Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Track type recusion and symbol instantiation depth seperately in createAnonymousTypeNode #28490

Merged

Conversation

weswigham
Copy link
Member

@weswigham weswigham commented Nov 12, 2018

Fixes #26228 by increasing the symbol depth limit from an implied 1 to an explicit 10 repetitions of the same symbol (an individual type can still only be visited once before being printed with any). This does mean that the behavior in #26228 will recur if you chain 10+ calls.... but this will make it way less noticeable.

Also use ... for recursive locations in quick info instead of any, to (hopefully) reduce confusion as to what's being printed in the future.

////
////declare const b: boolean;
////const obj/*1*/ = schema(b);
////const actualTypeOfNested/*2*/ = schema(obj);
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Interesting. This is not circular generic type though so this shouldn't run into the circularity print in the first place. So to me it feels like we are missing something else that we can account in ID (eg. instantiations of the type as well?)

Copy link
Member Author

@weswigham weswigham Nov 12, 2018

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Right, so we track how many times we visit the same symbol, since we don't know if the symbol is generative or not (ie, does each member produce a type whose member is a new instantiation of the type) and we have tests to that effect. In this case, we do produce a type with a member of the same symbol as the overall type, but it's finite - just 2 levels deep. The explicit depth check helps distinguish these cases (rather than assuming that all recursive instantiations could be circular and printing as any).

Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I understand why you are tracking depth but what i meant was why not add (symbol.links.instatiations.typeId) to determine if we are recuring into symbol + type combination. Thus we would still not have to print something like z : { y2: { y2: { y2: { y2: { y2: { y2: { y2: { y2: { y2: { y2: { y2: any; }; }; }; }; }; }; }; }; }; }; }

Copy link
Member Author

@weswigham weswigham Nov 12, 2018

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Every y2 in that type is within a differently id'd object literal type backed by the same (well, 1 of 2, the test is mutual recursion) symbol. No symbol + type id pair will ever repeat because it generates new type ids infinitely as it recurs. Which is why we just have to track symbol depth, similarly to how we do in instantiation itself.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
None yet
Projects
None yet
Development

Successfully merging this pull request may close these issues.

2 participants