Merge CoreTypes and CoreClasses into CommonElements.

pkg/compiler/lib/src/resolution/members.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library dart2js.resolution.members;
 
 import '../common.dart';
 import '../common/names.dart' show Selectors;
 import '../common/resolution.dart' show Resolution;
 import '../compile_time_constants.dart';
@@ skipping 153 matching lines @@
         inCheckContext = resolution.options.enableTypeAssertions &&
             !element.isLibrary &&
             !element.isTypedef &&
             !element.enclosingElement.isTypedef,
         inCatchBlock = false,
         constantState = element.isConst
             ? ConstantState.CONSTANT
             : ConstantState.NON_CONSTANT,
         super(resolution, registry);
 
-  CoreClasses get coreClasses => resolution.coreClasses;
-  CoreTypes get coreTypes => resolution.coreTypes;
+  CommonElements get commonElements => resolution.commonElements;
   ConstantEnvironment get constants => resolution.constants;
   ResolverTask get resolver => resolution.resolver;
   CompilerOptions get options => resolution.options;
 
   AsyncMarker get currentAsyncMarker {
     if (enclosingElement is FunctionElement) {
       FunctionElement function = enclosingElement;
       return function.asyncMarker;
     }
     return AsyncMarker.SYNC;
@@ skipping 144 matching lines @@
       if ((ElementCategory.SUPER & allowedCategory) == 0) {
         reporter.reportErrorMessage(node, MessageKind.INVALID_USE_OF_SUPER);
       }
       return const NoneResult();
     } else {
       String name = node.source;
       Element element = lookupInScope(reporter, node, scope, name);
       if (Elements.isUnresolved(element) && name == 'dynamic') {
         // TODO(johnniwinther): Remove this hack when we can return more complex
         // objects than [Element] from this method.
-        element = coreClasses.typeClass;
+        element = commonElements.typeClass;
         // Set the type to be `dynamic` to mark that this is a type literal.
         registry.setType(node, const DynamicType());
       }
       element = reportLookupErrorIfAny(element, node, name);
       if (element == null) {
         if (!inInstanceContext) {
           element = reportCannotResolve(node, name);
         }
       } else if (element.isMalformed) {
         // Use the malformed element.
@@ skipping 839 matching lines @@
       }
     } else {
       ResolutionResult expressionResult = visitExpression(expression);
       semantics = const DynamicAccess.expression();
       registry.registerDynamicUse(new DynamicUse(selector, null));
 
       if (expressionResult.isConstant) {
         bool isValidConstant;
         ConstantExpression expressionConstant = expressionResult.constant;
         DartType knownExpressionType =
-            expressionConstant.getKnownType(coreTypes);
+            expressionConstant.getKnownType(commonElements);
         switch (operator.kind) {
           case UnaryOperatorKind.COMPLEMENT:
-            isValidConstant = knownExpressionType == coreTypes.intType;
+            isValidConstant = knownExpressionType == commonElements.intType;
             break;
           case UnaryOperatorKind.NEGATE:
-            isValidConstant = knownExpressionType == coreTypes.intType ||
-                knownExpressionType == coreTypes.doubleType;
+            isValidConstant = knownExpressionType == commonElements.intType ||
+                knownExpressionType == commonElements.doubleType;
             break;
           case UnaryOperatorKind.NOT:
             reporter.internalError(
                 node, "Unexpected user definable unary operator: $operator");
         }
         if (isValidConstant) {
           // TODO(johnniwinther): Handle potentially invalid constant
           // expressions.
           ConstantExpression constant =
               new UnaryConstantExpression(operator, expressionConstant);
@@ skipping 12 matching lines @@
   /// Handle a not expression, like `!a`.
   ResolutionResult handleNot(Send node, UnaryOperator operator) {
     assert(invariant(node, operator.kind == UnaryOperatorKind.NOT));
 
     Node expression = node.receiver;
     ResolutionResult result = visitExpression(expression);
     registry.registerSendStructure(node, const NotStructure());
 
     if (result.isConstant) {
       ConstantExpression expressionConstant = result.constant;
-      if (expressionConstant.getKnownType(coreTypes) == coreTypes.boolType) {
+      if (expressionConstant.getKnownType(commonElements) ==
+          commonElements.boolType) {
         // TODO(johnniwinther): Handle potentially invalid constant expressions.
         ConstantExpression constant =
             new UnaryConstantExpression(operator, expressionConstant);
         registry.setConstant(node, constant);
         return new ConstantResult(node, constant);
       }
     }
 
     return const NoneResult();
   }
 
   /// Handle a logical and expression, like `a && b`.
   ResolutionResult handleLogicalAnd(Send node) {
     Node left = node.receiver;
     Node right = node.arguments.head;
     ResolutionResult leftResult =
         doInPromotionScope(left, () => visitExpression(left));
     ResolutionResult rightResult =
         doInPromotionScope(right, () => visitExpression(right));
     registry.registerSendStructure(node, const LogicalAndStructure());
 
     if (leftResult.isConstant && rightResult.isConstant) {
       ConstantExpression leftConstant = leftResult.constant;
       ConstantExpression rightConstant = rightResult.constant;
-      if (leftConstant.getKnownType(coreTypes) == coreTypes.boolType &&
-          rightConstant.getKnownType(coreTypes) == coreTypes.boolType) {
+      if (leftConstant.getKnownType(commonElements) ==
+              commonElements.boolType &&
+          rightConstant.getKnownType(commonElements) ==
+              commonElements.boolType) {
         // TODO(johnniwinther): Handle potentially invalid constant expressions.
         ConstantExpression constant = new BinaryConstantExpression(
             leftConstant, BinaryOperator.LOGICAL_AND, rightConstant);
         registry.setConstant(node, constant);
         return new ConstantResult(node, constant);
       }
     }
 
     return const NoneResult();
   }
 
   /// Handle a logical or expression, like `a || b`.
   ResolutionResult handleLogicalOr(Send node) {
     Node left = node.receiver;
     Node right = node.arguments.head;
     ResolutionResult leftResult = visitExpression(left);
     ResolutionResult rightResult = visitExpression(right);
     registry.registerSendStructure(node, const LogicalOrStructure());
 
     if (leftResult.isConstant && rightResult.isConstant) {
       ConstantExpression leftConstant = leftResult.constant;
       ConstantExpression rightConstant = rightResult.constant;
-      if (leftConstant.getKnownType(coreTypes) == coreTypes.boolType &&
-          rightConstant.getKnownType(coreTypes) == coreTypes.boolType) {
+      if (leftConstant.getKnownType(commonElements) ==
+              commonElements.boolType &&
+          rightConstant.getKnownType(commonElements) ==
+              commonElements.boolType) {
         // TODO(johnniwinther): Handle potentially invalid constant expressions.
         ConstantExpression constant = new BinaryConstantExpression(
             leftConstant, BinaryOperator.LOGICAL_OR, rightConstant);
         registry.setConstant(node, constant);
         return new ConstantResult(node, constant);
       }
     }
     return const NoneResult();
   }
 
@@ skipping 60 matching lines @@
     } else {
       ResolutionResult leftResult = visitExpression(left);
       ResolutionResult rightResult = visitExpression(right);
       registry.registerDynamicUse(new DynamicUse(selector, null));
       semantics = const DynamicAccess.expression();
 
       if (leftResult.isConstant && rightResult.isConstant) {
         bool isValidConstant;
         ConstantExpression leftConstant = leftResult.constant;
         ConstantExpression rightConstant = rightResult.constant;
-        DartType knownLeftType = leftConstant.getKnownType(coreTypes);
-        DartType knownRightType = rightConstant.getKnownType(coreTypes);
+        DartType knownLeftType = leftConstant.getKnownType(commonElements);
+        DartType knownRightType = rightConstant.getKnownType(commonElements);
         switch (operator.kind) {
           case BinaryOperatorKind.EQ:
           case BinaryOperatorKind.NOT_EQ:
-            isValidConstant = (knownLeftType == coreTypes.intType ||
-                    knownLeftType == coreTypes.doubleType ||
-                    knownLeftType == coreTypes.stringType ||
-                    knownLeftType == coreTypes.boolType ||
-                    knownLeftType == coreTypes.nullType) &&
-                (knownRightType == coreTypes.intType ||
-                    knownRightType == coreTypes.doubleType ||
-                    knownRightType == coreTypes.stringType ||
-                    knownRightType == coreTypes.boolType ||
-                    knownRightType == coreTypes.nullType);
+            isValidConstant = (knownLeftType == commonElements.intType ||
+                    knownLeftType == commonElements.doubleType ||
+                    knownLeftType == commonElements.stringType ||
+                    knownLeftType == commonElements.boolType ||
+                    knownLeftType == commonElements.nullType) &&
+                (knownRightType == commonElements.intType ||
+                    knownRightType == commonElements.doubleType ||
+                    knownRightType == commonElements.stringType ||
+                    knownRightType == commonElements.boolType ||
+                    knownRightType == commonElements.nullType);
             break;
           case BinaryOperatorKind.ADD:
-            isValidConstant = (knownLeftType == coreTypes.intType ||
-                    knownLeftType == coreTypes.doubleType ||
-                    knownLeftType == coreTypes.stringType) &&
-                (knownRightType == coreTypes.intType ||
-                    knownRightType == coreTypes.doubleType ||
-                    knownRightType == coreTypes.stringType);
+            isValidConstant = (knownLeftType == commonElements.intType ||
+                    knownLeftType == commonElements.doubleType ||
+                    knownLeftType == commonElements.stringType) &&
+                (knownRightType == commonElements.intType ||
+                    knownRightType == commonElements.doubleType ||
+                    knownRightType == commonElements.stringType);
             break;
           case BinaryOperatorKind.SUB:
           case BinaryOperatorKind.MUL:
           case BinaryOperatorKind.DIV:
           case BinaryOperatorKind.IDIV:
           case BinaryOperatorKind.MOD:
           case BinaryOperatorKind.GTEQ:
           case BinaryOperatorKind.GT:
           case BinaryOperatorKind.LTEQ:
           case BinaryOperatorKind.LT:
-            isValidConstant = (knownLeftType == coreTypes.intType ||
-                    knownLeftType == coreTypes.doubleType) &&
-                (knownRightType == coreTypes.intType ||
-                    knownRightType == coreTypes.doubleType);
+            isValidConstant = (knownLeftType == commonElements.intType ||
+                    knownLeftType == commonElements.doubleType) &&
+                (knownRightType == commonElements.intType ||
+                    knownRightType == commonElements.doubleType);
             break;
           case BinaryOperatorKind.SHL:
           case BinaryOperatorKind.SHR:
           case BinaryOperatorKind.AND:
           case BinaryOperatorKind.OR:
           case BinaryOperatorKind.XOR:
-            isValidConstant = knownLeftType == coreTypes.intType &&
-                knownRightType == coreTypes.intType;
+            isValidConstant = knownLeftType == commonElements.intType &&
+                knownRightType == commonElements.intType;
             break;
           case BinaryOperatorKind.INDEX:
             isValidConstant = false;
             break;
           case BinaryOperatorKind.LOGICAL_AND:
           case BinaryOperatorKind.LOGICAL_OR:
           case BinaryOperatorKind.IF_NULL:
             reporter.internalError(
                 node, "Unexpected binary operator '${operator}'.");
             break;
@@ skipping 632 matching lines @@
     return handleConstantTypeLiteralUpdate(node, name, typdef, type, semantics);
   }
 
   /// Handle access to a type literal of the type 'dynamic'. Like `dynamic` or
   /// `dynamic()`.
   ResolutionResult handleDynamicTypeLiteralAccess(Send node) {
     DartType type = const DynamicType();
     ConstantExpression constant = new TypeConstantExpression(
         // TODO(johnniwinther): Use [type] when evaluation of constants is done
         // directly on the constant expressions.
-        node.isCall ? coreTypes.typeType : type);
+        node.isCall ? commonElements.typeType : type);
     AccessSemantics semantics = new ConstantAccess.dynamicTypeLiteral(constant);
     return handleConstantTypeLiteralAccess(node, const PublicName('dynamic'),
-        coreClasses.typeClass, type, semantics);
+        commonElements.typeClass, type, semantics);
   }
 
   /// Handle update to a type literal of the type 'dynamic'. Like `dynamic++` or
   /// `dynamic = 0`.
   ResolutionResult handleDynamicTypeLiteralUpdate(SendSet node) {
     DartType type = const DynamicType();
     ConstantExpression constant =
         new TypeConstantExpression(const DynamicType());
     AccessSemantics semantics = new ConstantAccess.dynamicTypeLiteral(constant);
     return handleConstantTypeLiteralUpdate(node, const PublicName('dynamic'),
-        coreClasses.typeClass, type, semantics);
+        commonElements.typeClass, type, semantics);
   }
 
   /// Handle access to a type literal of a class. Like `C` or
   /// `C()` where 'C' is class.
   ResolutionResult handleClassTypeLiteralAccess(
       Send node, Name name, ClassElement cls) {
     cls.ensureResolved(resolution);
     DartType type = cls.rawType;
     ConstantExpression constant = new TypeConstantExpression(type);
     AccessSemantics semantics = new ConstantAccess.classTypeLiteral(constant);
@@ skipping 1490 matching lines @@
 
   ResolutionResult visitYield(Yield node) {
     if (!resolution.target.supportsAsyncAwait) {
       reporter.reportErrorMessage(
           node.yieldToken, MessageKind.ASYNC_AWAIT_NOT_SUPPORTED);
     } else {
       if (!currentAsyncMarker.isYielding) {
         reporter.reportErrorMessage(node, MessageKind.INVALID_YIELD);
       }
       if (currentAsyncMarker.isAsync) {
-        coreClasses.streamClass.ensureResolved(resolution);
+        commonElements.streamClass.ensureResolved(resolution);
       } else {
-        coreClasses.iterableClass.ensureResolved(resolution);
+        commonElements.iterableClass.ensureResolved(resolution);
       }
     }
     visit(node.expression);
     return const NoneResult();
   }
 
   ResolutionResult visitRedirectingFactoryBody(RedirectingFactoryBody node) {
     if (!enclosingElement.isFactoryConstructor) {
       reporter.reportErrorMessage(
           node, MessageKind.FACTORY_REDIRECTION_IN_NON_FACTORY);
@@ skipping 114 matching lines @@
   }
 
   ResolutionResult visitAwait(Await node) {
     if (!resolution.target.supportsAsyncAwait) {
       reporter.reportErrorMessage(
           node.awaitToken, MessageKind.ASYNC_AWAIT_NOT_SUPPORTED);
     } else {
       if (!currentAsyncMarker.isAsync) {
         reporter.reportErrorMessage(node, MessageKind.INVALID_AWAIT);
       }
-      coreClasses.futureClass.ensureResolved(resolution);
+      commonElements.futureClass.ensureResolved(resolution);
     }
     visit(node.expression);
     return const NoneResult();
   }
 
   ResolutionResult visitVariableDefinitions(VariableDefinitions node) {
     DartType type;
     if (node.type != null) {
       type = resolveTypeAnnotation(node.type);
     } else {
@@ skipping 161 matching lines @@
     if (node.isConst) {
       bool isValidAsConstant = !isInvalid && constructor.isConst;
 
       CommonElements commonElements = resolution.commonElements;
       if (commonElements.isSymbolConstructor(constructor)) {
         Node argumentNode = node.send.arguments.head;
         ConstantExpression constant = resolver.constantCompiler
             .compileNode(argumentNode, registry.mapping);
         ConstantValue name = resolution.constants.getConstantValue(constant);
         if (!name.isString) {
-          DartType type = name.getType(coreTypes);
+          DartType type = name.getType(commonElements);
           reporter.reportErrorMessage(
               argumentNode, MessageKind.STRING_EXPECTED, {'type': type});
         } else {
           StringConstantValue stringConstant = name;
           String nameString = stringConstant.toDartString().slowToString();
           if (validateSymbol(argumentNode, nameString)) {
             registry.registerConstSymbol(nameString);
           }
         }
       } else if (commonElements.isMirrorsUsedConstructor(constructor)) {
@@ skipping 53 matching lines @@
         };
       }
 
       analyzeConstantDeferred(node, onAnalyzed: onAnalyzed);
     } else {
       // Not constant.
       if (resolution.commonElements.isSymbolConstructor(constructor) &&
           !resolution.mirrorUsageAnalyzerTask
               .hasMirrorUsage(enclosingElement)) {
         reporter.reportHintMessage(node.newToken, MessageKind.NON_CONST_BLOAT,
-            {'name': coreClasses.symbolClass.name});
+            {'name': commonElements.symbolClass.name});
       }
       registry.registerNewStructure(
           node,
           new NewInvokeStructure(
               new ConstructorAccessSemantics(kind, constructor, type),
               selector));
     }
 
     return resolutionResult;
   }
 
   void checkConstMapKeysDontOverrideEquals(
       Spannable spannable, MapConstantValue map) {
     for (ConstantValue key in map.keys) {
       if (!key.isObject) continue;
       ObjectConstantValue objectConstant = key;
       DartType keyType = objectConstant.type;
       ClassElement cls = keyType.element;
-      if (cls == coreClasses.stringClass) continue;
+      if (cls == commonElements.stringClass) continue;
       Element equals = cls.lookupMember('==');
-      if (equals.enclosingClass != coreClasses.objectClass) {
+      if (equals.enclosingClass != commonElements.objectClass) {
         reporter.reportErrorMessage(spannable,
             MessageKind.CONST_MAP_KEY_OVERRIDES_EQUALS, {'type': keyType});
       }
     }
   }
 
   void analyzeConstant(Node node, {enforceConst: true}) {
     ConstantExpression constant = resolver.constantCompiler
         .compileNode(node, registry.mapping, enforceConst: enforceConst);
 
@@ skipping 88 matching lines @@
         }
       }
     }
     DartType listType;
     if (typeArgument != null) {
       if (node.isConst && typeArgument.containsTypeVariables) {
         reporter.reportErrorMessage(
             arguments.nodes.head, MessageKind.TYPE_VARIABLE_IN_CONSTANT);
         isValidAsConstant = false;
       }
-      listType = coreTypes.listType(typeArgument);
+      listType = commonElements.listType(typeArgument);
     } else {
-      listType = coreTypes.listType();
+      listType = commonElements.listType();
     }
     registry.registerLiteralList(node, listType,
         isConstant: node.isConst, isEmpty: node.elements.isEmpty);
     if (node.isConst) {
       List<ConstantExpression> constantExpressions = <ConstantExpression>[];
       inConstantContext(() {
         for (Node element in node.elements) {
           ResolutionResult elementResult = visit(element);
           if (isValidAsConstant && elementResult.isConstant) {
             constantExpressions.add(elementResult.constant);
@@ skipping 275 matching lines @@
           for (nodes = nodes.tail; !nodes.isEmpty; nodes = nodes.tail) {
             reporter.reportWarningMessage(
                 nodes.head, MessageKind.ADDITIONAL_TYPE_ARGUMENT);
             resolveTypeAnnotation(nodes.head);
           }
         }
       }
     }
     DartType mapType;
     if (valueTypeArgument != null) {
-      mapType = coreTypes.mapType(keyTypeArgument, valueTypeArgument);
+      mapType = commonElements.mapType(keyTypeArgument, valueTypeArgument);
     } else {
-      mapType = coreTypes.mapType();
+      mapType = commonElements.mapType();
     }
     if (node.isConst && mapType.containsTypeVariables) {
       reporter.reportErrorMessage(
           arguments, MessageKind.TYPE_VARIABLE_IN_CONSTANT);
       isValidAsConstant = false;
     }
     registry.registerMapLiteral(node, mapType,
         isConstant: node.isConst, isEmpty: node.entries.isEmpty);
 
     if (node.isConst) {
@@ skipping 31 matching lines @@
   ResolutionResult visitLiteralMapEntry(LiteralMapEntry node) {
     node.visitChildren(this);
     return const NoneResult();
   }
 
   ResolutionResult visitNamedArgument(NamedArgument node) {
     return visit(node.expression);
   }
 
   DartType typeOfConstant(ConstantValue constant) {
-    if (constant.isInt) return coreTypes.intType;
-    if (constant.isBool) return coreTypes.boolType;
-    if (constant.isDouble) return coreTypes.doubleType;
-    if (constant.isString) return coreTypes.stringType;
-    if (constant.isNull) return coreTypes.nullType;
-    if (constant.isFunction) return coreTypes.functionType;
+    if (constant.isInt) return commonElements.intType;
+    if (constant.isBool) return commonElements.boolType;
+    if (constant.isDouble) return commonElements.doubleType;
+    if (constant.isString) return commonElements.stringType;
+    if (constant.isNull) return commonElements.nullType;
+    if (constant.isFunction) return commonElements.functionType;
     assert(constant.isObject);
     ObjectConstantValue objectConstant = constant;
     return objectConstant.type;
   }
 
   bool overridesEquals(DartType type) {
     ClassElement cls = type.element;
     Element equals = cls.lookupMember('==');
-    return equals.enclosingClass != coreClasses.objectClass;
+    return equals.enclosingClass != commonElements.objectClass;
   }
 
   void checkCaseExpressions(SwitchStatement node) {
     CaseMatch firstCase = null;
     DartType firstCaseType = null;
     DiagnosticMessage error;
     List<DiagnosticMessage> infos = <DiagnosticMessage>[];
 
     for (Link<Node> cases = node.cases.nodes;
         !cases.isEmpty;
         cases = cases.tail) {
       SwitchCase switchCase = cases.head;
 
       for (Node labelOrCase in switchCase.labelsAndCases) {
         CaseMatch caseMatch = labelOrCase.asCaseMatch();
         if (caseMatch == null) continue;
 
         // Analyze the constant.
         ConstantExpression constant =
             registry.getConstant(caseMatch.expression);
         assert(invariant(node, constant != null,
             message: 'No constant computed for $node'));
 
         ConstantValue value = resolution.constants.getConstantValue(constant);
-        DartType caseType = value.getType(coreTypes); //typeOfConstant(value);
+        DartType caseType =
+            value.getType(commonElements); //typeOfConstant(value);
 
         if (firstCaseType == null) {
           firstCase = caseMatch;
           firstCaseType = caseType;
 
           // We only report the bad type on the first class element. All others
           // get a "type differs" error.
-          if (caseType == coreTypes.doubleType) {
+          if (caseType == commonElements.doubleType) {
             reporter.reportErrorMessage(
                 node,
                 MessageKind.SWITCH_CASE_VALUE_OVERRIDES_EQUALS,
                 {'type': "double"});
-          } else if (caseType == coreTypes.functionType) {
+          } else if (caseType == commonElements.functionType) {
             reporter.reportErrorMessage(
                 node, MessageKind.SWITCH_CASE_FORBIDDEN, {'type': "Function"});
           } else if (value.isObject && overridesEquals(caseType)) {
             reporter.reportErrorMessage(
                 firstCase.expression,
                 MessageKind.SWITCH_CASE_VALUE_OVERRIDES_EQUALS,
                 {'type': caseType});
           }
         } else {
           if (caseType != firstCaseType) {
@@ skipping 202 matching lines @@
         VariableElementX exceptionElement =
             registry.getDefinition(exceptionVariable);
         exceptionElement.variables.type = exceptionType;
       }
       registry.registerTypeUse(new TypeUse.catchType(exceptionType));
     }
     if (stackTraceDefinition != null) {
       Node stackTraceVariable = stackTraceDefinition.definitions.nodes.head;
       VariableElementX stackTraceElement =
           registry.getDefinition(stackTraceVariable);
-      InterfaceType stackTraceType = coreTypes.stackTraceType;
+      InterfaceType stackTraceType = commonElements.stackTraceType;
       stackTraceElement.variables.type = stackTraceType;
     }
     return const NoneResult();
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(
     DiagnosticReporter reporter, Node node, Scope scope, String name) {
   return Elements.unwrap(scope.lookup(name), reporter, node);
 }