Not task based analysis.

pkg/analyzer/lib/src/dart/analysis/driver.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.
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:typed_data';
 
 import 'package:analyzer/context/declared_variables.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart' show CompilationUnitElement;
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/error/listener.dart';
 import 'package:analyzer/exception/exception.dart';
 import 'package:analyzer/file_system/file_system.dart';
+import 'package:analyzer/src/dart/analysis/analysis_impl.dart';
 import 'package:analyzer/src/dart/analysis/byte_store.dart';
 import 'package:analyzer/src/dart/analysis/file_state.dart';
 import 'package:analyzer/src/dart/analysis/file_tracker.dart';
 import 'package:analyzer/src/dart/analysis/index.dart';
 import 'package:analyzer/src/dart/analysis/library_context.dart';
 import 'package:analyzer/src/dart/analysis/search.dart';
 import 'package:analyzer/src/dart/analysis/status.dart';
 import 'package:analyzer/src/dart/analysis/top_level_declaration.dart';
 import 'package:analyzer/src/generated/engine.dart'
     show AnalysisContext, AnalysisEngine, AnalysisOptions;
@@ skipping 102 matching lines @@
    * from file paths.
    */
   SourceFactory _sourceFactory;
 
   /**
    * The declared environment variables.
    */
   final DeclaredVariables declaredVariables = new DeclaredVariables();
 
   /**
+   * If `true`, then analysis should be done without using tasks model.
+   */
+  final bool analyzeWithoutTasks;
+
+  /**
    * The salt to mix into all hashes used as keys for serialized data.
    */
   final Uint32List _salt = new Uint32List(1 + AnalysisOptions.signatureLength);
 
   /**
    * The set of priority files, that should be analyzed sooner.
    */
   final _priorityFiles = new LinkedHashSet<String>();
 
   /**
@@ skipping 79 matching lines @@
    */
   AnalysisDriver(
       this._scheduler,
       PerformanceLog logger,
       this._resourceProvider,
       this._byteStore,
       this._contentOverlay,
       this.name,
       SourceFactory sourceFactory,
       this._analysisOptions,
-      {PackageBundle sdkBundle})
+      {PackageBundle sdkBundle,
+      this.analyzeWithoutTasks: false})
       : _logger = logger,
         _sourceFactory = sourceFactory.clone(),
         _sdkBundle = sdkBundle {
     _testView = new AnalysisDriverTestView(this);
     _createFileTracker(logger);
     _scheduler._add(this);
     _search = new Search(this);
   }
 
   /**
@@ skipping 442 matching lines @@
       if (bytes != null) {
         return _getAnalysisResultFromBytes(file, bytes);
       }
     }
 
     // We need the fully resolved unit, or the result is not cached.
     return _logger.run('Compute analysis result for $path', () {
       FileState file = _fileTracker.verifyApiSignature(path);
 
       // Prepare the library file - the file itself, or the known library.
-      FileState libraryFile = getLibraryFile(file);
-      if (libraryFile == null) {
+      FileState library = getLibraryFile(file);
+      if (library == null) {
         return null;
       }
 
       try {
-        LibraryContext libraryContext = _createLibraryContext(libraryFile);
+        LibraryContext libraryContext = _createLibraryContext(library);
         try {
-          var resolutionResult =
-              libraryContext.resolveUnit(libraryFile.source, file.source);
-          CompilationUnit resolvedUnit = resolutionResult.resolvedUnit;
-          List<AnalysisError> errors = resolutionResult.errors;
-          AnalysisDriverUnitIndexBuilder index = indexUnit(resolvedUnit);
+          CompilationUnit resolvedUnit;
+          List<int> bytes;
+          if (analyzeWithoutTasks) {
+            AnalyzerImpl analyzer = new AnalyzerImpl(analysisOptions,
+                sourceFactory, _fileTracker.fsState, libraryContext.store);
+            Map<FileState, UnitAnalysisResult> results =
+                analyzer.analyze(library);
+            UnitAnalysisResult fileResult = results[file];
+            resolvedUnit = fileResult.unit;
 
-          // Store the result into the cache.
-          List<int> bytes;
-          {
-            bytes = new AnalysisDriverResolvedUnitBuilder(
-                    errors: errors
-                        .map((error) => new AnalysisDriverUnitErrorBuilder(
-                            offset: error.offset,
-                            length: error.length,
-                            uniqueName: error.errorCode.uniqueName,
-                            message: error.message,
-                            correction: error.correction))
-                        .toList(),
-                    index: index)
-                .toBuffer();
-            String key = _getResolvedUnitKey(libraryFile, file);
-            _byteStore.put(key, bytes);
+            // Store the result into the cache.
+            bytes = _storeResolvedUnit(
+                library, file, resolvedUnit, fileResult.errors);
+          } else {
+            ResolutionResult resolutionResult =
+                libraryContext.resolveUnit(library.source, file.source);
+            resolvedUnit = resolutionResult.resolvedUnit;
+            List<AnalysisError> errors = resolutionResult.errors;
+
+            // Store the result into the cache.
+            bytes = _storeResolvedUnit(library, file, resolvedUnit, errors);
           }
 
           // Return the result, full or partial.
           _logger.writeln('Computed new analysis result.');
           AnalysisResult result = _getAnalysisResultFromBytes(file, bytes,
               content: withUnit ? file.content : null,
               withErrors: _fileTracker.addedFiles.contains(path),
               resolvedUnit: withUnit ? resolvedUnit : null);
           if (withUnit && _priorityFiles.contains(path)) {
             _priorityResults[path] = result;
           }
           return result;
         } finally {
           libraryContext.dispose();
         }
       } catch (exception, stackTrace) {
         String contextKey =
-            _storeExceptionContext(path, libraryFile, exception, stackTrace);
+            _storeExceptionContext(path, library, exception, stackTrace);
         throw new _ExceptionState(exception, stackTrace, contextKey);
       }
     });
   }
 
   AnalysisDriverUnitIndex _computeIndex(String path) {
     AnalysisResult analysisResult = _computeAnalysisResult(path,
         withUnit: false, asIsIfPartWithoutLibrary: true);
     return analysisResult._index;
   }
@@ skipping 344 matching lines @@
       String sec = _twoDigits(time.second);
       String ms = _threeDigits(time.millisecond);
       String key = 'exception_${time.year}$m$d' '_$h$min$sec' + '_$ms';
 
       _byteStore.put(key, bytes);
       return key;
     } catch (_) {
       return null;
     }
   }
+
+  /**
+   * Store the fully resolved results for the [file] in the [library] into the
+   * cache and return the stored bytes.
+   */
+  List<int> _storeResolvedUnit(FileState library, FileState file,
+      CompilationUnit resolvedUnit, List<AnalysisError> errors) {
+    AnalysisDriverUnitIndexBuilder index = indexUnit(resolvedUnit);
+
+    String key = _getResolvedUnitKey(library, file);
+    List<int> bytes = new AnalysisDriverResolvedUnitBuilder(
+            errors: errors
+                .map((error) => new AnalysisDriverUnitErrorBuilder(
+                    offset: error.offset,
+                    length: error.length,
+                    uniqueName: error.errorCode.uniqueName,
+                    message: error.message,
+                    correction: error.correction))
+                .toList(),
+            index: index)
+        .toBuffer();
+    _byteStore.put(key, bytes);
+    return bytes;
+  }
 }
 
 /**
  * Priorities of [AnalysisDriver] work. The farther a priority to the beginning
  * of the list, the earlier the corresponding [AnalysisDriver] should be asked
  * to perform work.
  */
 enum AnalysisDriverPriority { nothing, general, priority, interactive }
 
 /**
@@ skipping 630 matching lines @@
           libraryDeclarations.add(new TopLevelDeclarationInSource(
               file.source, declaration, isExported));
         }
       }
     }
 
     // We're not done yet.
     return false;
   }
 }