Use entities in CommonElements interface.

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 93 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.commonElements.functionType);
+    ResolutionInterfaceType functionType = compiler.commonElements.functionType;
+    return compiler.types
+        .isAssignable(computeType(compiler.resolution), 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 97 matching lines @@
   final ResolutionDartType type;
 
   TypeLiteralAccess(this.type) {
     assert(type != null);
   }
 
   Element get element => type.element;
 
   String get name => type.name;
 
-  ResolutionDartType computeType(Resolution resolution) =>
+  ResolutionInterfaceType 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 ResolutionDartType type;
 
@@ skipping 505 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, commonElements.functionType)) {
+        ResolutionInterfaceType functionType = commonElements.functionType;
+        if (types.isSubtype(interface, 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 ResolutionDynamicType());
         }
       }
       return null;
     }
 
     ResolutionDartType unaliasedBound =
@@ skipping 835 matching lines @@
   ResolutionDartType visitStringJuxtaposition(StringJuxtaposition node) {
     analyze(node.first);
     analyze(node.second);
     return stringType;
   }
 
   ResolutionDartType visitLiteralNull(LiteralNull node) {
     return const ResolutionDynamicType();
   }
 
-  ResolutionDartType visitLiteralSymbol(LiteralSymbol node) {
+  ResolutionInterfaceType visitLiteralSymbol(LiteralSymbol node) {
     return commonElements.symbolType;
   }
 
   ResolutionDartType computeConstructorType(
       ConstructorElement constructor, ResolutionDartType type) {
     if (Elements.isUnresolved(constructor))
       return const ResolutionDynamicType();
     ResolutionDartType constructorType = constructor.computeType(resolution);
     if (identical(type.kind, ResolutionTypeKind.INTERFACE)) {
       if (constructor.isSynthesized) {
@@ skipping 67 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) {
       ResolutionDartType expressionType = analyze(expression);
       if (executableContext.isGenerativeConstructor) {
         // The resolver already emitted an error for this expression.
       } else {
         if (currentAsyncMarker == AsyncMarker.ASYNC) {
-          expressionType =
+          ResolutionInterfaceType futureOfFlattenedType =
               commonElements.futureType(types.flatten(expressionType));
+          expressionType = futureOfFlattenedType;
         }
         if (expectedReturnType.isVoid &&
             !types.isAssignable(expressionType, const ResolutionVoidType())) {
           reportTypeWarning(expression, MessageKind.RETURN_VALUE_IN_VOID);
         } else {
           checkAssignable(expression, expressionType, expectedReturnType);
         }
       }
     } else if (currentAsyncMarker != AsyncMarker.SYNC) {
       // `return;` is allowed.
@@ skipping 17 matching lines @@
 
   ResolutionDartType visitAwait(Await node) {
     ResolutionDartType expressionType = analyze(node.expression);
     if (resolution.target.supportsAsyncAwait) {
       return types.flatten(expressionType);
     } else {
       return const ResolutionDynamicType();
     }
   }
 
-  ResolutionDartType visitYield(Yield node) {
+  visitYield(Yield node) {
     ResolutionDartType resultType = analyze(node.expression);
     if (!node.hasStar) {
       if (currentAsyncMarker.isAsync) {
-        resultType = commonElements.streamType(resultType);
+        ResolutionInterfaceType streamOfResultType =
+            commonElements.streamType(resultType);
+        resultType = streamOfResultType;
       } else {
-        resultType = commonElements.iterableType(resultType);
+        ResolutionInterfaceType iterableOfResultType =
+            commonElements.iterableType(resultType);
+        resultType = iterableOfResultType;
       }
     } else {
       if (currentAsyncMarker.isAsync) {
         // The static type of expression must be assignable to Stream.
-        checkAssignable(node, resultType, commonElements.streamType());
+        ResolutionInterfaceType streamType = commonElements.streamType();
+        checkAssignable(node, resultType, streamType);
       } else {
         // The static type of expression must be assignable to Iterable.
-        checkAssignable(node, resultType, commonElements.iterableType());
+        ResolutionInterfaceType iterableType = commonElements.iterableType();
+        checkAssignable(node, resultType, iterableType);
       }
     }
     // The static type of the result must be assignable to the declared type.
     checkAssignable(node, resultType, expectedReturnType);
   }
 
   ResolutionDartType visitTypeAnnotation(TypeAnnotation node) {
     return elements.getType(node);
   }
 
@@ skipping 100 matching lines @@
           declaredIdentifier.type, const ResolutionDynamicType());
     } else {
       return analyze(node.declaredIdentifier);
     }
   }
 
   visitAsyncForIn(AsyncForIn node) {
     ResolutionDartType elementType = computeForInElementType(node);
     ResolutionDartType expressionType = analyze(node.expression);
     if (resolution.target.supportsAsyncAwait) {
-      ResolutionDartType streamOfDynamic = commonElements.streamType();
+      ResolutionInterfaceType streamOfDynamic = commonElements.streamType();
       if (!types.isAssignable(expressionType, streamOfDynamic)) {
         reportMessage(node.expression, MessageKind.NOT_ASSIGNABLE,
             {'fromType': expressionType, 'toType': streamOfDynamic},
             isHint: true);
       } else {
         ResolutionInterfaceType interfaceType =
             Types.computeInterfaceType(resolution, expressionType);
         if (interfaceType != null) {
           ResolutionInterfaceType streamType =
               interfaceType.asInstanceOf(streamOfDynamic.element);
@@ skipping 157 matching lines @@
 
   visitTypedef(Typedef node) {
     // Do not typecheck [Typedef] nodes.
   }
 
   visitNode(Node node) {
     reporter.internalError(node,
         'Unexpected node ${node.getObjectDescription()} in the type checker.');
   }
 }