Issue 8742. Preserve leading line comments during java2dart translation.

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 153 matching lines @@
   Map<AnalysisContext, Map<Source, Set<Source>>> _contextToUnitToLibraries = {};
 
   int _sourceCount = 0;
 
   int _keyCount = 0;
 
   int _locationCount = 0;
 
   bool aboutToIndex(AnalysisContext context, CompilationUnitElement unitElement) {
     context = unwrapContext(context);
+    // may be already removed in other thread
     if (isRemovedContext(context)) {
       return false;
     }
+    // validate unit
     if (unitElement == null) {
       return false;
     }
     LibraryElement libraryElement = unitElement.library;
     if (libraryElement == null) {
       return false;
     }
     CompilationUnitElement definingUnitElement = libraryElement.definingCompilationUnit;
     if (definingUnitElement == null) {
       return false;
     }
+    // prepare sources
     Source library = definingUnitElement.source;
     Source unit = unitElement.source;
+    // special handling for the defining library unit
     if (unit == library) {
+      // prepare new parts
       Set<Source> newParts = new Set();
       for (CompilationUnitElement part in libraryElement.parts) {
         newParts.add(part.source);
       }
+      // prepare old parts
       Map<Source, Set<Source>> libraryToUnits = _contextToLibraryToUnits[context];
       if (libraryToUnits == null) {
         libraryToUnits = {};
         _contextToLibraryToUnits[context] = libraryToUnits;
       }
       Set<Source> oldParts = libraryToUnits[library];
+      // check if some parts are not in the library now
       if (oldParts != null) {
         Set<Source> noParts = oldParts.difference(newParts);
         for (Source noPart in noParts) {
           removeLocations(context, library, noPart);
         }
       }
+      // remember new parts
       libraryToUnits[library] = newParts;
     }
+    // remember libraries in which unit is used
     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;
     }
     libraries.add(library);
+    // remove locations
     removeLocations(context, library, unit);
+    // remove keys
     {
       Map<MemoryIndexStoreImpl_Source2, Set<MemoryIndexStoreImpl_ElementRelationKey>> sourceToKeys = _contextToSourceToKeys[context];
       if (sourceToKeys != null) {
         MemoryIndexStoreImpl_Source2 source2 = new MemoryIndexStoreImpl_Source2(library, unit);
         sourceToKeys.remove(source2);
       }
     }
+    // OK, we can index
     return true;
   }
 
   bool aboutToIndex2(AnalysisContext context, Source source) {
     context = unwrapContext(context);
+    // may be already removed in other thread
     if (isRemovedContext(context)) {
       return false;
     }
+    // remove locations
     removeLocations(context, source, source);
+    // remove keys
     {
       Map<MemoryIndexStoreImpl_Source2, Set<MemoryIndexStoreImpl_ElementRelationKey>> sourceToKeys = _contextToSourceToKeys[context];
       if (sourceToKeys != null) {
         MemoryIndexStoreImpl_Source2 source2 = new MemoryIndexStoreImpl_Source2(source, source);
         sourceToKeys.remove(source2);
       }
     }
+    // OK, we can index
     return true;
   }
 
   List<Location> getRelationships(Element element, Relationship relationship) {
     MemoryIndexStoreImpl_ElementRelationKey key = new MemoryIndexStoreImpl_ElementRelationKey(element, relationship);
     Set<Location> locations = _keyToLocations[key];
     if (locations != null) {
       return new List.from(locations);
     }
     return Location.EMPTY_ARRAY;
@@ skipping 33 matching lines @@
       }
     }
     return count;
   }
 
   void recordRelationship(Element element, Relationship relationship, Location location) {
     if (element == null || location == null) {
       return;
     }
     location = location.clone();
+    // at the index level we don't care about Member(s)
     if (element is Member) {
       element = (element as Member).baseElement;
     }
+    // prepare information
     AnalysisContext elementContext = element.context;
     AnalysisContext locationContext = location.element.context;
     Source elementSource = element.source;
     Source locationSource = location.element.source;
     Source elementLibrarySource = getLibrarySourceOrNull(element);
     Source locationLibrarySource = getLibrarySourceOrNull(location.element);
+    // sanity check
     if (locationContext == null) {
       return;
     }
     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)) {
       return;
     }
     if (isRemovedContext(locationContext)) {
       return;
     }
+    // record: key -> location(s)
     MemoryIndexStoreImpl_ElementRelationKey key = getCanonicalKey(element, relationship);
     {
       Set<Location> locations = _keyToLocations.remove(key);
       if (locations == null) {
         locations = createLocationIdentitySet();
       } else {
         _keyCount--;
       }
       _keyToLocations[key] = locations;
       _keyCount++;
       locations.add(location);
       _locationCount++;
     }
