unique symbol incorrectly widens to symbol when assigning to a const or readonly property

[kpdonn]

Search Terms:
unique symbol, literal, widen, reassign, const, readonly

Code

const t1 = Symbol("t1")
const t1Copy = t1
const result1: typeof t1 = t1 // no error
const result2: typeof t1 = t1Copy // error: type symbol not assignable to unique symbol

class T2 {
    static readonly sym = Symbol("T2")
    readonly kind = T2.sym
}

const inst = new T2()
const result3: typeof T2.sym = T2.sym // no error
const result4: typeof T2.sym = inst.kind // error: type symbol not assignable to unique symbol

declare function genericIdentity<T>(arg: T): T
const unexpectedError: typeof t1 = genericIdentity(t1)

declare function genericSymbolNested<T extends symbol>(arg: T): { prop: T }
const unexpectedError2: { prop: typeof t1 } = genericSymbolNested(t1)

Expected behavior:
No errors. t1Copy and inst.kind should retain their respective literal unique symbol types the same way string literals would because they are declared with const and readonly.

Actual behavior:
Errors on result2 and result4 because t1Copy and inst.kind are widened to symbol. When assigning a unique symbol variable to a new variable the type is always widened to symbol unless an explicit type annotation is added.

Playground Link:
Link

Related Issues:
Did not notice any similar bug reports, but the design notes from #17501 seem to confirm that the current behavior is a bug:

• Like literal types, these types contain "freshness" which can be widened away to produce a "regular" type.
• When you alias a symbolic const with another const, it has the type typeof [[that original variable]].

Which implies they should work like other literal types which would not be widened in the example above.

[kpdonn]

Additional cases with generics:

declare const sym: unique symbol

declare function genericIdentity<T>(arg: T): T
const unexpectedError: typeof sym = genericIdentity(sym)

declare function genericSymbolNested<T extends symbol>(arg: T): { prop: T }
const unexpectedError2: { prop: typeof sym } = genericSymbolNested(sym)

// Compare with the following equivalent code using literal strings:

declare const literalString: "literal"
const noErrorWithString: typeof literalString = genericIdentity(literalString)

declare function genericStringNested<T extends string>(arg: T): { prop: T }
const noErrorWithString2: { prop: typeof literalString } = genericStringNested(literalString)

Playground link

[mhegazy]

Type of a unique symbol is widened unless it is of the form const sym = Symbol(). the intent here is not clear. this was also done to avoid breaking changes.

[falsandtru]

You don't have any reason to widen the type here. This change never breaks any correct code. Then this is pure improvement. You don't have any reason to avoid this improvement.

[kpdonn]

the intent here is not clear.

The intent is that unique symbols should work the same way as string literals. They are conceptually the exact same thing: a type that has exactly one possible value. The use cases for the behavior I described are the same as the use cases for string literals.

I agree with @falsandtru that I don’t understand what cases you are concerned about where this would be a negative breaking change.

Also I just want to say that it’s very frustrating to go through the effort of putting together a very clear, minimally reproducible bug report only to have it apparently glanced at for a few seconds and assumed invalid. When I ran into this issue it wasn’t remotely clear what the root cause was. It took a decent amount of effort to narrow it down to the very straightforward example I posted here. It also took time to do the research to try to confirm my feeling that this was an unintentional bug, which the design notes from #17501 did (and still do) seem to explicitly confirm.

I realize you have many issues to go through and that most of them are invalid or duplicates which is why I try as much as possible to ensure that my issues are both valid and not duplicates. I try to respect your time but frankly I feel that respect is not always returned.

[typescript-bot]

Automatically closing this issue for housekeeping purposes. The issue labels indicate that it is unactionable at the moment or has already been addressed.

[falsandtru]

Now we can define unique symbol properties by changes of language design.