Merge pull request #1029 from lewis6991/fix/issue-1028-iterative-flow

fix(semantic): make flow narrowing iterative

Author: CppCXY

crates/emmylua_code_analysis/src/compilation/analyzer/lua/stats.rs

@@ -480,82 +480,79 @@ pub fn analyze_local_func_stat(
     Some(())
 }
 
-fn register_expr_key_member(analyzer: &mut LuaAnalyzer, field: &LuaTableField) {
-    // Register expression-key members early so table-decl inference (and pairs)
-    // can see them even when the table itself has no explicit generic type.
-    let Some(field_key) = field.get_field_key() else {
-        return;
-    };
-    let LuaIndexKey::Expr(_) = &field_key else {
-        return;
-    };
-    let member_id = LuaMemberId::new(field.get_syntax_id(), analyzer.file_id);
-    if analyzer
-        .db
-        .get_member_index()
-        .get_member(&member_id)
-        .is_some()
-    {
-        return;
+/// Analyzes an assignment-style table field.
+///
+/// Table-declaration analysis already registers static keys and value fields, for
+/// example `{ name = value }`, `{ ["name"] = value }`, `{ [1] = value }`, and
+/// `{ value1, value2 }`.
+///
+/// This pass binds the field value type and eagerly materializes resolved
+/// bracket-key members such as `{ [key] = value }`, `{ [true] = value }`, or
+/// `{ [SomeEnum.A] = value }` so later consumers like table inference and
+/// `pairs` can see them before the unresolved table-field pass runs.
+pub fn analyze_table_field(analyzer: &mut LuaAnalyzer, field: LuaTableField) -> Option<()> {
+    if !field.is_assign_field() {
+        return Some(());
     }
-    let cache = analyzer
-        .context
-        .infer_manager
-        .get_infer_cache(analyzer.file_id);
-    let Ok(member_key) = LuaMemberKey::from_index_key(analyzer.db, cache, &field_key) else {
-        return;
-    };
-    if matches!(member_key, LuaMemberKey::ExprType(ref typ) if typ.is_unknown()) {
-        return;
+
+    if let Some(field_key) = field.get_field_key() {
+        if let LuaIndexKey::Expr(_) = &field_key {
+            // Decl analysis leaves `[expr] = value` fields unresolved. If the key
+            // already resolves here, materialize the member now.
+            let db = &mut *analyzer.db;
+            let member_id = LuaMemberId::new(field.get_syntax_id(), analyzer.file_id);
+            if db.get_member_index().get_member(&member_id).is_none() {
+                let cache = analyzer
+                    .context
+                    .infer_manager
+                    .get_infer_cache(analyzer.file_id);
+                if let Ok(member_key) = LuaMemberKey::from_index_key(db, cache, &field_key) {
+                    if !matches!(member_key, LuaMemberKey::ExprType(ref typ) if typ.is_unknown()) {
+                        if let Some(table_expr) = field.get_parent::<LuaTableExpr>() {
+                            let owner_id = LuaMemberOwner::Element(InFiled::new(
+                                analyzer.file_id,
+                                table_expr.get_range(),
+                            ));
+                            let decl_feature = if analyzer.context.metas.contains(&analyzer.file_id)
+                            {
+                                LuaMemberFeature::MetaDefine
+                            } else {
+                                LuaMemberFeature::FileDefine
+                            };
+                            let member = LuaMember::new(member_id, member_key, decl_feature, None);
+                            db.get_member_index_mut().add_member(owner_id, member);
+                        }
+                    }
+                }
+            }
+        }
     }
-    let Some(table_expr) = field.get_parent::<LuaTableExpr>() else {
-        return;
-    };
-    let owner_id = LuaMemberOwner::Element(InFiled::new(analyzer.file_id, table_expr.get_range()));
-    let decl_feature = if analyzer.context.metas.contains(&analyzer.file_id) {
-        LuaMemberFeature::MetaDefine
-    } else {
-        LuaMemberFeature::FileDefine
-    };
-    let member = LuaMember::new(member_id, member_key, decl_feature, None);
-    analyzer
-        .db
-        .get_member_index_mut()
-        .add_member(owner_id, member);
-}
 
-pub fn analyze_table_field(analyzer: &mut LuaAnalyzer, field: LuaTableField) -> Option<()> {
-    register_expr_key_member(analyzer, &field);
-
-    if field.is_assign_field() {
-        let value_expr = field.get_value_expr()?;
-        let member_id = LuaMemberId::new(field.get_syntax_id(), analyzer.file_id);
-        let value_type = match analyzer.infer_expr(&value_expr.clone()) {
-            Ok(value_type) => match value_type {
-                LuaType::Def(ref_id) => LuaType::Ref(ref_id),
-                _ => value_type,
-            },
-            Err(InferFailReason::None) => LuaType::Unknown,
-            Err(reason) => {
-                let unresolve = UnResolveMember {
-                    file_id: analyzer.file_id,
-                    member_id,
-                    expr: Some(value_expr.clone()),
-                    prefix: None,
-                    ret_idx: 0,
-                };
+    let value_expr = field.get_value_expr()?;
+    let member_id = LuaMemberId::new(field.get_syntax_id(), analyzer.file_id);
+    let value_type = match analyzer.infer_expr(&value_expr.clone()) {
+        Ok(value_type) => match value_type {
+            LuaType::Def(ref_id) => LuaType::Ref(ref_id),
+            _ => value_type,
+        },
+        Err(InferFailReason::None) => LuaType::Unknown,
+        Err(reason) => {
+            let unresolve = UnResolveMember {
+                file_id: analyzer.file_id,
+                member_id,
+                expr: Some(value_expr.clone()),
+                prefix: None,
+                ret_idx: 0,
+            };
 
-                analyzer.context.add_unresolve(unresolve.into(), reason);
-                return None;
-            }
-        };
+            analyzer.context.add_unresolve(unresolve.into(), reason);
+            return None;
+        }
+    };
+
+    let cache = LuaTypeCache::InferType(value_type);
+    bind_type(analyzer.db, member_id.into(), cache);
 
-        bind_type(
-            analyzer.db,
-            member_id.into(),
-            LuaTypeCache::InferType(value_type),
-        );
-    }
     Some(())
 }
 

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

@@ -1,9 +1,11 @@
 #[cfg(test)]
 mod test {
     use crate::{DiagnosticCode, LuaType, VirtualWorkspace};
+    use emmylua_parser::{LuaAstToken, LuaLocalName};
 
     const STACKED_TYPE_GUARDS: usize = 180;
     const LARGE_LINEAR_ASSIGNMENT_STEPS: usize = 2048;
+    const MAXWELLHOME_ARRAY_VALUES: usize = 2048;
 
     #[test]
     fn test_closure_return() {
@@ -388,6 +390,47 @@ mod test {
         assert_eq!(ws.humanize_type(after_assign), "integer");
     }
 
+    #[test]
+    fn test_issue_1028_maxwellhome_like_large_array_builds_semantic_model() {
+        let mut ws = VirtualWorkspace::new();
+        let mut block = String::from(
+            r#"
+        ---@type integer
+        local tile = ({
+            layers = {
+                {
+                    data = {
+        "#,
+        );
+
+        for i in 0..MAXWELLHOME_ARRAY_VALUES {
+            block.push_str(&format!("                        {},\n", i % 3));
+        }
+
+        block.push_str(
+            r#"
+                    },
+                },
+            },
+        }).layers[1].data[1024]
+        "#,
+        );
+
+        let file_id = ws.def_file("maxwellhome.lua", &block);
+        let semantic_model = ws
+            .analysis
+            .compilation
+            .get_semantic_model(file_id)
+            .expect("expected semantic model for maxwellhome-like large array stress case");
+        let local_name = ws.get_node::<LuaLocalName>(file_id);
+        let token = local_name.get_name_token().expect("name token must exist");
+        let info = semantic_model
+            .get_semantic_info(token.syntax().clone().into())
+            .expect("semantic info must exist");
+
+        assert_eq!(ws.humanize_type(info.typ), "integer");
+    }
+
     #[test]
     fn test_pending_replay_order_uses_type_guard_before_self_return_cast_lookup() {
         let mut ws = VirtualWorkspace::new();
@@ -1866,6 +1909,27 @@ end
         assert_eq!(b, b_expected);
     }
 
+    #[test]
+    fn test_feature_const_local_alias_chain_does_not_inherit_flow() {
+        let mut ws = VirtualWorkspace::new_with_init_std_lib();
+
+        ws.def(
+            r#"
+            local ret --- @type string | nil
+
+            local is_string = type(ret) == "string"
+            local ok = is_string
+            if ok then
+                a = ret
+            end
+            "#,
+        );
+
+        let a = ws.expr_ty("a");
+        let a_expected = ws.ty("string?");
+        assert_eq!(a, a_expected);
+    }
+
     #[test]
     fn test_feature_generic_type_guard() {
         let mut ws = VirtualWorkspace::new();

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

@@ -168,6 +168,49 @@ mod test {
         assert_eq!(ws.expr_ty("key_out"), LuaType::String);
     }
 
+    #[test]
+    fn test_pairs_value_field_integer_keys() {
+        let mut ws = VirtualWorkspace::new_with_init_std_lib();
+
+        ws.def(
+            r#"
+            local t = { 10, 20, 30 }
+
+            for k, v in pairs(t) do
+                key_out = k
+                value_out = v
+            end
+        "#,
+        );
+
+        let key_out = ws.expr_ty("key_out");
+        let value_out = ws.expr_ty("value_out");
+        let LuaType::Union(key_union) = key_out else {
+            panic!("expected integer key union, got {:?}", key_out);
+        };
+        let LuaType::Union(value_union) = value_out else {
+            panic!("expected value union, got {:?}", value_out);
+        };
+
+        let expected_keys: HashSet<_> = vec![
+            LuaType::IntegerConst(1),
+            LuaType::IntegerConst(2),
+            LuaType::IntegerConst(3),
+        ]
+        .into_iter()
+        .collect();
+        let expected_values: HashSet<_> = vec![
+            LuaType::DocIntegerConst(10),
+            LuaType::DocIntegerConst(20),
+            LuaType::DocIntegerConst(30),
+        ]
+        .into_iter()
+        .collect();
+
+        assert_eq!(key_union.into_set(), expected_keys);
+        assert_eq!(value_union.into_set(), expected_values);
+    }
+
     #[test]
     fn test_issue_291() {
         let mut ws = VirtualWorkspace::new_with_init_std_lib();

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

@@ -368,4 +368,99 @@ mod test {
 
         assert_eq!(ws.expr_ty("result"), ws.ty("never"));
     }
+
+    #[test]
+    fn test_rawget_guard_narrows_matching_index_expr() {
+        let mut ws = VirtualWorkspace::new_with_init_std_lib();
+
+        ws.def(
+            r#"
+        ---@class T
+        ---@field x? integer
+
+        ---@type T
+        local t = {}
+
+        if rawget(t, "x") then
+            result = t.x
+        end
+        "#,
+        );
+
+        assert_eq!(ws.expr_ty("result"), LuaType::Integer);
+    }
+
+    #[test]
+    fn test_type_guard_call_narrows_matching_index_expr() {
+        let mut ws = VirtualWorkspace::new();
+
+        ws.def(
+            r#"
+        ---@generic T
+        ---@param inst any
+        ---@param type `T`
+        ---@return TypeGuard<T>
+        local function instance_of(inst, type)
+            return true
+        end
+
+        ---@class T
+        ---@field x? string|integer
+
+        ---@type T
+        local t = {}
+
+        if instance_of(t.x, "string") then
+            result = t.x
+        end
+        "#,
+        );
+
+        assert_eq!(ws.expr_ty("result"), LuaType::String);
+    }
+
+    #[test]
+    fn test_alias_predicate_guard_narrows_matching_index_expr() {
+        let mut ws = VirtualWorkspace::new();
+
+        ws.def(
+            r#"
+        ---@class T
+        ---@field x? integer
+
+        ---@type T
+        local t = {}
+
+        local ok = t.x ~= nil
+        if ok then
+            result = t.x
+        end
+        "#,
+        );
+
+        assert_eq!(ws.expr_ty("result"), LuaType::Integer);
+    }
+
+    #[test]
+    fn test_alias_chain_predicate_guard_keeps_matching_index_expr_wide() {
+        let mut ws = VirtualWorkspace::new();
+
+        ws.def(
+            r#"
+        ---@class T
+        ---@field x? integer
+
+        ---@type T
+        local t = {}
+
+        local has_x = t.x ~= nil
+        local ok = has_x
+        if ok then
+            result = t.x
+        end
+        "#,
+        );
+
+        assert_eq!(ws.expr_ty("result"), ws.ty("integer?"));
+    }
 }