Compute NativeBehavior for foreign functions.

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 ParsingContext, Resolution;
 import '../compiler.dart' show Compiler;
+import '../constants/expressions.dart';
 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';
 import 'enqueue.dart';
 import 'js.dart';
 
+typedef dynamic /*DartType|SpecialType*/ TypeLookup(String typeString);
+
 /// This class is a temporary work-around until we get a more powerful DartType.
 class SpecialType {
   final String name;
   const SpecialType._(this.name);
 
   /// The type Object, but no subtypes:
   static const JsObject = const SpecialType._('=Object');
 
   int get hashCode => name.hashCode;
 
@@ skipping 225 matching lines @@
   /// [nullType] define the types for `Object` and `Null`, respectively. The
   /// latter is used for the type strings of the form '' and 'var'.
   /// [validTags] can be used to restrict which tags are accepted.
   static void processSpecString(
       DiagnosticReporter reporter, Spannable spannable, String specString,
       {Iterable<String> validTags,
       void setSideEffects(SideEffects newEffects),
       void setThrows(NativeThrowBehavior throwKind),
       void setIsAllocation(bool isAllocation),
       void setUseGvn(bool useGvn),
-      dynamic resolveType(String typeString),
+      TypeLookup lookupType,
       List typesReturned,
       List typesInstantiated,
       objectType,
       nullType}) {
     bool seenError = false;
 
     void reportError(String message) {
       seenError = true;
       reporter.reportErrorMessage(
           spannable, MessageKind.GENERIC, {'text': message});
@@ skipping 22 matching lines @@
         }
         return;
       }
       if (typesString == '' || typesString == 'var') {
         if (onVar != null) {
           onVar();
         }
         return;
       }
       for (final typeString in typesString.split('|')) {
-        onType(resolveType(typeString.trim()));
+        onType(_parseType(typeString.trim(), spannable, reporter, lookupType));
       }
     }
 
     if (!specString.contains(';') && !specString.contains(':')) {
       // Form (1), types or pseudo-types like 'void' and 'var'.
       resolveTypesString(specString.trim(), onVar: () {
         typesReturned.add(objectType);
         typesReturned.add(nullType);
       }, onType: (type) {
         typesInstantiated.add(type);
@@ skipping 159 matching lines @@
             break;
           default:
             reportError("Unrecognized side-effect flag: '$dependency'.");
         }
       }
     }
 
     return sideEffects;
   }
 
