From 40937e438bbbb7887a7e9c1ae46531a9ed2e3c7b Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Wed, 7 Dec 2011 17:26:28 +0400 Subject: [PATCH] KT-762 Wrong highlighting in imports (No errors reported on unresolved imports) --- .../jet/lang/resolve/ImportsResolver.java | 108 ++++++++++++++++++ .../lang/resolve/TypeHierarchyResolver.java | 86 ++------------ .../diagnostics/tests/regressions/kt762.jet | 4 + 3 files changed, 119 insertions(+), 79 deletions(-) create mode 100644 compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java create mode 100644 compiler/testData/diagnostics/tests/regressions/kt762.jet diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java new file mode 100644 index 00000000000..a96ce5d3f4a --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java @@ -0,0 +1,108 @@ +package org.jetbrains.jet.lang.resolve; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor; +import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; +import org.jetbrains.jet.lang.psi.*; +import org.jetbrains.jet.lang.resolve.scopes.JetScope; +import org.jetbrains.jet.lang.resolve.scopes.WritableScope; +import org.jetbrains.jet.lang.types.JetType; +import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; + +import java.util.List; + +import static org.jetbrains.jet.lang.diagnostics.Errors.UNRESOLVED_REFERENCE; +import static org.jetbrains.jet.lang.diagnostics.Errors.UNSUPPORTED; + +/** + * @author abreslav + */ +public class ImportsResolver { + private final TopDownAnalysisContext context; + + public ImportsResolver(@NotNull TopDownAnalysisContext context) { + this.context = context; + } + + public void processTypeImports() { + for (JetNamespace jetNamespace : context.getNamespaceDescriptors().keySet()) { + processImports(jetNamespace, context.getNamespaceScopes().get(jetNamespace), context.getDeclaringScopes().get(jetNamespace)); + } + } + + private void processImports(@NotNull JetNamespace namespace, @NotNull WritableScope namespaceScope, @NotNull JetScope outerScope) { + context.getConfiguration().addDefaultImports(context.getTrace(), namespaceScope); + + List importDirectives = namespace.getImportDirectives(); + for (JetImportDirective importDirective : importDirectives) { + if (importDirective.isAbsoluteInRootNamespace()) { + context.getTrace().report(UNSUPPORTED.on(importDirective, "TypeHierarchyResolver")); // TODO + continue; + } + if (importDirective.isAllUnder()) { + JetExpression importedReference = importDirective.getImportedReference(); + if (importedReference != null) { + ExpressionTypingServices typeInferrerServices = context.getSemanticServices().getTypeInferrerServices(context.getTrace()); + JetType type = typeInferrerServices.getTypeWithNamespaces(namespaceScope, importedReference); + if (type != null) { + namespaceScope.importScope(type.getMemberScope()); + } + } + } + else { + ClassifierDescriptor classifierDescriptor = null; + NamespaceDescriptor namespaceDescriptor = null; + JetSimpleNameExpression referenceExpression = null; + + JetExpression importedReference = importDirective.getImportedReference(); + if (importedReference instanceof JetDotQualifiedExpression) { + JetDotQualifiedExpression reference = (JetDotQualifiedExpression) importedReference; + JetType type = context.getSemanticServices().getTypeInferrerServices(context.getTrace()).getTypeWithNamespaces(namespaceScope, reference.getReceiverExpression()); + JetExpression selectorExpression = reference.getSelectorExpression(); + if (selectorExpression != null) { + referenceExpression = (JetSimpleNameExpression) selectorExpression; + String referencedName = referenceExpression.getReferencedName(); + if (type != null && referencedName != null) { + classifierDescriptor = type.getMemberScope().getClassifier(referencedName); + namespaceDescriptor = type.getMemberScope().getNamespace(referencedName); + } + } + } + else { + assert importedReference instanceof JetSimpleNameExpression; + referenceExpression = (JetSimpleNameExpression) importedReference; + + String referencedName = referenceExpression.getReferencedName(); + if (referencedName != null) { + classifierDescriptor = outerScope.getClassifier(referencedName); + namespaceDescriptor = outerScope.getNamespace(referencedName); + + if (classifierDescriptor == null && namespaceDescriptor == null) { + context.getTrace().report(UNRESOLVED_REFERENCE.on(referenceExpression)); + } + } + } + + String aliasName = importDirective.getAliasName(); + if (aliasName == null) { + aliasName = referenceExpression != null ? referenceExpression.getReferencedName() : null; + } + if (classifierDescriptor != null) { + context.getTrace().record(BindingContext.REFERENCE_TARGET, referenceExpression, classifierDescriptor); + + if (aliasName != null) { + namespaceScope.importClassifierAlias(aliasName, classifierDescriptor); + } + } + if (namespaceDescriptor != null) { + if (classifierDescriptor == null) { + context.getTrace().record(BindingContext.REFERENCE_TARGET, referenceExpression, namespaceDescriptor); + } + if (aliasName != null) { + namespaceScope.importNamespaceAlias(aliasName, namespaceDescriptor); + } + } + } + } + } +} 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 6a694ed7d99..435fed20e44 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java @@ -15,7 +15,10 @@ 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.WriteThroughScope; -import org.jetbrains.jet.lang.types.*; +import org.jetbrains.jet.lang.types.JetType; +import org.jetbrains.jet.lang.types.TypeConstructor; +import org.jetbrains.jet.lang.types.TypeProjection; +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.lexer.JetTokens; @@ -30,17 +33,19 @@ import static org.jetbrains.jet.lang.resolve.BindingContext.*; */ public class TypeHierarchyResolver { private final TopDownAnalysisContext context; + private final ImportsResolver importsResolver; private LinkedList topologicalOrder; public TypeHierarchyResolver(TopDownAnalysisContext context) { this.context = context; + this.importsResolver = new ImportsResolver(context); } public void process(@NotNull JetScope outerScope, @NotNull NamespaceLike owner, @NotNull Collection declarations) { collectNamespacesAndClassifiers(outerScope, outerScope, owner, declarations); // namespaceScopes, classes - 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) @@ -75,7 +80,6 @@ public class TypeHierarchyResolver { WriteThroughScope namespaceScope = new WriteThroughScope(outerScope, namespaceDescriptor.getMemberScope(), new TraceBasedRedeclarationHandler(context.getTrace())); namespaceScope.changeLockLevel(WritableScope.LockLevel.BOTH); - context.getConfiguration().addDefaultImports(context.getTrace(), namespaceScope); context.getNamespaceScopes().put(namespace, namespaceScope); context.getDeclaringScopes().put(namespace, outerScope); @@ -233,82 +237,6 @@ public class TypeHierarchyResolver { return ClassKind.CLASS; } - private void processTypeImports() { - for (JetNamespace jetNamespace : context.getNamespaceDescriptors().keySet()) { - processImports(jetNamespace, context.getNamespaceScopes().get(jetNamespace), context.getDeclaringScopes().get(jetNamespace)); - } - } - - private void processImports(@NotNull JetNamespace namespace, @NotNull WritableScope namespaceScope, @NotNull JetScope outerScope) { - List importDirectives = namespace.getImportDirectives(); - for (JetImportDirective importDirective : importDirectives) { - if (importDirective.isAbsoluteInRootNamespace()) { - context.getTrace().report(UNSUPPORTED.on(importDirective, "TypeHierarchyResolver")); // TODO - continue; - } - if (importDirective.isAllUnder()) { - JetExpression importedReference = importDirective.getImportedReference(); - if (importedReference != null) { - ExpressionTypingServices typeInferrerServices = context.getSemanticServices().getTypeInferrerServices(context.getTrace()); - JetType type = typeInferrerServices.getTypeWithNamespaces(namespaceScope, importedReference); - if (type != null) { - namespaceScope.importScope(type.getMemberScope()); - } - } - } - else { - ClassifierDescriptor classifierDescriptor = null; - NamespaceDescriptor namespaceDescriptor = null; - JetSimpleNameExpression referenceExpression = null; - - JetExpression importedReference = importDirective.getImportedReference(); - if (importedReference instanceof JetDotQualifiedExpression) { - JetDotQualifiedExpression reference = (JetDotQualifiedExpression) importedReference; - JetType type = context.getSemanticServices().getTypeInferrerServices(context.getTrace()).getTypeWithNamespaces(namespaceScope, reference.getReceiverExpression()); - JetExpression selectorExpression = reference.getSelectorExpression(); - if (selectorExpression != null) { - referenceExpression = (JetSimpleNameExpression) selectorExpression; - String referencedName = referenceExpression.getReferencedName(); - if (type != null && referencedName != null) { - classifierDescriptor = type.getMemberScope().getClassifier(referencedName); - namespaceDescriptor = type.getMemberScope().getNamespace(referencedName); - } - } - } - else { - assert importedReference instanceof JetSimpleNameExpression; - referenceExpression = (JetSimpleNameExpression) importedReference; - - String referencedName = referenceExpression.getReferencedName(); - if (referencedName != null) { - classifierDescriptor = outerScope.getClassifier(referencedName); - namespaceDescriptor = outerScope.getNamespace(referencedName); - } - } - - String aliasName = importDirective.getAliasName(); - if (aliasName == null) { - aliasName = referenceExpression != null ? referenceExpression.getReferencedName() : null; - } - if (classifierDescriptor != null) { - context.getTrace().record(BindingContext.REFERENCE_TARGET, referenceExpression, classifierDescriptor); - - if (aliasName != null) { - namespaceScope.importClassifierAlias(aliasName, classifierDescriptor); - } - } - if (namespaceDescriptor != null) { - if (classifierDescriptor == null) { - context.getTrace().record(BindingContext.REFERENCE_TARGET, referenceExpression, namespaceDescriptor); - } - if (aliasName != null) { - namespaceScope.importNamespaceAlias(aliasName, namespaceDescriptor); - } - } - } - } - } - private void createTypeConstructors() { for (Map.Entry entry : context.getClasses().entrySet()) { JetClass jetClass = entry.getKey(); diff --git a/compiler/testData/diagnostics/tests/regressions/kt762.jet b/compiler/testData/diagnostics/tests/regressions/kt762.jet new file mode 100644 index 00000000000..848d478794e --- /dev/null +++ b/compiler/testData/diagnostics/tests/regressions/kt762.jet @@ -0,0 +1,4 @@ +//KT-762 Wrong highlighting in imports (No errors reported on unresolved imports) +import aaa // must be an error + +fun main(args : Array) {} \ No newline at end of file