Ignore recoverable parser errors in outline_builder to avoid double reporting.

pkg/front_end/lib/src/fasta/source/outline_builder.dart

 // Copyright (c) 2016, 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 fasta.outline_builder;
 
 import 'package:kernel/ast.dart' show ProcedureKind;
 
 import '../fasta_codes.dart' show FastaMessage, codeExpectedBlockToSkip;
 
@@ skipping 32 matching lines @@
   Abstract,
   Regular,
   RedirectingFactoryBody,
 }
 
 class OutlineBuilder extends UnhandledListener {
   final SourceLibraryBuilder library;
 
   final bool enableNative;
 
+  /// When true, recoverable parser errors are silently ignored. This is
+  /// because they will be reported by the BodyBuilder later. However, typedefs
+  /// are fully compiled by the outline builder, so parser errors are turned on
+  /// when parsing typedefs.
+  bool silenceParserErrors = true;
+
   String nativeMethodName;
 
   OutlineBuilder(SourceLibraryBuilder library)
       : library = library,
         enableNative = library.loader.target.enableNative(library);
 
   @override
   Uri get uri => library.fileUri;
 
   @override
@@ skipping 527 matching lines @@
     String name = pop();
     List<MetadataBuilder> metadata = pop();
     library.addEnum(metadata, name, constantNamesAndOffsets, charOffset,
         endBrace.charOffset);
     checkEmpty(enumKeyword.charOffset);
   }
 
   @override
   void beginFunctionTypeAlias(Token token) {
     library.beginNestedDeclaration(null, hasMembers: false);
+    silenceParserErrors = false;
   }
 
   @override
   void handleFunctionType(Token functionToken, Token endToken) {
     debugEvent("FunctionType");
     List<FormalParameterBuilder> formals = pop();
     pop(); // formals offset
     List<TypeVariableBuilder> typeVariables = pop();
     TypeBuilder returnType = pop();
     push(library.addFunctionType(
@@ skipping 32 matching lines @@
       } else {
         // TODO(ahe): Improve this error message.
         library.addCompileTimeError(
             equals.charOffset, "Can't create typedef from non-function type.");
       }
     }
     List<MetadataBuilder> metadata = pop();
     library.addFunctionTypeAlias(
         metadata, returnType, name, typeVariables, formals, charOffset);
     checkEmpty(typedefKeyword.charOffset);
+    silenceParserErrors = true;
   }
 
   @override
   void endTopLevelFields(int count, Token beginToken, Token endToken) {
     debugEvent("endTopLevelFields");
     List fieldsInfo = popList(count * 4);
     TypeBuilder type = pop();
     int modifiers = Modifier.validate(pop());
     List<MetadataBuilder> metadata = pop();
     library.addFields(metadata, modifiers, type, fieldsInfo);
@@ skipping 146 matching lines @@
     push(new Modifier.fromString(token.stringValue));
   }
 
   @override
   void handleModifiers(int count) {
     debugEvent("Modifiers");
     push(popList(count) ?? NullValue.Modifiers);
   }
 
   @override
+  void handleRecoverableError(Token token, FastaMessage message) {
+    if (silenceParserErrors) {
+      debugEvent("RecoverableError");
+    } else {
+      super.handleRecoverableError(token, message);
+    }
+  }
+
+  @override
   Token handleUnrecoverableError(Token token, FastaMessage message) {
     if (enableNative && message.code == codeExpectedBlockToSkip) {
       var target = library.loader.target;
       Token recover = target.skipNativeClause(token);
       if (recover != null) {
         nativeMethodName = target.extractNativeMethodName(token);
         return recover;
       }
     }
     return super.handleUnrecoverableError(token, message);
   }
 
   @override
   void addCompileTimeErrorFromMessage(FastaMessage message) {
     library.addCompileTimeError(message.charOffset, message.message,
         fileUri: message.uri);
   }
 
   @override
   Link<Token> handleMemberName(Link<Token> identifiers) {
     if (!enableNative || identifiers.isEmpty) return identifiers;
     return removeNativeClause(identifiers);
   }
 
   @override
   void debugEvent(String name) {
     // printEvent(name);
   }
 }