Fixes #151

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 dev_compiler.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 25 matching lines @@
       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, bool constContext);
+  StaticInfo checkAssignment(Expression expr, DartType t);
 
   DartType getStaticType(Expression expr) => expr.staticType;
 
   /// Given a type t, if t is an interface type with a call method
   /// defined, return the function type for the call method, otherwise
   /// return null.
   FunctionType getCallMethodType(DartType t) {
     if (t is InterfaceType) {
       ClassElement element = t.element;
       InheritanceManager manager = new InheritanceManager(element.library);
@@ skipping 29 matching lines @@
   MissingTypeReporter reportMissingType = null;
 
   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, bool constContext) {
+  StaticInfo checkAssignment(Expression expr, DartType toType) {
     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 329 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, bool constContext) {
+  StaticInfo checkAssignment(Expression expr, DartType toT) {
     final fromT = getStaticType(expr);
     final Coercion c = _coerceTo(fromT, toT);
     if (c is Identity) return null;
     if (c is CoercionError) return new StaticTypeError(this, expr, toT);
     var reason = null;
     if (options.inferDownwards) {
       var errors = <String>[];
       var ok = inferrer.inferExpression(expr, toT, errors);
       if (ok) return InferredType.create(this, expr, toT);
       reason = (errors.isNotEmpty) ? errors.first : null;
@@ skipping 320 matching lines @@
     var entries = e.entries;
     bool inferEntry(MapLiteralEntry entry) {
       return _inferExpression(entry.key, kType, errors) &&
           _inferExpression(entry.value, vType, errors);
     }
     var b = entries.every(inferEntry);
     if (b) annotateMapLiteral(e, targs);
     return b;
   }
 }