From b1d7765e3fa354e445d92228bbff23a05db0fe7b Mon Sep 17 00:00:00 2001 From: Nico Lehmann Date: Wed, 27 Nov 2024 11:13:37 -0800 Subject: [PATCH 1/3] Update to 2024-09-20 --- crates/flux-desugar/src/lib.rs | 2 +- crates/flux-driver/src/callbacks.rs | 3 ++- crates/flux-fhir-analysis/src/conv/mod.rs | 24 +++++++++---------- crates/flux-middle/src/lib.rs | 1 - crates/flux-middle/src/rty/mod.rs | 2 +- crates/flux-refineck/src/ghost_statements.rs | 1 + .../src/ghost_statements/points_to.rs | 8 +++---- rust-toolchain | 2 +- 8 files changed, 21 insertions(+), 22 deletions(-) diff --git a/crates/flux-desugar/src/lib.rs b/crates/flux-desugar/src/lib.rs index d73a4d8628..46c9e10e8b 100644 --- a/crates/flux-desugar/src/lib.rs +++ b/crates/flux-desugar/src/lib.rs @@ -213,7 +213,7 @@ impl<'genv, 'tcx> DesugarCtxt<'genv, 'tcx> { &'a self, owner_id: OwnerId, opaque_tys: Option<&'a mut UnordMap>>, - ) -> RustItemCtxt<'_, 'genv, 'tcx> { + ) -> RustItemCtxt<'a, 'genv, 'tcx> { let owner_id = self .genv .maybe_extern_id(owner_id.def_id) diff --git a/crates/flux-driver/src/callbacks.rs b/crates/flux-driver/src/callbacks.rs index 1b75c03c58..7090e56310 100644 --- a/crates/flux-driver/src/callbacks.rs +++ b/crates/flux-driver/src/callbacks.rs @@ -231,7 +231,7 @@ impl<'genv, 'tcx> CrateChecker<'genv, 'tcx> { fn mir_borrowck<'tcx>( tcx: TyCtxt<'tcx>, def_id: LocalDefId, -) -> query::queries::mir_borrowck::ProvidedValue { +) -> query::queries::mir_borrowck::ProvidedValue<'tcx> { let body_with_facts = rustc_borrowck::consumers::get_body_with_borrowck_facts( tcx, def_id, @@ -244,6 +244,7 @@ fn mir_borrowck<'tcx>( &body_with_facts.body, &mut |_, _| Ok(()), &mut dbg::writer_for_item(tcx, def_id.to_def_id(), "mir").unwrap(), + rustc_middle::mir::pretty::PrettyPrintMirOptions::from_cli(tcx), ) .unwrap(); } diff --git a/crates/flux-fhir-analysis/src/conv/mod.rs b/crates/flux-fhir-analysis/src/conv/mod.rs index c679f173c0..f587a24612 100644 --- a/crates/flux-fhir-analysis/src/conv/mod.rs +++ b/crates/flux-fhir-analysis/src/conv/mod.rs @@ -1295,14 +1295,12 @@ impl<'genv, 'tcx: 'genv, P: ConvPhase<'genv, 'tcx>> ConvCtxt

