Redo "Use an explicit 'this' parameter instead of 'This' nodes."

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 '../dart2jslib.dart' as dart2js;
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../cps_ir/cps_ir_nodes.dart' as cps_ir;
@@ skipping 49 matching lines @@
   /// A stack of singly-used labels that can be safely inlined at their use
   /// site.
   ///
   /// Code for continuations with exactly one use is inlined at the use site.
   /// This is not safe if the code is moved inside the scope of an exception
   /// handler (i.e., into a try block).  We keep a stack of singly-referenced
   /// continuations that are in scope without crossing a binding for a handler.
   List<cps_ir.Continuation> safeForInlining = <cps_ir.Continuation>[];
 
   ExecutableElement currentElement;
+  /// The 'this' Parameter for currentElement or the enclosing method.
+  cps_ir.Parameter thisParameter;
   cps_ir.Continuation returnContinuation;
 
   Builder parent;
 
   Builder(this.internalError, [this.parent]);
 
   Builder createInnerBuilder() {
     return new Builder(internalError, this);
   }
 
@@ skipping 33 matching lines @@
     while (variables.length <= primitive.registerIndex) {
       variables.add(new Variable(currentElement, primitive.hint));
     }
     return variables[primitive.registerIndex];
   }
 
   /// Obtains a reference to the tree Variable corresponding to the IR primitive
   /// referred to by [reference].
   /// This increments the reference count for the given variable, so the
   /// returned expression must be used in the tree.
