Suggestion: use receiver's declared type arguments as defaults to its class constructor

I run into this relatively simple pattern a lot:

class GenericClass<T, U, V> {
    a: T;
    b: U;
    c: V;
}

let x: GenericClass<number, string, boolean>;

x = new GenericClass();
// Which produces the error:
// Error: GenericClass<{}, {}, {}> is not assignable to GenericClass<number, string, boolean>

Since x has already been defined with a particular set of type arguments, these arguments could be implicitly assumed as defaults to its type's constructor when invoked with it being the receiver (for simplicity I'm assuming here it is the exact constructor as declared e.g. not a derived class).

I understand there will be cases where that would be very difficult or even impossible to achieve:

let createInstance = () => new GenericClass()
x = createInstance();

but these are relatively rare. Most of the time it's just:

class Example {
    myMap: Map<string, Array<{n: number}>>;

    constructor() {
        this.myMap = new Map<string, Array<{n: number}>>(); // <-- Why repeat?
    }
}

Which instead could have been:

class Example {
    myMap: Map<string, Array<{n: number}>>;

    constructor() {
        this.myMap = new Map(); // <-- Better.. :)
    }
}

• Any possible issues with this? perhaps ones that I'm not aware of or haven't thought of?
• Potential name collisions? (though I'm not aware of any?)
• Maybe just a bit too difficult to implement? perhaps revisit later? (though #5256 appears more difficult than this and seems to be in consideration?)
• Or maybe this 'bends' the semantics of the constructor expression (new Class<T>()), or at least its default type arguments, in a way that's slightly unappealing from a "purist" point of view"? (though this doesn't seem like a "purist" language?). Perhaps some concept of "contextual baseline default type arguments" can be included as an integral part of the future proposal for default type arguments?

No files, tests, or compiler entry points are named. Start by reviewing the GenericClass and Map examples, then trace how constructor type arguments are inferred from the receiving expression. Done requires a settled treatment of contextual defaults, indirect calls, derived classes, and constructor semantics.