[Macros] Parse macro declarations fully, and treat them as normal declarations

Author: DougGregor

include/swift/AST/ASTScope.h

@@ -1187,6 +1187,35 @@ class EnumElementScope : public ASTScopeImpl {
   void expandAScopeThatDoesNotCreateANewInsertionPoint(ScopeCreator &);
 };
 
+class MacroDeclScope final : public ASTScopeImpl {
+public:
+  MacroDecl *const decl;
+
+  MacroDeclScope(MacroDecl *e) : decl(e) {}
+  virtual ~MacroDeclScope() {}
+
+protected:
+  ASTScopeImpl *expandSpecifically(ScopeCreator &scopeCreator) override;
+
+private:
+  void expandAScopeThatDoesNotCreateANewInsertionPoint(ScopeCreator &);
+
+public:
+  std::string getClassName() const override;
+  SourceRange
+  getSourceRangeOfThisASTNode(bool omitAssertions = false) const override;
+
+protected:
+  void printSpecifics(llvm::raw_ostream &out) const override;
+
+public:
+  virtual NullablePtr<Decl> getDeclIfAny() const override { return decl; }
+  Decl *getDecl() const { return decl; }
+
+protected:
+  NullablePtr<const GenericParamList> genericParams() const override;
+};
+
 class AbstractStmtScope : public ASTScopeImpl {
 public:
   SourceRange

include/swift/AST/Decl.h

@@ -8278,41 +8278,41 @@ class MissingMemberDecl : public Decl {
 /// 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,
-  };
+  /// The location of the 'macro' keyword.
+  SourceLoc macroLoc;
 
-  /// 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 parameter list for a function-like macro.
+  ParameterList *parameterList;
 
-    /// The macro was defined in a compiler plugin.
-    Plugin,
-  };
+  /// Where the '->' or ':' is located, for a function- or value-like macro,
+  /// respectively.
+  SourceLoc arrowOrColonLoc;
 
-  /// The kind of macro.
-  const Kind kind;
+  /// The result type.
+  TypeLoc resultType;
 
-  /// How the macro is implemented.
-  const ImplementationKind implementationKind;
+  /// The module name for the external macro definition.
+  Identifier externalModuleName;
 
-  /// Supplemental modules that should be imported when
-  const ArrayRef<ModuleDecl *> supplementalSignatureModules;
+  /// The location of the module name for the external macro definition.
+  SourceLoc externalModuleNameLoc;
 
-  /// An opaque handle to the representation of the macro.
-  void * const opaqueHandle;
+  /// The type name for the external macro definition.
+  Identifier externalMacroTypeName;
 
-public:
-  MacroDecl(
-    Kind kind, ImplementationKind implementationKind, Identifier name,
-    ModuleDecl *owningModule,
-    ArrayRef<ModuleDecl *> supplementalSignatureModules,
-    void *opaqueHandle
-  );
+  /// The location of the type name for the external macro definition.
+  SourceLoc externalMacroTypeNameLoc;
+
+  MacroDecl(SourceLoc macroLoc, DeclName name, SourceLoc nameLoc,
+            GenericParamList *genericParams,
+            ParameterList *parameterList,
+            SourceLoc arrowOrColonLoc,
+            TypeRepr *resultType,
+            Identifier externalModuleName,
+            SourceLoc externalModuleNameLoc,
+            Identifier externalMacroTypeName,
+            SourceLoc externalMacroTypeNameLoc,
+            DeclContext *parent);
 
   SourceRange getSourceRange() const;
 
