public void startResolving(ClassNode node, SourceUnit source) { this.source = source; visitClass(node); }
this.resolveVisitor = new ResolveVisitor(this); this.staticImportVisitor = new StaticImportVisitor(); this.optimizer = new OptimizerVisitor(this);
MethodNode enclosingMethod = innerClassNode.getEnclosingMethod(); if (null != enclosingMethod) { resolveGenericsHeader(enclosingMethod.getGenericsTypes()); resolveGenericsHeader(node.getGenericsTypes()); currImportNode = importNode; ClassNode type = importNode.getType(); if (resolve(type, false, false, true)) { currImportNode = null; continue; addError("unable to resolve class " + type.getName(), type); if (resolve(type, false, false, true)) continue; String oldTypeName = type.getName(); type.setName(node.getPackageName() + "." + oldTypeName); if (resolve(type, false, false, true)) continue; type.setName(oldTypeName); addError("unable to resolve class " + type.getName(), type); if (resolve(type, true, true, true)) continue; addError("unable to resolve class " + type.getName(), type); if (resolve(type, true, true, true)) continue; addError("unable to resolve class " + type.getName(), type);
private void resolveOrFail(ClassNode type, String msg, ASTNode node) { if (resolve(type)) return; if (resolveToInner(type)) return; addError("unable to resolve class " + type.getName() + " " + msg, node); }
private void resolveOrFail(ClassNode type, ASTNode node, boolean prefereImports) { resolveGenericsTypes(type.getGenericsTypes()); if (prefereImports && resolveAliasFromModule(type)) return; resolveOrFail(type, node); }
protected Expression transformConstructorCallExpression(ConstructorCallExpression cce) { ClassNode type = cce.getType(); resolveOrFail(type, cce); if (Modifier.isAbstract(type.getModifiers())) { addError("You cannot create an instance from the abstract " + getDescription(type) + ".", cce); } return cce.transformExpression(this); }
private boolean resolve(ClassNode type, boolean testModuleImports, boolean testDefaultImports, boolean testStaticInnerClasses) { resolveGenericsTypes(type.getGenericsTypes()); if (type.isResolved() || type.isPrimaryClassNode()) return true; if (type.isArray()) { ClassNode element = type.getComponentType(); boolean resolved = resolve(element, testModuleImports, testDefaultImports, testStaticInnerClasses); if (resolved) { ClassNode cn = element.makeArray(); return resolveNestedClass(type) || resolveFromModule(type, testModuleImports) || resolveFromCompileUnit(type) || resolveFromDefaultImports(type, testDefaultImports) || resolveFromStaticInnerClasses(type, testStaticInnerClasses) || resolveFromClassCache(type) || resolveToClass(type) || resolveToScript(type);
inPropertyExpression = true; isTopLevelProperty = (objectExpression.getClass() != PropertyExpression.class); objectExpression = transform(objectExpression); Expression property = transform(pe.getProperty()); isTopLevelProperty = itlp; inPropertyExpression = ipe; pe.setSourcePosition(old); String className = lookupClassName(pe); if (className != null) { ClassNode type = ClassHelper.make(className); if (resolve(type)) { Expression ret = new ClassExpression(type); ret.setSourcePosition(pe); while (classNode != null) { ClassNode type = new ConstructedNestedClass(classNode, pe.getPropertyAsString()); if (resolve(type, false, false, false)) { if (classNode == ce.getType() || isVisibleNestedClass(type, ce.getType())) { Expression ret = new ClassExpression(type); ret.setSourcePosition(ce); checkThisAndSuperAsPropertyAccess(pe); if (isTopLevelProperty) ret = correctClassClassChain(pe); return ret;
private boolean resolve(ClassNode type, boolean testModuleImports, boolean testDefaultImports, boolean testStaticInnerClasses) { resolveGenericsTypes(type.getGenericsTypes()); if (type.isResolved() || type.isPrimaryClassNode()) return true; if (type.isArray()) { ClassNode element = type.getComponentType(); boolean resolved = resolve(element, testModuleImports, testDefaultImports, testStaticInnerClasses); if (resolved) { ClassNode cn = element.makeArray(); return resolveNestedClass(type) || resolveFromModule(type, testModuleImports) || resolveFromCompileUnit(type) || resolveFromDefaultImports(type, testDefaultImports) || resolveFromStaticInnerClasses(type, testStaticInnerClasses) || resolveToOuter(type);
return resolveAliasFromModule(type); if (resolveAliasFromModule(type)) return true; if (resolve(tmp, false, false, false)) { ambiguousClass(type, tmp, name); type.setRedirect(tmp.redirect()); return true; if (importNode.getFieldName().equals(name)) { ClassNode tmp = new ConstructedNestedClass(importNode.getType(), name); if (resolve(tmp, false, false, true)) { if ((tmp.getModifiers() & Opcodes.ACC_STATIC) != 0) { type.setRedirect(tmp.redirect()); if (resolve(tmp, false, false, true)) { ambiguousClass(type, tmp, name); type.setRedirect(tmp.redirect()); return true; if (resolve(tmp, false, false, true)) { if ((tmp.getModifiers() & Opcodes.ACC_STATIC) != 0) { ambiguousClass(type, tmp, name); type.setRedirect(tmp.redirect()); return true;
public void visitAnnotations(AnnotatedNode node) { List<AnnotationNode> annotations = node.getAnnotations(); if (annotations.isEmpty()) return; Map<String, AnnotationNode> tmpAnnotations = new HashMap<String, AnnotationNode>(); ClassNode annType; for (AnnotationNode an : annotations) { // skip built-in properties if (an.isBuiltIn()) continue; annType = an.getClassNode(); resolveOrFail(annType, ", unable to find class for annotation", an); for (Map.Entry<String, Expression> member : an.getMembers().entrySet()) { Expression newValue = transform(member.getValue()); Expression adjusted = transformInlineConstants(newValue); member.setValue(adjusted); checkAnnotationMemberValue(adjusted); } if (annType.isResolved()) { Class annTypeClass = annType.getTypeClass(); Retention retAnn = (Retention) annTypeClass.getAnnotation(Retention.class); if (retAnn != null && retAnn.value().equals(RetentionPolicy.RUNTIME) && !isRepeatable(annTypeClass)) { // remember runtime/non-repeatable annos (auto collecting of Repeatable annotations is handled elsewhere) AnnotationNode anyPrevAnnNode = tmpAnnotations.put(annTypeClass.getName(), an); if (anyPrevAnnNode != null) { addError("Cannot specify duplicate annotation on the same member : " + annType.getName(), an); } } } } }
public void visitAnnotations(AnnotatedNode node) { Map annotionMap = node.getAnnotations(); if (annotionMap.isEmpty()) return; Iterator it = annotionMap.values().iterator(); while (it.hasNext()) { AnnotationNode an = (AnnotationNode) it.next(); //skip builtin properties if (an.isBuiltIn()) continue; ClassNode type = an.getClassNode(); resolveOrFail(type, ", unable to find class for annotation", an); for (Iterator iter = an.getMembers().entrySet().iterator(); iter.hasNext();) { Map.Entry member = (Map.Entry) iter.next(); Expression memberValue = (Expression) member.getValue(); Expression newValue = transform(memberValue); member.setValue(newValue); if (newValue instanceof PropertyExpression) { PropertyExpression pe = (PropertyExpression) newValue; if (!(pe.getObjectExpression() instanceof ClassExpression)) { addError("unable to find class for enum",pe.getObjectExpression()); } } } } }
protected Expression transformDeclarationExpression(DeclarationExpression de) { Expression oldLeft = de.getLeftExpression(); Expression left = transform(oldLeft); if (left != oldLeft) { ClassExpression ce = (ClassExpression) left; addError("you tried to assign a value to the class " + ce.getType().getName(), oldLeft); return de; } Expression right = transform(de.getRightExpression()); if (right == de.getRightExpression()) return de; DeclarationExpression newDeclExpr = new DeclarationExpression((VariableExpression) left, de.getOperation(), right); newDeclExpr.setSourcePosition(de); return newDeclExpr; }
protected Expression transformDeclarationExpression(DeclarationExpression de) { visitAnnotations(de); Expression oldLeft = de.getLeftExpression(); checkingVariableTypeInDeclaration = true; Expression left = transform(oldLeft); checkingVariableTypeInDeclaration = false; if (left instanceof ClassExpression) { ClassExpression ce = (ClassExpression) left; addError("you tried to assign a value to the class " + ce.getType().getName(), oldLeft); return de; } Expression right = transform(de.getRightExpression()); if (right == de.getRightExpression()) { fixDeclaringClass(de); return de; } DeclarationExpression newDeclExpr = new DeclarationExpression(left, de.getOperation(), right); newDeclExpr.setDeclaringClass(de.getDeclaringClass()); fixDeclaringClass(newDeclExpr); newDeclExpr.setSourcePosition(de); newDeclExpr.addAnnotations(de.getAnnotations()); return newDeclExpr; }
private void resolveGenericsHeader(GenericsType[] types) { if (types == null) return; currentClass.setUsingGenerics(true); for (int i = 0; i < types.length; i++) { ClassNode type = types[i].getType(); String name = type.getName(); ClassNode[] bounds = types[i].getUpperBounds(); if (bounds != null) { boolean nameAdded = false; for (int j = 0; j < bounds.length; j++) { ClassNode upperBound = bounds[j]; if (!nameAdded && upperBound != null || !resolve(type)) { genericParameterNames.put(name, types[i]); types[i].setPlaceholder(true); type.setRedirect(upperBound); nameAdded = true; } resolveOrFail(upperBound, type); } } else { genericParameterNames.put(name, types[i]); type.setRedirect(ClassHelper.OBJECT_TYPE); types[i].setPlaceholder(true); } } }
protected Expression transformVariableExpression(VariableExpression ve) { visitAnnotations(ve); Variable v = ve.getAccessedVariable(); t = new LowerCaseClass(name); isClass = resolve(t); if(!isClass) { isClass = resolveToNestedOfCurrentClassAndSuperClasses(t); resolveOrFail(ve.getType(), ve); ClassNode origin = ve.getOriginType(); if (origin!=ve.getType()) resolveOrFail(origin, ve); return ve;
private boolean resolve(ClassNode type) { return resolve(type, true, true, true); }
for (ClassNode upperBound : bounds) { if (!isWild) { if (!nameAdded && upperBound != null || !resolve(classNode)) { if (toDealWithGenerics) { genericParameterNames.put(gtn, type); ClassNode upperBound = tp.getFirst(); ClassNode classNode = tp.getSecond(); resolveOrFail(upperBound, classNode); ClassNode upperBound = tp.getFirst(); GenericsType gt = tp.getSecond(); resolveGenericsHeader(upperBound.getGenericsTypes(), 0 == level ? gt : rootType, level + 1);
private boolean resolveToInner (ClassNode type) { // we do not do our name mangling to find an inner class // if the type is a ConstructedClassWithPackage, because in this case we // are resolving the name at a different place already if (type instanceof ConstructedClassWithPackage) return false; String name = type.getName(); String saved = name; while (true) { int len = name.lastIndexOf('.'); if (len == -1) break; name = name.substring(0,len) + "$" + name.substring(len+1); type.setName(name); if (resolve(type)) return true; } if(resolveToInnerEnum (type)) return true; type.setName(saved); return false; }
private boolean resolveFromStaticInnerClasses(ClassNode type, boolean testStaticInnerClasses) { // a class consisting of a vanilla name can never be // a static inner class, because at least one dot is // required for this. Example: foo.bar -> foo$bar if (type instanceof LowerCaseClass) return false; // try to resolve a public static inner class' name testStaticInnerClasses &= type.hasPackageName(); if (testStaticInnerClasses) { if (type instanceof ConstructedClassWithPackage) { // we replace '.' only in the className part // with '$' to find an inner class. The case that // the packageis really a class is handled else where ConstructedClassWithPackage tmp = (ConstructedClassWithPackage) type; String name = ((ConstructedClassWithPackage) type).className; tmp.className = replaceLastPoint(name); if (resolve(tmp, false, true, true)) { type.setRedirect(tmp.redirect()); return true; } tmp.className = name; } else { String name = type.getName(); String replacedPointType = replaceLastPoint(name); type.setName(replacedPointType); if (resolve(type, false, true, true)) return true; type.setName(name); } } return false; }