diff --git a/idea/src/org/jetbrains/jet/lang/resolve/BindingTrace.java b/idea/src/org/jetbrains/jet/lang/resolve/BindingTrace.java index 80093635c6f..46e2c1db7c0 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/BindingTrace.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/BindingTrace.java @@ -12,74 +12,6 @@ import org.jetbrains.jet.lang.types.JetType; * @author abreslav */ public interface BindingTrace { - public static final BindingTrace DUMMY = new BindingTrace() { - - @Override - public void recordExpressionType(@NotNull JetExpression expression, @NotNull JetType type) { - } - - @Override - public void recordReferenceResolution(@NotNull JetReferenceExpression expression, @NotNull DeclarationDescriptor descriptor) { - } - - @Override - public void recordLabelResolution(@NotNull JetReferenceExpression expression, @NotNull PsiElement element) { - } - - @Override - public void recordDeclarationResolution(@NotNull PsiElement declaration, @NotNull DeclarationDescriptor descriptor) { - } - - @Override - public void recordValueParameterAsPropertyResolution(@NotNull JetParameter declaration, @NotNull PropertyDescriptor descriptor) { - - } - - @Override - public void recordTypeResolution(@NotNull JetTypeReference typeReference, @NotNull JetType type) { - } - - @Override - public void recordBlock(JetFunctionLiteralExpression expression) { - } - - @Override - public void recordStatement(@NotNull JetElement statement) { - } - - @Override - public void removeStatementRecord(@NotNull JetElement statement) { - } - - @Override - public void removeReferenceResolution(@NotNull JetReferenceExpression referenceExpression) { - } - - @Override - public void requireBackingField(@NotNull PropertyDescriptor propertyDescriptor) { - } - - @NotNull - @Override - public ErrorHandler getErrorHandler() { - return ErrorHandler.DO_NOTHING; - } - - @Override - public boolean isProcessed(@NotNull JetExpression expression) { - return false; - } - - @Override - public void markAsProcessed(@NotNull JetExpression expression) { - - } - - @Override - public BindingContext getBindingContext() { - throw new UnsupportedOperationException(); - } - }; void recordExpressionType(@NotNull JetExpression expression, @NotNull JetType type); diff --git a/idea/src/org/jetbrains/jet/lang/resolve/BindingTraceContext.java b/idea/src/org/jetbrains/jet/lang/resolve/BindingTraceContext.java index 23f9555e2c6..6fd409578df 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/BindingTraceContext.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/BindingTraceContext.java @@ -71,7 +71,7 @@ public class BindingTraceContext implements BindingContext, BindingTrace { @Override public void recordExpressionType(@NotNull JetExpression expression, @NotNull JetType type) { - expressionTypes.put(expression, type); + safePut(expressionTypes, expression, type); } @Override @@ -81,7 +81,7 @@ public class BindingTraceContext implements BindingContext, BindingTrace { @Override public void recordLabelResolution(@NotNull JetReferenceExpression expression, @NotNull PsiElement element) { - labelResolutionResults.put(expression, element); + safePut(labelResolutionResults, expression, element); } @Override @@ -91,7 +91,7 @@ public class BindingTraceContext implements BindingContext, BindingTrace { @Override public void recordTypeResolution(@NotNull JetTypeReference typeReference, @NotNull JetType type) { - types.put(typeReference, type); + safePut(types, typeReference, type); } @Override @@ -106,7 +106,7 @@ public class BindingTraceContext implements BindingContext, BindingTrace { @Override public Void visitNamespaceDescriptor(NamespaceDescriptor descriptor, PsiElement declaration) { - namespaceDeclarationsToDescriptors.put(declaration, descriptor); + safePut(namespaceDeclarationsToDescriptors, declaration, descriptor); return null; } diff --git a/idea/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java b/idea/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java index 4367ac4eeb7..924da80e9a4 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java @@ -573,15 +573,15 @@ public class TopDownAnalyzer { public void visitDelegationToSuperCallSpecifier(JetDelegatorToSuperCall call) { JetTypeReference typeReference = call.getTypeReference(); if (typeReference != null) { - if (!jetClass.hasPrimaryConstructor()) { + if (jetClass.hasPrimaryConstructor()) { + typeInferrer.checkConstructorCall(scopeForConstructor, typeReference, call); + } + else { JetArgumentList valueArgumentList = call.getValueArgumentList(); assert valueArgumentList != null; trace.getErrorHandler().genericError(valueArgumentList.getNode(), "Class " + JetPsiUtil.safeName(jetClass.getName()) + " must have a constructor in order to be able to initialize supertypes"); } - else { - typeInferrer.checkConstructorCall(scopeForConstructor, typeReference, call); - } } } diff --git a/idea/src/org/jetbrains/jet/lang/resolve/TypeResolver.java b/idea/src/org/jetbrains/jet/lang/resolve/TypeResolver.java index 31f89981314..0aef62a92ed 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/TypeResolver.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/TypeResolver.java @@ -28,6 +28,9 @@ public class TypeResolver { @NotNull public JetType resolveType(@NotNull final JetScope scope, @NotNull final JetTypeReference typeReference) { + JetType cachedType = trace.getBindingContext().resolveTypeReference(typeReference); + if (cachedType != null) return cachedType; + final List annotations = AnnotationResolver.INSTANCE.resolveAnnotations(typeReference.getAttributes()); JetTypeElement typeElement = typeReference.getTypeElement(); diff --git a/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java b/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java index 417f2c0c836..b3761fedac6 100644 --- a/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java +++ b/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java @@ -494,6 +494,7 @@ public class JetTypeInferrer { else { trace.getErrorHandler().genericError(((JetElement) call).getNode(), "Calling a constructor is only supported for ordinary classes"); // TODO : review the message } + return null; } else { if (typeElement != null) { diff --git a/idea/tests/org/jetbrains/jet/JetTestUtils.java b/idea/tests/org/jetbrains/jet/JetTestUtils.java new file mode 100644 index 00000000000..7bc454cc2d0 --- /dev/null +++ b/idea/tests/org/jetbrains/jet/JetTestUtils.java @@ -0,0 +1,184 @@ +package org.jetbrains.jet; + +import com.intellij.psi.PsiElement; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.codegen.ClassCodegen; +import org.jetbrains.jet.lang.ErrorHandler; +import org.jetbrains.jet.lang.JetDiagnostic; +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.BindingTrace; +import org.jetbrains.jet.lang.types.JetType; + +import java.util.Collection; + +/** + * @author abreslav + */ +public class JetTestUtils { + public static final BindingTrace DUMMY = new BindingTrace() { + + @Override + public void recordExpressionType(@NotNull JetExpression expression, @NotNull JetType type) { + } + + @Override + public void recordReferenceResolution(@NotNull JetReferenceExpression expression, @NotNull DeclarationDescriptor descriptor) { + } + + @Override + public void recordLabelResolution(@NotNull JetReferenceExpression expression, @NotNull PsiElement element) { + } + + @Override + public void recordDeclarationResolution(@NotNull PsiElement declaration, @NotNull DeclarationDescriptor descriptor) { + } + + @Override + public void recordValueParameterAsPropertyResolution(@NotNull JetParameter declaration, @NotNull PropertyDescriptor descriptor) { + + } + + @Override + public void recordTypeResolution(@NotNull JetTypeReference typeReference, @NotNull JetType type) { + } + + @Override + public void recordBlock(JetFunctionLiteralExpression expression) { + } + + @Override + public void recordStatement(@NotNull JetElement statement) { + } + + @Override + public void removeStatementRecord(@NotNull JetElement statement) { + } + + @Override + public void removeReferenceResolution(@NotNull JetReferenceExpression referenceExpression) { + } + + @Override + public void requireBackingField(@NotNull PropertyDescriptor propertyDescriptor) { + } + + @NotNull + @Override + public ErrorHandler getErrorHandler() { + return ErrorHandler.DO_NOTHING; + } + + @Override + public boolean isProcessed(@NotNull JetExpression expression) { + return false; + } + + @Override + public void markAsProcessed(@NotNull JetExpression expression) { + + } + + @Override + public BindingContext getBindingContext() { + return new BindingContext() { + + @Override + public DeclarationDescriptor getDeclarationDescriptor(PsiElement declaration) { + throw new UnsupportedOperationException(); // TODO + } + + @Override + public NamespaceDescriptor getNamespaceDescriptor(JetNamespace declaration) { + throw new UnsupportedOperationException(); // TODO + } + + @Override + public ClassDescriptor getClassDescriptor(JetClass declaration) { + throw new UnsupportedOperationException(); // TODO + } + + @Override + public TypeParameterDescriptor getTypeParameterDescriptor(JetTypeParameter declaration) { + throw new UnsupportedOperationException(); // TODO + } + + @Override + public FunctionDescriptor getFunctionDescriptor(JetFunction declaration) { + throw new UnsupportedOperationException(); // TODO + } + + @Override + public ConstructorDescriptor getConstructorDescriptor(JetElement declaration) { + throw new UnsupportedOperationException(); // TODO + } + + @Override + public VariableDescriptor getVariableDescriptor(JetProperty declaration) { + throw new UnsupportedOperationException(); // TODO + } + + @Override + public VariableDescriptor getVariableDescriptor(JetParameter declaration) { + throw new UnsupportedOperationException(); // TODO + } + + @Override + public PropertyDescriptor getPropertyDescriptor(JetParameter primaryConstructorParameter) { + throw new UnsupportedOperationException(); // TODO + } + + @Override + public JetType getExpressionType(JetExpression expression) { + throw new UnsupportedOperationException(); // TODO + } + + @Override + public DeclarationDescriptor resolveReferenceExpression(JetReferenceExpression referenceExpression) { + throw new UnsupportedOperationException(); // TODO + } + + @Override + public JetType resolveTypeReference(JetTypeReference typeReference) { + return null; + } + + @Override + public PsiElement resolveToDeclarationPsiElement(JetReferenceExpression referenceExpression) { + throw new UnsupportedOperationException(); // TODO + } + + @Override + public PsiElement getDeclarationPsiElement(DeclarationDescriptor descriptor) { + throw new UnsupportedOperationException(); // TODO + } + + @Override + public boolean isBlock(JetFunctionLiteralExpression expression) { + throw new UnsupportedOperationException(); // TODO + } + + @Override + public boolean isStatement(JetExpression expression) { + throw new UnsupportedOperationException(); // TODO + } + + @Override + public boolean hasBackingField(PropertyDescriptor propertyDescriptor) { + throw new UnsupportedOperationException(); // TODO + } + + @Override + public ConstructorDescriptor resolveSuperConstructor(JetDelegatorToSuperCall superCall, ClassCodegen classCodegen) { + throw new UnsupportedOperationException(); // TODO + } + + @Override + public Collection getDiagnostics() { + throw new UnsupportedOperationException(); // TODO + } + }; + } + }; +} diff --git a/idea/tests/org/jetbrains/jet/types/JetOverridingTest.java b/idea/tests/org/jetbrains/jet/types/JetOverridingTest.java index 70d2a3ead0b..a1f1fb0e855 100644 --- a/idea/tests/org/jetbrains/jet/types/JetOverridingTest.java +++ b/idea/tests/org/jetbrains/jet/types/JetOverridingTest.java @@ -2,13 +2,13 @@ package org.jetbrains.jet.types; import com.intellij.codeInsight.daemon.LightDaemonAnalyzerTestCase; import com.intellij.openapi.application.PathManager; +import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.lang.JetSemanticServices; import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; import org.jetbrains.jet.lang.descriptors.FunctionDescriptorUtil; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.psi.JetChangeUtil; import org.jetbrains.jet.lang.psi.JetFunction; -import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.ClassDescriptorResolver; import org.jetbrains.jet.lang.types.*; import org.jetbrains.jet.parsing.JetParsingTest; @@ -30,7 +30,7 @@ public class JetOverridingTest extends LightDaemonAnalyzerTestCase { super.setUp(); library = JetStandardLibrary.getJetStandardLibrary(getProject()); semanticServices = JetSemanticServices.createSemanticServices(library); - classDescriptorResolver = semanticServices.getClassDescriptorResolver(BindingTrace.DUMMY); + classDescriptorResolver = semanticServices.getClassDescriptorResolver(JetTestUtils.DUMMY); } @Override diff --git a/idea/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java b/idea/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java index 48bac7f15dd..77e1747ab53 100644 --- a/idea/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java +++ b/idea/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java @@ -5,6 +5,7 @@ import com.intellij.codeInsight.daemon.LightDaemonAnalyzerTestCase; import com.intellij.openapi.application.PathManager; import com.intellij.openapi.project.Project; import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.lang.JetSemanticServices; import org.jetbrains.jet.lang.cfg.JetFlowInformationProvider; import org.jetbrains.jet.lang.descriptors.*; @@ -34,7 +35,7 @@ public class JetTypeCheckerTest extends LightDaemonAnalyzerTestCase { library = JetStandardLibrary.getJetStandardLibrary(getProject()); semanticServices = JetSemanticServices.createSemanticServices(library); classDefinitions = new ClassDefinitions(); - classDescriptorResolver = semanticServices.getClassDescriptorResolver(BindingTrace.DUMMY); + classDescriptorResolver = semanticServices.getClassDescriptorResolver(JetTestUtils.DUMMY); } @Override @@ -487,14 +488,14 @@ public class JetTypeCheckerTest extends LightDaemonAnalyzerTestCase { private void assertType(String expression, JetType expectedType) { Project project = getProject(); JetExpression jetExpression = JetChangeUtil.createExpression(project, expression); - JetType type = semanticServices.getTypeInferrer(BindingTrace.DUMMY, JetFlowInformationProvider.NONE).getType(classDefinitions.BASIC_SCOPE, jetExpression, false); + JetType type = semanticServices.getTypeInferrer(JetTestUtils.DUMMY, JetFlowInformationProvider.NONE).getType(classDefinitions.BASIC_SCOPE, jetExpression, false); assertTrue(type + " != " + expectedType, type.equals(expectedType)); } private void assertErrorType(String expression) { Project project = getProject(); JetExpression jetExpression = JetChangeUtil.createExpression(project, expression); - JetType type = semanticServices.getTypeInferrer(BindingTrace.DUMMY, JetFlowInformationProvider.NONE).safeGetType(classDefinitions.BASIC_SCOPE, jetExpression, false); + JetType type = semanticServices.getTypeInferrer(JetTestUtils.DUMMY, JetFlowInformationProvider.NONE).safeGetType(classDefinitions.BASIC_SCOPE, jetExpression, false); assertTrue("Error type expected but " + type + " returned", ErrorUtils.isErrorType(type)); } @@ -517,7 +518,7 @@ public class JetTypeCheckerTest extends LightDaemonAnalyzerTestCase { private void assertType(JetScope scope, String expression, String expectedTypeStr) { Project project = getProject(); JetExpression jetExpression = JetChangeUtil.createExpression(project, expression); - JetType type = semanticServices.getTypeInferrer(BindingTrace.DUMMY, JetFlowInformationProvider.NONE).getType(scope, jetExpression, false); + JetType type = semanticServices.getTypeInferrer(JetTestUtils.DUMMY, JetFlowInformationProvider.NONE).getType(scope, jetExpression, false); JetType expectedType = expectedTypeStr == null ? null : makeType(expectedTypeStr); assertEquals(expectedType, type); } @@ -527,7 +528,7 @@ public class JetTypeCheckerTest extends LightDaemonAnalyzerTestCase { } private JetType makeType(JetScope scope, String typeStr) { - return new TypeResolver(semanticServices, BindingTrace.DUMMY, true).resolveType(scope, JetChangeUtil.createType(getProject(), typeStr)); + return new TypeResolver(semanticServices, JetTestUtils.DUMMY, true).resolveType(scope, JetChangeUtil.createType(getProject(), typeStr)); } private class ClassDefinitions {