Support block code fragments in KotlinResolveCache

idea/src/org/jetbrains/jet/plugin/caches/resolve/KotlinResolveCache.kt

@@ -58,12 +58,13 @@ import org.jetbrains.jet.lang.psi.JetDelegationSpecifierList
 import org.jetbrains.jet.lang.psi.JetTypeParameter
 import org.jetbrains.jet.lang.psi.JetClassOrObject
 import org.jetbrains.jet.lang.psi.JetCallableDeclaration
-import org.jetbrains.jet.lang.psi.JetExpressionCodeFragment
+import org.jetbrains.jet.lang.psi.JetCodeFragment
 import org.jetbrains.jet.lang.psi.JetExpression
 import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo
 import org.jetbrains.jet.analyzer.analyzeInContext
 import org.jetbrains.jet.lang.resolve.BindingTraceContext
 import org.jetbrains.jet.lang.types.TypeUtils
+import org.jetbrains.jet.lang.resolve.scopes.ChainedScope
 
 public trait CacheExtension<T> {
     val platform: TargetPlatform
@@ -198,7 +199,7 @@ private object KotlinResolveDataProvider {
             javaClass<JetProperty>(),
             javaClass<JetImportDirective>(),
             javaClass<JetPackageDirective>(),
-            javaClass<JetExpressionCodeFragment>(),
+            javaClass<JetCodeFragment>(),
             // TODO: Non-analyzable so far, add more granular analysis
             javaClass<JetAnnotationEntry>(),
             javaClass<JetTypeConstraint>(),
@@ -228,7 +229,7 @@ private object KotlinResolveDataProvider {
 
     fun analyze(project: Project, resolveSession: ResolveSessionForBodies, analyzableElement: JetElement): AnalyzeExhaust {
         try {
-            if (analyzableElement is JetExpressionCodeFragment) {
+            if (analyzableElement is JetCodeFragment) {
                 return AnalyzeExhaust.success(
                         analyzeExpressionCodeFragment(resolveSession, analyzableElement),
                         resolveSession.getModuleDescriptor()
@@ -278,9 +279,9 @@ private object KotlinResolveDataProvider {
         }
     }
 
-    private fun analyzeExpressionCodeFragment(resolveSession: ResolveSessionForBodies, codeFragment: JetExpressionCodeFragment): BindingContext {
+    private fun analyzeExpressionCodeFragment(resolveSession: ResolveSessionForBodies, codeFragment: JetCodeFragment): BindingContext {
-        val codeFragmentExpression = codeFragment.getExpression()
+        val codeFragmentExpression = codeFragment.getSignificantElement()
-        if (codeFragmentExpression == null) return BindingContext.EMPTY
+        if (!(codeFragmentExpression is JetExpression)) return BindingContext.EMPTY
 
         val contextElement = codeFragment.getContext()
         if (contextElement !is JetExpression) return BindingContext.EMPTY
@@ -289,10 +290,17 @@ private object KotlinResolveDataProvider {
 
         val scopeForContextElement = contextForElement[BindingContext.RESOLUTION_SCOPE, contextElement]
         if (scopeForContextElement == null) return BindingContext.EMPTY
+
+        val codeFragmentScope = resolveSession.getScopeProvider().getFileScope(codeFragment)
+        val chainedScope = ChainedScope(
+                                scopeForContextElement.getContainingDeclaration(),
+                                "Scope for resolve code fragment",
+                                scopeForContextElement, codeFragmentScope)
+
         val dataFlowInfoForContextElement = contextForElement[BindingContext.EXPRESSION_DATA_FLOW_INFO, contextElement]
         val dataFlowInfo = dataFlowInfoForContextElement ?: DataFlowInfo.EMPTY
         return codeFragmentExpression.analyzeInContext(
-                scopeForContextElement,
+                chainedScope,
                 BindingTraceContext(),
                 dataFlowInfo,
                 TypeUtils.NO_EXPECTED_TYPE,

idea/src/org/jetbrains/jet/plugin/highlighter/JetPsiChecker.java

@@ -104,27 +104,15 @@ public class JetPsiChecker implements Annotator, HighlightRangeExtension {
 
         JetFile file = (JetFile) element.getContainingFile();
 
-        BindingContext bindingContext;
+        AnalyzeExhaust analyzeExhaust = ResolvePackage.getAnalysisResults(file);
-        if (file instanceof JetCodeFragment) {
+        if (analyzeExhaust.isError()) {
-            if (element instanceof JetElement) {
+            HighlighterPackage.updateHighlightingResult(file, true);
-                ResolveSessionForBodies resolveSession = ResolvePackage.getLazyResolveSession((JetElement) element);
-                bindingContext = resolveSession.resolveToElement((JetElement) element);
-            }
-            else {
-                return;
-            }
-        }
-        else {
-            AnalyzeExhaust analyzeExhaust = ResolvePackage.getAnalysisResults(file);
-            if (analyzeExhaust.isError()) {
-                HighlighterPackage.updateHighlightingResult(file, true);
 
-                throw new ProcessCanceledException(analyzeExhaust.getError());
+            throw new ProcessCanceledException(analyzeExhaust.getError());
-            }
-
-            bindingContext = analyzeExhaust.getBindingContext();
         }
 
+        BindingContext bindingContext = analyzeExhaust.getBindingContext();
+
         for (HighlightingVisitor visitor : getAfterAnalysisVisitor(holder, bindingContext)) {
             element.accept(visitor);
         }