Merge #466

466: Fix for type aliases in `mod app`, UB in `spawn_at`, and `#[cfg]` in hardware tasks r=AfoHT a=korken89

Type aliases such as the following did not work in `0.6-alpha`:

```rust
use rtic::app;

#[app(device = lm3s6965, dispatchers = [SSI0])]
mod app {
    type Test = u32;

    #[task]
    fn t1(_: t1::Context, _val: Test) {}
}
```

Plus that accessing associated constants of monotonic timers was not working as it should dues to the syntax and codegen transforming:

```rust
    #[monotonic(binds = SysTick, default = true)]
    type MyMono = DwtSystick<8_000_000>; // 8 MHz
```

into

```rust
    mod MyMono {
        // ...
    }
```

causing the original `type MyMono` to not exist anymore.

This PR fixes this and adds test to check for this by doing the following expansion instead:

 ```rust
    #[monotonic(binds = SysTick, default = true)]
    type MyMono = DwtSystick<8_000_000>; // 8 MHz
```

into

```rust
    type MyMono = DwtSystick<8_000_000>;

    mod monotonics {
        mod MyMono {
            // ...
        }

        // And other monotonics go here as well
    }
```

**Breaking change**

This causes a breaking change in accessing the `MyMono::now()` method which now exists under `monotonics::MyMono::now()`.

---

Moreover a UB issue was found and fixed in `spawn_at` and hardware tasks properly propagate `#[cfg]`s.

Closes #460
Closes #462
Closes #463

Co-authored-by: Emil Fresk <emil.fresk@gmail.com>

2 files changed, 36 insertions, 12 deletions

