Downwards inference. This adds support to the resolver for downwards

pkg/analyzer/lib/src/task/strong/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.
 
 // TODO(jmesserly): this was ported from package:dev_compiler, and needs to be
 // refactored to fit into analyzer.
 library analyzer.src.task.strong.rules;
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
@@ skipping 403 matching lines @@
   }
 
   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;
 
     var errors = <String>[];
+    
     var ok = inferrer.inferExpression(expr, toT, errors);
     if (ok) return InferredType.create(this, expr, toT);
     reason = (errors.isNotEmpty) ? errors.first : null;
 
     if (c is Cast) return DownCast.create(this, expr, c, reason: reason);
     assert(false);
     return null;
   }
 
   DartType elementType(Element e) {
@@ skipping 67 matching lines @@
 
   /// Downward inference
   bool inferExpression(Expression e, DartType t, List<String> errors) {
     // Don't cast top level expressions, only sub-expressions
     return _inferExpression(e, t, errors, cast: false);
   }
 
   /// Downward inference
   bool _inferExpression(Expression e, DartType t, List<String> errors,
       {cast: true}) {
-    if (e is ConditionalExpression) {
-      return _inferConditionalExpression(e, t, errors);
-    }
-    if (e is ParenthesizedExpression) {
-      return _inferParenthesizedExpression(e, t, errors);
-    }
     if (rules.isSubTypeOf(rules.getStaticType(e), t)) return true;
     if (cast && rules.getStaticType(e).isDynamic) {
       annotateCastFromDynamic(e, t);
       return true;
     }
-    if (e is FunctionExpression) return _inferFunctionExpression(e, t, errors);
-    if (e is ListLiteral) return _inferListLiteral(e, t, errors);
-    if (e is MapLiteral) return _inferMapLiteral(e, t, errors);
-    if (e is NamedExpression) return _inferNamedExpression(e, t, errors);
-    if (e is InstanceCreationExpression) {
-      return _inferInstanceCreationExpression(e, t, errors);
-    }
     errors.add("$e cannot be typed as $t");
     return false;
   }
 
   /// If t1 = I<dynamic, ..., dynamic>, then look for a supertype
   /// of t1 of the form K<S0, ..., Sm> where t2 = K<S0', ..., Sm'>
   /// If the supertype exists, use the constraints S0 <: S0', ... Sm <: Sm'
   /// to derive a concrete instantation for I of the form <T0, ..., Tn>,
   /// such that I<T0, .., Tn> <: t2
   List<DartType> _matchTypes(InterfaceType t1, InterfaceType t2) {
@@ skipping 223 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;
   }
 }