cannot instantiate a tagged union whose discriminant property is union type

[hellochar]

Hey typescript, I'm getting an error when instantiating a tagged union whose discriminant property is inlined into the literal, vs. set via assignment right afterwards. Is there something I'm missing here?

TypeScript Version: 2.0.3 (or whatever's on http://www.typescriptlang.org/play/)

Code

interface ILinearAxis { type: "linear"; }

interface ICategoricalAxis { type: "categorical"; }

type IAxis = ILinearAxis | ICategoricalAxis;
type IAxisType = "linear" | "categorical";

function getAxisType(): IAxisType {
    if (1 == 1) {
        return "categorical";
    } else {
        return "linear";
    }
}

const bad: IAxis = { type: getAxisType() };
//TS2322: Type '{ type: "linear" | "categorical"; }' is not assignable to type 'ILinearAxis | ICategoricalAxis'.
//    Type '{ type: "linear" | "categorical"; }' is not assignable to type 'ICategoricalAxis'.
//        Types of property 'type' are incompatible.
//            Type '"linear" | "categorical"' is not assignable to type '"categorical"'.
//                Type '"linear"' is not assignable to type '"categorical"'.

const good: IAxis = { type: undefined };
good.type = getAxisType();

Expected behavior: Both should work
Actual behavior: The "bad" axis declaration fails with the error described

Thanks!

[hellochar]

Related weirdness:

const axis: IAxis = { type: "categorical"; };

axis.type = "linear";
// errors here saying axis.type === "categorical"

Apparently it sees axis as type ICategoricalAxis even though I explicitly typedef-ed it as IAxis?

[ahejlsberg]

For your example to type check with no errors we would have to consider types of the form { x: "foo" | "bar" } to be equivalent to { x: "foo" } | { x: "bar" }. But this sort of equivalence only holds for types with a single property and isn't true in the general case. For example, it wouldn't be correct to consider { x: "foo" | "bar", y: string | number } to be equivalent to { x: "foo", y: string } | { x: "bar", y: number } because the first form allows all four combinations whereas the second form only allows two specific ones.

In your example, if all that ever differs between ILinearAxis and ICategoricalAxis is the type property, then you can just use a single interface IAxis { type: "linear" | "categorical" } and your code would work. But, if you actually have additional properties in ILinearAxis and ICategoricalAxis then you can't really structure your code the way you are.

[RyanCavanaugh]

Ref #8289