Mapped type over any incorrectly rejects structural assignability

[tmadeira]

Behavior difference: tsgo produces different results than TypeScript 6.0.

Steps to reproduce

Repository with minimal code to reproduce the issue: https://github.com/tmadeira/ts7-yup-bug

repro.ts (requires yup@1.6.1):

import { object, string, number, ObjectSchema } from "yup";
import type { AnyObjectSchema } from "yup";

interface MyValues {
  foo: string;
  bar: number;
}

const specific: ObjectSchema<MyValues> = object({
  foo: string().required(),
  bar: number().required(),
});

const test: AnyObjectSchema = specific;

tsconfig.json:

{
  "compilerOptions": {
    "strict": true,
    "moduleResolution": "bundler",
    "esModuleInterop": true
  },
  "include": ["repro.ts"]
}

The core issue is in how tsgo evaluates Yup's mapped type Shape:

type Shape<T extends Maybe<AnyObject>, C = any> = {
  [field in keyof T]-?: ISchema<T[field], C> | Reference;
};

When T = any, keyof any = string | number | symbol, so Shape<any, any> should structurally satisfy any concrete Shape<MyValues, AnyObject>. tsgo instead treats Shape<any, any> as having no specific keys.

Behavior with typescript@6.0

No errors. tsc 6.0.3 correctly recognizes that ObjectSchema<MyValues> is structurally assignable to AnyObjectSchema (ObjectSchema<any, any, any, any>).

Behavior with tsgo

tsgo 7.0.0-dev.20260624.1 reports TS2322:

repro.ts(14,7): error TS2322: Type 'ObjectSchema<MyValues, AnyObject, any, "">' is not assignable to type 'AnyObjectSchema'.
  The types returned by 'optional().concat' are incompatible between these types.
    ...
      Types of parameters 'schema' and 'schema' are incompatible.
        Type 'ObjectSchema<any, any, any, any>' is not assignable to type 'ObjectSchema<MyValues | undefined, AnyObject, any, "">'.
          The types returned by 'default(...).fields' are incompatible between these types.
            Type 'Shape<any, any>' is missing the following properties from type 'Shape<MyValues, AnyObject>': foo, bar

The terminal error — Shape<any, any> is missing properties foo, bar — shows that tsgo does not recognize the mapped type { [field in keyof any]-?: ... } as covering all possible keys.

In our project (yup 1.6.1, strict mode), this produces many errors. The ObjectSchema<ConcreteType> → AnyObjectSchema pattern is pervasive in Yup-based form validation.

[jakebailey]

I think this is a test:

// @strict: true
// @moduleResolution: bundler
// @noEmit: true

// Reduced from yup@1.6.1; https://github.com/microsoft/typescript-go/issues/4451
// ObjectSchema<{ foo, bar }> should be assignable to ObjectSchema<any>, but tsgo
// reports the mapped type Shape<any> as missing keys foo, bar; tsc accepts it.
// The contravariant `concat` parameter flips the comparison so Shape<any> is
// checked as the source against Shape<{ foo, bar }>.
type Shape<T> = { [field in keyof T]-?: T[field]; };
interface ObjectSchema<TIn> {
    __outputType: TIn extends {} ? {} : TIn;
    nullable(): ObjectSchema<TIn | null>;
    fields: Shape<NonNullable<TIn>>;
    concat(schema: this): this;
    partial(): ObjectSchema<Partial<TIn>>;
}
declare const specific: ObjectSchema<{ foo: string; bar: number }>;
const test: ObjectSchema<any> = specific;

[jakebailey]

This seems to be an effect of #3445, undoing that fixes the issue, but of course, undoes the fix. Anders Hejlsberg (@ahejlsberg)

[ahejlsberg]

TS7 is behaving as intended and actually fixes an issue in TS6. Consider:

declare let s1: Shape<{ foo: string, bar: string }>;
declare let s2: Shape<any>;
s1 = s2;  // Error, missing foo and bar properties

The above errors in both TS6 and TS7. However, when relating ObjectSchema<any> to ObjectSchema<{ foo: string, bar: string }>, checking of ObjectSchema instantiations gets more than three levels deep and TS6 bails out thinking that it is analyzing a generative recursive type, and the Shape mismatch is never discovered. However, with #3445, TS7 recognizes that some of the instantiations originate in resolution of explicitly written types and it therefore continues the analysis to a deeper level and discovers the Shape mismatch.