Rollback pkg/analyzer that breaks code_transformers

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;
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'source.dart';
 import 'scanner.dart' show Token;
 import 'ast.dart';
 import 'element.dart';
 import 'resolver.dart' show Namespace, NamespaceBuilder;
 import 'engine.dart';
 import 'html.dart' as ht;
 
 /**
  * Instances of the [RemoveSourceOperation] implement an operation that removes from the index
  * any data based on the content of a specified source.
  */
 class RemoveSourceOperation implements IndexOperation {
   /**
    * The index store against which this operation is being run.
    */
-  final IndexStore _indexStore;
+  IndexStore _indexStore;
 
   /**
    * The context in which source being removed.
    */
-  final AnalysisContext _context;
+  AnalysisContext _context;
 
   /**
    * The source being removed.
    */
-  final Source source;
+  Source source;
 
   /**
    * Initialize a newly created operation that will remove the specified resource.
    *
    * @param indexStore the index store against which this operation is being run
    * @param context the [AnalysisContext] to remove source in
    * @param source the [Source] to remove from index
    */
-  RemoveSourceOperation(this._indexStore, this._context, this.source);
+  RemoveSourceOperation(IndexStore indexStore, AnalysisContext context, Source source) {
+    this._indexStore = indexStore;
+    this._context = context;
+    this.source = source;
+  }
 
   @override
   bool get isQuery => false;
 
   @override
   void performOperation() {
     _indexStore.removeSource(_context, source);
   }
 
   @override
@@ skipping 466 matching lines @@
               _keyCount--;
             }
           }
         }
       }
     }
   }
 }
 
 class MemoryIndexStoreImpl_ElementRelationKey {
-  final Element _element;
+  Element _element;
 
-  final Relationship _relationship;
+  Relationship _relationship;
 
-  MemoryIndexStoreImpl_ElementRelationKey(this._element, this._relationship);
+  MemoryIndexStoreImpl_ElementRelationKey(Element element, Relationship relationship) {
+    this._element = element;
+    this._relationship = relationship;
+  }
 
   @override
   bool operator ==(Object obj) {
     MemoryIndexStoreImpl_ElementRelationKey other = obj as MemoryIndexStoreImpl_ElementRelationKey;
     Element otherElement = other._element;
     return identical(other._relationship, _relationship) && otherElement.nameOffset == _element.nameOffset && identical(otherElement.kind, _element.kind) && otherElement.displayName == _element.displayName && otherElement.source == _element.source;
   }
 
   @override
   int get hashCode => JavaArrays.makeHashCode([
       _element.source,
       _element.nameOffset,
       _element.kind,
       _element.displayName,
       _relationship]);
 
   @override
   String toString() => "${_element} ${_relationship}";
 }
 
 class MemoryIndexStoreImpl_Source2 {
-  final Source _librarySource;
+  Source _librarySource;
 
-  final Source _unitSource;
+  Source _unitSource;
 
-  MemoryIndexStoreImpl_Source2(this._librarySource, this._unitSource);
+  MemoryIndexStoreImpl_Source2(Source librarySource, Source unitSource) {
+    this._librarySource = librarySource;
+    this._unitSource = unitSource;
+  }
 
   @override
   bool operator ==(Object obj) {
     if (identical(obj, this)) {
       return true;
     }
     if (obj is! MemoryIndexStoreImpl_Source2) {
       return false;
     }
     MemoryIndexStoreImpl_Source2 other = obj as MemoryIndexStoreImpl_Source2;
     return other._librarySource == _librarySource && other._unitSource == _unitSource;
   }
 
   @override
   int get hashCode => JavaArrays.makeHashCode([_librarySource, _unitSource]);
 
   @override
   String toString() => "${_librarySource} ${_unitSource}";
 }
 
 /**
  * Instances of the [IndexUnitOperation] implement an operation that adds data to the index
  * based on the resolved [CompilationUnit].
  */
 class IndexUnitOperation implements IndexOperation {
   /**
    * The index store against which this operation is being run.
    */
-  final IndexStore _indexStore;
+  IndexStore _indexStore;
 
   /**
    * The context in which compilation unit was resolved.
    */
-  final AnalysisContext _context;
+  AnalysisContext _context;
 
   /**
    * The compilation unit being indexed.
    */
-  final CompilationUnit unit;
+  CompilationUnit unit;
 
   /**
    * The element of the compilation unit being indexed.
    */
   CompilationUnitElement _unitElement;
 
   /**
    * The source being indexed.
    */
   Source _source;
 
   /**
    * Initialize a newly created operation that will index the specified unit.
    *
    * @param indexStore the index store against which this operation is being run
    * @param context the context in which compilation unit was resolved
    * @param unit the fully resolved AST structure
    */
-  IndexUnitOperation(this._indexStore, this._context, this.unit) {
+  IndexUnitOperation(IndexStore indexStore, AnalysisContext context, CompilationUnit unit) {
+    this._indexStore = indexStore;
+    this._context = context;
+    this.unit = unit;
     this._unitElement = unit.element;
     this._source = _unitElement.source;
   }
 
   /**
    * @return the [Source] to be indexed.
    */
   Source get source => _source;
 
   @override
@@ skipping 64 matching lines @@
 }
 
 /**
  * Relationship between an element and a location. Relationships are identified by a globally unique
  * identifier.
  */
 class Relationship {
   /**
    * The unique identifier for this relationship.
    */
-  final String _uniqueId;
+  String _uniqueId;
 
   /**
    * A table mapping relationship identifiers to relationships.
    */
   static Map<String, Relationship> _RelationshipMap = {};
 
   /**
    * Return the relationship with the given unique identifier.
    *
    * @param uniqueId the unique identifier for the relationship
@@ skipping 11 matching lines @@
   /**
    * @return all registered [Relationship]s.
    */
   static Iterable<Relationship> values() => _RelationshipMap.values;
 
   /**
    * Initialize a newly created relationship to have the given unique identifier.
    *
    * @param uniqueId the unique identifier for this relationship
    */
-  Relationship(this._uniqueId);
+  Relationship(String uniqueId) {
+    this._uniqueId = uniqueId;
+  }
 
   /**
    * Return the unique identifier for this relationship.
    *
    * @return the unique identifier for this relationship
    */
   String get identifier => _uniqueId;
 
   @override
   String toString() => _uniqueId;
 }
 
 /**
  * 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.
    */
-  final IndexStore _indexStore;
+  IndexStore _indexStore;
 
   /**
    * The context to remove container.
    */
-  final AnalysisContext _context;
+  AnalysisContext _context;
 
   /**
    * The source container to remove.
    */
-  final SourceContainer container;
+  SourceContainer container;
 
   /**
    * Initialize a newly created operation that will remove the specified resource.
    *
    * @param indexStore the index store against which this operation is being run
    * @param context the [AnalysisContext] to remove container in
    * @param container the [SourceContainer] to remove from index
    */
-  RemoveSourcesOperation(this._indexStore, this._context, this.container);
+  RemoveSourcesOperation(IndexStore indexStore, AnalysisContext context, SourceContainer container) {
+    this._indexStore = indexStore;
+    this._context = context;
+    this.container = container;
+  }
 
   @override
   bool get isQuery => false;
 
   @override
   void performOperation() {
     _indexStore.removeSources(_context, container);
   }
 
   @override
@@ skipping 12 matching lines @@
 }
 
 /**
  * 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 const ProcessorState READY = const ProcessorState('READY', 0);
+  static final ProcessorState READY = new ProcessorState('READY', 0);
 
   /**
    * The processor is currently performing operations.
    */
