Invalid "Use an interface instead of a type literal" warning?

[letorbi]

TypeScript Version: 2.2.1

Code

interfaces.ts

interface IKeyValue {
  [key: string]: string;
}

interface IParent {
  foo?: IKeyValue;
  goo?: string;
}

// works

export interface ITestA extends IParent {
  foo?: {
    bar: string,
  };
}

// warning

type TFoo = {
  bar: string,
};

export interface ITestB extends IParent {
  foo?: TFoo;
}

// error
/*
interface IFoo {
    bar: string;
};

interface ITestC extends IParent {
  foo: IFoo;
}
*/

export class TestInline {
  public testA: ITestA;
  public testB: ITestB;
  // public testC: ITestC;

  public foo() {
    return 'foo';
  }
}

anywhere else

import {TestInline} from 'interfaces';

const ti = new TestInline();

Expected behavior:

If the warning "Use an interface instead of a type literal" is thrown, I should be able to replace the type literal by an interface without causing an error. If type and interface are not equivalent such a warning should not be thrown.

Actual behavior:

When I'm replacing the type literal at interface.ts line 19 with an interface definition (see commented out code), the compiler throws an error: [33:11] Interface 'ITestC' incorrectly extends interface IParent [...] Index signature is missing in type 'IFoo'.

[ajafff]

Are you sure this warning comes from typescript? I'd guess that's coming from the tslint rule interface-over-type-literal https://palantir.github.io/tslint/rules/interface-over-type-literal/

[RyanCavanaugh]

Indeed this is from TSLint.

[letorbi]

Oh, sorry for the hassle...

[letorbi]

Just for reference: The TSLint guys consider the behaviour a bug in TypeScript. They refer to the issue "Index signature is missing in type (only on interfaces, not on type alias)".