Tabnine Logo
ClassNode.getInnerClasses
Code IndexAdd Tabnine to your IDE (free)

How to use
getInnerClasses
method
in
org.codehaus.groovy.ast.ClassNode

Best Java code snippets using org.codehaus.groovy.ast.ClassNode.getInnerClasses (Showing top 20 results out of 315)

origin: org.codehaus.groovy/groovy

private static boolean isExtended(ClassNode owner, Iterator<InnerClassNode> classes) {
  while (classes.hasNext()) {
    InnerClassNode next =  classes.next();
    if (next!=owner && next.isDerivedFrom(owner)) return true;
  }
  if (owner.getInnerClasses().hasNext()) {
    return isExtended(owner, owner.getInnerClasses());
  }
  return false;
}
origin: org.codehaus.groovy/groovy

@Override
public void visitClass(final ClassNode node) {
  ClassNode prec = classNode;
  classNode = node;
  super.visitClass(node);
  Iterator<InnerClassNode> innerClasses = classNode.getInnerClasses();
  while (innerClasses.hasNext()) {
    InnerClassNode innerClassNode = innerClasses.next();
    visitClass(innerClassNode);
  }
  classNode = prec;
}
origin: org.codehaus.groovy/groovy

private void addPrivateFieldAndMethodAccessors(ClassNode node) {
  addPrivateBridgeMethods(node);
  addPrivateFieldsAccessors(node);
  Iterator<InnerClassNode> it = node.getInnerClasses();
  while (it.hasNext()) {
    addPrivateFieldAndMethodAccessors(it.next());
  }
}
origin: org.codehaus.groovy/groovy

