From 7c38e36b3385a6de0bf2ee7c2023efdb2b29840d Mon Sep 17 00:00:00 2001 From: Kirill Likhodedov Date: Sun, 29 Sep 2013 11:59:06 +0400 Subject: [PATCH 1/9] [log] Fix graph tests: implement SimpleHash#equals --- .../intellij/vcs/log/parser/SimpleHash.java | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/platform/vcs-log/graph/test/com/intellij/vcs/log/parser/SimpleHash.java b/platform/vcs-log/graph/test/com/intellij/vcs/log/parser/SimpleHash.java index 92ad9e7a67f1..ae88b28be21e 100644 --- a/platform/vcs-log/graph/test/com/intellij/vcs/log/parser/SimpleHash.java +++ b/platform/vcs-log/graph/test/com/intellij/vcs/log/parser/SimpleHash.java @@ -40,4 +40,22 @@ class SimpleHash implements Hash { public String toShortString() { return myHash.substring(0, 7); } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + SimpleHash that = (SimpleHash)o; + + if (myHash != null ? !myHash.equals(that.myHash) : that.myHash != null) return false; + + return true; + } + + @Override + public int hashCode() { + return myHash != null ? myHash.hashCode() : 0; + } + } From 4cb85d539a1471e1bb3be58487ac50b706cf8f04 Mon Sep 17 00:00:00 2001 From: Kirill Likhodedov Date: Sun, 29 Sep 2013 12:35:17 +0400 Subject: [PATCH 2/9] [log] Fix parser test: implement equals for SimpleCommit --- .../intellij/vcs/log/parser/SimpleCommit.java | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/platform/vcs-log/graph/test/com/intellij/vcs/log/parser/SimpleCommit.java b/platform/vcs-log/graph/test/com/intellij/vcs/log/parser/SimpleCommit.java index 824880462eac..7b9f09fd52ed 100644 --- a/platform/vcs-log/graph/test/com/intellij/vcs/log/parser/SimpleCommit.java +++ b/platform/vcs-log/graph/test/com/intellij/vcs/log/parser/SimpleCommit.java @@ -49,4 +49,21 @@ public class SimpleCommit implements TimedVcsCommit { public List getParents() { return myParents; } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + SimpleCommit commit = (SimpleCommit)o; + + if (myHash != null ? !myHash.equals(commit.myHash) : commit.myHash != null) return false; + + return true; + } + + @Override + public int hashCode() { + return myHash != null ? myHash.hashCode() : 0; + } } From 5f8e1c82d987da6d246506aa2ef28a1e345c6f02 Mon Sep 17 00:00:00 2001 From: Kirill Likhodedov Date: Sun, 29 Sep 2013 12:36:27 +0400 Subject: [PATCH 3/9] [git] fix RefParserTest We have just tags here => no need to output type (and think about proper RefType to String translation). --- plugins/git4idea/tests/git4idea/log/RefParserTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/plugins/git4idea/tests/git4idea/log/RefParserTest.java b/plugins/git4idea/tests/git4idea/log/RefParserTest.java index b9b6c4e192d3..ea393fec1e48 100644 --- a/plugins/git4idea/tests/git4idea/log/RefParserTest.java +++ b/plugins/git4idea/tests/git4idea/log/RefParserTest.java @@ -14,7 +14,7 @@ import static junit.framework.Assert.assertEquals; public class RefParserTest { public String toStr(VcsRef ref) { - return String.format("%s %s %s", ref.getCommitHash().asString(), ref.getType(), ref.getName()); + return String.format("%s TAG %s", ref.getCommitHash().asString(), ref.getName()); } public void runTest(String inputStr, String outStr) { From ee9b1f818a8dc3c52d20897676baee1f965c8d70 Mon Sep 17 00:00:00 2001 From: peter Date: Sun, 29 Sep 2013 09:42:41 +0200 Subject: [PATCH 4/9] fix typo --- .../intellij/codeInspection/dataFlow/DfaMemoryStateImpl.java | 4 ++-- .../src/com/intellij/codeInspection/dataFlow/StateMerger.java | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/DfaMemoryStateImpl.java b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/DfaMemoryStateImpl.java index 1d9469669b6f..9543ac1b1ec4 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/DfaMemoryStateImpl.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/DfaMemoryStateImpl.java @@ -817,14 +817,14 @@ public class DfaMemoryStateImpl implements DfaMemoryState { } } } - for (DfaVariableValue value : new ArrayList(getChangedVariable())) { + for (DfaVariableValue value : new ArrayList(getChangedVariables())) { if (value.isFlushableByCalls()) { doFlush(value, true); } } } - Set getChangedVariable() { + Set getChangedVariables() { return myVariableStates.keySet(); } diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/StateMerger.java b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/StateMerger.java index 7eddf0a33113..29b90ae62c9e 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/StateMerger.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/StateMerger.java @@ -144,7 +144,7 @@ class StateMerger { MultiMap,DfaMemoryStateImpl> byInstanceof = new MultiMap, DfaMemoryStateImpl>(); for (final DfaMemoryStateImpl state : states) { ProgressManager.checkCanceled(); - for (DfaVariableValue value : state.getChangedVariable()) { + for (DfaVariableValue value : state.getChangedVariables()) { for (DfaPsiType instanceofValue : state.getVariableState(value).myInstanceofValues) { byInstanceof.putValue(Pair.create(value, instanceofValue), state); } @@ -154,7 +154,7 @@ class StateMerger { for (final DfaMemoryStateImpl state : states) { ProgressManager.checkCanceled(); - for (final DfaVariableValue var : state.getChangedVariable()) { + for (final DfaVariableValue var : state.getChangedVariables()) { for (final DfaPsiType notInstanceof : state.getVariableState(var).myNotInstanceofValues) { final DfaVariableState varStateWithoutType = getVarStateWithoutType(state, var, notInstanceof); List complementaryStates = ContainerUtil.filter( From 1500c8e404d737c5ac2189f00a804caac1b5ce69 Mon Sep 17 00:00:00 2001 From: peter Date: Sun, 29 Sep 2013 10:34:10 +0200 Subject: [PATCH 5/9] dfa: merge states differing in one variable nullability --- .../dataFlow/DfaInstructionState.java | 9 ++-- .../dataFlow/DfaMemoryStateImpl.java | 12 +++-- .../codeInspection/dataFlow/StateMerger.java | 52 +++++++++++++++++-- .../dataFlow/fixture/MergeByNullability.java | 39 ++++++++++++++ .../DataFlowInspectionTest.java | 1 + 5 files changed, 99 insertions(+), 14 deletions(-) create mode 100644 java/java-tests/testData/inspection/dataFlow/fixture/MergeByNullability.java diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/DfaInstructionState.java b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/DfaInstructionState.java index fce630465eb9..22d2a09837a1 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/DfaInstructionState.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/DfaInstructionState.java @@ -99,12 +99,9 @@ class StateQueue { StateMerger merger = new StateMerger(); while (true) { List nextStates = merger.mergeByEquality(memoryStates); - if (nextStates == null) { - nextStates = merger.mergeByType(memoryStates); - } - if (nextStates == null) { - nextStates = merger.mergeByUnknowns(memoryStates); - } + if (nextStates == null) nextStates = merger.mergeByType(memoryStates); + if (nextStates == null) nextStates = merger.mergeByNullability(memoryStates); + if (nextStates == null) nextStates = merger.mergeByUnknowns(memoryStates); if (nextStates == null) break; memoryStates = nextStates; } diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/DfaMemoryStateImpl.java b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/DfaMemoryStateImpl.java index 9543ac1b1ec4..bb645fd355fe 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/DfaMemoryStateImpl.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/DfaMemoryStateImpl.java @@ -136,14 +136,16 @@ public class DfaMemoryStateImpl implements DfaMemoryState { } public int hashCode() { - return getPartialHashCode(true); + return getPartialHashCode(true, true); } - int getPartialHashCode(boolean unknowns) { - int hash = ((getNonTrivialEqClasses().hashCode() * 31 + + int getPartialHashCode(boolean unknowns, boolean varStates) { + int hash = (getNonTrivialEqClasses().hashCode() * 31 + getDistinctClassPairs().hashCode()) * 31 + - myStack.hashCode()) * 31 + - myVariableStates.hashCode(); + myStack.hashCode(); + if (varStates) { + hash = hash * 31 + myVariableStates.hashCode(); + } if (unknowns) { hash = hash * 31 + myUnknownVariables.hashCode(); } diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/StateMerger.java b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/StateMerger.java index 29b90ae62c9e..3fbb6084c851 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/StateMerger.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/StateMerger.java @@ -112,7 +112,7 @@ class StateMerger { MultiMap byHash = new MultiMap(); for (DfaMemoryStateImpl state : states) { ProgressManager.checkCanceled(); - byHash.putValue(state.getPartialHashCode(false), state); + byHash.putValue(state.getPartialHashCode(false, true), state); } for (Integer key : byHash.keySet()) { @@ -139,6 +139,48 @@ class StateMerger { return null; } + @Nullable + public List mergeByNullability(List states) { + MultiMap byHash = new MultiMap(); + for (DfaMemoryStateImpl state : states) { + ProgressManager.checkCanceled(); + byHash.putValue(state.getPartialHashCode(false, false), state); + } + + for (Integer key : byHash.keySet()) { + Collection similarStates = byHash.get(key); + if (similarStates.size() < 2) continue; + + for (final DfaMemoryStateImpl state1 : similarStates) { + ProgressManager.checkCanceled(); + for (final DfaVariableValue var : state1.getChangedVariables()) { + if (state1.getVariableState(var).getNullability() != Nullness.NULLABLE) { + continue; + } + + List complementary = ContainerUtil.filter(similarStates, new Condition() { + @Override + public boolean value(DfaMemoryStateImpl state2) { + return state1.equalsSuperficially(state2) && + state1.equalsByRelations(state2) && + areEquivalentModuloVar(state1, state2, var) && + areVarStatesEqualModuloNullability(state1, state2, var); + } + }); + if (complementary.size() > 1) { + DfaMemoryStateImpl copy = state1.createCopy(); + mergeUnknowns(copy, complementary); + return getMergeResult(copy, ContainerUtil.newHashSet(complementary), states); + } + } + + } + + } + + return null; + } + @Nullable public List mergeByType(List states) { MultiMap,DfaMemoryStateImpl> byInstanceof = new MultiMap, DfaMemoryStateImpl>(); @@ -238,8 +280,8 @@ class StateMerger { List compatible = ContainerUtil.filter(statesByEq.get(createPair(var, value)), new Condition() { @Override public boolean value(DfaMemoryStateImpl state2) { - return seemCompatible(state, state2, var) && - state.getVariableState(var).withNullability(Nullness.UNKNOWN).equals(state2.getVariableState(var).withNullability(Nullness.UNKNOWN)); + return seemCompatible(state, state2, var) && + areVarStatesEqualModuloNullability(state, state2, var); } }); if (compatible.isEmpty()) { @@ -250,6 +292,10 @@ class StateMerger { return statesByValue; } + private boolean areVarStatesEqualModuloNullability(DfaMemoryStateImpl state1, DfaMemoryStateImpl state2, DfaVariableValue var) { + return state1.getVariableState(var).withNullability(Nullness.UNKNOWN).equals(state2.getVariableState(var).withNullability(Nullness.UNKNOWN)); + } + private boolean seemCompatible(DfaMemoryStateImpl state1, DfaMemoryStateImpl state2, DfaVariableValue differentVar) { if (!state1.equalsSuperficially(state2)) { return false; diff --git a/java/java-tests/testData/inspection/dataFlow/fixture/MergeByNullability.java b/java/java-tests/testData/inspection/dataFlow/fixture/MergeByNullability.java new file mode 100644 index 000000000000..69991d2c0a57 --- /dev/null +++ b/java/java-tests/testData/inspection/dataFlow/fixture/MergeByNullability.java @@ -0,0 +1,39 @@ +import org.jetbrains.annotations.Nullable; + +abstract class Some { + void foo(Object o1, Object o2, Object o3, Object o4, Object o5, Object o6, Object o7, Object o8, Object o9) { + String p1 = unknown() ? bar(o1) : ""; + consume(p1 == null ? "" : p1); + + String p2 = unknown() ? bar(o2) : ""; + consume(p2 == null ? "" : p2); + + String p3 = unknown() ? bar(o3) : ""; + consume(p3 == null ? "" : p3); + + String p4 = unknown() ? bar(o4) : ""; + consume(p4 == null ? "" : p4); + + String p5 = unknown() ? bar(o5) : ""; + consume(p5 == null ? "" : p5); + + String p6 = unknown() ? bar(o6) : ""; + consume(p6 == null ? "" : p6); + + String p7 = unknown() ? bar(o7) : ""; + consume(p7 == null ? "" : p7); + + String p8 = unknown() ? bar(o8) : ""; + consume(p8 == null ? "" : p8); + + String p9 = unknown() ? bar(o9) : ""; + consume(p9 == null ? "" : p9); + + } + + abstract void consume(String s); + + abstract boolean unknown(); + + @Nullable abstract String bar(Object o); +} \ No newline at end of file diff --git a/java/java-tests/testSrc/com/intellij/codeInspection/DataFlowInspectionTest.java b/java/java-tests/testSrc/com/intellij/codeInspection/DataFlowInspectionTest.java index d1606807fec5..e99c0eb5704e 100644 --- a/java/java-tests/testSrc/com/intellij/codeInspection/DataFlowInspectionTest.java +++ b/java/java-tests/testSrc/com/intellij/codeInspection/DataFlowInspectionTest.java @@ -307,6 +307,7 @@ public class DataFlowInspectionTest extends LightCodeInsightFixtureTestCase { public void testManyDisjunctiveFieldAssignmentsInLoopNotComplex() { doTest(); } public void testVariablesDiverge() { doTest(); } + public void testMergeByNullability() { doTest(); } public void testDontForgetInstanceofInfoWhenMerging() { doTest(); } public void testDontMakeNullableAfterInstanceof() { doTest(); } From f3063e6679300cf259705a685d760f15bc718827 Mon Sep 17 00:00:00 2001 From: peter Date: Sun, 29 Sep 2013 11:22:56 +0200 Subject: [PATCH 6/9] dfa: don't merge by type states which have different eq states --- .../codeInspection/dataFlow/StateMerger.java | 4 +++- .../DontForgetEqInfoWhenMergingByType.java | 21 +++++++++++++++++++ .../DataFlowInspectionTest.java | 1 + 3 files changed, 25 insertions(+), 1 deletion(-) create mode 100644 java/java-tests/testData/inspection/dataFlow/fixture/DontForgetEqInfoWhenMergingByType.java diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/StateMerger.java b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/StateMerger.java index 3fbb6084c851..a9286654bbc1 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/StateMerger.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/StateMerger.java @@ -205,8 +205,10 @@ class StateMerger { @Override public boolean value(DfaMemoryStateImpl another) { return seemCompatible(state, another, var) && + another.getVariableState(var).myInstanceofValues.contains(notInstanceof) && varStateWithoutType.equals(getVarStateWithoutType(another, var, notInstanceof)) && - areEquivalentModuloVar(another, state, var); + areEquivalentModuloVar(another, state, var) && + !(state.isNull(var) && another.isNotNull(var)); } }); if (complementaryStates.isEmpty()) { diff --git a/java/java-tests/testData/inspection/dataFlow/fixture/DontForgetEqInfoWhenMergingByType.java b/java/java-tests/testData/inspection/dataFlow/fixture/DontForgetEqInfoWhenMergingByType.java new file mode 100644 index 000000000000..572b2fc2c4fa --- /dev/null +++ b/java/java-tests/testData/inspection/dataFlow/fixture/DontForgetEqInfoWhenMergingByType.java @@ -0,0 +1,21 @@ +class Some { + + private boolean canBePatternVariable(PsiElement element) { + if (element instanceof LeafElement) { + return true; + } + + while (!(element instanceof LeafElement) && element != null) { + element = getNextObject(element); + } + return element != null; + } + + PsiElement getNextObject(PsiElement element) { return element; } + + class LeafElement {} + interface PsiElement {} + +} + + diff --git a/java/java-tests/testSrc/com/intellij/codeInspection/DataFlowInspectionTest.java b/java/java-tests/testSrc/com/intellij/codeInspection/DataFlowInspectionTest.java index e99c0eb5704e..c5158a430b7b 100644 --- a/java/java-tests/testSrc/com/intellij/codeInspection/DataFlowInspectionTest.java +++ b/java/java-tests/testSrc/com/intellij/codeInspection/DataFlowInspectionTest.java @@ -309,6 +309,7 @@ public class DataFlowInspectionTest extends LightCodeInsightFixtureTestCase { public void testVariablesDiverge() { doTest(); } public void testMergeByNullability() { doTest(); } public void testDontForgetInstanceofInfoWhenMerging() { doTest(); } + public void testDontForgetEqInfoWhenMergingByType() { doTest(); } public void testDontMakeNullableAfterInstanceof() { doTest(); } public void _testNullCheckBeforeInstanceof() { doTest(); } // http://youtrack.jetbrains.com/issue/IDEA-113220 From 21c1306bec0f925fc99a5ddc8f37d5663c79649a Mon Sep 17 00:00:00 2001 From: anna Date: Fri, 27 Sep 2013 16:35:51 +0200 Subject: [PATCH 7/9] new inference: simplification --- .../source/tree/java/PsiMethodReferenceExpressionImpl.java | 3 --- 1 file changed, 3 deletions(-) diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiMethodReferenceExpressionImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiMethodReferenceExpressionImpl.java index 0d2a74b29af1..c8e6d23c1feb 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiMethodReferenceExpressionImpl.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiMethodReferenceExpressionImpl.java @@ -394,9 +394,6 @@ public class PsiMethodReferenceExpressionImpl extends PsiReferenceExpressionBase final PsiResolveHelper resolveHelper = JavaPsiFacade.getInstance(getProject()).getResolveHelper(); PsiSubstitutor psiSubstitutor = resolveHelper.inferTypeArguments(method.getTypeParameters(), types, rightTypes, languageLevel); psiSubstitutor = psiSubstitutor.putAll(substitutor); - if (method.isConstructor()) { - psiSubstitutor = psiSubstitutor.putAll(resolveHelper.inferTypeArguments(method.getContainingClass().getTypeParameters(), types, rightTypes, languageLevel)); - } return LambdaUtil.inferFromReturnType(method.getTypeParameters(), psiSubstitutor.substitute(method.getReturnType()), From 34de17190a7d0e31c0df6172379bcd1920243730 Mon Sep 17 00:00:00 2001 From: anna Date: Mon, 30 Sep 2013 11:29:32 +0200 Subject: [PATCH 8/9] extract method: suggest correctly capitalized name (IDEA-114102) --- .../refactoring/extractMethod/ExtractMethodProcessor.java | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/java/java-impl/src/com/intellij/refactoring/extractMethod/ExtractMethodProcessor.java b/java/java-impl/src/com/intellij/refactoring/extractMethod/ExtractMethodProcessor.java index c8007a344815..cf428c752d63 100644 --- a/java/java-impl/src/com/intellij/refactoring/extractMethod/ExtractMethodProcessor.java +++ b/java/java-impl/src/com/intellij/refactoring/extractMethod/ExtractMethodProcessor.java @@ -47,10 +47,7 @@ import com.intellij.openapi.util.text.StringUtil; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.openapi.wm.WindowManager; import com.intellij.psi.*; -import com.intellij.psi.codeStyle.CodeStyleManager; -import com.intellij.psi.codeStyle.CodeStyleSettingsManager; -import com.intellij.psi.codeStyle.JavaCodeStyleManager; -import com.intellij.psi.codeStyle.VariableKind; +import com.intellij.psi.codeStyle.*; import com.intellij.psi.controlFlow.ControlFlowUtil; import com.intellij.psi.impl.source.codeStyle.JavaCodeStyleManagerImpl; import com.intellij.psi.search.GlobalSearchScope; @@ -516,7 +513,7 @@ public class ExtractMethodProcessor implements MatchProvider { PsiElement prevSibling = PsiTreeUtil.skipSiblingsBackward(myElements[0], PsiWhiteSpace.class); if (prevSibling instanceof PsiComment && ((PsiComment)prevSibling).getTokenType() == JavaTokenType.END_OF_LINE_COMMENT) { - final String text = prevSibling.getText().trim().replaceAll(" ", "").substring(2); + final String text = StringUtil.decapitalize(StringUtil.capitalizeWords(prevSibling.getText().trim().substring(2), true)).replaceAll(" ", ""); if (JavaPsiFacade.getInstance(myProject).getNameHelper().isIdentifier(text) && text.length() < 20) { return text; } From 47979c3bcbec5b66bd7c53be218b95181760d98f Mon Sep 17 00:00:00 2001 From: "Vladislav.Soroka" Date: Mon, 30 Sep 2013 13:55:56 +0400 Subject: [PATCH 9/9] Gradle: NPE fixed --- .../resolve/GradleImplicitContributor.java | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/plugins/gradle/src/org/jetbrains/plugins/gradle/service/resolve/GradleImplicitContributor.java b/plugins/gradle/src/org/jetbrains/plugins/gradle/service/resolve/GradleImplicitContributor.java index fc7e1e38737f..2936d684c361 100644 --- a/plugins/gradle/src/org/jetbrains/plugins/gradle/service/resolve/GradleImplicitContributor.java +++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/service/resolve/GradleImplicitContributor.java @@ -151,15 +151,16 @@ public class GradleImplicitContributor implements GradleMethodContextContributor } Module module = ModuleUtilCore.findModuleForPsiElement(place); - if (module != null) { - String path = module.getOptionValue(ExternalSystemConstants.ROOT_PROJECT_PATH_KEY); - GradleLocalSettings localSettings = GradleLocalSettings.getInstance(place.getProject()); - Collection taskPojos = localSettings.getAvailableTasks().get(path); - for (ExternalTaskPojo taskPojo : taskPojos) { - if (taskName.equals(taskPojo.getName())) { - processTask(taskName, GRADLE_API_TASK, psiManager, processor, state, place); - return; - } + if (module == null) return; + String path = module.getOptionValue(ExternalSystemConstants.ROOT_PROJECT_PATH_KEY); + GradleLocalSettings localSettings = GradleLocalSettings.getInstance(place.getProject()); + Collection taskPojos = localSettings.getAvailableTasks().get(path); + if (taskPojos == null) return; + + for (ExternalTaskPojo taskPojo : taskPojos) { + if (taskName.equals(taskPojo.getName())) { + processTask(taskName, GRADLE_API_TASK, psiManager, processor, state, place); + return; } } }