Prefix resolution_types with Resolution.

pkg/compiler/lib/src/ssa/kernel_ast_adapter.dart

 // Copyright (c) 2016, 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 'package:js_runtime/shared/embedded_names.dart';
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/names.dart';
 import '../compiler.dart';
@@ skipping 302 matching lines @@
     //     ConstantExpression constantExpression =
     //         defaultExpression.accept(new Constantifier(this));
     //     assert(constantExpression != null);
     ConstantExpression constantExpression =
         kernel.parameterInitializerNodeToConstant[defaultExpression];
     if (constantExpression == null) return null;
     return _backend.constants.getConstantValue(constantExpression);
   }
 
   ConstantValue getConstantForType(ir.DartType irType) {
-    DartType type = getDartType(irType);
+    ResolutionDartType type = getDartType(irType);
     return _backend.constantSystem.createType(_compiler, type.asRaw());
   }
 
   bool isIntercepted(ir.Node node) {
     Selector selector = getSelector(node);
     return _backend.isInterceptedSelector(selector);
   }
 
   bool isInterceptedSelector(Selector selector) {
     return _backend.isInterceptedSelector(selector);
@@ skipping 143 matching lines @@
         assert(constant.fields.length == 1);
         ConstantValue indexConstant = constant.fields.values.single;
         if (indexConstant is IntConstantValue) {
           return indexConstant.primitiveValue;
         }
       }
     }
     return null;
   }
 
