From 26f98fdf58b6d3b03f413169c8a2db36fef087dc Mon Sep 17 00:00:00 2001 From: Mazdak Farrokhzad Date: Sun, 9 Jun 2019 06:15:16 +0200 Subject: enum-variant-generic-args-pats-pass: rename; test isn't specific to patterns. --- .../enum-variant-generic-args-pass.rs | 60 ++++++++++++++++++++++ .../enum-variant-generic-args-pats-pass.rs | 60 ---------------------- 2 files changed, 60 insertions(+), 60 deletions(-) create mode 100644 src/test/ui/type-alias-enum-variants/enum-variant-generic-args-pass.rs delete mode 100644 src/test/ui/type-alias-enum-variants/enum-variant-generic-args-pats-pass.rs diff --git a/src/test/ui/type-alias-enum-variants/enum-variant-generic-args-pass.rs b/src/test/ui/type-alias-enum-variants/enum-variant-generic-args-pass.rs new file mode 100644 index 00000000000..af05dd1b715 --- /dev/null +++ b/src/test/ui/type-alias-enum-variants/enum-variant-generic-args-pass.rs @@ -0,0 +1,60 @@ +// run-pass + +// Check that resolving, in the value namespace, to an `enum` variant +// through a type alias is well behaved in the presence of generics. +// We check for situations with: +// 1. a generic type `Alias`, we can type-apply `Alias` when referring to a variant. +// 2. a monotype `AliasFixed` of generic `Enum`, we can refer to variants +// and the type-application of `T` in `AliasFixed` is kept. + +#![allow(irrefutable_let_patterns)] + +#[allow(dead_code)] +enum Enum { TSVariant(T), SVariant { v: T }, UVariant } +type Alias = Enum; +type AliasFixed = Enum<()>; + +macro_rules! is_variant { + (TSVariant, $expr:expr) => (is_variant!(@check TSVariant, (_), $expr)); + (SVariant, $expr:expr) => (is_variant!(@check SVariant, { v: _ }, $expr)); + (UVariant, $expr:expr) => (is_variant!(@check UVariant, {}, $expr)); + (@check $variant:ident, $matcher:tt, $expr:expr) => ( + assert!(if let Enum::$variant::<()> $matcher = $expr { true } else { false }, + "expr does not have correct type"); + ); +} + +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(())); + + // 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: () }); + + // Unit variant + + is_variant!(UVariant, Enum::UVariant); + is_variant!(UVariant, Enum::UVariant::<()>); + is_variant!(UVariant, Enum::<()>::UVariant); + + is_variant!(UVariant, Alias::UVariant); + is_variant!(UVariant, Alias::<()>::UVariant); + + is_variant!(UVariant, AliasFixed::UVariant); +} diff --git a/src/test/ui/type-alias-enum-variants/enum-variant-generic-args-pats-pass.rs b/src/test/ui/type-alias-enum-variants/enum-variant-generic-args-pats-pass.rs deleted file mode 100644 index af05dd1b715..00000000000 --- a/src/test/ui/type-alias-enum-variants/enum-variant-generic-args-pats-pass.rs +++ /dev/null @@ -1,60 +0,0 @@ -// run-pass - -// Check that resolving, in the value namespace, to an `enum` variant -// through a type alias is well behaved in the presence of generics. -// We check for situations with: -// 1. a generic type `Alias`, we can type-apply `Alias` when referring to a variant. -// 2. a monotype `AliasFixed` of generic `Enum`, we can refer to variants -// and the type-application of `T` in `AliasFixed` is kept. - -#![allow(irrefutable_let_patterns)] - -#[allow(dead_code)] -enum Enum { TSVariant(T), SVariant { v: T }, UVariant } -type Alias = Enum; -type AliasFixed = Enum<()>; - -macro_rules! is_variant { - (TSVariant, $expr:expr) => (is_variant!(@check TSVariant, (_), $expr)); - (SVariant, $expr:expr) => (is_variant!(@check SVariant, { v: _ }, $expr)); - (UVariant, $expr:expr) => (is_variant!(@check UVariant, {}, $expr)); - (@check $variant:ident, $matcher:tt, $expr:expr) => ( - assert!(if let Enum::$variant::<()> $matcher = $expr { true } else { false }, - "expr does not have correct type"); - ); -} - -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(())); - - // 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: () }); - - // Unit variant - - is_variant!(UVariant, Enum::UVariant); - is_variant!(UVariant, Enum::UVariant::<()>); - is_variant!(UVariant, Enum::<()>::UVariant); - - is_variant!(UVariant, Alias::UVariant); - is_variant!(UVariant, Alias::<()>::UVariant); - - is_variant!(UVariant, AliasFixed::UVariant); -} -- cgit 1.4.1-3-g733a5