How to use

getEnclosingConstructor

method

in

java.lang.Class

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();
}