test.lox

print "file: test.lox";

print "# Class";

{ print "## Class ─ This";
    {
        class Egotist {
            fun speak() {
                print this;
            }
        };

        var egotist = Egotist();
        var method = Egotist().speak;
        method(); //> Egotist instance
    }

    {
        class Cake {
            fun taste() {
                var adjective = "delicious";
                if (this.flavor == "Belgian chocolate") {
                    adjective = "yummy";
                }
                print "The " + this.flavor + " cake is " + adjective + "!";

                this.tasted_counter = this.tasted_counter + 1;
                if (this.tasted_counter >= 2) {
                    print "But now I am full.";
                }
            }
        };

        var cake = Cake();
        cake.flavor = "German chocolate";
        cake.tasted_counter = 0;

        cake.taste();//> The German chocolate cake is delicious!
        print cake.tasted_counter; //> 1

        cake.flavor = "Belgian chocolate";
        {
            var taste_cake_method = cake.taste;

            taste_cake_method(); //> The Belgian chocolate cake is delicious!\nBut now I am full.
            print cake.tasted_counter; //> 2
            print taste_cake_method; //> <fn taste>
        }

    }

    { print "### Class ─ This: Invalid uses of this";
        // Error at 'this': Can't use 'this' outside of a class.
        // print this;

        fun not_a_method() {
            // Error at 'this': Can't use 'this' outside of a class.
            // print this;
        }

        not_a_method(); //> Undefined variable 'this'.
    }
}


{ print "## Class ─ Constructors & Initializer";

    class Foo {
        fun init() {
            print this;
            // return nil;
        }
    };

    var foo = Foo(); //> Foo instance

    { print "### Class ─ Constructors & Initializer: Invoking init() directly";
        { // Without `return` in `init()`.
            print foo.init(); //> Foo instance
        }

        { // With `return` in `init()`.
            class Bar {
                fun init() {
                    print this;
                    // Can't return from an initializer
                    // return 42;
                }
            };

            var bar = Bar(); //> Bar instance
            print bar.init(); //> Bar instance

            fun init() {
                // Error at 'this': Can't use 'this' outside of a class.
                // print this;
                print 4;
                return 2;
            }

            print init(); //> 4\n2
        } 
    }

}

print "Skipping block that has errors due to 'invoking init() directly'.";
if (true) {
    var is_enabled_block = true;

    // FIXME:
    //
    // NO ERROR REPORTED WHEN UNDEFINED VARIABLE IN A BLOCK SCOPE
    class Foo { };
    var foo = Foo();

    // ok
    is_enabled_block = false;
    if (is_enabled_block) {
        print is_reported_at_runtime;
    }

    // TODO: That is actually kind of useful sometimes, so we don’t want to
    // disallow it entirely. Instead, it should return this instead of nil.
    // That’s an easy fix over in LoxFunction.
    //
    // FIXME: FIXED
    // Skipping block that has errors due to 'invoking init() directly'.
    //     interpreter.execute:669:39: warn: method: IDENTIFIER init null,
    //      is_initializer in .class: true.
    // thread 7990 panic: access of union field 'ret' while field 'nil' is active
    // interpreter.zig:714:64: 0x107a69a in execute__anon_6626 (main)
    //             runtime_return_value = ReturnValue.fromValue(value).ret;
    //                                                                ^
    // interpreter.zig:623:37: 0x10ba945 in executeBlock__anon_10207 (main)
    //                 _ = try self.execute(statement, writer);
    class EmptyBar {
        fun init() {
            return;
        }
    };
    var empty_bar = EmptyBar();
    print empty_bar; //> EmptyBar instance
    print empty_bar.init(); //> nil

    // !ok
    is_enabled_block = false;
    print "is_enabled_block:";
    print is_enabled_block;
    // MAKE SURE WE DO NOT SKIP RESOLVER CHECKS IF THERE IS INIT. 
    // I GUESS, due to binding this, we are skipping the current
    // closure/environment just after init totally?
    if (is_enabled_block) {
        print is_not_reported_at_runtime;
    }
}




// see `:h modeline`
// vim: set commentstring=//\ %s :
// vim: set filetype=cpp :
// vim: set sts=4 sw=4 et :