[IDE] Split ResolvedCursorInfo into subclasses

This way, each kind of `ResolvedCursorInfo` can define its own set of properties and it’s obvious which properties are used for which kind. Also switch to getters and setters because that makes it easier to search for usages of properties by looking at the call hierarchy of the getter / setter.

Author: ahoppen

include/swift/IDE/Utils.h

@@ -128,71 +128,200 @@ enum class CursorInfoKind {
   StmtStart,
 };
 
+/// 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 {
+protected:
   CursorInfoKind Kind = CursorInfoKind::Invalid;
   SourceFile *SF = nullptr;
   SourceLoc Loc;
-  ValueDecl *ValueD = nullptr;
-  TypeDecl *CtorTyRef = nullptr;
-  ExtensionDecl *ExtTyRef = nullptr;
-  /// 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 {`).
-  /// Decls that are shadowed using shorthand syntax should be reported as
-  /// additional cursor info results.
-  SmallVector<ValueDecl *, 2> ShorthandShadowedDecls;
-  ModuleEntity Mod;
-  bool IsRef = true;
-  bool IsKeywordArgument = false;
-  Type Ty;
-  Type ContainerType;
-  Stmt *TrailingStmt = nullptr;
-  Expr *TrailingExpr = nullptr;
-  /// 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 *, 1> ReceiverTypes;
 
