Stop defensively copying AST structures before resolution

pkg/analyzer/lib/src/task/inputs.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.task.inputs;
 
 import 'dart:collection';
 
 import 'package:analyzer/task/model.dart';
 
@@ skipping 37 matching lines @@
 
   @override
   AnalysisTarget get currentTarget => null;
 
   @override
   void set currentValue(Object value) {
     throw new StateError('Only supported after moveNext() returns true');
   }
 
   @override
+  bool get flushOnAccess => false;
+
+  @override
   V get inputValue => input.value;
 
   @override
   void currentValueNotAvailable() {
     throw new StateError('Only supported after moveNext() returns true');
   }
 
   @override
   bool moveNext() => false;
 }
 
 /**
  * An input to an [AnalysisTask] that is computed by accessing a single result
  * defined on a single target.
  */
 class ListTaskInputImpl<E> extends SimpleTaskInput<List<E>>
     with ListTaskInputMixin<E>
     implements ListTaskInput<E> {
   /**
    * Initialize a newly created task input that computes the input by accessing
    * the given [result] associated with the given [target].
    */
   ListTaskInputImpl(AnalysisTarget target, ResultDescriptor<List<E>> result)
-      : super(target, result);
+      : super._unflushable(target, result);
 }
 
 /**
  * A mixin-ready implementation of [ListTaskInput].
  */
 abstract class ListTaskInputMixin<E> implements ListTaskInput<E> {
   ListTaskInput /*<V>*/ toList(UnaryFunction<E, dynamic /*<V>*/ > mapper) {
     return new ListToListTaskInput<E, dynamic /*V*/ >(this, mapper);
   }
 
@@ skipping 190 matching lines @@
   @override
   void set currentValue(Object value) {
     if (currentBuilder == null) {
       throw new StateError(
           'Cannot set the result value when there is no current result');
     }
     currentBuilder.currentValue = value;
   }
 
   @override
+  bool get flushOnAccess => currentBuilder.flushOnAccess;
+
+  @override
   void currentValueNotAvailable() {
     if (currentBuilder == null) {
       throw new StateError(
           'Cannot set the result value when there is no current result');
     }
     currentBuilder.currentValueNotAvailable();
   }
 
   @override
   bool moveNext() {
@@ skipping 131 matching lines @@
   @override
   void set currentValue(Object value) {
     if (builder == null) {
       throw new StateError(
           'Cannot set the result value when there is no current result');
     }
     builder.currentValue = value;
   }
 
   @override
+  bool get flushOnAccess => builder.flushOnAccess;
+
+  @override
   List<E> get inputValue {
     if (builder != null) {
       throw new StateError('Result value has not been created');
     }
     return _inputValue;
   }
 
   @override
   void currentValueNotAvailable() {
     if (builder == null) {
@@ skipping 31 matching lines @@
    * The target on which the result is defined.
    */
   final AnalysisTarget target;
 
   /**
    * The result to be accessed.
    */
   final ResultDescriptor<V> result;
 
   /**
+   * Return `true` if the value accessed by this input builder should be flushed
+   * from the cache at the time it is retrieved.
+   */
+  final bool flushOnAccess;
+
+  /**
    * Initialize a newly created task input that computes the input by accessing
    * the given [result] associated with the given [target].
    */
-  SimpleTaskInput(this.target, this.result);
+  SimpleTaskInput(this.target, this.result, {this.flushOnAccess: false});
+
+  /**
+   * Initialize a newly created task input that computes the input by accessing
+   * the given [result] associated with the given [target].
+   */
+  SimpleTaskInput._unflushable(this.target, this.result)
+      : flushOnAccess = false;
 
   @override
   TaskInputBuilder<V> createBuilder() => new SimpleTaskInputBuilder<V>(this);
 }
 
 /**
  * A [TaskInputBuilder] used to build an input based on a [SimpleTaskInput].
  */
 class SimpleTaskInputBuilder<V> implements TaskInputBuilder<V> {
   /**
@@ skipping 51 matching lines @@
   void set currentValue(Object value) {
     if (_state != _AT) {
       throw new StateError(
           'Cannot set the result value when there is no current result');
     }
     _resultValue = value as V;
     _resultSet = true;
   }
 
   @override
+  bool get flushOnAccess => input.flushOnAccess;
+
+  @override
   V get inputValue {
     if (_state != _AFTER) {
       throw new StateError('Result value has not been created');
     }
     return _resultValue;
   }
 
   @override
   void currentValueNotAvailable() {
     if (_state != _AT) {
@@ skipping 88 matching lines @@
   @override
   void set currentValue(Object value) {
     if (currentBuilder == null) {
       throw new StateError(
           'Cannot set the result value when there is no current result');
     }
     currentBuilder.currentValue = value;
   }
 
   @override
+  bool get flushOnAccess => currentBuilder.flushOnAccess;
+
+  @override
   Map<String, Object> get inputValue {
     if (nameIndex < inputNames.length) {
       throw new StateError('Result value has not been created');
     }
     return inputs;
   }
 
   /**
    * Assuming that there is a current input, return its name.
    */
@@ skipping 133 matching lines @@
   @override
   void set currentValue(Object value) {
     if (currentBuilder == null) {
       throw new StateError(
           'Cannot set the result value when there is no current result');
     }
     currentBuilder.currentValue = value;
   }
 
   @override
+  bool get flushOnAccess => currentBuilder.flushOnAccess;
+
+  @override
   C get inputValue {
     if (currentBuilder != null || _resultValue == null) {
       throw new StateError('Result value has not been created');
     }
     return _resultValue;
   }
 
   /**
    * The list of values being built.
    */
@@ skipping 47 matching lines @@
       return false;
     }
     _baseListElement = _baseList[_baseListIndex];
     currentBuilder = input.generateTaskInputs(_baseListElement).createBuilder();
     return currentBuilder.moveNext();
   }
 
   void _addResultElement(B baseElement, E resultElement);
   void _initResultValue();
 }