[RangeInfo] Include a boolean value in the resolved range info to indicate whether the given range has more than one entry point. (#7150)

A classic multi-entry range is several case statements.

Author: nkcsgexi

include/swift/IDE/Utils.h

@@ -227,6 +227,7 @@ struct ResolvedRangeInfo {
   RangeKind Kind;
   Type Ty;
   StringRef Content;
+  bool HasSingleEntry;
 
   // The topmost ast nodes contained in the given range.
   ArrayRef<ASTNode> ContainedNodes;
@@ -235,15 +236,18 @@ struct ResolvedRangeInfo {
   DeclContext* RangeContext;
   ResolvedRangeInfo(RangeKind Kind, Type Ty, StringRef Content,
                     DeclContext* RangeContext,
+                    bool HasSingleEntry,
                     ArrayRef<ASTNode> ContainedNodes,
                     ArrayRef<DeclaredDecl> DeclaredDecls,
                     ArrayRef<ReferencedDecl> ReferencedDecls): Kind(Kind),
-                      Ty(Ty), Content(Content), ContainedNodes(ContainedNodes),
+                      Ty(Ty), Content(Content), HasSingleEntry(HasSingleEntry),
+                      ContainedNodes(ContainedNodes),
                       DeclaredDecls(DeclaredDecls),
                       ReferencedDecls(ReferencedDecls),
                       RangeContext(RangeContext) {}
   ResolvedRangeInfo() :
-  ResolvedRangeInfo(RangeKind::Invalid, Type(), StringRef(), nullptr, {}, {}, {}) {}
+  ResolvedRangeInfo(RangeKind::Invalid, Type(), StringRef(), nullptr,
+                    /*Single entry*/true, {}, {}, {}) {}
   void print(llvm::raw_ostream &OS);
 };
 

lib/IDE/SwiftSourceDocInfo.cpp

@@ -211,6 +211,10 @@ void ResolvedRangeInfo::print(llvm::raw_ostream &OS) {
   printContext(OS, RangeContext);
   OS << "</Context>\n";
 
+  if (!HasSingleEntry) {
+    OS << "<Entry>Multi</Entry>\n";
+  }
+
   for (auto &VD : DeclaredDecls) {
     OS << "<Declared>" << VD.VD->getNameStr() << "</Declared>";
     OS << "<OutscopeReference>";
@@ -296,23 +300,25 @@ struct RangeResolver::Implementation {
   ResolvedRangeInfo getSingleNodeKind(ASTNode Node) {
     assert(!Node.isNull());
     assert(ContainedASTNodes.size() == 1);
+    // Single node implies single entry point, or is it?
+    bool SingleEntry = true;
     if (Node.is<Expr*>())
       return ResolvedRangeInfo(RangeKind::SingleExpression,
                                resolveNodeType(Node), Content,
-                               getImmediateContext(),
+                               getImmediateContext(), SingleEntry,
                                llvm::makeArrayRef(ContainedASTNodes),
                                llvm::makeArrayRef(DeclaredDecls),
                                llvm::makeArrayRef(ReferencedDecls));
     else if (Node.is<Stmt*>())
       return ResolvedRangeInfo(RangeKind::SingleStatement, resolveNodeType(Node),
-                               Content, getImmediateContext(),
+                               Content, getImmediateContext(), SingleEntry,
                                llvm::makeArrayRef(ContainedASTNodes),
                                llvm::makeArrayRef(DeclaredDecls),
                                llvm::makeArrayRef(ReferencedDecls));
     else {
       assert(Node.is<Decl*>());
       return ResolvedRangeInfo(RangeKind::SingleDecl, Type(), Content,
-                               getImmediateContext(),
+                               getImmediateContext(), SingleEntry,
                                llvm::makeArrayRef(ContainedASTNodes),
                                llvm::makeArrayRef(DeclaredDecls),
                                llvm::makeArrayRef(ReferencedDecls));
@@ -486,6 +492,22 @@ struct RangeResolver::Implementation {
     FurtherReferenceWalker(this).walk(getImmediateContext());
   }
 
+  bool hasSingleEntryPoint(ArrayRef<ASTNode> Nodes) {
+    unsigned CaseCount = 0;
+    // Count the number of case/default statements.
+    for (auto N : Nodes) {
+      if (Stmt *S = N.is<Stmt*>() ? N.get<Stmt*>() : nullptr) {
+        if (S->getKind() == StmtKind::Case)
+          CaseCount ++;
+      }
+    }
+    // If there are more than one case/default statements, there are more than
+    // one entry point.
+    if (CaseCount > 1)
+      return false;
+    return true;
+  }
+
   void analyze(ASTNode Node) {
     Decl *D = Node.is<Decl*>() ? Node.get<Decl*>() : nullptr;
     analyzeDecl(D);
@@ -529,7 +551,7 @@ struct RangeResolver::Implementation {
       Result = {RangeKind::MultiStatement,
                 /* Last node has the type */
                 resolveNodeType(DCInfo.EndMatches.back()), Content,
-                getImmediateContext(),
+                getImmediateContext(), hasSingleEntryPoint(ContainedASTNodes),
                 llvm::makeArrayRef(ContainedASTNodes),
                 llvm::makeArrayRef(DeclaredDecls),
                 llvm::makeArrayRef(ReferencedDecls)};

test/IDE/range_info_basics.swift

@@ -71,6 +71,17 @@ func foo6() -> Int {
   return a
 }
 
+func foo7(a : Int) -> Int {
+  switch a {
+  case 1:
+    return 0
+  case 2:
+    return 1
+  default:
+    return a
+  }
+}
+
 // RUN: %target-swift-ide-test -range -pos=8:1 -end-pos 8:32 -source-filename %s | %FileCheck %s -check-prefix=CHECK1
 // RUN: %target-swift-ide-test -range -pos=9:1 -end-pos 9:26 -source-filename %s | %FileCheck %s -check-prefix=CHECK2
 // RUN: %target-swift-ide-test -range -pos=10:1 -end-pos 10:27 -source-filename %s | %FileCheck %s -check-prefix=CHECK3
@@ -88,6 +99,9 @@ func foo6() -> Int {
 // RUN: %target-swift-ide-test -range -pos=63:1 -end-pos=66:44 -source-filename %s | %FileCheck %s -check-prefix=CHECK15
 // RUN: %target-swift-ide-test -range -pos=63:1 -end-pos=68:15 -source-filename %s | %FileCheck %s -check-prefix=CHECK16
 // RUN: %target-swift-ide-test -range -pos=67:1 -end-pos=67:19 -source-filename %s | %FileCheck %s -check-prefix=CHECK17
+// RUN: %target-swift-ide-test -range -pos=76:1 -end-pos=79:13 -source-filename %s | %FileCheck %s -check-prefix=CHECK18
+// RUN: %target-swift-ide-test -range -pos=76:1 -end-pos=77:13 -source-filename %s | %FileCheck %s -check-prefix=CHECK19
+// RUN: %target-swift-ide-test -range -pos=78:1 -end-pos=81:13 -source-filename %s | %FileCheck %s -check-prefix=CHECK20
 
 // CHECK1: <Kind>SingleDecl</Kind>
 // CHECK1-NEXT: <Content>func foo1() -> Int { return 0 }</Content>
@@ -312,3 +326,33 @@ func foo6() -> Int {
 // CHECK17-NEXT: <Referenced>c</Referenced><Type>Int</Type>
 // CHECK17-NEXT: <ASTNodes>1</ASTNodes>
 // CHECK17-NEXT: <end>
+
+// CHECK18: <Kind>MultiStatement</Kind>
+// CHECK18-NEXT: <Content>case 1:
+// CHECK18-NEXT:     return 0
+// CHECK18-NEXT:   case 2:
+// CHECK18-NEXT:     return 1</Content>
+// CHECK18-NEXT: <Type>Void</Type>
+// CHECK18-NEXT: <Context>swift_ide_test.(file).func decl</Context>
+// CHECK18-NEXT: <Entry>Multi</Entry>
+// CHECK18-NEXT: <ASTNodes>2</ASTNodes>
+// CHECK18-NEXT: <end>
+
+// CHECK19: <Kind>SingleStatement</Kind>
+// CHECK19-NEXT: <Content>case 1:
+// CHECK19-NEXT:     return 0</Content>
+// CHECK19-NEXT: <Type>Void</Type>
+// CHECK19-NEXT: <Context>swift_ide_test.(file).func decl</Context>
+// CHECK19-NEXT: <ASTNodes>1</ASTNodes>
+// CHECK19-NEXT: <end>
+
+// CHECK20: <Kind>MultiStatement</Kind>
+// CHECK20-NEXT: <Content>case 2:
+// CHECK20-NEXT:     return 1
+// CHECK20-NEXT:   default:
+// CHECK20-NEXT:     return a</Content>
+// CHECK20-NEXT: <Type>Void</Type>
+// CHECK20-NEXT: <Context>swift_ide_test.(file).func decl</Context>
+// CHECK20-NEXT: <Entry>Multi</Entry>
+// CHECK20-NEXT: <ASTNodes>2</ASTNodes>
+// CHECK20-NEXT: <end>