ripex 0.2.0

Multi-language structural parsing and fact extraction.
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

use super::expr::{Block, Expr};
use crate::span::Span;

#[derive(Debug, Clone)]
pub enum Stmt {
    Expr(Expr, Span),
    Decl(Decl, Span),
    Assign(Vec<Expr>, Vec<Expr>, Span),
    Define(Vec<Expr>, Vec<Expr>, Span),
    If(Expr, Box<Stmt>, Option<Box<Stmt>>, Span),
    For(
        Option<Box<Stmt>>,
        Option<Expr>,
        Option<Box<Stmt>>,
        Box<Stmt>,
        Span,
    ),
    ForRange(Expr, String, Option<String>, Box<Stmt>, Span),
    Switch(Option<Expr>, Vec<CaseClause>, Span),
    Select(Vec<CaseClause>, Span),
    Return(Vec<Expr>, Span),
    Break(Option<String>, Span),
    Continue(Option<String>, Span),
    Defer(Expr, Span),
    Go(Expr, Span),
    Block(Block, Span),
    Empty(Span),
    Label(String, Box<Stmt>, Span),
    Goto(String, Span),
    Send(Expr, Expr, Span),
    Fallthrough(Span),
}

#[derive(Debug, Clone)]
pub enum Decl {
    Var(VarDecl, Span),
    Const(ConstDecl, Span),
    Type(TypeDecl, Span),
    Func(FuncDecl, Span),
    Import(ImportDecl, Span),
    ImportGroup(Vec<ImportDecl>, Span),
    Package(String, Span),
}

#[derive(Debug, Clone)]
pub struct VarDecl {
    pub names: Vec<String>,
    pub kind: Option<Box<Expr>>,
    pub values: Vec<Expr>,
    pub span: Span,
}

#[derive(Debug, Clone)]
pub struct ConstDecl {
    pub names: Vec<String>,
    pub kind: Option<Box<Expr>>,
    pub values: Vec<Expr>,
    pub span: Span,
}

#[derive(Debug, Clone)]
pub struct TypeDecl {
    pub name: String,
    pub kind: Box<Expr>,
    pub span: Span,
}

#[derive(Debug, Clone)]
pub struct FuncDecl {
    pub name: String,
    pub receiver: Option<(String, String)>,
    pub params: Vec<(String, Box<Expr>)>,
    pub returns: Vec<Box<Expr>>,
    pub body: Option<Block>,
    pub span: Span,
}

#[derive(Debug, Clone)]
pub struct ImportDecl {
    pub path: String,
    pub alias: Option<String>,
    pub span: Span,
}

#[derive(Debug, Clone)]
pub struct CaseClause {
    pub expr: Option<Expr>,
    pub body: Vec<Stmt>,
    pub span: Span,
}