patch 9.0.1914: Vim9: few issues when accessing object members

Problem:  Vim9: few issues when accessing object members
Solution: When calling an object method, check for null object.
          Accessing a Dict object member doesn't work.

closes: #13119
closes: #13123
closes: #13124

Signed-off-by: Christian Brabandt <cb@256bit.org>
Co-authored-by: Yegappan Lakshmanan <yegappan@yahoo.com>

diff --git a/src/eval.c b/src/eval.c
index 0f952ee3e6a4fae4a6b95ef1df4d607403ce6fcc..931d51045152d589c57378d27aab0d2f07b627cc 100644 (file)
--- a/src/eval.c
+++ b/src/eval.c
@@ -1582,7 +1582,6 @@ get_lval(
                                        lp->ll_tv->vval.v_object + 1)) + m_idx;
                        else
                            lp->ll_tv = &cl->class_members_tv[m_idx];
-                       break;
                    }
                }
 

diff --git a/src/structs.h b/src/structs.h
index 4a82c82e6df143970eaa67926b8b3fe56b87d195..f5ad17414a63503ac07301a57b2f4b52c1f19940 100644 (file)
--- a/src/structs.h
+++ b/src/structs.h
@@ -1881,6 +1881,13 @@ struct ufunc_S
 #define FC_NEW     0x8000      // constructor
 #define FC_ABSTRACT 0x10000    // abstract method
 
+// Is "ufunc" an object method?
+#define IS_OBJECT_METHOD(ufunc) ((ufunc->uf_flags & FC_OBJECT) == FC_OBJECT)
+// Is "ufunc" a class new() constructor method?
+#define IS_CONSTRUCTOR_METHOD(ufunc) ((ufunc->uf_flags & FC_NEW) == FC_NEW)
+// Is "ufunc" an abstract class method?
+#define IS_ABSTRACT_METHOD(ufunc) ((ufunc->uf_flags & FC_ABSTRACT) == FC_ABSTRACT)
+
 #define MAX_FUNC_ARGS  20      // maximum number of function arguments
 #define VAR_SHORT_LEN  20      // short variable name length
 #define FIXVAR_CNT     12      // number of fixed variables

diff --git a/src/testdir/test_vim9_class.vim b/src/testdir/test_vim9_class.vim
index 1021114a9d28968e37c9f9a4c9a56c0a6771d7fa..763b5a539b958eb69d4f054888ca8640da4edd35 100644 (file)
--- a/src/testdir/test_vim9_class.vim
+++ b/src/testdir/test_vim9_class.vim
@@ -1507,6 +1507,7 @@ def Test_class_member()
   END
   v9.CheckSourceFailure(lines, 'E1340: Argument already declared in the class: count')
 
+  # Use a local variable in a method with the same name as a class variable
   lines =<< trim END
       vim9script
 
@@ -5488,4 +5489,114 @@ def Test_nested_object_assignment()
   v9.CheckSourceFailure(lines, 'E46: Cannot change read-only variable "value"')
 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
+    vim9script
+
+    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
+    vim9script
+
+    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
+    vim9script
+
+    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
+    vim9script
+
+    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)
+enddef
+
+" Test for using a dict as an object member
+def Test_dict_object_member()
+  var lines =<< trim END
+    vim9script
+
+    class Context
+      public this.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
+
 " vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker

