Refactor Parsing to remove compiler dependency

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.dart';
-import '../common/resolution.dart' show Resolution, Parsing;
+import '../common/resolution.dart' show Resolution, ParsingContext;
 import '../compiler.dart' show Compiler;
 import '../constants/constant_constructors.dart';
 import '../constants/constructors.dart';
 import '../constants/expressions.dart';
 import '../dart_types.dart';
 import '../diagnostics/messages.dart' show MessageTemplate;
 import '../ordered_typeset.dart' show OrderedTypeSet;
 import '../resolution/class_members.dart' show ClassMemberMixin;
 import '../resolution/scope.dart'
     show ClassScope, LibraryScope, Scope, TypeDeclarationScope;
@@ skipping 26 matching lines @@
   final Element enclosingElement;
   final int hashCode = ++elementHashCode;
   List<MetadataAnnotation> metadataInternal;
 
   ElementX(this.name, this.kind, this.enclosingElement) {
     assert(isError || implementationLibrary != null);
   }
 
   Modifiers get modifiers => Modifiers.EMPTY;
 
-  Node parseNode(Parsing parsing) {
+  Node parseNode(ParsingContext parsing) {
     parsing.reporter.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 1255 matching lines @@
    * 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(Resolution resolution) {
     if (thisTypeCache != null) return thisTypeCache;
-    Typedef node = parseNode(resolution.parsing);
+    Typedef node = parseNode(resolution.parsingContext);
     setThisAndRawTypes(createTypeVariables(node.typeParameters));
     ensureResolved(resolution);
     return thisTypeCache;
   }
 
   void ensureResolved(Resolution resolution) {
     if (resolutionState == STATE_NOT_STARTED) {
       resolution.resolveTypedef(this);
     }
   }
@@ skipping 52 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, Parsing parsing) {
+  VariableDefinitions parseNode(Element element, ParsingContext parsing) {
     return definitions;
   }
 
   DartType computeType(Element element, Resolution resolution) => type;
 }
 
 abstract class ConstantVariableMixin implements VariableElement {
   ConstantExpression constantCache;
 
   ConstantExpression get 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(Parsing parsing) {
+  Node parseNode(ParsingContext parsing) {
     if (definitionsCache != null) return definitionsCache;
 
     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."));
@@ skipping 29 matching lines @@
               definitions.definitions.beginToken,
               const Link<Node>().prepend(node),
               definitions.definitions.endToken));
     }
   }
 
   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].
-    parseNode(resolution.parsing);
+    parseNode(resolution.parsingContext);
     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 149 matching lines @@
       this.definitions, 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(Parsing parsing) => definitions;
+  Node parseNode(ParsingContext parsing) => definitions;
 
   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."));
@@ skipping 139 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(Parsing parsing) {
+  Node parseNode(ParsingContext 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 233 matching lines @@
   LocalFunctionElementX(String name, FunctionExpression this.node,
       ElementKind kind, Modifiers modifiers, ExecutableElement enclosing)
       : super(name, kind, modifiers, enclosing);
 
   ExecutableElement get executableContext => enclosingElement;
 
   MemberElement get memberContext => executableContext.memberContext;
 
   bool get hasNode => true;
 
-  FunctionExpression parseNode(Parsing parsing) => node;
+  FunctionExpression parseNode(ParsingContext 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 136 matching lines @@
 
   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(Parsing parsing) => null;
+  FunctionExpression parseNode(ParsingContext parsing) => null;
 
   bool get hasNode => false;
 
   FunctionExpression get node => null;
 
   @override
   SetterElement get setter => null;
 }
 
 class ConstructorBodyElementX extends BaseFunctionElementX
@@ skipping 60 matching lines @@
     functionSignature = new FunctionSignatureX(
         type: new FunctionType.synthesized(enclosingClass.thisType));
     _resolvedAst =
         new SynthesizedResolvedAst(this, ResolvedAstKind.DEFAULT_CONSTRUCTOR);
   }
 
   bool get isDefaultConstructor {
     return _resolvedAst.kind == ResolvedAstKind.DEFAULT_CONSTRUCTOR;
   }
 
-  FunctionExpression parseNode(Parsing parsing) => null;
+  FunctionExpression parseNode(ParsingContext parsing) => null;
 
   bool get hasNode => false;
 
   FunctionExpression get node => null;
 
   Token get position => enclosingElement.position;
 
   bool get isSynthesized => true;
 
   bool get hasResolvedAst => true;
@@ skipping 160 matching lines @@
   @override
   bool get isEnumClass => false;
 
   InterfaceType computeType(Resolution resolution) {
     if (isPatch) {
       origin.computeType(resolution);
       thisTypeCache = origin.thisType;
       rawTypeCache = origin.rawType;
     } else if (thisTypeCache == null) {
       computeThisAndRawType(
-          resolution, computeTypeParameters(resolution.parsing));
+          resolution, computeTypeParameters(resolution.parsingContext));
     }
     return thisTypeCache;
   }
 
   void computeThisAndRawType(
       Resolution resolution, List<DartType> typeVariables) {
     if (thisTypeCache == null) {
       if (origin == null) {
         setThisAndRawTypes(typeVariables);
       } else {
         thisTypeCache = origin.computeType(resolution);
         rawTypeCache = origin.rawType;
       }
     }
   }
 
   @override
   InterfaceType createType(List<DartType> typeArguments) {
     return new InterfaceType(this, typeArguments);
   }
 
