Prefix resolution_types with Resolution.

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';
@@ skipping 112 matching lines @@
  * If there is one or more `@Returns` annotations, the union of the named types
  * replaces the declared return type.
  *
  *     @Returns('IDBRequest')
  *     IDBRequest openCursor();
  *
  * Types in annotations are non-nullable, so include `@Returns('Null')` if
  * `null` may be returned.
  */
 class NativeBehavior {
-  /// [DartType]s or [SpecialType]s returned or yielded by the native element.
+  /// [ResolutionDartType]s or [SpecialType]s returned or yielded by the native
+  /// element.
   final List typesReturned = [];
 
-  /// [DartType]s or [SpecialType]s instantiated by the native element.
+  /// [ResolutionDartType]s or [SpecialType]s instantiated by the native
+  /// element.
   final List typesInstantiated = [];
 
   String codeTemplateText;
   // If this behavior is for a JS expression, [codeTemplate] contains the
   // parsed tree.
   js.Template codeTemplate;
 
   final SideEffects sideEffects;
 
   NativeThrowBehavior throwBehavior = NativeThrowBehavior.MAY;
@@ skipping 590 matching lines @@
     behavior.sideEffects.setTo(new SideEffects.empty());
     behavior.throwBehavior = NativeThrowBehavior.NEVER;
     _fillNativeBehaviorOfBuiltinOrEmbeddedGlobal(
         behavior, spannable, specString, lookupType, reporter, commonElements,
         validTags: ['returns', 'creates']);
     return behavior;
   }
 
   static NativeBehavior ofMethodElement(
       FunctionElement element, Compiler compiler) {
-    FunctionType type = element.computeType(compiler.resolution);
+    ResolutionFunctionType 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) {
+    ResolutionDartType 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,
+      ResolutionFunctionType type,
       List<ConstantExpression> metadata,
       TypeLookup lookupType,
       Compiler compiler,
       {bool isJsInterop}) {
     var behavior = new NativeBehavior();
     var returnType = type.returnType;
     // 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(
         !isJsInterop || compiler.options.trustJSInteropTypeAnnotations
             ? returnType
-            : const DynamicType());
+            : const ResolutionDynamicType());
     if (!type.returnType.isVoid) {
       // Declared types are nullable.
       behavior.typesReturned.add(compiler.commonElements.nullType);
     }
     behavior._capture(type, compiler.resolution,
         isInterop: isJsInterop, compiler: compiler);
 
-    for (DartType type in type.optionalParameterTypes) {
+    for (ResolutionDartType type in type.optionalParameterTypes) {
       behavior._escape(type, compiler.resolution);
     }
-    for (DartType type in type.namedParameterTypes) {
+    for (ResolutionDartType type in type.namedParameterTypes) {
       behavior._escape(type, compiler.resolution);
     }
 
     behavior._overrideWithAnnotations(
         spannable, metadata, lookupType, compiler);
     return behavior;
   }
 
   static NativeBehavior ofFieldElementLoad(
       MemberElement element, Compiler compiler) {
     Resolution resolution = compiler.resolution;
-    DartType type = element.computeType(resolution);
+    ResolutionDartType 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) {
+    ResolutionDartType 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,
+      ResolutionDartType type,
       List<ConstantExpression> metadata,
       TypeLookup lookupType,
       Compiler compiler,
       {bool isJsInterop}) {
     Resolution resolution = compiler.resolution;
     var behavior = new NativeBehavior();
     // TODO(sigmund,sra): consider doing something better for numeric types.
     behavior.typesReturned.add(
         !isJsInterop || compiler.options.trustJSInteropTypeAnnotations
             ? type
-            : const DynamicType());
+            : const ResolutionDynamicType());
     // Declared types are nullable.
     behavior.typesReturned.add(resolution.commonElements.nullType);
     behavior._capture(type, resolution,
         isInterop: isJsInterop, compiler: compiler);
     behavior._overrideWithAnnotations(
         spannable, metadata, lookupType, compiler);
     return behavior;
   }
 
   static NativeBehavior ofFieldElementStore(
       MemberElement field, Resolution resolution) {
-    DartType type = field.computeType(resolution);
+    ResolutionDartType type = field.computeType(resolution);
     return ofFieldStore(type, resolution);
   }
 
-  static NativeBehavior ofFieldStore(DartType type, Resolution resolution) {
+  static NativeBehavior ofFieldStore(
+      ResolutionDartType 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(
       Spannable spannable,
       Iterable<ConstantExpression> metadata,
@@ skipping 46 matching lines @@
         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) {
+  void _escape(ResolutionDartType type, Resolution resolution) {
     type.computeUnaliased(resolution);
     type = type.unaliased;
-    if (type is FunctionType) {
-      FunctionType functionType = type;
+    if (type is ResolutionFunctionType) {
+      ResolutionFunctionType functionType = type;
       // A function might be called from native code, passing us novel
       // parameters.
       _escape(functionType.returnType, resolution);
-      for (DartType parameter in functionType.parameterTypes) {
+      for (ResolutionDartType parameter in functionType.parameterTypes) {
         _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.
   ///
   /// We assume that JS-interop APIs cannot instantiate Dart types or
   /// non-JSInterop native types.
-  void _capture(DartType type, Resolution resolution,
+  void _capture(ResolutionDartType type, Resolution resolution,
       {bool isInterop: false, Compiler compiler}) {
     type.computeUnaliased(resolution);
     type = type.unaliased;
-    if (type is FunctionType) {
-      FunctionType functionType = type;
+    if (type is ResolutionFunctionType) {
+      ResolutionFunctionType functionType = type;
       _capture(functionType.returnType, resolution,
           isInterop: isInterop, compiler: compiler);
-      for (DartType parameter in functionType.parameterTypes) {
+      for (ResolutionDartType parameter in functionType.parameterTypes) {
         _escape(parameter, resolution);
       }
     } else {
       JavaScriptBackend backend = compiler?.backend;
       if (!isInterop) {
         typesInstantiated.add(type);
       } else {
         if (type.element != null && backend.isNative(type.element)) {
           // Any declared native or interop type (isNative implies isJsInterop)
           // is assumed to be allocated.
@@ skipping 19 matching lines @@
           // API.
         }
       }
     }
   }
 
   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();
+      return const ResolutionDynamicType();
     }
     var type = lookupType(typeString);
     if (type != null) return type;
 
     int index = typeString.indexOf('<');
     if (index < 1) {
       reporter.reportErrorMessage(spannable, MessageKind.GENERIC,
           {'text': "Type '$typeString' not found."});
-      return const DynamicType();
+      return const ResolutionDynamicType();
     }
     type = lookupType(typeString.substring(0, index));
     if (type != null) {
       // TODO(sra): Parse type parameters.
       return type;
     }
     reporter.reportErrorMessage(spannable, MessageKind.GENERIC,
         {'text': "Type '$typeString' not found."});
-    return const DynamicType();
+    return const ResolutionDynamicType();
   }
 }