diff --git a/examples/t-schedule.rs b/examples/t-schedule.rs
index ef04c45..5e38dba 100644
--- a/examples/t-schedule.rs
+++ b/examples/t-schedule.rs
@@ -26,24 +26,27 @@ mod app {
         // Task without message passing
 
         // Not default
-        let _: Result<foo::MyMono::SpawnHandle, ()> = foo::MyMono::spawn_at(MyMono::now());
+        let _: Result<foo::MyMono::SpawnHandle, ()> =
+            foo::MyMono::spawn_at(monotonics::MyMono::now());
         let handle: Result<foo::MyMono::SpawnHandle, ()> = foo::MyMono::spawn_after(Seconds(1_u32));
         let _: Result<foo::MyMono::SpawnHandle, ()> =
             handle.unwrap().reschedule_after(Seconds(1_u32));
 
         let handle: Result<foo::MyMono::SpawnHandle, ()> = foo::MyMono::spawn_after(Seconds(1_u32));
-        let _: Result<foo::MyMono::SpawnHandle, ()> = handle.unwrap().reschedule_at(MyMono::now());
+        let _: Result<foo::MyMono::SpawnHandle, ()> =
+            handle.unwrap().reschedule_at(monotonics::MyMono::now());
 
         let handle: Result<foo::MyMono::SpawnHandle, ()> = foo::MyMono::spawn_after(Seconds(1_u32));
         let _: Result<(), ()> = handle.unwrap().cancel();
 
         // Using default
-        let _: Result<foo::SpawnHandle, ()> = foo::spawn_at(MyMono::now());
+        let _: Result<foo::SpawnHandle, ()> = foo::spawn_at(monotonics::MyMono::now());
         let handle: Result<foo::SpawnHandle, ()> = foo::spawn_after(Seconds(1_u32));
         let _: Result<foo::SpawnHandle, ()> = handle.unwrap().reschedule_after(Seconds(1_u32));
 
         let handle: Result<foo::SpawnHandle, ()> = foo::spawn_after(Seconds(1_u32));
-        let _: Result<foo::SpawnHandle, ()> = handle.unwrap().reschedule_at(MyMono::now());
+        let _: Result<foo::SpawnHandle, ()> =
+            handle.unwrap().reschedule_at(monotonics::MyMono::now());
 
         let handle: Result<foo::SpawnHandle, ()> = foo::spawn_after(Seconds(1_u32));
         let _: Result<(), ()> = handle.unwrap().cancel();
@@ -51,7 +54,8 @@ mod app {
         // Task with single message passing
 
         // Not default
-        let _: Result<bar::MyMono::SpawnHandle, u32> = bar::MyMono::spawn_at(MyMono::now(), 0);
+        let _: Result<bar::MyMono::SpawnHandle, u32> =
+            bar::MyMono::spawn_at(monotonics::MyMono::now(), 0);
         let handle: Result<bar::MyMono::SpawnHandle, u32> =
             bar::MyMono::spawn_after(Seconds(1_u32), 0);
         let _: Result<bar::MyMono::SpawnHandle, ()> =
@@ -59,19 +63,21 @@ mod app {
 
         let handle: Result<bar::MyMono::SpawnHandle, u32> =
             bar::MyMono::spawn_after(Seconds(1_u32), 0);
-        let _: Result<bar::MyMono::SpawnHandle, ()> = handle.unwrap().reschedule_at(MyMono::now());
+        let _: Result<bar::MyMono::SpawnHandle, ()> =
+            handle.unwrap().reschedule_at(monotonics::MyMono::now());
 
         let handle: Result<bar::MyMono::SpawnHandle, u32> =
             bar::MyMono::spawn_after(Seconds(1_u32), 0);
         let _: Result<u32, ()> = handle.unwrap().cancel();
 
         // Using default
-        let _: Result<bar::SpawnHandle, u32> = bar::spawn_at(MyMono::now(), 0);
+        let _: Result<bar::SpawnHandle, u32> = bar::spawn_at(monotonics::MyMono::now(), 0);
         let handle: Result<bar::SpawnHandle, u32> = bar::spawn_after(Seconds(1_u32), 0);
         let _: Result<bar::SpawnHandle, ()> = handle.unwrap().reschedule_after(Seconds(1_u32));
 
         let handle: Result<bar::SpawnHandle, u32> = bar::spawn_after(Seconds(1_u32), 0);
-        let _: Result<bar::SpawnHandle, ()> = handle.unwrap().reschedule_at(MyMono::now());
+        let _: Result<bar::SpawnHandle, ()> =
+            handle.unwrap().reschedule_at(monotonics::MyMono::now());
 
         let handle: Result<bar::SpawnHandle, u32> = bar::spawn_after(Seconds(1_u32), 0);
         let _: Result<u32, ()> = handle.unwrap().cancel();
@@ -80,7 +86,7 @@ mod app {
 
         // Not default
         let _: Result<baz::MyMono::SpawnHandle, (u32, u32)> =
-            baz::MyMono::spawn_at(MyMono::now(), 0, 1);
+            baz::MyMono::spawn_at(monotonics::MyMono::now(), 0, 1);
         let handle: Result<baz::MyMono::SpawnHandle, (u32, u32)> =
             baz::MyMono::spawn_after(Seconds(1_u32), 0, 1);
         let _: Result<baz::MyMono::SpawnHandle, ()> =
@@ -88,19 +94,22 @@ mod app {
 
         let handle: Result<baz::MyMono::SpawnHandle, (u32, u32)> =
             baz::MyMono::spawn_after(Seconds(1_u32), 0, 1);
-        let _: Result<baz::MyMono::SpawnHandle, ()> = handle.unwrap().reschedule_at(MyMono::now());
+        let _: Result<baz::MyMono::SpawnHandle, ()> =
+            handle.unwrap().reschedule_at(monotonics::MyMono::now());
 
         let handle: Result<baz::MyMono::SpawnHandle, (u32, u32)> =
             baz::MyMono::spawn_after(Seconds(1_u32), 0, 1);
         let _: Result<(u32, u32), ()> = handle.unwrap().cancel();
 
         // Using default
-        let _: Result<baz::SpawnHandle, (u32, u32)> = baz::spawn_at(MyMono::now(), 0, 1);
+        let _: Result<baz::SpawnHandle, (u32, u32)> =
+            baz::spawn_at(monotonics::MyMono::now(), 0, 1);
         let handle: Result<baz::SpawnHandle, (u32, u32)> = baz::spawn_after(Seconds(1_u32), 0, 1);
         let _: Result<baz::SpawnHandle, ()> = handle.unwrap().reschedule_after(Seconds(1_u32));
 
         let handle: Result<baz::SpawnHandle, (u32, u32)> = baz::spawn_after(Seconds(1_u32), 0, 1);
-        let _: Result<baz::SpawnHandle, ()> = handle.unwrap().reschedule_at(MyMono::now());
+        let _: Result<baz::SpawnHandle, ()> =
+            handle.unwrap().reschedule_at(monotonics::MyMono::now());
 
         let handle: Result<baz::SpawnHandle, (u32, u32)> = baz::spawn_after(Seconds(1_u32), 0, 1);
         let _: Result<(u32, u32), ()> = handle.unwrap().cancel();
diff --git a/examples/type-usage.rs b/examples/type-usage.rs
new file mode 100644
index 0000000..9bb7eb8
--- /dev/null
+++ b/examples/type-usage.rs
@@ -0,0 +1,15 @@
+//! examples/type-usage.rs
+
+#![no_main]
+#![no_std]
+
+use panic_semihosting as _; // panic handler
+use rtic::app;
+
+#[app(device = lm3s6965, dispatchers = [SSI0])]
+mod app {
+    type Test = u32;
+
+    #[task]
+    fn t1(_: t1::Context, _val: Test) {}
+}