methods work on weird params

Author: tjdevries

crates/vim9-gen/src/call_expr.rs

@@ -2,7 +2,7 @@ use std::collections::HashSet;
 
 use parser::{CallExpression, Expression, Identifier};
 
-use crate::{Generate, State};
+use crate::{func_info_for_call, Generate, State};
 
 #[derive(Debug)]
 pub struct VimFuncMutability {
@@ -316,7 +316,18 @@ pub fn generate_method(
     state: &mut State,
 ) -> String {
     let mut call = *method.right.clone();
-    call.args.insert(0, *method.left.clone());
+
+    // Methods don't always get inserted in the first argument.
+    // Check if we have func info and use the method arg if applicable
+    let idx = match func_info_for_call(&call) {
+        Some(info) => info.method_arg.unwrap_or(1) - 1,
+        None => 0,
+    };
+
+    match idx == call.args.len() {
+        true => call.args.push(*method.left.clone()),
+        false => call.args.insert(idx, *method.left.clone()),
+    }
 
     let func_data: FunctionData = (&call).into();
     if expr_is_func_mutable(&method.left) {
@@ -333,8 +344,5 @@ pub fn generate_method(
         }
     }
 
-    let mut expr = method.right.clone();
-    expr.args.insert(0, *method.left.clone());
-
-    expr.gen(state)
+    call.gen(state)
 }

crates/vim9-gen/src/lib.rs

@@ -896,28 +896,30 @@ fn vim_to_type(ret: &vimfuncs::FuncReturnType) -> Type {
     }
 }
 
+pub fn func_info_for_call(c: &CallExpression) -> Option<vimfuncs::FuncInfo> {
+    match c.name() {
+        Some(ident) => {
+            match ident {
+                // TODO: Use our very cool new generated stuff here
+                Identifier::Raw(raw) => {
+                    return vimfuncs::get_func_info(&raw.name);
+                }
+                _ => None,
+            }
+        }
+        _ => None,
+    }
+}
+
 fn guess_type_of_expr(state: &State, expr: &Expression) -> Type {
     match expr {
         Expression::Number(_) => Type::Number,
         Expression::String(_) => Type::String,
         Expression::Boolean(_) => Type::Bool,
-        Expression::Call(c) => {
-            match c.name() {
-                Some(ident) => {
-                    match ident {
-                        // TODO: Use our very cool new generated stuff here
-                        Identifier::Raw(raw) => {
-                            match vimfuncs::get_func_info(&raw.name) {
-                                Some(info) => vim_to_type(&info.return_type),
-                                _ => Type::Any,
-                            }
-                        }
-                        _ => Type::Any,
-                    }
-                }
-                _ => Type::Any,
-            }
-        }
+        Expression::Call(c) => match func_info_for_call(&c) {
+            Some(info) => vim_to_type(&info.return_type),
+            _ => Type::Any,
+        },
         Expression::Infix(infix) => {
             if infix.operator.is_comparison() {
                 return Type::Bool;
@@ -936,7 +938,7 @@ fn guess_type_of_expr(state: &State, expr: &Expression) -> Type {
                 && right_ty == Type::Number
                 && infix.operator.is_math()
             {
-                return dbg!(Type::Number);
+                return Type::Number;
             }
 
             Type::Any
@@ -1580,6 +1582,10 @@ mod test {
     busted!(busted_methods_1, "../testdata/busted/methods_1.vim");
     busted!(busted_methods_2, "../testdata/busted/methods_2.vim");
     busted!(busted_megamethods, "../testdata/busted/megamethods.vim");
+    busted!(
+        busted_methods_shifted,
+        "../testdata/busted/methods_shifted.vim"
+    );
 
     snapshot!(test_expr, "../testdata/snapshots/expr.vim");
     snapshot!(test_if, "../testdata/snapshots/if.vim");

crates/vim9-gen/testdata/busted/methods_shifted.vim

@@ -0,0 +1,7 @@
+def Test_settabvar_method()
+  call settabvar(1, "testing", 0)
+  assert_equal(0, t:testing)
+
+  25->settabvar(1, "testing")
+  assert_equal(25, t:testing)
+enddef

crates/vim9-gen/testdata/output/busted_methods_shifted.lua

@@ -0,0 +1,21 @@
+local NVIM9 = require("vim9script")
+local __VIM9_MODULE = {}
+describe("filename", function()
+  local Test_settabvar_method = nil
+
+  it("Test_settabvar_method", function()
+    -- Set errors to empty
+    vim.v.errors = {}
+
+    -- Actual test
+    NVIM9.fn["settabvar"](1, "testing", 0)
+    NVIM9.fn["assert_equal"](0, vim.t["testing"])
+
+    NVIM9.fn["settabvar"](1, "testing", 25)
+    NVIM9.fn["assert_equal"](25, vim.t["testing"])
+
+    -- Assert that errors is still empty
+    assert.are.same({}, vim.v.errors)
+  end)
+end)
+return __VIM9_MODULE

crates/vim9-gen/testdata/output/vim9_gen__test__expr.snap

@@ -9,5 +9,11 @@ local __VIM9_MODULE = {}
 
 local x = 1 + 2
 print(x)
+
+local literal = NVIM9.fn["charcol"](".") - 1
+print(literal)
+
+local func_call = NVIM9.ops["Minus"](MyFunc(), 1)
+print(func_call)
 return __VIM9_MODULE
 

crates/vim9-gen/testdata/snapshots/expr.vim

@@ -2,3 +2,9 @@ vim9script
 
 var x = 1 + 2
 echo x
+
+var literal = charcol('.') - 1
+echo literal
+
+var func_call = MyFunc() - 1
+echo func_call