How to use

redirect

method

in

org.codehaus.groovy.ast.ClassNode

public OptimizingBooleanExpression(final Expression expression, final ClassNode type) {
  super(expression);
  this.expression = expression;
  // we must use the redirect node, otherwise InnerClassNode would not have the "correct" type
  this.type = type.redirect();
}

/**
 * Sets the superclass of this ClassNode
 */
public void setSuperClass(ClassNode superClass) {
  redirect().superClass = superClass;
}

public List<PropertyNode> getProperties() {
  final ClassNode r = redirect();
  if (r.properties == null)
    r.properties = new ArrayList<PropertyNode> ();
  return r.properties;
}

public static ClassNode getUnwrapper(ClassNode cn) {
  cn = cn.redirect();
  if (isPrimitiveType(cn)) return cn;
  ClassNode result = WRAPPER_TYPE_TO_PRIMITIVE_TYPE_MAP.get(cn);
  if (null != result) {
    return result;
  }
  return cn;
}

private ClassNode(ClassNode componentType) {
  this(componentType.getName()+"[]", ACC_PUBLIC, ClassHelper.OBJECT_TYPE);
  this.componentType = componentType.redirect();
  isPrimaryNode=false;
}

public void setInterfaces(ClassNode[] interfaces) {
  if (redirect!=null) {
    redirect().setInterfaces(interfaces);
  } else {
    this.interfaces = interfaces;
  }
}

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

public List<ConstructorNode> getDeclaredConstructors() {
  if (redirect != null) return redirect().getDeclaredConstructors();
  lazyClassInit();
  if (constructors == null)
    constructors = new ArrayList<ConstructorNode> ();
  return constructors;
}

/**
 * Finds a field matching the given name in this class.
 *
 * @param name the name of the field of interest
 * @return the method matching the given name and parameters or null
 */
public FieldNode getDeclaredField(String name) {
  if (redirect != null) return redirect().getDeclaredField(name);
  lazyClassInit();
  return fieldIndex == null ? null : fieldIndex.get(name);
}

/**
 * Detect whether a given ClassNode is a inner class (non-static).
 *
 * @param cNode the ClassNode of interest
 * @return true if the given node is a (non-static) inner class, else false
 */
public static boolean isInnerClass(ClassNode cNode) {
  return cNode.redirect().getOuterClass() != null
      && !Modifier.isStatic(cNode.getModifiers());
}

public void addMethod(MethodNode node) {
  node.setDeclaringClass(this);
  ClassNode base = redirect();
  if (base.methodsList.isEmpty()) {
    base.methodsList = new ArrayList<MethodNode>();
  }
  base.methodsList.add(node);
  base.methods.put(node.getName(), node);
}

/**
 * @return the array of interfaces which this ClassNode implements
 */
public ClassNode[] getInterfaces() {
  if (redirect!=null) return redirect().getInterfaces();
  lazyClassInit();
  return interfaces;
}

public FieldNode addField(String name, int modifiers, ClassNode type, Expression initialValue) {
  FieldNode node = new FieldNode(name, modifiers, type, redirect(), initialValue);
  addField(node);
  return node;
}

/**
 * @return the ClassNode of the super class of this type
 */
public ClassNode getSuperClass() {
  if (!lazyInitDone && !isResolved()) {
    throw new GroovyBugError("ClassNode#getSuperClass for "+getName()+" called before class resolving");
  }
  ClassNode sn = redirect().getUnresolvedSuperClass();
  if (sn!=null) sn=sn.redirect();
  return sn;
}

public boolean equals(Object o) {
  if (redirect!=null) return redirect().equals(o);
  if (!(o instanceof ClassNode)) return false;
  ClassNode cn = (ClassNode) o;
  return (cn.getText().equals(getText()));
}

public ClassNode getPlainNodeReference() {
  if (ClassHelper.isPrimitiveType(this)) return this;
  ClassNode n = new ClassNode(name, modifiers, superClass,null,null);
  n.isPrimaryNode = false;
  n.setRedirect(redirect());
  if (isArray()) {
    n.componentType = redirect().getComponentType();
  } 
  return n;
}

public static ClassNode resolveClassNodeGenerics(Map<GenericsTypeName, GenericsType> resolvedPlaceholders, final Map<GenericsTypeName, GenericsType> placeholdersFromContext, ClassNode currentType) {
  ClassNode target = currentType.redirect();
  resolvedPlaceholders = new HashMap<GenericsTypeName, GenericsType>(resolvedPlaceholders);
  applyContextGenerics(resolvedPlaceholders, placeholdersFromContext);
  Map<GenericsTypeName, GenericsType> connections = new HashMap<GenericsTypeName, GenericsType>();
  extractGenericsConnections(connections, currentType, target);
  applyGenericsConnections(connections, resolvedPlaceholders);
  currentType = applyGenericsContext(resolvedPlaceholders, currentType);
  return currentType;
}

private static List<AnnotationNode> getStoredTargetList(AnnotationNode aliasAnnotationUsage, SourceUnit source) {
  ClassNode alias = aliasAnnotationUsage.getClassNode().redirect();
  List<AnnotationNode> ret = getMeta(alias);
  return copy(ret, aliasAnnotationUsage);
}

static Map<GenericsTypeName, GenericsType> applyGenericsContextToParameterClass(
    Map<GenericsTypeName, GenericsType> spec, ClassNode parameterUsage
) {
  GenericsType[] gts = parameterUsage.getGenericsTypes();
  if (gts == null) return Collections.EMPTY_MAP;
  GenericsType[] newGTs = applyGenericsContext(spec, gts);
  ClassNode newTarget = parameterUsage.redirect().getPlainNodeReference();
  newTarget.setGenericsTypes(newGTs);
  return GenericsUtils.extractPlaceholders(newTarget);
}

public static boolean missesGenericsTypes(ClassNode cn) {
  if (cn.isArray()) return missesGenericsTypes(cn.getComponentType());
  GenericsType[] cnTypes = cn.getGenericsTypes();
  GenericsType[] rnTypes = cn.redirect().getGenericsTypes();
  if (rnTypes != null && cnTypes == null) return true;
  if (cnTypes != null) {
    for (GenericsType genericsType : cnTypes) {
      if (genericsType.isPlaceholder()) return true;
    }
  }
  return false;
}