Somewhat working

Test shadowed variable of same type

Fully type check caller side macro expansion

Skip macro default arg caller side expr at decl primary

Test macro expand more complex expressions

Set synthesized expression as implicit

Add test case for with argument, not compiling currently

Test with swiftinterface

Always use the string representation of the default argument

Now works across module boundary

Check works for multiple files

Make default argument expression work in single file

Use expected-error

Disallow expression macro as default argument

Using as a sub expression in default argument still allowed as expression macros behave the same as built-in magic literals

Author: ApolloZhu

include/swift/AST/DefaultArgumentKind.h

@@ -51,6 +51,8 @@ enum class DefaultArgumentKind : uint8_t {
   // Magic identifier literals expanded at the call site:
 #define MAGIC_IDENTIFIER(NAME, STRING, SYNTAX_KIND) NAME,
 #include "swift/AST/MagicIdentifierKinds.def"
+  /// An expression macro.
+  ExpressionMacro
 };
 enum { NumDefaultArgumentKindBits = 4 };
 

include/swift/AST/Module.h

@@ -106,6 +106,7 @@ enum class SourceFileKind {
   SIL,      ///< Came from a .sil file.
   Interface, ///< Came from a .swiftinterface file, representing another module.
   MacroExpansion, ///< Came from a macro expansion.
+  DefaultArgument, ///< Came from default argument at caller side
 };
 
 /// Contains information about where a particular path is used in

include/swift/AST/SourceFile.h

@@ -674,6 +674,7 @@ class SourceFile final : public FileUnit {
     case SourceFileKind::Interface:
     case SourceFileKind::SIL:
     case SourceFileKind::MacroExpansion:
+    case SourceFileKind::DefaultArgument:
       return false;
     }
     llvm_unreachable("bad SourceFileKind");

include/swift/Basic/Features.def

@@ -135,6 +135,7 @@ EXPERIMENTAL_FEATURE(NamedOpaqueTypes, false)
 EXPERIMENTAL_FEATURE(FlowSensitiveConcurrencyCaptures, false)
 EXPERIMENTAL_FEATURE(CodeItemMacros, false)
 EXPERIMENTAL_FEATURE(BodyMacros, true)
+EXPERIMENTAL_FEATURE(ExpressionMacroDefaultArguments, false)
 EXPERIMENTAL_FEATURE(TupleConformances, false)
 
 // Whether to enable @_used and @_section attributes

include/swift/Basic/MacroRoles.def

@@ -70,6 +70,9 @@ ATTACHED_MACRO_ROLE(Conformance, "conformance", "c")
 /// declarations in a code block.
 EXPERIMENTAL_FREESTANDING_MACRO_ROLE(CodeItem, "codeItem", CodeItemMacros)
 
+/// A freestanding macro that is used as the default argument
+EXPERIMENTAL_FREESTANDING_MACRO_ROLE(DefaultArgument, "defaultArgument", ExpressionMacroDefaultArguments)
+
 /// An attached macro that adds extensions to the declaration the
 /// macro is attached to.
 ATTACHED_MACRO_ROLE(Extension, "extension", "e")

include/swift/Basic/SourceManager.h

@@ -43,6 +43,9 @@ class GeneratedSourceInfo {
 
     /// Pretty-printed declarations that have no source location.
     PrettyPrinted,
+
+    /// The expansion of default argument at caller side
+    DefaultArgument,
   } kind;
 
   /// The source range in the enclosing buffer where this source was generated.

include/swift/Sema/ConstraintSystem.h

@@ -85,7 +85,7 @@ llvm::Optional<constraints::SyntacticElementTarget>
 typeCheckTarget(constraints::SyntacticElementTarget &target,
                 OptionSet<TypeCheckExprFlags> options);
 
-Type typeCheckParameterDefault(Expr *&, DeclContext *, Type, bool);
+Type typeCheckParameterDefault(Expr *&, DeclContext *, Type, bool, bool);
 
 } // end namespace TypeChecker
 
@@ -2970,7 +2970,7 @@ class ConstraintSystem {
 
   friend Type swift::TypeChecker::typeCheckParameterDefault(Expr *&,
                                                             DeclContext *, Type,
-                                                            bool);
+                                                            bool, bool);
 
   /// Emit the fixes computed as part of the solution, returning true if we were
   /// able to emit an error message, or false if none of the fixits worked out.

lib/AST/ASTDumper.cpp

@@ -309,6 +309,8 @@ static StringRef getDumpString(DefaultArgumentKind value) {
     case DefaultArgumentKind::EmptyDictionary: return "[:]";
     case DefaultArgumentKind::Normal: return "normal";
     case DefaultArgumentKind::StoredProperty: return "stored property";
+    case DefaultArgumentKind::ExpressionMacro:
+    return "expression macro";
   }
 
   llvm_unreachable("Unhandled DefaultArgumentKind in switch.");

lib/AST/ASTMangler.cpp

@@ -3877,6 +3877,8 @@ void ASTMangler::appendMacroExpansionContext(
 
   case GeneratedSourceInfo::PrettyPrinted:
   case GeneratedSourceInfo::ReplacedFunctionBody:
+  // TODO: ApolloZhu check if this correct?
+  case GeneratedSourceInfo::DefaultArgument:
     return appendContext(origDC, StringRef());
   }
 

lib/AST/ASTPrinter.cpp

@@ -3042,6 +3042,18 @@ static bool usesFeatureFreestandingMacros(Decl *decl) {
   return macro->getMacroRoles().contains(MacroRole::Declaration);
 }
 
+static bool usesFeatureExpressionMacroDefaultArguments(Decl *decl) {
+  if (auto func = dyn_cast<AbstractFunctionDecl>(decl)) {
+    for (auto param : *func->getParameters()) {
+      if (param->getDefaultArgumentKind() ==
+          DefaultArgumentKind::ExpressionMacro)
+        return true;
+    }
+  }
+
+  return false;
+}
+
 static bool usesFeatureCodeItemMacros(Decl *decl) {
   auto macro = dyn_cast<MacroDecl>(decl);
   if (!macro)