Handle list and map literals

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/resolution_types.dart';
 import '../elements/elements.dart';
 import '../elements/entities.dart';
+import '../elements/types.dart';
 import '../io/source_information.dart';
 import '../js_backend/native_data.dart';
 import '../js_backend/interceptor_data.dart';
 import '../tree/tree.dart' as ast;
 import '../types/types.dart';
 import '../world.dart' show ClosedWorld;
 
 import 'graph_builder.dart';
 import 'nodes.dart';
 import 'types.dart';
 
 /// Keeps track of locals (including parameters and phis) when building. The
 /// 'this' reference is treated as parameter and hence handled by this class,
 /// too.
 class LocalsHandler {
   /// The values of locals that can be directly accessed (without redirections
   /// to boxes or closure-fields).
   ///
   /// [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<ResolutionTypeVariableType, TypeVariableLocal> typeVariableLocals =
-      new Map<ResolutionTypeVariableType, TypeVariableLocal>();
+  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;
 
   /// 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 ResolutionInterfaceType instanceType;
+  final InterfaceType instanceType;
 
   final NativeData _nativeData;
 
   final InterceptorData _interceptorData;
 
   LocalsHandler(
       this.builder,
       this.executableContext,
       this.memberContext,
       this.contextClass,
-      ResolutionInterfaceType instanceType,
+      InterfaceType instanceType,
       this._nativeData,
       this._interceptorData)
       : this.instanceType =
             instanceType == null || instanceType.containsTypeVariables
                 ? null
                 : instanceType;
 
   ClosedWorld get closedWorld => builder.closedWorld;
 
   CommonMasks get commonMasks => closedWorld.commonMasks;
 
   GlobalTypeInferenceResults get _globalInferenceResults =>
       builder.globalInferenceResults;
 
   ClosureClassMaps get _closureToClassMapper => builder.closureToClassMapper;
 
   /// Substituted type variables occurring in [type] into the context of
   /// [contextClass].
-  ResolutionDartType substInContext(ResolutionDartType type) {
+  DartType substInContext(DartType type) {
     if (contextClass != null) {
-      ClassElement typeContext = Types.getClassContext(type);
+      ClassElement typeContext = DartTypes.getClassContext(type);
       if (typeContext != null) {
-        type = type.substByContext(contextClass.asInstanceOf(typeContext));
+        type = builder.types.substByContext(
+            type,
+            builder.types.asInstanceOf(
+                builder.types.getThisType(contextClass), typeContext));
+        //type = type.substByContext(contextClass.asInstanceOf(typeContext));

[Siggi Cherem (dart-lang), 2017/06/02 18:09:23]

delete old code? also below?

[Johnni Winther, 2017/06/02 18:53:46]

Done.

       }
     }
     if (instanceType != null) {
-      type = type.substByContext(instanceType);
+      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 280 matching lines @@
     }
 
     return activationVariables.putIfAbsent(local, () {
       HLocalValue localValue = new HLocalValue(local, commonMasks.nonNullType)
         ..sourceInformation = sourceInformation;
       builder.graph.entry.addAtExit(localValue);
       return localValue;
     });
   }
 
-  Local getTypeVariableAsLocal(ResolutionTypeVariableType type) {
+  Local getTypeVariableAsLocal(TypeVariableType 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 267 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)';
 }