Introduce a Macro AST type and use it to describe the macros we find

Author: DougGregor

include/swift/AST/Macro.h

@@ -0,0 +1,93 @@
+//===--- Macro.h - Swift Macro Definition -----------------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2020 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the `Macro` type that describes a macro definition.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_AST_MACRO_H
+#define SWIFT_AST_MACRO_H
+
+#include "swift/AST/ASTAllocated.h"
+#include "swift/AST/GenericSignature.h"
+#include "swift/AST/Identifier.h"
+#include "swift/AST/Type.h"
+
+namespace swift {
+  class ModuleDecl;
+
+  class Macro : public ASTAllocated<Macro> {
+  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;
+    
+    /// The name of the macro in the source, e.g., "stringify".
+    const Identifier name;
+
+    /// The generic signature, used to describe the signature of macros that
+    /// involve generic parameters.
+    const GenericSignature genericSignature;
+
+    /// The type signature of the macro.
+    const Type signature;
+
+    /// Documentation for the macro.
+    const StringRef documentation;
+
+    /// The module with which this macro is associated.
+    ModuleDecl * const owningModule;
+
+    /// Supplemental modules that should be imported when 
+    const ArrayRef<ModuleDecl *> supplementalSignatureModules;
+
+    /// An opaque handle to the representation of the macro.
+    void * const opaqueHandle;
+
+  public:
+    Macro(
+      Kind kind, ImplementationKind implementationKind, Identifier name,
+      GenericSignature genericSignature, Type signature,
+      StringRef documentation, ModuleDecl *owningModule,
+      ArrayRef<ModuleDecl *> supplementalSignatureModules,
+      void *opaqueHandle
+    ) : kind(kind), implementationKind(implementationKind), name(name),
+        genericSignature(genericSignature), signature(signature),
+        documentation(documentation), owningModule(owningModule),
+        supplementalSignatureModules(supplementalSignatureModules),
+        opaqueHandle(opaqueHandle) { }
+    
+    /// Whether this is a "function-like" macro, meaning that it's expected
+    /// to have function call arguments.
+    bool isFunctionLike() const;
+  };
+}
+
+#endif // SWIFT_AST_MACRO_H

include/swift/AST/TypeCheckRequests.h

@@ -45,6 +45,7 @@ class DefaultArgumentExpr;
 class DefaultArgumentType;
 class ClosureExpr;
 class GenericParamList;
+class Macro;
 class PrecedenceGroupDecl;
 class PropertyWrapperInitializerInfo;
 struct PropertyWrapperLValueness;
@@ -3733,35 +3734,20 @@ class SynthesizeHasSymbolQueryRequest
   bool isCached() const { return true; }
 };
 
