//// [tests/cases/compiler/complicatedPrivacy.ts] ////

=== complicatedPrivacy.ts ===
namespace m1 {
>m1 : typeof m1
>   : ^^^^^^^^^

    export namespace m2 {
>m2 : typeof m2
>   : ^^^^^^^^^


        export function f1(c1: C1) {
>f1 : (c1: C1) => void
>   : ^  ^^  ^^^^^^^^^
>c1 : C1
>   : ^^
        }
        export function f2(c2: C2) {
>f2 : (c2: C2) => void
>   : ^  ^^  ^^^^^^^^^
>c2 : C2
>   : ^^
        }

        export class C2 implements m3.i3 {
>C2 : C2
>   : ^^
>m3 : typeof m3
>   : ^^^^^^^^^

            public get p1(arg) {
>p1 : C1
>   : ^^
>arg : any
>    : ^^^

                return new C1();
>new C1() : C1
>         : ^^
>C1 : typeof C1
>   : ^^^^^^^^^
            }

            public set p1(arg1: C1) {
>p1 : C1
>   : ^^
>arg1 : C1
>     : ^^
            }

            public f55() {
>f55 : () => string
>    : ^^^^^^^^^^^^

                return "Hello world";
>"Hello world" : "Hello world"
>              : ^^^^^^^^^^^^^
            }
        }
    }

    export function f2(arg1: { x?: C1, y: number }) {
>f2 : (arg1: { x?: C1; y: number; }) => void
>   : ^    ^^                      ^^^^^^^^^
>arg1 : { x?: C1; y: number; }
>     : ^^^^^^  ^^^^^      ^^^
>x : C1
>  : ^^
>y : number
>  : ^^^^^^
    }

    export function f3(): {
>f3 : () => { (a: number): C1; }
>   : ^^^^^^                    

        (a: number) : C1;
>a : number
>  : ^^^^^^

    } {
        return null;
    }

    export function f4(arg1: 
>f4 : (arg1: { [number]: C1; }) => void
>   : ^    ^^                 ^^^^^^^^^
>arg1 : { [x: number]: C1; }
>     : ^^^^^^^^^^^^^^^^^^^^
    {
    [number]: C1; // Used to be indexer, now it is a computed property
>[number] : C1
>         : ^^
>number : any
>       : ^^^

    }) {
    }


    export function f5(arg2: {
>f5 : (arg2: { new (arg1: C1): C1; }) => void
>   : ^    ^^                       ^^^^^^^^^
>arg2 : new (arg1: C1) => C1
>     : ^^^^^    ^^  ^^^^^  

        new (arg1: C1) : C1
>arg1 : C1
>     : ^^

    }) {
    }
    namespace m3 {
>m3 : typeof m3
>   : ^^^^^^^^^

        function f2(f1: C1) {
>f2 : (f1: C1) => void
>   : ^  ^^  ^^^^^^^^^
>f1 : C1
>   : ^^
        }

        export interface i3 {
            f55(): string;
>f55 : () => string
>    : ^^^^^^      
        }
    }

    class C1 {
>C1 : C1
>   : ^^
    }

    interface i {
        x: number;
>x : number
>  : ^^^^^^
    }

    export class C5 implements i {
>C5 : C5
>   : ^^

        public x: number;
>x : number
>  : ^^^^^^
    }

    export var v2: C1[];
>v2 : C1[]
>   : ^^^^
}

class C2 {
>C2 : C2
>   : ^^
}

namespace m2 {
>m2 : typeof m2
>   : ^^^^^^^^^

    export namespace m3 {
>m3 : typeof m3
>   : ^^^^^^^^^

        export class c_pr  implements mglo5.i5, mglo5.i6 {
>c_pr : c_pr
>     : ^^^^
>mglo5 : any
>      : ^^^
>mglo5 : any
>      : ^^^

            f1() {
>f1 : () => string
>   : ^^^^^^^^^^^^

                return "Hello";
>"Hello" : "Hello"
>        : ^^^^^^^
            }
        }
        
        namespace m4 {
>m4 : typeof m4
>   : ^^^^^^^^^

            class C {
>C : C
>  : ^
            }
            namespace m5 {
>m5 : typeof m5
>   : ^^^^^^^^^
                
                export namespace m6 {
>m6 : typeof m6
>   : ^^^^^^^^^

                    function f1() {
>f1 : () => C
>   : ^^^^^^^

                        return new C();
>new C() : C
>        : ^
>C : typeof C
>  : ^^^^^^^^
                    }
                }
            }
        }

    }
}

namespace mglo5 {
    export interface i5 {
        f1(): string;
>f1 : () => string
>   : ^^^^^^      
    }

    interface i6 {
        f6(): number;
>f6 : () => number
>   : ^^^^^^      
    }
}

