From 23205c17c07e54bc6ed2a12227f28d13cacae6e9 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Fri, 25 Apr 2014 19:02:34 +0400 Subject: [PATCH] Utilities for analyzing expressions in given context introduced --- .../jetbrains/jet/analyzer/AnalyzerUtil.kt | 71 +++++++++++++++++++ .../expressions/ExpressionTypingServices.java | 6 +- .../plugin/project/ResolveElementCache.java | 12 ++-- .../KotlinIntroduceVariableHandler.java | 14 ++-- 4 files changed, 87 insertions(+), 16 deletions(-) create mode 100644 compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzerUtil.kt diff --git a/compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzerUtil.kt b/compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzerUtil.kt new file mode 100644 index 00000000000..338e166316a --- /dev/null +++ b/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())!! \ No newline at end of file diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingServices.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingServices.java index 042f6505484..6b4bb0d6602 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingServices.java +++ b/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 diff --git a/idea/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java b/idea/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java index 444e82691e1..d12766b4d64 100644 --- a/idea/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java +++ b/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() ); } } diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/introduce/introduceVariable/KotlinIntroduceVariableHandler.java b/idea/src/org/jetbrains/jet/plugin/refactoring/introduce/introduceVariable/KotlinIntroduceVariableHandler.java index dd5ccded192..f5f80eedefc 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/introduce/introduceVariable/KotlinIntroduceVariableHandler.java +++ b/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;