Check for extension methods when using whitelist

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;
@@ skipping 2514 matching lines @@
 
       target = _getTarget(lhs);
       id = lhs.propertyName;
     } else if (lhs is PrefixedIdentifier) {
       target = lhs.prefix;
       id = lhs.identifier;
     }
 
     if (target != null && DynamicInvoke.get(target)) {
       if (_inWhitelistCode(lhs)) {
-        return _visit(rhs).toAssignExpression(_visit(lhs));
+        var vars = <JS.MetaLetVariable, JS.Expression>{};
+        var l = _visit(_bindValue(vars, 'l', target));
+        var name = _emitMemberName(id.name);
+        return new JS.MetaLet(vars, [
+          js.call('(#[(#[dart._extensionType]) ? dartx[#] : #] = #)',
+              [l, l, name, name, _visit(rhs)])
+        ]);
       }
       return js.call('dart.dput(#, #, #)',
           [_visit(target), _emitMemberName(id.name), _visit(rhs)]);
     }
 
     return _visit(rhs).toAssignExpression(_visit(lhs));
   }
 
   JS.Expression _emitNullSafeSet(PropertyAccess node, Expression right) {
     // Emit `obj?.prop = expr` as:
@@ skipping 112 matching lines @@
       List<JS.Expression> typeArgs) {
     var type = getStaticType(target);
     var name = node.methodName.name;
     var element = node.methodName.staticElement;
     bool isStatic = element is ExecutableElement && element.isStatic;
     var memberName = _emitMemberName(name, type: type, isStatic: isStatic);
 
     JS.Expression jsTarget = _visit(target);
     if (DynamicInvoke.get(target) || DynamicInvoke.get(node.methodName)) {
       if (_inWhitelistCode(target)) {
-        jsTarget = new JS.PropertyAccess(jsTarget, memberName);
+        var vars = <JS.MetaLetVariable, JS.Expression>{};
+        var l = _visit(_bindValue(vars, 'l', target));
+        jsTarget = new JS.MetaLet(vars, [
+          js.call('(#[(#[dart._extensionType]) ? dartx[#] : #])',
+              [l, l, memberName, memberName,])
+        ]);
         if (typeArgs != null) jsTarget = new JS.Call(jsTarget, typeArgs);
         return new JS.Call(jsTarget, args);
       }
       if (typeArgs != null) {
         return js.call('dart.dgsend(#, #, #, #)',
             [jsTarget, new JS.ArrayInitializer(typeArgs), memberName, args]);
       } else {
         return js.call('dart.dsend(#, #, #)', [jsTarget, memberName, args]);
       }
     }
@@ skipping 1194 matching lines @@
     return _emitFunctionTypeArguments(type, instantiated);
   }
 
   JS.Expression _emitAccessInternal(Expression target, Element member,
       String memberName, List<JS.Expression> typeArgs) {
     bool isStatic = member is ClassMemberElement && member.isStatic;
     var name = _emitMemberName(memberName,
         type: getStaticType(target), isStatic: isStatic);
     if (DynamicInvoke.get(target)) {
       if (_inWhitelistCode(target)) {
-        return js.call('#.#', [_visit(target), name]);
+        var vars = <JS.MetaLetVariable, JS.Expression>{};
+        var l = _visit(_bindValue(vars, 'l', target));
+        return new JS.MetaLet(vars, [
+          js.call('(#[dart._extensionType]) ? #[dartx[#]] : #.#',
+              [l, l, name, l, name])
+        ]);
       }
       return js.call('dart.dload(#, #)', [_visit(target), name]);
     }
 
     var jsTarget = _visit(target);
     bool isSuper = jsTarget is JS.Super;
 
     if (isSuper && member is FieldElement && !member.isSynthetic) {
       // If super.x is actually a field, then x is an instance property since
       // subclasses cannot override x.
@@ skipping 25 matching lines @@
   /// Emits a generic send, like an operator method.
   ///
   /// **Please note** this function does not support method invocation syntax
   /// `obj.name(args)` because that could be a getter followed by a call.
   /// See [visitMethodInvocation].
   JS.Expression _emitSend(
       Expression target, String name, List<Expression> args) {
     var type = getStaticType(target);
     var memberName = _emitMemberName(name, unary: args.isEmpty, type: type);
     if (DynamicInvoke.get(target)) {
+      if (_inWhitelistCode(target)) {
+        var vars = <JS.MetaLetVariable, JS.Expression>{};
+        var l = _visit(_bindValue(vars, 'l', target));
+        return new JS.MetaLet(vars, [
+          js.call('(#[(#[dart._extensionType]) ? dartx[#] : #])(#)',
+              [l, l, memberName, memberName, _visitList(args)])
+        ]);
+        return new JS.Call(jsTarget, args);
+      }
       // dynamic dispatch
       var dynamicHelper = const {'[]': 'dindex', '[]=': 'dsetindex'}[name];
       if (dynamicHelper != null) {
         return js.call(
             'dart.$dynamicHelper(#, #)', [_visit(target), _visitList(args)]);
-      }
-      if (_inWhitelistCode(target)) {
-        return js
-            .call('#.#(#)', [_visit(target), memberName, _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 744 matching lines @@
 }
 
 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';