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
54
55
56
57

use crate::enums::variance::Variance;
use crate::functions::get_singleton_type::get_singleton_type;
use crate::functions::get_type_alt_j::get_type_id;
use crate::records::boolean_singleton::BooleanSingleton;
use crate::records::primitive_type::PrimitiveType;
use crate::records::singleton_type::SingletonType;
use crate::records::string_singleton::StringSingleton;
use crate::records::type_mismatch::TypeMismatch;
use crate::records::unifier::Unifier;
use crate::type_aliases::type_error_data::TypeErrorData;
use crate::type_aliases::type_id::TypeId;
use alloc::string::String;

impl Unifier {
    pub fn unifier_try_unify_singletons(&mut self, sub_ty: TypeId, super_ty: TypeId) {
        let super_prim = unsafe { get_type_id::<PrimitiveType>(super_ty) };
        let super_singleton = unsafe { get_type_id::<SingletonType>(super_ty) };
        let sub_singleton = unsafe { get_type_id::<SingletonType>(sub_ty) };

        if (super_prim.is_null() && super_singleton.is_null()) || sub_singleton.is_null() {
            self.ice_string("passed non singleton/primitive types to unifySingletons");
            return;
        }

        if !super_singleton.is_null() && unsafe { *super_singleton == *sub_singleton } {
            return;
        }

        if !super_prim.is_null()
            && unsafe { (*super_prim).r#type == PrimitiveType::Boolean }
            && !get_singleton_type::<BooleanSingleton>(sub_singleton).is_null()
            && self.variance == Variance::Covariant
        {
            return;
        }

        if !super_prim.is_null()
            && unsafe { (*super_prim).r#type == PrimitiveType::String }
            && !get_singleton_type::<StringSingleton>(sub_singleton).is_null()
            && self.variance == Variance::Covariant
        {
            return;
        }

        let context = self.unifier_mismatch_context();
        self.report_error_location_type_error_data(
            self.location,
            TypeErrorData::TypeMismatch(TypeMismatch {
                wanted_type: super_ty,
                given_type: sub_ty,
                reason: String::new(),
                error: None,
                context,
            }),
        );
    }
}