oxilean-codegen 0.1.2

OxiLean code generator - LCNF-based compilation and optimization
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
116
117
118
119
120

//! # SwiftExpr - Trait Implementations
//!
//! This module contains trait implementations for `SwiftExpr`.
//!
//! ## Implemented Traits
//!
//! - `Display`
//!
//! 🤖 Generated with [SplitRS](https://github.com/cool-japan/splitrs)

use crate::lcnf::*;

use super::types::SwiftExpr;
use std::fmt;

impl fmt::Display for SwiftExpr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            SwiftExpr::SwiftLitExpr(lit) => write!(f, "{}", lit),
            SwiftExpr::SwiftVar(name) => write!(f, "{}", name),
            SwiftExpr::SwiftSelf => write!(f, "self"),
            SwiftExpr::SwiftSuper => write!(f, "super"),
            SwiftExpr::SwiftCall { callee, args } => {
                write!(f, "{}(", callee)?;
                for (i, (label, expr)) in args.iter().enumerate() {
                    if i > 0 {
                        write!(f, ", ")?;
                    }
                    if label.is_empty() {
                        write!(f, "{}", expr)?;
                    } else {
                        write!(f, "{}: {}", label, expr)?;
                    }
                }
                write!(f, ")")
            }
            SwiftExpr::SwiftBinOp { op, lhs, rhs } => {
                write!(f, "({} {} {})", lhs, op, rhs)
            }
            SwiftExpr::SwiftMember(obj, field) => write!(f, "{}.{}", obj, field),
            SwiftExpr::SwiftSubscript(arr, idx) => write!(f, "{}[{}]", arr, idx),
            SwiftExpr::SwiftUnary(op, operand) => write!(f, "{}{}", op, operand),
            SwiftExpr::SwiftTernary(cond, then_e, else_e) => {
                write!(f, "({} ? {} : {})", cond, then_e, else_e)
            }
            SwiftExpr::SwiftOptionalChain(obj, field) => write!(f, "{}?.{}", obj, field),
            SwiftExpr::SwiftForceUnwrap(expr) => write!(f, "{}!", expr),
            SwiftExpr::SwiftArrayLit(elems) => {
                write!(f, "[")?;
                for (i, e) in elems.iter().enumerate() {
                    if i > 0 {
                        write!(f, ", ")?;
                    }
                    write!(f, "{}", e)?;
                }
                write!(f, "]")
            }
            SwiftExpr::SwiftDictLit(pairs) => {
                if pairs.is_empty() {
                    return write!(f, "[:]");
                }
                write!(f, "[")?;
                for (i, (k, v)) in pairs.iter().enumerate() {
                    if i > 0 {
                        write!(f, ", ")?;
                    }
                    write!(f, "{}: {}", k, v)?;
                }
                write!(f, "]")
            }
            SwiftExpr::SwiftTupleLit(elems) => {
                write!(f, "(")?;
                for (i, e) in elems.iter().enumerate() {
                    if i > 0 {
                        write!(f, ", ")?;
                    }
                    write!(f, "{}", e)?;
                }
                write!(f, ")")
            }
            SwiftExpr::SwiftAs(expr, ty) => write!(f, "({} as {})", expr, ty),
            SwiftExpr::SwiftTry(expr) => write!(f, "try {}", expr),
            SwiftExpr::SwiftAwait(expr) => write!(f, "await {}", expr),
            SwiftExpr::SwiftClosure {
                params,
                return_type,
                body,
            } => {
                write!(f, "{{ ")?;
                if !params.is_empty() {
                    for (i, (name, ty)) in params.iter().enumerate() {
                        if i > 0 {
                            write!(f, ", ")?;
                        }
                        if let Some(t) = ty {
                            write!(f, "{}: {}", name, t)?;
                        } else {
                            write!(f, "{}", name)?;
                        }
                    }
                    if let Some(ret) = return_type {
                        write!(f, " -> {} ", ret)?;
                    }
                    writeln!(f, "in")?;
                }
                for stmt in body {
                    writeln!(f, "    {}", stmt)?;
                }
                write!(f, "}}")
            }
            SwiftExpr::SwiftSwitchExpr { subject, arms } => {
                writeln!(f, "switch {} {{", subject)?;
                for (pat, expr) in arms {
                    writeln!(f, "    case {}: {}", pat, expr)?;
                }
                write!(f, "}}")
            }
        }
    }
}