backyard-nodes 0.1.9

Nodes representing PHP code AST.
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

# backyard-nodes

Nodes representing PHP code AST, with simple builder and walker.

## features

- Ast Nodes
- _"builder"_ simplify building AST nodes
- _"walker"_ simple walker through AST nodes

## usage

### builder

This builder is behind the `builder` feature.

    use backyard_nodes::builder::{ Builder, BlueprintBuildable };
    fn main() {
      let arena = bumpalo::Bump::new();
      let b = Builder::new();
      let node = b
        .Program(&[b.Assignment(b.Variable(b.Identifier("a")), "=", b.Number("21"))])
        .build(&arena);
      println!("{node:?}");
    }

Resulting this:

    Node {
      node_type: Program,
      wrapper: Program(ProgramNode {
        children: [
          Node {
            node_type: Assignment,
            wrapper: Assignment(AssignmentNode {
              left: Node {
                node_type: Variable,
                wrapper: Variable(VariableNode {
                  name: Node {
                    node_type: Identifier,
                    wrapper: Identifier(IdentifierNode { name: "a" }),
                    loc: None, leadings: None, trailings: None
                  }
                }),
                loc: None, leadings: None, trailings: None
              },
              operator: "=",
              right: Node {
                node_type: Number,
                wrapper: Number(NumberNode { value: "21" }),
                loc: None, leadings: None, trailings: None
              }
            }),
            loc: None, leadings: None, trailings: None
          }]
        }),
      loc: None, leadings: None, trailings: None
    }

### walker

This builder is behind the `walker` feature.

    use backyard_nodes::{ builder::{ BlueprintBuildable, Builder }, walker::Walker, NodeType };

    fn main() {
      let arena = bumpalo::Bump::new();
      let b = Builder::new();
      let node = b
        .Program(&[b.Assignment(b.Variable(b.Identifier("a")), "=", b.Number("21"))])
        .build(&arena);
      let mut walker = Walker::new(&*node).into_iter();

      assert_eq!(NodeType::Program, walker.next().unwrap().node_type);
      assert_eq!(NodeType::Assignment, walker.next().unwrap().node_type);
      assert_eq!(NodeType::Variable, walker.next().unwrap().node_type);
      assert_eq!(NodeType::Identifier, walker.next().unwrap().node_type);
      assert_eq!(NodeType::Number, walker.next().unwrap().node_type);
      assert!(walker.next().is_none());
    }

## ecosystem

- [backyard-lexer (Tokenizer)](https://crates.io/crates/backyard-lexer)
- [backyard-parser](https://crates.io/crates/backyard-parser)
- [backyard-generator](https://crates.io/crates/backyard-generator)

## heavily inspired by

- [oxc-project/oxc](https://github.com/oxc-project/oxc)
- [nikic/PHP-Parser](https://github.com/nikic/PHP-Parser)
- [glayzzle/php-parser](https://github.com/glayzzle/php-parser)

## license

[MIT](https://github.com/Alzera/backyard/blob/main/LICENSE)