libraryLicense(name: "markdownj", libraryName: "markdownj", version: "0.4.2", license: "New BSD", url: "https://code.google.com/p/markdownj/", licenseUrl: "http://opensource.org/licenses/BSD-3-Clause")
libraryLicense(name: "Maven", version: "2.2.1", license: "Apache 2.0", url: "http://maven.apache.org/", licenseUrl: "http://maven.apache.org/license.html")
libraryLicense(name: "plexus-util", version: "2.0.6", license: "Apache 2.0", url: "http://maven.apache.org/", libraryNames:['plexus-utils-2.0.6.jar'], licenseUrl: "http://apache.org/licenses/LICENSE-2.0")
-libraryLicense(name: "aether-api", version: "1.11", libraryNames: ["aether-api-1.11.jar"], license: "Apache 2.0", url: "http://maven.apache.org/", licenseUrl: "http://maven.apache.org/license.html")
+libraryLicense(name: "aether-api", version: "1.13.1", libraryNames: ["aether-api-1.13.1.jar"], license: "Apache 2.0", url: "http://maven.apache.org/", licenseUrl: "http://maven.apache.org/license.html")
libraryLicense(name: "aether-api-0.9.0.M2.jar", version: "0.9.0.M2", libraryNames: ["aether-api-0.9.0.M2.jar"], license: "Eclipse Public License v1.0", url: "http://nexus.sonatype.org/", licenseUrl: "http://www.eclipse.org/org/documents/epl-v10.html")
libraryLicense(name: "maven-2.2.1-uber", version: "2.2.1", libraryNames: ["maven-2.2.1-uber.jar"], license: "Apache 2.0", url: "http://maven.apache.org/", licenseUrl: "http://maven.apache.org/license.html")
-libraryLicense(name: "maven-artifact", version: "3.0.3", libraryNames: ["maven-artifact-3.0.3.jar"], license: "Apache 2.0", url: "http://maven.apache.org/", licenseUrl: "http://maven.apache.org/license.html")
-libraryLicense(name: "maven-core", version: "3.0.3", libraryNames: ["maven-core-3.0.3.jar"], license: "Apache 2.0", url: "http://maven.apache.org/", licenseUrl: "http://maven.apache.org/license.html")
+libraryLicense(name: "maven-artifact", version: "3.0.5", libraryNames: ["maven-artifact-3.0.5.jar"], license: "Apache 2.0", url: "http://maven.apache.org/", licenseUrl: "http://maven.apache.org/license.html")
+libraryLicense(name: "maven-core", version: "3.0.5", libraryNames: ["maven-core-3.0.5.jar"], license: "Apache 2.0", url: "http://maven.apache.org/", licenseUrl: "http://maven.apache.org/license.html")
libraryLicense(name: "plexus-component-annotations", version: "1.5.5", libraryNames: ["plexus-component-annotations-1.5.5.jar"], license: "Apache 2.0", url: "http://maven.apache.org/", licenseUrl: "http://maven.apache.org/license.html")
-libraryLicense(name: "Maven3", libraryNames: ["Maven3", "maven-dependency-tree-1.2.jar", "archetype-catalog-2.2.jar", "archetype-common-2.2.jar"], version: "3.0.3", license: "Apache 2.0", url: "http://maven.apache.org/", licenseUrl: "http://maven.apache.org/license.html")
+libraryLicense(name: "Maven3", libraryNames: ["Maven3", "maven-dependency-tree-1.2.jar", "archetype-catalog-2.2.jar", "archetype-common-2.2.jar"], version: "3.0.5", license: "Apache 2.0", url: "http://maven.apache.org/", licenseUrl: "http://maven.apache.org/license.html")
libraryLicense(name: "Gradle", version: "1.9", license: "Apache 2.0", url: "http://gradle.org/", licenseUrl: "http://gradle.org/license")
libraryLicense(name: "GradleJnaPosix", version: "1.0.3", license: "LGPL 2.1", url: "http://www.jruby.org/", licenseUrl: "http://www.gnu.org/licenses/lgpl-2.1.txt")
libraryLicense(name: "Slf4j", version: "1.7.2", license: "MIT License", url: "http://slf4j.org/", licenseUrl: "http://slf4j.org/license.html")
@NotNull
private final String myKey;
@NotNull
- private final Collection<? extends MethodsUsageIndexConfigure> myRequiredIndicesConfigures;
+ private final Collection<? extends ClassFilesIndexConfigure> myRequiredIndicesConfigures;
ClassFilesIndexFeature(@NotNull final String key,
- @NotNull final Collection<? extends MethodsUsageIndexConfigure> requiredIndicesConfigures) {
+ @NotNull final Collection<? extends ClassFilesIndexConfigure> requiredIndicesConfigures) {
myKey = key;
myRequiredIndicesConfigures = requiredIndicesConfigures;
}
- ClassFilesIndexFeature(@NotNull final String key, @NotNull final MethodsUsageIndexConfigure requiredConfigure) {
- this(key, Collections.<MethodsUsageIndexConfigure>singleton(requiredConfigure));
+ ClassFilesIndexFeature(@NotNull final String key, @NotNull final ClassFilesIndexConfigure requiredConfigure) {
+ this(key, Collections.<ClassFilesIndexConfigure>singleton(requiredConfigure));
}
public RegistryValue getRegistryValue() {
}
@NotNull
- public Collection<? extends MethodsUsageIndexConfigure> getRequiredIndicesConfigures() {
+ public Collection<? extends ClassFilesIndexConfigure> getRequiredIndicesConfigures() {
return myRequiredIndicesConfigures;
}
}
}
for (final ClassFilesIndexFeature feature : ClassFilesIndexFeature.values()) {
if (feature.isEnabled() && !myEnabledFeatures.containsKey(feature)) {
- for (final MethodsUsageIndexConfigure configure : feature.getRequiredIndicesConfigures()) {
+ for (final ClassFilesIndexConfigure configure : feature.getRequiredIndicesConfigures()) {
if (!myEnabledIndexReaders.containsKey(configure)) {
notAvailableConfiguresVisitor.process(configure);
}
}
private synchronized void disposeFeature(final ClassFilesIndexFeature featureToRemove) {
- for (final MethodsUsageIndexConfigure requiredConfigure : featureToRemove.getRequiredIndicesConfigures()) {
+ for (final ClassFilesIndexConfigure requiredConfigure : featureToRemove.getRequiredIndicesConfigures()) {
boolean needClose = true;
for (final ClassFilesIndexFeature enabledFeature : myEnabledFeatures.keySet()) {
if (!enabledFeature.equals(featureToRemove) && enabledFeature.getRequiredIndicesConfigures().contains(requiredConfigure)) {
if (myEnabledFeatures.containsKey(feature)) {
throw new IllegalStateException(String.format("feature %s already contains", feature.getKey()));
}
- final Map<MethodsUsageIndexConfigure, ClassFilesIndexReaderBase> newIndices =
- new HashMap<MethodsUsageIndexConfigure, ClassFilesIndexReaderBase>();
+ final Map<ClassFilesIndexConfigure, ClassFilesIndexReaderBase> newIndices =
+ new HashMap<ClassFilesIndexConfigure, ClassFilesIndexReaderBase>();
FeatureState newFeatureState = FeatureState.AVAILABLE;
- for (final MethodsUsageIndexConfigure requiredConfigure : feature.getRequiredIndicesConfigures()) {
+ for (final ClassFilesIndexConfigure requiredConfigure : feature.getRequiredIndicesConfigures()) {
boolean isIndexAlreadyLoaded = false;
for (final ClassFilesIndexFeature enabledFeature : myEnabledFeatures.keySet()) {
if (enabledFeature.getRequiredIndicesConfigures().contains(requiredConfigure)) {
}
}
- /**
- * All inheritors MUST have constructor with only one parameter - Project
- */
@SuppressWarnings("ConstantConditions")
protected ClassFilesIndexReaderBase(final KeyDescriptor<K> keyDescriptor,
final DataExternalizer<V> valueExternalizer,
return true;
}
}
-
}
final ChainCompletionContext completionContext) {
if (resultQualifiedClassName == null ||
ChainCompletionStringUtil.isPrimitiveOrArrayOfPrimitives(resultQualifiedClassName) ||
- completionContext.getTargetQName().equals(resultQualifiedClassName)) {
+ completionContext.getTarget().equals(resultQualifiedClassName)) {
return Collections.emptyList();
}
final TreeSet<UsageIndexValue> indexValues = myIndexReader.getMethods(resultQualifiedClassName);
else {
final PsiMethod[] methods = completionContext.resolveNotDeprecated(methodInvocation);
method = MethodChainsSearchUtil
- .getMethodWithMinNotPrimitiveParameters(methods, Collections.singleton(completionContext.getTargetQName()));
+ .getMethodWithMinNotPrimitiveParameters(methods, Collections.singleton(completionContext.getTarget().getClassQName()));
myCachedResolveResults.put(methodInvocation, method);
if (method == null) {
return Collections.emptyList();
package com.intellij.compiler.classFilesIndex.chainsSearch;
import com.intellij.compiler.classFilesIndex.chainsSearch.context.ChainCompletionContext;
+import com.intellij.compiler.classFilesIndex.chainsSearch.context.TargetType;
import com.intellij.compiler.classFilesIndex.impl.MethodsUsageIndexReader;
import com.intellij.compiler.classFilesIndex.impl.UsageIndexValue;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.progress.ProgressManager;
import com.intellij.openapi.util.Pair;
-import com.intellij.psi.PsiClass;
-import com.intellij.psi.PsiManager;
-import com.intellij.psi.PsiMethod;
-import com.intellij.psi.PsiModifier;
+import com.intellij.psi.*;
import com.intellij.util.Function;
import com.intellij.util.containers.ContainerUtil;
import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
import org.jetbrains.jps.classFilesIndex.indexer.impl.MethodIncompleteSignature;
+import org.jetbrains.jps.incremental.storage.BuildDataManager;
import java.util.*;
private static final Logger LOG = Logger.getInstance(ChainsSearcher.class);
private static final double NEXT_METHOD_IN_CHAIN_RATIO = 1.5;
- public static List<MethodsChain> search(final MethodsUsageIndexReader indexReader,
- final String targetQName,
+ public static List<MethodsChain> search(final int pathMaximalLength,
+ final TargetType targetType,
final Set<String> contextQNames,
final int maxResultSize,
- final int pathMaximalLength,
- final ChainCompletionContext context) {
- final SearchInitializer initializer = createInitializer(targetQName, indexReader, context.getExcludedQNames(), context);
- return search(indexReader, initializer, contextQNames, pathMaximalLength, maxResultSize, targetQName, context);
+ final ChainCompletionContext context,
+ final MethodsUsageIndexReader methodsUsageIndexReader) {
+ final SearchInitializer initializer =
+ createInitializer(targetType,
+ context.getExcludedQNames(),
+ methodsUsageIndexReader,
+ context);
+ if (initializer == null) {
+ return Collections.emptyList();
+ }
+ return search(methodsUsageIndexReader,
+ initializer,
+ contextQNames,
+ pathMaximalLength,
+ maxResultSize,
+ targetType.getClassQName(),
+ context);
}
- private static SearchInitializer createInitializer(final String targetQName,
- final MethodsUsageIndexReader indexReader,
+ @Nullable
+ private static SearchInitializer createInitializer(final TargetType target,
final Set<String> excludedParamsTypesQNames,
+ final MethodsUsageIndexReader methodsUsageIndexReader,
final ChainCompletionContext context) {
- return new SearchInitializer(indexReader.getMethods(targetQName), targetQName, excludedParamsTypesQNames, context);
+ final TreeSet<UsageIndexValue> methods = methodsUsageIndexReader.getMethods(target.getClassQName());
+ return new SearchInitializer(methods, target.getClassQName(), excludedParamsTypesQNames, context);
}
@NotNull
@Override
public WeightAware<Pair<MethodIncompleteSignature, MethodsChain>> fun(
final WeightAware<MethodIncompleteSignature> methodIncompleteSignatureWeightAware) {
- final MethodIncompleteSignature
- underlying =
- methodIncompleteSignatureWeightAware
- .getUnderlying();
+ final MethodIncompleteSignature underlying = methodIncompleteSignatureWeightAware.getUnderlying();
return new WeightAware<Pair<MethodIncompleteSignature, MethodsChain>>(
new Pair<MethodIncompleteSignature, MethodsChain>(
- underlying, new MethodsChain(
- context.resolveNotDeprecated(
- underlying),
- methodIncompleteSignatureWeightAware
- .getWeight(),
- underlying.getOwner())),
- methodIncompleteSignatureWeightAware
- .getWeight());
+ underlying,
+ new MethodsChain(context.resolveNotDeprecated(underlying),
+ methodIncompleteSignatureWeightAware.getWeight(),
+ underlying.getOwner()
+ )
+ ),
+ methodIncompleteSignatureWeightAware.getWeight()
+ );
}
- }));
+ }
+ ));
int maxWeight = 0;
for (final MethodsChain methodsChain : knownDistance.values()) {
result.add(currentVertex.getUnderlying().getSecond());
continue;
}
- final SortedSet<UsageIndexValue> nextMethods = indexReader.getMethods(currentVertexUnderlying.getFirst().getOwner());
+ final String currentReturnType = currentVertexUnderlying.getFirst().getOwner();
+ final SortedSet<UsageIndexValue> nextMethods = indexReader.getMethods(currentReturnType);
final MaxSizeTreeSet<WeightAware<MethodIncompleteSignature>> currentSignatures =
new MaxSizeTreeSet<WeightAware<MethodIncompleteSignature>>(maxResultSize);
for (final UsageIndexValue indexValue : nextMethods) {
final MethodIncompleteSignature methodInvocation = indexValue.getMethodIncompleteSignature();
final PsiMethod[] psiMethods = context.resolveNotDeprecated(methodInvocation);
if (psiMethods.length != 0 && MethodChainsSearchUtil.checkParametersForTypesQNames(psiMethods, allExcludedNames)) {
- final MethodsChain newBestMethodsChain = currentVertexMethodsChain.addEdge(psiMethods, indexValue.getMethodIncompleteSignature().getOwner(), vertexDistance);
- currentSignatures.add(new WeightAware<MethodIncompleteSignature>(indexValue.getMethodIncompleteSignature(), vertexDistance));
+ final MethodsChain newBestMethodsChain =
+ currentVertexMethodsChain.addEdge(psiMethods, indexValue.getMethodIncompleteSignature().getOwner(), vertexDistance);
+ currentSignatures
+ .add(new WeightAware<MethodIncompleteSignature>(indexValue.getMethodIncompleteSignature(), vertexDistance));
knownDistance.put(vertex, newBestMethodsChain);
}
}
return resultHolder.getRawResult();
}
}
-}
+}
\ No newline at end of file
@SuppressWarnings("ConstantConditions")
@Nullable
- private static WeightableChainLookupElement chainToWeightableLookupElement(final MethodsChain chain,
- final ChainCompletionContext context) {
+ private static LookupElement chainToWeightableLookupElement(final MethodsChain chain, final ChainCompletionContext context) {
final int chainSize = chain.size();
assert chainSize != 0;
final int lastMethodWeight = chain.getChainWeight();
for (final PsiMethod[] psiMethods : chain.getPath()) {
final PsiMethod method =
- MethodChainsSearchUtil.getMethodWithMinNotPrimitiveParameters(psiMethods, Collections.singleton(context.getTargetQName()));
+ MethodChainsSearchUtil.getMethodWithMinNotPrimitiveParameters(psiMethods, Collections.singleton(context.getTarget().getClassQName()));
if (method == null) {
return null;
}
for (int i = 0; i < parameters.length; i++) {
final PsiParameter parameter = parameters[i];
final String typeQName = parameter.getType().getCanonicalText();
- if (typeQName != null) {
- if (JAVA_LANG_STRING.equals(typeQName)) {
- final PsiVariable relevantStringVar = context.findRelevantStringInContext(parameter.getName());
- if (relevantStringVar == null) {
- notMatchedStringVars++;
- }
- else {
- parametersMap.put(i, new VariableSubLookupElement(relevantStringVar));
- }
+ if (JAVA_LANG_STRING.equals(typeQName)) {
+ final PsiVariable relevantStringVar = context.findRelevantStringInContext(parameter.getName());
+ if (relevantStringVar == null) {
+ notMatchedStringVars++;
}
- 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;
- }
- //todo
- final ContextRelevantStaticMethod contextRelevantStaticMethod =
- ContainerUtil.getFirstItem(context.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++;
- }
+ 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(context.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++;
}
}
}
else {
unMatched++;
}
- if (context.getTargetQName().equals(canonicalText) || additionalExcludedNames.contains(canonicalText)) {
+ if (context.getTarget().getClassQName().equals(canonicalText) || additionalExcludedNames.contains(canonicalText)) {
hasTarget = true;
}
}
-/*
- * 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.completion;
import com.intellij.codeInsight.completion.*;
+import com.intellij.codeInsight.lookup.LookupElement;
import com.intellij.compiler.classFilesIndex.api.index.ClassFilesIndexFeature;
import com.intellij.compiler.classFilesIndex.api.index.ClassFilesIndexFeaturesHolder;
-import com.intellij.compiler.classFilesIndex.chainsSearch.ChainCompletionStringUtil;
-import com.intellij.compiler.classFilesIndex.chainsSearch.ChainsSearcher;
-import com.intellij.compiler.classFilesIndex.chainsSearch.MethodsChain;
-import com.intellij.compiler.classFilesIndex.chainsSearch.MethodsChainLookupRangingHelper;
+import com.intellij.compiler.classFilesIndex.chainsSearch.*;
import com.intellij.compiler.classFilesIndex.chainsSearch.context.ChainCompletionContext;
import com.intellij.compiler.classFilesIndex.chainsSearch.context.ContextUtil;
-import com.intellij.codeInsight.lookup.LookupElement;
+import com.intellij.compiler.classFilesIndex.chainsSearch.context.TargetType;
import com.intellij.compiler.classFilesIndex.impl.MethodsUsageIndexReader;
import com.intellij.openapi.application.ApplicationManager;
-import com.intellij.openapi.util.text.StringUtil;
+import com.intellij.openapi.module.ModuleUtilCore;
+import com.intellij.openapi.project.Project;
import com.intellij.patterns.ElementPattern;
import com.intellij.psi.*;
-import com.intellij.psi.search.GlobalSearchScope;
+import com.intellij.psi.impl.source.PsiImmediateClassType;
import com.intellij.psi.search.searches.DirectClassInheritorsSearch;
import com.intellij.psi.util.PsiTreeUtil;
-import com.intellij.util.ProcessingContext;
-import com.intellij.util.Processor;
-import com.intellij.util.SmartList;
+import com.intellij.util.*;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
* @author Dmitry Batkovich
*/
public class MethodsChainsCompletionContributor extends CompletionContributor {
- public static final int INVOCATIONS_THRESHOLD = 3;
+ private final static boolean IS_UNIT_TEST_MODE = ApplicationManager.getApplication().isUnitTestMode();
+
+ public static final int INVOCATIONS_THRESHOLD = 2;
+ public static final CompletionType COMPLETION_TYPE = IS_UNIT_TEST_MODE ? CompletionType.BASIC : CompletionType.SMART;
private final static int MAX_SEARCH_RESULT_SIZE = 5;
private final static int MAX_CHAIN_SIZE = 4;
@Override
public void fillCompletionVariants(final CompletionParameters parameters, final CompletionResultSet result) {
- if (parameters.getInvocationCount() >= INVOCATIONS_THRESHOLD
- && ClassFilesIndexFeaturesHolder.getInstance(parameters.getPosition().getProject())
+ if (parameters.getInvocationCount() >= INVOCATIONS_THRESHOLD &&
+ ClassFilesIndexFeaturesHolder.getInstance(parameters.getPosition().getProject())
.enableFeatureIfNeed(ClassFilesIndexFeature.METHOD_CHAINS_COMPLETION)) {
super.fillCompletionVariants(parameters, result);
- if (ApplicationManager.getApplication().isUnitTestMode()) {
- result.stopHere();
- }
}
}
public MethodsChainsCompletionContributor() {
final ElementPattern<PsiElement> pattern =
or(CompletionContributorPatternUtil.patternForMethodParameter(), CompletionContributorPatternUtil.patternForVariableAssignment());
- extend(CompletionType.BASIC, pattern, new CompletionProvider<CompletionParameters>() {
+ extend(COMPLETION_TYPE, pattern, new CompletionProvider<CompletionParameters>() {
@Override
protected void addCompletions(final @NotNull CompletionParameters parameters,
final ProcessingContext context,
final ChainCompletionContext completionContext = extractContext(parameters);
if (completionContext == null) return;
- final String targetClassQName = completionContext.getTargetQName();
final Set<String> contextTypesKeysSet = completionContext.getContextTypes();
final Set<String> contextRelevantTypes = new HashSet<String>(contextTypesKeysSet.size() + 1);
for (final String type : contextTypesKeysSet) {
contextRelevantTypes.add(type);
}
}
- contextRelevantTypes.remove(targetClassQName);
-
- final List<LookupElement> foundElements = searchForLookups(targetClassQName, contextRelevantTypes, completionContext);
- result.addAllElements(foundElements);
+ final TargetType target = completionContext.getTarget();
+ contextRelevantTypes.remove(target.getClassQName());
+ final List<LookupElement> elementsFoundByMethodsChainsSearch = searchForLookups(target, contextRelevantTypes, completionContext);
+ if (!IS_UNIT_TEST_MODE) {
+ result.runRemainingContributors(parameters, new Consumer<CompletionResult>() {
+ @Override
+ public void consume(final CompletionResult completionResult) {
+ final LookupElement lookupElement = completionResult.getLookupElement();
+ final PsiElement lookupElementPsi = lookupElement.getPsiElement();
+ if (lookupElementPsi != null) {
+ for (final LookupElement element : elementsFoundByMethodsChainsSearch) {
+ if (lookupElementPsi.isEquivalentTo(element.getPsiElement())) {
+ elementsFoundByMethodsChainsSearch.remove(element);
+ break;
+ }
+ }
+ }
+ result.passResult(completionResult);
+ }
+ });
+ } else {
+ result.stopHere();
+ }
+ result.addAllElements(elementsFoundByMethodsChainsSearch);
}
});
}
- private static List<LookupElement> searchForLookups(final String targetClassQName,
+ private static List<LookupElement> searchForLookups(final TargetType target,
final Set<String> contextRelevantTypes,
final ChainCompletionContext completionContext) {
- final MethodsUsageIndexReader methodsUsageIndexReader = MethodsUsageIndexReader.getInstance(completionContext.getProject());
+ final Project project = completionContext.getProject();
+ final MethodsUsageIndexReader methodsUsageIndexReader = MethodsUsageIndexReader.getInstance(project);
final List<MethodsChain> searchResult =
- searchChains(targetClassQName, contextRelevantTypes, MAX_SEARCH_RESULT_SIZE, MAX_CHAIN_SIZE, completionContext, methodsUsageIndexReader);
+ searchChains(target, contextRelevantTypes, MAX_SEARCH_RESULT_SIZE, MAX_CHAIN_SIZE, completionContext, methodsUsageIndexReader);
if (searchResult.size() < MAX_SEARCH_RESULT_SIZE) {
- final PsiClass aClass = JavaPsiFacade.getInstance(completionContext.getProject())
- .findClass(targetClassQName, GlobalSearchScope.allScope(completionContext.getProject()));
- if (aClass != null) {
- DirectClassInheritorsSearch.search(aClass).forEach(new Processor<PsiClass>() {
+ if (!target.isArray()) {
+ final List<MethodsChain> inheritorFilteredSearchResult = new SmartList<MethodsChain>();
+ final Processor<TargetType> consumer = new Processor<TargetType>() {
@Override
- public boolean process(final PsiClass psiClass) {
- final String inheritorQName = psiClass.getQualifiedName();
- if (!StringUtil.isEmpty(inheritorQName)) {
- final List<MethodsChain> inheritorFilteredSearchResult = new SmartList<MethodsChain>();
- //noinspection ConstantConditions
- for (final MethodsChain chain : searchChains(inheritorQName, contextRelevantTypes, MAX_SEARCH_RESULT_SIZE, MAX_CHAIN_SIZE,
- completionContext, methodsUsageIndexReader)) {
- boolean insert = true;
- for (final MethodsChain baseChain : searchResult) {
- final MethodsChain.CompareResult r = MethodsChain.compare(baseChain, chain, completionContext.getPsiManager());
- if (r != MethodsChain.CompareResult.NOT_EQUAL) {
- insert = false;
- break;
- }
- }
- if (insert) {
- inheritorFilteredSearchResult.add(chain);
+ public boolean process(final TargetType targetType) {
+ for (final MethodsChain chain : searchChains(targetType, contextRelevantTypes, MAX_SEARCH_RESULT_SIZE, MAX_CHAIN_SIZE,
+ completionContext, methodsUsageIndexReader)) {
+ boolean insert = true;
+ for (final MethodsChain baseChain : searchResult) {
+ final MethodsChain.CompareResult r = MethodsChain.compare(baseChain, chain, completionContext.getPsiManager());
+ if (r != MethodsChain.CompareResult.NOT_EQUAL) {
+ insert = false;
+ break;
}
}
- searchResult.addAll(inheritorFilteredSearchResult);
+ if (insert) {
+ inheritorFilteredSearchResult.add(chain);
+ }
+ }
+ searchResult.addAll(inheritorFilteredSearchResult);
+ return searchResult.size() < MAX_SEARCH_RESULT_SIZE;
+ }
+ };
+ DirectClassInheritorsSearch.search(((PsiClassType)target.getPsiType()).resolve()).forEach(new Processor<PsiClass>() {
+ @Override
+ public boolean process(final PsiClass psiClass) {
+ final String inheritorQName = psiClass.getQualifiedName();
+ if (inheritorQName == null) {
+ return true;
}
- return true;
+ return consumer.process(new TargetType(inheritorQName, false, new PsiImmediateClassType(psiClass, PsiSubstitutor.EMPTY)));
}
});
}
return filteredResult;
}
- private static List<MethodsChain> searchChains(final String targetQName,
+ private static List<MethodsChain> searchChains(final TargetType target,
final Set<String> contextVarsQNames,
final int maxResultSize,
final int maxChainSize,
final ChainCompletionContext context,
final MethodsUsageIndexReader methodsUsageIndexReader) {
- return ChainsSearcher.search(methodsUsageIndexReader, targetQName, contextVarsQNames, maxResultSize, maxChainSize, context);
+ return ChainsSearcher.search(maxChainSize, target, contextVarsQNames, maxResultSize, context, methodsUsageIndexReader);
}
-}
+}
\ No newline at end of file
import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.NotNullLazyValue;
import com.intellij.openapi.util.UserDataHolder;
-import com.intellij.psi.JavaPsiFacade;
-import com.intellij.psi.PsiManager;
-import com.intellij.psi.PsiMethod;
-import com.intellij.psi.PsiVariable;
+import com.intellij.psi.*;
import com.intellij.psi.search.GlobalSearchScope;
import com.intellij.util.containers.FactoryMap;
import com.intellij.util.containers.MultiMap;
}
};
private final PsiMethod myContextMethod;
- private final String myTargetQName;
+ private final TargetType myTarget;
private final Set<String> myContainingClassQNames;
private final MultiMap<String, PsiVariable> myContextVars;
private final MultiMap<String, PsiMethod> myContainingClassGetters;
}
ChainCompletionContext(final PsiMethod contextMethod,
- final String targetQName,
+ final TargetType target,
final Set<String> containingClassQNames,
final MultiMap<String, PsiVariable> contextVars,
final MultiMap<String, PsiMethod> containingClassGetters,
final Project project,
final GlobalSearchScope resolveScope) {
myContextMethod = contextMethod;
- myTargetQName = targetQName;
+ myTarget = target;
myContainingClassQNames = containingClassQNames;
myContextVars = contextVars;
myContainingClassGetters = containingClassGetters;
return myContextMethodName.getValue();
}
- public String getTargetQName() {
- return myTargetQName;
+ public TargetType getTarget() {
+ return myTarget;
}
@Nullable
if (variableType == null || containingElement == null) {
return null;
}
+
+ final TargetType target;
if (variableType instanceof PsiClassType) {
- final PsiClass aClass = ((PsiClassType)variableType).resolve();
- if (aClass != null) {
- if (aClass.hasTypeParameters()) {
- return null;
- }
- }
- else {
- return null;
- }
+ target = TargetType.create((PsiClassType)variableType);
}
-
- final String targetQName = variableType.getCanonicalText();
- if (targetQName == null || targetQName.endsWith("[]")) {
+ else if (variableType instanceof PsiArrayType) {
+ target = TargetType.create((PsiArrayType)variableType);
+ }
+ else {
+ return null;
+ }
+ if (target == null) {
return null;
}
}
}
- return create(method, targetQName, contextVars, contextMethods, containingClassQNames, containingElement.getProject(),
+ return create(method, target, contextVars, contextMethods, containingClassQNames, containingElement.getProject(),
containingElement.getResolveScope(), excludedQNames);
}
@Nullable
private static ChainCompletionContext create(final PsiMethod contextMethod,
- final String targetQName,
+ final TargetType target,
final List<PsiVariable> contextVars,
final List<PsiMethod> contextMethods,
final Set<String> containingClassQNames,
final Map<String, PsiVariable> stringVars = new HashMap<String, PsiVariable>();
for (final PsiMethod method : contextMethods) {
- PsiType returnType = method.getReturnType();
+ final PsiType returnType = method.getReturnType();
if (returnType != null) {
final String returnTypeQName = returnType.getCanonicalText();
- if (returnTypeQName != null) {
- containingClassGetters.putValue(returnTypeQName, method);
- }
+ containingClassGetters.putValue(returnTypeQName, method);
}
}
final PsiClass aClass = ((PsiClassType)type).resolve();
if (aClass != null) {
final String classQName = type.getCanonicalText();
- if (!targetQName.equals(classQName)) {
+ if (!target.getClassQName().equals(classQName)) {
classQNames.add(classQName);
classQNames.addAll(resolveSupersNamesRecursively(aClass));
for (final PsiMethod method : aClass.getAllMethods()) {
if (method.getParameterList().getParametersCount() == 0 && method.getName().startsWith("get")) {
- final String getterReturnTypeQName = method.getReturnType().getCanonicalText();
- if (getterReturnTypeQName != null) {
+ final PsiType returnType = method.getReturnType();
+ if (returnType != null) {
+ final String getterReturnTypeQName = returnType.getCanonicalText();
contextVarsGetters.putValue(getterReturnTypeQName, new ContextRelevantVariableGetter(var, method));
}
}
}
else {
final String classQName = type.getCanonicalText();
- if (classQName != null) {
- classQNames.add(classQName);
- }
+ classQNames.add(classQName);
}
for (final String qName : classQNames) {
classQNameToVariable.putValue(qName, var);
}
}
- return new ChainCompletionContext(contextMethod, targetQName, containingClassQNames, classQNameToVariable, containingClassGetters,
+ return new ChainCompletionContext(contextMethod, target, containingClassQNames, classQNameToVariable, containingClassGetters,
contextVarsGetters, stringVars, excludedQNames, project, resolveScope);
}
for (final PsiMethod method : methods) {
if (method.hasModifierProperty(PsiModifier.STATIC) == signature.isStatic()) {
final PsiType returnType = method.getReturnType();
- if (returnType != null && returnType.equalsToText(signature.getReturnType())) {
- filtered.add(method);
+ if (returnType != null) {
+ if (returnType instanceof PsiClassType) {
+ final PsiClass resolved = ((PsiClassType)returnType).resolve();
+ if (resolved == null) {
+ continue;
+ }
+ final String qualifiedName = resolved.getQualifiedName();
+ if (qualifiedName == null) {
+ continue;
+ }
+ if (qualifiedName.equals(signature.getReturnType())) {
+ filtered.add(method);
+ }
+ } else if (returnType.equalsToText(signature.getReturnType())) {
+ filtered.add(method);
+ }
}
}
}
--- /dev/null
+/*
+ * Copyright 2000-2014 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.context;
+
+import com.intellij.psi.*;
+import com.intellij.util.containers.ContainerUtil;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author Dmitry Batkovich
+ */
+public class TargetType {
+
+ private final String myClassQName;
+ private final boolean myArray;
+ private final PsiType myPsiType;
+
+ public TargetType(final String classQName,
+ final boolean isArray,
+ final PsiType targetType) {
+ myClassQName = classQName;
+ myArray = isArray;
+ myPsiType = targetType;
+ }
+
+ public String getClassQName() {
+ return myClassQName;
+ }
+
+ public boolean isArray() {
+ return myArray;
+ }
+
+ public PsiType getPsiType() {
+ return myPsiType;
+ }
+
+ @Nullable
+ public static TargetType create(final PsiArrayType arrayType) {
+ PsiType currentComponentType = arrayType.getComponentType();
+ while (currentComponentType instanceof PsiArrayType) {
+ currentComponentType = ((PsiArrayType)currentComponentType).getComponentType();
+ }
+ if (!(currentComponentType instanceof PsiClassType)) {
+ return null;
+ }
+ final String targetQName = arrayType.getCanonicalText();
+ return new TargetType(targetQName, true, arrayType);
+ }
+
+ @Nullable
+ public static TargetType create(final PsiClassType classType) {
+ final PsiClassType.ClassResolveResult resolvedGenerics = classType.resolveGenerics();
+ final PsiClass resolvedClass = resolvedGenerics.getElement();
+ if (resolvedClass == null) {
+ return null;
+ }
+ final String classQName = resolvedClass.getQualifiedName();
+ if (classQName == null) {
+ return null;
+ }
+ if (resolvedClass.hasTypeParameters()) {
+ return null;
+ }
+ return new TargetType(classQName, false, classType);
+ }
+}
import com.intellij.openapi.ui.DialogWrapper;
import com.intellij.openapi.util.Disposer;
import com.intellij.util.ui.FormBuilder;
+import org.jetbrains.annotations.Nullable;
import javax.swing.*;
import java.awt.*;
}
super.doOKAction();
}
+
+ @Nullable
+ @Override
+ protected String getHelpId() {
+ return "Edit_Library_dialog";
+ }
}
private boolean showCustomOptions(@NotNull ModuleBuilder builder) {
String card = builder.getBuilderId();
if (!myCustomSteps.containsKey(card)) {
- ModuleWizardStep step = builder.getCustomOptionsStep(this);
+ ModuleWizardStep step = builder.getCustomOptionsStep(myContext, this);
if (step == null) return false;
step.updateStep();
myCustomSteps.put(card, step);
}
public void onFrameworkSelectionChanged(FrameworkSupportNode node) {
- final FrameworkSupportModelListener multicaster = myDispatcher.getMulticaster();
final FrameworkSupportInModuleProvider provider = node.getUserObject();
//todo[nik]
+ boolean checked = node.isChecked();
if (provider instanceof OldFrameworkSupportProviderWrapper) {
final FrameworkSupportProvider oldProvider = ((OldFrameworkSupportProviderWrapper) provider).getProvider();
- if (node.isChecked()) {
- multicaster.frameworkSelected(oldProvider);
- }
- else {
- multicaster.frameworkUnselected(oldProvider);
- }
+ selectFramework(oldProvider, checked);
}
for (FrameworkSupportInModuleProvider.FrameworkDependency dependency : provider.getDependenciesFrameworkIds()) {
if (!dependency.isOptional()) {
}
}
+ public void selectFramework(FrameworkSupportProvider provider, boolean checked) {
+ final FrameworkSupportModelListener multicaster = myDispatcher.getMulticaster();
+ if (checked) {
+ multicaster.frameworkSelected(provider);
+ }
+ else {
+ multicaster.frameworkUnselected(provider);
+ }
+ }
+
public void fireWizardStepUpdated() {
myDispatcher.getMulticaster().wizardStepUpdated();
}
import com.intellij.CommonBundle;
import com.intellij.ide.IdeBundle;
-import com.intellij.ide.util.PropertiesComponent;
-import com.intellij.openapi.module.ModuleType;
import com.intellij.openapi.options.ConfigurationException;
import com.intellij.openapi.project.Project;
-import com.intellij.openapi.project.ProjectManager;
-import com.intellij.openapi.projectRoots.ProjectJdkTable;
import com.intellij.openapi.projectRoots.Sdk;
import com.intellij.openapi.projectRoots.SdkTypeId;
import com.intellij.openapi.roots.ProjectRootManager;
import javax.swing.*;
import java.awt.*;
-import java.awt.event.ActionEvent;
-import java.awt.event.ActionListener;
/**
* @author Dmitry Avdeev
protected final WizardContext myWizardContext;
protected final ProjectSdksModel myModel;
private final ModuleBuilder myModuleBuilder;
+ private final JPanel myJdkPanel;
- public SdkSettingsStep(@NotNull SettingsStep settingsStep, @NotNull ModuleBuilder moduleBuilder, @NotNull Condition<SdkTypeId> sdkFilter) {
+ public SdkSettingsStep(SettingsStep settingsStep, @NotNull ModuleBuilder moduleBuilder,
+ @NotNull Condition<SdkTypeId> sdkFilter) {
+
+ this(settingsStep.getContext(), moduleBuilder, sdkFilter);
+ settingsStep.addSettingsField(getSdkFieldLabel(settingsStep.getContext().getProject()), myJdkPanel);
+ }
+
+ public SdkSettingsStep(WizardContext context,
+ @NotNull ModuleBuilder moduleBuilder,
+ @NotNull Condition<SdkTypeId> sdkFilter) {
myModuleBuilder = moduleBuilder;
- myWizardContext = settingsStep.getContext();
+ myWizardContext = context;
myModel = new ProjectSdksModel();
Project project = myWizardContext.getProject();
myModel.reset(project);
- myJdkComboBox = new JdkComboBox(myModel, sdkFilter);
-
- final PropertiesComponent component = project == null ? PropertiesComponent.getInstance() : PropertiesComponent.getInstance(project);
- ModuleType moduleType = moduleBuilder.getModuleType();
- final String selectedJdkProperty = "jdk.selected." + (moduleType == null ? "" : moduleType.getId());
- myJdkComboBox.addActionListener(new ActionListener() {
- @Override
- public void actionPerformed(ActionEvent e) {
- Sdk jdk = myJdkComboBox.getSelectedJdk();
- if (jdk != null) {
- component.setValue(selectedJdkProperty, jdk.getName());
- }
- }
- });
-
- if (project != null) {
- Sdk sdk = ProjectRootManager.getInstance(project).getProjectSdk();
- if (sdk != null && moduleBuilder.isSuitableSdkType(sdk.getSdkType())) {
- // use project SDK
- return;
- }
- }
- else {
- // set default project SDK
- Project defaultProject = ProjectManager.getInstance().getDefaultProject();
- Sdk sdk = ProjectRootManager.getInstance(defaultProject).getProjectSdk();
- if (sdk != null && sdkFilter.value(sdk.getSdkType())) {
- myJdkComboBox.setSelectedJdk(sdk);
- }
- }
-
- String value = component.getValue(selectedJdkProperty);
- if (value != null) {
- Sdk jdk = ProjectJdkTable.getInstance().findJdk(value);
- if (jdk != null) {
- myJdkComboBox.setSelectedJdk(jdk);
- }
- }
-
- JButton button = new JButton("Ne\u001Bw...");
- myJdkComboBox.setSetupButton(button, project, myModel,
- project == null ? new JdkComboBox.NoneJdkComboBoxItem() : new JdkComboBox.ProjectJdkComboBoxItem(),
- null,
- false);
- JPanel jdkPanel = new JPanel(new BorderLayout(4, 0));
- jdkPanel.add(myJdkComboBox);
- jdkPanel.add(button, BorderLayout.EAST);
- settingsStep.addSettingsField(getSdkFieldLabel(project), jdkPanel);
-
+ myJdkComboBox = JdkComboBox.createSdkComboBox(moduleBuilder, sdkFilter, project, myModel);
+ myJdkPanel = new JPanel(new BorderLayout(4, 0));
+ myJdkPanel.add(myJdkComboBox);
+ myJdkPanel.add(myJdkComboBox.getSetUpButton(), BorderLayout.EAST);
}
@NotNull
return (project == null ? "Project" : "Module") + " \u001BSDK:";
}
+ public JdkComboBox getJdkComboBox() {
+ return myJdkComboBox;
+ }
+
@Override
public JComponent getComponent() {
- return null;
+ return myJdkPanel;
}
@Override
package com.intellij.openapi.roots.ui.configuration;
import com.intellij.ide.DataManager;
+import com.intellij.ide.util.PropertiesComponent;
+import com.intellij.ide.util.projectWizard.ModuleBuilder;
import com.intellij.ide.util.projectWizard.ProjectJdkListRenderer;
import com.intellij.openapi.actionSystem.*;
+import com.intellij.openapi.module.ModuleType;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.project.ProjectBundle;
+import com.intellij.openapi.project.ProjectManager;
+import com.intellij.openapi.projectRoots.ProjectJdkTable;
import com.intellij.openapi.projectRoots.Sdk;
import com.intellij.openapi.projectRoots.SdkType;
import com.intellij.openapi.projectRoots.SdkTypeId;
+import com.intellij.openapi.roots.ProjectRootManager;
import com.intellij.openapi.roots.ui.configuration.projectRoot.JdkListConfigurable;
import com.intellij.openapi.roots.ui.configuration.projectRoot.ProjectSdksModel;
import com.intellij.openapi.ui.ComboBoxWithWidePopup;
private final Condition<SdkTypeId> myFilter;
@Nullable
private final Condition<SdkTypeId> myCreationFilter;
+ private JButton mySetUpButton;
public JdkComboBox(@NotNull final ProjectSdksModel jdkModel) {
this(jdkModel, null);
});
}
+ public static JdkComboBox createSdkComboBox(ModuleBuilder moduleBuilder,
+ Condition<SdkTypeId> sdkFilter,
+ Project project,
+ ProjectSdksModel model) {
+ final JdkComboBox comboBox = new JdkComboBox(model, sdkFilter);
+
+ final PropertiesComponent component = project == null ? PropertiesComponent.getInstance() : PropertiesComponent.getInstance(project);
+ ModuleType moduleType = moduleBuilder.getModuleType();
+ final String selectedJdkProperty = "jdk.selected." + (moduleType == null ? "" : moduleType.getId());
+ comboBox.addActionListener(new ActionListener() {
+ @Override
+ public void actionPerformed(ActionEvent e) {
+ Sdk jdk = comboBox.getSelectedJdk();
+ if (jdk != null) {
+ component.setValue(selectedJdkProperty, jdk.getName());
+ }
+ }
+ });
+
+ if (project != null) {
+ Sdk sdk = ProjectRootManager.getInstance(project).getProjectSdk();
+ if (sdk != null && moduleBuilder.isSuitableSdkType(sdk.getSdkType())) {
+ // use project SDK
+ return null;
+ }
+ }
+ else {
+ // set default project SDK
+ Project defaultProject = ProjectManager.getInstance().getDefaultProject();
+ Sdk sdk = ProjectRootManager.getInstance(defaultProject).getProjectSdk();
+ if (sdk != null && sdkFilter.value(sdk.getSdkType())) {
+ comboBox.setSelectedJdk(sdk);
+ }
+ }
+
+ String value = component.getValue(selectedJdkProperty);
+ if (value != null) {
+ Sdk jdk = ProjectJdkTable.getInstance().findJdk(value);
+ if (jdk != null) {
+ comboBox.setSelectedJdk(jdk);
+ }
+ }
+
+ JButton button = new JButton("Ne\u001Bw...");
+ comboBox.setSetupButton(button, project, model,
+ project == null ? new NoneJdkComboBoxItem() : new ProjectJdkComboBoxItem(),
+ null,
+ false);
+ return comboBox;
+ }
+
@Override
public Dimension getPreferredSize() {
final Rectangle rec = ScreenUtil.getScreenRectangle(0, 0);
final JdkComboBoxItem firstItem,
@Nullable final Condition<Sdk> additionalSetup,
final String actionGroupTitle) {
- setUpButton.addActionListener(new ActionListener() {
+
+ mySetUpButton = setUpButton;
+ mySetUpButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
DefaultActionGroup group = new DefaultActionGroup();
});
}
+ public JButton getSetUpButton() {
+ return mySetUpButton;
+ }
+
@Override
public JdkComboBoxItem getSelectedItem() {
return (JdkComboBoxItem)super.getSelectedItem();
import com.intellij.openapi.ui.ComboBox;
import com.intellij.util.ui.FormBuilder;
import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
import javax.swing.*;
import java.util.List;
protected boolean shouldCheckName(String newName) {
return true;
}
+
+ @Nullable
+ @Override
+ protected String getHelpId() {
+ return "Create_Library_dialog";
+ }
}
return myTableModifiableModel;
}
+ @Nullable
+ @Override
+ protected String getHelpId() {
+ return "Configure_Library_Dialog";
+ }
+
@Override
protected boolean shouldCheckName(String newName) {
return !Comparing.equal(newName, getLibraryRootsComponent().getLibraryEditor().getName());
}
@Nullable
- static HighlightInfo checkPublicClassInRightFile(PsiKeyword keyword, PsiModifierList psiModifierList) {
- // most test case classes are located in wrong files
+ static HighlightInfo checkPublicClassInRightFile(PsiClass aClass) {
+ // most test case classes are located in wrong files
if (ApplicationManager.getApplication().isUnitTestMode()) return null;
- if (new PsiMatcherImpl(keyword)
- .dot(PsiMatchers.hasText(PsiModifier.PUBLIC))
- .parent(PsiMatchers.hasClass(PsiModifierList.class))
- .parent(PsiMatchers.hasClass(PsiClass.class))
- .parent(PsiMatchers.hasClass(PsiJavaFile.class))
- .getElement() == null) {
- return null;
- }
-
- PsiClass aClass = (PsiClass)keyword.getParent().getParent();
- PsiJavaFile file = (PsiJavaFile)aClass.getContainingFile();
+ PsiFile containingFile = aClass.getContainingFile();
+ if (aClass.getParent() != containingFile || !aClass.hasModifierProperty(PsiModifier.PUBLIC) || !(containingFile instanceof PsiJavaFile)) return null;
+ PsiJavaFile file = (PsiJavaFile)containingFile;
VirtualFile virtualFile = file.getVirtualFile();
HighlightInfo errorResult = null;
if (virtualFile != null && !aClass.getName().equals(virtualFile.getNameWithoutExtension())) {
errorResult = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).
range(aClass, range.getStartOffset(), range.getEndOffset()).
descriptionAndTooltip(message).create();
+ PsiModifierList psiModifierList = aClass.getModifierList();
QuickFixAction.registerQuickFixAction(errorResult,
QUICK_FIX_FACTORY.createModifierListFix(psiModifierList, PsiModifier.PUBLIC, false, false));
PsiClass[] classes = file.getClasses();
/*
- * Copyright 2000-2013 JetBrains s.r.o.
+ * Copyright 2000-2014 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.
return result;
}
+ @NotNull
public static TextRange getMethodDeclarationTextRange(@NotNull PsiMethod method) {
if (method instanceof SyntheticElement) return TextRange.EMPTY_RANGE;
int start = stripAnnotationsFromModifierList(method.getModifierList());
return new TextRange(start, end);
}
+ @NotNull
public static TextRange getFieldDeclarationTextRange(@NotNull PsiField field) {
int start = stripAnnotationsFromModifierList(field.getModifierList());
int end = field.getNameIdentifier().getTextRange().getEndOffset();
return new TextRange(start, end);
}
+ @NotNull
public static TextRange getClassDeclarationTextRange(@NotNull PsiClass aClass) {
if (aClass instanceof PsiEnumConstantInitializer) {
return ((PsiEnumConstantInitializer)aClass).getEnumConstant().getNameIdentifier().getTextRange();
if (!myHolder.hasErrorResults()) myHolder.add(GenericsHighlightUtil.checkEnumMustNotBeLocal(aClass));
if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkImplicitThisReferenceBeforeSuper(aClass, myJavaSdkVersion));
if (!myHolder.hasErrorResults()) myHolder.add(HighlightClassUtil.checkClassAndPackageConflict(aClass));
+ if (!myHolder.hasErrorResults()) myHolder.add(HighlightClassUtil.checkPublicClassInRightFile(aClass));
}
@Override
PsiModifierList psiModifierList = (PsiModifierList)parent;
if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkNotAllowedModifier(keyword, psiModifierList));
if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkIllegalModifierCombination(keyword, psiModifierList));
- if (!myHolder.hasErrorResults()) myHolder.add(HighlightClassUtil.checkPublicClassInRightFile(keyword, psiModifierList));
if (PsiModifier.ABSTRACT.equals(text) && psiModifierList.getParent() instanceof PsiMethod) {
if (!myHolder.hasErrorResults()) {
myHolder.add(HighlightMethodUtil.checkAbstractMethodInConcreteClass((PsiMethod)psiModifierList.getParent(), keyword));
VirtualFile file = VirtualFileManager.getInstance().findFileByUrl(url);
if (file == null) continue;
if (!(file.getFileSystem() instanceof JarFileSystem) && !file.isDirectory()) {
- file = JarFileSystem.getInstance().findFileByPath(file.getPath() + JarFileSystem.JAR_SEPARATOR);
+ file = JarFileSystem.getInstance().getJarRootForLocalFile(file);
}
if (file == null) continue;
if (findInFile(file, new StringTokenizer(fqn, "."))) return true;
+++ /dev/null
-/*
- * Copyright 2000-2009 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.pom.java.impl;
-
-import com.intellij.lang.java.JavaLanguage;
-import com.intellij.openapi.roots.LanguageLevelProjectExtension;
-import com.intellij.pom.PomModel;
-import com.intellij.pom.PomModelAspect;
-import com.intellij.pom.event.PomModelEvent;
-import com.intellij.pom.java.LanguageLevel;
-import com.intellij.pom.java.PomJavaAspect;
-import com.intellij.pom.java.events.PomJavaAspectChangeSet;
-import com.intellij.pom.tree.TreeAspect;
-import com.intellij.pom.tree.events.TreeChangeEvent;
-import com.intellij.psi.PsiFile;
-import com.intellij.psi.PsiManager;
-
-import java.util.Collections;
-
-public class PomJavaAspectImpl extends PomJavaAspect {
- private final PsiManager myPsiManager;
- private final PomModel myPomModel;
-
- public PomJavaAspectImpl(PsiManager psiManager, TreeAspect treeAspect, PomModel pomModel) {
- myPsiManager = psiManager;
- myPomModel = pomModel;
- pomModel.registerAspect(PomJavaAspect.class, this, Collections.singleton((PomModelAspect)treeAspect));
- }
-
- public LanguageLevel getLanguageLevel() {
- return LanguageLevelProjectExtension.getInstance(myPsiManager.getProject()).getLanguageLevel();
- }
-
- public void update(PomModelEvent event) {
- final TreeChangeEvent changeSet = (TreeChangeEvent)event.getChangeSet(myPomModel.getModelAspect(TreeAspect.class));
- if(changeSet == null) return;
- final PsiFile containingFile = changeSet.getRootElement().getPsi().getContainingFile();
- if(!(containingFile.getLanguage() instanceof JavaLanguage)) return;
- final PomJavaAspectChangeSet set = new PomJavaAspectChangeSet(myPomModel);
- event.registerChangeSet(this, set);
- }
-}
package com.intellij.psi.impl.file.impl;
-import com.intellij.AppTopics;
-import com.intellij.openapi.fileEditor.FileDocumentManagerAdapter;
-import com.intellij.openapi.roots.*;
+import com.intellij.ide.startup.StartupManagerEx;
+import com.intellij.openapi.application.ApplicationManager;
+import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.roots.ProjectRootManager;
import com.intellij.openapi.startup.StartupManager;
-import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.psi.impl.PsiManagerEx;
import com.intellij.util.messages.MessageBus;
-import org.jetbrains.annotations.NotNull;
/**
* @author max
*/
public class JavaFileManagerImpl extends JavaFileManagerBase {
-
public JavaFileManagerImpl(final PsiManagerEx manager, final ProjectRootManager projectRootManager, MessageBus bus,
final StartupManager startupManager) {
super(manager, projectRootManager, bus);
- myConnection.subscribe(AppTopics.FILE_DOCUMENT_SYNC, new FileDocumentManagerAdapter() {
- @Override
- public void fileWithNoDocumentChanged(@NotNull final VirtualFile file) {
- clearNonRepositoryMaps();
- }
- });
-
-
-
- startupManager.registerStartupActivity(
- new Runnable() {
- @Override
- public void run() {
- initialize();
- }
- }
- );
-
+ if (!((StartupManagerEx)startupManager).startupActivityPassed() &&
+ !ApplicationManager.getApplication().isUnitTestMode() &&
+ !manager.getProject().isDefault()) {
+ Logger.getInstance("#com.intellij.psi.impl.file.impl.JavaFileManagerImpl")
+ .error("Access to psi files should be performed only after startup activity");
+ }
}
}
}
private boolean isIdentifier(String name) {
- return JavaPsiFacade.getInstance(myProject).getNameHelper().isIdentifier(name, LanguageLevel.HIGHEST);
+ return PsiNameHelper.getInstance(myProject).isIdentifier(name, LanguageLevel.HIGHEST);
}
private CodeStyleSettings getSettings() {
/*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2014 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.
import com.intellij.openapi.util.Disposer;
import com.intellij.psi.PsiSubstitutor;
import com.intellij.psi.util.PsiFormatUtil;
+import com.intellij.psi.util.PsiFormatUtilBase;
import com.intellij.refactoring.HelpID;
import com.intellij.refactoring.RefactoringBundle;
import com.intellij.refactoring.safeDelete.usageInfo.SafeDeleteOverridingMethodUsageInfo;
import com.intellij.ui.ScrollPaneFactory;
import com.intellij.ui.TableUtil;
import com.intellij.usageView.UsageInfo;
+import com.intellij.usages.UsageViewPresentation;
import com.intellij.usages.impl.UsagePreviewPanel;
import com.intellij.util.ui.Table;
import org.jetbrains.annotations.NonNls;
for (int i = 0; i < myMethodText.length; i++) {
myMethodText[i] = PsiFormatUtil.formatMethod(
((SafeDeleteOverridingMethodUsageInfo) myOverridingMethods.get(i)).getOverridingMethod(),
- PsiSubstitutor.EMPTY, PsiFormatUtil.SHOW_CONTAINING_CLASS
- | PsiFormatUtil.SHOW_NAME | PsiFormatUtil.SHOW_PARAMETERS | PsiFormatUtil.SHOW_TYPE,
- PsiFormatUtil.SHOW_TYPE
+ PsiSubstitutor.EMPTY, PsiFormatUtilBase.SHOW_CONTAINING_CLASS
+ | PsiFormatUtilBase.SHOW_NAME | PsiFormatUtilBase.SHOW_PARAMETERS | PsiFormatUtilBase.SHOW_TYPE,
+ PsiFormatUtilBase.SHOW_TYPE
);
}
- myUsagePreviewPanel = new UsagePreviewPanel(project);
+ myUsagePreviewPanel = new UsagePreviewPanel(project, new UsageViewPresentation());
setTitle(RefactoringBundle.message("unused.overriding.methods.title"));
init();
}
/*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2014 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.
import com.intellij.usageView.UsageInfo;
import com.intellij.usageView.UsageViewBundle;
import com.intellij.usages.Usage;
+import com.intellij.usages.UsageViewPresentation;
import com.intellij.usages.UsageViewSettings;
import com.intellij.usages.impl.UsagePreviewPanel;
import com.intellij.util.EditSourceOnDoubleClickHandler;
boolean vertical = myToolWindow.getAnchor() == ToolWindowAnchor.LEFT || myToolWindow.getAnchor() == ToolWindowAnchor.RIGHT;
Splitter splitter = new Splitter(vertical, UsageViewSettings.getInstance().PREVIEW_USAGES_SPLITTER_PROPORTIONS);
splitter.setFirstComponent(pane);
- myUsagePreviewPanel = new UsagePreviewPanel(myProject);
+ myUsagePreviewPanel = new UsagePreviewPanel(myProject, new UsageViewPresentation());
myUsagePreviewPanel.setBorder(IdeBorderFactory.createBorder(SideBorder.LEFT));
Disposer.register(this, myUsagePreviewPanel);
/*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2014 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.
import com.intellij.openapi.project.Project;
import com.intellij.usages.UsageContextPanel;
import com.intellij.usages.UsageView;
+import com.intellij.usages.UsageViewPresentation;
import com.intellij.usages.impl.UsageViewImpl;
import org.jetbrains.annotations.NotNull;
@NotNull
@Override
public UsageContextPanel create(@NotNull UsageView usageView) {
- return new UsageContextDataflowFromPanel(((UsageViewImpl)usageView).getProject());
+ return new UsageContextDataflowFromPanel(((UsageViewImpl)usageView).getProject(), usageView.getPresentation());
}
@NotNull
}
}
- public UsageContextDataflowFromPanel(@NotNull Project project) {
- super(project);
+ public UsageContextDataflowFromPanel(@NotNull Project project, @NotNull UsageViewPresentation presentation) {
+ super(project, presentation);
}
/*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2014 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.
import com.intellij.psi.PsiJavaFile;
import com.intellij.psi.PsiVariable;
import com.intellij.slicer.*;
-import com.intellij.usages.PsiElementUsageTarget;
-import com.intellij.usages.UsageContextPanel;
-import com.intellij.usages.UsageTarget;
-import com.intellij.usages.UsageView;
+import com.intellij.usages.*;
import com.intellij.usages.impl.UsageContextPanelBase;
import com.intellij.usages.impl.UsageViewImpl;
import org.jetbrains.annotations.NotNull;
import java.util.List;
public class UsageContextDataflowToPanel extends UsageContextPanelBase {
+ @NotNull private final UsageViewPresentation myPresentation;
private JComponent myPanel;
public static class Provider implements UsageContextPanel.Provider {
@NotNull
@Override
public UsageContextPanel create(@NotNull UsageView usageView) {
- return new UsageContextDataflowToPanel(((UsageViewImpl)usageView).getProject());
+ return new UsageContextDataflowToPanel(((UsageViewImpl)usageView).getProject(), usageView.getPresentation());
}
@Override
}
}
- public UsageContextDataflowToPanel(@NotNull Project project) {
- super(project);
+ public UsageContextDataflowToPanel(@NotNull Project project, @NotNull UsageViewPresentation presentation) {
+ super(project, presentation);
+ myPresentation = presentation;
}
@Override
public void updateLayoutLater(@Nullable final List<UsageInfo> infos) {
if (infos == null) {
removeAll();
- JComponent titleComp = new JLabel(UsageViewBundle.message("select.the.usage.to.preview"), SwingConstants.CENTER);
+ JComponent titleComp = new JLabel(UsageViewBundle.message("select.the.usage.to.preview", myPresentation.getUsagesWord()), SwingConstants.CENTER);
add(titleComp, BorderLayout.CENTER);
revalidate();
}
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.roots.*;
import com.intellij.openapi.util.Comparing;
-import com.intellij.openapi.util.Disposer;
import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.openapi.vfs.VirtualFileManager;
import com.intellij.openapi.vfs.VirtualFileWithId;
-import com.intellij.openapi.vfs.newvfs.BulkFileListener;
-import com.intellij.openapi.vfs.newvfs.events.VFileEvent;
import com.intellij.psi.*;
import com.intellij.psi.impl.PsiManagerEx;
import com.intellij.psi.impl.file.PsiPackageImpl;
import com.intellij.util.containers.ContainerUtil;
import com.intellij.util.messages.MessageBus;
import com.intellij.util.messages.MessageBusConnection;
-import org.jetbrains.annotations.NonNls;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jps.model.java.JavaModuleSourceRootTypes;
*/
public abstract class JavaFileManagerBase implements JavaFileManager, Disposable {
private static final Logger LOG = Logger.getInstance("#com.intellij.psi.impl.file.impl.JavaFileManagerImpl");
- @NonNls private static final String JAVA_EXTENSION = ".java";
- @NonNls private static final String CLASS_EXTENSION = ".class";
private final ConcurrentHashMap<GlobalSearchScope, PsiClass> myCachedObjectClassMap = new ConcurrentHashMap<GlobalSearchScope, PsiClass>();
- private final Map<String,PsiClass> myNameToClassMap = new ConcurrentHashMap<String, PsiClass>(); // used only in mode without repository
private final PsiManagerEx myManager;
private final ProjectRootManager myProjectRootManager;
- private final FileManager myFileManager;
- private final boolean myUseRepository;
- private Set<String> myNontrivialPackagePrefixes = null;
- private boolean myInitialized = false;
+ private volatile Set<String> myNontrivialPackagePrefixes = null;
private boolean myDisposed = false;
private final PackageIndex myPackageIndex;
protected final MessageBusConnection myConnection;
final PsiManagerEx manager, final ProjectRootManager projectRootManager,
final MessageBus bus) {
myManager = manager;
- myFileManager = manager.getFileManager();
myProjectRootManager = projectRootManager;
- myUseRepository = true;
myPackageIndex = PackageIndex.getInstance(myManager.getProject());
myConnection = bus.connect();
myConnection.subscribe(ProjectTopics.PROJECT_ROOTS, new ModuleRootAdapter() {
@Override
public void rootsChanged(final ModuleRootEvent event) {
myNontrivialPackagePrefixes = null;
- clearNonRepositoryMaps();
- }
- });
-
- myConnection.subscribe(VirtualFileManager.VFS_CHANGES, new BulkFileListener() {
- @Override
- public void before(@NotNull final List<? extends VFileEvent> events) {
- clearNonRepositoryMaps();
- }
-
- @Override
- public void after(@NotNull final List<? extends VFileEvent> events) {
- clearNonRepositoryMaps();
}
});
myCachedObjectClassMap.clear();
}
});
-
- Disposer.register(myManager.getProject(), this);
- }
-
- @Override
- public void initialize() {
- myInitialized = true;
}
@Override
myCachedObjectClassMap.clear();
}
- protected void clearNonRepositoryMaps() {
- if (!myUseRepository) {
- myNameToClassMap.clear();
- }
- }
-
@Override
@Nullable
public PsiPackage findPackage(@NotNull String packageName) {
@Override
@Nullable
public PsiClass findClass(@NotNull String qName, @NotNull GlobalSearchScope scope) {
- if (!myUseRepository) {
- return findClassWithoutRepository(qName);
- }
-
- if (!myInitialized) {
- LOG.error("Access to psi files should be performed only after startup activity");
- return null;
- }
LOG.assertTrue(!myDisposed);
if (CommonClassNames.JAVA_LANG_OBJECT.equals(qName)) { // optimization
return findClassInIndex(qName, scope);
}
- @Nullable
- private PsiClass findClassWithoutRepository(String qName) {
- PsiClass aClass = myNameToClassMap.get(qName);
- if (aClass != null) {
- return aClass;
- }
-
- aClass = _findClassWithoutRepository(qName);
- myNameToClassMap.put(qName, aClass);
- return aClass;
- }
-
- @Nullable
- private PsiClass _findClassWithoutRepository(String qName) {
- VirtualFile[] sourcePath = myProjectRootManager.orderEntries().sources().usingCache().getRoots();
- VirtualFile[] classPath = myProjectRootManager.orderEntries().withoutModuleSourceEntries().classes().usingCache().getRoots();
-
- int index = 0;
- while (index < qName.length()) {
- int index1 = qName.indexOf('.', index);
- if (index1 < 0) {
- index1 = qName.length();
- }
- String name = qName.substring(index, index1);
-
- final int sourceType = 0;
- //final int compiledType = 1;
-
- for (int type = 0; type < 2; type++) {
- VirtualFile[] vDirs = type == sourceType ? sourcePath : classPath;
- for (VirtualFile vDir : vDirs) {
- if (vDir != null) {
- VirtualFile vChild = type == sourceType
- ? vDir.findChild(name + JAVA_EXTENSION)
- : vDir.findChild(name + CLASS_EXTENSION);
- if (vChild != null) {
- PsiFile file = myFileManager.findFile(vChild);
- if (file instanceof PsiJavaFile) {
- PsiClass aClass = findClassByName((PsiJavaFile)file, name);
- if (aClass != null) {
- index = index1 + 1;
- while (index < qName.length()) {
- index1 = qName.indexOf('.', index);
- if (index1 < 0) {
- index1 = qName.length();
- }
- name = qName.substring(index, index1);
- aClass = findClassByName(aClass, name);
- if (aClass == null) return null;
- index = index1 + 1;
- }
- return aClass;
- }
- }
- }
- }
- }
- }
-
- boolean existsDir = false;
- for (int type = 0; type < 2; type++) {
- VirtualFile[] vDirs = type == sourceType ? sourcePath : classPath;
- for (int i = 0; i < vDirs.length; i++) {
- if (vDirs[i] != null) {
- VirtualFile vDirChild = vDirs[i].findChild(name);
- if (vDirChild != null) {
- PsiDirectory dir = myFileManager.findDirectory(vDirChild);
- if (dir != null) {
- vDirs[i] = vDirChild;
- existsDir = true;
- continue;
- }
- }
- vDirs[i] = null;
- }
- }
- }
- if (!existsDir) return null;
- index = index1 + 1;
- }
- return null;
- }
-
@Nullable
private PsiClass findClassInIndex(String qName, GlobalSearchScope scope) {
VirtualFile bestFile = null;
return myNontrivialPackagePrefixes;
}
- @Nullable
- private static PsiClass findClassByName(PsiJavaFile scope, String name) {
- PsiClass[] classes = scope.getClasses();
- for (PsiClass aClass : classes) {
- if (name.equals(aClass.getName())) {
- return aClass;
- }
- }
- return null;
- }
-
- @Nullable
- private static PsiClass findClassByName(PsiClass scope, String name) {
- PsiClass[] classes = scope.getInnerClasses();
- for (PsiClass aClass : classes) {
- if (name.equals(aClass.getName())) {
- return aClass;
- }
- }
- return null;
- }
}
* Returns the name helper for the project, which can be used to validate
* and parse Java identifiers.
*
+ * @deprecated use {@link com.intellij.psi.PsiNameHelper#getInstance(com.intellij.openapi.project.Project)}
* @return the name helper instance.
*/
@NotNull
*/
package com.intellij.psi;
+import com.intellij.openapi.components.ServiceManager;
+import com.intellij.openapi.project.Project;
import com.intellij.pom.java.LanguageLevel;
import com.intellij.psi.util.PsiTreeUtil;
import com.intellij.util.ArrayUtil;
* @see com.intellij.psi.JavaPsiFacade#getNameHelper()
*/
public abstract class PsiNameHelper {
+
+ public static PsiNameHelper getInstance(Project project) {
+ return ServiceManager.getService(project, PsiNameHelper.class);
+ }
+
/**
* Checks if the specified text is a Java identifier, using the language level of the project
* with which the name helper is associated to filter out keywords.
return Collections.emptyList();
}
- @Override
- public void initialize() {
- }
-
public void addToClasspath(VirtualFile root) {
myClasspath.add(root);
}
myProject.registerService(JavaFileManager.class, myFileManager);
JavaPsiFacadeImpl javaPsiFacade = new JavaPsiFacadeImpl(myProject, myPsiManager, myFileManager, myMessageBus);
- registerProjectComponent(JavaPsiFacade.class, javaPsiFacade);
myProject.registerService(JavaPsiFacade.class, javaPsiFacade);
}
/*
- * Copyright 2000-2013 JetBrains s.r.o.
+ * Copyright 2000-2014 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.
import com.intellij.openapi.util.NotNullLazyKey;
import com.intellij.psi.PsiElement;
import com.intellij.psi.impl.PsiManagerEx;
+import com.intellij.util.containers.ConcurrentList;
import com.intellij.util.containers.ConcurrentWeakHashMap;
import com.intellij.util.containers.ContainerUtil;
import org.jetbrains.annotations.NotNull;
import java.lang.ref.Reference;
import java.lang.ref.SoftReference;
import java.util.concurrent.ConcurrentMap;
-import java.util.concurrent.CopyOnWriteArrayList;
public class ControlFlowFactory {
// psiElements hold weakly, controlFlows softly
- private final ConcurrentMap<PsiElement, Reference<CopyOnWriteArrayList<ControlFlowContext>>> cachedFlows = new ConcurrentWeakHashMap<PsiElement, Reference<CopyOnWriteArrayList<ControlFlowContext>>>();
+ private final ConcurrentMap<PsiElement, Reference<ConcurrentList<ControlFlowContext>>> cachedFlows = new ConcurrentWeakHashMap<PsiElement, Reference<ConcurrentList<ControlFlowContext>>>();
private static final NotNullLazyKey<ControlFlowFactory, Project> INSTANCE_KEY = ServiceManager.createLazyKey(ControlFlowFactory.class);
boolean enableShortCircuit,
boolean evaluateConstantIfCondition) throws AnalysisCanceledException {
final long modificationCount = element.getManager().getModificationTracker().getModificationCount();
- CopyOnWriteArrayList<ControlFlowContext> cached = getOrCreateCachedFlowsForElement(element);
+ ConcurrentList<ControlFlowContext> cached = getOrCreateCachedFlowsForElement(element);
for (ControlFlowContext context : cached) {
if (context.isFor(policy, evaluateConstantIfCondition,modificationCount)) return context.controlFlow;
}
final long modificationCount = element.getManager().getModificationTracker().getModificationCount();
ControlFlowContext controlFlowContext = createContext(evaluateConstantIfCondition, policy, flow, modificationCount);
- CopyOnWriteArrayList<ControlFlowContext> cached = getOrCreateCachedFlowsForElement(element);
+ ConcurrentList<ControlFlowContext> cached = getOrCreateCachedFlowsForElement(element);
cached.addIfAbsent(controlFlowContext);
}
@NotNull
- private CopyOnWriteArrayList<ControlFlowContext> getOrCreateCachedFlowsForElement(@NotNull PsiElement element) {
- Reference<CopyOnWriteArrayList<ControlFlowContext>> cachedRef = cachedFlows.get(element);
- CopyOnWriteArrayList<ControlFlowContext> cached = com.intellij.reference.SoftReference.dereference(cachedRef);
+ private ConcurrentList<ControlFlowContext> getOrCreateCachedFlowsForElement(@NotNull PsiElement element) {
+ Reference<ConcurrentList<ControlFlowContext>> cachedRef = cachedFlows.get(element);
+ ConcurrentList<ControlFlowContext> cached = com.intellij.reference.SoftReference.dereference(cachedRef);
if (cached == null) {
- cached = ContainerUtil.createEmptyCOWList();
- cachedFlows.put(element, new SoftReference<CopyOnWriteArrayList<ControlFlowContext>>(cached));
+ cached = ContainerUtil.createConcurrentList();
+ cachedFlows.put(element, new SoftReference<ConcurrentList<ControlFlowContext>>(cached));
}
return cached;
}
*/
public class JavaPsiFacadeImpl extends JavaPsiFacadeEx {
private volatile PsiElementFinder[] myElementFinders;
- private final PsiNameHelper myNameHelper;
private final PsiConstantEvaluationHelper myConstantEvaluationHelper;
private volatile SoftReference<ConcurrentMap<String, PsiPackage>> myPackageCache;
private final Project myProject;
MessageBus bus) {
myProject = project;
myFileManager = javaFileManager;
- myNameHelper = new PsiNameHelperImpl(this);
myConstantEvaluationHelper = new PsiConstantEvaluationHelperImpl();
final PsiModificationTracker modificationTracker = psiManager.getModificationTracker();
@Override
@NotNull
public PsiNameHelper getNameHelper() {
- return myNameHelper;
+ return PsiNameHelper.getInstance(myProject);
}
@NotNull
package com.intellij.psi.impl;
import com.intellij.lang.java.lexer.JavaLexer;
+import com.intellij.openapi.project.Project;
import com.intellij.openapi.roots.LanguageLevelProjectExtension;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.pom.java.LanguageLevel;
-import com.intellij.psi.JavaPsiFacade;
import com.intellij.psi.PsiNameHelper;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public class PsiNameHelperImpl extends PsiNameHelper {
private final LanguageLevelProjectExtension myLanguageLevelExtension;
- public PsiNameHelperImpl(JavaPsiFacade manager) {
- myLanguageLevelExtension = LanguageLevelProjectExtension.getInstance(manager.getProject());
+ public PsiNameHelperImpl(Project project) {
+ myLanguageLevelExtension = LanguageLevelProjectExtension.getInstance(project);
}
@Override
import com.intellij.openapi.util.VolatileNullableLazyValue;
import com.intellij.psi.*;
import com.intellij.psi.impl.PsiImplUtil;
+import com.intellij.psi.impl.PsiJavaParserFacadeImpl;
import com.intellij.psi.impl.cache.TypeInfo;
import com.intellij.psi.impl.source.PsiClassReferenceType;
import com.intellij.psi.impl.source.tree.JavaElementType;
}
private ClsElementImpl calculateChild() {
- if (JavaPsiFacade.getInstance(getProject()).getElementFactory().createPrimitiveType(myTypeText) != null) {
+ if (PsiJavaParserFacadeImpl.getPrimitiveType(myTypeText) != null) {
return null;
}
else if (isArray()) {
}
private PsiType calculateType() {
- PsiType result = JavaPsiFacade.getInstance(getProject()).getElementFactory().createPrimitiveType(myTypeText);
+ PsiType result = PsiJavaParserFacadeImpl.getPrimitiveType(myTypeText);
if (result != null) return result;
ClsElementImpl childElement = myChild.getValue();
Collection<String> getNonTrivialPackagePrefixes();
- void initialize();
}
\ No newline at end of file
/*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2014 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.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package com.intellij.pom.java;
+import java.jang.String;
-import com.intellij.openapi.project.Project;
-import com.intellij.pom.PomModel;
-import com.intellij.pom.PomModelAspect;
+class PsiMethod {
+}
-public abstract class PomJavaAspect implements PomModelAspect {
- public static PomJavaAspect getInstance(Project project) {
- return project.getComponent(PomJavaAspect.class);
- }
+interface PsiClass {
+ PsiMethod[] getMethods();
+}
- public static PomJavaAspect getInstance(PomModel model) {
- return model.getModelAspect(PomJavaAspect.class);
- }
+public class TestCompletion {
- public abstract LanguageLevel getLanguageLevel();
-}
\ No newline at end of file
+ PsiClass c;
+
+ public void method() {
+ PsiMethod[] m = <caret>
+ }
+}
--- /dev/null
+/*
+ * Copyright 2000-2014 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.
+ */
+public class TestIndex {
+
+ public void statMethod(PsiClass c) {
+ c.getMethods();
+ c.getMethods();
+ c.getMethods();
+ c.getMethods();
+ c.getMethods();
+ c.getMethods();
+ c.getMethods();
+ c.getMethods();
+ }
+}
+
+class PsiMethod {
+}
+
+interface PsiClass {
+ PsiMethod[] getMethods();
+}
--- /dev/null
+package temp.04
+
+class Book {
+
+ static constraints = {
+ }
+}
import com.intellij.openapi.compiler.CompilerMessageCategory;
import com.intellij.openapi.util.io.FileUtil;
import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.psi.PsiClass;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiManager;
import com.intellij.testFramework.CompilerTester;
import com.intellij.testFramework.fixtures.JavaCodeInsightFixtureTestCase;
import com.intellij.util.Function;
import com.intellij.util.containers.ContainerUtil;
-import gnu.trove.TObjectIntHashMap;
import java.io.File;
import java.io.IOException;
-import java.util.List;
/**
* @author Dmitry Batkovich
}
protected final void compileAndIndexData(final String... fileNames) {
- final VirtualFile[] filesToCompile =
- ContainerUtil.map2Array(ContainerUtil.list(fileNames), new VirtualFile[fileNames.length], new Function<String, VirtualFile>() {
- @Override
- public VirtualFile fun(final String fileName) {
- try {
- return myFixture.addFileToProject(fileName, FileUtil.loadFile(new File(getTestDataPath() + getName() + "/" + fileName)))
- .getVirtualFile();
- }
- catch (final IOException e) {
- throw new RuntimeException(e);
- }
- }
- });
+ try {
+ for (String fileName : fileNames) {
+ myFixture.addFileToProject(fileName, FileUtil.loadFile(new File(getTestDataPath() + getName() + "/" + fileName))).getVirtualFile();
+ }
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
for (final CompilerMessage compilerMessage : myCompilerTester.rebuild()) {
- assertNotSame(CompilerMessageCategory.ERROR, compilerMessage.getCategory());
+ assertNotSame(compilerMessage.getMessage(), CompilerMessageCategory.ERROR, compilerMessage.getCategory());
}
}
}
/*
- * Copyright 2000-2013 JetBrains s.r.o.
+ * Copyright 2000-2014 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.
import com.intellij.codeInsight.daemon.impl.HighlightInfo;
import com.intellij.codeInspection.LocalInspectionTool;
import com.intellij.codeInspection.LossyEncodingInspection;
+import com.intellij.openapi.command.WriteCommandAction;
+import com.intellij.openapi.editor.Document;
import com.intellij.openapi.fileEditor.FileDocumentManager;
+import com.intellij.openapi.fileTypes.FileTypes;
+import com.intellij.openapi.fileTypes.StdFileTypes;
import com.intellij.openapi.vfs.CharsetToolkit;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.openapi.vfs.encoding.EncodingManager;
import java.util.Collection;
import java.util.List;
-public class LossyEncodingTest extends LightDaemonAnalyzerTestCase {
+public class LossyEncodingTest extends DaemonAnalyzerTestCase {
@NonNls private static final String BASE_PATH = "/codeInsight/daemonCodeAnalyzer/lossyEncoding";
@NotNull
public void testText() throws Exception {
doTest("Text.txt");
Charset ascii = CharsetToolkit.forName("US-ASCII");
+ VirtualFile myVFile = myFile.getVirtualFile();
EncodingManager.getInstance().setEncoding(myVFile, ascii);
assertEquals(ascii, myVFile.getCharset());
int start = myEditor.getCaretModel().getOffset();
backspace();
backspace();
- doTestConfiguredFile(true, false, null);
+
+ doDoTest(true, false);
}
public void testNativeConversion() throws Exception {
- configureFromFileText("x.properties","a=<caret>v");
+ configureByText(StdFileTypes.PROPERTIES, "a=<caret>v");
EncodingProjectManager.getInstance(getProject()).setNative2AsciiForPropertiesFiles(null, true);
UIUtil.dispatchAllInvocationEvents(); //reload files
configureByFile(BASE_PATH + "/" + "MultipleRanges.xml");
type("US-ASCII");
- doTestConfiguredFile(true, false, null);
+ doDoTest(true, false);
}
private void doTest(@NonNls String filePath) throws Exception {
EncodingManager.getInstance().setNative2AsciiForPropertiesFiles(null, true);
configureByFile(BASE_PATH + "/" + "NativeEncoding.properties");
- doTestConfiguredFile(true, false, null);
+ doDoTest(true, false);
}
- public void testDetectWrongEncoding() throws Exception {
+ public void testDetectWrongEncoding0() throws Exception {
String threeNotoriousRussianLetters = "\u0416\u041e\u041f";
- configureFromFileText("Win1251.txt", threeNotoriousRussianLetters);
+ configureByText(FileTypes.PLAIN_TEXT, threeNotoriousRussianLetters);
VirtualFile virtualFile = getFile().getVirtualFile();
+ final Document document = FileDocumentManager.getInstance().getDocument(virtualFile);
+ WriteCommandAction.runWriteCommandAction(getProject(), new Runnable() {
+ @Override
+ public void run() {
+ document.insertString(0, " ");
+ document.deleteString(0, 1);
+ }
+ });
+
+
+ assertTrue(FileDocumentManager.getInstance().isDocumentUnsaved(document));
assertEquals(CharsetToolkit.UTF8_CHARSET, virtualFile.getCharset());
Charset WINDOWS_1251 = Charset.forName("windows-1251");
virtualFile.setCharset(WINDOWS_1251);
- FileDocumentManager.getInstance().saveAllDocuments();
+ FileDocumentManager.getInstance().saveAllDocuments(); // save in wrong encoding
assertEquals(WINDOWS_1251, virtualFile.getCharset());
assertEquals(threeNotoriousRussianLetters, new String(virtualFile.contentsToByteArray(), WINDOWS_1251));
virtualFile.setCharset(CharsetToolkit.UTF8_CHARSET);
HighlightInfo info = assertOneElement(infos);
assertEquals("File was loaded in the wrong encoding: 'UTF-8'", info.getDescription());
}
+
+ public void testDetectWrongEncoding() throws Exception {
+ VirtualFile virtualFile = getVirtualFile(BASE_PATH + "/" + "Win1251.txt");
+ virtualFile.setCharset(CharsetToolkit.UTF8_CHARSET);
+ configureByExistingFile(virtualFile);
+ final Document document = FileDocumentManager.getInstance().getDocument(virtualFile);
+
+ assertFalse(FileDocumentManager.getInstance().isDocumentUnsaved(document));
+ assertEquals(CharsetToolkit.UTF8_CHARSET, virtualFile.getCharset());
+
+ doHighlighting();
+ List<HighlightInfo> infos = DaemonCodeAnalyzerEx.getInstanceEx(getProject()).getFileLevelHighlights(getProject(), getFile());
+ HighlightInfo info = assertOneElement(infos);
+ assertEquals("File was loaded in the wrong encoding: 'UTF-8'", info.getDescription());
+ }
+
+ public void testInconsistentLineSeparators() throws Exception {
+ VirtualFile virtualFile = getVirtualFile(BASE_PATH + "/" + getTestName(false) + ".txt");
+ configureByExistingFile(virtualFile);
+ FileDocumentManager.getInstance().saveAllDocuments();
+ final Document document = FileDocumentManager.getInstance().getDocument(virtualFile);
+ assertFalse(FileDocumentManager.getInstance().isDocumentUnsaved(document));
+ doHighlighting();
+ List<HighlightInfo> infos = DaemonCodeAnalyzerEx.getInstanceEx(getProject()).getFileLevelHighlights(getProject(), getFile());
+ assertEmpty(infos);
+ }
}
/*
- * Copyright 2000-2013 JetBrains s.r.o.
+ * Copyright 2000-2014 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.
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
return COUNT.incrementAndGet();
}
- public void testJobUtilFinishes() throws Exception {
+ public void testJobUtilCorrectlySplitsUpHugeWorkAndFinishes() throws Exception {
COUNT.set(0);
int N = 100000;
List<String> list = Collections.nCopies(N, null);
public void testJobUtilRecursiveCancel() throws Exception {
final List<String> list = Collections.nCopies(100, "");
final List<Integer> ilist = Collections.nCopies(100, 0);
- for (int i=0; i<1/*0*/; i++) {
+ for (int i=0; i<10; i++) {
COUNT.set(0);
long start = System.currentTimeMillis();
boolean success = false;
return true;
}
});
- System.out.println("nestedSuccess = " + nestedSuccess);
+ //System.out.println("nestedSuccess = " + nestedSuccess);
return true;
}
});
assertFalse(success);
}
}
+
+ public void testSaturation() throws InterruptedException {
+ final CountDownLatch latch = new CountDownLatch(1);
+ for (int i=0; i<100; i++) {
+ JobLauncher.getInstance().submitToJobThread(0, new Runnable() {
+ @Override
+ public void run() {
+ try {
+ latch.await();
+ }
+ catch (InterruptedException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ });
+ }
+ JobLauncher.getInstance().submitToJobThread(0, new Runnable() {
+ @Override
+ public void run() {
+ latch.countDown();
+ }
+ });
+
+ try {
+ boolean scheduled = latch.await(3, TimeUnit.SECONDS);
+ assertFalse(scheduled); // pool saturated, no thread can be scheduled
+ }
+ finally {
+ latch.countDown();
+ }
+ }
}
/*
- * Copyright 2000-2013 JetBrains s.r.o.
+ * Copyright 2000-2014 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.
import com.intellij.find.replaceInProject.ReplaceInProjectManager;
import com.intellij.lang.properties.IProperty;
import com.intellij.lang.properties.psi.PropertiesFile;
-import com.intellij.openapi.Disposable;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.application.ex.PathManagerEx;
import com.intellij.openapi.command.CommandProcessor;
import com.intellij.util.CommonProcessors;
import com.intellij.util.ThrowableRunnable;
import com.intellij.util.WaitFor;
+import org.jetbrains.annotations.NotNull;
import java.io.File;
import java.util.ArrayList;
assertEquals(expectedResults, usages.size());
}
- private List<UsageInfo> findUsages(final FindModel findModel) {
+ private List<UsageInfo> findUsages(@NotNull FindModel findModel) {
PsiDirectory psiDirectory = FindInProjectUtil.getPsiDirectory(findModel, myProject);
List<UsageInfo> result = new ArrayList<UsageInfo>();
final CommonProcessors.CollectProcessor<UsageInfo> collector = new CommonProcessors.CollectProcessor<UsageInfo>(result);
- FindInProjectUtil.findUsages(findModel, psiDirectory, myProject, true, collector, new FindUsagesProcessPresentation());
+ FindInProjectUtil.findUsages(findModel, psiDirectory, myProject, true, collector, new FindUsagesProcessPresentation(FindInProjectUtil.setupViewPresentation(true, findModel)));
return result;
}
});
}
- public void _testSkipUnknownFileTypes() throws IOException {
+ public void testSkipUnknownFileTypes() throws IOException {
VirtualFile dir = getVirtualFile(createTempDirectory());
PsiTestUtil.addSourceContentToRoots(myModule, dir);
import com.intellij.openapi.roots.OrderRootType;
import com.intellij.openapi.roots.libraries.Library;
import com.intellij.openapi.roots.libraries.LibraryTable;
-import com.intellij.openapi.roots.ui.configuration.ModulesProvider;
import com.intellij.openapi.util.Pair;
import com.intellij.openapi.util.io.FileUtil;
import com.intellij.openapi.vfs.LocalFileSystem;
return StdModuleTypes.JAVA.modifySettingsStep(settingsStep, this);
}
- @Override
- public ModuleWizardStep[] createWizardSteps(@NotNull WizardContext wizardContext, @NotNull ModulesProvider modulesProvider) {
- return getModuleType().createWizardSteps(wizardContext, this, modulesProvider);
- }
-
public void setupRootModel(ModifiableRootModel rootModel) throws ConfigurationException {
final CompilerModuleExtension compilerModuleExtension = rootModel.getModuleExtension(CompilerModuleExtension.class);
compilerModuleExtension.setExcludeOutput(true);
import com.intellij.openapi.util.Segment;
import com.intellij.openapi.util.io.FileUtil;
import com.intellij.openapi.util.text.StringUtil;
-import com.intellij.openapi.vfs.LocalFileSystem;
-import com.intellij.openapi.vfs.VfsUtil;
-import com.intellij.openapi.vfs.VfsUtilCore;
-import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.openapi.vfs.*;
import com.intellij.psi.PsiClass;
import com.intellij.psi.PsiDocumentManager;
import com.intellij.psi.PsiFile;
}
final VirtualFile vFile = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(tempFile);
assert vFile != null;
+ vFile.setCharset(CharsetToolkit.UTF8_CHARSET);
VfsUtil.saveText(vFile, text);
final VirtualFile vdir = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(dir);
assertEquals("Text mismatch in file " + filePath, newFileText1, text);
CaretModel caretModel = myEditor.getCaretModel();
- List<Caret> allCarets = caretModel.supportsMultipleCarets() ? new ArrayList<Caret>(caretModel.getAllCarets()) : null;
- assertEquals("Unexpected number of carets", caretState.carets.size(), caretModel.supportsMultipleCarets() ? allCarets.size() : 1);
+ List<Caret> allCarets = new ArrayList<Caret>(caretModel.getAllCarets());
+ assertEquals("Unexpected number of carets", caretState.carets.size(), allCarets.size());
for (int i = 0; i < caretState.carets.size(); i++) {
- String caretDescription = caretState.carets.size() == 1 ? "" : "caret " + i + "/" + caretState.carets.size() + " ";
- Caret currentCaret = caretModel.supportsMultipleCarets() ? allCarets.get(i) : null;
- LogicalPosition actualCaretPosition;
- if (caretModel.supportsMultipleCarets()) {
- actualCaretPosition = currentCaret.getLogicalPosition();
- }
- else {
- actualCaretPosition = caretModel.getLogicalPosition();
- }
+ String caretDescription = caretState.carets.size() == 1 ? "" : "caret " + (i + 1) + "/" + caretState.carets.size() + " ";
+ Caret currentCaret = allCarets.get(i);
+ LogicalPosition actualCaretPosition = currentCaret.getLogicalPosition();
EditorTestUtil.Caret expected = caretState.carets.get(i);
if (expected.offset != null) {
int caretLine = StringUtil.offsetToLineNumber(newFileText, expected.offset);
assertEquals(caretDescription + "caretLine", caretLine + 1, actualCaretPosition.line + 1);
assertEquals(caretDescription + "caretColumn", caretCol + 1, actualCaretPosition.column + 1);
}
- int actualSelectionStart = caretModel.supportsMultipleCarets() ? currentCaret.getSelectionStart() : myEditor.getSelectionModel().getSelectionStart();
- int actualSelectionEnd = caretModel.supportsMultipleCarets() ? currentCaret.getSelectionEnd() : myEditor.getSelectionModel().getSelectionEnd();
+ int actualSelectionStart = currentCaret.getSelectionStart();
+ int actualSelectionEnd = currentCaret.getSelectionEnd();
if (expected.selection != null) {
int selStartLine = StringUtil.offsetToLineNumber(newFileText, expected.selection.getStartOffset());
int selStartCol = expected.selection.getStartOffset() - StringUtil.lineColToOffset(newFileText, selStartLine, 0);
}
else {
assertFalse(caretDescription + "should has no selection, but was: (" + actualSelectionStart + ", " + actualSelectionEnd + ")",
- caretModel.supportsMultipleCarets() ? currentCaret.hasSelection() : myEditor.getSelectionModel().hasSelection());
+ currentCaret.hasSelection());
}
}
}
import com.intellij.compiler.impl.TranslatingCompilerFilesMonitor;
import com.intellij.compiler.impl.javaCompiler.javac.JavacConfiguration;
+import com.intellij.compiler.options.ExternalBuildOptionListener;
import com.intellij.compiler.server.BuildManager;
import com.intellij.openapi.application.PathManager;
import com.intellij.openapi.application.Result;
new WriteAction() {
protected void run(final Result result) {
CompilerWorkspaceConfiguration.getInstance(project).USE_OUT_OF_PROCESS_BUILD = true;
+ project.getMessageBus().syncPublisher(ExternalBuildOptionListener.TOPIC).externalBuildOptionChanged(true);
ApplicationManagerEx.getApplicationEx().doNotSave(false);
JavaAwareProjectJdkTableImpl table = JavaAwareProjectJdkTableImpl.getInstanceEx();
table.addJdk(table.getInternalJdk());
new WriteAction() {
protected void run(final Result result) {
CompilerWorkspaceConfiguration.getInstance(project).USE_OUT_OF_PROCESS_BUILD = false;
+ project.getMessageBus().syncPublisher(ExternalBuildOptionListener.TOPIC).externalBuildOptionChanged(false);
ApplicationManagerEx.getApplicationEx().doNotSave(true);
JavaAwareProjectJdkTableImpl table = JavaAwareProjectJdkTableImpl.getInstanceEx();
table.removeJdk(table.getInternalJdk());
private static final Set<String> ASM_PRIMITIVE_TYPES = ContainerUtil
.newHashSet("C", "D", "F", "I", "J", "S", "Z", "B", "V", "Ljava/lang/Object;", "Ljava/lang/String;", "Ljava/lang/Class;");
- public static boolean isPrimitiveOrArray(final String asmType) {
- if (asmType.startsWith("[")) {
- return true;
+ public static boolean isPrimitiveOrArrayOfPrimitives(final String asmType) {
+ for (int i = 0; i < asmType.length(); i++) {
+ if (asmType.charAt(i) != '[') {
+ return ASM_PRIMITIVE_TYPES.contains(asmType.substring(i));
+ }
}
- return ASM_PRIMITIVE_TYPES.contains(asmType);
+ throw new AssertionError("Illegal string: " + asmType);
}
}
*/
package org.jetbrains.jps.classFilesIndex.indexer.api;
+import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.util.Processor;
import com.intellij.util.containers.SLRUCache;
import com.intellij.util.io.DataExternalizer;
import com.intellij.util.io.EnumeratorStringDescriptor;
import java.io.DataOutput;
import java.io.File;
import java.io.IOException;
+import java.util.ArrayList;
import java.util.Collection;
import java.util.Map;
import java.util.concurrent.locks.Lock;
*/
package org.jetbrains.jps.classFilesIndex.indexer.api;
+import com.intellij.openapi.diagnostic.Log;
+import com.intellij.openapi.diagnostic.Logger;
import com.intellij.util.containers.ContainerUtil;
import com.intellij.util.io.PersistentHashMap;
import org.jetbrains.asm4.ClassReader;
* @author Dmitry Batkovich
*/
public class ClassFilesIndexWriter<K, V> {
+ private static final Logger LOG = Logger.getInstance(ClassFilesIndexWriter.class);
+
private final ClassFileIndexer<K, V> myIndexer;
private final boolean myEmpty;
protected final ClassFilesIndexStorage<K, V> myIndex;
}
ClassFilesIndexStorage<K, V> index = null;
IOException exception = null;
+ LOG.debug("start open... " + indexer.getIndexCanonicalName());
for (int attempt = 0; attempt < 2; attempt++) {
try {
index = new ClassFilesIndexStorage<K, V>(storageDir, myIndexer.getKeyDescriptor(), myIndexer.getDataExternalizer());
PersistentHashMap.deleteFilesStartingWith(ClassFilesIndexStorage.getIndexFile(storageDir));
}
}
+ LOG.debug("opened " + indexer.getIndexCanonicalName());
if (index == null) {
throw new RuntimeException(exception);
}
import java.io.File;
import java.util.*;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
/**
* @author Dmitry Batkovich
private static final String PROGRESS_MESSAGE = "Indexing class-files...";
public static final String PROPERTY_NAME = "intellij.compiler.output.index";
+ private final AtomicLong myMs = new AtomicLong(0);
+ private final AtomicInteger myFilesCount = new AtomicInteger(0);
private final Collection<ClassFilesIndexWriter> myIndexWriters = new ArrayList<ClassFilesIndexWriter>();
@Override
if (!isEnabled()) {
return;
}
+ final long ms = System.currentTimeMillis();
for (final ClassFilesIndexWriter index : myIndexWriters) {
index.close(context);
}
myIndexWriters.clear();
- LOG.info("class files indexing finished");
+ myMs.addAndGet(System.currentTimeMillis() - ms);
+ LOG.info("class files indexing finished for " + myFilesCount.get() + " files in " + myMs.get() + "ms");
}
@Nullable
final ClassReader reader,
final ClassWriter writer,
final InstrumentationClassFinder finder) {
+ final long ms = System.currentTimeMillis();
for (final ClassFilesIndexWriter index : myIndexWriters) {
index.update(compiled.getOutputFile().getPath(), reader);
}
+ myMs.addAndGet(System.currentTimeMillis() - ms);
+ myFilesCount.incrementAndGet();
return null;
}
import com.intellij.util.io.DataExternalizer;
import com.intellij.util.io.EnumeratorStringDescriptor;
+import com.intellij.util.io.KeyDescriptor;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jps.classFilesIndex.AsmUtil;
return myStatic;
}
+ @Override
+ public String toString() {
+ return "MethodIncompleteSignature{" +
+ "myOwner='" + myOwner + '\'' +
+ ", myReturnType='" + myReturnType + '\'' +
+ ", myName='" + myName + '\'' +
+ ", myStatic=" + myStatic +
+ '}';
+ }
+
public final static Comparator<MethodIncompleteSignature> COMPARATOR = new Comparator<MethodIncompleteSignature>() {
@Override
public int compare(final MethodIncompleteSignature o1, final MethodIncompleteSignature o2) {
*/
package org.jetbrains.jps.classFilesIndex.indexer.impl;
-import com.intellij.util.containers.FactoryMap;
import com.intellij.util.io.DataExternalizer;
import com.intellij.util.io.EnumeratorStringDescriptor;
import com.intellij.util.io.KeyDescriptor;
import gnu.trove.TObjectIntHashMap;
import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
import org.jetbrains.asm4.*;
import org.jetbrains.jps.classFilesIndex.AsmUtil;
import org.jetbrains.jps.classFilesIndex.TObjectIntHashMapExternalizer;
import org.jetbrains.jps.classFilesIndex.indexer.api.ClassFileIndexer;
-import org.jetbrains.jps.classFilesIndex.indexer.api.ClassFilesIndicesBuilder;
import java.util.HashMap;
import java.util.Map;
@NotNull
@Override
public Map<String, TObjectIntHashMap<MethodIncompleteSignature>> map(final ClassReader inputData) {
- final Map<String, TObjectIntHashMap<MethodIncompleteSignature>> map = new HashMap<String, TObjectIntHashMap<MethodIncompleteSignature>>();
+ final Map<String, TObjectIntHashMap<MethodIncompleteSignature>> map =
+ new HashMap<String, TObjectIntHashMap<MethodIncompleteSignature>>();
final MethodVisitor methodVisitor = new MethodVisitor(Opcodes.ASM4) {
@Override
public void visitMethodInsn(final int opcode, final String owner, final String name, final String desc) {
final Type returnType = Type.getReturnType(desc);
- if (MethodIncompleteSignature.CONSTRUCTOR_METHOD_NAME.equals(name) || AsmUtil.isPrimitiveOrArray(returnType.getDescriptor())) {
+
projects / idea / community.git / commitdiff