-  static NativeBehavior ofJsCall(Send jsCall, DiagnosticReporter reporter,
+  /// Returns a [TypeLookup] that uses [resolver] to perform lookup and [node]
+  /// as position for errors.
+  static TypeLookup _typeLookup(Node node, ForeignResolver resolver) {
+    return (String name) => resolver.resolveTypeFromString(node, name);
+  }
+
+  /// Compute the [NativeBehavior] for a [Send] node calling the 'JS' function.
+  static NativeBehavior ofJsCallSend(Send jsCall, DiagnosticReporter reporter,
       ParsingContext parsing, CoreTypes coreTypes, ForeignResolver resolver) {
+    var argNodes = jsCall.arguments;
+    if (argNodes.isEmpty || argNodes.tail.isEmpty) {
+      reporter.reportErrorMessage(jsCall, MessageKind.WRONG_ARGUMENT_FOR_JS);
+      return new NativeBehavior();
+    }
+
+    var specArgument = argNodes.head;
+    if (specArgument is! StringNode || specArgument.isInterpolation) {
+      reporter.reportErrorMessage(
+          specArgument, MessageKind.WRONG_ARGUMENT_FOR_JS_FIRST);
+      return new NativeBehavior();
+    }
+
+    var codeArgument = argNodes.tail.head;
+    if (codeArgument is! StringNode || codeArgument.isInterpolation) {
+      reporter.reportErrorMessage(
+          codeArgument, MessageKind.WRONG_ARGUMENT_FOR_JS_SECOND);
+      return new NativeBehavior();
+    }
+
+    String specString = specArgument.dartString.slowToString();
+    String codeString = codeArgument.dartString.slowToString();
+
+    return ofJsCall(specString, codeString, _typeLookup(specArgument, resolver),
+        specArgument, reporter, coreTypes);
+  }
+
+  /// Compute the [NativeBehavior] for a call to the 'JS' function with the
+  /// given [specString] and [codeString] (first and second arguments).
+  static NativeBehavior ofJsCall(
+      String specString,
+      String codeString,
+      TypeLookup lookupType,
+      Spannable spannable,
+      DiagnosticReporter reporter,
+      CoreTypes coreTypes) {
     // 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) {
-      reporter.reportErrorMessage(jsCall, MessageKind.GENERIC,
-          {'text': "JS expression takes two or more arguments."});
-      return behavior;
-    }
-
-    var specArgument = argNodes.head;
-    if (specArgument is! StringNode || specArgument.isInterpolation) {
-      reporter.reportErrorMessage(specArgument, MessageKind.GENERIC,
-          {'text': "JS first argument must be a string literal."});
-      return behavior;
-    }
-
-    var codeArgument = argNodes.tail.head;
-    if (codeArgument is! StringNode || codeArgument.isInterpolation) {
-      reporter.reportErrorMessage(codeArgument, MessageKind.GENERIC,
-          {'text': "JS second argument must be a string literal."});
-      return behavior;
-    }
-
-    behavior.codeTemplateText = codeArgument.dartString.slowToString();
+    behavior.codeTemplateText = codeString;
     behavior.codeTemplate = js.js.parseForeignJS(behavior.codeTemplateText);
 
-    String specString = specArgument.dartString.slowToString();
-
-    dynamic resolveType(String typeString) {
-      return _parseType(
-          typeString,
-          parsing,
-          (name) => resolver.resolveTypeFromString(specArgument, name),
-          specArgument);
-    }
-
     bool sideEffectsAreEncodedInSpecString = false;
 
     void setSideEffects(SideEffects newEffects) {
       sideEffectsAreEncodedInSpecString = true;
       behavior.sideEffects.setTo(newEffects);
     }
 
     bool throwBehaviorFromSpecString = false;
     void setThrows(NativeThrowBehavior throwBehavior) {
       throwBehaviorFromSpecString = true;
       behavior.throwBehavior = throwBehavior;
     }
 
     void setIsAllocation(bool isAllocation) {
       behavior.isAllocation = isAllocation;
     }
 
     void setUseGvn(bool useGvn) {
       behavior.useGvn = useGvn;
     }
 
-    processSpecString(reporter, specArgument, specString,
+    processSpecString(reporter, spannable, specString,
         setSideEffects: setSideEffects,
         setThrows: setThrows,
         setIsAllocation: setIsAllocation,
         setUseGvn: setUseGvn,
-        resolveType: resolveType,
+        lookupType: lookupType,
         typesReturned: behavior.typesReturned,
         typesInstantiated: behavior.typesInstantiated,
         objectType: coreTypes.objectType,
         nullType: coreTypes.nullType);
 
     if (!sideEffectsAreEncodedInSpecString) {
       new SideEffectsVisitor(behavior.sideEffects)
           .visit(behavior.codeTemplate.ast);
     }
     if (!throwBehaviorFromSpecString) {
       behavior.throwBehavior =
           new ThrowBehaviorVisitor().analyze(behavior.codeTemplate.ast);
     }
 
     return behavior;
   }
 
   static void _fillNativeBehaviorOfBuiltinOrEmbeddedGlobal(
       NativeBehavior behavior,
-      Send jsBuiltinOrEmbeddedGlobalCall,
+      Spannable spannable,
+      String specString,
+      TypeLookup lookupType,
       DiagnosticReporter reporter,
-      ParsingContext parsing,
       CoreTypes coreTypes,
-      ForeignResolver resolver,
-      {bool isBuiltin,
-      List<String> validTags}) {
+      {List<String> validTags}) {
+    void setSideEffects(SideEffects newEffects) {
+      behavior.sideEffects.setTo(newEffects);
+    }
+
+    processSpecString(reporter, spannable, specString,
+        validTags: validTags,
+        lookupType: lookupType,
+        setSideEffects: setSideEffects,
+        typesReturned: behavior.typesReturned,
+        typesInstantiated: behavior.typesInstantiated,
+        objectType: coreTypes.objectType,
+        nullType: coreTypes.nullType);
+  }
+
+  static NativeBehavior ofJsBuiltinCallSend(
+      Send jsBuiltinCall,
+      DiagnosticReporter reporter,
+      CoreTypes coreTypes,
+      ForeignResolver resolver) {
+    NativeBehavior behavior = new NativeBehavior();
+    behavior.sideEffects.setTo(new SideEffects());
+
     // 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.
 
-    String builtinOrGlobal = isBuiltin ? "builtin" : "embedded global";
-
-    Link<Node> argNodes = jsBuiltinOrEmbeddedGlobalCall.arguments;
+    Link<Node> argNodes = jsBuiltinCall.arguments;
     if (argNodes.isEmpty) {
-      reporter.internalError(jsBuiltinOrEmbeddedGlobalCall,
-          "JS $builtinOrGlobal expression has no type.");
+      reporter.internalError(
+          jsBuiltinCall, "JS builtin expression has no type.");
     }
 
     // We don't check the given name. That needs to be done at a later point.
     // This is, because we want to allow non-literals (like references to
     // enums) as names.
     if (argNodes.tail.isEmpty) {
-      reporter.internalError(jsBuiltinOrEmbeddedGlobalCall,
-          'JS $builtinOrGlobal is missing name.');
-    }
-
-    if (!isBuiltin) {
-      if (!argNodes.tail.tail.isEmpty) {
-        reporter.internalError(argNodes.tail.tail.head,
-            'JS embedded global has more than 2 arguments');
-      }
+      reporter.internalError(jsBuiltinCall, "JS builtin is missing name.");
     }
 
     LiteralString specLiteral = argNodes.head.asLiteralString();
     if (specLiteral == null) {
       // 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.
       reporter.internalError(argNodes.head, "Unexpected first argument.");
     }
 
     String specString = specLiteral.dartString.slowToString();
 
-    dynamic resolveType(String typeString) {
-      return _parseType(
-          typeString,
-          parsing,
-          (name) => resolver.resolveTypeFromString(specLiteral, name),
-          jsBuiltinOrEmbeddedGlobalCall);
-    }
-
-    void setSideEffects(SideEffects newEffects) {
-      behavior.sideEffects.setTo(newEffects);
-    }
-
-    processSpecString(reporter, jsBuiltinOrEmbeddedGlobalCall, specString,
-        validTags: validTags,
-        resolveType: resolveType,
-        setSideEffects: setSideEffects,
-        typesReturned: behavior.typesReturned,
-        typesInstantiated: behavior.typesInstantiated,
-        objectType: coreTypes.objectType,
-        nullType: coreTypes.nullType);
+    return ofJsBuiltinCall(specString, _typeLookup(jsBuiltinCall, resolver),
+        jsBuiltinCall, reporter, coreTypes);
   }
 
   static NativeBehavior ofJsBuiltinCall(
-      Send jsBuiltinCall,
+      String specString,
+      TypeLookup lookupType,
+      Spannable spannable,
       DiagnosticReporter reporter,
-      ParsingContext parsing,
+      CoreTypes coreTypes) {
+    NativeBehavior behavior = new NativeBehavior();
+    behavior.sideEffects.setTo(new SideEffects());
+    _fillNativeBehaviorOfBuiltinOrEmbeddedGlobal(
+        behavior, spannable, specString, lookupType, reporter, coreTypes);
+    return behavior;
+  }
+
+  static NativeBehavior ofJsEmbeddedGlobalCallSend(
+      Send jsEmbeddedGlobalCall,
+      DiagnosticReporter reporter,
       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,
-      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;
 
+    // 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.
+
+    Link<Node> argNodes = jsEmbeddedGlobalCall.arguments;
+    if (argNodes.isEmpty) {
+      reporter.internalError(
+          jsEmbeddedGlobalCall, "JS embedded global expression has no type.");
+    }
+
+    // We don't check the given name. That needs to be done at a later point.
+    // This is, because we want to allow non-literals (like references to
+    // enums) as names.
+    if (argNodes.tail.isEmpty) {
+      reporter.internalError(
+          jsEmbeddedGlobalCall, "JS embedded global is missing name.");
+    }
+
+    if (!argNodes.tail.tail.isEmpty) {
+      reporter.internalError(argNodes.tail.tail.head,
+          'JS embedded global has more than 2 arguments');
+    }
+
+    LiteralString specLiteral = argNodes.head.asLiteralString();
+    if (specLiteral == null) {
+      // 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.
+      reporter.internalError(argNodes.head, "Unexpected first argument.");
+    }
+
+    String specString = specLiteral.dartString.slowToString();
+
+    return ofJsEmbeddedGlobalCall(
+        specString,
+        _typeLookup(jsEmbeddedGlobalCall, resolver),
+        jsEmbeddedGlobalCall,
+        reporter,
+        coreTypes);
+  }
+
+  static NativeBehavior ofJsEmbeddedGlobalCall(
+      String specString,
+      TypeLookup lookupType,
+      Spannable spannable,
+      DiagnosticReporter reporter,
+      CoreTypes coreTypes) {
+    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(
-        behavior, jsEmbeddedGlobalCall, reporter, parsing, coreTypes, resolver,
-        isBuiltin: false, validTags: const ['returns', 'creates']);
-
+        behavior, spannable, specString, lookupType, reporter, coreTypes,
+        validTags: ['returns', 'creates']);
     return behavior;
   }
 
