Merge CoreTypes and CoreClasses into CommonElements.

pkg/compiler/lib/src/typechecker.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.typechecker;
 
 import 'common/names.dart' show Identifiers;
 import 'common/resolution.dart' show Resolution;
 import 'common/tasks.dart' show CompilerTask;
 import 'common.dart';
@@ skipping 94 matching lines @@
   /// Returns [: true :] if the element can be access as an invocation.
   bool isCallable(Compiler compiler) {
     if (element != null && element.isAbstractField) {
       AbstractFieldElement abstractFieldElement = element;
       if (abstractFieldElement.getter == null) {
         // Setters cannot be invoked as function invocations.
         return false;
       }
     }
     return compiler.types.isAssignable(
-        computeType(compiler.resolution), compiler.coreTypes.functionType);
+        computeType(compiler.resolution), compiler.commonElements.functionType);
   }
 }
 
 /// An access of a instance member.
 class MemberAccess extends ElementAccess {
   final MemberSignature member;
 
   MemberAccess(MemberSignature this.member);
 
   Element get element => member.declarations.first.element;
@@ skipping 96 matching lines @@
   final DartType type;
 
   TypeLiteralAccess(this.type) {
     assert(type != null);
   }
 
   Element get element => type.element;
 
   String get name => type.name;
 
-  DartType computeType(Resolution resolution) => resolution.coreTypes.typeType;
+  DartType computeType(Resolution resolution) =>
+      resolution.commonElements.typeType;
 
   String toString() => 'TypeLiteralAccess($type)';
 }
 
 /// An access to the 'call' method of a function type.
 class FunctionCallAccess implements ElementAccess {
   final Element element;
   final DartType type;
 
   const FunctionCallAccess(this.element, this.type);
@@ skipping 47 matching lines @@
 
   Node lastSeenNode;
   DartType expectedReturnType;
   AsyncMarker currentAsyncMarker = AsyncMarker.SYNC;
 
   final ClassElement currentClass;
 
   /// The immediately enclosing field, method or constructor being analyzed.
   ExecutableElement executableContext;
 
-  CoreTypes get coreTypes => compiler.coreTypes;
+  CommonElements get commonElements => compiler.commonElements;
 
   DiagnosticReporter get reporter => compiler.reporter;
 
   Resolution get resolution => compiler.resolution;
 
-  InterfaceType get intType => coreTypes.intType;
-  InterfaceType get doubleType => coreTypes.doubleType;
-  InterfaceType get boolType => coreTypes.boolType;
-  InterfaceType get stringType => coreTypes.stringType;
+  InterfaceType get intType => commonElements.intType;
+  InterfaceType get doubleType => commonElements.doubleType;
+  InterfaceType get boolType => commonElements.boolType;
+  InterfaceType get stringType => commonElements.stringType;
 
   DartType thisType;
   DartType superType;
 
   Link<DartType> cascadeTypes = const Link<DartType>();
 
   bool analyzingInitializer = false;
 
   Map<Node, List<TypePromotion>> shownTypePromotionsMap =
       new Map<Node, List<TypePromotion>>();
@@ skipping 421 matching lines @@
           return const DynamicAccess();
         } else {
           return new MemberAccess(member);
         }
       }
       if (name == const PublicName('call')) {
         if (unaliasedBound.isFunctionType) {
           // This is an access the implicit 'call' method of a function type.
           return new FunctionCallAccess(receiverElement, unaliasedBound);
         }
-        if (types.isSubtype(interface, coreTypes.functionType)) {
+        if (types.isSubtype(interface, commonElements.functionType)) {
           // This is an access of the special 'call' method implicitly defined
           // on 'Function'. This method can be called with any arguments, which
           // we ensure by giving it the type 'dynamic'.
           return new FunctionCallAccess(null, const DynamicType());
         }
       }
       return null;
     }
 
     DartType unaliasedBound =
