Add an integration test for kythe support with bug fixes

pkg/analysis_server/lib/src/services/kythe/kythe_visitors.dart

 // Copyright (c) 2017, 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.
 
 import 'dart:convert';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
 import 'package:analyzer/dart/ast/syntactic_entity.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/dart/element/visitor.dart';
+import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/src/dart/resolver/inheritance_manager.dart';
+import 'package:analyzer/src/generated/bazel.dart';
+import 'package:analyzer/src/generated/gn.dart';
 import 'package:analyzer_plugin/protocol/protocol_common.dart'
     show KytheEntry, KytheVName;
 
 import 'schema.dart' as schema;
 
 const int _notFound = -1;
 
-/// Computes analysis of the given compilation [unit]. The unit is assumed to
-/// exist in the given [corpus] and to have the given text [contents]. Analysis
-/// results are returned as a list of [KytheEntry] objects.
-List<KytheEntry> computeIndex(
-    String corpus, CompilationUnit unit, String contents) {
-  final List<KytheEntry> entries = [];
-  var visitor = new KytheDartVisitor(
-      entries,
-      corpus,
-      new InheritanceManager(
-          resolutionMap.elementDeclaredByCompilationUnit(unit).library),
-      contents);
-  unit.accept(visitor);
-  return entries;
-}
-
 /// Given some [ConstructorElement], this method returns '<class-name>' as the
 /// name of the constructor, unless the constructor is a named constructor in
 /// which '<class-name>.<constructor-name>' is returned.
 String _computeConstructorElementName(ConstructorElement element) {
   assert(element != null);
   var name = element.enclosingElement.name;
   var constructorName = element.name;
   if (!constructorName.isEmpty) {
     name = name + '.' + constructorName;
   }
   return name;
 }
 
 /// Create an anchor signature of the form '<start>-<end>'.
 String _getAnchorSignature(int start, int end) {
   return '$start-$end';
 }
 
