Handle list and map literals

pkg/compiler/lib/src/ssa/builder_kernel.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 'package:kernel/ast.dart' as ir;
 
 import '../closure.dart';
 import '../common.dart';
 import '../common/codegen.dart' show CodegenRegistry;
 import '../common/names.dart';
@@ skipping 632 matching lines @@
           visitElse: null,
           // TODO(27394): Add sourceInformation via
           // `sourceInformationBuilder.buildIf(?)`.
         );
       }
     }
     functionNode.body.accept(this);
     closeFunction();
   }
 
-  void addImplicitInstantiation(ResolutionDartType type) {
+  void addImplicitInstantiation(DartType type) {
     if (type != null) {
       currentImplicitInstantiations.add(type);
     }
   }
 
-  void removeImplicitInstantiation(ResolutionDartType type) {
+  void removeImplicitInstantiation(DartType type) {
     if (type != null) {
       currentImplicitInstantiations.removeLast();
     }
   }
 
   void openFunction() {
     HBasicBlock block = graph.addNewBlock();
     open(graph.entry);
 
     localsHandler.startFunction(targetElement, functionNode,
@@ skipping 1153 matching lines @@
         astAdapter.getConstantForSymbol(symbolLiteral), closedWorld));
     registry?.registerConstSymbol(symbolLiteral.value);
   }
 
   @override
   void visitNullLiteral(ir.NullLiteral nullLiteral) {
     stack.add(graph.addConstantNull(closedWorld));
   }
 
   /// Set the runtime type information if necessary.
-  HInstruction setListRuntimeTypeInfoIfNeeded(
+  HInstruction _setListRuntimeTypeInfoIfNeeded(
       HInstruction object, ir.ListLiteral listLiteral) {
-    ResolutionInterfaceType type = localsHandler
-        .substInContext(astAdapter.getDartTypeOfListLiteral(listLiteral));
+    InterfaceType type = localsHandler.substInContext(_commonElements
+        .listType(_elementMap.getDartType(listLiteral.typeArgument)));
     if (!rtiNeed.classNeedsRti(type.element) || type.treatAsRaw) {
       return object;
     }
     List<HInstruction> arguments = <HInstruction>[];
-    for (ResolutionDartType argument in type.typeArguments) {
+    for (DartType argument in type.typeArguments) {
       arguments.add(typeBuilder.analyzeTypeArgument(argument, sourceElement));
     }
     // TODO(15489): Register at codegen.
     registry?.registerInstantiation(type);
     return callSetRuntimeTypeInfoWithTypeArguments(type, arguments, object);
   }
 
   @override
   void visitListLiteral(ir.ListLiteral listLiteral) {
     HInstruction listInstruction;
     if (listLiteral.isConst) {
       listInstruction = graph.addConstant(
           astAdapter.getConstantFor(listLiteral), closedWorld);
     } else {
       List<HInstruction> elements = <HInstruction>[];
       for (ir.Expression element in listLiteral.expressions) {
         element.accept(this);
         elements.add(pop());
       }
       listInstruction =
           new HLiteralList(elements, commonMasks.extendableArrayType);
       add(listInstruction);
       listInstruction =
-          setListRuntimeTypeInfoIfNeeded(listInstruction, listLiteral);
+          _setListRuntimeTypeInfoIfNeeded(listInstruction, listLiteral);
     }
 
     TypeMask type = _typeInferenceMap.typeOfListLiteral(
         targetElement, listLiteral, closedWorld);
     if (!type.containsAll(closedWorld)) {
       listInstruction.instructionType = type;
     }
     stack.add(listInstruction);
   }
 
@@ skipping 22 matching lines @@
       constructor = _commonElements.mapLiteralConstructor;
       HLiteralList argList =
           new HLiteralList(constructorArgs, commonMasks.extendableArrayType);
       add(argList);
       inputs.add(argList);
     }
 
     assert(
         constructor is ConstructorEntity && constructor.isFactoryConstructor);
 
-    ResolutionInterfaceType type = localsHandler
-        .substInContext(astAdapter.getDartTypeOfMapLiteral(mapLiteral));
-
+    InterfaceType type = localsHandler.substInContext(_commonElements.mapType(
+        _elementMap.getDartType(mapLiteral.keyType),
+        _elementMap.getDartType(mapLiteral.valueType)));
     ClassEntity cls = constructor.enclosingClass;
 
     if (rtiNeed.classNeedsRti(cls)) {
       List<HInstruction> typeInputs = <HInstruction>[];
-      type.typeArguments.forEach((ResolutionDartType argument) {
+      type.typeArguments.forEach((DartType argument) {
         typeInputs
             .add(typeBuilder.analyzeTypeArgument(argument, sourceElement));
       });
 
       // We lift this common call pattern into a helper function to save space
       // in the output.
       if (typeInputs.every((HInstruction input) => input.isNull())) {
         if (constructorArgs.isEmpty) {
           constructor = _commonElements.mapLiteralUntypedEmptyMaker;
         } else {
@@ skipping 1480 matching lines @@
     enterBlock.setBlockFlow(
         new HTryBlockInformation(
             kernelBuilder.wrapStatementGraph(bodyGraph),
             exception,
             kernelBuilder.wrapStatementGraph(catchGraph),
             kernelBuilder.wrapStatementGraph(finallyGraph)),
         exitBlock);
     kernelBuilder.inTryStatement = previouslyInTryStatement;
   }
 }