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