More clean-ups after removing not-body incremenal 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 analyzer.src.generated.incremental_resolver;
 
 import 'dart:collection';
 import 'dart:math' as math;
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 18 matching lines @@
 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/generated/utilities_dart.dart';
 import 'package:analyzer/src/task/dart.dart';
 import 'package:analyzer/task/dart.dart';
 import 'package:analyzer/task/general.dart' show CONTENT, LINE_INFO;
 import 'package:analyzer/task/model.dart';
 
 /**
- * If `true`, an attempt to resolve API-changing modifications is made.
- */
-bool _resolveApiChanges = false;
-
-/**
- * This method is used to enable/disable API-changing modifications resolution.
- */
-void set test_resolveApiChanges(bool value) {
-  _resolveApiChanges = value;
-}
-
-/**
  * The [Delta] implementation used by incremental resolver.
  * It keeps Dart results that are either don't change or are updated.
  */
 class IncrementalBodyDelta extends Delta {
   /**
    * The offset of the changed contents.
    */
   final int updateOffset;
 
   /**
@@ skipping 189 matching lines @@
         _source = definingUnit.source,
         _librarySource = definingUnit.library.source,
         _updateEndOld = updateEndOld,
         _updateEndNew = updateEndNew,
         _updateDelta = updateEndNew - updateEndOld;
 
   /**
    * Resolve [body], reporting any errors or warnings to the given listener.
    *
    * [body] - the root of the AST structure to be resolved.
-   *
-   * Returns `true` if resolution was successful.
    */
-  bool resolve(BlockFunctionBody body) {
+  void resolve(BlockFunctionBody body) {
     logger.enter('resolve: $_definingUnit');
     try {
       Declaration executable = _findResolutionRoot(body);
       _prepareResolutionContext(executable);
       // update elements
       _updateCache();
       _updateElementNameOffsets();
       _buildElements(executable, body);
       // resolve
       _resolveReferences(executable);
       _computeConstants(executable);
       _resolveErrors = errorListener.getErrorsForSource(_source);
       // verify
       _verify(executable);
       _context.invalidateLibraryHints(_librarySource);
       // update entry errors
       _updateEntry();
-      // OK
-      return true;
     } finally {
       logger.exit();
     }
   }
 
   void _buildElements(Declaration executable, AstNode node) {
     LoggingTimer timer = logger.startTimer();
     try {
       ElementHolder holder = new ElementHolder();
       ElementBuilder builder = new ElementBuilder(holder, _definingUnit);
@@ skipping 247 matching lines @@
   List<AnalysisError> _newScanErrors = <AnalysisError>[];
   List<AnalysisError> _newParseErrors = <AnalysisError>[];
 
   PoorMansIncrementalResolver(
       this._typeProvider,
       this._unitSource,
       this._cache,
       this._sourceEntry,
       this._unitEntry,
       this._oldUnit,
-      bool resolveApiChanges) {
-    _resolveApiChanges = resolveApiChanges;
-  }
+      bool resolveApiChanges);
 
   /**
    * Attempts to update [_oldUnit] to the state corresponding to [newCode].
    * Returns `true` if success, or `false` otherwise.
    * The [_oldUnit] might be damaged.
    */
   bool resolve(String newCode) {
     logger.enter('diff/resolve $_unitSource');
     try {
       // prepare old unit
@@ skipping 162 matching lines @@
         }
         // perform incremental resolution
         IncrementalResolver incrementalResolver = new IncrementalResolver(
             _cache,
             _sourceEntry,
             _unitEntry,
             _unitElement,
             _updateOffset,
             _updateEndOld,
             _updateEndNew);
-        bool success = incrementalResolver.resolve(newNode);
-        // check if success
-        if (!success) {
-          logger.log('Failure: element model changed.');
-          return false;
-        }
+        incrementalResolver.resolve(newNode);
         // update DartEntry
         _updateEntry();
         logger.log('Success.');
         return true;
       }
     } catch (e, st) {
       logger.logException(e, st);
       logger.log('Failure: exception.');
       // The incremental resolver log is usually turned off,
       // so also log the exception to the instrumentation log.
@@ skipping 560 matching lines @@
   @override
   String toString() => name;
 }
 
 class _TokenPair {
   final _TokenDifferenceKind kind;
   final Token oldToken;
   final Token newToken;
   _TokenPair(this.kind, this.oldToken, this.newToken);
 }