Use Swift Syntax for checking literals

Author: ApolloZhu

include/swift/AST/DiagnosticsSema.def

@@ -7526,9 +7526,6 @@ ERROR(macro_attached_to_invalid_decl,none,
 ERROR(macro_as_default_argument, none,
       "non-built-in macro cannot be used as default argument",
       ())
-ERROR(macro_as_default_argument_arguments_must_be_literal, none,
-      "argument to macro used as default argument must be literal",
-      ())
 ERROR(conformance_macro,none,
       "conformance macros are replaced by extension macros",
       ())

include/swift/Bridging/ASTGen.h

@@ -68,6 +68,10 @@ void *_Nonnull swift_ASTGen_resolveExecutableMacro(
     void *_Nonnull opaquePluginHandle);
 void swift_ASTGen_destroyExecutableMacro(void *_Nonnull macro);
 
+bool swift_ASTGen_checkDefaultArgumentMacroExpression(
+    void *_Nonnull diagEngine, void *_Nonnull sourceFile,
+    const void *_Nonnull macroSourceLocation);
+
 ptrdiff_t swift_ASTGen_checkMacroDefinition(
     void *_Nonnull diagEngine, void *_Nonnull sourceFile,
     const void *_Nonnull macroSourceLocation,

lib/ASTGen/Sources/ASTGen/Macros.swift

@@ -179,6 +179,53 @@ fileprivate func identifierFromStringLiteral(_ node: ExprSyntax) -> String? {
   return stringSegment.content.text
 }
 
+/// Checks if the macro expression used as an default argument has any issues.
+///
+/// - Returns: `true` if all restrictions are satisfied, `false` if diagnostics
+/// are emitted.
+@_cdecl("swift_ASTGen_checkDefaultArgumentMacroExpression")
+func checkDefaultArgumentMacroExpression(
+  diagEnginePtr: UnsafeMutableRawPointer,
+  sourceFilePtr: UnsafeRawPointer,
+  macroLocationPtr: UnsafePointer<UInt8>
+) -> Bool {
+  let sourceFilePtr = sourceFilePtr.bindMemory(to: ExportedSourceFile.self, capacity: 1)
+
+  // Find the macro expression.
+  guard
+    let macroExpr = findSyntaxNodeInSourceFile(
+      sourceFilePtr: sourceFilePtr,
+      sourceLocationPtr: macroLocationPtr,
+      type: MacroExpansionExprSyntax.self
+    )
+  else {
+    // FIXME: Produce an error
+    return false
+  }
+
+  do {
+    try macroExpr.checkDefaultArgumentMacroExpression()
+    return true
+  } catch let errDiags as DiagnosticsError {
+    let srcMgr = SourceManager(cxxDiagnosticEngine: diagEnginePtr)
+    srcMgr.insert(sourceFilePtr)
+    for diag in errDiags.diagnostics {
+      srcMgr.diagnose(diagnostic: diag)
+    }
+    return false
+  } catch let error {
+    let srcMgr = SourceManager(cxxDiagnosticEngine: diagEnginePtr)
+    srcMgr.insert(sourceFilePtr)
+    srcMgr.diagnose(
+      diagnostic: .init(
+        node: macroExpr,
+        message: ASTGenMacroDiagnostic.thrownError(error)
+      )
+    )
+    return false
+  }
+}
+
 /// Check a macro definition, producing a description of that macro definition
 /// for use in macro expansion.
 ///

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -54,6 +54,7 @@
 #include "swift/AST/TypeWalker.h"
 #include "swift/Basic/Defer.h"
 #include "swift/Basic/Statistic.h"
+#include "swift/Bridging/ASTGen.h"
 #include "swift/Parse/Lexer.h"
 #include "swift/Parse/Parser.h"
 #include "swift/Serialization/SerializedModuleLoader.h"
@@ -1033,18 +1034,16 @@ static bool checkExpressionMacroDefaultValueRestrictions(ParamDecl *param) {
     return false;
   }
 
-  auto macroExpansionExpr = cast<MacroExpansionExpr>(initExpr);
-  // only allow arguments that are literals
-  auto args = macroExpansionExpr->getArgs();
-  for (auto arg : *args)
-    if (!isa<LiteralExpr>(arg.getExpr()) ||
-        isa<InterpolatedStringLiteralExpr>(arg.getExpr())) {
-      ctx.Diags.diagnose(
-          arg.getExpr()->getLoc(),
-          diag::macro_as_default_argument_arguments_must_be_literal);
-      return false;
-    }
-  return true;
+#if SWIFT_BUILD_SWIFT_SYNTAX
+  auto *DC = param->getInnermostDeclContext();
+  const SourceFile *SF = DC->getParentSourceFile();
+  return swift_ASTGen_checkDefaultArgumentMacroExpression(
+      &ctx.Diags, SF->getExportedSourceFile(),
+      initExpr->getLoc().getOpaquePointerValue());
+#else
+  ctx.Diags.diagnose(initExpr->getLoc(), diag::macro_unsupported));
+  return false;
+#endif
 }
 
 void TypeChecker::notePlaceholderReplacementTypes(Type writtenType,

test/Macros/macro_default_argument_diagnostics.swift

@@ -50,10 +50,10 @@ func testObject(color: Stringified<MyLiteral> = #stringify(#colorLiteral(red: 0.
 
 let myString = "oops"
 
-// expected-error@+1{{argument to macro used as default argument must be literal}}
+// expected-error@+1{{only literals are permitted}}
 func testIdentifier(notOkay: Stringified<String> = #stringify(myString)) {}
 
-// expected-error@+1{{argument to macro used as default argument must be literal}}
+// expected-error@+1{{only literals are permitted}}
 func testString(interpolated: Stringified<String> = #stringify("Hello \(0b10001)")) {}
 
 // expected-error@+1{{macro 'stringify' is internal and cannot be referenced from a default argument value}}