Check default arguments even if a function has no body

This is needed for textual interfaces, but the behavior doesn't
have to be specific to that, since functions without bodies don't
come up in other situations.

Author: jrose-apple

lib/Sema/TypeCheckDecl.cpp

@@ -3131,12 +3131,12 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
       }
     }
 
-    if (FD->hasBody()) {
-      // Record the body.
-      TC.definedFunctions.push_back(FD);
-    } else if (requiresDefinition(FD)) {
+    if (requiresDefinition(FD) && !FD->hasBody()) {
       // Complain if we should have a body.
       TC.diagnose(FD->getLoc(), diag::func_decl_without_brace);
+    } else {
+      // Record the body.
+      TC.definedFunctions.push_back(FD);
     }
   }
 
@@ -3362,20 +3362,18 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     AccessControlChecker::checkAccessControl(TC, CD);
     UsableFromInlineChecker::checkUsableFromInline(TC, CD);
 
-    if (CD->hasBody() && !CD->isMemberwiseInitializer()) {
-      TC.definedFunctions.push_back(CD);
-    } else if (requiresDefinition(CD)) {
+    if (requiresDefinition(CD) && !CD->hasBody()) {
       // Complain if we should have a body.
       TC.diagnose(CD->getLoc(), diag::missing_initializer_def);
+    } else {
+      TC.definedFunctions.push_back(CD);
     }
   }
 
   void visitDestructorDecl(DestructorDecl *DD) {
     TC.validateDecl(DD);
     TC.checkDeclAttributes(DD);
-
-    if (DD->hasBody())
-      TC.definedFunctions.push_back(DD);
+    TC.definedFunctions.push_back(DD);
   }
 };
 } // end anonymous namespace

lib/Sema/TypeCheckStmt.cpp

@@ -1533,6 +1533,7 @@ void TypeChecker::checkDefaultArguments(ParameterList *params,
 bool TypeChecker::typeCheckAbstractFunctionBodyUntil(AbstractFunctionDecl *AFD,
                                                      SourceLoc EndTypeCheckLoc) {
   validateDecl(AFD);
+  checkDefaultArguments(AFD->getParameters(), AFD);
 
   if (!AFD->getBody())
     return false;
@@ -1554,9 +1555,6 @@ bool TypeChecker::typeCheckAbstractFunctionBody(AbstractFunctionDecl *AFD) {
   if (AFD->isBodyTypeChecked())
     return false;
 
-  if (!AFD->getBody())
-    return false;
-
   FrontendStatsTracer StatsTracer(Context.Stats, "typecheck-fn", AFD);
   PrettyStackTraceDecl StackEntry("type-checking", AFD);
 
@@ -1575,17 +1573,16 @@ bool TypeChecker::typeCheckAbstractFunctionBody(AbstractFunctionDecl *AFD) {
   if (error)
     return true;
 
-  performAbstractFuncDeclDiagnostics(*this, AFD);
+  if (AFD->getBody())
+    performAbstractFuncDeclDiagnostics(*this, AFD);
+
   return false;
 }
 
 // Type check a function body (defined with the func keyword) that is either a
 // named function or an anonymous func expression.
 bool TypeChecker::typeCheckFunctionBodyUntil(FuncDecl *FD,
                                              SourceLoc EndTypeCheckLoc) {
-  // Check the default argument definitions.
-  checkDefaultArguments(FD->getParameters(), FD);
-
   // Clang imported inline functions do not have a Swift body to
   // typecheck.
   if (FD->getClangDecl())
@@ -1688,12 +1685,8 @@ static bool isKnownEndOfConstructor(ASTNode N) {
 
 bool TypeChecker::typeCheckConstructorBodyUntil(ConstructorDecl *ctor,
                                                 SourceLoc EndTypeCheckLoc) {
-  // Check the default argument definitions.
-  checkDefaultArguments(ctor->getParameters(), ctor);
-
   BraceStmt *body = ctor->getBody();
-  if (!body)
-    return true;
+  assert(body);
 
   // For constructors, we make sure that the body ends with a "return" stmt,
   // which we either implicitly synthesize, or the user can write.  This
@@ -1822,8 +1815,7 @@ bool TypeChecker::typeCheckDestructorBodyUntil(DestructorDecl *DD,
   StmtChecker SC(*this, static_cast<AbstractFunctionDecl *>(DD));
   SC.EndTypeCheckLoc = EndTypeCheckLoc;
   BraceStmt *Body = DD->getBody();
-  if (!Body)
-    return false;
+  assert(Body);
 
   bool HadError = SC.typeCheckBody(Body);
 

test/ModuleInterface/DefaultArgs.swiftinterface

@@ -0,0 +1,22 @@
+// RUN: %target-swift-frontend -emit-silgen %s | %FileCheck %s
+
+class SomeClass {
+  // Has defaults, but no body.
+  public func hasDefaults(a: Int = 4, b: Int = 1 + 2)
+
+  // CHECK-LABEL: sil hidden @$S11DefaultArgs9SomeClassC11hasDefaults1a1bySi_SitFfA_
+  // CHECK: integer_literal $Builtin.Int2048, 4
+  // CHECK: end sil function '$S11DefaultArgs9SomeClassC11hasDefaults1a1bySi_SitFfA_'
+
+  // CHECK-LABEL: sil hidden @$S11DefaultArgs9SomeClassC11hasDefaults1a1bySi_SitFfA0_
+  // CHECK: integer_literal $Builtin.Int2048, 1
+  // CHECK: integer_literal $Builtin.Int2048, 2
+  // CHECK: function_ref @$SSi1poiyS2i_SitFZ
+  // CHECK: end sil function '$S11DefaultArgs9SomeClassC11hasDefaults1a1bySi_SitFfA0_'
+
+  public init(a: Int = 5)
+
+  // CHECK-LABEL: sil hidden @$S11DefaultArgs9SomeClassC1aACSi_tcfcfA_
+  // CHECK: integer_literal $Builtin.Int2048, 5
+  // CHECK: end sil function '$S11DefaultArgs9SomeClassC1aACSi_tcfcfA_'
+}