Automatically generate Lua getters for all fields inside AST nodes

Author: ahomescu

Diff for: c2rust-refactor/build.rs

@@ -32,6 +32,7 @@ fn main() {
     process_ast("mac_table", &out_dir.join("mac_table_gen.inc.rs"));
     process_ast("nt_match", &out_dir.join("nt_match_gen.inc.rs"));
     process_ast("ast_names", &out_dir.join("ast_names_gen.inc.rs"));
+    process_ast("lua_ast_node", &out_dir.join("lua_ast_node_gen.inc.rs"));
 
     process_ast(
         "rewrite_rewrite",

Diff for: c2rust-refactor/gen/ast.txt

@@ -31,7 +31,7 @@ struct Mod { inner, #[mac_table_seq] items, #[rewrite_ignore] inline }
 
 
 #[rewrite_print_recover] #[rewrite_seq_item] #[rewrite_extra_strategies=item_header]
-#[nonterminal] #[extend_span]
+#[nonterminal] #[extend_span] #[fold_kind=ItemKind] #[boxed]
 struct Item { ident, #[match=ignore] attrs, id, kind, vis, span,
               #[match=ignore] #[rewrite_ignore] tokens }
 enum ItemKind {
@@ -61,9 +61,10 @@ enum UseTreeKind {
     Nested(nested),
 }
 
+#[fold_kind=UseTreeKind] #[boxed=both]
 struct UseTree { kind, prefix, span }
 
-#[nonterminal] #[extend_span]
+#[nonterminal] #[extend_span] #[fold_kind=TraitItemKind]
 struct TraitItem { id, ident, #[match=ignore] attrs, generics, kind, span,
                    #[match=ignore] #[rewrite_ignore] tokens }
 enum TraitItemKind {
@@ -73,7 +74,7 @@ enum TraitItemKind {
     Macro(mac),
 }
 
-#[nonterminal] #[extend_span]
+#[nonterminal] #[extend_span] #[fold_item=ImplItemKind]
 struct ImplItem { id, ident, vis, defaultness, #[match=ignore] attrs, generics, kind, span,
                   #[match=ignore] #[rewrite_ignore] tokens }
 enum ImplItemKind {
@@ -102,6 +103,7 @@ struct MethodSig { header, decl }
 
 struct ForeignMod { abi, #[mac_table_seq] items }
 #[rewrite_print_recover] #[rewrite_seq_item] #[nonterminal] #[extend_span]
+#[fold_kind=ForeignItemKind]
 struct ForeignItem { ident, #[match=ignore] attrs, kind, id, span, vis }
 enum ForeignItemKind {
     Fn(decl, generics),
@@ -112,7 +114,7 @@ enum ForeignItemKind {
 
 
 struct Generics { params, where_clause, span }
-#[extend_span]
+#[extend_span] #[fold_kind=GenericParamKind]
 struct GenericParam { id, ident, attrs, bounds, kind, is_placeholder }
 enum GenericParamKind {
     Lifetime,
@@ -145,6 +147,7 @@ enum CrateSugar {
 }
 
 #[match=custom] #[rewrite_print_recover] #[mac_table_record] #[nonterminal]
+#[fold_kind=TyKind] #[boxed]
 struct Ty { id, kind, span }
 struct MutTy {ty, mutbl}
 enum TyKind {
@@ -167,12 +170,15 @@ enum TyKind {
     CVarArgs,
 }
 
-flag TraitObjectSyntax;
-
+enum TraitObjectSyntax {
+    Dyn,
+    None,
+}
 
 flag LitIntType;
 flag FloatTy;
 
+#[boxed]
 struct BareFnTy { unsafety, abi, decl, generic_params }
 struct Lifetime { id, ident }
 enum GenericBound {
@@ -182,6 +188,7 @@ enum GenericBound {
 
 struct PolyTraitRef { trait_ref, span, bound_generic_params }
 
+#[boxed]
 struct FnDecl { inputs, output }
 struct FnHeader { unsafety, asyncness, constness, abi }
 #[rewrite_print]
@@ -193,6 +200,7 @@ enum FunctionRetTy {
 
 
 #[match=custom] #[rewrite_print_recover] #[rewrite_seq_item] #[nonterminal]
+#[fold_kind=StmtKind]
 struct Stmt { id, kind, span }
 #[no_debug]
 enum StmtKind {
@@ -203,11 +211,12 @@ enum StmtKind {
     Mac(mac),
 }
 
-#[extend_span]
+#[extend_span] #[boxed]
 struct Local { pat, ty, init, id, span, #[match=ignore] attrs }
 
 
 #[match=custom] #[rewrite_print_recover] #[extend_span] #[mac_table_record] #[nonterminal]
+#[fold_kind=ExprKind] #[boxed]
 struct Expr { id, kind, span, #[match=ignore] attrs }
 #[prec_contains_expr]
 enum ExprKind {
@@ -295,11 +304,12 @@ enum BinOpKind {
 struct Field { id, ident, expr, span, is_shorthand, attrs, is_placeholder }
 #[extend_span]
 struct Arm { id, attrs, pat, guard, body, span, is_placeholder }
-#[match=custom] #[rewrite_print_recover] #[nonterminal]
+#[match=custom] #[rewrite_print_recover] #[nonterminal] #[boxed]
 struct Block { #[mac_table_seq] stmts, id, rules, span }
 
 
 #[match=custom] #[mac_table_record] #[nonterminal]
+#[fold_kind=PatKind] #[boxed]
 struct Pat { id, kind, span }
 enum PatKind {
     Wild,
@@ -337,18 +347,28 @@ enum LitKind {
     Err(sym),
 }
 
-#[no_kind]
+#[fold_kind=TokenLitKind]
 struct TokenLit { kind, symbol, suffix }
 
-flag TokenLitKind;
-
+enum TokenLitKind {
+    Bool,
+    Byte,
+    Char,
+    Integer,
+    Float,
+    Str,
+    StrRaw(n),
+    ByteStr,
+    ByteStrRaw(n),
+    Err,
+}
 
 flag Defaultness;
 flag Constness;
 flag ImplPolarity;
 flag IsAuto;
 flag Unsafety;
-flag Abi;
+#[to_lua_custom] flag Abi;
 #[match=eq] flag Mutability;
 enum RangeEnd {
     Included(syntax),
@@ -379,9 +399,11 @@ struct AttrItem { path, tokens }
 flag AttrStyle;
 
 
-#[match=custom] #[nonterminal]
+#[match=custom] #[nonterminal] #[boxed=both]
 struct Path { span, segments }
 struct PathSegment { ident, id, args }
+
+#[boxed]
 enum GenericArgs {
     AngleBracketed(abpd),
     Parenthesized(ppd),
@@ -408,11 +430,13 @@ flag MacStmtStyle;
 flag TokenStream;
 struct MacroDef { tokens, legacy }
 
-
+#[boxed]
 struct InlineAsm {
 asm, asm_str_style, outputs, inputs, clobbers,
 volatile, alignstack, dialect
 }
+
+#[boxed]
 struct GlobalAsm { asm }
 struct InlineAsmOutput { constraint, expr, is_rw, is_indirect }
 
@@ -429,22 +453,24 @@ struct AnonConst {
     value,
 }
 
-#[match=custom] #[equiv_mode=custom] struct Ident { name, span }
-#[match=eq] flag Name;
+#[match=custom] #[equiv_mode=custom] #[to_lua_custom] struct Ident { name, span }
+#[match=eq] #[to_lua_custom] flag Name;
 #[equiv_mode=ignore] #[match=eq] flag SyntaxContext;
 
-#[equiv_mode=ignore] #[rewrite_ignore]
+#[equiv_mode=ignore] #[rewrite_ignore] #[to_lua_custom]
 flag Span;
 #[equiv_mode=ignore] #[rewrite_ignore] #[list_node_ids=custom] #[mac_table_custom]
+#[to_lua_custom]
 flag NodeId;
-#[equiv_mode=ignore] #[rewrite_ignore]
+#[equiv_mode=ignore] #[rewrite_ignore] #[to_lua_custom]
 flag AttrId;
 
-flag usize;
-#[match=eq] flag bool;
-#[match=eq] flag u128;
-#[match=eq] flag u8;
-#[match=eq] flag char;
+#[to_lua_custom] flag usize;
+#[match=eq] #[to_lua_custom] flag bool;
+#[match=eq] #[to_lua_custom] flag u128;
+#[match=eq] #[to_lua_custom] flag u16;
+#[match=eq] #[to_lua_custom] flag u8;
+#[match=eq] #[to_lua_custom] flag char;
 
 
 enum Nonterminal {
@@ -476,6 +502,7 @@ struct DelimSpan { open, close }
 flag DelimToken;
 flag Token;
 
+#[fold_kind=MetaItemKind]
 struct MetaItem { path, kind, span }
 enum MetaItemKind {
     Word,

Diff for: c2rust-refactor/gen/ast_names.py

@@ -24,26 +24,6 @@ def do_ast_names_impl(d):
     yield '  }'
     yield '}'
 
-def find_kind_field(s):
-    if 'no_kind' in s.attrs:
-        return None
-
-    marked_fields = []
-    for f in s.fields:
-        if 'kind' in f.attrs:
-            marked_fields.append(f.name)
-    if len(marked_fields) == 1:
-        return marked_fields[0]
-    elif len(marked_fields) > 1:
-        raise ValueError('struct %s has %d fields marked #[kind] (expected 0 or 1)' %
-                (s.name, len(marked_fields)))
-
-    for f in s.fields:
-        if f.name == 'kind':
-            return f.name
-
-    return None
-
 @linewise
 def generate(decls):
     yield '// AUTOMATICALLY GENERATED - DO NOT EDIT'

Diff for: c2rust-refactor/gen/lua_ast_node.py

@@ -0,0 +1,107 @@
+'''This module generates `LuaAstNode` impls for each AST node.
+
+Attributes:
+
+- `#[fold_kind=FooKind]`: Folds the kind enum with the given name
+  into the current structure.
+
+- `#[to_lua_custom]`: implements `ToLuaExt` and `UserData` separately.
+'''
+
+from datetime import datetime
+from textwrap import indent, dedent
+
+from ast import *
+from util import *
+
+@linewise
+def do_enum_variants(s, match_pat):
+    # Emit `children`
+    yield '    methods.add_method("children", |_lua_ctx, this, ()| {'
+    yield '      match %s {' % match_pat
+    for v in s.variants:
+        fpat = struct_pattern(v, '%s::%s' % (s.name, v.name))
+        yield '        %s => Ok([' % fpat
+        for f in v.fields:
+            yield '          %s.clone().to_lua_ext(_lua_ctx)?,' % f.name
+        yield '        ].iter().cloned().collect::<Vec<Value>>()),'
+    yield '      }'
+    yield '    });'
+
+    # Emit `nth_child`
+    yield '    methods.add_method("nth_child", |_lua_ctx, this, idx: usize| {'
+    yield '      match (%s, idx) {' % match_pat
+    for v in s.variants:
+        for idx, f in enumerate(v.fields):
+            fpat = struct_pattern(v, '%s::%s' % (s.name, v.name))
+            yield '        (%s, %d) => %s.clone().to_lua_ext(_lua_ctx),' % (fpat, idx, f.name)
+    yield '        _ => Ok(Value::Nil)' # FIXME
+    yield '      }'
+    yield '    });'
+
+@linewise
+def do_one_impl(s, kind_map, boxed):
+    # This object is NOT thread-safe. Do not use an object of this class from a
+    # thread that did not acquire it.
+    type_name = 'P<%s>' % s.name if boxed else s.name
+    yield 'unsafe impl Send for LuaAstNode<%s> {}' % type_name
+    yield 'impl LuaAstNodeSafe for LuaAstNode<%s> {}' % type_name
+    yield 'impl UserData for LuaAstNode<%s> {' % type_name
+    yield '  #[allow(unused, non_shorthand_field_patterns)]'
+    yield '  fn add_methods<\'lua, M: UserDataMethods<\'lua, Self>>(methods: &mut M) {'
+    if isinstance(s, Struct):
+        # FIXME: handle tuple struct
+        kind_field = find_kind_field(s)
+        for f in s.fields:
+            yield '    methods.add_method("get_%s", |_lua_ctx, this, ()| {' % f.name
+            if f.name == kind_field:
+                yield '      Ok(this.borrow().%s.ast_name())' % f.name
+            else:
+                yield '      this.borrow().%s.clone().to_lua_ext(_lua_ctx)' % f.name
+            yield '    });'
+
+        if 'fold_kind' in s.attrs:
+            kind_name = s.attrs['fold_kind']
+            kind_decl = kind_map[kind_name]
+            yield do_enum_variants(kind_decl, '&this.borrow().%s' % kind_field)
+
+    elif isinstance(s, Enum):
+        yield '    methods.add_method("get_kind", |_lua_ctx, this, ()| {'
+        yield '      Ok(this.borrow().ast_name())'
+        yield '    });'
+        box_prefix = '&**' if boxed else '&*'
+        yield do_enum_variants(s, box_prefix + 'this.borrow()')
+
+    yield '    <Self as AddMoreMethods>::add_more_methods(methods);'
+    yield '  }'
+    yield '}'
+
+@linewise
+def do_impl(s, kind_map):
+    if 'boxed' in s.attrs:
+        yield do_one_impl(s, kind_map, True)
+    if 'boxed' not in s.attrs or s.attrs['boxed'] == 'both':
+        yield do_one_impl(s, kind_map, False)
+
+@linewise
+def generate(decls):
+    yield '// AUTOMATICALLY GENERATED - DO NOT EDIT'
+    yield '// Produced %s by process_ast.py' % (datetime.now(),)
+    yield ''
+
+    kind_map = {}
+    for d in decls:
+        if 'fold_kind' in d.attrs:
+            kind_name = d.attrs['fold_kind']
+            kind_map[kind_name] = None
+
+    for d in decls:
+        if d.name in kind_map:
+            kind_map[d.name] = d
+
+    for d in decls:
+        if 'to_lua_custom' in d.attrs:
+            continue
+
+        yield do_impl(d, kind_map)
+

Diff for: c2rust-refactor/gen/process_ast.py

@@ -252,6 +252,9 @@ def parse(s):
     elif mode == 'ast_names':
         import ast_names
         text = ast_names.generate(decls)
+    elif mode == 'lua_ast_node':
+        import lua_ast_node
+        text = lua_ast_node.generate(decls)
     else:
         raise ValueError('unknown mode: %r' % mode)
 

Diff for: c2rust-refactor/gen/util.py

@@ -49,3 +49,22 @@ def snake(s):
         s = s[1:]
     return s
 
+def find_kind_field(s):
+    if 'no_kind' in s.attrs:
+        return None
+
+    marked_fields = []
+    for f in s.fields:
+        if 'kind' in f.attrs:
+            marked_fields.append(f.name)
+    if len(marked_fields) == 1:
+        return marked_fields[0]
+    elif len(marked_fields) > 1:
+        raise ValueError('struct %s has %d fields marked #[kind] (expected 0 or 1)' %
+                (s.name, len(marked_fields)))
+
+    for f in s.fields:
+        if f.name == 'kind':
+            return f.name
+
+    return None