Request: Optional strict typing on bracket access to properties

[xi]

Tested with TypeScript 1.8.7

I have a situation where I need to access a property on an object with bracket notation because the property name contains dots. Unfortunately, TypeScript is less strict with the bracket notation:

interface IFoo {
  n: number;
  s: string;
}

function testNumber(x : number) {
  return x;
}

function (foo : IFoo) {
  testNumber(foo.n);  // pass
  testNumber(foo.s);  // fail
  testNumber(foo.asd);  // fail

  testNumber(foo['n']);  // pass
  testNumber(foo['s']);  // fail
  testNumber(foo['asd']);  // pass
}

foo.asd in this case fails because asd is not a valid property of IFoo. But foo['asd'] is assumed to be of type any.

I read somewhere that this behavior is intentional to offer some kind of backdoor. I am pretty sure I do not need that backdoor in my project, but I need foo['asd'] to fail. So it would be great if this behavior could be optionally turned on.

I guess the --noImplicitAny option would have some effect, but unfortunately turning it on would require major changes in the rest of my codebase, so that is not an option.

[mhegazy]

JavaScript allows to index into any object. TypeScript compiler can not statically know type checked all these, e.g. var name = getName(); x[name];. so it gives it the type any.

Obviously this is not type-safe, for this you have index signatures on types, e.g.

interface IFoo {
  n: number;
  s: string;
  [x:string] : number | string;
}

testNumber(foo['asd']);  // now fails

--noImplicitAny enforces that you can not access into anything without either 1. using known property names (e.g. foo["n"] above), or 2. having an index signature on the type as outlined above.

[xi]

My report was not a question but a feature request. I will take your answer as a no to that request.

[Psvensso]

However when the index type is a number you loose some more typing.

The compiler seems to be lost when doing:

interface IFoo {
        [x: number]: number | string;
}
var t = foo['a']; // t = any

The equivalent, but using string as index key, works as expected even with "wrong" accessor type:

interface IFoo {
        [x: string]: number | string;
}
var t = foo[0]; // t = number | string;

This is perhaps a silly example but becomes odd when using enums as keys.
And in 2.1.5 you can't use enums as accessors yet so you have to use key:number.

@mhegazy any recommendations of usage here? (e.g. not getting back type:any when using key:number)

Using 2.1.5 in examples