[SourceKit] Extend variable type request to show fully qualified types

Author: skrtks

include/swift/Sema/IDETypeChecking.h

@@ -261,8 +261,11 @@ namespace swift {
     /// The start of the printed type in a separate string buffer.
     uint32_t TypeOffset;
 
+    /// The start of the printed qualified type.
+    uint32_t QualifiedTypeOffset;
+
     VariableTypeInfo(uint32_t Offset, uint32_t Length, bool HasExplicitType,
-                     uint32_t TypeOffset);
+                     uint32_t TypeOffset, uint32_t QualifiedTypeOffset);
   };
 
   /// Collect type information for every variable declaration in \c SF

lib/IDE/IDETypeChecking.cpp

@@ -824,29 +824,26 @@ class VariableTypeCollector : public SourceEntityWalker {
       return false;
     }
     if (auto VD = dyn_cast<VarDecl>(D)) {
+      // Skip this declaration and its children if the type is an error type.
+      if (VD->getType()->is<ErrorType>()) {
+        return false;
+      }
       unsigned VarOffset =
           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 and its children if the type is an error type.
-        if (Ty->is<ErrorType>()) {
-          return false;
-        }
-        Ty->print(OS, Options);
-      }
+
+      auto printOptions = PrintOptions();
+      auto TyOffset = addToTypeBuffer(printOptions, VD);
+      printOptions.FullyQualifiedTypes = true;
+      auto QTyOffset = addToTypeBuffer(printOptions, VD);
+
       // Transfer the type to `OS` if needed and get the offset of this string
       // in `OS`.
-      auto TyOffset = getTypeOffset(Buffer.str());
       bool HasExplicitType =
           VD->getTypeReprOrParentPatternTypeRepr() != nullptr;
       // Add the type information to the result list.
-      Results.emplace_back(VarOffset, VarLength, HasExplicitType, TyOffset);
+      Results.emplace_back(VarOffset, VarLength, HasExplicitType, TyOffset,
+                           QTyOffset);
     }
     return true;
   }
@@ -865,12 +862,26 @@ class VariableTypeCollector : public SourceEntityWalker {
     // Skip this pattern and its subtree if outside the range
     return overlapsTotalRange(P->getSourceRange());
   }
+
+private:
+  // Save the type to the result buffer with desired formatting and return the
+  // offset in the buffer.
+  uint32_t addToTypeBuffer(PrintOptions &Options, VarDecl *VD) {
+    SmallString<64> Buffer;
+    llvm::raw_svector_ostream OS(Buffer);
+    Options.SynthesizeSugarOnTypes = true;
+    auto Ty = VD->getType();
+    Ty->print(OS, Options);
+
+    return getTypeOffset(Buffer.str());
+  }
 };
 
 VariableTypeInfo::VariableTypeInfo(uint32_t Offset, uint32_t Length,
-                                   bool HasExplicitType, uint32_t TypeOffset)
+                                   bool HasExplicitType, uint32_t TypeOffset,
+                                   uint32_t QualifiedTypeOffset)
     : Offset(Offset), Length(Length), HasExplicitType(HasExplicitType),
