Type inference fails

[newcat]

TypeScript Version: 4.2.0-dev.20201127

Search Terms:

• typescript type inference
• typescript type not inferred correctly
• typescript mapped types

Code

interface INodeIO<T = any> {
    value: T;
}

type IODefinition = Record<string, INodeIO>;
type IODefinitionValues<D extends IODefinition> = {
    [K in keyof D]: D[K] extends INodeIO<infer T> ? T : never;
};
type CalcFunc<I extends IODefinition, O extends IODefinition> = (
    inputs: IODefinitionValues<I>
) => IODefinitionValues<O>;

type NodeDefinition<I extends IODefinition, O extends IODefinition> = {
    setup(): { inputs: I; outputs: O };
    calculate?: CalcFunc<I, O>;
};

function defineNode<I extends IODefinition, O extends IODefinition>(def: NodeDefinition<I, O>) {
    return def; // placeholder
}

// T1 is correctly identified as
// T1 = { hello: number; }
type T1 = IODefinitionValues<{ hello: { value: number } }>;

// T2 is identified as (inputs: IODefinitionValues<{ test: { value: number; };}>) => IODefinitionValues<{ ret: { value: boolean; }; }>
type T2 = CalcFunc<{ test: { value: number } }, { ret: { value: boolean } }>;


// This works as expected, Intellisense is working and I get type errors when using the wrong type
const calcFuncTest: T2 = (def) => ({ ret: Boolean(def.test) });
calcFuncTest({ test: 3 });

defineNode({
    setup() {
        return {
            inputs: {
                a: { value: 3 },
                b: { value: "bar" }
            },
            outputs: {
                c: { value: false },
                d: { value: "foo" }
            }
        };
    },
    calculate(inputs) {
        return {
            c: inputs.v, // (1)
            d: inputs.a, // (2)
        };
    }
});

Expected behavior:

• (1) should give an error, since inputs.v does not exist
• (2) should give an error, since inputs.a is a number, while d is a string

Actual behavior:
The code above compiles without errors. Also, Intellisense is not working at the calculate function inside defineNode.

Playground Link:
Link

Related Issues:

[jcalz]

Could you provide a more minimal example?

Possibly related to #33042, #39838, #38872, maybe others?

[newcat]

Tried shrinking it a bit, wasn't too successful (new playground link). But I replaced the domain-specific language with some generic terms so I hope it is a bit easier to understand. I'll explain it in more detail below.

class Wrapper<T = any> {
    public value?: T;
}

type WrappedMap = Record<string, Wrapper>;
type Unwrap<D extends WrappedMap> = {
    [K in keyof D]: D[K] extends Wrapper<infer T> ? T : never;
};

type MappingComponent<I extends WrappedMap, O extends WrappedMap> = {
    setup(): { inputs: I; outputs: O };
    map?: (inputs: Unwrap<I>) => Unwrap<O>;
};

declare function createMappingComponent<I extends WrappedMap, O extends WrappedMap>(def: MappingComponent<I, O>): void;

createMappingComponent({
    setup() {
        return {
            inputs: {
                num: new Wrapper<number>(),
                str: new Wrapper<string>()
            },
            outputs: {
                bool: new Wrapper<boolean>(),
                str: new Wrapper<string>()
            }
        };
    },
    map(inputs) {
        return {
            bool: inputs.nonexistent, // (1)
            str: inputs.num,          // (2)
        };
    }
});

Essentially, the code is about creating a MappingComponent, which has some defined inputs I and some defined outputs O. In the setup() method, these inputs and outputs are defined as a Record<string, Wrapper> each. These wrapper instances can be seen as placeholders.

The map function receives the values of the input placeholders (input Wrapper), so in this example it would be { num: <some number>, str: <some string> }. It needs to return values for the output placeholders like this { bool: <some boolean>, str: <some string> }.

Similar to above, I expect

• (1) should give an error, since inputs.nonexistent does not exist
• (2) should give an error, since inputs.num is a number, while str should be a string

Interestingly, the outputs O are inferred correctly. So for example, returning bool: 3 in the map function creates an error, since 3 is not a boolean.

[RyanCavanaugh]

I don't see any evidence of a bug here. The inference for a setup like this is extremely complex, but if the type parameters are set up correctly then you would see the expected errors.

class Wrapper<T> {
    public value?: T;
}

type WrappedMap<Values> = Record<string, Wrapper<Values>>;
type Unwrap<D extends WrappedMap<unknown>> = {
    [K in keyof D]: D[K] extends Wrapper<infer T> ? T : never;
};

type MappingComponent<I extends WrappedMap<unknown>, O extends WrappedMap<unknown>> = {
    setup(): { inputs: I; outputs: O };
    map?: (inputs: Unwrap<I>) => Unwrap<O>;
};

declare function createMappingComponent<I extends WrappedMap<unknown>, O extends WrappedMap<unknown>>(def: MappingComponent<I, O>): MappingComponent<I, O>;

const res = createMappingComponent({
    setup() {
        return {
            inputs: {
                num: new Wrapper<number>(),
                str: new Wrapper<string>()
            },
            outputs: {
                bool: new Wrapper<boolean>(),
                str: new Wrapper<string>()
            }
        };
    },
    // Errors as expected
    map(inputs) {
        return {
            bool: inputs.nonexistent, // (1)
            str: inputs.num,          // (2)
        };
    }
});

Because there's a Record<string, in the definition of WrappedMap, you're not going to get an error on inputs.nonexistent, but it will produce unknown which triggers a downstream error.

[newcat]

I tried your code, however, I get errors on correct code now, because the values of inputs are of type unknown now. Example of a correct map function in the context above:

map(inputs) {
    return {
        bool: true,
        str: inputs.str,
    };
}

Results in this error:

Type '(inputs: Unwrap<Record<string, Wrapper<unknown>>>) => { bool: boolean; str: unknown; }' is not assignable to type '(inputs: Unwrap<Record<string, Wrapper<unknown>>>) => Unwrap<{ bool: Wrapper<boolean>; str: Wrapper<string>; }>'.
  Call signature return types '{ bool: boolean; str: unknown; }' and 'Unwrap<{ bool: Wrapper<boolean>; str: Wrapper<string>; }>' are incompatible.
    The types of 'str' are incompatible between these types.
      Type 'unknown' is not assignable to type 'string'.(2322)
input.tsx(12, 5): The expected type comes from property 'map' which is declared here on type 'MappingComponent<Record<string, Wrapper<unknown>>, { bool: Wrapper<boolean>; str: Wrapper<string>; }>'

This may very well be a design limitation, because when the map function is not present, the type of res is correctly inferred as

const res: MappingComponent<{
    num: Wrapper<number>;
    str: Wrapper<string>;
}, {
    bool: Wrapper<boolean>;
    str: Wrapper<string>;
}>

As soon as I write the mapping function, the type of res changes to:

const res: MappingComponent<Record<string, Wrapper<unknown>>, Record<string, Wrapper<unknown>>>