harn-parser 0.8.17

Parser, AST, and type checker for the Harn programming language
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

//! Type rules for binary operators.
//!
//! Pure helper that maps `(operator, left_type, right_type)` to the inferred
//! result type without touching scope or emitting diagnostics. The
//! diagnostic-emitting binary-op checker lives on `TypeChecker` itself
//! (`check_binops`) — see `inference::binary_ops`.

use crate::ast::*;

use super::scope::InferredType;
use super::union::{contains_nil, simplify_union, without_nil};

fn dict_like(ty: &TypeExpr) -> bool {
    matches!(ty, TypeExpr::Named(n) if n == "dict")
        || matches!(ty, TypeExpr::DictType(..))
        || matches!(ty, TypeExpr::Shape(_))
}

/// Infer the result type of a binary operation.
pub(super) fn infer_binary_op_type(
    op: &str,
    left: &InferredType,
    right: &InferredType,
) -> InferredType {
    match op {
        "==" | "!=" | "<" | ">" | "<=" | ">=" | "&&" | "||" | "in" | "not_in" => {
            Some(TypeExpr::Named("bool".into()))
        }
        "+" => match (left, right) {
            (Some(TypeExpr::Named(l)), Some(TypeExpr::Named(r))) => {
                match (l.as_str(), r.as_str()) {
                    ("int", "int") => Some(TypeExpr::Named("int".into())),
                    ("float", _) | (_, "float") => Some(TypeExpr::Named("float".into())),
                    ("string", "string") => Some(TypeExpr::Named("string".into())),
                    ("list", "list") => Some(TypeExpr::Named("list".into())),
                    ("dict", "dict") => Some(TypeExpr::Named("dict".into())),
                    _ => None,
                }
            }
            // dict + dict shallow-merges. Recognize parameterized and shape
            // forms so a `dict<string, V> + Shape{...}` chain (the common
            // connector/agent option-projection idiom) keeps the dict-shaped
            // typing instead of falling through to `None` and downgrading
            // every subsequent inference step to untyped.
            (Some(l), Some(r)) if dict_like(l) && dict_like(r) => {
                Some(TypeExpr::Named("dict".into()))
            }
            _ => None,
        },
        "-" | "/" | "%" => match (left, right) {
            (Some(TypeExpr::Named(l)), Some(TypeExpr::Named(r))) => {
                match (l.as_str(), r.as_str()) {
                    ("int", "int") => Some(TypeExpr::Named("int".into())),
                    ("float", _) | (_, "float") => Some(TypeExpr::Named("float".into())),
                    _ => None,
                }
            }
            _ => None,
        },
        "**" => match (left, right) {
            (Some(TypeExpr::Named(l)), Some(TypeExpr::Named(r))) => {
                match (l.as_str(), r.as_str()) {
                    ("int", "int") => Some(TypeExpr::Named("int".into())),
                    ("float", _) | (_, "float") => Some(TypeExpr::Named("float".into())),
                    _ => None,
                }
            }
            _ => None,
        },
        "*" => match (left, right) {
            (Some(TypeExpr::Named(l)), Some(TypeExpr::Named(r))) => {
                match (l.as_str(), r.as_str()) {
                    ("string", "int") | ("int", "string") => Some(TypeExpr::Named("string".into())),
                    ("int", "int") => Some(TypeExpr::Named("int".into())),
                    ("float", _) | (_, "float") => Some(TypeExpr::Named("float".into())),
                    _ => None,
                }
            }
            _ => None,
        },
        "??" => match (left, right) {
            (Some(left), right) => match without_nil(left) {
                // Left is only nil, so the result is exactly the fallback.
                None => right.clone(),
                // Left cannot be nil, so the fallback is unreachable.
                Some(non_nil_left) if !contains_nil(left) => Some(non_nil_left),
                // Left may be nil; include the fallback when its type is known.
                Some(non_nil_left) => match right {
                    Some(right) if &non_nil_left == right => Some(non_nil_left),
                    Some(right) => Some(simplify_union(vec![non_nil_left, right.clone()])),
                    None => Some(non_nil_left),
                },
            },
            // Unknown left: use right as best guess.
            (None, _) => right.clone(),
        },
        "|>" => None,
        _ => None,
    }
}