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

pkg/compiler/lib/src/elements/modelx.dart

 // Copyright (c) 2013, 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 elements.modelx;
 
+import '../common/resolution.dart' show
+    Resolution,
+    Parsing;
 import '../compiler.dart' show
     Compiler;
 import '../constants/constant_constructors.dart';
 import '../constants/constructors.dart';
 import '../constants/expressions.dart';
 import '../dart_types.dart';
 import '../diagnostics/diagnostic_listener.dart';
 import '../diagnostics/invariant.dart' show
     invariant;
 import '../diagnostics/messages.dart';
@@ skipping 43 matching lines @@
   final Element enclosingElement;
   final int hashCode = ++elementHashCode;
   List<MetadataAnnotation> metadataInternal;
 
   ElementX(this.name, this.kind, this.enclosingElement) {
     assert(isErroneous || implementationLibrary != null);
   }
 
   Modifiers get modifiers => Modifiers.EMPTY;
 
-  Node parseNode(DiagnosticListener listener) {
-    listener.internalError(this,
+  Node parseNode(Parsing parsing) {
+    parsing.listener.internalError(this,
         'parseNode not implemented on $this.');
     return null;
   }
 
   void set metadata(List<MetadataAnnotation> metadata) {
     assert(metadataInternal == null);
     for (MetadataAnnotationX annotation in metadata) {
       assert(annotation.annotatedElement == null);
       annotation.annotatedElement = this;
     }
@@ skipping 223 matching lines @@
   get immediateRedirectionTarget => unsupported();
   get nestedClosures => unsupported();
   get memberContext => unsupported();
   get executableContext => unsupported();
   get isExternal => unsupported();
   get constantConstructor => null;
 
   bool get isRedirectingGenerative => unsupported();
   bool get isRedirectingFactory => unsupported();
 
-  computeSignature(compiler) => unsupported();
-  computeType(compiler) => unsupported();
+  computeSignature(Resolution resolution) => unsupported();
+  computeType(Resolution resolution) => unsupported();
 
   bool get hasFunctionSignature => false;
 
   get effectiveTarget => this;
 
   computeEffectiveTargetType(InterfaceType newType) => unsupported();
 
   get definingConstructor => null;
 
   FunctionElement asFunctionElement() => this;
@@ skipping 947 matching lines @@
   PrefixElementX(String prefix,
                  Element enclosing,
                  this.firstPosition,
                  this.deferredImport)
       : super(prefix, ElementKind.PREFIX, enclosing);
 
   bool get isTopLevel => false;
 
   Element lookupLocalMember(String memberName) => importScope[memberName];
 
-  DartType computeType(Compiler compiler) => const DynamicType();
+  DartType computeType(Resolution resolution) => const DynamicType();
 
   Token get position => firstPosition;
 
   void addImport(Element element,
                  ImportElement import,
                  DiagnosticListener listener) {
     importScope.addImport(this, element, import, listener);
   }
 
   accept(ElementVisitor visitor, arg) {
@@ skipping 34 matching lines @@
   /**
    * Function signature for a typedef of a function type. The signature is
    * kept to provide full information about parameter names through the mirror
    * system.
    *
    * The [functionSignature] is not available until the typedef element has been
    * resolved.
    */
   FunctionSignature functionSignature;
 
-  TypedefType computeType(Compiler compiler) {
+  TypedefType computeType(Resolution resolution) {
     if (thisTypeCache != null) return thisTypeCache;
-    Typedef node = parseNode(compiler);
-    setThisAndRawTypes(compiler, createTypeVariables(node.typeParameters));
-    ensureResolved(compiler);
+    Typedef node = parseNode(resolution.parsing);
+    setThisAndRawTypes(createTypeVariables(node.typeParameters));
+    ensureResolved(resolution);
     return thisTypeCache;
   }
 
-  void ensureResolved(Compiler compiler) {
+  void ensureResolved(Resolution resolution) {
     if (resolutionState == STATE_NOT_STARTED) {
-      compiler.resolver.resolve(this);
+      resolution.resolveTypedef(this);
     }
   }
 
   TypedefType createType(List<DartType> typeArguments) {
     return new TypedefType(this, typeArguments);
   }
 
   Scope buildScope() {
     return new TypeDeclarationScope(enclosingElement.buildScope(), this);
   }
 
-  void checkCyclicReference(Compiler compiler) {
+  void checkCyclicReference(Resolution resolution) {
     if (hasBeenCheckedForCycles) return;
-    var visitor = new TypedefCyclicVisitor(compiler, this);
-    computeType(compiler).accept(visitor, null);
+    var visitor = new TypedefCyclicVisitor(resolution.listener, this);
+    computeType(resolution).accept(visitor, null);
     hasBeenCheckedForCycles = true;
   }
 
   accept(ElementVisitor visitor, arg) {
     return visitor.visitTypedefElement(this, arg);
   }
 
   // A typedef cannot be patched therefore defines itself.
   AstElement get definingElement => this;
 }
@@ skipping 27 matching lines @@
       //    @foo @bar var a, b, c
       //
       // the metadata list is reported through the declaration of `a`, and `b`
       // and `c` report an empty list of metadata.
       return;
     }
     assert(metadataInternal == null);
     metadataInternal = metadata;
   }
 
-  VariableDefinitions parseNode(Element element, DiagnosticListener listener) {
+  VariableDefinitions parseNode(Element element, Parsing parsing) {
     return definitions;
   }
 
-  DartType computeType(Element element, Compiler compiler) => type;
+  DartType computeType(Element element, Resolution resolution) => type;
 }
 
 abstract class ConstantVariableMixin implements VariableElement {
   ConstantExpression constantCache;
 
   ConstantExpression get constant {
     if (isPatch) {
       ConstantVariableMixin originVariable = origin;
       return originVariable.constant;
     }
@@ skipping 58 matching lines @@
         message: "Node has not been computed for $this."));
     return definitionsCache;
   }
 
   Expression get initializer {
     assert(invariant(this, definitionsCache != null,
         message: "Initializer has not been computed for $this."));
     return initializerCache;
   }
 
-  Node parseNode(DiagnosticListener listener) {
+  Node parseNode(Parsing parsing) {
     if (definitionsCache != null) return definitionsCache;
 
-    VariableDefinitions definitions = variables.parseNode(this, listener);
+    VariableDefinitions definitions = variables.parseNode(this, parsing);
     createDefinitions(definitions);
     return definitionsCache;
   }
 
   void createDefinitions(VariableDefinitions definitions) {
     assert(invariant(this, definitionsCache == null,
         message: "VariableDefinitions has already been computed for $this."));
     Expression node;
     int count = 0;
     for (Link<Node> link = definitions.definitions.nodes;
@@ skipping 19 matching lines @@
       // Create a [VariableDefinitions] node for the single definition of
       // [node].
       definitionsCache = new VariableDefinitions(definitions.type,
           definitions.modifiers, new NodeList(
               definitions.definitions.beginToken,
               const Link<Node>().prepend(node),
               definitions.definitions.endToken));
     }
   }
 
-  DartType computeType(Compiler compiler) {
+  DartType computeType(Resolution resolution) {
     if (variables.type != null) return variables.type;
     // Call [parseNode] to ensure that [definitionsCache] and [initializerCache]
     // are set as a consequence of calling [computeType].
-    return compiler.withCurrentElement(this, () {
-      parseNode(compiler);
-      return variables.computeType(this, compiler);
-    });
+    parseNode(resolution.parsing);
+    return variables.computeType(this, resolution);
   }
 
   DartType get type {
     assert(invariant(this, variables.type != null,
         message: "Type has not been computed for $this."));
     return variables.type;
   }
 
   bool get isInstanceMember => isClassMember && !isStatic;
 
@@ skipping 120 matching lines @@
   AstElement get definingElement => this;
 
   void reuseElement() {
     throw new UnsupportedError("reuseElement");
   }
 
   FieldElementX copyWithEnclosing(Element enclosingElement) {
     throw new UnsupportedError("copyWithEnclosing");
   }
 
-  DartType computeType(Compiler compiler) => type;
+  DartType computeType(Resolution resolution) => type;
 }
 
 /// [Element] for a parameter-like element.
 class FormalElementX extends ElementX
     with AstElementMixin
     implements FormalElement {
   final VariableDefinitions definitions;
   final Identifier identifier;
   DartType typeCache;
 
@@ skipping 10 matching lines @@
                  Identifier identifier)
       : this.identifier = identifier,
         super(identifier.source, elementKind, enclosingElement);
 
   FunctionTypedElement get functionDeclaration => enclosingElement;
 
   Modifiers get modifiers => definitions.modifiers;
 
   Token get position => identifier.getBeginToken();
 
-  Node parseNode(DiagnosticListener listener) => definitions;
+  Node parseNode(Parsing parsing) => definitions;
 
-  DartType computeType(Compiler compiler) {
+  DartType computeType(Resolution resolution) {
     assert(invariant(this, type != null,
         message: "Parameter type has not been set for $this."));
     return type;
   }
 
   DartType get type {
     assert(invariant(this, typeCache != null,
             message: "Parameter type has not been set for $this."));
         return typeCache;
   }
@@ skipping 132 matching lines @@
   GetterElementX getter;
   SetterElementX setter;
 
   AbstractFieldElementX(String name, Element enclosing)
       : super(name, ElementKind.ABSTRACT_FIELD, enclosing);
 
   DartType computeType(Compiler compiler) {
     throw "internal error: AbstractFieldElement has no type";
   }
 
-  Node parseNode(DiagnosticListener listener) {
+  Node parseNode(Parsing parsing) {
     throw "internal error: AbstractFieldElement has no node";
   }
 
   Token get position {
     // The getter and setter may be defined in two different
     // compilation units.  However, we know that one of them is
     // non-null and defined in the same compilation unit as the
     // abstract element.
     // TODO(lrn): No we don't know that if the element from the same
     // compilation unit is patched.
@@ skipping 83 matching lines @@
   bool get isExternal => modifiers.isExternal;
 
   bool get isInstanceMember {
     return isClassMember
            && !isConstructor
            && !isStatic;
   }
 
   bool get hasFunctionSignature => functionSignatureCache != null;
 
-  FunctionSignature computeSignature(Compiler compiler) {
+  FunctionSignature computeSignature(Resolution resolution) {
     if (functionSignatureCache != null) return functionSignatureCache;
-    compiler.withCurrentElement(this, () {
-      functionSignatureCache = compiler.resolver.resolveSignature(this);
-    });
+    functionSignatureCache = resolution.resolveSignature(this);
     return functionSignatureCache;
   }
 
   FunctionSignature get functionSignature {
     assert(invariant(this, functionSignatureCache != null,
         message: "Function signature has not been computed for $this."));
     return functionSignatureCache;
   }
 
   List<ParameterElement> get parameters {
     // TODO(johnniwinther): Store the list directly, possibly by using List
     // instead of Link in FunctionSignature.
     List<ParameterElement> list = <ParameterElement>[];
     functionSignature.forEachParameter((e) => list.add(e));
     return list;
   }
 
-  FunctionType computeType(Compiler compiler) {
+  FunctionType computeType(Resolution resolution) {
     if (typeCache != null) return typeCache;
-    typeCache = computeSignature(compiler).type;
+    typeCache = computeSignature(resolution).type;
     return typeCache;
   }
 
   FunctionType get type {
     assert(invariant(this, typeCache != null,
         message: "Type has not been computed for $this."));
     return typeCache;
   }
 
   FunctionElement asFunctionElement() => this;
@@ skipping 96 matching lines @@
                         Modifiers modifiers,
                         ExecutableElement enclosing)
       : super(name, kind, modifiers, enclosing);
 
   ExecutableElement get executableContext => enclosingElement;
 
   MemberElement get memberContext => executableContext.memberContext;
 
   bool get hasNode => true;
 
-  FunctionExpression parseNode(DiagnosticListener listener) => node;
+  FunctionExpression parseNode(Parsing parsing) => node;
 
   Token get position {
     // Use the name as position if this is not an unnamed closure.
     if (node.name != null) {
       return node.name.getBeginToken();
     } else {
       return node.getBeginToken();
     }
   }
 
@@ skipping 100 matching lines @@
     implements GetterElement {
   final PrefixElement prefix;
 
   DeferredLoaderGetterElementX(PrefixElement prefix)
       : this.prefix = prefix,
         super("loadLibrary",
               Modifiers.EMPTY,
               prefix,
               false);
 
-  FunctionSignature computeSignature(Compiler compiler) {
+  FunctionSignature computeSignature(Resolution resolution) {
     if (functionSignatureCache != null) return functionSignature;
-    compiler.withCurrentElement(this, () {
-      DartType inner = new FunctionType(this);
-      functionSignatureCache = new FunctionSignatureX(type: inner);
-    });
+    functionSignatureCache =
+        new FunctionSignatureX(type: new FunctionType(this));
     return functionSignatureCache;
   }
 
   bool get isClassMember => false;
 
   bool get isSynthesized => true;
 
   bool get isDeferredLoaderGetter => true;
 
   bool get isTopLevel => true;
   // By having position null, the enclosing elements location is printed in
   // error messages.
   Token get position => null;
 
-  FunctionExpression parseNode(DiagnosticListener listener) => null;
+  FunctionExpression parseNode(Parsing parsing) => null;
 
   bool get hasNode => false;
 
   FunctionExpression get node => null;
 
   @override
   SetterElement get setter => null;
 }
 
 class ConstructorBodyElementX extends BaseFunctionElementX
@@ skipping 10 matching lines @@
   }
 
   bool get hasNode => constructor.hasNode;
 
   FunctionExpression get node => constructor.node;
 
   List<MetadataAnnotation> get metadata => constructor.metadata;
 
   bool get isInstanceMember => true;
 
-  FunctionType computeType(Compiler compiler) {
-    compiler.internalError(this, '$this.computeType.');
+  FunctionType computeType(Resolution resolution) {
+    resolution.listener.internalError(this, '$this.computeType.');
     return null;
   }
 
   Token get position => constructor.position;
 
   Element get outermostEnclosingMemberOrTopLevel => constructor;
 
   Element get analyzableElement => constructor.analyzableElement;
 
   accept(ElementVisitor visitor, arg) {
@@ skipping 27 matching lines @@
                                             Element enclosing)
       : isDefaultConstructor = true,
         super('',
               ElementKind.GENERATIVE_CONSTRUCTOR,
               Modifiers.EMPTY,
               enclosing) {
     typeCache = new FunctionType.synthesized(enclosingClass.thisType);
     functionSignatureCache = new FunctionSignatureX(type: type);
   }
 
-  FunctionExpression parseNode(DiagnosticListener listener) => null;
+  FunctionExpression parseNode(Parsing parsing) => null;
 
   bool get hasNode => false;
 
   FunctionExpression get node => null;
 
   Token get position => enclosingElement.position;
 
   bool get isSynthesized => true;
 
   DartType get type {
     if (isDefaultConstructor) {
       return super.type;
     } else {
       // TODO(johnniwinther): Ensure that the function type substitutes type
       // variables correctly.
       return definingConstructor.type;
     }
   }
 
-  FunctionSignature computeSignature(compiler) {
+  FunctionSignature computeSignature(Resolution resolution) {
     if (functionSignatureCache != null) return functionSignatureCache;
     if (definingConstructor.isErroneous) {
-      return functionSignatureCache =
-          compiler.objectClass.localLookup('').computeSignature(compiler);
+      typeCache = new FunctionType.synthesized(enclosingClass.thisType);
+      return functionSignatureCache = new FunctionSignatureX(type: type);
     }
     // TODO(johnniwinther): Ensure that the function signature (and with it the
     // function type) substitutes type variables correctly.
-    definingConstructor.computeType(compiler);
+    definingConstructor.computeType(resolution);
     functionSignatureCache = definingConstructor.functionSignature;
     typeCache = definingConstructor.type;
     return functionSignatureCache;
   }
 
   accept(ElementVisitor visitor, arg) {
     return visitor.visitConstructorElement(this, arg);
   }
 }
 
@@ skipping 39 matching lines @@
   }
 
   T get rawType {
     assert(invariant(this, rawTypeCache != null,
                      message: 'Raw type has not been computed for $this'));
     return rawTypeCache;
   }
 
   T createType(List<DartType> typeArguments);
 
-  void setThisAndRawTypes(Compiler compiler, List<DartType> typeParameters) {
+  void setThisAndRawTypes(List<DartType> typeParameters) {
     assert(invariant(this, thisTypeCache == null,
         message: "This type has already been set on $this."));
     assert(invariant(this, rawTypeCache == null,
         message: "Raw type has already been set on $this."));
     thisTypeCache = createType(typeParameters);
     if (typeParameters.isEmpty) {
       rawTypeCache = thisTypeCache;
     } else {
       List<DartType> dynamicParameters =
           new List.filled(typeParameters.length, const DynamicType());
@@ skipping 66 matching lines @@
 
   int get hashCode => id;
 
   bool get hasBackendMembers => !backendMembers.isEmpty;
 
   bool get isUnnamedMixinApplication => false;
 
   @override
   bool get isEnumClass => false;
 
-  InterfaceType computeType(Compiler compiler) {
+  InterfaceType computeType(Resolution resolution) {
     if (isPatch) {
-      origin.computeType(compiler);
+      origin.computeType(resolution);
       thisTypeCache = origin.thisType;
       rawTypeCache = origin.rawType;
     } else if (thisTypeCache == null) {
-      computeThisAndRawType(compiler, computeTypeParameters(compiler));
+      computeThisAndRawType(
+          resolution, computeTypeParameters(resolution.parsing));
     }
     return thisTypeCache;
   }
 
-  void computeThisAndRawType(Compiler compiler, List<DartType> typeVariables) {
+  void computeThisAndRawType(Resolution resolution,
+                             List<DartType> typeVariables) {
     if (thisTypeCache == null) {
       if (origin == null) {
-        setThisAndRawTypes(compiler, typeVariables);
+        setThisAndRawTypes(typeVariables);
       } else {
-        thisTypeCache = origin.computeType(compiler);
+        thisTypeCache = origin.computeType(resolution);
         rawTypeCache = origin.rawType;
       }
     }
   }
 
   @override
   InterfaceType createType(List<DartType> typeArguments) {
     return new InterfaceType(this, typeArguments);
   }
 
-  List<DartType> computeTypeParameters(Compiler compiler);
+  List<DartType> computeTypeParameters(Parsing parsing);
 
   bool get isObject {
     assert(invariant(this, isResolved,
         message: "isObject has not been computed for $this."));
     return supertype == null;
   }
 
-  void ensureResolved(Compiler compiler) {
+  void ensureResolved(Resolution resolution) {
     if (resolutionState == STATE_NOT_STARTED) {
-      compiler.resolver.resolveClass(this);
-      compiler.world.registerClass(this);
+      resolution.resolveClass(this);
+      resolution.registerClass(this);
     }
   }
 
-  void setDefaultConstructor(FunctionElement constructor, Compiler compiler);
+  void setDefaultConstructor(FunctionElement constructor,
+                             DiagnosticListener listener);
 
   void addBackendMember(Element member) {
     // TODO(ngeoffray): Deprecate this method.
     assert(member.isGenerativeConstructorBody);
     backendMembers = backendMembers.prepend(member);
   }
 
   void reverseBackendMembers() {
     backendMembers = backendMembers.reverse();
   }
@@ skipping 106 matching lines @@
   }
 
   bool get hasConstructor {
     // Search in scope to be sure we search patched constructors.
     for (var element in localScope.values) {
       if (element.isConstructor) return true;
     }
     return false;
   }
 
-  void setDefaultConstructor(FunctionElement constructor, Compiler compiler) {
+  void setDefaultConstructor(FunctionElement constructor,
+                             DiagnosticListener listener) {
     // The default constructor, although synthetic, is part of a class' API.
-    addMember(constructor, compiler);
+    addMember(constructor, listener);
   }
 
-  List<DartType> computeTypeParameters(Compiler compiler) {
-    ClassNode node = parseNode(compiler);
+  List<DartType> computeTypeParameters(Parsing parsing) {
+    ClassNode node = parseNode(parsing);
     return createTypeVariables(node.typeParameters);
   }
 
   Scope buildScope() => new ClassScope(enclosingElement.buildScope(), this);
 
   String toString() {
     if (origin != null) {
       return 'patch ${super.toString()}';
     } else if (patch != null) {
       return 'origin ${super.toString()}';
@@ skipping 13 matching lines @@
   @override
   bool get hasNode => true;
 
   @override
   Token get position => node.name.token;
 
   @override
   bool get isEnumClass => true;
 
   @override
-  Node parseNode(Compiler compiler) => node;
+  Node parseNode(Parsing parsing) => node;
 
   @override
   accept(ElementVisitor visitor, arg) {
     return visitor.visitEnumClassElement(this, arg);
   }
 
-  List<DartType> computeTypeParameters(Compiler compiler) => const <DartType>[];
+  List<DartType> computeTypeParameters(Parsing parsing) => const <DartType>[];
 
   List<FieldElement> get enumValues {
     assert(invariant(this, _enumValues != null,
         message: "enumValues has not been computed for $this."));
     return _enumValues;
   }
 
   void set enumValues(List<FieldElement> values) {
     assert(invariant(this, _enumValues == null,
         message: "enumValues has already been computed for $this."));
     _enumValues = values;
   }
 }
 
 class EnumConstructorElementX extends ConstructorElementX {
   final FunctionExpression node;
 
   EnumConstructorElementX(EnumClassElementX enumClass,
                           Modifiers modifiers,
                           this.node)
       : super('', // Name.
               ElementKind.GENERATIVE_CONSTRUCTOR,
               modifiers,
               enumClass);
 
   @override
   bool get hasNode => true;
 
   @override
-  FunctionExpression parseNode(Compiler compiler) => node;
+  FunctionExpression parseNode(Parsing parsing) => node;
 }
 
 class EnumMethodElementX extends MethodElementX {
   final FunctionExpression node;
 
   EnumMethodElementX(String name,
                      EnumClassElementX enumClass,
                      Modifiers modifiers,
                      this.node)
       : super(name, ElementKind.FUNCTION, modifiers, enumClass, true);
 
   @override
   bool get hasNode => true;
 
   @override
-  FunctionExpression parseNode(Compiler compiler) => node;
+  FunctionExpression parseNode(Parsing parsing) => node;
 }
 
 class EnumFormalElementX extends InitializingFormalElementX {
   EnumFormalElementX(ConstructorElement constructor,
                      VariableDefinitions variables,
                      Identifier identifier,
                      EnumFieldElementX fieldElement)
       : super(constructor, variables, identifier, null, fieldElement) {
     typeCache = fieldElement.type;
   }
@@ skipping 33 matching lines @@
   bool get hasConstructor => !constructors.isEmpty;
   bool get hasLocalScopeMembers => !constructors.isEmpty;
 
   get patch => null;
   get origin => null;
 
   bool get hasNode => true;
 
   Token get position => node.getBeginToken();
 
-  Node parseNode(DiagnosticListener listener) => node;
+  Node parseNode(Parsing parsing) => node;
 
   FunctionElement lookupLocalConstructor(String name) {
     for (Link<Element> link = constructors;
          !link.isEmpty;
          link = link.tail) {
       if (link.head.name == name) return link.head;
     }
     return null;
   }
 
@@ skipping 18 matching lines @@
   }
 
   void addToScope(Element element, DiagnosticListener listener) {
     listener.internalError(this, 'Cannot add to scope of $this.');
   }
 
   void addConstructor(FunctionElement constructor) {
     constructors = constructors.prepend(constructor);
   }
 
-  void setDefaultConstructor(FunctionElement constructor, Compiler compiler) {
+  void setDefaultConstructor(FunctionElement constructor,
+                             DiagnosticListener listener) {
     assert(!hasConstructor);
     addConstructor(constructor);
   }
 
-  List<DartType> computeTypeParameters(Compiler compiler) {
+  List<DartType> computeTypeParameters(Parsing parsing) {
     NamedMixinApplication named = node.asNamedMixinApplication();
     if (named == null) {
       throw new SpannableAssertionFailure(node,
           "Type variables on unnamed mixin applications must be set on "
           "creation.");
     }
     return createTypeVariables(named.typeParameters);
   }
 
   accept(ElementVisitor visitor, arg) {
@@ skipping 64 matching lines @@
   DartType boundCache;
 
   TypeVariableElementX(String name,
                        TypeDeclarationElement enclosing,
                        this.index,
                        this.node)
     : super(name, ElementKind.TYPE_VARIABLE, enclosing);
 
   TypeDeclarationElement get typeDeclaration => enclosingElement;
 
-  TypeVariableType computeType(compiler) => type;
+  TypeVariableType computeType(Resolution resolution) => type;
 
   TypeVariableType get type {
     assert(invariant(this, typeCache != null,
         message: "Type has not been set on $this."));
     return typeCache;
   }
 
   DartType get bound {
     assert(invariant(this, boundCache != null,
         message: "Bound has not been set on $this."));
     return boundCache;
   }
 
   bool get hasNode => true;
 
-  Node parseNode(compiler) => node;
+  Node parseNode(Parsing parsing) => node;
 
   Token get position => node.getBeginToken();
 
   accept(ElementVisitor visitor, arg) {
     return visitor.visitTypeVariableElement(this, arg);
   }
 
   // A type variable cannot be patched therefore defines itself.
   AstElement get definingElement => this;
 }
@@ skipping 31 matching lines @@
   Element annotatedElement;
   int resolutionState;
 
   /**
    * The beginning token of this annotation, or [:null:] if it is synthetic.
    */
   Token get beginToken;
 
   MetadataAnnotationX([this.resolutionState = STATE_NOT_STARTED]);
 
-  MetadataAnnotation ensureResolved(Compiler compiler) {
+  MetadataAnnotation ensureResolved(Resolution resolution) {
     if (annotatedElement.isClass || annotatedElement.isTypedef) {
       TypeDeclarationElement typeDeclaration = annotatedElement;
-      typeDeclaration.ensureResolved(compiler);
+      typeDeclaration.ensureResolved(resolution);
     }
     if (resolutionState == STATE_NOT_STARTED) {
-      compiler.resolver.resolveMetadataAnnotation(this);
+      resolution.resolveMetadataAnnotation(this);
     }
     return this;
   }
 
-  Node parseNode(DiagnosticListener listener);
+  Node parseNode(Parsing parsing);
 
   String toString() => 'MetadataAnnotation($constant, $resolutionState)';
 }
 
 /// Metadata annotation on a parameter.
 class ParameterMetadataAnnotation extends MetadataAnnotationX {
   final Metadata metadata;
 
   ParameterMetadataAnnotation(Metadata this.metadata);
 
-  Node parseNode(DiagnosticListener listener) => metadata.expression;
+  Node parseNode(Parsing parsing) => metadata.expression;
 
   Token get beginToken => metadata.getBeginToken();
 
   Token get endToken => metadata.getEndToken();
 
   bool get hasNode => true;
 
   Metadata get node => metadata;
 }
 
@@ skipping 42 matching lines @@
   AstElement get definingElement;
 
   bool get hasResolvedAst => definingElement.hasTreeElements;
 
   ResolvedAst get resolvedAst {
     return new ResolvedAst(declaration,
         definingElement.node, definingElement.treeElements);
   }
 
 }