From 32f06b53323280dc7fb149e0a25eb1c7045ecd4e Mon Sep 17 00:00:00 2001 From: Dominik Stolz Date: Tue, 6 Jun 2023 16:26:53 +0200 Subject: [PATCH 01/12] Add TransId to refer to translated items --- creusot/src/backend.rs | 78 +++++++++++++++++++------------- creusot/src/backend/clone_map.rs | 4 +- 2 files changed, 49 insertions(+), 33 deletions(-) diff --git a/creusot/src/backend.rs b/creusot/src/backend.rs index 6145fbc95..b7d370cc4 100644 --- a/creusot/src/backend.rs +++ b/creusot/src/backend.rs @@ -22,12 +22,23 @@ pub(crate) mod term; pub(crate) mod traits; pub(crate) mod ty; +#[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Debug)] +struct TransId { + def_id: DefId, +} + +impl From for TransId { + fn from(def_id: DefId) -> Self { + TransId { def_id } + } +} + pub struct Why3Generator<'tcx> { ctx: TranslationCtx<'tcx>, - dependencies: IndexMap>, - functions: IndexMap, - translated_items: IndexSet, - in_translation: Vec>, + dependencies: IndexMap>, + functions: IndexMap, + translated_items: IndexSet, + in_translation: Vec>, } impl<'tcx> Deref for Why3Generator<'tcx> { @@ -56,12 +67,13 @@ impl<'tcx> Why3Generator<'tcx> { } // Checks if we are allowed to recurse into - fn safe_cycle(&self, def_id: DefId) -> bool { - self.in_translation.last().map(|l| l.contains(&def_id)).unwrap_or_default() + fn safe_cycle(&self, trans_id: TransId) -> bool { + self.in_translation.last().map(|l| l.contains(&trans_id)).unwrap_or_default() } pub(crate) fn translate(&mut self, def_id: DefId) { - if self.translated_items.contains(&def_id) || self.safe_cycle(def_id) { + let tid = def_id.into(); + if self.translated_items.contains(&tid) || self.safe_cycle(tid) { return; } debug!("translating {:?}", def_id); @@ -72,8 +84,8 @@ impl<'tcx> Why3Generator<'tcx> { ItemType::Trait => { self.start(def_id); let tr = self.translate_trait(def_id); - self.dependencies.insert(def_id, CloneSummary::new()); - self.functions.insert(def_id, tr); + self.dependencies.insert(tid, CloneSummary::new()); + self.functions.insert(tid, tr); self.finish(def_id); } ItemType::Impl => { @@ -81,8 +93,8 @@ impl<'tcx> Why3Generator<'tcx> { self.start(def_id); let impl_ = traits::lower_impl(self, def_id); - self.dependencies.insert(def_id, CloneSummary::new()); - self.functions.insert(def_id, TranslatedItem::Impl { modl: impl_ }); + self.dependencies.insert(tid, CloneSummary::new()); + self.functions.insert(tid, TranslatedItem::Impl { modl: impl_ }); self.finish(def_id); } } @@ -95,15 +107,15 @@ impl<'tcx> Why3Generator<'tcx> { self.start(def_id); let (modl, dependencies) = self.translate_assoc_ty(def_id); self.finish(def_id); - self.dependencies.insert(def_id, dependencies); - self.functions.insert(def_id, TranslatedItem::AssocTy { modl }); + self.dependencies.insert(tid, dependencies); + self.functions.insert(tid, TranslatedItem::AssocTy { modl }); } ItemType::Constant => { self.start(def_id); let (constant, dependencies) = self.translate_constant(def_id); self.finish(def_id); - self.dependencies.insert(def_id, dependencies); - self.functions.insert(def_id, constant); + self.dependencies.insert(tid, dependencies); + self.functions.insert(tid, constant); } ItemType::Type => { let bg = self.binding_group(def_id).clone(); @@ -116,7 +128,7 @@ impl<'tcx> Why3Generator<'tcx> { self.finish(*d); } - let repr = self.representative_type(def_id); + let repr = self.representative_type(def_id).into(); if let Some(modl) = modl { self.functions .insert(repr, TranslatedItem::Type { modl, accessors: Default::default() }); @@ -148,31 +160,31 @@ impl<'tcx> Why3Generator<'tcx> { debug!("translating {:?} as logical", def_id); let (stub, modl, proof_modl, has_axioms, deps) = crate::backend::logic::translate_logic_or_predicate(self, def_id); - self.dependencies.insert(def_id, deps); + self.dependencies.insert(def_id.into(), deps); TranslatedItem::Logic { stub, interface, modl, proof_modl, has_axioms } } ItemType::Closure => { let (ty_modl, modl) = program::translate_closure(self, def_id); - self.dependencies.insert(def_id, deps); + self.dependencies.insert(def_id.into(), deps); TranslatedItem::Closure { interface: vec![ty_modl, interface], modl } } ItemType::Program => { debug!("translating {def_id:?} as program"); - self.dependencies.insert(def_id, deps); + self.dependencies.insert(def_id.into(), deps); let modl = program::translate_function(self, def_id); TranslatedItem::Program { interface, modl } } _ => unreachable!(), }; - self.functions.insert(def_id, translated); + self.functions.insert(def_id.into(), translated); } pub(crate) fn translate_accessor(&mut self, field_id: DefId) { - if !self.translated_items.insert(field_id) { + if !self.translated_items.insert(field_id.into()) { return; } @@ -187,7 +199,7 @@ impl<'tcx> Why3Generator<'tcx> { self.translate(adt_did); let accessor = ty::translate_accessor(self, adt_did, variant_did, field_id); - let repr_id = self.representative_type(adt_did); + let repr_id: TransId = self.representative_type(adt_did).into(); if let TranslatedItem::Type { ref mut accessors, .. } = &mut self.functions[&repr_id] { accessors.entry(variant_did).or_default().insert(field_id, accessor); }; @@ -195,22 +207,24 @@ impl<'tcx> Why3Generator<'tcx> { } pub(crate) fn item(&self, def_id: DefId) -> Option<&TranslatedItem> { - let def_id = if matches!(util::item_type(***self, def_id), ItemType::Type) { + let tid: TransId = if matches!(util::item_type(***self, def_id), ItemType::Type) { self.representative_type(def_id) } else { def_id - }; - self.functions.get(&def_id) + } + .into(); + self.functions.get(&tid) } pub(crate) fn modules(self) -> impl Iterator + 'tcx { - self.functions.into_iter() + self.functions.into_iter().map(|(tid, item)| (tid.def_id, item)) } pub(crate) fn start_group(&mut self, ids: IndexSet) { assert!(!ids.is_empty()); + let ids = ids.into_iter().map(Into::into).collect(); if self.in_translation.iter().rev().any(|s| !s.is_disjoint(&ids)) { - let span = self.def_span(ids.first().unwrap()); + let span = self.def_span(ids.first().unwrap().def_id); self.in_translation.push(ids); self.crash_and_error( @@ -229,7 +243,8 @@ impl<'tcx> Why3Generator<'tcx> { // Indicate we have finished translating a given id pub(crate) fn finish(&mut self, def_id: DefId) { - if !self.in_translation.last_mut().unwrap().remove(&def_id) { + let tid = def_id.into(); + if !self.in_translation.last_mut().unwrap().remove(&tid) { self.crash_and_error( self.def_span(def_id), &format!("{:?} is not in translation", def_id), @@ -240,10 +255,11 @@ impl<'tcx> Why3Generator<'tcx> { self.in_translation.pop(); } - self.translated_items.insert(def_id); + self.translated_items.insert(tid); } - pub(crate) fn dependencies(&self, def_id: DefId) -> Option<&CloneSummary<'tcx>> { - self.dependencies.get(&def_id) + pub(crate) fn dependencies(&self, key: dependency::Key<'tcx>) -> Option<&CloneSummary<'tcx>> { + let tid = TransId { def_id: key.did }; + self.dependencies.get(&tid) } } diff --git a/creusot/src/backend/clone_map.rs b/creusot/src/backend/clone_map.rs index 21c065a8f..9723c0cfa 100644 --- a/creusot/src/backend/clone_map.rs +++ b/creusot/src/backend/clone_map.rs @@ -405,7 +405,7 @@ impl<'tcx> CloneMap<'tcx> { "{:?} {:?} has {:?} dependencies", self.names[&key].kind, key, - ctx.dependencies(key.did).map(|d| d.len()) + ctx.dependencies(key).map(|d| d.len()) ); self.clone_laws(ctx, key); self.clone_dependencies(ctx, key); @@ -453,7 +453,7 @@ impl<'tcx> CloneMap<'tcx> { let opaque_clone = !matches!(self.clone_level, CloneLevel::Body) || self.names[&key].opaque == CloneOpacity::Opaque; - for (dep, info) in ctx.dependencies(key.did).iter().flat_map(|i| i.iter()) { + for (dep, info) in ctx.dependencies(key).iter().flat_map(|i| i.iter()) { if opaque_clone && !info.public { continue; } From 3cddd6027c52d5c3a78ef6910fc0356b85ff9c42 Mon Sep 17 00:00:00 2001 From: Dominik Stolz Date: Tue, 6 Jun 2023 16:32:49 +0200 Subject: [PATCH 02/12] Generate structural invariants --- creusot-contracts/src/invariant.rs | 7 ++ creusot/src/backend.rs | 18 ++++- creusot/src/backend/clone_map.rs | 72 ++++++++++++----- creusot/src/backend/dependency.rs | 30 +++++-- creusot/src/backend/ty.rs | 23 +++--- creusot/src/backend/ty_inv.rs | 121 +++++++++++++++++++++++++++++ creusot/src/translated_item.rs | 5 ++ creusot/src/util.rs | 4 + 8 files changed, 236 insertions(+), 44 deletions(-) create mode 100644 creusot/src/backend/ty_inv.rs diff --git a/creusot-contracts/src/invariant.rs b/creusot-contracts/src/invariant.rs index 80ba1537e..cabca3b45 100644 --- a/creusot-contracts/src/invariant.rs +++ b/creusot-contracts/src/invariant.rs @@ -21,6 +21,13 @@ pub trait Invariant { } } +#[predicate] +#[open(self)] +#[rustc_diagnostic_item = "creusot_invariant_internal"] +pub fn inv(_x: T) -> bool { + true +} + impl<'a, T: Invariant + ?Sized> Invariant for &'a T { #[predicate] #[open] diff --git a/creusot/src/backend.rs b/creusot/src/backend.rs index b7d370cc4..17696304b 100644 --- a/creusot/src/backend.rs +++ b/creusot/src/backend.rs @@ -21,15 +21,17 @@ pub(crate) mod signature; pub(crate) mod term; pub(crate) mod traits; pub(crate) mod ty; +pub(crate) mod ty_inv; #[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Debug)] struct TransId { def_id: DefId, + inv: bool, } impl From for TransId { fn from(def_id: DefId) -> Self { - TransId { def_id } + TransId { def_id, inv: false } } } @@ -206,6 +208,18 @@ impl<'tcx> Why3Generator<'tcx> { // self.types[&repr_id].accessors; } + pub(crate) fn translate_tyinv(&mut self, adt_did: DefId) { + let tid = TransId { def_id: adt_did, inv: true }; + if self.dependencies.contains_key(&tid) { + return; + } + + self.translate(adt_did); + let (modl, deps) = ty_inv::build_inv_module(self, adt_did); + self.dependencies.insert(tid, deps); + self.functions.insert(tid, TranslatedItem::TyInv { modl }); + } + pub(crate) fn item(&self, def_id: DefId) -> Option<&TranslatedItem> { let tid: TransId = if matches!(util::item_type(***self, def_id), ItemType::Type) { self.representative_type(def_id) @@ -259,7 +273,7 @@ impl<'tcx> Why3Generator<'tcx> { } pub(crate) fn dependencies(&self, key: dependency::Key<'tcx>) -> Option<&CloneSummary<'tcx>> { - let tid = TransId { def_id: key.did }; + let tid = TransId { def_id: key.did, inv: key.inv }; self.dependencies.get(&tid) } } diff --git a/creusot/src/backend/clone_map.rs b/creusot/src/backend/clone_map.rs index 9723c0cfa..50a82e2ac 100644 --- a/creusot/src/backend/clone_map.rs +++ b/creusot/src/backend/clone_map.rs @@ -30,7 +30,7 @@ use crate::{ }, ctx::*, translation::traits, - util::{self, get_builtin, ident_of, ident_of_ty, item_name, module_name}, + util::{self, get_builtin, ident_of, ident_of_ty, inv_module_name, item_name, module_name}, }; // Prelude modules @@ -112,6 +112,7 @@ pub struct CloneMap<'tcx> { // DefId of the item which is cloning. Used for trait resolution self_id: DefId, + pub(crate) self_inv: bool, // TODO: Push the graph into an opaque type with tight api boundary // Graph which is used to calculate the full clone set clone_graph: DiGraphMap, IndexSet<(Kind, SymbolKind)>>, @@ -211,10 +212,20 @@ impl<'tcx> CloneInfo { impl<'tcx> CloneMap<'tcx> { pub(crate) fn new(tcx: TyCtxt<'tcx>, self_id: DefId, clone_level: CloneLevel) -> Self { + Self::new_inv(tcx, self_id, clone_level, false) + } + + pub(crate) fn new_inv( + tcx: TyCtxt<'tcx>, + self_id: DefId, + clone_level: CloneLevel, + inv: bool, + ) -> Self { let names = IndexMap::new(); let mut c = CloneMap { tcx, self_id, + self_inv: inv, names, name_counts: Default::default(), prelude: IndexMap::new(), @@ -275,7 +286,9 @@ impl<'tcx> CloneMap<'tcx> { let count: usize = *self.name_counts.entry(base).and_modify(|c| *c += 1).or_insert(0); trace!("inserting {:?} as {}{}", key, base, count); - let name = if util::item_type(self.tcx, key.did) == ItemType::Type { + let name = if key.inv { + Symbol::intern(&*inv_module_name(self.tcx, key.did)) + } else if util::item_type(self.tcx, key.did) == ItemType::Type { Symbol::intern(&*module_name(self.tcx, key.did)) } else { Symbol::intern(&format!("{}{}", base, count)) @@ -341,6 +354,13 @@ impl<'tcx> CloneMap<'tcx> { clone.qname_ident(name.into()) } + pub(crate) fn ty_inv(&mut self, ty: Ty<'tcx>) -> QName { + let def_id = + self.tcx.get_diagnostic_item(Symbol::intern("creusot_invariant_internal")).unwrap(); + let subst = self.tcx.mk_substs(&[ty::GenericArg::from(ty)]); + self.value(def_id, subst) + } + fn self_key(&self) -> Key<'tcx> { let subst = match self.tcx.def_kind(self.self_id) { DefKind::Closure => match self.tcx.type_of(self.self_id).subst_identity().kind() { @@ -351,7 +371,7 @@ impl<'tcx> CloneMap<'tcx> { }; let subst = self.tcx.erase_regions(subst); - (self.self_id, subst).into() + Key::new(self.self_id, subst, self.self_inv) } pub(crate) fn import_prelude_module(&mut self, module: PreludeModule) { @@ -378,7 +398,7 @@ impl<'tcx> CloneMap<'tcx> { let key = *self.names.get_index(i).unwrap().0; i += 1; - trace!("{:?} is public={:?}", key, self.names[&key].public); + trace!("update graph with {:?} (public={:?})", key, self.names[&key].public); if key != self.self_key() { self.add_graph_edge( @@ -401,12 +421,15 @@ impl<'tcx> CloneMap<'tcx> { ctx.translate(key.did); - trace!( - "{:?} {:?} has {:?} dependencies", - self.names[&key].kind, - key, - ctx.dependencies(key).map(|d| d.len()) - ); + if key.did == self.tcx.get_diagnostic_item(Symbol::intern("creusot_invariant_internal")).unwrap() + && let TyKind::Adt(adt_def, adt_subst) = key.subst.type_at(0).kind() + && !adt_def.is_box() + && adt_def.did() != self.self_id { + trace!("resolve tyinv {key:?} as {adt_def:?} {adt_subst:?}"); + ctx.translate_tyinv(adt_def.did()); + self.insert(Key::new(adt_def.did(), *adt_subst, true)); + } + self.clone_laws(ctx, key); self.clone_dependencies(ctx, key); } @@ -453,8 +476,14 @@ impl<'tcx> CloneMap<'tcx> { let opaque_clone = !matches!(self.clone_level, CloneLevel::Body) || self.names[&key].opaque == CloneOpacity::Opaque; + trace!( + "cloning dependencies of {:?} {:?}, len={:?}, opaque={opaque_clone}", + self.names[&key].kind, + key, + ctx.dependencies(key).map(|d| d.len()) + ); for (dep, info) in ctx.dependencies(key).iter().flat_map(|i| i.iter()) { - if opaque_clone && !info.public { + if opaque_clone && !info.public && !key.inv { continue; } @@ -491,7 +520,7 @@ impl<'tcx> CloneMap<'tcx> { if let Some(d1) = user.cloneable_id() { Some(&self.names[&d1].kind) } else { None }; let k2 = if let Some(d2) = prov.cloneable_id() { Some(&self.names[&d2].kind) } else { None }; - trace!("{k1:?} = {:?} --> {k2:?} = {:?}", user, prov); + trace!("edge {k1:?} = {:?} --> {k2:?} = {:?}", user, prov); if let None = self.clone_graph.edge_weight_mut(user, prov) { self.clone_graph.add_edge(user, prov, IndexSet::new()); @@ -542,17 +571,17 @@ impl<'tcx> CloneMap<'tcx> { } fn build_clone(&mut self, ctx: &mut Why3Generator<'tcx>, item: DepNode<'tcx>) -> Option { - let node @ Key { did: def_id, subst } = item.cloneable_id()?; + let node @ Key { did: def_id, subst, inv } = item.cloneable_id()?; // Types can't be cloned, but are used (for now). - if util::item_type(ctx.tcx, def_id) == ItemType::Type { + if util::item_type(ctx.tcx, def_id) == ItemType::Type && !inv { if self.used_types.insert(def_id) { let name = if let Some(builtin) = get_builtin(ctx.tcx, def_id) { let name = QName::from_string(&builtin.as_str()).unwrap().module_qname(); Decl::UseDecl(Use { name: name.clone(), as_: None, export: false }) } else { - let name = cloneable_name(ctx, def_id, CloneLevel::Body); + let name = cloneable_name(ctx, def_id, CloneLevel::Body, false); Decl::UseDecl(Use { name: name.clone(), as_: Some(name), export: false }) }; return Some(name); @@ -578,7 +607,7 @@ impl<'tcx> CloneMap<'tcx> { clone_subst.push(CloneSubst::Type(ty_name, ty)) } } - DepNode::Item(dep) => { + DepNode::Item(dep) | DepNode::TyInv(dep) => { for (nm, sym) in syms { let elem = sym.to_subst(*nm, self.names[&dep].kind); clone_subst.push(elem); @@ -587,7 +616,7 @@ impl<'tcx> CloneMap<'tcx> { } } - let use_axioms = ctx.item(def_id).map(|i| i.has_axioms()).unwrap_or(false); + let use_axioms = inv || ctx.item(def_id).map(|i| i.has_axioms()).unwrap_or(false); if use_axioms { clone_subst.push(CloneSubst::Axiom(None)) } @@ -599,12 +628,12 @@ impl<'tcx> CloneMap<'tcx> { trace!( "emit clone node={node:?} name={:?} as={:?}", - cloneable_name(ctx, def_id, interface), + cloneable_name(ctx, def_id, interface, inv), self.names[&node].kind.clone() ); Some(Decl::Clone(DeclClone { - name: cloneable_name(ctx, def_id, interface), + name: cloneable_name(ctx, def_id, interface, inv), subst: clone_subst, kind: self.names[&node].kind.clone().into(), })) @@ -638,7 +667,7 @@ impl<'tcx> CloneMap<'tcx> { DfsPostOrder::new(&self.clone_graph, DepNode::new(self.tcx, self.self_key())); while let Some(node) = topo.walk_next(&self.clone_graph) { let Some(item) = node.cloneable_id() else { continue }; - trace!("processing node {:?}", self.names[&item].kind); + trace!("processing node {:?} (inv={})", self.names[&item].kind, item.inv,); if std::mem::replace(&mut self.names[&item].cloned, true) { continue; @@ -752,7 +781,7 @@ pub enum CloneLevel { Body, } -fn cloneable_name(ctx: &TranslationCtx, def_id: DefId, interface: CloneLevel) -> QName { +fn cloneable_name(ctx: &TranslationCtx, def_id: DefId, interface: CloneLevel, inv: bool) -> QName { use util::ItemType::*; // TODO: Refactor. @@ -777,6 +806,7 @@ fn cloneable_name(ctx: &TranslationCtx, def_id: DefId, interface: CloneLevel) -> Program | Closure => { QName { module: Vec::new(), name: interface::interface_name(ctx, def_id) } } + Type if inv => inv_module_name(ctx.tcx, def_id).into(), Trait | Type | AssocTy => module_name(ctx.tcx, def_id).into(), Unsupported(_) => unreachable!(), } diff --git a/creusot/src/backend/dependency.rs b/creusot/src/backend/dependency.rs index a861b7d7d..46fd27abb 100644 --- a/creusot/src/backend/dependency.rs +++ b/creusot/src/backend/dependency.rs @@ -15,20 +15,31 @@ use crate::{ /// These should be used both to power the cloning system and to order the overall translation of items in Creusot. /// -#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash, PartialOrd, Ord)] +#[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)] pub struct Key<'tcx> { pub(crate) did: DefId, pub(crate) subst: SubstsRef<'tcx>, + pub(crate) inv: bool, +} + +impl<'tcx> std::fmt::Debug for Key<'tcx> { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{:}{:?}{:?}", if self.inv { "Inv:" } else { "" }, &self.did, &self.subst) + } } impl<'tcx> From<(DefId, SubstsRef<'tcx>)> for Key<'tcx> { #[inline] fn from(value: (DefId, SubstsRef<'tcx>)) -> Self { - Key { did: value.0, subst: value.1 } + Key { did: value.0, subst: value.1, inv: false } } } impl<'tcx> Key<'tcx> { + pub(crate) fn new(did: DefId, subst: SubstsRef<'tcx>, inv: bool) -> Self { + Key { did, subst, inv } + } + #[inline] pub(crate) fn erase_regions(mut self, tcx: TyCtxt<'tcx>) -> Self { self.subst = tcx.erase_regions(self.subst); @@ -43,7 +54,8 @@ impl<'tcx> Key<'tcx> { #[inline] pub(crate) fn closure_hack(self, tcx: TyCtxt<'tcx>) -> Self { - closure_hack(tcx, self.did, self.subst).into() + let (did, subst) = closure_hack(tcx, self.did, self.subst); + Key { did, subst, ..self } } } @@ -51,11 +63,13 @@ impl<'tcx> Key<'tcx> { pub(crate) enum Dependency<'tcx> { Type(Ty<'tcx>), Item(Key<'tcx>), + TyInv(Key<'tcx>), } impl<'tcx> Dependency<'tcx> { pub(crate) fn new(tcx: TyCtxt<'tcx>, dep: Key<'tcx>) -> Self { match util::item_type(tcx, dep.did) { + ItemType::Type if dep.inv => Dependency::TyInv(dep), ItemType::Type => Dependency::Type(tcx.mk_adt(tcx.adt_def(dep.did), dep.subst)), // ItemType::Closure => Dependency::Type(tcx.type_of(dep.0).subst(tcx, dep.1)), ItemType::AssocTy => Dependency::Type(tcx.mk_projection(dep.did, dep.subst)), @@ -79,9 +93,10 @@ impl<'tcx> Dependency<'tcx> { ) -> Option { match self { Dependency::Type(ty) => resolve_type(ty, ctx.tcx, param_env), - Dependency::Item(Key { did: item, subst: substs }) => { + Dependency::Item(Key { did: item, subst: substs, .. }) => { resolve_item(item, substs, ctx.tcx, param_env) } + dep @ Dependency::TyInv(_) => Some(dep), } } @@ -89,13 +104,14 @@ impl<'tcx> Dependency<'tcx> { match self { Dependency::Item(i) => Some(i), Dependency::Type(t) => match t.kind() { - TyKind::Adt(def, substs) => Some(Key { did: def.did(), subst: substs }), - TyKind::Closure(id, substs) => Some(Key { did: *id, subst: substs }), + TyKind::Adt(def, substs) => Some(Key { did: def.did(), subst: substs, inv: false }), + TyKind::Closure(id, substs) => Some(Key { did: *id, subst: substs, inv: false }), TyKind::Alias(AliasKind::Projection, aty) => { - Some(Key { did: aty.def_id, subst: aty.substs }) + Some(Key { did: aty.def_id, subst: aty.substs, inv: false }) } _ => None, }, + Dependency::TyInv(i) => Some(i), } } } diff --git a/creusot/src/backend/ty.rs b/creusot/src/backend/ty.rs index dbe4afb6b..8e94b362b 100644 --- a/creusot/src/backend/ty.rs +++ b/creusot/src/backend/ty.rs @@ -333,23 +333,18 @@ pub(crate) fn translate_tydecl( } } - let mut tys = Vec::new(); - for did in bg.iter() { - tys.push(build_ty_decl(ctx, &mut names, *did)); - } + let ty_decl = + TyDecl::Adt { tys: bg.iter().map(|did| build_ty_decl(ctx, &mut names, *did)).collect() }; let (mut decls, _) = names.to_clones(ctx); - decls.push(Decl::TyDecl(TyDecl::Adt { tys: tys.clone() })); + decls.push(Decl::TyDecl(ty_decl)); + let mut modls = vec![Module { name: name.clone(), decls }]; - for did in bg { - if *did == repr { - continue; - }; - modls.push(Module { - name: module_name(ctx.tcx, *did), - decls: vec![Decl::UseDecl(Use { name: name.clone().into(), as_: None, export: true })], - }); - } + + modls.extend(bg.iter().filter(|did| **did != repr).map(|did| Module { + name: module_name(ctx.tcx, *did), + decls: vec![Decl::UseDecl(Use { name: name.clone().into(), as_: None, export: true })], + })); Some(modls) } diff --git a/creusot/src/backend/ty_inv.rs b/creusot/src/backend/ty_inv.rs new file mode 100644 index 000000000..074c3a1f2 --- /dev/null +++ b/creusot/src/backend/ty_inv.rs @@ -0,0 +1,121 @@ +use super::{ty::translate_ty, CloneMap, CloneSummary, Why3Generator}; +use crate::{ctx::*, translation::function, util}; +use rustc_hir::{def::Namespace, def_id::DefId}; +use rustc_middle::ty::{self, subst::SubstsRef, Ty, TyKind}; +use rustc_span::DUMMY_SP; +use why3::{ + declaration::{Axiom, Decl, Module}, + exp::{Exp, Pattern}, + Ident, +}; + +pub(crate) fn build_inv_module<'tcx>( + ctx: &mut Why3Generator<'tcx>, + did: DefId, +) -> (Module, CloneSummary<'tcx>) { + let mut names = CloneMap::new_inv(ctx.tcx, did, CloneLevel::Stub, true); + + let ty_name = util::item_name(ctx.tcx, did, Namespace::TypeNS); + let axiom_name = Ident::from(format!("inv_{}", &*ty_name)); + let inv_axiom = build_inv_axiom(ctx, &mut names, did, axiom_name); + + let (clones, summary) = names.to_clones(ctx); + + let mut decls = function::own_generic_decls_for(ctx.tcx, did).collect::>(); + decls.extend(clones); + decls.push(Decl::Axiom(inv_axiom)); + + (Module { name: util::inv_module_name(ctx.tcx, did), decls }, summary) +} + +fn build_inv_axiom<'tcx>( + ctx: &mut Why3Generator<'tcx>, + names: &mut CloneMap<'tcx>, + did: DefId, + name: Ident, +) -> Axiom { + let ty = ctx.type_of(did).subst_identity(); + let lhs: Exp = Exp::impure_qvar(names.ty_inv(ty)).app_to(Exp::pure_var("self".into())); + let rhs = build_inv_exp(ctx, names, "self".into(), ty, true).unwrap_or_else(|| Exp::mk_true()); + + let axiom = Exp::Forall( + vec![("self".into(), translate_ty(ctx, names, DUMMY_SP, ty))], + Box::new(lhs.eq(rhs)), + ); + Axiom { name, axiom } +} + +fn build_inv_exp<'tcx>( + ctx: &mut Why3Generator<'tcx>, + names: &mut CloneMap<'tcx>, + ident: Ident, + ty: Ty<'tcx>, + destruct_adt: bool, +) -> Option { + match ty.kind() { + TyKind::Tuple(tys) => { + let fields: Vec = + tys.iter().enumerate().map(|(i, _)| format!("a_{i}").into()).collect(); + + let body = tys + .iter() + .enumerate() + .flat_map(|(i, t)| build_inv_exp(ctx, names, fields[i].clone(), t, destruct_adt)) + .reduce(|e1, e2| e1.log_and(e2))?; + + let pattern = Pattern::TupleP(fields.into_iter().map(Pattern::VarP).collect()); + Some(Exp::Let { pattern, arg: Box::new(Exp::pure_var(ident)), body: Box::new(body) }) + } + TyKind::Adt(adt_def, adt_subst) if adt_def.is_box() => { + build_inv_exp(ctx, names, ident, adt_subst[0].expect_ty(), destruct_adt) + } + TyKind::Adt(adt_def, subst) if destruct_adt => { + build_inv_exp_adt(ctx, names, ident, *adt_def, subst) + } + TyKind::Adt(_, _) | TyKind::Param(_) => { + let inv_fun = Exp::impure_qvar(names.ty_inv(ty)); + Some(inv_fun.app_to(Exp::pure_var(ident))) + } + _ => None, // TODO add more cases + } +} + +fn build_inv_exp_adt<'tcx>( + ctx: &mut Why3Generator<'tcx>, + names: &mut CloneMap<'tcx>, + ident: Ident, + adt_def: ty::AdtDef, + subst: SubstsRef<'tcx>, +) -> Option { + let mut branches = vec![]; + let mut trivial = true; + + for var_def in adt_def.variants().iter() { + let tuple_var = var_def.ctor.is_some(); + + let mut pats = vec![]; + let mut exp = Exp::mk_true(); + for (field_idx, field_def) in var_def.fields.iter().enumerate() { + let field_name: Ident = if tuple_var { + format!("a_{field_idx}").into() + } else { + field_def.name.as_str().into() + }; + + let field_ty = field_def.ty(ctx.tcx, subst); + if let Some(field_inv) = build_inv_exp(ctx, names, field_name.clone(), field_ty, false) + { + pats.push(Pattern::VarP(field_name)); + exp = exp.log_and(field_inv); + trivial = false; + } else { + pats.push(Pattern::Wildcard); + } + } + + let var_name = names.constructor(var_def.def_id, subst); + branches.push((Pattern::ConsP(var_name, pats), exp)); + } + + (!trivial).then(|| Exp::Match(Box::new(Exp::pure_var(ident)), branches)) +} diff --git a/creusot/src/translated_item.rs b/creusot/src/translated_item.rs index ced63ab6f..270829532 100644 --- a/creusot/src/translated_item.rs +++ b/creusot/src/translated_item.rs @@ -39,6 +39,9 @@ pub enum TranslatedItem { modl: Vec, accessors: IndexMap>, }, + TyInv { + modl: Module, + }, } impl<'a> TranslatedItem { @@ -75,6 +78,7 @@ impl<'a> TranslatedItem { Box::new(modl.into_iter()) } Closure { interface, modl } => Box::new(interface.into_iter().chain(modl.into_iter())), + TyInv { modl } => Box::new(iter::once(modl)), } } @@ -94,6 +98,7 @@ impl<'a> TranslatedItem { } TranslatedItem::Type { .. } => self.modules(), TranslatedItem::Closure { interface, modl: _ } => Box::new(interface.into_iter()), + TranslatedItem::TyInv { modl } => Box::new(std::iter::once(modl)), } } } diff --git a/creusot/src/util.rs b/creusot/src/util.rs index 5de299a53..e91a6ec7d 100644 --- a/creusot/src/util.rs +++ b/creusot/src/util.rs @@ -218,6 +218,10 @@ pub(crate) fn ident_of_ty(sym: Symbol) -> Ident { Ident::build(&id) } +pub(crate) fn inv_module_name(tcx: TyCtxt, def_id: DefId) -> Ident { + format!("{}_Inv", &*ident_path(tcx, def_id)).into() +} + pub(crate) fn module_name(tcx: TyCtxt, def_id: DefId) -> Ident { let kind = tcx.def_kind(def_id); use rustc_hir::def::DefKind::*; From 58f4dc3b1b59f37b56cfb9b26f5ac980733599e8 Mon Sep 17 00:00:00 2001 From: Dominik Stolz Date: Tue, 6 Jun 2023 17:00:53 +0200 Subject: [PATCH 03/12] Add test --- .../type_invariants/generated.mlcfg | 153 ++++++++++++++++++ .../type_invariants/generated.rs | 8 + 2 files changed, 161 insertions(+) create mode 100644 creusot/tests/should_succeed/type_invariants/generated.mlcfg create mode 100644 creusot/tests/should_succeed/type_invariants/generated.rs diff --git a/creusot/tests/should_succeed/type_invariants/generated.mlcfg b/creusot/tests/should_succeed/type_invariants/generated.mlcfg new file mode 100644 index 000000000..82534f05a --- /dev/null +++ b/creusot/tests/should_succeed/type_invariants/generated.mlcfg @@ -0,0 +1,153 @@ + +module Core_Option_Option_Type + type t_option 't = + | C_None + | C_Some 't + +end +module Core_Ptr_NonNull_NonNull_Type + use prelude.Opaque + type t_nonnull 't = + | C_NonNull opaque_ptr + +end +module Core_Marker_PhantomData_Type + type t_phantomdata 't = + | C_PhantomData + +end +module Core_Ptr_Unique_Unique_Type + use Core_Marker_PhantomData_Type as Core_Marker_PhantomData_Type + use Core_Ptr_NonNull_NonNull_Type as Core_Ptr_NonNull_NonNull_Type + type t_unique 't = + | C_Unique (Core_Ptr_NonNull_NonNull_Type.t_nonnull 't) (Core_Marker_PhantomData_Type.t_phantomdata 't) + +end +module Alloc_Boxed_Box_Type + use Core_Ptr_Unique_Unique_Type as Core_Ptr_Unique_Unique_Type + type t_box 't 'a = + | C_Box (Core_Ptr_Unique_Unique_Type.t_unique 't) 'a + +end +module Alloc_Alloc_Global_Type + type t_global = + | C_Global + +end +module Generated_List_Type + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type + use Core_Option_Option_Type as Core_Option_Option_Type + type t_list 't = + | C_List 't (Core_Option_Option_Type.t_option (t_list 't)) + +end +module CreusotContracts_Invariant_Inv_Stub + type t + predicate inv (_x : t) +end +module CreusotContracts_Invariant_Inv_Interface + type t + predicate inv (_x : t) + val inv (_x : t) : bool + ensures { result = inv _x } + +end +module CreusotContracts_Invariant_Inv + type t + predicate inv (_x : t) = + [#"../../../../../creusot-contracts/src/invariant.rs" 28 4 28 8] true + val inv (_x : t) : bool + ensures { result = inv _x } + +end +module Core_Option_Option_Type_Inv + type t + clone CreusotContracts_Invariant_Inv_Stub as Inv1 with + type t = t + use Core_Option_Option_Type as Core_Option_Option_Type + clone CreusotContracts_Invariant_Inv_Stub as Inv0 with + type t = Core_Option_Option_Type.t_option t + axiom inv_t_option : forall self : Core_Option_Option_Type.t_option t . Inv0.inv self = match (self) with + | Core_Option_Option_Type.C_None -> true + | Core_Option_Option_Type.C_Some a_0 -> Inv1.inv a_0 + end +end +module Generated_List_Type_Inv + type t + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Generated_List_Type as Generated_List_Type + use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type + clone CreusotContracts_Invariant_Inv_Stub as Inv3 with + type t = Generated_List_Type.t_list t + use Core_Option_Option_Type as Core_Option_Option_Type + clone CreusotContracts_Invariant_Inv_Stub as Inv2 with + type t = Core_Option_Option_Type.t_option (Generated_List_Type.t_list t) + clone Core_Option_Option_Type_Inv as Core_Option_Option_Type_Inv with + type t = Generated_List_Type.t_list t, + predicate Inv0.inv = Inv2.inv, + predicate Inv1.inv = Inv3.inv, + axiom . + clone CreusotContracts_Invariant_Inv_Stub as Inv1 with + type t = t + clone CreusotContracts_Invariant_Inv_Stub as Inv0 with + type t = Generated_List_Type.t_list t + axiom inv_t_list : forall self : Generated_List_Type.t_list t . Inv0.inv self = match (self) with + | Generated_List_Type.C_List a_0 a_1 -> Inv1.inv a_0 /\ Inv2.inv a_1 + end +end +module Generated_UseList_Interface + use prelude.Int + use prelude.UInt32 + use Generated_List_Type as Generated_List_Type + val use_list [#"../generated.rs" 6 0 6 29] (l : Generated_List_Type.t_list uint32) : () +end +module Generated_UseList + use prelude.Int + use prelude.UInt32 + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Generated_List_Type as Generated_List_Type + use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type + clone CreusotContracts_Invariant_Inv_Interface as Inv3 with + type t = Generated_List_Type.t_list uint32 + use Core_Option_Option_Type as Core_Option_Option_Type + clone CreusotContracts_Invariant_Inv_Interface as Inv2 with + type t = Core_Option_Option_Type.t_option (Generated_List_Type.t_list uint32) + clone Core_Option_Option_Type_Inv as Core_Option_Option_Type_Inv with + type t = Generated_List_Type.t_list uint32, + predicate Inv0.inv = Inv2.inv, + predicate Inv1.inv = Inv3.inv, + axiom . + clone CreusotContracts_Invariant_Inv_Interface as Inv1 with + type t = uint32 + clone CreusotContracts_Invariant_Inv_Interface as Inv0 with + type t = Generated_List_Type.t_list uint32 + clone Generated_List_Type_Inv as Generated_List_Type_Inv with + type t = uint32, + predicate Inv0.inv = Inv0.inv, + predicate Inv1.inv = Inv1.inv, + predicate Inv2.inv = Inv2.inv, + predicate Inv3.inv = Inv3.inv, + axiom . + let rec cfg use_list [#"../generated.rs" 6 0 6 29] [@cfg:stackify] [@cfg:subregion_analysis] (l : Generated_List_Type.t_list uint32) : () + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : (); + var l_1 : Generated_List_Type.t_list uint32; + { + l_1 <- l; + goto BB0 + } + BB0 { + assert { [@expl:assertion] [#"../generated.rs" 7 18 7 35] Inv0.inv l_1 }; + goto BB1 + } + BB1 { + _0 <- (); + goto BB2 + } + BB2 { + return _0 + } + +end diff --git a/creusot/tests/should_succeed/type_invariants/generated.rs b/creusot/tests/should_succeed/type_invariants/generated.rs new file mode 100644 index 000000000..03905794e --- /dev/null +++ b/creusot/tests/should_succeed/type_invariants/generated.rs @@ -0,0 +1,8 @@ +extern crate creusot_contracts; +use creusot_contracts::{*, invariant}; + +pub struct List(T, Option>>); + +pub fn use_list(l: List) { + proof_assert!(invariant::inv(l)) +} From 02dfd35c92c2d2a1ea1eb1df4ca91da143fec8d7 Mon Sep 17 00:00:00 2001 From: Dominik Stolz Date: Wed, 7 Jun 2023 14:42:34 +0200 Subject: [PATCH 04/12] Add user invariants --- creusot-contracts/src/invariant.rs | 24 ++++++ creusot/src/backend/ty_inv.rs | 83 +++++++++++++++++-- .../type_invariants/generated.mlcfg | 81 ++++++++++++++---- .../type_invariants/generated.rs | 2 +- 4 files changed, 165 insertions(+), 25 deletions(-) diff --git a/creusot-contracts/src/invariant.rs b/creusot-contracts/src/invariant.rs index cabca3b45..df6d8d14f 100644 --- a/creusot-contracts/src/invariant.rs +++ b/creusot-contracts/src/invariant.rs @@ -28,6 +28,30 @@ pub fn inv(_x: T) -> bool { true } +pub trait UserInv { + #[predicate] + #[rustc_diagnostic_item = "creusot_invariant_user"] + fn user_inv(self) -> bool; +} + +#[cfg(creusot)] +impl UserInv for T { + #[predicate] + #[open] + #[rustc_diagnostic_item = "creusot_invariant_user_default"] + default fn user_inv(self) -> bool { + true + } +} + +impl UserInv for i32 { + #[predicate] + #[open] + fn user_inv(self) -> bool { + pearlite! { self@ > 0 } + } +} + impl<'a, T: Invariant + ?Sized> Invariant for &'a T { #[predicate] #[open] diff --git a/creusot/src/backend/ty_inv.rs b/creusot/src/backend/ty_inv.rs index 074c3a1f2..69c42780b 100644 --- a/creusot/src/backend/ty_inv.rs +++ b/creusot/src/backend/ty_inv.rs @@ -1,8 +1,12 @@ use super::{ty::translate_ty, CloneMap, CloneSummary, Why3Generator}; -use crate::{ctx::*, translation::function, util}; +use crate::{ + ctx::*, + translation::{function, traits}, + util, +}; use rustc_hir::{def::Namespace, def_id::DefId}; -use rustc_middle::ty::{self, subst::SubstsRef, Ty, TyKind}; -use rustc_span::DUMMY_SP; +use rustc_middle::ty::{subst::SubstsRef, AdtDef, GenericArg, ParamEnv, Ty, TyKind}; +use rustc_span::{Symbol, DUMMY_SP}; use why3::{ declaration::{Axiom, Decl, Module}, exp::{Exp, Pattern}, @@ -35,8 +39,10 @@ fn build_inv_axiom<'tcx>( name: Ident, ) -> Axiom { let ty = ctx.type_of(did).subst_identity(); + let param_env = ctx.param_env(did); let lhs: Exp = Exp::impure_qvar(names.ty_inv(ty)).app_to(Exp::pure_var("self".into())); - let rhs = build_inv_exp(ctx, names, "self".into(), ty, true).unwrap_or_else(|| Exp::mk_true()); + let rhs = build_inv_exp(ctx, names, "self".into(), ty, param_env, true) + .unwrap_or_else(|| Exp::mk_true()); let axiom = Exp::Forall( vec![("self".into(), translate_ty(ctx, names, DUMMY_SP, ty))], @@ -50,6 +56,35 @@ fn build_inv_exp<'tcx>( names: &mut CloneMap<'tcx>, ident: Ident, ty: Ty<'tcx>, + param_env: ParamEnv<'tcx>, + destruct_adt: bool, +) -> Option { + let ty = ctx.normalize_erasing_regions(param_env, ty); + + let user_inv = if destruct_adt { + resolve_user_inv(ctx, ty, param_env).map(|(uinv_did, uinv_subst)| { + let inv_name = names.value(uinv_did, uinv_subst); + Exp::impure_qvar(inv_name).app(vec![Exp::pure_var(ident.clone())]) + }) + } else { + None + }; + + let struct_inv = build_inv_exp_struct(ctx, names, ident, ty, param_env, destruct_adt); + + match (user_inv, struct_inv) { + (None, None) => None, + (Some(inv), None) | (None, Some(inv)) => Some(inv), + (Some(user_inv), Some(struct_inv)) => Some(user_inv.log_and(struct_inv)), + } +} + +fn build_inv_exp_struct<'tcx>( + ctx: &mut Why3Generator<'tcx>, + names: &mut CloneMap<'tcx>, + ident: Ident, + ty: Ty<'tcx>, + param_env: ParamEnv<'tcx>, destruct_adt: bool, ) -> Option { match ty.kind() { @@ -60,17 +95,19 @@ fn build_inv_exp<'tcx>( let body = tys .iter() .enumerate() - .flat_map(|(i, t)| build_inv_exp(ctx, names, fields[i].clone(), t, destruct_adt)) + .flat_map(|(i, t)| { + build_inv_exp(ctx, names, fields[i].clone(), t, param_env, destruct_adt) + }) .reduce(|e1, e2| e1.log_and(e2))?; let pattern = Pattern::TupleP(fields.into_iter().map(Pattern::VarP).collect()); Some(Exp::Let { pattern, arg: Box::new(Exp::pure_var(ident)), body: Box::new(body) }) } TyKind::Adt(adt_def, adt_subst) if adt_def.is_box() => { - build_inv_exp(ctx, names, ident, adt_subst[0].expect_ty(), destruct_adt) + build_inv_exp(ctx, names, ident, adt_subst[0].expect_ty(), param_env, destruct_adt) } TyKind::Adt(adt_def, subst) if destruct_adt => { - build_inv_exp_adt(ctx, names, ident, *adt_def, subst) + build_inv_exp_adt(ctx, names, ident, param_env, *adt_def, subst) } TyKind::Adt(_, _) | TyKind::Param(_) => { let inv_fun = Exp::impure_qvar(names.ty_inv(ty)); @@ -84,7 +121,8 @@ fn build_inv_exp_adt<'tcx>( ctx: &mut Why3Generator<'tcx>, names: &mut CloneMap<'tcx>, ident: Ident, - adt_def: ty::AdtDef, + param_env: ParamEnv<'tcx>, + adt_def: AdtDef, subst: SubstsRef<'tcx>, ) -> Option { let mut branches = vec![]; @@ -103,7 +141,8 @@ fn build_inv_exp_adt<'tcx>( }; let field_ty = field_def.ty(ctx.tcx, subst); - if let Some(field_inv) = build_inv_exp(ctx, names, field_name.clone(), field_ty, false) + if let Some(field_inv) = + build_inv_exp(ctx, names, field_name.clone(), field_ty, param_env, false) { pats.push(Pattern::VarP(field_name)); exp = exp.log_and(field_inv); @@ -119,3 +158,29 @@ fn build_inv_exp_adt<'tcx>( (!trivial).then(|| Exp::Match(Box::new(Exp::pure_var(ident)), branches)) } + +fn resolve_user_inv<'tcx>( + ctx: &mut Why3Generator<'tcx>, + ty: Ty<'tcx>, + param_env: ParamEnv<'tcx>, +) -> Option<(DefId, SubstsRef<'tcx>)> { + let trait_did = ctx.get_diagnostic_item(Symbol::intern("creusot_invariant_user")).unwrap(); + let default_did = + ctx.get_diagnostic_item(Symbol::intern("creusot_invariant_user_default")).unwrap(); + + let (impl_did, subst) = traits::resolve_assoc_item_opt( + ctx.tcx, + param_env, + trait_did, + ctx.mk_substs(&[GenericArg::from(ty)]), + )?; + let subst = ctx.try_normalize_erasing_regions(param_env, subst).unwrap_or(subst); + + // if inv resolved to the default impl and is not specializable, ignore + if impl_did == default_did && !traits::still_specializable(ctx.tcx, param_env, impl_did, subst) + { + None + } else { + Some((impl_did, subst)) + } +} diff --git a/creusot/tests/should_succeed/type_invariants/generated.mlcfg b/creusot/tests/should_succeed/type_invariants/generated.mlcfg index 82534f05a..2b722b4eb 100644 --- a/creusot/tests/should_succeed/type_invariants/generated.mlcfg +++ b/creusot/tests/should_succeed/type_invariants/generated.mlcfg @@ -60,18 +60,38 @@ module CreusotContracts_Invariant_Inv val inv (_x : t) : bool ensures { result = inv _x } +end +module CreusotContracts_Invariant_UserInv_UserInv_Stub + type self + predicate user_inv (self : self) +end +module CreusotContracts_Invariant_UserInv_UserInv_Interface + type self + predicate user_inv (self : self) + val user_inv (self : self) : bool + ensures { result = user_inv self } + +end +module CreusotContracts_Invariant_UserInv_UserInv + type self + predicate user_inv (self : self) + val user_inv (self : self) : bool + ensures { result = user_inv self } + end module Core_Option_Option_Type_Inv type t clone CreusotContracts_Invariant_Inv_Stub as Inv1 with type t = t use Core_Option_Option_Type as Core_Option_Option_Type + clone CreusotContracts_Invariant_UserInv_UserInv_Stub as UserInv0 with + type self = Core_Option_Option_Type.t_option t clone CreusotContracts_Invariant_Inv_Stub as Inv0 with type t = Core_Option_Option_Type.t_option t - axiom inv_t_option : forall self : Core_Option_Option_Type.t_option t . Inv0.inv self = match (self) with + axiom inv_t_option : forall self : Core_Option_Option_Type.t_option t . Inv0.inv self = (UserInv0.user_inv self /\ match (self) with | Core_Option_Option_Type.C_None -> true | Core_Option_Option_Type.C_Some a_0 -> Inv1.inv a_0 - end + end) end module Generated_List_Type_Inv type t @@ -81,59 +101,90 @@ module Generated_List_Type_Inv clone CreusotContracts_Invariant_Inv_Stub as Inv3 with type t = Generated_List_Type.t_list t use Core_Option_Option_Type as Core_Option_Option_Type + clone CreusotContracts_Invariant_UserInv_UserInv_Stub as UserInv1 with + type self = Core_Option_Option_Type.t_option (Generated_List_Type.t_list t) clone CreusotContracts_Invariant_Inv_Stub as Inv2 with type t = Core_Option_Option_Type.t_option (Generated_List_Type.t_list t) clone Core_Option_Option_Type_Inv as Core_Option_Option_Type_Inv with type t = Generated_List_Type.t_list t, predicate Inv0.inv = Inv2.inv, + predicate UserInv0.user_inv = UserInv1.user_inv, predicate Inv1.inv = Inv3.inv, axiom . clone CreusotContracts_Invariant_Inv_Stub as Inv1 with type t = t + clone CreusotContracts_Invariant_UserInv_UserInv_Stub as UserInv0 with + type self = Generated_List_Type.t_list t clone CreusotContracts_Invariant_Inv_Stub as Inv0 with type t = Generated_List_Type.t_list t - axiom inv_t_list : forall self : Generated_List_Type.t_list t . Inv0.inv self = match (self) with + axiom inv_t_list : forall self : Generated_List_Type.t_list t . Inv0.inv self = (UserInv0.user_inv self /\ match (self) with | Generated_List_Type.C_List a_0 a_1 -> Inv1.inv a_0 /\ Inv2.inv a_1 - end + end) +end +module CreusotContracts_Invariant_Impl0_UserInv_Stub + type t + predicate user_inv (self : t) +end +module CreusotContracts_Invariant_Impl0_UserInv_Interface + type t + predicate user_inv (self : t) + val user_inv (self : t) : bool + ensures { result = user_inv self } + +end +module CreusotContracts_Invariant_Impl0_UserInv + type t + predicate user_inv (self : t) = + [#"../../../../../creusot-contracts/src/invariant.rs" 43 8 43 12] true + val user_inv (self : t) : bool + ensures { result = user_inv self } + end module Generated_UseList_Interface use prelude.Int - use prelude.UInt32 + use prelude.Int32 use Generated_List_Type as Generated_List_Type - val use_list [#"../generated.rs" 6 0 6 29] (l : Generated_List_Type.t_list uint32) : () + val use_list [#"../generated.rs" 6 0 6 29] (l : Generated_List_Type.t_list int32) : () end module Generated_UseList use prelude.Int - use prelude.UInt32 + use prelude.Int32 use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type use Generated_List_Type as Generated_List_Type use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type clone CreusotContracts_Invariant_Inv_Interface as Inv3 with - type t = Generated_List_Type.t_list uint32 + type t = Generated_List_Type.t_list int32 use Core_Option_Option_Type as Core_Option_Option_Type + clone CreusotContracts_Invariant_Impl0_UserInv as UserInv1 with + type t = Core_Option_Option_Type.t_option (Generated_List_Type.t_list int32) clone CreusotContracts_Invariant_Inv_Interface as Inv2 with - type t = Core_Option_Option_Type.t_option (Generated_List_Type.t_list uint32) + type t = Core_Option_Option_Type.t_option (Generated_List_Type.t_list int32) clone Core_Option_Option_Type_Inv as Core_Option_Option_Type_Inv with - type t = Generated_List_Type.t_list uint32, + type t = Generated_List_Type.t_list int32, predicate Inv0.inv = Inv2.inv, + predicate UserInv0.user_inv = UserInv1.user_inv, predicate Inv1.inv = Inv3.inv, axiom . clone CreusotContracts_Invariant_Inv_Interface as Inv1 with - type t = uint32 + type t = int32 + clone CreusotContracts_Invariant_Impl0_UserInv as UserInv0 with + type t = Generated_List_Type.t_list int32 clone CreusotContracts_Invariant_Inv_Interface as Inv0 with - type t = Generated_List_Type.t_list uint32 + type t = Generated_List_Type.t_list int32 clone Generated_List_Type_Inv as Generated_List_Type_Inv with - type t = uint32, + type t = int32, predicate Inv0.inv = Inv0.inv, + predicate UserInv0.user_inv = UserInv0.user_inv, predicate Inv1.inv = Inv1.inv, predicate Inv2.inv = Inv2.inv, + predicate UserInv1.user_inv = UserInv1.user_inv, predicate Inv3.inv = Inv3.inv, axiom . - let rec cfg use_list [#"../generated.rs" 6 0 6 29] [@cfg:stackify] [@cfg:subregion_analysis] (l : Generated_List_Type.t_list uint32) : () + let rec cfg use_list [#"../generated.rs" 6 0 6 29] [@cfg:stackify] [@cfg:subregion_analysis] (l : Generated_List_Type.t_list int32) : () = [@vc:do_not_keep_trace] [@vc:sp] var _0 : (); - var l_1 : Generated_List_Type.t_list uint32; + var l_1 : Generated_List_Type.t_list int32; { l_1 <- l; goto BB0 diff --git a/creusot/tests/should_succeed/type_invariants/generated.rs b/creusot/tests/should_succeed/type_invariants/generated.rs index 03905794e..3f6fc09ac 100644 --- a/creusot/tests/should_succeed/type_invariants/generated.rs +++ b/creusot/tests/should_succeed/type_invariants/generated.rs @@ -3,6 +3,6 @@ use creusot_contracts::{*, invariant}; pub struct List(T, Option>>); -pub fn use_list(l: List) { +pub fn use_list(l: List) { proof_assert!(invariant::inv(l)) } From 1c821e455aeda23781a103e9380bd323b2f63699 Mon Sep 17 00:00:00 2001 From: Dominik Stolz Date: Thu, 8 Jun 2023 17:26:44 +0200 Subject: [PATCH 05/12] Generate type invariant modules for non-ADT types --- creusot/src/backend.rs | 40 +- creusot/src/backend/clone_map.rs | 471 +++++++++--------- creusot/src/backend/dependency.rs | 132 +++-- creusot/src/backend/term.rs | 6 +- creusot/src/backend/ty.rs | 11 +- creusot/src/backend/ty_inv.rs | 110 +++- creusot/src/translation.rs | 4 +- creusot/src/util.rs | 13 +- .../type_invariants/generated.mlcfg | 85 +--- 9 files changed, 459 insertions(+), 413 deletions(-) diff --git a/creusot/src/backend.rs b/creusot/src/backend.rs index 17696304b..84bf7652c 100644 --- a/creusot/src/backend.rs +++ b/creusot/src/backend.rs @@ -1,5 +1,6 @@ use indexmap::{IndexMap, IndexSet}; use rustc_hir::{def::DefKind, def_id::DefId}; +use rustc_span::DUMMY_SP; use crate::{ ctx::{TranslatedItem, TranslationCtx}, @@ -9,6 +10,8 @@ use std::ops::{Deref, DerefMut}; pub(crate) use clone_map::*; +use self::{dependency::Dependency, ty_inv::TyInvKind}; + pub(crate) mod clone_map; pub(crate) mod constant; pub(crate) mod dependency; @@ -24,14 +27,14 @@ pub(crate) mod ty; pub(crate) mod ty_inv; #[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Debug)] -struct TransId { - def_id: DefId, - inv: bool, +pub(crate) enum TransId { + Item(DefId), + TyInv(TyInvKind), } impl From for TransId { fn from(def_id: DefId) -> Self { - TransId { def_id, inv: false } + TransId::Item(def_id) } } @@ -208,14 +211,17 @@ impl<'tcx> Why3Generator<'tcx> { // self.types[&repr_id].accessors; } - pub(crate) fn translate_tyinv(&mut self, adt_did: DefId) { - let tid = TransId { def_id: adt_did, inv: true }; + pub(crate) fn translate_tyinv(&mut self, inv_kind: TyInvKind) { + let tid = TransId::TyInv(inv_kind); if self.dependencies.contains_key(&tid) { return; } - self.translate(adt_did); - let (modl, deps) = ty_inv::build_inv_module(self, adt_did); + if let TyInvKind::Adt(adt_did) = inv_kind { + self.translate(adt_did); + } + + let (modl, deps) = ty_inv::build_inv_module(self, inv_kind); self.dependencies.insert(tid, deps); self.functions.insert(tid, TranslatedItem::TyInv { modl }); } @@ -230,15 +236,20 @@ impl<'tcx> Why3Generator<'tcx> { self.functions.get(&tid) } - pub(crate) fn modules(self) -> impl Iterator + 'tcx { - self.functions.into_iter().map(|(tid, item)| (tid.def_id, item)) + pub(crate) fn modules(self) -> impl Iterator + 'tcx { + self.functions.into_iter() } pub(crate) fn start_group(&mut self, ids: IndexSet) { assert!(!ids.is_empty()); let ids = ids.into_iter().map(Into::into).collect(); if self.in_translation.iter().rev().any(|s| !s.is_disjoint(&ids)) { - let span = self.def_span(ids.first().unwrap().def_id); + let span = if let TransId::Item(def_id) = ids.first().unwrap() { + self.def_span(def_id) + } else { + DUMMY_SP + }; + self.in_translation.push(ids); self.crash_and_error( @@ -272,8 +283,11 @@ impl<'tcx> Why3Generator<'tcx> { self.translated_items.insert(tid); } - pub(crate) fn dependencies(&self, key: dependency::Key<'tcx>) -> Option<&CloneSummary<'tcx>> { - let tid = TransId { def_id: key.did, inv: key.inv }; + pub(crate) fn dependencies(&self, key: Dependency<'tcx>) -> Option<&CloneSummary<'tcx>> { + let tid = match key { + Dependency::TyInv(ty) => TransId::TyInv(TyInvKind::from_ty(ty)), + _ => key.did().map(|(def_id, _)| TransId::Item(def_id))?, + }; self.dependencies.get(&tid) } } diff --git a/creusot/src/backend/clone_map.rs b/creusot/src/backend/clone_map.rs index 50a82e2ac..cc19da668 100644 --- a/creusot/src/backend/clone_map.rs +++ b/creusot/src/backend/clone_map.rs @@ -1,5 +1,7 @@ #![allow(deprecated)] +use std::iter; + use heck::ToUpperCamelCase; use indexmap::{IndexMap, IndexSet}; use petgraph::{graphmap::DiGraphMap, visit::DfsPostOrder, EdgeDirection::Outgoing}; @@ -9,9 +11,8 @@ use rustc_hir::{ }; use rustc_middle::ty::{ self, - subst::{GenericArgKind, InternalSubsts, SubstsRef}, - AliasKind, AliasTy, ParamEnv, Ty, TyCtxt, TyKind, TypeFoldable, TypeSuperVisitable, - TypeVisitor, + subst::{InternalSubsts, SubstsRef}, + AliasKind, ParamEnv, Ty, TyCtxt, TyKind, TypeFoldable, TypeSuperVisitable, TypeVisitor, }; use rustc_span::{Symbol, DUMMY_SP}; use rustc_target::abi::FieldIdx; @@ -22,12 +23,7 @@ use why3::{ }; use crate::{ - backend::{ - self, - dependency::{Dependency, Key}, - interface, - ty::translate_ty_param, - }, + backend::{self, dependency::Dependency, interface}, ctx::*, translation::traits, util::{self, get_builtin, ident_of, ident_of_ty, inv_module_name, item_name, module_name}, @@ -92,14 +88,16 @@ impl PreludeModule { } } -type CloneNode<'tcx> = Key<'tcx>; -pub(super) type CloneSummary<'tcx> = IndexMap, CloneInfo>; +// a clone node is expected to have a DefId +type CloneNode<'tcx> = Dependency<'tcx>; +type DepNode<'tcx> = Dependency<'tcx>; +pub(super) type CloneSummary<'tcx> = IndexMap, CloneInfo>; #[derive(Clone)] pub struct CloneMap<'tcx> { tcx: TyCtxt<'tcx>, prelude: IndexMap, - pub names: IndexMap, CloneInfo>, + names: IndexMap, CloneInfo>, // Track how many instances of a name already exist name_counts: IndexMap, @@ -111,8 +109,7 @@ pub struct CloneMap<'tcx> { clone_level: CloneLevel, // DefId of the item which is cloning. Used for trait resolution - self_id: DefId, - pub(crate) self_inv: bool, + self_id: CloneNode<'tcx>, // TODO should this be a TransId? // TODO: Push the graph into an opaque type with tight api boundary // Graph which is used to calculate the full clone set clone_graph: DiGraphMap, IndexSet<(Kind, SymbolKind)>>, @@ -139,8 +136,6 @@ impl<'tcx> Drop for CloneMap<'tcx> { } } -type DepNode<'tcx> = Dependency<'tcx>; - #[derive(Clone, Copy, Debug, PartialEq, Eq, TyEncodable, TyDecodable, Hash)] enum Kind { Named(Symbol), @@ -160,7 +155,11 @@ impl Kind { use rustc_macros::{TyDecodable, TyEncodable}; -use super::Why3Generator; +use super::{ + ty::ty_param_names, + ty_inv::{tyinv_substs, TyInvKind}, + TransId, Why3Generator, +}; #[derive(Clone, Copy, Debug, PartialEq, Eq, TyEncodable, TyDecodable)] enum CloneOpacity { @@ -212,20 +211,37 @@ impl<'tcx> CloneInfo { impl<'tcx> CloneMap<'tcx> { pub(crate) fn new(tcx: TyCtxt<'tcx>, self_id: DefId, clone_level: CloneLevel) -> Self { - Self::new_inv(tcx, self_id, clone_level, false) + Self::new_with_tid(tcx, TransId::Item(self_id), clone_level) } - pub(crate) fn new_inv( + pub(crate) fn new_with_tid( tcx: TyCtxt<'tcx>, - self_id: DefId, + self_id: TransId, clone_level: CloneLevel, - inv: bool, ) -> Self { - let names = IndexMap::new(); - let mut c = CloneMap { + let mut names = IndexMap::new(); + + let self_id = match self_id { + TransId::Item(self_id) => { + let subst = match tcx.def_kind(self_id) { + DefKind::Closure => match tcx.type_of(self_id).subst_identity().kind() { + TyKind::Closure(_, subst) => subst, + _ => unreachable!(), + }, + _ => InternalSubsts::identity_for_item(tcx, self_id), + }; + + CloneNode::new(tcx, (self_id, subst)).erase_regions(tcx) + } + TransId::TyInv(inv_kind) => CloneNode::TyInv(inv_kind.to_ty(tcx)), + }; + + debug!("cloning self: {:?}", self_id); + names.insert(self_id, CloneInfo::hidden()); + + CloneMap { tcx, self_id, - self_inv: inv, names, name_counts: Default::default(), prelude: IndexMap::new(), @@ -234,10 +250,7 @@ impl<'tcx> CloneMap<'tcx> { last_cloned: 0, public: false, used_types: Default::default(), - }; - debug!("cloning self: {:?}", c.self_key()); - c.names.insert(c.self_key(), CloneInfo::hidden()); - c + } } pub(crate) fn summary(&self) -> CloneSummary<'tcx> { @@ -262,36 +275,44 @@ impl<'tcx> CloneMap<'tcx> { /// Internal: only meant for mutually recursive type declaration pub(crate) fn insert_hidden(&mut self, def_id: DefId, subst: SubstsRef<'tcx>) { - let subst = self.tcx.erase_regions(subst); - self.names.insert((def_id, subst).into(), CloneInfo::hidden()); + let node = CloneNode::new(self.tcx, (def_id, subst)).erase_regions(self.tcx); + self.names.insert(node, CloneInfo::hidden()); } #[deprecated( note = "Avoid using this method in favor of one of the more semantic alternatives: `value`, `accessor`, `ty`" )] - pub(crate) fn insert(&mut self, key: Key<'tcx>) -> &mut CloneInfo { + pub(crate) fn insert(&mut self, key: CloneNode<'tcx>) -> &mut CloneInfo { let key = key.erase_regions(self.tcx).closure_hack(self.tcx); self.names.entry(key).or_insert_with(|| { - let base_sym = match util::item_type(self.tcx, key.did) { - ItemType::Impl => self.tcx.item_name(self.tcx.trait_id_of_impl(key.did).unwrap()), - ItemType::Closure => Symbol::intern(&format!( - "closure{}", - self.tcx.def_path(key.did).data.last().unwrap().disambiguator - )), - _ => self.tcx.item_name(key.did), - }; - - let base = Symbol::intern(&base_sym.as_str().to_upper_camel_case()); - let count: usize = *self.name_counts.entry(base).and_modify(|c| *c += 1).or_insert(0); - trace!("inserting {:?} as {}{}", key, base, count); + let name = match key { + CloneNode::Item(did, _) => { + let base_sym = match util::item_type(self.tcx, did) { + ItemType::Impl => { + self.tcx.item_name(self.tcx.trait_id_of_impl(did).unwrap()) + } + ItemType::Closure => Symbol::intern(&format!( + "closure{}", + self.tcx.def_path(did).data.last().unwrap().disambiguator + )), + _ => self.tcx.item_name(did), + }; - let name = if key.inv { - Symbol::intern(&*inv_module_name(self.tcx, key.did)) - } else if util::item_type(self.tcx, key.did) == ItemType::Type { - Symbol::intern(&*module_name(self.tcx, key.did)) - } else { - Symbol::intern(&format!("{}{}", base, count)) + let base = Symbol::intern(&base_sym.as_str().to_upper_camel_case()); + let count: usize = + *self.name_counts.entry(base).and_modify(|c| *c += 1).or_insert(0); + trace!("inserting {:?} as {}{}", key, base, count); + Symbol::intern(&format!("{}{}", base, count)) + } + CloneNode::Type(_) => { + let (did, _) = key.did().unwrap(); + Symbol::intern(&*module_name(self.tcx, did)) + } + CloneNode::TyInv(ty) => { + let inv_kind = TyInvKind::from_ty(ty); + Symbol::intern(&*inv_module_name(self.tcx, inv_kind)) + } }; let info = CloneInfo::from_name(name, self.public); @@ -301,12 +322,14 @@ impl<'tcx> CloneMap<'tcx> { pub(crate) fn value(&mut self, def_id: DefId, subst: SubstsRef<'tcx>) -> QName { let name = item_name(self.tcx, def_id, Namespace::ValueNS); - self.insert((def_id, subst).into()).qname_ident(name.into()) + let node = CloneNode::new(self.tcx, (def_id, subst)); + self.insert(node).qname_ident(name.into()) } pub(crate) fn ty(&mut self, def_id: DefId, subst: SubstsRef<'tcx>) -> QName { let name = item_name(self.tcx, def_id, Namespace::TypeNS); - self.insert((def_id, subst).into()).qname_ident(name.into()) + let node = CloneNode::new(self.tcx, (def_id, subst)); + self.insert(node).qname_ident(name.into()) } pub(crate) fn constructor(&mut self, def_id: DefId, subst: SubstsRef<'tcx>) -> QName { @@ -317,7 +340,8 @@ impl<'tcx> CloneMap<'tcx> { }; let mut name = item_name(self.tcx, def_id, Namespace::ValueNS); name.capitalize(); - self.insert((type_id, subst).into()).qname_ident(name.into()) + let node = CloneNode::new(self.tcx, (type_id, subst)); + self.insert(node).qname_ident(name.into()) } /// Creates a name for a type or closure projection ie: x.field1 @@ -335,7 +359,8 @@ impl<'tcx> CloneMap<'tcx> { ix: FieldIdx, ) -> QName { let tcx = self.tcx; - let clone = self.insert((def_id, subst).into()); + let node = CloneNode::new(self.tcx, (def_id, subst)); + let clone = self.insert(node); let name: Ident = match util::item_type(tcx, def_id) { ItemType::Closure => format!("field_{}", ix.as_usize()).into(), ItemType::Type => { @@ -361,17 +386,16 @@ impl<'tcx> CloneMap<'tcx> { self.value(def_id, subst) } - fn self_key(&self) -> Key<'tcx> { - let subst = match self.tcx.def_kind(self.self_id) { - DefKind::Closure => match self.tcx.type_of(self.self_id).subst_identity().kind() { - TyKind::Closure(_, subst) => subst, - _ => unreachable!(), - }, - _ => InternalSubsts::identity_for_item(self.tcx, self.self_id), - }; + fn self_did(&self) -> Option { + self.self_id.did().map(|(self_did, _)| self_did) + } - let subst = self.tcx.erase_regions(subst); - Key::new(self.self_id, subst, self.self_inv) + fn param_env(&self, ctx: &TranslationCtx<'tcx>) -> ParamEnv<'tcx> { + if let Some(did) = self.self_did() { + ctx.param_env(did) + } else { + ParamEnv::empty() + } } pub(crate) fn import_prelude_module(&mut self, module: PreludeModule) { @@ -393,85 +417,82 @@ impl<'tcx> CloneMap<'tcx> { // to build the correct substitution. // let mut i = self.last_cloned; - let param_env = ctx.param_env(self.self_id); + let param_env = self.param_env(ctx); while i < self.names.len() { let key = *self.names.get_index(i).unwrap().0; i += 1; trace!("update graph with {:?} (public={:?})", key, self.names[&key].public); - if key != self.self_key() { - self.add_graph_edge( - DepNode::new(self.tcx, self.self_key()), - DepNode::new(self.tcx, key), - ); + if key != self.self_id { + self.add_graph_edge(self.self_id, key); } if self.names[&key].kind == Kind::Hidden { continue; } - if traits::still_specializable(self.tcx, param_env, key.did, key.subst) { - self.names[&key].opaque(); - } + if let Some((did, subst)) = key.did() { + if traits::still_specializable(self.tcx, param_env, did, subst) { + self.names[&key].opaque(); + } - if !ctx.is_transparent_from(key.did, self.self_id) { - self.names[&key].opaque(); - } + if self.self_did().is_some_and(|self_did| !ctx.is_transparent_from(did, self_did)) { + self.names[&key].opaque(); + } + + ctx.translate(did); - ctx.translate(key.did); + if util::is_inv_internal(self.tcx, did) && self.clone_level == CloneLevel::Body { + self.clone_tyinv(ctx, subst.type_at(0)); + } - if key.did == self.tcx.get_diagnostic_item(Symbol::intern("creusot_invariant_internal")).unwrap() - && let TyKind::Adt(adt_def, adt_subst) = key.subst.type_at(0).kind() - && !adt_def.is_box() - && adt_def.did() != self.self_id { - trace!("resolve tyinv {key:?} as {adt_def:?} {adt_subst:?}"); - ctx.translate_tyinv(adt_def.did()); - self.insert(Key::new(adt_def.did(), *adt_subst, true)); + self.clone_laws(ctx, did, subst); } - self.clone_laws(ctx, key); self.clone_dependencies(ctx, key); } } - fn clone_dependencies(&mut self, ctx: &mut Why3Generator<'tcx>, key: Key<'tcx>) { - let key_dep = DepNode::new(ctx.tcx, key); - // Check the substitution for dependencies on closures - for ty in key.subst.types().flat_map(|t| t.walk()) { - let ty = match ty.unpack() { - GenericArgKind::Type(ty) => ty, - _ => continue, - }; + fn clone_tyinv(&mut self, ctx: &mut Why3Generator<'tcx>, ty: Ty<'tcx>) { + if ty.is_box() || matches!(ty.kind(), TyKind::Param(_)) { + return; + } - match ty.kind() { - TyKind::Closure(id, subst) => { - let key = (*id, *subst).into(); - self.insert(key); - // Sketchy... shouldn't we need to do something to subst? - // eprintln!("{:?}", DepNode::new(ctx.tcx, key)); - self.add_graph_edge(key_dep, DepNode::new(ctx.tcx, key)); - } - TyKind::Adt(def, subst) => { - let key = (def.did(), *subst).into(); - self.insert(key); - self.add_graph_edge(key_dep, DepNode::new(ctx.tcx, key)); - } - _ => {} - } + let inv_kind = TyInvKind::from_ty(ty); + if let CloneNode::TyInv(self_ty) = self.self_id && TyInvKind::from_ty(self_ty) == inv_kind { + return; } - let key_public = self.names[&key].public; + ctx.translate_tyinv(inv_kind); + self.insert(DepNode::TyInv(ty)); + } - walk_projections(key.subst, |pty: &AliasTy<'tcx>| { - let dep = self.resolve_dep(ctx, (pty.def_id, pty.substs).into()); + fn clone_dependencies(&mut self, ctx: &mut Why3Generator<'tcx>, key: DepNode<'tcx>) { + let key_public = self.names[&key].public; - if let Some(dep_key) = dep.cloneable_id() { - self.insert(dep_key).public |= key_public; - } + if let Some((_, key_subst)) = key.did() { + // Check the substitution for nodeendencies on closures + walk_types(key_subst, |t| { + let node = match t.kind() { + TyKind::Alias(AliasKind::Projection, pty) => { + let node = CloneNode::new(ctx.tcx, (pty.def_id, pty.substs)); + Some(self.resolve_dep(ctx, node)) + } + TyKind::Closure(id, subst) => { + // Sketchy... shouldn't we need to do something to subst? + Some(CloneNode::new(ctx.tcx, (*id, *subst))) + } + TyKind::Adt(_, _) => Some(CloneNode::Type(t)), + _ => None, + }; - self.add_graph_edge(key_dep, dep); - }); + if let Some(node) = node { + self.insert(node).public |= key_public; + self.add_graph_edge(key, node); + } + }); + } let opaque_clone = !matches!(self.clone_level, CloneLevel::Body) || self.names[&key].opaque == CloneOpacity::Opaque; @@ -483,7 +504,7 @@ impl<'tcx> CloneMap<'tcx> { ctx.dependencies(key).map(|d| d.len()) ); for (dep, info) in ctx.dependencies(key).iter().flat_map(|i| i.iter()) { - if opaque_clone && !info.public && !key.inv { + if opaque_clone && !info.public && !key.is_inv() { continue; } @@ -491,20 +512,18 @@ impl<'tcx> CloneMap<'tcx> { let orig = dep; - let dep = self.resolve_dep(ctx, dep.subst(self.tcx, key.subst)); + let dep = self.resolve_dep(ctx, dep.subst(self.tcx, key)); - if let Some(dep_key) = dep.cloneable_id() { - trace!("inserting dependency {:?} {:?}", key, dep); - self.insert(dep_key).public |= key_public && info.public; - } + trace!("inserting dependency {:?} {:?}", key, dep); + self.insert(dep).public |= key_public && info.public; // Skip reflexive edges - if dep == key_dep { + if dep == key { continue; } - let edge_set = self.add_graph_edge(key_dep, dep); - if let Some(sym) = refineable_symbol(ctx.tcx, orig.did) { + let edge_set = self.add_graph_edge(key, dep); + if let Some(sym) = refineable_symbol(ctx.tcx, *orig) { edge_set.insert((info.kind, sym)); } } @@ -516,10 +535,8 @@ impl<'tcx> CloneMap<'tcx> { user: DepNode<'tcx>, prov: DepNode<'tcx>, ) -> &mut IndexSet<(Kind, SymbolKind)> { - let k1 = - if let Some(d1) = user.cloneable_id() { Some(&self.names[&d1].kind) } else { None }; - let k2 = - if let Some(d2) = prov.cloneable_id() { Some(&self.names[&d2].kind) } else { None }; + let k1 = &self.names[&user].kind; + let k2 = &self.names[&prov].kind; trace!("edge {k1:?} = {:?} --> {k2:?} = {:?}", user, prov); if let None = self.clone_graph.edge_weight_mut(user, prov) { @@ -532,26 +549,29 @@ impl<'tcx> CloneMap<'tcx> { // Given an initial substitution, find out the substituted and resolved version of the dependency `dep`. // This will attempt to normalize traits and associated types if the substitution provides enough // information. - fn resolve_dep(&self, ctx: &TranslationCtx<'tcx>, dep: Key<'tcx>) -> DepNode<'tcx> { - let param_env = ctx.param_env(self.self_id); - - let dep = DepNode::new(self.tcx, dep); + fn resolve_dep(&self, ctx: &TranslationCtx<'tcx>, dep: DepNode<'tcx>) -> DepNode<'tcx> { + let param_env = self.param_env(ctx); dep.resolve(ctx, param_env).unwrap_or(dep) } - fn clone_laws(&mut self, ctx: &mut TranslationCtx<'tcx>, key: Key<'tcx>) { - let Some(item) = ctx.tcx.opt_associated_item(key.did) else { return }; + fn clone_laws( + &mut self, + ctx: &mut TranslationCtx<'tcx>, + key_did: DefId, + key_subst: SubstsRef<'tcx>, + ) { + let Some(item) = ctx.tcx.opt_associated_item(key_did) else { return }; + let Some(self_did) = self.self_did() else { return }; // Dont clone laws into the trait / impl which defines them. - if let Some(self_trait) = ctx.tcx.opt_associated_item(self.self_id) { - if self_trait.container_id(ctx.tcx) == item.container_id(ctx.tcx) { - return; - } + if let Some(self_item) = ctx.tcx.opt_associated_item(self_did) + && self_item.container_id(ctx.tcx) == item.container_id(ctx.tcx) { + return; } // If the function we are cloning into is `#[trusted]` there is no need for laws. // Similarily, if it has no body, there will be no proofs. - if util::is_trusted(ctx.tcx, self.self_id) || !util::has_body(ctx, self.self_id) { + if util::is_trusted(ctx.tcx, self_did) || !util::has_body(ctx, self_did) { return; } @@ -559,45 +579,40 @@ impl<'tcx> CloneMap<'tcx> { return; } - let laws = ctx.laws(item.container_id(ctx.tcx)); - - for law in laws { + let tcx = ctx.tcx; + for law in ctx.laws(item.container_id(tcx)) { trace!("adding law {:?} in {:?}", *law, self.self_id); // No way the substitution is correct... - let law = self.insert((*law, key.subst).into()); + let law = self.insert(DepNode::new(tcx, (*law, key_subst))); law.public = false; } } fn build_clone(&mut self, ctx: &mut Why3Generator<'tcx>, item: DepNode<'tcx>) -> Option { - let node @ Key { did: def_id, subst, inv } = item.cloneable_id()?; - // Types can't be cloned, but are used (for now). - if util::item_type(ctx.tcx, def_id) == ItemType::Type && !inv { - if self.used_types.insert(def_id) { - let name = if let Some(builtin) = get_builtin(ctx.tcx, def_id) { + if let DepNode::Type(_) = item { + let (def_id, _) = item.did()?; + return self.used_types.insert(def_id).then(|| { + if let Some(builtin) = get_builtin(ctx.tcx, def_id) { let name = QName::from_string(&builtin.as_str()).unwrap().module_qname(); - - Decl::UseDecl(Use { name: name.clone(), as_: None, export: false }) + Decl::UseDecl(Use { name: name, as_: None, export: false }) } else { - let name = cloneable_name(ctx, def_id, CloneLevel::Body, false); + let name = cloneable_name(ctx, item, CloneLevel::Body); Decl::UseDecl(Use { name: name.clone(), as_: Some(name), export: false }) - }; - return Some(name); - } - return None; + } + }); } - let mut clone_subst = base_subst(ctx, self, ctx.param_env(self.self_id), def_id, subst); + let mut clone_subst = base_subst(ctx, self, item); + trace!("base substs of {item:?}: {clone_subst:?}"); - let dep_node = DepNode::new(ctx.tcx, node); - let outbound: Vec<_> = self.clone_graph.neighbors_directed(dep_node, Outgoing).collect(); + let outbound: Vec<_> = self.clone_graph.neighbors_directed(item, Outgoing).collect(); // Grab definitions from all of our dependencies for dep in outbound { - let syms = &self.clone_graph[(dep_node, dep)]; - trace!("dependency={:?} of={:?} syms={:?}", dep, node, syms); + let syms = &self.clone_graph[(item, dep)]; + trace!("dependency={:?} of={:?} syms={:?}", dep, item, syms); match dep { DepNode::Type(ty) => { @@ -607,7 +622,7 @@ impl<'tcx> CloneMap<'tcx> { clone_subst.push(CloneSubst::Type(ty_name, ty)) } } - DepNode::Item(dep) | DepNode::TyInv(dep) => { + _ => { for (nm, sym) in syms { let elem = sym.to_subst(*nm, self.names[&dep].kind); clone_subst.push(elem); @@ -616,26 +631,30 @@ impl<'tcx> CloneMap<'tcx> { } } - let use_axioms = inv || ctx.item(def_id).map(|i| i.has_axioms()).unwrap_or(false); + let use_axioms = item.is_inv() + || item.did().is_some_and(|(def_id, _)| { + ctx.item(def_id).map(|i| i.has_axioms()).unwrap_or(false) + }); + if use_axioms { clone_subst.push(CloneSubst::Axiom(None)) } - let interface = match (self.clone_level, self.names[&node].opaque) { + let clone_level = match (self.clone_level, self.names[&item].opaque) { (CloneLevel::Body, CloneOpacity::Opaque) => CloneLevel::Interface, (x, _) => x, }; trace!( - "emit clone node={node:?} name={:?} as={:?}", - cloneable_name(ctx, def_id, interface, inv), - self.names[&node].kind.clone() + "emit clone node={item:?} name={:?} as={:?}", + cloneable_name(ctx, item, clone_level), + self.names[&item].kind.clone() ); Some(Decl::Clone(DeclClone { - name: cloneable_name(ctx, def_id, interface, inv), + name: cloneable_name(ctx, item, clone_level), subst: clone_subst, - kind: self.names[&node].kind.clone().into(), + kind: self.names[&item].kind.clone().into(), })) } @@ -663,17 +682,15 @@ impl<'tcx> CloneMap<'tcx> { // Broken because of closures which share a defid for the type *and* function // debug_assert!(!is_cyclic_directed(&self.clone_graph), "clone graph for {:?} is cyclic", self.self_id ); - let mut topo = - DfsPostOrder::new(&self.clone_graph, DepNode::new(self.tcx, self.self_key())); + let mut topo = DfsPostOrder::new(&self.clone_graph, self.self_id); while let Some(node) = topo.walk_next(&self.clone_graph) { - let Some(item) = node.cloneable_id() else { continue }; - trace!("processing node {:?} (inv={})", self.names[&item].kind, item.inv,); + trace!("processing node {:?}", self.names[&node].kind); - if std::mem::replace(&mut self.names[&item].cloned, true) { + if std::mem::replace(&mut self.names[&node].cloned, true) { continue; } - if self.names[&item].kind == Kind::Hidden { + if self.names[&node].kind == Kind::Hidden { continue; } @@ -702,8 +719,8 @@ impl<'tcx> CloneMap<'tcx> { fn to_dot(&self, ctx: &TranslationCtx<'tcx>) { use petgraph::dot::{Config, Dot}; use std::io::Write; - let mut f = std::fs::File::create(format!("graphs/{}.dot", ctx.def_path_str(self.self_id))) - .unwrap(); + let path = format!("graphs/{}.dot", ctx.def_path_str(self.self_did().unwrap())); + let mut f = std::fs::File::create(path).unwrap(); let g = self.clone_graph.clone(); // g.remove_node(DepNode::new(self.tcx, self.self_key())); @@ -716,14 +733,14 @@ impl<'tcx> CloneMap<'tcx> { &|_, _| { String::new() }, &|_, n| { let s = match n { - (Dependency::Type(ty), Dependency::Type(_)) => format!("{:?}", ty), - (Dependency::Item(k), Dependency::Item(_)) => { + (DepNode::Type(ty), DepNode::Type(_)) => format!("{:?}", ty), + (DepNode::Item(did, subst), DepNode::Item(_, _)) => { format!( "({}, {:?})", - ctx.opt_item_name(k.did) + ctx.opt_item_name(did) .map(|n| n.as_str().to_string()) - .unwrap_or(ctx.def_path_str(k.did)), - k.subst, + .unwrap_or(ctx.def_path_str(did)), + subst, ) } _ => panic!(), @@ -736,40 +753,31 @@ impl<'tcx> CloneMap<'tcx> { } } -// Create the substitution used to clone `def_id` with the rustc substitution `subst`. pub(crate) fn base_subst<'tcx>( ctx: &mut Why3Generator<'tcx>, names: &mut CloneMap<'tcx>, - param_env: ParamEnv<'tcx>, - mut def_id: DefId, - subst: SubstsRef<'tcx>, + dep: DepNode<'tcx>, ) -> Vec { - use rustc_middle::ty::GenericParamDefKind; - loop { - if ctx.tcx.is_closure(def_id) { - def_id = ctx.tcx.parent(def_id); - } else { - break; - } - } - let trait_params = ctx.tcx.generics_of(def_id); - let mut clone_subst = Vec::new(); - - if subst.is_empty() { - return Vec::new(); - } - - for ix in 0..trait_params.count() { - let p = trait_params.param_at(ix, ctx.tcx); - let ty = subst[ix]; - if let GenericParamDefKind::Type { .. } = p.kind { - let ty = ctx.normalize_erasing_regions(param_env, ty.expect_ty()); - let ty = backend::ty::translate_ty(ctx, names, rustc_span::DUMMY_SP, ty); - clone_subst.push(CloneSubst::Type(translate_ty_param(p.name).into(), ty)); - } - } - - clone_subst + let (generics, substs) = if let Some((def_id, subst)) = dep.did() { + let generics = ty_param_names(ctx.tcx, def_id).collect(); + (generics, subst) + } else if let DepNode::TyInv(ty) = dep { + let generics = TyInvKind::from_ty(ty).generics(ctx.tcx); + let substs = tyinv_substs(ctx.tcx, ty); + (generics, substs) + } else { + return vec![]; + }; + + let param_env = names.param_env(ctx); + + let mut clone_substs = vec![]; + for (name, arg) in iter::zip(generics, substs.types()) { + let ty = ctx.normalize_erasing_regions(param_env, arg); + let ty = backend::ty::translate_ty(ctx, names, rustc_span::DUMMY_SP, ty); + clone_substs.push(CloneSubst::Type(name.into(), ty)); + } + clone_substs } // Which kind of module should we clone @@ -781,12 +789,19 @@ pub enum CloneLevel { Body, } -fn cloneable_name(ctx: &TranslationCtx, def_id: DefId, interface: CloneLevel, inv: bool) -> QName { +fn cloneable_name(ctx: &TranslationCtx, dep: DepNode, clone_level: CloneLevel) -> QName { use util::ItemType::*; + if let DepNode::TyInv(ty) = dep { + let inv_kind = TyInvKind::from_ty(ty); + return inv_module_name(ctx.tcx, inv_kind).into(); + } + + let (def_id, _) = dep.did().unwrap(); + // TODO: Refactor. match util::item_type(ctx.tcx, def_id) { - Logic | Predicate | Impl => match interface { + Logic | Predicate | Impl => match clone_level { CloneLevel::Stub => QName { module: Vec::new(), name: format!("{}_Stub", &*module_name(ctx.tcx, def_id)).into(), @@ -795,7 +810,7 @@ fn cloneable_name(ctx: &TranslationCtx, def_id: DefId, interface: CloneLevel, in CloneLevel::Interface => interface::interface_name(ctx, def_id).into(), CloneLevel::Body => module_name(ctx.tcx, def_id).into(), }, - Constant => match interface { + Constant => match clone_level { CloneLevel::Body => module_name(ctx.tcx, def_id).into(), _ => QName { module: Vec::new(), @@ -806,7 +821,6 @@ fn cloneable_name(ctx: &TranslationCtx, def_id: DefId, interface: CloneLevel, in Program | Closure => { QName { module: Vec::new(), name: interface::interface_name(ctx, def_id) } } - Type if inv => inv_module_name(ctx.tcx, def_id).into(), Trait | Type | AssocTy => module_name(ctx.tcx, def_id).into(), Unsupported(_) => unreachable!(), } @@ -862,8 +876,9 @@ impl SymbolKind { } // Identify the name and kind of symbol which can be refined in a given defid -fn refineable_symbol<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> Option { +fn refineable_symbol<'tcx>(tcx: TyCtxt<'tcx>, dep: DepNode<'tcx>) -> Option { use util::ItemType::*; + let (def_id, _) = dep.did()?; match util::item_type(tcx, def_id) { Logic => Some(SymbolKind::Function(tcx.item_name(def_id))), Predicate => Some(SymbolKind::Predicate(tcx.item_name(def_id))), @@ -879,24 +894,24 @@ fn refineable_symbol<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> Option>, F: FnMut(&AliasTy<'tcx>)>(s: T, f: F) { - s.visit_with(&mut ProjectionTyVisitor { f, p: std::marker::PhantomData }); +// Walk all the types in a substitution so we can add dependencies on them +fn walk_types<'tcx, T: TypeFoldable>, F: FnMut(Ty<'tcx>)>(s: T, f: F) { + s.visit_with(&mut TyVisitor { f, p: std::marker::PhantomData }); } -struct ProjectionTyVisitor<'tcx, F: FnMut(&AliasTy<'tcx>)> { +struct TyVisitor<'tcx, F: FnMut(Ty<'tcx>)> { f: F, p: std::marker::PhantomData<&'tcx ()>, } -impl<'tcx, F: FnMut(&AliasTy<'tcx>)> TypeVisitor> for ProjectionTyVisitor<'tcx, F> { +impl<'tcx, F: FnMut(Ty<'tcx>)> TypeVisitor> for TyVisitor<'tcx, F> { fn visit_ty(&mut self, t: Ty<'tcx>) -> std::ops::ControlFlow { - match t.kind() { - TyKind::Alias(AliasKind::Projection, pty) => { - (self.f)(pty); - t.super_visit_with(self) - } - _ => t.super_visit_with(self), - } + let t = match t.kind() { + // Box is treated as T, the A param is ignored + TyKind::Adt(adt_def, adt_subst) if adt_def.is_box() => adt_subst.type_at(0), + _ => t, + }; + (self.f)(t); + t.super_visit_with(self) } } diff --git a/creusot/src/backend/dependency.rs b/creusot/src/backend/dependency.rs index 46fd27abb..856d0e7ce 100644 --- a/creusot/src/backend/dependency.rs +++ b/creusot/src/backend/dependency.rs @@ -9,81 +9,28 @@ use crate::{ util::{self, ItemType}, }; +use super::ty_inv::tyinv_substs; + /// Dependencies between items and the resolution logic to find the 'monomorphic' forms accounting /// for various Creusot hacks like the handling of closures. /// /// These should be used both to power the cloning system and to order the overall translation of items in Creusot. /// -#[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)] -pub struct Key<'tcx> { - pub(crate) did: DefId, - pub(crate) subst: SubstsRef<'tcx>, - pub(crate) inv: bool, -} - -impl<'tcx> std::fmt::Debug for Key<'tcx> { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(f, "{:}{:?}{:?}", if self.inv { "Inv:" } else { "" }, &self.did, &self.subst) - } -} - -impl<'tcx> From<(DefId, SubstsRef<'tcx>)> for Key<'tcx> { - #[inline] - fn from(value: (DefId, SubstsRef<'tcx>)) -> Self { - Key { did: value.0, subst: value.1, inv: false } - } -} - -impl<'tcx> Key<'tcx> { - pub(crate) fn new(did: DefId, subst: SubstsRef<'tcx>, inv: bool) -> Self { - Key { did, subst, inv } - } - - #[inline] - pub(crate) fn erase_regions(mut self, tcx: TyCtxt<'tcx>) -> Self { - self.subst = tcx.erase_regions(self.subst); - self - } - - #[inline] - pub(crate) fn subst(mut self, tcx: TyCtxt<'tcx>, substs: SubstsRef<'tcx>) -> Self { - self.subst = EarlyBinder(self.subst).subst(tcx, substs); - self - } - - #[inline] - pub(crate) fn closure_hack(self, tcx: TyCtxt<'tcx>) -> Self { - let (did, subst) = closure_hack(tcx, self.did, self.subst); - Key { did, subst, ..self } - } -} - #[derive(Copy, Clone, PartialEq, Eq, Debug, Hash, PartialOrd, Ord)] pub(crate) enum Dependency<'tcx> { Type(Ty<'tcx>), - Item(Key<'tcx>), - TyInv(Key<'tcx>), + Item(DefId, SubstsRef<'tcx>), + TyInv(Ty<'tcx>), } impl<'tcx> Dependency<'tcx> { - pub(crate) fn new(tcx: TyCtxt<'tcx>, dep: Key<'tcx>) -> Self { - match util::item_type(tcx, dep.did) { - ItemType::Type if dep.inv => Dependency::TyInv(dep), - ItemType::Type => Dependency::Type(tcx.mk_adt(tcx.adt_def(dep.did), dep.subst)), - // ItemType::Closure => Dependency::Type(tcx.type_of(dep.0).subst(tcx, dep.1)), - ItemType::AssocTy => Dependency::Type(tcx.mk_projection(dep.did, dep.subst)), - _ => Dependency::Item(dep), + pub(crate) fn new(tcx: TyCtxt<'tcx>, (did, subst): (DefId, SubstsRef<'tcx>)) -> Self { + match util::item_type(tcx, did) { + ItemType::Type => Dependency::Type(tcx.mk_adt(tcx.adt_def(did), subst)), + ItemType::AssocTy => Dependency::Type(tcx.mk_projection(did, subst)), + _ => Dependency::Item(did, subst), } - - // if matches!( - // tcx.def_kind(id_substs.0), - // DefKind::Struct | DefKind::Enum | DefKind::Union | DefKind::Closure - // ) { - // Dependency::Type(tcx.type_of(id_substs.0).subst(tcx, id_substs.1)) - // } else { - // Dependency::Item(id_substs) - // } } pub(crate) fn resolve( @@ -93,25 +40,60 @@ impl<'tcx> Dependency<'tcx> { ) -> Option { match self { Dependency::Type(ty) => resolve_type(ty, ctx.tcx, param_env), - Dependency::Item(Key { did: item, subst: substs, .. }) => { - resolve_item(item, substs, ctx.tcx, param_env) - } + Dependency::Item(item, substs) => resolve_item(item, substs, ctx.tcx, param_env), dep @ Dependency::TyInv(_) => Some(dep), } } - pub(crate) fn cloneable_id(self) -> Option> { + pub(crate) fn did(self) -> Option<(DefId, SubstsRef<'tcx>)> { match self { - Dependency::Item(i) => Some(i), - Dependency::Type(t) => match t.kind() { - TyKind::Adt(def, substs) => Some(Key { did: def.did(), subst: substs, inv: false }), - TyKind::Closure(id, substs) => Some(Key { did: *id, subst: substs, inv: false }), - TyKind::Alias(AliasKind::Projection, aty) => { - Some(Key { did: aty.def_id, subst: aty.substs, inv: false }) - } + Dependency::Item(def_id, subst) => Some((def_id, subst)), + Dependency::Type(t) | Dependency::TyInv(t) => match t.kind() { + TyKind::Adt(def, substs) => Some((def.did(), substs)), + TyKind::Closure(id, substs) => Some((*id, substs)), + TyKind::Alias(AliasKind::Projection, aty) => Some((aty.def_id, aty.substs)), _ => None, }, - Dependency::TyInv(i) => Some(i), + } + } + + pub(crate) fn is_inv(&self) -> bool { + matches!(self, Dependency::TyInv(_)) + } + + #[inline] + pub(crate) fn erase_regions(mut self, tcx: TyCtxt<'tcx>) -> Self { + match &mut self { + Dependency::Item(_, s) => *s = tcx.erase_regions(*s), + Dependency::Type(ty) | Dependency::TyInv(ty) => *ty = tcx.erase_regions(*ty), + }; + self + } + + #[inline] + pub(crate) fn subst(mut self, tcx: TyCtxt<'tcx>, other: Dependency<'tcx>) -> Self { + let substs = if let Dependency::TyInv(ty) = other { + tyinv_substs(tcx, ty) + } else if let Some((_, substs)) = other.did() { + substs + } else { + return self; + }; + + match &mut self { + Dependency::Item(_, s) => *s = EarlyBinder(*s).subst(tcx, substs), + Dependency::Type(ty) | Dependency::TyInv(ty) => { + *ty = EarlyBinder(*ty).subst(tcx, substs) + } + }; + self + } + + #[inline] + pub(crate) fn closure_hack(self, tcx: TyCtxt<'tcx>) -> Self { + match self { + Dependency::Item(did, subst) => Dependency::new(tcx, closure_hack(tcx, did, subst)), + _ => self, } } } @@ -141,7 +123,7 @@ fn resolve_item<'tcx>( }; let resolved = closure_hack(tcx, resolved.0, resolved.1); let normed = tcx.try_normalize_erasing_regions(param_env, resolved).unwrap(); - Some(Dependency::new(tcx, normed.into())) + Some(Dependency::new(tcx, normed)) } pub(crate) fn closure_hack<'tcx>( diff --git a/creusot/src/backend/term.rs b/creusot/src/backend/term.rs index dafa4dc71..25f88d067 100644 --- a/creusot/src/backend/term.rs +++ b/creusot/src/backend/term.rs @@ -332,10 +332,10 @@ impl<'tcx> Lower<'_, 'tcx> { use rustc_hir::def_id::DefId; use rustc_middle::ty::{subst::SubstsRef, TyCtxt}; -use super::Why3Generator; +use super::{dependency::Dependency, Why3Generator}; pub(crate) fn lower_literal<'tcx>( - _ctx: &mut TranslationCtx<'tcx>, + ctx: &mut TranslationCtx<'tcx>, names: &mut CloneMap<'tcx>, lit: Literal<'tcx>, ) -> Exp { @@ -359,7 +359,7 @@ pub(crate) fn lower_literal<'tcx>( } Literal::Function(id, subst) => { #[allow(deprecated)] - names.insert((id, subst).into()); + names.insert(Dependency::new(ctx.tcx, (id, subst))); Exp::Tuple(Vec::new()) } Literal::Float(f, fty) => { diff --git a/creusot/src/backend/ty.rs b/creusot/src/backend/ty.rs index 8e94b362b..c99c0e733 100644 --- a/creusot/src/backend/ty.rs +++ b/creusot/src/backend/ty.rs @@ -400,13 +400,10 @@ pub(crate) fn ty_param_names( } let gens = tcx.generics_of(def_id); - gens.params - .iter() - .filter_map(|param| match param.kind { - ty::GenericParamDefKind::Type { .. } => Some(translate_ty_param(param.name)), - _ => None, - }) - .map(Ident::from) + (0..gens.count()).map(move |i| gens.param_at(i, tcx)).filter_map(|param| match param.kind { + ty::GenericParamDefKind::Type { .. } => Some(translate_ty_param(param.name)), + _ => None, + }) } fn field_ty<'tcx>( diff --git a/creusot/src/backend/ty_inv.rs b/creusot/src/backend/ty_inv.rs index 69c42780b..de5c66d84 100644 --- a/creusot/src/backend/ty_inv.rs +++ b/creusot/src/backend/ty_inv.rs @@ -1,48 +1,114 @@ -use super::{ty::translate_ty, CloneMap, CloneSummary, Why3Generator}; -use crate::{ - ctx::*, - translation::{function, traits}, - util, +use super::{ + ty::{translate_ty, ty_param_names}, + CloneMap, CloneSummary, TransId, Why3Generator, }; +use crate::{ctx::*, translation::traits, util}; use rustc_hir::{def::Namespace, def_id::DefId}; -use rustc_middle::ty::{subst::SubstsRef, AdtDef, GenericArg, ParamEnv, Ty, TyKind}; +use rustc_middle::ty::{subst::SubstsRef, AdtDef, GenericArg, ParamEnv, Ty, TyCtxt, TyKind}; use rustc_span::{Symbol, DUMMY_SP}; use why3::{ - declaration::{Axiom, Decl, Module}, + declaration::{Axiom, Decl, Module, TyDecl}, exp::{Exp, Pattern}, Ident, }; +#[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Debug)] +pub(crate) enum TyInvKind { + Trivial, + Adt(DefId), + Tuple(usize), +} + +impl TyInvKind { + pub(crate) fn from_ty(ty: Ty) -> Self { + match ty.kind() { + TyKind::Bool | TyKind::Char | TyKind::Int(_) | TyKind::Uint(_) | TyKind::Float(_) => { + TyInvKind::Trivial + } + TyKind::Adt(adt_def, _) => TyInvKind::Adt(adt_def.did()), + TyKind::Tuple(tys) => TyInvKind::Tuple(tys.len()), + _ => TyInvKind::Trivial, // TODO + } + } + + pub(crate) fn to_ty<'tcx>(self, tcx: TyCtxt<'tcx>) -> Ty<'tcx> { + match self { + TyInvKind::Trivial => tcx.mk_ty_param(0, Symbol::intern("T")), + TyInvKind::Adt(did) => tcx.type_of(did).subst_identity(), + TyInvKind::Tuple(arity) => tcx.mk_tup_from_iter( + (0..arity).map(|i| tcx.mk_ty_param(i as _, Symbol::intern(&format!("T{i}")))), + ), + } + } + + pub(crate) fn generics(self, tcx: TyCtxt) -> Vec { + match self { + TyInvKind::Trivial => vec!["t".into()], + TyInvKind::Adt(def_id) => ty_param_names(tcx, def_id).collect(), + TyInvKind::Tuple(arity) => (0..arity).map(|i| format!["t{i}"].into()).collect(), + } + } +} + +pub(crate) fn tyinv_substs<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> SubstsRef<'tcx> { + match ty.kind() { + TyKind::Bool | TyKind::Char | TyKind::Int(_) | TyKind::Uint(_) | TyKind::Float(_) => { + tcx.mk_substs(&[GenericArg::from(ty)]) + } + TyKind::Adt(_, adt_substs) => adt_substs, + TyKind::Tuple(tys) => tcx.mk_substs_from_iter(tys.iter().map(GenericArg::from)), + _ => tcx.mk_substs(&[]), + } +} + pub(crate) fn build_inv_module<'tcx>( ctx: &mut Why3Generator<'tcx>, - did: DefId, + inv_kind: TyInvKind, ) -> (Module, CloneSummary<'tcx>) { - let mut names = CloneMap::new_inv(ctx.tcx, did, CloneLevel::Stub, true); - - let ty_name = util::item_name(ctx.tcx, did, Namespace::TypeNS); - let axiom_name = Ident::from(format!("inv_{}", &*ty_name)); - let inv_axiom = build_inv_axiom(ctx, &mut names, did, axiom_name); + let mut names = CloneMap::new_with_tid(ctx.tcx, TransId::TyInv(inv_kind), CloneLevel::Stub); + let generics = inv_kind.generics(ctx.tcx); + let inv_axiom = build_inv_axiom(ctx, &mut names, inv_kind); + + let mut decls = vec![]; + decls.extend( + generics + .into_iter() + .map(|ty_name| Decl::TyDecl(TyDecl::Opaque { ty_name, ty_params: vec![] })), + ); let (clones, summary) = names.to_clones(ctx); - - let mut decls = function::own_generic_decls_for(ctx.tcx, did).collect::>(); decls.extend(clones); + decls.push(Decl::Axiom(inv_axiom)); - (Module { name: util::inv_module_name(ctx.tcx, did), decls }, summary) + (Module { name: util::inv_module_name(ctx.tcx, inv_kind), decls }, summary) } fn build_inv_axiom<'tcx>( ctx: &mut Why3Generator<'tcx>, names: &mut CloneMap<'tcx>, - did: DefId, - name: Ident, + inv_kind: TyInvKind, ) -> Axiom { - let ty = ctx.type_of(did).subst_identity(); - let param_env = ctx.param_env(did); + let name = match inv_kind { + TyInvKind::Trivial => "inv_trivial".into(), + TyInvKind::Adt(did) => { + let ty_name = util::item_name(ctx.tcx, did, Namespace::TypeNS); + format!("inv_{}", &*ty_name).into() + } + TyInvKind::Tuple(arity) => format!("inv_tuple{arity}").into(), + }; + + let param_env = + if let TyInvKind::Adt(did) = inv_kind { ctx.param_env(did) } else { ParamEnv::empty() }; + + let ty = inv_kind.to_ty(ctx.tcx); let lhs: Exp = Exp::impure_qvar(names.ty_inv(ty)).app_to(Exp::pure_var("self".into())); - let rhs = build_inv_exp(ctx, names, "self".into(), ty, param_env, true) - .unwrap_or_else(|| Exp::mk_true()); + let rhs = if TyInvKind::Trivial == inv_kind { + Exp::mk_true() + } else { + build_inv_exp(ctx, names, "self".into(), ty, param_env, true) + .unwrap_or_else(|| Exp::mk_true()) + }; let axiom = Exp::Forall( vec![("self".into(), translate_ty(ctx, names, DUMMY_SP, ty))], diff --git a/creusot/src/translation.rs b/creusot/src/translation.rs index f0a16c652..d1d4551c1 100644 --- a/creusot/src/translation.rs +++ b/creusot/src/translation.rs @@ -8,7 +8,7 @@ pub(crate) mod specification; pub(crate) mod traits; use crate::{ - backend::Why3Generator, + backend::{TransId, Why3Generator}, ctx, ctx::load_extern_specs, error::CrErr, @@ -116,7 +116,7 @@ pub(crate) fn after_analysis(ctx: TranslationCtx) -> Result<(), Box> let matcher: &str = matcher.as_ref().map(|s| &s[..]).unwrap_or(""); let tcx = why3.tcx; let modules = why3.modules().flat_map(|(id, item)| { - if tcx.def_path_str(id).contains(matcher) { + if let TransId::Item(did) = id && tcx.def_path_str(did).contains(matcher) { item.modules() } else { item.interface() diff --git a/creusot/src/util.rs b/creusot/src/util.rs index e91a6ec7d..308b621d3 100644 --- a/creusot/src/util.rs +++ b/creusot/src/util.rs @@ -1,4 +1,5 @@ use crate::{ + backend::ty_inv::TyInvKind, ctx::*, translation::{ pearlite::{self, super_visit_mut_term, Literal, Term, TermKind, TermVisitorMut}, @@ -109,6 +110,10 @@ pub(crate) fn is_type_invariant(tcx: TyCtxt, def_id: DefId) -> bool { .unwrap_or(false) } +pub(crate) fn is_inv_internal(tcx: TyCtxt, def_id: DefId) -> bool { + def_id == tcx.get_diagnostic_item(Symbol::intern("creusot_invariant_internal")).unwrap() +} + pub(crate) fn opacity_witness_name(tcx: TyCtxt, def_id: DefId) -> Option { get_attr(tcx.get_attrs_unchecked(def_id), &["creusot", "clause", "open"]).and_then(|item| { match &item.args { @@ -218,8 +223,12 @@ pub(crate) fn ident_of_ty(sym: Symbol) -> Ident { Ident::build(&id) } -pub(crate) fn inv_module_name(tcx: TyCtxt, def_id: DefId) -> Ident { - format!("{}_Inv", &*ident_path(tcx, def_id)).into() +pub(crate) fn inv_module_name(tcx: TyCtxt, kind: TyInvKind) -> Ident { + match kind { + TyInvKind::Trivial => "TyInv_Trivial".into(), + TyInvKind::Adt(adt_did) => format!("{}_Inv", &*ident_path(tcx, adt_did)).into(), + TyInvKind::Tuple(arity) => format!("TyInv_Tuple{arity}").into(), + } } pub(crate) fn module_name(tcx: TyCtxt, def_id: DefId) -> Ident { diff --git a/creusot/tests/should_succeed/type_invariants/generated.mlcfg b/creusot/tests/should_succeed/type_invariants/generated.mlcfg index 2b722b4eb..b62bf5696 100644 --- a/creusot/tests/should_succeed/type_invariants/generated.mlcfg +++ b/creusot/tests/should_succeed/type_invariants/generated.mlcfg @@ -4,39 +4,8 @@ module Core_Option_Option_Type | C_None | C_Some 't -end -module Core_Ptr_NonNull_NonNull_Type - use prelude.Opaque - type t_nonnull 't = - | C_NonNull opaque_ptr - -end -module Core_Marker_PhantomData_Type - type t_phantomdata 't = - | C_PhantomData - -end -module Core_Ptr_Unique_Unique_Type - use Core_Marker_PhantomData_Type as Core_Marker_PhantomData_Type - use Core_Ptr_NonNull_NonNull_Type as Core_Ptr_NonNull_NonNull_Type - type t_unique 't = - | C_Unique (Core_Ptr_NonNull_NonNull_Type.t_nonnull 't) (Core_Marker_PhantomData_Type.t_phantomdata 't) - -end -module Alloc_Boxed_Box_Type - use Core_Ptr_Unique_Unique_Type as Core_Ptr_Unique_Unique_Type - type t_box 't 'a = - | C_Box (Core_Ptr_Unique_Unique_Type.t_unique 't) 'a - -end -module Alloc_Alloc_Global_Type - type t_global = - | C_Global - end module Generated_List_Type - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type use Core_Option_Option_Type as Core_Option_Option_Type type t_list 't = | C_List 't (Core_Option_Option_Type.t_option (t_list 't)) @@ -79,38 +48,12 @@ module CreusotContracts_Invariant_UserInv_UserInv ensures { result = user_inv self } end -module Core_Option_Option_Type_Inv - type t - clone CreusotContracts_Invariant_Inv_Stub as Inv1 with - type t = t - use Core_Option_Option_Type as Core_Option_Option_Type - clone CreusotContracts_Invariant_UserInv_UserInv_Stub as UserInv0 with - type self = Core_Option_Option_Type.t_option t - clone CreusotContracts_Invariant_Inv_Stub as Inv0 with - type t = Core_Option_Option_Type.t_option t - axiom inv_t_option : forall self : Core_Option_Option_Type.t_option t . Inv0.inv self = (UserInv0.user_inv self /\ match (self) with - | Core_Option_Option_Type.C_None -> true - | Core_Option_Option_Type.C_Some a_0 -> Inv1.inv a_0 - end) -end module Generated_List_Type_Inv type t - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type use Generated_List_Type as Generated_List_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type - clone CreusotContracts_Invariant_Inv_Stub as Inv3 with - type t = Generated_List_Type.t_list t use Core_Option_Option_Type as Core_Option_Option_Type - clone CreusotContracts_Invariant_UserInv_UserInv_Stub as UserInv1 with - type self = Core_Option_Option_Type.t_option (Generated_List_Type.t_list t) clone CreusotContracts_Invariant_Inv_Stub as Inv2 with type t = Core_Option_Option_Type.t_option (Generated_List_Type.t_list t) - clone Core_Option_Option_Type_Inv as Core_Option_Option_Type_Inv with - type t = Generated_List_Type.t_list t, - predicate Inv0.inv = Inv2.inv, - predicate UserInv0.user_inv = UserInv1.user_inv, - predicate Inv1.inv = Inv3.inv, - axiom . clone CreusotContracts_Invariant_Inv_Stub as Inv1 with type t = t clone CreusotContracts_Invariant_UserInv_UserInv_Stub as UserInv0 with @@ -140,6 +83,26 @@ module CreusotContracts_Invariant_Impl0_UserInv ensures { result = user_inv self } end +module TyInv_Trivial + type t + clone CreusotContracts_Invariant_Inv_Stub as Inv0 with + type t = t + axiom inv_trivial : forall self : t . Inv0.inv self = true +end +module Core_Option_Option_Type_Inv + type t + clone CreusotContracts_Invariant_Inv_Stub as Inv1 with + type t = t + use Core_Option_Option_Type as Core_Option_Option_Type + clone CreusotContracts_Invariant_UserInv_UserInv_Stub as UserInv0 with + type self = Core_Option_Option_Type.t_option t + clone CreusotContracts_Invariant_Inv_Stub as Inv0 with + type t = Core_Option_Option_Type.t_option t + axiom inv_t_option : forall self : Core_Option_Option_Type.t_option t . Inv0.inv self = (UserInv0.user_inv self /\ match (self) with + | Core_Option_Option_Type.C_None -> true + | Core_Option_Option_Type.C_Some a_0 -> Inv1.inv a_0 + end) +end module Generated_UseList_Interface use prelude.Int use prelude.Int32 @@ -149,9 +112,7 @@ end module Generated_UseList use prelude.Int use prelude.Int32 - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type use Generated_List_Type as Generated_List_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type clone CreusotContracts_Invariant_Inv_Interface as Inv3 with type t = Generated_List_Type.t_list int32 use Core_Option_Option_Type as Core_Option_Option_Type @@ -167,6 +128,10 @@ module Generated_UseList axiom . clone CreusotContracts_Invariant_Inv_Interface as Inv1 with type t = int32 + clone TyInv_Trivial as TyInv_Trivial with + type t = int32, + predicate Inv0.inv = Inv1.inv, + axiom . clone CreusotContracts_Invariant_Impl0_UserInv as UserInv0 with type t = Generated_List_Type.t_list int32 clone CreusotContracts_Invariant_Inv_Interface as Inv0 with @@ -177,8 +142,6 @@ module Generated_UseList predicate UserInv0.user_inv = UserInv0.user_inv, predicate Inv1.inv = Inv1.inv, predicate Inv2.inv = Inv2.inv, - predicate UserInv1.user_inv = UserInv1.user_inv, - predicate Inv3.inv = Inv3.inv, axiom . let rec cfg use_list [#"../generated.rs" 6 0 6 29] [@cfg:stackify] [@cfg:subregion_analysis] (l : Generated_List_Type.t_list int32) : () From 6077aa522c8c0bb13467348cf2bb452b0210b400 Mon Sep 17 00:00:00 2001 From: Dominik Stolz Date: Tue, 13 Jun 2023 19:50:30 +0200 Subject: [PATCH 06/12] Add TyInvKind::Borrow --- creusot/src/backend/ty_inv.rs | 61 ++++++++++++++++++++++++++++------- creusot/src/util.rs | 1 + 2 files changed, 50 insertions(+), 12 deletions(-) diff --git a/creusot/src/backend/ty_inv.rs b/creusot/src/backend/ty_inv.rs index de5c66d84..923bdaa01 100644 --- a/creusot/src/backend/ty_inv.rs +++ b/creusot/src/backend/ty_inv.rs @@ -3,6 +3,7 @@ use super::{ CloneMap, CloneSummary, TransId, Why3Generator, }; use crate::{ctx::*, translation::traits, util}; +use rustc_ast::Mutability; use rustc_hir::{def::Namespace, def_id::DefId}; use rustc_middle::ty::{subst::SubstsRef, AdtDef, GenericArg, ParamEnv, Ty, TyCtxt, TyKind}; use rustc_span::{Symbol, DUMMY_SP}; @@ -15,6 +16,7 @@ use why3::{ #[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Debug)] pub(crate) enum TyInvKind { Trivial, + Borrow, Adt(DefId), Tuple(usize), } @@ -25,6 +27,11 @@ impl TyInvKind { TyKind::Bool | TyKind::Char | TyKind::Int(_) | TyKind::Uint(_) | TyKind::Float(_) => { TyInvKind::Trivial } + TyKind::Ref(_, ty, Mutability::Not) => TyInvKind::from_ty(*ty), + TyKind::Ref(_, _, Mutability::Mut) => TyInvKind::Borrow, + TyKind::Adt(adt_def, adt_substs) if adt_def.is_box() => { + TyInvKind::from_ty(adt_substs.type_at(0)) + } TyKind::Adt(adt_def, _) => TyInvKind::Adt(adt_def.did()), TyKind::Tuple(tys) => TyInvKind::Tuple(tys.len()), _ => TyInvKind::Trivial, // TODO @@ -34,6 +41,11 @@ impl TyInvKind { pub(crate) fn to_ty<'tcx>(self, tcx: TyCtxt<'tcx>) -> Ty<'tcx> { match self { TyInvKind::Trivial => tcx.mk_ty_param(0, Symbol::intern("T")), + TyInvKind::Borrow => { + let re = tcx.lifetimes.re_erased; + let ty = tcx.mk_ty_param(0, Symbol::intern("T")); + tcx.mk_mut_ref(re, ty) + } TyInvKind::Adt(did) => tcx.type_of(did).subst_identity(), TyInvKind::Tuple(arity) => tcx.mk_tup_from_iter( (0..arity).map(|i| tcx.mk_ty_param(i as _, Symbol::intern(&format!("T{i}")))), @@ -43,7 +55,7 @@ impl TyInvKind { pub(crate) fn generics(self, tcx: TyCtxt) -> Vec { match self { - TyInvKind::Trivial => vec!["t".into()], + TyInvKind::Trivial | TyInvKind::Borrow => vec!["t".into()], TyInvKind::Adt(def_id) => ty_param_names(tcx, def_id).collect(), TyInvKind::Tuple(arity) => (0..arity).map(|i| format!["t{i}"].into()).collect(), } @@ -55,12 +67,30 @@ pub(crate) fn tyinv_substs<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> SubstsRef<' TyKind::Bool | TyKind::Char | TyKind::Int(_) | TyKind::Uint(_) | TyKind::Float(_) => { tcx.mk_substs(&[GenericArg::from(ty)]) } + TyKind::Ref(_, ty, Mutability::Not) => tyinv_substs(tcx, *ty), + TyKind::Ref(_, ty, Mutability::Mut) => tcx.mk_substs(&[GenericArg::from(*ty)]), + TyKind::Adt(adt_def, adt_substs) if adt_def.is_box() => { + tyinv_substs(tcx, adt_substs.type_at(0)) + } TyKind::Adt(_, adt_substs) => adt_substs, TyKind::Tuple(tys) => tcx.mk_substs_from_iter(tys.iter().map(GenericArg::from)), - _ => tcx.mk_substs(&[]), + _ => tcx.mk_substs(&[GenericArg::from(ty)]), } } +pub(crate) fn is_tyinv_trivial<'tcx>( + ctx: &TranslationCtx<'tcx>, + def_id: DefId, + ty: Ty<'tcx>, +) -> bool { + // TODO ADT fields + let param_env = ctx.param_env(def_id); + let non_trivial = ty.walk().any(|ty| { + ty.as_type().is_some_and(|ty| resolve_user_inv(ctx.tcx, ty, param_env).is_some()) + }); + !non_trivial +} + pub(crate) fn build_inv_module<'tcx>( ctx: &mut Why3Generator<'tcx>, inv_kind: TyInvKind, @@ -91,6 +121,7 @@ fn build_inv_axiom<'tcx>( ) -> Axiom { let name = match inv_kind { TyInvKind::Trivial => "inv_trivial".into(), + TyInvKind::Borrow => "inv_borrow".into(), TyInvKind::Adt(did) => { let ty_name = util::item_name(ctx.tcx, did, Namespace::TypeNS); format!("inv_{}", &*ty_name).into() @@ -128,7 +159,7 @@ fn build_inv_exp<'tcx>( let ty = ctx.normalize_erasing_regions(param_env, ty); let user_inv = if destruct_adt { - resolve_user_inv(ctx, ty, param_env).map(|(uinv_did, uinv_subst)| { + resolve_user_inv(ctx.tcx, ty, param_env).map(|(uinv_did, uinv_subst)| { let inv_name = names.value(uinv_did, uinv_subst); Exp::impure_qvar(inv_name).app(vec![Exp::pure_var(ident.clone())]) }) @@ -154,6 +185,14 @@ fn build_inv_exp_struct<'tcx>( destruct_adt: bool, ) -> Option { match ty.kind() { + TyKind::Ref(_, ty, Mutability::Not) => { + build_inv_exp(ctx, names, ident, *ty, param_env, destruct_adt) + } + TyKind::Ref(_, ty, Mutability::Mut) => { + let e = build_inv_exp(ctx, names, ident, *ty, param_env, destruct_adt)?; + // TODO include final value + Some(Exp::Current(Box::new(e))) + } TyKind::Tuple(tys) => { let fields: Vec = tys.iter().enumerate().map(|(i, _)| format!("a_{i}").into()).collect(); @@ -226,25 +265,23 @@ fn build_inv_exp_adt<'tcx>( } fn resolve_user_inv<'tcx>( - ctx: &mut Why3Generator<'tcx>, + tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, param_env: ParamEnv<'tcx>, ) -> Option<(DefId, SubstsRef<'tcx>)> { - let trait_did = ctx.get_diagnostic_item(Symbol::intern("creusot_invariant_user")).unwrap(); - let default_did = - ctx.get_diagnostic_item(Symbol::intern("creusot_invariant_user_default")).unwrap(); + let trait_did = tcx.get_diagnostic_item(Symbol::intern("creusot_invariant_user"))?; + let default_did = tcx.get_diagnostic_item(Symbol::intern("creusot_invariant_user_default"))?; let (impl_did, subst) = traits::resolve_assoc_item_opt( - ctx.tcx, + tcx, param_env, trait_did, - ctx.mk_substs(&[GenericArg::from(ty)]), + tcx.mk_substs(&[GenericArg::from(ty)]), )?; - let subst = ctx.try_normalize_erasing_regions(param_env, subst).unwrap_or(subst); + let subst = tcx.try_normalize_erasing_regions(param_env, subst).unwrap_or(subst); // if inv resolved to the default impl and is not specializable, ignore - if impl_did == default_did && !traits::still_specializable(ctx.tcx, param_env, impl_did, subst) - { + if impl_did == default_did && !traits::still_specializable(tcx, param_env, impl_did, subst) { None } else { Some((impl_did, subst)) diff --git a/creusot/src/util.rs b/creusot/src/util.rs index 308b621d3..b7ae2c2d3 100644 --- a/creusot/src/util.rs +++ b/creusot/src/util.rs @@ -226,6 +226,7 @@ pub(crate) fn ident_of_ty(sym: Symbol) -> Ident { pub(crate) fn inv_module_name(tcx: TyCtxt, kind: TyInvKind) -> Ident { match kind { TyInvKind::Trivial => "TyInv_Trivial".into(), + TyInvKind::Borrow => "TyInv_Borrows".into(), TyInvKind::Adt(adt_did) => format!("{}_Inv", &*ident_path(tcx, adt_did)).into(), TyInvKind::Tuple(arity) => format!("TyInv_Tuple{arity}").into(), } From 0a6fa3438387f64e42972f9cc12a5b1f502f88a1 Mon Sep 17 00:00:00 2001 From: Dominik Stolz Date: Mon, 12 Jun 2023 18:21:29 +0200 Subject: [PATCH 07/12] Fixes --- creusot/src/backend/clone_map.rs | 75 ++++++++++--------- creusot/src/backend/dependency.rs | 4 +- creusot/src/backend/ty_inv.rs | 13 ---- creusot/src/util.rs | 5 +- .../type_invariants/generated.rs | 2 +- 5 files changed, 44 insertions(+), 55 deletions(-) diff --git a/creusot/src/backend/clone_map.rs b/creusot/src/backend/clone_map.rs index cc19da668..8787b2f40 100644 --- a/creusot/src/backend/clone_map.rs +++ b/creusot/src/backend/clone_map.rs @@ -286,37 +286,34 @@ impl<'tcx> CloneMap<'tcx> { let key = key.erase_regions(self.tcx).closure_hack(self.tcx); self.names.entry(key).or_insert_with(|| { - let name = match key { - CloneNode::Item(did, _) => { - let base_sym = match util::item_type(self.tcx, did) { - ItemType::Impl => { - self.tcx.item_name(self.tcx.trait_id_of_impl(did).unwrap()) - } - ItemType::Closure => Symbol::intern(&format!( - "closure{}", - self.tcx.def_path(did).data.last().unwrap().disambiguator - )), - _ => self.tcx.item_name(did), - }; + if let CloneNode::Type(ty) = key && !matches!(ty.kind(), TyKind::Alias(_, _)) { + return if let Some((did, _)) = key.did() { + let name = Symbol::intern(&*module_name(self.tcx, did)); + CloneInfo::from_name(name, self.public) + } else { + CloneInfo::hidden() + }; + } - let base = Symbol::intern(&base_sym.as_str().to_upper_camel_case()); - let count: usize = - *self.name_counts.entry(base).and_modify(|c| *c += 1).or_insert(0); - trace!("inserting {:?} as {}{}", key, base, count); - Symbol::intern(&format!("{}{}", base, count)) - } - CloneNode::Type(_) => { - let (did, _) = key.did().unwrap(); - Symbol::intern(&*module_name(self.tcx, did)) - } - CloneNode::TyInv(ty) => { - let inv_kind = TyInvKind::from_ty(ty); - Symbol::intern(&*inv_module_name(self.tcx, inv_kind)) - } + let base = if let CloneNode::TyInv(ty) = key { + let inv_kind = TyInvKind::from_ty(ty); + Symbol::intern(&*inv_module_name(self.tcx, inv_kind)) + } else { + let did = key.did().unwrap().0; + let base = match util::item_type(self.tcx, did) { + ItemType::Impl => self.tcx.item_name(self.tcx.trait_id_of_impl(did).unwrap()), + ItemType::Closure => Symbol::intern(&format!( + "closure{}", + self.tcx.def_path(did).data.last().unwrap().disambiguator + )), + _ => self.tcx.item_name(did), + }; + Symbol::intern(&base.as_str().to_upper_camel_case()) }; - let info = CloneInfo::from_name(name, self.public); - info + let count: usize = *self.name_counts.entry(base).and_modify(|c| *c += 1).or_insert(0); + trace!("inserting {key:?} as {base}{count}"); + CloneInfo::from_name(Symbol::intern(&format!("{base}{count}")), self.public) }) } @@ -593,15 +590,19 @@ impl<'tcx> CloneMap<'tcx> { // Types can't be cloned, but are used (for now). if let DepNode::Type(_) = item { let (def_id, _) = item.did()?; - return self.used_types.insert(def_id).then(|| { - if let Some(builtin) = get_builtin(ctx.tcx, def_id) { - let name = QName::from_string(&builtin.as_str()).unwrap().module_qname(); - Decl::UseDecl(Use { name: name, as_: None, export: false }) - } else { - let name = cloneable_name(ctx, item, CloneLevel::Body); - Decl::UseDecl(Use { name: name.clone(), as_: Some(name), export: false }) - } - }); + // check if type is not an assoc type + if util::item_type(ctx.tcx, def_id) == ItemType::Type { + let use_decl = self.used_types.insert(def_id).then(|| { + if let Some(builtin) = get_builtin(ctx.tcx, def_id) { + let name = QName::from_string(&builtin.as_str()).unwrap().module_qname(); + Use { name: name, as_: None, export: false } + } else { + let name = cloneable_name(ctx, item, CloneLevel::Body); + Use { name: name.clone(), as_: Some(name), export: false } + } + }); + return use_decl.map(Decl::UseDecl); + } } let mut clone_subst = base_subst(ctx, self, item); diff --git a/creusot/src/backend/dependency.rs b/creusot/src/backend/dependency.rs index 856d0e7ce..7b3f281e1 100644 --- a/creusot/src/backend/dependency.rs +++ b/creusot/src/backend/dependency.rs @@ -9,7 +9,7 @@ use crate::{ util::{self, ItemType}, }; -use super::ty_inv::tyinv_substs; +use super::ty_inv; /// Dependencies between items and the resolution logic to find the 'monomorphic' forms accounting /// for various Creusot hacks like the handling of closures. @@ -73,7 +73,7 @@ impl<'tcx> Dependency<'tcx> { #[inline] pub(crate) fn subst(mut self, tcx: TyCtxt<'tcx>, other: Dependency<'tcx>) -> Self { let substs = if let Dependency::TyInv(ty) = other { - tyinv_substs(tcx, ty) + ty_inv::tyinv_substs(tcx, ty) } else if let Some((_, substs)) = other.did() { substs } else { diff --git a/creusot/src/backend/ty_inv.rs b/creusot/src/backend/ty_inv.rs index 923bdaa01..a5e1d62e2 100644 --- a/creusot/src/backend/ty_inv.rs +++ b/creusot/src/backend/ty_inv.rs @@ -78,19 +78,6 @@ pub(crate) fn tyinv_substs<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> SubstsRef<' } } -pub(crate) fn is_tyinv_trivial<'tcx>( - ctx: &TranslationCtx<'tcx>, - def_id: DefId, - ty: Ty<'tcx>, -) -> bool { - // TODO ADT fields - let param_env = ctx.param_env(def_id); - let non_trivial = ty.walk().any(|ty| { - ty.as_type().is_some_and(|ty| resolve_user_inv(ctx.tcx, ty, param_env).is_some()) - }); - !non_trivial -} - pub(crate) fn build_inv_module<'tcx>( ctx: &mut Why3Generator<'tcx>, inv_kind: TyInvKind, diff --git a/creusot/src/util.rs b/creusot/src/util.rs index b7ae2c2d3..88e344fce 100644 --- a/creusot/src/util.rs +++ b/creusot/src/util.rs @@ -111,7 +111,8 @@ pub(crate) fn is_type_invariant(tcx: TyCtxt, def_id: DefId) -> bool { } pub(crate) fn is_inv_internal(tcx: TyCtxt, def_id: DefId) -> bool { - def_id == tcx.get_diagnostic_item(Symbol::intern("creusot_invariant_internal")).unwrap() + tcx.get_diagnostic_item(Symbol::intern("creusot_invariant_internal")) + .is_some_and(|did| did == def_id) } pub(crate) fn opacity_witness_name(tcx: TyCtxt, def_id: DefId) -> Option { @@ -226,7 +227,7 @@ pub(crate) fn ident_of_ty(sym: Symbol) -> Ident { pub(crate) fn inv_module_name(tcx: TyCtxt, kind: TyInvKind) -> Ident { match kind { TyInvKind::Trivial => "TyInv_Trivial".into(), - TyInvKind::Borrow => "TyInv_Borrows".into(), + TyInvKind::Borrow => "TyInv_Borrow".into(), TyInvKind::Adt(adt_did) => format!("{}_Inv", &*ident_path(tcx, adt_did)).into(), TyInvKind::Tuple(arity) => format!("TyInv_Tuple{arity}").into(), } diff --git a/creusot/tests/should_succeed/type_invariants/generated.rs b/creusot/tests/should_succeed/type_invariants/generated.rs index 3f6fc09ac..1b5a0af53 100644 --- a/creusot/tests/should_succeed/type_invariants/generated.rs +++ b/creusot/tests/should_succeed/type_invariants/generated.rs @@ -1,5 +1,5 @@ extern crate creusot_contracts; -use creusot_contracts::{*, invariant}; +use creusot_contracts::{invariant, *}; pub struct List(T, Option>>); From 74a9293be10b1115ff377e7d0a1a69189e69d388 Mon Sep 17 00:00:00 2001 From: Dominik Stolz Date: Wed, 14 Jun 2023 16:01:24 +0200 Subject: [PATCH 08/12] Address comments --- creusot-contracts/src/invariant.rs | 8 -------- creusot/src/backend/clone_map.rs | 17 ++++------------- creusot/src/backend/constant.rs | 2 +- creusot/src/backend/dependency.rs | 10 +++++++++- creusot/src/backend/interface.rs | 2 +- creusot/src/backend/logic.rs | 8 ++++---- creusot/src/backend/program.rs | 4 ++-- creusot/src/backend/traits.rs | 4 ++-- creusot/src/backend/ty.rs | 4 ++-- creusot/src/backend/ty_inv.rs | 6 +++--- 10 files changed, 28 insertions(+), 37 deletions(-) diff --git a/creusot-contracts/src/invariant.rs b/creusot-contracts/src/invariant.rs index df6d8d14f..119798e40 100644 --- a/creusot-contracts/src/invariant.rs +++ b/creusot-contracts/src/invariant.rs @@ -44,14 +44,6 @@ impl UserInv for T { } } -impl UserInv for i32 { - #[predicate] - #[open] - fn user_inv(self) -> bool { - pearlite! { self@ > 0 } - } -} - impl<'a, T: Invariant + ?Sized> Invariant for &'a T { #[predicate] #[open] diff --git a/creusot/src/backend/clone_map.rs b/creusot/src/backend/clone_map.rs index 8787b2f40..9a3bb8eb7 100644 --- a/creusot/src/backend/clone_map.rs +++ b/creusot/src/backend/clone_map.rs @@ -210,15 +210,7 @@ impl<'tcx> CloneInfo { } impl<'tcx> CloneMap<'tcx> { - pub(crate) fn new(tcx: TyCtxt<'tcx>, self_id: DefId, clone_level: CloneLevel) -> Self { - Self::new_with_tid(tcx, TransId::Item(self_id), clone_level) - } - - pub(crate) fn new_with_tid( - tcx: TyCtxt<'tcx>, - self_id: TransId, - clone_level: CloneLevel, - ) -> Self { + pub(crate) fn new(tcx: TyCtxt<'tcx>, self_id: TransId, clone_level: CloneLevel) -> Self { let mut names = IndexMap::new(); let self_id = match self_id { @@ -233,7 +225,7 @@ impl<'tcx> CloneMap<'tcx> { CloneNode::new(tcx, (self_id, subst)).erase_regions(tcx) } - TransId::TyInv(inv_kind) => CloneNode::TyInv(inv_kind.to_ty(tcx)), + TransId::TyInv(inv_kind) => CloneNode::TyInv(inv_kind.to_skeleton_ty(tcx)), }; debug!("cloning self: {:?}", self_id); @@ -295,8 +287,7 @@ impl<'tcx> CloneMap<'tcx> { }; } - let base = if let CloneNode::TyInv(ty) = key { - let inv_kind = TyInvKind::from_ty(ty); + let base = if let Some(inv_kind) = key.ty_inv_kind() { Symbol::intern(&*inv_module_name(self.tcx, inv_kind)) } else { let did = key.did().unwrap().0; @@ -457,7 +448,7 @@ impl<'tcx> CloneMap<'tcx> { } let inv_kind = TyInvKind::from_ty(ty); - if let CloneNode::TyInv(self_ty) = self.self_id && TyInvKind::from_ty(self_ty) == inv_kind { + if self.self_id.ty_inv_kind().is_some_and(|self_kind| self_kind == inv_kind) { return; } diff --git a/creusot/src/backend/constant.rs b/creusot/src/backend/constant.rs index fdfafea94..602ff59c0 100644 --- a/creusot/src/backend/constant.rs +++ b/creusot/src/backend/constant.rs @@ -28,7 +28,7 @@ impl<'tcx> Why3Generator<'tcx> { let param_env = self.param_env(def_id); let span = self.def_span(def_id); let res = from_ty_const(&mut self.ctx, constant, param_env, span); - let mut names = CloneMap::new(self.tcx, def_id, CloneLevel::Body); + let mut names = CloneMap::new(self.tcx, def_id.into(), CloneLevel::Body); let res = res.to_why(self, &mut names, &LocalDecls::new()); let sig = signature_of(self, &mut names, def_id); let mut decls: Vec<_> = closure_generic_decls(self.tcx, def_id).collect(); diff --git a/creusot/src/backend/dependency.rs b/creusot/src/backend/dependency.rs index 7b3f281e1..2a8a6b148 100644 --- a/creusot/src/backend/dependency.rs +++ b/creusot/src/backend/dependency.rs @@ -9,7 +9,7 @@ use crate::{ util::{self, ItemType}, }; -use super::ty_inv; +use super::ty_inv::{self, TyInvKind}; /// Dependencies between items and the resolution logic to find the 'monomorphic' forms accounting /// for various Creusot hacks like the handling of closures. @@ -57,6 +57,14 @@ impl<'tcx> Dependency<'tcx> { } } + pub(crate) fn ty_inv_kind(self) -> Option { + if let Dependency::TyInv(ty) = self { + Some(TyInvKind::from_ty(ty)) + } else { + None + } + } + pub(crate) fn is_inv(&self) -> bool { matches!(self, Dependency::TyInv(_)) } diff --git a/creusot/src/backend/interface.rs b/creusot/src/backend/interface.rs index d8ffb5a0a..03d75747c 100644 --- a/creusot/src/backend/interface.rs +++ b/creusot/src/backend/interface.rs @@ -21,7 +21,7 @@ pub(crate) fn interface_for<'tcx>( def_id: DefId, ) -> (Module, CloneSummary<'tcx>) { debug!("interface_for: {def_id:?}"); - let mut names = CloneMap::new(ctx.tcx, def_id, CloneLevel::Stub); + let mut names = CloneMap::new(ctx.tcx, def_id.into(), CloneLevel::Stub); let mut sig = signature_of(ctx, &mut names, def_id); sig.contract.variant = Vec::new(); diff --git a/creusot/src/backend/logic.rs b/creusot/src/backend/logic.rs index eae2678db..723db00ff 100644 --- a/creusot/src/backend/logic.rs +++ b/creusot/src/backend/logic.rs @@ -65,7 +65,7 @@ fn builtin_body<'tcx>( ctx: &mut Why3Generator<'tcx>, def_id: DefId, ) -> (Module, CloneSummary<'tcx>) { - let mut names = CloneMap::new(ctx.tcx, def_id, CloneLevel::Stub); + let mut names = CloneMap::new(ctx.tcx, def_id.into(), CloneLevel::Stub); let mut sig = signature_of(ctx, &mut names, def_id); let (val_args, val_binders) = binders_to_args(ctx, sig.args); sig.args = val_binders; @@ -133,7 +133,7 @@ pub(crate) fn val_decl<'tcx>( } fn body_module<'tcx>(ctx: &mut Why3Generator<'tcx>, def_id: DefId) -> (Module, CloneSummary<'tcx>) { - let mut names = CloneMap::new(ctx.tcx, def_id, CloneLevel::Stub); + let mut names = CloneMap::new(ctx.tcx, def_id.into(), CloneLevel::Stub); let mut sig = signature_of(ctx, &mut names, def_id); let mut val_sig = sig.clone(); @@ -198,7 +198,7 @@ fn body_module<'tcx>(ctx: &mut Why3Generator<'tcx>, def_id: DefId) -> (Module, C } pub(crate) fn stub_module(ctx: &mut Why3Generator, def_id: DefId) -> Module { - let mut names = CloneMap::new(ctx.tcx, def_id, CloneLevel::Stub); + let mut names = CloneMap::new(ctx.tcx, def_id.into(), CloneLevel::Stub); let mut sig = signature_of(ctx, &mut names, def_id); if util::is_predicate(ctx.tcx, def_id) { @@ -225,7 +225,7 @@ fn proof_module(ctx: &mut Why3Generator, def_id: DefId) -> Option { return None; } - let mut names = CloneMap::new(ctx.tcx, def_id, CloneLevel::Body); + let mut names = CloneMap::new(ctx.tcx, def_id.into(), CloneLevel::Body); let mut sig = signature_of(ctx, &mut names, def_id); diff --git a/creusot/src/backend/program.rs b/creusot/src/backend/program.rs index c1dc2b509..1e638c5c1 100644 --- a/creusot/src/backend/program.rs +++ b/creusot/src/backend/program.rs @@ -37,7 +37,7 @@ use why3::{ use super::signature::sig_to_why3; fn closure_ty<'tcx>(ctx: &mut Why3Generator<'tcx>, def_id: DefId) -> Module { - let mut names = CloneMap::new(ctx.tcx, def_id, CloneLevel::Body); + let mut names = CloneMap::new(ctx.tcx, def_id.into(), CloneLevel::Body); let mut decls = Vec::new(); let TyKind::Closure(_, subst) = ctx.tcx.type_of(def_id).subst_identity().kind() else { unreachable!() }; @@ -152,7 +152,7 @@ pub(crate) fn translate_function<'tcx, 'sess>( def_id: DefId, ) -> Option { let tcx = ctx.tcx; - let mut names = CloneMap::new(tcx, def_id, CloneLevel::Body); + let mut names = CloneMap::new(tcx, def_id.into(), CloneLevel::Body); let body_ids = collect_body_ids(ctx, def_id)?; let body = to_why(ctx, &mut names, body_ids[0]); diff --git a/creusot/src/backend/traits.rs b/creusot/src/backend/traits.rs index 40e35ce5f..d3e13499d 100644 --- a/creusot/src/backend/traits.rs +++ b/creusot/src/backend/traits.rs @@ -16,7 +16,7 @@ pub(crate) fn lower_impl<'tcx>(ctx: &mut Why3Generator<'tcx>, def_id: DefId) -> let tcx = ctx.tcx; let data = ctx.trait_impl(def_id).clone(); - let mut names = CloneMap::new(ctx.tcx, def_id, CloneLevel::Body); + let mut names = CloneMap::new(ctx.tcx, def_id.into(), CloneLevel::Body); let mut impl_decls = Vec::new(); for refn in &data.refinements { @@ -41,7 +41,7 @@ impl<'tcx> Why3Generator<'tcx> { pub(crate) fn translate_assoc_ty(&mut self, def_id: DefId) -> (Module, CloneSummary<'tcx>) { assert_eq!(util::item_type(self.tcx, def_id), ItemType::AssocTy); - let mut names = CloneMap::new(self.tcx, def_id, CloneLevel::Interface); + let mut names = CloneMap::new(self.tcx, def_id.into(), CloneLevel::Interface); let mut decls: Vec<_> = all_generic_decls_for(self.tcx, def_id).collect(); let name = item_name(self.tcx, def_id, Namespace::TypeNS); diff --git a/creusot/src/backend/ty.rs b/creusot/src/backend/ty.rs index c99c0e733..91bf627e6 100644 --- a/creusot/src/backend/ty.rs +++ b/creusot/src/backend/ty.rs @@ -291,7 +291,7 @@ pub(crate) fn translate_tydecl( return None; } - let mut names = CloneMap::new(ctx.tcx, repr, CloneLevel::Stub); + let mut names = CloneMap::new(ctx.tcx, repr.into(), CloneLevel::Stub); let name = module_name(ctx.tcx, repr); let span = ctx.def_span(repr); @@ -432,7 +432,7 @@ pub(crate) fn translate_accessor( let substs = InternalSubsts::identity_for_item(ctx.tcx, adt_did); let repr = ctx.representative_type(adt_did); - let mut names = CloneMap::new(ctx.tcx, repr, CloneLevel::Stub); + let mut names = CloneMap::new(ctx.tcx, repr.into(), CloneLevel::Stub); // UGLY hack to ensure that we don't explicitly use/clone the members of a binding group let bg = ctx.binding_group(repr).clone(); diff --git a/creusot/src/backend/ty_inv.rs b/creusot/src/backend/ty_inv.rs index a5e1d62e2..ce23d77ee 100644 --- a/creusot/src/backend/ty_inv.rs +++ b/creusot/src/backend/ty_inv.rs @@ -38,7 +38,7 @@ impl TyInvKind { } } - pub(crate) fn to_ty<'tcx>(self, tcx: TyCtxt<'tcx>) -> Ty<'tcx> { + pub(crate) fn to_skeleton_ty<'tcx>(self, tcx: TyCtxt<'tcx>) -> Ty<'tcx> { match self { TyInvKind::Trivial => tcx.mk_ty_param(0, Symbol::intern("T")), TyInvKind::Borrow => { @@ -82,7 +82,7 @@ pub(crate) fn build_inv_module<'tcx>( ctx: &mut Why3Generator<'tcx>, inv_kind: TyInvKind, ) -> (Module, CloneSummary<'tcx>) { - let mut names = CloneMap::new_with_tid(ctx.tcx, TransId::TyInv(inv_kind), CloneLevel::Stub); + let mut names = CloneMap::new(ctx.tcx, TransId::TyInv(inv_kind), CloneLevel::Stub); let generics = inv_kind.generics(ctx.tcx); let inv_axiom = build_inv_axiom(ctx, &mut names, inv_kind); @@ -119,7 +119,7 @@ fn build_inv_axiom<'tcx>( let param_env = if let TyInvKind::Adt(did) = inv_kind { ctx.param_env(did) } else { ParamEnv::empty() }; - let ty = inv_kind.to_ty(ctx.tcx); + let ty = inv_kind.to_skeleton_ty(ctx.tcx); let lhs: Exp = Exp::impure_qvar(names.ty_inv(ty)).app_to(Exp::pure_var("self".into())); let rhs = if TyInvKind::Trivial == inv_kind { Exp::mk_true() From 413456d4b5bc66561d38ebda40e70d18436a469d Mon Sep 17 00:00:00 2001 From: Dominik Stolz Date: Wed, 14 Jun 2023 16:26:12 +0200 Subject: [PATCH 09/12] Make self_id a TransId --- creusot/src/backend/clone_map.rs | 44 +++++++++++++------------------ creusot/src/backend/dependency.rs | 26 +++++++++++++++--- 2 files changed, 41 insertions(+), 29 deletions(-) diff --git a/creusot/src/backend/clone_map.rs b/creusot/src/backend/clone_map.rs index 9a3bb8eb7..156a29697 100644 --- a/creusot/src/backend/clone_map.rs +++ b/creusot/src/backend/clone_map.rs @@ -10,9 +10,8 @@ use rustc_hir::{ def_id::DefId, }; use rustc_middle::ty::{ - self, - subst::{InternalSubsts, SubstsRef}, - AliasKind, ParamEnv, Ty, TyCtxt, TyKind, TypeFoldable, TypeSuperVisitable, TypeVisitor, + self, subst::SubstsRef, AliasKind, ParamEnv, Ty, TyCtxt, TyKind, TypeFoldable, + TypeSuperVisitable, TypeVisitor, }; use rustc_span::{Symbol, DUMMY_SP}; use rustc_target::abi::FieldIdx; @@ -108,8 +107,8 @@ pub struct CloneMap<'tcx> { // - Body: Will directly use the full body of dependencies, except for program functions clone_level: CloneLevel, - // DefId of the item which is cloning. Used for trait resolution - self_id: CloneNode<'tcx>, // TODO should this be a TransId? + // TransId of the item which is cloning. Used for trait resolution + self_id: TransId, // TODO: Push the graph into an opaque type with tight api boundary // Graph which is used to calculate the full clone set clone_graph: DiGraphMap, IndexSet<(Kind, SymbolKind)>>, @@ -213,23 +212,8 @@ impl<'tcx> CloneMap<'tcx> { pub(crate) fn new(tcx: TyCtxt<'tcx>, self_id: TransId, clone_level: CloneLevel) -> Self { let mut names = IndexMap::new(); - let self_id = match self_id { - TransId::Item(self_id) => { - let subst = match tcx.def_kind(self_id) { - DefKind::Closure => match tcx.type_of(self_id).subst_identity().kind() { - TyKind::Closure(_, subst) => subst, - _ => unreachable!(), - }, - _ => InternalSubsts::identity_for_item(tcx, self_id), - }; - - CloneNode::new(tcx, (self_id, subst)).erase_regions(tcx) - } - TransId::TyInv(inv_kind) => CloneNode::TyInv(inv_kind.to_skeleton_ty(tcx)), - }; - debug!("cloning self: {:?}", self_id); - names.insert(self_id, CloneInfo::hidden()); + names.insert(CloneNode::from_trans_id(tcx, self_id), CloneInfo::hidden()); CloneMap { tcx, @@ -374,8 +358,15 @@ impl<'tcx> CloneMap<'tcx> { self.value(def_id, subst) } + fn self_key(&self) -> CloneNode<'tcx> { + CloneNode::from_trans_id(self.tcx, self.self_id) + } + fn self_did(&self) -> Option { - self.self_id.did().map(|(self_did, _)| self_did) + match self.self_id { + TransId::Item(did) | TransId::TyInv(TyInvKind::Adt(did)) => Some(did), + _ => None, + } } fn param_env(&self, ctx: &TranslationCtx<'tcx>) -> ParamEnv<'tcx> { @@ -412,8 +403,9 @@ impl<'tcx> CloneMap<'tcx> { i += 1; trace!("update graph with {:?} (public={:?})", key, self.names[&key].public); - if key != self.self_id { - self.add_graph_edge(self.self_id, key); + let self_key = self.self_key(); + if key != self_key { + self.add_graph_edge(self_key, key); } if self.names[&key].kind == Kind::Hidden { @@ -448,7 +440,7 @@ impl<'tcx> CloneMap<'tcx> { } let inv_kind = TyInvKind::from_ty(ty); - if self.self_id.ty_inv_kind().is_some_and(|self_kind| self_kind == inv_kind) { + if let TransId::TyInv(self_kind) = self.self_id && self_kind == inv_kind { return; } @@ -674,7 +666,7 @@ impl<'tcx> CloneMap<'tcx> { // Broken because of closures which share a defid for the type *and* function // debug_assert!(!is_cyclic_directed(&self.clone_graph), "clone graph for {:?} is cyclic", self.self_id ); - let mut topo = DfsPostOrder::new(&self.clone_graph, self.self_id); + let mut topo = DfsPostOrder::new(&self.clone_graph, self.self_key()); while let Some(node) = topo.walk_next(&self.clone_graph) { trace!("processing node {:?}", self.names[&node].kind); diff --git a/creusot/src/backend/dependency.rs b/creusot/src/backend/dependency.rs index 2a8a6b148..6b1165bd3 100644 --- a/creusot/src/backend/dependency.rs +++ b/creusot/src/backend/dependency.rs @@ -1,5 +1,5 @@ -use rustc_hir::def_id::DefId; -use rustc_middle::ty::{EarlyBinder, ParamEnv, SubstsRef, Ty, TyCtxt, TyKind}; +use rustc_hir::{def::DefKind, def_id::DefId}; +use rustc_middle::ty::{EarlyBinder, InternalSubsts, ParamEnv, SubstsRef, Ty, TyCtxt, TyKind}; use rustc_span::Symbol; use rustc_type_ir::AliasKind; @@ -9,7 +9,10 @@ use crate::{ util::{self, ItemType}, }; -use super::ty_inv::{self, TyInvKind}; +use super::{ + ty_inv::{self, TyInvKind}, + TransId, +}; /// Dependencies between items and the resolution logic to find the 'monomorphic' forms accounting /// for various Creusot hacks like the handling of closures. @@ -33,6 +36,23 @@ impl<'tcx> Dependency<'tcx> { } } + pub(crate) fn from_trans_id(tcx: TyCtxt<'tcx>, trans_id: TransId) -> Self { + match trans_id { + TransId::Item(self_id) => { + let subst = match tcx.def_kind(self_id) { + DefKind::Closure => match tcx.type_of(self_id).subst_identity().kind() { + TyKind::Closure(_, subst) => subst, + _ => unreachable!(), + }, + _ => InternalSubsts::identity_for_item(tcx, self_id), + }; + + Dependency::new(tcx, (self_id, subst)).erase_regions(tcx) + } + TransId::TyInv(inv_kind) => Dependency::TyInv(inv_kind.to_skeleton_ty(tcx)), + } + } + pub(crate) fn resolve( self, ctx: &TranslationCtx<'tcx>, From c93c37b6f09f28688ae8852510c602dbb37bb7a7 Mon Sep 17 00:00:00 2001 From: Dominik Stolz Date: Wed, 14 Jun 2023 14:59:42 +0200 Subject: [PATCH 10/12] Update proofs --- creusot/tests/should_fail/cycle.stderr | 2 +- creusot/tests/should_succeed/all_zero.mlcfg | 31 - .../should_succeed/all_zero/why3session.xml | 2 +- .../should_succeed/all_zero/why3shapes.gz | Bin 403 -> 403 bytes creusot/tests/should_succeed/bdd.mlcfg | 10 +- .../tests/should_succeed/binary_search.mlcfg | 35 +- .../binary_search/why3session.xml | 4 +- .../binary_search/why3shapes.gz | Bin 2056 -> 2056 bytes creusot/tests/should_succeed/bug/387.mlcfg | 35 +- creusot/tests/should_succeed/cell/02.mlcfg | 6 +- creusot/tests/should_succeed/hashmap.mlcfg | 19 +- .../should_succeed/hashmap/why3session.xml | 58 +- .../should_succeed/hashmap/why3shapes.gz | Bin 6080 -> 6084 bytes .../tests/should_succeed/ite_normalize.mlcfg | 2 +- .../should_succeed/iterators/01_range.mlcfg | 10 +- .../iterators/02_iter_mut.mlcfg | 16 +- .../iterators/03_std_iterators.mlcfg | 36 +- .../should_succeed/iterators/04_skip.mlcfg | 22 +- .../should_succeed/iterators/05_map.mlcfg | 18 +- .../should_succeed/iterators/05_take.mlcfg | 18 +- .../iterators/06_map_precond.mlcfg | 36 +- .../should_succeed/iterators/07_fuse.mlcfg | 28 +- .../iterators/08_collect_extend.mlcfg | 24 +- .../iterators/08_collect_extend/why3shapes.gz | Bin 2713 -> 2711 bytes .../should_succeed/iterators/09_empty.mlcfg | 10 +- .../should_succeed/iterators/10_once.mlcfg | 10 +- .../should_succeed/iterators/11_repeat.mlcfg | 10 +- .../should_succeed/iterators/12_zip.mlcfg | 20 +- .../should_succeed/iterators/13_cloned.mlcfg | 22 +- .../should_succeed/iterators/14_copied.mlcfg | 22 +- .../iterators/15_enumerate.mlcfg | 30 +- .../tests/should_succeed/list_index_mut.mlcfg | 43 +- .../list_index_mut/why3session.xml | 2 +- .../list_index_mut/why3shapes.gz | Bin 671 -> 670 bytes .../tests/should_succeed/red_black_tree.mlcfg | 439 ++--- .../red_black_tree/why3session.xml | 1413 +++++++++++++---- .../red_black_tree/why3shapes.gz | Bin 37216 -> 47711 bytes creusot/tests/should_succeed/replace.mlcfg | 31 - .../rusthorn/inc_some_2_list.mlcfg | 33 +- .../rusthorn/inc_some_2_list/why3session.xml | 2 +- .../rusthorn/inc_some_2_list/why3shapes.gz | Bin 952 -> 953 bytes .../rusthorn/inc_some_2_tree.mlcfg | 33 +- .../rusthorn/inc_some_2_tree/why3session.xml | 3 +- .../rusthorn/inc_some_2_tree/why3shapes.gz | Bin 1085 -> 1085 bytes .../rusthorn/inc_some_list.mlcfg | 33 +- .../rusthorn/inc_some_list/why3session.xml | 2 +- .../rusthorn/inc_some_list/why3shapes.gz | Bin 880 -> 878 bytes .../rusthorn/inc_some_tree.mlcfg | 33 +- .../rusthorn/inc_some_tree/why3session.xml | 2 +- .../rusthorn/inc_some_tree/why3shapes.gz | Bin 951 -> 951 bytes .../syntax/10_mutual_rec_types.mlcfg | 35 +- .../type_invariants/borrows.mlcfg | 14 +- .../type_invariants/generated.mlcfg | 11 +- .../vector/06_knights_tour.mlcfg | 14 +- 54 files changed, 1546 insertions(+), 1133 deletions(-) diff --git a/creusot/tests/should_fail/cycle.stderr b/creusot/tests/should_fail/cycle.stderr index 8be9abb0b..bb5442039 100644 --- a/creusot/tests/should_fail/cycle.stderr +++ b/creusot/tests/should_fail/cycle.stderr @@ -6,7 +6,7 @@ warning: unused import: `creusot_contracts::*` | = note: `#[warn(unused_imports)]` on by default -error[creusot]: encountered a cycle during translation: [{DefId(0:5 ~ cycle[c4ca]::f)}, {DefId(0:6 ~ cycle[c4ca]::g)}, {DefId(0:5 ~ cycle[c4ca]::f)}] +error[creusot]: encountered a cycle during translation: [{Item(DefId(0:5 ~ cycle[c4ca]::f))}, {Item(DefId(0:6 ~ cycle[c4ca]::g))}, {Item(DefId(0:5 ~ cycle[c4ca]::f))}] --> cycle.rs:4:1 | 4 | pub fn f() { diff --git a/creusot/tests/should_succeed/all_zero.mlcfg b/creusot/tests/should_succeed/all_zero.mlcfg index f4152e3ef..f67c51f3d 100644 --- a/creusot/tests/should_succeed/all_zero.mlcfg +++ b/creusot/tests/should_succeed/all_zero.mlcfg @@ -104,35 +104,6 @@ module CreusotContracts_Resolve_Impl1_Resolve val resolve (self : borrowed t) : bool ensures { result = resolve self } -end -module Core_Ptr_NonNull_NonNull_Type - use prelude.Opaque - type t_nonnull 't = - | C_NonNull opaque_ptr - -end -module Core_Marker_PhantomData_Type - type t_phantomdata 't = - | C_PhantomData - -end -module Core_Ptr_Unique_Unique_Type - use Core_Marker_PhantomData_Type as Core_Marker_PhantomData_Type - use Core_Ptr_NonNull_NonNull_Type as Core_Ptr_NonNull_NonNull_Type - type t_unique 't = - | C_Unique (Core_Ptr_NonNull_NonNull_Type.t_nonnull 't) (Core_Marker_PhantomData_Type.t_phantomdata 't) - -end -module Alloc_Boxed_Box_Type - use Core_Ptr_Unique_Unique_Type as Core_Ptr_Unique_Unique_Type - type t_box 't 'a = - | C_Box (Core_Ptr_Unique_Unique_Type.t_unique 't) 'a - -end -module Alloc_Alloc_Global_Type - type t_global = - | C_Global - end module AllZero_AllZero_Interface use prelude.Int @@ -152,9 +123,7 @@ module AllZero_AllZero use prelude.Borrow use prelude.Int use prelude.UInt32 - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type use AllZero_List_Type as AllZero_List_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type clone CreusotContracts_Resolve_Impl1_Resolve as Resolve2 with type t = AllZero_List_Type.t_list clone CreusotContracts_Resolve_Impl1_Resolve as Resolve1 with diff --git a/creusot/tests/should_succeed/all_zero/why3session.xml b/creusot/tests/should_succeed/all_zero/why3session.xml index f1e6ba251..ec3504850 100644 --- a/creusot/tests/should_succeed/all_zero/why3session.xml +++ b/creusot/tests/should_succeed/all_zero/why3session.xml @@ -7,7 +7,7 @@ - + diff --git a/creusot/tests/should_succeed/all_zero/why3shapes.gz b/creusot/tests/should_succeed/all_zero/why3shapes.gz index e0c43d4138a4a5713bdeae3b69e0d368220c5f38..8f1223c25dcfa2df88ac65cfb2bf497d7fc0b93a 100644 GIT binary patch literal 403 zcmV;E0c`#siwFP!00000|BaHtPJ}QJhVMKDH`5k?O|p67BeTh+-|dFnbfAe~Q< zJC!btkS!VgbI`$eb-8Mg5}8*o{aMwdlsj|uChaCEjBVpu2DeXb2yd9ei-^mz1^KZ4L*_0sgo^&Vd#PcLCp4=FU)7frU>y|6t5{Y zu?VpcxMz`9dEbo))R=*-%nBFBX3{3vEYwXBXH8_S(-oNHjLkNv8YwWfO#Y8K-&bI4 ziSYs?CgUon$v#_z#6BPSdoe^>t_`#Exrm5V^Mz!)?p4wLRNX;p5 zr`)9xk~yP)4m$XuE;kKQBGclnJFAN1ayK1Ul!M&uE26_$?xY%n6xJ$OILrdjf?f?> zb5#hj7EdyWZc#vBCLGJM>-%n0$A|ORgpXu>YGs2kF?2zMAdJ1{i|MmqQv_~`_>xi) zix4w`tt`?a?b-o>PG(>$lg!1j9<@nggt|%Mtck32x_~KZu*n8hBL&8m$^J3TeFbt$ z=8CN-u_Spg?_W8))qoJNFT@RkRVmEi1<(I{bne)AGRhY%GjYSF9&f)f=go{OC zNZDGn;LqhO%MSN8XB{!zXpXOa_;z!A(OigBtVQC+pUda%3DK;8cCq`2 - + - + diff --git a/creusot/tests/should_succeed/binary_search/why3shapes.gz b/creusot/tests/should_succeed/binary_search/why3shapes.gz index 1f472fda461ba109cf1830f558f21940947db327..0b6b89003ab5a6bd57607f0f8bdf5edccaf707f4 100644 GIT binary patch delta 2052 zcmV+f2>bVl5Qq?v8h_64zDNrgK@8=k=V1@@YETr}8k@$2onFrQ^*f|&iNd4I`hdBpoiEOmZlwM&4g<5CuI$N~*T2fU~$PMIh)vCtGn1Q`j@K@OL9 z3D}D|aN@=0aR@&fqLh1g6f}jPEtSUns{+CirA&z`ftsupOEJsee6vWDOcvDnwx?r?!iuc0S(aiYY=68)W1`v!_Xs=sM8li1$iM^3 z|H^V~DjDZ?yQ5U&Hv9E{yL$>ldfj~81;S(4JW(%b>f^etC-EaRZd)5nJ1h6F5AKiM zw@~NksJYE>6=HJ_`^{gWa*|%0`{~_2i``7vjgp7wv|noxpQ%$7qRqp0`;{2^-R(B+ z@rj-`Pk&^v3}#akenXxLsqhfKT&J14=}hy!iirw# z7Sk#P{jNIr1wb~7djGo2u21yB-p4*C>z0;W5+P<5&^Lo#tb?7=Je3H)$p>`ac(ch21voj*3%zBbjq= z*wAzM6n2X(jrI7j{n6C*_}M+g=Tx8Rorg2ejLhtQ*$h`HoyeFJYF2!F2ELmYsdT(j zxV3Rl7cAc)oce@?kOo|2I^6cVS-A%NIyNXZg@-c5>nR_vl zk8YvMeD^pKGu?#K#&UYB$$i1#-Dsk-`G3K7CjCBM&&`aFoxWSv<=H6@%Qy8};8n9N zZ|n1JOE?}L)Fe(9r|ZUtczu3|Dh;FMcV|BJ^Ze~phL3Lb`M2nJhVgW_o+;Ls$oxrF z<`tLYhgH7doid6S?o~;u^aL+^O47gI-o`@*JCO7D|8xik&oX-wCq^A6(Q8AaNgy}`x&i}y_Hv}>LIRP;1y0&n@tMWG7I&kd)^6D_p=#4vdV`3 z^VsaO@Yn7Bskm&8~pW11C-8=fewnehb6?57?g=d$gSK3+K zmmLr7s)*xf6oe6maP!PfJ^zU0f!ro)l2I5MT< zJo({xU^73tK0MB-RNY7qR3c?gr$7E-qTf8a-Jff6w)3BxMgd4}WN?l#483+-$cViY zz2^#|T0qMh4?#UZ}t%v&bdJC`luN>VvhMFEneFCBYc23rsnMRvX1b-=pL~%SbF3VjmW^ z)vci)Y?zH^=;c8FYb~t<%Ld6E2M#LqIAl@aEno}K0z0U=C=rDn0)Ip{XwQd0A!Fo( zgD{bY1(+5{QMDjj5Em>UkG2=V%Aln0nI#-K*G~IB+CfO2EFf#azGi12X(oFOEE+Fa zv|@0IG7*dtj1Sq4XpwNn7U4B(x(5x;4LbBz8A4w~a6J!!YfE+)oVOfX4lQRb64qp# z^i+%TC9|rRj#Ab~L4QmzW>9JHE7?b4htWY~v*In5``&@TKtI4`bY^g1n3viM3$%p` zu39eNXxs&g4+b_MQox*A5Rb|Tp$s>~Lz9i0mg~0|kJN}FL@Jzts>WIj2DJsHJ#kwo zMa&bd<@Sx{buX-hFfcz176)OBWrR|cY8a@jvUzL;T%AG-mVX;#(BN2yegLXtu-;hC zqDWW>(+b@RdXTLUt>FKIeaE!cENW|`3PLgPVju!?FBnK;`($5YE1{LF7544Gc!`!t zX^~ot)J|&a&DrglQ)*egO^wi)%P+tyUfWk90Qe@Y0R`E%fSmIb5s0(vy iOHTM+pz|^MV7#SHlXdekmC3rgQvWaSmM$kr8vp=CI13B_ delta 2052 zcmV+f2>bVl5Qq?v8h;M&T%-kzAcpeN^RNecH7H(MVbi#<)5|%(eutE0k+PF`gKmM; zqB%Ey^UVz9zyG#6e70Z1Vf8)i55w;9Un{x#?H`T(@V)~_?r$xA+IJ2*woczMNAB$H z_ICGp_|e%cgUgS@Lq|57rn_Cm-G22D9=8v>PlHQl>}k~zM}IcW?O@-d%D;DCLTBu! z@PziCcH80csiXIH9}c^R@1axoXxwyabNUK8jf#~#8<(dwV2n5OqVNom>;db5qQ&?2 z8%jw2w=75PKg+dnuvy#Taog{{J^I7hW;O&JkTNtNWt>@rbb3>q$9|~o%nG!VNkLnO zpl+d)DMD1pOMimP3GW}V)cKLsE&(E^r6}MK1sW0$cu|v|GEr#KLX#H}WF&Y8Ib7By zU@z*xi5J784?i2Elzle|>O#a6t0E zvK*UA#@hXUl4|U5*dBKKr{L4q&DVWEJpAy4y`ZU&Yj+OCCur=hHkfuc_TdohANy~i z&e5c~%WxH9OAm+PuTVKjU!42t?IDZZ%-D^R$LF+PYaySpQx&4k!*2H#8TsAr2mAPh zPs0-$EPsO;%0)7n9j5OX&EH|kY<-CK+rv}xF_|CGQy~=|!k6nbb2nXR-d8bU!7gIj zq@dqb2fqNw(41-$kF~(_X6f^~Gd4>|;XENw1_o!2|4*2}=1qr6)pWUs9T`;P43`dy zZLq0Y{kZEO(RNG4R2+_GnmamH#I)0VEEj(GK7XW{yz2j4{T24Rv^y%!?G0tlz0n4r z!>6!c?QpEehux2+uE)>zAwH-2Oz%9Nd0}K>_sig~QaX__Db%d^_zZkEFH&i`QrInr zl-`o7Ss{tIFJIICfFOm6`s>~~0 zk1tmFf_KU&y>PEeQl%$&*;A7K{q{B9m2w>&`VJ;4c+SJ`q z8PxcsI*?^8gRBn>;;fRf|1K)|iiA_Bix`$Ee>Z!a8~rSPUCJrFkn<9HT7Lt-7!0#R zSWiJ+^@?{p&VInLYnbI+q z{4jcCGdsCHJ}#(K-AIpALS=@hpMIF=hex~rbBoUQ?sL;f0Kv2f))GQPuPoyt(%$mk zF$qzwpe2px#)6_kQbP#0+J8nFwCHy>N;iuGvLIW7Yc#84(^j3O|IAp2kpV=F~kX_CEYY#`F2Tcsrn=uohrL_`+&*oT#A zRjcujHpE2jd*Shar36N6h!@Ne#&e;P1xi{lui5b^O+>GNMC}BL zhI=b96G2N(n9p{2OA%+Oq0EUWMLBZ3W>GY|lbq%Anm9V=bdCgO-t&BGzae z^<+!MOJ-#+ET*iFoPPq*+RHTfrRbwHpjF`6EPspTzPG?>z&~IjTJ0@p;)HVC0B+G0 zlPwc(G;RaN2cCFJF<^!*h()P6mzrthq0Yv2%hX$pM{Gn9A{LIvsxgKJO_c$u9CDjW ziOl1qW#*0MRnLup;ED6zP^=|w2%;2)^d6$k=4s2}>J%C++`JtaC$Jd_ zVW@~gC@Yk))Nm^p^LV&kuY_m?Zw31WzPMN1@E{Q{?mYG(7liYcAY&0h>5?xjav^`2 zM`nU@LI*3TWPQR#Cp9)S>P%1ih$A$6%a43O_5T7mi)eF68vp=I3j#j? diff --git a/creusot/tests/should_succeed/bug/387.mlcfg b/creusot/tests/should_succeed/bug/387.mlcfg index 5dd1d377d..73fee43aa 100644 --- a/creusot/tests/should_succeed/bug/387.mlcfg +++ b/creusot/tests/should_succeed/bug/387.mlcfg @@ -10,40 +10,9 @@ module Core_Option_Option_Type | C_Some a -> a end end -module Core_Ptr_NonNull_NonNull_Type - use prelude.Opaque - type t_nonnull 't = - | C_NonNull opaque_ptr - -end -module Core_Marker_PhantomData_Type - type t_phantomdata 't = - | C_PhantomData - -end -module Core_Ptr_Unique_Unique_Type - use Core_Marker_PhantomData_Type as Core_Marker_PhantomData_Type - use Core_Ptr_NonNull_NonNull_Type as Core_Ptr_NonNull_NonNull_Type - type t_unique 't = - | C_Unique (Core_Ptr_NonNull_NonNull_Type.t_nonnull 't) (Core_Marker_PhantomData_Type.t_phantomdata 't) - -end -module Alloc_Boxed_Box_Type - use Core_Ptr_Unique_Unique_Type as Core_Ptr_Unique_Unique_Type - type t_box 't 'a = - | C_Box (Core_Ptr_Unique_Unique_Type.t_unique 't) 'a - -end -module Alloc_Alloc_Global_Type - type t_global = - | C_Global - -end module C387_Node_Type use prelude.Int use prelude.UInt32 - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type use Core_Option_Option_Type as Core_Option_Option_Type type t_node = | C_Node (t_tree) uint32 (t_tree) @@ -328,9 +297,6 @@ module C387_Impl0_Height clone CreusotContracts_Logic_Ord_Impl2_LeLog as LeLog0 clone CreusotContracts_Logic_Ord_Impl2_GeLog as GeLog0 clone CreusotContracts_Std1_Num_Impl10_DeepModel as DeepModel0 - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use C387_Node_Type as C387_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type clone Core_Cmp_Ord_Max_Interface as Max0 with type self = uint64, function DeepModel0.deep_model = DeepModel0.deep_model, @@ -338,6 +304,7 @@ module C387_Impl0_Height predicate LeLog0.le_log = LeLog0.le_log, predicate LtLog0.lt_log = LtLog0.lt_log, type DeepModelTy0.deepModelTy = int + use C387_Node_Type as C387_Node_Type use Core_Option_Option_Type as Core_Option_Option_Type use C387_Tree_Type as C387_Tree_Type let rec cfg height [#"../387.rs" 16 4 16 31] [@cfg:stackify] [@cfg:subregion_analysis] (self : C387_Tree_Type.t_tree) : uint64 diff --git a/creusot/tests/should_succeed/cell/02.mlcfg b/creusot/tests/should_succeed/cell/02.mlcfg index e733e32f8..a517ea1e9 100644 --- a/creusot/tests/should_succeed/cell/02.mlcfg +++ b/creusot/tests/should_succeed/cell/02.mlcfg @@ -227,14 +227,14 @@ module C02_Impl1_Inv use prelude.Borrow use prelude.Int use prelude.UIntSize - clone C02_Fib_Stub as Fib1 with + clone C02_Fib_Stub as Fib0 with axiom . use Core_Option_Option_Type as Core_Option_Option_Type use C02_Fib_Type as C02_Fib_Type predicate inv [#"../02.rs" 70 4 70 43] (self : C02_Fib_Type.t_fib) (v : Core_Option_Option_Type.t_option usize) = [#"../02.rs" 72 12 75 13] match (v) with | Core_Option_Option_Type.C_None -> true - | Core_Option_Option_Type.C_Some i -> UIntSize.to_int i = Fib1.fib (UIntSize.to_int (C02_Fib_Type.fib_ix self)) + | Core_Option_Option_Type.C_Some i -> UIntSize.to_int i = Fib0.fib (UIntSize.to_int (C02_Fib_Type.fib_ix self)) end val inv [#"../02.rs" 70 4 70 43] (self : C02_Fib_Type.t_fib) (v : Core_Option_Option_Type.t_option usize) : bool ensures { result = inv self v } @@ -665,7 +665,7 @@ module C02_FibMemo clone C02_Fib as Fib0 with axiom . clone C02_Impl1_Inv as Inv0 with - function Fib1.fib = Fib0.fib + function Fib0.fib = Fib0.fib clone CreusotContracts_Std1_Slice_Impl5_HasValue as HasValue0 with type t = C02_Cell_Type.t_cell (Core_Option_Option_Type.t_option usize) (C02_Fib_Type.t_fib) clone CreusotContracts_Std1_Slice_Impl5_InBounds as InBounds0 with diff --git a/creusot/tests/should_succeed/hashmap.mlcfg b/creusot/tests/should_succeed/hashmap.mlcfg index e04b9b774..44a0dc8cf 100644 --- a/creusot/tests/should_succeed/hashmap.mlcfg +++ b/creusot/tests/should_succeed/hashmap.mlcfg @@ -1215,21 +1215,15 @@ module CreusotContracts_Std1_Slice_Impl5_ResolveElswhere val resolve_elswhere [@inline:trivial] (self : usize) (old' : Seq.seq t) (fin : Seq.seq t) : bool ensures { result = resolve_elswhere self old' fin } -end -module Alloc_Boxed_Box_Type - use Core_Ptr_Unique_Unique_Type as Core_Ptr_Unique_Unique_Type - type t_box 't 'a = - | C_Box (Core_Ptr_Unique_Unique_Type.t_unique 't) 'a - end module Hashmap_Impl5_Add_Interface type k type v use prelude.Borrow use map.Map + use Core_Option_Option_Type as Core_Option_Option_Type clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with type self = k - use Core_Option_Option_Type as Core_Option_Option_Type use map.Map use Hashmap_MyHashMap_Type as Hashmap_MyHashMap_Type clone CreusotContracts_Model_Impl3_ShallowModel_Stub as ShallowModel1 with @@ -1265,9 +1259,9 @@ module Hashmap_Impl5_Add use prelude.Borrow use map.Map use seq.Seq + use Core_Option_Option_Type as Core_Option_Option_Type clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with type self = k - use Core_Option_Option_Type as Core_Option_Option_Type use map.Map use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type use Hashmap_List_Type as Hashmap_List_Type @@ -1300,7 +1294,6 @@ module Hashmap_Impl5_Add type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, function BucketIx0.bucket_ix = BucketIx0.bucket_ix, function IndexLogic0.index_logic = IndexLogic0.index_logic - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type use prelude.Ghost clone CreusotContracts_Std1_Slice_Impl5_ResolveElswhere as ResolveElswhere0 with type t = Hashmap_List_Type.t_list (k, v) @@ -1696,7 +1689,6 @@ module Hashmap_Impl5_Get type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, function Get0.get = Get0.get, function BucketIx0.bucket_ix = BucketIx0.bucket_ix - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type clone CreusotContracts_Std1_Slice_Impl5_HasValue as HasValue0 with type t = Hashmap_List_Type.t_list (k, v) clone CreusotContracts_Std1_Slice_Impl5_InBounds as InBounds0 with @@ -1902,9 +1894,9 @@ module Hashmap_Impl5_Resize_Interface use seq.Seq use prelude.Int use map.Map + use Core_Option_Option_Type as Core_Option_Option_Type clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with type self = k - use Core_Option_Option_Type as Core_Option_Option_Type use map.Map use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type use Hashmap_List_Type as Hashmap_List_Type @@ -1942,20 +1934,19 @@ module Hashmap_Impl5_Resize use prelude.Borrow use map.Map use seq.Seq - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use Hashmap_List_Type as Hashmap_List_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with type self = k clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel0 with type self = k, type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Hashmap_List_Type as Hashmap_List_Type clone CreusotContracts_Std1_Slice_Impl5_ResolveElswhere as ResolveElswhere0 with type t = Hashmap_List_Type.t_list (k, v) clone CreusotContracts_Std1_Slice_Impl5_HasValue as HasValue0 with type t = Hashmap_List_Type.t_list (k, v) clone CreusotContracts_Std1_Slice_Impl5_InBounds as InBounds0 with type t = Hashmap_List_Type.t_list (k, v) + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type clone Core_Num_Impl11_Max as Max0 clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Interface as ShallowModel2 with diff --git a/creusot/tests/should_succeed/hashmap/why3session.xml b/creusot/tests/should_succeed/hashmap/why3session.xml index 2eaef1115..07765b9c5 100644 --- a/creusot/tests/should_succeed/hashmap/why3session.xml +++ b/creusot/tests/should_succeed/hashmap/why3session.xml @@ -2,8 +2,8 @@ + - @@ -30,16 +30,16 @@ - + - + - + - + @@ -66,12 +66,12 @@ - + - + @@ -81,13 +81,13 @@ - + - + - + @@ -96,7 +96,7 @@ - + @@ -115,24 +115,24 @@ - + - + - + - + @@ -143,7 +143,7 @@ - + @@ -156,7 +156,7 @@ - + @@ -177,7 +177,7 @@ - + @@ -189,40 +189,40 @@ - + - + - + - + - + - + - + - + @@ -234,13 +234,13 @@ - + - + @@ -252,7 +252,7 @@ - + diff --git a/creusot/tests/should_succeed/hashmap/why3shapes.gz b/creusot/tests/should_succeed/hashmap/why3shapes.gz index a8c2067a1e2d7579695d62219769eff3eb959328..d8633d76600379bcb0825ac9f4549bebb0ca4dc6 100644 GIT binary patch literal 6084 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 GcmM#O!Nh?8 diff --git a/creusot/tests/should_succeed/ite_normalize.mlcfg b/creusot/tests/should_succeed/ite_normalize.mlcfg index 7ccef4e42..200d3c156 100644 --- a/creusot/tests/should_succeed/ite_normalize.mlcfg +++ b/creusot/tests/should_succeed/ite_normalize.mlcfg @@ -233,9 +233,9 @@ module IteNormalize_Impl0_Insert_Interface type v use prelude.Borrow use map.Map + use Core_Option_Option_Type as Core_Option_Option_Type clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with type self = k - use Core_Option_Option_Type as Core_Option_Option_Type use map.Map use IteNormalize_BTreeMap_Type as IteNormalize_BTreeMap_Type clone CreusotContracts_Model_Impl3_ShallowModel_Stub as ShallowModel1 with diff --git a/creusot/tests/should_succeed/iterators/01_range.mlcfg b/creusot/tests/should_succeed/iterators/01_range.mlcfg index 1248aa0c7..242a6c189 100644 --- a/creusot/tests/should_succeed/iterators/01_range.mlcfg +++ b/creusot/tests/should_succeed/iterators/01_range.mlcfg @@ -454,12 +454,12 @@ end module C01Range_Impl0 end -module CreusotContracts_Invariant_Impl1_Invariant_Stub +module CreusotContracts_Invariant_Impl2_Invariant_Stub type t use prelude.Borrow predicate invariant' (self : borrowed t) end -module CreusotContracts_Invariant_Impl1_Invariant_Interface +module CreusotContracts_Invariant_Impl2_Invariant_Interface type t use prelude.Borrow predicate invariant' (self : borrowed t) @@ -467,13 +467,13 @@ module CreusotContracts_Invariant_Impl1_Invariant_Interface ensures { result = invariant' self } end -module CreusotContracts_Invariant_Impl1_Invariant +module CreusotContracts_Invariant_Impl2_Invariant type t use prelude.Borrow clone CreusotContracts_Invariant_Invariant_Invariant_Stub as Invariant0 with type self = t predicate invariant' (self : borrowed t) = - [#"../../../../../creusot-contracts/src/invariant.rs" 36 20 36 39] Invariant0.invariant' ( * self) + [#"../../../../../creusot-contracts/src/invariant.rs" 59 20 59 39] Invariant0.invariant' ( * self) val invariant' (self : borrowed t) : bool ensures { result = invariant' self } @@ -497,7 +497,7 @@ module C01Range_Impl1 predicate Resolve0.resolve = Resolve0.resolve clone CreusotContracts_Invariant_Invariant_Invariant as Invariant0 with type self = C01Range_Range_Type.t_range - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant1 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant1 with type t = C01Range_Range_Type.t_range, predicate Invariant0.invariant' = Invariant0.invariant' clone C01Range_Impl1_Produces as Produces0 diff --git a/creusot/tests/should_succeed/iterators/02_iter_mut.mlcfg b/creusot/tests/should_succeed/iterators/02_iter_mut.mlcfg index 8ae2485ad..70635c610 100644 --- a/creusot/tests/should_succeed/iterators/02_iter_mut.mlcfg +++ b/creusot/tests/should_succeed/iterators/02_iter_mut.mlcfg @@ -568,12 +568,12 @@ module CreusotContracts_Invariant_Invariant_Invariant ensures { result = invariant' self } end -module CreusotContracts_Invariant_Impl1_Invariant_Stub +module CreusotContracts_Invariant_Impl2_Invariant_Stub type t use prelude.Borrow predicate invariant' (self : borrowed t) end -module CreusotContracts_Invariant_Impl1_Invariant_Interface +module CreusotContracts_Invariant_Impl2_Invariant_Interface type t use prelude.Borrow predicate invariant' (self : borrowed t) @@ -581,13 +581,13 @@ module CreusotContracts_Invariant_Impl1_Invariant_Interface ensures { result = invariant' self } end -module CreusotContracts_Invariant_Impl1_Invariant +module CreusotContracts_Invariant_Impl2_Invariant type t use prelude.Borrow clone CreusotContracts_Invariant_Invariant_Invariant_Stub as Invariant0 with type self = t predicate invariant' (self : borrowed t) = - [#"../../../../../creusot-contracts/src/invariant.rs" 36 20 36 39] Invariant0.invariant' ( * self) + [#"../../../../../creusot-contracts/src/invariant.rs" 59 20 59 39] Invariant0.invariant' ( * self) val invariant' (self : borrowed t) : bool ensures { result = invariant' self } @@ -662,7 +662,7 @@ module C02IterMut_Impl1_Next_Interface clone C02IterMut_Impl1_Completed_Stub as Completed0 with type t = t use Core_Option_Option_Type as Core_Option_Option_Type - clone CreusotContracts_Invariant_Impl1_Invariant_Stub as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant_Stub as Invariant0 with type t = C02IterMut_IterMut_Type.t_itermut t val next [#"../02_iter_mut.rs" 57 4 57 44] (self : borrowed (C02IterMut_IterMut_Type.t_itermut t)) : Core_Option_Option_Type.t_option (borrowed t) requires {[#"../02_iter_mut.rs" 57 17 57 21] Invariant0.invariant' self} @@ -721,7 +721,7 @@ module C02IterMut_Impl1_Next type t = t, predicate Resolve0.resolve = Resolve0.resolve, function ShallowModel0.shallow_model = ShallowModel1.shallow_model - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant0 with type t = C02IterMut_IterMut_Type.t_itermut t, predicate Invariant0.invariant' = Invariant1.invariant' use Core_Option_Option_Type as Core_Option_Option_Type @@ -1286,7 +1286,7 @@ module C02IterMut_AllZero type t = usize, function ShallowModel0.shallow_model = ShallowModel3.shallow_model, val Max0.mAX' = Max0.mAX' - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant1 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant1 with type t = C02IterMut_IterMut_Type.t_itermut usize, predicate Invariant0.invariant' = Invariant0.invariant' clone CreusotContracts_Logic_Ops_Impl0_IndexLogic as IndexLogic2 with @@ -1491,7 +1491,7 @@ module C02IterMut_Impl1 type t = t, function ShallowModel0.shallow_model = ShallowModel0.shallow_model, val Max0.mAX' = Max0.mAX' - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant1 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant1 with type t = C02IterMut_IterMut_Type.t_itermut t, predicate Invariant0.invariant' = Invariant0.invariant' clone C02IterMut_Impl1_Produces as Produces0 with diff --git a/creusot/tests/should_succeed/iterators/03_std_iterators.mlcfg b/creusot/tests/should_succeed/iterators/03_std_iterators.mlcfg index ebfebb59c..0e2465da0 100644 --- a/creusot/tests/should_succeed/iterators/03_std_iterators.mlcfg +++ b/creusot/tests/should_succeed/iterators/03_std_iterators.mlcfg @@ -1554,12 +1554,12 @@ module Core_Slice_Impl0_IterMut_Interface ensures { Invariant0.invariant' result } end -module CreusotContracts_Invariant_Impl1_Invariant_Stub +module CreusotContracts_Invariant_Impl2_Invariant_Stub type t use prelude.Borrow predicate invariant' (self : borrowed t) end -module CreusotContracts_Invariant_Impl1_Invariant_Interface +module CreusotContracts_Invariant_Impl2_Invariant_Interface type t use prelude.Borrow predicate invariant' (self : borrowed t) @@ -1567,13 +1567,13 @@ module CreusotContracts_Invariant_Impl1_Invariant_Interface ensures { result = invariant' self } end -module CreusotContracts_Invariant_Impl1_Invariant +module CreusotContracts_Invariant_Impl2_Invariant type t use prelude.Borrow clone CreusotContracts_Invariant_Invariant_Invariant_Stub as Invariant0 with type self = t predicate invariant' (self : borrowed t) = - [#"../../../../../creusot-contracts/src/invariant.rs" 36 20 36 39] Invariant0.invariant' ( * self) + [#"../../../../../creusot-contracts/src/invariant.rs" 59 20 59 39] Invariant0.invariant' ( * self) val invariant' (self : borrowed t) : bool ensures { result = invariant' self } @@ -1629,7 +1629,7 @@ module Core_Slice_Iter_Impl189_Next_Interface type t = t clone Core_Iter_Traits_Iterator_Iterator_Item_Type as Item0 with type self = Core_Slice_Iter_IterMut_Type.t_itermut t - clone CreusotContracts_Invariant_Impl1_Invariant_Stub as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant_Stub as Invariant0 with type t = Core_Slice_Iter_IterMut_Type.t_itermut t val next (self : borrowed (Core_Slice_Iter_IterMut_Type.t_itermut t)) : Core_Option_Option_Type.t_option (borrowed t) requires {Invariant0.invariant' self} @@ -1801,7 +1801,7 @@ module C03StdIterators_AllZero function ShallowModel0.shallow_model = ShallowModel4.shallow_model, function ShallowModel1.shallow_model = ShallowModel3.shallow_model, val Max0.mAX' = Max0.mAX' - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant1 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant1 with type t = Core_Slice_Iter_IterMut_Type.t_itermut usize, predicate Invariant0.invariant' = Invariant0.invariant' use seq.Seq @@ -2315,7 +2315,7 @@ module Core_Iter_Adapters_Skip_Impl1_Next_Interface type self = Core_Iter_Adapters_Skip_Skip_Type.t_skip i clone Core_Iter_Traits_Iterator_Iterator_Item_Type as Item0 with type self = Core_Iter_Adapters_Skip_Skip_Type.t_skip i - clone CreusotContracts_Invariant_Impl1_Invariant_Stub as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant_Stub as Invariant0 with type t = Core_Iter_Adapters_Skip_Skip_Type.t_skip i val next (self : borrowed (Core_Iter_Adapters_Skip_Skip_Type.t_skip i)) : Core_Option_Option_Type.t_option Item1.item requires {Invariant0.invariant' self} @@ -2359,7 +2359,7 @@ module CreusotContracts_Std1_Iter_Skip_Impl2_Completed use Core_Iter_Adapters_Skip_Skip_Type as Core_Iter_Adapters_Skip_Skip_Type clone CreusotContracts_Std1_Iter_Skip_Impl0_Iter_Stub as Iter0 with type i = i - clone CreusotContracts_Invariant_Impl1_Invariant_Stub as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant_Stub as Invariant0 with type t = i clone CreusotContracts_Std1_Iter_Skip_Impl0_N_Stub as N0 with type i = i, @@ -2987,7 +2987,7 @@ module C03StdIterators_SkipTake function Iter0.iter = Iter0.iter clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve3 with type self = Item0.item - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant4 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant4 with type t = Core_Iter_Adapters_Take_Take_Type.t_take i, predicate Invariant0.invariant' = Invariant1.invariant' use Core_Iter_Adapters_Skip_Skip_Type as Core_Iter_Adapters_Skip_Skip_Type @@ -3039,7 +3039,7 @@ module C03StdIterators_SkipTake predicate Resolve0.resolve = Resolve3.resolve, predicate Completed0.completed = Completed1.completed, val Max0.mAX' = Max0.mAX' - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant3 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant3 with type t = Core_Iter_Adapters_Skip_Skip_Type.t_skip (Core_Iter_Adapters_Take_Take_Type.t_take i), predicate Invariant0.invariant' = Invariant2.invariant' use Core_Option_Option_Type as Core_Option_Option_Type @@ -3554,7 +3554,7 @@ module CreusotContracts_Std1_Iter_MapInv_Impl3_Reinitialize type b = b, type f = f, type Item0.item = Item0.item - clone CreusotContracts_Invariant_Impl1_Invariant_Stub as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant_Stub as Invariant0 with type t = CreusotContracts_Std1_Iter_MapInv_MapInv_Type.t_mapinv i Item0.item f predicate reinitialize (_1 : ()) = [#"../../../../../creusot-contracts/src/std/iter/map_inv.rs" 122 8 128 9] forall reset : borrowed (CreusotContracts_Std1_Iter_MapInv_MapInv_Type.t_mapinv i Item0.item f) . Invariant0.invariant' reset -> Completed0.completed reset -> Invariant1.invariant' (CreusotContracts_Std1_Iter_MapInv_MapInv_Type.mapinv_iter ( ^ reset)) -> NextPrecondition0.next_precondition ( ^ reset) /\ Preservation0.preservation (CreusotContracts_Std1_Iter_MapInv_MapInv_Type.mapinv_iter ( ^ reset)) (CreusotContracts_Std1_Iter_MapInv_MapInv_Type.mapinv_func ( ^ reset)) @@ -3773,7 +3773,7 @@ module Core_Iter_Traits_Iterator_Iterator_Collect_Interface type self = self clone CreusotContracts_Resolve_Resolve_Resolve_Stub as Resolve0 with type self = self - clone CreusotContracts_Invariant_Impl1_Invariant_Stub as Invariant1 with + clone CreusotContracts_Invariant_Impl2_Invariant_Stub as Invariant1 with type t = self clone CreusotContracts_Invariant_Invariant_Invariant_Stub as Invariant0 with type self = self @@ -4233,7 +4233,7 @@ module C03StdIterators_Counter type f = Closure00.c03stditerators_counter_closure0, predicate Resolve1.resolve = Closure00.resolve, predicate Resolve0.resolve = Resolve4.resolve - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant2 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant2 with type t = CreusotContracts_Std1_Iter_MapInv_MapInv_Type.t_mapinv (Core_Slice_Iter_Iter_Type.t_iter uint32) uint32 Closure00.c03stditerators_counter_closure0, predicate Invariant0.invariant' = Invariant1.invariant' clone CreusotContracts_Std1_Iter_MapInv_Impl3_Preservation as Preservation0 with @@ -4810,7 +4810,7 @@ module CreusotContracts_Std1_Iter_Enumerate_Impl1_Invariant use prelude.Borrow clone CreusotContracts_Std1_Iter_Iterator_Completed_Stub as Completed0 with type self = i - clone CreusotContracts_Invariant_Impl1_Invariant_Stub as Invariant1 with + clone CreusotContracts_Invariant_Impl2_Invariant_Stub as Invariant1 with type t = i clone Core_Usize_Max_Stub as Max0 use Core_Iter_Adapters_Enumerate_Enumerate_Type as Core_Iter_Adapters_Enumerate_Enumerate_Type @@ -4967,7 +4967,7 @@ module Core_Iter_Adapters_Enumerate_Impl1_Next_Interface type self = Core_Iter_Adapters_Enumerate_Enumerate_Type.t_enumerate i clone Core_Iter_Traits_Iterator_Iterator_Item_Type as Item0 with type self = Core_Iter_Adapters_Enumerate_Enumerate_Type.t_enumerate i - clone CreusotContracts_Invariant_Impl1_Invariant_Stub as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant_Stub as Invariant0 with type t = Core_Iter_Adapters_Enumerate_Enumerate_Type.t_enumerate i val next (self : borrowed (Core_Iter_Adapters_Enumerate_Enumerate_Type.t_enumerate i)) : Core_Option_Option_Type.t_option (usize, Item1.item) requires {Invariant0.invariant' self} @@ -5123,7 +5123,7 @@ module CreusotContracts_Std1_Iter_Enumerate_Impl2_Completed use Core_Iter_Adapters_Enumerate_Enumerate_Type as Core_Iter_Adapters_Enumerate_Enumerate_Type clone CreusotContracts_Std1_Iter_Enumerate_Impl0_Iter_Stub as Iter0 with type i = i - clone CreusotContracts_Invariant_Impl1_Invariant_Stub as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant_Stub as Invariant0 with type t = i predicate completed (self : borrowed (Core_Iter_Adapters_Enumerate_Enumerate_Type.t_enumerate i)) = [#"../../../../../creusot-contracts/src/std/iter/enumerate.rs" 57 8 57 115] exists inner : borrowed i . Invariant0.invariant' inner /\ * inner = Iter0.iter ( * self) /\ ^ inner = Iter0.iter ( ^ self) /\ Completed0.completed inner @@ -5173,7 +5173,7 @@ module C03StdIterators_EnumerateRange function DeepModel0.deep_model = DeepModel0.deep_model clone CreusotContracts_Invariant_Invariant_Invariant as Invariant1 with type self = Core_Ops_Range_Range_Type.t_range usize - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant3 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant3 with type t = Core_Ops_Range_Range_Type.t_range usize, predicate Invariant0.invariant' = Invariant1.invariant' clone CreusotContracts_Std1_Iter_Range_Impl0_Produces as Produces1 with @@ -5205,7 +5205,7 @@ module C03StdIterators_EnumerateRange predicate Completed0.completed = Completed1.completed clone CreusotContracts_Std1_Iter_Enumerate_Impl1_Invariant_Interface as Invariant0 with type i = Core_Ops_Range_Range_Type.t_range usize - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant2 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant2 with type t = Core_Iter_Adapters_Enumerate_Enumerate_Type.t_enumerate (Core_Ops_Range_Range_Type.t_range usize), predicate Invariant0.invariant' = Invariant0.invariant' clone CreusotContracts_Std1_Iter_Enumerate_Impl0_N_Interface as N0 with diff --git a/creusot/tests/should_succeed/iterators/04_skip.mlcfg b/creusot/tests/should_succeed/iterators/04_skip.mlcfg index 2a01182a5..32a4254f4 100644 --- a/creusot/tests/should_succeed/iterators/04_skip.mlcfg +++ b/creusot/tests/should_succeed/iterators/04_skip.mlcfg @@ -57,12 +57,12 @@ module C04Skip_Impl0_Invariant ensures { result = invariant' self } end -module CreusotContracts_Invariant_Impl1_Invariant_Stub +module CreusotContracts_Invariant_Impl2_Invariant_Stub type t use prelude.Borrow predicate invariant' (self : borrowed t) end -module CreusotContracts_Invariant_Impl1_Invariant_Interface +module CreusotContracts_Invariant_Impl2_Invariant_Interface type t use prelude.Borrow predicate invariant' (self : borrowed t) @@ -70,13 +70,13 @@ module CreusotContracts_Invariant_Impl1_Invariant_Interface ensures { result = invariant' self } end -module CreusotContracts_Invariant_Impl1_Invariant +module CreusotContracts_Invariant_Impl2_Invariant type t use prelude.Borrow clone CreusotContracts_Invariant_Invariant_Invariant_Stub as Invariant0 with type self = t predicate invariant' (self : borrowed t) = - [#"../../../../../creusot-contracts/src/invariant.rs" 36 20 36 39] Invariant0.invariant' ( * self) + [#"../../../../../creusot-contracts/src/invariant.rs" 59 20 59 39] Invariant0.invariant' ( * self) val invariant' (self : borrowed t) : bool ensures { result = invariant' self } @@ -181,7 +181,7 @@ module C04Skip_Impl1_Completed clone C04Skip_Common_Iterator_Produces_Stub as Produces0 with type self = i, type Item0.item = Item0.item - clone CreusotContracts_Invariant_Impl1_Invariant_Stub as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant_Stub as Invariant0 with type t = i use C04Skip_Skip_Type as C04Skip_Skip_Type predicate completed [#"../04_skip.rs" 33 4 33 35] (self : borrowed (C04Skip_Skip_Type.t_skip i)) = @@ -653,7 +653,7 @@ module C04Skip_Common_Iterator_Next_Interface clone C04Skip_Common_Iterator_Completed_Stub as Completed0 with type self = self use Core_Option_Option_Type as Core_Option_Option_Type - clone CreusotContracts_Invariant_Impl1_Invariant_Stub as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant_Stub as Invariant0 with type t = self val next [#"../common.rs" 27 4 27 45] (self : borrowed self) : Core_Option_Option_Type.t_option Item0.item requires {[#"../common.rs" 27 17 27 21] Invariant0.invariant' self} @@ -701,7 +701,7 @@ module C04Skip_Impl1_Next_Interface clone C04Skip_Impl1_Completed_Stub as Completed0 with type i = i use Core_Option_Option_Type as Core_Option_Option_Type - clone CreusotContracts_Invariant_Impl1_Invariant_Stub as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant_Stub as Invariant0 with type t = C04Skip_Skip_Type.t_skip i val next [#"../04_skip.rs" 74 4 74 41] (self : borrowed (C04Skip_Skip_Type.t_skip i)) : Core_Option_Option_Type.t_option Item0.item requires {[#"../04_skip.rs" 74 17 74 21] Invariant0.invariant' self} @@ -727,7 +727,7 @@ module C04Skip_Impl1_Next axiom . clone C04Skip_Common_Iterator_Completed_Interface as Completed1 with type self = i - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant2 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant2 with type t = i, predicate Invariant0.invariant' = Invariant3.invariant' clone C04Skip_Common_Iterator_Item_Type as Item0 with @@ -780,7 +780,7 @@ module C04Skip_Impl1_Next predicate Completed0.completed = Completed1.completed, predicate Produces0.produces = Produces0.produces, predicate Invariant1.invariant' = Invariant3.invariant' - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant0 with type t = C04Skip_Skip_Type.t_skip i, predicate Invariant0.invariant' = Invariant1.invariant' clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve2 with @@ -920,7 +920,7 @@ module C04Skip_Impl1 type self = i clone CreusotContracts_Invariant_Invariant_Invariant_Interface as Invariant2 with type self = i - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant3 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant3 with type t = i, predicate Invariant0.invariant' = Invariant2.invariant' clone C04Skip_Common_Iterator_Item_Type as Item0 with @@ -944,7 +944,7 @@ module C04Skip_Impl1 clone C04Skip_Impl0_Invariant as Invariant0 with type i = i, predicate Invariant0.invariant' = Invariant2.invariant' - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant1 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant1 with type t = C04Skip_Skip_Type.t_skip i, predicate Invariant0.invariant' = Invariant0.invariant' clone C04Skip_Impl1_Produces as Produces0 with diff --git a/creusot/tests/should_succeed/iterators/05_map.mlcfg b/creusot/tests/should_succeed/iterators/05_map.mlcfg index 9f2840a5c..e14b8c3e2 100644 --- a/creusot/tests/should_succeed/iterators/05_map.mlcfg +++ b/creusot/tests/should_succeed/iterators/05_map.mlcfg @@ -1380,12 +1380,12 @@ module C05Map_Impl0_ProducesTrans_Impl = [@vc:do_not_keep_trace] [@vc:sp] [#"../05_map.rs" 30 4 30 10] () end -module CreusotContracts_Invariant_Impl1_Invariant_Stub +module CreusotContracts_Invariant_Impl2_Invariant_Stub type t use prelude.Borrow predicate invariant' (self : borrowed t) end -module CreusotContracts_Invariant_Impl1_Invariant_Interface +module CreusotContracts_Invariant_Impl2_Invariant_Interface type t use prelude.Borrow predicate invariant' (self : borrowed t) @@ -1393,13 +1393,13 @@ module CreusotContracts_Invariant_Impl1_Invariant_Interface ensures { result = invariant' self } end -module CreusotContracts_Invariant_Impl1_Invariant +module CreusotContracts_Invariant_Impl2_Invariant type t use prelude.Borrow clone CreusotContracts_Invariant_Invariant_Invariant_Stub as Invariant0 with type self = t predicate invariant' (self : borrowed t) = - [#"../../../../../creusot-contracts/src/invariant.rs" 36 20 36 39] Invariant0.invariant' ( * self) + [#"../../../../../creusot-contracts/src/invariant.rs" 59 20 59 39] Invariant0.invariant' ( * self) val invariant' (self : borrowed t) : bool ensures { result = invariant' self } @@ -1669,7 +1669,7 @@ module C05Map_Common_Iterator_Next_Interface clone C05Map_Common_Iterator_Completed_Stub as Completed0 with type self = self use Core_Option_Option_Type as Core_Option_Option_Type - clone CreusotContracts_Invariant_Impl1_Invariant_Stub as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant_Stub as Invariant0 with type t = self val next [#"../common.rs" 27 4 27 45] (self : borrowed self) : Core_Option_Option_Type.t_option Item0.item requires {[#"../common.rs" 27 17 27 21] Invariant0.invariant' self} @@ -2008,7 +2008,7 @@ module C05Map_Impl0_Next_Interface type b = b, type f = f use Core_Option_Option_Type as Core_Option_Option_Type - clone CreusotContracts_Invariant_Impl1_Invariant_Stub as Invariant1 with + clone CreusotContracts_Invariant_Impl2_Invariant_Stub as Invariant1 with type t = C05Map_Map_Type.t_map i f clone C05Map_Impl2_Invariant_Stub as Invariant0 with type i = i, @@ -2139,7 +2139,7 @@ module C05Map_Impl0_Next predicate Produces0.produces = Produces0.produces, predicate Precondition0.precondition = Precondition0.precondition, predicate PostconditionMut0.postcondition_mut = PostconditionMut0.postcondition_mut - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant2 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant2 with type t = i, predicate Invariant0.invariant' = Invariant3.invariant' clone C05Map_Common_Iterator_ProducesTrans_Interface as ProducesTrans0 with @@ -2173,7 +2173,7 @@ module C05Map_Impl0_Next predicate Invariant0.invariant' = Invariant3.invariant', predicate NextPrecondition0.next_precondition = NextPrecondition0.next_precondition, predicate Preservation0.preservation = Preservation0.preservation - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant1 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant1 with type t = C05Map_Map_Type.t_map i f, predicate Invariant0.invariant' = Invariant0.invariant' use Core_Option_Option_Type as Core_Option_Option_Type @@ -2622,7 +2622,7 @@ module C05Map_Impl0 predicate Invariant0.invariant' = Invariant2.invariant', predicate NextPrecondition0.next_precondition = NextPrecondition0.next_precondition, predicate Preservation0.preservation = Preservation0.preservation - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant0 with type t = C05Map_Map_Type.t_map i f, predicate Invariant0.invariant' = Invariant1.invariant' goal next_refn : [#"../05_map.rs" 60 4 60 44] forall self : borrowed (C05Map_Map_Type.t_map i f) . Invariant0.invariant' self -> Invariant0.invariant' self /\ Invariant1.invariant' ( * self) /\ (forall result : Core_Option_Option_Type.t_option b . Invariant1.invariant' ( ^ self) /\ Invariant1.invariant' ( ^ self) /\ match (result) with diff --git a/creusot/tests/should_succeed/iterators/05_take.mlcfg b/creusot/tests/should_succeed/iterators/05_take.mlcfg index 803330f56..4dc2edc8b 100644 --- a/creusot/tests/should_succeed/iterators/05_take.mlcfg +++ b/creusot/tests/should_succeed/iterators/05_take.mlcfg @@ -542,12 +542,12 @@ module C05Take_Impl0_ProducesTrans_Impl = [@vc:do_not_keep_trace] [@vc:sp] [#"../05_take.rs" 42 4 42 10] () end -module CreusotContracts_Invariant_Impl1_Invariant_Stub +module CreusotContracts_Invariant_Impl2_Invariant_Stub type t use prelude.Borrow predicate invariant' (self : borrowed t) end -module CreusotContracts_Invariant_Impl1_Invariant_Interface +module CreusotContracts_Invariant_Impl2_Invariant_Interface type t use prelude.Borrow predicate invariant' (self : borrowed t) @@ -555,13 +555,13 @@ module CreusotContracts_Invariant_Impl1_Invariant_Interface ensures { result = invariant' self } end -module CreusotContracts_Invariant_Impl1_Invariant +module CreusotContracts_Invariant_Impl2_Invariant type t use prelude.Borrow clone CreusotContracts_Invariant_Invariant_Invariant_Stub as Invariant0 with type self = t predicate invariant' (self : borrowed t) = - [#"../../../../../creusot-contracts/src/invariant.rs" 36 20 36 39] Invariant0.invariant' ( * self) + [#"../../../../../creusot-contracts/src/invariant.rs" 59 20 59 39] Invariant0.invariant' ( * self) val invariant' (self : borrowed t) : bool ensures { result = invariant' self } @@ -586,7 +586,7 @@ module C05Take_Common_Iterator_Next_Interface clone C05Take_Common_Iterator_Completed_Stub as Completed0 with type self = self use Core_Option_Option_Type as Core_Option_Option_Type - clone CreusotContracts_Invariant_Impl1_Invariant_Stub as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant_Stub as Invariant0 with type t = self val next [#"../common.rs" 27 4 27 45] (self : borrowed self) : Core_Option_Option_Type.t_option Item0.item requires {[#"../common.rs" 27 17 27 21] Invariant0.invariant' self} @@ -612,7 +612,7 @@ module C05Take_Impl0_Next_Interface clone C05Take_Impl0_Completed_Stub as Completed0 with type i = i use Core_Option_Option_Type as Core_Option_Option_Type - clone CreusotContracts_Invariant_Impl1_Invariant_Stub as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant_Stub as Invariant0 with type t = C05Take_Take_Type.t_take i val next [#"../05_take.rs" 53 4 53 41] (self : borrowed (C05Take_Take_Type.t_take i)) : Core_Option_Option_Type.t_option Item0.item requires {[#"../05_take.rs" 53 17 53 21] Invariant0.invariant' self} @@ -642,7 +642,7 @@ module C05Take_Impl0_Next type Item0.item = Item0.item clone C05Take_Common_Iterator_Completed_Interface as Completed1 with type self = i - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant2 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant2 with type t = i, predicate Invariant0.invariant' = Invariant3.invariant' clone C05Take_Common_Iterator_ProducesTrans_Interface as ProducesTrans0 with @@ -671,7 +671,7 @@ module C05Take_Impl0_Next type i = i, predicate Resolve0.resolve = Resolve0.resolve, predicate Completed0.completed = Completed1.completed - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant0 with type t = C05Take_Take_Type.t_take i, predicate Invariant0.invariant' = Invariant1.invariant' use Core_Option_Option_Type as Core_Option_Option_Type @@ -755,7 +755,7 @@ module C05Take_Impl0 clone C05Take_Impl1_Invariant as Invariant1 with type i = i, predicate Invariant0.invariant' = Invariant2.invariant' - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant0 with type t = C05Take_Take_Type.t_take i, predicate Invariant0.invariant' = Invariant1.invariant' goal next_refn : [#"../05_take.rs" 53 4 53 41] forall self : borrowed (C05Take_Take_Type.t_take i) . Invariant0.invariant' self -> Invariant0.invariant' self /\ (forall result : Core_Option_Option_Type.t_option Item0.item . Invariant1.invariant' ( ^ self) /\ match (result) with diff --git a/creusot/tests/should_succeed/iterators/06_map_precond.mlcfg b/creusot/tests/should_succeed/iterators/06_map_precond.mlcfg index f51fee765..ee8481fca 100644 --- a/creusot/tests/should_succeed/iterators/06_map_precond.mlcfg +++ b/creusot/tests/should_succeed/iterators/06_map_precond.mlcfg @@ -1480,12 +1480,12 @@ module C06MapPrecond_Impl0_ProducesTrans_Impl = [@vc:do_not_keep_trace] [@vc:sp] [#"../06_map_precond.rs" 32 4 32 10] () end -module CreusotContracts_Invariant_Impl1_Invariant_Stub +module CreusotContracts_Invariant_Impl2_Invariant_Stub type t use prelude.Borrow predicate invariant' (self : borrowed t) end -module CreusotContracts_Invariant_Impl1_Invariant_Interface +module CreusotContracts_Invariant_Impl2_Invariant_Interface type t use prelude.Borrow predicate invariant' (self : borrowed t) @@ -1493,13 +1493,13 @@ module CreusotContracts_Invariant_Impl1_Invariant_Interface ensures { result = invariant' self } end -module CreusotContracts_Invariant_Impl1_Invariant +module CreusotContracts_Invariant_Impl2_Invariant type t use prelude.Borrow clone CreusotContracts_Invariant_Invariant_Invariant_Stub as Invariant0 with type self = t predicate invariant' (self : borrowed t) = - [#"../../../../../creusot-contracts/src/invariant.rs" 36 20 36 39] Invariant0.invariant' ( * self) + [#"../../../../../creusot-contracts/src/invariant.rs" 59 20 59 39] Invariant0.invariant' ( * self) val invariant' (self : borrowed t) : bool ensures { result = invariant' self } @@ -1787,7 +1787,7 @@ module C06MapPrecond_Common_Iterator_Next_Interface clone C06MapPrecond_Common_Iterator_Completed_Stub as Completed0 with type self = self use Core_Option_Option_Type as Core_Option_Option_Type - clone CreusotContracts_Invariant_Impl1_Invariant_Stub as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant_Stub as Invariant0 with type t = self val next [#"../common.rs" 27 4 27 45] (self : borrowed self) : Core_Option_Option_Type.t_option Item0.item requires {[#"../common.rs" 27 17 27 21] Invariant0.invariant' self} @@ -2155,7 +2155,7 @@ module C06MapPrecond_Impl0_Next_Interface type f = f, type Item0.item = Item0.item use Core_Option_Option_Type as Core_Option_Option_Type - clone CreusotContracts_Invariant_Impl1_Invariant_Stub as Invariant1 with + clone CreusotContracts_Invariant_Impl2_Invariant_Stub as Invariant1 with type t = C06MapPrecond_Map_Type.t_map i Item0.item f clone C06MapPrecond_Impl2_Invariant_Stub as Invariant0 with type i = i, @@ -2291,7 +2291,7 @@ module C06MapPrecond_Impl0_Next predicate Produces0.produces = Produces0.produces, predicate Precondition0.precondition = Precondition0.precondition, predicate PostconditionMut0.postcondition_mut = PostconditionMut0.postcondition_mut - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant2 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant2 with type t = i, predicate Invariant0.invariant' = Invariant3.invariant' clone C06MapPrecond_Common_Iterator_ProducesTrans_Interface as ProducesTrans0 with @@ -2326,7 +2326,7 @@ module C06MapPrecond_Impl0_Next predicate Invariant0.invariant' = Invariant3.invariant', predicate NextPrecondition0.next_precondition = NextPrecondition0.next_precondition, predicate Preservation0.preservation = Preservation0.preservation - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant1 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant1 with type t = C06MapPrecond_Map_Type.t_map i Item0.item f, predicate Invariant0.invariant' = Invariant0.invariant' clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve3 with @@ -2859,10 +2859,10 @@ module C06MapPrecond_Identity type i = i, type b = Item0.item, type f = Closure00.c06mapprecond_identity_closure0 i, + type Item0.item = Item0.item, predicate Unnest0.unnest = Closure00.unnest, predicate Precondition0.precondition = Closure00.precondition, predicate PostconditionMut0.postcondition_mut = Closure00.postcondition_mut, - type Item0.item = Item0.item, predicate Produces0.produces = Produces0.produces clone C06MapPrecond_Common_Iterator_Completed_Interface as Completed1 with type self = i @@ -2872,28 +2872,28 @@ module C06MapPrecond_Identity type i = i, type b = Item0.item, type f = Closure00.c06mapprecond_identity_closure0 i, + type Item0.item = Item0.item, predicate Unnest0.unnest = Closure00.unnest, predicate Precondition0.precondition = Closure00.precondition, predicate PostconditionMut0.postcondition_mut = Closure00.postcondition_mut, - type Item0.item = Item0.item, predicate Invariant0.invariant' = Invariant0.invariant', predicate Produces0.produces = Produces0.produces clone C06MapPrecond_Impl1_NextPrecondition as NextPrecondition0 with type i = i, type b = Item0.item, type f = Closure00.c06mapprecond_identity_closure0 i, - predicate Precondition0.precondition = Closure00.precondition, type Item0.item = Item0.item, + predicate Precondition0.precondition = Closure00.precondition, predicate Invariant0.invariant' = Invariant0.invariant', predicate Produces0.produces = Produces0.produces clone C06MapPrecond_Impl1_PreservationInv as PreservationInv0 with type i = i, type b = Item0.item, type f = Closure00.c06mapprecond_identity_closure0 i, + type Item0.item = Item0.item, predicate Unnest0.unnest = Closure00.unnest, predicate Precondition0.precondition = Closure00.precondition, predicate PostconditionMut0.postcondition_mut = Closure00.postcondition_mut, - type Item0.item = Item0.item, predicate Preservation0.preservation = Preservation0.preservation, predicate Invariant0.invariant' = Invariant0.invariant', predicate Produces0.produces = Produces0.produces, @@ -2961,8 +2961,8 @@ module C06MapPrecond_Identity type i = i, type b = Item0.item, type f = Closure00.c06mapprecond_identity_closure0 i, - predicate Precondition0.precondition = Closure00.precondition, type Item0.item = Item0.item, + predicate Precondition0.precondition = Closure00.precondition, predicate Invariant0.invariant' = Invariant0.invariant', predicate Produces0.produces = Produces0.produces, predicate Reinitialize0.reinitialize = Reinitialize0.reinitialize, @@ -3098,7 +3098,7 @@ module C06MapPrecond_Increment_Interface type self = i clone C06MapPrecond_Common_Iterator_Completed_Stub as Completed0 with type self = i - clone CreusotContracts_Invariant_Impl1_Invariant_Stub as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant_Stub as Invariant0 with type t = i val increment [#"../06_map_precond.rs" 185 0 185 50] (iter : i) : () requires {[#"../06_map_precond.rs" 181 0 181 187] forall done_ : borrowed i . Invariant0.invariant' done_ -> Completed0.completed done_ -> Invariant1.invariant' ( ^ done_) -> (forall steps : Seq.seq uint32 . forall next : i . Invariant1.invariant' next -> Produces0.produces ( ^ done_) steps next -> steps = Seq.empty /\ ^ done_ = next)} @@ -3220,7 +3220,7 @@ module C06MapPrecond_Increment predicate Produces0.produces = Produces0.produces, type Item0.item = uint32, axiom . - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant1 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant1 with type t = i, predicate Invariant0.invariant' = Invariant2.invariant' clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with @@ -3406,7 +3406,7 @@ module C06MapPrecond_Counter_Interface type self = i clone C06MapPrecond_Common_Iterator_Completed_Stub as Completed0 with type self = i - clone CreusotContracts_Invariant_Impl1_Invariant_Stub as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant_Stub as Invariant0 with type t = i val counter [#"../06_map_precond.rs" 201 0 201 48] (iter : i) : () requires {[#"../06_map_precond.rs" 199 0 199 187] forall done_ : borrowed i . Invariant0.invariant' done_ -> Completed0.completed done_ -> Invariant1.invariant' ( ^ done_) -> (forall steps : Seq.seq uint32 . forall next : i . Invariant1.invariant' next -> Produces0.produces ( ^ done_) steps next -> steps = Seq.empty /\ ^ done_ = next)} @@ -3534,7 +3534,7 @@ module C06MapPrecond_Counter predicate Produces0.produces = Produces0.produces, type Item0.item = uint32, axiom . - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant0 with type t = i, predicate Invariant0.invariant' = Invariant1.invariant' clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with @@ -3695,7 +3695,7 @@ module C06MapPrecond_Impl0 predicate Invariant0.invariant' = Invariant2.invariant', predicate NextPrecondition0.next_precondition = NextPrecondition0.next_precondition, predicate Preservation0.preservation = Preservation0.preservation - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant0 with type t = C06MapPrecond_Map_Type.t_map i Item0.item f, predicate Invariant0.invariant' = Invariant1.invariant' goal next_refn : [#"../06_map_precond.rs" 63 4 63 44] forall self : borrowed (C06MapPrecond_Map_Type.t_map i Item0.item f) . Invariant0.invariant' self -> Invariant0.invariant' self /\ Invariant1.invariant' ( * self) /\ (forall result : Core_Option_Option_Type.t_option b . Invariant1.invariant' ( ^ self) /\ Invariant1.invariant' ( ^ self) /\ match (result) with diff --git a/creusot/tests/should_succeed/iterators/07_fuse.mlcfg b/creusot/tests/should_succeed/iterators/07_fuse.mlcfg index 3b9d490c9..1b3a7bdda 100644 --- a/creusot/tests/should_succeed/iterators/07_fuse.mlcfg +++ b/creusot/tests/should_succeed/iterators/07_fuse.mlcfg @@ -313,12 +313,12 @@ module C07Fuse_Impl1_Produces ensures { result = produces self prod other } end -module CreusotContracts_Invariant_Impl1_Invariant_Stub +module CreusotContracts_Invariant_Impl2_Invariant_Stub type t use prelude.Borrow predicate invariant' (self : borrowed t) end -module CreusotContracts_Invariant_Impl1_Invariant_Interface +module CreusotContracts_Invariant_Impl2_Invariant_Interface type t use prelude.Borrow predicate invariant' (self : borrowed t) @@ -326,13 +326,13 @@ module CreusotContracts_Invariant_Impl1_Invariant_Interface ensures { result = invariant' self } end -module CreusotContracts_Invariant_Impl1_Invariant +module CreusotContracts_Invariant_Impl2_Invariant type t use prelude.Borrow clone CreusotContracts_Invariant_Invariant_Invariant_Stub as Invariant0 with type self = t predicate invariant' (self : borrowed t) = - [#"../../../../../creusot-contracts/src/invariant.rs" 36 20 36 39] Invariant0.invariant' ( * self) + [#"../../../../../creusot-contracts/src/invariant.rs" 59 20 59 39] Invariant0.invariant' ( * self) val invariant' (self : borrowed t) : bool ensures { result = invariant' self } @@ -448,7 +448,7 @@ module C07Fuse_Common_Iterator_Next_Interface clone C07Fuse_Common_Iterator_Completed_Stub as Completed0 with type self = self use Core_Option_Option_Type as Core_Option_Option_Type - clone CreusotContracts_Invariant_Impl1_Invariant_Stub as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant_Stub as Invariant0 with type t = self val next [#"../common.rs" 27 4 27 45] (self : borrowed self) : Core_Option_Option_Type.t_option Item0.item requires {[#"../common.rs" 27 17 27 21] Invariant0.invariant' self} @@ -474,7 +474,7 @@ module C07Fuse_Impl1_Next_Interface clone C07Fuse_Impl1_Completed_Stub as Completed0 with type i = i use Core_Option_Option_Type as Core_Option_Option_Type - clone CreusotContracts_Invariant_Impl1_Invariant_Stub as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant_Stub as Invariant0 with type t = C07Fuse_Fuse_Type.t_fuse i val next [#"../07_fuse.rs" 45 4 45 44] (self : borrowed (C07Fuse_Fuse_Type.t_fuse i)) : Core_Option_Option_Type.t_option Item0.item requires {[#"../07_fuse.rs" 45 17 45 21] Invariant0.invariant' self} @@ -508,7 +508,7 @@ module C07Fuse_Impl1_Next type Item0.item = Item0.item clone C07Fuse_Common_Iterator_Completed_Interface as Completed1 with type self = i - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant2 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant2 with type t = i, predicate Invariant0.invariant' = Invariant3.invariant' clone C07Fuse_Common_Iterator_ProducesTrans_Interface as ProducesTrans0 with @@ -533,7 +533,7 @@ module C07Fuse_Impl1_Next predicate Produces0.produces = Produces1.produces clone C07Fuse_Impl1_Completed as Completed0 with type i = i - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant0 with type t = C07Fuse_Fuse_Type.t_fuse i, predicate Invariant0.invariant' = Invariant1.invariant' clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve4 with @@ -878,7 +878,7 @@ module C07Fuse_Impl3_IsFused_Stub use C07Fuse_Fuse_Type as C07Fuse_Fuse_Type clone C07Fuse_Impl2_Invariant_Stub as Invariant1 with type i = i - clone CreusotContracts_Invariant_Impl1_Invariant_Stub as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant_Stub as Invariant0 with type t = C07Fuse_Fuse_Type.t_fuse i clone C07Fuse_Impl1_Produces_Stub as Produces0 with type i = i, @@ -897,7 +897,7 @@ module C07Fuse_Impl3_IsFused_Interface use C07Fuse_Fuse_Type as C07Fuse_Fuse_Type clone C07Fuse_Impl2_Invariant_Stub as Invariant1 with type i = i - clone CreusotContracts_Invariant_Impl1_Invariant_Stub as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant_Stub as Invariant0 with type t = C07Fuse_Fuse_Type.t_fuse i clone C07Fuse_Impl1_Produces_Stub as Produces0 with type i = i, @@ -926,7 +926,7 @@ module C07Fuse_Impl3_IsFused use C07Fuse_Fuse_Type as C07Fuse_Fuse_Type clone C07Fuse_Impl2_Invariant_Stub as Invariant1 with type i = i - clone CreusotContracts_Invariant_Impl1_Invariant_Stub as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant_Stub as Invariant0 with type t = C07Fuse_Fuse_Type.t_fuse i clone C07Fuse_Impl1_Produces_Stub as Produces0 with type i = i, @@ -1000,7 +1000,7 @@ module C07Fuse_Impl3_IsFused_Impl predicate Produces0.produces = Produces0.produces, type Item0.item = Item0.item, axiom . - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant0 with type t = C07Fuse_Fuse_Type.t_fuse i, predicate Invariant0.invariant' = Invariant1.invariant' clone C07Fuse_Impl1_Completed as Completed0 with @@ -1045,7 +1045,7 @@ module C07Fuse_Impl1 clone C07Fuse_Impl2_Invariant as Invariant1 with type i = i, predicate Invariant0.invariant' = Invariant2.invariant' - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant0 with type t = C07Fuse_Fuse_Type.t_fuse i, predicate Invariant0.invariant' = Invariant1.invariant' goal next_refn : [#"../07_fuse.rs" 45 4 45 44] forall self : borrowed (C07Fuse_Fuse_Type.t_fuse i) . Invariant0.invariant' self -> Invariant0.invariant' self /\ (forall result : Core_Option_Option_Type.t_option Item0.item . Invariant1.invariant' ( ^ self) /\ match (result) with @@ -1087,7 +1087,7 @@ module C07Fuse_Impl3 clone C07Fuse_Impl2_Invariant as Invariant0 with type i = i, predicate Invariant0.invariant' = Invariant2.invariant' - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant1 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant1 with type t = C07Fuse_Fuse_Type.t_fuse i, predicate Invariant0.invariant' = Invariant0.invariant' goal is_fused_refn : [#"../07_fuse.rs" 98 4 98 62] forall self : borrowed (C07Fuse_Fuse_Type.t_fuse i) . forall steps : Seq.seq Item0.item . forall next : C07Fuse_Fuse_Type.t_fuse i . Invariant0.invariant' next /\ Invariant1.invariant' self /\ Produces0.produces ( ^ self) steps next /\ Completed0.completed self -> Invariant0.invariant' next /\ Invariant1.invariant' self /\ Produces0.produces ( ^ self) steps next /\ Completed0.completed self /\ (forall result : () . Invariant0.invariant' ( ^ self) /\ steps = Seq.empty /\ ^ self = next -> Invariant0.invariant' ( ^ self) /\ steps = Seq.empty /\ ^ self = next) diff --git a/creusot/tests/should_succeed/iterators/08_collect_extend.mlcfg b/creusot/tests/should_succeed/iterators/08_collect_extend.mlcfg index c5ed6a4ac..c132817d1 100644 --- a/creusot/tests/should_succeed/iterators/08_collect_extend.mlcfg +++ b/creusot/tests/should_succeed/iterators/08_collect_extend.mlcfg @@ -18,12 +18,12 @@ module CreusotContracts_Invariant_Invariant_Invariant ensures { result = invariant' self } end -module CreusotContracts_Invariant_Impl1_Invariant_Stub +module CreusotContracts_Invariant_Impl2_Invariant_Stub type t use prelude.Borrow predicate invariant' (self : borrowed t) end -module CreusotContracts_Invariant_Impl1_Invariant_Interface +module CreusotContracts_Invariant_Impl2_Invariant_Interface type t use prelude.Borrow predicate invariant' (self : borrowed t) @@ -31,13 +31,13 @@ module CreusotContracts_Invariant_Impl1_Invariant_Interface ensures { result = invariant' self } end -module CreusotContracts_Invariant_Impl1_Invariant +module CreusotContracts_Invariant_Impl2_Invariant type t use prelude.Borrow clone CreusotContracts_Invariant_Invariant_Invariant_Stub as Invariant0 with type self = t predicate invariant' (self : borrowed t) = - [#"../../../../../creusot-contracts/src/invariant.rs" 36 20 36 39] Invariant0.invariant' ( * self) + [#"../../../../../creusot-contracts/src/invariant.rs" 59 20 59 39] Invariant0.invariant' ( * self) val invariant' (self : borrowed t) : bool ensures { result = invariant' self } @@ -433,7 +433,7 @@ module Core_Iter_Traits_Iterator_Iterator_Next_Interface clone CreusotContracts_Std1_Iter_Iterator_Completed_Stub as Completed0 with type self = self use Core_Option_Option_Type as Core_Option_Option_Type - clone CreusotContracts_Invariant_Impl1_Invariant_Stub as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant_Stub as Invariant0 with type t = self val next (self : borrowed self) : Core_Option_Option_Type.t_option Item0.item requires {Invariant0.invariant' self} @@ -661,7 +661,7 @@ module C08CollectExtend_Extend_Interface type Item0.item = t clone CreusotContracts_Std1_Iter_Iterator_Completed_Stub as Completed0 with type self = i - clone CreusotContracts_Invariant_Impl1_Invariant_Stub as Invariant1 with + clone CreusotContracts_Invariant_Impl2_Invariant_Stub as Invariant1 with type t = i clone CreusotContracts_Invariant_Invariant_Invariant_Stub as Invariant0 with type self = i @@ -722,7 +722,7 @@ module C08CollectExtend_Extend predicate Invariant0.invariant' = Invariant0.invariant' clone CreusotContracts_Std1_Iter_Iterator_Completed_Interface as Completed0 with type self = i - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant1 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant1 with type t = i, predicate Invariant0.invariant' = Invariant0.invariant' clone Alloc_Vec_Impl1_Push_Interface as Push0 with @@ -1005,7 +1005,7 @@ module C08CollectExtend_Collect_Interface type Item0.item = Item0.item clone CreusotContracts_Std1_Iter_Iterator_Completed_Stub as Completed0 with type self = i - clone CreusotContracts_Invariant_Impl1_Invariant_Stub as Invariant1 with + clone CreusotContracts_Invariant_Impl2_Invariant_Stub as Invariant1 with type t = i clone CreusotContracts_Invariant_Invariant_Invariant_Stub as Invariant0 with type self = i @@ -1019,9 +1019,9 @@ module C08CollectExtend_Collect use prelude.Ghost use seq.Seq use prelude.Borrow + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type clone Core_Iter_Traits_Iterator_Iterator_Item_Type as Item0 with type self = i - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type clone Core_Num_Impl11_Max as Max0 clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Interface as ShallowModel0 with @@ -1069,7 +1069,7 @@ module C08CollectExtend_Collect predicate Invariant0.invariant' = Invariant0.invariant' clone CreusotContracts_Std1_Iter_Iterator_Completed_Interface as Completed0 with type self = i - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant1 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant1 with type t = i, predicate Invariant0.invariant' = Invariant0.invariant' clone Alloc_Vec_Impl1_Push_Interface as Push0 with @@ -1689,7 +1689,7 @@ module C08CollectExtend_ExtendIndex type a = Alloc_Alloc_Global_Type.t_global, predicate Resolve0.resolve = Resolve3.resolve, function ShallowModel0.shallow_model = ShallowModel7.shallow_model - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant1 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant1 with type t = Alloc_Vec_IntoIter_IntoIter_Type.t_intoiter uint32 (Alloc_Alloc_Global_Type.t_global), predicate Invariant0.invariant' = Invariant0.invariant' clone CreusotContracts_Std1_Vec_Impl3_IntoIterPost as IntoIterPost0 with @@ -1842,7 +1842,7 @@ module C08CollectExtend_CollectExample clone Core_Num_Impl11_Max as Max0 clone CreusotContracts_Std1_Iter_Iterator_Completed_Interface as Completed0 with type self = i - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant1 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant1 with type t = i, predicate Invariant0.invariant' = Invariant0.invariant' use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type diff --git a/creusot/tests/should_succeed/iterators/08_collect_extend/why3shapes.gz b/creusot/tests/should_succeed/iterators/08_collect_extend/why3shapes.gz index c667278c34fd11158316010f24554b7ea949b5aa..713d0fc20926203fe36373cd7298a95cfa8b146c 100644 GIT binary patch delta 2494 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 IH8>{#0BRx7jsO4v delta 2496 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 (forall result : Core_Option_Option_Type.t_option t . match (result) with diff --git a/creusot/tests/should_succeed/iterators/10_once.mlcfg b/creusot/tests/should_succeed/iterators/10_once.mlcfg index d6c99f4b3..8e8d2b164 100644 --- a/creusot/tests/should_succeed/iterators/10_once.mlcfg +++ b/creusot/tests/should_succeed/iterators/10_once.mlcfg @@ -286,12 +286,12 @@ module CreusotContracts_Invariant_Invariant_Invariant ensures { result = invariant' self } end -module CreusotContracts_Invariant_Impl1_Invariant_Stub +module CreusotContracts_Invariant_Impl2_Invariant_Stub type t use prelude.Borrow predicate invariant' (self : borrowed t) end -module CreusotContracts_Invariant_Impl1_Invariant_Interface +module CreusotContracts_Invariant_Impl2_Invariant_Interface type t use prelude.Borrow predicate invariant' (self : borrowed t) @@ -299,13 +299,13 @@ module CreusotContracts_Invariant_Impl1_Invariant_Interface ensures { result = invariant' self } end -module CreusotContracts_Invariant_Impl1_Invariant +module CreusotContracts_Invariant_Impl2_Invariant type t use prelude.Borrow clone CreusotContracts_Invariant_Invariant_Invariant_Stub as Invariant0 with type self = t predicate invariant' (self : borrowed t) = - [#"../../../../../creusot-contracts/src/invariant.rs" 36 20 36 39] Invariant0.invariant' ( * self) + [#"../../../../../creusot-contracts/src/invariant.rs" 59 20 59 39] Invariant0.invariant' ( * self) val invariant' (self : borrowed t) : bool ensures { result = invariant' self } @@ -329,7 +329,7 @@ module C10Once_Impl0 predicate Resolve0.resolve = Resolve0.resolve clone CreusotContracts_Invariant_Invariant_Invariant as Invariant0 with type self = C10Once_Once_Type.t_once t - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant1 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant1 with type t = C10Once_Once_Type.t_once t, predicate Invariant0.invariant' = Invariant0.invariant' clone C10Once_Impl0_Produces as Produces0 with diff --git a/creusot/tests/should_succeed/iterators/11_repeat.mlcfg b/creusot/tests/should_succeed/iterators/11_repeat.mlcfg index 2e28d167a..3bc1daf9c 100644 --- a/creusot/tests/should_succeed/iterators/11_repeat.mlcfg +++ b/creusot/tests/should_succeed/iterators/11_repeat.mlcfg @@ -277,12 +277,12 @@ module CreusotContracts_Invariant_Invariant_Invariant ensures { result = invariant' self } end -module CreusotContracts_Invariant_Impl1_Invariant_Stub +module CreusotContracts_Invariant_Impl2_Invariant_Stub type t use prelude.Borrow predicate invariant' (self : borrowed t) end -module CreusotContracts_Invariant_Impl1_Invariant_Interface +module CreusotContracts_Invariant_Impl2_Invariant_Interface type t use prelude.Borrow predicate invariant' (self : borrowed t) @@ -290,13 +290,13 @@ module CreusotContracts_Invariant_Impl1_Invariant_Interface ensures { result = invariant' self } end -module CreusotContracts_Invariant_Impl1_Invariant +module CreusotContracts_Invariant_Impl2_Invariant type t use prelude.Borrow clone CreusotContracts_Invariant_Invariant_Invariant_Stub as Invariant0 with type self = t predicate invariant' (self : borrowed t) = - [#"../../../../../creusot-contracts/src/invariant.rs" 36 20 36 39] Invariant0.invariant' ( * self) + [#"../../../../../creusot-contracts/src/invariant.rs" 59 20 59 39] Invariant0.invariant' ( * self) val invariant' (self : borrowed t) : bool ensures { result = invariant' self } @@ -317,7 +317,7 @@ module C11Repeat_Impl0 type a = a clone CreusotContracts_Invariant_Invariant_Invariant as Invariant0 with type self = C11Repeat_Repeat_Type.t_repeat a - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant1 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant1 with type t = C11Repeat_Repeat_Type.t_repeat a, predicate Invariant0.invariant' = Invariant0.invariant' clone C11Repeat_Impl0_Produces as Produces0 with diff --git a/creusot/tests/should_succeed/iterators/12_zip.mlcfg b/creusot/tests/should_succeed/iterators/12_zip.mlcfg index 576dcbb61..41768149e 100644 --- a/creusot/tests/should_succeed/iterators/12_zip.mlcfg +++ b/creusot/tests/should_succeed/iterators/12_zip.mlcfg @@ -629,12 +629,12 @@ module C12Zip_Impl0_ProducesTrans_Impl = [@vc:do_not_keep_trace] [@vc:sp] [#"../12_zip.rs" 39 4 39 10] () end -module CreusotContracts_Invariant_Impl1_Invariant_Stub +module CreusotContracts_Invariant_Impl2_Invariant_Stub type t use prelude.Borrow predicate invariant' (self : borrowed t) end -module CreusotContracts_Invariant_Impl1_Invariant_Interface +module CreusotContracts_Invariant_Impl2_Invariant_Interface type t use prelude.Borrow predicate invariant' (self : borrowed t) @@ -642,13 +642,13 @@ module CreusotContracts_Invariant_Impl1_Invariant_Interface ensures { result = invariant' self } end -module CreusotContracts_Invariant_Impl1_Invariant +module CreusotContracts_Invariant_Impl2_Invariant type t use prelude.Borrow clone CreusotContracts_Invariant_Invariant_Invariant_Stub as Invariant0 with type self = t predicate invariant' (self : borrowed t) = - [#"../../../../../creusot-contracts/src/invariant.rs" 36 20 36 39] Invariant0.invariant' ( * self) + [#"../../../../../creusot-contracts/src/invariant.rs" 59 20 59 39] Invariant0.invariant' ( * self) val invariant' (self : borrowed t) : bool ensures { result = invariant' self } @@ -744,7 +744,7 @@ module C12Zip_Common_Iterator_Next_Interface clone C12Zip_Common_Iterator_Completed_Stub as Completed0 with type self = self use Core_Option_Option_Type as Core_Option_Option_Type - clone CreusotContracts_Invariant_Impl1_Invariant_Stub as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant_Stub as Invariant0 with type t = self val next [#"../common.rs" 27 4 27 45] (self : borrowed self) : Core_Option_Option_Type.t_option Item0.item requires {[#"../common.rs" 27 17 27 21] Invariant0.invariant' self} @@ -777,7 +777,7 @@ module C12Zip_Impl0_Next_Interface type i = i, type j = j use Core_Option_Option_Type as Core_Option_Option_Type - clone CreusotContracts_Invariant_Impl1_Invariant_Stub as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant_Stub as Invariant0 with type t = C12Zip_Zip_Type.t_zip i j val next [#"../12_zip.rs" 50 4 50 44] (self : borrowed (C12Zip_Zip_Type.t_zip i j)) : Core_Option_Option_Type.t_option (Item0.item, Item1.item) requires {[#"../12_zip.rs" 50 17 50 21] Invariant0.invariant' self} @@ -819,7 +819,7 @@ module C12Zip_Impl0_Next type Item0.item = Item1.item clone C12Zip_Common_Iterator_Completed_Interface as Completed2 with type self = j - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant4 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant4 with type t = j, predicate Invariant0.invariant' = Invariant5.invariant' clone C12Zip_Common_Iterator_ProducesTrans_Interface as ProducesTrans1 with @@ -839,7 +839,7 @@ module C12Zip_Impl0_Next type Item0.item = Item0.item clone C12Zip_Common_Iterator_Completed_Interface as Completed1 with type self = i - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant2 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant2 with type t = i, predicate Invariant0.invariant' = Invariant3.invariant' clone C12Zip_Common_Iterator_ProducesTrans_Interface as ProducesTrans0 with @@ -872,7 +872,7 @@ module C12Zip_Impl0_Next type j = j, predicate Completed0.completed = Completed1.completed, predicate Completed1.completed = Completed2.completed - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant0 with type t = C12Zip_Zip_Type.t_zip i j, predicate Invariant0.invariant' = Invariant1.invariant' clone CreusotContracts_Resolve_Impl0_Resolve as Resolve1 with @@ -1033,7 +1033,7 @@ module C12Zip_Impl0 type j = j, predicate Invariant0.invariant' = Invariant2.invariant', predicate Invariant1.invariant' = Invariant3.invariant' - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant0 with type t = C12Zip_Zip_Type.t_zip i j, predicate Invariant0.invariant' = Invariant1.invariant' goal next_refn : [#"../12_zip.rs" 50 4 50 44] forall self : borrowed (C12Zip_Zip_Type.t_zip i j) . Invariant0.invariant' self -> Invariant0.invariant' self /\ (forall result : Core_Option_Option_Type.t_option (Item0.item, Item1.item) . Invariant1.invariant' ( ^ self) /\ match (result) with diff --git a/creusot/tests/should_succeed/iterators/13_cloned.mlcfg b/creusot/tests/should_succeed/iterators/13_cloned.mlcfg index 4192ec775..043e8b1f4 100644 --- a/creusot/tests/should_succeed/iterators/13_cloned.mlcfg +++ b/creusot/tests/should_succeed/iterators/13_cloned.mlcfg @@ -515,12 +515,12 @@ module C13Cloned_Impl0_ProducesTrans_Impl = [@vc:do_not_keep_trace] [@vc:sp] [#"../13_cloned.rs" 41 4 41 10] () end -module CreusotContracts_Invariant_Impl1_Invariant_Stub +module CreusotContracts_Invariant_Impl2_Invariant_Stub type t use prelude.Borrow predicate invariant' (self : borrowed t) end -module CreusotContracts_Invariant_Impl1_Invariant_Interface +module CreusotContracts_Invariant_Impl2_Invariant_Interface type t use prelude.Borrow predicate invariant' (self : borrowed t) @@ -528,13 +528,13 @@ module CreusotContracts_Invariant_Impl1_Invariant_Interface ensures { result = invariant' self } end -module CreusotContracts_Invariant_Impl1_Invariant +module CreusotContracts_Invariant_Impl2_Invariant type t use prelude.Borrow clone CreusotContracts_Invariant_Invariant_Invariant_Stub as Invariant0 with type self = t predicate invariant' (self : borrowed t) = - [#"../../../../../creusot-contracts/src/invariant.rs" 36 20 36 39] Invariant0.invariant' ( * self) + [#"../../../../../creusot-contracts/src/invariant.rs" 59 20 59 39] Invariant0.invariant' ( * self) val invariant' (self : borrowed t) : bool ensures { result = invariant' self } @@ -581,7 +581,7 @@ module C13Cloned_Common_Iterator_Next_Interface clone C13Cloned_Common_Iterator_Completed_Stub as Completed0 with type self = self use Core_Option_Option_Type as Core_Option_Option_Type - clone CreusotContracts_Invariant_Impl1_Invariant_Stub as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant_Stub as Invariant0 with type t = self val next [#"../common.rs" 27 4 27 45] (self : borrowed self) : Core_Option_Option_Type.t_option Item0.item requires {[#"../common.rs" 27 17 27 21] Invariant0.invariant' self} @@ -617,7 +617,7 @@ module C13Cloned_Impl0_Next_Interface type i = i, type t = t use Core_Option_Option_Type as Core_Option_Option_Type - clone CreusotContracts_Invariant_Impl1_Invariant_Stub as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant_Stub as Invariant0 with type t = C13Cloned_Cloned_Type.t_cloned i val next [#"../13_cloned.rs" 52 4 52 35] (self : borrowed (C13Cloned_Cloned_Type.t_cloned i)) : Core_Option_Option_Type.t_option t requires {[#"../13_cloned.rs" 52 17 52 21] Invariant0.invariant' self} @@ -645,7 +645,7 @@ module C13Cloned_Impl0_Next clone C13Cloned_Common_Iterator_Completed_Interface as Completed1 with type self = i use Core_Option_Option_Type as Core_Option_Option_Type - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant2 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant2 with type t = i, predicate Invariant0.invariant' = Invariant3.invariant' clone C13Cloned_Common_Iterator_ProducesTrans_Interface as ProducesTrans0 with @@ -673,10 +673,10 @@ module C13Cloned_Impl0_Next type i = i, type t = t, predicate Completed0.completed = Completed1.completed - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant0 with type t = C13Cloned_Cloned_Type.t_cloned i, predicate Invariant0.invariant' = Invariant1.invariant' - clone Core_Option_Impl2_Cloned_Interface as Cloned1 with + clone Core_Option_Impl2_Cloned_Interface as Cloned0 with type t = t clone C13Cloned_Common_Iterator_Next_Interface as Next0 with type self = i, @@ -709,7 +709,7 @@ module C13Cloned_Impl0_Next } BB1 { assume { Resolve0.resolve self }; - _0 <- ([#"../13_cloned.rs" 53 8 53 33] Cloned1.cloned ([#"../13_cloned.rs" 53 8 53 24] Next0.next _4)); + _0 <- ([#"../13_cloned.rs" 53 8 53 33] Cloned0.cloned ([#"../13_cloned.rs" 53 8 53 24] Next0.next _4)); _4 <- any borrowed i; goto BB2 } @@ -746,7 +746,7 @@ module C13Cloned_Impl0 type i = i, type t = t, predicate Invariant0.invariant' = Invariant2.invariant' - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant0 with type t = C13Cloned_Cloned_Type.t_cloned i, predicate Invariant0.invariant' = Invariant1.invariant' goal next_refn : [#"../13_cloned.rs" 52 4 52 35] forall self : borrowed (C13Cloned_Cloned_Type.t_cloned i) . Invariant0.invariant' self -> Invariant0.invariant' self /\ (forall result : Core_Option_Option_Type.t_option t . Invariant1.invariant' ( ^ self) /\ match (result) with diff --git a/creusot/tests/should_succeed/iterators/14_copied.mlcfg b/creusot/tests/should_succeed/iterators/14_copied.mlcfg index cfba103b8..26733fac3 100644 --- a/creusot/tests/should_succeed/iterators/14_copied.mlcfg +++ b/creusot/tests/should_succeed/iterators/14_copied.mlcfg @@ -515,12 +515,12 @@ module C14Copied_Impl0_ProducesTrans_Impl = [@vc:do_not_keep_trace] [@vc:sp] [#"../14_copied.rs" 41 4 41 10] () end -module CreusotContracts_Invariant_Impl1_Invariant_Stub +module CreusotContracts_Invariant_Impl2_Invariant_Stub type t use prelude.Borrow predicate invariant' (self : borrowed t) end -module CreusotContracts_Invariant_Impl1_Invariant_Interface +module CreusotContracts_Invariant_Impl2_Invariant_Interface type t use prelude.Borrow predicate invariant' (self : borrowed t) @@ -528,13 +528,13 @@ module CreusotContracts_Invariant_Impl1_Invariant_Interface ensures { result = invariant' self } end -module CreusotContracts_Invariant_Impl1_Invariant +module CreusotContracts_Invariant_Impl2_Invariant type t use prelude.Borrow clone CreusotContracts_Invariant_Invariant_Invariant_Stub as Invariant0 with type self = t predicate invariant' (self : borrowed t) = - [#"../../../../../creusot-contracts/src/invariant.rs" 36 20 36 39] Invariant0.invariant' ( * self) + [#"../../../../../creusot-contracts/src/invariant.rs" 59 20 59 39] Invariant0.invariant' ( * self) val invariant' (self : borrowed t) : bool ensures { result = invariant' self } @@ -581,7 +581,7 @@ module C14Copied_Common_Iterator_Next_Interface clone C14Copied_Common_Iterator_Completed_Stub as Completed0 with type self = self use Core_Option_Option_Type as Core_Option_Option_Type - clone CreusotContracts_Invariant_Impl1_Invariant_Stub as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant_Stub as Invariant0 with type t = self val next [#"../common.rs" 27 4 27 45] (self : borrowed self) : Core_Option_Option_Type.t_option Item0.item requires {[#"../common.rs" 27 17 27 21] Invariant0.invariant' self} @@ -617,7 +617,7 @@ module C14Copied_Impl0_Next_Interface type i = i, type t = t use Core_Option_Option_Type as Core_Option_Option_Type - clone CreusotContracts_Invariant_Impl1_Invariant_Stub as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant_Stub as Invariant0 with type t = C14Copied_Copied_Type.t_copied i val next [#"../14_copied.rs" 52 4 52 35] (self : borrowed (C14Copied_Copied_Type.t_copied i)) : Core_Option_Option_Type.t_option t requires {[#"../14_copied.rs" 52 17 52 21] Invariant0.invariant' self} @@ -645,7 +645,7 @@ module C14Copied_Impl0_Next clone C14Copied_Common_Iterator_Completed_Interface as Completed1 with type self = i use Core_Option_Option_Type as Core_Option_Option_Type - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant2 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant2 with type t = i, predicate Invariant0.invariant' = Invariant3.invariant' clone C14Copied_Common_Iterator_ProducesTrans_Interface as ProducesTrans0 with @@ -673,10 +673,10 @@ module C14Copied_Impl0_Next type i = i, type t = t, predicate Completed0.completed = Completed1.completed - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant0 with type t = C14Copied_Copied_Type.t_copied i, predicate Invariant0.invariant' = Invariant1.invariant' - clone Core_Option_Impl2_Copied_Interface as Copied1 with + clone Core_Option_Impl2_Copied_Interface as Copied0 with type t = t clone C14Copied_Common_Iterator_Next_Interface as Next0 with type self = i, @@ -709,7 +709,7 @@ module C14Copied_Impl0_Next } BB1 { assume { Resolve0.resolve self }; - _0 <- ([#"../14_copied.rs" 53 8 53 33] Copied1.copied ([#"../14_copied.rs" 53 8 53 24] Next0.next _4)); + _0 <- ([#"../14_copied.rs" 53 8 53 33] Copied0.copied ([#"../14_copied.rs" 53 8 53 24] Next0.next _4)); _4 <- any borrowed i; goto BB2 } @@ -742,7 +742,7 @@ module C14Copied_Impl0 type i = i, type t = t, predicate Invariant0.invariant' = Invariant2.invariant' - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant1 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant1 with type t = C14Copied_Copied_Type.t_copied i, predicate Invariant0.invariant' = Invariant0.invariant' clone C14Copied_Impl0_Produces as Produces0 with diff --git a/creusot/tests/should_succeed/iterators/15_enumerate.mlcfg b/creusot/tests/should_succeed/iterators/15_enumerate.mlcfg index 13750a1a5..eee9f234e 100644 --- a/creusot/tests/should_succeed/iterators/15_enumerate.mlcfg +++ b/creusot/tests/should_succeed/iterators/15_enumerate.mlcfg @@ -294,12 +294,12 @@ module C15Enumerate_Impl0_Produces ensures { result = produces self visited o } end -module CreusotContracts_Invariant_Impl1_Invariant_Stub +module CreusotContracts_Invariant_Impl2_Invariant_Stub type t use prelude.Borrow predicate invariant' (self : borrowed t) end -module CreusotContracts_Invariant_Impl1_Invariant_Interface +module CreusotContracts_Invariant_Impl2_Invariant_Interface type t use prelude.Borrow predicate invariant' (self : borrowed t) @@ -307,13 +307,13 @@ module CreusotContracts_Invariant_Impl1_Invariant_Interface ensures { result = invariant' self } end -module CreusotContracts_Invariant_Impl1_Invariant +module CreusotContracts_Invariant_Impl2_Invariant type t use prelude.Borrow clone CreusotContracts_Invariant_Invariant_Invariant_Stub as Invariant0 with type self = t predicate invariant' (self : borrowed t) = - [#"../../../../../creusot-contracts/src/invariant.rs" 36 20 36 39] Invariant0.invariant' ( * self) + [#"../../../../../creusot-contracts/src/invariant.rs" 59 20 59 39] Invariant0.invariant' ( * self) val invariant' (self : borrowed t) : bool ensures { result = invariant' self } @@ -350,7 +350,7 @@ module C15Enumerate_Impl1_Invariant use prelude.Borrow clone C15Enumerate_Common_Iterator_Completed_Stub as Completed0 with type self = i - clone CreusotContracts_Invariant_Impl1_Invariant_Stub as Invariant1 with + clone CreusotContracts_Invariant_Impl2_Invariant_Stub as Invariant1 with type t = i clone Core_Usize_Max_Stub as Max0 clone C15Enumerate_Common_Iterator_Item_Type as Item0 with @@ -447,7 +447,7 @@ module C15Enumerate_Impl0_ProducesRefl_Impl axiom . clone C15Enumerate_Common_Iterator_Completed_Interface as Completed0 with type self = i - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant2 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant2 with type t = i, predicate Invariant0.invariant' = Invariant1.invariant' clone Core_Usize_Max as Max0 @@ -571,7 +571,7 @@ module C15Enumerate_Impl0_ProducesTrans_Impl axiom . clone C15Enumerate_Common_Iterator_Completed_Interface as Completed0 with type self = i - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant2 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant2 with type t = i, predicate Invariant0.invariant' = Invariant1.invariant' clone Core_Usize_Max as Max0 @@ -664,7 +664,7 @@ module C15Enumerate_Common_Iterator_Next_Interface clone C15Enumerate_Common_Iterator_Completed_Stub as Completed0 with type self = self use Core_Option_Option_Type as Core_Option_Option_Type - clone CreusotContracts_Invariant_Impl1_Invariant_Stub as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant_Stub as Invariant0 with type t = self val next [#"../common.rs" 27 4 27 45] (self : borrowed self) : Core_Option_Option_Type.t_option Item0.item requires {[#"../common.rs" 27 17 27 21] Invariant0.invariant' self} @@ -692,7 +692,7 @@ module C15Enumerate_Impl0_Next_Interface clone C15Enumerate_Impl0_Completed_Stub as Completed0 with type i = i use Core_Option_Option_Type as Core_Option_Option_Type - clone CreusotContracts_Invariant_Impl1_Invariant_Stub as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant_Stub as Invariant0 with type t = C15Enumerate_Enumerate_Type.t_enumerate i val next [#"../15_enumerate.rs" 53 4 53 44] (self : borrowed (C15Enumerate_Enumerate_Type.t_enumerate i)) : Core_Option_Option_Type.t_option (usize, Item0.item) requires {[#"../15_enumerate.rs" 53 17 53 21] Invariant0.invariant' self} @@ -723,7 +723,7 @@ module C15Enumerate_Impl0_Next type Item0.item = Item0.item clone C15Enumerate_Common_Iterator_Completed_Interface as Completed1 with type self = i - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant2 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant2 with type t = i, predicate Invariant0.invariant' = Invariant3.invariant' clone C15Enumerate_Common_Iterator_ProducesTrans_Interface as ProducesTrans0 with @@ -754,7 +754,7 @@ module C15Enumerate_Impl0_Next clone C15Enumerate_Impl0_Completed as Completed0 with type i = i, predicate Completed0.completed = Completed1.completed - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant0 with type t = C15Enumerate_Enumerate_Type.t_enumerate i, predicate Invariant0.invariant' = Invariant1.invariant' use Core_Option_Option_Type as Core_Option_Option_Type @@ -861,7 +861,7 @@ module C15Enumerate_Enumerate_Interface type Item0.item = Item0.item clone C15Enumerate_Common_Iterator_Completed_Stub as Completed0 with type self = i - clone CreusotContracts_Invariant_Impl1_Invariant_Stub as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant_Stub as Invariant0 with type t = i val enumerate [#"../15_enumerate.rs" 82 0 82 54] (iter : i) : C15Enumerate_Enumerate_Type.t_enumerate i requires {[#"../15_enumerate.rs" 80 0 80 75] forall i : borrowed i . Invariant0.invariant' i -> Completed0.completed i -> Produces0.produces ( * i) (Seq.empty ) ( ^ i)} @@ -901,7 +901,7 @@ module C15Enumerate_Enumerate axiom . clone C15Enumerate_Common_Iterator_Completed_Interface as Completed0 with type self = i - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant0 with type t = i, predicate Invariant0.invariant' = Invariant1.invariant' clone Core_Usize_Max as Max0 @@ -952,7 +952,7 @@ module C15Enumerate_Impl0 type self = i clone CreusotContracts_Invariant_Invariant_Invariant_Interface as Invariant2 with type self = i - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant3 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant3 with type t = i, predicate Invariant0.invariant' = Invariant2.invariant' clone Core_Usize_Max as Max0 @@ -976,7 +976,7 @@ module C15Enumerate_Impl0 val Max0.mAX' = Max0.mAX', predicate Invariant1.invariant' = Invariant3.invariant', predicate Completed0.completed = Completed1.completed - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant1 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant1 with type t = C15Enumerate_Enumerate_Type.t_enumerate i, predicate Invariant0.invariant' = Invariant0.invariant' clone C15Enumerate_Impl0_Produces as Produces0 with diff --git a/creusot/tests/should_succeed/list_index_mut.mlcfg b/creusot/tests/should_succeed/list_index_mut.mlcfg index 5d910b4b6..9a4239cc1 100644 --- a/creusot/tests/should_succeed/list_index_mut.mlcfg +++ b/creusot/tests/should_succeed/list_index_mut.mlcfg @@ -10,40 +10,9 @@ module ListIndexMut_Option_Type | C_Some a -> a end end -module Core_Ptr_NonNull_NonNull_Type - use prelude.Opaque - type t_nonnull 't = - | C_NonNull opaque_ptr - -end -module Core_Marker_PhantomData_Type - type t_phantomdata 't = - | C_PhantomData - -end -module Core_Ptr_Unique_Unique_Type - use Core_Marker_PhantomData_Type as Core_Marker_PhantomData_Type - use Core_Ptr_NonNull_NonNull_Type as Core_Ptr_NonNull_NonNull_Type - type t_unique 't = - | C_Unique (Core_Ptr_NonNull_NonNull_Type.t_nonnull 't) (Core_Marker_PhantomData_Type.t_phantomdata 't) - -end -module Alloc_Boxed_Box_Type - use Core_Ptr_Unique_Unique_Type as Core_Ptr_Unique_Unique_Type - type t_box 't 'a = - | C_Box (Core_Ptr_Unique_Unique_Type.t_unique 't) 'a - -end -module Alloc_Alloc_Global_Type - type t_global = - | C_Global - -end module ListIndexMut_List_Type use prelude.Int use prelude.UInt32 - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type use ListIndexMut_Option_Type as ListIndexMut_Option_Type type t_list = | C_List uint32 (ListIndexMut_Option_Type.t_option (t_list)) @@ -72,9 +41,7 @@ module ListIndexMut_Len_Interface end module ListIndexMut_Len use prelude.Int - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type use ListIndexMut_List_Type as ListIndexMut_List_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type use ListIndexMut_Option_Type as ListIndexMut_Option_Type function len [#"../list_index_mut.rs" 14 0 14 22] (l : ListIndexMut_List_Type.t_list) : int = [#"../list_index_mut.rs" 13 0 13 8] let ListIndexMut_List_Type.C_List _ ls = l in 1 + match (ls) with @@ -107,9 +74,7 @@ end module ListIndexMut_Get use prelude.Int use prelude.UInt32 - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type use ListIndexMut_List_Type as ListIndexMut_List_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type use ListIndexMut_Option_Type as ListIndexMut_Option_Type function get [#"../list_index_mut.rs" 25 0 25 39] (l : ListIndexMut_List_Type.t_list) (ix : int) : ListIndexMut_Option_Type.t_option uint32 @@ -171,12 +136,10 @@ module ListIndexMut_IndexMut use prelude.Int use prelude.UIntSize use prelude.UInt32 - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use ListIndexMut_List_Type as ListIndexMut_List_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type use ListIndexMut_Option_Type as ListIndexMut_Option_Type clone CreusotContracts_Resolve_Impl1_Resolve as Resolve2 with type t = uint32 + use ListIndexMut_List_Type as ListIndexMut_List_Type clone CreusotContracts_Resolve_Impl1_Resolve as Resolve1 with type t = ListIndexMut_List_Type.t_list clone CreusotContracts_Resolve_Impl1_Resolve as Resolve0 with @@ -292,9 +255,7 @@ module ListIndexMut_Write use prelude.Int use prelude.UIntSize use prelude.UInt32 - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type use ListIndexMut_List_Type as ListIndexMut_List_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type use ListIndexMut_Option_Type as ListIndexMut_Option_Type clone ListIndexMut_Get as Get0 clone ListIndexMut_Len as Len0 @@ -345,9 +306,7 @@ module ListIndexMut_F use prelude.UInt32 use prelude.UIntSize use prelude.Borrow - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type use ListIndexMut_List_Type as ListIndexMut_List_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type use ListIndexMut_Option_Type as ListIndexMut_Option_Type clone ListIndexMut_Get as Get0 clone ListIndexMut_Len as Len0 diff --git a/creusot/tests/should_succeed/list_index_mut/why3session.xml b/creusot/tests/should_succeed/list_index_mut/why3session.xml index 238fcddd2..2ea2208cd 100644 --- a/creusot/tests/should_succeed/list_index_mut/why3session.xml +++ b/creusot/tests/should_succeed/list_index_mut/why3session.xml @@ -7,7 +7,7 @@ - + diff --git a/creusot/tests/should_succeed/list_index_mut/why3shapes.gz b/creusot/tests/should_succeed/list_index_mut/why3shapes.gz index b845885ea9abdaec2653d69cbe276ab9c6906dae..f973ea49c6a0dfb3d410e39cb52d74446c542dd0 100644 GIT binary patch literal 670 zcmV;P0%83hiwFP!00000|BX~li`y^|z57@AwymKcjcmy(o5KX-_TAT%rrGDD-O7#pp)WEMNMP=c zZ|=B%l^bih^oO>)2>c?S?e(NP8*6Tx+J;px2EZCk*5cgA?csZW*2aoi0F9t#e-`{% z-2`V3f}f+9b+__r%rt+RoOS^O3xeDjVi%HM z;ybIcd1Tuij{UV$RUsu>`#m|EZn3bzD>Kv2MrM8E_Df`TPzuon-=B>blBbt5H!3FR%<4>-e-(Lbdz^#|t%WNzln3ELQMdWx zjD(8@%*VP#L-pBRMXU^@%x$~3ViUB+t;X~ml*S5;wcVkhD(vZFXfHaMBWmKmr z$p!)kmGj*oPof%!r-nQ75;gbIB#9;%SYs4Y7N96JN+BjOYgkFSQkSl8+l1Y+BR= zDoA$w^J^O$OcJTRAbUREjAtJ2QxZ=<#cwsm?`oX7q5m4QIQblPrPzrd>LL=3I4&SV)bp;n6Tj?m#fdV1v?I z6zWil8H937JP6SrXNFB$dHmK*=4l1T*yXdznK{>K%w!cjcTl-FY0nWEPgS--TTExY z4!tVDeJ=~4H+VT4^w;=+y_PhcpI3aG__B;a-4@71p;uZ;o z2O;a4J^r@ZVPOFjLH1gBEwO#xh7`WDo8aU@@N*Ee?N(g1nbD`&X%;{*C&-Q=bRqF2 zyk`y8kL>zmJzRS^-8q+K0f*e6>H$I)QVT3W;g+D_2@2Sf2r>?ypkN5?xLb4qCx*t2OiX! zZNRZtIoAzxBx a end end -module Core_Ptr_NonNull_NonNull_Type - use prelude.Opaque - type t_nonnull 't = - | C_NonNull opaque_ptr - -end -module Core_Marker_PhantomData_Type - type t_phantomdata 't = - | C_PhantomData - -end -module Core_Ptr_Unique_Unique_Type - use Core_Marker_PhantomData_Type as Core_Marker_PhantomData_Type - use Core_Ptr_NonNull_NonNull_Type as Core_Ptr_NonNull_NonNull_Type - type t_unique 't = - | C_Unique (Core_Ptr_NonNull_NonNull_Type.t_nonnull 't) (Core_Marker_PhantomData_Type.t_phantomdata 't) - -end -module Alloc_Boxed_Box_Type - use Core_Ptr_Unique_Unique_Type as Core_Ptr_Unique_Unique_Type - type t_box 't 'a = - | C_Box (Core_Ptr_Unique_Unique_Type.t_unique 't) 'a - -end -module Alloc_Alloc_Global_Type - type t_global = - | C_Global - -end module RedBlackTree_Node_Type - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type use Core_Option_Option_Type as Core_Option_Option_Type use RedBlackTree_Color_Type as RedBlackTree_Color_Type type t_node 'k 'v = @@ -180,14 +149,12 @@ end module RedBlackTree_Impl0_HasMapping type k type v - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with type self = k clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with type self = k, type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use RedBlackTree_Node_Type as RedBlackTree_Node_Type use Core_Option_Option_Type as Core_Option_Option_Type use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type predicate has_mapping [#"../red_black_tree.rs" 31 4 31 57] (self : RedBlackTree_Tree_Type.t_tree k v) (k : DeepModelTy0.deepModelTy) (v : v) @@ -265,14 +232,12 @@ module RedBlackTree_Impl0_ModelAcc type k type v use map.Map - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with type self = k clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with type self = k, type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use RedBlackTree_Node_Type as RedBlackTree_Node_Type use Core_Option_Option_Type as Core_Option_Option_Type use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type function model_acc [#"../red_black_tree.rs" 49 4 52 47] (self : RedBlackTree_Tree_Type.t_tree k v) (accu : Map.map DeepModelTy0.deepModelTy (Core_Option_Option_Type.t_option v)) : Map.map DeepModelTy0.deepModelTy (Core_Option_Option_Type.t_option v) @@ -333,14 +298,12 @@ module RedBlackTree_Impl0_ModelAccHasMapping type k type v use map.Map - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with type self = k clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with type self = k, type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use RedBlackTree_Node_Type as RedBlackTree_Node_Type use Core_Option_Option_Type as Core_Option_Option_Type use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type clone RedBlackTree_Impl0_HasMapping_Stub as HasMapping0 with @@ -368,14 +331,12 @@ module RedBlackTree_Impl0_ModelAccHasMapping_Impl type k type v use map.Map - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with type self = k clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel0 with type self = k, type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use RedBlackTree_Node_Type as RedBlackTree_Node_Type use Core_Option_Option_Type as Core_Option_Option_Type use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type clone RedBlackTree_Impl0_HasMapping as HasMapping0 with @@ -502,9 +463,7 @@ end module RedBlackTree_Impl5_BstInvariant type k type v - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type clone RedBlackTree_Impl4_BstInvariantHere_Stub as BstInvariantHere0 with type k = k, type v = v @@ -950,9 +909,6 @@ module RedBlackTree_Impl0_HasMappingModelAcc type k type v use map.Map - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with type self = k use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type @@ -975,6 +931,7 @@ module RedBlackTree_Impl0_HasMappingModelAcc clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with type self = k, type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use RedBlackTree_Node_Type as RedBlackTree_Node_Type clone RedBlackTree_Impl5_BstInvariant_Stub as BstInvariant0 with type k = k, type v = v @@ -1049,13 +1006,11 @@ module RedBlackTree_Impl0_HasMappingModelAcc_Impl predicate LeLog0.le_log = LeLog0.le_log, function CmpLog0.cmp_log = CmpLog0.cmp_log, axiom . - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel0 with type self = k, type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use RedBlackTree_Node_Type as RedBlackTree_Node_Type use Core_Option_Option_Type as Core_Option_Option_Type clone RedBlackTree_Impl0_HasMapping as HasMapping0 with type k = k, @@ -1300,12 +1255,10 @@ module RedBlackTree_Impl0_HasMappingModel_Impl predicate LeLog0.le_log = LeLog0.le_log, function CmpLog0.cmp_log = CmpLog0.cmp_log, axiom . - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel0 with type self = k, type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use RedBlackTree_Node_Type as RedBlackTree_Node_Type use Core_Option_Option_Type as Core_Option_Option_Type use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type clone RedBlackTree_Impl0_ModelAcc as ModelAcc0 with @@ -1499,12 +1452,10 @@ module RedBlackTree_Impl0_HasMappingInj_Impl predicate LeLog0.le_log = LeLog0.le_log, function CmpLog0.cmp_log = CmpLog0.cmp_log, axiom . - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel0 with type self = k, type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use RedBlackTree_Node_Type as RedBlackTree_Node_Type use Core_Option_Option_Type as Core_Option_Option_Type use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type clone RedBlackTree_Impl0_ModelAcc as ModelAcc0 with @@ -1577,9 +1528,6 @@ end module RedBlackTree_Impl1_HasMapping_Stub type k type v - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with type self = k use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type @@ -1587,6 +1535,7 @@ module RedBlackTree_Impl1_HasMapping_Stub type k = k, type v = v, type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use RedBlackTree_Node_Type as RedBlackTree_Node_Type use Core_Option_Option_Type as Core_Option_Option_Type predicate has_mapping [#"../red_black_tree.rs" 140 4 140 57] (self : RedBlackTree_Node_Type.t_node k v) (k : DeepModelTy0.deepModelTy) (v : v) @@ -1594,9 +1543,6 @@ end module RedBlackTree_Impl1_HasMapping_Interface type k type v - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with type self = k use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type @@ -1604,6 +1550,7 @@ module RedBlackTree_Impl1_HasMapping_Interface type k = k, type v = v, type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use RedBlackTree_Node_Type as RedBlackTree_Node_Type use Core_Option_Option_Type as Core_Option_Option_Type predicate has_mapping [#"../red_black_tree.rs" 140 4 140 57] (self : RedBlackTree_Node_Type.t_node k v) (k : DeepModelTy0.deepModelTy) (v : v) @@ -1616,9 +1563,6 @@ end module RedBlackTree_Impl1_HasMapping type k type v - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with type self = k clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with @@ -1629,6 +1573,7 @@ module RedBlackTree_Impl1_HasMapping type k = k, type v = v, type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use RedBlackTree_Node_Type as RedBlackTree_Node_Type use Core_Option_Option_Type as Core_Option_Option_Type predicate has_mapping [#"../red_black_tree.rs" 140 4 140 57] (self : RedBlackTree_Node_Type.t_node k v) (k : DeepModelTy0.deepModelTy) (v : v) @@ -1643,14 +1588,12 @@ end module RedBlackTree_Impl1_HasMapping_Impl type k type v - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with type self = k clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel0 with type self = k, type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use RedBlackTree_Node_Type as RedBlackTree_Node_Type use Core_Option_Option_Type as Core_Option_Option_Type use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type clone RedBlackTree_Impl0_HasMapping as HasMapping0 with @@ -1684,9 +1627,6 @@ end module RedBlackTree_Impl1_SameMappings type k type v - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with type self = k use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type @@ -1694,6 +1634,7 @@ module RedBlackTree_Impl1_SameMappings type k = k, type v = v, type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use RedBlackTree_Node_Type as RedBlackTree_Node_Type use Core_Option_Option_Type as Core_Option_Option_Type clone RedBlackTree_Impl1_HasMapping_Stub as HasMapping0 with type k = k, @@ -1849,9 +1790,7 @@ end module RedBlackTree_Impl7_Color type k type v - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type use Core_Option_Option_Type as Core_Option_Option_Type use RedBlackTree_Color_Type as RedBlackTree_Color_Type use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type @@ -1914,9 +1853,7 @@ end module RedBlackTree_Impl7_ColorInvariant type k type v - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type clone RedBlackTree_Impl8_ColorInvariantHere_Stub as ColorInvariantHere0 with type k = k, type v = v @@ -1953,10 +1890,8 @@ end module RedBlackTree_Impl6_MatchT type k type v - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type use RedBlackTree_Color_Type as RedBlackTree_Color_Type + use RedBlackTree_Node_Type as RedBlackTree_Node_Type use Core_Option_Option_Type as Core_Option_Option_Type use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type clone RedBlackTree_Impl7_ColorInvariant_Stub as ColorInvariant0 with @@ -2074,10 +2009,8 @@ module RedBlackTree_Impl9_Height type k type v use prelude.Int - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type use RedBlackTree_Color_Type as RedBlackTree_Color_Type + use RedBlackTree_Node_Type as RedBlackTree_Node_Type use Core_Option_Option_Type as Core_Option_Option_Type use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type function height [#"../red_black_tree.rs" 296 4 296 26] (self : RedBlackTree_Tree_Type.t_tree k v) : int = @@ -2098,10 +2031,8 @@ module RedBlackTree_Impl9_Height_Impl type k type v use prelude.Int - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type use RedBlackTree_Color_Type as RedBlackTree_Color_Type + use RedBlackTree_Node_Type as RedBlackTree_Node_Type use Core_Option_Option_Type as Core_Option_Option_Type use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type let rec ghost function height [#"../red_black_tree.rs" 296 4 296 26] (self : RedBlackTree_Tree_Type.t_tree k v) : int @@ -2164,9 +2095,7 @@ end module RedBlackTree_Impl9_HeightInvariant type k type v - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type clone RedBlackTree_Impl10_HeightInvariantHere_Stub as HeightInvariantHere0 with type k = k, type v = v @@ -2185,14 +2114,12 @@ module RedBlackTree_Impl10_Height_Stub type k type v use prelude.Int - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type clone RedBlackTree_Impl9_Height_Stub as Height0 with type k = k, type v = v, axiom . + use RedBlackTree_Node_Type as RedBlackTree_Node_Type use Core_Option_Option_Type as Core_Option_Option_Type function height [#"../red_black_tree.rs" 328 4 328 26] (self : RedBlackTree_Node_Type.t_node k v) : int end @@ -2200,14 +2127,12 @@ module RedBlackTree_Impl10_Height_Interface type k type v use prelude.Int - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type clone RedBlackTree_Impl9_Height_Stub as Height0 with type k = k, type v = v, axiom . + use RedBlackTree_Node_Type as RedBlackTree_Node_Type use Core_Option_Option_Type as Core_Option_Option_Type function height [#"../red_black_tree.rs" 328 4 328 26] (self : RedBlackTree_Node_Type.t_node k v) : int val height [#"../red_black_tree.rs" 328 4 328 26] (self : RedBlackTree_Node_Type.t_node k v) : int @@ -2220,15 +2145,13 @@ module RedBlackTree_Impl10_Height type k type v use prelude.Int - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type use RedBlackTree_Color_Type as RedBlackTree_Color_Type use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type clone RedBlackTree_Impl9_Height_Stub as Height0 with type k = k, type v = v, axiom . + use RedBlackTree_Node_Type as RedBlackTree_Node_Type use Core_Option_Option_Type as Core_Option_Option_Type function height [#"../red_black_tree.rs" 328 4 328 26] (self : RedBlackTree_Node_Type.t_node k v) : int = [#"../red_black_tree.rs" 330 12 333 13] match (RedBlackTree_Node_Type.node_color self) with @@ -2245,10 +2168,8 @@ module RedBlackTree_Impl10_Height_Impl type k type v use prelude.Int - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type use RedBlackTree_Color_Type as RedBlackTree_Color_Type + use RedBlackTree_Node_Type as RedBlackTree_Node_Type use Core_Option_Option_Type as Core_Option_Option_Type use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type clone RedBlackTree_Impl9_Height as Height0 with @@ -2428,19 +2349,17 @@ module RedBlackTree_Impl13_IsRed type k type v use prelude.Borrow - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type use Core_Option_Option_Type as Core_Option_Option_Type use RedBlackTree_Color_Type as RedBlackTree_Color_Type use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type - clone RedBlackTree_Impl7_Color as Color1 with + clone RedBlackTree_Impl7_Color as Color0 with type k = k, type v = v clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with type self = RedBlackTree_Tree_Type.t_tree k v let rec cfg is_red [#"../red_black_tree.rs" 388 4 388 28] [@cfg:stackify] [@cfg:subregion_analysis] (self : RedBlackTree_Tree_Type.t_tree k v) : bool - ensures { [#"../red_black_tree.rs" 387 14 387 45] result = (Color1.color self = RedBlackTree_Color_Type.C_Red) } + ensures { [#"../red_black_tree.rs" 387 14 387 45] result = (Color0.color self = RedBlackTree_Color_Type.C_Red) } = [@vc:do_not_keep_trace] [@vc:sp] var _0 : bool; @@ -2573,9 +2492,6 @@ module RedBlackTree_Impl14_RotateRight_Interface type k type v use prelude.Borrow - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with type self = k use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type @@ -2583,6 +2499,7 @@ module RedBlackTree_Impl14_RotateRight_Interface type k = k, type v = v, axiom . + use RedBlackTree_Node_Type as RedBlackTree_Node_Type use Core_Option_Option_Type as Core_Option_Option_Type clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Stub as LtLog0 with type self = DeepModelTy0.deepModelTy @@ -2632,11 +2549,9 @@ module RedBlackTree_Impl14_RotateRight type self = DeepModelTy0.deepModelTy clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with type self = DeepModelTy0.deepModelTy - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type use RedBlackTree_Color_Type as RedBlackTree_Color_Type + use RedBlackTree_Node_Type as RedBlackTree_Node_Type use Core_Option_Option_Type as Core_Option_Option_Type clone RedBlackTree_Impl9_Height as Height1 with type k = k, @@ -2742,7 +2657,7 @@ module RedBlackTree_Impl14_RotateRight type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, predicate HasMapping0.has_mapping = HasMapping1.has_mapping, predicate HasMapping1.has_mapping = HasMapping0.has_mapping - clone RedBlackTree_Impl7_Color as Color1 with + clone RedBlackTree_Impl7_Color as Color0 with type k = k, type v = v clone RedBlackTree_Impl12_InternalInvariant as InternalInvariant0 with @@ -2777,12 +2692,12 @@ module RedBlackTree_Impl14_RotateRight type self = Ghost.ghost_ty (borrowed (RedBlackTree_Node_Type.t_node k v)) let rec cfg rotate_right [#"../red_black_tree.rs" 412 4 412 30] [@cfg:stackify] [@cfg:subregion_analysis] (self : borrowed (RedBlackTree_Node_Type.t_node k v)) : () requires {[#"../red_black_tree.rs" 400 15 400 43] InternalInvariant0.internal_invariant ( * self)} - requires {[#"../red_black_tree.rs" 401 15 401 42] Color1.color (RedBlackTree_Node_Type.node_left ( * self)) = RedBlackTree_Color_Type.C_Red} + requires {[#"../red_black_tree.rs" 401 15 401 42] Color0.color (RedBlackTree_Node_Type.node_left ( * self)) = RedBlackTree_Color_Type.C_Red} ensures { [#"../red_black_tree.rs" 402 14 402 42] SameMappings0.same_mappings ( * self) ( ^ self) } ensures { [#"../red_black_tree.rs" 403 14 403 42] InternalInvariant0.internal_invariant ( ^ self) } ensures { [#"../red_black_tree.rs" 404 14 404 50] Height0.height ( * self) = Height0.height ( ^ self) } ensures { [#"../red_black_tree.rs" 405 14 405 65] LtLog0.lt_log (DeepModel0.deep_model (RedBlackTree_Node_Type.node_key ( ^ self))) (DeepModel0.deep_model (RedBlackTree_Node_Type.node_key ( * self))) } - ensures { [#"../red_black_tree.rs" 406 14 406 42] Color1.color (RedBlackTree_Node_Type.node_right ( ^ self)) = RedBlackTree_Color_Type.C_Red } + ensures { [#"../red_black_tree.rs" 406 14 406 42] Color0.color (RedBlackTree_Node_Type.node_right ( ^ self)) = RedBlackTree_Color_Type.C_Red } ensures { [#"../red_black_tree.rs" 407 14 407 44] RedBlackTree_Node_Type.node_color ( ^ self) = RedBlackTree_Node_Type.node_color ( * self) } ensures { [#"../red_black_tree.rs" 408 4 411 36] exists r : RedBlackTree_Node_Type.t_node k v . exists l : RedBlackTree_Node_Type.t_node k v . RedBlackTree_Tree_Type.tree_node (RedBlackTree_Node_Type.node_left ( * self)) = Core_Option_Option_Type.C_Some l /\ RedBlackTree_Tree_Type.tree_node (RedBlackTree_Node_Type.node_right ( ^ self)) = Core_Option_Option_Type.C_Some r /\ (RedBlackTree_Node_Type.node_left ( ^ self), RedBlackTree_Node_Type.node_left r, RedBlackTree_Node_Type.node_right r) = (RedBlackTree_Node_Type.node_left l, RedBlackTree_Node_Type.node_right l, RedBlackTree_Node_Type.node_right ( * self)) /\ RedBlackTree_Node_Type.node_key r = RedBlackTree_Node_Type.node_key ( * self) } @@ -2903,9 +2818,6 @@ module RedBlackTree_Impl14_RotateLeft_Interface type k type v use prelude.Borrow - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with type self = k use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type @@ -2913,6 +2825,7 @@ module RedBlackTree_Impl14_RotateLeft_Interface type k = k, type v = v, axiom . + use RedBlackTree_Node_Type as RedBlackTree_Node_Type use Core_Option_Option_Type as Core_Option_Option_Type clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Stub as LtLog0 with type self = DeepModelTy0.deepModelTy @@ -2962,11 +2875,9 @@ module RedBlackTree_Impl14_RotateLeft type self = DeepModelTy0.deepModelTy clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with type self = DeepModelTy0.deepModelTy - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type use RedBlackTree_Color_Type as RedBlackTree_Color_Type + use RedBlackTree_Node_Type as RedBlackTree_Node_Type use Core_Option_Option_Type as Core_Option_Option_Type clone RedBlackTree_Impl9_Height as Height1 with type k = k, @@ -3072,7 +2983,7 @@ module RedBlackTree_Impl14_RotateLeft type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, predicate HasMapping0.has_mapping = HasMapping1.has_mapping, predicate HasMapping1.has_mapping = HasMapping0.has_mapping - clone RedBlackTree_Impl7_Color as Color1 with + clone RedBlackTree_Impl7_Color as Color0 with type k = k, type v = v clone RedBlackTree_Impl12_InternalInvariant as InternalInvariant0 with @@ -3107,12 +3018,12 @@ module RedBlackTree_Impl14_RotateLeft type self = Ghost.ghost_ty (borrowed (RedBlackTree_Node_Type.t_node k v)) let rec cfg rotate_left [#"../red_black_tree.rs" 462 4 462 29] [@cfg:stackify] [@cfg:subregion_analysis] (self : borrowed (RedBlackTree_Node_Type.t_node k v)) : () requires {[#"../red_black_tree.rs" 450 15 450 43] InternalInvariant0.internal_invariant ( * self)} - requires {[#"../red_black_tree.rs" 451 15 451 43] Color1.color (RedBlackTree_Node_Type.node_right ( * self)) = RedBlackTree_Color_Type.C_Red} + requires {[#"../red_black_tree.rs" 451 15 451 43] Color0.color (RedBlackTree_Node_Type.node_right ( * self)) = RedBlackTree_Color_Type.C_Red} ensures { [#"../red_black_tree.rs" 452 14 452 42] SameMappings0.same_mappings ( * self) ( ^ self) } ensures { [#"../red_black_tree.rs" 453 14 453 42] InternalInvariant0.internal_invariant ( ^ self) } ensures { [#"../red_black_tree.rs" 454 14 454 50] Height0.height ( * self) = Height0.height ( ^ self) } ensures { [#"../red_black_tree.rs" 455 14 455 65] LtLog0.lt_log (DeepModel0.deep_model (RedBlackTree_Node_Type.node_key ( * self))) (DeepModel0.deep_model (RedBlackTree_Node_Type.node_key ( ^ self))) } - ensures { [#"../red_black_tree.rs" 456 14 456 41] Color1.color (RedBlackTree_Node_Type.node_left ( ^ self)) = RedBlackTree_Color_Type.C_Red } + ensures { [#"../red_black_tree.rs" 456 14 456 41] Color0.color (RedBlackTree_Node_Type.node_left ( ^ self)) = RedBlackTree_Color_Type.C_Red } ensures { [#"../red_black_tree.rs" 457 14 457 44] RedBlackTree_Node_Type.node_color ( ^ self) = RedBlackTree_Node_Type.node_color ( * self) } ensures { [#"../red_black_tree.rs" 458 4 461 36] exists r : RedBlackTree_Node_Type.t_node k v . exists l : RedBlackTree_Node_Type.t_node k v . RedBlackTree_Tree_Type.tree_node (RedBlackTree_Node_Type.node_right ( * self)) = Core_Option_Option_Type.C_Some r /\ RedBlackTree_Tree_Type.tree_node (RedBlackTree_Node_Type.node_left ( ^ self)) = Core_Option_Option_Type.C_Some l /\ (RedBlackTree_Node_Type.node_left l, RedBlackTree_Node_Type.node_right l, RedBlackTree_Node_Type.node_right ( ^ self)) = (RedBlackTree_Node_Type.node_left ( * self), RedBlackTree_Node_Type.node_left r, RedBlackTree_Node_Type.node_right r) /\ RedBlackTree_Node_Type.node_key l = RedBlackTree_Node_Type.node_key ( * self) } @@ -3248,9 +3159,7 @@ module RedBlackTree_Impl14_FlipColors_Interface type v = v, axiom . use RedBlackTree_Color_Type as RedBlackTree_Color_Type - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type clone RedBlackTree_Impl1_SameMappings_Stub as SameMappings0 with type k = k, type v = v @@ -3339,11 +3248,9 @@ module RedBlackTree_Impl14_FlipColors clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel0 with type self = k, type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type use RedBlackTree_Color_Type as RedBlackTree_Color_Type + use RedBlackTree_Node_Type as RedBlackTree_Node_Type use Core_Option_Option_Type as Core_Option_Option_Type clone RedBlackTree_Impl9_Height as Height1 with type k = k, @@ -3401,7 +3308,7 @@ module RedBlackTree_Impl14_FlipColors type v = v, function Height0.height = Height1.height, axiom . - clone RedBlackTree_Impl7_Color as Color1 with + clone RedBlackTree_Impl7_Color as Color0 with type k = k, type v = v clone RedBlackTree_Impl12_InternalInvariant as InternalInvariant0 with @@ -3425,7 +3332,7 @@ module RedBlackTree_Impl14_FlipColors requires {[#"../red_black_tree.rs" 472 15 472 43] InternalInvariant0.internal_invariant ( * self)} requires {[#"../red_black_tree.rs" 473 15 473 40] RedBlackTree_Tree_Type.tree_node (RedBlackTree_Node_Type.node_left ( * self)) <> Core_Option_Option_Type.C_None} requires {[#"../red_black_tree.rs" 474 15 474 41] RedBlackTree_Tree_Type.tree_node (RedBlackTree_Node_Type.node_right ( * self)) <> Core_Option_Option_Type.C_None} - requires {[#"../red_black_tree.rs" 475 15 475 60] Color1.color (RedBlackTree_Node_Type.node_left ( * self)) = Color1.color (RedBlackTree_Node_Type.node_right ( * self))} + requires {[#"../red_black_tree.rs" 475 15 475 60] Color0.color (RedBlackTree_Node_Type.node_left ( * self)) = Color0.color (RedBlackTree_Node_Type.node_right ( * self))} ensures { [#"../red_black_tree.rs" 476 14 476 42] InternalInvariant0.internal_invariant ( ^ self) } ensures { [#"../red_black_tree.rs" 477 14 477 50] Height0.height ( * self) = Height0.height ( ^ self) } ensures { [#"../red_black_tree.rs" 478 14 478 42] SameMappings0.same_mappings ( * self) ( ^ self) } @@ -3507,14 +3414,12 @@ module RedBlackTree_Impl14_Balance_Interface type k type v use prelude.Borrow - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type clone RedBlackTree_Impl9_Height_Stub as Height1 with type k = k, type v = v, axiom . + use RedBlackTree_Node_Type as RedBlackTree_Node_Type use Core_Option_Option_Type as Core_Option_Option_Type use RedBlackTree_Cp_Type as RedBlackTree_Cp_Type clone RedBlackTree_Impl6_MatchN_Stub as MatchN0 with @@ -3533,7 +3438,7 @@ module RedBlackTree_Impl14_Balance_Interface clone RedBlackTree_Impl7_ColorInvariant_Stub as ColorInvariant0 with type k = k, type v = v - clone RedBlackTree_Impl7_Color_Stub as Color1 with + clone RedBlackTree_Impl7_Color_Stub as Color0 with type k = k, type v = v clone RedBlackTree_Impl12_InternalInvariant_Stub as InternalInvariant0 with @@ -3541,13 +3446,13 @@ module RedBlackTree_Impl14_Balance_Interface type v = v val balance [#"../red_black_tree.rs" 510 4 510 25] (self : borrowed (RedBlackTree_Node_Type.t_node k v)) : () requires {[#"../red_black_tree.rs" 491 15 491 43] InternalInvariant0.internal_invariant ( * self)} - requires {[#"../red_black_tree.rs" 492 4 493 47] RedBlackTree_Node_Type.node_color ( * self) = RedBlackTree_Color_Type.C_Red /\ Color1.color (RedBlackTree_Node_Type.node_left ( * self)) = RedBlackTree_Color_Type.C_Red -> ColorInvariant0.color_invariant (RedBlackTree_Node_Type.node_left ( * self))} - requires {[#"../red_black_tree.rs" 494 4 495 48] RedBlackTree_Node_Type.node_color ( * self) = RedBlackTree_Color_Type.C_Red /\ Color1.color (RedBlackTree_Node_Type.node_right ( * self)) = RedBlackTree_Color_Type.C_Red -> ColorInvariant0.color_invariant (RedBlackTree_Node_Type.node_right ( * self))} - requires {[#"../red_black_tree.rs" 496 4 496 110] RedBlackTree_Node_Type.node_color ( * self) = RedBlackTree_Color_Type.C_Red /\ Color1.color (RedBlackTree_Node_Type.node_right ( * self)) = RedBlackTree_Color_Type.C_Red /\ Color1.color (RedBlackTree_Node_Type.node_left ( * self)) = RedBlackTree_Color_Type.C_Red -> false} + requires {[#"../red_black_tree.rs" 492 4 493 47] RedBlackTree_Node_Type.node_color ( * self) = RedBlackTree_Color_Type.C_Red /\ Color0.color (RedBlackTree_Node_Type.node_left ( * self)) = RedBlackTree_Color_Type.C_Red -> ColorInvariant0.color_invariant (RedBlackTree_Node_Type.node_left ( * self))} + requires {[#"../red_black_tree.rs" 494 4 495 48] RedBlackTree_Node_Type.node_color ( * self) = RedBlackTree_Color_Type.C_Red /\ Color0.color (RedBlackTree_Node_Type.node_right ( * self)) = RedBlackTree_Color_Type.C_Red -> ColorInvariant0.color_invariant (RedBlackTree_Node_Type.node_right ( * self))} + requires {[#"../red_black_tree.rs" 496 4 496 110] RedBlackTree_Node_Type.node_color ( * self) = RedBlackTree_Color_Type.C_Red /\ Color0.color (RedBlackTree_Node_Type.node_right ( * self)) = RedBlackTree_Color_Type.C_Red /\ Color0.color (RedBlackTree_Node_Type.node_left ( * self)) = RedBlackTree_Color_Type.C_Red -> false} ensures { [#"../red_black_tree.rs" 497 14 497 42] SameMappings0.same_mappings ( * self) ( ^ self) } ensures { [#"../red_black_tree.rs" 498 14 498 42] InternalInvariant0.internal_invariant ( ^ self) } ensures { [#"../red_black_tree.rs" 499 14 499 50] Height0.height ( * self) = Height0.height ( ^ self) } - ensures { [#"../red_black_tree.rs" 500 4 501 34] ColorInvariant0.color_invariant (RedBlackTree_Node_Type.node_left ( * self)) /\ Color1.color (RedBlackTree_Node_Type.node_right ( * self)) = RedBlackTree_Color_Type.C_Black -> * self = ^ self } + ensures { [#"../red_black_tree.rs" 500 4 501 34] ColorInvariant0.color_invariant (RedBlackTree_Node_Type.node_left ( * self)) /\ Color0.color (RedBlackTree_Node_Type.node_right ( * self)) = RedBlackTree_Color_Type.C_Black -> * self = ^ self } ensures { [#"../red_black_tree.rs" 502 4 503 39] MatchN0.match_n (Cpn0.cpn (RedBlackTree_Color_Type.C_Black) (Cpn0.cpn (RedBlackTree_Color_Type.C_Red) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Red)) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Black))) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Black))) ( * self) -> MatchN0.match_n (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Red)) ( ^ self) } ensures { [#"../red_black_tree.rs" 504 4 505 63] MatchN0.match_n (Cpn0.cpn (RedBlackTree_Color_Type.C_Black) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Black)) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Red))) ( * self) -> MatchN0.match_n (Cpn0.cpn (RedBlackTree_Color_Type.C_Black) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Red)) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Black))) ( ^ self) } ensures { [#"../red_black_tree.rs" 506 4 507 61] MatchN0.match_n (Cpn0.cpn (RedBlackTree_Color_Type.C_Red) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Black)) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Red))) ( * self) -> MatchN0.match_n (Cpn0.cpn (RedBlackTree_Color_Type.C_Red) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Red)) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Black))) ( ^ self) } @@ -3569,11 +3474,9 @@ module RedBlackTree_Impl14_Balance type self = DeepModelTy0.deepModelTy clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with type self = DeepModelTy0.deepModelTy - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type use RedBlackTree_Color_Type as RedBlackTree_Color_Type + use RedBlackTree_Node_Type as RedBlackTree_Node_Type use Core_Option_Option_Type as Core_Option_Option_Type clone RedBlackTree_Impl9_Height as Height1 with type k = k, @@ -3648,13 +3551,13 @@ module RedBlackTree_Impl14_Balance predicate LeLog0.le_log = LeLog0.le_log, function CmpLog0.cmp_log = CmpLog0.cmp_log, axiom . - clone RedBlackTree_Impl7_Color as Color1 with + clone RedBlackTree_Impl7_Color as Color0 with type k = k, type v = v clone RedBlackTree_Impl8_ColorInvariantHere as ColorInvariantHere0 with type k = k, type v = v, - function Color0.color = Color1.color + function Color0.color = Color0.color clone RedBlackTree_Impl7_ColorInvariant as ColorInvariant0 with type k = k, type v = v, @@ -3663,7 +3566,7 @@ module RedBlackTree_Impl14_Balance clone RedBlackTree_Impl6_MatchT as MatchT0 with type k = k, type v = v, - function Color0.color = Color1.color, + function Color0.color = Color0.color, predicate ColorInvariant0.color_invariant = ColorInvariant0.color_invariant clone RedBlackTree_Impl8_ColorInvariant as ColorInvariant1 with type k = k, @@ -3715,7 +3618,7 @@ module RedBlackTree_Impl14_Balance type k = k, type v = v, predicate InternalInvariant0.internal_invariant = InternalInvariant0.internal_invariant, - function Color0.color = Color1.color, + function Color0.color = Color0.color, function Height0.height = Height0.height, predicate SameMappings0.same_mappings = SameMappings0.same_mappings, function Height1.height = Height1.height @@ -3723,7 +3626,7 @@ module RedBlackTree_Impl14_Balance type k = k, type v = v, predicate InternalInvariant0.internal_invariant = InternalInvariant0.internal_invariant, - function Color0.color = Color1.color, + function Color0.color = Color0.color, predicate SameMappings0.same_mappings = SameMappings0.same_mappings, function Height0.height = Height0.height, function DeepModel0.deep_model = DeepModel0.deep_model, @@ -3740,7 +3643,7 @@ module RedBlackTree_Impl14_Balance type k = k, type v = v, predicate InternalInvariant0.internal_invariant = InternalInvariant0.internal_invariant, - function Color0.color = Color1.color, + function Color0.color = Color0.color, predicate SameMappings0.same_mappings = SameMappings0.same_mappings, function Height0.height = Height0.height, function DeepModel0.deep_model = DeepModel0.deep_model, @@ -3750,16 +3653,16 @@ module RedBlackTree_Impl14_Balance clone RedBlackTree_Impl13_IsRed_Interface as IsRed0 with type k = k, type v = v, - function Color0.color = Color1.color + function Color0.color = Color0.color let rec cfg balance [#"../red_black_tree.rs" 510 4 510 25] [@cfg:stackify] [@cfg:subregion_analysis] (self : borrowed (RedBlackTree_Node_Type.t_node k v)) : () requires {[#"../red_black_tree.rs" 491 15 491 43] InternalInvariant0.internal_invariant ( * self)} - requires {[#"../red_black_tree.rs" 492 4 493 47] RedBlackTree_Node_Type.node_color ( * self) = RedBlackTree_Color_Type.C_Red /\ Color1.color (RedBlackTree_Node_Type.node_left ( * self)) = RedBlackTree_Color_Type.C_Red -> ColorInvariant0.color_invariant (RedBlackTree_Node_Type.node_left ( * self))} - requires {[#"../red_black_tree.rs" 494 4 495 48] RedBlackTree_Node_Type.node_color ( * self) = RedBlackTree_Color_Type.C_Red /\ Color1.color (RedBlackTree_Node_Type.node_right ( * self)) = RedBlackTree_Color_Type.C_Red -> ColorInvariant0.color_invariant (RedBlackTree_Node_Type.node_right ( * self))} - requires {[#"../red_black_tree.rs" 496 4 496 110] RedBlackTree_Node_Type.node_color ( * self) = RedBlackTree_Color_Type.C_Red /\ Color1.color (RedBlackTree_Node_Type.node_right ( * self)) = RedBlackTree_Color_Type.C_Red /\ Color1.color (RedBlackTree_Node_Type.node_left ( * self)) = RedBlackTree_Color_Type.C_Red -> false} + requires {[#"../red_black_tree.rs" 492 4 493 47] RedBlackTree_Node_Type.node_color ( * self) = RedBlackTree_Color_Type.C_Red /\ Color0.color (RedBlackTree_Node_Type.node_left ( * self)) = RedBlackTree_Color_Type.C_Red -> ColorInvariant0.color_invariant (RedBlackTree_Node_Type.node_left ( * self))} + requires {[#"../red_black_tree.rs" 494 4 495 48] RedBlackTree_Node_Type.node_color ( * self) = RedBlackTree_Color_Type.C_Red /\ Color0.color (RedBlackTree_Node_Type.node_right ( * self)) = RedBlackTree_Color_Type.C_Red -> ColorInvariant0.color_invariant (RedBlackTree_Node_Type.node_right ( * self))} + requires {[#"../red_black_tree.rs" 496 4 496 110] RedBlackTree_Node_Type.node_color ( * self) = RedBlackTree_Color_Type.C_Red /\ Color0.color (RedBlackTree_Node_Type.node_right ( * self)) = RedBlackTree_Color_Type.C_Red /\ Color0.color (RedBlackTree_Node_Type.node_left ( * self)) = RedBlackTree_Color_Type.C_Red -> false} ensures { [#"../red_black_tree.rs" 497 14 497 42] SameMappings0.same_mappings ( * self) ( ^ self) } ensures { [#"../red_black_tree.rs" 498 14 498 42] InternalInvariant0.internal_invariant ( ^ self) } ensures { [#"../red_black_tree.rs" 499 14 499 50] Height0.height ( * self) = Height0.height ( ^ self) } - ensures { [#"../red_black_tree.rs" 500 4 501 34] ColorInvariant0.color_invariant (RedBlackTree_Node_Type.node_left ( * self)) /\ Color1.color (RedBlackTree_Node_Type.node_right ( * self)) = RedBlackTree_Color_Type.C_Black -> * self = ^ self } + ensures { [#"../red_black_tree.rs" 500 4 501 34] ColorInvariant0.color_invariant (RedBlackTree_Node_Type.node_left ( * self)) /\ Color0.color (RedBlackTree_Node_Type.node_right ( * self)) = RedBlackTree_Color_Type.C_Black -> * self = ^ self } ensures { [#"../red_black_tree.rs" 502 4 503 39] MatchN0.match_n (Cpn0.cpn (RedBlackTree_Color_Type.C_Black) (Cpn0.cpn (RedBlackTree_Color_Type.C_Red) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Red)) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Black))) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Black))) ( * self) -> MatchN0.match_n (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Red)) ( ^ self) } ensures { [#"../red_black_tree.rs" 504 4 505 63] MatchN0.match_n (Cpn0.cpn (RedBlackTree_Color_Type.C_Black) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Black)) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Red))) ( * self) -> MatchN0.match_n (Cpn0.cpn (RedBlackTree_Color_Type.C_Black) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Red)) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Black))) ( ^ self) } ensures { [#"../red_black_tree.rs" 506 4 507 61] MatchN0.match_n (Cpn0.cpn (RedBlackTree_Color_Type.C_Red) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Black)) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Red))) ( * self) -> MatchN0.match_n (Cpn0.cpn (RedBlackTree_Color_Type.C_Red) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Red)) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Black))) ( ^ self) } @@ -3936,13 +3839,11 @@ module RedBlackTree_Impl14_MoveRedLeft_Interface type k = k, type v = v, axiom . - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type use RedBlackTree_Color_Type as RedBlackTree_Color_Type - clone RedBlackTree_Impl7_Color_Stub as Color1 with + clone RedBlackTree_Impl7_Color_Stub as Color0 with type k = k, type v = v + use RedBlackTree_Node_Type as RedBlackTree_Node_Type clone RedBlackTree_Impl8_ColorInvariant_Stub as ColorInvariant0 with type k = k, type v = v @@ -3983,7 +3884,7 @@ module RedBlackTree_Impl14_MoveRedLeft_Interface ensures { [#"../red_black_tree.rs" 534 4 535 47] forall v : v . forall k : DeepModelTy0.deepModelTy . HasMapping0.has_mapping ( * self) k v /\ LeLog0.le_log k (DeepModel0.deep_model (RedBlackTree_Node_Type.node_key ( * self))) -> HasMapping0.has_mapping ( * result) k v } ensures { [#"../red_black_tree.rs" 536 4 537 108] forall v : v . forall k : DeepModelTy0.deepModelTy . HasMapping0.has_mapping ( ^ self) k v = (HasMapping0.has_mapping ( ^ result) k v \/ HasMapping0.has_mapping ( * self) k v /\ not HasMapping0.has_mapping ( * result) k v) } ensures { [#"../red_black_tree.rs" 538 14 539 61] MatchN0.match_n (Cpn0.cpn (RedBlackTree_Color_Type.C_Black) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Red)) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Black))) ( * result) \/ MatchN0.match_n (Cpn0.cpn (RedBlackTree_Color_Type.C_Black) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Red)) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Red))) ( * result) } - ensures { [#"../red_black_tree.rs" 540 4 541 45] ColorInvariant0.color_invariant ( ^ result) /\ (Color1.color (RedBlackTree_Node_Type.node_right ( * result)) = RedBlackTree_Color_Type.C_Black -> RedBlackTree_Node_Type.node_color ( ^ result) = RedBlackTree_Color_Type.C_Black) -> ColorInvariant0.color_invariant ( ^ self) } + ensures { [#"../red_black_tree.rs" 540 4 541 45] ColorInvariant0.color_invariant ( ^ result) /\ (Color0.color (RedBlackTree_Node_Type.node_right ( * result)) = RedBlackTree_Color_Type.C_Black -> RedBlackTree_Node_Type.node_color ( ^ result) = RedBlackTree_Color_Type.C_Black) -> ColorInvariant0.color_invariant ( ^ self) } end module RedBlackTree_Impl14_MoveRedLeft @@ -3999,11 +3900,9 @@ module RedBlackTree_Impl14_MoveRedLeft use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with type self = DeepModelTy0.deepModelTy - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type use RedBlackTree_Color_Type as RedBlackTree_Color_Type + use RedBlackTree_Node_Type as RedBlackTree_Node_Type use Core_Option_Option_Type as Core_Option_Option_Type clone RedBlackTree_Impl9_Height as Height1 with type k = k, @@ -4038,13 +3937,13 @@ module RedBlackTree_Impl14_MoveRedLeft type k = k, type v = v, predicate BstInvariantHere0.bst_invariant_here = BstInvariantHere0.bst_invariant_here - clone RedBlackTree_Impl7_Color as Color1 with + clone RedBlackTree_Impl7_Color as Color0 with type k = k, type v = v clone RedBlackTree_Impl8_ColorInvariantHere as ColorInvariantHere0 with type k = k, type v = v, - function Color0.color = Color1.color + function Color0.color = Color0.color clone RedBlackTree_Impl7_ColorInvariant as ColorInvariant1 with type k = k, type v = v, @@ -4095,7 +3994,7 @@ module RedBlackTree_Impl14_MoveRedLeft clone RedBlackTree_Impl6_MatchT as MatchT0 with type k = k, type v = v, - function Color0.color = Color1.color, + function Color0.color = Color0.color, predicate ColorInvariant0.color_invariant = ColorInvariant1.color_invariant clone RedBlackTree_Impl10_HeightInvariant as HeightInvariant0 with type k = k, @@ -4147,7 +4046,7 @@ module RedBlackTree_Impl14_MoveRedLeft type k = k, type v = v, predicate InternalInvariant0.internal_invariant = InternalInvariant0.internal_invariant, - function Color0.color = Color1.color, + function Color0.color = Color0.color, predicate SameMappings0.same_mappings = SameMappings0.same_mappings, function Height0.height = Height0.height, function DeepModel0.deep_model = DeepModel0.deep_model, @@ -4158,7 +4057,7 @@ module RedBlackTree_Impl14_MoveRedLeft type k = k, type v = v, predicate InternalInvariant0.internal_invariant = InternalInvariant0.internal_invariant, - function Color0.color = Color1.color, + function Color0.color = Color0.color, predicate SameMappings0.same_mappings = SameMappings0.same_mappings, function Height0.height = Height0.height, function DeepModel0.deep_model = DeepModel0.deep_model, @@ -4168,7 +4067,7 @@ module RedBlackTree_Impl14_MoveRedLeft clone RedBlackTree_Impl13_IsRed_Interface as IsRed0 with type k = k, type v = v, - function Color0.color = Color1.color + function Color0.color = Color0.color clone CreusotContracts_Resolve_Impl1_Resolve as Resolve0 with type t = RedBlackTree_Node_Type.t_node k v clone Core_Option_Impl0_Unwrap_Interface as Unwrap0 with @@ -4179,7 +4078,7 @@ module RedBlackTree_Impl14_MoveRedLeft type k = k, type v = v, predicate InternalInvariant0.internal_invariant = InternalInvariant0.internal_invariant, - function Color0.color = Color1.color, + function Color0.color = Color0.color, function Height0.height = Height0.height, predicate SameMappings0.same_mappings = SameMappings0.same_mappings, function Height1.height = Height1.height @@ -4195,7 +4094,7 @@ module RedBlackTree_Impl14_MoveRedLeft ensures { [#"../red_black_tree.rs" 534 4 535 47] forall v : v . forall k : DeepModelTy0.deepModelTy . HasMapping0.has_mapping ( * self) k v /\ LeLog0.le_log k (DeepModel0.deep_model (RedBlackTree_Node_Type.node_key ( * self))) -> HasMapping0.has_mapping ( * result) k v } ensures { [#"../red_black_tree.rs" 536 4 537 108] forall v : v . forall k : DeepModelTy0.deepModelTy . HasMapping0.has_mapping ( ^ self) k v = (HasMapping0.has_mapping ( ^ result) k v \/ HasMapping0.has_mapping ( * self) k v /\ not HasMapping0.has_mapping ( * result) k v) } ensures { [#"../red_black_tree.rs" 538 14 539 61] MatchN0.match_n (Cpn0.cpn (RedBlackTree_Color_Type.C_Black) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Red)) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Black))) ( * result) \/ MatchN0.match_n (Cpn0.cpn (RedBlackTree_Color_Type.C_Black) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Red)) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Red))) ( * result) } - ensures { [#"../red_black_tree.rs" 540 4 541 45] ColorInvariant0.color_invariant ( ^ result) /\ (Color1.color (RedBlackTree_Node_Type.node_right ( * result)) = RedBlackTree_Color_Type.C_Black -> RedBlackTree_Node_Type.node_color ( ^ result) = RedBlackTree_Color_Type.C_Black) -> ColorInvariant0.color_invariant ( ^ self) } + ensures { [#"../red_black_tree.rs" 540 4 541 45] ColorInvariant0.color_invariant ( ^ result) /\ (Color0.color (RedBlackTree_Node_Type.node_right ( * result)) = RedBlackTree_Color_Type.C_Black -> RedBlackTree_Node_Type.node_color ( ^ result) = RedBlackTree_Color_Type.C_Black) -> ColorInvariant0.color_invariant ( ^ self) } = [@vc:do_not_keep_trace] [@vc:sp] var _0 : borrowed (RedBlackTree_Node_Type.t_node k v); @@ -4321,13 +4220,11 @@ module RedBlackTree_Impl14_MoveRedRight_Interface type k = k, type v = v, axiom . - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type use RedBlackTree_Color_Type as RedBlackTree_Color_Type - clone RedBlackTree_Impl7_Color_Stub as Color1 with + clone RedBlackTree_Impl7_Color_Stub as Color0 with type k = k, type v = v + use RedBlackTree_Node_Type as RedBlackTree_Node_Type clone RedBlackTree_Impl8_ColorInvariant_Stub as ColorInvariant0 with type k = k, type v = v @@ -4368,7 +4265,7 @@ module RedBlackTree_Impl14_MoveRedRight_Interface ensures { [#"../red_black_tree.rs" 563 4 564 47] forall v : v . forall k : DeepModelTy0.deepModelTy . HasMapping0.has_mapping ( * self) k v /\ LeLog0.le_log (DeepModel0.deep_model (RedBlackTree_Node_Type.node_key ( * self))) k -> HasMapping0.has_mapping ( * result) k v } ensures { [#"../red_black_tree.rs" 565 4 566 108] forall v : v . forall k : DeepModelTy0.deepModelTy . HasMapping0.has_mapping ( ^ self) k v = (HasMapping0.has_mapping ( ^ result) k v \/ HasMapping0.has_mapping ( * self) k v /\ not HasMapping0.has_mapping ( * result) k v) } ensures { [#"../red_black_tree.rs" 567 14 568 61] MatchN0.match_n (Cpn0.cpn (RedBlackTree_Color_Type.C_Black) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Black)) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Red))) ( * result) \/ MatchN0.match_n (Cpn0.cpn (RedBlackTree_Color_Type.C_Black) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Red)) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Red))) ( * result) } - ensures { [#"../red_black_tree.rs" 569 4 570 45] ColorInvariant0.color_invariant ( ^ result) /\ (Color1.color (RedBlackTree_Node_Type.node_left ( * result)) = RedBlackTree_Color_Type.C_Black -> RedBlackTree_Node_Type.node_color ( ^ result) = RedBlackTree_Color_Type.C_Black) -> ColorInvariant0.color_invariant ( ^ self) } + ensures { [#"../red_black_tree.rs" 569 4 570 45] ColorInvariant0.color_invariant ( ^ result) /\ (Color0.color (RedBlackTree_Node_Type.node_left ( * result)) = RedBlackTree_Color_Type.C_Black -> RedBlackTree_Node_Type.node_color ( ^ result) = RedBlackTree_Color_Type.C_Black) -> ColorInvariant0.color_invariant ( ^ self) } end module RedBlackTree_Impl14_MoveRedRight @@ -4384,11 +4281,9 @@ module RedBlackTree_Impl14_MoveRedRight use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with type self = DeepModelTy0.deepModelTy - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type use RedBlackTree_Color_Type as RedBlackTree_Color_Type + use RedBlackTree_Node_Type as RedBlackTree_Node_Type use Core_Option_Option_Type as Core_Option_Option_Type clone RedBlackTree_Impl9_Height as Height1 with type k = k, @@ -4423,13 +4318,13 @@ module RedBlackTree_Impl14_MoveRedRight type k = k, type v = v, predicate BstInvariantHere0.bst_invariant_here = BstInvariantHere0.bst_invariant_here - clone RedBlackTree_Impl7_Color as Color1 with + clone RedBlackTree_Impl7_Color as Color0 with type k = k, type v = v clone RedBlackTree_Impl8_ColorInvariantHere as ColorInvariantHere0 with type k = k, type v = v, - function Color0.color = Color1.color + function Color0.color = Color0.color clone RedBlackTree_Impl7_ColorInvariant as ColorInvariant1 with type k = k, type v = v, @@ -4480,7 +4375,7 @@ module RedBlackTree_Impl14_MoveRedRight clone RedBlackTree_Impl6_MatchT as MatchT0 with type k = k, type v = v, - function Color0.color = Color1.color, + function Color0.color = Color0.color, predicate ColorInvariant0.color_invariant = ColorInvariant1.color_invariant clone RedBlackTree_Impl10_HeightInvariant as HeightInvariant0 with type k = k, @@ -4532,7 +4427,7 @@ module RedBlackTree_Impl14_MoveRedRight type k = k, type v = v, predicate InternalInvariant0.internal_invariant = InternalInvariant0.internal_invariant, - function Color0.color = Color1.color, + function Color0.color = Color0.color, predicate SameMappings0.same_mappings = SameMappings0.same_mappings, function Height0.height = Height0.height, function DeepModel0.deep_model = DeepModel0.deep_model, @@ -4542,7 +4437,7 @@ module RedBlackTree_Impl14_MoveRedRight clone RedBlackTree_Impl13_IsRed_Interface as IsRed0 with type k = k, type v = v, - function Color0.color = Color1.color + function Color0.color = Color0.color clone CreusotContracts_Resolve_Impl1_Resolve as Resolve0 with type t = RedBlackTree_Node_Type.t_node k v clone Core_Option_Impl0_Unwrap_Interface as Unwrap0 with @@ -4553,7 +4448,7 @@ module RedBlackTree_Impl14_MoveRedRight type k = k, type v = v, predicate InternalInvariant0.internal_invariant = InternalInvariant0.internal_invariant, - function Color0.color = Color1.color, + function Color0.color = Color0.color, function Height0.height = Height0.height, predicate SameMappings0.same_mappings = SameMappings0.same_mappings, function Height1.height = Height1.height @@ -4569,7 +4464,7 @@ module RedBlackTree_Impl14_MoveRedRight ensures { [#"../red_black_tree.rs" 563 4 564 47] forall v : v . forall k : DeepModelTy0.deepModelTy . HasMapping0.has_mapping ( * self) k v /\ LeLog0.le_log (DeepModel0.deep_model (RedBlackTree_Node_Type.node_key ( * self))) k -> HasMapping0.has_mapping ( * result) k v } ensures { [#"../red_black_tree.rs" 565 4 566 108] forall v : v . forall k : DeepModelTy0.deepModelTy . HasMapping0.has_mapping ( ^ self) k v = (HasMapping0.has_mapping ( ^ result) k v \/ HasMapping0.has_mapping ( * self) k v /\ not HasMapping0.has_mapping ( * result) k v) } ensures { [#"../red_black_tree.rs" 567 14 568 61] MatchN0.match_n (Cpn0.cpn (RedBlackTree_Color_Type.C_Black) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Black)) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Red))) ( * result) \/ MatchN0.match_n (Cpn0.cpn (RedBlackTree_Color_Type.C_Black) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Red)) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Red))) ( * result) } - ensures { [#"../red_black_tree.rs" 569 4 570 45] ColorInvariant0.color_invariant ( ^ result) /\ (Color1.color (RedBlackTree_Node_Type.node_left ( * result)) = RedBlackTree_Color_Type.C_Black -> RedBlackTree_Node_Type.node_color ( ^ result) = RedBlackTree_Color_Type.C_Black) -> ColorInvariant0.color_invariant ( ^ self) } + ensures { [#"../red_black_tree.rs" 569 4 570 45] ColorInvariant0.color_invariant ( ^ result) /\ (Color0.color (RedBlackTree_Node_Type.node_left ( * result)) = RedBlackTree_Color_Type.C_Black -> RedBlackTree_Node_Type.node_color ( ^ result) = RedBlackTree_Color_Type.C_Black) -> ColorInvariant0.color_invariant ( ^ self) } = [@vc:do_not_keep_trace] [@vc:sp] var _0 : borrowed (RedBlackTree_Node_Type.t_node k v); @@ -4735,10 +4630,8 @@ module RedBlackTree_Impl15_New predicate LeLog0.le_log = LeLog0.le_log, function CmpLog0.cmp_log = CmpLog0.cmp_log, axiom . - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type use RedBlackTree_Color_Type as RedBlackTree_Color_Type + use RedBlackTree_Node_Type as RedBlackTree_Node_Type use Core_Option_Option_Type as Core_Option_Option_Type use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type clone RedBlackTree_Impl9_Height as Height0 with @@ -4852,7 +4745,7 @@ module RedBlackTree_Impl15_InsertRec_Interface type self = k, type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy use RedBlackTree_Color_Type as RedBlackTree_Color_Type - clone RedBlackTree_Impl7_Color_Stub as Color1 with + clone RedBlackTree_Impl7_Color_Stub as Color0 with type k = k, type v = v use RedBlackTree_Cp_Type as RedBlackTree_Cp_Type @@ -4875,7 +4768,7 @@ module RedBlackTree_Impl15_InsertRec_Interface requires {[#"../red_black_tree.rs" 593 15 593 40] ColorInvariant0.color_invariant ( * self)} ensures { [#"../red_black_tree.rs" 594 14 594 42] InternalInvariant0.internal_invariant ( ^ self) } ensures { [#"../red_black_tree.rs" 595 14 595 50] Height0.height ( * self) = Height0.height ( ^ self) } - ensures { [#"../red_black_tree.rs" 596 14 597 39] MatchT0.match_t (Cpn0.cpn (RedBlackTree_Color_Type.C_Red) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Red)) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Black))) ( ^ self) /\ Color1.color ( * self) = RedBlackTree_Color_Type.C_Red \/ ColorInvariant0.color_invariant ( ^ self) } + ensures { [#"../red_black_tree.rs" 596 14 597 39] MatchT0.match_t (Cpn0.cpn (RedBlackTree_Color_Type.C_Red) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Red)) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Black))) ( ^ self) /\ Color0.color ( * self) = RedBlackTree_Color_Type.C_Red \/ ColorInvariant0.color_invariant ( ^ self) } ensures { [#"../red_black_tree.rs" 598 14 598 56] HasMapping0.has_mapping ( ^ self) (DeepModel0.deep_model key) val' } ensures { [#"../red_black_tree.rs" 599 4 599 127] forall v : v . forall k : DeepModelTy0.deepModelTy . k = DeepModel0.deep_model key \/ HasMapping0.has_mapping ( * self) k v = HasMapping0.has_mapping ( ^ self) k v } @@ -4895,10 +4788,8 @@ module RedBlackTree_Impl15_InsertRec clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with type self = DeepModelTy0.deepModelTy use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type use RedBlackTree_Color_Type as RedBlackTree_Color_Type + use RedBlackTree_Node_Type as RedBlackTree_Node_Type use Core_Option_Option_Type as Core_Option_Option_Type clone RedBlackTree_Impl9_Height as Height0 with type k = k, @@ -4923,13 +4814,13 @@ module RedBlackTree_Impl15_InsertRec predicate HasMapping0.has_mapping = HasMapping0.has_mapping, function DeepModel0.deep_model = DeepModel0.deep_model, predicate LtLog0.lt_log = LtLog0.lt_log - clone RedBlackTree_Impl7_Color as Color1 with + clone RedBlackTree_Impl7_Color as Color0 with type k = k, type v = v clone RedBlackTree_Impl8_ColorInvariantHere as ColorInvariantHere0 with type k = k, type v = v, - function Color0.color = Color1.color + function Color0.color = Color0.color clone RedBlackTree_Impl7_ColorInvariant as ColorInvariant0 with type k = k, type v = v, @@ -5011,7 +4902,7 @@ module RedBlackTree_Impl15_InsertRec clone RedBlackTree_Impl6_MatchT as MatchT0 with type k = k, type v = v, - function Color0.color = Color1.color, + function Color0.color = Color0.color, predicate ColorInvariant0.color_invariant = ColorInvariant0.color_invariant clone RedBlackTree_Impl6_MatchN as MatchN0 with type k = k, @@ -5044,7 +4935,7 @@ module RedBlackTree_Impl15_InsertRec type k = k, type v = v, predicate InternalInvariant0.internal_invariant = InternalInvariant1.internal_invariant, - function Color1.color = Color1.color, + function Color0.color = Color0.color, predicate ColorInvariant0.color_invariant = ColorInvariant0.color_invariant, predicate SameMappings0.same_mappings = SameMappings0.same_mappings, function Height0.height = Height1.height, @@ -5075,7 +4966,7 @@ module RedBlackTree_Impl15_InsertRec requires {[#"../red_black_tree.rs" 593 15 593 40] ColorInvariant0.color_invariant ( * self)} ensures { [#"../red_black_tree.rs" 594 14 594 42] InternalInvariant0.internal_invariant ( ^ self) } ensures { [#"../red_black_tree.rs" 595 14 595 50] Height0.height ( * self) = Height0.height ( ^ self) } - ensures { [#"../red_black_tree.rs" 596 14 597 39] MatchT0.match_t (Cpn0.cpn (RedBlackTree_Color_Type.C_Red) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Red)) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Black))) ( ^ self) /\ Color1.color ( * self) = RedBlackTree_Color_Type.C_Red \/ ColorInvariant0.color_invariant ( ^ self) } + ensures { [#"../red_black_tree.rs" 596 14 597 39] MatchT0.match_t (Cpn0.cpn (RedBlackTree_Color_Type.C_Red) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Red)) (RedBlackTree_Cp_Type.C_CPL (RedBlackTree_Color_Type.C_Black))) ( ^ self) /\ Color0.color ( * self) = RedBlackTree_Color_Type.C_Red \/ ColorInvariant0.color_invariant ( ^ self) } ensures { [#"../red_black_tree.rs" 598 14 598 56] HasMapping0.has_mapping ( ^ self) (DeepModel0.deep_model key) val' } ensures { [#"../red_black_tree.rs" 599 4 599 127] forall v : v . forall k : DeepModelTy0.deepModelTy . k = DeepModel0.deep_model key \/ HasMapping0.has_mapping ( * self) k v = HasMapping0.has_mapping ( ^ self) k v } @@ -5313,9 +5204,9 @@ module RedBlackTree_Impl15_Insert_Interface type v use prelude.Borrow use map.Map + use Core_Option_Option_Type as Core_Option_Option_Type clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with type self = k - use Core_Option_Option_Type as Core_Option_Option_Type use map.Map use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with @@ -5397,10 +5288,8 @@ module RedBlackTree_Impl15_Insert function CmpLog0.cmp_log = CmpLog0.cmp_log, axiom . use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type use RedBlackTree_Color_Type as RedBlackTree_Color_Type + use RedBlackTree_Node_Type as RedBlackTree_Node_Type use Core_Option_Option_Type as Core_Option_Option_Type clone RedBlackTree_Impl9_Height as Height0 with type k = k, @@ -5425,13 +5314,13 @@ module RedBlackTree_Impl15_Insert predicate HasMapping0.has_mapping = HasMapping0.has_mapping, function DeepModel0.deep_model = DeepModel0.deep_model, predicate LtLog0.lt_log = LtLog0.lt_log - clone RedBlackTree_Impl7_Color as Color1 with + clone RedBlackTree_Impl7_Color as Color0 with type k = k, type v = v clone RedBlackTree_Impl8_ColorInvariantHere as ColorInvariantHere0 with type k = k, type v = v, - function Color0.color = Color1.color + function Color0.color = Color0.color clone RedBlackTree_Impl9_HeightInvariant as HeightInvariant0 with type k = k, type v = v, @@ -5473,7 +5362,7 @@ module RedBlackTree_Impl15_Insert clone RedBlackTree_Impl6_MatchT as MatchT0 with type k = k, type v = v, - function Color0.color = Color1.color, + function Color0.color = Color0.color, predicate ColorInvariant0.color_invariant = ColorInvariant0.color_invariant clone RedBlackTree_Cpn as Cpn0 clone RedBlackTree_Impl11_InternalInvariant as InternalInvariant0 with @@ -5495,7 +5384,7 @@ module RedBlackTree_Impl15_Insert type v = v, predicate InternalInvariant0.internal_invariant = InternalInvariant0.internal_invariant, predicate ColorInvariant0.color_invariant = ColorInvariant0.color_invariant, - function Color0.color = Color1.color + function Color0.color = Color0.color clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve2 with type self = Ghost.ghost_ty () clone RedBlackTree_Impl0_HasMappingModel as HasMappingModel0 with @@ -5525,7 +5414,7 @@ module RedBlackTree_Impl15_Insert function Height0.height = Height0.height, function Cpn0.cpn = Cpn0.cpn, predicate MatchT0.match_t = MatchT0.match_t, - function Color1.color = Color1.color, + function Color0.color = Color0.color, function DeepModel0.deep_model = DeepModel0.deep_model, predicate HasMapping0.has_mapping = HasMapping0.has_mapping, type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy @@ -5597,6 +5486,11 @@ module Alloc_Boxed_Impl57_AsMut_Interface ensures { [#"../../../../creusot-contracts/src/std/boxed.rs" 33 26 33 43] * self = * result } ensures { [#"../../../../creusot-contracts/src/std/boxed.rs" 34 26 34 43] ^ self = ^ result } +end +module Alloc_Alloc_Global_Type + type t_global = + | C_Global + end module RedBlackTree_Impl15_DeleteMaxRec_Interface type k @@ -5604,7 +5498,7 @@ module RedBlackTree_Impl15_DeleteMaxRec_Interface use prelude.Borrow use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type use RedBlackTree_Color_Type as RedBlackTree_Color_Type - clone RedBlackTree_Impl7_Color_Stub as Color1 with + clone RedBlackTree_Impl7_Color_Stub as Color0 with type k = k, type v = v clone RedBlackTree_Impl7_ColorInvariant_Stub as ColorInvariant0 with @@ -5642,7 +5536,7 @@ module RedBlackTree_Impl15_DeleteMaxRec_Interface ensures { [#"../red_black_tree.rs" 638 4 638 104] forall v : v . forall k : DeepModelTy0.deepModelTy . HasMapping0.has_mapping ( * self) k v -> LeLog0.le_log k (DeepModel0.deep_model (let (a, _) = result in a)) } ensures { [#"../red_black_tree.rs" 639 4 640 73] forall v : v . forall k : DeepModelTy0.deepModelTy . HasMapping0.has_mapping ( ^ self) k v = (DeepModel0.deep_model (let (a, _) = result in a) <> k /\ HasMapping0.has_mapping ( * self) k v) } ensures { [#"../red_black_tree.rs" 641 14 641 39] ColorInvariant0.color_invariant ( ^ self) } - ensures { [#"../red_black_tree.rs" 642 4 642 69] Color1.color ( * self) = RedBlackTree_Color_Type.C_Black -> Color1.color ( ^ self) = RedBlackTree_Color_Type.C_Black } + ensures { [#"../red_black_tree.rs" 642 4 642 69] Color0.color ( * self) = RedBlackTree_Color_Type.C_Black -> Color0.color ( ^ self) = RedBlackTree_Color_Type.C_Black } end module RedBlackTree_Impl15_DeleteMaxRec @@ -5659,10 +5553,8 @@ module RedBlackTree_Impl15_DeleteMaxRec clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with type self = DeepModelTy0.deepModelTy use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type use RedBlackTree_Color_Type as RedBlackTree_Color_Type + use RedBlackTree_Node_Type as RedBlackTree_Node_Type use Core_Option_Option_Type as Core_Option_Option_Type clone RedBlackTree_Impl9_Height as Height0 with type k = k, @@ -5707,13 +5599,13 @@ module RedBlackTree_Impl15_DeleteMaxRec type v = v, predicate BstInvariantHere0.bst_invariant_here = BstInvariantHere0.bst_invariant_here, predicate BstInvariant0.bst_invariant = BstInvariant0.bst_invariant - clone RedBlackTree_Impl7_Color as Color1 with + clone RedBlackTree_Impl7_Color as Color0 with type k = k, type v = v clone RedBlackTree_Impl8_ColorInvariantHere as ColorInvariantHere0 with type k = k, type v = v, - function Color0.color = Color1.color + function Color0.color = Color0.color clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with type self = DeepModelTy0.deepModelTy, function CmpLog0.cmp_log = CmpLog0.cmp_log, @@ -5778,7 +5670,7 @@ module RedBlackTree_Impl15_DeleteMaxRec clone RedBlackTree_Impl6_MatchT as MatchT0 with type k = k, type v = v, - function Color0.color = Color1.color, + function Color0.color = Color0.color, predicate ColorInvariant0.color_invariant = ColorInvariant0.color_invariant clone RedBlackTree_Impl6_MatchN as MatchN0 with type k = k, @@ -5801,6 +5693,7 @@ module RedBlackTree_Impl15_DeleteMaxRec type v = v, predicate BstInvariant0.bst_invariant = BstInvariant1.bst_invariant, predicate HeightInvariant0.height_invariant = HeightInvariant1.height_invariant + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type clone RedBlackTree_Cpn as Cpn0 clone RedBlackTree_Impl11_InternalInvariant as InternalInvariant0 with type k = k, @@ -5822,7 +5715,7 @@ module RedBlackTree_Impl15_DeleteMaxRec type k = k, type v = v, predicate InternalInvariant0.internal_invariant = InternalInvariant1.internal_invariant, - function Color1.color = Color1.color, + function Color0.color = Color0.color, predicate ColorInvariant0.color_invariant = ColorInvariant0.color_invariant, predicate SameMappings0.same_mappings = SameMappings0.same_mappings, function Height0.height = Height1.height, @@ -5843,7 +5736,7 @@ module RedBlackTree_Impl15_DeleteMaxRec function DeepModel0.deep_model = DeepModel0.deep_model, predicate LeLog0.le_log = LeLog0.le_log, predicate ColorInvariant0.color_invariant = ColorInvariant1.color_invariant, - function Color1.color = Color1.color, + function Color0.color = Color0.color, function Height1.height = Height0.height, predicate HasMapping1.has_mapping = HasMapping0.has_mapping clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve1 with @@ -5856,7 +5749,7 @@ module RedBlackTree_Impl15_DeleteMaxRec type k = k, type v = v, predicate InternalInvariant0.internal_invariant = InternalInvariant1.internal_invariant, - function Color0.color = Color1.color, + function Color0.color = Color0.color, predicate SameMappings0.same_mappings = SameMappings0.same_mappings, function Height0.height = Height1.height, function DeepModel0.deep_model = DeepModel0.deep_model, @@ -5866,7 +5759,7 @@ module RedBlackTree_Impl15_DeleteMaxRec clone RedBlackTree_Impl13_IsRed_Interface as IsRed0 with type k = k, type v = v, - function Color0.color = Color1.color + function Color0.color = Color0.color clone CreusotContracts_Resolve_Impl1_Resolve as Resolve0 with type t = RedBlackTree_Node_Type.t_node k v clone Alloc_Boxed_Impl57_AsMut_Interface as AsMut1 with @@ -5885,7 +5778,7 @@ module RedBlackTree_Impl15_DeleteMaxRec ensures { [#"../red_black_tree.rs" 638 4 638 104] forall v : v . forall k : DeepModelTy0.deepModelTy . HasMapping0.has_mapping ( * self) k v -> LeLog0.le_log k (DeepModel0.deep_model (let (a, _) = result in a)) } ensures { [#"../red_black_tree.rs" 639 4 640 73] forall v : v . forall k : DeepModelTy0.deepModelTy . HasMapping0.has_mapping ( ^ self) k v = (DeepModel0.deep_model (let (a, _) = result in a) <> k /\ HasMapping0.has_mapping ( * self) k v) } ensures { [#"../red_black_tree.rs" 641 14 641 39] ColorInvariant0.color_invariant ( ^ self) } - ensures { [#"../red_black_tree.rs" 642 4 642 69] Color1.color ( * self) = RedBlackTree_Color_Type.C_Black -> Color1.color ( ^ self) = RedBlackTree_Color_Type.C_Black } + ensures { [#"../red_black_tree.rs" 642 4 642 69] Color0.color ( * self) = RedBlackTree_Color_Type.C_Black -> Color0.color ( ^ self) = RedBlackTree_Color_Type.C_Black } = [@vc:do_not_keep_trace] [@vc:sp] var _0 : (k, v); @@ -6083,9 +5976,9 @@ module RedBlackTree_Impl15_DeleteMax_Interface use prelude.Borrow use map.Map use map.Const + use Core_Option_Option_Type as Core_Option_Option_Type clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with type self = k - use Core_Option_Option_Type as Core_Option_Option_Type use map.Map use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type clone RedBlackTree_Impl3_ShallowModel_Stub as ShallowModel1 with @@ -6120,10 +6013,8 @@ module RedBlackTree_Impl15_DeleteMax use map.Map use map.Const use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type use RedBlackTree_Color_Type as RedBlackTree_Color_Type + use RedBlackTree_Node_Type as RedBlackTree_Node_Type use Core_Option_Option_Type as Core_Option_Option_Type clone RedBlackTree_Impl9_Height as Height0 with type k = k, @@ -6159,13 +6050,13 @@ module RedBlackTree_Impl15_DeleteMax predicate HasMapping0.has_mapping = HasMapping0.has_mapping, function DeepModel0.deep_model = DeepModel0.deep_model, predicate LtLog0.lt_log = LtLog0.lt_log - clone RedBlackTree_Impl7_Color as Color1 with + clone RedBlackTree_Impl7_Color as Color0 with type k = k, type v = v clone RedBlackTree_Impl8_ColorInvariantHere as ColorInvariantHere0 with type k = k, type v = v, - function Color0.color = Color1.color + function Color0.color = Color0.color clone RedBlackTree_Impl9_HeightInvariant as HeightInvariant0 with type k = k, type v = v, @@ -6250,7 +6141,7 @@ module RedBlackTree_Impl15_DeleteMax clone RedBlackTree_Impl6_MatchT as MatchT0 with type k = k, type v = v, - function Color0.color = Color1.color, + function Color0.color = Color0.color, predicate ColorInvariant0.color_invariant = ColorInvariant0.color_invariant clone RedBlackTree_Impl11_InternalInvariant as InternalInvariant0 with type k = k, @@ -6271,7 +6162,7 @@ module RedBlackTree_Impl15_DeleteMax type v = v, predicate InternalInvariant0.internal_invariant = InternalInvariant0.internal_invariant, predicate ColorInvariant0.color_invariant = ColorInvariant0.color_invariant, - function Color0.color = Color1.color + function Color0.color = Color0.color clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve4 with type self = Ghost.ghost_ty () clone RedBlackTree_Impl0_HasMappingModel as HasMappingModel0 with @@ -6301,7 +6192,7 @@ module RedBlackTree_Impl15_DeleteMax type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, predicate LeLog0.le_log = LeLog0.le_log, predicate ColorInvariant0.color_invariant = ColorInvariant0.color_invariant, - function Color1.color = Color1.color + function Color0.color = Color0.color clone RedBlackTree_Impl0_SameMappings as SameMappings0 with type k = k, type v = v, @@ -6312,7 +6203,7 @@ module RedBlackTree_Impl15_DeleteMax clone RedBlackTree_Impl13_IsRed_Interface as IsRed0 with type k = k, type v = v, - function Color0.color = Color1.color + function Color0.color = Color0.color clone CreusotContracts_Resolve_Impl1_Resolve as Resolve2 with type t = RedBlackTree_Tree_Type.t_tree k v clone CreusotContracts_Resolve_Impl1_Resolve as Resolve1 with @@ -6455,7 +6346,7 @@ module RedBlackTree_Impl15_DeleteMinRec_Interface use prelude.Borrow use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type use RedBlackTree_Color_Type as RedBlackTree_Color_Type - clone RedBlackTree_Impl7_Color_Stub as Color1 with + clone RedBlackTree_Impl7_Color_Stub as Color0 with type k = k, type v = v clone RedBlackTree_Impl7_ColorInvariant_Stub as ColorInvariant0 with @@ -6493,7 +6384,7 @@ module RedBlackTree_Impl15_DeleteMinRec_Interface ensures { [#"../red_black_tree.rs" 691 4 691 104] forall v : v . forall k : DeepModelTy0.deepModelTy . HasMapping0.has_mapping ( * self) k v -> LeLog0.le_log (DeepModel0.deep_model (let (a, _) = result in a)) k } ensures { [#"../red_black_tree.rs" 692 4 693 73] forall v : v . forall k : DeepModelTy0.deepModelTy . HasMapping0.has_mapping ( ^ self) k v = (DeepModel0.deep_model (let (a, _) = result in a) <> k /\ HasMapping0.has_mapping ( * self) k v) } ensures { [#"../red_black_tree.rs" 694 14 694 39] ColorInvariant0.color_invariant ( ^ self) } - ensures { [#"../red_black_tree.rs" 695 4 695 69] Color1.color ( * self) = RedBlackTree_Color_Type.C_Black -> Color1.color ( ^ self) = RedBlackTree_Color_Type.C_Black } + ensures { [#"../red_black_tree.rs" 695 4 695 69] Color0.color ( * self) = RedBlackTree_Color_Type.C_Black -> Color0.color ( ^ self) = RedBlackTree_Color_Type.C_Black } end module RedBlackTree_Impl15_DeleteMinRec @@ -6512,10 +6403,8 @@ module RedBlackTree_Impl15_DeleteMinRec clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with type self = DeepModelTy0.deepModelTy use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type use RedBlackTree_Color_Type as RedBlackTree_Color_Type + use RedBlackTree_Node_Type as RedBlackTree_Node_Type use Core_Option_Option_Type as Core_Option_Option_Type clone RedBlackTree_Impl9_Height as Height0 with type k = k, @@ -6558,13 +6447,13 @@ module RedBlackTree_Impl15_DeleteMinRec type v = v, predicate BstInvariantHere0.bst_invariant_here = BstInvariantHere0.bst_invariant_here, predicate BstInvariant0.bst_invariant = BstInvariant0.bst_invariant - clone RedBlackTree_Impl7_Color as Color1 with + clone RedBlackTree_Impl7_Color as Color0 with type k = k, type v = v clone RedBlackTree_Impl8_ColorInvariantHere as ColorInvariantHere0 with type k = k, type v = v, - function Color0.color = Color1.color + function Color0.color = Color0.color clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with type self = DeepModelTy0.deepModelTy, function CmpLog0.cmp_log = CmpLog0.cmp_log, @@ -6640,7 +6529,7 @@ module RedBlackTree_Impl15_DeleteMinRec clone RedBlackTree_Impl6_MatchT as MatchT0 with type k = k, type v = v, - function Color0.color = Color1.color, + function Color0.color = Color0.color, predicate ColorInvariant0.color_invariant = ColorInvariant0.color_invariant clone RedBlackTree_Impl6_MatchN as MatchN0 with type k = k, @@ -6652,6 +6541,7 @@ module RedBlackTree_Impl15_DeleteMinRec type v = v, predicate BstInvariant0.bst_invariant = BstInvariant1.bst_invariant, predicate HeightInvariant0.height_invariant = HeightInvariant1.height_invariant + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type clone RedBlackTree_Cpn as Cpn0 clone RedBlackTree_Impl11_InternalInvariant as InternalInvariant0 with type k = k, @@ -6673,7 +6563,7 @@ module RedBlackTree_Impl15_DeleteMinRec type k = k, type v = v, predicate InternalInvariant0.internal_invariant = InternalInvariant1.internal_invariant, - function Color1.color = Color1.color, + function Color0.color = Color0.color, predicate ColorInvariant0.color_invariant = ColorInvariant0.color_invariant, predicate SameMappings0.same_mappings = SameMappings0.same_mappings, function Height0.height = Height1.height, @@ -6694,7 +6584,7 @@ module RedBlackTree_Impl15_DeleteMinRec function DeepModel0.deep_model = DeepModel0.deep_model, predicate LeLog0.le_log = LeLog0.le_log, predicate ColorInvariant0.color_invariant = ColorInvariant1.color_invariant, - function Color1.color = Color1.color, + function Color0.color = Color0.color, function Height1.height = Height0.height, predicate HasMapping1.has_mapping = HasMapping0.has_mapping clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve1 with @@ -6706,7 +6596,7 @@ module RedBlackTree_Impl15_DeleteMinRec clone RedBlackTree_Impl13_IsRed_Interface as IsRed0 with type k = k, type v = v, - function Color0.color = Color1.color + function Color0.color = Color0.color clone CreusotContracts_Resolve_Impl1_Resolve as Resolve0 with type t = RedBlackTree_Node_Type.t_node k v clone Alloc_Boxed_Impl57_AsMut_Interface as AsMut1 with @@ -6725,7 +6615,7 @@ module RedBlackTree_Impl15_DeleteMinRec ensures { [#"../red_black_tree.rs" 691 4 691 104] forall v : v . forall k : DeepModelTy0.deepModelTy . HasMapping0.has_mapping ( * self) k v -> LeLog0.le_log (DeepModel0.deep_model (let (a, _) = result in a)) k } ensures { [#"../red_black_tree.rs" 692 4 693 73] forall v : v . forall k : DeepModelTy0.deepModelTy . HasMapping0.has_mapping ( ^ self) k v = (DeepModel0.deep_model (let (a, _) = result in a) <> k /\ HasMapping0.has_mapping ( * self) k v) } ensures { [#"../red_black_tree.rs" 694 14 694 39] ColorInvariant0.color_invariant ( ^ self) } - ensures { [#"../red_black_tree.rs" 695 4 695 69] Color1.color ( * self) = RedBlackTree_Color_Type.C_Black -> Color1.color ( ^ self) = RedBlackTree_Color_Type.C_Black } + ensures { [#"../red_black_tree.rs" 695 4 695 69] Color0.color ( * self) = RedBlackTree_Color_Type.C_Black -> Color0.color ( ^ self) = RedBlackTree_Color_Type.C_Black } = [@vc:do_not_keep_trace] [@vc:sp] var _0 : (k, v); @@ -6898,9 +6788,9 @@ module RedBlackTree_Impl15_DeleteMin_Interface use prelude.Borrow use map.Map use map.Const + use Core_Option_Option_Type as Core_Option_Option_Type clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with type self = k - use Core_Option_Option_Type as Core_Option_Option_Type use map.Map use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type clone RedBlackTree_Impl3_ShallowModel_Stub as ShallowModel1 with @@ -6935,10 +6825,8 @@ module RedBlackTree_Impl15_DeleteMin use map.Map use map.Const use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type use RedBlackTree_Color_Type as RedBlackTree_Color_Type + use RedBlackTree_Node_Type as RedBlackTree_Node_Type use Core_Option_Option_Type as Core_Option_Option_Type clone RedBlackTree_Impl9_Height as Height0 with type k = k, @@ -6959,13 +6847,13 @@ module RedBlackTree_Impl15_DeleteMin use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with type self = DeepModelTy0.deepModelTy - clone RedBlackTree_Impl7_Color as Color1 with + clone RedBlackTree_Impl7_Color as Color0 with type k = k, type v = v clone RedBlackTree_Impl8_ColorInvariantHere as ColorInvariantHere0 with type k = k, type v = v, - function Color0.color = Color1.color + function Color0.color = Color0.color clone RedBlackTree_Impl9_HeightInvariant as HeightInvariant0 with type k = k, type v = v, @@ -7037,7 +6925,7 @@ module RedBlackTree_Impl15_DeleteMin clone RedBlackTree_Impl6_MatchT as MatchT0 with type k = k, type v = v, - function Color0.color = Color1.color, + function Color0.color = Color0.color, predicate ColorInvariant0.color_invariant = ColorInvariant0.color_invariant clone RedBlackTree_Impl5_BstInvariant as BstInvariant0 with type k = k, @@ -7086,7 +6974,7 @@ module RedBlackTree_Impl15_DeleteMin type v = v, predicate InternalInvariant0.internal_invariant = InternalInvariant0.internal_invariant, predicate ColorInvariant0.color_invariant = ColorInvariant0.color_invariant, - function Color0.color = Color1.color + function Color0.color = Color0.color clone Core_Option_Impl0_Unwrap_Interface as Unwrap0 with type t = borrowed (RedBlackTree_Node_Type.t_node k v) clone Core_Option_Impl0_AsMut_Interface as AsMut0 with @@ -7103,13 +6991,13 @@ module RedBlackTree_Impl15_DeleteMin type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, predicate LeLog0.le_log = LeLog0.le_log, predicate ColorInvariant0.color_invariant = ColorInvariant0.color_invariant, - function Color1.color = Color1.color + function Color0.color = Color0.color clone CreusotContracts_Resolve_Impl1_Resolve as Resolve3 with type t = RedBlackTree_Node_Type.t_node k v clone RedBlackTree_Impl13_IsRed_Interface as IsRed0 with type k = k, type v = v, - function Color0.color = Color1.color + function Color0.color = Color0.color clone CreusotContracts_Resolve_Impl1_Resolve as Resolve2 with type t = RedBlackTree_Tree_Type.t_tree k v clone CreusotContracts_Resolve_Impl1_Resolve as Resolve1 with @@ -7295,7 +7183,7 @@ module RedBlackTree_Impl15_DeleteRec_Interface use prelude.Borrow use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type use RedBlackTree_Color_Type as RedBlackTree_Color_Type - clone RedBlackTree_Impl7_Color_Stub as Color1 with + clone RedBlackTree_Impl7_Color_Stub as Color0 with type k = k, type v = v clone RedBlackTree_Impl7_ColorInvariant_Stub as ColorInvariant0 with @@ -7337,7 +7225,7 @@ module RedBlackTree_Impl15_DeleteRec_Interface end } ensures { [#"../red_black_tree.rs" 745 4 745 129] forall v : v . forall k : DeepModelTy0.deepModelTy . HasMapping0.has_mapping ( ^ self) k v = (DeepModel0.deep_model key <> k /\ HasMapping0.has_mapping ( * self) k v) } ensures { [#"../red_black_tree.rs" 746 14 746 39] ColorInvariant0.color_invariant ( ^ self) } - ensures { [#"../red_black_tree.rs" 747 4 747 69] Color1.color ( * self) = RedBlackTree_Color_Type.C_Black -> Color1.color ( ^ self) = RedBlackTree_Color_Type.C_Black } + ensures { [#"../red_black_tree.rs" 747 4 747 69] Color0.color ( * self) = RedBlackTree_Color_Type.C_Black -> Color0.color ( ^ self) = RedBlackTree_Color_Type.C_Black } end module RedBlackTree_Impl15_DeleteRec @@ -7352,10 +7240,8 @@ module RedBlackTree_Impl15_DeleteRec clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with type self = DeepModelTy0.deepModelTy use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type use RedBlackTree_Color_Type as RedBlackTree_Color_Type + use RedBlackTree_Node_Type as RedBlackTree_Node_Type use Core_Option_Option_Type as Core_Option_Option_Type clone RedBlackTree_Impl9_Height as Height0 with type k = k, @@ -7468,13 +7354,13 @@ module RedBlackTree_Impl15_DeleteRec predicate LeLog0.le_log = LeLog0.le_log, function CmpLog0.cmp_log = CmpLog0.cmp_log, axiom . - clone RedBlackTree_Impl7_Color as Color1 with + clone RedBlackTree_Impl7_Color as Color0 with type k = k, type v = v clone RedBlackTree_Impl8_ColorInvariantHere as ColorInvariantHere0 with type k = k, type v = v, - function Color0.color = Color1.color + function Color0.color = Color0.color use prelude.Ghost clone RedBlackTree_Impl3_ShallowModel as ShallowModel0 with type k = k, @@ -7512,7 +7398,7 @@ module RedBlackTree_Impl15_DeleteRec clone RedBlackTree_Impl6_MatchT as MatchT0 with type k = k, type v = v, - function Color0.color = Color1.color, + function Color0.color = Color0.color, predicate ColorInvariant0.color_invariant = ColorInvariant0.color_invariant clone RedBlackTree_Impl6_MatchN as MatchN0 with type k = k, @@ -7537,6 +7423,7 @@ module RedBlackTree_Impl15_DeleteRec type v = v, predicate BstInvariant0.bst_invariant = BstInvariant1.bst_invariant, predicate HeightInvariant0.height_invariant = HeightInvariant1.height_invariant + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type clone CreusotContracts_Model_Impl0_DeepModel as DeepModel0 with type t = k, type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, @@ -7551,7 +7438,7 @@ module RedBlackTree_Impl15_DeleteRec type k = k, type v = v, predicate InternalInvariant0.internal_invariant = InternalInvariant1.internal_invariant, - function Color1.color = Color1.color, + function Color0.color = Color0.color, predicate ColorInvariant0.color_invariant = ColorInvariant0.color_invariant, predicate SameMappings0.same_mappings = SameMappings0.same_mappings, function Height0.height = Height1.height, @@ -7570,7 +7457,7 @@ module RedBlackTree_Impl15_DeleteRec function DeepModel0.deep_model = DeepModel1.deep_model, predicate LeLog0.le_log = LeLog0.le_log, predicate ColorInvariant0.color_invariant = ColorInvariant1.color_invariant, - function Color1.color = Color1.color, + function Color0.color = Color0.color, function Height1.height = Height0.height, predicate HasMapping1.has_mapping = HasMapping0.has_mapping clone CreusotContracts_Resolve_Impl1_Resolve as Resolve9 with @@ -7604,7 +7491,7 @@ module RedBlackTree_Impl15_DeleteRec type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, predicate LeLog0.le_log = LeLog0.le_log, predicate ColorInvariant0.color_invariant = ColorInvariant0.color_invariant, - function Color1.color = Color1.color + function Color0.color = Color0.color clone RedBlackTree_Impl14_MoveRedRight_Interface as MoveRedRight0 with type k = k, type v = v, @@ -7617,7 +7504,7 @@ module RedBlackTree_Impl15_DeleteRec function DeepModel0.deep_model = DeepModel1.deep_model, predicate LeLog0.le_log = LeLog0.le_log, predicate ColorInvariant0.color_invariant = ColorInvariant1.color_invariant, - function Color1.color = Color1.color, + function Color0.color = Color0.color, function Height1.height = Height0.height, predicate HasMapping1.has_mapping = HasMapping0.has_mapping clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve6 with @@ -7645,7 +7532,7 @@ module RedBlackTree_Impl15_DeleteRec type k = k, type v = v, predicate InternalInvariant0.internal_invariant = InternalInvariant1.internal_invariant, - function Color0.color = Color1.color, + function Color0.color = Color0.color, predicate SameMappings0.same_mappings = SameMappings0.same_mappings, function Height0.height = Height1.height, function DeepModel0.deep_model = DeepModel1.deep_model, @@ -7655,7 +7542,7 @@ module RedBlackTree_Impl15_DeleteRec clone RedBlackTree_Impl13_IsRed_Interface as IsRed0 with type k = k, type v = v, - function Color0.color = Color1.color + function Color0.color = Color0.color clone Core_Cmp_Ord_Cmp_Interface as Cmp0 with type self = k, function DeepModel0.deep_model = DeepModel1.deep_model, @@ -7683,7 +7570,7 @@ module RedBlackTree_Impl15_DeleteRec end } ensures { [#"../red_black_tree.rs" 745 4 745 129] forall v : v . forall k : DeepModelTy0.deepModelTy . HasMapping0.has_mapping ( ^ self) k v = (DeepModel0.deep_model key <> k /\ HasMapping0.has_mapping ( * self) k v) } ensures { [#"../red_black_tree.rs" 746 14 746 39] ColorInvariant0.color_invariant ( ^ self) } - ensures { [#"../red_black_tree.rs" 747 4 747 69] Color1.color ( * self) = RedBlackTree_Color_Type.C_Black -> Color1.color ( ^ self) = RedBlackTree_Color_Type.C_Black } + ensures { [#"../red_black_tree.rs" 747 4 747 69] Color0.color ( * self) = RedBlackTree_Color_Type.C_Black -> Color0.color ( ^ self) = RedBlackTree_Color_Type.C_Black } = [@vc:do_not_keep_trace] [@vc:sp] var _0 : Core_Option_Option_Type.t_option (k, v); @@ -8117,9 +8004,9 @@ module RedBlackTree_Impl15_Delete_Interface type v use prelude.Borrow use map.Map + use Core_Option_Option_Type as Core_Option_Option_Type clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with type self = k - use Core_Option_Option_Type as Core_Option_Option_Type use map.Map use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type clone RedBlackTree_Impl3_ShallowModel_Stub as ShallowModel1 with @@ -8208,10 +8095,8 @@ module RedBlackTree_Impl15_Delete function CmpLog0.cmp_log = CmpLog0.cmp_log, axiom . use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type use RedBlackTree_Color_Type as RedBlackTree_Color_Type + use RedBlackTree_Node_Type as RedBlackTree_Node_Type use Core_Option_Option_Type as Core_Option_Option_Type clone RedBlackTree_Impl9_Height as Height0 with type k = k, @@ -8221,13 +8106,13 @@ module RedBlackTree_Impl15_Delete type k = k, type v = v, function Height0.height = Height0.height - clone RedBlackTree_Impl7_Color as Color1 with + clone RedBlackTree_Impl7_Color as Color0 with type k = k, type v = v clone RedBlackTree_Impl8_ColorInvariantHere as ColorInvariantHere0 with type k = k, type v = v, - function Color0.color = Color1.color + function Color0.color = Color0.color clone RedBlackTree_Impl9_HeightInvariant as HeightInvariant0 with type k = k, type v = v, @@ -8257,7 +8142,7 @@ module RedBlackTree_Impl15_Delete clone RedBlackTree_Impl6_MatchT as MatchT0 with type k = k, type v = v, - function Color0.color = Color1.color, + function Color0.color = Color0.color, predicate ColorInvariant0.color_invariant = ColorInvariant0.color_invariant clone RedBlackTree_Impl5_BstInvariant as BstInvariant0 with type k = k, @@ -8310,7 +8195,7 @@ module RedBlackTree_Impl15_Delete type v = v, predicate InternalInvariant0.internal_invariant = InternalInvariant0.internal_invariant, predicate ColorInvariant0.color_invariant = ColorInvariant0.color_invariant, - function Color0.color = Color1.color + function Color0.color = Color0.color clone Core_Option_Impl0_Unwrap_Interface as Unwrap0 with type t = borrowed (RedBlackTree_Node_Type.t_node k v) clone Core_Option_Impl0_AsMut_Interface as AsMut0 with @@ -8327,13 +8212,13 @@ module RedBlackTree_Impl15_Delete function DeepModel1.deep_model = DeepModel0.deep_model, type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, predicate ColorInvariant0.color_invariant = ColorInvariant0.color_invariant, - function Color1.color = Color1.color + function Color0.color = Color0.color clone CreusotContracts_Resolve_Impl1_Resolve as Resolve4 with type t = RedBlackTree_Node_Type.t_node k v clone RedBlackTree_Impl13_IsRed_Interface as IsRed0 with type k = k, type v = v, - function Color0.color = Color1.color + function Color0.color = Color0.color clone CreusotContracts_Resolve_Impl1_Resolve as Resolve3 with type t = RedBlackTree_Tree_Type.t_tree k v clone CreusotContracts_Resolve_Impl1_Resolve as Resolve2 with @@ -8541,10 +8426,8 @@ module RedBlackTree_Impl15_Get use prelude.Ghost use prelude.Borrow use map.Map - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type use RedBlackTree_Color_Type as RedBlackTree_Color_Type + use RedBlackTree_Node_Type as RedBlackTree_Node_Type use Core_Option_Option_Type as Core_Option_Option_Type use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type clone RedBlackTree_Impl9_Height as Height0 with @@ -8924,11 +8807,9 @@ module RedBlackTree_Impl15_GetMut axiom . use Core_Option_Option_Type as Core_Option_Option_Type use map.Map - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use RedBlackTree_Node_Type as RedBlackTree_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type use RedBlackTree_Tree_Type as RedBlackTree_Tree_Type use RedBlackTree_Color_Type as RedBlackTree_Color_Type + use RedBlackTree_Node_Type as RedBlackTree_Node_Type clone RedBlackTree_Impl9_Height as Height0 with type k = k, type v = v, diff --git a/creusot/tests/should_succeed/red_black_tree/why3session.xml b/creusot/tests/should_succeed/red_black_tree/why3session.xml index 12baf36c0..f5c706869 100644 --- a/creusot/tests/should_succeed/red_black_tree/why3session.xml +++ b/creusot/tests/should_succeed/red_black_tree/why3session.xml @@ -2,9 +2,10 @@ - + + @@ -14,12 +15,12 @@ - + - + @@ -46,10 +47,10 @@ - + - + @@ -63,19 +64,19 @@ - + - + - + - + @@ -87,7 +88,7 @@ - + @@ -99,35 +100,35 @@ - + - + - + - + - + - + - + - + @@ -140,42 +141,42 @@ - + - + - + - + - + - + - + - + - + @@ -191,10 +192,10 @@ - + - + @@ -218,25 +219,305 @@ - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + @@ -263,25 +544,25 @@ - + - + - + - + - + - + @@ -296,12 +577,12 @@ - + - + @@ -313,7 +594,7 @@ - + @@ -323,22 +604,22 @@ - + - + - + - + @@ -347,12 +628,12 @@ - + - + @@ -365,7 +646,7 @@ - + @@ -381,12 +662,12 @@ - + - + @@ -397,12 +678,12 @@ - + - + @@ -411,7 +692,7 @@ - + @@ -442,16 +723,16 @@ - + - + - + @@ -460,10 +741,10 @@ - + - + @@ -472,7 +753,43 @@ - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -484,21 +801,21 @@ - + - + - + - + - + @@ -509,19 +826,58 @@ - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + - + @@ -531,12 +887,107 @@ - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + @@ -561,45 +1012,52 @@ - + - + - + - + - + - + - + + + + + + + + - + - + - + - + - + @@ -608,17 +1066,32 @@ - + - + - + + + + + + + + + + + + + + + + @@ -630,10 +1103,10 @@ - + - + @@ -646,36 +1119,85 @@ - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + - + + + + + + + + + + + + + + + + + + + + + + - + - + - + - + @@ -685,10 +1207,10 @@ - + - + @@ -697,25 +1219,25 @@ - + - + - + - + - + @@ -724,17 +1246,35 @@ - + - + + + + + + + + + + + + - + + + + + + + + @@ -746,10 +1286,10 @@ - + - + @@ -764,20 +1304,52 @@ - + - + + + + + + + + + + + + + + + + + + + + + + - + - + + + + + + + + + + + + @@ -793,10 +1365,10 @@ - + - + @@ -805,15 +1377,15 @@ - + - + - + @@ -824,20 +1396,34 @@ - + - + + + + + + + + + + + + + + + - + - + @@ -851,27 +1437,27 @@ - + - + - + - + - + - + - + @@ -883,12 +1469,12 @@ - + - + @@ -909,62 +1495,118 @@ - + - + - + - + - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + - + - + - + - + - + + + + + + + + + + + + + + + + + + + + + + - + - + - + - + - + @@ -980,10 +1622,10 @@ - + - + @@ -997,10 +1639,10 @@ - + - + @@ -1009,15 +1651,15 @@ - + - + - + @@ -1026,10 +1668,10 @@ - + - + @@ -1038,27 +1680,27 @@ - + - + - + - + - + - + @@ -1070,12 +1712,12 @@ - + - + @@ -1096,59 +1738,83 @@ - + - + - + - + - + - + - + - + + + + + + + + + + + + + + + + + + + + + + + + + - + - + - + - + - + - + @@ -1158,22 +1824,46 @@ - + + + + + + + + + + + + + + + + + + + + + + + + + - + - + - + @@ -1182,12 +1872,52 @@ - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + @@ -1198,7 +1928,7 @@ - + @@ -1207,10 +1937,10 @@ - + - + @@ -1219,29 +1949,36 @@ - + - + - + - + - + - + - + + + + + + + + @@ -1251,25 +1988,81 @@ - + - + - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + + + + + + + + + + + + - + + + + + + + + + + + + @@ -1278,21 +2071,21 @@ - + - + - + - + - + @@ -1303,17 +2096,17 @@ - + - + - + @@ -1325,7 +2118,18 @@ - + + + + + + + + + + + + @@ -1334,12 +2138,19 @@ - + - + + + + + + + + @@ -1355,10 +2166,10 @@ - + - + @@ -1368,18 +2179,33 @@ - + - + - + + + + + + + + + + + + + + + + - + @@ -1392,15 +2218,15 @@ - + - + - + @@ -1409,12 +2235,24 @@ - + - + + + + + + + + + + + + + @@ -1427,10 +2265,10 @@ - + - + @@ -1441,10 +2279,10 @@ - + - + @@ -1458,34 +2296,34 @@ - + - + - + - + - + - + @@ -1496,29 +2334,29 @@ - + - + - + - + - + @@ -1527,12 +2365,12 @@ - + - + @@ -1547,28 +2385,57 @@ - + - + - + - + + + + + + + + + + + + - + + + + + + + + + + + + - + + + + + + + + @@ -1577,21 +2444,21 @@ - + - + - + - + - + @@ -1607,27 +2474,27 @@ - + - + - + - + - + - + - + @@ -1636,7 +2503,7 @@ - + @@ -1649,7 +2516,7 @@ - + @@ -1661,67 +2528,67 @@ - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + diff --git a/creusot/tests/should_succeed/red_black_tree/why3shapes.gz b/creusot/tests/should_succeed/red_black_tree/why3shapes.gz index 9dba101a380c7f47a4f0c31e08fd1a376e0ebd07..37c2554fdca62fe12dd68cf9a61f307e12ff2414 100644 GIT binary patch literal 47711 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 vPP{ohQ4oDT*4j@#Nht7wg00i|O6N`{lo`hJOto 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 E0Hu<8 - + diff --git a/creusot/tests/should_succeed/rusthorn/inc_some_2_list/why3shapes.gz b/creusot/tests/should_succeed/rusthorn/inc_some_2_list/why3shapes.gz index be78866448e673264db8baced592f601d8160292..2b07ebedc585bd8be67a8c20081b112688544ac7 100644 GIT binary patch literal 953 zcmV;q14jHGiwFP!00000|CLqSj@vd6efL-BE$tQoI75o0if#cxSi=U2J_US?KudIE zM3w@}j{EuLMbypfAl-+x=E5_>qnV>$UXuQc{$~2*ySenIuKhjX$;+=B{pYLhZ)Zg+ zvM-_m712dmbZviESNrt$sZk^^3jM06!ZCD=p~vLyMit4iyCjV{pLJT6e?+N*+4c<*3ArMZpVte@fs7ftnVa}(zVd&?&n=3%IFDXJ^mM+u5}6N5>t8C$%& zV*Yxe&%Ds5wmfvVw(ge|`P`8Esi5=)#WvS}1iC~8#Q)hOCB_!E&g5eY+p&d_rF}#o z5n<%bG4`(`YfYdc#iI|#H=sY=zBOjL-}r*Daz?19Uo5@hmxfz>(M{9c%X3$oCNLUe zull1mK3i%Br}ccaOa(G*fDH-h6O?qXFQ)IB??&;&=prq zA?8!l7@I(Nr)|VpbZQ)7bgx?VrNxr`_|SxUN9ZEhuG*Qn#wkL#OU2`u(N& zes`ED8fSoRSHSL|O+Y!|qMY^jpab3+_x`HCnzHZCrnJ*@-MC31{>}MjY*D8~(U&j6 zbG@S3!U~NH`ekE35U}OBr6f|ZkYo$+L_1fBYgn<&W^)6cqb~C%SwWoX3gw=u#k49K zCltkY-OTDkL)p*Xahd2A1;xA(KL(U88;KJQ_|OQh@Zl$ESta_7ofyHe>F6icf1xO` zQj(7&>c`yaOd6iJRg9=1ZZRhHWj|D3`oGne#vJw(i-n%>sr>Sg;Pf{xo7Z3GUo!yG z%AZSzOo3Nn=V5^X;8v)@lhrHmQD((yh}zTPgASmwL4D+$oox8!?{Fih*u)Hv&NVM` zNXV8bQ6Wxk6$Apy=42&e19ffcnu}U%Z7P%?FcSx+Ybh&ZFil`bHe4KzJOwE=vlCxS zW3~O58g0aZLnU=Wces%nX$qVlu&zXk8A%TU4Ch1~bVeyp#E$RM9otyV)&R7YRHiz^ bnpx8Mp<>*+(84C!PHz4K#rfeqa|!?eJI>|c literal 952 zcmV;p14sNHiwFP!00000|CLqAj@w2Mz3VG@b25PeR`tpt6M!H_kbod3qmL$=jxqQ*z%q975&X;4~{hsjT<=2h=^HpDNCzaOe zzK90YsV>T*?=E+BwNHN^Tb1TTpaV14?~HgcF_@_}V~clJ z%wI3`nHT!ll~sT1n#-~xpBr*N6_mc9*yj3=K$oZ?^?x==iLr&PGx^xUc5Go}X&({N zh%oZz82i_ewI)!d#iI|#H=sY=zO`n$-}r*Dc1EbDUo5@hmxNn<(QVt`%TwQ&HZU4u zull1mK3i%Br}ccaOa(G*fDQ@l2@2cmv$^!`ccb|D2uh64XxS|aKV3pW>RudE=!z?< z5c8>Nj7=cC(>CHPIyH_ky4S4_Cq8@NCs<*yq^|n&xxbs{!|7`PJsdmTDqw!lK%pNw zcOtd_fLUw2E2Mg>+lvV|6T{8eyTD=zEEMtx%pQ3hn4{^e`tev;=U!@Mcrwm6K%N%X73-5vBV5txG54A5aceAHjX z9(n|JsHp-RfXUkuIN+u#8(_0x%Uoz$^+BJU)9!guTvs6I7L-s$h+9?XAyan*{r(bs zzdOtni8Da9D`0ofCZHT}QO^2%&;jp^dwB z=Xyo5g%uhZ^vlM6AYjXLOGzYRA;}itiFU3M*RW!lP3HzYM_uMkvVu6%6~aAJi)mFP zPAH1)x|!97hR~nA<1*1L3W|9nehdg%HWDWq@Szc0;loeTvP$$DJ28S`)6q|?|3Z<} zN=ZJBs2_8uGb}uDs~Ay3++s}XOMj@oYHm|?Vzh(fW zl|PpbnF6oE&O-wOz^zb)C#zTBqtuGi5Vfbn2OU6VgZjuhJK6Bd-{D41v56TTooim? zkdQ4=qCy + @@ -18,7 +19,7 @@ - + diff --git a/creusot/tests/should_succeed/rusthorn/inc_some_2_tree/why3shapes.gz b/creusot/tests/should_succeed/rusthorn/inc_some_2_tree/why3shapes.gz index 347dc6cf5fc36a11e0666b1ab49e8ba8f59fcaca..6882206972f0cfefec14c721abb79ddcf08e235b 100644 GIT binary patch delta 1073 zcmV-11kU@t2)zg?ABzY8000000RNR%S+C+Y6n^Jd@HXwOMzW6`FIB08&_y6!bzVk( zoRKLUe}4IDzq`x)hdW>P?dkWqn7{lwvwtq^<#sfrCfijfKuwn2Gp&hTm4CH6XYS^T zk8jR4hAdYryD-A=Pxw<9KKL}f&$h#0i09pvVcuOD_Q?IwYt}Qfnm6rvesIU5EfK6d zwWpK&duA7QsxxF|Ki|F|9C>?hg9kb~yfPike_q@LU({Y$*lSzvPgf&@QfyZt5z3cn zx}kx=2XCg_{x*`?NTRP(e>U-lT++cky%|mZ)oP@pu}S20c||oo*b^pHf)U=$=qS=8 zswff^Q|kBo-6vA_nTs{HYJV!L_IBD`#=!v@g{rpWT+lquMUNyzeg-`C+-4c-m|=mZ zfB#4$S=5w-PwuCpO=fOqHSS62H}elof0)4u{<#^G|1$jo}geG&hFA4emJB1 zM~b7+3xIQyTVT5ipD-|ShW&1aUtCVMe;m?aynBELi7=K~hg2B!>S;3R#Fqg41dE4R z#c{9N^SQmd-G}41h}!H=_F$m!b_RyUb;2VQzo0;ANRr#NJzQKsN=Gn9m2#AMj$NLgS+g8PuYQ+f*D*G2*?^^9)4EP_6e-8p6ebKSx*QAqqCC$L3j6tdbB2*Yf9rc4 zGjF01bm9g*dRJmT5C$Z^7@<;edu}$Sx%;v*e;5h_JVgRLZBej>MDWxjaDvDbM@C*xf;1{i$Cj z&f?5)NHgOjMD3(yyi1N_7dke$f7)-ZytGGGBHDH4&ymm$&oWG7|F?r~IWp%=$VR-# z)H)+P7Kt(AJDJns=-ilXaSC(Reoo61$0@8Fd-D;8KSv$=4dexoaTF7wQX((5Ux75F zay<>En1s%MHpj8!o1bZ!2f{)iY#c~G(C{u0nBdc&EX%~v2SSI6K>UM(e@uqMLqbRd zmpAO5HlWtw{sM`M8lP~ldAGQ1y&c#NIz|WjfbD=~)`9JS_Ub9yLC5GYW%L1y$C##! zj$o;b@%ja%3K9zX;<@7`>ZcW;3P~c|)*6>T5(KXKI^F30uR^@bkyd&JNLD;e;uAGG zGO$s3b@YE++vOx9eJ6#n}TU%)>8<0EdoOP^# zW==O`)`$w4x~Z(9lyY5h&Z$yTDiAwX2{A7=e8V;{qok&_^V2v?1yRm~*BgAJ{#N>zNWH){4TONN98J`4Z=`>hC+ delta 1073 zcmV-11kU@t2)zg?ABzY8000000RNR%S+C+Y6n@XI;BDGljbtA?UaC?Fp^HGe>b#8n zIFTtFe|Gt5zq`xqhdW>P?dkWKn7#a3*gxm?ayuGQlg+XdpeBp%nbyQEw|})eXYS^T zk8jR4hAfs#J2%4cPxw&YJc-JGkS~ZV_yI zYELKkcVXvtsxxG1Ki|F|9C>?hg9kb~yfPike_q@LU)Elj+iSbspRPs*rPwS(B9t%C zbVCD!58h0<{cR+(kwjmo{%qn8xuk=8dNZ2*tJO$HW0T11;)-f~uqRAt3r2W1qoYWZ zsG>+vOsU`Rcb`bzXD(LQs{LtOwYSsmG7b*NC{(o>=Yr;OE_x&(@-yJ6=O)Wg#|%q6 zfBi=q$+D&-d~!b(Z8Gzdz29|l-T3mzzC5cSi@rWlF8czlh645Dh;b!o(INK(>c{Gz zBH8VWQR!F2aK75Zp}lX9hI;6s&S5K2kC%y#WCs;hp zDvo>Ap3m*w?LHj8Mbu`0vIhgDw=*y-t`i=i_yr|OLz3LC?BU`9QaXY;s+6P5bL@J> z9yN=}%$nsWdiA>;yNQDVL zaTaHWLz)>MA!;Wr<6UwbyU?-0f7O0-+e>?NTSU7S{u~MI@GQeL_J1?z79(@cglxo% zOsz7)W04p$zLPmEj?RtQ7N;<0?dP;Sah$@+u{R%a_;b{;-#}gf8AmY@Dkbt_`xQt- zDp%8B%1P+_XLB4ozWJG!c_1tV!p4F00}by2feAkS$+AoweIRtG2*f`qf5>DwJS2of zaCyV-X#;8%?k|wIsPPH+nsZY=aQp$D3Ij2fVsX**lCB&>;^EF#Tp@0hEs!B;wTiVplflziw6lmt0 rQ!}|1!I4{8mJYNA!c`+_RWr#PZyH+T>59+vS{45S8oeeSJ`4Z=(sva? diff --git a/creusot/tests/should_succeed/rusthorn/inc_some_list.mlcfg b/creusot/tests/should_succeed/rusthorn/inc_some_list.mlcfg index be7819cbf..40cb2bb4e 100644 --- a/creusot/tests/should_succeed/rusthorn/inc_some_list.mlcfg +++ b/creusot/tests/should_succeed/rusthorn/inc_some_list.mlcfg @@ -235,35 +235,6 @@ module CreusotContracts_Resolve_Impl1_Resolve val resolve (self : borrowed t) : bool ensures { result = resolve self } -end -module Core_Ptr_NonNull_NonNull_Type - use prelude.Opaque - type t_nonnull 't = - | C_NonNull opaque_ptr - -end -module Core_Marker_PhantomData_Type - type t_phantomdata 't = - | C_PhantomData - -end -module Core_Ptr_Unique_Unique_Type - use Core_Marker_PhantomData_Type as Core_Marker_PhantomData_Type - use Core_Ptr_NonNull_NonNull_Type as Core_Ptr_NonNull_NonNull_Type - type t_unique 't = - | C_Unique (Core_Ptr_NonNull_NonNull_Type.t_nonnull 't) (Core_Marker_PhantomData_Type.t_phantomdata 't) - -end -module Alloc_Boxed_Box_Type - use Core_Ptr_Unique_Unique_Type as Core_Ptr_Unique_Unique_Type - type t_box 't 'a = - | C_Box (Core_Ptr_Unique_Unique_Type.t_unique 't) 'a - -end -module Alloc_Alloc_Global_Type - type t_global = - | C_Global - end module CreusotContracts_Std1_Num_Impl6_ShallowModel_Stub use prelude.Int @@ -309,13 +280,11 @@ module IncSomeList_Impl0_TakeSome use prelude.UInt32 clone CreusotContracts_Std1_Num_Impl6_ShallowModel as ShallowModel1 use prelude.Int - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use IncSomeList_List_Type as IncSomeList_List_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type clone CreusotContracts_Model_Impl3_ShallowModel as ShallowModel0 with type t = uint32, type ShallowModelTy0.shallowModelTy = int, function ShallowModel0.shallow_model = ShallowModel1.shallow_model + use IncSomeList_List_Type as IncSomeList_List_Type clone IncSomeList_Impl0_Sum as Sum0 clone CreusotContracts_Resolve_Impl1_Resolve as Resolve2 with type t = uint32 diff --git a/creusot/tests/should_succeed/rusthorn/inc_some_list/why3session.xml b/creusot/tests/should_succeed/rusthorn/inc_some_list/why3session.xml index 8d5c9bad9..7c458282f 100644 --- a/creusot/tests/should_succeed/rusthorn/inc_some_list/why3session.xml +++ b/creusot/tests/should_succeed/rusthorn/inc_some_list/why3session.xml @@ -17,7 +17,7 @@ - + diff --git a/creusot/tests/should_succeed/rusthorn/inc_some_list/why3shapes.gz b/creusot/tests/should_succeed/rusthorn/inc_some_list/why3shapes.gz index 5b1bd60d70919246c049199b7a5318eb74635adc..10cd81380b64f7e49f765b9d56a6cbd41ae5e4db 100644 GIT binary patch literal 878 zcmV-!1Cjh6iwFP!00000|BY2!uhTFLe($g78*mU(?nw~`X{ye&Nr)$uN2;vNV4`c$ zx-ot}&aJnB#H3ZR6WgCZ$Ik1geE4pD+9CgCFT<(t-sd8JdXt%t&t|xtHLB6ROaiWv zDXX&YhP%GP>hr19Xj7KvSyN5Mtz+7HJiN_xnIHR0-rDooRN%Dg`mVFzGV^S%eRb-t z8i&Ap=N4CHZm3gfYHGkyVU4^3m#i`JKRBf22x03)F+$jm5Jr~v$pcCrM&2A_ zza3d?0yQchb$G0R`EvW&+9|)Wz@&D9i}&5MZGW%MePdgVeKzJvQ%C7LFMI_aqY^YB zYf!qQE8D%f*r9KKSWbLcOZ{%)IB=O4k@@zfb`!aYw|X)N6eqGIVj zQ7_hpJQA#)$6AH(x;O|+Q9qI1Dl4%2lg5PIXd&WdmKeciYudp&N8V!GVaS=YHGN~sDy3XR=Y{(O zEnj0w*U6Czn3Se6VRE;L;0Y4}80O36W;KN|adoF+(>(MQfzYXciW+_L*?H89_@VhU zk$?nzMhKcnz$IdGdNfR+IOUKk3!U2^0qBwNi<}~@@ zxK0!1YJS*i=+8EDmza4*LL0zM-%q;DVtYOmp<(8d@5gbt`>UtLG$qAsN-ph|b9dCqKqBK=Y7bNa^8h< zZ5f{tIPO&;L!*G E0Fs5f7ytkO literal 880 zcmV-$1CRV4iwFP!00000|BY2!tJ^pbe)q5NTf3($=xWJj&q6RKB(UsL(PNEb%iB=L zE^*TI=XZ4VB`s_qMl+hrr%yAZ_b>VMMSn9>{@q-s^EiCWi~Qw}O#l6=r~5^r1|6#? z;0EccuEt?{s2i;QJ@*Rjs!G2qsz}=E;?}eAK2ufRjn}+4my50;Xg!R>VE)VWtGLc zpz)^$r8V979`)5sWB=VKmX=uIaw!y+23+dXc)gAf)4scW^})LHpdko%JYlJ@uq()l zh5ZD5v32Cpk$3~HFpG}Neyl#F=V?t;v4lmJg1b3Px2Z@-Rr*XsVH`7I_yjfDxRt@n z9Y>W)1|JE3&{dUdB(4bF%@Ane>UVou5n@qS@=7S``UGx<+mF{$rl_s|r^}`39?9x< zNm4KG*IIAfUHB~~8fhUOGf@=31yq(6QoJn=MzG%Nelj+Y^GG`kS$DRjFCAINBbOm~ zX+K`ex0qr%SyBO$R8&Mvwwef@F%f{FKV9!eQ5X|9YZaR2sjmp6j{Q?M=pT1FhkBLY zH=iN`kU;E!ghjpT9@de$kpv|0fQ;}kE8MQ1SicHvqXLmM67#kWOr0Ybpcog0p<_4a z$rr|ToG>^2)zs5?F_|r5<{0s90F{26b-UH}awtN>EG5^EX}G)6Q^hp5h zIw<)6WtqIKBvf2LpC*~+kQgp#i9pE^;5j^oQd&j^^i6<2ZEvGByele}b}_!ng+9?isq=7ZOzdwP0#&O_tMqVCVrEz5A*nzk)O ztF<-_kywyYoS1HXj1#|M-Z;?xx!OQ{(QrdAr+ppF}D#HqlI)Hyv6h;)*z=@4oR zjK~t1f_AMWP#3goFllpfC=UFP?47hnf(OqOOU|P G2mk;{lewY* diff --git a/creusot/tests/should_succeed/rusthorn/inc_some_tree.mlcfg b/creusot/tests/should_succeed/rusthorn/inc_some_tree.mlcfg index 8d7316510..2fa7d509b 100644 --- a/creusot/tests/should_succeed/rusthorn/inc_some_tree.mlcfg +++ b/creusot/tests/should_succeed/rusthorn/inc_some_tree.mlcfg @@ -249,35 +249,6 @@ module CreusotContracts_Resolve_Impl1_Resolve val resolve (self : borrowed t) : bool ensures { result = resolve self } -end -module Core_Ptr_NonNull_NonNull_Type - use prelude.Opaque - type t_nonnull 't = - | C_NonNull opaque_ptr - -end -module Core_Marker_PhantomData_Type - type t_phantomdata 't = - | C_PhantomData - -end -module Core_Ptr_Unique_Unique_Type - use Core_Marker_PhantomData_Type as Core_Marker_PhantomData_Type - use Core_Ptr_NonNull_NonNull_Type as Core_Ptr_NonNull_NonNull_Type - type t_unique 't = - | C_Unique (Core_Ptr_NonNull_NonNull_Type.t_nonnull 't) (Core_Marker_PhantomData_Type.t_phantomdata 't) - -end -module Alloc_Boxed_Box_Type - use Core_Ptr_Unique_Unique_Type as Core_Ptr_Unique_Unique_Type - type t_box 't 'a = - | C_Box (Core_Ptr_Unique_Unique_Type.t_unique 't) 'a - -end -module Alloc_Alloc_Global_Type - type t_global = - | C_Global - end module CreusotContracts_Std1_Num_Impl6_ShallowModel_Stub use prelude.Int @@ -322,13 +293,11 @@ module IncSomeTree_Impl0_TakeSome use prelude.UInt32 clone CreusotContracts_Std1_Num_Impl6_ShallowModel as ShallowModel1 use prelude.Int - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use IncSomeTree_Tree_Type as IncSomeTree_Tree_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type clone CreusotContracts_Model_Impl3_ShallowModel as ShallowModel0 with type t = uint32, type ShallowModelTy0.shallowModelTy = int, function ShallowModel0.shallow_model = ShallowModel1.shallow_model + use IncSomeTree_Tree_Type as IncSomeTree_Tree_Type clone IncSomeTree_Impl0_Sum as Sum0 clone CreusotContracts_Resolve_Impl1_Resolve as Resolve2 with type t = uint32 diff --git a/creusot/tests/should_succeed/rusthorn/inc_some_tree/why3session.xml b/creusot/tests/should_succeed/rusthorn/inc_some_tree/why3session.xml index 81bc99c1f..8088825c4 100644 --- a/creusot/tests/should_succeed/rusthorn/inc_some_tree/why3session.xml +++ b/creusot/tests/should_succeed/rusthorn/inc_some_tree/why3session.xml @@ -17,7 +17,7 @@ - + diff --git a/creusot/tests/should_succeed/rusthorn/inc_some_tree/why3shapes.gz b/creusot/tests/should_succeed/rusthorn/inc_some_tree/why3shapes.gz index 8aab1148158ffc80a9bb3e8c4f69cdce00f146b0..6c87191b960b0224519853dc9968890c664c4fc0 100644 GIT binary patch delta 832 zcmV-G1Hb&Y2e${1DSuOq5nBrUi2L(9d`YCdThs?F=i>}#=9}Sge_NE-@A{{?mcPv9 zdK~&cN>MI87W(sxzTVFYwP?4B0%_4Qu5pX>YX4<881+y$SiTzFDYRUz^otUTeT6?< zu}P;Jb$0O#3g=n%N>QsW6@5$nEjOD&t;%k=lqYjO>pdK{?|+BBH-8uUMb9yXR{Goh z=gFYg=RNWUh9{T7FmW7%=dBf9^ljK5`!@i-gw88^Ey8JtVXzN?0{jdl3h*@*)B;r2cq3Y$ENLx!6Fd zj{UwF?)~AK2a_iODu3$TmbaayM~?JtoGeCuyv#>}HWNW(J3?IHXc12y8`QSdKZV=> zu1}}ou|I?LNfB2yy->oI?RO{qr9=b)@d*HERcE$4eKFVJ^vftYF0mps6)Xz?>1McG zhKD(PIREg6b;n+xfIycTA&OwT0?s%= z&SczO91NPSfD8C*KOSZ<`Ph2-Ty@4mff-H9&gclIg}2%>^L4n*c~~r_N`-Sz6(j2q zmd%vfYd)5MaJ|u|t8phelQC_c33iA9^d1MCMh-al&bX~dfcd;0JO;_JSD=c=D7lR? z;&2{%i#(1ZOLazGJ%7R}c~*O79%kK)yV%#Z{=i+WSQWXmZB2N}9Toc9x8M= z6WWEnICZn`i38!Lf0+GsIGe&Ztu-0jb2nkjZ2Ldn4&T#p+)+P=rfDbAp_soY*{sbE zeSaqBdeb1n*aeT%oNcFia{Z)8EoYBH{XgC3daqC*``p0wm4BPvbIZuk8a!KI- z zsT)pOt(#iQj>rQxMjOgWSK=)yI?<4>?HXNSj9J|<#&A_hSrKudjSwZ@vMt?`q9!fq z>8|C7bqCRP-7$ewLc);8Oo~>Qax0u-$C~QEG2^7+nhVx&(-Bb}2t$%IvMcLtRs0JM K8NVPk3IG7XT$?fg delta 832 zcmV-G1Hb&Y2e${1DSuIo5nBrUi2L(9e95G|Ths?F=i>}#=9}Sge_NE7@A{{?l)udR zau|m{N>MI87W(sxzT8dYX4>IjJm5UEMJZ86QsW6@5$nEjOD&t;&8pmq&9t={+2_AAiPSFn<^NMb9yXR{GoR z=h2|o=RNWUh9542Vd6Lj&s!_J=ux$2CC0yCPHozV$S3vab&=Id~q^RQS+mg69>Xo|1kT@crt}=T5B@3=k9?mv+e(QJA6;aaYy|edQ3Z!4#oUM$!2YS z==(D{*Lw^ij9u_J&DnOUC)ZDk)N=MH)c@0cuJ;NBvd;}%Uw^sTJ-3Vut-;fV;So&R zMb0hV%n(-Ht>8w7*}>qy0E a end end -module Core_Ptr_NonNull_NonNull_Type - use prelude.Opaque - type t_nonnull 't = - | C_NonNull opaque_ptr - -end -module Core_Marker_PhantomData_Type - type t_phantomdata 't = - | C_PhantomData - -end -module Core_Ptr_Unique_Unique_Type - use Core_Marker_PhantomData_Type as Core_Marker_PhantomData_Type - use Core_Ptr_NonNull_NonNull_Type as Core_Ptr_NonNull_NonNull_Type - type t_unique 't = - | C_Unique (Core_Ptr_NonNull_NonNull_Type.t_nonnull 't) (Core_Marker_PhantomData_Type.t_phantomdata 't) - -end -module Alloc_Boxed_Box_Type - use Core_Ptr_Unique_Unique_Type as Core_Ptr_Unique_Unique_Type - type t_box 't 'a = - | C_Box (Core_Ptr_Unique_Unique_Type.t_unique 't) 'a - -end -module Alloc_Alloc_Global_Type - type t_global = - | C_Global - -end module C10MutualRecTypes_Node_Type use prelude.Int use prelude.UInt32 - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type use Core_Option_Option_Type as Core_Option_Option_Type type t_node = | C_Node (t_tree) uint32 (t_tree) @@ -328,9 +297,6 @@ module C10MutualRecTypes_Impl0_Height clone CreusotContracts_Logic_Ord_Impl2_LeLog as LeLog0 clone CreusotContracts_Logic_Ord_Impl2_GeLog as GeLog0 clone CreusotContracts_Std1_Num_Impl10_DeepModel as DeepModel0 - use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type - use C10MutualRecTypes_Node_Type as C10MutualRecTypes_Node_Type - use Alloc_Boxed_Box_Type as Alloc_Boxed_Box_Type clone Core_Cmp_Ord_Max_Interface as Max0 with type self = uint64, function DeepModel0.deep_model = DeepModel0.deep_model, @@ -338,6 +304,7 @@ module C10MutualRecTypes_Impl0_Height predicate LeLog0.le_log = LeLog0.le_log, predicate LtLog0.lt_log = LtLog0.lt_log, type DeepModelTy0.deepModelTy = int + use C10MutualRecTypes_Node_Type as C10MutualRecTypes_Node_Type use Core_Option_Option_Type as Core_Option_Option_Type use C10MutualRecTypes_Tree_Type as C10MutualRecTypes_Tree_Type let rec cfg height [#"../10_mutual_rec_types.rs" 16 4 16 31] [@cfg:stackify] [@cfg:subregion_analysis] (self : C10MutualRecTypes_Tree_Type.t_tree) : uint64 diff --git a/creusot/tests/should_succeed/type_invariants/borrows.mlcfg b/creusot/tests/should_succeed/type_invariants/borrows.mlcfg index 7d7234914..d6c07a134 100644 --- a/creusot/tests/should_succeed/type_invariants/borrows.mlcfg +++ b/creusot/tests/should_succeed/type_invariants/borrows.mlcfg @@ -83,12 +83,12 @@ module CreusotContracts_Invariant_Invariant_Invariant ensures { result = invariant' self } end -module CreusotContracts_Invariant_Impl1_Invariant_Stub +module CreusotContracts_Invariant_Impl2_Invariant_Stub type t use prelude.Borrow predicate invariant' (self : borrowed t) end -module CreusotContracts_Invariant_Impl1_Invariant_Interface +module CreusotContracts_Invariant_Impl2_Invariant_Interface type t use prelude.Borrow predicate invariant' (self : borrowed t) @@ -96,13 +96,13 @@ module CreusotContracts_Invariant_Impl1_Invariant_Interface ensures { result = invariant' self } end -module CreusotContracts_Invariant_Impl1_Invariant +module CreusotContracts_Invariant_Impl2_Invariant type t use prelude.Borrow clone CreusotContracts_Invariant_Invariant_Invariant_Stub as Invariant0 with type self = t predicate invariant' (self : borrowed t) = - [#"../../../../../creusot-contracts/src/invariant.rs" 36 20 36 39] Invariant0.invariant' ( * self) + [#"../../../../../creusot-contracts/src/invariant.rs" 59 20 59 39] Invariant0.invariant' ( * self) val invariant' (self : borrowed t) : bool ensures { result = invariant' self } @@ -135,7 +135,7 @@ module Borrows_Impl1_SubMut_Interface use prelude.Int use Borrows_NonZeroU32_Type as Borrows_NonZeroU32_Type clone Borrows_Impl0_Invariant_Stub as Invariant1 - clone CreusotContracts_Invariant_Impl1_Invariant_Stub as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant_Stub as Invariant0 with type t = Borrows_NonZeroU32_Type.t_nonzerou32 val sub_mut [#"../borrows.rs" 23 4 23 40] (self : borrowed (Borrows_NonZeroU32_Type.t_nonzerou32)) (rhs : Borrows_NonZeroU32_Type.t_nonzerou32) : () requires {[#"../borrows.rs" 21 15 21 31] UInt32.to_int (Borrows_NonZeroU32_Type.nonzerou32_0 ( * self)) > UInt32.to_int (Borrows_NonZeroU32_Type.nonzerou32_0 rhs)} @@ -151,7 +151,7 @@ module Borrows_Impl1_SubMut use prelude.Borrow use Borrows_NonZeroU32_Type as Borrows_NonZeroU32_Type clone Borrows_Impl0_Invariant as Invariant1 - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant0 with type t = Borrows_NonZeroU32_Type.t_nonzerou32, predicate Invariant0.invariant' = Invariant1.invariant' clone CreusotContracts_Resolve_Impl1_Resolve as Resolve0 with @@ -195,7 +195,7 @@ module Borrows_Dec use prelude.Borrow use Borrows_NonZeroU32_Type as Borrows_NonZeroU32_Type clone Borrows_Impl0_Invariant as Invariant0 - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant1 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant1 with type t = Borrows_NonZeroU32_Type.t_nonzerou32, predicate Invariant0.invariant' = Invariant0.invariant' clone CreusotContracts_Resolve_Impl1_Resolve as Resolve0 with diff --git a/creusot/tests/should_succeed/type_invariants/generated.mlcfg b/creusot/tests/should_succeed/type_invariants/generated.mlcfg index b62bf5696..1c70b03b0 100644 --- a/creusot/tests/should_succeed/type_invariants/generated.mlcfg +++ b/creusot/tests/should_succeed/type_invariants/generated.mlcfg @@ -120,7 +120,7 @@ module Generated_UseList type t = Core_Option_Option_Type.t_option (Generated_List_Type.t_list int32) clone CreusotContracts_Invariant_Inv_Interface as Inv2 with type t = Core_Option_Option_Type.t_option (Generated_List_Type.t_list int32) - clone Core_Option_Option_Type_Inv as Core_Option_Option_Type_Inv with + clone Core_Option_Option_Type_Inv as Core_Option_Option_Type_Inv0 with type t = Generated_List_Type.t_list int32, predicate Inv0.inv = Inv2.inv, predicate UserInv0.user_inv = UserInv1.user_inv, @@ -128,7 +128,7 @@ module Generated_UseList axiom . clone CreusotContracts_Invariant_Inv_Interface as Inv1 with type t = int32 - clone TyInv_Trivial as TyInv_Trivial with + clone TyInv_Trivial as TyInv_Trivial0 with type t = int32, predicate Inv0.inv = Inv1.inv, axiom . @@ -136,7 +136,7 @@ module Generated_UseList type t = Generated_List_Type.t_list int32 clone CreusotContracts_Invariant_Inv_Interface as Inv0 with type t = Generated_List_Type.t_list int32 - clone Generated_List_Type_Inv as Generated_List_Type_Inv with + clone Generated_List_Type_Inv as Generated_List_Type_Inv0 with type t = int32, predicate Inv0.inv = Inv0.inv, predicate UserInv0.user_inv = UserInv0.user_inv, @@ -147,13 +147,12 @@ module Generated_UseList = [@vc:do_not_keep_trace] [@vc:sp] var _0 : (); - var l_1 : Generated_List_Type.t_list int32; + var l : Generated_List_Type.t_list int32 = l; { - l_1 <- l; goto BB0 } BB0 { - assert { [@expl:assertion] [#"../generated.rs" 7 18 7 35] Inv0.inv l_1 }; + assert { [@expl:assertion] [#"../generated.rs" 7 18 7 35] Inv0.inv l }; goto BB1 } BB1 { diff --git a/creusot/tests/should_succeed/vector/06_knights_tour.mlcfg b/creusot/tests/should_succeed/vector/06_knights_tour.mlcfg index e0005d3eb..4260f3c4b 100644 --- a/creusot/tests/should_succeed/vector/06_knights_tour.mlcfg +++ b/creusot/tests/should_succeed/vector/06_knights_tour.mlcfg @@ -599,12 +599,12 @@ module CreusotContracts_Std1_Iter_MapInv_MapInv_Type | C_MapInv _ a _ -> a end end -module CreusotContracts_Invariant_Impl1_Invariant_Stub +module CreusotContracts_Invariant_Impl2_Invariant_Stub type t use prelude.Borrow predicate invariant' (self : borrowed t) end -module CreusotContracts_Invariant_Impl1_Invariant_Interface +module CreusotContracts_Invariant_Impl2_Invariant_Interface type t use prelude.Borrow predicate invariant' (self : borrowed t) @@ -612,13 +612,13 @@ module CreusotContracts_Invariant_Impl1_Invariant_Interface ensures { result = invariant' self } end -module CreusotContracts_Invariant_Impl1_Invariant +module CreusotContracts_Invariant_Impl2_Invariant type t use prelude.Borrow clone CreusotContracts_Invariant_Invariant_Invariant_Stub as Invariant0 with type self = t predicate invariant' (self : borrowed t) = - [#"../../../../../creusot-contracts/src/invariant.rs" 36 20 36 39] Invariant0.invariant' ( * self) + [#"../../../../../creusot-contracts/src/invariant.rs" 59 20 59 39] Invariant0.invariant' ( * self) val invariant' (self : borrowed t) : bool ensures { result = invariant' self } @@ -853,7 +853,7 @@ module CreusotContracts_Std1_Iter_MapInv_Impl3_Reinitialize type b = b, type f = f, type Item0.item = Item0.item - clone CreusotContracts_Invariant_Impl1_Invariant_Stub as Invariant0 with + clone CreusotContracts_Invariant_Impl2_Invariant_Stub as Invariant0 with type t = CreusotContracts_Std1_Iter_MapInv_MapInv_Type.t_mapinv i Item0.item f predicate reinitialize (_1 : ()) = [#"../../../../../creusot-contracts/src/std/iter/map_inv.rs" 122 8 128 9] forall reset : borrowed (CreusotContracts_Std1_Iter_MapInv_MapInv_Type.t_mapinv i Item0.item f) . Invariant0.invariant' reset -> Completed0.completed reset -> Invariant1.invariant' (CreusotContracts_Std1_Iter_MapInv_MapInv_Type.mapinv_iter ( ^ reset)) -> NextPrecondition0.next_precondition ( ^ reset) /\ Preservation0.preservation (CreusotContracts_Std1_Iter_MapInv_MapInv_Type.mapinv_iter ( ^ reset)) (CreusotContracts_Std1_Iter_MapInv_MapInv_Type.mapinv_func ( ^ reset)) @@ -1090,7 +1090,7 @@ module Core_Iter_Traits_Iterator_Iterator_Collect_Interface type self = self clone CreusotContracts_Resolve_Resolve_Resolve_Stub as Resolve0 with type self = self - clone CreusotContracts_Invariant_Impl1_Invariant_Stub as Invariant1 with + clone CreusotContracts_Invariant_Impl2_Invariant_Stub as Invariant1 with type t = self clone CreusotContracts_Invariant_Invariant_Invariant_Stub as Invariant0 with type self = self @@ -1853,7 +1853,7 @@ module C06KnightsTour_Impl1_New type f = Closure30.c06knightstour_impl1_new_closure3, predicate Resolve1.resolve = Closure30.resolve, predicate Resolve0.resolve = Resolve1.resolve - clone CreusotContracts_Invariant_Impl1_Invariant as Invariant2 with + clone CreusotContracts_Invariant_Impl2_Invariant as Invariant2 with type t = CreusotContracts_Std1_Iter_MapInv_MapInv_Type.t_mapinv (Core_Ops_Range_Range_Type.t_range usize) usize Closure30.c06knightstour_impl1_new_closure3, predicate Invariant0.invariant' = Invariant1.invariant' clone CreusotContracts_Std1_Iter_MapInv_Impl3_Preservation as Preservation0 with From 251db3d63e62802a378748df0c4d1a8dade55348 Mon Sep 17 00:00:00 2001 From: Dominik Stolz Date: Wed, 14 Jun 2023 16:47:52 +0200 Subject: [PATCH 11/12] Fix borrows --- creusot/src/backend/ty_inv.rs | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-) diff --git a/creusot/src/backend/ty_inv.rs b/creusot/src/backend/ty_inv.rs index ce23d77ee..231c47d11 100644 --- a/creusot/src/backend/ty_inv.rs +++ b/creusot/src/backend/ty_inv.rs @@ -175,10 +175,18 @@ fn build_inv_exp_struct<'tcx>( TyKind::Ref(_, ty, Mutability::Not) => { build_inv_exp(ctx, names, ident, *ty, param_env, destruct_adt) } - TyKind::Ref(_, ty, Mutability::Mut) => { - let e = build_inv_exp(ctx, names, ident, *ty, param_env, destruct_adt)?; + TyKind::Ref(_, ty, Mutability::Mut) if destruct_adt => { + // cannot inline in ADTs, or else we might be missing + // `use prelude.Borrow` + // TODO include final value - Some(Exp::Current(Box::new(e))) + let deref = Exp::Current(Box::new(Exp::pure_var(ident))); + let body = build_inv_exp(ctx, names, "a".into(), *ty, param_env, destruct_adt)?; + Some(Exp::Let { + pattern: Pattern::VarP("a".into()), + arg: Box::new(deref), + body: Box::new(body), + }) } TyKind::Tuple(tys) => { let fields: Vec = @@ -201,7 +209,7 @@ fn build_inv_exp_struct<'tcx>( TyKind::Adt(adt_def, subst) if destruct_adt => { build_inv_exp_adt(ctx, names, ident, param_env, *adt_def, subst) } - TyKind::Adt(_, _) | TyKind::Param(_) => { + TyKind::Ref(_, _, _) | TyKind::Adt(_, _) | TyKind::Param(_) => { let inv_fun = Exp::impure_qvar(names.ty_inv(ty)); Some(inv_fun.app_to(Exp::pure_var(ident))) } From f41ad35ed1b62dfc3d1274b6f12bda929a07ee47 Mon Sep 17 00:00:00 2001 From: Dominik Stolz Date: Wed, 14 Jun 2023 17:41:02 +0200 Subject: [PATCH 12/12] Improve test --- .../type_invariants/generated.mlcfg | 207 ++++++++++++------ .../type_invariants/generated.rs | 22 +- .../type_invariants/generated/why3session.xml | 14 ++ .../type_invariants/generated/why3shapes.gz | Bin 0 -> 214 bytes 4 files changed, 177 insertions(+), 66 deletions(-) create mode 100644 creusot/tests/should_succeed/type_invariants/generated/why3session.xml create mode 100644 creusot/tests/should_succeed/type_invariants/generated/why3shapes.gz diff --git a/creusot/tests/should_succeed/type_invariants/generated.mlcfg b/creusot/tests/should_succeed/type_invariants/generated.mlcfg index 1c70b03b0..7ba47f00d 100644 --- a/creusot/tests/should_succeed/type_invariants/generated.mlcfg +++ b/creusot/tests/should_succeed/type_invariants/generated.mlcfg @@ -1,14 +1,38 @@ -module Core_Option_Option_Type - type t_option 't = - | C_None - | C_Some 't +module Generated_Sum10_Type + use prelude.Int + use prelude.Int32 + type t_sum10 = + | C_Sum10 int32 int32 + + let function sum10_0 (self : t_sum10) : int32 = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_Sum10 a _ -> a + end + let function sum10_1 (self : t_sum10) : int32 = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_Sum10 _ a -> a + end +end +module Generated_Impl0_UserInv_Stub + use Generated_Sum10_Type as Generated_Sum10_Type + predicate user_inv [#"../generated.rs" 11 4 11 29] (self : Generated_Sum10_Type.t_sum10) +end +module Generated_Impl0_UserInv_Interface + use Generated_Sum10_Type as Generated_Sum10_Type + predicate user_inv [#"../generated.rs" 11 4 11 29] (self : Generated_Sum10_Type.t_sum10) + val user_inv [#"../generated.rs" 11 4 11 29] (self : Generated_Sum10_Type.t_sum10) : bool + ensures { result = user_inv self } end -module Generated_List_Type - use Core_Option_Option_Type as Core_Option_Option_Type - type t_list 't = - | C_List 't (Core_Option_Option_Type.t_option (t_list 't)) +module Generated_Impl0_UserInv + use prelude.Int32 + use prelude.Int + use Generated_Sum10_Type as Generated_Sum10_Type + predicate user_inv [#"../generated.rs" 11 4 11 29] (self : Generated_Sum10_Type.t_sum10) = + [#"../generated.rs" 12 20 12 43] Int32.to_int (Generated_Sum10_Type.sum10_0 self) + Int32.to_int (Generated_Sum10_Type.sum10_1 self) = 10 + val user_inv [#"../generated.rs" 11 4 11 29] (self : Generated_Sum10_Type.t_sum10) : bool + ensures { result = user_inv self } end module CreusotContracts_Invariant_Inv_Stub @@ -29,6 +53,16 @@ module CreusotContracts_Invariant_Inv val inv (_x : t) : bool ensures { result = inv _x } +end +module Generated_Foo_Type + use prelude.Borrow + use prelude.Int + use prelude.UIntSize + use Generated_Sum10_Type as Generated_Sum10_Type + type t_foo 't = + | C_A (borrowed (Generated_Sum10_Type.t_sum10)) usize + | C_B 't + end module CreusotContracts_Invariant_UserInv_UserInv_Stub type self @@ -48,20 +82,22 @@ module CreusotContracts_Invariant_UserInv_UserInv ensures { result = user_inv self } end -module Generated_List_Type_Inv +module Generated_Foo_Type_Inv type t - use Generated_List_Type as Generated_List_Type - use Core_Option_Option_Type as Core_Option_Option_Type + use prelude.Borrow + use Generated_Sum10_Type as Generated_Sum10_Type clone CreusotContracts_Invariant_Inv_Stub as Inv2 with - type t = Core_Option_Option_Type.t_option (Generated_List_Type.t_list t) - clone CreusotContracts_Invariant_Inv_Stub as Inv1 with type t = t + use Generated_Foo_Type as Generated_Foo_Type + clone CreusotContracts_Invariant_Inv_Stub as Inv1 with + type t = borrowed (Generated_Sum10_Type.t_sum10) clone CreusotContracts_Invariant_UserInv_UserInv_Stub as UserInv0 with - type self = Generated_List_Type.t_list t + type self = Generated_Foo_Type.t_foo t clone CreusotContracts_Invariant_Inv_Stub as Inv0 with - type t = Generated_List_Type.t_list t - axiom inv_t_list : forall self : Generated_List_Type.t_list t . Inv0.inv self = (UserInv0.user_inv self /\ match (self) with - | Generated_List_Type.C_List a_0 a_1 -> Inv1.inv a_0 /\ Inv2.inv a_1 + type t = Generated_Foo_Type.t_foo t + axiom inv_t_foo : forall self : Generated_Foo_Type.t_foo t . Inv0.inv self = (UserInv0.user_inv self /\ match (self) with + | Generated_Foo_Type.C_A f1 _ -> Inv1.inv f1 + | Generated_Foo_Type.C_B a_0 -> Inv2.inv a_0 end) end module CreusotContracts_Invariant_Impl0_UserInv_Stub @@ -83,84 +119,129 @@ module CreusotContracts_Invariant_Impl0_UserInv ensures { result = user_inv self } end -module TyInv_Trivial - type t - clone CreusotContracts_Invariant_Inv_Stub as Inv0 with - type t = t - axiom inv_trivial : forall self : t . Inv0.inv self = true -end -module Core_Option_Option_Type_Inv +module TyInv_Borrow type t + use prelude.Borrow clone CreusotContracts_Invariant_Inv_Stub as Inv1 with type t = t - use Core_Option_Option_Type as Core_Option_Option_Type clone CreusotContracts_Invariant_UserInv_UserInv_Stub as UserInv0 with - type self = Core_Option_Option_Type.t_option t + type self = borrowed t clone CreusotContracts_Invariant_Inv_Stub as Inv0 with - type t = Core_Option_Option_Type.t_option t - axiom inv_t_option : forall self : Core_Option_Option_Type.t_option t . Inv0.inv self = (UserInv0.user_inv self /\ match (self) with - | Core_Option_Option_Type.C_None -> true - | Core_Option_Option_Type.C_Some a_0 -> Inv1.inv a_0 - end) + type t = borrowed t + axiom inv_borrow : forall self : borrowed t . Inv0.inv self = (UserInv0.user_inv self /\ (let a = * self in Inv1.inv a)) end -module Generated_UseList_Interface +module TyInv_Tuple2 + type t0 + type t1 + clone CreusotContracts_Invariant_Inv_Stub as Inv2 with + type t = t1 + clone CreusotContracts_Invariant_Inv_Stub as Inv1 with + type t = t0 + clone CreusotContracts_Invariant_Inv_Stub as Inv0 with + type t = (t0, t1) + axiom inv_tuple2 : forall self : (t0, t1) . Inv0.inv self = (let (a_0, a_1) = self in Inv1.inv a_0 /\ Inv2.inv a_1) +end +module Generated_Sum10_Type_Inv + use Generated_Sum10_Type as Generated_Sum10_Type + clone Generated_Impl0_UserInv_Stub as UserInv0 + clone CreusotContracts_Invariant_Inv_Stub as Inv0 with + type t = Generated_Sum10_Type.t_sum10 + axiom inv_t_sum10 : forall self : Generated_Sum10_Type.t_sum10 . Inv0.inv self = UserInv0.user_inv self +end +module TyInv_Trivial + type t + clone CreusotContracts_Invariant_Inv_Stub as Inv0 with + type t = t + axiom inv_trivial : forall self : t . Inv0.inv self = true +end +module Generated_UseFoo_Interface use prelude.Int - use prelude.Int32 - use Generated_List_Type as Generated_List_Type - val use_list [#"../generated.rs" 6 0 6 29] (l : Generated_List_Type.t_list int32) : () + use prelude.UInt32 + use prelude.Borrow + use Generated_Sum10_Type as Generated_Sum10_Type + use Generated_Foo_Type as Generated_Foo_Type + clone CreusotContracts_Invariant_Inv_Stub as Inv0 with + type t = Generated_Foo_Type.t_foo (Generated_Foo_Type.t_foo uint32, borrowed (Generated_Sum10_Type.t_sum10)) + val use_foo [#"../generated.rs" 22 0 22 61] (x : Generated_Foo_Type.t_foo (Generated_Foo_Type.t_foo uint32, borrowed (Generated_Sum10_Type.t_sum10))) : () + requires {[#"../generated.rs" 21 11 21 28] Inv0.inv x} + end -module Generated_UseList +module Generated_UseFoo use prelude.Int - use prelude.Int32 - use Generated_List_Type as Generated_List_Type + use prelude.UInt32 + use prelude.Borrow + clone CreusotContracts_Invariant_Inv_Interface as Inv5 with + type t = uint32 + clone TyInv_Trivial as TyInv_Trivial0 with + type t = uint32, + predicate Inv0.inv = Inv5.inv, + axiom . + use Generated_Foo_Type as Generated_Foo_Type + clone CreusotContracts_Invariant_Impl0_UserInv as UserInv3 with + type t = Generated_Foo_Type.t_foo uint32 + use Generated_Sum10_Type as Generated_Sum10_Type + clone Generated_Impl0_UserInv as UserInv2 + clone CreusotContracts_Invariant_Inv_Interface as Inv1 with + type t = borrowed (Generated_Sum10_Type.t_sum10) + clone CreusotContracts_Invariant_Inv_Interface as Inv4 with + type t = Generated_Foo_Type.t_foo uint32 + clone Generated_Foo_Type_Inv as Generated_Foo_Type_Inv1 with + type t = uint32, + predicate Inv0.inv = Inv4.inv, + predicate UserInv0.user_inv = UserInv3.user_inv, + predicate Inv1.inv = Inv1.inv, + predicate Inv2.inv = Inv5.inv, + axiom . clone CreusotContracts_Invariant_Inv_Interface as Inv3 with - type t = Generated_List_Type.t_list int32 - use Core_Option_Option_Type as Core_Option_Option_Type + type t = Generated_Sum10_Type.t_sum10 + clone Generated_Sum10_Type_Inv as Generated_Sum10_Type_Inv0 with + predicate Inv0.inv = Inv3.inv, + predicate UserInv0.user_inv = UserInv2.user_inv, + axiom . clone CreusotContracts_Invariant_Impl0_UserInv as UserInv1 with - type t = Core_Option_Option_Type.t_option (Generated_List_Type.t_list int32) + type t = borrowed (Generated_Sum10_Type.t_sum10) clone CreusotContracts_Invariant_Inv_Interface as Inv2 with - type t = Core_Option_Option_Type.t_option (Generated_List_Type.t_list int32) - clone Core_Option_Option_Type_Inv as Core_Option_Option_Type_Inv0 with - type t = Generated_List_Type.t_list int32, + type t = (Generated_Foo_Type.t_foo uint32, borrowed (Generated_Sum10_Type.t_sum10)) + clone TyInv_Tuple2 as TyInv_Tuple20 with + type t0 = Generated_Foo_Type.t_foo uint32, + type t1 = borrowed (Generated_Sum10_Type.t_sum10), predicate Inv0.inv = Inv2.inv, - predicate UserInv0.user_inv = UserInv1.user_inv, - predicate Inv1.inv = Inv3.inv, + predicate Inv1.inv = Inv4.inv, + predicate Inv2.inv = Inv1.inv, axiom . - clone CreusotContracts_Invariant_Inv_Interface as Inv1 with - type t = int32 - clone TyInv_Trivial as TyInv_Trivial0 with - type t = int32, + clone TyInv_Borrow as TyInv_Borrow0 with + type t = Generated_Sum10_Type.t_sum10, predicate Inv0.inv = Inv1.inv, + predicate UserInv0.user_inv = UserInv1.user_inv, + predicate Inv1.inv = Inv3.inv, axiom . clone CreusotContracts_Invariant_Impl0_UserInv as UserInv0 with - type t = Generated_List_Type.t_list int32 + type t = Generated_Foo_Type.t_foo (Generated_Foo_Type.t_foo uint32, borrowed (Generated_Sum10_Type.t_sum10)) clone CreusotContracts_Invariant_Inv_Interface as Inv0 with - type t = Generated_List_Type.t_list int32 - clone Generated_List_Type_Inv as Generated_List_Type_Inv0 with - type t = int32, + type t = Generated_Foo_Type.t_foo (Generated_Foo_Type.t_foo uint32, borrowed (Generated_Sum10_Type.t_sum10)) + clone Generated_Foo_Type_Inv as Generated_Foo_Type_Inv0 with + type t = (Generated_Foo_Type.t_foo uint32, borrowed (Generated_Sum10_Type.t_sum10)), predicate Inv0.inv = Inv0.inv, predicate UserInv0.user_inv = UserInv0.user_inv, predicate Inv1.inv = Inv1.inv, predicate Inv2.inv = Inv2.inv, axiom . - let rec cfg use_list [#"../generated.rs" 6 0 6 29] [@cfg:stackify] [@cfg:subregion_analysis] (l : Generated_List_Type.t_list int32) : () + let rec cfg use_foo [#"../generated.rs" 22 0 22 61] [@cfg:stackify] [@cfg:subregion_analysis] (x : Generated_Foo_Type.t_foo (Generated_Foo_Type.t_foo uint32, borrowed (Generated_Sum10_Type.t_sum10))) : () + requires {[#"../generated.rs" 21 11 21 28] Inv0.inv x} = [@vc:do_not_keep_trace] [@vc:sp] var _0 : (); - var l : Generated_List_Type.t_list int32 = l; + var x : Generated_Foo_Type.t_foo (Generated_Foo_Type.t_foo uint32, borrowed (Generated_Sum10_Type.t_sum10)) = x; { goto BB0 } BB0 { - assert { [@expl:assertion] [#"../generated.rs" 7 18 7 35] Inv0.inv l }; - goto BB1 - } - BB1 { + assert { [@expl:assertion] [#"../generated.rs" 23 18 23 35] Inv0.inv x }; _0 <- (); - goto BB2 - } - BB2 { return _0 } end +module Generated_Impl0 + +end diff --git a/creusot/tests/should_succeed/type_invariants/generated.rs b/creusot/tests/should_succeed/type_invariants/generated.rs index 1b5a0af53..76e792e5f 100644 --- a/creusot/tests/should_succeed/type_invariants/generated.rs +++ b/creusot/tests/should_succeed/type_invariants/generated.rs @@ -1,8 +1,24 @@ +#![allow(incomplete_features)] +#![feature(specialization)] extern crate creusot_contracts; use creusot_contracts::{invariant, *}; -pub struct List(T, Option>>); +pub struct Sum10(i32, i32); -pub fn use_list(l: List) { - proof_assert!(invariant::inv(l)) +impl invariant::UserInv for Sum10 { + #[predicate] + #[open] + fn user_inv(self) -> bool { + pearlite! { self.0@ + self.1@ == 10 } + } +} + +pub enum Foo<'a, T> { + A { f1: &'a mut Sum10, f2: usize }, + B(T), +} + +#[requires(invariant::inv(x))] +pub fn use_foo<'a>(x: Foo<'a, (Foo<'a, u32>, &'a mut Sum10)>) { + proof_assert!(invariant::inv(x)); } diff --git a/creusot/tests/should_succeed/type_invariants/generated/why3session.xml b/creusot/tests/should_succeed/type_invariants/generated/why3session.xml new file mode 100644 index 000000000..d3e44c3fc --- /dev/null +++ b/creusot/tests/should_succeed/type_invariants/generated/why3session.xml @@ -0,0 +1,14 @@ + + + + + + + + + + + + + diff --git a/creusot/tests/should_succeed/type_invariants/generated/why3shapes.gz b/creusot/tests/should_succeed/type_invariants/generated/why3shapes.gz new file mode 100644 index 0000000000000000000000000000000000000000..f540409ede3d6b99fd2507884b22ddc87224df01 GIT binary patch literal 214 zcmV;{04e_;iwFP!00000|3!|wj>0eyMSFjROEy);9zQ~tjT9M)5=|QoiV;YNK(esE zk8yUB?#$IaSFpnmBp9%dGO`-qOuju2Y?heT}{6^)rr4}pyuZk z$L;EFlo)R1+>UuAY0A56}BGDk3tugk+MM+tr>6^6R)F|CnvR>;SC)Ac6Y( zs9Y_buB@2^^K>G;`-fIgBTvI9lhB=pK?vi$#v`+HP@(NzkG86i!AE2ldzLQPU;+jm QRDe*5H&<2pJ3Rpa09yZKn*aa+ literal 0 HcmV?d00001