Fix DDC errors on DDC

lib/src/checker/resolver.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.
 
 /// Encapsulates how to invoke the analyzer resolver and overrides how it
 /// computes types on expressions to use our restricted set of types.
 library dev_compiler.src.checker.resolver;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 180 matching lines @@
       f is FieldDeclaration && !f.isStatic && !f.fields.isConst;
 
   /// Attempts to infer the type on [field] from overridden fields or getters if
   /// a type was not specified. If no type could be inferred, but it contains an
   /// initializer, we add it to [pending] so we can try to infer it using the
   /// initializer type instead.
   void _inferFieldTypeFromOverride(
       FieldDeclaration field, Set<VariableDeclaration> pending) {
     var variables = field.fields;
     for (var variable in variables.variables) {
-      var varElement = variable.element;
+      var varElement = variable.element as PropertyInducingElement;

[Jennifer Messerly, 2015/06/01 21:52:10]

hmm, this one almost seems like feedback for analyzer. Because fields and local
variables are mashed together, there's no type safe way to access the
field/local variable elements.

       if (!varElement.type.isDynamic || variables.type != null) continue;
       var getter = varElement.getter;
       // Note: type will be null only when there are no overrides. When some
       // override's type was not specified and couldn't be inferred, the type
       // here will be dynamic.
-      var type = searchTypeFor(varElement.enclosingElement.type, getter);
+      var enclosingElement = varElement.enclosingElement as ClassElement;
+      var type = searchTypeFor(enclosingElement.type, getter);
 
       // Infer from the RHS when there are no overrides.
       if (type == null) {
         if (variable.initializer != null) pending.add(variable);
         continue;
       }
 
       // When field is final and overriden getter is dynamic, we can infer from
       // the RHS without breaking subtyping rules (return type is covariant).
       if (type.returnType.isDynamic) {
@@ skipping 10 matching lines @@
       if (!varElement.isFinal) varElement.setter.parameters[0].type = newType;
     }
   }
 
   void _inferMethodReturnTypeFromOverride(MethodDeclaration method) {
     var methodElement = method.element;
     if ((methodElement is MethodElement ||
             methodElement is PropertyAccessorElement) &&
         methodElement.returnType.isDynamic &&
         method.returnType == null) {
-      var type =
-          searchTypeFor(methodElement.enclosingElement.type, methodElement);
+      var enclosingElement = methodElement.enclosingElement as ClassElement;

[Jennifer Messerly, 2015/06/01 21:52:10]

not sure if it's any better, but another way to express this:

var classElem = (methodElement as ClassMemberElement).enclosingElement;

[vsm, 2015/06/01 22:44:19]

This actually fails at runtime when methodElement is
PropertyAccessorElementImpl.

[Jennifer Messerly, 2015/06/01 23:10:56]

doh. PropertyAccessorElement strikes again.

+      var type = searchTypeFor(enclosingElement.type, methodElement);
       if (type != null && !type.returnType.isDynamic) {
         methodElement.returnType = type.returnType;
       }
     }
   }
 
   void _inferVariableFromInitializer(Iterable<VariableDeclaration> variables) {
     for (var variable in variables) {
-      var declaration = variable.parent;
+      var declaration = variable.parent as VariableDeclarationList;
       // Only infer on variables that don't have any declared type.
       if (declaration.type != null) continue;
       if (_options.onlyInferConstsAndFinalFields &&
           !declaration.isFinal &&
           !declaration.isConst) {
         return;
       }
       var initializer = variable.initializer;
       if (initializer == null) continue;
       var type = initializer.staticType;
       if (type == null || type.isDynamic || type.isBottom) continue;
       if (!_canInferFrom(initializer)) continue;
-      var element = variable.element;
+      var element = variable.element as PropertyInducingElement;
       // Note: it's ok to update the type here, since initializer.staticType
       // is already computed for all declarations in the library cycle. The
       // new types will only be propagated on a second run of the
       // ResolverVisitor.
       element.type = type;
       element.getter.returnType = type;
       if (!element.isFinal && !element.isConst) {
         element.setter.parameters[0].type = type;
       }
     }
@@ skipping 92 matching lines @@
     try {
       _revisiting = true;
       _nodeWasSkipped = false;
       var node = variable.parent.parent;
       var oldState;
       var state = _stateAtDeclaration[node];
       if (state != null) {
         oldState = new _ResolverState(this);
         state.restore(this);
         if (node is FieldDeclaration) {
-          var cls = node.parent;
+          var cls = node.parent as ClassDeclaration;
           enclosingClass = cls.element;
         }
       }
       visitNode(variable.initializer);
       if (!_nodeWasSkipped) _visitedInitializers.add(variable);
       if (oldState != null) oldState.restore(this);
     } finally {
       _revisiting = false;
     }
   }
@@ skipping 155 matching lines @@
     }
 
     return null;
   }
 
   @override
   visitDeclaredIdentifier(DeclaredIdentifier node) {
     super.visitDeclaredIdentifier(node);
     if (node.type != null) return;
 
-    var parent = node.parent;
-    assert(parent is ForEachStatement);
+    var parent = node.parent as ForEachStatement;
     var expr = parent.iterable;
     var element = node.element as LocalVariableElementImpl;
     var exprType = expr.staticType;
     if (exprType is InterfaceType) {
       var iteratedType = _findIteratedType(exprType);
       if (iteratedType != null) {
         element.type = iteratedType;
       }
     }
   }
@@ skipping 37 matching lines @@
         e.library.name == '_foreign_helper' &&
         e.name == 'JS') {
       // Fix types for JS builtin calls.
       //
       // This code was taken from analyzer. It's not super sophisticated:
       // only looks for the type name in dart:core, so we just copy it here.
       //
       // TODO(jmesserly): we'll likely need something that can handle a wider
       // variety of types, especially when we get to JS interop.
       var args = node.argumentList.arguments;
-      if (args.isNotEmpty && args.first is SimpleStringLiteral) {
+      var first = args.isNotEmpty ? args.first : null;
+      if (first is SimpleStringLiteral) {
         var coreLib = _typeProvider.objectType.element.library;
-        var classElem = coreLib.getType(args.first.stringValue);
+        var classElem = coreLib.getType(first.stringValue);
         if (classElem != null) node.staticType = classElem.type;
       }
     }
   }
 
   void _inferObjectAccess(
       Expression node, Expression target, SimpleIdentifier id) {
     // Search for Object accesses.
     var name = id.name;
     if (node.staticType.isDynamic &&
@@ skipping 43 matching lines @@
     }
   }
 
   // Review note: no longer need to override visitFunctionExpression, this is
   // handled by the analyzer internally.
   // TODO(vsm): in visitbinaryExpression: check computeStaticReturnType result?
   // TODO(vsm): in visitFunctionDeclaration: Should we ever use the expression
   // type in a (...) => expr or just the written type?
 
 }