-  static NativeBehavior ofMethod(FunctionElement method, Compiler compiler) {
-    FunctionType type = method.computeType(compiler.resolution);
+  static NativeBehavior ofMethodElement(
+      FunctionElement element, Compiler compiler) {
+    FunctionType type = element.computeType(compiler.resolution);
+    List<ConstantExpression> metadata = <ConstantExpression>[];
+    for (MetadataAnnotation annotation in element.implementation.metadata) {
+      annotation.ensureResolved(compiler.resolution);
+      metadata.add(annotation.constant);
+    }
+
+    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.resolution);
+      return cls.thisType;
+    }
+
+    return ofMethod(element, type, metadata, lookup, compiler,
+        isJsInterop: compiler.backend.isJsInterop(element));
+  }
+
+  static NativeBehavior ofMethod(
+      Spannable spannable,
+      FunctionType type,
+      List<ConstantExpression> metadata,
+      TypeLookup lookupType,
+      Compiler compiler,
+      {bool isJsInterop}) {
     var behavior = new NativeBehavior();
     var returnType = type.returnType;
-    bool isInterop = compiler.backend.isJsInterop(method);
     // Note: For dart:html and other internal libraries we maintain, we can
     // trust the return type and use it to limit what we enqueue. We have to
     // be more conservative about JS interop types and assume they can return
     // anything (unless the user provides the experimental flag to trust the
     // type of js-interop APIs). We do restrict the allocation effects and say
     // that interop calls create only interop types (which may be unsound if
     // an interop call returns a DOM type and declares a dynamic return type,
     // but otherwise we would include a lot of code by default).
     // TODO(sigmund,sra): consider doing something better for numeric types.
     behavior.typesReturned.add(
-        !isInterop || compiler.options.trustJSInteropTypeAnnotations
+        !isJsInterop || compiler.options.trustJSInteropTypeAnnotations
             ? returnType
             : const DynamicType());
     if (!type.returnType.isVoid) {
       // Declared types are nullable.
       behavior.typesReturned.add(compiler.coreTypes.nullType);
     }
     behavior._capture(type, compiler.resolution,
-        isInterop: isInterop, compiler: compiler);
+        isInterop: isJsInterop, compiler: compiler);
 
     for (DartType type in type.optionalParameterTypes) {
       behavior._escape(type, compiler.resolution);
     }
     for (DartType type in type.namedParameterTypes) {
       behavior._escape(type, compiler.resolution);
     }
 
