Deep nested object type inference

[eyal1990]

TypeScript Version: 3.6.4

Search Terms: Deep nested object type inference

Code

export interface A {
	b: B[];
}

export interface B {
	c: C[];
}

export interface C {
	d: D[];
}

export interface D {
	e: E[];
}
export interface E {
	id?: string;
}

// Doesn't work as expected
export const a1: A[] = [
	{
		b: [
			{
				c: [
					{
						d: [
							{
								e: [{ f: 'f' }], // Doesn't show error on f: 'f'
							},
						],
					},
				],
			},
		],
	},
];

// Work as expected
export const a2: A = {
	b: [
		{
			c: [
				{
					d: [
						{
							e: [{ f: 'f' }], // Does show error on f: 'f'
						},
					],
				},
			],
		},
	],
};

Expected behavior: Show error for unknown property 'f'

Actual behavior: Doesn't show error for unknown property 'f'

Playground Link:
http://www.typescriptlang.org/play/?ts=3.7-Beta#code/KYDwDg9gTgLgBASwHY2FAZgQwMbDgQTgG8AoASACMAuOAIQG0BdAbhIF8STRJZEU0suOsXLYaAYSasOXcNHjJUGHHnEiyAExoARKe07d5fJYLzb1wGgFE9HQ70UCVcK+oQaA-DQDOMKMgBzaQM5XmwIJF84TABGGnwmOABeOHpyUjJKGjTMsgzcsVTyXLzikq0iktz8qrJLVKI4dBoAcnQWuDZGABoykrZe2p6+sgG+4dyxzImxlhCeeHDI+EwAJnjk9WpK0oLsvprMipyqw9z6+kbmuDaOrsGqqZKJyYeyF6nhtlYgA
Related Issues:

[RyanCavanaugh]

This is fixed in the Nightly build

[fatcerberus]

Duplicate of #34619

Did that fix not make it into 3.7?

[RyanCavanaugh]

The fix missed 3.7; it will be in 3.8

[dgreensp]

I'm still getting a version of this error in 3.8 nightly:

type Test = Test[] | { contents: Test }

function verify1(a: Test): Test {
  return a
}

function verify2<A extends Test>(a: A): A {
  return a
}

export const x1 = verify1([
  [
    {
      // correctly errors in 3.8, incorrectly passes type-checking in 3.7
      contents: [[[{ x: 1 }]]],
    },
  ],
])

export const x2 = verify2([
  [
    {
      // incorrectly passes type-checking in 3.7 and 3.8!
      contents: [[[{ x: 1 }]]],
    },
  ],
])

[dgreensp]

I'm a bit concerned about the "depth limiter" that only allows five recursive instantiations of a type; what does that mean for type design? I am designing some recursive types that keep their full structure in their type parameters, basically a DSL that is fully reflected in the type structure.