Typescript getter 类型推断

Question

Typescript seems to be inferring field types strictly based on the private variable of a field. However, it won't complain if the getter returns a type union (1), nor will it infer the actual type from the getter (2):

    test('field type inference', () => {
  class A {
    x_: number;

    // 1: no type checking here
    get x(): number | undefined {
      if (this.x_ === 1) return undefined;
      return this.x_;
    }

    set x(v: number | undefined ) {
      this.x_ = +v;
    }
  }

  const a = new A();
  a.x = 1;

  // 2: The inferred type is number (as of x_, instead of getter)
  const x: number = a.x;

  console.log(a.x) // outputs 'undefined'
})

Is this specified / expected behavior?

Later edit. Note that strictNullCheck will not catch this either. The only two it will are missing initialization and setter

The following example with strictNullCheck warnings fixed:

test('field type inference', () => {
  class A {
    x_: number;

    get x(): number | undefined {
      if (this.x_ === 1) return undefined;
      return this.x_;
    }

    set x(v: number | undefined ) {
      this.x_ = +(v ?? 0);
    }

    constructor(value: number) {
      this.x_ = value;
    }
  }

  const a = new A(2);
  a.x = 1;

  const x: number = a.x;

  console.log(a.x)
});

Answer 1

Firstly, when you have properties typescript assumes that reading from the property will retrieve the value last written to that property. You getter/setter here breaks that convention. But because each get/set function is technically typesafe on it's own, typescript doesn't notice anything wrong.

Second, when you assign a constant to a property typed as a union, typescript remembers which member of that union applies for the rest of that scope. The fact you have logic in those getters/setters doesn't matter.

It's got nothing to do with the private property, and everything to do with the public one.

Let's say you had this very simple class:

// No getters/setters
class B {
  x: number | undefined
}

const b = new B()
b.x // number | undefined
b.x = 1
b.x // number

As you can see, typescript remembers what you've assigned, knows it's not undefined, and then strips that from the resulting type of the property in any where it can know that to be true.

---

Now let's try this class:

// useless getters/setters
class C {
  get x(): number | undefined {
    return undefined;
  }

  set x(v: number | undefined ) {
    // no-op
  }
}

const c = new C()
c.x // number | undefined
c.x = 1
c.x // number

Now the getters/setters are useless, but it gives you the "wrong" results.

Playground

---

Typescript expects a getter to return the last set value if that last value was set in the same synchronously executed scope. In fact most programmers probably would, too.

Ideally the compiler would flag an issue with something here, but tracing the type safety through these setters is actually a pretty complex thing to do.