@main: Enable main function to throw.

SE-0281 was accepted with the modification that the main function should
be allowed to be throwing.  Here support for enabling that is added.

Support is implemented in two steps:

(1) The $main wrapper function is modified to be throwing

static func $main() throws {
  return try main()
}

whenever the main function is throwing (it remains non-throwing when
$main is not throwing).

(2) The @main entry point is modified to be

sil [ossa] @main : $@convention(c) (Int32, UnsafeMutablePointer<Optional<UnsafeMutablePointer<Int8>>>) -> Int32 {
entry(%argc : $Int32, %argv : $UnsafeMutablePointer<Optional<UnsafeMutablePointer<Int8>>>):
  %the_main_type = metatype $@thin TheMainType.Type
  %the_main_func = function_ref @`TheMainType.main()` : $@convention(method) (@thin TheMainType.Type) -> @error Error
  try_apply %the_main_func(%the_main_type) : $@convention(method) (@thin TheMainType.Type) -> @error Error, normal success, error failure

success(%_ : $()):
  %success_code_builtin_int32 = integer_literal $Builtin.Int32, 0
  br bb1(%success_code_builtin_int32 : $Builtin.Int32)

failure(%error : @owned $Error):
  %_ = builtin "errorInMain"(%error : $Error) : $()
  end_lifetime %error : $Error
  %error_code_builtin_int32 = integer_literal $Builtin.Int32, 1
  br bb1(%error_code_builtin_int32 : $Builtin.Int32)

exit(%code_builtin_int32 : $Builtin.Int32):
  %code = struct $Int32 (%code_builtin_int32 : $Builtin.Int32)
  return %code : $Int32
}

whenever the main function is throwing (and consequently $main also is).

In the non-throwing case, (a) the try_apply instruction is replaced with an
apply instruction, (b) the body of the success block is appended to the
entry block, and (c) the success and failure blocks are removed.

Author: nate-chandler

include/swift/AST/DiagnosticsSema.def

@@ -2913,7 +2913,7 @@ NOTE(attr_ApplicationMain_script_here,none,
      ())
 
 ERROR(attr_MainType_without_main,none,
-      "%0 is annotated with @main and must provide a main static function of type () -> ().",
+      "%0 is annotated with @main and must provide a main static function of type () -> Void or () throws -> Void.",
       (DeclName))
 
 #undef SELECT_APPLICATION_MAIN

include/swift/AST/SourceFile.h

