| // Copyright (C) 2020-2026 Free Software Foundation, Inc. | |
| // This file is part of GCC. | |
| // GCC is free software; you can redistribute it and/or modify it under | |
| // the terms of the GNU General Public License as published by the Free | |
| // Software Foundation; either version 3, or (at your option) any later | |
| // version. | |
| // GCC is distributed in the hope that it will be useful, but WITHOUT ANY | |
| // WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| // FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| // for more details. | |
| // You should have received a copy of the GNU General Public License | |
| // along with GCC; see the file COPYING3. If not see | |
| // <http://www.gnu.org/licenses/>. | |
| #include "rust-casts.h" | |
| #include "rust-tyty-util.h" | |
| #include "rust-tyty.h" | |
| namespace Rust { | |
| namespace Resolver { | |
| TypeCastRules::TypeCastRules (location_t locus, TyTy::TyWithLocation from, | |
| TyTy::TyWithLocation to) | |
| : locus (locus), from (from), to (to) | |
| {} | |
| TypeCoercionRules::CoercionResult | |
| TypeCastRules::resolve (location_t locus, TyTy::TyWithLocation from, | |
| TyTy::TyWithLocation to, bool emit_error) | |
| { | |
| TypeCastRules cast_rules (locus, from, to); | |
| return cast_rules.check (emit_error); | |
| } | |
| TypeCoercionRules::CoercionResult | |
| TypeCastRules::check (bool emit_error) | |
| { | |
| // try the simple cast rules | |
| auto simple_cast = cast_rules (); | |
| if (!simple_cast.is_error ()) | |
| return simple_cast; | |
| // https://github.com/rust-lang/rust/blob/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/compiler/rustc_typeck/src/check/cast.rs#L565-L582 | |
| auto possible_coercion | |
| = TypeCoercionRules::TryCoerce (from.get_ty (), to.get_ty (), locus, | |
| true /*allow-autoderef*/, | |
| true /*is_cast_site*/); | |
| if (!possible_coercion.is_error ()) | |
| { | |
| // given the attempt was ok we need to ensure we perform it so that any | |
| // inference variables are unified correctly | |
| return TypeCoercionRules::Coerce (from.get_ty (), to.get_ty (), locus, | |
| true /*allow-autoderef*/, | |
| true /*is_cast_site*/); | |
| } | |
| if (emit_error) | |
| TypeCastRules::emit_cast_error (locus, from, to); | |
| return TypeCoercionRules::CoercionResult::get_error (); | |
| } | |
| TypeCoercionRules::CoercionResult | |
| TypeCastRules::cast_rules () | |
| { | |
| // https://github.com/rust-lang/rust/blob/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/compiler/rustc_typeck/src/check/cast.rs#L596 | |
| // https://github.com/rust-lang/rust/blob/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/compiler/rustc_typeck/src/check/cast.rs#L654 | |
| TyTy::BaseType *from_type = from.get_ty ()->destructure (); | |
| if (auto c = from_type->try_as<TyTy::ConstParamType> ()) | |
| from_type = c->get_specified_type (); | |
| rust_debug ("cast_rules from={%s} to={%s}", from_type->debug_str ().c_str (), | |
| to.get_ty ()->debug_str ().c_str ()); | |
| switch (from_type->get_kind ()) | |
| { | |
| case TyTy::TypeKind::INFER: | |
| { | |
| TyTy::InferType *from_infer | |
| = static_cast<TyTy::InferType *> (from_type); | |
| switch (from_infer->get_infer_kind ()) | |
| { | |
| case TyTy::InferType::InferTypeKind::GENERAL: | |
| return TypeCoercionRules::CoercionResult{{}, | |
| to.get_ty ()->clone ()}; | |
| case TyTy::InferType::InferTypeKind::INTEGRAL: | |
| switch (to.get_ty ()->get_kind ()) | |
| { | |
| case TyTy::TypeKind::CHAR: | |
| { | |
| // only u8 and char | |
| bool was_uint | |
| = from.get_ty ()->get_kind () == TyTy::TypeKind::UINT; | |
| bool was_u8 | |
| = was_uint | |
| && (static_cast<TyTy::UintType *> (from.get_ty ()) | |
| ->get_uint_kind () | |
| == TyTy::UintType::UintKind::U8); | |
| if (was_u8) | |
| return TypeCoercionRules::CoercionResult{ | |
| {}, to.get_ty ()->clone ()}; | |
| } | |
| break; | |
| case TyTy::TypeKind::USIZE: | |
| case TyTy::TypeKind::ISIZE: | |
| case TyTy::TypeKind::UINT: | |
| case TyTy::TypeKind::INT: | |
| case TyTy::TypeKind::POINTER: | |
| return TypeCoercionRules::CoercionResult{ | |
| {}, to.get_ty ()->clone ()}; | |
| case TyTy::TypeKind::INFER: | |
| { | |
| TyTy::InferType *to_infer | |
| = static_cast<TyTy::InferType *> (to.get_ty ()); | |
| switch (to_infer->get_infer_kind ()) | |
| { | |
| case TyTy::InferType::InferTypeKind::GENERAL: | |
| case TyTy::InferType::InferTypeKind::INTEGRAL: | |
| return TypeCoercionRules::CoercionResult{ | |
| {}, to.get_ty ()->clone ()}; | |
| default: | |
| return TypeCoercionRules::CoercionResult::get_error (); | |
| } | |
| } | |
| break; | |
| default: | |
| return TypeCoercionRules::CoercionResult::get_error (); | |
| } | |
| break; | |
| case TyTy::InferType::InferTypeKind::FLOAT: | |
| switch (to.get_ty ()->get_kind ()) | |
| { | |
| case TyTy::TypeKind::USIZE: | |
| case TyTy::TypeKind::ISIZE: | |
| case TyTy::TypeKind::UINT: | |
| case TyTy::TypeKind::INT: | |
| return TypeCoercionRules::CoercionResult{ | |
| {}, to.get_ty ()->clone ()}; | |
| case TyTy::TypeKind::INFER: | |
| { | |
| TyTy::InferType *to_infer | |
| = static_cast<TyTy::InferType *> (to.get_ty ()); | |
| switch (to_infer->get_infer_kind ()) | |
| { | |
| case TyTy::InferType::InferTypeKind::GENERAL: | |
| case TyTy::InferType::InferTypeKind::FLOAT: | |
| return TypeCoercionRules::CoercionResult{ | |
| {}, to.get_ty ()->clone ()}; | |
| default: | |
| return TypeCoercionRules::CoercionResult::get_error (); | |
| } | |
| } | |
| break; | |
| default: | |
| return TypeCoercionRules::CoercionResult::get_error (); | |
| } | |
| break; | |
| } | |
| } | |
| break; | |
| case TyTy::TypeKind::BOOL: | |
| switch (to.get_ty ()->get_kind ()) | |
| { | |
| case TyTy::TypeKind::INFER: | |
| case TyTy::TypeKind::USIZE: | |
| case TyTy::TypeKind::ISIZE: | |
| case TyTy::TypeKind::UINT: | |
| case TyTy::TypeKind::INT: | |
| return TypeCoercionRules::CoercionResult{{}, to.get_ty ()->clone ()}; | |
| default: | |
| return TypeCoercionRules::CoercionResult::get_error (); | |
| } | |
| break; | |
| case TyTy::TypeKind::CHAR: | |
| case TyTy::TypeKind::USIZE: | |
| case TyTy::TypeKind::ISIZE: | |
| case TyTy::TypeKind::UINT: | |
| case TyTy::TypeKind::INT: | |
| switch (to.get_ty ()->get_kind ()) | |
| { | |
| case TyTy::TypeKind::CHAR: | |
| { | |
| // only u8 and char | |
| bool was_uint = from.get_ty ()->get_kind () == TyTy::TypeKind::UINT; | |
| bool was_u8 = was_uint | |
| && (static_cast<TyTy::UintType *> (from.get_ty ()) | |
| ->get_uint_kind () | |
| == TyTy::UintType::UintKind::U8); | |
| if (was_u8) | |
| return TypeCoercionRules::CoercionResult{{}, | |
| to.get_ty ()->clone ()}; | |
| } | |
| break; | |
| case TyTy::TypeKind::FLOAT: | |
| { | |
| // can only do this for number types not char | |
| bool from_char | |
| = from.get_ty ()->get_kind () == TyTy::TypeKind::CHAR; | |
| if (!from_char) | |
| return TypeCoercionRules::CoercionResult{{}, | |
| to.get_ty ()->clone ()}; | |
| } | |
| break; | |
| case TyTy::TypeKind::POINTER: | |
| { | |
| // char can't be casted as a ptr | |
| bool from_char | |
| = from.get_ty ()->get_kind () == TyTy::TypeKind::CHAR; | |
| if (!from_char) | |
| return TypeCoercionRules::CoercionResult{{}, | |
| to.get_ty ()->clone ()}; | |
| } | |
| break; | |
| case TyTy::TypeKind::INFER: | |
| case TyTy::TypeKind::USIZE: | |
| case TyTy::TypeKind::ISIZE: | |
| case TyTy::TypeKind::UINT: | |
| case TyTy::TypeKind::INT: | |
| return TypeCoercionRules::CoercionResult{{}, to.get_ty ()->clone ()}; | |
| default: | |
| return TypeCoercionRules::CoercionResult::get_error (); | |
| } | |
| break; | |
| case TyTy::TypeKind::FLOAT: | |
| switch (to.get_ty ()->get_kind ()) | |
| { | |
| case TyTy::TypeKind::USIZE: | |
| case TyTy::TypeKind::ISIZE: | |
| case TyTy::TypeKind::UINT: | |
| case TyTy::TypeKind::INT: | |
| return TypeCoercionRules::CoercionResult{{}, to.get_ty ()->clone ()}; | |
| case TyTy::TypeKind::FLOAT: | |
| return TypeCoercionRules::CoercionResult{{}, to.get_ty ()->clone ()}; | |
| case TyTy::TypeKind::INFER: | |
| { | |
| TyTy::InferType *to_infer | |
| = static_cast<TyTy::InferType *> (to.get_ty ()); | |
| switch (to_infer->get_infer_kind ()) | |
| { | |
| case TyTy::InferType::InferTypeKind::GENERAL: | |
| case TyTy::InferType::InferTypeKind::FLOAT: | |
| return TypeCoercionRules::CoercionResult{ | |
| {}, to.get_ty ()->clone ()}; | |
| default: | |
| return TypeCoercionRules::CoercionResult::get_error (); | |
| } | |
| } | |
| break; | |
| default: | |
| return TypeCoercionRules::CoercionResult::get_error (); | |
| } | |
| break; | |
| case TyTy::TypeKind::REF: | |
| case TyTy::TypeKind::FNPTR: | |
| case TyTy::TypeKind::POINTER: | |
| switch (to.get_ty ()->get_kind ()) | |
| { | |
| case TyTy::TypeKind::USIZE: | |
| case TyTy::TypeKind::ISIZE: | |
| case TyTy::TypeKind::UINT: | |
| case TyTy::TypeKind::INT: | |
| { | |
| // refs should not cast to numeric type | |
| auto kind = from.get_ty ()->get_kind (); | |
| bool from_ptr = kind == TyTy::TypeKind::POINTER | |
| || kind == TyTy::TypeKind::FNPTR; | |
| if (from_ptr) | |
| { | |
| return TypeCoercionRules::CoercionResult{ | |
| {}, to.get_ty ()->clone ()}; | |
| } | |
| } | |
| break; | |
| case TyTy::TypeKind::REF: | |
| case TyTy::TypeKind::POINTER: | |
| return check_ptr_ptr_cast (); | |
| default: | |
| return TypeCoercionRules::CoercionResult::get_error (); | |
| } | |
| break; | |
| default: | |
| return TypeCoercionRules::CoercionResult::get_error (); | |
| } | |
| return TypeCoercionRules::CoercionResult::get_error (); | |
| } | |
| TypeCoercionRules::CoercionResult | |
| TypeCastRules::check_ptr_ptr_cast () | |
| { | |
| rust_debug ("check_ptr_ptr_cast from={%s} to={%s}", | |
| from.get_ty ()->debug_str ().c_str (), | |
| to.get_ty ()->debug_str ().c_str ()); | |
| bool from_is_ref = from.get_ty ()->get_kind () == TyTy::TypeKind::REF; | |
| bool to_is_ref = to.get_ty ()->get_kind () == TyTy::TypeKind::REF; | |
| bool from_is_ptr = from.get_ty ()->get_kind () == TyTy::TypeKind::POINTER; | |
| bool to_is_ptr = to.get_ty ()->get_kind () == TyTy::TypeKind::POINTER; | |
| if (from_is_ptr && to_is_ptr) | |
| { | |
| // mutability is ignored here as all pointer usage requires unsafe | |
| return TypeCoercionRules::CoercionResult{{}, to.get_ty ()->clone ()}; | |
| } | |
| else if (from_is_ref && to_is_ref) | |
| { | |
| const auto &from_ref = *from.get_ty ()->as<TyTy::ReferenceType> (); | |
| const auto &to_ref = *to.get_ty ()->as<TyTy::ReferenceType> (); | |
| if (from_ref.is_dyn_object () != to_ref.is_dyn_object ()) | |
| { | |
| // this needs to be handled by coercion logic | |
| return TypeCoercionRules::CoercionResult::get_error (); | |
| } | |
| // are the underlying types safely simple castable? | |
| const auto to_underly = to_ref.get_base (); | |
| const auto from_underly = from_ref.get_base (); | |
| auto res = resolve (locus, TyTy::TyWithLocation (from_underly), | |
| TyTy::TyWithLocation (to_underly), false); | |
| if (res.is_error ()) | |
| { | |
| // this needs to be handled by coercion logic | |
| return TypeCoercionRules::CoercionResult::get_error (); | |
| } | |
| // mutability must be coerceable | |
| TyTy::ReferenceType &f | |
| = static_cast<TyTy::ReferenceType &> (*from.get_ty ()); | |
| TyTy::ReferenceType &t | |
| = static_cast<TyTy::ReferenceType &> (*to.get_ty ()); | |
| if (TypeCoercionRules::coerceable_mutability (f.mutability (), | |
| t.mutability ())) | |
| { | |
| return TypeCoercionRules::CoercionResult{{}, to.get_ty ()->clone ()}; | |
| } | |
| } | |
| return TypeCoercionRules::CoercionResult::get_error (); | |
| } | |
| void | |
| TypeCastRules::emit_cast_error (location_t locus, TyTy::TyWithLocation from, | |
| TyTy::TyWithLocation to) | |
| { | |
| rich_location r (line_table, locus); | |
| r.add_range (from.get_locus ()); | |
| r.add_range (to.get_locus ()); | |
| ErrorCode error_code; | |
| std::string error_msg; | |
| switch (to.get_ty ()->get_kind ()) | |
| { | |
| case TyTy::TypeKind::BOOL: | |
| error_msg = "cannot cast %qs as %qs"; | |
| error_code = ErrorCode::E0054; | |
| break; | |
| case TyTy::TypeKind::CHAR: | |
| error_msg | |
| += "cannot cast %qs as %qs, only %<u8%> can be cast as %<char%>"; | |
| error_code = ErrorCode::E0604; | |
| break; | |
| case TyTy::TypeKind::SLICE: | |
| error_msg = "cast to unsized type: %qs as %qs"; | |
| error_code = ErrorCode::E0620; | |
| break; | |
| default: | |
| error_msg = "casting %qs as %qs is invalid"; | |
| error_code = ErrorCode::E0606; | |
| break; | |
| } | |
| rust_error_at (r, error_code, error_msg.c_str (), | |
| from.get_ty ()->get_name ().c_str (), | |
| to.get_ty ()->get_name ().c_str ()); | |
| } | |
| } // namespace Resolver | |
| } // namespace Rust |