Unroll 'synchronized {}' 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 35 matching lines @@
    * @param source the [Source] to remove from index
    */
   RemoveSourceOperation(IndexStore indexStore, AnalysisContext context, this.source) {
     this._indexStore = indexStore;
     this._context = context;
   }
 
   bool get isQuery => false;
 
   void performOperation() {
-    {
-      _indexStore.removeSource(_context, source);
-    }
+    _indexStore.removeSource(_context, source);
   }
 
   bool removeWhenSourceRemoved(Source source) => false;
 
   String toString() => "RemoveSource(${source.fullName})";
 }
 
 /**
  * The interface [IndexOperation] defines the behavior of objects used to perform operations
  * on an index.
@@ skipping 573 matching lines @@
   }
 
   /**
    * @return the [Source] to be indexed.
    */
   Source get source => _source;
 
   bool get isQuery => false;
 
   void performOperation() {
-    {
-      try {
-        bool mayIndex = _indexStore.aboutToIndex(_context, _unitElement);
-        if (!mayIndex) {
-          return;
-        }
-        unit.accept(new IndexContributor(_indexStore));
-        unit.accept(new AngularDartIndexContributor(_indexStore));
-      } catch (exception) {
-        AnalysisEngine.instance.logger.logError2("Could not index ${unit.element.location}", exception);
+    try {
+      bool mayIndex = _indexStore.aboutToIndex(_context, _unitElement);
+      if (!mayIndex) {
+        return;
       }
+      unit.accept(new IndexContributor(_indexStore));
+      unit.accept(new AngularDartIndexContributor(_indexStore));
+    } catch (exception) {
+      AnalysisEngine.instance.logger.logError2("Could not index ${unit.element.location}", exception);
     }
   }
 
   bool removeWhenSourceRemoved(Source source) => this._source == source;
 
   String toString() => "IndexUnitOperation(${_source.fullName})";
 }
 
 /**
  * Recursively visits [HtmlUnit] and every embedded [Expression].
@@ skipping 51 matching lines @@
    */
   static Map<String, Relationship> _RelationshipMap = {};
 
   /**
    * Return the relationship with the given unique identifier.
    *
    * @param uniqueId the unique identifier for the relationship
    * @return the relationship with the given unique identifier
    */
   static Relationship getRelationship(String uniqueId) {
-    {
-      Relationship relationship = _RelationshipMap[uniqueId];
-      if (relationship == null) {
-        relationship = new Relationship(uniqueId);
-        _RelationshipMap[uniqueId] = relationship;
-      }
-      return relationship;
+    Relationship relationship = _RelationshipMap[uniqueId];
+    if (relationship == null) {
+      relationship = new Relationship(uniqueId);
+      _RelationshipMap[uniqueId] = relationship;
     }
+    return relationship;
   }
 
   /**
    * @return all registered [Relationship]s.
    */
   static Iterable<Relationship> values() => _RelationshipMap.values;
 
   /**
    * Initialize a newly created relationship to have the given unique identifier.
    *
@@ skipping 107 matching lines @@
    * @param container the [SourceContainer] to remove from index
    */
   RemoveSourcesOperation(IndexStore indexStore, AnalysisContext context, this.container) {
     this._indexStore = indexStore;
     this._context = context;
   }
 
   bool get isQuery => false;
 
   void performOperation() {
-    {
-      _indexStore.removeSources(_context, container);
-    }
+    _indexStore.removeSources(_context, container);
   }
 
   bool removeWhenSourceRemoved(Source source) => false;
 
   String toString() => "RemoveSources(${container})";
 }
 
 /**
  * The interface `UniverseElement` defines element to use when we want to request "defines"
  * relations without specifying exact library.
@@ skipping 32 matching lines @@
     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;
+    // 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;
-      }
+      _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;
-      }
+    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;
-        }
+      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"
@@ skipping 18 matching lines @@
       }
     }
     return new List.from(sources);
   }
 
   /**
    * Return `true` if the current state is [ProcessorState#RUNNING].
    *
    * @return `true` if this processor is running
    */
-  bool get isRunning {
-    {
-      return identical(_state, ProcessorState.RUNNING);
-    }
-  }
+  bool get isRunning => identical(_state, ProcessorState.RUNNING);
 
   void threadYield() {
   }
 
   void waitOneMs() {
   }
 }
 
 /**
  * The enumeration <code>ProcessorState</code> represents the possible states of an operation
@@ skipping 1372 matching lines @@
    * [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 && (!_processQueries || _queryOperations.isEmpty)) {
+      if (timeout <= 0) {
+        return null;
       }
-      if (!_nonQueryOperations.isEmpty) {
-        return _nonQueryOperations.removeFirst();
-      }
-      if (_processQueries && !_queryOperations.isEmpty) {
-        return _queryOperations.removeFirst();
-      }
-      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();
+    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);
-    }
+    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();
-        }
+    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() {
-    {
-      return _nonQueryOperations.length + _queryOperations.length;
-    }
-  }
+  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));
   }
@@ skipping 106 matching lines @@
    * @param indexStore the index store against which this operation is being run
    * @param context the [AnalysisContext] to remove
    */
   RemoveContextOperation(IndexStore indexStore, this.context) {
     this._indexStore = indexStore;
   }
 
   bool get isQuery => false;
 
   void performOperation() {
-    {
-      _indexStore.removeContext(context);
-    }
+    _indexStore.removeContext(context);
   }
 
   bool removeWhenSourceRemoved(Source source) => false;
 
   String toString() => "RemoveContext(${context})";
 }
 
 /**
  * Instances of the [IndexHtmlUnitOperation] implement an operation that adds data to the
  * index based on the resolved [HtmlUnit].
@@ skipping 39 matching lines @@
   }
 
   /**
    * @return the [Source] to be indexed.
    */
   Source get source => _source;
 
   bool get isQuery => false;
 
   void performOperation() {
-    {
-      try {
-        bool mayIndex = _indexStore.aboutToIndex2(_context, _htmlElement);
-        if (!mayIndex) {
-          return;
-        }
-        AngularHtmlIndexContributor contributor = new AngularHtmlIndexContributor(_indexStore);
-        unit.accept(contributor);
-      } catch (exception) {
-        AnalysisEngine.instance.logger.logError2("Could not index ${unit.element.location}", exception);
+    try {
+      bool mayIndex = _indexStore.aboutToIndex2(_context, _htmlElement);
+      if (!mayIndex) {
+        return;
       }
+      AngularHtmlIndexContributor contributor = new AngularHtmlIndexContributor(_indexStore);
+      unit.accept(contributor);
+    } catch (exception) {
+      AnalysisEngine.instance.logger.logError2("Could not index ${unit.element.location}", exception);
     }
   }
 
   bool removeWhenSourceRemoved(Source source) => this._source == source;
 
   String toString() => "IndexHtmlUnitOperation(${_source.fullName})";
 }
 
 /**
  * Instances of the class <code>Location</code> represent a location related to an element. The
@@ skipping 70 matching lines @@
    * relationship with a specified element.
    */
   GetRelationshipsOperation(IndexStore indexStore, this.element, this.relationship, this.callback) {
     this._indexStore = indexStore;
   }
 
   bool get isQuery => true;
 
   void performOperation() {
     List<Location> locations;
-    {
-      locations = _indexStore.getRelationships(element, relationship);
-    }
+    locations = _indexStore.getRelationships(element, relationship);
     callback.hasRelationships(element, relationship, locations);
   }
 
   bool removeWhenSourceRemoved(Source source) => false;
 
   String toString() => "GetRelationships(${element}, ${relationship})";
 }
 
 /**
  * [Location] with attached data.
@@ skipping 18 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);
 }