Typing fixes to eliminate casts/dcalls

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 595 matching lines @@
     // 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 (e is Conversion) return _inferExpression(e.node, 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);
@@ skipping 84 matching lines @@
   }
 
   /// These assume that e is not already a subtype of t
 
   bool _inferConditionalExpression(
       ConditionalExpression e, DartType t, errors) {
     return _inferExpression(e.thenExpression, t, errors) &&
         _inferExpression(e.elseExpression, t, errors);
   }
 
+  bool _inferParenthesizedExpression(
+      ParenthesizedExpression e, DartType t, errors) {
+    return _inferExpression(e.expression, t, errors);
+  }
+
   bool _inferInstanceCreationExpression(
       InstanceCreationExpression e, DartType t, errors) {
     var arguments = e.argumentList.arguments;
     var rawType = rules.getStaticType(e);
     // rawType is the instantiated type of the instance
     if (rawType is! InterfaceType) return false;
     var type = (rawType as InterfaceType);
     if (type.typeParameters == null ||
         type.typeParameters.length == 0) return false;
     if (e.constructorName.type == null) return false;
@@ skipping 124 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;
   }
 }