private boolean helperClassNotCreatedYet(final ClassNode traitReceiver) {
  return !traitReceiver.redirect().getInnerClasses().hasNext()
      && this.unit.getAST().getClasses().contains(traitReceiver.redirect());
}
private boolean isTraitSuperPropertyExpression(Expression exp) {
origin: org.codehaus.groovy/groovy

protected void createInterfaceSyntheticStaticFields() {
  ClassNode icl =  controller.getInterfaceClassLoadingClass();
  if (referencedClasses.isEmpty()) {
    Iterator<InnerClassNode> it = icl.getOuterClass().getInnerClasses();
    while(it.hasNext()) {
      InnerClassNode inner = it.next();
      if (inner==icl) {
        it.remove();
        return;
      }
    }
    return;
  }
  addInnerClass(icl);
  for (Map.Entry<String, ClassNode> entry : referencedClasses.entrySet()) {            // generate a field node
    String staticFieldName = entry.getKey();
    ClassNode cn = entry.getValue();
    icl.addField(staticFieldName, ACC_STATIC + ACC_SYNTHETIC, ClassHelper.CLASS_Type.getPlainNodeReference(), new ClassExpression(cn));
  }
}
origin: org.codehaus.groovy/groovy

private void checkInnerClasses(final ClassNode cNode) {
  Iterator<InnerClassNode> it = cNode.getInnerClasses();
  while (it.hasNext()) {
    InnerClassNode origin = it.next();
    if ((origin.getModifiers() & ACC_STATIC) == 0) {
      unit.addError(new SyntaxException("Cannot have non-static inner class inside a trait ("+origin.getName()+")", origin.getLineNumber(), origin.getColumnNumber()));
    }
  }
}
origin: org.codehaus.groovy/groovy

public void visitClass(ClassNode node) {
  // AIC are already done, doing them here again will lead to wrong scopes
  if (node instanceof InnerClassNode) {
    InnerClassNode in = (InnerClassNode) node;
    if (in.isAnonymous() && !in.isEnum()) return;
  }
  pushState();
  prepareVisit(node);
  super.visitClass(node);
  if (recurseInnerClasses) {
    Iterator<InnerClassNode> innerClasses = node.getInnerClasses();
    while (innerClasses.hasNext()) {
      visitClass(innerClasses.next());
    }
  }
  popState();
}
origin: org.codehaus.groovy/groovy

ClassNode fieldHelperClassNode = null;
ClassNode staticFieldHelperClassNode = null;
Iterator<InnerClassNode> innerClasses = trait.redirect().getInnerClasses();
if (innerClasses != null && innerClasses.hasNext()) {
origin: org.codehaus.groovy/groovy

printMethods(out, classNode, isEnum);
for (Iterator<InnerClassNode> inner = classNode.getInnerClasses(); inner.hasNext(); ) {
origin: org.codehaus.groovy/groovy

@Override
public void visitClass(ClassNode node) {
  this.classNode = node;
  thisField = null;
  InnerClassNode innerClass = null;
  if (!node.isEnum() && !node.isInterface() && node instanceof InnerClassNode) {
    innerClass = (InnerClassNode) node;
    thisField = innerClass.getField("this$0");
    if (innerClass.getVariableScope() == null && innerClass.getDeclaredConstructors().isEmpty()) {
      // add dummy constructor
      innerClass.addConstructor(ACC_PUBLIC, Parameter.EMPTY_ARRAY, null, null);
    }
  }
  if (node.isEnum() || node.isInterface()) return;
  // use Iterator.hasNext() to check for available inner classes
  if (node.getInnerClasses().hasNext()) addDispatcherMethods(node);
  if (innerClass == null) return;
  super.visitClass(node);
  addDefaultMethods(innerClass);
}
origin: org.codehaus.groovy/groovy

private void processClass(ClassNode cNode, final ClassCodeVisitorSupport visitor) {
  if (!isEnabled(cNode)) return;
  if (cNode.isInterface()) {
    addError("Error processing interface '" + cNode.getName() +
        "'. " + MY_TYPE_NAME + " only allowed for classes.", cNode);
    return;
  }
  for (ConstructorNode cn : cNode.getDeclaredConstructors()) {
    if (hasNoExplicitAutoFinal(cn)) {
      processConstructorOrMethod(cn, visitor);
    }
  }
  for (MethodNode mn : cNode.getAllDeclaredMethods()) {
    if (hasNoExplicitAutoFinal(mn)) {
      processConstructorOrMethod(mn, visitor);
    }
  }
  Iterator<InnerClassNode> it = cNode.getInnerClasses();
  while (it.hasNext()) {
    InnerClassNode in = it.next();
    if (in.getAnnotations(MY_TYPE).isEmpty()) {
      processClass(in, visitor);
    }
  }
  visitor.visitClass(cNode);
}
origin: org.codehaus.groovy/groovy

typeCheckingContext.alreadyVisitedMethods = new LinkedHashSet<MethodNode>();
super.visitClass(node);
Iterator<InnerClassNode> innerClasses = node.getInnerClasses();
while (innerClasses.hasNext()) {
  InnerClassNode innerClassNode = innerClasses.next();
origin: org.codehaus.groovy/groovy

@Override
public void visitClass(final ClassNode node) {
  boolean skip = shouldSkipClassNode(node);
  if (!skip && !anyMethodSkip(node)) {
    node.putNodeMetaData(MopWriter.Factory.class, StaticCompilationMopWriter.FACTORY);
  }
  ClassNode oldCN = classNode;
  classNode = node;
  Iterator<InnerClassNode> innerClasses = classNode.getInnerClasses();
  while (innerClasses.hasNext()) {
    InnerClassNode innerClassNode = innerClasses.next();
    boolean innerStaticCompile = !(skip || isSkippedInnerClass(innerClassNode));
    innerClassNode.putNodeMetaData(STATIC_COMPILE_NODE, innerStaticCompile);
    innerClassNode.putNodeMetaData(WriterControllerFactory.class, node.getNodeMetaData(WriterControllerFactory.class));
    if (innerStaticCompile && !anyMethodSkip(innerClassNode)) {
      innerClassNode.putNodeMetaData(MopWriter.Factory.class, StaticCompilationMopWriter.FACTORY);
    }
  }
  super.visitClass(node);
  addPrivateFieldAndMethodAccessors(node);
  if (isStaticallyCompiled(node)) addDynamicOuterClassAccessorsCallback(node.getOuterClass());
  classNode = oldCN;
}
origin: org.codehaus.groovy/groovy

if (context == null || context.phase < phase || (context.phase == phase && !context.phaseComplete)) {
  int offset = 1;
  for (Iterator<InnerClassNode> iterator = classNode.getInnerClasses(); iterator.hasNext(); ) {
    iterator.next();
    offset++;
origin: org.codehaus.groovy/groovy

Iterator<InnerClassNode> innerClasses = node.getInnerClasses();
if (innerClasses.hasNext()) {
  thatType = innerClasses.next();
origin: org.codehaus.groovy/groovy

for (Iterator<InnerClassNode> iter = classNode.getInnerClasses(); iter.hasNext();) {
  InnerClassNode innerClass = iter.next();
  makeInnerClassEntry(innerClass);
origin: org.codehaus.groovy/groovy

  || (top instanceof InnerClassNode
  && Modifier.isPrivate(top.getModifiers())
  && !isExtended(top, top.getOuterClass().getInnerClasses()))
  ) {
CompareToNullExpression expr = new CompareToNullExpression(
origin: org.codehaus.groovy/groovy-macro

@Override
public void visitClass(final ClassNode node) {
  super.visitClass(node);
  Iterator<InnerClassNode> it = node.getInnerClasses();
  while (it.hasNext()) {
    InnerClassNode next = it.next();
    visitClass(next);
  }
}
origin: com.thinkaurelius.groovy-shaded-asm/groovy-shaded-asm

protected void createInterfaceSyntheticStaticFields() {
  ClassNode icl =  controller.getInterfaceClassLoadingClass();
  if (referencedClasses.isEmpty()) {
    Iterator<InnerClassNode> it = controller.getClassNode().getInnerClasses();
    while(it.hasNext()) {
      InnerClassNode inner = it.next();
      if (inner==icl) {
        it.remove();
        return;
      }
    }
    return;
  }
  addInnerClass(icl);
  for (String staticFieldName : referencedClasses.keySet()) {            // generate a field node
    icl.addField(staticFieldName, ACC_STATIC + ACC_SYNTHETIC, ClassHelper.CLASS_Type.getPlainNodeReference(), new ClassExpression(referencedClasses.get(staticFieldName)));
  }
}
origin: com.thinkaurelius.groovy-shaded-asm/groovy-shaded-asm

if (context == null || context.phase < phase || (context.phase == phase && !context.phaseComplete)) {
  int offset = 1;
  Iterator<InnerClassNode> iterator = classNode.getInnerClasses();
  while (iterator.hasNext()) {
    iterator.next();
org.codehaus.groovy.astClassNodegetInnerClasses

Popular methods of ClassNode

  • getName
  • getMethods
    This methods creates a list of all methods with this name of the current class and of all super clas
  • <init>
    Constructor used by makeArray() if no real class is available
  • getSuperClass
  • equals
  • addMethod
  • getAnnotations
  • addField
  • getFields
    Returns a list containing FieldNode objects for each field in the class represented by this ClassNod
  • getPlainNodeReference
  • getField
    Finds a field matching the given name in this class or a parent class.
  • getMethod
    Finds a method matching the given name and parameters in this class or any parent class.
  • getField,
  • getMethod,
  • isInterface,
  • getNameWithoutPackage,
  • isScript,
  • getDeclaredMethod,
  • getGenericsTypes,
  • getDeclaredConstructors,
  • getModifiers,
  • getTypeClass

Popular in Java

  • Parsing JSON documents to java classes using gson
  • getExternalFilesDir (Context)
  • getContentResolver (Context)
  • onRequestPermissionsResult (Fragment)
  • Rectangle (java.awt)
    A Rectangle specifies an area in a coordinate space that is enclosed by the Rectangle object's top-
  • SimpleDateFormat (java.text)
    Formats and parses dates in a locale-sensitive manner. Formatting turns a Date into a String, and pa
  • HashSet (java.util)
    HashSet is an implementation of a Set. All optional operations (adding and removing) are supported.
  • StringTokenizer (java.util)
    Breaks a string into tokens; new code should probably use String#split.> // Legacy code: StringTo
  • UUID (java.util)
    UUID is an immutable representation of a 128-bit universally unique identifier (UUID). There are mul
  • Handler (java.util.logging)
    A Handler object accepts a logging request and exports the desired messages to a target, for example
  • Github Copilot alternatives
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now