+    // record: location -> key
     location.internalKey = key;
+    // prepare source pairs
     MemoryIndexStoreImpl_Source2 elementSource2 = new MemoryIndexStoreImpl_Source2(elementLibrarySource, elementSource);
     MemoryIndexStoreImpl_Source2 locationSource2 = new MemoryIndexStoreImpl_Source2(locationLibrarySource, locationSource);
+    // record: element source -> keys
     {
       Map<MemoryIndexStoreImpl_Source2, Set<MemoryIndexStoreImpl_ElementRelationKey>> sourceToKeys = _contextToSourceToKeys[elementContext];
       if (sourceToKeys == null) {
         sourceToKeys = {};
         _contextToSourceToKeys[elementContext] = sourceToKeys;
       }
       Set<MemoryIndexStoreImpl_ElementRelationKey> keys = sourceToKeys[elementSource2];
       if (keys == null) {
         keys = new Set();
         sourceToKeys[elementSource2] = keys;
         _sourceCount++;
       }
       keys.remove(key);
       keys.add(key);
     }
+    // record: location source -> locations
     {
       Map<MemoryIndexStoreImpl_Source2, List<Location>> sourceToLocations = _contextToSourceToLocations[locationContext];
       if (sourceToLocations == null) {
         sourceToLocations = {};
         _contextToSourceToLocations[locationContext] = sourceToLocations;
       }
       List<Location> locations = sourceToLocations[locationSource2];
       if (locations == null) {
         locations = [];
         sourceToLocations[locationSource2] = locations;
       }
       locations.add(location);
     }
   }
 
   void removeContext(AnalysisContext context) {
     context = unwrapContext(context);
     if (context == null) {
       return;
     }
+    // mark as removed
     markRemovedContext(context);
     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);
     if (context == null) {
       return;
     }
+    // remove locations defined in source
     Map<Source, Set<Source>> unitToLibraries = _contextToUnitToLibraries[context];
     if (unitToLibraries != null) {
       Set<Source> libraries = unitToLibraries.remove(unit);
       if (libraries != null) {
         for (Source library in libraries) {
           MemoryIndexStoreImpl_Source2 source2 = new MemoryIndexStoreImpl_Source2(library, unit);
+          // remove locations defined in source
           removeLocations(context, library, unit);
+          // remove keys for elements defined in source
           Map<MemoryIndexStoreImpl_Source2, Set<MemoryIndexStoreImpl_ElementRelationKey>> sourceToKeys = _contextToSourceToKeys[context];
           if (sourceToKeys != null) {
             Set<MemoryIndexStoreImpl_ElementRelationKey> keys = sourceToKeys.remove(source2);
             if (keys != null) {
               for (MemoryIndexStoreImpl_ElementRelationKey key in keys) {
                 _canonicalKeys.remove(key);
                 Set<Location> locations = _keyToLocations.remove(key);
                 if (locations != null) {
                   _keyCount--;
                   _locationCount -= locations.length;
                 }
               }
               _sourceCount--;
             }
           }
         }
       }
     }
   }
 
   void removeSources(AnalysisContext context, SourceContainer container) {
     context = unwrapContext(context);
     if (context == null) {
       return;
     }
+    // remove sources #1
     Map<MemoryIndexStoreImpl_Source2, Set<MemoryIndexStoreImpl_ElementRelationKey>> sourceToKeys = _contextToSourceToKeys[context];
     if (sourceToKeys != null) {
       List<MemoryIndexStoreImpl_Source2> sources = [];
       for (MemoryIndexStoreImpl_Source2 source2 in sources) {
         Source source = source2._unitSource;
         if (container == null || container.contains(source)) {
           removeSource(context, source);
         }
       }
     }
+    // remove sources #2
     Map<MemoryIndexStoreImpl_Source2, List<Location>> sourceToLocations = _contextToSourceToLocations[context];
     if (sourceToLocations != null) {
       List<MemoryIndexStoreImpl_Source2> sources = [];
       for (MemoryIndexStoreImpl_Source2 source2 in sources) {
         Source source = source2._unitSource;
         if (container == null || container.contains(source)) {
           removeSource(context, source);
         }
       }
     }
@@ skipping 38 matching lines @@
     Map<MemoryIndexStoreImpl_Source2, List<Location>> sourceToLocations = _contextToSourceToLocations[context];
     if (sourceToLocations != null) {
       List<Location> sourceLocations = sourceToLocations.remove(source2);
       if (sourceLocations != null) {
         for (Location location in sourceLocations) {
           MemoryIndexStoreImpl_ElementRelationKey key = location.internalKey as MemoryIndexStoreImpl_ElementRelationKey;
           Set<Location> relLocations = _keyToLocations[key];
           if (relLocations != null) {
             relLocations.remove(location);
             _locationCount--;
+            // no locations with this key
             if (relLocations.isEmpty) {
               _canonicalKeys.remove(key);
               _keyToLocations.remove(key);
               _keyCount--;
             }
           }
         }
       }
     }
   }