-  VariableUse getVariableUse(cps_ir.Reference<cps_ir.Primitive> reference) {
+  Expression getVariableUse(cps_ir.Reference<cps_ir.Primitive> reference) {
+    if (thisParameter != null && reference.definition == thisParameter) {
+      return new This();
+    }
     Variable variable = getVariable(reference.definition);
     if (variable == null) {
       // Note: this may fail because you forgot to implement a visit-function
       // in the RegisterAllocator.
       internalError(
           CURRENT_ELEMENT_SPANNABLE,
           "Reference to ${reference.definition} has no register");
     }
     return new VariableUse(variable);
   }
@@ skipping 29 matching lines @@
   Variable addFunctionParameter(cps_ir.Definition variable) {
     if (variable is cps_ir.Parameter) {
       return getVariable(variable);
     } else {
       return addMutableVariable(variable as cps_ir.MutableVariable);
     }
   }
 
   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;
+    } else {
+      thisParameter = node.thisParameter;
+    }
     List<Variable> parameters =
         node.parameters.map(addFunctionParameter).toList();
     Statement body;
     if (!node.isAbstract) {
       returnContinuation = node.body.returnContinuation;
       phiTempVar = new Variable(node.element, null);
       body = visit(node.body);
     }
 
     return new FunctionDefinition(node.element, parameters,
         body, node.localConstants, node.defaultParameterValues);
   }
 
   ConstructorDefinition buildConstructor(cps_ir.ConstructorDefinition node) {
     currentElement = node.element;
+    thisParameter = node.thisParameter;
     List<Variable> parameters =
         node.parameters.map(addFunctionParameter).toList();
     List<Initializer> initializers;
     Statement body;
     if (!node.isAbstract) {
       initializers = node.initializers.map(visit).toList();
       returnContinuation = node.body.returnContinuation;
 
       phiTempVar = new Variable(node.element, null);
       body = visit(node.body);
@@ skipping 14 matching lines @@
     return new List<Expression>.generate(args.length,
          (int index) => getVariableUse(args[index]),
          growable: false);
   }
 
   /// Returns the list of variables corresponding to the arguments to a join
   /// continuation.
   ///
   /// The `readCount` of these variables will not be incremented. Instead,
   /// [buildPhiAssignments] will handle the increment, if necessary.
-  List<Variable> translatePhiArguments(List<cps_ir.Reference> args) {
+  /*  List<Variable> translatePhiArguments(List<cps_ir.Reference> args) {
     return new List<Variable>.generate(args.length,
          (int index) => getVariable(args[index].definition),
          growable: false);
-  }
+         }*/
 
   Statement buildContinuationAssignment(
       cps_ir.Parameter parameter,
       Expression argument,
       Statement buildRest()) {
     Variable variable = getVariable(parameter);
     Statement assignment;
     if (variable == null) {
       assignment = new ExpressionStatement(argument, null);
     } else {
       assignment = new Assign(variable, argument, null);
     }
     assignment.next = buildRest();
     return assignment;
   }
 
   /// Simultaneously assigns each argument to the corresponding parameter,
   /// then continues at the statement created by [buildRest].
   Statement buildPhiAssignments(
       List<cps_ir.Parameter> parameters,
-      List<Variable> arguments,
+      List<Expression> arguments,
       Statement buildRest()) {
     assert(parameters.length == arguments.length);
     // We want a parallel assignment to all parameters simultaneously.
     // Since we do not have parallel assignments in dart_tree, we must linearize
     // the assignments without attempting to read a previously-overwritten
     // value. For example {x,y = y,x} cannot be linearized to {x = y; y = x},
     // for this we must introduce a temporary variable: {t = x; x = y; y = t}.
 
     // [rightHand] is the inverse of [arguments], that is, it maps variables
     // to the assignments on which is occurs as the right-hand side.
     Map<Variable, List<int>> rightHand = <Variable, List<int>>{};
     for (int i = 0; i < parameters.length; i++) {
       Variable param = getVariable(parameters[i]);
-      Variable arg = arguments[i];
-      if (param == null || param == arg) {
-        continue; // No assignment necessary.
+      Expression arg = arguments[i];
+      if (arg is VariableUse) {
+        if (param == null || param == arg.variable) {
+          // No assignment necessary.
+          --arg.variable.readCount;
+          continue;
+        }
+        // v1 = v0
+        List<int> list = rightHand[arg.variable];
+        if (list == null) {
+          rightHand[arg.variable] = list = <int>[];
+        }
+        list.add(i);
+      } else {
+        // v1 = this;
       }
-      List<int> list = rightHand[arg];
-      if (list == null) {
-        rightHand[arg] = list = <int>[];
-      }
-      list.add(i);
     }
 
     Statement first, current;
-    void addAssignment(Variable dst, Variable src) {
+    void addAssignment(Variable dst, Expression src) {
       if (first == null) {
-        first = current = new Assign(dst, new VariableUse(src), null);
+        first = current = new Assign(dst, src, null);
       } else {
-        current = current.next = new Assign(dst, new VariableUse(src), null);
+        current = current.next = new Assign(dst, src, null);
       }
     }
 
-    List<Variable> assignmentSrc = new List<Variable>(parameters.length);
-    List<bool> done = new List<bool>(parameters.length);
+    List<Expression> assignmentSrc = new List<Expression>(parameters.length);
+    List<bool> done = new List<bool>.filled(parameters.length, false);
     void visitAssignment(int i) {
-      if (done[i] == true) {
+      if (done[i]) {
         return;
       }
       Variable param = getVariable(parameters[i]);
-      Variable arg = arguments[i];
-      if (param == null || param == arg) {
+      Expression arg = arguments[i];
+      if (param == null || (arg is VariableUse && param == arg.variable)) {
         return; // No assignment necessary.
       }
       if (assignmentSrc[i] != null) {
         // Cycle found; store argument in a temporary variable.
         // The temporary will then be used as right-hand side when the
         // assignment gets added.
-        if (assignmentSrc[i] != phiTempVar) { // Only move to temporary once.
-          assignmentSrc[i] = phiTempVar;
+        VariableUse source = assignmentSrc[i];
+        if (source.variable != phiTempVar) { // Only move to temporary once.
+          assignmentSrc[i] = new VariableUse(phiTempVar);
           addAssignment(phiTempVar, arg);
         }
         return;
       }
       assignmentSrc[i] = arg;
       List<int> paramUses = rightHand[param];
       if (paramUses != null) {
         for (int useIndex in paramUses) {
           visitAssignment(useIndex);
         }
       }
       addAssignment(param, assignmentSrc[i]);
       done[i] = true;
     }
 
     for (int i = 0; i < parameters.length; i++) {
-      if (done[i] == null) {
+      if (!done[i]) {
         visitAssignment(i);
       }
     }
 
     if (first == null) {
       first = buildRest();
     } else {
       current.next = buildRest();
     }
     return first;
@@ skipping 194 matching lines @@
     // Invocations of the return continuation are translated to returns.
     // Other continuation invocations are replaced with assignments of the
     // arguments to formal parameter variables, followed by the body if
     // the continuation is singly reference or a break if it is multiply
     // referenced.
     cps_ir.Continuation cont = node.continuation.definition;
     if (cont == returnContinuation) {
       assert(node.arguments.length == 1);
       return new Return(getVariableUse(node.arguments.single));
     } else {
-      List<Variable> arguments = translatePhiArguments(node.arguments);
+      List<Expression> arguments = translateArguments(node.arguments);
       return buildPhiAssignments(cont.parameters, arguments,
           () {
             // Translate invocations of recursive and non-recursive
             // continuations differently.
             //   * Non-recursive continuations
             //     - If there is one use, translate the continuation body
             //       inline at the invocation site.
             //     - If there are multiple uses, translate to Break.
             //   * Recursive continuations
             //     - There is a single non-recursive invocation.  Translate
@@ skipping 28 matching lines @@
     assert(cont.parameters.isEmpty);
     elseStatement =
         cont.hasExactlyOneUse ? visit(cont.body) : new Break(labels[cont]);
     return new If(condition, thenStatement, elseStatement);
   }
 
   Expression visitConstant(cps_ir.Constant node) {
     return new Constant(node.expression);
   }
 
-  Expression visitThis(cps_ir.This node) {
-    return new This();
-  }
-
   Expression visitReifyTypeVar(cps_ir.ReifyTypeVar node) {
     return new ReifyTypeVar(node.typeVariable);
   }
 
   Expression visitLiteralList(cps_ir.LiteralList node) {
     return new LiteralList(
             node.type,
             translateArguments(node.values));
   }
 
@@ skipping 48 matching lines @@
   }
 
   Expression visitReifyRuntimeType(cps_ir.ReifyRuntimeType node) {
     return new ReifyRuntimeType(getVariableUse(node.value));
   }
 
   Expression visitReadTypeVariable(cps_ir.ReadTypeVariable node) {
     return new ReadTypeVariable(node.variable, getVariableUse(node.target));
   }
 }