//  Exercise the pretty-print visualizer for the various grammar elements

testing_enabled: bool = false;

outer: @print type = {

    object_alias: <T> T requires true == 42;

    mytype: final type =
    {
        protected f: () -> int = 42;

        g: (virtual this, i:int) -> int = {
            using namespace ::std;

            s := "string literal";
            ret: int = i;
            p: const * const int = ret&;
            if p* < 0 {
                ret = -p*;
            }
            ret += strlen(s) - 10 + s.strlen() * (16 / (3 & 2)) % 3;

            m: map<const int,string> = ();
            m[0] = "har" as string;
            ret -= h("x", m).length();
            _ = m;

            return ret;
        }

        private h: (s: std::string, inout m: std::map<const int,std::string> ) -> std::string
            pre( m.empty() == false || false, "message" )
            pre<Bounds, testing_enabled>( 0 < m.ssize() < 100 && true != false, "size is (m.ssize())$" )
        = {
            a := :()={};
            b := :()={};
            c := :()={};

            while s.empty() next a() { break; }

            do { } next b() while s.empty();

            label: for m next c() do (_) { continue label; }

            if !s.empty() is (true) { a(); }
            else if !m.empty() { b(); }
            else { c(); }

            assert( true );

            return :() -> std::string = (s + m[0])$; ();
        }

        values: <T> (this, _: T) throws -> (offset: int, name: std::string) = {
            offset = 53;
            name = "plugh";
        }

        operator=: (out this) = { }

        operator=: (out this, that) = { }

        operator=: (implicit out this, _: int) = { }

        variadic: (x...: int) = { (std::cout << ... << x); }
    }

    test: () = {
        namespace_alias: namespace == ::std;

        using std::array;
        using std::cout;

        type_alias: type == array<int,10>;

        object_alias_1: i8 == 42;
        object_alias_2: == 42;


        var: ::outer::mytype = ();
        cout << var.g(42) << "\n";

        cout << inspect var.g(42) -> namespace_alias::string {
            is 43 = "forty-and-three";
            is _  = "default case";
        } << "\n";
    }

    x: <Ts...: type> type = {
        tup: std::tuple<Ts...> = ();
    }

    print: <Args...: type> (inout out: std::ostream, args...: Args) requires sizeof...(Args) >= 0u = {
        (out << ... << args);
    }

    all: <Args...: type> (args...: Args) -> bool =
        (... && args);

}

main: () = {
    outer::test();
}