Handle list and map literals

pkg/compiler/lib/src/ssa/kernel_ast_adapter.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:js_runtime/shared/embedded_names.dart';
 import 'package:kernel/ast.dart' as ir;
 
 import '../closure.dart';
 import '../common.dart';
 import '../compiler.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart';
 import '../common_elements.dart';
-import '../elements/resolution_types.dart';
 import '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../elements/modelx.dart';
+import '../elements/resolution_types.dart';
+import '../elements/types.dart';
 import '../js/js.dart' as js;
 import '../js_backend/js_backend.dart';
 import '../kernel/element_map.dart';
 import '../kernel/kernel.dart';
 import '../native/native.dart' as native;
 import '../resolution/tree_elements.dart';
 import '../tree/tree.dart' as ast;
 import '../types/masks.dart';
 import '../types/types.dart';
 import '../universe/selector.dart';
@@ skipping 274 matching lines @@
         assert(constant.fields.length == 1 || constant.fields.length == 2);
         ConstantValue indexConstant = constant.fields.values.first;
         if (indexConstant is IntConstantValue) {
           return indexConstant.primitiveValue;
         }
       }
     }
     return null;
   }
 
-  ResolutionDartType getDartType(ir.DartType type) {
+  DartType getDartType(ir.DartType type) {
     return _typeConverter.convert(type);
   }
 
-  List<ResolutionDartType> getDartTypes(List<ir.DartType> types) {
+  List<DartType> getDartTypes(List<ir.DartType> types) {
     return types.map(getDartType).toList();
   }
 
-  ResolutionInterfaceType getDartTypeOfListLiteral(ir.ListLiteral list) {
-    ast.Node node = getNodeOrNull(list);
-    if (node != null) return elements.getType(node);
-    assertNodeIsSynthetic(list);
-    return _compiler.commonElements.listType(getDartType(list.typeArgument));
-  }
-
-  ResolutionInterfaceType getDartTypeOfMapLiteral(ir.MapLiteral literal) {
-    ast.Node node = getNodeOrNull(literal);
-    if (node != null) return elements.getType(node);
-    assertNodeIsSynthetic(literal);
-    return _compiler.commonElements
-        .mapType(getDartType(literal.keyType), getDartType(literal.valueType));
-  }
-
   /// Computes the function type corresponding the signature of [node].
-  ResolutionFunctionType getFunctionType(ir.FunctionNode node) {
+  FunctionType getFunctionType(ir.FunctionNode node) {
     ResolutionDartType returnType = getDartType(node.returnType);
     List<ResolutionDartType> parameterTypes = <ResolutionDartType>[];
     List<ResolutionDartType> optionalParameterTypes = <ResolutionDartType>[];
     for (ir.VariableDeclaration variable in node.positionalParameters) {
       if (parameterTypes.length == node.requiredParameterCount) {
         optionalParameterTypes.add(getDartType(variable.type));
       } else {
         parameterTypes.add(getDartType(variable.type));
       }
     }
     List<String> namedParameters = <String>[];
     List<ResolutionDartType> namedParameterTypes = <ResolutionDartType>[];
     List<ir.VariableDeclaration> sortedNamedParameters =
         node.namedParameters.toList()..sort((a, b) => a.name.compareTo(b.name));
     for (ir.VariableDeclaration variable in sortedNamedParameters) {
       namedParameters.add(variable.name);
       namedParameterTypes.add(getDartType(variable.type));
     }
     return new ResolutionFunctionType.synthesized(returnType, parameterTypes,
         optionalParameterTypes, namedParameters, namedParameterTypes);
   }
 
-  ResolutionInterfaceType getInterfaceType(ir.InterfaceType type) =>
-      getDartType(type);
+  InterfaceType getInterfaceType(ir.InterfaceType type) => getDartType(type);
 
-  ResolutionInterfaceType createInterfaceType(
+  InterfaceType createInterfaceType(
       ir.Class cls, List<ir.DartType> typeArguments) {
     return new ResolutionInterfaceType(
         getClass(cls), getDartTypes(typeArguments));
   }
 
   MemberEntity getConstructorBodyEntity(ir.Constructor constructor) {
     AstElement element = getElement(constructor);
     MemberEntity constructorBody =
         ConstructorBodyElementX.createFromResolvedAst(element.resolvedAst);
     assert(constructorBody != null);
@@ skipping 312 matching lines @@
   TypeMask selectorTypeOf(Selector selector, TypeMask mask) {
     return TypeMaskFactory.inferredTypeForSelector(
         selector, mask, _globalInferenceResults);
   }
 
   TypeMask typeFromNativeBehavior(
       native.NativeBehavior nativeBehavior, ClosedWorld closedWorld) {
     return TypeMaskFactory.fromNativeBehavior(nativeBehavior, closedWorld);
   }
 }