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