| error[E0423]: expected value, found struct variant `E::B` |
| --> $DIR/fn-or-tuple-struct-without-args.rs:36:16 |
| | |
| LL | let _: E = E::B; |
| | ^^^- |
| | | | |
| | | help: a tuple variant with a similar name exists: `A` |
| | did you mean `E::B { /* fields */ }`? |
| |
| error[E0308]: mismatched types |
| --> $DIR/fn-or-tuple-struct-without-args.rs:29:20 |
| | |
| LL | fn foo(a: usize, b: usize) -> usize { a } |
| | ----------------------------------- fn(usize, usize) -> usize {foo} defined here |
| ... |
| LL | let _: usize = foo; |
| | ^^^ |
| | | |
| | expected usize, found fn item |
| | help: use parentheses to call this function: `foo(a, b)` |
| | |
| = note: expected type `usize` |
| found type `fn(usize, usize) -> usize {foo}` |
| |
| error[E0308]: mismatched types |
| --> $DIR/fn-or-tuple-struct-without-args.rs:30:16 |
| | |
| LL | struct S(usize, usize); |
| | ----------------------- fn(usize, usize) -> S {S} defined here |
| ... |
| LL | let _: S = S; |
| | ^ |
| | | |
| | expected struct `S`, found fn item |
| | help: use parentheses to instantiate this tuple struct: `S(_, _)` |
| | |
| = note: expected type `S` |
| found type `fn(usize, usize) -> S {S}` |
| |
| error[E0308]: mismatched types |
| --> $DIR/fn-or-tuple-struct-without-args.rs:31:20 |
| | |
| LL | fn bar() -> usize { 42 } |
| | ----------------- fn() -> usize {bar} defined here |
| ... |
| LL | let _: usize = bar; |
| | ^^^ |
| | | |
| | expected usize, found fn item |
| | help: use parentheses to call this function: `bar()` |
| | |
| = note: expected type `usize` |
| found type `fn() -> usize {bar}` |
| |
| error[E0308]: mismatched types |
| --> $DIR/fn-or-tuple-struct-without-args.rs:32:16 |
| | |
| LL | struct V(); |
| | ----------- fn() -> V {V} defined here |
| ... |
| LL | let _: V = V; |
| | ^ |
| | | |
| | expected struct `V`, found fn item |
| | help: use parentheses to instantiate this tuple struct: `V()` |
| | |
| = note: expected type `V` |
| found type `fn() -> V {V}` |
| |
| error[E0308]: mismatched types |
| --> $DIR/fn-or-tuple-struct-without-args.rs:33:20 |
| | |
| LL | fn baz(x: usize, y: usize) -> usize { x } |
| | ----------------------------------- fn(usize, usize) -> usize {<_ as T>::baz} defined here |
| ... |
| LL | let _: usize = T::baz; |
| | ^^^^^^ |
| | | |
| | expected usize, found fn item |
| | help: use parentheses to call this function: `T::baz(x, y)` |
| | |
| = note: expected type `usize` |
| found type `fn(usize, usize) -> usize {<_ as T>::baz}` |
| |
| error[E0308]: mismatched types |
| --> $DIR/fn-or-tuple-struct-without-args.rs:34:20 |
| | |
| LL | fn bat(x: usize) -> usize { 42 } |
| | ------------------------- fn(usize) -> usize {<_ as T>::bat} defined here |
| ... |
| LL | let _: usize = T::bat; |
| | ^^^^^^ |
| | | |
| | expected usize, found fn item |
| | help: use parentheses to call this function: `T::bat(x)` |
| | |
| = note: expected type `usize` |
| found type `fn(usize) -> usize {<_ as T>::bat}` |
| |
| error[E0308]: mismatched types |
| --> $DIR/fn-or-tuple-struct-without-args.rs:35:16 |
| | |
| LL | A(usize), |
| | -------- fn(usize) -> E {E::A} defined here |
| ... |
| LL | let _: E = E::A; |
| | ^^^^ |
| | | |
| | expected enum `E`, found fn item |
| | help: use parentheses to instantiate this tuple variant: `E::A(_)` |
| | |
| = note: expected type `E` |
| found type `fn(usize) -> E {E::A}` |
| |
| error[E0308]: mismatched types |
| --> $DIR/fn-or-tuple-struct-without-args.rs:37:20 |
| | |
| LL | fn baz(x: usize, y: usize) -> usize { x } |
| | ----------------------------------- fn(usize, usize) -> usize {<X as T>::baz} defined here |
| ... |
| LL | let _: usize = X::baz; |
| | ^^^^^^ |
| | | |
| | expected usize, found fn item |
| | help: use parentheses to call this function: `X::baz(x, y)` |
| | |
| = note: expected type `usize` |
| found type `fn(usize, usize) -> usize {<X as T>::baz}` |
| |
| error[E0308]: mismatched types |
| --> $DIR/fn-or-tuple-struct-without-args.rs:38:20 |
| | |
| LL | fn bat(x: usize) -> usize { 42 } |
| | ------------------------- fn(usize) -> usize {<X as T>::bat} defined here |
| ... |
| LL | let _: usize = X::bat; |
| | ^^^^^^ |
| | | |
| | expected usize, found fn item |
| | help: use parentheses to call this function: `X::bat(x)` |
| | |
| = note: expected type `usize` |
| found type `fn(usize) -> usize {<X as T>::bat}` |
| |
| error[E0308]: mismatched types |
| --> $DIR/fn-or-tuple-struct-without-args.rs:39:20 |
| | |
| LL | fn bax(x: usize) -> usize { 42 } |
| | ------------------------- fn(usize) -> usize {<X as T>::bax} defined here |
| ... |
| LL | let _: usize = X::bax; |
| | ^^^^^^ |
| | | |
| | expected usize, found fn item |
| | help: use parentheses to call this function: `X::bax(x)` |
| | |
| = note: expected type `usize` |
| found type `fn(usize) -> usize {<X as T>::bax}` |
| |
| error[E0308]: mismatched types |
| --> $DIR/fn-or-tuple-struct-without-args.rs:40:20 |
| | |
| LL | fn bach(x: usize) -> usize; |
| | --------------------------- fn(usize) -> usize {<X as T>::bach} defined here |
| ... |
| LL | let _: usize = X::bach; |
| | ^^^^^^^ |
| | | |
| | expected usize, found fn item |
| | help: use parentheses to call this function: `X::bach(x)` |
| | |
| = note: expected type `usize` |
| found type `fn(usize) -> usize {<X as T>::bach}` |
| |
| error[E0308]: mismatched types |
| --> $DIR/fn-or-tuple-struct-without-args.rs:41:20 |
| | |
| LL | fn ban(&self) -> usize { 42 } |
| | ---------------------- for<'r> fn(&'r X) -> usize {<X as T>::ban} defined here |
| ... |
| LL | let _: usize = X::ban; |
| | ^^^^^^ |
| | | |
| | expected usize, found fn item |
| | help: use parentheses to call this function: `X::ban(_)` |
| | |
| = note: expected type `usize` |
| found type `for<'r> fn(&'r X) -> usize {<X as T>::ban}` |
| |
| error[E0308]: mismatched types |
| --> $DIR/fn-or-tuple-struct-without-args.rs:42:20 |
| | |
| LL | fn bal(&self) -> usize; |
| | ----------------------- for<'r> fn(&'r X) -> usize {<X as T>::bal} defined here |
| ... |
| LL | let _: usize = X::bal; |
| | ^^^^^^ |
| | | |
| | expected usize, found fn item |
| | help: use parentheses to call this function: `X::bal(_)` |
| | |
| = note: expected type `usize` |
| found type `for<'r> fn(&'r X) -> usize {<X as T>::bal}` |
| |
| error[E0615]: attempted to take value of method `ban` on type `X` |
| --> $DIR/fn-or-tuple-struct-without-args.rs:43:22 |
| | |
| LL | let _: usize = X.ban; |
| | ^^^ help: use parentheses to call the method: `ban()` |
| |
| error[E0615]: attempted to take value of method `bal` on type `X` |
| --> $DIR/fn-or-tuple-struct-without-args.rs:44:22 |
| | |
| LL | let _: usize = X.bal; |
| | ^^^ help: use parentheses to call the method: `bal()` |
| |
| error[E0308]: mismatched types |
| --> $DIR/fn-or-tuple-struct-without-args.rs:46:20 |
| | |
| LL | let closure = || 42; |
| | -- closure defined here |
| LL | let _: usize = closure; |
| | ^^^^^^^ |
| | | |
| | expected usize, found closure |
| | help: use parentheses to call this closure: `closure()` |
| | |
| = note: expected type `usize` |
| found type `[closure@$DIR/fn-or-tuple-struct-without-args.rs:45:19: 45:24]` |
| |
| error: aborting due to 17 previous errors |
| |
| Some errors have detailed explanations: E0308, E0423, E0615. |
| For more information about an error, try `rustc --explain E0308`. |