re-land fix #27110 with proper DDC side of changes

pkg/dev_compiler/lib/src/compiler/reify_coercions.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.
 
 import 'package:analyzer/analyzer.dart' as analyzer;
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/type.dart' show DartType;
 import 'package:analyzer/src/dart/ast/ast.dart' show FunctionBodyImpl;
 import 'package:analyzer/src/dart/ast/utilities.dart' show NodeReplacer;
 import 'package:analyzer/src/dart/element/type.dart' show DynamicTypeImpl;
@@ skipping 13 matching lines @@
 
   CoercionReifier._();
 
   /// Transforms the given compilation units, and returns a new AST with
   /// explicit coercion nodes in appropriate places.
   static List<CompilationUnit> reify(List<CompilationUnit> units) {
     var cr = new CoercionReifier._();
     return units.map(cr.visitCompilationUnit).toList(growable: false);
   }
 
+
+  /// Returns true if the `as` [node] was created by this class.
+  // TODO(sra): Find a better way to recognize reified coercion, since we
+  // can't set the isSynthetic attribute.
+  static bool isImplicitCast(AsExpression node) => node.asOperator.offset == 0;
+
+  /// Creates an implicit cast for expression [e] to [toType].
+  static Expression castExpression(Expression e, DartType toType) {
+    // We use an empty name in the AST, because the JS code generator only cares
+    // about the target type. It does not look at the AST name.
+    var typeName = new TypeName(AstBuilder.identifierFromString(''), null);
+    typeName.type = toType;
+    var cast = AstBuilder.asExpression(e, typeName);
+    cast.staticType = toType;
+    return cast;
+  }
+
   @override
   CompilationUnit visitCompilationUnit(CompilationUnit node) {
     if (ast_properties.hasImplicitCasts(node)) {
       // Clone compilation unit, so we don't modify the originals.
       node = _clone(node);
       super.visitCompilationUnit(node);
     }
     return node;
   }
 
   @override
   visitExpression(Expression node) {
     node.visitChildren(this);
 
     var castType = ast_properties.getImplicitCast(node);
     if (castType != null) {
-      _replaceNode(node.parent, node, _castExpression(node, castType));
+      _replaceNode(node.parent, node, castExpression(node, castType));
     }
   }
 
   @override
   visitMethodInvocation(MethodInvocation node) {
     if (isInlineJS(node.methodName.staticElement)) {
       // Don't cast our inline-JS code in SDK.
       ast_properties.setImplicitCast(node, null);
     }
     visitExpression(node);
@@ skipping 11 matching lines @@
     node.iterable.accept(this);
     node.body.accept(this);
 
     // If needed, assert a cast inside the body before the variable is read.
     var variable = node.identifier ?? node.loopVariable.identifier;
     var castType = ast_properties.getImplicitCast(variable);
     if (castType != null) {
       // Build the cast. We will place this cast in the body, so need to clone
       // the variable's AST node and clear out its static type (otherwise we
       // will optimize away the cast).
-      var cast = _castExpression(
+      var cast = castExpression(
           _clone(variable)..staticType = DynamicTypeImpl.instance, castType);
 
       var body = node.body;
       var blockBody = <Statement>[RawAstBuilder.expressionStatement(cast)];
       if (body is Block) {
         blockBody.addAll(body.statements);
       } else {
         blockBody.add(body);
       }
       _replaceNode(node, body, RawAstBuilder.block(blockBody));
     }
   }
 
   void _replaceNode(AstNode parent, AstNode oldNode, AstNode newNode) {
     if (!identical(oldNode, newNode)) {
       var replaced = parent.accept(new NodeReplacer(oldNode, newNode));
       // It looks like NodeReplacer will always return true.
       // It does throw IllegalArgumentException though, if child is not found.
       assert(replaced);
     }
   }
 
-  Expression _castExpression(Expression e, DartType toType) {
-    // We use an empty name in the AST, because the JS code generator only cares
-    // about the target type. It does not look at the AST name.
-    var typeName = new TypeName(AstBuilder.identifierFromString(''), null);
-    typeName.type = toType;
-    var cast = AstBuilder.asExpression(e, typeName);
-    cast.staticType = toType;
-    return cast;
-  }
-
   /*=T*/ _clone/*<T extends AstNode>*/(/*=T*/ node) {
     var copy = node.accept(cloner) as dynamic/*=T*/;
     ResolutionCopier.copyResolutionData(node, copy);
     return copy;
   }
 }
 
 class _TreeCloner extends analyzer.AstCloner {
   void _cloneProperties(AstNode clone, AstNode node) {
     if (clone is Expression) {
@@ skipping 40 matching lines @@
 
   // TODO(jmesserly): workaround for
   // https://github.com/dart-lang/sdk/issues/26368
   @override
   TypeName visitTypeName(TypeName node) {
     var clone = super.visitTypeName(node);
     clone.type = node.type;
     return clone;
   }
 }