tsc reports error when a recursive type alias defines a finite type.

[vczh]

TypeScript Version: 3.4.0-dev.201xxxxx

Search Terms:

Code

Before pasting the code that makes tsc prompt compiler errors, please allow me to explain my scenario.

I am making an AST for a language, let's say it looks like this:

export interface Stop {
    kind: 'Stop';
}

export interface Unary {
    kind: 'Unary';
    x: Expr;
}

export interface Binary {
    kind: 'Binary';
    x: Expr;
    y: Expr;
}

export interface SugaredExpr {
    kind: 'SugaredExpr';
    x: Expr;
    y: Expr;
    z: Expr;
}

export type Expr = Stop | Unary | Binary | SugaredExpr;

Before compiling the code, I have a function called desugar, which transforms SugaredExpr to the combination of others, so the output looks like this:

export interface Stop {
    kind: 'Stop';
}

export interface Unary {
    kind: 'Unary';
    x: Expr;
}

export interface Binary {
    kind: 'Binary';
    x: Expr;
    y: Expr;
}

export type Expr = Stop | Unary | Binary;

Now I want to describe the type of desugar in an accurate way without violating the DRY principal, so I write the following code:

export interface Stop {
    kind: 'Stop';
}

export interface Unary<T> {
    kind: 'Unary';
    x: T;
}

export interface Binary<T> {
    kind: 'Binary';
    x: T;
    y: T;
}

export interface SugaredExpr {
    kind: 'SugaredExpr';
    x: ExprWithSugar;
    y: ExprWithSugar;
    z: ExprWithSugar;
}

export type ExprWithSugar = Stop | Unary<ExprWithSugar> | Binary<ExprWithSugar> | SugaredExpr;
export type Expr = Stop | Unary<Expr> | Binary<Expr>;

export function desugar(exprWithSugar: ExprWithSugar): Expr {
    throw new Error('Not Implemented');
}

T becomes the AST category. You pass union types of chosen ASTs, so that ExprWithSugar could be a Unary with SugaredExpr inside, but Expr could not.

Expected behavior: It compiles

Actual behavior:
Type alias 'ExprWithSugar' circularly references itself.ts(2456)
Type alias 'Expr' circularly references itself.ts(2456)

Obviously both ExprWithSugar and Expr should correct, because Stop ensures that the recursion is not infinite.

Related Issues: This is about recursive type alias. I searched and see some issues, but all of them seems incorrect. And I believe I am making a valid one.

[jack-williams]

If you search "recursive type aliases" you get this PR in first few hits: #33050. It was merged recently and enables this scenario for 3.7. You can try it out in the beta here.

[vczh]

@jack-williams Cool! Do you have a road map about when 3.7 will be available from npm?

[jack-williams]

#33352

[typescript-bot]

This issue has been marked as a 'Duplicate' and has seen no recent activity. It has been automatically closed for house-keeping purposes.