Branch data Line data Source code
1 : : // Copyright (C) 2020-2025 Free Software Foundation, Inc.
2 : :
3 : : // This file is part of GCC.
4 : :
5 : : // GCC is free software; you can redistribute it and/or modify it under
6 : : // the terms of the GNU General Public License as published by the Free
7 : : // Software Foundation; either version 3, or (at your option) any later
8 : : // version.
9 : :
10 : : // GCC is distributed in the hope that it will be useful, but WITHOUT ANY
11 : : // WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 : : // FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 : : // for more details.
14 : :
15 : : // You should have received a copy of the GNU General Public License
16 : : // along with GCC; see the file COPYING3. If not see
17 : : // <http://www.gnu.org/licenses/>.
18 : :
19 : : #include "rust-unify.h"
20 : :
21 : : namespace Rust {
22 : : namespace Resolver {
23 : :
24 : 201840 : UnifyRules::UnifyRules (TyTy::TyWithLocation lhs, TyTy::TyWithLocation rhs,
25 : : location_t locus, bool commit_flag, bool emit_error,
26 : : bool infer, std::vector<CommitSite> &commits,
27 : 201840 : std::vector<InferenceSite> &infers)
28 : 201840 : : lhs (lhs), rhs (rhs), locus (locus), commit_flag (commit_flag),
29 : 201840 : emit_error (emit_error), infer_flag (infer), commits (commits),
30 : 201840 : infers (infers), mappings (Analysis::Mappings::get ()),
31 : 201840 : context (*TypeCheckContext::get ())
32 : 201840 : {}
33 : :
34 : : TyTy::BaseType *
35 : 201840 : UnifyRules::Resolve (TyTy::TyWithLocation lhs, TyTy::TyWithLocation rhs,
36 : : location_t locus, bool commit_flag, bool emit_error,
37 : : bool infer, std::vector<CommitSite> &commits,
38 : : std::vector<InferenceSite> &infers)
39 : : {
40 : 201840 : UnifyRules r (lhs, rhs, locus, commit_flag, emit_error, infer, commits,
41 : 201840 : infers);
42 : :
43 : 201840 : TyTy::BaseType *result = r.go ();
44 : 201840 : commits.push_back ({lhs.get_ty (), rhs.get_ty (), result});
45 : 201840 : if (r.commit_flag)
46 : 68153 : UnifyRules::commit (lhs.get_ty (), rhs.get_ty (), result);
47 : :
48 : 201840 : bool failed = result->get_kind () == TyTy::TypeKind::ERROR;
49 : 201840 : if (failed && r.emit_error)
50 : 86 : r.emit_type_mismatch ();
51 : :
52 : 201840 : return result;
53 : : }
54 : :
55 : : TyTy::BaseType *
56 : 0 : UnifyRules::get_base ()
57 : : {
58 : 0 : return lhs.get_ty ()->destructure ();
59 : : }
60 : :
61 : : TyTy::BaseType *
62 : 0 : UnifyRules::get_other ()
63 : : {
64 : 0 : return rhs.get_ty ()->destructure ();
65 : : }
66 : :
67 : : void
68 : 158235 : UnifyRules::commit (TyTy::BaseType *base, TyTy::BaseType *other,
69 : : TyTy::BaseType *resolved)
70 : : {
71 : 158235 : TypeCheckContext &context = *TypeCheckContext::get ();
72 : 158235 : Analysis::Mappings &mappings = Analysis::Mappings::get ();
73 : :
74 : 158235 : TyTy::BaseType *b = base->destructure ();
75 : 158235 : TyTy::BaseType *o = other->destructure ();
76 : :
77 : 158235 : resolved->append_reference (b->get_ref ());
78 : 158235 : resolved->append_reference (o->get_ref ());
79 : 1643428 : for (auto ref : b->get_combined_refs ())
80 : 1485193 : resolved->append_reference (ref);
81 : 5281622 : for (auto ref : o->get_combined_refs ())
82 : 5123387 : resolved->append_reference (ref);
83 : :
84 : 158235 : o->append_reference (resolved->get_ref ());
85 : 158235 : o->append_reference (b->get_ref ());
86 : 158235 : b->append_reference (resolved->get_ref ());
87 : 158235 : b->append_reference (o->get_ref ());
88 : :
89 : 158235 : bool result_resolved = resolved->get_kind () != TyTy::TypeKind::INFER;
90 : 158235 : bool result_is_infer_var = resolved->get_kind () == TyTy::TypeKind::INFER;
91 : 158235 : bool results_is_non_general_infer_var
92 : : = (result_is_infer_var
93 : 158235 : && (static_cast<TyTy::InferType *> (resolved))->get_infer_kind ()
94 : 311514 : != TyTy::InferType::GENERAL);
95 : 153409 : if (result_resolved || results_is_non_general_infer_var)
96 : : {
97 : 6632857 : for (auto &ref : resolved->get_combined_refs ())
98 : : {
99 : 6474752 : TyTy::BaseType *ref_tyty = nullptr;
100 : 6474752 : bool ok = context.lookup_type (ref, &ref_tyty);
101 : 6474752 : if (!ok)
102 : 2983 : continue;
103 : :
104 : : // if any of the types are inference variables lets fix them
105 : 6471769 : if (ref_tyty->get_kind () == TyTy::TypeKind::INFER)
106 : : {
107 : 114866 : auto node = Analysis::NodeMapping (mappings.get_current_crate (),
108 : : UNKNOWN_NODEID, ref,
109 : 114866 : UNKNOWN_LOCAL_DEFID);
110 : 114866 : context.insert_type (node, resolved->clone ());
111 : : }
112 : 158105 : }
113 : : }
114 : 158235 : }
115 : :
116 : : void
117 : 86 : UnifyRules::emit_type_mismatch () const
118 : : {
119 : 86 : TyTy::BaseType *expected = lhs.get_ty ();
120 : 86 : TyTy::BaseType *expr = rhs.get_ty ();
121 : :
122 : 86 : rich_location r (line_table, locus);
123 : 86 : r.add_range (lhs.get_locus ());
124 : 86 : r.add_range (rhs.get_locus ());
125 : 86 : rust_error_at (r, ErrorCode::E0308,
126 : : "mismatched types, expected %qs but got %qs",
127 : 172 : expected->get_name ().c_str (), expr->get_name ().c_str ());
128 : 86 : }
129 : :
130 : : void
131 : 0 : UnifyRules::emit_abi_mismatch (const TyTy::FnType &expected,
132 : : const TyTy::FnType &got) const
133 : : {
134 : 0 : rich_location r (line_table, locus);
135 : 0 : r.add_range (lhs.get_locus ());
136 : 0 : r.add_range (rhs.get_locus ());
137 : 0 : rust_error_at (r, "mistached abi %qs got %qs",
138 : 0 : get_string_from_abi (expected.get_abi ()).c_str (),
139 : 0 : get_string_from_abi (got.get_abi ()).c_str ());
140 : 0 : }
141 : :
142 : : TyTy::BaseType *
143 : 201840 : UnifyRules::go ()
144 : : {
145 : 201840 : TyTy::BaseType *ltype = lhs.get_ty ();
146 : 201840 : TyTy::BaseType *rtype = rhs.get_ty ();
147 : :
148 : 201840 : ltype = lhs.get_ty ()->destructure ();
149 : 201840 : rtype = rhs.get_ty ()->destructure ();
150 : :
151 : 201840 : rust_debug ("unify::go ltype={%s} rtype={%s}", ltype->debug_str ().c_str (),
152 : : rtype->debug_str ().c_str ());
153 : :
154 : : // check bounds
155 : 201840 : bool ltype_is_placeholder = ltype->get_kind () == TyTy::TypeKind::PLACEHOLDER;
156 : 201840 : bool rtype_is_placeholder = rtype->get_kind () == TyTy::TypeKind::PLACEHOLDER;
157 : 201840 : bool types_equal = ltype->is_equal (*rtype);
158 : 485312 : bool should_check_bounds
159 : 201840 : = !types_equal && !(ltype_is_placeholder || rtype_is_placeholder);
160 : 82314 : if (should_check_bounds)
161 : : {
162 : 82314 : if (ltype->num_specified_bounds () > 0)
163 : : {
164 : 9789 : if (!ltype->bounds_compatible (*rtype, locus, emit_error))
165 : : {
166 : : // already emitted an error
167 : 567 : emit_error = false;
168 : 567 : return new TyTy::ErrorType (0);
169 : : }
170 : : }
171 : 72525 : else if (rtype->num_specified_bounds () > 0)
172 : : {
173 : 1061 : if (!rtype->bounds_compatible (*ltype, locus, emit_error))
174 : : {
175 : : // already emitted an error
176 : 115 : emit_error = false;
177 : 115 : return new TyTy::ErrorType (0);
178 : : }
179 : : }
180 : : }
181 : :
182 : 201158 : if (infer_flag)
183 : : {
184 : 83279 : bool rgot_param = rtype->get_kind () == TyTy::TypeKind::PARAM;
185 : 83279 : bool lhs_is_infer_var = ltype->get_kind () == TyTy::TypeKind::INFER;
186 : 83279 : bool lhs_is_general_infer_var
187 : : = lhs_is_infer_var
188 : 83279 : && static_cast<TyTy::InferType *> (ltype)->get_infer_kind ()
189 : 83279 : == TyTy::InferType::GENERAL;
190 : 83279 : bool expected_is_concrete
191 : 83279 : = ltype->is_concrete () && !lhs_is_general_infer_var;
192 : 83279 : bool rneeds_infer = expected_is_concrete && (rgot_param);
193 : :
194 : 83279 : bool lgot_param = ltype->get_kind () == TyTy::TypeKind::PARAM;
195 : 83279 : bool rhs_is_infer_var = rtype->get_kind () == TyTy::TypeKind::INFER;
196 : 83279 : bool rhs_is_general_infer_var
197 : : = rhs_is_infer_var
198 : 83279 : && static_cast<TyTy::InferType *> (rtype)->get_infer_kind ()
199 : 83279 : == TyTy::InferType::GENERAL;
200 : 83279 : bool receiver_is_concrete
201 : 83279 : = rtype->is_concrete () && !rhs_is_general_infer_var;
202 : 83279 : bool lneeds_infer = receiver_is_concrete && (lgot_param);
203 : :
204 : 83279 : if (rneeds_infer)
205 : : {
206 : 384 : TyTy::ParamType *p = static_cast<TyTy::ParamType *> (rtype);
207 : 384 : TyTy::TyVar iv
208 : 384 : = TyTy::TyVar::get_implicit_infer_var (rhs.get_locus ());
209 : 384 : rust_assert (iv.get_tyty ()->get_kind () == TyTy::TypeKind::INFER);
210 : 384 : TyTy::InferType *i = static_cast<TyTy::InferType *> (iv.get_tyty ());
211 : :
212 : 384 : infers.push_back ({p->get_ref (), p->get_ty_ref (), p, i});
213 : :
214 : : // FIXME
215 : : // this is hacky to set the implicit param lets make this a function
216 : 384 : p->set_ty_ref (i->get_ref ());
217 : :
218 : : // set the rtype now to the new inference var
219 : 384 : rtype = i;
220 : : }
221 : 82895 : else if (lneeds_infer)
222 : : {
223 : 2612 : TyTy::ParamType *p = static_cast<TyTy::ParamType *> (ltype);
224 : 2612 : TyTy::TyVar iv
225 : 2612 : = TyTy::TyVar::get_implicit_infer_var (lhs.get_locus ());
226 : 2612 : rust_assert (iv.get_tyty ()->get_kind () == TyTy::TypeKind::INFER);
227 : 2612 : TyTy::InferType *i = static_cast<TyTy::InferType *> (iv.get_tyty ());
228 : :
229 : 2612 : infers.push_back ({p->get_ref (), p->get_ty_ref (), p, i});
230 : :
231 : : // FIXME
232 : : // this is hacky to set the implicit param lets make this a function
233 : 2612 : p->set_ty_ref (i->get_ref ());
234 : :
235 : : // set the rtype now to the new inference var
236 : 2612 : ltype = i;
237 : : }
238 : : }
239 : :
240 : 201158 : switch (ltype->get_kind ())
241 : : {
242 : 54285 : case TyTy::INFER:
243 : 54285 : return expect_inference_variable (static_cast<TyTy::InferType *> (ltype),
244 : 54285 : rtype);
245 : :
246 : 11799 : case TyTy::ADT:
247 : 11799 : return expect_adt (static_cast<TyTy::ADTType *> (ltype), rtype);
248 : :
249 : 4922 : case TyTy::STR:
250 : 4922 : return expect_str (static_cast<TyTy::StrType *> (ltype), rtype);
251 : :
252 : 11005 : case TyTy::REF:
253 : 11005 : return expect_reference (static_cast<TyTy::ReferenceType *> (ltype),
254 : 11005 : rtype);
255 : :
256 : 15530 : case TyTy::POINTER:
257 : 15530 : return expect_pointer (static_cast<TyTy::PointerType *> (ltype), rtype);
258 : :
259 : 7418 : case TyTy::PARAM:
260 : 7418 : return expect_param (static_cast<TyTy::ParamType *> (ltype), rtype);
261 : :
262 : 1547 : case TyTy::ARRAY:
263 : 1547 : return expect_array (static_cast<TyTy::ArrayType *> (ltype), rtype);
264 : :
265 : 1839 : case TyTy::SLICE:
266 : 1839 : return expect_slice (static_cast<TyTy::SliceType *> (ltype), rtype);
267 : :
268 : 3241 : case TyTy::FNDEF:
269 : 3241 : return expect_fndef (static_cast<TyTy::FnType *> (ltype), rtype);
270 : :
271 : 92 : case TyTy::FNPTR:
272 : 92 : return expect_fnptr (static_cast<TyTy::FnPtr *> (ltype), rtype);
273 : :
274 : 11388 : case TyTy::TUPLE:
275 : 11388 : return expect_tuple (static_cast<TyTy::TupleType *> (ltype), rtype);
276 : :
277 : 5490 : case TyTy::BOOL:
278 : 5490 : return expect_bool (static_cast<TyTy::BoolType *> (ltype), rtype);
279 : :
280 : 1120 : case TyTy::CHAR:
281 : 1120 : return expect_char (static_cast<TyTy::CharType *> (ltype), rtype);
282 : :
283 : 29133 : case TyTy::INT:
284 : 29133 : return expect_int (static_cast<TyTy::IntType *> (ltype), rtype);
285 : :
286 : 20001 : case TyTy::UINT:
287 : 20001 : return expect_uint (static_cast<TyTy::UintType *> (ltype), rtype);
288 : :
289 : 7592 : case TyTy::FLOAT:
290 : 7592 : return expect_float (static_cast<TyTy::FloatType *> (ltype), rtype);
291 : :
292 : 10090 : case TyTy::USIZE:
293 : 10090 : return expect_usize (static_cast<TyTy::USizeType *> (ltype), rtype);
294 : :
295 : 2129 : case TyTy::ISIZE:
296 : 2129 : return expect_isize (static_cast<TyTy::ISizeType *> (ltype), rtype);
297 : :
298 : 277 : case TyTy::NEVER:
299 : 277 : return expect_never (static_cast<TyTy::NeverType *> (ltype), rtype);
300 : :
301 : 1606 : case TyTy::PLACEHOLDER:
302 : 1606 : return expect_placeholder (static_cast<TyTy::PlaceholderType *> (ltype),
303 : 1606 : rtype);
304 : :
305 : 0 : case TyTy::PROJECTION:
306 : 0 : return expect_projection (static_cast<TyTy::ProjectionType *> (ltype),
307 : 0 : rtype);
308 : :
309 : 554 : case TyTy::DYNAMIC:
310 : 554 : return expect_dyn (static_cast<TyTy::DynamicObjectType *> (ltype), rtype);
311 : :
312 : 100 : case TyTy::CLOSURE:
313 : 100 : return expect_closure (static_cast<TyTy::ClosureType *> (ltype), rtype);
314 : :
315 : 0 : case TyTy::OPAQUE:
316 : 0 : return expect_opaque (static_cast<TyTy::OpaqueType *> (ltype), rtype);
317 : :
318 : 0 : case TyTy::ERROR:
319 : 0 : return new TyTy::ErrorType (0);
320 : : }
321 : :
322 : 0 : return new TyTy::ErrorType (0);
323 : : }
324 : :
325 : : TyTy::BaseType *
326 : 54285 : UnifyRules::expect_inference_variable (TyTy::InferType *ltype,
327 : : TyTy::BaseType *rtype)
328 : : {
329 : 54285 : switch (rtype->get_kind ())
330 : : {
331 : 5170 : case TyTy::INFER: {
332 : 5170 : TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
333 : 5170 : switch (ltype->get_infer_kind ())
334 : : {
335 : 1512 : case TyTy::InferType::InferTypeKind::GENERAL:
336 : 1512 : return rtype->clone ();
337 : :
338 : 3626 : case TyTy::InferType::InferTypeKind::INTEGRAL: {
339 : 3626 : bool is_valid = r->get_infer_kind ()
340 : : == TyTy::InferType::InferTypeKind::INTEGRAL
341 : 3626 : || r->get_infer_kind ()
342 : 3660 : == TyTy::InferType::InferTypeKind::GENERAL;
343 : 3622 : if (is_valid)
344 : 3622 : return rtype->clone ();
345 : : }
346 : : break;
347 : :
348 : 32 : case TyTy::InferType::InferTypeKind::FLOAT: {
349 : 32 : bool is_valid
350 : 32 : = r->get_infer_kind () == TyTy::InferType::InferTypeKind::FLOAT
351 : 32 : || r->get_infer_kind ()
352 : 70 : == TyTy::InferType::InferTypeKind::GENERAL;
353 : 32 : if (is_valid)
354 : 32 : return rtype->clone ();
355 : : }
356 : : break;
357 : : }
358 : : }
359 : : break;
360 : :
361 : 43615 : case TyTy::INT:
362 : 43615 : case TyTy::UINT:
363 : 43615 : case TyTy::USIZE:
364 : 43615 : case TyTy::ISIZE: {
365 : 43615 : bool is_valid = (ltype->get_infer_kind ()
366 : : == TyTy::InferType::InferTypeKind::GENERAL)
367 : 43615 : || (ltype->get_infer_kind ()
368 : 43653 : == TyTy::InferType::InferTypeKind::INTEGRAL);
369 : 43615 : if (is_valid)
370 : : {
371 : 43615 : ltype->apply_primitive_type_hint (*rtype);
372 : 43615 : return rtype->clone ();
373 : : }
374 : : }
375 : : break;
376 : :
377 : 1496 : case TyTy::FLOAT: {
378 : 1496 : bool is_valid = (ltype->get_infer_kind ()
379 : : == TyTy::InferType::InferTypeKind::GENERAL)
380 : 1496 : || (ltype->get_infer_kind ()
381 : 1534 : == TyTy::InferType::InferTypeKind::FLOAT);
382 : 1496 : if (is_valid)
383 : : {
384 : 1496 : ltype->apply_primitive_type_hint (*rtype);
385 : 1496 : return rtype->clone ();
386 : : }
387 : : }
388 : : break;
389 : :
390 : 4004 : case TyTy::ADT:
391 : 4004 : case TyTy::STR:
392 : 4004 : case TyTy::REF:
393 : 4004 : case TyTy::POINTER:
394 : 4004 : case TyTy::PARAM:
395 : 4004 : case TyTy::ARRAY:
396 : 4004 : case TyTy::SLICE:
397 : 4004 : case TyTy::FNDEF:
398 : 4004 : case TyTy::FNPTR:
399 : 4004 : case TyTy::TUPLE:
400 : 4004 : case TyTy::BOOL:
401 : 4004 : case TyTy::CHAR:
402 : 4004 : case TyTy::NEVER:
403 : 4004 : case TyTy::PLACEHOLDER:
404 : 4004 : case TyTy::PROJECTION:
405 : 4004 : case TyTy::DYNAMIC:
406 : 4004 : case TyTy::CLOSURE:
407 : 4004 : case TyTy::OPAQUE: {
408 : 4004 : bool is_valid = (ltype->get_infer_kind ()
409 : 4004 : == TyTy::InferType::InferTypeKind::GENERAL);
410 : 4004 : if (is_valid)
411 : 3970 : return rtype->clone ();
412 : : }
413 : : break;
414 : :
415 : 0 : case TyTy::ERROR:
416 : 0 : return new TyTy::ErrorType (0);
417 : : }
418 : :
419 : 38 : return new TyTy::ErrorType (0);
420 : : }
421 : :
422 : : TyTy::BaseType *
423 : 11799 : UnifyRules::expect_adt (TyTy::ADTType *ltype, TyTy::BaseType *rtype)
424 : : {
425 : 11799 : switch (rtype->get_kind ())
426 : : {
427 : 96 : case TyTy::INFER: {
428 : 96 : TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
429 : 96 : bool is_valid
430 : 96 : = r->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL;
431 : 96 : if (is_valid)
432 : 96 : return ltype->clone ();
433 : : }
434 : : break;
435 : :
436 : 10458 : case TyTy::ADT: {
437 : 10458 : TyTy::ADTType &type = *static_cast<TyTy::ADTType *> (rtype);
438 : 10458 : if (ltype->get_adt_kind () != type.get_adt_kind ())
439 : : {
440 : 71 : return new TyTy::ErrorType (0);
441 : : }
442 : :
443 : 31161 : if (ltype->get_identifier ().compare (type.get_identifier ()) != 0)
444 : : {
445 : 131 : return new TyTy::ErrorType (0);
446 : : }
447 : :
448 : 10256 : if (ltype->number_of_variants () != type.number_of_variants ())
449 : : {
450 : 0 : return new TyTy::ErrorType (0);
451 : : }
452 : :
453 : 24114 : for (size_t i = 0; i < type.number_of_variants (); ++i)
454 : : {
455 : 13924 : TyTy::VariantDef *a = ltype->get_variants ().at (i);
456 : 13924 : TyTy::VariantDef *b = type.get_variants ().at (i);
457 : :
458 : 13924 : if (a->num_fields () != b->num_fields ())
459 : : {
460 : 0 : return new TyTy::ErrorType (0);
461 : : }
462 : :
463 : 30384 : for (size_t j = 0; j < a->num_fields (); j++)
464 : : {
465 : 16526 : TyTy::StructFieldType *base_field = a->get_field_at_index (j);
466 : 16526 : TyTy::StructFieldType *other_field = b->get_field_at_index (j);
467 : :
468 : 16526 : TyTy::BaseType *this_field_ty = base_field->get_field_type ();
469 : 16526 : TyTy::BaseType *other_field_ty = other_field->get_field_type ();
470 : :
471 : 16526 : TyTy::BaseType *unified_ty
472 : 16526 : = UnifyRules::Resolve (TyTy::TyWithLocation (this_field_ty),
473 : 16526 : TyTy::TyWithLocation (other_field_ty),
474 : 16526 : locus, commit_flag,
475 : 16526 : false /* emit_error */, infer_flag,
476 : : commits, infers);
477 : 16526 : if (unified_ty->get_kind () == TyTy::TypeKind::ERROR)
478 : : {
479 : 66 : return new TyTy::ErrorType (0);
480 : : }
481 : : }
482 : : }
483 : :
484 : : // generic args for the unit-struct case
485 : 10190 : if (type.is_unit () && ltype->is_unit ())
486 : : {
487 : 1205 : rust_assert (type.get_num_substitutions ()
488 : : == ltype->get_num_substitutions ());
489 : :
490 : 1251 : for (size_t i = 0; i < type.get_num_substitutions (); i++)
491 : : {
492 : 46 : auto &a = ltype->get_substs ().at (i);
493 : 46 : auto &b = type.get_substs ().at (i);
494 : :
495 : 46 : auto pa = a.get_param_ty ();
496 : 46 : auto pb = b.get_param_ty ();
497 : :
498 : 46 : auto res
499 : 46 : = UnifyRules::Resolve (TyTy::TyWithLocation (pa),
500 : 46 : TyTy::TyWithLocation (pb), locus,
501 : 46 : commit_flag, false /* emit_error */,
502 : 46 : infer_flag, commits, infers);
503 : 46 : if (res->get_kind () == TyTy::TypeKind::ERROR)
504 : : {
505 : 0 : return new TyTy::ErrorType (0);
506 : : }
507 : : }
508 : : }
509 : :
510 : 10190 : return type.clone ();
511 : : }
512 : 1245 : break;
513 : :
514 : 1245 : case TyTy::STR:
515 : 1245 : case TyTy::REF:
516 : 1245 : case TyTy::POINTER:
517 : 1245 : case TyTy::PARAM:
518 : 1245 : case TyTy::ARRAY:
519 : 1245 : case TyTy::SLICE:
520 : 1245 : case TyTy::FNDEF:
521 : 1245 : case TyTy::FNPTR:
522 : 1245 : case TyTy::TUPLE:
523 : 1245 : case TyTy::BOOL:
524 : 1245 : case TyTy::CHAR:
525 : 1245 : case TyTy::INT:
526 : 1245 : case TyTy::UINT:
527 : 1245 : case TyTy::FLOAT:
528 : 1245 : case TyTy::USIZE:
529 : 1245 : case TyTy::ISIZE:
530 : 1245 : case TyTy::NEVER:
531 : 1245 : case TyTy::PLACEHOLDER:
532 : 1245 : case TyTy::PROJECTION:
533 : 1245 : case TyTy::DYNAMIC:
534 : 1245 : case TyTy::CLOSURE:
535 : 1245 : case TyTy::OPAQUE:
536 : 1245 : case TyTy::ERROR:
537 : 1245 : return new TyTy::ErrorType (0);
538 : : }
539 : 0 : return new TyTy::ErrorType (0);
540 : : }
541 : :
542 : : TyTy::BaseType *
543 : 4922 : UnifyRules::expect_str (TyTy::StrType *ltype, TyTy::BaseType *rtype)
544 : : {
545 : 4922 : switch (rtype->get_kind ())
546 : : {
547 : 0 : case TyTy::INFER: {
548 : 0 : TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
549 : 0 : bool is_valid
550 : 0 : = r->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL;
551 : 0 : if (is_valid)
552 : 0 : return ltype->clone ();
553 : : }
554 : : break;
555 : :
556 : 4901 : case TyTy::STR:
557 : 4901 : return rtype->clone ();
558 : :
559 : 21 : case TyTy::ADT:
560 : 21 : case TyTy::REF:
561 : 21 : case TyTy::POINTER:
562 : 21 : case TyTy::PARAM:
563 : 21 : case TyTy::ARRAY:
564 : 21 : case TyTy::SLICE:
565 : 21 : case TyTy::FNDEF:
566 : 21 : case TyTy::FNPTR:
567 : 21 : case TyTy::TUPLE:
568 : 21 : case TyTy::BOOL:
569 : 21 : case TyTy::CHAR:
570 : 21 : case TyTy::INT:
571 : 21 : case TyTy::UINT:
572 : 21 : case TyTy::FLOAT:
573 : 21 : case TyTy::USIZE:
574 : 21 : case TyTy::ISIZE:
575 : 21 : case TyTy::NEVER:
576 : 21 : case TyTy::PLACEHOLDER:
577 : 21 : case TyTy::PROJECTION:
578 : 21 : case TyTy::DYNAMIC:
579 : 21 : case TyTy::CLOSURE:
580 : 21 : case TyTy::OPAQUE:
581 : 21 : case TyTy::ERROR:
582 : 21 : return new TyTy::ErrorType (0);
583 : : }
584 : 0 : return new TyTy::ErrorType (0);
585 : : }
586 : :
587 : : TyTy::BaseType *
588 : 11005 : UnifyRules::expect_reference (TyTy::ReferenceType *ltype, TyTy::BaseType *rtype)
589 : : {
590 : 11005 : switch (rtype->get_kind ())
591 : : {
592 : 37 : case TyTy::INFER: {
593 : 37 : TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
594 : 37 : bool is_valid
595 : 37 : = r->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL;
596 : 37 : if (is_valid)
597 : 30 : return ltype->clone ();
598 : : }
599 : : break;
600 : :
601 : 10663 : case TyTy::REF: {
602 : 10663 : TyTy::ReferenceType &type = *static_cast<TyTy::ReferenceType *> (rtype);
603 : 10663 : auto base_type = ltype->get_base ();
604 : 10663 : auto other_base_type = type.get_base ();
605 : :
606 : 10663 : TyTy::BaseType *base_resolved
607 : 10663 : = UnifyRules::Resolve (TyTy::TyWithLocation (base_type),
608 : 10663 : TyTy::TyWithLocation (other_base_type), locus,
609 : 10663 : commit_flag, false /* emit_error */,
610 : 10663 : infer_flag, commits, infers);
611 : 10663 : if (base_resolved->get_kind () == TyTy::TypeKind::ERROR)
612 : : {
613 : 1611 : return new TyTy::ErrorType (0);
614 : : }
615 : :
616 : : // rust is permissive about mutablity here you can always go from
617 : : // mutable to immutable but not the otherway round
618 : 9052 : bool mutability_ok = ltype->is_mutable () ? type.is_mutable () : true;
619 : 1056 : if (!mutability_ok)
620 : : {
621 : 4 : return new TyTy::ErrorType (0);
622 : : }
623 : :
624 : 9048 : return new TyTy::ReferenceType (ltype->get_ref (), ltype->get_ty_ref (),
625 : 9048 : TyTy::TyVar (base_resolved->get_ref ()),
626 : 18096 : ltype->mutability ());
627 : : }
628 : 305 : break;
629 : :
630 : 305 : case TyTy::STR:
631 : 305 : case TyTy::ADT:
632 : 305 : case TyTy::POINTER:
633 : 305 : case TyTy::PARAM:
634 : 305 : case TyTy::ARRAY:
635 : 305 : case TyTy::SLICE:
636 : 305 : case TyTy::FNDEF:
637 : 305 : case TyTy::FNPTR:
638 : 305 : case TyTy::TUPLE:
639 : 305 : case TyTy::BOOL:
640 : 305 : case TyTy::CHAR:
641 : 305 : case TyTy::INT:
642 : 305 : case TyTy::UINT:
643 : 305 : case TyTy::FLOAT:
644 : 305 : case TyTy::USIZE:
645 : 305 : case TyTy::ISIZE:
646 : 305 : case TyTy::NEVER:
647 : 305 : case TyTy::PLACEHOLDER:
648 : 305 : case TyTy::PROJECTION:
649 : 305 : case TyTy::DYNAMIC:
650 : 305 : case TyTy::CLOSURE:
651 : 305 : case TyTy::OPAQUE:
652 : 305 : case TyTy::ERROR:
653 : 305 : return new TyTy::ErrorType (0);
654 : : }
655 : 7 : return new TyTy::ErrorType (0);
656 : : }
657 : :
658 : : TyTy::BaseType *
659 : 15530 : UnifyRules::expect_pointer (TyTy::PointerType *ltype, TyTy::BaseType *rtype)
660 : : {
661 : 15530 : switch (rtype->get_kind ())
662 : : {
663 : 0 : case TyTy::INFER: {
664 : 0 : TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
665 : 0 : bool is_valid
666 : 0 : = r->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL;
667 : 0 : if (is_valid)
668 : 0 : return ltype->clone ();
669 : : }
670 : : break;
671 : :
672 : 15524 : case TyTy::POINTER: {
673 : 15524 : TyTy::PointerType &type = *static_cast<TyTy::PointerType *> (rtype);
674 : 15524 : auto base_type = ltype->get_base ();
675 : 15524 : auto other_base_type = type.get_base ();
676 : :
677 : 15524 : TyTy::BaseType *base_resolved
678 : 15524 : = UnifyRules::Resolve (TyTy::TyWithLocation (base_type),
679 : 15524 : TyTy::TyWithLocation (other_base_type), locus,
680 : 15524 : commit_flag, false /* emit_error */,
681 : 15524 : infer_flag, commits, infers);
682 : 15524 : if (base_resolved->get_kind () == TyTy::TypeKind::ERROR)
683 : : {
684 : 1681 : return new TyTy::ErrorType (0);
685 : : }
686 : :
687 : : // rust is permissive about mutablity here you can always go from
688 : : // mutable to immutable but not the otherway round
689 : 13843 : bool mutability_ok = ltype->is_mutable () ? type.is_mutable () : true;
690 : 1964 : if (!mutability_ok)
691 : : {
692 : 0 : return new TyTy::ErrorType (0);
693 : : }
694 : :
695 : 13843 : return new TyTy::PointerType (ltype->get_ref (), ltype->get_ty_ref (),
696 : 13843 : TyTy::TyVar (base_resolved->get_ref ()),
697 : 27686 : ltype->mutability ());
698 : : }
699 : 6 : break;
700 : :
701 : 6 : case TyTy::STR:
702 : 6 : case TyTy::ADT:
703 : 6 : case TyTy::REF:
704 : 6 : case TyTy::PARAM:
705 : 6 : case TyTy::ARRAY:
706 : 6 : case TyTy::SLICE:
707 : 6 : case TyTy::FNDEF:
708 : 6 : case TyTy::FNPTR:
709 : 6 : case TyTy::TUPLE:
710 : 6 : case TyTy::BOOL:
711 : 6 : case TyTy::CHAR:
712 : 6 : case TyTy::INT:
713 : 6 : case TyTy::UINT:
714 : 6 : case TyTy::FLOAT:
715 : 6 : case TyTy::USIZE:
716 : 6 : case TyTy::ISIZE:
717 : 6 : case TyTy::NEVER:
718 : 6 : case TyTy::PLACEHOLDER:
719 : 6 : case TyTy::PROJECTION:
720 : 6 : case TyTy::DYNAMIC:
721 : 6 : case TyTy::CLOSURE:
722 : 6 : case TyTy::OPAQUE:
723 : 6 : case TyTy::ERROR:
724 : 6 : return new TyTy::ErrorType (0);
725 : : }
726 : 0 : return new TyTy::ErrorType (0);
727 : : }
728 : :
729 : : TyTy::BaseType *
730 : 7418 : UnifyRules::expect_param (TyTy::ParamType *ltype, TyTy::BaseType *rtype)
731 : : {
732 : 7418 : switch (rtype->get_kind ())
733 : : {
734 : 239 : case TyTy::INFER: {
735 : 239 : TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
736 : 239 : bool is_valid
737 : 239 : = r->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL;
738 : 239 : if (is_valid)
739 : 239 : return ltype->clone ();
740 : : }
741 : : break;
742 : :
743 : 7046 : case TyTy::PARAM: {
744 : 7046 : TyTy::ParamType &type = *static_cast<TyTy::ParamType *> (rtype);
745 : : // bool symbol_matches
746 : : // = ltype->get_symbol ().compare (type.get_symbol ()) == 0;
747 : : // // TODO
748 : : // // I think rustc checks a debruinj index
749 : : // if (symbol_matches)
750 : : // {
751 : : // return type.clone ();
752 : : // }
753 : :
754 : : // matching symbol is not going to work when we mix symbol's and have
755 : : // nested generics
756 : :
757 : : // bounds match? FIXME
758 : :
759 : 7046 : return type.clone ();
760 : : }
761 : 133 : break;
762 : :
763 : 133 : case TyTy::POINTER:
764 : 133 : case TyTy::STR:
765 : 133 : case TyTy::ADT:
766 : 133 : case TyTy::REF:
767 : 133 : case TyTy::ARRAY:
768 : 133 : case TyTy::SLICE:
769 : 133 : case TyTy::FNDEF:
770 : 133 : case TyTy::FNPTR:
771 : 133 : case TyTy::TUPLE:
772 : 133 : case TyTy::BOOL:
773 : 133 : case TyTy::CHAR:
774 : 133 : case TyTy::INT:
775 : 133 : case TyTy::UINT:
776 : 133 : case TyTy::FLOAT:
777 : 133 : case TyTy::USIZE:
778 : 133 : case TyTy::ISIZE:
779 : 133 : case TyTy::NEVER:
780 : 133 : case TyTy::PLACEHOLDER:
781 : 133 : case TyTy::PROJECTION:
782 : 133 : case TyTy::DYNAMIC:
783 : 133 : case TyTy::CLOSURE:
784 : 133 : case TyTy::OPAQUE:
785 : 133 : case TyTy::ERROR:
786 : 133 : return new TyTy::ErrorType (0);
787 : : }
788 : 0 : return new TyTy::ErrorType (0);
789 : : }
790 : :
791 : : TyTy::BaseType *
792 : 1547 : UnifyRules::expect_array (TyTy::ArrayType *ltype, TyTy::BaseType *rtype)
793 : : {
794 : 1547 : switch (rtype->get_kind ())
795 : : {
796 : 20 : case TyTy::INFER: {
797 : 20 : TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
798 : 20 : bool is_valid
799 : 20 : = r->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL;
800 : 20 : if (is_valid)
801 : 20 : return ltype->clone ();
802 : : }
803 : : break;
804 : :
805 : 1492 : case TyTy::ARRAY: {
806 : 1492 : TyTy::ArrayType &type = *static_cast<TyTy::ArrayType *> (rtype);
807 : 1492 : TyTy::BaseType *element_unify = UnifyRules::Resolve (
808 : 1492 : TyTy::TyWithLocation (ltype->get_element_type ()),
809 : 1492 : TyTy::TyWithLocation (type.get_element_type ()), locus, commit_flag,
810 : 1492 : false /* emit_error*/, infer_flag, commits, infers);
811 : :
812 : 1492 : if (element_unify->get_kind () != TyTy::TypeKind::ERROR)
813 : : {
814 : 1492 : return new TyTy::ArrayType (type.get_ref (), type.get_ty_ref (),
815 : 1492 : type.get_ident ().locus,
816 : : type.get_capacity_expr (),
817 : : TyTy::TyVar (
818 : 1492 : element_unify->get_ref ()));
819 : : }
820 : : }
821 : : break;
822 : :
823 : 35 : case TyTy::PARAM:
824 : 35 : case TyTy::POINTER:
825 : 35 : case TyTy::STR:
826 : 35 : case TyTy::ADT:
827 : 35 : case TyTy::REF:
828 : 35 : case TyTy::SLICE:
829 : 35 : case TyTy::FNDEF:
830 : 35 : case TyTy::FNPTR:
831 : 35 : case TyTy::TUPLE:
832 : 35 : case TyTy::BOOL:
833 : 35 : case TyTy::CHAR:
834 : 35 : case TyTy::INT:
835 : 35 : case TyTy::UINT:
836 : 35 : case TyTy::FLOAT:
837 : 35 : case TyTy::USIZE:
838 : 35 : case TyTy::ISIZE:
839 : 35 : case TyTy::NEVER:
840 : 35 : case TyTy::PLACEHOLDER:
841 : 35 : case TyTy::PROJECTION:
842 : 35 : case TyTy::DYNAMIC:
843 : 35 : case TyTy::CLOSURE:
844 : 35 : case TyTy::OPAQUE:
845 : 35 : case TyTy::ERROR:
846 : 35 : return new TyTy::ErrorType (0);
847 : : }
848 : 0 : return new TyTy::ErrorType (0);
849 : : }
850 : :
851 : : TyTy::BaseType *
852 : 1839 : UnifyRules::expect_slice (TyTy::SliceType *ltype, TyTy::BaseType *rtype)
853 : : {
854 : 1839 : switch (rtype->get_kind ())
855 : : {
856 : 0 : case TyTy::INFER: {
857 : 0 : TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
858 : 0 : bool is_valid
859 : 0 : = r->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL;
860 : 0 : if (is_valid)
861 : 0 : return ltype->clone ();
862 : : }
863 : : break;
864 : :
865 : 1610 : case TyTy::SLICE: {
866 : 1610 : TyTy::SliceType &type = *static_cast<TyTy::SliceType *> (rtype);
867 : 1610 : TyTy::BaseType *element_unify = UnifyRules::Resolve (
868 : 1610 : TyTy::TyWithLocation (ltype->get_element_type ()),
869 : 1610 : TyTy::TyWithLocation (type.get_element_type ()), locus, commit_flag,
870 : 1610 : false /* emit_error*/, infer_flag, commits, infers);
871 : :
872 : 1610 : if (element_unify->get_kind () != TyTy::TypeKind::ERROR)
873 : : {
874 : 1610 : return new TyTy::SliceType (type.get_ref (), type.get_ty_ref (),
875 : 1610 : type.get_ident ().locus,
876 : : TyTy::TyVar (
877 : 3220 : element_unify->get_ref ()));
878 : : }
879 : : }
880 : : break;
881 : :
882 : 229 : case TyTy::PARAM:
883 : 229 : case TyTy::POINTER:
884 : 229 : case TyTy::STR:
885 : 229 : case TyTy::ADT:
886 : 229 : case TyTy::REF:
887 : 229 : case TyTy::ARRAY:
888 : 229 : case TyTy::FNDEF:
889 : 229 : case TyTy::FNPTR:
890 : 229 : case TyTy::TUPLE:
891 : 229 : case TyTy::BOOL:
892 : 229 : case TyTy::CHAR:
893 : 229 : case TyTy::INT:
894 : 229 : case TyTy::UINT:
895 : 229 : case TyTy::FLOAT:
896 : 229 : case TyTy::USIZE:
897 : 229 : case TyTy::ISIZE:
898 : 229 : case TyTy::NEVER:
899 : 229 : case TyTy::PLACEHOLDER:
900 : 229 : case TyTy::PROJECTION:
901 : 229 : case TyTy::DYNAMIC:
902 : 229 : case TyTy::CLOSURE:
903 : 229 : case TyTy::OPAQUE:
904 : 229 : case TyTy::ERROR:
905 : 229 : return new TyTy::ErrorType (0);
906 : : }
907 : 0 : return new TyTy::ErrorType (0);
908 : : }
909 : :
910 : : TyTy::BaseType *
911 : 3241 : UnifyRules::expect_fndef (TyTy::FnType *ltype, TyTy::BaseType *rtype)
912 : : {
913 : 3241 : switch (rtype->get_kind ())
914 : : {
915 : 0 : case TyTy::INFER: {
916 : 0 : TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
917 : 0 : bool is_valid
918 : 0 : = r->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL;
919 : 0 : if (is_valid)
920 : 0 : return ltype->clone ();
921 : : }
922 : : break;
923 : :
924 : 3241 : case TyTy::FNDEF: {
925 : 3241 : TyTy::FnType &type = *static_cast<TyTy::FnType *> (rtype);
926 : 3241 : if (ltype->num_params () != type.num_params ())
927 : : {
928 : 0 : return new TyTy::ErrorType (0);
929 : : }
930 : :
931 : 7488 : for (size_t i = 0; i < ltype->num_params (); i++)
932 : : {
933 : 4253 : auto a = ltype->param_at (i).get_type ();
934 : 4253 : auto b = type.param_at (i).get_type ();
935 : :
936 : 4253 : auto unified_param
937 : 4253 : = UnifyRules::Resolve (TyTy::TyWithLocation (a),
938 : 4253 : TyTy::TyWithLocation (b), locus,
939 : 4253 : commit_flag, false /* emit_errors */,
940 : 4253 : infer_flag, commits, infers);
941 : 4253 : if (unified_param->get_kind () == TyTy::TypeKind::ERROR)
942 : : {
943 : 6 : return new TyTy::ErrorType (0);
944 : : }
945 : : }
946 : :
947 : 3235 : auto unified_return = UnifyRules::Resolve (
948 : 3235 : TyTy::TyWithLocation (ltype->get_return_type ()),
949 : 3235 : TyTy::TyWithLocation (type.get_return_type ()), locus, commit_flag,
950 : 3235 : false /* emit_errors */, infer_flag, commits, infers);
951 : 3235 : if (unified_return->get_kind () == TyTy::TypeKind::ERROR)
952 : : {
953 : 2 : return new TyTy::ErrorType (0);
954 : : }
955 : :
956 : : // ABI match? see
957 : : // https://gcc-rust.zulipchat.com/#narrow/stream/266897-general/topic/extern.20blocks/near/346416045
958 : 3233 : if (ltype->get_abi () != type.get_abi ())
959 : : {
960 : 0 : if (emit_error)
961 : : {
962 : 0 : emit_abi_mismatch (*ltype, type);
963 : : }
964 : 0 : return new TyTy::ErrorType (0);
965 : : }
966 : :
967 : : // DEF Id match? see https://github.com/Rust-GCC/gccrs/issues/2053
968 : :
969 : 3233 : return ltype->clone ();
970 : : }
971 : 0 : break;
972 : :
973 : 0 : case TyTy::TUPLE:
974 : 0 : case TyTy::BOOL:
975 : 0 : case TyTy::CHAR:
976 : 0 : case TyTy::INT:
977 : 0 : case TyTy::FLOAT:
978 : 0 : case TyTy::ISIZE:
979 : 0 : case TyTy::ADT:
980 : 0 : case TyTy::STR:
981 : 0 : case TyTy::REF:
982 : 0 : case TyTy::POINTER:
983 : 0 : case TyTy::PARAM:
984 : 0 : case TyTy::ARRAY:
985 : 0 : case TyTy::SLICE:
986 : 0 : case TyTy::FNPTR:
987 : 0 : case TyTy::UINT:
988 : 0 : case TyTy::USIZE:
989 : 0 : case TyTy::NEVER:
990 : 0 : case TyTy::PLACEHOLDER:
991 : 0 : case TyTy::PROJECTION:
992 : 0 : case TyTy::DYNAMIC:
993 : 0 : case TyTy::CLOSURE:
994 : 0 : case TyTy::OPAQUE:
995 : 0 : case TyTy::ERROR:
996 : 0 : return new TyTy::ErrorType (0);
997 : : }
998 : 0 : return new TyTy::ErrorType (0);
999 : : }
1000 : :
1001 : : TyTy::BaseType *
1002 : 92 : UnifyRules::expect_fnptr (TyTy::FnPtr *ltype, TyTy::BaseType *rtype)
1003 : : {
1004 : 92 : switch (rtype->get_kind ())
1005 : : {
1006 : 0 : case TyTy::INFER: {
1007 : 0 : TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
1008 : 0 : bool is_valid
1009 : 0 : = r->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL;
1010 : 0 : if (is_valid)
1011 : 0 : return ltype->clone ();
1012 : : }
1013 : : break;
1014 : :
1015 : 46 : case TyTy::FNPTR: {
1016 : 46 : TyTy::FnPtr &type = *static_cast<TyTy::FnPtr *> (rtype);
1017 : 46 : if (ltype->num_params () != type.num_params ())
1018 : : {
1019 : 0 : return new TyTy::ErrorType (0);
1020 : : }
1021 : :
1022 : 102 : for (size_t i = 0; i < ltype->num_params (); i++)
1023 : : {
1024 : 56 : auto a = ltype->get_param_type_at (i);
1025 : 56 : auto b = type.get_param_type_at (i);
1026 : :
1027 : 56 : auto unified_param
1028 : 56 : = UnifyRules::Resolve (TyTy::TyWithLocation (a),
1029 : 56 : TyTy::TyWithLocation (b), locus,
1030 : 56 : commit_flag, false /* emit_errors */,
1031 : 56 : infer_flag, commits, infers);
1032 : 56 : if (unified_param->get_kind () == TyTy::TypeKind::ERROR)
1033 : : {
1034 : 0 : return new TyTy::ErrorType (0);
1035 : : }
1036 : : }
1037 : :
1038 : 46 : auto unified_return = UnifyRules::Resolve (
1039 : 46 : TyTy::TyWithLocation (ltype->get_return_type ()),
1040 : 46 : TyTy::TyWithLocation (type.get_return_type ()), locus, commit_flag,
1041 : 46 : false /* emit_errors */, infer_flag, commits, infers);
1042 : 46 : if (unified_return->get_kind () == TyTy::TypeKind::ERROR)
1043 : : {
1044 : 0 : return new TyTy::ErrorType (0);
1045 : : }
1046 : :
1047 : 46 : return ltype->clone ();
1048 : : }
1049 : 46 : break;
1050 : :
1051 : 46 : case TyTy::FNDEF: {
1052 : 46 : TyTy::FnType &type = *static_cast<TyTy::FnType *> (rtype);
1053 : 46 : auto this_ret_type = ltype->get_return_type ();
1054 : 46 : auto other_ret_type = type.get_return_type ();
1055 : :
1056 : 46 : auto unified_result
1057 : 46 : = UnifyRules::Resolve (TyTy::TyWithLocation (this_ret_type),
1058 : 46 : TyTy::TyWithLocation (other_ret_type), locus,
1059 : 46 : commit_flag, false /*emit_errors*/, infer_flag,
1060 : : commits, infers);
1061 : 46 : if (unified_result->get_kind () == TyTy::TypeKind::ERROR)
1062 : : {
1063 : 0 : return new TyTy::ErrorType (0);
1064 : : }
1065 : :
1066 : 46 : if (ltype->num_params () != type.num_params ())
1067 : : {
1068 : 0 : return new TyTy::ErrorType (0);
1069 : : }
1070 : :
1071 : 102 : for (size_t i = 0; i < ltype->num_params (); i++)
1072 : : {
1073 : 56 : auto this_param = ltype->get_param_type_at (i);
1074 : 56 : auto other_param = type.param_at (i).get_type ();
1075 : :
1076 : 56 : auto unified_param
1077 : 56 : = UnifyRules::Resolve (TyTy::TyWithLocation (this_param),
1078 : 56 : TyTy::TyWithLocation (other_param), locus,
1079 : 56 : commit_flag, false /* emit_errors */,
1080 : 56 : infer_flag, commits, infers);
1081 : 56 : if (unified_param->get_kind () == TyTy::TypeKind::ERROR)
1082 : : {
1083 : 0 : return new TyTy::ErrorType (0);
1084 : : }
1085 : : }
1086 : :
1087 : 46 : return ltype->clone ();
1088 : : }
1089 : 0 : break;
1090 : :
1091 : 0 : case TyTy::TUPLE:
1092 : 0 : case TyTy::BOOL:
1093 : 0 : case TyTy::CHAR:
1094 : 0 : case TyTy::INT:
1095 : 0 : case TyTy::FLOAT:
1096 : 0 : case TyTy::ISIZE:
1097 : 0 : case TyTy::ADT:
1098 : 0 : case TyTy::STR:
1099 : 0 : case TyTy::REF:
1100 : 0 : case TyTy::POINTER:
1101 : 0 : case TyTy::PARAM:
1102 : 0 : case TyTy::ARRAY:
1103 : 0 : case TyTy::SLICE:
1104 : 0 : case TyTy::UINT:
1105 : 0 : case TyTy::USIZE:
1106 : 0 : case TyTy::NEVER:
1107 : 0 : case TyTy::PLACEHOLDER:
1108 : 0 : case TyTy::PROJECTION:
1109 : 0 : case TyTy::DYNAMIC:
1110 : 0 : case TyTy::CLOSURE:
1111 : 0 : case TyTy::OPAQUE:
1112 : 0 : case TyTy::ERROR:
1113 : 0 : return new TyTy::ErrorType (0);
1114 : : }
1115 : 0 : return new TyTy::ErrorType (0);
1116 : : }
1117 : :
1118 : : TyTy::BaseType *
1119 : 11388 : UnifyRules::expect_tuple (TyTy::TupleType *ltype, TyTy::BaseType *rtype)
1120 : : {
1121 : 11388 : switch (rtype->get_kind ())
1122 : : {
1123 : 14 : case TyTy::INFER: {
1124 : 14 : TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
1125 : 14 : bool is_valid
1126 : 14 : = r->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL;
1127 : 14 : if (is_valid)
1128 : 4 : return ltype->clone ();
1129 : : }
1130 : : break;
1131 : :
1132 : 11360 : case TyTy::TUPLE: {
1133 : 11360 : TyTy::TupleType &type = *static_cast<TyTy::TupleType *> (rtype);
1134 : 11360 : if (ltype->num_fields () != type.num_fields ())
1135 : : {
1136 : 0 : return new TyTy::ErrorType (0);
1137 : : }
1138 : :
1139 : 11360 : std::vector<TyTy::TyVar> fields;
1140 : 12718 : for (size_t i = 0; i < ltype->num_fields (); i++)
1141 : : {
1142 : 1366 : TyTy::BaseType *bo = ltype->get_field (i);
1143 : 1366 : TyTy::BaseType *fo = type.get_field (i);
1144 : :
1145 : 1366 : TyTy::BaseType *unified_ty
1146 : 1366 : = UnifyRules::Resolve (TyTy::TyWithLocation (bo),
1147 : 1366 : TyTy::TyWithLocation (fo), locus,
1148 : 1366 : commit_flag, false /* emit_errors */,
1149 : 1366 : infer_flag, commits, infers);
1150 : 1366 : if (unified_ty->get_kind () == TyTy::TypeKind::ERROR)
1151 : 8 : return new TyTy::ErrorType (0);
1152 : :
1153 : 1358 : fields.push_back (TyTy::TyVar (unified_ty->get_ref ()));
1154 : : }
1155 : :
1156 : 11352 : return new TyTy::TupleType (type.get_ref (), type.get_ty_ref (),
1157 : 11352 : type.get_ident ().locus, fields);
1158 : 11360 : }
1159 : 14 : break;
1160 : :
1161 : 14 : case TyTy::BOOL:
1162 : 14 : case TyTy::CHAR:
1163 : 14 : case TyTy::INT:
1164 : 14 : case TyTy::FLOAT:
1165 : 14 : case TyTy::ISIZE:
1166 : 14 : case TyTy::ADT:
1167 : 14 : case TyTy::STR:
1168 : 14 : case TyTy::REF:
1169 : 14 : case TyTy::POINTER:
1170 : 14 : case TyTy::PARAM:
1171 : 14 : case TyTy::ARRAY:
1172 : 14 : case TyTy::SLICE:
1173 : 14 : case TyTy::FNDEF:
1174 : 14 : case TyTy::FNPTR:
1175 : 14 : case TyTy::UINT:
1176 : 14 : case TyTy::USIZE:
1177 : 14 : case TyTy::NEVER:
1178 : 14 : case TyTy::PLACEHOLDER:
1179 : 14 : case TyTy::PROJECTION:
1180 : 14 : case TyTy::DYNAMIC:
1181 : 14 : case TyTy::CLOSURE:
1182 : 14 : case TyTy::OPAQUE:
1183 : 14 : case TyTy::ERROR:
1184 : 14 : return new TyTy::ErrorType (0);
1185 : : }
1186 : 10 : return new TyTy::ErrorType (0);
1187 : : }
1188 : :
1189 : : TyTy::BaseType *
1190 : 5490 : UnifyRules::expect_bool (TyTy::BoolType *ltype, TyTy::BaseType *rtype)
1191 : : {
1192 : 5490 : switch (rtype->get_kind ())
1193 : : {
1194 : 35 : case TyTy::INFER: {
1195 : 35 : TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
1196 : 35 : bool is_valid
1197 : 35 : = r->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL;
1198 : 35 : if (is_valid)
1199 : : {
1200 : 0 : r->apply_primitive_type_hint (*ltype);
1201 : 0 : return ltype->clone ();
1202 : : }
1203 : : }
1204 : : break;
1205 : :
1206 : 5423 : case TyTy::BOOL:
1207 : 5423 : return rtype->clone ();
1208 : :
1209 : 32 : case TyTy::CHAR:
1210 : 32 : case TyTy::INT:
1211 : 32 : case TyTy::FLOAT:
1212 : 32 : case TyTy::ISIZE:
1213 : 32 : case TyTy::ADT:
1214 : 32 : case TyTy::STR:
1215 : 32 : case TyTy::REF:
1216 : 32 : case TyTy::POINTER:
1217 : 32 : case TyTy::PARAM:
1218 : 32 : case TyTy::ARRAY:
1219 : 32 : case TyTy::SLICE:
1220 : 32 : case TyTy::FNDEF:
1221 : 32 : case TyTy::FNPTR:
1222 : 32 : case TyTy::TUPLE:
1223 : 32 : case TyTy::UINT:
1224 : 32 : case TyTy::USIZE:
1225 : 32 : case TyTy::NEVER:
1226 : 32 : case TyTy::PLACEHOLDER:
1227 : 32 : case TyTy::PROJECTION:
1228 : 32 : case TyTy::DYNAMIC:
1229 : 32 : case TyTy::CLOSURE:
1230 : 32 : case TyTy::OPAQUE:
1231 : 32 : case TyTy::ERROR:
1232 : 32 : return new TyTy::ErrorType (0);
1233 : : }
1234 : 35 : return new TyTy::ErrorType (0);
1235 : : }
1236 : :
1237 : : TyTy::BaseType *
1238 : 1120 : UnifyRules::expect_char (TyTy::CharType *ltype, TyTy::BaseType *rtype)
1239 : : {
1240 : 1120 : switch (rtype->get_kind ())
1241 : : {
1242 : 6 : case TyTy::INFER: {
1243 : 6 : TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
1244 : 6 : bool is_valid
1245 : 6 : = r->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL;
1246 : 6 : if (is_valid)
1247 : : {
1248 : 0 : r->apply_primitive_type_hint (*ltype);
1249 : 0 : return ltype->clone ();
1250 : : }
1251 : : }
1252 : : break;
1253 : :
1254 : 1068 : case TyTy::CHAR:
1255 : 1068 : return rtype->clone ();
1256 : :
1257 : 46 : case TyTy::INT:
1258 : 46 : case TyTy::FLOAT:
1259 : 46 : case TyTy::ISIZE:
1260 : 46 : case TyTy::ADT:
1261 : 46 : case TyTy::STR:
1262 : 46 : case TyTy::REF:
1263 : 46 : case TyTy::POINTER:
1264 : 46 : case TyTy::PARAM:
1265 : 46 : case TyTy::ARRAY:
1266 : 46 : case TyTy::SLICE:
1267 : 46 : case TyTy::FNDEF:
1268 : 46 : case TyTy::FNPTR:
1269 : 46 : case TyTy::TUPLE:
1270 : 46 : case TyTy::BOOL:
1271 : 46 : case TyTy::UINT:
1272 : 46 : case TyTy::USIZE:
1273 : 46 : case TyTy::NEVER:
1274 : 46 : case TyTy::PLACEHOLDER:
1275 : 46 : case TyTy::PROJECTION:
1276 : 46 : case TyTy::DYNAMIC:
1277 : 46 : case TyTy::CLOSURE:
1278 : 46 : case TyTy::OPAQUE:
1279 : 46 : case TyTy::ERROR:
1280 : 46 : return new TyTy::ErrorType (0);
1281 : : }
1282 : 6 : return new TyTy::ErrorType (0);
1283 : : }
1284 : :
1285 : : TyTy::BaseType *
1286 : 29133 : UnifyRules::expect_int (TyTy::IntType *ltype, TyTy::BaseType *rtype)
1287 : : {
1288 : 29133 : switch (rtype->get_kind ())
1289 : : {
1290 : 5941 : case TyTy::INFER: {
1291 : 5941 : TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
1292 : 5941 : bool is_valid
1293 : 5941 : = r->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL
1294 : 5941 : || r->get_infer_kind () == TyTy::InferType::InferTypeKind::INTEGRAL;
1295 : 5933 : if (is_valid)
1296 : : {
1297 : 5933 : r->apply_primitive_type_hint (*ltype);
1298 : 5933 : return ltype->clone ();
1299 : : }
1300 : : }
1301 : : break;
1302 : :
1303 : 20933 : case TyTy::INT: {
1304 : 20933 : TyTy::IntType &type = *static_cast<TyTy::IntType *> (rtype);
1305 : 20933 : bool is_valid = ltype->get_int_kind () == type.get_int_kind ();
1306 : 20933 : if (is_valid)
1307 : 20878 : return new TyTy::IntType (type.get_ref (), type.get_ty_ref (),
1308 : 20878 : type.get_int_kind ());
1309 : : }
1310 : : break;
1311 : :
1312 : 2259 : case TyTy::FLOAT:
1313 : 2259 : case TyTy::ISIZE:
1314 : 2259 : case TyTy::ADT:
1315 : 2259 : case TyTy::STR:
1316 : 2259 : case TyTy::REF:
1317 : 2259 : case TyTy::POINTER:
1318 : 2259 : case TyTy::PARAM:
1319 : 2259 : case TyTy::ARRAY:
1320 : 2259 : case TyTy::SLICE:
1321 : 2259 : case TyTy::FNDEF:
1322 : 2259 : case TyTy::FNPTR:
1323 : 2259 : case TyTy::TUPLE:
1324 : 2259 : case TyTy::BOOL:
1325 : 2259 : case TyTy::CHAR:
1326 : 2259 : case TyTy::UINT:
1327 : 2259 : case TyTy::USIZE:
1328 : 2259 : case TyTy::NEVER:
1329 : 2259 : case TyTy::PLACEHOLDER:
1330 : 2259 : case TyTy::PROJECTION:
1331 : 2259 : case TyTy::DYNAMIC:
1332 : 2259 : case TyTy::CLOSURE:
1333 : 2259 : case TyTy::OPAQUE:
1334 : 2259 : case TyTy::ERROR:
1335 : 2259 : return new TyTy::ErrorType (0);
1336 : : }
1337 : 63 : return new TyTy::ErrorType (0);
1338 : : }
1339 : :
1340 : : TyTy::BaseType *
1341 : 20001 : UnifyRules::expect_uint (TyTy::UintType *ltype, TyTy::BaseType *rtype)
1342 : : {
1343 : 20001 : switch (rtype->get_kind ())
1344 : : {
1345 : 1044 : case TyTy::INFER: {
1346 : 1044 : TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
1347 : 1044 : bool is_valid
1348 : 1044 : = r->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL
1349 : 1044 : || r->get_infer_kind () == TyTy::InferType::InferTypeKind::INTEGRAL;
1350 : 1044 : if (is_valid)
1351 : : {
1352 : 1044 : r->apply_primitive_type_hint (*ltype);
1353 : 1044 : return ltype->clone ();
1354 : : }
1355 : : }
1356 : : break;
1357 : :
1358 : 17447 : case TyTy::UINT: {
1359 : 17447 : TyTy::UintType &type = *static_cast<TyTy::UintType *> (rtype);
1360 : 17447 : bool is_valid = ltype->get_uint_kind () == type.get_uint_kind ();
1361 : 17447 : if (is_valid)
1362 : 16497 : return new TyTy::UintType (type.get_ref (), type.get_ty_ref (),
1363 : 16497 : type.get_uint_kind ());
1364 : : }
1365 : : break;
1366 : :
1367 : 1510 : case TyTy::FLOAT:
1368 : 1510 : case TyTy::ISIZE:
1369 : 1510 : case TyTy::ADT:
1370 : 1510 : case TyTy::STR:
1371 : 1510 : case TyTy::REF:
1372 : 1510 : case TyTy::POINTER:
1373 : 1510 : case TyTy::PARAM:
1374 : 1510 : case TyTy::ARRAY:
1375 : 1510 : case TyTy::SLICE:
1376 : 1510 : case TyTy::FNDEF:
1377 : 1510 : case TyTy::FNPTR:
1378 : 1510 : case TyTy::TUPLE:
1379 : 1510 : case TyTy::BOOL:
1380 : 1510 : case TyTy::CHAR:
1381 : 1510 : case TyTy::INT:
1382 : 1510 : case TyTy::USIZE:
1383 : 1510 : case TyTy::NEVER:
1384 : 1510 : case TyTy::PLACEHOLDER:
1385 : 1510 : case TyTy::PROJECTION:
1386 : 1510 : case TyTy::DYNAMIC:
1387 : 1510 : case TyTy::CLOSURE:
1388 : 1510 : case TyTy::OPAQUE:
1389 : 1510 : case TyTy::ERROR:
1390 : 1510 : return new TyTy::ErrorType (0);
1391 : : }
1392 : 950 : return new TyTy::ErrorType (0);
1393 : : }
1394 : :
1395 : : TyTy::BaseType *
1396 : 7592 : UnifyRules::expect_float (TyTy::FloatType *ltype, TyTy::BaseType *rtype)
1397 : : {
1398 : 7592 : switch (rtype->get_kind ())
1399 : : {
1400 : 294 : case TyTy::INFER: {
1401 : 294 : TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
1402 : 294 : bool is_valid
1403 : 294 : = r->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL
1404 : 294 : || r->get_infer_kind () == TyTy::InferType::InferTypeKind::FLOAT;
1405 : 282 : if (is_valid)
1406 : : {
1407 : 282 : r->apply_primitive_type_hint (*ltype);
1408 : 282 : return ltype->clone ();
1409 : : }
1410 : : }
1411 : : break;
1412 : :
1413 : 6360 : case TyTy::FLOAT: {
1414 : 6360 : TyTy::FloatType &type = *static_cast<TyTy::FloatType *> (rtype);
1415 : 6360 : bool is_valid = ltype->get_float_kind () == type.get_float_kind ();
1416 : 6360 : if (is_valid)
1417 : 6298 : return new TyTy::FloatType (type.get_ref (), type.get_ty_ref (),
1418 : 6298 : type.get_float_kind ());
1419 : : }
1420 : : break;
1421 : :
1422 : 938 : case TyTy::ISIZE:
1423 : 938 : case TyTy::ADT:
1424 : 938 : case TyTy::STR:
1425 : 938 : case TyTy::REF:
1426 : 938 : case TyTy::POINTER:
1427 : 938 : case TyTy::PARAM:
1428 : 938 : case TyTy::ARRAY:
1429 : 938 : case TyTy::SLICE:
1430 : 938 : case TyTy::FNDEF:
1431 : 938 : case TyTy::FNPTR:
1432 : 938 : case TyTy::TUPLE:
1433 : 938 : case TyTy::BOOL:
1434 : 938 : case TyTy::CHAR:
1435 : 938 : case TyTy::INT:
1436 : 938 : case TyTy::UINT:
1437 : 938 : case TyTy::USIZE:
1438 : 938 : case TyTy::NEVER:
1439 : 938 : case TyTy::PLACEHOLDER:
1440 : 938 : case TyTy::PROJECTION:
1441 : 938 : case TyTy::DYNAMIC:
1442 : 938 : case TyTy::CLOSURE:
1443 : 938 : case TyTy::OPAQUE:
1444 : 938 : case TyTy::ERROR:
1445 : 938 : return new TyTy::ErrorType (0);
1446 : : }
1447 : 74 : return new TyTy::ErrorType (0);
1448 : : }
1449 : :
1450 : : TyTy::BaseType *
1451 : 2129 : UnifyRules::expect_isize (TyTy::ISizeType *ltype, TyTy::BaseType *rtype)
1452 : : {
1453 : 2129 : switch (rtype->get_kind ())
1454 : : {
1455 : 184 : case TyTy::INFER: {
1456 : 184 : TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
1457 : 184 : bool is_valid
1458 : 184 : = r->get_infer_kind () != TyTy::InferType::InferTypeKind::FLOAT;
1459 : 184 : if (is_valid)
1460 : : {
1461 : 184 : r->apply_primitive_type_hint (*ltype);
1462 : 184 : return ltype->clone ();
1463 : : }
1464 : : }
1465 : : break;
1466 : :
1467 : 1656 : case TyTy::ISIZE:
1468 : 1656 : return rtype->clone ();
1469 : :
1470 : 289 : case TyTy::ADT:
1471 : 289 : case TyTy::STR:
1472 : 289 : case TyTy::REF:
1473 : 289 : case TyTy::POINTER:
1474 : 289 : case TyTy::PARAM:
1475 : 289 : case TyTy::ARRAY:
1476 : 289 : case TyTy::SLICE:
1477 : 289 : case TyTy::FNDEF:
1478 : 289 : case TyTy::FNPTR:
1479 : 289 : case TyTy::TUPLE:
1480 : 289 : case TyTy::BOOL:
1481 : 289 : case TyTy::CHAR:
1482 : 289 : case TyTy::INT:
1483 : 289 : case TyTy::UINT:
1484 : 289 : case TyTy::FLOAT:
1485 : 289 : case TyTy::USIZE:
1486 : 289 : case TyTy::NEVER:
1487 : 289 : case TyTy::PLACEHOLDER:
1488 : 289 : case TyTy::PROJECTION:
1489 : 289 : case TyTy::DYNAMIC:
1490 : 289 : case TyTy::CLOSURE:
1491 : 289 : case TyTy::OPAQUE:
1492 : 289 : case TyTy::ERROR:
1493 : 289 : return new TyTy::ErrorType (0);
1494 : : }
1495 : 0 : return new TyTy::ErrorType (0);
1496 : : }
1497 : :
1498 : : TyTy::BaseType *
1499 : 10090 : UnifyRules::expect_usize (TyTy::USizeType *ltype, TyTy::BaseType *rtype)
1500 : : {
1501 : 10090 : switch (rtype->get_kind ())
1502 : : {
1503 : 1480 : case TyTy::INFER: {
1504 : 1480 : TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
1505 : 1480 : bool is_valid
1506 : 1480 : = r->get_infer_kind () != TyTy::InferType::InferTypeKind::FLOAT;
1507 : 1480 : if (is_valid)
1508 : : {
1509 : 1480 : r->apply_primitive_type_hint (*ltype);
1510 : 1480 : return ltype->clone ();
1511 : : }
1512 : : }
1513 : : break;
1514 : :
1515 : 8053 : case TyTy::USIZE:
1516 : 8053 : return rtype->clone ();
1517 : :
1518 : 557 : case TyTy::ADT:
1519 : 557 : case TyTy::STR:
1520 : 557 : case TyTy::REF:
1521 : 557 : case TyTy::POINTER:
1522 : 557 : case TyTy::PARAM:
1523 : 557 : case TyTy::ARRAY:
1524 : 557 : case TyTy::SLICE:
1525 : 557 : case TyTy::FNDEF:
1526 : 557 : case TyTy::FNPTR:
1527 : 557 : case TyTy::TUPLE:
1528 : 557 : case TyTy::BOOL:
1529 : 557 : case TyTy::CHAR:
1530 : 557 : case TyTy::INT:
1531 : 557 : case TyTy::UINT:
1532 : 557 : case TyTy::FLOAT:
1533 : 557 : case TyTy::ISIZE:
1534 : 557 : case TyTy::NEVER:
1535 : 557 : case TyTy::PLACEHOLDER:
1536 : 557 : case TyTy::PROJECTION:
1537 : 557 : case TyTy::DYNAMIC:
1538 : 557 : case TyTy::CLOSURE:
1539 : 557 : case TyTy::OPAQUE:
1540 : 557 : case TyTy::ERROR:
1541 : 557 : return new TyTy::ErrorType (0);
1542 : : }
1543 : 0 : return new TyTy::ErrorType (0);
1544 : : }
1545 : :
1546 : : TyTy::BaseType *
1547 : 277 : UnifyRules::expect_never (TyTy::NeverType *ltype, TyTy::BaseType *rtype)
1548 : : {
1549 : 277 : switch (rtype->get_kind ())
1550 : : {
1551 : 83 : case TyTy::INFER: {
1552 : 83 : TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
1553 : 83 : bool is_valid
1554 : 83 : = r->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL;
1555 : 83 : if (is_valid)
1556 : 83 : return ltype->clone ();
1557 : : }
1558 : 0 : break;
1559 : :
1560 : 194 : default:
1561 : 194 : return rtype->clone ();
1562 : : }
1563 : 0 : return new TyTy::ErrorType (0);
1564 : : }
1565 : :
1566 : : TyTy::BaseType *
1567 : 1606 : UnifyRules::expect_placeholder (TyTy::PlaceholderType *ltype,
1568 : : TyTy::BaseType *rtype)
1569 : : {
1570 : 1606 : switch (rtype->get_kind ())
1571 : : {
1572 : 391 : case TyTy::INFER: {
1573 : 391 : TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
1574 : 391 : bool is_valid
1575 : 391 : = r->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL;
1576 : 391 : if (is_valid)
1577 : 391 : return ltype->clone ();
1578 : : }
1579 : : break;
1580 : :
1581 : 491 : case TyTy::PLACEHOLDER:
1582 : 491 : return ltype->clone ();
1583 : :
1584 : 724 : case TyTy::PROJECTION:
1585 : 724 : case TyTy::DYNAMIC:
1586 : 724 : case TyTy::CLOSURE:
1587 : 724 : case TyTy::SLICE:
1588 : 724 : case TyTy::PARAM:
1589 : 724 : case TyTy::POINTER:
1590 : 724 : case TyTy::STR:
1591 : 724 : case TyTy::ADT:
1592 : 724 : case TyTy::REF:
1593 : 724 : case TyTy::ARRAY:
1594 : 724 : case TyTy::FNDEF:
1595 : 724 : case TyTy::FNPTR:
1596 : 724 : case TyTy::TUPLE:
1597 : 724 : case TyTy::BOOL:
1598 : 724 : case TyTy::CHAR:
1599 : 724 : case TyTy::INT:
1600 : 724 : case TyTy::UINT:
1601 : 724 : case TyTy::FLOAT:
1602 : 724 : case TyTy::USIZE:
1603 : 724 : case TyTy::ISIZE:
1604 : 724 : case TyTy::NEVER:
1605 : 724 : case TyTy::OPAQUE:
1606 : 724 : if (infer_flag)
1607 : 717 : return rtype->clone ();
1608 : 7 : gcc_fallthrough ();
1609 : :
1610 : 7 : case TyTy::ERROR:
1611 : 7 : return new TyTy::ErrorType (0);
1612 : : }
1613 : 0 : return new TyTy::ErrorType (0);
1614 : : }
1615 : :
1616 : : TyTy::BaseType *
1617 : 0 : UnifyRules::expect_projection (TyTy::ProjectionType *ltype,
1618 : : TyTy::BaseType *rtype)
1619 : : {
1620 : 0 : switch (rtype->get_kind ())
1621 : : {
1622 : 0 : case TyTy::INFER: {
1623 : 0 : TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
1624 : 0 : bool is_valid
1625 : 0 : = r->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL;
1626 : 0 : if (is_valid)
1627 : 0 : return ltype->clone ();
1628 : : }
1629 : : break;
1630 : :
1631 : : // FIXME
1632 : 0 : case TyTy::PROJECTION:
1633 : 0 : rust_unreachable ();
1634 : 0 : break;
1635 : :
1636 : 0 : case TyTy::DYNAMIC:
1637 : 0 : case TyTy::CLOSURE:
1638 : 0 : case TyTy::SLICE:
1639 : 0 : case TyTy::PARAM:
1640 : 0 : case TyTy::POINTER:
1641 : 0 : case TyTy::STR:
1642 : 0 : case TyTy::ADT:
1643 : 0 : case TyTy::REF:
1644 : 0 : case TyTy::ARRAY:
1645 : 0 : case TyTy::FNDEF:
1646 : 0 : case TyTy::FNPTR:
1647 : 0 : case TyTy::TUPLE:
1648 : 0 : case TyTy::BOOL:
1649 : 0 : case TyTy::CHAR:
1650 : 0 : case TyTy::INT:
1651 : 0 : case TyTy::UINT:
1652 : 0 : case TyTy::FLOAT:
1653 : 0 : case TyTy::USIZE:
1654 : 0 : case TyTy::ISIZE:
1655 : 0 : case TyTy::NEVER:
1656 : 0 : case TyTy::PLACEHOLDER:
1657 : 0 : case TyTy::OPAQUE:
1658 : 0 : case TyTy::ERROR:
1659 : 0 : return new TyTy::ErrorType (0);
1660 : : }
1661 : 0 : return new TyTy::ErrorType (0);
1662 : : }
1663 : :
1664 : : TyTy::BaseType *
1665 : 554 : UnifyRules::expect_dyn (TyTy::DynamicObjectType *ltype, TyTy::BaseType *rtype)
1666 : : {
1667 : 554 : switch (rtype->get_kind ())
1668 : : {
1669 : 0 : case TyTy::INFER: {
1670 : 0 : TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
1671 : 0 : bool is_valid
1672 : 0 : = r->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL;
1673 : 0 : if (is_valid)
1674 : 0 : return ltype->clone ();
1675 : : }
1676 : : break;
1677 : :
1678 : 554 : case TyTy::DYNAMIC: {
1679 : 554 : TyTy::DynamicObjectType &type
1680 : : = *static_cast<TyTy::DynamicObjectType *> (rtype);
1681 : 554 : if (ltype->num_specified_bounds () != type.num_specified_bounds ())
1682 : : {
1683 : 0 : return new TyTy::ErrorType (0);
1684 : : }
1685 : :
1686 : 554 : if (!ltype->bounds_compatible (type, locus, true))
1687 : : {
1688 : 0 : return new TyTy::ErrorType (0);
1689 : : }
1690 : :
1691 : 554 : return ltype->clone ();
1692 : : }
1693 : 0 : break;
1694 : :
1695 : 0 : case TyTy::CLOSURE:
1696 : 0 : case TyTy::SLICE:
1697 : 0 : case TyTy::PARAM:
1698 : 0 : case TyTy::POINTER:
1699 : 0 : case TyTy::STR:
1700 : 0 : case TyTy::ADT:
1701 : 0 : case TyTy::REF:
1702 : 0 : case TyTy::ARRAY:
1703 : 0 : case TyTy::FNDEF:
1704 : 0 : case TyTy::FNPTR:
1705 : 0 : case TyTy::TUPLE:
1706 : 0 : case TyTy::BOOL:
1707 : 0 : case TyTy::CHAR:
1708 : 0 : case TyTy::INT:
1709 : 0 : case TyTy::UINT:
1710 : 0 : case TyTy::FLOAT:
1711 : 0 : case TyTy::USIZE:
1712 : 0 : case TyTy::ISIZE:
1713 : 0 : case TyTy::NEVER:
1714 : 0 : case TyTy::PLACEHOLDER:
1715 : 0 : case TyTy::PROJECTION:
1716 : 0 : case TyTy::OPAQUE:
1717 : 0 : case TyTy::ERROR:
1718 : 0 : return new TyTy::ErrorType (0);
1719 : : }
1720 : 0 : return new TyTy::ErrorType (0);
1721 : : }
1722 : :
1723 : : TyTy::BaseType *
1724 : 100 : UnifyRules::expect_closure (TyTy::ClosureType *ltype, TyTy::BaseType *rtype)
1725 : : {
1726 : 100 : switch (rtype->get_kind ())
1727 : : {
1728 : 0 : case TyTy::INFER: {
1729 : 0 : TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
1730 : 0 : bool is_valid
1731 : 0 : = r->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL;
1732 : 0 : if (is_valid)
1733 : 0 : return ltype->clone ();
1734 : : }
1735 : : break;
1736 : :
1737 : 100 : case TyTy::CLOSURE: {
1738 : 100 : TyTy::ClosureType &type = *static_cast<TyTy::ClosureType *> (rtype);
1739 : 100 : if (ltype->get_def_id () != type.get_def_id ())
1740 : : {
1741 : 0 : return new TyTy::ErrorType (0);
1742 : : }
1743 : :
1744 : 100 : TyTy::BaseType *args_res = UnifyRules::Resolve (
1745 : 100 : TyTy::TyWithLocation (<ype->get_parameters ()),
1746 : 100 : TyTy::TyWithLocation (&type.get_parameters ()), locus, commit_flag,
1747 : 100 : false /* emit_error */, infer_flag, commits, infers);
1748 : 100 : if (args_res->get_kind () == TyTy::TypeKind::ERROR)
1749 : : {
1750 : 0 : return new TyTy::ErrorType (0);
1751 : : }
1752 : :
1753 : 100 : TyTy::BaseType *res = UnifyRules::Resolve (
1754 : 100 : TyTy::TyWithLocation (<ype->get_result_type ()),
1755 : 100 : TyTy::TyWithLocation (&type.get_result_type ()), locus, commit_flag,
1756 : 100 : false /* emit_error */, infer_flag, commits, infers);
1757 : 100 : if (res == nullptr || res->get_kind () == TyTy::TypeKind::ERROR)
1758 : : {
1759 : 0 : return new TyTy::ErrorType (0);
1760 : : }
1761 : :
1762 : 100 : return ltype->clone ();
1763 : : }
1764 : 0 : break;
1765 : :
1766 : 0 : case TyTy::SLICE:
1767 : 0 : case TyTy::PARAM:
1768 : 0 : case TyTy::POINTER:
1769 : 0 : case TyTy::STR:
1770 : 0 : case TyTy::ADT:
1771 : 0 : case TyTy::REF:
1772 : 0 : case TyTy::ARRAY:
1773 : 0 : case TyTy::FNDEF:
1774 : 0 : case TyTy::FNPTR:
1775 : 0 : case TyTy::TUPLE:
1776 : 0 : case TyTy::BOOL:
1777 : 0 : case TyTy::CHAR:
1778 : 0 : case TyTy::INT:
1779 : 0 : case TyTy::UINT:
1780 : 0 : case TyTy::FLOAT:
1781 : 0 : case TyTy::USIZE:
1782 : 0 : case TyTy::ISIZE:
1783 : 0 : case TyTy::NEVER:
1784 : 0 : case TyTy::PLACEHOLDER:
1785 : 0 : case TyTy::PROJECTION:
1786 : 0 : case TyTy::DYNAMIC:
1787 : 0 : case TyTy::OPAQUE:
1788 : 0 : case TyTy::ERROR:
1789 : 0 : return new TyTy::ErrorType (0);
1790 : : }
1791 : 0 : return new TyTy::ErrorType (0);
1792 : : }
1793 : :
1794 : : TyTy::BaseType *
1795 : 0 : UnifyRules::expect_opaque (TyTy::OpaqueType *ltype, TyTy::BaseType *rtype)
1796 : : {
1797 : 0 : switch (rtype->get_kind ())
1798 : : {
1799 : 0 : case TyTy::INFER: {
1800 : 0 : TyTy::InferType *r = static_cast<TyTy::InferType *> (rtype);
1801 : 0 : bool is_valid
1802 : 0 : = r->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL;
1803 : 0 : if (is_valid)
1804 : 0 : return ltype->clone ();
1805 : : }
1806 : : break;
1807 : :
1808 : 0 : case TyTy::OPAQUE: {
1809 : 0 : auto &type = *static_cast<TyTy::OpaqueType *> (rtype);
1810 : 0 : if (ltype->num_specified_bounds () != type.num_specified_bounds ())
1811 : : {
1812 : 0 : return new TyTy::ErrorType (0);
1813 : : }
1814 : :
1815 : 0 : if (!ltype->bounds_compatible (type, locus, true))
1816 : : {
1817 : 0 : return new TyTy::ErrorType (0);
1818 : : }
1819 : :
1820 : 0 : return ltype->clone ();
1821 : : }
1822 : 0 : break;
1823 : :
1824 : 0 : case TyTy::CLOSURE:
1825 : 0 : case TyTy::SLICE:
1826 : 0 : case TyTy::PARAM:
1827 : 0 : case TyTy::POINTER:
1828 : 0 : case TyTy::STR:
1829 : 0 : case TyTy::ADT:
1830 : 0 : case TyTy::REF:
1831 : 0 : case TyTy::ARRAY:
1832 : 0 : case TyTy::FNDEF:
1833 : 0 : case TyTy::FNPTR:
1834 : 0 : case TyTy::TUPLE:
1835 : 0 : case TyTy::BOOL:
1836 : 0 : case TyTy::CHAR:
1837 : 0 : case TyTy::INT:
1838 : 0 : case TyTy::UINT:
1839 : 0 : case TyTy::FLOAT:
1840 : 0 : case TyTy::USIZE:
1841 : 0 : case TyTy::ISIZE:
1842 : 0 : case TyTy::NEVER:
1843 : 0 : case TyTy::PLACEHOLDER:
1844 : 0 : case TyTy::PROJECTION:
1845 : 0 : case TyTy::DYNAMIC:
1846 : 0 : case TyTy::ERROR:
1847 : 0 : return new TyTy::ErrorType (0);
1848 : : }
1849 : 0 : return new TyTy::ErrorType (0);
1850 : : }
1851 : :
1852 : : } // namespace Resolver
1853 : : } // namespace Rust
|
