[Macros] Turn Macro into a declaration node.

Although the declaration of macros doesn't appear in Swift source code
that uses macros, they still operate as declarations within the
language. Rework `Macro` as `MacroDecl`, a generic value declaration,
which appropriate models its place in the language.

The vast majority of this change is in extending all of the various
switches on declaration kinds to account for macros.

Author: DougGregor

include/swift/AST/Decl.h

@@ -192,6 +192,7 @@ enum class DescriptiveDeclKind : uint8_t {
   Requirement,
   OpaqueResultType,
   OpaqueVarType,
+  Macro,
   MacroExpansion
 };
 
@@ -8270,6 +8271,68 @@ class MissingMemberDecl : public Decl {
   }
 };
 
+/// Provides a declaration of a macro.
+///
+/// Macros are defined externally via conformances to the 'Macro' type
+/// that is part of swift-syntax, and are introduced into the compiler via
+/// various mechanisms (built-in macros are linked in directly, plugin macros
+/// are introduced via compiler plugins, and so on). They have no explicit
+/// representation in the source code, but are still declarations.
+class MacroDecl : public GenericContext, public ValueDecl {
+public:
+  /// The kind of macro, which determines how it can be used in source code.
+  enum Kind: uint8_t {
+    /// An expression macro.
+    Expression,
+  };
+
+  /// Describes how the macro is implemented.
+  enum class ImplementationKind: uint8_t {
+    /// The macro is built-in to the compiler, linked against the same
+    /// underlying syntax tree libraries.
+    Builtin,
+
+    /// The macro was defined in a compiler plugin.
+    Plugin,
+  };
+
+  /// The kind of macro.
+  const Kind kind;
+
+  /// How the macro is implemented.
+  const ImplementationKind implementationKind;
+
+  /// Supplemental modules that should be imported when
+  const ArrayRef<ModuleDecl *> supplementalSignatureModules;
+
+  /// An opaque handle to the representation of the macro.
+  void * const opaqueHandle;
+
+public:
+  MacroDecl(
+    Kind kind, ImplementationKind implementationKind, Identifier name,
+    ModuleDecl *owningModule,
+    ArrayRef<ModuleDecl *> supplementalSignatureModules,
+    void *opaqueHandle
+  );
+
+  SourceRange getSourceRange() const;
+
+  static bool classof(const DeclContext *C) {
+    if (auto D = C->getAsDecl())
+      return classof(D);
+    return false;
+  }
+
+  static bool classof(const Decl *D) {
+    return D->getKind() == DeclKind::Macro;
+  }
+
+  using DeclContext::operator new;
+  using DeclContext::operator delete;
+  using Decl::getASTContext;
+};
+
 class MacroExpansionDecl : public Decl {
   SourceLoc PoundLoc;
   DeclNameRef Macro;

include/swift/AST/DeclContext.h

@@ -100,7 +100,8 @@ enum class DeclContextKind : unsigned {
   FileUnit,
   GenericTypeDecl,
   ExtensionDecl,
-  Last_DeclContextKind = ExtensionDecl
+  MacroDecl,
+  Last_DeclContextKind = MacroDecl
 };
 
 /// Kinds of DeclContexts after deserialization.
@@ -277,6 +278,7 @@ class alignas(1 << DeclContextAlignInBits) DeclContext
     case DeclContextKind::EnumElementDecl:
     case DeclContextKind::GenericTypeDecl:
     case DeclContextKind::ExtensionDecl:
+    case DeclContextKind::MacroDecl:
       return ASTHierarchy::Decl;
     }
     llvm_unreachable("Unhandled DeclContextKind");

include/swift/AST/DeclNodes.def

@@ -171,6 +171,7 @@ ABSTRACT_DECL(Value, Decl)
     ABSTRACT_FUNCTION_DECL(Func, AbstractFunctionDecl)
       ABSTRACT_FUNCTION_DECL(Accessor, FuncDecl)
     DECL_RANGE(AbstractFunction, Constructor, Accessor)
+  GENERIC_VALUE_DECL(Macro, ValueDecl)
   CONTEXT_VALUE_DECL(EnumElement, ValueDecl)
   DECL_RANGE(Value, Enum, EnumElement)
 

include/swift/AST/Macro.h

@@ -3738,16 +3738,16 @@ class SynthesizeHasSymbolQueryRequest
 /// module.
 class MacroLookupRequest
     : public SimpleRequest<MacroLookupRequest,
