[Test] Add range-info test driver to swift-ide-test. NFC

include/swift/IDE/Utils.h

@@ -209,13 +209,15 @@ struct ResolvedRangeInfo {
   RangeKind Kind;
   Type Ty;
   StringRef Content;
-  ResolvedRangeInfo(RangeKind Kind, Type Ty, StringRef Content) : Kind(Kind),
+  ResolvedRangeInfo(RangeKind Kind, Type Ty, StringRef Content): Kind(Kind),
     Ty(Ty), Content(Content) {}
+  ResolvedRangeInfo(): ResolvedRangeInfo(RangeKind::Invalid, Type(), StringRef()) {}
+  void print(llvm::raw_ostream &OS);
 };
 
 class RangeResolver : public SourceEntityWalker {
   struct Implementation;
-  Implementation &Impl;
+  Implementation *Impl;
   bool walkToExprPre(Expr *E) override;
   bool walkToExprPost(Expr *E) override;
   bool walkToStmtPre(Stmt *S) override;
@@ -224,6 +226,7 @@ class RangeResolver : public SourceEntityWalker {
   bool walkToDeclPost(Decl *D) override;
 public:
   RangeResolver(SourceFile &File, SourceLoc Start, SourceLoc End);
+  RangeResolver(SourceFile &File, unsigned Offset, unsigned Length);
   ResolvedRangeInfo resolve();
   ~RangeResolver();
 };

lib/IDE/SwiftSourceDocInfo.cpp

@@ -13,6 +13,7 @@
 #include "clang/Basic/Module.h"
 #include "clang/Index/USRGeneration.h"
 #include "clang/Lex/Lexer.h"
+#include "clang/Basic/CharInfo.h"
 
 #include "llvm/Support/MemoryBuffer.h"
 
@@ -174,6 +175,25 @@ bool SemaLocResolver::visitModuleReference(ModuleEntity Mod,
   return !tryResolve(Mod, Range.getStart());
 }
 
+void ResolvedRangeInfo::print(llvm::raw_ostream &OS) {
+  OS << "<Kind>";
+  switch (Kind) {
+  case RangeKind::SingleExpression: OS << "SingleExpression"; break;
+  case RangeKind::SingleDecl: OS << "SingleDecl"; break;
+  case RangeKind::MultiStatement: OS << "MultiStatement"; break;
+  case RangeKind::SingleStatement: OS << "SingleStatement"; break;
+  case RangeKind::Invalid: OS << "Invalid"; break;
+  }
+  OS << "</Kind>\n";
+
+  OS << "<Content>" << Content << "</Content>\n";
+  if (Ty) {
+    OS << "<Type>";
+    Ty->print(OS);
+    OS << "</Type>\n";
+  }
+}
+
 struct RangeResolver::Implementation {
   SourceFile &File;
 private:
@@ -214,9 +234,47 @@ private:
     }
   }
 
-public:
+  static SourceLoc getNonwhitespaceLocBefore(SourceManager &SM,
+                                             unsigned BufferID,
+                                             unsigned Offset) {
+    CharSourceRange entireRange = SM.getRangeForBuffer(BufferID);
+    StringRef Buffer = SM.extractText(entireRange);
+
+    const char *BufStart = Buffer.data();
+    if (Offset >= Buffer.size())
+      return SourceLoc();
+
+    for (unsigned Off = Offset; Off != 0; Off --) {
+      if (!clang::isWhitespace(*(BufStart + Off))) {
+        return SM.getLocForOffset(BufferID, Off);
+      }
+    }
+    return clang::isWhitespace(*BufStart) ? SourceLoc() :
+    SM.getLocForOffset(BufferID, 0);
+  }
+
+  static SourceLoc getNonwhitespaceLocAfter(SourceManager &SM,
+                                            unsigned BufferID,
+                                            unsigned Offset) {
+    CharSourceRange entireRange = SM.getRangeForBuffer(BufferID);
+    StringRef Buffer = SM.extractText(entireRange);
+
+    const char *BufStart = Buffer.data();
+    if (Offset >= Buffer.size())
+      return SourceLoc();
+
+    for (unsigned Off = Offset; Off < Buffer.size(); Off ++) {
+      if (!clang::isWhitespace(*(BufStart + Off))) {
+        return SM.getLocForOffset(BufferID, Off);
+      }
+    }
+    return SourceLoc();
+  }
+
   Implementation(SourceFile &File, SourceLoc Start, SourceLoc End) :
     File(File), Start(Start), End(End), Content(getContent()) {}
+
+public:
   bool hasResult() { return Result.hasValue(); }
   void enter(ASTNode Node) { ContextStack.emplace_back(Node); }
   void leave(ASTNode Node) {
@@ -224,6 +282,29 @@ public:
     ContextStack.pop_back();
   }
 
