fix #29504, dcall on object member when a temporary was involved.

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';
@@ skipping 4537 matching lines @@
     if (_isNull(left) || _isNull(right)) return true;
 
     var leftType = _canonicalizeNumTypes(getStaticType(left));
     var rightType = _canonicalizeNumTypes(getStaticType(right));
     return isPrimitiveType(leftType) && leftType == rightType;
   }
 
   bool _isNull(Expression expr) => expr is NullLiteral;
 
   SimpleIdentifier _createTemporary(String name, DartType type,
-      {bool nullable: true, JS.Expression variable}) {
+      {bool nullable: true, JS.Expression variable, bool dynamicInvoke}) {
     // We use an invalid source location to signal that this is a temporary.
     // See [_isTemporary].
     // TODO(jmesserly): alternatives are
     // * (ab)use Element.isSynthetic, which isn't currently used for
     //   LocalVariableElementImpl, so we could repurpose to mean "temp".
     // * add a new property to LocalVariableElementImpl.
     // * create a new subtype of LocalVariableElementImpl to mark a temp.
     var id = astFactory
         .simpleIdentifier(new StringToken(TokenType.IDENTIFIER, name, -1));
 
     variable ??= new JS.TemporaryId(name);
 
     id.staticElement = new TemporaryVariableElement.forNode(id, variable);
     id.staticType = type;
-    setIsDynamicInvoke(id, type.isDynamic);
+    setIsDynamicInvoke(id, dynamicInvoke ?? type.isDynamic);
     addTemporaryVariable(id.staticElement, nullable: nullable);
     return id;
   }
 
   JS.Expression _cacheConst(JS.Expression expr()) {
     var savedTypeParams = _typeParamInConst;
     _typeParamInConst = [];
 
     var jsExpr = expr();
 
@@ skipping 74 matching lines @@
   /// variables), then the resulting code will be simplified automatically.
   ///
   /// [scope] will be mutated to contain the new temporary's initialization.
   Expression _bindValue(Map<JS.MetaLetVariable, JS.Expression> scope,
       String name, Expression expr,
       {Expression context}) {
     // No need to do anything for stateless expressions.
     if (isStateless(_currentFunction, expr, context)) return expr;
 
     var variable = new JS.MetaLetVariable(name);
-    var t = _createTemporary(name, getStaticType(expr), variable: variable);
+    var t = _createTemporary(name, getStaticType(expr),
+        variable: variable,
+        dynamicInvoke: isDynamicInvoke(expr),
+        nullable: isNullable(expr));
     scope[variable] = _visit(expr);
     return t;
   }
 
   /// Desugars postfix increment.
   ///
   /// In the general case [expr] can be one of [IndexExpression],
   /// [PrefixExpression] or [PropertyAccess] and we need to
   /// ensure sub-expressions are evaluated once.
   ///
@@ skipping 181 matching lines @@
     var tail = <JS.Expression>[];
     for (;;) {
       var op = _getOperator(node);
       if (op != null && op.lexeme == '?.') {
         var nodeTarget = _getTarget(node);
         if (!isNullable(nodeTarget)) {
           node = _stripNullAwareOp(node, nodeTarget);
           break;
         }
 
-        var param =
-            _createTemporary('_', nodeTarget.staticType, nullable: false);
+        var param = _createTemporary('_', nodeTarget.staticType,
+            nullable: false, dynamicInvoke: isDynamicInvoke(node));
         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 _callHelper(
@@ skipping 1246 matching lines @@
   if (targetIdentifier.staticElement is! PrefixElement) return false;
   var prefix = targetIdentifier.staticElement as PrefixElement;
 
   // The library the prefix is referring to must come from a deferred import.
   var containingLibrary = resolutionMap
       .elementDeclaredByCompilationUnit(target.root as CompilationUnit)
       .library;
   var imports = containingLibrary.getImportsWithPrefix(prefix);
   return imports.length == 1 && imports[0].isDeferred;
 }