Intellisense and generated declarations emit wrong types (mapped types)

[gcanti]

TypeScript Version: 2.1.5, 2.1.6, 2.2.0-dev20170203

VS Code Version: 1.9.1

Code

class Type<T> { t: T }

type TypeOf<T extends Type<any>> = T['t'];

type Props = { [key: string]: Type<any> };

declare function obj<P extends Props>(props: P): Type<{ [K in keyof P]: TypeOf<P[K]> }>;

const str = new Type<string>()

const A = obj({
  a: str
})

type TypeOfA = TypeOf<typeof A> // => Intellisense correctly shows { a: string }

const B = obj({
  b: obj({
    c: str
  })
})

type TypeOfB = TypeOf<typeof B> // => should be { b: { c: string } } but Intellisense shows { b: any; }

// though the inferred type seems correct
const b1: TypeOfB = {} // error
const b2: TypeOfB = { b: {} } // error
const b3: TypeOfB = { b: { c: 'foo' } } // NO error

Expected behavior:

Intellisense should show

type TypeOfB = {
  b: {
    c: string
  };
}

Actual behavior:

Intellisense shows

type TypeOfB = {
  b: any;
}

EDIT: detail screenshot

[DanielRosenwasser]

Something's going on with the display writer. I found what I believe is the culprit in checker.ts:

else if (contains(symbolStack, symbol)) {
    // If type is an anonymous type literal in a type alias declaration, use type alias name
    const typeAlias = getTypeAliasForTypeLiteral(type);
    if (typeAlias) {
        // The specified symbol flags need to be reinterpreted as type flags
        buildSymbolDisplay(typeAlias, writer, enclosingDeclaration, SymbolFlags.Type, SymbolFormatFlags.None, flags);
    }
    else {
        // Recursive usage, use any
        writeKeyword(writer, SyntaxKind.AnyKeyword);
    }
}

Context:

// Since instantiations of the same anonymous type have the same symbol, tracking symbols instead
// of types allows us to catch circular references to instantiations of the same anonymous type

At the very least, all the other language service support still works as intended, but obviously this is a bummer. @ahejlsberg might be able to look at it, but I don't know if that'll be be before the 2.2 release.

[AlexGalays]

What's the new milestone?

[OliverJAsh]

I don't think this is just intellisense. My generated declarations also show the same:

https://unpkg.com/twitter-api-ts@0.0.28/target/types.d.ts on line 246.

errors refers to this type: https://github.com/OliverJAsh/twitter-api-ts/blob/b86922db500225e68824764bde389087c3867388/src/types.ts#L39

[OliverJAsh]

I have tested further and this issue does seem to effect generated declarations as well. Here is a reproducible test case.

Given:

export class Type<T> {
    t: T;
}

export type TypeOf<T extends Type<any>> = T['t'];

type Props = { [key: string]: Type<any> };

declare function obj<P extends Props>(props: P): Type<{ [K in keyof P]: TypeOf<P[K]> }>;

const str = new Type<string>();

const A = obj({
    a: str,
});

export const B = obj({
    b: obj({
        c: str,
    }),
});

export type TypeOfB = TypeOf<typeof B>;

When running tsc --declaration, the generated declaration file is:

export declare class Type<T> {
    t: T;
}
export declare type TypeOf<T extends Type<any>> = T['t'];
export declare const B: Type<{
    b: any;
}>;
export declare type TypeOfB = TypeOf<typeof B>;

Given:

import * as t from 'io-ts';

export const NestedInterface = t.type({
    foo: t.string,
    bar: t.type({
        baz: t.string,
    }),
});

export type NestedInterfaceType = t.TypeOf<typeof NestedInterface>;

When running tsc --declaration, the generated declaration file is:

import * as t from 'io-ts';
export declare const NestedInterface: t.InterfaceType<{
    foo: t.StringType;
    bar: t.InterfaceType<{
        baz: t.StringType;
    }, {
        baz: string;
    }, {
        baz: string;
    }, t.mixed>;
}, {
    foo: string;
    bar: any;
}, {
    foo: string;
    bar: any;
}, t.mixed>;
export declare type NestedInterfaceType = t.TypeOf<typeof NestedInterface>;

[pelotom]

Any plans to fix this? It breaks io-ts and runtypes rather severely.