Issue 23010. Compute constant and report related errors during incremental resolution.

pkg/analyzer/lib/src/generated/incremental_resolver.dart

 // Copyright (c) 2014, 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 engine.incremental_resolver;
 
 import 'dart:collection';
 import 'dart:math' as math;
 
+import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/services/lint.dart';
 
 import 'ast.dart';
 import 'element.dart';
 import 'engine.dart';
 import 'error.dart';
 import 'error_verifier.dart';
 import 'incremental_logger.dart' show logger, LoggingTimer;
 import 'java_engine.dart';
 import 'parser.dart';
@@ skipping 856 matching lines @@
       AstNode rootNode = _findResolutionRoot(node);
       _prepareResolutionContext(rootNode);
       // update elements
       _updateElementNameOffsets();
       _buildElements(rootNode);
       if (!_canBeIncrementallyResolved(rootNode)) {
         return false;
       }
       // resolve
       _resolveReferences(rootNode);
+      _computeConstants(rootNode);
+      _resolveErrors = errorListener.getErrorsForSource(_source);
       // verify
       _verify(rootNode);
       _context.invalidateLibraryHints(_librarySource);
       _generateLints(rootNode);
       // update entry errors
       _updateEntry();
       // OK
       return true;
     } finally {
       logger.exit();
@@ skipping 55 matching lines @@
   bool _canBeResolved(AstNode node) => node is ClassDeclaration ||
       node is ClassTypeAlias ||
       node is CompilationUnit ||
       node is ConstructorDeclaration ||
       node is FunctionDeclaration ||
       node is FunctionTypeAlias ||
       node is MethodDeclaration ||
       node is TopLevelVariableDeclaration;
 
   /**
+   * Compute a value for all of the constants in the given [node].
+   */
+  void _computeConstants(AstNode node) {
+    // compute values
+    {
+      CompilationUnit unit = node.getAncestor((n) => n is CompilationUnit);
+      ConstantValueComputer computer =
+          new ConstantValueComputer(_typeProvider, _context.declaredVariables);
+      computer.add(unit);
+      computer.computeValues();
+    }
+    // validate
+    {
+      ErrorReporter errorReporter = new ErrorReporter(errorListener, _source);
+      ConstantVerifier constantVerifier =
+          new ConstantVerifier(errorReporter, _definingLibrary, _typeProvider);
+      node.accept(constantVerifier);
+    }
+  }
+
+  /**
    * Starting at [node], find the smallest AST node that can be resolved
    * independently of any other nodes. Return the node that was found.
    *
    * [node] - the node at which the search is to begin
    *
    * Throws [AnalysisException] if there is no such node.
    */
   AstNode _findResolutionRoot(AstNode node) {
     while (node != null) {
       if (_canBeResolved(node)) {
@@ skipping 63 matching lines @@
           visitor.visitClassDeclarationIncrementally(
               _resolutionContext.enclosingClassDeclaration);
         }
         if (node is Comment) {
           visitor.resolveOnlyCommentInFunctionBody = true;
           node = node.parent;
         }
         visitor.initForIncrementalResolution();
         node.accept(visitor);
       }
-      // remember errors
-      _resolveErrors = errorListener.getErrorsForSource(_source);
     } finally {
       timer.stop('resolve references');
     }
   }
 
   void _shiftEntryErrors() {
     _shiftErrors(DartEntry.RESOLUTION_ERRORS);
     _shiftErrors(DartEntry.VERIFICATION_ERRORS);
     _shiftErrors(DartEntry.HINTS);
     _shiftErrors(DartEntry.LINTS);
@@ skipping 760 matching lines @@
   @override
   String toString() => name;
 }
 
 class _TokenPair {
   final _TokenDifferenceKind kind;
   final Token oldToken;
   final Token newToken;
   _TokenPair(this.kind, this.oldToken, this.newToken);
 }