Can't access potential member on union type

[testerez]

TypeScript Version: 2.4.0 / nightly (2.5.0-dev.201xxxxx)

Code

interface Foo {
  foo: string;
}

interface Bar {
  bar: string;
}

function test(item: Foo | Bar) {
  console.log(item.foo || item.bar)
}

Expected behavior:
This pattern is very common in javascript, that would be great to make it valid in typescript.

Actual behavior:

Property 'foo' does not exist on type 'Foo | Bar'.
  Property 'foo' does not exist on type 'Bar'.
Property 'bar' does not exist on type 'Foo | Bar'.
  Property 'bar' does not exist on type 'Foo'.

[kitsonk]

That would make the type system unsound. Doing so would cause all sorts of bad code.

You need to understand better how the typing system works. When you have a Schrödinger's cat type like that, TypeScript will only allow you to access the properties it knows are in common. If you wanted it to work, you could change the type:

interface Foo {
  foo: string;
}

interface Bar {
  bar: string;
}

function test(item: Foo & Bar) {
  console.log(item.foo || item.bar)
}

But it depends on what you are trying to do and represent properly, because you could narrow the type as well:

interface Foo {
  foo: string;
}

interface Bar {
  bar: string;
}

function isFoo(value: any): value is Foo {
  return 'foo' in value;
}

function test(item: Foo | Bar) {
  console.log(isFoo(item) ? item.foo : item.bar)
}

[RyanCavanaugh]

This has been the behavior forever and is not a bug. See #805

[testerez]

But what about stating that type of (Foo | Bar).foo is string | undefined. It seams pretty reasonable no?

[kitsonk]

No.

If you want Bar to possibly have foo then you can write it that way.

interface Bar {
  bar: string;
  foo?: string;
}

The typing system is designed to be sound. It isn't designed to be abused.