dart2js cps: Keep interceptors in a separate field.

pkg/compiler/lib/src/tree_ir/tree_ir_builder.dart

 // Copyright (c) 2014, 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 tree_ir_builder;
 
 import '../common.dart';
 import '../constants/values.dart';
 import '../cps_ir/cps_ir_nodes.dart' as cps_ir;
 import '../elements/elements.dart';
 import 'package:js_ast/js_ast.dart' as js;
+import '../js_backend/codegen/glue.dart';
 
 import 'tree_ir_nodes.dart';
 
 typedef Statement NodeCallback(Statement next);
 
 /**
  * Builder translates from CPS-based IR to direct-style Tree.
  *
  * A call `Invoke(fun, cont, args)`, where cont is a singly-referenced
  * non-exit continuation `Cont(v, body)` is translated into a direct-style call
@@ skipping 19 matching lines @@
  * Block arguments are later replaced with data flow during the Tree-to-Tree
  * translation out of SSA.  Jumps are eliminated during the Tree-to-Tree
  * control-flow recognition.
  *
  * Otherwise, the output of Builder looks very much like the input.  In
  * particular, intermediate values and blocks used for local control flow are
  * still all named.
  */
 class Builder implements cps_ir.Visitor/*<NodeCallback|Node>*/ {
   final InternalErrorFunction internalError;
+  final Glue glue;
 
   final Map<cps_ir.Primitive, Variable> primitive2variable =
       <cps_ir.Primitive, Variable>{};
   final Map<cps_ir.MutableVariable, Variable> mutable2variable =
       <cps_ir.MutableVariable, Variable>{};
   final Set<cps_ir.Constant> inlinedConstants = new Set<cps_ir.Constant>();
 
   // Continuations with more than one use are replaced with Tree labels.  This
   // is the mapping from continuations to labels.
   final Map<cps_ir.Continuation, Label> labels = <cps_ir.Continuation, Label>{};
 
   ExecutableElement currentElement;
-  /// The 'this' Parameter for currentElement or the enclosing method.
+  /// The parameter to be translated to 'this'.  This can either be the receiver
+  /// parameter, the interceptor parameter, or null if the method has neither.
   cps_ir.Parameter thisParameter;
   cps_ir.Continuation returnContinuation;
 
-  Builder parent;
-
-  Builder(this.internalError, [this.parent]);
-
-  Builder createInnerBuilder() {
-    return new Builder(internalError, this);
-  }
+  Builder(this.internalError, this.glue);
 
   /// Variable used in [buildPhiAssignments] as a temporary when swapping
   /// variables.
   Variable phiTempVar;
 
   Variable addMutableVariable(cps_ir.MutableVariable irVariable) {
     assert(!mutable2variable.containsKey(irVariable));
     Variable variable = new Variable(currentElement, irVariable.hint);
     mutable2variable[irVariable] = variable;
     return variable;
   }
 
   Variable getMutableVariable(cps_ir.MutableVariable mutableVariable) {
-    if (!mutable2variable.containsKey(mutableVariable)) {
-      return parent.getMutableVariable(mutableVariable)..isCaptured = true;
-    }
     return mutable2variable[mutableVariable];
   }
 
   VariableUse getMutableVariableUse(
         cps_ir.Reference<cps_ir.MutableVariable> reference) {
     Variable variable = getMutableVariable(reference.definition);
     return new VariableUse(variable);
   }
 
   /// Obtains the variable representing the given primitive. Returns null for
@@ skipping 21 matching lines @@
 
   Expression getVariableUseOrNull(
         cps_ir.Reference<cps_ir.Primitive> reference) {
     return reference == null ? null : getVariableUse(reference);
   }
 
   Label getLabel(cps_ir.Continuation cont) {
     return labels.putIfAbsent(cont, () => new Label());
   }
 
-  Variable addFunctionParameter(cps_ir.Parameter parameter) {
-    return getVariable(parameter);
-  }
-
   FunctionDefinition buildFunction(cps_ir.FunctionDefinition node) {
     currentElement = node.element;
-    if (parent != null) {
-      // Local function's 'this' refers to enclosing method's 'this'
-      thisParameter = parent.thisParameter;
+    List<Variable> parameters = node.parameters.map(getVariable).toList();
+    if (node.interceptorParameter != null) {
+      parameters.insert(0, getVariable(node.receiverParameter));
+      thisParameter = glue.methodUsesReceiverArgument(node.element)
+          ? node.interceptorParameter
+          : node.receiverParameter;
     } else {
-      thisParameter = node.thisParameter;
+      thisParameter = node.receiverParameter;
     }
-    List<Variable> parameters =
-        node.parameters.map(addFunctionParameter).toList();
     returnContinuation = node.returnContinuation;
     phiTempVar = new Variable(node.element, null);
     Statement body = translateExpression(node.body);
     return new FunctionDefinition(node.element, parameters, body);
   }
 
   /// Returns a list of variables corresponding to the arguments to a method
   /// call or similar construct.
   ///
   /// The `readCount` for these variables will be incremented.
@@ skipping 459 matching lines @@
                         getVariableUse(node.indexRef),
                         getVariableUse(node.valueRef));
   }
 
   Expression visitInvokeStatic(cps_ir.InvokeStatic node) {
     List<Expression> arguments = translateArguments(node.argumentRefs);
     return new InvokeStatic(node.target, node.selector, arguments,
                                          node.sourceInformation);
   }
 
