From 997fbb60a3217b4fc5043e67e81ff31b8220a0ba Mon Sep 17 00:00:00 2001 From: Stepan Koltsov Date: Sat, 10 Mar 2012 00:54:16 +0400 Subject: [PATCH] using guice to wire TopDownAnalyzer beans attempt 2 --- .idea/libraries/guice_3_0.xml | 13 + build.xml | 2 +- .../resolve/java/AnalyzerFacadeForJVM.java | 6 +- .../resolve/java/JavaBridgeConfiguration.java | 3 +- .../resolve/java/JavaDescriptorResolver.java | 9 +- .../resolve/java/JavaSemanticServices.java | 14 +- compiler/frontend/frontend.iml | 1 + .../jet/lang/JetSemanticServices.java | 66 ---- .../jet/lang/resolve/AnalyzingUtils.java | 12 +- .../jet/lang/resolve/AnnotationResolver.java | 54 ++-- .../jet/lang/resolve/BodyResolver.java | 151 ++++++--- .../jet/lang/resolve/ControlFlowAnalyzer.java | 12 +- .../jet/lang/resolve/DeclarationResolver.java | 80 +++-- .../jet/lang/resolve/DeclarationsChecker.java | 7 +- .../jet/lang/resolve/DelegationResolver.java | 10 +- .../jet/lang/resolve/DescriptorResolver.java | 299 +++++++++++------- .../jet/lang/resolve/ImportsResolver.java | 43 ++- .../jet/lang/resolve/OverloadResolver.java | 8 +- .../jet/lang/resolve/OverrideResolver.java | 9 +- .../lang/resolve/TopDownAnalysisContext.java | 88 ++++-- .../lang/resolve/TopDownAnalysisModule.java | 54 ++++ .../jet/lang/resolve/TopDownAnalyzer.java | 90 ++++-- .../lang/resolve/TypeHierarchyResolver.java | 52 ++- .../jet/lang/resolve/TypeResolver.java | 109 ++++--- .../jet/lang/resolve/calls/CallResolver.java | 122 ++++--- .../calls/OverloadingConflictResolver.java | 13 +- .../resolve/calls/autocasts/DataFlowInfo.java | 1 + .../CompileTimeConstantResolver.java | 25 +- .../BasicExpressionTypingVisitor.java | 44 +-- .../ClosureExpressionsTypingVisitor.java | 18 +- .../ControlStructureTypingVisitor.java | 38 +-- .../lang/types/expressions/DataFlowUtils.java | 2 +- .../expressions/ExpressionTypingContext.java | 80 ++--- .../expressions/ExpressionTypingServices.java | 122 ++++--- .../expressions/ExpressionTypingUtils.java | 27 +- .../ExpressionTypingVisitorForStatements.java | 12 +- .../PatternMatchingTypingVisitor.java | 26 +- .../lang/types/lang/JetStandardLibrary.java | 23 +- compiler/tests/compiler-tests.iml | 1 + .../jet/compiler/ReadJavaBinaryClassTest.java | 4 +- .../compiler/ReadKotlinBinaryClassTest.java | 4 +- .../jet/resolve/ExpectedResolveData.java | 4 +- .../jetbrains/jet/resolve/JetResolveTest.java | 14 +- .../JetDefaultModalityModifiersTest.java | 22 +- .../jetbrains/jet/types/JetOverloadTest.java | 17 +- .../jet/types/JetOverridingTest.java | 17 +- .../jet/types/JetTypeCheckerTest.java | 52 +-- idea/idea.iml | 1 + .../macro/BaseJetVariableMacro.java | 16 +- .../macro/JetAnyVariableMacro.java | 3 +- .../macro/JetIterableVariableMacro.java | 6 +- .../k2js/analyze/AnalyzerFacadeForJS.java | 6 +- lib/guice/aopalliance.jar | Bin 0 -> 4467 bytes lib/guice/guice-3.0-src.zip | Bin 0 -> 337553 bytes lib/guice/guice-3.0.jar | Bin 0 -> 710683 bytes lib/guice/javax.inject.jar | Bin 0 -> 2497 bytes 56 files changed, 1175 insertions(+), 737 deletions(-) create mode 100644 .idea/libraries/guice_3_0.xml delete mode 100644 compiler/frontend/src/org/jetbrains/jet/lang/JetSemanticServices.java create mode 100644 compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisModule.java create mode 100644 lib/guice/aopalliance.jar create mode 100644 lib/guice/guice-3.0-src.zip create mode 100644 lib/guice/guice-3.0.jar create mode 100644 lib/guice/javax.inject.jar diff --git a/.idea/libraries/guice_3_0.xml b/.idea/libraries/guice_3_0.xml new file mode 100644 index 00000000000..db65a2a44bd --- /dev/null +++ b/.idea/libraries/guice_3_0.xml @@ -0,0 +1,13 @@ + + + + + + + + + + + + + \ No newline at end of file diff --git a/build.xml b/build.xml index c1dde6bb3dc..8acbc9e970d 100644 --- a/build.xml +++ b/build.xml @@ -11,7 +11,7 @@ - + diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java index c21e617d445..8a0440aa127 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java @@ -28,7 +28,6 @@ import com.intellij.psi.util.CachedValuesManager; import com.intellij.psi.util.PsiModificationTracker; import com.intellij.util.Function; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.JetSemanticServices; import org.jetbrains.jet.lang.StandardConfiguration; import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils; @@ -141,15 +140,14 @@ public class AnalyzerFacadeForJVM { public static BindingContext analyzeFilesWithJavaIntegration(Project project, Collection files, Predicate filesToAnalyzeCompletely, JetControlFlowDataTraceFactory flowDataTraceFactory) { BindingTraceContext bindingTraceContext = new BindingTraceContext(); - JetSemanticServices semanticServices = JetSemanticServices.createSemanticServices(project); return AnalyzingUtils.analyzeFilesWithGivenTrace( project, JavaBridgeConfiguration.createJavaBridgeConfiguration(project, bindingTraceContext, StandardConfiguration.createStandardConfiguration(project)), files, filesToAnalyzeCompletely, flowDataTraceFactory, - bindingTraceContext, - semanticServices); + bindingTraceContext + ); } public static BindingContext shallowAnalyzeFiles(Collection files) { diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaBridgeConfiguration.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaBridgeConfiguration.java index 195f47a7bf9..41dee03f697 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaBridgeConfiguration.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaBridgeConfiguration.java @@ -19,7 +19,6 @@ package org.jetbrains.jet.lang.resolve.java; import com.intellij.openapi.project.Project; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.Configuration; -import org.jetbrains.jet.lang.JetSemanticServices; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.psi.JetImportDirective; @@ -48,7 +47,7 @@ public class JavaBridgeConfiguration implements Configuration { private JavaBridgeConfiguration(Project project, BindingTrace trace, Configuration delegateConfiguration) { this.project = project; - this.javaSemanticServices = new JavaSemanticServices(project, JetSemanticServices.createSemanticServices(project), trace); + this.javaSemanticServices = new JavaSemanticServices(project, trace); this.delegateConfiguration = delegateConfiguration; } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java index 3400964075b..d662150e11f 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java @@ -40,6 +40,7 @@ import org.jetbrains.jet.lang.resolve.java.alt.AltClassFinder; import org.jetbrains.jet.lang.resolve.java.kt.JetClassAnnotation; import org.jetbrains.jet.lang.types.*; import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import org.jetbrains.jet.plugin.JetFileType; import org.jetbrains.jet.rt.signature.JetSignatureAdapter; import org.jetbrains.jet.rt.signature.JetSignatureExceptionsAdapter; @@ -542,7 +543,7 @@ public class JavaDescriptorResolver { @Override public JetSignatureVisitor visitClassBound() { - return new JetTypeJetSignatureReader(semanticServices, semanticServices.getJetSemanticServices().getStandardLibrary(), typeVariableResolver) { + return new JetTypeJetSignatureReader(semanticServices, JetStandardLibrary.getInstance(), typeVariableResolver) { @Override protected void done(@NotNull JetType jetType) { if (isJavaLangObject(jetType)) { @@ -555,7 +556,7 @@ public class JavaDescriptorResolver { @Override public JetSignatureVisitor visitInterfaceBound() { - return new JetTypeJetSignatureReader(semanticServices, semanticServices.getJetSemanticServices().getStandardLibrary(), typeVariableResolver) { + return new JetTypeJetSignatureReader(semanticServices, JetStandardLibrary.getInstance(), typeVariableResolver) { @Override protected void done(@NotNull JetType jetType) { upperBounds.add(jetType); @@ -739,7 +740,7 @@ public class JavaDescriptorResolver { @Override public JetSignatureVisitor visitSuperclass() { - return new JetTypeJetSignatureReader(semanticServices, semanticServices.getJetSemanticServices().getStandardLibrary(), typeVariableResolver) { + return new JetTypeJetSignatureReader(semanticServices, JetStandardLibrary.getInstance(), typeVariableResolver) { @Override protected void done(@NotNull JetType jetType) { if (!jetType.equals(JetStandardClasses.getAnyType())) { @@ -971,7 +972,7 @@ public class JavaDescriptorResolver { JetType varargElementType; if (psiType instanceof PsiEllipsisType) { - varargElementType = semanticServices.getJetSemanticServices().getStandardLibrary().getArrayElementType(outType); + varargElementType = JetStandardLibrary.getInstance().getArrayElementType(outType); } else { varargElementType = null; } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaSemanticServices.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaSemanticServices.java index 7cde6588428..9fa00bcb29c 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaSemanticServices.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaSemanticServices.java @@ -19,11 +19,11 @@ package org.jetbrains.jet.lang.resolve.java; import com.intellij.openapi.project.Project; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.JetSemanticServices; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingTrace; +import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; /** * @author abreslav @@ -32,13 +32,11 @@ public class JavaSemanticServices { private final JavaTypeTransformer typeTransformer; private final JavaDescriptorResolver descriptorResolver; private final BindingTrace trace; - private final JetSemanticServices jetSemanticServices; - public JavaSemanticServices(Project project, JetSemanticServices jetSemanticServices, BindingTrace trace) { + public JavaSemanticServices(Project project, BindingTrace trace) { this.trace = trace; this.descriptorResolver = new JavaDescriptorResolver(project, this); - this.typeTransformer = new JavaTypeTransformer(this, jetSemanticServices.getStandardLibrary(), descriptorResolver); - this.jetSemanticServices = jetSemanticServices; + this.typeTransformer = new JavaTypeTransformer(this, JetStandardLibrary.getInstance(), descriptorResolver); } @NotNull @@ -56,14 +54,10 @@ public class JavaSemanticServices { return trace; } - public JetSemanticServices getJetSemanticServices() { - return jetSemanticServices; - } - @Nullable public ClassDescriptor getKotlinClassDescriptor(String qualifiedName) { if (qualifiedName.startsWith("jet.")) { - ClassDescriptor r = (ClassDescriptor) jetSemanticServices.getStandardLibrary().getLibraryScope().getClassifier(qualifiedName.substring("jet.".length())); + ClassDescriptor r = (ClassDescriptor) JetStandardLibrary.getInstance().getLibraryScope().getClassifier(qualifiedName.substring("jet.".length())); if (r == null) { // TODO: better error //throw new IllegalStateException(); diff --git a/compiler/frontend/frontend.iml b/compiler/frontend/frontend.iml index d0a04b011b4..101a5d558b7 100644 --- a/compiler/frontend/frontend.iml +++ b/compiler/frontend/frontend.iml @@ -8,6 +8,7 @@ + diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/JetSemanticServices.java b/compiler/frontend/src/org/jetbrains/jet/lang/JetSemanticServices.java deleted file mode 100644 index bff8b75cf3e..00000000000 --- a/compiler/frontend/src/org/jetbrains/jet/lang/JetSemanticServices.java +++ /dev/null @@ -1,66 +0,0 @@ -/* - * Copyright 2010-2012 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; - -import com.intellij.openapi.project.Project; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.resolve.BindingTrace; -import org.jetbrains.jet.lang.resolve.DescriptorResolver; -import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; -import org.jetbrains.jet.lang.types.checker.JetTypeChecker; -import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; - -/** - * @author abreslav - */ -public class JetSemanticServices { - public static JetSemanticServices createSemanticServices(JetStandardLibrary standardLibrary) { - return new JetSemanticServices(standardLibrary); - } - - public static JetSemanticServices createSemanticServices(Project project) { - return new JetSemanticServices(JetStandardLibrary.getInstance()); - } - - private final JetStandardLibrary standardLibrary; - private final JetTypeChecker typeChecker; - - private JetSemanticServices(JetStandardLibrary standardLibrary) { - this.standardLibrary = standardLibrary; - this.typeChecker = JetTypeChecker.INSTANCE; - } - - @NotNull - public JetStandardLibrary getStandardLibrary() { - return standardLibrary; - } - - @NotNull - public DescriptorResolver getClassDescriptorResolver(BindingTrace trace) { - return new DescriptorResolver(this, trace); - } - - @NotNull - public ExpressionTypingServices getTypeInferrerServices(@NotNull BindingTrace trace) { - return new ExpressionTypingServices(this, trace); - } - - @NotNull - public JetTypeChecker getTypeChecker() { - return typeChecker; - } -} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnalyzingUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnalyzingUtils.java index a049a54be9e..274e2381f9e 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnalyzingUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnalyzingUtils.java @@ -25,7 +25,6 @@ import com.intellij.psi.PsiErrorElement; import com.intellij.psi.PsiFile; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.Configuration; -import org.jetbrains.jet.lang.JetSemanticServices; import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.diagnostics.Diagnostic; @@ -35,6 +34,7 @@ import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl; +import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import java.util.ArrayList; import java.util.Collection; @@ -91,8 +91,7 @@ public class AnalyzingUtils { @NotNull Predicate filesToAnalyzeCompletely, @NotNull JetControlFlowDataTraceFactory flowDataTraceFactory) { BindingTraceContext bindingTraceContext = new BindingTraceContext(); - JetSemanticServices semanticServices = JetSemanticServices.createSemanticServices(project); - return analyzeFilesWithGivenTrace(project, configuration, files, filesToAnalyzeCompletely, flowDataTraceFactory, bindingTraceContext, semanticServices); + return analyzeFilesWithGivenTrace(project, configuration, files, filesToAnalyzeCompletely, flowDataTraceFactory, bindingTraceContext); } public static BindingContext analyzeFilesWithGivenTrace( @@ -101,10 +100,9 @@ public class AnalyzingUtils { @NotNull Collection files, @NotNull Predicate filesToAnalyzeCompletely, @NotNull JetControlFlowDataTraceFactory flowDataTraceFactory, - @NotNull BindingTraceContext bindingTraceContext, - @NotNull JetSemanticServices semanticServices) { + @NotNull BindingTraceContext bindingTraceContext) { - JetScope libraryScope = semanticServices.getStandardLibrary().getLibraryScope(); + JetScope libraryScope = JetStandardLibrary.getInstance().getLibraryScope(); ModuleDescriptor owner = new ModuleDescriptor(""); final WritableScope scope = new WritableScopeImpl( @@ -114,7 +112,7 @@ public class AnalyzingUtils { scope.importScope(libraryScope); scope.changeLockLevel(WritableScope.LockLevel.BOTH); - TopDownAnalyzer.process(semanticServices, bindingTraceContext, scope, new NamespaceLike.Adapter(owner) { + TopDownAnalyzer.process(project, bindingTraceContext, scope, new NamespaceLike.Adapter(owner) { private Map declaredNamespaces = Maps.newHashMap(); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java index c0c6351fc31..32252e33747 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java @@ -19,7 +19,6 @@ package org.jetbrains.jet.lang.resolve; import com.google.common.collect.Lists; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.JetSemanticServices; import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; @@ -36,6 +35,7 @@ import org.jetbrains.jet.lang.types.ErrorUtils; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; +import javax.inject.Inject; import java.util.Collections; import java.util.List; import java.util.Map; @@ -47,47 +47,50 @@ import static org.jetbrains.jet.lang.types.TypeUtils.NO_EXPECTED_TYPE; */ public class AnnotationResolver { - private final BindingTrace trace; - private final JetSemanticServices semanticServices; - private final CallResolver callResolver; + private ExpressionTypingServices expressionTypingServices; + private CallResolver callResolver; - public AnnotationResolver(JetSemanticServices semanticServices, BindingTrace trace) { - this.trace = trace; - this.callResolver = new CallResolver(semanticServices, DataFlowInfo.EMPTY); - this.semanticServices = semanticServices; + @Inject + public void setExpressionTypingServices(ExpressionTypingServices expressionTypingServices) { + this.expressionTypingServices = expressionTypingServices; + } + + @Inject + public void setCallResolver(CallResolver callResolver) { + this.callResolver = callResolver; } @NotNull - public List resolveAnnotations(@NotNull JetScope scope, @Nullable JetModifierList modifierList) { + public List resolveAnnotations(@NotNull JetScope scope, @Nullable JetModifierList modifierList, BindingTrace trace) { if (modifierList == null) { return Collections.emptyList(); } - return resolveAnnotations(scope, modifierList.getAnnotationEntries()); + return resolveAnnotations(scope, modifierList.getAnnotationEntries(), trace); } @NotNull - public List resolveAnnotations(@NotNull JetScope scope, @NotNull List annotationEntryElements) { + public List resolveAnnotations(@NotNull JetScope scope, @NotNull List annotationEntryElements, BindingTrace trace) { if (annotationEntryElements.isEmpty()) return Collections.emptyList(); List result = Lists.newArrayList(); for (JetAnnotationEntry entryElement : annotationEntryElements) { AnnotationDescriptor descriptor = new AnnotationDescriptor(); - resolveAnnotationStub(scope, entryElement, descriptor); + resolveAnnotationStub(scope, entryElement, descriptor, trace); result.add(descriptor); } return result; } public void resolveAnnotationStub(@NotNull JetScope scope, @NotNull JetAnnotationEntry entryElement, - @NotNull AnnotationDescriptor descriptor) { - OverloadResolutionResults results = resolveType(scope, entryElement, descriptor); - resolveArguments(results, descriptor); + @NotNull AnnotationDescriptor descriptor, BindingTrace trace) { + OverloadResolutionResults results = resolveType(scope, entryElement, descriptor, trace); + resolveArguments(results, descriptor, trace); } @NotNull private OverloadResolutionResults resolveType(@NotNull JetScope scope, - @NotNull JetAnnotationEntry entryElement, - @NotNull AnnotationDescriptor descriptor) { - OverloadResolutionResults results = callResolver.resolveCall(trace, scope, CallMaker.makeCall(ReceiverDescriptor.NO_RECEIVER, null, entryElement), NO_EXPECTED_TYPE); + @NotNull JetAnnotationEntry entryElement, + @NotNull AnnotationDescriptor descriptor, BindingTrace trace) { + OverloadResolutionResults results = callResolver.resolveCall(trace, scope, CallMaker.makeCall(ReceiverDescriptor.NO_RECEIVER, null, entryElement), NO_EXPECTED_TYPE, DataFlowInfo.EMPTY); JetType annotationType = results.getResultingDescriptor().getReturnType(); if (results.isSuccess()) { descriptor.setAnnotationType(annotationType); @@ -98,7 +101,7 @@ public class AnnotationResolver { } private void resolveArguments(@NotNull OverloadResolutionResults results, - @NotNull AnnotationDescriptor descriptor) { + @NotNull AnnotationDescriptor descriptor, BindingTrace trace) { List> arguments = Lists.newArrayList(); for (Map.Entry descriptorToArgument : results.getResultingCall().getValueArguments().entrySet()) { @@ -106,19 +109,18 @@ public class AnnotationResolver { List argumentExpressions = descriptorToArgument.getValue().getArgumentExpressions(); ValueParameterDescriptor parameterDescriptor = descriptorToArgument.getKey(); for (JetExpression argument : argumentExpressions) { - arguments.add(resolveAnnotationArgument(argument, parameterDescriptor.getType())); + arguments.add(resolveAnnotationArgument(argument, parameterDescriptor.getType(), trace)); } } descriptor.setValueArguments(arguments); } @Nullable - public CompileTimeConstant resolveAnnotationArgument(@NotNull JetExpression expression, @NotNull final JetType expectedType) { + public CompileTimeConstant resolveAnnotationArgument(@NotNull JetExpression expression, @NotNull final JetType expectedType, final BindingTrace trace) { JetVisitor, Void> visitor = new JetVisitor, Void>() { @Override public CompileTimeConstant visitConstantExpression(JetConstantExpression expression, Void nothing) { - ExpressionTypingServices typeInferrerServices = semanticServices.getTypeInferrerServices(trace); - JetType type = typeInferrerServices.getType(JetScope.EMPTY, expression, expectedType, DataFlowInfo.EMPTY); + JetType type = expressionTypingServices.getType(JetScope.EMPTY, expression, expectedType, DataFlowInfo.EMPTY, trace); if (type == null) { // TODO: // trace.report(ANNOTATION_PARAMETER_SHOULD_BE_CONSTANT.on(expression)); @@ -161,15 +163,15 @@ public class AnnotationResolver { } @NotNull - public List createAnnotationStubs(@Nullable JetModifierList modifierList) { + public List createAnnotationStubs(@Nullable JetModifierList modifierList, BindingTrace trace) { if (modifierList == null) { return Collections.emptyList(); } - return createAnnotationStubs(modifierList.getAnnotationEntries()); + return createAnnotationStubs(modifierList.getAnnotationEntries(), trace); } @NotNull - public List createAnnotationStubs(List annotations) { + public List createAnnotationStubs(List annotations, BindingTrace trace) { List result = Lists.newArrayList(); for (JetAnnotationEntry annotation : annotations) { AnnotationDescriptor annotationDescriptor = new AnnotationDescriptor(); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java index 29c04516317..a4f9d2d8f37 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java @@ -18,11 +18,45 @@ package org.jetbrains.jet.lang.resolve; import com.google.common.collect.Maps; import com.google.common.collect.Sets; +import com.google.inject.Inject; import com.intellij.psi.PsiElement; import com.intellij.util.containers.Queue; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.descriptors.*; -import org.jetbrains.jet.lang.psi.*; +import org.jetbrains.jet.lang.descriptors.ClassDescriptor; +import org.jetbrains.jet.lang.descriptors.ClassKind; +import org.jetbrains.jet.lang.descriptors.ConstructorDescriptor; +import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; +import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; +import org.jetbrains.jet.lang.descriptors.FunctionDescriptorUtil; +import org.jetbrains.jet.lang.descriptors.MutableClassDescriptor; +import org.jetbrains.jet.lang.descriptors.PropertyDescriptor; +import org.jetbrains.jet.lang.descriptors.PropertyGetterDescriptor; +import org.jetbrains.jet.lang.descriptors.PropertySetterDescriptor; +import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor; +import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; +import org.jetbrains.jet.lang.psi.JetClass; +import org.jetbrains.jet.lang.psi.JetClassInitializer; +import org.jetbrains.jet.lang.psi.JetClassOrObject; +import org.jetbrains.jet.lang.psi.JetDeclarationWithBody; +import org.jetbrains.jet.lang.psi.JetDelegationSpecifier; +import org.jetbrains.jet.lang.psi.JetDelegatorByExpressionSpecifier; +import org.jetbrains.jet.lang.psi.JetDelegatorToSuperCall; +import org.jetbrains.jet.lang.psi.JetDelegatorToSuperClass; +import org.jetbrains.jet.lang.psi.JetDelegatorToThisCall; +import org.jetbrains.jet.lang.psi.JetElement; +import org.jetbrains.jet.lang.psi.JetEnumEntry; +import org.jetbrains.jet.lang.psi.JetExpression; +import org.jetbrains.jet.lang.psi.JetNamedFunction; +import org.jetbrains.jet.lang.psi.JetObjectDeclaration; +import org.jetbrains.jet.lang.psi.JetParameter; +import org.jetbrains.jet.lang.psi.JetProperty; +import org.jetbrains.jet.lang.psi.JetPropertyAccessor; +import org.jetbrains.jet.lang.psi.JetReferenceExpression; +import org.jetbrains.jet.lang.psi.JetSecondaryConstructor; +import org.jetbrains.jet.lang.psi.JetSimpleNameExpression; +import org.jetbrains.jet.lang.psi.JetTypeReference; +import org.jetbrains.jet.lang.psi.JetValueArgumentList; +import org.jetbrains.jet.lang.psi.JetVisitorVoid; import org.jetbrains.jet.lang.resolve.calls.CallMaker; import org.jetbrains.jet.lang.resolve.calls.CallResolver; import org.jetbrains.jet.lang.resolve.calls.OverloadResolutionResults; @@ -31,7 +65,12 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; -import org.jetbrains.jet.lang.types.*; +import org.jetbrains.jet.lang.types.DeferredType; +import org.jetbrains.jet.lang.types.ErrorUtils; +import org.jetbrains.jet.lang.types.JetType; +import org.jetbrains.jet.lang.types.TypeConstructor; +import org.jetbrains.jet.lang.types.TypeUtils; +import org.jetbrains.jet.lang.types.checker.JetTypeChecker; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; import org.jetbrains.jet.lang.types.lang.JetStandardClasses; import org.jetbrains.jet.lexer.JetTokens; @@ -39,9 +78,29 @@ import org.jetbrains.jet.util.Box; import org.jetbrains.jet.util.lazy.ReenteringLazyValueComputationException; import org.jetbrains.jet.util.slicedmap.WritableSlice; -import java.util.*; +import java.util.Collection; +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.Set; -import static org.jetbrains.jet.lang.diagnostics.Errors.*; +import static org.jetbrains.jet.lang.diagnostics.Errors.ANONYMOUS_INITIALIZER_WITHOUT_CONSTRUCTOR; +import static org.jetbrains.jet.lang.diagnostics.Errors.BY_IN_SECONDARY_CONSTRUCTOR; +import static org.jetbrains.jet.lang.diagnostics.Errors.CONSTRUCTOR_IN_TRAIT; +import static org.jetbrains.jet.lang.diagnostics.Errors.DELEGATION_IN_TRAIT; +import static org.jetbrains.jet.lang.diagnostics.Errors.DELEGATION_NOT_TO_TRAIT; +import static org.jetbrains.jet.lang.diagnostics.Errors.FINAL_SUPERTYPE; +import static org.jetbrains.jet.lang.diagnostics.Errors.INITIALIZER_WITH_NO_ARGUMENTS; +import static org.jetbrains.jet.lang.diagnostics.Errors.MANY_CALLS_TO_THIS; +import static org.jetbrains.jet.lang.diagnostics.Errors.MANY_CLASSES_IN_SUPERTYPE_LIST; +import static org.jetbrains.jet.lang.diagnostics.Errors.SECONDARY_CONSTRUCTOR_BUT_NO_PRIMARY; +import static org.jetbrains.jet.lang.diagnostics.Errors.SECONDARY_CONSTRUCTOR_NO_INITIALIZER_LIST; +import static org.jetbrains.jet.lang.diagnostics.Errors.SUPERTYPE_APPEARS_TWICE; +import static org.jetbrains.jet.lang.diagnostics.Errors.SUPERTYPE_INITIALIZED_IN_TRAIT; +import static org.jetbrains.jet.lang.diagnostics.Errors.SUPERTYPE_NOT_A_CLASS_OR_TRAIT; +import static org.jetbrains.jet.lang.diagnostics.Errors.SUPERTYPE_NOT_INITIALIZED; +import static org.jetbrains.jet.lang.diagnostics.Errors.SUPERTYPE_NOT_INITIALIZED_DEFAULT; +import static org.jetbrains.jet.lang.diagnostics.Errors.TYPE_MISMATCH; import static org.jetbrains.jet.lang.resolve.BindingContext.DEFERRED_TYPE; import static org.jetbrains.jet.lang.types.TypeUtils.NO_EXPECTED_TYPE; @@ -49,15 +108,39 @@ import static org.jetbrains.jet.lang.types.TypeUtils.NO_EXPECTED_TYPE; * @author abreslav */ public class BodyResolver { - private final TopDownAnalysisContext context; + @NotNull + private TopDownAnalysisContext context; + @NotNull + private DescriptorResolver descriptorResolver; + @NotNull + private ExpressionTypingServices expressionTypingServices; + @NotNull + private CallResolver callResolver; - private final ObservableBindingTrace trace; - public BodyResolver(TopDownAnalysisContext context) { + @Inject + public void setContext(@NotNull TopDownAnalysisContext context) { this.context = context; - this.trace = context.getTrace(); } + @Inject + public void setDescriptorResolver(@NotNull DescriptorResolver descriptorResolver) { + this.descriptorResolver = descriptorResolver; + } + + @Inject + public void setExpressionTypingServices(@NotNull ExpressionTypingServices expressionTypingServices) { + this.expressionTypingServices = expressionTypingServices; + } + + @Inject + public void setCallResolver(@NotNull CallResolver callResolver) { + this.callResolver = callResolver; + } + + + + public void resolveBehaviorDeclarationBodies() { resolveDelegationSpecifierLists(); @@ -74,7 +157,7 @@ public class BodyResolver { computeDeferredTypes(); } } - + private void resolveDelegationSpecifierLists() { // TODO : Make sure the same thing is not initialized twice for (Map.Entry entry : context.getClasses().entrySet()) { @@ -90,8 +173,8 @@ public class BodyResolver { final ConstructorDescriptor primaryConstructor = descriptor.getUnsubstitutedPrimaryConstructor(); final JetScope scopeForConstructor = primaryConstructor == null ? null - : FunctionDescriptorUtil.getFunctionInnerScope(descriptor.getScopeForSupertypeResolution(), primaryConstructor, trace); - final ExpressionTypingServices typeInferrer = context.getSemanticServices().getTypeInferrerServices(trace); // TODO : flow + : FunctionDescriptorUtil.getFunctionInnerScope(descriptor.getScopeForSupertypeResolution(), primaryConstructor, context.getTrace()); + final ExpressionTypingServices typeInferrer = expressionTypingServices; // TODO : flow final Map supertypes = Maps.newLinkedHashMap(); JetVisitorVoid visitor = new JetVisitorVoid() { @@ -121,8 +204,8 @@ public class BodyResolver { JetScope scope = scopeForConstructor == null ? descriptor.getScopeForMemberResolution() : scopeForConstructor; - JetType type = typeInferrer.getType(scope, delegateExpression, NO_EXPECTED_TYPE); - if (type != null && supertype != null && !context.getSemanticServices().getTypeChecker().isSubtypeOf(type, supertype)) { + JetType type = typeInferrer.getType(scope, delegateExpression, NO_EXPECTED_TYPE, context.getTrace()); + if (type != null && supertype != null && !JetTypeChecker.INSTANCE.isSubtypeOf(type, supertype)) { context.getTrace().report(TYPE_MISMATCH.on(delegateExpression, supertype, type)); } } @@ -141,9 +224,9 @@ public class BodyResolver { assert descriptor.getKind() == ClassKind.TRAIT; return; } - OverloadResolutionResults results = new CallResolver(context.getSemanticServices(), DataFlowInfo.EMPTY).resolveCall( + OverloadResolutionResults results = callResolver.resolveCall( context.getTrace(), scopeForConstructor, - CallMaker.makeCall(ReceiverDescriptor.NO_RECEIVER, null, call), NO_EXPECTED_TYPE); + CallMaker.makeCall(ReceiverDescriptor.NO_RECEIVER, null, call), NO_EXPECTED_TYPE, DataFlowInfo.EMPTY); if (results.isSuccess()) { JetType supertype = results.getResultingDescriptor().getReturnType(); recordSupertype(typeReference, supertype); @@ -261,9 +344,8 @@ public class BodyResolver { ConstructorDescriptor primaryConstructor = classDescriptor.getUnsubstitutedPrimaryConstructor(); assert primaryConstructor != null; final JetScope scopeForInitializers = classDescriptor.getScopeForInitializers(); - ExpressionTypingServices typeInferrer = context.getSemanticServices().getTypeInferrerServices(trace); for (JetClassInitializer anonymousInitializer : anonymousInitializers) { - typeInferrer.getType(scopeForInitializers, anonymousInitializer.getBody(), NO_EXPECTED_TYPE); + expressionTypingServices.getType(scopeForInitializers, anonymousInitializer.getBody(), NO_EXPECTED_TYPE, context.getTrace()); } } else { @@ -298,12 +380,12 @@ public class BodyResolver { private void resolveSecondaryConstructorBody(JetSecondaryConstructor declaration, final ConstructorDescriptor descriptor) { if (!context.completeAnalysisNeeded(declaration)) return; MutableClassDescriptor classDescriptor = (MutableClassDescriptor) descriptor.getContainingDeclaration(); - final JetScope scopeForSupertypeInitializers = FunctionDescriptorUtil.getFunctionInnerScope(classDescriptor.getScopeForSupertypeResolution(), descriptor, trace); + final JetScope scopeForSupertypeInitializers = FunctionDescriptorUtil.getFunctionInnerScope(classDescriptor.getScopeForSupertypeResolution(), descriptor, context.getTrace()); //contains only constructor parameters - final JetScope scopeForConstructorBody = FunctionDescriptorUtil.getFunctionInnerScope(classDescriptor.getScopeForInitializers(), descriptor, trace); + final JetScope scopeForConstructorBody = FunctionDescriptorUtil.getFunctionInnerScope(classDescriptor.getScopeForInitializers(), descriptor, context.getTrace()); //contains members & backing fields - final CallResolver callResolver = new CallResolver(context.getSemanticServices(), DataFlowInfo.EMPTY); // TODO: dataFlowInfo + final DataFlowInfo dataFlowInfo = DataFlowInfo.EMPTY; // TODO: dataFlowInfo PsiElement nameElement = declaration.getNameNode().getPsi(); if (classDescriptor.getUnsubstitutedPrimaryConstructor() == null) { @@ -320,7 +402,7 @@ public class BodyResolver { public void visitDelegationToSuperCallSpecifier(JetDelegatorToSuperCall call) { JetTypeReference typeReference = call.getTypeReference(); if (typeReference != null) { - callResolver.resolveCall(context.getTrace(), scopeForSupertypeInitializers, CallMaker.makeCall(ReceiverDescriptor.NO_RECEIVER, null, call), NO_EXPECTED_TYPE); + callResolver.resolveCall(context.getTrace(), scopeForSupertypeInitializers, CallMaker.makeCall(ReceiverDescriptor.NO_RECEIVER, null, call), NO_EXPECTED_TYPE, dataFlowInfo); } } @@ -332,7 +414,7 @@ public class BodyResolver { callResolver.resolveCall(context.getTrace(), scopeForSupertypeInitializers, - CallMaker.makeCall(ReceiverDescriptor.NO_RECEIVER, null, call), NO_EXPECTED_TYPE); + CallMaker.makeCall(ReceiverDescriptor.NO_RECEIVER, null, call), NO_EXPECTED_TYPE, dataFlowInfo); // call.getThisReference(), // classDescriptor, // classDescriptor.getDefaultType(), @@ -363,9 +445,8 @@ public class BodyResolver { } JetExpression bodyExpression = declaration.getBodyExpression(); if (bodyExpression != null) { - ExpressionTypingServices typeInferrer = context.getSemanticServices().getTypeInferrerServices(trace); - typeInferrer.checkFunctionReturnType(scopeForConstructorBody, declaration, descriptor, JetStandardClasses.getUnitType()); + expressionTypingServices.checkFunctionReturnType(scopeForConstructorBody, declaration, descriptor, JetStandardClasses.getUnitType(), context.getTrace()); } checkDefaultParameterValues(declaration.getValueParameters(), descriptor.getValueParameters(), scopeForConstructorBody); @@ -424,8 +505,8 @@ public class BodyResolver { private JetScope makeScopeForPropertyAccessor(@NotNull JetPropertyAccessor accessor, PropertyDescriptor propertyDescriptor) { JetScope declaringScope = context.getDeclaringScopes().get(accessor); - JetScope propertyDeclarationInnerScope = context.getDescriptorResolver().getPropertyDeclarationInnerScope( - declaringScope, propertyDescriptor, propertyDescriptor.getTypeParameters(), propertyDescriptor.getReceiverParameter()); + JetScope propertyDeclarationInnerScope = descriptorResolver.getPropertyDeclarationInnerScope( + declaringScope, propertyDescriptor, propertyDescriptor.getTypeParameters(), propertyDescriptor.getReceiverParameter(), context.getTrace()); WritableScope accessorScope = new WritableScopeImpl(propertyDeclarationInnerScope, declaringScope.getContainingDeclaration(), new TraceBasedRedeclarationHandler(context.getTrace())).setDebugName("Accessor scope"); accessorScope.changeLockLevel(WritableScope.LockLevel.READING); @@ -451,7 +532,7 @@ public class BodyResolver { } private ObservableBindingTrace createFieldTrackingTrace(final PropertyDescriptor propertyDescriptor) { - return new ObservableBindingTrace(trace).addHandler(BindingContext.REFERENCE_TARGET, new ObservableBindingTrace.RecordHandler() { + return new ObservableBindingTrace(context.getTrace()).addHandler(BindingContext.REFERENCE_TARGET, new ObservableBindingTrace.RecordHandler() { @Override public void handleRecord(WritableSlice slice, JetReferenceExpression expression, DeclarationDescriptor descriptor) { if (expression instanceof JetSimpleNameExpression) { @@ -459,7 +540,7 @@ public class BodyResolver { if (simpleNameExpression.getReferencedNameElementType() == JetTokens.FIELD_IDENTIFIER) { // This check may be considered redundant as long as $x is only accessible from accessors to $x if (descriptor == propertyDescriptor) { // TODO : original? - trace.record(BindingContext.BACKING_FIELD_REQUIRED, propertyDescriptor); // TODO: this context.getTrace()? + context.getTrace().record(BindingContext.BACKING_FIELD_REQUIRED, propertyDescriptor); // TODO: this context.getTrace()? } } } @@ -469,9 +550,8 @@ public class BodyResolver { private void resolvePropertyInitializer(JetProperty property, PropertyDescriptor propertyDescriptor, JetExpression initializer, JetScope scope) { //JetFlowInformationProvider flowInformationProvider = context.getDescriptorResolver().computeFlowData(property, initializer); // TODO : flow JET-15 - ExpressionTypingServices typeInferrer = context.getSemanticServices().getTypeInferrerServices(trace); JetType expectedTypeForInitializer = property.getPropertyTypeRef() != null ? propertyDescriptor.getType() : NO_EXPECTED_TYPE; - JetType type = typeInferrer.getType(context.getDescriptorResolver().getPropertyDeclarationInnerScope(scope, propertyDescriptor, propertyDescriptor.getTypeParameters(), propertyDescriptor.getReceiverParameter()), initializer, expectedTypeForInitializer); + JetType type = expressionTypingServices.getType(descriptorResolver.getPropertyDeclarationInnerScope(scope, propertyDescriptor, propertyDescriptor.getTypeParameters(), propertyDescriptor.getReceiverParameter(), context.getTrace()), initializer, expectedTypeForInitializer, context.getTrace()); // // JetType expectedType = propertyDescriptor.getInType(); // if (expectedType == null) { @@ -493,7 +573,7 @@ public class BodyResolver { JetScope declaringScope = this.context.getDeclaringScopes().get(declaration); assert declaringScope != null; - resolveFunctionBody(trace, declaration, descriptor, declaringScope); + resolveFunctionBody(context.getTrace(), declaration, descriptor, declaringScope); assert descriptor.getReturnType() != null; } @@ -509,9 +589,7 @@ public class BodyResolver { JetExpression bodyExpression = function.getBodyExpression(); JetScope functionInnerScope = FunctionDescriptorUtil.getFunctionInnerScope(declaringScope, functionDescriptor, trace); if (bodyExpression != null) { - ExpressionTypingServices typeInferrer = context.getSemanticServices().getTypeInferrerServices(trace); - - typeInferrer.checkFunctionReturnType(functionInnerScope, function, functionDescriptor); + expressionTypingServices.checkFunctionReturnType(functionInnerScope, function, functionDescriptor, trace); } List valueParameters = function.getValueParameters(); @@ -523,14 +601,13 @@ public class BodyResolver { } private void checkDefaultParameterValues(List valueParameters, List valueParameterDescriptors, JetScope declaringScope) { - ExpressionTypingServices typeInferrer = context.getSemanticServices().getTypeInferrerServices(trace); for (int i = 0; i < valueParameters.size(); i++) { ValueParameterDescriptor valueParameterDescriptor = valueParameterDescriptors.get(i); if (valueParameterDescriptor.hasDefaultValue()) { JetParameter jetParameter = valueParameters.get(i); JetExpression defaultValue = jetParameter.getDefaultValue(); if (defaultValue != null) { - typeInferrer.getType(declaringScope, defaultValue, valueParameterDescriptor.getType()); + expressionTypingServices.getType(declaringScope, defaultValue, valueParameterDescriptor.getType(), context.getTrace()); } } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ControlFlowAnalyzer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ControlFlowAnalyzer.java index 0fc81a68092..26734c16bef 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ControlFlowAnalyzer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ControlFlowAnalyzer.java @@ -16,6 +16,7 @@ package org.jetbrains.jet.lang.resolve; +import com.google.inject.Inject; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.cfg.JetFlowInformationProvider; import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; @@ -35,13 +36,20 @@ import static org.jetbrains.jet.lang.types.TypeUtils.NO_EXPECTED_TYPE; */ public class ControlFlowAnalyzer { private TopDownAnalysisContext context; - private final JetControlFlowDataTraceFactory flowDataTraceFactory; + private JetControlFlowDataTraceFactory flowDataTraceFactory; - public ControlFlowAnalyzer(TopDownAnalysisContext context, JetControlFlowDataTraceFactory flowDataTraceFactory) { + + @Inject + public void setContext(TopDownAnalysisContext context) { this.context = context; + } + + @Inject + public void setFlowDataTraceFactory(JetControlFlowDataTraceFactory flowDataTraceFactory) { this.flowDataTraceFactory = flowDataTraceFactory; } + public void process() { for (JetClass aClass : context.getClasses().keySet()) { if (!context.completeAnalysisNeeded(aClass)) continue; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java index 60e4d0e31a7..bc9dd996319 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java @@ -16,9 +16,28 @@ package org.jetbrains.jet.lang.resolve; +import com.google.inject.Inject; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.descriptors.*; -import org.jetbrains.jet.lang.psi.*; +import org.jetbrains.jet.lang.descriptors.ClassKind; +import org.jetbrains.jet.lang.descriptors.ConstructorDescriptor; +import org.jetbrains.jet.lang.descriptors.MutableClassDescriptor; +import org.jetbrains.jet.lang.descriptors.MutableClassDescriptorLite; +import org.jetbrains.jet.lang.descriptors.NamespaceLike; +import org.jetbrains.jet.lang.descriptors.PropertyDescriptor; +import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor; +import org.jetbrains.jet.lang.psi.JetClass; +import org.jetbrains.jet.lang.psi.JetClassOrObject; +import org.jetbrains.jet.lang.psi.JetDeclaration; +import org.jetbrains.jet.lang.psi.JetEnumEntry; +import org.jetbrains.jet.lang.psi.JetFile; +import org.jetbrains.jet.lang.psi.JetModifierList; +import org.jetbrains.jet.lang.psi.JetNamedFunction; +import org.jetbrains.jet.lang.psi.JetObjectDeclaration; +import org.jetbrains.jet.lang.psi.JetParameter; +import org.jetbrains.jet.lang.psi.JetParameterList; +import org.jetbrains.jet.lang.psi.JetProperty; +import org.jetbrains.jet.lang.psi.JetSecondaryConstructor; +import org.jetbrains.jet.lang.psi.JetVisitorVoid; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; @@ -31,19 +50,43 @@ import static org.jetbrains.jet.lang.diagnostics.Errors.CONSTRUCTOR_IN_TRAIT; * @author abreslav */ public class DeclarationResolver { - private final AnnotationResolver annotationResolver; - private final TopDownAnalysisContext context; + @NotNull + private AnnotationResolver annotationResolver; + @NotNull + private TopDownAnalysisContext context; + @NotNull + private ImportsResolver importsResolver; + @NotNull + private DescriptorResolver descriptorResolver; - public DeclarationResolver(TopDownAnalysisContext context) { - this.context = context; - this.annotationResolver = new AnnotationResolver(context.getSemanticServices(), context.getTrace()); + + @Inject + public void setAnnotationResolver(@NotNull AnnotationResolver annotationResolver) { + this.annotationResolver = annotationResolver; } + @Inject + public void setContext(@NotNull TopDownAnalysisContext context) { + this.context = context; + } + + @Inject + public void setImportsResolver(@NotNull ImportsResolver importsResolver) { + this.importsResolver = importsResolver; + } + + @Inject + public void setDescriptorResolver(@NotNull DescriptorResolver descriptorResolver) { + this.descriptorResolver = descriptorResolver; + } + + + public void process() { resolveConstructorHeaders(); resolveAnnotationStubsOnClassesAndConstructors(); resolveFunctionAndPropertyHeaders(); - context.getImportsResolver().processMembersImports(); + importsResolver.processMembersImports(); } private void resolveConstructorHeaders() { @@ -59,7 +102,6 @@ public class DeclarationResolver { } private void resolveAnnotationStubsOnClassesAndConstructors() { - AnnotationResolver annotationResolver = new AnnotationResolver(context.getSemanticServices(), context.getTrace()); for (Map.Entry entry : context.getClasses().entrySet()) { JetClass jetClass = entry.getKey(); MutableClassDescriptor descriptor = entry.getValue(); @@ -75,7 +117,7 @@ public class DeclarationResolver { private void resolveAnnotationsForClassOrObject(AnnotationResolver annotationResolver, JetClassOrObject jetClass, MutableClassDescriptor descriptor) { JetModifierList modifierList = jetClass.getModifierList(); if (modifierList != null) { - descriptor.getAnnotations().addAll(annotationResolver.resolveAnnotations(descriptor.getScopeForSupertypeResolution(), modifierList.getAnnotationEntries())); + descriptor.getAnnotations().addAll(annotationResolver.resolveAnnotations(descriptor.getScopeForSupertypeResolution(), modifierList.getAnnotationEntries(), context.getTrace())); } } @@ -120,7 +162,7 @@ public class DeclarationResolver { declaration.accept(new JetVisitorVoid() { @Override public void visitNamedFunction(JetNamedFunction function) { - SimpleFunctionDescriptor functionDescriptor = context.getDescriptorResolver().resolveFunctionDescriptor(namespaceLike, scopeForFunctions, function); + SimpleFunctionDescriptor functionDescriptor = descriptorResolver.resolveFunctionDescriptor(namespaceLike, scopeForFunctions, function, context.getTrace()); namespaceLike.addFunctionDescriptor(functionDescriptor); context.getFunctions().put(function, functionDescriptor); context.getDeclaringScopes().put(function, scopeForFunctions); @@ -128,7 +170,7 @@ public class DeclarationResolver { @Override public void visitProperty(JetProperty property) { - PropertyDescriptor propertyDescriptor = context.getDescriptorResolver().resolvePropertyDescriptor(namespaceLike, scopeForPropertyInitializers, property); + PropertyDescriptor propertyDescriptor = descriptorResolver.resolvePropertyDescriptor(namespaceLike, scopeForPropertyInitializers, property, context.getTrace()); namespaceLike.addPropertyDescriptor(propertyDescriptor); context.getProperties().put(property, propertyDescriptor); context.getDeclaringScopes().put(property, scopeForPropertyInitializers); @@ -142,7 +184,7 @@ public class DeclarationResolver { @Override public void visitObjectDeclaration(JetObjectDeclaration declaration) { - PropertyDescriptor propertyDescriptor = context.getDescriptorResolver().resolveObjectDeclarationAsPropertyDescriptor(namespaceLike, declaration, context.getObjects().get(declaration)); + PropertyDescriptor propertyDescriptor = descriptorResolver.resolveObjectDeclarationAsPropertyDescriptor(namespaceLike, declaration, context.getObjects().get(declaration), context.getTrace()); namespaceLike.addPropertyDescriptor(propertyDescriptor); } @@ -151,7 +193,7 @@ public class DeclarationResolver { if (enumEntry.getPrimaryConstructorParameterList() == null) { MutableClassDescriptorLite classObjectDescriptor = ((MutableClassDescriptor) namespaceLike).getClassObjectDescriptor(); assert classObjectDescriptor != null; - PropertyDescriptor propertyDescriptor = context.getDescriptorResolver().resolveObjectDeclarationAsPropertyDescriptor(classObjectDescriptor, enumEntry, context.getClasses().get(enumEntry)); + PropertyDescriptor propertyDescriptor = descriptorResolver.resolveObjectDeclarationAsPropertyDescriptor(classObjectDescriptor, enumEntry, context.getClasses().get(enumEntry), context.getTrace()); classObjectDescriptor.addPropertyDescriptor(propertyDescriptor); } } @@ -170,13 +212,13 @@ public class DeclarationResolver { // TODO : not all the parameters are real properties JetScope memberScope = classDescriptor.getScopeForSupertypeResolution(); - ConstructorDescriptor constructorDescriptor = context.getDescriptorResolver().resolvePrimaryConstructorDescriptor(memberScope, classDescriptor, klass); + ConstructorDescriptor constructorDescriptor = descriptorResolver.resolvePrimaryConstructorDescriptor(memberScope, classDescriptor, klass, context.getTrace()); for (JetParameter parameter : klass.getPrimaryConstructorParameters()) { if (parameter.getValOrVarNode() != null) { - PropertyDescriptor propertyDescriptor = context.getDescriptorResolver().resolvePrimaryConstructorParameterToAProperty( + PropertyDescriptor propertyDescriptor = descriptorResolver.resolvePrimaryConstructorParameterToAProperty( classDescriptor, memberScope, - parameter + parameter, context.getTrace() ); classDescriptor.addPropertyDescriptor(propertyDescriptor); context.getPrimaryConstructorParameterProperties().add(propertyDescriptor); @@ -191,10 +233,10 @@ public class DeclarationResolver { if (classDescriptor.getKind() == ClassKind.TRAIT) { context.getTrace().report(CONSTRUCTOR_IN_TRAIT.on(constructor.getNameNode().getPsi())); } - ConstructorDescriptor constructorDescriptor = context.getDescriptorResolver().resolveSecondaryConstructorDescriptor( + ConstructorDescriptor constructorDescriptor = descriptorResolver.resolveSecondaryConstructorDescriptor( classDescriptor.getScopeForMemberResolution(), classDescriptor, - constructor); + constructor, context.getTrace()); classDescriptor.addConstructor(constructorDescriptor, context.getTrace()); context.getConstructors().put(constructor, constructorDescriptor); context.getDeclaringScopes().put(constructor, classDescriptor.getScopeForMemberLookup()); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java index 89601970fde..780bc2abeea 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java @@ -19,6 +19,7 @@ package org.jetbrains.jet.lang.resolve; import com.google.common.collect.Lists; import com.google.common.collect.Maps; import com.google.common.collect.Sets; +import com.google.inject.Inject; import com.intellij.lang.ASTNode; import com.intellij.openapi.util.Pair; import com.intellij.psi.PsiElement; @@ -44,12 +45,16 @@ import static org.jetbrains.jet.lang.resolve.BindingContext.TYPE; * @author svtk */ public class DeclarationsChecker { + @NotNull private TopDownAnalysisContext context; - public DeclarationsChecker(TopDownAnalysisContext context) { + + @Inject + public void setContext(@NotNull TopDownAnalysisContext context) { this.context = context; } + public void process() { Map classes = context.getClasses(); for (Map.Entry entry : classes.entrySet()) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegationResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegationResolver.java index 3c54d679757..a5629951103 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegationResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegationResolver.java @@ -16,6 +16,8 @@ package org.jetbrains.jet.lang.resolve; +import com.google.inject.Inject; +import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.types.JetType; @@ -28,12 +30,16 @@ import static org.jetbrains.jet.lang.resolve.BindingContext.DELEGATED; * @author abreslav */ public class DelegationResolver { - private final TopDownAnalysisContext context; + @NotNull + private TopDownAnalysisContext context; - public DelegationResolver(TopDownAnalysisContext context) { + + @Inject + public void setContext(@NotNull TopDownAnalysisContext context) { this.context = context; } + public void process() { addDelegatedMembers(); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java index 517e38c3b5f..b38c0682612 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java @@ -18,58 +18,140 @@ package org.jetbrains.jet.lang.resolve; import com.google.common.collect.Lists; import com.google.common.collect.Maps; +import com.google.inject.Inject; import com.intellij.lang.ASTNode; import com.intellij.psi.PsiElement; import com.intellij.psi.util.PsiTreeUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.JetSemanticServices; -import org.jetbrains.jet.lang.descriptors.*; +import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor; +import org.jetbrains.jet.lang.descriptors.ClassDescriptor; +import org.jetbrains.jet.lang.descriptors.ClassKind; +import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor; +import org.jetbrains.jet.lang.descriptors.ConstructorDescriptorImpl; +import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; +import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; +import org.jetbrains.jet.lang.descriptors.LocalVariableDescriptor; +import org.jetbrains.jet.lang.descriptors.Modality; +import org.jetbrains.jet.lang.descriptors.MutableClassDescriptor; +import org.jetbrains.jet.lang.descriptors.MutableValueParameterDescriptor; +import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; +import org.jetbrains.jet.lang.descriptors.PropertyDescriptor; +import org.jetbrains.jet.lang.descriptors.PropertyGetterDescriptor; +import org.jetbrains.jet.lang.descriptors.PropertySetterDescriptor; +import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor; +import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptorImpl; +import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; +import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; +import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptorImpl; +import org.jetbrains.jet.lang.descriptors.VariableDescriptor; +import org.jetbrains.jet.lang.descriptors.VariableDescriptorImpl; +import org.jetbrains.jet.lang.descriptors.Visibility; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; -import org.jetbrains.jet.lang.psi.*; +import org.jetbrains.jet.lang.psi.JetClass; +import org.jetbrains.jet.lang.psi.JetClassOrObject; +import org.jetbrains.jet.lang.psi.JetDeclaration; +import org.jetbrains.jet.lang.psi.JetDelegationSpecifier; +import org.jetbrains.jet.lang.psi.JetEnumEntry; +import org.jetbrains.jet.lang.psi.JetExpression; +import org.jetbrains.jet.lang.psi.JetModifierList; +import org.jetbrains.jet.lang.psi.JetNamedFunction; +import org.jetbrains.jet.lang.psi.JetNullableType; +import org.jetbrains.jet.lang.psi.JetObjectDeclarationName; +import org.jetbrains.jet.lang.psi.JetParameter; +import org.jetbrains.jet.lang.psi.JetProjectionKind; +import org.jetbrains.jet.lang.psi.JetProperty; +import org.jetbrains.jet.lang.psi.JetPropertyAccessor; +import org.jetbrains.jet.lang.psi.JetPsiUtil; +import org.jetbrains.jet.lang.psi.JetSecondaryConstructor; +import org.jetbrains.jet.lang.psi.JetSimpleNameExpression; +import org.jetbrains.jet.lang.psi.JetTypeConstraint; +import org.jetbrains.jet.lang.psi.JetTypeElement; +import org.jetbrains.jet.lang.psi.JetTypeParameter; +import org.jetbrains.jet.lang.psi.JetTypeParameterListOwner; +import org.jetbrains.jet.lang.psi.JetTypeProjection; +import org.jetbrains.jet.lang.psi.JetTypeReference; +import org.jetbrains.jet.lang.psi.JetUserType; import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl; import org.jetbrains.jet.lang.resolve.scopes.receivers.ExtensionReceiver; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; -import org.jetbrains.jet.lang.types.*; +import org.jetbrains.jet.lang.types.DeferredType; +import org.jetbrains.jet.lang.types.ErrorUtils; +import org.jetbrains.jet.lang.types.JetType; +import org.jetbrains.jet.lang.types.TypeProjection; +import org.jetbrains.jet.lang.types.TypeSubstitutor; +import org.jetbrains.jet.lang.types.TypeUtils; +import org.jetbrains.jet.lang.types.Variance; +import org.jetbrains.jet.lang.types.checker.JetTypeChecker; +import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; import org.jetbrains.jet.lang.types.lang.JetStandardClasses; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import org.jetbrains.jet.lexer.JetTokens; import org.jetbrains.jet.util.lazy.LazyValue; import org.jetbrains.jet.util.lazy.LazyValueWithDefault; -import java.util.*; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.List; +import java.util.Map; -import static org.jetbrains.jet.lang.diagnostics.Errors.*; +import static org.jetbrains.jet.lang.diagnostics.Errors.ABSTRACT_PROPERTY_IN_PRIMARY_CONSTRUCTOR_PARAMETERS; +import static org.jetbrains.jet.lang.diagnostics.Errors.CONFLICTING_CLASS_OBJECT_UPPER_BOUNDS; +import static org.jetbrains.jet.lang.diagnostics.Errors.CONFLICTING_UPPER_BOUNDS; +import static org.jetbrains.jet.lang.diagnostics.Errors.FINAL_CLASS_OBJECT_UPPER_BOUND; +import static org.jetbrains.jet.lang.diagnostics.Errors.FINAL_UPPER_BOUND; +import static org.jetbrains.jet.lang.diagnostics.Errors.NAME_IN_CONSTRAINT_IS_NOT_A_TYPE_PARAMETER; +import static org.jetbrains.jet.lang.diagnostics.Errors.NO_GENERICS_IN_SUPERTYPE_SPECIFIER; +import static org.jetbrains.jet.lang.diagnostics.Errors.NULLABLE_SUPERTYPE; +import static org.jetbrains.jet.lang.diagnostics.Errors.PROJECTION_IN_IMMEDIATE_ARGUMENT_TO_SUPERTYPE; +import static org.jetbrains.jet.lang.diagnostics.Errors.PROPERTY_WITH_NO_TYPE_NO_INITIALIZER; +import static org.jetbrains.jet.lang.diagnostics.Errors.SETTER_PARAMETER_WITH_DEFAULT_VALUE; +import static org.jetbrains.jet.lang.diagnostics.Errors.UNRESOLVED_REFERENCE; +import static org.jetbrains.jet.lang.diagnostics.Errors.UPPER_BOUND_VIOLATED; +import static org.jetbrains.jet.lang.diagnostics.Errors.VALUE_PARAMETER_WITH_NO_TYPE_ANNOTATION; +import static org.jetbrains.jet.lang.diagnostics.Errors.VAL_WITH_SETTER; +import static org.jetbrains.jet.lang.diagnostics.Errors.WRONG_GETTER_RETURN_TYPE; +import static org.jetbrains.jet.lang.diagnostics.Errors.WRONG_SETTER_PARAMETER_TYPE; /** * @author abreslav */ public class DescriptorResolver { - private final JetSemanticServices semanticServices; - private final TypeResolver typeResolver; - private final TypeResolver typeResolverNotCheckingBounds; - private final BindingTrace trace; - private final AnnotationResolver annotationResolver; + @NotNull + private TypeResolver typeResolver; + @NotNull + private AnnotationResolver annotationResolver; + @NotNull + private ExpressionTypingServices expressionTypingServices; - public DescriptorResolver(JetSemanticServices semanticServices, BindingTrace trace) { - this.semanticServices = semanticServices; - this.typeResolver = new TypeResolver(semanticServices, trace, true); - this.typeResolverNotCheckingBounds = new TypeResolver(semanticServices, trace, false); - this.trace = trace; - this.annotationResolver = new AnnotationResolver(semanticServices, trace); + @Inject + public void setTypeResolver(@NotNull TypeResolver typeResolver) { + this.typeResolver = typeResolver; } - public void resolveMutableClassDescriptor(@NotNull JetClass classElement, @NotNull MutableClassDescriptor descriptor) { + @Inject + public void setAnnotationResolver(@NotNull AnnotationResolver annotationResolver) { + this.annotationResolver = annotationResolver; + } + + @Inject + public void setExpressionTypingServices(@NotNull ExpressionTypingServices expressionTypingServices) { + this.expressionTypingServices = expressionTypingServices; + } + + + public void resolveMutableClassDescriptor(@NotNull JetClass classElement, @NotNull MutableClassDescriptor descriptor, BindingTrace trace) { // TODO : Where-clause List typeParameters = Lists.newArrayList(); int index = 0; for (JetTypeParameter typeParameter : classElement.getTypeParameters()) { TypeParameterDescriptor typeParameterDescriptor = TypeParameterDescriptor.createForFurtherModification( descriptor, - annotationResolver.createAnnotationStubs(typeParameter.getModifierList()), + annotationResolver.createAnnotationStubs(typeParameter.getModifierList(), trace), !typeParameter.hasModifier(JetTokens.ERASED_KEYWORD), typeParameter.getVariance(), JetPsiUtil.safeName(typeParameter.getName()), @@ -87,16 +169,16 @@ public class DescriptorResolver { trace.record(BindingContext.CLASS, classElement, descriptor); } - public void resolveSupertypes(@NotNull JetClassOrObject jetClass, @NotNull MutableClassDescriptor descriptor) { + public void resolveSupertypes(@NotNull JetClassOrObject jetClass, @NotNull MutableClassDescriptor descriptor, BindingTrace trace) { List delegationSpecifiers = jetClass.getDelegationSpecifiers(); if (delegationSpecifiers.isEmpty()) { - descriptor.addSupertype(getDefaultSupertype(jetClass)); + descriptor.addSupertype(getDefaultSupertype(jetClass, trace)); } else { Collection supertypes = resolveDelegationSpecifiers( descriptor.getScopeForSupertypeResolution(), delegationSpecifiers, - typeResolverNotCheckingBounds); + typeResolver, trace, false); for (JetType supertype : supertypes) { descriptor.addSupertype(supertype); } @@ -104,7 +186,7 @@ public class DescriptorResolver { } - private JetType getDefaultSupertype(JetClassOrObject jetClass) { + private JetType getDefaultSupertype(JetClassOrObject jetClass, BindingTrace trace) { // TODO : beautify if (jetClass instanceof JetEnumEntry) { JetClassOrObject parent = PsiTreeUtil.getParentOfType(jetClass, JetClassOrObject.class); @@ -120,7 +202,7 @@ public class DescriptorResolver { return JetStandardClasses.getAnyType(); } - public Collection resolveDelegationSpecifiers(JetScope extensibleScope, List delegationSpecifiers, @NotNull TypeResolver resolver) { + public Collection resolveDelegationSpecifiers(JetScope extensibleScope, List delegationSpecifiers, @NotNull TypeResolver resolver, BindingTrace trace, boolean checkBounds) { if (delegationSpecifiers.isEmpty()) { return Collections.emptyList(); } @@ -128,7 +210,7 @@ public class DescriptorResolver { for (JetDelegationSpecifier delegationSpecifier : delegationSpecifiers) { JetTypeReference typeReference = delegationSpecifier.getTypeReference(); if (typeReference != null) { - result.add(resolver.resolveType(extensibleScope, typeReference)); + result.add(resolver.resolveType(extensibleScope, typeReference, trace, checkBounds)); JetTypeElement typeElement = typeReference.getTypeElement(); while (typeElement instanceof JetNullableType) { JetNullableType nullableType = (JetNullableType) typeElement; @@ -153,19 +235,19 @@ public class DescriptorResolver { } @NotNull - public SimpleFunctionDescriptor resolveFunctionDescriptor(DeclarationDescriptor containingDescriptor, final JetScope scope, final JetNamedFunction function) { + public SimpleFunctionDescriptor resolveFunctionDescriptor(DeclarationDescriptor containingDescriptor, final JetScope scope, final JetNamedFunction function, final BindingTrace trace) { final SimpleFunctionDescriptorImpl functionDescriptor = new SimpleFunctionDescriptorImpl( containingDescriptor, - annotationResolver.resolveAnnotations(scope, function.getModifierList()), + annotationResolver.resolveAnnotations(scope, function.getModifierList(), trace), JetPsiUtil.safeName(function.getName()), CallableMemberDescriptor.Kind.DECLARATION ); WritableScope innerScope = new WritableScopeImpl(scope, functionDescriptor, new TraceBasedRedeclarationHandler(trace)).setDebugName("Function descriptor header scope"); innerScope.addLabeledDeclaration(functionDescriptor); - List typeParameterDescriptors = resolveTypeParameters(functionDescriptor, innerScope, function.getTypeParameters()); + List typeParameterDescriptors = resolveTypeParameters(functionDescriptor, innerScope, function.getTypeParameters(), trace); innerScope.changeLockLevel(WritableScope.LockLevel.BOTH); - resolveGenericBounds(function, innerScope, typeParameterDescriptors); + resolveGenericBounds(function, innerScope, typeParameterDescriptors, trace); JetType receiverType = null; JetTypeReference receiverTypeRef = function.getReceiverTypeRef(); @@ -174,17 +256,17 @@ public class DescriptorResolver { function.hasTypeParameterListBeforeFunctionName() ? innerScope : scope; - receiverType = typeResolver.resolveType(scopeForReceiver, receiverTypeRef); + receiverType = typeResolver.resolveType(scopeForReceiver, receiverTypeRef, trace, true); } - List valueParameterDescriptors = resolveValueParameters(functionDescriptor, innerScope, function.getValueParameters()); + List valueParameterDescriptors = resolveValueParameters(functionDescriptor, innerScope, function.getValueParameters(), trace); innerScope.changeLockLevel(WritableScope.LockLevel.READING); JetTypeReference returnTypeRef = function.getReturnTypeRef(); JetType returnType; if (returnTypeRef != null) { - returnType = typeResolver.resolveType(innerScope, returnTypeRef); + returnType = typeResolver.resolveType(innerScope, returnTypeRef, trace, true); } else if (function.hasBlockBody()) { returnType = JetStandardClasses.getUnitType(); @@ -196,7 +278,7 @@ public class DescriptorResolver { @Override protected JetType compute() { //JetFlowInformationProvider flowInformationProvider = computeFlowData(function, bodyExpression); - return semanticServices.getTypeInferrerServices(trace).inferFunctionReturnType(scope, function, functionDescriptor); + return expressionTypingServices.inferFunctionReturnType(scope, function, functionDescriptor, trace); } }); } @@ -236,7 +318,7 @@ public class DescriptorResolver { } @NotNull - private List resolveValueParameters(FunctionDescriptor functionDescriptor, WritableScope parameterScope, List valueParameters) { + private List resolveValueParameters(FunctionDescriptor functionDescriptor, WritableScope parameterScope, List valueParameters, BindingTrace trace) { List result = new ArrayList(); for (int i = 0, valueParametersSize = valueParameters.size(); i < valueParametersSize; i++) { JetParameter valueParameter = valueParameters.get(i); @@ -247,10 +329,10 @@ public class DescriptorResolver { trace.report(VALUE_PARAMETER_WITH_NO_TYPE_ANNOTATION.on(valueParameter)); type = ErrorUtils.createErrorType("Type annotation was missing"); } else { - type = typeResolver.resolveType(parameterScope, typeReference); + type = typeResolver.resolveType(parameterScope, typeReference, trace, true); } - ValueParameterDescriptor valueParameterDescriptor = resolveValueParameterDescriptor(functionDescriptor, valueParameter, i, type); + ValueParameterDescriptor valueParameterDescriptor = resolveValueParameterDescriptor(functionDescriptor, valueParameter, i, type, trace); parameterScope.addVariableDescriptor(valueParameterDescriptor); result.add(valueParameterDescriptor); } @@ -258,7 +340,7 @@ public class DescriptorResolver { } @NotNull - public MutableValueParameterDescriptor resolveValueParameterDescriptor(DeclarationDescriptor declarationDescriptor, JetParameter valueParameter, int index, JetType type) { + public MutableValueParameterDescriptor resolveValueParameterDescriptor(DeclarationDescriptor declarationDescriptor, JetParameter valueParameter, int index, JetType type, BindingTrace trace) { JetType varargElementType = null; JetType variableType = type; if (valueParameter.hasModifier(JetTokens.VARARG_KEYWORD)) { @@ -268,7 +350,7 @@ public class DescriptorResolver { MutableValueParameterDescriptor valueParameterDescriptor = new ValueParameterDescriptorImpl( declarationDescriptor, index, - annotationResolver.createAnnotationStubs(valueParameter.getModifierList()), + annotationResolver.createAnnotationStubs(valueParameter.getModifierList(), trace), JetPsiUtil.safeName(valueParameter.getName()), valueParameter.isMutable(), variableType, @@ -281,32 +363,31 @@ public class DescriptorResolver { } private JetType getVarargParameterType(JetType type) { - JetStandardLibrary standardLibrary = semanticServices.getStandardLibrary(); - JetType arrayType = standardLibrary.getPrimitiveArrayJetTypeByPrimitiveJetType(type); + JetType arrayType = JetStandardLibrary.getInstance().getPrimitiveArrayJetTypeByPrimitiveJetType(type); if (arrayType != null) { return arrayType; } else { - return standardLibrary.getArrayType(type); + return JetStandardLibrary.getInstance().getArrayType(type); } } - public List resolveTypeParameters(DeclarationDescriptor containingDescriptor, WritableScope extensibleScope, List typeParameters) { + public List resolveTypeParameters(DeclarationDescriptor containingDescriptor, WritableScope extensibleScope, List typeParameters, BindingTrace trace) { List result = new ArrayList(); for (int i = 0, typeParametersSize = typeParameters.size(); i < typeParametersSize; i++) { JetTypeParameter typeParameter = typeParameters.get(i); - result.add(resolveTypeParameter(containingDescriptor, extensibleScope, typeParameter, i)); + result.add(resolveTypeParameter(containingDescriptor, extensibleScope, typeParameter, i, trace)); } return result; } - private TypeParameterDescriptor resolveTypeParameter(DeclarationDescriptor containingDescriptor, WritableScope extensibleScope, JetTypeParameter typeParameter, int index) { + private TypeParameterDescriptor resolveTypeParameter(DeclarationDescriptor containingDescriptor, WritableScope extensibleScope, JetTypeParameter typeParameter, int index, BindingTrace trace) { // JetTypeReference extendsBound = typeParameter.getExtendsBound(); // JetType bound = extendsBound == null // ? JetStandardClasses.getDefaultBound() // : typeResolver.resolveType(extensibleScope, extendsBound); TypeParameterDescriptor typeParameterDescriptor = TypeParameterDescriptor.createForFurtherModification( containingDescriptor, - annotationResolver.createAnnotationStubs(typeParameter.getModifierList()), + annotationResolver.createAnnotationStubs(typeParameter.getModifierList(), trace), !typeParameter.hasModifier(JetTokens.ERASED_KEYWORD), typeParameter.getVariance(), JetPsiUtil.safeName(typeParameter.getName()), @@ -318,7 +399,7 @@ public class DescriptorResolver { return typeParameterDescriptor; } - public void resolveGenericBounds(@NotNull JetTypeParameterListOwner declaration, JetScope scope, List parameters) { + public void resolveGenericBounds(@NotNull JetTypeParameterListOwner declaration, JetScope scope, List parameters, BindingTrace trace) { List typeParameters = declaration.getTypeParameters(); Map parameterByName = Maps.newHashMap(); for (int i = 0, typeParametersSize = typeParameters.size(); i < typeParametersSize; i++) { @@ -327,7 +408,7 @@ public class DescriptorResolver { parameterByName.put(typeParameterDescriptor.getName(), typeParameterDescriptor); JetTypeReference extendsBound = jetTypeParameter.getExtendsBound(); if (extendsBound != null) { - typeParameterDescriptor.addUpperBound(resolveAndCheckUpperBoundType(extendsBound, scope, false)); + typeParameterDescriptor.addUpperBound(resolveAndCheckUpperBoundType(extendsBound, scope, false, trace)); } } for (JetTypeConstraint constraint : declaration.getTypeConstaints()) { @@ -341,7 +422,7 @@ public class DescriptorResolver { } TypeParameterDescriptor typeParameterDescriptor = parameterByName.get(referencedName); JetTypeReference boundTypeReference = constraint.getBoundTypeReference(); - JetType bound = boundTypeReference != null ? resolveAndCheckUpperBoundType(boundTypeReference, scope, constraint.isClassObjectContraint()) : null; + JetType bound = boundTypeReference != null ? resolveAndCheckUpperBoundType(boundTypeReference, scope, constraint.isClassObjectContraint(), trace) : null; if (typeParameterDescriptor == null) { // To tell the user that we look only for locally defined type parameters ClassifierDescriptor classifier = scope.getClassifier(referencedName); @@ -388,9 +469,9 @@ public class DescriptorResolver { } } - private JetType resolveAndCheckUpperBoundType(@NotNull JetTypeReference upperBound, @NotNull JetScope scope, boolean classObjectConstaint) { - JetType jetType = typeResolverNotCheckingBounds.resolveType(scope, upperBound); - if (!TypeUtils.canHaveSubtypes(semanticServices.getTypeChecker(), jetType)) { + private JetType resolveAndCheckUpperBoundType(@NotNull JetTypeReference upperBound, @NotNull JetScope scope, boolean classObjectConstaint, BindingTrace trace) { + JetType jetType = typeResolver.resolveType(scope, upperBound, trace, false); + if (!TypeUtils.canHaveSubtypes(JetTypeChecker.INSTANCE, jetType)) { if (classObjectConstaint) { trace.report(FINAL_CLASS_OBJECT_UPPER_BOUND.on(upperBound, jetType)); } @@ -402,16 +483,16 @@ public class DescriptorResolver { } @NotNull - public VariableDescriptor resolveLocalVariableDescriptor(@NotNull DeclarationDescriptor containingDeclaration, @NotNull JetScope scope, @NotNull JetParameter parameter) { - JetType type = resolveParameterType(scope, parameter); - return resolveLocalVariableDescriptor(containingDeclaration, parameter, type); + public VariableDescriptor resolveLocalVariableDescriptor(@NotNull DeclarationDescriptor containingDeclaration, @NotNull JetScope scope, @NotNull JetParameter parameter, BindingTrace trace) { + JetType type = resolveParameterType(scope, parameter, trace); + return resolveLocalVariableDescriptor(containingDeclaration, parameter, type, trace); } - private JetType resolveParameterType(JetScope scope, JetParameter parameter) { + private JetType resolveParameterType(JetScope scope, JetParameter parameter, BindingTrace trace) { JetTypeReference typeReference = parameter.getTypeReference(); JetType type; if (typeReference != null) { - type = typeResolver.resolveType(scope, typeReference); + type = typeResolver.resolveType(scope, typeReference, trace, true); } else { // Error is reported by the parser @@ -420,10 +501,10 @@ public class DescriptorResolver { return type; } - public VariableDescriptor resolveLocalVariableDescriptor(@NotNull DeclarationDescriptor containingDeclaration, @NotNull JetParameter parameter, @NotNull JetType type) { + public VariableDescriptor resolveLocalVariableDescriptor(@NotNull DeclarationDescriptor containingDeclaration, @NotNull JetParameter parameter, @NotNull JetType type, BindingTrace trace) { VariableDescriptor variableDescriptor = new LocalVariableDescriptor( containingDeclaration, - annotationResolver.createAnnotationStubs(parameter.getModifierList()), + annotationResolver.createAnnotationStubs(parameter.getModifierList(), trace), JetPsiUtil.safeName(parameter.getName()), type, parameter.isMutable()); @@ -432,19 +513,19 @@ public class DescriptorResolver { } @NotNull - public VariableDescriptor resolveLocalVariableDescriptor(DeclarationDescriptor containingDeclaration, JetScope scope, JetProperty property, DataFlowInfo dataFlowInfo) { - VariableDescriptorImpl variableDescriptor = resolveLocalVariableDescriptorWithType(containingDeclaration, property, null); + public VariableDescriptor resolveLocalVariableDescriptor(DeclarationDescriptor containingDeclaration, JetScope scope, JetProperty property, DataFlowInfo dataFlowInfo, BindingTrace trace) { + VariableDescriptorImpl variableDescriptor = resolveLocalVariableDescriptorWithType(containingDeclaration, property, null, trace); - JetType type = getVariableType(scope, property, dataFlowInfo, false); // For a local variable the type must not be deferred + JetType type = getVariableType(scope, property, dataFlowInfo, false, trace); // For a local variable the type must not be deferred variableDescriptor.setOutType(type); return variableDescriptor; } @NotNull - public VariableDescriptorImpl resolveLocalVariableDescriptorWithType(DeclarationDescriptor containingDeclaration, JetProperty property, JetType type) { + public VariableDescriptorImpl resolveLocalVariableDescriptorWithType(DeclarationDescriptor containingDeclaration, JetProperty property, JetType type, BindingTrace trace) { VariableDescriptorImpl variableDescriptor = new LocalVariableDescriptor( containingDeclaration, - annotationResolver.createAnnotationStubs(property.getModifierList()), + annotationResolver.createAnnotationStubs(property.getModifierList(), trace), JetPsiUtil.safeName(property.getName()), type, property.isVar()); @@ -454,26 +535,26 @@ public class DescriptorResolver { @NotNull public VariableDescriptor resolveObjectDeclaration(@NotNull DeclarationDescriptor containingDeclaration, - @NotNull JetClassOrObject objectDeclaration, - @NotNull ClassDescriptor classDescriptor) { + @NotNull JetClassOrObject objectDeclaration, + @NotNull ClassDescriptor classDescriptor, BindingTrace trace) { boolean isProperty = (containingDeclaration instanceof NamespaceDescriptor) || (containingDeclaration instanceof ClassDescriptor); if (isProperty) { - return resolveObjectDeclarationAsPropertyDescriptor(containingDeclaration, objectDeclaration, classDescriptor); + return resolveObjectDeclarationAsPropertyDescriptor(containingDeclaration, objectDeclaration, classDescriptor, trace); } else { - return resolveObjectDeclarationAsLocalVariable(containingDeclaration, objectDeclaration, classDescriptor); + return resolveObjectDeclarationAsLocalVariable(containingDeclaration, objectDeclaration, classDescriptor, trace); } } @NotNull public PropertyDescriptor resolveObjectDeclarationAsPropertyDescriptor(@NotNull DeclarationDescriptor containingDeclaration, - @NotNull JetClassOrObject objectDeclaration, - @NotNull ClassDescriptor classDescriptor) { + @NotNull JetClassOrObject objectDeclaration, + @NotNull ClassDescriptor classDescriptor, BindingTrace trace) { JetModifierList modifierList = objectDeclaration.getModifierList(); Visibility visibility = resolveVisibilityFromModifiers(objectDeclaration.getModifierList()); PropertyDescriptor propertyDescriptor = new PropertyDescriptor( containingDeclaration, - annotationResolver.createAnnotationStubs(modifierList), + annotationResolver.createAnnotationStubs(modifierList, trace), Modality.FINAL, visibility, false, @@ -492,11 +573,11 @@ public class DescriptorResolver { @NotNull private VariableDescriptor resolveObjectDeclarationAsLocalVariable(@NotNull DeclarationDescriptor containingDeclaration, - @NotNull JetClassOrObject objectDeclaration, - @NotNull ClassDescriptor classDescriptor) { + @NotNull JetClassOrObject objectDeclaration, + @NotNull ClassDescriptor classDescriptor, BindingTrace trace) { VariableDescriptorImpl variableDescriptor = new LocalVariableDescriptor( containingDeclaration, - annotationResolver.createAnnotationStubs(objectDeclaration.getModifierList()), + annotationResolver.createAnnotationStubs(objectDeclaration.getModifierList(), trace), JetPsiUtil.safeName(objectDeclaration.getName()), classDescriptor.getDefaultType(), /*isVar =*/ false); @@ -508,8 +589,8 @@ public class DescriptorResolver { } public JetScope getPropertyDeclarationInnerScope(@NotNull JetScope outerScope, - @NotNull PropertyDescriptor propertyDescriptor, List typeParameters, - ReceiverDescriptor receiver) { + @NotNull PropertyDescriptor propertyDescriptor, List typeParameters, + ReceiverDescriptor receiver, BindingTrace trace) { WritableScopeImpl result = new WritableScopeImpl(outerScope, propertyDescriptor, new TraceBasedRedeclarationHandler(trace)).setDebugName("Property declaration inner scope"); for (TypeParameterDescriptor typeParameterDescriptor : typeParameters) { result.addTypeParameterDescriptor(typeParameterDescriptor); @@ -522,7 +603,7 @@ public class DescriptorResolver { } @NotNull - public PropertyDescriptor resolvePropertyDescriptor(@NotNull DeclarationDescriptor containingDeclaration, @NotNull JetScope scope, JetProperty property) { + public PropertyDescriptor resolvePropertyDescriptor(@NotNull DeclarationDescriptor containingDeclaration, @NotNull JetScope scope, JetProperty property, BindingTrace trace) { JetModifierList modifierList = property.getModifierList(); boolean isVar = property.isVar(); @@ -531,7 +612,7 @@ public class DescriptorResolver { Modality defaultModality = getDefaultModality(containingDeclaration, hasBody); PropertyDescriptor propertyDescriptor = new PropertyDescriptor( containingDeclaration, - annotationResolver.resolveAnnotations(scope, modifierList), + annotationResolver.resolveAnnotations(scope, modifierList, trace), resolveModalityFromModifiers(property.getModifierList(), defaultModality), resolveVisibilityFromModifiers(property.getModifierList()), isVar, @@ -552,15 +633,15 @@ public class DescriptorResolver { } else { WritableScope writableScope = new WritableScopeImpl(scope, containingDeclaration, new TraceBasedRedeclarationHandler(trace)).setDebugName("Scope with type parameters of a property"); - typeParameterDescriptors = resolveTypeParameters(containingDeclaration, writableScope, typeParameters); + typeParameterDescriptors = resolveTypeParameters(containingDeclaration, writableScope, typeParameters, trace); writableScope.changeLockLevel(WritableScope.LockLevel.READING); - resolveGenericBounds(property, writableScope, typeParameterDescriptors); + resolveGenericBounds(property, writableScope, typeParameterDescriptors, trace); scopeWithTypeParameters = writableScope; } JetTypeReference receiverTypeRef = property.getReceiverTypeRef(); if (receiverTypeRef != null) { - receiverType = typeResolver.resolveType(scopeWithTypeParameters, receiverTypeRef); + receiverType = typeResolver.resolveType(scopeWithTypeParameters, receiverTypeRef, trace, true); } } @@ -568,14 +649,14 @@ public class DescriptorResolver { ? ReceiverDescriptor.NO_RECEIVER : new ExtensionReceiver(propertyDescriptor, receiverType); - JetScope propertyScope = getPropertyDeclarationInnerScope(scope, propertyDescriptor, typeParameterDescriptors, receiverDescriptor); + JetScope propertyScope = getPropertyDeclarationInnerScope(scope, propertyDescriptor, typeParameterDescriptors, receiverDescriptor, trace); - JetType type = getVariableType(propertyScope, property, DataFlowInfo.EMPTY, true); + JetType type = getVariableType(propertyScope, property, DataFlowInfo.EMPTY, true, trace); propertyDescriptor.setType(type, typeParameterDescriptors, DescriptorUtils.getExpectedThisObjectIfNeeded(containingDeclaration), receiverDescriptor); - PropertyGetterDescriptor getter = resolvePropertyGetterDescriptor(scopeWithTypeParameters, property, propertyDescriptor); - PropertySetterDescriptor setter = resolvePropertySetterDescriptor(scopeWithTypeParameters, property, propertyDescriptor); + PropertyGetterDescriptor getter = resolvePropertyGetterDescriptor(scopeWithTypeParameters, property, propertyDescriptor, trace); + PropertySetterDescriptor setter = resolvePropertySetterDescriptor(scopeWithTypeParameters, property, propertyDescriptor, trace); propertyDescriptor.initialize(getter, setter); @@ -599,7 +680,7 @@ public class DescriptorResolver { } @NotNull - private JetType getVariableType(@NotNull final JetScope scope, @NotNull final JetProperty property, @NotNull final DataFlowInfo dataFlowInfo, boolean allowDeferred) { + private JetType getVariableType(@NotNull final JetScope scope, @NotNull final JetProperty property, @NotNull final DataFlowInfo dataFlowInfo, boolean allowDeferred, final BindingTrace trace) { // TODO : receiver? JetTypeReference propertyTypeRef = property.getPropertyTypeRef(); @@ -616,7 +697,7 @@ public class DescriptorResolver { LazyValue lazyValue = new LazyValueWithDefault(ErrorUtils.createErrorType("Recursive dependency")) { @Override protected JetType compute() { - return semanticServices.getTypeInferrerServices(trace).safeGetType(scope, initializer, TypeUtils.NO_EXPECTED_TYPE, dataFlowInfo); + return expressionTypingServices.safeGetType(scope, initializer, TypeUtils.NO_EXPECTED_TYPE, dataFlowInfo, trace); } }; if (allowDeferred) { @@ -627,7 +708,7 @@ public class DescriptorResolver { } } } else { - return typeResolver.resolveType(scope, propertyTypeRef); + return typeResolver.resolveType(scope, propertyTypeRef, trace, true); } } @@ -676,11 +757,11 @@ public class DescriptorResolver { } @Nullable - private PropertySetterDescriptor resolvePropertySetterDescriptor(@NotNull JetScope scope, @NotNull JetProperty property, @NotNull PropertyDescriptor propertyDescriptor) { + private PropertySetterDescriptor resolvePropertySetterDescriptor(@NotNull JetScope scope, @NotNull JetProperty property, @NotNull PropertyDescriptor propertyDescriptor, BindingTrace trace) { JetPropertyAccessor setter = property.getSetter(); PropertySetterDescriptor setterDescriptor = null; if (setter != null) { - List annotations = annotationResolver.resolveAnnotations(scope, setter.getModifierList()); + List annotations = annotationResolver.resolveAnnotations(scope, setter.getModifierList(), trace); JetParameter parameter = setter.getParameter(); setterDescriptor = new PropertySetterDescriptor( @@ -701,7 +782,7 @@ public class DescriptorResolver { type = propertyDescriptor.getType(); // TODO : this maybe unknown at this point } else { - type = typeResolver.resolveType(scope, typeReference); + type = typeResolver.resolveType(scope, typeReference, trace, true); JetType inType = propertyDescriptor.getType(); if (inType != null) { if (!TypeUtils.equalTypes(type, inType)) { @@ -713,7 +794,7 @@ public class DescriptorResolver { } } - MutableValueParameterDescriptor valueParameterDescriptor = resolveValueParameterDescriptor(setterDescriptor, parameter, 0, type); + MutableValueParameterDescriptor valueParameterDescriptor = resolveValueParameterDescriptor(setterDescriptor, parameter, 0, type, trace); setterDescriptor.initialize(valueParameterDescriptor); } else { @@ -746,17 +827,17 @@ public class DescriptorResolver { } @Nullable - private PropertyGetterDescriptor resolvePropertyGetterDescriptor(@NotNull JetScope scope, @NotNull JetProperty property, @NotNull PropertyDescriptor propertyDescriptor) { + private PropertyGetterDescriptor resolvePropertyGetterDescriptor(@NotNull JetScope scope, @NotNull JetProperty property, @NotNull PropertyDescriptor propertyDescriptor, BindingTrace trace) { PropertyGetterDescriptor getterDescriptor; JetPropertyAccessor getter = property.getGetter(); if (getter != null) { - List annotations = annotationResolver.resolveAnnotations(scope, getter.getModifierList()); + List annotations = annotationResolver.resolveAnnotations(scope, getter.getModifierList(), trace); JetType outType = propertyDescriptor.getType(); JetType returnType = outType; JetTypeReference returnTypeReference = getter.getReturnTypeReference(); if (returnTypeReference != null) { - returnType = typeResolver.resolveType(scope, returnTypeReference); + returnType = typeResolver.resolveType(scope, returnTypeReference, trace, true); if (outType != null && !TypeUtils.equalTypes(returnType, outType)) { trace.report(WRONG_GETTER_RETURN_TYPE.on(returnTypeReference, propertyDescriptor.getReturnType())); } @@ -786,8 +867,8 @@ public class DescriptorResolver { } @NotNull - public ConstructorDescriptorImpl resolveSecondaryConstructorDescriptor(@NotNull JetScope scope, @NotNull ClassDescriptor classDescriptor, @NotNull JetSecondaryConstructor constructor) { - return createConstructorDescriptor(scope, classDescriptor, false, constructor.getModifierList(), constructor, classDescriptor.getTypeConstructor().getParameters(), constructor.getValueParameters()); + public ConstructorDescriptorImpl resolveSecondaryConstructorDescriptor(@NotNull JetScope scope, @NotNull ClassDescriptor classDescriptor, @NotNull JetSecondaryConstructor constructor, BindingTrace trace) { + return createConstructorDescriptor(scope, classDescriptor, false, constructor.getModifierList(), constructor, classDescriptor.getTypeConstructor().getParameters(), constructor.getValueParameters(), trace); } @NotNull @@ -797,10 +878,10 @@ public class DescriptorResolver { boolean isPrimary, @Nullable JetModifierList modifierList, @NotNull JetDeclaration declarationToTrace, - List typeParameters, @NotNull List valueParameters) { + List typeParameters, @NotNull List valueParameters, BindingTrace trace) { ConstructorDescriptorImpl constructorDescriptor = new ConstructorDescriptorImpl( classDescriptor, - annotationResolver.resolveAnnotations(scope, modifierList), + annotationResolver.resolveAnnotations(scope, modifierList, trace), isPrimary ); trace.record(BindingContext.CONSTRUCTOR, declarationToTrace, constructorDescriptor); @@ -811,12 +892,12 @@ public class DescriptorResolver { resolveValueParameters( constructorDescriptor, parameterScope, - valueParameters), + valueParameters, trace), resolveVisibilityFromModifiers(modifierList)); } @Nullable - public ConstructorDescriptorImpl resolvePrimaryConstructorDescriptor(@NotNull JetScope scope, @NotNull ClassDescriptor classDescriptor, @NotNull JetClass classElement) { + public ConstructorDescriptorImpl resolvePrimaryConstructorDescriptor(@NotNull JetScope scope, @NotNull ClassDescriptor classDescriptor, @NotNull JetClass classElement, BindingTrace trace) { if (classDescriptor.getKind() == ClassKind.ENUM_ENTRY && !classElement.hasPrimaryConstructor()) return null; return createConstructorDescriptor( scope, @@ -824,15 +905,15 @@ public class DescriptorResolver { true, classElement.getPrimaryConstructorModifierList(), classElement, - classDescriptor.getTypeConstructor().getParameters(), classElement.getPrimaryConstructorParameters()); + classDescriptor.getTypeConstructor().getParameters(), classElement.getPrimaryConstructorParameters(), trace); } @NotNull public PropertyDescriptor resolvePrimaryConstructorParameterToAProperty( @NotNull ClassDescriptor classDescriptor, @NotNull JetScope scope, - @NotNull JetParameter parameter) { - JetType type = resolveParameterType(scope, parameter); + @NotNull JetParameter parameter, BindingTrace trace) { + JetType type = resolveParameterType(scope, parameter, trace); String name = parameter.getName(); boolean isMutable = parameter.isMutable(); JetModifierList modifierList = parameter.getModifierList(); @@ -846,7 +927,7 @@ public class DescriptorResolver { PropertyDescriptor propertyDescriptor = new PropertyDescriptor( classDescriptor, - annotationResolver.resolveAnnotations(scope, modifierList), + annotationResolver.resolveAnnotations(scope, modifierList, trace), resolveModalityFromModifiers(parameter.getModifierList(), Modality.FINAL), resolveVisibilityFromModifiers(parameter.getModifierList()), isMutable, @@ -866,7 +947,7 @@ public class DescriptorResolver { return propertyDescriptor; } - public void checkBounds(@NotNull JetTypeReference typeReference, @NotNull JetType type) { + public void checkBounds(@NotNull JetTypeReference typeReference, @NotNull JetType type, BindingTrace trace) { if (ErrorUtils.isErrorType(type)) return; JetTypeElement typeElement = typeReference.getTypeElement(); @@ -886,10 +967,10 @@ public class DescriptorResolver { if (argumentTypeReference == null) continue; JetType typeArgument = arguments.get(i).getType(); - checkBounds(argumentTypeReference, typeArgument); + checkBounds(argumentTypeReference, typeArgument, trace); TypeParameterDescriptor typeParameterDescriptor = parameters.get(i); - checkBounds(argumentTypeReference, typeArgument, typeParameterDescriptor, substitutor); + checkBounds(argumentTypeReference, typeArgument, typeParameterDescriptor, substitutor, trace); } } @@ -897,10 +978,10 @@ public class DescriptorResolver { @NotNull JetTypeReference argumentTypeReference, @NotNull JetType typeArgument, @NotNull TypeParameterDescriptor typeParameterDescriptor, - @NotNull TypeSubstitutor substitutor) { + @NotNull TypeSubstitutor substitutor, BindingTrace trace) { for (JetType bound : typeParameterDescriptor.getUpperBounds()) { JetType substitutedBound = substitutor.safeSubstitute(bound, Variance.INVARIANT); - if (!semanticServices.getTypeChecker().isSubtypeOf(typeArgument, substitutedBound)) { + if (!JetTypeChecker.INSTANCE.isSubtypeOf(typeArgument, substitutedBound)) { trace.report(UPPER_BOUND_VIOLATED.on(argumentTypeReference, substitutedBound)); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java index 3ec7aa7d2ce..85732859908 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java @@ -20,11 +20,24 @@ import com.google.common.base.Predicate; import com.google.common.collect.Collections2; import com.google.common.collect.Lists; import com.google.common.collect.Maps; +import com.google.inject.Inject; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.descriptors.*; -import org.jetbrains.jet.lang.psi.*; -import org.jetbrains.jet.lang.resolve.scopes.*; +import org.jetbrains.jet.lang.Configuration; +import org.jetbrains.jet.lang.descriptors.ClassDescriptor; +import org.jetbrains.jet.lang.descriptors.ClassKind; +import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor; +import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; +import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; +import org.jetbrains.jet.lang.descriptors.VariableDescriptor; +import org.jetbrains.jet.lang.psi.JetDotQualifiedExpression; +import org.jetbrains.jet.lang.psi.JetExpression; +import org.jetbrains.jet.lang.psi.JetFile; +import org.jetbrains.jet.lang.psi.JetImportDirective; +import org.jetbrains.jet.lang.psi.JetQualifiedExpression; +import org.jetbrains.jet.lang.psi.JetSimpleNameExpression; +import org.jetbrains.jet.lang.resolve.scopes.JetScope; +import org.jetbrains.jet.lang.resolve.scopes.WritableScope; import org.jetbrains.jet.lang.types.JetType; import java.util.Collection; @@ -32,19 +45,35 @@ import java.util.Collections; import java.util.List; import java.util.Map; -import static org.jetbrains.jet.lang.diagnostics.Errors.*; +import static org.jetbrains.jet.lang.diagnostics.Errors.CANNOT_BE_IMPORTED; +import static org.jetbrains.jet.lang.diagnostics.Errors.CANNOT_IMPORT_FROM_ELEMENT; +import static org.jetbrains.jet.lang.diagnostics.Errors.NO_CLASS_OBJECT; +import static org.jetbrains.jet.lang.diagnostics.Errors.UNRESOLVED_REFERENCE; +import static org.jetbrains.jet.lang.diagnostics.Errors.UNSUPPORTED; +import static org.jetbrains.jet.lang.diagnostics.Errors.USELESS_HIDDEN_IMPORT; +import static org.jetbrains.jet.lang.diagnostics.Errors.USELESS_SIMPLE_IMPORT; /** * @author abreslav * @author svtk */ public class ImportsResolver { - private final TopDownAnalysisContext context; + @NotNull + private TopDownAnalysisContext context; + @NotNull + private Configuration configuration; - public ImportsResolver(@NotNull TopDownAnalysisContext context) { + @Inject + public void setContext(@NotNull TopDownAnalysisContext context) { this.context = context; } + @Inject + public void setConfiguration(@NotNull Configuration configuration) { + this.configuration = configuration; + } + + public void processTypeImports() { processImports(true); } @@ -64,7 +93,7 @@ public class ImportsResolver { } Map resolvedDirectives = Maps.newHashMap(); Collection defaultImportDirectives = Lists.newArrayList(); - context.getConfiguration().addDefaultImports(namespaceScope, defaultImportDirectives); + configuration.addDefaultImports(namespaceScope, defaultImportDirectives); for (JetImportDirective defaultImportDirective : defaultImportDirectives) { defaultImportResolver.processImportReference(defaultImportDirective, namespaceScope, delayedImporter); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverloadResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverloadResolver.java index 56b8a89c038..3d42fb34cbe 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverloadResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverloadResolver.java @@ -16,6 +16,7 @@ package org.jetbrains.jet.lang.resolve; +import com.google.inject.Inject; import com.intellij.openapi.util.Pair; import com.intellij.util.containers.MultiMap; import org.jetbrains.annotations.NotNull; @@ -35,12 +36,15 @@ import static org.jetbrains.jet.lang.resolve.BindingContext.DELEGATED; * @author Stepan Koltsov */ public class OverloadResolver { - private final TopDownAnalysisContext context; + private TopDownAnalysisContext context; - public OverloadResolver(@NotNull TopDownAnalysisContext context) { + + @Inject + public void setContext(TopDownAnalysisContext context) { this.context = context; } + public void process() { checkOverloads(); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java index 41abb3987b3..d85736c36b4 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java @@ -19,6 +19,7 @@ package org.jetbrains.jet.lang.resolve; import com.google.common.collect.Lists; import com.google.common.collect.Multimap; import com.google.common.collect.Sets; +import com.google.inject.Inject; import com.intellij.lang.ASTNode; import com.intellij.psi.PsiElement; import com.intellij.util.containers.MultiMap; @@ -43,12 +44,16 @@ import static org.jetbrains.jet.lang.resolve.BindingContext.DELEGATED; */ public class OverrideResolver { - private final TopDownAnalysisContext context; + private TopDownAnalysisContext context; - public OverrideResolver(@NotNull TopDownAnalysisContext context) { + + @Inject + public void setContext(TopDownAnalysisContext context) { this.context = context; } + + public void process() { generateOverrides(); checkOverrides(); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java index e8458a8bb6b..bd9ce72bab9 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java @@ -19,13 +19,27 @@ package org.jetbrains.jet.lang.resolve; import com.google.common.base.Predicate; import com.google.common.collect.Maps; import com.google.common.collect.Sets; +import com.google.inject.Guice; +import com.google.inject.Injector; +import com.intellij.openapi.project.Project; import com.intellij.psi.PsiElement; import com.intellij.psi.PsiFile; import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.Configuration; -import org.jetbrains.jet.lang.JetSemanticServices; -import org.jetbrains.jet.lang.descriptors.*; -import org.jetbrains.jet.lang.psi.*; +import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; +import org.jetbrains.jet.lang.descriptors.ConstructorDescriptor; +import org.jetbrains.jet.lang.descriptors.MutableClassDescriptor; +import org.jetbrains.jet.lang.descriptors.NamespaceDescriptorImpl; +import org.jetbrains.jet.lang.descriptors.PropertyDescriptor; +import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor; +import org.jetbrains.jet.lang.psi.JetClass; +import org.jetbrains.jet.lang.psi.JetDeclaration; +import org.jetbrains.jet.lang.psi.JetFile; +import org.jetbrains.jet.lang.psi.JetNamedFunction; +import org.jetbrains.jet.lang.psi.JetObjectDeclaration; +import org.jetbrains.jet.lang.psi.JetProperty; +import org.jetbrains.jet.lang.psi.JetSecondaryConstructor; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; @@ -36,14 +50,10 @@ import java.util.Set; /** * @author abreslav */ -/*package*/ class TopDownAnalysisContext { +public class TopDownAnalysisContext { private final ObservableBindingTrace trace; - private final JetSemanticServices semanticServices; - private final Configuration configuration; - private final DescriptorResolver descriptorResolver; - private final ImportsResolver importsResolver; private final Map classes = Maps.newLinkedHashMap(); private final Map objects = Maps.newLinkedHashMap(); protected final Map namespaceScopes = Maps.newHashMap(); @@ -58,17 +68,44 @@ import java.util.Set; private final Predicate analyzeCompletely; private StringBuilder debugOutput; - private boolean analyzingBootstrapLibrary = false; + private final boolean analyzingBootstrapLibrary; private boolean declaredLocally; - public TopDownAnalysisContext(JetSemanticServices semanticServices, BindingTrace trace, Predicate analyzeCompletely, @NotNull Configuration configuration, boolean declaredLocally) { + private final Injector injector; + + public TopDownAnalysisContext( + final Project project, + final BindingTrace trace, + Predicate analyzeCompletely, + @NotNull final Configuration configuration, + boolean declaredLocally, + boolean analyzingBootstrapLibrary, + @Nullable final JetControlFlowDataTraceFactory jetControlFlowDataTraceFactory) { + + if (analyzingBootstrapLibrary == (jetControlFlowDataTraceFactory != null)) { + throw new IllegalStateException( + "jetControlFlowDataTraceFactory must not be passed when analyzingBootstrapLibrary and vice versa"); + } + + injector = Guice.createInjector(new TopDownAnalysisModule(project, analyzingBootstrapLibrary) { + @Override + protected void configureAfter() { + bind(TopDownAnalysisContext.class).toInstance(TopDownAnalysisContext.this); + bind(Configuration.class).toInstance(configuration); + if (jetControlFlowDataTraceFactory != null) { + bind(JetControlFlowDataTraceFactory.class).toInstance(jetControlFlowDataTraceFactory); + } + } + }); + this.trace = new ObservableBindingTrace(trace); - this.semanticServices = semanticServices; - this.descriptorResolver = semanticServices.getClassDescriptorResolver(trace); - this.importsResolver = new ImportsResolver(this); this.analyzeCompletely = analyzeCompletely; - this.configuration = configuration; this.declaredLocally = declaredLocally; + this.analyzingBootstrapLibrary = analyzingBootstrapLibrary; + } + + public Injector getInjector() { + return injector; } public void debug(Object message) { @@ -93,10 +130,6 @@ import java.util.Set; return analyzingBootstrapLibrary; } - public void setAnalyzingBootstrapLibrary(boolean analyzingBootstrapLibrary) { - this.analyzingBootstrapLibrary = analyzingBootstrapLibrary; - } - public boolean completeAnalysisNeeded(@NotNull PsiElement element) { PsiFile containingFile = element.getContainingFile(); boolean result = containingFile != null && analyzeCompletely.apply(containingFile); @@ -106,22 +139,11 @@ import java.util.Set; return result; } + @NotNull public ObservableBindingTrace getTrace() { return trace; } - public JetSemanticServices getSemanticServices() { - return semanticServices; - } - - public DescriptorResolver getDescriptorResolver() { - return descriptorResolver; - } - - public ImportsResolver getImportsResolver() { - return importsResolver; - } - public Map getClasses() { return classes; } @@ -158,12 +180,8 @@ import java.util.Set; return functions; } - @NotNull - public Configuration getConfiguration() { - return configuration; - } - public boolean isDeclaredLocally() { return declaredLocally; } + } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisModule.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisModule.java new file mode 100644 index 00000000000..6c8bfecc7f1 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisModule.java @@ -0,0 +1,54 @@ +/* + * Copyright 2000-2012 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; + +import com.google.inject.AbstractModule; +import com.intellij.openapi.project.Project; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; + +/** + * @author Stepan Koltsov + */ +public abstract class TopDownAnalysisModule extends AbstractModule { + + @NotNull + private final Project project; + private final boolean analyzingStdlib; + + protected TopDownAnalysisModule(@NotNull Project project, boolean analyzingStdlib) { + this.project = project; + this.analyzingStdlib = analyzingStdlib; + } + + @Override + protected final void configure() { + binder().disableCircularProxies(); + + bind(Project.class).toInstance(project); + + if (!analyzingStdlib) { + // TODO: move outside + JetStandardLibrary.initialize(project); + bind(JetStandardLibrary.class).toInstance(JetStandardLibrary.getInstance()); + } + + configureAfter(); + } + + protected abstract void configureAfter(); +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java index 54b1f015220..aeafb180489 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java @@ -18,11 +18,12 @@ package org.jetbrains.jet.lang.resolve; import com.google.common.base.Predicate; import com.google.common.base.Predicates; +import com.google.inject.Inject; +import com.intellij.openapi.project.Project; import com.intellij.psi.PsiElement; import com.intellij.psi.PsiFile; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.Configuration; -import org.jetbrains.jet.lang.JetSemanticServices; import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.JetDeclaration; @@ -41,23 +42,59 @@ import java.util.List; */ public class TopDownAnalyzer { - private TopDownAnalyzer() {} + @NotNull + private DeclarationResolver declarationResolver; + @NotNull + private TypeHierarchyResolver typeHierarchyResolver; + @NotNull + private DelegationResolver delegationResolver; + @NotNull + private OverrideResolver overrideResolver; + @NotNull + private OverloadResolver overloadResolver; + + + @Inject + public void setDeclarationResolver(@NotNull DeclarationResolver declarationResolver) { + this.declarationResolver = declarationResolver; + } + + @Inject + public void setTypeHierarchyResolver(@NotNull TypeHierarchyResolver typeHierarchyResolver) { + this.typeHierarchyResolver = typeHierarchyResolver; + } + + @Inject + public void setDelegationResolver(@NotNull DelegationResolver delegationResolver) { + this.delegationResolver = delegationResolver; + } + + @Inject + public void setOverrideResolver(@NotNull OverrideResolver overrideResolver) { + this.overrideResolver = overrideResolver; + } + + @Inject + public void setOverloadResolver(@NotNull OverloadResolver overloadResolver) { + this.overloadResolver = overloadResolver; + } + + public static void process( - @NotNull JetSemanticServices semanticServices, - @NotNull BindingTrace trace, + Project project, @NotNull BindingTrace trace, @NotNull JetScope outerScope, @NotNull NamespaceLike owner, @NotNull Collection files, @NotNull Predicate analyzeCompletely, @NotNull JetControlFlowDataTraceFactory flowDataTraceFactory, @NotNull Configuration configuration - ) { - process(semanticServices, trace, outerScope, owner, files, analyzeCompletely, flowDataTraceFactory, configuration, false); + ) { + process(project, trace, outerScope, owner, files, analyzeCompletely, flowDataTraceFactory, configuration, false); } private static void process( - @NotNull JetSemanticServices semanticServices, + @NotNull Project project, @NotNull BindingTrace trace, @NotNull JetScope outerScope, @NotNull NamespaceLike owner, @@ -66,29 +103,31 @@ public class TopDownAnalyzer { @NotNull JetControlFlowDataTraceFactory flowDataTraceFactory, @NotNull Configuration configuration, boolean declaredLocally) { - TopDownAnalysisContext context = new TopDownAnalysisContext(semanticServices, trace, analyzeCompletely, configuration, declaredLocally); - doProcess(context, outerScope, owner, declarations, flowDataTraceFactory); + TopDownAnalysisContext context = new TopDownAnalysisContext(project, trace, analyzeCompletely, configuration, declaredLocally, false, flowDataTraceFactory); + context.getInjector().getInstance(TopDownAnalyzer.class).doProcess(context, outerScope, owner, declarations); } - private static void doProcess( + private void doProcess( TopDownAnalysisContext context, JetScope outerScope, NamespaceLike owner, - Collection declarations, - JetControlFlowDataTraceFactory flowDataTraceFactory) { + Collection declarations) { // context.enableDebugOutput(); context.debug("Enter"); - new TypeHierarchyResolver(context).process(outerScope, owner, declarations); - new DeclarationResolver(context).process(); - new DelegationResolver(context).process(); - new OverrideResolver(context).process(); + typeHierarchyResolver.process(outerScope, owner, declarations); + declarationResolver.process(); + delegationResolver.process(); + overrideResolver.process(); + lockScopes(context); - new OverloadResolver(context).process(); + + overloadResolver.process(); + if (!context.analyzingBootstrapLibrary()) { - new BodyResolver(context).resolveBehaviorDeclarationBodies(); - new ControlFlowAnalyzer(context, flowDataTraceFactory).process(); - new DeclarationsChecker(context).process(); + context.getInjector().getInstance(BodyResolver.class).resolveBehaviorDeclarationBodies(); + context.getInjector().getInstance(ControlFlowAnalyzer.class).process(); + context.getInjector().getInstance(DeclarationsChecker.class).process(); } context.debug("Exit"); @@ -109,12 +148,12 @@ public class TopDownAnalyzer { } public static void processStandardLibraryNamespace( - @NotNull JetSemanticServices semanticServices, + @NotNull Project project, @NotNull BindingTrace trace, @NotNull WritableScope outerScope, @NotNull NamespaceDescriptorImpl standardLibraryNamespace, @NotNull List files) { - TopDownAnalysisContext context = new TopDownAnalysisContext(semanticServices, trace, Predicates.alwaysTrue(), Configuration.EMPTY, false); + TopDownAnalysisContext context = new TopDownAnalysisContext(project, trace, Predicates.alwaysTrue(), Configuration.EMPTY, false, true, null); ArrayList toAnalyze = new ArrayList(); for(JetFile file : files) { context.getNamespaceDescriptors().put(file, standardLibraryNamespace); @@ -122,18 +161,17 @@ public class TopDownAnalyzer { toAnalyze.addAll(file.getDeclarations()); } // context.getDeclaringScopes().put(file, outerScope); - context.setAnalyzingBootstrapLibrary(true); - doProcess(context, outerScope, standardLibraryNamespace, toAnalyze, JetControlFlowDataTraceFactory.EMPTY); + context.getInjector().getInstance(TopDownAnalyzer.class).doProcess(context, outerScope, standardLibraryNamespace, toAnalyze); } public static void processObject( - @NotNull JetSemanticServices semanticServices, + @NotNull Project project, @NotNull BindingTrace trace, @NotNull JetScope outerScope, @NotNull DeclarationDescriptor containingDeclaration, @NotNull JetObjectDeclaration object) { - process(semanticServices, trace, outerScope, new NamespaceLike.Adapter(containingDeclaration) { + process(project, trace, outerScope, new NamespaceLike.Adapter(containingDeclaration) { @Override public NamespaceDescriptorImpl getNamespace(String name) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java index 91dd76e0d25..f256986a31f 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java @@ -19,11 +19,12 @@ package org.jetbrains.jet.lang.resolve; import com.google.common.collect.Lists; import com.google.common.collect.Multimap; import com.google.common.collect.Sets; -import com.intellij.lang.ASTNode; +import com.google.inject.Inject; import com.intellij.psi.PsiElement; import com.intellij.psi.PsiNameIdentifierOwner; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.lang.Configuration; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.psi.*; @@ -47,18 +48,45 @@ import static org.jetbrains.jet.lang.resolve.BindingContext.*; * @author abreslav */ public class TypeHierarchyResolver { - private final TopDownAnalysisContext context; + @NotNull + private TopDownAnalysisContext context; + @NotNull + private ImportsResolver importsResolver; + @NotNull + private DescriptorResolver descriptorResolver; + @NotNull + private Configuration configuration; + + + // state private LinkedList topologicalOrder; - public TypeHierarchyResolver(TopDownAnalysisContext context) { + @Inject + public void setContext(@NotNull TopDownAnalysisContext context) { this.context = context; } + @Inject + public void setImportsResolver(@NotNull ImportsResolver importsResolver) { + this.importsResolver = importsResolver; + } + + @Inject + public void setDescriptorResolver(@NotNull DescriptorResolver descriptorResolver) { + this.descriptorResolver = descriptorResolver; + } + + @Inject + public void setConfiguration(@NotNull Configuration configuration) { + this.configuration = configuration; + } + + public void process(@NotNull JetScope outerScope, @NotNull NamespaceLike owner, @NotNull Collection declarations) { collectNamespacesAndClassifiers(outerScope, outerScope, owner, declarations); // namespaceScopes, classes - context.getImportsResolver().processTypeImports(); + importsResolver.processTypeImports(); createTypeConstructors(); // create type constructors for classes and generic parameters, supertypes are not filled in resolveTypesInClassHeaders(); // Generic bounds and types in supertype lists (no expressions or constructor resolution) @@ -238,7 +266,7 @@ public class TypeHierarchyResolver { WritableScopeImpl scope = new WritableScopeImpl(JetScope.EMPTY, namespaceDescriptor, new TraceBasedRedeclarationHandler(context.getTrace())).setDebugName("Namespace member scope"); scope.changeLockLevel(WritableScope.LockLevel.BOTH); namespaceDescriptor.initialize(scope); - context.getConfiguration().extendNamespaceScope(context.getTrace(), namespaceDescriptor, scope); + configuration.extendNamespaceScope(context.getTrace(), namespaceDescriptor, scope); owner.addNamespace(namespaceDescriptor); if (file != null) { context.getTrace().record(BindingContext.NAMESPACE, file, namespaceDescriptor); @@ -260,7 +288,7 @@ public class TypeHierarchyResolver { for (Map.Entry entry : context.getClasses().entrySet()) { JetClass jetClass = entry.getKey(); MutableClassDescriptor descriptor = entry.getValue(); - context.getDescriptorResolver().resolveMutableClassDescriptor(jetClass, descriptor); + descriptorResolver.resolveMutableClassDescriptor(jetClass, descriptor, context.getTrace()); descriptor.createTypeConstructor(); } for (Map.Entry entry : context.getObjects().entrySet()) { @@ -277,13 +305,13 @@ public class TypeHierarchyResolver { for (Map.Entry entry : context.getClasses().entrySet()) { JetClass jetClass = entry.getKey(); MutableClassDescriptor descriptor = entry.getValue(); - context.getDescriptorResolver().resolveGenericBounds(jetClass, descriptor.getScopeForSupertypeResolution(), descriptor.getTypeConstructor().getParameters()); - context.getDescriptorResolver().resolveSupertypes(jetClass, descriptor); + descriptorResolver.resolveGenericBounds(jetClass, descriptor.getScopeForSupertypeResolution(), descriptor.getTypeConstructor().getParameters(), context.getTrace()); + descriptorResolver.resolveSupertypes(jetClass, descriptor, context.getTrace()); } for (Map.Entry entry : context.getObjects().entrySet()) { JetClassOrObject jetClass = entry.getKey(); MutableClassDescriptor descriptor = entry.getValue(); - context.getDescriptorResolver().resolveSupertypes(jetClass, descriptor); + descriptorResolver.resolveSupertypes(jetClass, descriptor, context.getTrace()); } } @@ -478,7 +506,7 @@ public class TypeHierarchyResolver { if (typeReference != null) { JetType type = context.getTrace().getBindingContext().get(TYPE, typeReference); if (type != null) { - context.getDescriptorResolver().checkBounds(typeReference, type); + descriptorResolver.checkBounds(typeReference, type, context.getTrace()); } } } @@ -488,7 +516,7 @@ public class TypeHierarchyResolver { if (extendsBound != null) { JetType type = context.getTrace().getBindingContext().get(TYPE, extendsBound); if (type != null) { - context.getDescriptorResolver().checkBounds(extendsBound, type); + descriptorResolver.checkBounds(extendsBound, type, context.getTrace()); } } } @@ -498,7 +526,7 @@ public class TypeHierarchyResolver { if (extendsBound != null) { JetType type = context.getTrace().getBindingContext().get(TYPE, extendsBound); if (type != null) { - context.getDescriptorResolver().checkBounds(extendsBound, type); + descriptorResolver.checkBounds(extendsBound, type, context.getTrace()); } } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.java index 7e37d9711c5..509a8be4424 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.java @@ -18,24 +18,44 @@ package org.jetbrains.jet.lang.resolve; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.JetSemanticServices; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; -import org.jetbrains.jet.lang.psi.*; +import org.jetbrains.jet.lang.psi.JetElement; +import org.jetbrains.jet.lang.psi.JetFunctionType; +import org.jetbrains.jet.lang.psi.JetNullableType; +import org.jetbrains.jet.lang.psi.JetParameter; +import org.jetbrains.jet.lang.psi.JetProjectionKind; +import org.jetbrains.jet.lang.psi.JetSimpleNameExpression; +import org.jetbrains.jet.lang.psi.JetTupleType; +import org.jetbrains.jet.lang.psi.JetTypeElement; +import org.jetbrains.jet.lang.psi.JetTypeProjection; +import org.jetbrains.jet.lang.psi.JetTypeReference; +import org.jetbrains.jet.lang.psi.JetUserType; +import org.jetbrains.jet.lang.psi.JetVisitorVoid; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.LazyScopeAdapter; -import org.jetbrains.jet.lang.types.*; +import org.jetbrains.jet.lang.types.ErrorUtils; +import org.jetbrains.jet.lang.types.JetType; +import org.jetbrains.jet.lang.types.JetTypeImpl; +import org.jetbrains.jet.lang.types.TypeConstructor; +import org.jetbrains.jet.lang.types.TypeProjection; +import org.jetbrains.jet.lang.types.TypeSubstitutor; +import org.jetbrains.jet.lang.types.TypeUtils; +import org.jetbrains.jet.lang.types.Variance; import org.jetbrains.jet.lang.types.lang.JetStandardClasses; import org.jetbrains.jet.util.lazy.LazyValue; +import javax.inject.Inject; import java.util.ArrayList; import java.util.Collections; import java.util.List; -import static org.jetbrains.jet.lang.diagnostics.Errors.*; +import static org.jetbrains.jet.lang.diagnostics.Errors.UNRESOLVED_REFERENCE; +import static org.jetbrains.jet.lang.diagnostics.Errors.UNSUPPORTED; +import static org.jetbrains.jet.lang.diagnostics.Errors.WRONG_NUMBER_OF_TYPE_ARGUMENTS; import static org.jetbrains.jet.lang.resolve.BindingContext.REFERENCE_TARGET; /** @@ -43,27 +63,28 @@ import static org.jetbrains.jet.lang.resolve.BindingContext.REFERENCE_TARGET; */ public class TypeResolver { - private final JetSemanticServices semanticServices; - private final BindingTrace trace; - private final boolean checkBounds; - private final AnnotationResolver annotationResolver; + private AnnotationResolver annotationResolver; + private DescriptorResolver descriptorResolver; - public TypeResolver(JetSemanticServices semanticServices, BindingTrace trace, boolean checkBounds) { - this.semanticServices = semanticServices; - this.trace = trace; - this.checkBounds = checkBounds; - this.annotationResolver = new AnnotationResolver(semanticServices, trace); + @Inject + public void setDescriptorResolver(DescriptorResolver descriptorResolver) { + this.descriptorResolver = descriptorResolver; + } + + @Inject + public void setAnnotationResolver(AnnotationResolver annotationResolver) { + this.annotationResolver = annotationResolver; } @NotNull - public JetType resolveType(@NotNull final JetScope scope, @NotNull final JetTypeReference typeReference) { + public JetType resolveType(@NotNull final JetScope scope, @NotNull final JetTypeReference typeReference, BindingTrace trace, boolean checkBounds) { JetType cachedType = trace.getBindingContext().get(BindingContext.TYPE, typeReference); if (cachedType != null) return cachedType; - final List annotations = annotationResolver.createAnnotationStubs(typeReference.getAnnotations()); + final List annotations = annotationResolver.createAnnotationStubs(typeReference.getAnnotations(), trace); JetTypeElement typeElement = typeReference.getTypeElement(); - JetType type = resolveTypeElement(scope, annotations, typeElement, false); + JetType type = resolveTypeElement(scope, annotations, typeElement, false, trace, checkBounds); trace.record(BindingContext.TYPE, typeReference, type); return type; @@ -71,7 +92,7 @@ public class TypeResolver { @NotNull private JetType resolveTypeElement(final JetScope scope, final List annotations, - JetTypeElement typeElement, final boolean nullable) { + JetTypeElement typeElement, final boolean nullable, final BindingTrace trace, final boolean checkBounds) { final JetType[] result = new JetType[1]; if (typeElement != null) { @@ -84,9 +105,9 @@ public class TypeResolver { return; } - ClassifierDescriptor classifierDescriptor = resolveClass(scope, type); + ClassifierDescriptor classifierDescriptor = resolveClass(scope, type, trace); if (classifierDescriptor == null) { - resolveTypeProjections(scope, ErrorUtils.createErrorType("No type").getConstructor(), type.getTypeArguments()); + resolveTypeProjections(scope, ErrorUtils.createErrorType("No type").getConstructor(), type.getTypeArguments(), trace, checkBounds); return; } @@ -95,7 +116,7 @@ public class TypeResolver { trace.record(BindingContext.REFERENCE_TARGET, referenceExpression, typeParameterDescriptor); - JetScope scopeForTypeParameter = getScopeForTypeParameter(typeParameterDescriptor); + JetScope scopeForTypeParameter = getScopeForTypeParameter(typeParameterDescriptor, checkBounds); if (scopeForTypeParameter instanceof ErrorUtils.ErrorScope) { result[0] = ErrorUtils.createErrorType("?"); } else { @@ -108,14 +129,14 @@ public class TypeResolver { ); } - resolveTypeProjections(scope, ErrorUtils.createErrorType("No type").getConstructor(), type.getTypeArguments()); + resolveTypeProjections(scope, ErrorUtils.createErrorType("No type").getConstructor(), type.getTypeArguments(), trace, checkBounds); } else if (classifierDescriptor instanceof ClassDescriptor) { ClassDescriptor classDescriptor = (ClassDescriptor) classifierDescriptor; trace.record(BindingContext.REFERENCE_TARGET, referenceExpression, classifierDescriptor); TypeConstructor typeConstructor = classifierDescriptor.getTypeConstructor(); - List arguments = resolveTypeProjections(scope, typeConstructor, type.getTypeArguments()); + List arguments = resolveTypeProjections(scope, typeConstructor, type.getTypeArguments(), trace, checkBounds); List parameters = typeConstructor.getParameters(); int expectedArgumentCount = parameters.size(); int actualArgumentCount = arguments.size(); @@ -145,7 +166,7 @@ public class TypeResolver { JetTypeReference typeReference = type.getTypeArguments().get(i).getTypeReference(); if (typeReference != null) { - semanticServices.getClassDescriptorResolver(trace).checkBounds(typeReference, argument, parameter, substitutor); + descriptorResolver.checkBounds(typeReference, argument, parameter, substitutor, trace); } } } @@ -156,29 +177,29 @@ public class TypeResolver { @Override public void visitNullableType(JetNullableType nullableType) { - result[0] = resolveTypeElement(scope, annotations, nullableType.getInnerType(), true); + result[0] = resolveTypeElement(scope, annotations, nullableType.getInnerType(), true, trace, checkBounds); } @Override public void visitTupleType(JetTupleType type) { // TODO labels - result[0] = JetStandardClasses.getTupleType(resolveTypes(scope, type.getComponentTypeRefs())); + result[0] = JetStandardClasses.getTupleType(resolveTypes(scope, type.getComponentTypeRefs(), trace, checkBounds)); } @Override public void visitFunctionType(JetFunctionType type) { JetTypeReference receiverTypeRef = type.getReceiverTypeRef(); - JetType receiverType = receiverTypeRef == null ? null : resolveType(scope, receiverTypeRef); + JetType receiverType = receiverTypeRef == null ? null : resolveType(scope, receiverTypeRef, trace, checkBounds); List parameterTypes = new ArrayList(); for (JetParameter parameter : type.getParameters()) { - parameterTypes.add(resolveType(scope, parameter.getTypeReference())); + parameterTypes.add(resolveType(scope, parameter.getTypeReference(), trace, checkBounds)); } JetTypeReference returnTypeRef = type.getReturnTypeRef(); JetType returnType; if (returnTypeRef != null) { - returnType = resolveType(scope, returnTypeRef); + returnType = resolveType(scope, returnTypeRef, trace, checkBounds); } else { returnType = JetStandardClasses.getUnitType(); @@ -202,7 +223,7 @@ public class TypeResolver { return result[0]; } - private JetScope getScopeForTypeParameter(final TypeParameterDescriptor typeParameterDescriptor) { + private JetScope getScopeForTypeParameter(final TypeParameterDescriptor typeParameterDescriptor, boolean checkBounds) { if (checkBounds) { return typeParameterDescriptor.getUpperBoundsAsType().getMemberScope(); } @@ -216,16 +237,16 @@ public class TypeResolver { } } - private List resolveTypes(JetScope scope, List argumentElements) { + private List resolveTypes(JetScope scope, List argumentElements, BindingTrace trace, boolean checkBounds) { final List arguments = new ArrayList(); for (JetTypeReference argumentElement : argumentElements) { - arguments.add(resolveType(scope, argumentElement)); + arguments.add(resolveType(scope, argumentElement, trace, checkBounds)); } return arguments; } @NotNull - private List resolveTypeProjections(JetScope scope, TypeConstructor constructor, List argumentElements) { + private List resolveTypeProjections(JetScope scope, TypeConstructor constructor, List argumentElements, BindingTrace trace, boolean checkBounds) { final List arguments = new ArrayList(); for (int i = 0, argumentElementsSize = argumentElements.size(); i < argumentElementsSize; i++) { JetTypeProjection argumentElement = argumentElements.get(i); @@ -244,7 +265,7 @@ public class TypeResolver { } else { // TODO : handle the Foo case - type = resolveType(scope, argumentElement.getTypeReference()); + type = resolveType(scope, argumentElement.getTypeReference(), trace, checkBounds); Variance kind = null; switch (projectionKind) { case IN: @@ -265,8 +286,8 @@ public class TypeResolver { } @Nullable - public ClassifierDescriptor resolveClass(JetScope scope, JetUserType userType) { - ClassifierDescriptor classifierDescriptor = resolveClassWithoutErrorReporting(scope, userType); + public ClassifierDescriptor resolveClass(JetScope scope, JetUserType userType, BindingTrace trace) { + ClassifierDescriptor classifierDescriptor = resolveClassWithoutErrorReporting(scope, userType, trace); if (classifierDescriptor == null) { trace.report(UNRESOLVED_REFERENCE.on(userType.getReferenceExpression())); @@ -279,7 +300,7 @@ public class TypeResolver { } @Nullable - private ClassifierDescriptor resolveClassWithoutErrorReporting(JetScope scope, JetUserType userType) { + private ClassifierDescriptor resolveClassWithoutErrorReporting(JetScope scope, JetUserType userType, BindingTrace trace) { JetSimpleNameExpression expression = userType.getReferenceExpression(); if (expression == null) { return null; @@ -292,12 +313,12 @@ public class TypeResolver { if (userType.isAbsoluteInRootNamespace()) { classifierDescriptor = JetModuleUtil.getRootNamespaceType(userType).getMemberScope().getClassifier(referencedName); trace.record(BindingContext.RESOLUTION_SCOPE, userType.getReferenceExpression(), - JetModuleUtil.getRootNamespaceType(userType).getMemberScope()); + JetModuleUtil.getRootNamespaceType(userType).getMemberScope()); } else { JetUserType qualifier = userType.getQualifier(); if (qualifier != null) { - scope = resolveClassLookupScope(scope, qualifier); + scope = resolveClassLookupScope(scope, qualifier, trace); } if (scope == null) { return ErrorUtils.getErrorClass(); @@ -310,8 +331,8 @@ public class TypeResolver { } @Nullable - private JetScope resolveClassLookupScope(JetScope scope, JetUserType userType) { - ClassifierDescriptor classifierDescriptor = resolveClassWithoutErrorReporting(scope, userType); + private JetScope resolveClassLookupScope(JetScope scope, JetUserType userType, BindingTrace trace) { + ClassifierDescriptor classifierDescriptor = resolveClassWithoutErrorReporting(scope, userType, trace); if (classifierDescriptor instanceof ClassDescriptor) { ClassDescriptor classDescriptor = (ClassDescriptor) classifierDescriptor; JetType classObjectType = classDescriptor.getClassObjectType(); @@ -320,7 +341,7 @@ public class TypeResolver { } } - NamespaceDescriptor namespaceDescriptor = resolveNamespace(scope, userType); + NamespaceDescriptor namespaceDescriptor = resolveNamespace(scope, userType, trace); if (namespaceDescriptor == null) { trace.report(UNRESOLVED_REFERENCE.on(userType.getReferenceExpression())); return null; @@ -329,15 +350,15 @@ public class TypeResolver { } @Nullable - private NamespaceDescriptor resolveNamespace(JetScope scope, JetUserType userType) { + private NamespaceDescriptor resolveNamespace(JetScope scope, JetUserType userType, BindingTrace trace) { if (userType.isAbsoluteInRootNamespace()) { - return resolveNamespace(JetModuleUtil.getRootNamespaceType(userType).getMemberScope(), userType); + return resolveNamespace(JetModuleUtil.getRootNamespaceType(userType).getMemberScope(), userType, trace); } JetUserType qualifier = userType.getQualifier(); NamespaceDescriptor namespace; if (qualifier != null) { - NamespaceDescriptor domain = resolveNamespace(scope, qualifier); + NamespaceDescriptor domain = resolveNamespace(scope, qualifier, trace); if (domain == null) { return null; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java index 49b62feb01c..6b7f413523c 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java @@ -19,10 +19,10 @@ package org.jetbrains.jet.lang.resolve.calls; import com.google.common.collect.Lists; import com.google.common.collect.Maps; import com.google.common.collect.Sets; +import com.google.inject.Inject; import com.intellij.lang.ASTNode; import com.intellij.psi.PsiElement; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.JetSemanticServices; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.*; @@ -33,6 +33,7 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; import org.jetbrains.jet.lang.types.*; +import org.jetbrains.jet.lang.types.checker.JetTypeChecker; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; import org.jetbrains.jet.lang.types.expressions.OperatorConventions; import org.jetbrains.jet.lang.types.lang.JetStandardClasses; @@ -56,22 +57,47 @@ import static org.jetbrains.jet.lang.types.TypeUtils.NO_EXPECTED_TYPE; public class CallResolver { private static final JetType DONT_CARE = ErrorUtils.createErrorTypeWithCustomDebugName("DONT_CARE"); - private final JetSemanticServices semanticServices; - private final OverloadingConflictResolver overloadingConflictResolver; - private final DataFlowInfo dataFlowInfo; + private final JetTypeChecker typeChecker = JetTypeChecker.INSTANCE; - public CallResolver(JetSemanticServices semanticServices, DataFlowInfo dataFlowInfo) { - this.semanticServices = semanticServices; - this.overloadingConflictResolver = new OverloadingConflictResolver(semanticServices); - this.dataFlowInfo = dataFlowInfo; + @NotNull + private OverloadingConflictResolver overloadingConflictResolver; + @NotNull + private ExpressionTypingServices expressionTypingServices; + @NotNull + private TypeResolver typeResolver; + @NotNull + private DescriptorResolver descriptorResolver; + + + @Inject + public void setOverloadingConflictResolver(@NotNull OverloadingConflictResolver overloadingConflictResolver) { + this.overloadingConflictResolver = overloadingConflictResolver; } + @Inject + public void setExpressionTypingServices(@NotNull ExpressionTypingServices expressionTypingServices) { + this.expressionTypingServices = expressionTypingServices; + } + + @Inject + public void setTypeResolver(@NotNull TypeResolver typeResolver) { + this.typeResolver = typeResolver; + } + + @Inject + public void setDescriptorResolver(@NotNull DescriptorResolver descriptorResolver) { + this.descriptorResolver = descriptorResolver; + } + + + @NotNull public OverloadResolutionResults resolveSimpleProperty( @NotNull BindingTrace trace, @NotNull JetScope scope, @NotNull Call call, - @NotNull JetType expectedType) { + @NotNull JetType expectedType, + @NotNull DataFlowInfo dataFlowInfo) { JetExpression calleeExpression = call.getCalleeExpression(); assert calleeExpression instanceof JetSimpleNameExpression; JetSimpleNameExpression nameExpression = (JetSimpleNameExpression) calleeExpression; @@ -88,7 +114,7 @@ public class CallResolver { task_prioritizer = TaskPrioritizers.VARIABLE_TASK_PRIORITIZER; } List> prioritizedTasks = task_prioritizer.computePrioritizedTasks(scope, call, referencedName, trace.getBindingContext(), dataFlowInfo); - return resolveCallToDescriptor(trace, scope, call, expectedType, prioritizedTasks, nameExpression); + return resolveCallToDescriptor(trace, scope, call, expectedType, prioritizedTasks, nameExpression, dataFlowInfo); } @NotNull @@ -96,9 +122,9 @@ public class CallResolver { @NotNull BindingTrace trace, @NotNull JetScope scope, @NotNull Call call, - @NotNull JetType expectedType - ) { - return resolveSimpleCallToFunctionDescriptor(trace, scope, call, expectedType); + @NotNull JetType expectedType, + @NotNull DataFlowInfo dataFlowInfo) { + return resolveSimpleCallToFunctionDescriptor(trace, scope, call, expectedType, dataFlowInfo); } @NotNull @@ -108,10 +134,10 @@ public class CallResolver { @NotNull final Call call, @NotNull final JetReferenceExpression functionReference, @NotNull String name, - @NotNull JetType expectedType) { + @NotNull JetType expectedType, DataFlowInfo dataFlowInfo) { List> tasks = TaskPrioritizers.FUNCTION_TASK_PRIORITIZER.computePrioritizedTasks( scope, call, name, trace.getBindingContext(), dataFlowInfo); - return doResolveCall(trace, scope, call, expectedType, tasks, functionReference); + return doResolveCall(trace, scope, call, expectedType, tasks, functionReference, dataFlowInfo); } @NotNull @@ -119,8 +145,8 @@ public class CallResolver { @NotNull BindingTrace trace, @NotNull JetScope scope, @NotNull final Call call, - @NotNull JetType expectedType - ) { + @NotNull JetType expectedType, + @NotNull DataFlowInfo dataFlowInfo) { List> prioritizedTasks; JetExpression calleeExpression = call.getCalleeExpression(); @@ -165,7 +191,7 @@ public class CallResolver { } JetTypeReference typeReference = expression.getTypeReference(); assert typeReference != null; - JetType constructedType = new TypeResolver(semanticServices, trace, true).resolveType(scope, typeReference); + JetType constructedType = typeResolver.resolveType(scope, typeReference, trace, true); DeclarationDescriptor declarationDescriptor = constructedType.getConstructor().getDeclarationDescriptor(); if (declarationDescriptor instanceof ClassDescriptor) { ClassDescriptor classDescriptor = (ClassDescriptor) declarationDescriptor; @@ -199,8 +225,7 @@ public class CallResolver { } else if (calleeExpression != null) { // Here we handle the case where the callee expression must be something of type function, e.g. (foo.bar())(1, 2) - ExpressionTypingServices typingServices = new ExpressionTypingServices(semanticServices, trace); - JetType calleeType = typingServices.safeGetType(scope, calleeExpression, NO_EXPECTED_TYPE); // We are actually expecting a function, but there seems to be no easy way of expressing this + JetType calleeType = expressionTypingServices.safeGetType(scope, calleeExpression, NO_EXPECTED_TYPE, trace); // We are actually expecting a function, but there seems to be no easy way of expressing this if (!JetStandardClasses.isFunctionType(calleeType)) { // checkTypesWithNoCallee(trace, scope, call); @@ -228,7 +253,7 @@ public class CallResolver { } } - return resolveCallToDescriptor(trace, scope, call, expectedType, prioritizedTasks, functionReference); + return resolveCallToDescriptor(trace, scope, call, expectedType, prioritizedTasks, functionReference, dataFlowInfo); } private OverloadResolutionResults checkArgumentTypesAndFail(BindingTrace trace, JetScope scope, Call call) { @@ -243,8 +268,9 @@ public class CallResolver { @NotNull final Call call, @NotNull JetType expectedType, @NotNull final List> prioritizedTasks, // high to low priority - @NotNull final JetReferenceExpression reference) { - return doResolveCall(trace, scope, call, expectedType, prioritizedTasks, reference); + @NotNull final JetReferenceExpression reference, + @NotNull DataFlowInfo dataFlowInfo) { + return doResolveCall(trace, scope, call, expectedType, prioritizedTasks, reference, dataFlowInfo); } @NotNull @@ -254,7 +280,8 @@ public class CallResolver { @NotNull final Call call, @NotNull JetType expectedType, @NotNull final List> prioritizedTasks, // high to low priority - @NotNull final JetReferenceExpression reference) { + @NotNull final JetReferenceExpression reference, + @NotNull DataFlowInfo dataFlowInfo) { ResolutionDebugInfo.Data debugInfo = ResolutionDebugInfo.create(); trace.record(ResolutionDebugInfo.RESOLUTION_DEBUG_INFO, call.getCallElement(), debugInfo); @@ -402,7 +429,7 @@ public class CallResolver { OverloadResolutionResultsImpl resultsForFirstNonemptyCandidateSet = null; for (ResolutionTask task : prioritizedTasks) { TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create(trace); - OverloadResolutionResultsImpl results = performResolutionGuardedForExtraFunctionLiteralArguments(temporaryTrace, scope, expectedType, task, tracing); + OverloadResolutionResultsImpl results = performResolutionGuardedForExtraFunctionLiteralArguments(temporaryTrace, scope, expectedType, task, tracing, dataFlowInfo); if (results.isSuccess()) { temporaryTrace.commit(); @@ -435,9 +462,9 @@ public class CallResolver { private OverloadResolutionResultsImpl performResolutionGuardedForExtraFunctionLiteralArguments( @NotNull BindingTrace trace, @NotNull JetScope scope, @NotNull JetType expectedType, - @NotNull ResolutionTask task, @NotNull TracingStrategy tracing + @NotNull ResolutionTask task, @NotNull TracingStrategy tracing, @NotNull DataFlowInfo dataFlowInfo ) { - OverloadResolutionResultsImpl results = performResolution(trace, scope, expectedType, task, tracing); + OverloadResolutionResultsImpl results = performResolution(trace, scope, expectedType, task, tracing, dataFlowInfo); // If resolution fails, we should check for some of the following situations: // class A { @@ -471,7 +498,7 @@ public class CallResolver { return Collections.emptyList(); } }, task.getDataFlowInfo()); - OverloadResolutionResultsImpl resultsWithFunctionLiteralsStripped = performResolution(TemporaryBindingTrace.create(trace), scope, expectedType, newTask, tracing); + OverloadResolutionResultsImpl resultsWithFunctionLiteralsStripped = performResolution(TemporaryBindingTrace.create(trace), scope, expectedType, newTask, tracing, dataFlowInfo); if (resultsWithFunctionLiteralsStripped.isSuccess() || resultsWithFunctionLiteralsStripped.isAmbiguity()) { tracing.danglingFunctionLiteralArgumentSuspected(trace, task.getCall().getFunctionLiteralArguments()); } @@ -484,7 +511,7 @@ public class CallResolver { private OverloadResolutionResultsImpl performResolution( @NotNull BindingTrace trace, @NotNull JetScope scope, @NotNull JetType expectedType, - @NotNull ResolutionTask task, @NotNull TracingStrategy tracing + @NotNull ResolutionTask task, @NotNull TracingStrategy tracing, DataFlowInfo dataFlowInfo ) { for (ResolvedCallImpl candidateCall : task.getCandidates()) { D candidate = candidateCall.getCandidateDescriptor(); @@ -544,8 +571,7 @@ public class CallResolver { // and throw the results away // We'll type check the arguments later, with the inferred types expected TemporaryBindingTrace traceForUnknown = TemporaryBindingTrace.create(temporaryTrace); - ExpressionTypingServices temporaryServices = new ExpressionTypingServices(semanticServices, traceForUnknown); - JetType type = temporaryServices.getType(scope, expression, substituteDontCare.substitute(valueParameterDescriptor.getType(), Variance.INVARIANT)); + JetType type = expressionTypingServices.getType(scope, expression, substituteDontCare.substitute(valueParameterDescriptor.getType(), Variance.INVARIANT), traceForUnknown); if (type != null && !ErrorUtils.isErrorType(type)) { constraintSystem.addSubtypingConstraint(VALUE_ARGUMENT.assertSubtyping(type, effectiveExpectedType)); } @@ -581,17 +607,17 @@ public class CallResolver { } // Here we type check the arguments with inferred types expected - checkValueArgumentTypes(scope, candidateCall); + checkValueArgumentTypes(scope, candidateCall, dataFlowInfo); candidateCall.setStatus(SUCCESS); } else { tracing.typeInferenceFailed(temporaryTrace, solution.getStatus()); - candidateCall.setStatus(OTHER_ERROR.combine(checkAllValueArguments(scope, tracing, task, candidateCall))); + candidateCall.setStatus(OTHER_ERROR.combine(checkAllValueArguments(scope, tracing, task, candidateCall, dataFlowInfo))); } } else { - candidateCall.setStatus(checkAllValueArguments(scope, tracing, task, candidateCall)); + candidateCall.setStatus(checkAllValueArguments(scope, tracing, task, candidateCall, dataFlowInfo)); } } else { @@ -604,7 +630,7 @@ public class CallResolver { } JetTypeReference typeReference = projection.getTypeReference(); if (typeReference != null) { - typeArguments.add(new TypeResolver(semanticServices, temporaryTrace, true).resolveType(scope, typeReference)); + typeArguments.add(typeResolver.resolveType(scope, typeReference, temporaryTrace, true)); } } int expectedTypeArgumentCount = candidate.getTypeParameters().size(); @@ -623,7 +649,7 @@ public class CallResolver { TypeParameterDescriptor typeParameterDescriptor = typeParameters.get(i); candidateCall.recordTypeArgument(typeParameterDescriptor, typeArguments.get(i)); } - candidateCall.setStatus(checkAllValueArguments(scope, tracing, task, candidateCall)); + candidateCall.setStatus(checkAllValueArguments(scope, tracing, task, candidateCall, dataFlowInfo)); } else { candidateCall.setStatus(OTHER_ERROR); @@ -693,20 +719,19 @@ public class CallResolver { } private void checkTypesWithNoCallee(BindingTrace trace, JetScope scope, Call call) { - ExpressionTypingServices typeInferrerServices = new ExpressionTypingServices(semanticServices, trace); for (ValueArgument valueArgument : call.getValueArguments()) { JetExpression argumentExpression = valueArgument.getArgumentExpression(); if (argumentExpression != null) { - typeInferrerServices.getType(scope, argumentExpression, NO_EXPECTED_TYPE); + expressionTypingServices.getType(scope, argumentExpression, NO_EXPECTED_TYPE, trace); } } for (JetExpression expression : call.getFunctionLiteralArguments()) { - typeInferrerServices.getType(scope, expression, NO_EXPECTED_TYPE); + expressionTypingServices.getType(scope, expression, NO_EXPECTED_TYPE, trace); } for (JetTypeProjection typeProjection : call.getTypeArguments()) { - new TypeResolver(semanticServices, trace, true).resolveType(scope, typeProjection.getTypeReference()); + typeResolver.resolveType(scope, typeProjection.getTypeReference(), trace, true); } } @@ -728,8 +753,8 @@ public class CallResolver { } } - private ResolutionStatus checkAllValueArguments(JetScope scope, TracingStrategy tracing, ResolutionTask task, ResolvedCallImpl candidateCall) { - ResolutionStatus result = checkValueArgumentTypes(scope, candidateCall); + private ResolutionStatus checkAllValueArguments(JetScope scope, TracingStrategy tracing, ResolutionTask task, ResolvedCallImpl candidateCall, DataFlowInfo dataFlowInfo) { + ResolutionStatus result = checkValueArgumentTypes(scope, candidateCall, dataFlowInfo); result = result.combine(checkReceiver(tracing, candidateCall, candidateCall.getResultingDescriptor().getReceiverParameter(), candidateCall.getReceiverArgument(), task)); result = result.combine(checkReceiver(tracing, candidateCall, candidateCall.getResultingDescriptor().getExpectedThisObject(), candidateCall.getThisObject(), task)); return result; @@ -752,7 +777,7 @@ public class CallResolver { JetType effectiveReceiverArgumentType = safeAccess ? TypeUtils.makeNotNullable(receiverArgumentType) : receiverArgumentType; - if (!semanticServices.getTypeChecker().isSubtypeOf(effectiveReceiverArgumentType, receiverParameter.getType())) { + if (!typeChecker.isSubtypeOf(effectiveReceiverArgumentType, receiverParameter.getType())) { tracing.wrongReceiverType(candidateCall.getTrace(), receiverParameter, receiverArgument); result = OTHER_ERROR; } @@ -765,7 +790,7 @@ public class CallResolver { return result; } - private ResolutionStatus checkValueArgumentTypes(JetScope scope, ResolvedCallImpl candidateCall) { + private ResolutionStatus checkValueArgumentTypes(JetScope scope, ResolvedCallImpl candidateCall, DataFlowInfo dataFlowInfo) { ResolutionStatus result = SUCCESS; for (Map.Entry entry : candidateCall.getValueArguments().entrySet()) { ValueParameterDescriptor parameterDescriptor = entry.getKey(); @@ -775,12 +800,11 @@ public class CallResolver { List argumentExpressions = resolvedArgument.getArgumentExpressions(); for (JetExpression argumentExpression : argumentExpressions) { - ExpressionTypingServices temporaryServices = new ExpressionTypingServices(semanticServices, candidateCall.getTrace()); - JetType type = temporaryServices.getType(scope, argumentExpression, parameterType, dataFlowInfo); + JetType type = expressionTypingServices.getType(scope, argumentExpression, parameterType, dataFlowInfo, candidateCall.getTrace()); if (type == null || ErrorUtils.isErrorType(type)) { candidateCall.argumentHasNoType(); } - else if (!semanticServices.getTypeChecker().isSubtypeOf(type, parameterType)) { + else if (!typeChecker.isSubtypeOf(type, parameterType)) { // VariableDescriptor variableDescriptor = AutoCastUtils.getVariableDescriptorFromSimpleName(temporaryTrace.getBindingContext(), argumentExpression); // if (variableDescriptor != null) { // JetType autoCastType = null; @@ -935,7 +959,7 @@ public class CallResolver { JetType typeArgument = typeArguments.get(i); JetTypeReference typeReference = jetTypeArguments.get(i).getTypeReference(); assert typeReference != null; - semanticServices.getClassDescriptorResolver(trace).checkBounds(typeReference, typeArgument, typeParameterDescriptor, substitutor); + descriptorResolver.checkBounds(typeReference, typeArgument, typeParameterDescriptor, substitutor, trace); } } @@ -1003,7 +1027,7 @@ public class CallResolver { ReceiverDescriptor functionReceiver = functionDescriptor.getReceiverParameter(); if (!functionReceiver.exists()) continue; if (!functionDescriptor.getTypeParameters().isEmpty()) continue; - if (!semanticServices.getTypeChecker().isSubtypeOf(receiver.getType(), functionReceiver.getType())) continue; + if (!typeChecker.isSubtypeOf(receiver.getType(), functionReceiver.getType())) continue; if (!checkValueParameters(functionDescriptor, parameterTypes))continue; result.add(resolvedCall); found = true; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadingConflictResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadingConflictResolver.java index 7a50d3b6b5a..e04f4559e8d 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadingConflictResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadingConflictResolver.java @@ -20,16 +20,17 @@ import gnu.trove.THashSet; import gnu.trove.TObjectHashingStrategy; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.JetSemanticServices; import org.jetbrains.jet.lang.descriptors.CallableDescriptor; import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.OverridingUtil; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; +import org.jetbrains.jet.lang.types.checker.JetTypeChecker; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.TypeUtils; +import javax.inject.Inject; import java.util.List; import java.util.Set; @@ -38,12 +39,6 @@ import java.util.Set; */ public class OverloadingConflictResolver { - private final JetSemanticServices semanticServices; - - public OverloadingConflictResolver(@NotNull JetSemanticServices semanticServices) { - this.semanticServices = semanticServices; - } - @Nullable public ResolvedCallImpl findMaximallySpecific(Set> candidates, boolean discriminateGenericDescriptors) { // Different autocasts may lead to the same candidate descriptor wrapped into different ResolvedCallImpl objects @@ -128,12 +123,12 @@ public class OverloadingConflictResolver { } private boolean typeMoreSpecific(@NotNull JetType specific, @NotNull JetType general) { - return semanticServices.getTypeChecker().isSubtypeOf(specific, general) || + return JetTypeChecker.INSTANCE.isSubtypeOf(specific, general) || numericTypeMoreSpecific(specific, general); } private boolean numericTypeMoreSpecific(@NotNull JetType specific, @NotNull JetType general) { - JetStandardLibrary standardLibrary = semanticServices.getStandardLibrary(); + JetStandardLibrary standardLibrary = JetStandardLibrary.getInstance(); JetType _double = standardLibrary.getDoubleType(); JetType _float = standardLibrary.getFloatType(); JetType _long = standardLibrary.getLongType(); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowInfo.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowInfo.java index 1633eac6468..da2db981af3 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowInfo.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowInfo.java @@ -53,6 +53,7 @@ public class DataFlowInfo { public static DataFlowInfo EMPTY = new DataFlowInfo(ImmutableMap.of(), Multimaps.newListMultimap(Collections.>emptyMap(), CommonSuppliers.getArrayListSupplier())); private final ImmutableMap nullabilityInfo; + /** Also immutable */ private final ListMultimap typeInfo; private DataFlowInfo(ImmutableMap nullabilityInfo, ListMultimap typeInfo) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/CompileTimeConstantResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/CompileTimeConstantResolver.java index 686fab15bdb..febee59455a 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/CompileTimeConstantResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/CompileTimeConstantResolver.java @@ -19,7 +19,6 @@ package org.jetbrains.jet.lang.resolve.constants; import com.google.common.base.Function; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.JetSemanticServices; import org.jetbrains.jet.lang.psi.JetEscapeStringTemplateEntry; import org.jetbrains.jet.lang.psi.JetLiteralStringTemplateEntry; import org.jetbrains.jet.lang.psi.JetStringTemplateEntry; @@ -38,17 +37,16 @@ import java.util.List; public class CompileTimeConstantResolver { public static final ErrorValue OUT_OF_RANGE = new ErrorValue("The value is out of range"); - private final JetSemanticServices semanticServices; + private final JetStandardLibrary standardLibrary; private final BindingTrace trace; - public CompileTimeConstantResolver(@NotNull JetSemanticServices semanticServices, @NotNull BindingTrace trace) { - this.semanticServices = semanticServices; + public CompileTimeConstantResolver(@NotNull BindingTrace trace) { + this.standardLibrary = JetStandardLibrary.getInstance(); this.trace = trace; } @NotNull public CompileTimeConstant getIntegerValue(@NotNull String text, @NotNull JetType expectedType) { - JetStandardLibrary standardLibrary = semanticServices.getStandardLibrary(); if (noExpectedType(expectedType)) { Long value = parseLongValue(text); if (value == null) { @@ -85,7 +83,7 @@ public class CompileTimeConstantResolver { upperBound = Byte.MAX_VALUE; } else { - JetTypeChecker typeChecker = semanticServices.getTypeChecker(); + JetTypeChecker typeChecker = JetTypeChecker.INSTANCE; JetType intType = standardLibrary.getIntType(); JetType longType = standardLibrary.getLongType(); if (typeChecker.isSubtypeOf(intType, expectedType)) { @@ -130,9 +128,8 @@ public class CompileTimeConstantResolver { @NotNull public CompileTimeConstant getFloatValue(@NotNull String text, @NotNull JetType expectedType) { - JetStandardLibrary standardLibrary = semanticServices.getStandardLibrary(); if (noExpectedType(expectedType) - || semanticServices.getTypeChecker().isSubtypeOf(standardLibrary.getDoubleType(), expectedType)) { + || JetTypeChecker.INSTANCE.isSubtypeOf(standardLibrary.getDoubleType(), expectedType)) { try { return new DoubleValue(Double.parseDouble(text)); } @@ -140,7 +137,7 @@ public class CompileTimeConstantResolver { return OUT_OF_RANGE; } } - else if (semanticServices.getTypeChecker().isSubtypeOf(standardLibrary.getFloatType(), expectedType)) { + else if (JetTypeChecker.INSTANCE.isSubtypeOf(standardLibrary.getFloatType(), expectedType)) { try { return new DoubleValue(Float.parseFloat(text)); } @@ -156,7 +153,7 @@ public class CompileTimeConstantResolver { @Nullable private CompileTimeConstant checkNativeType(String text, JetType expectedType, String title, JetType nativeType) { if (!noExpectedType(expectedType) - && !semanticServices.getTypeChecker().isSubtypeOf(nativeType, expectedType)) { + && !JetTypeChecker.INSTANCE.isSubtypeOf(nativeType, expectedType)) { return new ErrorValue("A " + title + " literal " + text + " does not conform to the expected type " + expectedType); } return null; @@ -164,7 +161,7 @@ public class CompileTimeConstantResolver { @NotNull public CompileTimeConstant getBooleanValue(@NotNull String text, @NotNull JetType expectedType) { - CompileTimeConstant error = checkNativeType(text, expectedType, "boolean", semanticServices.getStandardLibrary().getBooleanType()); + CompileTimeConstant error = checkNativeType(text, expectedType, "boolean", standardLibrary.getBooleanType()); if (error != null) { return error; } @@ -179,7 +176,7 @@ public class CompileTimeConstantResolver { @NotNull public CompileTimeConstant getCharValue(@NotNull String text, @NotNull JetType expectedType) { - CompileTimeConstant error = checkNativeType(text, expectedType, "character", semanticServices.getStandardLibrary().getCharType()); + CompileTimeConstant error = checkNativeType(text, expectedType, "character", standardLibrary.getCharType()); if (error != null) { return error; } @@ -265,7 +262,7 @@ public class CompileTimeConstantResolver { @NotNull public CompileTimeConstant getRawStringValue(@NotNull String unescapedText, @NotNull JetType expectedType) { - CompileTimeConstant error = checkNativeType("\"\"\"...\"\"\"", expectedType, "string", semanticServices.getStandardLibrary().getStringType()); + CompileTimeConstant error = checkNativeType("\"\"\"...\"\"\"", expectedType, "string", standardLibrary.getStringType()); if (error != null) { return error; } @@ -275,7 +272,7 @@ public class CompileTimeConstantResolver { @NotNull public CompileTimeConstant getEscapedStringValue(@NotNull List entries, @NotNull JetType expectedType) { - CompileTimeConstant error = checkNativeType("\"...\"", expectedType, "string", semanticServices.getStandardLibrary().getStringType()); + CompileTimeConstant error = checkNativeType("\"...\"", expectedType, "string", standardLibrary.getStringType()); if (error != null) { return error; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java index a5bbacca2fa..5c69de4a3a6 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java @@ -147,7 +147,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { ASTNode node = expression.getNode(); IElementType elementType = node.getElementType(); String text = node.getText(); - JetStandardLibrary standardLibrary = context.semanticServices.getStandardLibrary(); + JetStandardLibrary standardLibrary = JetStandardLibrary.getInstance(); CompileTimeConstantResolver compileTimeConstantResolver = context.getCompileTimeConstantResolver(); CompileTimeConstant value; @@ -172,7 +172,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { if (value instanceof ErrorValue) { ErrorValue errorValue = (ErrorValue) value; context.trace.report(ERROR_COMPILE_TIME_VALUE.on(node.getPsi(), errorValue.getMessage())); - return getDefaultType(context.semanticServices, elementType); + return getDefaultType(elementType); } else { context.trace.record(BindingContext.COMPILE_TIME_VALUE, expression, value); @@ -185,7 +185,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { JetTypeReference right = expression.getRight(); JetType result = null; if (right != null) { - JetType targetType = context.getTypeResolver().resolveType(context.scope, right); + JetType targetType = context.expressionTypingServices.getTypeResolver().resolveType(context.scope, right, context.trace, true); if (isTypeFlexible(expression.getLeft())) { TemporaryBindingTrace temporaryTraceWithExpectedType = TemporaryBindingTrace.create(context.trace); @@ -223,7 +223,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { JetSimpleNameExpression operationSign = expression.getOperationSign(); IElementType operationType = operationSign.getReferencedNameElementType(); if (operationType == JetTokens.COLON) { - if (targetType != NO_EXPECTED_TYPE && !context.semanticServices.getTypeChecker().isSubtypeOf(actualType, targetType)) { + if (targetType != NO_EXPECTED_TYPE && !JetTypeChecker.INSTANCE.isSubtypeOf(actualType, targetType)) { context.trace.report(TYPE_MISMATCH.on(expression.getLeft(), targetType, actualType)); return false; } @@ -242,7 +242,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { private void checkForCastImpossibility(JetBinaryExpressionWithTypeRHS expression, JetType actualType, JetType targetType, ExpressionTypingContext context) { if (actualType == null || targetType == NO_EXPECTED_TYPE) return; - JetTypeChecker typeChecker = context.semanticServices.getTypeChecker(); + JetTypeChecker typeChecker = JetTypeChecker.INSTANCE; if (!typeChecker.isSubtypeOf(targetType, actualType)) { if (typeChecker.isSubtypeOf(actualType, targetType)) { context.trace.report(USELESS_CAST_STATIC_ASSERT_IS_FINE.on(expression.getOperationSign())); @@ -346,7 +346,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { List entries = expression.getEntries(); List types = new ArrayList(); for (JetExpression entry : entries) { - types.add(context.getServices().safeGetType(context.scope, entry, NO_EXPECTED_TYPE)); // TODO + types.add(context.expressionTypingServices.safeGetType(context.scope, entry, NO_EXPECTED_TYPE, context.trace)); // TODO } if (context.expectedType != NO_EXPECTED_TYPE && JetStandardClasses.isTupleType(context.expectedType)) { List enrichedTypes = checkArgumentTypes(types, entries, context.expectedType.getArguments(), context); @@ -417,15 +417,15 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { JetUserType userType = (JetUserType) typeElement; // This may be just a superclass name even if the superclass is generic if (userType.getTypeArguments().isEmpty()) { - classifierCandidate = context.getTypeResolver().resolveClass(context.scope, userType); + classifierCandidate = context.expressionTypingServices.getTypeResolver().resolveClass(context.scope, userType, context.trace); } else { - supertype = context.getTypeResolver().resolveType(context.scope, superTypeQualifier); + supertype = context.expressionTypingServices.getTypeResolver().resolveType(context.scope, superTypeQualifier, context.trace, true); redundantTypeArguments = userType.getTypeArgumentList(); } } else { - supertype = context.getTypeResolver().resolveType(context.scope, superTypeQualifier); + supertype = context.expressionTypingServices.getTypeResolver().resolveType(context.scope, superTypeQualifier, context.trace, true); } if (supertype != null) { @@ -505,7 +505,9 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { } public JetType visitBlockExpression(JetBlockExpression expression, ExpressionTypingContext context, boolean isStatement) { - return context.getServices().getBlockReturnedType(context.scope, expression, isStatement ? CoercionStrategy.COERCION_TO_UNIT : CoercionStrategy.NO_COERCION, context); + return context.expressionTypingServices.getBlockReturnedType(context.scope, expression, isStatement + ? CoercionStrategy.COERCION_TO_UNIT + : CoercionStrategy.NO_COERCION, context, context.trace); } @Override @@ -544,9 +546,9 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { JetType result; if (expression.getOperationSign() == JetTokens.QUEST) { - if (selectorReturnType != null && !isBoolean(context.semanticServices, selectorReturnType)) { + if (selectorReturnType != null && !isBoolean(selectorReturnType)) { // TODO : more comprehensible error message - context.trace.report(TYPE_MISMATCH.on(selectorExpression, context.semanticServices.getStandardLibrary().getBooleanType(), selectorReturnType)); + context.trace.report(TYPE_MISMATCH.on(selectorExpression, JetStandardLibrary.getInstance().getBooleanType(), selectorReturnType)); } result = TypeUtils.makeNullable(receiverType); } @@ -566,7 +568,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { CompileTimeConstant wholeExpressionValue = context.trace.getBindingContext().get(BindingContext.COMPILE_TIME_VALUE, expression); DeclarationDescriptor declarationDescriptor = context.trace.getBindingContext().get(BindingContext.REFERENCE_TARGET, selectorExpression); if (wholeExpressionValue == null && receiverValue != null && !(receiverValue instanceof ErrorValue) && receiverValue.getValue() instanceof Number - && context.semanticServices.getStandardLibrary().getNumber() == declarationDescriptor) { + && JetStandardLibrary.getInstance().getNumber() == declarationDescriptor) { Number value = (Number) receiverValue.getValue(); String referencedName = selectorExpression.getReferencedName(); if (OperatorConventions.NUMBER_CONVERSIONS.contains(referencedName)) { @@ -707,13 +709,13 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { JetType returnType = functionDescriptor.getResultingDescriptor().getReturnType(); JetType result; if (operationType == JetTokens.PLUSPLUS || operationType == JetTokens.MINUSMINUS) { - if (context.semanticServices.getTypeChecker().isSubtypeOf(returnType, JetStandardClasses.getUnitType())) { + if (JetTypeChecker.INSTANCE.isSubtypeOf(returnType, JetStandardClasses.getUnitType())) { result = JetStandardClasses.getUnitType(); context.trace.report(INC_DEC_SHOULD_NOT_RETURN_UNIT.on(operationSign)); } else { JetType receiverType = receiver.getType(); - if (!context.semanticServices.getTypeChecker().isSubtypeOf(returnType, receiverType)) { + if (!JetTypeChecker.INSTANCE.isSubtypeOf(returnType, receiverType)) { context.trace.report(RESULT_TYPE_MISMATCH.on(operationSign, name, receiverType, returnType)); } else { @@ -785,7 +787,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { JetType compareToReturnType = getTypeForBinaryCall(context.scope, "compareTo", context, expression); if (compareToReturnType != null) { TypeConstructor constructor = compareToReturnType.getConstructor(); - JetStandardLibrary standardLibrary = context.semanticServices.getStandardLibrary(); + JetStandardLibrary standardLibrary = JetStandardLibrary.getInstance(); TypeConstructor intTypeConstructor = standardLibrary.getInt().getTypeConstructor(); if (constructor.equals(intTypeConstructor)) { result = standardLibrary.getBooleanType(); @@ -795,7 +797,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { } } else { - JetType booleanType = context.semanticServices.getStandardLibrary().getBooleanType(); + JetType booleanType = JetStandardLibrary.getInstance().getBooleanType(); if (OperatorConventions.EQUALS_OPERATIONS.contains(operationType)) { String name = "equals"; if (right != null) { @@ -841,10 +843,10 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { DataFlowInfo flowInfoLeft = DataFlowUtils.extractDataFlowInfoFromCondition(left, operationType == JetTokens.ANDAND, leftScope, context); // TODO: This gets computed twice: here and in extractDataFlowInfoFromCondition() for the whole condition WritableScopeImpl rightScope = operationType == JetTokens.ANDAND ? leftScope : newWritableScopeImpl(context).setDebugName("Right scope of && or ||"); JetType rightType = right == null ? null : facade.getType(right, context.replaceDataFlowInfo(flowInfoLeft).replaceScope(rightScope)); - if (leftType != null && !isBoolean(context.semanticServices, leftType)) { + if (leftType != null && !isBoolean(leftType)) { context.trace.report(TYPE_MISMATCH.on(left, booleanType, leftType)); } - if (rightType != null && !isBoolean(context.semanticServices, rightType)) { + if (rightType != null && !isBoolean(rightType)) { context.trace.report(TYPE_MISMATCH.on(right, booleanType, rightType)); } result = booleanType; @@ -892,7 +894,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { JetType rightType = facade.getType(right, context.replaceScope(context.scope)); if (rightType != null) { - JetType intersect = TypeUtils.intersect(context.semanticServices.getTypeChecker(), new HashSet(Arrays.asList(leftType, rightType))); + JetType intersect = TypeUtils.intersect(JetTypeChecker.INSTANCE, new HashSet(Arrays.asList(leftType, rightType))); if (intersect == null) { context.trace.report(EQUALITY_NOT_APPLICABLE.on(expression, operationSign, leftType, rightType)); } @@ -993,7 +995,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { if (value[0] != CompileTimeConstantResolver.OUT_OF_RANGE) { context.trace.record(BindingContext.COMPILE_TIME_VALUE, expression, new StringValue(builder.toString())); } - return DataFlowUtils.checkType(context.semanticServices.getStandardLibrary().getStringType(), expression, contextWithExpectedType); + return DataFlowUtils.checkType(JetStandardLibrary.getInstance().getStringType(), expression, contextWithExpectedType); } @Override diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java index 4b35e03903f..4f7bd0b124a 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java @@ -72,7 +72,7 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor { }; ObservableBindingTrace traceAdapter = new ObservableBindingTrace(context.trace); traceAdapter.addHandler(CLASS, handler); - TopDownAnalyzer.processObject(context.semanticServices, traceAdapter, context.scope, context.scope.getContainingDeclaration(), expression.getObjectDeclaration()); + TopDownAnalyzer.processObject(context.expressionTypingServices.getProject(), traceAdapter, context.scope, context.scope.getContainingDeclaration(), expression.getObjectDeclaration()); return DataFlowUtils.checkType(result[0], expression, context); } @@ -99,16 +99,16 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor { JetScope functionInnerScope = FunctionDescriptorUtil.getFunctionInnerScope(context.scope, functionDescriptor, context.trace); JetTypeReference returnTypeRef = functionLiteral.getReturnTypeRef(); if (returnTypeRef != null) { - returnType = context.getTypeResolver().resolveType(context.scope, returnTypeRef); - context.getServices().checkFunctionReturnType(expression, context.replaceScope(functionInnerScope). - replaceExpectedType(returnType).replaceExpectedReturnType(returnType).replaceDataFlowInfo(context.dataFlowInfo)); + returnType = context.expressionTypingServices.getTypeResolver().resolveType(context.scope, returnTypeRef, context.trace, true); + context.expressionTypingServices.checkFunctionReturnType(expression, context.replaceScope(functionInnerScope). + replaceExpectedType(returnType).replaceExpectedReturnType(returnType).replaceDataFlowInfo(context.dataFlowInfo), context.trace); } else { if (functionTypeExpected) { returnType = JetStandardClasses.getReturnTypeFromFunctionType(expectedType); } - returnType = context.getServices().getBlockReturnedType(functionInnerScope, bodyExpression, CoercionStrategy.COERCION_TO_UNIT, - context.replaceExpectedType(returnType).replaceExpectedReturnType(returnType)); + returnType = context.expressionTypingServices.getBlockReturnedType(functionInnerScope, bodyExpression, CoercionStrategy.COERCION_TO_UNIT, + context.replaceExpectedType(returnType).replaceExpectedReturnType(returnType), context.trace); } JetType safeReturnType = returnType == null ? ErrorUtils.createErrorType("") : returnType; functionDescriptor.setReturnType(safeReturnType); @@ -143,7 +143,7 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor { } } else { - effectiveReceiverType = context.getTypeResolver().resolveType(context.scope, receiverTypeRef); + effectiveReceiverType = context.expressionTypingServices.getTypeResolver().resolveType(context.scope, receiverTypeRef, context.trace, true); } functionDescriptor.initialize(effectiveReceiverType, NO_RECEIVER, Collections.emptyList(), valueParameterDescriptors, null, Modality.FINAL, Visibility.LOCAL); context.trace.record(BindingContext.FUNCTION, expression, functionDescriptor); @@ -174,7 +174,7 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor { JetType type; if (typeReference != null) { - type = context.getTypeResolver().resolveType(context.scope, typeReference); + type = context.expressionTypingServices.getTypeResolver().resolveType(context.scope, typeReference, context.trace, true); } else { if (expectedValueParameters != null && i < expectedValueParameters.size()) { @@ -185,7 +185,7 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor { type = ErrorUtils.createErrorType("Cannot be inferred"); } } - ValueParameterDescriptor valueParameterDescriptor = context.getDescriptorResolver().resolveValueParameterDescriptor(functionDescriptor, declaredParameter, i, type); + ValueParameterDescriptor valueParameterDescriptor = context.expressionTypingServices.getDescriptorResolver().resolveValueParameterDescriptor(functionDescriptor, declaredParameter, i, type, context.trace); valueParameterDescriptors.add(valueParameterDescriptor); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java index c21ae7f4c64..b8d7fc3f06d 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java @@ -39,7 +39,9 @@ import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl; import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver; import org.jetbrains.jet.lang.resolve.scopes.receivers.TransientReceiver; import org.jetbrains.jet.lang.types.*; +import org.jetbrains.jet.lang.types.checker.JetTypeChecker; import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import java.util.ArrayList; import java.util.Arrays; @@ -63,7 +65,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { if (condition != null) { JetType conditionType = facade.getType(condition, context.replaceScope(scope)); - if (conditionType != null && !isBoolean(context.semanticServices, conditionType)) { + if (conditionType != null && !isBoolean(conditionType)) { context.trace.report(TYPE_MISMATCH_IN_CONDITION.on(condition, conditionType)); } } @@ -92,7 +94,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { if (elseBranch == null) { if (thenBranch != null) { - JetType type = context.getServices().getBlockReturnedTypeWithWritableScope(thenScope, Collections.singletonList(thenBranch), CoercionStrategy.NO_COERCION, context.replaceDataFlowInfo(thenInfo)); + JetType type = context.expressionTypingServices.getBlockReturnedTypeWithWritableScope(thenScope, Collections.singletonList(thenBranch), CoercionStrategy.NO_COERCION, context.replaceDataFlowInfo(thenInfo), context.trace); if (type != null && JetStandardClasses.isNothing(type)) { facade.setResultingDataFlowInfo(elseInfo); } @@ -101,15 +103,15 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { return null; } if (thenBranch == null) { - JetType type = context.getServices().getBlockReturnedTypeWithWritableScope(elseScope, Collections.singletonList(elseBranch), CoercionStrategy.NO_COERCION, context.replaceDataFlowInfo(elseInfo)); + JetType type = context.expressionTypingServices.getBlockReturnedTypeWithWritableScope(elseScope, Collections.singletonList(elseBranch), CoercionStrategy.NO_COERCION, context.replaceDataFlowInfo(elseInfo), context.trace); if (type != null && JetStandardClasses.isNothing(type)) { facade.setResultingDataFlowInfo(thenInfo); } return DataFlowUtils.checkImplicitCast(DataFlowUtils.checkType(JetStandardClasses.getUnitType(), expression, contextWithExpectedType), expression, contextWithExpectedType, isStatement); } CoercionStrategy coercionStrategy = isStatement ? CoercionStrategy.COERCION_TO_UNIT : CoercionStrategy.NO_COERCION; - JetType thenType = context.getServices().getBlockReturnedTypeWithWritableScope(thenScope, Collections.singletonList(thenBranch), coercionStrategy, contextWithExpectedType.replaceDataFlowInfo(thenInfo)); - JetType elseType = context.getServices().getBlockReturnedTypeWithWritableScope(elseScope, Collections.singletonList(elseBranch), coercionStrategy, contextWithExpectedType.replaceDataFlowInfo(elseInfo)); + JetType thenType = context.expressionTypingServices.getBlockReturnedTypeWithWritableScope(thenScope, Collections.singletonList(thenBranch), coercionStrategy, contextWithExpectedType.replaceDataFlowInfo(thenInfo), context.trace); + JetType elseType = context.expressionTypingServices.getBlockReturnedTypeWithWritableScope(elseScope, Collections.singletonList(elseBranch), coercionStrategy, contextWithExpectedType.replaceDataFlowInfo(elseInfo), context.trace); JetType result; if (thenType == null) { @@ -150,7 +152,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { if (body != null) { WritableScopeImpl scopeToExtend = newWritableScopeImpl(context).setDebugName("Scope extended in while's condition"); DataFlowInfo conditionInfo = condition == null ? context.dataFlowInfo : DataFlowUtils.extractDataFlowInfoFromCondition(condition, true, scopeToExtend, context); - context.getServices().getBlockReturnedTypeWithWritableScope(scopeToExtend, Collections.singletonList(body), CoercionStrategy.NO_COERCION, context.replaceDataFlowInfo(conditionInfo)); + context.expressionTypingServices.getBlockReturnedTypeWithWritableScope(scopeToExtend, Collections.singletonList(body), CoercionStrategy.NO_COERCION, context.replaceDataFlowInfo(conditionInfo), context.trace); } if (!containsBreak(expression, context)) { facade.setResultingDataFlowInfo(DataFlowUtils.extractDataFlowInfoFromCondition(condition, false, null, context)); @@ -197,7 +199,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { if (!function.getFunctionLiteral().hasParameterSpecification()) { WritableScope writableScope = newWritableScopeImpl(context).setDebugName("do..while body scope"); conditionScope = writableScope; - context.getServices().getBlockReturnedTypeWithWritableScope(writableScope, function.getFunctionLiteral().getBodyExpression().getStatements(), CoercionStrategy.NO_COERCION, context); + context.expressionTypingServices.getBlockReturnedTypeWithWritableScope(writableScope, function.getFunctionLiteral().getBodyExpression().getStatements(), CoercionStrategy.NO_COERCION, context, context.trace); context.trace.record(BindingContext.BLOCK, function); } else { facade.getType(body, context.replaceScope(context.scope)); @@ -213,7 +215,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { else { block = Collections.singletonList(body); } - context.getServices().getBlockReturnedTypeWithWritableScope(writableScope, block, CoercionStrategy.NO_COERCION, context); + context.expressionTypingServices.getBlockReturnedTypeWithWritableScope(writableScope, block, CoercionStrategy.NO_COERCION, context, context.trace); } JetExpression condition = expression.getCondition(); checkCondition(conditionScope, condition, context); @@ -248,11 +250,11 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { JetTypeReference typeReference = loopParameter.getTypeReference(); VariableDescriptor variableDescriptor; if (typeReference != null) { - variableDescriptor = context.getDescriptorResolver().resolveLocalVariableDescriptor(context.scope.getContainingDeclaration(), context.scope, loopParameter); + variableDescriptor = context.expressionTypingServices.getDescriptorResolver().resolveLocalVariableDescriptor(context.scope.getContainingDeclaration(), context.scope, loopParameter, context.trace); JetType actualParameterType = variableDescriptor.getType(); if (expectedParameterType != null && actualParameterType != null && - !context.semanticServices.getTypeChecker().isSubtypeOf(expectedParameterType, actualParameterType)) { + !JetTypeChecker.INSTANCE.isSubtypeOf(expectedParameterType, actualParameterType)) { context.trace.report(TYPE_MISMATCH_IN_FOR_LOOP.on(typeReference, expectedParameterType, actualParameterType)); } } @@ -260,7 +262,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { if (expectedParameterType == null) { expectedParameterType = ErrorUtils.createErrorType("Error"); } - variableDescriptor = context.getDescriptorResolver().resolveLocalVariableDescriptor(context.scope.getContainingDeclaration(), loopParameter, expectedParameterType); + variableDescriptor = context.expressionTypingServices.getDescriptorResolver().resolveLocalVariableDescriptor(context.scope.getContainingDeclaration(), loopParameter, expectedParameterType, context.trace); } { @@ -277,7 +279,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { JetExpression body = expression.getBody(); if (body != null) { - context.getServices().getBlockReturnedTypeWithWritableScope(loopScope, Collections.singletonList(body), CoercionStrategy.NO_COERCION, context); + context.expressionTypingServices.getBlockReturnedTypeWithWritableScope(loopScope, Collections.singletonList(body), CoercionStrategy.NO_COERCION, context, context.trace); } return DataFlowUtils.checkType(JetStandardClasses.getUnitType(), expression, contextWithExpectedType); @@ -350,7 +352,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { public static OverloadResolutionResults resolveFakeCall(ExpressionReceiver receiver, ExpressionTypingContext context, String name) { - JetReferenceExpression fake = JetPsiFactory.createSimpleName(context.getProject(), "fake"); + JetReferenceExpression fake = JetPsiFactory.createSimpleName(context.expressionTypingServices.getProject(), "fake"); BindingTrace fakeTrace = new BindingTraceContext(); Call call = CallMaker.makeCall(fake, receiver, null, fake, Collections.emptyList()); return context.replaceBindingTrace(fakeTrace).resolveCallWithGivenName(call, fake, name); @@ -366,7 +368,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { } else { assert hasNextResolutionResults.isSuccess(); JetType hasNextReturnType = hasNextResolutionResults.getResultingDescriptor().getReturnType(); - if (!isBoolean(context.semanticServices, hasNextReturnType)) { + if (!isBoolean(hasNextReturnType)) { context.trace.report(HAS_NEXT_FUNCTION_TYPE_MISMATCH.on(loopRange, hasNextReturnType)); } } @@ -384,7 +386,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { // TODO : accessibility context.trace.report(HAS_NEXT_MUST_BE_READABLE.on(loopRange)); } - else if (!isBoolean(context.semanticServices, hasNextReturnType)) { + else if (!isBoolean(hasNextReturnType)) { context.trace.report(HAS_NEXT_PROPERTY_TYPE_MISMATCH.on(loopRange, hasNextReturnType)); } } @@ -401,8 +403,8 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { JetParameter catchParameter = catchClause.getCatchParameter(); JetExpression catchBody = catchClause.getCatchBody(); if (catchParameter != null) { - VariableDescriptor variableDescriptor = context.getDescriptorResolver().resolveLocalVariableDescriptor(context.scope.getContainingDeclaration(), context.scope, catchParameter); - JetType throwableType = context.semanticServices.getStandardLibrary().getThrowable().getDefaultType(); + VariableDescriptor variableDescriptor = context.expressionTypingServices.getDescriptorResolver().resolveLocalVariableDescriptor(context.scope.getContainingDeclaration(), context.scope, catchParameter, context.trace); + JetType throwableType = JetStandardLibrary.getInstance().getThrowable().getDefaultType(); DataFlowUtils.checkType(variableDescriptor.getType(), catchParameter, context.replaceExpectedType(throwableType)); if (catchBody != null) { WritableScope catchScope = newWritableScopeImpl(context).setDebugName("Catch scope"); @@ -437,7 +439,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { public JetType visitThrowExpression(JetThrowExpression expression, ExpressionTypingContext context) { JetExpression thrownExpression = expression.getThrownExpression(); if (thrownExpression != null) { - JetType throwableType = context.semanticServices.getStandardLibrary().getThrowable().getDefaultType(); + JetType throwableType = JetStandardLibrary.getInstance().getThrowable().getDefaultType(); facade.getType(thrownExpression, context.replaceExpectedType(throwableType).replaceScope(context.scope)); } return DataFlowUtils.checkType(JetStandardClasses.getNothingType(), expression, context); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/DataFlowUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/DataFlowUtils.java index a27223f156c..1697a8dcced 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/DataFlowUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/DataFlowUtils.java @@ -154,7 +154,7 @@ public class DataFlowUtils { @Nullable public static JetType checkType(@Nullable JetType expressionType, @NotNull JetExpression expression, @NotNull ExpressionTypingContext context) { if (expressionType == null || context.expectedType == null || context.expectedType == TypeUtils.NO_EXPECTED_TYPE || - context.semanticServices.getTypeChecker().isSubtypeOf(expressionType, context.expectedType)) { + JetTypeChecker.INSTANCE.isSubtypeOf(expressionType, context.expectedType)) { return expressionType; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingContext.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingContext.java index fffff07eea3..2c5b1226258 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingContext.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingContext.java @@ -17,18 +17,13 @@ package org.jetbrains.jet.lang.types.expressions; import com.intellij.lang.ASTNode; -import com.intellij.openapi.project.Project; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.JetSemanticServices; import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; import org.jetbrains.jet.lang.descriptors.VariableDescriptor; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingTrace; -import org.jetbrains.jet.lang.resolve.DescriptorResolver; -import org.jetbrains.jet.lang.resolve.TypeResolver; import org.jetbrains.jet.lang.resolve.calls.CallMaker; -import org.jetbrains.jet.lang.resolve.calls.CallResolver; import org.jetbrains.jet.lang.resolve.calls.OverloadResolutionResults; import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstantResolver; @@ -43,11 +38,11 @@ import java.util.Map; /** * @author abreslav */ -/*package*/ class ExpressionTypingContext { +public class ExpressionTypingContext { + @NotNull public static ExpressionTypingContext newContext( - @NotNull Project project, - @NotNull JetSemanticServices semanticServices, + @NotNull ExpressionTypingServices expressionTypingServices, @NotNull Map patternsToDataFlowInfo, @NotNull Map> patternsToBoundVariableLists, @NotNull LabelResolver labelResolver, @@ -57,7 +52,7 @@ import java.util.Map; @NotNull JetType expectedType, @NotNull JetType expectedReturnType, boolean namespacesAllowed) { - return new ExpressionTypingContext(project, semanticServices, patternsToDataFlowInfo, patternsToBoundVariableLists, + return new ExpressionTypingContext(expressionTypingServices, patternsToDataFlowInfo, patternsToBoundVariableLists, labelResolver, trace, scope, dataFlowInfo, expectedType, expectedReturnType, namespacesAllowed); } @@ -72,8 +67,7 @@ import java.util.Map; // return newContext(semanticServices, new HashMap(), new HashMap>(), new LabelResolver(), trace, scope, dataFlowInfo, expectedType, expectedReturnType); // } // - public final Project project; - public final JetSemanticServices semanticServices; + public final ExpressionTypingServices expressionTypingServices; public final BindingTrace trace; public final JetScope scope; @@ -88,15 +82,10 @@ import java.util.Map; // true for positions on the lhs of a '.', i.e. allows namespace results and 'super' public final boolean namespacesAllowed; - private CallResolver callResolver; - private TypeResolver typeResolver; - private DescriptorResolver descriptorResolver; - private ExpressionTypingServices services; private CompileTimeConstantResolver compileTimeConstantResolver; private ExpressionTypingContext( - @NotNull Project project, - @NotNull JetSemanticServices semanticServices, + @NotNull ExpressionTypingServices expressionTypingServices, @NotNull Map patternsToDataFlowInfo, @NotNull Map> patternsToBoundVariableLists, @NotNull LabelResolver labelResolver, @@ -106,13 +95,12 @@ import java.util.Map; @NotNull JetType expectedType, @NotNull JetType expectedReturnType, boolean namespacesAllowed) { - this.project = project; + this.expressionTypingServices = expressionTypingServices; this.trace = trace; this.patternsToBoundVariableLists = patternsToBoundVariableLists; this.patternsToDataFlowInfo = patternsToDataFlowInfo; this.labelResolver = labelResolver; this.scope = scope; - this.semanticServices = semanticServices; this.dataFlowInfo = dataFlowInfo; this.expectedType = expectedType; this.expectedReturnType = expectedReturnType; @@ -122,71 +110,43 @@ import java.util.Map; @NotNull public ExpressionTypingContext replaceNamespacesAllowed(boolean namespacesAllowed) { if (namespacesAllowed == this.namespacesAllowed) return this; - return newContext(project, semanticServices, patternsToDataFlowInfo, patternsToBoundVariableLists, labelResolver, trace, scope, dataFlowInfo, expectedType, expectedReturnType, namespacesAllowed); + return newContext(expressionTypingServices, patternsToDataFlowInfo, patternsToBoundVariableLists, labelResolver, trace, scope, dataFlowInfo, expectedType, expectedReturnType, namespacesAllowed); } @NotNull public ExpressionTypingContext replaceDataFlowInfo(DataFlowInfo newDataFlowInfo) { if (newDataFlowInfo == dataFlowInfo) return this; - return newContext(project, semanticServices, patternsToDataFlowInfo, patternsToBoundVariableLists, labelResolver, trace, scope, newDataFlowInfo, expectedType, expectedReturnType, namespacesAllowed); + return newContext(expressionTypingServices, patternsToDataFlowInfo, patternsToBoundVariableLists, labelResolver, trace, scope, newDataFlowInfo, expectedType, expectedReturnType, namespacesAllowed); } public ExpressionTypingContext replaceExpectedType(@Nullable JetType newExpectedType) { if (newExpectedType == null) return replaceExpectedType(TypeUtils.NO_EXPECTED_TYPE); if (expectedType == newExpectedType) return this; - return newContext(project, semanticServices, patternsToDataFlowInfo, patternsToBoundVariableLists, labelResolver, trace, scope, dataFlowInfo, newExpectedType, expectedReturnType, namespacesAllowed); + return newContext(expressionTypingServices, patternsToDataFlowInfo, patternsToBoundVariableLists, labelResolver, trace, scope, dataFlowInfo, newExpectedType, expectedReturnType, namespacesAllowed); } public ExpressionTypingContext replaceExpectedReturnType(@Nullable JetType newExpectedReturnType) { if (newExpectedReturnType == null) return replaceExpectedReturnType(TypeUtils.NO_EXPECTED_TYPE); if (expectedReturnType == newExpectedReturnType) return this; - return newContext(project, semanticServices, patternsToDataFlowInfo, patternsToBoundVariableLists, labelResolver, trace, scope, dataFlowInfo, expectedType, newExpectedReturnType, namespacesAllowed); + return newContext(expressionTypingServices, patternsToDataFlowInfo, patternsToBoundVariableLists, labelResolver, trace, scope, dataFlowInfo, expectedType, newExpectedReturnType, namespacesAllowed); } public ExpressionTypingContext replaceBindingTrace(@NotNull BindingTrace newTrace) { if (newTrace == trace) return this; - return newContext(project, semanticServices, patternsToDataFlowInfo, patternsToBoundVariableLists, labelResolver, newTrace, scope, dataFlowInfo, expectedType, expectedReturnType, namespacesAllowed); + return newContext(expressionTypingServices, patternsToDataFlowInfo, patternsToBoundVariableLists, labelResolver, newTrace, scope, dataFlowInfo, expectedType, expectedReturnType, namespacesAllowed); } @NotNull public ExpressionTypingContext replaceScope(@NotNull JetScope newScope) { if (newScope == scope) return this; - return newContext(project, semanticServices, patternsToDataFlowInfo, patternsToBoundVariableLists, labelResolver, trace, newScope, dataFlowInfo, expectedType, expectedReturnType, namespacesAllowed); + return newContext(expressionTypingServices, patternsToDataFlowInfo, patternsToBoundVariableLists, labelResolver, trace, newScope, dataFlowInfo, expectedType, expectedReturnType, namespacesAllowed); } ///////////// LAZY ACCESSORS - public CallResolver getCallResolver() { - if (callResolver == null) { - callResolver = new CallResolver(semanticServices, dataFlowInfo); - } - return callResolver; - } - - public ExpressionTypingServices getServices() { - if (services == null) { - services = new ExpressionTypingServices(semanticServices, trace); - } - return services; - } - - public TypeResolver getTypeResolver() { - if (typeResolver == null) { - typeResolver = new TypeResolver(semanticServices, trace, true); - } - return typeResolver; - } - - public DescriptorResolver getDescriptorResolver() { - if (descriptorResolver == null) { - descriptorResolver = semanticServices.getClassDescriptorResolver(trace); - } - return descriptorResolver; - } - public CompileTimeConstantResolver getCompileTimeConstantResolver() { if (compileTimeConstantResolver == null) { - compileTimeConstantResolver = new CompileTimeConstantResolver(semanticServices, trace); + compileTimeConstantResolver = new CompileTimeConstantResolver(trace); } return compileTimeConstantResolver; } @@ -195,7 +155,7 @@ import java.util.Map; @NotNull public OverloadResolutionResults resolveCallWithGivenName(@NotNull Call call, @NotNull JetReferenceExpression functionReference, @NotNull String name) { - return getCallResolver().resolveCallWithGivenName(trace, scope, call, functionReference, name, expectedType); + return expressionTypingServices.getCallResolver().resolveCallWithGivenName(trace, scope, call, functionReference, name, expectedType, dataFlowInfo); } @NotNull @@ -206,23 +166,19 @@ import java.util.Map; @Nullable public FunctionDescriptor resolveCall(@NotNull ReceiverDescriptor receiver, @Nullable ASTNode callOperationNode, @NotNull JetCallExpression callExpression) { - OverloadResolutionResults results = getCallResolver().resolveCall(trace, scope, CallMaker.makeCall(receiver, callOperationNode, callExpression), expectedType); + OverloadResolutionResults results = expressionTypingServices.getCallResolver().resolveCall(trace, scope, CallMaker.makeCall(receiver, callOperationNode, callExpression), expectedType, dataFlowInfo); return results.singleResult() ? results.getResultingDescriptor() : null; } @NotNull public OverloadResolutionResults resolveSimpleProperty(@NotNull ReceiverDescriptor receiver, @Nullable ASTNode callOperationNode, @NotNull JetSimpleNameExpression nameExpression) { Call call = CallMaker.makePropertyCall(receiver, callOperationNode, nameExpression); - return getCallResolver().resolveSimpleProperty(trace, scope, call, expectedType); + return expressionTypingServices.getCallResolver().resolveSimpleProperty(trace, scope, call, expectedType, dataFlowInfo); } @NotNull public OverloadResolutionResults resolveExactSignature(@NotNull ReceiverDescriptor receiver, @NotNull String name, @NotNull List parameterTypes) { - return getCallResolver().resolveExactSignature(scope, receiver, name, parameterTypes); + return expressionTypingServices.getCallResolver().resolveExactSignature(scope, receiver, name, parameterTypes); } - @NotNull - public Project getProject() { - return project; - } } 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 5f18ca5b884..82e08041e09 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 @@ -17,11 +17,12 @@ package org.jetbrains.jet.lang.types.expressions; import com.google.common.collect.Lists; +import com.google.inject.Inject; +import com.intellij.openapi.project.Project; import com.intellij.psi.PsiElement; import com.intellij.psi.tree.IElementType; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.JetSemanticServices; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; import org.jetbrains.jet.lang.descriptors.FunctionDescriptorUtil; @@ -29,6 +30,7 @@ import org.jetbrains.jet.lang.descriptors.VariableDescriptor; import org.jetbrains.jet.lang.diagnostics.Diagnostic; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.*; +import org.jetbrains.jet.lang.resolve.calls.CallResolver; import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; @@ -37,6 +39,7 @@ import org.jetbrains.jet.lang.types.CommonSupertypes; import org.jetbrains.jet.lang.types.ErrorUtils; import org.jetbrains.jet.lang.types.lang.JetStandardClasses; import org.jetbrains.jet.lang.types.JetType; +import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import org.jetbrains.jet.lexer.JetTokens; import java.util.*; @@ -51,23 +54,67 @@ import static org.jetbrains.jet.lang.types.TypeUtils.NO_EXPECTED_TYPE; * @author abreslav */ public class ExpressionTypingServices { - private final JetSemanticServices semanticServices; - private final BindingTrace trace; private final ExpressionTypingFacade expressionTypingFacade = ExpressionTypingVisitorDispatcher.create(); - public ExpressionTypingServices(JetSemanticServices semanticServices, BindingTrace trace) { - this.semanticServices = semanticServices; - this.trace = trace; + @NotNull + private Project project; + @NotNull + private CallResolver callResolver; + @NotNull + private DescriptorResolver descriptorResolver; + @NotNull + private TypeResolver typeResolver; + + + + @NotNull + public Project getProject() { + return project; + } + + @Inject + public void setProject(@NotNull Project project) { + this.project = project; } @NotNull - public JetType safeGetType(@NotNull JetScope scope, @NotNull JetExpression expression, @NotNull JetType expectedType) { - return safeGetType(scope, expression, expectedType, DataFlowInfo.EMPTY); + public CallResolver getCallResolver() { + return callResolver; } - public JetType safeGetType(@NotNull JetScope scope, @NotNull JetExpression expression, @NotNull JetType expectedType, @NotNull DataFlowInfo dataFlowInfo) { - JetType type = getType(scope, expression, expectedType, dataFlowInfo); + @Inject + public void setCallResolver(@NotNull CallResolver callResolver) { + this.callResolver = callResolver; + } + + @NotNull + public DescriptorResolver getDescriptorResolver() { + return descriptorResolver; + } + + @Inject + public void setDescriptorResolver(@NotNull DescriptorResolver descriptorResolver) { + this.descriptorResolver = descriptorResolver; + } + + @NotNull + public TypeResolver getTypeResolver() { + return typeResolver; + } + + @Inject + public void setTypeResolver(@NotNull TypeResolver typeResolver) { + this.typeResolver = typeResolver; + } + + @NotNull + public JetType safeGetType(@NotNull JetScope scope, @NotNull JetExpression expression, @NotNull JetType expectedType, BindingTrace trace) { + return safeGetType(scope, expression, expectedType, DataFlowInfo.EMPTY, trace); + } + + public JetType safeGetType(@NotNull JetScope scope, @NotNull JetExpression expression, @NotNull JetType expectedType, @NotNull DataFlowInfo dataFlowInfo, BindingTrace trace) { + JetType type = getType(scope, expression, expectedType, dataFlowInfo, trace); if (type != null) { return type; } @@ -75,25 +122,23 @@ public class ExpressionTypingServices { } @Nullable - public JetType getType(@NotNull final JetScope scope, @NotNull JetExpression expression, @NotNull JetType expectedType) { - return getType(scope, expression, expectedType, DataFlowInfo.EMPTY); + public JetType getType(@NotNull final JetScope scope, @NotNull JetExpression expression, @NotNull JetType expectedType, BindingTrace trace) { + return getType(scope, expression, expectedType, DataFlowInfo.EMPTY, trace); } @Nullable - public JetType getType(@NotNull final JetScope scope, @NotNull JetExpression expression, @NotNull JetType expectedType, @NotNull DataFlowInfo dataFlowInfo) { + public JetType getType(@NotNull final JetScope scope, @NotNull JetExpression expression, @NotNull JetType expectedType, @NotNull DataFlowInfo dataFlowInfo, BindingTrace trace) { ExpressionTypingContext context = ExpressionTypingContext.newContext( - expression.getProject(), - semanticServices, + this, new HashMap(), new HashMap>(), new LabelResolver(), trace, scope, dataFlowInfo, expectedType, FORBIDDEN, false ); return expressionTypingFacade.getType(expression, context); } - public JetType getTypeWithNamespaces(@NotNull final JetScope scope, @NotNull JetExpression expression) { + public JetType getTypeWithNamespaces(@NotNull final JetScope scope, @NotNull JetExpression expression, BindingTrace trace) { ExpressionTypingContext context = ExpressionTypingContext.newContext( - expression.getProject(), - semanticServices, + this, new HashMap(), new HashMap>(), new LabelResolver(), trace, scope, DataFlowInfo.EMPTY, NO_EXPECTED_TYPE, FORBIDDEN, true); @@ -102,7 +147,7 @@ public class ExpressionTypingServices { } @NotNull - public JetType inferFunctionReturnType(@NotNull JetScope outerScope, JetDeclarationWithBody function, FunctionDescriptor functionDescriptor) { + public JetType inferFunctionReturnType(@NotNull JetScope outerScope, JetDeclarationWithBody function, FunctionDescriptor functionDescriptor, BindingTrace trace) { Map typeMap = collectReturnedExpressionsWithTypes(trace, outerScope, function, functionDescriptor); Collection types = typeMap.values(); return types.isEmpty() @@ -111,20 +156,20 @@ public class ExpressionTypingServices { } - public void checkFunctionReturnType(@NotNull JetScope functionInnerScope, @NotNull JetDeclarationWithBody function, @NotNull FunctionDescriptor functionDescriptor) { - checkFunctionReturnType(functionInnerScope, function, functionDescriptor, DataFlowInfo.EMPTY, null); + public void checkFunctionReturnType(@NotNull JetScope functionInnerScope, @NotNull JetDeclarationWithBody function, @NotNull FunctionDescriptor functionDescriptor, BindingTrace trace) { + checkFunctionReturnType(functionInnerScope, function, functionDescriptor, DataFlowInfo.EMPTY, null, trace); } - public void checkFunctionReturnType(@NotNull JetScope functionInnerScope, @NotNull JetDeclarationWithBody function, @NotNull FunctionDescriptor functionDescriptor, @Nullable JetType expectedReturnType) { - checkFunctionReturnType(functionInnerScope, function, functionDescriptor, DataFlowInfo.EMPTY, expectedReturnType); + public void checkFunctionReturnType(@NotNull JetScope functionInnerScope, @NotNull JetDeclarationWithBody function, @NotNull FunctionDescriptor functionDescriptor, @Nullable JetType expectedReturnType, BindingTrace trace) { + checkFunctionReturnType(functionInnerScope, function, functionDescriptor, DataFlowInfo.EMPTY, expectedReturnType, trace); } ///////////////////////////////////////////////////////// - /*package*/ void checkFunctionReturnType(@NotNull JetScope functionInnerScope, @NotNull JetDeclarationWithBody function, @NotNull FunctionDescriptor functionDescriptor, @NotNull DataFlowInfo dataFlowInfo) { - checkFunctionReturnType(functionInnerScope, function, functionDescriptor, dataFlowInfo, null); + /*package*/ void checkFunctionReturnType(@NotNull JetScope functionInnerScope, @NotNull JetDeclarationWithBody function, @NotNull FunctionDescriptor functionDescriptor, @NotNull DataFlowInfo dataFlowInfo, BindingTrace trace) { + checkFunctionReturnType(functionInnerScope, function, functionDescriptor, dataFlowInfo, null, trace); } - /*package*/ void checkFunctionReturnType(@NotNull JetScope functionInnerScope, @NotNull JetDeclarationWithBody function, @NotNull FunctionDescriptor functionDescriptor, @NotNull DataFlowInfo dataFlowInfo, @Nullable JetType expectedReturnType) { + /*package*/ void checkFunctionReturnType(@NotNull JetScope functionInnerScope, @NotNull JetDeclarationWithBody function, @NotNull FunctionDescriptor functionDescriptor, @NotNull DataFlowInfo dataFlowInfo, @Nullable JetType expectedReturnType, BindingTrace trace) { if (expectedReturnType == null) { expectedReturnType = functionDescriptor.getReturnType(); if (!function.hasBlockBody() && !function.hasDeclaredReturnType()) { @@ -132,13 +177,13 @@ public class ExpressionTypingServices { } } checkFunctionReturnType(function, ExpressionTypingContext.newContext( - function.getProject(), - semanticServices, new HashMap(), new HashMap>(), new LabelResolver(), + this, + new HashMap(), new HashMap>(), new LabelResolver(), trace, functionInnerScope, dataFlowInfo, NO_EXPECTED_TYPE, expectedReturnType, false - )); + ), trace); } - /*package*/ void checkFunctionReturnType(JetDeclarationWithBody function, ExpressionTypingContext context) { + /*package*/ void checkFunctionReturnType(JetDeclarationWithBody function, ExpressionTypingContext context, BindingTrace trace) { JetExpression bodyExpression = function.getBodyExpression(); if (bodyExpression == null) return; @@ -152,7 +197,7 @@ public class ExpressionTypingServices { JetFunctionLiteralExpression functionLiteralExpression = (JetFunctionLiteralExpression) function; JetBlockExpression blockExpression = functionLiteralExpression.getBodyExpression(); assert blockExpression != null; - getBlockReturnedType(newContext.scope, blockExpression, CoercionStrategy.COERCION_TO_UNIT, context); + getBlockReturnedType(newContext.scope, blockExpression, CoercionStrategy.COERCION_TO_UNIT, context, trace); } else { expressionTypingFacade.getType(bodyExpression, newContext, !blockBody); @@ -160,7 +205,7 @@ public class ExpressionTypingServices { } @Nullable - /*package*/ JetType getBlockReturnedType(@NotNull JetScope outerScope, @NotNull JetBlockExpression expression, @NotNull CoercionStrategy coercionStrategyForLastExpression, ExpressionTypingContext context) { + /*package*/ JetType getBlockReturnedType(@NotNull JetScope outerScope, @NotNull JetBlockExpression expression, @NotNull CoercionStrategy coercionStrategyForLastExpression, ExpressionTypingContext context, BindingTrace trace) { List block = expression.getStatements(); if (block.isEmpty()) { return DataFlowUtils.checkType(JetStandardClasses.getUnitType(), expression, context); @@ -169,7 +214,7 @@ public class ExpressionTypingServices { DeclarationDescriptor containingDescriptor = outerScope.getContainingDeclaration(); WritableScope scope = new WritableScopeImpl(outerScope, containingDescriptor, new TraceBasedRedeclarationHandler(context.trace)).setDebugName("getBlockReturnedType"); scope.changeLockLevel(WritableScope.LockLevel.BOTH); - return getBlockReturnedTypeWithWritableScope(scope, block, coercionStrategyForLastExpression, context); + return getBlockReturnedTypeWithWritableScope(scope, block, coercionStrategyForLastExpression, context, trace); } private Map collectReturnedExpressionsWithTypes( @@ -180,8 +225,10 @@ public class ExpressionTypingServices { JetExpression bodyExpression = function.getBodyExpression(); assert bodyExpression != null; JetScope functionInnerScope = FunctionDescriptorUtil.getFunctionInnerScope(outerScope, functionDescriptor, trace); - expressionTypingFacade.getType(bodyExpression, ExpressionTypingContext.newContext(function.getProject(), semanticServices, new HashMap(), new HashMap>(), new LabelResolver(), - trace, functionInnerScope, DataFlowInfo.EMPTY, NO_EXPECTED_TYPE, FORBIDDEN, false), !function.hasBlockBody()); + expressionTypingFacade.getType(bodyExpression, ExpressionTypingContext.newContext( + this, + new HashMap(), new HashMap>(), new LabelResolver(), + trace, functionInnerScope, DataFlowInfo.EMPTY, NO_EXPECTED_TYPE, FORBIDDEN, false), !function.hasBlockBody()); //todo function literals final Collection returnedExpressions = Lists.newArrayList(); if (function.hasBlockBody()) { @@ -225,7 +272,7 @@ public class ExpressionTypingServices { return typeMap; } - /*package*/ JetType getBlockReturnedTypeWithWritableScope(@NotNull WritableScope scope, @NotNull List block, @NotNull CoercionStrategy coercionStrategyForLastExpression, ExpressionTypingContext context) { + /*package*/ JetType getBlockReturnedTypeWithWritableScope(@NotNull WritableScope scope, @NotNull List block, @NotNull CoercionStrategy coercionStrategyForLastExpression, ExpressionTypingContext context, BindingTrace trace) { if (block.isEmpty()) { return JetStandardClasses.getUnitType(); } @@ -309,7 +356,8 @@ public class ExpressionTypingServices { } private ExpressionTypingContext createContext(ExpressionTypingContext oldContext, BindingTrace trace, WritableScope scope, DataFlowInfo dataFlowInfo, JetType expectedType, JetType expectedReturnType) { - return ExpressionTypingContext.newContext(oldContext.project, oldContext.semanticServices, oldContext.patternsToDataFlowInfo, oldContext.patternsToBoundVariableLists, oldContext.labelResolver, trace, scope, dataFlowInfo, expectedType, expectedReturnType, oldContext.namespacesAllowed); + return ExpressionTypingContext.newContext( + this, oldContext.patternsToDataFlowInfo, oldContext.patternsToBoundVariableLists, oldContext.labelResolver, trace, scope, dataFlowInfo, expectedType, expectedReturnType, oldContext.namespacesAllowed); } private ObservableBindingTrace makeTraceInterceptingTypeMismatch(final BindingTrace trace, final JetExpression expressionToWatch, final boolean[] mismatchFound) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java index 48e1e72a696..d00138f036e 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java @@ -22,7 +22,6 @@ import com.intellij.psi.tree.TokenSet; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.JetNodeTypes; -import org.jetbrains.jet.lang.JetSemanticServices; import org.jetbrains.jet.lang.descriptors.CallableDescriptor; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; @@ -34,10 +33,12 @@ import org.jetbrains.jet.lang.resolve.calls.inference.*; import org.jetbrains.jet.lang.resolve.scopes.*; import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; +import org.jetbrains.jet.lang.types.checker.JetTypeChecker; import org.jetbrains.jet.lang.types.lang.JetStandardClasses; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.TypeUtils; import org.jetbrains.jet.lang.types.Variance; +import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import java.util.ArrayList; import java.util.Collection; @@ -78,8 +79,8 @@ public class ExpressionTypingUtils { return scope; } - public static boolean isBoolean(@NotNull JetSemanticServices semanticServices, @NotNull JetType type) { - return semanticServices.getTypeChecker().isSubtypeOf(type, semanticServices.getStandardLibrary().getBooleanType()); + public static boolean isBoolean(@NotNull JetType type) { + return JetTypeChecker.INSTANCE.isSubtypeOf(type, JetStandardLibrary.getInstance().getBooleanType()); } public static boolean ensureBooleanResult(JetExpression operationSign, String name, JetType resultType, ExpressionTypingContext context) { @@ -89,8 +90,8 @@ public class ExpressionTypingUtils { public static boolean ensureBooleanResultWithCustomSubject(JetExpression operationSign, JetType resultType, String subjectName, ExpressionTypingContext context) { if (resultType != null) { // TODO : Relax? - if (!isBoolean(context.semanticServices, resultType)) { - context.trace.report(RESULT_TYPE_MISMATCH.on(operationSign, subjectName, context.semanticServices.getStandardLibrary().getBooleanType(), resultType)); + if (!isBoolean(resultType)) { + context.trace.report(RESULT_TYPE_MISMATCH.on(operationSign, subjectName, JetStandardLibrary.getInstance().getBooleanType(), resultType)); return false; } } @@ -98,18 +99,18 @@ public class ExpressionTypingUtils { } @NotNull - public static JetType getDefaultType(JetSemanticServices semanticServices, IElementType constantType) { + public static JetType getDefaultType(IElementType constantType) { if (constantType == JetNodeTypes.INTEGER_CONSTANT) { - return semanticServices.getStandardLibrary().getIntType(); + return JetStandardLibrary.getInstance().getIntType(); } else if (constantType == JetNodeTypes.FLOAT_CONSTANT) { - return semanticServices.getStandardLibrary().getDoubleType(); + return JetStandardLibrary.getInstance().getDoubleType(); } else if (constantType == JetNodeTypes.BOOLEAN_CONSTANT) { - return semanticServices.getStandardLibrary().getBooleanType(); + return JetStandardLibrary.getInstance().getBooleanType(); } else if (constantType == JetNodeTypes.CHARACTER_CONSTANT) { - return semanticServices.getStandardLibrary().getCharType(); + return JetStandardLibrary.getInstance().getCharType(); } else if (constantType == JetNodeTypes.NULL) { return JetStandardClasses.getNullableNothingType(); @@ -148,12 +149,12 @@ public class ExpressionTypingUtils { return expression; } - public static boolean isVariableIterable(@NotNull Project project, @NotNull VariableDescriptor variableDescriptor, @NotNull JetScope scope) { + public static boolean isVariableIterable(@NotNull ExpressionTypingServices expressionTypingServices, + @NotNull Project project, @NotNull VariableDescriptor variableDescriptor, @NotNull JetScope scope) { JetExpression expression = JetPsiFactory.createExpression(project, "fake"); ExpressionReceiver expressionReceiver = new ExpressionReceiver(expression, variableDescriptor.getType()); ExpressionTypingContext context = ExpressionTypingContext.newContext( - project, - JetSemanticServices.createSemanticServices(project), + expressionTypingServices, new HashMap(), new HashMap>(), new LabelResolver(), diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorForStatements.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorForStatements.java index 9012e65f57f..60778cde171 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorForStatements.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorForStatements.java @@ -79,11 +79,11 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito @Override public JetType visitObjectDeclaration(JetObjectDeclaration declaration, ExpressionTypingContext context) { - TopDownAnalyzer.processObject(context.semanticServices, context.trace, scope, scope.getContainingDeclaration(), declaration); + TopDownAnalyzer.processObject(context.expressionTypingServices.getProject(), context.trace, scope, scope.getContainingDeclaration(), declaration); ClassDescriptor classDescriptor = context.trace.getBindingContext().get(BindingContext.CLASS, declaration); if (classDescriptor != null) { - VariableDescriptor variableDescriptor = context.getDescriptorResolver() - .resolveObjectDeclaration(scope.getContainingDeclaration(), declaration, classDescriptor); + VariableDescriptor variableDescriptor = context.expressionTypingServices.getDescriptorResolver() + .resolveObjectDeclaration(scope.getContainingDeclaration(), declaration, classDescriptor, context.trace); scope.addVariableDescriptor(variableDescriptor); } return DataFlowUtils.checkStatementType(declaration, context); @@ -106,7 +106,7 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito context.trace.report(LOCAL_VARIABLE_WITH_SETTER.on(setter)); } - VariableDescriptor propertyDescriptor = context.getDescriptorResolver().resolveLocalVariableDescriptor(scope.getContainingDeclaration(), scope, property, context.dataFlowInfo); + VariableDescriptor propertyDescriptor = context.expressionTypingServices.getDescriptorResolver().resolveLocalVariableDescriptor(scope.getContainingDeclaration(), scope, property, context.dataFlowInfo, context.trace); JetExpression initializer = property.getInitializer(); if (property.getPropertyTypeRef() != null && initializer != null) { JetType outType = propertyDescriptor.getType(); @@ -126,10 +126,10 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito @Override public JetType visitNamedFunction(JetNamedFunction function, ExpressionTypingContext context) { - SimpleFunctionDescriptor functionDescriptor = context.getDescriptorResolver().resolveFunctionDescriptor(scope.getContainingDeclaration(), scope, function); + SimpleFunctionDescriptor functionDescriptor = context.expressionTypingServices.getDescriptorResolver().resolveFunctionDescriptor(scope.getContainingDeclaration(), scope, function, context.trace); scope.addFunctionDescriptor(functionDescriptor); JetScope functionInnerScope = FunctionDescriptorUtil.getFunctionInnerScope(context.scope, functionDescriptor, context.trace); - context.getServices().checkFunctionReturnType(functionInnerScope, function, functionDescriptor, context.dataFlowInfo); + context.expressionTypingServices.checkFunctionReturnType(functionInnerScope, function, functionDescriptor, context.dataFlowInfo, context.trace); return DataFlowUtils.checkStatementType(function, context); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/PatternMatchingTypingVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/PatternMatchingTypingVisitor.java index bdf25441bca..56bd680ab88 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/PatternMatchingTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/PatternMatchingTypingVisitor.java @@ -32,7 +32,9 @@ import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; import org.jetbrains.jet.lang.resolve.scopes.receivers.TransientReceiver; import org.jetbrains.jet.lang.types.*; +import org.jetbrains.jet.lang.types.checker.JetTypeChecker; import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import java.util.Collections; import java.util.List; @@ -61,7 +63,7 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor { context.patternsToDataFlowInfo.put(pattern, newDataFlowInfo); context.patternsToBoundVariableLists.put(pattern, scopeToExtend.getDeclaredVariables()); } - return DataFlowUtils.checkType(context.semanticServices.getStandardLibrary().getBooleanType(), expression, contextWithExpectedType); + return DataFlowUtils.checkType(JetStandardLibrary.getInstance().getBooleanType(), expression, contextWithExpectedType); } @Override @@ -74,7 +76,7 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor { // TODO :change scope according to the bound value in the when header final JetExpression subjectExpression = expression.getSubjectExpression(); - final JetType subjectType = subjectExpression != null ? context.getServices().safeGetType(context.scope, subjectExpression, TypeUtils.NO_EXPECTED_TYPE) : ErrorUtils.createErrorType("Unknown type"); + final JetType subjectType = subjectExpression != null ? context.expressionTypingServices.safeGetType(context.scope, subjectExpression, TypeUtils.NO_EXPECTED_TYPE, context.trace) : ErrorUtils.createErrorType("Unknown type"); final DataFlowValue variableDescriptor = subjectExpression != null ? DataFlowValueFactory.INSTANCE.createDataFlowValue(subjectExpression, subjectType, context.trace.getBindingContext()) : DataFlowValue.NULL; // TODO : exhaustive patterns @@ -115,7 +117,7 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor { if (bodyExpression != null) { ExpressionTypingContext newContext = contextWithExpectedType.replaceScope(scopeToExtend).replaceDataFlowInfo(newDataFlowInfo); CoercionStrategy coercionStrategy = isStatement ? CoercionStrategy.COERCION_TO_UNIT : CoercionStrategy.NO_COERCION; - JetType type = context.getServices().getBlockReturnedTypeWithWritableScope(scopeToExtend, Collections.singletonList(bodyExpression), coercionStrategy, newContext); + JetType type = context.expressionTypingServices.getBlockReturnedTypeWithWritableScope(scopeToExtend, Collections.singletonList(bodyExpression), coercionStrategy, newContext, context.trace); if (type != null) { expressionTypes.add(type); } @@ -180,7 +182,7 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor { public void visitTypePattern(JetTypePattern typePattern) { JetTypeReference typeReference = typePattern.getTypeReference(); if (typeReference == null) return; - JetType type = context.getTypeResolver().resolveType(context.scope, typeReference); + JetType type = context.expressionTypingServices.getTypeResolver().resolveType(context.scope, typeReference, context.trace, true); checkTypeCompatibility(type, subjectType, typePattern); result.set(context.dataFlowInfo.establishSubtyping(subjectVariables, type)); } @@ -238,8 +240,8 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor { if (expression == null) return; JetType type = facade.getType(expression, context.replaceScope(scopeToExtend)); if (conditionExpected) { - JetType booleanType = context.semanticServices.getStandardLibrary().getBooleanType(); - if (type != null && !context.semanticServices.getTypeChecker().equalTypes(booleanType, type)) { + JetType booleanType = JetStandardLibrary.getInstance().getBooleanType(); + if (type != null && !JetTypeChecker.INSTANCE.equalTypes(booleanType, type)) { context.trace.report(TYPE_MISMATCH_IN_CONDITION.on(pattern, type)); } return; @@ -251,11 +253,11 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor { public void visitBindingPattern(JetBindingPattern pattern) { JetProperty variableDeclaration = pattern.getVariableDeclaration(); JetTypeReference propertyTypeRef = variableDeclaration.getPropertyTypeRef(); - JetType type = propertyTypeRef == null ? subjectType : context.getTypeResolver().resolveType(context.scope, propertyTypeRef); - VariableDescriptor variableDescriptor = context.getDescriptorResolver().resolveLocalVariableDescriptorWithType(context.scope.getContainingDeclaration(), variableDeclaration, type); + JetType type = propertyTypeRef == null ? subjectType : context.expressionTypingServices.getTypeResolver().resolveType(context.scope, propertyTypeRef, context.trace, true); + VariableDescriptor variableDescriptor = context.expressionTypingServices.getDescriptorResolver().resolveLocalVariableDescriptorWithType(context.scope.getContainingDeclaration(), variableDeclaration, type, context.trace); scopeToExtend.addVariableDescriptor(variableDescriptor); if (propertyTypeRef != null) { - if (!context.semanticServices.getTypeChecker().isSubtypeOf(subjectType, type)) { + if (!JetTypeChecker.INSTANCE.isSubtypeOf(subjectType, type)) { context.trace.report(TYPE_MISMATCH_IN_BINDING_PATTERN.on(propertyTypeRef, type, subjectType)); } } @@ -278,12 +280,12 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor { if (type == null) { return; } - if (TypeUtils.intersect(context.semanticServices.getTypeChecker(), Sets.newHashSet(type, subjectType)) == null) { + if (TypeUtils.intersect(JetTypeChecker.INSTANCE, Sets.newHashSet(type, subjectType)) == null) { context.trace.report(INCOMPATIBLE_TYPES.on(reportErrorOn, type, subjectType)); return; } - - if (BasicExpressionTypingVisitor.isCastErased(subjectType, type, context.semanticServices.getTypeChecker())) { + + if (BasicExpressionTypingVisitor.isCastErased(subjectType, type, JetTypeChecker.INSTANCE)) { context.trace.report(Errors.CANNOT_CHECK_FOR_ERASED.on(reportErrorOn, type)); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/lang/JetStandardLibrary.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/lang/JetStandardLibrary.java index 77007964b5a..8888d1a0510 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/lang/JetStandardLibrary.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/lang/JetStandardLibrary.java @@ -22,7 +22,6 @@ import com.intellij.openapi.util.io.FileUtil; import com.intellij.psi.PsiFileFactory; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.JetSemanticServices; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; import org.jetbrains.jet.lang.descriptors.PropertyDescriptor; @@ -54,11 +53,28 @@ public class JetStandardLibrary { private static JetStandardLibrary instance = null; + private static boolean initializing; + private static Throwable initializationFailed; + // This method must be called at least once per application run, on any project // before any type checking is run public static synchronized void initialize(@NotNull Project project) { if (instance == null) { - instance = new JetStandardLibrary(project); + if (initializing) { + throw new IllegalStateException("builtin library initialization loop"); + } + if (initializationFailed != null) { + throw new RuntimeException( + "builtin library initialization failed previously: " + initializationFailed, initializationFailed); + } + initializing = true; + try { + instance = new JetStandardLibrary(project); + } catch (Throwable e) { + initializationFailed = e; + throw new RuntimeException("builtin library initialization failed: " + e, e); + } + initializing = false; } } @@ -122,11 +138,10 @@ public class JetStandardLibrary { files.add(file); } - JetSemanticServices bootstrappingSemanticServices = JetSemanticServices.createSemanticServices(this); BindingTraceContext bindingTraceContext = new BindingTraceContext(); WritableScopeImpl writableScope = new WritableScopeImpl(JetStandardClasses.STANDARD_CLASSES, JetStandardClasses.STANDARD_CLASSES_NAMESPACE, RedeclarationHandler.THROW_EXCEPTION).setDebugName("Root bootstrap scope"); writableScope.changeLockLevel(WritableScope.LockLevel.BOTH); - TopDownAnalyzer.processStandardLibraryNamespace(bootstrappingSemanticServices, bindingTraceContext, writableScope, JetStandardClasses.STANDARD_CLASSES_NAMESPACE, files); + TopDownAnalyzer.processStandardLibraryNamespace(project, bindingTraceContext, writableScope, JetStandardClasses.STANDARD_CLASSES_NAMESPACE, files); AnalyzingUtils.throwExceptionOnErrors(bindingTraceContext.getBindingContext()); initStdClasses(); diff --git a/compiler/tests/compiler-tests.iml b/compiler/tests/compiler-tests.iml index d3c95e7a65d..b63d81d0c6a 100644 --- a/compiler/tests/compiler-tests.iml +++ b/compiler/tests/compiler-tests.iml @@ -14,6 +14,7 @@ + diff --git a/compiler/tests/org/jetbrains/jet/compiler/ReadJavaBinaryClassTest.java b/compiler/tests/org/jetbrains/jet/compiler/ReadJavaBinaryClassTest.java index ab5c20da718..b9cd5068055 100644 --- a/compiler/tests/org/jetbrains/jet/compiler/ReadJavaBinaryClassTest.java +++ b/compiler/tests/org/jetbrains/jet/compiler/ReadJavaBinaryClassTest.java @@ -25,7 +25,6 @@ import junit.framework.Test; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.JetTestCaseBuilder; import org.jetbrains.jet.JetTestUtils; -import org.jetbrains.jet.lang.JetSemanticServices; import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.psi.JetFile; @@ -112,8 +111,7 @@ public class ReadJavaBinaryClassTest extends TestCaseWithTmpdir { jetCoreEnvironment.addToClasspath(tmpdir); jetCoreEnvironment.addToClasspath(new File("out/production/runtime")); - JetSemanticServices jetSemanticServices = JetSemanticServices.createSemanticServices(jetCoreEnvironment.getProject()); - JavaSemanticServices semanticServices = new JavaSemanticServices(jetCoreEnvironment.getProject(), jetSemanticServices, new BindingTraceContext()); + JavaSemanticServices semanticServices = new JavaSemanticServices(jetCoreEnvironment.getProject(), new BindingTraceContext()); JavaDescriptorResolver javaDescriptorResolver = semanticServices.getDescriptorResolver(); return javaDescriptorResolver.resolveNamespace("test"); diff --git a/compiler/tests/org/jetbrains/jet/compiler/ReadKotlinBinaryClassTest.java b/compiler/tests/org/jetbrains/jet/compiler/ReadKotlinBinaryClassTest.java index 2a6e0ed02cd..53464129b40 100644 --- a/compiler/tests/org/jetbrains/jet/compiler/ReadKotlinBinaryClassTest.java +++ b/compiler/tests/org/jetbrains/jet/compiler/ReadKotlinBinaryClassTest.java @@ -29,7 +29,6 @@ import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.codegen.ClassBuilderFactories; import org.jetbrains.jet.codegen.ClassFileFactory; import org.jetbrains.jet.codegen.GenerationState; -import org.jetbrains.jet.lang.JetSemanticServices; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.AnalyzingUtils; @@ -90,8 +89,7 @@ public class ReadKotlinBinaryClassTest extends TestCaseWithTmpdir { jetCoreEnvironment.addToClasspath(tmpdir); jetCoreEnvironment.addToClasspath(new File("out/production/runtime")); - JetSemanticServices jetSemanticServices = JetSemanticServices.createSemanticServices(jetCoreEnvironment.getProject()); - JavaSemanticServices semanticServices = new JavaSemanticServices(jetCoreEnvironment.getProject(), jetSemanticServices, new BindingTraceContext()); + JavaSemanticServices semanticServices = new JavaSemanticServices(jetCoreEnvironment.getProject(), new BindingTraceContext()); JavaDescriptorResolver javaDescriptorResolver = semanticServices.getDescriptorResolver(); NamespaceDescriptor namespaceFromClass = javaDescriptorResolver.resolveNamespace("test"); diff --git a/compiler/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java b/compiler/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java index 345b18eaf28..b6e721d8a64 100644 --- a/compiler/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java +++ b/compiler/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java @@ -23,7 +23,6 @@ import com.intellij.openapi.project.Project; import com.intellij.psi.PsiElement; import com.intellij.psi.PsiFile; import com.intellij.psi.util.PsiTreeUtil; -import org.jetbrains.jet.lang.JetSemanticServices; import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.diagnostics.Diagnostic; @@ -135,8 +134,7 @@ public abstract class ExpectedResolveData { } final Set unresolvedReferences = Sets.newHashSet(); Project project = files.iterator().next().getProject(); - JetSemanticServices semanticServices = JetSemanticServices.createSemanticServices(project); - JetStandardLibrary lib = semanticServices.getStandardLibrary(); + JetStandardLibrary lib = JetStandardLibrary.getInstance(); BindingContext bindingContext = AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(project, files, Predicates.alwaysTrue(), JetControlFlowDataTraceFactory.EMPTY); for (Diagnostic diagnostic : bindingContext.getDiagnostics()) { diff --git a/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java b/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java index 48420fb7028..528246b6b22 100644 --- a/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java +++ b/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java @@ -16,6 +16,7 @@ package org.jetbrains.jet.resolve; +import com.google.inject.Guice; import com.intellij.openapi.application.PathManager; import com.intellij.openapi.project.Project; import com.intellij.psi.JavaPsiFacade; @@ -25,17 +26,16 @@ import com.intellij.psi.PsiMethod; import junit.framework.Test; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.JetTestCaseBuilder; -import org.jetbrains.jet.lang.JetSemanticServices; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.BindingTraceContext; +import org.jetbrains.jet.lang.resolve.TopDownAnalysisModule; import org.jetbrains.jet.lang.resolve.calls.CallResolver; import org.jetbrains.jet.lang.resolve.calls.OverloadResolutionResults; import org.jetbrains.jet.lang.resolve.calls.ResolvedCall; -import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; @@ -119,8 +119,7 @@ public class JetResolveTest extends ExtensibleResolveTestCase { @NotNull private PsiClass findClass(String qualifiedName) { Project project = getProject(); - JetSemanticServices jetSemanticServices = JetSemanticServices.createSemanticServices(project); - JavaSemanticServices javaSemanticServices = new JavaSemanticServices(project, jetSemanticServices, new BindingTraceContext()); + JavaSemanticServices javaSemanticServices = new JavaSemanticServices(project, new BindingTraceContext()); return javaSemanticServices.getDescriptorResolver().findClass(qualifiedName); } @@ -135,7 +134,12 @@ public class JetResolveTest extends ExtensibleResolveTestCase { List parameterTypeList = Arrays.asList(parameterType); // JetTypeInferrer.Services typeInferrerServices = JetSemanticServices.createSemanticServices(getProject()).getTypeInferrerServices(new BindingTraceContext()); - CallResolver callResolver = new CallResolver(JetSemanticServices.createSemanticServices(getProject()), DataFlowInfo.EMPTY); + CallResolver callResolver = Guice.createInjector(new TopDownAnalysisModule(getProject(), false) { + @Override + protected void configureAfter() { + } + }).getInstance(CallResolver.class); + OverloadResolutionResults functions = callResolver.resolveExactSignature( classDescriptor.getMemberScope(typeArguments), ReceiverDescriptor.NO_RECEIVER, name, parameterTypeList); for (ResolvedCall resolvedCall : functions.getResultingCalls()) { diff --git a/compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java b/compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java index 341d99f2d53..9f0992c4b09 100644 --- a/compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java +++ b/compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java @@ -16,13 +16,15 @@ package org.jetbrains.jet.types; +import com.google.inject.Guice; +import com.google.inject.Injector; import org.jetbrains.jet.JetLiteFixture; import org.jetbrains.jet.JetTestUtils; -import org.jetbrains.jet.lang.JetSemanticServices; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.DescriptorResolver; +import org.jetbrains.jet.lang.resolve.TopDownAnalysisModule; import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler; @@ -50,9 +52,13 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture { private JetScope scope; public void setUp() throws Exception { - JetStandardLibrary library = JetStandardLibrary.getInstance(); - JetSemanticServices semanticServices = JetSemanticServices.createSemanticServices(library); - descriptorResolver = semanticServices.getClassDescriptorResolver(JetTestUtils.DUMMY_EXCEPTION_ON_ERROR_TRACE); + Injector injector = Guice.createInjector(new TopDownAnalysisModule(getProject(), false) { + @Override + protected void configureAfter() { + } + }); + JetStandardLibrary library = injector.getInstance(JetStandardLibrary.class); + descriptorResolver = injector.getInstance(DescriptorResolver.class); scope = createScope(library.getLibraryScope()); } @@ -72,7 +78,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture { private MutableClassDescriptor createClassDescriptor(ClassKind kind, JetClass aClass) { MutableClassDescriptor classDescriptor = new MutableClassDescriptor(JetTestUtils.DUMMY_TRACE, root, scope, kind); - descriptorResolver.resolveMutableClassDescriptor(aClass, classDescriptor); + descriptorResolver.resolveMutableClassDescriptor(aClass, classDescriptor, JetTestUtils.DUMMY_TRACE); return classDescriptor; } @@ -90,7 +96,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture { List declarations = aClass.getDeclarations(); JetNamedFunction function = (JetNamedFunction) declarations.get(0); - SimpleFunctionDescriptor functionDescriptor = descriptorResolver.resolveFunctionDescriptor(classDescriptor, scope, function); + SimpleFunctionDescriptor functionDescriptor = descriptorResolver.resolveFunctionDescriptor(classDescriptor, scope, function, JetTestUtils.DUMMY_TRACE); assertEquals(expectedFunctionModality, functionDescriptor.getModality()); } @@ -101,7 +107,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture { List declarations = aClass.getDeclarations(); JetProperty property = (JetProperty) declarations.get(0); - PropertyDescriptor propertyDescriptor = descriptorResolver.resolvePropertyDescriptor(classDescriptor, scope, property); + PropertyDescriptor propertyDescriptor = descriptorResolver.resolvePropertyDescriptor(classDescriptor, scope, property, JetTestUtils.DUMMY_TRACE); assertEquals(expectedPropertyModality, propertyDescriptor.getModality()); } @@ -113,7 +119,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture { List declarations = aClass.getDeclarations(); JetProperty property = (JetProperty) declarations.get(0); - PropertyDescriptor propertyDescriptor = descriptorResolver.resolvePropertyDescriptor(classDescriptor, scope, property); + PropertyDescriptor propertyDescriptor = descriptorResolver.resolvePropertyDescriptor(classDescriptor, scope, property, JetTestUtils.DUMMY_TRACE); PropertyAccessorDescriptor propertyAccessor = isGetter ? propertyDescriptor.getGetter() : propertyDescriptor.getSetter(); diff --git a/compiler/tests/org/jetbrains/jet/types/JetOverloadTest.java b/compiler/tests/org/jetbrains/jet/types/JetOverloadTest.java index 593f6d1dfec..816c90250b6 100644 --- a/compiler/tests/org/jetbrains/jet/types/JetOverloadTest.java +++ b/compiler/tests/org/jetbrains/jet/types/JetOverloadTest.java @@ -16,16 +16,18 @@ package org.jetbrains.jet.types; +import com.google.inject.Guice; +import com.google.inject.Injector; import org.jetbrains.jet.JetLiteFixture; import org.jetbrains.jet.JetTestCaseBuilder; import org.jetbrains.jet.JetTestUtils; -import org.jetbrains.jet.lang.JetSemanticServices; import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.psi.JetNamedFunction; import org.jetbrains.jet.lang.psi.JetPsiFactory; import org.jetbrains.jet.lang.resolve.DescriptorResolver; import org.jetbrains.jet.lang.resolve.OverloadUtil; +import org.jetbrains.jet.lang.resolve.TopDownAnalysisModule; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; /** @@ -35,15 +37,18 @@ public class JetOverloadTest extends JetLiteFixture { private ModuleDescriptor root = new ModuleDescriptor("test_root"); private JetStandardLibrary library; - private JetSemanticServices semanticServices; private DescriptorResolver descriptorResolver; @Override public void setUp() throws Exception { super.setUp(); - library = JetStandardLibrary.getInstance(); - semanticServices = JetSemanticServices.createSemanticServices(library); - descriptorResolver = semanticServices.getClassDescriptorResolver(JetTestUtils.DUMMY_TRACE); + Injector injector = Guice.createInjector(new TopDownAnalysisModule(getProject(), false) { + @Override + protected void configureAfter() { + } + }); + library = injector.getInstance(JetStandardLibrary.class); + descriptorResolver = injector.getInstance(DescriptorResolver.class); } @Override @@ -171,7 +176,7 @@ public class JetOverloadTest extends JetLiteFixture { private FunctionDescriptor makeFunction(String funDecl) { JetNamedFunction function = JetPsiFactory.createFunction(getProject(), funDecl); - return descriptorResolver.resolveFunctionDescriptor(root, library.getLibraryScope(), function); + return descriptorResolver.resolveFunctionDescriptor(root, library.getLibraryScope(), function, JetTestUtils.DUMMY_TRACE); } } diff --git a/compiler/tests/org/jetbrains/jet/types/JetOverridingTest.java b/compiler/tests/org/jetbrains/jet/types/JetOverridingTest.java index b38932993a6..5fc840dcd5f 100644 --- a/compiler/tests/org/jetbrains/jet/types/JetOverridingTest.java +++ b/compiler/tests/org/jetbrains/jet/types/JetOverridingTest.java @@ -16,16 +16,18 @@ package org.jetbrains.jet.types; +import com.google.inject.Guice; +import com.google.inject.Injector; import org.jetbrains.jet.JetLiteFixture; import org.jetbrains.jet.JetTestCaseBuilder; import org.jetbrains.jet.JetTestUtils; -import org.jetbrains.jet.lang.JetSemanticServices; import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.psi.JetNamedFunction; import org.jetbrains.jet.lang.psi.JetPsiFactory; import org.jetbrains.jet.lang.resolve.DescriptorResolver; import org.jetbrains.jet.lang.resolve.OverridingUtil; +import org.jetbrains.jet.lang.resolve.TopDownAnalysisModule; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; /** @@ -35,15 +37,18 @@ public class JetOverridingTest extends JetLiteFixture { private ModuleDescriptor root = new ModuleDescriptor("test_root"); private JetStandardLibrary library; - private JetSemanticServices semanticServices; private DescriptorResolver descriptorResolver; @Override public void setUp() throws Exception { super.setUp(); - library = JetStandardLibrary.getInstance(); - semanticServices = JetSemanticServices.createSemanticServices(library); - descriptorResolver = semanticServices.getClassDescriptorResolver(JetTestUtils.DUMMY_TRACE); + Injector injector = Guice.createInjector(new TopDownAnalysisModule(getProject(), false) { + @Override + protected void configureAfter() { + } + }); + library = injector.getInstance(JetStandardLibrary.class); + descriptorResolver = injector.getInstance(DescriptorResolver.class); } @Override @@ -161,6 +166,6 @@ public class JetOverridingTest extends JetLiteFixture { private FunctionDescriptor makeFunction(String funDecl) { JetNamedFunction function = JetPsiFactory.createFunction(getProject(), funDecl); - return descriptorResolver.resolveFunctionDescriptor(root, library.getLibraryScope(), function); + return descriptorResolver.resolveFunctionDescriptor(root, library.getLibraryScope(), function, JetTestUtils.DUMMY_TRACE); } } diff --git a/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java b/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java index 6bfec86797b..81fedd44e30 100644 --- a/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java +++ b/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java @@ -17,13 +17,14 @@ package org.jetbrains.jet.types; import com.google.common.collect.Sets; +import com.google.inject.Guice; +import com.google.inject.Injector; import com.intellij.openapi.project.Project; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.JetLiteFixture; import org.jetbrains.jet.JetTestCaseBuilder; import org.jetbrains.jet.JetTestUtils; -import org.jetbrains.jet.lang.JetSemanticServices; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.psi.*; @@ -36,6 +37,8 @@ import org.jetbrains.jet.lang.resolve.scopes.*; import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; import org.jetbrains.jet.lang.types.*; +import org.jetbrains.jet.lang.types.checker.JetTypeChecker; +import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; import org.jetbrains.jet.lang.types.lang.JetStandardClasses; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import org.jetbrains.jet.lexer.JetTokens; @@ -48,11 +51,12 @@ import java.util.*; public class JetTypeCheckerTest extends JetLiteFixture { private JetStandardLibrary library; - private JetSemanticServices semanticServices; private ClassDefinitions classDefinitions; private DescriptorResolver descriptorResolver; private JetScope scopeWithImports; private TypeResolver typeResolver; + private ExpressionTypingServices expressionTypingServices; + public JetTypeCheckerTest() { super(""); @@ -62,11 +66,19 @@ public class JetTypeCheckerTest extends JetLiteFixture { public void setUp() throws Exception { super.setUp(); library = JetStandardLibrary.getInstance(); - semanticServices = JetSemanticServices.createSemanticServices(library); classDefinitions = new ClassDefinitions(); - descriptorResolver = semanticServices.getClassDescriptorResolver(JetTestUtils.DUMMY_TRACE); + + Injector injector = Guice.createInjector(new TopDownAnalysisModule(getProject(), false) { + @Override + protected void configureAfter() { + } + }); + descriptorResolver = injector.getInstance(DescriptorResolver.class); + descriptorResolver = injector.getInstance(DescriptorResolver.class); + typeResolver = injector.getInstance(TypeResolver.class); + expressionTypingServices = injector.getInstance(ExpressionTypingServices.class); + scopeWithImports = addImports(classDefinitions.BASIC_SCOPE); - typeResolver = new TypeResolver(semanticServices, JetTestUtils.DUMMY_TRACE, true); } @Override @@ -513,7 +525,7 @@ public class JetTypeCheckerTest extends JetLiteFixture { for (String type : types) { typesToIntersect.add(makeType(type)); } - JetType result = TypeUtils.intersect(semanticServices.getTypeChecker(), typesToIntersect); + JetType result = TypeUtils.intersect(JetTypeChecker.INSTANCE, typesToIntersect); // assertNotNull("Intersection is null for " + typesToIntersect, result); assertEquals(makeType(expected), result); } @@ -530,7 +542,7 @@ public class JetTypeCheckerTest extends JetLiteFixture { private void assertSubtypingRelation(String subtype, String supertype, boolean expected) { JetType typeNode1 = makeType(subtype); JetType typeNode2 = makeType(supertype); - boolean result = semanticServices.getTypeChecker().isSubtypeOf( + boolean result = JetTypeChecker.INSTANCE.isSubtypeOf( typeNode1, typeNode2); String modifier = expected ? "not " : ""; @@ -540,14 +552,14 @@ public class JetTypeCheckerTest extends JetLiteFixture { private void assertType(String expression, JetType expectedType) { Project project = getProject(); JetExpression jetExpression = JetPsiFactory.createExpression(project, expression); - JetType type = semanticServices.getTypeInferrerServices(JetTestUtils.DUMMY_TRACE).getType(scopeWithImports, jetExpression, TypeUtils.NO_EXPECTED_TYPE); + JetType type = expressionTypingServices.getType(scopeWithImports, jetExpression, TypeUtils.NO_EXPECTED_TYPE, JetTestUtils.DUMMY_TRACE); assertTrue(type + " != " + expectedType, type.equals(expectedType)); } private void assertErrorType(String expression) { Project project = getProject(); JetExpression jetExpression = JetPsiFactory.createExpression(project, expression); - JetType type = semanticServices.getTypeInferrerServices(JetTestUtils.DUMMY_TRACE).safeGetType(scopeWithImports, jetExpression, TypeUtils.NO_EXPECTED_TYPE); + JetType type = expressionTypingServices.safeGetType(scopeWithImports, jetExpression, TypeUtils.NO_EXPECTED_TYPE, JetTestUtils.DUMMY_TRACE); assertTrue("Error type expected but " + type + " returned", ErrorUtils.isErrorType(type)); } @@ -570,7 +582,7 @@ public class JetTypeCheckerTest extends JetLiteFixture { private void assertType(JetScope scope, String expression, String expectedTypeStr) { Project project = getProject(); JetExpression jetExpression = JetPsiFactory.createExpression(project, expression); - JetType type = semanticServices.getTypeInferrerServices(JetTestUtils.DUMMY_TRACE).getType(addImports(scope), jetExpression, TypeUtils.NO_EXPECTED_TYPE); + JetType type = expressionTypingServices.getType(addImports(scope), jetExpression, TypeUtils.NO_EXPECTED_TYPE, JetTestUtils.DUMMY_TRACE); JetType expectedType = expectedTypeStr == null ? null : makeType(expectedTypeStr); assertEquals(expectedType, type); } @@ -578,7 +590,7 @@ public class JetTypeCheckerTest extends JetLiteFixture { private WritableScopeImpl addImports(JetScope scope) { WritableScopeImpl writableScope = new WritableScopeImpl(scope, scope.getContainingDeclaration(), RedeclarationHandler.DO_NOTHING); writableScope.importScope(library.getLibraryScope()); - JavaSemanticServices javaSemanticServices = new JavaSemanticServices(getProject(), semanticServices, JetTestUtils.DUMMY_TRACE); + JavaSemanticServices javaSemanticServices = new JavaSemanticServices(getProject(), JetTestUtils.DUMMY_TRACE); writableScope.importScope(new JavaPackageScope("", JavaBridgeConfiguration.createNamespaceDescriptor(JavaDescriptorResolver.JAVA_ROOT, ""), javaSemanticServices)); writableScope.importScope(new JavaPackageScope("java.lang", JavaBridgeConfiguration.createNamespaceDescriptor("lang", "java.lang"), javaSemanticServices)); writableScope.changeLockLevel(WritableScope.LockLevel.BOTH); @@ -590,7 +602,7 @@ public class JetTypeCheckerTest extends JetLiteFixture { } private JetType makeType(JetScope scope, String typeStr) { - return new TypeResolver(semanticServices, JetTestUtils.DUMMY_TRACE, true).resolveType(scope, JetPsiFactory.createType(getProject(), typeStr)); + return typeResolver.resolveType(scope, JetPsiFactory.createType(getProject(), typeStr), JetTestUtils.DUMMY_TRACE, true); } private class ClassDefinitions { @@ -657,7 +669,7 @@ public class JetTypeCheckerTest extends JetLiteFixture { Set writableFunctionGroup = Sets.newLinkedHashSet(); ModuleDescriptor module = new ModuleDescriptor("TypeCheckerTest"); for (String funDecl : FUNCTION_DECLARATIONS) { - FunctionDescriptor functionDescriptor = descriptorResolver.resolveFunctionDescriptor(module, this, JetPsiFactory.createFunction(getProject(), funDecl)); + FunctionDescriptor functionDescriptor = descriptorResolver.resolveFunctionDescriptor(module, this, JetPsiFactory.createFunction(getProject(), funDecl), JetTestUtils.DUMMY_TRACE); if (name.equals(functionDescriptor.getName())) { writableFunctionGroup.add(functionDescriptor); } @@ -682,14 +694,14 @@ public class JetTypeCheckerTest extends JetLiteFixture { // This call has side-effects on the parameterScope (fills it in) List typeParameters - = descriptorResolver.resolveTypeParameters(classDescriptor, parameterScope, classElement.getTypeParameters()); - descriptorResolver.resolveGenericBounds(classElement, parameterScope, typeParameters); + = descriptorResolver.resolveTypeParameters(classDescriptor, parameterScope, classElement.getTypeParameters(), JetTestUtils.DUMMY_TRACE); + descriptorResolver.resolveGenericBounds(classElement, parameterScope, typeParameters, JetTestUtils.DUMMY_TRACE); List delegationSpecifiers = classElement.getDelegationSpecifiers(); // TODO : assuming that the hierarchy is acyclic Collection supertypes = delegationSpecifiers.isEmpty() ? Collections.singleton(JetStandardClasses.getAnyType()) - : descriptorResolver.resolveDelegationSpecifiers(parameterScope, delegationSpecifiers, typeResolver); + : descriptorResolver.resolveDelegationSpecifiers(parameterScope, delegationSpecifiers, typeResolver, JetTestUtils.DUMMY_TRACE, true); // for (JetType supertype: supertypes) { // if (supertype.getConstructor().isSealed()) { // trace.getErrorHandler().genericError(classElement.getNameAsDeclaration().getNode(), "Class " + classElement.getName() + " can not extend final type " + supertype); @@ -706,7 +718,7 @@ public class JetTypeCheckerTest extends JetLiteFixture { @Override public void visitProperty(JetProperty property) { if (property.getPropertyTypeRef() != null) { - memberDeclarations.addPropertyDescriptor(descriptorResolver.resolvePropertyDescriptor(classDescriptor, parameterScope, property)); + memberDeclarations.addPropertyDescriptor(descriptorResolver.resolvePropertyDescriptor(classDescriptor, parameterScope, property, JetTestUtils.DUMMY_TRACE)); } else { // TODO : Caution: a cyclic dependency possible throw new UnsupportedOperationException(); @@ -716,7 +728,7 @@ public class JetTypeCheckerTest extends JetLiteFixture { @Override public void visitNamedFunction(JetNamedFunction function) { if (function.getReturnTypeRef() != null) { - memberDeclarations.addFunctionDescriptor(descriptorResolver.resolveFunctionDescriptor(classDescriptor, parameterScope, function)); + memberDeclarations.addFunctionDescriptor(descriptorResolver.resolveFunctionDescriptor(classDescriptor, parameterScope, function, JetTestUtils.DUMMY_TRACE)); } else { // TODO : Caution: a cyclic dependency possible throw new UnsupportedOperationException(); @@ -740,11 +752,11 @@ public class JetTypeCheckerTest extends JetLiteFixture { null ); for (JetSecondaryConstructor constructor : classElement.getSecondaryConstructors()) { - ConstructorDescriptorImpl functionDescriptor = descriptorResolver.resolveSecondaryConstructorDescriptor(memberDeclarations, classDescriptor, constructor); + ConstructorDescriptorImpl functionDescriptor = descriptorResolver.resolveSecondaryConstructorDescriptor(memberDeclarations, classDescriptor, constructor, JetTestUtils.DUMMY_TRACE); functionDescriptor.setReturnType(classDescriptor.getDefaultType()); constructors.add(functionDescriptor); } - ConstructorDescriptorImpl primaryConstructorDescriptor = descriptorResolver.resolvePrimaryConstructorDescriptor(scope, classDescriptor, classElement); + ConstructorDescriptorImpl primaryConstructorDescriptor = descriptorResolver.resolvePrimaryConstructorDescriptor(scope, classDescriptor, classElement, JetTestUtils.DUMMY_TRACE); if (primaryConstructorDescriptor != null) { primaryConstructorDescriptor.setReturnType(classDescriptor.getDefaultType()); constructors.add(primaryConstructorDescriptor); diff --git a/idea/idea.iml b/idea/idea.iml index 99b26f27f32..a91c6c948a6 100644 --- a/idea/idea.iml +++ b/idea/idea.iml @@ -27,6 +27,7 @@ + diff --git a/idea/src/org/jetbrains/jet/plugin/liveTemplates/macro/BaseJetVariableMacro.java b/idea/src/org/jetbrains/jet/plugin/liveTemplates/macro/BaseJetVariableMacro.java index 87e6e467d5a..9e61c79909e 100644 --- a/idea/src/org/jetbrains/jet/plugin/liveTemplates/macro/BaseJetVariableMacro.java +++ b/idea/src/org/jetbrains/jet/plugin/liveTemplates/macro/BaseJetVariableMacro.java @@ -16,6 +16,7 @@ package org.jetbrains.jet.plugin.liveTemplates.macro; +import com.google.inject.Guice; import com.intellij.codeInsight.lookup.LookupElement; import com.intellij.codeInsight.lookup.LookupElementBuilder; import com.intellij.codeInsight.template.Expression; @@ -34,7 +35,10 @@ import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.descriptors.VariableDescriptor; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; +import org.jetbrains.jet.lang.resolve.TopDownAnalysisModule; import org.jetbrains.jet.lang.resolve.scopes.JetScope; +import org.jetbrains.jet.lang.types.expressions.ExpressionTypingContext; +import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; import org.jetbrains.jet.plugin.compiler.WholeProjectAnalyzerFacade; import java.util.ArrayList; @@ -51,7 +55,7 @@ public abstract class BaseJetVariableMacro extends Macro { private JetNamedDeclaration[] getVariables(Expression[] params, ExpressionContext context) { if (params.length != 0) return null; - Project project = context.getProject(); + final Project project = context.getProject(); PsiDocumentManager.getInstance(project).commitAllDocuments(); PsiFile psiFile = PsiDocumentManager.getInstance(project).getPsiFile(context.getEditor().getDocument()); @@ -66,11 +70,17 @@ public abstract class BaseJetVariableMacro extends Macro { return null; } + ExpressionTypingServices callResolverContext = Guice.createInjector(new TopDownAnalysisModule(project, false) { + @Override + protected void configureAfter() { + } + }).getInstance(ExpressionTypingServices.class); + List filteredDescriptors = new ArrayList(); for (DeclarationDescriptor declarationDescriptor : scope.getAllDescriptors()) { if (declarationDescriptor instanceof VariableDescriptor) { VariableDescriptor variableDescriptor = (VariableDescriptor) declarationDescriptor; - if (isSuitable(variableDescriptor, scope, project)) { + if (isSuitable(variableDescriptor, scope, project, callResolverContext)) { filteredDescriptors.add(variableDescriptor); } } @@ -89,7 +99,7 @@ public abstract class BaseJetVariableMacro extends Macro { return declarations.toArray(new JetNamedDeclaration[declarations.size()]); } - protected abstract boolean isSuitable(@NotNull VariableDescriptor variableDescriptor, @NotNull JetScope scope, @NotNull Project project); + protected abstract boolean isSuitable(@NotNull VariableDescriptor variableDescriptor, @NotNull JetScope scope, @NotNull Project project, ExpressionTypingServices callResolverContext); @Nullable private static JetExpression findContextExpression(PsiFile psiFile, int startOffset) { diff --git a/idea/src/org/jetbrains/jet/plugin/liveTemplates/macro/JetAnyVariableMacro.java b/idea/src/org/jetbrains/jet/plugin/liveTemplates/macro/JetAnyVariableMacro.java index 127c1ce7e81..ff9c2a511d6 100644 --- a/idea/src/org/jetbrains/jet/plugin/liveTemplates/macro/JetAnyVariableMacro.java +++ b/idea/src/org/jetbrains/jet/plugin/liveTemplates/macro/JetAnyVariableMacro.java @@ -20,6 +20,7 @@ import com.intellij.openapi.project.Project; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.VariableDescriptor; import org.jetbrains.jet.lang.resolve.scopes.JetScope; +import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; import org.jetbrains.jet.plugin.JetBundle; /** @@ -38,7 +39,7 @@ public class JetAnyVariableMacro extends BaseJetVariableMacro { } @Override - protected boolean isSuitable(@NotNull VariableDescriptor variableDescriptor, @NotNull JetScope scope, @NotNull Project project) { + protected boolean isSuitable(@NotNull VariableDescriptor variableDescriptor, @NotNull JetScope scope, @NotNull Project project, ExpressionTypingServices callResolverContext) { return true; } } diff --git a/idea/src/org/jetbrains/jet/plugin/liveTemplates/macro/JetIterableVariableMacro.java b/idea/src/org/jetbrains/jet/plugin/liveTemplates/macro/JetIterableVariableMacro.java index da9808d61a1..8c9c8dac21a 100644 --- a/idea/src/org/jetbrains/jet/plugin/liveTemplates/macro/JetIterableVariableMacro.java +++ b/idea/src/org/jetbrains/jet/plugin/liveTemplates/macro/JetIterableVariableMacro.java @@ -20,6 +20,7 @@ import com.intellij.openapi.project.Project; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.VariableDescriptor; import org.jetbrains.jet.lang.resolve.scopes.JetScope; +import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingUtils; import org.jetbrains.jet.plugin.JetBundle; @@ -28,6 +29,7 @@ import org.jetbrains.jet.plugin.JetBundle; * @since 2/7/12 */ public class JetIterableVariableMacro extends BaseJetVariableMacro { + @Override public String getName() { return "kotlinIterableVariable"; @@ -39,7 +41,7 @@ public class JetIterableVariableMacro extends BaseJetVariableMacro { } @Override - protected boolean isSuitable(@NotNull VariableDescriptor variableDescriptor, @NotNull JetScope scope, @NotNull Project project) { - return ExpressionTypingUtils.isVariableIterable(project, variableDescriptor, scope); + protected boolean isSuitable(@NotNull VariableDescriptor variableDescriptor, @NotNull JetScope scope, @NotNull Project project, ExpressionTypingServices callResolverContext) { + return ExpressionTypingUtils.isVariableIterable(callResolverContext, project, variableDescriptor, scope); } } diff --git a/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java b/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java index a798d0bc595..6286bce5fcd 100644 --- a/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java +++ b/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java @@ -23,7 +23,6 @@ import com.intellij.psi.PsiFile; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.Configuration; -import org.jetbrains.jet.lang.JetSemanticServices; import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.psi.JetFile; @@ -95,15 +94,14 @@ public final class AnalyzerFacadeForJS { public static BindingContext analyzeNamespace(@NotNull JetFile file) { BindingTraceContext bindingTraceContext = new BindingTraceContext(); Project project = file.getProject(); - JetSemanticServices semanticServices = JetSemanticServices.createSemanticServices(project); return AnalyzingUtils.analyzeFilesWithGivenTrace( project, JsConfiguration.jsLibConfiguration(project), Collections.singletonList(file), Predicates.alwaysTrue(), JetControlFlowDataTraceFactory.EMPTY, - bindingTraceContext, - semanticServices); + bindingTraceContext + ); } private static final class JsConfiguration implements Configuration { diff --git a/lib/guice/aopalliance.jar b/lib/guice/aopalliance.jar new file mode 100644 index 0000000000000000000000000000000000000000..578b1a0c359ef88a84461bdb91d9d0041afd54de GIT binary patch literal 4467 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
  • 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

    oXW@bynp0q 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

    wxe=_BHa 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%0Dp1qakkL|R*(Epas!oWf8O+m*0lnEb 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 literal 0 HcmV?d00001 diff --git a/lib/guice/guice-3.0.jar b/lib/guice/guice-3.0.jar new file mode 100644 index 0000000000000000000000000000000000000000..76be5e0dd45859e52870c92ba6695f96417a4d71 GIT binary patch literal 710683 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

    t$XEsw$DZ>ce$H7VXRbbg!VL&p}klkK> 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
    e8V0ChpMXLVDWvdcu~Qd5KEP+B(| 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 literal 0 HcmV?d00001 diff --git a/lib/guice/javax.inject.jar b/lib/guice/javax.inject.jar new file mode 100644 index 0000000000000000000000000000000000000000..a9dfb86d27a3b18b646dad07f15b0d28d729cef7 GIT binary patch literal 2497 zcmaJ@3pAAZ8=e__BdVQ6VP}XaB-E%}=Fl*jT7#Vok!`CnuH!OtJISTRAVjlh&B&B% zV#KV z9}|W8xcK}4K;j@WF_?H+Z@m=+!f%9Y$YHsdAIuaauHs)lJhXoB)Jwxl)2($d4RG`JXt;xGjq1L9OcrMJ`MG~U zrfGA#W%{g~Q*R&RMJ!jcUmw470i^6VGu+d_h`WpSp}$Q`<5;GmO^y&Or`POC^6E}x z!dY&MMZc1Z$Dh*wv}7SGvM=*q-Bnw+Wxk0!$zntj5x5>G~}PeCCDO*+hj z?StHR%<;Pz)37Q=LakCVn#5H|s(xWleBtY?1CEsW8~O48k&?U1Zl#9A9qC_(w^GG= zGJBYaH!UkvQf3zTJp_+~N>&|38SVswK=u54Yf=?NNwp#RxVn7d)Ed`-hQ+@2B;?Mq z?n_;<)jOdFbl#S-hgFh`UR94*diQy&^y#c}ugpUK$!+xf2Ae%Zq$`ev@Fo|$*1RQFZqr!~BUQJXyw4^K8|Aa@-{dT6makYuEHU$BudeHve`xfqF z@!gVrb8ccxhF{v{$-w4PP7kKxW{o;RSEHt>-^M6tF4X~h81Ji zIe@k0$hISz*Q6QEUJN8NEzov~#hwL+Y0f1l2Fv;lb-Z5b81}EdYFZ0AH>`=)Mx)Rt zv*u{&C$QE1H1xt_J8Z4j0o?*}p}0+Vx3NjC#_wGu%r8}Jf(Ux+p}i#Z(!) zKUBi6za2^@bh2~|Le8xEzDpV>-3X)h+h_$0Ur~olCmAS)p3eGFv6?~n0iD%cB~eT6 zT_2e29j<7r1$#ZxgHcV6{Py<+su&_?+oz`6)5KpX-;V`#i`_ zBbxTmn9|Xli{p(|tncfn;%+UD*4L#8&2U>=Cy3JC(y@BzZ1(l)gD(2<*8Kwm3(VB9 zh!0^A;D;ELxxTq}JsUmp*Uh#l<;v_XIbXAC{i-t%`4G?FZ$GOzKOUdm=)}9p?I;n~ zjf;#=Du3pJ9uB=YtB#J+O>;sP&Gmk;0{kpsIXc0`h(AD~2z0RP9ADHs(h42+U(TtWRAM!fd@a zc%1`*9DNlk$%OYW+>^iER4ut{-NS|CWLq$j)A`Eo1#Du@3O zB*D|y-P<*g;`^D$8*P>tv+c1T>?S>)_s2+;^jN3wEct0yk;>%}M9^_13$Ka6Br@|+S-ZvX+k0F%UkagIP*qm z@|Pk$4Ti{pHk?}6ZUj!f5d{8n(^g^M#^W}_2v1u$HM1VvFq9~HEsy7#=Bq4$%Gz~;igg^S`^AG`1l+FEs$4T%r QKp+3C)c7P^g9_gM57H-)%K!iX literal 0 HcmV?d00001

    Vt(!!Ze~}CJ2??i=+&=vb9LGQL0T1e2 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ȇgHE2bH}F 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