Swift indexing

include/swift/AST/ASTWalker.h

@@ -190,8 +190,8 @@ class ASTWalker {
   virtual bool walkToTypeReprPost(TypeRepr *T) { return true; }
 
   /// This method configures whether the walker should explore into the generic
-  /// params in an AbstractFunctionDecl.
-  virtual bool shouldWalkIntoFunctionGenericParams() { return false; }
+  /// params in AbstractFunctionDecl and NominalTypeDecl.
+  virtual bool shouldWalkIntoGenericParams() { return false; }
 
   /// walkToParameterListPre - This method is called when first visiting a
   /// ParameterList, before walking into its parameters.  If it returns false,

include/swift/AST/SourceEntityWalker.h

@@ -126,7 +126,7 @@ class SourceEntityWalker {
   /// Whether walk into the inactive region in a #if config statement.
   virtual bool shouldWalkInactiveConfigRegion() { return false; }
 
-  virtual bool shouldWalkIntoFunctionGenericParams() { return true; }
+  virtual bool shouldWalkIntoGenericParams() { return true; }
 
 protected:
   SourceEntityWalker() = default;

include/swift/Index/IndexDataConsumer.h

@@ -22,6 +22,8 @@ class IndexDataConsumer {
   virtual void anchor();
 
 public:
+  enum Action {Skip, Abort, Continue};
+
   virtual ~IndexDataConsumer() {}
 
   virtual void failed(StringRef error) = 0;
@@ -32,8 +34,7 @@ class IndexDataConsumer {
   virtual bool startDependency(SymbolKind kind, StringRef name, StringRef path,
                                bool isSystem, StringRef hash) = 0;
   virtual bool finishDependency(SymbolKind kind) = 0;
-  virtual bool startSourceEntity(const IndexSymbol &symbol) = 0;
-  virtual bool recordRelatedEntity(const IndexSymbol &symbol) = 0;
+  virtual Action startSourceEntity(const IndexSymbol &symbol) = 0;
   virtual bool finishSourceEntity(SymbolKind kind, SymbolSubKindSet subKinds,
                                   SymbolRoleSet roles) = 0;
 

include/swift/Index/IndexSymbol.h

@@ -92,25 +92,48 @@ inline SymbolSubKindSet &operator|=(SymbolSubKindSet &SKSet, SymbolSubKind SK) {
 using SymbolRole = clang::index::SymbolRole;
 using SymbolRoleSet = clang::index::SymbolRoleSet;
 
-struct IndexSymbol {
+struct IndexRelation {
   const ValueDecl *decl;
   SymbolKind kind;
   SymbolSubKindSet subKinds = SymbolSubKindSet(0);
   SymbolRoleSet roles = SymbolRoleSet(0);
+
   // The following strings are guaranteed to live at least as long as the
   // current indexing action.
   StringRef name;
   StringRef USR; // USR may be safely compared by pointer.
   StringRef group;
-  StringRef receiverUSR;
+
+  IndexRelation(SymbolRoleSet Roles, const ValueDecl *Sym, SymbolKind Kind, SymbolSubKindSet SubKinds, StringRef Name, StringRef USR)
+  : decl(Sym), kind(Kind), subKinds(SubKinds), roles(Roles), name(Name), USR(USR) {}
+
+  IndexRelation() = default;
+};
+
+struct IndexSymbol : IndexRelation {
+  SmallVector<IndexRelation, 3> Relations;
   unsigned line = 0;
   unsigned column = 0;
 
   IndexSymbol() = default;
+
+  StringRef getReceiverUSR() const {
+    for(auto Relation: Relations) {
+      if (Relation.roles & (SymbolRoleSet) SymbolRole::RelationReceivedBy)
+        return Relation.USR;
+    }
+    return StringRef();
+  }
 };
 
 SymbolKind getSymbolKindForDecl(const Decl *D);
 
+StringRef getSymbolKindString(SymbolKind K);
+
+void applyForEachSymbolSubKind(SymbolSubKindSet SubKinds,
+                               llvm::function_ref<void(SymbolSubKind)> Fn);
+void printSymbolSubKinds(SymbolSubKindSet SubKinds, raw_ostream &OS);
+
 } // end namespace index
 } // end namespace swift
 

lib/AST/ASTWalker.cpp

@@ -201,10 +201,29 @@ class Traversal : public ASTVisitor<Traversal, Expr*, Stmt*,
   }
 
   bool visitNominalTypeDecl(NominalTypeDecl *NTD) {
-    if (auto GPS = NTD->getGenericParams()) {
-      for (auto GP : GPS->getParams()) {
+    if (NTD->getGenericParams() &&
+        Walker.shouldWalkIntoGenericParams()) {
+      // Visit generic params
+      for (auto GP : NTD->getGenericParams()->getParams()) {
         if (doIt(GP))
           return true;
+        for(auto Inherit: GP->getInherited()) {
+          if (doIt(Inherit))
+            return true;
+        }
+      }
+      // Visit param conformance
+      for (auto &Req : NTD->getGenericParams()->getRequirements()) {
+        switch (Req.getKind()) {
+          case RequirementReprKind::SameType:
+            if (doIt(Req.getFirstTypeLoc()) || doIt(Req.getSecondTypeLoc()))
+              return true;
+            break;
+          case RequirementReprKind::TypeConstraint:
+            if (doIt(Req.getSubjectLoc()) || doIt(Req.getConstraintLoc()))
+              return true;
+            break;
+        }
       }
     }
 
@@ -237,7 +256,7 @@ class Traversal : public ASTVisitor<Traversal, Expr*, Stmt*,
     PrettyStackTraceDecl debugStack("walking into body of", AFD);
 #endif
     if (AFD->getGenericParams() &&
-        Walker.shouldWalkIntoFunctionGenericParams()) {
+        Walker.shouldWalkIntoGenericParams()) {
 
       // Visit generic params
       for (auto &P : AFD->getGenericParams()->getParams()) {

lib/AST/SourceEntityWalker.cpp

@@ -40,8 +40,8 @@ class SemaAnnotator : public ASTWalker {
   bool isDone() const { return Cancelled; }
 
 private:
-  bool shouldWalkIntoFunctionGenericParams() override {
-    return SEWalker.shouldWalkIntoFunctionGenericParams();
+  bool shouldWalkIntoGenericParams() override {
+    return SEWalker.shouldWalkIntoGenericParams();
   }
   bool walkToDeclPre(Decl *D) override;
   std::pair<bool, Expr *> walkToExprPre(Expr *E) override;

lib/IDE/SyntaxModel.cpp

@@ -297,7 +297,7 @@ class ModelASTWalker : public ASTWalker {
   bool walkToDeclPost(Decl *D) override;
   bool walkToTypeReprPre(TypeRepr *T) override;
   std::pair<bool, Pattern*> walkToPatternPre(Pattern *P) override;
-  bool shouldWalkIntoFunctionGenericParams() override { return true; }
+  bool shouldWalkIntoGenericParams() override { return true; }
 
 private:
   static bool findUrlStartingLoc(StringRef Text, unsigned &Start,