[RangeInfo] Report declared and referenced decls in a given range.

Author: nkcsgexi

include/swift/IDE/Utils.h

@@ -209,9 +209,15 @@ struct ResolvedRangeInfo {
   RangeKind Kind;
   Type Ty;
   StringRef Content;
-  ResolvedRangeInfo(RangeKind Kind, Type Ty, StringRef Content): Kind(Kind),
-    Ty(Ty), Content(Content) {}
-  ResolvedRangeInfo(): ResolvedRangeInfo(RangeKind::Invalid, Type(), StringRef()) {}
+  ArrayRef<ValueDecl*> DeclaredDecls;
+  ArrayRef<ValueDecl*> ReferencedDecls;
+  ResolvedRangeInfo(RangeKind Kind, Type Ty, StringRef Content,
+                    ArrayRef<ValueDecl*> DeclaredDecls,
+                    ArrayRef<ValueDecl*> ReferencedDecls): Kind(Kind),
+                      Ty(Ty), Content(Content), DeclaredDecls(DeclaredDecls),
+                      ReferencedDecls(ReferencedDecls) {}
+  ResolvedRangeInfo() :
+    ResolvedRangeInfo(RangeKind::Invalid, Type(), StringRef(), {}, {}) {}
   void print(llvm::raw_ostream &OS);
 };
 