-      TypeOffset(TypeOffset) {}
+      TypeOffset(TypeOffset), QualifiedTypeOffset(QualifiedTypeOffset) {}
 
 void swift::collectVariableType(
     SourceFile &SF, SourceRange Range,

tools/SourceKit/docs/Protocol.md

@@ -816,10 +816,11 @@ type checking and the necessary compiler arguments to help resolve all dependenc
 ```
 var-type-info ::=
 {
-    <key.variable_offset>:       (int64)    // Offset of a variable identifier in the source file
-    <key.variable_length>:       (int64)    // Length of a variable identifier an expression in the source file
-    <key.variable_type>:         (string)   // Printed type of the variable declaration
-    <key.variable_type_explicit> (bool)     // Whether the declaration has an explicit type annotation
+    <key.variable_offset>:          (int64)    // Offset of a variable identifier in the source file
+    <key.variable_length>:          (int64)    // Length of a variable identifier an expression in the source file
+    <key.variable_type>:            (string)   // Printed type of the variable declaration
+    <key.variable_qualified_type>:  (string)   // Printed fully qualified type of the variable declaration
+    <key.variable_type_explicit>    (bool)     // Whether the declaration has an explicit type annotation
 }
 ```
 

tools/SourceKit/include/SourceKit/Core/LangSupport.h

@@ -148,6 +148,7 @@ struct VariableType {
   /// The offset of the type's string representation inside
   /// `VariableTypesInFile.TypeBuffer`.
   unsigned TypeOffset;
+  unsigned QualifiedTypeOffset;
   /// Whether the variable declaration has an explicit type annotation.
   bool HasExplicitType;
 };

tools/SourceKit/lib/SwiftLang/SwiftSourceDocInfo.cpp

@@ -2643,7 +2643,9 @@ void SwiftLangSupport::collectVariableTypes(
       collectVariableType(*SF, Range, Infos, OS);
 
       for (auto Info : Infos) {
-        Result.Results.push_back({Info.Offset, Info.Length, Info.TypeOffset, Info.HasExplicitType});
+        Result.Results.push_back({Info.Offset, Info.Length, Info.TypeOffset,
+                                  Info.QualifiedTypeOffset,
+                                  Info.HasExplicitType});
       }
       Result.TypeBuffer = OS.str();
       Receiver(RequestResult<VariableTypesInFile>::fromResult(Result));

tools/SourceKit/tools/sourcekitd/lib/API/VariableTypeArray.cpp

@@ -11,11 +11,10 @@
 //===----------------------------------------------------------------------===//
 
 #include "sourcekitd/VariableTypeArray.h"
-#include "sourcekitd/CompactArray.h"
+#include "DictionaryKeys.h"
 #include "SourceKit/Core/LLVM.h"
 #include "SourceKit/Core/LangSupport.h"
-#include "SourceKit/Support/UIdent.h"
-#include "DictionaryKeys.h"
+#include "sourcekitd/CompactArray.h"
 
 #include "llvm/Support/MemoryBuffer.h"
 
@@ -32,8 +31,10 @@ class VariableTypeReader {
   //  - Variable offset in the source buffer
   //  - Variable length in the source buffer
   //  - Offset of printed Variable type inside `PrintedTypes`
+  //  - Offset of printed Variable qualified type inside printedType
   //  - Whether the variable has an explicit type annotation
-  CompactArrayReader<unsigned, unsigned, unsigned, unsigned> EntryReader;
+  CompactArrayReader<unsigned, unsigned, unsigned, unsigned, unsigned>
+      EntryReader;
 
   static uint64_t getHeaderValue(char *Buffer, unsigned Index) {
     uint64_t HeaderField;
@@ -55,7 +56,8 @@ class VariableTypeReader {
     VariableType Result;
     unsigned HasExplicitType;
     EntryReader.readEntries(Idx, Result.VarOffset, Result.VarLength,
-                            Result.TypeOffset, HasExplicitType);
+                            Result.TypeOffset, Result.QualifiedTypeOffset,
+                            HasExplicitType);
     Result.HasExplicitType = static_cast<bool>(HasExplicitType);
     return Result;
   }
@@ -79,6 +81,8 @@ class VariableTypeReader {
     APPLY(KeyVariableOffset, Int, Result.VarOffset);
     APPLY(KeyVariableLength, Int, Result.VarLength);
     APPLY(KeyVariableType, String, Reader.readPrintedType(Result.TypeOffset));
+    APPLY(KeyVariableQualifiedType, String,
+          Reader.readPrintedType(Result.QualifiedTypeOffset));
     APPLY(KeyVariableTypeExplicit, Bool, Result.HasExplicitType);
     return true;
   }
@@ -88,7 +92,7 @@ class VariableTypeReader {
 struct VariableTypeArrayBuilder::Implementation {
   /// A builder that builds values read by \c EntryReader in \c
   /// VariableTypeReader. See \c VariableTypeReader::EntryReader for more info.
-  CompactArrayBuilder<unsigned, unsigned, unsigned, unsigned> Builder;
+  CompactArrayBuilder<unsigned, unsigned, unsigned, unsigned, unsigned> Builder;
   /// A builder that builds the \c PrintedTypes string used by \c
   /// VariableTypeReader. See \c VariableTypeReader::PrintedTypes for more info.
   CompactArrayBuilder<StringRef> StrBuilder;
@@ -146,7 +150,7 @@ VariableTypeArrayBuilder::~VariableTypeArrayBuilder() { delete &Impl; }
 void VariableTypeArrayBuilder::add(const VariableType &VarType) {
   Impl.Builder.addEntry(VarType.VarOffset, VarType.VarLength,
                         VarType.TypeOffset /*Printed type is null-terminated*/,
-                        VarType.HasExplicitType);
+                        VarType.QualifiedTypeOffset, VarType.HasExplicitType);
 }
 
 std::unique_ptr<llvm::MemoryBuffer> VariableTypeArrayBuilder::createBuffer() {

utils/gyb_sourcekit_support/UIDs.py

@@ -182,6 +182,7 @@ def __init__(self, internal_name, external_name):
     KEY('VariableOffset', 'key.variable_offset'),
     KEY('VariableLength', 'key.variable_length'),
     KEY('VariableType', 'key.variable_type'),
+    KEY('VariableQualifiedType', 'key.variable_qualified_type'),
     KEY('VariableTypeExplicit', 'key.variable_type_explicit'),
     KEY('CanonicalizeType', 'key.canonicalize_type'),
     KEY('InternalDiagnostic', 'key.internal_diagnostic'),