erl_parse 0.0.8

Erlang source code parser
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

use erl_tokenize::tokens::{AtomToken, SymbolToken};
use erl_tokenize::values::Symbol;
use erl_tokenize::{Position, PositionRange};

use super::super::Expr;
use super::Type;
use crate::traits::{Parse, TokenRead};
use crate::{Parser, Result};

/// `AtomToken` `Option<RecordFieldDefault>` `Option<RecordFieldType>`
#[derive(Debug, Clone)]
pub struct RecordFieldDecl {
    pub field_name: AtomToken,
    pub field_default: Option<RecordFieldDefault>,
    pub field_type: Option<RecordFieldType>,
}
impl Parse for RecordFieldDecl {
    fn parse<T: TokenRead>(parser: &mut Parser<T>) -> Result<Self> {
        Ok(RecordFieldDecl {
            field_name: track!(parser.parse())?,
            field_default: track!(parser.parse())?,
            field_type: track!(parser.parse())?,
        })
    }
}
impl PositionRange for RecordFieldDecl {
    fn start_position(&self) -> Position {
        self.field_name.start_position()
    }
    fn end_position(&self) -> Position {
        self.field_type
            .as_ref()
            .map(PositionRange::end_position)
            .or_else(|| self.field_default.as_ref().map(PositionRange::end_position))
            .unwrap_or_else(|| self.field_name.end_position())
    }
}

/// `=` `Expr`
#[derive(Debug, Clone)]
pub struct RecordFieldDefault {
    pub _match: SymbolToken,
    pub value: Expr,
}
impl Parse for RecordFieldDefault {
    fn parse<T: TokenRead>(parser: &mut Parser<T>) -> Result<Self> {
        Ok(RecordFieldDefault {
            _match: track!(parser.expect(&Symbol::Match))?,
            value: track!(parser.parse())?,
        })
    }
}
impl PositionRange for RecordFieldDefault {
    fn start_position(&self) -> Position {
        self._match.start_position()
    }
    fn end_position(&self) -> Position {
        self.value.end_position()
    }
}

/// `::` `Type`
#[derive(Debug, Clone)]
pub struct RecordFieldType {
    pub _double_colon: SymbolToken,
    pub field_type: Type,
}
impl Parse for RecordFieldType {
    fn parse<T: TokenRead>(parser: &mut Parser<T>) -> Result<Self> {
        Ok(RecordFieldType {
            _double_colon: track!(parser.expect(&Symbol::DoubleColon))?,
            field_type: track!(parser.parse())?,
        })
    }
}
impl PositionRange for RecordFieldType {
    fn start_position(&self) -> Position {
        self._double_colon.start_position()
    }
    fn end_position(&self) -> Position {
        self.field_type.end_position()
    }
}