{ } fhir::Res::Def(DefKind::TyParam, param_id) | fhir::Res::SelfTyParam { trait_: param_id } => { - let predicates = self - .probe_type_param_bounds(param_id, assoc_ident) - .predicates; + let predicates = self.probe_type_param_bounds(param_id, assoc_ident); self.probe_single_bound_for_assoc_item( || { traits::transitive_bounds_that_define_assoc_item( tcx, - predicates.iter().filter_map(|(p, _)| { + predicates.iter_identity_copied().filter_map(|(p, _)| { Some(p.as_trait_clause()?.map_bound(|t| t.trait_ref)) }), assoc_ident, @@ -1364,7 +1362,7 @@ impl<'genv, 'tcx: 'genv, P: ConvPhase<'genv, 'tcx>> ConvCtxt

{ &self, param_id: DefId, assoc_ident: Ident, - ) -> ty::GenericPredicates<'tcx> { + ) -> ty::EarlyBinder<'tcx, &'tcx [(ty::Clause<'tcx>, Span)]> { // We would like to do this computation on the resolved id for it to work with extern specs // but the `type_param_predicates` query is only defined for `LocalDefId`. This is mostly // fine because the worst that can happen is that we fail to infer a trait when using the @@ -1381,7 +1379,7 @@ impl<'genv, 'tcx: 'genv, P: ConvPhase<'genv, 'tcx>> ConvCtxt

{ self.tcx() .type_param_predicates((owner_id.def_id, param_id, assoc_ident)) } - FluxOwnerId::Flux(_) => ty::GenericPredicates::default(), + FluxOwnerId::Flux(_) => ty::EarlyBinder::bind(&[]), } } @@ -1419,22 +1417,22 @@ impl<'genv, 'tcx: 'genv, P: ConvPhase<'genv, 'tcx>> ConvCtxt

{ match res { ResolvedArg::StaticLifetime => rty::ReStatic, ResolvedArg::EarlyBound(def_id) => { - let index = self.genv().def_id_to_param_index(def_id); - let name = lifetime_name(def_id); + let index = self.genv().def_id_to_param_index(def_id.to_def_id()); + let name = lifetime_name(def_id.to_def_id()); rty::ReEarlyParam(rty::EarlyParamRegion { index, name }) } ResolvedArg::LateBound(_, index, def_id) => { let depth = env.depth().checked_sub(1).unwrap(); - let name = lifetime_name(def_id); - let kind = rty::BoundRegionKind::BrNamed(def_id, name); + let name = lifetime_name(def_id.to_def_id()); + let kind = rty::BoundRegionKind::BrNamed(def_id.to_def_id(), name); let var = BoundVar::from_u32(index); let bound_region = rty::BoundRegion { var, kind }; rty::ReBound(rty::DebruijnIndex::from_usize(depth), bound_region) } ResolvedArg::Free(scope, id) => { - let name = lifetime_name(id); - let bound_region = rty::BoundRegionKind::BrNamed(id, name); - rty::ReLateParam(rty::LateParamRegion { scope, bound_region }) + let name = lifetime_name(id.to_def_id()); + let bound_region = rty::BoundRegionKind::BrNamed(id.to_def_id(), name); + rty::ReLateParam(rty::LateParamRegion { scope: scope.to_def_id(), bound_region }) } ResolvedArg::Error(_) => bug!("lifetime resolved to an error"), } diff --git a/crates/flux-middle/src/lib.rs b/crates/flux-middle/src/lib.rs index fa4f14266c..14c425a888 100644 --- a/crates/flux-middle/src/lib.rs +++ b/crates/flux-middle/src/lib.rs @@ -9,7 +9,6 @@ map_try_insert, min_specialization, never_type, - precise_capturing, rustc_private, unwrap_infallible )] diff --git a/crates/flux-middle/src/rty/mod.rs b/crates/flux-middle/src/rty/mod.rs index c3bf82b3ed..0d45b1d4e5 100644 --- a/crates/flux-middle/src/rty/mod.rs +++ b/crates/flux-middle/src/rty/mod.rs @@ -145,7 +145,7 @@ impl AdtSortDef { /// Given a list of generic args, returns an iterator of the generic arguments that should be /// mapped to sorts for instantiation. - pub fn filter_generic_args<'a, A>(&'a self, args: &'a [A]) -> impl Iterator + 'a { + pub fn filter_generic_args<'a, A>(&'a self, args: &'a [A]) -> impl Iterator + 'a { self.0.params.iter().map(|p| &args[p.index as usize]) } diff --git a/crates/flux-refineck/src/ghost_statements.rs b/crates/flux-refineck/src/ghost_statements.rs index fd32094ff6..4bb3affd90 100644 --- a/crates/flux-refineck/src/ghost_statements.rs +++ b/crates/flux-refineck/src/ghost_statements.rs @@ -181,6 +181,7 @@ impl GhostStatements { Ok(()) }, w, + rustc_middle::mir::pretty::PrettyPrintMirOptions::from_cli(tcx), ) } } diff --git a/crates/flux-refineck/src/ghost_statements/points_to.rs b/crates/flux-refineck/src/ghost_statements/points_to.rs index f56b2833f4..fae8e83ad2 100644 --- a/crates/flux-refineck/src/ghost_statements/points_to.rs +++ b/crates/flux-refineck/src/ghost_statements/points_to.rs @@ -280,9 +280,9 @@ impl<'a> CollectPointerToBorrows<'a> { } impl<'a, 'mir, 'tcx> ResultsVisitor<'mir, 'tcx, Results<'a, 'tcx>> for CollectPointerToBorrows<'_> { - type FlowState = State; + type Domain = State; - fn visit_block_start(&mut self, state: &Self::FlowState) { + fn visit_block_start(&mut self, state: &Self::Domain) { self.before_state.clear(); for place_idx in self.tracked_places.keys() { let value = state.get_idx(*place_idx, self.map); @@ -293,7 +293,7 @@ impl<'a, 'mir, 'tcx> ResultsVisitor<'mir, 'tcx, Results<'a, 'tcx>> for CollectPo fn visit_statement_after_primary_effect( &mut self, _results: &mut Results<'a, 'tcx>, - state: &Self::FlowState, + state: &Self::Domain, _statement: &'mir mir::Statement<'tcx>, location: mir::Location, ) { @@ -315,7 +315,7 @@ impl<'a, 'mir, 'tcx> ResultsVisitor<'mir, 'tcx, Results<'a, 'tcx>> for CollectPo fn visit_terminator_after_primary_effect( &mut self, results: &mut Results<'a, 'tcx>, - _state: &Self::FlowState, + _state: &Self::Domain, terminator: &'mir mir::Terminator<'tcx>, location: mir::Location, ) { diff --git a/rust-toolchain b/rust-toolchain index 93922b8928..fea4784296 100644 --- a/rust-toolchain +++ b/rust-toolchain @@ -1,3 +1,3 @@ [toolchain] -channel = "nightly-2024-08-20" +channel = "nightly-2024-09-20" components = ["rust-src", "rustc-dev", "llvm-tools", "rustfmt"] From 8f1f9f3940a808afee7b403f413a3e4557ac8a19 Mon Sep 17 00:00:00 2001 From: Nico Lehmann Date: Wed, 27 Nov 2024 17:29:51 -0800 Subject: [PATCH 2/3] Update to 2024-10-20 --- crates/flux-desugar/src/desugar.rs | 90 ++++++++-------- crates/flux-desugar/src/lib.rs | 25 ++--- crates/flux-desugar/src/resolver.rs | 18 ++-- crates/flux-driver/src/collector/mod.rs | 12 +-- crates/flux-fhir-analysis/src/conv/mod.rs | 58 +++++----- crates/flux-fhir-analysis/src/lib.rs | 81 +++++++++----- crates/flux-fhir-analysis/src/wf/mod.rs | 37 +++---- .../flux-fhir-analysis/src/wf/param_usage.rs | 4 +- crates/flux-fhir-analysis/src/wf/sortck.rs | 5 +- crates/flux-middle/src/fhir.rs | 67 ++++++++---- crates/flux-middle/src/fhir/lift.rs | 100 ++++++++---------- crates/flux-middle/src/fhir/visit.rs | 18 ++-- crates/flux-middle/src/global_env.rs | 29 +++-- crates/flux-middle/src/lib.rs | 3 +- crates/flux-middle/src/rty/projections.rs | 2 +- crates/flux-middle/src/rty/refining.rs | 2 +- crates/flux-refineck/src/checker.rs | 8 +- .../src/ghost_statements/points_to.rs | 8 +- crates/flux-rustc-bridge/src/lowering.rs | 15 ++- crates/flux-rustc-bridge/src/mir.rs | 6 +- rust-toolchain | 2 +- 21 files changed, 312 insertions(+), 278 deletions(-) diff --git a/crates/flux-desugar/src/desugar.rs b/crates/flux-desugar/src/desugar.rs index 3ea3a758bd..4a8fd1949b 100644 --- a/crates/flux-desugar/src/desugar.rs +++ b/crates/flux-desugar/src/desugar.rs @@ -13,7 +13,7 @@ use flux_syntax::{ walk_list, }; use hir::{def::DefKind, ItemKind}; -use rustc_data_structures::{fx::FxIndexSet, unord::UnordMap}; +use rustc_data_structures::fx::FxIndexSet; use rustc_errors::{Diagnostic, ErrorGuaranteed}; use rustc_hash::FxHashSet; use rustc_hir::{self as hir, OwnerId}; @@ -104,7 +104,7 @@ pub(crate) struct RustItemCtxt<'a, 'genv, 'tcx> { owner: MaybeExternId, fn_sig_scope: Option, resolver_output: &'genv ResolverOutput, - opaque_tys: Option<&'a mut UnordMap>>, + opaque_tys: Option<&'a mut Vec<&'genv fhir::OpaqueTy<'genv>>>, } struct FluxItemCtxt<'genv, 'tcx> { @@ -119,7 +119,7 @@ impl<'a, 'genv, 'tcx: 'genv> RustItemCtxt<'a, 'genv, 'tcx> { genv: GlobalEnv<'genv, 'tcx>, owner: MaybeExternId, resolver_output: &'genv ResolverOutput, - opaque_tys: Option<&'a mut UnordMap>>, + opaque_tys: Option<&'a mut Vec<&'genv fhir::OpaqueTy<'genv>>>, ) -> Self { RustItemCtxt { genv, @@ -131,13 +131,6 @@ impl<'a, 'genv, 'tcx: 'genv> RustItemCtxt<'a, 'genv, 'tcx> { } } - fn with_new_owner<'b>( - &'b mut self, - owner: MaybeExternId, - ) -> RustItemCtxt<'b, 'genv, 'tcx> { - RustItemCtxt::new(self.genv, owner, self.resolver_output, self.opaque_tys.as_deref_mut()) - } - fn as_lift_cx<'b>(&'b mut self) -> LiftCtxt<'b, 'genv, 'tcx> { LiftCtxt::new(self.genv, self.owner, &self.local_id_gen, self.opaque_tys.as_deref_mut()) } @@ -248,10 +241,7 @@ impl<'a, 'genv, 'tcx: 'genv> RustItemCtxt<'a, 'genv, 'tcx> { bounds: &[surface::TraitRef], ) -> Result> { try_alloc_slice!(self.genv, bounds, |bound| { - Ok(fhir::GenericBound::Trait( - self.desugar_trait_ref(bound)?, - fhir::TraitBoundModifier::None, - )) + Ok(fhir::GenericBound::Trait(self.desugar_trait_ref(bound)?)) }) } @@ -263,7 +253,12 @@ impl<'a, 'genv, 'tcx: 'genv> RustItemCtxt<'a, 'genv, 'tcx> { span_bug!(trait_ref.path.span, "desugar_alias_reft: unexpected qpath") }; let span = path.span; - Ok(fhir::PolyTraitRef { bound_generic_params: &[], trait_ref: path, span }) + Ok(fhir::PolyTraitRef { + bound_generic_params: &[], + modifiers: fhir::TraitBoundModifier::None, + trait_ref: path, + span, + }) } fn desugar_refined_by( @@ -638,21 +633,17 @@ impl<'a, 'genv, 'tcx: 'genv> RustItemCtxt<'a, 'genv, 'tcx> { ) -> Result> { match asyncness { surface::Async::Yes { node_id, span } => { - let item_id = self.resolver_output.impl_trait_res_map[&node_id]; - let def_id = item_id.owner_id.def_id; + let def_id = self.resolver_output.impl_trait_res_map[&node_id]; let res = Res::Def(DefKind::OpaqueTy, def_id.to_def_id()); // FIXME(nilehmann) since we can only pass local ids for opaque types it means we // can't support extern specs with opaque types. - let opaque_ty = self - .with_new_owner(MaybeExternId::Local(item_id.owner_id)) - .desugar_opaque_ty_for_async(returns)?; - self.insert_opaque_ty(item_id.owner_id.def_id, opaque_ty); + let opaque_ty = self.desugar_opaque_ty_for_async(def_id, returns)?; + let opaque_ty = self.insert_opaque_ty(opaque_ty); let (args, _) = self.desugar_generic_args(res, &[])?; - let item_id = hir::ItemId { owner_id: hir::OwnerId { def_id } }; let refine_args = self.implicit_params_to_args(self.fn_sig_scope.unwrap()); - let kind = fhir::TyKind::OpaqueDef(item_id, args, refine_args, false); + let kind = fhir::TyKind::OpaqueDef(opaque_ty, args, refine_args); Ok(fhir::Ty { kind, span }) } surface::Async::No => Ok(self.desugar_fn_ret_ty(returns)?), @@ -661,11 +652,10 @@ impl<'a, 'genv, 'tcx: 'genv> RustItemCtxt<'a, 'genv, 'tcx> { fn desugar_opaque_ty_for_async( &mut self, + def_id: LocalDefId, returns: &surface::FnRetTy, - ) -> Result> { + ) -> Result> { let output = self.desugar_fn_ret_ty(returns)?; - // Does this opaque type have any generics? - let generics = self.as_lift_cx().lift_generics()?; let trait_ref = self.make_lang_item_path( hir::LangItem::Future, DUMMY_SP, @@ -675,13 +665,17 @@ impl<'a, 'genv, 'tcx: 'genv> RustItemCtxt<'a, 'genv, 'tcx> { kind: fhir::AssocItemConstraintKind::Equality { term: output }, }]), ); - let bound = fhir::GenericBound::Trait( - fhir::PolyTraitRef { bound_generic_params: &[], trait_ref, span: trait_ref.span }, - fhir::TraitBoundModifier::None, - ); - let opaque_ty = fhir::OpaqueTy { bounds: self.genv.alloc_slice(&[bound]) }; - - Ok(fhir::Item { generics, kind: fhir::ItemKind::OpaqueTy(opaque_ty), owner_id: self.owner }) + let bound = fhir::GenericBound::Trait(fhir::PolyTraitRef { + bound_generic_params: &[], + modifiers: fhir::TraitBoundModifier::None, + trait_ref, + span: trait_ref.span, + }); + let opaque_ty = fhir::OpaqueTy { + def_id: MaybeExternId::Local(def_id), + bounds: self.genv.alloc_slice(&[bound]), + }; + Ok(opaque_ty) } fn make_lang_item_path( @@ -719,12 +713,12 @@ impl<'a, 'genv, 'tcx: 'genv> RustItemCtxt<'a, 'genv, 'tcx> { fn desugar_opaque_ty_for_impl_trait( &mut self, + def_id: LocalDefId, bounds: &[surface::TraitRef], - ) -> Result> { - let generics = self.as_lift_cx().lift_generics()?; + ) -> Result> { let bounds = self.desugar_generic_bounds(bounds)?; - let opaque_ty = fhir::OpaqueTy { bounds }; - Ok(fhir::Item { generics, kind: fhir::ItemKind::OpaqueTy(opaque_ty), owner_id: self.owner }) + let opaque_ty = fhir::OpaqueTy { def_id: MaybeExternId::Local(def_id), bounds }; + Ok(opaque_ty) } fn desugar_variant_ret( @@ -772,11 +766,16 @@ impl<'a, 'genv, 'tcx: 'genv> RustItemCtxt<'a, 'genv, 'tcx> { Some(resolved_id) } - fn insert_opaque_ty(&mut self, def_id: LocalDefId, opaque_ty: fhir::Item<'genv>) { + fn insert_opaque_ty( + &mut self, + opaque_ty: fhir::OpaqueTy<'genv>, + ) -> &'genv fhir::OpaqueTy<'genv> { + let opaque_ty = self.genv.alloc(opaque_ty); self.opaque_tys .as_mut() - .unwrap_or_else(|| bug!("`impl Trait` not supported in this item {def_id:?}")) - .insert(def_id, opaque_ty); + .unwrap_or_else(|| bug!("`impl Trait` not supported in this item `{:?}`", self.owner)) + .push(opaque_ty); + opaque_ty } #[track_caller] @@ -1533,20 +1532,17 @@ impl<'a, 'genv, 'tcx> DesugarCtxt<'genv, 'tcx> for RustItemCtxt<'a, 'genv, 'tcx> node_id: NodeId, bounds: &[surface::TraitRef], ) -> Result> { - let item_id = self.resolver_output().impl_trait_res_map[&node_id]; - let def_id = item_id.owner_id.def_id; + let def_id = self.resolver_output().impl_trait_res_map[&node_id]; let res = Res::Def(DefKind::OpaqueTy, def_id.to_def_id()); // FIXME(nilehmann) since we can only pass local ids for opaque types it means we can't // support extern specs with opaque types. - let opaque_ty = self - .with_new_owner(MaybeExternId::Local(item_id.owner_id)) - .desugar_opaque_ty_for_impl_trait(bounds)?; - self.insert_opaque_ty(def_id, opaque_ty); + let opaque_ty = self.desugar_opaque_ty_for_impl_trait(def_id, bounds)?; + let opaque_ty = self.insert_opaque_ty(opaque_ty); let (args, _) = self.desugar_generic_args(res, &[])?; let refine_args = self.implicit_params_to_args(self.fn_sig_scope.unwrap()); - Ok(fhir::TyKind::OpaqueDef(item_id, args, refine_args, false)) + Ok(fhir::TyKind::OpaqueDef(opaque_ty, args, refine_args)) } } diff --git a/crates/flux-desugar/src/lib.rs b/crates/flux-desugar/src/lib.rs index 46c9e10e8b..70ab82c124 100644 --- a/crates/flux-desugar/src/lib.rs +++ b/crates/flux-desugar/src/lib.rs @@ -16,7 +16,7 @@ use flux_common::{ span_bug, }; use flux_macros::fluent_messages; -use rustc_data_structures::unord::{ExtendUnord, UnordMap}; +use rustc_data_structures::unord::UnordMap; fluent_messages! { "../locales/en-US.ftl" } @@ -64,8 +64,8 @@ pub fn desugar<'genv>( let item = cx .as_rust_item_ctxt(owner_id, Some(&mut opaque_tys)) .desugar_item_fn(fn_spec)?; - nodes.extend_unord(opaque_tys.into_items().map(|(def_id, opaque_ty)| { - (def_id, fhir::Node::Item(genv.alloc(opaque_ty))) + nodes.extend(opaque_tys.into_iter().map(|opaque_ty| { + (opaque_ty.def_id.local_id(), fhir::Node::OpaqueTy(opaque_ty)) })); nodes.insert(def_id, fhir::Node::Item(genv.alloc(item))); } @@ -136,16 +136,9 @@ pub fn desugar<'genv>( ), ); } - hir::ItemKind::OpaqueTy(_) => { - // Opaque types are desugared as part of the desugaring of their defining function - span_bug!(item.span, "unexpected opaque type"); - } - _ => { - span_bug!(item.span, "unsupported item"); - } + _ => span_bug!(item.span, "unsupported item"), } } - rustc_hir::OwnerNode::TraitItem(trait_item) => { match trait_item.kind { rustc_hir::TraitItemKind::Fn(..) => { @@ -154,8 +147,8 @@ pub fn desugar<'genv>( let item = cx .as_rust_item_ctxt(owner_id, Some(&mut opaque_tys)) .desugar_trait_fn(fn_spec)?; - nodes.extend_unord(opaque_tys.into_items().map(|(def_id, opaque_ty)| { - (def_id, fhir::Node::Item(genv.alloc(opaque_ty))) + nodes.extend(opaque_tys.into_iter().map(|opaque_ty| { + (opaque_ty.def_id.local_id(), fhir::Node::OpaqueTy(opaque_ty)) })); nodes.insert(def_id, fhir::Node::TraitItem(genv.alloc(item))); } @@ -178,8 +171,8 @@ pub fn desugar<'genv>( let item = cx .as_rust_item_ctxt(owner_id, Some(&mut opaque_tys)) .desugar_impl_fn(fn_spec)?; - nodes.extend_unord(opaque_tys.into_items().map(|(def_id, opaque_ty)| { - (def_id, fhir::Node::Item(genv.alloc(opaque_ty))) + nodes.extend(opaque_tys.into_iter().map(|opaque_ty| { + (opaque_ty.def_id.local_id(), fhir::Node::OpaqueTy(opaque_ty)) })); nodes.insert(def_id, fhir::Node::ImplItem(genv.alloc(item))); } @@ -212,7 +205,7 @@ impl<'genv, 'tcx> DesugarCtxt<'genv, 'tcx> { fn as_rust_item_ctxt<'a>( &'a self, owner_id: OwnerId, - opaque_tys: Option<&'a mut UnordMap>>, + opaque_tys: Option<&'a mut Vec<&'genv fhir::OpaqueTy<'genv>>>, ) -> RustItemCtxt<'a, 'genv, 'tcx> { let owner_id = self .genv diff --git a/crates/flux-desugar/src/resolver.rs b/crates/flux-desugar/src/resolver.rs index 13a840326c..8d6f2ff323 100644 --- a/crates/flux-desugar/src/resolver.rs +++ b/crates/flux-desugar/src/resolver.rs @@ -21,7 +21,7 @@ use rustc_hir::{ Namespace::{self, *}, PerNS, }, - def_id::CRATE_DEF_ID, + def_id::{LocalDefId, CRATE_DEF_ID}, ParamName, PrimTy, CRATE_HIR_ID, CRATE_OWNER_ID, }; use rustc_middle::{metadata::ModChild, ty::TyCtxt}; @@ -573,7 +573,7 @@ impl Segment for Ident { struct ItemResolver<'a, 'genv, 'tcx> { resolver: &'a mut CrateResolver<'genv, 'tcx>, - opaque: Option, // TODO: HACK! need to generalize to multiple opaque types/impls in a signature. + opaque: Option, // TODO: HACK! need to generalize to multiple opaque types/impls in a signature. errors: Errors<'genv>, } @@ -673,7 +673,7 @@ fn map_res(res: hir::def::Res) -> hir::def::Res { } struct OpaqueTypeCollector<'sess> { - opaque: Option, // TODO: HACK! need to generalize to multiple opaque types/impls in a signature. + opaque: Option, // TODO: HACK! need to generalize to multiple opaque types/impls in a signature. errors: Errors<'sess>, } @@ -682,7 +682,7 @@ impl<'sess> OpaqueTypeCollector<'sess> { Self { opaque: None, errors: Errors::new(sess) } } - fn collect_item(sess: &'sess FluxSession, item: &hir::Item) -> Result> { + fn collect_item(sess: &'sess FluxSession, item: &hir::Item) -> Result> { let mut collector = Self::new(sess); hir::intravisit::walk_item(&mut collector, item); collector.into_result() @@ -691,7 +691,7 @@ impl<'sess> OpaqueTypeCollector<'sess> { fn collect_impl_item( sess: &'sess FluxSession, impl_item: &hir::ImplItem, - ) -> Result> { + ) -> Result> { let mut collector = Self::new(sess); hir::intravisit::walk_impl_item(&mut collector, impl_item); collector.into_result() @@ -700,13 +700,13 @@ impl<'sess> OpaqueTypeCollector<'sess> { fn collect_trait_item( sess: &'sess FluxSession, trait_item: &hir::TraitItem, - ) -> Result> { + ) -> Result> { let mut collector = Self::new(sess); hir::intravisit::walk_trait_item(&mut collector, trait_item); collector.into_result() } - fn into_result(self) -> Result> { + fn into_result(self) -> Result> { self.errors.into_result()?; Ok(self.opaque) } @@ -714,14 +714,14 @@ impl<'sess> OpaqueTypeCollector<'sess> { impl<'tcx> hir::intravisit::Visitor<'tcx> for OpaqueTypeCollector<'_> { fn visit_ty(&mut self, ty: &'tcx hir::Ty<'tcx>) { - if let hir::TyKind::OpaqueDef(item_id, ..) = ty.kind { + if let hir::TyKind::OpaqueDef(opaque_ty, ..) = ty.kind { if self.opaque.is_some() { self.errors.emit(errors::UnsupportedSignature::new( ty.span, "duplicate opaque types in signature", )); } else { - self.opaque = Some(item_id); + self.opaque = Some(opaque_ty.def_id); } } hir::intravisit::walk_ty(self, ty); diff --git a/crates/flux-driver/src/collector/mod.rs b/crates/flux-driver/src/collector/mod.rs index a62dab35e4..f83d6fdc81 100644 --- a/crates/flux-driver/src/collector/mod.rs +++ b/crates/flux-driver/src/collector/mod.rs @@ -17,7 +17,7 @@ use flux_middle::{ use flux_syntax::{surface, ParseResult, ParseSess}; use itertools::Itertools; use rustc_ast::{ - tokenstream::TokenStream, AttrArgs, AttrItem, AttrKind, MetaItemKind, NestedMetaItem, + tokenstream::TokenStream, AttrArgs, AttrItem, AttrKind, MetaItemInner, MetaItemKind, }; use rustc_errors::ErrorGuaranteed; use rustc_hir::{ @@ -533,7 +533,7 @@ fn parse_yes_no_with_reason(attr_item: &AttrItem) -> std::result::Result (bool, &[NestedMetaItem]) { +fn parse_opt_yes_no(items: &[MetaItemInner], default: bool) -> (bool, &[MetaItemInner]) { let [hd, tl @ ..] = items else { return (default, items) }; if hd.is_word() { if hd.has_name(sym::yes) { @@ -548,7 +548,7 @@ fn parse_opt_yes_no(items: &[NestedMetaItem], default: bool) -> (bool, &[NestedM } } -fn parse_opt_reason(items: &[NestedMetaItem]) -> (Option, &[NestedMetaItem]) { +fn parse_opt_reason(items: &[MetaItemInner]) -> (Option, &[MetaItemInner]) { let [hd, tl @ ..] = items else { return (None, items) }; if let Some(value) = hd.value_str() && hd.has_name(sym::reason) @@ -797,9 +797,9 @@ impl FluxAttrCFG { Ok(cfg) } - fn parse_cfg_item(&mut self, nested_item: &NestedMetaItem) -> CFGResult { + fn parse_cfg_item(&mut self, nested_item: &MetaItemInner) -> CFGResult { match nested_item { - NestedMetaItem::MetaItem(item) => { + MetaItemInner::MetaItem(item) => { let name = item.name_or_empty().to_ident_string(); let span = item.span; if !name.is_empty() { @@ -821,7 +821,7 @@ impl FluxAttrCFG { } Err(errors::CFGError { span, message: "bad setting name".to_string() }) } - NestedMetaItem::Lit(_) => { + MetaItemInner::Lit(_) => { Err(errors::CFGError { span: nested_item.span(), message: "unsupported item".to_string(), diff --git a/crates/flux-fhir-analysis/src/conv/mod.rs b/crates/flux-fhir-analysis/src/conv/mod.rs index f587a24612..6aeb766230 100644 --- a/crates/flux-fhir-analysis/src/conv/mod.rs +++ b/crates/flux-fhir-analysis/src/conv/mod.rs @@ -30,12 +30,7 @@ use itertools::Itertools; use rustc_data_structures::fx::FxIndexMap; use rustc_errors::Diagnostic; use rustc_hash::FxHashSet; -use rustc_hir::{ - self as hir, - def::DefKind, - def_id::{DefId, LocalDefId}, - OwnerId, PrimTy, Safety, -}; +use rustc_hir::{def::DefKind, def_id::DefId, OwnerId, PrimTy, Safety}; use rustc_middle::{ middle::resolve_bound_vars::ResolvedArg, ty::{self, AssocItem, AssocKind, BoundRegionKind::BrNamed, BoundVar, TyCtxt}, @@ -636,10 +631,10 @@ impl<'genv, 'tcx: 'genv, P: ConvPhase<'genv, 'tcx>> ConvCtxt

{ pub(crate) fn conv_opaque_ty( &mut self, - def_id: LocalDefId, opaque_ty: &fhir::OpaqueTy, ) -> QueryResult { - let parent = self.tcx().local_parent(def_id); + let def_id = opaque_ty.def_id; + let parent = self.tcx().local_parent(def_id.local_id()); let refparams = &self .genv() .map() @@ -649,8 +644,8 @@ impl<'genv, 'tcx: 'genv, P: ConvPhase<'genv, 'tcx>> ConvCtxt

{ let env = &mut Env::new(refparams); - let args = rty::GenericArg::identity_for_item(self.genv(), def_id)?; - let alias_ty = rty::AliasTy::new(def_id.into(), args, env.to_early_param_args()); + let args = rty::GenericArg::identity_for_item(self.genv(), def_id.resolved_id())?; + let alias_ty = rty::AliasTy::new(def_id.resolved_id(), args, env.to_early_param_args()); let self_ty = rty::BaseTy::opaque(alias_ty).to_ty(); // FIXME(nilehmann) use a good span here Ok(self @@ -891,14 +886,23 @@ impl<'genv, 'tcx: 'genv, P: ConvPhase<'genv, 'tcx>> ConvCtxt

{ let mut clauses = vec![]; for bound in bounds { match bound { - fhir::GenericBound::Trait(poly_trait_ref, fhir::TraitBoundModifier::None) => { - self.conv_poly_trait_ref( - env, - bounded_ty_span, - &bounded_ty, - poly_trait_ref, - &mut clauses, - )?; + fhir::GenericBound::Trait(poly_trait_ref) => { + match poly_trait_ref.modifiers { + fhir::TraitBoundModifier::None => { + self.conv_poly_trait_ref( + env, + bounded_ty_span, + &bounded_ty, + poly_trait_ref, + &mut clauses, + )?; + } + fhir::TraitBoundModifier::Maybe => { + // Maybe bounds are only supported for `?Sized`. The effect of the maybe + // bound is to relax the default which is `Sized` to not have the `Sized` + // bound, so we just skip it here. + } + } } fhir::GenericBound::Outlives(lft) => { let re = self.conv_lifetime(env, *lft); @@ -910,10 +914,6 @@ impl<'genv, 'tcx: 'genv, P: ConvPhase<'genv, 'tcx>> ConvCtxt

{ )), )); } - // Maybe bounds are only supported for `?Sized`. The effect of the maybe bound is to - // relax the default which is `Sized` to not have the `Sized` bound, so we just skip - // it here. - fhir::GenericBound::Trait(_, fhir::TraitBoundModifier::Maybe) => {} } } Ok(clauses) @@ -1090,8 +1090,8 @@ impl<'genv, 'tcx: 'genv, P: ConvPhase<'genv, 'tcx>> ConvCtxt

{ rty::Expr::unit(), )) } - fhir::TyKind::OpaqueDef(item_id, lifetimes, reft_args, _in_trait) => { - self.conv_opaque_def(env, *item_id, lifetimes, reft_args) + fhir::TyKind::OpaqueDef(opaque_ty, lifetimes, reft_args) => { + self.conv_opaque_def(env, opaque_ty, lifetimes, reft_args) } fhir::TyKind::TraitObject(trait_bounds, lft, syn) => { if matches!(syn, rustc_ast::TraitObjectSyntax::Dyn) { @@ -1108,11 +1108,17 @@ impl<'genv, 'tcx: 'genv, P: ConvPhase<'genv, 'tcx>> ConvCtxt

{ fn conv_opaque_def( &mut self, env: &mut Env, - item_id: hir::ItemId, + opaque_ty: &fhir::OpaqueTy, lifetimes: &[fhir::GenericArg], reft_args: &[fhir::Expr], ) -> QueryResult { - let def_id = item_id.owner_id.to_def_id(); + // During the first phase we need to run conv on the opaque type to collect sorts for base + // types in the bounds. + if !P::HAS_ELABORATED_INFORMATION { + self.conv_opaque_ty(opaque_ty)?; + } + + let def_id = opaque_ty.def_id.resolved_id(); let generics = self.genv().generics_of(def_id)?; let args = rty::GenericArg::for_item(self.genv(), def_id, |param, _| { if let Some(i) = (param.index as usize).checked_sub(generics.count() - lifetimes.len()) diff --git a/crates/flux-fhir-analysis/src/lib.rs b/crates/flux-fhir-analysis/src/lib.rs index 03c0b159bb..d916ab343c 100644 --- a/crates/flux-fhir-analysis/src/lib.rs +++ b/crates/flux-fhir-analysis/src/lib.rs @@ -28,7 +28,12 @@ use flux_middle::{ global_env::GlobalEnv, queries::{Providers, QueryErr, QueryResult}, query_bug, - rty::{self, fold::TypeFoldable, refining::Refiner, WfckResults}, + rty::{ + self, + fold::TypeFoldable, + refining::{self, Refiner}, + WfckResults, + }, MaybeExternId, }; use flux_rustc_bridge::lowering::Lower; @@ -155,16 +160,37 @@ fn predicates_of( def_id: LocalDefId, ) -> QueryResult> { let def_id = genv.maybe_extern_id(def_id); - if let Some(generics) = genv.map().get_generics(def_id.local_id())? { - let wfckresults = genv.check_wf(def_id.local_id())?; - AfterSortck::new(genv, &wfckresults) - .into_conv_ctxt() - .conv_generic_predicates(def_id, generics) - } else { - Ok(rty::EarlyBinder(rty::GenericPredicates { - parent: genv.tcx().predicates_of(def_id).parent, - predicates: rty::List::empty(), - })) + match genv.def_kind(def_id) { + DefKind::Impl { .. } + | DefKind::Struct + | DefKind::Enum + | DefKind::Union + | DefKind::TyAlias { .. } + | DefKind::AssocFn + | DefKind::AssocTy + | DefKind::Trait + | DefKind::Fn => { + let generics = genv + .map() + .get_generics(def_id.local_id())? + .ok_or_else(|| query_bug!(def_id.local_id(), "no generics for {def_id:?}"))?; + let wfckresults = genv.check_wf(def_id.local_id())?; + AfterSortck::new(genv, &wfckresults) + .into_conv_ctxt() + .conv_generic_predicates(def_id, generics) + } + DefKind::OpaqueTy | DefKind::Closure => { + Ok(rty::EarlyBinder(rty::GenericPredicates { + parent: genv.tcx().predicates_of(def_id).parent, + predicates: rty::List::empty(), + })) + } + kind => { + Err(query_bug!( + def_id.local_id(), + "predicates_of called on `{def_id:?}` with kind `{kind:?}`" + ))? + } } } @@ -304,16 +330,15 @@ fn sort_of_assoc_reft( } } -fn item_bounds( - genv: GlobalEnv, - local_id: LocalDefId, -) -> QueryResult> { - let wfckresults = genv.check_wf(local_id)?; - let opaque_ty = genv.map().expect_item(local_id)?.expect_opaque_ty(); +fn item_bounds(genv: GlobalEnv, def_id: LocalDefId) -> QueryResult> { + let def_id = genv.maybe_extern_id(def_id); + let parent = genv.tcx().local_parent(def_id.local_id()); + let wfckresults = genv.check_wf(parent)?; + let opaque_ty = genv.map().node(def_id.local_id())?.expect_opaque_ty(); Ok(rty::EarlyBinder( AfterSortck::new(genv, &wfckresults) .into_conv_ctxt() - .conv_opaque_ty(local_id, opaque_ty)?, + .conv_opaque_ty(opaque_ty)?, )) } @@ -327,7 +352,6 @@ fn generics_of(genv: GlobalEnv, def_id: LocalDefId) -> QueryResult QueryResult { - let rustc_generics = genv.tcx().generics_of(def_id.local_id()); - rty::Generics { - own_params: rty::List::empty(), - parent: rustc_generics.parent, - parent_count: rustc_generics.parent_count, - has_self: rustc_generics.has_self, - } + DefKind::OpaqueTy | DefKind::Closure => { + let rustc_generics = genv.lower_generics_of(def_id); + refining::refine_generics(genv, def_id.resolved_id(), &rustc_generics)? } kind => { Err(query_bug!( @@ -499,7 +518,11 @@ fn variants_of( fn fn_sig(genv: GlobalEnv, def_id: LocalDefId) -> QueryResult> { let def_id = genv.maybe_extern_id(def_id); - let fhir_fn_sig = genv.desugar(def_id.local_id())?.fn_sig().unwrap(); + let fhir_fn_sig = genv + .map() + .expect_owner_node(def_id.local_id())? + .fn_sig() + .unwrap(); let wfckresults = genv.check_wf(def_id.local_id())?; let fn_sig = AfterSortck::new(genv, &wfckresults) .into_conv_ctxt() @@ -522,7 +545,7 @@ fn fn_sig(genv: GlobalEnv, def_id: LocalDefId) -> QueryResult QueryResult> { - let node = genv.desugar(def_id)?; + let node = genv.map().expect_owner_node(def_id)?; let wfckresults = wf::check_node(genv, &node)?; Ok(Rc::new(wfckresults)) } diff --git a/crates/flux-fhir-analysis/src/wf/mod.rs b/crates/flux-fhir-analysis/src/wf/mod.rs index edce88cdaa..eadd3c3f3b 100644 --- a/crates/flux-fhir-analysis/src/wf/mod.rs +++ b/crates/flux-fhir-analysis/src/wf/mod.rs @@ -84,7 +84,7 @@ pub(crate) fn check_invariants( pub(crate) fn check_node<'genv>( genv: GlobalEnv<'genv, '_>, - node: &fhir::Node<'genv>, + node: &fhir::OwnerNode<'genv>, ) -> Result { let mut infcx = InferCtxt::new(genv, node.owner_id().local_id().into()); let mut wf = Wf::new(&mut infcx); @@ -103,7 +103,7 @@ pub(crate) fn check_node<'genv>( } /// Check that all param sorts are fully resolved and save them in [`WfckResults`] -fn resolve_params(infcx: &mut InferCtxt, node: &fhir::Node) -> Result { +fn resolve_params(infcx: &mut InferCtxt, node: &fhir::OwnerNode) -> Result { visit_refine_params(node, |param| infcx.resolve_param_sort(param)) } @@ -143,7 +143,7 @@ impl<'a, 'genv, 'tcx> Wf<'a, 'genv, 'tcx> { } } - fn check_node(&mut self, node: &fhir::Node<'genv>) { + fn check_node(&mut self, node: &fhir::OwnerNode<'genv>) { self.visit_node(node); } @@ -160,21 +160,8 @@ impl<'a, 'genv, 'tcx> Wf<'a, 'genv, 'tcx> { } /// Initializes the inference context with all refinement parameters in `node` - fn insert_params_for_node(&mut self, node: &fhir::Node) -> Result { + fn insert_params_for_node(&mut self, node: &fhir::OwnerNode) -> Result { let genv = self.infcx.genv; - if let fhir::Node::Item(fhir::Item { - kind: fhir::ItemKind::OpaqueTy(..), owner_id, .. - }) = node - { - let parent = genv.tcx().local_parent(owner_id.local_id().def_id); - if let Some(generics) = genv.map().get_generics(parent).emit(&genv)? { - let wfckresults = genv.check_wf(parent).emit(&genv)?; - for param in generics.refinement_params { - let sort = wfckresults.node_sorts().get(param.fhir_id).unwrap().clone(); - self.infcx.insert_param(param.id, sort, param.kind); - } - } - } visit_refine_params(node, |param| { let sort = self.as_conv_ctxt().conv_sort(¶m.sort).emit(&genv)?; self.infcx.insert_param(param.id, sort, param.kind); @@ -197,12 +184,12 @@ impl<'a, 'genv, 'tcx> Wf<'a, 'genv, 'tcx> { /// collecting the sort of all base types. /// /// [inference context]: InferCtxt - fn init_infcx(&mut self, node: &fhir::Node<'genv>) -> QueryResult { + fn init_infcx(&mut self, node: &fhir::OwnerNode<'genv>) -> QueryResult { let def_id = node.owner_id().map(|id| id.def_id); self.insert_params_for_node(node)?; let cx = self.as_conv_ctxt(); match node { - fhir::Node::Item(item) => { + fhir::OwnerNode::Item(item) => { match &item.kind { fhir::ItemKind::Enum(enum_def) => { cx.conv_enum_variants(def_id, enum_def)?; @@ -237,12 +224,9 @@ impl<'a, 'genv, 'tcx> Wf<'a, 'genv, 'tcx> { cx.conv_fn_sig(def_id, fn_sig)?; cx.conv_generic_predicates(def_id, &item.generics)?; } - fhir::ItemKind::OpaqueTy(opaque_ty) => { - cx.conv_opaque_ty(def_id.expect_local(), opaque_ty)?; - } } } - fhir::Node::TraitItem(trait_item) => { + fhir::OwnerNode::TraitItem(trait_item) => { match trait_item.kind { fhir::TraitItemKind::Fn(fn_sig) => { cx.conv_fn_sig(def_id, &fn_sig)?; @@ -251,7 +235,7 @@ impl<'a, 'genv, 'tcx> Wf<'a, 'genv, 'tcx> { fhir::TraitItemKind::Type => {} } } - fhir::Node::ImplItem(impl_item) => { + fhir::OwnerNode::ImplItem(impl_item) => { match impl_item.kind { fhir::ImplItemKind::Fn(fn_sig) => { cx.conv_fn_sig(def_id, &fn_sig)?; @@ -406,7 +390,10 @@ impl<'genv> fhir::visit::Visitor<'genv> for Wf<'_, 'genv, '_> { } } -fn visit_refine_params(node: &fhir::Node, f: impl FnMut(&fhir::RefineParam) -> Result) -> Result { +fn visit_refine_params( + node: &fhir::OwnerNode, + f: impl FnMut(&fhir::RefineParam) -> Result, +) -> Result { struct RefineParamVisitor { f: F, err: Option, diff --git a/crates/flux-fhir-analysis/src/wf/param_usage.rs b/crates/flux-fhir-analysis/src/wf/param_usage.rs index 0ff5d23567..3fbe335e06 100644 --- a/crates/flux-fhir-analysis/src/wf/param_usage.rs +++ b/crates/flux-fhir-analysis/src/wf/param_usage.rs @@ -25,7 +25,7 @@ use super::{ type Result = std::result::Result; -pub(crate) fn check<'genv>(infcx: &InferCtxt<'genv, '_>, node: &fhir::Node<'genv>) -> Result { +pub(crate) fn check<'genv>(infcx: &InferCtxt<'genv, '_>, node: &fhir::OwnerNode<'genv>) -> Result { ParamUsesChecker::new(infcx).run(|ck| ck.visit_node(node)) } @@ -138,7 +138,7 @@ impl<'a, 'genv, 'tcx> ParamUsesChecker<'a, 'genv, 'tcx> { } impl<'genv> fhir::visit::Visitor<'genv> for ParamUsesChecker<'_, 'genv, '_> { - fn visit_node(&mut self, node: &fhir::Node<'genv>) { + fn visit_node(&mut self, node: &fhir::OwnerNode<'genv>) { if node.fn_sig().is_some() { // Check early refinement parameters in fn-like nodes let snapshot = self.xi.snapshot(); diff --git a/crates/flux-fhir-analysis/src/wf/sortck.rs b/crates/flux-fhir-analysis/src/wf/sortck.rs index c2dbf5ba30..636e3db8a1 100644 --- a/crates/flux-fhir-analysis/src/wf/sortck.rs +++ b/crates/flux-fhir-analysis/src/wf/sortck.rs @@ -710,7 +710,10 @@ pub(crate) struct ImplicitParamInferer<'a, 'genv, 'tcx> { } impl<'a, 'genv, 'tcx> ImplicitParamInferer<'a, 'genv, 'tcx> { - pub(crate) fn infer(infcx: &'a mut InferCtxt<'genv, 'tcx>, node: &fhir::Node<'genv>) -> Result { + pub(crate) fn infer( + infcx: &'a mut InferCtxt<'genv, 'tcx>, + node: &fhir::OwnerNode<'genv>, + ) -> Result { let errors = Errors::new(infcx.genv.sess()); let mut vis = Self { infcx, errors }; vis.visit_node(node); diff --git a/crates/flux-middle/src/fhir.rs b/crates/flux-middle/src/fhir.rs index 6d2dd2a017..bfbf2e3c7f 100644 --- a/crates/flux-middle/src/fhir.rs +++ b/crates/flux-middle/src/fhir.rs @@ -30,7 +30,7 @@ pub use rustc_hir::PrimTy; use rustc_hir::{ def::DefKind, def_id::{DefId, LocalDefId}, - FnHeader, ItemId, OwnerId, ParamName, Safety, + FnHeader, OwnerId, ParamName, Safety, }; use rustc_index::newtype_index; use rustc_macros::{Decodable, Encodable, TyDecodable, TyEncodable}; @@ -154,31 +154,58 @@ pub enum Node<'fhir> { Item(&'fhir Item<'fhir>), TraitItem(&'fhir TraitItem<'fhir>), ImplItem(&'fhir ImplItem<'fhir>), + OpaqueTy(&'fhir OpaqueTy<'fhir>), } impl<'fhir> Node<'fhir> { + pub fn as_owner(self) -> Option> { + match self { + Node::Item(item) => Some(OwnerNode::Item(item)), + Node::TraitItem(trait_item) => Some(OwnerNode::TraitItem(trait_item)), + Node::ImplItem(impl_item) => Some(OwnerNode::ImplItem(impl_item)), + Node::OpaqueTy(_) => None, + } + } + + pub fn expect_opaque_ty(&self) -> &'fhir OpaqueTy<'fhir> { + if let Node::OpaqueTy(opaque_ty) = &self { + opaque_ty + } else { + bug!("expected opaque type") + } + } +} + +#[derive(Clone, Copy, Debug)] +pub enum OwnerNode<'fhir> { + Item(&'fhir Item<'fhir>), + TraitItem(&'fhir TraitItem<'fhir>), + ImplItem(&'fhir ImplItem<'fhir>), +} + +impl<'fhir> OwnerNode<'fhir> { pub fn fn_sig(&self) -> Option<&'fhir FnSig<'fhir>> { match self { - Node::Item(Item { kind: ItemKind::Fn(fn_sig, ..), .. }) - | Node::TraitItem(TraitItem { kind: TraitItemKind::Fn(fn_sig), .. }) - | Node::ImplItem(ImplItem { kind: ImplItemKind::Fn(fn_sig), .. }) => Some(fn_sig), + OwnerNode::Item(Item { kind: ItemKind::Fn(fn_sig, ..), .. }) + | OwnerNode::TraitItem(TraitItem { kind: TraitItemKind::Fn(fn_sig), .. }) + | OwnerNode::ImplItem(ImplItem { kind: ImplItemKind::Fn(fn_sig), .. }) => Some(fn_sig), _ => None, } } pub fn generics(self) -> &'fhir Generics<'fhir> { match self { - Node::Item(item) => &item.generics, - Node::TraitItem(trait_item) => &trait_item.generics, - Node::ImplItem(impl_item) => &impl_item.generics, + OwnerNode::Item(item) => &item.generics, + OwnerNode::TraitItem(trait_item) => &trait_item.generics, + OwnerNode::ImplItem(impl_item) => &impl_item.generics, } } pub fn owner_id(&self) -> MaybeExternId { match self { - Node::Item(item) => item.owner_id, - Node::TraitItem(trait_item) => trait_item.owner_id, - Node::ImplItem(impl_item) => impl_item.owner_id, + OwnerNode::Item(item) => item.owner_id, + OwnerNode::TraitItem(trait_item) => trait_item.owner_id, + OwnerNode::ImplItem(impl_item) => impl_item.owner_id, } } } @@ -215,14 +242,6 @@ impl<'fhir> Item<'fhir> { } } - pub fn expect_opaque_ty(&self) -> &OpaqueTy<'fhir> { - if let ItemKind::OpaqueTy(opaque_ty) = &self.kind { - opaque_ty - } else { - bug!("expected opaque type") - } - } - pub fn expect_impl(&self) -> &Impl<'fhir> { if let ItemKind::Impl(impl_) = &self.kind { impl_ @@ -248,7 +267,6 @@ pub enum ItemKind<'fhir> { Trait(Trait<'fhir>), Impl(Impl<'fhir>), Fn(FnSig<'fhir>), - OpaqueTy(OpaqueTy<'fhir>), } #[derive(Debug)] @@ -311,13 +329,14 @@ pub type GenericBounds<'fhir> = &'fhir [GenericBound<'fhir>]; #[derive(Debug, Clone, Copy)] pub enum GenericBound<'fhir> { - Trait(PolyTraitRef<'fhir>, TraitBoundModifier), + Trait(PolyTraitRef<'fhir>), Outlives(Lifetime), } #[derive(Debug, Clone, Copy)] pub struct PolyTraitRef<'fhir> { pub bound_generic_params: &'fhir [GenericParam<'fhir>], + pub modifiers: TraitBoundModifier, pub trait_ref: Path<'fhir>, pub span: Span, } @@ -374,6 +393,7 @@ pub struct ImplAssocReft<'fhir> { #[derive(Debug)] pub struct OpaqueTy<'fhir> { + pub def_id: MaybeExternId, pub bounds: GenericBounds<'fhir>, } @@ -526,7 +546,7 @@ pub enum TyKind<'fhir> { Tuple(&'fhir [Ty<'fhir>]), Array(&'fhir Ty<'fhir>, ConstArg), RawPtr(&'fhir Ty<'fhir>, Mutability), - OpaqueDef(ItemId, &'fhir [GenericArg<'fhir>], &'fhir [Expr<'fhir>], bool), + OpaqueDef(&'fhir OpaqueTy<'fhir>, &'fhir [GenericArg<'fhir>], &'fhir [Expr<'fhir>]), TraitObject(&'fhir [PolyTraitRef<'fhir>], Lifetime, TraitObjectSyntax), Never, Infer, @@ -1313,10 +1333,11 @@ impl fmt::Debug for Ty<'_> { TyKind::RawPtr(ty, Mutability::Not) => write!(f, "*const {ty:?}"), TyKind::RawPtr(ty, Mutability::Mut) => write!(f, "*mut {ty:?}"), TyKind::Infer => write!(f, "_"), - TyKind::OpaqueDef(def_id, args, refine_args, _) => { + TyKind::OpaqueDef(opaque_ty, args, refine_args) => { write!( f, - "impl trait " + "impl trait ", + opaque_ty.def_id.resolved_id(), ) } TyKind::TraitObject(poly_traits, _lft, _syntax) => { diff --git a/crates/flux-middle/src/fhir/lift.rs b/crates/flux-middle/src/fhir/lift.rs index 18517db39d..97b4501754 100644 --- a/crates/flux-middle/src/fhir/lift.rs +++ b/crates/flux-middle/src/fhir/lift.rs @@ -2,10 +2,8 @@ use flux_common::{bug, index::IndexGen, iter::IterExt}; use flux_errors::ErrorGuaranteed; -use hir::OwnerId; -use rustc_data_structures::unord::UnordMap; use rustc_errors::Diagnostic; -use rustc_hir::{self as hir, def_id::LocalDefId, FnHeader}; +use rustc_hir::{self as hir, def_id::LocalDefId, FnHeader, OwnerId}; use rustc_span::Span; use super::{FhirId, FluxOwnerId}; @@ -19,7 +17,7 @@ type Result = std::result::Result; pub struct LiftCtxt<'a, 'genv, 'tcx> { genv: GlobalEnv<'genv, 'tcx>, - opaque_tys: Option<&'a mut UnordMap>>, + opaque_tys: Option<&'a mut Vec<&'genv fhir::OpaqueTy<'genv>>>, local_id_gen: &'a IndexGen, owner: MaybeExternId, } @@ -29,19 +27,11 @@ impl<'a, 'genv, 'tcx> LiftCtxt<'a, 'genv, 'tcx> { genv: GlobalEnv<'genv, 'tcx>, owner: MaybeExternId, local_id_gen: &'a IndexGen, - opaque_tys: Option<&'a mut UnordMap>>, + opaque_tys: Option<&'a mut Vec<&'genv fhir::OpaqueTy<'genv>>>, ) -> Self { Self { genv, opaque_tys, local_id_gen, owner } } - fn with_new_owner<'b>( - &'b mut self, - owner: MaybeExternId, - local_id_gen: &'b IndexGen, - ) -> LiftCtxt<'b, 'genv, 'tcx> { - LiftCtxt::new(self.genv, owner, local_id_gen, self.opaque_tys.as_deref_mut()) - } - pub fn lift_generics(&mut self) -> Result> { let generics = self.genv.hir().get_generics(self.local_id()).unwrap(); self.lift_generics_inner(generics) @@ -116,17 +106,8 @@ impl<'a, 'genv, 'tcx> LiftCtxt<'a, 'genv, 'tcx> { bound: &hir::GenericBound, ) -> Result> { match bound { - hir::GenericBound::Trait(poly_trait_ref, hir::TraitBoundModifier::None) => { - Ok(fhir::GenericBound::Trait( - self.lift_poly_trait_ref(*poly_trait_ref)?, - fhir::TraitBoundModifier::None, - )) - } - hir::GenericBound::Trait(poly_trait_ref, hir::TraitBoundModifier::Maybe) => { - Ok(fhir::GenericBound::Trait( - self.lift_poly_trait_ref(*poly_trait_ref)?, - fhir::TraitBoundModifier::Maybe, - )) + hir::GenericBound::Trait(poly_trait_ref) => { + Ok(fhir::GenericBound::Trait(self.lift_poly_trait_ref(*poly_trait_ref)?)) } hir::GenericBound::Outlives(lft) => { let lft = self.lift_lifetime(lft)?; @@ -140,26 +121,36 @@ impl<'a, 'genv, 'tcx> LiftCtxt<'a, 'genv, 'tcx> { &mut self, poly_trait_ref: hir::PolyTraitRef, ) -> Result> { + let modifiers = match poly_trait_ref.modifiers { + rustc_hir::TraitBoundModifier::None => fhir::TraitBoundModifier::None, + rustc_hir::TraitBoundModifier::Maybe => fhir::TraitBoundModifier::Maybe, + rustc_hir::TraitBoundModifier::Const + | rustc_hir::TraitBoundModifier::Negative + | rustc_hir::TraitBoundModifier::MaybeConst => { + return self.emit_unsupported(&format!( + "unsupported trait modifier: `{:?}`", + poly_trait_ref.modifiers, + )); + } + }; let bound_generic_params = try_alloc_slice!(self.genv, &poly_trait_ref.bound_generic_params, |param| { self.lift_generic_param(param) })?; let trait_ref = self.lift_path(poly_trait_ref.trait_ref.path)?; - Ok(fhir::PolyTraitRef { bound_generic_params, trait_ref, span: poly_trait_ref.span }) + Ok(fhir::PolyTraitRef { + bound_generic_params, + modifiers, + trait_ref, + span: poly_trait_ref.span, + }) } - fn lift_opaque_ty(&mut self) -> Result> { - let hir::ItemKind::OpaqueTy(opaque_ty) = self.genv.hir().expect_item(self.local_id()).kind - else { - bug!("expected opaque type") - }; - - let generics = self.lift_generics()?; + fn lift_opaque_ty(&mut self, opaque_ty: &hir::OpaqueTy) -> Result> { let bounds = try_alloc_slice!(self.genv, &opaque_ty.bounds, |bound| self.lift_generic_bound(bound))?; - let opaque_ty = fhir::OpaqueTy { bounds }; - Ok(fhir::Item { generics, kind: fhir::ItemKind::OpaqueTy(opaque_ty), owner_id: self.owner }) + Ok(fhir::OpaqueTy { def_id: MaybeExternId::Local(opaque_ty.def_id), bounds }) } pub fn lift_fn_header(&mut self) -> FnHeader { @@ -306,26 +297,22 @@ impl<'a, 'genv, 'tcx> LiftCtxt<'a, 'genv, 'tcx> { let ty = self.lift_ty(mut_ty.ty)?; fhir::TyKind::RawPtr(self.genv.alloc(ty), mut_ty.mutbl) } - hir::TyKind::OpaqueDef(item_id, args, in_trait_def) => { - let opaque_ty = self - .with_new_owner(MaybeExternId::Local(item_id.owner_id), &IndexGen::new()) - .lift_opaque_ty()?; - self.insert_opaque_ty(item_id.owner_id.def_id, opaque_ty); - + hir::TyKind::OpaqueDef(opaque_ty, args) => { + let opaque_ty = self.lift_opaque_ty(opaque_ty)?; + let opaque_ty = self.insert_opaque_ty(opaque_ty); let args = self.lift_generic_args(args)?; - fhir::TyKind::OpaqueDef(item_id, args, &[], in_trait_def) + fhir::TyKind::OpaqueDef(opaque_ty, args, &[]) } hir::TyKind::TraitObject(poly_traits, lft, syntax) => { - let poly_traits = - try_alloc_slice!(self.genv, poly_traits, |(poly_trait, modifier)| { - if *modifier != hir::TraitBoundModifier::None { - return self.emit_unsupported(&format!( - "unsupported type: `{}`", - rustc_hir_pretty::ty_to_string(&self.genv.tcx(), ty) - )); - } - self.lift_poly_trait_ref(*poly_trait) - })?; + let poly_traits = try_alloc_slice!(self.genv, poly_traits, |poly_trait| { + if poly_trait.modifiers != hir::TraitBoundModifier::None { + return self.emit_unsupported(&format!( + "unsupported type: `{}`", + rustc_hir_pretty::ty_to_string(&self.genv.tcx(), ty) + )); + } + self.lift_poly_trait_ref(*poly_trait) + })?; let lft = self.lift_lifetime(lft)?; fhir::TyKind::TraitObject(poly_traits, lft, syntax) @@ -483,11 +470,16 @@ impl<'a, 'genv, 'tcx> LiftCtxt<'a, 'genv, 'tcx> { fhir::ConstArg { kind: fhir::ConstArgKind::Infer, span: const_arg.span() } } - fn insert_opaque_ty(&mut self, def_id: LocalDefId, opaque_ty: fhir::Item<'genv>) { + fn insert_opaque_ty( + &mut self, + opaque_ty: fhir::OpaqueTy<'genv>, + ) -> &'genv fhir::OpaqueTy<'genv> { + let opaque_ty = self.genv.alloc(opaque_ty); self.opaque_tys .as_mut() - .unwrap_or_else(|| bug!("`impl Trait` not supported in this item {def_id:?}")) - .insert(def_id, opaque_ty); + .unwrap_or_else(|| bug!("`impl Trait` not supported in this item `{:?}`", self.owner)) + .push(opaque_ty); + opaque_ty } #[track_caller] diff --git a/crates/flux-middle/src/fhir/visit.rs b/crates/flux-middle/src/fhir/visit.rs index c2fdf870f5..bae7d33e3a 100644 --- a/crates/flux-middle/src/fhir/visit.rs +++ b/crates/flux-middle/src/fhir/visit.rs @@ -2,7 +2,7 @@ use super::{ AliasReft, AssocItemConstraint, AssocItemConstraintKind, BaseTy, BaseTyKind, Ensures, EnumDef, Expr, ExprKind, FieldDef, FieldExpr, FnDecl, FnOutput, FnSig, FuncSort, GenericArg, GenericBound, Generics, Impl, ImplAssocReft, ImplItem, ImplItemKind, Item, ItemKind, Lifetime, - Lit, Node, OpaqueTy, Path, PathExpr, PathSegment, PolyFuncSort, PolyTraitRef, QPath, + Lit, OpaqueTy, OwnerNode, Path, PathExpr, PathSegment, PolyFuncSort, PolyTraitRef, QPath, RefineParam, Requires, Sort, SortPath, StructDef, TraitAssocReft, TraitItem, TraitItemKind, Ty, TyAlias, TyKind, VariantDef, VariantRet, WhereBoundPredicate, }; @@ -21,7 +21,7 @@ macro_rules! walk_list { } pub trait Visitor<'v>: Sized { - fn visit_node(&mut self, node: &Node<'v>) { + fn visit_node(&mut self, node: &OwnerNode<'v>) { walk_node(self, node); } @@ -227,7 +227,7 @@ pub fn walk_opaque_ty<'v, V: Visitor<'v>>(vis: &mut V, opaque_ty: &OpaqueTy<'v>) pub fn walk_generic_bound<'v, V: Visitor<'v>>(vis: &mut V, bound: &GenericBound<'v>) { match bound { - GenericBound::Trait(trait_ref, _) => vis.visit_poly_trait_ref(trait_ref), + GenericBound::Trait(trait_ref) => vis.visit_poly_trait_ref(trait_ref), GenericBound::Outlives(_) => {} } } @@ -236,11 +236,11 @@ pub fn walk_poly_trait_ref<'v, V: Visitor<'v>>(vis: &mut V, trait_ref: &PolyTrai vis.visit_path(&trait_ref.trait_ref); } -pub fn walk_node<'v, V: Visitor<'v>>(vis: &mut V, node: &Node<'v>) { +pub fn walk_node<'v, V: Visitor<'v>>(vis: &mut V, node: &OwnerNode<'v>) { match node { - Node::Item(item) => vis.visit_item(item), - Node::TraitItem(trait_item) => vis.visit_trait_item(trait_item), - Node::ImplItem(impl_item) => vis.visit_impl_item(impl_item), + OwnerNode::Item(item) => vis.visit_item(item), + OwnerNode::TraitItem(trait_item) => vis.visit_trait_item(trait_item), + OwnerNode::ImplItem(impl_item) => vis.visit_impl_item(impl_item), } } @@ -255,7 +255,6 @@ pub fn walk_item<'v, V: Visitor<'v>>(vis: &mut V, item: &Item<'v>) { } ItemKind::Impl(impl_) => vis.visit_impl(impl_), ItemKind::Fn(fn_sig) => vis.visit_fn_sig(fn_sig), - ItemKind::OpaqueTy(opaque_ty) => vis.visit_opaque_ty(opaque_ty), } } @@ -378,7 +377,8 @@ pub fn walk_ty<'v, V: Visitor<'v>>(vis: &mut V, ty: &Ty<'v>) { TyKind::RawPtr(ty, _mtblt) => { vis.visit_ty(ty); } - TyKind::OpaqueDef(_item_id, generics, refine, _bool) => { + TyKind::OpaqueDef(opaque_ty, generics, refine) => { + vis.visit_opaque_ty(opaque_ty); walk_list!(vis, visit_generic_arg, generics); walk_list!(vis, visit_expr, refine); } diff --git a/crates/flux-middle/src/global_env.rs b/crates/flux-middle/src/global_env.rs index 5983453993..371644ca7d 100644 --- a/crates/flux-middle/src/global_env.rs +++ b/crates/flux-middle/src/global_env.rs @@ -167,19 +167,28 @@ impl<'genv, 'tcx> GlobalEnv<'genv, 'tcx> { self.inner.queries.mir(self, def_id) } - pub fn lower_generics_of(self, def_id: DefId) -> ty::Generics<'tcx> { - self.inner.queries.lower_generics_of(self, def_id) + pub fn lower_generics_of(self, def_id: impl IntoQueryParam) -> ty::Generics<'tcx> { + self.inner + .queries + .lower_generics_of(self, def_id.into_query_param()) } pub fn lower_predicates_of( self, - def_id: impl Into, + def_id: impl IntoQueryParam, ) -> QueryResult { - self.inner.queries.lower_predicates_of(self, def_id.into()) + self.inner + .queries + .lower_predicates_of(self, def_id.into_query_param()) } - pub fn lower_type_of(self, def_id: impl Into) -> QueryResult> { - self.inner.queries.lower_type_of(self, def_id.into()) + pub fn lower_type_of( + self, + def_id: impl IntoQueryParam, + ) -> QueryResult> { + self.inner + .queries + .lower_type_of(self, def_id.into_query_param()) } pub fn lower_fn_sig( @@ -503,7 +512,7 @@ impl<'genv, 'tcx> Map<'genv, 'tcx> { if matches!(self.genv.def_kind(def_id), DefKind::Closure) { Ok(None) } else { - Ok(Some(self.node(def_id)?.generics())) + Ok(Some(self.expect_owner_node(def_id)?.generics())) } } @@ -552,7 +561,7 @@ impl<'genv, 'tcx> Map<'genv, 'tcx> { pub fn fn_quals_for(self, def_id: LocalDefId) -> QueryResult<&'genv [Ident]> { // This is called on adts when checking invariants - if let Some(fn_sig) = self.node(def_id)?.fn_sig() { + if let Some(fn_sig) = self.expect_owner_node(def_id)?.fn_sig() { Ok(fn_sig.qualifiers) } else { Ok(&[]) @@ -570,6 +579,10 @@ impl<'genv, 'tcx> Map<'genv, 'tcx> { pub fn node(self, def_id: LocalDefId) -> QueryResult> { self.genv.desugar(def_id) } + + pub fn expect_owner_node(self, def_id: LocalDefId) -> QueryResult> { + Ok(self.node(def_id)?.as_owner().unwrap()) + } } #[macro_export] diff --git a/crates/flux-middle/src/lib.rs b/crates/flux-middle/src/lib.rs index 14c425a888..0d6d20422f 100644 --- a/crates/flux-middle/src/lib.rs +++ b/crates/flux-middle/src/lib.rs @@ -59,7 +59,6 @@ use rustc_data_structures::{ fx::FxIndexMap, unord::{UnordMap, UnordSet}, }; -use rustc_hir as hir; use rustc_hir::OwnerId; use rustc_macros::extension; use rustc_span::{ @@ -436,7 +435,7 @@ pub enum ExternSpecMappingErr { #[derive(Default)] pub struct ResolverOutput { pub path_res_map: UnordMap, - pub impl_trait_res_map: UnordMap, + pub impl_trait_res_map: UnordMap, /// Resolution of explicitly and implicitly scoped parameters. The [`fhir::ParamId`] is unique /// per item. The [`NodeId`] used as the key corresponds to the node introducing the parameter. /// When explicit, this is the id of the [`surface::GenericArg`] or [`surface::RefineParam`], diff --git a/crates/flux-middle/src/rty/projections.rs b/crates/flux-middle/src/rty/projections.rs index b01117f172..b482ec8c4e 100644 --- a/crates/flux-middle/src/rty/projections.rs +++ b/crates/flux-middle/src/rty/projections.rs @@ -114,7 +114,7 @@ impl<'genv, 'tcx, 'cx> Normalizer<'genv, 'tcx, 'cx> { projection_ty, cause, 10, - &mut vec![], + &mut rustc_infer::traits::PredicateObligations::new(), ) .expect_type(); let rustc_ty = ty.lower(self.tcx()).unwrap(); diff --git a/crates/flux-middle/src/rty/refining.rs b/crates/flux-middle/src/rty/refining.rs index e0806ff6a4..72f3061663 100644 --- a/crates/flux-middle/src/rty/refining.rs +++ b/crates/flux-middle/src/rty/refining.rs @@ -18,7 +18,7 @@ use crate::{ query_bug, rty, }; -pub(crate) fn refine_generics( +pub fn refine_generics( genv: GlobalEnv, def_id: DefId, generics: &ty::Generics, diff --git a/crates/flux-refineck/src/checker.rs b/crates/flux-refineck/src/checker.rs index fd7fe91a70..eef6b22535 100644 --- a/crates/flux-refineck/src/checker.rs +++ b/crates/flux-refineck/src/checker.rs @@ -1340,18 +1340,18 @@ impl<'ck, 'genv, 'tcx, M: Mode> Checker<'ck, 'genv, 'tcx, M> { } } } - CastKind::Pointer(mir::PointerCast::Unsize) => { + CastKind::PointerCoercion(mir::PointerCast::Unsize) => { self.check_unsize_cast(infcx, env, stmt_span, from, to)? } CastKind::FloatToInt | CastKind::IntToFloat | CastKind::PtrToPtr - | CastKind::Pointer(mir::PointerCast::MutToConstPointer) - | CastKind::Pointer(mir::PointerCast::ClosureFnPointer) + | CastKind::PointerCoercion(mir::PointerCast::MutToConstPointer) + | CastKind::PointerCoercion(mir::PointerCast::ClosureFnPointer) | CastKind::PointerWithExposedProvenance => { self.refine_default(to).with_span(self.body.span())? } - CastKind::Pointer(mir::PointerCast::ReifyFnPointer) => { + CastKind::PointerCoercion(mir::PointerCast::ReifyFnPointer) => { let to = self.refine_default(to).with_span(self.body.span())?; if let TyKind::Indexed(rty::BaseTy::FnDef(def_id, args), _) = from.kind() && let TyKind::Indexed(BaseTy::FnPtr(super_sig), _) = to.kind() diff --git a/crates/flux-refineck/src/ghost_statements/points_to.rs b/crates/flux-refineck/src/ghost_statements/points_to.rs index fae8e83ad2..245e8548f3 100644 --- a/crates/flux-refineck/src/ghost_statements/points_to.rs +++ b/crates/flux-refineck/src/ghost_statements/points_to.rs @@ -187,14 +187,12 @@ impl<'a> PointsToAnalysis<'a> { } } -impl<'a, 'tcx> rustc_mir_dataflow::AnalysisDomain<'tcx> for PointsToAnalysis<'a> { +impl<'tcx> rustc_mir_dataflow::Analysis<'tcx> for PointsToAnalysis<'_> { type Domain = State; - type Direction = rustc_mir_dataflow::Forward; - const NAME: &'static str = "PointsToAnalysis"; - fn bottom_value(&self, _body: &mir::Body<'tcx>) -> Self::Domain { + fn bottom_value(&self, _: &mir::Body<'tcx>) -> Self::Domain { State { values: IndexVec::from_elem_n(FlatSet::BOTTOM, self.map.value_count) } } @@ -218,9 +216,7 @@ impl<'a, 'tcx> rustc_mir_dataflow::AnalysisDomain<'tcx> for PointsToAnalysis<'a> } } } -} -impl<'tcx> rustc_mir_dataflow::Analysis<'tcx> for PointsToAnalysis<'_> { fn apply_statement_effect( &mut self, state: &mut Self::Domain, diff --git a/crates/flux-rustc-bridge/src/lowering.rs b/crates/flux-rustc-bridge/src/lowering.rs index 214fd2e232..fccea1dd36 100644 --- a/crates/flux-rustc-bridge/src/lowering.rs +++ b/crates/flux-rustc-bridge/src/lowering.rs @@ -15,7 +15,7 @@ use rustc_middle::{ TyCtxt, ValTree, }, }; -use rustc_span::{Span, Symbol}; +use rustc_span::{Span, Symbol, DUMMY_SP}; use rustc_trait_selection::traits::SelectionContext; use super::{ @@ -492,6 +492,7 @@ impl<'sess, 'tcx> MirLoweringCtxt<'_, 'sess, 'tcx> { Some(crate::mir::PointerCast::ReifyFnPointer) } rustc_adjustment::PointerCoercion::UnsafeFnPointer + | rustc_adjustment::PointerCoercion::DynStar | rustc_adjustment::PointerCoercion::ArrayToPointer => None, } } @@ -501,8 +502,8 @@ impl<'sess, 'tcx> MirLoweringCtxt<'_, 'sess, 'tcx> { rustc_mir::CastKind::IntToFloat => Some(CastKind::IntToFloat), rustc_mir::CastKind::FloatToInt => Some(CastKind::FloatToInt), rustc_mir::CastKind::PtrToPtr => Some(CastKind::PtrToPtr), - rustc_mir::CastKind::PointerCoercion(ptr_coercion) => { - Some(CastKind::Pointer(self.lower_pointer_coercion(ptr_coercion)?)) + rustc_mir::CastKind::PointerCoercion(ptr_coercion, _) => { + Some(CastKind::PointerCoercion(self.lower_pointer_coercion(ptr_coercion)?)) } rustc_mir::CastKind::PointerExposeProvenance => Some(CastKind::PointerExposeProvenance), rustc_mir::CastKind::PointerWithExposedProvenance => { @@ -612,9 +613,13 @@ impl<'sess, 'tcx> MirLoweringCtxt<'_, 'sess, 'tcx> { // HACK(nilehmann) we evaluate the constant to support u32::MAX // we should instead lower it as is and refine its type. - let val = constant.const_.normalize(tcx, ParamEnv::empty()); + let const_ = constant + .const_ + .eval(tcx, ParamEnv::empty(), DUMMY_SP) + .map(|val| Const::Val(val, constant.const_.ty())) + .unwrap_or(constant.const_); let ty = constant.ty(); - match (val, ty.kind()) { + match (const_, ty.kind()) { (Const::Val(ConstValue::Scalar(Scalar::Int(scalar)), ty), _) => { self.scalar_int_to_constant(scalar, ty) } diff --git a/crates/flux-rustc-bridge/src/mir.rs b/crates/flux-rustc-bridge/src/mir.rs index 0c77aac217..90c714b823 100644 --- a/crates/flux-rustc-bridge/src/mir.rs +++ b/crates/flux-rustc-bridge/src/mir.rs @@ -14,7 +14,7 @@ use rustc_index::IndexSlice; use rustc_infer::infer::TyCtxtInferExt; use rustc_macros::{TyDecodable, TyEncodable}; use rustc_middle::{ - mir::{self}, + mir, ty::{FloatTy, IntTy, ParamConst, TyCtxt, UintTy}, }; pub use rustc_middle::{ @@ -220,7 +220,7 @@ pub enum CastKind { FloatToInt, IntToFloat, PtrToPtr, - Pointer(PointerCast), + PointerCoercion(PointerCast), PointerExposeProvenance, PointerWithExposedProvenance, } @@ -724,7 +724,7 @@ impl fmt::Debug for CastKind { CastKind::FloatToInt => write!(f, "FloatToInt"), CastKind::IntToFloat => write!(f, "IntToFloat"), CastKind::PtrToPtr => write!(f, "PtrToPtr"), - CastKind::Pointer(c) => write!(f, "Pointer({c:?})"), + CastKind::PointerCoercion(c) => write!(f, "Pointer({c:?})"), CastKind::PointerExposeProvenance => write!(f, "PointerExposeProvenance"), CastKind::PointerWithExposedProvenance => write!(f, "PointerWithExposedProvenance"), } diff --git a/rust-toolchain b/rust-toolchain index fea4784296..e4a974e4e7 100644 --- a/rust-toolchain +++ b/rust-toolchain @@ -1,3 +1,3 @@ [toolchain] -channel = "nightly-2024-09-20" +channel = "nightly-2024-10-20" components = ["rust-src", "rustc-dev", "llvm-tools", "rustfmt"] From 568fcec4772da8799f3456ced638575096dcb92a Mon Sep 17 00:00:00 2001 From: Nico Lehmann Date: Wed, 27 Nov 2024 21:19:46 -0800 Subject: [PATCH 3/3] Update to 2024-11-03 --- Cargo.lock | 19 +++- Cargo.toml | 1 + crates/flux-arc-interner/Cargo.toml | 2 + crates/flux-arc-interner/src/lib.rs | 1 - crates/flux-common/Cargo.toml | 2 + crates/flux-common/src/lib.rs | 2 +- crates/flux-desugar/Cargo.toml | 2 + crates/flux-desugar/src/desugar.rs | 34 +------ crates/flux-desugar/src/lib.rs | 4 +- .../src/resolver/refinement_resolver.rs | 2 +- crates/flux-fhir-analysis/Cargo.toml | 1 + .../src/compare_impl_item.rs | 6 +- crates/flux-fhir-analysis/src/conv/mod.rs | 98 +++++++------------ crates/flux-fhir-analysis/src/lib.rs | 2 +- crates/flux-fhir-analysis/src/wf/sortck.rs | 2 +- crates/flux-infer/src/infer.rs | 3 +- crates/flux-infer/src/refine_tree.rs | 2 +- crates/flux-metadata/Cargo.toml | 1 + crates/flux-metadata/src/decoder.rs | 4 +- crates/flux-metadata/src/encoder.rs | 8 +- crates/flux-metadata/src/lib.rs | 2 +- crates/flux-middle/Cargo.toml | 1 + crates/flux-middle/src/fhir.rs | 26 +++-- crates/flux-middle/src/fhir/lift.rs | 27 ++--- crates/flux-middle/src/fhir/visit.rs | 4 +- crates/flux-middle/src/lib.rs | 2 +- crates/flux-middle/src/pretty.rs | 2 +- crates/flux-middle/src/queries.rs | 3 +- crates/flux-middle/src/rty/mod.rs | 26 ++--- crates/flux-middle/src/rty/projections.rs | 2 +- crates/flux-middle/src/rty/subst.rs | 2 +- crates/flux-middle/src/sort_of.rs | 2 +- crates/flux-refineck/Cargo.toml | 1 + crates/flux-refineck/src/checker.rs | 23 +++-- .../src/ghost_statements/fold_unfold.rs | 4 +- .../src/ghost_statements/points_to.rs | 7 +- crates/flux-refineck/src/lib.rs | 2 +- crates/flux-refineck/src/queue.rs | 20 ++-- crates/flux-refineck/src/type_env.rs | 2 +- crates/flux-rustc-bridge/src/lowering.rs | 13 +-- crates/flux-rustc-bridge/src/mir.rs | 40 ++++++-- crates/flux-rustc-bridge/src/ty/mod.rs | 28 +++--- lib/liquid-fixpoint/src/lib.rs | 3 +- rust-toolchain | 2 +- 44 files changed, 222 insertions(+), 218 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 7e157fc804..5313f33fe8 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1,6 +1,6 @@ # This file is automatically @generated by Cargo. # It is not intended for manual editing. -version = 3 +version = 4 [[package]] name = "adler2" @@ -405,7 +405,7 @@ dependencies = [ "fluent-syntax", "intl-memoizer", "intl_pluralrules", - "rustc-hash", + "rustc-hash 1.1.0", "self_cell 0.10.3", "smallvec", "unic-langid", @@ -435,6 +435,7 @@ version = "0.1.0" dependencies = [ "dashmap", "hashbrown 0.14.5", + "rustc-hash 2.0.0", ] [[package]] @@ -462,6 +463,7 @@ name = "flux-common" version = "0.1.0" dependencies = [ "flux-config", + "rustc-hash 2.0.0", ] [[package]] @@ -484,6 +486,7 @@ dependencies = [ "flux-middle", "flux-syntax", "itertools 0.13.0", + "rustc-hash 2.0.0", ] [[package]] @@ -527,6 +530,7 @@ dependencies = [ "flux-middle", "flux-rustc-bridge", "itertools 0.13.0", + "rustc-hash 2.0.0", ] [[package]] @@ -570,6 +574,7 @@ dependencies = [ "flux-macros", "flux-middle", "itertools 0.13.0", + "rustc-hash 2.0.0", ] [[package]] @@ -589,6 +594,7 @@ dependencies = [ "hashbrown 0.14.5", "itertools 0.13.0", "liquid-fixpoint", + "rustc-hash 2.0.0", "toposort-scc", ] @@ -605,6 +611,7 @@ dependencies = [ "flux-rustc-bridge", "itertools 0.13.0", "liquid-fixpoint", + "rustc-hash 2.0.0", "serde", "serde_json", "tracing", @@ -1166,6 +1173,12 @@ version = "1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2" +[[package]] +name = "rustc-hash" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "583034fd73374156e66797ed8e5b0d5690409c9226b22d87cb7f19821c05d152" + [[package]] name = "rustfix" version = "0.8.5" @@ -1565,7 +1578,7 @@ version = "0.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "deb68604048ff8fa93347f02441e4487594adc20bb8a084f9e564d2b827a0a9f" dependencies = [ - "rustc-hash", + "rustc-hash 1.1.0", ] [[package]] diff --git a/Cargo.toml b/Cargo.toml index 8b4bbda8a5..eb85b097bc 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -36,6 +36,7 @@ hashbrown = "0.14.3" home = "0.5.9" itertools = "0.13.0" pad-adapter = "0.1.1" +rustc-hash = "2.0.0" serde = { version = "1.0", features = ["derive"] } serde_json = "1.0" toml = "0.8" diff --git a/crates/flux-arc-interner/Cargo.toml b/crates/flux-arc-interner/Cargo.toml index 0d115680bf..7caf15a74e 100644 --- a/crates/flux-arc-interner/Cargo.toml +++ b/crates/flux-arc-interner/Cargo.toml @@ -7,6 +7,8 @@ version = "0.1.0" dashmap.workspace = true hashbrown.workspace = true +rustc-hash.workspace = true + [lints] workspace = true diff --git a/crates/flux-arc-interner/src/lib.rs b/crates/flux-arc-interner/src/lib.rs index 651c835477..1d5954946f 100644 --- a/crates/flux-arc-interner/src/lib.rs +++ b/crates/flux-arc-interner/src/lib.rs @@ -4,7 +4,6 @@ #![feature(rustc_private)] -extern crate rustc_hash; extern crate rustc_serialize; extern crate rustc_target; diff --git a/crates/flux-common/Cargo.toml b/crates/flux-common/Cargo.toml index c8c2482099..dc065eeb73 100644 --- a/crates/flux-common/Cargo.toml +++ b/crates/flux-common/Cargo.toml @@ -9,6 +9,8 @@ edition.workspace = true [dependencies] flux-config.workspace = true +rustc-hash.workspace = true + [package.metadata.rust-analyzer] rustc_private = true diff --git a/crates/flux-common/src/lib.rs b/crates/flux-common/src/lib.rs index 9c2647f7d8..d8064eae01 100644 --- a/crates/flux-common/src/lib.rs +++ b/crates/flux-common/src/lib.rs @@ -2,7 +2,7 @@ extern crate rustc_borrowck; extern crate rustc_errors; -extern crate rustc_hash; + extern crate rustc_hir; extern crate rustc_index; extern crate rustc_middle; diff --git a/crates/flux-desugar/Cargo.toml b/crates/flux-desugar/Cargo.toml index 8d07b27dbb..891528ac98 100644 --- a/crates/flux-desugar/Cargo.toml +++ b/crates/flux-desugar/Cargo.toml @@ -17,7 +17,9 @@ flux-errors.workspace = true flux-macros.workspace = true flux-middle.workspace = true flux-syntax.workspace = true + itertools.workspace = true +rustc-hash.workspace = true [package.metadata.rust-analyzer] rustc_private = true diff --git a/crates/flux-desugar/src/desugar.rs b/crates/flux-desugar/src/desugar.rs index 4a8fd1949b..4c3a7326d7 100644 --- a/crates/flux-desugar/src/desugar.rs +++ b/crates/flux-desugar/src/desugar.rs @@ -634,16 +634,12 @@ impl<'a, 'genv, 'tcx: 'genv> RustItemCtxt<'a, 'genv, 'tcx> { match asyncness { surface::Async::Yes { node_id, span } => { let def_id = self.resolver_output.impl_trait_res_map[&node_id]; - let res = Res::Def(DefKind::OpaqueTy, def_id.to_def_id()); - // FIXME(nilehmann) since we can only pass local ids for opaque types it means we // can't support extern specs with opaque types. let opaque_ty = self.desugar_opaque_ty_for_async(def_id, returns)?; let opaque_ty = self.insert_opaque_ty(opaque_ty); - let (args, _) = self.desugar_generic_args(res, &[])?; - let refine_args = self.implicit_params_to_args(self.fn_sig_scope.unwrap()); - let kind = fhir::TyKind::OpaqueDef(opaque_ty, args, refine_args); + let kind = fhir::TyKind::OpaqueDef(opaque_ty); Ok(fhir::Ty { kind, span }) } surface::Async::No => Ok(self.desugar_fn_ret_ty(returns)?), @@ -896,27 +892,6 @@ trait DesugarCtxt<'genv, 'tcx: 'genv> { }) } - fn implicit_params_to_args(&self, scope: NodeId) -> &'genv [fhir::Expr<'genv>] { - self.genv() - .alloc_slice_fill_iter( - self.resolve_implicit_params(scope) - .map(|(ident, id, kind)| { - let span = ident.span; - let path = fhir::PathExpr { - segments: self.genv().alloc_slice(&[ident]), - res: ExprRes::Param(kind, id), - fhir_id: self.next_fhir_id(), - span: ident.span, - }; - fhir::Expr { - kind: fhir::ExprKind::Var(path, Some(kind)), - fhir_id: self.next_fhir_id(), - span, - } - }), - ) - } - fn desugar_refine_params( &self, params: &[surface::RefineParam], @@ -1511,7 +1486,7 @@ fn desugar_base_sort<'genv>( } } -impl<'a, 'genv, 'tcx> DesugarCtxt<'genv, 'tcx> for RustItemCtxt<'a, 'genv, 'tcx> { +impl<'genv, 'tcx> DesugarCtxt<'genv, 'tcx> for RustItemCtxt<'_, 'genv, 'tcx> { fn next_fhir_id(&self) -> FhirId { FhirId { owner: FluxOwnerId::Rust(self.owner.local_id()), @@ -1533,16 +1508,13 @@ impl<'a, 'genv, 'tcx> DesugarCtxt<'genv, 'tcx> for RustItemCtxt<'a, 'genv, 'tcx> bounds: &[surface::TraitRef], ) -> Result> { let def_id = self.resolver_output().impl_trait_res_map[&node_id]; - let res = Res::Def(DefKind::OpaqueTy, def_id.to_def_id()); // FIXME(nilehmann) since we can only pass local ids for opaque types it means we can't // support extern specs with opaque types. let opaque_ty = self.desugar_opaque_ty_for_impl_trait(def_id, bounds)?; let opaque_ty = self.insert_opaque_ty(opaque_ty); - let (args, _) = self.desugar_generic_args(res, &[])?; - let refine_args = self.implicit_params_to_args(self.fn_sig_scope.unwrap()); - Ok(fhir::TyKind::OpaqueDef(opaque_ty, args, refine_args)) + Ok(fhir::TyKind::OpaqueDef(opaque_ty)) } } diff --git a/crates/flux-desugar/src/lib.rs b/crates/flux-desugar/src/lib.rs index 70ab82c124..e755ebb356 100644 --- a/crates/flux-desugar/src/lib.rs +++ b/crates/flux-desugar/src/lib.rs @@ -4,7 +4,7 @@ extern crate rustc_data_structures; extern crate rustc_errors; -extern crate rustc_hash; + extern crate rustc_hir; extern crate rustc_middle; extern crate rustc_span; @@ -256,7 +256,7 @@ impl<'genv, 'tcx> CrateDesugar<'genv, 'tcx> { } } -impl<'genv, 'tcx> CrateDesugar<'genv, 'tcx> { +impl CrateDesugar<'_, '_> { fn desugar_flux_items(&mut self, specs: &Specs) { for item in specs.flux_items_by_parent.values().flatten() { match item { diff --git a/crates/flux-desugar/src/resolver/refinement_resolver.rs b/crates/flux-desugar/src/resolver/refinement_resolver.rs index f487b350aa..122d4deb7e 100644 --- a/crates/flux-desugar/src/resolver/refinement_resolver.rs +++ b/crates/flux-desugar/src/resolver/refinement_resolver.rs @@ -706,7 +706,7 @@ impl<'a, 'genv, 'tcx> RefinementResolver<'a, 'genv, 'tcx> { } } -impl<'genv> ScopedVisitor for RefinementResolver<'_, 'genv, '_> { +impl ScopedVisitor for RefinementResolver<'_, '_, '_> { fn is_box(&self, segment: &surface::PathSegment) -> bool { self.resolver_output() .path_res_map diff --git a/crates/flux-fhir-analysis/Cargo.toml b/crates/flux-fhir-analysis/Cargo.toml index 62e1e4e1d8..daf025b8cb 100644 --- a/crates/flux-fhir-analysis/Cargo.toml +++ b/crates/flux-fhir-analysis/Cargo.toml @@ -14,6 +14,7 @@ flux-middle.workspace = true flux-rustc-bridge.workspace = true itertools.workspace = true +rustc-hash.workspace = true [package.metadata.rust-analyzer] rustc_private = true diff --git a/crates/flux-fhir-analysis/src/compare_impl_item.rs b/crates/flux-fhir-analysis/src/compare_impl_item.rs index 82bef60198..7fec0372d6 100644 --- a/crates/flux-fhir-analysis/src/compare_impl_item.rs +++ b/crates/flux-fhir-analysis/src/compare_impl_item.rs @@ -4,6 +4,7 @@ use flux_middle::{ }; use rustc_hash::FxHashSet; use rustc_infer::infer::TyCtxtInferExt; +use rustc_middle::ty::TypingMode; use rustc_span::{def_id::DefId, ErrorGuaranteed, Symbol}; type Result = std::result::Result; @@ -58,7 +59,10 @@ fn check_assoc_reft( trait_id: DefId, name: Symbol, ) -> Result { - let infcx = genv.tcx().infer_ctxt().build(); + let infcx = genv + .tcx() + .infer_ctxt() + .build(TypingMode::non_body_analysis()); let impl_span = genv .map() diff --git a/crates/flux-fhir-analysis/src/conv/mod.rs b/crates/flux-fhir-analysis/src/conv/mod.rs index 6aeb766230..e5b105684f 100644 --- a/crates/flux-fhir-analysis/src/conv/mod.rs +++ b/crates/flux-fhir-analysis/src/conv/mod.rs @@ -21,7 +21,7 @@ use flux_middle::{ self, fold::TypeFoldable, refining::{self, Refiner}, - ESpan, List, WfckResults, INNERMOST, + ESpan, List, RefineArgsExt, WfckResults, INNERMOST, }, MaybeExternId, }; @@ -292,7 +292,7 @@ pub(crate) fn conv_generics( rty::GenericParamDef { index: 0, name: kw::SelfUpper, def_id: def_id.resolved_id(), kind } }); let rust_generics = genv.tcx().generics_of(def_id.resolved_id()); - let mut params = { + let params = { opt_self .into_iter() .chain(rust_generics.own_params.iter().flat_map(|rust_param| { @@ -311,25 +311,6 @@ pub(crate) fn conv_generics( .collect_vec() }; - // HACK(nilehmann) add host param for effect to std/core external specs - if let Some(extern_id) = def_id.as_extern() { - if let Some((pos, param)) = genv - .lower_generics_of(extern_id) - .params - .iter() - .find_position(|p| p.is_host_effect()) - { - params.insert( - pos, - rty::GenericParamDef { - kind: refining::refine_generic_param_def_kind(false, param.kind), - def_id: param.def_id, - index: param.index, - name: param.name, - }, - ); - } - } let rust_generics = genv.tcx().generics_of(def_id.resolved_id()); rty::Generics { own_params: List::from_vec(params), @@ -359,7 +340,7 @@ fn conv_generic_param_kind(kind: &fhir::GenericParamKind) -> rty::GenericParamDe rty::GenericParamDefKind::Base { has_default: default.is_some() } } fhir::GenericParamKind::Lifetime => rty::GenericParamDefKind::Lifetime, - fhir::GenericParamKind::Const { is_host_effect: _, .. } => { + fhir::GenericParamKind::Const { .. } => { rty::GenericParamDefKind::Const { has_default: false } } } @@ -1090,9 +1071,7 @@ impl<'genv, 'tcx: 'genv, P: ConvPhase<'genv, 'tcx>> ConvCtxt

{ rty::Expr::unit(), )) } - fhir::TyKind::OpaqueDef(opaque_ty, lifetimes, reft_args) => { - self.conv_opaque_def(env, opaque_ty, lifetimes, reft_args) - } + fhir::TyKind::OpaqueDef(opaque_ty) => self.conv_opaque_def(env, opaque_ty), fhir::TyKind::TraitObject(trait_bounds, lft, syn) => { if matches!(syn, rustc_ast::TraitObjectSyntax::Dyn) { self.conv_trait_object(env, trait_bounds, *lft) @@ -1109,45 +1088,38 @@ impl<'genv, 'tcx: 'genv, P: ConvPhase<'genv, 'tcx>> ConvCtxt

{ &mut self, env: &mut Env, opaque_ty: &fhir::OpaqueTy, - lifetimes: &[fhir::GenericArg], - reft_args: &[fhir::Expr], ) -> QueryResult { - // During the first phase we need to run conv on the opaque type to collect sorts for base - // types in the bounds. - if !P::HAS_ELABORATED_INFORMATION { + let def_id = opaque_ty.def_id; + + if P::HAS_ELABORATED_INFORMATION { + let lifetimes = self.tcx().opaque_captured_lifetimes(def_id.local_id()); + + let generics = self.tcx().generics_of(opaque_ty.def_id); + + let offset = generics.parent_count; + + let args = rty::GenericArg::for_item(self.genv(), def_id.resolved_id(), |param, _| { + if let Some(i) = (param.index as usize).checked_sub(offset) { + let (lifetime, _) = lifetimes[i]; + rty::GenericArg::Lifetime(self.conv_resolved_lifetime(env, lifetime)) + } else { + rty::GenericArg::from_param_def(param) + } + })?; + let reft_args = rty::RefineArgs::identity_for_item(self.genv(), def_id.resolved_id())?; + let alias_ty = rty::AliasTy::new(def_id.resolved_id(), args, reft_args); + Ok(rty::BaseTy::opaque(alias_ty).to_ty()) + } else { + // During sortck we need to run conv on the opaque type to collect sorts for base types + // in the opaque type's bounds. After sortck, we don't need to because opaque types are + // converted as part of `genv.item_bounds`. self.conv_opaque_ty(opaque_ty)?; - } - let def_id = opaque_ty.def_id.resolved_id(); - let generics = self.genv().generics_of(def_id)?; - let args = rty::GenericArg::for_item(self.genv(), def_id, |param, _| { - if let Some(i) = (param.index as usize).checked_sub(generics.count() - lifetimes.len()) - { - // Resolve our own lifetime parameters. - let rty::GenericParamDefKind::Lifetime { .. } = param.kind else { - span_bug!( - self.tcx().def_span(param.def_id), - "only expected lifetime for opaque's own generics, got {:?}", - param.kind - ); - }; - let fhir::GenericArg::Lifetime(lft) = &lifetimes[i] else { - bug!( - "expected lifetime argument for param {param:?}, found {:?}", - &lifetimes[i] - ) - }; - rty::GenericArg::Lifetime(self.conv_lifetime(env, *lft)) - } else { - rty::GenericArg::from_param_def(param) - } - })?; - let reft_args = reft_args - .iter() - .map(|arg| self.conv_expr(env, arg)) - .try_collect()?; - let alias_ty = rty::AliasTy::new(def_id, args, reft_args); - Ok(rty::BaseTy::opaque(alias_ty).to_ty()) + // `RefineArgs::identity_for_item` uses `genv.refinement_generics_of` which in turn + // requires `genv.check_wf`, so we simply return all empty here to avoid the circularity + let alias_ty = rty::AliasTy::new(def_id.resolved_id(), List::empty(), List::empty()); + Ok(rty::BaseTy::opaque(alias_ty).to_ty()) + } } fn conv_trait_object( @@ -1418,6 +1390,10 @@ impl<'genv, 'tcx: 'genv, P: ConvPhase<'genv, 'tcx>> ConvCtxt

{ fhir::Lifetime::Hole(_) => return rty::Region::ReVar(self.next_region_vid()), fhir::Lifetime::Resolved(res) => res, }; + self.conv_resolved_lifetime(env, res) + } + + fn conv_resolved_lifetime(&mut self, env: &Env, res: ResolvedArg) -> rty::Region { let tcx = self.tcx(); let lifetime_name = |def_id| tcx.item_name(def_id); match res { diff --git a/crates/flux-fhir-analysis/src/lib.rs b/crates/flux-fhir-analysis/src/lib.rs index d916ab343c..c05b3b6edc 100644 --- a/crates/flux-fhir-analysis/src/lib.rs +++ b/crates/flux-fhir-analysis/src/lib.rs @@ -3,7 +3,7 @@ extern crate rustc_ast; extern crate rustc_data_structures; extern crate rustc_errors; -extern crate rustc_hash; + extern crate rustc_hir; extern crate rustc_infer; extern crate rustc_middle; diff --git a/crates/flux-fhir-analysis/src/wf/sortck.rs b/crates/flux-fhir-analysis/src/wf/sortck.rs index 636e3db8a1..66027e03d3 100644 --- a/crates/flux-fhir-analysis/src/wf/sortck.rs +++ b/crates/flux-fhir-analysis/src/wf/sortck.rs @@ -470,7 +470,7 @@ impl<'genv, 'tcx> InferCtxt<'genv, 'tcx> { } } -impl<'genv> InferCtxt<'genv, '_> { +impl InferCtxt<'_, '_> { pub(super) fn insert_param( &mut self, id: fhir::ParamId, diff --git a/crates/flux-infer/src/infer.rs b/crates/flux-infer/src/infer.rs index 77a3cb95f8..378fa14138 100644 --- a/crates/flux-infer/src/infer.rs +++ b/crates/flux-infer/src/infer.rs @@ -300,7 +300,7 @@ pub struct InferCtxtAt<'a, 'infcx, 'genv, 'tcx> { pub span: Span, } -impl<'a, 'infcx, 'genv, 'tcx> InferCtxtAt<'a, 'infcx, 'genv, 'tcx> { +impl InferCtxtAt<'_, '_, '_, '_> { fn tag(&self, reason: ConstrReason) -> Tag { Tag::new(reason, self.span) } @@ -485,7 +485,6 @@ struct Sub { /// remove the location from the environment, the type is always going to be overwritten. /// (there's a check for this btw, if you write an &strg we require an ensures for that /// location for the signature to be well-formed) - impl Sub { fn new(reason: ConstrReason, span: Span) -> Self { Self { reason, span, obligations: vec![] } diff --git a/crates/flux-infer/src/refine_tree.rs b/crates/flux-infer/src/refine_tree.rs index 114d17c2fc..a845e4e65a 100644 --- a/crates/flux-infer/src/refine_tree.rs +++ b/crates/flux-infer/src/refine_tree.rs @@ -804,7 +804,7 @@ impl RefineCtxtTrace { bindings.push(bind); } NodeKind::Assumption(e) if !e.simplify().is_trivially_true() => { - exprs.push(format!("{e:?}")) + exprs.push(format!("{e:?}")); } _ => (), } diff --git a/crates/flux-metadata/Cargo.toml b/crates/flux-metadata/Cargo.toml index 4700d5e1fd..77df5e7e01 100644 --- a/crates/flux-metadata/Cargo.toml +++ b/crates/flux-metadata/Cargo.toml @@ -14,6 +14,7 @@ flux-middle.workspace = true derive-where.workspace = true itertools.workspace = true +rustc-hash.workspace = true [package.metadata.rust-analyzer] rustc_private = true diff --git a/crates/flux-metadata/src/decoder.rs b/crates/flux-metadata/src/decoder.rs index 0ae1868fcf..714891e58d 100644 --- a/crates/flux-metadata/src/decoder.rs +++ b/crates/flux-metadata/src/decoder.rs @@ -53,7 +53,7 @@ pub(super) fn decode_crate_metadata( implement_ty_decoder!(DecodeContext<'a, 'tcx>); -impl<'a, 'tcx> SpanDecoder for DecodeContext<'a, 'tcx> { +impl SpanDecoder for DecodeContext<'_, '_> { fn decode_attr_id(&mut self) -> rustc_ast::AttrId { self.tcx.sess.psess.attr_id_generator.mk_attr_id() } @@ -121,7 +121,7 @@ impl<'a, 'tcx> SpanDecoder for DecodeContext<'a, 'tcx> { } } -impl<'a, 'tcx> TyDecoder for DecodeContext<'a, 'tcx> { +impl<'tcx> TyDecoder for DecodeContext<'_, 'tcx> { type I = TyCtxt<'tcx>; const CLEAR_CROSS_CRATE: bool = true; diff --git a/crates/flux-metadata/src/encoder.rs b/crates/flux-metadata/src/encoder.rs index 81cd212e50..cd4efd0aec 100644 --- a/crates/flux-metadata/src/encoder.rs +++ b/crates/flux-metadata/src/encoder.rs @@ -1,7 +1,7 @@ use std::collections::hash_map::Entry; use flux_middle::global_env::GlobalEnv; -use rustc_hash::FxHashMap; +use rustc_data_structures::fx::FxHashMap; use rustc_hir::def_id::{DefId, LOCAL_CRATE}; use rustc_metadata::errors::FailCreateFileEncoder; use rustc_middle::{ @@ -57,7 +57,7 @@ pub fn encode_metadata(genv: GlobalEnv, path: &std::path::Path) { ecx.opaque.finish().unwrap(); } -impl<'a, 'tcx> SpanEncoder for EncodeContext<'a, 'tcx> { +impl SpanEncoder for EncodeContext<'_, '_> { fn encode_crate_num(&mut self, crate_num: CrateNum) { if crate_num != LOCAL_CRATE && self.is_proc_macro { bug!("Attempted to encode non-local CrateNum {crate_num:?} for proc-macro crate"); @@ -129,7 +129,7 @@ impl<'a, 'tcx> SpanEncoder for EncodeContext<'a, 'tcx> { } } -impl<'a, 'tcx> TyEncoder for EncodeContext<'a, 'tcx> { +impl<'tcx> TyEncoder for EncodeContext<'_, 'tcx> { const CLEAR_CROSS_CRATE: bool = true; type I = TyCtxt<'tcx>; @@ -167,7 +167,7 @@ macro_rules! encoder_methods { } } -impl<'a, 'tcx> Encoder for EncodeContext<'a, 'tcx> { +impl Encoder for EncodeContext<'_, '_> { encoder_methods! { emit_usize(usize); emit_u128(u128); diff --git a/crates/flux-metadata/src/lib.rs b/crates/flux-metadata/src/lib.rs index bc1a7b918a..1a1c3f2dad 100644 --- a/crates/flux-metadata/src/lib.rs +++ b/crates/flux-metadata/src/lib.rs @@ -4,7 +4,7 @@ extern crate rustc_ast; extern crate rustc_data_structures; extern crate rustc_errors; -extern crate rustc_hash; + extern crate rustc_hir; extern crate rustc_macros; extern crate rustc_metadata; diff --git a/crates/flux-middle/Cargo.toml b/crates/flux-middle/Cargo.toml index 71fda40a35..d0d658c255 100644 --- a/crates/flux-middle/Cargo.toml +++ b/crates/flux-middle/Cargo.toml @@ -23,6 +23,7 @@ ena.workspace = true hashbrown.workspace = true itertools.workspace = true toposort-scc.workspace = true +rustc-hash.workspace = true [package.metadata.rust-analyzer] diff --git a/crates/flux-middle/src/fhir.rs b/crates/flux-middle/src/fhir.rs index bfbf2e3c7f..ce5d64ea5e 100644 --- a/crates/flux-middle/src/fhir.rs +++ b/crates/flux-middle/src/fhir.rs @@ -138,7 +138,7 @@ pub struct GenericParam<'fhir> { pub enum GenericParamKind<'fhir> { Type { default: Option> }, Lifetime, - Const { ty: Ty<'fhir>, is_host_effect: bool }, + Const { ty: Ty<'fhir> }, } #[derive(Debug)] @@ -301,7 +301,7 @@ pub enum FluxItem<'fhir> { Func(SpecFunc<'fhir>), } -impl<'fhir> FluxItem<'fhir> { +impl FluxItem<'_> { pub fn name(&self) -> Symbol { match self { FluxItem::Qualifier(qual) => qual.name, @@ -408,7 +408,7 @@ pub struct FluxItems<'fhir> { pub items: FxHashMap>, } -impl<'fhir> FluxItems<'fhir> { +impl FluxItems<'_> { pub fn new() -> Self { Self { items: Default::default() } } @@ -546,7 +546,7 @@ pub enum TyKind<'fhir> { Tuple(&'fhir [Ty<'fhir>]), Array(&'fhir Ty<'fhir>, ConstArg), RawPtr(&'fhir Ty<'fhir>, Mutability), - OpaqueDef(&'fhir OpaqueTy<'fhir>, &'fhir [GenericArg<'fhir>], &'fhir [Expr<'fhir>]), + OpaqueDef(&'fhir OpaqueTy<'fhir>), TraitObject(&'fhir [PolyTraitRef<'fhir>], Lifetime, TraitObjectSyntax), Never, Infer, @@ -987,7 +987,7 @@ pub enum ExprKind<'fhir> { Constructor(Option>, &'fhir [FieldExpr<'fhir>], Option<&'fhir Spread<'fhir>>), } -impl<'fhir> Expr<'fhir> { +impl Expr<'_> { pub fn is_colon_param(&self) -> Option { if let ExprKind::Var(path, Some(ParamKind::Colon)) = &self.kind && let ExprRes::Param(kind, id) = path.res @@ -1056,7 +1056,7 @@ newtype_index! { pub struct ParamId {} } -impl<'fhir> PolyTraitRef<'fhir> { +impl PolyTraitRef<'_> { pub fn trait_def_id(&self) -> DefId { let path = &self.trait_ref; if let Res::Def(DefKind::Trait, did) = path.res { @@ -1133,7 +1133,7 @@ impl TryFrom> for Res { } } -impl<'fhir> QPath<'fhir> { +impl QPath<'_> { pub fn span(&self) -> Span { match self { QPath::Resolved(_, path) => path.span, @@ -1212,7 +1212,7 @@ impl<'fhir> From> for Sort<'fhir> { } } -impl<'fhir> FuncSort<'fhir> { +impl FuncSort<'_> { pub fn inputs(&self) -> &[Sort] { &self.inputs_and_output[..self.inputs_and_output.len() - 1] } @@ -1234,7 +1234,7 @@ impl rustc_errors::IntoDiagArg for Path<'_> { } } -impl<'fhir> StructDef<'fhir> { +impl StructDef<'_> { pub fn is_opaque(&self) -> bool { matches!(self.kind, StructKind::Opaque) } @@ -1333,12 +1333,8 @@ impl fmt::Debug for Ty<'_> { TyKind::RawPtr(ty, Mutability::Not) => write!(f, "*const {ty:?}"), TyKind::RawPtr(ty, Mutability::Mut) => write!(f, "*mut {ty:?}"), TyKind::Infer => write!(f, "_"), - TyKind::OpaqueDef(opaque_ty, args, refine_args) => { - write!( - f, - "impl trait ", - opaque_ty.def_id.resolved_id(), - ) + TyKind::OpaqueDef(opaque_ty) => { + write!(f, "impl trait ", opaque_ty.def_id.resolved_id(),) } TyKind::TraitObject(poly_traits, _lft, _syntax) => { write!(f, "dyn {poly_traits:?}") diff --git a/crates/flux-middle/src/fhir/lift.rs b/crates/flux-middle/src/fhir/lift.rs index 97b4501754..50eeeb7df3 100644 --- a/crates/flux-middle/src/fhir/lift.rs +++ b/crates/flux-middle/src/fhir/lift.rs @@ -61,9 +61,9 @@ impl<'a, 'genv, 'tcx> LiftCtxt<'a, 'genv, 'tcx> { default: default.map(|ty| self.lift_ty(ty)).transpose()?, } } - hir::GenericParamKind::Const { ty, is_host_effect, .. } => { + hir::GenericParamKind::Const { ty, .. } => { let ty = self.lift_ty(ty)?; - fhir::GenericParamKind::Const { ty, is_host_effect } + fhir::GenericParamKind::Const { ty } } }; Ok(fhir::GenericParam { @@ -122,13 +122,17 @@ impl<'a, 'genv, 'tcx> LiftCtxt<'a, 'genv, 'tcx> { poly_trait_ref: hir::PolyTraitRef, ) -> Result> { let modifiers = match poly_trait_ref.modifiers { - rustc_hir::TraitBoundModifier::None => fhir::TraitBoundModifier::None, - rustc_hir::TraitBoundModifier::Maybe => fhir::TraitBoundModifier::Maybe, - rustc_hir::TraitBoundModifier::Const - | rustc_hir::TraitBoundModifier::Negative - | rustc_hir::TraitBoundModifier::MaybeConst => { + rustc_hir::TraitBoundModifiers { + constness: rustc_hir::BoundConstness::Never, + polarity: rustc_hir::BoundPolarity::Positive, + } => fhir::TraitBoundModifier::None, + rustc_hir::TraitBoundModifiers { + constness: rustc_hir::BoundConstness::Never, + polarity: rustc_hir::BoundPolarity::Maybe(_), + } => fhir::TraitBoundModifier::Maybe, + _ => { return self.emit_unsupported(&format!( - "unsupported trait modifier: `{:?}`", + "unsupported trait modifiers: `{:?}`", poly_trait_ref.modifiers, )); } @@ -297,15 +301,14 @@ impl<'a, 'genv, 'tcx> LiftCtxt<'a, 'genv, 'tcx> { let ty = self.lift_ty(mut_ty.ty)?; fhir::TyKind::RawPtr(self.genv.alloc(ty), mut_ty.mutbl) } - hir::TyKind::OpaqueDef(opaque_ty, args) => { + hir::TyKind::OpaqueDef(opaque_ty) => { let opaque_ty = self.lift_opaque_ty(opaque_ty)?; let opaque_ty = self.insert_opaque_ty(opaque_ty); - let args = self.lift_generic_args(args)?; - fhir::TyKind::OpaqueDef(opaque_ty, args, &[]) + fhir::TyKind::OpaqueDef(opaque_ty) } hir::TyKind::TraitObject(poly_traits, lft, syntax) => { let poly_traits = try_alloc_slice!(self.genv, poly_traits, |poly_trait| { - if poly_trait.modifiers != hir::TraitBoundModifier::None { + if poly_trait.modifiers != hir::TraitBoundModifiers::NONE { return self.emit_unsupported(&format!( "unsupported type: `{}`", rustc_hir_pretty::ty_to_string(&self.genv.tcx(), ty) diff --git a/crates/flux-middle/src/fhir/visit.rs b/crates/flux-middle/src/fhir/visit.rs index bae7d33e3a..6f3246a9db 100644 --- a/crates/flux-middle/src/fhir/visit.rs +++ b/crates/flux-middle/src/fhir/visit.rs @@ -377,10 +377,8 @@ pub fn walk_ty<'v, V: Visitor<'v>>(vis: &mut V, ty: &Ty<'v>) { TyKind::RawPtr(ty, _mtblt) => { vis.visit_ty(ty); } - TyKind::OpaqueDef(opaque_ty, generics, refine) => { + TyKind::OpaqueDef(opaque_ty) => { vis.visit_opaque_ty(opaque_ty); - walk_list!(vis, visit_generic_arg, generics); - walk_list!(vis, visit_expr, refine); } TyKind::TraitObject(poly_traits, lft, _) => { walk_list!(vis, visit_poly_trait_ref, poly_traits); diff --git a/crates/flux-middle/src/lib.rs b/crates/flux-middle/src/lib.rs index 0d6d20422f..3292b63aba 100644 --- a/crates/flux-middle/src/lib.rs +++ b/crates/flux-middle/src/lib.rs @@ -16,7 +16,7 @@ extern crate rustc_ast; extern crate rustc_data_structures; extern crate rustc_errors; -extern crate rustc_hash; + extern crate rustc_hir; extern crate rustc_hir_pretty; extern crate rustc_index; diff --git a/crates/flux-middle/src/pretty.rs b/crates/flux-middle/src/pretty.rs index 21a6f398f5..e09b91f4e4 100644 --- a/crates/flux-middle/src/pretty.rs +++ b/crates/flux-middle/src/pretty.rs @@ -435,7 +435,7 @@ where Ok(()) } } -impl<'a, T> Pretty for Parens<'a, T> +impl Pretty for Parens<'_, T> where T: Pretty, { diff --git a/crates/flux-middle/src/queries.rs b/crates/flux-middle/src/queries.rs index ea3601d524..03f692cb08 100644 --- a/crates/flux-middle/src/queries.rs +++ b/crates/flux-middle/src/queries.rs @@ -262,7 +262,8 @@ impl<'genv, 'tcx> Queries<'genv, 'tcx> { ) -> QueryResult>> { run_with_cache(&self.mir, def_id, || { let mir = unsafe { flux_common::mir_storage::retrieve_mir_body(genv.tcx(), def_id) }; - let mir = lowering::MirLoweringCtxt::lower_mir_body(genv.tcx(), genv.sess(), mir)?; + let mir = + lowering::MirLoweringCtxt::lower_mir_body(genv.tcx(), genv.sess(), def_id, mir)?; Ok(Rc::new(mir)) }) } diff --git a/crates/flux-middle/src/rty/mod.rs b/crates/flux-middle/src/rty/mod.rs index 0d45b1d4e5..7cff5e585e 100644 --- a/crates/flux-middle/src/rty/mod.rs +++ b/crates/flux-middle/src/rty/mod.rs @@ -452,19 +452,21 @@ impl<'tcx> ToRustc<'tcx> for ExistentialPredicate { fn to_rustc(&self, tcx: TyCtxt<'tcx>) -> Self::T { match self { ExistentialPredicate::Trait(trait_ref) => { - let trait_ref = rustc_middle::ty::ExistentialTraitRef { - def_id: trait_ref.def_id, - args: trait_ref.args.to_rustc(tcx), - }; + let trait_ref = rustc_middle::ty::ExistentialTraitRef::new_from_args( + tcx, + trait_ref.def_id, + trait_ref.args.to_rustc(tcx), + ); rustc_middle::ty::ExistentialPredicate::Trait(trait_ref) } ExistentialPredicate::Projection(projection) => { rustc_middle::ty::ExistentialPredicate::Projection( - rustc_middle::ty::ExistentialProjection { - def_id: projection.def_id, - args: projection.args.to_rustc(tcx), - term: projection.term.skip_binder_ref().to_rustc(tcx).into(), - }, + rustc_middle::ty::ExistentialProjection::new_from_args( + tcx, + projection.def_id, + projection.args.to_rustc(tcx), + projection.term.skip_binder_ref().to_rustc(tcx).into(), + ), ) } ExistentialPredicate::AutoTrait(def_id) => { @@ -1722,11 +1724,11 @@ pub type RefineArgs = List; #[extension(pub trait RefineArgsExt)] impl RefineArgs { - fn identity_for_item(genv: &GlobalEnv, def_id: DefId) -> QueryResult { + fn identity_for_item(genv: GlobalEnv, def_id: DefId) -> QueryResult { let reft_generics = genv.refinement_generics_of(def_id)?; let mut args = vec![]; for i in 0..reft_generics.count() { - let param = reft_generics.param_at(i, *genv)?; + let param = reft_generics.param_at(i, genv)?; let expr = Expr::var(Var::EarlyParam(EarlyReftParam { index: i as u32, name: param.name })); args.push(expr); @@ -2572,7 +2574,7 @@ impl WfckResults { } } -impl<'a, T> LocalTableInContextMut<'a, T> { +impl LocalTableInContextMut<'_, T> { pub fn insert(&mut self, fhir_id: FhirId, value: T) { tracked_span_assert_eq!(self.owner, fhir_id.owner); self.data.insert(fhir_id.local_id, value); diff --git a/crates/flux-middle/src/rty/projections.rs b/crates/flux-middle/src/rty/projections.rs index b482ec8c4e..acc20f5142 100644 --- a/crates/flux-middle/src/rty/projections.rs +++ b/crates/flux-middle/src/rty/projections.rs @@ -425,7 +425,7 @@ impl FallibleTypeFolder for Normalizer<'_, '_, '_> { fn try_fold_const(&mut self, c: &Const) -> Result { c.to_rustc(self.tcx()) - .normalize(self.tcx(), self.rustc_param_env()) + .normalize_internal(self.tcx(), self.rustc_param_env()) .lower(self.tcx()) .map_err(|e| QueryErr::unsupported(self.def_id, e.into_err())) } diff --git a/crates/flux-middle/src/rty/subst.rs b/crates/flux-middle/src/rty/subst.rs index 1b4c84336c..fd0cba309b 100644 --- a/crates/flux-middle/src/rty/subst.rs +++ b/crates/flux-middle/src/rty/subst.rs @@ -163,7 +163,7 @@ pub(crate) struct GenericArgsDelegate<'a, 'tcx>( pub(crate) TyCtxt<'tcx>, ); -impl<'a, 'tcx> GenericsSubstDelegate for GenericArgsDelegate<'a, 'tcx> { +impl GenericsSubstDelegate for GenericArgsDelegate<'_, '_> { fn sort_for_param(&mut self, param_ty: ParamTy) -> Result { match self.0.get(param_ty.index as usize) { Some(GenericArg::Base(ctor)) => Ok(ctor.sort()), diff --git a/crates/flux-middle/src/sort_of.rs b/crates/flux-middle/src/sort_of.rs index cd51d12746..393531d48c 100644 --- a/crates/flux-middle/src/sort_of.rs +++ b/crates/flux-middle/src/sort_of.rs @@ -5,7 +5,7 @@ use rustc_span::def_id::DefId; use crate::{global_env::GlobalEnv, queries::QueryResult, query_bug, rty}; -impl<'sess, 'tcx> GlobalEnv<'sess, 'tcx> { +impl GlobalEnv<'_, '_> { pub fn sort_of_self_ty_alias(self, alias_to: DefId) -> QueryResult> { let self_ty = self.tcx().type_of(alias_to).instantiate_identity(); self.sort_of_rust_ty(alias_to, self_ty) diff --git a/crates/flux-refineck/Cargo.toml b/crates/flux-refineck/Cargo.toml index 1fe1cc58d3..de9917d58b 100644 --- a/crates/flux-refineck/Cargo.toml +++ b/crates/flux-refineck/Cargo.toml @@ -19,6 +19,7 @@ serde_json.workspace = true liquid-fixpoint.workspace = true itertools.workspace = true +rustc-hash.workspace = true tracing = "0.1" diff --git a/crates/flux-refineck/src/checker.rs b/crates/flux-refineck/src/checker.rs index eef6b22535..dd2176ee82 100644 --- a/crates/flux-refineck/src/checker.rs +++ b/crates/flux-refineck/src/checker.rs @@ -42,7 +42,7 @@ use rustc_index::bit_set::BitSet; use rustc_infer::infer::TyCtxtInferExt; use rustc_middle::{ mir::{SourceInfo, SwitchTargets}, - ty::{TyCtxt, TypeSuperVisitable as _, TypeVisitable as _}, + ty::{TyCtxt, TypeSuperVisitable as _, TypeVisitable as _, TypingMode}, }; use rustc_span::{sym, Span}; @@ -340,7 +340,10 @@ pub(crate) fn trait_impl_subtyping( InferCtxtRoot::new(genv, trait_method_id, kvars, Some(&trait_ref.args)).with_span(span)?; dbg::refine_mode_span!(genv.tcx(), def_id, bb_envs).in_scope(|| { - let rustc_infcx = genv.tcx().infer_ctxt().build(); + let rustc_infcx = genv + .tcx() + .infer_ctxt() + .build(TypingMode::non_body_analysis()); let mut infcx = root_ctxt.infcx(trait_method_id, &rustc_infcx); let trait_fn_sig = genv.fn_sig(trait_method_id).with_span(span)?; let tcx = genv.tcx(); @@ -348,7 +351,7 @@ pub(crate) fn trait_impl_subtyping( let impl_args = GenericArg::identity_for_item(genv, def_id).with_span(span)?; let trait_args = impl_args.rebase_onto(&tcx, impl_id, &trait_ref.args); let trait_refine_args = - RefineArgs::identity_for_item(&genv, trait_method_id).with_span(span)?; + RefineArgs::identity_for_item(genv, trait_method_id).with_span(span)?; let impl_sig = genv.fn_sig(def_id).with_span(span)?; check_fn_subtyping( &mut infcx, @@ -386,10 +389,11 @@ fn find_trait_item( /// at the call-site and then folding the pointer back into the &mut upon return. /// See [NOTE:Fold-Local-Pointers] /// +/// ```text /// unpack(T) = T' /// ---------------------------------------[local-unfold] /// Γ ; &mut T => Γ, l:[<: T] T' ; ptr(l) - +/// ``` fn unfold_local_ptrs( infcx: &mut InferCtxt, env: &mut TypeEnv, @@ -417,12 +421,15 @@ fn unfold_local_ptrs( Ok(tys) } -/// [NOTE:Fold-Local-Pointers] Fold local pointers implements roughly a rule like this (for all the local pointers) -/// that converts the local pointers created via [NOTE:Unfold-Local-Pointers] back into &mut. +/// [NOTE:Fold-Local-Pointers] Fold local pointers implements roughly a rule like this (for all the +/// local pointers) that converts the local pointers created via [NOTE:Unfold-Local-Pointers] back +/// into &mut. /// +/// ```text /// T1 <: T2 /// --------------------- [local-fold] /// Γ, l:[<: T2] T1 => Γ +/// ``` fn fold_local_ptrs(infcx: &mut InferCtxt, env: &mut TypeEnv, span: Span) -> Result { let mut at = infcx.at(span); env.fold_local_ptrs(&mut at).with_span(span)?; @@ -465,7 +472,7 @@ impl<'ck, 'genv, 'tcx, M: Mode> Checker<'ck, 'genv, 'tcx, M> { visited: BitSet::new_empty(body.basic_blocks.len()), output: fn_sig.output().clone(), snapshots: IndexVec::from_fn_n(|_| None, body.basic_blocks.len()), - queue: WorkQueue::empty(body.basic_blocks.len(), body.dominators()), + queue: WorkQueue::empty(body.basic_blocks.len(), &body.dominator_order_rank), }; ck.check_ghost_statements_at(&mut infcx, &mut env, Point::FunEntry, body.span())?; @@ -1647,7 +1654,7 @@ fn collect_params_in_clauses(genv: GlobalEnv, def_id: DefId) -> FxHashSet params: FxHashSet, } - impl<'tcx> rustc_middle::ty::TypeVisitor> for Collector { + impl rustc_middle::ty::TypeVisitor> for Collector { fn visit_ty(&mut self, t: rustc_middle::ty::Ty) { if let rustc_middle::ty::Param(param_ty) = t.kind() { self.params.insert(param_ty.index as usize); diff --git a/crates/flux-refineck/src/ghost_statements/fold_unfold.rs b/crates/flux-refineck/src/ghost_statements/fold_unfold.rs index 73f3993d4b..520a956c79 100644 --- a/crates/flux-refineck/src/ghost_statements/fold_unfold.rs +++ b/crates/flux-refineck/src/ghost_statements/fold_unfold.rs @@ -254,7 +254,7 @@ enum PlaceNode { Ty(Ty), } -impl<'a, 'genv, 'tcx, M: Mode> FoldUnfoldAnalysis<'a, 'genv, 'tcx, M> { +impl FoldUnfoldAnalysis<'_, '_, '_, M> { fn run(mut self, fn_sig: Option<&rty::EarlyBinder>) -> QueryResult { let mut env = Env::new(self.body); @@ -470,7 +470,7 @@ impl<'a, 'genv, 'tcx, M> FoldUnfoldAnalysis<'a, 'genv, 'tcx, M> { discriminants: Default::default(), point: Point::FunEntry, visited: BitSet::new_empty(body.basic_blocks.len()), - queue: WorkQueue::empty(body.basic_blocks.len(), body.dominators()), + queue: WorkQueue::empty(body.basic_blocks.len(), &body.dominator_order_rank), mode, } } diff --git a/crates/flux-refineck/src/ghost_statements/points_to.rs b/crates/flux-refineck/src/ghost_statements/points_to.rs index 245e8548f3..6d647732f8 100644 --- a/crates/flux-refineck/src/ghost_statements/points_to.rs +++ b/crates/flux-refineck/src/ghost_statements/points_to.rs @@ -53,8 +53,7 @@ pub(crate) fn add_ghost_statements<'tcx>( let mut visitor = CollectPointerToBorrows::new(&map, stmts); PointsToAnalysis::new(&map, fn_sig) - .into_engine(genv.tcx(), body) - .iterate_to_fixpoint() + .iterate_to_fixpoint(genv.tcx(), body, None) .visit_reachable_with(body, &mut visitor); Ok(()) @@ -604,7 +603,7 @@ impl<'a> Children<'a> { } } -impl<'a> Iterator for Children<'a> { +impl Iterator for Children<'_> { type Item = PlaceIndex; fn next(&mut self) -> Option { @@ -793,7 +792,7 @@ impl State { } /// This is used to visualize the dataflow analysis. -impl<'a> DebugWithContext> for State { +impl DebugWithContext> for State { fn fmt_with(&self, ctxt: &PointsToAnalysis, f: &mut fmt::Formatter<'_>) -> std::fmt::Result { debug_with_context(&self.values, None, ctxt.map, f) } diff --git a/crates/flux-refineck/src/lib.rs b/crates/flux-refineck/src/lib.rs index 39bceb97ce..1a4bf179b1 100644 --- a/crates/flux-refineck/src/lib.rs +++ b/crates/flux-refineck/src/lib.rs @@ -14,7 +14,7 @@ extern crate rustc_data_structures; extern crate rustc_errors; -extern crate rustc_hash; + extern crate rustc_hir; extern crate rustc_index; extern crate rustc_infer; diff --git a/crates/flux-refineck/src/queue.rs b/crates/flux-refineck/src/queue.rs index 82c475f894..891e9cade0 100644 --- a/crates/flux-refineck/src/queue.rs +++ b/crates/flux-refineck/src/queue.rs @@ -1,28 +1,32 @@ use std::collections::BinaryHeap; -use rustc_data_structures::graph::dominators::Dominators; -use rustc_index::bit_set::BitSet; +use rustc_index::{bit_set::BitSet, IndexVec}; use rustc_middle::mir::BasicBlock; struct Item<'a> { bb: BasicBlock, - dominators: &'a Dominators, + dominator_order_rank: &'a IndexVec, } pub(crate) struct WorkQueue<'a> { heap: BinaryHeap>, set: BitSet, - dominators: &'a Dominators, + dominator_order_rank: &'a IndexVec, } impl<'a> WorkQueue<'a> { - pub(crate) fn empty(len: usize, dominators: &'a Dominators) -> Self { - Self { heap: BinaryHeap::with_capacity(len), set: BitSet::new_empty(len), dominators } + pub(crate) fn empty(len: usize, dominator_order_rank: &'a IndexVec) -> Self { + Self { + heap: BinaryHeap::with_capacity(len), + set: BitSet::new_empty(len), + dominator_order_rank, + } } pub(crate) fn insert(&mut self, bb: BasicBlock) -> bool { if self.set.insert(bb) { - self.heap.push(Item { bb, dominators: self.dominators }); + self.heap + .push(Item { bb, dominator_order_rank: self.dominator_order_rank }); true } else { false @@ -55,6 +59,6 @@ impl Eq for Item<'_> {} impl Ord for Item<'_> { fn cmp(&self, other: &Self) -> std::cmp::Ordering { - self.dominators.cmp_in_dominator_order(other.bb, self.bb) + self.dominator_order_rank[other.bb].cmp(&self.dominator_order_rank[self.bb]) } } diff --git a/crates/flux-refineck/src/type_env.rs b/crates/flux-refineck/src/type_env.rs index 71af1ac04b..15c8cb7403 100644 --- a/crates/flux-refineck/src/type_env.rs +++ b/crates/flux-refineck/src/type_env.rs @@ -888,7 +888,7 @@ struct TypeEnvBind { } impl TypeEnvTrace { - pub fn new<'a>(env: &TypeEnv<'a>) -> Self { + pub fn new(env: &TypeEnv) -> Self { let mut bindings = vec![]; env.bindings .iter() diff --git a/crates/flux-rustc-bridge/src/lowering.rs b/crates/flux-rustc-bridge/src/lowering.rs index fccea1dd36..6a8af49d61 100644 --- a/crates/flux-rustc-bridge/src/lowering.rs +++ b/crates/flux-rustc-bridge/src/lowering.rs @@ -4,7 +4,7 @@ use flux_errors::FluxSession; use itertools::Itertools; use rustc_borrowck::consumers::BodyWithBorrowckFacts; use rustc_errors::ErrorGuaranteed; -use rustc_hir::def_id::DefId; +use rustc_hir::def_id::{DefId, LocalDefId}; use rustc_infer::{infer::TyCtxtInferExt, traits::Obligation}; use rustc_macros::{Decodable, Encodable}; use rustc_middle::{ @@ -12,7 +12,7 @@ use rustc_middle::{ traits::{ImplSource, ObligationCause}, ty::{ self as rustc_ty, adjustment as rustc_adjustment, GenericArgKind, ParamConst, ParamEnv, - TyCtxt, ValTree, + TyCtxt, TypingMode, ValTree, }, }; use rustc_span::{Span, Symbol, DUMMY_SP}; @@ -104,7 +104,7 @@ pub fn resolve_trait_ref_impl_id<'tcx>( trait_ref: rustc_ty::TraitRef<'tcx>, ) -> Option<(DefId, rustc_middle::ty::GenericArgsRef<'tcx>)> { let param_env = tcx.param_env(def_id); - let infcx = tcx.infer_ctxt().build(); + let infcx = tcx.infer_ctxt().build(TypingMode::non_body_analysis()); trait_ref_impl_id(tcx, &mut SelectionContext::new(&infcx), param_env, trait_ref) } @@ -128,9 +128,10 @@ impl<'sess, 'tcx> MirLoweringCtxt<'_, 'sess, 'tcx> { pub fn lower_mir_body( tcx: TyCtxt<'tcx>, sess: &'sess FluxSession, + def_id: LocalDefId, body_with_facts: BodyWithBorrowckFacts<'tcx>, ) -> Result, ErrorGuaranteed> { - let infcx = replicate_infer_ctxt(tcx, &body_with_facts); + let infcx = replicate_infer_ctxt(tcx, def_id, &body_with_facts); let param_env = tcx.param_env(body_with_facts.body.source.def_id()); let selcx = SelectionContext::new(&infcx); let mut lower = @@ -1021,8 +1022,8 @@ impl<'tcx> Lower<'tcx> for &rustc_middle::ty::GenericParamDef { GenericParamDefKind::Type { has_default } } rustc_ty::GenericParamDefKind::Lifetime => GenericParamDefKind::Lifetime, - rustc_ty::GenericParamDefKind::Const { has_default, is_host_effect, .. } => { - GenericParamDefKind::Const { has_default, is_host_effect } + rustc_ty::GenericParamDefKind::Const { has_default, .. } => { + GenericParamDefKind::Const { has_default } } }; GenericParamDef { def_id: self.def_id, index: self.index, name: self.name, kind } diff --git a/crates/flux-rustc-bridge/src/mir.rs b/crates/flux-rustc-bridge/src/mir.rs index 90c714b823..ccd7a440f2 100644 --- a/crates/flux-rustc-bridge/src/mir.rs +++ b/crates/flux-rustc-bridge/src/mir.rs @@ -8,14 +8,17 @@ use itertools::Itertools; use rustc_ast::Mutability; pub use rustc_borrowck::borrow_set::BorrowData; use rustc_borrowck::consumers::{BodyWithBorrowckFacts, BorrowIndex}; -use rustc_data_structures::{fx::FxIndexMap, graph::dominators::Dominators}; -use rustc_hir::def_id::DefId; +use rustc_data_structures::{ + fx::FxIndexMap, + graph::{self, dominators::Dominators, DirectedGraph, StartNode}, +}; +use rustc_hir::def_id::{DefId, LocalDefId}; use rustc_index::IndexSlice; use rustc_infer::infer::TyCtxtInferExt; use rustc_macros::{TyDecodable, TyEncodable}; use rustc_middle::{ mir, - ty::{FloatTy, IntTy, ParamConst, TyCtxt, UintTy}, + ty::{FloatTy, IntTy, ParamConst, TyCtxt, TypingMode, UintTy}, }; pub use rustc_middle::{ mir::{ @@ -68,6 +71,7 @@ pub struct Body<'tcx> { /// [region variable ids]: super::ty::RegionVid /// [`InferCtxt`]: rustc_infer::infer::InferCtxt pub infcx: rustc_infer::infer::InferCtxt<'tcx>, + pub dominator_order_rank: IndexVec, /// See [`mk_fake_predecessors`] fake_predecessors: IndexVec, body_with_facts: BodyWithBorrowckFacts<'tcx>, @@ -349,7 +353,7 @@ pub enum Constant { Opaque(Ty), } -impl<'tcx> Terminator<'tcx> { +impl Terminator<'_> { pub fn is_return(&self) -> bool { matches!(self.kind, TerminatorKind::Return) } @@ -369,7 +373,24 @@ impl<'tcx> Body<'tcx> { infcx: rustc_infer::infer::InferCtxt<'tcx>, ) -> Self { let fake_predecessors = mk_fake_predecessors(&basic_blocks); - Self { basic_blocks, local_decls, infcx, fake_predecessors, body_with_facts } + + // The dominator rank of each node is just its index in a reverse-postorder traversal. + let graph = &body_with_facts.body.basic_blocks; + let mut dominator_order_rank = IndexVec::from_elem_n(0, graph.num_nodes()); + let reverse_post_order = graph::iterate::reverse_post_order(graph, graph.start_node()); + assert_eq!(reverse_post_order.len(), graph.num_nodes()); + for (rank, bb) in (0u32..).zip(reverse_post_order) { + dominator_order_rank[bb] = rank; + } + + Self { + basic_blocks, + local_decls, + infcx, + fake_predecessors, + body_with_facts, + dominator_order_rank, + } } pub fn def_id(&self) -> DefId { @@ -446,9 +467,12 @@ impl<'tcx> Body<'tcx> { /// [`InferCtxt`]: rustc_infer::infer::InferCtxt pub(crate) fn replicate_infer_ctxt<'tcx>( tcx: TyCtxt<'tcx>, + def_id: LocalDefId, body_with_facts: &BodyWithBorrowckFacts<'tcx>, ) -> rustc_infer::infer::InferCtxt<'tcx> { - let infcx = tcx.infer_ctxt().build(); + let infcx = tcx + .infer_ctxt() + .build(TypingMode::analysis_in_body(tcx, def_id)); for info in &body_with_facts.region_inference_context.var_infos { infcx.next_region_var(info.origin); } @@ -522,7 +546,7 @@ impl fmt::Debug for Statement { } } -impl<'tcx> fmt::Debug for CallKind<'tcx> { +impl fmt::Debug for CallKind<'_> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { CallKind::FnDef { resolved_id, resolved_args, .. } => { @@ -541,7 +565,7 @@ impl<'tcx> fmt::Debug for CallKind<'tcx> { } } -impl<'tcx> fmt::Debug for Terminator<'tcx> { +impl fmt::Debug for Terminator<'_> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match &self.kind { TerminatorKind::Return => write!(f, "return"), diff --git a/crates/flux-rustc-bridge/src/ty/mod.rs b/crates/flux-rustc-bridge/src/ty/mod.rs index 47d98b3ad7..25134ac8f0 100644 --- a/crates/flux-rustc-bridge/src/ty/mod.rs +++ b/crates/flux-rustc-bridge/src/ty/mod.rs @@ -70,17 +70,11 @@ pub struct GenericParamDef { pub kind: GenericParamDefKind, } -impl GenericParamDef { - pub fn is_host_effect(&self) -> bool { - matches!(self.kind, GenericParamDefKind::Const { is_host_effect: true, .. }) - } -} - #[derive(Debug, Hash, Eq, PartialEq, Clone, Copy, TyEncodable, TyDecodable)] pub enum GenericParamDefKind { Type { has_default: bool }, Lifetime, - Const { has_default: bool, is_host_effect: bool }, + Const { has_default: bool }, } #[derive(Clone, Debug)] @@ -867,19 +861,21 @@ impl<'tcx> ToRustc<'tcx> for ExistentialPredicate { fn to_rustc(&self, tcx: TyCtxt<'tcx>) -> Self::T { match self { ExistentialPredicate::Trait(trait_ref) => { - let trait_ref = rustc_middle::ty::ExistentialTraitRef { - def_id: trait_ref.def_id, - args: trait_ref.args.to_rustc(tcx), - }; + let trait_ref = rustc_middle::ty::ExistentialTraitRef::new_from_args( + tcx, + trait_ref.def_id, + trait_ref.args.to_rustc(tcx), + ); rustc_middle::ty::ExistentialPredicate::Trait(trait_ref) } ExistentialPredicate::Projection(projection) => { rustc_middle::ty::ExistentialPredicate::Projection( - rustc_middle::ty::ExistentialProjection { - def_id: projection.def_id, - args: projection.args.to_rustc(tcx), - term: projection.term.to_rustc(tcx).into(), - }, + rustc_middle::ty::ExistentialProjection::new_from_args( + tcx, + projection.def_id, + projection.args.to_rustc(tcx), + projection.term.to_rustc(tcx).into(), + ), ) } ExistentialPredicate::AutoTrait(def_id) => { diff --git a/lib/liquid-fixpoint/src/lib.rs b/lib/liquid-fixpoint/src/lib.rs index 89d7916bbf..98a543d31b 100644 --- a/lib/liquid-fixpoint/src/lib.rs +++ b/lib/liquid-fixpoint/src/lib.rs @@ -214,8 +214,7 @@ impl Task { .stdin(Stdio::piped()) .stdout(Stdio::piped()) .stderr(Stdio::null()) - .spawn() - .unwrap(); + .spawn()?; let mut stdin = None; std::mem::swap(&mut stdin, &mut child.stdin); { diff --git a/rust-toolchain b/rust-toolchain index e4a974e4e7..8feb5820f4 100644 --- a/rust-toolchain +++ b/rust-toolchain @@ -1,3 +1,3 @@ [toolchain] -channel = "nightly-2024-10-20" +channel = "nightly-2024-11-03" components = ["rust-src", "rustc-dev", "llvm-tools", "rustfmt"]