Prefix resolution_types with Resolution.

pkg/compiler/lib/src/js_backend/constant_system_javascript.dart

 // Copyright (c) 2012, 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.
 
 library dart2js.constant_system.js;
 
 import '../compiler.dart' show Compiler;
 import '../constant_system_dart.dart';
 import '../constants/constant_system.dart';
 import '../constants/values.dart';
@@ skipping 280 matching lines @@
   NumConstantValue createDouble(double d) =>
       convertToJavaScriptConstant(new DoubleConstantValue(d));
   StringConstantValue createString(DartString string) {
     return new StringConstantValue(string);
   }
 
   BoolConstantValue createBool(bool value) => new BoolConstantValue(value);
   NullConstantValue createNull() => new NullConstantValue();
 
   @override
-  ListConstantValue createList(InterfaceType type, List<ConstantValue> values) {
+  ListConstantValue createList(
+      ResolutionInterfaceType type, List<ConstantValue> values) {
     return new ListConstantValue(type, values);
   }
 
   @override
-  ConstantValue createType(Compiler compiler, DartType type) {
+  ConstantValue createType(Compiler compiler, ResolutionDartType type) {
     return new TypeConstantValue(
         type,
         compiler.backend.backendClasses.typeImplementation
             .computeType(compiler.resolution));
   }
 
   // Integer checks report true for -0.0, INFINITY, and -INFINITY.  At
   // runtime an 'X is int' check is implemented as:
   //
   // typeof(X) === "number" && Math.floor(X) === X
   //
   // We consistently match that runtime semantics at compile time as well.
   bool isInt(ConstantValue constant) {
     return constant.isInt ||
         constant.isMinusZero ||
         constant.isPositiveInfinity ||
         constant.isNegativeInfinity;
   }
 
   bool isDouble(ConstantValue constant) =>
       constant.isDouble && !constant.isMinusZero;
   bool isString(ConstantValue constant) => constant.isString;
   bool isBool(ConstantValue constant) => constant.isBool;
   bool isNull(ConstantValue constant) => constant.isNull;
 
-  bool isSubtype(DartTypes types, DartType s, DartType t) {
+  bool isSubtype(DartTypes types, ResolutionDartType s, ResolutionDartType t) {
     // At runtime, an integer is both an integer and a double: the
     // integer type check is Math.floor, which will return true only
     // for real integers, and our double type check is 'typeof number'
     // which will return true for both integers and doubles.
     if (s == types.commonElements.intType &&
         t == types.commonElements.doubleType) {
       return true;
     }
     return types.isSubtype(s, t);
   }
 
-  MapConstantValue createMap(Compiler compiler, InterfaceType sourceType,
-      List<ConstantValue> keys, List<ConstantValue> values) {
+  MapConstantValue createMap(
+      Compiler compiler,
+      ResolutionInterfaceType sourceType,
+      List<ConstantValue> keys,
+      List<ConstantValue> values) {
     JavaScriptBackend backend = compiler.backend;
     CommonElements commonElements = compiler.commonElements;
 
     bool onlyStringKeys = true;
     ConstantValue protoValue = null;
     for (int i = 0; i < keys.length; i++) {
       var key = keys[i];
       if (key.isString) {
         if (key.primitiveValue == JavaScriptMapConstant.PROTO_PROPERTY) {
           protoValue = values[i];
         }
       } else {
         onlyStringKeys = false;
         // Don't handle __proto__ values specially in the general map case.
         protoValue = null;
         break;
       }
     }
 
     bool hasProtoKey = (protoValue != null);
-    DartType keysType;
+    ResolutionDartType keysType;
     if (sourceType.treatAsRaw) {
       keysType = commonElements.listType();
     } else {
       keysType = commonElements.listType(sourceType.typeArguments.first);
     }
     ListConstantValue keysList = new ListConstantValue(keysType, keys);
     ClassElement classElement = onlyStringKeys
         ? (hasProtoKey
             ? backend.helpers.constantProtoMapClass
             : backend.helpers.constantStringMapClass)
         : backend.helpers.generalConstantMapClass;
     classElement.ensureResolved(compiler.resolution);
-    List<DartType> typeArgument = sourceType.typeArguments;
-    InterfaceType type;
+    List<ResolutionDartType> typeArgument = sourceType.typeArguments;
+    ResolutionInterfaceType type;
     if (sourceType.treatAsRaw) {
       type = classElement.rawType;
     } else {
-      type = new InterfaceType(classElement, typeArgument);
+      type = new ResolutionInterfaceType(classElement, typeArgument);
     }
     return new JavaScriptMapConstant(
         type, keysList, values, protoValue, onlyStringKeys);
   }
 
   @override
   ConstantValue createSymbol(Compiler compiler, String text) {
     // TODO(johnniwinther): Create a backend agnostic value.
     JavaScriptBackend backend = compiler.backend;
     ClassElement symbolClass = backend.helpers.symbolImplementationClass;
-    InterfaceType type = symbolClass.rawType;
+    ResolutionInterfaceType type = symbolClass.rawType;
     ConstantValue argument = createString(new DartString.literal(text));
     Map<FieldElement, ConstantValue> fields = <FieldElement, ConstantValue>{};
     symbolClass.forEachInstanceField(
         (ClassElement enclosingClass, FieldElement field) {
       fields[field] = argument;
     }, includeSuperAndInjectedMembers: true);
     assert(fields.length == 1);
     return new ConstructedConstantValue(type, fields);
   }
 }
@@ skipping 14 matching lines @@
   static const String LENGTH_NAME = "_length";
   static const String JS_OBJECT_NAME = "_jsObject";
   static const String KEYS_NAME = "_keys";
   static const String PROTO_VALUE = "_protoValue";
   static const String JS_DATA_NAME = "_jsData";
 
   final ListConstantValue keyList;
   final ConstantValue protoValue;
   final bool onlyStringKeys;
 
-  JavaScriptMapConstant(InterfaceType type, ListConstantValue keyList,
+  JavaScriptMapConstant(ResolutionInterfaceType type, ListConstantValue keyList,
       List<ConstantValue> values, this.protoValue, this.onlyStringKeys)
       : this.keyList = keyList,
         super(type, keyList.entries, values);
   bool get isMap => true;
 
   List<ConstantValue> getDependencies() {
     List<ConstantValue> result = <ConstantValue>[];
     if (onlyStringKeys) {
       result.add(keyList);
     } else {
       // Add the keys individually to avoid generating an unused list constant
       // for the keys.
       result.addAll(keys);
     }
     result.addAll(values);
     return result;
   }
 }