Type instantiation is excessively deep and possibly infinite. ts(2589)

[xeptore]

Bug that occurs due to excessive deep type computation.

const store = {
  state: {},
  modules: {
    a: {
      modules: {
        b: {
          modules: {
            c: {
              state: {},
              modules: {
                d: {
                  modules: {
                    e: {
                      modules: {
                        f: {
                          state: {},
                        },
                      },
                    },
                    f: {
                      state: {},
                    },
                    g: {},
                  },
                },
              },
            },
          },
        },
      },
    },
  },
};
type stateTypedStore = ModuleState<typeof store>;
//                     ^
//                     Type instantiation is excessively deep and possibly infinite. ts(2589)

[xeptore]

@millsp, @piotrwitek, could you please help me to mitigate this bug? Maybe reducing computation in someway?
I sincerely appreciate your help!

[millsp]

Have you tried to microsoft/TypeScript#30188 (comment)

[xeptore]

@millsp yes, I've seen your comment before. But, first, I don't know how to really implement this in my types. Moreover, in my case, where I need to check whether a property exists deep down the object tree, starting from a key in the root, won't this extends infer I ? Sometype<I> : never (specially never case), result in wrong outcome for that deep check? In the first comment example object, I need to know whether typeof store contains a state in its children (which in this example it exists in modules.a.modules.b.modules.c.modules.d.modules.e.modules.f)?

[millsp]

I'll take a quick look if you can set up a repro

[xeptore]

@millsp, many thanks for giving me this opportunity! 😄
I'll try to make the types and tests cases more readable today, and then I will send you highlighted test cases for different scenarios.

[xeptore]

@millsp, here is the link to playground that reproduces the error.
I tried to write rules applied for a valid state check.
Thank you for your time!

[millsp]

@xeptore I don't see any failure, would you mind adding the cases that make it break?

[xeptore]

@millsp, sorry, forgot to add a test case that causes the error. Updated at here.

Do you think that the behaviour is due to the deeply nested object structure and it is expected?

[millsp]

This is normal. There is only so much TypeScript can compute. The best thing you can do now is to try to simplify HasState to make it use less resources.

[millsp]

Or find a way to avoid using extends on the recursive type, because that's what causes the whole thing to want to be unfolded by TS.

[xeptore]

Or find a way to avoid using extends on the recursive type, because that's what causes the whole thing to want to be unfolded by TS.

This will only help to reduce the computation complexity that should be done by TS, maybe adding the ability to support 2-3 more nested layers comparing the current maximum depth, am I right?