Expanded tests for enum variants with generic args.

Author: Alexander Regueiro

src/test/run-pass/enum-generic-args.rs

@@ -0,0 +1,55 @@
+#![feature(irrefutable_let_patterns)]
+#![feature(type_alias_enum_variants)]
+
+#![allow(irrefutable_let_patterns)]
+
+enum Enum<T> { TSVariant(T), SVariant { v: T } }
+type Alias<T> = Enum<T>;
+type AliasFixed = Enum<()>;
+
+macro_rules! is_variant {
+    (TSVariant, $expr:expr) => (is_variant!(@TSVariant, (_), $expr));
+    (SVariant, $expr:expr) => (is_variant!(@SVariant, { v: _ }, $expr));
+    (@$variant:ident, $matcher:tt, $expr:expr) => (
+        assert!(if let Enum::$variant::<()> $matcher = $expr { true } else { false },
+                "expr does not have correct type");
+    );
+}
+
+impl<T> Enum<T> {
+    fn ts_variant() {
+        is_variant!(TSVariant, Self::TSVariant(()));
+    }
+
+    fn s_variant() {
+        is_variant!(SVariant, Self::SVariant { v: () });
+    }
+}
+
+fn main() {
+    // Tuple struct variant
+
+    is_variant!(TSVariant, Enum::TSVariant(()));
+    is_variant!(TSVariant, Enum::TSVariant::<()>(()));
+    is_variant!(TSVariant, Enum::<()>::TSVariant(()));
+
+    is_variant!(TSVariant, Alias::TSVariant(()));
+    is_variant!(TSVariant, Alias::<()>::TSVariant(()));
+
+    is_variant!(TSVariant, AliasFixed::TSVariant(()));
+
+    Enum::<()>::ts_variant();
+
+    // Struct variant
+
+    is_variant!(SVariant, Enum::SVariant { v: () });
+    is_variant!(SVariant, Enum::SVariant::<()> { v: () });
+    is_variant!(SVariant, Enum::<()>::SVariant { v: () });
+
+    is_variant!(SVariant, Alias::SVariant { v: () });
+    is_variant!(SVariant, Alias::<()>::SVariant { v: () });
+
+    is_variant!(SVariant, AliasFixed::SVariant { v: () });
+
+    Enum::<()>::s_variant();
+}

src/test/run-pass/enum-variant-generic-args.rs

@@ -0,0 +1,30 @@
+#![feature(type_alias_enum_variants)]
+
+#[derive(Debug, PartialEq, Eq)]
+enum Foo {
+    Bar(i32),
+    Baz { i: i32 },
+}
+
+type FooAlias = Foo;
+type OptionAlias = Option<i32>;
+
+impl Foo {
+    fn foo() -> Self {
+        Self::Bar(3)
+    }
+}
+
+fn main() {
+    let t = FooAlias::Bar(1);
+    assert_eq!(t, Foo::Bar(1));
+    let t = FooAlias::Baz { i: 2 };
+    assert_eq!(t, Foo::Baz { i: 2 });
+    match t {
+        FooAlias::Bar(_i) => {}
+        FooAlias::Baz { i } => { assert_eq!(i, 2); }
+    }
+    assert_eq!(Foo::foo(), Foo::Bar(3));
+
+    assert_eq!(OptionAlias::Some(4), Option::Some(4));
+}

src/test/run-pass/type-alias-enum-variants-2.rs

@@ -0,0 +1,65 @@
+#![feature(type_alias_enum_variants)]
+
+enum Enum<T> { TSVariant(T), SVariant { v: T } }
+type Alias<T> = Enum<T>;
+type AliasFixed = Enum<()>;
+
+impl<T> Enum<T> {
+    fn ts_variant() {
+        Self::TSVariant::<()>(());
+        //~^ ERROR type parameters are not allowed on this type [E0109]
+        Self::<()>::TSVariant(());
+        //~^ ERROR type parameters are not allowed on this type [E0109]
+        Self::<()>::TSVariant::<()>(());
+        //~^ ERROR type parameters are not allowed on this type [E0109]
+        //~^^ ERROR type parameters are not allowed on this type [E0109]
+    }
+
+    fn s_variant() {
+        Self::SVariant::<()>(());
+        //~^ ERROR type parameters are not allowed on this type [E0109]
+        Self::<()>::SVariant(());
+        //~^ ERROR type parameters are not allowed on this type [E0109]
+        Self::<()>::SVariant::<()>(());
+        //~^ ERROR type parameters are not allowed on this type [E0109]
+        //~^^ ERROR type parameters are not allowed on this type [E0109]
+    }
+}
+
+fn main() {
+    // Tuple struct variant
+
+    Enum::<()>::TSVariant::<()>(());
+    //~^ ERROR type parameters are not allowed on this type [E0109]
+
+    Alias::TSVariant::<()>(());
+    //~^ ERROR type parameters are not allowed on this type [E0109]
+    Alias::<()>::TSVariant::<()>(());
+    //~^ ERROR type parameters are not allowed on this type [E0109]
+
+    AliasFixed::TSVariant::<()>(());
+    //~^ ERROR type parameters are not allowed on this type [E0109]
+    AliasFixed::<()>::TSVariant(());
+    //~^ ERROR wrong number of type arguments: expected 0, found 1 [E0107]
+    AliasFixed::<()>::TSVariant::<()>(());
+    //~^ ERROR type parameters are not allowed on this type [E0109]
+    //~^^ ERROR wrong number of type arguments: expected 0, found 1 [E0107]
+
+    // Struct variant
+
+    Enum::<()>::SVariant::<()>(());
+    //~^ ERROR type parameters are not allowed on this type [E0109]
+
+    Alias::SVariant::<()>(());
+    //~^ ERROR type parameters are not allowed on this type [E0109]
+    Alias::<()>::SVariant::<()>(());
+    //~^ ERROR type parameters are not allowed on this type [E0109]
+
+    AliasFixed::SVariant::<()>(());
+    //~^ ERROR type parameters are not allowed on this type [E0109]
+    AliasFixed::<()>::SVariant(());
+    //~^ ERROR wrong number of type arguments: expected 0, found 1 [E0107]
+    AliasFixed::<()>::SVariant::<()>(());
+    //~^ ERROR type parameters are not allowed on this type [E0109]
+    //~^^ ERROR wrong number of type arguments: expected 0, found 1 [E0107]
+}