@@ skipping 372 matching lines @@
   }
 
   /**
    * 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 {
       {
@@ skipping 556 matching lines @@
     IndexContributor_ImportElementInfo info = getImportElementInfo(prefixNode);
     return info != null ? info._element : null;
   }
 
   /**
    * @return the [ImportElementInfo] with [ImportElement] that is referenced by this
    *         node with [PrefixElement], may be `null`.
    */
   static IndexContributor_ImportElementInfo getImportElementInfo(SimpleIdentifier prefixNode) {
     IndexContributor_ImportElementInfo info = new IndexContributor_ImportElementInfo();
+    // prepare environment
     ASTNode parent = prefixNode.parent;
     CompilationUnit unit = prefixNode.getAncestor(CompilationUnit);
     LibraryElement libraryElement = unit.element.library;
+    // prepare used element
     Element usedElement = null;
     if (parent is PrefixedIdentifier) {
       PrefixedIdentifier prefixed = parent;
       usedElement = prefixed.staticElement;
       info._periodEnd = prefixed.period.end;
     }
     if (parent is MethodInvocation) {
       MethodInvocation invocation = parent;
       usedElement = invocation.methodName.staticElement;
       info._periodEnd = invocation.period.end;
     }
+    // we need used Element
     if (usedElement == null) {
       return null;
     }
+    // find ImportElement
     String prefix = prefixNode.name;
     Map<ImportElement, Set<Element>> importElementsMap = {};
     info._element = getImportElement2(libraryElement, prefix, usedElement, importElementsMap);
     if (info._element == null) {
       return null;
     }
     return info;
   }
 
   /**
    * @return the [ImportElement] that declares given [PrefixElement] and imports library
    *         with given "usedElement".
    */
   static ImportElement getImportElement2(LibraryElement libraryElement, String prefix, Element usedElement, Map<ImportElement, Set<Element>> importElementsMap) {
+    // validate Element
     if (usedElement == null) {
       return null;
     }
     if (usedElement.enclosingElement is! CompilationUnitElement) {
       return null;
     }
     LibraryElement usedLibrary = usedElement.library;
+    // find ImportElement that imports used library with used prefix
     List<ImportElement> candidates = null;
     for (ImportElement importElement in libraryElement.imports) {
+      // required library
       if (importElement.importedLibrary != usedLibrary) {
         continue;
       }
+      // required prefix
       PrefixElement prefixElement = importElement.prefix;
       if (prefix == null) {
         if (prefixElement != null) {
           continue;
         }
       } else {
         if (prefixElement == null) {
           continue;
         }
         if (prefix != prefixElement.name) {
           continue;
         }
       }
+      // no combinators => only possible candidate
       if (importElement.combinators.length == 0) {
         return importElement;
       }
+      // OK, we have candidate
       if (candidates == null) {
         candidates = [];
       }
       candidates.add(importElement);
     }
+    // no candidates, probably element is defined in this library
     if (candidates == null) {
       return null;
     }
+    // one candidate
     if (candidates.length == 1) {
       return candidates[0];
     }
+    // ensure that each ImportElement has set of elements
     for (ImportElement importElement in candidates) {
       if (importElementsMap.containsKey(importElement)) {
         continue;
       }
       Namespace namespace = new NamespaceBuilder().createImportNamespace(importElement);
       Set<Element> elements = new Set();
       importElementsMap[importElement] = elements;
     }
+    // use import namespace to choose correct one
     for (MapEntry<ImportElement, Set<Element>> entry in getMapEntrySet(importElementsMap)) {
       if (entry.getValue().contains(usedElement)) {
         return entry.getKey();
       }
     }
+    // not found
     return null;
   }
 
   /**
    * If the given expression has resolved type, returns the new location with this type.
    *
    * @param location the base location
    * @param expression the expression assigned at the given location
    */
   static Location getLocationWithExpressionType(Location location, Expression expression) {
@@ skipping 21 matching lines @@
    * If the given identifier has a synthetic [PropertyAccessorElement], i.e. accessor for
    * normal field, and it is LHS of assignment, then include [Type] of the assigned value into
    * the [Location].
    *
    * @param identifier the identifier to record location
    * @param element the element of the identifier
    * @param location the raw location
    * @return the [Location] with the type of the assigned value
    */
   static Location getLocationWithTypeAssignedToField(SimpleIdentifier identifier, Element element, Location location) {
+    // we need accessor
     if (element is! PropertyAccessorElement) {
       return location;
     }
     PropertyAccessorElement accessor = element as PropertyAccessorElement;
+    // should be setter
     if (!accessor.isSetter) {
       return location;
     }
+    // accessor should be synthetic, i.e. field normal
     if (!accessor.isSynthetic) {
       return location;
     }
+    // should be LHS of assignment
     ASTNode parent;
     {
       ASTNode node = identifier;
       parent = node.parent;
+      // new T().field = x;
       if (parent is PropertyAccess) {
         PropertyAccess propertyAccess = parent as PropertyAccess;
         if (identical(propertyAccess.propertyName, node)) {
           node = propertyAccess;
           parent = propertyAccess.parent;
         }
       }
+      // obj.field = x;
       if (parent is PrefixedIdentifier) {
         PrefixedIdentifier prefixedIdentifier = parent as PrefixedIdentifier;
         if (identical(prefixedIdentifier.identifier, node)) {
           node = prefixedIdentifier;
           parent = prefixedIdentifier.parent;
         }
       }
     }
+    // OK, remember the type
     if (parent is AssignmentExpression) {
       AssignmentExpression assignment = parent as AssignmentExpression;
       Expression rhs = assignment.rightHandSide;
       location = getLocationWithExpressionType(location, rhs);
     }
+    // done
     return location;
   }
 
   /**
    * @return `true` if given "node" is part of [PrefixedIdentifier] "prefix.node".
    */
   static bool isIdentifierInPrefixedIdentifier(SimpleIdentifier node) {
     ASTNode parent = node.parent;
     return parent is PrefixedIdentifier && identical(parent.identifier, node);
   }
@@ skipping 142 matching lines @@
       _libraryElement = unitElement.enclosingElement;
       if (_libraryElement != null) {
         return super.visitCompilationUnit(node);
       }
     }
     return null;
   }
 
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     ConstructorElement element = node.element;
+    // define
     {
       Location location;
       if (node.name != null) {
         int start = node.period.offset;
         int end = node.name.end;
         location = createLocation3(start, end - start);
       } else {
         int start = node.returnType.end;
         location = createLocation3(start, 0);
       }
       recordRelationship(element, IndexConstants.IS_DEFINED_BY, location);
     }
