You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@groovy.apache.org by em...@apache.org on 2026/01/24 15:29:12 UTC
(groovy) branch master updated: refactor static property handling
This is an automated email from the ASF dual-hosted git repository.
emilles pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/groovy.git
The following commit(s) were added to refs/heads/master by this push:
new f773c06a8d refactor static property handling
f773c06a8d is described below
commit f773c06a8dcc9a1a19f2b5be8d05567661330be1
Author: Eric Milles <er...@thomsonreuters.com>
AuthorDate: Sat Jan 24 06:40:02 2026 -0600
refactor static property handling
---
.../groovy/transform/ASTTestTransformation.groovy | 8 +-
src/main/java/groovy/lang/MetaClass.java | 4 +-
src/main/java/groovy/lang/MetaClassImpl.java | 195 +++++++++------------
.../classgen/InnerClassCompletionVisitor.java | 33 ++--
src/test/groovy/bugs/Groovy4006.groovy | 142 +++++++++++++++
src/test/groovy/bugs/Groovy4006Bug.groovy | 151 ----------------
.../groovy/util/ReferenceManagerTest.groovy | 5 +-
7 files changed, 253 insertions(+), 285 deletions(-)
diff --git a/src/main/groovy/org/codehaus/groovy/transform/ASTTestTransformation.groovy b/src/main/groovy/org/codehaus/groovy/transform/ASTTestTransformation.groovy
index 456f3bb36e..897894bd17 100644
--- a/src/main/groovy/org/codehaus/groovy/transform/ASTTestTransformation.groovy
+++ b/src/main/groovy/org/codehaus/groovy/transform/ASTTestTransformation.groovy
@@ -99,8 +99,8 @@ class ASTTestTransformation implements ASTTransformation, CompilationUnitAware {
private final Binding binding = new Binding([:].withDefault { null })
@Override
- void call(final SourceUnit source) {
- if (source == sourceUnit) {
+ void call(final SourceUnit unit) {
+ if (unit == sourceUnit) {
test()
}
}
@@ -113,6 +113,8 @@ class ASTTestTransformation implements ASTTransformation, CompilationUnitAware {
sb = sb[testClosure.columnNumber..<sb.length()]
String testSource = sb[0..<sb.lastIndexOf('}')]
+ def compilationUnit = ASTTestTransformation.this.@compilationUnit
+
binding['node'] = astNode
binding['sourceUnit'] = sourceUnit
binding['compilationUnit'] = compilationUnit
@@ -140,7 +142,7 @@ class ASTTestTransformation implements ASTTransformation, CompilationUnitAware {
}
}
- static class LabelFinder extends ClassCodeVisitorSupport {
+ private static class LabelFinder extends ClassCodeVisitorSupport {
static List<Statement> lookup(final MethodNode node, final String label) {
LabelFinder finder = new LabelFinder(label, null)
diff --git a/src/main/java/groovy/lang/MetaClass.java b/src/main/java/groovy/lang/MetaClass.java
index b06d4c6cc5..3b72d8c74c 100644
--- a/src/main/java/groovy/lang/MetaClass.java
+++ b/src/main/java/groovy/lang/MetaClass.java
@@ -49,7 +49,7 @@ public interface MetaClass extends MetaObjectProtocol {
* @param isCallToSuper Whether the method is a call to a super class method
* @param fromInsideClass Whether the call was invoked from the inside or the outside of the class
*
- * @return The return value of the method
+ * @return The method's return value.
*/
Object invokeMethod(Class sender, Object receiver, String methodName, Object[] arguments, boolean isCallToSuper, boolean fromInsideClass);
@@ -66,7 +66,7 @@ public interface MetaClass extends MetaObjectProtocol {
* @param isCallToSuper Whether the call is to a super class property
* @param fromInsideClass ??
*
- * @return The properties value
+ * @return The property's value.
*/
Object getProperty(Class sender, Object receiver, String property, boolean isCallToSuper, boolean fromInsideClass);
diff --git a/src/main/java/groovy/lang/MetaClassImpl.java b/src/main/java/groovy/lang/MetaClassImpl.java
index 2dcd9c6ca0..94c972b72e 100644
--- a/src/main/java/groovy/lang/MetaClassImpl.java
+++ b/src/main/java/groovy/lang/MetaClassImpl.java
@@ -832,64 +832,43 @@ public class MetaClassImpl implements MetaClass, MutableMetaClass {
MetaBeanProperty property = findPropertyInClassHierarchy(propertyName, theCachedClass);
if (property != null) {
onSuperPropertyFoundInHierarchy(property);
- if (!isGetter) {
+ if (isGetter) {
+ return property.getProperty(instance);
+ } else {
property.setProperty(instance, optionalValue);
return null;
}
- return property.getProperty(instance);
}
- // look for getProperty or setProperty overrides
+ // look for getProperty or setProperty
if (isGetter) {
- final Class<?>[] getPropertyArgs = {String.class};
- final MetaMethod method = findMethodInClassHierarchy(instance.getClass(), GET_PROPERTY_METHOD, getPropertyArgs, this);
+ MetaMethod method = findMethodInClassHierarchy(instance.getClass(), GET_PROPERTY_METHOD, GETTER_MISSING_ARGS, this);
if (method instanceof ClosureMetaMethod) {
onGetPropertyFoundInHierarchy(method);
return method.invoke(instance, new Object[]{propertyName});
}
} else {
- final Class<?>[] setPropertyArgs = {String.class, Object.class};
- final MetaMethod method = findMethodInClassHierarchy(instance.getClass(), SET_PROPERTY_METHOD, setPropertyArgs, this);
+ MetaMethod method = findMethodInClassHierarchy(instance.getClass(), SET_PROPERTY_METHOD, SETTER_MISSING_ARGS, this);
if (method instanceof ClosureMetaMethod) {
onSetPropertyFoundInHierarchy(method);
return method.invoke(instance, new Object[]{propertyName, optionalValue});
}
}
- try {
- if (!(instance instanceof Class)) {
- if (isGetter) {
- if (propertyMissingGet != null) {
- return propertyMissingGet.invoke(instance, new Object[]{propertyName});
- }
- } else {
- if (propertyMissingSet != null) {
- return propertyMissingSet.invoke(instance, new Object[]{propertyName, optionalValue});
- }
- }
- }
- } catch (InvokerInvocationException iie) {
- boolean shouldHandle = isGetter && propertyMissingGet != null;
- if (!shouldHandle) shouldHandle = !isGetter && propertyMissingSet != null;
- if (shouldHandle && iie.getCause() instanceof MissingPropertyException) {
- throw (MissingPropertyException) iie.getCause();
- }
- throw iie;
- }
-
- Class<?> theClass = instance instanceof Class ? (Class<?>) instance : instance.getClass();
- if (instance instanceof Class && theClass != Class.class) {
- final MetaProperty metaProperty = InvokerHelper.getMetaClass(Class.class).hasProperty(instance, propertyName);
- if (metaProperty != null) {
- if (isGetter) {
- return metaProperty.getProperty(instance);
+ if (!(instance instanceof Class)) {
+ MetaMethod propertyMissing = isGetter ? propertyMissingGet : propertyMissingSet;
+ if (propertyMissing != null) {
+ var arguments = isGetter ? new Object[]{propertyName}
+ : new Object[]{propertyName, optionalValue};
+ try {
+ return propertyMissing.invoke(instance, arguments);
+ } catch (InvokerInvocationException iie) {
+ throw iie.getCause() instanceof MissingPropertyException mpe ? mpe : iie;
}
- metaProperty.setProperty(instance, optionalValue);
- return null;
}
}
- throw new MissingPropertyExceptionNoStack(propertyName, theClass);
+ throw new MissingPropertyExceptionNoStack(propertyName, instance instanceof Class ? (Class<?>) instance : instance.getClass());
}
private Object invokeMissingMethod(final Object instance, final String methodName, final Object[] arguments, final RuntimeException original, final boolean isCallToSuper) {
@@ -973,33 +952,29 @@ public class MetaClassImpl implements MetaClass, MutableMetaClass {
}
/**
- * Hook to deal with the case of MissingProperty for static properties. The method will look attempt to look up
- * "propertyMissing" handlers and invoke them otherwise thrown a MissingPropertyException
+ * Hook to deal with the case of missing property for static properties. The
+ * method attempts to look up "$static_propertyMissing" handlers and invoke
+ * them otherwise throws a MissingPropertyException.
*
- * @param instance The instance
- * @param propertyName The name of the property
- * @param optionalValue The value in the case of a setter
- * @param isGetter True if it's a getter
- * @return The value in the case of a getter or a MissingPropertyException
- */
- protected Object invokeStaticMissingProperty(Object instance, String propertyName, Object optionalValue, boolean isGetter) {
- MetaClass mc = instance instanceof Class ? registry.getMetaClass((Class<?>) instance) : this;
- if (isGetter) {
- MetaMethod propertyMissing = mc.getMetaMethod(STATIC_PROPERTY_MISSING, GETTER_MISSING_ARGS);
- if (propertyMissing != null) {
- return propertyMissing.invoke(instance, new Object[]{propertyName});
- }
- } else {
- MetaMethod propertyMissing = mc.getMetaMethod(STATIC_PROPERTY_MISSING, SETTER_MISSING_ARGS);
- if (propertyMissing != null) {
- return propertyMissing.invoke(instance, new Object[]{propertyName, optionalValue});
+ * @param instance the class instance
+ * @param propertyName the name of the property
+ * @param optionalValue the value in the case of a setter
+ * @param isGetter true for property read, false for property write
+ * @return The value in the case of a getter or null in the case of a setter.
+ * @throws MissingPropertyException
+ */
+ protected Object invokeStaticMissingProperty(final Object instance, final String propertyName, final Object optionalValue, final boolean isGetter) {
+ MetaMethod propertyMissing = getMetaMethod(STATIC_PROPERTY_MISSING, isGetter ? GETTER_MISSING_ARGS : SETTER_MISSING_ARGS);
+ if (propertyMissing != null) {
+ var arguments = isGetter ? new Object[]{propertyName} : new Object[]{propertyName, optionalValue};
+ try {
+ return propertyMissing.invoke(instance, arguments);
+ } catch (InvokerInvocationException iie) {
+ throw iie.getCause() instanceof MissingPropertyException mpe ? mpe : iie;
}
}
- if (instance instanceof Class) {
- throw new MissingPropertyException(propertyName, (Class<?>) instance);
- }
- throw new MissingPropertyException(propertyName, theClass);
+ throw new MissingPropertyExceptionNoStack(propertyName, theClass);
}
/**
@@ -1322,13 +1297,14 @@ public class MetaClassImpl implements MetaClass, MutableMetaClass {
}
private MetaClass lookupObjectMetaClass(Object object) {
- if (object instanceof GroovyObject go) {
- return go.getMetaClass();
+ if (object instanceof GroovyObject groovyObject) {
+ return groovyObject.getMetaClass();
+ }
+ Class<?> ownerClass = object.getClass();
+ if (ownerClass == Class.class) {
+ ownerClass = (Class<?>) object;
}
- Class ownerClass = object.getClass();
- if (ownerClass == Class.class) ownerClass = (Class) object;
- MetaClass metaClass = registry.getMetaClass(ownerClass);
- return metaClass;
+ return registry.getMetaClass(ownerClass);
}
private static Object invokeMethodOnGroovyObject(String methodName, Object[] originalArguments, Object owner) {
@@ -1818,9 +1794,6 @@ public class MetaClassImpl implements MetaClass, MutableMetaClass {
}
}
- /**
- * @return the given property's value on the object
- */
@Override
public Object getProperty(final Class sender, final Object object, final String name, final boolean useSuper, final boolean fromInsideClass) {
@@ -1904,37 +1877,42 @@ public class MetaClassImpl implements MetaClass, MutableMetaClass {
//------------------------------------------------------------------
MetaMethod metaMethod = VM_PLUGIN.transformMetaMethod(this, method);
return metaMethod.doMethodInvoke(object, arguments);
- } else {
- //------------------------------------------------------------------
- // special cases -- maybe these cases should be special MetaClasses!
- //------------------------------------------------------------------
- if (isStatic) {
- MetaClass cmc = registry.getMetaClass(Class.class);
- return cmc.getProperty(Class.class, object, name, false, false);
- }
- if (object instanceof Collection) {
- return DefaultGroovyMethods.getAt((Collection<?>) object, name);
- }
- if (object instanceof Object[]) {
- return DefaultGroovyMethods.getAt(Arrays.asList((Object[]) object), name);
- }
- MetaMethod addListenerMethod = listeners.get(name);
- if (addListenerMethod != null) {
- // TODO: one day we could try return the previously registered Closure listener for easy removal
- return null;
- }
+ }
+
+ //------------------------------------------------------------------
+ // special cases -- maybe these cases should be special MetaClasses!
+ //------------------------------------------------------------------
+ if (isStatic) {
+ return getClassProperty(sender, (Class<?>) object, name);
+ }
+ if (object instanceof Collection) {
+ return DefaultGroovyMethods.getAt((Collection<?>) object, name);
+ }
+ if (object instanceof Object[]) {
+ return DefaultGroovyMethods.getAt(Arrays.asList((Object[]) object), name);
+ }
+ if (listeners.get(name) != null) {
+ // TODO: one day we could try return the previously registered Closure listener for easy removal
+ return null;
}
//----------------------------------------------------------------------
// missing property protocol
//----------------------------------------------------------------------
- if (object instanceof Class) {
- return invokeStaticMissingProperty(object, name, null, true);
- }
return invokeMissingProperty(object, name, null, true);
}
- public MetaProperty getEffectiveGetMetaProperty(final Class sender, final Object object, String name, final boolean useSuper) {
+ private Object getClassProperty(final Class<?> sender, final Class<?> receiver, final String name) throws MissingPropertyException {
+ try {
+ MetaClass cmc = registry.getMetaClass(Class.class);
+ return cmc.getProperty(Class.class, receiver, name, false, false);
+ } catch (MissingPropertyException ignore) {
+ // try $static_propertyMissing / throw MissingPropertyException
+ return invokeStaticMissingProperty(receiver, name, null, true);
+ }
+ }
+
+ public MetaProperty getEffectiveGetMetaProperty(final Class sender, final Object object, final String name, final boolean useSuper) {
//----------------------------------------------------------------------
// handling of static
@@ -2022,12 +2000,11 @@ public class MetaClassImpl implements MetaClass, MutableMetaClass {
//----------------------------------------------------------------------
// special cases
//----------------------------------------------------------------------
- if (theClass != Class.class && object instanceof Class) {
+ if (isStatic) {
return new ReadOnlyMetaProperty(name) {
@Override
public Object getProperty(final Object receiver) {
- MetaClass cmc = registry.getMetaClass(Class.class);
- return cmc.getProperty(Class.class, receiver, getName(), false, false);
+ return getClassProperty(sender, (Class<?>) receiver, getName());
}
};
}
@@ -2047,8 +2024,7 @@ public class MetaClassImpl implements MetaClass, MutableMetaClass {
}
};
}
- MetaMethod addListenerMethod = listeners.get(name);
- if (addListenerMethod != null) {
+ if (listeners.get(name) != null) {
return new ReadOnlyMetaProperty(name) {
@Override
public Object getProperty(final Object receiver) { return null; }
@@ -2056,16 +2032,8 @@ public class MetaClassImpl implements MetaClass, MutableMetaClass {
}
//----------------------------------------------------------------------
- // error due to missing method/field
+ // missing property protocol
//----------------------------------------------------------------------
- if (isStatic || object instanceof Class) {
- return new ReadOnlyMetaProperty(name) {
- @Override
- public Object getProperty(final Object receiver) {
- return invokeStaticMissingProperty(receiver, getName(), null, true);
- }
- };
- }
return new ReadOnlyMetaProperty(name) {
@Override
public Object getProperty(final Object receiver) {
@@ -2791,6 +2759,15 @@ public class MetaClassImpl implements MetaClass, MutableMetaClass {
return;
}
+ //----------------------------------------------------------------------
+ // metaClass property
+ //----------------------------------------------------------------------
+ if (isStatic && name.equals("metaClass")) {
+ MetaClass cmc = registry.getMetaClass(Class.class);
+ cmc.setProperty(Class.class, object, name, newValue, false, false);
+ return;
+ }
+
//----------------------------------------------------------------------
// missing property protocol
//----------------------------------------------------------------------
@@ -2800,10 +2777,10 @@ public class MetaClassImpl implements MetaClass, MutableMetaClass {
if (mp != null) {
throw new ReadOnlyPropertyException(name, theClass);
}
- if (object instanceof Class && !"metaClass".equals(name)) {
- invokeStaticMissingProperty(object, name, newValue, false);
- } else {
+ if (!isStatic) {
invokeMissingProperty(object, name, newValue, false);
+ } else {
+ invokeStaticMissingProperty(object, name, newValue, false);
}
}
diff --git a/src/main/java/org/codehaus/groovy/classgen/InnerClassCompletionVisitor.java b/src/main/java/org/codehaus/groovy/classgen/InnerClassCompletionVisitor.java
index 5cde1cc739..fb70379836 100644
--- a/src/main/java/org/codehaus/groovy/classgen/InnerClassCompletionVisitor.java
+++ b/src/main/java/org/codehaus/groovy/classgen/InnerClassCompletionVisitor.java
@@ -18,8 +18,6 @@
*/
package org.codehaus.groovy.classgen;
-import groovy.lang.MissingMethodException;
-import groovy.lang.MissingPropertyException;
import groovy.transform.CompileStatic;
import groovy.transform.stc.POJO;
import org.codehaus.groovy.ast.ClassHelper;
@@ -90,10 +88,6 @@ public class InnerClassCompletionVisitor extends InnerClassVisitorHelper {
private FieldNode thisField;
private final SourceUnit sourceUnit;
- private static final String
- CLOSURE_INTERNAL_NAME = BytecodeHelper.getClassInternalName(CLOSURE_TYPE),
- CLOSURE_DESCRIPTOR = BytecodeHelper.getTypeDescription(CLOSURE_TYPE);
-
public InnerClassCompletionVisitor(CompilationUnit cu, SourceUnit su) {
sourceUnit = su;
}
@@ -124,8 +118,8 @@ public class InnerClassCompletionVisitor extends InnerClassVisitorHelper {
super.visitClass(node);
- boolean innerPojo = hasAnnotation(node, ClassHelper.make(POJO.class))
- && hasAnnotation(node, ClassHelper.make(CompileStatic.class));
+ boolean innerPojo = hasAnnotation(node, new ClassNode(POJO.class))
+ && hasAnnotation(node, new ClassNode(CompileStatic.class));
if (!innerPojo) {
addMopMethods(innerClass);
}
@@ -213,11 +207,11 @@ public class InnerClassCompletionVisitor extends InnerClassVisitorHelper {
setPropertyGetterDispatcher(block, VariableExpression.THIS_EXPRESSION, method.getParameters());
}
- private void getThis(MethodVisitor mv, String classInternalName, String outerClassDescriptor, String innerClassInternalName) {
+ private void getThis(final MethodVisitor mv, final String classInternalName, final String outerClassDescriptor, final String innerClassInternalName) {
mv.visitVarInsn(ALOAD, 0);
if (thisField != null && CLOSURE_TYPE.equals(thisField.getType())) {
- mv.visitFieldInsn(GETFIELD, classInternalName, "this$0", CLOSURE_DESCRIPTOR);
- mv.visitMethodInsn(INVOKEVIRTUAL, CLOSURE_INTERNAL_NAME, "getThisObject", "()Ljava/lang/Object;", false);
+ mv.visitFieldInsn(GETFIELD, classInternalName, "this$0", BytecodeHelper.getTypeDescription(CLOSURE_TYPE));
+ mv.visitMethodInsn(INVOKEVIRTUAL, BytecodeHelper.getClassInternalName(CLOSURE_TYPE), "getThisObject", "()Ljava/lang/Object;", false);
mv.visitTypeInsn(CHECKCAST, innerClassInternalName);
} else {
mv.visitFieldInsn(GETFIELD, classInternalName, "this$0", outerClassDescriptor);
@@ -347,26 +341,31 @@ public class InnerClassCompletionVisitor extends InnerClassVisitorHelper {
final ClassNode returnType, final Parameter[] parameters, final BiConsumer<BlockStatement, Parameter[]> consumer) {
MethodNode method = innerClass.getDeclaredMethod(methodName, parameters);
if (method == null) {
+ // try {
+ // <consumer dispatch>
+ // } catch (MissingMethodException notFound) {
+ // throw new MissingMethodException(notFound.method, this, notFound.arguments)
+ // }
Parameter catchParam = param(OBJECT_TYPE, "notFound"); // dummy type
ClassNode exceptionT;
Expression newException;
Expression selfType = varX("this");
if ((modifiers & ACC_STATIC) == 0) selfType = callX(selfType, "getClass");
if (methodName.endsWith("methodMissing")) {
- exceptionT = ClassHelper.make(MissingMethodException.class);
+ exceptionT = ClassHelper.make(groovy.lang.MissingMethodException.class);
newException = ctorX(exceptionT, args(propX(varX(catchParam),"method"), selfType, propX(varX(catchParam),"arguments")));
} else {
- exceptionT = ClassHelper.make(MissingPropertyException.class);
+ exceptionT = ClassHelper.make(groovy.lang.MissingPropertyException.class);
newException = ctorX(exceptionT, args(propX(varX(catchParam), "property"), selfType, propX(varX(catchParam), "cause")));
}
-
catchParam.setType(exceptionT);
catchParam.setOriginType(exceptionT);
BlockStatement handleMissing = block();
consumer.accept(handleMissing, parameters);
- TryCatchStatement methodBody = tryCatchS(handleMissing);
- methodBody.addCatch(catchS(catchParam, throwS(newException)));
- innerClass.addSyntheticMethod(methodName, modifiers, returnType, parameters, ClassNode.EMPTY_ARRAY, methodBody);
+ TryCatchStatement tryCatch = tryCatchS(handleMissing);
+ tryCatch.addCatch(catchS(catchParam, throwS(newException)));
+
+ innerClass.addSyntheticMethod(methodName, modifiers, returnType, parameters, ClassNode.EMPTY_ARRAY, tryCatch);
// if there is a user-defined method, add compiler error and continue
} else if (isStatic(innerClass) && (method.getModifiers() & ACC_SYNTHETIC) == 0) {
diff --git a/src/test/groovy/bugs/Groovy4006.groovy b/src/test/groovy/bugs/Groovy4006.groovy
new file mode 100644
index 0000000000..5fdad19a2f
--- /dev/null
+++ b/src/test/groovy/bugs/Groovy4006.groovy
@@ -0,0 +1,142 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package bugs
+
+import org.junit.jupiter.api.Test
+
+import static groovy.test.GroovyAssert.shouldFail
+
+final class Groovy4006 {
+
+ @Test
+ void testOuterThisReferenceImplicitPassingToInnerClassConstructorNoArg() {
+ def ex = shouldFail RuntimeException, '''
+ class MyOuterClass4006V1 {
+ def outerName = 'OC1'
+ def foo() {
+ def ic = new MyInnerClass4006V1()
+ ic.bar()
+ }
+ class MyInnerClass4006V1 {
+ def innerName
+ MyInnerClass4006V1() {
+ this.innerName = 'IC1'
+ }
+ def bar() {
+ assert this.innerName == 'IC1'
+ assert this.outerName == 'OC1'
+ this.outerName = 'OC1New'
+ assert this.outerName == 'OC1New'
+ throw new RuntimeException('V1 - Inner class now successfully refers to implicitly passed outer this reference!')
+ }
+ }
+ }
+ def oc = new MyOuterClass4006V1()
+ oc.foo()
+ '''
+ assert ex.message == 'V1 - Inner class now successfully refers to implicitly passed outer this reference!'
+ }
+
+ @Test
+ void testOuterThisReferenceImplicitPassingToInnerClassConstructorWithArg() {
+ def ex = shouldFail RuntimeException, '''
+ class MyOuterClass4006V2 {
+ def outerName = 'OC2'
+ def foo() {
+ def ic = new MyInnerClass4006V1('IC2')
+ ic.bar()
+ }
+ class MyInnerClass4006V1 {
+ def innerName
+ MyInnerClass4006V1(innerName) {
+ this.innerName = innerName
+ }
+ def bar() {
+ assert this.innerName == 'IC2'
+ assert this.outerName == 'OC2'
+ this.outerName = 'OC2New'
+ assert this.outerName == 'OC2New'
+ throw new RuntimeException('V2 - Inner class now successfully refers to implicitly passed outer this reference!')
+ }
+ }
+ }
+ def oc = new MyOuterClass4006V2()
+ oc.foo()
+ '''
+ assert ex.message == 'V2 - Inner class now successfully refers to implicitly passed outer this reference!'
+ }
+
+ @Test
+ void testOuterThisReferenceImplicitPassingToInnerClassConstructorWithArgInAProp() {
+ def ex = shouldFail RuntimeException, '''
+ class MyOuterClass4006V3 {
+ def outerName = 'OC3'
+ def icField = new MyInnerClass4006V3('IC3');
+ def foo() {
+ icField.bar()
+ }
+ class MyInnerClass4006V3 {
+ def innerName
+ MyInnerClass4006V3(innerName) {
+ this.innerName = innerName
+ }
+ def bar() {
+ assert this.innerName == 'IC3'
+ assert this.outerName == 'OC3'
+ this.outerName = 'OC3New'
+ assert this.outerName == 'OC3New'
+ throw new RuntimeException('V3 - Inner class now successfully refers to implicitly passed outer this reference!')
+ }
+ }
+ }
+ def oc = new MyOuterClass4006V3()
+ oc.foo()
+ '''
+ assert ex.message == 'V3 - Inner class now successfully refers to implicitly passed outer this reference!'
+ }
+
+ @Test
+ void testOuterThisReferenceImplicitPassingToInnerClassConstructorWithArgInAField() {
+ def ex = shouldFail RuntimeException, '''
+ class MyOuterClass4006V4 {
+ def outerName = 'OC4'
+ private def icField = new MyInnerClass4006V4('IC4');
+ def foo() {
+ icField.bar()
+ }
+ class MyInnerClass4006V4 {
+ def innerName
+ MyInnerClass4006V4(innerName) {
+ this.innerName = innerName
+ }
+ def bar() {
+ assert this.innerName == 'IC4'
+ assert this.outerName == 'OC4'
+ this.outerName = 'OC4New'
+ assert this.outerName == 'OC4New'
+ throw new RuntimeException('V4 - Inner class now successfully refers to implicitly passed outer this reference!')
+ }
+ }
+ }
+ def oc = new MyOuterClass4006V4()
+ oc.foo()
+ '''
+ assert ex.message == 'V4 - Inner class now successfully refers to implicitly passed outer this reference!'
+ }
+}
diff --git a/src/test/groovy/bugs/Groovy4006Bug.groovy b/src/test/groovy/bugs/Groovy4006Bug.groovy
deleted file mode 100644
index f5045605f0..0000000000
--- a/src/test/groovy/bugs/Groovy4006Bug.groovy
+++ /dev/null
@@ -1,151 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-package bugs
-
-import groovy.test.GroovyTestCase
-
-class Groovy4006Bug extends GroovyTestCase {
- void testOuterThisReferenceImplicitPassingToInnerClassConstructorNoArg() {
- try {
- assertScript """
- class MyOuterClass4006V1 {
- def outerName = 'OC1'
- def foo() {
- def ic = new MyInnerClass4006V1()
- ic.bar()
- }
- class MyInnerClass4006V1 {
- def innerName
- MyInnerClass4006V1() {
- this.innerName = 'IC1'
- }
- def bar() {
- assert this.innerName == 'IC1'
- assert this.outerName == 'OC1'
- this.outerName = 'OC1New'
- assert this.outerName == 'OC1New'
- throw new RuntimeException('V1 - Inner class now successfully refers to implicitly passed outer this reference!')
- }
- }
- }
- def oc = new MyOuterClass4006V1()
- oc.foo()
- """
- fail('The script run should have failed with RuntimeException, coming from bar() of inner class')
- } catch (RuntimeException ex) {
- assert ex.message == 'V1 - Inner class now successfully refers to implicitly passed outer this reference!'
- }
- }
-
- void testOuterThisReferenceImplicitPassingToInnerClassConstructorWithArg() {
- try {
- assertScript """
- class MyOuterClass4006V2 {
- def outerName = 'OC2'
- def foo() {
- def ic = new MyInnerClass4006V1('IC2')
- ic.bar()
- }
- class MyInnerClass4006V1 {
- def innerName
- MyInnerClass4006V1(innerName) {
- this.innerName = innerName
- }
- def bar() {
- assert this.innerName == 'IC2'
- assert this.outerName == 'OC2'
- this.outerName = 'OC2New'
- assert this.outerName == 'OC2New'
- throw new RuntimeException('V2 - Inner class now successfully refers to implicitly passed outer this reference!')
- }
- }
- }
- def oc = new MyOuterClass4006V2()
- oc.foo()
- """
- fail('The script run should have failed with RuntimeException, coming from bar() of inner class')
- } catch (RuntimeException ex) {
- assert ex.message == 'V2 - Inner class now successfully refers to implicitly passed outer this reference!'
- }
- }
-
- void testOuterThisReferenceImplicitPassingToInnerClassConstructorWithArgInAProp() {
- try {
- assertScript """
- class MyOuterClass4006V3 {
- def outerName = 'OC3'
- def icField = new MyInnerClass4006V3('IC3');
- def foo() {
- icField.bar()
- }
- class MyInnerClass4006V3 {
- def innerName
- MyInnerClass4006V3(innerName) {
- this.innerName = innerName
- }
- def bar() {
- assert this.innerName == 'IC3'
- assert this.outerName == 'OC3'
- this.outerName = 'OC3New'
- assert this.outerName == 'OC3New'
- throw new RuntimeException('V3 - Inner class now successfully refers to implicitly passed outer this reference!')
- }
- }
- }
- def oc = new MyOuterClass4006V3()
- oc.foo()
- """
- fail('The script run should have failed with RuntimeException, coming from bar() of inner class')
- } catch (RuntimeException ex) {
- assert ex.message == 'V3 - Inner class now successfully refers to implicitly passed outer this reference!'
- }
- }
-
- void testOuterThisReferenceImplicitPassingToInnerClassConstructorWithArgInAField() {
- try {
- assertScript """
- class MyOuterClass4006V4 {
- def outerName = 'OC4'
- private def icField = new MyInnerClass4006V4('IC4');
- def foo() {
- icField.bar()
- }
- class MyInnerClass4006V4 {
- def innerName
- MyInnerClass4006V4(innerName) {
- this.innerName = innerName
- }
- def bar() {
- assert this.innerName == 'IC4'
- assert this.outerName == 'OC4'
- this.outerName = 'OC4New'
- assert this.outerName == 'OC4New'
- throw new RuntimeException('V4 - Inner class now successfully refers to implicitly passed outer this reference!')
- }
- }
- }
- def oc = new MyOuterClass4006V4()
- oc.foo()
- """
- fail('The script run should have failed with RuntimeException, coming from bar() of inner class')
- } catch (RuntimeException ex) {
- assert ex.message == 'V4 - Inner class now successfully refers to implicitly passed outer this reference!'
- }
- }
-}
diff --git a/src/test/groovy/org/codehaus/groovy/util/ReferenceManagerTest.groovy b/src/test/groovy/org/codehaus/groovy/util/ReferenceManagerTest.groovy
index 0e518890f0..44de389707 100644
--- a/src/test/groovy/org/codehaus/groovy/util/ReferenceManagerTest.groovy
+++ b/src/test/groovy/org/codehaus/groovy/util/ReferenceManagerTest.groovy
@@ -110,13 +110,12 @@ final class ReferenceManagerTest {
// Populate queue with enough references that call back into removeStallEntries
// so that would normally generate a StackOverflowError
10000.times {
- TestReference<Object> ref = new TestReference<Object>(new Object(), new Finalizable() {
+ queue.add(new TestReference<>(new Object(), new Finalizable() {
@Override
void finalizeReference() {
callback.removeStallEntries()
}
- })
- queue.add(ref)
+ }))
}
callback.removeStallEntries()
// Success if we made it this far with no StackOverflowError