Utilities for analyzing expressions in given context introduced

compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzerUtil.kt

@@ -0,0 +1,71 @@
+/*
+ * 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.analyzer
+
+import org.jetbrains.jet.lang.psi.JetExpression
+import org.jetbrains.jet.lang.resolve.scopes.JetScope
+import org.jetbrains.jet.di.InjectorForMacros
+import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo
+import org.jetbrains.jet.lang.types.JetType
+import org.jetbrains.jet.lang.types.TypeUtils
+import org.jetbrains.jet.lang.descriptors.ModuleDescriptor
+import org.jetbrains.jet.lang.types.JetTypeInfo
+import org.jetbrains.jet.lang.types.ErrorUtils
+import org.jetbrains.jet.lang.resolve.BindingContext
+import org.jetbrains.jet.lang.resolve.BindingTraceContext
+import org.jetbrains.jet.lang.resolve.BindingTrace
+import org.jetbrains.jet.lang.resolve.DescriptorUtils
+
+public fun JetExpression.computeTypeInfoInContext(
+        scope: JetScope,
+        trace: BindingTrace = BindingTraceContext(),
+        dataFlowInfo: DataFlowInfo = DataFlowInfo.EMPTY,
+        expectedType: JetType = TypeUtils.NO_EXPECTED_TYPE,
+        module: ModuleDescriptor = scope.getModule()
+): JetTypeInfo {
+    val injectorForMacros = InjectorForMacros(getProject(), module)
+    return injectorForMacros.getExpressionTypingServices()!!.getTypeInfo(scope, this, expectedType, dataFlowInfo, trace)
+}
+
+public fun JetExpression.analyzeInContext(
+        scope: JetScope,
+        trace: BindingTrace = BindingTraceContext(),
+        dataFlowInfo: DataFlowInfo = DataFlowInfo.EMPTY,
+        expectedType: JetType = TypeUtils.NO_EXPECTED_TYPE,
+        module: ModuleDescriptor = scope.getModule()
+): BindingContext {
+    computeTypeInfoInContext(scope, trace, dataFlowInfo, expectedType, module)
+    return trace.getBindingContext()
+}
+
+public fun JetExpression.computeTypeInContext(
+        scope: JetScope,
+        trace: BindingTrace = BindingTraceContext(),
+        dataFlowInfo: DataFlowInfo = DataFlowInfo.EMPTY,
+        expectedType: JetType = TypeUtils.NO_EXPECTED_TYPE,
+        module: ModuleDescriptor = scope.getModule()
+): JetType {
+    return computeTypeInfoInContext(scope, trace, dataFlowInfo, expectedType, module).getType().safeType(this)
+}
+
+public fun JetType?.safeType(expression: JetExpression): JetType {
+    if (this != null) return this
+
+    return ErrorUtils.createErrorType("Type for " + expression.getText())
+}
+
+private fun JetScope.getModule(): ModuleDescriptor = DescriptorUtils.getParentOfType(this.getContainingDeclaration(), javaClass<ModuleDescriptor>())!!

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingServices.java

@@ -21,6 +21,7 @@ import com.intellij.openapi.project.Project;
 import com.intellij.psi.tree.IElementType;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.analyzer.AnalyzerPackage;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
 import org.jetbrains.jet.lang.descriptors.ScriptDescriptor;
@@ -147,10 +148,7 @@ public class ExpressionTypingServices {
     @NotNull
     public JetType safeGetType(@NotNull JetScope scope, @NotNull JetExpression expression, @NotNull JetType expectedType, @NotNull DataFlowInfo dataFlowInfo, @NotNull BindingTrace trace) {
         JetType type = getType(scope, expression, expectedType, dataFlowInfo, trace);
-        if (type != null) {
-            return type;
-        }
-        return ErrorUtils.createErrorType("Type for " + expression.getText());
+        return AnalyzerPackage.safeType(type, expression);
     }
 
     @NotNull

idea/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java

@@ -26,8 +26,8 @@ import com.intellij.psi.util.*;
 import kotlin.Function1;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.analyzer.AnalyzerPackage;
 import org.jetbrains.jet.di.InjectorForBodyResolve;
-import org.jetbrains.jet.di.InjectorForMacros;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.Annotated;
 import org.jetbrains.jet.lang.psi.*;
@@ -229,13 +229,13 @@ public class ResolveElementCache {
         JetScope scopeForContextElement = contextForElement.get(BindingContext.RESOLUTION_SCOPE, contextExpression);
         if (scopeForContextElement != null) {
             DataFlowInfo dataFlowInfoForContextElement = contextForElement.get(BindingContext.EXPRESSION_DATA_FLOW_INFO, contextExpression);
-            InjectorForMacros injectorForMacros = new InjectorForMacros(codeFragment.getProject(), resolveSession.getModuleDescriptor());
-            injectorForMacros.getExpressionTypingServices().getType(
+            AnalyzerPackage.computeTypeInContext(
+                    codeFragment.getExpression(),
                     scopeForContextElement,
-                    codeFragmentExpression,
-                    TypeUtils.NO_EXPECTED_TYPE,
+                    trace,
                     dataFlowInfoForContextElement == null ? DataFlowInfo.EMPTY : dataFlowInfoForContextElement,
-                    trace
+                    TypeUtils.NO_EXPECTED_TYPE,
+                    resolveSession.getModuleDescriptor()
             );
         }
     }

idea/src/org/jetbrains/jet/plugin/refactoring/introduce/introduceVariable/KotlinIntroduceVariableHandler.java

@@ -34,9 +34,9 @@ import com.intellij.refactoring.introduce.inplace.OccurrencesChooser;
 import kotlin.Function1;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.di.InjectorForMacros;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.descriptors.VariableDescriptor;
+import org.jetbrains.jet.analyzer.AnalyzerPackage;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingTraceContext;
@@ -55,7 +55,10 @@ import org.jetbrains.jet.plugin.codeInsight.CodeInsightUtils;
 import org.jetbrains.jet.plugin.codeInsight.ShortenReferences;
 import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache;
 import org.jetbrains.jet.plugin.project.ResolveSessionForBodies;
-import org.jetbrains.jet.plugin.refactoring.*;
+import org.jetbrains.jet.plugin.refactoring.JetNameSuggester;
+import org.jetbrains.jet.plugin.refactoring.JetNameValidatorImpl;
+import org.jetbrains.jet.plugin.refactoring.JetRefactoringBundle;
+import org.jetbrains.jet.plugin.refactoring.JetRefactoringUtil;
 import org.jetbrains.jet.plugin.refactoring.introduce.KotlinIntroduceHandlerBase;
 import org.jetbrains.jet.renderer.DescriptorRenderer;
 
@@ -133,10 +136,9 @@ public class KotlinIntroduceVariableHandler extends KotlinIntroduceHandlerBase {
             }
 
             ObservableBindingTrace bindingTrace = new ObservableBindingTrace(new BindingTraceContext());
-            InjectorForMacros injector = new InjectorForMacros(project, resolveSession.getModuleDescriptor());
-            JetType typeNoExpectedType = injector.getExpressionTypingServices().getType(scope, expression,
-                                                                                TypeUtils.NO_EXPECTED_TYPE, dataFlowInfo,
-                                                                                bindingTrace);
+            JetType typeNoExpectedType = AnalyzerPackage.computeTypeInfoInContext(
+                    expression, scope, bindingTrace, dataFlowInfo, TypeUtils.NO_EXPECTED_TYPE, resolveSession.getModuleDescriptor()
+            ).getType();
             if (expressionType != null && typeNoExpectedType != null && !JetTypeChecker.INSTANCE.equalTypes(expressionType,
                                                                                                            typeNoExpectedType)) {
                 noTypeInference = true;