Improve parser error recovery.

dart/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 190 matching lines @@
   TypeAnnotation asTypeAnnotation() => null;
   TypeVariable asTypeVariable() => null;
   Typedef asTypedef() => null;
   VariableDefinitions asVariableDefinitions() => null;
   While asWhile() => null;
 
   bool isValidBreakTarget() => false;
   bool isValidContinueTarget() => false;
   bool isThis() => false;
   bool isSuper() => false;
+
+  bool get isErroneous => false;
 }
 
 class ClassNode extends Node {
   final Modifiers modifiers;
   final Identifier name;
   final Node superclass;
   final NodeList interfaces;
   final NodeList typeParameters;
   final NodeList body;
 
@@ skipping 91 matching lines @@
   Statement();
 
   Statement asStatement() => this;
 
   // TODO(ahe): make class abstract instead of adding an abstract method.
   accept(Visitor visitor);
 
   bool isValidBreakTarget() => true;
 }
 
-/// Errorneous expression that behaves as a literal null.
+/// Erroneous expression that behaves as a literal null.
 class ErrorExpression extends LiteralNull {
   ErrorExpression(token)
       : super(token);
 
   ErrorExpression asErrorExpression() => this;
+
+  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 {
@@ skipping 70 matching lines @@
     return firstBeginToken(receiver, selector);
   }
 
   Token getEndToken() {
     if (isPrefix) {
       if (receiver != null) return receiver.getEndToken();
       if (selector != null) return selector.getEndToken();
       return null;
     }
     if (!isPostfix && argumentsNode != null) {
-      return argumentsNode.getEndToken();
+      Token token = argumentsNode.getEndToken();
+      if (token != null) return token;
     }
     if (selector != null) return selector.getEndToken();
-    return receiver.getBeginToken();
+    return getBeginToken();
   }
 
   Send copyWithReceiver(Node newReceiver) {
     assert(receiver == null);
     return new Send(newReceiver, selector, argumentsNode);
   }
 }
 
 class Postfix extends NodeList {
   Postfix() : super(null, const Link<Node>());
@@ skipping 119 matching lines @@
      }
     return endToken;
   }
 
   Token getEndToken() {
     if (endToken != null) return endToken;
     if (nodes != null) {
       Link<Node> link = nodes;
       if (link.isEmpty) return beginToken;
       while (!link.tail.isEmpty) link = link.tail;
-      if (link.head.getEndToken() != null) return link.head.getEndToken();
-      if (link.head.getBeginToken() != null) return link.head.getBeginToken();
+      Node lastNode = link.head;
+      if (lastNode != null) {
+        if (lastNode.getEndToken() != null) return lastNode.getEndToken();
+        if (lastNode.getBeginToken() != null) return lastNode.getBeginToken();
+      }
     }
     return beginToken;
   }
 }
 
 class Block extends Statement {
   final NodeList statements;
 
   Block(this.statements);
 
@@ skipping 1534 matching lines @@
 }
 
 class IsInterpolationVisitor extends Visitor<bool> {
   const IsInterpolationVisitor();
   bool visitNode(Node node) => false;
   bool visitStringInterpolation(StringInterpolation node) => true;
   bool visitStringJuxtaposition(StringJuxtaposition node)
       => node.isInterpolation;
 }
 
+/// Erroneous node used to recover from parser errors.  Implements various
+/// interfaces and provides bare minimum of implementation to avoid unnecessary
+/// messages.
+class ErrorNode
+    extends Node
+    implements FunctionExpression, VariableDefinitions, Typedef {
+  final Token token;
+  final String reason;
+  final Identifier name;
+  final NodeList definitions;
+
+  ErrorNode.internal(this.token, this.reason, this.name, this.definitions);
+
+  factory ErrorNode(Token token, String reason) {
+    Identifier name = new Identifier(token);
+    NodeList definitions = new NodeList(
+        null, const Link<Node>().prepend(name), null, null);
+    return new ErrorNode.internal(token, reason, name, definitions);
+  }
+
+  Token get beginToken => token;
+  Token get endToken => token;
+
+  Token getBeginToken() => token;
+
+  Token getEndToken() => token;
+
+  accept(Visitor visitor) {}
+
+  visitChildren(Visitor visitor) {}
+
+  bool get isErroneous => true;
+
+  // FunctionExpression.
+  get parameters => null;
+  get body => null;
+  get returnType => null;
+  get modifiers => Modifiers.EMPTY;
+  get initializers => null;
+  get getOrSet => null;
+  get isRedirectingFactory => false;
+  bool hasBody() => false;
+  bool hasEmptyBody() => false;
+
+  // VariableDefinitions.
+  get metadata => null;
+  get type => null;
+
+  // Typedef.
+  get typeParameters => null;
+  get formals => null;
+  get typedefKeyword => null;
+}