Merge pull request #62086 from DougGregor/macro-decl

Author: DougGregor

include/swift/AST/ASTContext.h

@@ -352,12 +352,6 @@ class ASTContext final {
       llvm::SmallPtrSet<DerivativeAttr *, 1>>
       DerivativeAttrs;
 
-  /// Cache of compiler plugins keyed by their name.
-  llvm::StringMap<CompilerPlugin> LoadedPlugins;
-
-  /// Cache of loaded symbols.
-  llvm::StringMap<void *> LoadedSymbols;
-
 private:
   /// The current generation number, which reflects the number of
   /// times that external modules have been loaded.
@@ -1452,8 +1446,11 @@ class ASTContext final {
   /// The declared interface type of Builtin.TheTupleType.
   BuiltinTupleType *getBuiltinTupleType();
 
-  /// Finds the loaded compiler plugin given its name.
-  CompilerPlugin *getLoadedPlugin(StringRef name);
+  /// Finds the loaded compiler plugins with the given name.
+  TinyPtrVector<CompilerPlugin *> getLoadedPlugins(StringRef name);
+
+  /// Add a loaded plugin with the given name.
+  void addLoadedPlugin(StringRef name, CompilerPlugin *plugin);
 
   /// Finds the address of the given symbol. If `libraryHandleHint` is non-null,
   /// search within the library.

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

@@ -4906,14 +4906,6 @@ class ConstraintSystem {
                           ConstraintLocator *locator,
                           OpenedTypeMap *replacements = nullptr);
 
-#if SWIFT_SWIFT_PARSER
-  /// Retrieve the opened type of a macro with the given name.
-  ///
-  /// \returns The opened type of the macro with this name, or the null \c Type
-  /// if no such macro exists.
-  Type getTypeOfMacroReference(Identifier macroName, Expr *anchor);
-#endif
-
   /// Retrieve a list of generic parameter types solver has "opened" (replaced
   /// with a type variable) at the given location.
   ArrayRef<OpenedType> getOpenedTypes(ConstraintLocator *locator) const {

include/swift/Sema/ConstraintSystem.h

@@ -515,6 +515,15 @@ struct ASTContext::Implementation {
 
   llvm::StringMap<OptionSet<SearchPathKind>> SearchPathsSet;
 
+  /// Cache of compiler plugins keyed by their name.
+  ///
+  /// Names can be overloaded, so there can be multiple plugins with the same
+  /// name.
+  llvm::StringMap<TinyPtrVector<CompilerPlugin*>> LoadedPlugins;
+
+  /// Cache of loaded symbols.
+  llvm::StringMap<void *> LoadedSymbols;
+
   /// The permanent arena.
   Arena Permanent;
 
@@ -579,6 +588,12 @@ ASTContext::Implementation::Implementation()
 ASTContext::Implementation::~Implementation() {
   for (auto &cleanup : Cleanups)
     cleanup();
+
+  for (const auto &pluginsByName : LoadedPlugins) {
+    for (auto plugin : pluginsByName.second) {
+      delete plugin;
+    }
+  }
 }
 
 ConstraintCheckerArenaRAII::
@@ -6047,16 +6062,21 @@ BuiltinTupleType *ASTContext::getBuiltinTupleType() {
   return result;
 }
 
-CompilerPlugin *ASTContext::getLoadedPlugin(StringRef name) {
-  auto lookup = LoadedPlugins.find(name);
-  if (lookup == LoadedPlugins.end())
-    return nullptr;
-  return &lookup->second;
+TinyPtrVector<CompilerPlugin *> ASTContext::getLoadedPlugins(StringRef name) {
+  auto &loadedPlugins = getImpl().LoadedPlugins;
+  auto lookup = loadedPlugins.find(name);
+  if (lookup == loadedPlugins.end())
+    return { };
+  return lookup->second;
+}
+
+void ASTContext::addLoadedPlugin(StringRef name, CompilerPlugin *plugin) {
+  getImpl().LoadedPlugins[name].push_back(plugin);
 }
 
 void *ASTContext::getAddressOfSymbol(const char *name,
                                      void *libraryHandleHint) {
-  auto lookup = LoadedSymbols.try_emplace(name, nullptr);
+  auto lookup = getImpl().LoadedSymbols.try_emplace(name, nullptr);
   void *&address = lookup.first->getValue();
 #if !defined(_WIN32)
   if (lookup.second) {