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

pkg/dev_compiler/lib/src/compiler/code_generator.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 'dart:collection' show HashMap, HashSet;
 import 'dart:math' show min, max;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart' show Token, TokenType;
 import 'package:analyzer/dart/element/element.dart';
@@ skipping 10 matching lines @@
     show StrongTypeSystemImpl;
 import 'package:analyzer/src/summary/idl.dart' show UnlinkedUnit;
 import 'package:analyzer/src/summary/link.dart' as summary_link;
 import 'package:analyzer/src/summary/package_bundle_reader.dart';
 import 'package:analyzer/src/summary/summarize_ast.dart'
     show serializeAstUnlinked;
 import 'package:analyzer/src/summary/summarize_elements.dart'
     show PackageBundleAssembler;
 import 'package:analyzer/src/summary/summary_sdk.dart';
 import 'package:analyzer/src/task/strong/ast_properties.dart'
-    show isDynamicInvoke, setIsDynamicInvoke;
+    show isDynamicInvoke, setIsDynamicInvoke, getImplicitAssignmentCast;
 import 'package:path/path.dart' show separator;
 
 import '../closure/closure_annotator.dart' show ClosureAnnotator;
 import '../js_ast/js_ast.dart' as JS;
 import '../js_ast/js_ast.dart' show js;
 import 'ast_builder.dart' show AstBuilder;
 import 'compiler.dart' show BuildUnit, CompilerOptions, JSModuleFile;
 import 'element_helpers.dart';
 import 'element_loader.dart' show ElementLoader;
 import 'extension_types.dart' show ExtensionTypeSet;
@@ skipping 509 matching lines @@
         return js.call('dart.asInt(#)', jsFrom);
       }
 
       // A no-op in JavaScript.
       return jsFrom;
     }
 
     var type = _emitType(to,
         nameType: options.nameTypeTests || options.hoistTypeTests,
         hoistType: options.hoistTypeTests);
-    if (isReifiedCoercion(node)) {
+    if (CoercionReifier.isImplicitCast(node)) {
       return js.call('#._check(#)', [type, jsFrom]);
     } else {
       return js.call('#.as(#)', [type, jsFrom]);
     }
   }
 
-  bool isReifiedCoercion(AstNode node) {
-    // TODO(sra): Find a better way to recognize reified coercion, since we
-    // can't set the isSynthetic attribute.
-    return (node is AsExpression) && (node.asOperator.offset == 0);
-  }
-
   @override
   visitIsExpression(IsExpression node) {
     // Generate `is` as `dart.is` or `typeof` depending on the RHS type.
     JS.Expression result;
     var type = node.type.type;
     var lhs = _visit(node.expression);
     var typeofName = _jsTypeofName(type);
     if (typeofName != null) {
       result = js.call('typeof # == #', [lhs, js.string(typeofName, "'")]);
     } else {
@@ skipping 1338 matching lines @@
     if (redirect != null) {
       var newKeyword = redirect.staticElement.isFactory ? '' : 'new';
       // Pass along all arguments verbatim, and let the callee handle them.
       // TODO(jmesserly): we'll need something different once we have
       // rest/spread support, but this should work for now.
       var params =
           visitFormalParameterList(node.parameters, destructure: false);
 
       var fun = new JS.Fun(
           params,
-          js.statement(
-              '{ return $newKeyword #(#); }', [_visit(redirect), params]),
+          js.statement('{ return $newKeyword #(#); }',
+              [_visit(redirect) as JS.Node, params]),
           returnType: returnType);
       return annotate(
           new JS.Method(name, fun, isStatic: true), node, node.element);
     }
 
     // For const constructors we need to ensure default values are
     // available for use by top-level constant initializers.
     ClassDeclaration cls = node.parent;
     if (node.constKeyword != null) _loader.startTopLevel(cls.element);
     var params = visitFormalParameterList(node.parameters);
@@ skipping 1062 matching lines @@
       var t = _bindValue(vars, 't', x, context: x);
       return new JS.MetaLet(vars, [
         js.call('# == null ? # : #', [_visit(t), _emitSet(x, right), _visit(t)])
       ]);
     }
 
     // Desugar `x += y` as `x = x + y`, ensuring that if `x` has subexpressions
     // (for example, x is IndexExpression) we evaluate those once.
     var vars = <JS.MetaLetVariable, JS.Expression>{};
     var lhs = _bindLeftHandSide(vars, left, context: context);
-    var inc = AstBuilder.binaryExpression(lhs, op, right);
-    inc.staticElement = element;
-    inc.staticType = getStaticType(left);
+    Expression inc = AstBuilder.binaryExpression(lhs, op, right)
+      ..staticElement = element
+      ..staticType = getStaticType(lhs);
+
+    var castTo = getImplicitAssignmentCast(left);
+    if (castTo != null) inc = CoercionReifier.castExpression(inc, castTo);
     return new JS.MetaLet(vars, [_emitSet(lhs, inc)]);
   }
 
   JS.Expression _emitSet(Expression lhs, Expression rhs) {
     if (lhs is IndexExpression) {
       var target = _getTarget(lhs);
       if (_useNativeJsIndexer(target.staticType)) {
         return js
             .call('#[#] = #', [_visit(target), _visit(lhs.index), _visit(rhs)]);
       }
@@ skipping 1507 matching lines @@
             _createTemporary('_', nodeTarget.staticType, nullable: false);
         var baseNode = _stripNullAwareOp(node, param);
         tail.add(
             new JS.ArrowFun(<JS.Parameter>[_visit(param)], _visit(baseNode)));
         node = nodeTarget;
       } else {
         break;
       }
     }
     if (tail.isEmpty) return _visit(node);
