Bug: Accessing private statics in a class via its derived class is allowed

[JoshuaKGoldberg]

TypeScript Version:

1.8.X

Code

class FooBase {
    private static privateStatic: string = "";

    testBase(): void {
        console.log(FooBase.privateStatic);

        // Should error, but doesn't
        console.log(Foo.privateStatic);
   }
}

class Foo extends FooBase {
    test() {
        // Should error, and does
        console.log(Foo.privateStatic);
    }
}

Expected behavior:
Accessing Foo.privateStatic shouldn't be allowed, regardless of the context it's called in.

Actual behavior:
FooBase is allowed to do this.

(thanks @sethbrenith for deducing this)

[Elephant-Vessel]

What's the motivation?

[JoshuaKGoldberg]

@Elephant-Vessel not sure what you mean. This is incorrect behavior, yes?

[Elephant-Vessel]

I'm just curious about why this would be regarded as incorrect behavior. This works for example fine in C#, why would it be incorrect in the context of TypeScript?

[mhegazy]

looking at this again, i is not a bug. it behaves as intended. see https://github.com/Microsoft/TypeScript/blob/master/doc/spec.md#822-accessibility

Private property members can be accessed only within their declaring class. Specifically, a private member M declared in a class C can be accessed only within the class body of C.

the private property privateStatic property is accessed within the class declaring it. there are no restriction on what type it is accessed through (e.g. like the case with protected).

[JoshuaKGoldberg]

Interesting. I disagree with both the TypeScript and C# spec in that accessing a member (static or otherwise) of an item implies that it's a publicly available property of that item. But, if you & the other spec writers believe otherwise, looks like the issue ends here.

@Elephant-Vessel this behavior was flagged when enabling the no-unused-variable tslint rule. We were a bit weirded out that it was allowed.

[JoshuaKGoldberg]

Funny enough I actually encountered a bug caused by this behavior today.

class FooBase {
    private static privateStatic: string = "unset";

    testPrivateStatic(): void {
        Foo.privateStatic = "set";
        console.log(FooBase.privateStatic);
   }
}

class Foo extends FooBase { }

// Logs "unset" but you'd expect it to log "set"
new FooBase().testPrivateStatic();

@mhegazy, I think the spec should be changed. Does this change your mind? :)
@Elephant-Vessel In C# you're accessing the same member regardless of which class it's entering through. In TypeScript it's a member of the explicit class you're looking at.