@@ -8479,6 +8479,8 @@ inline bool ValueDecl::hasCurriedSelf() const {
 inline bool ValueDecl::hasParameterList() const {
   if (auto *eed = dyn_cast<EnumElementDecl>(this))
     return eed->hasAssociatedValues();
+  if (auto *macro = dyn_cast<MacroDecl>(this))
+    return macro->parameterList != nullptr;
   return isa<AbstractFunctionDecl>(this) || isa<SubscriptDecl>(this);
 }
 

include/swift/AST/DiagnosticsParse.def

@@ -2006,15 +2006,17 @@ ERROR(expected_macro_value_type,PointsToFirstBadToken,
 ERROR(no_default_arg_macro,none,
       "default arguments are not allowed in macros", ())
 ERROR(expected_lparen_macro,PointsToFirstBadToken,
-      "expected '(' for macro parameters or ':' for a value-like macro''", ())
-ERROR(macro_decl_expected_arrow,none,
-      "expected '->' after macro parameter list", ())
+      "expected '(' for macro parameters or ':' for a value-like macro", ())
 ERROR(expected_type_macro_result,PointsToFirstBadToken,
       "expected macro result type", ())
-ERROR(macro_decl_expected_equal,none,
+ERROR(macro_decl_expected_equal,PointsToFirstBadToken,
       "expected '=' to introduce external macro name", ())
-ERROR(macro_decl_expected_period,none,
+ERROR(macro_decl_expected_macro_module,PointsToFirstBadToken,
+      "expected external macro name", ())
+ERROR(macro_decl_expected_period,PointsToFirstBadToken,
       "expected '.' between external macro module and type name", ())
+ERROR(macro_decl_expected_macro_type,PointsToFirstBadToken,
+      "expected external macro type name", ())
 
 ERROR(macro_expansion_expr_expected_macro_identifier,none,
       "expected a macro identifier for a pound literal expression", ())

include/swift/AST/Expr.h

@@ -6021,6 +6021,9 @@ class MacroExpansionExpr final : public Expr {
   ArgumentList *ArgList;
   Expr *Rewritten;
 
+  /// The referenced macro.
+  ConcreteDeclRef macroRef;
+
 public:
   explicit MacroExpansionExpr(SourceLoc poundLoc, DeclNameRef macroName,
                               DeclNameLoc macroNameLoc,
@@ -6053,6 +6056,9 @@ class MacroExpansionExpr final : public Expr {
 
   SourceLoc getLoc() const { return PoundLoc; }
 
+  ConcreteDeclRef getMacroRef() const { return macroRef; }
+  void setMacroRef(ConcreteDeclRef ref) { macroRef = ref; }
+
   SourceRange getSourceRange() const;
 
   static bool classof(const Expr *E) {

include/swift/AST/MacroDefinition.h

@@ -0,0 +1,97 @@
+//===--- MacroDefinition.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 provides the definition of a macro, which gives access to its
+// implementation.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_AST_MACRO_DEFINITION_H
+#define SWIFT_AST_MACRO_DEFINITION_H
+
+#include "llvm/ADT/PointerUnion.h"
+
+namespace swift {
+
+class CompilerPlugin;
+
+/// Provides the definition of a macro.
+struct MacroDefinition {
+    /// 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,
+  };
+
+public:
+  Kind kind;
+  ImplementationKind implKind;
+
+private:
+  void *opaqueHandle;
+
+  MacroDefinition(Kind kind, ImplementationKind implKind, void *opaqueHandle)
+    : kind(kind), implKind(implKind), opaqueHandle(opaqueHandle) { }
+
+public:
+  static MacroDefinition forInvalid() {
+    return MacroDefinition{
+      Kind::Expression, ImplementationKind::Builtin, nullptr
+    };
+  }
+
+  static MacroDefinition forBuiltin(Kind kind, void *opaqueHandle) {
+    return MacroDefinition{kind, ImplementationKind::Builtin, opaqueHandle};
+  }
+
+  static MacroDefinition forCompilerPlugin(Kind kind, CompilerPlugin *plugin) {
+    return MacroDefinition{kind, ImplementationKind::Plugin, plugin};
+  }
+
+  bool isInvalid() const { return opaqueHandle == nullptr; }
+
+  explicit operator bool() const { return !isInvalid(); }
+
+  void *getAsBuiltin() const {
+    switch (implKind) {
+    case ImplementationKind::Builtin:
+      return opaqueHandle;
+
+    case ImplementationKind::Plugin:
+      return nullptr;
+    }
+  }
+
+  CompilerPlugin *getAsCompilerPlugin() const {
+    switch (implKind) {
+    case ImplementationKind::Builtin:
+      return nullptr;
+
+    case ImplementationKind::Plugin:
+      return (CompilerPlugin *)opaqueHandle;
+    }
+  }
+};
+
+}
+
+#endif // SWIFT_AST_MACRO_DEFINITION_H

include/swift/AST/TypeCheckRequests.h

@@ -45,7 +45,7 @@ class DefaultArgumentExpr;
 class DefaultArgumentType;
 class ClosureExpr;
 class GenericParamList;
-class Macro;
+struct MacroDefinition;
 class PrecedenceGroupDecl;
 class PropertyWrapperInitializerInfo;
 struct PropertyWrapperLValueness;
@@ -3715,22 +3715,23 @@ class GetTypeWrapperInitializer
   bool isCached() const { return true; }
 };
 
-/// Lookup all macros with the given name that are visible from the given
-/// module.
-class MacroLookupRequest
-    : public SimpleRequest<MacroLookupRequest,
-                           ArrayRef<MacroDecl *>(Identifier, ModuleDecl *),
+/// Find the definition of a given macro.
+class MacroDefinitionRequest
+    : public SimpleRequest<MacroDefinitionRequest,
+                           MacroDefinition(MacroDecl *),
                            RequestFlags::Cached> {
 public:
   using SimpleRequest::SimpleRequest;
 
 private:
   friend SimpleRequest;
 
-  ArrayRef<MacroDecl *> evaluate(Evaluator &evaluator,
-                                 Identifier macroName, ModuleDecl *mod) const;
+  MacroDefinition evaluate(Evaluator &evaluator, MacroDecl *macro) const;
 
 public:
+  // Source location
+  SourceLoc getNearestLoc() const;
+
   bool isCached() const { return true; }
 };
 

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -437,6 +437,6 @@ SWIFT_REQUEST(TypeChecker, SynthesizeLocalVariableForTypeWrapperStorage,
 SWIFT_REQUEST(TypeChecker, GetTypeWrapperInitializer,
               ConstructorDecl *(NominalTypeDecl *),
               Cached, NoLocationInfo)
-SWIFT_REQUEST(TypeChecker, MacroLookupRequest,
-              ArrayRef<Macro *>(Identifier, ModuleDecl *),
+SWIFT_REQUEST(TypeChecker, MacroDefinitionRequest,
+              MacroDefinition(MacroDecl *),
               Cached, NoLocationInfo)

lib/AST/ASTScope.cpp

@@ -150,6 +150,7 @@ DEFINE_GET_CLASS_NAME(SpecializeAttributeScope)
 DEFINE_GET_CLASS_NAME(DifferentiableAttributeScope)
 DEFINE_GET_CLASS_NAME(SubscriptDeclScope)
 DEFINE_GET_CLASS_NAME(EnumElementScope)
+DEFINE_GET_CLASS_NAME(MacroDeclScope)
 DEFINE_GET_CLASS_NAME(IfStmtScope)
 DEFINE_GET_CLASS_NAME(WhileStmtScope)
 DEFINE_GET_CLASS_NAME(GuardStmtScope)

lib/AST/ASTScopeCreation.cpp

@@ -289,7 +289,6 @@ class NodeAdder
   VISIT_AND_IGNORE(ParamDecl)
   VISIT_AND_IGNORE(PoundDiagnosticDecl)
   VISIT_AND_IGNORE(MissingMemberDecl)
-  VISIT_AND_IGNORE(MacroDecl)
   VISIT_AND_IGNORE(MacroExpansionDecl)
 
   // Only members of the active clause are in scope, and those
@@ -325,6 +324,7 @@ class NodeAdder
   VISIT_AND_CREATE(ForEachStmt, ForEachStmtScope)
   VISIT_AND_CREATE(CaseStmt, CaseStmtScope)
   VISIT_AND_CREATE(AbstractFunctionDecl, AbstractFunctionDeclScope)
+  VISIT_AND_CREATE(MacroDecl, MacroDeclScope)
 
 #undef VISIT_AND_CREATE
 
@@ -682,6 +682,7 @@ NO_NEW_INSERTION_POINT(ForEachStmtScope)
 NO_NEW_INSERTION_POINT(IfStmtScope)
 NO_NEW_INSERTION_POINT(RepeatWhileScope)
 NO_NEW_INSERTION_POINT(SubscriptDeclScope)
+NO_NEW_INSERTION_POINT(MacroDeclScope)
 NO_NEW_INSERTION_POINT(SwitchStmtScope)
 NO_NEW_INSERTION_POINT(WhileStmtScope)
 
@@ -1068,6 +1069,17 @@ void SubscriptDeclScope::expandAScopeThatDoesNotCreateANewInsertionPoint(
   scopeCreator.addChildrenForParsedAccessors(decl, leaf);
 }
 
+void MacroDeclScope::expandAScopeThatDoesNotCreateANewInsertionPoint(
+    ScopeCreator &scopeCreator) {
+  scopeCreator.addChildrenForKnownAttributes(decl, this);
+  auto *leaf = scopeCreator.addNestedGenericParamScopesToTree(
+      decl, getPotentiallyOpaqueGenericParams(decl), this);
+  if (decl->parameterList) {
+    scopeCreator.constructExpandAndInsert<ParameterListScope>(
+        leaf, decl->parameterList, nullptr);
+  }
+}
+
 void CaptureListScope::expandAScopeThatDoesNotCreateANewInsertionPoint(
     ScopeCreator &scopeCreator) {
   auto *closureExpr = expr->getClosureBody();

lib/AST/ASTScopeLookup.cpp

@@ -189,6 +189,9 @@ NullablePtr<const GenericParamList> GenericTypeScope::genericParams() const {
 NullablePtr<const GenericParamList> ExtensionScope::genericParams() const {
   return decl->getGenericParams();
 }
+NullablePtr<const GenericParamList> MacroDeclScope::genericParams() const {
+  return decl->getParsedGenericParams();
+}
 
 #pragma mark lookInMyGenericParameters
 

lib/AST/ASTScopePrinting.cpp

@@ -178,6 +178,10 @@ void SubscriptDeclScope::printSpecifics(llvm::raw_ostream &out) const {
   decl->dumpRef(out);
 }
 
+void MacroDeclScope::printSpecifics(llvm::raw_ostream &out) const {
+  decl->dumpRef(out);
+}
+
 void ConditionalClausePatternUseScope::printSpecifics(
     llvm::raw_ostream &out) const {
   sec.getPattern()->print(out);

lib/AST/ASTScopeSourceRange.cpp

@@ -122,6 +122,11 @@ SourceRange SubscriptDeclScope::getSourceRangeOfThisASTNode(
   return decl->getSourceRangeIncludingAttrs();
 }
 
+SourceRange MacroDeclScope::getSourceRangeOfThisASTNode(
+    const bool omitAssertions) const {
+  return decl->getSourceRangeIncludingAttrs();
+}
+
 SourceRange
 EnumElementScope::getSourceRangeOfThisASTNode(const bool omitAssertions) const {
   return decl->getSourceRange();