Partial body resolve: to take source Kotlin callables with Nothing type from caches

GitOrigin-RevId: abde9b141fab052dab0fe0ac6961a7a5fdcaf764

plugins/kotlin/analysis/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java

@@ -28,16 +28,26 @@ import org.jetbrains.jet.lang.psi.JetElement;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider;
 import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.resolve.lazy.DefaultNothingCallableNamesService;
 import org.jetbrains.jet.lang.resolve.lazy.ElementResolver;
+import org.jetbrains.jet.lang.resolve.lazy.PossiblyNothingCallableNamesService;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
+import org.jetbrains.jet.plugin.stubindex.JetPossiblyNothingFunctionShortNameIndex;
+import org.jetbrains.jet.plugin.stubindex.JetPossiblyNothingPropertyShortNameIndex;
 import org.jetbrains.jet.storage.LazyResolveStorageManager;
 import org.jetbrains.jet.storage.MemoizedFunctionToNotNull;
 
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Set;
+
 public class ResolveElementCache extends ElementResolver {
+    private final Project project;
     private final CachedValue<MemoizedFunctionToNotNull<JetElement, BindingContext>> additionalResolveCache;
 
     public ResolveElementCache(ResolveSession resolveSession, Project project) {
         super(resolveSession);
+        this.project = project;
 
         // Recreate internal cache after change of modification count
         this.additionalResolveCache =
@@ -74,4 +84,29 @@ public class ResolveElementCache extends ElementResolver {
     public AdditionalCheckerProvider getAdditionalCheckerProvider(@NotNull JetFile jetFile) {
         return TargetPlatformDetector.getPlatform(jetFile).getAdditionalCheckerProvider();
     }
+
+    @NotNull
+    @Override
+    protected PossiblyNothingCallableNamesService possiblyNothingCallableNamesService() {
+        return new PossiblyNothingCallableNamesService() {
+            @NotNull
+            @Override
+            public Set<String> functionNames() {
+                // we have to add hardcoded-names until we have Kotlin compiled classes in caches
+                Set<String> hardcodedNames = DefaultNothingCallableNamesService.INSTANCE$.functionNames();
+                Collection<String> indexedNames = JetPossiblyNothingFunctionShortNameIndex.getInstance().getAllKeys(project);
+                Set<String> set = new HashSet<String>(hardcodedNames.size() + indexedNames.size());
+                set.addAll(hardcodedNames);
+                set.addAll(indexedNames);
+                return set;
+                //TODO: what about local declarations?
+            }
+
+            @NotNull
+            @Override
+            public Set<String> propertyNames() {
+                return new HashSet<String>(JetPossiblyNothingPropertyShortNameIndex.getInstance().getAllKeys(project));
+            }
+        };
+    }
 }

plugins/kotlin/analysis/src/org/jetbrains/jet/plugin/stubindex/JetPossiblyNothingFunctionShortNameIndex.java

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2010-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 org.jetbrains.jet.plugin.stubindex;
+
+import com.intellij.openapi.project.Project;
+import com.intellij.psi.search.GlobalSearchScope;
+import com.intellij.psi.stubs.StringStubIndexExtension;
+import com.intellij.psi.stubs.StubIndexKey;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.psi.JetNamedFunction;
+
+import java.util.Collection;
+
+public class JetPossiblyNothingFunctionShortNameIndex extends StringStubIndexExtension<JetNamedFunction> {
+    private static final StubIndexKey<String, JetNamedFunction> KEY = KotlinIndexUtil.createIndexKey(JetPossiblyNothingFunctionShortNameIndex.class);
+
+    private static final JetPossiblyNothingFunctionShortNameIndex ourInstance = new JetPossiblyNothingFunctionShortNameIndex();
+
+    public static JetPossiblyNothingFunctionShortNameIndex getInstance() {
+        return ourInstance;
+    }
+
+    private JetPossiblyNothingFunctionShortNameIndex() {}
+
+    @NotNull
+    @Override
+    public StubIndexKey<String, JetNamedFunction> getKey() {
+        return KEY;
+    }
+
+    @NotNull
+    @Override
+    public Collection<JetNamedFunction> get(@NotNull String s, @NotNull Project project, @NotNull GlobalSearchScope scope) {
+        return super.get(s, project, JetSourceFilterScope.kotlinSourcesAndLibraries(scope, project));
+    }
+}

plugins/kotlin/analysis/src/org/jetbrains/jet/plugin/stubindex/JetPossiblyNothingPropertyShortNameIndex.java

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2010-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 org.jetbrains.jet.plugin.stubindex;
+
+import com.intellij.openapi.project.Project;
+import com.intellij.psi.search.GlobalSearchScope;
+import com.intellij.psi.stubs.StringStubIndexExtension;
+import com.intellij.psi.stubs.StubIndexKey;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.psi.JetProperty;
+
+import java.util.Collection;
+
+public class JetPossiblyNothingPropertyShortNameIndex extends StringStubIndexExtension<JetProperty> {
+    private static final StubIndexKey<String, JetProperty> KEY = KotlinIndexUtil.createIndexKey(JetPossiblyNothingPropertyShortNameIndex.class);
+
+    private static final JetPossiblyNothingPropertyShortNameIndex ourInstance = new JetPossiblyNothingPropertyShortNameIndex();
+
+    public static JetPossiblyNothingPropertyShortNameIndex getInstance() {
+        return ourInstance;
+    }
+
+    private JetPossiblyNothingPropertyShortNameIndex() {}
+
+    @NotNull
+    @Override
+    public StubIndexKey<String, JetProperty> getKey() {
+        return KEY;
+    }
+
+    @NotNull
+    @Override
+    public Collection<JetProperty> get(@NotNull String s, @NotNull Project project, @NotNull GlobalSearchScope scope) {
+        return super.get(s, project, JetSourceFilterScope.kotlinSourcesAndLibraries(scope, project));
+    }
+}

plugins/kotlin/analysis/src/org/jetbrains/jet/plugin/stubindex/StubIndexServiceImpl.java

@@ -113,6 +113,10 @@ public class StubIndexServiceImpl implements StubIndexService {
                 }
             }
             sink.occurrence(JetFunctionShortNameIndex.getInstance().getKey(), name);
+
+            if (stub.isPossiblyNothingType()) {
+                sink.occurrence(JetPossiblyNothingFunctionShortNameIndex.getInstance().getKey(), name);
+            }
         }
         // can have special fq name in case of syntactically incorrect function with no name
         FqName topFQName = stub.getFqName();