-  List<DartType> computeTypeParameters(Parsing parsing);
+  List<DartType> computeTypeParameters(ParsingContext parsing);
 
   bool get isObject {
     assert(invariant(this, isResolved,
         message: "isObject has not been computed for $this."));
     return supertype == null;
   }
 
   void ensureResolved(Resolution resolution) {
     if (resolutionState == STATE_NOT_STARTED) {
       resolution.resolveClass(this);
@@ skipping 111 matching lines @@
     }
     return false;
   }
 
   void setDefaultConstructor(
       FunctionElement constructor, DiagnosticReporter reporter) {
     // The default constructor, although synthetic, is part of a class' API.
     addMember(constructor, reporter);
   }
 
-  List<DartType> computeTypeParameters(Parsing parsing) {
+  List<DartType> computeTypeParameters(ParsingContext 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) {
@@ skipping 40 matching lines @@
   @override
   bool get hasNode => true;
 
   @override
   Token get position => node.name.token;
 
   @override
   bool get isEnumClass => true;
 
   @override
-  Node parseNode(Parsing parsing) => node;
+  Node parseNode(ParsingContext parsing) => node;
 
   @override
   accept(ElementVisitor visitor, arg) {
     return visitor.visitEnumClassElement(this, arg);
   }
 
-  List<DartType> computeTypeParameters(Parsing parsing) => const <DartType>[];
+  List<DartType> computeTypeParameters(ParsingContext 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."));
@@ skipping 37 matching lines @@
       : super(
             '', // Name.
             ElementKind.GENERATIVE_CONSTRUCTOR,
             modifiers,
             enumClass);
 
   @override
   bool get hasNode => true;
 
   @override
-  FunctionExpression parseNode(Parsing parsing) => node;
+  FunctionExpression parseNode(ParsingContext parsing) => node;
 
   @override
   SourceSpan get sourcePosition => enclosingClass.sourcePosition;
 }
 
 /// This element is used to encode the implicit methods in an enum class.
 ///
 /// For instance
 ///
 ///     enum A { b, c, }
@@ skipping 21 matching lines @@
   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(Parsing parsing) => node;
+  FunctionExpression parseNode(ParsingContext parsing) => node;
 
   @override
   SourceSpan get sourcePosition => enclosingClass.sourcePosition;
 }
 
 /// This element is used to encode the initializing formal of the implicit
 /// constructor in an enum class.
 ///
 /// For instance
 ///
@@ skipping 133 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(Parsing parsing) => node;
+  Node parseNode(ParsingContext parsing) => node;
 
   void addMember(Element element, DiagnosticReporter reporter) {
     throw new UnsupportedError("Cannot add member to $this.");
   }
 
   void addToScope(Element element, DiagnosticReporter reporter) {
     reporter.internalError(this, 'Cannot add to scope of $this.');
   }
 
   void addConstructor(FunctionElement constructor) {
     constructors = constructors.prepend(constructor);
   }
 
   void setDefaultConstructor(
       FunctionElement constructor, DiagnosticReporter reporter) {
     assert(!hasConstructor);
     addConstructor(constructor);
   }
 
-  List<DartType> computeTypeParameters(Parsing parsing) {
+  List<DartType> computeTypeParameters(ParsingContext 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);
   }
 
@@ skipping 103 matching lines @@
   }
 
   DartType get bound {
     assert(invariant(this, boundCache != null,
         message: "Bound has not been set on $this."));
     return boundCache;
   }
 
   bool get hasNode => true;
 
-  Node parseNode(Parsing parsing) => node;
+  Node parseNode(ParsingContext 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 42 matching lines @@
     if (annotatedElement.isClass || annotatedElement.isTypedef) {
       TypeDeclarationElement typeDeclaration = annotatedElement;
       typeDeclaration.ensureResolved(resolution);
     }
     if (resolutionState == STATE_NOT_STARTED) {
       resolution.resolveMetadataAnnotation(this);
     }
     return this;
   }
 
-  Node parseNode(Parsing parsing);
+  Node parseNode(ParsingContext parsing);
 
   String toString() => 'MetadataAnnotation($constant, $resolutionState)';
 }
 
 /// Metadata annotation on a parameter.
 class ParameterMetadataAnnotation extends MetadataAnnotationX {
   final Metadata metadata;
 
   ParameterMetadataAnnotation(Metadata this.metadata);
 
-  Node parseNode(Parsing parsing) => metadata.expression;
+  Node parseNode(ParsingContext parsing) => metadata.expression;
 
   Token get beginToken => metadata.getBeginToken();
 
   Token get endToken => metadata.getEndToken();
 
   bool get hasNode => true;
 
   Metadata get node => metadata;
 }
 
@@ skipping 43 matching lines @@
 
   bool get hasResolvedAst {
     return definingElement.hasNode && definingElement.hasTreeElements;
   }
 
   ResolvedAst get resolvedAst {
     return new ParsedResolvedAst(
         declaration, definingElement.node, definingElement.treeElements);
   }
 }