+    // visit children
     enterScope(element);
     try {
       return super.visitConstructorDeclaration(node);
     } finally {
       exitScope();
     }
   }
 
   Object visitConstructorName(ConstructorName node) {
     ConstructorElement element = node.staticElement;
@@ skipping 115 matching lines @@
   }
 
   Object visitPrefixExpression(PrefixExpression node) {
     recordOperatorReference(node.operator, node.bestElement);
     return super.visitPrefixExpression(node);
   }
 
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     Element nameElement = new NameElementImpl(node.name);
     Location location = createLocation2(node);
+    // name in declaration
     if (node.inDeclarationContext()) {
       recordRelationship(nameElement, IndexConstants.IS_DEFINED_BY, location);
       return null;
     }
+    // prepare information
     Element element = node.bestElement;
+    // qualified name reference
     recordQualifiedMemberReference(node, element, nameElement, location);
+    // stop if already handled
     if (isAlreadyHandledName(node)) {
       return null;
     }
+    // record specific relations
     if (element is ClassElement || element is FunctionElement || element is FunctionTypeAliasElement || element is LabelElement || element is TypeParameterElement) {
       recordRelationship(element, IndexConstants.IS_REFERENCED_BY, location);
     } else if (element is FieldElement) {
       location = getLocationWithInitializerType(node, location);
       recordRelationship(element, IndexConstants.IS_REFERENCED_BY, location);
     } else if (element is FieldFormalParameterElement) {
       FieldFormalParameterElement fieldParameter = element;
       FieldElement field = fieldParameter.field;
       recordRelationship(field, IndexConstants.IS_REFERENCED_BY_QUALIFIED, location);
     } else if (element is PrefixElement) {
@@ skipping 51 matching lines @@
     enterScope(element);
     try {
       return super.visitTypeParameter(node);
     } finally {
       exitScope();
     }
   }
 
   Object visitVariableDeclaration(VariableDeclaration node) {
     VariableElement element = node.element;
+    // record declaration
     {
       SimpleIdentifier name = node.name;
       Location location = createLocation2(name);
       location = getLocationWithExpressionType(location, node.initializer);
       recordRelationship(element, IndexConstants.IS_DEFINED_BY, location);
     }
+    // visit
     enterScope(element);
     try {
       return super.visitVariableDeclaration(node);
     } finally {
       exitScope();
     }
   }
 
   Object visitVariableDeclarationList(VariableDeclarationList node) {
     NodeList<VariableDeclaration> variables = node.variables;
     if (variables != null) {
+      // use first VariableDeclaration as Element for Location(s) in type
       {
         TypeName type = node.type;
         if (type != null) {
           for (VariableDeclaration variableDeclaration in variables) {
             enterScope(variableDeclaration.element);
             try {
               type.accept(this);
             } finally {
               exitScope();
             }
+            // only one iteration
             break;
           }
         }
       }
+      // visit variables
       variables.accept(this);
     }
     return null;
   }
 
   /**
    * @return the [Location] representing location of the [ASTNode].
    */
   Location createLocation2(ASTNode node) => createLocation3(node.offset, node.length);
 
