Improve parser error recovery.

dart/sdk/lib/_internal/compiler/implementation/elements/modelx.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.
 
 library elements.modelx;
 
 import 'elements.dart';
 import '../helpers/helpers.dart';
 import '../tree/tree.dart';
 import '../util/util.dart';
@@ skipping 10 matching lines @@
                                  DiagnosticListener,
                                  Script,
                                  FunctionType,
                                  Selector,
                                  Constant,
                                  Compiler,
                                  isPrivateName;
 
 import '../dart_types.dart';
 
-import '../scanner/scannerlib.dart' show Token, EOF_TOKEN;
+import '../scanner/scannerlib.dart' show
+    EOF_TOKEN,
+    ErrorToken,
+    Token;
 
 import '../ordered_typeset.dart' show OrderedTypeSet;
 
 import 'visitor.dart' show ElementVisitor;
 
 abstract class ElementX extends Element {
   static int elementHashCode = 0;
 
   final String name;
   final ElementKind kind;
@@ skipping 103 matching lines @@
   static Token findNameToken(Token token, bool isConstructor, String name,
                              String enclosingClassName) {
     // We search for the token that has the name of this element.
     // For constructors, that doesn't work because they may have
     // named formed out of multiple tokens (named constructors) so
     // for those we search for the class name instead.
     String needle = isConstructor ? enclosingClassName : name;
     // The unary '-' operator has a special element name (specified).
     if (needle == 'unary-') needle = '-';
     for (Token t = token; EOF_TOKEN != t.kind; t = t.next) {
-      if (needle == t.value) return t;
+      if (t is !ErrorToken && needle == t.value) return t;
     }
     return token;
   }
 
   CompilationUnitElement get compilationUnit {
     Element element = this;
     while (!element.isCompilationUnit) {
       element = element.enclosingElement;
     }
     return element;
@@ skipping 124 matching lines @@
 class ErroneousElementX extends ElementX implements ErroneousElement {
   final MessageKind messageKind;
   final Map messageArguments;
 
   ErroneousElementX(this.messageKind, this.messageArguments,
                     String name, Element enclosing)
       : super(name, ElementKind.ERROR, enclosing);
 
   bool get isErroneous => true;
 
+  bool get isSynthesized => true;
+
   AbstractFieldElement abstractField;
 
   unsupported() {
     throw 'unsupported operation on erroneous element';
   }
 
   Link<MetadataAnnotation> get metadata => unsupported();
   get node => unsupported();
   get type => unsupported();
   get cachedNode => unsupported();
@@ skipping 2252 matching lines @@
     assert(invariant(this, this.origin == null,
                      message: "Origin element is a patch."));
     assert(invariant(patch, patch.origin == null,
                      message: "Element is patched twice."));
     assert(invariant(patch, patch.patch == null,
                      message: "Patch element is patched."));
     this.patch = patch;
     patch.origin = this;
   }
 }