@@ skipping 829 matching lines @@
     analyze(node.first);
     analyze(node.second);
     return stringType;
   }
 
   DartType visitLiteralNull(LiteralNull node) {
     return const DynamicType();
   }
 
   DartType visitLiteralSymbol(LiteralSymbol node) {
-    return coreTypes.symbolType;
+    return commonElements.symbolType;
   }
 
   DartType computeConstructorType(
       ConstructorElement constructor, DartType type) {
     if (Elements.isUnresolved(constructor)) return const DynamicType();
     DartType constructorType = constructor.computeType(resolution);
     if (identical(type.kind, TypeKind.INTERFACE)) {
       if (constructor.isSynthesized) {
         // TODO(johnniwinther): Remove this when synthesized constructors handle
         // type variables correctly.
@@ skipping 66 matching lines @@
 
     // Executing a return statement return e; [...] It is a static type warning
     // if the type of e may not be assigned to the declared return type of the
     // immediately enclosing function.
     if (expression != null) {
       DartType expressionType = analyze(expression);
       if (executableContext.isGenerativeConstructor) {
         // The resolver already emitted an error for this expression.
       } else {
         if (currentAsyncMarker == AsyncMarker.ASYNC) {
-          expressionType = coreTypes.futureType(types.flatten(expressionType));
+          expressionType =
+              commonElements.futureType(types.flatten(expressionType));
         }
         if (expectedReturnType.isVoid &&
             !types.isAssignable(expressionType, const VoidType())) {
           reportTypeWarning(expression, MessageKind.RETURN_VALUE_IN_VOID);
         } else {
           checkAssignable(expression, expressionType, expectedReturnType);
         }
       }
     } else if (currentAsyncMarker != AsyncMarker.SYNC) {
       // `return;` is allowed.
@@ skipping 21 matching lines @@
       return types.flatten(expressionType);
     } else {
       return const DynamicType();
     }
   }
 
   DartType visitYield(Yield node) {
     DartType resultType = analyze(node.expression);
     if (!node.hasStar) {
       if (currentAsyncMarker.isAsync) {
-        resultType = coreTypes.streamType(resultType);
+        resultType = commonElements.streamType(resultType);
       } else {
-        resultType = coreTypes.iterableType(resultType);
+        resultType = commonElements.iterableType(resultType);
       }
     } else {
       if (currentAsyncMarker.isAsync) {
         // The static type of expression must be assignable to Stream.
-        checkAssignable(node, resultType, coreTypes.streamType());
+        checkAssignable(node, resultType, commonElements.streamType());
       } else {
         // The static type of expression must be assignable to Iterable.
-        checkAssignable(node, resultType, coreTypes.iterableType());
+        checkAssignable(node, resultType, commonElements.iterableType());
       }
     }
     // The static type of the result must be assignable to the declared type.
     checkAssignable(node, resultType, expectedReturnType);
     return const StatementType();
   }
 
   DartType visitTypeAnnotation(TypeAnnotation node) {
     return elements.getType(node);
   }
@@ skipping 99 matching lines @@
       return analyzeWithDefault(declaredIdentifier.type, const DynamicType());
     } else {
       return analyze(node.declaredIdentifier);
     }
   }
 
   visitAsyncForIn(AsyncForIn node) {
     DartType elementType = computeForInElementType(node);
     DartType expressionType = analyze(node.expression);
     if (resolution.target.supportsAsyncAwait) {
-      DartType streamOfDynamic = coreTypes.streamType();
+      DartType streamOfDynamic = commonElements.streamType();
       if (!types.isAssignable(expressionType, streamOfDynamic)) {
         reportMessage(node.expression, MessageKind.NOT_ASSIGNABLE,
             {'fromType': expressionType, 'toType': streamOfDynamic},
             isHint: true);
       } else {
         InterfaceType interfaceType =
             Types.computeInterfaceType(resolution, expressionType);
         if (interfaceType != null) {
           InterfaceType streamType =
               interfaceType.asInstanceOf(streamOfDynamic.element);
@@ skipping 161 matching lines @@
 
   visitTypedef(Typedef node) {
     // Do not typecheck [Typedef] nodes.
   }
 
   visitNode(Node node) {
     reporter.internalError(node,
         'Unexpected node ${node.getObjectDescription()} in the type checker.');
   }
 }