remove DynKind (only support Dyn) else panic

flux-rs · ranjitjhala · Jul 29, 2024 · May 22, 2024 · Jun 14, 2024 · Jun 17, 2024
commit 01c4724ccd3ab35ed2718e0f311f5c6bce746a2e
diff --git a/crates/flux-fhir-analysis/src/conv/fill_holes.rs b/crates/flux-fhir-analysis/src/conv/fill_holes.rs
@@ -217,8 217,8 @@ impl<'genv, 'tcx> Zipper<'genv, 'tcx> {
  debug_assert_eq!(pty_a, pty_b);
  }
  (
- rty::BaseTy::Dynamic(poly_trait_refs, re_a, _),
- ty::TyKind::Dynamic(poly_trait_refs_b, re_b, _),
  rty::BaseTy::Dynamic(poly_trait_refs, re_a),
  ty::TyKind::Dynamic(poly_trait_refs_b, re_b),
  ) => {
  self.zip_region(re_a, re_b);
  debug_assert_eq!(poly_trait_refs.len(), poly_trait_refs_b.len());

diff --git a/crates/flux-fhir-analysis/src/conv/mod.rs b/crates/flux-fhir-analysis/src/conv/mod.rs
@@ -23,10 23,7 @@ use flux_middle::{
  refining::{self, Refiner},
  AdtSortDef, ESpan, WfckResults, INNERMOST,
  },
- rustc::{
- self,
- ty::{DynKind, Region},
- },
  rustc::{self, ty::Region},
 };
 use itertools::Itertools;
 use rustc_data_structures::fx::FxIndexMap;
@@ -819,18 816,11 @@ impl<'a, 'genv, 'tcx> ConvCtxt<'a, 'genv, 'tcx> {
  .map(|poly_trait| self.conv_poly_trait_ref_dyn(env, poly_trait))
  .try_collect()?;
  let region = self.conv_lifetime(env, *lft);
- let kind = Self::conv_trait_object_syntax(syn);
- Ok(rty::Ty::dynamic(exi_preds, region, kind))
- }
- }
- }
-
- fn conv_trait_object_syntax(syn: &rustc_ast::TraitObjectSyntax) -> DynKind {
- match syn {
- rustc_ast::TraitObjectSyntax::Dyn => DynKind::Dyn,
- rustc_ast::TraitObjectSyntax::None => DynKind::None,
- rustc_ast::TraitObjectSyntax::DynStar => {
- tracked_span_bug!("dyn* traits not supported yet")
  if matches!(syn, rustc_ast::TraitObjectSyntax::Dyn) {
  Ok(rty::Ty::dynamic(exi_preds, region))
  } else {
  tracked_span_bug!("dyn* traits not supported yet")
  }
  }
  }
  }

diff --git a/crates/flux-middle/src/rty/fold.rs b/crates/flux-middle/src/rty/fold.rs
@@ -971,7 971,7 @@ impl TypeSuperVisitable for BaseTy {
  | BaseTy::Closure(_, _)
  | BaseTy::Never
  | BaseTy::Param(_) => ControlFlow::Continue(()),
- BaseTy::Dynamic(exi_preds, _, _) => exi_preds.visit_with(visitor),
  BaseTy::Dynamic(exi_preds, _) => exi_preds.visit_with(visitor),
  }
  }
 }
@@ -1011,12 1011,8 @@ impl TypeSuperFoldable for BaseTy {
  args.try_fold_with(folder)?,
  )
  }
- BaseTy::Dynamic(exi_preds, region, syn) => {
- BaseTy::Dynamic(
- exi_preds.try_fold_with(folder)?,
- region.try_fold_with(folder)?,
- *syn,
- )
  BaseTy::Dynamic(exi_preds, region) => {
  BaseTy::Dynamic(exi_preds.try_fold_with(folder)?, region.try_fold_with(folder)?)
  }
  };
  Ok(bty)

