TypeScript/tests/baselines/reference/declFileMethods.types

=== tests/cases/compiler/declFileMethods_0.ts ===

export class c1 {
>c1 : c1, Symbol(c1, Decl(declFileMethods_0.ts, 0, 0))

    /** This comment should appear for foo*/
    public foo() {
>foo : () => void, Symbol(foo, Decl(declFileMethods_0.ts, 1, 17))
    }
    /** This is comment for function signature*/
    public fooWithParameters(/** this is comment about a*/a: string,
>fooWithParameters : (a: string, b: number) => void, Symbol(fooWithParameters, Decl(declFileMethods_0.ts, 4, 5))
>a : string, Symbol(a, Decl(declFileMethods_0.ts, 6, 29))

        /** this is comment for b*/
        b: number) {
>b : number, Symbol(b, Decl(declFileMethods_0.ts, 6, 68))

        var d = a;
>d : string, Symbol(d, Decl(declFileMethods_0.ts, 9, 11))
>a : string, Symbol(a, Decl(declFileMethods_0.ts, 6, 29))
    }
    public fooWithRestParameters(a: string, ...rests: string[]) {
>fooWithRestParameters : (a: string, ...rests: string[]) => string, Symbol(fooWithRestParameters, Decl(declFileMethods_0.ts, 10, 5))
>a : string, Symbol(a, Decl(declFileMethods_0.ts, 11, 33))
>rests : string[], Symbol(rests, Decl(declFileMethods_0.ts, 11, 43))

        return a + rests.join("");
>a + rests.join("") : string
>a : string, Symbol(a, Decl(declFileMethods_0.ts, 11, 33))
>rests.join("") : string
>rests.join : (separator?: string) => string, Symbol(Array.join, Decl(lib.d.ts, 1035, 31))
>rests : string[], Symbol(rests, Decl(declFileMethods_0.ts, 11, 43))
>join : (separator?: string) => string, Symbol(Array.join, Decl(lib.d.ts, 1035, 31))
>"" : string
    }

    public fooWithOverloads(a: string): string;
>fooWithOverloads : { (a: string): string; (a: number): number; }, Symbol(fooWithOverloads, Decl(declFileMethods_0.ts, 13, 5), Decl(declFileMethods_0.ts, 15, 47), Decl(declFileMethods_0.ts, 16, 47))
>a : string, Symbol(a, Decl(declFileMethods_0.ts, 15, 28))

    public fooWithOverloads(a: number): number;
>fooWithOverloads : { (a: string): string; (a: number): number; }, Symbol(fooWithOverloads, Decl(declFileMethods_0.ts, 13, 5), Decl(declFileMethods_0.ts, 15, 47), Decl(declFileMethods_0.ts, 16, 47))
>a : number, Symbol(a, Decl(declFileMethods_0.ts, 16, 28))

    public fooWithOverloads(a: any): any {
>fooWithOverloads : { (a: string): string; (a: number): number; }, Symbol(fooWithOverloads, Decl(declFileMethods_0.ts, 13, 5), Decl(declFileMethods_0.ts, 15, 47), Decl(declFileMethods_0.ts, 16, 47))
>a : any, Symbol(a, Decl(declFileMethods_0.ts, 17, 28))

        return a;
>a : any, Symbol(a, Decl(declFileMethods_0.ts, 17, 28))
    }


