Change the algorithm in validate_terminates

creusot-contracts-proc/src/lib.rs

@@ -426,6 +426,17 @@ pub fn snapshot(assertion: TS1) -> TS1 {
 #[proc_macro_attribute]
 pub fn terminates(_: TS1, tokens: TS1) -> TS1 {
     let documentation = document_spec("terminates", TS1::new());
+    if let Ok(item) = syn::parse::<ImplItemFn>(tokens.clone()) {
+        if let Some(def) = item.defaultness {
+            return syn::Error::new(
+                def.span(),
+                "`terminates` functions cannot use the `default` modifier",
+            )
+            .into_compile_error()
+            .into();
+        }
+    };
+
     let mut result = TS1::from(quote! { #[creusot::clause::terminates] #documentation });
     result.extend(tokens);
     result
@@ -434,6 +445,16 @@ pub fn terminates(_: TS1, tokens: TS1) -> TS1 {
 #[proc_macro_attribute]
 pub fn pure(_: TS1, tokens: TS1) -> TS1 {
     let documentation = document_spec("pure", TS1::new());
+    if let Ok(item) = syn::parse::<ImplItemFn>(tokens.clone()) {
+        if let Some(def) = item.defaultness {
+            return syn::Error::new(
+                def.span(),
+                "`pure` functions cannot use the `default` modifier",
+            )
+            .into_compile_error()
+            .into();
+        }
+    };
     let mut result = TS1::from(
         quote! { #[creusot::clause::no_panic] #[creusot::clause::terminates] #documentation },
     );
@@ -474,7 +495,13 @@ impl Parse for LogicInput {
         let attrs = input.call(Attribute::parse_outer)?;
         // Infalliable, no visibility = inherited
         let vis: Visibility = input.parse()?;
-        let default = input.parse()?;
+        let default: Option<_> = input.parse()?;
+        if default.is_some() {
+            return Err(syn::Error::new(
+                input.span(),
+                "logical functions cannot use the `default` modifier",
+            ));
+        }
         let sig: Signature = input.parse()?;
         let lookahead = input.lookahead1();
         if lookahead.peek(Token![;]) {

creusot/src/translation/traits.rs

@@ -261,7 +261,7 @@ impl<'tcx> TraitResolved<'tcx> {
                 return TraitResolved::NoInstance;
             }
         };
-        trace!("resolve_assoc_item_opt {source:?}",);
+        trace!("TraitResolved::resolve {source:?}",);
 
         match source {
             ImplSource::UserDefined(impl_data) => {
@@ -305,6 +305,29 @@ impl<'tcx> TraitResolved<'tcx> {
         }
     }
 
+    /// Given a trait and some type parameters, try to find a concrete `impl` block for
+    /// this trait.
+    pub(crate) fn impl_id_of_trait(
+        tcx: TyCtxt<'tcx>,
+        param_env: ParamEnv<'tcx>,
+        trait_def_id: DefId,
+        substs: GenericArgsRef<'tcx>,
+    ) -> Option<DefId> {
+        let trait_ref = TraitRef::from_method(tcx, trait_def_id, substs);
+        let trait_ref = tcx.normalize_erasing_regions(param_env, trait_ref);
+
+        let Ok(source) = tcx.codegen_select_candidate((param_env, trait_ref)) else {
+            return None;
+        };
+        trace!("TraitResolved::impl_id_of_trait {source:?}",);
+        match source {
+            ImplSource::UserDefined(impl_data) => Some(impl_data.impl_def_id),
+            ImplSource::Param(_) => None,
+            // TODO: should we return something here, like we do in the above method?
+            ImplSource::Builtin(_, _) => None,
+        }
+    }
+
     pub fn to_opt(
         self,
         did: DefId,