typecasting to a generic interface from an object literal

[sramam]

TypeScript Version: 2.1.5

interface Orig<T extends string> {
    type: T;
}

type TypeId = 'SpecA';

interface SpecA extends Orig<TypeId> {
    name?: string;
}

const goodCast = <SpecA>{
    type: 'SpecA'
}

const badCast = <SpecA>{
    type: 'SpecB'
}
// throws an error:
// Type '{ type: "SpecB"; }' cannot be converted to type 'SpecA'.
//  Types of property 'type' are incompatible.
//    Type '"SpecB"' is not comparable to type '"SpecA"'.

const justData = {
    type: 'SpecB'
};

const castLater = <SpecA>justData;
// Expected an error to be thrown, but the compiler accepts this.

Expected behavior:
The typecast to castLater should trigger a compile error.

Actual behavior:
it doesn't.

[RyanCavanaugh]

justData gets type { type: string } so the downcast to { type: 'SpecA' } is OK. It gets that type (rather than { type: 'SpecB' }) so that it's not illegal to write e.g. `justData.type = 'whatever'". This logic doesn't apply in the earlier cases because a "fresh" object literal is known to not be mutated (or need to be able to be mutated) between when it's created and when it's bound to the variable it's initializing.

[sramam]

aah. makes sense.

castLater does get the cast:

castLater.type = 'SpecA'; is ok (as desired)
castLater.type = 'SpecB'; isn't
Even
castLater.type = justData.type; triggers an error.

That was the purpose of the cast in the first place.

Thanks for the clarification.