Add Resolution and Parsing interfaces for computeType, ensureResolved and parseNode.

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 'compiler.dart' show
     Compiler;
 import 'constants/expressions.dart';
 import 'constants/values.dart';
 import 'core_types.dart';
 import 'dart_types.dart';
 import 'diagnostics/diagnostic_listener.dart' show
     DiagnosticMessage;
@@ skipping 78 matching lines @@
 
 /**
  * [ElementAccess] represents the access of [element], either as a property
  * access or invocation.
  */
 abstract class ElementAccess {
   Element get element;
 
   String get name => element.name;
 
-  DartType computeType(Compiler compiler);
+  DartType computeType(Resolution resolution);
 
   /// 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), compiler.coreTypes.functionType);
+        computeType(compiler.resolution), compiler.coreTypes.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;
 
-  DartType computeType(Compiler compiler) => member.type;
+  DartType computeType(Resolution resolution) => member.type;
 
   String toString() => 'MemberAccess($member)';
 }
 
 /// An access of an unresolved element.
 class DynamicAccess implements ElementAccess {
   const DynamicAccess();
 
   Element get element => null;
 
   String get name => 'dynamic';
 
-  DartType computeType(Compiler compiler) => const DynamicType();
+  DartType computeType(Resolution resolution) => const DynamicType();
 
   bool isCallable(Compiler compiler) => true;
 
   String toString() => 'DynamicAccess';
 }
 
 /**
  * An access of a resolved top-level or static property or function, or an
  * access of a resolved element through [:this:].
  */
 class ResolvedAccess extends ElementAccess {
   final Element element;
 
   ResolvedAccess(Element this.element) {
     assert(element != null);
   }
 
-  DartType computeType(Compiler compiler) {
+  DartType computeType(Resolution resolution) {
     if (element.isGetter) {
       GetterElement getter = element;
-      FunctionType functionType = getter.computeType(compiler);
+      FunctionType functionType = getter.computeType(resolution);
       return functionType.returnType;
     } else if (element.isSetter) {
       SetterElement setter = element;
-      FunctionType functionType = setter.computeType(compiler);
+      FunctionType functionType = setter.computeType(resolution);
       if (functionType.parameterTypes.length != 1) {
         // TODO(johnniwinther,karlklose): this happens for malformed static
         // setters. Treat them the same as instance members.
         return const DynamicType();
       }
       return functionType.parameterTypes.first;
     } else if (element.isTypedef || element.isClass) {
       TypeDeclarationElement typeDeclaration = element;
-      typeDeclaration.computeType(compiler);
+      typeDeclaration.computeType(resolution);
       return typeDeclaration.thisType;
     } else {
       TypedElement typedElement = element;
-      typedElement.computeType(compiler);
+      typedElement.computeType(resolution);
       return typedElement.type;
     }
   }
 
   String toString() => 'ResolvedAccess($element)';
 }
 
 /// An access to a promoted variable.
 class PromotedAccess extends ElementAccess {
   final VariableElement element;
   final DartType type;
 
   PromotedAccess(VariableElement this.element, DartType this.type) {
     assert(element != null);
     assert(type != null);
   }
 
-  DartType computeType(Compiler compiler) => type;
+  DartType computeType(Resolution resolution) => type;
 
   String toString() => 'PromotedAccess($element,$type)';
 }
 
 /**
  * An access of a resolved top-level or static property or function, or an
  * access of a resolved element through [:this:].
  */
 class TypeAccess extends ElementAccess {
   final DartType type;
   TypeAccess(DartType this.type) {
     assert(type != null);
   }
 
   Element get element => type.element;
 
-  DartType computeType(Compiler compiler) => type;
+  DartType computeType(Resolution resolution) => type;
 
   String toString() => 'TypeAccess($type)';
 }
 
 /**
  * An access of a type literal.
  */
 class TypeLiteralAccess extends ElementAccess {
   final DartType type;
 
   TypeLiteralAccess(this.type) {
     assert(type != null);
   }
 
   Element get element => type.element;
 
   String get name => type.name;
 
-  DartType computeType(Compiler compiler) => compiler.typeClass.rawType;
+  DartType computeType(Resolution resolution) => resolution.coreTypes.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);
 
   String get name => 'call';
 
-  DartType computeType(Compiler compiler) => type;
+  DartType computeType(Resolution resolution) => type;
 
   bool isCallable(Compiler compiler) => true;
 
   String toString() => 'FunctionAccess($element, $type)';
 }
 
 
 /// An is-expression that potentially promotes a variable.
 class TypePromotion {
   final Send node;
@@ skipping 35 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;
+  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;
 
   DartType thisType;
   DartType superType;
 
   Link<DartType> cascadeTypes = const Link<DartType>();
@@ skipping 332 matching lines @@
                      message: 'FunctionExpression with no element'));
     if (Elements.isUnresolved(element)) return const DynamicType();
     if (element.isGenerativeConstructor) {
       type = const DynamicType();
       returnType = const VoidType();
 
       element.functionSignature.forEachParameter((ParameterElement parameter) {
         if (parameter.isInitializingFormal) {
           InitializingFormalElement fieldParameter = parameter;
           checkAssignable(parameter, parameter.type,
-              fieldParameter.fieldElement.computeType(compiler));
+              fieldParameter.fieldElement.computeType(resolution));
         }
       });
       if (node.initializers != null) {
         analyze(node.initializers, inInitializer: true);
       }
     } else {
-      FunctionType functionType = element.computeType(compiler);
+      FunctionType functionType = element.computeType(resolution);
       returnType = functionType.returnType;
       type = functionType;
     }
     ExecutableElement previousExecutableContext = executableContext;
     DartType previousReturnType = expectedReturnType;
     expectedReturnType = returnType;
     AsyncMarker previousAsyncMarker = currentAsyncMarker;
 
     executableContext = element;
     currentAsyncMarker = element.asyncMarker;