-    behavior._overrideWithAnnotations(method, compiler);
+    behavior._overrideWithAnnotations(
+        spannable, metadata, lookupType, compiler);
     return behavior;
   }
 
-  static NativeBehavior ofFieldLoad(MemberElement field, Compiler compiler) {
+  static NativeBehavior ofFieldElementLoad(
+      MemberElement element, Compiler compiler) {
     Resolution resolution = compiler.resolution;
-    DartType type = field.computeType(resolution);
+    DartType type = element.computeType(resolution);
+    List<ConstantExpression> metadata = <ConstantExpression>[];
+    for (MetadataAnnotation annotation in element.implementation.metadata) {
+      annotation.ensureResolved(compiler.resolution);
+      metadata.add(annotation.constant);
+    }
+
+    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.resolution);
+      return cls.thisType;
+    }
+
+    return ofFieldLoad(element, type, metadata, lookup, compiler,
+        isJsInterop: compiler.backend.isJsInterop(element));
+  }
+
+  static NativeBehavior ofFieldLoad(
+      Spannable spannable,
+      DartType type,
+      List<ConstantExpression> metadata,
+      TypeLookup lookupType,
+      Compiler compiler,
+      {bool isJsInterop}) {
+    Resolution resolution = compiler.resolution;
     var behavior = new NativeBehavior();
-    bool isInterop = compiler.backend.isJsInterop(field);
     // TODO(sigmund,sra): consider doing something better for numeric types.
     behavior.typesReturned.add(
-        !isInterop || compiler.options.trustJSInteropTypeAnnotations
+        !isJsInterop || compiler.options.trustJSInteropTypeAnnotations
             ? type
             : const DynamicType());
     // Declared types are nullable.
     behavior.typesReturned.add(resolution.coreTypes.nullType);
     behavior._capture(type, resolution,
-        isInterop: isInterop, compiler: compiler);
-    behavior._overrideWithAnnotations(field, compiler);
+        isInterop: isJsInterop, compiler: compiler);
+    behavior._overrideWithAnnotations(
+        spannable, metadata, lookupType, compiler);
     return behavior;
   }
 
