java/compiler/impl/src/com/intellij/compiler/classFilesIndex/chainsSearch/MethodsChainLookupRangingHelper.java - platform/tools/idea - Git at Google

 /*
  * Copyright 2000-2013 JetBrains s.r.o.
  *
  * 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.intellij.compiler.classFilesIndex.chainsSearch;

 import com.intellij.codeInsight.NullableNotNullManager;
 import com.intellij.codeInsight.completion.JavaChainLookupElement;
 import com.intellij.compiler.classFilesIndex.chainsSearch.context.ChainCompletionContext;
 import com.intellij.compiler.classFilesIndex.chainsSearch.context.ContextRelevantStaticMethod;
 import com.intellij.compiler.classFilesIndex.chainsSearch.context.ContextRelevantVariableGetter;
 import com.intellij.compiler.classFilesIndex.chainsSearch.completion.lookup.ChainCompletionNewVariableLookupElement;
 import com.intellij.compiler.classFilesIndex.chainsSearch.completion.lookup.WeightableChainLookupElement;
 import com.intellij.compiler.classFilesIndex.chainsSearch.completion.lookup.sub.GetterLookupSubLookupElement;
 import com.intellij.compiler.classFilesIndex.chainsSearch.completion.lookup.sub.SubLookupElement;
 import com.intellij.compiler.classFilesIndex.chainsSearch.completion.lookup.sub.VariableSubLookupElement;
 import com.intellij.codeInsight.lookup.LookupElement;
 import com.intellij.codeInsight.lookup.VariableLookupItem;
 import com.intellij.psi.*;
 import com.intellij.util.containers.ContainerUtil;
 import gnu.trove.TIntObjectHashMap;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;

 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;

 import static com.intellij.compiler.classFilesIndex.chainsSearch.completion.lookup.ChainCompletionLookupElementUtil.createLookupElement;
 import static com.intellij.psi.CommonClassNames.JAVA_LANG_STRING;

 /**
  * @author Dmitry Batkovich <dmitry.batkovich@jetbrains.com>
  */
 public class MethodsChainLookupRangingHelper {

   public static List<LookupElement> chainsToWeightableLookupElements(final List<MethodsChain> chains,
                                                                      final ChainCompletionContext context) {
     final CachedRelevantStaticMethodSearcher staticMethodSearcher = new CachedRelevantStaticMethodSearcher(context);
     final List<LookupElement> lookupElements = new ArrayList<LookupElement>(chains.size());
     for (final MethodsChain chain : chains) {
       final LookupElement lookupElement = chainToWeightableLookupElement(chain, context, staticMethodSearcher);
       if (lookupElement != null) {
         lookupElements.add(lookupElement);
       }
     }
     return lookupElements;
   }

   @SuppressWarnings("ConstantConditions")
   @Nullable
   private static LookupElement chainToWeightableLookupElement(final MethodsChain chain,
                                                               final ChainCompletionContext context,
                                                               final CachedRelevantStaticMethodSearcher staticMethodSearcher) {
     final int chainSize = chain.size();
     assert chainSize != 0;
     final int lastMethodWeight = chain.getChainWeight();
     int unreachableParametersCount = 0;
     int notMatchedStringVars = 0;
     int matchedParametersInContext = 0;
     Boolean isFirstMethodStatic = null;
     Boolean hasCallingVariableInContext = null;
     LookupElement chainLookupElement = null;
     PsiClass newVariableClass = null;
     final NullableNotNullManager nullableNotNullManager = NullableNotNullManager.getInstance(context.getProject());

     for (final PsiMethod[] psiMethods : chain.getPath()) {
       final PsiMethod method =
         MethodChainsSearchUtil.getMethodWithMinNotPrimitiveParameters(psiMethods, Collections.singleton(context.getTarget().getClassQName()));
       if (method == null) {
         return null;
       }
       if (isFirstMethodStatic == null) {
         isFirstMethodStatic = psiMethods[0].hasModifierProperty(PsiModifier.STATIC);
       }
       final PsiClass qualifierClass;
       final boolean isHead = chainLookupElement == null;
       if (isHead) {
         final String qualifierClassName = chain.getQualifierClassName();
         qualifierClass = JavaPsiFacade.getInstance(context.getProject()).
           findClass(qualifierClassName, context.getResolveScope());
       }
       else {
         qualifierClass = null;
       }

       final MethodProcResult procResult = processMethod(method, qualifierClass, isHead, lastMethodWeight, context, staticMethodSearcher,
                                                         nullableNotNullManager);
       if (procResult == null) {
         return null;
       }
       if (hasCallingVariableInContext == null) {
         hasCallingVariableInContext = procResult.hasCallingVariableInContext();
       }
       if (isHead && procResult.isIntroduceNewVariable()) {
         newVariableClass = qualifierClass;
       }
       matchedParametersInContext += procResult.getMatchedParametersInContext();
       unreachableParametersCount += procResult.getUnreachableParametersCount();
       notMatchedStringVars += procResult.getNotMatchedStringVars();
       chainLookupElement =
         isHead ? procResult.getLookupElement() : new JavaChainLookupElement(chainLookupElement, procResult.getLookupElement());
     }

     if (newVariableClass != null) {
       chainLookupElement = ChainCompletionNewVariableLookupElement.create(newVariableClass, chainLookupElement);
     }

     final ChainRelevance relevance =
       new ChainRelevance(chainSize, lastMethodWeight, unreachableParametersCount, notMatchedStringVars, hasCallingVariableInContext,
                          isFirstMethodStatic, matchedParametersInContext);

     return new WeightableChainLookupElement(chainLookupElement, relevance);
   }


   @Nullable
   private static MethodProcResult processMethod(@NotNull final PsiMethod method,
                                                 @Nullable final PsiClass qualifierClass,
                                                 final boolean isHeadMethod,
                                                 final int weight,
                                                 final ChainCompletionContext context,
                                                 final CachedRelevantStaticMethodSearcher staticMethodSearcher,
                                                 final NullableNotNullManager nullableNotNullManager) {
     int unreachableParametersCount = 0;
     int notMatchedStringVars = 0;
     int matchedParametersInContext = 0;
     boolean hasCallingVariableInContext = false;
     boolean introduceNewVariable = false;
     final PsiParameterList parameterList = method.getParameterList();
     final TIntObjectHashMap<SubLookupElement> parametersMap = new TIntObjectHashMap<SubLookupElement>(parameterList.getParametersCount());
     final PsiParameter[] parameters = parameterList.getParameters();
     for (int i = 0; i < parameters.length; i++) {
       final PsiParameter parameter = parameters[i];
       final String typeQName = parameter.getType().getCanonicalText();
       if (JAVA_LANG_STRING.equals(typeQName)) {
         final PsiVariable relevantStringVar = context.findRelevantStringInContext(parameter.getName());
         if (relevantStringVar == null) {
           notMatchedStringVars++;
         }
         else {
           parametersMap.put(i, new VariableSubLookupElement(relevantStringVar));
         }
       }
       else if (!ChainCompletionStringUtil.isPrimitiveOrArrayOfPrimitives(typeQName)) {
         final Collection<PsiVariable> contextVariables = context.getVariables(typeQName);
         final PsiVariable contextVariable = ContainerUtil.getFirstItem(contextVariables, null);
         if (contextVariable != null) {
           if (contextVariables.size() == 1) parametersMap.put(i, new VariableSubLookupElement(contextVariable));
           matchedParametersInContext++;
           continue;
         }
         final Collection<ContextRelevantVariableGetter> relevantVariablesGetters = context.getRelevantVariablesGetters(typeQName);
         final ContextRelevantVariableGetter contextVariableGetter = ContainerUtil.getFirstItem(relevantVariablesGetters, null);
         if (contextVariableGetter != null) {
           if (relevantVariablesGetters.size() == 1) parametersMap.put(i, contextVariableGetter.createSubLookupElement());
           matchedParametersInContext++;
           continue;
         }
         final Collection<PsiMethod> containingClassMethods = context.getContainingClassMethods(typeQName);
         final PsiMethod contextRelevantGetter = ContainerUtil.getFirstItem(containingClassMethods, null);
         if (contextRelevantGetter != null) {
           if (containingClassMethods.size() == 1) parametersMap.put(i, new GetterLookupSubLookupElement(method.getName()));
           matchedParametersInContext++;
           continue;
         }
         final ContextRelevantStaticMethod contextRelevantStaticMethod =
           ContainerUtil.getFirstItem(staticMethodSearcher.getRelevantStaticMethods(typeQName, weight), null);
         if (contextRelevantStaticMethod != null) {
           //
           // In most cases it is not really relevant
           //
           //parametersMap.put(i, contextRelevantStaticMethod.createLookupElement());
           matchedParametersInContext++;
           continue;
         }
         if (!nullableNotNullManager.isNullable(parameter, true)) {
           unreachableParametersCount++;
         }
       }
     }
     final LookupElement lookupElement;
     if (isHeadMethod) {
       if (method.hasModifierProperty(PsiModifier.STATIC)) {
         hasCallingVariableInContext = true;
         lookupElement = createLookupElement(method, parametersMap);
       }
       else if (method.isConstructor()) {
         return null;
       }
       else {
         @SuppressWarnings("ConstantConditions")
         final String classQName = qualifierClass.getQualifiedName();
         if (classQName == null) return null;
         final Object e = ContainerUtil.getFirstItem(context.getContextRefElements(classQName), null);
         if (e != null) {
           final LookupElement firstChainElement;
           if (e instanceof PsiVariable) {
             firstChainElement = new VariableLookupItem((PsiVariable)e);
           }
           else if (e instanceof PsiMethod) {
             firstChainElement = createLookupElement((PsiMethod)e, null);
           }
           else if (e instanceof LookupElement) {
             firstChainElement = (LookupElement)e;
           }
           else {
             throw new AssertionError();
           }
           hasCallingVariableInContext = true;
           lookupElement = new JavaChainLookupElement(firstChainElement, createLookupElement(method, parametersMap));
         }
         else {
           lookupElement = createLookupElement(method, parametersMap);
           if (!context.getContainingClassQNames().contains(classQName)) {
             introduceNewVariable = true;
           }
         }
       }
     }
     else {
       lookupElement = createLookupElement(method, parametersMap);
     }
     return new MethodProcResult(lookupElement,
                                 unreachableParametersCount,
                                 notMatchedStringVars,
                                 hasCallingVariableInContext,
                                 introduceNewVariable,
                                 matchedParametersInContext);
   }

   private static class MethodProcResult {
     private final LookupElement myMethodLookup;
     private final int myUnreachableParametersCount;
     private final int myNotMatchedStringVars;
     private final boolean myHasCallingVariableInContext;
     private final boolean myIntroduceNewVariable;
     private final int myMatchedParametersInContext;

     private MethodProcResult(final LookupElement methodLookup,
                              final int unreachableParametersCount,
                              final int notMatchedStringVars,
                              final boolean hasCallingVariableInContext,
                              final boolean introduceNewVariable,
                              final int matchedParametersInContext) {
       myMethodLookup = methodLookup;
       myUnreachableParametersCount = unreachableParametersCount;
       myNotMatchedStringVars = notMatchedStringVars;
       myHasCallingVariableInContext = hasCallingVariableInContext;
       myIntroduceNewVariable = introduceNewVariable;
       myMatchedParametersInContext = matchedParametersInContext;
     }

     private boolean isIntroduceNewVariable() {
       return myIntroduceNewVariable;
     }

     private boolean hasCallingVariableInContext() {
       return myHasCallingVariableInContext;
     }

     private LookupElement getLookupElement() {
       return myMethodLookup;
     }

     private int getUnreachableParametersCount() {
       return myUnreachableParametersCount;
     }

     private int getNotMatchedStringVars() {
       return myNotMatchedStringVars;
     }

     public int getMatchedParametersInContext() {
       return myMatchedParametersInContext;
     }
   }
 }
	/*
	* Copyright 2000-2013 JetBrains s.r.o.
	*
	* 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.intellij.compiler.classFilesIndex.chainsSearch;

	import com.intellij.codeInsight.NullableNotNullManager;
	import com.intellij.codeInsight.completion.JavaChainLookupElement;
	import com.intellij.compiler.classFilesIndex.chainsSearch.context.ChainCompletionContext;
	import com.intellij.compiler.classFilesIndex.chainsSearch.context.ContextRelevantStaticMethod;
	import com.intellij.compiler.classFilesIndex.chainsSearch.context.ContextRelevantVariableGetter;
	import com.intellij.compiler.classFilesIndex.chainsSearch.completion.lookup.ChainCompletionNewVariableLookupElement;
	import com.intellij.compiler.classFilesIndex.chainsSearch.completion.lookup.WeightableChainLookupElement;
	import com.intellij.compiler.classFilesIndex.chainsSearch.completion.lookup.sub.GetterLookupSubLookupElement;
	import com.intellij.compiler.classFilesIndex.chainsSearch.completion.lookup.sub.SubLookupElement;
	import com.intellij.compiler.classFilesIndex.chainsSearch.completion.lookup.sub.VariableSubLookupElement;
	import com.intellij.codeInsight.lookup.LookupElement;
	import com.intellij.codeInsight.lookup.VariableLookupItem;
	import com.intellij.psi.*;
	import com.intellij.util.containers.ContainerUtil;
	import gnu.trove.TIntObjectHashMap;
	import org.jetbrains.annotations.NotNull;
	import org.jetbrains.annotations.Nullable;

	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.Collections;
	import java.util.List;

	import static com.intellij.compiler.classFilesIndex.chainsSearch.completion.lookup.ChainCompletionLookupElementUtil.createLookupElement;
	import static com.intellij.psi.CommonClassNames.JAVA_LANG_STRING;

	/**
	* @author Dmitry Batkovich <dmitry.batkovich@jetbrains.com>
	*/
	public class MethodsChainLookupRangingHelper {

	public static List<LookupElement> chainsToWeightableLookupElements(final List<MethodsChain> chains,
	final ChainCompletionContext context) {
	final CachedRelevantStaticMethodSearcher staticMethodSearcher = new CachedRelevantStaticMethodSearcher(context);
	final List<LookupElement> lookupElements = new ArrayList<LookupElement>(chains.size());
	for (final MethodsChain chain : chains) {
	final LookupElement lookupElement = chainToWeightableLookupElement(chain, context, staticMethodSearcher);
	if (lookupElement != null) {
	lookupElements.add(lookupElement);
	}
	}
	return lookupElements;
	}

	@SuppressWarnings("ConstantConditions")
	@Nullable
	private static LookupElement chainToWeightableLookupElement(final MethodsChain chain,
	final ChainCompletionContext context,
	final CachedRelevantStaticMethodSearcher staticMethodSearcher) {
	final int chainSize = chain.size();
	assert chainSize != 0;
	final int lastMethodWeight = chain.getChainWeight();
	int unreachableParametersCount = 0;
	int notMatchedStringVars = 0;
	int matchedParametersInContext = 0;
	Boolean isFirstMethodStatic = null;
	Boolean hasCallingVariableInContext = null;
	LookupElement chainLookupElement = null;
	PsiClass newVariableClass = null;
	final NullableNotNullManager nullableNotNullManager = NullableNotNullManager.getInstance(context.getProject());

	for (final PsiMethod[] psiMethods : chain.getPath()) {
	final PsiMethod method =
	MethodChainsSearchUtil.getMethodWithMinNotPrimitiveParameters(psiMethods, Collections.singleton(context.getTarget().getClassQName()));
	if (method == null) {
	return null;
	}
	if (isFirstMethodStatic == null) {
	isFirstMethodStatic = psiMethods[0].hasModifierProperty(PsiModifier.STATIC);
	}
	final PsiClass qualifierClass;
	final boolean isHead = chainLookupElement == null;
	if (isHead) {
	final String qualifierClassName = chain.getQualifierClassName();
	qualifierClass = JavaPsiFacade.getInstance(context.getProject()).
	findClass(qualifierClassName, context.getResolveScope());
	}
	else {
	qualifierClass = null;
	}

	final MethodProcResult procResult = processMethod(method, qualifierClass, isHead, lastMethodWeight, context, staticMethodSearcher,
	nullableNotNullManager);
	if (procResult == null) {
	return null;
	}
	if (hasCallingVariableInContext == null) {
	hasCallingVariableInContext = procResult.hasCallingVariableInContext();
	}
	if (isHead && procResult.isIntroduceNewVariable()) {
	newVariableClass = qualifierClass;
	}
	matchedParametersInContext += procResult.getMatchedParametersInContext();
	unreachableParametersCount += procResult.getUnreachableParametersCount();
	notMatchedStringVars += procResult.getNotMatchedStringVars();
	chainLookupElement =
	isHead ? procResult.getLookupElement() : new JavaChainLookupElement(chainLookupElement, procResult.getLookupElement());
	}

	if (newVariableClass != null) {
	chainLookupElement = ChainCompletionNewVariableLookupElement.create(newVariableClass, chainLookupElement);
	}

	final ChainRelevance relevance =
	new ChainRelevance(chainSize, lastMethodWeight, unreachableParametersCount, notMatchedStringVars, hasCallingVariableInContext,
	isFirstMethodStatic, matchedParametersInContext);

	return new WeightableChainLookupElement(chainLookupElement, relevance);
	}


	@Nullable
	private static MethodProcResult processMethod(@NotNull final PsiMethod method,
	@Nullable final PsiClass qualifierClass,
	final boolean isHeadMethod,
	final int weight,
	final ChainCompletionContext context,
	final CachedRelevantStaticMethodSearcher staticMethodSearcher,
	final NullableNotNullManager nullableNotNullManager) {
	int unreachableParametersCount = 0;
	int notMatchedStringVars = 0;
	int matchedParametersInContext = 0;
	boolean hasCallingVariableInContext = false;
	boolean introduceNewVariable = false;
	final PsiParameterList parameterList = method.getParameterList();
	final TIntObjectHashMap<SubLookupElement> parametersMap = new TIntObjectHashMap<SubLookupElement>(parameterList.getParametersCount());
	final PsiParameter[] parameters = parameterList.getParameters();
	for (int i = 0; i < parameters.length; i++) {
	final PsiParameter parameter = parameters[i];
	final String typeQName = parameter.getType().getCanonicalText();
	if (JAVA_LANG_STRING.equals(typeQName)) {
	final PsiVariable relevantStringVar = context.findRelevantStringInContext(parameter.getName());
	if (relevantStringVar == null) {
	notMatchedStringVars++;
	}
	else {
	parametersMap.put(i, new VariableSubLookupElement(relevantStringVar));
	}
	}
	else if (!ChainCompletionStringUtil.isPrimitiveOrArrayOfPrimitives(typeQName)) {
	final Collection<PsiVariable> contextVariables = context.getVariables(typeQName);
	final PsiVariable contextVariable = ContainerUtil.getFirstItem(contextVariables, null);
	if (contextVariable != null) {
	if (contextVariables.size() == 1) parametersMap.put(i, new VariableSubLookupElement(contextVariable));
	matchedParametersInContext++;
	continue;
	}
	final Collection<ContextRelevantVariableGetter> relevantVariablesGetters = context.getRelevantVariablesGetters(typeQName);
	final ContextRelevantVariableGetter contextVariableGetter = ContainerUtil.getFirstItem(relevantVariablesGetters, null);
	if (contextVariableGetter != null) {
	if (relevantVariablesGetters.size() == 1) parametersMap.put(i, contextVariableGetter.createSubLookupElement());
	matchedParametersInContext++;
	continue;
	}
	final Collection<PsiMethod> containingClassMethods = context.getContainingClassMethods(typeQName);
	final PsiMethod contextRelevantGetter = ContainerUtil.getFirstItem(containingClassMethods, null);
	if (contextRelevantGetter != null) {
	if (containingClassMethods.size() == 1) parametersMap.put(i, new GetterLookupSubLookupElement(method.getName()));
	matchedParametersInContext++;
	continue;
	}
	final ContextRelevantStaticMethod contextRelevantStaticMethod =
	ContainerUtil.getFirstItem(staticMethodSearcher.getRelevantStaticMethods(typeQName, weight), null);
	if (contextRelevantStaticMethod != null) {
	//
	// In most cases it is not really relevant
	//
	//parametersMap.put(i, contextRelevantStaticMethod.createLookupElement());
	matchedParametersInContext++;
	continue;
	}
	if (!nullableNotNullManager.isNullable(parameter, true)) {
	unreachableParametersCount++;
	}
	}
	}
	final LookupElement lookupElement;
	if (isHeadMethod) {
	if (method.hasModifierProperty(PsiModifier.STATIC)) {
	hasCallingVariableInContext = true;
	lookupElement = createLookupElement(method, parametersMap);
	}
	else if (method.isConstructor()) {
	return null;
	}
	else {
	@SuppressWarnings("ConstantConditions")
	final String classQName = qualifierClass.getQualifiedName();
	if (classQName == null) return null;
	final Object e = ContainerUtil.getFirstItem(context.getContextRefElements(classQName), null);
	if (e != null) {
	final LookupElement firstChainElement;
	if (e instanceof PsiVariable) {
	firstChainElement = new VariableLookupItem((PsiVariable)e);
	}
	else if (e instanceof PsiMethod) {
	firstChainElement = createLookupElement((PsiMethod)e, null);
	}
	else if (e instanceof LookupElement) {
	firstChainElement = (LookupElement)e;
	}
	else {
	throw new AssertionError();
	}
	hasCallingVariableInContext = true;
	lookupElement = new JavaChainLookupElement(firstChainElement, createLookupElement(method, parametersMap));
	}
	else {
	lookupElement = createLookupElement(method, parametersMap);
	if (!context.getContainingClassQNames().contains(classQName)) {
	introduceNewVariable = true;
	}
	}
	}
	}
	else {
	lookupElement = createLookupElement(method, parametersMap);
	}
	return new MethodProcResult(lookupElement,
	unreachableParametersCount,
	notMatchedStringVars,
	hasCallingVariableInContext,
	introduceNewVariable,
	matchedParametersInContext);
	}

	private static class MethodProcResult {
	private final LookupElement myMethodLookup;
	private final int myUnreachableParametersCount;
	private final int myNotMatchedStringVars;
	private final boolean myHasCallingVariableInContext;
	private final boolean myIntroduceNewVariable;
	private final int myMatchedParametersInContext;

	private MethodProcResult(final LookupElement methodLookup,
	final int unreachableParametersCount,
	final int notMatchedStringVars,
	final boolean hasCallingVariableInContext,
	final boolean introduceNewVariable,
	final int matchedParametersInContext) {
	myMethodLookup = methodLookup;
	myUnreachableParametersCount = unreachableParametersCount;
	myNotMatchedStringVars = notMatchedStringVars;
	myHasCallingVariableInContext = hasCallingVariableInContext;
	myIntroduceNewVariable = introduceNewVariable;
	myMatchedParametersInContext = matchedParametersInContext;
	}

	private boolean isIntroduceNewVariable() {
	return myIntroduceNewVariable;
	}

	private boolean hasCallingVariableInContext() {
	return myHasCallingVariableInContext;
	}

	private LookupElement getLookupElement() {
	return myMethodLookup;
	}

	private int getUnreachableParametersCount() {
	return myUnreachableParametersCount;
	}

	private int getNotMatchedStringVars() {
	return myNotMatchedStringVars;
	}

	public int getMatchedParametersInContext() {
	return myMatchedParametersInContext;
	}
	}
	}