@@ skipping 11 matching lines @@
     } else if (node.isSuper()) {
       return superType;
     } else {
       TypedElement element = elements[node];
       assert(invariant(node, element != null,
           message: 'Missing element for identifier'));
       assert(invariant(node, element.isVariable ||
                              element.isParameter ||
                              element.isField,
           message: 'Unexpected context element ${element}'));
-      return element.computeType(compiler);
+      return element.computeType(resolution);
     }
   }
 
   DartType visitIf(If node) {
     Expression condition = node.condition.expression;
     Statement thenPart = node.thenPart;
 
     checkCondition(node.condition);
     analyzeInPromotedContext(condition, thenPart);
     if (node.elsePart != null) {
@@ skipping 162 matching lines @@
         }
       }
     }
     return const DynamicAccess();
   }
 
   DartType lookupMemberType(Node node, DartType type, String name,
                             MemberKind memberKind,
                             {bool isHint: false}) {
     return lookupMember(node, type, name, memberKind, null, isHint: isHint)
-        .computeType(compiler);
+        .computeType(resolution);
   }
 
   void analyzeArguments(Send send, Element element, DartType type,
                         [LinkBuilder<DartType> argumentTypes]) {
     Link<Node> arguments = send.arguments;
-    DartType unaliasedType = type.unalias(compiler);
+    DartType unaliasedType = type.unalias(resolution);
     if (identical(unaliasedType.kind, TypeKind.FUNCTION)) {
 
       /// Report [warning] including info(s) about the declaration of [element]
       /// or [type].
       void reportWarning(DiagnosticMessage warning) {
         // TODO(johnniwinther): Support pointing to individual parameters on
         // assignability warnings.
         List<DiagnosticMessage> infos = <DiagnosticMessage>[];
         Element declaration = element;
         if (declaration == null) {
@@ skipping 92 matching lines @@
       }
     }
   }
 
   // Analyze the invocation [node] of [elementAccess].
   //
   // If provided [argumentTypes] is filled with the argument types during
   // analysis.
   DartType analyzeInvocation(Send node, ElementAccess elementAccess,
                              [LinkBuilder<DartType> argumentTypes]) {
-    DartType type = elementAccess.computeType(compiler);
+    DartType type = elementAccess.computeType(resolution);
     if (elementAccess.isCallable(compiler)) {
       analyzeArguments(node, elementAccess.element, type, argumentTypes);
     } else {
       reportTypeWarning(node, MessageKind.NOT_CALLABLE,
           {'elementName': elementAccess.name});
       analyzeArguments(node, elementAccess.element, const DynamicType(),
                        argumentTypes);
     }
-    type = type.unalias(compiler);
+    type = type.unalias(resolution);
     if (identical(type.kind, TypeKind.FUNCTION)) {
       FunctionType funType = type;
       return funType.returnType;
     } else {
       return const DynamicType();
     }
   }
 
   /**
    * Computes the [ElementAccess] for [name] on the [node] possibly using the
@@ skipping 90 matching lines @@
 
   /**
    * Computes the type of the access of [name] on the [node] possibly using the
    * [element] provided for [node] by the resolver.
    */
   DartType computeAccessType(Send node, String name, Element element,
                              MemberKind memberKind,
                              {bool lookupClassMember: false}) {
     DartType type =
         computeAccess(node, name, element, memberKind,
-            lookupClassMember: lookupClassMember).computeType(compiler);
+            lookupClassMember: lookupClassMember).computeType(resolution);
     if (type == null) {
       compiler.internalError(node, 'Type is null on access of $name on $node.');
     }
     return type;
   }
 
   /// Compute a version of [shownType] that is more specific that [knownType].
   /// This is used to provided better hints when trying to promote a supertype
   /// to a raw subtype. For instance trying to promote `Iterable<int>` to `List`
   /// we suggest the use of `List<int>`, which would make promotion valid.
