Refactor Parsing to remove compiler dependency

pkg/compiler/lib/src/native/behavior.dart

 // Copyright (c) 2014, 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.
 
 import '../common.dart';
 import '../common/backend_api.dart' show ForeignResolver;
-import '../common/resolution.dart' show Parsing, Resolution;
+import '../common/resolution.dart' show ParsingContext, Resolution;
 import '../compiler.dart' show Compiler;
 import '../constants/values.dart';
 import '../core_types.dart' show CoreTypes;
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../js/js.dart' as js;
 import '../js_backend/js_backend.dart';
 import '../tree/tree.dart';
 import '../universe/side_effects.dart' show SideEffects;
 import '../util/util.dart';
@@ skipping 435 matching lines @@
           default:
             reportError("Unrecognized side-effect flag: '$dependency'.");
         }
       }
     }
 
     return sideEffects;
   }
 
   static NativeBehavior ofJsCall(Send jsCall, DiagnosticReporter reporter,
-      Parsing parsing, CoreTypes coreTypes, ForeignResolver resolver) {
+      ParsingContext parsing, CoreTypes coreTypes, ForeignResolver resolver) {
     // The first argument of a JS-call is a string encoding various attributes
     // of the code.
     //
     //  'Type1|Type2'.  A union type.
     //  '=Object'.      A JavaScript Object, no subtype.
 
     NativeBehavior behavior = new NativeBehavior();
 
     var argNodes = jsCall.arguments;
     if (argNodes.isEmpty || argNodes.tail.isEmpty) {
@@ skipping 70 matching lines @@
           new ThrowBehaviorVisitor().analyze(behavior.codeTemplate.ast);
     }
 
     return behavior;
   }
 
   static void _fillNativeBehaviorOfBuiltinOrEmbeddedGlobal(
       NativeBehavior behavior,
       Send jsBuiltinOrEmbeddedGlobalCall,
       DiagnosticReporter reporter,
-      Parsing parsing,
+      ParsingContext parsing,
       CoreTypes coreTypes,
       ForeignResolver resolver,
       {bool isBuiltin,
       List<String> validTags}) {
     // The first argument of a JS-embedded global call is a string encoding
     // the type of the code.
     //
     //  'Type1|Type2'.  A union type.
     //  '=Object'.      A JavaScript Object, no subtype.
 
@@ skipping 47 matching lines @@
         setSideEffects: setSideEffects,
         typesReturned: behavior.typesReturned,
         typesInstantiated: behavior.typesInstantiated,
         objectType: coreTypes.objectType,
         nullType: coreTypes.nullType);
   }
 
   static NativeBehavior ofJsBuiltinCall(
       Send jsBuiltinCall,
       DiagnosticReporter reporter,
-      Parsing parsing,
+      ParsingContext parsing,
       CoreTypes coreTypes,
       ForeignResolver resolver) {
     NativeBehavior behavior = new NativeBehavior();
     behavior.sideEffects.setTo(new SideEffects());
 
     _fillNativeBehaviorOfBuiltinOrEmbeddedGlobal(
         behavior, jsBuiltinCall, reporter, parsing, coreTypes, resolver,
         isBuiltin: true);
 
     return behavior;
   }
 
   static NativeBehavior ofJsEmbeddedGlobalCall(
       Send jsEmbeddedGlobalCall,
       DiagnosticReporter reporter,
-      Parsing parsing,
+      ParsingContext parsing,
       CoreTypes coreTypes,
       ForeignResolver resolver) {
     NativeBehavior behavior = new NativeBehavior();
     // TODO(sra): Allow the use site to override these defaults.
     // Embedded globals are usually pre-computed data structures or JavaScript
     // functions that never change.
     behavior.sideEffects.setTo(new SideEffects.empty());
     behavior.throwBehavior = NativeThrowBehavior.NEVER;
 
     _fillNativeBehaviorOfBuiltinOrEmbeddedGlobal(
@@ skipping 117 matching lines @@
 
       Iterable<ConstantValue> fields = constructedObject.fields.values;
       // TODO(sra): Better validation of the constant.
       if (fields.length != 1 || !fields.single.isString) {
         reporter.internalError(
             annotation, 'Annotations needs one string: ${annotation.node}');
       }
       StringConstantValue specStringConstant = fields.single;
       String specString = specStringConstant.toDartString().slowToString();
       for (final typeString in specString.split('|')) {
-        var type = _parseType(typeString, compiler.parsing, lookup, annotation);
+        var type =
+            _parseType(typeString, compiler.parsingContext, lookup, annotation);
         if (types == null) types = [];
         types.add(type);
       }
     }
     return types;
   }
 
   /// Models the behavior of having intances of [type] escape from Dart code
   /// into native code.
   void _escape(DartType type, Resolution resolution) {
@@ skipping 53 matching lines @@
         } else {
           // Otherwise, when the declared type is a Dart type, we do not
           // register an allocation because we assume it cannot be instantiated
           // from within the JS-interop code. It must have escaped from another
           // API.
         }
       }
     }
   }
 
-  static dynamic _parseType(
-      String typeString, Parsing parsing, lookup(name), locationNodeOrElement) {
+  static dynamic _parseType(String typeString, ParsingContext parsing,
+      lookup(name), locationNodeOrElement) {
     DiagnosticReporter reporter = parsing.reporter;
     if (typeString == '=Object') return SpecialType.JsObject;
     if (typeString == 'dynamic') {
       return const DynamicType();
     }
     var type = lookup(typeString);
     if (type != null) return type;
 
     int index = typeString.indexOf('<');
     if (index < 1) {
       reporter.reportErrorMessage(_errorNode(locationNodeOrElement, parsing),
           MessageKind.GENERIC, {'text': "Type '$typeString' not found."});
       return const DynamicType();
     }
     type = lookup(typeString.substring(0, index));
     if (type != null) {
       // TODO(sra): Parse type parameters.
       return type;
     }
     reporter.reportErrorMessage(_errorNode(locationNodeOrElement, parsing),
         MessageKind.GENERIC, {'text': "Type '$typeString' not found."});
     return const DynamicType();
   }
 
-  static _errorNode(locationNodeOrElement, Parsing parsing) {
+  static _errorNode(locationNodeOrElement, ParsingContext parsing) {
     if (locationNodeOrElement is Node) return locationNodeOrElement;
     return locationNodeOrElement.parseNode(parsing);
   }
 }