    /** This comment should appear for privateFoo*/
    private privateFoo() {
>privateFoo : () => void, Symbol(privateFoo, Decl(declFileMethods_0.ts, 19, 5))
    }
    /** This is comment for function signature*/
    private privateFooWithParameters(/** this is comment about a*/a: string,
>privateFooWithParameters : (a: string, b: number) => void, Symbol(privateFooWithParameters, Decl(declFileMethods_0.ts, 24, 5))
>a : string, Symbol(a, Decl(declFileMethods_0.ts, 26, 37))

        /** this is comment for b*/
        b: number) {
>b : number, Symbol(b, Decl(declFileMethods_0.ts, 26, 76))

        var d = a;
>d : string, Symbol(d, Decl(declFileMethods_0.ts, 29, 11))
>a : string, Symbol(a, Decl(declFileMethods_0.ts, 26, 37))
    }
    private privateFooWithRestParameters(a: string, ...rests: string[]) {
>privateFooWithRestParameters : (a: string, ...rests: string[]) => string, Symbol(privateFooWithRestParameters, Decl(declFileMethods_0.ts, 30, 5))
>a : string, Symbol(a, Decl(declFileMethods_0.ts, 31, 41))
>rests : string[], Symbol(rests, Decl(declFileMethods_0.ts, 31, 51))

        return a + rests.join("");
>a + rests.join("") : string
>a : string, Symbol(a, Decl(declFileMethods_0.ts, 31, 41))
>rests.join("") : string
>rests.join : (separator?: string) => string, Symbol(Array.join, Decl(lib.d.ts, 1035, 31))
>rests : string[], Symbol(rests, Decl(declFileMethods_0.ts, 31, 51))
>join : (separator?: string) => string, Symbol(Array.join, Decl(lib.d.ts, 1035, 31))
>"" : string
    }
    private privateFooWithOverloads(a: string): string;
>privateFooWithOverloads : { (a: string): string; (a: number): number; }, Symbol(privateFooWithOverloads, Decl(declFileMethods_0.ts, 33, 5), Decl(declFileMethods_0.ts, 34, 55), Decl(declFileMethods_0.ts, 35, 55))
>a : string, Symbol(a, Decl(declFileMethods_0.ts, 34, 36))

    private privateFooWithOverloads(a: number): number;
>privateFooWithOverloads : { (a: string): string; (a: number): number; }, Symbol(privateFooWithOverloads, Decl(declFileMethods_0.ts, 33, 5), Decl(declFileMethods_0.ts, 34, 55), Decl(declFileMethods_0.ts, 35, 55))
>a : number, Symbol(a, Decl(declFileMethods_0.ts, 35, 36))

    private privateFooWithOverloads(a: any): any {
>privateFooWithOverloads : { (a: string): string; (a: number): number; }, Symbol(privateFooWithOverloads, Decl(declFileMethods_0.ts, 33, 5), Decl(declFileMethods_0.ts, 34, 55), Decl(declFileMethods_0.ts, 35, 55))
>a : any, Symbol(a, Decl(declFileMethods_0.ts, 36, 36))

        return a;
>a : any, Symbol(a, Decl(declFileMethods_0.ts, 36, 36))
    }


    /** This comment should appear for static foo*/
    static staticFoo() {
>staticFoo : () => void, Symbol(c1.staticFoo, Decl(declFileMethods_0.ts, 38, 5))
    }
    /** This is comment for function signature*/
    static staticFooWithParameters(/** this is comment about a*/a: string,
>staticFooWithParameters : (a: string, b: number) => void, Symbol(c1.staticFooWithParameters, Decl(declFileMethods_0.ts, 43, 5))
>a : string, Symbol(a, Decl(declFileMethods_0.ts, 45, 35))

        /** this is comment for b*/
        b: number) {
>b : number, Symbol(b, Decl(declFileMethods_0.ts, 45, 74))

        var d = a;
>d : string, Symbol(d, Decl(declFileMethods_0.ts, 48, 11))
>a : string, Symbol(a, Decl(declFileMethods_0.ts, 45, 35))
    }
    static staticFooWithRestParameters(a: string, ...rests: string[]) {
>staticFooWithRestParameters : (a: string, ...rests: string[]) => string, Symbol(c1.staticFooWithRestParameters, Decl(declFileMethods_0.ts, 49, 5))
>a : string, Symbol(a, Decl(declFileMethods_0.ts, 50, 39))
>rests : string[], Symbol(rests, Decl(declFileMethods_0.ts, 50, 49))

        return a + rests.join("");
>a + rests.join("") : string
>a : string, Symbol(a, Decl(declFileMethods_0.ts, 50, 39))
>rests.join("") : string
>rests.join : (separator?: string) => string, Symbol(Array.join, Decl(lib.d.ts, 1035, 31))
>rests : string[], Symbol(rests, Decl(declFileMethods_0.ts, 50, 49))
>join : (separator?: string) => string, Symbol(Array.join, Decl(lib.d.ts, 1035, 31))
>"" : string
    }
    static staticFooWithOverloads(a: string): string;
>staticFooWithOverloads : { (a: string): string; (a: number): number; }, Symbol(c1.staticFooWithOverloads, Decl(declFileMethods_0.ts, 52, 5), Decl(declFileMethods_0.ts, 53, 53), Decl(declFileMethods_0.ts, 54, 53))
>a : string, Symbol(a, Decl(declFileMethods_0.ts, 53, 34))

