Close the parity gaps the upstream suites name

.github/workflows/terminal.yml

@@ -55,6 +55,9 @@ jobs:
       - run: rustup toolchain install 1.98.0 --profile minimal
       - run: cargo test --locked -p ox-tui --lib
       - run: cargo test --locked -p ox-sys --lib
+      - name: Check the whole workspace for the host MSVC target
+        run: cargo check --locked --workspace --all-targets
+      - run: cargo test --locked -p ox-editor --test platform_startup
       - run: rustup target add i686-pc-windows-msvc
       - name: Preserve libuv uname behavior under WOW64
         run: cargo test --locked -p ox-sys --lib --target i686-pc-windows-msvc

.gitignore

@@ -142,3 +142,4 @@ tmtags
 # copies the ABI-compatible reference build artifacts here so the
 # `parser/<lang>.*` runtime lookup resolves them).
 runtime/parser/
+target-*/

crates/ox-api/src/api_function_names.rs

@@ -1849,19 +1849,6 @@ pub(crate) const API_FUNCTIONS: &[FunctionMetadata] = &[
             ("follow", TypeRef::Boolean, false),
         ],
     },
-    FunctionMetadata {
-        name: "nvim_mcursor",
-        since: 15,
-        deprecated_since: None,
-        method: false,
-        fast: false,
-        textlock: false,
-        returns: TypeRef::Integer,
-        params: &[
-            ("buf", TypeRef::Buffer, false),
-            ("pos", TypeRef::Named("ArrayOf(Integer, 2)"), false),
-        ],
-    },
     FunctionMetadata {
         name: "nvim_get_color_by_name",
         since: 1,

crates/ox-api/src/autocmd.rs

@@ -258,6 +258,61 @@ pub(crate) fn fire_filetype(
     result
 }
 
+/// Plans and executes `Event::OptionSet` for one committed option change
+/// (`apply_optionset_autocmd_now`, option.c:2099-2134).
+///
+/// The option's full name is the match text. The six `v:option_*` values are
+/// published before the plan runs and put back afterwards, whatever the
+/// callbacks do, so a nested dispatch restores its own values on the way out
+/// and never leaks them into the outer dispatch.
+pub(crate) fn fire_option_set(
+    session: &ApiSession,
+    name: &str,
+    scope: ox_editor::OptionSetScope,
+    old: &Object,
+    old_local: Option<&Object>,
+    old_global: Option<&Object>,
+    new: &Object,
+) -> Result<(), ApiError> {
+    // Upstream skips the event while startup runs (`starting`,
+    // option.c:2147) and while a dispatch is already in flight
+    // (`*get_vim_var_str(VV_OPTION_TYPE) != NUL`, option.c:2102). Startup in
+    // this port has finished exactly when `v:vim_did_enter` is 1, which
+    // upstream sets at the same point it clears `starting`.
+    let started = session.with_editor(|editor| {
+        matches!(
+            editor.vvars().get(&OxStr::from("vim_did_enter")),
+            Some(Object::Integer(1))
+        )
+    });
+    let firing = session.with_state(|state| state.option_set_in_flight);
+    if !started || firing {
+        return Ok(());
+    }
+    let saved = session.with_editor_mut(|editor| {
+        editor.publish_option_set(scope, old, old_local, old_global, new)
+    });
+    session.with_state_mut(|state| state.option_set_in_flight = true);
+    let match_name = OxStr::from(name);
+    let buffer = session.with_editor(|editor| editor.current_buffer());
+    let plan = session.with_editor_mut(|editor| {
+        editor.autocmds_mut().plan(
+            Event::OptionSet,
+            AutocmdContext {
+                buffer,
+                file_name: None,
+                match_name: Some(match_name.as_bytes()),
+                nested: true,
+                data: None,
+            },
+        )
+    });
+    let result = execute_firing_plan(session, plan);
+    session.with_state_mut(|state| state.option_set_in_flight = false);
+    session.with_editor_mut(|editor| editor.restore_option_set(saved));
+    result
+}
+
 fn text(value: &OxStr, what: &str) -> Result<String, ApiError> {
     String::from_utf8(value.0.clone())
         .map_err(|_| ApiError::validation(format!("{what} must be valid UTF-8")))
@@ -525,7 +580,7 @@ fn autocmd_kind(opts: &Dict) -> Result<AutocmdKind, ApiError> {
     let callback = opts.get(&OxStr::from("callback"));
     match (command, callback) {
         (Some(Object::String(command)), None) => {
-            Ok(AutocmdKind::ExString(text(command, "command")?))
+            Ok(AutocmdKind::ExString { source: text(command, "command")?, script: None })
         }
         (None, Some(Object::LuaRef(callback))) => Ok(AutocmdKind::LuaCallback(
             u64::try_from(*callback).map_err(|_| ApiError::validation("Invalid 'callback'"))?,
@@ -826,7 +881,7 @@ fn autocmd_definition(item: &AutocmdDefinition) -> Dict {
     entries.push((
         OxStr::from("command"),
         match &item.kind {
-            AutocmdKind::ExString(command) => Object::String(OxStr::from(command.as_str())),
+            AutocmdKind::ExString { source: command, .. } => Object::String(OxStr::from(command.as_str())),
             AutocmdKind::VimscriptFunction(_) | AutocmdKind::LuaCallback(_) => {
                 Object::String(OxStr::from(""))
             }
@@ -845,7 +900,7 @@ fn autocmd_definition(item: &AutocmdDefinition) -> Dict {
                 Object::LuaRef(i32::try_from(*callback).unwrap_or(i32::MAX)),
             ));
         }
-        AutocmdKind::ExString(_) => {}
+        AutocmdKind::ExString { .. } => {}
     }
     entries.push((
         OxStr::from("pattern"),

crates/ox-api/src/buffer.rs

@@ -867,6 +867,11 @@ pub fn nvim_buf_set_var(
     value: Object,
 ) -> Result<(), ApiError> {
     let buffer = resolve_buffer(session, buffer)?;
+    if crate::global::host_present(session) {
+        return crate::runtime::with_command_executor(session, |session, executor| {
+            executor.set_buffer_var(session, buffer, name, value)
+        });
+    }
     session.with_editor_mut(|editor| {
         if name.as_bytes() == b"changedtick" {
             return Err(ApiError::validation(format!(
@@ -899,6 +904,11 @@ pub fn nvim_buf_del_var(
     name: OxStr,
 ) -> Result<(), ApiError> {
     let buffer = resolve_buffer(session, buffer)?;
+    if crate::global::host_present(session) {
+        return crate::runtime::with_command_executor(session, |session, executor| {
+            executor.del_buffer_var(session, buffer, name)
+        });
+    }
     session.with_editor_mut(|editor| {
         if name.as_bytes() == b"changedtick" {
             return Err(ApiError::validation(format!(
@@ -1518,7 +1528,6 @@ mod tests {
     use std::cell::RefCell;
     use std::rc::Rc;
 
-
     use super::*;
 
     #[test]
@@ -1527,16 +1536,15 @@ mod tests {
         let buffer = editor.borrow_mut().create_buffer(true).unwrap();
         let session = ApiSession::new(editor);
 
-        assert!(nvim_buf_attach(
-            &session,
-            buffer,
-            false,
-            Dict(vec![(
-                OxStr::from("on_bytes"),
-                Object::LuaRef(41),
-            )]),
-        )
-        .unwrap());
+        assert!(
+            nvim_buf_attach(
+                &session,
+                buffer,
+                false,
+                Dict(vec![(OxStr::from("on_bytes"), Object::LuaRef(41),)]),
+            )
+            .unwrap()
+        );
         assert!(nvim_buf_detach(&session, buffer).unwrap());
 
         session.with_editor_mut(|editor| {