NamespaceType → PackageType.

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);
     }
 }

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);
+        PackageType packageType = lookupPackageType(expression, context);
-        if (namespaceType == null) {
+        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);
+        PackageViewDescriptor packageView = context.scope.getPackage(name);
-        if (namespace == null) {
+        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);

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;
     }

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<Pair<JetScope, ReceiverValue>> variants = new ArrayList<Pair<JetScope, ReceiverValue>>(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));
             }

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);

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;
         }

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;

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

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<JetType> 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;
         }

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) {

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<DeclarationDescriptor> descriptors = new HashSet<DeclarationDescriptor>();
 
@@ -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<DeclarationDescriptor>(descriptors);
         }
 

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);

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;
         }