@@ -136,6 +140,10 @@ public class StubIndexServiceImpl implements StubIndexService {
             }
 
             sink.occurrence(JetPropertyShortNameIndex.getInstance().getKey(), name);
+
+            if (stub.isPossiblyNothingType()) {
+                sink.occurrence(JetPossiblyNothingPropertyShortNameIndex.getInstance().getKey(), name);
+            }
         }
         // can have special fq name in case of syntactically incorrect function with no name
         if (stub.isTopLevel()) {

plugins/kotlin/common/src/org/jetbrains/jet/lang/resolve/lazy/ElementResolver.java

@@ -69,6 +69,11 @@ public abstract class ElementResolver {
         return resolveToElement(jetElement, false);
     }
 
+    @NotNull
+    protected PossiblyNothingCallableNamesService possiblyNothingCallableNamesService() {
+        return DefaultNothingCallableNamesService.INSTANCE$;
+    }
+
     @NotNull
     public BindingContext resolveToElement(@NotNull JetElement jetElement, boolean partialBodyResolve) {
         @SuppressWarnings("unchecked") JetElement elementOfAdditionalResolve = (JetElement) JetPsiUtil.getTopmostParentOfTypes(
@@ -96,7 +101,7 @@ public abstract class ElementResolver {
                 boolean inBody = body != null && PsiTreeUtil.isAncestor(body, jetElement, false);
                 Function1<JetElement, Boolean> filter;
                 if (inBody) {
-                    filter = new PartialBodyResolveFilter(jetElement, body);
+                    filter = new PartialBodyResolveFilter(jetElement, body, possiblyNothingCallableNamesService());
                 }
                 else { // do as less as possible body-resolve
                     filter = new Function1<JetElement, Boolean>() {

plugins/kotlin/common/src/org/jetbrains/jet/lang/resolve/lazy/PartialBodyResolveFilter.kt

@@ -27,10 +27,16 @@ import com.intellij.psi.PsiElement
 import org.jetbrains.jet.JetNodeTypes
 import org.jetbrains.jet.lang.psi.psiUtil.isAncestor
 
-class PartialBodyResolveFilter(elementToResolve: JetElement, private val body: JetExpression) : (JetElement) -> Boolean {
+class PartialBodyResolveFilter(
+        elementToResolve: JetElement,
+        private val body: JetExpression,
+        possiblyNothingCallableNamesService: PossiblyNothingCallableNamesService
+) : (JetElement) -> Boolean {
 
     private val statementsToResolve = HashSet<JetExpression>()
     private val processedBlocks = HashSet<JetBlockExpression>()
+    private val possiblyNothingFunctionNames = possiblyNothingCallableNamesService.functionNames()
+    private val possiblyNothingPropertyNames = possiblyNothingCallableNamesService.propertyNames()
 
     ;{
         assert(body.isAncestor(elementToResolve, strict = false))
@@ -286,6 +292,13 @@ class PartialBodyResolveFilter(elementToResolve: JetElement, private val body: J
                 super.visitCallExpression(expression)
             }
 
+            override fun visitSimpleNameExpression(expression: JetSimpleNameExpression) {
+                val name = expression.getReferencedName()
+                if (name in possiblyNothingPropertyNames) {
+                    result.add(expression)
+                }
+            }
+
             override fun visitBinaryExpression(expression: JetBinaryExpression) {
                 if (expression.getOperationToken() == JetTokens.ELVIS) {
                     // do not search exits after "?:"
@@ -368,9 +381,5 @@ class PartialBodyResolveFilter(elementToResolve: JetElement, private val body: J
 
     private fun JetBlockExpression.lastStatement(): JetExpression?
             = getLastChild().siblings(forward = false).filterIsInstance<JetExpression>().firstOrNull()
-
-    class object {
-        private val possiblyNothingFunctionNames = setOf("error") // currently hard-coded
-    }
 }
 

plugins/kotlin/common/src/org/jetbrains/jet/lang/resolve/lazy/PossiblyNothingCallableNamesService.kt

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2010-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 org.jetbrains.jet.lang.resolve.lazy
+
+public trait PossiblyNothingCallableNamesService {
+    public fun functionNames(): Set<String>
+    public fun propertyNames(): Set<String>
+}
+
+public object DefaultNothingCallableNamesService : PossiblyNothingCallableNamesService {
+    private val hardcodedNames = setOf("error")
+
+    override fun functionNames() = hardcodedNames
+    override fun propertyNames(): Set<String> = setOf()
+}

plugins/kotlin/idea/src/META-INF/plugin.xml

@@ -395,6 +395,8 @@
     <stubIndex implementation="org.jetbrains.jet.plugin.stubindex.JetTopLevelPropertiesFqnNameIndex"/>
     <stubIndex implementation="org.jetbrains.jet.plugin.stubindex.JetAnnotationsIndex"/>
     <stubIndex implementation="org.jetbrains.jet.plugin.stubindex.JetTopLevelObjectShortNameIndex"/>
+    <stubIndex implementation="org.jetbrains.jet.plugin.stubindex.JetPossiblyNothingFunctionShortNameIndex"/>
+    <stubIndex implementation="org.jetbrains.jet.plugin.stubindex.JetPossiblyNothingPropertyShortNameIndex"/>
 
     <psi.classFileDecompiler implementation="org.jetbrains.jet.plugin.decompiler.JetClassFileDecompiler"/>
     

plugins/kotlin/idea/tests/test/org/jetbrains/jet/resolve/PartialBodyResolveTestGenerated.java

@@ -19,6 +19,7 @@ package org.jetbrains.jet.resolve;
 import com.intellij.testFramework.TestDataPath;
 import org.jetbrains.jet.JUnit3RunnerWithInners;
 import org.jetbrains.jet.JetTestUtils;
+import org.jetbrains.jet.test.InnerTestClasses;
 import org.jetbrains.jet.test.TestMetadata;
 import org.junit.runner.RunWith;
 
@@ -107,6 +108,24 @@ public class PartialBodyResolveTestGenerated extends AbstractPartialBodyResolveT
         doTest(fileName);
     }
 
+    @TestMetadata("IfNotIsErrorVariable.kt")
+    public void testIfNotIsErrorVariable() throws Exception {
+        String fileName = JetTestUtils.navigationMetadata("idea/testData/resolve/partialBodyResolve/IfNotIsErrorVariable.kt");
+        doTest(fileName);
+    }
+
+    @TestMetadata("IfNotIsMyError.kt")
+    public void testIfNotIsMyError() throws Exception {
+        String fileName = JetTestUtils.navigationMetadata("idea/testData/resolve/partialBodyResolve/IfNotIsMyError.kt");
+        doTest(fileName);
+    }
+
+    @TestMetadata("IfNotIsNothingProp.kt")
+    public void testIfNotIsNothingProp() throws Exception {
+        String fileName = JetTestUtils.navigationMetadata("idea/testData/resolve/partialBodyResolve/IfNotIsNothingProp.kt");
+        doTest(fileName);
+    }
+
     @TestMetadata("IfNotIsReturn.kt")
     public void testIfNotIsReturn() throws Exception {
         String fileName = JetTestUtils.navigationMetadata("idea/testData/resolve/partialBodyResolve/IfNotIsReturn.kt");

plugins/kotlin/idea/tests/testData/resolve/partialBodyResolve/IfNotIsErrorVariable.dump

@@ -0,0 +1,3 @@
+Resolve target: value-parameter val p: kotlin.Any
+Skipped statements:
+if (p !is String) { print(error) }

plugins/kotlin/idea/tests/testData/resolve/partialBodyResolve/IfNotIsErrorVariable.kt

@@ -0,0 +1,7 @@
+val error = "error"
+fun foo(p: Any) {
+    if (p !is String) {
+        print(error)
+    }
+    println(<caret>p.size)
+}

plugins/kotlin/idea/tests/testData/resolve/partialBodyResolve/IfNotIsMyError.dump

@@ -0,0 +1,2 @@
+Resolve target: value-parameter val p: kotlin.Any smart-casted to kotlin.String
+Skipped statements:

plugins/kotlin/idea/tests/testData/resolve/partialBodyResolve/IfNotIsMyError.kt

@@ -0,0 +1,8 @@
+fun myError(): Nothing = throw Exception()
+
+fun foo(p: Any) {
+    if (p !is String) {
+        myError()
+    }
+    println(<caret>p.size)
+}

plugins/kotlin/idea/tests/testData/resolve/partialBodyResolve/IfNotIsNothingProp.dump

@@ -0,0 +1,2 @@
+Resolve target: value-parameter val p: kotlin.Any smart-casted to kotlin.String
+Skipped statements:

plugins/kotlin/idea/tests/testData/resolve/partialBodyResolve/IfNotIsNothingProp.kt

@@ -0,0 +1,9 @@
+val prop: Nothing
+    get() = throw Exception()
+
+fun foo(p: Any) {
+    if (p !is String) {
+        prop
+    }
+    println(<caret>p.size)
+}