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

pkg/compiler/lib/src/cps_ir/cps_ir_builder.dart

 // Copyright (c) 2013, 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 dart2js.ir_builder;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' show PrimitiveConstantValue;
 import '../dart_types.dart';
 import '../dart2jslib.dart';
@@ skipping 201 matching lines @@
   final List<JumpCollector> breakCollectors = <JumpCollector>[];
 
   /// A stack of collectors for continues.
   final List<JumpCollector> continueCollectors = <JumpCollector>[];
 
   final List<ConstDeclaration> localConstants = <ConstDeclaration>[];
 
   final ExecutableElement currentElement;
 
   final ir.Continuation returnContinuation = new ir.Continuation.retrn();
+  ir.Parameter _thisParameter;
+  ir.Parameter enclosingMethodThisParameter;
 
   final List<ir.Definition> functionParameters = <ir.Definition>[];
 
   IrBuilderDelimitedState(this.constantSystem, this.currentElement);
+
+  ir.Parameter get thisParameter => _thisParameter;
+  void set thisParameter(ir.Parameter value) {
+    assert(_thisParameter == null);
+    _thisParameter = value;
+  }
+}
+
+class ThisParameterLocal implements Local {
+  final ExecutableElement executableContext;
+  ThisParameterLocal(this.executableContext);
+  String get name => 'this';
+  toString() => 'ThisParameterLocal($executableContext)';
 }
 
 /// A factory for building the cps IR.
 ///
 /// [DartIrBuilder] and [JsIrBuilder] implement nested functions and captured
 /// variables in different ways.
 abstract class IrBuilder {
   IrBuilder _makeInstance();
 
   // TODO(johnniwinther): Remove this from the [IrBuilder].
@@ skipping 53 matching lines @@
   void _enterForLoopBody(ClosureScope scope,
                          List<LocalElement> loopVariables);
 
   /// Called before building the update of a for-loop.
   void _enterForLoopUpdate(ClosureScope scope,
                            List<LocalElement> loopVariables);
 
   /// Add the given function parameter to the IR, and bind it in the environment
   /// or put it in its box, if necessary.
   void _createFunctionParameter(ParameterElement parameterElement);
+  void _createThisParameter();
 
   /// Creates an access to the receiver from the current (or enclosing) method.
   ///
   /// If inside a closure class, [buildThis] will redirect access through
   /// closure fields in order to access the receiver from the enclosing method.
   ir.Primitive buildThis();
 
   // TODO(johnniwinther): Make these field final and remove the default values
   // when [IrBuilder] is a property of [IrBuilderVisitor] instead of a mixin.
 
@@ skipping 71 matching lines @@
   IrBuilder makeRecursiveBuilder() {
     IrBuilder inner = _makeInstance()
         ..state = state
         ..environment = new Environment.empty();
     environment.index2variable.forEach(inner.createLocalParameter);
     return inner;
   }
 
   /// Construct a builder for an inner function.
   IrBuilder makeInnerFunctionBuilder(ExecutableElement currentElement) {
+    IrBuilderDelimitedState innerState =
+        new IrBuilderDelimitedState(state.constantSystem, currentElement)
+          ..enclosingMethodThisParameter = state.enclosingMethodThisParameter;
     return _makeInstance()
-        ..state = new IrBuilderDelimitedState(state.constantSystem, currentElement)
+        ..state = innerState
         ..environment = new Environment.empty();
   }
 
   bool get isOpen => _root == null || _current != null;
 
 
   void buildFieldInitializerHeader({ClosureScope closureScope}) {
     _enterScope(closureScope);
   }
 
   List<ir.Primitive> buildFunctionHeader(Iterable<ParameterElement> parameters,
                                         {ClosureScope closureScope,
                                          ClosureEnvironment env}) {
+    _createThisParameter();
     _enterClosureEnvironment(env);
     _enterScope(closureScope);
     parameters.forEach(_createFunctionParameter);
     return _parameters;
   }
 
   /// Creates a parameter for [local] and adds it to the current environment.
   ir.Parameter createLocalParameter(Local local) {
     ir.Parameter parameter = new ir.Parameter(local);
     _parameters.add(parameter);
@@ skipping 236 matching lines @@
   ir.FunctionDefinition makeFunctionDefinition(
       List<ConstantExpression> defaults) {
     FunctionElement element = state.currentElement;
     if (element.isAbstract || element.isExternal) {
       assert(invariant(element, _root == null,
           message: "Non-empty body for abstract method $element: $_root"));
       assert(invariant(element, state.localConstants.isEmpty,
           message: "Local constants for abstract method $element: "
                    "${state.localConstants}"));
       return new ir.FunctionDefinition.abstract(
-                element, state.functionParameters, defaults);
+          element, state.thisParameter, state.functionParameters, defaults);
     } else {
       ir.RunnableBody body = makeRunnableBody();
       return new ir.FunctionDefinition(
-          element, state.functionParameters, body,
+          element, state.thisParameter, state.functionParameters, body,
           state.localConstants, defaults);
     }
   }
 
   /// Create a constructor definition without a body, for representing
   /// external constructors declarations.
   ir.ConstructorDefinition makeAbstractConstructorDefinition(
       List<ConstantExpression> defaults) {
     FunctionElement element = state.currentElement;
     assert(invariant(element, _root == null,
         message: "Non-empty body for external constructor $element: $_root"));
     assert(invariant(element, state.localConstants.isEmpty,
         message: "Local constants for external constructor $element: "
                  "${state.localConstants}"));
     return new ir.ConstructorDefinition.abstract(
         element, state.functionParameters, defaults);
   }
 
   ir.ConstructorDefinition makeConstructorDefinition(
       List<ConstantExpression> defaults, List<ir.Initializer> initializers) {
     FunctionElement element = state.currentElement;
     ir.RunnableBody body = makeRunnableBody();
     return new ir.ConstructorDefinition(
-        element, state.functionParameters, body, initializers,
+        element, state.thisParameter, state.functionParameters, body, initializers,
         state.localConstants, defaults);
   }
 
   /// Create a super invocation where the method name and the argument structure
   /// are defined by [selector] and the argument values are defined by
   /// [arguments].
   ir.Primitive buildSuperInvocation(Element target,
                                     Selector selector,
                                     List<ir.Primitive> arguments);
 
@@ skipping 440 matching lines @@
     bodyBuilder._enterScope(closureScope);
     if (buildVariableDeclaration != null) {
       buildVariableDeclaration(bodyBuilder);
     }
 
     ir.Parameter currentValue = new ir.Parameter(null);
     ir.Continuation currentInvoked = new ir.Continuation([currentValue]);
     bodyBuilder.add(new ir.LetCont(currentInvoked,
         new ir.InvokeMethod(iterator, new Selector.getter("current", null),
             currentInvoked, emptyArguments)));
+    // TODO(sra): Does this cover all cases? The general setter case include
+    // super.
     if (Elements.isLocal(variableElement)) {
       bodyBuilder.buildLocalSet(variableElement, currentValue);
-    } else if (Elements.isStaticOrTopLevel(variableElement)) {
+    } else if (Elements.isStaticOrTopLevel(variableElement) ||
+               Elements.isErroneous(variableElement)) {
       bodyBuilder.buildStaticSet(
           variableElement, variableSelector, currentValue);
     } else {
       ir.Primitive receiver = bodyBuilder.buildThis();
+      assert(receiver != null);
       bodyBuilder.buildDynamicSet(receiver, variableSelector, currentValue);
     }
 
     buildBody(bodyBuilder);
     assert(state.breakCollectors.last == breakCollector);
     assert(state.continueCollectors.last == continueCollector);
     state.breakCollectors.removeLast();
     state.continueCollectors.removeLast();
 
     // Create body entry and loop exit continuations and a branch to them.
@@ skipping 863 matching lines @@
     ir.Parameter parameter = new ir.Parameter(parameterElement);
     _parameters.add(parameter);
     if (isInMutableVariable(parameterElement)) {
       state.functionParameters.add(getMutableVariable(parameterElement));
     } else {
       state.functionParameters.add(parameter);
       environment.extend(parameterElement, parameter);
     }
   }
 