-    return js.call('dart.nullSafe(#, #)', [_visit(node), tail.reversed]);
+    return js.call(
+        'dart.nullSafe(#, #)', [_visit(node) as JS.Expression, tail.reversed]);
   }
 
   static Token _getOperator(Expression node) {
     if (node is PropertyAccess) return node.operator;
     if (node is MethodInvocation) return node.operator;
     return null;
   }
 
   // TODO(jmesserly): this is dropping source location.
   Expression _stripNullAwareOp(Expression node, Expression newTarget) {
@@ skipping 132 matching lines @@
         var vars = <JS.MetaLetVariable, JS.Expression>{};
         var l = _visit(_bindValue(vars, 'l', target));
         return new JS.MetaLet(vars, [
           js.call('(#[(#[dart._extensionType]) ? dartx[#] : #]).call(#, #)',
               [l, l, memberName, memberName, l, _visitList(args)])
         ]);
       }
       // dynamic dispatch
       var dynamicHelper = const {'[]': 'dindex', '[]=': 'dsetindex'}[name];
       if (dynamicHelper != null) {
-        return js.call(
-            'dart.$dynamicHelper(#, #)', [_visit(target), _visitList(args)]);
+        return js.call('dart.$dynamicHelper(#, #)',
+            [_visit(target) as JS.Expression, _visitList(args)]);
       } else {
         return js.call('dart.dsend(#, #, #)',
             [_visit(target), memberName, _visitList(args)]);
       }
     }
 
     // Generic dispatch to a statically known method.
     return js.call('#.#(#)', [_visit(target), memberName, _visitList(args)]);
   }
 
@@ skipping 333 matching lines @@
 
     if (isConst) return _cacheConst(emitList);
     return emitList();
   }
 
   @override
   visitMapLiteral(MapLiteral node) {
     // TODO(jmesserly): we can likely make these faster.
     JS.Expression emitMap() {
       var entries = node.entries;
-      var mapArguments = null;
+      Object mapArguments = null;
       var type = node.staticType as InterfaceType;
       var typeArgs = type.typeArguments;
       var reifyTypeArgs = typeArgs.any((t) => !t.isDynamic);
       if (entries.isEmpty && !reifyTypeArgs) {
         mapArguments = [];
       } else if (entries.every((e) => e.key is StringLiteral)) {
         // Use JS object literal notation if possible, otherwise use an array.
         // We could do this any time all keys are non-nullable String type.
         // For now, support StringLiteral as the common non-nullable String case.
         var props = <JS.Property>[];
@@ skipping 101 matching lines @@
     if (node is BinaryExpression) {
       JS.Expression shortCircuit(String code) {
         return finish(js.call(code,
             [_visitTest(node.leftOperand), _visitTest(node.rightOperand)]));
       }
 
       var op = node.operator.type.lexeme;
       if (op == '&&') return shortCircuit('# && #');
       if (op == '||') return shortCircuit('# || #');
     }
-    if (isReifiedCoercion(node)) {
-      AsExpression asNode = node;
-      assert(asNode.staticType == types.boolType);
-      return js.call('dart.test(#)', _visit(asNode.expression));
+    if (node is AsExpression && CoercionReifier.isImplicitCast(node)) {
+      assert(node.staticType == types.boolType);
+      return js.call('dart.test(#)', _visit(node.expression));
     }
     JS.Expression result = _visit(node);
     if (isNullable(node)) result = js.call('dart.test(#)', result);
     return result;
   }
 
   /// Like [_emitMemberName], but for declaration sites.
   ///
   /// Unlike call sites, we always have an element available, so we can use it
   /// directly rather than computing the relevant options for [_emitMemberName].
@@ skipping 260 matching lines @@
   if (uri.scheme == 'package') {
     // Strip the package name.
     // TODO(vsm): This is not unique if an escaped '/'appears in a filename.
     // E.g., "foo/bar.dart" and "foo$47bar.dart" would collide.
     qualifiedPath = uri.pathSegments.skip(1).join(separator);
   } else if (uri.toFilePath().startsWith(libraryRoot)) {
     qualifiedPath =
         uri.path.substring(libraryRoot.length).replaceAll('/', separator);
   } else {
     // We don't have a unique name.
-    throw 'Invalid library root. $libraryRoot does not contain ${uri.toFilePath()}';
+    throw 'Invalid library root. $libraryRoot does not contain ${uri
+        .toFilePath()}';
   }
   return pathToJSIdentifier(qualifiedPath);
 }
 
 /// Shorthand for identifier-like property names.
 /// For now, we emit them as strings and the printer restores them to
 /// identifiers if it can.
 // TODO(jmesserly): avoid the round tripping through quoted form.
 JS.LiteralString _propertyName(String name) => js.string(name, "'");
 
 // TODO(jacobr): we would like to do something like the following
 // but we don't have summary support yet.
 // bool _supportJsExtensionMethod(AnnotatedNode node) =>
 //    _getAnnotation(node, "SupportJsExtensionMethod") != null;
 
 /// 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 {
   final JS.Expression jsVariable;
+
   TemporaryVariableElement.forNode(Identifier name, this.jsVariable)
       : super.forNode(name);
 
   int get hashCode => identityHashCode(this);
+
   bool operator ==(Object other) => identical(this, other);
 }
 
 bool isLibraryPrefix(Expression node) =>
     node is SimpleIdentifier && node.staticElement is PrefixElement;
 
 LibraryElement _getLibrary(AnalysisContext c, String uri) =>
     c.computeLibraryElement(c.sourceFactory.forUri(uri));
 
 bool _isDartRuntime(LibraryElement l) =>
     l.isInSdk && l.source.uri.toString() == 'dart:_runtime';