Merge pull request #83400 from swiftlang/jepa-main

Address `llvm::PointerUnion::{is,get}` deprecations

Author: AnthonyLatsis

include/swift/AST/ASTNode.h

@@ -45,9 +45,15 @@ namespace swift {
   enum class PatternKind : uint8_t;
   enum class StmtKind;
 
-  struct ASTNode
-      : public llvm::PointerUnion<Expr *, Stmt *, Decl *, Pattern *, TypeRepr *,
-                                  StmtConditionElement *, CaseLabelItem *> {
+  namespace detail {
+  using ASTNodeBase =
+      llvm::PointerUnion<Expr *, Stmt *, Decl *, Pattern *, TypeRepr *,
+                         StmtConditionElement *, CaseLabelItem *>;
+  } // end namespace detail
+
+  struct ASTNode : public detail::ASTNodeBase {
+    using Base = detail::ASTNodeBase;
+
     // Inherit the constructors from PointerUnion.
     using PointerUnion::PointerUnion;
 
@@ -109,6 +115,14 @@ namespace swift {
 
 namespace llvm {
   using swift::ASTNode;
+
+  /// `isa`, `dyn_cast`, `cast` for `ASTNode`.
+  template <typename To>
+  struct CastInfo<To, ASTNode> : public CastInfo<To, ASTNode::Base> {};
+  template <typename To>
+  struct CastInfo<To, const ASTNode>
+      : public CastInfo<To, const ASTNode::Base> {};
+
   template <> struct DenseMapInfo<ASTNode> {
     static inline ASTNode getEmptyKey() {
       return DenseMapInfo<swift::Expr *>::getEmptyKey();

include/swift/AST/AnyFunctionRef.h

@@ -72,13 +72,13 @@ class AnyFunctionRef {
   CaptureInfo getCaptureInfo() const {
     if (auto *AFD = TheFunction.dyn_cast<AbstractFunctionDecl *>())
       return AFD->getCaptureInfo();
-    return TheFunction.get<AbstractClosureExpr *>()->getCaptureInfo();
+    return cast<AbstractClosureExpr *>(TheFunction)->getCaptureInfo();
   }
 
   ParameterList *getParameters() const {
     if (auto *AFD = TheFunction.dyn_cast<AbstractFunctionDecl *>())
       return AFD->getParameters();
-    return TheFunction.get<AbstractClosureExpr *>()->getParameters();
+    return cast<AbstractClosureExpr *>(TheFunction)->getParameters();
   }
 
   bool hasExternalPropertyWrapperParameters() const {
@@ -90,7 +90,7 @@ class AnyFunctionRef {
   Type getType() const {
     if (auto *AFD = TheFunction.dyn_cast<AbstractFunctionDecl *>())
       return AFD->getInterfaceType();
-    return TheFunction.get<AbstractClosureExpr *>()->getType();
+    return cast<AbstractClosureExpr *>(TheFunction)->getType();
   }
 
   Type getBodyResultType() const {
@@ -99,7 +99,7 @@ class AnyFunctionRef {
         return FD->mapTypeIntoContext(FD->getResultInterfaceType());
       return TupleType::getEmpty(AFD->getASTContext());
     }
-    return TheFunction.get<AbstractClosureExpr *>()->getResultType();
+    return cast<AbstractClosureExpr *>(TheFunction)->getResultType();
   }
 
   ArrayRef<AnyFunctionType::Yield>
@@ -115,7 +115,7 @@ class AnyFunctionRef {
   BraceStmt *getBody() const {
     if (auto *AFD = TheFunction.dyn_cast<AbstractFunctionDecl *>())
       return AFD->getBody();
-    auto *ACE = TheFunction.get<AbstractClosureExpr *>();
+    auto *ACE = cast<AbstractClosureExpr *>(TheFunction);
     if (auto *CE = dyn_cast<ClosureExpr>(ACE))
       return CE->getBody();
     return cast<AutoClosureExpr>(ACE)->getBody();
@@ -127,7 +127,7 @@ class AnyFunctionRef {
       return;
     }
 
-    auto *ACE = TheFunction.get<AbstractClosureExpr *>();
+    auto *ACE = cast<AbstractClosureExpr *>(TheFunction);
     if (auto *CE = dyn_cast<ClosureExpr>(ACE)) {
       CE->setBody(stmt);
       CE->setBodyState(ClosureExpr::BodyState::Parsed);
@@ -143,7 +143,7 @@ class AnyFunctionRef {
       return;
     }
 
-    auto *ACE = TheFunction.get<AbstractClosureExpr *>();
+    auto *ACE = cast<AbstractClosureExpr *>(TheFunction);
     if (auto *CE = dyn_cast<ClosureExpr>(ACE)) {
       CE->setBody(stmt);
       CE->setBodyState(ClosureExpr::BodyState::TypeChecked);
@@ -168,7 +168,7 @@ class AnyFunctionRef {
   DeclContext *getAsDeclContext() const {
     if (auto *AFD = TheFunction.dyn_cast<AbstractFunctionDecl *>())
       return AFD;
-    return TheFunction.get<AbstractClosureExpr *>();
+    return cast<AbstractClosureExpr *>(TheFunction);
   }
 
   AbstractFunctionDecl *getAbstractFunctionDecl() const {

include/swift/AST/AvailabilityDomain.h

@@ -120,9 +120,9 @@ class AvailabilityDomain final {
   AvailabilityDomain(Storage storage) : storage(storage) {};
 
   std::optional<InlineDomain> getInlineDomain() const {
-    return storage.is<InlineDomainPtr>()
+    return isa<InlineDomainPtr>(storage)
                ? static_cast<std::optional<InlineDomain>>(
-                     storage.get<InlineDomainPtr>())
+                     cast<InlineDomainPtr>(storage))
                : std::nullopt;
   }
 
@@ -203,7 +203,7 @@ class AvailabilityDomain final {
   /// the domain. Returns `nullptr` otherwise.
   const CustomAvailabilityDomain *getCustomDomain() const {
     if (isCustom())
-      return storage.get<const CustomAvailabilityDomain *>();
+      return cast<const CustomAvailabilityDomain *>(storage);
     return nullptr;
   }
 
@@ -401,25 +401,25 @@ class AvailabilityDomainOrIdentifier {
       : storage(domain) {};
 
   bool isDomain() const {
-    return storage.getPointer().is<AvailabilityDomain>();
+    return isa<AvailabilityDomain>(storage.getPointer());
   }
-  bool isIdentifier() const { return storage.getPointer().is<Identifier>(); }
+  bool isIdentifier() const { return isa<Identifier>(storage.getPointer()); }
 
   /// Overwrites the existing domain or identifier with the given domain.
   void setDomain(AvailabilityDomain domain) { storage = Storage(domain); }
 
   /// Returns the resolved domain, or `std::nullopt` if there isn't one.
   std::optional<AvailabilityDomain> getAsDomain() const {
     if (isDomain())
-      return storage.getPointer().get<AvailabilityDomain>();
+      return cast<AvailabilityDomain>(storage.getPointer());
     return std::nullopt;
   }
 
   /// Returns the unresolved identifier, or `std::nullopt` if the domain has
   /// been resolved.
   std::optional<Identifier> getAsIdentifier() const {
     if (isIdentifier())
-      return storage.getPointer().get<Identifier>();
+      return cast<Identifier>(storage.getPointer());
     return std::nullopt;
   }
 

include/swift/AST/CatchNode.h

@@ -22,12 +22,16 @@
 
 namespace swift {
 
+namespace detail {
+using CatchNodeBase = llvm::PointerUnion<AbstractFunctionDecl *, ClosureExpr *,
+                                         DoCatchStmt *, AnyTryExpr *>;
+} // end namespace detail
+
 /// An AST node that represents a point where a thrown error can be caught and
 /// or rethrown, which includes functions do...catch statements.
-class CatchNode: public llvm::PointerUnion<
-    AbstractFunctionDecl *, ClosureExpr *, DoCatchStmt *, AnyTryExpr *
-  > {
+class CatchNode : public detail::CatchNodeBase {
 public:
+  using Base = detail::CatchNodeBase;
   using PointerUnion::PointerUnion;
 
   /// Determine the thrown error type within the region of this catch node
@@ -62,4 +66,17 @@ SourceLoc extractNearestSourceLoc(CatchNode catchNode);
 
 } // end namespace swift
 
+namespace llvm {
+
+using swift::CatchNode;
+
+/// `isa`, `dyn_cast`, `cast` for `CatchNode`.
+template <typename To>
+struct CastInfo<To, CatchNode> : public CastInfo<To, CatchNode::Base> {};
+template <typename To>
+struct CastInfo<To, const CatchNode>
+    : public CastInfo<To, const CatchNode::Base> {};
+
+} // end namespace llvm
+
 #endif // SWIFT_AST_CATCHNODE_H

include/swift/AST/ClangNode.h

@@ -14,6 +14,7 @@
 #define SWIFT_CLANGNODE_H
 
 #include "swift/Basic/Debug.h"
+#include "swift/Basic/LLVM.h"
 #include "llvm/ADT/PointerUnion.h"
 
 namespace clang {
@@ -76,16 +77,16 @@ class ClangNode {
   }
 
   const clang::Decl *castAsDecl() const {
-    return Ptr.get<Box<clang::Decl>>().value;
+    return cast<Box<clang::Decl>>(Ptr).value;
   }
   const clang::MacroInfo *castAsMacroInfo() const {
-    return Ptr.get<Box<clang::MacroInfo>>().value;
+    return cast<Box<clang::MacroInfo>>(Ptr).value;
   }
   const clang::ModuleMacro *castAsModuleMacro() const {
-    return Ptr.get<Box<clang::ModuleMacro>>().value;
+    return cast<Box<clang::ModuleMacro>>(Ptr).value;
   }
   const clang::Module *castAsModule() const {
-    return Ptr.get<Box<clang::Module>>().value;
+    return cast<Box<clang::Module>>(Ptr).value;
   }
 
   // Get the MacroInfo for a local definition, one imported from a

include/swift/AST/Decl.h

@@ -1021,7 +1021,7 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl>, public Swi
     if (auto dc = Context.dyn_cast<DeclContext *>())
       return dc->getASTContext();
 
-    return *Context.get<ASTContext *>();
+    return *cast<ASTContext *>(Context);
   }
 
   const DeclAttributes &getAttrs() const {

include/swift/AST/Identifier.h

@@ -573,7 +573,7 @@ class DeclName {
     if (auto compound = BaseNameOrCompound.dyn_cast<CompoundDeclName*>())
       return compound->BaseName;
 
-    return BaseNameOrCompound.get<DeclBaseName>();
+    return cast<DeclBaseName>(BaseNameOrCompound);
   }
 
   /// Assert that the base name is not special and return its identifier.
@@ -597,13 +597,11 @@ class DeclName {
   explicit operator bool() const {
     if (BaseNameOrCompound.dyn_cast<CompoundDeclName*>())
       return true;
-    return !BaseNameOrCompound.get<DeclBaseName>().empty();
+    return !cast<DeclBaseName>(BaseNameOrCompound).empty();
   }
 
   /// True if this is a simple one-component name.
-  bool isSimpleName() const {
-    return BaseNameOrCompound.is<DeclBaseName>();
-  }
+  bool isSimpleName() const { return isa<DeclBaseName>(BaseNameOrCompound); }
 
   /// True if this is a compound name.
   bool isCompoundName() const {

include/swift/AST/NameLookupRequests.h

@@ -651,7 +651,7 @@ class OperatorLookupDescriptor final {
   DeclContext *getDC() const {
     if (auto *module = getModule())
       return module;
-    return fileOrModule.get<FileUnit *>();
+    return cast<FileUnit *>(fileOrModule);
   }
 
   friend llvm::hash_code hash_value(const OperatorLookupDescriptor &desc) {

include/swift/AST/Pattern.h

@@ -617,10 +617,10 @@ class EnumElementPattern : public Pattern {
   }
 
   Expr *getUnresolvedOriginalExpr() const {
-    return ElementDeclOrUnresolvedOriginalExpr.get<Expr*>();
+    return cast<Expr *>(ElementDeclOrUnresolvedOriginalExpr);
   }
   bool hasUnresolvedOriginalExpr() const {
-    return ElementDeclOrUnresolvedOriginalExpr.is<Expr*>();
+    return isa<Expr *>(ElementDeclOrUnresolvedOriginalExpr);
   }
   void setUnresolvedOriginalExpr(Expr *e) {
     ElementDeclOrUnresolvedOriginalExpr = e;

include/swift/AST/ProtocolConformanceRef.h

@@ -120,28 +120,26 @@ class ProtocolConformanceRef {
                                             ProtocolDecl *protocol);
 
   bool isConcrete() const {
-    return !isInvalid() && Union.is<ProtocolConformance*>();
+    return !isInvalid() && isa<ProtocolConformance *>(Union);
   }
   ProtocolConformance *getConcrete() const {
     ASSERT(isConcrete());
-    return Union.get<ProtocolConformance*>();
+    return cast<ProtocolConformance *>(Union);
   }
 
-  bool isPack() const {
-    return !isInvalid() && Union.is<PackConformance*>();
-  }
+  bool isPack() const { return !isInvalid() && isa<PackConformance *>(Union); }
   PackConformance *getPack() const {
     ASSERT(isPack());
-    return Union.get<PackConformance*>();
+    return cast<PackConformance *>(Union);
   }
 
   bool isAbstract() const {
-    return !isInvalid() && Union.is<AbstractConformance*>();
+    return !isInvalid() && isa<AbstractConformance *>(Union);
   }
 
   AbstractConformance *getAbstract() const {
     ASSERT(isAbstract());
-    return Union.get<AbstractConformance *>();
+    return cast<AbstractConformance *>(Union);
   }
 
   /// Determine whether this conformance (or a conformance it depends on)