Bug: Wrong case of `expression_of_fn_ptr`

[ssyram]

The following code:

use std::path::PathBuf;

fn func(path: PathBuf) -> PathBuf {
  path.components().skip(1).collect()
}
fn main() { }

Produces the error of:

ERROR translating test::func: File "lib/AstOfLlbc.ml", line 1726, characters 8-14: Assertion failed

[protz]

I believe this is due to some iterator traits being blocklisted because they used to be non-extractable.

If I apply this diff:

diff --git a/lib/AstOfLlbc.ml b/lib/AstOfLlbc.ml
index 25b533e..d7a1fda 100644
--- a/lib/AstOfLlbc.ml
+++ b/lib/AstOfLlbc.ml
@@ -1155,11 +1155,6 @@ let blocklisted_trait_decls =
     "core::marker::Sync";
     "core::marker::Tuple";
     "core::marker::Copy";
-    (* The traits below *should* be handled properly ASAP. But for now, we have specific *instances*
-       of those trait methods in the builtin lookup table, which we then implement by hand with
-       macros. *)
-    "core::iter::traits::iterator::Iterator";
-    "core::iter::range::Step";
     (* TODO: figure out what to do with those *)
     "core::clone::Clone";
     (* TODO: these ones carry the drop_in_place code, but sometimes there's no

then we get a loop because

Visiting opaque function: core::iter::adapters::skip::{core::iter::traits::iterator::Iterator<Clause1_Item> for core::iter::adapters::skip::Skip<I>[TraitClause@0]}::next
  opaque fn core::iter::adapters::skip::{core::iter::traits::iterator::Iterator<Clause1_Item> for core::iter::adapters::skip::Skip<I>[TraitClause@0]}::next<0, I, Clause1_Item>(&0 mut (core::iter::adapters::skip::Skip<I>[T
raitClause@0])) -> core::option::Option<Clause1_Item>[parent(TraitClause@1)::TraitClause@1]
  where
    [TraitClause@0]: core::marker::Sized<I>,
    [TraitClause@1]: core::iter::traits::iterator::Iterator<I, Clause1_Item>,

# to compute the signature of skip::next, we need the types for the methods of Iterator, such as collect

computed method signature core::iter::traits::iterator::Iterator::collect:
fn<B>(T@0) -> T@2
where
 [TraitClause@0]: core::marker::Sized<T@2>,
 [TraitClause@1]: core::iter::traits::collect::FromIterator<T@2, T@1>,
 [TraitClause@2]: core::marker::Sized<T@0>,

# in turn, to compute the type of `collect`, we need to get the types of the methods in FromIterator

 computed method signature core::iter::traits::collect::FromIterator::from_iter:
fn<T, Clause1_IntoIter>(T@3) -> T@2
where
 [TraitClause@0]: core::marker::Sized<T@3>,
 [TraitClause@1]: core::iter::traits::collect::IntoIterator<T@3, T@1, T@4>,

# but IntoIterator inherits the Iterator trait, and then we loop

I don't think there's an easy way to fix this -- this looks like non-regular polymorphism (i.e. one where the type graph is not finite); @Nadrieril how does this get monomorphized suitably?

I don't think this is worth spending a lot of time on this, because this is likely going to be a very hard fix, and I'd rather wait for monomorphization to fix it, especially if you already have a workaround

[ssyram]

OK, good to know the actual situation and no worries, this is just a tiny manual fix.

[Nadrieril]

The type graph always ends up finite, Rust doesn't support unbounded polymorphic recursion or anything like that; it may get coinductive however. Charon's monomorphization supports this case.

[protz]

Yes I guess I'd have to detect cycles and stop the recursive construction of the trait method arguments. Sounds like it'd be much better to take the monomorphized code.

Thanks for your understanding @ssyram