Support locals in compile_from_dill_test.

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 '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../elements/types.dart';
 import '../io/source_information.dart';
@@ skipping 23 matching lines @@
       new Map<Local, CapturedVariable>();
   final GraphBuilder builder;
   ClosureClassMap closureData;
   Map<TypeVariableType, TypeVariableLocal> typeVariableLocals =
       new Map<TypeVariableType, TypeVariableLocal>();
   final Entity executableContext;
   final MemberEntity memberContext;
 
   /// The class that defines the current type environment or null if no type
   /// variables are in scope.
-  final ClassElement contextClass;
+  final ClassEntity 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);
   ///     }
@@ skipping 35 matching lines @@
   /// Substituted type variables occurring in [type] into the context of
   /// [contextClass].
   DartType substInContext(DartType type) {
     if (contextClass != null) {
       ClassElement typeContext = DartTypes.getClassContext(type);
       if (typeContext != null) {
         type = builder.types.substByContext(
             type,
             builder.types.asInstanceOf(
                 builder.types.getThisType(contextClass), typeContext));
-        //type = type.substByContext(contextClass.asInstanceOf(typeContext));
       }
     }
     if (instanceType != null) {
       type = builder.types.substByContext(type, instanceType);
-      //type = type.substByContext(instanceType);
     }
     return type;
   }
 
   /// Creates a new [LocalsHandler] based on [other]. We only need to
   /// copy the [directLocals], since the other fields can be shared
   /// throughout the AST visit.
   LocalsHandler.from(LocalsHandler other)
       : directLocals = new Map<Local, HInstruction>.from(other.directLocals),
         redirectionMapping = other.redirectionMapping,
@@ skipping 135 matching lines @@
       // context.
       HThis thisInstruction = new HThis(closureData.thisLocal, getTypeOfThis());
       builder.graph.thisInstruction = thisInstruction;
       builder.graph.entry.addAtEntry(thisInstruction);
       directLocals[closureData.thisLocal] = thisInstruction;
     }
 
     // If this method is an intercepted method, add the extra
     // parameter to it, that is the actual receiver for intercepted
     // classes, or the same as [:this:] for non-intercepted classes.
-    ClassElement cls = element.enclosingClass;
+    ClassEntity cls = element.enclosingClass;
 
     // When the class extends a native class, the instance is pre-constructed
     // and passed to the generative constructor factory function as a parameter.
     // Instead of allocating and initializing the object, the constructor
     // 'upgrades' the native subclass object by initializing the Dart fields.
     bool isNativeUpgradeFactory = element is ConstructorEntity &&
         element.isGenerativeConstructor &&
         _nativeData.isNativeOrExtendsNative(cls);
     if (_interceptorData.isInterceptedMethod(element)) {
       bool isInterceptedClass = _interceptorData.isInterceptedClass(cls);
@@ skipping 412 matching lines @@
   final MemberEntity memberContext;
 
   // Avoid slow Object.hashCode.
   final int hashCode = _nextHashCode = (_nextHashCode + 1).toUnsigned(30);
   static int _nextHashCode = 0;
 
   SyntheticLocal(this.name, this.executableContext, this.memberContext);
 
   toString() => 'SyntheticLocal($name)';
 }