diff --git a/crates/flux-middle/src/rty/mod.rs b/crates/flux-middle/src/rty/mod.rs
@@ -57,11 57,7 @@ use crate::{
  intern::{impl_internable, impl_slice_internable, Interned, List},
  queries::QueryResult,
  rty::subst::SortSubst,
- rustc::{
- self,
- mir::Place,
- ty::{DynKind, VariantDef},
- },
  rustc::{self, mir::Place, ty::VariantDef},
 };
 
 #[derive(Debug, Clone, Eq, PartialEq, Hash, TyEncodable, TyDecodable)]
@@ -642,12 638,8 @@ impl Ty {
  Self::alias(AliasKind::Projection, alias_ty)
  }
 
- pub fn dynamic(
- preds: impl Into<List<Binder<ExistentialPredicate>>>,
- region: Region,
- kind: DynKind,
- ) -> Ty {
- BaseTy::Dynamic(preds.into(), region, kind).to_ty()
  pub fn dynamic(preds: impl Into<List<Binder<ExistentialPredicate>>>, region: Region) -> Ty {
  BaseTy::Dynamic(preds.into(), region).to_ty()
  }
 
  pub fn strg_ref(re: Region, path: Path, ty: Ty) -> Ty {
@@ -979,7 971,7 @@ pub enum BaseTy {
  Never,
  Closure(DefId, /* upvar_tys */ List<Ty>),
  Coroutine(DefId, /*resume_ty: */ Ty, /* upvar_tys: */ List<Ty>),
- Dynamic(List<Binder<ExistentialPredicate>>, Region, DynKind),
  Dynamic(List<Binder<ExistentialPredicate>>, Region),
  Param(ParamTy),
 }
 
@@ -1128,7 1120,7 @@ impl BaseTy {
  | BaseTy::Array(_, _)
  | BaseTy::Closure(_, _)
  | BaseTy::Coroutine(..)
- | BaseTy::Dynamic(_, _, _)
  | BaseTy::Dynamic(_, _)
  | BaseTy::Never => Sort::unit(),
  }
  }
@@ -1161,7 1153,14 @@ impl BaseTy {
  BaseTy::Array(_, _) => todo!(),
  BaseTy::Never => tcx.types.never,
  BaseTy::Closure(_, _) => todo!(),
- BaseTy::Dynamic(_, _, _) => todo!(),
  BaseTy::Dynamic(_exi_preds, _re) => {
  todo!()
  // let preds = exi_preds
  // .iter()
  // .map(|pred| pred.to_rustc(tcx))
  // .collect_vec();
  // ty::Ty::new_dynamic(tcx, preds, re.to_rustc(tcx), rustc_middle::ty::DynKind::Dyn)
  }
  BaseTy::Coroutine(def_id, resume_ty, upvars) => {
  todo!("Generator {def_id:?} {resume_ty:?} {upvars:?}")
  // let args = args.iter().map(|arg| into_rustc_generic_arg(tcx, arg));

diff --git a/crates/flux-middle/src/rty/pretty.rs b/crates/flux-middle/src/rty/pretty.rs
@@ -399,7 399,7 @@ impl Pretty for BaseTy {
  }
  Ok(())
  }
- BaseTy::Dynamic(exi_preds, _, _) => {
  BaseTy::Dynamic(exi_preds, _) => {
  w!("dyn {:?}", join!(", ", exi_preds))
  }
  }

diff --git a/crates/flux-middle/src/rty/refining.rs b/crates/flux-middle/src/rty/refining.rs
@@ -382,12 382,12 @@ impl<'genv, 'tcx> Refiner<'genv, 'tcx> {
  rustc::ty::TyKind::RawPtr(ty, mu) => {
  rty::BaseTy::RawPtr(self.as_default().refine_ty(ty)?, *mu)
  }
- rustc::ty::TyKind::Dynamic(exi_preds, r, kind) => {
  rustc::ty::TyKind::Dynamic(exi_preds, r) => {
  let exi_preds = exi_preds
  .iter()
  .map(|ty| self.refine_existential_predicate(ty))
  .try_collect()?;
- rty::BaseTy::Dynamic(exi_preds, *r, *kind)
  rty::BaseTy::Dynamic(exi_preds, *r)
  }
  };
  Ok(TyOrBase::Base((self.refine)(bty)))

diff --git a/crates/flux-middle/src/rustc/lowering.rs b/crates/flux-middle/src/rustc/lowering.rs
@@ -25,9 25,9 @@ use super::{
  },
  ty::{
  AdtDef, AdtDefData, AliasKind, Binder, BoundRegion, BoundVariableKind, Clause, ClauseKind,
- Const, ConstKind, DynKind, ExistentialPredicate, FieldDef, FnSig, GenericArg,
- GenericParamDef, GenericParamDefKind, GenericPredicates, Generics, OutlivesPredicate,
- PolyFnSig, TraitPredicate, TraitRef, Ty, TypeOutlivesPredicate, VariantDef,
  Const, ConstKind, ExistentialPredicate, FieldDef, FnSig, GenericArg, GenericParamDef,
  GenericParamDefKind, GenericPredicates, Generics, OutlivesPredicate, PolyFnSig,
  TraitPredicate, TraitRef, Ty, TypeOutlivesPredicate, VariantDef,
  },
 };
 use crate::{
@@ -740,17 740,17 @@ pub(crate) fn lower_ty<'tcx>(
  let args = lower_generic_args(tcx, args)?;
  Ok(Ty::mk_generator_witness(*did, args))
  }
- rustc_ty::Dynamic(predicates, region, kind) => {
  rustc_ty::Dynamic(predicates, region, rustc_ty::DynKind::Dyn) => {
  let region = lower_region(region)?;
- let kind = lower_dyn_kind(kind)?;
 
  let exi_preds = List::from_vec(
  predicates
  .iter()
  .map(|pred| lower_existential_predicate(tcx, pred))
  .try_collect()?,
  );
 
- Ok(Ty::mk_dynamic(exi_preds, region, kind))
  Ok(Ty::mk_dynamic(exi_preds, region))
  }
  _ => Err(UnsupportedReason::new(format!("unsupported type `{ty:?}`"))),
  }
@@ -822,14 822,14 @@ fn lower_generic_arg<'tcx>(
  }
 }
 
