Static class properties not fitting into index signature types

[tetranoir]

Bug Report

🔎 Search Terms

static class index signature missing

🕗 Version & Regression Information

Tested on 3.9 and 4.2

Please keep and fill in the line that best applies:

• This is the behavior in every version I tried, and I reviewed the FAQ for entries about static classes

⏯ Playground Link

Playground link with relevant code

💻 Code

class D {
  static a = 'a';
}

class E {
  static E = {a: 'a'};
}

const F = {
  a: 'a',
};

function fn1<T extends {a: string}>(arg: T) {}
fn1(D);
fn1(E.E);
fn1(F);


function fn2<T extends {[k: string]: string}>(arg: T) {}
fn2(D);  // errors
fn2({ ...D });  // errors
fn2(Object.assign({}, D));  // errors
fn2(E.E);
fn2(F);

🙁 Actual behavior

Each line here

fn2(D);
fn2({ ...D });
fn2(Object.assign({}, D));

errors

Argument of type 'typeof D' is not assignable to parameter of type '{ [k: string]: string; }'.
  Index signature is missing in type 'typeof D'.

🙂 Expected behavior

No type errors. Or at least no errors for { ...D } and Object.assign({}, D) because those both result in { a: 'a' }, without the prototype or new().

[tetranoir]

My workaround for this esoteric problem has been to create a static property const object with all properties I would have put into the static class.

class D {
  static a = 'a';
}

becomes

class D {
  static _ = { a: 'a' };
}

[MartinJohns]

Possibly related: #6480 / #37797

[RyanCavanaugh]

There are places where we allow a string index signature to be inferred, and places we don't. The general principle is that declaration merging should not be able to induce an error due to index signature violation, and as you can see from where the errors occur, that's correctly happening.

[tetranoir]

But, I think fn2({ ...D });should at least work because in object copying, the prototype is stripped out.

[RyanCavanaugh]

Declaration merging could allow non-prototype writes that would invalidate the signature

[tetranoir]

Makes sense. Thanks for the explanation!