From 997d3597a9f588b54bc421402eef9211e35315d6 Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Thu, 9 Jan 2014 23:29:49 +0400 Subject: [PATCH] =?UTF-8?q?NamespaceType=20=E2=86=92=20PackageType.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../jet/lang/resolve/JetModuleUtil.java | 6 ++-- .../resolve/calls/CallExpressionResolver.java | 30 +++++++++---------- .../calls/autocasts/DataFlowValueFactory.java | 2 +- .../resolve/calls/tasks/TaskPrioritizer.java | 6 ++-- .../BasicExpressionTypingVisitor.java | 2 +- .../expressions/ExpressionTypingUtils.java | 3 +- .../jetbrains/jet/lang/types/ErrorUtils.java | 2 +- .../{NamespaceType.java => PackageType.java} | 8 ++--- .../jetbrains/jet/lang/types/TypeUtils.java | 2 +- .../jet/lang/types/lang/KotlinBuiltIns.java | 6 ++-- .../jet/plugin/codeInsight/TipsManager.java | 6 ++-- .../refactoring/JetRefactoringUtil.java | 4 +-- .../JetIntroduceVariableHandler.java | 4 +-- 13 files changed, 40 insertions(+), 41 deletions(-) rename core/descriptors/src/org/jetbrains/jet/lang/types/{NamespaceType.java => PackageType.java} (88%) diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/JetModuleUtil.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/JetModuleUtil.java index 8e856487338..b93859dd681 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/JetModuleUtil.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/JetModuleUtil.java @@ -20,11 +20,11 @@ import org.jetbrains.jet.lang.psi.JetElement; import org.jetbrains.jet.lang.resolve.name.SpecialNames; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue; -import org.jetbrains.jet.lang.types.NamespaceType; +import org.jetbrains.jet.lang.types.PackageType; public class JetModuleUtil { - public static NamespaceType getRootNamespaceType(JetElement expression) { + public static PackageType getRootPackageType(JetElement expression) { // TODO: this is a stub: at least the modules' root namespaces must be indexed here - return new NamespaceType(SpecialNames.ROOT_NAMESPACE, JetScope.EMPTY, ReceiverValue.NO_RECEIVER); + return new PackageType(SpecialNames.ROOT_NAMESPACE, JetScope.EMPTY, ReceiverValue.NO_RECEIVER); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallExpressionResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallExpressionResolver.java index fc70b9c3e95..9a88c3799d5 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallExpressionResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallExpressionResolver.java @@ -130,7 +130,7 @@ public class CallExpressionResolver { p.println(toString(), " for ", classifier); } }; - return new NamespaceType(referencedName, scopeForStaticMembersResolution, NO_RECEIVER); + return new PackageType(referencedName, scopeForStaticMembersResolution, NO_RECEIVER); } temporaryTrace.commit(); return result[0]; @@ -181,7 +181,7 @@ public class CallExpressionResolver { JetScope scope = new ChainedScope( classifier, "Member scope for extended class object type " + classifier, scopes.toArray(new JetScope[scopes.size()]) ); - return new NamespaceType(referencedName, scope, new ExpressionReceiver(expression, classObjectType)); + return new PackageType(referencedName, scope, new ExpressionReceiver(expression, classObjectType)); } private boolean furtherNameLookup( @@ -189,12 +189,12 @@ public class CallExpressionResolver { @NotNull JetType[] result, @NotNull ResolutionContext context ) { - NamespaceType namespaceType = lookupNamespaceType(expression, context); - if (namespaceType == null) { + PackageType packageType = lookupPackageType(expression, context); + if (packageType == null) { return false; } if (isLHSOfDot(expression)) { - result[0] = namespaceType; + result[0] = packageType; return true; } context.trace.report(EXPRESSION_EXPECTED_NAMESPACE_FOUND.on(expression)); @@ -203,26 +203,26 @@ public class CallExpressionResolver { } @Nullable - private NamespaceType lookupNamespaceType(@NotNull JetSimpleNameExpression expression, @NotNull ResolutionContext context) { + private PackageType lookupPackageType(@NotNull JetSimpleNameExpression expression, @NotNull ResolutionContext context) { Name name = expression.getReferencedNameAsName(); - PackageViewDescriptor namespace = context.scope.getPackage(name); - if (namespace == null) { + PackageViewDescriptor packageView = context.scope.getPackage(name); + if (packageView == null) { return null; } - context.trace.record(REFERENCE_TARGET, expression, namespace); + context.trace.record(REFERENCE_TARGET, expression, packageView); - // Construct a NamespaceType with everything from the namespace and with nested classes of the corresponding class (if any) + // Construct a PackageType with everything from the package and with nested classes of the corresponding class (if any) JetScope scope; ClassifierDescriptor classifier = context.scope.getClassifier(name); if (classifier instanceof ClassDescriptor) { scope = new ChainedScope( - namespace, "Namespace type member scope for " + expression.getText(), namespace.getMemberScope(), getStaticNestedClassesScope((ClassDescriptor) classifier) + packageView, "Package type member scope for " + expression.getText(), packageView.getMemberScope(), getStaticNestedClassesScope((ClassDescriptor) classifier) ); } else { - scope = namespace.getMemberScope(); + scope = packageView.getMemberScope(); } - return new NamespaceType(name, scope, NO_RECEIVER); + return new PackageType(name, scope, NO_RECEIVER); } @Nullable @@ -295,7 +295,7 @@ public class CallExpressionResolver { JetType type = getVariableType(nameExpression, receiver, callOperationNode, context.replaceTraceAndCache(temporaryForVariable), result); if (result[0]) { temporaryForVariable.commit(); - if (type instanceof NamespaceType && !isLHSOfDot(nameExpression)) { + if (type instanceof PackageType && !isLHSOfDot(nameExpression)) { type = null; } return JetTypeInfo.create(type, context.dataFlowInfo); @@ -452,7 +452,7 @@ public class CallExpressionResolver { JetType selectorReturnType = selectorReturnTypeInfo.getType(); //TODO move further - if (!(receiverType instanceof NamespaceType) && expression.getOperationSign() == JetTokens.SAFE_ACCESS) { + if (!(receiverType instanceof PackageType) && expression.getOperationSign() == JetTokens.SAFE_ACCESS) { if (selectorReturnType != null && !KotlinBuiltIns.getInstance().isUnit(selectorReturnType)) { if (receiverType.isNullable()) { selectorReturnType = TypeUtils.makeNullable(selectorReturnType); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowValueFactory.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowValueFactory.java index 1b9f9e47e34..1f5bbeda7a7 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowValueFactory.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowValueFactory.java @@ -156,7 +156,7 @@ public class DataFlowValueFactory { return getIdForThisReceiver(declarationDescriptor); } else if (expression instanceof JetRootNamespaceExpression) { - return createPackageInfo(JetModuleUtil.getRootNamespaceType(expression)); + return createPackageInfo(JetModuleUtil.getRootPackageType(expression)); } return NO_IDENTIFIER_INFO; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/TaskPrioritizer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/TaskPrioritizer.java index ee5e6b895b6..60f6b23e066 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/TaskPrioritizer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/TaskPrioritizer.java @@ -35,7 +35,7 @@ import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue; import org.jetbrains.jet.lang.types.ErrorUtils; import org.jetbrains.jet.lang.types.JetType; -import org.jetbrains.jet.lang.types.NamespaceType; +import org.jetbrains.jet.lang.types.PackageType; import org.jetbrains.jet.lang.types.checker.JetTypeChecker; import java.util.ArrayList; @@ -87,10 +87,10 @@ public class TaskPrioritizer { List> variants = new ArrayList>(2); ReceiverValue explicitReceiver = context.call.getExplicitReceiver(); - if (explicitReceiver.exists() && explicitReceiver.getType() instanceof NamespaceType) { + if (explicitReceiver.exists() && explicitReceiver.getType() instanceof PackageType) { JetType receiverType = explicitReceiver.getType(); variants.add(Pair.create(receiverType.getMemberScope(), NO_RECEIVER)); - ReceiverValue value = ((NamespaceType) receiverType).getReceiverValue(); + ReceiverValue value = ((PackageType) receiverType).getReceiverValue(); if (value.exists()) { variants.add(Pair.create(context.scope, value)); } 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 dac6177a4e0..42c230d4792 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 @@ -1172,7 +1172,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { @Override public JetTypeInfo visitRootNamespaceExpression(@NotNull JetRootNamespaceExpression expression, ExpressionTypingContext context) { if (JetPsiUtil.isLHSOfDot(expression)) { - return DataFlowUtils.checkType(JetModuleUtil.getRootNamespaceType(expression), expression, context, context.dataFlowInfo); + return DataFlowUtils.checkType(JetModuleUtil.getRootPackageType(expression), expression, context, context.dataFlowInfo); } context.trace.report(NAMESPACE_IS_NOT_AN_EXPRESSION.on(expression)); return JetTypeInfo.create(null, context.dataFlowInfo); 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 40f35dfa691..fe34c12117d 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.openapi.project.Project; import com.intellij.openapi.util.Pair; import com.intellij.psi.PsiElement; import com.intellij.psi.tree.IElementType; -import com.intellij.psi.tree.TokenSet; import com.intellij.psi.util.PsiTreeUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -259,7 +258,7 @@ public class ExpressionTypingUtils { ) { JetType type = receiverArgument.getType(); - if (type instanceof NamespaceType) { + if (type instanceof PackageType) { // This fake class ruins standard algorithms return false; } diff --git a/core/descriptors/src/org/jetbrains/jet/lang/types/ErrorUtils.java b/core/descriptors/src/org/jetbrains/jet/lang/types/ErrorUtils.java index 8b268e22d7b..cf3e736b234 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/types/ErrorUtils.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/types/ErrorUtils.java @@ -299,7 +299,7 @@ public class ErrorUtils { public static boolean containsErrorType(@Nullable JetType type) { if (type == null) return false; - if (type instanceof NamespaceType) return false; + if (type instanceof PackageType) return false; if (type.isError()) return true; for (TypeProjection projection : type.getArguments()) { if (containsErrorType(projection.getType())) return true; diff --git a/core/descriptors/src/org/jetbrains/jet/lang/types/NamespaceType.java b/core/descriptors/src/org/jetbrains/jet/lang/types/PackageType.java similarity index 88% rename from core/descriptors/src/org/jetbrains/jet/lang/types/NamespaceType.java rename to core/descriptors/src/org/jetbrains/jet/lang/types/PackageType.java index 7ef4e29987e..7872df63f57 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/types/NamespaceType.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/types/PackageType.java @@ -25,15 +25,15 @@ import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue; import java.util.List; /** - * This is a fake type assigned to namespace expressions. Only member lookup is + * This is a fake type assigned to package expressions. Only member lookup is * supposed to be done on these types. */ -public class NamespaceType implements JetType { +public class PackageType implements JetType { private final Name name; private final JetScope memberScope; private final ReceiverValue receiver; - public NamespaceType(@NotNull Name name, @NotNull JetScope memberScope, @NotNull ReceiverValue receiver) { + public PackageType(@NotNull Name name, @NotNull JetScope memberScope, @NotNull ReceiverValue receiver) { this.name = name; this.memberScope = memberScope; this.receiver = receiver; @@ -62,7 +62,7 @@ public class NamespaceType implements JetType { } private TypeConstructor throwException() { - throw new UnsupportedOperationException("Only member lookup is allowed on a namespace type " + name); + throw new UnsupportedOperationException("Only member lookup is allowed on a package type " + name); } @NotNull diff --git a/core/descriptors/src/org/jetbrains/jet/lang/types/TypeUtils.java b/core/descriptors/src/org/jetbrains/jet/lang/types/TypeUtils.java index 586e16b89a2..a0c4a4cbd52 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/types/TypeUtils.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/types/TypeUtils.java @@ -528,7 +528,7 @@ public class TypeUtils { private static boolean equalsOrContainsAsArgument(@Nullable JetType type, @NotNull Set possibleArgumentTypes) { if (type == null) return false; if (possibleArgumentTypes.contains(type)) return true; - if (type instanceof NamespaceType) return false; + if (type instanceof PackageType) return false; for (TypeProjection projection : type.getArguments()) { if (equalsOrContainsAsArgument(projection.getType(), possibleArgumentTypes)) return true; } diff --git a/core/descriptors/src/org/jetbrains/jet/lang/types/lang/KotlinBuiltIns.java b/core/descriptors/src/org/jetbrains/jet/lang/types/lang/KotlinBuiltIns.java index 134e9c19b11..c35788df948 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/types/lang/KotlinBuiltIns.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/types/lang/KotlinBuiltIns.java @@ -905,17 +905,17 @@ public class KotlinBuiltIns { } public boolean isNothingOrNullableNothing(@NotNull JetType type) { - return !(type instanceof NamespaceType) + return !(type instanceof PackageType) && type.getConstructor() == getNothing().getTypeConstructor(); } public boolean isAnyOrNullableAny(@NotNull JetType type) { - return !(type instanceof NamespaceType) && + return !(type instanceof PackageType) && type.getConstructor() == getAny().getTypeConstructor(); } public boolean isUnit(@NotNull JetType type) { - return !(type instanceof NamespaceType) && type.equals(getUnitType()); + return !(type instanceof PackageType) && type.equals(getUnitType()); } public boolean isData(@NotNull ClassDescriptor classDescriptor) { diff --git a/idea/src/org/jetbrains/jet/plugin/codeInsight/TipsManager.java b/idea/src/org/jetbrains/jet/plugin/codeInsight/TipsManager.java index ece3b7ed9d9..a4f236c2f3c 100644 --- a/idea/src/org/jetbrains/jet/plugin/codeInsight/TipsManager.java +++ b/idea/src/org/jetbrains/jet/plugin/codeInsight/TipsManager.java @@ -38,7 +38,7 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScopeUtils; import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue; import org.jetbrains.jet.lang.types.JetType; -import org.jetbrains.jet.lang.types.NamespaceType; +import org.jetbrains.jet.lang.types.PackageType; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingUtils; import java.util.*; @@ -60,7 +60,7 @@ public final class TipsManager { JetType expressionType = context.get(BindingContext.EXPRESSION_TYPE, receiverExpression); if (expressionType != null && resolutionScope != null && !expressionType.isError()) { - if (!(expressionType instanceof NamespaceType)) { + if (!(expressionType instanceof PackageType)) { ExpressionReceiver receiverValue = new ExpressionReceiver(receiverExpression, expressionType); Set descriptors = new HashSet(); @@ -197,7 +197,7 @@ public final class TipsManager { ) { // It's impossible to add extension function for namespace JetType receiverType = receiverValue.getType(); - if (receiverType instanceof NamespaceType) { + if (receiverType instanceof PackageType) { return new HashSet(descriptors); } diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/JetRefactoringUtil.java b/idea/src/org/jetbrains/jet/plugin/refactoring/JetRefactoringUtil.java index da2ad5c60dc..a0e1a1d4a5a 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/JetRefactoringUtil.java +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/JetRefactoringUtil.java @@ -41,7 +41,7 @@ import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingContextUtils; import org.jetbrains.jet.lang.resolve.java.jetAsJava.KotlinLightMethod; import org.jetbrains.jet.lang.types.JetType; -import org.jetbrains.jet.lang.types.NamespaceType; +import org.jetbrains.jet.lang.types.PackageType; import org.jetbrains.jet.lang.types.checker.JetTypeChecker; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lexer.JetKeywordToken; @@ -385,7 +385,7 @@ public class JetRefactoringUtil { JetExpression expression = (JetExpression)element; BindingContext bindingContext = AnalyzerFacadeWithCache.analyzeFileWithCache((JetFile) expression.getContainingFile()).getBindingContext(); JetType expressionType = bindingContext.get(BindingContext.EXPRESSION_TYPE, expression); - if (expressionType == null || !(expressionType instanceof NamespaceType) && + if (expressionType == null || !(expressionType instanceof PackageType) && !JetTypeChecker.INSTANCE.equalTypes(KotlinBuiltIns. getInstance().getUnitType(), expressionType)) { expressions.add(expression); diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/introduceVariable/JetIntroduceVariableHandler.java b/idea/src/org/jetbrains/jet/plugin/refactoring/introduceVariable/JetIntroduceVariableHandler.java index 1e0990cbfed..6f7a40057f1 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/introduceVariable/JetIntroduceVariableHandler.java +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/introduceVariable/JetIntroduceVariableHandler.java @@ -43,7 +43,7 @@ import org.jetbrains.jet.lang.resolve.ObservableBindingTrace; import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.types.JetType; -import org.jetbrains.jet.lang.types.NamespaceType; +import org.jetbrains.jet.lang.types.PackageType; import org.jetbrains.jet.lang.types.TypeUtils; import org.jetbrains.jet.lang.types.checker.JetTypeChecker; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; @@ -132,7 +132,7 @@ public class JetIntroduceVariableHandler extends JetIntroduceHandlerBase { noTypeInference = true; } } - if (expressionType instanceof NamespaceType) { + if (expressionType instanceof PackageType) { showErrorHint(project, editor, JetRefactoringBundle.message("cannot.refactor.namespace.expression")); return; }