-  static NativeBehavior ofFieldStore(MemberElement field, Compiler compiler) {
-    Resolution resolution = compiler.resolution;
+  static NativeBehavior ofFieldElementStore(
+      MemberElement field, Resolution resolution) {
     DartType type = field.computeType(resolution);
+    return ofFieldStore(type, resolution);
+  }
+
+  static NativeBehavior ofFieldStore(DartType type, Resolution resolution) {
     var behavior = new NativeBehavior();
     behavior._escape(type, 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.resolution);
-      return cls.thisType;
-    }
+  void _overrideWithAnnotations(
+      Spannable spannable,
+      Iterable<ConstantExpression> metadata,
+      TypeLookup lookupType,
+      Compiler compiler) {
+    if (metadata.isEmpty) return;
 
     NativeEnqueuer enqueuer = compiler.enqueuer.resolution.nativeEnqueuer;
-    var creates =
-        _collect(element, compiler, enqueuer.annotationCreatesClass, lookup);
-    var returns =
-        _collect(element, compiler, enqueuer.annotationReturnsClass, lookup);
+    var creates = _collect(spannable, metadata, compiler,
+        enqueuer.annotationCreatesClass, lookupType);
+    var returns = _collect(spannable, metadata, compiler,
+        enqueuer.annotationReturnsClass, lookupType);
 
     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)) {
+  static _collect(Spannable spannable, Iterable<ConstantExpression> metadata,
+      Compiler compiler, Element annotationClass, TypeLookup lookupType) {
     DiagnosticReporter reporter = compiler.reporter;
     var types = null;
-    for (MetadataAnnotation annotation in element.implementation.metadata) {
-      annotation.ensureResolved(compiler.resolution);
-      ConstantValue value =
-          compiler.constants.getConstantValue(annotation.constant);
+    for (ConstantExpression constant in metadata) {
+      ConstantValue value = compiler.constants.getConstantValue(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) {
-        reporter.internalError(
-            annotation, 'Annotations needs one string: ${annotation.node}');
+        reporter.internalError(spannable,
+            'Annotations needs one string: ${constant.toStructuredText()}');
       }
       StringConstantValue specStringConstant = fields.single;
       String specString = specStringConstant.toDartString().slowToString();
       for (final typeString in specString.split('|')) {
-        var type =
-            _parseType(typeString, compiler.parsingContext, lookup, annotation);
+        var type = _parseType(typeString, spannable, reporter, lookupType);
         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, ParsingContext parsing,
-      lookup(name), locationNodeOrElement) {
-    DiagnosticReporter reporter = parsing.reporter;
+  static dynamic /*DartType|SpecialType*/ _parseType(String typeString,
+      Spannable spannable, DiagnosticReporter reporter, TypeLookup lookupType) {
     if (typeString == '=Object') return SpecialType.JsObject;
     if (typeString == 'dynamic') {
       return const DynamicType();
     }
-    var type = lookup(typeString);
+    var type = lookupType(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."});
+      reporter.reportErrorMessage(spannable, MessageKind.GENERIC,
+          {'text': "Type '$typeString' not found."});
       return const DynamicType();
     }
-    type = lookup(typeString.substring(0, index));
+    type = lookupType(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."});
+    reporter.reportErrorMessage(spannable, MessageKind.GENERIC,
+        {'text': "Type '$typeString' not found."});
     return const DynamicType();
   }
-
-  static _errorNode(locationNodeOrElement, ParsingContext parsing) {
-    if (locationNodeOrElement is Node) return locationNodeOrElement;
-    return locationNodeOrElement.parseNode(parsing);
-  }
 }