Merge pull request #61783 from DougGregor/macro-type-checking

Author: DougGregor

include/swift/AST/CASTBridging.h

@@ -14,6 +14,7 @@
 #define SWIFT_C_AST_ASTBRIDGING_H
 
 #include <inttypes.h>
+#include "swift/Basic/Compiler.h"
 
 #if __clang__
 // Provide macros to temporarily suppress warning about the use of
@@ -48,6 +49,43 @@ typedef struct {
 
 typedef void *BridgedIdentifier;
 
+typedef struct {
+  BridgedIdentifier _Nullable Name;
+  void *_Nullable NameLoc;
+  BridgedIdentifier _Nullable SecondName;
+  void *_Nullable SecondNameLoc;
+  void *_Nullable UnderscoreLoc;
+  void *_Nullable ColonLoc;
+  void *Type;
+  void *_Nullable TrailingCommaLoc;
+} BridgedTupleTypeElement;
+
+typedef enum ENUM_EXTENSIBILITY_ATTR(open) BridgedRequirementReprKind : long {
+  /// A type bound T : P, where T is a type that depends on a generic
+  /// parameter and P is some type that should bound T, either as a concrete
+  /// supertype or a protocol to which T must conform.
+  BridgedRequirementReprKindTypeConstraint,
+
+  /// A same-type requirement T == U, where T and U are types that shall be
+  /// equivalent.
+  BridgedRequirementReprKindSameType,
+
+  /// A layout bound T : L, where T is a type that depends on a generic
+  /// parameter and L is some layout specification that should bound T.
+  BridgedRequirementReprKindLayoutConstraint,
+
+  // Note: there is code that packs this enum in a 2-bit bitfield.  Audit users
+  // when adding enumerators.
+} BridgedRequirementReprKind;
+
+typedef struct {
+  void *_Nullable SeparatorLoc;
+  BridgedRequirementReprKind Kind;
+  void *FirstType;
+  void *SecondType;
+  // FIXME: Handle Layout Requirements
+} BridgedRequirementRepr;
+
 #ifdef __cplusplus
 extern "C" {
 
@@ -123,10 +161,33 @@ struct DeclContextAndDecl {
 };
 
 struct DeclContextAndDecl StructDecl_create(
-    void *ctx, void *loc, BridgedIdentifier name, void *nameLoc, void *dc);
+    void *ctx, void *loc, BridgedIdentifier name, void *nameLoc, void *_Nullable genericParams, void *dc);
 struct DeclContextAndDecl ClassDecl_create(
     void *ctx, void *loc, BridgedIdentifier name, void *nameLoc, void *dc);
 
+void *ArrayTypeRepr_create(void *ctx, void *base, void *lsquareLoc, void *rsquareLoc);
+void *DictionaryTypeRepr_create(void *ctx, void *keyType, void *valueType, void *lsquareLoc, void *colonloc, void *rsquareLoc);
+void *OptionalTypeRepr_create(void *ctx, void *base, void *questionLoc);
+void *ImplicitlyUnwrappedOptionalTypeRepr_create(void *ctx, void *base, void *exclamationLoc);
+void *MetatypeTypeRepr_create(void *ctx, void *baseType, void *typeLoc);
+void *ProtocolTypeRepr_create(void *ctx, void *baseType, void *protoLoc);
+void *PackExpansionTypeRepr_create(void *ctx, void *base, void *ellipsisLoc);
+void *TupleTypeRepr_create(void *ctx, BridgedArrayRef elements, void *lParenLoc, void *rParenLoc);
+void *IdentTypeRepr_create(void *ctx, BridgedArrayRef components);
+void *GenericIdentTypeRepr_create(void *ctx, BridgedIdentifier name, void *nameLoc, BridgedArrayRef genericArgs, void *lAngle, void *rAngle);
+void *CompositionTypeRepr_create(void *ctx, BridgedArrayRef types, void *firstTypeLoc);
+void *FunctionTypeRepr_create(void *ctx, void *argsTy, void *_Nullable asyncLoc, void *_Nullable throwsLoc, void *arrowLoc, void *returnType);
+void *NamedOpaqueReturnTypeRepr_create(void *ctx, void *baseTy);
+void *OpaqueReturnTypeRepr_create(void *ctx, void *opaqueLoc, void *baseTy);
+void *ExistentialTypeRepr_create(void *ctx, void *anyLoc, void *baseTy);
+void *GenericParamList_create(void *ctx, void *lAngleLoc, BridgedArrayRef params, void *_Nullable whereLoc, BridgedArrayRef reqs, void *rAngleLoc);
+void *GenericTypeParamDecl_create(void *ctx, void *declContext, BridgedIdentifier name, void *nameLoc, void *_Nullable ellipsisLoc, long index, _Bool isParameterPack);
+void GenericTypeParamDecl_setInheritedType(void *ctx, void *Param, void *ty);
+
+struct DeclContextAndDecl TypeAliasDecl_create(void *ctx, void *declContext, void *aliasLoc, void *equalLoc, BridgedIdentifier name, void *nameLoc, void *_Nullable genericParams);
+void TypeAliasDecl_setUnderlyingTypeRepr(void *decl, void *underlyingType);
+
+
 void TopLevelCodeDecl_dump(void *);
 void Expr_dump(void *);
 void Decl_dump(void *);

include/swift/AST/Expr.h

@@ -6013,20 +6013,23 @@ class TypeJoinExpr final : public Expr,
 
 class MacroExpansionExpr final : public Expr {
 private:
-  Expr *Macro;
-  Expr *Rewritten;
-  ArgumentList *ArgList;
   SourceLoc PoundLoc;
+  DeclNameRef MacroName;
+  DeclNameLoc MacroNameLoc;
+  ArgumentList *ArgList;
+  Expr *Rewritten;
 
 public:
-  explicit MacroExpansionExpr(SourceLoc poundLoc, Expr *macro,
+  explicit MacroExpansionExpr(SourceLoc poundLoc, DeclNameRef macroName,
+                              DeclNameLoc macroNameLoc,
                               ArgumentList *argList, bool isImplicit = false,
                               Type ty = Type())
-      : Expr(ExprKind::MacroExpansion, isImplicit, ty), Macro(macro),
-        Rewritten(nullptr), ArgList(argList), PoundLoc(poundLoc) {}
+      : Expr(ExprKind::MacroExpansion, isImplicit, ty), PoundLoc(poundLoc),
+        MacroName(macroName), MacroNameLoc(macroNameLoc), ArgList(argList),
+        Rewritten(nullptr) { }
 
-  Expr *getMacro() const { return Macro; }
-  void setMacro(Expr *macro) { Macro = macro; }
+  DeclNameRef getMacroName() const { return MacroName; }
+  DeclNameLoc getMacroNameLoc() const { return MacroNameLoc; }
 
   Expr *getRewritten() const { return Rewritten; }
   void setRewritten(Expr *rewritten) { Rewritten = rewritten; }
@@ -6038,7 +6041,7 @@ class MacroExpansionExpr final : public Expr {
 
   SourceRange getSourceRange() const {
     return SourceRange(
-        PoundLoc, ArgList ? ArgList->getEndLoc() : Macro->getEndLoc());
+        PoundLoc, ArgList ? ArgList->getEndLoc() : MacroNameLoc.getEndLoc());
   }
 
   static bool classof(const Expr *E) {

include/swift/AST/TypeCheckRequests.h

@@ -3754,6 +3754,40 @@ 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 *),
+                           RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  StructDecl *evaluate(Evaluator &evaluator,
+                       std::string macroName, ModuleDecl *mod) const;
+
+public:
+  bool isCached() const { return true; }
+};
+
 void simple_display(llvm::raw_ostream &out, ASTNode node);
 void simple_display(llvm::raw_ostream &out, Type value);
 void simple_display(llvm::raw_ostream &out, const TypeRepr *TyR);

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -443,3 +443,6 @@ SWIFT_REQUEST(TypeChecker, GetTypeWrapperInitializer,
 SWIFT_REQUEST(TypeChecker, SynthesizeHasSymbolQueryRequest,
               FuncDecl *(ValueDecl *),
               Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, MacroContextRequest,
+              StructDecl *(std::string, ModuleDecl *),
+              Cached, NoLocationInfo)

include/swift/Sema/ConstraintSystem.h

@@ -4906,6 +4906,14 @@ 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(StringRef macro, 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 {

lib/AST/ASTDumper.cpp

@@ -2976,8 +2976,7 @@ class PrintExpr : public ExprVisitor<PrintExpr> {
 
   void visitMacroExpansionExpr(MacroExpansionExpr *E) {
     printCommon(E, "macro_expansion_expr");
-    OS << '\n';
-    printRec(E->getMacro());
+    PrintWithColorRAII(OS, IdentifierColor) << " name=" << E->getMacroName();
     if (E->getArgs()) {
       OS << '\n';
       printArgumentList(E->getArgs());

lib/AST/ASTWalker.cpp

@@ -1247,8 +1247,6 @@ class Traversal : public ASTVisitor<Traversal, Expr*, Stmt*,
   }
 
   Expr *visitMacroExpansionExpr(MacroExpansionExpr *E) {
-    auto *macro = doIt(E->getMacro());
-    if (!macro) return nullptr;
     Expr *rewritten = nullptr;
     if (E->getRewritten()) {
       rewritten = doIt(E->getRewritten());
@@ -1259,7 +1257,6 @@ class Traversal : public ASTVisitor<Traversal, Expr*, Stmt*,
       args = doIt(E->getArgs());
       if (!args) return nullptr;
     }
-    E->setMacro(macro);
     E->setRewritten(rewritten);
     E->setArgs(args);
     return E;