diff --git a/charon-ml/src/CharonVersion.ml b/charon-ml/src/CharonVersion.ml index 9adcfa763..bee0ea833 100644 --- a/charon-ml/src/CharonVersion.ml +++ b/charon-ml/src/CharonVersion.ml @@ -1,3 +1,3 @@ (* This is an automatically generated file, generated from `charon/Cargo.toml`. *) (* To re-generate this file, rune `make` in the root directory *) -let supported_charon_version = "0.1.236" +let supported_charon_version = "0.1.237" diff --git a/charon-ml/src/PrintFmt.ml b/charon-ml/src/PrintFmt.ml index 868fc59d3..a3b69d54f 100644 --- a/charon-ml/src/PrintFmt.ml +++ b/charon-ml/src/PrintFmt.ml @@ -1101,6 +1101,106 @@ let pp_generic_params_single_line (env : fmt_env) (fmt : Format.formatter) let generic_params_to_string_single_line env generics = pp_to_string (fun fmt -> pp_generic_params_single_line env fmt generics) +(** Print a built-in attribute the way it is written in the source. *) +let pp_rustc_attribute_kind (fmt : Format.formatter) + (kind : rustc_attribute_kind) : unit = + match kind with + | RustcAttributeKindAutomaticallyDerived -> + pp_string fmt "automatically_derived" + | RustcAttributeKindCold -> pp_string fmt "cold" + | RustcAttributeKindDeprecated (deprecation, _) -> + pp_string fmt "deprecated"; + let since = + match deprecation.since with + | RustcDeprecatedSinceRustcVersion v -> + Some (Printf.sprintf "%d.%d.%d" v.major v.minor v.patch) + | RustcDeprecatedSinceFuture -> Some "future" + | RustcDeprecatedSinceNonStandard since -> Some since + | RustcDeprecatedSinceUnspecified | RustcDeprecatedSinceErr -> None + in + let since = Option.map (fun since -> "since = \"" ^ since ^ "\"") since in + let note = + Option.map + (fun (note : rustc_ident) -> "note = \"" ^ note.name ^ "\"") + deprecation.note + in + let args = List.filter_map (fun x -> x) [ since; note ] in + if args <> [] then Format.fprintf fmt "(%s)" (String.concat ", " args) + | RustcAttributeKindFundamental -> pp_string fmt "fundamental" + | RustcAttributeKindIgnore (_, reason) -> + pp_string fmt "ignore"; + Option.iter (fun reason -> Format.fprintf fmt " = \"%s\"" reason) reason + | RustcAttributeKindInline (inline, _) -> ( + match inline with + | RustcInlineAttrNone -> pp_string fmt "inline" + | RustcInlineAttrHint -> pp_string fmt "inline(hint)" + | RustcInlineAttrAlways -> pp_string fmt "inline(always)" + | RustcInlineAttrNever -> pp_string fmt "inline(never)" + | RustcInlineAttrForce _ -> pp_string fmt "rustc_force_inline") + | RustcAttributeKindMayDangle _ -> pp_string fmt "may_dangle" + | RustcAttributeKindNaked _ -> pp_string fmt "naked" + | RustcAttributeKindNoLink -> pp_string fmt "no_link" + | RustcAttributeKindNoMangle _ -> pp_string fmt "no_mangle" + | RustcAttributeKindNonExhaustive _ -> pp_string fmt "non_exhaustive" + | RustcAttributeKindOptimize (optimize, _) -> ( + match optimize with + | RustcOptimizeAttrDefault -> pp_string fmt "optimize(default)" + | RustcOptimizeAttrDoNotOptimize -> pp_string fmt "optimize(none)" + | RustcOptimizeAttrSpeed -> pp_string fmt "optimize(speed)" + | RustcOptimizeAttrSize -> pp_string fmt "optimize(size)") + | RustcAttributeKindRustcAlign (align, _) -> + Format.fprintf fmt "rustc_align(%d)" align + | RustcAttributeKindRustcIntrinsic -> pp_string fmt "rustc_intrinsic" + | RustcAttributeKindRustcTestEntrypointMarker -> + pp_string fmt "rustc_test_entrypoint_marker" + | RustcAttributeKindShouldPanic reason -> + pp_string fmt "should_panic"; + Option.iter + (fun reason -> Format.fprintf fmt "(expected = \"%s\")" reason) + reason + | RustcAttributeKindTargetFeature (features, _, _) -> + let features = List.map (fun (feature, _) -> feature) features in + Format.fprintf fmt "target_feature(enable = \"%s\")" + (String.concat "," features) + | RustcAttributeKindTrackCaller _ -> pp_string fmt "track_caller" + +let pp_item_id (env : fmt_env) (fmt : Format.formatter) (id : item_id) : unit = + match find_short_name env id with + | Some name -> pp_name env fmt name + | None -> pp_string fmt (item_id_to_pretty_string id) + +let pp_attribute_unindented (env : fmt_env) (fmt : Format.formatter) + (attr : attribute) : unit = + match attr with + | AttrOpaque -> pp_string fmt "#[charon::opaque]" + | AttrExclude -> pp_string fmt "#[charon::exclude]" + | AttrRename name -> Format.fprintf fmt "#[charon::rename(\"%s\")]" name + | AttrVariantsPrefix prefix -> + Format.fprintf fmt "#[charon::variants_prefix(\"%s\")]" prefix + | AttrVariantsSuffix suffix -> + Format.fprintf fmt "#[charon::variants_suffix(\"%s\")]" suffix + | AttrTransparent -> pp_string fmt "#[charon::transparent]" + | AttrIsPrecondition id -> + Format.fprintf fmt "#[charon::precondition] // of %a" (pp_item_id env) id + | AttrIsPostcondition id -> + Format.fprintf fmt "#[charon::postcondition] // of %a" (pp_item_id env) id + | AttrHasPrecondition id -> + Format.fprintf fmt "// precondition: %a" (pp_item_id env) (IdFun id) + | AttrHasPostcondition id -> + Format.fprintf fmt "// postcondition: %a" (pp_item_id env) (IdFun id) + | AttrDocComment comment -> + let lines = String.split_on_char '\n' comment in + pp_sep_list "\n" pp_string fmt (List.map (fun line -> "///" ^ line) lines) + | AttrBuiltin kind -> Format.fprintf fmt "#[%a]" pp_rustc_attribute_kind kind + | AttrUnknown attr -> Format.fprintf fmt "#[%a]" pp_raw_attribute attr + +let pp_attribute (env : fmt_env) (indent : string) (fmt : Format.formatter) + (attr : attribute) : unit = + (* An attribute may span several lines: the caller indents the first line, we + indent the subsequent ones ourselves. *) + let attr = pp_to_string (fun fmt -> pp_attribute_unindented env fmt attr) in + pp_sep_list ("\n" ^ indent) pp_string fmt (String.split_on_char '\n' attr) + let pp_item_intro (env : fmt_env) (indent : string) (keyword : string) (id : item_id) (fmt : Format.formatter) (meta : item_meta) : unit = let full_name = full_name_to_string env meta.name in @@ -1110,6 +1210,20 @@ let pp_item_intro (env : fmt_env) (indent : string) (keyword : string) (name_to_string env short_name, "// Full name: " ^ full_name ^ "\n") | None -> (full_name, "") in + let attributes = + List.filter_map + (fun attr -> + (* Doc-comments are long and don't affect the semantics; skip them. *) + match attr with + | AttrDocComment _ -> None + | _ -> + Some + (indent + ^ pp_to_string (fun fmt -> pp_attribute env indent fmt attr) + ^ "\n")) + meta.attr_info.attributes + |> String.concat "" + in let lang_item = match meta.lang_item with | None -> "" @@ -1130,7 +1244,7 @@ let pp_item_intro (env : fmt_env) (indent : string) (keyword : string) | Some id -> indent ^ "#[diagnostic_item(\"" ^ id ^ "\")]\n" in let public = if meta.attr_info.public then "pub " else "" in - Format.fprintf fmt "%s%s%s%s%s%s %s" full_name_comment lang_item + Format.fprintf fmt "%s%s%s%s%s%s%s %s" full_name_comment attributes lang_item diagnostic_item indent public keyword name let item_intro_to_string env indent keyword id meta = diff --git a/charon-ml/src/generated/Generated_Meta.ml b/charon-ml/src/generated/Generated_Meta.ml index 002e5fc43..c503fc4b2 100644 --- a/charon-ml/src/generated/Generated_Meta.ml +++ b/charon-ml/src/generated/Generated_Meta.ml @@ -205,9 +205,9 @@ and rustc_attribute_kind = Fields: - [align] - [span] *) - | RustcAttributeKindRustcDiagnosticItem of string - (** Represents [#[rustc_diagnostic_item]] *) | RustcAttributeKindRustcIntrinsic (** Represents [#[rustc_intrinsic]] *) + | RustcAttributeKindRustcTestEntrypointMarker + (** Represents [#[rustc_test_entrypoint_marker]] *) | RustcAttributeKindShouldPanic of string option (** Represents [#[should_panic]] diff --git a/charon-ml/src/generated/Generated_OfJson.ml b/charon-ml/src/generated/Generated_OfJson.ml index 1ef9bc298..8977bd40d 100644 --- a/charon-ml/src/generated/Generated_OfJson.ml +++ b/charon-ml/src/generated/Generated_OfJson.ml @@ -2079,10 +2079,9 @@ and rustc_attribute_kind_of_json (ctx : of_json_ctx) (js : json) : let* align = int_of_json ctx align in let* span = span_of_json ctx span in Ok (RustcAttributeKindRustcAlign (align, span)) - | `Assoc [ ("RustcDiagnosticItem", _0) ] -> - let* _0 = string_of_json ctx _0 in - Ok (RustcAttributeKindRustcDiagnosticItem _0) | `String "RustcIntrinsic" -> Ok RustcAttributeKindRustcIntrinsic + | `String "RustcTestEntrypointMarker" -> + Ok RustcAttributeKindRustcTestEntrypointMarker | `Assoc [ ("ShouldPanic", `Assoc [ ("reason", reason) ]) ] -> let* reason = option_of_json string_of_json ctx reason in Ok (RustcAttributeKindShouldPanic reason) diff --git a/charon-ml/src/generated/Generated_OfPostcard.ml b/charon-ml/src/generated/Generated_OfPostcard.ml index 6970626b5..b09396682 100644 --- a/charon-ml/src/generated/Generated_OfPostcard.ml +++ b/charon-ml/src/generated/Generated_OfPostcard.ml @@ -1818,10 +1818,8 @@ and rustc_attribute_kind_of_postcard (ctx : of_postcard_ctx) let* align = u64_of_postcard ctx st in let* span = span_of_postcard ctx st in Ok (RustcAttributeKindRustcAlign (align, span)) - | 13 -> - let* _0 = string_of_postcard ctx st in - Ok (RustcAttributeKindRustcDiagnosticItem _0) - | 14 -> Ok RustcAttributeKindRustcIntrinsic + | 13 -> Ok RustcAttributeKindRustcIntrinsic + | 14 -> Ok RustcAttributeKindRustcTestEntrypointMarker | 15 -> let* reason = option_of_postcard string_of_postcard ctx st in Ok (RustcAttributeKindShouldPanic reason) diff --git a/charon/Cargo.lock b/charon/Cargo.lock index 57ccc7146..d9ccee84b 100644 --- a/charon/Cargo.lock +++ b/charon/Cargo.lock @@ -237,7 +237,7 @@ checksum = "9555578bc9e57714c812a1f84e4fc5b4d21fcb063490c624de019f7464c91268" [[package]] name = "charon" -version = "0.1.236" +version = "0.1.237" dependencies = [ "annotate-snippets", "anstream", diff --git a/charon/Cargo.toml b/charon/Cargo.toml index 87f6214ce..ca0854422 100644 --- a/charon/Cargo.toml +++ b/charon/Cargo.toml @@ -26,7 +26,7 @@ tracing = { version = "0.1", features = ["max_level_trace"] } [package] name = "charon" -version = "0.1.236" +version = "0.1.237" authors.workspace = true edition.workspace = true license.workspace = true diff --git a/charon/src/ast/from_rustc.rs b/charon/src/ast/from_rustc.rs index 0ed2f6a4b..a679bc6c4 100644 --- a/charon/src/ast/from_rustc.rs +++ b/charon/src/ast/from_rustc.rs @@ -104,10 +104,10 @@ pub enum AttributeKind { Optimize(OptimizeAttr, Span), /// Represents `#[align(N)]`. RustcAlign { align: u64, span: Span }, - /// Represents `#[rustc_diagnostic_item]` - RustcDiagnosticItem(Ustr), /// Represents `#[rustc_intrinsic]` RustcIntrinsic, + /// Represents `#[rustc_test_entrypoint_marker]` + RustcTestEntrypointMarker, /// Represents `#[should_panic]` ShouldPanic { reason: Option }, /// Represents `#[target_feature(enable = "...")]` and diff --git a/charon/src/bin/charon-driver/translate/translate_from_rustc.rs b/charon/src/bin/charon-driver/translate/translate_from_rustc.rs index 6c4b6d376..2e26c9f69 100644 --- a/charon/src/bin/charon-driver/translate/translate_from_rustc.rs +++ b/charon/src/bin/charon-driver/translate/translate_from_rustc.rs @@ -82,10 +82,10 @@ impl<'tcx> TranslateCtx<'tcx> { span: self.translate_span(span), }) } - AttributeKind::RustcDiagnosticItem(_0) => Ok( - from_rustc::AttributeKind::RustcDiagnosticItem((_0).to_string().into()), - ), AttributeKind::RustcIntrinsic => Ok(from_rustc::AttributeKind::RustcIntrinsic), + AttributeKind::RustcTestEntrypointMarker => { + Ok(from_rustc::AttributeKind::RustcTestEntrypointMarker) + } AttributeKind::ShouldPanic { reason } => Ok(from_rustc::AttributeKind::ShouldPanic { reason: (reason) .as_ref() diff --git a/charon/src/bin/generate-asts/generate_rust.rs b/charon/src/bin/generate-asts/generate_rust.rs index c4dbf4725..c445d8616 100644 --- a/charon/src/bin/generate-asts/generate_rust.rs +++ b/charon/src/bin/generate-asts/generate_rust.rs @@ -73,8 +73,8 @@ impl RustcDatatypes { "NonExhaustive", "Optimize", "RustcAlign", - "RustcDiagnosticItem", "RustcIntrinsic", + "RustcTestEntrypointMarker", "ShouldPanic", "TargetFeature", "TrackCaller", diff --git a/charon/src/pretty/fmt_with_ctx.rs b/charon/src/pretty/fmt_with_ctx.rs index 6037a9cb9..66f99216d 100644 --- a/charon/src/pretty/fmt_with_ctx.rs +++ b/charon/src/pretty/fmt_with_ctx.rs @@ -1143,6 +1143,13 @@ impl ItemMeta { writeln!(f, "// Full name: {}", self.name.full_name(ctx))?; } + for attr in &self.attr_info.attributes { + // Doc-comments are long and don't affect the semantics; skip them. + if attr.is_doc_comment() { + continue; + } + writeln!(f, "{tab}{}", attr.with_ctx(ctx))?; + } if let Some(id) = &self.lang_item { writeln!(f, "{tab}#[lang_item({id:?})]")?; } @@ -1429,6 +1436,133 @@ impl PolyTraitDeclRef { } } +impl FmtWithCtx for Attribute { + fn fmt_with_ctx(&self, ctx: &C, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let mut attr = String::new(); + self.fmt_unindented(ctx, &mut attr)?; + let sep = format!("\n{}", ctx.indent()); + write!(f, "{}", attr.lines().format(sep.as_str())) + } +} + +impl Attribute { + fn fmt_unindented(&self, ctx: &C, f: &mut impl fmt::Write) -> fmt::Result { + match self { + Attribute::Opaque => write!(f, "#[charon::opaque]"), + Attribute::Exclude => write!(f, "#[charon::exclude]"), + Attribute::Rename(name) => write!(f, "#[charon::rename(\"{name}\")]"), + Attribute::VariantsPrefix(prefix) => { + write!(f, "#[charon::variants_prefix(\"{prefix}\")]") + } + Attribute::VariantsSuffix(suffix) => { + write!(f, "#[charon::variants_suffix(\"{suffix}\")]") + } + Attribute::Transparent => write!(f, "#[charon::transparent]"), + Attribute::IsPrecondition(id) => { + write!(f, "#[charon::precondition] // of {}", id.with_ctx(ctx)) + } + Attribute::IsPostcondition(id) => { + write!(f, "#[charon::postcondition] // of {}", id.with_ctx(ctx)) + } + Attribute::HasPrecondition(id) => { + let id = ItemId::Fun(*id); + write!(f, "// precondition: {}", id.with_ctx(ctx)) + } + Attribute::HasPostcondition(id) => { + let id = ItemId::Fun(*id); + write!(f, "// postcondition: {}", id.with_ctx(ctx)) + } + Attribute::DocComment(comment) => { + write!( + f, + "{}", + comment + .lines() + .map(|line| format!("///{line}")) + .format("\n") + ) + } + Attribute::Builtin(kind) => write!(f, "#[{kind}]"), + Attribute::Unknown(attr) => write!(f, "#[{attr}]"), + } + } +} + +/// Print a built-in attribute the way it is written in the source. +impl Display for from_rustc::AttributeKind { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + use from_rustc::AttributeKind; + match self { + AttributeKind::AutomaticallyDerived => write!(f, "automatically_derived"), + AttributeKind::Cold => write!(f, "cold"), + AttributeKind::Deprecated { deprecation, .. } => { + write!(f, "deprecated")?; + let since = match &deprecation.since { + from_rustc::DeprecatedSince::RustcVersion(v) => { + Some(format!("{}.{}.{}", v.major, v.minor, v.patch)) + } + from_rustc::DeprecatedSince::Future => Some("future".to_owned()), + from_rustc::DeprecatedSince::NonStandard(since) => Some(since.to_string()), + from_rustc::DeprecatedSince::Unspecified | from_rustc::DeprecatedSince::Err => { + None + } + }; + let since = since.map(|since| format!("since = \"{since}\"")); + let note = deprecation + .note + .as_ref() + .map(|note| format!("note = \"{}\"", note.name)); + let args = since.into_iter().chain(note).format(", ").to_string(); + if !args.is_empty() { + write!(f, "({args})")?; + } + Ok(()) + } + AttributeKind::Fundamental => write!(f, "fundamental"), + AttributeKind::Ignore { reason, .. } => { + write!(f, "ignore")?; + if let Some(reason) = reason { + write!(f, " = \"{reason}\"")?; + } + Ok(()) + } + AttributeKind::Inline(inline, _) => match inline { + from_rustc::InlineAttr::None => write!(f, "inline"), + from_rustc::InlineAttr::Hint => write!(f, "inline(hint)"), + from_rustc::InlineAttr::Always => write!(f, "inline(always)"), + from_rustc::InlineAttr::Never => write!(f, "inline(never)"), + from_rustc::InlineAttr::Force { .. } => write!(f, "rustc_force_inline"), + }, + AttributeKind::MayDangle(_) => write!(f, "may_dangle"), + AttributeKind::Naked(_) => write!(f, "naked"), + AttributeKind::NoLink => write!(f, "no_link"), + AttributeKind::NoMangle(_) => write!(f, "no_mangle"), + AttributeKind::NonExhaustive(_) => write!(f, "non_exhaustive"), + AttributeKind::Optimize(optimize, _) => match optimize { + from_rustc::OptimizeAttr::Default => write!(f, "optimize(default)"), + from_rustc::OptimizeAttr::DoNotOptimize => write!(f, "optimize(none)"), + from_rustc::OptimizeAttr::Speed => write!(f, "optimize(speed)"), + from_rustc::OptimizeAttr::Size => write!(f, "optimize(size)"), + }, + AttributeKind::RustcAlign { align, .. } => write!(f, "rustc_align({align})"), + AttributeKind::RustcIntrinsic => write!(f, "rustc_intrinsic"), + AttributeKind::RustcTestEntrypointMarker => write!(f, "rustc_test_entrypoint_marker"), + AttributeKind::ShouldPanic { reason } => { + write!(f, "should_panic")?; + if let Some(reason) = reason { + write!(f, "(expected = \"{reason}\")")?; + } + Ok(()) + } + AttributeKind::TargetFeature { features, .. } => { + let features = features.iter().map(|(feature, _)| feature).format(","); + write!(f, "target_feature(enable = \"{features}\")") + } + AttributeKind::TrackCaller(_) => write!(f, "track_caller"), + } + } +} + impl Display for RawAttribute { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> std::result::Result<(), fmt::Error> { write!(f, "{}", self.path)?; diff --git a/charon/tests/cargo.rs b/charon/tests/cargo.rs index 325bc43ff..6c064a9b8 100644 --- a/charon/tests/cargo.rs +++ b/charon/tests/cargo.rs @@ -234,6 +234,13 @@ fn main() -> Result<(), Box> { Success, ), issue_1298, + mktest( + "test-attributes", + root.join("test-attributes"), + &[], + &["--tests".to_owned()], + Success, + ), ]; let args = libtest_mimic::Arguments::from_args(); diff --git a/charon/tests/cargo/dependencies.out b/charon/tests/cargo/dependencies.out index 9eef9366d..6f97190f3 100644 --- a/charon/tests/cargo/dependencies.out +++ b/charon/tests/cargo/dependencies.out @@ -5,10 +5,12 @@ pub opaque type Arguments<'a> // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -17,6 +19,7 @@ pub trait Sized } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -25,6 +28,7 @@ pub trait Tuple } // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { diff --git a/charon/tests/cargo/issue-396-lib-bin.out b/charon/tests/cargo/issue-396-lib-bin.out index 4ac1692cc..57def1792 100644 --- a/charon/tests/cargo/issue-396-lib-bin.out +++ b/charon/tests/cargo/issue-396-lib-bin.out @@ -36,10 +36,12 @@ pub unsafe fn new<'a, const N : usize, const M : usize>(_1: &'a [u8; N], _2: &'a = // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/cargo/issue-412-dup-deps.out b/charon/tests/cargo/issue-412-dup-deps.out index 7f448fe26..93303d03b 100644 --- a/charon/tests/cargo/issue-412-dup-deps.out +++ b/charon/tests/cargo/issue-412-dup-deps.out @@ -5,10 +5,12 @@ pub opaque type Arguments<'a> // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/cargo/test-attributes.out b/charon/tests/cargo/test-attributes.out new file mode 100644 index 000000000..d96959ec9 --- /dev/null +++ b/charon/tests/cargo/test-attributes.out @@ -0,0 +1,976 @@ +# Final LLBC before serialization: + +// Full name: core::alloc::layout::Layout +#[lang_item(AllocLayout)] +pub opaque type Layout + +// Full name: core::alloc::AllocError +pub struct AllocError {} + +// Full name: core::marker::MetaSized +#[fundamental] +#[lang_item(MetaSized)] +pub trait MetaSized + +// Full name: core::marker::Sized +#[fundamental] +#[lang_item(Sized)] +pub trait Sized +{ + proof ImpliedClause0: (Self: MetaSized) + non-dyn-compatible +} + +// Full name: core::result::Result +#[diagnostic_item("Result")] +pub enum Result +where + TraitClause0: (T: Sized), + TraitClause1: (E: Sized), +{ + Ok { _0: T }, + Err { _0: E }, +} + +// Full name: core::ptr::non_null::NonNull +#[diagnostic_item("NonNull")] +pub opaque type NonNull + +// Full name: core::alloc::Allocator +pub trait Allocator +{ + proof ImpliedClause0: (Self: MetaSized) + fn allocate<'_0_1>; + fn deallocate<'_0_1>; + vtable: core::alloc::Allocator::{vtable} +} + +// Full name: core::borrow::Borrow +#[diagnostic_item("Borrow")] +pub trait Borrow +{ + proof ImpliedClause0: (Self: MetaSized) + proof ImpliedClause1: (Borrowed: MetaSized) + fn borrow<'_0_1>; + vtable: core::borrow::Borrow::{vtable} +} + +// Full name: core::fmt::Arguments +#[lang_item(FormatArguments)] +pub opaque type Arguments<'a> + +// Full name: core::fmt::{Arguments<'a>}::from_str +pub fn from_str<'a>(_1: &'static str) -> Arguments<'a> += + +// Full name: core::marker::Send +#[diagnostic_item("Send")] +pub trait Send + +// Full name: core::marker::Destruct +#[lang_item(Destruct)] +pub trait Destruct +{ + fn drop_glue<'_0_1>; + non-dyn-compatible +} + +// Full name: core::marker::Tuple +#[fundamental] +#[lang_item(Tuple)] +pub trait Tuple +{ + proof ImpliedClause0: (Self: MetaSized) + non-dyn-compatible +} + +opaque type core::ops::function::Fn::{vtable} + +opaque type core::ops::function::FnOnce::{vtable} + +// Full name: core::ops::function::FnOnce +#[fundamental] +#[lang_item(FnOnce)] +pub trait FnOnce +{ + proof ImpliedClause0: (Self: MetaSized) + proof ImpliedClause1: (Args: Sized) + proof ImpliedClause2: (Args: Tuple) + proof ImpliedClause3: (Self::Output: Sized) + type Output + fn call_once; + vtable: core::ops::function::FnOnce::{vtable} +} + +// Full name: core::ops::function::FnMut +#[fundamental] +#[lang_item(FnMut)] +pub trait FnMut +{ + proof ImpliedClause0: (Self: MetaSized) + proof ImpliedClause1: (Self: FnOnce) + proof ImpliedClause2: (Args: Sized) + proof ImpliedClause3: (Args: Tuple) + fn call_mut<'_0_1>; + vtable: core::ops::function::FnMut::{vtable} +} + +// Full name: core::ops::function::Fn +#[fundamental] +#[lang_item(Fn)] +pub trait Fn +{ + proof ImpliedClause0: (Self: MetaSized) + proof ImpliedClause1: (Self: FnMut) + proof ImpliedClause2: (Args: Sized) + proof ImpliedClause3: (Args: Tuple) + fn call<'_0_1>; + vtable: core::ops::function::Fn::{vtable} +} + +// Full name: core::option::Option +#[lang_item(Option)] +#[diagnostic_item("Option")] +pub enum Option +where + TraitClause0: (T: Sized), +{ + None, + Some { _0: T }, +} + +// Full name: std::process::ExitCode +pub opaque type ExitCode + +// Full name: std::process::Termination +#[lang_item(Termination)] +pub trait Termination +{ + proof ImpliedClause0: (Self: MetaSized) + fn report; + vtable: std::process::Termination::{vtable} +} + +// Full name: std::process::{impl Termination for ()}::report +pub fn report(_1: ()) -> ExitCode += + +// Full name: std::process::{impl Termination for ()} +impl "impl_Termination_for_unit" Termination for () { + proof ImpliedClause0: ((): MetaSized) = {built_in impl MetaSized for ()} + fn report = report + vtable: impl_Termination_for_unit::{vtable} +} + +// Full name: alloc::alloc::Global +#[lang_item(GlobalAlloc)] +pub struct Global {} + +// Full name: alloc::alloc::{impl Allocator for Global}::deallocate +#[track_caller] +pub unsafe fn deallocate<'_0>(_1: &'_0 Global, _2: NonNull, _3: Layout) += + +// Full name: alloc::alloc::{impl Allocator for Global}::allocate +#[track_caller] +pub fn allocate<'_0>(_1: &'_0 Global, _2: Layout) -> Result, AllocError>[{built_in impl Sized for NonNull<[u8]>}, {built_in impl Sized for AllocError}] += + +// Full name: alloc::alloc::{impl Allocator for Global} +impl "impl_Allocator_for_Global" Allocator for Global { + proof ImpliedClause0: (Global: MetaSized) = {built_in impl MetaSized for Global} + fn allocate<'_0_1> = allocate<'_0_1> + fn deallocate<'_0_1> = deallocate<'_0_1> + vtable: impl_Allocator_for_Global::{vtable} +} + +// Full name: alloc::borrow::ToOwned +#[diagnostic_item("ToOwned")] +pub trait ToOwned +{ + proof ImpliedClause0: (Self: MetaSized) + proof ImpliedClause1: (Self::Owned: Sized) + proof ImpliedClause2: (Self::Owned: Borrow) + type Owned + fn to_owned<'_0_1>; + non-dyn-compatible +} + +// Full name: alloc::borrow::Cow +#[diagnostic_item("Cow")] +pub enum Cow<'a, B> +where + TraitClause0: (B: MetaSized), + TraitClause1: (B: ToOwned), + TypeOutlives0: B: 'a, + TypeOutlives1: B: 'a, +{ + Borrowed { _0: &'a B }, + Owned { _0: TraitClause1::Owned }, +} + +// Full name: alloc::boxed::Box +#[fundamental] +#[lang_item(OwnedBox)] +pub opaque type Box +where + TraitClause0: (T: MetaSized), + TraitClause1: (A: Sized), + TraitClause2: (A: Allocator), + +// Full name: alloc::string::String +#[lang_item(String)] +pub opaque type String + +// Full name: alloc::str::{impl Borrow for String}::borrow +pub fn borrow<'_0>(_1: &'_0 String) -> &'_0 str += + +// Full name: alloc::str::{impl Borrow for String} +impl "impl_Borrow_str_for_String" Borrow for String { + proof ImpliedClause0: (String: MetaSized) = {built_in impl MetaSized for String} + proof ImpliedClause1: (str: MetaSized) = {built_in impl MetaSized for str} + fn borrow<'_0_1> = borrow<'_0_1> + vtable: impl_Borrow_str_for_String::{vtable} +} + +// Full name: alloc::str::{impl ToOwned for str}::to_owned +pub fn to_owned<'_0>(_1: &'_0 str) -> String += + +// Full name: alloc::str::{impl ToOwned for str} +impl "impl_ToOwned_for_str" ToOwned for str { + proof ImpliedClause0: (str: MetaSized) = {built_in impl MetaSized for str} + proof ImpliedClause1: (String: Sized) = {built_in impl Sized for String} + proof ImpliedClause2: (String: Borrow) = impl_Borrow_str_for_String + type Owned = String + fn to_owned<'_0_1> = to_owned<'_0_1> + non-dyn-compatible +} + +// Full name: test::bench::Bencher +pub opaque type Bencher + +// Full name: test::types::NamePadding +pub enum NamePadding { + PadNone, + PadOnRight, +} + +// Full name: test::types::TestName +pub enum TestName { + StaticTestName { _0: &'static str }, + DynTestName { _0: String }, + AlignedTestName { _0: Cow<'static, str>[{built_in impl MetaSized for str}, impl_ToOwned_for_str], _1: NamePadding }, +} + +// Full name: test::types::TestType +pub enum TestType { + UnitTest, + IntegrationTest, + DocTest, + Unknown, +} + +// Full name: test::options::ShouldPanic +pub enum ShouldPanic { + No, + Yes, + YesWithMessage { _0: &'static str }, +} + +// Full name: test::types::TestDesc +pub struct TestDesc { + name: TestName, + ignore: bool, + ignore_message: Option<&'static str>[{built_in impl Sized for &'static str}], + source_file: &'static str, + start_line: usize, + start_col: usize, + end_line: usize, + end_col: usize, + should_panic: ShouldPanic, + compile_fail: bool, + no_run: bool, + test_type: TestType, +} + +// Full name: test::types::TestFn +pub enum TestFn { + StaticTestFn { _0: fn() -> Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}] }, + StaticBenchFn { _0: fn<'_0_1>(&'_0_1 mut Bencher) -> Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}] }, + StaticBenchAsTestFn { _0: fn<'_0_1>(&'_0_1 mut Bencher) -> Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}] }, + DynTestFn { _0: Box<(dyn FnOnce<(), Output = Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}]> + Send + 'static), Global>[{built_in impl MetaSized for (dyn FnOnce<(), Output = Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}]> + Send + 'static)}, {built_in impl Sized for Global}, impl_Allocator_for_Global] }, + DynBenchFn { _0: Box<(dyn for<'_0_2> Fn<(&'_0_2 mut Bencher,), ImpliedClause1::ImpliedClause1::Output = Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}]> + Send + 'static), Global>[{built_in impl MetaSized for (dyn for<'_0_3> Fn<(&'_0_3 mut Bencher,), ImpliedClause1::ImpliedClause1::Output = Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}]> + Send + 'static)}, {built_in impl Sized for Global}, impl_Allocator_for_Global] }, + DynBenchAsTestFn { _0: Box<(dyn for<'_0_2> Fn<(&'_0_2 mut Bencher,), ImpliedClause1::ImpliedClause1::Output = Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}]> + Send + 'static), Global>[{built_in impl MetaSized for (dyn for<'_0_3> Fn<(&'_0_3 mut Bencher,), ImpliedClause1::ImpliedClause1::Output = Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}]> + Send + 'static)}, {built_in impl Sized for Global}, impl_Allocator_for_Global] }, +} + +// Full name: test::types::TestDescAndFn +pub struct TestDescAndFn { + desc: TestDesc, + testfn: TestFn, +} + +// Full name: test::test_main_static +pub fn test_main_static<'_0, '_1>(_1: &'_0 [&'_1 TestDescAndFn]) +where + RegionOutlives0: '_1: '_0, += + +// Full name: test::assert_test_result +pub fn assert_test_result(_1: T) -> Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}] +where + TraitClause0: (T: Sized), + TraitClause1: (T: Termination), += + +// Full name: test::types::TestName::{impl Destruct for TestName}::drop_glue +unsafe fn impl_Destruct_for_TestName::drop_glue<'_0>(_1: &'_0 mut TestName) += + +// Full name: test::types::TestFn::{impl Destruct for TestFn}::drop_glue +unsafe fn impl_Destruct_for_TestFn::drop_glue<'_0>(_1: &'_0 mut TestFn) += + +// Full name: test::types::TestDesc::{impl Destruct for TestDesc}::drop_glue +unsafe fn impl_Destruct_for_TestDesc::drop_glue<'_0>(_1: &'_0 mut TestDesc) += + +// Full name: test_attributes::foo +fn foo() +{ + let _0: (); // return + + storage_live(_0) + _0 = () + _0 = () + return +} + +struct test_attributes::tests::test_ignore::closure {} + +// Full name: test_attributes::tests::test_ignore::closure::{impl Destruct for test_attributes::tests::test_ignore::closure}::drop_glue +unsafe fn {impl Destruct for test_attributes::tests::test_ignore::closure}::drop_glue<'_0>(_1: &'_0 mut test_attributes::tests::test_ignore::closure) +{ + let _0: (); // return + let _1: &'1 mut test_attributes::tests::test_ignore::closure; // arg #1 + + storage_live(_0) + _0 = () + return +} + +#[ignore] +#[rustc_test_entrypoint_marker] +fn test_attributes::tests::test_ignore#1() +{ + let _0: (); // return + + storage_live(_0) + _0 = () + _0 = () + return +} + +// Full name: test_attributes::tests::test_ignore::{impl Fn<()> for test_attributes::tests::test_ignore::closure}::call +fn {impl Fn<()> for test_attributes::tests::test_ignore::closure}::call<'_0>(_1: &'_0 test_attributes::tests::test_ignore::closure, tupled_args: ()) -> Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}] +{ + let _0: Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}]; // return + let _1: &'1 test_attributes::tests::test_ignore::closure; // arg #1 + let tupled_args: (); // arg #2 + let _3: (); // anonymous local + + storage_live(_0) + storage_live(_3) + _3 = test_attributes::tests::test_ignore#1() + ↳⚡ unwind_continue + _0 = assert_test_result<()>[{built_in impl Sized for ()}, impl_Termination_for_unit](move _3) + ↳⚡ unwind_continue + storage_dead(_3) + return +} + +// Full name: test_attributes::tests::test_ignore::{impl FnMut<()> for test_attributes::tests::test_ignore::closure}::call_mut +fn {impl FnMut<()> for test_attributes::tests::test_ignore::closure}::call_mut<'_0>(state: &'_0 mut test_attributes::tests::test_ignore::closure, args: ()) -> Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}] +{ + let _0: Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}]; // return + let state: &'_0 mut test_attributes::tests::test_ignore::closure; // arg #1 + let args: (); // arg #2 + let _3: &'0 test_attributes::tests::test_ignore::closure; // anonymous local + + storage_live(_0) + storage_live(_3) + _3 = &(*state) + _0 = {impl Fn<()> for test_attributes::tests::test_ignore::closure}::call<'2>(move _3, move args) + ↳⚡ unwind_continue + return +} + +// Full name: test_attributes::tests::test_ignore::{impl FnOnce<()> for test_attributes::tests::test_ignore::closure}::call_once +fn {impl FnOnce<()> for test_attributes::tests::test_ignore::closure}::call_once(_1: test_attributes::tests::test_ignore::closure, _2: ()) -> Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}] +{ + let _0: Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}]; // return + let _1: test_attributes::tests::test_ignore::closure; // arg #1 + let _2: (); // arg #2 + let _3: &'1 mut test_attributes::tests::test_ignore::closure; // anonymous local + + storage_live(_0) + storage_live(_3) + _3 = &mut _1 + _0 = {impl FnMut<()> for test_attributes::tests::test_ignore::closure}::call_mut<'2>(move _3, move _2) + ↳⚡ drop[{impl Destruct for test_attributes::tests::test_ignore::closure}::drop_glue<'3>] _1 + ↳⚡ unwind_terminate + unwind_continue + drop[{impl Destruct for test_attributes::tests::test_ignore::closure}::drop_glue<'4>] _1 + ↳⚡ unwind_continue + return +} + +fn test_attributes::tests::test_ignore::closure::as_fn() -> Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}] +{ + let _0: Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}]; // return + let args: (); // local + let state: test_attributes::tests::test_ignore::closure; // local + + storage_live(_0) + storage_live(args) + storage_live(state) + args = () + state = test_attributes::tests::test_ignore::closure { } + _0 = {impl FnOnce<()> for test_attributes::tests::test_ignore::closure}::call_once(move state, move args) + ↳⚡ unwind_continue + return +} + +pub fn test_attributes::tests::test_ignore() -> TestDescAndFn +{ + let _0: TestDescAndFn; // return + let _1: TestDesc; // anonymous local + let _2: TestName; // anonymous local + let _3: Option<&'6 str>[{built_in impl Sized for &'6 str}]; // anonymous local + let _4: ShouldPanic; // anonymous local + let _5: TestType; // anonymous local + let _6: TestFn; // anonymous local + let _7: fn() -> Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}]; // anonymous local + let _8: test_attributes::tests::test_ignore::closure; // anonymous local + + storage_live(_0) + storage_live(_1) + storage_live(_2) + _2 = TestName::StaticTestName { _0: const "tests::test_ignore" } + storage_live(_3) + _3 = Option::None { } + storage_live(_4) + _4 = ShouldPanic::No { } + storage_live(_5) + _5 = TestType::UnitTest { } + _1 = TestDesc { name: move _2, ignore: const true, ignore_message: move _3, source_file: const "src/lib.rs", start_line: const 18usize, start_col: const 8usize, end_line: const 18usize, end_col: const 19usize, should_panic: move _4, compile_fail: const false, no_run: const false, test_type: move _5 } + storage_dead(_5) + storage_dead(_4) + storage_dead(_3) + conditional_drop[impl_Destruct_for_TestName::drop_glue<'16>] _2 + ↳⚡ conditional_drop[impl_Destruct_for_TestDesc::drop_glue<'18>] _1 + ↳⚡ unwind_terminate + unwind_continue + storage_dead(_2) + storage_live(_6) + storage_live(_7) + storage_live(_8) + _8 = test_attributes::tests::test_ignore::closure { } + _7 = cast Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}]>(const test_attributes::tests::test_ignore::closure::as_fn) + storage_dead(_8) + _6 = TestFn::StaticTestFn { _0: move _7 } + storage_dead(_7) + _0 = TestDescAndFn { desc: move _1, testfn: move _6 } + conditional_drop[impl_Destruct_for_TestFn::drop_glue<'17>] _6 + ↳⚡ conditional_drop[impl_Destruct_for_TestDesc::drop_glue<'18>] _1 + ↳⚡ unwind_terminate + unwind_continue + storage_dead(_6) + conditional_drop[impl_Destruct_for_TestDesc::drop_glue<'19>] _1 + ↳⚡ unwind_continue + storage_dead(_1) + return +} + +pub const test_attributes::tests::test_ignore: TestDescAndFn = test_attributes::tests::test_ignore() + +struct test_attributes::tests::test_should_panic::closure {} + +// Full name: test_attributes::tests::test_should_panic::closure::{impl Destruct for test_attributes::tests::test_should_panic::closure}::drop_glue +unsafe fn {impl Destruct for test_attributes::tests::test_should_panic::closure}::drop_glue<'_0>(_1: &'_0 mut test_attributes::tests::test_should_panic::closure) +{ + let _0: (); // return + let _1: &'1 mut test_attributes::tests::test_should_panic::closure; // arg #1 + + storage_live(_0) + _0 = () + return +} + +#[should_panic] +#[rustc_test_entrypoint_marker] +fn test_attributes::tests::test_should_panic#1() +{ + let _0: (); // return + let _1: Arguments<'1>; // anonymous local + + storage_live(_0) + _0 = () + storage_live(_1) + _1 = from_str<'2>(const "This test should panic") + ↳⚡ unwind_continue + panic(core::panicking::panic_fmt) +} + +// Full name: test_attributes::tests::test_should_panic::{impl Fn<()> for test_attributes::tests::test_should_panic::closure}::call +fn {impl Fn<()> for test_attributes::tests::test_should_panic::closure}::call<'_0>(_1: &'_0 test_attributes::tests::test_should_panic::closure, tupled_args: ()) -> Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}] +{ + let _0: Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}]; // return + let _1: &'1 test_attributes::tests::test_should_panic::closure; // arg #1 + let tupled_args: (); // arg #2 + let _3: (); // anonymous local + + storage_live(_0) + storage_live(_3) + _3 = test_attributes::tests::test_should_panic#1() + ↳⚡ unwind_continue + _0 = assert_test_result<()>[{built_in impl Sized for ()}, impl_Termination_for_unit](move _3) + ↳⚡ unwind_continue + storage_dead(_3) + return +} + +// Full name: test_attributes::tests::test_should_panic::{impl FnMut<()> for test_attributes::tests::test_should_panic::closure}::call_mut +fn {impl FnMut<()> for test_attributes::tests::test_should_panic::closure}::call_mut<'_0>(state: &'_0 mut test_attributes::tests::test_should_panic::closure, args: ()) -> Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}] +{ + let _0: Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}]; // return + let state: &'_0 mut test_attributes::tests::test_should_panic::closure; // arg #1 + let args: (); // arg #2 + let _3: &'0 test_attributes::tests::test_should_panic::closure; // anonymous local + + storage_live(_0) + storage_live(_3) + _3 = &(*state) + _0 = {impl Fn<()> for test_attributes::tests::test_should_panic::closure}::call<'2>(move _3, move args) + ↳⚡ unwind_continue + return +} + +// Full name: test_attributes::tests::test_should_panic::{impl FnOnce<()> for test_attributes::tests::test_should_panic::closure}::call_once +fn {impl FnOnce<()> for test_attributes::tests::test_should_panic::closure}::call_once(_1: test_attributes::tests::test_should_panic::closure, _2: ()) -> Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}] +{ + let _0: Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}]; // return + let _1: test_attributes::tests::test_should_panic::closure; // arg #1 + let _2: (); // arg #2 + let _3: &'1 mut test_attributes::tests::test_should_panic::closure; // anonymous local + + storage_live(_0) + storage_live(_3) + _3 = &mut _1 + _0 = {impl FnMut<()> for test_attributes::tests::test_should_panic::closure}::call_mut<'2>(move _3, move _2) + ↳⚡ drop[{impl Destruct for test_attributes::tests::test_should_panic::closure}::drop_glue<'3>] _1 + ↳⚡ unwind_terminate + unwind_continue + drop[{impl Destruct for test_attributes::tests::test_should_panic::closure}::drop_glue<'4>] _1 + ↳⚡ unwind_continue + return +} + +fn test_attributes::tests::test_should_panic::closure::as_fn() -> Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}] +{ + let _0: Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}]; // return + let args: (); // local + let state: test_attributes::tests::test_should_panic::closure; // local + + storage_live(_0) + storage_live(args) + storage_live(state) + args = () + state = test_attributes::tests::test_should_panic::closure { } + _0 = {impl FnOnce<()> for test_attributes::tests::test_should_panic::closure}::call_once(move state, move args) + ↳⚡ unwind_continue + return +} + +pub fn test_attributes::tests::test_should_panic() -> TestDescAndFn +{ + let _0: TestDescAndFn; // return + let _1: TestDesc; // anonymous local + let _2: TestName; // anonymous local + let _3: Option<&'6 str>[{built_in impl Sized for &'6 str}]; // anonymous local + let _4: ShouldPanic; // anonymous local + let _5: TestType; // anonymous local + let _6: TestFn; // anonymous local + let _7: fn() -> Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}]; // anonymous local + let _8: test_attributes::tests::test_should_panic::closure; // anonymous local + + storage_live(_0) + storage_live(_1) + storage_live(_2) + _2 = TestName::StaticTestName { _0: const "tests::test_should_panic" } + storage_live(_3) + _3 = Option::None { } + storage_live(_4) + _4 = ShouldPanic::Yes { } + storage_live(_5) + _5 = TestType::UnitTest { } + _1 = TestDesc { name: move _2, ignore: const false, ignore_message: move _3, source_file: const "src/lib.rs", start_line: const 12usize, start_col: const 8usize, end_line: const 12usize, end_col: const 25usize, should_panic: move _4, compile_fail: const false, no_run: const false, test_type: move _5 } + storage_dead(_5) + storage_dead(_4) + storage_dead(_3) + conditional_drop[impl_Destruct_for_TestName::drop_glue<'16>] _2 + ↳⚡ conditional_drop[impl_Destruct_for_TestDesc::drop_glue<'18>] _1 + ↳⚡ unwind_terminate + unwind_continue + storage_dead(_2) + storage_live(_6) + storage_live(_7) + storage_live(_8) + _8 = test_attributes::tests::test_should_panic::closure { } + _7 = cast Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}]>(const test_attributes::tests::test_should_panic::closure::as_fn) + storage_dead(_8) + _6 = TestFn::StaticTestFn { _0: move _7 } + storage_dead(_7) + _0 = TestDescAndFn { desc: move _1, testfn: move _6 } + conditional_drop[impl_Destruct_for_TestFn::drop_glue<'17>] _6 + ↳⚡ conditional_drop[impl_Destruct_for_TestDesc::drop_glue<'18>] _1 + ↳⚡ unwind_terminate + unwind_continue + storage_dead(_6) + conditional_drop[impl_Destruct_for_TestDesc::drop_glue<'19>] _1 + ↳⚡ unwind_continue + storage_dead(_1) + return +} + +pub const test_attributes::tests::test_should_panic: TestDescAndFn = test_attributes::tests::test_should_panic() + +struct test_attributes::tests::test_foo::closure {} + +// Full name: test_attributes::tests::test_foo::closure::{impl Destruct for test_attributes::tests::test_foo::closure}::drop_glue +unsafe fn {impl Destruct for test_attributes::tests::test_foo::closure}::drop_glue<'_0>(_1: &'_0 mut test_attributes::tests::test_foo::closure) +{ + let _0: (); // return + let _1: &'1 mut test_attributes::tests::test_foo::closure; // arg #1 + + storage_live(_0) + _0 = () + return +} + +#[rustc_test_entrypoint_marker] +fn test_attributes::tests::test_foo#1() +{ + let _0: (); // return + let _1: (); // anonymous local + + storage_live(_0) + _0 = () + storage_live(_1) + _1 = foo() + ↳⚡ unwind_continue + storage_dead(_1) + _0 = () + return +} + +// Full name: test_attributes::tests::test_foo::{impl Fn<()> for test_attributes::tests::test_foo::closure}::call +fn {impl Fn<()> for test_attributes::tests::test_foo::closure}::call<'_0>(_1: &'_0 test_attributes::tests::test_foo::closure, tupled_args: ()) -> Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}] +{ + let _0: Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}]; // return + let _1: &'1 test_attributes::tests::test_foo::closure; // arg #1 + let tupled_args: (); // arg #2 + let _3: (); // anonymous local + + storage_live(_0) + storage_live(_3) + _3 = test_attributes::tests::test_foo#1() + ↳⚡ unwind_continue + _0 = assert_test_result<()>[{built_in impl Sized for ()}, impl_Termination_for_unit](move _3) + ↳⚡ unwind_continue + storage_dead(_3) + return +} + +// Full name: test_attributes::tests::test_foo::{impl FnMut<()> for test_attributes::tests::test_foo::closure}::call_mut +fn {impl FnMut<()> for test_attributes::tests::test_foo::closure}::call_mut<'_0>(state: &'_0 mut test_attributes::tests::test_foo::closure, args: ()) -> Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}] +{ + let _0: Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}]; // return + let state: &'_0 mut test_attributes::tests::test_foo::closure; // arg #1 + let args: (); // arg #2 + let _3: &'0 test_attributes::tests::test_foo::closure; // anonymous local + + storage_live(_0) + storage_live(_3) + _3 = &(*state) + _0 = {impl Fn<()> for test_attributes::tests::test_foo::closure}::call<'2>(move _3, move args) + ↳⚡ unwind_continue + return +} + +// Full name: test_attributes::tests::test_foo::{impl FnOnce<()> for test_attributes::tests::test_foo::closure}::call_once +fn {impl FnOnce<()> for test_attributes::tests::test_foo::closure}::call_once(_1: test_attributes::tests::test_foo::closure, _2: ()) -> Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}] +{ + let _0: Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}]; // return + let _1: test_attributes::tests::test_foo::closure; // arg #1 + let _2: (); // arg #2 + let _3: &'1 mut test_attributes::tests::test_foo::closure; // anonymous local + + storage_live(_0) + storage_live(_3) + _3 = &mut _1 + _0 = {impl FnMut<()> for test_attributes::tests::test_foo::closure}::call_mut<'2>(move _3, move _2) + ↳⚡ drop[{impl Destruct for test_attributes::tests::test_foo::closure}::drop_glue<'3>] _1 + ↳⚡ unwind_terminate + unwind_continue + drop[{impl Destruct for test_attributes::tests::test_foo::closure}::drop_glue<'4>] _1 + ↳⚡ unwind_continue + return +} + +fn test_attributes::tests::test_foo::closure::as_fn() -> Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}] +{ + let _0: Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}]; // return + let args: (); // local + let state: test_attributes::tests::test_foo::closure; // local + + storage_live(_0) + storage_live(args) + storage_live(state) + args = () + state = test_attributes::tests::test_foo::closure { } + _0 = {impl FnOnce<()> for test_attributes::tests::test_foo::closure}::call_once(move state, move args) + ↳⚡ unwind_continue + return +} + +pub fn test_attributes::tests::test_foo() -> TestDescAndFn +{ + let _0: TestDescAndFn; // return + let _1: TestDesc; // anonymous local + let _2: TestName; // anonymous local + let _3: Option<&'6 str>[{built_in impl Sized for &'6 str}]; // anonymous local + let _4: ShouldPanic; // anonymous local + let _5: TestType; // anonymous local + let _6: TestFn; // anonymous local + let _7: fn() -> Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}]; // anonymous local + let _8: test_attributes::tests::test_foo::closure; // anonymous local + + storage_live(_0) + storage_live(_1) + storage_live(_2) + _2 = TestName::StaticTestName { _0: const "tests::test_foo" } + storage_live(_3) + _3 = Option::None { } + storage_live(_4) + _4 = ShouldPanic::No { } + storage_live(_5) + _5 = TestType::UnitTest { } + _1 = TestDesc { name: move _2, ignore: const false, ignore_message: move _3, source_file: const "src/lib.rs", start_line: const 6usize, start_col: const 8usize, end_line: const 6usize, end_col: const 16usize, should_panic: move _4, compile_fail: const false, no_run: const false, test_type: move _5 } + storage_dead(_5) + storage_dead(_4) + storage_dead(_3) + conditional_drop[impl_Destruct_for_TestName::drop_glue<'16>] _2 + ↳⚡ conditional_drop[impl_Destruct_for_TestDesc::drop_glue<'18>] _1 + ↳⚡ unwind_terminate + unwind_continue + storage_dead(_2) + storage_live(_6) + storage_live(_7) + storage_live(_8) + _8 = test_attributes::tests::test_foo::closure { } + _7 = cast Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}]>(const test_attributes::tests::test_foo::closure::as_fn) + storage_dead(_8) + _6 = TestFn::StaticTestFn { _0: move _7 } + storage_dead(_7) + _0 = TestDescAndFn { desc: move _1, testfn: move _6 } + conditional_drop[impl_Destruct_for_TestFn::drop_glue<'17>] _6 + ↳⚡ conditional_drop[impl_Destruct_for_TestDesc::drop_glue<'18>] _1 + ↳⚡ unwind_terminate + unwind_continue + storage_dead(_6) + conditional_drop[impl_Destruct_for_TestDesc::drop_glue<'19>] _1 + ↳⚡ unwind_continue + storage_dead(_1) + return +} + +pub const test_attributes::tests::test_foo: TestDescAndFn = test_attributes::tests::test_foo() + +// Full name: test_attributes::main +pub fn main() +{ + let _0: (); // return + let _1: &'4 [&'5 TestDescAndFn]; // anonymous local + let _2: &'9 [&'10 TestDescAndFn; 3usize]; // anonymous local + let _3: &'11 [&'12 TestDescAndFn; 3usize]; // anonymous local + let _4: &'20 [&'21 TestDescAndFn; 3usize]; // anonymous local + let _5: &'22 [&'23 TestDescAndFn; 3usize]; // anonymous local + let _6: &'32 [&'33 TestDescAndFn; 3usize]; // anonymous local + let _7: [&'34 TestDescAndFn; 3usize]; // anonymous local + let _8: &'35 TestDescAndFn; // anonymous local + let _9: &'36 TestDescAndFn; // anonymous local + let _10: TestDescAndFn; // anonymous local + let _11: &'37 TestDescAndFn; // anonymous local + let _12: &'38 TestDescAndFn; // anonymous local + let _13: TestDescAndFn; // anonymous local + let _14: &'39 TestDescAndFn; // anonymous local + let _15: &'40 TestDescAndFn; // anonymous local + let _16: TestDescAndFn; // anonymous local + + storage_live(_5) + storage_live(_6) + storage_live(_7) + storage_live(_8) + storage_live(_9) + storage_live(_10) + storage_live(_11) + storage_live(_12) + storage_live(_13) + storage_live(_14) + storage_live(_15) + storage_live(_16) + _10 = copy test_attributes::tests::test_foo + _9 = &_10 + _8 = &(*_9) + _13 = copy test_attributes::tests::test_ignore + _12 = &_13 + _11 = &(*_12) + _16 = copy test_attributes::tests::test_should_panic + _15 = &_16 + _14 = &(*_15) + _7 = [move _8, move _11, move _14] + _6 = &_7 + _5 = move _6 + storage_live(_0) + storage_live(_4) + _0 = () + storage_live(_1) + storage_live(_2) + storage_live(_3) + _4 = move _5 + _3 = &(*_4) + _2 = &(*_3) + _1 = unsize_cast<&'9 [&'10 TestDescAndFn; 3usize], &'26 [&'27 TestDescAndFn], 3usize>(move _2) + storage_dead(_2) + _0 = test_main_static<'30, '31>(move _1) + ↳⚡ unwind_continue + storage_dead(_1) + storage_dead(_3) + return +} + +// Full name: test_attributes::tests::test_foo::{impl FnOnce<()> for test_attributes::tests::test_foo::closure} +impl FnOnce<()> for test_attributes::tests::test_foo::closure { + proof ImpliedClause0: (test_attributes::tests::test_foo::closure: MetaSized) = {built_in impl MetaSized for test_attributes::tests::test_foo::closure} + proof ImpliedClause1: ((): Sized) = {built_in impl Sized for ()} + proof ImpliedClause2: ((): Tuple) = {built_in impl Tuple for ()} + proof ImpliedClause3: (Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}]: Sized) = {built_in impl Sized for Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}]} + type Output = Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}] + fn call_once = {impl FnOnce<()> for test_attributes::tests::test_foo::closure}::call_once + non-dyn-compatible +} + +// Full name: test_attributes::tests::test_foo::{impl FnMut<()> for test_attributes::tests::test_foo::closure} +impl FnMut<()> for test_attributes::tests::test_foo::closure { + proof ImpliedClause0: (test_attributes::tests::test_foo::closure: MetaSized) = {built_in impl MetaSized for test_attributes::tests::test_foo::closure} + proof ImpliedClause1: (test_attributes::tests::test_foo::closure: FnOnce<()>) = {impl FnOnce<()> for test_attributes::tests::test_foo::closure} + proof ImpliedClause2: ((): Sized) = {built_in impl Sized for ()} + proof ImpliedClause3: ((): Tuple) = {built_in impl Tuple for ()} + fn call_mut<'_0_1> = {impl FnMut<()> for test_attributes::tests::test_foo::closure}::call_mut<'_0_1> + non-dyn-compatible +} + +// Full name: test_attributes::tests::test_foo::{impl Fn<()> for test_attributes::tests::test_foo::closure} +impl Fn<()> for test_attributes::tests::test_foo::closure { + proof ImpliedClause0: (test_attributes::tests::test_foo::closure: MetaSized) = {built_in impl MetaSized for test_attributes::tests::test_foo::closure} + proof ImpliedClause1: (test_attributes::tests::test_foo::closure: FnMut<()>) = {impl FnMut<()> for test_attributes::tests::test_foo::closure} + proof ImpliedClause2: ((): Sized) = {built_in impl Sized for ()} + proof ImpliedClause3: ((): Tuple) = {built_in impl Tuple for ()} + fn call<'_0_1> = {impl Fn<()> for test_attributes::tests::test_foo::closure}::call<'_0_1> + non-dyn-compatible +} + +// Full name: test_attributes::tests::test_foo::closure::{impl Destruct for test_attributes::tests::test_foo::closure} +impl Destruct for test_attributes::tests::test_foo::closure { + fn drop_glue<'_0_1> = {impl Destruct for test_attributes::tests::test_foo::closure}::drop_glue<'_0_1> + non-dyn-compatible +} + +// Full name: test_attributes::tests::test_should_panic::{impl FnOnce<()> for test_attributes::tests::test_should_panic::closure} +impl FnOnce<()> for test_attributes::tests::test_should_panic::closure { + proof ImpliedClause0: (test_attributes::tests::test_should_panic::closure: MetaSized) = {built_in impl MetaSized for test_attributes::tests::test_should_panic::closure} + proof ImpliedClause1: ((): Sized) = {built_in impl Sized for ()} + proof ImpliedClause2: ((): Tuple) = {built_in impl Tuple for ()} + proof ImpliedClause3: (Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}]: Sized) = {built_in impl Sized for Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}]} + type Output = Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}] + fn call_once = {impl FnOnce<()> for test_attributes::tests::test_should_panic::closure}::call_once + non-dyn-compatible +} + +// Full name: test_attributes::tests::test_should_panic::{impl FnMut<()> for test_attributes::tests::test_should_panic::closure} +impl FnMut<()> for test_attributes::tests::test_should_panic::closure { + proof ImpliedClause0: (test_attributes::tests::test_should_panic::closure: MetaSized) = {built_in impl MetaSized for test_attributes::tests::test_should_panic::closure} + proof ImpliedClause1: (test_attributes::tests::test_should_panic::closure: FnOnce<()>) = {impl FnOnce<()> for test_attributes::tests::test_should_panic::closure} + proof ImpliedClause2: ((): Sized) = {built_in impl Sized for ()} + proof ImpliedClause3: ((): Tuple) = {built_in impl Tuple for ()} + fn call_mut<'_0_1> = {impl FnMut<()> for test_attributes::tests::test_should_panic::closure}::call_mut<'_0_1> + non-dyn-compatible +} + +// Full name: test_attributes::tests::test_should_panic::{impl Fn<()> for test_attributes::tests::test_should_panic::closure} +impl Fn<()> for test_attributes::tests::test_should_panic::closure { + proof ImpliedClause0: (test_attributes::tests::test_should_panic::closure: MetaSized) = {built_in impl MetaSized for test_attributes::tests::test_should_panic::closure} + proof ImpliedClause1: (test_attributes::tests::test_should_panic::closure: FnMut<()>) = {impl FnMut<()> for test_attributes::tests::test_should_panic::closure} + proof ImpliedClause2: ((): Sized) = {built_in impl Sized for ()} + proof ImpliedClause3: ((): Tuple) = {built_in impl Tuple for ()} + fn call<'_0_1> = {impl Fn<()> for test_attributes::tests::test_should_panic::closure}::call<'_0_1> + non-dyn-compatible +} + +// Full name: test_attributes::tests::test_should_panic::closure::{impl Destruct for test_attributes::tests::test_should_panic::closure} +impl Destruct for test_attributes::tests::test_should_panic::closure { + fn drop_glue<'_0_1> = {impl Destruct for test_attributes::tests::test_should_panic::closure}::drop_glue<'_0_1> + non-dyn-compatible +} + +// Full name: test_attributes::tests::test_ignore::{impl FnOnce<()> for test_attributes::tests::test_ignore::closure} +impl FnOnce<()> for test_attributes::tests::test_ignore::closure { + proof ImpliedClause0: (test_attributes::tests::test_ignore::closure: MetaSized) = {built_in impl MetaSized for test_attributes::tests::test_ignore::closure} + proof ImpliedClause1: ((): Sized) = {built_in impl Sized for ()} + proof ImpliedClause2: ((): Tuple) = {built_in impl Tuple for ()} + proof ImpliedClause3: (Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}]: Sized) = {built_in impl Sized for Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}]} + type Output = Result<(), String>[{built_in impl Sized for ()}, {built_in impl Sized for String}] + fn call_once = {impl FnOnce<()> for test_attributes::tests::test_ignore::closure}::call_once + non-dyn-compatible +} + +// Full name: test_attributes::tests::test_ignore::{impl FnMut<()> for test_attributes::tests::test_ignore::closure} +impl FnMut<()> for test_attributes::tests::test_ignore::closure { + proof ImpliedClause0: (test_attributes::tests::test_ignore::closure: MetaSized) = {built_in impl MetaSized for test_attributes::tests::test_ignore::closure} + proof ImpliedClause1: (test_attributes::tests::test_ignore::closure: FnOnce<()>) = {impl FnOnce<()> for test_attributes::tests::test_ignore::closure} + proof ImpliedClause2: ((): Sized) = {built_in impl Sized for ()} + proof ImpliedClause3: ((): Tuple) = {built_in impl Tuple for ()} + fn call_mut<'_0_1> = {impl FnMut<()> for test_attributes::tests::test_ignore::closure}::call_mut<'_0_1> + non-dyn-compatible +} + +// Full name: test_attributes::tests::test_ignore::{impl Fn<()> for test_attributes::tests::test_ignore::closure} +impl Fn<()> for test_attributes::tests::test_ignore::closure { + proof ImpliedClause0: (test_attributes::tests::test_ignore::closure: MetaSized) = {built_in impl MetaSized for test_attributes::tests::test_ignore::closure} + proof ImpliedClause1: (test_attributes::tests::test_ignore::closure: FnMut<()>) = {impl FnMut<()> for test_attributes::tests::test_ignore::closure} + proof ImpliedClause2: ((): Sized) = {built_in impl Sized for ()} + proof ImpliedClause3: ((): Tuple) = {built_in impl Tuple for ()} + fn call<'_0_1> = {impl Fn<()> for test_attributes::tests::test_ignore::closure}::call<'_0_1> + non-dyn-compatible +} + +// Full name: test_attributes::tests::test_ignore::closure::{impl Destruct for test_attributes::tests::test_ignore::closure} +impl Destruct for test_attributes::tests::test_ignore::closure { + fn drop_glue<'_0_1> = {impl Destruct for test_attributes::tests::test_ignore::closure}::drop_glue<'_0_1> + non-dyn-compatible +} + + + diff --git a/charon/tests/cargo/test-attributes/Cargo.lock b/charon/tests/cargo/test-attributes/Cargo.lock new file mode 100644 index 000000000..a2b5a1116 --- /dev/null +++ b/charon/tests/cargo/test-attributes/Cargo.lock @@ -0,0 +1,7 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "test-attributes" +version = "0.1.0" diff --git a/charon/tests/cargo/test-attributes/Cargo.toml b/charon/tests/cargo/test-attributes/Cargo.toml new file mode 100644 index 000000000..492e70bab --- /dev/null +++ b/charon/tests/cargo/test-attributes/Cargo.toml @@ -0,0 +1,6 @@ +[workspace] + +[package] +name = "test-attributes" +version = "0.1.0" +edition = "2021" diff --git a/charon/tests/cargo/test-attributes/src/lib.rs b/charon/tests/cargo/test-attributes/src/lib.rs new file mode 100644 index 000000000..958d6b2c3 --- /dev/null +++ b/charon/tests/cargo/test-attributes/src/lib.rs @@ -0,0 +1,19 @@ +fn foo() {} + +#[cfg(test)] +mod tests { + #[test] + fn test_foo() { + super::foo(); + } + + #[test] + #[should_panic] + fn test_should_panic() { + panic!("This test should panic"); + } + + #[test] + #[ignore] + fn test_ignore() {} +} diff --git a/charon/tests/cargo/toml.out b/charon/tests/cargo/toml.out index 37fb9e624..f82c30d5e 100644 --- a/charon/tests/cargo/toml.out +++ b/charon/tests/cargo/toml.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/advanced-const-generics.out b/charon/tests/ui/advanced-const-generics.out index 6fce19753..20da24f3a 100644 --- a/charon/tests/ui/advanced-const-generics.out +++ b/charon/tests/ui/advanced-const-generics.out @@ -25,10 +25,12 @@ where = // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -72,6 +74,7 @@ enum Foo { } // Full name: test_crate::{impl Eq for Foo}::assert_fields_are_eq +#[inline(hint)] pub fn impl_Eq_for_Foo::assert_fields_are_eq<'_0>(self: &'_0 Foo) { let _0: (); // return @@ -85,6 +88,7 @@ pub fn impl_Eq_for_Foo::assert_fields_are_eq<'_0>(self: &'_0 Foo) } // Full name: test_crate::{impl PartialEq for Foo}::eq +#[inline(hint)] pub fn eq<'_0, '_1>(self: &'_0 Foo, other: &'_1 Foo) -> bool { let _0: bool; // return @@ -152,6 +156,7 @@ impl "impl_ConstParamTy__for_Foo" ConstParamTy_ for Foo { } // Full name: test_crate::{impl Debug for Foo}::fmt +#[inline(hint)] pub fn fmt<'_0, '_1, '_2>(self: &'_0 Foo, f: &'_1 mut Formatter<'_2>) -> Result<(), Error>[{built_in impl Sized for ()}, {built_in impl Sized for Error}] where RegionOutlives0: '_2: '_1, diff --git a/charon/tests/ui/arrays.out b/charon/tests/ui/arrays.out index 96298c4a1..fa182756b 100644 --- a/charon/tests/ui/arrays.out +++ b/charon/tests/ui/arrays.out @@ -1,6 +1,7 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized @@ -16,6 +17,7 @@ pub trait Index } // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -184,12 +186,14 @@ where = // Full name: core::slice::index::{impl SliceIndex<[T], [T]> for Range[{built_in impl Sized for usize}]}::get_unchecked_mut +#[track_caller] pub unsafe fn get_unchecked_mut(_1: Range[{built_in impl Sized for usize}], _2: *mut [T]) -> *mut [T] where TraitClause0: (T: Sized), = // Full name: core::slice::index::{impl SliceIndex<[T], [T]> for Range[{built_in impl Sized for usize}]}::get_unchecked +#[track_caller] pub unsafe fn get_unchecked(_1: Range[{built_in impl Sized for usize}], _2: *const [T]) -> *const [T] where TraitClause0: (T: Sized), diff --git a/charon/tests/ui/assoc-const-with-generics.out b/charon/tests/ui/assoc-const-with-generics.out index 6da3521a7..fbe82cf31 100644 --- a/charon/tests/ui/assoc-const-with-generics.out +++ b/charon/tests/ui/assoc-const-with-generics.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/associated_types/assoc-constraint-on-assoc-ty-nested.out b/charon/tests/ui/associated_types/assoc-constraint-on-assoc-ty-nested.out index 138d1b2d0..f7396e280 100644 --- a/charon/tests/ui/associated_types/assoc-constraint-on-assoc-ty-nested.out +++ b/charon/tests/ui/associated_types/assoc-constraint-on-assoc-ty-nested.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/associated_types/assoc-constraint-on-assoc-ty.2.out b/charon/tests/ui/associated_types/assoc-constraint-on-assoc-ty.2.out index d795aef17..53f7a00d9 100644 --- a/charon/tests/ui/associated_types/assoc-constraint-on-assoc-ty.2.out +++ b/charon/tests/ui/associated_types/assoc-constraint-on-assoc-ty.2.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/associated_types/assoc-constraint-on-assoc-ty.out b/charon/tests/ui/associated_types/assoc-constraint-on-assoc-ty.out index 55f3b9704..9e62b735a 100644 --- a/charon/tests/ui/associated_types/assoc-constraint-on-assoc-ty.out +++ b/charon/tests/ui/associated_types/assoc-constraint-on-assoc-ty.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/associated_types/assoc-ty-bound-refers-to-assoc-ty.out b/charon/tests/ui/associated_types/assoc-ty-bound-refers-to-assoc-ty.out index b7e53d0f9..46b62a732 100644 --- a/charon/tests/ui/associated_types/assoc-ty-bound-refers-to-assoc-ty.out +++ b/charon/tests/ui/associated_types/assoc-ty-bound-refers-to-assoc-ty.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/associated_types/assoc-ty-default-with-self-bound.out b/charon/tests/ui/associated_types/assoc-ty-default-with-self-bound.out index d9f6550fd..b0af802e5 100644 --- a/charon/tests/ui/associated_types/assoc-ty-default-with-self-bound.out +++ b/charon/tests/ui/associated_types/assoc-ty-default-with-self-bound.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/associated_types/assoc-ty-via-supertrait-and-bounds.out b/charon/tests/ui/associated_types/assoc-ty-via-supertrait-and-bounds.out index 77274bf44..b170873e4 100644 --- a/charon/tests/ui/associated_types/assoc-ty-via-supertrait-and-bounds.out +++ b/charon/tests/ui/associated_types/assoc-ty-via-supertrait-and-bounds.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/associated_types/assoc-type-with-fn-bound.out b/charon/tests/ui/associated_types/assoc-type-with-fn-bound.out index d2c8e11f2..ca3e731b9 100644 --- a/charon/tests/ui/associated_types/assoc-type-with-fn-bound.out +++ b/charon/tests/ui/associated_types/assoc-type-with-fn-bound.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -13,6 +15,7 @@ pub trait Sized } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -21,6 +24,7 @@ pub trait Tuple } // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { @@ -33,6 +37,7 @@ pub trait FnOnce } // Full name: core::ops::function::FnMut +#[fundamental] #[lang_item(FnMut)] pub trait FnMut { @@ -45,6 +50,7 @@ pub trait FnMut } // Full name: core::ops::function::Fn +#[fundamental] #[lang_item(Fn)] pub trait Fn { diff --git a/charon/tests/ui/associated_types/associated-types.out b/charon/tests/ui/associated_types/associated-types.out index a2054e1e8..3437d52be 100644 --- a/charon/tests/ui/associated_types/associated-types.out +++ b/charon/tests/ui/associated_types/associated-types.out @@ -1,6 +1,7 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized @@ -15,6 +16,7 @@ pub trait Borrow } // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/associated_types/closure-inside-impl-with-bound-with-assoc-ty.out b/charon/tests/ui/associated_types/closure-inside-impl-with-bound-with-assoc-ty.out index 94eee9377..bf449a534 100644 --- a/charon/tests/ui/associated_types/closure-inside-impl-with-bound-with-assoc-ty.out +++ b/charon/tests/ui/associated_types/closure-inside-impl-with-bound-with-assoc-ty.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -21,6 +23,7 @@ pub trait Destruct } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -29,6 +32,7 @@ pub trait Tuple } // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { @@ -41,6 +45,7 @@ pub trait FnOnce } // Full name: core::ops::function::FnMut +#[fundamental] #[lang_item(FnMut)] pub trait FnMut { @@ -53,6 +58,7 @@ pub trait FnMut } // Full name: core::ops::function::Fn +#[fundamental] #[lang_item(Fn)] pub trait Fn { diff --git a/charon/tests/ui/associated_types/dictionary_passing_style_woes.out b/charon/tests/ui/associated_types/dictionary_passing_style_woes.out index e0c45042d..e3b6371e7 100644 --- a/charon/tests/ui/associated_types/dictionary_passing_style_woes.out +++ b/charon/tests/ui/associated_types/dictionary_passing_style_woes.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/associated_types/gat-used-in-method.out b/charon/tests/ui/associated_types/gat-used-in-method.out index 28f1a0932..52bb30c19 100644 --- a/charon/tests/ui/associated_types/gat-used-in-method.out +++ b/charon/tests/ui/associated_types/gat-used-in-method.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/associated_types/generic-impl-with-defaulted-method-with-clause-with-assoc-ty.out b/charon/tests/ui/associated_types/generic-impl-with-defaulted-method-with-clause-with-assoc-ty.out index eeea40f60..b7a671253 100644 --- a/charon/tests/ui/associated_types/generic-impl-with-defaulted-method-with-clause-with-assoc-ty.out +++ b/charon/tests/ui/associated_types/generic-impl-with-defaulted-method-with-clause-with-assoc-ty.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/associated_types/impl-with-dyn-assoc-ty.out b/charon/tests/ui/associated_types/impl-with-dyn-assoc-ty.out index 4f2e8d470..b5f3dde7e 100644 --- a/charon/tests/ui/associated_types/impl-with-dyn-assoc-ty.out +++ b/charon/tests/ui/associated_types/impl-with-dyn-assoc-ty.out @@ -3,10 +3,12 @@ opaque type core::marker::MetaSized::{vtable} // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/associated_types/issue-1036-failed-assoc-ty-lifting.out b/charon/tests/ui/associated_types/issue-1036-failed-assoc-ty-lifting.out index 787239094..7fbfd9316 100644 --- a/charon/tests/ui/associated_types/issue-1036-failed-assoc-ty-lifting.out +++ b/charon/tests/ui/associated_types/issue-1036-failed-assoc-ty-lifting.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/associated_types/issue-1068-double-visit.out b/charon/tests/ui/associated_types/issue-1068-double-visit.out index 1c9fafc91..7ab7e8ba2 100644 --- a/charon/tests/ui/associated_types/issue-1068-double-visit.out +++ b/charon/tests/ui/associated_types/issue-1068-double-visit.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/associated_types/issue-1078-default-assoc-ty-self-ref-clause.2.out b/charon/tests/ui/associated_types/issue-1078-default-assoc-ty-self-ref-clause.2.out index 8e42602eb..9c49461c8 100644 --- a/charon/tests/ui/associated_types/issue-1078-default-assoc-ty-self-ref-clause.2.out +++ b/charon/tests/ui/associated_types/issue-1078-default-assoc-ty-self-ref-clause.2.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/associated_types/issue-1078-default-assoc-ty-self-ref-clause.out b/charon/tests/ui/associated_types/issue-1078-default-assoc-ty-self-ref-clause.out index a36fbb38c..7a2b8cce9 100644 --- a/charon/tests/ui/associated_types/issue-1078-default-assoc-ty-self-ref-clause.out +++ b/charon/tests/ui/associated_types/issue-1078-default-assoc-ty-self-ref-clause.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/associated_types/issue-1260-self-ref-assoc-const.out b/charon/tests/ui/associated_types/issue-1260-self-ref-assoc-const.out index 51137d38b..40e470424 100644 --- a/charon/tests/ui/associated_types/issue-1260-self-ref-assoc-const.out +++ b/charon/tests/ui/associated_types/issue-1260-self-ref-assoc-const.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/associated_types/issue-1326-assoc-through-supertrait.out b/charon/tests/ui/associated_types/issue-1326-assoc-through-supertrait.out index 34197cad2..76b7cd3c6 100644 --- a/charon/tests/ui/associated_types/issue-1326-assoc-through-supertrait.out +++ b/charon/tests/ui/associated_types/issue-1326-assoc-through-supertrait.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/associated_types/issue-968-default-assoc-const.out b/charon/tests/ui/associated_types/issue-968-default-assoc-const.out index edb5b4472..eac0e2793 100644 --- a/charon/tests/ui/associated_types/issue-968-default-assoc-const.out +++ b/charon/tests/ui/associated_types/issue-968-default-assoc-const.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/associated_types/iter-empty.out b/charon/tests/ui/associated_types/iter-empty.out index 34948b540..cbadd2e0c 100644 --- a/charon/tests/ui/associated_types/iter-empty.out +++ b/charon/tests/ui/associated_types/iter-empty.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/associated_types/lift-assoc-ty-in-alias.out b/charon/tests/ui/associated_types/lift-assoc-ty-in-alias.out index d3a241750..1c7ef6c4b 100644 --- a/charon/tests/ui/associated_types/lift-assoc-ty-in-alias.out +++ b/charon/tests/ui/associated_types/lift-assoc-ty-in-alias.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/associated_types/mem-discriminant-from-derive.out b/charon/tests/ui/associated_types/mem-discriminant-from-derive.out index 92c92798b..07fd30967 100644 --- a/charon/tests/ui/associated_types/mem-discriminant-from-derive.out +++ b/charon/tests/ui/associated_types/mem-discriminant-from-derive.out @@ -30,6 +30,7 @@ where = // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized @@ -54,6 +55,7 @@ impl "impl_StructuralPartialEq_for_Enum" StructuralPartialEq for Enum { } // Full name: test_crate::{impl PartialEq for Enum}::eq +#[inline(hint)] pub fn impl_PartialEq_Enum_for_Enum::eq<'_0, '_1>(self: &'_0 Enum, other: &'_1 Enum) -> bool { let _0: bool; // return diff --git a/charon/tests/ui/associated_types/method-with-assoc-type-constraint.out b/charon/tests/ui/associated_types/method-with-assoc-type-constraint.out index dc2ac4779..ecc7c234d 100644 --- a/charon/tests/ui/associated_types/method-with-assoc-type-constraint.out +++ b/charon/tests/ui/associated_types/method-with-assoc-type-constraint.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/associated_types/pointee_metadata.out b/charon/tests/ui/associated_types/pointee_metadata.out index 0831c4fab..db3b6657f 100644 --- a/charon/tests/ui/associated_types/pointee_metadata.out +++ b/charon/tests/ui/associated_types/pointee_metadata.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/associated_types/quantified-trait-type-constraint.out b/charon/tests/ui/associated_types/quantified-trait-type-constraint.out index 91fe0ef97..02202423d 100644 --- a/charon/tests/ui/associated_types/quantified-trait-type-constraint.out +++ b/charon/tests/ui/associated_types/quantified-trait-type-constraint.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/associated_types/supertrait-item-bound-has-assoc-ty.out b/charon/tests/ui/associated_types/supertrait-item-bound-has-assoc-ty.out index b9a510f1c..473eae175 100644 --- a/charon/tests/ui/associated_types/supertrait-item-bound-has-assoc-ty.out +++ b/charon/tests/ui/associated_types/supertrait-item-bound-has-assoc-ty.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/borrowck-statements.out b/charon/tests/ui/borrowck-statements.out index 2472c014e..b5fb30422 100644 --- a/charon/tests/ui/borrowck-statements.out +++ b/charon/tests/ui/borrowck-statements.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/call-to-known-trait-method.out b/charon/tests/ui/call-to-known-trait-method.out index 888b5bc16..62e8bc239 100644 --- a/charon/tests/ui/call-to-known-trait-method.out +++ b/charon/tests/ui/call-to-known-trait-method.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -93,6 +95,7 @@ where } // Full name: test_crate::{impl Default for Struct[TraitClause0]}::default +#[inline(hint)] pub fn impl_Default_for_Struct::default() -> Struct[TraitClause0] where TraitClause0: (A: Sized), diff --git a/charon/tests/ui/closure-as-fn.out b/charon/tests/ui/closure-as-fn.out index c712945d9..440e439cc 100644 --- a/charon/tests/ui/closure-as-fn.out +++ b/charon/tests/ui/closure-as-fn.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -21,6 +23,7 @@ pub trait Destruct } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -29,6 +32,7 @@ pub trait Tuple } // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { @@ -42,6 +46,7 @@ pub trait FnOnce } // Full name: core::ops::function::FnMut +#[fundamental] #[lang_item(FnMut)] pub trait FnMut { @@ -54,6 +59,7 @@ pub trait FnMut } // Full name: core::ops::function::Fn +#[fundamental] #[lang_item(Fn)] pub trait Fn { diff --git a/charon/tests/ui/closures.out b/charon/tests/ui/closures.out index c3ca8b08a..d97ff1927 100644 --- a/charon/tests/ui/closures.out +++ b/charon/tests/ui/closures.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -13,6 +15,7 @@ pub trait Tuple } // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -21,6 +24,7 @@ pub trait Sized } // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { @@ -33,6 +37,7 @@ pub trait FnOnce } // Full name: core::ops::function::FnMut +#[fundamental] #[lang_item(FnMut)] pub trait FnMut { @@ -86,6 +91,7 @@ impl "impl_Clone_for_u32" Clone for u32 { } // Full name: core::ops::function::Fn +#[fundamental] #[lang_item(Fn)] pub trait Fn { @@ -159,6 +165,7 @@ pub fn incr_u32(x: u32) -> u32 } // Full name: test_crate::map_option +#[allow(clippy::manual_map)] pub fn map_option(x_1: Option[TraitClause0], f: F) -> Option[TraitClause0] where TraitClause0: (T: Sized), @@ -287,6 +294,7 @@ where } // Full name: test_crate::map_option_pointer_ref +#[allow(clippy::manual_map, clippy::needless_lifetimes)] pub fn map_option_pointer_ref<'a, T, F>(x_1: &'a Option[TraitClause0], f: fn<'_0_1>(&'_0_1 T) -> T) -> Option[TraitClause0] where TraitClause0: (T: Sized), @@ -842,6 +850,7 @@ fn test_crate::test_closure_ref_u32::closure::as_fn<'_0>(arg1: &'_0 u32) -> &'_0 } // Full name: test_crate::test_closure_ref_u32 +#[allow(clippy::needless_lifetimes)] pub fn test_closure_ref_u32<'a>(x: &'a u32) -> &'a u32 { let _0: &'1 u32; // return @@ -1614,6 +1623,7 @@ pub fn test_map_option_id2(x: Option[{built_in impl Sized for u32}]) -> Opt } // Full name: test_crate::id_clone +#[allow(clippy::redundant_clone)] pub fn id_clone(x: T) -> T where TraitClause0: (T: Sized), diff --git a/charon/tests/ui/closures_with_where.out b/charon/tests/ui/closures_with_where.out index c301efb78..bc036555c 100644 --- a/charon/tests/ui/closures_with_where.out +++ b/charon/tests/ui/closures_with_where.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -13,6 +15,7 @@ pub trait Tuple } // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -21,6 +24,7 @@ pub trait Sized } // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { @@ -34,6 +38,7 @@ pub trait FnOnce } // Full name: core::ops::function::FnMut +#[fundamental] #[lang_item(FnMut)] pub trait FnMut { diff --git a/charon/tests/ui/comments.out b/charon/tests/ui/comments.out index 6d164d539..c822c3b28 100644 --- a/charon/tests/ui/comments.out +++ b/charon/tests/ui/comments.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -247,6 +249,7 @@ struct Foo { } // Full name: test_crate::{impl Default for Foo}::default +#[inline(hint)] pub fn impl_Default_for_Foo::default() -> Foo { let _0: Foo; // return @@ -280,6 +283,7 @@ struct Bar { } // Full name: test_crate::{impl Default for Bar}::default +#[inline(hint)] pub fn impl_Default_for_Bar::default() -> Bar { let _0: Bar; // return diff --git a/charon/tests/ui/constants.out b/charon/tests/ui/constants.out index 9ffc9ce7a..193f96891 100644 --- a/charon/tests/ui/constants.out +++ b/charon/tests/ui/constants.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -54,6 +56,7 @@ pub fn X1() -> u32 pub const X1: u32 = X1() // Full name: test_crate::X2 +#[allow(clippy::let_and_return)] pub fn X2() -> u32 { let _0: u32; // return @@ -69,6 +72,7 @@ pub fn X2() -> u32 } // Full name: test_crate::X2 +#[allow(clippy::let_and_return)] pub const X2: u32 = X2() // Full name: test_crate::incr diff --git a/charon/tests/ui/consts/evaluate-consts-mono.out b/charon/tests/ui/consts/evaluate-consts-mono.out index 7599257ad..fdca15b43 100644 --- a/charon/tests/ui/consts/evaluate-consts-mono.out +++ b/charon/tests/ui/consts/evaluate-consts-mono.out @@ -4,6 +4,7 @@ opaque type {vtable} // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized diff --git a/charon/tests/ui/consts/evaluate-consts-recursive-static.out b/charon/tests/ui/consts/evaluate-consts-recursive-static.out index d48c7ecfa..2efc5dc93 100644 --- a/charon/tests/ui/consts/evaluate-consts-recursive-static.out +++ b/charon/tests/ui/consts/evaluate-consts-recursive-static.out @@ -1,6 +1,7 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized @@ -11,6 +12,7 @@ where TraitClause0: (T: MetaSized), // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/consts/evaluate-consts.out b/charon/tests/ui/consts/evaluate-consts.out index 96e62f9ec..ebdb019d1 100644 --- a/charon/tests/ui/consts/evaluate-consts.out +++ b/charon/tests/ui/consts/evaluate-consts.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/control-flow/issue-1051-missing-loop-jump.out b/charon/tests/ui/control-flow/issue-1051-missing-loop-jump.out index 18cafebf0..92f992300 100644 --- a/charon/tests/ui/control-flow/issue-1051-missing-loop-jump.out +++ b/charon/tests/ui/control-flow/issue-1051-missing-loop-jump.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/control-flow/issue-297-cfg.out b/charon/tests/ui/control-flow/issue-297-cfg.out index e3ed29eeb..189e82d1b 100644 --- a/charon/tests/ui/control-flow/issue-297-cfg.out +++ b/charon/tests/ui/control-flow/issue-297-cfg.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -72,6 +74,7 @@ where } // Full name: core::slice::{[T]}::chunks +#[track_caller] pub fn chunks<'_0, T>(_1: &'_0 [T], _2: usize) -> Chunks<'_0, T>[TraitClause0] where TraitClause0: (T: Sized), diff --git a/charon/tests/ui/control-flow/loops.out b/charon/tests/ui/control-flow/loops.out index f9f08bf7a..f1b5c4bc4 100644 --- a/charon/tests/ui/control-flow/loops.out +++ b/charon/tests/ui/control-flow/loops.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -352,12 +354,14 @@ where = // Full name: core::slice::index::{impl SliceIndex<[T]> for usize}::get_unchecked_mut +#[track_caller] pub unsafe fn get_unchecked_mut(_1: usize, _2: *mut [T]) -> *mut T where TraitClause0: (T: Sized), = // Full name: core::slice::index::{impl SliceIndex<[T]> for usize}::get_unchecked +#[track_caller] pub unsafe fn get_unchecked(_1: usize, _2: *const [T]) -> *const T where TraitClause0: (T: Sized), @@ -691,6 +695,7 @@ pub fn test_loop3(max: u32) -> u32 } // Full name: test_crate::test_loop4 +#[allow(unused_assignments)] pub fn test_loop4(max: u32) -> u32 { let _0: u32; // return diff --git a/charon/tests/ui/control-flow/simple-fallthrough.out b/charon/tests/ui/control-flow/simple-fallthrough.out index 6b5094142..d53f8d7d6 100644 --- a/charon/tests/ui/control-flow/simple-fallthrough.out +++ b/charon/tests/ui/control-flow/simple-fallthrough.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/control-flow/ullbc-control-flow.out b/charon/tests/ui/control-flow/ullbc-control-flow.out index a32ed5cd9..0b1883280 100644 --- a/charon/tests/ui/control-flow/ullbc-control-flow.out +++ b/charon/tests/ui/control-flow/ullbc-control-flow.out @@ -1,10 +1,12 @@ # Final ULLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/copy_nonoverlapping.out b/charon/tests/ui/copy_nonoverlapping.out index 059ac7bc3..dd27ce78f 100644 --- a/charon/tests/ui/copy_nonoverlapping.out +++ b/charon/tests/ui/copy_nonoverlapping.out @@ -5,6 +5,7 @@ pub opaque type Layout // Full name: core::alloc::layout::{Layout}::from_size_align_unchecked +#[track_caller] pub unsafe fn from_size_align_unchecked(_1: usize, _2: usize) -> Layout = @@ -17,10 +18,12 @@ pub trait Destruct } // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -130,6 +133,7 @@ impl "impl_Clone_for_usize" Clone for usize { } // Full name: core::intrinsics::abort +#[rustc_intrinsic] pub fn abort() -> ! = @@ -153,6 +157,7 @@ pub struct Location<'a> { } // Full name: core::intrinsics::caller_location +#[rustc_intrinsic] pub fn caller_location() -> &'static Location<'static> = @@ -167,6 +172,7 @@ pub trait Copy } // Full name: core::intrinsics::ctpop +#[rustc_intrinsic] pub fn ctpop(x_1: T) -> u32 where TraitClause0: (T: Sized), @@ -234,6 +240,7 @@ fn core::panic::panic_info::{PanicInfo<'a>}::new<'a>(message: &'a Arguments<'a>, } // Full name: core::panic::location::{Location<'a>}::caller +#[track_caller] pub fn caller<'a>() -> &'static Location<'static> { let _0: &'3 Location<'4>; // return @@ -244,6 +251,7 @@ pub fn caller<'a>() -> &'static Location<'static> return } +#[track_caller] fn core::panicking::panic_nounwind_fmt::runtime<'_0>(fmt: Arguments<'_0>, force_no_backtrace: bool) -> ! { let _0: !; // return @@ -311,16 +319,19 @@ fn core::panicking::panic_nounwind_fmt::runtime<'_0>(fmt: Arguments<'_0>, force_ ↳⚡ undefined_behavior } +#[rustc_intrinsic] pub fn core::intrinsics::size_of() -> usize where TraitClause0: (T: Sized), = +#[rustc_intrinsic] pub fn core::intrinsics::align_of() -> usize where TraitClause0: (T: Sized), = +#[rustc_intrinsic] pub unsafe fn core::intrinsics::copy_nonoverlapping(src_1: *const T, dst_2: *mut T, count_3: usize) where TraitClause0: (T: Sized), @@ -484,6 +495,7 @@ fn check_language_ub() -> bool } // Full name: core::panicking::panic_nounwind_fmt +#[track_caller] pub fn panic_nounwind_fmt<'_0>(fmt: Arguments<'_0>, force_no_backtrace: bool) -> ! { let _0: !; // return @@ -509,6 +521,7 @@ pub fn panic_nounwind_fmt<'_0>(fmt: Arguments<'_0>, force_no_backtrace: bool) -> unwind_terminate } +#[track_caller] fn core::mem::alignment::{Alignment}::new_unchecked::precondition_check(align: usize) { let _0: (); // return @@ -561,6 +574,7 @@ fn core::mem::alignment::{Alignment}::new_unchecked::precondition_check(align: u } // Full name: core::mem::alignment::{Alignment}::new_unchecked +#[track_caller] pub unsafe fn new_unchecked(align: usize) -> Alignment { let _0: Alignment; // return @@ -753,6 +767,7 @@ where = IS_ZST[TraitClause0]() // Full name: core::option::unwrap_failed +#[track_caller] fn unwrap_failed() -> ! { let _0: !; // return @@ -762,6 +777,7 @@ fn unwrap_failed() -> ! } // Full name: core::option::{Option[TraitClause0]}::unwrap +#[track_caller] #[diagnostic_item("option_unwrap")] pub fn unwrap(self: Option[TraitClause0]) -> T where @@ -898,9 +914,11 @@ where return } +#[track_caller] fn core::ptr::copy_nonoverlapping::precondition_check(_1: *const (), _2: *mut (), _3: usize, _4: usize, _5: usize) = +#[track_caller] #[diagnostic_item("ptr_copy_nonoverlapping")] pub unsafe fn core::ptr::copy_nonoverlapping(src: *const T, dst: *mut T, count: usize) where diff --git a/charon/tests/ui/cross_compile_32_bit.out b/charon/tests/ui/cross_compile_32_bit.out index 20415a1f6..37185541b 100644 --- a/charon/tests/ui/cross_compile_32_bit.out +++ b/charon/tests/ui/cross_compile_32_bit.out @@ -12,6 +12,7 @@ pub const MAX: usize = MAX() pub opaque type NonNull // Full name: core::ptr::non_null::{NonNull}::new_unchecked +#[track_caller] pub unsafe fn new_unchecked(_1: *mut T) -> NonNull = diff --git a/charon/tests/ui/demo.out b/charon/tests/ui/demo.out index 5ef77c686..e4a062282 100644 --- a/charon/tests/ui/demo.out +++ b/charon/tests/ui/demo.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/desugar_drops_to_calls.out b/charon/tests/ui/desugar_drops_to_calls.out index 8d4eb194f..3e9909bbb 100644 --- a/charon/tests/ui/desugar_drops_to_calls.out +++ b/charon/tests/ui/desugar_drops_to_calls.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/desugar_drops_to_calls_mono.out b/charon/tests/ui/desugar_drops_to_calls_mono.out index 47172c012..833e57021 100644 --- a/charon/tests/ui/desugar_drops_to_calls_mono.out +++ b/charon/tests/ui/desugar_drops_to_calls_mono.out @@ -3,10 +3,12 @@ opaque type core::marker::MetaSized::{vtable} // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/drop_after_overflow.out b/charon/tests/ui/drop_after_overflow.out index 8c744df92..19312b293 100644 --- a/charon/tests/ui/drop_after_overflow.out +++ b/charon/tests/ui/drop_after_overflow.out @@ -9,6 +9,7 @@ pub fn from_str<'a>(_1: &'static str) -> Arguments<'a> = // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized diff --git a/charon/tests/ui/dyn-trait.out b/charon/tests/ui/dyn-trait.out index bdc6a4c9b..b9b1e0b00 100644 --- a/charon/tests/ui/dyn-trait.out +++ b/charon/tests/ui/dyn-trait.out @@ -12,10 +12,12 @@ pub trait PartialEq } // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -24,6 +26,7 @@ pub trait Sized } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -34,6 +37,7 @@ pub trait Tuple opaque type core::ops::function::Fn::{vtable} // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { @@ -47,6 +51,7 @@ pub trait FnOnce } // Full name: core::ops::function::FnMut +#[fundamental] #[lang_item(FnMut)] pub trait FnMut { @@ -59,6 +64,7 @@ pub trait FnMut } // Full name: core::ops::function::Fn +#[fundamental] #[lang_item(Fn)] pub trait Fn { @@ -98,6 +104,7 @@ where = // Full name: test_crate::construct +#[charon::opaque] fn construct(_1: T) -> alloc::boxed::Box<(dyn Display + 'static)>[{built_in impl MetaSized for (dyn Display + 'static)}, {built_in impl Sized for Global}] where TraitClause0: (T: Sized), @@ -124,6 +131,7 @@ fn destruct<'_0>(x: &'_0 (dyn Display + '_0)) -> String } // Full name: test_crate::combine +#[charon::opaque] fn combine() = diff --git a/charon/tests/ui/dyn-with-diamond-supertraits.out b/charon/tests/ui/dyn-with-diamond-supertraits.out index b0f713973..0ebb96ade 100644 --- a/charon/tests/ui/dyn-with-diamond-supertraits.out +++ b/charon/tests/ui/dyn-with-diamond-supertraits.out @@ -1,16 +1,19 @@ # Final LLBC before serialization: // Full name: core::ops::arith::{impl Add for &'_0 i32}::add +#[track_caller] pub fn add<'_0>(_1: &'_0 i32, _2: i32) -> i32 = opaque type core::marker::MetaSized::{vtable} // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/explicit-drop-bounds.out b/charon/tests/ui/explicit-drop-bounds.out index 2e5e075ee..ab2d36df8 100644 --- a/charon/tests/ui/explicit-drop-bounds.out +++ b/charon/tests/ui/explicit-drop-bounds.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/external.out b/charon/tests/ui/external.out index e71ea936f..48ee6973b 100644 --- a/charon/tests/ui/external.out +++ b/charon/tests/ui/external.out @@ -1,6 +1,7 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized @@ -11,6 +12,7 @@ where TraitClause0: (T: MetaSized), // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -154,6 +156,7 @@ where = // Full name: core::option::{Option[TraitClause0]}::unwrap +#[track_caller] #[diagnostic_item("option_unwrap")] pub fn unwrap(_1: Option[TraitClause0]) -> T where @@ -259,6 +262,7 @@ pub fn test_new_non_zero_u32(x: u32) -> NonZero[{built_in impl Sized for u3 } // Full name: test_crate::test_vec_push +#[allow(clippy::vec_init_then_push)] pub fn test_vec_push() { let _0: (); // return diff --git a/charon/tests/ui/filtering/inner-items.out b/charon/tests/ui/filtering/inner-items.out index 3f5c6862d..b5f280478 100644 --- a/charon/tests/ui/filtering/inner-items.out +++ b/charon/tests/ui/filtering/inner-items.out @@ -1,6 +1,7 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized @@ -114,6 +115,7 @@ fn inner4() } // Full name: test_crate::module::opaque +#[charon::opaque] fn opaque() = diff --git a/charon/tests/ui/filtering/issue-1270-start-from-pub-skip-foreign-pub.out b/charon/tests/ui/filtering/issue-1270-start-from-pub-skip-foreign-pub.out index 7ba4e5980..72e4c9c96 100644 --- a/charon/tests/ui/filtering/issue-1270-start-from-pub-skip-foreign-pub.out +++ b/charon/tests/ui/filtering/issue-1270-start-from-pub-skip-foreign-pub.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -92,6 +94,7 @@ where = // Full name: core::result::{impl FromResidual[{built_in impl Sized for Infallible}, TraitClause1]> for Result[TraitClause0, TraitClause2]}::from_residual +#[track_caller] pub fn from_residual(_1: Result[{built_in impl Sized for Infallible}, TraitClause1]) -> Result[TraitClause0, TraitClause2] where TraitClause0: (T: Sized), diff --git a/charon/tests/ui/filtering/opacity.out b/charon/tests/ui/filtering/opacity.out index 870a6d0ea..a351090d4 100644 --- a/charon/tests/ui/filtering/opacity.out +++ b/charon/tests/ui/filtering/opacity.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -24,6 +26,7 @@ pub trait From } // Full name: core::convert::{impl Into for T}::into +#[track_caller] pub fn into(self: T) -> U where TraitClause0: (T: Sized), diff --git a/charon/tests/ui/filtering/opaque-trait.out b/charon/tests/ui/filtering/opaque-trait.out index a7b17d213..8b660e02e 100644 --- a/charon/tests/ui/filtering/opaque-trait.out +++ b/charon/tests/ui/filtering/opaque-trait.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -13,6 +15,7 @@ pub trait Sized } // Full name: test_crate::Trait +#[charon::opaque] trait Trait { proof ImpliedClause0: (Self: MetaSized) diff --git a/charon/tests/ui/filtering/opaque_attribute.out b/charon/tests/ui/filtering/opaque_attribute.out index b0087933c..32bfebd63 100644 --- a/charon/tests/ui/filtering/opaque_attribute.out +++ b/charon/tests/ui/filtering/opaque_attribute.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -24,6 +26,7 @@ where } // Full name: test_crate::BoolTrait +#[charon::opaque] pub trait BoolTrait { proof ImpliedClause0: (Self: MetaSized) @@ -97,6 +100,7 @@ where } // Full name: test_crate::test_bool_trait_option +#[charon::opaque] pub fn test_bool_trait_option(_1: Option[TraitClause0]) -> bool where TraitClause0: (T: Sized), @@ -104,19 +108,24 @@ where = // Full name: test_crate::Test +#[charon::opaque] opaque type Test // Full name: test_crate::SIX_SIX_SIX +#[charon::opaque] fn SIX_SIX_SIX() -> u32 = // Full name: test_crate::SIX_SIX_SIX +#[charon::opaque] const SIX_SIX_SIX: u32 = SIX_SIX_SIX() // Full name: test_crate::Test2 +#[charon::opaque] opaque type Test2 // Full name: test_crate::Test3 +#[charon::opaque] opaque type Test3 // Full name: test_crate::opaque::fn_in_opaque_module diff --git a/charon/tests/ui/filtering/start_from.out b/charon/tests/ui/filtering/start_from.out index 4573d3638..1ad42aad5 100644 --- a/charon/tests/ui/filtering/start_from.out +++ b/charon/tests/ui/filtering/start_from.out @@ -1,6 +1,7 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized diff --git a/charon/tests/ui/filtering/start_from_attribute.out b/charon/tests/ui/filtering/start_from_attribute.out index 4e6058d77..291484259 100644 --- a/charon/tests/ui/filtering/start_from_attribute.out +++ b/charon/tests/ui/filtering/start_from_attribute.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: test_crate::module2::do_translate +#[verify::start_from] fn do_translate() { let _0: (); // return @@ -16,6 +18,7 @@ fn do_translate() } // Full name: test_crate::module2::also_translate +#[foobar::haha] fn also_translate() { let _0: (); // return @@ -30,6 +33,7 @@ fn also_translate() struct Type1 {} // Full name: test_crate::module2::{impl Trait1 for Type1}::method +#[verify::start_from] fn method() { let _0: (); // return diff --git a/charon/tests/ui/filtering/start_from_pub.out b/charon/tests/ui/filtering/start_from_pub.out index f96ca93a6..229f0f67a 100644 --- a/charon/tests/ui/filtering/start_from_pub.out +++ b/charon/tests/ui/filtering/start_from_pub.out @@ -1,6 +1,7 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized diff --git a/charon/tests/ui/find-sized-clause.out b/charon/tests/ui/find-sized-clause.out index 3d5eb3da1..fa131ce95 100644 --- a/charon/tests/ui/find-sized-clause.out +++ b/charon/tests/ui/find-sized-clause.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/foreign-type-alias.out b/charon/tests/ui/foreign-type-alias.out index 358b462ec..431703189 100644 --- a/charon/tests/ui/foreign-type-alias.out +++ b/charon/tests/ui/foreign-type-alias.out @@ -1,6 +1,7 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized @@ -15,6 +16,7 @@ pub trait Borrow } // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/function-conditions.out b/charon/tests/ui/function-conditions.out index 2baa6d5b4..631b1128f 100644 --- a/charon/tests/ui/function-conditions.out +++ b/charon/tests/ui/function-conditions.out @@ -1,6 +1,7 @@ # Final LLBC before serialization: // Full name: test_crate::function +// precondition: precondition fn function() { let _0: (); // return @@ -12,6 +13,7 @@ fn function() } // Full name: test_crate::function::precondition +#[charon::precondition] // of function fn precondition() -> bool { let _0: bool; // return diff --git a/charon/tests/ui/gat-causes-unhandled-ty-clause.out b/charon/tests/ui/gat-causes-unhandled-ty-clause.out index daaccfd35..3c0b64721 100644 --- a/charon/tests/ui/gat-causes-unhandled-ty-clause.out +++ b/charon/tests/ui/gat-causes-unhandled-ty-clause.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/gosim-demo.out b/charon/tests/ui/gosim-demo.out index 92402fbf7..278f91cab 100644 --- a/charon/tests/ui/gosim-demo.out +++ b/charon/tests/ui/gosim-demo.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/impl-trait.out b/charon/tests/ui/impl-trait.out index dd04ad522..1d970ba1d 100644 --- a/charon/tests/ui/impl-trait.out +++ b/charon/tests/ui/impl-trait.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -60,6 +62,7 @@ pub trait Destruct } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -68,6 +71,7 @@ pub trait Tuple } // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { diff --git a/charon/tests/ui/issue-1041-shift-through-index-mut.out b/charon/tests/ui/issue-1041-shift-through-index-mut.out index 732afa355..709a0e805 100644 --- a/charon/tests/ui/issue-1041-shift-through-index-mut.out +++ b/charon/tests/ui/issue-1041-shift-through-index-mut.out @@ -1,6 +1,7 @@ # Final ULLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized diff --git a/charon/tests/ui/issue-114-opaque-bodies.out b/charon/tests/ui/issue-114-opaque-bodies.out index c568a02a2..0626d2970 100644 --- a/charon/tests/ui/issue-114-opaque-bodies.out +++ b/charon/tests/ui/issue-114-opaque-bodies.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/issue-118-generic-copy.out b/charon/tests/ui/issue-118-generic-copy.out index f46ef5016..a04c1377f 100644 --- a/charon/tests/ui/issue-118-generic-copy.out +++ b/charon/tests/ui/issue-118-generic-copy.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -45,6 +47,7 @@ pub trait Copy struct Foo {} // Full name: test_crate::{impl Clone for Foo}::clone +#[inline(hint)] pub fn clone<'_0>(self: &'_0 Foo) -> Foo { let _0: Foo; // return diff --git a/charon/tests/ui/issue-120-bare-discriminant-read.out b/charon/tests/ui/issue-120-bare-discriminant-read.out index 3d48de1f8..d177d7501 100644 --- a/charon/tests/ui/issue-120-bare-discriminant-read.out +++ b/charon/tests/ui/issue-120-bare-discriminant-read.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/issue-159-heterogeneous-recursive-definitions.out b/charon/tests/ui/issue-159-heterogeneous-recursive-definitions.out index 826af6da7..0007eeb01 100644 --- a/charon/tests/ui/issue-159-heterogeneous-recursive-definitions.out +++ b/charon/tests/ui/issue-159-heterogeneous-recursive-definitions.out @@ -1,6 +1,7 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized diff --git a/charon/tests/ui/issue-165-vec-macro.out b/charon/tests/ui/issue-165-vec-macro.out index de9e23a11..48a9779a7 100644 --- a/charon/tests/ui/issue-165-vec-macro.out +++ b/charon/tests/ui/issue-165-vec-macro.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/issue-323-closure-borrow.out b/charon/tests/ui/issue-323-closure-borrow.out index 1b8ea4ce6..746e018d9 100644 --- a/charon/tests/ui/issue-323-closure-borrow.out +++ b/charon/tests/ui/issue-323-closure-borrow.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -21,6 +23,7 @@ pub trait Destruct } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -29,6 +32,7 @@ pub trait Tuple } // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { @@ -42,6 +46,7 @@ pub trait FnOnce } // Full name: core::ops::function::FnMut +#[fundamental] #[lang_item(FnMut)] pub trait FnMut { diff --git a/charon/tests/ui/issue-369-mismatched-genericparams.out b/charon/tests/ui/issue-369-mismatched-genericparams.out index f5145214b..7c49df690 100644 --- a/charon/tests/ui/issue-369-mismatched-genericparams.out +++ b/charon/tests/ui/issue-369-mismatched-genericparams.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/issue-372-type-param-out-of-range.out b/charon/tests/ui/issue-372-type-param-out-of-range.out index 24a159e64..73ce4f9ae 100644 --- a/charon/tests/ui/issue-372-type-param-out-of-range.out +++ b/charon/tests/ui/issue-372-type-param-out-of-range.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -13,6 +15,7 @@ pub trait Sized } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -21,6 +24,7 @@ pub trait Tuple } // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { @@ -34,6 +38,7 @@ pub trait FnOnce } // Full name: core::ops::function::FnMut +#[fundamental] #[lang_item(FnMut)] pub trait FnMut { diff --git a/charon/tests/ui/issue-378-ctor-as-fn.out b/charon/tests/ui/issue-378-ctor-as-fn.out index 600351db6..5760bfc3f 100644 --- a/charon/tests/ui/issue-378-ctor-as-fn.out +++ b/charon/tests/ui/issue-378-ctor-as-fn.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/issue-394-rpit-with-lifetime.out b/charon/tests/ui/issue-394-rpit-with-lifetime.out index bef98c6e3..ada45e40b 100644 --- a/charon/tests/ui/issue-394-rpit-with-lifetime.out +++ b/charon/tests/ui/issue-394-rpit-with-lifetime.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -24,6 +26,7 @@ where } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -32,6 +35,7 @@ pub trait Tuple } // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { @@ -45,6 +49,7 @@ pub trait FnOnce } // Full name: core::ops::function::FnMut +#[fundamental] #[lang_item(FnMut)] pub trait FnMut { diff --git a/charon/tests/ui/issue-395-failed-to-normalize.out b/charon/tests/ui/issue-395-failed-to-normalize.out index d956c619a..3769c1138 100644 --- a/charon/tests/ui/issue-395-failed-to-normalize.out +++ b/charon/tests/ui/issue-395-failed-to-normalize.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/issue-4-slice-try-into-array.out b/charon/tests/ui/issue-4-slice-try-into-array.out index 17acacf0d..edcc67958 100644 --- a/charon/tests/ui/issue-4-slice-try-into-array.out +++ b/charon/tests/ui/issue-4-slice-try-into-array.out @@ -9,10 +9,12 @@ impl "impl_Debug_for_TryFromSliceError" Debug for TryFromSliceError { } // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -113,6 +115,7 @@ impl "impl_Copy_for_u8" Copy for u8 { } // Full name: core::result::{Result[TraitClause0, TraitClause1]}::unwrap +#[track_caller] pub fn unwrap(_1: Result[TraitClause0, TraitClause1]) -> T where TraitClause0: (T: Sized), diff --git a/charon/tests/ui/issue-4-traits.out b/charon/tests/ui/issue-4-traits.out index 3fbb24b0b..0296ac270 100644 --- a/charon/tests/ui/issue-4-traits.out +++ b/charon/tests/ui/issue-4-traits.out @@ -9,10 +9,12 @@ impl "impl_Debug_for_TryFromSliceError" Debug for TryFromSliceError { } // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -113,6 +115,7 @@ impl "impl_Copy_for_u8" Copy for u8 { } // Full name: core::result::{Result[TraitClause0, TraitClause1]}::unwrap +#[track_caller] pub fn unwrap(_1: Result[TraitClause0, TraitClause1]) -> T where TraitClause0: (T: Sized), diff --git a/charon/tests/ui/issue-45-misc.out b/charon/tests/ui/issue-45-misc.out index a32351b5c..d7f6a1379 100644 --- a/charon/tests/ui/issue-45-misc.out +++ b/charon/tests/ui/issue-45-misc.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -13,6 +15,7 @@ pub trait Tuple } // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -21,6 +24,7 @@ pub trait Sized } // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { @@ -34,6 +38,7 @@ pub trait FnOnce } // Full name: core::ops::function::FnMut +#[fundamental] #[lang_item(FnMut)] pub trait FnMut { diff --git a/charon/tests/ui/issue-70-override-provided-method.2-nodup.out b/charon/tests/ui/issue-70-override-provided-method.2-nodup.out index 91ec01e89..9604491b8 100644 --- a/charon/tests/ui/issue-70-override-provided-method.2-nodup.out +++ b/charon/tests/ui/issue-70-override-provided-method.2-nodup.out @@ -1,6 +1,7 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized diff --git a/charon/tests/ui/issue-70-override-provided-method.2.out b/charon/tests/ui/issue-70-override-provided-method.2.out index e5fdc396d..118acea37 100644 --- a/charon/tests/ui/issue-70-override-provided-method.2.out +++ b/charon/tests/ui/issue-70-override-provided-method.2.out @@ -1,6 +1,7 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized diff --git a/charon/tests/ui/issue-70-override-provided-method.3.out b/charon/tests/ui/issue-70-override-provided-method.3.out index ca13f36f7..00652068d 100644 --- a/charon/tests/ui/issue-70-override-provided-method.3.out +++ b/charon/tests/ui/issue-70-override-provided-method.3.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/issue-70-override-provided-method.out b/charon/tests/ui/issue-70-override-provided-method.out index 5e37b3148..5e13c9c52 100644 --- a/charon/tests/ui/issue-70-override-provided-method.out +++ b/charon/tests/ui/issue-70-override-provided-method.out @@ -18,10 +18,12 @@ pub enum Ordering { } // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -151,6 +153,7 @@ impl "impl_StructuralPartialEq_for_Foo" StructuralPartialEq for Foo { } // Full name: test_crate::{impl PartialEq for Foo}::eq +#[inline(hint)] pub fn impl_PartialEq_Foo_for_Foo::eq<'_0, '_1>(self: &'_0 Foo, other: &'_1 Foo) -> bool { let _0: bool; // return @@ -179,6 +182,7 @@ impl "impl_PartialEq_Foo_for_Foo" PartialEq for Foo { } // Full name: test_crate::{impl PartialOrd for Foo}::partial_cmp +#[inline(hint)] pub fn impl_PartialOrd_Foo_for_Foo::partial_cmp<'_0, '_1>(self: &'_0 Foo, other: &'_1 Foo) -> Option[{built_in impl Sized for Ordering}] { let _0: Option[{built_in impl Sized for Ordering}]; // return diff --git a/charon/tests/ui/issue-72-hash-missing-impl.out b/charon/tests/ui/issue-72-hash-missing-impl.out index d7fd19ed9..93dfb8d0e 100644 --- a/charon/tests/ui/issue-72-hash-missing-impl.out +++ b/charon/tests/ui/issue-72-hash-missing-impl.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/issue-91-enum-to-discriminant-cast.out b/charon/tests/ui/issue-91-enum-to-discriminant-cast.out index 01011919f..344b53180 100644 --- a/charon/tests/ui/issue-91-enum-to-discriminant-cast.out +++ b/charon/tests/ui/issue-91-enum-to-discriminant-cast.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -48,6 +50,7 @@ enum Foo { } // Full name: test_crate::{impl Clone for Foo}::clone +#[inline(hint)] pub fn clone<'_0>(self: &'_0 Foo) -> Foo { let _0: Foo; // return diff --git a/charon/tests/ui/issue-93-recursive-traits-with-assoc-types.out b/charon/tests/ui/issue-93-recursive-traits-with-assoc-types.out index d7f848afd..f858dd093 100644 --- a/charon/tests/ui/issue-93-recursive-traits-with-assoc-types.out +++ b/charon/tests/ui/issue-93-recursive-traits-with-assoc-types.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/issue-94-recursive-trait-defns.out b/charon/tests/ui/issue-94-recursive-trait-defns.out index eda08ff26..f11605d17 100644 --- a/charon/tests/ui/issue-94-recursive-trait-defns.out +++ b/charon/tests/ui/issue-94-recursive-trait-defns.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/issue-97-missing-parent-item-clause.out b/charon/tests/ui/issue-97-missing-parent-item-clause.out index 436b16623..ae087393b 100644 --- a/charon/tests/ui/issue-97-missing-parent-item-clause.out +++ b/charon/tests/ui/issue-97-missing-parent-item-clause.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/iterator.out b/charon/tests/ui/iterator.out index 81985578a..aad385202 100644 --- a/charon/tests/ui/iterator.out +++ b/charon/tests/ui/iterator.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -94,6 +96,7 @@ where } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -102,6 +105,7 @@ pub trait Tuple } // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { @@ -115,6 +119,7 @@ pub trait FnOnce } // Full name: core::ops::function::FnMut +#[fundamental] #[lang_item(FnMut)] pub trait FnMut { @@ -881,6 +886,7 @@ where = // Full name: core::array::iter::{impl Iterator for IntoIter[TraitClause0]}::array_chunks +#[track_caller] pub fn impl_Iterator_for_IntoIter::array_chunks(_1: IntoIter[TraitClause0]) -> ArrayChunks[TraitClause0], N>[TraitClause1, impl_Iterator_for_IntoIter[TraitClause0]] where TraitClause0: (T: Sized), @@ -1537,6 +1543,7 @@ where = // Full name: core::cmp::Eq::assert_receiver_is_total_eq +#[deprecated(since = "1.95.0", note = "implementation detail of `#[derive(Eq)]`")] #[diagnostic_item("assert_receiver_is_total_eq")] pub fn assert_receiver_is_total_eq<'_0, Self>(_1: &'_0 Self) where @@ -1640,6 +1647,7 @@ where = // Full name: core::ops::arith::{impl AddAssign<&'_0 i32> for i32}::add_assign +#[track_caller] pub fn add_assign<'_0, '_1>(_1: &'_1 mut i32, _2: &'_0 i32) = @@ -2304,6 +2312,7 @@ where TraitClause2: (Self: Clone), = +#[track_caller] pub fn core::iter::traits::iterator::Iterator::array_chunks(_1: Self) -> ArrayChunks[TraitClause1, TraitClause0] where TraitClause0: (Self: Iterator), @@ -2834,6 +2843,7 @@ where = // Full name: core::slice::iter::{impl Iterator for Iter<'a, T>[TraitClause0]}::array_chunks +#[track_caller] pub fn impl_Iterator_for_Iter::array_chunks<'a, T, const N : usize>(_1: Iter<'a, T>[TraitClause0]) -> ArrayChunks[TraitClause0], N>[TraitClause1, impl_Iterator_for_Iter<'a, T>[TraitClause0]] where TraitClause0: (T: Sized), @@ -3686,6 +3696,7 @@ where = // Full name: core::slice::iter::{impl Iterator for Chunks<'a, T>[TraitClause0]}::array_chunks +#[track_caller] pub fn impl_Iterator_for_Chunks::array_chunks<'a, T, const N : usize>(_1: Chunks<'a, T>[TraitClause0]) -> ArrayChunks[TraitClause0], N>[TraitClause1, impl_Iterator_for_Chunks<'a, T>[TraitClause0]] where TraitClause0: (T: Sized), @@ -4663,6 +4674,7 @@ where = // Full name: core::slice::iter::{impl Iterator for ChunksExact<'a, T>[TraitClause0]}::array_chunks +#[track_caller] pub fn impl_Iterator_for_ChunksExact::array_chunks<'a, T, const N : usize>(_1: ChunksExact<'a, T>[TraitClause0]) -> ArrayChunks[TraitClause0], N>[TraitClause1, impl_Iterator_for_ChunksExact<'a, T>[TraitClause0]] where TraitClause0: (T: Sized), @@ -5410,6 +5422,7 @@ where = // Full name: core::slice::{[T]}::chunks +#[track_caller] pub fn chunks<'_0, T>(_1: &'_0 [T], _2: usize) -> Chunks<'_0, T>[TraitClause0] where TraitClause0: (T: Sized), @@ -5417,6 +5430,7 @@ where = // Full name: core::slice::{[T]}::chunks_exact +#[track_caller] pub fn chunks_exact<'_0, T>(_1: &'_0 [T], _2: usize) -> ChunksExact<'_0, T>[TraitClause0] where TraitClause0: (T: Sized), diff --git a/charon/tests/ui/lifetime-mutability.out b/charon/tests/ui/lifetime-mutability.out index b3e6a15f4..64894628b 100644 --- a/charon/tests/ui/lifetime-mutability.out +++ b/charon/tests/ui/lifetime-mutability.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/matches.out b/charon/tests/ui/matches.out index 93bda3c27..f4e7d8ea9 100644 --- a/charon/tests/ui/matches.out +++ b/charon/tests/ui/matches.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/max_char.out b/charon/tests/ui/max_char.out index 946a24785..cca5c8480 100644 --- a/charon/tests/ui/max_char.out +++ b/charon/tests/ui/max_char.out @@ -1,6 +1,7 @@ # Final LLBC before serialization: // Full name: core::char::MAX +#[deprecated(since = "future", note = "replaced by the `MAX` associated constant on `char`")] pub fn MAX() -> char { let _0: char; // return @@ -11,6 +12,7 @@ pub fn MAX() -> char } // Full name: core::char::MAX +#[deprecated(since = "future", note = "replaced by the `MAX` associated constant on `char`")] pub const MAX: char = MAX() // Full name: test_crate::main diff --git a/charon/tests/ui/method-impl-generalization.out b/charon/tests/ui/method-impl-generalization.out index a3ced4c65..910587a4f 100644 --- a/charon/tests/ui/method-impl-generalization.out +++ b/charon/tests/ui/method-impl-generalization.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/method-ref.out b/charon/tests/ui/method-ref.out index 553d4df62..0a964b7a8 100644 --- a/charon/tests/ui/method-ref.out +++ b/charon/tests/ui/method-ref.out @@ -9,10 +9,12 @@ pub enum Ordering { } // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/ml-mono-name-matcher-tests.out b/charon/tests/ui/ml-mono-name-matcher-tests.out index 6d789ea8a..a76919d96 100644 --- a/charon/tests/ui/ml-mono-name-matcher-tests.out +++ b/charon/tests/ui/ml-mono-name-matcher-tests.out @@ -23,6 +23,9 @@ pub fn index::><'_0>(_1: &'_0 [bool], _2: RangeFrom:: // Full name: test_crate::foo::bar +#[pattern::pass("test_crate::foo::bar")] +#[pattern::fail("crate::foo::bar")] +#[pattern::fail("foo::bar")] fn bar() { let _0: (); // return @@ -34,6 +37,15 @@ fn bar() } // Full name: test_crate::foo +#[pattern::pass(call[0], "core::option::{core::option::Option<@T>}::is_some<'_, i32>")] +#[pattern::fail(call[0], "core::option::{core::option::Option<@T>}::is_some<_, i32>")] +#[pattern::pass(call[0], "core::option::{core::option::Option<@T>}::is_some<'_, @T>")] +#[pattern::pass(call[1], "ArrayToSliceShared<'_, bool, 1>")] +#[pattern::pass(call[2], +"core::ops::index::Index<[bool], core::ops::range::RangeFrom>::index")] +#[pattern::pass(call[2], "core::ops::index::Index<[@T], @I>::index")] +#[pattern::fail(call[2], +"core::slice::index::{core::ops::index::Index<[@T], @I>}::index>")] fn foo() { let _0: (); // return @@ -128,6 +140,12 @@ fn test_crate::funs_with_disambiguator::f() -> u32 } // Full name: test_crate::funs_with_disambiguator +#[pattern::pass(call[0], "test_crate::funs_with_disambiguator::f#1")] +#[pattern::fail(call[0], "test_crate::funs_with_disambiguator::f#0")] +#[pattern::fail(call[0], "test_crate::funs_with_disambiguator::f")] +#[pattern::pass(call[1], "test_crate::funs_with_disambiguator::f")] +#[pattern::pass(call[1], "test_crate::funs_with_disambiguator::f#0")] +#[pattern::fail(call[1], "test_crate::funs_with_disambiguator::f#1")] fn funs_with_disambiguator(b: bool) -> u32 { let _0: u32; // return @@ -160,6 +178,8 @@ struct MonoContainer::<&'_ str> { item: &'_ str, } +#[pattern::pass("test_crate::{test_crate::MonoContainer<@T>}::create<@T>")] +#[pattern::pass("test_crate::_::create<@T>")] fn test_crate::{MonoContainer::}::create::(item: i32) -> MonoContainer:: { let _0: MonoContainer::; // return @@ -174,6 +194,8 @@ fn test_crate::{MonoContainer::}::create::(item: i32) -> MonoContainer return } +#[pattern::pass("test_crate::{test_crate::MonoContainer<@T>}::create<@T>")] +#[pattern::pass("test_crate::_::create<@T>")] fn test_crate::{MonoContainer::<&'_ str>}::create::<&'_ str>(item: &'_ str) -> MonoContainer::<&'_ str> { let _0: MonoContainer::<&'_ str>; // return @@ -189,6 +211,7 @@ fn test_crate::{MonoContainer::<&'_ str>}::create::<&'_ str>(item: &'_ str) -> M } // Full name: test_crate::mono_usage +#[pattern::pass("test_crate::mono_usage")] fn mono_usage() { let _0: (); // return diff --git a/charon/tests/ui/ml-multi-target-name-matcher-tests.out b/charon/tests/ui/ml-multi-target-name-matcher-tests.out index 0585a1240..d8387ef30 100644 --- a/charon/tests/ui/ml-multi-target-name-matcher-tests.out +++ b/charon/tests/ui/ml-multi-target-name-matcher-tests.out @@ -1,3 +1,6 @@ +#[pattern::pass("test_crate::x86_only")] +#[pattern::fail("test_crate::x86_only::aarch64-apple-darwin")] +#[pattern::fail("test_crate::x86_only::x86_64-apple-darwin")] fn test_crate::x86_only() -> u64 { let _0: u64; // return @@ -7,6 +10,9 @@ fn test_crate::x86_only() -> u64 return } +#[pattern::pass("test_crate::arm_only")] +#[pattern::fail("test_crate::arm_only::aarch64-apple-darwin")] +#[pattern::fail("test_crate::arm_only::x86_64-apple-darwin")] fn test_crate::arm_only() -> u64 { let _0: u64; // return @@ -16,6 +22,7 @@ fn test_crate::arm_only() -> u64 return } +#[pattern::pass("test_crate::shared_fn")] fn test_crate::shared_fn() -> u64 { let _0: u64; // return diff --git a/charon/tests/ui/ml-name-matcher-tests.out b/charon/tests/ui/ml-name-matcher-tests.out index 9ece2122e..2b2c805bf 100644 --- a/charon/tests/ui/ml-name-matcher-tests.out +++ b/charon/tests/ui/ml-name-matcher-tests.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -138,6 +140,9 @@ where pub struct Global {} // Full name: test_crate::foo::bar +#[pattern::pass("test_crate::foo::bar")] +#[pattern::fail("crate::foo::bar")] +#[pattern::fail("foo::bar")] fn bar() { let _0: (); // return @@ -158,6 +163,12 @@ trait Trait } // Full name: test_crate::{impl Trait[TraitClause0]> for alloc::boxed::Box[TraitClause0::ImpliedClause0, {built_in impl Sized for Global}]}::method +#[pattern::pass("test_crate::{test_crate::Trait, core::option::Option<@T>>}::method<@T, @U>")] +#[pattern::pass("test_crate::{test_crate::Trait, core::option::Option<@T>>}::method<@T, @U>")] +#[pattern::fail("test_crate::{test_crate::Trait, Option<@T>>}::method<@T, @U>")] +#[pattern::pass("test_crate::{test_crate::Trait, core::option::Option<@U>>}::method<@T, @U>")] +#[pattern::pass("test_crate::{test_crate::Trait<@T, @U>}::method<@T, @U>")] +#[pattern::fail("test_crate::Trait<@T>::method")] fn impl_Trait_Option_for_Box_Global::method() where TraitClause0: (T: Sized), @@ -183,6 +194,8 @@ where } // Full name: test_crate::{impl Trait[TraitClause0::ImpliedClause0, {built_in impl Sized for Global}]> for Option[TraitClause1]}::method +#[pattern::pass("test_crate::{test_crate::Trait, alloc::boxed::Box<@T>>}::method<@T, @U, @V>")] +#[pattern::pass("test_crate::{test_crate::Trait, alloc::boxed::Box<@T>>}::method<@T, @U, @V>")] fn impl_Trait_Box_for_Option::method() where TraitClause0: (T: Sized), @@ -210,6 +223,16 @@ where } // Full name: test_crate::foo +#[pattern::pass(call[0], "core::option::{core::option::Option<@T>}::is_some<'_, i32>")] +#[pattern::fail(call[0], "core::option::{core::option::Option<@T>}::is_some<_, @T>")] +#[pattern::pass(call[0], "core::option::{core::option::Option<@T>}::is_some<'_, @U>")] +#[pattern::fail(call[0], "core::option::{core::option::Option}::is_some<_, i32>")] +#[pattern::pass(call[1], "ArrayToSliceShared<'_, bool, 1>")] +#[pattern::pass(call[2], +"core::ops::index::Index<[bool], core::ops::range::RangeFrom>::index")] +#[pattern::pass(call[2], "core::ops::index::Index<[@T], @I>::index")] +#[pattern::fail(call[2], +"core::slice::index::{core::ops::index::Index<[@T], @I>}::index>")] fn foo() { let _0: (); // return @@ -304,6 +327,12 @@ fn test_crate::funs_with_disambiguator::f() -> u32 } // Full name: test_crate::funs_with_disambiguator +#[pattern::pass(call[0], "test_crate::funs_with_disambiguator::f#1")] +#[pattern::fail(call[0], "test_crate::funs_with_disambiguator::f#0")] +#[pattern::fail(call[0], "test_crate::funs_with_disambiguator::f")] +#[pattern::pass(call[1], "test_crate::funs_with_disambiguator::f")] +#[pattern::pass(call[1], "test_crate::funs_with_disambiguator::f#0")] +#[pattern::fail(call[1], "test_crate::funs_with_disambiguator::f#1")] fn funs_with_disambiguator(b: bool) -> u32 { let _0: u32; // return @@ -335,6 +364,8 @@ where } // Full name: test_crate::{MonoContainer[TraitClause0]}::create +#[pattern::pass("test_crate::{test_crate::MonoContainer<@T>}::create<@T>")] +#[pattern::pass("test_crate::_::create<@T>")] fn create(item: T) -> MonoContainer[TraitClause0] where TraitClause0: (T: Sized), @@ -358,6 +389,7 @@ where } // Full name: test_crate::mono_usage +#[pattern::pass("test_crate::mono_usage")] fn mono_usage() { let _0: (); // return @@ -390,6 +422,7 @@ trait Get<'a, Self, T> } // Full name: test_crate::{impl Get<'a, T> for &'a MonoContainer[TraitClause0]}::get +#[pattern::to_name("test_cratetest_crateGetASharedAtest_crateMonoContainerTTget")] fn {impl Get<'a, T> for &'a MonoContainer[TraitClause0]}::get<'a, T>(self: &'a MonoContainer[TraitClause0]) -> &'a T where TraitClause0: (T: Sized), diff --git a/charon/tests/ui/ml-partial-mono-name-matcher-tests.out b/charon/tests/ui/ml-partial-mono-name-matcher-tests.out index bacdb252e..508cc64db 100644 --- a/charon/tests/ui/ml-partial-mono-name-matcher-tests.out +++ b/charon/tests/ui/ml-partial-mono-name-matcher-tests.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -12,9 +14,11 @@ pub trait Sized non-dyn-compatible } +#[fundamental] #[lang_item(MetaSized)] pub trait core::marker::MetaSized::<&_ mut _><'_0, T0> +#[fundamental] #[lang_item(Sized)] pub trait core::marker::Sized::<&_ mut _><'_0, T0> { @@ -22,9 +26,11 @@ pub trait core::marker::Sized::<&_ mut _><'_0, T0> non-dyn-compatible } +#[fundamental] #[lang_item(MetaSized)] pub trait core::marker::MetaSized::><'_0, T0> +#[fundamental] #[lang_item(Sized)] pub trait core::marker::Sized::><'_0, T0> { @@ -106,6 +112,10 @@ where } // Full name: test_crate::use_id_mut +#[pattern::pass(call[0], "test_crate::identity<&'_ mut @T>")] +#[pattern::pass(call[0], "test_crate::identity<@T>")] +#[pattern::fail(call[0], "test_crate::identity<&'_ @T>")] +#[pattern::pass(call[1], "test_crate::identity>")] fn use_id_mut(x: A) where TraitClause0: (A: Sized), diff --git a/charon/tests/ui/monomorphization/closure-fn.out b/charon/tests/ui/monomorphization/closure-fn.out index 5f10be3cb..ae8fcd9d1 100644 --- a/charon/tests/ui/monomorphization/closure-fn.out +++ b/charon/tests/ui/monomorphization/closure-fn.out @@ -3,10 +3,12 @@ opaque type core::marker::MetaSized::{vtable} // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -23,6 +25,7 @@ pub trait Destruct } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -35,6 +38,7 @@ opaque type core::ops::function::Fn::{vtable} opaque type core::ops::function::FnOnce::{vtable} // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { @@ -47,6 +51,7 @@ pub trait FnOnce opaque type core::ops::function::FnMut::{vtable} // Full name: core::ops::function::FnMut +#[fundamental] #[lang_item(FnMut)] pub trait FnMut { @@ -58,6 +63,7 @@ pub trait FnMut } // Full name: core::ops::function::Fn +#[fundamental] #[lang_item(Fn)] pub trait Fn { diff --git a/charon/tests/ui/monomorphization/closure-fnonce.out b/charon/tests/ui/monomorphization/closure-fnonce.out index 61fcd0469..b078cd6eb 100644 --- a/charon/tests/ui/monomorphization/closure-fnonce.out +++ b/charon/tests/ui/monomorphization/closure-fnonce.out @@ -3,10 +3,12 @@ opaque type core::marker::MetaSized::{vtable} // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -23,6 +25,7 @@ pub trait Destruct } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -41,6 +44,7 @@ pub fn drop::(_1: NotCopy) opaque type core::ops::function::FnOnce::{vtable} // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { diff --git a/charon/tests/ui/monomorphization/closures.out b/charon/tests/ui/monomorphization/closures.out index 894eaf7ce..8861b72d2 100644 --- a/charon/tests/ui/monomorphization/closures.out +++ b/charon/tests/ui/monomorphization/closures.out @@ -3,10 +3,12 @@ opaque type core::marker::MetaSized::{vtable} // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -23,6 +25,7 @@ pub trait Destruct } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -43,6 +46,7 @@ opaque type core::ops::function::Fn::{vtable} opaque type core::ops::function::FnOnce::{vtable} // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { @@ -55,6 +59,7 @@ pub trait FnOnce opaque type core::ops::function::FnMut::{vtable} // Full name: core::ops::function::FnMut +#[fundamental] #[lang_item(FnMut)] pub trait FnMut { @@ -66,6 +71,7 @@ pub trait FnMut } // Full name: core::ops::function::Fn +#[fundamental] #[lang_item(Fn)] pub trait Fn { diff --git a/charon/tests/ui/monomorphization/fndefs-casts.out b/charon/tests/ui/monomorphization/fndefs-casts.out index e58e19e93..1d2bd5906 100644 --- a/charon/tests/ui/monomorphization/fndefs-casts.out +++ b/charon/tests/ui/monomorphization/fndefs-casts.out @@ -3,10 +3,12 @@ opaque type core::marker::MetaSized::{vtable} // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -15,6 +17,7 @@ pub trait Sized } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -27,6 +30,7 @@ opaque type core::ops::function::Fn::{vtable} opaque type core::ops::function::FnOnce::{vtable} // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { @@ -39,6 +43,7 @@ pub trait FnOnce opaque type core::ops::function::FnMut::{vtable} // Full name: core::ops::function::FnMut +#[fundamental] #[lang_item(FnMut)] pub trait FnMut { @@ -50,6 +55,7 @@ pub trait FnMut } // Full name: core::ops::function::Fn +#[fundamental] #[lang_item(Fn)] pub trait Fn { diff --git a/charon/tests/ui/monomorphization/generic-method.out b/charon/tests/ui/monomorphization/generic-method.out index 1d7b6557a..aa039c5de 100644 --- a/charon/tests/ui/monomorphization/generic-method.out +++ b/charon/tests/ui/monomorphization/generic-method.out @@ -4,6 +4,7 @@ opaque type {vtable} // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized diff --git a/charon/tests/ui/monomorphization/issue-1159-assoc-const.out b/charon/tests/ui/monomorphization/issue-1159-assoc-const.out index 3b417ada4..2d063c3fe 100644 --- a/charon/tests/ui/monomorphization/issue-1159-assoc-const.out +++ b/charon/tests/ui/monomorphization/issue-1159-assoc-const.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -16,6 +18,7 @@ pub trait Sized opaque type {vtable} // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized diff --git a/charon/tests/ui/monomorphization/issue-1262-defaulted-method-indirection.out b/charon/tests/ui/monomorphization/issue-1262-defaulted-method-indirection.out index 1939c1cd8..4a5f295d9 100644 --- a/charon/tests/ui/monomorphization/issue-1262-defaulted-method-indirection.out +++ b/charon/tests/ui/monomorphization/issue-1262-defaulted-method-indirection.out @@ -4,6 +4,7 @@ opaque type {vtable} // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized diff --git a/charon/tests/ui/monomorphization/issue-917-inline-const-with-poly-type.out b/charon/tests/ui/monomorphization/issue-917-inline-const-with-poly-type.out index f30804fa9..f98c22697 100644 --- a/charon/tests/ui/monomorphization/issue-917-inline-const-with-poly-type.out +++ b/charon/tests/ui/monomorphization/issue-917-inline-const-with-poly-type.out @@ -3,10 +3,12 @@ opaque type core::marker::MetaSized::{vtable} // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -23,6 +25,7 @@ pub trait Destruct } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -35,6 +38,7 @@ opaque type core::ops::function::Fn::{vtable} opaque type core::ops::function::FnOnce::{vtable} // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { @@ -47,6 +51,7 @@ pub trait FnOnce opaque type core::ops::function::FnMut::{vtable} // Full name: core::ops::function::FnMut +#[fundamental] #[lang_item(FnMut)] pub trait FnMut { @@ -58,6 +63,7 @@ pub trait FnMut } // Full name: core::ops::function::Fn +#[fundamental] #[lang_item(Fn)] pub trait Fn { diff --git a/charon/tests/ui/monomorphization/issue-922-assoc-const-with-default.out b/charon/tests/ui/monomorphization/issue-922-assoc-const-with-default.out index 27ae7dfc8..8ec836795 100644 --- a/charon/tests/ui/monomorphization/issue-922-assoc-const-with-default.out +++ b/charon/tests/ui/monomorphization/issue-922-assoc-const-with-default.out @@ -4,10 +4,12 @@ opaque type {vtable} // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/monomorphization/simpl-trait-assoc-types-2.out b/charon/tests/ui/monomorphization/simpl-trait-assoc-types-2.out index 6eaf49528..cfb7b4939 100644 --- a/charon/tests/ui/monomorphization/simpl-trait-assoc-types-2.out +++ b/charon/tests/ui/monomorphization/simpl-trait-assoc-types-2.out @@ -3,6 +3,7 @@ opaque type core::marker::MetaSized::{vtable} // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized diff --git a/charon/tests/ui/monomorphization/simple-trait-assoc-types-3.out b/charon/tests/ui/monomorphization/simple-trait-assoc-types-3.out index d39767b72..7acb2628b 100644 --- a/charon/tests/ui/monomorphization/simple-trait-assoc-types-3.out +++ b/charon/tests/ui/monomorphization/simple-trait-assoc-types-3.out @@ -3,6 +3,7 @@ opaque type core::marker::MetaSized::{vtable} // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized diff --git a/charon/tests/ui/monomorphization/simple-trait-assoc-types.out b/charon/tests/ui/monomorphization/simple-trait-assoc-types.out index 42e0b960d..d42423622 100644 --- a/charon/tests/ui/monomorphization/simple-trait-assoc-types.out +++ b/charon/tests/ui/monomorphization/simple-trait-assoc-types.out @@ -3,6 +3,7 @@ opaque type core::marker::MetaSized::{vtable} // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized diff --git a/charon/tests/ui/monomorphization/simple-trait-generics-2.out b/charon/tests/ui/monomorphization/simple-trait-generics-2.out index 949692e32..786bc60ee 100644 --- a/charon/tests/ui/monomorphization/simple-trait-generics-2.out +++ b/charon/tests/ui/monomorphization/simple-trait-generics-2.out @@ -3,10 +3,12 @@ opaque type core::marker::MetaSized::{vtable} // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/monomorphization/simple-trait-generics-assoc-2.out b/charon/tests/ui/monomorphization/simple-trait-generics-assoc-2.out index d499824b8..5570d03c1 100644 --- a/charon/tests/ui/monomorphization/simple-trait-generics-assoc-2.out +++ b/charon/tests/ui/monomorphization/simple-trait-generics-assoc-2.out @@ -3,10 +3,12 @@ opaque type core::marker::MetaSized::{vtable} // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/monomorphization/simple-trait-generics-assoc.out b/charon/tests/ui/monomorphization/simple-trait-generics-assoc.out index 1e2ece14a..98c180e5f 100644 --- a/charon/tests/ui/monomorphization/simple-trait-generics-assoc.out +++ b/charon/tests/ui/monomorphization/simple-trait-generics-assoc.out @@ -3,10 +3,12 @@ opaque type core::marker::MetaSized::{vtable} // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/monomorphization/simple-trait-generics.out b/charon/tests/ui/monomorphization/simple-trait-generics.out index 23ef04de8..29cc2ff85 100644 --- a/charon/tests/ui/monomorphization/simple-trait-generics.out +++ b/charon/tests/ui/monomorphization/simple-trait-generics.out @@ -3,10 +3,12 @@ opaque type core::marker::MetaSized::{vtable} // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/monomorphization/simple-trait-two-methods.out b/charon/tests/ui/monomorphization/simple-trait-two-methods.out index 2b0cc8521..3c4122dfd 100644 --- a/charon/tests/ui/monomorphization/simple-trait-two-methods.out +++ b/charon/tests/ui/monomorphization/simple-trait-two-methods.out @@ -3,6 +3,7 @@ opaque type core::marker::MetaSized::{vtable} // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized diff --git a/charon/tests/ui/monomorphization/simple_trait.out b/charon/tests/ui/monomorphization/simple_trait.out index deb6ce92f..35e8be24a 100644 --- a/charon/tests/ui/monomorphization/simple_trait.out +++ b/charon/tests/ui/monomorphization/simple_trait.out @@ -3,6 +3,7 @@ opaque type core::marker::MetaSized::{vtable} // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized diff --git a/charon/tests/ui/monomorphization/simple_trait_with_trait_alias.out b/charon/tests/ui/monomorphization/simple_trait_with_trait_alias.out index ebfe9f4a6..c5f21dbbd 100644 --- a/charon/tests/ui/monomorphization/simple_trait_with_trait_alias.out +++ b/charon/tests/ui/monomorphization/simple_trait_with_trait_alias.out @@ -3,6 +3,7 @@ opaque type core::marker::MetaSized::{vtable} // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized diff --git a/charon/tests/ui/monomorphization/simple_trait_with_trait_alias_generics.out b/charon/tests/ui/monomorphization/simple_trait_with_trait_alias_generics.out index 66abc14d2..f1a62a611 100644 --- a/charon/tests/ui/monomorphization/simple_trait_with_trait_alias_generics.out +++ b/charon/tests/ui/monomorphization/simple_trait_with_trait_alias_generics.out @@ -3,10 +3,12 @@ opaque type core::marker::MetaSized::{vtable} // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/monomorphization/unsatisfied-method-bounds.out b/charon/tests/ui/monomorphization/unsatisfied-method-bounds.out index 071b628bf..f2c22ebf5 100644 --- a/charon/tests/ui/monomorphization/unsatisfied-method-bounds.out +++ b/charon/tests/ui/monomorphization/unsatisfied-method-bounds.out @@ -3,6 +3,7 @@ opaque type core::marker::MetaSized::{vtable} // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized diff --git a/charon/tests/ui/monomorphization/vtable-blanket-impl.out b/charon/tests/ui/monomorphization/vtable-blanket-impl.out index d332fa84e..938f0a36a 100644 --- a/charon/tests/ui/monomorphization/vtable-blanket-impl.out +++ b/charon/tests/ui/monomorphization/vtable-blanket-impl.out @@ -3,6 +3,7 @@ opaque type core::marker::MetaSized::{vtable} // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized diff --git a/charon/tests/ui/monomorphization/vtable-lifetime-impl.out b/charon/tests/ui/monomorphization/vtable-lifetime-impl.out index 8a9b11ea4..3d3728196 100644 --- a/charon/tests/ui/monomorphization/vtable-lifetime-impl.out +++ b/charon/tests/ui/monomorphization/vtable-lifetime-impl.out @@ -3,6 +3,7 @@ opaque type core::marker::MetaSized::{vtable} // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized diff --git a/charon/tests/ui/monomorphization/vtable-ref-impl.out b/charon/tests/ui/monomorphization/vtable-ref-impl.out index f70a4d548..adeecab36 100644 --- a/charon/tests/ui/monomorphization/vtable-ref-impl.out +++ b/charon/tests/ui/monomorphization/vtable-ref-impl.out @@ -3,6 +3,7 @@ opaque type core::marker::MetaSized::{vtable} // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized diff --git a/charon/tests/ui/monomorphize-mut-no-types.out b/charon/tests/ui/monomorphize-mut-no-types.out index 8dfa108ec..a976a64ce 100644 --- a/charon/tests/ui/monomorphize-mut-no-types.out +++ b/charon/tests/ui/monomorphize-mut-no-types.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -12,9 +14,11 @@ pub trait Sized non-dyn-compatible } +#[fundamental] #[lang_item(MetaSized)] pub trait core::marker::MetaSized::<&_ mut _><'_0, T0> +#[fundamental] #[lang_item(Sized)] pub trait core::marker::Sized::<&_ mut _><'_0, T0> { @@ -22,9 +26,11 @@ pub trait core::marker::Sized::<&_ mut _><'_0, T0> non-dyn-compatible } +#[fundamental] #[lang_item(MetaSized)] pub trait core::marker::MetaSized::><'_0, T0> +#[fundamental] #[lang_item(Sized)] pub trait core::marker::Sized::><'_0, T0> { @@ -32,9 +38,11 @@ pub trait core::marker::Sized::><'_0, T0> non-dyn-compatible } +#[fundamental] #[lang_item(MetaSized)] pub trait core::marker::MetaSized::>><'_0, T0> +#[fundamental] #[lang_item(Sized)] pub trait core::marker::Sized::>><'_0, T0> { diff --git a/charon/tests/ui/monomorphize-mut.out b/charon/tests/ui/monomorphize-mut.out index 74a7b7c59..c5c3fa21c 100644 --- a/charon/tests/ui/monomorphize-mut.out +++ b/charon/tests/ui/monomorphize-mut.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -12,9 +14,11 @@ pub trait Sized non-dyn-compatible } +#[fundamental] #[lang_item(MetaSized)] pub trait core::marker::MetaSized::<&_ mut _><'_0, T0> +#[fundamental] #[lang_item(Sized)] pub trait core::marker::Sized::<&_ mut _><'_0, T0> { @@ -22,9 +26,11 @@ pub trait core::marker::Sized::<&_ mut _><'_0, T0> non-dyn-compatible } +#[fundamental] #[lang_item(MetaSized)] pub trait core::marker::MetaSized::<&_ mut &_ mut _><'_0, '_1, T0> +#[fundamental] #[lang_item(Sized)] pub trait core::marker::Sized::<&_ mut &_ mut _><'_0, '_1, T0> { @@ -32,11 +38,13 @@ pub trait core::marker::Sized::<&_ mut &_ mut _><'_0, '_1, T0> non-dyn-compatible } +#[fundamental] #[lang_item(MetaSized)] pub trait core::marker::MetaSized::<_, _>[TraitClause0]><'_0, T0> where TraitClause0: (T0: core::marker::Sized::<&_ mut _><'_0>), +#[fundamental] #[lang_item(Sized)] pub trait core::marker::Sized::<_, _>[TraitClause0]><'_0, T0> where @@ -46,12 +54,14 @@ where non-dyn-compatible } +#[fundamental] #[lang_item(MetaSized)] pub trait core::marker::MetaSized::<_, _>[TraitClause1]><_, _>[TraitClause0, TraitClause1]><'_0, T0> where TraitClause0: (T0: core::marker::Sized::<_, _>[TraitClause0]><'_0>[TraitClause1]), TraitClause1: (T0: core::marker::Sized::<&_ mut _><'_0>), +#[fundamental] #[lang_item(Sized)] pub trait core::marker::Sized::<_, _>[TraitClause1]><_, _>[TraitClause0, TraitClause1]><'_0, T0> where @@ -62,12 +72,14 @@ where non-dyn-compatible } +#[fundamental] #[lang_item(MetaSized)] pub trait core::marker::MetaSized::[TraitClause0]><'_0, T0> where TraitClause0: (T0: Sized), TypeOutlives0: T0: '_0, +#[fundamental] #[lang_item(Sized)] pub trait core::marker::Sized::[TraitClause0]><'_0, T0> where @@ -78,12 +90,14 @@ where non-dyn-compatible } +#[fundamental] #[lang_item(MetaSized)] pub trait core::marker::MetaSized::[TraitClause0]><'_0, T0> where TraitClause0: (T0: Sized), TypeOutlives0: T0: '_0, +#[fundamental] #[lang_item(Sized)] pub trait core::marker::Sized::[TraitClause0]><'_0, T0> where @@ -94,6 +108,7 @@ where non-dyn-compatible } +#[fundamental] #[lang_item(MetaSized)] pub trait core::marker::MetaSized::[TraitClause0]><'_0, T0> where @@ -101,6 +116,7 @@ where TypeOutlives0: T0: '_0, TypeOutlives1: T0: '_0, +#[fundamental] #[lang_item(Sized)] pub trait core::marker::Sized::[TraitClause0]><'_0, T0> where @@ -112,6 +128,7 @@ where non-dyn-compatible } +#[fundamental] #[lang_item(MetaSized)] pub trait core::marker::MetaSized::<_, _>[TraitClause0]><'_0, T0> where @@ -191,6 +208,7 @@ where } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -199,6 +217,7 @@ pub trait Tuple } // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { diff --git a/charon/tests/ui/multi-target/default-trait-assoc-const.out b/charon/tests/ui/multi-target/default-trait-assoc-const.out index 8a1f3c7e5..bf543345b 100644 --- a/charon/tests/ui/multi-target/default-trait-assoc-const.out +++ b/charon/tests/ui/multi-target/default-trait-assoc-const.out @@ -1,3 +1,4 @@ +#[fundamental] #[lang_item(MetaSized)] pub trait core::marker::MetaSized diff --git a/charon/tests/ui/multi-target/evaluate-consts-size-of.out b/charon/tests/ui/multi-target/evaluate-consts-size-of.out index 44a7cac47..9759e04b5 100644 --- a/charon/tests/ui/multi-target/evaluate-consts-size-of.out +++ b/charon/tests/ui/multi-target/evaluate-consts-size-of.out @@ -1,5 +1,6 @@ opaque type core::marker::MetaSized::{vtable} +#[fundamental] #[lang_item(MetaSized)] pub trait core::marker::MetaSized diff --git a/charon/tests/ui/multi-target/issue-1182-dedup-impls.out b/charon/tests/ui/multi-target/issue-1182-dedup-impls.out index 1bec5fb22..8d827da44 100644 --- a/charon/tests/ui/multi-target/issue-1182-dedup-impls.out +++ b/charon/tests/ui/multi-target/issue-1182-dedup-impls.out @@ -1,3 +1,4 @@ +#[fundamental] #[lang_item(MetaSized)] pub trait core::marker::MetaSized diff --git a/charon/tests/ui/multi-target/issue-1213-merge-methods-when-missing-simple.out b/charon/tests/ui/multi-target/issue-1213-merge-methods-when-missing-simple.out index 21a673f24..07642b87d 100644 --- a/charon/tests/ui/multi-target/issue-1213-merge-methods-when-missing-simple.out +++ b/charon/tests/ui/multi-target/issue-1213-merge-methods-when-missing-simple.out @@ -1,6 +1,8 @@ +#[fundamental] #[lang_item(MetaSized)] pub trait core::marker::MetaSized +#[fundamental] #[lang_item(Sized)] pub trait core::marker::Sized { @@ -8,6 +10,7 @@ pub trait core::marker::Sized non-dyn-compatible } +#[charon::opaque] trait test_crate::Trait { proof ImpliedClause0: (Self: core::marker::MetaSized) diff --git a/charon/tests/ui/multi-target/issue-1213-merge-methods-when-missing.out b/charon/tests/ui/multi-target/issue-1213-merge-methods-when-missing.out index 22ad233f2..b8f2c8636 100644 --- a/charon/tests/ui/multi-target/issue-1213-merge-methods-when-missing.out +++ b/charon/tests/ui/multi-target/issue-1213-merge-methods-when-missing.out @@ -1,6 +1,8 @@ +#[fundamental] #[lang_item(MetaSized)] pub trait core::marker::MetaSized +#[fundamental] #[lang_item(Sized)] pub trait core::marker::Sized { diff --git a/charon/tests/ui/multi-target/issue-1307-required-method.out b/charon/tests/ui/multi-target/issue-1307-required-method.out index 06d0dc5fe..8d81faf3f 100644 --- a/charon/tests/ui/multi-target/issue-1307-required-method.out +++ b/charon/tests/ui/multi-target/issue-1307-required-method.out @@ -1,6 +1,8 @@ +#[fundamental] #[lang_item(MetaSized)] pub trait core::marker::MetaSized +#[fundamental] #[lang_item(Sized)] pub trait core::marker::Sized { diff --git a/charon/tests/ui/multi-target/multi-target-from-symcrypt.out b/charon/tests/ui/multi-target/multi-target-from-symcrypt.out index da8850e14..5dbbe26b4 100644 --- a/charon/tests/ui/multi-target/multi-target-from-symcrypt.out +++ b/charon/tests/ui/multi-target/multi-target-from-symcrypt.out @@ -9,9 +9,11 @@ pub unsafe fn core::core_arch::aarch64::neon::generated::vst1q_u16(_1: *mut u16, pub unsafe fn core::core_arch::arm_shared::neon::generated::vaddq_u16(_1: core::core_arch::arm_shared::neon::uint16x8_t, _2: core::core_arch::arm_shared::neon::uint16x8_t) -> core::core_arch::arm_shared::neon::uint16x8_t = +#[fundamental] #[lang_item(MetaSized)] pub trait core::marker::MetaSized +#[fundamental] #[lang_item(Sized)] pub trait core::marker::Sized { diff --git a/charon/tests/ui/multi-target/multi-targets-file-ids.out b/charon/tests/ui/multi-target/multi-targets-file-ids.out index 91af2266a..a627a97ff 100644 --- a/charon/tests/ui/multi-target/multi-targets-file-ids.out +++ b/charon/tests/ui/multi-target/multi-targets-file-ids.out @@ -9,9 +9,11 @@ pub unsafe fn core::core_arch::aarch64::neon::generated::vst1q_u16(_1: *mut u16, pub unsafe fn core::core_arch::arm_shared::neon::generated::vaddq_u16(_1: core::core_arch::arm_shared::neon::uint16x8_t, _2: core::core_arch::arm_shared::neon::uint16x8_t) -> core::core_arch::arm_shared::neon::uint16x8_t = +#[fundamental] #[lang_item(MetaSized)] pub trait core::marker::MetaSized +#[fundamental] #[lang_item(Sized)] pub trait core::marker::Sized { diff --git a/charon/tests/ui/no_nested_borrows.out b/charon/tests/ui/no_nested_borrows.out index 0ad0c4c61..357fa500f 100644 --- a/charon/tests/ui/no_nested_borrows.out +++ b/charon/tests/ui/no_nested_borrows.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -335,6 +337,7 @@ pub fn cast_bool_to_bool(x: bool) -> bool } // Full name: test_crate::test2 +#[allow(unused_variables)] pub fn test2() { let _0: (); // return @@ -452,6 +455,7 @@ pub fn get_max(x: u32, y: u32) -> u32 } // Full name: test_crate::test_list1 +#[allow(unused_variables)] pub fn test_list1() { let _0: (); // return diff --git a/charon/tests/ui/nondiverging-intrinsics.out b/charon/tests/ui/nondiverging-intrinsics.out index 3cb5fcfcb..02d761f75 100644 --- a/charon/tests/ui/nondiverging-intrinsics.out +++ b/charon/tests/ui/nondiverging-intrinsics.out @@ -1,14 +1,17 @@ # Final LLBC before serialization: // Full name: core::intrinsics::assume +#[rustc_intrinsic] pub unsafe fn assume(b_1: bool) = // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -17,6 +20,7 @@ pub trait Sized } // Full name: core::intrinsics::copy_nonoverlapping +#[rustc_intrinsic] pub unsafe fn copy_nonoverlapping(src_1: *const T, dst_2: *mut T, count_3: usize) where TraitClause0: (T: Sized), diff --git a/charon/tests/ui/params.out b/charon/tests/ui/params.out index badb37c07..d627b916e 100644 --- a/charon/tests/ui/params.out +++ b/charon/tests/ui/params.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/partial-monomorphization/issue-1204-partial-mono-tuples.out b/charon/tests/ui/partial-monomorphization/issue-1204-partial-mono-tuples.out index db7f6cb78..63025ac53 100644 --- a/charon/tests/ui/partial-monomorphization/issue-1204-partial-mono-tuples.out +++ b/charon/tests/ui/partial-monomorphization/issue-1204-partial-mono-tuples.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -12,9 +14,11 @@ pub trait Sized non-dyn-compatible } +#[fundamental] #[lang_item(MetaSized)] pub trait core::marker::MetaSized::<(&_ mut _, &_ mut _)><'_0, '_1, T0, T1> +#[fundamental] #[lang_item(Sized)] pub trait core::marker::Sized::<(&_ mut _, &_ mut _)><'_0, '_1, T0, T1> { diff --git a/charon/tests/ui/polonius_map.out b/charon/tests/ui/polonius_map.out index aba2c4b0c..6089341f2 100644 --- a/charon/tests/ui/polonius_map.out +++ b/charon/tests/ui/polonius_map.out @@ -1,6 +1,7 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized @@ -67,6 +68,7 @@ impl "impl_Eq_for_u32" Eq for u32 { } // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/predicates-on-late-bound-vars.out b/charon/tests/ui/predicates-on-late-bound-vars.out index dbbc7a02e..115df423c 100644 --- a/charon/tests/ui/predicates-on-late-bound-vars.out +++ b/charon/tests/ui/predicates-on-late-bound-vars.out @@ -1,6 +1,7 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized @@ -11,9 +12,11 @@ where TraitClause0: (T: MetaSized), // Full name: core::cell::BorrowError +#[non_exhaustive] pub struct BorrowError {} // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/ptr-offset.out b/charon/tests/ui/ptr-offset.out index f244fa2f9..31c21793b 100644 --- a/charon/tests/ui/ptr-offset.out +++ b/charon/tests/ui/ptr-offset.out @@ -5,10 +5,12 @@ pub fn addr(_1: *const T) -> usize = // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -127,6 +129,7 @@ where = // Full name: core::panicking::panic_nounwind_fmt +#[track_caller] pub fn panic_nounwind_fmt<'_0>(_1: Arguments<'_0>, _2: bool) -> ! = @@ -171,6 +174,7 @@ fn runtime_offset_nowrap(this: *const (), count: isize, size: usize) -> bool } // Full name: core::ptr::const_ptr::{*const T}::offset::precondition_check +#[track_caller] fn precondition_check(this: *const (), count: isize, size: usize) { let _0: (); // return @@ -241,6 +245,7 @@ fn precondition_check(this: *const (), count: isize, size: usize) } // Full name: core::ptr::const_ptr::{*const T}::offset +#[track_caller] pub unsafe fn offset(self: *const T, count: isize) -> *const T where TraitClause0: (T: Sized), diff --git a/charon/tests/ui/ptr_no_provenance.out b/charon/tests/ui/ptr_no_provenance.out index 1ba6be5fa..6c9c39d6a 100644 --- a/charon/tests/ui/ptr_no_provenance.out +++ b/charon/tests/ui/ptr_no_provenance.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/quantified-clause.out b/charon/tests/ui/quantified-clause.out index 012d22411..40a31f71d 100644 --- a/charon/tests/ui/quantified-clause.out +++ b/charon/tests/ui/quantified-clause.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -80,6 +82,7 @@ pub trait Destruct } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -88,6 +91,7 @@ pub trait Tuple } // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { @@ -101,6 +105,7 @@ pub trait FnOnce } // Full name: core::ops::function::FnMut +#[fundamental] #[lang_item(FnMut)] pub trait FnMut { diff --git a/charon/tests/ui/raw-boxes.out b/charon/tests/ui/raw-boxes.out index 67eb760db..431138620 100644 --- a/charon/tests/ui/raw-boxes.out +++ b/charon/tests/ui/raw-boxes.out @@ -168,6 +168,7 @@ where return } +#[track_caller] fn core::ptr::write_bytes::precondition_check(addr: *const (), align: usize, zero_size: bool) { let _0: (); // return @@ -401,6 +402,7 @@ where Some { _0: T }, } +#[track_caller] fn core::mem::alignment::{Alignment}::new_unchecked::precondition_check(align: usize) { let _0: (); // return @@ -440,6 +442,7 @@ fn core::mem::alignment::{Alignment}::new_unchecked::precondition_check(align: u return } +#[track_caller] pub unsafe fn core::mem::alignment::{Alignment}::new_unchecked(align: usize) -> Alignment { let _0: Alignment; // return @@ -599,6 +602,7 @@ where return } +#[track_caller] #[diagnostic_item("ptr_write_bytes")] pub unsafe fn core::ptr::write_bytes(dst: *mut T, val: u8, count: usize) where @@ -670,6 +674,7 @@ where return } +#[track_caller] pub unsafe fn core::ptr::mut_ptr::{*mut T}::write_bytes(self: *mut T, val: u8, count: usize) where TraitClause0: (T: Sized), @@ -824,6 +829,7 @@ where return } +#[track_caller] fn core::ptr::copy_nonoverlapping::precondition_check(src: *const (), dst: *mut (), size: usize, align: usize, count: usize) { let _0: (); // return @@ -967,6 +973,7 @@ where return } +#[track_caller] #[diagnostic_item("ptr_copy_nonoverlapping")] pub unsafe fn core::ptr::copy_nonoverlapping(src: *const T, dst: *mut T, count: usize) where @@ -1783,6 +1790,7 @@ pub fn core::ptr::const_ptr::{*const T}::is_null(self: *const T) -> bool } // Full name: core::ptr::read +#[track_caller] #[diagnostic_item("ptr_read")] pub unsafe fn read(src: *const T) -> T where @@ -1845,6 +1853,7 @@ pub fn core::ptr::mut_ptr::{*mut T}::is_null(self: *mut T) -> bool return } +#[track_caller] fn core::ptr::non_null::{NonNull}::new_unchecked::precondition_check(ptr: *mut ()) { let _0: (); // return @@ -1884,6 +1893,7 @@ fn core::ptr::non_null::{NonNull}::new_unchecked::precondition_check(ptr: *mu ↳⚡ undefined_behavior } +#[track_caller] pub unsafe fn core::ptr::non_null::{NonNull}::new_unchecked(ptr: *mut T) -> NonNull { let _0: NonNull; // return @@ -2015,6 +2025,7 @@ where } // Full name: alloc::boxed::Box +#[fundamental] #[lang_item(OwnedBox)] pub struct Box where @@ -2158,6 +2169,7 @@ where } // Full name: alloc::boxed::box_new_uninit +#[track_caller] fn box_new_uninit(layout: Layout) -> *mut u8 { let _0: *mut u8; // return @@ -2215,6 +2227,7 @@ fn box_new_uninit(layout: Layout) -> *mut u8 return } +#[track_caller] #[diagnostic_item("box_new")] pub fn alloc::boxed::{Box[TraitClause0::ImpliedClause0, {built_in impl Sized for Global}, {impl#0}]}::new(x: T) -> Box[TraitClause0::ImpliedClause0, {built_in impl Sized for Global}, {impl#0}] where diff --git a/charon/tests/ui/region-inference-vars.out b/charon/tests/ui/region-inference-vars.out index 6f0f71d2d..e665fe2aa 100644 --- a/charon/tests/ui/region-inference-vars.out +++ b/charon/tests/ui/region-inference-vars.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/regressions/invalid-reconstruct-assert.out b/charon/tests/ui/regressions/invalid-reconstruct-assert.out index e18f88384..c7dc15c7f 100644 --- a/charon/tests/ui/regressions/invalid-reconstruct-assert.out +++ b/charon/tests/ui/regressions/invalid-reconstruct-assert.out @@ -21,10 +21,12 @@ pub trait Destruct } // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -40,10 +42,12 @@ where = // Full name: core::intrinsics::assume +#[rustc_intrinsic] pub unsafe fn assume(b_1: bool) = // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -52,6 +56,7 @@ pub trait Tuple } // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { @@ -65,6 +70,7 @@ pub trait FnOnce } // Full name: core::ops::function::FnMut +#[fundamental] #[lang_item(FnMut)] pub trait FnMut { @@ -87,10 +93,12 @@ where Err { _0: E }, } +#[track_caller] fn core::hint::assert_unchecked::precondition_check(_1: bool) = // Full name: core::slice::index::{impl SliceIndex<[T]> for usize}::get_unchecked::precondition_check +#[track_caller] fn impl_SliceIndex_slice_for_usize::get_unchecked::precondition_check(_1: usize, _2: usize) = diff --git a/charon/tests/ui/regressions/issue-1010-missing-lifetime.out b/charon/tests/ui/regressions/issue-1010-missing-lifetime.out index 196f456fc..f7d8cf05b 100644 --- a/charon/tests/ui/regressions/issue-1010-missing-lifetime.out +++ b/charon/tests/ui/regressions/issue-1010-missing-lifetime.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -21,6 +23,7 @@ pub trait Destruct } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -29,6 +32,7 @@ pub trait Tuple } // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { @@ -42,6 +46,7 @@ pub trait FnOnce } // Full name: core::ops::function::FnMut +#[fundamental] #[lang_item(FnMut)] pub trait FnMut { @@ -54,6 +59,7 @@ pub trait FnMut } // Full name: core::ops::function::Fn +#[fundamental] #[lang_item(Fn)] pub trait Fn { diff --git a/charon/tests/ui/regressions/issue-1067-filename-ice.out b/charon/tests/ui/regressions/issue-1067-filename-ice.out index 072d3cdf7..4342abfc1 100644 --- a/charon/tests/ui/regressions/issue-1067-filename-ice.out +++ b/charon/tests/ui/regressions/issue-1067-filename-ice.out @@ -9,10 +9,12 @@ impl "impl_Debug_for_Error" Debug for Error { } // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -41,6 +43,7 @@ where = // Full name: core::result::{Result[TraitClause0, TraitClause1]}::unwrap +#[track_caller] pub fn unwrap(_1: Result[TraitClause0, TraitClause1]) -> T where TraitClause0: (T: Sized), diff --git a/charon/tests/ui/regressions/issue-1074-vtable-supertrait.out b/charon/tests/ui/regressions/issue-1074-vtable-supertrait.out index fe44485c6..625ad304f 100644 --- a/charon/tests/ui/regressions/issue-1074-vtable-supertrait.out +++ b/charon/tests/ui/regressions/issue-1074-vtable-supertrait.out @@ -9,6 +9,7 @@ pub trait Send opaque type core::marker::MetaSized::{vtable} // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized diff --git a/charon/tests/ui/regressions/issue-1089-inline-const-precise-drops.out b/charon/tests/ui/regressions/issue-1089-inline-const-precise-drops.out index 6a9cfe83b..5451dff20 100644 --- a/charon/tests/ui/regressions/issue-1089-inline-const-precise-drops.out +++ b/charon/tests/ui/regressions/issue-1089-inline-const-precise-drops.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/regressions/issue-1236-vtable-fn-ptr.out b/charon/tests/ui/regressions/issue-1236-vtable-fn-ptr.out index 0ea4b7c40..b1c651c73 100644 --- a/charon/tests/ui/regressions/issue-1236-vtable-fn-ptr.out +++ b/charon/tests/ui/regressions/issue-1236-vtable-fn-ptr.out @@ -3,6 +3,7 @@ opaque type core::marker::MetaSized::{vtable} // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized diff --git a/charon/tests/ui/regressions/issue-1294-remove-clause-underflow.out b/charon/tests/ui/regressions/issue-1294-remove-clause-underflow.out index 58090356c..359a36421 100644 --- a/charon/tests/ui/regressions/issue-1294-remove-clause-underflow.out +++ b/charon/tests/ui/regressions/issue-1294-remove-clause-underflow.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/regressions/issue-1297-box-new-allocator-ty.out b/charon/tests/ui/regressions/issue-1297-box-new-allocator-ty.out index 7bc1eaa98..b2921dbae 100644 --- a/charon/tests/ui/regressions/issue-1297-box-new-allocator-ty.out +++ b/charon/tests/ui/regressions/issue-1297-box-new-allocator-ty.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/regressions/issue-393-vec-with-control-flow.out b/charon/tests/ui/regressions/issue-393-vec-with-control-flow.out index 73cc52c31..60d6f2ebe 100644 --- a/charon/tests/ui/regressions/issue-393-vec-with-control-flow.out +++ b/charon/tests/ui/regressions/issue-393-vec-with-control-flow.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -43,6 +45,7 @@ where = // Full name: alloc::boxed::{alloc::boxed::Box[TraitClause0::ImpliedClause0, {built_in impl Sized for Global}]}::new_uninit +#[track_caller] pub fn new_uninit() -> alloc::boxed::Box[TraitClause0]>[{built_in impl MetaSized for MaybeUninit[TraitClause0]}, {built_in impl Sized for Global}] where TraitClause0: (T: Sized), diff --git a/charon/tests/ui/regressions/issue-792-trait-ref-panic-when-tracing.out b/charon/tests/ui/regressions/issue-792-trait-ref-panic-when-tracing.out index 89ca56074..982ecd398 100644 --- a/charon/tests/ui/regressions/issue-792-trait-ref-panic-when-tracing.out +++ b/charon/tests/ui/regressions/issue-792-trait-ref-panic-when-tracing.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/regressions/issue-967-assoc-type-coherence.out b/charon/tests/ui/regressions/issue-967-assoc-type-coherence.out index 89711f7ed..f9a369454 100644 --- a/charon/tests/ui/regressions/issue-967-assoc-type-coherence.out +++ b/charon/tests/ui/regressions/issue-967-assoc-type-coherence.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/rename_attribute.out b/charon/tests/ui/rename_attribute.out index 78cdf9043..bf1911e63 100644 --- a/charon/tests/ui/rename_attribute.out +++ b/charon/tests/ui/rename_attribute.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -13,6 +15,7 @@ pub trait Sized } // Full name: test_crate::BoolTrait +#[charon::rename("BoolTest")] pub trait BoolTrait { proof ImpliedClause0: (Self: MetaSized) @@ -21,6 +24,7 @@ pub trait BoolTrait vtable: test_crate::BoolTrait::{vtable} } +#[charon::rename("retTest")] pub fn test_crate::BoolTrait::ret_true<'_0, Self>(self: &'_0 Self) -> bool where TraitClause0: (Self: BoolTrait), @@ -48,6 +52,7 @@ pub fn get_bool<'_0>(self: &'_0 bool) -> bool } // Full name: test_crate::{impl BoolTrait for bool}::ret_true +#[charon::rename("retTest")] pub fn impl_BoolTrait_for_bool::ret_true<'_0>(self: &'_0 bool) -> bool { let _0: bool; // return @@ -68,6 +73,7 @@ impl "impl_BoolTrait_for_bool" BoolTrait for bool { } // Full name: test_crate::test_bool_trait +#[charon::rename("BoolFn")] pub fn test_bool_trait(x: bool) -> bool where TraitClause0: (T: Sized), @@ -106,9 +112,11 @@ where } // Full name: test_crate::Test +#[charon::rename("TypeTest")] type Test = i32 // Full name: test_crate::SimpleEnum +#[charon::rename("VariantsTest")] enum SimpleEnum { FirstVariant, SecondVariant, @@ -116,11 +124,13 @@ enum SimpleEnum { } // Full name: test_crate::Foo +#[charon::rename("StructTest")] struct Foo { field1: u32, } // Full name: test_crate::C +#[charon::rename("Const_Test")] fn C() -> u32 { let _0: u32; // return @@ -141,9 +151,11 @@ fn C() -> u32 } // Full name: test_crate::C +#[charon::rename("Const_Test")] const C: u32 = C() // Full name: test_crate::Test2 +#[charon::rename("_TypeAeneas36")] type Test2 = u32 diff --git a/charon/tests/ui/result-unwrap.out b/charon/tests/ui/result-unwrap.out index 7492cc30d..f3f5a8f97 100644 --- a/charon/tests/ui/result-unwrap.out +++ b/charon/tests/ui/result-unwrap.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -32,9 +34,11 @@ where } // Full name: core::result::unwrap_failed +#[track_caller] fn unwrap_failed<'_0, '_1>(_1: &'_0 str, _2: &'_1 (dyn Debug + '_1)) -> ! = +#[track_caller] pub fn core::result::{Result[TraitClause0, TraitClause1]}::unwrap(self: Result[TraitClause0, TraitClause1]) -> T where TraitClause0: (T: Sized), diff --git a/charon/tests/ui/rust-name-matcher-tests.out b/charon/tests/ui/rust-name-matcher-tests.out index 34521376c..77b92de14 100644 --- a/charon/tests/ui/rust-name-matcher-tests.out +++ b/charon/tests/ui/rust-name-matcher-tests.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -36,6 +38,16 @@ where pub struct Global {} // Full name: test_crate::foo::bar +#[pattern::fail("test_crate::foo::bar::_")] +#[pattern::pass("test_crate::foo::bar")] +#[pattern::pass("test_crate::foo::_")] +#[pattern::pass("test_crate::foo")] +#[pattern::pass("test_crate")] +#[pattern::pass("test_crate::_")] +#[pattern::pass("test_crate::_::bar")] +#[pattern::fail("test_crate::_::lsdkfjs")] +#[pattern::pass("crate::foo::bar")] +#[pattern::fail("foo::bar")] fn bar() { let _0: (); // return @@ -47,6 +59,9 @@ fn bar() } // Full name: test_crate::Trait +#[pattern::pass("test_crate::Trait")] +#[pattern::fail("test_crate::Trait<_>")] +#[pattern::pass("test_crate::Trait<_, _>")] trait Trait { proof ImpliedClause0: (Self: MetaSized) @@ -56,6 +71,12 @@ trait Trait } // Full name: test_crate::{impl Trait[TraitClause0]> for alloc::boxed::Box[TraitClause0::ImpliedClause0, {built_in impl Sized for Global}]}::method +#[pattern::pass("test_crate::{impl test_crate::Trait<_> for _}::method")] +#[pattern::pass("{impl test_crate::Trait<_> for _}::method")] +#[pattern::pass("test_crate::{impl test_crate::Trait<_> for _}::_")] +#[pattern::pass("test_crate::{impl test_crate::Trait<_> for _}")] +#[pattern::pass("test_crate::{impl test_crate::Trait<_, _>}"::method)] +#[pattern::fail("test_crate::Trait<_>::method")] fn impl_Trait_Option_for_Box_Global::method() where TraitClause0: (T: Sized), @@ -140,6 +161,8 @@ where } // Full name: test_crate::{Generic[TraitClause0]}::new +#[pattern::pass("test_crate::_::new")] +#[pattern::pass("_::_::new")] fn new(value: T) -> Generic[TraitClause0] where TraitClause0: (T: Sized), @@ -163,6 +186,7 @@ where } // Full name: test_crate::{Generic[TraitClause0]}::get +#[pattern::pass("test_crate::_::get")] fn get<'_0, T>(self: &'_0 Generic[TraitClause0]) -> &'_0 T where TraitClause0: (T: Sized), @@ -181,6 +205,7 @@ where } // Full name: test_crate::use_generic +#[pattern::pass("test_crate::use_generic")] fn use_generic() { let _0: (); // return diff --git a/charon/tests/ui/rvalues.out b/charon/tests/ui/rvalues.out index a7e232e0b..d5b3c7403 100644 --- a/charon/tests/ui/rvalues.out +++ b/charon/tests/ui/rvalues.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -21,6 +23,7 @@ pub trait Destruct } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -57,6 +60,7 @@ pub fn MIN() -> f64 pub const MIN: f64 = MIN() // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { @@ -70,6 +74,7 @@ pub trait FnOnce } // Full name: core::ops::function::FnMut +#[fundamental] #[lang_item(FnMut)] pub trait FnMut { @@ -82,6 +87,7 @@ pub trait FnMut } // Full name: core::ops::function::Fn +#[fundamental] #[lang_item(Fn)] pub trait Fn { diff --git a/charon/tests/ui/scopes.out b/charon/tests/ui/scopes.out index 83c627ab5..74d7fb911 100644 --- a/charon/tests/ui/scopes.out +++ b/charon/tests/ui/scopes.out @@ -1,6 +1,7 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized @@ -13,6 +14,7 @@ trait Trait<'a, Self> } // Full name: test_crate::{impl Trait<'a> for &'a ()}::method +#[charon::opaque] fn method<'a, 'b>(_1: &'b &'a ()) -> &'b () where RegionOutlives0: 'a: 'b, @@ -26,21 +28,26 @@ impl<'a> Trait<'a> for &'a () { } // Full name: test_crate::Foo +#[charon::opaque] opaque type Foo<'a> +#[charon::opaque] fn test_crate::{Foo<'_0>}::bar<'_0, '_1>(_1: &'_1 Foo<'_0>) -> &'_1 () where RegionOutlives0: '_0: '_1, = // Full name: test_crate::foo +#[charon::opaque] fn foo<'_0>(_1: &'_0 fn<'_0_1>(&'_0_1 u32) -> u32) = +#[charon::opaque] fn test_crate::bar<'_0>(_1: &'_0 fn<'_0_1>(&'_0_1 fn<'_0_2>(&'_0_2 u32) -> u32)) = // Full name: test_crate::baz +#[charon::opaque] fn baz<'a>(_1: &'a fn<'b>(&'a u32, &'b fn<'c>(&'a u32, &'b u32, &'c u32) -> u32)) = diff --git a/charon/tests/ui/send_bound.out b/charon/tests/ui/send_bound.out index 692f4f74f..c56ad3f31 100644 --- a/charon/tests/ui/send_bound.out +++ b/charon/tests/ui/send_bound.out @@ -5,10 +5,12 @@ pub trait Send // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/additions.out b/charon/tests/ui/simple/additions.out index 29d0d3111..2896ee8dc 100644 --- a/charon/tests/ui/simple/additions.out +++ b/charon/tests/ui/simple/additions.out @@ -9,10 +9,12 @@ pub trait Destruct } // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -131,6 +133,7 @@ pub trait Copy non-dyn-compatible } +#[rustc_intrinsic] pub fn core::intrinsics::saturating_add(a_1: T, b_2: T) -> T where TraitClause0: (T: Sized), diff --git a/charon/tests/ui/simple/alias-ty-missing-hrtb.out b/charon/tests/ui/simple/alias-ty-missing-hrtb.out index c96264550..d8bedbaa5 100644 --- a/charon/tests/ui/simple/alias-ty-missing-hrtb.out +++ b/charon/tests/ui/simple/alias-ty-missing-hrtb.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/assoc-const-with-self-clause.out b/charon/tests/ui/simple/assoc-const-with-self-clause.out index 5bbdadf88..a83aaf153 100644 --- a/charon/tests/ui/simple/assoc-const-with-self-clause.out +++ b/charon/tests/ui/simple/assoc-const-with-self-clause.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/box-deref-elaborated.out b/charon/tests/ui/simple/box-deref-elaborated.out index 92b1df770..232f09417 100644 --- a/charon/tests/ui/simple/box-deref-elaborated.out +++ b/charon/tests/ui/simple/box-deref-elaborated.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/box-deref-optimized.out b/charon/tests/ui/simple/box-deref-optimized.out index 92b1df770..232f09417 100644 --- a/charon/tests/ui/simple/box-deref-optimized.out +++ b/charon/tests/ui/simple/box-deref-optimized.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/box-dyn-fnonce-raw.out b/charon/tests/ui/simple/box-dyn-fnonce-raw.out index 6f0b0916a..135a11b2c 100644 --- a/charon/tests/ui/simple/box-dyn-fnonce-raw.out +++ b/charon/tests/ui/simple/box-dyn-fnonce-raw.out @@ -11,6 +11,7 @@ pub fn size<'_0>(_1: &'_0 Layout) -> usize opaque type core::marker::MetaSized::{vtable} // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized @@ -24,6 +25,7 @@ where pub struct AllocError {} // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -64,6 +66,7 @@ pub trait Destruct } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -187,6 +190,7 @@ struct core::ops::function::FnOnce::{vtable} { } // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { @@ -227,10 +231,12 @@ where pub struct Global {} // Full name: alloc::alloc::{impl Allocator for Global}::deallocate +#[track_caller] pub unsafe fn deallocate<'_0>(_1: &'_0 Global, _2: NonNull, _3: Layout) = // Full name: alloc::alloc::{impl Allocator for Global}::allocate +#[track_caller] pub fn allocate<'_0>(_1: &'_0 Global, _2: Layout) -> Result, AllocError>[{built_in impl Sized for NonNull<[u8]>}, {built_in impl Sized for AllocError}] = @@ -247,6 +253,7 @@ pub fn handle_alloc_error(_1: Layout) -> ! = // Full name: alloc::boxed::Box +#[fundamental] #[lang_item(OwnedBox)] pub struct Box where @@ -390,6 +397,7 @@ where } // Full name: alloc::boxed::box_new_uninit +#[track_caller] fn box_new_uninit(layout: Layout) -> *mut u8 { let _0: *mut u8; // return @@ -448,6 +456,7 @@ fn box_new_uninit(layout: Layout) -> *mut u8 } // Full name: alloc::boxed::{Box[TraitClause0::ImpliedClause0, {built_in impl Sized for Global}, impl_Allocator_for_Global]}::new +#[track_caller] #[diagnostic_item("box_new")] pub fn new(x: T) -> Box[TraitClause0::ImpliedClause0, {built_in impl Sized for Global}, impl_Allocator_for_Global] where diff --git a/charon/tests/ui/simple/box-new.out b/charon/tests/ui/simple/box-new.out index 7509374a4..5ffdc955b 100644 --- a/charon/tests/ui/simple/box-new.out +++ b/charon/tests/ui/simple/box-new.out @@ -8,10 +8,12 @@ pub opaque type Layout pub struct AllocError {} // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -48,10 +50,12 @@ pub trait Allocator pub struct Global {} // Full name: alloc::alloc::{impl Allocator for Global}::deallocate +#[track_caller] pub unsafe fn deallocate<'_0>(_1: &'_0 Global, _2: NonNull, _3: Layout) = // Full name: alloc::alloc::{impl Allocator for Global}::allocate +#[track_caller] pub fn allocate<'_0>(_1: &'_0 Global, _2: Layout) -> Result, AllocError>[{built_in impl Sized for NonNull<[u8]>}, {built_in impl Sized for AllocError}] = @@ -64,6 +68,7 @@ impl "impl_Allocator_for_Global" Allocator for Global { } // Full name: alloc::boxed::Box +#[fundamental] #[lang_item(OwnedBox)] pub opaque type Box where @@ -82,6 +87,7 @@ where = // Full name: alloc::boxed::{Box[TraitClause0::ImpliedClause0, {built_in impl Sized for Global}, impl_Allocator_for_Global]}::new +#[track_caller] #[diagnostic_item("box_new")] pub fn new(_1: T) -> Box[TraitClause0::ImpliedClause0, {built_in impl Sized for Global}, impl_Allocator_for_Global] where diff --git a/charon/tests/ui/simple/builtin-drop-mono.out b/charon/tests/ui/simple/builtin-drop-mono.out index 2530e231c..936cd7264 100644 --- a/charon/tests/ui/simple/builtin-drop-mono.out +++ b/charon/tests/ui/simple/builtin-drop-mono.out @@ -4,10 +4,12 @@ opaque type {vtable} // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/builtin-drop.out b/charon/tests/ui/simple/builtin-drop.out index eeb5fd65d..a360ec45a 100644 --- a/charon/tests/ui/simple/builtin-drop.out +++ b/charon/tests/ui/simple/builtin-drop.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/call-foreign-defaulted-method.out b/charon/tests/ui/simple/call-foreign-defaulted-method.out index 235cba7f8..10b3a6f5d 100644 --- a/charon/tests/ui/simple/call-foreign-defaulted-method.out +++ b/charon/tests/ui/simple/call-foreign-defaulted-method.out @@ -1,6 +1,7 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized diff --git a/charon/tests/ui/simple/call-inherent-method-with-trait-bound.out b/charon/tests/ui/simple/call-inherent-method-with-trait-bound.out index a482b1bfb..d5830f456 100644 --- a/charon/tests/ui/simple/call-inherent-method-with-trait-bound.out +++ b/charon/tests/ui/simple/call-inherent-method-with-trait-bound.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/call-method-via-supertrait-bound.out b/charon/tests/ui/simple/call-method-via-supertrait-bound.out index 36d04f118..4cd605578 100644 --- a/charon/tests/ui/simple/call-method-via-supertrait-bound.out +++ b/charon/tests/ui/simple/call-method-via-supertrait-bound.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/catch-unwind.out b/charon/tests/ui/simple/catch-unwind.out index bf2fda3b2..ea9393985 100644 --- a/charon/tests/ui/simple/catch-unwind.out +++ b/charon/tests/ui/simple/catch-unwind.out @@ -3,6 +3,7 @@ opaque type core::any::Any::{vtable} // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized @@ -26,6 +27,7 @@ where pub trait Send // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -34,6 +36,7 @@ pub trait Sized } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -42,6 +45,7 @@ pub trait Tuple } // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { diff --git a/charon/tests/ui/simple/closure-capture-ref-by-move.out b/charon/tests/ui/simple/closure-capture-ref-by-move.out index 03c1be153..3ac69d5cb 100644 --- a/charon/tests/ui/simple/closure-capture-ref-by-move.out +++ b/charon/tests/ui/simple/closure-capture-ref-by-move.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -21,6 +23,7 @@ pub trait Destruct } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -29,6 +32,7 @@ pub trait Tuple } // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { @@ -42,6 +46,7 @@ pub trait FnOnce } // Full name: core::ops::function::FnMut +#[fundamental] #[lang_item(FnMut)] pub trait FnMut { diff --git a/charon/tests/ui/simple/closure-fn.out b/charon/tests/ui/simple/closure-fn.out index 53fac6b37..ef1aae4eb 100644 --- a/charon/tests/ui/simple/closure-fn.out +++ b/charon/tests/ui/simple/closure-fn.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -21,6 +23,7 @@ pub trait Destruct } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -29,6 +32,7 @@ pub trait Tuple } // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { @@ -42,6 +46,7 @@ pub trait FnOnce } // Full name: core::ops::function::FnMut +#[fundamental] #[lang_item(FnMut)] pub trait FnMut { @@ -54,6 +59,7 @@ pub trait FnMut } // Full name: core::ops::function::Fn +#[fundamental] #[lang_item(Fn)] pub trait Fn { diff --git a/charon/tests/ui/simple/closure-fnmut.out b/charon/tests/ui/simple/closure-fnmut.out index 809dd1dfe..fb1572f95 100644 --- a/charon/tests/ui/simple/closure-fnmut.out +++ b/charon/tests/ui/simple/closure-fnmut.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -21,6 +23,7 @@ pub trait Destruct } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -29,6 +32,7 @@ pub trait Tuple } // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { @@ -42,6 +46,7 @@ pub trait FnOnce } // Full name: core::ops::function::FnMut +#[fundamental] #[lang_item(FnMut)] pub trait FnMut { diff --git a/charon/tests/ui/simple/closure-fnonce.out b/charon/tests/ui/simple/closure-fnonce.out index b92313561..c7cfeede8 100644 --- a/charon/tests/ui/simple/closure-fnonce.out +++ b/charon/tests/ui/simple/closure-fnonce.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -21,6 +23,7 @@ pub trait Destruct } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -37,6 +40,7 @@ where = // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { diff --git a/charon/tests/ui/simple/closure-inside-impl.out b/charon/tests/ui/simple/closure-inside-impl.out index 5db200a89..dde298bbf 100644 --- a/charon/tests/ui/simple/closure-inside-impl.out +++ b/charon/tests/ui/simple/closure-inside-impl.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -21,6 +23,7 @@ pub trait Destruct } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -29,6 +32,7 @@ pub trait Tuple } // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { @@ -42,6 +46,7 @@ pub trait FnOnce } // Full name: core::ops::function::FnMut +#[fundamental] #[lang_item(FnMut)] pub trait FnMut { @@ -54,6 +59,7 @@ pub trait FnMut } // Full name: core::ops::function::Fn +#[fundamental] #[lang_item(Fn)] pub trait Fn { diff --git a/charon/tests/ui/simple/closure-inside-inline-const.out b/charon/tests/ui/simple/closure-inside-inline-const.out index 4038cdaa4..4fd1985ae 100644 --- a/charon/tests/ui/simple/closure-inside-inline-const.out +++ b/charon/tests/ui/simple/closure-inside-inline-const.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -21,6 +23,7 @@ pub trait Destruct } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -36,6 +39,7 @@ where = // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { @@ -49,6 +53,7 @@ pub trait FnOnce } // Full name: core::ops::function::FnMut +#[fundamental] #[lang_item(FnMut)] pub trait FnMut { @@ -61,6 +66,7 @@ pub trait FnMut } // Full name: core::ops::function::Fn +#[fundamental] #[lang_item(Fn)] pub trait Fn { diff --git a/charon/tests/ui/simple/closure-uses-ambient-self-clause.out b/charon/tests/ui/simple/closure-uses-ambient-self-clause.out index 41c28971d..ad0d7e79c 100644 --- a/charon/tests/ui/simple/closure-uses-ambient-self-clause.out +++ b/charon/tests/ui/simple/closure-uses-ambient-self-clause.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -21,6 +23,7 @@ pub trait Destruct } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -29,6 +32,7 @@ pub trait Tuple } // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { @@ -42,6 +46,7 @@ pub trait FnOnce } // Full name: core::ops::function::FnMut +#[fundamental] #[lang_item(FnMut)] pub trait FnMut { @@ -54,6 +59,7 @@ pub trait FnMut } // Full name: core::ops::function::Fn +#[fundamental] #[lang_item(Fn)] pub trait Fn { diff --git a/charon/tests/ui/simple/closure-with-drops.out b/charon/tests/ui/simple/closure-with-drops.out index ab5dd99da..a92aac947 100644 --- a/charon/tests/ui/simple/closure-with-drops.out +++ b/charon/tests/ui/simple/closure-with-drops.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -21,6 +23,7 @@ pub trait Destruct } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -38,6 +41,7 @@ where = // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { @@ -54,6 +58,7 @@ pub trait FnOnce } // Full name: core::ops::function::FnMut +#[fundamental] #[lang_item(FnMut)] pub trait FnMut { @@ -68,6 +73,7 @@ pub trait FnMut } // Full name: core::ops::function::Fn +#[fundamental] #[lang_item(Fn)] pub trait Fn { diff --git a/charon/tests/ui/simple/closure-with-non-upvar-lifetime.out b/charon/tests/ui/simple/closure-with-non-upvar-lifetime.out index e1102959e..02de89f84 100644 --- a/charon/tests/ui/simple/closure-with-non-upvar-lifetime.out +++ b/charon/tests/ui/simple/closure-with-non-upvar-lifetime.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -21,6 +23,7 @@ pub trait Destruct } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -29,6 +32,7 @@ pub trait Tuple } // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { @@ -42,6 +46,7 @@ pub trait FnOnce } // Full name: core::ops::function::FnMut +#[fundamental] #[lang_item(FnMut)] pub trait FnMut { @@ -54,6 +59,7 @@ pub trait FnMut } // Full name: core::ops::function::Fn +#[fundamental] #[lang_item(Fn)] pub trait Fn { diff --git a/charon/tests/ui/simple/closure-with-remove-adt-clauses.out b/charon/tests/ui/simple/closure-with-remove-adt-clauses.out index d421c9e13..440a656ca 100644 --- a/charon/tests/ui/simple/closure-with-remove-adt-clauses.out +++ b/charon/tests/ui/simple/closure-with-remove-adt-clauses.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -41,6 +43,7 @@ pub trait Destruct } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -49,6 +52,7 @@ pub trait Tuple } // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { @@ -61,6 +65,7 @@ pub trait FnOnce } // Full name: core::ops::function::FnMut +#[fundamental] #[lang_item(FnMut)] pub trait FnMut { @@ -73,6 +78,7 @@ pub trait FnMut } // Full name: core::ops::function::Fn +#[fundamental] #[lang_item(Fn)] pub trait Fn { diff --git a/charon/tests/ui/simple/conditional-drop.out b/charon/tests/ui/simple/conditional-drop.out index 81d4d1e9c..50db11e6b 100644 --- a/charon/tests/ui/simple/conditional-drop.out +++ b/charon/tests/ui/simple/conditional-drop.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/defaulted-rpitit.2.out b/charon/tests/ui/simple/defaulted-rpitit.2.out index c58e33374..fcd40a981 100644 --- a/charon/tests/ui/simple/defaulted-rpitit.2.out +++ b/charon/tests/ui/simple/defaulted-rpitit.2.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/defaulted-rpitit.3.out b/charon/tests/ui/simple/defaulted-rpitit.3.out index 5f854c328..23d9a452c 100644 --- a/charon/tests/ui/simple/defaulted-rpitit.3.out +++ b/charon/tests/ui/simple/defaulted-rpitit.3.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/defaulted-rpitit.out b/charon/tests/ui/simple/defaulted-rpitit.out index 4e090f728..eaef9386f 100644 --- a/charon/tests/ui/simple/defaulted-rpitit.out +++ b/charon/tests/ui/simple/defaulted-rpitit.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/double-promotion.out b/charon/tests/ui/simple/double-promotion.out index 69ea1166c..0f2247602 100644 --- a/charon/tests/ui/simple/double-promotion.out +++ b/charon/tests/ui/simple/double-promotion.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/drop-cow.out b/charon/tests/ui/simple/drop-cow.out index 5467197a8..4a1cab71b 100644 --- a/charon/tests/ui/simple/drop-cow.out +++ b/charon/tests/ui/simple/drop-cow.out @@ -9,6 +9,7 @@ pub trait Destruct } // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized @@ -25,6 +26,7 @@ pub trait Borrow } // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/drop-glue-with-const-generic-silenced.out b/charon/tests/ui/simple/drop-glue-with-const-generic-silenced.out index 890904b19..8f024ac6b 100644 --- a/charon/tests/ui/simple/drop-glue-with-const-generic-silenced.out +++ b/charon/tests/ui/simple/drop-glue-with-const-generic-silenced.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/drop-glue-with-const-generic.out b/charon/tests/ui/simple/drop-glue-with-const-generic.out index 64d2cab21..174d1060d 100644 --- a/charon/tests/ui/simple/drop-glue-with-const-generic.out +++ b/charon/tests/ui/simple/drop-glue-with-const-generic.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/drop-string-desugar.out b/charon/tests/ui/simple/drop-string-desugar.out index 1e9d61153..9e9e37cfa 100644 --- a/charon/tests/ui/simple/drop-string-desugar.out +++ b/charon/tests/ui/simple/drop-string-desugar.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/drop-string.out b/charon/tests/ui/simple/drop-string.out index ef5428f4d..7e39b8cfe 100644 --- a/charon/tests/ui/simple/drop-string.out +++ b/charon/tests/ui/simple/drop-string.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/dyn-broken-assoc-type-constraint.out b/charon/tests/ui/simple/dyn-broken-assoc-type-constraint.out index 96c6916a8..8a3d11063 100644 --- a/charon/tests/ui/simple/dyn-broken-assoc-type-constraint.out +++ b/charon/tests/ui/simple/dyn-broken-assoc-type-constraint.out @@ -3,10 +3,12 @@ opaque type core::marker::MetaSized::{vtable} // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/dyn-cast-to-supertrait.out b/charon/tests/ui/simple/dyn-cast-to-supertrait.out index c6fd43b31..a5b85ba0d 100644 --- a/charon/tests/ui/simple/dyn-cast-to-supertrait.out +++ b/charon/tests/ui/simple/dyn-cast-to-supertrait.out @@ -3,6 +3,7 @@ opaque type core::marker::MetaSized::{vtable} // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized diff --git a/charon/tests/ui/simple/dyn-fn.out b/charon/tests/ui/simple/dyn-fn.out index 0526ce958..ae8e3063f 100644 --- a/charon/tests/ui/simple/dyn-fn.out +++ b/charon/tests/ui/simple/dyn-fn.out @@ -3,10 +3,12 @@ opaque type core::marker::MetaSized::{vtable} // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -23,6 +25,7 @@ pub trait Destruct } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -31,6 +34,7 @@ pub trait Tuple } // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { @@ -46,6 +50,7 @@ pub trait FnOnce opaque type core::ops::function::FnMut::{vtable} // Full name: core::ops::function::FnMut +#[fundamental] #[lang_item(FnMut)] pub trait FnMut { @@ -67,6 +72,7 @@ struct core::ops::function::Fn::{vtable} { } // Full name: core::ops::function::Fn +#[fundamental] #[lang_item(Fn)] pub trait Fn { diff --git a/charon/tests/ui/simple/dyn-method-with-early-bound-lifetimes.out b/charon/tests/ui/simple/dyn-method-with-early-bound-lifetimes.out index 1d66b9be0..875dbcc5d 100644 --- a/charon/tests/ui/simple/dyn-method-with-early-bound-lifetimes.out +++ b/charon/tests/ui/simple/dyn-method-with-early-bound-lifetimes.out @@ -3,6 +3,7 @@ opaque type core::marker::MetaSized::{vtable} // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized diff --git a/charon/tests/ui/simple/fewer-clauses-in-method-impl.2.out b/charon/tests/ui/simple/fewer-clauses-in-method-impl.2.out index 11d628c9f..38c1ec0bb 100644 --- a/charon/tests/ui/simple/fewer-clauses-in-method-impl.2.out +++ b/charon/tests/ui/simple/fewer-clauses-in-method-impl.2.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/fewer-clauses-in-method-impl.out b/charon/tests/ui/simple/fewer-clauses-in-method-impl.out index 56ed6083a..b2698f947 100644 --- a/charon/tests/ui/simple/fewer-clauses-in-method-impl.out +++ b/charon/tests/ui/simple/fewer-clauses-in-method-impl.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/fn_ptr_trait.out b/charon/tests/ui/simple/fn_ptr_trait.out index 2af3e15a6..5208664e6 100644 --- a/charon/tests/ui/simple/fn_ptr_trait.out +++ b/charon/tests/ui/simple/fn_ptr_trait.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -33,6 +35,7 @@ pub trait Copy } // Full name: core::marker::FnPtr +#[fundamental] #[lang_item(FnPtrTrait)] pub trait FnPtr { diff --git a/charon/tests/ui/simple/foreign-inline-const.out b/charon/tests/ui/simple/foreign-inline-const.out index 50fd5019f..90c58b503 100644 --- a/charon/tests/ui/simple/foreign-inline-const.out +++ b/charon/tests/ui/simple/foreign-inline-const.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/gat-check-binder-levels.out b/charon/tests/ui/simple/gat-check-binder-levels.out index 4e42612f3..50a83b925 100644 --- a/charon/tests/ui/simple/gat-check-binder-levels.out +++ b/charon/tests/ui/simple/gat-check-binder-levels.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/gat-complex-lifetimes.out b/charon/tests/ui/simple/gat-complex-lifetimes.out index 94c712dee..70bffd63d 100644 --- a/charon/tests/ui/simple/gat-complex-lifetimes.out +++ b/charon/tests/ui/simple/gat-complex-lifetimes.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/gat-default.out b/charon/tests/ui/simple/gat-default.out index 097e2bdf9..ea828cc4d 100644 --- a/charon/tests/ui/simple/gat-default.out +++ b/charon/tests/ui/simple/gat-default.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/gat-implied-clause.out b/charon/tests/ui/simple/gat-implied-clause.out index ceb34024a..35e6e474f 100644 --- a/charon/tests/ui/simple/gat-implied-clause.out +++ b/charon/tests/ui/simple/gat-implied-clause.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/generic-cast-to-dyn.out b/charon/tests/ui/simple/generic-cast-to-dyn.out index c1a55208b..b2ba0c607 100644 --- a/charon/tests/ui/simple/generic-cast-to-dyn.out +++ b/charon/tests/ui/simple/generic-cast-to-dyn.out @@ -3,6 +3,7 @@ opaque type core::any::Any::{vtable} // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized @@ -22,6 +23,7 @@ where } // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/generic-discriminant.out b/charon/tests/ui/simple/generic-discriminant.out index 7d1dcb678..d99727e35 100644 --- a/charon/tests/ui/simple/generic-discriminant.out +++ b/charon/tests/ui/simple/generic-discriminant.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -104,6 +106,7 @@ where TraitClause0: (T: Sized), // Full name: core::mem::discriminant +#[track_caller] #[diagnostic_item("mem_discriminant")] pub fn discriminant<'_0, T>(v: &'_0 T) -> Discriminant[TraitClause0] where diff --git a/charon/tests/ui/simple/generic-impl-with-defaulted-method.out b/charon/tests/ui/simple/generic-impl-with-defaulted-method.out index 2c96fac2f..09d06c869 100644 --- a/charon/tests/ui/simple/generic-impl-with-defaulted-method.out +++ b/charon/tests/ui/simple/generic-impl-with-defaulted-method.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/generic-impl-with-method.out b/charon/tests/ui/simple/generic-impl-with-method.out index 72c0e27d3..ded2d771a 100644 --- a/charon/tests/ui/simple/generic-impl-with-method.out +++ b/charon/tests/ui/simple/generic-impl-with-method.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/generic-offset-of.out b/charon/tests/ui/simple/generic-offset-of.out index d5d5fba7f..0348c4dce 100644 --- a/charon/tests/ui/simple/generic-offset-of.out +++ b/charon/tests/ui/simple/generic-offset-of.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/impl-trait-in-arg.out b/charon/tests/ui/simple/impl-trait-in-arg.out index 49117b8f4..fe18605cc 100644 --- a/charon/tests/ui/simple/impl-trait-in-arg.out +++ b/charon/tests/ui/simple/impl-trait-in-arg.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/intrinsic-same-name-across-modules.out b/charon/tests/ui/simple/intrinsic-same-name-across-modules.out index 23b2b511f..ca7d56b1b 100644 --- a/charon/tests/ui/simple/intrinsic-same-name-across-modules.out +++ b/charon/tests/ui/simple/intrinsic-same-name-across-modules.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -43,6 +45,7 @@ pub trait Copy non-dyn-compatible } +#[rustc_intrinsic] pub fn core::intrinsics::wrapping_add(a_1: T, b_2: T) -> T where TraitClause0: (T: Sized), @@ -56,6 +59,8 @@ impl "impl_Copy_for_u8" Copy for u8 { non-dyn-compatible } +#[rustc_intrinsic] +#[inline(hint)] pub fn test_crate::first::nested::wrapping_add(lhs_1: T, rhs_2: T) -> T where TraitClause0: (T: Sized), diff --git a/charon/tests/ui/simple/issue-1040-closure-upvar-lifetime.out b/charon/tests/ui/simple/issue-1040-closure-upvar-lifetime.out index 4563d1045..9eadfbeca 100644 --- a/charon/tests/ui/simple/issue-1040-closure-upvar-lifetime.out +++ b/charon/tests/ui/simple/issue-1040-closure-upvar-lifetime.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -21,6 +23,7 @@ pub trait Destruct } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -29,6 +32,7 @@ pub trait Tuple } // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { @@ -42,6 +46,7 @@ pub trait FnOnce } // Full name: core::ops::function::FnMut +#[fundamental] #[lang_item(FnMut)] pub trait FnMut { @@ -54,6 +59,7 @@ pub trait FnMut } // Full name: core::ops::function::Fn +#[fundamental] #[lang_item(Fn)] pub trait Fn { diff --git a/charon/tests/ui/simple/issue-988-closure-outlives.out b/charon/tests/ui/simple/issue-988-closure-outlives.out index aa9244352..c7c11c6fb 100644 --- a/charon/tests/ui/simple/issue-988-closure-outlives.out +++ b/charon/tests/ui/simple/issue-988-closure-outlives.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -21,6 +23,7 @@ pub trait Destruct } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -29,6 +32,7 @@ pub trait Tuple } // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { @@ -42,6 +46,7 @@ pub trait FnOnce } // Full name: core::ops::function::FnMut +#[fundamental] #[lang_item(FnMut)] pub trait FnMut { @@ -54,6 +59,7 @@ pub trait FnMut } // Full name: core::ops::function::Fn +#[fundamental] #[lang_item(Fn)] pub trait Fn { diff --git a/charon/tests/ui/simple/lending-iterator-gat.out b/charon/tests/ui/simple/lending-iterator-gat.out index ad2687933..b4409676a 100644 --- a/charon/tests/ui/simple/lending-iterator-gat.out +++ b/charon/tests/ui/simple/lending-iterator-gat.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -21,6 +23,7 @@ pub trait Destruct } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -29,6 +32,7 @@ pub trait Tuple } // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { @@ -42,6 +46,7 @@ pub trait FnOnce } // Full name: core::ops::function::FnMut +#[fundamental] #[lang_item(FnMut)] pub trait FnMut { diff --git a/charon/tests/ui/simple/lifetime-unification-from-trait-impl.out b/charon/tests/ui/simple/lifetime-unification-from-trait-impl.out index 03554fd0f..0e6da313b 100644 --- a/charon/tests/ui/simple/lifetime-unification-from-trait-impl.out +++ b/charon/tests/ui/simple/lifetime-unification-from-trait-impl.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/manual-drop-impl.out b/charon/tests/ui/simple/manual-drop-impl.out index 95c17234b..a809140a8 100644 --- a/charon/tests/ui/simple/manual-drop-impl.out +++ b/charon/tests/ui/simple/manual-drop-impl.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/min.out b/charon/tests/ui/simple/min.out index 43f4488ee..8e181d505 100644 --- a/charon/tests/ui/simple/min.out +++ b/charon/tests/ui/simple/min.out @@ -9,10 +9,12 @@ pub trait Destruct } // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/multiple-promoteds.out b/charon/tests/ui/simple/multiple-promoteds.out index 18691d33c..e4e917606 100644 --- a/charon/tests/ui/simple/multiple-promoteds.out +++ b/charon/tests/ui/simple/multiple-promoteds.out @@ -1,6 +1,7 @@ # Final LLBC before serialization: // Full name: core::ops::arith::{impl Add<&'_0 u32> for &'_1 u32}::add +#[track_caller] pub fn add<'_0, '_1>(_1: &'_1 u32, _2: &'_0 u32) -> u32 = diff --git a/charon/tests/ui/simple/nested-closure-lifetime.out b/charon/tests/ui/simple/nested-closure-lifetime.out index 2623f959f..992ecc829 100644 --- a/charon/tests/ui/simple/nested-closure-lifetime.out +++ b/charon/tests/ui/simple/nested-closure-lifetime.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -31,6 +33,7 @@ pub trait Destruct } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -39,6 +42,7 @@ pub trait Tuple } // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { @@ -52,6 +56,7 @@ pub trait FnOnce } // Full name: core::ops::function::FnMut +#[fundamental] #[lang_item(FnMut)] pub trait FnMut { @@ -64,6 +69,7 @@ pub trait FnMut } // Full name: core::ops::function::Fn +#[fundamental] #[lang_item(Fn)] pub trait Fn { diff --git a/charon/tests/ui/simple/nested-closure-trait-ref.out b/charon/tests/ui/simple/nested-closure-trait-ref.out index 667acb9f6..56230ea03 100644 --- a/charon/tests/ui/simple/nested-closure-trait-ref.out +++ b/charon/tests/ui/simple/nested-closure-trait-ref.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -31,6 +33,7 @@ pub trait Destruct } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -39,6 +42,7 @@ pub trait Tuple } // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { @@ -52,6 +56,7 @@ pub trait FnOnce } // Full name: core::ops::function::FnMut +#[fundamental] #[lang_item(FnMut)] pub trait FnMut { @@ -64,6 +69,7 @@ pub trait FnMut } // Full name: core::ops::function::Fn +#[fundamental] #[lang_item(Fn)] pub trait Fn { diff --git a/charon/tests/ui/simple/nested-closure.out b/charon/tests/ui/simple/nested-closure.out index af25dd8fb..6837efcc4 100644 --- a/charon/tests/ui/simple/nested-closure.out +++ b/charon/tests/ui/simple/nested-closure.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -31,6 +33,7 @@ pub trait Destruct } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -39,6 +42,7 @@ pub trait Tuple } // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { @@ -52,6 +56,7 @@ pub trait FnOnce } // Full name: core::ops::function::FnMut +#[fundamental] #[lang_item(FnMut)] pub trait FnMut { @@ -64,6 +69,7 @@ pub trait FnMut } // Full name: core::ops::function::Fn +#[fundamental] #[lang_item(Fn)] pub trait Fn { diff --git a/charon/tests/ui/simple/non-lifetime-gats.out b/charon/tests/ui/simple/non-lifetime-gats.out index 666caaa77..46db63510 100644 --- a/charon/tests/ui/simple/non-lifetime-gats.out +++ b/charon/tests/ui/simple/non-lifetime-gats.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/opaque-trait-with-clause-in-method.out b/charon/tests/ui/simple/opaque-trait-with-clause-in-method.out index c6d34b6ab..8edb4aa0c 100644 --- a/charon/tests/ui/simple/opaque-trait-with-clause-in-method.out +++ b/charon/tests/ui/simple/opaque-trait-with-clause-in-method.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/opaque-vtable.out b/charon/tests/ui/simple/opaque-vtable.out index b99a582a6..c57fc4507 100644 --- a/charon/tests/ui/simple/opaque-vtable.out +++ b/charon/tests/ui/simple/opaque-vtable.out @@ -1,6 +1,7 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized diff --git a/charon/tests/ui/simple/pass-higher-kinded-fn-item-as-closure.out b/charon/tests/ui/simple/pass-higher-kinded-fn-item-as-closure.out index 2801f73f5..aca7f8f6d 100644 --- a/charon/tests/ui/simple/pass-higher-kinded-fn-item-as-closure.out +++ b/charon/tests/ui/simple/pass-higher-kinded-fn-item-as-closure.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -21,6 +23,7 @@ pub trait Destruct } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -29,6 +32,7 @@ pub trait Tuple } // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { @@ -41,6 +45,7 @@ pub trait FnOnce } // Full name: core::ops::function::FnMut +#[fundamental] #[lang_item(FnMut)] pub trait FnMut { @@ -53,6 +58,7 @@ pub trait FnMut } // Full name: core::ops::function::Fn +#[fundamental] #[lang_item(Fn)] pub trait Fn { diff --git a/charon/tests/ui/simple/promoted-closure-no-warns.out b/charon/tests/ui/simple/promoted-closure-no-warns.out index 1d0bf86c0..64a59aa42 100644 --- a/charon/tests/ui/simple/promoted-closure-no-warns.out +++ b/charon/tests/ui/simple/promoted-closure-no-warns.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -21,6 +23,7 @@ pub trait Destruct } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -29,6 +32,7 @@ pub trait Tuple } // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { @@ -42,6 +46,7 @@ pub trait FnOnce } // Full name: core::ops::function::FnMut +#[fundamental] #[lang_item(FnMut)] pub trait FnMut { @@ -54,6 +59,7 @@ pub trait FnMut } // Full name: core::ops::function::Fn +#[fundamental] #[lang_item(Fn)] pub trait Fn { diff --git a/charon/tests/ui/simple/promoted-closure.out b/charon/tests/ui/simple/promoted-closure.out index 1d0bf86c0..64a59aa42 100644 --- a/charon/tests/ui/simple/promoted-closure.out +++ b/charon/tests/ui/simple/promoted-closure.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -21,6 +23,7 @@ pub trait Destruct } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -29,6 +32,7 @@ pub trait Tuple } // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { @@ -42,6 +46,7 @@ pub trait FnOnce } // Full name: core::ops::function::FnMut +#[fundamental] #[lang_item(FnMut)] pub trait FnMut { @@ -54,6 +59,7 @@ pub trait FnMut } // Full name: core::ops::function::Fn +#[fundamental] #[lang_item(Fn)] pub trait Fn { diff --git a/charon/tests/ui/simple/promoted-in-generic-fn.out b/charon/tests/ui/simple/promoted-in-generic-fn.out index 82986f462..255aed20d 100644 --- a/charon/tests/ui/simple/promoted-in-generic-fn.out +++ b/charon/tests/ui/simple/promoted-in-generic-fn.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/promoted-inside-impl.out b/charon/tests/ui/simple/promoted-inside-impl.out index 3d3d01e48..44f984829 100644 --- a/charon/tests/ui/simple/promoted-inside-impl.out +++ b/charon/tests/ui/simple/promoted-inside-impl.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/promoted-literal-addition-overflow.out b/charon/tests/ui/simple/promoted-literal-addition-overflow.out index 9a8f57f51..d442cb06d 100644 --- a/charon/tests/ui/simple/promoted-literal-addition-overflow.out +++ b/charon/tests/ui/simple/promoted-literal-addition-overflow.out @@ -8,6 +8,7 @@ pub fn MAX() -> u32 pub const MAX: u32 = MAX() // Full name: test_crate::overflow +#[allow(arithmetic_overflow)] fn overflow() -> &'static u32 { let _0: &'1 u32; // return diff --git a/charon/tests/ui/simple/promoted_in_closure.out b/charon/tests/ui/simple/promoted_in_closure.out index 53032b558..03a2e1a8b 100644 --- a/charon/tests/ui/simple/promoted_in_closure.out +++ b/charon/tests/ui/simple/promoted_in_closure.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -21,6 +23,7 @@ pub trait Destruct } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -29,6 +32,7 @@ pub trait Tuple } // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { @@ -42,6 +46,7 @@ pub trait FnOnce } // Full name: core::ops::function::FnMut +#[fundamental] #[lang_item(FnMut)] pub trait FnMut { @@ -54,6 +59,7 @@ pub trait FnMut } // Full name: core::ops::function::Fn +#[fundamental] #[lang_item(Fn)] pub trait Fn { diff --git a/charon/tests/ui/simple/promoted_in_default_method.out b/charon/tests/ui/simple/promoted_in_default_method.out index 39f7253c3..afb494570 100644 --- a/charon/tests/ui/simple/promoted_in_default_method.out +++ b/charon/tests/ui/simple/promoted_in_default_method.out @@ -1,6 +1,7 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized diff --git a/charon/tests/ui/simple/ptr-from-raw-parts.out b/charon/tests/ui/simple/ptr-from-raw-parts.out index 7fe0b2fb1..5c4009bf6 100644 --- a/charon/tests/ui/simple/ptr-from-raw-parts.out +++ b/charon/tests/ui/simple/ptr-from-raw-parts.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/ptr_metadata.out b/charon/tests/ui/simple/ptr_metadata.out index 553e16cc4..6dcb49029 100644 --- a/charon/tests/ui/simple/ptr_metadata.out +++ b/charon/tests/ui/simple/ptr_metadata.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/remove-adt-clauses-closure-keep-assoc.out b/charon/tests/ui/simple/remove-adt-clauses-closure-keep-assoc.out index f13808589..bdae744fa 100644 --- a/charon/tests/ui/simple/remove-adt-clauses-closure-keep-assoc.out +++ b/charon/tests/ui/simple/remove-adt-clauses-closure-keep-assoc.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -21,6 +23,7 @@ pub trait Destruct } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -29,6 +32,7 @@ pub trait Tuple } // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { diff --git a/charon/tests/ui/simple/remove-adt-clauses-keep-assoc.out b/charon/tests/ui/simple/remove-adt-clauses-keep-assoc.out index 94813e78f..9f481e440 100644 --- a/charon/tests/ui/simple/remove-adt-clauses-keep-assoc.out +++ b/charon/tests/ui/simple/remove-adt-clauses-keep-assoc.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/remove-adt-clauses-supertrait.out b/charon/tests/ui/simple/remove-adt-clauses-supertrait.out index 64c64d110..ef67c24f4 100644 --- a/charon/tests/ui/simple/remove-adt-clauses-supertrait.out +++ b/charon/tests/ui/simple/remove-adt-clauses-supertrait.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -21,6 +23,7 @@ pub trait Destruct } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -29,6 +32,7 @@ pub trait Tuple } // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { diff --git a/charon/tests/ui/simple/remove-adt-clauses.out b/charon/tests/ui/simple/remove-adt-clauses.out index 44152c497..7387b1eaf 100644 --- a/charon/tests/ui/simple/remove-adt-clauses.out +++ b/charon/tests/ui/simple/remove-adt-clauses.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/rpitit-with-const-generic.out b/charon/tests/ui/simple/rpitit-with-const-generic.out index 706f01164..148a04595 100644 --- a/charon/tests/ui/simple/rpitit-with-const-generic.out +++ b/charon/tests/ui/simple/rpitit-with-const-generic.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/rpitit-with-lifetime-bound.out b/charon/tests/ui/simple/rpitit-with-lifetime-bound.out index 90fa8d0c7..8d4e4b6c4 100644 --- a/charon/tests/ui/simple/rpitit-with-lifetime-bound.out +++ b/charon/tests/ui/simple/rpitit-with-lifetime-bound.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/rpitit-with-lifetime.out b/charon/tests/ui/simple/rpitit-with-lifetime.out index 088c19c95..27c0957ad 100644 --- a/charon/tests/ui/simple/rpitit-with-lifetime.out +++ b/charon/tests/ui/simple/rpitit-with-lifetime.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/rpitit.out b/charon/tests/ui/simple/rpitit.out index 7c00962d4..a07bf69ce 100644 --- a/charon/tests/ui/simple/rpitit.out +++ b/charon/tests/ui/simple/rpitit.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/single-variant-enum-drop-glue.out b/charon/tests/ui/simple/single-variant-enum-drop-glue.out index fd6c337d9..bee82a57d 100644 --- a/charon/tests/ui/simple/single-variant-enum-drop-glue.out +++ b/charon/tests/ui/simple/single-variant-enum-drop-glue.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/slice_index_range.out b/charon/tests/ui/simple/slice_index_range.out index 66e3efe14..3fce4b40c 100644 --- a/charon/tests/ui/simple/slice_index_range.out +++ b/charon/tests/ui/simple/slice_index_range.out @@ -1,5 +1,6 @@ # Final LLBC before serialization: +#[track_caller] fn core::slice::index::slice_index_fail::do_panic::runtime(start: usize, len: usize) -> ! { let _0: !; // return @@ -104,6 +105,7 @@ fn core::slice::index::slice_index_fail::do_panic::runtime(start: usize, len: us panic(core::panicking::panic_fmt) } +#[track_caller] fn core::slice::index::slice_index_fail::do_panic#1::runtime(end: usize, len: usize) -> ! { let _0: !; // return @@ -208,6 +210,7 @@ fn core::slice::index::slice_index_fail::do_panic#1::runtime(end: usize, len: us panic(core::panicking::panic_fmt) } +#[track_caller] fn core::slice::index::slice_index_fail::do_panic#2::runtime(start: usize, end: usize) -> ! { let _0: !; // return @@ -312,6 +315,7 @@ fn core::slice::index::slice_index_fail::do_panic#2::runtime(start: usize, end: panic(core::panicking::panic_fmt) } +#[track_caller] fn core::slice::index::slice_index_fail::do_panic#3::runtime(end: usize, len: usize) -> ! { let _0: !; // return @@ -427,6 +431,7 @@ where Some { _0: T }, } +#[track_caller] fn core::slice::index::slice_index_fail::do_panic(start: usize, len: usize) -> ! { let _0: !; // return @@ -452,6 +457,7 @@ fn core::slice::index::slice_index_fail::do_panic(start: usize, len: usize) -> ! unwind_continue } +#[track_caller] fn core::slice::index::slice_index_fail::do_panic#1(end: usize, len: usize) -> ! { let _0: !; // return @@ -477,6 +483,7 @@ fn core::slice::index::slice_index_fail::do_panic#1(end: usize, len: usize) -> ! unwind_continue } +#[track_caller] fn core::slice::index::slice_index_fail::do_panic#2(start: usize, end: usize) -> ! { let _0: !; // return @@ -502,6 +509,7 @@ fn core::slice::index::slice_index_fail::do_panic#2(start: usize, end: usize) -> unwind_continue } +#[track_caller] fn core::slice::index::slice_index_fail::do_panic#3(end: usize, len: usize) -> ! { let _0: !; // return @@ -581,6 +589,7 @@ where } // Full name: core::slice::index::slice_index_fail +#[track_caller] fn slice_index_fail(start: usize, end: usize, len: usize) -> ! { let _0: !; // return @@ -1060,6 +1069,7 @@ where } // Full name: core::slice::index::{impl SliceIndex<[T]> for Range[{built_in impl Sized for usize}]}::get_unchecked::precondition_check +#[track_caller] fn impl_SliceIndex_slice_for_Range_usize::get_unchecked::precondition_check(start: usize, end: usize, len: usize) { let _0: (); // return @@ -1135,6 +1145,7 @@ fn impl_SliceIndex_slice_for_Range_usize::get_unchecked::precondition_check(star } // Full name: core::slice::index::{impl SliceIndex<[T]> for Range[{built_in impl Sized for usize}]}::get_unchecked +#[track_caller] pub unsafe fn impl_SliceIndex_slice_for_Range_usize::get_unchecked(self: Range[{built_in impl Sized for usize}], slice: *const [T]) -> *const [T] where TraitClause0: (T: Sized), @@ -1215,6 +1226,7 @@ where } // Full name: core::slice::index::{impl SliceIndex<[T]> for Range[{built_in impl Sized for usize}]}::get_unchecked_mut::precondition_check +#[track_caller] fn impl_SliceIndex_slice_for_Range_usize::get_unchecked_mut::precondition_check(start: usize, end: usize, len: usize) { let _0: (); // return @@ -1290,6 +1302,7 @@ fn impl_SliceIndex_slice_for_Range_usize::get_unchecked_mut::precondition_check( } // Full name: core::slice::index::{impl SliceIndex<[T]> for Range[{built_in impl Sized for usize}]}::get_unchecked_mut +#[track_caller] pub unsafe fn impl_SliceIndex_slice_for_Range_usize::get_unchecked_mut(self: Range[{built_in impl Sized for usize}], slice: *mut [T]) -> *mut [T] where TraitClause0: (T: Sized), diff --git a/charon/tests/ui/simple/struct-with-drops.out b/charon/tests/ui/simple/struct-with-drops.out index f74f45ab5..675ae48a7 100644 --- a/charon/tests/ui/simple/struct-with-drops.out +++ b/charon/tests/ui/simple/struct-with-drops.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/supertrait-impl-with-assoc-type-constraint.out b/charon/tests/ui/simple/supertrait-impl-with-assoc-type-constraint.out index eed7a8c64..f6f55f6bc 100644 --- a/charon/tests/ui/simple/supertrait-impl-with-assoc-type-constraint.out +++ b/charon/tests/ui/simple/supertrait-impl-with-assoc-type-constraint.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/thread-local.out b/charon/tests/ui/simple/thread-local.out index bd249d103..6b688bb4e 100644 --- a/charon/tests/ui/simple/thread-local.out +++ b/charon/tests/ui/simple/thread-local.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -59,6 +61,7 @@ pub trait Destruct } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -74,6 +77,7 @@ where = // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { @@ -87,6 +91,7 @@ pub trait FnOnce } // Full name: core::ops::function::FnMut +#[fundamental] #[lang_item(FnMut)] pub trait FnMut { @@ -99,6 +104,7 @@ pub trait FnMut } // Full name: core::ops::function::Fn +#[fundamental] #[lang_item(Fn)] pub trait Fn { @@ -201,6 +207,7 @@ where = // Full name: test_crate::FOO::__rust_std_internal_init_fn +#[inline(hint)] fn __rust_std_internal_init_fn() -> u32 { let _0: u32; // return diff --git a/charon/tests/ui/simple/trait-alias.out b/charon/tests/ui/simple/trait-alias.out index 616435ac1..4a53228a0 100644 --- a/charon/tests/ui/simple/trait-alias.out +++ b/charon/tests/ui/simple/trait-alias.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -54,6 +56,7 @@ trait Trait struct Struct {} // Full name: test_crate::{impl Clone for Struct}::clone +#[inline(hint)] pub fn clone<'_0>(self: &'_0 Struct) -> Struct { let _0: Struct; // return diff --git a/charon/tests/ui/simple/trait-default-const-cross-crate.out b/charon/tests/ui/simple/trait-default-const-cross-crate.out index bf6a0aee4..92571cef4 100644 --- a/charon/tests/ui/simple/trait-default-const-cross-crate.out +++ b/charon/tests/ui/simple/trait-default-const-cross-crate.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/trait-default-const.out b/charon/tests/ui/simple/trait-default-const.out index 4e117d3b4..a4ba9fbf0 100644 --- a/charon/tests/ui/simple/trait-default-const.out +++ b/charon/tests/ui/simple/trait-default-const.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/trivial_generic_function.out b/charon/tests/ui/simple/trivial_generic_function.out index 5a80bc998..d33446c7f 100644 --- a/charon/tests/ui/simple/trivial_generic_function.out +++ b/charon/tests/ui/simple/trivial_generic_function.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/vec-push.out b/charon/tests/ui/simple/vec-push.out index e46f70ad1..b22d2e7e3 100644 --- a/charon/tests/ui/simple/vec-push.out +++ b/charon/tests/ui/simple/vec-push.out @@ -5,10 +5,12 @@ pub opaque type Layout // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/vec-with-capacity.out b/charon/tests/ui/simple/vec-with-capacity.out index 38b0881d6..ae0f1404d 100644 --- a/charon/tests/ui/simple/vec-with-capacity.out +++ b/charon/tests/ui/simple/vec-with-capacity.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/simple/well-formedness-bound.out b/charon/tests/ui/simple/well-formedness-bound.out index a70b64028..1342e6b7b 100644 --- a/charon/tests/ui/simple/well-formedness-bound.out +++ b/charon/tests/ui/simple/well-formedness-bound.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/skip-borrowck.out b/charon/tests/ui/skip-borrowck.out index 41452b682..775ceb08b 100644 --- a/charon/tests/ui/skip-borrowck.out +++ b/charon/tests/ui/skip-borrowck.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/slice-index-range.out b/charon/tests/ui/slice-index-range.out index d8fe651d3..29e411396 100644 --- a/charon/tests/ui/slice-index-range.out +++ b/charon/tests/ui/slice-index-range.out @@ -1,6 +1,7 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized @@ -17,6 +18,7 @@ pub trait Index } // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -35,6 +37,7 @@ where TypeOutlives2: I: '_0, = +#[track_caller] fn core::slice::index::slice_index_fail::do_panic::runtime(start: usize, len: usize) -> ! { let _0: !; // return @@ -139,6 +142,7 @@ fn core::slice::index::slice_index_fail::do_panic::runtime(start: usize, len: us panic(core::panicking::panic_fmt) } +#[track_caller] fn core::slice::index::slice_index_fail::do_panic#1::runtime(end: usize, len: usize) -> ! { let _0: !; // return @@ -243,6 +247,7 @@ fn core::slice::index::slice_index_fail::do_panic#1::runtime(end: usize, len: us panic(core::panicking::panic_fmt) } +#[track_caller] fn core::slice::index::slice_index_fail::do_panic#2::runtime(start: usize, end: usize) -> ! { let _0: !; // return @@ -347,6 +352,7 @@ fn core::slice::index::slice_index_fail::do_panic#2::runtime(start: usize, end: panic(core::panicking::panic_fmt) } +#[track_caller] fn core::slice::index::slice_index_fail::do_panic#3::runtime(end: usize, len: usize) -> ! { let _0: !; // return @@ -476,6 +482,7 @@ where end: Idx, } +#[track_caller] fn core::slice::index::slice_index_fail::do_panic(start: usize, len: usize) -> ! { let _0: !; // return @@ -501,6 +508,7 @@ fn core::slice::index::slice_index_fail::do_panic(start: usize, len: usize) -> ! unwind_continue } +#[track_caller] fn core::slice::index::slice_index_fail::do_panic#1(end: usize, len: usize) -> ! { let _0: !; // return @@ -526,6 +534,7 @@ fn core::slice::index::slice_index_fail::do_panic#1(end: usize, len: usize) -> ! unwind_continue } +#[track_caller] fn core::slice::index::slice_index_fail::do_panic#2(start: usize, end: usize) -> ! { let _0: !; // return @@ -551,6 +560,7 @@ fn core::slice::index::slice_index_fail::do_panic#2(start: usize, end: usize) -> unwind_continue } +#[track_caller] fn core::slice::index::slice_index_fail::do_panic#3(end: usize, len: usize) -> ! { let _0: !; // return @@ -577,6 +587,7 @@ fn core::slice::index::slice_index_fail::do_panic#3(end: usize, len: usize) -> ! } // Full name: core::panicking::panic_nounwind_fmt +#[track_caller] pub fn panic_nounwind_fmt<'_0>(_1: Arguments<'_0>, _2: bool) -> ! = @@ -659,6 +670,7 @@ where } // Full name: core::slice::index::slice_index_fail +#[track_caller] fn slice_index_fail(start: usize, end: usize, len: usize) -> ! { let _0: !; // return @@ -1214,6 +1226,7 @@ where } // Full name: core::slice::index::{impl SliceIndex<[T]> for Range[{built_in impl Sized for usize}]}::get_unchecked_mut::precondition_check +#[track_caller] fn impl_SliceIndex_slice_for_Range_usize::get_unchecked_mut::precondition_check(start: usize, end: usize, len: usize) { let _0: (); // return @@ -1289,6 +1302,7 @@ fn impl_SliceIndex_slice_for_Range_usize::get_unchecked_mut::precondition_check( } // Full name: core::slice::index::{impl SliceIndex<[T]> for Range[{built_in impl Sized for usize}]}::get_unchecked_mut +#[track_caller] pub unsafe fn get_unchecked_mut(self: Range[{built_in impl Sized for usize}], slice: *mut [T]) -> *mut [T] where TraitClause0: (T: Sized), @@ -1369,6 +1383,7 @@ where } // Full name: core::slice::index::{impl SliceIndex<[T]> for Range[{built_in impl Sized for usize}]}::get_unchecked::precondition_check +#[track_caller] fn impl_SliceIndex_slice_for_Range_usize::get_unchecked::precondition_check(start: usize, end: usize, len: usize) { let _0: (); // return @@ -1444,6 +1459,7 @@ fn impl_SliceIndex_slice_for_Range_usize::get_unchecked::precondition_check(star } // Full name: core::slice::index::{impl SliceIndex<[T]> for Range[{built_in impl Sized for usize}]}::get_unchecked +#[track_caller] pub unsafe fn get_unchecked(self: Range[{built_in impl Sized for usize}], slice: *const [T]) -> *const [T] where TraitClause0: (T: Sized), diff --git a/charon/tests/ui/string-literal.out b/charon/tests/ui/string-literal.out index 937db748f..9855fbf00 100644 --- a/charon/tests/ui/string-literal.out +++ b/charon/tests/ui/string-literal.out @@ -1,6 +1,7 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized diff --git a/charon/tests/ui/traits.out b/charon/tests/ui/traits.out index 8ab6e137c..091bd3e00 100644 --- a/charon/tests/ui/traits.out +++ b/charon/tests/ui/traits.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -21,6 +23,7 @@ pub trait Destruct } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -29,6 +32,7 @@ pub trait Tuple } // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { @@ -42,6 +46,7 @@ pub trait FnOnce } // Full name: core::ops::function::FnMut +#[fundamental] #[lang_item(FnMut)] pub trait FnMut { @@ -54,6 +59,7 @@ pub trait FnMut } // Full name: core::ops::function::Fn +#[fundamental] #[lang_item(Fn)] pub trait Fn { diff --git a/charon/tests/ui/traits/default-method-with-item-bound.2.out b/charon/tests/ui/traits/default-method-with-item-bound.2.out index c24c9ddcc..b7b7861a5 100644 --- a/charon/tests/ui/traits/default-method-with-item-bound.2.out +++ b/charon/tests/ui/traits/default-method-with-item-bound.2.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/traits/default-method-with-item-bound.3.out b/charon/tests/ui/traits/default-method-with-item-bound.3.out index d39804573..1b47f78af 100644 --- a/charon/tests/ui/traits/default-method-with-item-bound.3.out +++ b/charon/tests/ui/traits/default-method-with-item-bound.3.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/traits/default-method-with-item-bound.4.out b/charon/tests/ui/traits/default-method-with-item-bound.4.out index 2959b086e..3460374b5 100644 --- a/charon/tests/ui/traits/default-method-with-item-bound.4.out +++ b/charon/tests/ui/traits/default-method-with-item-bound.4.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/traits/default-method-with-item-bound.5.out b/charon/tests/ui/traits/default-method-with-item-bound.5.out index b18d6d4a0..f46bfda7d 100644 --- a/charon/tests/ui/traits/default-method-with-item-bound.5.out +++ b/charon/tests/ui/traits/default-method-with-item-bound.5.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -13,6 +15,7 @@ pub trait Sized } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -21,6 +24,7 @@ pub trait Tuple } // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { @@ -34,6 +38,7 @@ pub trait FnOnce } // Full name: core::ops::function::FnMut +#[fundamental] #[lang_item(FnMut)] pub trait FnMut { diff --git a/charon/tests/ui/traits/default-method-with-item-bound.6.out b/charon/tests/ui/traits/default-method-with-item-bound.6.out index 8a13b7197..730efacc7 100644 --- a/charon/tests/ui/traits/default-method-with-item-bound.6.out +++ b/charon/tests/ui/traits/default-method-with-item-bound.6.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/traits/default-method-with-item-bound.out b/charon/tests/ui/traits/default-method-with-item-bound.out index bb1fe7ec6..155cee4de 100644 --- a/charon/tests/ui/traits/default-method-with-item-bound.out +++ b/charon/tests/ui/traits/default-method-with-item-bound.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/traits/issue-1242-dyn-send-supertrait.out b/charon/tests/ui/traits/issue-1242-dyn-send-supertrait.out index 4ee47a311..61dcc8148 100644 --- a/charon/tests/ui/traits/issue-1242-dyn-send-supertrait.out +++ b/charon/tests/ui/traits/issue-1242-dyn-send-supertrait.out @@ -9,6 +9,7 @@ pub trait Send opaque type core::marker::MetaSized::{vtable} // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized diff --git a/charon/tests/ui/traits/issue-513-gat-clause-mismatch-use-clause.out b/charon/tests/ui/traits/issue-513-gat-clause-mismatch-use-clause.out index e007b0f33..fb4b3eb13 100644 --- a/charon/tests/ui/traits/issue-513-gat-clause-mismatch-use-clause.out +++ b/charon/tests/ui/traits/issue-513-gat-clause-mismatch-use-clause.out @@ -20,10 +20,12 @@ impl "impl_PartialEq_u32_for_u32" PartialEq for u32 { } // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/traits/issue-513-gat-clause-mismatch.out b/charon/tests/ui/traits/issue-513-gat-clause-mismatch.out index 54a4e5516..1bd428f75 100644 --- a/charon/tests/ui/traits/issue-513-gat-clause-mismatch.out +++ b/charon/tests/ui/traits/issue-513-gat-clause-mismatch.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/traits/issue-513-method-clause-mismatch-and-default-call.out b/charon/tests/ui/traits/issue-513-method-clause-mismatch-and-default-call.out index 56b03835e..8650d9c15 100644 --- a/charon/tests/ui/traits/issue-513-method-clause-mismatch-and-default-call.out +++ b/charon/tests/ui/traits/issue-513-method-clause-mismatch-and-default-call.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/traits/issue-513-method-clause-mismatch.out b/charon/tests/ui/traits/issue-513-method-clause-mismatch.out index b58f43334..37c4cbe8a 100644 --- a/charon/tests/ui/traits/issue-513-method-clause-mismatch.out +++ b/charon/tests/ui/traits/issue-513-method-clause-mismatch.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/traits/issue-513-method-late-bound-mismatch.out b/charon/tests/ui/traits/issue-513-method-late-bound-mismatch.out index c07809016..a1c9f71a4 100644 --- a/charon/tests/ui/traits/issue-513-method-late-bound-mismatch.out +++ b/charon/tests/ui/traits/issue-513-method-late-bound-mismatch.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/traits/pointee-metadata-bounds.out b/charon/tests/ui/traits/pointee-metadata-bounds.out index 5dd62900b..fa344b74a 100644 --- a/charon/tests/ui/traits/pointee-metadata-bounds.out +++ b/charon/tests/ui/traits/pointee-metadata-bounds.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/traits/remove-self-clause-on-closure.out b/charon/tests/ui/traits/remove-self-clause-on-closure.out index b55edbbaa..29c4ab891 100644 --- a/charon/tests/ui/traits/remove-self-clause-on-closure.out +++ b/charon/tests/ui/traits/remove-self-clause-on-closure.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -21,6 +23,7 @@ pub trait Destruct } // Full name: core::marker::Tuple +#[fundamental] #[lang_item(Tuple)] pub trait Tuple { @@ -29,6 +32,7 @@ pub trait Tuple } // Full name: core::ops::function::FnOnce +#[fundamental] #[lang_item(FnOnce)] pub trait FnOnce { @@ -41,6 +45,7 @@ pub trait FnOnce } // Full name: core::ops::function::FnMut +#[fundamental] #[lang_item(FnMut)] pub trait FnMut { @@ -53,6 +58,7 @@ pub trait FnMut } // Full name: core::ops::function::Fn +#[fundamental] #[lang_item(Fn)] pub trait Fn { diff --git a/charon/tests/ui/traits/remove-unused-clauses.out b/charon/tests/ui/traits/remove-unused-clauses.out index 38f877a31..f7329bd08 100644 --- a/charon/tests/ui/traits/remove-unused-clauses.out +++ b/charon/tests/ui/traits/remove-unused-clauses.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/traits_special.out b/charon/tests/ui/traits_special.out index d3c3ff95a..00e13e78b 100644 --- a/charon/tests/ui/traits_special.out +++ b/charon/tests/ui/traits_special.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/type-id.out b/charon/tests/ui/type-id.out index d77d437ff..2372db526 100644 --- a/charon/tests/ui/type-id.out +++ b/charon/tests/ui/type-id.out @@ -7,10 +7,12 @@ pub struct TypeId { } // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::intrinsics::type_id +#[rustc_intrinsic] pub fn type_id() -> TypeId where TraitClause0: (T: MetaSized), @@ -45,6 +47,7 @@ where } // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/type_alias.out b/charon/tests/ui/type_alias.out index c7b14746b..562ecaf34 100644 --- a/charon/tests/ui/type_alias.out +++ b/charon/tests/ui/type_alias.out @@ -1,6 +1,7 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized @@ -15,6 +16,7 @@ pub trait Borrow } // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/type_inference_is_order_dependent.out b/charon/tests/ui/type_inference_is_order_dependent.out index eaee40c25..f16f1d1dd 100644 --- a/charon/tests/ui/type_inference_is_order_dependent.out +++ b/charon/tests/ui/type_inference_is_order_dependent.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/unsafe.out b/charon/tests/ui/unsafe.out index 02f1ecaaa..7819f1bc7 100644 --- a/charon/tests/ui/unsafe.out +++ b/charon/tests/ui/unsafe.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -148,6 +150,7 @@ impl "impl_Hash_for_unit" Hash for () { non-dyn-compatible } +#[rustc_intrinsic] pub unsafe fn core::intrinsics::assume(b_1: bool) = @@ -179,6 +182,7 @@ pub trait Freeze pub trait Unpin // Full name: core::ptr::const_ptr::{*const T}::read +#[track_caller] pub unsafe fn read(_1: *const T) -> T where TraitClause0: (T: Sized), diff --git a/charon/tests/ui/unsize.out b/charon/tests/ui/unsize.out index b57f5fe7d..7a1e4fb52 100644 --- a/charon/tests/ui/unsize.out +++ b/charon/tests/ui/unsize.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/unsized-string-consts.out b/charon/tests/ui/unsized-string-consts.out index f6210eda7..22671f330 100644 --- a/charon/tests/ui/unsized-string-consts.out +++ b/charon/tests/ui/unsized-string-consts.out @@ -1,6 +1,7 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized diff --git a/charon/tests/ui/unsupported/issue-79-bound-regions.out b/charon/tests/ui/unsupported/issue-79-bound-regions.out index 6482fafc4..ff1bde86d 100644 --- a/charon/tests/ui/unsupported/issue-79-bound-regions.out +++ b/charon/tests/ui/unsupported/issue-79-bound-regions.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/unwind-llbc.out b/charon/tests/ui/unwind-llbc.out index 996785f6f..df7ba34bd 100644 --- a/charon/tests/ui/unwind-llbc.out +++ b/charon/tests/ui/unwind-llbc.out @@ -1,6 +1,7 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized diff --git a/charon/tests/ui/variadics.out b/charon/tests/ui/variadics.out index 49d336b8d..f418d24f1 100644 --- a/charon/tests/ui/variadics.out +++ b/charon/tests/ui/variadics.out @@ -11,6 +11,7 @@ where = // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized @@ -29,6 +30,7 @@ impl "impl_VaArgSafe_for_i32" VaArgSafe for i32 { } // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { @@ -37,6 +39,7 @@ pub trait Sized } // Full name: core::ffi::va_list::{VaList<'f>}::next_arg +#[track_caller] pub unsafe fn next_arg<'f, '_1, T>(_1: &'_1 mut VaList<'f>) -> T where TraitClause0: (T: Sized), diff --git a/charon/tests/ui/vec-reconstruct-move-values.out b/charon/tests/ui/vec-reconstruct-move-values.out index 934429062..ff5ac4185 100644 --- a/charon/tests/ui/vec-reconstruct-move-values.out +++ b/charon/tests/ui/vec-reconstruct-move-values.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/vec-reconstruct-multiple-adjacent.out b/charon/tests/ui/vec-reconstruct-multiple-adjacent.out index 4ec89c62c..5eeccdab9 100644 --- a/charon/tests/ui/vec-reconstruct-multiple-adjacent.out +++ b/charon/tests/ui/vec-reconstruct-multiple-adjacent.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/vec-reconstruct-nested.out b/charon/tests/ui/vec-reconstruct-nested.out index 351407e5d..f25cc8113 100644 --- a/charon/tests/ui/vec-reconstruct-nested.out +++ b/charon/tests/ui/vec-reconstruct-nested.out @@ -1,10 +1,12 @@ # Final LLBC before serialization: // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/vtable-simple.out b/charon/tests/ui/vtable-simple.out index 7e4d4086c..6cf347c67 100644 --- a/charon/tests/ui/vtable-simple.out +++ b/charon/tests/ui/vtable-simple.out @@ -3,10 +3,12 @@ opaque type core::marker::MetaSized::{vtable} // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/vtable_drop.out b/charon/tests/ui/vtable_drop.out index 4437e83d5..3bdedff7b 100644 --- a/charon/tests/ui/vtable_drop.out +++ b/charon/tests/ui/vtable_drop.out @@ -11,10 +11,12 @@ pub trait Destruct opaque type core::marker::MetaSized::{vtable} // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized { diff --git a/charon/tests/ui/vtables.out b/charon/tests/ui/vtables.out index 4f50a8ca5..3335feda2 100644 --- a/charon/tests/ui/vtables.out +++ b/charon/tests/ui/vtables.out @@ -3,10 +3,12 @@ opaque type core::marker::MetaSized::{vtable} // Full name: core::marker::MetaSized +#[fundamental] #[lang_item(MetaSized)] pub trait MetaSized // Full name: core::marker::Sized +#[fundamental] #[lang_item(Sized)] pub trait Sized {