shuck-parser 0.0.41

A fast, safe bash parser library
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

use super::super::*;

impl<'a> Parser<'a> {
    pub(in crate::parser) fn heredoc_body_with_parts(
        &self,
        parts: Vec<HeredocBodyPartNode>,
        span: Span,
        mode: HeredocBodyMode,
        source_backed: bool,
    ) -> HeredocBody {
        HeredocBody {
            mode,
            source_backed,
            parts,
            span,
        }
    }

    pub(in crate::parser) fn heredoc_body_part_from_word_part_node(
        &self,
        part: WordPartNode,
        source_backed: bool,
    ) -> HeredocBodyPartNode {
        let span = part.span;
        let kind = match part.kind {
            WordPart::Literal(text) => HeredocBodyPart::Literal(text),
            WordPart::Variable(name) => HeredocBodyPart::Variable(name),
            WordPart::CommandSubstitution { body, syntax } => {
                HeredocBodyPart::CommandSubstitution { body, syntax }
            }
            WordPart::ArithmeticExpansion {
                expression,
                expression_ast,
                expression_word_ast,
                syntax,
            } => HeredocBodyPart::ArithmeticExpansion {
                expression,
                expression_ast: expression_ast.map(|ast| *ast),
                expression_word_ast: *expression_word_ast,
                syntax,
            },
            WordPart::Parameter(parameter) => HeredocBodyPart::Parameter(parameter),
            part @ (WordPart::ParameterExpansion { .. }
            | WordPart::Length(_)
            | WordPart::ArrayAccess(_)
            | WordPart::ArrayLength(_)
            | WordPart::ArrayIndices(_)
            | WordPart::Substring { .. }
            | WordPart::ArraySlice { .. }
            | WordPart::IndirectExpansion { .. }
            | WordPart::PrefixMatch { .. }
            | WordPart::Transformation { .. }) => {
                match self.parameter_word_part_from_legacy(
                    part,
                    span.start,
                    span.end,
                    source_backed,
                ) {
                    WordPart::Parameter(parameter) => HeredocBodyPart::Parameter(parameter),
                    other => self.literal_heredoc_body_part_from_word_part(other, span),
                }
            }
            other => self.literal_heredoc_body_part_from_word_part(other, span),
        };

        HeredocBodyPartNode::new(kind, span)
    }

    pub(in crate::parser) fn literal_heredoc_body_part_from_word_part(
        &self,
        part: WordPart,
        span: Span,
    ) -> HeredocBodyPart {
        if span.end.offset <= self.input.len() {
            return HeredocBodyPart::Literal(LiteralText::source());
        }

        let mut syntax = String::new();
        self.push_word_part_syntax(&mut syntax, &part, span);
        HeredocBodyPart::Literal(LiteralText::owned(syntax))
    }
}