@@ skipping 82 matching lines @@
     if (library != null) {
       Location location = createLocation2(node.uri);
       recordRelationship(library.definingCompilationUnit, IndexConstants.IS_REFERENCED_BY, location);
     }
   }
 
   /**
    * Record reference to the given operator [Element] and name.
    */
   void recordOperatorReference(Token operator, Element element) {
+    // prepare location
     Location location = createLocation4(operator);
+    // record name reference
     {
       String name = operator.lexeme;
       if (name == "++") {
         name = "+";
       }
       if (name == "--") {
         name = "-";
       }
       if (name.endsWith("=") && name != "==") {
         name = name.substring(0, name.length - 1);
       }
       Element nameElement = new NameElementImpl(name);
       Relationship relationship = element != null ? IndexConstants.IS_REFERENCED_BY_QUALIFIED_RESOLVED : IndexConstants.IS_REFERENCED_BY_QUALIFIED_UNRESOLVED;
       recordRelationship(nameElement, relationship, location);
     }
+    // record element reference
     if (element != null) {
       recordRelationship(element, IndexConstants.IS_INVOKED_BY_QUALIFIED, location);
     }
   }
 
   /**
    * Records reference if the given [SimpleIdentifier] looks like a qualified property access
    * or method invocation.
    */
   void recordQualifiedMemberReference(SimpleIdentifier node, Element element, Element nameElement, Location location) {
@@ skipping 235 matching lines @@
       for (ToolkitObjectElement object in toolkitObjects) {
         if (object is AngularComponentElement) {
           indexComponent(object);
         }
         if (object is AngularDirectiveElement) {
           AngularDirectiveElement directive = object;
           indexDirective(directive);
         }
       }
     }
+    // stop visiting
     return null;
   }
 
   Object visitCompilationUnitMember(CompilationUnitMember node) => null;
 
   void indexComponent(AngularComponentElement component) {
     indexProperties(component.properties);
   }
 
   void indexDirective(AngularDirectiveElement directive) {
     indexProperties(directive.properties);
   }
 
   void indexProperties(List<AngularPropertyElement> properties) {
     for (AngularPropertyElement property in properties) {
       FieldElement field = property.field;
       if (field != null) {
         int offset = property.fieldNameOffset;
         int length = field.name.length;
         Location location = new Location(property, offset, length);
-        _store.recordRelationship(field, IndexConstants.IS_REFERENCED_BY, location);
+        // getter reference
+        if (property.propertyKind.callsGetter()) {
+          PropertyAccessorElement getter = field.getter;
+          if (getter != null) {
+            _store.recordRelationship(getter, IndexConstants.IS_REFERENCED_BY_QUALIFIED, location);
+          }
+        }
+        // setter reference
+        if (property.propertyKind.callsSetter()) {
+          PropertyAccessorElement setter = field.setter;
+          if (setter != null) {
+            _store.recordRelationship(setter, IndexConstants.IS_REFERENCED_BY_QUALIFIED, location);
+          }
+        }
       }
     }
   }
 }
 
 /**
  * Instances of the [RemoveContextOperation] implement an operation that removes from the
  * index any data based on the specified [AnalysisContext].
  *
  * @coverage dart.engine.index
@@ skipping 229 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);
 }