Type inference inconsistency with generic constraints

Bug Report

🔎 Search Terms

• type inference const string
• type inference generic constraints

🕗 Version & Regression Information

Tested on

• 3.9.7
• 4.2.3
• 4.3.0-beta

⏯ Playground Link

Playground link

💻 Code

Following Generic Constraints

type Concatable<T> = {
	concat: (...xss: T[]) => T
};

export const concat = <T extends Concatable<T>>
	(xs: T, ...xss: T[] ): T => xs.concat( ...xss );

export const test_1 = concat([1, 2], [3, 4]);         // OK
export const test_2 = concat("foo" as string, "bar"); // OK
export const test_3 = concat<string>("foo", "bar");   // OK

// Expected: 'test_4: string'
// Got:      'test_4: Concatable<"foo" | "bar">'
export const test_4 = concat("foo", "bar");
// Error:                    ^^^^^
// Argument of type 'string' is not assignable to
// parameter of type 'Concatable<"foo" | "bar">'

🙁 Actual behavior

test_4: Concatable<"foo" | "bar">

TS leaks the constraint for type T into type T
TS provides no good way to make Rust-like trait

🙂 Expected behavior

T, test_4, "foo" and "bar" all infer type string

Reproduce the generic-constraint example in the linked TypeScript Playground across the listed versions and inspect the inferred type of test_4. The fix is complete when concat("foo", "bar") infers string without an error, matching the expected behavior while preserving the other examples.