patch 9.0.1140: cannot call an object method in a compiled function

Problem:    Cannot call an object method in a compiled function.
Solution:   Compile the instructins to invoke an object method.

diff --git a/src/structs.h b/src/structs.h
index 3bc92788b7934f2ba94dc17695d558a8422538ea..50260aeff282e94c68a1d2bb78a9b7d057a92781 100644 (file)
--- a/src/structs.h
+++ b/src/structs.h
@@ -1822,8 +1822,8 @@ struct ufunc_S
                                // copy_lambda_to_global_func()
 #define FC_LAMBDA   0x2000     // one line "return {expr}"
 
-#define FC_OBJECT   010000     // object method
-#define FC_NEW     030000      // constructor (also an object method)
+#define FC_OBJECT   0x4000     // object method
+#define FC_NEW     0x8000      // constructor
 
 #define MAX_FUNC_ARGS  20      // maximum number of function arguments
 #define VAR_SHORT_LEN  20      // short variable name length

diff --git a/src/testdir/test_vim9_class.vim b/src/testdir/test_vim9_class.vim
index 81076f8d32fd4841626d2234bea436b3511247c3..60730c4d5d3ca6d62030a8e991831d7c9a1b2365 100644 (file)
--- a/src/testdir/test_vim9_class.vim
+++ b/src/testdir/test_vim9_class.vim
@@ -329,6 +329,7 @@ def Test_class_object_member_access()
 
       class MyCar
         this.make: string
+        this.age = 5
 
         def new(make_arg: string)
           this.make = make_arg
@@ -337,6 +338,9 @@ def Test_class_object_member_access()
         def GetMake(): string
           return $"make = {this.make}"
         enddef
+        def GetAge(): number
+          return this.age
+        enddef
       endclass
 
       var c = MyCar.new("abc")
@@ -347,6 +351,12 @@ def Test_class_object_member_access()
 
       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.CheckScriptSuccess(lines)
 

diff --git a/src/version.c b/src/version.c
index 9e06cd4009d4c21faf9af11f323ab52c2c0e9069..bc0d3fd8c1694a0594610193b67f4162d20f1a64 100644 (file)
--- a/src/version.c
+++ b/src/version.c
@@ -695,6 +695,8 @@ static char *(features[]) =
 
 static int included_patches[] =
 {   /* Add new patch number below this line */
+/**/
+    1140,
 /**/
     1139,
 /**/

diff --git a/src/vim9compile.c b/src/vim9compile.c
index 0bf04a188da2028f4ac58c660fd36cfce52b466e..1f264371216c55b6b57fb4d8b5d1da0b28eaf246 100644 (file)
--- a/src/vim9compile.c
+++ b/src/vim9compile.c
@@ -45,7 +45,7 @@ lookup_local(char_u *name, size_t len, lvar_T *lvar, cctx_T *cctx)
 
     if (len == 4 && STRNCMP(name, "this", 4) == 0
            && cctx->ctx_ufunc != NULL
-           && (cctx->ctx_ufunc->uf_flags & FC_OBJECT))
+           && (cctx->ctx_ufunc->uf_flags & (FC_OBJECT|FC_NEW)))
     {
        if (lvar != NULL)
        {
@@ -313,7 +313,7 @@ variable_exists(char_u *name, size_t len, cctx_T *cctx)
                    || arg_exists(name, len, NULL, NULL, NULL, cctx) == OK
                    || (len == 4
                        && cctx->ctx_ufunc != NULL
-                       && (cctx->ctx_ufunc->uf_flags & FC_OBJECT)
+                       && (cctx->ctx_ufunc->uf_flags & (FC_OBJECT|FC_NEW))
                        && STRNCMP(name, "this", 4) == 0)))
            || script_var_exists(name, len, cctx, NULL) == OK
            || class_member_index(name, len, NULL, cctx) >= 0
