Questions about compile times, syn and introspection.

[Permik]

Are you aware of the https://github.com/facet-rs/facet project?

It's a cool introspection library that doesn't use syn so the compile times stay manageable.
It does a lot of the work in comp time and type system, while using minimal macros to achieve fast compilation times.

I'll be very interested about what you think if this could be utilized in the cpg project.

Cheers!

[soareschen]

Hi @Permik, yes, I'm aware of Facet. I think the goals for Facet is quite different from the goals of CGP. In particular, Facet aims to reduce the compile time, especially for use of proc macros, by shifting the logic to runtime introspection. On the other hand, CGP aims to shift everything from run time to compile time, but via generics instead of proc macros.

The promise offer by both CGP and Facet shares some similarity. Facet requires users to only use #[derive(Facet)] on a struct, and get everything else such as serialization for free via runtime introspection. CGP also requires user to only derive some general traits such as #[derive(HasField, HasFields, BuildField)] on a struct, and everything else such as serialization can technically be implemented generically. In fact, I suspect that the generic CGP traits could probably even support a generic implementation of the Facet trait. We could also improve the ergonomic later by, by having a unified derive macro like #[derive(CgpField)] to derive al CGP field traits for a struct or enum.

For CGP, we don't care as much about compile time as Facet. Things may take slightly longer to compile, but the extra time is worth it if we can have less runtime overhead and eliminate runtime error. That said, CGP code tend to compile much faster than regular Rust code, due to the way we write code abstractly. The current main overhead of compiling CGP programs is at the main program compilation, but even that is pretty much solved by the next-gen trait solver, which should stabilize soon in Rust.

I think if there is one thing to learn from Facet, it is to remove the dependency of syn from the implementation of CGP macros, and use lighter weight macro libraries like unsynn, or even implementing the parser in CGP itself. However, even doing so, I'm not sure if we can completely remove syn from our dependency. We currently rely syn to parse the Rust constructs like ItemStruct, ItemImpl, and ItemTrait. I would like to support the full syntax grammar of Rust, and I don't know how Facet would parse something like ItemStruct without the help of syn. But if they have better approach, then I'm open to adopting alternatives to syn for parsing token streams.