jiebi/CodeConvo huggingface dataset:
<ins> error: cannot find macro `something_later` in this scope --> $DIR/defined-later-issue-121061.rs:2:5 | LL |     something_later!(); |     ^^^^^^^^^^^^^^^ consider moving the definition of `something_later` before this call | note: a macro with the same name exists, but it appears later at here --> $DIR/defined-later-issue-121061.rs:5:14 | LL | macro_rules! something_later { |              ^^^^^^^^^^^^^^^ error: aborting due to 1 previous error </ins>
ItemId { owner_id: self.owner_id } } <ins> /// Check if this is an [`ItemKind::Enum`], [`ItemKind::Struct`] or /// [`ItemKind::Union`]. pub fn is_adt(&self) -> bool { matches!(self.kind, ItemKind::Enum(..) | ItemKind::Struct(..) | ItemKind::Union(..)) } </ins> expect_methods_self_kind! { expect_extern_crate, Option<Symbol>, ItemKind::ExternCrate(s), *s;
for field in variant.fields.iter().filter(|f| f.is_unnamed()) { let field_ty = tcx.type_of(field.did).instantiate_identity(); if let Some(adt) = field_ty.ty_adt_def() <del> && !adt.is_anonymous() && !adt.repr().c() </del> <ins> && !adt.is_enum() </ins> { <del> let field_ty_span = tcx.def_span(adt.did()); tcx.dcx().emit_err(errors::UnnamedFieldsRepr::FieldMissingReprC { span: tcx.def_span(field.did), field_ty_span, field_ty, field_adt_kind: adt.descr(), sugg_span: field_ty_span.shrink_to_lo(), }); </del> <ins> if !adt.is_anonymous() && !adt.repr().c() { let field_ty_span = tcx.def_span(adt.did()); tcx.dcx().emit_err(errors::UnnamedFieldsRepr::FieldMissingReprC { span: tcx.def_span(field.did), field_ty_span, field_ty, field_adt_kind: adt.descr(), sugg_span: field_ty_span.shrink_to_lo(), }); } } else { tcx.dcx().emit_err(errors::InvalidUnnamedFieldTy { span: tcx.def_span(field.did) }); </ins> } } }
} } hir::TyKind::Path(hir::QPath::Resolved(_, hir::Path { res, .. })) => { <del> self.check_field_in_nested_adt(self.tcx.adt_def(res.def_id()), field.span); </del> <ins> // If this is a direct path to an ADT, we can check it // If this is a type alias or non-ADT, `check_unnamed_fields` should verify it if let Some(def_id) = res.opt_def_id() && let Some(local) = def_id.as_local() && let Node::Item(item) = self.tcx.hir_node_by_def_id(local) && item.is_adt() { self.check_field_in_nested_adt(self.tcx.adt_def(def_id), field.span); } </ins> } // Abort due to errors (there must be an error if an unnamed field //  has any type kind other than an anonymous adt or a named adt)
} #[derive(Diagnostic)] <ins> #[diag(hir_analysis_invalid_unnamed_field_ty)] pub struct InvalidUnnamedFieldTy { #[primary_span] pub span: Span, } #[derive(Diagnostic)] </ins> #[diag(hir_analysis_return_type_notation_on_non_rpitit)] pub(crate) struct ReturnTypeNotationOnNonRpitit<'tcx> { #[primary_span]
<ins> //@ aux-build:dep.rs // test for #121151 #![allow(incomplete_features)] #![feature(unnamed_fields)] extern crate dep; #[repr(C)] struct A { a: u8, } enum BadEnum { A, B, } #[repr(C)] enum BadEnum2 { A, B, } type MyStruct = A; type MyI32 = i32; #[repr(C)] struct L { _: i32, //~ ERROR unnamed fields can only have struct or union types _: MyI32, //~ ERROR unnamed fields can only have struct or union types _: BadEnum, //~ ERROR unnamed fields can only have struct or union types _: BadEnum2, //~ ERROR unnamed fields can only have struct or union types _: MyStruct, _: dep::BadStruct, //~ ERROR named type of unnamed field must have `#[repr(C)]` representation _: dep::BadEnum, //~ ERROR unnamed fields can only have struct or union types _: dep::BadEnum2, //~ ERROR unnamed fields can only have struct or union types _: dep::BadAlias, //~ ERROR unnamed fields can only have struct or union types _: dep::GoodAlias, _: dep::GoodStruct, } fn main() {} </ins>
<ins> error: unnamed fields can only have struct or union types --> $DIR/restrict_type_hir.rs:31:5 | LL |     _: i32, |     ^^^^^^ error: unnamed fields can only have struct or union types --> $DIR/restrict_type_hir.rs:32:5 | LL |     _: MyI32, |     ^^^^^^^^ error: unnamed fields can only have struct or union types --> $DIR/restrict_type_hir.rs:33:5 | LL |     _: BadEnum, |     ^^^^^^^^^^ error: unnamed fields can only have struct or union types --> $DIR/restrict_type_hir.rs:34:5 | LL |     _: BadEnum2, |     ^^^^^^^^^^^ error: named type of unnamed field must have `#[repr(C)]` representation --> $DIR/restrict_type_hir.rs:36:5 | LL |     _: dep::BadStruct, |     ^^^^^^^^^^^^^^^^^ unnamed field defined here | ::: $DIR/auxiliary/dep.rs:4:1 | LL | pub struct BadStruct(()); | -------------------- `BadStruct` defined here | help: add `#[repr(C)]` to this struct --> $DIR/auxiliary/dep.rs:4:1 | LL + #[repr(C)] LL | pub struct BadStruct(()); | error: unnamed fields can only have struct or union types --> $DIR/restrict_type_hir.rs:37:5 | LL |     _: dep::BadEnum, |     ^^^^^^^^^^^^^^^ error: unnamed fields can only have struct or union types --> $DIR/restrict_type_hir.rs:38:5 | LL |     _: dep::BadEnum2, |     ^^^^^^^^^^^^^^^^ error: unnamed fields can only have struct or union types --> $DIR/restrict_type_hir.rs:39:5 | LL |     _: dep::BadAlias, |     ^^^^^^^^^^^^^^^^ error: aborting due to 8 previous errors </ins>
let func_ty = func.ty(body, tcx); if let ty::FnDef(callee, args) = *func_ty.kind() { <del> let normalized_args = tcx.normalize_erasing_regions(param_env, args); </del> <ins> let Ok(normalized_args) = tcx.try_normalize_erasing_regions(param_env, args) else { return false; }; </ins> let (callee, call_args) = if let Ok(Some(instance)) = Instance::resolve(tcx, param_env, callee, normalized_args) {
<ins> fn problematic_function<Space>(material_surface_element: ()) where DefaultAllocator: FiniteElementAllocator<(), Space>, { let _: Point2<f64> = material_surface_element.map_reference_coords().into(); } impl<N, R> Allocator<N, R> for DefaultAllocator where R::Value: DimName, //~ ERROR: `Value` not found for `R` { type Buffer = (); } impl<N> Allocator<N, ()> for DefaultAllocator {} //~^ ERROR: conflicting implementations impl DimName for () {} impl DimName for u32 {} impl<N, D: DimName> From<VectorN<N, D>> for Point<N, D> { fn from(_: VectorN<N, D>) -> Self { todo!() } } impl FiniteElement<u32> for () {} type VectorN<N, D> = Matrix<<DefaultAllocator as Allocator<N, D>>::Buffer>; type Point2<N> = Point<N, u32>; struct DefaultAllocator; struct Matrix<S>(S); struct Point<N, D>(N, D); trait Allocator<Scalar, R> { type Buffer; } trait DimName {} trait FiniteElementAllocator<GeometryDim, NodalDim>: Allocator<f64, ()> + Allocator<f64, NodalDim> { } trait FiniteElement<GeometryDim> { fn map_reference_coords(&self) -> VectorN<f64, GeometryDim> { todo!() } } fn main() {} </ins>
<ins> error[E0220]: associated type `Value` not found for `R` --> $DIR/normalize-conflicting-impls.rs:10:8 | LL |     R::Value: DimName, |        ^^^^^ associated type `Value` not found error[E0119]: conflicting implementations of trait `Allocator<_, ()>` for type `DefaultAllocator` --> $DIR/normalize-conflicting-impls.rs:14:1 | LL | / impl<N, R> Allocator<N, R> for DefaultAllocator LL | | where LL | |     R::Value: DimName, | |______________________- first implementation here ... LL |   impl<N> Allocator<N, ()> for DefaultAllocator {} |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `DefaultAllocator` error: aborting due to 2 previous errors Some errors have detailed explanations: E0119, E0220. For more information about an error, try `rustc --explain E0119`. </ins>
} else if let UseSpans::FnSelfUse { kind: CallKind::Normal { .. }, .. } = move_spans { // We already suggest cloning for these cases in `explain_captures`. <ins> } else if let UseSpans::ClosureUse { closure_kind: ClosureKind::Coroutine(CoroutineKind::Desugared(_, CoroutineSource::Block)), args_span: _, capture_kind_span: _, path_span, } = move_spans { self.suggest_cloning(err, ty, expr, path_span); </ins> } else if self.suggest_hoisting_call_outside_loop(err, expr) { // The place where the the type moves would be misleading to suggest clone. // #121466
} // FIXME: We make sure that this is a normal top-level binding, <del> // but we could suggest `todo!()` for all uninitalized bindings in the pattern pattern </del> <ins> // but we could suggest `todo!()` for all uninitialized bindings in the pattern pattern </ins> if let hir::StmtKind::Let(hir::LetStmt { span, ty, init: None, pat, .. }) = &ex.kind && let hir::PatKind::Binding(..) = pat.kind
true } <del> /// In a move error that occurs on a call wihtin a loop, we try to identify cases where cloning </del> <ins> /// In a move error that occurs on a call within a loop, we try to identify cases where cloning </ins> /// the value would lead to a logic error. We infer these cases by seeing if the moved value is /// part of the logic to break the loop, either through an explicit `break` or if the expression /// is part of a `while let`.
{ // FIXME: We could check that the call's *parent* takes `&mut val` to make the // suggestion more targeted to the `mk_iter(val).next()` case. Maybe do that only to <del> // check for wheter to suggest `let value` or `let mut value`. </del> <ins> // check for whether to suggest `let value` or `let mut value`. </ins> let span = in_loop.span; if !finder.found_breaks.is_empty()
<ins> error[E0382]: use of moved value: `value` --> $DIR/cloning-in-async-block-121547.rs:5:9 | LL |   async fn clone_async_block(value: String) { |                              ----- move occurs because `value` has type `String`, which does not implement the `Copy` trait LL |       for _ in 0..10 { |       -------------- inside of this loop LL | /         async { LL | |             drop(value); | |                  ----- use occurs due to use in coroutine LL | | LL | |         }.await | |_________^ value moved here, in previous iteration of loop | help: consider cloning the value if the performance cost is acceptable | LL |             drop(value.clone()); |                       ++++++++ error: aborting due to 1 previous error For more information about this error, try `rustc --explain E0382`. </ins>
/// `ManuallyDrop` to control drop order (needs to be dropped after all the nodes). pub(super) alloc: ManuallyDrop<A>, // For dropck; the `Box` avoids making the `Unpin` impl more strict than before <del> _marker: PhantomData<crate::boxed::Box<(K, V)>>, </del> <ins> _marker: PhantomData<crate::boxed::Box<(K, V), A>>, </ins> } #[stable(feature = "btree_drop", since = "1.7.0")]
// If we have a symlink like libLLVM-18.so -> libLLVM.so.18.1, install the target of the // symlink, which is what will actually get loaded at runtime. builder.install(&t!(fs::canonicalize(source)), destination, 0o644); <ins> let full_dest = destination.join(source.file_name().unwrap()); </ins> if install_symlink { <del> // If requested, also install the symlink. This is used by download-ci-llvm. let full_dest = destination.join(source.file_name().unwrap()); </del> <ins> // For download-ci-llvm, also install the symlink, to match what LLVM does. Using a // symlink is fine here, as this is not a rustup component. </ins> builder.copy(&source, &full_dest); <ins> } else { // Otherwise, replace the symlink with an equivalent linker script. This is used when // projects like miri link against librustc_driver.so. We don't use a symlink, as // these are not allowed inside rustup components. let link = t!(fs::read_link(source)); t!(std::fs::write(full_dest, format!("INPUT({})n", link.display()))); </ins> } } else { builder.install(&source, destination, 0o644);
let suggest_eq = if self.token.kind == token::Dot && let _ = self.bump() && let mut snapshot = self.create_snapshot_for_diagnostic() <del> && let Ok(_) = snapshot.parse_dot_suffix_expr( colon_sp, self.mk_expr_err( </del> <ins> && let Ok(_) = snapshot .parse_dot_suffix_expr( </ins> colon_sp, <del> self.dcx().delayed_bug("error during `:` -> `=` recovery"), ), ) { </del> <ins> self.mk_expr_err( colon_sp, self.dcx() .delayed_bug("error during `:` -> `=` recovery"), ), ) .map_err(Diag::cancel) { </ins> true } else if let Some(op) = self.check_assoc_op() && op.node.can_continue_expr_unambiguously()
error: expected one of `!`, `+`, `->`, `::`, `;`, or `=`, found `.` <del> --> $DIR/recover-colon-instead-of-eq-in-local.rs:2:32 </del> <ins> --> $DIR/recover-colon-instead-of-eq-in-local.rs:5:32 | LL |     let _: std::env::temp_dir().join(&self, push: Box<usize>); |          -                     ^ expected one of `!`, `+`, `->`, `::`, `;`, or `=` |          | |          while parsing the type for `_` error: expected one of `!`, `+`, `->`, `::`, `;`, or `=`, found `.` --> $DIR/recover-colon-instead-of-eq-in-local.rs:9:32 </ins> | LL |     let _: std::env::temp_dir().join("foo"); |          -                     ^ expected one of `!`, `+`, `->`, `::`, `;`, or `=`
kind: hir::GenericParamKind::Type { default: Some(ty), .. }, .. }) => vec![*ty], <ins> hir::Node::AnonConst(_) if let Some(const_param_id) = tcx.hir().opt_const_param_default_param_def_id(hir_id) && let hir::Node::GenericParam(hir::GenericParam { kind: hir::GenericParamKind::Const { ty, .. }, .. }) = tcx.hir_node_by_def_id(const_param_id) => { vec![*ty] } </ins> ref node => bug!("Unexpected node {:?}", node), }, WellFormedLoc::Param { function: _, param_idx } => {
<ins> trait Trait<const N: Trait = bar> { //~^ ERROR cannot find value `bar` in this scope //~| ERROR cycle detected when computing type of `Trait::N` //~| ERROR cycle detected when computing type of `Trait::N` //~| ERROR `(dyn Trait<{const error}> + 'static)` is forbidden as the type of a const generic parameter //~| WARN trait objects without an explicit `dyn` are deprecated //~| WARN this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021! fn fnc(&self) { } } fn main() {} </ins>
<ins> error[E0425]: cannot find value `bar` in this scope --> $DIR/ice-hir-wf-check-anon-const-issue-122199.rs:1:30 | LL | trait Trait<const N: Trait = bar> { |                              ^^^ not found in this scope warning: trait objects without an explicit `dyn` are deprecated --> $DIR/ice-hir-wf-check-anon-const-issue-122199.rs:1:22 | LL | trait Trait<const N: Trait = bar> { |                      ^^^^^ | = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021! = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html> = note: `#[warn(bare_trait_objects)]` on by default help: if this is an object-safe trait, use `dyn` | LL | trait Trait<const N: dyn Trait = bar> { |                      +++ error[E0391]: cycle detected when computing type of `Trait::N` --> $DIR/ice-hir-wf-check-anon-const-issue-122199.rs:1:22 | LL | trait Trait<const N: Trait = bar> { |                      ^^^^^ | = note: ...which immediately requires computing type of `Trait::N` again note: cycle used when computing explicit predicates of trait `Trait` --> $DIR/ice-hir-wf-check-anon-const-issue-122199.rs:1:1 | LL | trait Trait<const N: Trait = bar> { | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information error[E0391]: cycle detected when computing type of `Trait::N` --> $DIR/ice-hir-wf-check-anon-const-issue-122199.rs:1:13 | LL | trait Trait<const N: Trait = bar> { |             ^^^^^^^^^^^^^^^^^^^^ | = note: ...which immediately requires computing type of `Trait::N` again note: cycle used when computing explicit predicates of trait `Trait` --> $DIR/ice-hir-wf-check-anon-const-issue-122199.rs:1:1 | LL | trait Trait<const N: Trait = bar> { | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information error: `(dyn Trait<{const error}> + 'static)` is forbidden as the type of a const generic parameter --> $DIR/ice-hir-wf-check-anon-const-issue-122199.rs:1:22 | LL | trait Trait<const N: Trait = bar> { |                      ^^^^^ | = note: the only supported types are integers, `bool` and `char` error: aborting due to 4 previous errors; 1 warning emitted Some errors have detailed explanations: E0391, E0425. For more information about an error, try `rustc --explain E0391`. </ins>
trait Trait<const N: Trait = bar> { <del> //~^ ERROR cannot find value `bar` in this scope //~| ERROR cycle detected when computing type of `Trait::N` //~| ERROR cycle detected when computing type of `Trait::N` //~| ERROR `(dyn Trait<{const error}> + 'static)` is forbidden as the type of a const generic parameter //~| WARN trait objects without an explicit `dyn` are deprecated //~| WARN this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021! fn fnc(&self) { </del> <ins> //~^ ERROR cannot find value `bar` in this scope //~| ERROR cycle detected when computing type of `Trait::N` //~| ERROR cycle detected when computing type of `Trait::N` //~| ERROR the trait `Trait` cannot be made into an object //~| ERROR the trait `Trait` cannot be made into an object //~| ERROR the trait `Trait` cannot be made into an object //~| ERROR `(dyn Trait<{const error}> + 'static)` is forbidden as the type of a const generic parameter //~| WARN trait objects without an explicit `dyn` are deprecated [bare_trait_objects] //~| WARN this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021! //~| WARN trait objects without an explicit `dyn` are deprecated [bare_trait_objects] //~| WARN this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021! fn fnc<const N: Trait = u32>(&self) -> Trait { //~^ ERROR the name `N` is already used for a generic parameter in this item's generic parameters //~| ERROR expected value, found builtin type `u32` //~| ERROR defaults for const parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions //~| ERROR associated item referring to unboxed trait object for its own trait //~| ERROR the trait `Trait` cannot be made into an object //~| ERROR `(dyn Trait<{const error}> + 'static)` is forbidden as the type of a const generic parameter //~| WARN trait objects without an explicit `dyn` are deprecated [bare_trait_objects] //~| WARN this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021! //~| WARN trait objects without an explicit `dyn` are deprecated [bare_trait_objects] //~| WARN this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021! //~| WARN trait objects without an explicit `dyn` are deprecated [bare_trait_objects] //~| WARN this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021! bar //~^ ERROR cannot find value `bar` in this scope </ins> } }
<ins> error[E0403]: the name `N` is already used for a generic parameter in this item's generic parameters --> $DIR/ice-hir-wf-check-anon-const-issue-122199.rs:13:18 | LL | trait Trait<const N: Trait = bar> { |                   - first use of `N` ... LL |     fn fnc<const N: Trait = u32>(&self) -> Trait { |                  ^ already used </ins> error[E0425]: cannot find value `bar` in this scope --> $DIR/ice-hir-wf-check-anon-const-issue-122199.rs:1:30 | LL | trait Trait<const N: Trait = bar> { |                              ^^^ not found in this scope <ins> error[E0423]: expected value, found builtin type `u32` --> $DIR/ice-hir-wf-check-anon-const-issue-122199.rs:13:29 | LL |     fn fnc<const N: Trait = u32>(&self) -> Trait { |                             ^^^ not a value error[E0425]: cannot find value `bar` in this scope --> $DIR/ice-hir-wf-check-anon-const-issue-122199.rs:26:9 | LL |         bar |         ^^^ not found in this scope </ins> warning: trait objects without an explicit `dyn` are deprecated --> $DIR/ice-hir-wf-check-anon-const-issue-122199.rs:1:22 |
use middle::freevars; use middle::pat_util; use middle::ty; <del> use middle::typeck::MethodCall; </del> <ins> use middle::typeck::{MethodCall, MethodObject, MethodOrigin, MethodParam}; use middle::typeck::{MethodStatic}; </ins> use middle::typeck; <del> use syntax::ast; use syntax::codemap::{Span}; </del> use util::ppaux::Repr; use std::gc::Gc; <ins> use syntax::ast; use syntax::codemap::Span; </ins> /////////////////////////////////////////////////////////////////////////// // The Delegate trait
WriteAndRead, // x += y } <ins> enum OverloadedCallType { FnOverloadedCall, FnMutOverloadedCall, FnOnceOverloadedCall, } impl OverloadedCallType { fn from_trait_id(tcx: &ty::ctxt, trait_id: ast::DefId) -> OverloadedCallType { for &(maybe_function_trait, overloaded_call_type) in [ (tcx.lang_items.fn_once_trait(), FnOnceOverloadedCall), (tcx.lang_items.fn_mut_trait(), FnMutOverloadedCall), (tcx.lang_items.fn_trait(), FnOverloadedCall) ].iter() { match maybe_function_trait { Some(function_trait) if function_trait == trait_id => { return overloaded_call_type } _ => continue, } } tcx.sess.bug("overloaded call didn't map to known function trait") } fn from_method_id(tcx: &ty::ctxt, method_id: ast::DefId) -> OverloadedCallType { let method_descriptor = match tcx.methods.borrow_mut().find(&method_id) { None => { tcx.sess.bug("overloaded call method wasn't in method  map") } Some(ref method_descriptor) => (*method_descriptor).clone(), }; let impl_id = match method_descriptor.container { ty::TraitContainer(_) => { tcx.sess.bug("statically resolved overloaded call method  belonged to a trait?!") } ty::ImplContainer(impl_id) => impl_id, }; let trait_ref = match ty::impl_trait_ref(tcx, impl_id) { None => { tcx.sess.bug("statically resolved overloaded call impl  didn't implement a trait?!") } Some(ref trait_ref) => (*trait_ref).clone(), }; OverloadedCallType::from_trait_id(tcx, trait_ref.def_id) } fn from_method_origin(tcx: &ty::ctxt, origin: &MethodOrigin) -> OverloadedCallType { match *origin { MethodStatic(def_id) => { OverloadedCallType::from_method_id(tcx, def_id) } MethodParam(ref method_param) => { OverloadedCallType::from_trait_id(tcx, method_param.trait_id) } MethodObject(ref method_object) => { OverloadedCallType::from_trait_id(tcx, method_object.trait_id) } } } } </ins> /////////////////////////////////////////////////////////////////////////// // The ExprUseVisitor type //
} } _ => { <del> match self.tcx() .method_map .borrow() .find(&MethodCall::expr(call.id)) { Some(_) => { // FIXME(#14774, pcwalton): Implement this. </del> <ins> let overloaded_call_type = match self.tcx() .method_map .borrow() .find(&MethodCall::expr(call.id)) { Some(ref method_callee) => { OverloadedCallType::from_method_origin( self.tcx(), &method_callee.origin) </ins> } None => { self.tcx().sess.span_bug( callee.span, format!("unexpected callee type {}", <del> callee_ty.repr(self.tcx())).as_slice()); </del> <ins> callee_ty.repr(self.tcx())).as_slice()) } }; match overloaded_call_type { FnMutOverloadedCall => { self.borrow_expr(callee, ty::ReScope(call.id), ty::MutBorrow, ClosureInvocation); } FnOverloadedCall => { self.borrow_expr(callee, ty::ReScope(call.id), ty::ImmBorrow, ClosureInvocation); </ins> } <ins> FnOnceOverloadedCall => self.consume_expr(callee), </ins> } } }