+  void _createThisParameter() {
+    void create() {
+      ir.Parameter thisParameter =
+          new ir.Parameter(new ThisParameterLocal(state.currentElement));
+      state.thisParameter = thisParameter;
+      state.enclosingMethodThisParameter = thisParameter;
+    }
+    if (state.currentElement.isLocal) return;
+    if (state.currentElement.isStatic) return;
+    if (state.currentElement.isGenerativeConstructor) {
+      create();
+      return;
+    }
+    if (state.currentElement.isStatic) return;
+    if (state.currentElement.isInstanceMember) {
+      create();
+      return;
+    }
+  }
+
   void declareLocalVariable(LocalVariableElement variableElement,
                             {ir.Primitive initialValue}) {
     assert(isOpen);
     if (initialValue == null) {
       initialValue = buildNullLiteral();
     }
     if (isInMutableVariable(variableElement)) {
       add(new ir.LetMutable(getMutableVariable(variableElement),
                             initialValue));
     } else {
@@ skipping 38 matching lines @@
     assert(isOpen);
     if (isInMutableVariable(local)) {
       add(new ir.SetMutableVariable(getMutableVariable(local), value));
     } else {
       value.useElementAsHint(local);
       environment.update(local, value);
     }
     return value;
   }
 
-  ir.Primitive buildThis() => addPrimitive(new ir.This());
+  ir.Primitive buildThis() {
+    return state.enclosingMethodThisParameter;
+  }
 
   ir.Primitive buildSuperInvocation(Element target,
                                     Selector selector,
                                     List<ir.Primitive> arguments) {
     return _buildInvokeSuper(target, selector, arguments);
   }
 
 }
 
 /// State shared between JsIrBuilders within the same function.
