Prefix resolution_types with Resolution.

pkg/compiler/lib/src/ssa/locals_handler.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 '../closure.dart';
 import '../common.dart';
 import '../compiler.dart' show Compiler;
 import '../elements/resolution_types.dart';
 import '../elements/elements.dart';
 import '../io/source_information.dart';
@@ skipping 17 matching lines @@
   ///
   /// [directLocals] is iterated, so it is "insertion ordered" to make the
   /// iteration order a function only of insertions and not a function of
   /// e.g. Element hash codes.  I'd prefer to use a SortedMap but some elements
   /// don't have source locations for [Elements.compareByPosition].
   Map<Local, HInstruction> directLocals = new Map<Local, HInstruction>();
   Map<Local, CapturedVariable> redirectionMapping =
       new Map<Local, CapturedVariable>();
   final GraphBuilder builder;
   ClosureClassMap closureData;
-  Map<TypeVariableType, TypeVariableLocal> typeVariableLocals =
-      new Map<TypeVariableType, TypeVariableLocal>();
+  Map<ResolutionTypeVariableType, TypeVariableLocal> typeVariableLocals =
+      new Map<ResolutionTypeVariableType, TypeVariableLocal>();
   final ExecutableElement executableContext;
 
   /// The class that defines the current type environment or null if no type
   /// variables are in scope.
   ClassElement get contextClass => executableContext.contextClass;
 
   /// The type of the current instance, if concrete.
   ///
   /// This allows for handling fixed type argument in case of inlining. For
   /// instance, checking `'foo'` against `String` instead of `T` in `main`:
   ///
   ///     class Foo<T> {
   ///       T field;
   ///       Foo(this.field);
   ///     }
   ///     main() {
   ///       new Foo<String>('foo');
   ///     }
   ///
   /// [instanceType] is not used if it contains type variables, since these
   /// might not be in scope or from the current instance.
   ///
-  final InterfaceType instanceType;
+  final ResolutionInterfaceType instanceType;
 
   final Compiler _compiler;
 
   LocalsHandler(this.builder, this.executableContext,
-      InterfaceType instanceType, this._compiler)
+      ResolutionInterfaceType instanceType, this._compiler)
       : this.instanceType =
             instanceType == null || instanceType.containsTypeVariables
                 ? null
                 : instanceType;
 
   ClosedWorld get closedWorld => builder.closedWorld;
 
   CommonMasks get commonMasks => closedWorld.commonMasks;
 
   GlobalTypeInferenceResults get _globalInferenceResults =>
       _compiler.globalInference.results;
 
   /// Substituted type variables occurring in [type] into the context of
   /// [contextClass].
-  DartType substInContext(DartType type) {
+  ResolutionDartType substInContext(ResolutionDartType type) {
     if (contextClass != null) {
       ClassElement typeContext = Types.getClassContext(type);
       if (typeContext != null) {
         type = type.substByContext(contextClass.asInstanceOf(typeContext));
       }
     }
     if (instanceType != null) {
       type = type.substByContext(instanceType);
     }
     return type;
@@ skipping 285 matching lines @@
     }
 
     return activationVariables.putIfAbsent(local, () {
       HLocalValue localValue = new HLocalValue(local, commonMasks.nonNullType)
         ..sourceInformation = sourceInformation;
       builder.graph.entry.addAtExit(localValue);
       return localValue;
     });
   }
 
-  Local getTypeVariableAsLocal(TypeVariableType type) {
+  Local getTypeVariableAsLocal(ResolutionTypeVariableType type) {
     return typeVariableLocals.putIfAbsent(type, () {
       return new TypeVariableLocal(type, executableContext);
     });
   }
 
   /// Sets the [element] to [value]. If the element is boxed or stored in a
   /// closure then the method generates code to set the value.
   void updateLocal(Local local, HInstruction value,
       {SourceInformation sourceInformation}) {
     if (value is HRef) {
@@ skipping 263 matching lines @@
   final ExecutableElement executableContext;
 
   // Avoid slow Object.hashCode.
   final int hashCode = _nextHashCode = (_nextHashCode + 1).toUnsigned(30);
   static int _nextHashCode = 0;
 
   SyntheticLocal(this.name, this.executableContext);
 
   toString() => 'SyntheticLocal($name)';
 }