Type Guard for function property leads to overloading

[arusakov]

TypeScript Version: 2.2.1

I'm confused with type guard and function property.
Type Guard can redefine property from number | undefined to number (useful for strictNullChecks mode)
But for functions such type guard has added overloading.

Code

// --strictNullChecks

class X {
  checkValSimple(): this is X & { valSimple: number } {
    return true
  }
  valSimple: number | undefined;

  checkValGetter(): this is X & { valGetter: number } {
    return true
  }
  get valGetter(): number | undefined {
    return 1
  }

  hasValFunc(): this is X & { valFunc(): number } {
    return true
  }
  valFunc(): number | undefined {
    return 1
  }
}

const x = new X();
if (x.checkValSimple()) {
  x.valSimple.toFixed() // ok
}

if (x.checkValGetter()) {
  x.valGetter.toFixed() // ok
}

if (x.hasValFunc()) {
  x.valFunc().toFixed() // Error: Object is possibly 'undefined'.
}

Expected behavior:
No error in the last case

Actual behavior:
In the last case valFunc() has two signatures:

• (): number | undefined
• (): number

[aluanhaddad]

That might seem surprising, but it is correct. Your type guard refines the type of this such that it has a --strictNullChecks distinct overload. Based on your member names, I think you may have a logic error.
Specifically, the name hasValFunc suggests the following definition rather than what you currently have.

class X {
  hasValFunc(): this is X & { valFunc(): number } {
    return !!this.valFunc;
  }
  valFunc?: () => number = () => {
    return 1;
  };
}

this changes the semantics of your class, making the function a per instance property instead of a method on X.prototype, but I think that this is also correct.

[arusakov]

@aluanhaddad
Previous example is synthetic, I can provide the better one:

// --strictNullChecks

type XData = {
  flags: {
    hasProp1: boolean,
  },
  prop1?: number,
}

class X {
  protected data: XData;

  hasProp1(): this is this & { getProp1(): number } {
    return this.data.flags.hasProp1
  }

  hasProp1Alternative(): this is this & { data: { prop1: number } } {
    return this.data.flags.hasProp1
  }

  getProp1() {
    return this.data.prop1
  }
}

const x = new X()
if (x.hasProp1()) {
  x.getProp1().toFixed() // error
}
if (x.hasProp1Alternative()) {
  x.getProp1().toFixed() // error
  x.data.prop1.toFixed() // ok, but this breaks down encapsulation
}

Here are a few main reasons:

• I have complex data struct and I want to encapsulate this inside class
• I want to use manual getters (for example for es3 compatibility)
• I don't want to access possibly nonexistent (prop1?) property (this leads to deoptimization in V8)

Maybe there is alternative way, but in my example TypeScript doesn't provide me what I want (via both hasProp1() and hasProp1Alternative())

Simple summary:
I want to change return type of an object method via using guard function. But it's not possible.

[mhegazy]

This is not the intended use of type guards as they stand today. Moreover, the intersection behavior you are seeing is consistent with the semantics of the type operator; a intersecting two signatures result in overloads. I believe you are looking for something like #11117.