-                           ArrayRef<Macro *>(Identifier, ModuleDecl *),
+                           ArrayRef<MacroDecl *>(Identifier, ModuleDecl *),
                            RequestFlags::Cached> {
 public:
   using SimpleRequest::SimpleRequest;
 
 private:
   friend SimpleRequest;
 
-  ArrayRef<Macro *> evaluate(Evaluator &evaluator,
-                             Identifier macroName, ModuleDecl *mod) const;
+  ArrayRef<MacroDecl *> evaluate(Evaluator &evaluator,
+                                 Identifier macroName, ModuleDecl *mod) const;
 
 public:
   bool isCached() const { return true; }
@@ -3758,7 +3758,6 @@ void simple_display(llvm::raw_ostream &out, Type value);
 void simple_display(llvm::raw_ostream &out, const TypeRepr *TyR);
 void simple_display(llvm::raw_ostream &out, ImplicitMemberAction action);
 void simple_display(llvm::raw_ostream &out, ResultBuilderBodyPreCheck pck);
-void simple_display(llvm::raw_ostream &out, const Macro *macro);
 
 #define SWIFT_TYPEID_ZONE TypeChecker
 #define SWIFT_TYPEID_HEADER "swift/AST/TypeCheckerTypeIDZone.def"

include/swift/AST/TypeCheckRequests.h

@@ -41,6 +41,7 @@ class TypeMemberVisitor : public DeclVisitor<ImplClass, RetTy> {
   BAD_MEMBER(TopLevelCode)
   BAD_MEMBER(Operator)
   BAD_MEMBER(PrecedenceGroup)
+  BAD_MEMBER(Macro)
 
   // The children of these are automatically inserted into the
   // surrounding context.

include/swift/AST/TypeMemberVisitor.h

@@ -117,6 +117,7 @@ enum class CodeCompletionDeclKind : uint8_t {
   LocalVar,
   GlobalVar,
   PrecedenceGroup,
+  Macro,
 };
 
 enum class CodeCompletionLiteralKind : uint8_t {

include/swift/IDE/CodeCompletionResult.h

@@ -698,6 +698,8 @@ namespace {
         printGenericParameters(OS, AFD->getParsedGenericParams());
       if (auto *GTD = dyn_cast<GenericTypeDecl>(VD))
         printGenericParameters(OS, GTD->getParsedGenericParams());
+      if (auto *MD = dyn_cast<MacroDecl>(VD))
+        printGenericParameters(OS, MD->getParsedGenericParams());
 
       if (auto *var = dyn_cast<VarDecl>(VD)) {
         PrintWithColorRAII(OS, TypeColor) << " type='";
@@ -1307,6 +1309,11 @@ namespace {
       PrintWithColorRAII(OS, ParenthesisColor) << ')';
     }
 
+    void visitMacroDecl(MacroDecl *MD) {
+      printCommon(MD, "macro_decl");
+      PrintWithColorRAII(OS, ParenthesisColor) << ')';
+    }
+
     void visitMacroExpansionDecl(MacroExpansionDecl *MED) {
       printCommon(MED, "macro_expansion_decl ");
       OS << MED->getMacro();
@@ -1425,6 +1432,10 @@ void swift::printContext(raw_ostream &os, DeclContext *dc) {
   case DeclContextKind::EnumElementDecl:
     printName(os, cast<EnumElementDecl>(dc)->getName());
     break;
+
+  case DeclContextKind::MacroDecl:
+    printName(os, cast<MacroDecl>(dc)->getName());
+    break;
   }
 }
 

lib/AST/ASTDumper.cpp

@@ -2379,6 +2379,9 @@ void ASTMangler::appendContext(const DeclContext *ctx, StringRef useModuleName)
   case DeclContextKind::TopLevelCodeDecl:
     // Mangle the containing module context.
     return appendContext(ctx->getParent(), useModuleName);
+
+  case DeclContextKind::MacroDecl:
+    llvm_unreachable("macro declarations are never mangled");
   }
 
   llvm_unreachable("bad decl context");

lib/AST/ASTMangler.cpp

@@ -1895,6 +1895,10 @@ bool ShouldPrintChecker::shouldPrint(const Decl *D,
       return true;
   }
 
+  // Skip macros, which don't have an in-source representation.
+  if (isa<MacroDecl>(D))
+    return false;
+
   // Skip declarations that are not accessible.
   if (auto *VD = dyn_cast<ValueDecl>(D)) {
     if (Options.AccessFilter > AccessLevel::Private &&
@@ -4433,6 +4437,10 @@ void PrintAST::visitMissingMemberDecl(MissingMemberDecl *decl) {
   Printer << " */";
 }
 
+void PrintAST::visitMacroDecl(MacroDecl *decl) {
+  // No in-source representation of macros.
+}
+
 void PrintAST::visitMacroExpansionDecl(MacroExpansionDecl *decl) {
   Printer << '#' << decl->getMacro();
   if (decl->getArgs()) {