[NFC] Factor out DiagnosticArgument into a new file

Author: AnthonyLatsis

Diff for: include/swift/AST/DiagnosticArgument.h

@@ -0,0 +1,208 @@
+//===--- DiagnosticArgument.h -----------------------------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2025 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_AST_DIAGNOSTIC_ARGUMENT_H
+#define SWIFT_AST_DIAGNOSTIC_ARGUMENT_H
+
+#include "swift/AST/ActorIsolation.h"
+#include "swift/AST/AvailabilityDomain.h"
+#include "swift/AST/DiagnosticConsumer.h"
+#include "swift/AST/Identifier.h"
+#include "swift/AST/LayoutConstraint.h"
+#include "swift/AST/TypeLoc.h"
+#include "swift/Basic/Version.h"
+#include "llvm/Support/VersionTuple.h"
+
+namespace clang {
+class NamedDecl;
+class Type;
+} // namespace clang
+
+namespace swift {
+
+class Decl;
+class DeclAttribute;
+class TypeRepr;
+
+enum class DescriptivePatternKind : uint8_t;
+enum class DescriptiveDeclKind : uint8_t;
+enum class ReferenceOwnership : uint8_t;
+enum class SelfAccessKind : uint8_t;
+enum class StaticSpellingKind : uint8_t;
+enum class StmtKind;
+
+/// A family of wrapper types for compiler data types that forces its
+/// underlying data to be formatted with full qualification.
+///
+/// So far, this is only useful for \c Type, hence the SFINAE'ing.
+template <typename T, typename = void>
+struct FullyQualified {};
+
+template <typename T>
+struct FullyQualified<
+    T, typename std::enable_if<std::is_convertible<T, Type>::value>::type> {
+  Type t;
+
+public:
+  FullyQualified(T t) : t(t) {};
+
+  Type getType() const { return t; }
+};
+
+struct WitnessType {
+  Type t;
+
+  WitnessType(Type t) : t(t) {}
+
+  Type getType() { return t; }
+};
+
+/// Describes the kind of diagnostic argument we're storing.
+enum class DiagnosticArgumentKind {
+  String,
+  Integer,
+  Unsigned,
+  Identifier,
+  ObjCSelector,
+  Decl,
+  Type,
+  TypeRepr,
+  FullyQualifiedType,
+  WitnessType,
+  DescriptivePatternKind,
+  SelfAccessKind,
+  ReferenceOwnership,
+  StaticSpellingKind,
+  DescriptiveDeclKind,
+  DescriptiveStmtKind,
+  DeclAttribute,
+  AvailabilityDomain,
+  AvailabilityRange,
+  VersionTuple,
+  LayoutConstraint,
+  ActorIsolation,
+  IsolationSource,
+  Diagnostic,
+  ClangDecl,
+  ClangType,
+};
+
+/// Variant type that holds a single diagnostic argument of a known
+/// type.
+///
+/// All diagnostic arguments are converted to an instance of this class.
+class DiagnosticArgument {
+  DiagnosticArgumentKind Kind;
+  union {
+    int IntegerVal;
+    unsigned UnsignedVal;
+    StringRef StringVal;
+    DeclNameRef IdentifierVal;
+    ObjCSelector ObjCSelectorVal;
+    const Decl *TheDecl;
+    Type TypeVal;
+    TypeRepr *TyR;
+    FullyQualified<Type> FullyQualifiedTypeVal;
+    WitnessType WitnessTypeVal;
+    DescriptivePatternKind DescriptivePatternKindVal;
+    SelfAccessKind SelfAccessKindVal;
+    ReferenceOwnership ReferenceOwnershipVal;
+    StaticSpellingKind StaticSpellingKindVal;
+    DescriptiveDeclKind DescriptiveDeclKindVal;
+    StmtKind DescriptiveStmtKindVal;
+    const DeclAttribute *DeclAttributeVal;
+    AvailabilityDomain AvailabilityDomainVal;
+    AvailabilityRange AvailabilityRangeVal;
+    llvm::VersionTuple VersionVal;
+    LayoutConstraint LayoutConstraintVal;
+    ActorIsolation ActorIsolationVal;
+    IsolationSource IsolationSourceVal;
+    DiagnosticInfo *DiagnosticVal;
+    const clang::NamedDecl *ClangDecl;
+    const clang::Type *ClangType;
+  };
+
+public:
+  DiagnosticArgument(StringRef S);
+  DiagnosticArgument(int I);
+  DiagnosticArgument(unsigned I);
+  DiagnosticArgument(DeclNameRef R);
+  DiagnosticArgument(DeclName D);
+  DiagnosticArgument(DeclBaseName D);
+  DiagnosticArgument(Identifier I);
+  DiagnosticArgument(ObjCSelector S);
+  DiagnosticArgument(const Decl *VD);
+  DiagnosticArgument(Type T);
+  DiagnosticArgument(TypeRepr *T);
+  DiagnosticArgument(FullyQualified<Type> FQT);
+  DiagnosticArgument(WitnessType WT);
+  DiagnosticArgument(const TypeLoc &TL);
+  DiagnosticArgument(DescriptivePatternKind DPK);
+  DiagnosticArgument(ReferenceOwnership RO);
+  DiagnosticArgument(SelfAccessKind SAK);
+  DiagnosticArgument(StaticSpellingKind SSK);
+  DiagnosticArgument(DescriptiveDeclKind DDK);
+  DiagnosticArgument(StmtKind SK);
+  DiagnosticArgument(const DeclAttribute *attr);
+  DiagnosticArgument(const AvailabilityDomain domain);
+  DiagnosticArgument(const AvailabilityRange &range);
+  DiagnosticArgument(llvm::VersionTuple version);
+  DiagnosticArgument(LayoutConstraint L);
+  DiagnosticArgument(ActorIsolation AI);
+  DiagnosticArgument(IsolationSource IS);
+  DiagnosticArgument(DiagnosticInfo *D);
+  DiagnosticArgument(const clang::NamedDecl *ND);
+  DiagnosticArgument(const clang::Type *Ty);
+
+  /// Initializes a diagnostic argument using the underlying type of the
+  /// given enum.
+  template <
+      typename EnumType,
+      typename std::enable_if<std::is_enum<EnumType>::value>::type * = nullptr>
+  DiagnosticArgument(EnumType value)
+      : DiagnosticArgument(
+            static_cast<typename std::underlying_type<EnumType>::type>(value)) {
+  }
+
+  DiagnosticArgumentKind getKind() const;
+
+  StringRef getAsString() const;
+  int getAsInteger() const;
+  unsigned getAsUnsigned() const;
+  DeclNameRef getAsIdentifier() const;
+  ObjCSelector getAsObjCSelector() const;
+  const Decl *getAsDecl() const;
+  Type getAsType() const;
+  TypeRepr *getAsTypeRepr() const;
+  FullyQualified<Type> getAsFullyQualifiedType() const;
+  WitnessType getAsWitnessType() const;
+  DescriptivePatternKind getAsDescriptivePatternKind() const;
+  ReferenceOwnership getAsReferenceOwnership() const;
+  SelfAccessKind getAsSelfAccessKind() const;
+  StaticSpellingKind getAsStaticSpellingKind() const;
+  DescriptiveDeclKind getAsDescriptiveDeclKind() const;
+  StmtKind getAsDescriptiveStmtKind() const;
+  const DeclAttribute *getAsDeclAttribute() const;
+  const AvailabilityDomain getAsAvailabilityDomain() const;
+  const AvailabilityRange getAsAvailabilityRange() const;
+  llvm::VersionTuple getAsVersionTuple() const;
+  LayoutConstraint getAsLayoutConstraint() const;
+  ActorIsolation getAsActorIsolation() const;
+  IsolationSource getAsIsolationSource() const;
+  DiagnosticInfo *getAsDiagnostic() const;
+  const clang::NamedDecl *getAsClangDecl() const;
+  const clang::Type *getAsClangType() const;
+};
+
+} // namespace swift
+
+#endif /* SWIFT_AST_DIAGNOSTIC_ARGUMENT_H */