Check '= super' is actually parsed correctly in module interfaces via an execution test

Also pass the decls themselves rather than their locations when diagnosing
incorrect usage of '= super'.

Author: Nathan Hawes

lib/Sema/TypeCheckStmt.cpp

@@ -1760,19 +1760,17 @@ checkInheritedDefaultValueRestrictions(TypeChecker &TC, ParamDecl *PD) {
   auto ctor = dyn_cast<ConstructorDecl>(DC);
   if (!ctor || ctor->isConvenienceInit()) {
     TC.diagnose(
-        PD->getLoc(),
-        diag::inherited_default_value_not_in_designated_constructor);
+        PD, diag::inherited_default_value_not_in_designated_constructor);
     return;
   }
 
   // The decl it overrides should also be a designated initializer.
   auto overridden = ctor->getOverriddenDecl();
   if (!overridden || overridden->isConvenienceInit()) {
     TC.diagnose(
-        PD->getLoc(),
-        diag::inherited_default_value_used_in_non_overriding_constructor);
+        PD, diag::inherited_default_value_used_in_non_overriding_constructor);
     if (overridden)
-      TC.diagnose(overridden->getLoc(), diag::overridden_here);
+      TC.diagnose(overridden, diag::overridden_here);
     return;
   }
 
@@ -1781,8 +1779,8 @@ checkInheritedDefaultValueRestrictions(TypeChecker &TC, ParamDecl *PD) {
   assert(idx && "containing decl does not contain param?");
   ParamDecl *equivalentParam = overridden->getParameters()->get(*idx);
   if (equivalentParam->getDefaultArgumentKind() == DefaultArgumentKind::None) {
-    TC.diagnose(PD->getLoc(), diag::corresponding_param_not_defaulted);
-    TC.diagnose(equivalentParam->getLoc(), diag::inherited_default_param_here);
+    TC.diagnose(PD, diag::corresponding_param_not_defaulted);
+    TC.diagnose(equivalentParam, diag::inherited_default_param_here);
   }
 }
 

test/ParseableInterface/inherited-defaults-execution.swift

@@ -0,0 +1,47 @@
+// REQUIRES: executable_test
+// RUN: %empty-directory(%t)
+
+// 1) Build the 'Inherited' library and its interface from this file
+//
+// RUN: %target-build-swift-dylib(%t/%target-library-name(Inherited)) -emit-module-path %t/Inherited.swiftmodule -emit-parseable-module-interface-path %t/Inherited.swiftinterface -module-name Inherited %s
+// RUN: rm %t/Inherited.swiftmodule
+
+// 2) Check the interface includes the synthesized initializers of the base
+//    class in the derived class explicitly and uses the '= super' syntax to
+//    inherit its default arguments.
+//
+// RUN: cat %t/Inherited.swiftinterface | %FileCheck --check-prefix=INTERFACE %s
+//
+// INTERFACE: public class Base {
+// INTERFACE:   public init(x: Swift.Int = 45, y: Swift.Int = 98)
+// INTERFACE: }
+// INTERFACE: public class Derived : Inherited.Base {
+// INTERFACE:   override public init(x: Swift.Int = super, y: Swift.Int = super)
+// INTERFACE: }
+
+// 4) Generate a main.swift file that uses the 'Inherited' library and makes use
+//    of the inherited default arguments
+//
+// RUN: echo "import Inherited" > %t/main.swift
+// RUN: echo "print(Derived().x)" >> %t/main.swift
+// RUN: echo "print(Derived().y)" >> %t/main.swift
+
+// 5) Build and run the executable, checking the defaulted arguments resulted in
+//    the correct values being stored
+//
+// RUN: %target-build-swift -I%t -L%t -lInherited -o %t/main %target-rpath(%t) %t/main.swift -swift-version 5
+// RUN: %target-codesign %t/main %t/%target-library-name(Inherited)
+// RUN: %target-run %t/main | %FileCheck --check-prefix=OUTPUT %s
+//
+// OUTPUT: 45
+// OUTPUT-NEXT: 98
+
+public class Base {
+  public let x: Int
+  public let y: Int
+  public init(x: Int = 45, y: Int = 98) {
+    self.x = x
+    self.y = y
+  }
+}
+public class Derived: Base {}