| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| package org.codehaus.groovy.control; |
| |
| import groovy.lang.Tuple2; |
| import org.apache.groovy.ast.tools.ExpressionUtils; |
| import org.codehaus.groovy.GroovyBugError; |
| import org.codehaus.groovy.ast.ASTNode; |
| import org.codehaus.groovy.ast.AnnotatedNode; |
| import org.codehaus.groovy.ast.AnnotationNode; |
| import org.codehaus.groovy.ast.ClassCodeExpressionTransformer; |
| import org.codehaus.groovy.ast.ClassHelper; |
| import org.codehaus.groovy.ast.ClassNode; |
| import org.codehaus.groovy.ast.CompileUnit; |
| import org.codehaus.groovy.ast.CompileUnit.ConstructedOuterNestedClassNode; |
| import org.codehaus.groovy.ast.DynamicVariable; |
| import org.codehaus.groovy.ast.FieldNode; |
| import org.codehaus.groovy.ast.GenericsType; |
| import org.codehaus.groovy.ast.GenericsType.GenericsTypeName; |
| import org.codehaus.groovy.ast.ImportNode; |
| import org.codehaus.groovy.ast.InnerClassNode; |
| import org.codehaus.groovy.ast.MethodNode; |
| import org.codehaus.groovy.ast.ModuleNode; |
| import org.codehaus.groovy.ast.Parameter; |
| import org.codehaus.groovy.ast.PropertyNode; |
| import org.codehaus.groovy.ast.Variable; |
| import org.codehaus.groovy.ast.VariableScope; |
| import org.codehaus.groovy.ast.expr.AnnotationConstantExpression; |
| import org.codehaus.groovy.ast.expr.ArgumentListExpression; |
| import org.codehaus.groovy.ast.expr.BinaryExpression; |
| import org.codehaus.groovy.ast.expr.CastExpression; |
| import org.codehaus.groovy.ast.expr.ClassExpression; |
| import org.codehaus.groovy.ast.expr.ClosureExpression; |
| import org.codehaus.groovy.ast.expr.ConstantExpression; |
| import org.codehaus.groovy.ast.expr.ConstructorCallExpression; |
| import org.codehaus.groovy.ast.expr.DeclarationExpression; |
| import org.codehaus.groovy.ast.expr.Expression; |
| import org.codehaus.groovy.ast.expr.ListExpression; |
| import org.codehaus.groovy.ast.expr.MapEntryExpression; |
| import org.codehaus.groovy.ast.expr.MapExpression; |
| import org.codehaus.groovy.ast.expr.MethodCallExpression; |
| import org.codehaus.groovy.ast.expr.PropertyExpression; |
| import org.codehaus.groovy.ast.expr.SpreadMapExpression; |
| import org.codehaus.groovy.ast.expr.VariableExpression; |
| import org.codehaus.groovy.ast.stmt.BlockStatement; |
| import org.codehaus.groovy.ast.stmt.CatchStatement; |
| import org.codehaus.groovy.ast.stmt.ForStatement; |
| import org.codehaus.groovy.ast.stmt.Statement; |
| import org.codehaus.groovy.control.ClassNodeResolver.LookupResult; |
| import org.codehaus.groovy.runtime.memoize.EvictableCache; |
| import org.codehaus.groovy.runtime.memoize.UnlimitedConcurrentCache; |
| import org.codehaus.groovy.syntax.Types; |
| import org.codehaus.groovy.transform.trait.Traits; |
| import org.objectweb.asm.Opcodes; |
| |
| import java.lang.annotation.Annotation; |
| import java.lang.annotation.Retention; |
| import java.lang.annotation.RetentionPolicy; |
| import java.lang.reflect.Modifier; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.LinkedHashMap; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.ListIterator; |
| import java.util.Map; |
| import java.util.Objects; |
| import java.util.Set; |
| import java.util.function.BiConsumer; |
| import java.util.function.Predicate; |
| |
| import static groovy.lang.Tuple.tuple; |
| import static org.codehaus.groovy.ast.tools.ClosureUtils.getParametersSafe; |
| |
| /** |
| * Visitor to resolve Types and convert VariableExpression to |
| * ClassExpressions if needed. The ResolveVisitor will try to |
| * find the Class for a ClassExpression and prints an error if |
| * it fails to do so. Constructions like C[], foo as C, (C) foo |
| * will force creation of a ClassExpression for C |
| * <p> |
| * Note: the method to start the resolving is startResolving(ClassNode, SourceUnit). |
| */ |
| public class ResolveVisitor extends ClassCodeExpressionTransformer { |
| // note: BigInteger and BigDecimal are also imported by default |
| // `java.util` is used much frequently than other two java packages(`java.io` and `java.net`), so place java.util before the two packages |
| public static final String[] DEFAULT_IMPORTS = {"java.lang.", "java.util.", "java.io.", "java.net.", "groovy.lang.", "groovy.util."}; |
| private static final String BIGINTEGER_STR = "BigInteger"; |
| private static final String BIGDECIMAL_STR = "BigDecimal"; |
| public static final String QUESTION_MARK = "?"; |
| public static final String[] EMPTY_STRING_ARRAY = new String[0]; |
| |
| private ClassNode currentClass; |
| private final CompilationUnit compilationUnit; |
| private SourceUnit source; |
| private VariableScope currentScope; |
| |
| private boolean isTopLevelProperty = true; |
| private boolean inPropertyExpression = false; |
| private boolean inClosure = false; |
| |
| private final Map<ClassNode, ClassNode> possibleOuterClassNodeMap = new HashMap<>(); |
| private Map<GenericsTypeName, GenericsType> genericParameterNames = new HashMap<>(); |
| private final Set<FieldNode> fieldTypesChecked = new HashSet<>(); |
| private boolean checkingVariableTypeInDeclaration; |
| private ImportNode currImportNode; |
| private MethodNode currentMethod; |
| private ClassNodeResolver classNodeResolver; |
| |
| /** |
| * A ConstructedNestedClass consists of an outer class and a name part, denoting a |
| * nested class with an unknown number of levels down. This allows resolve tests to |
| * skip this node for further inner class searches and combinations with imports, since |
| * the outer class we know is already resolved. |
| */ |
| private static class ConstructedNestedClass extends ClassNode { |
| final ClassNode knownEnclosingType; |
| |
| public ConstructedNestedClass(final ClassNode outer, final String inner) { |
| super(outer.getName() + "$" + inner.replace('.', '$'), Opcodes.ACC_PUBLIC, ClassHelper.OBJECT_TYPE); |
| this.knownEnclosingType = outer; |
| this.isPrimaryNode = false; |
| } |
| |
| @Override |
| public String getUnresolvedName() { |
| // outer class (aka knownEnclosingType) may have aliased name that should be reflected here too |
| return super.getUnresolvedName().replace(knownEnclosingType.getName(), knownEnclosingType.getUnresolvedName()); |
| } |
| |
| @Override |
| public boolean hasPackageName() { |
| if (redirect() != this) return super.hasPackageName(); |
| return knownEnclosingType.hasPackageName(); |
| } |
| |
| @Override |
| public String setName(final String name) { |
| if (redirect() != this) { |
| return super.setName(name); |
| } else { |
| throw new GroovyBugError("ConstructedNestedClass#setName should not be called"); |
| } |
| } |
| } |
| |
| /** |
| * we use ConstructedClassWithPackage to limit the resolving the compiler |
| * does when combining package names and class names. The idea |
| * that if we use a package, then we do not want to replace the |
| * '.' with a '$' for the package part, only for the class name |
| * part. There is also the case of a imported class, so this logic |
| * can't be done in these cases... |
| */ |
| private static class ConstructedClassWithPackage extends ClassNode { |
| final String prefix; |
| String className; |
| |
| public ConstructedClassWithPackage(final String pkg, final String name) { |
| super(pkg + name, Opcodes.ACC_PUBLIC, ClassHelper.OBJECT_TYPE); |
| isPrimaryNode = false; |
| this.prefix = pkg; |
| this.className = name; |
| } |
| |
| @Override |
| public String getName() { |
| if (redirect() != this) |
| return super.getName(); |
| return prefix + className; |
| } |
| |
| @Override |
| public boolean hasPackageName() { |
| if (redirect() != this) |
| return super.hasPackageName(); |
| return className.indexOf('.') != -1; |
| } |
| |
| @Override |
| public String setName(final String name) { |
| if (redirect() != this) { |
| return super.setName(name); |
| } else { |
| throw new GroovyBugError("ConstructedClassWithPackage#setName should not be called"); |
| } |
| } |
| } |
| |
| /** |
| * we use LowerCaseClass to limit the resolving the compiler |
| * does for vanilla names starting with a lower case letter. The idea |
| * that if we use a vanilla name with a lower case letter, that this |
| * is in most cases no class. If it is a class the class needs to be |
| * imported explicitly. The effect is that in an expression like |
| * "def foo = bar" we do not have to use a loadClass call to check the |
| * name foo and bar for being classes. Instead we will ask the module |
| * for an alias for this name which is much faster. |
| */ |
| private static class LowerCaseClass extends ClassNode { |
| final String className; |
| |
| public LowerCaseClass(final String name) { |
| super(name, Opcodes.ACC_PUBLIC, ClassHelper.OBJECT_TYPE); |
| isPrimaryNode = false; |
| this.className = name; |
| } |
| |
| @Override |
| public String getName() { |
| if (redirect() != this) |
| return super.getName(); |
| return className; |
| } |
| |
| @Override |
| public boolean hasPackageName() { |
| if (redirect() != this) |
| return super.hasPackageName(); |
| return false; |
| } |
| |
| @Override |
| public String setName(final String name) { |
| if (redirect() != this) { |
| return super.setName(name); |
| } else { |
| throw new GroovyBugError("LowerCaseClass#setName should not be called"); |
| } |
| } |
| } |
| |
| public ResolveVisitor(final CompilationUnit compilationUnit) { |
| this.compilationUnit = compilationUnit; |
| setClassNodeResolver(new ClassNodeResolver()); |
| } |
| |
| public void setClassNodeResolver(final ClassNodeResolver classNodeResolver) { |
| this.classNodeResolver = classNodeResolver; |
| } |
| |
| public void startResolving(final ClassNode node, final SourceUnit source) { |
| this.source = source; |
| visitClass(node); |
| } |
| |
| @Override |
| protected SourceUnit getSourceUnit() { |
| return source; |
| } |
| |
| @Override |
| protected void visitConstructorOrMethod(final MethodNode node, final boolean isConstructor) { |
| VariableScope oldScope = currentScope; |
| currentScope = node.getVariableScope(); |
| Map<GenericsTypeName, GenericsType> oldPNames = genericParameterNames; |
| genericParameterNames = node.isStatic() && !Traits.isTrait(node.getDeclaringClass()) |
| ? new HashMap<>() : new HashMap<>(genericParameterNames); |
| |
| resolveGenericsHeader(node.getGenericsTypes()); |
| |
| Parameter[] paras = node.getParameters(); |
| for (Parameter p : paras) { |
| p.setInitialExpression(transform(p.getInitialExpression())); |
| resolveOrFail(p.getType(), p.getType()); |
| visitAnnotations(p); |
| } |
| ClassNode[] exceptions = node.getExceptions(); |
| for (ClassNode t : exceptions) { |
| resolveOrFail(t, node); |
| } |
| resolveOrFail(node.getReturnType(), node); |
| |
| MethodNode oldCurrentMethod = currentMethod; |
| currentMethod = node; |
| super.visitConstructorOrMethod(node, isConstructor); |
| |
| currentMethod = oldCurrentMethod; |
| genericParameterNames = oldPNames; |
| currentScope = oldScope; |
| } |
| |
| @Override |
| public void visitField(final FieldNode node) { |
| ClassNode t = node.getType(); |
| if (!fieldTypesChecked.contains(node)) { |
| resolveOrFail(t, node); |
| } |
| super.visitField(node); |
| } |
| |
| @Override |
| public void visitProperty(final PropertyNode node) { |
| Map<GenericsTypeName, GenericsType> oldPNames = genericParameterNames; |
| if (node.isStatic() && !Traits.isTrait(node.getDeclaringClass())) { |
| genericParameterNames = new HashMap<>(); |
| } |
| |
| ClassNode t = node.getType(); |
| resolveOrFail(t, node); |
| super.visitProperty(node); |
| fieldTypesChecked.add(node.getField()); |
| |
| genericParameterNames = oldPNames; |
| } |
| |
| private boolean resolveToInner(final 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; |
| if (type instanceof ConstructedNestedClass) return false; |
| String name = type.getName(); |
| String saved = name; |
| while (name.lastIndexOf('.') != -1) { |
| name = replaceLastPointWithDollar(name); |
| type.setName(name); |
| if (resolve(type)) { |
| return true; |
| } |
| } |
| |
| type.setName(saved); |
| return false; |
| } |
| |
| private void resolveOrFail(final ClassNode type, final String msg, final ASTNode node) { |
| if (resolve(type)) return; |
| if (resolveToInner(type)) return; |
| if (resolveToOuterNested(type)) return; |
| |
| addError("unable to resolve class " + type.toString(false) + msg, node); |
| } |
| |
| // GROOVY-7812(#1): Static inner classes cannot be accessed from other files when running by 'groovy' command |
| // if the type to resolve is an inner class and it is in an outer class which is not resolved, |
| // we set the resolved type to a placeholder class node, i.e. a ConstructedOuterNestedClass instance |
| // when resolving the outer class later, we set the resolved type of ConstructedOuterNestedClass instance to the actual inner class node(SEE GROOVY-7812(#2)) |
| private boolean resolveToOuterNested(final ClassNode type) { |
| CompileUnit compileUnit = currentClass.getCompileUnit(); |
| String typeName = type.getName(); |
| |
| BiConsumer<ConstructedOuterNestedClassNode, ClassNode> setRedirectListener = (s, c) -> type.setRedirect(s); |
| |
| ModuleNode module = currentClass.getModule(); |
| for (ImportNode importNode : module.getStaticImports().values()) { |
| String importFieldName = importNode.getFieldName(); |
| String importAlias = importNode.getAlias(); |
| |
| if (!typeName.equals(importAlias)) continue; |
| |
| ConstructedOuterNestedClassNode constructedOuterNestedClassNode = tryToConstructOuterNestedClassNodeViaStaticImport(compileUnit, importNode, importFieldName, setRedirectListener); |
| if (null != constructedOuterNestedClassNode) { |
| compileUnit.addClassNodeToResolve(constructedOuterNestedClassNode); |
| return true; |
| } |
| } |
| |
| for (Map.Entry<String, ClassNode> entry : compileUnit.getClassesToCompile().entrySet()) { |
| ClassNode outerClassNode = entry.getValue(); |
| ConstructedOuterNestedClassNode constructedOuterNestedClassNode = tryToConstructOuterNestedClassNode(type, outerClassNode, setRedirectListener); |
| if (null != constructedOuterNestedClassNode) { |
| compileUnit.addClassNodeToResolve(constructedOuterNestedClassNode); |
| return true; |
| } |
| } |
| |
| boolean toResolveFurther = false; |
| for (ImportNode importNode : module.getStaticStarImports().values()) { |
| ConstructedOuterNestedClassNode constructedOuterNestedClassNode = tryToConstructOuterNestedClassNodeViaStaticImport(compileUnit, importNode, typeName, setRedirectListener); |
| if (null != constructedOuterNestedClassNode) { |
| compileUnit.addClassNodeToResolve(constructedOuterNestedClassNode); |
| toResolveFurther = true; // do not return here to try all static star imports because currently we do not know which outer class the class to resolve is declared in. |
| } |
| } |
| if (toResolveFurther) return true; |
| |
| // GROOVY-9243 |
| toResolveFurther = false; |
| if (typeName.indexOf('.') == -1) { |
| Map<String, ClassNode> hierClasses = findHierClasses(currentClass); |
| for (ClassNode cn : hierClasses.values()) { |
| ConstructedOuterNestedClassNode constructedOuterNestedClassNode = tryToConstructOuterNestedClassNodeForBaseType(compileUnit, typeName, cn, setRedirectListener); |
| if (null != constructedOuterNestedClassNode) { |
| compileUnit.addClassNodeToResolve(constructedOuterNestedClassNode); |
| toResolveFurther = true; |
| } |
| } |
| } |
| |
| return toResolveFurther; |
| } |
| |
| private ConstructedOuterNestedClassNode tryToConstructOuterNestedClassNodeViaStaticImport(final CompileUnit compileUnit, final ImportNode importNode, final String typeName, final BiConsumer<ConstructedOuterNestedClassNode, ClassNode> setRedirectListener) { |
| String importClassName = importNode.getClassName(); |
| ClassNode outerClassNode = compileUnit.getClass(importClassName); |
| |
| if (null == outerClassNode) return null; |
| |
| String outerNestedClassName = importClassName + "$" + typeName.replace('.', '$'); |
| ConstructedOuterNestedClassNode constructedOuterNestedClassNode = new ConstructedOuterNestedClassNode(outerClassNode, outerNestedClassName); |
| constructedOuterNestedClassNode.addSetRedirectListener(setRedirectListener); |
| return constructedOuterNestedClassNode; |
| } |
| |
| private ConstructedOuterNestedClassNode tryToConstructOuterNestedClassNode(final ClassNode type, final ClassNode outerClassNode, final BiConsumer<ConstructedOuterNestedClassNode, ClassNode> setRedirectListener) { |
| String outerClassName = outerClassNode.getName(); |
| |
| for (String typeName = type.getName(), ident = typeName; ident.indexOf('.') != -1; ) { |
| ident = ident.substring(0, ident.lastIndexOf('.')); |
| if (outerClassName.endsWith(ident)) { |
| String outerNestedClassName = outerClassName + typeName.substring(ident.length()).replace('.', '$'); |
| ConstructedOuterNestedClassNode constructedOuterNestedClassNode = new ConstructedOuterNestedClassNode(outerClassNode, outerNestedClassName); |
| constructedOuterNestedClassNode.addSetRedirectListener(setRedirectListener); |
| return constructedOuterNestedClassNode; |
| } |
| } |
| |
| return null; |
| } |
| |
| private ConstructedOuterNestedClassNode tryToConstructOuterNestedClassNodeForBaseType(final CompileUnit compileUnit, final String typeName, final ClassNode cn, final BiConsumer<ConstructedOuterNestedClassNode, ClassNode> setRedirectListener) { |
| if (!compileUnit.getClassesToCompile().containsValue(cn)) return null; |
| |
| String outerNestedClassName = cn.getName() + "$" + typeName; |
| ConstructedOuterNestedClassNode constructedOuterNestedClassNode = new ConstructedOuterNestedClassNode(cn, outerNestedClassName); |
| constructedOuterNestedClassNode.addSetRedirectListener(setRedirectListener); |
| return constructedOuterNestedClassNode; |
| } |
| |
| private void resolveOrFail(final ClassNode type, final ASTNode node, final boolean prefereImports) { |
| resolveGenericsTypes(type.getGenericsTypes()); |
| if (prefereImports && resolveAliasFromModule(type)) return; |
| resolveOrFail(type, node); |
| } |
| |
| private void resolveOrFail(final ClassNode type, final ASTNode node) { |
| resolveOrFail(type, "", node); |
| } |
| |
| protected boolean resolve(final ClassNode type) { |
| return resolve(type, true, true, true); |
| } |
| |
| protected boolean resolve(final ClassNode type, final boolean testModuleImports, final boolean testDefaultImports, final 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(); |
| type.setRedirect(cn); |
| } |
| return resolved; |
| } |
| |
| // test if vanilla name is current class name |
| if (currentClass == type) return true; |
| |
| String typeName = type.getName(); |
| |
| GenericsType genericsType = genericParameterNames.get(new GenericsTypeName(typeName)); |
| if (genericsType != null) { |
| type.setRedirect(genericsType.getType()); |
| type.setGenericsTypes(new GenericsType[]{genericsType}); |
| type.setGenericsPlaceHolder(true); |
| return true; |
| } |
| |
| if (currentClass.getNameWithoutPackage().equals(typeName)) { |
| type.setRedirect(currentClass); |
| return true; |
| } |
| |
| return (!type.hasPackageName() && resolveNestedClass(type)) || |
| resolveFromModule(type, testModuleImports) || |
| resolveFromCompileUnit(type) || |
| (testDefaultImports && !type.hasPackageName() && resolveFromDefaultImports(type)) || |
| resolveToOuter(type) || |
| (testStaticInnerClasses && type.hasPackageName() && resolveFromStaticInnerClasses(type)); |
| } |
| |
| protected boolean resolveNestedClass(final ClassNode type) { |
| if (type instanceof ConstructedNestedClass || type instanceof ConstructedClassWithPackage) return false; |
| |
| // We have for example a class name A, are in class X |
| // and there is a nested class A$X. we want to be able |
| // to access that class directly, so A becomes a valid |
| // name in X. |
| // GROOVY-4043: Do this check up the hierarchy, if needed. |
| for (ClassNode classToCheck : findHierClasses(currentClass).values()) { |
| if (setRedirect(type, classToCheck)) return true; |
| } |
| |
| // GROOVY-8947: Resolve non-static inner class outside of outer class. |
| ClassNode possibleOuterClassNode = possibleOuterClassNodeMap.get(type); |
| if (possibleOuterClassNode != null) { |
| if (setRedirect(type, possibleOuterClassNode)) return true; |
| } |
| |
| // Another case we want to check here is if we are in a |
| // nested class A$B$C and want to access B without |
| // qualifying it by A.B. A alone will work, since that |
| // is the qualified (minus package) name of that class |
| // anyway. |
| |
| List<ClassNode> outerClasses = currentClass.getOuterClasses(); |
| if (!outerClasses.isEmpty()) { |
| // Since we have B and want to get A we start with the most |
| // outer class, put them together and then see if that does |
| // already exist. In case of B from within A$B we are done |
| // after the first step already. In case of for example |
| // A.B.C.D.E.F and accessing E from F we test A$E=failed, |
| // A$B$E=failed, A$B$C$E=fail, A$B$C$D$E=success. |
| |
| for (ListIterator<ClassNode> it = outerClasses.listIterator(outerClasses.size()); it.hasPrevious();) { |
| ClassNode outerClass = it.previous(); |
| if (setRedirect(type, outerClass)) return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| private boolean setRedirect(final ClassNode type, final ClassNode classToCheck) { |
| String typeName = type.getName(); |
| |
| Predicate<ClassNode> resolver = (ClassNode maybeOuter) -> { |
| if (!typeName.equals(maybeOuter.getName())) { |
| ClassNode maybeNested = new ConstructedNestedClass(maybeOuter, typeName); |
| if (resolveFromCompileUnit(maybeNested) || resolveToOuter(maybeNested)) { |
| type.setRedirect(maybeNested); |
| return true; |
| } |
| } |
| return false; |
| }; |
| |
| if (resolver.test(classToCheck)) { |
| if (currentClass != classToCheck && !currentClass.getOuterClasses().contains(classToCheck) && !isVisibleNestedClass(type.redirect(), currentClass)) { |
| type.setRedirect(null); |
| } else { |
| return true; |
| } |
| } |
| for (ClassNode face : classToCheck.getAllInterfaces()) { |
| if (resolver.test(face)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| private static String replaceLastPointWithDollar(final String name) { |
| int lastPointIndex = name.lastIndexOf('.'); |
| |
| return name.substring(0, lastPointIndex) + "$" + name.substring(lastPointIndex + 1); |
| } |
| |
| protected boolean resolveFromStaticInnerClasses(final ClassNode type) { |
| // 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 || type instanceof ConstructedNestedClass)) { |
| if (type instanceof ConstructedClassWithPackage) { |
| // we replace '.' only in the className part |
| // with '$' to find an inner class. The case that |
| // the package is really a class is handled elsewhere |
| ConstructedClassWithPackage tmp = (ConstructedClassWithPackage) type; |
| String savedName = tmp.className; |
| tmp.className = replaceLastPointWithDollar(savedName); |
| if (resolve(tmp, false, true, true)) { |
| type.setRedirect(tmp.redirect()); |
| return true; |
| } |
| tmp.className = savedName; |
| } else { |
| String savedName = type.getName(); |
| String replacedPointType = replaceLastPointWithDollar(savedName); |
| type.setName(replacedPointType); |
| if (resolve(type, false, true, true)) return true; |
| type.setName(savedName); |
| } |
| } |
| return false; |
| } |
| |
| protected boolean resolveFromDefaultImports(final ClassNode type) { |
| // we do not resolve a vanilla name starting with a lower case letter |
| // try to resolve against a default import, because we know that the |
| // default packages do not contain classes like these |
| if (!(type instanceof LowerCaseClass)) { |
| String typeName = type.getName(); |
| |
| Set<String> packagePrefixSet = DEFAULT_IMPORT_CLASS_AND_PACKAGES_CACHE.get(typeName); |
| if (packagePrefixSet != null) { |
| // if the type name was resolved before, we can try the successfully resolved packages first, which are much less and very likely successful to resolve. |
| // As a result, we can avoid trying other default import packages and further resolving, which can improve the resolving performance to some extent. |
| if (resolveFromDefaultImports(type, packagePrefixSet.toArray(EMPTY_STRING_ARRAY))) { |
| return true; |
| } |
| } |
| |
| if (resolveFromDefaultImports(type, DEFAULT_IMPORTS)) { |
| return true; |
| } |
| if (BIGINTEGER_STR.equals(typeName)) { |
| type.setRedirect(ClassHelper.BigInteger_TYPE); |
| return true; |
| } |
| if (BIGDECIMAL_STR.equals(typeName)) { |
| type.setRedirect(ClassHelper.BigDecimal_TYPE); |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| private static final EvictableCache<String, Set<String>> DEFAULT_IMPORT_CLASS_AND_PACKAGES_CACHE = new UnlimitedConcurrentCache<>(); |
| |
| protected boolean resolveFromDefaultImports(final ClassNode type, final String[] packagePrefixes) { |
| String typeName = type.getName(); |
| |
| for (String packagePrefix : packagePrefixes) { |
| // We limit the inner class lookups here by using ConstructedClassWithPackage. |
| // This way only the name will change, the packagePrefix will |
| // not be included in the lookup. The case where the |
| // packagePrefix is really a class is handled elsewhere. |
| // WARNING: This code does not expect a class that has a static |
| // inner class in DEFAULT_IMPORTS |
| ConstructedClassWithPackage tmp = new ConstructedClassWithPackage(packagePrefix, typeName); |
| if (resolve(tmp, false, false, false)) { |
| type.setRedirect(tmp.redirect()); |
| |
| if (DEFAULT_IMPORTS == packagePrefixes) { // Only the non-cached type and packages should be cached |
| Set<String> packagePrefixSet = DEFAULT_IMPORT_CLASS_AND_PACKAGES_CACHE.getAndPut(typeName, key -> new HashSet<>(2)); |
| packagePrefixSet.add(packagePrefix); |
| } |
| |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| protected boolean resolveFromCompileUnit(final ClassNode type) { |
| // look into the compile unit if there is a class with that name |
| CompileUnit compileUnit = currentClass.getCompileUnit(); |
| if (compileUnit == null) return false; |
| ClassNode cuClass = compileUnit.getClass(type.getName()); |
| if (cuClass != null) { |
| if (type != cuClass) type.setRedirect(cuClass); |
| return true; |
| } |
| return false; |
| } |
| |
| private void ambiguousClass(final ClassNode type, final ClassNode iType, final String name) { |
| if (type.getName().equals(iType.getName())) { |
| addError("reference to " + name + " is ambiguous, both class " + type.getName() + " and " + iType.getName() + " match", type); |
| } else { |
| type.setRedirect(iType); |
| } |
| } |
| |
| private boolean resolveAliasFromModule(final ClassNode type) { |
| // In case of getting a ConstructedClassWithPackage here we do not do checks for partial |
| // matches with imported classes. The ConstructedClassWithPackage is already a constructed |
| // node and any subclass resolving will then take place elsewhere |
| if (type instanceof ConstructedClassWithPackage) return false; |
| |
| ModuleNode module = currentClass.getModule(); |
| if (module == null) return false; |
| String name = type.getName(); |
| |
| // check module node imports aliases |
| // the while loop enables a check for inner classes which are not fully imported, |
| // but visible as the surrounding class is imported and the inner class is public/protected static |
| String pname = name; |
| int index = name.length(); |
| /* |
| * we have a name foo.bar and an import foo.foo. This means foo.bar is possibly |
| * foo.foo.bar rather than foo.bar. This means to cut at the dot in foo.bar and |
| * foo for import |
| */ |
| do { |
| pname = name.substring(0, index); |
| ClassNode aliasedNode = null; |
| ImportNode importNode = module.getImport(pname); |
| if (importNode != null && importNode != currImportNode) { |
| aliasedNode = importNode.getType(); |
| } |
| if (aliasedNode == null) { |
| importNode = module.getStaticImports().get(pname); |
| if (importNode != null && importNode != currImportNode) { |
| // static alias only for inner classes and must be at end of chain |
| ClassNode tmp = new ConstructedNestedClass(importNode.getType(), importNode.getFieldName()); |
| if (resolve(tmp, false, false, true)) { |
| if ((tmp.getModifiers() & Opcodes.ACC_STATIC) != 0) { |
| type.setRedirect(tmp.redirect()); |
| return true; |
| } |
| } |
| } |
| } |
| |
| if (aliasedNode != null) { |
| if (pname.length() == name.length()) { |
| // full match |
| |
| // We can compare here by length, because pname is always |
| // a substring of name, so same length means they are equal. |
| type.setRedirect(aliasedNode); |
| return true; |
| } else { |
| //partial match |
| |
| // At this point we know that we have a match for pname. This may |
| // mean, that name[pname.length()..<-1] is a static inner class. |
| // For this the rest of the name does not need any dots in its name. |
| // It is either completely a inner static class or it is not. |
| // Since we do not want to have useless lookups we create the name |
| // completely and use a ConstructedClassWithPackage to prevent lookups against the package. |
| String className = aliasedNode.getNameWithoutPackage() + "$" + name.substring(pname.length() + 1).replace('.', '$'); |
| ConstructedClassWithPackage tmp = new ConstructedClassWithPackage(aliasedNode.getPackageName() + ".", className); |
| if (resolve(tmp, true, true, false)) { |
| type.setRedirect(tmp.redirect()); |
| return true; |
| } |
| } |
| } |
| index = pname.lastIndexOf('.'); |
| } while (index != -1); |
| return false; |
| } |
| |
| protected boolean resolveFromModule(final ClassNode type, final boolean testModuleImports) { |
| if (type instanceof ConstructedNestedClass) return false; |
| |
| // we decided if we have a vanilla name starting with a lower case |
| // letter that we will not try to resolve this name against .* |
| // imports. Instead a full import is needed for these. |
| // resolveAliasFromModule will do this check for us. This method |
| // does also check the module contains a class in the same package |
| // of this name. This check is not done for vanilla names starting |
| // with a lower case letter anymore |
| if (type instanceof LowerCaseClass) { |
| return resolveAliasFromModule(type); |
| } |
| |
| String name = type.getName(); |
| ModuleNode module = currentClass.getModule(); |
| if (module == null) return false; |
| |
| boolean newNameUsed = false; |
| // we add a package if there is none yet and the module has one. But we |
| // do not add that if the type is a ConstructedClassWithPackage. The code in ConstructedClassWithPackage |
| // hasPackageName() will return true if ConstructedClassWithPackage#className has no dots. |
| // but since the prefix may have them and the code there does ignore that |
| // fact. We check here for ConstructedClassWithPackage. |
| if (!type.hasPackageName() && module.hasPackageName() && !(type instanceof ConstructedClassWithPackage)) { |
| type.setName(module.getPackageName() + name); |
| newNameUsed = true; |
| } |
| // look into the module node if there is a class with that name |
| List<ClassNode> moduleClasses = module.getClasses(); |
| for (ClassNode mClass : moduleClasses) { |
| if (mClass.getName().equals(type.getName())) { |
| if (mClass != type) type.setRedirect(mClass); |
| return true; |
| } |
| } |
| if (newNameUsed) type.setName(name); |
| |
| if (testModuleImports) { |
| if (resolveAliasFromModule(type)) return true; |
| |
| if (module.hasPackageName()) { |
| // check package this class is defined in. The usage of ConstructedClassWithPackage here |
| // means, that the module package will not be involved when the |
| // compiler tries to find an inner class. |
| ConstructedClassWithPackage tmp = new ConstructedClassWithPackage(module.getPackageName(), name); |
| if (resolve(tmp, false, false, false)) { |
| ambiguousClass(type, tmp, name); |
| type.setRedirect(tmp.redirect()); |
| return true; |
| } |
| } |
| |
| // check module static imports (for static inner classes) |
| for (ImportNode importNode : module.getStaticImports().values()) { |
| 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()); |
| return true; |
| } |
| } |
| } |
| } |
| |
| // check module node import packages |
| for (ImportNode importNode : module.getStarImports()) { |
| String packagePrefix = importNode.getPackageName(); |
| // We limit the inner class lookups here by using ConstructedClassWithPackage. |
| // This way only the name will change, the packagePrefix will |
| // not be included in the lookup. The case where the |
| // packagePrefix is really a class is handled elsewhere. |
| ConstructedClassWithPackage tmp = new ConstructedClassWithPackage(packagePrefix, name); |
| if (resolve(tmp, false, false, true)) { |
| ambiguousClass(type, tmp, name); |
| type.setRedirect(tmp.redirect()); |
| return true; |
| } |
| } |
| |
| // check for star imports (import static pkg.Outer.*) matching static inner classes |
| for (ImportNode importNode : module.getStaticStarImports().values()) { |
| ClassNode tmp = new ConstructedNestedClass(importNode.getType(), name); |
| if (resolve(tmp, false, false, true)) { |
| if ((tmp.getModifiers() & Opcodes.ACC_STATIC) != 0) { |
| ambiguousClass(type, tmp, name); |
| type.setRedirect(tmp.redirect()); |
| return true; |
| } |
| } |
| |
| } |
| } |
| return false; |
| } |
| |
| protected boolean resolveToOuter(final ClassNode type) { |
| String name = type.getName(); |
| |
| // We do not need to check instances of LowerCaseClass |
| // to be a Class, because unless there was an import for |
| // for this we do not lookup these cases. This was a decision |
| // made on the mailing list. To ensure we will not visit this |
| // method again we set a NO_CLASS for this name |
| if (type instanceof LowerCaseClass) { |
| classNodeResolver.cacheClass(name, ClassNodeResolver.NO_CLASS); |
| return false; |
| } |
| |
| if (currentClass.getModule().hasPackageName() && name.indexOf('.') == -1) return false; |
| |
| LookupResult lr = classNodeResolver.resolveName(name, compilationUnit); |
| if (lr != null) { |
| if (lr.isSourceUnit()) { |
| SourceUnit su = lr.getSourceUnit(); |
| currentClass.getCompileUnit().addClassNodeToCompile(type, su); |
| } else { |
| type.setRedirect(lr.getClassNode()); |
| } |
| return true; |
| } |
| |
| return false; |
| } |
| |
| @Override |
| public Expression transform(final Expression exp) { |
| if (exp == null) return null; |
| Expression ret; |
| if (exp instanceof VariableExpression) { |
| ret = transformVariableExpression((VariableExpression) exp); |
| } else if (exp.getClass() == PropertyExpression.class) { |
| ret = transformPropertyExpression((PropertyExpression) exp); |
| } else if (exp instanceof DeclarationExpression) { |
| ret = transformDeclarationExpression((DeclarationExpression) exp); |
| } else if (exp instanceof BinaryExpression) { |
| ret = transformBinaryExpression((BinaryExpression) exp); |
| } else if (exp instanceof MethodCallExpression) { |
| ret = transformMethodCallExpression((MethodCallExpression) exp); |
| } else if (exp instanceof ClosureExpression) { |
| ret = transformClosureExpression((ClosureExpression) exp); |
| } else if (exp instanceof ConstructorCallExpression) { |
| ret = transformConstructorCallExpression((ConstructorCallExpression) exp); |
| } else if (exp instanceof AnnotationConstantExpression) { |
| ret = transformAnnotationConstantExpression((AnnotationConstantExpression) exp); |
| } else { |
| resolveOrFail(exp.getType(), exp); |
| ret = exp.transformExpression(this); |
| } |
| if (ret != null && ret != exp) { |
| ret.setSourcePosition(exp); |
| } |
| return ret; |
| } |
| |
| private static String lookupClassName(final PropertyExpression pe) { |
| boolean doInitialClassTest = true; |
| StringBuilder name = new StringBuilder(32); |
| // this loop builds a name from right to left each name part |
| // separated by "." |
| for (Expression expr = pe; expr != null; expr = ((PropertyExpression) expr).getObjectExpression()) { |
| if (expr instanceof VariableExpression) { |
| VariableExpression ve = (VariableExpression) expr; |
| // stop at super and this |
| if (ve.isSuperExpression() || ve.isThisExpression()) { |
| return null; |
| } |
| String varName = ve.getName(); |
| Tuple2<StringBuilder, Boolean> classNameInfo = makeClassName(doInitialClassTest, name, varName); |
| name = classNameInfo.getV1(); |
| doInitialClassTest = classNameInfo.getV2(); |
| |
| break; |
| } |
| |
| // anything other than PropertyExpressions or |
| // VariableExpressions will stop resolving |
| if (expr.getClass() != PropertyExpression.class) { |
| return null; |
| } |
| |
| String property = ((PropertyExpression) expr).getPropertyAsString(); |
| // the class property stops resolving, dynamic property names too |
| if (property == null || property.equals("class")) { |
| return null; |
| } |
| Tuple2<StringBuilder, Boolean> classNameInfo = makeClassName(doInitialClassTest, name, property); |
| name = classNameInfo.getV1(); |
| doInitialClassTest = classNameInfo.getV2(); |
| } |
| |
| if (null == name || name.length() == 0) return null; |
| |
| return name.toString(); |
| } |
| |
| private static Tuple2<StringBuilder, Boolean> makeClassName(final boolean doInitialClassTest, final StringBuilder name, final String varName) { |
| if (doInitialClassTest) { |
| // we are at the first name part. This is the right most part. |
| // If this part is in lower case, then we do not need a class |
| // check. other parts of the property expression will be tested |
| // by a different method call to this method, so foo.Bar.bar |
| // can still be resolved to the class foo.Bar and the static |
| // field bar. |
| if (!testVanillaNameForClass(varName)) { |
| return tuple(null, Boolean.TRUE); |
| } else { |
| return tuple(new StringBuilder(varName), Boolean.FALSE); |
| } |
| } |
| name.insert(0, varName + "."); |
| return tuple(name, Boolean.FALSE); |
| } |
| |
| // iterate from the inner most to the outer and check for classes |
| // this check will ignore a .class property, for Example Integer.class will be |
| // a PropertyExpression with the ClassExpression of Integer as objectExpression |
| // and class as property |
| private static Expression correctClassClassChain(final PropertyExpression pe) { |
| LinkedList<Expression> stack = new LinkedList<Expression>(); |
| ClassExpression found = null; |
| for (Expression it = pe; it != null; it = ((PropertyExpression) it).getObjectExpression()) { |
| if (it instanceof ClassExpression) { |
| found = (ClassExpression) it; |
| break; |
| } else if (!(it.getClass() == PropertyExpression.class)) { |
| return pe; |
| } |
| stack.addFirst(it); |
| } |
| if (found == null) return pe; |
| |
| if (stack.isEmpty()) return pe; |
| Object stackElement = stack.removeFirst(); |
| if (!(stackElement.getClass() == PropertyExpression.class)) return pe; |
| PropertyExpression classPropertyExpression = (PropertyExpression) stackElement; |
| String propertyNamePart = classPropertyExpression.getPropertyAsString(); |
| if (propertyNamePart == null || !propertyNamePart.equals("class")) return pe; |
| |
| found.setSourcePosition(classPropertyExpression); |
| if (stack.isEmpty()) return found; |
| stackElement = stack.removeFirst(); |
| if (!(stackElement.getClass() == PropertyExpression.class)) return pe; |
| PropertyExpression classPropertyExpressionContainer = (PropertyExpression) stackElement; |
| |
| classPropertyExpressionContainer.setObjectExpression(found); |
| return pe; |
| } |
| |
| protected Expression transformPropertyExpression(PropertyExpression pe) { |
| boolean itlp = isTopLevelProperty; |
| boolean ipe = inPropertyExpression; |
| |
| Expression objectExpression = pe.getObjectExpression(); |
| inPropertyExpression = true; |
| isTopLevelProperty = (objectExpression.getClass() != PropertyExpression.class); |
| objectExpression = transform(objectExpression); |
| // we handle the property part as if it were not part of the property |
| inPropertyExpression = false; |
| Expression property = transform(pe.getProperty()); |
| isTopLevelProperty = itlp; |
| inPropertyExpression = ipe; |
| |
| boolean spreadSafe = pe.isSpreadSafe(); |
| PropertyExpression old = pe; |
| pe = new PropertyExpression(objectExpression, property, pe.isSafe()); |
| pe.setSpreadSafe(spreadSafe); |
| pe.setSourcePosition(old); |
| |
| String className = lookupClassName(pe); |
| if (className != null) { |
| ClassNode type = ClassHelper.make(className); |
| if (resolve(type)) { |
| return new ClassExpression(type); |
| } |
| } |
| if (objectExpression instanceof ClassExpression && pe.getPropertyAsString() != null) { |
| // possibly an inner class (or inherited inner class) |
| ClassExpression ce = (ClassExpression) objectExpression; |
| ClassNode classNode = ce.getType(); |
| while (classNode != null) { |
| ClassNode type = new ConstructedNestedClass(classNode, pe.getPropertyAsString()); |
| if (resolve(type, false, false, false)) { |
| if (classNode == ce.getType() || isVisibleNestedClass(type, ce.getType())) { |
| return new ClassExpression(type); |
| } |
| } |
| classNode = classNode.getSuperClass(); |
| } |
| } |
| Expression ret = pe; |
| checkThisAndSuperAsPropertyAccess(pe); |
| if (isTopLevelProperty) ret = correctClassClassChain(pe); |
| return ret; |
| } |
| |
| private static boolean isVisibleNestedClass(final ClassNode innerType, final ClassNode outerType) { |
| int modifiers = innerType.getModifiers(); |
| return Modifier.isPublic(modifiers) || Modifier.isProtected(modifiers) |
| || (!Modifier.isPrivate(modifiers) && Objects.equals(innerType.getPackageName(), outerType.getPackageName())); |
| } |
| |
| private boolean directlyImplementsTrait(final ClassNode trait) { |
| ClassNode[] interfaces = currentClass.getInterfaces(); |
| if (interfaces == null) { |
| return currentClass.getSuperClass().equals(trait); |
| } |
| for (ClassNode node : interfaces) { |
| if (node.equals(trait)) { |
| return true; |
| } |
| } |
| return currentClass.getSuperClass().equals(trait); |
| } |
| |
| private void checkThisAndSuperAsPropertyAccess(final PropertyExpression expression) { |
| if (expression.isImplicitThis()) return; |
| String prop = expression.getPropertyAsString(); |
| if (prop == null) return; |
| if (!prop.equals("this") && !prop.equals("super")) return; |
| |
| ClassNode type = expression.getObjectExpression().getType(); |
| if (expression.getObjectExpression() instanceof ClassExpression) { |
| if (!(currentClass instanceof InnerClassNode) && !Traits.isTrait(type)) { |
| addError("The usage of 'Class.this' and 'Class.super' is only allowed in nested/inner classes.", expression); |
| return; |
| } |
| if (currentScope != null && !currentScope.isInStaticContext() && Traits.isTrait(type) && "super".equals(prop) && directlyImplementsTrait(type)) { |
| return; |
| } |
| ClassNode iterType = currentClass; |
| while (iterType != null) { |
| if (iterType.equals(type)) break; |
| iterType = iterType.getOuterClass(); |
| } |
| if (iterType == null) { |
| addError("The class '" + type.getName() + "' needs to be an outer class of '" + |
| currentClass.getName() + "' when using '.this' or '.super'.", expression); |
| } |
| if ((currentClass.getModifiers() & Opcodes.ACC_STATIC) == 0) return; |
| if (currentScope != null && !currentScope.isInStaticContext()) return; |
| addError("The usage of 'Class.this' and 'Class.super' within static nested class '" + |
| currentClass.getName() + "' is not allowed in a static context.", expression); |
| } |
| } |
| |
| protected Expression transformVariableExpression(final VariableExpression ve) { |
| visitAnnotations(ve); |
| Variable v = ve.getAccessedVariable(); |
| |
| if(!(v instanceof DynamicVariable) && !checkingVariableTypeInDeclaration) { |
| /* |
| * GROOVY-4009: when a normal variable is simply being used, there is no need to try to |
| * resolve its type. Variable type resolve should proceed only if the variable is being declared. |
| */ |
| return ve; |
| } |
| if (v instanceof DynamicVariable) { |
| String name = ve.getName(); |
| ClassNode t = ClassHelper.make(name); |
| // asking isResolved here allows to check if a primitive |
| // type name like "int" was used to make t. In such a case |
| // we have nothing left to do. |
| boolean isClass = t.isResolved(); |
| if (!isClass) { |
| // It was no primitive type, so next we see if the name, |
| // which is a vanilla name, starts with a lower case letter. |
| // In that case we change it to a LowerCaseClass to let the |
| // compiler skip the resolving at several places in this class. |
| if (Character.isLowerCase(name.charAt(0))) { |
| t = new LowerCaseClass(name); |
| } |
| isClass = resolve(t); |
| } |
| if (isClass) { |
| // the name is a type so remove it from the scoping |
| // as it is only a classvariable, it is only in |
| // referencedClassVariables, but must be removed |
| // for each parentscope too |
| for (VariableScope scope = currentScope; scope != null && !scope.isRoot(); scope = scope.getParent()) { |
| if (scope.removeReferencedClassVariable(ve.getName()) == null) break; |
| } |
| return new ClassExpression(t); |
| } |
| } |
| resolveOrFail(ve.getType(), ve); |
| ClassNode origin = ve.getOriginType(); |
| if (origin != ve.getType()) resolveOrFail(origin, ve); |
| return ve; |
| } |
| |
| private static boolean testVanillaNameForClass(final String name) { |
| if (name == null || name.length() == 0) return false; |
| return !Character.isLowerCase(name.charAt(0)); |
| } |
| |
| protected Expression transformBinaryExpression(final BinaryExpression be) { |
| Expression left = transform(be.getLeftExpression()); |
| if (be.getOperation().isA(Types.ASSIGNMENT_OPERATOR) && left instanceof ClassExpression) { |
| ClassExpression ce = (ClassExpression) left; |
| String error = "you tried to assign a value to the class '" + ce.getType().getName() + "'"; |
| if (ce.getType().isScript()) { |
| error += ". Do you have a script with this name?"; |
| } |
| addError(error, be.getLeftExpression()); |
| return be; |
| } |
| if (left instanceof ClassExpression && be.getOperation().isOneOf( |
| new int[]{Types.ARRAY_EXPRESSION, Types.SYNTH_LIST, Types.SYNTH_MAP})) { |
| if (be.getRightExpression() instanceof ListExpression) { |
| ListExpression list = (ListExpression) be.getRightExpression(); |
| if (list.getExpressions().isEmpty()) { |
| return new ClassExpression(left.getType().makeArray()); |
| } else { |
| // maybe we have C[k1:v1, k2:v2] -> should become (C)([k1:v1, k2:v2]) |
| boolean map = true; |
| for (Expression expression : list.getExpressions()) { |
| if (!(expression instanceof MapEntryExpression)) { |
| map = false; |
| break; |
| } |
| } |
| |
| if (map) { |
| MapExpression me = new MapExpression(); |
| for (Expression expression : list.getExpressions()) { |
| me.addMapEntryExpression((MapEntryExpression) transform(expression)); |
| } |
| me.setSourcePosition(list); |
| CastExpression ce = new CastExpression(left.getType(), me); |
| ce.setCoerce(true); |
| return ce; |
| } |
| } |
| } else if (be.getRightExpression() instanceof SpreadMapExpression) { |
| // we have C[*:map] -> should become (C) map |
| SpreadMapExpression mapExpression = (SpreadMapExpression) be.getRightExpression(); |
| Expression right = transform(mapExpression.getExpression()); |
| CastExpression ce = new CastExpression(left.getType(), right); |
| ce.setCoerce(true); |
| return ce; |
| } |
| |
| if (be.getRightExpression() instanceof MapEntryExpression) { |
| // may be we have C[k1:v1] -> should become (C)([k1:v1]) |
| MapExpression me = new MapExpression(); |
| me.addMapEntryExpression((MapEntryExpression) transform(be.getRightExpression())); |
| me.setSourcePosition(be.getRightExpression()); |
| return new CastExpression(left.getType(), me); |
| } |
| } |
| Expression right = transform(be.getRightExpression()); |
| be.setLeftExpression(left); |
| be.setRightExpression(right); |
| return be; |
| } |
| |
| protected Expression transformClosureExpression(final ClosureExpression ce) { |
| boolean oldInClosure = inClosure; |
| inClosure = true; |
| for (Parameter para : getParametersSafe(ce)) { |
| ClassNode t = para.getType(); |
| resolveOrFail(t, ce); |
| visitAnnotations(para); |
| if (para.hasInitialExpression()) { |
| para.setInitialExpression(transform(para.getInitialExpression())); |
| } |
| visitAnnotations(para); |
| } |
| |
| Statement code = ce.getCode(); |
| if (code != null) code.visit(this); |
| inClosure = oldInClosure; |
| return ce; |
| } |
| |
| protected Expression transformConstructorCallExpression(final ConstructorCallExpression cce) { |
| findPossibleOuterClassNodeForNonStaticInnerClassInstantiation(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 void findPossibleOuterClassNodeForNonStaticInnerClassInstantiation(final ConstructorCallExpression cce) { |
| // GROOVY-8947: Fail to resolve non-static inner class outside of outer class |
| // `new Computer().new Cpu(4)` will be parsed to `new Cpu(new Computer(), 4)` |
| // so non-static inner class instantiation expression's first argument is a constructor call of outer class |
| // but the first argument is constructor call can not be non-static inner class instantiation expression, e.g. |
| // `new HashSet(new ArrayList())`, so we add "possible" to the variable name |
| Expression argumentExpression = cce.getArguments(); |
| if (argumentExpression instanceof ArgumentListExpression) { |
| ArgumentListExpression argumentListExpression = (ArgumentListExpression) argumentExpression; |
| List<Expression> expressionList = argumentListExpression.getExpressions(); |
| if (!expressionList.isEmpty()) { |
| Expression firstExpression = expressionList.get(0); |
| |
| if (firstExpression instanceof ConstructorCallExpression) { |
| ConstructorCallExpression constructorCallExpression = (ConstructorCallExpression) firstExpression; |
| ClassNode possibleOuterClassNode = constructorCallExpression.getType(); |
| possibleOuterClassNodeMap.put(cce.getType(), possibleOuterClassNode); |
| } |
| } |
| } |
| } |
| |
| private static String getDescription(final ClassNode node) { |
| return (node.isInterface() ? "interface" : "class") + " '" + node.getName() + "'"; |
| } |
| |
| protected Expression transformMethodCallExpression(final MethodCallExpression mce) { |
| Expression args = transform(mce.getArguments()); |
| Expression method = transform(mce.getMethod()); |
| Expression object = transform(mce.getObjectExpression()); |
| |
| resolveGenericsTypes(mce.getGenericsTypes()); |
| |
| MethodCallExpression ret = new MethodCallExpression(object, method, args); |
| ret.setGenericsTypes(mce.getGenericsTypes()); |
| ret.setMethodTarget(mce.getMethodTarget()); |
| ret.setImplicitThis(mce.isImplicitThis()); |
| ret.setSpreadSafe(mce.isSpreadSafe()); |
| ret.setSafe(mce.isSafe()); |
| return ret; |
| } |
| |
| protected Expression transformDeclarationExpression(final 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()); |
| newDeclExpr.addAnnotations(de.getAnnotations()); |
| newDeclExpr.copyNodeMetaData(de); |
| fixDeclaringClass(newDeclExpr); |
| return newDeclExpr; |
| } |
| |
| // TODO: get normal resolving to set declaring class |
| private void fixDeclaringClass(final DeclarationExpression newDeclExpr) { |
| if (newDeclExpr.getDeclaringClass() == null && currentMethod != null) { |
| newDeclExpr.setDeclaringClass(currentMethod.getDeclaringClass()); |
| } |
| } |
| |
| protected Expression transformAnnotationConstantExpression(final AnnotationConstantExpression ace) { |
| AnnotationNode an = (AnnotationNode) ace.getValue(); |
| ClassNode type = an.getClassNode(); |
| resolveOrFail(type, " for annotation", an); |
| for (Map.Entry<String, Expression> member : an.getMembers().entrySet()) { |
| member.setValue(transform(member.getValue())); |
| } |
| return ace; |
| } |
| |
| @Override |
| public void visitAnnotations(final AnnotatedNode node) { |
| List<AnnotationNode> annotations = node.getAnnotations(); |
| if (annotations.isEmpty()) return; |
| Map<String, AnnotationNode> tmpAnnotations = new HashMap<>(); |
| for (AnnotationNode an : annotations) { |
| // skip built-in properties |
| if (an.isBuiltIn()) continue; |
| ClassNode annType = an.getClassNode(); |
| resolveOrFail(annType, " 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 = annTypeClass.getAnnotation(Retention.class); |
| if (retAnn != null && !retAnn.value().equals(RetentionPolicy.SOURCE) && !isRepeatable(annTypeClass)) { |
| // remember non-source/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); |
| } |
| } |
| } |
| } |
| } |
| |
| private boolean isRepeatable(final Class<?> annTypeClass) { |
| Annotation[] annTypeAnnotations = annTypeClass.getAnnotations(); |
| for (Annotation annTypeAnnotation : annTypeAnnotations) { |
| if (annTypeAnnotation.annotationType().getName().equals("java.lang.annotation.Repeatable")) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| // resolve constant-looking expressions statically (do here as they get transformed away later) |
| private static Expression transformInlineConstants(final Expression exp) { |
| if (exp instanceof AnnotationConstantExpression) { |
| ConstantExpression ce = (ConstantExpression) exp; |
| if (ce.getValue() instanceof AnnotationNode) { |
| // replicate a little bit of AnnotationVisitor here |
| // because we can't wait until later to do this |
| AnnotationNode an = (AnnotationNode) ce.getValue(); |
| for (Map.Entry<String, Expression> member : an.getMembers().entrySet()) { |
| member.setValue(transformInlineConstants(member.getValue())); |
| } |
| } |
| } else { |
| return ExpressionUtils.transformInlineConstants(exp); |
| } |
| return exp; |
| } |
| |
| private void checkAnnotationMemberValue(final Expression newValue) { |
| if (newValue instanceof PropertyExpression) { |
| PropertyExpression pe = (PropertyExpression) newValue; |
| if (!(pe.getObjectExpression() instanceof ClassExpression)) { |
| addError("unable to find class '" + pe.getText() + "' for annotation attribute constant", pe.getObjectExpression()); |
| } |
| } else if (newValue instanceof ListExpression) { |
| ListExpression le = (ListExpression) newValue; |
| for (Expression e : le.getExpressions()) { |
| checkAnnotationMemberValue(e); |
| } |
| } |
| } |
| |
| @Override |
| public void visitClass(final ClassNode node) { |
| ClassNode oldNode = currentClass; |
| |
| currentClass = node; |
| |
| if (node instanceof InnerClassNode) { |
| if (Modifier.isStatic(node.getModifiers())) { |
| genericParameterNames = new HashMap<>(); |
| } |
| |
| InnerClassNode innerClassNode = (InnerClassNode) node; |
| if (innerClassNode.isAnonymous()) { |
| MethodNode enclosingMethod = innerClassNode.getEnclosingMethod(); |
| if (null != enclosingMethod) { |
| resolveGenericsHeader(enclosingMethod.getGenericsTypes()); |
| } |
| } |
| } else { |
| genericParameterNames = new HashMap<>(); |
| } |
| |
| resolveGenericsHeader(node.getGenericsTypes()); |
| |
| ModuleNode module = node.getModule(); |
| if (!module.hasImportsResolved()) { |
| for (ImportNode importNode : module.getImports()) { |
| currImportNode = importNode; |
| ClassNode type = importNode.getType(); |
| if (resolve(type, false, false, true)) { |
| currImportNode = null; |
| continue; |
| } |
| currImportNode = null; |
| addError("unable to resolve class " + type.getName(), type); |
| } |
| for (ImportNode importNode : module.getStaticStarImports().values()) { |
| ClassNode type = importNode.getType(); |
| if (resolve(type, false, false, true)) continue; |
| // Maybe this type belongs in the same package as the node that is doing the |
| // static import. In that case, the package may not have been explicitly specified. |
| // Try with the node's package too. If still not found, revert to original type name. |
| if (type.getPackageName() == null && node.getPackageName() != null) { |
| 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); |
| } |
| for (ImportNode importNode : module.getStaticImports().values()) { |
| ClassNode type = importNode.getType(); |
| if (resolve(type, true, true, true)) continue; |
| addError("unable to resolve class " + type.getName(), type); |
| } |
| for (ImportNode importNode : module.getStaticStarImports().values()) { |
| ClassNode type = importNode.getType(); |
| if (resolve(type, true, true, true)) continue; |
| addError("unable to resolve class " + type.getName(), type); |
| } |
| module.setImportsResolved(true); |
| } |
| |
| ClassNode sn = node.getUnresolvedSuperClass(); |
| if (sn != null) resolveOrFail(sn, node, true); |
| |
| for (ClassNode anInterface : node.getInterfaces()) { |
| resolveOrFail(anInterface, node, true); |
| } |
| |
| checkCyclicInheritance(node, node.getUnresolvedSuperClass(), node.getInterfaces()); |
| |
| super.visitClass(node); |
| |
| resolveOuterNestedClassFurther(node); |
| |
| currentClass = oldNode; |
| } |
| |
| // GROOVY-7812(#2): Static inner classes cannot be accessed from other files when running by 'groovy' command |
| private void resolveOuterNestedClassFurther(final ClassNode node) { |
| CompileUnit compileUnit = currentClass.getCompileUnit(); |
| |
| if (null == compileUnit) return; |
| |
| Map<String, ConstructedOuterNestedClassNode> classesToResolve = compileUnit.getClassesToResolve(); |
| List<String> resolvedInnerClassNameList = new LinkedList<>(); |
| |
| for (Map.Entry<String, ConstructedOuterNestedClassNode> entry : classesToResolve.entrySet()) { |
| String innerClassName = entry.getKey(); |
| ConstructedOuterNestedClassNode constructedOuterNestedClass = entry.getValue(); |
| |
| // When the outer class is resolved, all inner classes are resolved too |
| if (node.getName().equals(constructedOuterNestedClass.getEnclosingClassNode().getName())) { |
| ClassNode innerClassNode = compileUnit.getClass(innerClassName); // find the resolved inner class |
| |
| if (null == innerClassNode) { |
| return; // "unable to resolve class" error can be thrown already, no need to `addError`, so just return |
| } |
| |
| constructedOuterNestedClass.setRedirect(innerClassNode); |
| resolvedInnerClassNameList.add(innerClassName); |
| } |
| } |
| |
| for (String innerClassName : resolvedInnerClassNameList) { |
| classesToResolve.remove(innerClassName); |
| } |
| } |
| |
| private void checkCyclicInheritance(final ClassNode originalNode, final ClassNode parentToCompare, final ClassNode[] interfacesToCompare) { |
| if (!originalNode.isInterface()) { |
| if (parentToCompare == null) return; |
| if (originalNode == parentToCompare.redirect()) { |
| addError("Cyclic inheritance involving " + parentToCompare.getName() + " in class " + originalNode.getName(), originalNode); |
| return; |
| } |
| if (interfacesToCompare != null && interfacesToCompare.length > 0) { |
| for (ClassNode intfToCompare : interfacesToCompare) { |
| if (originalNode == intfToCompare.redirect()) { |
| addError("Cycle detected: the type " + originalNode.getName() + " cannot implement itself" , originalNode); |
| return; |
| } |
| } |
| } |
| if (parentToCompare == ClassHelper.OBJECT_TYPE) return; |
| checkCyclicInheritance(originalNode, parentToCompare.getUnresolvedSuperClass(), null); |
| } else { |
| if (interfacesToCompare != null && interfacesToCompare.length > 0) { |
| // check interfaces at this level first |
| for (ClassNode intfToCompare : interfacesToCompare) { |
| if(originalNode == intfToCompare.redirect()) { |
| addError("Cyclic inheritance involving " + intfToCompare.getName() + " in interface " + originalNode.getName(), originalNode); |
| return; |
| } |
| } |
| // check next level of interfaces |
| for (ClassNode intf : interfacesToCompare) { |
| checkCyclicInheritance(originalNode, null, intf.getInterfaces()); |
| } |
| } |
| } |
| } |
| |
| @Override |
| public void visitCatchStatement(final CatchStatement cs) { |
| resolveOrFail(cs.getExceptionType(), cs); |
| if (cs.getExceptionType() == ClassHelper.DYNAMIC_TYPE) { |
| cs.getVariable().setType(ClassHelper.make(Exception.class)); |
| } |
| super.visitCatchStatement(cs); |
| } |
| |
| @Override |
| public void visitForLoop(final ForStatement forLoop) { |
| resolveOrFail(forLoop.getVariableType(), forLoop); |
| super.visitForLoop(forLoop); |
| } |
| |
| @Override |
| public void visitBlockStatement(final BlockStatement block) { |
| VariableScope oldScope = currentScope; |
| currentScope = block.getVariableScope(); |
| super.visitBlockStatement(block); |
| currentScope = oldScope; |
| } |
| |
| private boolean resolveGenericsTypes(final GenericsType[] types) { |
| if (types == null) return true; |
| currentClass.setUsingGenerics(true); |
| boolean resolved = true; |
| for (GenericsType type : types) { |
| // attempt resolution on all types, so don't short-circuit and stop if we've previously failed |
| resolved = resolveGenericsType(type) && resolved; |
| } |
| return resolved; |
| } |
| |
| private void resolveGenericsHeader(final GenericsType[] types) { |
| resolveGenericsHeader(types, null, 0); |
| } |
| |
| private void resolveGenericsHeader(final GenericsType[] types, final GenericsType rootType, final int level) { |
| if (types == null) return; |
| currentClass.setUsingGenerics(true); |
| List<Tuple2<ClassNode, GenericsType>> upperBoundsWithGenerics = new LinkedList<>(); |
| List<Tuple2<ClassNode, ClassNode>> upperBoundsToResolve = new LinkedList<>(); |
| for (GenericsType type : types) { |
| if (level > 0 && type.getName().equals(rootType.getName())) { |
| continue; |
| } |
| |
| ClassNode classNode = type.getType(); |
| String name = type.getName(); |
| GenericsTypeName gtn = new GenericsTypeName(name); |
| ClassNode[] bounds = type.getUpperBounds(); |
| boolean isWild = QUESTION_MARK.equals(name); |
| boolean toDealWithGenerics = 0 == level || (level > 0 && null != genericParameterNames.get(gtn)); |
| |
| if (bounds != null) { |
| boolean nameAdded = false; |
| for (ClassNode upperBound : bounds) { |
| if (!isWild) { |
| if (!nameAdded && upperBound != null || !resolve(classNode)) { |
| if (toDealWithGenerics) { |
| genericParameterNames.put(gtn, type); |
| type.setPlaceholder(true); |
| classNode.setRedirect(upperBound); |
| nameAdded = true; |
| } |
| } |
| |
| upperBoundsToResolve.add(tuple(upperBound, classNode)); |
| } |
| |
| if (upperBound != null && upperBound.isUsingGenerics()) { |
| upperBoundsWithGenerics.add(tuple(upperBound, type)); |
| } |
| } |
| } else { |
| if (!isWild) { |
| if (toDealWithGenerics) { |
| GenericsType originalGt = genericParameterNames.get(gtn); |
| genericParameterNames.put(gtn, type); |
| type.setPlaceholder(true); |
| |
| if (null == originalGt) { |
| classNode.setRedirect(ClassHelper.OBJECT_TYPE); |
| } else { |
| classNode.setRedirect(originalGt.getType()); |
| } |
| } |
| } |
| } |
| } |
| |
| for (Tuple2<ClassNode, ClassNode> tp : upperBoundsToResolve) { |
| ClassNode upperBound = tp.getV1(); |
| ClassNode classNode = tp.getV2(); |
| resolveOrFail(upperBound, classNode); |
| } |
| |
| for (Tuple2<ClassNode, GenericsType> tp : upperBoundsWithGenerics) { |
| ClassNode upperBound = tp.getV1(); |
| GenericsType gt = tp.getV2(); |
| resolveGenericsHeader(upperBound.getGenericsTypes(), 0 == level ? gt : rootType, level + 1); |
| } |
| } |
| |
| private boolean resolveGenericsType(final GenericsType genericsType) { |
| if (genericsType.isResolved()) return true; |
| currentClass.setUsingGenerics(true); |
| ClassNode type = genericsType.getType(); |
| // save name before redirect |
| GenericsTypeName name = new GenericsTypeName(type.getName()); |
| ClassNode[] bounds = genericsType.getUpperBounds(); |
| if (!genericParameterNames.containsKey(name)) { |
| if (bounds != null) { |
| for (ClassNode upperBound : bounds) { |
| resolveOrFail(upperBound, genericsType); |
| type.setRedirect(upperBound); |
| resolveGenericsTypes(upperBound.getGenericsTypes()); |
| } |
| } else if (genericsType.isWildcard()) { |
| type.setRedirect(ClassHelper.OBJECT_TYPE); |
| } else { |
| resolveOrFail(type, genericsType); |
| } |
| } else { |
| GenericsType gt = genericParameterNames.get(name); |
| type.setRedirect(gt.getType()); |
| genericsType.setPlaceholder(true); |
| } |
| |
| if (genericsType.getLowerBound() != null) { |
| resolveOrFail(genericsType.getLowerBound(), genericsType); |
| } |
| |
| if (resolveGenericsTypes(type.getGenericsTypes())) { |
| genericsType.setResolved(genericsType.getType().isResolved()); |
| } |
| return genericsType.isResolved(); |
| |
| } |
| |
| private static Map<String, ClassNode> findHierClasses(final ClassNode currentClass) { |
| Map<String, ClassNode> hierClasses = new LinkedHashMap<>(); |
| for (ClassNode classToCheck = currentClass; classToCheck != ClassHelper.OBJECT_TYPE; classToCheck = classToCheck.getSuperClass()) { |
| if (classToCheck == null || hierClasses.containsKey(classToCheck.getName())) break; |
| hierClasses.put(classToCheck.getName(), classToCheck); |
| } |
| return hierClasses; |
| } |
| } |
