如何在编译时捕获子类型到超类型的分配？

Question

I learnt that the

rule for TypeScript's structural type system is that x is compatible with y if y has at least the same members as x

This allows an assignment of a variable of a subtype to a variable of a supertype. Is there a way to get a compile-time error regarding that assignment?

( TypeScript Playground )

interface SuperT {
    field: string
}

// an explicitly declared subtype object for a supertype variable generates an error
const super1: SuperT = {field: 'value', extra: 1} // compile-time error: Type '{ field: string; extra: number; }' is not assignable to type 'SuperT'

function subTValue() { return {field: 'value', extra: 1} }
const super2: SuperT = subTValue() // no compile-time error, BUT HOW TO get a compile-time error here? 

Answer 1

You want exact types which aren't directly supported. You can do various tricks with generics and conditional types to get closer. Here's one way to do it indirectly:

interface SuperT {
    field: string
}

type Exactly<T, U extends T> = T & Record<Exclude<keyof U, keyof T>, never>;
const asExactlySuperT = <U extends Exactly<SuperT, U>>(superT: U) => superT;

const superOkay: SuperT = asExactlySuperT({ field: "a" }); // okay

function subTValue() { return { field: 'value', extra: 1 } }
const superBad: SuperT = asExactlySuperT(subTValue()); // error! 
// types of property "extra" are incompatible

Link to code

The idea there is that Exactly<T, U> will take a type T and a candidate type U which hopefully matches T exactly with no extra properties. If it does, then Exactly<T, U> will equal U . If it does not, then Exactly<T, U> will set the property types of any extra properties to never . Since asExactlySuperT<U>() requires that U extends Exactly<SuperT, U> , the only way that can happen is if there are no extra properties in U .

Hope that helps. Good luck!

Answer 2

As Ray Toal found out, an answer for a very similar issue can be found here . (And I knew this in the first place, I just wanted to check jcalz 's reaction time. Pretty impressive, @jcalz!)

Based on that approach, my code would look like:

( TypeScript Playground )

type StrictPropertyCheck<T, TExpected, TError> = Exclude<keyof T, keyof TExpected> extends never ? {} : TError

interface SuperT {
    field: string
}

function doIdentity<T extends SuperT>(a: T & StrictPropertyCheck<T, SuperT, "Only allowed properties of SuperT">) {
    return a
}


function subTValue() { return { field: 'value', extra: 1 } }

const super3: SuperT = doIdentity(subTValue()) // we do get a compile-time error!