Remove the limited invalidation feature.

pkg/analyzer/lib/src/context/context.dart

 // Copyright (c) 2015, 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 analyzer.src.context.context;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 11 matching lines @@
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/incremental_resolver.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/sdk.dart' show DartSdk;
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/utilities_collection.dart';
 import 'package:analyzer/src/task/dart.dart';
 import 'package:analyzer/src/task/dart_work_manager.dart';
 import 'package:analyzer/src/task/driver.dart';
-import 'package:analyzer/src/task/incremental_element_builder.dart';
 import 'package:analyzer/src/task/manager.dart';
 import 'package:analyzer/task/dart.dart';
 import 'package:analyzer/task/general.dart';
 import 'package:analyzer/task/html.dart';
 import 'package:analyzer/task/model.dart';
 import 'package:html/dom.dart' show Document;
 
 /**
  * Type of callback functions used by PendingFuture. Functions of this type
  * should perform a computation based on the data in [entry] and return it. If
@@ skipping 287 matching lines @@
     this._options.incrementalValidation = options.incrementalValidation;
     this._options.lint = options.lint;
     this._options.lintRules = options.lintRules;
     this._options.preserveComments = options.preserveComments;
     if (this._options.strongMode != options.strongMode) {
       _typeSystem = null;
     }
     this._options.strongMode = options.strongMode;
     this._options.trackCacheDependencies = options.trackCacheDependencies;
     this._options.disableCacheFlushing = options.disableCacheFlushing;
-    this._options.finerGrainedInvalidation = options.finerGrainedInvalidation;
     this._options.patchPaths = options.patchPaths;
     if (options is AnalysisOptionsImpl) {
       this._options.strongModeHints = options.strongModeHints;
       this._options.implicitCasts = options.implicitCasts;
       this._options.nonnullableTypes = options.nonnullableTypes;
       this._options.implicitDynamic = options.implicitDynamic;
     }
     if (needsRecompute) {
       for (WorkManager workManager in workManagers) {
         workManager.onAnalysisOptionsChanged();
@@ skipping 1483 matching lines @@
     // Fast path if the contents is the same as it was last time.
     if (oldContents != null && fileContents?.data == oldContents) {
       return;
     }
 
     // We're going to update the cache, so reset the driver.
     driver.reset();
 
     // We need to invalidate the cache.
     {
-      if (analysisOptions.finerGrainedInvalidation &&
-          AnalysisEngine.isDartFileName(source.fullName)) {
-        // TODO(scheglov) Incorrect implementation in general.
-        entry.setState(TOKEN_STREAM, CacheState.FLUSHED);
-        entry.setState(PARSED_UNIT, CacheState.FLUSHED);
-        SourceKind sourceKind = getKindOf(source);
-        List<Source> partSources = getResult(source, INCLUDED_PARTS);
-        if (sourceKind == SourceKind.LIBRARY && partSources.isEmpty) {
-          Source librarySource = source;
-          // Try to find an old unit which has element model.
-          CacheEntry unitEntry =
-              getCacheEntry(new LibrarySpecificUnit(librarySource, source));
-          CompilationUnit oldUnit = RESOLVED_UNIT_RESULTS
-              .skipWhile((result) => result != RESOLVED_UNIT2)
-              .map(unitEntry.getValue)
-              .firstWhere((unit) => unit != null, orElse: () => null);
-          // If we have the old unit, we can try to update it.
-          if (oldUnit != null) {
-            // Safely parse the source.
-            CompilationUnit newUnit;
-            try {
-              newUnit = parseCompilationUnit(source);
-            } catch (_) {
-              // The source might have been removed by this time.
-              // We cannot perform incremental invalidation.
-            }
-            // If the new unit was parsed successfully, continue.
-            if (newUnit != null) {
-              IncrementalCompilationUnitElementBuilder builder =
-                  new IncrementalCompilationUnitElementBuilder(
-                      oldUnit, newUnit);
-              builder.build();
-              CompilationUnitElementDelta unitDelta = builder.unitDelta;
-              if (!unitDelta.hasDirectiveChange) {
-                unitEntry.setValueIncremental(
-                    COMPILATION_UNIT_CONSTANTS, builder.unitConstants, false);
-                DartDelta dartDelta = new DartDelta(source);
-                unitDelta.addedDeclarations.forEach(dartDelta.elementChanged);
-                unitDelta.removedDeclarations.forEach(dartDelta.elementChanged);
-                unitDelta.classDeltas.values.forEach(dartDelta.classChanged);
-                entry.setState(CONTENT, CacheState.INVALID, delta: dartDelta);
-                return;
-              }
-            }
-          }
-        }
-      }
       entry.setState(CONTENT, CacheState.INVALID);
       entry.setState(MODIFICATION_TIME, CacheState.INVALID);
       entry.setState(SOURCE_KIND, CacheState.INVALID);
     }
     for (WorkManager workManager in workManagers) {
       workManager.applyChange(
           Source.EMPTY_LIST, <Source>[source], Source.EMPTY_LIST);
     }
   }
 
@@ skipping 375 matching lines @@
     }
     DartSdk sdk = factory.dartSdk;
     if (sdk == null) {
       throw new ArgumentError(
           "The source factory for an SDK analysis context must have a DartUriResolver");
     }
     return new AnalysisCache(
         <CachePartition>[AnalysisEngine.instance.partitionManager.forSdk(sdk)]);
   }
 }