Export function with public signature not allowed

[mwisnicki]

This is my sub-case of https://typescript.codeplex.com/workitem/1312.

Consider trivial export of function:

module foo {
    function bar() {}
    export var pub = bar;
}

Compiler will complain about exporting private type bar. I could type it explicitly as ()=>void but it doesn't scale to real world usage like wrapping functions with potentially complex, generic signatures:

module foo {
    function wrap<T extends Function>(f: T): T {
        /* complex wrapping */
        return f;
    }

    /* complex generic signature */
    function _bar<T>() {}

    export var bar = wrap(_bar);
}

[RyanCavanaugh]

This is fixed in the new compiler.

[fdecampredon]

Wow it seems a big change and a pretty cool one, following the long discussion on codeplex could you explicit the new rules about export and private type ?

[RyanCavanaugh]

I'm not 100% on how this works, but the fundamental change is that we've changed our philosophy on .d.ts emit a bit -- rather than excluding a broad class of patterns that might be problematic (mostly around trying to anonymize types that might be self-referential), we're instead going with the theory that yes, sometimes you will be able to write a .ts file for which we cannot generate a .d.ts file, but we'll just let you deal with that fact when it comes up rather than trying to block the scenario from the beginning.

[fdecampredon]

sounds reasonable thanks for the explanation

[abergs]

👍 In which version of TS will this be shipped?

[RyanCavanaugh]

1.1 will be the first release of the new compiler. We haven't announced a schedule for it yet.

[thrandre]

This feature is still not released, or am I mistaken? Running version 1.3 of the compiler.

[RyanCavanaugh]

This issue as described is fixed in 1.3. Can you post an example of something you'd expect to work that doesn't?

[thrandre]

class Foo {}

var foo = new Foo();

export = foo;

I don't know if this is supposed to work or not. I'm getting the old "Exported variable 'foo' has or is using private type Foo" message.

[RyanCavanaugh]

That code compiles for me in 1.3 as long as --d isn't specified, which is the expected behavior.

[thrandre]

@RyanCavanaugh My fault. You are totally right - it does compile. R# was giving me a hard time.

[asgerhallas]

@thrandre off topic, but do you know if there's a way to get rid of resharpers incorrect warning about this? :)