jfecher
commented
1 week ago Current goal is to get a vertical slice of metaprogramming working to support deriving a trait impl of a simple type on a simple trait like Default:
comptime fn derive_default(typ: TypeDefinition) -> Quoted {
let generics: [Quoted] = typ.generics();
assert(generics.is_empty(), "derive_default: Deriving Default on generic types is currently unimplemented");
let type_name: Type = typ.as_type();
let fields: [(Quoted, Type)] = typ.fields();
let fields: Quoted = fields.map(|(name, _)| quote { $name : Default::default(), })
.join();
quote {
impl Default for $type_name {
fn default() -> Self {
Self { $fields }
}
}
}
}
#[derive_default]
struct Foo {
x: Field
}
// Expected output:
//
// impl Default for Foo {
// fn default(this: Self) -> Self {
// Foo {
// x: Default::default(),
// }
// }
// }Required unimplemented features:
- Query functions on
TypeDefinition:generics,as_type, andfields Quotedtype for quoted, unparsed raw token streams. I think this is necessary to quote code fragments likequote { $name : Default::default(), }which is only valid in the context of struct initialization. I've chosen this name to avoid confusion with crypto tokens thatTokensorTokenStreammay cause.- Additionally, to support this and make unquoting easier into arbitrary locations of quoted values, I'd like to move from an AST representation of quoted values to a token stream. This will ensure we can combine values like
quote { $name : Default::default(), }where$nameis spliced in despite us not knowing what grammar rule it should be part of (is it an identifier? an expression?). Quotedtoken streams will be the new default type of quoted values with alternate types likequote Type { ... }orquote TopLevelItem { ... }only being used to force a quoted value into a particular shape so that specific methods can be called on it.TypeDefinitionis the only type with methods on it above but we can imagine similar methods on aTypevalue which would be meaningless on unparsedQuotedvalues.- Notably, quoting the impl as a token stream avoids us needing to rework the parser to make our top level statement parser recursive since at parse time we'd only be parsing a token stream here.
- The token stream ends when the matching
}is found. - We avoid actually parsing
Quotedvalues until they're expanded into a macro's call site: either a top level statement or an expression. When this happens, we parse the token stream and issue an error if we cannot parse into a top level statement or an expression.
- Additionally, to support this and make unquoting easier into arbitrary locations of quoted values, I'd like to move from an AST representation of quoted values to a token stream. This will ensure we can combine values like
- Some helper functions like
jointo join a slice of quoted values into one:fn join(slice: [Quoted]) -> Quoted { let mut ret = quote {}; for element in slice { // Since quoted values are token streams, we do not need (or want) a `;` separator. ret = quote { $ret $element }; } ret } - Finally, it is optional but would be very useful to get generic functions like
mapworking in the interpreter. The work around for this is writing a monomorphic version ofmapforQuotedvalues.
Edit: We used to have a Code type for quoted code. Maybe we should use that name over Quoted?
Proposal: https://hackmd.io/Tkzo_ryvTsWMPESmWHPiZw?view