Typecheck map and list literals

lib/src/checker/rules.dart

 // Copyright (c) 2015, 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.
 
 library ddc.src.checker.rules;
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 
@@ skipping 17 matching lines @@
       {bool ignoreReturn: false}) => isSubTypeOf(f1, f2);
 
   bool isBoolType(DartType t) => t == provider.boolType;
   bool isDoubleType(DartType t) => t == provider.doubleType;
   bool isIntType(DartType t) => t == provider.intType;
   bool isNumType(DartType t) => t == provider.intType.superclass;
   bool isStringType(DartType t) => t == provider.stringType;
   bool isNonNullableType(DartType t) => false;
   bool maybeNonNullableType(DartType t) => false;
 
-  StaticInfo checkAssignment(Expression expr, DartType t);
+  StaticInfo checkAssignment(Expression expr, DartType t, bool constContext);
 
   DartType getStaticType(Expression expr) => expr.staticType;
 
   DartType elementType(Element e);
 
   bool isDynamic(DartType t);
   bool isDynamicTarget(Expression expr);
   bool isDynamicGet(Expression expr);
   bool isDynamicCall(Expression call);
 }
 
 class DartRules extends TypeRules {
   DartRules(TypeProvider provider) : super(provider);
 
   bool isSubTypeOf(DartType t1, DartType t2) {
     return t1.isSubtypeOf(t2);
   }
 
   bool isAssignable(DartType t1, DartType t2) {
     return t1.isAssignableTo(t2);
   }
 
-  StaticInfo checkAssignment(Expression expr, DartType toType) {
+  StaticInfo checkAssignment(
+      Expression expr, DartType toType, bool constContext) {
     final fromType = getStaticType(expr);
     if (!isAssignable(fromType, toType)) {
       return new StaticTypeError(this, expr, toType);
     }
     return null;
   }
 
   DartType elementType(Element e) {
     return (e as dynamic).type;
   }
@@ skipping 376 matching lines @@
     // type system, but allowed in the regular dart type system, since these
     // are likely to succeed.  The canonical example is List<dynamic> and
     // Iterable<T> for some concrete T (e.g. Object).  These are unrelated
     // in the restricted system, but List<dynamic> <: Iterable<T> in dart.
     if (options.relaxedCasts && fromT.isAssignableTo(toT)) {
       return Coercion.cast(fromT, toT);
     }
     return Coercion.error();
   }
 
-  StaticInfo checkAssignment(Expression expr, DartType toT) {
+  StaticInfo checkAssignment(Expression expr, DartType toT, bool constContext) {
     final fromT = getStaticType(expr);
     final Coercion c = _coerceTo(fromT, toT, true);
+    if (c is Identity) return null;
     if (c is CoercionError) return new StaticTypeError(this, expr, toT);
+    if (constContext && !options.allowConstCasts) {
+      return new StaticTypeError(this, expr, toT);
+    }
     if (c is Cast) return DownCast.create(this, expr, c);
     if (c is Wrapper) return ClosureWrap.create(this, expr, c, toT);
-    assert(c is Identity);
+    assert(false);
     return null;
   }
 
   DartType elementType(Element e) {
     return (e as dynamic).type;
   }
 
   bool isDynamic(DartType t) => options.ignoreTypes || t.isDynamic;
 
   /// Returns `true` if the target expression is dynamic.
@@ skipping 12 matching lines @@
   /// Returns `true` if the expression is a dynamic function call or method
   /// invocation.
   bool isDynamicCall(Expression call) {
     if (options.ignoreTypes) return true;
     var t = getStaticType(call);
     // TODO(jmesserly): fix handling of types with `call` methods. These are not
     // FunctionType, but they also aren't dynamic calls.
     return t.isDynamic || t.isDartCoreFunction || t is! FunctionType;
   }
 }