-fn lower_dyn_kind(kind: &rustc_ty::DynKind) -> Result<DynKind, UnsupportedReason> {
- match kind {
- rustc_ty::DynKind::Dyn => Ok(DynKind::Dyn),
- rustc_ty::DynKind::DynStar => {
- Err(UnsupportedReason::new(format!("unsupported dyn kind `{kind:?}`")))
- }
- }
-}
 // fn lower_dyn_kind(kind: &rustc_ty::DynKind) -> Result<DynKind, UnsupportedReason> {
 //  match kind {
 //  rustc_ty::DynKind::Dyn => Ok(DynKind::Dyn),
 //  rustc_ty::DynKind::DynStar => {
 //  Err(UnsupportedReason::new(format!("unsupported dyn kind `{kind:?}`")))
 //  }
 //  }
 // }
 
 fn lower_region(region: &rustc_middle::ty::Region) -> Result<Region, UnsupportedReason> {
  use rustc_middle::ty::RegionKind;

diff --git a/crates/flux-middle/src/rustc/ty.rs b/crates/flux-middle/src/rustc/ty.rs
@@ -182,7 182,7 @@ pub enum TyKind {
  CoroutineWitness(DefId, GenericArgs),
  Alias(AliasKind, AliasTy),
  RawPtr(Ty, Mutability),
- Dynamic(List<Binder<ExistentialPredicate>>, Region, DynKind),
  Dynamic(List<Binder<ExistentialPredicate>>, Region),
 }
 
 #[derive(Debug, PartialEq, Eq, Hash, TyEncodable, TyDecodable)]
@@ -196,12 196,6 @@ pub struct ExistentialTraitRef {
  pub args: GenericArgs,
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TyEncodable, TyDecodable)]
-pub enum DynKind {
- Dyn,
- None,
-}
-
 #[derive(Debug, PartialEq, Eq, Hash, TyEncodable, TyDecodable)]
 pub struct AliasTy {
  pub args: GenericArgs,
@@ -648,12 642,8 @@ impl Ty {
  TyKind::Param(param).intern()
  }
 
- pub fn mk_dynamic(
- exi_preds: impl Into<List<Binder<ExistentialPredicate>>>,
- r: Region,
- kind: DynKind,
- ) -> Ty {
- TyKind::Dynamic(exi_preds.into(), r, kind).intern()
  pub fn mk_dynamic(exi_preds: impl Into<List<Binder<ExistentialPredicate>>>, r: Region) -> Ty {
  TyKind::Dynamic(exi_preds.into(), r).intern()
  }
 
  pub fn mk_ref(region: Region, ty: Ty, mutability: Mutability) -> Ty {
@@ -747,7 737,7 @@ impl Ty {
  TyKind::Coroutine(_, _) => todo!(),
  TyKind::CoroutineWitness(_, _) => todo!(),
  TyKind::Alias(_, _) => todo!(),
- TyKind::Dynamic(_, _, _) => todo!(),
  TyKind::Dynamic(_, _) => todo!(),
  };
  rustc_ty::Ty::new(tcx, kind)
  }
@@ -870,7 860,7 @@ impl fmt::Debug for Ty {
  write!(f, ")")?;
  Ok(())
  }
- TyKind::Dynamic(exi_preds, _r, _syn) => {
  TyKind::Dynamic(exi_preds, _r) => {
  write!(f, "dyn {exi_preds:?}")
  }
  }

diff --git a/crates/flux-middle/src/rustc/ty/subst.rs b/crates/flux-middle/src/rustc/ty/subst.rs
@@ -46,7 46,7 @@ impl Subst for Ty {
  TyKind::RawPtr(ty, mutbl) => Ty::mk_raw_ptr(ty.subst(args), *mutbl),
  TyKind::Param(param_ty) => args[param_ty.index as usize].expect_type().clone(),
  TyKind::FnPtr(fn_sig) => Ty::mk_fn_ptr(fn_sig.subst(args)),
- TyKind::Dynamic(exi_preds, re, syn) => Ty::mk_dynamic(exi_preds.subst(args), *re, *syn),
  TyKind::Dynamic(exi_preds, re) => Ty::mk_dynamic(exi_preds.subst(args), *re),
  TyKind::Bool
  | TyKind::Uint(_)
  | TyKind::Str

diff --git a/crates/flux-refineck/src/checker.rs b/crates/flux-refineck/src/checker.rs
@@ -974,7 974,7 @@ impl<'ck, 'genv, 'tcx, M: Mode> Checker<'ck, 'genv, 'tcx, M> {
  Ty::mk_ref(*dst_re, dst_slice, *dst_mut)
  } else
  // &T -> & dyn U
- if let rustc::ty::TyKind::Dynamic(_, _, _) = dst_ty.kind() {
  if let rustc::ty::TyKind::Dynamic(_, _) = dst_ty.kind() {
  self.genv
  .refine_default(&self.generics, to)
  .with_span(self.body.span())?

diff --git a/crates/flux-refineck/src/constraint_gen.rs b/crates/flux-refineck/src/constraint_gen.rs
@@ -584,7 584,7 @@ impl<'a, 'genv, 'tcx> InferCtxt<'a, 'genv, 'tcx> {
  | (BaseTy::Str, BaseTy::Str)
  | (BaseTy::Char, BaseTy::Char)
  | (BaseTy::RawPtr(_, _), BaseTy::RawPtr(_, _))
- | (BaseTy::Dynamic(_, _, _), BaseTy::Dynamic(_, _, _)) => Ok(()),
  | (BaseTy::Dynamic(_, _), BaseTy::Dynamic(_, _)) => Ok(()),
  (BaseTy::Closure(did1, tys1), BaseTy::Closure(did2, tys2)) if did1 == did2 => {
  debug_assert_eq!(tys1.len(), tys2.len());
  for (ty1, ty2) in iter::zip(tys1, tys2) {

diff --git a/crates/flux-refineck/src/type_env.rs b/crates/flux-refineck/src/type_env.rs
@@ -373,7 373,7 @@ impl BasicBlockEnvShape {
  | BaseTy::Char
  | BaseTy::Never
  | BaseTy::Closure(_, _)
- | BaseTy::Dynamic(_, _, _)
  | BaseTy::Dynamic(_, _)
  | BaseTy::Coroutine(..) => bty.clone(),
  }
  }