@@ skipping 196 matching lines @@
             return intType;
           } else if (identical(argumentType.element, compiler.doubleClass)) {
             return doubleType;
           }
         }
       }
       return resultType;
     } else if (node.isPropertyAccess) {
       ElementAccess access =
           computeAccess(node, selector.source, element, MemberKind.GETTER);
-      return access.computeType(compiler);
+      return access.computeType(resolution);
     } else if (node.isFunctionObjectInvocation) {
       return unhandledExpression();
     } else {
       ElementAccess access =
           computeAccess(node, selector.source, element, MemberKind.METHOD);
       return analyzeInvocation(node, access);
     }
   }
 
   /// Returns the first type in the list or [:dynamic:] if the list is empty.
@@ skipping 223 matching lines @@
     return const DynamicType();
   }
 
   DartType visitLiteralSymbol(LiteralSymbol node) {
     return compiler.symbolClass.rawType;
   }
 
   DartType computeConstructorType(ConstructorElement constructor,
                                   DartType type) {
     if (Elements.isUnresolved(constructor)) return const DynamicType();
-    DartType constructorType = constructor.computeType(compiler);
+    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.
         InterfaceType interfaceType = type;
         ClassElement receiverElement = interfaceType.element;
         while (receiverElement.isMixinApplication) {
           receiverElement = receiverElement.supertype.element;
         }
         constructorType = constructorType.substByContext(
@@ skipping 202 matching lines @@
           analyzeWithDefault(declaredIdentifier.type, const DynamicType());
     } else {
       return analyze(node.declaredIdentifier);
     }
   }
 
   visitAsyncForIn(AsyncForIn node) {
     DartType elementType = computeForInElementType(node);
     DartType expressionType = analyze(node.expression);
     // TODO(johnniwinther): Move this to _CompilerCoreTypes.
-    compiler.streamClass.ensureResolved(compiler);
+    compiler.streamClass.ensureResolved(resolution);
     DartType streamOfDynamic = coreTypes.streamType();
     if (!types.isAssignable(expressionType, streamOfDynamic)) {
       reportMessage(node.expression,
           MessageKind.NOT_ASSIGNABLE,
           {'fromType': expressionType, 'toType': streamOfDynamic},
           isHint: true);
     } else {
       InterfaceType interfaceType =
           Types.computeInterfaceType(compiler, expressionType);
       if (interfaceType != null) {
@@ skipping 155 matching lines @@
 
   visitTypedef(Typedef node) {
     // Do not typecheck [Typedef] nodes.
   }
 
   visitNode(Node node) {
     compiler.internalError(node,
         'Unexpected node ${node.getObjectDescription()} in the type checker.');
   }
 }