[SourceKit] Pass ResolvedCursorInfo as shared pointer instead of by value

This allows us to model the `ResolvedCursorInfo` types as a proper type hierarchy instead of having to store all values in the base `ResolvedCursorInfo` type.

rdar://102853071

Author: ahoppen

include/swift/IDE/CursorInfo.h

@@ -26,7 +26,7 @@ namespace ide {
 class CursorInfoConsumer {
 public:
   virtual ~CursorInfoConsumer() {}
-  virtual void handleResults(const ResolvedCursorInfo &) = 0;
+  virtual void handleResults(ResolvedCursorInfoPtr) = 0;
 };
 
 /// Create a factory for code completion callbacks.

include/swift/IDE/IDERequestIDZone.def

@@ -18,7 +18,8 @@
 SWIFT_REQUEST(IDE, CollectOverriddenDeclsRequest,
               ArrayRef<ValueDecl *>(OverridenDeclsOwner), Cached,
               NoLocationInfo)
-SWIFT_REQUEST(IDE, CursorInfoRequest, ide::ResolvedCursorInfo(CursorInfoOwner),
+SWIFT_REQUEST(IDE, CursorInfoRequest,
+              ide::ResolvedCursorInfoPtr(CursorInfoOwner),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(IDE, ProvideDefaultImplForRequest,
               ArrayRef<ValueDecl *>(ValueDecl *), Cached,

include/swift/IDE/IDERequests.h

@@ -57,20 +57,19 @@ struct CursorInfoOwner {
 void simple_display(llvm::raw_ostream &out, const CursorInfoOwner &owner);
 
 /// Resolve cursor info at a given location.
-class CursorInfoRequest:
-    public SimpleRequest<CursorInfoRequest,
-                         ide::ResolvedCursorInfo(CursorInfoOwner),
-                         RequestFlags::Cached>
-{
+class CursorInfoRequest
+    : public SimpleRequest<CursorInfoRequest,
+                           ide::ResolvedCursorInfoPtr(CursorInfoOwner),
+                           RequestFlags::Cached> {
 public:
   using SimpleRequest::SimpleRequest;
 
 private:
   friend SimpleRequest;
 
   // Evaluation.
-  ide::ResolvedCursorInfo evaluate(Evaluator &evaluator,
-                                   CursorInfoOwner CI) const;
+  ide::ResolvedCursorInfoPtr evaluate(Evaluator &evaluator,
+                                      CursorInfoOwner CI) const;
 
 public:
   // Caching

include/swift/IDE/Utils.h

@@ -131,54 +131,12 @@ enum class CursorInfoKind {
 
 /// Base class of more specialized \c ResolvedCursorInfos that also represents
 /// and \c Invalid cursor info.
-/// Subclasses of \c ResolvedCursorInfo cannot add new stored properies because
-/// \c ResolvedCursorInfo is being passed around as its base class and thus any
-/// properties in subclasses would get lost.
-struct ResolvedCursorInfo {
+struct ResolvedCursorInfo : public llvm::RefCountedBase<ResolvedCursorInfo> {
 protected:
   CursorInfoKind Kind = CursorInfoKind::Invalid;
   SourceFile *SF = nullptr;
   SourceLoc Loc;
 
-  // Technically, these structs could form a union (because only one of them is
-  // active at a time). But I had issues with C++ complaining about copy
-  // constructors and gave up. At the moment it's only wasting 3 words for non
-  // ValueRef data.
-  struct {
-    ValueDecl *ValueD = nullptr;
-    TypeDecl *CtorTyRef = nullptr;
-    ExtensionDecl *ExtTyRef = nullptr;
-    bool IsRef = true;
-    Type Ty;
-    Type ContainerType;
-    Optional<std::pair<const CustomAttr *, Decl *>> CustomAttrRef = None;
-
-    bool IsKeywordArgument = false;
-    /// It this is a ref, whether it is "dynamic". See \c ide::isDynamicRef.
-    bool IsDynamic = false;
-    /// If this is a dynamic ref, the types of the base (multiple in the case of
-    /// protocol composition).
-    SmallVector<NominalTypeDecl *> ReceiverTypes;
-    /// Declarations that were shadowed by \c ValueD using a shorthand syntax
-    /// that names both the newly declared variable and the referenced variable
-    /// by the same identifier in the source text. This includes shorthand
-    /// closure captures (`[foo]`) and shorthand if captures
-    /// (`if let foo {`). Ordered from innermost to outermost shadows.
-    ///
-    /// Decls that are shadowed using shorthand syntax should be reported as
-    /// additional cursor info results.
-    SmallVector<ValueDecl *> ShorthandShadowedDecls;
-  } ValueRefInfo;
-  struct {
-    ModuleEntity Mod;
-  } ModuleRefInfo;
-  struct {
-    Expr *TrailingExpr = nullptr;
-  } ExprStartInfo;
-  struct {
-    Stmt *TrailingStmt = nullptr;
-  } StmtStartInfo;
-
 public:
   ResolvedCursorInfo() = default;
   ResolvedCursorInfo(SourceFile *SF) : SF(SF) {}
@@ -200,142 +158,172 @@ struct ResolvedCursorInfo {
   bool isInvalid() const { return Kind == CursorInfoKind::Invalid; }
 };
 
+typedef llvm::IntrusiveRefCntPtr<ResolvedCursorInfo> ResolvedCursorInfoPtr;
+
 struct ResolvedValueRefCursorInfo : public ResolvedCursorInfo {
-  // IMPORTANT: Don't add stored properties here. See comment on
-  // ResolvedCursorInfo.
+private:
+  ValueDecl *ValueD = nullptr;
+  TypeDecl *CtorTyRef = nullptr;
+  ExtensionDecl *ExtTyRef = nullptr;
+  bool IsRef = true;
+  Type Ty;
+  Type ContainerType;
+  Optional<std::pair<const CustomAttr *, Decl *>> CustomAttrRef = None;
+
+  bool IsKeywordArgument = false;
+  /// It this is a ref, whether it is "dynamic". See \c ide::isDynamicRef.
+  bool IsDynamic = false;
+  /// If this is a dynamic ref, the types of the base (multiple in the case of
+  /// protocol composition).
+  SmallVector<NominalTypeDecl *> ReceiverTypes;
+  /// Declarations that were shadowed by \c ValueD using a shorthand syntax
+  /// that names both the newly declared variable and the referenced variable
+  /// by the same identifier in the source text. This includes shorthand
+  /// closure captures (`[foo]`) and shorthand if captures
+  /// (`if let foo {`). Ordered from innermost to outermost shadows.
+  ///
+  /// Decls that are shadowed using shorthand syntax should be reported as
+  /// additional cursor info results.
+  SmallVector<ValueDecl *> ShorthandShadowedDecls;
 
+public:
   ResolvedValueRefCursorInfo() = default;
-  explicit ResolvedValueRefCursorInfo(const ResolvedCursorInfo &Base,
+  explicit ResolvedValueRefCursorInfo(ResolvedCursorInfoPtr Base,
                                       ValueDecl *ValueD, TypeDecl *CtorTyRef,
                                       ExtensionDecl *ExtTyRef, bool IsRef,
                                       Type Ty, Type ContainerType)
-      : ResolvedCursorInfo(Base) {
-    assert(Base.getKind() == CursorInfoKind::Invalid &&
+      : ResolvedCursorInfo(*Base), ValueD(ValueD), CtorTyRef(CtorTyRef),
+        ExtTyRef(ExtTyRef), IsRef(IsRef), Ty(Ty), ContainerType(ContainerType) {
+    assert(Base->getKind() == CursorInfoKind::Invalid &&
            "Can only specialize from invalid");
-    Kind = CursorInfoKind::ValueRef;
-    ValueRefInfo.ValueD = ValueD;
-    ValueRefInfo.CtorTyRef = CtorTyRef;
-    ValueRefInfo.ExtTyRef = ExtTyRef;
-    ValueRefInfo.IsRef = IsRef;
-    ValueRefInfo.Ty = Ty;
-    ValueRefInfo.ContainerType = ContainerType;
+    this->Kind = CursorInfoKind::ValueRef;
   }
 
-  ValueDecl *getValueD() const { return ValueRefInfo.ValueD; }
-  void setValueD(ValueDecl *ValueD) { ValueRefInfo.ValueD = ValueD; }
+  ValueDecl *getValueD() const { return ValueD; }
+  void setValueD(ValueDecl *ValueD) { this->ValueD = ValueD; }
 
-  ExtensionDecl *getExtTyRef() const { return ValueRefInfo.ExtTyRef; }
+  ExtensionDecl *getExtTyRef() const { return ExtTyRef; }
 
-  TypeDecl *getCtorTyRef() const { return ValueRefInfo.CtorTyRef; }
+  TypeDecl *getCtorTyRef() const { return CtorTyRef; }
 
-  bool isRef() const { return ValueRefInfo.IsRef; }
-  void setIsRef(bool IsRef) { ValueRefInfo.IsRef = IsRef; }
+  bool isRef() const { return IsRef; }
+  void setIsRef(bool IsRef) { this->IsRef = IsRef; }
 
-  Type getType() const { return ValueRefInfo.Ty; }
+  Type getType() const { return Ty; }
 
-  Type getContainerType() const { return ValueRefInfo.ContainerType; }
-  void setContainerType(Type Ty) { ValueRefInfo.ContainerType = Ty; }
+  Type getContainerType() const { return ContainerType; }
+  void setContainerType(Type Ty) { this->ContainerType = Ty; }
 
-  bool isKeywordArgument() const { return ValueRefInfo.IsKeywordArgument; }
+  bool isKeywordArgument() const { return IsKeywordArgument; }
   void setIsKeywordArgument(bool IsKeywordArgument) {
-    ValueRefInfo.IsKeywordArgument = IsKeywordArgument;
+    this->IsKeywordArgument = IsKeywordArgument;
   }
 
-  bool isDynamic() const { return ValueRefInfo.IsDynamic; }
-  void setIsDynamic(bool IsDynamic) { ValueRefInfo.IsDynamic = IsDynamic; }
+  bool isDynamic() const { return this->IsDynamic; }
+  void setIsDynamic(bool IsDynamic) { this->IsDynamic = IsDynamic; }
 
   ArrayRef<NominalTypeDecl *> getReceiverTypes() const {
-    return ValueRefInfo.ReceiverTypes;
+    return this->ReceiverTypes;
   }
   void setReceiverTypes(const SmallVector<NominalTypeDecl *> &ReceiverTypes) {
-    ValueRefInfo.ReceiverTypes = ReceiverTypes;
+    this->ReceiverTypes = ReceiverTypes;
   }
 
   ArrayRef<ValueDecl *> getShorthandShadowedDecls() const {
-    return ValueRefInfo.ShorthandShadowedDecls;
+    return this->ShorthandShadowedDecls;
   };
   void setShorthandShadowedDecls(
       const SmallVector<ValueDecl *> &ShorthandShadowedDecls) {
-    ValueRefInfo.ShorthandShadowedDecls = ShorthandShadowedDecls;
+    this->ShorthandShadowedDecls = ShorthandShadowedDecls;
   };
 
-  ValueDecl *typeOrValue() {
-    return ValueRefInfo.CtorTyRef ? ValueRefInfo.CtorTyRef
-                                  : ValueRefInfo.ValueD;
-  }
+  ValueDecl *typeOrValue() { return CtorTyRef ? CtorTyRef : ValueD; }
 
   Optional<std::pair<const CustomAttr *, Decl *>> getCustomAttrRef() const {
-    return ValueRefInfo.CustomAttrRef;
+    return CustomAttrRef;
   }
   void setCustomAttrRef(Optional<std::pair<const CustomAttr *, Decl *>> ref) {
-    ValueRefInfo.CustomAttrRef = ref;
+    CustomAttrRef = ref;
   }
 
   static bool classof(const ResolvedCursorInfo *Info) {
     return Info->getKind() == CursorInfoKind::ValueRef;
   }
 };
 
+typedef llvm::IntrusiveRefCntPtr<ResolvedValueRefCursorInfo>
+    ResolvedValueRefCursorInfoPtr;
+
 struct ResolvedModuleRefCursorInfo : public ResolvedCursorInfo {
-  // IMPORTANT: Don't add stored properties here. See comment on
-  // ResolvedCursorInfo.
+private:
+  ModuleEntity Mod;
 
-  ResolvedModuleRefCursorInfo(const ResolvedCursorInfo &Base, ModuleEntity Mod)
-      : ResolvedCursorInfo(Base) {
-    assert(Base.getKind() == CursorInfoKind::Invalid &&
+public:
+  ResolvedModuleRefCursorInfo(ResolvedCursorInfoPtr Base, ModuleEntity Mod)
+      : ResolvedCursorInfo(*Base), Mod(Mod) {
+    assert(Base->getKind() == CursorInfoKind::Invalid &&
            "Can only specialize from invalid");
-    Kind = CursorInfoKind::ModuleRef;
-    ModuleRefInfo.Mod = Mod;
+    this->Kind = CursorInfoKind::ModuleRef;
   }
 
-  ModuleEntity getMod() const { return ModuleRefInfo.Mod; }
+  ModuleEntity getMod() const { return Mod; }
 
   static bool classof(const ResolvedCursorInfo *Info) {
     return Info->getKind() == CursorInfoKind::ModuleRef;
   }
 };
 
+typedef llvm::IntrusiveRefCntPtr<ResolvedModuleRefCursorInfo>
+    ResolvedModuleRefCursorInfoPtr;
+
 struct ResolvedExprStartCursorInfo : public ResolvedCursorInfo {
-  // IMPORTANT: Don't add stored properties here. See comment on
-  // ResolvedCursorInfo.
+private:
+  Expr *TrailingExpr = nullptr;
 
-  ResolvedExprStartCursorInfo(const ResolvedCursorInfo &Base,
-                              Expr *TrailingExpr)
-      : ResolvedCursorInfo(Base) {
-    assert(Base.getKind() == CursorInfoKind::Invalid &&
+public:
+  ResolvedExprStartCursorInfo(ResolvedCursorInfoPtr Base, Expr *TrailingExpr)
+      : ResolvedCursorInfo(*Base), TrailingExpr(TrailingExpr) {
+    assert(Base->getKind() == CursorInfoKind::Invalid &&
            "Can only specialize from invalid");
-    Kind = CursorInfoKind::ExprStart;
-    ExprStartInfo.TrailingExpr = TrailingExpr;
+    this->Kind = CursorInfoKind::ExprStart;
   }
 
-  Expr *getTrailingExpr() const { return ExprStartInfo.TrailingExpr; }
+  Expr *getTrailingExpr() const { return TrailingExpr; }
 
   static bool classof(const ResolvedCursorInfo *Info) {
     return Info->getKind() == CursorInfoKind::ExprStart;
   }
 };
 
+typedef llvm::IntrusiveRefCntPtr<ResolvedExprStartCursorInfo>
+    ResolvedExprStartCursorInfoPtr;
+
 struct ResolvedStmtStartCursorInfo : public ResolvedCursorInfo {
-  // IMPORTANT: Don't add stored properties here. See comment on
-  // ResolvedCursorInfo.
+  Stmt *TrailingStmt = nullptr;
 
-  ResolvedStmtStartCursorInfo(const ResolvedCursorInfo &Base,
-                              Stmt *TrailingStmt)
-      : ResolvedCursorInfo(Base) {
-    assert(Base.getKind() == CursorInfoKind::Invalid &&
+  ResolvedStmtStartCursorInfo(ResolvedCursorInfoPtr Base, Stmt *TrailingStmt)
+      : ResolvedCursorInfo(*Base), TrailingStmt(TrailingStmt) {
+    assert(Base->getKind() == CursorInfoKind::Invalid &&
            "Can only specialize from invalid");
-    Kind = CursorInfoKind::StmtStart;
-    StmtStartInfo.TrailingStmt = TrailingStmt;
+    this->Kind = CursorInfoKind::StmtStart;
   }
 
-  Stmt *getTrailingStmt() const { return StmtStartInfo.TrailingStmt; }
+  Stmt *getTrailingStmt() const { return TrailingStmt; }
 
   static bool classof(const ResolvedCursorInfo *Info) {
     return Info->getKind() == CursorInfoKind::StmtStart;
   }
 };
 
-void simple_display(llvm::raw_ostream &out, const ResolvedCursorInfo &info);
+typedef llvm::IntrusiveRefCntPtr<ResolvedStmtStartCursorInfo>
+    ResolvedStmtStartCursorInfoPtr;
+
+void simple_display(llvm::raw_ostream &out, ResolvedCursorInfoPtr info);
+
+template <typename T>
+llvm::IntrusiveRefCntPtr<T> dyn_cast_cursor_info(ResolvedCursorInfoPtr Ptr) {
+  return llvm::IntrusiveRefCntPtr<T>(dyn_cast<T>(Ptr.get()));
+}
 
 struct UnresolvedLoc {
   SourceLoc Loc;

include/swift/IDETool/IDEInspectionInstance.h

@@ -82,7 +82,7 @@ struct ConformingMethodListResults {
 /// The results returned from \c IDEInspectionInstance::cursorInfo.
 struct CursorInfoResults {
   /// The actual results. If \c nullptr, no results were found.
-  const ResolvedCursorInfo *Result;
+  ResolvedCursorInfoPtr Result;
   /// Whether an AST was reused to produce the results.
   bool DidReuseAST;
 };

include/swift/Refactoring/Refactoring.h

@@ -136,7 +136,7 @@ void collectAvailableRefactorings(
     llvm::SmallVectorImpl<RefactoringKind> &Kinds,
     llvm::ArrayRef<DiagnosticConsumer *> DiagConsumers);
 
-void collectAvailableRefactorings(const ResolvedCursorInfo &CursorInfo,
+void collectAvailableRefactorings(ResolvedCursorInfoPtr CursorInfo,
                                   llvm::SmallVectorImpl<RefactoringKind> &Kinds,
                                   bool ExcludeRename);