[AST] MacroRoleAttr accept any 'Expr *' as the conformances arguments

rintaro · rintaro · commit 0f1b65071605 · 2024-11-14T15:10:11.000-08:00
diff --git a/include/swift/AST/Attr.h b/include/swift/AST/Attr.h
@@ -2495,7 +2495,7 @@ class NonisolatedAttr final : public DeclAttribute {
 class MacroRoleAttr final
     : public DeclAttribute,
       private llvm::TrailingObjects<MacroRoleAttr, MacroIntroducedDeclName,
-                                    TypeExpr *> {
+                                    Expr *> {
   friend TrailingObjects;
 
   MacroSyntax syntax;
@@ -2507,22 +2507,22 @@ class MacroRoleAttr final
   MacroRoleAttr(SourceLoc atLoc, SourceRange range, MacroSyntax syntax,
                 SourceLoc lParenLoc, MacroRole role,
                 ArrayRef<MacroIntroducedDeclName> names,
-                ArrayRef<TypeExpr *> conformances,
-                SourceLoc rParenLoc, bool implicit);
+                ArrayRef<Expr *> conformances, SourceLoc rParenLoc,
+                bool implicit);
 
 public:
   static MacroRoleAttr *create(ASTContext &ctx, SourceLoc atLoc,
                                SourceRange range, MacroSyntax syntax,
                                SourceLoc lParenLoc, MacroRole role,
                                ArrayRef<MacroIntroducedDeclName> names,
-                               ArrayRef<TypeExpr *> conformances,
+                               ArrayRef<Expr *> conformances,
                                SourceLoc rParenLoc, bool implicit);
 
   size_t numTrailingObjects(OverloadToken<MacroIntroducedDeclName>) const {
     return numNames;
   }
 
-  size_t numTrailingObjects(OverloadToken<TypeExpr *>) const {
+  size_t numTrailingObjects(OverloadToken<Expr *>) const {
     return numConformances;
   }
 
@@ -2532,7 +2532,8 @@ class MacroRoleAttr final
   MacroSyntax getMacroSyntax() const { return syntax; }
   MacroRole getMacroRole() const { return role; }
   ArrayRef<MacroIntroducedDeclName> getNames() const;
-  ArrayRef<TypeExpr *> getConformances() const;
+  ArrayRef<Expr *> getConformances() const;
+  MutableArrayRef<Expr *> getConformances();
   bool hasNameKind(MacroIntroducedDeclNameKind kind) const;
 
   static bool classof(const DeclAttribute *DA) {
diff --git a/lib/AST/Attr.cpp b/lib/AST/Attr.cpp
@@ -2960,29 +2960,28 @@ MacroRoleAttr::MacroRoleAttr(SourceLoc atLoc, SourceRange range,
                              MacroSyntax syntax, SourceLoc lParenLoc,
                              MacroRole role,
                              ArrayRef<MacroIntroducedDeclName> names,
-                             ArrayRef<TypeExpr *> conformances,
-                             SourceLoc rParenLoc, bool implicit)
+                             ArrayRef<Expr *> conformances, SourceLoc rParenLoc,
+                             bool implicit)
     : DeclAttribute(DeclAttrKind::MacroRole, atLoc, range, implicit),
       syntax(syntax), role(role), numNames(names.size()),
       numConformances(conformances.size()), lParenLoc(lParenLoc),
       rParenLoc(rParenLoc) {
   auto *trailingNamesBuffer = getTrailingObjects<MacroIntroducedDeclName>();
   std::uninitialized_copy(names.begin(), names.end(), trailingNamesBuffer);
 
-  auto *trailingConformancesBuffer = getTrailingObjects<TypeExpr *>();
+  auto *trailingConformancesBuffer = getTrailingObjects<Expr *>();
   std::uninitialized_copy(conformances.begin(), conformances.end(),
                           trailingConformancesBuffer);
 }
 
-MacroRoleAttr *
-MacroRoleAttr::create(ASTContext &ctx, SourceLoc atLoc, SourceRange range,
-                      MacroSyntax syntax, SourceLoc lParenLoc, MacroRole role,
-                      ArrayRef<MacroIntroducedDeclName> names,
-                      ArrayRef<TypeExpr *> conformances,
-                      SourceLoc rParenLoc, bool implicit) {
-  unsigned size =
-      totalSizeToAlloc<MacroIntroducedDeclName, TypeExpr *>(
-          names.size(), conformances.size());
+MacroRoleAttr *MacroRoleAttr::create(ASTContext &ctx, SourceLoc atLoc,
+                                     SourceRange range, MacroSyntax syntax,
+                                     SourceLoc lParenLoc, MacroRole role,
+                                     ArrayRef<MacroIntroducedDeclName> names,
+                                     ArrayRef<Expr *> conformances,
+                                     SourceLoc rParenLoc, bool implicit) {
+  unsigned size = totalSizeToAlloc<MacroIntroducedDeclName, Expr *>(
+      names.size(), conformances.size());
   auto *mem = ctx.Allocate(size, alignof(MacroRoleAttr));
   return new (mem) MacroRoleAttr(atLoc, range, syntax, lParenLoc, role, names,
                                  conformances, rParenLoc, implicit);
@@ -2995,11 +2994,12 @@ ArrayRef<MacroIntroducedDeclName> MacroRoleAttr::getNames() const {
   };
 }
 
-ArrayRef<TypeExpr *> MacroRoleAttr::getConformances() const {
-  return {
-    getTrailingObjects<TypeExpr *>(),
-    numConformances
-  };
+ArrayRef<Expr *> MacroRoleAttr::getConformances() const {
+  return {getTrailingObjects<Expr *>(), numConformances};
+}
+
+MutableArrayRef<Expr *> MacroRoleAttr::getConformances() {
+  return {getTrailingObjects<Expr *>(), numConformances};
 }
 
 bool MacroRoleAttr::hasNameKind(MacroIntroducedDeclNameKind kind) const {
diff --git a/lib/AST/Bridging/DeclAttributeBridging.cpp b/lib/AST/Bridging/DeclAttributeBridging.cpp
@@ -294,8 +294,8 @@ BridgedMacroRoleAttr BridgedMacroRoleAttr_createParsed(
   for (auto &n : cNames.unbridged<BridgedMacroIntroducedDeclName>())
     names.push_back(n.unbridged());
 
-  SmallVector<TypeExpr *, 2> conformances;
-  for (auto &t : cConformances.unbridged<BridgedTypeExpr>())
+  SmallVector<Expr *, 2> conformances;
+  for (auto &t : cConformances.unbridged<BridgedExpr>())
     conformances.push_back(t.unbridged());
 
   return MacroRoleAttr::create(
diff --git a/lib/ASTGen/Sources/ASTGen/DeclAttrs.swift b/lib/ASTGen/Sources/ASTGen/DeclAttrs.swift
@@ -753,86 +753,6 @@ extension ASTGenVisitor {
     return BridgedMacroIntroducedDeclName(kind: kind, name: name)
   }
 
-  struct GeneratedGenericArguments {
-    var arguments: BridgedArrayRef = .init()
-    var range: BridgedSourceRange = .init()
-  }
-
-  /// Generate 'TypeRepr' from a expression, because 'conformances' arguments in
-  /// macro role attributes are parsed as normal expressions.
-  func generateMacroIntroducedConformance(
-    expr: ExprSyntax,
-    genericArgs: GeneratedGenericArguments = GeneratedGenericArguments()
-  ) -> BridgedTypeRepr? {
-    switch expr.as(ExprSyntaxEnum.self) {
-    case .typeExpr(let node):
-      return self.generate(type: node.type)
-
-    case .declReferenceExpr(let node):
-      guard node.argumentNames == nil else {
-        // 'Foo.bar(_:baz:)'
-        break
-      }
-      let name = self.generateIdentifierAndSourceLoc(node.baseName)
-      return BridgedUnqualifiedIdentTypeRepr .createParsed(
-        self.ctx,
-        name: name.identifier,
-        nameLoc: name.sourceLoc,
-        genericArgs: genericArgs.arguments,
-        leftAngleLoc: genericArgs.range.start,
-        rightAngleLoc: genericArgs.range.end
-      ).asTypeRepr
-
-    case .memberAccessExpr(let node):
-      guard let parsedBase = node.base else {
-        // Implicit member expressions. E.g. '.Foo'
-        break
-      }
-      guard let base = self.generateMacroIntroducedConformance(expr: parsedBase) else {
-        // Unsupported base expr. E.g. 'foo().bar'
-        return nil
-      }
-      guard node.declName.argumentNames == nil else {
-        // Function name. E.g. 'Foo.bar(_:baz:)'
-        break
-      }
-      let name = self.generateIdentifierAndSourceLoc(node.declName.baseName)
-      return BridgedDeclRefTypeRepr.createParsed(
-        self.ctx,
-        base: base,
-        name: name.identifier,
-        nameLoc: name.sourceLoc,
-        genericArguments: genericArgs.arguments,
-        angleRange: genericArgs.range
-      ).asTypeRepr
-
-    case .genericSpecializationExpr(let node):
-      guard node.expression.is(MemberAccessExprSyntax.self) || node.expression.is(DeclReferenceExprSyntax.self) else {
-        break
-      }
-      let args = node.genericArgumentClause.arguments.lazy.map {
-        self.generate(genericArgument: $0.argument)
-      }
-      return self.generateMacroIntroducedConformance(
-        expr: node.expression,
-        genericArgs: GeneratedGenericArguments(
-          arguments: args.bridgedArray(in: self),
-          range: self.generateSourceRange(node.genericArgumentClause)
-        )
-      )
-
-    case .sequenceExpr:
-      // TODO: Support protocol composition.
-      break
-
-    default:
-      break
-    }
-
-    // TODO: Diagnose invalid expression for a conformance.
-    return nil
-  }
-
   func generateMacroRoleAttr(attribute node: AttributeSyntax, attrName: SyntaxText) -> BridgedMacroRoleAttr? {
     // '@freestanding' or '@attached'.
     assert(attrName == "freestanding" || attrName == "attached")
@@ -865,7 +785,7 @@ extension ASTGenVisitor {
     }
 
     var names: [BridgedMacroIntroducedDeclName] = []
-    var conformances: [BridgedTypeExpr] = []
+    var conformances: [BridgedExpr] = []
 
     enum ArgState {
       case inNames
@@ -913,9 +833,7 @@ extension ASTGenVisitor {
           names.append(name)
         }
       case .inConformances:
-        if let conformance = self.generateMacroIntroducedConformance(expr: arg.expression) {
-          conformances.append(BridgedTypeExpr.createParsed(self.ctx, type: conformance))
-        }
+        conformances.append(self.generate(expr: arg.expression))
       case .inInvalid:
         // Ignore the value.
         break
diff --git a/lib/Parse/ParseDecl.cpp b/lib/Parse/ParseDecl.cpp
@@ -2429,7 +2429,7 @@ Parser::parseMacroRoleAttribute(
   bool sawConformances = false;
   bool sawNames = false;
   SmallVector<MacroIntroducedDeclName, 2> names;
-  SmallVector<TypeExpr *, 2> conformances;
+  SmallVector<Expr *, 2> conformances;
   auto argumentsStatus = parseList(
       tok::r_paren, lParenLoc, rParenLoc,
       /*AllowSepAfterLast=*/false, diag::expected_rparen_expr_list, [&] {
@@ -2525,9 +2525,9 @@ Parser::parseMacroRoleAttribute(
           sawConformances = true;
 
           // Parse the introduced conformances
-          auto type = parseType();
-          auto *typeExpr = new (Context) TypeExpr(type.get());
-          conformances.push_back(typeExpr);
+          auto expr = parseExpr(diag::expected_type);
+          if (expr.isNonNull())
+            conformances.push_back(expr.get());
 
           return status;
         }
diff --git a/lib/Sema/TypeCheckMacros.cpp b/lib/Sema/TypeCheckMacros.cpp
@@ -40,12 +40,13 @@
 #include "swift/Basic/Lazy.h"
 #include "swift/Basic/SourceManager.h"
 #include "swift/Basic/StringExtras.h"
-#include "swift/ClangImporter/ClangModule.h"
 #include "swift/Bridging/ASTGen.h"
 #include "swift/Bridging/MacroEvaluation.h"
+#include "swift/ClangImporter/ClangModule.h"
 #include "swift/Demangling/Demangler.h"
 #include "swift/Demangling/ManglingMacros.h"
 #include "swift/Parse/Lexer.h"
+#include "swift/Sema/ConstraintSystem.h"
 #include "swift/Sema/IDETypeChecking.h"
 #include "swift/Subsystems.h"
 #include "llvm/Config/config.h"
@@ -2091,7 +2092,19 @@ ResolveMacroConformances::evaluate(Evaluator &evaluator,
   auto &ctx = dc->getASTContext();
 
   SmallVector<Type, 2> protocols;
-  for (auto *typeExpr : attr->getConformances()) {
+  for (Expr *&expr : const_cast<MacroRoleAttr *>(attr)->getConformances()) {
+    using namespace constraints;
+    auto target = SyntacticElementTarget(expr, dc, CTP_Unused, Type(),
+                                         /*isDiscarded=*/true);
+    if (ConstraintSystem::preCheckTarget(target))
+      continue;
+    auto *typeExpr = dyn_cast<TypeExpr>(target.getAsExpr());
+    if (!typeExpr) {
+      ctx.Diags.diagnose(expr->getStartLoc(), diag::expected_type);
+      continue;
+    }
+    expr = typeExpr;
+
     if (auto *typeRepr = typeExpr->getTypeRepr()) {
       auto resolved =
           TypeResolution::forInterface(
diff --git a/lib/Serialization/Deserialization.cpp b/lib/Serialization/Deserialization.cpp
@@ -6360,7 +6360,7 @@ llvm::Error DeclDeserializer::deserializeDeclCommon() {
         }
 
         introducedDeclNames = introducedDeclNames.slice(numNames);
-        SmallVector<TypeExpr *, 1> conformances;
+        SmallVector<Expr *, 1> conformances;
         for (TypeID conformanceID : introducedDeclNames) {
           auto conformance = MF.getTypeChecked(conformanceID);
           if (!conformance) {
diff --git a/lib/Serialization/Serialization.cpp b/lib/Serialization/Serialization.cpp
@@ -3399,13 +3399,13 @@ class Serializer::DeclSerializer : public DeclVisitor<DeclSerializer> {
 
       unsigned numNames = introducedDeclNames.size();
 
-      (void)evaluateOrDefault(S.getASTContext().evaluator,
-                              ResolveMacroConformances{theAttr, D}, {});
+      auto conformances =
+          evaluateOrDefault(S.getASTContext().evaluator,
+                            ResolveMacroConformances{theAttr, D}, {});
 
       unsigned numConformances = 0;
-      for (auto conformance : theAttr->getConformances()) {
-        introducedDeclNames.push_back(
-            S.addTypeRef(conformance->getInstanceType()));
+      for (auto conformance : conformances) {
+        introducedDeclNames.push_back(S.addTypeRef(conformance));
         ++numConformances;
       }
 

Original file line number	Diff line number	Diff line change
`@@ -6360,7 +6360,7 @@ llvm::Error DeclDeserializer::deserializeDeclCommon() {`
`6360`	`6360`	`}`
`6361`	`6361`
`6362`	`6362`	`introducedDeclNames = introducedDeclNames.slice(numNames);`
`6363`		`- SmallVector<TypeExpr *, 1> conformances;`
	`6363`	`+ SmallVector<Expr *, 1> conformances;`
`6364`	`6364`	`for (TypeID conformanceID : introducedDeclNames) {`
`6365`	`6365`	`auto conformance = MF.getTypeChecked(conformanceID);`
`6366`	`6366`	`if (!conformance) {`