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