Compute pending errors for @Required named parameters.

pkg/analyzer/lib/src/dart/analysis/analysis_impl.dart

 // Copyright (c) 2017, 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.
 
 import 'package:analyzer/context/declared_variables.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/error/listener.dart';
 import 'package:analyzer/src/context/context.dart';
@@ skipping 31 matching lines @@
   StoreBasedSummaryResynthesizer _resynthesizer;
   LibraryElement _libraryElement;
 
   final Map<FileState, LineInfo> _fileToLineInfo = {};
   final Map<FileState, IgnoreInfo> _fileToIgnoreInfo = {};
 
   final Map<FileState, RecordingErrorListener> _errorListeners = {};
   final Map<FileState, ErrorReporter> _errorReporters = {};
   final List<UsedImportedElements> _usedImportedElementsList = [];
   final List<UsedLocalElements> _usedLocalElementsList = [];
+  final Map<FileState, List<PendingError>> _fileToPendingErrors = {};
   final List<ConstantEvaluationTarget> _constants = [];
 
   AnalyzerImpl(this._analysisOptions, this._declaredVariables,
       this._sourceFactory, this._fsState, this._store, this._library);
 
   /**
    * Compute analysis results for all units of the library.
    */
   Map<FileState, UnitAnalysisResult> analyze() {
     Map<FileState, CompilationUnit> units = {};
@@ skipping 16 matching lines @@
           _context, _sourceFactory, _analysisOptions.strongMode, _store);
       _typeProvider = _resynthesizer.typeProvider;
       _context.typeProvider = _typeProvider;
 
       _libraryElement = _resynthesizer.getLibraryElement(_library.uriStr);
 
       _resolveDirectives(units);
 
       units.forEach((file, unit) {
         _resolveFile(file, unit);
+        _computePendingMissingRequiredParameters(file, unit);
       });
 
       _computeConstants();
 
       units.forEach((file, unit) {
         {
           var visitor = new GatherUsedLocalElementsVisitor(_libraryElement);
           unit.accept(visitor);
           _usedLocalElementsList.add(visitor.usedElements);
         }
@@ skipping 37 matching lines @@
       nodeMap[constant] = node;
     }
 
     for (_ConstantNode node in nodes) {
       if (!node.isEvaluated) {
         new _ConstantWalker(evaluationEngine).walk(node);
       }
     }
   }
 
+  void _computePendingMissingRequiredParameters(
+      FileState file, CompilationUnit unit) {
+    // TODO(scheglov) This can be done without "pending" if we resynthesize.
+    var computer = new RequiredConstantsComputer(file.source);
+    unit.accept(computer);
+    _constants.addAll(computer.requiredConstants);
+    _fileToPendingErrors[file] = computer.pendingErrors;
+  }
+
   void _computeVerifyErrorsAndHints(FileState file, CompilationUnit unit) {
     RecordingErrorListener errorListener = _getErrorListener(file);
     CompilationUnitElement unitElement = unit.element;
 
     //
-    // Use the ErrorVerifier to compute errors.
+    // Convert the pending errors into actual errors.
     //
-    List<PendingError> pendingErrors;
-    {
-      RequiredConstantsComputer computer =
-          new RequiredConstantsComputer(file.source);
-      unit.accept(computer);
-      pendingErrors = computer.pendingErrors;
-      List<ConstantEvaluationTarget> requiredConstants =
-          computer.requiredConstants;
+    for (PendingError pendingError in _fileToPendingErrors[file]) {
+      errorListener.onError(pendingError.toAnalysisError());
     }
 
     if (_analysisOptions.strongMode) {
       AnalysisOptionsImpl options = _analysisOptions as AnalysisOptionsImpl;
       CodeChecker checker = new CodeChecker(
           _typeProvider,
           new StrongTypeSystemImpl(_typeProvider,
               implicitCasts: options.implicitCasts,
               nonnullableTypes: options.nonnullableTypes),
           errorListener,
@@ skipping 20 matching lines @@
     //
     ErrorVerifier errorVerifier = new ErrorVerifier(
         errorReporter,
         _libraryElement,
         _typeProvider,
         new InheritanceManager(_libraryElement),
         _analysisOptions.enableSuperMixins);
     unit.accept(errorVerifier);
 
     //
-    // Convert the pending errors into actual errors.
-    //
-    for (PendingError pendingError in pendingErrors) {
-      errorListener.onError(pendingError.toAnalysisError());
-    }
-
-    //
     // Find dead code.
     //
     unit.accept(
         new DeadCodeVerifier(errorReporter, typeSystem: _context.typeSystem));
 
     // Dart2js analysis.
     if (_analysisOptions.dart2jsHint) {
       unit.accept(new Dart2JSVerifier(errorReporter));
     }
 
@@ skipping 521 matching lines @@
 }
 
 /**
  * Either the name or the source associated with a part-of directive.
  */
 class _NameOrSource {
   final String name;
   final Source source;
   _NameOrSource(this.name, this.source);
 }