Typescript: Not reporting error of deep object literal as expected

[vilic]

TypeScript Version: 3.6.3 / 3.7.0-dev.20191021

Search Terms: type check, no error, large object

Code

interface A {
  b: B[];
}

interface B {
  c: C;
}

interface C {
  d: D[];
}

interface D {
  e: E[];
}

interface E {
  f: F[];
}

interface F {
  g: G;
}

interface G {
  h: H[];
}

interface H {
  i: string;
}

const x: A = {
  b: [
    {
      c: {
        d: [
          {
            e: [
              {
                f: [
                  {
                    g: {
                      h: [
                        {
                          // intellisense still works, but type check fails here
                          // i: '',
                        },
                      ],
                    },
                  },
                ],
              },
            ],
          },
        ],
      },
    },
  ],
};

Expected behavior:

Reporting error as property i is missing.

Actual behavior:

No error.

Playground Link: http://www.typescriptlang.org/play/?ts=Nightly&ssl=1&ssc=1&pln=61&pc=1#code/JYOwLgpgTgZghgYwgAgILIN4ChnIEYBcyAQgNoC6A3FgL5ZaiSyIrGY7IJEDC1dD4aPCTJu7XABMiAEQp96jIS2TTxyCEQCic2gsHMRmtTCIAxHf0UGUptQHMiAcXkCmwlI7UALIgAkLem7KvmrARADOYFCgdi4IAPYgkcgAHkToALxqhMikHLjYuEWcRIXFRVK5+eUF1TW4GlX19WXNNSZNbc2tXfUOar1tPp2DXT2jbQD0k8hgAJ4ADigIXhAIANbI8MAANuHIq1AQdRP108hhyADkVwA0J6dFNPePNeQvr7jPD73fj+8-Gp-XoArrAt4fYrg5DAgE0ahAA

[fatcerberus]

This is fun, type checking for the contents of H[] seems to be completely disabled, you can stuff literally anything you want into that array and TypeScript won't make a peep:

• Playground

[RyanCavanaugh]

@ahejlsberg I'm not aware of any limiters that should apply in this scenario?

[ahejlsberg]

The example is running into the depth limiter for nested instantiations of the same type. We stop once we've seen five or more instantiations, in this case of type Array<T>. Here's a very simple repro:

const aa: string[][][][][] = [[[[[42]]]]];  // No error!

I'm going think about the best way to not trigger from nested literals (which are never recursive).