public static Constructor callGetEnclosingConstructor(Class thiz) { return thiz.getEnclosingConstructor(); }
private boolean mayNeedHiddenThis() { Class<?> declaringClass = constructor.getDeclaringClass(); if (declaringClass.getEnclosingConstructor() != null) { // Enclosed in a constructor, needs hidden this return true; } Method enclosingMethod = declaringClass.getEnclosingMethod(); if (enclosingMethod != null) { // Enclosed in a method, if it's not static, must need hidden this. return !Modifier.isStatic(enclosingMethod.getModifiers()); } else { // Strictly, this doesn't necessarily indicate a hidden 'this' in the case of // static initializer. But there seems no way to tell in that case. :( // This may cause issues when an anonymous class is created inside a static initializer, // and the class's constructor's first parameter happens to be the enclosing class. // In such case, we may mistakenly think that the class is within a non-static context // and the first parameter is the hidden 'this'. return declaringClass.getEnclosingClass() != null && !Modifier.isStatic(declaringClass.getModifiers()); } } }
private boolean mayNeedHiddenThis() { Class<?> declaringClass = constructor.getDeclaringClass(); if (declaringClass.getEnclosingConstructor() != null) { // Enclosed in a constructor, needs hidden this return true; } Method enclosingMethod = declaringClass.getEnclosingMethod(); if (enclosingMethod != null) { // Enclosed in a method, if it's not static, must need hidden this. return !Modifier.isStatic(enclosingMethod.getModifiers()); } else { // Strictly, this doesn't necessarily indicate a hidden 'this' in the case of // static initializer. But there seems no way to tell in that case. :( // This may cause issues when an anonymous class is created inside a static initializer, // and the class's constructor's first parameter happens to be the enclosing class. // In such case, we may mistakenly think that the class is within a non-static context // and the first parameter is the hidden 'this'. return declaringClass.getEnclosingClass() != null && !Modifier.isStatic(declaringClass.getModifiers()); } } }
/** * Tests whether the class represented by this {@code Class} is defined * locally. */ public boolean isLocalClass() { boolean enclosed = (getEnclosingMethod() != null || getEnclosingConstructor() != null); return enclosed && !isAnonymousClass(); }
private boolean mayNeedHiddenThis() { Class<?> declaringClass = constructor.getDeclaringClass(); if (declaringClass.getEnclosingConstructor() != null) { // Enclosed in a constructor, needs hidden this return true; } Method enclosingMethod = declaringClass.getEnclosingMethod(); if (enclosingMethod != null) { // Enclosed in a method, if it's not static, must need hidden this. return !Modifier.isStatic(enclosingMethod.getModifiers()); } else { // Strictly, this doesn't necessarily indicate a hidden 'this' in the case of // static initializer. But there seems no way to tell in that case. :( // This may cause issues when an anonymous class is created inside a static initializer, // and the class's constructor's first parameter happens to be the enclosing class. // In such case, we may mistakenly think that the class is within a non-static context // and the first parameter is the hidden 'this'. return declaringClass.getEnclosingClass() != null && !Modifier.isStatic(declaringClass.getModifiers()); } } }
private static GenericDeclaration nextLayer(GenericDeclaration decl) { if (decl instanceof Class) { // FIXME: Is the following hierarchy correct?: Class cl = (Class)decl; // RoboVM note: Start of change. Do what the old 4.1.1 code did instead // of AnnotationAccess.getEnclosingMethodOrConstructor(cl) in 4.4.3. decl = cl.getEnclosingMethod(); if (decl != null) { return decl; } decl = cl.getEnclosingConstructor(); if (decl != null) { return decl; } // RoboVM note: End of change, return cl.getEnclosingClass(); } else if (decl instanceof Method) { return ((Method)decl).getDeclaringClass(); } else if (decl instanceof Constructor) { return ((Constructor)decl).getDeclaringClass(); } else { throw new AssertionError(); } }
private boolean mayNeedHiddenThis() { Class<?> declaringClass = constructor.getDeclaringClass(); if (declaringClass.getEnclosingConstructor() != null) { // Enclosed in a constructor, needs hidden this return true; } Method enclosingMethod = declaringClass.getEnclosingMethod(); if (enclosingMethod != null) { // Enclosed in a method, if it's not static, must need hidden this. return !Modifier.isStatic(enclosingMethod.getModifiers()); } else { // Strictly, this doesn't necessarily indicate a hidden 'this' in the case of // static initializer. But there seems no way to tell in that case. :( // This may cause issues when an anonymous class is created inside a static initializer, // and the class's constructor's first parameter happens to be the enclosing class. // In such case, we may mistakenly think that the class is within a non-static context // and the first parameter is the hidden 'this'. return declaringClass.getEnclosingClass() != null && !Modifier.isStatic(declaringClass.getModifiers()); } } }
/** * {@inheritDoc} */ public MethodDescription.InDefinedShape getEnclosingMethod() { Method enclosingMethod = type.getEnclosingMethod(); Constructor<?> enclosingConstructor = type.getEnclosingConstructor(); if (enclosingMethod != null) { return new MethodDescription.ForLoadedMethod(enclosingMethod); } else if (enclosingConstructor != null) { return new MethodDescription.ForLoadedConstructor(enclosingConstructor); } else { return MethodDescription.UNDEFINED; } }
/** * Tests whether the class represented by this {@code Class} is defined * locally. */ public boolean isLocalClass() { boolean enclosed = (getEnclosingMethod() != null || getEnclosingConstructor() != null); return enclosed && !isAnonymousClass(); }
/** * Tests whether the class represented by this {@code Class} is defined * locally. */ public boolean isLocalClass() { boolean enclosed = (getEnclosingMethod() != null || getEnclosingConstructor() != null); return enclosed && !isAnonymousClass(); }
/** * Tests whether the class represented by this {@code Class} is defined * locally. */ public boolean isLocalClass() { boolean enclosed = (getEnclosingMethod() != null || getEnclosingConstructor() != null); return enclosed && !isAnonymousClass(); }
private boolean isStaticLocalContainer(Class<?> klass) { Constructor<?> enclosingConstructor = klass.getEnclosingConstructor(); if(enclosingConstructor != null) return Modifier.isStatic(enclosingConstructor.getModifiers()); Method enclosingMethod = klass.getEnclosingMethod(); return Modifier.isStatic(enclosingMethod.getModifiers()); }
/** * Tests whether the class represented by this {@code Class} is defined * locally. */ public boolean isLocalClass() { boolean enclosed = (getEnclosingMethod() != null || getEnclosingConstructor() != null); return enclosed && !isAnonymousClass(); }
/** * Tests whether the class represented by this {@code Class} is defined * locally. */ public boolean isLocalClass() { boolean enclosed = (getEnclosingMethod() != null || getEnclosingConstructor() != null); return enclosed && !isAnonymousClass(); }
@Override public MethodDescription getEnclosingMethod() { Method enclosingMethod = type.getEnclosingMethod(); Constructor<?> enclosingConstructor = type.getEnclosingConstructor(); if (enclosingMethod != null) { return new MethodDescription.ForLoadedMethod(enclosingMethod); } else if (enclosingConstructor != null) { return new MethodDescription.ForLoadedConstructor(enclosingConstructor); } else { return MethodDescription.UNDEFINED; } }
@Test public void getEnclosingConstructor () throws SecurityException, NoSuchMethodException{ if (verifyNoPropertyViolation()){ Class cls = (new ClassTest.TestEnclosedClass()).foo.getClass(); assertTrue(cls.getEnclosingConstructor().getDeclaringClass() == ClassTest.TestEnclosedClass.class); assertEquals(cls.getEnclosingConstructor().getName(), "<init>"); assertNull(cls.getEnclosingMethod()); } }
@JRubyMethod public IRubyObject enclosing_constructor() { Constructor<?> ctor = javaClass().getEnclosingConstructor(); if (ctor != null) { return new JavaConstructor(getRuntime(), ctor); } return getRuntime().getNil(); }
@JRubyMethod public IRubyObject enclosing_constructor() { Constructor<?> ctor = javaClass().getEnclosingConstructor(); if (ctor != null) { return new JavaConstructor(getRuntime(), ctor); } return getRuntime().getNil(); }
@JRubyMethod public IRubyObject enclosing_constructor() { Constructor<?> ctor = javaClass().getEnclosingConstructor(); if (ctor != null) { return new JavaConstructor(getRuntime(), ctor); } return getRuntime().getNil(); }
@JRubyMethod public IRubyObject enclosing_constructor() { Constructor<?> ctor = javaClass().getEnclosingConstructor(); if (ctor != null) { return new JavaConstructor(getRuntime(), ctor); } return getRuntime().getNil(); }