Fix DDC errors on DDC

lib/src/checker/checker.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.checker;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/scanner.dart' show Token, TokenType;
@@ skipping 209 matching lines @@
   ///
   /// The [errorLocation] node indicates where errors are reported, see
   /// [_checkSingleOverride] for more details.
   _checkIndividualOverridesFromClass(
       ClassDeclaration node, InterfaceType baseType, Set<String> seen) {
     for (var member in node.members) {
       if (member is ConstructorDeclaration) continue;
       if (member is FieldDeclaration) {
         if (member.isStatic) continue;
         for (var variable in member.fields.variables) {
-          var name = variable.element.name;
+          var element = variable.element as PropertyInducingElement;

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

random Q, do we always prefer this pattern over:

PropertyInducingElement element = variable.element;

?

reason I ask, it's 7 chars shorter ("var_as_"), which is almost 10% of line
length or 3.5 indent levels

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

I lean toward the rhs version - it makes it explicit that there is a cast going
on and that cast would appear in generated JS.

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

err, wouldn't we generate a cast in JS for both cases?

+          var name = element.name;
           if (seen.contains(name)) continue;
-          var getter = variable.element.getter;
-          var setter = variable.element.setter;
+          var getter = element.getter;
+          var setter = element.setter;
           bool found = _checkSingleOverride(getter, baseType, variable, member);
           if (!variable.isFinal &&
               _checkSingleOverride(setter, baseType, variable, member)) {
             found = true;
           }
           if (found) seen.add(name);
         }
-      } else {
-        assert(member is MethodDeclaration);
+      } else if (member is MethodDeclaration) {
         if (member.isStatic) continue;
         var method = member.element;

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

instead of changing the if structure, maybe

  var method = (member as MethodDeclaration).element;

then no assert needed

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

It's actually on isStatic, but done there.

         if (seen.contains(method.name)) continue;
         if (_checkSingleOverride(method, baseType, member, member)) {
           seen.add(method.name);
         }
+      } else {
+        assert(false);
       }
     }
   }
 
   /// Checks that [element] correctly overrides its corresponding member in
   /// [type]. Returns `true` if an override was found, that is, if [element] has
   /// a corresponding member in [type] that it overrides.
   ///
   /// The [errorLocation] is a node where the error is reported. For example, a
   /// bad override of a method in a class with respect to its superclass is
@@ skipping 581 matching lines @@
   void _recordDynamicInvoke(AstNode node) {
     _reporter.log(new DynamicInvoke(_rules, node));
   }
 
   void _recordMessage(StaticInfo info) {
     if (info == null) return;
     if (info.level >= logger.Level.SEVERE) _failure = true;
     _reporter.log(info);
   }
 }