    static staticFooWithOverloads(a: number): number;
>staticFooWithOverloads : { (a: string): string; (a: number): number; }, Symbol(c1.staticFooWithOverloads, Decl(declFileMethods_0.ts, 52, 5), Decl(declFileMethods_0.ts, 53, 53), Decl(declFileMethods_0.ts, 54, 53))
>a : number, Symbol(a, Decl(declFileMethods_0.ts, 54, 34))

    static staticFooWithOverloads(a: any): any {
>staticFooWithOverloads : { (a: string): string; (a: number): number; }, Symbol(c1.staticFooWithOverloads, Decl(declFileMethods_0.ts, 52, 5), Decl(declFileMethods_0.ts, 53, 53), Decl(declFileMethods_0.ts, 54, 53))
>a : any, Symbol(a, Decl(declFileMethods_0.ts, 55, 34))

        return a;
>a : any, Symbol(a, Decl(declFileMethods_0.ts, 55, 34))
    }


    /** This comment should appear for privateStaticFoo*/
    private static privateStaticFoo() {
>privateStaticFoo : () => void, Symbol(c1.privateStaticFoo, Decl(declFileMethods_0.ts, 57, 5))
    }
    /** This is comment for function signature*/
    private static privateStaticFooWithParameters(/** this is comment about a*/a: string,
>privateStaticFooWithParameters : (a: string, b: number) => void, Symbol(c1.privateStaticFooWithParameters, Decl(declFileMethods_0.ts, 62, 5))
>a : string, Symbol(a, Decl(declFileMethods_0.ts, 64, 50))

        /** this is comment for b*/
        b: number) {
>b : number, Symbol(b, Decl(declFileMethods_0.ts, 64, 89))

        var d = a;
>d : string, Symbol(d, Decl(declFileMethods_0.ts, 67, 11))
>a : string, Symbol(a, Decl(declFileMethods_0.ts, 64, 50))
    }
    private static privateStaticFooWithRestParameters(a: string, ...rests: string[]) {
>privateStaticFooWithRestParameters : (a: string, ...rests: string[]) => string, Symbol(c1.privateStaticFooWithRestParameters, Decl(declFileMethods_0.ts, 68, 5))
>a : string, Symbol(a, Decl(declFileMethods_0.ts, 69, 54))
>rests : string[], Symbol(rests, Decl(declFileMethods_0.ts, 69, 64))

        return a + rests.join("");
>a + rests.join("") : string
>a : string, Symbol(a, Decl(declFileMethods_0.ts, 69, 54))
>rests.join("") : string
>rests.join : (separator?: string) => string, Symbol(Array.join, Decl(lib.d.ts, 1035, 31))
>rests : string[], Symbol(rests, Decl(declFileMethods_0.ts, 69, 64))
>join : (separator?: string) => string, Symbol(Array.join, Decl(lib.d.ts, 1035, 31))
>"" : string
    }
    private static privateStaticFooWithOverloads(a: string): string;
>privateStaticFooWithOverloads : { (a: string): string; (a: number): number; }, Symbol(c1.privateStaticFooWithOverloads, Decl(declFileMethods_0.ts, 71, 5), Decl(declFileMethods_0.ts, 72, 68), Decl(declFileMethods_0.ts, 73, 68))
>a : string, Symbol(a, Decl(declFileMethods_0.ts, 72, 49))

    private static privateStaticFooWithOverloads(a: number): number;
>privateStaticFooWithOverloads : { (a: string): string; (a: number): number; }, Symbol(c1.privateStaticFooWithOverloads, Decl(declFileMethods_0.ts, 71, 5), Decl(declFileMethods_0.ts, 72, 68), Decl(declFileMethods_0.ts, 73, 68))
>a : number, Symbol(a, Decl(declFileMethods_0.ts, 73, 49))

