Can't use a class like an interface if has private members

[yortus]

TypeScript Version: nightly (2.0.0-dev.20160629)

Code

// This example works great. The 'MockFoo' implementation must have
// the same shape as 'RealFoo', but shares no implementation. We get
// compile-time errors if any members are missing or incompatible.
// This saves the boilerplate of separately maintaining a 'Foo' interface.
class RealFoo {
    foo() { return 'real foo'}
}
class MockFoo implements RealFoo { // NB: 'implements', not 'extends'
    foo() { return 'mock foo'}
}


// This example works not so great:
class RealBar {
    bar() { return 'real bar'}
    private p;
}
class MockBar1 implements RealBar { // ERROR: Property 'p' is missing in type 'MockBar1'
    bar() { return 'mock bar'}
}
class MockBar2 implements RealBar { // ERROR: Types have separate declarations of private property 'p'
    bar() { return 'mock bar'}
    private p;
}


// This also doesn't work. Strange error, given that the 'Bar' interface doesn't have a 'p'.
interface Bar extends RealBar { } // Automagically extract an interface from 'RealBar'
class MockBar3 implements Bar { // ERROR: Property 'p' is missing in type 'MockBar3'
    bar() { return 'mock bar'}
}

Expected behavior:
I expected all the examples above to compile without errors.

Actual behavior:
Compile-time errors are issued as shown in the code comments above.

Additional Info:
I should note that I'm using a technique above that I'm not 100% sure is officially sanctioned, even though it works beautifully as in the first example:

1. An interface can extend a class as a shortcut for getting all the class's public shape as if it was an interface.
2. In addition to (1), a class can also implement another class as if it were just an interface. It's different from extends in that it's purely compile time, and not runtime implementation is shared with the 'implemented' class.

In my case, that second 'feature' saves a substantial amount of boilerplate work associated with maintaining a separate interface.

The problem, as noted in the code comments, is that if the class has private members, then these members seem to prevent it from being used like an interface. I don't know why the private members matter - I though they should just be omitted when looking at the interface representation of a class.

[yortus]

After deeper digging, this is a duplicate of #471 (coincidentally duplicated right down to the MockFoo in the example).

#471 is closed, but tagged 'revisit'. I do hope it can be revisited with a workable solution.