Stop defensively copying AST structures before resolution

pkg/analyzer/lib/task/model.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.task.model;
 
 import 'dart:collection';
+import 'dart:developer';
 
 import 'package:analyzer/src/generated/engine.dart' hide AnalysisTask;
 import 'package:analyzer/src/generated/error.dart' show AnalysisError;
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/utilities_general.dart';
 import 'package:analyzer/src/task/driver.dart';
 import 'package:analyzer/src/task/model.dart';
 
 /**
@@ skipping 59 matching lines @@
  * Clients are expected to extend this class when creating new tasks.
  */
 abstract class AnalysisTask {
   /**
    * A table mapping the types of analysis tasks to the number of times each
    * kind of task has been performed.
    */
   static final Map<Type, int> countMap = new HashMap<Type, int>();
 
   /**
+   * A table mapping the types of analysis tasks to user tags used to collect
+   * timing data for the Observatory.
+   */
+  static Map<Type, UserTag> tagMap = new HashMap<Type, UserTag>();
+
+  /**
    * A table mapping the types of analysis tasks to stopwatches used to compute
    * how much time was spent executing each kind of task.
    */
   static final Map<Type, Stopwatch> stopwatchMap =
       new HashMap<Type, Stopwatch>();
 
   /**
    * The context in which the task is to be performed.
    */
   final AnalysisContext context;
@@ skipping 124 matching lines @@
       if (contextName == null) {
         contextName = 'unnamed';
       }
       AnalysisEngine.instance.instrumentationService
           .logAnalysisTask(contextName, this);
       //
       // Gather statistics on the performance of the task.
       //
       int count = countMap[runtimeType];
       countMap[runtimeType] = count == null ? 1 : count + 1;
+//      UserTag tag = tagMap.putIfAbsent(
+//          runtimeType, () => new UserTag(runtimeType.toString()));
       Stopwatch stopwatch = stopwatchMap[runtimeType];
       if (stopwatch == null) {
         stopwatch = new Stopwatch();
         stopwatchMap[runtimeType] = stopwatch;
       }
+//      UserTag previousTag = tag.makeCurrent();
+//      try {
       stopwatch.start();
       //
       // Actually perform the task.
       //
       try {
         if (dependencyCycle != null && !handlesDependencyCycles) {
           throw new InfiniteTaskLoopException(this, dependencyCycle);
         }
         internalPerform();
       } finally {
         stopwatch.stop();
       }
+//      } finally {
+//        previousTag.makeCurrent();
+//      }
     } on AnalysisException {
       rethrow;
     } catch (exception, stackTrace) {
       throw new AnalysisException(
           'Unexpected exception while performing $description',
           new CaughtException(exception, stackTrace));
     }
   }
 }
 
 /**
  * A description of a [List]-based analysis result that can be computed by an
  * [AnalysisTask].
  *
  * Clients are not expected to subtype this class.
  */
 abstract class ListResultDescriptor<E> implements ResultDescriptor<List<E>> {
   /**
    * Initialize a newly created analysis result to have the given [name] and
    * [defaultValue]. If a [cachingPolicy] is provided, it will control how long
    * values associated with this result will remain in the cache.
    */
   factory ListResultDescriptor(String name, List<E> defaultValue,
       {ResultCachingPolicy<List<E>> cachingPolicy}) = ListResultDescriptorImpl<
       E>;
 
   @override
-  ListTaskInput<E> of(AnalysisTarget target);
+  ListTaskInput<E> of(AnalysisTarget target, {bool flushOnAccess: false});
 }
 
 /**
  * A description of an input to an [AnalysisTask] that can be used to compute
  * that input.
  *
  * Clients are not expected to subtype this class.
  */
 abstract class ListTaskInput<E> extends TaskInput<List<E>> {
   /**
@@ skipping 94 matching lines @@
    */
   V get defaultValue;
 
   /**
    * Return the name of this descriptor.
    */
   String get name;
 
   /**
    * Return a task input that can be used to compute this result for the given
-   * [target].
+   * [target]. If [flushOnAccess] is `true` then the value of this result that
+   * is associated with the [target] will be flushed when it is accessed.
    */
-  TaskInput<V> of(AnalysisTarget target);
+  TaskInput<V> of(AnalysisTarget target, {bool flushOnAccess: false});
 }
 
 /**
  * A specification of the given [result] for the given [target].
  *
  * Clients are not expected to subtype this class.
  */
 class TargetedResult {
   /**
    * An empty list of results.
@@ skipping 120 matching lines @@
 
   /**
    * Set the [value] that was computed for the current result.
    *
    * Throws a [StateError] if [moveNext] has not been invoked or if the last
    * invocation of [moveNext] returned `false`.
    */
   void set currentValue(Object value);
 
   /**
+   * Return `true` if the value accessed by this input builder should be flushed
+   * from the cache at the time it is retrieved.
+   */
+  bool get flushOnAccess;
+
+  /**
    * Return the [value] that was computed by this builder.
    *
    * Throws a [StateError] if [moveNext] has not been invoked or if the last
    * invocation of [moveNext] returned `true`.
    *
    * Returns `null` if no value could be computed due to a circular dependency.
    */
   V get inputValue;
 
   /**
@@ skipping 103 matching lines @@
   /**
    * A work should be done, but without any special urgency.
    */
   NORMAL,
 
   /**
    * Nothing to do.
    */
   NONE
 }