@@ -224,6 +230,8 @@ class RangeResolver : public SourceEntityWalker {
   bool walkToStmtPost(Stmt *S) override;
   bool walkToDeclPre(Decl *D, CharSourceRange Range) override;
   bool walkToDeclPost(Decl *D) override;
+  bool visitDeclReference(ValueDecl *D, CharSourceRange Range,
+                          TypeDecl *CtorTyRef, Type T) override;
 public:
   RangeResolver(SourceFile &File, SourceLoc Start, SourceLoc End);
   RangeResolver(SourceFile &File, unsigned Offset, unsigned Length);

lib/IDE/SwiftSourceDocInfo.cpp

@@ -204,10 +204,19 @@ void ResolvedRangeInfo::print(llvm::raw_ostream &OS) {
     Ty->print(OS);
     OS << "</Type>\n";
   }
+  for (auto *VD : DeclaredDecls) {
+    OS << "<Declared>" << VD->getNameStr() << "</Declared>\n";
+  }
+  for (auto *VD : ReferencedDecls) {
+    OS << "<Referenced>" << VD->getNameStr() << "</Referenced>\n";
+  }
+  OS << "<end>\n";
 }
 
 struct RangeResolver::Implementation {
   SourceFile &File;
+  ASTContext &Ctx;
+  SourceManager &SM;
 private:
   enum class RangeMatchKind : int8_t {
     NoneMatch,
@@ -233,19 +242,40 @@ struct RangeResolver::Implementation {
     return ContextStack.back();
   }
 
+  std::vector<ValueDecl*> DeclaredDecls;
+  std::vector<ValueDecl*> ReferencedDecls;
+
+  void pushBackDeclUniquely(std::vector<ValueDecl*> &Bag, ValueDecl* VD) {
+    if (std::find(Bag.begin(), Bag.end(), VD) == Bag.end()) {
+      Bag.push_back(VD);
+    }
+  }
+
   ResolvedRangeInfo getSingleNodeKind(ASTNode Node) {
     assert(!Node.isNull());
     if (Node.is<Expr*>())
       return ResolvedRangeInfo(RangeKind::SingleExpression,
-                               Node.get<Expr*>()->getType(), Content);
+                               Node.get<Expr*>()->getType(), Content,
+                               llvm::makeArrayRef(DeclaredDecls),
+                               llvm::makeArrayRef(ReferencedDecls));
     else if (Node.is<Stmt*>())
-      return ResolvedRangeInfo(RangeKind::SingleStatement, Type(), Content);
+      return ResolvedRangeInfo(RangeKind::SingleStatement, Type(), Content,
+                               DeclaredDecls, ReferencedDecls);
     else {
       assert(Node.is<Decl*>());
-      return ResolvedRangeInfo(RangeKind::SingleDecl, Type(), Content);
+      return ResolvedRangeInfo(RangeKind::SingleDecl, Type(), Content,
+                               DeclaredDecls, ReferencedDecls);
     }
   }
 
+  bool isContainedInSelection(CharSourceRange Range) {
+    if (SM.isBeforeInBuffer(Range.getStart(), Start))
+      return false;
+    if (SM.isBeforeInBuffer(End, Range.getEnd()))
+      return false;
+    return true;
+  }
+
   static SourceLoc getNonwhitespaceLocBefore(SourceManager &SM,
                                              unsigned BufferID,
                                              unsigned Offset) {
@@ -284,7 +314,8 @@ struct RangeResolver::Implementation {
   }
 
   Implementation(SourceFile &File, SourceLoc Start, SourceLoc End) :
-    File(File), Start(Start), End(End), Content(getContent()) {}
+    File(File), Ctx(File.getASTContext()), SM(Ctx.SourceMgr), Start(Start),
+    End(End), Content(getContent()) {}
 
 public:
   bool hasResult() { return Result.hasValue(); }
@@ -318,6 +349,13 @@ struct RangeResolver::Implementation {
   }
 
   void analyze(ASTNode Node) {
+    // Collect declared decls in the range.
+    if (Node.is<Decl*>()) {
+      if (auto *VD = dyn_cast<ValueDecl>(Node.get<Decl*>())) {
+        pushBackDeclUniquely(DeclaredDecls, VD);
+      }
+    }
+
     auto &DCInfo = getCurrentDC();
     switch (getRangeMatchKind(Node.getSourceRange())) {
     case RangeMatchKind::NoneMatch:
@@ -332,14 +370,16 @@ struct RangeResolver::Implementation {
       DCInfo.EndMatches.emplace_back(Node);
       break;
     }
+
     if (!DCInfo.StartMatches.empty() && !DCInfo.EndMatches.empty()) {
-      Result = {RangeKind::MultiStatement, Type(), Content};
+      Result = {RangeKind::MultiStatement, Type(), Content,
+                llvm::makeArrayRef(DeclaredDecls),
+                llvm::makeArrayRef(ReferencedDecls)};
       return;
     }
   }
 
   bool shouldEnter(ASTNode Node) {
-    SourceManager &SM = File.getASTContext().SourceMgr;
     if (hasResult())
       return false;
     if (SM.isBeforeInBuffer(End, Node.getSourceRange().Start))
@@ -352,7 +392,14 @@ struct RangeResolver::Implementation {
   ResolvedRangeInfo getResult() {
     if (Result.hasValue())
       return Result.getValue();
-    return ResolvedRangeInfo(RangeKind::Invalid, Type(), getContent());
+    return ResolvedRangeInfo();
+  }
+
+  void analyzeDeclRef(ValueDecl *VD, CharSourceRange Range) {
+    if (!isContainedInSelection(Range))
+      return;
+    // Collect referenced decls in the range.
+    pushBackDeclUniquely(ReferencedDecls, VD);
   }
 
 private:
@@ -422,6 +469,14 @@ bool RangeResolver::walkToDeclPost(Decl *D) {
   return !Impl->hasResult();
 }
 
+
+bool RangeResolver::
+visitDeclReference(ValueDecl *D, CharSourceRange Range, TypeDecl *CtorTyRef,
+                   Type T) {
+  Impl->analyzeDeclRef(D, Range);
+  return true;
+}
+
 ResolvedRangeInfo RangeResolver::resolve() {
   if (!Impl)
     return ResolvedRangeInfo();

test/IDE/range_info_basics.swift

@@ -19,22 +19,41 @@ struct S { func foo() {} }
 
 // CHECK1: <Kind>SingleDecl</Kind>
 // CHECK1-NEXT: <Content>func foo1() -> Int { return 0 }</Content>
+// CHECK1-NEXT: <Declared>foo1</Declared>
+// CHECK1-NEXT: <end>
 
 // CHECK2: <Kind>SingleDecl</Kind>
 // CHECK2-NEXT: <Content>class C { func foo() {} }</Content>
+// CHECK2-NEXT: <Declared>C</Declared>
+// CHECK2-NEXT: <end>
 
 // CHECK3: <Kind>SingleDecl</Kind>
 // CHECK3-NEXT: <Content>struct S { func foo() {} }</Content>
+// CHECK3-NEXT: <Declared>S</Declared>
+// CHECK3-NEXT: <end>
 
 // CHECK4: <Kind>MultiStatement</Kind>
 // CHECK4-NEXT: <Content>aaa = aaa + 3
 // CHECK4-NEXT: if aaa == 3 { aaa = 4 }</Content>
+// CHECK4-NEXT: <Declared>foo</Declared>
+// CHECK4-NEXT: <Referenced>aaa</Referenced>
+// CHECK4-NEXT: <Referenced>+</Referenced>
+// CHECK4-NEXT: <end>
 
 // CHECK5: <Kind>MultiStatement</Kind>
 // CHECK5-NEXT: <Content>aaa = aaa + 3
 // CHECK5-NEXT: if aaa == 3 { aaa = 4 }
 // CHECK5-NEXT: return aaa</Content>
+// CHECK5-NEXT: <Declared>foo</Declared>
+// CHECK5-NEXT: <Referenced>aaa</Referenced>
+// CHECK5-NEXT: <Referenced>+</Referenced>
+// CHECK5-NEXT: <Referenced>==</Referenced>
+// CHECK5-NEXT: <end>
 
 // CHECK6: <Kind>MultiStatement</Kind>
 // CHECK6-NEXT: if aaa == 3 { aaa = 4 }
 // CHECK6-NEXT: return aaa</Content>
+// CHECK6-NEXT: <Declared>foo</Declared>
+// CHECK6-NEXT: <Referenced>aaa</Referenced>
+// CHECK6-NEXT: <Referenced>==</Referenced>
+// CHECK6-NEXT: <end>