Broken inference between index typed object and Record

[AlexGalays]

TypeScript Version: 2.2.2

Code

interface Errors {
  [field: string]: {
    key: string
    message: string
  }
}

const errors: Errors = {}

function genericObjectFunction<K extends string, V>(obj: Record<K, V>): [K, V][] {
  return []
}

/*
 Argument of type 'Errors' is not assignable to parameter of type 'Record<string, never>'.
 Index signatures are incompatible.
 Type '{ key: string; message: string; }' is not assignable to type 'never'.
 */
genericObjectFunction(errors)

The types seem generally compatible though, as expected this is legal:

const errorRecord: Record<string, { key: string, message: string }> = errors

Expected behavior:
genericObjectFunction(errors) should compile.

[aluanhaddad]

The reason this fails is that

interface Errors {
  [field: string]: {
    key: string
    message: string
  };
}

has no discrete keys. So the record is empty. The Record<K, V> type is defined by mapping keys to values and since there are no known values, the generic instantiation has no members.

Consider

const errors = { // no explicit type, inferred type has members, still compatible with interface.
  password: {
    key: 'minimumComplexity',
    message: 'Password must contain at least one non alphanumeric character'
  }
};

function genericObjectFunction<K extends string, V>(obj: Record<K, V>): [K, V][] {
  return [];
};

const genericErrors = genericObjectFunction(errors);

EDIT:
Here is an example with a workaround (note: the overload order is significant)

interface Errors {
  [field: string]: {
    key: string
    message: string
  }
}

const errors: Errors = {
  password: {
    key: 'minimumComplexity',
    message: 'Password must contain at least one non alphanumeric character'
  }
};

function genericObjectFunction<K extends string, V>(obj: Record<K, V>): [K, V][];
function genericObjectFunction<V>(obj: { [field: string]: V }): [string,{[P in keyof V]:V[P]}][];
function genericObjectFunction<K extends string, V>(obj: Record<string, V>): [K, V][]{
  return [];
};
const typeInferredErrors = {
  password: {
    key: 'minimumComplexity',
    message: 'Password must contain at least one non alphanumeric character'
  }
};

const genericErrorsX = genericObjectFunction(errors);
const genericErrorsY = genericObjectFunction(typeInferredErrors);

[AlexGalays]

Yes, I tried the overloads as a POC and it works. It's just a bit annoying to do that on dozens of functions :)

I understand Record tries to extract information from explicit keys and values, but couldn't a simple translation exist between the two worlds?

[aluanhaddad]

I understand Record tries to extract information from explicit keys and values, but couldn't a simple translation exist between the two worlds?

Possibly, but I feel like mixing the two could be error prone.

It is also possible that this is a bug. I do not believe it is but I could certainly be wrong.

[russelldavis]

This no longer produces an error as of v3.3.3.

Playground link: v3.1.6, with error
Playground link: v3.3.3, no error

Should this be closed?