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

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.
 
 part of native;
 
 /// This class is a temporary work-around until we get a more powerful DartType.
 class SpecialType {
   final String name;
   const SpecialType._(this.name);
@@ skipping 448 matching lines @@
     }
 
     behavior.codeTemplate =
         js.js.parseForeignJS(codeArgument.dartString.slowToString());
 
     String specString = specArgument.dartString.slowToString();
 
     dynamic resolveType(String typeString) {
       return _parseType(
           typeString,
-          compiler,
+          compiler.resolution,
           (name) => resolver.resolveTypeFromString(specArgument, name),
           specArgument);
     }
 
     bool sideEffectsAreEncodedInSpecString = false;
 
     void setSideEffects(SideEffects newEffects) {
       sideEffectsAreEncodedInSpecString = true;
       behavior.sideEffects.setTo(newEffects);
     }
@@ skipping 14 matching lines @@
 
     processSpecString(compiler, specArgument,
         specString,
         setSideEffects: setSideEffects,
         setThrows: setThrows,
         setIsAllocation: setIsAllocation,
         setUseGvn: setUseGvn,
         resolveType: resolveType,
         typesReturned: behavior.typesReturned,
         typesInstantiated: behavior.typesInstantiated,
-        objectType: compiler.objectClass.computeType(compiler),
-        nullType: compiler.nullClass.computeType(compiler));
+        objectType: compiler.coreTypes.objectType,
+        nullType: compiler.coreTypes.nullType);
 
     if (!sideEffectsAreEncodedInSpecString) {
       new SideEffectsVisitor(behavior.sideEffects)
           .visit(behavior.codeTemplate.ast);
     }
     if (!throwBehaviorFromSpecString) {
       behavior.throwBehavior =
           new ThrowBehaviorVisitor().analyze(behavior.codeTemplate.ast);
     }
 
@@ skipping 41 matching lines @@
       // TODO(sra): We could accept a type identifier? e.g. JS(bool, '1<2').  It
       // is not very satisfactory because it does not work for void, dynamic.
       compiler.internalError(argNodes.head, "Unexpected first argument.");
     }
 
     String specString = specLiteral.dartString.slowToString();
 
     dynamic resolveType(String typeString) {
       return _parseType(
           typeString,
-          compiler,
+          compiler.resolution,
           (name) => resolver.resolveTypeFromString(specLiteral, name),
           jsBuiltinOrEmbeddedGlobalCall);
     }
 
     void setSideEffects(SideEffects newEffects) {
       behavior.sideEffects.setTo(newEffects);
     }
 
     processSpecString(compiler, jsBuiltinOrEmbeddedGlobalCall,
                       specString,
                       validTags: validTags,
                       resolveType: resolveType,
                       setSideEffects: setSideEffects,
                       typesReturned: behavior.typesReturned,
                       typesInstantiated: behavior.typesInstantiated,
-                      objectType: compiler.objectClass.computeType(compiler),
-                      nullType: compiler.nullClass.computeType(compiler));
+                      objectType: compiler.coreTypes.objectType,
+                      nullType: compiler.coreTypes.nullType);
   }
 
   static NativeBehavior ofJsBuiltinCall(Send jsBuiltinCall,
                                         Compiler compiler,
                                         ResolverVisitor resolver) {
     NativeBehavior behavior = new NativeBehavior();
     behavior.sideEffects.setTo(new SideEffects());
 
     _fillNativeBehaviorOfBuiltinOrEmbeddedGlobal(
         behavior, jsBuiltinCall, compiler, resolver, isBuiltin: true);
@@ skipping 12 matching lines @@
     behavior.throwBehavior = NativeThrowBehavior.NEVER;
 
     _fillNativeBehaviorOfBuiltinOrEmbeddedGlobal(
         behavior, jsEmbeddedGlobalCall, compiler, resolver,
         isBuiltin: false,
         validTags: const ['returns', 'creates']);
 
     return behavior;
   }
 