    private static privateStaticFooWithOverloads(a: any): any {
>privateStaticFooWithOverloads : { (a: string): string; (a: number): number; }, Symbol(c1.privateStaticFooWithOverloads, Decl(declFileMethods_0.ts, 71, 5), Decl(declFileMethods_0.ts, 72, 68), Decl(declFileMethods_0.ts, 73, 68))
>a : any, Symbol(a, Decl(declFileMethods_0.ts, 74, 49))

        return a;
>a : any, Symbol(a, Decl(declFileMethods_0.ts, 74, 49))
    }
}

export interface I1 {
>I1 : I1, Symbol(I1, Decl(declFileMethods_0.ts, 77, 1))

    /** This comment should appear for foo*/
    foo(): string;
>foo : () => string, Symbol(foo, Decl(declFileMethods_0.ts, 79, 21))

    /** This is comment for function signature*/
    fooWithParameters(/** this is comment about a*/a: string,
>fooWithParameters : (a: string, b: number) => void, Symbol(fooWithParameters, Decl(declFileMethods_0.ts, 81, 18))
>a : string, Symbol(a, Decl(declFileMethods_0.ts, 84, 22))

        /** this is comment for b*/
        b: number): void;
>b : number, Symbol(b, Decl(declFileMethods_0.ts, 84, 61))

    fooWithRestParameters(a: string, ...rests: string[]): string;
>fooWithRestParameters : (a: string, ...rests: string[]) => string, Symbol(fooWithRestParameters, Decl(declFileMethods_0.ts, 86, 25))
>a : string, Symbol(a, Decl(declFileMethods_0.ts, 88, 26))
>rests : string[], Symbol(rests, Decl(declFileMethods_0.ts, 88, 36))

    fooWithOverloads(a: string): string;
>fooWithOverloads : { (a: string): string; (a: number): number; }, Symbol(fooWithOverloads, Decl(declFileMethods_0.ts, 88, 65), Decl(declFileMethods_0.ts, 90, 40))
>a : string, Symbol(a, Decl(declFileMethods_0.ts, 90, 21))

    fooWithOverloads(a: number): number;
>fooWithOverloads : { (a: string): string; (a: number): number; }, Symbol(fooWithOverloads, Decl(declFileMethods_0.ts, 88, 65), Decl(declFileMethods_0.ts, 90, 40))
>a : number, Symbol(a, Decl(declFileMethods_0.ts, 91, 21))
}

=== tests/cases/compiler/declFileMethods_1.ts ===
class c2 {
>c2 : c2, Symbol(c2, Decl(declFileMethods_1.ts, 0, 0))

    /** This comment should appear for foo*/
    public foo() {
>foo : () => void, Symbol(foo, Decl(declFileMethods_1.ts, 0, 10))
    }
    /** This is comment for function signature*/
    public fooWithParameters(/** this is comment about a*/a: string,
>fooWithParameters : (a: string, b: number) => void, Symbol(fooWithParameters, Decl(declFileMethods_1.ts, 3, 5))
>a : string, Symbol(a, Decl(declFileMethods_1.ts, 5, 29))

        /** this is comment for b*/
        b: number) {
>b : number, Symbol(b, Decl(declFileMethods_1.ts, 5, 68))

        var d = a;
>d : string, Symbol(d, Decl(declFileMethods_1.ts, 8, 11))
>a : string, Symbol(a, Decl(declFileMethods_1.ts, 5, 29))
    }
    public fooWithRestParameters(a: string, ...rests: string[]) {
>fooWithRestParameters : (a: string, ...rests: string[]) => string, Symbol(fooWithRestParameters, Decl(declFileMethods_1.ts, 9, 5))
>a : string, Symbol(a, Decl(declFileMethods_1.ts, 10, 33))
>rests : string[], Symbol(rests, Decl(declFileMethods_1.ts, 10, 43))

        return a + rests.join("");
>a + rests.join("") : string
>a : string, Symbol(a, Decl(declFileMethods_1.ts, 10, 33))
>rests.join("") : string
>rests.join : (separator?: string) => string, Symbol(Array.join, Decl(lib.d.ts, 1035, 31))
>rests : string[], Symbol(rests, Decl(declFileMethods_1.ts, 10, 43))
>join : (separator?: string) => string, Symbol(Array.join, Decl(lib.d.ts, 1035, 31))
>"" : string
    }

