Fix generic types

add tests

get parent init

Author: Azoy

lib/SILGen/SILGenApply.cpp

@@ -3364,8 +3364,7 @@ void DelayedArgument::emitDefaultArgument(SILGenFunction &SGF,
           var->getDeclContext()->getGenericSignatureOfContext();
 
         if (genericEnv && typeGenericSig) {
-          // Get the substitutions from the constructor's generic env.
-          subs = genericEnv->getForwardingSubstitutionMap();
+          subs = info.defaultArgsOwner.getSubstitutions();
         }
 
         value = SGF.emitApplyOfStoredPropertyInitializer(info.loc,

lib/Sema/CodeSynthesis.cpp

@@ -1655,11 +1655,10 @@ static void maybeAddMemberwiseDefaultArg(ParamDecl *arg, VarDecl *var,
   if (!var->getParentPattern()->getSingleVar())
     return;
 
-  // If we don't have an initializer and we can't assign a default initializer
-  // in silgen, then we can't generate a default value. An example of a default
-  // initializer would be var x: Int? where the default is nil.
-  if (!var->getParentInitializer() &&
-      !var->getParentPatternBinding()->isDefaultInitializable())
+  // If we don't have an expression initializer or silgen can't assign a default
+  // initializer, then we can't generate a default value. An example of where
+  // silgen can assign a default is var x: Int? where the default is nil.
+  if (!var->getParentPatternBinding()->isDefaultInitializable())
     return;
 
   // We can add a default value now.
@@ -1675,6 +1674,14 @@ static void maybeAddMemberwiseDefaultArg(ParamDecl *arg, VarDecl *var,
   // we're going to call the variable's initializer expression.
   arg->setStoredProperty(var);
   arg->setDefaultArgumentKind(DefaultArgumentKind::StoredProperty);
+
+  // If the type is T? and has no initial value, then set the default arg kind
+  // to nil literal. This is useful when we need to print the constructor.
+  // Note, this will always be the sugared T? because we don't default init an
+  // explicit Optional<T>.
+  if (isa<OptionalType>(var->getType().getPointer()) &&
+      !var->getParentInitializer())
+    arg->setDefaultArgumentKind(DefaultArgumentKind::NilLiteral);
 }
 
 /// Create an implicit struct or class constructor.

test/IDE/complete_at_top_level.swift

@@ -263,8 +263,8 @@ func resyncParser7() {}
 var topLevelVar2 = FooStruct#^TOP_LEVEL_VAR_INIT_2^#
 // TOP_LEVEL_VAR_INIT_2: Begin completions
 // TOP_LEVEL_VAR_INIT_2-NEXT: Decl[InstanceMethod]/CurrNominal: .instanceFunc({#(self): FooStruct#})[#(Int) -> Void#]{{; name=.+$}}
-// TOP_LEVEL_VAR_INIT_2-NEXT: Decl[Constructor]/CurrNominal: ({#instanceVar: Int#})[#FooStruct#]{{; name=.+$}}
 // TOP_LEVEL_VAR_INIT_2-NEXT: Decl[Constructor]/CurrNominal: ()[#FooStruct#]{{; name=.+$}}
+// TOP_LEVEL_VAR_INIT_2-NEXT: Decl[Constructor]/CurrNominal: ({#instanceVar: Int#})[#FooStruct#]{{; name=.+$}}
 // TOP_LEVEL_VAR_INIT_2-NEXT: Decl[Constructor]/CurrNominal: ()[#FooStruct#]{{; name=.+$}}
 // TOP_LEVEL_VAR_INIT_2-NEXT: Keyword[self]/CurrNominal: .self[#FooStruct.Type#]; name=self
 // TOP_LEVEL_VAR_INIT_2-NEXT: Keyword/CurrNominal:       .Type[#FooStruct.Type#]; name=Type

test/SILGen/stored_property_default_arg.swift

@@ -0,0 +1,40 @@
+// RUN: %target-swift-emit-silgen -primary-file %s | %FileCheck %s
+
+// Currently, this only appears for memberwise initializers.
+
+struct A {
+  var b: Int = 0
+  var c: Bool = false
+}
+
+// CHECK: function_ref variable initialization expression of A.c
+// CHECK-NEXT: [[C1_REF:%.*]] = function_ref @$s27stored_property_default_arg1AV1cSbvpfi : $@convention(thin) () -> Bool
+// CHECK-NEXT: [[C1:%.*]] = apply [[C1_REF]]() : $@convention(thin) () -> Bool
+// CHECK-NEXT: function_ref A.init(b:c:)
+// CHECK-NEXT: [[A1_REF:%.*]] = function_ref @$s27stored_property_default_arg1AV1b1cACSi_SbtcfC : $@convention(method) (Int, Bool, @thin A.Type) -> A
+// 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-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
+// CHECK-NEXT: {{.*}} = apply [[A2_REF]]([[B1]], {{.*}}, {{.*}}) : $@convention(method) (Int, Bool, @thin A.Type) -> A
+
+let e = A(c: true)
+
+struct F<T> {
+  var g: T
+  var h: Int = 0
+}
+
+// CHECK: function_ref variable initialization expression of F.h
+// CHECK-NEXT: [[H1_REF:%.*]] = function_ref @$s27stored_property_default_arg1FV1hSivpfi : $@convention(thin) <τ_0_0> () -> Int
+// CHECK-NEXT: [[H1:%.*]] = apply [[H1_REF]]<Int>() : $@convention(thin) <τ_0_0> () -> Int
+// CHECK-NEXT: function_ref F.init(g:h:)
+// CHECK-NEXT: [[F1_REF:%.*]] = function_ref @$s27stored_property_default_arg1FV1g1hACyxGx_SitcfC : $@convention(method) <τ_0_0> (@in τ_0_0, Int, @thin F<τ_0_0>.Type) -> @out F<τ_0_0>
+// CHECK-NEXT: {{.*}} = apply [[F1_REF]]<Int>({{.*}}, {{.*}}, [[H1]], {{.*}}) : $@convention(method) <τ_0_0> (@in τ_0_0, Int, @thin F<τ_0_0>.Type) -> @out F<τ_0_0>
+
+let i = F(g: 128)

test/decl/func/default-values.swift

@@ -135,3 +135,36 @@ func inoutFuncWithDefaultArg4(x: inout Int = &aLiteral) {} // expected-error {{c
 func inoutFuncWithDefaultArg5(x: inout Int = &bLiteral) {} // expected-error {{cannot provide default value to inout parameter 'x'}}
 func inoutFuncWithDefaultArg6(x: inout Int = #file) {} // expected-error {{cannot provide default value to inout parameter 'x'}}
 func inoutFuncWithDefaultArg7(_: inout Int = 1) {} // expected-error {{cannot provide default value to inout parameter '_'}}
+
+// SE-0242 - Test that memberwise constructor generates default values
+
+struct Foo {
+  var a: Int
+  var b: Bool = false
+  let c: (Int, Bool) = (1, true)
+  let d: Int
+  var (e, f) = (0, false)
+  var g: Int?
+  let h: Bool?
+
+  // The generated memberwise should look like the following:
+  // init(a: Int, b: Bool = false, d: Int, e: Int, f: Bool, g: Int? = nil, h: Bool?)
+}
+
+// Here b = false and g = nil
+let fooThing1 = Foo(a: 0, d: 1, e: 2, f: false, h: nil) // ok
+// Here g = nil
+let fooThing2 = Foo(a: 0, b: true, d: 1, e: 2, f: false, h: nil) // ok
+// Here b = false
+let fooThing3 = Foo(a: 0, d: 1, e: 2, f: false, g: 10, h: nil) // ok
+// Use all the parameters
+let fooThing4 = Foo(a: 0, b: true, d: 1, e: 2, f: false, g: 10, h: nil) // ok
+
+// Ensure that tuple init is not allowed
+// Here b = false and g = nil, but we're checking that e and f don't get a default value
+let fooThing5 = Foo(a: 0, d: 1, h: nil) // expected-error {{missing argument for parameter 'e' in call}}
+                                        // expected-note@-25 {{'init(a:b:d:e:f:g:h:)' declared here}}
+
+// Here b = false and g = nil, but we're checking that f doesn't get a default value
+let fooThing6 = Foo(a: 0, d: 1, e: 2, h: nil) // expected-error {{missing argument for parameter 'f' in call}}
+                                              // expected-note@-29 {{'init(a:b:d:e:f:g:h:)' declared here}}