Drop the 'analyzeWithoutTasks' flag for AnalysisDriver.

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/context_root.dart';
 import 'package:analyzer/context/declared_variables.dart';
@@ skipping 114 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;
-
-  /**
    * Information about the context root being analyzed by this driver.
    */
   final ContextRoot contextRoot;
 
   /**
    * The salt to mix into all hashes used as keys for serialized data.
    */
   final Uint32List _salt = new Uint32List(1 + AnalysisOptions.signatureLength);
 
   /**
@@ skipping 100 matching lines @@
    */
   AnalysisDriver(
       this._scheduler,
       PerformanceLog logger,
       this._resourceProvider,
       this._byteStore,
       this._contentOverlay,
       this.contextRoot,
       SourceFactory sourceFactory,
       this._analysisOptions,
-      {PackageBundle sdkBundle,
-      this.analyzeWithoutTasks: true})
+      {PackageBundle sdkBundle})
       : _logger = logger,
         _sourceFactory = sourceFactory.clone(),
         _sdkBundle = sdkBundle {
     _onResults = _resultController.stream.asBroadcastStream();
     _testView = new AnalysisDriverTestView(this);
     _createFileTracker(logger);
     _scheduler.add(this);
     _search = new Search(this);
   }
 
@@ skipping 674 matching lines @@
       if (bytes != null) {
         return _getAnalysisResultFromBytes(file, signature, bytes);
       }
     }
 
     // We need the fully resolved unit, or the result is not cached.
     return _logger.run('Compute analysis result for $path', () {
       try {
         LibraryContext libraryContext = _createLibraryContext(library);
         try {
+          LibraryAnalyzer analyzer = new LibraryAnalyzer(
+              analysisOptions,
+              declaredVariables,
+              sourceFactory,
+              _fileTracker.fsState,
+              libraryContext.store,
+              library);
+          Map<FileState, UnitAnalysisResult> results = analyzer.analyze();
+
+          List<int> bytes;
           CompilationUnit resolvedUnit;
-          List<int> bytes;
-          if (analyzeWithoutTasks) {
-            LibraryAnalyzer analyzer = new LibraryAnalyzer(
-                analysisOptions,
-                declaredVariables,
-                sourceFactory,
-                _fileTracker.fsState,
-                libraryContext.store,
-                library);
-            Map<FileState, UnitAnalysisResult> results = analyzer.analyze();
-            for (FileState unitFile in results.keys) {
-              UnitAnalysisResult unitResult = results[unitFile];
-              List<int> unitBytes =
-                  _serializeResolvedUnit(unitResult.unit, unitResult.errors);
-              String unitSignature =
-                  _getResolvedUnitSignature(library, unitFile);
-              String unitKey = _getResolvedUnitKey(unitSignature);
-              _byteStore.put(unitKey, unitBytes);
-              if (unitFile == file) {
-                bytes = unitBytes;
-                resolvedUnit = unitResult.unit;
-              }
+          for (FileState unitFile in results.keys) {
+            UnitAnalysisResult unitResult = results[unitFile];
+            List<int> unitBytes =
+                _serializeResolvedUnit(unitResult.unit, unitResult.errors);
+            String unitSignature = _getResolvedUnitSignature(library, unitFile);
+            String unitKey = _getResolvedUnitKey(unitSignature);
+            _byteStore.put(unitKey, unitBytes);
+            if (unitFile == file) {
+              bytes = unitBytes;
+              resolvedUnit = unitResult.unit;
             }
-          } else {
-            ResolutionResult resolutionResult =
-                libraryContext.resolveUnit(library.source, file.source);
-            resolvedUnit = resolutionResult.resolvedUnit;
-            List<AnalysisError> errors = resolutionResult.errors;
-
-            // Store the result into the cache.
-            bytes = _serializeResolvedUnit(resolvedUnit, errors);
-            _byteStore.put(key, bytes);
           }
 
           // Return the result, full or partial.
           _logger.writeln('Computed new analysis result.');
           AnalysisResult result = _getAnalysisResultFromBytes(
               file, signature, bytes,
               content: withUnit ? file.content : null,
               resolvedUnit: withUnit ? resolvedUnit : null);
           if (withUnit && _priorityFiles.contains(path)) {
             _priorityResults[path] = result;
@@ skipping 988 matching lines @@
           libraryDeclarations.add(new TopLevelDeclarationInSource(
               file.source, declaration, isExported));
         }
       }
     }
 
     // We're not done yet.
     return false;
   }
 }