cps2js: Clean up some obsolete TODOs.

pkg/compiler/lib/src/tree_ir/tree_ir_nodes.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_nodes;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' as values;
 import '../dart_types.dart' show DartType, GenericType;
 import '../elements/elements.dart';
@@ skipping 312 matching lines @@
 /// Logical negation.
 class Not extends Expression {
   Expression operand;
 
   Not(this.operand);
 
   accept(ExpressionVisitor visitor) => visitor.visitNot(this);
   accept1(ExpressionVisitor1 visitor, arg) => visitor.visitNot(this, arg);
 }
 
-class FunctionExpression extends Expression {
+class FunctionExpression extends Expression implements DartSpecificNode {
   final FunctionDefinition definition;
 
   FunctionExpression(this.definition) {
     assert(definition.element.type.returnType.treatAsDynamic);
   }
 
   accept(ExpressionVisitor visitor) => visitor.visitFunctionExpression(this);
   accept1(ExpressionVisitor1 visitor, arg) {
     return visitor.visitFunctionExpression(this, arg);
   }
 }
 
 /// Declares a local function.
 /// Used for functions that may not occur in expression context due to
 /// being recursive or having a return type.
 /// The [variable] must not occur as the left-hand side of an [Assign] or
 /// any other [FunctionDeclaration].
-class FunctionDeclaration extends Statement {
+class FunctionDeclaration extends Statement implements DartSpecificNode {
   Variable variable;
   final FunctionDefinition definition;
   Statement next;
 
   FunctionDeclaration(this.variable, this.definition, this.next) {
     ++variable.writeCount;
   }
 
   accept(StatementVisitor visitor) => visitor.visitFunctionDeclaration(this);
   accept1(StatementVisitor1 visitor, arg) {
@@ skipping 243 matching lines @@
   FunctionDefinition(this.element, this.parameters, this.body,
       this.localConstants, this.defaultParameterValues);
 
   /// Returns `true` if this function is abstract.
   ///
   /// If `true` [body] is `null` and [localConstants] is empty.
   bool get isAbstract => body == null;
   applyPass(Pass pass) => pass.rewriteFunctionDefinition(this);
 }
 
-abstract class Initializer implements Expression {}
+abstract class Initializer implements Expression, DartSpecificNode {}
 
 class FieldInitializer extends Initializer {
   final FieldElement element;
   Statement body;
   bool processed = false;
 
   FieldInitializer(this.element, this.body);
 
   accept(ExpressionVisitor visitor) => visitor.visitFieldInitializer(this);
   accept1(ExpressionVisitor1 visitor, arg) {
@@ skipping 24 matching lines @@
                         List<ConstDeclaration> localConstants,
                         List<ConstantExpression> defaultParameterValues)
       : super(element, parameters, body, localConstants,
               defaultParameterValues);
 
   applyPass(Pass pass) => pass.rewriteConstructorDefinition(this);
 }
 
 abstract class JsSpecificNode implements Node {}
 
+abstract class DartSpecificNode implements Node {}
+
 class CreateBox extends Expression implements JsSpecificNode {
   accept(ExpressionVisitor visitor) => visitor.visitCreateBox(this);
   accept1(ExpressionVisitor1 visitor, arg) => visitor.visitCreateBox(this, arg);
 }
 
 class CreateInstance extends Expression implements JsSpecificNode {
   ClassElement classElement;
   List<Expression> arguments;
 
   CreateInstance(this.classElement, this.arguments);
@@ skipping 250 matching lines @@
     visitStatement(node.next);
   }
 
   visitCreateBox(CreateBox node) {
   }
 
   visitCreateInstance(CreateInstance node) {
     node.arguments.forEach(visitExpression);
   }
 }