luaur_analysis/methods/
constraint_solver_try_dispatch_constraint_solver.rs

1use crate::functions::get_constraint::get_constraint;
2use crate::records::assign_index_constraint::AssignIndexConstraint;
3use crate::records::assign_prop_constraint::AssignPropConstraint;
4use crate::records::constraint::Constraint;
5use crate::records::constraint_solver::ConstraintSolver;
6use crate::records::equality_constraint::EqualityConstraint;
7use crate::records::function_call_constraint::FunctionCallConstraint;
8use crate::records::function_check_constraint::FunctionCheckConstraint;
9use crate::records::generalization_constraint::GeneralizationConstraint;
10use crate::records::has_indexer_constraint::HasIndexerConstraint;
11use crate::records::has_prop_constraint::HasPropConstraint;
12use crate::records::iterable_constraint::IterableConstraint;
13use crate::records::name_constraint::NameConstraint;
14use crate::records::pack_subtype_constraint::PackSubtypeConstraint;
15use crate::records::primitive_type_constraint::PrimitiveTypeConstraint;
16use crate::records::push_function_type_constraint::PushFunctionTypeConstraint;
17use crate::records::push_type_constraint::PushTypeConstraint;
18use crate::records::reduce_constraint::ReduceConstraint;
19use crate::records::reduce_pack_constraint::ReducePackConstraint;
20use crate::records::simplify_constraint::SimplifyConstraint;
21use crate::records::subtype_constraint::SubtypeConstraint;
22use crate::records::type_alias_expansion_constraint::TypeAliasExpansionConstraint;
23use crate::records::type_instantiation_constraint::TypeInstantiationConstraint;
24use crate::records::unpack_constraint::UnpackConstraint;
25use luaur_common::macros::luau_assert::LUAU_ASSERT;
26use luaur_common::FFlag;
27
28impl ConstraintSolver {
29    pub fn try_dispatch_not_null_constraint_bool(
30        &mut self,
31        constraint: *const Constraint,
32        force: bool,
33    ) -> bool {
34        if FFlag::LuauConstraintGraph.get() {
35            LUAU_ASSERT!(
36                force
37                    || !unsafe {
38                        (*self.cgraph).has_unsolved_dependencies(
39                            crate::type_aliases::constraint_vertex::ConstraintVertex::V2(
40                                constraint,
41                            ),
42                        )
43                    }
44            );
45        } else {
46            if !force && self.deprecate_d_is_blocked(constraint) {
47                return false;
48            }
49        }
50
51        let mut success = false;
52        let c = unsafe { &*constraint };
53
54        if let Some(sc) = unsafe { get_constraint::<SubtypeConstraint>(c).as_ref() } {
55            success = self.try_dispatch_subtype_constraint_not_null_constraint(sc, constraint);
56        } else if let Some(psc) = unsafe { get_constraint::<PackSubtypeConstraint>(c).as_ref() } {
57            success =
58                self.try_dispatch_pack_subtype_constraint_not_null_constraint(psc, constraint);
59        } else if let Some(gc) = unsafe { get_constraint::<GeneralizationConstraint>(c).as_ref() } {
60            success =
61                self.try_dispatch_generalization_constraint_not_null_constraint(gc, constraint);
62        } else if let Some(ic) = unsafe { get_constraint::<IterableConstraint>(c).as_ref() } {
63            success = self
64                .try_dispatch_iterable_constraint_not_null_constraint_bool(ic, constraint, force);
65        } else if let Some(nc) = unsafe { get_constraint::<NameConstraint>(c).as_ref() } {
66            success = self.try_dispatch_name_constraint_not_null_constraint(nc, constraint);
67        } else if let Some(taec) =
68            unsafe { get_constraint::<TypeAliasExpansionConstraint>(c).as_ref() }
69        {
70            success = self
71                .try_dispatch_type_alias_expansion_constraint_not_null_constraint(taec, constraint);
72        } else if let Some(fcc) = unsafe { get_constraint::<FunctionCallConstraint>(c).as_ref() } {
73            success = self.try_dispatch_function_call_constraint_not_null_constraint_bool(
74                fcc, constraint, force,
75            );
76        } else if let Some(fcc) = unsafe { get_constraint::<FunctionCheckConstraint>(c).as_ref() } {
77            success = self.try_dispatch_function_check_constraint_not_null_constraint_bool(
78                fcc, constraint, force,
79            );
80        } else if let Some(pc) = unsafe { get_constraint::<PrimitiveTypeConstraint>(c).as_ref() } {
81            success =
82                self.try_dispatch_primitive_type_constraint_not_null_constraint(pc, constraint);
83        } else if let Some(hpc) = unsafe { get_constraint::<HasPropConstraint>(c).as_ref() } {
84            success = self.try_dispatch_has_prop_constraint_not_null_constraint(hpc, constraint);
85        } else if let Some(spc) = unsafe { get_constraint::<HasIndexerConstraint>(c).as_ref() } {
86            success = self.try_dispatch_has_indexer_constraint_not_null_constraint(spc, constraint);
87        } else if let Some(uc) = unsafe { get_constraint::<AssignPropConstraint>(c).as_ref() } {
88            success = self.try_dispatch_assign_prop_constraint_not_null_constraint(uc, constraint);
89        } else if let Some(uc) = unsafe { get_constraint::<AssignIndexConstraint>(c).as_ref() } {
90            success = self.try_dispatch_assign_index_constraint_not_null_constraint(uc, constraint);
91        } else if let Some(uc) = unsafe { get_constraint::<UnpackConstraint>(c).as_ref() } {
92            success = self.try_dispatch_unpack_constraint_not_null_constraint(uc, constraint);
93        } else if let Some(rc) = unsafe { get_constraint::<ReduceConstraint>(c).as_ref() } {
94            success =
95                self.try_dispatch_reduce_constraint_not_null_constraint_bool(rc, constraint, force);
96        } else if let Some(rpc) = unsafe { get_constraint::<ReducePackConstraint>(c).as_ref() } {
97            success = self.try_dispatch_reduce_pack_constraint_not_null_constraint_bool(
98                rpc, constraint, force,
99            );
100        } else if let Some(eqc) = unsafe { get_constraint::<EqualityConstraint>(c).as_ref() } {
101            success = self.try_dispatch_equality_constraint_not_null_constraint(eqc, constraint);
102        } else if let Some(sc) = unsafe { get_constraint::<SimplifyConstraint>(c).as_ref() } {
103            success = self
104                .try_dispatch_simplify_constraint_not_null_constraint_bool(sc, constraint, force);
105        } else if let Some(pftc) =
106            unsafe { get_constraint::<PushFunctionTypeConstraint>(c).as_ref() }
107        {
108            success = self
109                .try_dispatch_push_function_type_constraint_not_null_constraint(pftc, constraint);
110        } else if let Some(esgc) =
111            unsafe { get_constraint::<TypeInstantiationConstraint>(c).as_ref() }
112        {
113            LUAU_ASSERT!(FFlag::LuauExplicitTypeInstantiationSupport.get());
114            success = self
115                .try_dispatch_type_instantiation_constraint_not_null_constraint(esgc, constraint);
116        } else if let Some(ptc) = unsafe { get_constraint::<PushTypeConstraint>(c).as_ref() } {
117            success = self
118                .try_dispatch_push_type_constraint_not_null_constraint_bool(ptc, constraint, force);
119        } else {
120            LUAU_ASSERT!(false);
121        }
122
123        success
124    }
125}
luaur_analysis/methods/constraint_solver_try_dispatch_constraint_solver.rs

luaur_analysis/methods/
constraint_solver_try_dispatch_constraint_solver.rs