@@ -3018,7 +3018,7 @@ compile_def_function(
        goto erret;
 
     // For an object method and constructor "this" is the first local variable.
-    if (ufunc->uf_flags & FC_OBJECT)
+    if (ufunc->uf_flags & (FC_OBJECT|FC_NEW))
     {
        dfunc_T *dfunc = ((dfunc_T *)def_functions.ga_data)
                                                         + ufunc->uf_dfunc_idx;

diff --git a/src/vim9execute.c b/src/vim9execute.c
index 0aed737ad5739dc55009bb0161c97f852107ca0e..087a8f4bd5a2829247da3ab416903cc565dbb405 100644 (file)
--- a/src/vim9execute.c
+++ b/src/vim9execute.c
@@ -532,6 +532,9 @@ call_dfunc(
        return FAIL;
     }
 
+    // If this is an object method, the object is just before the arguments.
+    typval_T   *obj = STACK_TV_BOT(0) - argcount - vararg_count - 1;
+
     // Check the argument types.
     if (check_ufunc_arg_types(ufunc, argcount, vararg_count, ectx) == FAIL)
        return FAIL;
@@ -594,6 +597,14 @@ call_dfunc(
     }
     ectx->ec_stack.ga_len += STACK_FRAME_SIZE + varcount;
 
+    // For an object method move the object from just before the arguments to
+    // the first local variable.
+    if (ufunc->uf_flags & FC_OBJECT)
+    {
+       *STACK_TV_VAR(0) = *obj;
+       obj->v_type = VAR_UNKNOWN;
+    }
+
     partial_T *pt = pt_arg != NULL ? pt_arg : ufunc->uf_partial;
     if (pt != NULL || (ufunc->uf_flags & FC_CLOSURE))
     {
@@ -1073,7 +1084,6 @@ func_return(ectx_T *ectx)
     dfunc_T    *dfunc = ((dfunc_T *)def_functions.ga_data)
                                                          + ectx->ec_dfunc_idx;
     int                argcount = ufunc_argcount(dfunc->df_ufunc);
-    int                top = ectx->ec_frame_idx - argcount;
     estack_T   *entry;
     int                prev_dfunc_idx = STACK_TV(ectx->ec_frame_idx
                                        + STACK_FRAME_FUNC_OFF)->vval.v_number;
@@ -1111,7 +1121,11 @@ func_return(ectx_T *ectx)
     if (handle_closure_in_use(ectx, TRUE) == FAIL)
        return FAIL;
 
-    // Clear the arguments.
+    // 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)
+       --top;
     for (idx = top; idx < ectx->ec_frame_idx; ++idx)
        clear_tv(STACK_TV(idx));
 

diff --git a/src/vim9expr.c b/src/vim9expr.c
index 5a6b1108322029925f38afa9816462f26b673530..daf014f84bf3825aae3b253f51d39575a9e1d512 100644 (file)
--- a/src/vim9expr.c
+++ b/src/vim9expr.c
@@ -273,9 +273,12 @@ compile_class_object_index(cctx_T *cctx, char_u **arg, type_T *type)
     class_T *cl = (class_T *)type->tt_member;
     if (*name_end == '(')
     {
+       int     function_count;
+       ufunc_T **functions;
+
        if (type->tt_type == VAR_CLASS)
        {
-           garray_T    *instr = &cctx->ctx_instr;
+           garray_T *instr = &cctx->ctx_instr;
            if (instr->ga_len > 0)
            {
                isn_T *isn = ((isn_T *)instr->ga_data) + instr->ga_len - 1;
@@ -288,34 +291,47 @@ compile_class_object_index(cctx_T *cctx, char_u **arg, type_T *type)
                }
            }
 
-           for (int i = 0; i < cl->class_class_function_count; ++i)
+           function_count = cl->class_class_function_count;
+           functions = cl->class_class_functions;
+       }
+       else
+       {
+           // type->tt_type == VAR_OBJECT: method call
+           function_count = cl->class_obj_method_count;
+           functions = cl->class_obj_methods;
+       }
+
+       ufunc_T *ufunc = NULL;
+       for (int i = 0; i < function_count; ++i)
+       {
+           ufunc_T *fp = functions[i];
+           // Use a separate pointer to avoid that ASAN complains about
+           // uf_name[] only being 4 characters.
+           char_u *ufname = (char_u *)fp->uf_name;
+           if (STRNCMP(name, ufname, len) == 0 && ufname[len] == NUL)
            {
-               ufunc_T *fp = cl->class_class_functions[i];
-               // Use a separate pointer to avoid that ASAN complains about
-               // uf_name[] only being 4 characters.
-               char_u *ufname = (char_u *)fp->uf_name;
-               if (STRNCMP(name, ufname, len) == 0 && ufname[len] == NUL)
-               {
-                   *arg = skipwhite(name_end + 1);
-                   int         argcount = 0;
-                   if (compile_arguments(arg, cctx, &argcount,
-                                                      CA_NOT_SPECIAL) == FAIL)
-                       return FAIL;
-                   return generate_CALL(cctx, fp, argcount);
-               }
+               ufunc = fp;
+               break;
            }
-
-           semsg(_(e_method_not_found_on_class_str_str),
-                                                        cl->class_name, name);
-           return FAIL;
        }
-       else
+       if (ufunc == NULL)
        {
-           // TODO: method call
-           emsg("compile_class_object_index(): object call not handled yet");
+           // TODO: different error for object method?
+           semsg(_(e_method_not_found_on_class_str_str), cl->class_name, name);
+           return FAIL;
        }
+
+       // Compile the arguments and call the class function or object method.
+       // The object method will know that the object is on the stack, just
+       // before the arguments.
+       *arg = skipwhite(name_end + 1);
+       int argcount = 0;
+       if (compile_arguments(arg, cctx, &argcount, CA_NOT_SPECIAL) == FAIL)
+           return FAIL;
+       return generate_CALL(cctx, ufunc, argcount);
     }
-    else if (type->tt_type == VAR_OBJECT)
+
+    if (type->tt_type == VAR_OBJECT)
     {
        for (int i = 0; i < cl->class_obj_member_count; ++i)
        {

diff --git a/src/vim9script.c b/src/vim9script.c
index 63eed4bf55d98e30f2de8db2e6f85db3080f5b09..0af7bb6d0d4deca6b892bf73943224ada187e995 100644 (file)
--- a/src/vim9script.c
+++ b/src/vim9script.c
@@ -1136,7 +1136,7 @@ check_reserved_name(char_u *name, cctx_T *cctx)
                && !(STRCMP("this", name) == 0
                    && cctx != NULL
                    && cctx->ctx_ufunc != NULL
-                   && (cctx->ctx_ufunc->uf_flags & FC_OBJECT)))
+                   && (cctx->ctx_ufunc->uf_flags & (FC_OBJECT|FC_NEW))))
        {
            semsg(_(e_cannot_use_reserved_name_str), name);
            return FAIL;