diff options
Diffstat (limited to 'mnv/src/testdir/test_mnv9_class.mnv')
| -rw-r--r-- | mnv/src/testdir/test_mnv9_class.mnv | 11872 |
1 files changed, 11872 insertions, 0 deletions
diff --git a/mnv/src/testdir/test_mnv9_class.mnv b/mnv/src/testdir/test_mnv9_class.mnv new file mode 100644 index 0000000000..de6c07fd74 --- /dev/null +++ b/mnv/src/testdir/test_mnv9_class.mnv @@ -0,0 +1,11872 @@ +" Test MNV9 classes + +import './util/mnv9.mnv' as v9 + +def Test_class_basic() + # Class supported only in "mnv9script" + var lines =<< trim END + class NotWorking + endclass + END + v9.CheckSourceFailure(lines, 'E1316: Class can only be defined in MNV9 script', 1) + + # First character in a class name should be capitalized. + lines =<< trim END + mnv9script + class notWorking + endclass + END + v9.CheckSourceFailure(lines, 'E1314: Class name must start with an uppercase letter: notWorking', 2) + + # Only alphanumeric characters are supported in a class name + lines =<< trim END + mnv9script + class Not@working + endclass + END + v9.CheckSourceFailure(lines, 'E1315: White space required after name: Not@working', 2) + + # Unsupported keyword (instead of class) + lines =<< trim END + mnv9script + abstract noclass Something + endclass + END + v9.CheckSourceFailure(lines, 'E475: Invalid argument: noclass Something', 2) + + # Only the complete word "class" should be recognized + lines =<< trim END + mnv9script + abstract classy Something + endclass + END + v9.CheckSourceFailure(lines, 'E475: Invalid argument: classy Something', 2) + + # The complete "endclass" should be specified. + lines =<< trim END + mnv9script + class Something + endcl + END + v9.CheckSourceFailure(lines, 'E1065: Command cannot be shortened: endcl', 3) + + # Additional words after "endclass" + lines =<< trim END + mnv9script + class Something + endclass school's out + END + v9.CheckSourceFailure(lines, "E488: Trailing characters: school's out", 3) + + # Additional commands after "endclass" + lines =<< trim END + mnv9script + class Something + endclass | echo 'done' + END + v9.CheckSourceFailure(lines, "E488: Trailing characters: | echo 'done'", 3) + + # Additional command after "class name" + lines =<< trim END + mnv9script + class Something | var x = 10 + endclass + END + v9.CheckSourceFailure(lines, "E488: Trailing characters: | var x = 10", 2) + + # Additional command after "object variable" + lines =<< trim END + mnv9script + class Something + var l: list<number> = [] | var y = 10 + endclass + END + v9.CheckSourceFailure(lines, "E488: Trailing characters: | var y = 10", 3) + + # Additional command after "class variable" + lines =<< trim END + mnv9script + class Something + static var d = {a: 10} | var y = 10 + endclass + END + v9.CheckSourceFailure(lines, "E488: Trailing characters: | var y = 10", 3) + + # Additional command after "object method" + lines =<< trim END + mnv9script + class Something + def Foo() | var y = 10 + enddef + endclass + END + v9.CheckSourceFailure(lines, "E488: Trailing characters: | var y = 10", 3) + + # Comments are allowed after an inline block + lines =<< trim END + mnv9script + class Foo + static const bar = { # {{{ + baz: 'qux' + } # }}} + endclass + assert_equal({baz: 'qux'}, Foo.bar) + END + v9.CheckSourceSuccess(lines) + + # Try to define a class with the same name as an existing variable + lines =<< trim END + mnv9script + var Something: list<number> = [1] + class Thing + endclass + interface Api + endinterface + class Something extends Thing implements Api + var v1: string = '' + def Foo() + enddef + endclass + END + v9.CheckSourceFailure(lines, 'E1041: Redefining script item: "Something"', 7) + + # Use old "this." prefixed member variable declaration syntax (without initialization) + lines =<< trim END + mnv9script + class Something + this.count: number + endclass + END + v9.CheckSourceFailure(lines, 'E1318: Not a valid command in a class: this.count: number', 3) + + # Use old "this." prefixed member variable declaration syntax (with initialization) + lines =<< trim END + mnv9script + class Something + this.count: number = 42 + endclass + END + v9.CheckSourceFailure(lines, 'E1318: Not a valid command in a class: this.count: number = 42', 3) + + # Use old "this." prefixed member variable declaration syntax (type inferred) + lines =<< trim END + mnv9script + class Something + this.count = 42 + endclass + END + v9.CheckSourceFailure(lines, 'E1318: Not a valid command in a class: this.count = 42', 3) + + # Use "this" without any member variable name + lines =<< trim END + mnv9script + class Something + this + endclass + END + v9.CheckSourceFailure(lines, 'E1318: Not a valid command in a class: this', 3) + + # Use "this." without any member variable name + lines =<< trim END + mnv9script + class Something + this. + endclass + END + v9.CheckSourceFailure(lines, 'E1318: Not a valid command in a class: this.', 3) + + # Space between "this" and ".<variable>" + lines =<< trim END + mnv9script + class Something + this .count + endclass + END + v9.CheckSourceFailure(lines, 'E1318: Not a valid command in a class: this .count', 3) + + # Space between "this." and the member variable name + lines =<< trim END + mnv9script + class Something + this. count + endclass + END + v9.CheckSourceFailure(lines, 'E1318: Not a valid command in a class: this. count', 3) + + # Use "that" instead of "this" + lines =<< trim END + mnv9script + class Something + var count: number + that.count + endclass + END + v9.CheckSourceFailure(lines, 'E1318: Not a valid command in a class: that.count', 4) + + # Use "variable" instead of "var" for member variable declaration (without initialization) + lines =<< trim END + mnv9script + class Something + variable count: number + endclass + END + v9.CheckSourceFailure(lines, 'E1318: Not a valid command in a class: variable count: number', 3) + + # Use "variable" instead of "var" for member variable declaration (with initialization) + lines =<< trim END + mnv9script + class Something + variable count: number = 42 + endclass + END + v9.CheckSourceFailure(lines, 'E1318: Not a valid command in a class: variable count: number = 42', 3) + + # Use "variable" instead of "var" for member variable declaration (type inferred) + lines =<< trim END + mnv9script + class Something + variable count = 42 + endclass + END + v9.CheckSourceFailure(lines, 'E1318: Not a valid command in a class: variable count = 42', 3) + + # Use a non-existing member variable in new() + lines =<< trim END + mnv9script + class Something + def new() + this.state = 0 + enddef + endclass + var obj = Something.new() + END + v9.CheckSourceFailure(lines, 'E1326: Variable "state" not found in object "Something"', 1) + + # Space before ":" in a member variable declaration + lines =<< trim END + mnv9script + class Something + var count : number + endclass + END + v9.CheckSourceFailure(lines, 'E1059: No white space allowed before colon: count : number', 3) + + # No space after ":" in a member variable declaration + lines =<< trim END + mnv9script + class Something + var count:number + endclass + END + v9.CheckSourceFailure(lines, "E1069: White space required after ':'", 3) + + # Missing ":var" in a "var" member variable declaration (without initialization) + lines =<< trim END + mnv9script + class Something + var: number + endclass + END + v9.CheckSourceFailure(lines, 'E1317: Invalid object variable declaration: var: number', 3) + + # Missing ":var" in a "var" member variable declaration (with initialization) + lines =<< trim END + mnv9script + class Something + var: number = 42 + endclass + END + v9.CheckSourceFailure(lines, 'E1317: Invalid object variable declaration: var: number = 42', 3) + + # Missing ":var" in a "var" member variable declaration (type inferred) + lines =<< trim END + mnv9script + class Something + var = 42 + endclass + END + v9.CheckSourceFailure(lines, 'E1317: Invalid object variable declaration: var = 42', 3) + + # Test for unsupported comment specifier + lines =<< trim END + mnv9script + class Something + # comment + #{ + endclass + END + v9.CheckSourceFailure(lines, 'E1170: Cannot use #{ to start a comment', 3) + + # Test for using class as a bool + lines =<< trim END + mnv9script + class A + endclass + if A + endif + END + v9.CheckSourceFailure(lines, 'E1405: Class "A" cannot be used as a value', 4) + + # Test for using object as a bool + lines =<< trim END + mnv9script + class A + endclass + var a = A.new() + if a + endif + END + v9.CheckSourceFailure(lines, 'E1320: Using an Object as a Number', 5) + + # Test for using class as a float + lines =<< trim END + mnv9script + class A + endclass + sort([1.1, A], 'f') + END + v9.CheckSourceFailure(lines, 'E1405: Class "A" cannot be used as a value', 4) + + # Test for using object as a float + lines =<< trim END + mnv9script + class A + endclass + var a = A.new() + sort([1.1, a], 'f') + END + v9.CheckSourceFailure(lines, 'E1322: Using an Object as a Float', 5) + + # Test for using class as a string + lines =<< trim END + mnv9script + class A + endclass + :exe 'call ' .. A + END + v9.CheckSourceFailure(lines, 'E1405: Class "A" cannot be used as a value', 4) + + # Test for using object as a string + lines =<< trim END + mnv9script + class A + endclass + var a = A.new() + :exe 'call ' .. a + END + v9.CheckSourceFailure(lines, 'E1324: Using an Object as a String', 5) + + # Test creating a class with member variables and methods, calling a object + # method. Check for using type() and typename() with a class and an object. + lines =<< trim END + mnv9script + + class TextPosition + var lnum: number + var col: number + + # make a nicely formatted string + def ToString(): string + return $'({this.lnum}, {this.col})' + enddef + endclass + + # use the automatically generated new() method + var pos = TextPosition.new(2, 12) + assert_equal(2, pos.lnum) + assert_equal(12, pos.col) + + # call an object method + assert_equal('(2, 12)', pos.ToString()) + + assert_equal(v:t_class, type(TextPosition)) + assert_equal(v:t_object, type(pos)) + assert_equal('class<TextPosition>', typename(TextPosition)) + assert_equal('object<TextPosition>', typename(pos)) + END + v9.CheckSourceSuccess(lines) + + # When referencing object methods, space cannot be used after a "." + lines =<< trim END + mnv9script + class A + def Foo(): number + return 10 + enddef + endclass + var a = A.new() + var v = a. Foo() + END + v9.CheckSourceFailure(lines, "E1202: No white space allowed after '.'", 8) + + # Using an object without specifying a method or a member variable + lines =<< trim END + mnv9script + class A + def Foo(): number + return 10 + enddef + endclass + var a = A.new() + var v = a. + END + v9.CheckSourceFailure(lines, 'E15: Invalid expression: "a."', 8) + + # Error when parsing the arguments of an object method. + lines =<< trim END + mnv9script + class A + def Foo() + enddef + endclass + var a = A.new() + var v = a.Foo(,) + END + v9.CheckSourceFailure(lines, 'E15: Invalid expression: "a.Foo(,)"', 7) + + # Use a multi-line initialization for a member variable + lines =<< trim END + mnv9script + class A + var y = { + X: 1 + } + endclass + var a = A.new() + END + v9.CheckSourceSuccess(lines) +enddef + +" Tests for object/class methods in a class +def Test_class_def_method() + # Using the "public" keyword when defining an object method + var lines =<< trim END + mnv9script + class A + public def Foo() + enddef + endclass + END + v9.CheckSourceFailure(lines, 'E1388: public keyword not supported for a method', 3) + + # Using the "public" keyword when defining a class method + lines =<< trim END + mnv9script + class A + public static def Foo() + enddef + endclass + END + v9.CheckSourceFailure(lines, 'E1388: public keyword not supported for a method', 3) + + # Using the "public" keyword when defining an object protected method + lines =<< trim END + mnv9script + class A + public def _Foo() + enddef + endclass + END + v9.CheckSourceFailure(lines, 'E1388: public keyword not supported for a method', 3) + + # Using the "public" keyword when defining a class protected method + lines =<< trim END + mnv9script + class A + public static def _Foo() + enddef + endclass + END + v9.CheckSourceFailure(lines, 'E1388: public keyword not supported for a method', 3) + + # Using a "def" keyword without an object method name + lines =<< trim END + mnv9script + class A + def + enddef + endclass + END + v9.CheckSourceFailure(lines, 'E1318: Not a valid command in a class: def', 3) + + # Using a "def" keyword without a class method name + lines =<< trim END + mnv9script + class A + static def + enddef + endclass + END + v9.CheckSourceFailure(lines, 'E1318: Not a valid command in a class: static def', 3) +enddef + +def Test_class_defined_twice() + # class defined twice should fail + var lines =<< trim END + mnv9script + class There + endclass + class There + endclass + END + v9.CheckSourceFailure(lines, 'E1041: Redefining script item: "There"', 4) + + # one class, reload same script twice is OK + lines =<< trim END + mnv9script + class There + endclass + END + writefile(lines, 'XclassTwice.mnv', 'D') + source XclassTwice.mnv + source XclassTwice.mnv +enddef + +def Test_returning_null_object() + # this was causing an internal error + var lines =<< trim END + mnv9script + + class BufferList + def Current(): any + return null_object + enddef + endclass + + var buffers = BufferList.new() + echo buffers.Current() + END + v9.CheckSourceSuccess(lines) +enddef + +def Test_using_null_class() + var lines =<< trim END + @_ = null_class.member + END + v9.CheckDefExecAndScriptFailure(lines, ['E1395: Using a null class', 'E1363: Incomplete type']) + + # Test for using a null class as a value + lines =<< trim END + mnv9script + echo empty(null_class) + END + v9.CheckSourceFailure(lines, 'E1405: Class "" cannot be used as a value', 2) + + # Test for using a null class with string() + lines =<< trim END + mnv9script + assert_equal('class [unknown]', string(null_class)) + END + v9.CheckSourceSuccess(lines) + + # Test for using a null class with type() and typename() + lines =<< trim END + mnv9script + assert_equal(12, type(null_class)) + assert_equal('class<any>', typename(null_class)) + END + v9.CheckSourceSuccess(lines) +enddef + +def Test_object_not_set() + # Use an uninitialized object in script context + var lines =<< trim END + mnv9script + + class State + var value = 'xyz' + endclass + + var state: State + var db = {'xyz': 789} + echo db[state.value] + END + v9.CheckSourceFailure(lines, 'E1360: Using a null object', 9) + + # Use an uninitialized object from a def function + lines =<< trim END + mnv9script + + class Class + var id: string + def Method1() + echo 'Method1' .. this.id + enddef + endclass + + var obj: Class + def Func() + obj.Method1() + enddef + Func() + END + v9.CheckSourceFailure(lines, 'E1360: Using a null object', 1) + + # Pass an uninitialized object variable to a "new" function and try to call an + # object method. + lines =<< trim END + mnv9script + + class Background + var background = 'dark' + endclass + + class Colorscheme + var _bg: Background + + def GetBackground(): string + return this._bg.background + enddef + endclass + + var bg: Background # UNINITIALIZED + echo Colorscheme.new(bg).GetBackground() + END + v9.CheckSourceFailure(lines, 'E1360: Using a null object', 1) + + lines =<< trim END + mnv9script + + class Class + var id: string + def Method1() + echo 'Method1' .. this.id + enddef + endclass + + var obj = null_object + def Func() + obj.Method1() + enddef + Func() + END + v9.CheckSourceFailure(lines, 'E1360: Using a null object', 1) + + # Reference a object variable through a null class object which is stored in a + # variable of type "any". + lines =<< trim END + mnv9script + + def Z() + var o: any = null_object + o.v = 4 + enddef + Z() + END + v9.CheckSourceFailure(lines, 'E1360: Using a null object', 2) + + # Do "echom" of a null object variable. + lines =<< trim END + mnv9script + + def X() + var x = null_object + echom x + enddef + X() + END + v9.CheckSourceFailure(lines, 'E1324: Using an Object as a String', 2) + + # Use a null object variable that mnv wants to force to number. + lines =<< trim END + mnv9script + + def X() + var o = null_object + var l = [ 1, o] + sort(l, 'N') + enddef + X() + END + v9.CheckSourceFailure(lines, 'E1324: Using an Object as a String', 3) +enddef + +" Null object assignment and comparison +def Test_null_object_assign_compare() + var lines =<< trim END + mnv9script + + var nullo = null_object + def F(): any + return nullo + enddef + assert_equal('object<any>', typename(F())) + + var o0 = F() + assert_true(o0 == null_object) + assert_true(o0 == null) + + var o1: any = nullo + assert_true(o1 == null_object) + assert_true(o1 == null) + + def G() + var x = null_object + enddef + + class C + endclass + var o2: C + assert_true(o2 == null_object) + assert_true(o2 == null) + + o2 = null_object + assert_true(o2 == null) + + o2 = C.new() + assert_true(o2 != null) + + o2 = null_object + assert_true(o2 == null) + END + v9.CheckSourceSuccess(lines) +enddef + +" Test for object member initialization and disassembly +def Test_class_member_initializer() + var lines =<< trim END + mnv9script + + class TextPosition + var lnum: number = 1 + var col: number = 1 + + # constructor with only the line number + def new(lnum: number) + this.lnum = lnum + enddef + endclass + + var pos = TextPosition.new(3) + assert_equal(3, pos.lnum) + assert_equal(1, pos.col) + + var instr = execute('disassemble TextPosition.new') + assert_match('new\_s*' .. + '0 NEW TextPosition size \d\+\_s*' .. + '\d PUSHNR 1\_s*' .. + '\d STORE_THIS 0\_s*' .. + '\d PUSHNR 1\_s*' .. + '\d STORE_THIS 1\_s*' .. + 'this.lnum = lnum\_s*' .. + '\d LOAD arg\[-1]\_s*' .. + '\d PUSHNR 0\_s*' .. + '\d LOAD $0\_s*' .. + '\d\+ STOREINDEX object\_s*' .. + '\d\+ RETURN object.*', + instr) + END + v9.CheckSourceSuccess(lines) +enddef + +def Test_member_any_used_as_object() + var lines =<< trim END + mnv9script + + class Inner + public var value: number = 0 + endclass + + class Outer + var inner: any + endclass + + def F(outer: Outer) + outer.inner.value = 1 + enddef + + var inner_obj = Inner.new(0) + var outer_obj = Outer.new(inner_obj) + F(outer_obj) + assert_equal(1, inner_obj.value) + END + v9.CheckSourceSuccess(lines) + + # Try modifying a protected variable using an "any" object + lines =<< trim END + mnv9script + + class Inner + var _value: string = '' + endclass + + class Outer + var inner: any + endclass + + def F(outer: Outer) + outer.inner._value = 'b' + enddef + + var inner_obj = Inner.new('a') + var outer_obj = Outer.new(inner_obj) + F(outer_obj) + END + v9.CheckSourceFailure(lines, 'E1333: Cannot access protected variable "_value" in class "Inner"', 1) + + # Try modifying a non-existing variable using an "any" object + lines =<< trim END + mnv9script + + class Inner + var value: string = '' + endclass + + class Outer + var inner: any + endclass + + def F(outer: Outer) + outer.inner.someval = 'b' + enddef + + var inner_obj = Inner.new('a') + var outer_obj = Outer.new(inner_obj) + F(outer_obj) + END + v9.CheckSourceFailure(lines, 'E1326: Variable "someval" not found in object "Inner"', 1) +enddef + +" Nested assignment to a object variable which is of another class type +def Test_assignment_nested_type() + var lines =<< trim END + mnv9script + + class Inner + public var value: number = 0 + endclass + + class Outer + var inner: Inner + endclass + + def F(outer: Outer) + outer.inner.value = 1 + enddef + + def Test_assign_to_nested_typed_member() + var inner = Inner.new(0) + var outer = Outer.new(inner) + F(outer) + assert_equal(1, inner.value) + enddef + + Test_assign_to_nested_typed_member() + + var script_inner = Inner.new(0) + var script_outer = Outer.new(script_inner) + script_outer.inner.value = 1 + assert_equal(1, script_inner.value) + END + v9.CheckSourceSuccess(lines) + + # Assignment where target item is read only in :def + lines =<< trim END + mnv9script + + class Inner + var value: number = 0 + endclass + + class Outer + var inner: Inner + endclass + + def F(outer: Outer) + outer.inner.value = 1 + enddef + + def Test_assign_to_nested_typed_member() + var inner = Inner.new(0) + var outer = Outer.new(inner) + F(outer) + assert_equal(1, inner.value) + enddef + + Test_assign_to_nested_typed_member() + END + v9.CheckSourceFailure(lines, 'E1335: Variable "value" in class "Inner" is not writable', 1) + + # Assignment where target item is read only script level + lines =<< trim END + mnv9script + + class Inner + var value: number = 0 + endclass + + class Outer + var inner: Inner + endclass + + def F(outer: Outer) + outer.inner.value = 1 + enddef + + var script_inner = Inner.new(0) + var script_outer = Outer.new(script_inner) + script_outer.inner.value = 1 + assert_equal(1, script_inner.value) + END + v9.CheckSourceFailure(lines, 'E1335: Variable "value" in class "Inner" is not writable', 17) +enddef + +def Test_assignment_with_operator() + # Use "+=" to assign to a object variable + var lines =<< trim END + mnv9script + + class Foo + public var x: number + + def Add(n: number) + this.x += n + enddef + endclass + + var f = Foo.new(3) + f.Add(17) + assert_equal(20, f.x) + + def AddToFoo(obj: Foo) + obj.x += 3 + enddef + + AddToFoo(f) + assert_equal(23, f.x) + END + v9.CheckSourceSuccess(lines) +enddef + +def Test_list_of_objects() + var lines =<< trim END + mnv9script + + class Foo + def Add() + enddef + endclass + + def ProcessList(fooList: list<Foo>) + for foo in fooList + foo.Add() + endfor + enddef + + var l: list<Foo> = [Foo.new()] + ProcessList(l) + END + v9.CheckSourceSuccess(lines) +enddef + +def Test_expr_after_using_object() + var lines =<< trim END + mnv9script + + class Something + var label: string = '' + endclass + + def Foo(): Something + var v = Something.new() + echo 'in Foo(): ' .. typename(v) + return v + enddef + + Foo() + END + v9.CheckSourceSuccess(lines) +enddef + +def Test_class_default_new() + var lines =<< trim END + mnv9script + + class TextPosition + var lnum: number = 1 + var col: number = 1 + endclass + + var pos = TextPosition.new() + assert_equal(1, pos.lnum) + assert_equal(1, pos.col) + + pos = TextPosition.new(v:none, v:none) + assert_equal(1, pos.lnum) + assert_equal(1, pos.col) + + pos = TextPosition.new(3, 22) + assert_equal(3, pos.lnum) + assert_equal(22, pos.col) + + pos = TextPosition.new(v:none, 33) + assert_equal(1, pos.lnum) + assert_equal(33, pos.col) + END + v9.CheckSourceSuccess(lines) + + lines =<< trim END + mnv9script + class Person + var name: string + var age: number = 42 + var education: string = "unknown" + + def new(this.name, this.age = v:none, this.education = v:none) + enddef + endclass + + var piet = Person.new("Piet") + assert_equal("Piet", piet.name) + assert_equal(42, piet.age) + assert_equal("unknown", piet.education) + + var chris = Person.new("Chris", 4, "none") + assert_equal("Chris", chris.name) + assert_equal(4, chris.age) + assert_equal("none", chris.education) + END + v9.CheckSourceSuccess(lines) + + lines =<< trim END + mnv9script + class Person + var name: string + var age: number = 42 + var education: string = "unknown" + + def new(this.name, this.age = v:none, this.education = v:none) + enddef + endclass + + var missing = Person.new() + END + v9.CheckSourceFailure(lines, 'E119: Not enough arguments for function: new', 11) + + # Using a specific value to initialize an instance variable in the new() + # method. + lines =<< trim END + mnv9script + class A + var val: string + def new(this.val = 'a') + enddef + endclass + END + v9.CheckSourceFailure(lines, "E1328: Constructor default value must be v:none: = 'a'", 4) +enddef + +def Test_class_new_with_object_member() + var lines =<< trim END + mnv9script + + class C + var str: string + var num: number + def new(this.str, this.num) + enddef + def newVals(this.str, this.num) + enddef + endclass + + def Check() + try + var c = C.new('cats', 2) + assert_equal('cats', c.str) + assert_equal(2, c.num) + + c = C.newVals('dogs', 4) + assert_equal('dogs', c.str) + assert_equal(4, c.num) + catch + assert_report($'Unexpected exception was caught: {v:exception}') + endtry + enddef + + Check() + END + v9.CheckSourceSuccess(lines) + + lines =<< trim END + mnv9script + + class C + var str: string + var num: number + def new(this.str, this.num) + enddef + endclass + + def Check() + try + var c = C.new(1, 2) + catch + assert_report($'Unexpected exception was caught: {v:exception}') + endtry + enddef + + Check() + END + v9.CheckSourceFailure(lines, 'E1013: Argument 1: type mismatch, expected string but got number', 2) + + lines =<< trim END + mnv9script + + class C + var str: string + var num: number + def newVals(this.str, this.num) + enddef + endclass + + def Check() + try + var c = C.newVals('dogs', 'apes') + catch + assert_report($'Unexpected exception was caught: {v:exception}') + endtry + enddef + + Check() + END + v9.CheckSourceFailure(lines, 'E1013: Argument 2: type mismatch, expected number but got string', 2) + + lines =<< trim END + mnv9script + + class C + var str: string + def new(str: any) + enddef + endclass + + def Check() + try + var c = C.new(1) + catch + assert_report($'Unexpected exception was caught: {v:exception}') + endtry + enddef + + Check() + END + v9.CheckSourceSuccess(lines) + + # Try using "this." argument in a class method + lines =<< trim END + mnv9script + class A + var val = 10 + static def Foo(this.val: number) + enddef + endclass + END + v9.CheckSourceFailure(lines, 'E1390: Cannot use an object variable "this.val" except with the "new" method', 4) + + # Try using "this." argument in an object method + lines =<< trim END + mnv9script + class A + var val = 10 + def Foo(this.val: number) + enddef + endclass + END + v9.CheckSourceFailure(lines, 'E1390: Cannot use an object variable "this.val" except with the "new" method', 4) +enddef + +def Test_class_object_member_inits() + var lines =<< trim END + mnv9script + class TextPosition + var lnum: number + var col = 1 + var addcol: number = 2 + endclass + + var pos = TextPosition.new() + assert_equal(0, pos.lnum) + assert_equal(1, pos.col) + assert_equal(2, pos.addcol) + END + v9.CheckSourceSuccess(lines) + + lines =<< trim END + mnv9script + class TextPosition + var lnum + var col = 1 + endclass + END + v9.CheckSourceFailure(lines, 'E1022: Type or initialization required', 3) + + # If the type is not specified for a member, then it should be set during + # object creation and not when defining the class. + lines =<< trim END + mnv9script + + var init_count = 0 + def Init(): string + init_count += 1 + return 'foo' + enddef + + class A + var str1 = Init() + var str2: string = Init() + var col = 1 + endclass + + assert_equal(init_count, 0) + var a = A.new() + assert_equal(init_count, 2) + END + v9.CheckSourceSuccess(lines) + + # Test for initializing an object member with an unknown variable/type + lines =<< trim END + mnv9script + class A + var value = init_val + endclass + var a = A.new() + END + v9.CheckSourceFailure(lines, 'E1001: Variable not found: init_val', 1) + + # Test for initializing an object member with an special type + lines =<< trim END + mnv9script + class A + var value: void + endclass + END + v9.CheckSourceFailure(lines, 'E1330: Invalid type used in variable declaration: void', 3) +enddef + +" Test for instance variable access +def Test_instance_variable_access() + var lines =<< trim END + mnv9script + class Triple + var _one = 1 + var two = 2 + public var three = 3 + + def GetOne(): number + return this._one + enddef + endclass + + var trip = Triple.new() + assert_equal(1, trip.GetOne()) + assert_equal(2, trip.two) + assert_equal(3, trip.three) + assert_fails('echo trip._one', 'E1333: Cannot access protected variable "_one" in class "Triple"') + + assert_fails('trip._one = 11', 'E1333: Cannot access protected variable "_one" in class "Triple"') + assert_fails('trip.two = 22', 'E1335: Variable "two" in class "Triple" is not writable') + trip.three = 33 + assert_equal(33, trip.three) + + assert_fails('trip.four = 4', 'E1326: Variable "four" not found in object "Triple"') + END + v9.CheckSourceSuccess(lines) + + # Test for a public member variable name beginning with an underscore + lines =<< trim END + mnv9script + class A + public var _val = 10 + endclass + END + v9.CheckSourceFailure(lines, 'E1332: public variable name cannot start with underscore: public var _val = 10', 3) + + lines =<< trim END + mnv9script + + class MyCar + var make: string + var age = 5 + + def new(make_arg: string) + this.make = make_arg + enddef + + def GetMake(): string + return $"make = {this.make}" + enddef + def GetAge(): number + return this.age + enddef + endclass + + var c = MyCar.new("abc") + assert_equal('make = abc', c.GetMake()) + + c = MyCar.new("def") + assert_equal('make = def', c.GetMake()) + + var c2 = MyCar.new("123") + assert_equal('make = 123', c2.GetMake()) + + def CheckCar() + assert_equal("make = def", c.GetMake()) + assert_equal(5, c.GetAge()) + enddef + CheckCar() + END + v9.CheckSourceSuccess(lines) + + lines =<< trim END + mnv9script + + class MyCar + var make: string + + def new(make_arg: string) + this.make = make_arg + enddef + endclass + + var c = MyCar.new("abc") + var c = MyCar.new("def") + END + v9.CheckSourceFailure(lines, 'E1041: Redefining script item: "c"', 12) + + lines =<< trim END + mnv9script + + class Foo + var x: list<number> = [] + + def Add(n: number): any + this.x->add(n) + return this + enddef + endclass + + echo Foo.new().Add(1).Add(2).x + echo Foo.new().Add(1).Add(2) + .x + echo Foo.new().Add(1) + .Add(2).x + echo Foo.new() + .Add(1).Add(2).x + echo Foo.new() + .Add(1) + .Add(2) + .x + END + v9.CheckSourceSuccess(lines) + + # Test for "public" cannot be abbreviated + lines =<< trim END + mnv9script + class Something + pub var val = 1 + endclass + END + v9.CheckSourceFailure(lines, 'E1065: Command cannot be shortened: pub var val = 1', 3) + + # Test for "public" keyword must be followed by "var" or "static". + lines =<< trim END + mnv9script + class Something + public val = 1 + endclass + END + v9.CheckSourceFailure(lines, 'E1331: public must be followed by "var" or "static"', 3) + + # Modify a instance variable using the class name in the script context + lines =<< trim END + mnv9script + class A + public var val = 1 + endclass + A.val = 1 + END + v9.CheckSourceFailure(lines, 'E1376: Object variable "val" accessible only using class "A" object', 5) + + # Read a instance variable using the class name in the script context + lines =<< trim END + mnv9script + class A + public var val = 1 + endclass + var i = A.val + END + v9.CheckSourceFailure(lines, 'E1376: Object variable "val" accessible only using class "A" object', 5) + + # Modify a instance variable using the class name in a def function + lines =<< trim END + mnv9script + class A + public var val = 1 + endclass + def T() + A.val = 1 + enddef + T() + END + v9.CheckSourceFailure(lines, 'E1376: Object variable "val" accessible only using class "A" object', 1) + + # Read a instance variable using the class name in a def function + lines =<< trim END + mnv9script + class A + public var val = 1 + endclass + def T() + var i = A.val + enddef + T() + END + v9.CheckSourceFailure(lines, 'E1376: Object variable "val" accessible only using class "A" object', 1) + + # Access from child class extending a class: + lines =<< trim END + mnv9script + class A + var ro_obj_var = 10 + public var rw_obj_var = 20 + var _priv_obj_var = 30 + endclass + + class B extends A + def Foo() + var x: number + x = this.ro_obj_var + this.ro_obj_var = 0 + x = this.rw_obj_var + this.rw_obj_var = 0 + x = this._priv_obj_var + this._priv_obj_var = 0 + enddef + endclass + + var b = B.new() + b.Foo() + END + v9.CheckSourceSuccess(lines) +enddef + +" Test for class variable access +def Test_class_variable_access() + # Test for "static" cannot be abbreviated + var lines =<< trim END + mnv9script + class Something + stat var val = 1 + endclass + END + v9.CheckSourceFailure(lines, 'E1065: Command cannot be shortened: stat var val = 1', 3) + + # Test for "static" cannot be followed by "public". + lines =<< trim END + mnv9script + class Something + static public var val = 1 + endclass + END + v9.CheckSourceFailure(lines, 'E1368: Static must be followed by "var" or "def"', 3) + + # A readonly class variable cannot be modified from a child class + lines =<< trim END + mnv9script + class A + static var ro_class_var = 40 + endclass + + class B extends A + def Foo() + A.ro_class_var = 50 + enddef + endclass + + var b = B.new() + b.Foo() + END + v9.CheckSourceFailure(lines, 'E1335: Variable "ro_class_var" in class "A" is not writable', 1) + + # A protected class variable cannot be accessed from a child class + lines =<< trim END + mnv9script + class A + static var _priv_class_var = 60 + endclass + + class B extends A + def Foo() + var i = A._priv_class_var + enddef + endclass + + var b = B.new() + b.Foo() + END + v9.CheckSourceFailure(lines, 'E1333: Cannot access protected variable "_priv_class_var" in class "A"', 1) + + # A protected class variable cannot be modified from a child class + lines =<< trim END + mnv9script + class A + static var _priv_class_var = 60 + endclass + + class B extends A + def Foo() + A._priv_class_var = 0 + enddef + endclass + + var b = B.new() + b.Foo() + END + v9.CheckSourceFailure(lines, 'E1333: Cannot access protected variable "_priv_class_var" in class "A"', 1) + + # Access from child class extending a class and from script context + lines =<< trim END + mnv9script + class A + static var ro_class_var = 10 + public static var rw_class_var = 20 + static var _priv_class_var = 30 + endclass + + class B extends A + def Foo() + var x: number + x = A.ro_class_var + assert_equal(10, x) + x = A.rw_class_var + assert_equal(25, x) + A.rw_class_var = 20 + assert_equal(20, A.rw_class_var) + enddef + endclass + + assert_equal(10, A.ro_class_var) + assert_equal(20, A.rw_class_var) + A.rw_class_var = 25 + assert_equal(25, A.rw_class_var) + var b = B.new() + b.Foo() + END + v9.CheckSourceSuccess(lines) +enddef + +def Test_class_object_compare() + var class_lines =<< trim END + mnv9script + class Item + var nr = 0 + var name = 'xx' + endclass + END + + # used at the script level and in a compiled function + var test_lines =<< trim END + var i1 = Item.new() + assert_equal(i1, i1) + assert_true(i1 is i1) + var i2 = Item.new() + assert_equal(i1, i2) + assert_false(i1 is i2) + var i3 = Item.new(0, 'xx') + assert_equal(i1, i3) + + var io1 = Item.new(1, 'xx') + assert_notequal(i1, io1) + var io2 = Item.new(0, 'yy') + assert_notequal(i1, io2) + END + + v9.CheckSourceSuccess(class_lines + test_lines) + v9.CheckSourceSuccess( + class_lines + ['def Test()'] + test_lines + ['enddef', 'Test()']) + + for op in ['>', '>=', '<', '<=', '=~', '!~'] + var op_lines = [ + 'var i1 = Item.new()', + 'var i2 = Item.new()', + 'echo i1 ' .. op .. ' i2', + ] + v9.CheckSourceFailure(class_lines + op_lines, 'E1153: Invalid operation for object', 8) + v9.CheckSourceFailure(class_lines + + ['def Test()'] + op_lines + ['enddef', 'Test()'], 'E1153: Invalid operation for object') + endfor +enddef + +def Test_object_type() + var lines =<< trim END + mnv9script + + class One + var one = 1 + endclass + class Two + var two = 2 + endclass + class TwoMore extends Two + var more = 9 + endclass + + var o: One = One.new() + var t: Two = Two.new() + var m: TwoMore = TwoMore.new() + var tm: Two = TwoMore.new() + + t = m + END + v9.CheckSourceSuccess(lines) + + lines =<< trim END + mnv9script + + class One + var one = 1 + endclass + class Two + var two = 2 + endclass + + var o: One = Two.new() + END + v9.CheckSourceFailure(lines, 'E1012: Type mismatch; expected object<One> but got object<Two>', 10) + + lines =<< trim END + mnv9script + + interface One + def GetMember(): number + endinterface + class Two implements One + var one = 1 + def GetMember(): number + return this.one + enddef + endclass + + var o: One = Two.new(5) + assert_equal(5, o.GetMember()) + END + v9.CheckSourceSuccess(lines) + + lines =<< trim END + mnv9script + + class Num + var n: number = 0 + endclass + + def Ref(name: string): func(Num): Num + return (arg: Num): Num => { + return eval(name)(arg) + } + enddef + + const Fn = Ref('Double') + var Double = (m: Num): Num => Num.new(m.n * 2) + + echo Fn(Num.new(4)) + END + v9.CheckSourceSuccess(lines) +enddef + +def Test_class_member() + # check access rules + var lines =<< trim END + mnv9script + class TextPos + var lnum = 1 + var col = 1 + static var counter = 0 + static var _secret = 7 + public static var anybody = 42 + + static def AddToCounter(nr: number) + counter += nr + enddef + endclass + + assert_equal(0, TextPos.counter) + TextPos.AddToCounter(3) + assert_equal(3, TextPos.counter) + assert_fails('echo TextPos.noSuchMember', 'E1337: Class variable "noSuchMember" not found in class "TextPos"') + + def GetCounter(): number + return TextPos.counter + enddef + assert_equal(3, GetCounter()) + + assert_fails('TextPos.noSuchMember = 2', 'E1337: Class variable "noSuchMember" not found in class "TextPos"') + assert_fails('TextPos.counter = 5', 'E1335: Variable "counter" in class "TextPos" is not writable') + assert_fails('TextPos.counter += 5', 'E1335: Variable "counter" in class "TextPos" is not writable') + + assert_fails('echo TextPos._secret', 'E1333: Cannot access protected variable "_secret" in class "TextPos"') + assert_fails('TextPos._secret = 8', 'E1333: Cannot access protected variable "_secret" in class "TextPos"') + + assert_equal(42, TextPos.anybody) + TextPos.anybody = 12 + assert_equal(12, TextPos.anybody) + TextPos.anybody += 5 + assert_equal(17, TextPos.anybody) + END + v9.CheckSourceSuccess(lines) + + # example in the help + lines =<< trim END + mnv9script + class OtherThing + var size: number + static var totalSize: number + + def new(this.size) + totalSize += this.size + enddef + endclass + assert_equal(0, OtherThing.totalSize) + var to3 = OtherThing.new(3) + assert_equal(3, OtherThing.totalSize) + var to7 = OtherThing.new(7) + assert_equal(10, OtherThing.totalSize) + END + v9.CheckSourceSuccess(lines) + + # using static class member twice + lines =<< trim END + mnv9script + + class HTML + static var author: string = 'John Doe' + + static def MacroSubstitute(s: string): string + return substitute(s, '{{author}}', author, 'gi') + enddef + endclass + + assert_equal('some text', HTML.MacroSubstitute('some text')) + assert_equal('some text', HTML.MacroSubstitute('some text')) + END + v9.CheckSourceSuccess(lines) + + # access protected member in lambda + lines =<< trim END + mnv9script + + class Foo + var _x: number = 0 + + def Add(n: number): number + const F = (): number => this._x + n + return F() + enddef + endclass + + var foo = Foo.new() + assert_equal(5, foo.Add(5)) + END + v9.CheckSourceSuccess(lines) + + # access protected member in lambda body + lines =<< trim END + mnv9script + + class Foo + var _x: number = 6 + + def Add(n: number): number + var Lam = () => { + this._x = this._x + n + } + Lam() + return this._x + enddef + endclass + + var foo = Foo.new() + assert_equal(13, foo.Add(7)) + END + v9.CheckSourceSuccess(lines) + + # check shadowing + lines =<< trim END + mnv9script + + class Some + static var count = 0 + def Method(count: number) + echo count + enddef + endclass + + var s = Some.new() + s.Method(7) + END + v9.CheckSourceFailure(lines, 'E1340: Argument already declared in the class: count', 5) + + # Use a local variable in a method with the same name as a class variable + lines =<< trim END + mnv9script + + class Some + static var count = 0 + def Method(arg: number) + var count = 3 + echo arg count + enddef + endclass + + var s = Some.new() + s.Method(7) + END + v9.CheckSourceFailure(lines, 'E1341: Variable already declared in the class: count', 1) + + # Test for using an invalid type for a member variable + lines =<< trim END + mnv9script + class A + var val: xxx + endclass + END + v9.CheckSourceFailure(lines, 'E1010: Type not recognized: xxx', 3) + + # Test for setting a member on a null object + lines =<< trim END + mnv9script + class A + public var val: string + endclass + + def F() + var obj: A + obj.val = "" + enddef + F() + END + v9.CheckSourceFailure(lines, 'E1360: Using a null object', 2) + + # Test for accessing a member on a null object + lines =<< trim END + mnv9script + class A + var val: string + endclass + + def F() + var obj: A + echo obj.val + enddef + F() + END + v9.CheckSourceFailure(lines, 'E1360: Using a null object', 2) + + # Test for setting a member on a null object, at script level + lines =<< trim END + mnv9script + class A + public var val: string + endclass + + var obj: A + obj.val = "" + END + v9.CheckSourceFailure(lines, 'E1360: Using a null object', 7) + + # Test for accessing a member on a null object, at script level + lines =<< trim END + mnv9script + class A + var val: string + endclass + + var obj: A + echo obj.val + END + v9.CheckSourceFailure(lines, 'E1360: Using a null object', 7) + + # Test for no space before or after the '=' when initializing a member + # variable + lines =<< trim END + mnv9script + class A + var val: number= 10 + endclass + END + v9.CheckSourceFailure(lines, "E1004: White space required before and after '='", 3) + lines =<< trim END + mnv9script + class A + var val: number =10 + endclass + END + v9.CheckSourceFailure(lines, "E1004: White space required before and after '='", 3) + + # Space is not allowed before the object member variable name + lines =<< trim END + mnv9script + class A + var n: number = 10 + endclass + + def Fn() + var a = A.new() + var y = a. n + enddef + defcompile + END + v9.CheckSourceFailure(lines, "E1202: No white space allowed after '.': . n", 2) + + # Access a non-existing member + lines =<< trim END + mnv9script + class A + endclass + var a = A.new() + var v = a.bar + END + v9.CheckSourceFailure(lines, 'E1326: Variable "bar" not found in object "A"', 5) +enddef + +" These messages should show the defining class of the variable (base class), +" not the class that did the reference (super class) +def Test_defining_class_message() + var lines =<< trim END + mnv9script + + class Base + var _v1: list<list<number>> + endclass + + class Child extends Base + endclass + + var o = Child.new() + var x = o._v1 + END + v9.CheckSourceFailure(lines, 'E1333: Cannot access protected variable "_v1" in class "Base"', 11) + lines =<< trim END + mnv9script + + class Base + var _v1: list<list<number>> + endclass + + class Child extends Base + endclass + + def F() + var o = Child.new() + var x = o._v1 + enddef + F() + END + v9.CheckSourceFailure(lines, 'E1333: Cannot access protected variable "_v1" in class "Base"', 2) + lines =<< trim END + mnv9script + + class Base + var v1: list<list<number>> + endclass + + class Child extends Base + endclass + + var o = Child.new() + o.v1 = [] + END + v9.CheckSourceFailure(lines, 'E1335: Variable "v1" in class "Base" is not writable', 11) + lines =<< trim END + mnv9script + + class Base + var v1: list<list<number>> + endclass + + class Child extends Base + endclass + + def F() + var o = Child.new() + o.v1 = [] + enddef + F() + END + + # Attempt to read a protected variable that is in the middle + # of the class hierarchy. + v9.CheckSourceFailure(lines, 'E1335: Variable "v1" in class "Base" is not writable', 2) + lines =<< trim END + mnv9script + + class Base0 + endclass + + class Base extends Base0 + var _v1: list<list<number>> + endclass + + class Child extends Base + endclass + + def F() + var o = Child.new() + var x = o._v1 + enddef + F() + END + v9.CheckSourceFailure(lines, 'E1333: Cannot access protected variable "_v1" in class "Base"', 2) + + # Attempt to read a protected variable that is at the start + # of the class hierarchy. + lines =<< trim END + mnv9script + + class Base0 + endclass + + class Base extends Base0 + endclass + + class Child extends Base + var _v1: list<list<number>> + endclass + + def F() + var o = Child.new() + var x = o._v1 + enddef + F() + END + v9.CheckSourceFailure(lines, 'E1333: Cannot access protected variable "_v1" in class "Child"', 2) +enddef + +func Test_class_garbagecollect() + let lines =<< trim END + mnv9script + + class Point + var p = [2, 3] + static var pl = ['a', 'b'] + static var pd = {a: 'a', b: 'b'} + endclass + + echo Point.pl Point.pd + call test_garbagecollect_now() + echo Point.pl Point.pd + END + call v9.CheckSourceSuccess(lines) + + let lines =<< trim END + mnv9script + + interface View + endinterface + + class Widget + var view: View + endclass + + class MyView implements View + var widget: Widget + + def new() + # this will result in a circular reference to this object + var widget = Widget.new(this) + enddef + endclass + + var view = MyView.new() + + # overwrite "view", will be garbage-collected next + view = MyView.new() + test_garbagecollect_now() + END + call v9.CheckSourceSuccess(lines) +endfunc + +def Test_class_method() + var lines =<< trim END + mnv9script + class Value + var value = 0 + static var objects = 0 + + def new(v: number) + this.value = v + ++objects + enddef + + static def GetCount(): number + return objects + enddef + endclass + + assert_equal(0, Value.GetCount()) + var v1 = Value.new(2) + assert_equal(1, Value.GetCount()) + var v2 = Value.new(7) + assert_equal(2, Value.GetCount()) + END + v9.CheckSourceSuccess(lines) + + # Test for cleaning up after a class definition failure when using class + # functions. + lines =<< trim END + mnv9script + class A + static def Foo() + enddef + aaa + endclass + END + v9.CheckSourceFailure(lines, 'E1318: Not a valid command in a class: aaa', 5) + + # Test for calling a class method from another class method without the class + # name prefix. + lines =<< trim END + mnv9script + class A + static var myList: list<number> = [1] + static def Foo(n: number) + myList->add(n) + enddef + static def Bar() + Foo(2) + enddef + def Baz() + Foo(3) + enddef + endclass + A.Bar() + var a = A.new() + a.Baz() + assert_equal([1, 2, 3], A.myList) + END + v9.CheckSourceSuccess(lines) +enddef + +def Test_class_defcompile() + var lines =<< trim END + mnv9script + + class C + def Fo(i: number): string + return i + enddef + endclass + + defcompile C.Fo + END + v9.CheckSourceFailure(lines, 'E1012: Type mismatch; expected string but got number', 1) + + lines =<< trim END + mnv9script + + class C + static def Fc(): number + return 'x' + enddef + endclass + + defcompile C.Fc + END + v9.CheckSourceFailure(lines, 'E1012: Type mismatch; expected number but got string', 1) + + lines =<< trim END + mnv9script + + class C + static def new() + enddef + endclass + + defcompile C.new + END + v9.CheckSourceFailure(lines, 'E1370: Cannot define a "new" method as static', 5) + + # Trying to compile a function using a non-existing class variable + lines =<< trim END + mnv9script + defcompile x.Foo() + END + v9.CheckSourceFailure(lines, 'E475: Invalid argument: x.Foo()', 2) + + # Trying to compile a function using a variable which is not a class + lines =<< trim END + mnv9script + var x: number + defcompile x.Foo() + END + v9.CheckSourceFailure(lines, 'E475: Invalid argument: x.Foo()', 3) + + # Trying to compile a function without specifying the name + lines =<< trim END + mnv9script + class A + endclass + defcompile A. + END + v9.CheckSourceFailure(lines, 'E475: Invalid argument: A.', 4) + + # Trying to compile a non-existing class object member function + lines =<< trim END + mnv9script + class A + endclass + var a = A.new() + defcompile a.Foo() + END + v9.CheckSourceFailureList(lines, ['E1326: Variable "Foo" not found in object "A"', 'E475: Invalid argument: a.Foo()']) +enddef + +def Test_class_object_to_string() + var lines =<< trim END + mnv9script + class TextPosition + var lnum = 1 + var col = 22 + endclass + + assert_equal("class TextPosition", string(TextPosition)) + + var pos = TextPosition.new() + assert_equal("object of TextPosition {lnum: 1, col: 22}", string(pos)) + END + v9.CheckSourceSuccess(lines) + + # check string() with object nesting + lines =<< trim END + mnv9script + class C + var nest1: C + var nest2: C + def Init(n1: C, n2: C) + this.nest1 = n1 + this.nest2 = n2 + enddef + endclass + + var o1 = C.new() + var o2 = C.new() + o1.Init(o1, o2) + o2.Init(o2, o1) + + # The following previously put's mnv into an infinite loop. + + var expect = "object of C {nest1: object of C {...}, nest2: object of C {nest1: object of C {...}, nest2: object of C {...}}}" + assert_equal(expect, string(o1)) + END + v9.CheckSourceSuccess(lines) + + lines =<< trim END + mnv9script + + class B + endclass + + class C + var b: B + var c: C + endclass + + var o1 = C.new(B.new(), C.new(B.new())) + var expect = "object of C {b: object of B {}, c: object of C {b: object of B {}, c: object of [unknown]}}" + assert_equal(expect, string(o1)) + END + v9.CheckSourceSuccess(lines) +enddef + +def Test_class_used_as_type() + var lines =<< trim END + mnv9script + + class Point + var x = 0 + var y = 0 + endclass + + var p: Point + p = Point.new(2, 33) + assert_equal(2, p.x) + assert_equal(33, p.y) + END + v9.CheckSourceSuccess(lines) + + lines =<< trim END + mnv9script + + interface HasX + var x: number + endinterface + + class Point implements HasX + var x = 0 + var y = 0 + endclass + + var p: Point + p = Point.new(2, 33) + var hx = p + assert_equal(2, hx.x) + END + v9.CheckSourceSuccess(lines) + + lines =<< trim END + mnv9script + + class Point + var x = 0 + var y = 0 + endclass + + var p: Point + p = 'text' + END + v9.CheckSourceFailure(lines, 'E1012: Type mismatch; expected object<Point> but got string', 9) +enddef + +def Test_class_extends() + var lines =<< trim END + mnv9script + class Base + var one = 1 + def GetOne(): number + return this.one + enddef + endclass + class Child extends Base + var two = 2 + def GetTotal(): number + return this.one + this.two + enddef + endclass + var o = Child.new() + assert_equal(1, o.one) + assert_equal(2, o.two) + assert_equal(1, o.GetOne()) + assert_equal(3, o.GetTotal()) + END + v9.CheckSourceSuccess(lines) + + lines =<< trim END + mnv9script + class Base + var one = 1 + endclass + class Child extends Base + var two = 2 + endclass + var o = Child.new(3, 44) + assert_equal(3, o.one) + assert_equal(44, o.two) + END + v9.CheckSourceSuccess(lines) + + lines =<< trim END + mnv9script + class Base + var one = 1 + endclass + class Child extends Base extends Base + var two = 2 + endclass + END + v9.CheckSourceFailure(lines, 'E1352: Duplicate "extends"', 5) + + lines =<< trim END + mnv9script + class Child extends BaseClass + var two = 2 + endclass + END + v9.CheckSourceFailure(lines, 'E1353: Class name not found: BaseClass', 4) + + lines =<< trim END + mnv9script + var SomeVar = 99 + class Child extends SomeVar + var two = 2 + endclass + END + v9.CheckSourceFailure(lines, 'E1354: Cannot extend SomeVar', 5) + + lines =<< trim END + mnv9script + class Child + var age: number + def ToString(): number + return this.age + enddef + def ToString(): string + return this.age + enddef + endclass + END + v9.CheckSourceFailure(lines, 'E1355: Duplicate function: ToString', 9) + + lines =<< trim END + mnv9script + class Base + var name: string + static def ToString(): string + return 'Base class' + enddef + endclass + + class Child extends Base + var age: number + def ToString(): string + return Base.ToString() .. ': ' .. this.age + enddef + endclass + + var o = Child.new('John', 42) + assert_equal('Base class: 42', o.ToString()) + END + v9.CheckSourceSuccess(lines) + + lines =<< trim END + mnv9script + class Base + var value = 1 + def new(init: number) + this.value = number + 1 + enddef + endclass + class Child extends Base + def new() + this.new(3) + enddef + endclass + var c = Child.new() + END + v9.CheckSourceFailure(lines, 'E1385: Class method "new" accessible only using class "Child"', 1) + + # base class with more than one object member + lines =<< trim END + mnv9script + + class Result + var success: bool + var value: any = null + endclass + + class Success extends Result + def new(this.value = v:none) + this.success = true + enddef + endclass + + var v = Success.new('asdf') + assert_equal("object of Success {success: true, value: 'asdf'}", string(v)) + END + v9.CheckSourceSuccess(lines) + + # class name after "extends" doesn't end in a space or NUL character + lines =<< trim END + mnv9script + class A + endclass + class B extends A" + endclass + END + v9.CheckSourceFailure(lines, 'E1315: White space required after name: A"', 4) +enddef + +def Test_using_base_class() + var lines =<< trim END + mnv9script + + class BaseEE + def Enter(): any + return null + enddef + def Exit(resource: any): void + enddef + endclass + + class ChildEE extends BaseEE + def Enter(): any + return 42 + enddef + + def Exit(resource: number): void + g:result ..= '/exit' + enddef + endclass + + def With(ee: BaseEE) + var r = ee.Enter() + try + g:result ..= r + finally + g:result ..= '/finally' + ee.Exit(r) + endtry + enddef + + g:result = '' + With(ChildEE.new()) + assert_equal('42/finally/exit', g:result) + END + v9.CheckSourceSuccess(lines) + unlet g:result +enddef + +" Test for using a method from the super class +def Test_super_dispatch() + # See #15448 and #15463 + var lines =<< trim END + mnv9script + + class A + def String(): string + return 'A' + enddef + endclass + + class B extends A + def String(): string + return super.String() + enddef + endclass + + class C extends B + endclass + + assert_equal('A', C.new().String()) + END + v9.CheckSourceSuccess(lines) + + lines =<< trim END + mnv9script + + class A + def F(): string + return 'AA' + enddef + endclass + + class B extends A + def F(): string + return 'BB' + enddef + def S(): string + return super.F() + enddef + def S0(): string + return this.S() + enddef + endclass + + class C extends B + def F(): string + return 'CC' + enddef + def ToB(): string + return super.F() + enddef + endclass + + assert_equal('AA', B.new().S()) + assert_equal('AA', C.new().S()) + assert_equal('AA', B.new().S0()) + assert_equal('AA', C.new().S0()) + + assert_equal('BB', C.new().ToB()) + + assert_equal('CC', C.new().F()) + assert_equal('BB', B.new().F()) + assert_equal('AA', A.new().F()) + END + v9.CheckSourceSuccess(lines) + + lines =<< trim END + mnv9script + + var call_chain: list<string> + + abstract class A + abstract def _G(): string + + def F(): string + call_chain->add('A.F()') + return this._G() + enddef + def _H(): string + call_chain->add('A._H()') + return this.F() + enddef + endclass + + class B extends A + def _G(): string + call_chain->add('B.G()') + return 'BBB' + enddef + def SF(): string + call_chain->add('B.SF()') + return super._H() + enddef + endclass + + class C extends B + endclass + + class D extends C + def SF(): string + call_chain->add('D.SF()') + return super.SF() + enddef + endclass + + class E extends D + def SF(): string + call_chain->add('E.SF()') + return super.SF() + enddef + endclass + + class F extends E + def _G(): string + call_chain->add('F._G()') + return 'FFF' + enddef + endclass + + # E.new() -> A.F() -> B._G() + call_chain = [] + var o1 = E.new() + assert_equal('BBB', o1.F()) + assert_equal(['A.F()', 'B.G()'], call_chain) + + # F.new() -> E.SF() -> D.SF() -> B.SF() -> A._H() -> A.F() -> F._G() + call_chain = [] + var o2 = F.new() + assert_equal('FFF', o2.SF()) + assert_equal(['E.SF()', 'D.SF()', 'B.SF()', 'A._H()', 'A.F()', 'F._G()'], call_chain) + END + v9.CheckSourceSuccess(lines) + + # problems with method dispatch: super -> abstract + # https://github.com/Project-Tick/Project-Tick/issues/15514 + lines =<< trim END + mnv9script + abstract class B + abstract def ToString(): string + endclass + + class C extends B + def ToString(): string + return super.ToString() + enddef + endclass + + try + defcompile C.ToString + call assert_false(1, 'command should have failed') + catch + call assert_exception('E1431: Abstract method "ToString" in class "B" cannot be accessed directly') + endtry + END + v9.CheckSourceSuccess(lines) + + # problems with method dispatch: super -> abstract -> concrete + lines =<< trim END + mnv9script + + class A + def ToString() + echo 'A' + enddef + endclass + + abstract class B extends A + abstract def ToString() + endclass + + class C extends B + def ToString() + super.ToString() + enddef + endclass + + try + defcompile C.ToString + call assert_false(1, 'command should have failed') + catch + call assert_exception('E1431: Abstract method "ToString" in class "B" cannot be accessed directly') + endtry + END + v9.CheckSourceSuccess(lines) + + # Invoking a super method and an interface method which have the same name. + lines =<< trim END + mnv9script + + interface I + def ToString(): string + endinterface + + # Note that A does not implement I. + class A + def ToString(): string + return 'A' + enddef + endclass + + class B extends A implements I + def ToString(): string + return super.ToString() + enddef + endclass + + def TestI(i: I): string + return i.ToString() + enddef + + assert_equal('A', B.new().ToString()) + assert_equal('A', TestI(B.new())) + END + v9.CheckSourceSuccess(lines) + + # super and an abstract class with no abstract methods + lines =<< trim END + mnv9script + + class A + def ToString(): string + return 'A' + enddef + endclass + + # An abstract class with no abstract methods. + abstract class B extends A + endclass + + class C extends B + def ToString(): string + return super.ToString() + enddef + endclass + + def TestA(a: A): string + return a.ToString() + enddef + + def TestB(b: B): string + return b.ToString() + enddef + + assert_equal('A', C.new().ToString()) + assert_equal('A', TestA(A.new())) + assert_equal('A', TestA(C.new())) + assert_equal('A', TestB(C.new())) + END + v9.CheckSourceSuccess(lines) + + # super and an abstract class with no abstract methods and the initial + # implements clause + lines =<< trim END + mnv9script + + interface I + def ToString(): string + endinterface + + # Note that A does not implement I. + class A + def ToString(): string + return 'A' + enddef + endclass + + # An abstract class with no abstract methods. + abstract class B extends A implements I + endclass + + class C extends B implements I + def ToString(): string + return super.ToString() + enddef + endclass + + # Note that A.ToString() is different from I.ToString(). + def TestA(a: A): string + return a.ToString() + enddef + + assert_equal('A', C.new().ToString()) + assert_equal('A', TestA(A.new())) + assert_equal('A', TestA(C.new())) + END + v9.CheckSourceSuccess(lines) + + # Invoking a class method in the parent class using "super" should fail + lines =<< trim END + mnv9script + + class A + static def Fn(): string + return 'A' + enddef + endclass + + class B extends A + static def Fn(): string + return super.Fn() + enddef + endclass + defcompile + END + v9.CheckSourceFailure(lines, 'E1325: Method "Fn" not found in class "B"') + + # Missing name after "super" keyword + lines =<< trim END + mnv9script + class A + endclass + class B extends A + def Fn() + var x = super.() + enddef + endclass + defcompile + END + v9.CheckSourceFailure(lines, 'E1127: Missing name after dot', 1) +enddef + +def Test_class_import() + var lines =<< trim END + mnv9script + export class Animal + var kind: string + var name: string + endclass + END + writefile(lines, 'Xanimal.mnv', 'D') + + lines =<< trim END + mnv9script + import './Xanimal.mnv' as animal + + var a: animal.Animal + a = animal.Animal.new('fish', 'Eric') + assert_equal('fish', a.kind) + assert_equal('Eric', a.name) + + var b: animal.Animal = animal.Animal.new('cat', 'Garfield') + assert_equal('cat', b.kind) + assert_equal('Garfield', b.name) + END + v9.CheckScriptSuccess(lines) +enddef + +" Test for importing a class into a legacy script and calling the class method +def Test_class_method_from_legacy_script() + var lines =<< trim END + mnv9script + export class A + static var name: string = 'a' + static def SetName(n: string) + name = n + enddef + endclass + END + writefile(lines, 'Xmnv9export.mnv', 'D') + + lines =<< trim END + import './Xmnv9export.mnv' as mnv9 + + call s:mnv9.A.SetName('b') + call assert_equal('b', s:mnv9.A.name) + END + v9.CheckScriptSuccess(lines) +enddef + +" Test for extending an imported class +def Test_extend_imported_class() + var lines =<< trim END + mnv9script + export class Imp_C1 + def Fn1(): number + return 5 + enddef + endclass + END + writefile(lines, 'Xextendimportclass.mnv', 'D') + + lines =<< trim END + mnv9script + import './Xextendimportclass.mnv' as XClass + + class A extends XClass.Imp_C1 + endclass + var a = A.new() + assert_equal(5, a.Fn1()) + END + v9.CheckScriptSuccess(lines) +enddef + +def Test_abstract_class() + var lines =<< trim END + mnv9script + abstract class Base + var name: string + endclass + class Person extends Base + var age: number + endclass + var p: Base = Person.new('Peter', 42) + assert_equal('Peter', p.name) + assert_equal(42, p.age) + END + v9.CheckSourceSuccess(lines) + + lines =<< trim END + mnv9script + abstract class Base + var name: string + endclass + class Person extends Base + var age: number + endclass + var p = Base.new('Peter') + END + v9.CheckSourceFailure(lines, 'E1325: Method "new" not found in class "Base"', 8) + + lines =<< trim END + abstract class Base + var name: string + endclass + END + v9.CheckSourceFailure(lines, 'E1316: Class can only be defined in MNV9 script', 1) + + # Test for "abstract" cannot be abbreviated + lines =<< trim END + mnv9script + abs class A + endclass + END + v9.CheckSourceFailure(lines, 'E1065: Command cannot be shortened: abs class A', 2) + + # Additional commands after "abstract class" + lines =<< trim END + mnv9script + abstract class Something | var x = [] + endclass + END + v9.CheckSourceFailure(lines, "E488: Trailing characters: | var x = []", 2) + + # Abstract class cannot have a "new" function + lines =<< trim END + mnv9script + abstract class Base + def new() + enddef + endclass + END + v9.CheckSourceFailure(lines, 'E1359: Cannot define a "new" method in an abstract class', 4) + + # extending an abstract class with class methods and variables + lines =<< trim END + mnv9script + abstract class A + static var s: string = 'mnv' + static def Fn(): list<number> + return [10] + enddef + endclass + class B extends A + endclass + var b = B.new() + assert_equal('mnv', A.s) + assert_equal([10], A.Fn()) + END + v9.CheckScriptSuccess(lines) +enddef + +def Test_closure_in_class() + var lines =<< trim END + mnv9script + + class Foo + var y: list<string> = ['B'] + + def new() + g:result = filter(['A', 'B'], (_, v) => index(this.y, v) == -1) + enddef + endclass + + Foo.new() + assert_equal(['A'], g:result) + END + v9.CheckSourceSuccess(lines) +enddef + +def Test_construct_object_from_legacy() + # Cannot directly invoke constructor from legacy + var lines =<< trim END + mnv9script + + var newCalled = false + + class A + def new(arg: string) + newCalled = true + enddef + endclass + + export def CreateA(...args: list<any>): A + return call(A.new, args) + enddef + + g:P = CreateA + legacy call g:P('some_arg') + assert_equal(true, newCalled) + unlet g:P + END + v9.CheckSourceSuccess(lines) + + lines =<< trim END + mnv9script + + var newCalled = false + + class A + static def CreateA(options = {}): any + return A.new() + enddef + def new() + newCalled = true + enddef + endclass + + g:P = A.CreateA + legacy call g:P() + assert_equal(true, newCalled) + unlet g:P + END + v9.CheckSourceSuccess(lines) + + # This also tests invoking "new()" with "call" + lines =<< trim END + mnv9script + + var createdObject: any + + class A + var val1: number + var val2: number + static def CreateA(...args: list<any>): any + createdObject = call(A.new, args) + return createdObject + enddef + endclass + + g:P = A.CreateA + legacy call g:P(3, 5) + assert_equal(3, createdObject.val1) + assert_equal(5, createdObject.val2) + legacy call g:P() + assert_equal(0, createdObject.val1) + assert_equal(0, createdObject.val2) + legacy call g:P(7) + assert_equal(7, createdObject.val1) + assert_equal(0, createdObject.val2) + unlet g:P + END + v9.CheckSourceSuccess(lines) +enddef + +def Test_defer_with_object() + var lines =<< trim END + mnv9script + + class CWithEE + def Enter() + g:result ..= "entered/" + enddef + def Exit() + g:result ..= "exited" + enddef + endclass + + def With(ee: CWithEE, F: func) + ee.Enter() + defer ee.Exit() + F() + enddef + + g:result = '' + var obj = CWithEE.new() + obj->With(() => { + g:result ..= "called/" + }) + assert_equal('entered/called/exited', g:result) + END + v9.CheckSourceSuccess(lines) + unlet g:result + + lines =<< trim END + mnv9script + + class BaseWithEE + def Enter() + g:result ..= "entered-base/" + enddef + def Exit() + g:result ..= "exited-base" + enddef + endclass + + class CWithEE extends BaseWithEE + def Enter() + g:result ..= "entered-child/" + enddef + def Exit() + g:result ..= "exited-child" + enddef + endclass + + def With(ee: BaseWithEE, F: func) + ee.Enter() + defer ee.Exit() + F() + enddef + + g:result = '' + var obj = CWithEE.new() + obj->With(() => { + g:result ..= "called/" + }) + assert_equal('entered-child/called/exited-child', g:result) + END + v9.CheckSourceSuccess(lines) + unlet g:result +enddef + +" The following test used to crash MNV (Github issue #12676) +def Test_extends_method_crashes_mnv() + var lines =<< trim END + mnv9script + + class Observer + endclass + + class Property + var value: any + + def Set(v: any) + if v != this.value + this.value = v + endif + enddef + + def Register(observer: Observer) + enddef + endclass + + class Bool extends Property + var value2: bool + endclass + + def Observe(obj: Property, who: Observer) + obj.Register(who) + enddef + + var p = Bool.new(false) + var myObserver = Observer.new() + + Observe(p, myObserver) + + p.Set(true) + END + v9.CheckSourceSuccess(lines) +enddef + +" Test for calling a method in a class that is extended +def Test_call_method_in_extended_class() + var lines =<< trim END + mnv9script + + var prop_init_called = false + var prop_register_called = false + + class Property + def Init() + prop_init_called = true + enddef + + def Register() + prop_register_called = true + enddef + endclass + + class Bool extends Property + endclass + + def Observe(obj: Property) + obj.Register() + enddef + + var p = Property.new() + Observe(p) + + p.Init() + assert_true(prop_init_called) + assert_true(prop_register_called) + END + v9.CheckSourceSuccess(lines) +enddef + +def Test_instanceof() + var lines =<< trim END + mnv9script + + class Base1 + endclass + + class Base2 extends Base1 + endclass + + interface Intf1 + endinterface + + class Mix1 implements Intf1 + endclass + + class Base3 extends Mix1 + endclass + + type AliasBase1 = Base1 + type AliasBase2 = Base2 + type AliasIntf1 = Intf1 + type AliasMix1 = Mix1 + + var b1 = Base1.new() + var b2 = Base2.new() + var b3 = Base3.new() + + assert_true(instanceof(b1, Base1)) + assert_true(instanceof(b2, Base1)) + assert_false(instanceof(b1, Base2)) + assert_true(instanceof(b3, Mix1)) + assert_true(instanceof(b3, Base1, Base2, Intf1)) + + assert_true(instanceof(b1, AliasBase1)) + assert_true(instanceof(b2, AliasBase1)) + assert_false(instanceof(b1, AliasBase2)) + assert_true(instanceof(b3, AliasMix1)) + assert_true(instanceof(b3, AliasBase1, AliasBase2, AliasIntf1)) + + def Foo() + var a1 = Base1.new() + var a2 = Base2.new() + var a3 = Base3.new() + + assert_true(instanceof(a1, Base1)) + assert_true(instanceof(a2, Base1)) + assert_false(instanceof(a1, Base2)) + assert_true(instanceof(a3, Mix1)) + assert_true(instanceof(a3, Base1, Base2, Intf1)) + + assert_true(instanceof(a1, AliasBase1)) + assert_true(instanceof(a2, AliasBase1)) + assert_false(instanceof(a1, AliasBase2)) + assert_true(instanceof(a3, AliasMix1)) + assert_true(instanceof(a3, AliasBase1, AliasBase2, AliasIntf1)) + enddef + Foo() + + var o_null: Base1 + assert_false(instanceof(o_null, Base1)) + + END + v9.CheckSourceSuccess(lines) + + lines =<< trim END + mnv9script + + class Base1 + endclass + instanceof(Base1.new()) + END + v9.CheckSourceFailure(lines, 'E119: Not enough arguments for function: instanceof') + + lines =<< trim END + mnv9script + + class Base1 + endclass + def F() + instanceof(Base1.new()) + enddef + F() + END + v9.CheckSourceFailure(lines, 'E119: Not enough arguments for function: instanceof') + + lines =<< trim END + mnv9script + + class Base1 + endclass + + class Base2 + endclass + + var o = Base2.new() + instanceof(o, Base1, Base2, 3) + END + v9.CheckSourceFailure(lines, 'E693: Class or class typealias required for argument 4', 10) + + lines =<< trim END + mnv9script + + class Base1 + endclass + + class Base2 + endclass + + def F() + var o = Base2.new() + instanceof(o, Base1, Base2, 3) + enddef + F() + END + v9.CheckSourceFailure(lines, 'E693: Class or class typealias required for argument 4') +enddef + +" Test for calling a method in the parent class that is extended partially. +" This used to fail with the 'E118: Too many arguments for function: Text' error +" message (Github issue #12524). +def Test_call_method_in_parent_class() + var lines =<< trim END + mnv9script + + class Widget + var _lnum: number = 1 + + def SetY(lnum: number) + this._lnum = lnum + enddef + + def Text(): string + return '' + enddef + endclass + + class Foo extends Widget + def Text(): string + return '<Foo>' + enddef + endclass + + def Stack(w1: Widget, w2: Widget): list<Widget> + w1.SetY(1) + w2.SetY(2) + return [w1, w2] + enddef + + var foo1 = Foo.new() + var foo2 = Foo.new() + var l = Stack(foo1, foo2) + END + v9.CheckSourceSuccess(lines) +enddef + +" Test for calling methods from three levels of classes +def Test_multi_level_method_call() + var lines =<< trim END + mnv9script + + var A_func1: number = 0 + var A_func2: number = 0 + var A_func3: number = 0 + var B_func2: number = 0 + var B_func3: number = 0 + var C_func3: number = 0 + + class A + def Func1() + A_func1 += 1 + enddef + + def Func2() + A_func2 += 1 + enddef + + def Func3() + A_func3 += 1 + enddef + endclass + + class B extends A + def Func2() + B_func2 += 1 + enddef + + def Func3() + B_func3 += 1 + enddef + endclass + + class C extends B + def Func3() + C_func3 += 1 + enddef + endclass + + def A_CallFuncs(a: A) + a.Func1() + a.Func2() + a.Func3() + enddef + + def B_CallFuncs(b: B) + b.Func1() + b.Func2() + b.Func3() + enddef + + def C_CallFuncs(c: C) + c.Func1() + c.Func2() + c.Func3() + enddef + + var cobj = C.new() + A_CallFuncs(cobj) + B_CallFuncs(cobj) + C_CallFuncs(cobj) + assert_equal(3, A_func1) + assert_equal(0, A_func2) + assert_equal(0, A_func3) + assert_equal(3, B_func2) + assert_equal(0, B_func3) + assert_equal(3, C_func3) + END + v9.CheckSourceSuccess(lines) +enddef + +" Test for using members from three levels of classes +def Test_multi_level_member_access() + var lines =<< trim END + mnv9script + + class A + public var val1: number = 0 + endclass + + class B extends A + public var val2: number = 0 + endclass + + class C extends B + public var val3: number = 0 + endclass + + def A_members(a: A) + a.val1 += 1 + enddef + + def B_members(b: B) + b.val1 += 1 + b.val2 += 1 + enddef + + def C_members(c: C) + c.val1 += 1 + c.val2 += 1 + c.val3 += 1 + enddef + + var cobj = C.new() + A_members(cobj) + B_members(cobj) + C_members(cobj) + assert_equal(3, cobj.val1) + assert_equal(2, cobj.val2) + assert_equal(1, cobj.val3) + END + v9.CheckSourceSuccess(lines) +enddef + +" Test expansion of <stack> with class methods. +def Test_stack_expansion_with_methods() + var lines =<< trim END + mnv9script + + class C + def M1() + F0() + enddef + endclass + + def F0() + assert_match('<SNR>\d\+_F\[1\]\.\.<SNR>\d\+_C\.M1\[1\]\.\.<SNR>\d\+_F0\[1\]$', expand('<stack>')) + enddef + + def F() + C.new().M1() + enddef + + F() + END + v9.CheckSourceSuccess(lines) +enddef + +" Test the return type of the new() constructor +def Test_new_return_type() + # new() uses the default return type and there is no return statement + var lines =<< trim END + mnv9script + + class C + var _bufnr: number + + def new(this._bufnr) + if !bufexists(this._bufnr) + this._bufnr = -1 + endif + enddef + endclass + + var c = C.new(12345) + assert_equal('object<C>', typename(c)) + + var v1: C + v1 = C.new(12345) + assert_equal('object<C>', typename(v1)) + + def F() + var v2: C + v2 = C.new(12345) + assert_equal('object<C>', typename(v2)) + enddef + F() + END + v9.CheckSourceSuccess(lines) + + # new() uses the default return type and an empty 'return' statement + lines =<< trim END + mnv9script + + class C + var _bufnr: number + + def new(this._bufnr) + if !bufexists(this._bufnr) + this._bufnr = -1 + return + endif + enddef + endclass + + var c = C.new(12345) + assert_equal('object<C>', typename(c)) + + var v1: C + v1 = C.new(12345) + assert_equal('object<C>', typename(v1)) + + def F() + var v2: C + v2 = C.new(12345) + assert_equal('object<C>', typename(v2)) + enddef + F() + END + v9.CheckSourceSuccess(lines) + + # new() uses "any" return type and returns "this" + lines =<< trim END + mnv9script + + class C + var _bufnr: number + + def new(this._bufnr): any + if !bufexists(this._bufnr) + this._bufnr = -1 + return this + endif + enddef + endclass + END + v9.CheckSourceFailure(lines, 'E1365: Cannot use a return type with the "new" method', 11) + + # new() uses 'Dict' return type and returns a Dict + lines =<< trim END + mnv9script + + class C + var _state: dict<any> + + def new(): dict<any> + this._state = {} + return this._state + enddef + endclass + + var c = C.new() + assert_equal('object<C>', typename(c)) + END + v9.CheckSourceFailure(lines, 'E1365: Cannot use a return type with the "new" method', 9) +enddef + +" Test for checking a member initialization type at run time. +def Test_runtime_type_check_for_member_init() + var lines =<< trim END + mnv9script + + var retnum: bool = false + + def F(): any + retnum = !retnum + if retnum + return 1 + else + return "hello" + endif + enddef + + class C + var _foo: bool = F() + endclass + + var c1 = C.new() + var c2 = C.new() + END + v9.CheckSourceFailure(lines, 'E1012: Type mismatch; expected bool but got string', 0) +enddef + +" Test for locking a variable referring to an object and reassigning to another +" object. +def Test_lockvar_object() + var lines =<< trim END + mnv9script + + class C + var val: number + def new(this.val) + enddef + endclass + + var some_dict: dict<C> = { a: C.new(1), b: C.new(2), c: C.new(3), } + lockvar 2 some_dict + + var current: C + current = some_dict['c'] + assert_equal(3, current.val) + current = some_dict['b'] + assert_equal(2, current.val) + + def F() + current = some_dict['c'] + enddef + + def G() + current = some_dict['b'] + enddef + + F() + assert_equal(3, current.val) + G() + assert_equal(2, current.val) + END + v9.CheckSourceSuccess(lines) +enddef + +" Test trying to lock an object variable from various places +def Test_lockvar_object_variable() + # An object variable lockvar has several cases: + # object method, scriptlevel, scriplevel from :def, :def arg + # method arg, static method arg. + # Also different depths + + # + # lockvar of read-only object variable + # + + # read-only lockvar from object method + var lines =<< trim END + mnv9script + + class C + var val1: number + def Lock() + lockvar this.val1 + enddef + endclass + var o = C.new(3) + o.Lock() + END + v9.CheckSourceFailure(lines, 'E1391: Cannot (un)lock variable "this.val1" in class "C"') + + # read-only lockvar from scriptlevel + lines =<< trim END + mnv9script + + class C + var val2: number + endclass + var o = C.new(3) + lockvar o.val2 + END + v9.CheckSourceFailure(lines, 'E1335: Variable "val2" in class "C" is not writable') + + # read-only lockvar of scriptlevel variable from def + lines =<< trim END + mnv9script + + class C + var val3: number + endclass + var o = C.new(3) + def Lock() + lockvar o.val3 + enddef + Lock() + END + v9.CheckSourceFailure(lines, 'E1335: Variable "val3" in class "C" is not writable') + + # read-only lockvar of def argument variable + lines =<< trim END + mnv9script + + class C + var val4: number + endclass + def Lock(o: C) + lockvar o.val4 + enddef + Lock(C.new(3)) + END + v9.CheckSourceFailure(lines, 'E1335: Variable "val4" in class "C" is not writable') + + # read-only lockvar from object method arg + lines =<< trim END + mnv9script + + class C + var val5: number + def Lock(c: C) + lockvar c.val5 + enddef + endclass + var o = C.new(3) + o.Lock(C.new(5)) + END + v9.CheckSourceFailure(lines, 'E1391: Cannot (un)lock variable "c.val5" in class "C"') + + # read-only lockvar from class method arg + lines =<< trim END + mnv9script + + class C + var val6: number + static def Lock(c: C) + lockvar c.val6 + enddef + endclass + var o = C.new(3) + C.Lock(o) + END + v9.CheckSourceFailure(lines, 'E1391: Cannot (un)lock variable "c.val6" in class "C"') + + # + # lockvar of public object variable + # + + # lockvar from object method + lines =<< trim END + mnv9script + + class C + public var val1: number + def Lock() + lockvar this.val1 + enddef + endclass + var o = C.new(3) + o.Lock() + END + v9.CheckSourceFailure(lines, 'E1391: Cannot (un)lock variable "this.val1" in class "C"', 1) + + # lockvar from scriptlevel + lines =<< trim END + mnv9script + + class C + public var val2: number + endclass + var o = C.new(3) + lockvar o.val2 + END + v9.CheckSourceFailure(lines, 'E1391: Cannot (un)lock variable "o.val2" in class "C"', 7) + + # lockvar of scriptlevel variable from def + lines =<< trim END + mnv9script + + class C + public var val3: number + endclass + var o = C.new(3) + def Lock() + lockvar o.val3 + enddef + Lock() + END + v9.CheckSourceFailure(lines, 'E1391: Cannot (un)lock variable "o.val3" in class "C"', 1) + + # lockvar of def argument variable + lines =<< trim END + mnv9script + + class C + public var val4: number + endclass + def Lock(o: C) + lockvar o.val4 + enddef + Lock(C.new(3)) + END + v9.CheckSourceFailure(lines, 'E1391: Cannot (un)lock variable "o.val4" in class "C"', 1) + + # lockvar from object method arg + lines =<< trim END + mnv9script + + class C + public var val5: number + def Lock(c: C) + lockvar c.val5 + enddef + endclass + var o = C.new(3) + o.Lock(C.new(5)) + END + v9.CheckSourceFailure(lines, 'E1391: Cannot (un)lock variable "c.val5" in class "C"', 1) + + # lockvar from class method arg + lines =<< trim END + mnv9script + + class C + public var val6: number + static def Lock(c: C) + lockvar c.val6 + enddef + endclass + var o = C.new(3) + C.Lock(o) + END + v9.CheckSourceFailure(lines, 'E1391: Cannot (un)lock variable "c.val6" in class "C"', 1) +enddef + +" Test trying to lock a class variable from various places +def Test_lockvar_class_variable() + + # lockvar bare static from object method + var lines =<< trim END + mnv9script + + class C + public static var sval1: number + def Lock() + lockvar sval1 + enddef + endclass + var o = C.new() + o.Lock() + END + v9.CheckSourceFailure(lines, 'E1392: Cannot (un)lock class variable "sval1" in class "C"', 1) + + # lockvar C.static from object method + lines =<< trim END + mnv9script + + class C + public static var sval2: number + def Lock() + lockvar C.sval2 + enddef + endclass + var o = C.new() + o.Lock() + END + v9.CheckSourceFailure(lines, 'E1392: Cannot (un)lock class variable "C.sval2" in class "C"', 1) + + # lockvar bare static from class method + lines =<< trim END + mnv9script + + class C + public static var sval3: number + static def Lock() + lockvar sval3 + enddef + endclass + C.Lock() + END + v9.CheckSourceFailure(lines, 'E1392: Cannot (un)lock class variable "sval3" in class "C"', 1) + + # lockvar C.static from class method + lines =<< trim END + mnv9script + + class C + public static var sval4: number + static def Lock() + lockvar C.sval4 + enddef + endclass + C.Lock() + END + v9.CheckSourceFailure(lines, 'E1392: Cannot (un)lock class variable "C.sval4" in class "C"', 1) + + # lockvar C.static from script level + lines =<< trim END + mnv9script + + class C + public static var sval5: number + endclass + lockvar C.sval5 + END + v9.CheckSourceFailure(lines, 'E1392: Cannot (un)lock class variable "C.sval5" in class "C"', 6) + + # lockvar o.static from script level + lines =<< trim END + mnv9script + + class C + public static var sval6: number + endclass + var o = C.new() + lockvar o.sval6 + END + v9.CheckSourceFailure(lines, 'E1375: Class variable "sval6" accessible only using class "C"', 7) +enddef + +" Test locking an argument to :def +def Test_lockvar_argument() + # Lockvar a function arg + var lines =<< trim END + mnv9script + + def Lock(val: any) + lockvar val + enddef + + var d = {a: 1, b: 2} + Lock(d) + + d->extend({c: 3}) + END + v9.CheckSourceFailure(lines, 'E741: Value is locked: extend() argument') + + # Lockvar a function arg. Verify "sval" is interpreted as argument and not a + # class member in "C". This tests lval_root_is_arg. + lines =<< trim END + mnv9script + + class C + public static var sval: list<number> + endclass + + def Lock2(sval: any) + lockvar sval + enddef + + var o = C.new() + Lock2(o) + END + v9.CheckSourceSuccess(lines) + + # Lock a class. + lines =<< trim END + mnv9script + + class C + public static var sval: list<number> + endclass + + def Lock2(sval: any) + lockvar sval + enddef + + Lock2(C) + END + v9.CheckSourceFailure(lines, 'E1405: Class "C" cannot be used as a value') + + # Lock an object. + lines =<< trim END + mnv9script + + class C + public static var sval: list<number> + endclass + + def Lock2(sval: any) + lockvar sval + enddef + + Lock2(C.new()) + END + v9.CheckSourceSuccess(lines) + + # In this case (unlike previous) "lockvar sval" is a class member. + lines =<< trim END + mnv9script + + class C + public static var sval: list<number> + def Lock2() + lockvar sval + enddef + endclass + + + var o = C.new() + o.Lock2() + END + v9.CheckSourceFailure(lines, 'E1392: Cannot (un)lock class variable "sval" in class "C"', 1) +enddef + +" Test that this can be locked without error +def Test_lockvar_this() + # lockvar this + var lines =<< trim END + mnv9script + class C + def TLock() + lockvar this + enddef + endclass + var o = C.new() + o.TLock() + END + v9.CheckSourceSuccess(lines) + + # lockvar four (four letter word, but not this) + lines =<< trim END + mnv9script + class C + def TLock4() + var four: number + lockvar four + enddef + endclass + var o = C.new() + o.TLock4() + END + v9.CheckSourceFailure(lines, 'E1178: Cannot lock or unlock a local variable') + + # lockvar this5; "this" + one char, 5 letter word, starting with "this" + lines =<< trim END + mnv9script + class C + def TLock5() + var this5: number + lockvar this5 + enddef + endclass + var o = C.new() + o.TLock5() + END + v9.CheckSourceFailure(lines, 'E1178: Cannot lock or unlock a local variable') +enddef + +" Test some general lockvar cases +def Test_lockvar_general() + # lockvar an object and a class. It does nothing + var lines =<< trim END + mnv9script + class C + endclass + var o = C.new() + lockvar o + lockvar C + END + v9.CheckSourceSuccess(lines) + + # Lock a list element that's nested in an object variable from a :def + lines =<< trim END + mnv9script + + class C + public var val: list<list<number>> = [ [1], [2], [3] ] + endclass + def Lock2(obj: any) + lockvar obj.val[1] + enddef + + var o = C.new() + Lock2(o) + o.val[0] = [9] + assert_equal([ [9], [2], [3] ], o.val) + try + o.val[1] = [999] + call assert_false(true, 'assign should have failed') + catch + assert_exception('E741:') + endtry + o.val[2] = [8] + assert_equal([ [9], [2], [8] ], o.val) + END + v9.CheckSourceSuccess(lines) + + # Lock a list element that's nested in an object variable from scriptlevel + lines =<< trim END + mnv9script + + class C + public var val: list<list<number>> = [ [1], [2], [3] ] + endclass + + var o = C.new() + lockvar o.val[1] + o.val[0] = [9] + assert_equal([ [9], [2], [3] ], o.val) + try + o.val[1] = [999] + call assert_false(true, 'assign should have failed') + catch + assert_exception('E741:') + endtry + o.val[2] = [8] + assert_equal([ [9], [2], [8] ], o.val) + END + v9.CheckSourceSuccess(lines) + + # lock a script level variable from an object method + lines =<< trim END + mnv9script + + class C + def Lock() + lockvar l + enddef + endclass + + var l = [1] + C.new().Lock() + l[0] = 11 + END + v9.CheckSourceFailure(lines, 'E741: Value is locked: l[0] = 11', 11) + + # lock a list element referenced by a protected object variable + # in an object fetched via a script level list + lines =<< trim END + mnv9script + + class C + var _v1: list<list<number>> + def Lock() + lockvar lc[0]._v1[1] + enddef + endclass + + var l = [[1], [2], [3]] + var o = C.new(l) + var lc: list<C> = [ o ] + + o.Lock() + l[0] = [22] + l[1] = [33] + END + v9.CheckSourceFailure(lines, 'E741: Value is locked: l[1] = [33]', 16) + + # similar to the previous test, except the locking code is executing + # in a class that does not own the protected variable. + # Note that the locking code is in a class has a protected variable of + # the same name. + lines =<< trim END + mnv9script + + class C2 + var _v1: list<list<number>> + def Lock(obj: any) + lockvar lc[0]._v1[1] + enddef + endclass + + class C + var _v1: list<list<number>> + endclass + + var l = [[1], [2], [3]] + var o = C.new(l) + var lc: list<C> = [ o ] + + var o2 = C2.new() + o2.Lock(o) + END + v9.CheckSourceFailure(lines, 'E1333: Cannot access protected variable "_v1" in class "C"') +enddef + +" Test builtin islocked() +def Test_lockvar_islocked() + # Can't lock class/object variable + # Lock class/object variable's value + # Lock item of variable's value (a list item) + # variable is at index 1 within class/object + var lines =<< trim END + mnv9script + + class C + var o0: list<list<number>> = [ [0], [1], [2]] + var o1: list<list<number>> = [[10], [11], [12]] + static var c0: list<list<number>> = [[20], [21], [22]] + static var c1: list<list<number>> = [[30], [31], [32]] + endclass + + def LockIt(arg: any) + lockvar arg + enddef + + def UnlockIt(arg: any) + unlockvar arg + enddef + + var obj = C.new() + #lockvar obj.o1 # can't lock something you can't write to + + try + lockvar obj.o1 # can't lock something you can't write to + call assert_false(1, '"lockvar obj.o1" should have failed') + catch + call assert_exception('E1335:') + endtry + + LockIt(obj.o1) # but can lock it's value + assert_equal(1, islocked("obj.o1")) + assert_equal(1, islocked("obj.o1[0]")) + assert_equal(1, islocked("obj.o1[1]")) + UnlockIt(obj.o1) + assert_equal(0, islocked("obj.o1")) + assert_equal(0, islocked("obj.o1[0]")) + + lockvar obj.o1[0] + assert_equal(0, islocked("obj.o1")) + assert_equal(1, islocked("obj.o1[0]")) + assert_equal(0, islocked("obj.o1[1]")) + unlockvar obj.o1[0] + assert_equal(0, islocked("obj.o1")) + assert_equal(0, islocked("obj.o1[0]")) + + # Same thing, but with a static + + try + lockvar C.c1 # can't lock something you can't write to + call assert_false(1, '"lockvar C.c1" should have failed') + catch + call assert_exception('E1335:') + endtry + + LockIt(C.c1) # but can lock it's value + assert_equal(1, islocked("C.c1")) + assert_equal(1, islocked("C.c1[0]")) + assert_equal(1, islocked("C.c1[1]")) + UnlockIt(C.c1) + assert_equal(0, islocked("C.c1")) + assert_equal(0, islocked("C.c1[0]")) + + lockvar C.c1[0] + assert_equal(0, islocked("C.c1")) + assert_equal(1, islocked("C.c1[0]")) + assert_equal(0, islocked("C.c1[1]")) + unlockvar C.c1[0] + assert_equal(0, islocked("C.c1")) + assert_equal(0, islocked("C.c1[0]")) + END + v9.CheckSourceSuccess(lines) + + # Do islocked() from an object method + # and then from a class method + lines =<< trim END + mnv9script + + var l0o0 = [ [0], [1], [2]] + var l0o1 = [ [10], [11], [12]] + var l0c0 = [[120], [121], [122]] + var l0c1 = [[130], [131], [132]] + + class C0 + var o0: list<list<number>> = l0o0 + var o1: list<list<number>> = l0o1 + static var c0: list<list<number>> = l0c0 + static var c1: list<list<number>> = l0c1 + def Islocked(arg: string): number + return islocked(arg) + enddef + static def SIslocked(arg: string): number + return islocked(arg) + enddef + endclass + + var l2o0 = [[20000], [20001], [20002]] + var l2o1 = [[20010], [20011], [20012]] + var l2c0 = [[20120], [20121], [20122]] + var l2c1 = [[20130], [20131], [20132]] + + class C2 + var o0: list<list<number>> = l2o0 + var o1: list<list<number>> = l2o1 + static var c0: list<list<number>> = l2c0 + static var c1: list<list<number>> = l2c1 + def Islocked(arg: string): number + return islocked(arg) + enddef + static def SIslocked(arg: string): number + return islocked(arg) + enddef + endclass + + var obj0 = C0.new() + var obj2 = C2.new() + + var l = [ obj0, null_object, obj2 ] + + # lock list, object func access through script var expr + assert_equal(0, obj0.Islocked("l[0].o0")) + assert_equal(0, obj0.Islocked("l[0].o0[2]")) + lockvar l0o0 + assert_equal(1, obj0.Islocked("l[0].o0")) + assert_equal(1, obj0.Islocked("l[0].o0[2]")) + + #echo "check-b" obj2.Islocked("l[1].o1") # NULL OBJECT + + # lock list element, object func access through script var expr + lockvar l0o1[1] + assert_equal(0, obj0.Islocked("this.o1[0]")) + assert_equal(1, obj0.Islocked("this.o1[1]")) + + assert_equal(0, obj0.Islocked("this.o1")) + lockvar l0o1 + assert_equal(1, obj0.Islocked("this.o1")) + unlockvar l0o1 + + lockvar l0c1[1] + + # static by class name member expr from same class + assert_equal(0, obj0.Islocked("C0.c1[0]")) + assert_equal(1, obj0.Islocked("C0.c1[1]")) + # static by bare name member expr from same class + assert_equal(0, obj0.Islocked("c1[0]")) + assert_equal(1, obj0.Islocked("c1[1]")) + + # static by class name member expr from other class + assert_equal(0, obj2.Islocked("C0.c1[0]")) + assert_equal(1, obj2.Islocked("C0.c1[1]")) + # static by bare name member expr from other class + assert_equal(0, obj2.Islocked("c1[0]")) + assert_equal(0, obj2.Islocked("c1[1]")) + + + # static by bare name in same class + assert_equal(0, obj0.Islocked("c0")) + lockvar l0c0 + assert_equal(1, obj0.Islocked("c0")) + + # + # similar stuff, but use static method + # + + unlockvar l0o0 + + # lock list, object func access through script var expr + assert_equal(0, C0.SIslocked("l[0].o0")) + assert_equal(0, C0.SIslocked("l[0].o0[2]")) + lockvar l0o0 + assert_equal(1, C0.SIslocked("l[0].o0")) + assert_equal(1, C0.SIslocked("l[0].o0[2]")) + + unlockvar l0o1 + + # can't access "this" from class method + try + C0.SIslocked("this.o1[0]") + call assert_0(1, '"C0.SIslocked("this.o1[0]")" should have failed') + catch + call assert_exception('E121: Undefined variable: this') + endtry + + lockvar l0c1[1] + + # static by class name member expr from same class + assert_equal(0, C0.SIslocked("C0.c1[0]")) + assert_equal(1, C0.SIslocked("C0.c1[1]")) + # static by bare name member expr from same class + assert_equal(0, C0.SIslocked("c1[0]")) + assert_equal(1, C0.SIslocked("c1[1]")) + + # static by class name member expr from other class + assert_equal(0, C2.SIslocked("C0.c1[0]")) + assert_equal(1, C2.SIslocked("C0.c1[1]")) + # static by bare name member expr from other class + assert_equal(0, C2.SIslocked("c1[0]")) + assert_equal(0, C2.SIslocked("c1[1]")) + + + # static by bare name in same class + unlockvar l0c0 + assert_equal(0, C0.SIslocked("c0")) + lockvar l0c0 + assert_equal(1, C0.SIslocked("c0")) + END + v9.CheckSourceSuccess(lines) + + # Check islocked class/object from various places. + lines =<< trim END + mnv9script + + class C + def Islocked(arg: string): number + return islocked(arg) + enddef + static def SIslocked(arg: string): number + return islocked(arg) + enddef + endclass + var obj = C.new() + + # object method + assert_equal(0, obj.Islocked("this")) + assert_equal(0, obj.Islocked("C")) + + # class method + ### assert_equal(0, C.SIslocked("this")) + assert_equal(0, C.SIslocked("C")) + + #script level + var v: number + v = islocked("C") + assert_equal(0, v) + v = islocked("obj") + assert_equal(0, v) + END + v9.CheckSourceSuccess(lines) +enddef + +def Test_lockvar_islocked_notfound() + # Try non-existent things + var lines =<< trim END + mnv9script + + class C + def Islocked(arg: string): number + return islocked(arg) + enddef + static def SIslocked(arg: string): number + return islocked(arg) + enddef + endclass + var obj = C.new() + assert_equal(-1, obj.Islocked("anywhere")) + assert_equal(-1, C.SIslocked("notanywhere")) + END + v9.CheckSourceSuccess(lines) + + # Something not found of the form "name1.name2" is an error + lines =<< trim END + mnv9script + + islocked("one.two") + END + v9.CheckSourceFailure(lines, 'E121: Undefined variable: one') + + lines =<< trim END + mnv9script + + class C + var val = { key: "value" } + def Islocked(arg: string): number + return islocked(arg) + enddef + endclass + var obj = C.new() + obj.Islocked("this.val.not_there")) + END + v9.CheckSourceFailure(lines, 'E716: Key not present in Dictionary: "not_there"') + + lines =<< trim END + mnv9script + + class C + def Islocked(arg: string): number + return islocked(arg) + enddef + endclass + var obj = C.new() + obj.Islocked("this.notobjmember") + END + v9.CheckSourceFailure(lines, 'E1326: Variable "notobjmember" not found in object "C"') + + # access a script variable through methods + lines =<< trim END + mnv9script + + var l = [1] + class C + def Islocked(arg: string): number + return islocked(arg) + enddef + static def SIslocked(arg: string): number + return islocked(arg) + enddef + endclass + var obj = C.new() + assert_equal(0, obj.Islocked("l")) + assert_equal(0, C.SIslocked("l")) + lockvar l + assert_equal(1, obj.Islocked("l")) + assert_equal(1, C.SIslocked("l")) + END + v9.CheckSourceSuccess(lines) +enddef + +" Test for a protected object method +def Test_protected_object_method() + # Try calling a protected method using an object (at the script level) + var lines =<< trim END + mnv9script + + class A + def _Foo(): number + return 1234 + enddef + endclass + var a = A.new() + a._Foo() + END + v9.CheckSourceFailure(lines, 'E1366: Cannot access protected method: _Foo', 9) + + # Try calling a protected method using an object (from a def function) + lines =<< trim END + mnv9script + + class A + def _Foo(): number + return 1234 + enddef + endclass + def T() + var a = A.new() + a._Foo() + enddef + T() + END + v9.CheckSourceFailure(lines, 'E1366: Cannot access protected method: _Foo()', 2) + + # Use a protected method from another object method (in script context) + lines =<< trim END + mnv9script + + class A + def _Foo(): number + return 1234 + enddef + def Bar(): number + return this._Foo() + enddef + endclass + var a = A.new() + assert_equal(1234, a.Bar()) + END + v9.CheckSourceSuccess(lines) + + # Use a protected method from another object method (def function context) + lines =<< trim END + mnv9script + + class A + def _Foo(): number + return 1234 + enddef + def Bar(): number + return this._Foo() + enddef + endclass + def T() + var a = A.new() + assert_equal(1234, a.Bar()) + enddef + T() + END + v9.CheckSourceSuccess(lines) + + # Try calling a protected method without the "this" prefix + lines =<< trim END + mnv9script + + class A + def _Foo(): number + return 1234 + enddef + def Bar(): number + return _Foo() + enddef + endclass + var a = A.new() + a.Bar() + END + v9.CheckSourceFailure(lines, 'E117: Unknown function: _Foo', 1) + + # Try calling a protected method using the class name + lines =<< trim END + mnv9script + + class A + def _Foo(): number + return 1234 + enddef + endclass + A._Foo() + END + v9.CheckSourceFailure(lines, 'E1366: Cannot access protected method: _Foo', 8) + + # Define two protected methods with the same name + lines =<< trim END + mnv9script + + class A + def _Foo() + enddef + def _Foo() + enddef + endclass + var a = A.new() + END + v9.CheckSourceFailure(lines, 'E1355: Duplicate function: _Foo', 7) + + # Define a protected method and a object method with the same name + lines =<< trim END + mnv9script + + class A + def _Foo() + enddef + def Foo() + enddef + endclass + var a = A.new() + END + v9.CheckSourceFailure(lines, 'E1355: Duplicate function: Foo', 7) + + # Define an object method and a protected method with the same name + lines =<< trim END + mnv9script + + class A + def Foo() + enddef + def _Foo() + enddef + endclass + var a = A.new() + END + v9.CheckSourceFailure(lines, 'E1355: Duplicate function: _Foo', 7) + + # Call a public method and a protected method from a protected method + lines =<< trim END + mnv9script + + class A + def Foo(): number + return 100 + enddef + def _Bar(): number + return 200 + enddef + def _Baz() + assert_equal(100, this.Foo()) + assert_equal(200, this._Bar()) + enddef + def T() + this._Baz() + enddef + endclass + var a = A.new() + a.T() + END + v9.CheckSourceSuccess(lines) + + # Try calling a protected method from another class + lines =<< trim END + mnv9script + + class A + def _Foo(): number + return 100 + enddef + endclass + class B + def Foo(): number + var a = A.new() + a._Foo() + enddef + endclass + var b = B.new() + b.Foo() + END + v9.CheckSourceFailure(lines, 'E1366: Cannot access protected method: _Foo()', 2) + + # Call a protected object method from a child class object method + lines =<< trim END + mnv9script + class A + def _Foo(): number + return 1234 + enddef + endclass + class B extends A + def Bar() + enddef + endclass + class C extends B + def Baz(): number + return this._Foo() + enddef + endclass + var c = C.new() + assert_equal(1234, c.Baz()) + END + v9.CheckSourceSuccess(lines) + + # Call a protected object method from a child class object + lines =<< trim END + mnv9script + class A + def _Foo(): number + return 1234 + enddef + endclass + class B extends A + def Bar() + enddef + endclass + class C extends B + def Baz(): number + enddef + endclass + var c = C.new() + assert_equal(1234, c._Foo()) + END + v9.CheckSourceFailure(lines, 'E1366: Cannot access protected method: _Foo', 16) + + # Using "_" prefix in a method name should fail outside of a class + lines =<< trim END + mnv9script + def _Foo(): number + return 1234 + enddef + var a = _Foo() + END + v9.CheckSourceFailure(lines, 'E1267: Function name must start with a capital: _Foo(): number', 2) + + # Test for initializing a protected funcref instance variable to a protected + # class method from another class + lines =<< trim END + mnv9script + + class A + static def _Internal(): string + enddef + endclass + + class B + var Fn: func = A._Internal + endclass + var b = B.new() + END + v9.CheckSourceFailure(lines, 'E1366: Cannot access protected method: _Internal', 1) +enddef + +" Test for an protected class method +def Test_protected_class_method() + # Try calling a class protected method (at the script level) + var lines =<< trim END + mnv9script + + class A + static def _Foo(): number + return 1234 + enddef + endclass + A._Foo() + END + v9.CheckSourceFailure(lines, 'E1366: Cannot access protected method: _Foo', 8) + + # Try calling a class protected method (from a def function) + lines =<< trim END + mnv9script + + class A + static def _Foo(): number + return 1234 + enddef + endclass + def T() + A._Foo() + enddef + T() + END + v9.CheckSourceFailure(lines, 'E1366: Cannot access protected method: _Foo()', 1) + + # Try calling a class protected method using an object (at the script level) + lines =<< trim END + mnv9script + + class A + static def _Foo(): number + return 1234 + enddef + endclass + var a = A.new() + a._Foo() + END + v9.CheckSourceFailure(lines, 'E1366: Cannot access protected method: _Foo', 9) + + # Try calling a class protected method using an object (from a def function) + lines =<< trim END + mnv9script + + class A + static def _Foo(): number + return 1234 + enddef + endclass + def T() + var a = A.new() + a._Foo() + enddef + T() + END + v9.CheckSourceFailure(lines, 'E1366: Cannot access protected method: _Foo', 2) + + # Use a class protected method from an object method + lines =<< trim END + mnv9script + + class A + static def _Foo(): number + return 1234 + enddef + def Bar() + assert_equal(1234, _Foo()) + enddef + endclass + var a = A.new() + a.Bar() + END + v9.CheckSourceSuccess(lines) + + # Use a class protected method from another class protected method without the + # class name prefix. + lines =<< trim END + mnv9script + + class A + static def _Foo1(): number + return 1234 + enddef + static def _Foo2() + assert_equal(1234, _Foo1()) + enddef + def Bar() + _Foo2() + enddef + endclass + var a = A.new() + a.Bar() + END + v9.CheckSourceSuccess(lines) + + # Declare a class method and a class protected method with the same name + lines =<< trim END + mnv9script + + class A + static def _Foo() + enddef + static def Foo() + enddef + endclass + var a = A.new() + END + v9.CheckSourceFailure(lines, 'E1355: Duplicate function: Foo', 7) + + # Try calling a class protected method from another class + lines =<< trim END + mnv9script + + class A + static def _Foo(): number + return 1234 + enddef + endclass + class B + def Foo(): number + return A._Foo() + enddef + endclass + var b = B.new() + assert_equal(1234, b.Foo()) + END + v9.CheckSourceFailure(lines, 'E1366: Cannot access protected method: _Foo()', 1) + + # Call a protected class method from a child class object method + lines =<< trim END + mnv9script + class A + static def _Foo(): number + return 1234 + enddef + endclass + class B extends A + def Bar() + enddef + endclass + class C extends B + def Baz(): number + return A._Foo() + enddef + endclass + var c = C.new() + assert_equal(1234, c.Baz()) + END + v9.CheckSourceFailure(lines, 'E1366: Cannot access protected method: _Foo()', 1) + + # Call a protected class method from a child class protected class method + lines =<< trim END + mnv9script + class A + static def _Foo(): number + return 1234 + enddef + endclass + class B extends A + def Bar() + enddef + endclass + class C extends B + static def Baz(): number + return A._Foo() + enddef + endclass + assert_equal(1234, C.Baz()) + END + v9.CheckSourceFailure(lines, 'E1366: Cannot access protected method: _Foo()', 1) + + # Call a protected class method from a child class object + lines =<< trim END + mnv9script + class A + static def _Foo(): number + return 1234 + enddef + endclass + class B extends A + def Bar() + enddef + endclass + class C extends B + def Baz(): number + enddef + endclass + var c = C.new() + assert_equal(1234, C._Foo()) + END + v9.CheckSourceFailure(lines, 'E1325: Method "_Foo" not found in class "C"', 16) + + # Test for initializing a protected funcref class variable to a protected + # class method from another class + lines =<< trim END + mnv9script + + class A + static def _Internal(): string + enddef + endclass + + class B + static var Fn: func = A._Internal + endclass + END + v9.CheckSourceFailure(lines, 'E1366: Cannot access protected method: _Internal', 10) +enddef + +" Test for using the return value of a class/object method as a function +" argument. +def Test_objmethod_funcarg() + var lines =<< trim END + mnv9script + + class C + def Foo(): string + return 'foo' + enddef + endclass + + def Bar(a: number, s: string): string + return s + enddef + + def Baz(c: C) + assert_equal('foo', Bar(10, c.Foo())) + enddef + + var t = C.new() + Baz(t) + END + v9.CheckSourceSuccess(lines) + + lines =<< trim END + mnv9script + + class C + static def Foo(): string + return 'foo' + enddef + endclass + + def Bar(a: number, s: string): string + return s + enddef + + def Baz() + assert_equal('foo', Bar(10, C.Foo())) + enddef + + Baz() + END + v9.CheckSourceSuccess(lines) +enddef + +def Test_static_inheritence() + # subclasses get their own static copy + var lines =<< trim END + mnv9script + + class A + static var _svar: number + var _mvar: number + def new() + _svar = 1 + this._mvar = 101 + enddef + def AccessObject(): number + return this._mvar + enddef + def AccessStaticThroughObject(): number + return _svar + enddef + endclass + + class B extends A + def new() + this._mvar = 102 + enddef + endclass + + class C extends B + def new() + this._mvar = 103 + enddef + + def AccessPrivateStaticThroughClassName(): number + assert_equal(1, A._svar) + return 444 + enddef + endclass + + var oa = A.new() + var ob = B.new() + var oc = C.new() + assert_equal(101, oa.AccessObject()) + assert_equal(102, ob.AccessObject()) + assert_equal(103, oc.AccessObject()) + + assert_fails('echo oc.AccessPrivateStaticThroughClassName()', 'E1333: Cannot access protected variable "_svar" in class "A"') + + # verify object properly resolves to correct static + assert_equal(1, oa.AccessStaticThroughObject()) + assert_equal(1, ob.AccessStaticThroughObject()) + assert_equal(1, oc.AccessStaticThroughObject()) + END + v9.CheckSourceSuccess(lines) +enddef + +" Test for declaring duplicate object and class members +def Test_dup_member_variable() + # Duplicate member variable + var lines =<< trim END + mnv9script + class C + var val = 10 + var val = 20 + endclass + END + v9.CheckSourceFailure(lines, 'E1369: Duplicate variable: val', 4) + + # Duplicate protected member variable + lines =<< trim END + mnv9script + class C + var _val = 10 + var _val = 20 + endclass + END + v9.CheckSourceFailure(lines, 'E1369: Duplicate variable: _val', 4) + + # Duplicate public member variable + lines =<< trim END + mnv9script + class C + public var val = 10 + public var val = 20 + endclass + END + v9.CheckSourceFailure(lines, 'E1369: Duplicate variable: val', 4) + + # Duplicate protected member variable + lines =<< trim END + mnv9script + class C + var val = 10 + var _val = 20 + endclass + END + v9.CheckSourceFailure(lines, 'E1369: Duplicate variable: _val', 4) + + # Duplicate public and protected member variable + lines =<< trim END + mnv9script + class C + var _val = 20 + public var val = 10 + endclass + END + v9.CheckSourceFailure(lines, 'E1369: Duplicate variable: val', 4) + + # Duplicate class member variable + lines =<< trim END + mnv9script + class C + static var s: string = "abc" + static var _s: string = "def" + endclass + END + v9.CheckSourceFailure(lines, 'E1369: Duplicate variable: _s', 4) + + # Duplicate public and protected class member variable + lines =<< trim END + mnv9script + class C + public static var s: string = "abc" + static var _s: string = "def" + endclass + END + v9.CheckSourceFailure(lines, 'E1369: Duplicate variable: _s', 4) + + # Duplicate class and object member variable + lines =<< trim END + mnv9script + class C + static var val = 10 + var val = 20 + def new() + enddef + endclass + var c = C.new() + assert_equal(10, C.val) + assert_equal(20, c.val) + END + v9.CheckSourceFailure(lines, 'E1369: Duplicate variable: val', 4) + + # Duplicate object member variable in a derived class + lines =<< trim END + mnv9script + class A + var val = 10 + endclass + class B extends A + endclass + class C extends B + var val = 20 + endclass + END + v9.CheckSourceFailure(lines, 'E1369: Duplicate variable: val', 9) + + # Duplicate object protected member variable in a derived class + lines =<< trim END + mnv9script + class A + var _val = 10 + endclass + class B extends A + endclass + class C extends B + var _val = 20 + endclass + END + v9.CheckSourceFailure(lines, 'E1369: Duplicate variable: _val', 9) + + # Duplicate object protected member variable in a derived class + lines =<< trim END + mnv9script + class A + var val = 10 + endclass + class B extends A + endclass + class C extends B + var _val = 20 + endclass + END + v9.CheckSourceFailure(lines, 'E1369: Duplicate variable: _val', 9) + + # Duplicate object member variable in a derived class + lines =<< trim END + mnv9script + class A + var _val = 10 + endclass + class B extends A + endclass + class C extends B + var val = 20 + endclass + END + v9.CheckSourceFailure(lines, 'E1369: Duplicate variable: val', 9) + + # Two member variables with a common prefix + lines =<< trim END + mnv9script + class A + public static var svar2: number + public static var svar: number + endclass + END + v9.CheckSourceSuccess(lines) +enddef + +" Test for accessing a protected member outside a class in a def function +def Test_protected_member_access_outside_class() + # try to modify a protected instance variable from a def function + var lines =<< trim END + mnv9script + class A + var _val = 10 + endclass + def T() + var a = A.new() + a._val = 20 + enddef + T() + END + v9.CheckSourceFailure(lines, 'E1333: Cannot access protected variable "_val" in class "A"', 2) + + # access a non-existing protected instance variable from a def function + lines =<< trim END + mnv9script + class A + var _val = 10 + endclass + def T() + var a = A.new() + a._a = 1 + enddef + T() + END + v9.CheckSourceFailure(lines, 'E1326: Variable "_a" not found in object "A"', 2) + + # try to read a protected class variable from a def function using an instance + lines =<< trim END + mnv9script + class A + static var _val = 10 + endclass + def T() + var a = A.new() + var x = a._val + enddef + T() + END + v9.CheckSourceFailure(lines, 'E1375: Class variable "_val" accessible only using class "A"', 2) + + # try to modify a protected class variable from a def function using an + # instance + lines =<< trim END + mnv9script + class A + static var _val = 10 + endclass + def T() + var a = A.new() + a._val = 3 + enddef + T() + END + v9.CheckSourceFailure(lines, 'E1375: Class variable "_val" accessible only using class "A"', 2) + + # try to read a protected class variable from a def function using the class + lines =<< trim END + mnv9script + class A + static var _val = 10 + endclass + def T() + var x = A._val + enddef + T() + END + v9.CheckSourceFailure(lines, 'E1333: Cannot access protected variable "_val" in class "A"', 1) + + # try to modify a protected class variable from a def function using the class + lines =<< trim END + mnv9script + class A + static var _val = 10 + endclass + def T() + A._val = 3 + enddef + T() + END + v9.CheckSourceFailure(lines, 'E1333: Cannot access protected variable "_val" in class "A"', 1) + + # initialize a protected class variable using a protected class variable + # from another class + lines =<< trim END + mnv9script + class A + static var _aval = 10 + endclass + class B + static var _bval = A._aval + endclass + END + v9.CheckSourceFailure(lines, 'E1333: Cannot access protected variable "_aval" in class "A"', 7) + + # initialize a protected instance variable using a protected class variable + # from another class + lines =<< trim END + mnv9script + class A + static var _aval = 10 + endclass + class B + var _bval = A._aval + endclass + var b = B.new() + END + v9.CheckSourceFailure(lines, 'E1333: Cannot access protected variable "_aval" in class "A"', 1) +enddef + +" Test for trying to change a readonly member from a def function +def Test_readonly_member_change_in_def_func() + var lines =<< trim END + mnv9script + class A + var val: number + endclass + def T() + var a = A.new() + a.val = 20 + enddef + T() + END + v9.CheckSourceFailure(lines, 'E1335: Variable "val" in class "A" is not writable', 2) +enddef + +" Test for reading and writing a class member from a def function +def Test_modify_class_member_from_def_function() + var lines =<< trim END + mnv9script + class A + var var1: number = 10 + public static var var2: list<number> = [1, 2] + public static var var3: dict<number> = {a: 1, b: 2} + static var _priv_var4: number = 40 + endclass + def T() + assert_equal([1, 2], A.var2) + assert_equal({a: 1, b: 2}, A.var3) + A.var2 = [3, 4] + A.var3 = {c: 3, d: 4} + assert_equal([3, 4], A.var2) + assert_equal({c: 3, d: 4}, A.var3) + assert_fails('echo A._priv_var4', 'E1333: Cannot access protected variable "_priv_var4" in class "A"') + enddef + T() + END + v9.CheckSourceSuccess(lines) +enddef + +" Test for accessing a class member variable using an object +def Test_class_variable_access_using_object() + var lines =<< trim END + mnv9script + class A + public static var svar1: list<number> = [1] + public static var svar2: list<number> = [2] + endclass + + A.svar1->add(3) + A.svar2->add(4) + assert_equal([1, 3], A.svar1) + assert_equal([2, 4], A.svar2) + + def Foo() + A.svar1->add(7) + A.svar2->add(8) + assert_equal([1, 3, 7], A.svar1) + assert_equal([2, 4, 8], A.svar2) + enddef + Foo() + END + v9.CheckSourceSuccess(lines) + + # Cannot read from a class variable using an object in script context + lines =<< trim END + mnv9script + class A + public var var1: number + public static var svar2: list<number> = [1] + endclass + + var a = A.new() + echo a.svar2 + END + v9.CheckSourceFailure(lines, 'E1375: Class variable "svar2" accessible only using class "A"', 8) + + # Cannot write to a class variable using an object in script context + lines =<< trim END + mnv9script + class A + public var var1: number + public static var svar2: list<number> = [1] + endclass + + var a = A.new() + a.svar2 = [2] + END + v9.CheckSourceFailure(lines, 'E1375: Class variable "svar2" accessible only using class "A"', 8) + + # Cannot read from a class variable using an object in def method context + lines =<< trim END + mnv9script + class A + public var var1: number + public static var svar2: list<number> = [1] + endclass + + def T() + var a = A.new() + echo a.svar2 + enddef + T() + END + v9.CheckSourceFailure(lines, 'E1375: Class variable "svar2" accessible only using class "A"', 2) + + # Cannot write to a class variable using an object in def method context + lines =<< trim END + mnv9script + class A + public var var1: number + public static var svar2: list<number> = [1] + endclass + + def T() + var a = A.new() + a.svar2 = [2] + enddef + T() + END + v9.CheckSourceFailure(lines, 'E1375: Class variable "svar2" accessible only using class "A"', 2) +enddef + +" Test for abstract methods +def Test_abstract_method() + # Use two abstract methods + var lines =<< trim END + mnv9script + abstract class A + def M1(): number + return 10 + enddef + abstract def M2(): number + abstract def M3(): number + endclass + class B extends A + def M2(): number + return 20 + enddef + def M3(): number + return 30 + enddef + endclass + var b = B.new() + assert_equal([10, 20, 30], [b.M1(), b.M2(), b.M3()]) + END + v9.CheckSourceSuccess(lines) + + # Don't define an abstract method + lines =<< trim END + mnv9script + abstract class A + abstract def Foo() + endclass + class B extends A + endclass + END + v9.CheckSourceFailure(lines, 'E1373: Abstract method "Foo" is not implemented', 6) + + # Use abstract method in a concrete class + lines =<< trim END + mnv9script + class A + abstract def Foo() + endclass + class B extends A + endclass + END + v9.CheckSourceFailure(lines, 'E1372: Abstract method "abstract def Foo()" cannot be defined in a concrete class', 3) + + # Use abstract method in an interface + lines =<< trim END + mnv9script + interface A + abstract def Foo() + endinterface + class B implements A + def Foo() + enddef + endclass + END + v9.CheckSourceFailure(lines, 'E1404: Abstract cannot be used in an interface', 3) + + # Use abstract static method in an interface + lines =<< trim END + mnv9script + interface A + abstract static def Foo() + enddef + endinterface + END + v9.CheckSourceFailure(lines, 'E1404: Abstract cannot be used in an interface', 3) + + # Use abstract static variable in an interface + lines =<< trim END + mnv9script + interface A + abstract static foo: number = 10 + endinterface + END + v9.CheckSourceFailure(lines, 'E1404: Abstract cannot be used in an interface', 3) + + # Abbreviate the "abstract" keyword + lines =<< trim END + mnv9script + class A + abs def Foo() + endclass + END + v9.CheckSourceFailure(lines, 'E1065: Command cannot be shortened: abs def Foo()', 3) + + # Use "abstract" with a member variable + lines =<< trim END + mnv9script + abstract class A + abstract this.val = 10 + endclass + END + v9.CheckSourceFailure(lines, 'E1371: Abstract must be followed by "def"', 3) + + # Use a static abstract method + lines =<< trim END + mnv9script + abstract class A + abstract static def Foo(): number + endclass + END + v9.CheckSourceFailure(lines, 'E1371: Abstract must be followed by "def"', 3) + + # Type mismatch between abstract method and concrete method + lines =<< trim END + mnv9script + abstract class A + abstract def Foo(a: string, b: number): list<number> + endclass + class B extends A + def Foo(a: number, b: string): list<string> + return [] + enddef + endclass + END + v9.CheckSourceFailure(lines, 'E1383: Method "Foo": type mismatch, expected func(string, number): list<number> but got func(number, string): list<string>', 9) + + # Invoke an abstract method from a def function + lines =<< trim END + mnv9script + abstract class A + abstract def Foo(): list<number> + endclass + class B extends A + def Foo(): list<number> + return [3, 5] + enddef + endclass + def Bar(c: B) + assert_equal([3, 5], c.Foo()) + enddef + var b = B.new() + Bar(b) + END + v9.CheckSourceSuccess(lines) + + # Use a static method in an abstract class + lines =<< trim END + mnv9script + abstract class A + static def Foo(): string + return 'foo' + enddef + endclass + assert_equal('foo', A.Foo()) + END + v9.CheckSourceSuccess(lines) + + # Invoke method returning a value through the abstract class. See #15432. + lines =<< trim END + mnv9script + + abstract class A + abstract def String(): string + endclass + + class B extends A + def String(): string + return 'B' + enddef + endclass + + def F(o: A) + assert_equal('B', o.String()) + enddef + F(B.new()) + END + v9.CheckSourceSuccess(lines) + + # Invoke abstract method returning a value does not compile + lines =<< trim END + mnv9script + + abstract class A + abstract def String(): string + return 'X' + enddef + endclass + END + v9.CheckScriptFailure(lines, "E1318: Not a valid command in a class: return 'X'") +enddef + +" Test for calling a class method from a subclass +def Test_class_method_call_from_subclass() + # class method call from a subclass + var lines =<< trim END + mnv9script + + class A + static def Foo() + echo "foo" + enddef + endclass + + class B extends A + def Bar() + Foo() + enddef + endclass + + var b = B.new() + b.Bar() + END + v9.CheckSourceFailure(lines, 'E1384: Class method "Foo" accessible only inside class "A"', 1) +enddef + +" Test for calling a class method using an object in a def function context and +" script context. +def Test_class_method_call_using_object() + # script context + var lines =<< trim END + mnv9script + class A + static def Foo(): list<string> + return ['a', 'b'] + enddef + def Bar() + assert_equal(['a', 'b'], A.Foo()) + assert_equal(['a', 'b'], Foo()) + enddef + endclass + + def T() + assert_equal(['a', 'b'], A.Foo()) + var t_a = A.new() + t_a.Bar() + enddef + + assert_equal(['a', 'b'], A.Foo()) + var a = A.new() + a.Bar() + T() + END + v9.CheckSourceSuccess(lines) + + # script context + lines =<< trim END + mnv9script + class A + static def Foo(): string + return 'foo' + enddef + endclass + + var a = A.new() + assert_equal('foo', a.Foo()) + END + v9.CheckSourceFailure(lines, 'E1385: Class method "Foo" accessible only using class "A"', 9) + + # def function context + lines =<< trim END + mnv9script + class A + static def Foo(): string + return 'foo' + enddef + endclass + + def T() + var a = A.new() + assert_equal('foo', a.Foo()) + enddef + T() + END + v9.CheckSourceFailure(lines, 'E1385: Class method "Foo" accessible only using class "A"', 2) +enddef + +def Test_class_variable() + var lines =<< trim END + mnv9script + + class A + public static var val: number = 10 + static def ClassFunc() + assert_equal(10, val) + enddef + def ObjFunc() + assert_equal(10, val) + enddef + endclass + + class B extends A + endclass + + assert_equal(10, A.val) + A.ClassFunc() + var a = A.new() + a.ObjFunc() + var b = B.new() + b.ObjFunc() + + def T1(a1: A) + a1.ObjFunc() + A.ClassFunc() + enddef + T1(b) + + A.val = 20 + assert_equal(20, A.val) + END + v9.CheckSourceSuccess(lines) + + # Modifying a parent class variable from a child class method + lines =<< trim END + mnv9script + + class A + static var val: number = 10 + endclass + + class B extends A + static def ClassFunc() + val = 20 + enddef + endclass + B.ClassFunc() + END + v9.CheckSourceFailure(lines, 'E1374: Class variable "val" accessible only inside class "A"', 1) + + # Reading a parent class variable from a child class method + lines =<< trim END + mnv9script + + class A + static var val: number = 10 + endclass + + class B extends A + static def ClassFunc() + var i = val + enddef + endclass + B.ClassFunc() + END + v9.CheckSourceFailure(lines, 'E1374: Class variable "val" accessible only inside class "A"', 1) + + # Modifying a parent class variable from a child object method + lines =<< trim END + mnv9script + + class A + static var val: number = 10 + endclass + + class B extends A + def ObjFunc() + val = 20 + enddef + endclass + var b = B.new() + b.ObjFunc() + END + v9.CheckSourceFailure(lines, 'E1374: Class variable "val" accessible only inside class "A"', 1) + + # Reading a parent class variable from a child object method + lines =<< trim END + mnv9script + + class A + static var val: number = 10 + endclass + + class B extends A + def ObjFunc() + var i = val + enddef + endclass + var b = B.new() + b.ObjFunc() + END + v9.CheckSourceFailure(lines, 'E1374: Class variable "val" accessible only inside class "A"', 1) + + # Modifying a class variable using an object at script level + lines =<< trim END + mnv9script + + class A + static var val: number = 10 + endclass + var a = A.new() + a.val = 20 + END + v9.CheckSourceFailure(lines, 'E1375: Class variable "val" accessible only using class "A"', 7) + + # Reading a class variable using an object at script level + lines =<< trim END + mnv9script + + class A + static var val: number = 10 + endclass + var a = A.new() + var i = a.val + END + v9.CheckSourceFailure(lines, 'E1375: Class variable "val" accessible only using class "A"', 7) + + # Modifying a class variable using an object at function level + lines =<< trim END + mnv9script + + class A + static var val: number = 10 + endclass + + def T() + var a = A.new() + a.val = 20 + enddef + T() + END + v9.CheckSourceFailure(lines, 'E1375: Class variable "val" accessible only using class "A"', 2) + + # Reading a class variable using an object at function level + lines =<< trim END + mnv9script + + class A + static var val: number = 10 + endclass + def T() + var a = A.new() + var i = a.val + enddef + T() + END + v9.CheckSourceFailure(lines, 'E1375: Class variable "val" accessible only using class "A"', 2) + + # Use old implicit var declaration syntax (without initialization) + lines =<< trim END + mnv9script + + class A + static val: number + endclass + END + v9.CheckSourceFailure(lines, 'E1368: Static must be followed by "var" or "def"', 4) + + # Use old implicit var declaration syntax (with initialization) + lines =<< trim END + mnv9script + + class A + static val: number = 10 + endclass + END + v9.CheckSourceFailure(lines, 'E1368: Static must be followed by "var" or "def"', 4) + + # Use old implicit var declaration syntax (type inferred) + lines =<< trim END + mnv9script + + class A + static val = 10 + endclass + END + v9.CheckSourceFailure(lines, 'E1368: Static must be followed by "var" or "def"', 4) + + # Missing ":var" in "var" class variable declaration (without initialization) + lines =<< trim END + mnv9script + + class A + static var: number + endclass + END + v9.CheckSourceFailure(lines, 'E1329: Invalid class variable declaration: static var: number', 4) + + # Missing ":var" in "var" class variable declaration (with initialization) + lines =<< trim END + mnv9script + + class A + static var: number = 10 + endclass + END + v9.CheckSourceFailure(lines, 'E1329: Invalid class variable declaration: static var: number = 10', 4) + + # Missing ":var" in "var" class variable declaration (type inferred) + lines =<< trim END + mnv9script + + class A + static var = 10 + endclass + END + v9.CheckSourceFailure(lines, 'E1329: Invalid class variable declaration: static var = 10', 4) + +enddef + +" Test for using a duplicate class method and class variable in a child class +def Test_dup_class_member() + # duplicate class variable, class method and overridden object method + var lines =<< trim END + mnv9script + class A + static var sval = 100 + static def Check() + assert_equal(100, sval) + enddef + def GetVal(): number + return sval + enddef + endclass + + class B extends A + static var sval = 200 + static def Check() + assert_equal(200, sval) + enddef + def GetVal(): number + return sval + enddef + endclass + + def T1(aa: A): number + return aa.GetVal() + enddef + + def T2(bb: B): number + return bb.GetVal() + enddef + + assert_equal(100, A.sval) + assert_equal(200, B.sval) + var a = A.new() + assert_equal(100, a.GetVal()) + var b = B.new() + assert_equal(200, b.GetVal()) + assert_equal(200, T1(b)) + assert_equal(200, T2(b)) + END + v9.CheckSourceSuccess(lines) + + # duplicate class variable and class method + lines =<< trim END + mnv9script + class A + static var sval = 100 + static def Check() + assert_equal(100, sval) + enddef + def GetVal(): number + return sval + enddef + endclass + + class B extends A + static var sval = 200 + static def Check() + assert_equal(200, sval) + enddef + endclass + + def T1(aa: A): number + return aa.GetVal() + enddef + + def T2(bb: B): number + return bb.GetVal() + enddef + + assert_equal(100, A.sval) + assert_equal(200, B.sval) + var a = A.new() + assert_equal(100, a.GetVal()) + var b = B.new() + assert_equal(100, b.GetVal()) + assert_equal(100, T1(b)) + assert_equal(100, T2(b)) + END + v9.CheckSourceSuccess(lines) +enddef + +" Test for calling an instance method using the class +def Test_instance_method_call_using_class() + # Invoke an object method using a class in script context + var lines =<< trim END + mnv9script + class A + def Foo() + echo "foo" + enddef + endclass + A.Foo() + END + v9.CheckSourceFailure(lines, 'E1386: Object method "Foo" accessible only using class "A" object', 7) + + # Invoke an object method using a class in def function context + lines =<< trim END + mnv9script + class A + def Foo() + echo "foo" + enddef + endclass + def T() + A.Foo() + enddef + T() + END + v9.CheckSourceFailure(lines, 'E1386: Object method "Foo" accessible only using class "A" object', 1) +enddef + +" Test for duplicate class method and instance method +def Test_dup_classmethod_objmethod() + # Duplicate instance method + var lines =<< trim END + mnv9script + class A + static def Foo() + enddef + def Foo() + enddef + endclass + END + v9.CheckSourceFailure(lines, 'E1355: Duplicate function: Foo', 6) + + # Duplicate protected instance method + lines =<< trim END + mnv9script + class A + static def Foo() + enddef + def _Foo() + enddef + endclass + END + v9.CheckSourceFailure(lines, 'E1355: Duplicate function: _Foo', 6) + + # Duplicate class method + lines =<< trim END + mnv9script + class A + def Foo() + enddef + static def Foo() + enddef + endclass + END + v9.CheckSourceFailure(lines, 'E1355: Duplicate function: Foo', 6) + + # Duplicate protected class method + lines =<< trim END + mnv9script + class A + def Foo() + enddef + static def _Foo() + enddef + endclass + END + v9.CheckSourceFailure(lines, 'E1355: Duplicate function: _Foo', 6) + + # Duplicate protected class and object method + lines =<< trim END + mnv9script + class A + def _Foo() + enddef + static def _Foo() + enddef + endclass + END + v9.CheckSourceFailure(lines, 'E1355: Duplicate function: _Foo', 6) +enddef + +" Test for an instance method access level comparison with parent instance +" methods. +def Test_instance_method_access_level() + # protected method in subclass + var lines =<< trim END + mnv9script + class A + def Foo() + enddef + endclass + class B extends A + endclass + class C extends B + def _Foo() + enddef + endclass + END + v9.CheckSourceFailure(lines, 'E1377: Access level of method "_Foo" is different in class "A"', 11) + + # Public method in subclass + lines =<< trim END + mnv9script + class A + def _Foo() + enddef + endclass + class B extends A + endclass + class C extends B + def Foo() + enddef + endclass + END + v9.CheckSourceFailure(lines, 'E1377: Access level of method "Foo" is different in class "A"', 11) +enddef + +def Test_extend_empty_class() + var lines =<< trim END + mnv9script + class A + endclass + class B extends A + endclass + class C extends B + public static var rw_class_var = 1 + public var rw_obj_var = 2 + static def ClassMethod(): number + return 3 + enddef + def ObjMethod(): number + return 4 + enddef + endclass + assert_equal(1, C.rw_class_var) + assert_equal(3, C.ClassMethod()) + var c = C.new() + assert_equal(2, c.rw_obj_var) + assert_equal(4, c.ObjMethod()) + END + v9.CheckSourceSuccess(lines) +enddef + +" Test for assigning to a member variable in a nested class +def Test_nested_object_assignment() + var lines =<< trim END + mnv9script + + class A + var value: number + endclass + + class B + var a: A = A.new() + endclass + + class C + var b: B = B.new() + endclass + + class D + var c: C = C.new() + endclass + + def T(da: D) + da.c.b.a.value = 10 + enddef + + var d = D.new() + T(d) + END + v9.CheckSourceFailure(lines, 'E1335: Variable "value" in class "A" is not writable', 1) +enddef + +" Test for calling methods using a null object +def Test_null_object_method_call() + # Calling a object method using a null object in script context + var lines =<< trim END + mnv9script + + class C + def Foo() + assert_report('This method should not be executed') + enddef + endclass + + var o: C + o.Foo() + END + v9.CheckSourceFailure(lines, 'E1360: Using a null object', 10) + + # Calling a object method using a null object in def function context + lines =<< trim END + mnv9script + + class C + def Foo() + assert_report('This method should not be executed') + enddef + endclass + + def T() + var o: C + o.Foo() + enddef + T() + END + v9.CheckSourceFailure(lines, 'E1360: Using a null object', 2) + + # Calling a object method through another class method using a null object in + # script context + lines =<< trim END + mnv9script + + class C + def Foo() + assert_report('This method should not be executed') + enddef + + static def Bar(o_any: any) + var o_typed: C = o_any + o_typed.Foo() + enddef + endclass + + var o: C + C.Bar(o) + END + v9.CheckSourceFailure(lines, 'E1360: Using a null object', 2) + + # Calling a object method through another class method using a null object in + # def function context + lines =<< trim END + mnv9script + + class C + def Foo() + assert_report('This method should not be executed') + enddef + + static def Bar(o_any: any) + var o_typed: C = o_any + o_typed.Foo() + enddef + endclass + + def T() + var o: C + C.Bar(o) + enddef + T() + END + v9.CheckSourceFailure(lines, 'E1360: Using a null object', 2) + + # Calling an object method defined in a class that is extended. This differs + # from the previous by invoking ISN_METHODCALL instead of ISN_DCALL. + lines =<< trim END + mnv9script + + class C0 + def F() + enddef + endclass + + class C extends C0 + endclass + + def X() + var o: C0 = null_object + o.F() + enddef + X() + END + v9.CheckSourceFailure(lines, 'E1360: Using a null object', 2) + + # Getting a function ref an object method. + lines =<< trim END + mnv9script + + class C0 + def F() + enddef + endclass + + class C extends C0 + endclass + + def X() + var o: C0 = null_object + var XXX = o.F + enddef + X() + END + v9.CheckSourceFailure(lines, 'E1360: Using a null object', 2) +enddef + +" Test for using a dict as an object member +def Test_dict_object_member() + var lines =<< trim END + mnv9script + + class Context + public var state: dict<number> = {} + def GetState(): dict<number> + return this.state + enddef + endclass + + var ctx = Context.new() + ctx.state->extend({a: 1}) + ctx.state['b'] = 2 + assert_equal({a: 1, b: 2}, ctx.GetState()) + + def F() + ctx.state['c'] = 3 + assert_equal({a: 1, b: 2, c: 3}, ctx.GetState()) + enddef + F() + assert_equal(3, ctx.state.c) + ctx.state.c = 4 + assert_equal(4, ctx.state.c) + END + v9.CheckSourceSuccess(lines) +enddef + +" The following test was failing after 9.0.1914. This was caused by using a +" freed object from a previous method call. +def Test_freed_object_from_previous_method_call() + var lines =<< trim END + mnv9script + + class Context + endclass + + class Result + endclass + + def Failure(): Result + return Result.new() + enddef + + def GetResult(ctx: Context): Result + return Failure() + enddef + + def Test_GetResult() + var ctx = Context.new() + var result = GetResult(ctx) + enddef + + Test_GetResult() + END + v9.CheckSourceSuccess(lines) +enddef + +" Test for duplicate object and class variable +def Test_duplicate_variable() + # Object variable name is same as the class variable name + var lines =<< trim END + mnv9script + class A + public static var sval: number + public var sval: number + endclass + var a = A.new() + END + v9.CheckSourceFailure(lines, 'E1369: Duplicate variable: sval', 4) + + # Duplicate variable name and calling a class method + lines =<< trim END + mnv9script + class A + public static var sval: number + public var sval: number + def F1() + echo this.sval + enddef + static def F2() + echo sval + enddef + endclass + A.F2() + END + v9.CheckSourceFailure(lines, 'E1369: Duplicate variable: sval', 4) + + # Duplicate variable with an empty constructor + lines =<< trim END + mnv9script + class A + public static var sval: number + public var sval: number + def new() + enddef + endclass + var a = A.new() + END + v9.CheckSourceFailure(lines, 'E1369: Duplicate variable: sval', 4) +enddef + +" Test for using a reserved keyword as a variable name +def Test_reserved_varname() + for kword in ['true', 'false', 'null', 'null_blob', 'null_dict', + 'null_function', 'null_list', 'null_partial', 'null_string', + 'null_channel', 'null_job', 'super', 'this'] + + var lines =<< trim eval END + mnv9script + class C + public var {kword}: list<number> = [1, 2, 3] + endclass + var o = C.new() + END + v9.CheckSourceFailure(lines, $'E1034: Cannot use reserved name {kword}', 3) + + lines =<< trim eval END + mnv9script + class C + public var {kword}: list<number> = [1, 2, 3] + def new() + enddef + endclass + var o = C.new() + END + v9.CheckSourceFailure(lines, $'E1034: Cannot use reserved name {kword}', 3) + + lines =<< trim eval END + mnv9script + class C + public var {kword}: list<number> = [1, 2, 3] + def new() + enddef + def F() + echo this.{kword} + enddef + endclass + var o = C.new() + o.F() + END + v9.CheckSourceFailure(lines, $'E1034: Cannot use reserved name {kword}', 3) + + # class variable name + if kword != 'this' + lines =<< trim eval END + mnv9script + class C + public static var {kword}: list<number> = [1, 2, 3] + endclass + END + v9.CheckSourceFailure(lines, $'E1034: Cannot use reserved name {kword}', 3) + endif + endfor +enddef + +" Test for checking the type of the arguments and the return value of a object +" method in an extended class. +def Test_extended_obj_method_type_check() + var lines =<< trim END + mnv9script + + class A + endclass + class B extends A + endclass + class C extends B + endclass + + class Foo + def Doit(p: B): B + return B.new() + enddef + endclass + + class Bar extends Foo + def Doit(p: C): B + return B.new() + enddef + endclass + END + v9.CheckSourceFailure(lines, 'E1383: Method "Doit": type mismatch, expected func(object<B>): object<B> but got func(object<C>): object<B>', 20) + + lines =<< trim END + mnv9script + + class A + endclass + class B extends A + endclass + class C extends B + endclass + + class Foo + def Doit(p: B): B + return B.new() + enddef + endclass + + class Bar extends Foo + def Doit(p: B): C + return C.new() + enddef + endclass + END + v9.CheckSourceSuccess(lines) + + lines =<< trim END + mnv9script + + class A + endclass + class B extends A + endclass + class C extends B + endclass + + class Foo + def Doit(p: B): B + return B.new() + enddef + endclass + + class Bar extends Foo + def Doit(p: A): B + return B.new() + enddef + endclass + END + v9.CheckSourceFailure(lines, 'E1383: Method "Doit": type mismatch, expected func(object<B>): object<B> but got func(object<A>): object<B>', 20) + + lines =<< trim END + mnv9script + + class A + endclass + class B extends A + endclass + class C extends B + endclass + + class Foo + def Doit(p: B): B + return B.new() + enddef + endclass + + class Bar extends Foo + def Doit(p: B): A + return A.new() + enddef + endclass + END + v9.CheckSourceFailure(lines, 'E1383: Method "Doit": type mismatch, expected func(object<B>): object<B> but got func(object<B>): object<A>', 20) + + # check varargs type mismatch + lines =<< trim END + mnv9script + + class B + def F(...xxx: list<any>) + enddef + endclass + class C extends B + def F(xxx: list<any>) + enddef + endclass + END + v9.CheckSourceFailure(lines, 'E1383: Method "F": type mismatch, expected func(...list<any>) but got func(list<any>)', 10) +enddef + +" Test type checking for class variable in assignments +func Test_class_variable_complex_type_check() + " class variable with a specific type. Try assigning a different type at + " script level. + let lines =<< trim END + mnv9script + def Foo(l: list<dict<blob>>): dict<list<blob>> + return {} + enddef + class A + public static var Fn: func(list<dict<blob>>): dict<list<blob>> = Foo + endclass + test_garbagecollect_now() + A.Fn = "abc" + END + call v9.CheckSourceFailure(lines, 'E1012: Type mismatch; expected func(list<dict<blob>>): dict<list<blob>> but got string', 9) + + " class variable with a specific type. Try assigning a different type at + " class def method level. + let lines =<< trim END + mnv9script + def Foo(l: list<dict<blob>>): dict<list<blob>> + return {} + enddef + class A + public static var Fn: func(list<dict<blob>>): dict<list<blob>> = Foo + def Bar() + Fn = "abc" + enddef + endclass + var a = A.new() + test_garbagecollect_now() + a.Bar() + END + call v9.CheckSourceFailure(lines, 'E1012: Type mismatch; expected func(list<dict<blob>>): dict<list<blob>> but got string', 1) + + " class variable with a specific type. Try assigning a different type at + " script def method level. + let lines =<< trim END + mnv9script + def Foo(l: list<dict<blob>>): dict<list<blob>> + return {} + enddef + class A + public static var Fn: func(list<dict<blob>>): dict<list<blob>> = Foo + endclass + def Bar() + A.Fn = "abc" + enddef + test_garbagecollect_now() + Bar() + END + call v9.CheckSourceFailure(lines, 'E1012: Type mismatch; expected func(list<dict<blob>>): dict<list<blob>> but got string', 1) + + " class variable without any type. Should be set to the initialization + " expression type. Try assigning a different type from script level. + let lines =<< trim END + mnv9script + def Foo(l: list<dict<blob>>): dict<list<blob>> + return {} + enddef + class A + public static var Fn = Foo + endclass + test_garbagecollect_now() + A.Fn = "abc" + END + call v9.CheckSourceFailure(lines, 'E1012: Type mismatch; expected func(list<dict<blob>>): dict<list<blob>> but got string', 9) + + " class variable without any type. Should be set to the initialization + " expression type. Try assigning a different type at class def level. + let lines =<< trim END + mnv9script + def Foo(l: list<dict<blob>>): dict<list<blob>> + return {} + enddef + class A + public static var Fn = Foo + def Bar() + Fn = "abc" + enddef + endclass + var a = A.new() + test_garbagecollect_now() + a.Bar() + END + call v9.CheckSourceFailure(lines, 'E1012: Type mismatch; expected func(list<dict<blob>>): dict<list<blob>> but got string', 1) + + " class variable without any type. Should be set to the initialization + " expression type. Try assigning a different type at script def level. + let lines =<< trim END + mnv9script + def Foo(l: list<dict<blob>>): dict<list<blob>> + return {} + enddef + class A + public static var Fn = Foo + endclass + def Bar() + A.Fn = "abc" + enddef + test_garbagecollect_now() + Bar() + END + call v9.CheckSourceFailure(lines, 'E1012: Type mismatch; expected func(list<dict<blob>>): dict<list<blob>> but got string', 1) + + " class variable with 'any" type. Can be assigned different types. + let lines =<< trim END + mnv9script + def Foo(l: list<dict<blob>>): dict<list<blob>> + return {} + enddef + class A + public static var Fn: any = Foo + public static var Fn2: any + endclass + test_garbagecollect_now() + assert_equal('func(list<dict<blob>>): dict<list<blob>>', typename(A.Fn)) + A.Fn = "abc" + test_garbagecollect_now() + assert_equal('string', typename(A.Fn)) + A.Fn2 = Foo + test_garbagecollect_now() + assert_equal('func(list<dict<blob>>): dict<list<blob>>', typename(A.Fn2)) + A.Fn2 = "xyz" + test_garbagecollect_now() + assert_equal('string', typename(A.Fn2)) + END + call v9.CheckSourceSuccess(lines) + + " class variable with 'any" type. Can be assigned different types. + let lines =<< trim END + mnv9script + def Foo(l: list<dict<blob>>): dict<list<blob>> + return {} + enddef + class A + public static var Fn: any = Foo + public static var Fn2: any + + def Bar() + assert_equal('func(list<dict<blob>>): dict<list<blob>>', typename(Fn)) + Fn = "abc" + assert_equal('string', typename(Fn)) + Fn2 = Foo + assert_equal('func(list<dict<blob>>): dict<list<blob>>', typename(Fn2)) + Fn2 = "xyz" + assert_equal('string', typename(Fn2)) + enddef + endclass + var a = A.new() + test_garbagecollect_now() + a.Bar() + test_garbagecollect_now() + A.Fn = Foo + a.Bar() + END + call v9.CheckSourceSuccess(lines) + + " class variable with 'any" type. Can be assigned different types. + let lines =<< trim END + mnv9script + def Foo(l: list<dict<blob>>): dict<list<blob>> + return {} + enddef + class A + public static var Fn: any = Foo + public static var Fn2: any + endclass + + def Bar() + assert_equal('func(list<dict<blob>>): dict<list<blob>>', typename(A.Fn)) + A.Fn = "abc" + assert_equal('string', typename(A.Fn)) + A.Fn2 = Foo + assert_equal('func(list<dict<blob>>): dict<list<blob>>', typename(A.Fn2)) + A.Fn2 = "xyz" + assert_equal('string', typename(A.Fn2)) + enddef + Bar() + test_garbagecollect_now() + A.Fn = Foo + Bar() + END + call v9.CheckSourceSuccess(lines) + + let lines =<< trim END + mnv9script + class A + public static var foo = [0z10, 0z20] + endclass + assert_equal([0z10, 0z20], A.foo) + A.foo = [0z30] + assert_equal([0z30], A.foo) + var a = A.foo + assert_equal([0z30], a) + END + call v9.CheckSourceSuccess(lines) +endfunc + +" Test type checking for object variable in assignments +func Test_object_variable_complex_type_check() + " object variable with a specific type. Try assigning a different type at + " script level. + let lines =<< trim END + mnv9script + def Foo(l: list<dict<blob>>): dict<list<blob>> + return {} + enddef + class A + public var Fn: func(list<dict<blob>>): dict<list<blob>> = Foo + endclass + var a = A.new() + test_garbagecollect_now() + a.Fn = "abc" + END + call v9.CheckSourceFailure(lines, 'E1012: Type mismatch; expected func(list<dict<blob>>): dict<list<blob>> but got string', 10) + + " object variable with a specific type. Try assigning a different type at + " object def method level. + let lines =<< trim END + mnv9script + def Foo(l: list<dict<blob>>): dict<list<blob>> + return {} + enddef + class A + public var Fn: func(list<dict<blob>>): dict<list<blob>> = Foo + def Bar() + this.Fn = "abc" + this.Fn = Foo + enddef + endclass + var a = A.new() + test_garbagecollect_now() + a.Bar() + END + call v9.CheckSourceFailure(lines, 'E1012: Type mismatch; expected func(list<dict<blob>>): dict<list<blob>> but got string', 1) + + " object variable with a specific type. Try assigning a different type at + " script def method level. + let lines =<< trim END + mnv9script + def Foo(l: list<dict<blob>>): dict<list<blob>> + return {} + enddef + class A + public var Fn: func(list<dict<blob>>): dict<list<blob>> = Foo + endclass + def Bar() + var a = A.new() + a.Fn = "abc" + a.Fn = Foo + enddef + test_garbagecollect_now() + Bar() + END + call v9.CheckSourceFailure(lines, 'E1012: Type mismatch; expected func(list<dict<blob>>): dict<list<blob>> but got string', 2) + + " object variable without any type. Should be set to the initialization + " expression type. Try assigning a different type from script level. + let lines =<< trim END + mnv9script + def Foo(l: list<dict<blob>>): dict<list<blob>> + return {} + enddef + class A + public var Fn = Foo + endclass + var a = A.new() + test_garbagecollect_now() + a.Fn = "abc" + END + call v9.CheckSourceFailure(lines, 'E1012: Type mismatch; expected func(list<dict<blob>>): dict<list<blob>> but got string', 10) + + " object variable without any type. Should be set to the initialization + " expression type. Try assigning a different type at object def level. + let lines =<< trim END + mnv9script + def Foo(l: list<dict<blob>>): dict<list<blob>> + return {} + enddef + class A + public var Fn = Foo + def Bar() + this.Fn = "abc" + this.Fn = Foo + enddef + endclass + var a = A.new() + test_garbagecollect_now() + a.Bar() + END + call v9.CheckSourceFailure(lines, 'E1012: Type mismatch; expected func(list<dict<blob>>): dict<list<blob>> but got string', 1) + + " object variable without any type. Should be set to the initialization + " expression type. Try assigning a different type at script def level. + let lines =<< trim END + mnv9script + def Foo(l: list<dict<blob>>): dict<list<blob>> + return {} + enddef + class A + public var Fn = Foo + endclass + def Bar() + var a = A.new() + a.Fn = "abc" + a.Fn = Foo + enddef + test_garbagecollect_now() + Bar() + END + call v9.CheckSourceFailure(lines, 'E1012: Type mismatch; expected func(list<dict<blob>>): dict<list<blob>> but got string', 2) + + " object variable with 'any" type. Can be assigned different types. + let lines =<< trim END + mnv9script + def Foo(l: list<dict<blob>>): dict<list<blob>> + return {} + enddef + class A + public var Fn: any = Foo + public var Fn2: any + endclass + + var a = A.new() + test_garbagecollect_now() + assert_equal('func(list<dict<blob>>): dict<list<blob>>', typename(a.Fn)) + a.Fn = "abc" + test_garbagecollect_now() + assert_equal('string', typename(a.Fn)) + a.Fn2 = Foo + test_garbagecollect_now() + assert_equal('func(list<dict<blob>>): dict<list<blob>>', typename(a.Fn2)) + a.Fn2 = "xyz" + test_garbagecollect_now() + assert_equal('string', typename(a.Fn2)) + END + call v9.CheckSourceSuccess(lines) + + " object variable with 'any" type. Can be assigned different types. + let lines =<< trim END + mnv9script + def Foo(l: list<dict<blob>>): dict<list<blob>> + return {} + enddef + class A + public var Fn: any = Foo + public var Fn2: any + + def Bar() + assert_equal('func(list<dict<blob>>): dict<list<blob>>', typename(this.Fn)) + this.Fn = "abc" + assert_equal('string', typename(this.Fn)) + this.Fn2 = Foo + assert_equal('func(list<dict<blob>>): dict<list<blob>>', typename(this.Fn2)) + this.Fn2 = "xyz" + assert_equal('string', typename(this.Fn2)) + enddef + endclass + + var a = A.new() + test_garbagecollect_now() + a.Bar() + test_garbagecollect_now() + a.Fn = Foo + a.Bar() + END + call v9.CheckSourceSuccess(lines) + + " object variable with 'any" type. Can be assigned different types. + let lines =<< trim END + mnv9script + def Foo(l: list<dict<blob>>): dict<list<blob>> + return {} + enddef + class A + public var Fn: any = Foo + public var Fn2: any + endclass + + def Bar() + var a = A.new() + assert_equal('func(list<dict<blob>>): dict<list<blob>>', typename(a.Fn)) + a.Fn = "abc" + assert_equal('string', typename(a.Fn)) + a.Fn2 = Foo + assert_equal('func(list<dict<blob>>): dict<list<blob>>', typename(a.Fn2)) + a.Fn2 = "xyz" + assert_equal('string', typename(a.Fn2)) + enddef + test_garbagecollect_now() + Bar() + test_garbagecollect_now() + Bar() + END + call v9.CheckSourceSuccess(lines) +endfunc + +" Test for recursively calling an object method. This used to cause an +" use-after-free error. +def Test_recursive_object_method_call() + var lines =<< trim END + mnv9script + class A + var val: number = 0 + def Foo(): number + if this.val >= 90 + return this.val + endif + this.val += 1 + return this.Foo() + enddef + endclass + var a = A.new() + assert_equal(90, a.Foo()) + END + v9.CheckSourceSuccess(lines) +enddef + +" Test for recursively calling a class method. +def Test_recursive_class_method_call() + var lines =<< trim END + mnv9script + class A + static var val: number = 0 + static def Foo(): number + if val >= 90 + return val + endif + val += 1 + return Foo() + enddef + endclass + assert_equal(90, A.Foo()) + END + v9.CheckSourceSuccess(lines) +enddef + +" Test for checking the argument types and the return type when assigning a +" funcref to make sure the invariant class type is used. +def Test_funcref_argtype_returntype_check() + var lines =<< trim END + mnv9script + class A + endclass + class B extends A + endclass + + def Foo(p: B): B + return B.new() + enddef + + var Bar: func(A): A = Foo + END + v9.CheckSourceFailure(lines, 'E1012: Type mismatch; expected func(object<A>): object<A> but got func(object<B>): object<B>', 11) + + lines =<< trim END + mnv9script + class A + endclass + class B extends A + endclass + + def Foo(p: B): B + return B.new() + enddef + + def Baz() + var Bar: func(A): A = Foo + enddef + Baz() + END + v9.CheckSourceFailure(lines, 'E1012: Type mismatch; expected func(object<A>): object<A> but got func(object<B>): object<B>', 1) +enddef + +def Test_funcref_argtype_invariance_check() + var lines =<< trim END + mnv9script + + class A + endclass + class B extends A + endclass + class C extends B + endclass + + var Func: func(B): number + Func = (o: B): number => 3 + assert_equal(3, Func(B.new())) + END + v9.CheckSourceSuccess(lines) + + lines =<< trim END + mnv9script + + class A + endclass + class B extends A + endclass + class C extends B + endclass + + var Func: func(B): number + Func = (o: A): number => 3 + END + v9.CheckSourceFailure(lines, 'E1012: Type mismatch; expected func(object<B>): number but got func(object<A>): number', 11) + + lines =<< trim END + mnv9script + + class A + endclass + class B extends A + endclass + class C extends B + endclass + + var Func: func(B): number + Func = (o: C): number => 3 + END + v9.CheckSourceFailure(lines, 'E1012: Type mismatch; expected func(object<B>): number but got func(object<C>): number', 11) +enddef + +" Test for using an operator (e.g. +) with an assignment +def Test_op_and_assignment() + # Using += with a class variable + var lines =<< trim END + mnv9script + class A + public static var val: list<number> = [] + static def Foo(): list<number> + val += [1] + return val + enddef + endclass + def Bar(): list<number> + A.val += [2] + return A.val + enddef + assert_equal([1], A.Foo()) + assert_equal([1, 2], Bar()) + A.val += [3] + assert_equal([1, 2, 3], A.val) + END + v9.CheckSourceSuccess(lines) + + # Using += with an object variable + lines =<< trim END + mnv9script + class A + public var val: list<number> = [] + def Foo(): list<number> + this.val += [1] + return this.val + enddef + endclass + def Bar(bar_a: A): list<number> + bar_a.val += [2] + return bar_a.val + enddef + var a = A.new() + assert_equal([1], a.Foo()) + assert_equal([1, 2], Bar(a)) + a.val += [3] + assert_equal([1, 2, 3], a.val) + END + v9.CheckSourceSuccess(lines) +enddef + +" Test for using an object method as a funcref +def Test_object_funcref() + # Using object method funcref from a def function + var lines =<< trim END + mnv9script + class A + def Foo(): list<number> + return [3, 2, 1] + enddef + endclass + def Bar() + var a = A.new() + var Fn = a.Foo + assert_equal([3, 2, 1], Fn()) + enddef + Bar() + END + v9.CheckSourceSuccess(lines) + + # Using object method funcref at the script level + lines =<< trim END + mnv9script + class A + def Foo(): dict<number> + return {a: 1, b: 2} + enddef + endclass + var a = A.new() + var Fn = a.Foo + assert_equal({a: 1, b: 2}, Fn()) + END + v9.CheckSourceSuccess(lines) + + # Using object method funcref at the script level + lines =<< trim END + mnv9script + class A + var val: number + def Foo(): number + return this.val + enddef + endclass + var a = A.new(345) + var Fn = a.Foo + assert_equal(345, Fn()) + END + v9.CheckSourceSuccess(lines) + + # Using object method funcref from another object method + lines =<< trim END + mnv9script + class A + def Foo(): list<number> + return [3, 2, 1] + enddef + def Bar() + var Fn = this.Foo + assert_equal([3, 2, 1], Fn()) + enddef + endclass + var a = A.new() + a.Bar() + END + v9.CheckSourceSuccess(lines) + + # Using function() to get a object method funcref + lines =<< trim END + mnv9script + class A + def Foo(l: list<any>): list<any> + return l + enddef + endclass + var a = A.new() + var Fn = function(a.Foo, [[{a: 1, b: 2}, [3, 4]]]) + assert_equal([{a: 1, b: 2}, [3, 4]], Fn()) + END + v9.CheckSourceSuccess(lines) + + # Use an object method with a function returning a funcref and then call the + # funcref. + lines =<< trim END + mnv9script + + def Map(F: func(number): number): func(number): number + return (n: number) => F(n) + enddef + + class Math + def Double(n: number): number + return 2 * n + enddef + endclass + + const math = Math.new() + assert_equal(48, Map(math.Double)(24)) + END + v9.CheckSourceSuccess(lines) + + # Try using a protected object method funcref from a def function + lines =<< trim END + mnv9script + class A + def _Foo() + enddef + endclass + def Bar() + var a = A.new() + var Fn = a._Foo + enddef + Bar() + END + v9.CheckSourceFailure(lines, 'E1366: Cannot access protected method: _Foo', 2) + + # Try using a protected object method funcref at the script level + lines =<< trim END + mnv9script + class A + def _Foo() + enddef + endclass + var a = A.new() + var Fn = a._Foo + END + v9.CheckSourceFailure(lines, 'E1366: Cannot access protected method: _Foo', 7) + + # Using a protected object method funcref from another object method + lines =<< trim END + mnv9script + class A + def _Foo(): list<number> + return [3, 2, 1] + enddef + def Bar() + var Fn = this._Foo + assert_equal([3, 2, 1], Fn()) + enddef + endclass + var a = A.new() + a.Bar() + END + v9.CheckSourceSuccess(lines) + + # Using object method funcref using call() + lines =<< trim END + mnv9script + class A + var val: number + def Foo(): number + return this.val + enddef + endclass + + def Bar(obj: A) + assert_equal(123, call(obj.Foo, [])) + enddef + + var a = A.new(123) + Bar(a) + assert_equal(123, call(a.Foo, [])) + END + v9.CheckSourceSuccess(lines) +enddef + +" Test for using a class method as a funcref +def Test_class_funcref() + # Using class method funcref in a def function + var lines =<< trim END + mnv9script + class A + static def Foo(): list<number> + return [3, 2, 1] + enddef + endclass + def Bar() + var Fn = A.Foo + assert_equal([3, 2, 1], Fn()) + enddef + Bar() + END + v9.CheckSourceSuccess(lines) + + # Using class method funcref at script level + lines =<< trim END + mnv9script + class A + static def Foo(): dict<number> + return {a: 1, b: 2} + enddef + endclass + var Fn = A.Foo + assert_equal({a: 1, b: 2}, Fn()) + END + v9.CheckSourceSuccess(lines) + + # Using class method funcref at the script level + lines =<< trim END + mnv9script + class A + public static var val: number + static def Foo(): number + return val + enddef + endclass + A.val = 567 + var Fn = A.Foo + assert_equal(567, Fn()) + END + v9.CheckSourceSuccess(lines) + + # Using function() to get a class method funcref + lines =<< trim END + mnv9script + class A + static def Foo(l: list<any>): list<any> + return l + enddef + endclass + var Fn = function(A.Foo, [[{a: 1, b: 2}, [3, 4]]]) + assert_equal([{a: 1, b: 2}, [3, 4]], Fn()) + END + v9.CheckSourceSuccess(lines) + + # Using a class method funcref from another class method + lines =<< trim END + mnv9script + class A + static def Foo(): list<number> + return [3, 2, 1] + enddef + static def Bar() + var Fn = Foo + assert_equal([3, 2, 1], Fn()) + enddef + endclass + A.Bar() + END + v9.CheckSourceSuccess(lines) + + # Use a class method with a function returning a funcref and then call the + # funcref. + lines =<< trim END + mnv9script + + def Map(F: func(number): number): func(number): number + return (n: number) => F(n) + enddef + + class Math + static def StaticDouble(n: number): number + return 2 * n + enddef + endclass + + assert_equal(48, Map(Math.StaticDouble)(24)) + END + v9.CheckSourceSuccess(lines) + + # Try using a protected class method funcref in a def function + lines =<< trim END + mnv9script + class A + static def _Foo() + enddef + endclass + def Bar() + var Fn = A._Foo + enddef + Bar() + END + v9.CheckSourceFailure(lines, 'E1366: Cannot access protected method: _Foo', 1) + + # Try using a protected class method funcref at script level + lines =<< trim END + mnv9script + class A + static def _Foo() + enddef + endclass + var Fn = A._Foo + END + v9.CheckSourceFailure(lines, 'E1366: Cannot access protected method: _Foo', 6) + + # Using a protected class method funcref from another class method + lines =<< trim END + mnv9script + class A + static def _Foo(): list<number> + return [3, 2, 1] + enddef + static def Bar() + var Fn = _Foo + assert_equal([3, 2, 1], Fn()) + enddef + endclass + A.Bar() + END + v9.CheckSourceSuccess(lines) + + # Using class method funcref using call() + lines =<< trim END + mnv9script + class A + public static var val: number + static def Foo(): number + return val + enddef + endclass + + def Bar() + A.val = 468 + assert_equal(468, call(A.Foo, [])) + enddef + Bar() + assert_equal(468, call(A.Foo, [])) + END + v9.CheckSourceSuccess(lines) +enddef + +" Test for using an object member as a funcref +def Test_object_member_funcref() + # Using a funcref object variable in an object method + var lines =<< trim END + mnv9script + def Foo(n: number): number + return n * 10 + enddef + + class A + var Cb: func(number): number = Foo + def Bar() + assert_equal(200, this.Cb(20)) + enddef + endclass + + var a = A.new() + a.Bar() + END + v9.CheckSourceSuccess(lines) + + # Using a funcref object variable in a def method + lines =<< trim END + mnv9script + def Foo(n: number): number + return n * 10 + enddef + + class A + var Cb: func(number): number = Foo + endclass + + def Bar() + var a = A.new() + assert_equal(200, a.Cb(20)) + enddef + Bar() + END + v9.CheckSourceSuccess(lines) + + # Using a funcref object variable at script level + lines =<< trim END + mnv9script + def Foo(n: number): number + return n * 10 + enddef + + class A + var Cb: func(number): number = Foo + endclass + + var a = A.new() + assert_equal(200, a.Cb(20)) + END + v9.CheckSourceSuccess(lines) + + # Using a funcref object variable pointing to an object method in an object + # method. + lines =<< trim END + mnv9script + class A + var Cb: func(number): number = this.Foo + def Foo(n: number): number + return n * 10 + enddef + def Bar() + assert_equal(200, this.Cb(20)) + enddef + endclass + + var a = A.new() + a.Bar() + END + v9.CheckSourceSuccess(lines) + + # Using a funcref object variable pointing to an object method in a def + # method. + lines =<< trim END + mnv9script + class A + var Cb: func(number): number = this.Foo + def Foo(n: number): number + return n * 10 + enddef + endclass + + def Bar() + var a = A.new() + assert_equal(200, a.Cb(20)) + enddef + Bar() + END + v9.CheckSourceSuccess(lines) + + # Using a funcref object variable pointing to an object method at script + # level. + lines =<< trim END + mnv9script + class A + var Cb = this.Foo + def Foo(n: number): number + return n * 10 + enddef + endclass + + var a = A.new() + assert_equal(200, a.Cb(20)) + END + v9.CheckSourceSuccess(lines) +enddef + +" Test for using a class member as a funcref +def Test_class_member_funcref() + # Using a funcref class variable in a class method + var lines =<< trim END + mnv9script + def Foo(n: number): number + return n * 10 + enddef + + class A + static var Cb = Foo + static def Bar() + assert_equal(200, Cb(20)) + enddef + endclass + + A.Bar() + END + v9.CheckSourceSuccess(lines) + + # Using a funcref class variable in a def method + lines =<< trim END + mnv9script + def Foo(n: number): number + return n * 10 + enddef + + class A + public static var Cb = Foo + endclass + + def Bar() + assert_equal(200, A.Cb(20)) + enddef + Bar() + END + v9.CheckSourceSuccess(lines) + + # Using a funcref class variable at script level + lines =<< trim END + mnv9script + def Foo(n: number): number + return n * 10 + enddef + + class A + public static var Cb = Foo + endclass + + assert_equal(200, A.Cb(20)) + END + v9.CheckSourceSuccess(lines) + + # Using a funcref class variable pointing to a class method in a class + # method. + lines =<< trim END + mnv9script + class A + static var Cb: func(number): number + static def Foo(n: number): number + return n * 10 + enddef + static def Init() + Cb = Foo + enddef + static def Bar() + assert_equal(200, Cb(20)) + enddef + endclass + + A.Init() + A.Bar() + END + v9.CheckSourceSuccess(lines) + + # Using a funcref class variable pointing to a class method in a def method. + lines =<< trim END + mnv9script + class A + static var Cb: func(number): number + static def Foo(n: number): number + return n * 10 + enddef + static def Init() + Cb = Foo + enddef + endclass + + def Bar() + A.Init() + assert_equal(200, A.Cb(20)) + enddef + Bar() + END + v9.CheckSourceSuccess(lines) + + # Using a funcref class variable pointing to a class method at script level. + lines =<< trim END + mnv9script + class A + static var Cb: func(number): number + static def Foo(n: number): number + return n * 10 + enddef + static def Init() + Cb = Foo + enddef + endclass + + A.Init() + assert_equal(200, A.Cb(20)) + END + v9.CheckSourceSuccess(lines) +enddef + +" Test for using object methods as popup callback functions +def Test_objmethod_popup_callback() + # Use the popup from the script level + var lines =<< trim END + mnv9script + + class A + var selection: number = -1 + var filterkeys: list<string> = [] + + def PopupFilter(id: number, key: string): bool + add(this.filterkeys, key) + return popup_filter_yesno(id, key) + enddef + + def PopupCb(id: number, result: number) + this.selection = result ? 100 : 200 + enddef + endclass + + var a = A.new() + feedkeys('', 'xt') + var winid = popup_create('Y/N?', + {filter: a.PopupFilter, callback: a.PopupCb}) + feedkeys('y', 'xt') + popup_close(winid) + assert_equal(100, a.selection) + assert_equal(['y'], a.filterkeys) + feedkeys('', 'xt') + winid = popup_create('Y/N?', + {filter: a.PopupFilter, callback: a.PopupCb}) + feedkeys('n', 'xt') + popup_close(winid) + assert_equal(200, a.selection) + assert_equal(['y', 'n'], a.filterkeys) + END + v9.CheckSourceSuccess(lines) + + # Use the popup from a def function + lines =<< trim END + mnv9script + + class A + var selection: number = -1 + var filterkeys: list<string> = [] + + def PopupFilter(id: number, key: string): bool + add(this.filterkeys, key) + return popup_filter_yesno(id, key) + enddef + + def PopupCb(id: number, result: number) + this.selection = result ? 100 : 200 + enddef + endclass + + def Foo() + var a = A.new() + feedkeys('', 'xt') + var winid = popup_create('Y/N?', + {filter: a.PopupFilter, callback: a.PopupCb}) + feedkeys('y', 'xt') + popup_close(winid) + assert_equal(100, a.selection) + assert_equal(['y'], a.filterkeys) + feedkeys('', 'xt') + winid = popup_create('Y/N?', + {filter: a.PopupFilter, callback: a.PopupCb}) + feedkeys('n', 'xt') + popup_close(winid) + assert_equal(200, a.selection) + assert_equal(['y', 'n'], a.filterkeys) + enddef + Foo() + END + v9.CheckSourceSuccess(lines) +enddef + +" Test for using class methods as popup callback functions +def Test_classmethod_popup_callback() + # Use the popup from the script level + var lines =<< trim END + mnv9script + + class A + static var selection: number = -1 + static var filterkeys: list<string> = [] + + static def PopupFilter(id: number, key: string): bool + add(filterkeys, key) + return popup_filter_yesno(id, key) + enddef + + static def PopupCb(id: number, result: number) + selection = result ? 100 : 200 + enddef + endclass + + feedkeys('', 'xt') + var winid = popup_create('Y/N?', + {filter: A.PopupFilter, callback: A.PopupCb}) + feedkeys('y', 'xt') + popup_close(winid) + assert_equal(100, A.selection) + assert_equal(['y'], A.filterkeys) + feedkeys('', 'xt') + winid = popup_create('Y/N?', + {filter: A.PopupFilter, callback: A.PopupCb}) + feedkeys('n', 'xt') + popup_close(winid) + assert_equal(200, A.selection) + assert_equal(['y', 'n'], A.filterkeys) + END + v9.CheckSourceSuccess(lines) + + # Use the popup from a def function + lines =<< trim END + mnv9script + + class A + static var selection: number = -1 + static var filterkeys: list<string> = [] + + static def PopupFilter(id: number, key: string): bool + add(filterkeys, key) + return popup_filter_yesno(id, key) + enddef + + static def PopupCb(id: number, result: number) + selection = result ? 100 : 200 + enddef + endclass + + def Foo() + feedkeys('', 'xt') + var winid = popup_create('Y/N?', + {filter: A.PopupFilter, callback: A.PopupCb}) + feedkeys('y', 'xt') + popup_close(winid) + assert_equal(100, A.selection) + assert_equal(['y'], A.filterkeys) + feedkeys('', 'xt') + winid = popup_create('Y/N?', + {filter: A.PopupFilter, callback: A.PopupCb}) + feedkeys('n', 'xt') + popup_close(winid) + assert_equal(200, A.selection) + assert_equal(['y', 'n'], A.filterkeys) + enddef + Foo() + END + v9.CheckSourceSuccess(lines) +enddef + +" Test for using an object method as a timer callback function +def Test_objmethod_timer_callback() + # Use the timer callback from script level + var lines =<< trim END + mnv9script + + class A + var timerTick: number = -1 + def TimerCb(timerID: number) + this.timerTick = 6 + enddef + endclass + + var a = A.new() + timer_start(0, a.TimerCb) + var maxWait = 5 + while maxWait > 0 && a.timerTick == -1 + :sleep 10m + maxWait -= 1 + endwhile + assert_equal(6, a.timerTick) + END + v9.CheckSourceSuccess(lines) + + # Use the timer callback from a def function + lines =<< trim END + mnv9script + + class A + var timerTick: number = -1 + def TimerCb(timerID: number) + this.timerTick = 6 + enddef + endclass + + def Foo() + var a = A.new() + timer_start(0, a.TimerCb) + var maxWait = 5 + while maxWait > 0 && a.timerTick == -1 + :sleep 10m + maxWait -= 1 + endwhile + assert_equal(6, a.timerTick) + enddef + Foo() + END + v9.CheckSourceSuccess(lines) +enddef + +" Test for using a class method as a timer callback function +def Test_classmethod_timer_callback() + # Use the timer callback from script level + var lines =<< trim END + mnv9script + + class A + static var timerTick: number = -1 + static def TimerCb(timerID: number) + timerTick = 6 + enddef + endclass + + timer_start(0, A.TimerCb) + var maxWait = 5 + while maxWait > 0 && A.timerTick == -1 + :sleep 10m + maxWait -= 1 + endwhile + assert_equal(6, A.timerTick) + END + v9.CheckSourceSuccess(lines) + + # Use the timer callback from a def function + lines =<< trim END + mnv9script + + class A + static var timerTick: number = -1 + static def TimerCb(timerID: number) + timerTick = 6 + enddef + endclass + + def Foo() + timer_start(0, A.TimerCb) + var maxWait = 5 + while maxWait > 0 && A.timerTick == -1 + :sleep 10m + maxWait -= 1 + endwhile + assert_equal(6, A.timerTick) + enddef + Foo() + END + v9.CheckSourceSuccess(lines) +enddef + +" Test for using a class variable as the first and/or second operand of a binary +" operator. +def Test_class_variable_as_operands() + var lines =<< trim END + mnv9script + class Tests + static var truthy: bool = true + public static var TruthyFn: func + static var list: list<any> = [] + static var four: number = 4 + static var str: string = 'hello' + + static def Str(): string + return str + enddef + + static def Four(): number + return four + enddef + + static def List(): list<any> + return list + enddef + + static def Truthy(): bool + return truthy + enddef + + def TestOps() + assert_true(Tests.truthy == truthy) + assert_true(truthy == Tests.truthy) + assert_true(Tests.list isnot []) + assert_true([] isnot Tests.list) + assert_equal(2, Tests.four >> 1) + assert_equal(16, 1 << Tests.four) + assert_equal(8, Tests.four + four) + assert_equal(8, four + Tests.four) + assert_equal('hellohello', Tests.str .. str) + assert_equal('hellohello', str .. Tests.str) + + # Using class variable for list indexing + var l = range(10) + assert_equal(4, l[Tests.four]) + assert_equal([4, 5, 6], l[Tests.four : Tests.four + 2]) + + # Using class variable for Dict key + var d = {hello: 'abc'} + assert_equal('abc', d[Tests.str]) + enddef + endclass + + def TestOps2() + assert_true(Tests.truthy == Tests.Truthy()) + assert_true(Tests.Truthy() == Tests.truthy) + assert_true(Tests.truthy == Tests.TruthyFn()) + assert_true(Tests.TruthyFn() == Tests.truthy) + assert_true(Tests.list is Tests.List()) + assert_true(Tests.List() is Tests.list) + assert_equal(2, Tests.four >> 1) + assert_equal(16, 1 << Tests.four) + assert_equal(8, Tests.four + Tests.Four()) + assert_equal(8, Tests.Four() + Tests.four) + assert_equal('hellohello', Tests.str .. Tests.Str()) + assert_equal('hellohello', Tests.Str() .. Tests.str) + + # Using class variable for list indexing + var l = range(10) + assert_equal(4, l[Tests.four]) + assert_equal([4, 5, 6], l[Tests.four : Tests.four + 2]) + + # Using class variable for Dict key + var d = {hello: 'abc'} + assert_equal('abc', d[Tests.str]) + enddef + + Tests.TruthyFn = Tests.Truthy + var t = Tests.new() + t.TestOps() + TestOps2() + + assert_true(Tests.truthy == Tests.Truthy()) + assert_true(Tests.Truthy() == Tests.truthy) + assert_true(Tests.truthy == Tests.TruthyFn()) + assert_true(Tests.TruthyFn() == Tests.truthy) + assert_true(Tests.list is Tests.List()) + assert_true(Tests.List() is Tests.list) + assert_equal(2, Tests.four >> 1) + assert_equal(16, 1 << Tests.four) + assert_equal(8, Tests.four + Tests.Four()) + assert_equal(8, Tests.Four() + Tests.four) + assert_equal('hellohello', Tests.str .. Tests.Str()) + assert_equal('hellohello', Tests.Str() .. Tests.str) + + # Using class variable for list indexing + var l = range(10) + assert_equal(4, l[Tests.four]) + assert_equal([4, 5, 6], l[Tests.four : Tests.four + 2]) + + # Using class variable for Dict key + var d = {hello: 'abc'} + assert_equal('abc', d[Tests.str]) + END + v9.CheckSourceSuccess(lines) +enddef + +" Test for checking the type of the key used to access an object dict member. +def Test_dict_member_key_type_check() + var lines =<< trim END + mnv9script + + abstract class State + var numbers: dict<string> = {0: 'nil', 1: 'unity'} + endclass + + class Test extends State + def ObjMethodTests() + var cursor: number = 0 + var z: number = 0 + [this.numbers[cursor]] = ['zero.1'] + assert_equal({0: 'zero.1', 1: 'unity'}, this.numbers) + [this.numbers[string(cursor)], z] = ['zero.2', 1] + assert_equal({0: 'zero.2', 1: 'unity'}, this.numbers) + [z, this.numbers[string(cursor)]] = [1, 'zero.3'] + assert_equal({0: 'zero.3', 1: 'unity'}, this.numbers) + [this.numbers[cursor], z] = ['zero.4', 1] + assert_equal({0: 'zero.4', 1: 'unity'}, this.numbers) + [z, this.numbers[cursor]] = [1, 'zero.5'] + assert_equal({0: 'zero.5', 1: 'unity'}, this.numbers) + enddef + + static def ClassMethodTests(that: State) + var cursor: number = 0 + var z: number = 0 + [that.numbers[cursor]] = ['zero.1'] + assert_equal({0: 'zero.1', 1: 'unity'}, that.numbers) + [that.numbers[string(cursor)], z] = ['zero.2', 1] + assert_equal({0: 'zero.2', 1: 'unity'}, that.numbers) + [z, that.numbers[string(cursor)]] = [1, 'zero.3'] + assert_equal({0: 'zero.3', 1: 'unity'}, that.numbers) + [that.numbers[cursor], z] = ['zero.4', 1] + assert_equal({0: 'zero.4', 1: 'unity'}, that.numbers) + [z, that.numbers[cursor]] = [1, 'zero.5'] + assert_equal({0: 'zero.5', 1: 'unity'}, that.numbers) + enddef + + def new() + enddef + + def newMethodTests() + var cursor: number = 0 + var z: number + [this.numbers[cursor]] = ['zero.1'] + assert_equal({0: 'zero.1', 1: 'unity'}, this.numbers) + [this.numbers[string(cursor)], z] = ['zero.2', 1] + assert_equal({0: 'zero.2', 1: 'unity'}, this.numbers) + [z, this.numbers[string(cursor)]] = [1, 'zero.3'] + assert_equal({0: 'zero.3', 1: 'unity'}, this.numbers) + [this.numbers[cursor], z] = ['zero.4', 1] + assert_equal({0: 'zero.4', 1: 'unity'}, this.numbers) + [z, this.numbers[cursor]] = [1, 'zero.5'] + assert_equal({0: 'zero.5', 1: 'unity'}, this.numbers) + enddef + endclass + + def DefFuncTests(that: Test) + var cursor: number = 0 + var z: number + [that.numbers[cursor]] = ['zero.1'] + assert_equal({0: 'zero.1', 1: 'unity'}, that.numbers) + [that.numbers[string(cursor)], z] = ['zero.2', 1] + assert_equal({0: 'zero.2', 1: 'unity'}, that.numbers) + [z, that.numbers[string(cursor)]] = [1, 'zero.3'] + assert_equal({0: 'zero.3', 1: 'unity'}, that.numbers) + [that.numbers[cursor], z] = ['zero.4', 1] + assert_equal({0: 'zero.4', 1: 'unity'}, that.numbers) + [z, that.numbers[cursor]] = [1, 'zero.5'] + assert_equal({0: 'zero.5', 1: 'unity'}, that.numbers) + enddef + + Test.newMethodTests() + Test.new().ObjMethodTests() + Test.ClassMethodTests(Test.new()) + DefFuncTests(Test.new()) + + const test: Test = Test.new() + var cursor: number = 0 + [test.numbers[cursor], cursor] = ['zero', 1] + [cursor, test.numbers[cursor]] = [1, 'one'] + assert_equal({0: 'zero', 1: 'one'}, test.numbers) + END + v9.CheckSourceSuccess(lines) + + lines =<< trim END + mnv9script + + class A + var numbers: dict<string> = {a: '1', b: '2'} + + def new() + enddef + + def Foo() + var z: number + [this.numbers.a, z] = [{}, 10] + enddef + endclass + + var a = A.new() + a.Foo() + END + v9.CheckSourceFailure(lines, 'E1012: Type mismatch; expected string but got dict<any>', 2) + + lines =<< trim END + mnv9script + + class A + var numbers: dict<number> = {a: 1, b: 2} + + def new() + enddef + + def Foo() + var x: string = 'a' + var y: number + [this.numbers[x], y] = [{}, 10] + enddef + endclass + + var a = A.new() + a.Foo() + END + v9.CheckSourceFailure(lines, 'E1012: Type mismatch; expected number but got dict<any>', 3) +enddef + +def Test_compile_many_def_functions_in_funcref_instr() + # This used to crash MNV. This is reproducible only when run on new instance + # of MNV. + var lines =<< trim END + mnv9script + + class A + def new() + this.TakeFunc(this.F00) + enddef + + def TakeFunc(F: func) + enddef + + def F00() + this.F01() + this.F02() + this.F03() + this.F04() + this.F05() + this.F06() + this.F07() + this.F08() + this.F09() + this.F10() + this.F11() + this.F12() + this.F13() + this.F14() + this.F15() + this.F16() + this.F17() + this.F18() + this.F19() + this.F20() + this.F21() + this.F22() + this.F23() + this.F24() + this.F25() + this.F26() + this.F27() + this.F28() + this.F29() + this.F30() + this.F31() + this.F32() + this.F33() + this.F34() + this.F35() + this.F36() + this.F37() + this.F38() + this.F39() + this.F40() + this.F41() + this.F42() + this.F43() + this.F44() + this.F45() + this.F46() + this.F47() + enddef + + def F01() + enddef + def F02() + enddef + def F03() + enddef + def F04() + enddef + def F05() + enddef + def F06() + enddef + def F07() + enddef + def F08() + enddef + def F09() + enddef + def F10() + enddef + def F11() + enddef + def F12() + enddef + def F13() + enddef + def F14() + enddef + def F15() + enddef + def F16() + enddef + def F17() + enddef + def F18() + enddef + def F19() + enddef + def F20() + enddef + def F21() + enddef + def F22() + enddef + def F23() + enddef + def F24() + enddef + def F25() + enddef + def F26() + enddef + def F27() + enddef + def F28() + enddef + def F29() + enddef + def F30() + enddef + def F31() + enddef + def F32() + enddef + def F33() + enddef + def F34() + enddef + def F35() + enddef + def F36() + enddef + def F37() + enddef + def F38() + enddef + def F39() + enddef + def F40() + enddef + def F41() + enddef + def F42() + enddef + def F43() + enddef + def F44() + enddef + def F45() + enddef + def F46() + enddef + def F47() + enddef + endclass + + A.new() + END + writefile(lines, 'Xscript', 'D') + g:RunMNV([], [], '-u NONE -S Xscript -c qa') + assert_equal(0, v:shell_error) +enddef + +" Test for 'final' class and object variables +def Test_final_class_object_variable() + # Test for changing a final object variable from an object function + var lines =<< trim END + mnv9script + class A + final foo: string = "abc" + def Foo() + this.foo = "def" + enddef + endclass + defcompile A.Foo + END + v9.CheckSourceFailure(lines, 'E1409: Cannot change read-only variable "foo" in class "A"', 1) + + # Test for changing a final object variable from the 'new' function + lines =<< trim END + mnv9script + class A + final s1: string + final s2: string + def new(this.s1) + this.s2 = 'def' + enddef + endclass + var a = A.new('abc') + assert_equal('abc', a.s1) + assert_equal('def', a.s2) + END + v9.CheckSourceSuccess(lines) + + # Test for a final class variable + lines =<< trim END + mnv9script + class A + static final s1: string = "abc" + endclass + assert_equal('abc', A.s1) + END + v9.CheckSourceSuccess(lines) + + # Test for changing a final class variable from a class function + lines =<< trim END + mnv9script + class A + static final s1: string = "abc" + static def Foo() + s1 = "def" + enddef + endclass + A.Foo() + END + v9.CheckSourceFailure(lines, 'E1409: Cannot change read-only variable "s1" in class "A"', 1) + + # Test for changing a public final class variable at script level + lines =<< trim END + mnv9script + class A + public static final s1: string = "abc" + endclass + assert_equal('abc', A.s1) + A.s1 = 'def' + END + v9.CheckSourceFailure(lines, 'E1409: Cannot change read-only variable "s1" in class "A"', 6) + + # Test for changing a public final class variable from a class function + lines =<< trim END + mnv9script + class A + public static final s1: string = "abc" + static def Foo() + s1 = "def" + enddef + endclass + A.Foo() + END + v9.CheckSourceFailure(lines, 'E1409: Cannot change read-only variable "s1" in class "A"', 1) + + # Test for changing a public final class variable from a function + lines =<< trim END + mnv9script + class A + public static final s1: string = "abc" + endclass + def Foo() + A.s1 = 'def' + enddef + defcompile + END + v9.CheckSourceFailure(lines, 'E1409: Cannot change read-only variable "s1" in class "A"', 1) + + # Test for using a final variable of composite type + lines =<< trim END + mnv9script + class A + public final l: list<number> + def new() + this.l = [1, 2] + enddef + def Foo() + this.l[0] = 3 + this.l->add(4) + enddef + endclass + var a = A.new() + assert_equal([1, 2], a.l) + a.Foo() + assert_equal([3, 2, 4], a.l) + END + v9.CheckSourceSuccess(lines) + + # Test for changing a final variable of composite type from another object + # function + lines =<< trim END + mnv9script + class A + public final l: list<number> = [1, 2] + def Foo() + this.l = [3, 4] + enddef + endclass + var a = A.new() + a.Foo() + END + v9.CheckSourceFailure(lines, 'E1409: Cannot change read-only variable "l" in class "A"', 1) + + # Test for modifying a final variable of composite type at script level + lines =<< trim END + mnv9script + class A + public final l: list<number> = [1, 2] + endclass + var a = A.new() + a.l[0] = 3 + a.l->add(4) + assert_equal([3, 2, 4], a.l) + END + v9.CheckSourceSuccess(lines) + + # Test for modifying a final variable of composite type from a function + lines =<< trim END + mnv9script + class A + public final l: list<number> = [1, 2] + endclass + def Foo() + var a = A.new() + a.l[0] = 3 + a.l->add(4) + assert_equal([3, 2, 4], a.l) + enddef + Foo() + END + v9.CheckSourceSuccess(lines) + + # Test for modifying a final variable of composite type from another object + # function + lines =<< trim END + mnv9script + class A + public final l: list<number> = [1, 2] + def Foo() + this.l[0] = 3 + this.l->add(4) + enddef + endclass + var a = A.new() + a.Foo() + assert_equal([3, 2, 4], a.l) + END + v9.CheckSourceSuccess(lines) + + # Test for assigning a new value to a final variable of composite type at + # script level + lines =<< trim END + mnv9script + class A + public final l: list<number> = [1, 2] + endclass + var a = A.new() + a.l = [3, 4] + END + v9.CheckSourceFailure(lines, 'E1409: Cannot change read-only variable "l" in class "A"', 6) + + # Test for assigning a new value to a final variable of composite type from + # another object function + lines =<< trim END + mnv9script + class A + public final l: list<number> = [1, 2] + def Foo() + this.l = [3, 4] + enddef + endclass + var a = A.new() + a.Foo() + END + v9.CheckSourceFailure(lines, 'E1409: Cannot change read-only variable "l" in class "A"', 1) + + # Test for assigning a new value to a final variable of composite type from + # another function + lines =<< trim END + mnv9script + class A + public final l: list<number> = [1, 2] + endclass + def Foo() + var a = A.new() + a.l = [3, 4] + enddef + Foo() + END + v9.CheckSourceFailure(lines, 'E1409: Cannot change read-only variable "l" in class "A"', 2) + + # Error case: Use 'final' with just a variable name + lines =<< trim END + mnv9script + class A + final foo + endclass + var a = A.new() + END + v9.CheckSourceFailure(lines, 'E1022: Type or initialization required', 3) + + # Error case: Use 'final' followed by 'public' + lines =<< trim END + mnv9script + class A + final public foo: number + endclass + var a = A.new() + END + v9.CheckSourceFailure(lines, 'E1022: Type or initialization required', 3) + + # Error case: Use 'final' followed by 'static' + lines =<< trim END + mnv9script + class A + final static foo: number + endclass + var a = A.new() + END + v9.CheckSourceFailure(lines, 'E1022: Type or initialization required', 3) + + # Error case: 'final' cannot be used in an interface + lines =<< trim END + mnv9script + interface A + final foo: number = 10 + endinterface + END + v9.CheckSourceFailure(lines, 'E1408: Final variable not supported in an interface', 3) + + # Error case: 'final' not supported for an object method + lines =<< trim END + mnv9script + class A + final def Foo() + enddef + endclass + END + v9.CheckSourceFailure(lines, 'E1022: Type or initialization required', 3) + + # Error case: 'final' not supported for a class method + lines =<< trim END + mnv9script + class A + static final def Foo() + enddef + endclass + END + v9.CheckSourceFailure(lines, 'E1022: Type or initialization required', 3) +enddef + +" Test for 'const' class and object variables +def Test_const_class_object_variable() + # Test for changing a const object variable from an object function + var lines =<< trim END + mnv9script + class A + const foo: string = "abc" + def Foo() + this.foo = "def" + enddef + endclass + defcompile A.Foo + END + v9.CheckSourceFailure(lines, 'E1409: Cannot change read-only variable "foo" in class "A"', 1) + + # Test for changing a const object variable from the 'new' function + lines =<< trim END + mnv9script + class A + const s1: string + const s2: string + def new(this.s1) + this.s2 = 'def' + enddef + endclass + var a = A.new('abc') + assert_equal('abc', a.s1) + assert_equal('def', a.s2) + END + v9.CheckSourceSuccess(lines) + + # Test for changing a const object variable from an object method called from + # the 'new' function + lines =<< trim END + mnv9script + class A + const s1: string = 'abc' + def new() + this.ChangeStr() + enddef + def ChangeStr() + this.s1 = 'def' + enddef + endclass + var a = A.new() + END + v9.CheckSourceFailure(lines, 'E1409: Cannot change read-only variable "s1" in class "A"', 1) + + # Test for a const class variable + lines =<< trim END + mnv9script + class A + static const s1: string = "abc" + endclass + assert_equal('abc', A.s1) + END + v9.CheckSourceSuccess(lines) + + # Test for changing a const class variable from a class function + lines =<< trim END + mnv9script + class A + static const s1: string = "abc" + static def Foo() + s1 = "def" + enddef + endclass + A.Foo() + END + v9.CheckSourceFailure(lines, 'E1409: Cannot change read-only variable "s1" in class "A"', 1) + + # Test for changing a public const class variable at script level + lines =<< trim END + mnv9script + class A + public static const s1: string = "abc" + endclass + assert_equal('abc', A.s1) + A.s1 = 'def' + END + v9.CheckSourceFailure(lines, 'E1409: Cannot change read-only variable "s1" in class "A"', 6) + + # Test for changing a public const class variable from a class function + lines =<< trim END + mnv9script + class A + public static const s1: string = "abc" + static def Foo() + s1 = "def" + enddef + endclass + A.Foo() + END + v9.CheckSourceFailure(lines, 'E1409: Cannot change read-only variable "s1" in class "A"', 1) + + # Test for changing a public const class variable from a function + lines =<< trim END + mnv9script + class A + public static const s1: string = "abc" + endclass + def Foo() + A.s1 = 'def' + enddef + defcompile + END + v9.CheckSourceFailure(lines, 'E1409: Cannot change read-only variable "s1" in class "A"', 1) + + # Test for changing a const List item from an object function + lines =<< trim END + mnv9script + class A + public const l: list<number> + def new() + this.l = [1, 2] + enddef + def Foo() + this.l[0] = 3 + enddef + endclass + var a = A.new() + assert_equal([1, 2], a.l) + a.Foo() + END + v9.CheckSourceFailure(lines, 'E1119: Cannot change locked list item', 1) + + # Test for adding a value to a const List from an object function + lines =<< trim END + mnv9script + class A + public const l: list<number> + def new() + this.l = [1, 2] + enddef + def Foo() + this.l->add(3) + enddef + endclass + var a = A.new() + a.Foo() + END + v9.CheckSourceFailure(lines, 'E741: Value is locked: add() argument', 1) + + # Test for reassigning a const List from an object function + lines =<< trim END + mnv9script + class A + public const l: list<number> = [1, 2] + def Foo() + this.l = [3, 4] + enddef + endclass + var a = A.new() + a.Foo() + END + v9.CheckSourceFailure(lines, 'E1409: Cannot change read-only variable "l" in class "A"', 1) + + # Test for changing a const List item at script level + lines =<< trim END + mnv9script + class A + public const l: list<number> = [1, 2] + endclass + var a = A.new() + a.l[0] = 3 + END + v9.CheckSourceFailure(lines, 'E741: Value is locked:', 6) + + # Test for adding a value to a const List item at script level + lines =<< trim END + mnv9script + class A + public const l: list<number> = [1, 2] + endclass + var a = A.new() + a.l->add(4) + END + v9.CheckSourceFailure(lines, 'E741: Value is locked:', 6) + + # Test for changing a const List item from a function + lines =<< trim END + mnv9script + class A + public const l: list<number> = [1, 2] + endclass + def Foo() + var a = A.new() + a.l[0] = 3 + enddef + Foo() + END + v9.CheckSourceFailure(lines, 'E1119: Cannot change locked list item', 2) + + # Test for adding a value to a const List item from a function + lines =<< trim END + mnv9script + class A + public const l: list<number> = [1, 2] + endclass + def Foo() + var a = A.new() + a.l->add(4) + enddef + Foo() + END + v9.CheckSourceFailure(lines, 'E741: Value is locked: add() argument', 2) + + # Test for changing a const List item from an object method + lines =<< trim END + mnv9script + class A + public const l: list<number> = [1, 2] + def Foo() + this.l[0] = 3 + enddef + endclass + var a = A.new() + a.Foo() + END + v9.CheckSourceFailure(lines, 'E1119: Cannot change locked list item', 1) + + # Test for adding a value to a const List item from an object method + lines =<< trim END + mnv9script + class A + public const l: list<number> = [1, 2] + def Foo() + this.l->add(4) + enddef + endclass + var a = A.new() + a.Foo() + END + v9.CheckSourceFailure(lines, 'E741: Value is locked: add() argument', 1) + + # Test for reassigning a const List object variable at script level + lines =<< trim END + mnv9script + class A + public const l: list<number> = [1, 2] + endclass + var a = A.new() + a.l = [3, 4] + END + v9.CheckSourceFailure(lines, 'E1409: Cannot change read-only variable "l" in class "A"', 6) + + # Test for reassigning a const List object variable from an object method + lines =<< trim END + mnv9script + class A + public const l: list<number> = [1, 2] + def Foo() + this.l = [3, 4] + enddef + endclass + var a = A.new() + a.Foo() + END + v9.CheckSourceFailure(lines, 'E1409: Cannot change read-only variable "l" in class "A"', 1) + + # Test for reassigning a const List object variable from another function + lines =<< trim END + mnv9script + class A + public const l: list<number> = [1, 2] + endclass + def Foo() + var a = A.new() + a.l = [3, 4] + enddef + Foo() + END + v9.CheckSourceFailure(lines, 'E1409: Cannot change read-only variable "l" in class "A"', 2) + + # Error case: Use 'const' with just a variable name + lines =<< trim END + mnv9script + class A + const foo + endclass + var a = A.new() + END + v9.CheckSourceFailure(lines, 'E1022: Type or initialization required', 3) + + # Error case: Use 'const' followed by 'public' + lines =<< trim END + mnv9script + class A + const public foo: number + endclass + var a = A.new() + END + v9.CheckSourceFailure(lines, 'E1022: Type or initialization required', 3) + + # Error case: Use 'const' followed by 'static' + lines =<< trim END + mnv9script + class A + const static foo: number + endclass + var a = A.new() + END + v9.CheckSourceFailure(lines, 'E1022: Type or initialization required', 3) + + # Error case: 'const' cannot be used in an interface + lines =<< trim END + mnv9script + interface A + const foo: number = 10 + endinterface + END + v9.CheckSourceFailure(lines, 'E1410: Const variable not supported in an interface', 3) + + # Error case: 'const' not supported for an object method + lines =<< trim END + mnv9script + class A + const def Foo() + enddef + endclass + END + v9.CheckSourceFailure(lines, 'E1022: Type or initialization required', 3) + + # Error case: 'const' not supported for a class method + lines =<< trim END + mnv9script + class A + static const def Foo() + enddef + endclass + END + v9.CheckSourceFailure(lines, 'E1022: Type or initialization required', 3) +enddef + +" Test for compiling class/object methods using :defcompile +def Test_defcompile_class() + # defcompile all the classes in the current script + var lines =<< trim END + mnv9script + class A + def Foo() + var i = 10 + enddef + endclass + class B + def Bar() + var i = 20 + xxx + enddef + endclass + defcompile + END + v9.CheckSourceFailure(lines, 'E476: Invalid command: xxx', 2) + + # defcompile a specific class + lines =<< trim END + mnv9script + class A + def Foo() + xxx + enddef + endclass + class B + def Bar() + yyy + enddef + endclass + defcompile B + END + v9.CheckSourceFailure(lines, 'E476: Invalid command: yyy', 1) + + # defcompile a non-class + lines =<< trim END + mnv9script + class A + def Foo() + enddef + endclass + var X: list<number> = [] + defcompile X + END + v9.CheckSourceFailure(lines, 'E1061: Cannot find function X', 7) + + # defcompile a class twice + lines =<< trim END + mnv9script + class A + def new() + enddef + endclass + defcompile A + defcompile A + assert_equal('Function A.new does not need compiling', v:statusmsg) + END + v9.CheckSourceSuccess(lines) + + # defcompile should not compile an imported class + lines =<< trim END + mnv9script + export class A + def Foo() + xxx + enddef + endclass + END + writefile(lines, 'Xdefcompileimport.mnv', 'D') + lines =<< trim END + mnv9script + + import './Xdefcompileimport.mnv' + class B + endclass + defcompile + END + v9.CheckScriptSuccess(lines) +enddef + +" Test for cases common to all the object builtin methods +def Test_object_builtin_method() + var lines =<< trim END + mnv9script + class A + def abc() + enddef + endclass + END + v9.CheckSourceFailure(lines, 'E1267: Function name must start with a capital: abc()', 3) + + for funcname in ["len", "string", "empty"] + lines =<< trim eval END + mnv9script + class A + static def {funcname}(): number + enddef + endclass + END + v9.CheckSourceFailure(lines, 'E1413: Builtin class method not supported', 3) + endfor +enddef + +" Test for using the empty() builtin method with an object +" This is a legacy function to use the test_garbagecollect_now() function. +func Test_object_empty() + let lines =<< trim END + mnv9script + class A + def empty(): bool + return true + enddef + endclass + + def Foo() + var afoo = A.new() + assert_equal(true, empty(afoo)) + assert_equal(true, afoo->empty()) + enddef + + var a = A.new() + assert_equal(1, empty(a)) + assert_equal(1, a->empty()) + test_garbagecollect_now() + assert_equal(1, empty(a)) + Foo() + test_garbagecollect_now() + Foo() + END + call v9.CheckSourceSuccess(lines) + + " empty() should return 1 without a builtin method + let lines =<< trim END + mnv9script + class A + endclass + + def Foo() + var afoo = A.new() + assert_equal(1, empty(afoo)) + enddef + + var a = A.new() + assert_equal(1, empty(a)) + Foo() + END + call v9.CheckSourceSuccess(lines) + + " Unsupported signature for the empty() method + let lines =<< trim END + mnv9script + class A + def empty() + enddef + endclass + END + call v9.CheckSourceFailure(lines, 'E1383: Method "empty": type mismatch, expected func(): bool but got func()', 4) + + " Error when calling the empty() method + let lines =<< trim END + mnv9script + class A + def empty(): bool + throw "Failed to check emptiness" + enddef + endclass + + def Foo() + var afoo = A.new() + var i = empty(afoo) + enddef + + var a = A.new() + assert_fails('empty(a)', 'Failed to check emptiness') + assert_fails('Foo()', 'Failed to check emptiness') + END + call v9.CheckSourceSuccess(lines) + + " call empty() using an object from a script + let lines =<< trim END + mnv9script + class A + def empty(): bool + return true + enddef + endclass + var afoo = A.new() + assert_equal(true, afoo.empty()) + END + call v9.CheckSourceSuccess(lines) + + " call empty() using an object from a method + let lines =<< trim END + mnv9script + class A + def empty(): bool + return true + enddef + endclass + def Foo() + var afoo = A.new() + assert_equal(true, afoo.empty()) + enddef + Foo() + END + call v9.CheckSourceSuccess(lines) + + " call empty() using "this" from an object method + let lines =<< trim END + mnv9script + class A + def empty(): bool + return true + enddef + def Foo(): bool + return this.empty() + enddef + endclass + def Bar() + var abar = A.new() + assert_equal(true, abar.Foo()) + enddef + Bar() + END + call v9.CheckSourceSuccess(lines) + + " Call empty() from a derived object + let lines =<< trim END + mnv9script + class A + def empty(): bool + return false + enddef + endclass + class B extends A + def empty(): bool + return true + enddef + endclass + def Foo(afoo: A) + assert_equal(true, empty(afoo)) + var bfoo = B.new() + assert_equal(true, empty(bfoo)) + enddef + var b = B.new() + assert_equal(1, empty(b)) + Foo(b) + END + call v9.CheckSourceSuccess(lines) + + " Invoking empty method using an interface + let lines =<< trim END + mnv9script + interface A + def empty(): bool + endinterface + class B implements A + def empty(): bool + return false + enddef + endclass + def Foo(a: A) + assert_equal(false, empty(a)) + enddef + var b = B.new() + Foo(b) + END + call v9.CheckSourceSuccess(lines) +endfunc + +" Test for using the len() builtin method with an object +" This is a legacy function to use the test_garbagecollect_now() function. +func Test_object_length() + let lines =<< trim END + mnv9script + class A + var mylen: number = 0 + def new(n: number) + this.mylen = n + enddef + def len(): number + return this.mylen + enddef + endclass + + def Foo() + var afoo = A.new(12) + assert_equal(12, len(afoo)) + assert_equal(12, afoo->len()) + enddef + + var a = A.new(22) + assert_equal(22, len(a)) + assert_equal(22, a->len()) + test_garbagecollect_now() + assert_equal(22, len(a)) + Foo() + test_garbagecollect_now() + Foo() + END + call v9.CheckSourceSuccess(lines) + + " len() should return 0 without a builtin method + let lines =<< trim END + mnv9script + class A + endclass + + def Foo() + var afoo = A.new() + assert_equal(0, len(afoo)) + enddef + + var a = A.new() + assert_equal(0, len(a)) + Foo() + END + call v9.CheckSourceSuccess(lines) + + " Unsupported signature for the len() method + let lines =<< trim END + mnv9script + class A + def len() + enddef + endclass + END + call v9.CheckSourceFailure(lines, 'E1383: Method "len": type mismatch, expected func(): number but got func()', 4) + + " Error when calling the len() method + let lines =<< trim END + mnv9script + class A + def len(): number + throw "Failed to compute length" + enddef + endclass + + def Foo() + var afoo = A.new() + var i = len(afoo) + enddef + + var a = A.new() + assert_fails('len(a)', 'Failed to compute length') + assert_fails('Foo()', 'Failed to compute length') + END + call v9.CheckSourceSuccess(lines) + + " call len() using an object from a script + let lines =<< trim END + mnv9script + class A + def len(): number + return 5 + enddef + endclass + var afoo = A.new() + assert_equal(5, afoo.len()) + END + call v9.CheckSourceSuccess(lines) + + " call len() using an object from a method + let lines =<< trim END + mnv9script + class A + def len(): number + return 5 + enddef + endclass + def Foo() + var afoo = A.new() + assert_equal(5, afoo.len()) + enddef + Foo() + END + call v9.CheckSourceSuccess(lines) + + " call len() using "this" from an object method + let lines =<< trim END + mnv9script + class A + def len(): number + return 8 + enddef + def Foo(): number + return this.len() + enddef + endclass + def Bar() + var abar = A.new() + assert_equal(8, abar.Foo()) + enddef + Bar() + END + call v9.CheckSourceSuccess(lines) + + " Call len() from a derived object + let lines =<< trim END + mnv9script + class A + def len(): number + return 10 + enddef + endclass + class B extends A + def len(): number + return 20 + enddef + endclass + def Foo(afoo: A) + assert_equal(20, len(afoo)) + var bfoo = B.new() + assert_equal(20, len(bfoo)) + enddef + var b = B.new() + assert_equal(20, len(b)) + Foo(b) + END + call v9.CheckSourceSuccess(lines) + + " Invoking len method using an interface + let lines =<< trim END + mnv9script + interface A + def len(): number + endinterface + class B implements A + def len(): number + return 123 + enddef + endclass + def Foo(a: A) + assert_equal(123, len(a)) + enddef + var b = B.new() + Foo(b) + END + call v9.CheckSourceSuccess(lines) +endfunc + +" Test for using the string() builtin method with an object +" This is a legacy function to use the test_garbagecollect_now() function. +func Test_object_string() + let lines =<< trim END + mnv9script + class A + var name: string + def string(): string + return this.name + enddef + endclass + + def Foo() + var afoo = A.new("foo-A") + assert_equal('foo-A', string(afoo)) + assert_equal('foo-A', afoo->string()) + enddef + + var a = A.new("script-A") + assert_equal('script-A', string(a)) + assert_equal('script-A', a->string()) + assert_equal(['script-A'], execute('echo a')->split("\n")) + test_garbagecollect_now() + assert_equal('script-A', string(a)) + Foo() + test_garbagecollect_now() + Foo() + END + call v9.CheckSourceSuccess(lines) + + " string() should return "object of A {}" without a builtin method + let lines =<< trim END + mnv9script + class A + endclass + + def Foo() + var afoo = A.new() + assert_equal('object of A {}', string(afoo)) + enddef + + var a = A.new() + assert_equal('object of A {}', string(a)) + Foo() + END + call v9.CheckSourceSuccess(lines) + + " Unsupported signature for the string() method + let lines =<< trim END + mnv9script + class A + def string() + enddef + endclass + END + call v9.CheckSourceFailure(lines, 'E1383: Method "string": type mismatch, expected func(): string but got func()', 4) + + " Error when calling the string() method + let lines =<< trim END + mnv9script + class A + def string(): string + throw "Failed to get text" + enddef + endclass + + def Foo() + var afoo = A.new() + var i = string(afoo) + enddef + + var a = A.new() + assert_fails('string(a)', 'Failed to get text') + assert_fails('Foo()', 'Failed to get text') + END + call v9.CheckSourceSuccess(lines) + + " call string() using an object from a script + let lines =<< trim END + mnv9script + class A + def string(): string + return 'A' + enddef + endclass + var afoo = A.new() + assert_equal('A', afoo.string()) + END + call v9.CheckSourceSuccess(lines) + + " call string() using an object from a method + let lines =<< trim END + mnv9script + class A + def string(): string + return 'A' + enddef + endclass + def Foo() + var afoo = A.new() + assert_equal('A', afoo.string()) + enddef + Foo() + END + call v9.CheckSourceSuccess(lines) + + " call string() using "this" from an object method + let lines =<< trim END + mnv9script + class A + def string(): string + return 'A' + enddef + def Foo(): string + return this.string() + enddef + endclass + def Bar() + var abar = A.new() + assert_equal('A', abar.string()) + enddef + Bar() + END + call v9.CheckSourceSuccess(lines) + + " Call string() from a derived object + let lines =<< trim END + mnv9script + class A + def string(): string + return 'A' + enddef + endclass + class B extends A + def string(): string + return 'B' + enddef + endclass + def Foo(afoo: A) + assert_equal('B', string(afoo)) + var bfoo = B.new() + assert_equal('B', string(bfoo)) + enddef + var b = B.new() + assert_equal('B', string(b)) + Foo(b) + END + call v9.CheckSourceSuccess(lines) + + " Invoking string method using an interface + let lines =<< trim END + mnv9script + interface A + def string(): string + endinterface + class B implements A + def string(): string + return 'B' + enddef + endclass + def Foo(a: A) + assert_equal('B', string(a)) + enddef + var b = B.new() + Foo(b) + END + call v9.CheckSourceSuccess(lines) +endfunc + +" Test for using the string() builtin method with an object's method +def Test_method_string() + var lines =<< trim END + mnv9script + class A + def F() + enddef + endclass + assert_match('function(''<SNR>\d\+_A\.F'')', string(A.new().F)) + END + v9.CheckScriptSuccess(lines) +enddef + +" Test for using a class in the class definition +def Test_Ref_Class_Within_Same_Class() + var lines =<< trim END + mnv9script + class A + var n: number = 0 + def Equals(other: A): bool + return this.n == other.n + enddef + endclass + + var a1 = A.new(10) + var a2 = A.new(10) + var a3 = A.new(20) + assert_equal(true, a1.Equals(a2)) + assert_equal(false, a2.Equals(a3)) + END + v9.CheckScriptSuccess(lines) + + lines =<< trim END + mnv9script + + class Foo + var num: number + def Clone(): Foo + return Foo.new(this.num) + enddef + endclass + + var f1 = Foo.new(1) + + def F() + var f2: Foo = f1.Clone() + assert_equal(false, f2 is f1) + assert_equal(true, f2.num == f1.num) + enddef + F() + + var f3: Foo = f1.Clone() + assert_equal(false, f3 is f1) + assert_equal(true, f3.num == f1.num) + END + v9.CheckScriptSuccess(lines) + + # Test for trying to use a class to extend when defining the same class + lines =<< trim END + mnv9script + class A extends A + endclass + END + v9.CheckScriptFailure(lines, 'E1354: Cannot extend A', 3) + + # Test for trying to use a class to implement when defining the same class + lines =<< trim END + mnv9script + class A implements A + endclass + END + v9.CheckScriptFailure(lines, 'E1347: Not a valid interface: A', 3) +enddef + +" Test for comparing a class referencing itself +def Test_Object_Compare_With_Recursive_Class_Ref() + var lines =<< trim END + mnv9script + + class C + public var nest: C + endclass + + var o1 = C.new() + o1.nest = o1 + + var result = o1 == o1 + assert_equal(true, result) + END + v9.CheckScriptSuccess(lines) + + lines =<< trim END + mnv9script + + class C + public var nest: C + endclass + var o1 = C.new() + var o2 = C.new(C.new()) + + var result = o1 == o2 + assert_equal(false, result) + END + v9.CheckScriptSuccess(lines) + + lines =<< trim END + mnv9script + class C + var nest1: C + var nest2: C + def Init(n1: C, n2: C) + this.nest1 = n1 + this.nest2 = n2 + enddef + endclass + + var o1 = C.new() + var o2 = C.new() + o1.Init(o1, o2) + o2.Init(o2, o1) + + var result = o1 == o2 + assert_equal(true, result) + END + v9.CheckScriptSuccess(lines) +enddef + +" Test for comparing a class with nesting objects +def Test_Object_Compare_With_Nesting_Objects() + # On a compare, after mnv equal recurses 1000 times, not finding an unequal, + # return the compare is equal. + # Test that limit + + var lines =<< trim END + mnv9script + class C + public var n: number + public var nest: C + + # Create a "C" that chains/nests to indicated depth. + # return {head: firstC, tail: lastC} + static def CreateNested(depth: number): dict<C> + var first = C.new(1, null_object) + var last = first + for i in range(2, depth) + last.nest = C.new(i, null_object) + last = last.nest + endfor + return {head: first, tail: last} + enddef + + # Return pointer to nth item in chain. + def GetLink(depth: number): C + var count = 1 + var p: C = this + while count < depth + p = p.nest + if p == null + throw "too deep" + endif + count += 1 + endwhile + return p + enddef + + # Return the length of the chain + def len(): number + var count = 1 + var p: C = this + while p.nest != null + p = p.nest + count += 1 + endwhile + return count + enddef + endclass + + var chain = C.CreateNested(3) + var s = "object of C {n: 1, nest: object of C {n: 2, nest: object of C {n: 3, nest: object of [unknown]}}}" + assert_equal(s, string(chain.head)) + assert_equal(3, chain.head->len()) + + var chain1 = C.CreateNested(100) + var chain2 = C.CreateNested(100) + assert_true(chain1.head == chain2.head) + + # modify the tail of chain2, compare not equal + chain2.tail.n = 123456 + assert_true(chain1.head != chain2.head) + + # a tail of a different length compares not equal + chain2 = C.CreateNested(101) + assert_true(chain1.head != chain2.head) + + chain1 = C.CreateNested(1000) + chain2 = C.CreateNested(1000) + assert_true(chain1.head == chain2.head) + + # modify the tail of chain2, compare not equal + chain2.tail.n = 123456 + assert_true(chain1.head != chain2.head) + + # try a chain longer that the limit + chain1 = C.CreateNested(1001) + chain2 = C.CreateNested(1001) + assert_true(chain1.head == chain2.head) + + # modify the tail, but still equal + chain2.tail.n = 123456 + assert_true(chain1.head == chain2.head) + + # remove 2 items from front, shorten the chain by two. + chain1.head = chain1.head.GetLink(3) + chain2.head = chain2.head.GetLink(3) + assert_equal(3, chain1.head.n) + assert_equal(3, chain2.head.n) + assert_equal(999, chain1.head->len()) + assert_equal(999, chain2.head->len()) + # Now less than the limit, compare not equal + assert_true(chain1.head != chain2.head) + END + v9.CheckScriptSuccess(lines) +enddef + +" Test for using a compound operator from a lambda function in an object method +def Test_compound_op_in_objmethod_lambda() + # Test using the "+=" operator + var lines =<< trim END + mnv9script + class A + var n: number = 10 + def Foo() + var Fn = () => { + this.n += 1 + } + Fn() + enddef + endclass + + var a = A.new() + a.Foo() + assert_equal(11, a.n) + END + v9.CheckScriptSuccess(lines) + + # Test using the "..=" operator + lines =<< trim END + mnv9script + class A + var s: string = "a" + def Foo() + var Fn = () => { + this.s ..= "a" + } + Fn() + enddef + endclass + + var a = A.new() + a.Foo() + a.Foo() + assert_equal("aaa", a.s) + END + v9.CheckScriptSuccess(lines) +enddef + +" Test for using test_refcount() with a class and an object +def Test_class_object_refcount() + var lines =<< trim END + mnv9script + class A + endclass + var a: A = A.new() + assert_equal(2, test_refcount(A)) + assert_equal(1, test_refcount(a)) + var b = a + assert_equal(2, test_refcount(A)) + assert_equal(2, test_refcount(a)) + assert_equal(2, test_refcount(b)) + END + v9.CheckScriptSuccess(lines) +enddef + +" call a lambda function in one object from another object +def Test_lambda_invocation_across_classes() + var lines =<< trim END + mnv9script + class A + var s: string = "foo" + def GetFn(): func + var Fn = (): string => { + return this.s + } + return Fn + enddef + endclass + + class B + var s: string = "bar" + def GetFn(): func + var a = A.new() + return a.GetFn() + enddef + endclass + + var b = B.new() + var Fn = b.GetFn() + assert_equal("foo", Fn()) + END + v9.CheckScriptSuccess(lines) +enddef + +" Test for using a class member which is an object of the current class +def Test_current_class_object_class_member() + var lines =<< trim END + mnv9script + class A + public static var obj1: A = A.new(10) + var n: number + endclass + defcompile + assert_equal(10, A.obj1.n) + END + v9.CheckScriptSuccess(lines) +enddef + +" Test for updating a base class variable from a base class method without the +" class name. This used to crash MNV (Github issue #14352). +def Test_use_base_class_variable_from_base_class_method() + var lines =<< trim END + mnv9script + + class DictKeyClass + static var _obj_id_count = 1 + def _GenerateKey() + _obj_id_count += 1 + enddef + static def GetIdCount(): number + return _obj_id_count + enddef + endclass + + class C extends DictKeyClass + def F() + this._GenerateKey() + enddef + endclass + + C.new().F() + assert_equal(2, DictKeyClass.GetIdCount()) + END + v9.CheckScriptSuccess(lines) +enddef + +" Test for accessing protected funcref object and class variables +def Test_protected_funcref() + # protected funcref object variable + var lines =<< trim END + mnv9script + class Test1 + const _Id: func(any): any = (v) => v + endclass + var n = Test1.new()._Id(1) + END + v9.CheckScriptFailure(lines, 'E1333: Cannot access protected variable "_Id" in class "Test1"', 5) + + # protected funcref class variable + lines =<< trim END + mnv9script + class Test2 + static const _Id: func(any): any = (v) => v + endclass + var n = Test2._Id(2) + END + v9.CheckScriptFailure(lines, 'E1333: Cannot access protected variable "_Id" in class "Test2"', 5) +enddef + +" Test for using lambda block in classes +def Test_lambda_block_in_class() + # This used to crash MNV + var lines =<< trim END + mnv9script + class IdClass1 + const Id: func(number): number = (num: number): number => { + # Return a ID + return num * 10 + } + endclass + var id = IdClass1.new() + assert_equal(20, id.Id(2)) + END + v9.CheckScriptSuccess(lines) + + # This used to crash MNV + lines =<< trim END + mnv9script + class IdClass2 + static const Id: func(number): number = (num: number): number => { + # Return a ID + return num * 2 + } + endclass + assert_equal(16, IdClass2.Id(8)) + END + v9.CheckScriptSuccess(lines) +enddef + +" Test for defcompiling an abstract method +def Test_abstract_method_defcompile() + # Compile an abstract class with abstract object methods + var lines =<< trim END + mnv9script + abstract class A + abstract def Foo(): string + abstract def Bar(): list<string> + endclass + defcompile + END + v9.CheckScriptSuccess(lines) + + # Compile a concrete object method in an abstract class + lines =<< trim END + mnv9script + abstract class A + abstract def Foo(): string + abstract def Bar(): list<string> + def Baz(): string + pass + enddef + endclass + defcompile + END + v9.CheckScriptFailure(lines, 'E476: Invalid command: pass', 1) + + # Compile a concrete class method in an abstract class + lines =<< trim END + mnv9script + abstract class A + abstract def Foo(): string + abstract def Bar(): list<string> + static def Baz(): string + pass + enddef + endclass + defcompile + END + v9.CheckScriptFailure(lines, 'E476: Invalid command: pass', 1) +enddef + +" Test for defining a class in a function +def Test_class_definition_in_a_function() + var lines =<< trim END + mnv9script + def Foo() + class A + endclass + enddef + defcompile + END + v9.CheckScriptFailure(lines, 'E1429: Class can only be used in a script', 1) +enddef + +" Test for using [] with a class and an object +def Test_class_object_index() + var lines =<< trim END + mnv9script + class A + endclass + A[10] = 1 + END + v9.CheckScriptFailure(lines, 'E689: Index not allowed after a class: A[10] = 1', 4) + + lines =<< trim END + mnv9script + class A + endclass + var a = A.new() + a[10] = 1 + END + v9.CheckScriptFailure(lines, 'E689: Index not allowed after a object: a[10] = 1', 5) +enddef + +def Test_class_member_init_typecheck() + # Ensure the class member is assigned its declared type. + var lines =<< trim END + mnv9script + class S + static var l: list<string> = [] + endclass + S.l->add(123) + END + v9.CheckScriptFailure(lines, 'E1012: Type mismatch; expected string but got number', 5) + + # Ensure the initializer value and the declared type match. + lines =<< trim END + mnv9script + class S + var l: list<string> = [1, 2, 3] + endclass + var o = S.new() + END + v9.CheckScriptFailure(lines, 'E1382: Variable "l": type mismatch, expected list<string> but got list<number>') + + # Ensure the class member is assigned its declared type. + lines =<< trim END + mnv9script + class S + var l: list<string> = [] + endclass + var o = S.new() + o.l->add(123) + END + v9.CheckScriptFailure(lines, 'E1012: Type mismatch; expected string but got number', 6) +enddef + +def Test_class_cast() + var lines =<< trim END + mnv9script + class A + endclass + class B extends A + var mylen: number + endclass + def F(o: A): number + return (<B>o).mylen + enddef + + defcompile F + END + v9.CheckScriptSuccess(lines) +enddef + +" Test for using a variable of type "any" with an object +def Test_any_obj_var_type() + var lines =<< trim END + mnv9script + class A + var name: string = "foobar" + def Foo(): string + return "func foo" + enddef + endclass + + def CheckVals(x: any) + assert_equal("foobar", x.name) + assert_equal("func foo", x.Foo()) + enddef + + var a = A.new() + CheckVals(a) + END + v9.CheckScriptSuccess(lines) + + # Try to set a non-existing variable + lines =<< trim END + mnv9script + class A + var name: string = "foobar" + endclass + + def SetNonExistingVar(x: any) + x.bar = [1, 2, 3] + enddef + + var a = A.new() + SetNonExistingVar(a) + END + v9.CheckScriptFailure(lines, 'E1326: Variable "bar" not found in object "A"', 1) + + # Try to read a non-existing variable + lines =<< trim END + mnv9script + class A + var name: string = "foobar" + endclass + + def GetNonExistingVar(x: any) + var i: dict<any> = x.bar + enddef + + var a = A.new() + GetNonExistingVar(a) + END + v9.CheckScriptFailure(lines, 'E1326: Variable "bar" not found in object "A"', 1) + + # Try to invoke a non-existing method + lines =<< trim END + mnv9script + class A + def Foo(): number + return 10 + enddef + endclass + + def CallNonExistingMethod(x: any) + var i: number = x.Bar() + enddef + + var a = A.new() + CallNonExistingMethod(a) + END + v9.CheckScriptFailure(lines, 'E1326: Variable "Bar" not found in object "A"', 1) + + # Use an object which is a Dict value + lines =<< trim END + mnv9script + class Foo + def Bar(): number + return 369 + enddef + endclass + + def GetValue(FooDict: dict<any>): number + var n: number = 0 + for foo in values(FooDict) + n += foo.Bar() + endfor + return n + enddef + + var d = {'x': Foo.new()} + assert_equal(369, GetValue(d)) + END + v9.CheckScriptSuccess(lines) + + # Nested data. Object containing a Dict containing another Object. + lines =<< trim END + mnv9script + class Context + public var state: dict<any> = {} + endclass + + class Metadata + public var value = 0 + endclass + + var ctx = Context.new() + ctx.state["meta"] = Metadata.new(2468) + + const foo = ctx.state.meta.value + + def F(): number + const bar = ctx.state.meta.value + return bar + enddef + + assert_equal(2468, F()) + END + v9.CheckScriptSuccess(lines) + + # Accessing an object from a method inside the class using any type + lines =<< trim END + mnv9script + class C + def _G(): string + return '_G' + enddef + static def S(o_any: any): string + return o_any._G() + enddef + endclass + + var o1 = C.new() + assert_equal('_G', C.S(o1)) + END + v9.CheckScriptSuccess(lines) + + # Modifying an object protected variable from a method in another class using + # any type + lines =<< trim END + mnv9script + + class A + var num = 10 + endclass + + class B + def SetVal(x: any) + x.num = 20 + enddef + endclass + + var a = A.new() + var b = B.new() + b.SetVal(a) + END + v9.CheckScriptFailure(lines, 'E1335: Variable "num" in class "A" is not writable', 1) + + # Accessing a object protected variable from a method in another class using + # any type + lines =<< trim END + mnv9script + + class A + var _num = 10 + endclass + + class B + def GetVal(x: any): number + return x._num + enddef + endclass + + var a = A.new() + var b = B.new() + var i = b.GetVal(a) + END + v9.CheckScriptFailure(lines, 'E1333: Cannot access protected variable "_num" in class "A"', 1) + + # Accessing an object returned from an imported function and class + lines =<< trim END + mnv9script + export class Foo + public var name: string + endclass + + export def ReturnFooObject(): Foo + var r = Foo.new('star') + return r + enddef + END + writefile(lines, 'Xanyvar1.mnv', 'D') + + lines =<< trim END + mnv9script + + import './Xanyvar1.mnv' + + def GetName(): string + var whatever = Xanyvar1.ReturnFooObject() + return whatever.name + enddef + + assert_equal('star', GetName()) + END + v9.CheckScriptSuccess(lines) + + # Try to modify a protected object variable using a variable of type "any" + lines =<< trim END + mnv9script + + class Foo + var n: number = 10 + endclass + def Fn(x: any) + x.n = 20 + enddef + var a = Foo.new() + Fn(a) + END + v9.CheckScriptFailure(lines, 'E1335: Variable "n" in class "Foo" is not writable', 1) + + # Try to read a protected object variable using a variable of type "any" + lines =<< trim END + mnv9script + + class Foo + var _n: number = 10 + endclass + def Fn(x: any): number + return x._n + enddef + + var a = Foo.new() + Fn(a) + END + v9.CheckScriptFailure(lines, 'E1333: Cannot access protected variable "_n" in class "Foo"', 1) + + # Read a protected object variable using a variable of type "any" in an object + # method + lines =<< trim END + mnv9script + + class Foo + var _n: number = 10 + def Fn(x: any): number + return x._n + enddef + endclass + + var a = Foo.new() + assert_equal(10, a.Fn(a)) + END + v9.CheckScriptSuccess(lines) + + # Try to call a protected object method using a "any" type variable + lines =<< trim END + mnv9script + + class Foo + def _GetVal(): number + return 234 + enddef + endclass + def Fn(x: any): number + return x._GetVal() + enddef + + var a = Foo.new() + Fn(a) + END + v9.CheckScriptFailure(lines, 'E1366: Cannot access protected method: _GetVal', 1) + + # Call a protected object method using a "any" type variable from another + # object method + lines =<< trim END + mnv9script + + class Foo + def _GetVal(): number + return 234 + enddef + def FooVal(x: any): number + return x._GetVal() + enddef + endclass + + var a = Foo.new() + assert_equal(234, a.FooVal(a)) + END + v9.CheckScriptSuccess(lines) + + # Method chaining + lines =<< trim END + mnv9script + + export class T + var id: number = 268 + def F(): any + return this + enddef + endclass + + def H() + var a = T.new().F().F() + assert_equal(268, a.id) + enddef + H() + + var b: T = T.new().F().F() + assert_equal(268, b.id) + END + v9.CheckScriptSuccess(lines) + + # Using a null object to access a member variable + lines =<< trim END + mnv9script + def Fn(x: any): number + return x.num + enddef + + Fn(null_object) + END + v9.CheckScriptFailure(lines, 'E1360: Using a null object', 1) + + # Using a null object to invoke a method + lines =<< trim END + mnv9script + def Fn(x: any) + x.Foo() + enddef + + Fn(null_object) + END + v9.CheckScriptFailure(lines, 'E1360: Using a null object', 1) + + # Try to change a const object variable using a "any" variable + lines =<< trim END + mnv9script + class A + public const v1: number = 123 + endclass + + def Fn(o: any) + o.v1 = 321 + enddef + + var a = A.new() + Fn(a) + END + v9.CheckScriptFailure(lines, 'E1409: Cannot change read-only variable "v1" in class "A"', 1) + + # Try to change a final object variable using a "any" variable + lines =<< trim END + mnv9script + class A + public final v1: number = 123 + endclass + + def Fn(o: any) + o.v1 = 321 + enddef + + var a = A.new() + Fn(a) + END + v9.CheckScriptFailure(lines, 'E1409: Cannot change read-only variable "v1" in class "A"', 1) + + # Assign a different type of value to an "any" type object variable + lines =<< trim END + mnv9script + class A + public var v1: list<any> = [1, 2] + endclass + + def Fn(o: A) + o.v1 = 'abc' + enddef + + var a = A.new() + Fn(a) + END + v9.CheckScriptFailure(lines, 'E1012: Type mismatch; expected list<any> but got string', 1) +enddef + +" Test for using an object method with mapnew() +def Test_mapnew_with_instance_method() + var lines =<< trim END + mnv9script + + class Foo + var str: string + var nums: list<number> = [1, 2, 3] + + def InstanceMethod(n: number): string + return this.str .. n + enddef + + def MapperMethod(idx: number, elem: number): string + return elem->this.InstanceMethod() + enddef + + def MapTest() + this.str = "foo" + var l = ['foo1', 'foo2', 'foo3'] + assert_equal(l, this.nums->mapnew(this.MapperMethod)) + enddef + endclass + + Foo.new().MapTest() + END + v9.CheckSourceSuccess(lines) + + # Error in the mapnew() function + lines =<< trim END + mnv9script + + class Foo + var str: string + var nums: list<number> = [1, 2, 3] + + def InstanceMethod(n: number): string + throw "InstanceMethod failed" + enddef + + def MapperMethod(idx: number, elem: number): string + return elem->this.InstanceMethod() + enddef + + def MapTest() + this.str = "foo" + var caught_exception: bool = false + try + this.nums->mapnew(this.MapperMethod) + catch /InstanceMethod failed/ + caught_exception = true + endtry + assert_true(caught_exception) + enddef + endclass + + Foo.new().MapTest() + END + v9.CheckSourceSuccess(lines) +enddef + +" Test for using an object method in a method call. +def Test_use_object_method_in_a_method_call() + var lines =<< trim END + mnv9script + + class Foo + def Cost(nums: list<number>): number + return nums[0] * nums[1] + enddef + + def ShowCost(): string + var g = [4, 5] + return $"Cost is: {g->this.Cost()}" + enddef + endclass + + var d = Foo.new() + assert_equal('Cost is: 20', d.ShowCost()) + END + v9.CheckSourceSuccess(lines) + + # Test for using a non-existing object method in string interpolation + lines =<< trim END + mnv9script + + class Foo + def Cost(nums: list<number>): number + return nums[0] * nums[1] + enddef + + def ShowCost(): string + var g = [4, 5] + echo $"Cost is: {g->this.NewCost()}" + enddef + endclass + + var d = Foo.new() + d.ShowCost() + END + v9.CheckSourceFailure(lines, 'E1326: Variable "NewCost" not found in object "Foo"') +enddef + +" Test for referencing an object variable which is not yet initialized +def Test_uninitialized_object_var() + var lines =<< trim END + mnv9script + class Foo + const two: number = Foo.Two(this) + const one: number = 1 + + static def Two(that: Foo): number + return that.one + 2 + enddef + endclass + + echo Foo.Two(Foo.new()) + END + v9.CheckSourceFailure(lines, "E1430: Uninitialized object variable 'one' referenced") + + lines =<< trim END + mnv9script + class Foo + const one: number = Foo.One(this) + + static def One(that: Foo): number + return 1 + enddef + endclass + + assert_equal(1, Foo.One(Foo.new())) + END + v9.CheckSourceSuccess(lines) + + lines =<< trim END + mnv9script + class Foo + const one: number = 1 + const two: number = Foo.Two(this) + + static def Two(that: Foo): number + return that.one + 1 + enddef + endclass + + assert_equal(2, Foo.Two(Foo.new())) + END + v9.CheckSourceSuccess(lines) + + lines =<< trim END + mnv9script + class Foo + const Id: func(any): any = ((_) => (v) => v)(this) + + static def Id(that: Foo): func(any): any + return that.Id + enddef + endclass + + assert_equal(5, Foo.Id(Foo.new())(5)) + assert_equal(7, Foo.new().Id(7)) + END + v9.CheckSourceSuccess(lines) + + lines =<< trim END + mnv9script + class Foo + const Id: func(any): any = ((that) => (_) => that)(this) + + static def Id(that: Foo): func(any): any + return that.Id + enddef + endclass + + const Id0: func(any): any = Foo.Id(Foo.new()) + const Id1: func(any): any = Foo.new().Id + END + v9.CheckSourceSuccess(lines) + + lines =<< trim END + mnv9script + class Foo + const Id: any = Foo.Id(this) + + static def Id(that: Foo): any + return that.Id + enddef + endclass + + const Id2: any = Foo.Id(Foo.new()) + const Id3: any = Foo.new().Id + END + v9.CheckSourceFailure(lines, "E1430: Uninitialized object variable 'Id' referenced") + + lines =<< trim END + mnv9script + + class Foo + var x: string = '' + var Y: func(): string = () => this.x + endclass + + var foo = Foo.new('ok') + assert_equal('ok', foo.Y()) + END + v9.CheckSourceSuccess(lines) + + lines =<< trim END + mnv9script + + class Foo + var x: string = this.x + endclass + + var foo = Foo.new('ok') + END + v9.CheckSourceFailure(lines, "E1430: Uninitialized object variable 'x' referenced") +enddef + +" Test for initializing member variables of compound type in the constructor +def Test_constructor_init_compound_member_var() + var lines =<< trim END + mnv9script + + class Foo + var v1: string = "aaa" + var v2: list<number> = [1, 2] + var v3: dict<string> = {a: 'a', b: 'b'} + endclass + + class Bar + var v4: string = "bbb" + var v5: Foo = Foo.new() + var v6: list<number> = [1, 2] + endclass + + var b: Bar = Bar.new() + assert_equal("aaa", b.v5.v1) + assert_equal([1, 2], b.v5.v2) + assert_equal({a: 'a', b: 'b'}, b.v5.v3) + assert_equal("bbb", b.v4) + assert_equal([1, 2], b.v6) + END + v9.CheckSourceSuccess(lines) +enddef + +" Test for using a concrete method in an abstract extended class which is +" further extended +def Test_abstract_method_across_hierarchy() + var lines =<< trim END + mnv9script + + abstract class A + abstract def Foo(): string + endclass + + abstract class B extends A + abstract def Bar(): string + endclass + + class C extends B + def Foo(): string + return 'foo' + enddef + + def Bar(): string + return 'bar' + enddef + endclass + + def Fn1(a: A): string + return a.Foo() + enddef + + def Fn2(b: B): string + return b.Bar() + enddef + + var c = C.new() + assert_equal('foo', Fn1(c)) + assert_equal('bar', Fn2(c)) + END + v9.CheckSourceSuccess(lines) + + lines =<< trim END + mnv9script + + abstract class A + abstract def Foo(): string + endclass + + abstract class B extends A + abstract def Bar(): string + endclass + + class C extends B + def Bar(): string + return 'bar' + enddef + endclass + + defcompile + END + v9.CheckSourceFailure(lines, 'E1373: Abstract method "Foo" is not implemented') + + lines =<< trim END + mnv9script + + abstract class A + abstract def M1(): string + abstract def M2(): string + endclass + + abstract class B extends A + def M1(): string + return 'B: M1' + enddef + + def M2(): string + return 'B: M2' + enddef + endclass + + class C1 extends B + def M1(): string + return 'C1: M1' + enddef + endclass + + class C2 extends B + def M2(): string + return 'C2: M2' + enddef + endclass + + class D1 extends C1 + endclass + + class D2 extends C2 + endclass + + var l: list<string> = [] + for Type in ['C1', 'C2', 'D1', 'D2'] + l->add(eval($'{Type}.new().M1()')) + l->add(eval($'{Type}.new().M2()')) + endfor + assert_equal(['C1: M1', 'B: M2', 'B: M1', 'C2: M2', 'C1: M1', 'B: M2', 'B: M1', 'C2: M2'], l) + END + v9.CheckSourceSuccess(lines) + + lines =<< trim END + mnv9script + + abstract class A + abstract def M1(): string + abstract def M2(): string + endclass + + class B extends A + def M1(): string + return 'B: M1' + enddef + + def M2(): string + return 'B: M2' + enddef + endclass + + abstract class C extends B + endclass + + class D1 extends C + def M1(): string + return 'D1: M1' + enddef + endclass + + class D2 extends C + def M2(): string + return 'D2: M2' + enddef + endclass + + class E1 extends D1 + endclass + + class E2 extends D2 + endclass + + var l: list<string> = [] + for Type in ['B', 'D1', 'D2', 'E1', 'E2'] + l->add(eval($'{Type}.new().M1()')) + l->add( eval($'{Type}.new().M2()')) + endfor + assert_equal(['B: M1', 'B: M2', 'D1: M1', 'B: M2', 'B: M1', 'D2: M2', 'D1: M1', 'B: M2', 'B: M1', 'D2: M2'], l) + END + v9.CheckSourceSuccess(lines) +enddef + +" Test for using a protected new() method (singleton design pattern) +def Test_protected_new_method() + var lines =<< trim END + mnv9script + class A + def _new() + enddef + endclass + var a = A.new() + END + v9.CheckSourceFailure(lines, 'E1325: Method "new" not found in class "A"', 6) + + lines =<< trim END + mnv9script + class A + static var _instance: A + static var handler: func = A._Internal + var str: string + def _new(str: string) + this.str = str + enddef + static def _Internal(): string + return "test" + enddef + static def GetInstance(str: string): A + if _instance == null + _instance = A._new(str) + endif + return _instance + enddef + endclass + var a: A = A.GetInstance('foo') + var b: A = A.GetInstance('bar') + assert_equal('foo', a.str) + assert_equal('foo', b.str) + assert_equal('test', A.handler()) + END + v9.CheckSourceSuccess(lines) + + lines =<< trim END + mnv9script + enum Test + A, + B, + C + + static var handler: func = Test._Internal + + static def _Internal(): string + return "test" + enddef + endenum + assert_equal('test', Test.handler()) + END + v9.CheckSourceSuccess(lines) +enddef + +" Test for using 'super' in a closure function inside an object method +def Test_super_in_closure() + var lines =<< trim END + mnv9script + + class A + const _value: number + + def Fn(): func(any): number + return (_: any) => this._value + enddef + endclass + + class B extends A + def Fn(): func(any): number + return (_: any) => super._value + enddef + endclass + + assert_equal(100, A.new(100).Fn()(null)) + assert_equal(200, B.new(200).Fn()(null)) + END + v9.CheckSourceSuccess(lines) +enddef + +" Test for using 'super' to access methods and variables +def Test_super_keyword() + var lines =<< trim END + mnv9script + class Base + var name: string + def ToString(): string + return this.name + enddef + endclass + + class Child extends Base + var age: number + def ToString(): string + return super.ToString() .. ': ' .. this.age + enddef + endclass + + var o = Child.new('John', 42) + assert_equal('John: 42', o.ToString()) + END + v9.CheckSourceSuccess(lines) + + lines =<< trim END + mnv9script + class Child + var age: number + def ToString(): string + return super .ToString() .. ': ' .. this.age + enddef + endclass + var o = Child.new(42) + echo o.ToString() + END + v9.CheckSourceFailure(lines, 'E1356: "super" must be followed by a dot', 1) + + lines =<< trim END + mnv9script + class Base + var name: string + def ToString(): string + return this.name + enddef + endclass + + var age = 42 + def ToString(): string + return super.ToString() .. ': ' .. age + enddef + echo ToString() + END + v9.CheckSourceFailure(lines, 'E1357: Using "super" not in a class method', 1) + + lines =<< trim END + mnv9script + class Child + var age: number + def ToString(): string + return super.ToString() .. ': ' .. this.age + enddef + endclass + var o = Child.new(42) + echo o.ToString() + END + v9.CheckSourceFailure(lines, 'E1358: Using "super" not in a child class', 1) + + # Using super, Child invokes Base method which has optional arg. #12471 + lines =<< trim END + mnv9script + + class Base + var success: bool = false + def Method(arg = 0) + this.success = true + enddef + endclass + + class Child extends Base + def new() + super.Method() + enddef + endclass + + var obj = Child.new() + assert_equal(true, obj.success) + END + v9.CheckSourceSuccess(lines) + + # Using 'super' to access an object variable in the parent + lines =<< trim END + mnv9script + + class A + var foo: string = 'xxx' + endclass + + class B extends A + def GetString(): string + return super.foo + enddef + endclass + + var b: B = B.new() + echo b.GetString() + END + v9.CheckSourceSuccess(lines) + + # Using 'super' to access an static class variable in the parent should fail + lines =<< trim END + mnv9script + + class A + static var foo: string = 'xxx' + endclass + + class B extends A + def GetString(): string + return super.foo + enddef + endclass + + defcompile + END + v9.CheckSourceFailure(lines, 'E1326: Variable "foo" not found in object "B"') + + # Using super to access an overridden method in the parent class + lines =<< trim END + mnv9script + + class A + def Foo(): string + return 'A.Foo' + enddef + endclass + + class B extends A + def Foo(): string + return 'B.Foo' + enddef + + def Bar(): string + return $'{super.Foo()} {this.Foo()}' + enddef + endclass + + var b = B.new() + assert_equal('A.Foo B.Foo', b.Bar()) + END + v9.CheckSourceSuccess(lines) + + # Test for using super in a lambda function to invoke a base class method from + # the new() method. + lines =<< trim END + mnv9script + + def G(F: func): string + return F() + enddef + + class Base + def F(): string + return 'Base.F()' + enddef + endclass + + class Foo extends Base + var s: string = 'x' + def new() + this.s = G((): string => { + return super.F() + }) + enddef + endclass + + var f = Foo.new() + assert_equal('Base.F()', f.s) + END + v9.CheckSourceSuccess(lines) +enddef + +" Test for using a list of objects +def Test_method_call_from_list_of_objects() + var lines =<< trim END + mnv9script + + class A + var n: list<number> = [100, 101] + def F(): string + return 'A.F' + enddef + endclass + + class B + var name: string + var n: list<number> = [200, 201] + def new(this.name) + enddef + def F(): string + return 'B.F' + enddef + endclass + + var obj1 = A.new() + var obj2 = B.new('b1') + + def CheckObjectList() + var objlist = [obj1, obj2] + assert_equal('list<object<any>>', typename(objlist)) + + # Use a member function + assert_equal('A.F', objlist[0].F()) + assert_equal('B.F', objlist[1].F()) + + # Use a member variable on the RHS + assert_equal([100, 101], objlist[0].n) + assert_equal([200, 201], objlist[1].n) + + # Use a member variable on the LHS + objlist[0].n[1] = 110 + objlist[1].n[1] = 210 + assert_equal([100, 110], objlist[0].n) + assert_equal([200, 210], objlist[1].n) + + # Iterate using a for loop + var s1 = [] + for o in objlist + add(s1, o.F()) + endfor + assert_equal(['A.F', 'B.F'], s1) + + # Iterate using foreach() + var s2 = [] + foreach(objlist, (k, v) => add(s2, v.F())) + assert_equal(['A.F', 'B.F'], s2) + + # Add a new list item + objlist->add(B.new('b2')) + assert_equal('b2', objlist[2].name) + enddef + + CheckObjectList() + + var objlist = [A.new(), B.new('b2')] + assert_equal('list<object<any>>', typename(objlist)) + + # Use a member function + assert_equal('A.F', objlist[0].F()) + assert_equal('B.F', objlist[1].F()) + + # Use a member variable on the RHS + assert_equal([100, 101], objlist[0].n) + assert_equal([200, 201], objlist[1].n) + + # Use a member variable on the LHS + objlist[0].n[1] = 110 + objlist[1].n[1] = 210 + assert_equal([100, 110], objlist[0].n) + assert_equal([200, 210], objlist[1].n) + + # Iterate using a for loop + var s1 = [] + for o in objlist + add(s1, o.F()) + endfor + assert_equal(['A.F', 'B.F'], s1) + + # Iterate using foreach() + var s2 = [] + foreach(objlist, (k, v) => add(s2, v.F())) + assert_equal(['A.F', 'B.F'], s2) + + # Add a new list item + objlist->add(B.new('b2')) + assert_equal('b2', objlist[2].name) + END + v9.CheckSourceSuccess(lines) + + lines =<< trim END + mnv9script + + class A + endclass + + class B + endclass + + var objlist = [A.new(), B.new()] + def Fn() + objlist->add(10) + enddef + + try + Fn() + catch + assert_exception('MNV(eval):E1012: Type mismatch; expected object<any> but got number') + endtry + + try + objlist->add(10) + catch + assert_exception('MNV(eval):E1012: Type mismatch; expected object<any> but got number') + endtry + END + v9.CheckSourceSuccess(lines) + + # Adding an enum to a List of objects should fail + lines =<< trim END + mnv9script + class A + endclass + class B + endclass + enum C + Red, + Green, + endenum + var items = [A.new(), B.new()] + def Fn() + items->add(C.Red) + enddef + + try + Fn() + catch + assert_exception('MNV(eval):E1012: Type mismatch; expected object<any> but got enum<C>') + endtry + + try + items->add(C.Green) + catch + assert_exception('MNV(eval):E1012: Type mismatch; expected object<any> but got enum<C>') + endtry + + var items2 = [C.Red, C.Green] + def Fn2() + items2->add(A.new()) + enddef + try + Fn2() + catch + assert_exception('MNV(eval):E1012: Type mismatch; expected enum<C> but got object<A>') + endtry + + try + items2->add(B.new()) + catch + assert_exception('MNV(eval):E1012: Type mismatch; expected enum<C> but got object<B>') + endtry + END + v9.CheckSourceSuccess(lines) +enddef + +" Test for using a dict of objects +def Test_dict_of_objects() + var lines =<< trim END + mnv9script + + class A + var n: list<number> = [100, 101] + def F(): string + return 'A.F' + enddef + endclass + + class B + var name: string + var n: list<number> = [200, 201] + def new(this.name) + enddef + def F(): string + return 'B.F' + enddef + endclass + + var obj1 = A.new() + var obj2 = B.new('b1') + + def CheckObjectDict() + var objdict = {o_a: obj1, o_b: obj2} + assert_equal('dict<object<any>>', typename(objdict)) + + # Use a member function + assert_equal('A.F', objdict.o_a.F()) + assert_equal('B.F', objdict.o_b.F()) + + # Use a member variable on the RHS + assert_equal([100, 101], objdict.o_a.n) + assert_equal([200, 201], objdict.o_b.n) + + # Use a member variable on the LHS + objdict.o_a.n[1] = 110 + objdict.o_b.n[1] = 210 + assert_equal([100, 110], objdict.o_a.n) + assert_equal([200, 210], objdict.o_b.n) + + # Iterate using a for loop + var l = [] + for v in values(objdict) + add(l, v.F()) + endfor + assert_equal(['A.F', 'B.F'], l) + + # Iterate using foreach() + l = [] + foreach(objdict, (k, v) => add(l, v.F())) + assert_equal(['A.F', 'B.F'], l) + + # Add a new dict item + objdict['o_b2'] = B.new('b2') + assert_equal('b2', objdict.o_b2.name) + enddef + + CheckObjectDict() + + var objdict = {o_a: A.new(), o_b: B.new('b2')} + assert_equal('dict<object<any>>', typename(objdict)) + assert_equal('A.F', objdict.o_a.F()) + assert_equal('B.F', objdict.o_b.F()) + assert_equal([100, 101], objdict.o_a.n) + assert_equal([200, 201], objdict.o_b.n) + + var l = [] + for v in values(objdict) + add(l, v.F()) + endfor + assert_equal(['A.F', 'B.F'], l) + + # Add a new dict item + objdict['o_b2'] = B.new('b2') + assert_equal('b2', objdict.o_b2.name) + END + v9.CheckSourceSuccess(lines) + + lines =<< trim END + mnv9script + + class A + endclass + class B + endclass + class C + endclass + var objdict = {a: A.new(), b: B.new()} + def Fn() + objdict['c'] = C.new() + enddef + + try + Fn() + catch + assert_exception('MNV(eval):E1012: Type mismatch; expected object<any> but got number') + endtry + + try + objdict['c'] = C.new() + catch + assert_exception('MNV(eval):E1012: Type mismatch; expected object<any> but got number') + endtry + END + v9.CheckSourceSuccess(lines) + + # Adding an enum to a Dict of objects should fail + lines =<< trim END + mnv9script + class A + endclass + class B + endclass + enum C + Red, + Green, + endenum + var items = {o_a: A.new(), o_b: B.new()} + def Fn() + items['o_c'] = C.Red + enddef + + try + Fn() + catch + assert_exception('MNV(eval):E1012: Type mismatch; expected object<any> but got enum<C>') + endtry + + try + items['o_c'] = C.Green + catch + assert_exception('MNV(var):E1012: Type mismatch; expected object<any> but got enum<C>') + endtry + + var items2 = {red: C.Red, green: C.Green} + def Fn2() + items2['o_a'] = A.new() + enddef + try + Fn2() + catch + assert_exception('MNV(eval):E1012: Type mismatch; expected enum<C> but got object<A>') + endtry + + try + items2['o_a'] = B.new() + catch + assert_exception('MNV(var):E1012: Type mismatch; expected enum<C> but got object<B>') + endtry + END + v9.CheckSourceSuccess(lines) +enddef + +" Test for using the type() and typename() functions with a variable of type +" object +def Test_type_typename_funcs_with_object_variable() + var lines =<< trim END + mnv9script + + class A + endclass + + class B + endclass + + var o1: object<any> + assert_equal([13, 'object<any>'], [type(o1), typename(o1)]) + + var o2: object<A> + assert_equal([13, 'object<any>'], [type(o2), typename(o2)]) + + var o3: A + assert_equal([13, 'object<any>'], [type(o3), typename(o3)]) + + var o4 = A.new() + assert_equal([13, 'object<A>'], [type(o4), typename(o4)]) + + var l = [A.new(), B.new()] + assert_equal([13, 'object<B>'], [type(l[1]), typename(l[1])]) + + var d = {o_a: A.new(), o_b: B.new()} + assert_equal([13, 'object<B>'], [type(d.o_b), typename(d.o_b)]) + END + v9.CheckSourceSuccess(lines) +enddef + +" Test for object<any> type +def Test_object_any_type() + # assigning different objects to variable of type object<any> + var lines =<< trim END + mnv9script + class A + endclass + class B + endclass + var x: object<any> + x = A.new() + assert_true(instanceof(x, A)) + x = B.new() + assert_true(instanceof(x, B)) + x = null_object + assert_true(instanceof(x, null_class)) + END + v9.CheckSourceSuccess(lines) + + # Use a list of object<any> variable + lines =<< trim END + mnv9script + class A + endclass + class B + endclass + var l: list<object<any>> + l->add(A.new()) + l->add(B.new()) + assert_true(instanceof(l[0], A)) + assert_true(instanceof(l[1], B)) + END + v9.CheckSourceSuccess(lines) + + # Using object<any> as a function argument type and the return type + lines =<< trim END + mnv9script + class A + endclass + class B + endclass + def Fn(x: object<any>): object<any> + return x + enddef + assert_true(instanceof(Fn(A.new()), A)) + assert_true(instanceof(Fn(B.new()), B)) + END + + # Try assigning a different type of value to a object<any> variable + lines =<< trim END + var x: object<any> = [] + END + v9.CheckSourceDefAndScriptFailure(lines, ['E1012: Type mismatch; expected object<any> but got list<any>', 'E1012: Type mismatch; expected object<any> but got list<any>']) + + # Try assigning a different type of value to a object<any> variable + lines =<< trim END + var x: object<any> + x = 0z10 + END + v9.CheckSourceDefAndScriptFailure(lines, ['E1012: Type mismatch; expected object<any> but got blob', 'E1012: Type mismatch; expected object<any> but got blob']) + + # Try adding a different type of value to a list<object<any>> variable + lines =<< trim END + var x: list<object<any>> + x->add({}) + END + v9.CheckSourceDefAndScriptFailure(lines, ['E1012: Type mismatch; expected object<any> but got dict<any>', 'E1012: Type mismatch; expected object<any> but got dict<any>']) + + # Try adding a different type of value to a dict<object<any>> variable + lines =<< trim END + var x: dict<object<any>> + x['a'] = {} + END + v9.CheckSourceDefAndScriptFailure(lines, ['E1012: Type mismatch; expected object<any> but got dict<any>', 'E1012: Type mismatch; expected object<any> but got dict<any>']) + + # Error if comparing object with non object when using COMPAREANY instruction + lines =<< trim END + mnv9script + + enum DirectiveType + Unknown, + Set + endenum + + type PatternSteps = list<any> + type Directive = tuple<DirectiveType, PatternSteps> + + def Test(): void + var directive: Directive = (DirectiveType.Unknown, ["eq", 1, "hello"]) + + if directive[0] == "test" + endif + enddef + + Test() + END + v9.CheckSourceFailure(lines, 'E1437: Can only compare Object with Object', 3) +enddef + +" Test for object<{class}> type +def Test_object_of_class_type() + var lines =<< trim END + mnv9script + class A + endclass + var x: object<A> + x = A.new() + assert_true(instanceof(x, A)) + var y: object<A> = A.new() + assert_true(instanceof(y, A)) + END + v9.CheckSourceSuccess(lines) + + lines =<< trim END + mnv9script + class A + endclass + class B + endclass + var x: object<A> + x = B.new() + END + v9.CheckSourceFailure(lines, 'E1012: Type mismatch; expected object<A> but got object<B>') + + lines =<< trim END + mnv9script + class A + endclass + class B + endclass + def Fn(x: object<A>): object<B> + return B.new() + enddef + assert_true(instanceof(Fn(A.new()), B)) + END + v9.CheckSourceSuccess(lines) + + lines =<< trim END + var x: object + END + v9.CheckSourceDefAndScriptFailure(lines, ['E1008: Missing <type> after object', 'E1008: Missing <type> after object']) + + lines =<< trim END + var x: object <any> + END + v9.CheckSourceDefAndScriptFailure(lines, ['E1068: No white space allowed before ''<'': <any>', 'E1068: No white space allowed before ''<'': <any>']) + + lines =<< trim END + var x: object<any + END + v9.CheckSourceDefAndScriptFailure(lines, ['E1009: Missing > after type: <any', 'E1009: Missing > after type: <any']) + + lines =<< trim END + var x: object<any,any> + END + v9.CheckSourceDefFailure(lines, 'E1009: Missing > after type: <any,any>') + + lines =<< trim END + mnv9script + var x: object<any,any> + END + v9.CheckSourceFailure(lines, 'E488: Trailing characters: ,any>') + + lines =<< trim END + var x: object<number> + END + v9.CheckSourceDefAndScriptFailure(lines, [ + \ 'E1353: Class name not found: <number>', + \ 'E1353: Class name not found: <number>']) +enddef + +" Test for the object and class member type +def Test_obj_class_member_type() + var lines =<< trim END + mnv9script + class L + var l: list<number> + endclass + var obj_L = L.new([10, 20]) + assert_equal('list<number>', typename(obj_L.l)) + obj_L.l->add('a') + END + v9.CheckSourceFailure(lines, 'E1012: Type mismatch; expected number but got string', 7) + + lines =<< trim END + mnv9script + class T + var t: list<tuple<string>> + endclass + var obj_T = T.new([('a',), ('b',)]) + assert_equal('list<tuple<string>>', typename(obj_T.t)) + obj_T.t->add([('c', 10, true)]) + END + v9.CheckSourceFailure(lines, 'E1012: Type mismatch; expected tuple<string> but got list<tuple<string, number, bool>>', 7) + + lines =<< trim END + mnv9script + class D + var d: dict<number> + endclass + var obj_D = D.new({a: 10, b: 20}) + assert_equal('dict<number>', typename(obj_D.d)) + obj_D.d->extend({c: 'C'}) + END + v9.CheckSourceFailure(lines, 'E1013: Argument 2: type mismatch, expected dict<number> but got dict<string> in extend()', 7) + + lines =<< trim END + mnv9script + class L + public static var l: list<number> + endclass + L.l = [10, 20] + assert_equal('list<number>', typename(L.l)) + L.l->add('a') + END + v9.CheckSourceFailure(lines, 'E1012: Type mismatch; expected number but got string', 7) + + lines =<< trim END + mnv9script + class T + public static var t: list<tuple<string>> + endclass + T.t = [('a',), ('b',)] + assert_equal('list<tuple<string>>', typename(T.t)) + T.t->add([('c', 10, true)]) + END + v9.CheckSourceFailure(lines, 'E1012: Type mismatch; expected tuple<string> but got list<tuple<string, number, bool>>', 7) + + lines =<< trim END + mnv9script + class D + public static var d: dict<number> + endclass + D.d = {a: 10, b: 20} + assert_equal('dict<number>', typename(D.d)) + D.d->extend({c: 'C'}) + END + v9.CheckSourceFailure(lines, 'E1013: Argument 2: type mismatch, expected dict<number> but got dict<string> in extend()', 7) +enddef + +" Test for garbage collecting a class with a member referring to the class +" (self reference) +func Test_class_selfref_gc() + let lines =<< trim END + mnv9script + class Foo + static var MyFoo = Foo.new() + static var d = {a: [1, 2]} + static var l = [{a: 'a', b: 'b'}] + endclass + assert_equal(2, test_refcount(Foo)) + test_garbagecollect_now() + assert_equal(2, test_refcount(Foo)) + END + call v9.CheckSourceSuccess(lines) +endfunc + +" Test if class members can be accessed via a lambda inside a object/class +" method. +func Test_class_member_lambda() + let lines =<< trim END + mnv9script + class A + static var regular: string + static var _protected: string + + static def RegularMethod(): string + return A.regular + enddef + + static def _ProtectedMethod(): string + return A._protected + enddef + + def new() + var FuncA: func = () => { + A.regular = "regular" + assert_equal("regular", A.RegularMethod()) + } + var FuncB: func = () => { + A._protected = "protected" + assert_equal("protected", A._ProtectedMethod()) + } + + FuncA() + FuncB() + enddef + endclass + + A.new() + END + call v9.CheckSourceSuccess(lines) +endfunc + +" mnv: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker |