Auto merge of #46479 - bkchr:termination_trait, r=arielb1

Implements RFC 1937: `?` in `main`

This is the first part of the RFC 1937 that supports new
`Termination` trait in the rust `main` function.

Thanks @nikomatsakis, @arielb1 and all other people in the gitter channel for all your help!

The support for doctest and `#[test]` is still missing, bu as @nikomatsakis said, smaller pull requests are better :)

src/test/codegen-units/item-collection/cross-crate-closures.rs

@@ -17,12 +17,14 @@
 // compile-flags:-Zprint-trans-items=eager
 
 #![deny(dead_code)]
+#![feature(start)]
 
 // aux-build:cgu_extern_closures.rs
 extern crate cgu_extern_closures;
 
-//~ TRANS_ITEM fn cross_crate_closures::main[0]
-fn main() {
+//~ TRANS_ITEM fn cross_crate_closures::start[0]
+#[start]
+fn start(_: isize, _: *const *const u8) -> isize {
 
     //~ TRANS_ITEM fn cgu_extern_closures::inlined_fn[0]
     //~ TRANS_ITEM fn cgu_extern_closures::inlined_fn[0]::{{closure}}[0]
@@ -35,6 +37,8 @@ fn main() {
     // Nothing should be generated for this call, we just link to the instance
     // in the extern crate.
     let _ = cgu_extern_closures::non_inlined_fn(6, 7);
+
+    0
 }
 
 //~ TRANS_ITEM drop-glue i8

src/test/codegen-units/item-collection/cross-crate-generic-functions.rs

@@ -12,13 +12,14 @@
 // compile-flags:-Zprint-trans-items=eager
 
 #![deny(dead_code)]
+#![feature(start)]
 
 // aux-build:cgu_generic_function.rs
 extern crate cgu_generic_function;
 
-//~ TRANS_ITEM fn cross_crate_generic_functions::main[0]
-fn main()
-{
+//~ TRANS_ITEM fn cross_crate_generic_functions::start[0]
+#[start]
+fn start(_: isize, _: *const *const u8) -> isize {
     //~ TRANS_ITEM fn cgu_generic_function::bar[0]<u32>
     //~ TRANS_ITEM fn cgu_generic_function::foo[0]<u32>
     let _ = cgu_generic_function::foo(1u32);
@@ -29,4 +30,6 @@ fn main()
 
     // This should not introduce a codegen item
     let _ = cgu_generic_function::exported_but_not_generic(3);
+
+    0
 }

src/test/codegen-units/item-collection/cross-crate-trait-method.rs

@@ -12,15 +12,16 @@
 // compile-flags:-Zprint-trans-items=eager
 
 #![deny(dead_code)]
+#![feature(start)]
 
 // aux-build:cgu_export_trait_method.rs
 extern crate cgu_export_trait_method;
 
 use cgu_export_trait_method::Trait;
 
-//~ TRANS_ITEM fn cross_crate_trait_method::main[0]
-fn main()
-{
+//~ TRANS_ITEM fn cross_crate_trait_method::start[0]
+#[start]
+fn start(_: isize, _: *const *const u8) -> isize {
     // The object code of these methods is contained in the external crate, so
     // calling them should *not* introduce codegen items in the current crate.
     let _: (u32, u32) = Trait::without_default_impl(0);
@@ -55,4 +56,6 @@ fn main()
     let _: (char, char) = Trait::without_default_impl_generic('c');
     //~ TRANS_ITEM fn cgu_export_trait_method::{{impl}}[0]::without_default_impl_generic[0]<bool>
     let _: (char, bool) = Trait::without_default_impl_generic(false);
+
+    0
 }

src/test/codegen-units/item-collection/drop_in_place_intrinsic.rs

@@ -12,6 +12,8 @@
 // compile-flags:-Zprint-trans-items=eager
 // compile-flags:-Zinline-in-all-cgus
 
+#![feature(start)]
+
 //~ TRANS_ITEM fn core::ptr[0]::drop_in_place[0]<drop_in_place_intrinsic::StructWithDtor[0]> @@ drop_in_place_intrinsic0[Internal]
 struct StructWithDtor(u32);
 
@@ -20,13 +22,16 @@ impl Drop for StructWithDtor {
     fn drop(&mut self) {}
 }
 
-//~ TRANS_ITEM fn drop_in_place_intrinsic::main[0]
-fn main() {
+//~ TRANS_ITEM fn drop_in_place_intrinsic::start[0]
+#[start]
+fn start(_: isize, _: *const *const u8) -> isize {
 
     //~ TRANS_ITEM fn core::ptr[0]::drop_in_place[0]<[drop_in_place_intrinsic::StructWithDtor[0]; 2]> @@ drop_in_place_intrinsic0[Internal]
     let x = [StructWithDtor(0), StructWithDtor(1)];
 
     drop_slice_in_place(&x);
+
+    0
 }
 
 //~ TRANS_ITEM fn drop_in_place_intrinsic::drop_slice_in_place[0]

src/test/codegen-units/item-collection/function-as-argument.rs

@@ -12,6 +12,7 @@
 // compile-flags:-Zprint-trans-items=eager
 
 #![deny(dead_code)]
+#![feature(start)]
 
 fn take_fn_once<T1, T2, F: FnOnce(T1, T2)>(f: F, x: T1, y: T2) {
     (f)(x, y)
@@ -23,8 +24,9 @@ fn take_fn_pointer<T1, T2>(f: fn(T1, T2), x: T1, y: T2) {
     (f)(x, y)
 }
 
-//~ TRANS_ITEM fn function_as_argument::main[0]
-fn main() {
+//~ TRANS_ITEM fn function_as_argument::start[0]
+#[start]
+fn start(_: isize, _: *const *const u8) -> isize {
 
     //~ TRANS_ITEM fn function_as_argument::take_fn_once[0]<u32, &str, fn(u32, &str)>
     //~ TRANS_ITEM fn function_as_argument::function[0]<u32, &str>
@@ -43,4 +45,6 @@ fn main() {
     //~ TRANS_ITEM fn function_as_argument::take_fn_pointer[0]<f32, i64>
     //~ TRANS_ITEM fn function_as_argument::function[0]<f32, i64>
     take_fn_pointer(function, 0f32, 0i64);
+
+    0
 }

src/test/codegen-units/item-collection/generic-drop-glue.rs

@@ -13,6 +13,7 @@
 // compile-flags:-Zinline-in-all-cgus
 
 #![deny(dead_code)]
+#![feature(start)]
 
 struct StructWithDrop<T1, T2> {
     x: T1,
@@ -53,8 +54,9 @@ impl Drop for NonGenericWithDrop {
     fn drop(&mut self) {}
 }
 
-//~ TRANS_ITEM fn generic_drop_glue::main[0]
-fn main() {
+//~ TRANS_ITEM fn generic_drop_glue::start[0]
+#[start]
+fn start(_: isize, _: *const *const u8) -> isize {
     //~ TRANS_ITEM fn core::ptr[0]::drop_in_place[0]<generic_drop_glue::StructWithDrop[0]<i8, char>> @@ generic_drop_glue0[Internal]
     //~ TRANS_ITEM fn generic_drop_glue::{{impl}}[0]::drop[0]<i8, char>
     let _ = StructWithDrop { x: 0i8, y: 'a' }.x;
@@ -94,4 +96,6 @@ fn main() {
         EnumNoDrop::A(x) => x,
         EnumNoDrop::B(x) => x as f64
     };
+
+    0
 }

src/test/codegen-units/item-collection/generic-functions.rs

@@ -12,6 +12,7 @@
 // compile-flags:-Zprint-trans-items=eager
 
 #![deny(dead_code)]
+#![feature(start)]
 
 fn foo1<T1>(a: T1) -> (T1, u32) {
     (a, 1)
@@ -31,8 +32,9 @@ pub fn lifetime_only<'a>(a: &'a u32) -> &'a u32 {
     a
 }
 
-//~ TRANS_ITEM fn generic_functions::main[0]
-fn main() {
+//~ TRANS_ITEM fn generic_functions::start[0]
+#[start]
+fn start(_: isize, _: *const *const u8) -> isize {
     //~ TRANS_ITEM fn generic_functions::foo1[0]<i32>
     let _ = foo1(2i32);
     //~ TRANS_ITEM fn generic_functions::foo1[0]<i64>
@@ -59,4 +61,6 @@ fn main() {
     let _ = foo3(0i16, "a", 2usize);
     //~ TRANS_ITEM fn generic_functions::foo3[0]<char, (), ()>
     let _ = foo3('v', (), ());
+
+    0
 }

src/test/codegen-units/item-collection/generic-impl.rs

@@ -12,6 +12,7 @@
 // compile-flags:-Zprint-trans-items=eager
 
 #![deny(dead_code)]
+#![feature(start)]
 
 struct Struct<T> {
     x: T,
@@ -50,9 +51,9 @@ impl<'a> LifeTimeOnly<'a> {
     pub fn non_instantiated<T>(&self) {}
 }
 
-
-//~ TRANS_ITEM fn generic_impl::main[0]
-fn main() {
+//~ TRANS_ITEM fn generic_impl::start[0]
+#[start]
+fn start(_: isize, _: *const *const u8) -> isize {
     //~ TRANS_ITEM fn generic_impl::{{impl}}[0]::new[0]<i32>
     //~ TRANS_ITEM fn generic_impl::id[0]<i32>
     //~ TRANS_ITEM fn generic_impl::{{impl}}[0]::get[0]<i32, i16>
@@ -76,4 +77,6 @@ fn main() {
     //~ TRANS_ITEM fn generic_impl::{{impl}}[0]::new[0]<generic_impl::Struct[0]<&str>>
     //~ TRANS_ITEM fn generic_impl::id[0]<generic_impl::Struct[0]<&str>>
     let _ = (Struct::new(Struct::new("str")).f)(Struct::new("str"));
+
+    0
 }

src/test/codegen-units/item-collection/impl-in-non-instantiated-generic.rs

@@ -12,6 +12,7 @@
 // compile-flags:-Zprint-trans-items=eager
 
 #![deny(dead_code)]
+#![feature(start)]
 
 trait SomeTrait {
     fn foo(&self);
@@ -28,7 +29,10 @@ pub fn generic_function<T>(x: T) -> (T, i32) {
     (x, 0)
 }
 
-//~ TRANS_ITEM fn impl_in_non_instantiated_generic::main[0]
-fn main() {
+//~ TRANS_ITEM fn impl_in_non_instantiated_generic::start[0]
+#[start]
+fn start(_: isize, _: *const *const u8) -> isize {
     0i64.foo();
+
+    0
 }

src/test/codegen-units/item-collection/instantiation-through-vtable.rs

@@ -13,6 +13,7 @@
 // compile-flags:-Zinline-in-all-cgus
 
 #![deny(dead_code)]
+#![feature(start)]
 
 trait Trait {
     fn foo(&self) -> u32;
@@ -28,8 +29,9 @@ impl<T> Trait for Struct<T> {
     fn bar(&self) {}
 }
 
-//~ TRANS_ITEM fn instantiation_through_vtable::main[0]
-fn main() {
+//~ TRANS_ITEM fn instantiation_through_vtable::start[0]
+#[start]
+fn start(_: isize, _: *const *const u8) -> isize {
     let s1 = Struct { _a: 0u32 };
 
     //~ TRANS_ITEM fn core::ptr[0]::drop_in_place[0]<instantiation_through_vtable::Struct[0]<u32>> @@ instantiation_through_vtable0[Internal]
@@ -42,4 +44,6 @@ fn main() {
     //~ TRANS_ITEM fn instantiation_through_vtable::{{impl}}[0]::foo[0]<u64>
     //~ TRANS_ITEM fn instantiation_through_vtable::{{impl}}[0]::bar[0]<u64>
     let _ = &s1 as &Trait;
+
+    0
 }

src/test/codegen-units/item-collection/items-within-generic-items.rs

@@ -12,6 +12,7 @@
 // compile-flags:-Zprint-trans-items=eager
 
 #![deny(dead_code)]
+#![feature(start)]
 
 fn generic_fn<T>(a: T) -> (T, i32) {
     //~ TRANS_ITEM fn items_within_generic_items::generic_fn[0]::nested_fn[0]
@@ -31,12 +32,15 @@ fn generic_fn<T>(a: T) -> (T, i32) {
     return (a, x + nested_fn(0));
 }
 
-//~ TRANS_ITEM fn items_within_generic_items::main[0]
-fn main() {
+//~ TRANS_ITEM fn items_within_generic_items::start[0]
+#[start]
+fn start(_: isize, _: *const *const u8) -> isize {
     //~ TRANS_ITEM fn items_within_generic_items::generic_fn[0]<i64>
     let _ = generic_fn(0i64);
     //~ TRANS_ITEM fn items_within_generic_items::generic_fn[0]<u16>
     let _ = generic_fn(0u16);
     //~ TRANS_ITEM fn items_within_generic_items::generic_fn[0]<i8>
     let _ = generic_fn(0i8);
+
+    0
 }

src/test/codegen-units/item-collection/non-generic-closures.rs

@@ -17,6 +17,7 @@
 // compile-flags:-Zprint-trans-items=eager
 
 #![deny(dead_code)]
+#![feature(start)]
 
 //~ TRANS_ITEM fn non_generic_closures::temporary[0]
 fn temporary() {
@@ -52,12 +53,15 @@ fn assigned_to_variable_executed_directly() {
     f(4);
 }
 
-//~ TRANS_ITEM fn non_generic_closures::main[0]
-fn main() {
+//~ TRANS_ITEM fn non_generic_closures::start[0]
+#[start]
+fn start(_: isize, _: *const *const u8) -> isize {
     temporary();
     assigned_to_variable_but_not_executed();
     assigned_to_variable_executed_directly();
     assigned_to_variable_executed_indirectly();
+
+    0
 }
 
 //~ TRANS_ITEM fn non_generic_closures::run_closure[0]

src/test/codegen-units/item-collection/non-generic-drop-glue.rs

@@ -13,6 +13,7 @@
 // compile-flags:-Zinline-in-all-cgus
 
 #![deny(dead_code)]
+#![feature(start)]
 
 //~ TRANS_ITEM fn core::ptr[0]::drop_in_place[0]<non_generic_drop_glue::StructWithDrop[0]> @@ non_generic_drop_glue0[Internal]
 struct StructWithDrop {
@@ -42,8 +43,9 @@ enum EnumNoDrop {
     A(i32)
 }
 
-//~ TRANS_ITEM fn non_generic_drop_glue::main[0]
-fn main() {
+//~ TRANS_ITEM fn non_generic_drop_glue::start[0]
+#[start]
+fn start(_: isize, _: *const *const u8) -> isize {
     let _ = StructWithDrop { x: 0 }.x;
     let _ = StructNoDrop { x: 0 }.x;
     let _ = match EnumWithDrop::A(0) {
@@ -52,4 +54,6 @@ fn main() {
     let _ = match EnumNoDrop::A(0) {
         EnumNoDrop::A(x) => x
     };
+
+    0
 }

src/test/codegen-units/item-collection/non-generic-functions.rs

@@ -12,6 +12,7 @@
 // compile-flags:-Zprint-trans-items=eager
 
 #![deny(dead_code)]
+#![feature(start)]
 
 //~ TRANS_ITEM fn non_generic_functions::foo[0]
 fn foo() {
@@ -69,11 +70,14 @@ impl Struct {
     }
 }
 
-//~ TRANS_ITEM fn non_generic_functions::main[0]
-fn main() {
+//~ TRANS_ITEM fn non_generic_functions::start[0]
+#[start]
+fn start(_: isize, _: *const *const u8) -> isize {
     foo();
     bar();
     Struct::foo();
     let x = Struct { _x: 0 };
     x.bar();
+
+    0
 }

src/test/codegen-units/item-collection/static-init.rs

@@ -9,6 +9,9 @@
 // except according to those terms.
 
 // compile-flags:-Zprint-trans-items=eager
+// ignore-tidy-linelength
+
+#![feature(start)]
 
 pub static FN : fn() = foo::<i32>;
 
@@ -17,6 +20,9 @@ pub fn foo<T>() { }
 //~ TRANS_ITEM fn static_init::foo[0]<i32>
 //~ TRANS_ITEM static static_init::FN[0]
 
-fn main() { }
+//~ TRANS_ITEM fn static_init::start[0]
+#[start]
+fn start(_: isize, _: *const *const u8) -> isize {
+    0
+}
 
-//~ TRANS_ITEM fn static_init::main[0]

src/test/codegen-units/item-collection/statics-and-consts.rs

@@ -12,6 +12,7 @@
 // compile-flags:-Zprint-trans-items=eager
 
 #![deny(dead_code)]
+#![feature(start)]
 
 static STATIC1: i64 = {
     const STATIC1_CONST1: i64 = 2;
@@ -47,9 +48,13 @@ fn foo() {
     };
 }
 
-fn main() {
+//~ TRANS_ITEM fn statics_and_consts::start[0]
+#[start]
+fn start(_: isize, _: *const *const u8) -> isize {
     foo();
     let _ = STATIC1;
+
+    0
 }
 
 //~ TRANS_ITEM static statics_and_consts::STATIC1[0]
@@ -58,5 +63,3 @@ fn main() {
 //~ TRANS_ITEM static statics_and_consts::foo[0]::STATIC2[0]
 //~ TRANS_ITEM static statics_and_consts::foo[0]::STATIC2[1]
 //~ TRANS_ITEM static statics_and_consts::foo[0]::STATIC2[2]
-
-//~ TRANS_ITEM fn statics_and_consts::main[0]

src/test/codegen-units/item-collection/trait-implementations.rs

@@ -12,6 +12,7 @@
 // compile-flags:-Zprint-trans-items=eager
 
 #![deny(dead_code)]
+#![feature(start)]
 
 pub trait SomeTrait {
     fn foo(&self);
@@ -55,8 +56,9 @@ impl<T> SomeGenericTrait<T> for f32 {
     fn bar<T2>(&self, _: T, _: T2) {}
 }
 
-//~ TRANS_ITEM fn trait_implementations::main[0]
-fn main() {
+//~ TRANS_ITEM fn trait_implementations::start[0]
+#[start]
+fn start(_: isize, _: *const *const u8) -> isize {
    //~ TRANS_ITEM fn trait_implementations::{{impl}}[1]::bar[0]<char>
    0i32.bar('x');
 
@@ -77,4 +79,6 @@ fn main() {
 
    //~ TRANS_ITEM fn trait_implementations::{{impl}}[3]::bar[0]<&str, &str>
    0f32.bar("&str", "&str");
+
+   0
 }

src/test/codegen-units/item-collection/trait-method-as-argument.rs

@@ -12,6 +12,7 @@
 // compile-flags:-Zprint-trans-items=eager
 
 #![deny(dead_code)]
+#![feature(start)]
 
 trait Trait : Sized {
     fn foo(self) -> Self { self }
@@ -36,8 +37,9 @@ fn take_foo_mut<T, F: FnMut(T) -> T>(mut f: F, arg: T) -> T {
     (f)(arg)
 }
 
-//~ TRANS_ITEM fn trait_method_as_argument::main[0]
-fn main() {
+//~ TRANS_ITEM fn trait_method_as_argument::start[0]
+#[start]
+fn start(_: isize, _: *const *const u8) -> isize {
     //~ TRANS_ITEM fn trait_method_as_argument::take_foo_once[0]<u32, fn(u32) -> u32>
     //~ TRANS_ITEM fn trait_method_as_argument::{{impl}}[0]::foo[0]
     //~ TRANS_ITEM fn core::ops[0]::function[0]::FnOnce[0]::call_once[0]<fn(u32) -> u32, (u32)>
@@ -63,4 +65,6 @@ fn main() {
     //~ TRANS_ITEM fn trait_method_as_argument::take_foo_mut[0]<char, fn(char) -> char>
     //~ TRANS_ITEM fn core::ops[0]::function[0]::FnMut[0]::call_mut[0]<fn(u32) -> u32, (u32)>
     take_foo_mut(Trait::foo, 'c');
+
+    0
 }

src/test/codegen-units/item-collection/trait-method-default-impl.rs

@@ -12,6 +12,7 @@
 // compile-flags:-Zprint-trans-items=eager
 
 #![deny(dead_code)]
+#![feature(start)]
 
 trait SomeTrait {
     fn foo(&self) { }
@@ -46,8 +47,9 @@ impl<T1> SomeGenericTrait<T1> for u32 {
     // since nothing is monomorphic here, nothing should be generated unless used somewhere.
 }
 
-//~ TRANS_ITEM fn trait_method_default_impl::main[0]
-fn main() {
+//~ TRANS_ITEM fn trait_method_default_impl::start[0]
+#[start]
+fn start(_: isize, _: *const *const u8) -> isize {
     //~ TRANS_ITEM fn trait_method_default_impl::SomeTrait[0]::bar[0]<i8, char>
     let _ = 1i8.bar('c');
 
@@ -65,4 +67,6 @@ fn main() {
 
     //~ TRANS_ITEM fn trait_method_default_impl::SomeGenericTrait[0]::bar[0]<u32, i16, ()>
     0u32.bar(0i16, ());
+
+    0
 }

src/test/codegen-units/item-collection/transitive-drop-glue.rs

@@ -13,6 +13,7 @@
 // compile-flags:-Zinline-in-all-cgus
 
 #![deny(dead_code)]
+#![feature(start)]
 
 //~ TRANS_ITEM fn core::ptr[0]::drop_in_place[0]<transitive_drop_glue::Root[0]> @@ transitive_drop_glue0[Internal]
 struct Root(Intermediate);
@@ -34,9 +35,9 @@ impl<T> Drop for LeafGen<T> {
     fn drop(&mut self) {}
 }
 
-//~ TRANS_ITEM fn transitive_drop_glue::main[0]
-fn main() {
-
+//~ TRANS_ITEM fn transitive_drop_glue::start[0]
+#[start]
+fn start(_: isize, _: *const *const u8) -> isize {
     let _ = Root(Intermediate(Leaf));
 
     //~ TRANS_ITEM fn core::ptr[0]::drop_in_place[0]<transitive_drop_glue::RootGen[0]<u32>> @@ transitive_drop_glue0[Internal]
@@ -50,4 +51,6 @@ fn main() {
     //~ TRANS_ITEM fn core::ptr[0]::drop_in_place[0]<transitive_drop_glue::LeafGen[0]<i16>> @@ transitive_drop_glue0[Internal]
     //~ TRANS_ITEM fn transitive_drop_glue::{{impl}}[1]::drop[0]<i16>
     let _ = RootGen(IntermediateGen(LeafGen(0i16)));
+
+    0
 }

src/test/codegen-units/item-collection/tuple-drop-glue.rs

@@ -13,6 +13,7 @@
 // compile-flags:-Zinline-in-all-cgus
 
 #![deny(dead_code)]
+#![feature(start)]
 
 //~ TRANS_ITEM fn core::ptr[0]::drop_in_place[0]<tuple_drop_glue::Dropped[0]> @@ tuple_drop_glue0[Internal]
 struct Dropped;
@@ -22,12 +23,15 @@ impl Drop for Dropped {
     fn drop(&mut self) {}
 }
 
-//~ TRANS_ITEM fn tuple_drop_glue::main[0]
-fn main() {
+//~ TRANS_ITEM fn tuple_drop_glue::start[0]
+#[start]
+fn start(_: isize, _: *const *const u8) -> isize {
     //~ TRANS_ITEM fn core::ptr[0]::drop_in_place[0]<(u32, tuple_drop_glue::Dropped[0])> @@ tuple_drop_glue0[Internal]
     let x = (0u32, Dropped);
 
     //~ TRANS_ITEM fn core::ptr[0]::drop_in_place[0]<(i16, (tuple_drop_glue::Dropped[0], bool))> @@ tuple_drop_glue0[Internal]
     //~ TRANS_ITEM fn core::ptr[0]::drop_in_place[0]<(tuple_drop_glue::Dropped[0], bool)> @@ tuple_drop_glue0[Internal]
     let x = (0i16, (Dropped, true));
+
+    0
 }

src/test/codegen-units/item-collection/unsizing.rs

@@ -15,6 +15,7 @@
 #![deny(dead_code)]
 #![feature(coerce_unsized)]
 #![feature(unsize)]
+#![feature(start)]
 
 use std::marker::Unsize;
 use std::ops::CoerceUnsized;
@@ -53,9 +54,9 @@ struct Wrapper<T: ?Sized>(*const T);
 
 impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<Wrapper<U>> for Wrapper<T> {}
 
-//~ TRANS_ITEM fn unsizing::main[0]
-fn main()
-{
+//~ TRANS_ITEM fn unsizing::start[0]
+#[start]
+fn start(_: isize, _: *const *const u8) -> isize {
     // simple case
     let bool_sized = &true;
     //~ TRANS_ITEM fn core::ptr[0]::drop_in_place[0]<bool> @@ unsizing0[Internal]
@@ -83,4 +84,6 @@ fn main()
     //~ TRANS_ITEM fn core::ptr[0]::drop_in_place[0]<u32> @@ unsizing0[Internal]
     //~ TRANS_ITEM fn unsizing::{{impl}}[3]::foo[0]
     let _wrapper_sized = wrapper_sized as Wrapper<Trait>;
+
+    0
 }

src/test/codegen-units/partitioning/methods-are-with-self-type.rs

@@ -19,6 +19,7 @@
 // compile-flags:-Zprint-trans-items=lazy -Zincremental=tmp/partitioning-tests/methods-are-with-self-type
 
 #![allow(dead_code)]
+#![feature(start)]
 
 struct SomeType;
 
@@ -63,9 +64,9 @@ mod type2 {
     pub struct Struct;
 }
 
-//~ TRANS_ITEM fn methods_are_with_self_type::main[0]
-fn main()
-{
+//~ TRANS_ITEM fn methods_are_with_self_type::start[0]
+#[start]
+fn start(_: isize, _: *const *const u8) -> isize {
     //~ TRANS_ITEM fn methods_are_with_self_type::mod1[0]::{{impl}}[1]::method[0]<u32, u64> @@ methods_are_with_self_type.volatile[WeakODR]
     SomeGenericType(0u32, 0u64).method();
     //~ TRANS_ITEM fn methods_are_with_self_type::mod1[0]::{{impl}}[1]::associated_fn[0]<char, &str> @@ methods_are_with_self_type.volatile[WeakODR]
@@ -80,6 +81,8 @@ fn main()
     type1::Struct.default();
     //~ TRANS_ITEM fn methods_are_with_self_type::Trait[0]::default[0]<methods_are_with_self_type::type2[0]::Struct[0]> @@ methods_are_with_self_type-type2.volatile[WeakODR]
     type2::Struct.default();
+
+    0
 }
 
 //~ TRANS_ITEM drop-glue i8

src/test/codegen-units/partitioning/vtable-through-const.rs

@@ -18,6 +18,8 @@
 // This test case makes sure, that references made through constants are
 // recorded properly in the InliningMap.
 
+#![feature(start)]
+
 mod mod1 {
     pub trait Trait1 {
         fn do_something(&self) {}
@@ -38,7 +40,7 @@ mod mod1 {
 
     fn id<T>(x: T) -> T { x }
 
-    // These are referenced, so they produce trans-items (see main())
+    // These are referenced, so they produce trans-items (see start())
     pub const TRAIT1_REF: &'static Trait1 = &0u32 as &Trait1;
     pub const TRAIT1_GEN_REF: &'static Trait1Gen<u8> = &0u32 as &Trait1Gen<u8>;
     pub const ID_CHAR: fn(char) -> char = id::<char>;
@@ -68,8 +70,9 @@ mod mod1 {
     pub const ID_I64: fn(i64) -> i64 = id::<i64>;
 }
 
-//~ TRANS_ITEM fn vtable_through_const::main[0] @@ vtable_through_const[Internal]
-fn main() {
+//~ TRANS_ITEM fn vtable_through_const::start[0]
+#[start]
+fn start(_: isize, _: *const *const u8) -> isize {
     //~ TRANS_ITEM fn core::ptr[0]::drop_in_place[0]<u32> @@ vtable_through_const[Internal]
 
     // Since Trait1::do_something() is instantiated via its default implementation,
@@ -90,4 +93,6 @@ fn main() {
 
     //~ TRANS_ITEM fn vtable_through_const::mod1[0]::id[0]<char> @@ vtable_through_const-mod1.volatile[External]
     mod1::ID_CHAR('x');
+
+    0
 }

src/test/compile-fail/feature-gate-termination_trait.rs

@@ -0,0 +1,13 @@
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn main() -> i32 { //~ ERROR main function has wrong type [E0580]
+    0
+}

src/test/compile-fail/main-wrong-type-2.rs

@@ -7,8 +7,9 @@
 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
+#![feature(termination_trait)]
 
 fn main() -> char {
-//~^ ERROR: main function has wrong type [E0580]
+//~^ ERROR: the trait bound `char: std::Termination` is not satisfied
     ' '
 }

src/test/compile-fail/termination-trait-not-satisfied.rs

@@ -0,0 +1,17 @@
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(termination_trait)]
+
+struct ReturnType {}
+
+fn main() -> ReturnType { //~ ERROR `ReturnType: std::Termination` is not satisfied
+    ReturnType {}
+}

src/test/run-make/sepcomp-inlining/foo.rs

@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(start)]
+
 #[inline]
 fn inlined() -> u32 {
     1234
@@ -29,7 +31,10 @@ mod b {
     }
 }
 
-fn main() {
+#[start]
+fn start(_: isize, _: *const *const u8) -> isize {
     a::f();
     b::f();
+
+    0
 }

src/test/run-pass/termination-trait-for-empty.rs

@@ -1,4 +1,4 @@
-// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -8,4 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn main() -> i32 { 0 } //~ ERROR E0580
+#![feature(termination_trait)]
+
+fn main() {}

src/test/run-pass/termination-trait-for-i32.rs

@@ -0,0 +1,15 @@
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(termination_trait)]
+
+fn main() -> i32 {
+    0
+}

src/test/run-pass/termination-trait-for-result.rs

@@ -0,0 +1,17 @@
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(termination_trait)]
+
+use std::io::Error;
+
+fn main() -> Result<(), Error> {
+    Ok(())
+}

src/test/ui/print_type_sizes/anonymous.rs

@@ -15,7 +15,10 @@
 // that one cannot control the sizes of these types with the same sort
 // of enum-variant manipulation tricks.
 
-pub fn main() {
+#![feature(start)]
+
+#[start]
+fn start(_: isize, _: *const *const u8) -> isize {
     let _byte: u8 = 0;
     let _word: usize = 0;
     let _tuple: (u8, usize)= (0, 0);
@@ -25,4 +28,6 @@ pub fn main() {
 
     fn id(x: u8) -> u8 { x };
     fn bye(_: u8) -> ! { loop { } }
+
+    0
 }

src/test/ui/print_type_sizes/generics.rs

@@ -15,6 +15,8 @@
 // monomorphized, in the MIR of the original function in which they
 // occur, to have their size reported.
 
+#![feature(start)]
+
 // In an ad-hoc attempt to avoid the injection of unwinding code
 // (which clutters the output of `-Z print-type-sizes` with types from
 // `unwind::libunwind`):
@@ -66,9 +68,11 @@ pub fn f1<T:Copy>(x: T) {
         Pair::new(FiftyBytes::new(), FiftyBytes::new());
 }
 
-pub fn main() {
+#[start]
+fn start(_: isize, _: *const *const u8) -> isize {
     let _b: Pair<u8> = Pair::new(0, 0);
     let _s: Pair<SevenBytes> = Pair::new(SevenBytes::new(), SevenBytes::new());
     let _z: ZeroSized = ZeroSized;
     f1::<SevenBytes>(SevenBytes::new());
+    0
 }

src/test/ui/print_type_sizes/multiple_types.rs

@@ -14,6 +14,8 @@
 // This file illustrates that when multiple structural types occur in
 // a function, every one of them is included in the output.
 
+#![feature(start)]
+
 pub struct SevenBytes([u8;  7]);
 pub struct FiftyBytes([u8; 50]);
 
@@ -22,8 +24,10 @@ pub enum Enum {
     Large(FiftyBytes),
 }
 
-pub fn main() {
+#[start]
+fn start(_: isize, _: *const *const u8) -> isize {
     let _e: Enum;
     let _f: FiftyBytes;
     let _s: SevenBytes;
+    0
 }

src/test/ui/print_type_sizes/niche-filling.rs

@@ -21,6 +21,7 @@
 // aligned (while on most it is 8-byte aligned) and so the resulting
 // padding and overall computed sizes can be quite different.
 
+#![feature(start)]
 #![feature(nonzero)]
 #![allow(dead_code)]
 
@@ -76,7 +77,8 @@ pub enum Enum4<A, B, C, D> {
     Four(D)
 }
 
-pub fn main() {
+#[start]
+fn start(_: isize, _: *const *const u8) -> isize {
     let _x: MyOption<NonZero<u32>> = Default::default();
     let _y: EmbeddedDiscr = Default::default();
     let _z: MyOption<IndirectNonZero<u32>> = Default::default();
@@ -87,4 +89,5 @@ pub fn main() {
     let _e: Enum4<(), char, (), ()> = Enum4::One(());
     let _f: Enum4<(), (), bool, ()> = Enum4::One(());
     let _g: Enum4<(), (), (), MyOption<u8>> = Enum4::One(());
+    0
 }

src/test/ui/print_type_sizes/no_duplicates.rs

@@ -15,12 +15,16 @@
 // (even if multiple functions), it is only printed once in the
 // print-type-sizes output.
 
+#![feature(start)]
+
 pub struct SevenBytes([u8; 7]);
 
 pub fn f1() {
     let _s: SevenBytes = SevenBytes([0; 7]);
 }
 
-pub fn main() {
+#[start]
+fn start(_: isize, _: *const *const u8) -> isize {
     let _s: SevenBytes = SevenBytes([0; 7]);
+    0
 }

src/test/ui/print_type_sizes/packed.rs

@@ -20,6 +20,7 @@
 // padding and overall computed sizes can be quite different.
 
 #![allow(dead_code)]
+#![feature(start)]
 
 #[derive(Default)]
 #[repr(packed)]
@@ -42,7 +43,9 @@ struct Padded {
     d: u8,
 }
 
-pub fn main() {
+#[start]
+fn start(_: isize, _: *const *const u8) -> isize {
     let _c: Packed = Default::default();
     let _d: Padded = Default::default();
+    0
 }

src/test/ui/print_type_sizes/padding.rs

@@ -19,6 +19,7 @@
 // aligned (while on most it is 8-byte aligned) and so the resulting
 // padding and overall computed sizes can be quite different.
 
+#![feature(start)]
 #![allow(dead_code)]
 
 struct S {
@@ -37,4 +38,7 @@ enum E2 {
     B(S),
 }
 
-fn main() { }
+#[start]
+fn start(_: isize, _: *const *const u8) -> isize {
+    0
+}

src/test/ui/print_type_sizes/repr-align.rs

@@ -20,6 +20,7 @@
 // padding and overall computed sizes can be quite different.
 #![feature(attr_literals)]
 #![feature(repr_align)]
+#![feature(start)]
 #![allow(dead_code)]
 
 #[repr(align(16))]
@@ -39,6 +40,8 @@ struct S {
     d: i8,
 }
 
-fn main() {
+#[start]
+fn start(_: isize, _: *const *const u8) -> isize {
     let _s: S = Default::default();
+    0
 }

src/test/ui/print_type_sizes/uninhabited.rs

@@ -12,8 +12,11 @@
 // must-compile-successfully
 
 #![feature(never_type)]
+#![feature(start)]
 
-pub fn main() {
+#[start]
+fn start(_: isize, _: *const *const u8) -> isize {
     let _x: Option<!> = None;
     let _y: Result<u32, !> = Ok(42);
+    0
 }

src/test/ui/print_type_sizes/variants.rs

@@ -19,6 +19,8 @@
 // 2. For an enum, the print-type-sizes output will also include the
 //    size of each variant.
 
+#![feature(start)]
+
 pub struct SevenBytes([u8;  7]);
 pub struct FiftyBytes([u8; 50]);
 
@@ -27,6 +29,8 @@ pub enum Enum {
     Large(FiftyBytes),
 }
 
-pub fn main() {
+#[start]
+fn start(_: isize, _: *const *const u8) -> isize {
     let _e: Enum;
+    0
 }