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

pkg/compiler/lib/src/cps_ir/cps_ir_nodes.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.
 
 // IrNodes are kept in a separate library to have precise control over their
 // dependencies on other parts of the system.
 library dart2js.ir_nodes;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' as values show ConstantValue;
@@ skipping 620 matching lines @@
 class Constant extends Primitive {
   final ConstantExpression expression;
 
   Constant(this.expression);
 
   values.ConstantValue get value => expression.value;
 
   accept(Visitor visitor) => visitor.visitConstant(this);
 }
 
+class This extends Primitive {
+  This();
+
+  accept(Visitor visitor) => visitor.visitThis(this);
+}
+
 /// Reify the given type variable as a [Type].
 /// This depends on the current binding of 'this'.
 class ReifyTypeVar extends Primitive implements DartSpecificNode {
   final TypeVariableElement typeVariable;
 
   ReifyTypeVar(this.typeVariable);
 
   values.ConstantValue get constant => null;
 
   accept(Visitor visitor) => visitor.visitReifyTypeVar(this);
@@ skipping 42 matching lines @@
     super.hint = hint;
   }
 
   // In addition to a parent pointer to the containing Continuation or
   // FunctionDefinition, parameters have an index into the list of parameters
   // bound by the parent.  This gives constant-time access to the continuation
   // from the parent.
   int parentIndex;
 
   accept(Visitor visitor) => visitor.visitParameter(this);