+  List<Expression> insertReceiverArgument(Expression receiver,
+        List<Expression> arguments) {
+    return new List<Expression>.generate(arguments.length + 1,
+        (n) => n == 0 ? receiver : arguments[n - 1],
+        growable: false);
+  }
+
   Expression visitInvokeMethod(cps_ir.InvokeMethod node) {
-    if (node.callingConvention == cps_ir.CallingConvention.OneShotIntercepted) {
-      List<Expression> arguments = new List.generate(
-          1 + node.argumentRefs.length,
-          (n) => getVariableUse(n == 0 ? node.receiverRef : node.argumentRefs[n - 1]),
-          growable: false);
-      return new OneShotInterceptor(node.selector, node.mask, arguments,
-          node.sourceInformation);
+    switch (node.callingConvention) {
+      case cps_ir.CallingConvention.Normal:
+        InvokeMethod invoke = new InvokeMethod(
+            getVariableUse(node.receiverRef),
+            node.selector,
+            node.mask,
+            translateArguments(node.argumentRefs),
+            node.sourceInformation);
+        invoke.receiverIsNotNull = !node.receiver.type.isNullable;
+        return invoke;
+
+      case cps_ir.CallingConvention.Intercepted:
+        List<Expression> arguments = insertReceiverArgument(
+            getVariableUse(node.receiverRef),
+            translateArguments(node.argumentRefs));
+        InvokeMethod invoke = new InvokeMethod(
+            getVariableUse(node.interceptorRef),
+            node.selector,
+            node.mask,
+            arguments,
+            node.sourceInformation);
+        // Sometimes we know the Dart receiver is non-null because it has been
+        // refined, which implies that the JS receiver also can not be null at
+        // the use-site.  Interceptors are not refined, so this information is
+        // not always available on the JS receiver.
+        // Also check the JS receiver's type, however, because sometimes we know
+        // an interceptor is non-null because it intercepts JSNull.
+        invoke.receiverIsNotNull =
+            !node.receiver.type.isNullable ||
+            !node.interceptor.type.isNullable;
+        return invoke;
+
+      case cps_ir.CallingConvention.DummyIntercepted:
+        List<Expression> arguments = insertReceiverArgument(
+            new Constant(new IntConstantValue(0)),
+            translateArguments(node.argumentRefs));
+        InvokeMethod invoke = new InvokeMethod(
+            getVariableUse(node.receiverRef),
+            node.selector,
+            node.mask,
+            arguments,
+            node.sourceInformation);
+        invoke.receiverIsNotNull = !node.receiver.type.isNullable;
+        return invoke;
+
+      case cps_ir.CallingConvention.OneShotIntercepted:
+        List<Expression> arguments = insertReceiverArgument(
+            getVariableUse(node.receiverRef),
+            translateArguments(node.argumentRefs));
+        return new OneShotInterceptor(
+            node.selector,
+            node.mask,
+            arguments,
+            node.sourceInformation);
     }
-    InvokeMethod invoke = new InvokeMethod(
-        getVariableUse(node.receiverRef),
-        node.selector,
-        node.mask,
-        translateArguments(node.argumentRefs),
-        node.sourceInformation);
-    // Sometimes we know the Dart receiver is non-null because it has been
-    // refined, which implies that the JS receiver also can not be null at the
-    // use-site.  Interceptors are not refined, so this information is not
-    // always available on the JS receiver.
-    // Also check the JS receiver's type, however, because sometimes we know an
-    // interceptor is non-null because it intercepts JSNull.
-    invoke.receiverIsNotNull =
-        !node.dartReceiver.type.isNullable ||
-        !node.receiver.type.isNullable;
-    return invoke;
   }
 
   Expression visitInvokeMethodDirectly(cps_ir.InvokeMethodDirectly node) {
-    Expression receiver = getVariableUse(node.receiverRef);
-    List<Expression> arguments = translateArguments(node.argumentRefs);
-    return new InvokeMethodDirectly(receiver, node.target,
-        node.selector, arguments, node.sourceInformation);
+    if (node.interceptorRef != null) {
+      return new InvokeMethodDirectly(getVariableUse(node.interceptorRef),
+          node.target,
+          node.selector,
+          insertReceiverArgument(getVariableUse(node.receiverRef),
+              translateArguments(node.argumentRefs)),
+          node.sourceInformation);
+    } else {
+      return new InvokeMethodDirectly(getVariableUse(node.receiverRef),
+          node.target,
+          node.selector,
+          translateArguments(node.argumentRefs),
+          node.sourceInformation);
+    }
   }
 
   Expression visitTypeCast(cps_ir.TypeCast node) {
     Expression value = getVariableUse(node.valueRef);
     List<Expression> typeArgs = translateArguments(node.typeArgumentRefs);
     return new TypeOperator(value, node.dartType, typeArgs, isTypeTest: false);
   }
 
   Expression visitInvokeConstructor(cps_ir.InvokeConstructor node) {
     List<Expression> arguments = translateArguments(node.argumentRefs);
@@ skipping 76 matching lines @@
 
   visitFunctionDefinition(cps_ir.FunctionDefinition node) {
     unexpectedNode(node);
   }
   visitParameter(cps_ir.Parameter node) => unexpectedNode(node);
   visitContinuation(cps_ir.Continuation node) => unexpectedNode(node);
   visitMutableVariable(cps_ir.MutableVariable node) => unexpectedNode(node);
   visitRethrow(cps_ir.Rethrow node) => unexpectedNode(node);
   visitBoundsCheck(cps_ir.BoundsCheck node) => unexpectedNode(node);
 }