feat(analyzer): rewrite match expression analyzer for correctness

This commit introduces a complete rewrite of the `match` expression analyzer to resolve numerous bugs and correctness issues in the previous implementation.

The old analyzer struggled to correctly model the control flow and type narrowing within a `match` block, leading to false positives and missed errors related to unreachable arms and exhaustiveness.

The new implementation correctly simulates `match` semantics by sequentially analyzing each arm, applying its conditions as assertions to narrow the subject's type, and carrying the remaining (unhandled) subject type forward to subsequent arms.

Key capabilities of the new analyzer include:

- **Accurate Exhaustiveness Checking**: Correctly determines if all possible types of the subject are handled and reports `MatchNotExhaustive` if not.
- **Precise Unreachable Code Detection**: Identifies unreachable arms that are shadowed by previous arms or whose conditions can never be met.
- **Redundant Condition Analysis**: Finds arms that are *always* true given the remaining subject type, making subsequent arms unreachable.
- **Correct Type Inference**: Reliably infers the final return type by combining the types of all reachable arms.

This rewrite provides a robust and correct foundation for analyzing `match` expressions, leading to far more accurate and useful diagnostics.

closes #260

Signed-off-by: azjezz <[email protected]>

Author: azjezz

crates/analyzer/src/assertion.rs