@@ -155,9 +155,6 @@ class SourceFile final : public FileUnit {
   /// The source location of the main type.
   SourceLoc MainDeclDiagLoc;
 
-  /// The main function in the type marked @main.
-  FuncDecl *MainFunc = nullptr;
-
   /// A hash of all interface-contributing tokens that have been lexed for
   /// this source file so far.
   /// We only collect interface hash for primary input files.

lib/AST/Decl.cpp

@@ -7332,7 +7332,7 @@ bool FuncDecl::isCallAsFunctionMethod() const {
 bool FuncDecl::isMainTypeMainMethod() const {
   return (getBaseIdentifier() == getASTContext().Id_main) &&
          !isInstanceMember() && getResultInterfaceType()->isVoid() &&
-         getParameters()->size() == 0 && !hasThrows();
+         getParameters()->size() == 0;
 }
 
 ConstructorDecl::ConstructorDecl(DeclName Name, SourceLoc ConstructorLoc,

lib/SILGen/SILGenFunction.cpp

@@ -725,8 +725,8 @@ void SILGenFunction::emitArtificialTopLevel(Decl *mainDecl) {
     // Emit a call to the main static function.
     // return Module.$main();
     auto *mainFunc = cast<FuncDecl>(mainDecl);
-
-    SILGenFunctionBuilder builder(SGM);
+    auto moduleLoc = RegularLocation::getModuleLocation();
+    auto *entryBlock = B.getInsertionBB();
 
     SILDeclRef mainFunctionDeclRef(mainFunc, SILDeclRef::Kind::Func);
     SILFunction *mainFunction =
@@ -743,16 +743,51 @@ void SILGenFunction::emitArtificialTopLevel(Decl *mainDecl) {
     }
     auto metatype = B.createMetatype(mainType, getLoweredType(mainType->getInterfaceType()));
 
-    auto mainFunctionRef = B.createFunctionRef(mainFunc, mainFunction);
+    auto mainFunctionRef = B.createFunctionRef(moduleLoc, mainFunction);
 
-    B.createApply(mainFunc, mainFunctionRef, SubstitutionMap(), {metatype});
+    auto builtinInt32Type = SILType::getBuiltinIntegerType(32, getASTContext());
 
-    SILValue returnValue = B.createIntegerLiteral(
-        mainFunc, SILType::getBuiltinIntegerType(32, getASTContext()), 0);
+    auto *exitBlock = createBasicBlock();
+    B.setInsertionPoint(exitBlock);
+    SILValue exitCode = exitBlock->createPhiArgument(builtinInt32Type,
+                                                     ValueOwnershipKind::None);
     auto returnType = F.getConventions().getSingleSILResultType();
-    if (returnValue->getType() != returnType)
-      returnValue = B.createStruct(mainFunc, returnType, returnValue);
-    B.createReturn(mainFunc, returnValue);
+    if (exitCode->getType() != returnType)
+      exitCode = B.createStruct(moduleLoc, returnType, exitCode);
+    B.createReturn(moduleLoc, exitCode);
+
+    if (mainFunc->hasThrows()) {
+      auto *successBlock = createBasicBlock();
+      B.setInsertionPoint(successBlock);
+      successBlock->createPhiArgument(SGM.Types.getEmptyTupleType(),
+                                      ValueOwnershipKind::None);
+      SILValue zeroReturnValue =
+          B.createIntegerLiteral(moduleLoc, builtinInt32Type, 0);
+      B.createBranch(moduleLoc, exitBlock, {zeroReturnValue});
+
+      auto *failureBlock = createBasicBlock();
+      B.setInsertionPoint(failureBlock);
+      SILValue error = failureBlock->createPhiArgument(
+          SILType::getExceptionType(getASTContext()),
+          ValueOwnershipKind::Owned);
+      // Log the error.
+      B.createBuiltin(moduleLoc, getASTContext().getIdentifier("errorInMain"),
+                      SGM.Types.getEmptyTupleType(), {}, {error});
+      B.createEndLifetime(moduleLoc, error);
+      SILValue oneReturnValue =
+          B.createIntegerLiteral(moduleLoc, builtinInt32Type, 1);
+      B.createBranch(moduleLoc, exitBlock, {oneReturnValue});
+
+      B.setInsertionPoint(entryBlock);
+      B.createTryApply(moduleLoc, mainFunctionRef, SubstitutionMap(),
+                       {metatype}, successBlock, failureBlock);
+    } else {
+      B.setInsertionPoint(entryBlock);
+      B.createApply(moduleLoc, mainFunctionRef, SubstitutionMap(), {metatype});
+      SILValue returnValue =
+          B.createIntegerLiteral(moduleLoc, builtinInt32Type, 0);
+      B.createBranch(moduleLoc, exitBlock, {returnValue});
+    }
     return;
   }
   }

lib/Sema/TypeCheckAttr.cpp

@@ -1786,14 +1786,19 @@ void AttributeChecker::visitMainTypeAttr(MainTypeAttr *attr) {
     mainFunction = viableCandidates[0];
   }
 
-  auto voidToVoidFunctionType = FunctionType::get({}, context.TheEmptyTupleType);
+  bool mainFunctionThrows = mainFunction->hasThrows();
+
+  auto voidToVoidFunctionType =
+      FunctionType::get({}, context.TheEmptyTupleType,
+                        FunctionType::ExtInfo().withThrows(mainFunctionThrows));
   auto nominalToVoidToVoidFunctionType = FunctionType::get({AnyFunctionType::Param(nominal->getInterfaceType())}, voidToVoidFunctionType);
   auto *func = FuncDecl::create(
-      context, /*StaticLoc*/ braces.End, StaticSpellingKind::KeywordStatic,
-      /*FuncLoc*/ location,
+      context, /*StaticLoc*/ SourceLoc(), StaticSpellingKind::KeywordStatic,
+      /*FuncLoc*/ SourceLoc(),
       DeclName(context, DeclBaseName(context.Id_MainEntryPoint),
                ParameterList::createEmpty(context)),
-      /*NameLoc*/ braces.End, /*Throws=*/false, /*ThrowsLoc=*/SourceLoc(),
+      /*NameLoc*/ SourceLoc(), /*Throws=*/mainFunctionThrows,
+      /*ThrowsLoc=*/SourceLoc(),
       /*GenericParams=*/nullptr, ParameterList::createEmpty(context),
       /*FnRetType=*/TypeLoc::withoutLoc(TupleType::getEmpty(context)),
       declContext);
@@ -1821,12 +1826,23 @@ void AttributeChecker::visitMainTypeAttr(MainTypeAttr *attr) {
   auto *dotSyntaxCallExpr = new (context) DotSyntaxCallExpr(
       funcDeclRefExpr, /*DotLoc*/ SourceLoc(), typeExpr, voidToVoidFunctionType);
   dotSyntaxCallExpr->setImplicit(true);
-  dotSyntaxCallExpr->setThrows(false);
+  dotSyntaxCallExpr->setThrows(mainFunctionThrows);
 
   auto *callExpr = CallExpr::createImplicit(context, dotSyntaxCallExpr, {}, {});
   callExpr->setImplicit(true);
-  callExpr->setThrows(false);
+  callExpr->setThrows(mainFunctionThrows);
   callExpr->setType(context.TheEmptyTupleType);
+
+  Expr *returnedExpr;
+
+  if (mainFunctionThrows) {
+    auto *tryExpr = new (context) TryExpr(
+        SourceLoc(), callExpr, context.TheEmptyTupleType, /*implicit=*/true);
+    returnedExpr = tryExpr;
+  } else {
+    returnedExpr = callExpr;
+  }
+
   auto *returnStmt =
       new (context) ReturnStmt(SourceLoc(), callExpr, /*Implicit=*/true);
 

test/attr/ApplicationMain/attr_main_arguments.swift

@@ -1,6 +1,6 @@
 // RUN: %target-swift-frontend -typecheck -parse-as-library -verify %s
 
-@main // expected-error{{'MyBase' is annotated with @main and must provide a main static function of type () -> ().}}
+@main // expected-error{{'MyBase' is annotated with @main and must provide a main static function}}
 struct MyBase {
   static func main(_ argc: Int, _ argv: [String]) {
   }

test/attr/ApplicationMain/attr_main_dynamicCallable.swift

@@ -1,6 +1,6 @@
 // RUN: %target-swift-frontend -typecheck -parse-as-library -verify %s
 
-@main // expected-error{{'Foo' is annotated with @main and must provide a main static function of type () -> ().}}
+@main // expected-error{{'Foo' is annotated with @main and must provide a main static function}}
 struct Foo {
   @dynamicCallable
   struct main {

test/attr/ApplicationMain/attr_main_dynamicMemberLookup.swift

@@ -1,6 +1,6 @@
 // RUN: %target-swift-frontend -typecheck -parse-as-library -verify %s
 
-@main @dynamicMemberLookup // expected-error{{'Main' is annotated with @main and must provide a main static function of type () -> ().}}
+@main @dynamicMemberLookup // expected-error{{'Main' is annotated with @main and must provide a main static function}}
 struct Main {
     subscript(dynamicMember member: String) -> () -> Void {
         return {

test/attr/ApplicationMain/attr_main_extension_nofunc.swift

@@ -3,7 +3,7 @@
 class EntryPoint {
 }
 
-@main // expected-error{{'EntryPoint' is annotated with @main and must provide a main static function of type () -> ()}}
+@main // expected-error{{'EntryPoint' is annotated with @main and must provide a main static function}}
 extension EntryPoint {
 }
 

test/attr/ApplicationMain/attr_main_instance.swift

@@ -1,6 +1,6 @@
 // RUN: %target-swift-frontend -typecheck -parse-as-library -verify %s
 
-@main // expected-error{{'MyBase' is annotated with @main and must provide a main static function of type () -> ().}}
+@main // expected-error{{'MyBase' is annotated with @main and must provide a main static function}}
 class MyBase {
   func main() {
   }

test/attr/ApplicationMain/attr_main_resolves_types_nonthrowing.swift

@@ -0,0 +1,22 @@
+// RUN: %target-run-simple-swift(-parse-as-library) | %FileCheck %s
+// REQUIRES: executable_test
+
+protocol P {
+}
+extension P {
+    static func main() throws {
+        print("P.main")
+    }
+}
+struct S {
+    static func main() {
+        print("S.main")
+    }
+}
+
+// CHECK: S.main
+@main
+extension S : P {}
+
+
+

test/attr/ApplicationMain/attr_main_resolves_types_nonthrowing_2.swift

@@ -0,0 +1,20 @@
+// RUN: %target-run-simple-swift(-parse-as-library) | %FileCheck %s
+// REQUIRES: executable_test
+
+protocol P {
+}
+extension P {
+    static func main() {
+        print("P.main")
+    }
+}
+struct S {
+    static func main() {
+        print("S.main though neither throw")
+    }
+}
+
+// CHECK: S.main though neither throw
+@main
+extension S : P {}
+

test/attr/ApplicationMain/attr_main_resolves_types_throws.swift

@@ -0,0 +1,20 @@
+// RUN: %target-run-simple-swift(-parse-as-library) | %FileCheck %s
+// REQUIRES: executable_test
+
+protocol P {
+}
+extension P {
+    static func main() {
+        print("P.main")
+    }
+}
+struct S {
+    static func main() throws {
+        print("S.main though throwing")
+    }
+}
+
+// CHECK: S.main though throwing
+@main
+extension S : P {}
+

test/attr/ApplicationMain/attr_main_resolves_types_throws_2.swift

@@ -0,0 +1,21 @@
+// RUN: %target-run-simple-swift(-parse-as-library) | %FileCheck %s
+// REQUIRES: executable_test
+
+protocol P {
+}
+extension P {
+    static func main() throws {
+        print("P.main")
+    }
+}
+struct S {
+    static func main() throws {
+        print("S.main though both throw")
+    }
+}
+
+// CHECK: S.main though both throw
+@main
+extension S : P {}
+
+

test/attr/ApplicationMain/attr_main_return.swift

@@ -1,6 +1,6 @@
 // RUN: %target-swift-frontend -typecheck -parse-as-library -verify %s
 
-@main // expected-error{{'MyBase' is annotated with @main and must provide a main static function of type () -> ().}}
+@main // expected-error{{'MyBase' is annotated with @main and must provide a main static function}}
 struct MyBase {
   static func main() -> Int {
   }

test/attr/ApplicationMain/attr_main_throws.swift

@@ -1,6 +1,6 @@
 // RUN: %target-swift-frontend -typecheck -parse-as-library -verify %s
 
-@main // expected-error{{'MyBase' is annotated with @main and must provide a main static function of type () -> ().}}
+@main
 struct MyBase {
   static func main() throws { 
   }

test/attr/ApplicationMain/attr_main_throws_prints_error.swift

@@ -0,0 +1,16 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-build-swift -parse-as-library %s -o %t/main
+// RUN: %target-codesign %t/main
+// RUN: not --crash %t/main 2>&1 | %FileCheck %s
+// REQUIRES: executable_test
+// REQUIRES: OS=macosx
+
+enum Err : Error { case or }
+
+// CHECK: Fatal error: Error raised at top level: main.Err.or:
+@main
+struct S {
+    static func main() throws {
+        throw Err.or
+    }
+}