gradle-3.1-src.zip

/* * Copyright 2016 the original author or authors. * * Licensed 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.gradle.groovy.scripts.internal; import org.codehaus.groovy.GroovyBugError; import org.codehaus.groovy.ast.*; import org.codehaus.groovy.ast.expr.*; 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; import org.codehaus.groovy.control.CompilationUnit; import org.codehaus.groovy.control.ResolveVisitor; import org.codehaus.groovy.control.SourceUnit; import org.codehaus.groovy.syntax.Types; import org.codehaus.groovy.transform.trait.Traits; import org.objectweb.asm.Opcodes; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.reflect.Modifier; import java.util.*; /** * A Gradle version of the Groovy {@link ResolveVisitor} that takes some shortcuts to make resolving faster. It tries to be as close as the original implementation, while having a significant impact * on performance, by taking advantage of knowlegdge of Gradle default imports, including a mapping from simple name to fully qualified class name. It also avoids unnecessary lookups of classnodes. * * @since 2.12 */ public class GradleResolveVisitor extends ResolveVisitor { private ClassNode currentClass; // note: BigInteger and BigDecimal are also imported by default public static final String[] DEFAULT_IMPORTS = {"java.lang.", "java.io.", "java.net.", "java.util.", "groovy.lang.", "groovy.util."}; private final Map<String, List<String>> simpleNameToFQN; private final String[] gradlePublicPackages; private CompilationUnit compilationUnit; private SourceUnit source; private VariableScope currentScope; private boolean isTopLevelProperty = true; private boolean inPropertyExpression; private boolean inClosure; private Map<String, GenericsType> genericParameterNames = new HashMap<String, GenericsType>(); private Set<FieldNode> fieldTypesChecked = new HashSet<FieldNode>(); 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 { private final ClassNode knownEnclosingType; public ConstructedNestedClass(ClassNode outer, String inner) { super(outer.getName() + "$" + replacePoints(inner), Opcodes.ACC_PUBLIC, ClassHelper.OBJECT_TYPE); this.knownEnclosingType = outer; this.isPrimaryNode = false; } public boolean hasPackageName() { if (redirect() != this) { return super.hasPackageName(); } return knownEnclosingType.hasPackageName(); } public String setName(String name) { if (redirect() != this) { return super.setName(name); } else { throw new GroovyBugError("ConstructedNestedClass#setName should not be called"); } } } private static String replacePoints(String name) { return name.replace('.', '$'); } /** * 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 { private final String prefix; private String className; public ConstructedClassWithPackage(String pkg, String name) { super(pkg + name, Opcodes.ACC_PUBLIC, ClassHelper.OBJECT_TYPE); isPrimaryNode = false; this.prefix = pkg; this.className = name; } public String getName() { if (redirect() != this) { return super.getName(); } return prefix + className; } public boolean hasPackageName() { if (redirect() != this) { return super.hasPackageName(); } return getName().indexOf('.') != -1; } public String setName(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 { private final String className; public LowerCaseClass(String name) { super(name, Opcodes.ACC_PUBLIC, ClassHelper.OBJECT_TYPE); isPrimaryNode = false; this.className = name; } public String getName() { if (redirect() != this) { return super.getName(); } return className; } public boolean hasPackageName() { if (redirect() != this) { return super.hasPackageName(); } return false; } public String setName(String name) { if (redirect() != this) { return super.setName(name); } else { throw new GroovyBugError("LowerCaseClass#setName should not be called"); } } } public GradleResolveVisitor(CompilationUnit cu, String[] exportedPackages, Map<String, List<String>> simpleNameToFQN) { super(cu); compilationUnit = cu; this.classNodeResolver = new ClassNodeResolver(); this.simpleNameToFQN = simpleNameToFQN; this.gradlePublicPackages = exportedPackages; } public void startResolving(ClassNode node, SourceUnit source) { this.source = source; visitClass(node); } protected void visitConstructorOrMethod(MethodNode node, boolean isConstructor) { VariableScope oldScope = currentScope; currentScope = node.getVariableScope(); Map<String, GenericsType> oldPNames = genericParameterNames; genericParameterNames = new HashMap<String, GenericsType>(genericParameterNames); resolveGenericsHeader(node.getGenericsTypes()); Parameter[] paras = node.getParameters(); for