Mix in [TreeElementMixin] only on nodes that need it.

sdk/lib/_internal/compiler/implementation/tree/nodes.dart

 // Copyright (c) 2012, 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.
 
 part of tree;
 
 abstract class Visitor<R> {
   const Visitor();
 
   R visitNode(Node node);
@@ skipping 47 matching lines @@
   R visitNewExpression(NewExpression node) => visitExpression(node);
   R visitNodeList(NodeList node) => visitNode(node);
   R visitOperator(Operator node) => visitIdentifier(node);
   R visitParenthesizedExpression(ParenthesizedExpression node) {
     return visitExpression(node);
   }
   R visitPart(Part node) => visitLibraryTag(node);
   R visitPartOf(PartOf node) => visitNode(node);
   R visitPostfix(Postfix node) => visitNodeList(node);
   R visitPrefix(Prefix node) => visitNodeList(node);
+  R visitRedirectingFactoryBody(RedirectingFactoryBody node) {
+    return visitStatement(node);
+  }
   R visitRethrow(Rethrow node) => visitStatement(node);
   R visitReturn(Return node) => visitStatement(node);
   R visitSend(Send node) => visitExpression(node);
   R visitSendSet(SendSet node) => visitSend(node);
   R visitStatement(Statement node) => visitNode(node);
   R visitStringNode(StringNode node) => visitExpression(node);
   R visitStringInterpolation(StringInterpolation node) => visitStringNode(node);
   R visitStringInterpolationPart(StringInterpolationPart node) {
     return visitNode(node);
   }
@@ skipping 25 matching lines @@
  * A node in a syntax tree.
  *
  * The abstract part of "abstract syntax tree" is invalidated when
  * supporting tools such as code formatting. These tools need concrete
  * syntax such as parentheses and no constant folding.
  *
  * We support these tools by storing additional references back to the
  * token stream. These references are stored in fields ending with
  * "Token".
  */
-abstract class Node extends TreeElementMixin implements Spannable {
+abstract class Node extends NullTreeElementMixin implements Spannable {
   final int hashCode;
   static int _HASH_COUNTER = 0;
 
   Node() : hashCode = ++_HASH_COUNTER;
 
   accept(Visitor visitor);
 
   visitChildren(Visitor visitor);
 
   /**
@@ skipping 54 matching lines @@
   MixinApplication asMixinApplication() => null;
   Modifiers asModifiers() => null;
   NamedArgument asNamedArgument() => null;
   NamedMixinApplication asNamedMixinApplication() => null;
   NewExpression asNewExpression() => null;
   NodeList asNodeList() => null;
   Operator asOperator() => null;
   ParenthesizedExpression asParenthesizedExpression() => null;
   Part asPart() => null;
   PartOf asPartOf() => null;
+  RedirectingFactoryBody asRedirectingFactoryBody() => null;
   Rethrow asRethrow() => null;
   Return asReturn() => null;
   Send asSend() => null;
   SendSet asSendSet() => null;
   Statement asStatement() => null;
   StringInterpolation asStringInterpolation() => null;
   StringInterpolationPart asStringInterpolationPart() => null;
   StringJuxtaposition asStringJuxtaposition() => null;
   StringNode asStringNode() => null;
   SwitchCase asSwitchCase() => null;
@@ skipping 133 matching lines @@
   bool get isErroneous => true;
 }
 
 /**
  * A message send aka method invocation. In Dart, most operations can
  * (and should) be considered as message sends. Getters and setters
  * are just methods with a special syntax. Consequently, we model
  * property access, assignment, operators, and method calls with this
  * one node.
  */
-class Send extends Expression {
+class Send extends Expression with StoredTreeElementMixin {
   final Node receiver;
   final Node selector;
   final NodeList argumentsNode;
   Link<Node> get arguments => argumentsNode.nodes;
 
   Send([this.receiver, this.selector, this.argumentsNode]);
   Send.postfix(this.receiver, this.selector, [Node argument = null])
       : argumentsNode = (argument == null)
         ? new Postfix()
         : new Postfix.singleton(argument);
@@ skipping 342 matching lines @@
   FunctionDeclaration asFunctionDeclaration() => this;
 
   accept(Visitor visitor) => visitor.visitFunctionDeclaration(this);
 
   visitChildren(Visitor visitor) => function.accept(visitor);
 
   Token getBeginToken() => function.getBeginToken();
   Token getEndToken() => function.getEndToken();
 }
 
-class FunctionExpression extends Expression {
+class FunctionExpression extends Expression with StoredTreeElementMixin {
   final Node name;
 
   /**
    * List of VariableDefinitions or NodeList.
    *
    * A NodeList can only occur at the end and holds named parameters.
    */
   final NodeList parameters;
 
   final Statement body;
   final TypeAnnotation returnType;
   final Modifiers modifiers;
   final NodeList initializers;
 
   final Token getOrSet;
 
   FunctionExpression(this.name, this.parameters, this.body, this.returnType,
                      this.modifiers, this.initializers, this.getOrSet) {
     assert(modifiers != null);
   }
 
   FunctionExpression asFunctionExpression() => this;
 
   accept(Visitor visitor) => visitor.visitFunctionExpression(this);
 
   bool get isRedirectingFactory {
-    return body != null && body.asReturn() != null &&
-        body.asReturn().isRedirectingFactoryBody;
+    return body != null && body.asRedirectingFactoryBody() != null;
   }
 
   visitChildren(Visitor visitor) {
     if (modifiers != null) modifiers.accept(visitor);
     if (returnType != null) returnType.accept(visitor);
     if (name != null) name.accept(visitor);
     if (parameters != null) parameters.accept(visitor);
     if (initializers != null) initializers.accept(visitor);
     if (body != null) body.accept(visitor);
   }
@@ skipping 225 matching lines @@
 
   Token getEndToken() => identifiers.getEndToken();
 
   String get slowNameString {
     Unparser unparser = new Unparser();
     unparser.unparseNodeListOfIdentifiers(identifiers);
     return unparser.result;
   }
 }
 
-class Identifier extends Expression {
+class Identifier extends Expression with StoredTreeElementMixin {
   final Token token;
 
   String get source => token.value;
 
   Identifier(Token this.token);
 
   bool isThis() => identical(source, 'this');
 
   bool isSuper() => identical(source, 'super');
 
@@ skipping 26 matching lines @@
   final Node expression;
   final Token beginToken;
   final Token endToken;
 
   Return(this.beginToken, this.endToken, this.expression);
 
   Return asReturn() => this;
 
   bool get hasExpression => expression != null;
 
-  bool get isRedirectingFactoryBody => beginToken.stringValue == '=';
-
   accept(Visitor visitor) => visitor.visitReturn(this);
 
   visitChildren(Visitor visitor) {
     if (expression != null) expression.accept(visitor);
   }
 
   Token getBeginToken() => beginToken;
 
   Token getEndToken() {
     if (endToken == null) return expression.getEndToken();
     return endToken;
   }
 }
 
+class RedirectingFactoryBody extends Statement with StoredTreeElementMixin {
+  final Node constructorReference;
+  final Token beginToken;
+  final Token endToken;
+
+  RedirectingFactoryBody(this.beginToken, this.endToken,
+                         this.constructorReference);
+
+  RedirectingFactoryBody asRedirectingFactoryBody() => this;
+
+  accept(Visitor visitor) => visitor.visitRedirectingFactoryBody(this);
+
+  visitChildren(Visitor visitor) {
+    constructorReference.accept(visitor);
+  }
+
+  Token getBeginToken() => beginToken;
+
+  Token getEndToken() => endToken;
+}
+
 class ExpressionStatement extends Statement {
   final Expression expression;
   final Token endToken;
 
   ExpressionStatement(this.expression, this.endToken);
 
   ExpressionStatement asExpressionStatement() => this;
 
   accept(Visitor visitor) => visitor.visitExpressionStatement(this);
 
@@ skipping 607 matching lines @@
 
 class ContinueStatement extends GotoStatement {
   ContinueStatement(Identifier target, Token keywordToken, Token semicolonToken)
     : super(target, keywordToken, semicolonToken);
 
   ContinueStatement asContinueStatement() => this;
 
   accept(Visitor visitor) => visitor.visitContinueStatement(this);
 }
 
-class ForIn extends Loop {
+class ForIn extends Loop with StoredTreeElementMixin {
   final Node declaredIdentifier;
   final Expression expression;
 
   final Token forToken;
   final Token inToken;
 
   ForIn(this.declaredIdentifier, this.expression,
         Statement body, this.forToken, this.inToken) : super(body);
 
   Expression get condition => null;
@@ skipping 476 matching lines @@
 
   // VariableDefinitions.
   get metadata => null;
   get type => null;
 
   // Typedef.
   get typeParameters => null;
   get formals => null;
   get typedefKeyword => null;
 }