Fix DDC errors on DDC

lib/src/codegen/js_codegen.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.codegen.js_codegen;
 
 import 'dart:collection' show HashSet, HashMap;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
@@ skipping 505 matching lines @@
   ///
   /// This will return `null` if the adapter was already added on a super type,
   /// otherwise it returns the adapter code.
   // TODO(jmesserly): should we adapt `Iterator` too?
   JS.Method _emitIterable(InterfaceType t) {
     // If a parent had an `iterator` (concrete or abstract) or implements
     // Iterable, we know the adapter is already there, so we can skip it as a
     // simple code size optimization.
     var parent = t.lookUpGetterInSuperclass('iterator', t.element.library);
     if (parent != null) return null;
-    parent = findSupertype(t, _implementsIterable);
-    if (parent != null) return null;
+    var parentType = findSupertype(t, _implementsIterable);
+    if (parentType != null) return null;
 
     // Otherwise, emit the adapter method, which wraps the Dart iterator in
     // an ES6 iterator.
     return new JS.Method(js.call('$_SYMBOL.iterator'), js.call(
         'function() { return new dart.JsIterator(this.#); }',
         [_emitMemberName('iterator', type: t)]));
   }
 
   /// Emit class members that need to come after the class declaration, such
   /// as static fields. See [_emitClassMethods] for things that are emitted
@@ skipping 594 matching lines @@
   JS.Expression visitSimpleIdentifier(SimpleIdentifier node) {
     var accessor = node.staticElement;
     if (accessor == null) {
       return js.commentExpression(
           'Unimplemented unknown name', new JS.Identifier(node.name));
     }
 
     // Get the original declaring element. If we had a property accessor, this
     // indirects back to a (possibly synthetic) field.
     var element = accessor;
-    if (element is PropertyAccessorElement) element = accessor.variable;
+    if (accessor is PropertyAccessorElement) element = accessor.variable;
 
     _loader.declareBeforeUse(element);
 
     var name = element.name;
 
     // type literal
     if (element is ClassElement ||
         element is DynamicElementImpl ||
         element is FunctionTypeAliasElement) {
-      return _emitTypeName(fillDynamicTypeArgs(element.type, types));
+      return _emitTypeName(
+          fillDynamicTypeArgs((element as dynamic).type, types));
     }
 
     // library member
     if (element.enclosingElement is CompilationUnitElement) {
       return _maybeQualifiedName(
           element, _emitMemberName(name, isStatic: true));
     }
 
     // Unqualified class member. This could mean implicit-this, or implicit
     // call to a static from the same class.
@@ skipping 583 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 = expr.argumentList.arguments;
-        if (args.isNotEmpty && args.first is SimpleStringLiteral) {
-          var types = args.first.stringValue;
+        var first = args.isNotEmpty ? args.first : null;
+        if (first is SimpleStringLiteral) {
+          var types = first.stringValue;
           if (!types.split('|').contains('Null')) {
             return true;
           }
         }
       }
     }
     return false;
   }
 
   JS.Expression notNull(Expression expr) {
@@ skipping 284 matching lines @@
         !_isJSBuiltinType(type) &&
         _isNonNullableExpression(target)) {
       return false;
     }
     return true;
   }
 
   /// Shared code for [PrefixedIdentifier] and [PropertyAccess].
   JS.Expression _emitGet(Expression target, SimpleIdentifier memberId) {
     var member = memberId.staticElement;
-    if (member is PropertyAccessorElement) member = member.variable;
+    if (member is PropertyAccessorElement) {
+      member = (member as PropertyAccessorElement).variable;
+    }
     bool isStatic = member is ClassMemberElement && member.isStatic;
     if (isStatic) {
       _loader.declareBeforeUse(member);
     }
     var name = _emitMemberName(memberId.name,
         type: getStaticType(target), isStatic: isStatic);
     if (rules.isDynamicTarget(target)) {
       return js.call('dart.$DLOAD(#, #)', [_visit(target), name]);
     }
 
@@ skipping 166 matching lines @@
 
     // TODO(jmesserly): this is inconsistent with [visitIsExpression], which
     // has special case for typeof.
     return new JS.If(js.call('dart.is(#, #)', [
       _visit(_catchParameter),
       _emitTypeName(clause.exceptionType.type),
     ]), then, otherwise);
   }
 
   JS.Statement _statement(Iterable stmts) {
-    var s = stmts is List ? stmts : new List<JS.Statement>.from(stmts);
+    List s = stmts is List ? stmts : new List<JS.Statement>.from(stmts);
     // TODO(jmesserly): empty block singleton?
     if (s.length == 0) return new JS.Block([]);
     if (s.length == 1) return s[0];
     return new JS.Block(s);
   }
 
   /// Visits the catch clause body. This skips the exception type guard, if any.
   /// That is handled in [_visitCatch].
   @override
   JS.Statement visitCatchClause(CatchClause node) {
@@ skipping 386 matching lines @@
 
 /// A special kind of element created by the compiler, signifying a temporary
 /// variable. These objects use instance equality, and should be shared
 /// everywhere in the tree where they are treated as the same variable.
 class TemporaryVariableElement extends LocalVariableElementImpl {
   TemporaryVariableElement.forNode(Identifier name) : super.forNode(name);
 
   int get hashCode => identityHashCode(this);
   bool operator ==(Object other) => identical(this, other);
 }