Add CoreClasses

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 '../compiler.dart' show
@@ skipping 166 matching lines @@
       // TODO(karlklose): clean this up (dartbug.com/8870).
       inCheckContext = compiler.enableTypeAssertions &&
           !element.isLibrary &&
           !element.isTypedef &&
           !element.enclosingElement.isTypedef,
       inCatchBlock = false,
       constantState = element.isConst
           ? ConstantState.CONSTANT : ConstantState.NON_CONSTANT,
       super(compiler, registry);
 
+  CoreClasses get coreClasses => compiler.coreClasses;
+
   CoreTypes get coreTypes => compiler.coreTypes;
 
   AsyncMarker get currentAsyncMarker {
     if (enclosingElement is FunctionElement) {
       FunctionElement function = enclosingElement;
       return function.asyncMarker;
     }
     return AsyncMarker.SYNC;
   }
 
@@ skipping 155 matching lines @@
         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 = compiler.typeClass;
+        element = coreClasses.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 1730 matching lines @@
   /// 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);
     AccessSemantics semantics = new ConstantAccess.dynamicTypeLiteral(constant);
     return handleConstantTypeLiteralAccess(
-        node, const PublicName('dynamic'), compiler.typeClass, type, semantics);
+        node, const PublicName('dynamic'),
+        coreClasses.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'), compiler.typeClass, type, semantics);
+        node, const PublicName('dynamic'),
+        coreClasses.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;
@@ skipping 1439 matching lines @@
             node,
             MessageKind.RETURN_IN_GENERATOR,
             {'modifier': currentAsyncMarker});
       }
     }
     visit(node.expression);
     return const NoneResult();
   }
 
   ResolutionResult visitYield(Yield node) {
-    compiler.streamClass.ensureResolved(resolution);
-    compiler.iterableClass.ensureResolved(resolution);
+    coreClasses.streamClass.ensureResolved(resolution);
+    coreClasses.iterableClass.ensureResolved(resolution);
     visit(node.expression);
     return const NoneResult();
   }
 
   ResolutionResult visitRedirectingFactoryBody(RedirectingFactoryBody node) {
     final isSymbolConstructor = enclosingElement == compiler.symbolConstructor;
     if (!enclosingElement.isFactoryConstructor) {
       reporter.reportErrorMessage(
           node, MessageKind.FACTORY_REDIRECTION_IN_NON_FACTORY);
       reporter.reportHintMessage(
@@ skipping 103 matching lines @@
     return const NoneResult();
   }
 
   ResolutionResult visitThrow(Throw node) {
     registry.registerThrowExpression();
     visit(node.expression);
     return const NoneResult();
   }
 
   ResolutionResult visitAwait(Await node) {
-    compiler.futureClass.ensureResolved(resolution);
+    coreClasses.futureClass.ensureResolved(resolution);
     visit(node.expression);
     return const NoneResult();
   }
 
   ResolutionResult visitVariableDefinitions(VariableDefinitions node) {
     DartType type;
     if (node.type != null) {
       type = resolveTypeAnnotation(node.type);
     } else {
       type = const DynamicType();
@@ skipping 130 matching lines @@
           String nameString = stringConstant.toDartString().slowToString();
           if (validateSymbol(argumentNode, nameString)) {
             registry.registerConstSymbol(nameString);
           }
         }
       } else {
         if (!compiler.mirrorUsageAnalyzerTask.hasMirrorUsage(
                 enclosingElement)) {
           reporter.reportHintMessage(
               node.newToken, MessageKind.NON_CONST_BLOAT,
-              {'name': compiler.symbolClass.name});
+              {'name': coreClasses.symbolClass.name});
         }
       }
     } else if (isMirrorsUsedConstant) {
       compiler.mirrorUsageAnalyzerTask.validate(node, registry.mapping);
     }
     if (node.isConst) {
       analyzeConstantDeferred(node);
 
       // TODO(johnniwinther): Compute this in the [ConstructorResolver].
       // Check that the constructor is not deferred.
@@ skipping 27 matching lines @@
     return const NoneResult();
   }
 
   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 == compiler.stringClass) continue;
+      if (cls == coreClasses.stringClass) continue;
       Element equals = cls.lookupMember('==');
-      if (equals.enclosingClass != compiler.objectClass) {
+      if (equals.enclosingClass != coreClasses.objectClass) {
         reporter.reportErrorMessage(
             spannable,
             MessageKind.CONST_MAP_KEY_OVERRIDES_EQUALS,
             {'type': keyType});
       }
     }
   }
 
   void analyzeConstant(Node node, {enforceConst: true}) {
     ConstantExpression constant =
@@ skipping 462 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 compiler.intClass.rawType;
-    if (constant.isBool) return compiler.boolClass.rawType;
-    if (constant.isDouble) return compiler.doubleClass.rawType;
-    if (constant.isString) return compiler.stringClass.rawType;
-    if (constant.isNull) return compiler.nullClass.rawType;
-    if (constant.isFunction) return compiler.functionClass.rawType;
+    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;
     assert(constant.isObject);
     ObjectConstantValue objectConstant = constant;
     return objectConstant.type;
   }
 
   bool overridesEquals(DartType type) {
     ClassElement cls = type.element;
     Element equals = cls.lookupMember('==');
-    return equals.enclosingClass != compiler.objectClass;
+    return equals.enclosingClass != coreClasses.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 = compiler.constants.getConstantValue(constant);
-        DartType caseType = typeOfConstant(value);
+        DartType caseType = value.getType(coreTypes);//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.element == compiler.doubleClass) {
+          if (caseType == coreTypes.doubleType) {
             reporter.reportErrorMessage(
                 node,
                 MessageKind.SWITCH_CASE_VALUE_OVERRIDES_EQUALS,
                 {'type': "double"});
-          } else if (caseType.element == compiler.functionClass) {
+          } else if (caseType == coreTypes.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 {
@@ skipping 212 matching lines @@
     }
     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);
 }