Fix DDC errors on DDC

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 730 matching lines @@
     if (classTypeName.typeArguments != null) return false;
     // Infer type arguments
     var targs = _matchTypes(type, t);
     if (targs == null) return false;
     if (e.staticElement == null) return false;
     var constructorElement = e.staticElement;
     // From the constructor element get:
     //  the instantiated type of the constructor, then
     //     the uninstantiated element for the constructor, then
     //        the uninstantiated type for the constructor
-    var baseType = constructorElement.type.element.type;
+    var rawConstructorElement =
+        constructorElement.type.element as ConstructorElement;
+    var baseType = rawConstructorElement.type;
     if (baseType == null) return false;
     // From the interface type (instantiated), get:
     //  the uninstantiated element, then
     //    the uninstantiated type, then
     //      the type arguments (aka the type parameters)
     var tparams = type.element.type.typeArguments;
     // Take the uninstantiated constructor type, and replace the type
     // parameters with the inferred arguments.
     var fType = baseType.substitute2(targs, tparams);
     {
@@ skipping 22 matching lines @@
     annotateInstanceCreationExpression(e, targs);
     return true;
   }
 
   bool _inferNamedExpression(NamedExpression e, DartType t, errors) {
     return _inferExpression(e.expression, t, errors);
   }
 
   bool _inferFunctionExpression(FunctionExpression e, DartType t, errors) {
     if (t is! FunctionType) return false;
-    var fType = (t as FunctionType);
-    var eType = e.staticType;
+    var fType = t as FunctionType;
+    var eType = e.staticType as FunctionType;
     if (eType is! FunctionType) return false;
 
     // We have a function literal, so we can treat the arrow type
     // as non-fuzzy.  Since we're not improving on parameter types
     // currently, if this check fails then we cannot succeed, so
     // bail out.  Otherwise, we never need to check the parameter types
     // again.
     if (!rules.isFunctionSubTypeOf(eType, fType,
         fuzzyArrows: false, ignoreReturn: true)) return false;
 
@@ skipping 56 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;
   }
 }