-
-/// Retrieves the evaluation context of a macro with the given name.
-///
-/// The macro evaluation context is a user-defined generic signature and return
-/// type that serves as the "interface type" of references to the macro. The
-/// current implementation takes those pieces of syntax from the macro itself,
-/// then inserts them into a Swift struct that looks like
-///
-/// \code
-/// struct __MacroEvaluationContext\(macro.genericSignature) {
-///   typealias SignatureType = \(macro.signature)
-/// }
-/// \endcode
-///
-/// So that we can use all of Swift's native name lookup and type resolution
-/// facilities to map the parsed signature type back into a semantic \c Type
-/// AST and a set of requiremnets.
-class MacroContextRequest
-    : public SimpleRequest<MacroContextRequest,
-                           StructDecl *(std::string, ModuleDecl *),
+/// Lookup all macros with the given name that are visible from the given
+/// module.
+class MacroLookupRequest
+    : public SimpleRequest<MacroLookupRequest,
+                           ArrayRef<Macro *>(Identifier, ModuleDecl *),
                            RequestFlags::Cached> {
 public:
   using SimpleRequest::SimpleRequest;
 
 private:
   friend SimpleRequest;
 
-  StructDecl *evaluate(Evaluator &evaluator,
-                       std::string macroName, ModuleDecl *mod) const;
+  ArrayRef<Macro *> evaluate(Evaluator &evaluator,
+                             Identifier macroName, ModuleDecl *mod) const;
 
 public:
   bool isCached() const { return true; }
@@ -3772,6 +3758,7 @@ 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/TypeCheckerTypeIDZone.def

@@ -440,6 +440,6 @@ SWIFT_REQUEST(TypeChecker, GetTypeWrapperInitializer,
 SWIFT_REQUEST(TypeChecker, SynthesizeHasSymbolQueryRequest,
               FuncDecl *(ValueDecl *),
               Cached, NoLocationInfo)
-SWIFT_REQUEST(TypeChecker, MacroContextRequest,
-              StructDecl *(std::string, ModuleDecl *),
+SWIFT_REQUEST(TypeChecker, MacroLookupRequest,
+              ArrayRef<Macro *>(Identifier, ModuleDecl *),
               Cached, NoLocationInfo)

include/swift/Sema/ConstraintSystem.h

@@ -4911,7 +4911,7 @@ class ConstraintSystem {
   ///
   /// \returns The opened type of the macro with this name, or the null \c Type
   /// if no such macro exists.
-  Type getTypeOfMacroReference(StringRef macro, Expr *anchor);
+  Type getTypeOfMacroReference(Identifier macroName, Expr *anchor);
 #endif
 
   /// Retrieve a list of generic parameter types solver has "opened" (replaced

lib/ASTGen/Sources/ASTGen/Macros.swift

@@ -1,3 +1,4 @@
+import SwiftParser
 import SwiftSyntax
 @_spi(Testing) import _SwiftSyntaxMacros
 
@@ -104,20 +105,35 @@ extension ExportedMacro {
   }
 }
 
-/// Query the macro evaluation context of the given macro.
+/// Query the macro evaluation context given the evaluation
+/// context sources.
 @_cdecl("swift_ASTGen_getMacroEvaluationContext")
 public func getMacroEvaluationContext(
   sourceFilePtr: UnsafePointer<UInt8>,
   declContext: UnsafeMutableRawPointer,
   context: UnsafeMutableRawPointer,
-  macroPtr: UnsafeMutablePointer<UInt8>,
-  contextPtr: UnsafeMutablePointer<UnsafeMutableRawPointer?>
-) {
-  contextPtr.pointee = macroPtr.withMemoryRebound(to: ExportedMacro.self, capacity: 1) { macro in
-    return ASTGenVisitor(ctx: context, base: sourceFilePtr, declContext: declContext)
-      .visit(StructDeclSyntax(stringLiteral: macro.pointee.evaluationContext))
-      .rawValue
+  evaluatedSourceBuffer: UnsafePointer<UInt8>,
+  evaluatedSourceBufferLength: Int
+) -> UnsafeMutableRawPointer? {
+  let evaluatedSource = UnsafeBufferPointer(
+      start: evaluatedSourceBuffer,
+      count: evaluatedSourceBufferLength
+  )
+  let sourceFile = Parser.parse(source: evaluatedSource)
+
+  // Dig out the top-level struct declaration. That's all we'll
+  // parse.
+  guard let structDecl = sourceFile.statements.first(
+    where: { item in item.item.is(StructDeclSyntax.self)
+    })?.item.as(StructDeclSyntax.self) else {
+    return nil
   }
+
+  // Parse and ASTGen that top-level declaration.
+  // FIXME: we need to emit diagnostics from this.
+  return ASTGenVisitor(
+    ctx: context, base: sourceFilePtr, declContext: declContext
+  ).visit(structDecl).rawValue
 }
 
 @_cdecl("swift_ASTGen_evaluateMacro")

lib/Sema/CSGen.cpp

@@ -1200,7 +1200,8 @@ namespace {
         if (!protocol)
           return Type();
 
-        auto openedType = CS.getTypeOfMacroReference(kind, expr);
+        auto openedType = CS.getTypeOfMacroReference(
+            ctx.getIdentifier(kind), expr);
         if (!openedType)
           return Type();
 
@@ -3633,7 +3634,7 @@ namespace {
       auto &ctx = CS.getASTContext();
       if (ctx.LangOpts.hasFeature(Feature::Macros)) {
         auto macroIdent = expr->getMacroName().getBaseIdentifier();
-        auto refType = CS.getTypeOfMacroReference(macroIdent.str(), expr);
+        auto refType = CS.getTypeOfMacroReference(macroIdent, expr);
         if (!refType) {
           ctx.Diags.diagnose(expr->getMacroNameLoc(), diag::macro_undefined,
                              macroIdent)

lib/Sema/ConstraintSystem.cpp

@@ -24,6 +24,7 @@
 #include "TypeChecker.h"
 #include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/Initializer.h"
+#include "swift/AST/Macro.h"
 #include "swift/AST/ParameterList.h"
 #include "swift/AST/ProtocolConformance.h"
 #include "swift/AST/TypeCheckRequests.h"
@@ -2472,25 +2473,22 @@ ConstraintSystem::getTypeOfMemberReference(
 }
 
 #if SWIFT_SWIFT_PARSER
-Type ConstraintSystem::getTypeOfMacroReference(StringRef macroName,
+Type ConstraintSystem::getTypeOfMacroReference(Identifier macroName,
                                                Expr *anchor) {
-  auto req = MacroContextRequest{macroName.str(), DC->getParentModule()};
-  auto *macroCtx = evaluateOrDefault(getASTContext().evaluator, req, nullptr);
-  if (!macroCtx)
+  auto req = MacroLookupRequest{macroName, DC->getParentModule()};
+  auto macros = evaluateOrDefault(getASTContext().evaluator, req, { });
+  if (macros.empty())
     return Type();
 
-  auto *locator = getConstraintLocator(anchor);
-  // Dig through to __MacroEvaluationContext.SignatureType
-  auto sig = getASTContext().getIdentifier("SignatureType");
-  auto *signature = cast<TypeAliasDecl>(macroCtx->lookupDirect(sig).front());
-  auto type = signature->getUnderlyingType();
+  // FIXME: Handle macro overloading.
+  auto macro = macros.front();
 
   // Open any the generic types.
   OpenedTypeMap replacements;
-  openGeneric(signature->getParent(), signature->getGenericSignature(),
-              locator, replacements);
+  openGeneric(macro->owningModule, macro->genericSignature,
+              getConstraintLocator(anchor), replacements);
 
-  return openType(type, replacements);
+  return openType(macro->signature, replacements);
 }
 #endif