fix: preserve custom types in self-assignment replay

fix #1178

Author: xuhuanzy

crates/emmylua_code_analysis/src/compilation/test/flow.rs

@@ -3599,6 +3599,25 @@ _2 = a[1]
         assert_eq!(ws.humanize_type(after_assign), "Counter");
     }
 
+    #[test]
+    fn test_assignment_rhs_keeps_self_type_for_scalar_operator() {
+        let mut ws = VirtualWorkspace::new();
+        ws.def(
+            r#"
+        ---@class Vector
+        ---@operator div(number): Vector
+
+        local position ---@type Vector
+
+        position = position / 1
+        after_assign = position
+        "#,
+        );
+
+        let after_assign = ws.expr_ty("after_assign");
+        assert_eq!(ws.humanize_type(after_assign), "Vector");
+    }
+
     #[test]
     #[timeout(5000)]
     fn test_issue_1114_repeated_self_dependent_assignments_build_semantic_model() {

crates/emmylua_code_analysis/src/diagnostic/test/assign_type_mismatch_test.rs

@@ -1602,4 +1602,37 @@ return t
             "#
         ));
     }
+
+    #[test]
+    fn test_self_assignment_with_scalar_operator_keeps_declared_class() {
+        let mut ws = VirtualWorkspace::new();
+        assert!(ws.has_no_diagnostic(
+            DiagnosticCode::AssignTypeMismatch,
+            r#"
+            ---@class Vector
+            ---@operator div(number): Vector
+
+            local v ---@type Vector
+            local position ---@type Vector
+
+            position = position / 1
+            v = position
+            "#,
+        ));
+    }
+
+    #[test]
+    fn test_self_assignment_without_scalar_operator_reports_mismatch() {
+        let mut ws = VirtualWorkspace::new();
+        assert!(!ws.has_no_diagnostic(
+            DiagnosticCode::AssignTypeMismatch,
+            r#"
+            ---@class Vector
+
+            local position ---@type Vector
+
+            position = position / 1
+            "#,
+        ));
+    }
 }

crates/emmylua_code_analysis/src/semantic/infer/narrow/get_type_at_flow.rs

@@ -218,14 +218,6 @@ impl FlowReplayQuery {
         Ok(())
     }
 
-    fn resolve_dependencies(&mut self, var_ref_id: &VarRefId, typ: LuaType) {
-        for query in &mut self.dependency_queries {
-            if query.var_ref_id == *var_ref_id {
-                query.resolved_type = Some(typ.clone());
-            }
-        }
-    }
-
     fn accept_result(&mut self, dependency_result: InferResult) -> Result<(), InferFailReason> {
         let dependency_query = self
             .dependency_queries
@@ -1114,11 +1106,18 @@ impl<'a> FlowTypeEngine<'a> {
                 expr.clone(),
                 true,
             );
-            // A plain self-dependent RHS would replay this assignment while
-            // trying to type itself. Treat that self read as unknown; `and`/`or`
-            // assignments still need the antecedent value for their semantics.
+            // 普通自引用 RHS 优先使用明确的自定义声明类型, 避免回放时重新进入当前赋值节点.
+            // `and`/`or` 中的读取仍保留表达式内部流位置, 以应用短路分支的收窄结果.
             if explicit_var_type.is_none() && !contains_short_circuit_binary_expr(&expr) {
-                replay_query.resolve_dependencies(&var_ref_id, LuaType::Unknown);
+                let self_dependency_type = get_var_ref_type(self.db, self.cache, &var_ref_id)
+                    .ok()
+                    .filter(|typ| typ.is_custom_type())
+                    .unwrap_or(LuaType::Unknown);
+                for dependency_query in &mut replay_query.dependency_queries {
+                    if dependency_query.var_ref_id == var_ref_id {
+                        dependency_query.resolved_type = Some(self_dependency_type.clone());
+                    }
+                }
             }
             return self.start_expr_replay(
                 walk,