-
-  String toString() => 'Parameter(${hint == null ? null : hint.name})';
 }
 
 /// Continuations are normally bound by 'let cont'.  A continuation with one
 /// parameter and no body is used to represent a function's return continuation.
 /// The return continuation is bound by the Function, not by 'let cont'.
 class Continuation extends Definition<Continuation> implements InteriorNode {
   final List<Parameter> parameters;
   Expression body = null;
 
   // In addition to a parent pointer to the containing LetCont, continuations
@@ skipping 71 matching lines @@
   final Continuation returnContinuation;
   RunnableBody(this.body, this.returnContinuation);
   accept(Visitor visitor) => visitor.visitRunnableBody(this);
 }
 
 /// A function definition, consisting of parameters and a body.  The parameters
 /// include a distinguished continuation parameter (held by the body).
 class FunctionDefinition extends Node
     implements ExecutableDefinition {
   final FunctionElement element;
-  final Parameter thisParameter;
   /// Mixed list of [Parameter]s and [MutableVariable]s.
   final List<Definition> parameters;
   final RunnableBody body;
   final List<ConstDeclaration> localConstants;
 
   /// Values for optional parameters.
   final List<ConstantExpression> defaultParameterValues;
 
   FunctionDefinition(this.element,
-      this.thisParameter,
       this.parameters,
       this.body,
       this.localConstants,
       this.defaultParameterValues);
 
   FunctionDefinition.abstract(this.element,
-                              this.thisParameter,
                               this.parameters,
                               this.defaultParameterValues)
       : body = null,
         localConstants = const <ConstDeclaration>[];
 
   accept(Visitor visitor) => visitor.visitFunctionDefinition(this);
   applyPass(Pass pass) => pass.rewriteFunctionDefinition(this);
 
   /// Returns `true` if this function is abstract or external.
   ///
@@ skipping 16 matching lines @@
   final List<RunnableBody> arguments;
   final Selector selector;
   SuperInitializer(this.target, this.arguments, this.selector);
   accept(Visitor visitor) => visitor.visitSuperInitializer(this);
 }
 
 class ConstructorDefinition extends FunctionDefinition {
   final List<Initializer> initializers;
 
   ConstructorDefinition(ConstructorElement element,
-                        Definition thisParameter, // only Dart
                         List<Definition> parameters,
                         RunnableBody body,
                         this.initializers,
                         List<ConstDeclaration> localConstants,
                         List<ConstantExpression> defaultParameterValues)
-  : super(element, thisParameter, parameters, body, localConstants,
-          defaultParameterValues);
+      : super(element, parameters, body, localConstants,
+              defaultParameterValues);
 
   // 'Abstract' here means "has no body" and is used to represent external
   // constructors.
   ConstructorDefinition.abstract(
       ConstructorElement element,
       List<Definition> parameters,
       List<ConstantExpression> defaultParameterValues)
       : initializers = null,
-        super.abstract(element, null, parameters, defaultParameterValues);
+        super.abstract(element, parameters, defaultParameterValues);
 
   accept(Visitor visitor) => visitor.visitConstructorDefinition(this);
   applyPass(Pass pass) => pass.rewriteConstructorDefinition(this);
 }
 
 /// Converts the internal representation of a type to a Dart object of type
 /// [Type].
 class ReifyRuntimeType extends Primitive implements JsSpecificNode {
   /// Reference to the internal representation of a type (as produced, for
   /// example, by [ReadTypeVariable]).
@@ skipping 53 matching lines @@
   T visitConcatenateStrings(ConcatenateStrings node);
   T visitBranch(Branch node);
   T visitTypeOperator(TypeOperator node);
   T visitSetMutableVariable(SetMutableVariable node);
   T visitDeclareFunction(DeclareFunction node);
 
   // Definitions.
   T visitLiteralList(LiteralList node);
   T visitLiteralMap(LiteralMap node);
   T visitConstant(Constant node);
+  T visitThis(This node);
   T visitReifyTypeVar(ReifyTypeVar node);
   T visitCreateFunction(CreateFunction node);
   T visitGetMutableVariable(GetMutableVariable node);
   T visitParameter(Parameter node);
   T visitContinuation(Continuation node);
   T visitMutableVariable(MutableVariable node);
 
   // JavaScript specific nodes.
 
   // Conditions.
@@ skipping 32 matching lines @@
   visitFieldDefinition(FieldDefinition node) {
     processFieldDefinition(node);
     if (node.hasInitializer) {
       visit(node.body);
     }
   }
 
   processFunctionDefinition(FunctionDefinition node) {}
   visitFunctionDefinition(FunctionDefinition node) {
     processFunctionDefinition(node);
-    if (node.thisParameter != null) visit(node.thisParameter);
     node.parameters.forEach(visit);
     if (!node.isAbstract) {
       visit(node.body);
     }
   }
 
   processConstructorDefinition(ConstructorDefinition node) {}
   visitConstructorDefinition(ConstructorDefinition node) {
     processConstructorDefinition(node);
-    if (node.thisParameter != null) visit(node.thisParameter);
     node.parameters.forEach(visit);
     node.initializers.forEach(visit);
     visit(node.body);
   }
 
   processFieldInitializer(FieldInitializer node) {}
   visitFieldInitializer(FieldInitializer node) {
     processFieldInitializer(node);
     visit(node.body);
   }
@@ skipping 123 matching lines @@
     processLiteralMap(node);
     for (LiteralMapEntry entry in node.entries) {
       processReference(entry.key);
       processReference(entry.value);
     }
   }
 
   processConstant(Constant node) {}
   visitConstant(Constant node) => processConstant(node);
 
+  processThis(This node) {}
+  visitThis(This node) => processThis(node);
+
   processReifyTypeVar(ReifyTypeVar node) {}
   visitReifyTypeVar(ReifyTypeVar node) => processReifyTypeVar(node);
 
   processCreateFunction(CreateFunction node) {}
   visitCreateFunction(CreateFunction node) {
     processCreateFunction(node);
     visit(node.definition);
   }
 
   processMutableVariable(node) {}
@@ skipping 256 matching lines @@
     }
   }
 
   void visitTypeOperator(TypeOperator node) {
     visitReference(node.receiver);
   }
 
   void visitConstant(Constant node) {
   }
 
+  void visitThis(This node) {
+  }
+
   void visitReifyTypeVar(ReifyTypeVar node) {
   }
 
   void visitCreateFunction(CreateFunction node) {
     new RegisterAllocator(internalError).visit(node.definition);
   }
 
   void visitGetMutableVariable(GetMutableVariable node) {
   }
 
@@ skipping 62 matching lines @@
   }
 
   void visitReifyRuntimeType(ReifyRuntimeType node) {
     visitReference(node.value);
   }
 
   void visitReadTypeVariable(ReadTypeVariable node) {
     visitReference(node.target);
   }
 }