Detect deeper change in function parameters

[academo]

Currently levitate can detect trivial type changes in function parameters such as the following cases:

function old(x:number, y:string) {}
function new(x:number, y:number) {} //detect change in `y`

Or when using an interface or type:

// old
type params = {
   x: number;
   y: string;
}
function old({x, y}: params) {}


// new
type params = {
   x: number;
   y: number; // detects change in `y`
}
function new({x, y}: params) {}

But it will fail to recognize changes in more complex types such union, extensions, or in anyway processed like: Omit, Pick, etc..

example:

// old
type parentType = {
   x: number;
}

type params = parentType & { y: string};

function old({x, y}: params) {}

// new
type parentType = {
   x: string; // it won't detect `x` changed to `string`
}

type params = parentType & { y: string};

function new({x, y}: params) {}

Ideas:

There are some "hidden" APIs inside the typescript compiler that make the task of identifier changes in these complex types somehow easier: isAssignableTo, isComparableTo But they are not public and there's not much traction to make them available (see microsoft/TypeScript#9879).

Some packages such as https://github.com/SamVerschueren/tsd-typescript or https://github.com/skarab42/unleashed-typescript patch or replace typescript to expose those APIs. We could use one of those packages to access the internal APIs and detect changes.

The challenge after that is to create a human-readable diff of those types, specially in very complex ones.