You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@groovy.apache.org by su...@apache.org on 2020/02/01 00:02:49 UTC
[groovy] 03/08: GROOVY-9380: VMPlugin refactor: Coalesce Java5
through Java7 into Java8
This is an automated email from the ASF dual-hosted git repository.
sunlan pushed a commit to branch GROOVY_3_0_X
in repository https://gitbox.apache.org/repos/asf/groovy.git
commit 2661c787da9fcaa7451f3f78556ce0b32530a1a1
Author: Paul King <pa...@asert.com.au>
AuthorDate: Fri Jan 31 08:44:13 2020 +1000
GROOVY-9380: VMPlugin refactor: Coalesce Java5 through Java7 into Java8
(cherry picked from commit 697bf094a40b9afda80ae1da0b431c26ec5a3ca3)
---
.../ast/decompiled/FormalParameterParser.java | 6 +-
.../groovy/ast/decompiled/TypeSignatureParser.java | 4 +-
.../classgen/asm/indy/InvokeDynamicWriter.java | 20 +-
.../sc/IndyStaticTypesMultiTypeDispatcher.java | 2 +-
.../org/codehaus/groovy/vmplugin/v5/Java5.java | 1 +
.../vmplugin/v5/PluginDefaultGroovyMethods.java | 1 +
.../org/codehaus/groovy/vmplugin/v6/Java6.java | 1 +
.../groovy/vmplugin/v7/CacheableCallSite.java | 1 +
.../groovy/vmplugin/v7/IndyArrayAccess.java | 1 +
.../v7/IndyGuardsFiltersAndSignatures.java | 1 +
.../codehaus/groovy/vmplugin/v7/IndyInterface.java | 1 +
.../org/codehaus/groovy/vmplugin/v7/IndyMath.java | 1 +
.../org/codehaus/groovy/vmplugin/v7/Java7.java | 1 +
.../groovy/vmplugin/v7/MethodHandleWrapper.java | 1 +
.../org/codehaus/groovy/vmplugin/v7/Selector.java | 1 +
.../codehaus/groovy/vmplugin/v7/TypeHelper.java | 1 +
.../groovy/vmplugin/v7/TypeTransformers.java | 1 +
.../vmplugin/{v7 => v8}/CacheableCallSite.java | 4 +-
.../vmplugin/{v7 => v8}/IndyArrayAccess.java | 2 +-
.../{v7 => v8}/IndyGuardsFiltersAndSignatures.java | 4 +-
.../groovy/vmplugin/{v7 => v8}/IndyInterface.java | 2 +-
.../groovy/vmplugin/{v7 => v8}/IndyMath.java | 14 +-
.../org/codehaus/groovy/vmplugin/v8/Java8.java | 612 ++++++++++++++++++++-
.../vmplugin/{v7 => v8}/MethodHandleWrapper.java | 2 +-
.../vmplugin/v8/PluginDefaultGroovyMethods.java | 114 +++-
.../groovy/vmplugin/{v7 => v8}/Selector.java | 64 +--
.../groovy/vmplugin/{v7 => v8}/TypeHelper.java | 2 +-
.../vmplugin/{v7 => v8}/TypeTransformers.java | 3 +-
.../org/codehaus/groovy/vmplugin/v9/Java9.java | 3 +-
src/test/groovy/lang/MetaClassRegistryTest.groovy | 2 +-
src/test/indy/IndyUsageTest.groovy | 2 +-
31 files changed, 793 insertions(+), 82 deletions(-)
diff --git a/src/main/java/org/codehaus/groovy/ast/decompiled/FormalParameterParser.java b/src/main/java/org/codehaus/groovy/ast/decompiled/FormalParameterParser.java
index 2c3ca9a..a5275b7 100644
--- a/src/main/java/org/codehaus/groovy/ast/decompiled/FormalParameterParser.java
+++ b/src/main/java/org/codehaus/groovy/ast/decompiled/FormalParameterParser.java
@@ -21,7 +21,7 @@ package org.codehaus.groovy.ast.decompiled;
import org.codehaus.groovy.ast.ClassNode;
import org.codehaus.groovy.ast.GenericsType;
import org.codehaus.groovy.control.CompilerConfiguration;
-import org.codehaus.groovy.vmplugin.v5.Java5;
+import org.codehaus.groovy.vmplugin.v8.Java8;
import org.objectweb.asm.signature.SignatureVisitor;
import java.util.ArrayList;
@@ -46,9 +46,9 @@ abstract class FormalParameterParser extends SignatureVisitor {
protected void flushTypeParameter() {
if (currentTypeParameter != null) {
- ClassNode ref = Java5.configureTypeVariableReference(currentTypeParameter);
+ ClassNode ref = Java8.configureTypeVariableReference(currentTypeParameter);
ClassNode[] boundNodes = parameterBounds.toArray(ClassNode.EMPTY_ARRAY);
- typeParameters.add(Java5.configureTypeVariableDefinition(ref, boundNodes));
+ typeParameters.add(Java8.configureTypeVariableDefinition(ref, boundNodes));
currentTypeParameter = null;
parameterBounds.clear();
diff --git a/src/main/java/org/codehaus/groovy/ast/decompiled/TypeSignatureParser.java b/src/main/java/org/codehaus/groovy/ast/decompiled/TypeSignatureParser.java
index 7d7537a..67986ef 100644
--- a/src/main/java/org/codehaus/groovy/ast/decompiled/TypeSignatureParser.java
+++ b/src/main/java/org/codehaus/groovy/ast/decompiled/TypeSignatureParser.java
@@ -22,7 +22,7 @@ import org.codehaus.groovy.ast.ClassHelper;
import org.codehaus.groovy.ast.ClassNode;
import org.codehaus.groovy.ast.GenericsType;
import org.codehaus.groovy.control.CompilerConfiguration;
-import org.codehaus.groovy.vmplugin.v5.Java5;
+import org.codehaus.groovy.vmplugin.v8.Java8;
import org.objectweb.asm.Type;
import org.objectweb.asm.signature.SignatureVisitor;
@@ -44,7 +44,7 @@ abstract class TypeSignatureParser extends SignatureVisitor {
@Override
public void visitTypeVariable(String name) {
- finished(Java5.configureTypeVariableReference(name));
+ finished(Java8.configureTypeVariableReference(name));
}
@Override
diff --git a/src/main/java/org/codehaus/groovy/classgen/asm/indy/InvokeDynamicWriter.java b/src/main/java/org/codehaus/groovy/classgen/asm/indy/InvokeDynamicWriter.java
index 64c67d7..b5483cf 100644
--- a/src/main/java/org/codehaus/groovy/classgen/asm/indy/InvokeDynamicWriter.java
+++ b/src/main/java/org/codehaus/groovy/classgen/asm/indy/InvokeDynamicWriter.java
@@ -36,7 +36,7 @@ import org.codehaus.groovy.classgen.asm.MethodCallerMultiAdapter;
import org.codehaus.groovy.classgen.asm.OperandStack;
import org.codehaus.groovy.classgen.asm.WriterController;
import org.codehaus.groovy.runtime.wrappers.Wrapper;
-import org.codehaus.groovy.vmplugin.v7.IndyInterface;
+import org.codehaus.groovy.vmplugin.v8.IndyInterface;
import org.objectweb.asm.Handle;
import java.lang.invoke.CallSite;
@@ -44,15 +44,15 @@ import java.lang.invoke.MethodHandles.Lookup;
import java.lang.invoke.MethodType;
import static org.codehaus.groovy.classgen.asm.BytecodeHelper.getTypeDescription;
-import static org.codehaus.groovy.vmplugin.v7.IndyInterface.CallType.CAST;
-import static org.codehaus.groovy.vmplugin.v7.IndyInterface.CallType.GET;
-import static org.codehaus.groovy.vmplugin.v7.IndyInterface.CallType.INIT;
-import static org.codehaus.groovy.vmplugin.v7.IndyInterface.CallType.METHOD;
-import static org.codehaus.groovy.vmplugin.v7.IndyInterface.GROOVY_OBJECT;
-import static org.codehaus.groovy.vmplugin.v7.IndyInterface.IMPLICIT_THIS;
-import static org.codehaus.groovy.vmplugin.v7.IndyInterface.SAFE_NAVIGATION;
-import static org.codehaus.groovy.vmplugin.v7.IndyInterface.SPREAD_CALL;
-import static org.codehaus.groovy.vmplugin.v7.IndyInterface.THIS_CALL;
+import static org.codehaus.groovy.vmplugin.v8.IndyInterface.CallType.CAST;
+import static org.codehaus.groovy.vmplugin.v8.IndyInterface.CallType.GET;
+import static org.codehaus.groovy.vmplugin.v8.IndyInterface.CallType.INIT;
+import static org.codehaus.groovy.vmplugin.v8.IndyInterface.CallType.METHOD;
+import static org.codehaus.groovy.vmplugin.v8.IndyInterface.GROOVY_OBJECT;
+import static org.codehaus.groovy.vmplugin.v8.IndyInterface.IMPLICIT_THIS;
+import static org.codehaus.groovy.vmplugin.v8.IndyInterface.SAFE_NAVIGATION;
+import static org.codehaus.groovy.vmplugin.v8.IndyInterface.SPREAD_CALL;
+import static org.codehaus.groovy.vmplugin.v8.IndyInterface.THIS_CALL;
import static org.objectweb.asm.Opcodes.H_INVOKESTATIC;
/**
diff --git a/src/main/java/org/codehaus/groovy/classgen/asm/indy/sc/IndyStaticTypesMultiTypeDispatcher.java b/src/main/java/org/codehaus/groovy/classgen/asm/indy/sc/IndyStaticTypesMultiTypeDispatcher.java
index 4fa6e36..cd213ca 100644
--- a/src/main/java/org/codehaus/groovy/classgen/asm/indy/sc/IndyStaticTypesMultiTypeDispatcher.java
+++ b/src/main/java/org/codehaus/groovy/classgen/asm/indy/sc/IndyStaticTypesMultiTypeDispatcher.java
@@ -22,7 +22,7 @@ import org.codehaus.groovy.classgen.asm.BinaryExpressionWriter;
import org.codehaus.groovy.classgen.asm.MethodCaller;
import org.codehaus.groovy.classgen.asm.WriterController;
import org.codehaus.groovy.classgen.asm.sc.StaticTypesBinaryExpressionMultiTypeDispatcher;
-import org.codehaus.groovy.vmplugin.v7.IndyInterface;
+import org.codehaus.groovy.vmplugin.v8.IndyInterface;
import org.objectweb.asm.Handle;
import org.objectweb.asm.MethodVisitor;
diff --git a/src/main/java/org/codehaus/groovy/vmplugin/v5/Java5.java b/src/main/java/org/codehaus/groovy/vmplugin/v5/Java5.java
index f3e9aab..327b892 100644
--- a/src/main/java/org/codehaus/groovy/vmplugin/v5/Java5.java
+++ b/src/main/java/org/codehaus/groovy/vmplugin/v5/Java5.java
@@ -65,6 +65,7 @@ import java.util.List;
/**
* java 5 based functions
*/
+@Deprecated
public class Java5 implements VMPlugin {
private static final Class[] EMPTY_CLASS_ARRAY = new Class[0];
private static final Class[] PLUGIN_DGM = {PluginDefaultGroovyMethods.class};
diff --git a/src/main/java/org/codehaus/groovy/vmplugin/v5/PluginDefaultGroovyMethods.java b/src/main/java/org/codehaus/groovy/vmplugin/v5/PluginDefaultGroovyMethods.java
index 04b8041..95f95f3 100644
--- a/src/main/java/org/codehaus/groovy/vmplugin/v5/PluginDefaultGroovyMethods.java
+++ b/src/main/java/org/codehaus/groovy/vmplugin/v5/PluginDefaultGroovyMethods.java
@@ -33,6 +33,7 @@ import java.util.Arrays;
* JDK classes inside the Groovy environment. Static methods are used with the
* first parameter the destination class.
*/
+@Deprecated
public class PluginDefaultGroovyMethods extends DefaultGroovyMethodsSupport {
/**
diff --git a/src/main/java/org/codehaus/groovy/vmplugin/v6/Java6.java b/src/main/java/org/codehaus/groovy/vmplugin/v6/Java6.java
index ee421a0..5322444 100644
--- a/src/main/java/org/codehaus/groovy/vmplugin/v6/Java6.java
+++ b/src/main/java/org/codehaus/groovy/vmplugin/v6/Java6.java
@@ -23,6 +23,7 @@ import org.codehaus.groovy.vmplugin.v5.Java5;
/**
* Java 6 based functions. M12n moved these to modules.
*/
+@Deprecated
public class Java6 extends Java5 {
@Override
diff --git a/src/main/java/org/codehaus/groovy/vmplugin/v7/CacheableCallSite.java b/src/main/java/org/codehaus/groovy/vmplugin/v7/CacheableCallSite.java
index af96a07..9f85413 100644
--- a/src/main/java/org/codehaus/groovy/vmplugin/v7/CacheableCallSite.java
+++ b/src/main/java/org/codehaus/groovy/vmplugin/v7/CacheableCallSite.java
@@ -34,6 +34,7 @@ import java.util.concurrent.atomic.AtomicLong;
*
* @since 3.0.0
*/
+@Deprecated
public class CacheableCallSite extends MutableCallSite {
private static final int CACHE_SIZE = SystemUtil.getIntegerSafe("groovy.indy.callsite.cache.size", 16);
private final MemoizeCache<String, MethodHandleWrapper> cache = new LRUCache<>(CACHE_SIZE);
diff --git a/src/main/java/org/codehaus/groovy/vmplugin/v7/IndyArrayAccess.java b/src/main/java/org/codehaus/groovy/vmplugin/v7/IndyArrayAccess.java
index f79bc28..3e4ca5f 100644
--- a/src/main/java/org/codehaus/groovy/vmplugin/v7/IndyArrayAccess.java
+++ b/src/main/java/org/codehaus/groovy/vmplugin/v7/IndyArrayAccess.java
@@ -31,6 +31,7 @@ import java.util.HashMap;
*
* @since 2.5.0
*/
+@Deprecated
public class IndyArrayAccess {
private static final MethodHandle notNegative, normalizeIndex;
diff --git a/src/main/java/org/codehaus/groovy/vmplugin/v7/IndyGuardsFiltersAndSignatures.java b/src/main/java/org/codehaus/groovy/vmplugin/v7/IndyGuardsFiltersAndSignatures.java
index 1fd4942..08ef8f9 100644
--- a/src/main/java/org/codehaus/groovy/vmplugin/v7/IndyGuardsFiltersAndSignatures.java
+++ b/src/main/java/org/codehaus/groovy/vmplugin/v7/IndyGuardsFiltersAndSignatures.java
@@ -51,6 +51,7 @@ import static org.codehaus.groovy.vmplugin.v7.IndyInterface.LOOKUP;
* This class contains guards, runtime filters and
* MethodType signatures used by indy.
*/
+@Deprecated
public class IndyGuardsFiltersAndSignatures {
private static final MethodType
diff --git a/src/main/java/org/codehaus/groovy/vmplugin/v7/IndyInterface.java b/src/main/java/org/codehaus/groovy/vmplugin/v7/IndyInterface.java
index 0eb6fa4..fff40836 100644
--- a/src/main/java/org/codehaus/groovy/vmplugin/v7/IndyInterface.java
+++ b/src/main/java/org/codehaus/groovy/vmplugin/v7/IndyInterface.java
@@ -46,6 +46,7 @@ import java.util.stream.Stream;
* interfacing methods with bytecode for invokedynamic as well as some helper
* methods and classes.
*/
+@Deprecated
public class IndyInterface {
private static final long INDY_OPTIMIZE_THRESHOLD = SystemUtil.getLongSafe("groovy.indy.optimize.threshold", 100_000L);
diff --git a/src/main/java/org/codehaus/groovy/vmplugin/v7/IndyMath.java b/src/main/java/org/codehaus/groovy/vmplugin/v7/IndyMath.java
index 982f00f..f758ae5 100644
--- a/src/main/java/org/codehaus/groovy/vmplugin/v7/IndyMath.java
+++ b/src/main/java/org/codehaus/groovy/vmplugin/v7/IndyMath.java
@@ -41,6 +41,7 @@ import static org.codehaus.groovy.vmplugin.v7.TypeHelper.replaceWithMoreSpecific
* WARNING: This class is for internal use only. Do not use it outside of the
* org.codehaus.groovy.vmplugin.v7 package of groovy-core.
*/
+@Deprecated
public class IndyMath {
private static final MethodType
diff --git a/src/main/java/org/codehaus/groovy/vmplugin/v7/Java7.java b/src/main/java/org/codehaus/groovy/vmplugin/v7/Java7.java
index ac829db..6f0eca9 100644
--- a/src/main/java/org/codehaus/groovy/vmplugin/v7/Java7.java
+++ b/src/main/java/org/codehaus/groovy/vmplugin/v7/Java7.java
@@ -34,6 +34,7 @@ import java.security.PrivilegedAction;
* <p>
* For crude customization, you can add your own methods to your own version and place it on the classpath ahead of this one.
*/
+@Deprecated
public class Java7 extends Java6 {
private static class LookupHolder {
private static final Constructor<MethodHandles.Lookup> LOOKUP_Constructor;
diff --git a/src/main/java/org/codehaus/groovy/vmplugin/v7/MethodHandleWrapper.java b/src/main/java/org/codehaus/groovy/vmplugin/v7/MethodHandleWrapper.java
index 0319e93..c2e4d43 100644
--- a/src/main/java/org/codehaus/groovy/vmplugin/v7/MethodHandleWrapper.java
+++ b/src/main/java/org/codehaus/groovy/vmplugin/v7/MethodHandleWrapper.java
@@ -26,6 +26,7 @@ import java.util.concurrent.atomic.AtomicLong;
*
* @since 3.0.0
*/
+@Deprecated
class MethodHandleWrapper {
private final MethodHandle cachedMethodHandle;
private final MethodHandle targetMethodHandle;
diff --git a/src/main/java/org/codehaus/groovy/vmplugin/v7/Selector.java b/src/main/java/org/codehaus/groovy/vmplugin/v7/Selector.java
index be01361..7633a24 100644
--- a/src/main/java/org/codehaus/groovy/vmplugin/v7/Selector.java
+++ b/src/main/java/org/codehaus/groovy/vmplugin/v7/Selector.java
@@ -97,6 +97,7 @@ import static org.codehaus.groovy.vmplugin.v7.IndyInterface.LOG_ENABLED;
import static org.codehaus.groovy.vmplugin.v7.IndyInterface.LOOKUP;
import static org.codehaus.groovy.vmplugin.v7.IndyInterface.switchPoint;
+@Deprecated
public abstract class Selector {
public Object[] args, originalArguments;
public MetaMethod method;
diff --git a/src/main/java/org/codehaus/groovy/vmplugin/v7/TypeHelper.java b/src/main/java/org/codehaus/groovy/vmplugin/v7/TypeHelper.java
index 8591fae..266e72b 100644
--- a/src/main/java/org/codehaus/groovy/vmplugin/v7/TypeHelper.java
+++ b/src/main/java/org/codehaus/groovy/vmplugin/v7/TypeHelper.java
@@ -28,6 +28,7 @@ import java.math.BigInteger;
* WARNING: This class is for internal use only. do not use it outside of its
* package and not outside groovy-core.
*/
+@Deprecated
public class TypeHelper {
/**
* Get wrapper class for a given class.
diff --git a/src/main/java/org/codehaus/groovy/vmplugin/v7/TypeTransformers.java b/src/main/java/org/codehaus/groovy/vmplugin/v7/TypeTransformers.java
index d4c92ad..823902c 100644
--- a/src/main/java/org/codehaus/groovy/vmplugin/v7/TypeTransformers.java
+++ b/src/main/java/org/codehaus/groovy/vmplugin/v7/TypeTransformers.java
@@ -43,6 +43,7 @@ import java.util.Map;
/**
* This class contains several transformers for used during method invocation.
*/
+@Deprecated
public class TypeTransformers {
private static final MethodHandles.Lookup LOOKUP = MethodHandles.lookup();
private static final MethodHandle
diff --git a/src/main/java/org/codehaus/groovy/vmplugin/v7/CacheableCallSite.java b/src/main/java/org/codehaus/groovy/vmplugin/v8/CacheableCallSite.java
similarity index 95%
copy from src/main/java/org/codehaus/groovy/vmplugin/v7/CacheableCallSite.java
copy to src/main/java/org/codehaus/groovy/vmplugin/v8/CacheableCallSite.java
index af96a07..a6e4c4c 100644
--- a/src/main/java/org/codehaus/groovy/vmplugin/v7/CacheableCallSite.java
+++ b/src/main/java/org/codehaus/groovy/vmplugin/v8/CacheableCallSite.java
@@ -16,17 +16,15 @@
* specific language governing permissions and limitations
* under the License.
*/
-package org.codehaus.groovy.vmplugin.v7;
+package org.codehaus.groovy.vmplugin.v8;
import org.apache.groovy.util.SystemUtil;
-import org.codehaus.groovy.GroovyBugError;
import org.codehaus.groovy.runtime.memoize.LRUCache;
import org.codehaus.groovy.runtime.memoize.MemoizeCache;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodType;
import java.lang.invoke.MutableCallSite;
-import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
/**
diff --git a/src/main/java/org/codehaus/groovy/vmplugin/v7/IndyArrayAccess.java b/src/main/java/org/codehaus/groovy/vmplugin/v8/IndyArrayAccess.java
similarity index 99%
copy from src/main/java/org/codehaus/groovy/vmplugin/v7/IndyArrayAccess.java
copy to src/main/java/org/codehaus/groovy/vmplugin/v8/IndyArrayAccess.java
index f79bc28..126b89c 100644
--- a/src/main/java/org/codehaus/groovy/vmplugin/v7/IndyArrayAccess.java
+++ b/src/main/java/org/codehaus/groovy/vmplugin/v8/IndyArrayAccess.java
@@ -16,7 +16,7 @@
* specific language governing permissions and limitations
* under the License.
*/
-package org.codehaus.groovy.vmplugin.v7;
+package org.codehaus.groovy.vmplugin.v8;
import org.codehaus.groovy.GroovyBugError;
diff --git a/src/main/java/org/codehaus/groovy/vmplugin/v7/IndyGuardsFiltersAndSignatures.java b/src/main/java/org/codehaus/groovy/vmplugin/v8/IndyGuardsFiltersAndSignatures.java
similarity index 98%
copy from src/main/java/org/codehaus/groovy/vmplugin/v7/IndyGuardsFiltersAndSignatures.java
copy to src/main/java/org/codehaus/groovy/vmplugin/v8/IndyGuardsFiltersAndSignatures.java
index 1fd4942..3daf152 100644
--- a/src/main/java/org/codehaus/groovy/vmplugin/v7/IndyGuardsFiltersAndSignatures.java
+++ b/src/main/java/org/codehaus/groovy/vmplugin/v8/IndyGuardsFiltersAndSignatures.java
@@ -16,7 +16,7 @@
* specific language governing permissions and limitations
* under the License.
*/
-package org.codehaus.groovy.vmplugin.v7;
+package org.codehaus.groovy.vmplugin.v8;
import groovy.lang.Closure;
import groovy.lang.GroovyObject;
@@ -45,7 +45,7 @@ import java.util.Collection;
import java.util.HashSet;
import java.util.Map;
-import static org.codehaus.groovy.vmplugin.v7.IndyInterface.LOOKUP;
+import static org.codehaus.groovy.vmplugin.v8.IndyInterface.LOOKUP;
/**
* This class contains guards, runtime filters and
diff --git a/src/main/java/org/codehaus/groovy/vmplugin/v7/IndyInterface.java b/src/main/java/org/codehaus/groovy/vmplugin/v8/IndyInterface.java
similarity index 99%
copy from src/main/java/org/codehaus/groovy/vmplugin/v7/IndyInterface.java
copy to src/main/java/org/codehaus/groovy/vmplugin/v8/IndyInterface.java
index 0eb6fa4..fb9303e 100644
--- a/src/main/java/org/codehaus/groovy/vmplugin/v7/IndyInterface.java
+++ b/src/main/java/org/codehaus/groovy/vmplugin/v8/IndyInterface.java
@@ -16,7 +16,7 @@
* specific language governing permissions and limitations
* under the License.
*/
-package org.codehaus.groovy.vmplugin.v7;
+package org.codehaus.groovy.vmplugin.v8;
import groovy.lang.GroovySystem;
import org.apache.groovy.util.SystemUtil;
diff --git a/src/main/java/org/codehaus/groovy/vmplugin/v7/IndyMath.java b/src/main/java/org/codehaus/groovy/vmplugin/v8/IndyMath.java
similarity index 95%
copy from src/main/java/org/codehaus/groovy/vmplugin/v7/IndyMath.java
copy to src/main/java/org/codehaus/groovy/vmplugin/v8/IndyMath.java
index 982f00f..56b2a7b 100644
--- a/src/main/java/org/codehaus/groovy/vmplugin/v7/IndyMath.java
+++ b/src/main/java/org/codehaus/groovy/vmplugin/v8/IndyMath.java
@@ -16,7 +16,7 @@
* specific language governing permissions and limitations
* under the License.
*/
-package org.codehaus.groovy.vmplugin.v7;
+package org.codehaus.groovy.vmplugin.v8;
import groovy.lang.MetaMethod;
import org.codehaus.groovy.GroovyBugError;
@@ -27,12 +27,12 @@ import java.math.BigDecimal;
import java.util.HashMap;
import java.util.Map;
-import static org.codehaus.groovy.vmplugin.v7.IndyInterface.LOOKUP;
-import static org.codehaus.groovy.vmplugin.v7.TypeHelper.isBigDecCategory;
-import static org.codehaus.groovy.vmplugin.v7.TypeHelper.isDoubleCategory;
-import static org.codehaus.groovy.vmplugin.v7.TypeHelper.isIntCategory;
-import static org.codehaus.groovy.vmplugin.v7.TypeHelper.isLongCategory;
-import static org.codehaus.groovy.vmplugin.v7.TypeHelper.replaceWithMoreSpecificType;
+import static org.codehaus.groovy.vmplugin.v8.IndyInterface.LOOKUP;
+import static org.codehaus.groovy.vmplugin.v8.TypeHelper.isBigDecCategory;
+import static org.codehaus.groovy.vmplugin.v8.TypeHelper.isDoubleCategory;
+import static org.codehaus.groovy.vmplugin.v8.TypeHelper.isIntCategory;
+import static org.codehaus.groovy.vmplugin.v8.TypeHelper.isLongCategory;
+import static org.codehaus.groovy.vmplugin.v8.TypeHelper.replaceWithMoreSpecificType;
/**
* This class contains math operations used by indy instead of the normal
diff --git a/src/main/java/org/codehaus/groovy/vmplugin/v8/Java8.java b/src/main/java/org/codehaus/groovy/vmplugin/v8/Java8.java
index f4bd201..5ef4b70 100644
--- a/src/main/java/org/codehaus/groovy/vmplugin/v8/Java8.java
+++ b/src/main/java/org/codehaus/groovy/vmplugin/v8/Java8.java
@@ -18,16 +18,53 @@
*/
package org.codehaus.groovy.vmplugin.v8;
+import groovy.lang.MetaClass;
+import groovy.lang.MetaMethod;
+import org.codehaus.groovy.GroovyBugError;
+import org.codehaus.groovy.ast.AnnotatedNode;
import org.codehaus.groovy.ast.AnnotationNode;
+import org.codehaus.groovy.ast.ClassHelper;
+import org.codehaus.groovy.ast.ClassNode;
import org.codehaus.groovy.ast.CompileUnit;
+import org.codehaus.groovy.ast.ConstructorNode;
+import org.codehaus.groovy.ast.FieldNode;
+import org.codehaus.groovy.ast.GenericsType;
+import org.codehaus.groovy.ast.MethodNode;
+import org.codehaus.groovy.ast.PackageNode;
import org.codehaus.groovy.ast.Parameter;
-import org.codehaus.groovy.vmplugin.v7.Java7;
+import org.codehaus.groovy.ast.expr.ClassExpression;
+import org.codehaus.groovy.ast.expr.ConstantExpression;
+import org.codehaus.groovy.ast.expr.Expression;
+import org.codehaus.groovy.ast.expr.ListExpression;
+import org.codehaus.groovy.ast.expr.PropertyExpression;
+import org.codehaus.groovy.ast.stmt.ReturnStatement;
+import org.codehaus.groovy.reflection.ReflectionUtils;
+import org.codehaus.groovy.vmplugin.VMPlugin;
+import org.codehaus.groovy.vmplugin.VMPluginFactory;
+import java.lang.annotation.Annotation;
import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.reflect.AccessibleObject;
+import java.lang.reflect.Array;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.GenericArrayType;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.MalformedParameterizedTypeException;
import java.lang.reflect.Method;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.ReflectPermission;
import java.lang.reflect.Type;
-import java.util.ArrayList;
-import java.util.Collections;
+import java.lang.reflect.TypeVariable;
+import java.lang.reflect.WildcardType;
+import java.security.AccessController;
+import java.security.Permission;
+import java.security.PrivilegedAction;
import java.util.List;
/**
@@ -35,16 +72,76 @@ import java.util.List;
*
* @since 2.5.0
*/
-public class Java8 extends Java7 {
+public class Java8 implements VMPlugin {
- private final Class<?>[] PLUGIN_DGM;
+ private static final Class<?>[] PLUGIN_DGM = {PluginDefaultGroovyMethods.class};
+ private static final Class<?>[] EMPTY_CLASS_ARRAY = new Class[0];
+ private static final Method[] EMPTY_METHOD_ARRAY = new Method[0];
+ private static final Annotation[] EMPTY_ANNOTATION_ARRAY = new Annotation[0];
+ private static final Permission ACCESS_PERMISSION = new ReflectPermission("suppressAccessChecks");
public Java8() {
super();
- List<Class<?>> dgmClasses = new ArrayList<>();
- Collections.addAll(dgmClasses, (Class<?>[]) super.getPluginDefaultGroovyMethods());
- dgmClasses.add(PluginDefaultGroovyMethods.class);
- PLUGIN_DGM = dgmClasses.toArray(new Class<?>[0]);
+ }
+
+ public static GenericsType configureTypeVariableDefinition(ClassNode base, ClassNode[] cBounds) {
+ ClassNode redirect = base.redirect();
+ base.setRedirect(null);
+ GenericsType gt;
+ if (cBounds == null || cBounds.length == 0) {
+ gt = new GenericsType(base);
+ } else {
+ gt = new GenericsType(base, cBounds, null);
+ gt.setName(base.getName());
+ gt.setPlaceholder(true);
+ }
+ base.setRedirect(redirect);
+ return gt;
+ }
+
+ private static ClassNode configureClass(Class<?> c) {
+ if (c.isPrimitive()) {
+ return ClassHelper.make(c);
+ } else {
+ return ClassHelper.makeWithoutCaching(c, false);
+ }
+ }
+
+ public static ClassNode configureTypeVariableReference(String name) {
+ ClassNode cn = ClassHelper.makeWithoutCaching(name);
+ cn.setGenericsPlaceHolder(true);
+ ClassNode cn2 = ClassHelper.makeWithoutCaching(name);
+ cn2.setGenericsPlaceHolder(true);
+ GenericsType[] gts = new GenericsType[]{new GenericsType(cn2)};
+ cn.setGenericsTypes(gts);
+ cn.setRedirect(ClassHelper.OBJECT_TYPE);
+ return cn;
+ }
+
+ private static void setRetentionPolicy(RetentionPolicy value, AnnotationNode node) {
+ switch (value) {
+ case RUNTIME:
+ node.setRuntimeRetention(true);
+ break;
+ case SOURCE:
+ node.setSourceRetention(true);
+ break;
+ case CLASS:
+ node.setClassRetention(true);
+ break;
+ default:
+ throw new GroovyBugError("unsupported Retention " + value);
+ }
+ }
+
+ private static void setMethodDefaultValue(MethodNode mn, Method m) {
+ ConstantExpression cExp = new ConstantExpression(m.getDefaultValue());
+ mn.setCode(new ReturnStatement(cExp));
+ mn.setAnnotationDefault(true);
+ }
+
+ private static Constructor<MethodHandles.Lookup> getLookupConstructor() {
+ return LookupHolder.LOOKUP_Constructor;
}
@Override
@@ -57,18 +154,36 @@ public class Java8 extends Java7 {
return 8;
}
- @Override
protected int getElementCode(ElementType value) {
switch (value) {
+ case TYPE:
+ return AnnotationNode.TYPE_TARGET;
+ case CONSTRUCTOR:
+ return AnnotationNode.CONSTRUCTOR_TARGET;
+ case METHOD:
+ return AnnotationNode.METHOD_TARGET;
+ case FIELD:
+ return AnnotationNode.FIELD_TARGET;
+ case PARAMETER:
+ return AnnotationNode.PARAMETER_TARGET;
+ case LOCAL_VARIABLE:
+ return AnnotationNode.LOCAL_VARIABLE_TARGET;
+ case ANNOTATION_TYPE:
+ return AnnotationNode.ANNOTATION_TARGET;
+ case PACKAGE:
+ return AnnotationNode.PACKAGE_TARGET;
case TYPE_PARAMETER:
return AnnotationNode.TYPE_PARAMETER_TARGET;
case TYPE_USE:
return AnnotationNode.TYPE_USE_TARGET;
}
- return super.getElementCode(value);
+ if ("MODULE".equals(value.name())) {
+ return AnnotationNode.TYPE_TARGET;
+ } else {
+ throw new GroovyBugError("unsupported Target " + value);
+ }
}
- @Override
protected Parameter[] processParameters(CompileUnit compileUnit, Method m) {
java.lang.reflect.Parameter[] parameters = m.getParameters();
Type[] types = m.getGenericParameterTypes();
@@ -83,4 +198,477 @@ public class Java8 extends Java7 {
}
return params;
}
+
+ public void setAdditionalClassInformation(ClassNode cn) {
+ setGenericsTypes(cn);
+ }
+
+ private void setGenericsTypes(ClassNode cn) {
+ TypeVariable[] tvs = cn.getTypeClass().getTypeParameters();
+ GenericsType[] gts = configureTypeVariable(tvs);
+ cn.setGenericsTypes(gts);
+ }
+
+ private GenericsType[] configureTypeVariable(TypeVariable[] tvs) {
+ if (tvs.length == 0) return null;
+ GenericsType[] gts = new GenericsType[tvs.length];
+ for (int i = 0; i < tvs.length; i++) {
+ gts[i] = configureTypeVariableDefinition(tvs[i]);
+ }
+ return gts;
+ }
+
+ private GenericsType configureTypeVariableDefinition(TypeVariable tv) {
+ return configureTypeVariableDefinition(configureTypeVariableReference(tv.getName()), configureTypes(tv.getBounds()));
+ }
+
+ private ClassNode[] configureTypes(Type[] types) {
+ if (types.length == 0) return null;
+ ClassNode[] nodes = new ClassNode[types.length];
+ for (int i = 0; i < types.length; i++) {
+ nodes[i] = configureType(types[i]);
+ }
+ return nodes;
+ }
+
+ private ClassNode configureType(Type type) {
+ if (type instanceof WildcardType) {
+ return configureWildcardType((WildcardType) type);
+ } else if (type instanceof ParameterizedType) {
+ return configureParameterizedType((ParameterizedType) type);
+ } else if (type instanceof GenericArrayType) {
+ return configureGenericArray((GenericArrayType) type);
+ } else if (type instanceof TypeVariable) {
+ return configureTypeVariableReference(((TypeVariable) type).getName());
+ } else if (type instanceof Class) {
+ return configureClass((Class<?>) type);
+ } else if (type==null) {
+ throw new GroovyBugError("Type is null. Most probably you let a transform reuse existing ClassNodes with generics information, that is now used in a wrong context.");
+ } else {
+ throw new GroovyBugError("unknown type: " + type + " := " + type.getClass());
+ }
+ }
+
+ private ClassNode configureGenericArray(GenericArrayType genericArrayType) {
+ Type component = genericArrayType.getGenericComponentType();
+ ClassNode node = configureType(component);
+ return node.makeArray();
+ }
+
+ private ClassNode configureWildcardType(final WildcardType wildcardType) {
+ ClassNode base = ClassHelper.makeWithoutCaching("?");
+ base.setRedirect(ClassHelper.OBJECT_TYPE);
+
+ ClassNode[] lowers = configureTypes(wildcardType.getLowerBounds());
+ ClassNode[] uppers = configureTypes(wildcardType.getUpperBounds());
+ // beware of [Object] upper bounds; often it's <?> or <? super T>
+ if (lowers != null || wildcardType.getTypeName().equals("?")) {
+ uppers = null;
+ }
+
+ GenericsType gt = new GenericsType(base, uppers, lowers != null ? lowers[0] : null);
+ gt.setWildcard(true);
+
+ ClassNode wt = ClassHelper.makeWithoutCaching(Object.class, false);
+ wt.setGenericsTypes(new GenericsType[]{gt});
+ return wt;
+ }
+
+ private ClassNode configureParameterizedType(ParameterizedType parameterizedType) {
+ ClassNode base = configureType(parameterizedType.getRawType());
+ GenericsType[] gts = configureTypeArguments(parameterizedType.getActualTypeArguments());
+ base.setGenericsTypes(gts);
+ return base;
+ }
+
+ private GenericsType[] configureTypeArguments(Type[] ta) {
+ if (ta.length == 0) return null;
+ GenericsType[] gts = new GenericsType[ta.length];
+ for (int i = 0; i < ta.length; i++) {
+ ClassNode t = configureType(ta[i]);
+ if (ta[i] instanceof WildcardType) {
+ GenericsType[] gen = t.getGenericsTypes();
+ gts[i] = gen[0];
+ } else {
+ gts[i] = new GenericsType(t);
+ }
+ }
+ return gts;
+ }
+
+ public Class<?>[] getPluginStaticGroovyMethods() {
+ return EMPTY_CLASS_ARRAY;
+ }
+
+ private void setAnnotationMetaData(Annotation[] annotations, AnnotatedNode an) {
+ for (Annotation annotation : annotations) {
+ AnnotationNode node = new AnnotationNode(ClassHelper.make(annotation.annotationType()));
+ configureAnnotation(node, annotation);
+ an.addAnnotation(node);
+ }
+ }
+
+ @Deprecated
+ private void configureAnnotationFromDefinition(AnnotationNode definition, AnnotationNode root) {
+ VMPlugin plugin = VMPluginFactory.getPlugin();
+ plugin.configureAnnotationNodeFromDefinition(definition, root);
+ }
+
+ public void configureAnnotationNodeFromDefinition(AnnotationNode definition, AnnotationNode root) {
+ ClassNode type = definition.getClassNode();
+ if ("java.lang.annotation.Retention".equals(type.getName())) {
+ Expression exp = definition.getMember("value");
+ if (!(exp instanceof PropertyExpression)) return;
+ PropertyExpression pe = (PropertyExpression) exp;
+ String name = pe.getPropertyAsString();
+ RetentionPolicy policy = RetentionPolicy.valueOf(name);
+ setRetentionPolicy(policy, root);
+ } else if ("java.lang.annotation.Target".equals(type.getName())) {
+ Expression exp = definition.getMember("value");
+ if (!(exp instanceof ListExpression)) return;
+ ListExpression le = (ListExpression) exp;
+ int bitmap = 0;
+ for (Expression e : le.getExpressions()) {
+ if (!(e instanceof PropertyExpression)) return;
+ PropertyExpression element = (PropertyExpression) e;
+ String name = element.getPropertyAsString();
+ ElementType value = ElementType.valueOf(name);
+ bitmap |= getElementCode(value);
+ }
+ root.setAllowedTargets(bitmap);
+ }
+ }
+
+ public void configureAnnotation(AnnotationNode node) {
+ ClassNode type = node.getClassNode();
+ VMPlugin plugin = VMPluginFactory.getPlugin();
+ List<AnnotationNode> annotations = type.getAnnotations();
+ for (AnnotationNode an : annotations) {
+ plugin.configureAnnotationNodeFromDefinition(an, node);
+ }
+ plugin.configureAnnotationNodeFromDefinition(node, node);
+ }
+
+ private void configureAnnotation(AnnotationNode node, Annotation annotation) {
+ Class<?> type = annotation.annotationType();
+ if (type == Retention.class) {
+ Retention r = (Retention) annotation;
+ RetentionPolicy value = r.value();
+ setRetentionPolicy(value, node);
+ node.setMember("value", new PropertyExpression(
+ new ClassExpression(ClassHelper.makeWithoutCaching(RetentionPolicy.class, false)),
+ value.toString()));
+ } else if (type == Target.class) {
+ Target t = (Target) annotation;
+ ElementType[] elements = t.value();
+ ListExpression elementExprs = new ListExpression();
+ for (ElementType element : elements) {
+ elementExprs.addExpression(new PropertyExpression(
+ new ClassExpression(ClassHelper.ELEMENT_TYPE_TYPE), element.name()));
+ }
+ node.setMember("value", elementExprs);
+ } else {
+ Method[] declaredMethods;
+ try {
+ declaredMethods = type.getDeclaredMethods();
+ } catch (SecurityException se) {
+ declaredMethods = EMPTY_METHOD_ARRAY;
+ }
+ for (Method declaredMethod : declaredMethods) {
+ try {
+ Object value = declaredMethod.invoke(annotation);
+ Expression valueExpression = annotationValueToExpression(value);
+ if (valueExpression == null)
+ continue;
+ node.setMember(declaredMethod.getName(), valueExpression);
+ } catch (IllegalAccessException | InvocationTargetException ignore) {
+ }
+ }
+ }
+ }
+
+ private Expression annotationValueToExpression (Object value) {
+ if (value == null || value instanceof String || value instanceof Number || value instanceof Character || value instanceof Boolean)
+ return new ConstantExpression(value);
+
+ if (value instanceof Class)
+ return new ClassExpression(ClassHelper.makeWithoutCaching((Class<?>)value));
+
+ if (value.getClass().isArray()) {
+ ListExpression elementExprs = new ListExpression();
+ int len = Array.getLength(value);
+ for (int i = 0; i != len; ++i)
+ elementExprs.addExpression(annotationValueToExpression(Array.get(value, i)));
+ return elementExprs;
+ }
+
+ return null;
+ }
+
+ public void configureClassNode(CompileUnit compileUnit, ClassNode classNode) {
+ try {
+ Class<?> clazz = classNode.getTypeClass();
+ Field[] fields = clazz.getDeclaredFields();
+ for (Field f : fields) {
+ ClassNode ret = makeClassNode(compileUnit, f.getGenericType(), f.getType());
+ FieldNode fn = new FieldNode(f.getName(), f.getModifiers(), ret, classNode, null);
+ setAnnotationMetaData(f.getAnnotations(), fn);
+ classNode.addField(fn);
+ }
+ Method[] methods = clazz.getDeclaredMethods();
+ for (Method m : methods) {
+ ClassNode ret = makeClassNode(compileUnit, m.getGenericReturnType(), m.getReturnType());
+ Parameter[] params = processParameters(compileUnit, m);
+ ClassNode[] exceptions = makeClassNodes(compileUnit, m.getGenericExceptionTypes(), m.getExceptionTypes());
+ MethodNode mn = new MethodNode(m.getName(), m.getModifiers(), ret, params, exceptions, null);
+ mn.setSynthetic(m.isSynthetic());
+ setMethodDefaultValue(mn, m);
+ setAnnotationMetaData(m.getAnnotations(), mn);
+ mn.setGenericsTypes(configureTypeVariable(m.getTypeParameters()));
+ classNode.addMethod(mn);
+ }
+ Constructor[] constructors = clazz.getDeclaredConstructors();
+ for (Constructor ctor : constructors) {
+ Type[] types = ctor.getGenericParameterTypes();
+ Parameter[] params1 = Parameter.EMPTY_ARRAY;
+ if (types.length > 0) {
+ params1 = new Parameter[types.length];
+ for (int i = 0; i < params1.length; i++) {
+ params1[i] = makeParameter(compileUnit, types[i], ctor.getParameterTypes()[i], getConstructorParameterAnnotations(ctor)[i], "param" + i);
+ }
+ }
+ Parameter[] params = params1;
+ ClassNode[] exceptions = makeClassNodes(compileUnit, ctor.getGenericExceptionTypes(), ctor.getExceptionTypes());
+ ConstructorNode cn = classNode.addConstructor(ctor.getModifiers(), params, exceptions, null);
+ setAnnotationMetaData(ctor.getAnnotations(), cn);
+ }
+
+ Class<?> sc = clazz.getSuperclass();
+ if (sc != null) classNode.setUnresolvedSuperClass(makeClassNode(compileUnit, clazz.getGenericSuperclass(), sc));
+ makeInterfaceTypes(compileUnit, classNode, clazz);
+ setAnnotationMetaData(classNode.getTypeClass().getAnnotations(), classNode);
+
+ PackageNode packageNode = classNode.getPackage();
+ if (packageNode != null) {
+ setAnnotationMetaData(classNode.getTypeClass().getPackage().getAnnotations(), packageNode);
+ }
+ } catch (NoClassDefFoundError e) {
+ throw new NoClassDefFoundError("Unable to load class "+classNode.toString(false)+" due to missing dependency "+e.getMessage());
+ } catch (MalformedParameterizedTypeException e) {
+ throw new RuntimeException("Unable to configure class node for class "+classNode.toString(false)+" due to malformed parameterized types", e);
+ }
+ }
+
+ /**
+ * Synthetic parameters such as those added for inner class constructors may
+ * not be included in the parameter annotations array. This is the case when
+ * at least one parameter of an inner class constructor has an annotation with
+ * a RUNTIME retention (this occurs for JDK8 and below). This method will
+ * normalize the annotations array so that it contains the same number of
+ * elements as the array returned from {@link Constructor#getParameterTypes()}.
+ *
+ * If adjustment is required, the adjusted array will be prepended with a
+ * zero-length element. If no adjustment is required, the original array
+ * from {@link Constructor#getParameterAnnotations()} will be returned.
+ *
+ * @param constructor the Constructor for which to return parameter annotations
+ * @return array of arrays containing the annotations on the parameters of the given Constructor
+ */
+ private Annotation[][] getConstructorParameterAnnotations(Constructor<?> constructor) {
+ /*
+ * TODO: Remove after JDK9 is the minimum JDK supported
+ *
+ * JDK9+ correctly accounts for the synthetic parameter and when it becomes
+ * the minimum version this method should no longer be required.
+ */
+ int parameterCount = constructor.getParameterTypes().length;
+ Annotation[][] annotations = constructor.getParameterAnnotations();
+ int diff = parameterCount - annotations.length;
+ if (diff > 0) {
+ // May happen on JDK8 and below. We add elements to the front of the array to account for the synthetic params:
+ // - for an inner class we expect one param to account for the synthetic outer reference
+ // - for an enum we expect two params to account for the synthetic name and ordinal
+ if ((!constructor.getDeclaringClass().isEnum() && diff > 1) || diff > 2) {
+ throw new GroovyBugError(
+ "Constructor parameter annotations length [" + annotations.length + "] " +
+ "does not match the parameter length: " + constructor
+ );
+ }
+ Annotation[][] adjusted = new Annotation[parameterCount][];
+ for (int i = 0; i < diff; i++) {
+ adjusted[i] = EMPTY_ANNOTATION_ARRAY;
+ }
+ System.arraycopy(annotations, 0, adjusted, diff, annotations.length);
+ return adjusted;
+ }
+ return annotations;
+ }
+
+ private void makeInterfaceTypes(CompileUnit cu, ClassNode classNode, Class<?> clazz) {
+ Type[] interfaceTypes = clazz.getGenericInterfaces();
+ if (interfaceTypes.length == 0) {
+ classNode.setInterfaces(ClassNode.EMPTY_ARRAY);
+ } else {
+ ClassNode[] ret = new ClassNode[interfaceTypes.length];
+ for (int i = 0; i < interfaceTypes.length; i++) {
+ Type type = interfaceTypes[i];
+ while (!(type instanceof Class)) {
+ ParameterizedType pt = (ParameterizedType) type;
+ Type t2 = pt.getRawType();
+ if (t2==type) {
+ throw new GroovyBugError("Cannot transform generic signature of "+clazz+
+ " with generic interface "+interfaceTypes[i]+" to a class.");
+ }
+ type = t2;
+ }
+ ret[i] = makeClassNode(cu, interfaceTypes[i], (Class<?>) type);
+ }
+ classNode.setInterfaces(ret);
+ }
+ }
+
+ private ClassNode[] makeClassNodes(CompileUnit cu, Type[] types, Class<?>[] cls) {
+ ClassNode[] nodes = new ClassNode[types.length];
+ for (int i = 0; i < nodes.length; i++) {
+ nodes[i] = makeClassNode(cu, types[i], cls[i]);
+ }
+ return nodes;
+ }
+
+ private ClassNode makeClassNode(CompileUnit cu, Type t, Class<?> c) {
+ ClassNode back = null;
+ if (cu != null) back = cu.getClass(c.getName());
+ if (back == null) back = ClassHelper.make(c);
+ if (!(t instanceof Class)) {
+ ClassNode front = configureType(t);
+ front.setRedirect(back);
+ return front;
+ }
+ return back.getPlainNodeReference();
+ }
+
+ protected Parameter makeParameter(CompileUnit cu, Type type, Class<?> cl, Annotation[] annotations, String name) {
+ ClassNode cn = makeClassNode(cu, type, cl);
+ Parameter parameter = new Parameter(cn, name);
+ setAnnotationMetaData(annotations, parameter);
+ return parameter;
+ }
+
+ /**
+ * The following scenarios can not set accessible, i.e. the return value is false
+ * 1) SecurityException occurred
+ * 2) the accessible object is a Constructor object for the Class class
+ *
+ * @param accessibleObject the accessible object to check
+ * @param callerClass the callerClass to invoke {@code setAccessible}
+ * @return the check result
+ */
+ @Override
+ public boolean checkCanSetAccessible(AccessibleObject accessibleObject, Class<?> callerClass) {
+ SecurityManager sm = System.getSecurityManager();
+ try {
+ if (sm != null) {
+ sm.checkPermission(ACCESS_PERMISSION);
+ }
+ } catch (SecurityException e) {
+ return false;
+ }
+
+ if (accessibleObject instanceof Constructor) {
+ Constructor c = (Constructor) accessibleObject;
+ if (c.getDeclaringClass() == Class.class) {
+ return false; // Cannot make a java.lang.Class constructor accessible
+ }
+ }
+
+ return true;
+ }
+
+ @Override
+ public boolean checkAccessible(Class<?> callerClass, Class<?> declaringClass, int memberModifiers, boolean allowIllegalAccess) {
+ return true;
+ }
+
+ @Override
+ public boolean trySetAccessible(AccessibleObject ao) {
+ try {
+ ao.setAccessible(true);
+ return true;
+ } catch (SecurityException e) {
+ throw e;
+ } catch (Throwable t) {
+ return false;
+ }
+ }
+
+ @Override
+ public MetaMethod transformMetaMethod(MetaClass metaClass, MetaMethod metaMethod, Class<?> caller) {
+ return metaMethod;
+ }
+
+ @Override
+ public MetaMethod transformMetaMethod(MetaClass metaClass, MetaMethod metaMethod) {
+ return transformMetaMethod(metaClass, metaMethod, null);
+ }
+
+ @Override
+ public void invalidateCallSites() {
+ IndyInterface.invalidateSwitchPoints();
+ }
+
+ @Override
+ public Object getInvokeSpecialHandle(final Method method, final Object receiver) {
+ if (getLookupConstructor() == null) {
+ throw new GroovyBugError("getInvokeSpecialHandle requires at least JDK 7 wot private access to Lookup");
+ }
+ if (!method.isAccessible()) {
+ AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
+ ReflectionUtils.trySetAccessible(method);
+ return null;
+ });
+ }
+ Class<?> declaringClass = method.getDeclaringClass();
+ try {
+ return getLookupConstructor().newInstance(declaringClass, -1).
+ unreflectSpecial(method, declaringClass).
+ bindTo(receiver);
+ } catch (ReflectiveOperationException e) {
+ throw new GroovyBugError(e);
+ }
+ }
+
+ @Override
+ public Object invokeHandle(Object handle, Object[] args) throws Throwable {
+ MethodHandle mh = (MethodHandle) handle;
+ return mh.invokeWithArguments(args);
+ }
+
+ private static class LookupHolder {
+ private static final Constructor<MethodHandles.Lookup> LOOKUP_Constructor;
+
+ static {
+ Constructor<MethodHandles.Lookup> con;
+ try {
+ con = MethodHandles.Lookup.class.getDeclaredConstructor(Class.class, int.class);
+ } catch (NoSuchMethodException e) {
+ throw new GroovyBugError(e);
+ }
+ try {
+ if (!con.isAccessible()) {
+ final Constructor tmp = con;
+ AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
+ ReflectionUtils.trySetAccessible(tmp);
+ return null;
+ });
+ }
+ } catch (SecurityException se) {
+ con = null;
+ } catch (RuntimeException re) {
+ // test for JDK9 JIGSAW
+ if (!"java.lang.reflect.InaccessibleObjectException".equals(re.getClass().getName())) throw re;
+ con = null;
+ }
+ LOOKUP_Constructor = con;
+ }
+ }
}
diff --git a/src/main/java/org/codehaus/groovy/vmplugin/v7/MethodHandleWrapper.java b/src/main/java/org/codehaus/groovy/vmplugin/v8/MethodHandleWrapper.java
similarity index 97%
copy from src/main/java/org/codehaus/groovy/vmplugin/v7/MethodHandleWrapper.java
copy to src/main/java/org/codehaus/groovy/vmplugin/v8/MethodHandleWrapper.java
index 0319e93..8849fe6 100644
--- a/src/main/java/org/codehaus/groovy/vmplugin/v7/MethodHandleWrapper.java
+++ b/src/main/java/org/codehaus/groovy/vmplugin/v8/MethodHandleWrapper.java
@@ -16,7 +16,7 @@
* specific language governing permissions and limitations
* under the License.
*/
-package org.codehaus.groovy.vmplugin.v7;
+package org.codehaus.groovy.vmplugin.v8;
import java.lang.invoke.MethodHandle;
import java.util.concurrent.atomic.AtomicLong;
diff --git a/src/main/java/org/codehaus/groovy/vmplugin/v8/PluginDefaultGroovyMethods.java b/src/main/java/org/codehaus/groovy/vmplugin/v8/PluginDefaultGroovyMethods.java
index d3952fb..7ac2176 100644
--- a/src/main/java/org/codehaus/groovy/vmplugin/v8/PluginDefaultGroovyMethods.java
+++ b/src/main/java/org/codehaus/groovy/vmplugin/v8/PluginDefaultGroovyMethods.java
@@ -19,10 +19,17 @@
package org.codehaus.groovy.vmplugin.v8;
import groovy.lang.Closure;
+import groovy.lang.EmptyRange;
+import groovy.lang.GString;
+import groovy.lang.IntRange;
import groovy.transform.stc.ClosureParams;
import groovy.transform.stc.FirstParam;
+import org.codehaus.groovy.runtime.DefaultGroovyMethodsSupport;
+import org.codehaus.groovy.runtime.InvokerHelper;
import org.codehaus.groovy.runtime.NullObject;
+import org.codehaus.groovy.runtime.RangeInfo;
+import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.Iterator;
@@ -63,7 +70,7 @@ import java.util.stream.StreamSupport;
*
* @since 2.5.0
*/
-public class PluginDefaultGroovyMethods {
+public class PluginDefaultGroovyMethods extends DefaultGroovyMethodsSupport {
// No instances, static methods only
private PluginDefaultGroovyMethods() {
@@ -354,6 +361,111 @@ public class PluginDefaultGroovyMethods {
return new TransformedFuture<T>(self, transform);
}
+ /**
+ * This method is called by the ++ operator for enums. It will invoke
+ * Groovy's default next behaviour for enums do not have their own
+ * next method.
+ *
+ * @param self an Enum
+ * @return the next defined enum from the enum class
+ */
+ public static Object next(final Enum self) {
+ for (Method method : self.getClass().getMethods()) {
+ if (method.getName().equals("next") && method.getParameterCount() == 0) {
+ return InvokerHelper.invokeMethod(self, "next", InvokerHelper.EMPTY_ARGS);
+ }
+ }
+ Object[] values = (Object[]) InvokerHelper.invokeStaticMethod(self.getClass(), "values", InvokerHelper.EMPTY_ARGS);
+ int index = Arrays.asList(values).indexOf(self);
+ return values[index < values.length - 1 ? index + 1 : 0];
+ }
+
+ /**
+ * This method is called by the -- operator for enums. It will invoke
+ * Groovy's default previous behaviour for enums that do not have
+ * their own previous method.
+ *
+ * @param self an Enum
+ * @return the previous defined enum from the enum class
+ */
+ public static Object previous(final Enum self) {
+ for (Method method : self.getClass().getMethods()) {
+ if (method.getName().equals("previous") && method.getParameterCount() == 0) {
+ return InvokerHelper.invokeMethod(self, "previous", InvokerHelper.EMPTY_ARGS);
+ }
+ }
+ Object[] values = (Object[]) InvokerHelper.invokeStaticMethod(self.getClass(), "values", InvokerHelper.EMPTY_ARGS);
+ int index = Arrays.asList(values).indexOf(self);
+ return values[index > 0 ? index - 1 : values.length - 1];
+ }
+
+ /**
+ * Standard Groovy size() method for StringBuilders.
+ *
+ * @param builder a StringBuilder
+ * @return the length of the StringBuilder
+ */
+ public static int size(final StringBuilder builder) {
+ return builder.length();
+ }
+
+ /**
+ * Overloads the left shift operator to provide an easy way to append multiple
+ * objects as string representations to a StringBuilder.
+ *
+ * @param self a StringBuilder
+ * @param value a value to append
+ * @return the StringBuilder on which this operation was invoked
+ */
+ public static StringBuilder leftShift(final StringBuilder self, final Object value) {
+ if (value instanceof GString) {
+ // Force the conversion of the GString to string now, or appending
+ // is going to be extremely expensive, due to calls to GString#charAt,
+ // which is going to re-evaluate the GString for each character!
+ return self.append(value.toString());
+ }
+ if (value instanceof CharSequence) {
+ return self.append((CharSequence)value);
+ }
+ return self.append(value);
+ }
+
+ /**
+ * Support the range subscript operator for StringBuilder.
+ * Index values are treated as characters within the builder.
+ *
+ * @param self a StringBuilder
+ * @param range a Range
+ * @param value the object that's toString() will be inserted
+ */
+ public static void putAt(final StringBuilder self, final IntRange range, final Object value) {
+ RangeInfo info = DefaultGroovyMethodsSupport.subListBorders(self.length(), range);
+ self.replace(info.from, info.to, value.toString());
+ }
+
+ /**
+ * Support the range subscript operator for StringBuilder.
+ *
+ * @param self a StringBuilder
+ * @param range a Range
+ * @param value the object that's toString() will be inserted
+ */
+ public static void putAt(final StringBuilder self, final EmptyRange range, final Object value) {
+ RangeInfo info = DefaultGroovyMethodsSupport.subListBorders(self.length(), range);
+ self.replace(info.from, info.to, value.toString());
+ }
+
+ /**
+ * Appends a String to this StringBuilder.
+ *
+ * @param self a StringBuilder
+ * @param value a String
+ * @return a String
+ */
+ public static String plus(final StringBuilder self, final String value) {
+ return self + value;
+ }
+
private static class TransformedFuture<E> implements Future<E> {
private final Future delegate;
private final Closure<E> transform;
diff --git a/src/main/java/org/codehaus/groovy/vmplugin/v7/Selector.java b/src/main/java/org/codehaus/groovy/vmplugin/v8/Selector.java
similarity index 96%
copy from src/main/java/org/codehaus/groovy/vmplugin/v7/Selector.java
copy to src/main/java/org/codehaus/groovy/vmplugin/v8/Selector.java
index be01361..6741689 100644
--- a/src/main/java/org/codehaus/groovy/vmplugin/v7/Selector.java
+++ b/src/main/java/org/codehaus/groovy/vmplugin/v8/Selector.java
@@ -16,7 +16,7 @@
* specific language governing permissions and limitations
* under the License.
*/
-package org.codehaus.groovy.vmplugin.v7;
+package org.codehaus.groovy.vmplugin.v8;
import groovy.lang.AdaptingMetaClass;
import groovy.lang.Closure;
@@ -51,7 +51,7 @@ import org.codehaus.groovy.runtime.metaclass.NewStaticMetaMethod;
import org.codehaus.groovy.runtime.metaclass.ReflectionMetaMethod;
import org.codehaus.groovy.runtime.wrappers.Wrapper;
import org.codehaus.groovy.vmplugin.VMPluginFactory;
-import org.codehaus.groovy.vmplugin.v7.IndyInterface.CallType;
+import org.codehaus.groovy.vmplugin.v8.IndyInterface.CallType;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
@@ -66,36 +66,36 @@ import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
-import static org.codehaus.groovy.vmplugin.v7.IndyGuardsFiltersAndSignatures.ARRAYLIST_CONSTRUCTOR;
-import static org.codehaus.groovy.vmplugin.v7.IndyGuardsFiltersAndSignatures.BEAN_CONSTRUCTOR_PROPERTY_SETTER;
-import static org.codehaus.groovy.vmplugin.v7.IndyGuardsFiltersAndSignatures.BOOLEAN_IDENTITY;
-import static org.codehaus.groovy.vmplugin.v7.IndyGuardsFiltersAndSignatures.CLASS_FOR_NAME;
-import static org.codehaus.groovy.vmplugin.v7.IndyGuardsFiltersAndSignatures.DTT_CAST_TO_TYPE;
-import static org.codehaus.groovy.vmplugin.v7.IndyGuardsFiltersAndSignatures.EQUALS;
-import static org.codehaus.groovy.vmplugin.v7.IndyGuardsFiltersAndSignatures.GROOVY_CAST_EXCEPTION;
-import static org.codehaus.groovy.vmplugin.v7.IndyGuardsFiltersAndSignatures.GROOVY_OBJECT_GET_PROPERTY;
-import static org.codehaus.groovy.vmplugin.v7.IndyGuardsFiltersAndSignatures.GROOVY_OBJECT_INVOKER;
-import static org.codehaus.groovy.vmplugin.v7.IndyGuardsFiltersAndSignatures.HASHSET_CONSTRUCTOR;
-import static org.codehaus.groovy.vmplugin.v7.IndyGuardsFiltersAndSignatures.HAS_CATEGORY_IN_CURRENT_THREAD_GUARD;
-import static org.codehaus.groovy.vmplugin.v7.IndyGuardsFiltersAndSignatures.INTERCEPTABLE_INVOKER;
-import static org.codehaus.groovy.vmplugin.v7.IndyGuardsFiltersAndSignatures.IS_NULL;
-import static org.codehaus.groovy.vmplugin.v7.IndyGuardsFiltersAndSignatures.META_CLASS_INVOKE_STATIC_METHOD;
-import static org.codehaus.groovy.vmplugin.v7.IndyGuardsFiltersAndSignatures.META_METHOD_INVOKER;
-import static org.codehaus.groovy.vmplugin.v7.IndyGuardsFiltersAndSignatures.META_PROPERTY_GETTER;
-import static org.codehaus.groovy.vmplugin.v7.IndyGuardsFiltersAndSignatures.MOP_GET;
-import static org.codehaus.groovy.vmplugin.v7.IndyGuardsFiltersAndSignatures.MOP_INVOKE_CONSTRUCTOR;
-import static org.codehaus.groovy.vmplugin.v7.IndyGuardsFiltersAndSignatures.MOP_INVOKE_METHOD;
-import static org.codehaus.groovy.vmplugin.v7.IndyGuardsFiltersAndSignatures.NULL_REF;
-import static org.codehaus.groovy.vmplugin.v7.IndyGuardsFiltersAndSignatures.SAME_CLASS;
-import static org.codehaus.groovy.vmplugin.v7.IndyGuardsFiltersAndSignatures.SAME_MC;
-import static org.codehaus.groovy.vmplugin.v7.IndyGuardsFiltersAndSignatures.SAM_CONVERSION;
-import static org.codehaus.groovy.vmplugin.v7.IndyGuardsFiltersAndSignatures.UNWRAP_EXCEPTION;
-import static org.codehaus.groovy.vmplugin.v7.IndyGuardsFiltersAndSignatures.UNWRAP_METHOD;
-import static org.codehaus.groovy.vmplugin.v7.IndyGuardsFiltersAndSignatures.unwrap;
-import static org.codehaus.groovy.vmplugin.v7.IndyInterface.LOG;
-import static org.codehaus.groovy.vmplugin.v7.IndyInterface.LOG_ENABLED;
-import static org.codehaus.groovy.vmplugin.v7.IndyInterface.LOOKUP;
-import static org.codehaus.groovy.vmplugin.v7.IndyInterface.switchPoint;
+import static org.codehaus.groovy.vmplugin.v8.IndyGuardsFiltersAndSignatures.ARRAYLIST_CONSTRUCTOR;
+import static org.codehaus.groovy.vmplugin.v8.IndyGuardsFiltersAndSignatures.BEAN_CONSTRUCTOR_PROPERTY_SETTER;
+import static org.codehaus.groovy.vmplugin.v8.IndyGuardsFiltersAndSignatures.BOOLEAN_IDENTITY;
+import static org.codehaus.groovy.vmplugin.v8.IndyGuardsFiltersAndSignatures.CLASS_FOR_NAME;
+import static org.codehaus.groovy.vmplugin.v8.IndyGuardsFiltersAndSignatures.DTT_CAST_TO_TYPE;
+import static org.codehaus.groovy.vmplugin.v8.IndyGuardsFiltersAndSignatures.EQUALS;
+import static org.codehaus.groovy.vmplugin.v8.IndyGuardsFiltersAndSignatures.GROOVY_CAST_EXCEPTION;
+import static org.codehaus.groovy.vmplugin.v8.IndyGuardsFiltersAndSignatures.GROOVY_OBJECT_GET_PROPERTY;
+import static org.codehaus.groovy.vmplugin.v8.IndyGuardsFiltersAndSignatures.GROOVY_OBJECT_INVOKER;
+import static org.codehaus.groovy.vmplugin.v8.IndyGuardsFiltersAndSignatures.HASHSET_CONSTRUCTOR;
+import static org.codehaus.groovy.vmplugin.v8.IndyGuardsFiltersAndSignatures.HAS_CATEGORY_IN_CURRENT_THREAD_GUARD;
+import static org.codehaus.groovy.vmplugin.v8.IndyGuardsFiltersAndSignatures.INTERCEPTABLE_INVOKER;
+import static org.codehaus.groovy.vmplugin.v8.IndyGuardsFiltersAndSignatures.IS_NULL;
+import static org.codehaus.groovy.vmplugin.v8.IndyGuardsFiltersAndSignatures.META_CLASS_INVOKE_STATIC_METHOD;
+import static org.codehaus.groovy.vmplugin.v8.IndyGuardsFiltersAndSignatures.META_METHOD_INVOKER;
+import static org.codehaus.groovy.vmplugin.v8.IndyGuardsFiltersAndSignatures.META_PROPERTY_GETTER;
+import static org.codehaus.groovy.vmplugin.v8.IndyGuardsFiltersAndSignatures.MOP_GET;
+import static org.codehaus.groovy.vmplugin.v8.IndyGuardsFiltersAndSignatures.MOP_INVOKE_CONSTRUCTOR;
+import static org.codehaus.groovy.vmplugin.v8.IndyGuardsFiltersAndSignatures.MOP_INVOKE_METHOD;
+import static org.codehaus.groovy.vmplugin.v8.IndyGuardsFiltersAndSignatures.NULL_REF;
+import static org.codehaus.groovy.vmplugin.v8.IndyGuardsFiltersAndSignatures.SAME_CLASS;
+import static org.codehaus.groovy.vmplugin.v8.IndyGuardsFiltersAndSignatures.SAME_MC;
+import static org.codehaus.groovy.vmplugin.v8.IndyGuardsFiltersAndSignatures.SAM_CONVERSION;
+import static org.codehaus.groovy.vmplugin.v8.IndyGuardsFiltersAndSignatures.UNWRAP_EXCEPTION;
+import static org.codehaus.groovy.vmplugin.v8.IndyGuardsFiltersAndSignatures.UNWRAP_METHOD;
+import static org.codehaus.groovy.vmplugin.v8.IndyGuardsFiltersAndSignatures.unwrap;
+import static org.codehaus.groovy.vmplugin.v8.IndyInterface.LOG;
+import static org.codehaus.groovy.vmplugin.v8.IndyInterface.LOG_ENABLED;
+import static org.codehaus.groovy.vmplugin.v8.IndyInterface.LOOKUP;
+import static org.codehaus.groovy.vmplugin.v8.IndyInterface.switchPoint;
public abstract class Selector {
public Object[] args, originalArguments;
diff --git a/src/main/java/org/codehaus/groovy/vmplugin/v7/TypeHelper.java b/src/main/java/org/codehaus/groovy/vmplugin/v8/TypeHelper.java
similarity index 99%
copy from src/main/java/org/codehaus/groovy/vmplugin/v7/TypeHelper.java
copy to src/main/java/org/codehaus/groovy/vmplugin/v8/TypeHelper.java
index 8591fae..1ebd9f6 100644
--- a/src/main/java/org/codehaus/groovy/vmplugin/v7/TypeHelper.java
+++ b/src/main/java/org/codehaus/groovy/vmplugin/v8/TypeHelper.java
@@ -16,7 +16,7 @@
* specific language governing permissions and limitations
* under the License.
*/
-package org.codehaus.groovy.vmplugin.v7;
+package org.codehaus.groovy.vmplugin.v8;
import java.lang.invoke.MethodType;
diff --git a/src/main/java/org/codehaus/groovy/vmplugin/v7/TypeTransformers.java b/src/main/java/org/codehaus/groovy/vmplugin/v8/TypeTransformers.java
similarity index 99%
copy from src/main/java/org/codehaus/groovy/vmplugin/v7/TypeTransformers.java
copy to src/main/java/org/codehaus/groovy/vmplugin/v8/TypeTransformers.java
index d4c92ad..e22b0db 100644
--- a/src/main/java/org/codehaus/groovy/vmplugin/v7/TypeTransformers.java
+++ b/src/main/java/org/codehaus/groovy/vmplugin/v8/TypeTransformers.java
@@ -16,7 +16,7 @@
* specific language governing permissions and limitations
* under the License.
*/
-package org.codehaus.groovy.vmplugin.v7;
+package org.codehaus.groovy.vmplugin.v8;
import groovy.lang.Closure;
import groovy.lang.GString;
@@ -27,6 +27,7 @@ import org.codehaus.groovy.reflection.stdclasses.CachedSAMClass;
import org.codehaus.groovy.runtime.ConvertedClosure;
import org.codehaus.groovy.runtime.typehandling.DefaultTypeTransformation;
import org.codehaus.groovy.transform.trait.Traits;
+import org.codehaus.groovy.vmplugin.v8.TypeHelper;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
diff --git a/src/main/java/org/codehaus/groovy/vmplugin/v9/Java9.java b/src/main/java/org/codehaus/groovy/vmplugin/v9/Java9.java
index 806191d..cfcb9d8 100644
--- a/src/main/java/org/codehaus/groovy/vmplugin/v9/Java9.java
+++ b/src/main/java/org/codehaus/groovy/vmplugin/v9/Java9.java
@@ -27,7 +27,6 @@ import org.codehaus.groovy.GroovyBugError;
import org.codehaus.groovy.reflection.CachedClass;
import org.codehaus.groovy.reflection.CachedMethod;
import org.codehaus.groovy.reflection.ReflectionUtils;
-import org.codehaus.groovy.vmplugin.v5.Java5;
import org.codehaus.groovy.vmplugin.v8.Java8;
import java.lang.invoke.MethodHandle;
@@ -120,7 +119,7 @@ public class Java9 extends Java8 {
/**
* This method may be used by a caller in class C to check whether to enable access to a member of declaring class D successfully
- * if {@link Java5#checkCanSetAccessible(java.lang.reflect.AccessibleObject, java.lang.Class)} returns true and any of the following hold:
+ * if {@link Java8#checkCanSetAccessible(java.lang.reflect.AccessibleObject, java.lang.Class)} returns true and any of the following hold:
* <p>
* 1) C and D are in the same module.
* 2) The member is public and D is public in a package that the module containing D exports to at least the module containing C.
diff --git a/src/test/groovy/lang/MetaClassRegistryTest.groovy b/src/test/groovy/lang/MetaClassRegistryTest.groovy
index 79f4733..0f0fecc 100644
--- a/src/test/groovy/lang/MetaClassRegistryTest.groovy
+++ b/src/test/groovy/lang/MetaClassRegistryTest.groovy
@@ -30,7 +30,7 @@ class MetaClassRegistryTest extends GroovyTestCase {
static initSize
static {
try {
- Class.forName("org.codehaus.groovy.vmplugin.v7.IndyInterface", true, MetaClassRegistryTest.classLoader)
+ Class.forName("org.codehaus.groovy.vmplugin.v8.IndyInterface", true, MetaClassRegistryTest.classLoader)
} catch (e) {
}
initSize = GroovySystem.metaClassRegistry.metaClassRegistryChangeEventListeners.size()
diff --git a/src/test/indy/IndyUsageTest.groovy b/src/test/indy/IndyUsageTest.groovy
index 436fb1c..5e95ca7 100644
--- a/src/test/indy/IndyUsageTest.groovy
+++ b/src/test/indy/IndyUsageTest.groovy
@@ -33,7 +33,7 @@ final class IndyUsageTest {
try {
foo()
} catch (e) {
- assert e.stackTrace.find { it.className == 'org.codehaus.groovy.vmplugin.v7.IndyInterface' }
+ assert e.stackTrace.find { it.className == 'org.codehaus.groovy.vmplugin.v8.IndyInterface' }
}
'''
}
Re: [groovy] 03/08: GROOVY-9380: VMPlugin refactor: Coalesce Java5
through Java7 into Java8
Posted by "Daniel.Sun" <su...@apache.org>.
Hi Jochen,
> but since you decided to move them now I would recommend to do it
> "proper".
Agreed ;-)
> compiler specific static methods out of the VMplugin into the compiler
Which classes do you recommend to accept the compiler specific static
methods?
Cheers,
Daniel.Sun
-----
Apache Groovy committer & PMC member
Blog: http://blog.sunlan.me
Twitter: @daniel_sun
--
Sent from: http://groovy.329449.n5.nabble.com/Groovy-Dev-f372993.html
Re: [groovy] 03/08: GROOVY-9380: VMPlugin refactor: Coalesce Java5
through Java7 into Java8
Posted by Paul King <pa...@asert.com.au>.
We can certainly look at this. There is quite a bit of historic code in
that package which could be moved elsewhere. I recommend doing that outside
this issue.
On Sat, Feb 1, 2020 at 9:37 PM Jochen Theodorou <bl...@gmx.org> wrote:
> On 01.02.20 01:02, sunlan@apache.org wrote:
> > This is an automated email from the ASF dual-hosted git repository.
> >
> > sunlan pushed a commit to branch GROOVY_3_0_X
> > in repository https://gitbox.apache.org/repos/asf/groovy.git
> >
> > commit 2661c787da9fcaa7451f3f78556ce0b32530a1a1
> > Author: Paul King <pa...@asert.com.au>
> > AuthorDate: Fri Jan 31 08:44:13 2020 +1000
> >
> > GROOVY-9380: VMPlugin refactor: Coalesce Java5 through Java7 into
> Java8
> >
> > (cherry picked from commit 697bf094a40b9afda80ae1da0b431c26ec5a3ca3)
> [...]
>
> I think this kind of refactoring should actually go one step further and
> move configureTypeVariableDefinition, configureClass,
> configureTypeVariableReference, setRetentionPolicy,
> setMethodDefaultValue as compiler specific static methods out of the
> VMplugin into the compiler. It made kind of sense to have these in the
> past and past means really that Groovy is not requiring at least Java5.
> When we required at least Java5 it was just laziness to keep them there
> (or we had better things to do), but since you decided to move them now
> I would recommend to do it "proper".
>
> bye Jochen
>
Re: [groovy] 03/08: GROOVY-9380: VMPlugin refactor: Coalesce Java5
through Java7 into Java8
Posted by Jochen Theodorou <bl...@gmx.org>.
On 01.02.20 01:02, sunlan@apache.org wrote:
> This is an automated email from the ASF dual-hosted git repository.
>
> sunlan pushed a commit to branch GROOVY_3_0_X
> in repository https://gitbox.apache.org/repos/asf/groovy.git
>
> commit 2661c787da9fcaa7451f3f78556ce0b32530a1a1
> Author: Paul King <pa...@asert.com.au>
> AuthorDate: Fri Jan 31 08:44:13 2020 +1000
>
> GROOVY-9380: VMPlugin refactor: Coalesce Java5 through Java7 into Java8
>
> (cherry picked from commit 697bf094a40b9afda80ae1da0b431c26ec5a3ca3)
[...]
I think this kind of refactoring should actually go one step further and
move configureTypeVariableDefinition, configureClass,
configureTypeVariableReference, setRetentionPolicy,
setMethodDefaultValue as compiler specific static methods out of the
VMplugin into the compiler. It made kind of sense to have these in the
past and past means really that Groovy is not requiring at least Java5.
When we required at least Java5 it was just laziness to keep them there
(or we had better things to do), but since you decided to move them now
I would recommend to do it "proper".
bye Jochen