Compute constants in non-task analyzer.

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/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.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';
 import 'package:analyzer/src/dart/analysis/file_state.dart';
 import 'package:analyzer/src/dart/ast/ast.dart';
+import 'package:analyzer/src/dart/constant/evaluation.dart';
+import 'package:analyzer/src/dart/constant/utilities.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/scanner/scanner.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/error/pending_error.dart';
 import 'package:analyzer/src/generated/declaration_resolver.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error_verifier.dart';
 import 'package:analyzer/src/generated/parser.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/summary/package_bundle_reader.dart';
 import 'package:analyzer/src/task/dart.dart';
 import 'package:analyzer/src/task/strong/checker.dart';
+import 'package:front_end/src/dependency_walker.dart';
 import 'package:front_end/src/scanner/reader.dart';
 
 /**
  * Analyzer of Dart files.
  *
  * Work in progress, not ready to be used.
  */
 class AnalyzerImpl {
   final AnalysisOptions analysisOptions;
   final SourceFactory sourceFactory;
   final FileSystemState fsState;
   final SummaryDataStore store;
 
   AnalysisContextImpl analysisContext;
   TypeProvider typeProvider;
   StoreBasedSummaryResynthesizer resynthesizer;
   final Map<FileState, RecordingErrorListener> _errorListeners = {};
   final Map<FileState, ErrorReporter> _errorReporters = {};
   final List<UsedImportedElements> usedImportedElementsList = [];
   final List<UsedLocalElements> usedLocalElementsList = [];
+  final List<ConstantEvaluationTarget> _constants = [];
 
   AnalyzerImpl(
       this.analysisOptions, this.sourceFactory, this.fsState, this.store);
 
   /**
    * Compute analysis results for all units of the [library].
    */
   Map<FileState, UnitAnalysisResult> analyze(FileState library) {
     Map<FileState, CompilationUnit> units = {};
 
@@ skipping 13 matching lines @@
     try {
       resynthesizer = new StoreBasedSummaryResynthesizer(
           analysisContext, sourceFactory, analysisOptions.strongMode, store);
       typeProvider = resynthesizer.typeProvider;
       analysisContext.typeProvider = typeProvider;
 
       units.forEach((file, unit) {
         _resolveFile(analysisContext, library, file, unit);
       });
 
+      _computeConstants();
+
       units.forEach((file, unit) {
         LibraryElement libraryElement = unit.element.library;
         {
           var visitor = new GatherUsedLocalElementsVisitor(libraryElement);
           unit.accept(visitor);
           usedLocalElementsList.add(visitor.usedElements);
         }
         {
           var visitor = new GatherUsedImportedElementsVisitor(libraryElement);
           unit.accept(visitor);
@@ skipping 10 matching lines @@
 
     // Return full results.
     Map<FileState, UnitAnalysisResult> results = {};
     units.forEach((file, unit) {
       List<AnalysisError> errors = _getErrorListener(file).errors;
       results[file] = new UnitAnalysisResult(file, unit, errors);
     });
     return results;
   }
 
+  /**
+   * Compute [_constants] in all units.
+   */
+  void _computeConstants() {
+    ConstantEvaluationEngine evaluationEngine = new ConstantEvaluationEngine(
+        analysisContext.typeProvider, analysisContext.declaredVariables,
+        typeSystem: analysisContext.typeSystem);
+
+    List<_ConstantNode> nodes = [];
+    Map<ConstantEvaluationTarget, _ConstantNode> nodeMap = {};
+    for (ConstantEvaluationTarget constant in _constants) {
+      var node = new _ConstantNode(evaluationEngine, nodeMap, constant);
+      nodes.add(node);
+      nodeMap[constant] = node;
+    }
+
+    for (_ConstantNode node in nodes) {
+      if (!node.isEvaluated) {
+        new _ConstantWalker(evaluationEngine).walk(node);
+      }
+    }
+  }
+
   void _computeVerifyErrorsAndHints(AnalysisContext analysisContext,
       FileState libraryFile, FileState file, CompilationUnit unit) {
     RecordingErrorListener errorListener = _getErrorListener(file);
     CompilationUnitElement unitElement = unit.element;
     LibraryElement libraryElement = unitElement.library;
 
+    //
+    // Use the ErrorVerifier to compute errors.
+    //
+    List<PendingError> pendingErrors;
+    {
+      RequiredConstantsComputer computer =
+          new RequiredConstantsComputer(file.source);
+      unit.accept(computer);
+      pendingErrors = computer.pendingErrors;
+      List<ConstantEvaluationTarget> requiredConstants =
+          computer.requiredConstants;
+    }
+
+    if (analysisOptions.strongMode) {
+      AnalysisOptionsImpl options = analysisOptions as AnalysisOptionsImpl;
+      CodeChecker checker = new CodeChecker(
+          typeProvider,
+          new StrongTypeSystemImpl(typeProvider,
+              implicitCasts: options.implicitCasts,
+              nonnullableTypes: options.nonnullableTypes),
+          errorListener,
+          options);
+      checker.visitCompilationUnit(unit);
+    }
+
+    var errorReporter = _getErrorReporter(file);
+
+    //
+    // Validate the directives.
+    //
+    _validateUriBasedDirectives(file, unit);
+
+    //
+    // Use the ConstantVerifier to compute errors.
+    //
+    ConstantVerifier constantVerifier = new ConstantVerifier(errorReporter,
+        libraryElement, typeProvider, analysisContext.declaredVariables);
+    unit.accept(constantVerifier);
+
+    //
+    // Use the ErrorVerifier to compute errors.
+    //
+    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: analysisContext.typeSystem));
+
+    // Dart2js analysis.
+    if (analysisOptions.dart2jsHint) {
+      unit.accept(new Dart2JSVerifier(errorReporter));
+    }
+
+    InheritanceManager inheritanceManager = new InheritanceManager(
+        libraryElement,
+        includeAbstractFromSuperclasses: true);
+
+    unit.accept(new BestPracticesVerifier(
+        errorReporter, typeProvider, libraryElement, inheritanceManager,
+        typeSystem: analysisContext.typeSystem));
+
+    unit.accept(new OverrideVerifier(errorReporter, inheritanceManager));
+
+    new ToDoFinder(errorReporter).findIn(unit);
+
     // Verify imports.
     {
       ImportsVerifier verifier = new ImportsVerifier();
       verifier.addImports(unit);
       usedImportedElementsList.forEach(verifier.removeUsedElements);
       ErrorReporter errorReporter = _getErrorReporter(file);
       verifier.generateDuplicateImportHints(errorReporter);
       verifier.generateUnusedImportHints(errorReporter);
       verifier.generateUnusedShownNameHints(errorReporter);
     }
@@ skipping 48 matching lines @@
     Parser parser = new Parser(file.source, errorListener);
     parser.parseGenericMethodComments = analysisOptions.strongMode;
     CompilationUnit unit = parser.parseCompilationUnit(token);
     unit.lineInfo = lineInfo;
     return unit;
   }
 
   void _resolveFile(AnalysisContext analysisContext, FileState library,
       FileState file, CompilationUnit unit) {
     if (!file.exists) {
-      var unitElement = new CompilationUnitElementImpl(file.source.shortName);
+      Source source = file.source;
+      var unitElement = new CompilationUnitElementImpl(source.shortName);
       var libraryElement = new LibraryElementImpl(analysisContext, null, -1, 0);
+      unitElement.source = source;
+      unitElement.librarySource = source;
       libraryElement.definingCompilationUnit = unitElement;
       unit.element = unitElement;
       return;
     }
 
     RecordingErrorListener errorListener = _getErrorListener(file);
 
     String libraryUri = library.uri.toString();
     String unitUri = file.uri.toString();
     CompilationUnitElement unitElement = resynthesizer.getElement(
@@ skipping 36 matching lines @@
     unit.accept(new PartialResolverVisitor(libraryElement, unitElement.source,
         typeProvider, AnalysisErrorListener.NULL_LISTENER));
 
     // Nothing for RESOLVED_UNIT8?
     // Nothing for RESOLVED_UNIT9?
     // Nothing for RESOLVED_UNIT10?
 
     unit.accept(new ResolverVisitor(
         libraryElement, unitElement.source, typeProvider, errorListener));
 
-    // TODO(scheglov) RESOLVED_UNIT12: compute constants
-
     //
-    // Use the ErrorVerifier to compute errors.
+    // Find constants to compute.
     //
-    List<PendingError> pendingErrors;
     {
-      RequiredConstantsComputer computer =
-          new RequiredConstantsComputer(file.source);
-      unit.accept(computer);
-      pendingErrors = computer.pendingErrors;
-      List<ConstantEvaluationTarget> requiredConstants =
-          computer.requiredConstants;
+      ConstantFinder constantFinder = new ConstantFinder();
+      unit.accept(constantFinder);
+      _constants.addAll(constantFinder.constantsToCompute);
     }
-
-    if (analysisOptions.strongMode) {
-      AnalysisOptionsImpl options = analysisOptions as AnalysisOptionsImpl;
-      CodeChecker checker = new CodeChecker(
-          typeProvider,
-          new StrongTypeSystemImpl(typeProvider,
-              implicitCasts: options.implicitCasts,
-              nonnullableTypes: options.nonnullableTypes),
-          errorListener,
-          options);
-      checker.visitCompilationUnit(unit);
-    }
-
-    var errorReporter = _getErrorReporter(file);
-
-    //
-    // Validate the directives.
-    //
-    _validateUriBasedDirectives(file, unit);
-
-    //
-    // Use the ConstantVerifier to compute errors.
-    //
-    ConstantVerifier constantVerifier = new ConstantVerifier(errorReporter,
-        libraryElement, typeProvider, analysisContext.declaredVariables);
-    unit.accept(constantVerifier);
-
-    //
-    // Use the ErrorVerifier to compute errors.
-    //
-    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: analysisContext.typeSystem));
-
-    // Dart2js analysis.
-    if (analysisOptions.dart2jsHint) {
-      unit.accept(new Dart2JSVerifier(errorReporter));
-    }
-
-    InheritanceManager inheritanceManager = new InheritanceManager(
-        libraryElement,
-        includeAbstractFromSuperclasses: true);
-
-    unit.accept(new BestPracticesVerifier(
-        errorReporter, typeProvider, libraryElement, inheritanceManager,
-        typeSystem: analysisContext.typeSystem));
-
-    unit.accept(new OverrideVerifier(errorReporter, inheritanceManager));
-
-    new ToDoFinder(errorReporter).findIn(unit);
   }
 
   /**
    * Return the result of resolve the given [uriContent], reporting errors
    * against the [uriLiteral].
    */
   Source _resolveUri(FileState file, bool isImport, StringLiteral uriLiteral,
       String uriContent) {
     UriValidationCode code =
         UriBasedDirectiveImpl.validateUri(isImport, uriLiteral, uriContent);
@@ skipping 101 matching lines @@
  */
 class UnitAnalysisResult {
   final FileState file;
   final CompilationUnit unit;
   final List<AnalysisError> errors;
 
   UnitAnalysisResult(this.file, this.unit, this.errors);
 }
 
 /**
+ * [Node] that is used to compute constants in dependency order.
+ */
+class _ConstantNode extends Node<_ConstantNode> {
+  final ConstantEvaluationEngine evaluationEngine;
+  final Map<ConstantEvaluationTarget, _ConstantNode> nodeMap;
+  final ConstantEvaluationTarget constant;
+
+  List<_ConstantNode> _dependencies = null;
+
+  bool isEvaluated = false;
+
+  _ConstantNode(this.evaluationEngine, this.nodeMap, this.constant);
+
+  @override
+  List<_ConstantNode> computeDependencies() {
+    if (_dependencies == null) {
+      List<ConstantEvaluationTarget> targets = [];
+      evaluationEngine.computeDependencies(constant, targets.add);
+      _dependencies = targets.map(_getNode).toList();
+    }
+    return _dependencies;
+  }
+
+  _ConstantNode _getNode(ConstantEvaluationTarget constant) {
+    return nodeMap.putIfAbsent(
+        constant, () => new _ConstantNode(evaluationEngine, nodeMap, constant));
+  }
+}
+
+/**
+ * [DependencyWalker] for computing constants and detecting cycles.
+ */
+class _ConstantWalker extends DependencyWalker<_ConstantNode> {
+  final ConstantEvaluationEngine evaluationEngine;
+
+  _ConstantWalker(this.evaluationEngine);
+
+  @override
+  void evaluate(_ConstantNode node) {
+    evaluationEngine.computeConstantValue(node.constant);
+    node.isEvaluated = true;
+  }
+
+  @override
+  void evaluateScc(List<_ConstantNode> scc) {
+    var constantsInCycle = scc.map((node) => node.constant);
+    for (_ConstantNode node in scc) {
+      evaluationEngine.generateCycleError(constantsInCycle, node.constant);
+      node.isEvaluated = true;
+    }
+  }
+}
+
+/**
  * [ContentCache] wrapper around [FileContentOverlay].
  */
 class _ContentCacheWrapper implements ContentCache {
   final FileSystemState fsState;
 
   _ContentCacheWrapper(this.fsState);
 
   @override
   void accept(ContentCacheVisitor visitor) {
     throw new UnimplementedError();
@@ skipping 17 matching lines @@
   @override
   String setContents(Source source, String contents) {
     throw new UnimplementedError();
   }
 
   FileState _getFileForSource(Source source) {
     String path = source.fullName;
     return fsState.getFileForPath(path);
   }
 }