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