-  static NativeBehavior ofMethod(FunctionElement method, Compiler compiler) {
-    FunctionType type = method.computeType(compiler);
+  static NativeBehavior ofMethod(FunctionElement method,  Compiler compiler) {
+    FunctionType type = method.computeType(compiler.resolution);
     var behavior = new NativeBehavior();
     behavior.typesReturned.add(type.returnType);
     if (!type.returnType.isVoid) {
       // Declared types are nullable.
-      behavior.typesReturned.add(compiler.nullClass.computeType(compiler));
+      behavior.typesReturned.add(compiler.coreTypes.nullType);
     }
-    behavior._capture(type, compiler);
+    behavior._capture(type, compiler.resolution);
 
     // TODO(sra): Optional arguments are currently missing from the
     // DartType. This should be fixed so the following work-around can be
     // removed.
     method.functionSignature.forEachOptionalParameter(
         (ParameterElement parameter) {
-          behavior._escape(parameter.type, compiler);
+          behavior._escape(parameter.type, compiler.resolution);
         });
 
     behavior._overrideWithAnnotations(method, compiler);
     return behavior;
   }
 
   static NativeBehavior ofFieldLoad(MemberElement field, Compiler compiler) {
-    DartType type = field.computeType(compiler);
+    DartType type = field.computeType(compiler.resolution);
     var behavior = new NativeBehavior();
     behavior.typesReturned.add(type);
     // Declared types are nullable.
-    behavior.typesReturned.add(compiler.nullClass.computeType(compiler));
-    behavior._capture(type, compiler);
+    behavior.typesReturned.add(compiler.coreTypes.nullType);
+    behavior._capture(type, compiler.resolution);
     behavior._overrideWithAnnotations(field, compiler);
     return behavior;
   }
 
   static NativeBehavior ofFieldStore(MemberElement field, Compiler compiler) {
-    DartType type = field.computeType(compiler);
+    DartType type = field.computeType(compiler.resolution);
     var behavior = new NativeBehavior();
-    behavior._escape(type, compiler);
+    behavior._escape(type, compiler.resolution);
     // We don't override the default behaviour - the annotations apply to
     // loading the field.
     return behavior;
   }
 
   void _overrideWithAnnotations(Element element, Compiler compiler) {
     if (element.implementation.metadata.isEmpty) return;
 
     DartType lookup(String name) {
       Element e = element.buildScope().lookup(name);
       if (e == null) return null;
       if (e is! ClassElement) return null;
       ClassElement cls = e;
-      cls.ensureResolved(compiler);
+      cls.ensureResolved(compiler.resolution);
       return cls.thisType;
     }
 
     NativeEnqueuer enqueuer = compiler.enqueuer.resolution.nativeEnqueuer;
     var creates = _collect(element, compiler, enqueuer.annotationCreatesClass,
                            lookup);
     var returns = _collect(element, compiler, enqueuer.annotationReturnsClass,
                            lookup);
 
     if (creates != null) {
       typesInstantiated..clear()..addAll(creates);
     }
     if (returns != null) {
       typesReturned..clear()..addAll(returns);
     }
   }
 
   /**
    * Returns a list of type constraints from the annotations of
    * [annotationClass].
    * Returns `null` if no constraints.
    */
   static _collect(Element element, Compiler compiler, Element annotationClass,
                   lookup(str)) {
     var types = null;
     for (MetadataAnnotation annotation in element.implementation.metadata) {
-      annotation.ensureResolved(compiler);
+      annotation.ensureResolved(compiler.resolution);
       ConstantValue value =
           compiler.constants.getConstantValue(annotation.constant);
       if (!value.isConstructedObject) continue;
       ConstructedConstantValue constructedObject = value;
       if (constructedObject.type.element != annotationClass) continue;
 
       Iterable<ConstantValue> fields = constructedObject.fields.values;
       // TODO(sra): Better validation of the constant.
       if (fields.length != 1 || !fields.single.isString) {
-        PartialMetadataAnnotation partial = annotation;
         compiler.internalError(annotation,
-            'Annotations needs one string: ${partial.parseNode(compiler)}');
+            '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, lookup, annotation);
+        var type =
+            _parseType(typeString, compiler.resolution, 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, Compiler compiler) {
-    type = type.unalias(compiler);
+  void _escape(DartType type, Resolution resolution) {
+    type = type.unalias(resolution);
     if (type is FunctionType) {
       FunctionType functionType = type;
       // A function might be called from native code, passing us novel
       // parameters.
-      _escape(functionType.returnType, compiler);
+      _escape(functionType.returnType, resolution);
       for (DartType parameter in functionType.parameterTypes) {
-        _capture(parameter, compiler);
+        _capture(parameter, resolution);
       }
     }
   }
 
   /// Models the behavior of Dart code receiving instances and methods of [type]
   /// from native code.  We usually start the analysis by capturing a native
   /// method that has been used.
-  void _capture(DartType type, Compiler compiler) {
-    type = type.unalias(compiler);
+  void _capture(DartType type, Resolution resolution) {
+    type = type.unalias(resolution);
     if (type is FunctionType) {
       FunctionType functionType = type;
-      _capture(functionType.returnType, compiler);
+      _capture(functionType.returnType, resolution);
       for (DartType parameter in functionType.parameterTypes) {
-        _escape(parameter, compiler);
+        _escape(parameter, resolution);
       }
     } else {
       typesInstantiated.add(type);
     }
   }
 
-  static dynamic _parseType(String typeString, Compiler compiler,
+  static dynamic _parseType(
+      String typeString,
+      Resolution resolution,
       lookup(name), locationNodeOrElement) {
     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) {
-      compiler.reportErrorMessage(
-          _errorNode(locationNodeOrElement, compiler),
+      resolution.listener.reportErrorMessage(
+          _errorNode(locationNodeOrElement, resolution.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;
     }
-    compiler.reportErrorMessage(
-        _errorNode(locationNodeOrElement, compiler),
+    resolution.listener.reportErrorMessage(
+        _errorNode(locationNodeOrElement, resolution.parsing),
         MessageKind.GENERIC,
         {'text': "Type '$typeString' not found."});
     return const DynamicType();
   }
 
-  static _errorNode(locationNodeOrElement, compiler) {
+  static _errorNode(locationNodeOrElement, Parsing parsing) {
     if (locationNodeOrElement is Node) return locationNodeOrElement;
-    return locationNodeOrElement.parseNode(compiler);
+    return locationNodeOrElement.parseNode(parsing);
   }
 }