    public fooWithOverloads(a: string): string;
>fooWithOverloads : { (a: string): string; (a: number): number; }, Symbol(fooWithOverloads, Decl(declFileMethods_1.ts, 12, 5), Decl(declFileMethods_1.ts, 14, 47), Decl(declFileMethods_1.ts, 15, 47))
>a : string, Symbol(a, Decl(declFileMethods_1.ts, 14, 28))

    public fooWithOverloads(a: number): number;
>fooWithOverloads : { (a: string): string; (a: number): number; }, Symbol(fooWithOverloads, Decl(declFileMethods_1.ts, 12, 5), Decl(declFileMethods_1.ts, 14, 47), Decl(declFileMethods_1.ts, 15, 47))
>a : number, Symbol(a, Decl(declFileMethods_1.ts, 15, 28))

    public fooWithOverloads(a: any): any {
>fooWithOverloads : { (a: string): string; (a: number): number; }, Symbol(fooWithOverloads, Decl(declFileMethods_1.ts, 12, 5), Decl(declFileMethods_1.ts, 14, 47), Decl(declFileMethods_1.ts, 15, 47))
>a : any, Symbol(a, Decl(declFileMethods_1.ts, 16, 28))

        return a;
>a : any, Symbol(a, Decl(declFileMethods_1.ts, 16, 28))
    }


    /** This comment should appear for privateFoo*/
    private privateFoo() {
>privateFoo : () => void, Symbol(privateFoo, Decl(declFileMethods_1.ts, 18, 5))
    }
    /** This is comment for function signature*/
    private privateFooWithParameters(/** this is comment about a*/a: string,
>privateFooWithParameters : (a: string, b: number) => void, Symbol(privateFooWithParameters, Decl(declFileMethods_1.ts, 23, 5))
>a : string, Symbol(a, Decl(declFileMethods_1.ts, 25, 37))

        /** this is comment for b*/
        b: number) {
>b : number, Symbol(b, Decl(declFileMethods_1.ts, 25, 76))

        var d = a;
>d : string, Symbol(d, Decl(declFileMethods_1.ts, 28, 11))
>a : string, Symbol(a, Decl(declFileMethods_1.ts, 25, 37))
    }
    private privateFooWithRestParameters(a: string, ...rests: string[]) {
>privateFooWithRestParameters : (a: string, ...rests: string[]) => string, Symbol(privateFooWithRestParameters, Decl(declFileMethods_1.ts, 29, 5))
>a : string, Symbol(a, Decl(declFileMethods_1.ts, 30, 41))
>rests : string[], Symbol(rests, Decl(declFileMethods_1.ts, 30, 51))

        return a + rests.join("");
>a + rests.join("") : string
>a : string, Symbol(a, Decl(declFileMethods_1.ts, 30, 41))
>rests.join("") : string
>rests.join : (separator?: string) => string, Symbol(Array.join, Decl(lib.d.ts, 1035, 31))
>rests : string[], Symbol(rests, Decl(declFileMethods_1.ts, 30, 51))
>join : (separator?: string) => string, Symbol(Array.join, Decl(lib.d.ts, 1035, 31))
>"" : string
    }
    private privateFooWithOverloads(a: string): string;
>privateFooWithOverloads : { (a: string): string; (a: number): number; }, Symbol(privateFooWithOverloads, Decl(declFileMethods_1.ts, 32, 5), Decl(declFileMethods_1.ts, 33, 55), Decl(declFileMethods_1.ts, 34, 55))
>a : string, Symbol(a, Decl(declFileMethods_1.ts, 33, 36))

    private privateFooWithOverloads(a: number): number;
>privateFooWithOverloads : { (a: string): string; (a: number): number; }, Symbol(privateFooWithOverloads, Decl(declFileMethods_1.ts, 32, 5), Decl(declFileMethods_1.ts, 33, 55), Decl(declFileMethods_1.ts, 34, 55))
>a : number, Symbol(a, Decl(declFileMethods_1.ts, 34, 36))

    private privateFooWithOverloads(a: any): any {
>privateFooWithOverloads : { (a: string): string; (a: number): number; }, Symbol(privateFooWithOverloads, Decl(declFileMethods_1.ts, 32, 5), Decl(declFileMethods_1.ts, 33, 55), Decl(declFileMethods_1.ts, 34, 55))
>a : any, Symbol(a, Decl(declFileMethods_1.ts, 35, 36))

        return a;
>a : any, Symbol(a, Decl(declFileMethods_1.ts, 35, 36))
    }