-String _getPath(Element e) {
+String _getPath(ResourceProvider provider, Element e) {
   // TODO(jwren) This method simply serves to provide the WORKSPACE relative
   // path for sources in Elements, it needs to be written in a more robust way.
   // TODO(jwren) figure out what source generates a e != null, but
   // e.source == null to ensure that it is not a bug somewhere in the stack.
   if (e == null || e.source == null) {
     // null sometimes when the element is used to generate the node type
     // "dynamic"
     return '';
   }
-  var path = e.source.fullName;
-  assert(path.lastIndexOf('CORPUS_NAME') != -1);
-  return path.substring(path.lastIndexOf('CORPUS_NAME') + 12);
+  String path = e.source.fullName;
+  BazelWorkspace bazelWorkspace = BazelWorkspace.find(provider, path);
+  if (bazelWorkspace != null) {
+    return provider.pathContext.relative(path, from: bazelWorkspace.root);
+  }
+  GnWorkspace gnWorkspace = GnWorkspace.find(provider, path);
+  if (gnWorkspace != null) {
+    return provider.pathContext.relative(path, from: gnWorkspace.root);
+  }
+  if (path.lastIndexOf('CORPUS_NAME') != -1) {
+    return path.substring(path.lastIndexOf('CORPUS_NAME') + 12);
+  }
+  return path;
 }
 
 /// If a non-null element is passed, the [SignatureElementVisitor] is used to
 /// generate and return a [String] signature, otherwise [schema.DYNAMIC_KIND] is
 /// returned.
-String _getSignature(Element element, String nodeKind, String corpus) {
+String _getSignature(ResourceProvider provider, Element element,
+    String nodeKind, String corpus) {
   assert(nodeKind != schema.ANCHOR_KIND); // Call _getAnchorSignature instead
   if (element == null) {
     return schema.DYNAMIC_KIND;
   }
   if (element is CompilationUnitElement) {
-    return _getPath(element);
+    return _getPath(provider, element);
   }
   return '$nodeKind:${element.accept(SignatureElementVisitor.instance)}';
 }
 
 class CodedBufferWriter {
   CodedBufferWriter(var v);
   toBuffer() {}
 }
 
 /// This visitor writes out Kythe facts and edges as specified by the Kythe
 /// Schema here https://kythe.io/docs/schema/.  This visitor handles all nodes,
 /// facts and edges.
 class KytheDartVisitor extends GeneralizingAstVisitor with OutputUtils {
+  final ResourceProvider resourceProvider;
   final List<KytheEntry> entries;
   final String corpus;
   final InheritanceManager _inheritanceManager;
+  final String _contents;
+
   String _enclosingFilePath = '';
   Element _enclosingElement;
   ClassElement _enclosingClassElement;
   KytheVName _enclosingVName;
   KytheVName _enclosingFileVName;
   KytheVName _enclosingClassVName;
-  final String _contents;
 
-  KytheDartVisitor(
-      this.entries, this.corpus, this._inheritanceManager, this._contents);
+  KytheDartVisitor(this.resourceProvider, this.entries, this.corpus,
+      this._inheritanceManager, this._contents);
 
   @override
   String get enclosingFilePath => _enclosingFilePath;
 
   @override
   visitAnnotation(Annotation node) {
     // TODO(jwren) To get the full set of cross refs correct, additional ref
     // edges are needed, example: from "A" in "A.namedConstructor()"
 
     var start = node.name.offset;
@@ skipping 213 matching lines @@
       _safelyVisit(node.documentationComment);
       _safelyVisitList(node.metadata);
       _safelyVisit(node.typeParameters);
       _safelyVisit(node.withClause);
       _safelyVisit(node.implementsClause);
     });
   }
 
   @override
   visitCompilationUnit(CompilationUnit node) {
-    _enclosingFilePath = _getPath(node.element);
+    _enclosingFilePath = _getPath(resourceProvider, node.element);
     return _withEnclosingElement(node.element, () {
       addFact(_enclosingFileVName, schema.NODE_KIND_FACT,
           _encode(schema.FILE_KIND));
       addFact(_enclosingFileVName, schema.TEXT_FACT, _encode(_contents));
       addFact(_enclosingFileVName, schema.TEXT_ENCODING_FACT,
           _encode(schema.DEFAULT_TEXT_ENCODING));
 
       // handle LibraryDirective:
 
       // A "package" VName in Kythe, schema.PACKAGE_KIND, is a Dart "library".
@@ skipping 739 matching lines @@
     }
   }
 }
 
 /// This class is meant to be a mixin to concrete visitor methods to walk the
 /// [Element] or [AstNode]s produced by the Dart Analyzer to output Kythe
 /// [KytheEntry] protos.
 abstract class OutputUtils {
   /// A set of [String]s which have already had a name [KytheVName] created.
   final Set<String> nameNodes = new Set<String>();
+
   String get corpus;
+
   KytheVName get dynamicBuiltin => _vName(schema.DYNAMIC_KIND, '', '', '');
 
   String get enclosingFilePath;
 
   List<KytheEntry> get entries;
+
   KytheVName get fnBuiltin => _vName(schema.FN_BUILTIN, '', '', '');
+
+  ResourceProvider get resourceProvider;
+
   KytheVName get voidBuiltin => _vName(schema.VOID_BUILTIN, '', '', '');
 
   /// This is a convenience method for adding anchors. If the [start] and [end]
   /// offsets are provided, they are used, otherwise the offsets are computed by
   /// using the [syntacticEntity]. If a non-empty list of edges is provided, as
   /// well as a target, then this method also adds the edges from the anchor to
   /// target. The anchor [KytheVName] is returned.
   ///
   /// If a [target] and [enclosingTarget] are provided, a childof edge is
   /// written out from the target to the enclosing target.
@@ skipping 70 matching lines @@
       String factName, List<int> factValue) {
     assert(source != null);
     assert(factName != null);
     assert(factValue != null);
     // factValue may be an empty array, the fact may be that a file text or
     // document text is empty
     if (edgeKind == null || edgeKind.isEmpty) {
       edgeKind = null;
       target = null;
     }
-    var entry = new KytheEntry(source, edgeKind, target, factName, factValue);
+    var entry = new KytheEntry(source, factName,
+        kind: edgeKind, target: target, value: factValue);
     entries.add(entry);
     return entry;
   }
 
   /// This is a convenience method for visitors to add a fact [KytheEntry].
   KytheEntry addFact(KytheVName source, String factName, List<int> factValue) {
     return addEntry(source, null, null, factName, factValue);
   }
 
   /// This is a convenience method for adding function types.
@@ skipping 107 matching lines @@
   KytheVName _vNameFile() {
     // file vnames, the signature and language are not set
     return _vName('', corpus, '', enclosingFilePath, '');
   }
 
   /// Given some [Element] and Kythe node kind, this method generates and
   /// returns the [KytheVName].
   KytheVName _vNameFromElement(Element e, String nodeKind) {
     assert(nodeKind != schema.FILE_KIND);
     // general case
-    return _vName(_getSignature(e, nodeKind, corpus), corpus, '', _getPath(e));
+    return _vName(_getSignature(resourceProvider, e, nodeKind, corpus), corpus,
+        '', _getPath(resourceProvider, e));
   }
 
   /// Returns a [KytheVName] corresponding to the given [DartType].
   KytheVName _vNameFromType(DartType type) {
     if (type == null || type.isDynamic) {
       return dynamicBuiltin;
     } else if (type.isVoid) {
       return voidBuiltin;
     } else if (type.element is ClassElement) {
       return _vNameFromElement(type.element, schema.RECORD_KIND);
@@ skipping 43 matching lines @@
   }
 
   @override
   StringBuffer visitTypeParameterElement(TypeParameterElement e) {
     // It is legal to have a named constructor with the same name as a type
     // parameter.  So we distinguish them by using '.' between the class (or
     // typedef) name and the type parameter name.
     return e.enclosingElement.accept(this)..write('.')..write(e.name);
   }
 }