Allow literal arguments

Author: ApolloZhu

include/swift/AST/DiagnosticsSema.def

@@ -7530,8 +7530,8 @@ ERROR(conformance_macro,none,
 ERROR(macro_as_default_argument, none,
       "non-built-in macro cannot be used as default argument",
       ())
-ERROR(macro_as_default_argument_has_arguments, none,
-      "macro used as default argument cannot have arguments",
+ERROR(macro_as_default_argument_arguments_must_be_literal, none,
+      "argument to macro used as default argument must be literal",
       ())
 
 ERROR(macro_resolve_circular_reference, none,

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -1019,6 +1019,33 @@ static void checkInheritedDefaultValueRestrictions(ParamDecl *PD) {
   }
 }
 
+static bool checkExpressionMacroDefaultValueRestrictions(ParamDecl *param) {
+  assert(param->getDefaultArgumentKind() ==
+         DefaultArgumentKind::ExpressionMacro);
+  auto &ctx = param->getASTContext();
+  auto *initExpr = param->getStructuralDefaultExpr();
+  assert(initExpr);
+
+  // Prohibit default argument that is a non-built-in macro to avoid confusion,
+  // unless the experimental feature flag is set.
+  if (!ctx.LangOpts.hasFeature(Feature::ExpressionMacroDefaultArguments)) {
+    ctx.Diags.diagnose(initExpr->getLoc(), diag::macro_as_default_argument);
+    return false;
+  }
+
+  auto macroExpansionExpr = cast<MacroExpansionExpr>(initExpr);
+  // only allow arguments that are literals
+  auto args = macroExpansionExpr->getArgs();
+  for (auto arg : *args)
+    if (!dyn_cast<LiteralExpr>(arg.getExpr())) {
+      ctx.Diags.diagnose(
+          arg.getExpr()->getLoc(),
+          diag::macro_as_default_argument_arguments_must_be_literal);
+      return false;
+    }
+  return true;
+}
+
 void TypeChecker::notePlaceholderReplacementTypes(Type writtenType,
                                                   Type inferredType) {
   assert(writtenType && inferredType &&
@@ -1132,20 +1159,12 @@ Expr *DefaultArgumentExprRequest::evaluate(Evaluator &evaluator,
   auto *initExpr = param->getStructuralDefaultExpr();
   assert(initExpr);
 
-  // Prohibit default argument that is a non-built-in macro to avoid confusion,
-  auto macroExpansionExpr = dyn_cast<MacroExpansionExpr>(initExpr);
-  if (macroExpansionExpr) {
-    // unless the experimental feature flag is set.
-    if (!ctx.LangOpts.hasFeature(Feature::ExpressionMacroDefaultArguments)) {
-      ctx.Diags.diagnose(initExpr->getLoc(), diag::macro_as_default_argument);
-      return new (ctx) ErrorExpr(initExpr->getSourceRange(), ErrorType::get(ctx));
-    }
-    auto args = macroExpansionExpr->getArgs();
-    if (!args->empty()) {
-      ctx.Diags.diagnose(args->getLoc(), diag::macro_as_default_argument_has_arguments);
-      return new (ctx) ErrorExpr(initExpr->getSourceRange(), ErrorType::get(ctx));
-    }
-  }
+  auto isMacroExpansionExpr =
+      param->getDefaultArgumentKind() == DefaultArgumentKind::ExpressionMacro;
+
+  if (isMacroExpansionExpr &&
+      !checkExpressionMacroDefaultValueRestrictions(param))
+    return new (ctx) ErrorExpr(initExpr->getSourceRange(), ErrorType::get(ctx));
 
   // If the param has an error type, there's no point type checking the default
   // expression, unless we are type checking for code completion, in which case
@@ -1163,7 +1182,7 @@ Expr *DefaultArgumentExprRequest::evaluate(Evaluator &evaluator,
   }
 
   // Expression macro default arguments are checked at caller side
-  if (macroExpansionExpr)
+  if (isMacroExpansionExpr)
     return initExpr;
 
   // Walk the checked initializer and contextualize any closures

test/Macros/macro_default_argument_diagnostics.swift

@@ -0,0 +1,53 @@
+// REQUIRES: swift_swift_parser
+
+// RUN: %empty-directory(%t)
+// RUN: %host-build-swift -swift-version 5 -emit-library -o %t/%target-library-name(MacroDefinition) -module-name=MacroDefinition %S/Inputs/syntax_macro_definitions.swift -g -no-toolchain-stdlib-rpath
+
+// RUN: %target-typecheck-verify-swift -swift-version 5 -load-plugin-library %t/%target-library-name(MacroDefinition) %s -enable-experimental-feature ExpressionMacroDefaultArguments -enable-bare-slash-regex
+
+typealias Stringified<T> = (T, String)
+@freestanding(expression)
+macro stringify<T>(_ value: T) -> Stringified<T> = #externalMacro(
+    module: "MacroDefinition", type: "StringifyMacro"
+)
+
+struct MyType { }
+typealias MyInt = Int
+struct MyLiteral: ExpressibleByStringLiteral, _ExpressibleByColorLiteral, _ExpressibleByImageLiteral, _ExpressibleByFileReferenceLiteral {
+    init(stringLiteral value: StringLiteralType) {}
+    init(_colorLiteralRed: Float, green: Float, blue: Float, alpha: Float) {}
+    init(imageLiteralResourceName: String) {}
+    init(fileReferenceLiteralResourceName: String) {}
+}
+
+// MARK: literals
+
+func testNil(nil: Stringified<MyLiteral?> = #stringify(nil)) {}
+func testBool(true: Stringified<Bool> = #stringify(true),
+              false: Stringified<Bool> = #stringify(false)) {}
+func testInt(positive: Stringified<UInt64> = #stringify(1_000_001),
+             zero: Stringified<MyInt> = #stringify(0x0),
+             negative: Stringified<Int32> = #stringify(-0o21)) {}
+func testFloat(double: Stringified<Double> = #stringify(-0xC.3p0),
+               float: Stringified<Float> = #stringify(00003.14159)) {}
+func testString(literal: Stringified<MyLiteral> = #stringify("🐨"),
+                interpolated: Stringified<String> = #stringify("Hello \(0b10001)")) {}
+func testMagic(fileID: Stringified<String> = #stringify(#fileID),
+               filePath: Stringified<String> = #stringify(#filePath),
+               file: Stringified<String> = #stringify(#file),
+               function: Stringified<String> = #stringify(#function),
+               line: Stringified<Int> = #stringify(#line),
+               column: Stringified<Int> = #stringify(#column),
+               dso: Stringified<UnsafeRawPointer> = #stringify(#dsohandle)) {}
+@available(SwiftStdlib 5.7, *)
+func testRegex(literal: Stringified<Regex<Substring>> = #stringify(/foo/)) {}
+func testObject(color: Stringified<MyLiteral> = #stringify(#colorLiteral(red: 0.4, green: 0.8, blue: 1, alpha: 1)),
+                image: Stringified<MyLiteral> = #stringify(#imageLiteral(resourceName: "swift.png")),
+                file: Stringified<MyLiteral> = #stringify(#fileLiteral(resourceName: "main.swift"))) {}
+
+// MARK: not literal
+
+let myString = "oops"
+
+// expected-error@+1{{argument to macro used as default argument must be literal}}
+func testIdentifier(notOkay: Stringified<String> = #stringify(myString)) {}