+  // 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;
+    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 {`).
+    /// 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) {}
 
-  ValueDecl *typeOrValue() { return CtorTyRef ? CtorTyRef : ValueD; }
+  CursorInfoKind getKind() const { return Kind; }
+
+  SourceFile *getSourceFile() const { return SF; }
+
+  SourceLoc getLoc() const { return Loc; }
+  void setLoc(SourceLoc Loc) { this->Loc = Loc; }
 
   friend bool operator==(const ResolvedCursorInfo &lhs,
                          const ResolvedCursorInfo &rhs) {
     return lhs.SF == rhs.SF &&
       lhs.Loc.getOpaquePointerValue() == rhs.Loc.getOpaquePointerValue();
   }
 
-  void setValueRef(ValueDecl *ValueD, TypeDecl *CtorTyRef,
-                   ExtensionDecl *ExtTyRef, bool IsRef,
-                   Type Ty, Type ContainerType) {
+  bool isValid() const { return !isInvalid(); }
+  bool isInvalid() const { return Kind == CursorInfoKind::Invalid; }
+};
+
+struct ResolvedValueRefCursorInfo : public ResolvedCursorInfo {
+  // IMPORTANT: Don't add stored properties here. See comment on
+  // ResolvedCursorInfo.
+
+  ResolvedValueRefCursorInfo() = default;
+  explicit ResolvedValueRefCursorInfo(const ResolvedCursorInfo &Base,
+                                      ValueDecl *ValueD, TypeDecl *CtorTyRef,
+                                      ExtensionDecl *ExtTyRef, bool IsRef,
+                                      Type Ty, Type ContainerType)
+      : ResolvedCursorInfo(Base) {
+    assert(Base.getKind() == CursorInfoKind::Invalid &&
+           "Can only specialize from invalid");
     Kind = CursorInfoKind::ValueRef;
-    this->ValueD = ValueD;
-    this->CtorTyRef = CtorTyRef;
-    this->ExtTyRef = ExtTyRef;
-    this->IsRef = IsRef;
-    this->Ty = Ty;
-    this->ContainerType = ContainerType;
+    ValueRefInfo.ValueD = ValueD;
+    ValueRefInfo.CtorTyRef = CtorTyRef;
+    ValueRefInfo.ExtTyRef = ExtTyRef;
+    ValueRefInfo.IsRef = IsRef;
+    ValueRefInfo.Ty = Ty;
+    ValueRefInfo.ContainerType = ContainerType;
+  }
+
+  ValueDecl *getValueD() const { return ValueRefInfo.ValueD; }
+  void setValueD(ValueDecl *ValueD) { ValueRefInfo.ValueD = ValueD; }
+
+  ExtensionDecl *getExtTyRef() const { return ValueRefInfo.ExtTyRef; }
+
+  TypeDecl *getCtorTyRef() const { return ValueRefInfo.CtorTyRef; }
+
+  bool isRef() const { return ValueRefInfo.IsRef; }
+  void setIsRef(bool IsRef) { ValueRefInfo.IsRef = IsRef; }
+
+  Type getType() const { return ValueRefInfo.Ty; }
+
+  Type getContainerType() const { return ValueRefInfo.ContainerType; }
+  void setContainerType(Type Ty) { ValueRefInfo.ContainerType = Ty; }
+
+  bool isKeywordArgument() const { return ValueRefInfo.IsKeywordArgument; }
+  void setIsKeywordArgument(bool IsKeywordArgument) {
+    ValueRefInfo.IsKeywordArgument = IsKeywordArgument;
+  }
+
+  bool isDynamic() const { return ValueRefInfo.IsDynamic; }
+  void setIsDynamic(bool IsDynamic) { ValueRefInfo.IsDynamic = IsDynamic; }
+
+  ArrayRef<NominalTypeDecl *> getReceiverTypes() const {
+    return ValueRefInfo.ReceiverTypes;
+  }
+  void setReceiverTypes(const SmallVector<NominalTypeDecl *> &ReceiverTypes) {
+    ValueRefInfo.ReceiverTypes = ReceiverTypes;
+  }
+
+  ArrayRef<ValueDecl *> getShorthandShadowedDecls() const {
+    return ValueRefInfo.ShorthandShadowedDecls;
+  };
+  void setShorthandShadowedDecls(
+      const SmallVector<ValueDecl *> &ShorthandShadowedDecls) {
+    ValueRefInfo.ShorthandShadowedDecls = ShorthandShadowedDecls;
+  };
+
+  ValueDecl *typeOrValue() {
+    return ValueRefInfo.CtorTyRef ? ValueRefInfo.CtorTyRef
+                                  : ValueRefInfo.ValueD;
   }
-  void setModuleRef(ModuleEntity Mod) {
+
+  static bool classof(const ResolvedCursorInfo *Info) {
+    return Info->getKind() == CursorInfoKind::ValueRef;
+  }
+};
+
+struct ResolvedModuleRefCursorInfo : public ResolvedCursorInfo {
+  // IMPORTANT: Don't add stored properties here. See comment on
+  // ResolvedCursorInfo.
+
+  ResolvedModuleRefCursorInfo(const ResolvedCursorInfo &Base, ModuleEntity Mod)
+      : ResolvedCursorInfo(Base) {
+    assert(Base.getKind() == CursorInfoKind::Invalid &&
+           "Can only specialize from invalid");
     Kind = CursorInfoKind::ModuleRef;
-    this->Mod = Mod;
+    ModuleRefInfo.Mod = Mod;
   }
-  void setTrailingStmt(Stmt *TrailingStmt) {
-    Kind = CursorInfoKind::StmtStart;
-    this->TrailingStmt = TrailingStmt;
+
+  ModuleEntity getMod() const { return ModuleRefInfo.Mod; }
+
+  static bool classof(const ResolvedCursorInfo *Info) {
+    return Info->getKind() == CursorInfoKind::ModuleRef;
   }
-  void setTrailingExpr(Expr* TrailingExpr) {
+};
+
+struct ResolvedExprStartCursorInfo : public ResolvedCursorInfo {
+  // IMPORTANT: Don't add stored properties here. See comment on
+  // ResolvedCursorInfo.
+
+  ResolvedExprStartCursorInfo(const ResolvedCursorInfo &Base,
+                              Expr *TrailingExpr)
+      : ResolvedCursorInfo(Base) {
+    assert(Base.getKind() == CursorInfoKind::Invalid &&
+           "Can only specialize from invalid");
     Kind = CursorInfoKind::ExprStart;
-    this->TrailingExpr = TrailingExpr;
+    ExprStartInfo.TrailingExpr = TrailingExpr;
   }
 
-  bool isValid() const { return !isInvalid(); }
-  bool isInvalid() const { return Kind == CursorInfoKind::Invalid; }
+  Expr *getTrailingExpr() const { return ExprStartInfo.TrailingExpr; }
+
+  static bool classof(const ResolvedCursorInfo *Info) {
+    return Info->getKind() == CursorInfoKind::ExprStart;
+  }
+};
+
+struct ResolvedStmtStartCursorInfo : public ResolvedCursorInfo {
+  // IMPORTANT: Don't add stored properties here. See comment on
+  // ResolvedCursorInfo.
+
+  ResolvedStmtStartCursorInfo(const ResolvedCursorInfo &Base,
+                              Stmt *TrailingStmt)
+      : ResolvedCursorInfo(Base) {
+    assert(Base.getKind() == CursorInfoKind::Invalid &&
+           "Can only specialize from invalid");
+    Kind = CursorInfoKind::StmtStart;
+    StmtStartInfo.TrailingStmt = TrailingStmt;
+  }
+
+  Stmt *getTrailingStmt() const { return StmtStartInfo.TrailingStmt; }
+
+  static bool classof(const ResolvedCursorInfo *Info) {
+    return Info->getKind() == CursorInfoKind::StmtStart;
+  }
 };
 
 void simple_display(llvm::raw_ostream &out, const ResolvedCursorInfo &info);

lib/IDE/IDERequests.cpp

@@ -125,20 +125,24 @@ bool CursorInfoResolver::tryResolve(ValueDecl *D, TypeDecl *CtorTyRef,
     }
   }
 
+  ResolvedValueRefCursorInfo ValueRefInfo(CursorInfo, D, CtorTyRef, ExtTyRef,
+                                          IsRef, Ty, ContainerType);
   if (Expr *BaseE = getBase(ExprStack)) {
     if (isDynamicRef(BaseE, D)) {
-      CursorInfo.IsDynamic = true;
-      ide::getReceiverType(BaseE, CursorInfo.ReceiverTypes);
+      ValueRefInfo.setIsDynamic(true);
+      SmallVector<NominalTypeDecl *> ReceiverTypes;
+      ide::getReceiverType(BaseE, ReceiverTypes);
+      ValueRefInfo.setReceiverTypes(ReceiverTypes);
     }
   }
 
-  CursorInfo.setValueRef(D, CtorTyRef, ExtTyRef, IsRef, Ty, ContainerType);
+  CursorInfo = ValueRefInfo;
   return true;
 }
 
 bool CursorInfoResolver::tryResolve(ModuleEntity Mod, SourceLoc Loc) {
   if (Loc == LocToResolve) {
-    CursorInfo.setModuleRef(Mod);
+    CursorInfo = ResolvedModuleRefCursorInfo(CursorInfo, Mod);
     return true;
   }
   return false;
@@ -147,13 +151,13 @@ bool CursorInfoResolver::tryResolve(ModuleEntity Mod, SourceLoc Loc) {
 bool CursorInfoResolver::tryResolve(Stmt *St) {
   if (auto *LST = dyn_cast<LabeledStmt>(St)) {
     if (LST->getStartLoc() == LocToResolve) {
-      CursorInfo.setTrailingStmt(St);
+      CursorInfo = ResolvedStmtStartCursorInfo(CursorInfo, St);
       return true;
     }
   }
   if (auto *CS = dyn_cast<CaseStmt>(St)) {
     if (CS->getStartLoc() == LocToResolve) {
-      CursorInfo.setTrailingStmt(St);
+      CursorInfo = ResolvedStmtStartCursorInfo(CursorInfo, St);
       return true;
     }
   }
@@ -171,16 +175,21 @@ bool CursorInfoResolver::visitSubscriptReference(ValueDecl *D,
 ResolvedCursorInfo CursorInfoResolver::resolve(SourceLoc Loc) {
   assert(Loc.isValid());
   LocToResolve = Loc;
-  CursorInfo.Loc = Loc;
+  CursorInfo.setLoc(Loc);
 
   walk(SrcFile);
 
-  if (!CursorInfo.IsRef) {
-    // If we have a definition, add any decls that it potentially shadows
-    auto ShorthandShadowedDecl = ShorthandShadowedDecls[CursorInfo.ValueD];
-    while (ShorthandShadowedDecl) {
-      CursorInfo.ShorthandShadowedDecls.push_back(ShorthandShadowedDecl);
-      ShorthandShadowedDecl = ShorthandShadowedDecls[ShorthandShadowedDecl];
+  if (auto ValueRefInfo = dyn_cast<ResolvedValueRefCursorInfo>(&CursorInfo)) {
+    if (!ValueRefInfo->isRef()) {
+      SmallVector<ValueDecl *> ShadowedDecls;
+      // If we have a definition, add any decls that it potentially shadows
+      auto ShorthandShadowedDecl =
+          ShorthandShadowedDecls[ValueRefInfo->getValueD()];
+      while (ShorthandShadowedDecl) {
+        ShadowedDecls.push_back(ShorthandShadowedDecl);
+        ShorthandShadowedDecl = ShorthandShadowedDecls[ShorthandShadowedDecl];
+      }
+      ValueRefInfo->setShorthandShadowedDecls(ShadowedDecls);
     }
   }
 
@@ -307,7 +316,7 @@ bool CursorInfoResolver::walkToExprPost(Expr *E) {
     return false;
 
   if (OutermostCursorExpr && isCursorOn(E, LocToResolve)) {
-    CursorInfo.setTrailingExpr(OutermostCursorExpr);
+    CursorInfo = ResolvedExprStartCursorInfo(CursorInfo, OutermostCursorExpr);
     return false;
   }
 
@@ -328,8 +337,9 @@ bool CursorInfoResolver::visitCallArgName(Identifier Name,
     return true;
 
   bool Found = tryResolve(D, nullptr, nullptr, Range.getStart(), /*IsRef=*/true);
-  if (Found)
-    CursorInfo.IsKeywordArgument = true;
+  if (Found) {
+    cast<ResolvedValueRefCursorInfo>(CursorInfo).setIsKeywordArgument(true);
+  }
   return !Found;
 }
 
@@ -383,9 +393,9 @@ void swift::ide::simple_display(llvm::raw_ostream &out,
   if (info.isInvalid())
     return;
   out << "Resolved cursor info at ";
-  auto &SM = info.SF->getASTContext().SourceMgr;
-  out << SM.getIdentifierForBuffer(*info.SF->getBufferID());
-  auto LC = SM.getLineAndColumnInBuffer(info.Loc);
+  auto &SM = info.getSourceFile()->getASTContext().SourceMgr;
+  out << SM.getIdentifierForBuffer(*info.getSourceFile()->getBufferID());
+  auto LC = SM.getLineAndColumnInBuffer(info.getLoc());
   out << ":" << LC.first << ":" << LC.second;
 }