[indexer] When visiting a NominalTypeDecl, cover the type references in the where clause and generic param inheritance too.

Also rename ASTWalker::shouldWalkIntoFunctionGenericParams() to shouldWalkIntoGenericParams() since it's now used when walking NominalTypeDecl (not just AbstractFunctionDecl).

Author: Nathan Hawes

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/IndexSymbol.h

@@ -111,6 +111,12 @@ struct IndexSymbol {
 
 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,

lib/Index/Index.cpp

@@ -316,6 +316,8 @@ class IndexSwiftASTWalker : public SourceEntityWalker {
   bool initFuncDeclIndexSymbol(ValueDecl *D, IndexSymbol &Info);
   bool initCallRefIndexSymbol(Expr *CurrentE, Expr *ParentE, ValueDecl *D,
                               SourceLoc Loc, IndexSymbol &Info);
+  bool initVarRefIndexSymbols(Expr *CurrentE, ValueDecl *D, SourceLoc Loc,
+                              IndexSymbol &Info);
 
   std::pair<unsigned, unsigned> getLineCol(SourceLoc Loc) {
     if (Loc.isInvalid())
@@ -522,6 +524,12 @@ bool IndexSwiftASTWalker::startEntityRef(ValueDecl *D, SourceLoc Loc) {
 
     return startEntity(D, Info);
 
+  } else if (isa<AbstractStorageDecl>(D)) {
+    IndexSymbol Info;
+    if (initVarRefIndexSymbols(getCurrentExpr(), D, Loc, Info))
+      return false;
+
+    return startEntity(D, Info);
   } else {
     IndexSymbol Info;
     if (initIndexSymbol(D, Loc, /*IsRef=*/true, Info))
@@ -955,6 +963,29 @@ bool IndexSwiftASTWalker::initCallRefIndexSymbol(Expr *CurrentE, Expr *ParentE,
   return false;
 }
 
+bool IndexSwiftASTWalker::initVarRefIndexSymbols(Expr *CurrentE, ValueDecl *D, SourceLoc Loc, IndexSymbol &Info) {
+
+  if (!(CurrentE->getReferencedDecl() == D))
+    return true;
+
+  if (initIndexSymbol(D, Loc, /*IsRef=*/true, Info))
+    return true;
+
+  AccessKind Kind = CurrentE->hasLValueAccessKind() ? CurrentE->getLValueAccessKind() : AccessKind::Read;
+  switch (Kind) {
+  case swift::AccessKind::Read:
+    Info.roles |= (unsigned)SymbolRole::Read;
+    break;
+  case swift::AccessKind::ReadWrite:
+    Info.roles |= (unsigned)SymbolRole::Read;
+    LLVM_FALLTHROUGH;
+  case swift::AccessKind::Write:
+    Info.roles |= (unsigned)SymbolRole::Write;
+  }
+  
+  return false;
+}
+
 llvm::hash_code
 IndexSwiftASTWalker::hashFileReference(llvm::hash_code code,
                                        SourceFileOrModule SFOrMod) {

lib/Index/IndexSymbol.cpp

@@ -83,3 +83,81 @@ SymbolKind index::getSymbolKindForDecl(const Decl *D) {
       return SymbolKind::Unknown;
   }
 }
+
+StringRef index::getSymbolKindString(SymbolKind K) {
+  switch (K) {
+    case SymbolKind::Unknown: return "<unknown>";
+    case SymbolKind::Module: return "module";
+    case SymbolKind::ClangModule: return "clang-module";
+    case SymbolKind::Enum: return "enum";
+    case SymbolKind::EnumElement: return "enum-element";
+    case SymbolKind::Struct: return "struct";
+    case SymbolKind::Class: return "class";
+    case SymbolKind::Protocol: return "protocol";
+    case SymbolKind::Extension: return "extension";
+    case SymbolKind::TypeAlias: return "type-alias";
+    case SymbolKind::Function: return "function";
+    case SymbolKind::Variable: return "variable";
+    case SymbolKind::InstanceMethod: return "instance-method";
+    case SymbolKind::ClassMethod: return "class-method";
+    case SymbolKind::StaticMethod: return "static-method";
+    case SymbolKind::InstanceProperty: return "instance-property";
+    case SymbolKind::ClassProperty: return "class-property";
+    case SymbolKind::StaticProperty: return "static-property";
+    case SymbolKind::Constructor: return "constructor";
+    case SymbolKind::Destructor: return "destructor";
+    case SymbolKind::PrefixOperator: return "prefix-operator";
+    case SymbolKind::PostfixOperator: return "postfix-operator";
+    case SymbolKind::InfixOperator: return "infix-operator";
+    case SymbolKind::Accessor: return "accessor";
+    case SymbolKind::Subscript: return "subscript";
+    case SymbolKind::AssociatedType: return "associated-type";
+    case SymbolKind::GenericTypeParam: return "generic-type-param";
+  }
+  llvm_unreachable("invalid symbol kind");
+}
+
+void index::applyForEachSymbolSubKind(SymbolSubKindSet SubKinds,
+                                      llvm::function_ref<void(SymbolSubKind)> Fn) {
+#define APPLY_FOR_SUBKIND(K) \
+if (SubKinds & (unsigned)SymbolSubKind::K) \
+Fn(SymbolSubKind::K)
+
+  APPLY_FOR_SUBKIND(AccessorGetter);
+  APPLY_FOR_SUBKIND(AccessorSetter);
+  APPLY_FOR_SUBKIND(AccessorWillSet);
+  APPLY_FOR_SUBKIND(AccessorDidSet);
+  APPLY_FOR_SUBKIND(AccessorAddressor);
+  APPLY_FOR_SUBKIND(AccessorMutableAddressor);
+  APPLY_FOR_SUBKIND(ExtensionOfStruct);
+  APPLY_FOR_SUBKIND(ExtensionOfClass);
+  APPLY_FOR_SUBKIND(ExtensionOfEnum);
+  APPLY_FOR_SUBKIND(ExtensionOfProtocol);
+  APPLY_FOR_SUBKIND(UnitTest);
+
+#undef APPLY_FOR_SUBKIND
+}
+
+void index::printSymbolSubKinds(SymbolSubKindSet SubKinds, raw_ostream &OS) {
+  bool VisitedOnce = false;
+  applyForEachSymbolSubKind(SubKinds, [&](SymbolSubKind SubKind) {
+    if (VisitedOnce)
+      OS << ',';
+    else
+      VisitedOnce = true;
+    switch (SubKind) {
+      case SymbolSubKind::None: OS << "none"; break;
+      case SymbolSubKind::UnitTest: OS << "test"; break;
+      case SymbolSubKind::AccessorGetter: OS << "get"; break;
+      case SymbolSubKind::AccessorSetter: OS << "set"; break;
+      case SymbolSubKind::AccessorWillSet: OS << "willSet"; break;
+      case SymbolSubKind::AccessorDidSet: OS << "didSet"; break;
+      case SymbolSubKind::AccessorAddressor: OS << "addr"; break;
+      case SymbolSubKind::AccessorMutableAddressor: OS << "mutAddr"; break;
+      case SymbolSubKind::ExtensionOfStruct: OS << "extStruct"; break;
+      case SymbolSubKind::ExtensionOfClass: OS << "extClass"; break;
+      case SymbolSubKind::ExtensionOfEnum: OS << "extEnum"; break;
+      case SymbolSubKind::ExtensionOfProtocol: OS << "extProt"; break;
+    }
+  });
+}

tools/swift-ide-test/CMakeLists.txt

@@ -5,6 +5,7 @@ add_swift_host_tool(swift-ide-test
   LINK_LIBRARIES
     swiftDriver
     swiftFrontend
+    swiftIndex
     swiftIDE
   LLVM_COMPONENT_DEPENDS
     DebugInfoCodeView