android/src/com/android/tools/idea/gradle/service/resolve/AndroidDslContributor.java - platform/tools/adt/idea - Git at Google

 /*
  * Copyright (C) 2013 The Android Open Source Project
  *
  * 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 com.android.tools.idea.gradle.service.resolve;

 import com.android.annotations.VisibleForTesting;
 import com.android.tools.idea.gradle.parser.GradleBuildFile;
 import com.android.tools.lint.checks.GradleDetector;
 import com.google.common.base.Joiner;
 import com.google.common.base.Splitter;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Lists;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Key;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.psi.*;
 import com.intellij.psi.scope.PsiScopeProcessor;
 import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.util.NotNullFunction;
 import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.plugins.gradle.service.GradleBuildClasspathManager;
 import org.jetbrains.plugins.gradle.service.resolve.GradleMethodContextContributor;
 import org.jetbrains.plugins.gradle.service.resolve.GradleResolverUtil;
 import org.jetbrains.plugins.groovy.lang.psi.GroovyFile;
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.arguments.GrArgumentList;
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.blocks.GrClosableBlock;
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrMethodCall;
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrReferenceExpression;
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.path.GrMethodCallExpression;
 import org.jetbrains.plugins.groovy.lang.psi.impl.GroovyPsiManager;
 import org.jetbrains.plugins.groovy.lang.psi.impl.synthetic.GrLightMethodBuilder;
 import org.jetbrains.plugins.groovy.lang.psi.impl.synthetic.GrLightParameter;
 import org.jetbrains.plugins.groovy.lang.psi.impl.synthetic.GrLightVariable;
 import org.jetbrains.plugins.groovy.lang.psi.util.GroovyPropertyUtils;

 import java.util.*;

 /**
  * {@link AndroidDslContributor} provides symbol resolution for identifiers inside the android block
  * in a Gradle build script.
  */
 public class AndroidDslContributor implements GradleMethodContextContributor {
   private static final Logger LOG = Logger.getInstance(AndroidDslContributor.class);

   @NonNls private static final String DSL_ANDROID = "android";
   @NonNls private static final String ANDROID_FQCN = "com.android.build.gradle.AppExtension";
   @NonNls private static final String ANDROID_LIB_FQCN = "com.android.build.gradle.LibraryExtension";

   private static final Key<PsiElement> CONTRIBUTOR_KEY = Key.create("AndroidDslContributor.key");

   @NonNls private List<VirtualFile> myLastClassPath = Collections.emptyList();

   private static final Map<String, String> ourDslForClassMap = ImmutableMap.of(
     "com.android.builder.DefaultProductFlavor", "com.android.build.gradle.internal.dsl.ProductFlavorDsl",
     "com.android.builder.DefaultBuildType", "com.android.build.gradle.internal.dsl.BuildTypeDsl",
     "com.android.builder.model.SigningConfig", "com.android.build.gradle.internal.dsl.SigningConfigDsl");

   @Override
   public void process(@NotNull List<String> callStack,
                       @NotNull PsiScopeProcessor processor,
                       @NotNull ResolveState state,
                       @NotNull PsiElement place) {
     // The Android DSL within a Gradle build script looks something like this:
     //     android {
     //         compileSdkVersion 18
     //         buildToolsVersion "19.0.0"
     //
     //         defaultConfig {
     //           minSdkVersion 8
     //         }
     //
     //         buildTypes {
     //           release {
     //             runProguard false
     //             proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.txt'
     //           }
     //         }
     //
     //         lintOptions {
     //           quiet true
     //         }
     //     }
     // This method receives a callstack leading to a particular symbol, e.g. android.compileSdkVersion, or
     // android.buildTypes.release.runProguard. Based on the given call stack, we have to resolve either to a particular class or to a
     // particular setter within the class.
     //
     // The blocks are processed top down i.e. android is resolved before any symbols within the android closure are resolved.
     // When a particular symbol is resolved, the resolution is cached as user data of that PsiElement under CONTRIBUTOR_KEY.
     // All symbols inside the android block first attempt to determine their parent method, and look at the parent contributor.
     // Depending on the parent contributor (method or class), the symbols are resolved to be either method calls of a class or
     // new domain objects.


     // There are two issues that necessitate this custom processing: 1. Groovy doesn't know what the block corresponding to
     // 'android' with a closure means i.e. it doesn't know that it is an extension provided by the android Gradle plugin.
     // 2. Once it understands that 'android' is a closure of a certain type, it still stumbles over methods that take in
     // either an Action<T> or a Action<NamedDomainObject<T>>. So most of the code simply tries to match the former to a method
     // that takes a closure<T> and the latter to be a closure that defines objects with closure<T>

     // we only care about symbols within the android closure
     String topLevel = ContainerUtil.getLastItem(callStack, null);
     if (!DSL_ANDROID.equals(topLevel)) {
       return;
     }

     logClassPathOnce(place.getProject());

     GroovyPsiManager psiManager = GroovyPsiManager.getInstance(place.getProject());

     // top level android block
     if (callStack.size() == 1) {
       String fqcn = resolveAndroidExtension(place.getContainingFile());
       PsiClass contributorClass = fqcn == null ? null : findClassByName(psiManager, place.getResolveScope(), fqcn);
       if (contributorClass != null) {
         String qualifiedName = contributorClass.getQualifiedName();
         if (qualifiedName == null) {
           qualifiedName = fqcn;
         }

         // resolve 'android' as a method that takes a closure
         resolveToMethodWithClosure(place, contributorClass, qualifiedName, processor, state, psiManager);
         cacheContributorInfo(place, contributorClass);
       }
       return;
     }

     // For all blocks within android, we first figure out who contributed the parent block.
     PsiElement parentContributor = getParentContributor(place);
     if (parentContributor == null) {
       return;
     }

     // if the parent object is a class, then process the current identifier as a method of the parent class
     if (parentContributor instanceof PsiClass) {
       PsiMethod method =
         findAndProcessContributingMethod(callStack.get(0), processor, state, place, (PsiClass)parentContributor, psiManager);
       cacheContributorInfo(place, method);
       return;
     }

     // if the parent object is a method, then the type of the current object depends on the arguments of the parent:
     // (In the snippets below, ^ points to the current symbol being resolved).
     //     1. lintOptions { ^quiet = true; }
     //        lintOptions is declared as: lintOptions(Action<LintOptionsImpl> action).
     //        So 'quiet' is simply a method on the LintOptionsImpl class.
     //     2. buildTypes { debug^ { } }
     //        buildTypes is declared as: buildTypes(Action<NamedDomainObjectContainer<DefaultBuildType>> action)
     //        So debug is a named domain object of type DefaultBuildType
     //     3. sourceSets {
     //             main {}
     //             debug.setRoot {}
     //        }
     //        This is similar to case 2, we just need to make sure that debug is resolved as a variable of type AndroidSourceSet
     if (!(parentContributor instanceof PsiMethod)) {
       return;
     }

     // determine the type variable present in the parent method
     ParametrizedTypeExtractor typeExtractor = getTypeExtractor((PsiMethod)parentContributor);
     if (typeExtractor == null) {
       LOG.info("inside the closure of a method, but unable to extract the closure parameter's type.");
       return;
     }

     if (typeExtractor.hasNamedDomainObjectContainer()) {
       // this symbol must be a NamedDomainObject<T>
       // so define a it as a method with the given name (place.getText()) with an argument Closure<T>
       String namedDomainObject = typeExtractor.getNamedDomainObject();
       assert namedDomainObject != null : typeExtractor.getCanonicalType(); // because hasNamedDomainObjectContainer()

       PsiClass contributorClass = findClassByName(psiManager, place.getResolveScope(), namedDomainObject);
       if (contributorClass != null) {
         String qualifiedName = contributorClass.getQualifiedName();
         if (qualifiedName == null) {
           qualifiedName = namedDomainObject;
         }
         resolveToMethodWithClosure(place, contributorClass, qualifiedName, processor, state, psiManager);
         cacheContributorInfo(place, contributorClass);
       }
       return;
     }

     if (typeExtractor.isClosure()) {
       // the parent method was of type Action<T>, so this is simply a method of class T
       String clz = typeExtractor.getClosureType();
       assert clz != null : typeExtractor.getCanonicalType(); // because typeExtractor.isClosure()

       PsiClass contributorClass = findClassByName(psiManager, place.getResolveScope(), clz);
       if (contributorClass == null) {
         return;
       }

       PsiMethod method = findAndProcessContributingMethod(callStack.get(0), processor, state, place, contributorClass, psiManager);
       cacheContributorInfo(place, method);
     }
   }

   private static void resolveToMethodWithClosure(PsiElement place,
                                                  PsiElement resolveToElement,
                                                  String closureTypeFqcn,
                                                  PsiScopeProcessor processor,
                                                  ResolveState state,
                                                  GroovyPsiManager psiManager) {
     if (place.getParent() instanceof GrMethodCallExpression) {
       GrLightMethodBuilder methodWithClosure =
         GradleResolverUtil.createMethodWithClosure(place.getText(), closureTypeFqcn, null, place, psiManager);
       if (methodWithClosure != null) {
         processor.execute(methodWithClosure, state);
         methodWithClosure.setNavigationElement(resolveToElement);
       }
     } else if (place.getParent() instanceof GrReferenceExpression) {
       GrLightVariable variable = new GrLightVariable(place.getManager(), place.getText(), closureTypeFqcn, place);
       processor.execute(variable, state);
     }
   }

   @Nullable
   private static PsiMethod findAndProcessContributingMethod(String symbol,
                                                             PsiScopeProcessor processor,
                                                             ResolveState state,
                                                             PsiElement place,
                                                             PsiClass contributorClass,
                                                             GroovyPsiManager psiManager) {
     PsiMethod method = getContributingMethod(place, contributorClass, symbol);
     if (method == null) {
       return null;
     }

     ParametrizedTypeExtractor typeExtractor = getTypeExtractor(method);
     if (typeExtractor != null && !typeExtractor.hasNamedDomainObjectContainer() && typeExtractor.isClosure()) {
       // method takes a closure argument
       String clz = typeExtractor.getClosureType();
       if (clz == null) {
         clz = CommonClassNames.JAVA_LANG_OBJECT;
       }
       if (ourDslForClassMap.containsKey(clz)) {
         clz = ourDslForClassMap.get(clz);
       }
       resolveToMethodWithClosure(place, method, clz, processor, state, psiManager);
     } else {
       GrLightMethodBuilder builder = new GrLightMethodBuilder(place.getManager(), method.getName());
       PsiElementFactory factory = JavaPsiFacade.getElementFactory(place.getManager().getProject());
       PsiType type = new PsiArrayType(factory.createTypeByFQClassName(CommonClassNames.JAVA_LANG_OBJECT, place.getResolveScope()));
       builder.addParameter(new GrLightParameter("param", type, builder));
       PsiClassType retType = factory.createTypeByFQClassName(CommonClassNames.JAVA_LANG_OBJECT, place.getResolveScope());
       builder.setReturnType(retType);
       processor.execute(builder, state);

       builder.setNavigationElement(method);
     }

     return method;
   }

   @Nullable
   private static PsiMethod getContributingMethod(PsiElement place,
                                                  PsiClass contributorClass,
                                                  String methodName) {
     GrMethodCall call = PsiTreeUtil.getParentOfType(place, GrMethodCall.class);
     if (call == null) {
       return null;
     }

     GrArgumentList args = call.getArgumentList();
     int argsCount = GradleResolverUtil.getGrMethodArumentsCount(args);

     PsiMethod[] methodsByName = findMethodByName(contributorClass, methodName);

     // first check to see if we can narrow down by # of arguments
     for (PsiMethod method : methodsByName) {
       if (method.getParameterList().getParametersCount() == argsCount) {
         return method;
       }
     }

     // if we couldn't narrow down by # of arguments, just use the first one
     return methodsByName.length > 0 ? methodsByName[0] : null;
   }

   @NotNull
   private static PsiMethod[] findMethodByName(PsiClass contributorClass, String methodName) {
     // Search for methods that match the given name, or a setter or getter.
     List<String> possibleMethods = Arrays.asList(methodName, GroovyPropertyUtils.getSetterName(methodName),
                                                  GroovyPropertyUtils.getGetterNameNonBoolean(methodName),
                                                  GroovyPropertyUtils.getGetterNameBoolean(methodName));

     for (String possibleMethod : possibleMethods) {
       PsiMethod[] methods = contributorClass.findMethodsByName(possibleMethod, true);
       if (methods.length > 0) {
         return methods;
       }
     }

     return PsiMethod.EMPTY_ARRAY;
   }

   @Nullable
   private static ParametrizedTypeExtractor getTypeExtractor(PsiMethod parentContributor) {
     PsiParameter[] parameters = parentContributor.getParameterList().getParameters();

     // The method must have had at least 1 closure argument.
     if (parameters.length < 1) {
       return null;
     }

     PsiParameter param = parameters[parameters.length-1];
     String parameterType = param.getType().getCanonicalText();

     return new ParametrizedTypeExtractor(parameterType);
   }

   /**
    * Returns the contributor of the enclosing block.
    * This is performed by first obtaining the closeable block that contains this element, and figuring out the method whose
    * closure argument is the closeable block. We do this instead of directly looking for a parent element of type method call
    * since this scheme allows us to handle both the following two cases:
    *   sourceSets {
    *      ^main {}
    *      ^debug.setRoot()
    *   }
    * In the above example, parent(parent('main')) == parent('debug') == 'sourceSets'.
    */
   @Nullable
   private static PsiElement getParentContributor(PsiElement place) {
     ApplicationManager.getApplication().assertReadAccessAllowed();

     GrClosableBlock closeableBlock = PsiTreeUtil.getParentOfType(place, GrClosableBlock.class);
     if (closeableBlock == null || !(closeableBlock.getParent() instanceof GrMethodCall)) {
       return null;
     }
     PsiElement parentContributor = closeableBlock.getParent().getUserData(CONTRIBUTOR_KEY);
     if (parentContributor == null) {
       return null;
     }
     return parentContributor;
   }

   @Nullable
   public static PsiClass findClassByName(GroovyPsiManager psiManager, GlobalSearchScope resolveScope, @NotNull String fqcn) {
     if (ourDslForClassMap.containsKey(fqcn)) {
       fqcn = ourDslForClassMap.get(fqcn);
     }

     return psiManager.findClassWithCache(fqcn, resolveScope);
   }

   private static void cacheContributorInfo(@NotNull PsiElement place, @Nullable PsiElement contributor) {
     if (contributor == null) {
       return;
     }

     // only cache info if this is a method call (and not a reference expression or something else),
     // as only method calls can contain closure arguments where this might be needed
     if (!(place.getParent() instanceof GrMethodCall)) {
       return;
     }

     // A method call of form "lintOptions { quiet = true }" has a PSI structure like:
     //   |- Method call
     //   |---- Reference Expression
     //   |--------PsiElement (identifier) (place usually points to this)
     //   |---- Arguments
     //   |---- Closeable block
     // Rather than caching information at the method call identifier, we cache it at the
     // root method call.
     GrMethodCall method = PsiTreeUtil.getParentOfType(place, GrMethodCall.class);
     if (method != null) {
       method.putUserData(CONTRIBUTOR_KEY, contributor);
     }
   }

   private void logClassPathOnce(@NotNull Project project) {
     List<VirtualFile> files = GradleBuildClasspathManager.getInstance(project).getAllClasspathEntries();
     if (ContainerUtil.equalsIdentity(files, myLastClassPath)) {
       return;
     }
     myLastClassPath = files;

     List<String> paths = ContainerUtil.map(files, new NotNullFunction<VirtualFile, String>() {
       @NotNull
       @Override
       public String fun(VirtualFile vf) {
         return vf.getPath();
       }
     });
     String classPath = Joiner.on(':').join(paths);
     LOG.info(String.format("Android DSL resolver classpath (project %1$s): %2$s", project.getName(), classPath));
   }

   /** Returns the class corresponding to the android extension for given file. */
   @Nullable
   private static String resolveAndroidExtension(PsiFile file) {
     assert file instanceof GroovyFile;
     List<String> plugins = GradleBuildFile.getPlugins((GroovyFile)file);
     if (plugins.contains(GradleDetector.APP_PLUGIN_ID) || plugins.contains(GradleDetector.OLD_APP_PLUGIN_ID)) {
       return ANDROID_FQCN;
     }
     else if (plugins.contains(GradleDetector.LIB_PLUGIN_ID) || plugins.contains(GradleDetector.OLD_LIB_PLUGIN_ID)) {
       return ANDROID_LIB_FQCN;
     }
     else {
       return null;
     }
   }

   /**
    * {@link ParametrizedTypeExtractor} is a simple utility class that allows a few queries to be made on a parameterized type
    * such as {@code Action<NamedDomainObject<X>>}.
    */
   @VisibleForTesting
   static class ParametrizedTypeExtractor {
     private static final String GRADLE_ACTION_FQCN = "org.gradle.api.Action";
     private static final String GRADLE_NAMED_DOMAIN_OBJECT_CONTAINER_FQCN = "org.gradle.api.NamedDomainObjectContainer";

     private static final Splitter SPLITTER = Splitter.onPattern("[<>]").trimResults().omitEmptyStrings();
     private final ArrayList<String> myParameterTypes;
     private final String myCanonicalType;

     public ParametrizedTypeExtractor(String canonicalType) {
       myCanonicalType = canonicalType;
       myParameterTypes = Lists.newArrayList(SPLITTER.split(canonicalType));
     }

     public String getCanonicalType() {
       return myCanonicalType;
     }

     public boolean isClosure() {
       return myParameterTypes.contains(GRADLE_ACTION_FQCN);
     }

     @Nullable
     public String getClosureType() {
       if (!isClosure()) {
         return null;
       }

       StringBuilder sb = new StringBuilder(100);
       for (int i = 1; i < myParameterTypes.size(); i++) {
         String type = myParameterTypes.get(i);
         type = type.replace("? extends ", ""); // remove wildcards
         type = type.replace("? super ", ""); // remove wildcards
         sb.append(type);
         if (i != myParameterTypes.size() - 1) {
           sb.append('<');
         }
       }
       for (int i = 1; i < myParameterTypes.size() - 1; i++) {
         sb.append('>');
       }

       return sb.toString();
     }

     @Nullable
     public String getNamedDomainObject() {
       return hasNamedDomainObjectContainer() ? ContainerUtil.getLastItem(myParameterTypes) : null;
     }

     public boolean hasNamedDomainObjectContainer() {
       for (String type : myParameterTypes) {
         if (type.contains(GRADLE_NAMED_DOMAIN_OBJECT_CONTAINER_FQCN)) {
           return true;
         }
       }

       return false;
     }
   }
 }
	/*
	* Copyright (C) 2013 The Android Open Source Project
	*
	* 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 com.android.tools.idea.gradle.service.resolve;

	import com.android.annotations.VisibleForTesting;
	import com.android.tools.idea.gradle.parser.GradleBuildFile;
	import com.android.tools.lint.checks.GradleDetector;
	import com.google.common.base.Joiner;
	import com.google.common.base.Splitter;
	import com.google.common.collect.ImmutableMap;
	import com.google.common.collect.Lists;
	import com.intellij.openapi.application.ApplicationManager;
	import com.intellij.openapi.diagnostic.Logger;
	import com.intellij.openapi.project.Project;
	import com.intellij.openapi.util.Key;
	import com.intellij.openapi.vfs.VirtualFile;
	import com.intellij.psi.*;
	import com.intellij.psi.scope.PsiScopeProcessor;
	import com.intellij.psi.search.GlobalSearchScope;
	import com.intellij.psi.util.PsiTreeUtil;
	import com.intellij.util.NotNullFunction;
	import com.intellij.util.containers.ContainerUtil;
	import org.jetbrains.annotations.NonNls;
	import org.jetbrains.annotations.NotNull;
	import org.jetbrains.annotations.Nullable;
	import org.jetbrains.plugins.gradle.service.GradleBuildClasspathManager;
	import org.jetbrains.plugins.gradle.service.resolve.GradleMethodContextContributor;
	import org.jetbrains.plugins.gradle.service.resolve.GradleResolverUtil;
	import org.jetbrains.plugins.groovy.lang.psi.GroovyFile;
	import org.jetbrains.plugins.groovy.lang.psi.api.statements.arguments.GrArgumentList;
	import org.jetbrains.plugins.groovy.lang.psi.api.statements.blocks.GrClosableBlock;
	import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrMethodCall;
	import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrReferenceExpression;
	import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.path.GrMethodCallExpression;
	import org.jetbrains.plugins.groovy.lang.psi.impl.GroovyPsiManager;
	import org.jetbrains.plugins.groovy.lang.psi.impl.synthetic.GrLightMethodBuilder;
	import org.jetbrains.plugins.groovy.lang.psi.impl.synthetic.GrLightParameter;
	import org.jetbrains.plugins.groovy.lang.psi.impl.synthetic.GrLightVariable;
	import org.jetbrains.plugins.groovy.lang.psi.util.GroovyPropertyUtils;

	import java.util.*;

	/**
	* {@link AndroidDslContributor} provides symbol resolution for identifiers inside the android block
	* in a Gradle build script.
	*/
	public class AndroidDslContributor implements GradleMethodContextContributor {
	private static final Logger LOG = Logger.getInstance(AndroidDslContributor.class);

	@NonNls private static final String DSL_ANDROID = "android";
	@NonNls private static final String ANDROID_FQCN = "com.android.build.gradle.AppExtension";
	@NonNls private static final String ANDROID_LIB_FQCN = "com.android.build.gradle.LibraryExtension";

	private static final Key<PsiElement> CONTRIBUTOR_KEY = Key.create("AndroidDslContributor.key");

	@NonNls private List<VirtualFile> myLastClassPath = Collections.emptyList();

	private static final Map<String, String> ourDslForClassMap = ImmutableMap.of(
	"com.android.builder.DefaultProductFlavor", "com.android.build.gradle.internal.dsl.ProductFlavorDsl",
	"com.android.builder.DefaultBuildType", "com.android.build.gradle.internal.dsl.BuildTypeDsl",
	"com.android.builder.model.SigningConfig", "com.android.build.gradle.internal.dsl.SigningConfigDsl");

	@Override
	public void process(@NotNull List<String> callStack,
	@NotNull PsiScopeProcessor processor,
	@NotNull ResolveState state,
	@NotNull PsiElement place) {
	// The Android DSL within a Gradle build script looks something like this:
	// android {
	// compileSdkVersion 18
	// buildToolsVersion "19.0.0"
	//
	// defaultConfig {
	// minSdkVersion 8
	// }
	//
	// buildTypes {
	// release {
	// runProguard false
	// proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.txt'
	// }
	// }
	//
	// lintOptions {
	// quiet true
	// }
	// }
	// This method receives a callstack leading to a particular symbol, e.g. android.compileSdkVersion, or
	// android.buildTypes.release.runProguard. Based on the given call stack, we have to resolve either to a particular class or to a
	// particular setter within the class.
	//
	// The blocks are processed top down i.e. android is resolved before any symbols within the android closure are resolved.
	// When a particular symbol is resolved, the resolution is cached as user data of that PsiElement under CONTRIBUTOR_KEY.
	// All symbols inside the android block first attempt to determine their parent method, and look at the parent contributor.
	// Depending on the parent contributor (method or class), the symbols are resolved to be either method calls of a class or
	// new domain objects.


	// There are two issues that necessitate this custom processing: 1. Groovy doesn't know what the block corresponding to
	// 'android' with a closure means i.e. it doesn't know that it is an extension provided by the android Gradle plugin.
	// 2. Once it understands that 'android' is a closure of a certain type, it still stumbles over methods that take in
	// either an Action<T> or a Action<NamedDomainObject<T>>. So most of the code simply tries to match the former to a method
	// that takes a closure<T> and the latter to be a closure that defines objects with closure<T>

	// we only care about symbols within the android closure
	String topLevel = ContainerUtil.getLastItem(callStack, null);
	if (!DSL_ANDROID.equals(topLevel)) {
	return;
	}

	logClassPathOnce(place.getProject());

	GroovyPsiManager psiManager = GroovyPsiManager.getInstance(place.getProject());

	// top level android block
	if (callStack.size() == 1) {
	String fqcn = resolveAndroidExtension(place.getContainingFile());
	PsiClass contributorClass = fqcn == null ? null : findClassByName(psiManager, place.getResolveScope(), fqcn);
	if (contributorClass != null) {
	String qualifiedName = contributorClass.getQualifiedName();
	if (qualifiedName == null) {
	qualifiedName = fqcn;
	}

	// resolve 'android' as a method that takes a closure
	resolveToMethodWithClosure(place, contributorClass, qualifiedName, processor, state, psiManager);
	cacheContributorInfo(place, contributorClass);
	}
	return;
	}

	// For all blocks within android, we first figure out who contributed the parent block.
	PsiElement parentContributor = getParentContributor(place);
	if (parentContributor == null) {
	return;
	}

	// if the parent object is a class, then process the current identifier as a method of the parent class
	if (parentContributor instanceof PsiClass) {
	PsiMethod method =
	findAndProcessContributingMethod(callStack.get(0), processor, state, place, (PsiClass)parentContributor, psiManager);
	cacheContributorInfo(place, method);
	return;
	}

	// if the parent object is a method, then the type of the current object depends on the arguments of the parent:
	// (In the snippets below, ^ points to the current symbol being resolved).
	// 1. lintOptions { ^quiet = true; }
	// lintOptions is declared as: lintOptions(Action<LintOptionsImpl> action).
	// So 'quiet' is simply a method on the LintOptionsImpl class.
	// 2. buildTypes { debug^ { } }
	// buildTypes is declared as: buildTypes(Action<NamedDomainObjectContainer<DefaultBuildType>> action)
	// So debug is a named domain object of type DefaultBuildType
	// 3. sourceSets {
	// main {}
	// debug.setRoot {}
	// }
	// This is similar to case 2, we just need to make sure that debug is resolved as a variable of type AndroidSourceSet
	if (!(parentContributor instanceof PsiMethod)) {
	return;
	}

	// determine the type variable present in the parent method
	ParametrizedTypeExtractor typeExtractor = getTypeExtractor((PsiMethod)parentContributor);
	if (typeExtractor == null) {
	LOG.info("inside the closure of a method, but unable to extract the closure parameter's type.");
	return;
	}

	if (typeExtractor.hasNamedDomainObjectContainer()) {
	// this symbol must be a NamedDomainObject<T>
	// so define a it as a method with the given name (place.getText()) with an argument Closure<T>
	String namedDomainObject = typeExtractor.getNamedDomainObject();
	assert namedDomainObject != null : typeExtractor.getCanonicalType(); // because hasNamedDomainObjectContainer()

	PsiClass contributorClass = findClassByName(psiManager, place.getResolveScope(), namedDomainObject);
	if (contributorClass != null) {
	String qualifiedName = contributorClass.getQualifiedName();
	if (qualifiedName == null) {
	qualifiedName = namedDomainObject;
	}
	resolveToMethodWithClosure(place, contributorClass, qualifiedName, processor, state, psiManager);
	cacheContributorInfo(place, contributorClass);
	}
	return;
	}

	if (typeExtractor.isClosure()) {
	// the parent method was of type Action<T>, so this is simply a method of class T
	String clz = typeExtractor.getClosureType();
	assert clz != null : typeExtractor.getCanonicalType(); // because typeExtractor.isClosure()

	PsiClass contributorClass = findClassByName(psiManager, place.getResolveScope(), clz);
	if (contributorClass == null) {
	return;
	}

	PsiMethod method = findAndProcessContributingMethod(callStack.get(0), processor, state, place, contributorClass, psiManager);
	cacheContributorInfo(place, method);
	}
	}

	private static void resolveToMethodWithClosure(PsiElement place,
	PsiElement resolveToElement,
	String closureTypeFqcn,
	PsiScopeProcessor processor,
	ResolveState state,
	GroovyPsiManager psiManager) {
	if (place.getParent() instanceof GrMethodCallExpression) {
	GrLightMethodBuilder methodWithClosure =
	GradleResolverUtil.createMethodWithClosure(place.getText(), closureTypeFqcn, null, place, psiManager);
	if (methodWithClosure != null) {
	processor.execute(methodWithClosure, state);
	methodWithClosure.setNavigationElement(resolveToElement);
	}
	} else if (place.getParent() instanceof GrReferenceExpression) {
	GrLightVariable variable = new GrLightVariable(place.getManager(), place.getText(), closureTypeFqcn, place);
	processor.execute(variable, state);
	}
	}

	@Nullable
	private static PsiMethod findAndProcessContributingMethod(String symbol,
	PsiScopeProcessor processor,
	ResolveState state,
	PsiElement place,
	PsiClass contributorClass,
	GroovyPsiManager psiManager) {
	PsiMethod method = getContributingMethod(place, contributorClass, symbol);
	if (method == null) {
	return null;
	}

	ParametrizedTypeExtractor typeExtractor = getTypeExtractor(method);
	if (typeExtractor != null && !typeExtractor.hasNamedDomainObjectContainer() && typeExtractor.isClosure()) {
	// method takes a closure argument
	String clz = typeExtractor.getClosureType();
	if (clz == null) {
	clz = CommonClassNames.JAVA_LANG_OBJECT;
	}
	if (ourDslForClassMap.containsKey(clz)) {
	clz = ourDslForClassMap.get(clz);
	}
	resolveToMethodWithClosure(place, method, clz, processor, state, psiManager);
	} else {
	GrLightMethodBuilder builder = new GrLightMethodBuilder(place.getManager(), method.getName());
	PsiElementFactory factory = JavaPsiFacade.getElementFactory(place.getManager().getProject());
	PsiType type = new PsiArrayType(factory.createTypeByFQClassName(CommonClassNames.JAVA_LANG_OBJECT, place.getResolveScope()));
	builder.addParameter(new GrLightParameter("param", type, builder));
	PsiClassType retType = factory.createTypeByFQClassName(CommonClassNames.JAVA_LANG_OBJECT, place.getResolveScope());
	builder.setReturnType(retType);
	processor.execute(builder, state);

	builder.setNavigationElement(method);
	}

	return method;
	}

	@Nullable
	private static PsiMethod getContributingMethod(PsiElement place,
	PsiClass contributorClass,
	String methodName) {
	GrMethodCall call = PsiTreeUtil.getParentOfType(place, GrMethodCall.class);
	if (call == null) {
	return null;
	}

	GrArgumentList args = call.getArgumentList();
	int argsCount = GradleResolverUtil.getGrMethodArumentsCount(args);

	PsiMethod[] methodsByName = findMethodByName(contributorClass, methodName);

	// first check to see if we can narrow down by # of arguments
	for (PsiMethod method : methodsByName) {
	if (method.getParameterList().getParametersCount() == argsCount) {
	return method;
	}
	}

	// if we couldn't narrow down by # of arguments, just use the first one
	return methodsByName.length > 0 ? methodsByName[0] : null;
	}

	@NotNull
	private static PsiMethod[] findMethodByName(PsiClass contributorClass, String methodName) {
	// Search for methods that match the given name, or a setter or getter.
	List<String> possibleMethods = Arrays.asList(methodName, GroovyPropertyUtils.getSetterName(methodName),
	GroovyPropertyUtils.getGetterNameNonBoolean(methodName),
	GroovyPropertyUtils.getGetterNameBoolean(methodName));

	for (String possibleMethod : possibleMethods) {
	PsiMethod[] methods = contributorClass.findMethodsByName(possibleMethod, true);
	if (methods.length > 0) {
	return methods;
	}
	}

	return PsiMethod.EMPTY_ARRAY;
	}

	@Nullable
	private static ParametrizedTypeExtractor getTypeExtractor(PsiMethod parentContributor) {
	PsiParameter[] parameters = parentContributor.getParameterList().getParameters();

	// The method must have had at least 1 closure argument.
	if (parameters.length < 1) {
	return null;
	}

	PsiParameter param = parameters[parameters.length-1];
	String parameterType = param.getType().getCanonicalText();

	return new ParametrizedTypeExtractor(parameterType);
	}

	/**
	* Returns the contributor of the enclosing block.
	* This is performed by first obtaining the closeable block that contains this element, and figuring out the method whose
	* closure argument is the closeable block. We do this instead of directly looking for a parent element of type method call
	* since this scheme allows us to handle both the following two cases:
	* sourceSets {
	* ^main {}
	* ^debug.setRoot()
	* }
	* In the above example, parent(parent('main')) == parent('debug') == 'sourceSets'.
	*/
	@Nullable
	private static PsiElement getParentContributor(PsiElement place) {
	ApplicationManager.getApplication().assertReadAccessAllowed();

	GrClosableBlock closeableBlock = PsiTreeUtil.getParentOfType(place, GrClosableBlock.class);
	if (closeableBlock == null \|\| !(closeableBlock.getParent() instanceof GrMethodCall)) {
	return null;
	}
	PsiElement parentContributor = closeableBlock.getParent().getUserData(CONTRIBUTOR_KEY);
	if (parentContributor == null) {
	return null;
	}
	return parentContributor;
	}

	@Nullable
	public static PsiClass findClassByName(GroovyPsiManager psiManager, GlobalSearchScope resolveScope, @NotNull String fqcn) {
	if (ourDslForClassMap.containsKey(fqcn)) {
	fqcn = ourDslForClassMap.get(fqcn);
	}

	return psiManager.findClassWithCache(fqcn, resolveScope);
	}

	private static void cacheContributorInfo(@NotNull PsiElement place, @Nullable PsiElement contributor) {
	if (contributor == null) {
	return;
	}

	// only cache info if this is a method call (and not a reference expression or something else),
	// as only method calls can contain closure arguments where this might be needed
	if (!(place.getParent() instanceof GrMethodCall)) {
	return;
	}

	// A method call of form "lintOptions { quiet = true }" has a PSI structure like:
	// \|- Method call
	// \|---- Reference Expression
	// \|--------PsiElement (identifier) (place usually points to this)
	// \|---- Arguments
	// \|---- Closeable block
	// Rather than caching information at the method call identifier, we cache it at the
	// root method call.
	GrMethodCall method = PsiTreeUtil.getParentOfType(place, GrMethodCall.class);
	if (method != null) {
	method.putUserData(CONTRIBUTOR_KEY, contributor);
	}
	}

	private void logClassPathOnce(@NotNull Project project) {
	List<VirtualFile> files = GradleBuildClasspathManager.getInstance(project).getAllClasspathEntries();
	if (ContainerUtil.equalsIdentity(files, myLastClassPath)) {
	return;
	}
	myLastClassPath = files;

	List<String> paths = ContainerUtil.map(files, new NotNullFunction<VirtualFile, String>() {
	@NotNull
	@Override
	public String fun(VirtualFile vf) {
	return vf.getPath();
	}
	});
	String classPath = Joiner.on(':').join(paths);
	LOG.info(String.format("Android DSL resolver classpath (project %1$s): %2$s", project.getName(), classPath));
	}

	/** Returns the class corresponding to the android extension for given file. */
	@Nullable
	private static String resolveAndroidExtension(PsiFile file) {
	assert file instanceof GroovyFile;
	List<String> plugins = GradleBuildFile.getPlugins((GroovyFile)file);
	if (plugins.contains(GradleDetector.APP_PLUGIN_ID) \|\| plugins.contains(GradleDetector.OLD_APP_PLUGIN_ID)) {
	return ANDROID_FQCN;
	}
	else if (plugins.contains(GradleDetector.LIB_PLUGIN_ID) \|\| plugins.contains(GradleDetector.OLD_LIB_PLUGIN_ID)) {
	return ANDROID_LIB_FQCN;
	}
	else {
	return null;
	}
	}

	/**
	* {@link ParametrizedTypeExtractor} is a simple utility class that allows a few queries to be made on a parameterized type
	* such as {@code Action<NamedDomainObject<X>>}.
	*/
	@VisibleForTesting
	static class ParametrizedTypeExtractor {
	private static final String GRADLE_ACTION_FQCN = "org.gradle.api.Action";
	private static final String GRADLE_NAMED_DOMAIN_OBJECT_CONTAINER_FQCN = "org.gradle.api.NamedDomainObjectContainer";

	private static final Splitter SPLITTER = Splitter.onPattern("[<>]").trimResults().omitEmptyStrings();
	private final ArrayList<String> myParameterTypes;
	private final String myCanonicalType;

	public ParametrizedTypeExtractor(String canonicalType) {
	myCanonicalType = canonicalType;
	myParameterTypes = Lists.newArrayList(SPLITTER.split(canonicalType));
	}

	public String getCanonicalType() {
	return myCanonicalType;
	}

	public boolean isClosure() {
	return myParameterTypes.contains(GRADLE_ACTION_FQCN);
	}

	@Nullable
	public String getClosureType() {
	if (!isClosure()) {
	return null;
	}

	StringBuilder sb = new StringBuilder(100);
	for (int i = 1; i < myParameterTypes.size(); i++) {
	String type = myParameterTypes.get(i);
	type = type.replace("? extends ", ""); // remove wildcards
	type = type.replace("? super ", ""); // remove wildcards
	sb.append(type);
	if (i != myParameterTypes.size() - 1) {
	sb.append('<');
	}
	}
	for (int i = 1; i < myParameterTypes.size() - 1; i++) {
	sb.append('>');
	}

	return sb.toString();
	}

	@Nullable
	public String getNamedDomainObject() {
	return hasNamedDomainObjectContainer() ? ContainerUtil.getLastItem(myParameterTypes) : null;
	}

	public boolean hasNamedDomainObjectContainer() {
	for (String type : myParameterTypes) {
	if (type.contains(GRADLE_NAMED_DOMAIN_OBJECT_CONTAINER_FQCN)) {
	return true;
	}
	}

	return false;
	}
	}
	}