c2rust-refactor 0.15.0

C2Rust refactoring tool implementation
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

'''This module generates `AstEquiv` impls for each AST node type.

- Two struct values are equivalent if their fields are equivalent.
- Two enum values are equivalent if they are built with the same variant and
  they have equivalent values in their corresponding fields.
- Two flag values are equivalent if they are equivalent under `==`.

Attributes:

- `#[equiv_mode=eq]`: On a type declaration, generate a trivial `impl` that compares
  values using `==`.

- `#[equiv_mode=ignore]`: On a type declaration, generate a trivial `impl` that
  always returns `true`.  The effect is that comparisons will ignore fields of
  this type.

- `#[equiv_mode=custom]`: On a type declaration, do not generate an `impl`.
'''

from datetime import datetime
from textwrap import indent, dedent

from ast import *
from util import *


@linewise
def exhaustiveness_check(se, target):
    yield 'match %s {' % target
    for v, path in variants_paths(se):
        yield '  &%s => {},' % struct_pattern(v, path)
    yield '}'

@linewise
def comparison(se, method, target1, target2):
    yield 'match (%s, %s) {' % (target1, target2)
    for v, path in variants_paths(se):
        yield '  (&%s,' % struct_pattern(v, path, '1')
        yield '   &%s) => {' % struct_pattern(v, path, '2')
        for f in v.fields:
            yield '    AstEquiv::%s(%s1, %s2) &&' % \
                    (method, f.name, f.name)
        yield '    true'
        yield '  }'
    yield '  (_, _) => false,'
    yield '}'


@linewise
def compare_impl(se):
    yield '#[allow(unused, non_shorthand_field_patterns)]'
    yield 'impl AstEquiv for %s {' % se.name
    yield '  fn ast_equiv(&self, other: &Self) -> bool {'
    yield '    // Exhaustiveness check'
    yield indent(exhaustiveness_check(se, 'self'), '    ')
    yield ''
    yield '    // Comparison'
    yield indent(comparison(se, 'ast_equiv', 'self', 'other'), '    ')
    yield '  }'
    yield '  fn unnamed_equiv(&self, other: &Self) -> bool {'
    yield indent(comparison(se, 'unnamed_equiv', 'self', 'other'), '    ')
    yield '  }'
    yield '}'

@linewise
def eq_impl(d):
    yield '#[allow(unused)]'
    yield 'impl AstEquiv for %s {' % d.name
    yield '  fn ast_equiv(&self, other: &Self) -> bool {'
    yield '    self == other'
    yield '  }'
    yield '  fn unnamed_equiv(&self, other: &Self) -> bool {'
    yield '    self == other'
    yield '  }'
    yield '}'

@linewise
def ignore_impl(d):
    yield '#[allow(unused)]'
    yield 'impl AstEquiv for %s {' % d.name
    yield '  fn ast_equiv(&self, other: &Self) -> bool {'
    yield '    true'
    yield '  }'
    yield '  fn unnamed_equiv(&self, other: &Self) -> bool {'
    yield '    true'
    yield '  }'
    yield '}'

@linewise
def generate(decls):
    yield '// AUTOMATICALLY GENERATED - DO NOT EDIT'
    yield '// Produced %s by process_ast.py' % (datetime.now(),)
    yield ''

    for d in decls:
        mode = d.attrs.get('equiv_mode')
        if mode is None:
            if isinstance(d, (Struct, Enum)):
                mode = 'compare'
            else:
                mode = 'eq'

        if mode == 'compare':
            yield compare_impl(d)
        elif mode == 'eq':
            yield eq_impl(d)
        elif mode == 'ignore':
            yield ignore_impl(d)
        elif mode == 'custom':
            pass