Inconsistent Self behavior with generic structs

[arucil]

Summary from @pnkfelix : Self used as a tuple-struct constructor function should use the fully type-substituted form from the impl block, but does not.

Thus, today this code is accepted, but it should not be.

struct _Bar<T>(T);

impl<T> _Bar<T> {
    fn _map1<U>(x: U) -> _Bar<U> {
        Self(x)
    }
}

(Fixing this would be a breaking-change, so we should take care in how we deploy it.)

Original bug report follows:

---

I tried this code:

struct _Foo<T> {
    x: T
}

impl<T> _Foo<T> {
    fn _map<U>(x: U) -> _Foo<U> {
        Self { x }
    }
}

struct _Bar<T>(T);

impl<T> _Bar<T> {
    fn _map<U>(x: U) -> _Bar<U> {
        Self(x)
    }
}

In nightly rustc, _Bar compiles while _Foo yields a type mismatch error:

error[E0308]: mismatched types
  --> src/main.rs:10:16
   |
8  | impl<T> _Foo<T> {
   |      - expected type parameter
9  |     fn _map<U>(x: U) -> _Foo<U> {
   |             - found type parameter
10 |         Self { x }
   |                ^ expected type parameter `T`, found type parameter `U`
   |

[petrochenkov]

The _Bar one is incorrect, Self has all its generic parameters substituted, i.e. it's _Foo<T>/_Bar<T> in both cases, type or constructor function.

[pnkfelix]

To be 100% clear here: I believe what @petrochenkov is saying is that the compiler has a bug, and that the bug is that the code

impl<T> _Bar<T> {
    fn _map<U>(x: U) -> _Bar<U> {
        Self(x)
    }
}

should be treated as a short-hand for:

impl<T> _Bar<T> {
    fn _map<U>(x: U) -> _Bar<U> {
        _Bar::<T>(x)
    }
}

and thus should be yielding the same error that one sees for the _Foo cases in the code from the description.

However, the _Bar::_map code is not yielding an error at all.

[pnkfelix]

T-compiler triage: leaving nominated for T-lang. Tagging as P-high priority to resolve whether the semantics described by @petrochenkov is indeed what we want, and if so, how to address deploying a breaking-change to fix it.

[Centril]

cc @eddyb

I thought we had fixed this bug in #61896 (and to be clear, it's clearly a bug (as noted by @petrochenkov in #69306 (comment)). It should not compile.

[Centril]

Just to simplify a bit (still passes but shouldn't):

struct _Bar<T>(T);

impl<T> _Bar<T> {
    fn _map1(x: u8) -> _Bar<u8> {
        Self(x)
    }
}

[eddyb]

Just checked on godbolt and it seems to compile in every stable release since it was stabilized (1.32.0). I haven't looked into the code again, but I don't really understand how #61896 didn't cover this. Did we forget to add a test with errors, and only tried to prevent ICEs, or something?