Address stylistic suggestions in VariableTypeCollector

Rename VariableTypeCollector::getTypeOffsets to ::getTypeOffset and only
return the start offset, since the end offset is no longer needed (the
string is null-terminated).

Also improve variable naming slightly.

Author: fwcd

include/swift/Sema/IDETypeChecking.h

@@ -225,12 +225,12 @@ namespace swift {
   };
 
   /// Collect type information for every variable declaration in \c SF
-  /// within the given range.
+  /// within the given range into \c VariableTypeInfos.
   /// All types will be printed to \c OS and the type offsets of the
   /// \c VariableTypeInfos will index into the string that backs this
   /// stream.
   void collectVariableType(SourceFile &SF, SourceRange Range,
-                           std::vector<VariableTypeInfo> &Scratch,
+                           std::vector<VariableTypeInfo> &VariableTypeInfos,
                            llvm::raw_ostream &OS);
 
   /// FIXME: All of the below goes away once CallExpr directly stores its

lib/IDE/IDETypeChecking.cpp

@@ -735,7 +735,7 @@ swift::collectExpressionType(SourceFile &SF,
 /// declaration.
 class VariableTypeCollector : public SourceEntityWalker {
 private:
-  SourceManager &SM;
+  const SourceManager &SM;
   unsigned int BufferId;
 
   /// The range in which variable types are to be collected.
@@ -746,23 +746,23 @@ class VariableTypeCollector : public SourceEntityWalker {
 
   /// We print all types into a single output stream (e.g. into a string buffer)
   /// and provide offsets into this string buffer to describe individual types,
-  /// i.e. `OS` builds a string that contains all null-terminated printed type
+  /// i.e. \c OS builds a string that contains all null-terminated printed type
   /// strings. When referring to one of these types, we can use the offsets at
-  /// which it starts in the `OS`.
+  /// which it starts in the \c OS.
   llvm::raw_ostream &OS;
 
-  /// Map from a printed type to the offset in OS where the type starts.
+  /// Map from a printed type to the offset in \c OS where the type starts.
   llvm::StringMap<uint32_t> TypeOffsets;
 
-  /// Returns the start and end offset of this string in `OS`. If `PrintedType`
-  /// hasn't been printed to `OS` yet, this function will do so.
-  std::pair<uint32_t, uint32_t> getTypeOffsets(StringRef PrintedType) {
+  /// Returns the start offset of this string in \c OS. If \c PrintedType
+  /// hasn't been printed to \c OS yet, this function will do so.
+  uint32_t getTypeOffset(StringRef PrintedType) {
     auto It = TypeOffsets.find(PrintedType);
     if (It == TypeOffsets.end()) {
       TypeOffsets[PrintedType] = OS.tell();
       OS << PrintedType << '\0';
     }
-    return {TypeOffsets[PrintedType], PrintedType.size()};
+    return TypeOffsets[PrintedType];
   }
 
   /// Checks whether the given range overlaps the total range in which we
@@ -772,44 +772,44 @@ class VariableTypeCollector : public SourceEntityWalker {
   }
 
 public:
-  VariableTypeCollector(SourceFile &SF, SourceRange Range,
+  VariableTypeCollector(const SourceFile &SF, SourceRange Range,
                         std::vector<VariableTypeInfo> &Results,
                         llvm::raw_ostream &OS)
       : SM(SF.getASTContext().SourceMgr), BufferId(*SF.getBufferID()),
         TotalRange(Range), Results(Results), OS(OS) {}
 
-  bool walkToDeclPre(Decl *D, CharSourceRange DeclRange) override {
-    if (DeclRange.isInvalid()) {
-      return false;
+  bool walkToDeclPre(Decl *D, CharSourceRange DeclNameRange) override {
+    if (DeclNameRange.isInvalid()) {
+      return true;
     }
     // Skip this declaration and its subtree if outside the range
     if (!overlapsTotalRange(D->getSourceRange())) {
       return false;
     }
     if (auto VD = dyn_cast<VarDecl>(D)) {
       unsigned VarOffset =
-          SM.getLocOffsetInBuffer(DeclRange.getStart(), BufferId);
-      unsigned VarLength = DeclRange.getByteLength();
+          SM.getLocOffsetInBuffer(DeclNameRange.getStart(), BufferId);
+      unsigned VarLength = DeclNameRange.getByteLength();
       // Print the type to a temporary buffer
       SmallString<64> Buffer;
       {
         llvm::raw_svector_ostream OS(Buffer);
         PrintOptions Options;
         Options.SynthesizeSugarOnTypes = true;
         auto Ty = VD->getType();
-        // Skip this declaration if the type is an error type.
+        // Skip this declaration and its children if the type is an error type.
         if (Ty->is<ErrorType>()) {
           return false;
         }
         Ty->print(OS, Options);
       }
-      // Transfer the type to `OS` if needed and get the offsets of this string
+      // Transfer the type to `OS` if needed and get the offset of this string
       // in `OS`.
-      auto TyOffsets = getTypeOffsets(Buffer.str());
+      auto TyOffset = getTypeOffset(Buffer.str());
       bool HasExplicitType =
           VD->getTypeReprOrParentPatternTypeRepr() != nullptr;
       // Add the type information to the result list.
-      Results.emplace_back(VarOffset, VarLength, HasExplicitType, TyOffsets.first);
+      Results.emplace_back(VarOffset, VarLength, HasExplicitType, TyOffset);
     }
     return true;
   }
@@ -835,10 +835,10 @@ VariableTypeInfo::VariableTypeInfo(uint32_t Offset, uint32_t Length,
     : Offset(Offset), Length(Length), HasExplicitType(HasExplicitType),
       TypeOffset(TypeOffset) {}
 
-void swift::collectVariableType(SourceFile &SF, SourceRange Range,
-                                std::vector<VariableTypeInfo> &Scratch,
-                                llvm::raw_ostream &OS) {
-  VariableTypeCollector Walker(SF, Range, Scratch, OS);
+void swift::collectVariableType(
+    SourceFile &SF, SourceRange Range,
+    std::vector<VariableTypeInfo> &VariableTypeInfos, llvm::raw_ostream &OS) {
+  VariableTypeCollector Walker(SF, Range, VariableTypeInfos, OS);
   Walker.walk(SF);
 }