fix(flow): preserve pcall narrowing for normalized alias payloads

Fix a `pcall()` success-guard regression where payload types coming from
multiline aliases could lose their concrete type after normalization.

The underlying issue was that several lookup paths assumed a normalized
multiline alias would still be `LuaType::Union`. Recurse on the
normalized result instead, and preserve `never` when all branches are
`never`.

Author: lewis6991

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

@@ -1454,6 +1454,26 @@ end
         assert_eq!(b_desc, "table");
     }
 
+    #[test]
+    fn test_multiline_alias_never_member_preserves_string_call() {
+        let mut ws = VirtualWorkspace::new_with_init_std_lib();
+
+        ws.def(
+            r#"
+            ---@alias OnlyString
+            ---| string
+            ---| never
+
+            ---@type OnlyString
+            local value
+
+            result = value:sub(1)
+            "#,
+        );
+
+        assert_eq!(ws.expr_ty("result"), ws.ty("string"));
+    }
+
     #[test]
     fn test_issue_364() {
         let mut ws = VirtualWorkspace::new();

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

@@ -175,4 +175,37 @@ mod test {
         );
         assert_eq!(ws.expr_ty("narrowed"), ws.ty("integer"));
     }
+
+    #[test]
+    fn test_pcall_same_payload_type_stays_string_under_success_guard() {
+        let mut ws = VirtualWorkspace::new_with_init_std_lib();
+
+        ws.def(
+            r#"
+        ---@param value any
+        ---@return string
+        local function inspect(value)
+            return tostring(value)
+        end
+
+        ---@param err any
+        ---@return string
+        local function format_error_value(err)
+            if type(err) == 'string' then
+                return err
+            end
+
+            local ok, inspected = pcall(inspect, err)
+            if ok then
+                narrowed = inspected
+                return inspected
+            end
+
+            return tostring(err)
+        end
+        "#,
+        );
+
+        assert_eq!(ws.expr_ty("narrowed"), ws.ty("string"));
+    }
 }

crates/emmylua_code_analysis/src/db_index/type/types.rs

@@ -528,24 +528,30 @@ impl LuaType {
             _ => {
                 let mut result_types = Vec::new();
                 let mut hash_set = HashSet::new();
+                let mut saw_never = false;
                 for typ in types {
                     match typ {
                         LuaType::Union(u) => {
                             for t in u.into_vec() {
-                                if hash_set.insert(t.clone()) {
+                                if t.is_never() {
+                                    saw_never = true;
+                                } else if hash_set.insert(t.clone()) {
                                     result_types.push(t);
                                 }
                             }
                         }
                         _ => {
-                            if hash_set.insert(typ.clone()) {
+                            if typ.is_never() {
+                                saw_never = true;
+                            } else if hash_set.insert(typ.clone()) {
                                 result_types.push(typ);
                             }
                         }
                     }
                 }
 
                 match result_types.len() {
+                    0 if saw_never => LuaType::Never,
                     0 => LuaType::Nil,
                     1 => result_types[0].clone(),
                     _ => LuaType::Union(LuaUnionType::from_vec(result_types).into()),
@@ -1576,7 +1582,7 @@ impl LuaMultiLineUnion {
             types.push(t.clone());
         }
 
-        LuaType::Union(Arc::new(LuaUnionType::from_vec(types)))
+        LuaType::from_vec(types)
     }
 
     pub fn contain_tpl(&self) -> bool {

crates/emmylua_code_analysis/src/semantic/infer/infer_index/mod.rs

@@ -176,11 +176,7 @@ pub fn infer_member_by_member_key(
         }
         LuaType::MultiLineUnion(multi_union) => {
             let union_type = multi_union.to_union();
-            if let LuaType::Union(union_type) = union_type {
-                infer_union_member(db, cache, &union_type, index_expr, infer_guard)
-            } else {
-                Err(InferFailReason::FieldNotFound)
-            }
+            infer_member_by_member_key(db, cache, &union_type, index_expr, infer_guard)
         }
         LuaType::Intersection(intersection_type) => {
             infer_intersection_member(db, cache, intersection_type, index_expr, infer_guard)

crates/emmylua_code_analysis/src/semantic/infer/narrow/condition_flow/call_flow.rs

@@ -142,10 +142,9 @@ pub fn get_type_at_call_expr(
 fn needs_antecedent_same_var_colon_lookup(member_type: &LuaType) -> bool {
     let candidate_members = match member_type {
         LuaType::Union(union_type) => union_type.into_vec(),
-        LuaType::MultiLineUnion(multi_union) => match multi_union.to_union() {
-            LuaType::Union(union_type) => union_type.into_vec(),
-            _ => return false,
-        },
+        LuaType::MultiLineUnion(multi_union) => {
+            return needs_antecedent_same_var_colon_lookup(&multi_union.to_union());
+        }
         _ => return false,
     };
 

crates/emmylua_code_analysis/src/semantic/member/find_members.rs

@@ -121,11 +121,7 @@ fn find_members_guard(
         LuaType::Union(union_type) => find_union_members(db, union_type, ctx, filter),
         LuaType::MultiLineUnion(multi_union) => {
             let union_type = multi_union.to_union();
-            if let LuaType::Union(union_type) = union_type {
-                find_union_members(db, &union_type, ctx, filter)
-            } else {
-                None
-            }
+            find_members_guard(db, &union_type, ctx, filter)
         }
         LuaType::Intersection(intersection_type) => {
             find_intersection_members(db, intersection_type, ctx, filter)

crates/emmylua_code_analysis/src/semantic/type_check/complex_type/mod.rs

@@ -129,7 +129,7 @@ pub fn check_complex_type_compact(
         }
         LuaType::MultiLineUnion(multi_union) => {
             let union = multi_union.to_union();
-            return check_complex_type_compact(
+            return check_general_type_compact(
                 context,
                 &union,
                 compact_type,