    /** This comment should appear for static foo*/
    static staticFoo() {
>staticFoo : () => void, Symbol(c2.staticFoo, Decl(declFileMethods_1.ts, 37, 5))
    }
    /** This is comment for function signature*/
    static staticFooWithParameters(/** this is comment about a*/a: string,
>staticFooWithParameters : (a: string, b: number) => void, Symbol(c2.staticFooWithParameters, Decl(declFileMethods_1.ts, 42, 5))
>a : string, Symbol(a, Decl(declFileMethods_1.ts, 44, 35))

        /** this is comment for b*/
        b: number) {
>b : number, Symbol(b, Decl(declFileMethods_1.ts, 44, 74))

        var d = a;
>d : string, Symbol(d, Decl(declFileMethods_1.ts, 47, 11))
>a : string, Symbol(a, Decl(declFileMethods_1.ts, 44, 35))
    }
    static staticFooWithRestParameters(a: string, ...rests: string[]) {
>staticFooWithRestParameters : (a: string, ...rests: string[]) => string, Symbol(c2.staticFooWithRestParameters, Decl(declFileMethods_1.ts, 48, 5))
>a : string, Symbol(a, Decl(declFileMethods_1.ts, 49, 39))
>rests : string[], Symbol(rests, Decl(declFileMethods_1.ts, 49, 49))

        return a + rests.join("");
>a + rests.join("") : string
>a : string, Symbol(a, Decl(declFileMethods_1.ts, 49, 39))
>rests.join("") : string
>rests.join : (separator?: string) => string, Symbol(Array.join, Decl(lib.d.ts, 1035, 31))
>rests : string[], Symbol(rests, Decl(declFileMethods_1.ts, 49, 49))
>join : (separator?: string) => string, Symbol(Array.join, Decl(lib.d.ts, 1035, 31))
>"" : string
    }
    static staticFooWithOverloads(a: string): string;
>staticFooWithOverloads : { (a: string): string; (a: number): number; }, Symbol(c2.staticFooWithOverloads, Decl(declFileMethods_1.ts, 51, 5), Decl(declFileMethods_1.ts, 52, 53), Decl(declFileMethods_1.ts, 53, 53))
>a : string, Symbol(a, Decl(declFileMethods_1.ts, 52, 34))

    static staticFooWithOverloads(a: number): number;
>staticFooWithOverloads : { (a: string): string; (a: number): number; }, Symbol(c2.staticFooWithOverloads, Decl(declFileMethods_1.ts, 51, 5), Decl(declFileMethods_1.ts, 52, 53), Decl(declFileMethods_1.ts, 53, 53))
>a : number, Symbol(a, Decl(declFileMethods_1.ts, 53, 34))

    static staticFooWithOverloads(a: any): any {
>staticFooWithOverloads : { (a: string): string; (a: number): number; }, Symbol(c2.staticFooWithOverloads, Decl(declFileMethods_1.ts, 51, 5), Decl(declFileMethods_1.ts, 52, 53), Decl(declFileMethods_1.ts, 53, 53))
>a : any, Symbol(a, Decl(declFileMethods_1.ts, 54, 34))

        return a;
>a : any, Symbol(a, Decl(declFileMethods_1.ts, 54, 34))
    }