@@ -44,6 +44,20 @@ pub fn scrape_assertions(
     }
 
     match unwrap_expression(expression) {
+        Expression::UnaryPrefix(UnaryPrefix { operator: UnaryPrefixOperator::Not(_), operand }) => {
+            let assertions = scrape_assertions(operand, artifacts, assertion_context);
+            let mut negated_assertions = HashMap::default();
+            for assertion in assertions {
+                for (var_name, assertion_set) in assertion {
+                    negated_assertions
+                        .entry(var_name)
+                        .or_insert_with(Vec::new)
+                        .extend(negate_assertion_set(assertion_set));
+                }
+            }
+
+            return if negated_assertions.is_empty() { vec![] } else { vec![negated_assertions] };
+        }
         Expression::Call(call) => {
             // Collect `@assert` assertions.
             if_types.extend(process_custom_assertions(call.span(), artifacts));
@@ -331,15 +345,15 @@ pub(super) fn scrape_equality_assertions(
         }
     };
 
-    if let Some(null_position) = has_null_variable(left, right) {
+    if let Some(null_position) = has_null_variable(left, right, artifacts) {
         return get_null_equality_assertions(left, right, assertion_context, null_position);
     }
 
-    if let Some(true_position) = has_true_variable(left, right) {
-        return get_true_equality_assertions(left, is_identity, right, assertion_context, true_position);
+    if let Some(true_position) = has_true_variable(left, right, artifacts) {
+        return get_true_equality_assertions(left, is_identity, right, artifacts, assertion_context, true_position);
     }
 
-    if let Some(false_position) = has_false_variable(left, right) {
+    if let Some(false_position) = has_false_variable(left, right, artifacts) {
         return get_false_equality_assertions(left, is_identity, right, assertion_context, false_position);
     }
 
@@ -410,15 +424,15 @@ fn scrape_inequality_assertions(
         }
     };
 
-    if let Some(null_position) = has_null_variable(left, right) {
+    if let Some(null_position) = has_null_variable(left, right, artifacts) {
         return get_null_inequality_assertions(left, right, assertion_context, null_position);
     }
 
-    if let Some(false_position) = has_false_variable(left, right) {
+    if let Some(false_position) = has_false_variable(left, right, artifacts) {
         return get_false_inquality_assertions(left, right, assertion_context, false_position);
     }
 
-    if let Some(true_position) = has_true_variable(left, right) {
+    if let Some(true_position) = has_true_variable(left, right, artifacts) {
         return get_true_inquality_assertions(left, right, assertion_context, true_position);
     }
 
@@ -1142,6 +1156,7 @@ fn get_true_equality_assertions(
     left: &Expression,
     is_identity: bool,
     right: &Expression,
+    artifacts: &mut AnalysisArtifacts,
     assertion_context: AssertionContext<'_>,
     true_position: OtherValuePosition,
 ) -> Vec<HashMap<String, AssertionSet>> {
@@ -1166,10 +1181,11 @@ fn get_true_equality_assertions(
             if_types.insert(var_name, vec![vec![Assertion::Truthy]]);
         }
 
-        return vec![if_types];
+        vec![if_types]
+    } else {
+        // If we can't get an expression ID, we can still assert that the expression is truthy.
+        scrape_assertions(base_conditional, artifacts, assertion_context)
     }
-
-    vec![]
 }
 
 pub fn has_typed_value_comparison(
@@ -1473,41 +1489,89 @@ pub fn has_enum_case_comparison(
 }
 
 #[inline]
-pub const fn has_null_variable(left: &Expression, right: &Expression) -> Option<OtherValuePosition> {
+pub fn has_null_variable(
+    left: &Expression,
+    right: &Expression,
+    artifacts: &AnalysisArtifacts,
+) -> Option<OtherValuePosition> {
     if let Expression::Literal(Literal::Null(_)) = unwrap_expression(right) {
         return Some(OtherValuePosition::Right);
     }
 
+    if let Some(right_type) = artifacts.get_expression_type(right)
+        && right_type.is_null()
+    {
+        return Some(OtherValuePosition::Right);
+    }
+
     if let Expression::Literal(Literal::Null(_)) = unwrap_expression(left) {
         return Some(OtherValuePosition::Left);
     }
 
+    if let Some(left_type) = artifacts.get_expression_type(left)
+        && left_type.is_null()
+    {
+        return Some(OtherValuePosition::Left);
+    }
+
     None
 }
 
 #[inline]
-pub const fn has_false_variable(left: &Expression, right: &Expression) -> Option<OtherValuePosition> {
+pub fn has_false_variable(
+    left: &Expression,
+    right: &Expression,
+    artifacts: &AnalysisArtifacts,
+) -> Option<OtherValuePosition> {
     if let Expression::Literal(Literal::False(_)) = unwrap_expression(right) {
         return Some(OtherValuePosition::Right);
     }
 
+    if let Some(right_type) = artifacts.get_expression_type(right)
+        && right_type.is_false()
+    {
+        return Some(OtherValuePosition::Right);
+    }
+
     if let Expression::Literal(Literal::False(_)) = unwrap_expression(left) {
         return Some(OtherValuePosition::Left);
     }
 
+    if let Some(left_type) = artifacts.get_expression_type(left)
+        && left_type.is_false()
+    {
+        return Some(OtherValuePosition::Left);
+    }
+
     None
 }
 
 #[inline]
-pub const fn has_true_variable(left: &Expression, right: &Expression) -> Option<OtherValuePosition> {
+pub fn has_true_variable(
+    left: &Expression,
+    right: &Expression,
+    artifacts: &AnalysisArtifacts,
+) -> Option<OtherValuePosition> {
     if let Expression::Literal(Literal::True(_)) = unwrap_expression(right) {
         return Some(OtherValuePosition::Right);
     }
 
+    if let Some(right_type) = artifacts.get_expression_type(right)
+        && right_type.is_true()
+    {
+        return Some(OtherValuePosition::Right);
+    }
+
     if let Expression::Literal(Literal::True(_)) = unwrap_expression(left) {
         return Some(OtherValuePosition::Left);
     }
 
+    if let Some(left_type) = artifacts.get_expression_type(left)
+        && left_type.is_true()
+    {
+        return Some(OtherValuePosition::Left);
+    }
+
     None
 }
 

crates/analyzer/src/code.rs

@@ -114,8 +114,6 @@ impl Code {
     pub const MATCH_EXPRESSION_ONLY_DEFAULT_ARM: &'static str = "match-expression-only-default-arm";
     pub const EMPTY_MATCH_EXPRESSION: &'static str = "empty-match-expression";
     pub const UNKNOWN_MATCH_SUBJECT_TYPE: &'static str = "unknown-match-subject-type";
-    pub const UNKNOWN_MATCH_CONDITION_TYPE: &'static str = "unknown-match-condition-type";
-    pub const UNREACHABLE_MATCH_ARM_CONDITION: &'static str = "unreachable-match-arm-condition";
     pub const UNREACHABLE_MATCH_ARM: &'static str = "unreachable-match-arm";
     pub const UNREACHABLE_MATCH_DEFAULT_ARM: &'static str = "unreachable-match-default-arm";
     pub const MATCH_ARM_ALWAYS_TRUE: &'static str = "match-arm-always-true";

crates/analyzer/src/common/synthetic.rs

@@ -10,17 +10,17 @@ pub fn new_synthetic_call(interner: &ThreadedInterner, f: &str, expression: Expr
     Expression::Call(Call::Function(FunctionCall {
         function: Box::new(Expression::Literal(Literal::String(LiteralString {
             kind: Some(LiteralStringKind::SingleQuoted),
-            span: Span::dummy(0, 1),
+            span: Span::zero(),
             raw: str_id,
             value: Some(f.to_string()),
         }))),
         argument_list: ArgumentList {
-            left_parenthesis: Span::dummy(0, 1),
+            left_parenthesis: Span::zero(),
             arguments: TokenSeparatedSequence::new(
                 vec![Argument::Positional(PositionalArgument { ellipsis: None, value: expression })],
                 vec![],
             ),
-            right_parenthesis: Span::dummy(0, 1),
+            right_parenthesis: Span::zero(),
         },
     }))
 }
@@ -38,6 +38,19 @@ pub fn new_synthetic_disjunctive_equality(
     expr
 }
 
+pub fn new_synthetic_disjunctive_identity(
+    subject: &Expression,
+    left: &Expression,
+    right: Vec<&Expression>,
+) -> Expression {
+    let mut expr = new_synthetic_identical(subject, left);
+    for r in right {
+        expr = new_synthetic_or(&expr, &new_synthetic_identical(subject, r));
+    }
+
+    expr
+}
+
 pub fn new_synthetic_negation(expression: &Expression) -> Expression {
     if let Expression::Binary(Binary { lhs, operator: BinaryOperator::And(_), rhs }) = expression {
         return new_synthetic_or(&new_synthetic_negation(lhs), &new_synthetic_negation(rhs));
@@ -49,16 +62,20 @@ pub fn new_synthetic_negation(expression: &Expression) -> Expression {
     })
 }
 
-pub fn new_synthetic_variable(interner: &ThreadedInterner, name: &str) -> Expression {
-    Expression::Variable(Variable::Direct(DirectVariable { span: Span::dummy(0, 1), name: interner.intern(name) }))
+pub fn new_synthetic_variable(interner: &ThreadedInterner, name: &str, span: Span) -> Expression {
+    Expression::Variable(Variable::Direct(DirectVariable { span, name: interner.intern(name) }))
+}
+
+pub fn new_synthetic_identical(left: &Expression, right: &Expression) -> Expression {
+    new_synthetic_binary(left, BinaryOperator::Identical(Span::zero()), right)
 }
 
 pub fn new_synthetic_equals(left: &Expression, right: &Expression) -> Expression {
-    new_synthetic_binary(left, BinaryOperator::Equal(Span::dummy(0, 1)), right)
+    new_synthetic_binary(left, BinaryOperator::Equal(Span::zero()), right)
 }
 
 pub fn new_synthetic_or(left: &Expression, right: &Expression) -> Expression {
-    new_synthetic_binary(left, BinaryOperator::Or(Span::dummy(0, 1)), right)
+    new_synthetic_binary(left, BinaryOperator::Or(Span::zero()), right)
 }
 
 pub fn new_synthetic_binary(left: &Expression, operator: BinaryOperator, right: &Expression) -> Expression {

crates/analyzer/src/context/block.rs

@@ -9,10 +9,14 @@ use mago_algebra::clause::Clause;
 use mago_codex::assertion::Assertion;
 use mago_codex::context::ScopeContext;
 use mago_codex::metadata::CodebaseMetadata;
+use mago_codex::ttype::TType;
 use mago_codex::ttype::add_optional_union_type;
 use mago_codex::ttype::atomic::TAtomic;
 use mago_codex::ttype::atomic::scalar::TScalar;
+use mago_codex::ttype::comparator::ComparisonResult;
+use mago_codex::ttype::comparator::union_comparator;
 use mago_codex::ttype::get_mixed;
+use mago_codex::ttype::get_never;
 use mago_codex::ttype::union::TUnion;
 use mago_collector::Collector;
 use mago_interner::StringIdentifier;
@@ -24,9 +28,9 @@ use crate::context::Context;
 use crate::context::scope::control_action::ControlAction;
 use crate::context::scope::finally_scope::FinallyScope;
 use crate::context::scope::var_has_root;
-use crate::expression::r#match::subtract_union_types;
 use crate::reconciler::ReconciliationContext;
 use crate::reconciler::assertion_reconciler;
+use crate::reconciler::negated_assertion_reconciler;
 
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub enum BreakContext {
@@ -666,6 +670,69 @@ fn substitute_types(
     add_optional_union_type(updated_type, new_type, context.codebase, context.interner)
 }
 
+/// Subtracts the types in `type_to_remove` from `existing_type`.
+///
+/// This function iterates through each atomic type in `existing_type`. For each of these,
+/// it iteratively applies the logic of "is not `atomic_from_remove_set`" for every
+/// atomic type in `type_to_remove`. This effectively refines each part of `existing_type`
+/// to exclude any possibilities covered by `type_to_remove`.
+///
+/// This is primarily useful for determining remaining possible types for a match subject
+/// after some conditional arms have been considered.
+///
+/// # Arguments
+///
+/// * `context` - The reconciliation context, providing access to codebase and interner.
+/// * `existing_type` - The initial `TUnion` type (the minuend).
+/// * `type_to_remove` - The `TUnion` type whose components should be subtracted from `existing_type`.
+///
+/// # Returns
+///
+/// A new `TUnion` representing `existing_type - type_to_remove`.
+pub fn subtract_union_types(context: &mut Context<'_>, existing_type: TUnion, type_to_remove: TUnion) -> TUnion {
+    if existing_type == type_to_remove {
+        return get_never();
+    }
+
+    if !(existing_type.has_literal_value() && type_to_remove.has_literal_value())
+        && union_comparator::is_contained_by(
+            context.codebase,
+            context.interner,
+            &existing_type,
+            &type_to_remove,
+            false,
+            false,
+            true,
+            &mut ComparisonResult::new(),
+        )
+    {
+        return existing_type;
+    }
+
+    let mut reconciliation_context = context.get_reconciliation_context();
+    let mut result = existing_type;
+    for atomic in type_to_remove.types {
+        let assertion = Assertion::IsNotType(atomic);
+        let key = result.get_id(Some(reconciliation_context.interner));
+        result = negated_assertion_reconciler::reconcile(
+            &mut reconciliation_context,
+            &assertion,
+            &result,
+            false,
+            None,
+            key,
+            None,
+            true,
+        );
+
+        if result.is_never() {
+            break;
+        }
+    }
+
+    result
+}
+
 fn should_keep_clause(clause: &Rc<Clause>, remove_var_id: &str, new_type: Option<&TUnion>) -> bool {
     if let Some(possibilities) = clause.possibilities.get(remove_var_id) {
         if possibilities.len() == 1

crates/analyzer/src/expression/binary/comparison.rs

@@ -348,6 +348,12 @@ fn report_redundant_comparison(
     comparison_description: &str,
     result_value_str: &str,
 ) {
+    let operator_span = binary.operator.span();
+    if operator_span.is_zero() {
+        // this is a synthetic node, do not report it.
+        return;
+    }
+
     context.collector.report_with_code(
         Code::REDUNDANT_COMPARISON,
         Issue::help(format!(

crates/analyzer/src/expression/binary/logical.rs

@@ -112,7 +112,7 @@ pub fn analyze_logical_and_operation<'a>(
             &mut changed_var_ids,
             &left_referenced_var_ids,
             &binary.rhs.span(),
-            true,
+            !binary.operator.span().is_zero(),
             !block_context.inside_negation,
         );
     } else {
@@ -473,7 +473,7 @@ pub fn analyze_logical_or_operation<'a>(
                 &mut right_changed_var_ids,
                 &right_referenced_var_ids,
                 &binary.rhs.span(),
-                true,
+                !binary.operator.span().is_zero(),
                 block_context.inside_negation,
             );
         }
@@ -642,6 +642,12 @@ fn report_redundant_logical_operation(
     rhs_description: &str,
     result_value_str: &str,
 ) {
+    let operator_span = binary.operator.span();
+    if operator_span.is_zero() {
+        // Do not report issues for synthetic nodes.
+        return;
+    }
+
     context.collector.report_with_code(
         Code::REDUNDANT_LOGICAL_OPERATION,
         Issue::help(format!(