Emit default arg generator for stored property kind

Author: Azoy

lib/SILGen/SILGen.cpp

@@ -1068,11 +1068,10 @@ void SILGenModule::emitDefaultArgGenerator(SILDeclRef constant, Expr *arg,
     llvm_unreachable("No default argument here?");
 
   case DefaultArgumentKind::Normal:
+  case DefaultArgumentKind::StoredProperty:
     break;
 
   case DefaultArgumentKind::Inherited:
-    return;
-
   case DefaultArgumentKind::Column:
   case DefaultArgumentKind::File:
   case DefaultArgumentKind::Line:
@@ -1081,7 +1080,6 @@ void SILGenModule::emitDefaultArgGenerator(SILDeclRef constant, Expr *arg,
   case DefaultArgumentKind::NilLiteral:
   case DefaultArgumentKind::EmptyArray:
   case DefaultArgumentKind::EmptyDictionary:
-  case DefaultArgumentKind::StoredProperty:
     return;
   }
 
@@ -1161,7 +1159,12 @@ void SILGenModule::emitDefaultArgGenerators(SILDeclRef::Loc decl,
                                             ParameterList *paramList) {
   unsigned index = 0;
   for (auto param : *paramList) {
-    if (auto defaultArg = param->getDefaultValue())
+    auto defaultArg = param->getDefaultValue();
+
+    if (auto var = param->getStoredProperty())
+      defaultArg = var->getParentInitializer();
+
+    if (defaultArg)
       emitDefaultArgGenerator(SILDeclRef::getDefaultArgGenerator(decl, index),
                               defaultArg, param->getDefaultArgumentKind(),
                               param->getDefaultArgumentInitContext());

lib/SILGen/SILGenApply.cpp

@@ -3186,40 +3186,11 @@ void DelayedArgument::emitDefaultArgument(SILGenFunction &SGF,
                                           const DefaultArgumentStorage &info,
                                           SmallVectorImpl<ManagedValue> &args,
                                           size_t &argIndex) {
-  RValue value;  
-  bool isStoredPropertyDefaultArg = false;
-
-  // Check if this is a synthesized memberwise constructor for stored property
-  // default values
-  if (auto ctor = dyn_cast<ConstructorDecl>(info.defaultArgsOwner.getDecl())) {
-    if (ctor->isMemberwiseInitializer() && ctor->isImplicit()) {
-      auto param = ctor->getParameters()->get(info.destIndex);
-      
-      if (auto var = param->getStoredProperty()) {
-        // This is a stored property default arg. Do not emit a call to the
-        // default arg generator, but rather the variable initializer expression
-        isStoredPropertyDefaultArg = true;
-
-        auto pbd = var->getParentPatternBinding();
-        auto entry = pbd->getPatternEntryForVarDecl(var);
-        auto subs = info.defaultArgsOwner.getSubstitutions();
-
-        value = SGF.emitApplyOfStoredPropertyInitializer(info.loc,
-                                                         entry, subs,
-                                                         info.resultType,
-                                                         info.origResultType,
-                                                         SGFContext());
-      }
-    }
-  }
-
-  if (!isStoredPropertyDefaultArg) {
-    value = SGF.emitApplyOfDefaultArgGenerator(info.loc,
-                                               info.defaultArgsOwner,
-                                               info.destIndex,
-                                               info.resultType,
-                                               info.origResultType);
-  }
+  auto value = SGF.emitApplyOfDefaultArgGenerator(info.loc,
+                                                  info.defaultArgsOwner,
+                                                  info.destIndex,
+                                                  info.resultType,
+                                                  info.origResultType);
 
   SmallVector<ManagedValue, 4> loweredArgs;
   SmallVector<DelayedArgument, 4> delayedArgs;

test/SILGen/stored_property_default_arg.swift

@@ -17,8 +17,8 @@ func checkConcreteType() {
 // CHECK-NEXT: {{.*}} = apply [[A1_REF]]({{.*}}, [[C1]], {{.*}}) : $@convention(method) (Int, Bool, @thin A.Type) -> A
   let d = A(b: 1)
 
-// CHECK: function_ref variable initialization expression of A.b
-// CHECK-NEXT: [[B1_REF:%.*]] = function_ref @$s27stored_property_default_arg1AV1bSivpfi : $@convention(thin) () -> Int
+// CHECK: function_ref default argument 0 of A.init(b:c:)
+// CHECK-NEXT: [[B1_REF:%.*]] = function_ref @$s27stored_property_default_arg1AV1b1cACSi_SbtcfcfA_ : $@convention(thin) () -> Int
 // CHECK-NEXT: [[B1:%.*]] = apply [[B1_REF]]() : $@convention(thin) () -> Int
 // CHECK-NEXT: function_ref A.init(b:c:)
 // CHECK-NEXT: [[A2_REF:%.*]] = function_ref @$s27stored_property_default_arg1AV1b1cACSi_SbtcfC : $@convention(method) (Int, Bool, @thin A.Type) -> A

test/Serialization/Inputs/stored_property_default_arg_testable.swift

@@ -0,0 +1,4 @@
+struct Foo {
+  var bar = 0
+  var baz = false
+}

test/Serialization/stored_property_default_arg.swift

@@ -0,0 +1,14 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -emit-module -enable-testing -o %t %S/Inputs/stored_property_default_arg_testable.swift
+// RUN: %target-swift-frontend -emit-silgen -I %t %s | %FileCheck %s
+
+@testable import stored_property_default_arg_testable
+
+// CHECK: function_ref default argument 0 of Foo.init(bar:baz:)
+// CHECK-NEXT: [[BAR_REF:%.*]] = function_ref @$s36stored_property_default_arg_testable3FooV3bar3bazACSi_SbtcfcfA_ : $@convention(thin) () -> Int
+// CHECK-NEXT: [[BAR:%.*]] = apply [[BAR_REF]]() : $@convention(thin) () -> Int
+// CHECK-NEXT: function_ref Foo.init(bar:baz:)
+// CHECK-NEXT: [[FOO_REF:%.*]] = function_ref @$s36stored_property_default_arg_testable3FooV3bar3bazACSi_SbtcfC : $@convention(method) (Int, Bool, @thin Foo.Type) -> Foo
+// CHECK-NEXT: {{.*}} = apply [[FOO_REF]]([[BAR]], {{.*}}, {{.*}}) : $@convention(method) (Int, Bool, @thin Foo.Type) -> Foo
+
+_ = Foo(baz: true)