Diffusion Ant (mir/inline-method) Code

ant/tests/test_class_function_hoisting.cjs
3fa05edd2fe3mir/inline-method

test_class_function_hoisting.cjs
View Options

			// Test class function (method) hoisting behavior
			// Class methods can be called regardless of their definition order within the class body
			// But classes themselves are NOT hoisted like function declarations

			console.log("=== Test 1: Methods calling other methods defined later ===");
			class Calculator {
			calculate(x) {
			return this.double(x) + this.triple(x);
			}

			double(x) {
			return x * 2;
			}

			triple(x) {
			return x * 3;
			}
			}

			let calc = new Calculator();
			console.log("calculate(5) should be 25:", calc.calculate(5));

			console.log("\n=== Test 2: Constructor calling methods defined after it ===");
			class Greeter {
			constructor(name) {
			this.name = name;
			this.greeting = this.makeGreeting();
			}

			makeGreeting() {
			return "Hello, " + this.name + "!";
			}
			}

			let greeter = new Greeter("World");
			console.log("greeting should be 'Hello, World!':", greeter.greeting);

			console.log("\n=== Test 3: Method calling method defined before constructor ===");
			class Parser {
			parse(input) {
			return this.validate(input);
			}

			constructor() {
			this.initialized = true;
			}

			validate(input) {
			return input.length > 0;
			}
			}

			let parser = new Parser();
			console.log("parse('test') should be true:", parser.parse("test"));

			console.log("\n=== Test 4: Mutual method references ===");
			class Counter {
			increment() {
			this.value = this.getValue() + 1;
			}

			decrement() {
			this.value = this.getValue() - 1;
			}

			constructor(initial) {
			this.value = initial;
			}

			getValue() {
			return this.value;
			}
			}

			let counter = new Counter(10);
			counter.increment();
			console.log("after increment should be 11:", counter.getValue());
			counter.decrement();
			counter.decrement();
			console.log("after two decrements should be 9:", counter.getValue());

			console.log("\n=== Test 5: Deep method call chain ===");
			class Chain {
			a() {
			return this.b() + 1;
			}

			b() {
			return this.c() + 2;
			}

			c() {
			return this.d() + 3;
			}

			d() {
			return 10;
			}
			}

			let chain = new Chain();
			console.log("a() should be 16 (10+3+2+1):", chain.a());

			console.log("\n=== Test 6: Class NOT hoisted (should error if accessed before) ===");
			try {
			let early = new NotYetDefined();
			console.log("ERROR: Should not reach here");
			} catch (e) {
			console.log("Correctly caught error - class not hoisted");
			}

			class NotYetDefined {
			constructor() {
			this.value = 42;
			}
			}

			let late = new NotYetDefined();
			console.log("After definition, value should be 42:", late.value);

			console.log("\n=== Test 7: Static methods hoisting within class ===");
			class StaticTest {
			static compute() {
			return StaticTest.helper() * 2;
			}

			static helper() {
			return 21;
			}
			}

			console.log("StaticTest.compute() should be 42:", StaticTest.compute());

			console.log("\n=== Test 8: Getter/setter order independence ===");
			class GetSet {
			get doubled() {
			return this._val * 2;
			}

			constructor(val) {
			this._val = val;
			}

			set doubled(val) {
			this._val = val / 2;
			}
			}

			let gs = new GetSet(5);
			console.log("doubled should be 10:", gs.doubled);
			gs.doubled = 20;
			console.log("after setting doubled=20, _val should be 10:", gs._val);

			console.log("\n=== All class function hoisting tests completed ===");

Owner Packages

No Owners