fix: stop repeated assignments from hanging

Statements like `text = text .. value` or `total = total + value`
could make type analysis revisit the same variable over and over, which
stalled semantic model building.

Handle that case directly for simple built-in operations. Other
assignments still use the normal flow analysis, including custom
operators.

Fixes #1114

Assisted-by: Codex

Author: lewis6991

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

@@ -8,6 +8,7 @@ mod test {
     const LARGE_LINEAR_ASSIGNMENT_STEPS: usize = 2048;
     const MAXWELLHOME_ARRAY_VALUES: usize = 2048;
     const ISSUE_1100_HIGHLIGHT_GROUPS: usize = 2048;
+    const ISSUE_1114_REPEATED_BINARY_STEPS: usize = 512;
 
     #[test]
     fn test_closure_return() {
@@ -2942,6 +2943,147 @@ _2 = a[1]
         assert_eq!(ws.humanize_type(after_assign), "Pattern");
     }
 
+    #[test]
+    fn test_assignment_binary_rhs_replays_non_self_dependency() {
+        let mut ws = VirtualWorkspace::new();
+        ws.def(
+            r#"
+        ---@class FooValue
+        ---@field kind "foo"
+        ---@field value integer
+
+        ---@class BarValue
+        ---@field kind "bar"
+        ---@field value string
+
+        local right ---@type FooValue|BarValue
+
+        if right.kind == "foo" then
+            local value
+            value = right.value + 1
+            after_assign = value
+        end
+        "#,
+        );
+
+        let after_assign = ws.expr_ty("after_assign");
+        assert_eq!(ws.humanize_type(after_assign), "integer");
+    }
+
+    #[test]
+    fn test_assignment_rhs_keeps_flow_dependent_concat_operator() {
+        let mut ws = VirtualWorkspace::new();
+        ws.def(
+            r#"
+        ---@class Rope
+        ---@operator concat(Rope): Rope
+
+        local left ---@type Rope?
+        local right ---@type Rope?
+
+        if not left then return end
+        if not right then return end
+        left = left .. right
+        after_assign = left
+        "#,
+        );
+
+        let after_assign = ws.expr_ty("after_assign");
+        assert_eq!(ws.humanize_type(after_assign), "Rope");
+    }
+
+    #[test]
+    fn test_assignment_rhs_keeps_flow_dependent_add_operator() {
+        let mut ws = VirtualWorkspace::new();
+        ws.def(
+            r#"
+        ---@class Counter
+        ---@operator add(Counter): Counter
+
+        local left ---@type Counter?
+        local right ---@type Counter?
+
+        if not left then return end
+        if not right then return end
+        left = left + right
+        after_assign = left
+        "#,
+        );
+
+        let after_assign = ws.expr_ty("after_assign");
+        assert_eq!(ws.humanize_type(after_assign), "Counter");
+    }
+
+    #[test]
+    #[timeout(5000)]
+    fn test_issue_1114_repeated_self_concat_builds_semantic_model() {
+        let mut ws = VirtualWorkspace::new();
+        let repeated_assignments =
+            "wnd = wnd .. config.pic[idx][index]\n".repeat(ISSUE_1114_REPEATED_BINARY_STEPS);
+        let block = format!(
+            r#"
+        function f(idx, index)
+            local wnd = ""
+            local child = ""
+            {repeated_assignments}
+            return wnd:format(child:sub(1, -2))
+        end
+        "#
+        );
+
+        let file_id = ws.def(&block);
+
+        assert!(
+            ws.analysis
+                .compilation
+                .get_semantic_model(file_id)
+                .is_some(),
+            "expected semantic model for repeated self-concat repro"
+        );
+    }
+
+    #[test]
+    #[timeout(5000)]
+    fn test_issue_1114_repeated_self_add_builds_semantic_model() {
+        let mut ws = VirtualWorkspace::new();
+        let repeated_assignments =
+            "total = total + config.pic[idx][index]\n".repeat(ISSUE_1114_REPEATED_BINARY_STEPS);
+        let block = format!(
+            r#"
+        function f(idx, index)
+            local total = 0
+            {repeated_assignments}
+            return total
+        end
+        "#
+        );
+
+        let file_id = ws.def(&block);
+
+        assert!(
+            ws.analysis
+                .compilation
+                .get_semantic_model(file_id)
+                .is_some(),
+            "expected semantic model for repeated self-add repro"
+        );
+    }
+
+    #[test]
+    fn test_binary_assignment_infer_error_keeps_previous_type() {
+        let mut ws = VirtualWorkspace::new();
+        ws.def(
+            r#"
+        local value = "prior"
+        value = config.pic + 1
+        after_assign = value
+        "#,
+        );
+
+        let after_assign = ws.expr_ty("after_assign");
+        assert_eq!(ws.humanize_type(after_assign), "string");
+    }
+
     #[test]
     fn test_eq_uses_branch_narrowed_rhs_ref_type() {
         let mut ws = VirtualWorkspace::new();

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

@@ -1,13 +1,13 @@
 use emmylua_parser::{
-    LuaAssignStat, LuaAstNode, LuaChunk, LuaDocOpType, LuaExpr, LuaIndexKey, LuaIndexMemberExpr,
-    LuaSyntaxId, LuaTableExpr, LuaVarExpr,
+    BinaryOperator, LuaAssignStat, LuaAstNode, LuaChunk, LuaDocOpType, LuaExpr, LuaIndexKey,
+    LuaIndexMemberExpr, LuaSyntaxId, LuaTableExpr, LuaVarExpr,
 };
 use hashbrown::HashSet;
 use std::{rc::Rc, sync::Arc};
 
 use crate::{
     CacheEntry, DbIndex, FlowId, FlowNode, FlowNodeKind, FlowTree, InferFailReason, LuaDeclId,
-    LuaInferCache, LuaMemberId, LuaSignatureId, LuaType, TypeOps, check_type_compact,
+    LuaInferCache, LuaMemberId, LuaSignatureId, LuaType, LuaTypeNode, TypeOps, check_type_compact,
     semantic::{
         cache::{FlowAssignmentInfo, FlowMode, FlowVarCache},
         infer::{
@@ -1049,9 +1049,48 @@ impl<'a> FlowTypeEngine<'a> {
                 Some(self.tree),
                 self.cache,
                 antecedent_flow_id,
-                expr,
+                expr.clone(),
                 true,
             );
+            // Flow replay would recurse on `x = x <op> unresolved`; only that
+            // self-dependent shape gets the primitive shortcut.
+            if explicit_var_type.is_none()
+                && let LuaExpr::BinaryExpr(binary_expr) = &expr
+                && let Some(op_token) = binary_expr.get_op_token()
+                && let Some(fallback_type) = binary_assignment_operator_type(op_token.get_op())
+                && replay_query
+                    .dependency_queries
+                    .iter()
+                    .any(|query| query.var_ref_id == var_ref_id)
+                && !binary_expr
+                    .get_exprs()
+                    .is_some_and(|(left_expr, right_expr)| {
+                        [left_expr, right_expr].into_iter().any(|operand| {
+                            try_infer_expr_no_flow(self.db, self.cache, operand)
+                                .ok()
+                                .flatten()
+                                .is_some_and(|typ| typ.any_type(LuaType::is_custom_type))
+                        })
+                    })
+            {
+                let expr_type = match try_infer_expr_no_flow(self.db, self.cache, expr.clone()) {
+                    Ok(Some(expr_type)) => Some(
+                        expr_type
+                            .get_result_slot_type(result_slot)
+                            .unwrap_or(LuaType::Nil),
+                    ),
+                    Ok(None) | Err(_) if result_slot == 0 => Some(fallback_type),
+                    Ok(None) | Err(_) => None,
+                };
+                if let Some(expr_type) = expr_type
+                    && matches!(
+                        expr_type,
+                        LuaType::Integer | LuaType::Number | LuaType::String
+                    )
+                {
+                    return Ok(self.finish_walk(walk, expr_type));
+                }
+            }
             return self.start_expr_replay(
                 walk,
                 FlowExprReplay::Assignment {
@@ -1647,6 +1686,25 @@ fn preserves_assignment_expr_type(typ: &LuaType) -> bool {
     matches!(typ, LuaType::TableConst(_) | LuaType::Object(_)) || is_exact_assignment_expr_type(typ)
 }
 
+fn binary_assignment_operator_type(op: BinaryOperator) -> Option<LuaType> {
+    match op {
+        BinaryOperator::OpAdd
+        | BinaryOperator::OpSub
+        | BinaryOperator::OpMul
+        | BinaryOperator::OpDiv
+        | BinaryOperator::OpMod
+        | BinaryOperator::OpPow => Some(LuaType::Number),
+        BinaryOperator::OpIDiv
+        | BinaryOperator::OpBAnd
+        | BinaryOperator::OpBOr
+        | BinaryOperator::OpBXor
+        | BinaryOperator::OpShl
+        | BinaryOperator::OpShr => Some(LuaType::Integer),
+        BinaryOperator::OpConcat => Some(LuaType::String),
+        _ => None,
+    }
+}
+
 fn is_partial_assignment_expr_compatible(
     db: &DbIndex,
     source_type: &LuaType,