+  static Implementation *createInstance(SourceFile &File, unsigned StartOff,
+                                        unsigned Length) {
+    SourceManager &SM = File.getASTContext().SourceMgr;
+    unsigned BufferId = File.getBufferID().getValue();
+    SourceLoc StartLoc = Implementation::getNonwhitespaceLocAfter(SM, BufferId,
+                                                                  StartOff);
+    SourceLoc EndLoc = Implementation::getNonwhitespaceLocBefore(SM, BufferId,
+                                                         StartOff + Length - 1);
+    StartLoc = Lexer::getLocForStartOfToken(SM, StartLoc);
+    EndLoc = Lexer::getLocForStartOfToken(SM, EndLoc);
+    return StartLoc.isInvalid() || EndLoc.isInvalid() ? nullptr :
+      new Implementation(File, StartLoc, EndLoc);
+  }
+
+  static Implementation *createInstance(SourceFile &File, SourceLoc Start,
+                                        SourceLoc End) {
+    SourceManager &SM = File.getASTContext().SourceMgr;
+    unsigned BufferId = File.getBufferID().getValue();
+    unsigned StartOff = SM.getLocOffsetInBuffer(Start, BufferId);
+    unsigned EndOff = SM.getLocOffsetInBuffer(End, BufferId);
+    return createInstance(File, StartOff, EndOff - StartOff);
+  }
+
   void analyze(ASTNode Node) {
     auto &DCInfo = getCurrentDC();
     switch (getRangeMatchKind(Node.getSourceRange())) {
@@ -283,53 +364,58 @@ private:
 };
 
 RangeResolver::RangeResolver(SourceFile &File, SourceLoc Start, SourceLoc End) :
-  Impl(*new Implementation(File, Start, End)) {}
+  Impl(Implementation::createInstance(File, Start, End)) {}
 
-RangeResolver::~RangeResolver() { delete &Impl; }
+RangeResolver::RangeResolver(SourceFile &File, unsigned Offset, unsigned Length) :
+  Impl(Implementation::createInstance(File, Offset, Length)) {}
+
+RangeResolver::~RangeResolver() { if (Impl) delete Impl; }
 
 bool RangeResolver::walkToExprPre(Expr *E) {
-  if (!Impl.shouldEnter(E))
+  if (!Impl->shouldEnter(E))
     return false;
-  Impl.analyze(E);
+  Impl->analyze(E);
-  Impl.enter(E);
+  Impl->enter(E);
   return true;
 }
 
 bool RangeResolver::walkToStmtPre(Stmt *S) {
-  if (!Impl.shouldEnter(S))
+  if (!Impl->shouldEnter(S))
     return false;
-  Impl.analyze(S);
+  Impl->analyze(S);
-  Impl.enter(S);
+  Impl->enter(S);
   return true;
 };
 
 bool RangeResolver::walkToDeclPre(Decl *D, CharSourceRange Range) {
-  if (!Impl.shouldEnter(D))
+  if (!Impl->shouldEnter(D))
     return false;
-  Impl.analyze(D);
+  Impl->analyze(D);
-  Impl.enter(D);
+  Impl->enter(D);
   return true;
 }
 
 bool RangeResolver::walkToExprPost(Expr *E) {
-  Impl.leave(E);
+  Impl->leave(E);
-  return !Impl.hasResult();
+  return !Impl->hasResult();
 }
 
 bool RangeResolver::walkToStmtPost(Stmt *S) {
-  Impl.leave(S);
+  Impl->leave(S);
-  return !Impl.hasResult();
+  return !Impl->hasResult();
 };
 
 bool RangeResolver::walkToDeclPost(Decl *D) {
-  Impl.leave(D);
+  Impl->leave(D);
-  return !Impl.hasResult();
+  return !Impl->hasResult();
 }
 
 ResolvedRangeInfo RangeResolver::resolve() {
-  Impl.enter(ASTNode());
+  if (!Impl)
-  walk(Impl.File);
+    return ResolvedRangeInfo();
-  return Impl.getResult();
+  Impl->enter(ASTNode());
+  walk(Impl->File);
+  return Impl->getResult();
 }
 
 void swift::ide::getLocationInfoForClangNode(ClangNode ClangNode,

test/IDE/range_info_basics.swift

@@ -0,0 +1,40 @@
+func foo() -> Int{
+  var aaa = 1 + 2
+  aaa = aaa + 3
+  if aaa == 3 { aaa = 4 }
+  return aaa
+}
+
+func foo1() -> Int { return 0 }
+class C { func foo() {} }
+struct S { func foo() {} }
+
+
+// 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
+// RUN: %target-swift-ide-test -range -pos=3:1 -end-pos=4:26 -source-filename %s | %FileCheck %s -check-prefix=CHECK4
+// RUN: %target-swift-ide-test -range -pos=3:1 -end-pos=5:13 -source-filename %s | %FileCheck %s -check-prefix=CHECK5
+// RUN: %target-swift-ide-test -range -pos=4:1 -end-pos=5:13 -source-filename %s | %FileCheck %s -check-prefix=CHECK6
+
+// CHECK1: <Kind>SingleDecl</Kind>
+// CHECK1-NEXT: <Content>func foo1() -> Int { return 0 }</Content>
+
+// CHECK2: <Kind>SingleDecl</Kind>
+// CHECK2-NEXT: <Content>class C { func foo() {} }</Content>
+
+// CHECK3: <Kind>SingleDecl</Kind>
+// CHECK3-NEXT: <Content>struct S { func foo() {} }</Content>
+
+// CHECK4: <Kind>MultiStatement</Kind>
+// CHECK4-NEXT: <Content>aaa = aaa + 3
+// CHECK4-NEXT: if aaa == 3 { aaa = 4 }</Content>
+
+// CHECK5: <Kind>MultiStatement</Kind>
+// CHECK5-NEXT: <Content>aaa = aaa + 3
+// CHECK5-NEXT: if aaa == 3 { aaa = 4 }
+// CHECK5-NEXT: return aaa</Content>
+
+// CHECK6: <Kind>MultiStatement</Kind>
+// CHECK6-NEXT: if aaa == 3 { aaa = 4 }
+// CHECK6-NEXT: return aaa</Content>

tools/SourceKit/lib/SwiftLang/SwiftSourceDocInfo.cpp

@@ -493,7 +493,7 @@ static StringRef getSourceToken(unsigned Offset,
   return L.getTokenAt(Loc).getText();
 }
 
-static llvm::Optional<unsigned> 
+static llvm::Optional<unsigned>
 mapOffsetToOlderSnapshot(unsigned Offset,
                          ImmutableTextSnapshotRef NewSnap,
                          ImmutableTextSnapshotRef OldSnap) {
@@ -519,7 +519,7 @@ mapOffsetToOlderSnapshot(unsigned Offset,
   return Offset;
 }
 
-static llvm::Optional<unsigned> 
+static llvm::Optional<unsigned>
 mapOffsetToNewerSnapshot(unsigned Offset,
                          ImmutableTextSnapshotRef OldSnap,
                          ImmutableTextSnapshotRef NewSnap) {
@@ -1023,43 +1023,6 @@ static void resolveRange(SwiftLangSupport &Lang,
     unsigned Length;
     std::function<void(const RangeInfo&)> Receiver;
 
-    static SourceLoc getNonwhitespaceLocBefore(SourceManager &SM,
-                                               unsigned BufferID,
-                                               unsigned Offset) {
-      CharSourceRange entireRange = SM.getRangeForBuffer(BufferID);
-      StringRef Buffer = SM.extractText(entireRange);
-
-      const char *BufStart = Buffer.data();
-      if (Offset >= Buffer.size())
-        return SourceLoc();
-
-      for (unsigned Off = Offset; Off != 0; Off --) {
-        if (!clang::isWhitespace(*(BufStart + Off))) {
-          return SM.getLocForOffset(BufferID, Off);
-        }
-      }
-      return clang::isWhitespace(*BufStart) ? SourceLoc() :
-        SM.getLocForOffset(BufferID, 0);
-    }
-
-    static SourceLoc getNonwhitespaceLocAfter(SourceManager &SM,
-                                              unsigned BufferID,
-                                              unsigned Offset) {
-      CharSourceRange entireRange = SM.getRangeForBuffer(BufferID);
-      StringRef Buffer = SM.extractText(entireRange);
-
-      const char *BufStart = Buffer.data();
-      if (Offset >= Buffer.size())
-        return SourceLoc();
-
-      for (unsigned Off = Offset; Off < Buffer.size(); Off ++) {
-        if (!clang::isWhitespace(*(BufStart + Off))) {
-          return SM.getLocForOffset(BufferID, Off);
-        }
-      }
-      return SourceLoc();
-    }
-
   public:
     RangeInfoConsumer(StringRef InputFile, unsigned Offset, unsigned Length,
                        SwiftLangSupport &Lang, SwiftInvocationRef ASTInvok,
@@ -1070,25 +1033,10 @@ static void resolveRange(SwiftLangSupport &Lang,
 
     void handlePrimaryAST(ASTUnitRef AstUnit) override {
       auto &CompIns = AstUnit->getCompilerInstance();
-
-      unsigned BufferID = AstUnit->getPrimarySourceFile().getBufferID().getValue();
-      SourceManager &SM = CompIns.getSourceMgr();
-      SourceLoc StartLoc = getNonwhitespaceLocAfter(SM, BufferID, Offset);
-      SourceLoc EndLoc = getNonwhitespaceLocBefore(SM, BufferID,
-                                                   Offset + Length - 1);
-
-      StartLoc = Lexer::getLocForStartOfToken(SM, StartLoc);
-      EndLoc = Lexer::getLocForStartOfToken(SM, EndLoc);
-
-      if (StartLoc.isInvalid() || EndLoc.isInvalid()) {
-        Receiver({});
-        return;
-      }
-
       if (trace::enabled()) {
         // FIXME: Implement tracing
       }
-      RangeResolver Resolver(AstUnit->getPrimarySourceFile(), StartLoc, EndLoc);
+      RangeResolver Resolver(AstUnit->getPrimarySourceFile(), Offset, Length);
       ResolvedRangeInfo Info = Resolver.resolve();
 
       CompilerInvocation CompInvok;

tools/swift-ide-test/swift-ide-test.cpp

@@ -95,6 +95,7 @@ enum class ActionType {
   GenerateModuleAPIDescription,
   DiffModuleAPI,
   ReconstructType,
+  Range,
 };
 
 class NullDebuggerClient : public DebuggerClient {
@@ -208,6 +209,9 @@ Action(llvm::cl::desc("Mode:"), llvm::cl::init(ActionType::None),
            clEnumValN(ActionType::PrintModuleGroups,
                       "print-module-groups",
                       "Print group names in a module"),
+           clEnumValN(ActionType::Range,
+                      "range",
+                      "Print information about a given range"),
            clEnumValEnd));
 
 static llvm::cl::opt<std::string>
@@ -523,6 +527,9 @@ DeclToPrint("decl-to-print",
 static llvm::cl::opt<std::string>
 LineColumnPair("pos", llvm::cl::desc("Line:Column pair"));
 
+static llvm::cl::opt<std::string>
+EndLineColumnPair("end-pos", llvm::cl::desc("Line:Column pair"));
+
 static llvm::cl::opt<std::string>
 USR("usr", llvm::cl::desc("USR"));
 
@@ -2615,6 +2622,48 @@ static int doReconstructType(const CompilerInvocation &InitInvok,
   return 0;
 }
 
+static int doPrintRangeInfo(const CompilerInvocation &InitInvok,
+                            StringRef SourceFileName,
+                            StringRef StartPos,
+                            StringRef EndPos) {
+  auto StartOp = parseLineCol(StartPos);
+  auto EndOp = parseLineCol(EndPos);
+  if (!StartOp.hasValue() || !EndOp.hasValue())
+    return 1;
+  auto StartLineCol = StartOp.getValue();
+  auto EndLineCol = EndOp.getValue();
+  CompilerInvocation Invocation(InitInvok);
+  Invocation.addInputFilename(SourceFileName);
+  Invocation.getLangOptions().DisableAvailabilityChecking = false;
+
+  CompilerInstance CI;
+
+  // Display diagnostics to stderr.
+  PrintingDiagnosticConsumer PrintDiags;
+  CI.addDiagnosticConsumer(&PrintDiags);
+  if (CI.setup(Invocation))
+    return 1;
+  CI.performSema();
+  SourceFile *SF = nullptr;
+  for (auto Unit : CI.getMainModule()->getFiles()) {
+    SF = dyn_cast<SourceFile>(Unit);
+    if (SF)
+      break;
+  }
+  assert(SF && "no source file?");
+  assert(SF->getBufferID().hasValue() && "no buffer id?");
+  SourceManager &SM = SF->getASTContext().SourceMgr;
+  unsigned bufferID = SF->getBufferID().getValue();
+  SourceLoc StartLoc = SM.getLocForLineCol(bufferID, StartLineCol.first,
+                                           StartLineCol.second);
+  SourceLoc EndLoc = SM.getLocForLineCol(bufferID, EndLineCol.first,
+                                         EndLineCol.second);
+  RangeResolver Resolver(*SF, StartLoc, EndLoc);
+  ResolvedRangeInfo Result = Resolver.resolve();
+  Result.print(llvm::outs());
+  return 0;
+}
+
 static int doPrintUSRs(const CompilerInvocation &InitInvok,
                        StringRef SourceFilename) {
   CompilerInvocation Invocation(InitInvok);
@@ -3026,6 +3075,11 @@ int main(int argc, char *argv[]) {
   case ActionType::ReconstructType:
     ExitCode = doReconstructType(InitInvok, options::SourceFilename);
     break;
+  case ActionType::Range:
+    ExitCode = doPrintRangeInfo(InitInvok, options::SourceFilename,
+                                options::LineColumnPair,
+                                options::EndLineColumnPair);
+    break;
   }
 
   if (options::PrintStats)