@@ skipping 26 matching lines @@
   Map<ast.TryStatement, TryStatementInfo> get tryStatements => null;
   Set<Local> get mutableCapturedVariables => null;
   bool isInMutableVariable(Local local) => false;
   void makeMutableVariable(Local local) {}
   void removeMutableVariable(Local local) {}
 
   void _enterClosureEnvironment(ClosureEnvironment env) {
     if (env == null) return;
 
     // Obtain a reference to the function object (this).
-    ir.Primitive thisPrim = addPrimitive(new ir.This());
+    ir.Parameter thisPrim = state.thisParameter;
 
     // Obtain access to the free variables.
     env.freeVariables.forEach((Local local, ClosureLocation location) {
       if (location.isBox) {
         // Boxed variables are loaded from their box on-demand.
         jsState.boxedVariables[local] = location;
       } else {
         // Unboxed variables are loaded from the function object immediately.
         // This includes BoxLocals which are themselves unboxed variables.
         environment.extend(local,
@@ skipping 40 matching lines @@
     ClosureLocation location = jsState.boxedVariables[parameterElement];
     if (location != null) {
       add(new ir.SetField(environment.lookup(location.box),
                           location.field,
                           parameter));
     } else {
       environment.extend(parameterElement, parameter);
     }
   }
 
+  void _createThisParameter() {
+    if (Elements.isStaticOrTopLevel(state.currentElement)) return;
+    if (state.currentElement.isLocal) return;
+    state.thisParameter =
+        new ir.Parameter(new ThisParameterLocal(state.currentElement));
+  }
+
   void declareLocalVariable(LocalElement variableElement,
                             {ir.Primitive initialValue}) {
     assert(isOpen);
     if (initialValue == null) {
       initialValue = buildNullLiteral();
     }
     ClosureLocation location = jsState.boxedVariables[variableElement];
     if (location != null) {
       add(new ir.SetField(environment.lookup(location.box),
                           location.field,
@@ skipping 83 matching lines @@
     for (VariableElement loopVar in scope.boxedLoopVariables) {
       ClosureLocation location = scope.capturedVariables[loopVar];
       ir.Primitive value = addPrimitive(new ir.GetField(box, location.field));
       add(new ir.SetField(newBox, location.field, value));
     }
     environment.update(scope.box, newBox);
   }
 
   ir.Primitive buildThis() {
     if (jsState.receiver != null) return jsState.receiver;
-    return addPrimitive(new ir.This());
+    return state.thisParameter;
   }
 
   ir.Primitive buildSuperInvocation(Element target,
                                     Selector selector,
                                     List<ir.Primitive> arguments) {
     // Direct calls to FieldElements are currently problematic because the
     // backend will not issue a getter for the field unless it finds a dynamic
     // access that matches its getter.
     // As a workaround, we generate GetField for this case, although ideally
     // this should be the result of inlining the field's getter.
@@ skipping 21 matching lines @@
             receiver, target, selector, k, arguments));
   }
 
   /// Loads parameters to a constructor body into the environment.
   ///
   /// The header for a constructor body differs from other functions in that
   /// some parameters are already boxed, and the box is passed as an argument
   /// instead of being created in the header.
   void buildConstructorBodyHeader(Iterable<Local> parameters,
                                   ClosureScope closureScope) {
+    _createThisParameter();
     for (Local param in parameters) {
       ir.Parameter parameter = createLocalParameter(param);
       state.functionParameters.add(parameter);
     }
     if (closureScope != null) {
       jsState.boxedVariables.addAll(closureScope.capturedVariables);
     }
   }
 }
 
@@ skipping 59 matching lines @@
 // TODO(johnniwinther): Support passing of [DartType] for the exception.
 class CatchClauseInfo {
   final LocalVariableElement exceptionVariable;
   final LocalVariableElement stackTraceVariable;
   final SubbuildFunction buildCatchBlock;
 
   CatchClauseInfo({this.exceptionVariable,
                    this.stackTraceVariable,
                    this.buildCatchBlock});
 }