backyard-generator 0.1.10

Convert AST node back to PHP code.
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

use backyard_nodes::{ cast_node, Node, NodeType, NodeWrapper };

use crate::generator::{ Builder, Generator, GeneratorArgument };

pub struct SinglesGenerator;

impl SinglesGenerator {
  pub fn generate<'arena>(
    generator: &mut Generator<'arena, '_>,
    builder: &mut Builder,
    node: &Node<'arena>
  ) {
    match node.node_type {
      NodeType::Break => {
        builder.push("break");
        if let Some(node) = &cast_node!(Break, &node.wrapper).statement {
          builder.push(" ");
          generator.generate_node(builder, node, &mut GeneratorArgument::default());
        }
      }
      NodeType::Continue => {
        builder.push("continue");
        if let Some(node) = &cast_node!(Continue, &node.wrapper).statement {
          builder.push(" ");
          generator.generate_node(builder, node, &mut GeneratorArgument::default());
        }
      }
      NodeType::Return => {
        builder.push("return");
        if let Some(node) = &cast_node!(Return, &node.wrapper).statement {
          builder.push(" ");
          generator.generate_node(builder, node, &mut GeneratorArgument::default());
        }
      }
      NodeType::Clone => {
        builder.push("clone ");
        generator.generate_node(
          builder,
          &cast_node!(Clone, &node.wrapper).statement,
          &mut GeneratorArgument::default()
        );
      }
      NodeType::New => {
        builder.push("new ");
        generator.generate_node(
          builder,
          &cast_node!(New, &node.wrapper).statement,
          &mut GeneratorArgument::default()
        );
      }
      NodeType::Print => {
        builder.push("print ");
        generator.generate_node(
          builder,
          &cast_node!(Print, &node.wrapper).statement,
          &mut GeneratorArgument::default()
        );
      }
      NodeType::Throw => {
        builder.push("throw ");
        generator.generate_node(
          builder,
          &cast_node!(Throw, &node.wrapper).statement,
          &mut GeneratorArgument::default()
        );
      }
      NodeType::Goto => {
        builder.push("goto ");
        generator.generate_node(
          builder,
          &cast_node!(Goto, &node.wrapper).label,
          &mut GeneratorArgument::default()
        );
      }
      NodeType::Inline => {
        builder.push(" ?>");
        builder.push(&cast_node!(Inline, &node.wrapper).text.to_string());
        builder.push("<?php ");
      }
      NodeType::Boolean => {
        let node = cast_node!(Boolean, &node.wrapper);
        if node.is_true {
          builder.push("true");
        } else {
          builder.push("false");
        }
      }
      NodeType::This => {
        builder.push("$this");
      }
      NodeType::Null => {
        builder.push("null");
      }
      NodeType::SelfKeyword => {
        builder.push("self");
      }
      NodeType::Parent => {
        builder.push("parent");
      }
      NodeType::StaticKeyword => {
        builder.push("static");
      }
      _ => {}
    }
  }
}