Merge #390

390: Spawn and schedule from anywhere r=AfoHT a=korken89

This PR moves RTIC to the spawn and schedule from anywhere syntax.

Notable changes:
 * We do no longer support non-`Send` types.
 * Some extra code is generated as any task may spawn/schedule any task. However Rust/LLVM does a great job optimizing away non used instantiations (no real code-size difference observed).
 * Worst case priority inversion has increased, but it is now predictable.

Upsides:
 * With this we should be able to support async/await.
 * RTIC tasks can now be callbacks (spawned and scheduled).
 * RTIC tasks can be stored.

Needs the following PR to land first: https://github.com/rtic-rs/rtic-syntax/pull/34

The following now works:

```rust
#[rtic::app(device = lm3s6965, monotonic = rtic::cyccnt::CYCCNT)]
mod app {
    #[init]
    fn init(mut cx: init::Context) -> init::LateResources {
        // Init stuff...

        // New spawn syntax
        foo::spawn().unwrap();

        // New schedule syntax
        bar::schedule(now + 4_000_000.cycles()).unwrap();

        init::LateResources {}
    }

    #[task]
    fn foo(_: foo::Context) {}

    #[task]
    fn bar(_: bar::Context) {}

    extern "C" {
        fn SSI0();
    }
}

```

Co-authored-by: Per Lindgren <per.lindgren@ltu.se>
Co-authored-by: Emil Fresk <emil.fresk@gmail.com>

1 files changed, 25 insertions, 25 deletions

diff --git a/examples/t-spawn.rs b/examples/t-spawn.rs
index efb748bc..cf850e46 100644
--- a/examples/t-spawn.rs
+++ b/examples/t-spawn.rs
@@ -9,45 +9,45 @@ use panic_halt as _;
 
 #[rtic::app(device = lm3s6965)]
 mod app {
-    #[init(spawn = [foo, bar, baz])]
-    fn init(c: init::Context) -> init::LateResources {
-        let _: Result<(), ()> = c.spawn.foo();
-        let _: Result<(), u32> = c.spawn.bar(0);
-        let _: Result<(), (u32, u32)> = c.spawn.baz(0, 1);
+    #[init]
+    fn init(_: init::Context) -> init::LateResources {
+        let _: Result<(), ()> = foo::spawn();
+        let _: Result<(), u32> = bar::spawn(0);
+        let _: Result<(), (u32, u32)> = baz::spawn(0, 1);
 
         init::LateResources {}
     }
 
-    #[idle(spawn = [foo, bar, baz])]
-    fn idle(c: idle::Context) -> ! {
-        let _: Result<(), ()> = c.spawn.foo();
-        let _: Result<(), u32> = c.spawn.bar(0);
-        let _: Result<(), (u32, u32)> = c.spawn.baz(0, 1);
+    #[idle]
+    fn idle(_: idle::Context) -> ! {
+        let _: Result<(), ()> = foo::spawn();
+        let _: Result<(), u32> = bar::spawn(0);
+        let _: Result<(), (u32, u32)> = baz::spawn(0, 1);
 
         loop {
             cortex_m::asm::nop();
         }
     }
 
-    #[task(binds = SVCall, spawn = [foo, bar, baz])]
-    fn svcall(c: svcall::Context) {
-        let _: Result<(), ()> = c.spawn.foo();
-        let _: Result<(), u32> = c.spawn.bar(0);
-        let _: Result<(), (u32, u32)> = c.spawn.baz(0, 1);
+    #[task(binds = SVCall)]
+    fn svcall(_: svcall::Context) {
+        let _: Result<(), ()> = foo::spawn();
+        let _: Result<(), u32> = bar::spawn(0);
+        let _: Result<(), (u32, u32)> = baz::spawn(0, 1);
     }
 
-    #[task(binds = UART0, spawn = [foo, bar, baz])]
-    fn uart0(c: uart0::Context) {
-        let _: Result<(), ()> = c.spawn.foo();
-        let _: Result<(), u32> = c.spawn.bar(0);
-        let _: Result<(), (u32, u32)> = c.spawn.baz(0, 1);
+    #[task(binds = UART0)]
+    fn uart0(_: uart0::Context) {
+        let _: Result<(), ()> = foo::spawn();
+        let _: Result<(), u32> = bar::spawn(0);
+        let _: Result<(), (u32, u32)> = baz::spawn(0, 1);
     }
 
-    #[task(spawn = [foo, bar, baz])]
-    fn foo(c: foo::Context) {
-        let _: Result<(), ()> = c.spawn.foo();
-        let _: Result<(), u32> = c.spawn.bar(0);
-        let _: Result<(), (u32, u32)> = c.spawn.baz(0, 1);
+    #[task]
+    fn foo(_: foo::Context) {
+        let _: Result<(), ()> = foo::spawn();
+        let _: Result<(), u32> = bar::spawn(0);
+        let _: Result<(), (u32, u32)> = baz::spawn(0, 1);
     }
 
     #[task]