slang_solidity 1.3.5

A modular set of compiler APIs empowering the next generation of Solidity code analysis and developer tooling. Written in Rust and distributed in multiple languages.
Documentation 
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
111
112
113
114
115

{% macro render_visitor(language) -%}
  {%- set target = model.ir_languages[language].target -%}
  use std::rc::Rc;
  use crate::cst::TerminalNode;
  #[allow(clippy::wildcard_imports)]
  use super::nodes::*;

  pub trait Visitor {
    {%- for parent_type, sequence in target.sequences %}
      fn enter_{{ parent_type | snake_case }}(&mut self, _node: &{{ parent_type }}) -> bool { true }
      fn leave_{{ parent_type | snake_case }}(&mut self, _node: &{{ parent_type }}) {}
    {% endfor -%}
    {%- for parent_type, choice in target.choices %}
      fn enter_{{ parent_type | snake_case }}(&mut self, _node: &{{ parent_type }}) -> bool { true }
      fn leave_{{ parent_type | snake_case }}(&mut self, _node: &{{ parent_type }}) {}
    {% endfor -%}
    {%- for parent_type, collection in target.collections %}
      fn enter_{{ parent_type | snake_case }}(&mut self, _items: &{{ parent_type }}) -> bool { true }
      fn leave_{{ parent_type | snake_case }}(&mut self, _items: &{{ parent_type }}) {}
    {% endfor -%}
  }

  //
  // Sequences:
  //

  {% for parent_type, sequence in target.sequences %}
    pub fn accept_{{ parent_type | snake_case }}(node: &{{ parent_type }}, visitor: &mut impl Visitor) {
      if !visitor.enter_{{ parent_type | snake_case }}(node) {
        return;
      }
      {% for field in sequence.fields -%}
        {%- if not field.type.is_terminal -%}
          {%- if field.is_optional -%}
            if let Some(ref {{ field.label | snake_case }}) = node.{{ field.label | snake_case }} {
              accept_{{ field.type.name | snake_case }}({{ field.label }}, visitor);
            }
          {% else -%}
            accept_{{ field.type.name | snake_case }}(&node.{{ field.label }}, visitor);
          {%- endif -%}
        {%- endif -%}
      {%- endfor -%}
      visitor.leave_{{ parent_type | snake_case }}(node);
    }

  {% endfor %}

  //
  // Choices:
  //

  {% for parent_type, choice in target.choices %}
    {%- set nonterminals = choice.variants | filter(attribute="kind", value="Nonterminal") -%}
    {%- set unique_terminals = choice.variants | filter(attribute="kind", value="UniqueTerminal") -%}
    {%- set non_unique_terminals = choice.variants | filter(attribute="kind", value="Terminal") -%}
    {% if nonterminals | length == 0 %}
      pub fn accept_{{ parent_type | snake_case }}(_node: &{{ parent_type }}, _visitor: &mut impl Visitor) {}
    {% else %}
      pub fn accept_{{ parent_type | snake_case }}(node: &{{ parent_type }}, visitor: &mut impl Visitor) {
        if !visitor.enter_{{ parent_type | snake_case }}(node) {
          return;
        }
        match node {
          {% for nonterminal in nonterminals -%}
            {{ parent_type }}::{{ nonterminal.name }}(ref {{ nonterminal.name | snake_case }}) => {
              accept_{{ nonterminal.name | snake_case }}({{ nonterminal.name | snake_case }}, visitor);
            }
          {%- endfor %}
          {%- if non_unique_terminals | length > 0 %}
            {%- for terminal in non_unique_terminals -%}
              {%- if not loop.first -%} | {%- endif -%}
              {{ parent_type }}::{{ terminal.name }}(_)
            {%- endfor -%}
            => {}
          {% endif -%}
          {%- if unique_terminals | length > 0 %}
            {%- for terminal in unique_terminals -%}
              {%- if not loop.first -%} | {%- endif -%}
              {{ parent_type }}::{{ terminal.name }}
            {%- endfor -%}
            => {}
          {% endif -%}
        }
        visitor.leave_{{ parent_type | snake_case }}(node);
      }
    {% endif %}
  {% endfor %}

  //
  // Repeated & Separated
  //

  {% for parent_type, collection in target.collections -%}
    {%- if collection.item_type.is_terminal %}
      #[inline]
      fn accept_{{ parent_type | snake_case }}(items: &Vec<Rc<TerminalNode>>, visitor: &mut impl Visitor) {
        if visitor.enter_{{ parent_type | snake_case }}(items) {
          visitor.leave_{{ parent_type | snake_case }}(items);
        }
      }
    {% else %}
      #[inline]
      fn accept_{{ parent_type | snake_case }}(items: &Vec<{{ collection.item_type.name }}>, visitor: &mut impl Visitor) {
        if !visitor.enter_{{ parent_type | snake_case }}(items) {
          return;
        }
        for item in items {
          accept_{{ collection.item_type.name | snake_case }}(item, visitor);
        }
        visitor.leave_{{ parent_type | snake_case }}(items);
      }
    {% endif -%}
  {% endfor %}

{% endmacro render_visitor %}