knave 0.9.3

A small Lisp for humans and agents that infers types and ownership and compiles to readable Rust
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

use rustc_hash::{FxHashMap, FxHashSet};

use crate::core::BindingId;
use crate::types::{Scheme, Type, TypedProgram};

pub struct UncoercedMethodParameters {
    positions: FxHashMap<BindingId, FxHashSet<usize>>,
}

impl UncoercedMethodParameters {
    pub fn of(program: &TypedProgram) -> Self {
        let receiverless_methods: FxHashSet<BindingId> = program
            .trait_definitions
            .iter()
            .flat_map(|definition| &definition.methods)
            .filter(|method| method.receiver.is_none())
            .map(|method| method.binding)
            .collect();
        let positions = program
            .modules
            .iter()
            .flat_map(|module| &module.definitions)
            .filter(|definition| receiverless_methods.contains(&definition.binding))
            .map(|definition| (definition.binding, Self::positions(&definition.scheme)))
            .collect();
        Self { positions }
    }

    pub fn contains(&self, method: BindingId, position: usize) -> bool {
        self.positions
            .get(&method)
            .is_some_and(|positions| positions.contains(&position))
    }

    fn positions(scheme: &Scheme) -> FxHashSet<usize> {
        let Type::Function(_, parameters, _) = &scheme.body else {
            unreachable!("a trait method has a function type")
        };
        parameters
            .iter()
            .enumerate()
            .filter(|(_, parameter)| parameter.is_generic_behind_shared_references())
            .map(|(position, _)| position)
            .collect()
    }
}