update infer conditional

Author: xuhuanzy

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

@@ -719,4 +719,36 @@ mod test {
         //     assert_eq!(result_ty, ws.ty("number"));
         // }
     }
+
+    #[test]
+    fn test_generic_extends_function_params() {
+        let mut ws = VirtualWorkspace::new();
+        ws.def(
+            r#"
+            ---@alias ConstructorParameters<T> T extends new (fun(...: infer P): any) and P or never
+            ---@alias Parameters<T extends function> T extends (fun(...: infer P): any) and P or never
+
+            ---@alias Procedure fun(...: any[]): any
+
+            ---@alias MockParameters<T> T extends table and ConstructorParameters<T> or T extends Procedure and Parameters<T> or never
+
+            ---@class Mock<T>
+            ---@field calls MockParameters<T>[]
+            "#,
+        );
+        ws.def(
+            r#"
+                ---@generic T: Procedure
+                ---@param a T?
+                ---@return Mock<T>
+                local function fn(a)
+                end
+
+                result = fn().calls
+            "#,
+        );
+
+        let result_ty = ws.expr_ty("result");
+        assert_eq!(ws.humanize_type(result_ty), "any[][]");
+    }
 }

crates/emmylua_code_analysis/src/semantic/generic/instantiate_type/mod.rs

@@ -639,17 +639,16 @@ fn collect_infer_assignments(
                                     };
                                     rest_types.push(source_ty.clone());
                                 }
+                                let ty = match rest_types.len() {
+                                    0 => LuaType::Never,
+                                    1 => rest_types[0].clone(),
+                                    _ => LuaType::Tuple(
+                                        LuaTupleType::new(rest_types, LuaTupleStatus::InferResolve)
+                                            .into(),
+                                    ),
+                                };
 
-                                let tuple_ty = LuaType::Tuple(
-                                    LuaTupleType::new(rest_types, LuaTupleStatus::InferResolve)
-                                        .into(),
-                                );
-                                if !collect_infer_assignments(
-                                    db,
-                                    &tuple_ty,
-                                    pattern_ty,
-                                    assignments,
-                                ) {
+                                if !collect_infer_assignments(db, &ty, pattern_ty, assignments) {
                                     return false;
                                 }
                             }
@@ -683,6 +682,16 @@ fn collect_infer_assignments(
                         false
                     }
                 }
+                LuaType::Ref(type_decl_id) => {
+                    if let Some(type_decl) = db.get_type_index().get_type_decl(type_decl_id) {
+                        if type_decl.is_alias()
+                            && let Some(origin) = type_decl.get_alias_origin(db, None)
+                        {
+                            return collect_infer_assignments(db, &origin, &pattern, assignments);
+                        }
+                    }
+                    false
+                }
                 _ => false,
             }
         }