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 624 matching lines @@
 
   values.ConstantValue get value => expression.value;
 
   accept(Visitor visitor) => visitor.visitConstant(this);
 }
 
 class This extends Primitive {
   This();
 
   accept(Visitor visitor) => visitor.visitThis(this);
 }

[asgerf, 2015/03/18 13:28:25]

If the This class is not used anymore, then remove it.

[sra1, 2015/03/19 10:42:51]

Done.

 
 /// 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;
 
@@ skipping 43 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, parameters, body, localConstants,
-              defaultParameterValues);
+  : super(element, thisParameter, 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, parameters, defaultParameterValues);
+        super.abstract(element, null, 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 622 matching lines @@
   }
 
   void visitReifyRuntimeType(ReifyRuntimeType node) {
     visitReference(node.value);
   }
 
   void visitReadTypeVariable(ReadTypeVariable node) {
     visitReference(node.target);
   }
 }