-  DartType getDartType(ir.DartType type) {
+  ResolutionDartType getDartType(ir.DartType type) {
     return type.accept(_typeConverter);
   }
 
-  List<DartType> getDartTypes(List<ir.DartType> types) {
+  List<ResolutionDartType> getDartTypes(List<ir.DartType> types) {
     return types.map(getDartType).toList();
   }
 
-  DartType getDartTypeOfListLiteral(ir.ListLiteral list) {
+  ResolutionDartType getDartTypeOfListLiteral(ir.ListLiteral list) {
     ast.Node node = getNodeOrNull(list);
     if (node != null) return elements.getType(node);
     assertNodeIsSynthetic(list);
     return _compiler.commonElements.listType(getDartType(list.typeArgument));
   }
 
-  DartType getDartTypeOfMapLiteral(ir.MapLiteral literal) {
+  ResolutionDartType getDartTypeOfMapLiteral(ir.MapLiteral literal) {
     ast.Node node = getNodeOrNull(literal);
     if (node != null) return elements.getType(node);
     assertNodeIsSynthetic(literal);
     return _compiler.commonElements
         .mapType(getDartType(literal.keyType), getDartType(literal.valueType));
   }
 
-  DartType getFunctionReturnType(ir.FunctionNode node) {
+  ResolutionDartType getFunctionReturnType(ir.FunctionNode node) {
     return getDartType(node.returnType);
   }
 
   /// Computes the function type corresponding the signature of [node].
-  FunctionType getFunctionType(ir.FunctionNode node) {
-    DartType returnType = getFunctionReturnType(node);
-    List<DartType> parameterTypes = <DartType>[];
-    List<DartType> optionalParameterTypes = <DartType>[];
+  ResolutionFunctionType getFunctionType(ir.FunctionNode node) {
+    ResolutionDartType returnType = getFunctionReturnType(node);
+    List<ResolutionDartType> parameterTypes = <ResolutionDartType>[];
+    List<ResolutionDartType> optionalParameterTypes = <ResolutionDartType>[];
     for (ir.VariableDeclaration variable in node.positionalParameters) {
       if (parameterTypes.length == node.requiredParameterCount) {
         optionalParameterTypes.add(getDartType(variable.type));
       } else {
         parameterTypes.add(getDartType(variable.type));
       }
     }
     List<String> namedParameters = <String>[];
-    List<DartType> namedParameterTypes = <DartType>[];
+    List<ResolutionDartType> namedParameterTypes = <ResolutionDartType>[];
     List<ir.VariableDeclaration> sortedNamedParameters =
         node.namedParameters.toList()..sort((a, b) => a.name.compareTo(b.name));
     for (ir.VariableDeclaration variable in sortedNamedParameters) {
       namedParameters.add(variable.name);
       namedParameterTypes.add(getDartType(variable.type));
     }
-    return new FunctionType.synthesized(returnType, parameterTypes,
+    return new ResolutionFunctionType.synthesized(returnType, parameterTypes,
         optionalParameterTypes, namedParameters, namedParameterTypes);
   }
 
   /// Converts [annotations] into a list of [ConstantExpression]s.
   List<ConstantExpression> getMetadata(List<ir.Expression> annotations) {
     List<ConstantExpression> metadata = <ConstantExpression>[];
     annotations.forEach((ir.Expression node) {
       ConstantExpression constant = node.accept(new Constantifier(this));
       if (constant == null) {
         throw new UnsupportedError(
@@ skipping 20 matching lines @@
     }
     return ForeignKind.NONE;
   }
 
   /// Return `true` if [node] is the `dart:_foreign_helper` library.
   bool isForeignLibrary(ir.Library node) {
     return node.importUri == BackendHelpers.DART_FOREIGN_HELPER;
   }
 
   /// Looks up [typeName] for use in the spec-string of a `JS` called.
-  // TODO(johnniwinther): Use this in [native.NativeBehavior] instead of calling the
-  // `ForeignResolver`.
+  // TODO(johnniwinther): Use this in [native.NativeBehavior] instead of calling
+  // the `ForeignResolver`.
   // TODO(johnniwinther): Cache the result to avoid redundant lookups?
   native.TypeLookup _typeLookup({bool resolveAsRaw: true}) {
     return (String typeName) {
-      DartType findIn(Uri uri) {
+      ResolutionDartType findIn(Uri uri) {
         LibraryElement library = _compiler.libraryLoader.lookupLibrary(uri);
         if (library != null) {
           Element element = library.find(typeName);
           if (element != null && element.isClass) {
             ClassElement cls = element;
             // TODO(johnniwinther): Align semantics.
             return resolveAsRaw ? cls.rawType : cls.thisType;
           }
         }
         return null;
       }
 
-      DartType type = findIn(Uris.dart_core);
+      ResolutionDartType type = findIn(Uris.dart_core);
       type ??= findIn(BackendHelpers.DART_JS_HELPER);
       type ??= findIn(BackendHelpers.DART_INTERCEPTORS);
       type ??= findIn(BackendHelpers.DART_ISOLATE_HELPER);
       type ??= findIn(Uris.dart_collection);
       type ??= findIn(Uris.dart_html);
       type ??= findIn(Uris.dart_svg);
       type ??= findIn(Uris.dart_web_audio);
       type ??= findIn(Uris.dart_web_gl);
       return type;
     };
@@ skipping 28 matching lines @@
 
     return native.NativeBehavior.ofJsCall(
         specString,
         codeString,
         _typeLookup(resolveAsRaw: true),
         CURRENT_ELEMENT_SPANNABLE,
         reporter,
         _compiler.commonElements);
   }
 
-  /// Computes the [native.NativeBehavior] for a call to the [JS_BUILTIN] function.
+  /// Computes the [native.NativeBehavior] for a call to the [JS_BUILTIN]
+  /// function.
   // TODO(johnniwinther): Cache this for later use.
   native.NativeBehavior getNativeBehaviorForJsBuiltinCall(
       ir.StaticInvocation node) {
     if (node.arguments.positional.length < 1) {
       reporter.internalError(
           CURRENT_ELEMENT_SPANNABLE, "JS builtin expression has no type.");
       return new native.NativeBehavior();
     }
     if (node.arguments.positional.length < 2) {
       reporter.internalError(
           CURRENT_ELEMENT_SPANNABLE, "JS builtin is missing name.");
       return new native.NativeBehavior();
     }
     String specString = _getStringArgument(node, 0);
     if (specString == null) {
       reporter.internalError(
           CURRENT_ELEMENT_SPANNABLE, "Unexpected first argument.");
       return new native.NativeBehavior();
     }
     return native.NativeBehavior.ofJsBuiltinCall(
         specString,
         _typeLookup(resolveAsRaw: true),
         CURRENT_ELEMENT_SPANNABLE,
         reporter,
         _compiler.commonElements);
   }
 
-  /// Computes the [native.NativeBehavior] for a call to the [JS_EMBEDDED_GLOBAL]
-  /// function.
+  /// Computes the [native.NativeBehavior] for a call to the
+  /// [JS_EMBEDDED_GLOBAL] function.
   // TODO(johnniwinther): Cache this for later use.
   native.NativeBehavior getNativeBehaviorForJsEmbeddedGlobalCall(
       ir.StaticInvocation node) {
     if (node.arguments.positional.length < 1) {
       reporter.internalError(CURRENT_ELEMENT_SPANNABLE,
           "JS embedded global expression has no type.");
       return new native.NativeBehavior();
     }
     if (node.arguments.positional.length < 2) {
       reporter.internalError(
@@ skipping 31 matching lines @@
           return true;
         }
       }
     }
     return false;
   }
 
   /// Computes the native behavior for reading the native [field].
   // TODO(johnniwinther): Cache this for later use.
   native.NativeBehavior getNativeBehaviorForFieldLoad(ir.Field field) {
-    DartType type = getDartType(field.type);
+    ResolutionDartType type = getDartType(field.type);
     List<ConstantExpression> metadata = getMetadata(field.annotations);
     return native.NativeBehavior.ofFieldLoad(CURRENT_ELEMENT_SPANNABLE, type,
         metadata, _typeLookup(resolveAsRaw: false), _compiler,
         isJsInterop: false);
   }
 
   /// Computes the native behavior for writing to the native [field].
   // TODO(johnniwinther): Cache this for later use.
   native.NativeBehavior getNativeBehaviorForFieldStore(ir.Field field) {
-    DartType type = getDartType(field.type);
+    ResolutionDartType type = getDartType(field.type);
     return native.NativeBehavior.ofFieldStore(type, _compiler.resolution);
   }
 
   /// Computes the native behavior for calling [procedure].
   // TODO(johnniwinther): Cache this for later use.
   native.NativeBehavior getNativeBehaviorForMethod(ir.Procedure procedure) {
-    DartType type = getFunctionType(procedure.function);
+    ResolutionDartType type = getFunctionType(procedure.function);
     List<ConstantExpression> metadata = getMetadata(procedure.annotations);
     return native.NativeBehavior.ofMethod(CURRENT_ELEMENT_SPANNABLE, type,
         metadata, _typeLookup(resolveAsRaw: false), _compiler,
         isJsInterop: false);
   }
 }
 
 /// Kinds of foreign functions.
 enum ForeignKind {
   JS,
   JS_BUILTIN,
   JS_EMBEDDED_GLOBAL,
   JS_INTERCEPTOR_CONSTANT,
   NONE,
 }
 
-/// Visitor that converts kernel dart types into [DartType].
-class DartTypeConverter extends ir.DartTypeVisitor<DartType> {
+/// Visitor that converts kernel dart types into [ResolutionDartType].
+class DartTypeConverter extends ir.DartTypeVisitor<ResolutionDartType> {
   final KernelAstAdapter astAdapter;
 
   DartTypeConverter(this.astAdapter);
 
-  DartType visitType(ir.DartType type) => type.accept(this);
+  ResolutionDartType visitType(ir.DartType type) => type.accept(this);
 
-  List<DartType> visitTypes(List<ir.DartType> types) {
+  List<ResolutionDartType> visitTypes(List<ir.DartType> types) {
     return new List.generate(
         types.length, (int index) => types[index].accept(this));
   }
 
   @override
-  DartType visitTypeParameterType(ir.TypeParameterType node) {
+  ResolutionDartType visitTypeParameterType(ir.TypeParameterType node) {
     if (node.parameter.parent is ir.Class) {
       ir.Class cls = node.parameter.parent;
       int index = cls.typeParameters.indexOf(node.parameter);
       ClassElement classElement = astAdapter.getElement(cls);
       return classElement.typeVariables[index];
     } else if (node.parameter.parent is ir.FunctionNode) {
       ir.FunctionNode func = node.parameter.parent;
       int index = func.typeParameters.indexOf(node.parameter);
       Element element = astAdapter.getElement(func);
       if (element.isConstructor) {
         ClassElement classElement = element.enclosingClass;
         return classElement.typeVariables[index];
       } else {
         GenericElement genericElement = element;
         return genericElement.typeVariables[index];
       }
     }
     throw new UnsupportedError('Unsupported type parameter type node $node.');
   }
 
   @override
-  DartType visitFunctionType(ir.FunctionType node) {
-    return new FunctionType.synthesized(
+  ResolutionDartType visitFunctionType(ir.FunctionType node) {
+    return new ResolutionFunctionType.synthesized(
         visitType(node.returnType),
         visitTypes(node.positionalParameters
             .take(node.requiredParameterCount)
             .toList()),
         visitTypes(node.positionalParameters
             .skip(node.requiredParameterCount)
             .toList()),
         node.namedParameters.map((n) => n.name).toList(),
         node.namedParameters.map((n) => visitType(n.type)).toList());
   }
 
   @override
-  DartType visitInterfaceType(ir.InterfaceType node) {
+  ResolutionDartType visitInterfaceType(ir.InterfaceType node) {
     ClassElement cls = astAdapter.getElement(node.classNode);
-    return new InterfaceType(cls, visitTypes(node.typeArguments));
+    return new ResolutionInterfaceType(cls, visitTypes(node.typeArguments));
   }
 
   @override
-  DartType visitVoidType(ir.VoidType node) {
-    return const VoidType();
+  ResolutionDartType visitVoidType(ir.VoidType node) {
+    return const ResolutionVoidType();
   }
 
   @override
-  DartType visitDynamicType(ir.DynamicType node) {
-    return const DynamicType();
+  ResolutionDartType visitDynamicType(ir.DynamicType node) {
+    return const ResolutionDynamicType();
   }
 
   @override
-  DartType visitInvalidType(ir.InvalidType node) {
+  ResolutionDartType visitInvalidType(ir.InvalidType node) {
     throw new UnimplementedError("Invalid types not currently supported");
   }
 }
 
 /// Visitor that converts string literals and concatenations of string literals
 /// into the string value.
 class Stringifier extends ir.ExpressionVisitor<String> {
   @override
   String visitStringLiteral(ir.StringLiteral node) => node.value;
 
@@ skipping 13 matching lines @@
 /// [ConstantExpression].
 class Constantifier extends ir.ExpressionVisitor<ConstantExpression> {
   final KernelAstAdapter astAdapter;
 
   Constantifier(this.astAdapter);
 
   @override
   ConstantExpression visitConstructorInvocation(ir.ConstructorInvocation node) {
     ConstructorElement constructor =
         astAdapter.getElement(node.target).declaration;
-    List<DartType> typeArguments = <DartType>[];
+    List<ResolutionDartType> typeArguments = <ResolutionDartType>[];
     for (ir.DartType type in node.arguments.types) {
       typeArguments.add(astAdapter.getDartType(type));
     }
     List<ConstantExpression> arguments = <ConstantExpression>[];
     List<String> argumentNames = <String>[];
     for (ir.Expression argument in node.arguments.positional) {
       ConstantExpression constant = argument.accept(this);
       if (constant == null) return null;
       arguments.add(constant);
     }
@@ skipping 73 matching lines @@
 
   @override
   String get name => null;
 
   @override
   int get nestingLevel => 1;
 
   @override
   ast.Node get statement => null;
 }