Handle type variable test and typed list literal.

pkg/compiler/lib/src/ssa/optimize.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.
 
 import '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/names.dart' show Selectors;
 import '../common/tasks.dart' show CompilerTask;
 import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart';
 import '../constants/values.dart';
@@ skipping 1239 matching lines @@
       return new HTypeInfoReadRaw(source, _closedWorld.commonMasks.dynamicType);
     }
 
     // TODO(sra): Consider fusing type expression trees with no type variables,
     // as these could be represented like constants.
 
     return tryCopyInfo() ?? node;
   }
 
   HInstruction visitTypeInfoReadVariable(HTypeInfoReadVariable node) {
-    ResolutionTypeVariableType variable = node.variable;
+    TypeVariableType variable = node.variable;
+    ClassEntity contextClass = variable.element.typeDeclaration;
     HInstruction object = node.object;
 
-    HInstruction finishGroundType(ResolutionInterfaceType groundType) {
-      ResolutionInterfaceType typeAtVariable =
-          groundType.asInstanceOf(variable.element.enclosingClass);
+    HInstruction finishGroundType(InterfaceType groundType) {
+      InterfaceType typeAtVariable =
+          _closedWorld.dartTypes.asInstanceOf(groundType, contextClass);
       if (typeAtVariable != null) {
         int index = variable.element.index;
-        ResolutionDartType typeArgument = typeAtVariable.typeArguments[index];
+        DartType typeArgument = typeAtVariable.typeArguments[index];
         HInstruction replacement = new HTypeInfoExpression(
             TypeInfoExpressionKind.COMPLETE,
             typeArgument,
             const <HInstruction>[],
             _closedWorld.commonMasks.dynamicType);
         return replacement;
       }
       return node;
     }
 
     /// Read the type variable from an allocation of type [createdClass], where
     /// [selectTypeArgumentFromObjectCreation] extracts the type argument from
     /// the allocation for factory constructor call.
-    HInstruction finishSubstituted(ClassElement createdClass,
+    HInstruction finishSubstituted(ClassEntity createdClass,
         HInstruction selectTypeArgumentFromObjectCreation(int index)) {
+      InterfaceType thisType = _closedWorld.dartTypes.getThisType(createdClass);
+
       HInstruction instructionForTypeVariable(ResolutionTypeVariableType tv) {
         return selectTypeArgumentFromObjectCreation(
-            createdClass.thisType.typeArguments.indexOf(tv));
+            thisType.typeArguments.indexOf(tv));
       }
 
-      ResolutionDartType type = createdClass.thisType
-          .asInstanceOf(variable.element.enclosingClass)
+      DartType type = _closedWorld.dartTypes
+          .asInstanceOf(thisType, contextClass)
           .typeArguments[variable.element.index];
-      if (type is ResolutionTypeVariableType) {
+      if (type is TypeVariableType) {
         return instructionForTypeVariable(type);
       }
       List<HInstruction> arguments = <HInstruction>[];
       type.forEachTypeVariable((v) {
         arguments.add(instructionForTypeVariable(v));
       });
       HInstruction replacement = new HTypeInfoExpression(
           TypeInfoExpressionKind.COMPLETE,
           type,
           arguments,
@@ skipping 1685 matching lines @@
 
     keyedValues.forEach((receiver, values) {
       result.keyedValues[receiver] =
           new Map<HInstruction, HInstruction>.from(values);
     });
 
     result.nonEscapingReceivers.addAll(nonEscapingReceivers);
     return result;
   }
 }