    /** This comment should appear for privateStaticFoo*/
    private static privateStaticFoo() {
>privateStaticFoo : () => void, Symbol(c2.privateStaticFoo, Decl(declFileMethods_1.ts, 56, 5))
    }
    /** This is comment for function signature*/
    private static privateStaticFooWithParameters(/** this is comment about a*/a: string,
>privateStaticFooWithParameters : (a: string, b: number) => void, Symbol(c2.privateStaticFooWithParameters, Decl(declFileMethods_1.ts, 61, 5))
>a : string, Symbol(a, Decl(declFileMethods_1.ts, 63, 50))

        /** this is comment for b*/
        b: number) {
>b : number, Symbol(b, Decl(declFileMethods_1.ts, 63, 89))

        var d = a;
>d : string, Symbol(d, Decl(declFileMethods_1.ts, 66, 11))
>a : string, Symbol(a, Decl(declFileMethods_1.ts, 63, 50))
    }
    private static privateStaticFooWithRestParameters(a: string, ...rests: string[]) {
>privateStaticFooWithRestParameters : (a: string, ...rests: string[]) => string, Symbol(c2.privateStaticFooWithRestParameters, Decl(declFileMethods_1.ts, 67, 5))
>a : string, Symbol(a, Decl(declFileMethods_1.ts, 68, 54))
>rests : string[], Symbol(rests, Decl(declFileMethods_1.ts, 68, 64))

        return a + rests.join("");
>a + rests.join("") : string
>a : string, Symbol(a, Decl(declFileMethods_1.ts, 68, 54))
>rests.join("") : string
>rests.join : (separator?: string) => string, Symbol(Array.join, Decl(lib.d.ts, 1035, 31))
>rests : string[], Symbol(rests, Decl(declFileMethods_1.ts, 68, 64))
>join : (separator?: string) => string, Symbol(Array.join, Decl(lib.d.ts, 1035, 31))
>"" : string
    }
    private static privateStaticFooWithOverloads(a: string): string;
>privateStaticFooWithOverloads : { (a: string): string; (a: number): number; }, Symbol(c2.privateStaticFooWithOverloads, Decl(declFileMethods_1.ts, 70, 5), Decl(declFileMethods_1.ts, 71, 68), Decl(declFileMethods_1.ts, 72, 68))
>a : string, Symbol(a, Decl(declFileMethods_1.ts, 71, 49))

    private static privateStaticFooWithOverloads(a: number): number;
>privateStaticFooWithOverloads : { (a: string): string; (a: number): number; }, Symbol(c2.privateStaticFooWithOverloads, Decl(declFileMethods_1.ts, 70, 5), Decl(declFileMethods_1.ts, 71, 68), Decl(declFileMethods_1.ts, 72, 68))
>a : number, Symbol(a, Decl(declFileMethods_1.ts, 72, 49))

    private static privateStaticFooWithOverloads(a: any): any {
>privateStaticFooWithOverloads : { (a: string): string; (a: number): number; }, Symbol(c2.privateStaticFooWithOverloads, Decl(declFileMethods_1.ts, 70, 5), Decl(declFileMethods_1.ts, 71, 68), Decl(declFileMethods_1.ts, 72, 68))
>a : any, Symbol(a, Decl(declFileMethods_1.ts, 73, 49))

        return a;
>a : any, Symbol(a, Decl(declFileMethods_1.ts, 73, 49))
    }
}

interface I2 {
>I2 : I2, Symbol(I2, Decl(declFileMethods_1.ts, 76, 1))

    /** This comment should appear for foo*/
    foo(): string;
>foo : () => string, Symbol(foo, Decl(declFileMethods_1.ts, 78, 14))

    /** This is comment for function signature*/
    fooWithParameters(/** this is comment about a*/a: string,
>fooWithParameters : (a: string, b: number) => void, Symbol(fooWithParameters, Decl(declFileMethods_1.ts, 80, 18))
>a : string, Symbol(a, Decl(declFileMethods_1.ts, 83, 22))

        /** this is comment for b*/
        b: number): void;
>b : number, Symbol(b, Decl(declFileMethods_1.ts, 83, 61))

    fooWithRestParameters(a: string, ...rests: string[]): string;
>fooWithRestParameters : (a: string, ...rests: string[]) => string, Symbol(fooWithRestParameters, Decl(declFileMethods_1.ts, 85, 25))
>a : string, Symbol(a, Decl(declFileMethods_1.ts, 87, 26))
>rests : string[], Symbol(rests, Decl(declFileMethods_1.ts, 87, 36))

    fooWithOverloads(a: string): string;
>fooWithOverloads : { (a: string): string; (a: number): number; }, Symbol(fooWithOverloads, Decl(declFileMethods_1.ts, 87, 65), Decl(declFileMethods_1.ts, 89, 40))
>a : string, Symbol(a, Decl(declFileMethods_1.ts, 89, 21))

    fooWithOverloads(a: number): number;
>fooWithOverloads : { (a: string): string; (a: number): number; }, Symbol(fooWithOverloads, Decl(declFileMethods_1.ts, 87, 65), Decl(declFileMethods_1.ts, 89, 40))
>a : number, Symbol(a, Decl(declFileMethods_1.ts, 90, 21))
}