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?

Es werden keine Dateien, Tests oder Compiler-Einstiegspunkte genannt. Beginne mit der Durchsicht der GenericClass- und Map-Beispiele und verfolge anschließend, wie Konstruktor-Typargumente aus dem empfangenden Ausdruck abgeleitet werden. Die Aufgabe ist abgeschlossen, wenn der Umgang mit kontextbezogenen Standardwerten, indirekten Aufrufen, abgeleiteten Klassen und der Konstruktorsemantik geklärt ist.