Support for DartBlockBody, DartExpressionBody, DartOmit in java2dart.

pkg/analyzer/lib/src/generated/index.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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.index;
 
 import 'dart:collection' show Queue;
@@ skipping 75 matching lines @@
    * @return `true` if this operation should be removed from the operation queue as a
    *         result of removing the resource
    */
   bool removeWhenSourceRemoved(Source source);
 }
 
 /**
  * [IndexStore] which keeps full index in memory.
  */
 class MemoryIndexStoreImpl implements MemoryIndexStore {
-  static Object _WEAK_SET_VALUE = new Object();
-
   /**
    * When logging is on, [AnalysisEngine] actually creates
    * [InstrumentedAnalysisContextImpl], which wraps [AnalysisContextImpl] used to create
    * actual [Element]s. So, in index we have to unwrap [InstrumentedAnalysisContextImpl]
    * when perform any operation.
    */
   static AnalysisContext unwrapContext(AnalysisContext context) {
     if (context is InstrumentedAnalysisContextImpl) {
       context = (context as InstrumentedAnalysisContextImpl).basis;
     }
     return context;
   }
 
   /**
    * @return the [Source] of the enclosing [LibraryElement], may be `null`.
    */
   static Source _getLibrarySourceOrNull(Element element) {
     LibraryElement library = element.library;
     if (library == null) {
       return null;
     }
     if (library.isAngularHtml) {
       return null;
     }
     return library.source;
   }
 
   /**
-   * We add [AnalysisContext] to this weak set to ensure that we don't continue to add
-   * relationships after some context was removed using [removeContext].
-   */
-  Expando _removedContexts = new Expando();
-
-  /**
    * This map is used to canonicalize equal keys.
    */
   Map<MemoryIndexStoreImpl_ElementRelationKey, MemoryIndexStoreImpl_ElementRelationKey> _canonicalKeys = {};
 
   /**
    * The mapping of [ElementRelationKey] to the [Location]s, one-to-many.
    */
   Map<MemoryIndexStoreImpl_ElementRelationKey, Set<Location>> _keyToLocations = {};
 
   /**
@@ skipping 21 matching lines @@
   Map<AnalysisContext, Map<Source, Set<Source>>> _contextToUnitToLibraries = {};
 
   int _sourceCount = 0;
 
   int _keyCount = 0;
 
   int _locationCount = 0;
 
   bool aboutToIndexDart(AnalysisContext context, CompilationUnitElement unitElement) {
     context = unwrapContext(context);
-    // may be already removed in other thread
-    if (_isRemovedContext(context)) {
+    // may be already disposed in other thread
+    if (context.isDisposed) {
       return false;
     }
     // validate unit
     if (unitElement == null) {
       return false;
     }
     LibraryElement libraryElement = unitElement.library;
     if (libraryElement == null) {
       return false;
     }
@@ skipping 42 matching lines @@
           _sourceCount--;
         }
       }
     }
     // OK, we can index
     return true;
   }
 
   bool aboutToIndexHtml(AnalysisContext context, HtmlElement htmlElement) {
     context = unwrapContext(context);
-    // may be already removed in other thread
-    if (_isRemovedContext(context)) {
+    // may be already disposed in other thread
+    if (context.isDisposed) {
       return false;
     }
     // remove locations
     Source source = htmlElement.source;
     _removeLocations(context, null, source);
     // remove keys
     {
       Map<MemoryIndexStoreImpl_Source2, Set<MemoryIndexStoreImpl_ElementRelationKey>> sourceToKeys = _contextToSourceToKeys[context];
       if (sourceToKeys != null) {
         MemoryIndexStoreImpl_Source2 source2 = new MemoryIndexStoreImpl_Source2(null, source);
@@ skipping 77 matching lines @@
     }
     if (locationSource == null) {
       return;
     }
     if (elementContext == null && element is! NameElementImpl && element is! UniverseElementImpl) {
       return;
     }
     if (elementSource == null && element is! NameElementImpl && element is! UniverseElementImpl) {
       return;
     }
-    // may be already removed in other thread
-    if (_isRemovedContext(elementContext)) {
+    // may be already disposed in other thread
+    if (elementContext != null && elementContext.isDisposed) {
       return;
     }
-    if (_isRemovedContext(locationContext)) {
+    if (locationContext.isDisposed) {
       return;
     }
     // record: key -> location(s)
     MemoryIndexStoreImpl_ElementRelationKey key = _getCanonicalKey(element, relationship);
     {
       Set<Location> locations = _keyToLocations.remove(key);
       if (locations == null) {
         locations = _createLocationIdentitySet();
       } else {
         _keyCount--;
@@ skipping 38 matching lines @@
       }
       locations.add(location);
     }
   }
 
   void removeContext(AnalysisContext context) {
     context = unwrapContext(context);
     if (context == null) {
       return;
     }
-    // mark as removed
-    _markRemovedContext(context);
+    // remove sources
     removeSources(context, null);
     // remove context
     _contextToSourceToKeys.remove(context);
     _contextToSourceToLocations.remove(context);
     _contextToLibraryToUnits.remove(context);
     _contextToUnitToLibraries.remove(context);
   }
 
   void removeSource(AnalysisContext context, Source unit) {
     context = unwrapContext(context);
@@ skipping 71 matching lines @@
   MemoryIndexStoreImpl_ElementRelationKey _getCanonicalKey(Element element, Relationship relationship) {
     MemoryIndexStoreImpl_ElementRelationKey key = new MemoryIndexStoreImpl_ElementRelationKey(element, relationship);
     MemoryIndexStoreImpl_ElementRelationKey canonicalKey = _canonicalKeys[key];
     if (canonicalKey == null) {
       canonicalKey = key;
       _canonicalKeys[key] = canonicalKey;
     }
     return canonicalKey;
   }
 
-  /**
-   * Checks if given [AnalysisContext] is marked as removed.
-   */
-  bool _isRemovedContext(AnalysisContext context) => _removedContexts[context] != null;
-
-  /**
-   * Marks given [AnalysisContext] as removed.
-   */
-  void _markRemovedContext(AnalysisContext context) {
-    _removedContexts[context] = true;
-  }
-
   void _recordUnitInLibrary(AnalysisContext context, Source library, Source unit) {
     Map<Source, Set<Source>> unitToLibraries = _contextToUnitToLibraries[context];
     if (unitToLibraries == null) {
       unitToLibraries = {};
       _contextToUnitToLibraries[context] = unitToLibraries;
     }
     Set<Source> libraries = unitToLibraries[unit];
     if (libraries == null) {
       libraries = new Set();
       unitToLibraries[unit] = libraries;
@@ skipping 239 matching lines @@
    * Return the unique identifier for this relationship.
    *
    * @return the unique identifier for this relationship
    */
   String get identifier => _uniqueId;
 
   String toString() => _uniqueId;
 }
 
 /**
- * Implementation of [Index].
- */
-class IndexImpl implements Index {
-  IndexStore _store;
-
-  OperationQueue _queue;
-
-  OperationProcessor _processor;
-
-  IndexImpl(IndexStore store, OperationQueue queue, OperationProcessor processor) {
-    this._store = store;
-    this._queue = queue;
-    this._processor = processor;
-  }
-
-  void getRelationships(Element element, Relationship relationship, RelationshipCallback callback) {
-    _queue.enqueue(new GetRelationshipsOperation(_store, element, relationship, callback));
-  }
-
-  String get statistics => _store.statistics;
-
-  void indexHtmlUnit(AnalysisContext context, ht.HtmlUnit unit) {
-    if (unit == null) {
-      return;
-    }
-    if (unit.element == null) {
-      return;
-    }
-    if (unit.element.angularCompilationUnit == null) {
-      return;
-    }
-    _queue.enqueue(new IndexHtmlUnitOperation(_store, context, unit));
-  }
-
-  void indexUnit(AnalysisContext context, CompilationUnit unit) {
-    if (unit == null) {
-      return;
-    }
-    if (unit.element == null) {
-      return;
-    }
-    _queue.enqueue(new IndexUnitOperation(_store, context, unit));
-  }
-
-  void removeContext(AnalysisContext context) {
-    _queue.enqueue(new RemoveContextOperation(_store, context));
-  }
-
-  void removeSource(AnalysisContext context, Source source) {
-    _queue.enqueue(new RemoveSourceOperation(_store, context, source));
-  }
-
-  void removeSources(AnalysisContext context, SourceContainer container) {
-    _queue.enqueue(new RemoveSourcesOperation(_store, context, container));
-  }
-
-  void run() {
-    _processor.run();
-  }
-
-  void stop() {
-    _processor.stop(false);
-  }
-}
-
-/**
  * Instances of the [RemoveSourcesOperation] implement an operation that removes from the
  * index any data based on the content of source belonging to a [SourceContainer].
  */
 class RemoveSourcesOperation implements IndexOperation {
   /**
    * The index store against which this operation is being run.
    */
   IndexStore _indexStore;
 
   /**
@@ skipping 31 matching lines @@
 
 /**
  * The interface `UniverseElement` defines element to use when we want to request "defines"
  * relations without specifying exact library.
  */
 abstract class UniverseElement implements Element {
   static final UniverseElement INSTANCE = UniverseElementImpl.INSTANCE;
 }
 
 /**
- * Instances of the [OperationProcessor] process the operations on a single
- * [OperationQueue]. Each processor can be run one time on a single thread.
- */
-class OperationProcessor {
-  /**
-   * The queue containing the operations to be processed.
-   */
-  OperationQueue _queue;
-
-  /**
-   * The current state of the processor.
-   */
-  ProcessorState _state = ProcessorState.READY;
-
-  /**
-   * The number of milliseconds for which the thread on which the processor is running will wait for
-   * an operation to become available if there are no operations ready to be processed.
-   */
-  static int _WAIT_DURATION = 100;
-
-  /**
-   * Initialize a newly created operation processor to process the operations on the given queue.
-   *
-   * @param queue the queue containing the operations to be processed
-   */
-  OperationProcessor(OperationQueue queue) {
-    this._queue = queue;
-  }
-
-  /**
-   * Start processing operations. If the processor is already running on a different thread, then
-   * this method will return immediately with no effect. Otherwise, this method will not return
-   * until after the processor has been stopped from a different thread or until the thread running
-   * the processor has been interrupted.
-   */
-  void run() {
-    // This processor is, or was, already running on a different thread.
-    if (_state != ProcessorState.READY) {
-      throw new IllegalStateException("Operation processors can only be run one time");
-    }
-    // OK, run.
-    _state = ProcessorState.RUNNING;
-    try {
-      while (isRunning) {
-        // wait for operation
-        IndexOperation operation = null;
-        {
-          operation = _queue.dequeue(_WAIT_DURATION);
-        }
-        // perform operation
-        if (operation != null) {
-          try {
-            operation.performOperation();
-          } catch (exception) {
-            AnalysisEngine.instance.logger.logError2("Exception in indexing operation: ${operation}", exception);
-          }
-        }
-      }
-    } finally {
-      _state = ProcessorState.STOPPED;
-    }
-  }
-
-  /**
-   * Stop processing operations after the current operation has completed. If the argument is
-   * `true` then this method will wait until the last operation has completed; otherwise this
-   * method might return before the last operation has completed.
-   *
-   * @param wait `true` if this method will wait until the last operation has completed before
-   *          returning
-   * @return the library files for the libraries that need to be analyzed when a new session is
-   *         started.
-   */
-  List<Source> stop(bool wait) {
-    if (identical(_state, ProcessorState.READY)) {
-      _state = ProcessorState.STOPPED;
-      return unanalyzedSources;
-    } else if (identical(_state, ProcessorState.STOPPED)) {
-      return unanalyzedSources;
-    } else if (identical(_state, ProcessorState.RUNNING)) {
-      _state = ProcessorState.STOP_REQESTED;
-    }
-    while (wait) {
-      if (identical(_state, ProcessorState.STOPPED)) {
-        return unanalyzedSources;
-      }
-      _waitOneMs();
-    }
-    return unanalyzedSources;
-  }
-
-  /**
-   * Waits until processors will switch from "ready" to "running" state.
-   *
-   * @return `true` if processor is now actually in "running" state, e.g. not in "stopped"
-   *         state.
-   */
-  bool waitForRunning() {
-    while (identical(_state, ProcessorState.READY)) {
-      _threadYield();
-    }
-    return identical(_state, ProcessorState.RUNNING);
-  }
-
-  /**
-   * @return the [Source]s that are not indexed yet.
-   */
-  List<Source> get unanalyzedSources {
-    Set<Source> sources = new Set();
-    for (IndexOperation operation in _queue.operations) {
-      if (operation is IndexUnitOperation) {
-        Source source = operation.source;
-        sources.add(source);
-      }
-    }
-    return new List.from(sources);
-  }
-
-  /**
-   * Return `true` if the current state is [ProcessorState#RUNNING].
-   *
-   * @return `true` if this processor is running
-   */
-  bool get isRunning => identical(_state, ProcessorState.RUNNING);
-
-  void _threadYield() {
-  }
-
-  void _waitOneMs() {
-  }
-}
-
-/**
  * The enumeration <code>ProcessorState</code> represents the possible states of an operation
  * processor.
  */
 class ProcessorState extends Enum<ProcessorState> {
   /**
    * The processor is ready to be run (has not been run before).
    */
   static final ProcessorState READY = new ProcessorState('READY', 0);
 
   /**
@@ skipping 1301 matching lines @@
  * Information about [ImportElement] and place where it is referenced using
  * [PrefixElement].
  */
 class IndexContributor_ImportElementInfo {
   ImportElement _element;
 
   int _periodEnd = 0;
 }
 
 /**
- * Factory for [Index] and [IndexStore].
- */
-class IndexFactory {
-  /**
-   * @return the new instance of [Index] which uses given [IndexStore].
-   */
-  static Index newIndex(IndexStore store) {
-    OperationQueue queue = new OperationQueue();
-    OperationProcessor processor = new OperationProcessor(queue);
-    return new IndexImpl(store, queue, processor);
-  }
-
-  /**
-   * @return the new instance of [MemoryIndexStore].
-   */
-  static MemoryIndexStore newMemoryIndexStore() => new MemoryIndexStoreImpl();
-}
-
-/**
- * Instances of the [OperationQueue] represent a queue of operations against the index that
- * are waiting to be performed.
- */
-class OperationQueue {
-  /**
-   * The non-query operations that are waiting to be performed.
-   */
-  Queue<IndexOperation> _nonQueryOperations = new Queue();
-
-  /**
-   * The query operations that are waiting to be performed.
-   */
-  Queue<IndexOperation> _queryOperations = new Queue();
-
-  /**
-   * `true` if query operations should be returned by [dequeue] or {code false}
-   * if not.
-   */
-  bool _processQueries = true;
-
-  /**
-   * If this queue is not empty, then remove the next operation from the head of this queue and
-   * return it. If this queue is empty (see [setProcessQueries], then the behavior
-   * of this method depends on the value of the argument. If the argument is less than or equal to
-   * zero (<code>0</code>), then `null` will be returned immediately. If the argument is
-   * greater than zero, then this method will wait until at least one operation has been added to
-   * this queue or until the given amount of time has passed. If, at the end of that time, this
-   * queue is empty, then `null` will be returned. If this queue is not empty, then the first
-   * operation will be removed and returned.
-   *
-   * Note that `null` can be returned, even if a positive timeout is given.
-   *
-   * Note too that this method's timeout is not treated the same way as the timeout value used for
-   * [Object#wait]. In particular, it is not possible to cause this method to wait for
-   * an indefinite period of time.
-   *
-   * @param timeout the maximum number of milliseconds to wait for an operation to be available
-   *          before giving up and returning `null`
-   * @return the operation that was removed from the queue
-   * @throws InterruptedException if the thread on which this method is running was interrupted
-   *           while it was waiting for an operation to be added to the queue
-   */
-  IndexOperation dequeue(int timeout) {
-    if (_nonQueryOperations.isEmpty && (!_processQueries || _queryOperations.isEmpty)) {
-      if (timeout <= 0) {
-        return null;
-      }
-      _waitForOperationAvailable(timeout);
-    }
-    if (!_nonQueryOperations.isEmpty) {
-      return _nonQueryOperations.removeFirst();
-    }
-    if (_processQueries && !_queryOperations.isEmpty) {
-      return _queryOperations.removeFirst();
-    }
-    return null;
-  }
-
-  /**
-   * Add the given operation to the tail of this queue.
-   *
-   * @param operation the operation to be added to the queue
-   */
-  void enqueue(IndexOperation operation) {
-    if (operation is RemoveSourceOperation) {
-      Source source = operation.source;
-      _removeForSource(source, _nonQueryOperations);
-      _removeForSource(source, _queryOperations);
-    }
-    if (operation.isQuery) {
-      _queryOperations.add(operation);
-    } else {
-      _nonQueryOperations.add(operation);
-    }
-    _notifyOperationAvailable();
-  }
-
-  /**
-   * Return a list containing all of the operations that are currently on the queue. Modifying this
-   * list will not affect the state of the queue.
-   *
-   * @return all of the operations that are currently on the queue
-   */
-  List<IndexOperation> get operations {
-    List<IndexOperation> operations = [];
-    operations.addAll(_nonQueryOperations);
-    operations.addAll(_queryOperations);
-    return operations;
-  }
-
-  /**
-   * Set whether the receiver's [dequeue] method should return query operations.
-   *
-   * @param processQueries `true` if the receiver's [dequeue] method should
-   *          return query operations or `false` if query operations should be queued but not
-   *          returned by the receiver's [dequeue] method until this method is called
-   *          with a value of `true`.
-   */
-  void set processQueries(bool processQueries) {
-    if (this._processQueries != processQueries) {
-      this._processQueries = processQueries;
-      if (processQueries && !_queryOperations.isEmpty) {
-        _notifyOperationAvailable();
-      }
-    }
-  }
-
-  /**
-   * Return the number of operations on the queue.
-   *
-   * @return the number of operations on the queue
-   */
-  int size() => _nonQueryOperations.length + _queryOperations.length;
-
-  void _notifyOperationAvailable() {
-  }
-
-  /**
-   * Removes operations that should be removed when given [Source] is removed.
-   */
-  void _removeForSource(Source source, Queue<IndexOperation> operations) {
-    operations.removeWhere((_) => _.removeWhenSourceRemoved(source));
-  }
-
-  void _waitForOperationAvailable(int timeout) {
-  }
-}
-
-/**
  * Special [Element] which is used to index references to the name without specifying concrete
  * kind of this name - field, method or something else.
  */
 class NameElementImpl extends ElementImpl {
   NameElementImpl(String name) : super.con2("name:${name}", -1);
 
   accept(ElementVisitor visitor) => null;
 
   ElementKind get kind => ElementKind.NAME;
 }
@@ skipping 288 matching lines @@
    * element are available. For example, if the element is a field and the relationship is the
    * is-referenced-by relationship, then this method will be invoked with each location at which the
    * field is referenced.
    *
    * @param element the [Element] that has the relationship with the locations
    * @param relationship the relationship between the given element and the locations
    * @param locations the locations that were found
    */
   void hasRelationships(Element element, Relationship relationship, List<Location> locations);
 }