diff --git a/src/version.c b/src/version.c
index c43b28f3732008fb6d25d1b8165c29299b1aa41b..809fb608112b0c67593d06cb6ff4abca4b8115fc 100644 (file)
--- a/src/version.c
+++ b/src/version.c
@@ -699,6 +699,8 @@ static char *(features[]) =
 
 static int included_patches[] =
 {   /* Add new patch number below this line */
+/**/
+    1914,
 /**/
     1913,
 /**/

diff --git a/src/vim9class.c b/src/vim9class.c
index f122f90c1f6373b73dff6959aa37e1880ec3f25d..a2e305c0a1a5cd9e987dd3e3e41397c952ddc72f 100644 (file)
--- a/src/vim9class.c
+++ b/src/vim9class.c
@@ -534,7 +534,7 @@ validate_abstract_class_methods(
        for (int i = 0; i < extends_method_count; i++)
        {
            ufunc_T *uf = extends_methods[i];
-           if ((uf->uf_flags & FC_ABSTRACT) == 0)
+           if (!IS_ABSTRACT_METHOD(uf))
                continue;
 
            int method_found = FALSE;

diff --git a/src/vim9cmds.c b/src/vim9cmds.c
index 3f44b88733625191ecbd80c8a1601785fc502a57..0ca3be11a8c97ffb0b141365c9bc4c99fe86443a 100644 (file)
--- a/src/vim9cmds.c
+++ b/src/vim9cmds.c
@@ -2617,7 +2617,7 @@ compile_return(char_u *arg, int check_return_type, int legacy, cctx_T *cctx)
            return NULL;
        }
 
-       if (cctx->ctx_ufunc->uf_flags & FC_NEW)
+       if (IS_CONSTRUCTOR_METHOD(cctx->ctx_ufunc))
        {
            // For a class new() constructor, return an object of the class.
            generate_instr(cctx, ISN_RETURN_OBJECT);

diff --git a/src/vim9compile.c b/src/vim9compile.c
index ab063f9ff26dce6d2d6b9f916d9023090ac7fb94..a8d8c7d220bf790ab43847e6b6676a7bb6f98872 100644 (file)
--- a/src/vim9compile.c
+++ b/src/vim9compile.c
@@ -3286,7 +3286,7 @@ compile_def_function(
 
        // In the constructor allocate memory for the object and initialize the
        // object members.
-       if ((ufunc->uf_flags & FC_NEW) == FC_NEW)
+       if (IS_CONSTRUCTOR_METHOD(ufunc))
        {
            generate_CONSTRUCT(&cctx, ufunc->uf_class);
 
@@ -3949,7 +3949,7 @@ nextline:
        if (ufunc->uf_ret_type->tt_type == VAR_UNKNOWN)
            ufunc->uf_ret_type = &t_void;
        else if (ufunc->uf_ret_type->tt_type != VAR_VOID
-               && (ufunc->uf_flags & FC_NEW) != FC_NEW)
+               && !IS_CONSTRUCTOR_METHOD(ufunc))
        {
            emsg(_(e_missing_return_statement));
            goto erret;
@@ -3957,7 +3957,7 @@ nextline:
 
        // Return void if there is no return at the end.
        // For a constructor return the object.
-       if ((ufunc->uf_flags & FC_NEW) == FC_NEW)
+       if (IS_CONSTRUCTOR_METHOD(ufunc))
        {
            generate_instr(&cctx, ISN_RETURN_OBJECT);
            ufunc->uf_ret_type = &ufunc->uf_class->class_object_type;

diff --git a/src/vim9execute.c b/src/vim9execute.c
index 7c61ff418ea0b9481e58693bf45a4ce712c070c5..23dee1cfca857088ec3b01ba1fcbcd3e4d1309ce 100644 (file)
--- a/src/vim9execute.c
+++ b/src/vim9execute.c
@@ -535,6 +535,15 @@ call_dfunc(
     // If this is an object method, the object is just before the arguments.
     typval_T   *obj = STACK_TV_BOT(0) - argcount - vararg_count - 1;
 
+    if (obj->v_type == VAR_OBJECT && obj->vval.v_object == NULL
+                                       && !IS_CONSTRUCTOR_METHOD(ufunc))
+    {
+       // If this is not the constructor method, then a valid object is
+       // needed.
+       emsg(_(e_using_null_object));
+       return FAIL;
+    }
+
     // Check the argument types.
     if (check_ufunc_arg_types(ufunc, argcount, vararg_count, ectx) == FAIL)
        return FAIL;
@@ -599,7 +608,7 @@ call_dfunc(
 
     // For an object method move the object from just before the arguments to
     // the first local variable.
-    if (ufunc->uf_flags & FC_OBJECT)
+    if (IS_OBJECT_METHOD(ufunc))
     {
        *STACK_TV_VAR(0) = *obj;
        obj->v_type = VAR_UNKNOWN;
@@ -1148,7 +1157,7 @@ func_return(ectx_T *ectx)
     // Clear the arguments.  If this was an object method also clear the
     // object, it is just before the arguments.
     int top = ectx->ec_frame_idx - argcount;
-    if (dfunc->df_ufunc->uf_flags & FC_OBJECT)
+    if (IS_OBJECT_METHOD(dfunc->df_ufunc))
        --top;
     for (idx = top; idx < ectx->ec_frame_idx; ++idx)
        clear_tv(STACK_TV(idx));