False positive for TS2729 (use before initialization) in 3.8.3, nightly

[Jessidhia]

TypeScript Version: 3.8.3, nightly

Search Terms: used before initialization

Code

Reproduction requires both --target esnext and --useDefineForClassFields to be enabled.

class Foo {
    constructor (readonly foo: boolean) {}
}

class Bar extends Foo {
    bar = this.calculateBar(this.foo)

    private calculateBar(positive: boolean) {
        return positive ? 1 : -1
    }
}

Expected behavior:

Code to build.

Even if TypeScript was doing some kind of flow analysis here (which could flag this.foo instead of this.calculateBar), Foo's constructor is guaranteed to finish executing before bar's initializer gets a chance to run; and a prototype method is never not initialized.

Actual behavior:

Property 'calculateBar' is used before its initialization.(2729)
input.ts(8, 13): 'calculateBar' is declared here.

Playground Link: Playground Link

Related Issues: This seems related to #37287, just happens on different conditions

[a-tarasyuk]

Based on the test, it seems ok to use property from a base class. However, there is no case for the method, I think @sandersn can help with this issue :).

// assignParameterPropertyToPropertyDeclarationESNext.ts
// @useDefineForClassFields: true
// @target: esnext
class C {
    qux = this.bar // should error
    bar = this.foo // should error
    quiz = this.bar // ok
    m1() {
        this.foo // ok
    }
    constructor(public foo: string) {}
    quim = this.baz // should error
    baz = this.foo; // should error
    quid = this.baz // ok
    m2() {
        this.foo // ok
    }
}

class D extends C {
    quill = this.foo // ok
}

class E {
    bar = () => this.foo1 + this.foo2; // both ok
    foo1 = '';
    constructor(public foo2: string) {}
}

class F {
    Inner = class extends F {
        p2 = this.p1
    }
    p1 = 0
}

class G {
    Inner = class extends G {
        p2 = this.p1
    }
    constructor(public p1: number) {}
}

Do I need to extend the test with the property assignment which refers to a method? Like so

class C {
    qux = this.bar // should error
    bar = this.foo // should error
    quiz = this.bar // ok
    quiz1 = this.m1() // ?

    m1() {
        this.foo // ok
    }
    constructor(public foo: string) {}
    quim = this.baz // should error
    baz = this.foo; // should error
    quid = this.baz // ok
    m2() {
        this.foo // ok
    }
}

class D extends C {
    quill = this.foo // ok
    quill1 = this.m3(this.foo); // ?
    m3(str: stirng) {}
}

[Jessidhia]

It might be possible to reduce the case further without using inheritance; the actual place where I encountered it was a component that called a prototype method to generate the initial this.state of a React class (which did require a value from this.props as an argument); I used inheritance to force the this.props stand-in to be initialized by the time the subclass initializer / constructor runs.

[sandersn]

@Jessidhia yeah, here's a much smaller repro:

class C {
    p = true
    q = this.m(this.p)
    m(b: boolean) { return b }
}

As far as I can tell, this has the same problem.

@a-tarasyuk now I need to read and understand your examples =)

[a-tarasyuk]

@sandersn I took my example from the existing test. :)

[sandersn]

@a-tarasyuk thanks for pointing out the test case to add to.

I think it's just a simple bug in the new esnext-specific code in use-before-def. Those functions are a bug farm on the order of 1 fix=1 bug.