-  static const ProcessorState RUNNING = const ProcessorState('RUNNING', 1);
+  static final ProcessorState RUNNING = new ProcessorState('RUNNING', 1);
 
   /**
    * The processor is currently performing operations but has been asked to stop.
    */
-  static const ProcessorState STOP_REQESTED = const ProcessorState('STOP_REQESTED', 2);
+  static final ProcessorState STOP_REQESTED = new ProcessorState('STOP_REQESTED', 2);
 
   /**
    * The processor has stopped performing operations and cannot be used again.
    */
-  static const ProcessorState STOPPED = const ProcessorState('STOPPED', 3);
+  static final ProcessorState STOPPED = new ProcessorState('STOPPED', 3);
 
-  static const List<ProcessorState> values = const [READY, RUNNING, STOP_REQESTED, STOPPED];
+  static final List<ProcessorState> values = [READY, RUNNING, STOP_REQESTED, STOPPED];
 
-  const ProcessorState(String name, int ordinal) : super(name, ordinal);
+  ProcessorState(String name, int ordinal) : super(name, ordinal);
 }
 
 /**
  * Constants used when populating and accessing the index.
  */
 abstract class IndexConstants {
   /**
    * An element used to represent the universe.
    */
   static final Element UNIVERSE = UniverseElement.INSTANCE;
@@ skipping 134 matching lines @@
   static final Relationship ANGULAR_CLOSING_TAG_REFERENCE = Relationship.getRelationship("angular-closing-tag-reference");
 }
 
 /**
  * Visits resolved [HtmlUnit] and adds relationships into [IndexStore].
  */
 class AngularHtmlIndexContributor extends ExpressionVisitor {
   /**
    * The [IndexStore] to record relations into.
    */
-  final IndexStore _store;
+  IndexStore _store;
 
   /**
    * The index contributor used to index Dart [Expression]s.
    */
   IndexContributor _indexContributor;
 
   HtmlElement _htmlUnitElement;
 
   /**
    * Initialize a newly created Angular HTML index contributor.
    *
    * @param store the [IndexStore] to record relations into.
    */
-  AngularHtmlIndexContributor(this._store) {
-    _indexContributor = new IndexContributor_AngularHtmlIndexContributor(_store, this);
+  AngularHtmlIndexContributor(IndexStore store) {
+    this._store = store;
+    _indexContributor = new IndexContributor_AngularHtmlIndexContributor(store, this);
   }
 
   @override
   void visitExpression(Expression expression) {
     // NgFilter
     if (expression is SimpleIdentifier) {
       SimpleIdentifier identifier = expression;
       Element element = identifier.bestElement;
       if (element is AngularElement) {
         _store.recordRelationship(element, IndexConstants.ANGULAR_REFERENCE, _createLocationForIdentifier(identifier));
@@ skipping 528 matching lines @@
     if (parent is PropertyAccess) {
       return identical(parent.propertyName, node);
     }
     if (parent is MethodInvocation) {
       MethodInvocation invocation = parent;
       return invocation.realTarget != null && identical(invocation.methodName, node);
     }
     return false;
   }
 
-  final IndexStore _store;
+  IndexStore _store;
 
   LibraryElement _libraryElement;
 
   Map<ImportElement, Set<Element>> _importElementsMap = {};
 
   /**
    * A stack whose top element (the element with the largest index) is an element representing the
    * inner-most enclosing scope.
    */
   Queue<Element> _elementStack = new Queue();
 
-  IndexContributor(this._store);
+  IndexContributor(IndexStore store) {
+    this._store = store;
+  }
 
   /**
    * Enter a new scope represented by the given [Element].
    */
   void enterScope(Element element) {
     _elementStack.addFirst(element);
   }
 
   /**
    * @return the inner-most enclosing [Element], may be `null`.
@@ skipping 591 matching lines @@
 
   @override
   ElementKind get kind => ElementKind.NAME;
 }
 
 /**
  * Visits resolved [CompilationUnit] and adds Angular specific relationships into
  * [IndexStore].
  */
 class AngularDartIndexContributor extends GeneralizingAstVisitor<Object> {
-  final IndexStore _store;
+  IndexStore _store;
 
-  AngularDartIndexContributor(this._store);
+  AngularDartIndexContributor(IndexStore store) {
+    this._store = store;
+  }
 
   @override
   Object visitClassDeclaration(ClassDeclaration node) {
     ClassElement classElement = node.element;
     if (classElement != null) {
       List<ToolkitObjectElement> toolkitObjects = classElement.toolkitObjects;
       for (ToolkitObjectElement object in toolkitObjects) {
         if (object is AngularComponentElement) {
           _indexComponent(object);
         }
@@ skipping 51 matching lines @@
 }
 
 /**
  * Instances of the [RemoveContextOperation] implement an operation that removes from the
  * index any data based on the specified [AnalysisContext].
  */
 class RemoveContextOperation implements IndexOperation {
   /**
    * The index store against which this operation is being run.
    */
-  final IndexStore _indexStore;
+  IndexStore _indexStore;
 
   /**
    * The context being removed.
    */
-  final AnalysisContext context;
+  AnalysisContext context;
 
   /**
    * Initialize a newly created operation that will remove the specified resource.
    *
    * @param indexStore the index store against which this operation is being run
    * @param context the [AnalysisContext] to remove
    */
-  RemoveContextOperation(this._indexStore, this.context);
+  RemoveContextOperation(IndexStore indexStore, AnalysisContext context) {
+    this._indexStore = indexStore;
+    this.context = context;
+  }
 
   @override
   bool get isQuery => false;
 
   @override
   void performOperation() {
     _indexStore.removeContext(context);
   }
 
   @override
   bool removeWhenSourceRemoved(Source source) => false;
 
   @override
   String toString() => "RemoveContext(${context})";
 }
 
 /**
  * Instances of the [IndexHtmlUnitOperation] implement an operation that adds data to the
  * index based on the resolved [HtmlUnit].
  */
 class IndexHtmlUnitOperation implements IndexOperation {
   /**
    * The index store against which this operation is being run.
    */
-  final IndexStore _indexStore;
+  IndexStore _indexStore;
 
   /**
    * The context in which [HtmlUnit] was resolved.
    */
-  final AnalysisContext _context;
+  AnalysisContext _context;
 
   /**
    * The [HtmlUnit] being indexed.
    */
-  final ht.HtmlUnit unit;
+  ht.HtmlUnit unit;
 
   /**
    * The element of the [HtmlUnit] being indexed.
    */
   HtmlElement _htmlElement;
 
   /**
    * The source being indexed.
    */
   Source _source;
 
   /**
    * Initialize a newly created operation that will index the specified [HtmlUnit].
    *
    * @param indexStore the index store against which this operation is being run
    * @param context the context in which [HtmlUnit] was resolved
    * @param unit the fully resolved [HtmlUnit]
    */
-  IndexHtmlUnitOperation(this._indexStore, this._context, this.unit) {
+  IndexHtmlUnitOperation(IndexStore indexStore, AnalysisContext context, ht.HtmlUnit unit) {
+    this._indexStore = indexStore;
+    this._context = context;
+    this.unit = unit;
     this._htmlElement = unit.element;
     this._source = _htmlElement.source;
   }
 
   /**
    * @return the [Source] to be indexed.
    */
   Source get source => _source;
 
   @override
@@ skipping 27 matching lines @@
  */
 class Location {
   /**
    * An empty array of locations.
    */
   static List<Location> EMPTY_ARRAY = new List<Location>(0);
 
   /**
    * The element containing this location.
    */
-  final Element element;
+  Element element;
 
   /**
    * The offset of this location within the resource containing the element.
    */
-  final int offset;
+  int offset = 0;
 
   /**
    * The length of this location.
    */
-  final int length;
+  int length = 0;
 
   /**
    * Internal field used to hold a key that is referenced at this location.
    */
   Object internalKey;
 
   /**
    * Initialize a newly create location to be relative to the given element at the given offset with
    * the given length.
    *
    * @param element the [Element] containing this location
    * @param offset the offset of this location within the resource containing the element
    * @param length the length of this location
    */
-  Location(this.element, this.offset, this.length) {
+  Location(Element element, int offset, int length) {
     if (element == null) {
       throw new IllegalArgumentException("element location cannot be null");
     }
+    this.element = element;
+    this.offset = offset;
+    this.length = length;
   }
 
   /**
    * Returns a clone of this [Location].
    */
   Location newClone() => new Location(element, offset, length);
 
   @override
   String toString() => "[${offset} - ${(offset + length)}) in ${element}";
 }
 
 /**
  * [IndexStore] which keeps all information in memory, but can write it to stream and read
  * later.
  */
 abstract class MemoryIndexStore implements IndexStore {
 }
 
 /**
  * Instances of the [GetRelationshipsOperation] implement an operation used to access the
  * locations that have a specified relationship with a specified element.
  */
 class GetRelationshipsOperation implements IndexOperation {
-  final IndexStore _indexStore;
+  IndexStore _indexStore;
 
-  final Element element;
+  Element element;
 
-  final Relationship relationship;
+  Relationship relationship;
 
-  final RelationshipCallback callback;
+  RelationshipCallback callback;
 
   /**
    * Initialize a newly created operation that will access the locations that have a specified
    * relationship with a specified element.
    */
-  GetRelationshipsOperation(this._indexStore, this.element, this.relationship, this.callback);
+  GetRelationshipsOperation(IndexStore indexStore, Element element, Relationship relationship, RelationshipCallback callback) {
+    this._indexStore = indexStore;
+    this.element = element;
+    this.relationship = relationship;
+    this.callback = callback;
+  }
 
   @override
   bool get isQuery => true;
 
   @override
   void performOperation() {
     List<Location> locations;
     locations = _indexStore.getRelationships(element, relationship);
     callback.hasRelationships(element, relationship, locations);
   }
 
   @override
   bool removeWhenSourceRemoved(Source source) => false;
 
   @override
   String toString() => "GetRelationships(${element}, ${relationship})";
 }
 
 /**
  * [Location] with attached data.
  */
 class LocationWithData<D> extends Location {
-  final D data;
+  D data;
 
-  LocationWithData.con1(Location location, this.data) : super(location.element, location.offset, location.length);
+  LocationWithData.con1(Location location, D data) : super(location.element, location.offset, location.length) {
+    this.data = data;
+  }
 
-  LocationWithData.con2(Element element, int offset, int length, this.data) : super(element, offset, length);
+  LocationWithData.con2(Element element, int offset, int length, D data) : super(element, offset, length) {
+    this.data = data;
+  }
 
   @override
   Location newClone() => new LocationWithData<D>.con2(element, offset, length, data);
 }
 
 /**
  * The interface <code>RelationshipCallback</code> defines the behavior of objects that are invoked
  * with the results of a query about a given relationship.
  */
 abstract class RelationshipCallback {
   /**
    * This method is invoked when the locations that have a specified relationship with a specified
    * 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);
 }