luaur-analysis 0.1.3

Luau type checker and type inference (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
47
48
49
50
51
52
53

//! Node: `cxx:Method:Luau.Analysis:Analysis/src/OverloadResolver.cpp:175:overload_resolver_resolve_overload`
//! Source: `Analysis/src/OverloadResolver.cpp:175-196` (hand-ported)

use crate::functions::follow_type::follow_type_id;
use crate::functions::get_type_alt_j::get_type_id;
use crate::records::intersection_type::IntersectionType;
use crate::records::overload_resolution::OverloadResolution;
use crate::records::overload_resolver::OverloadResolver;
use crate::type_aliases::type_id::TypeId;
use crate::type_aliases::type_pack_id::TypePackId;
use luaur_ast::records::location::Location;
use luaur_common::records::dense_hash_set::DenseHashSet;

impl OverloadResolver {
    /// C++ `OverloadResolution resolveOverload(TypeId ty, TypePackId argsPack, Location fnLocation, NotNull<DenseHashSet<TypeId>> uniqueTypes, bool useFreeTypeBounds)`.
    pub fn resolve_overload(
        &mut self,
        ty: TypeId,
        args_pack: TypePackId,
        fn_location: Location,
        unique_types: *mut DenseHashSet<TypeId>,
        _use_free_type_bounds: bool,
    ) -> OverloadResolution {
        let mut result = OverloadResolution {
            ok: alloc::vec::Vec::new(),
            non_functions: alloc::vec::Vec::new(),
            potential_overloads: alloc::vec::Vec::new(),
            incompatible_overloads: alloc::vec::Vec::new(),
            arity_mismatches: alloc::vec::Vec::new(),
            metamethods: DenseHashSet::new(core::ptr::null_mut()),
        };

        let ty = unsafe { follow_type_id(ty) };

        let it = unsafe { get_type_id::<IntersectionType>(ty) };
        if !it.is_null() {
            let parts = unsafe { (*it).parts.clone() };
            for component in parts {
                self.test_function_or_union(
                    &mut result,
                    component,
                    args_pack,
                    fn_location,
                    unique_types,
                );
            }
        } else {
            self.test_function_or_union(&mut result, ty, args_pack, fn_location, unique_types);
        }

        result
    }
}