@main: Added $main func to @main type.

Previously, the function was being added to the list of top level decls
in the source file as that list was being iterated, leading to iterator
issues.

Here, the function is instead added to the nominal type decl which is
decorated with @main.  Doing so requires calling the $main function with
the metatype for the nominal type.

The workaround for the iterator invalidation issue which had been
applied previously, namely changing the type of the Decls member of
SourceFile from std::vector<Decl *> to SmallVector<Decl *, 16> is
reverted.

Author: nate-chandler

lib/SILGen/SILGenFunction.cpp

@@ -732,9 +732,12 @@ void SILGenFunction::emitArtificialTopLevel(Decl *mainDecl) {
     SILFunction *mainFunction =
         SGM.getFunction(mainFunctionDeclRef, NotForDefinition);
 
+    NominalTypeDecl *mainType = cast<NominalTypeDecl>(mainFunc->getDeclContext());
+    auto metatype = B.createMetatype(mainType, getLoweredType(mainType->getInterfaceType()));
+
     auto mainFunctionRef = B.createFunctionRef(mainFunc, mainFunction);
 
-    B.createApply(mainFunc, mainFunctionRef, SubstitutionMap(), {});
+    B.createApply(mainFunc, mainFunctionRef, SubstitutionMap(), {metatype});
 
     SILValue returnValue = B.createIntegerLiteral(
         mainFunc, SILType::getBuiltinIntegerType(32, getASTContext()), 0);

lib/Sema/TypeCheckAttr.cpp

@@ -1767,18 +1767,18 @@ void AttributeChecker::visitMainTypeAttr(MainTypeAttr *attr) {
   }
 
   auto voidToVoidFunctionType = FunctionType::get({}, context.TheEmptyTupleType);
+  auto nominalToVoidToVoidFunctionType = FunctionType::get({AnyFunctionType::Param(nominal->getInterfaceType())}, voidToVoidFunctionType);
   auto *func = FuncDecl::create(
-      context, /*StaticLoc*/ SourceLoc(), StaticSpellingKind::None,
+      context, /*StaticLoc*/ nominal->getBraces().End, StaticSpellingKind::KeywordStatic,
       /*FuncLoc*/ location,
       DeclName(context, DeclBaseName(context.Id_MainEntryPoint),
                ParameterList::createEmpty(context)),
-      /*NameLoc*/ SourceLoc(), /*Throws=*/false, /*ThrowsLoc=*/SourceLoc(),
+      /*NameLoc*/ nominal->getBraces().End, /*Throws=*/false, /*ThrowsLoc=*/SourceLoc(),
       /*GenericParams=*/nullptr, ParameterList::createEmpty(context),
       /*FnRetType=*/TypeLoc::withoutLoc(TupleType::getEmpty(context)),
-      nominal->getParentSourceFile());
+      nominal);
   func->setImplicit(true);
   func->setSynthesized(true);
-  func->setInterfaceType(voidToVoidFunctionType);
 
   auto *typeExpr = TypeExpr::createImplicit(nominal->getDeclaredType(), context);
 
@@ -1815,9 +1815,9 @@ void AttributeChecker::visitMainTypeAttr(MainTypeAttr *attr) {
   auto *body = BraceStmt::create(context, SourceLoc(), stmts,
                                 SourceLoc(), /*Implicit*/true);
   func->setBodyParsed(body);
-  func->setInterfaceType(voidToVoidFunctionType);
+  func->setInterfaceType(nominalToVoidToVoidFunctionType);
 
-  nominal->getParentSourceFile()->addTopLevelDecl(func);
+  nominal->addMember(func);
   // This function must be type-checked. Why?  Consider the following scenario:
   //
   //     protocol AlmostMainable {}