shuck-semantic 0.0.19

Semantic analysis model for shell scripts with scopes, bindings, and dataflow
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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

use bitflags::bitflags;
use shuck_ast::{Name, Span};

use crate::{DeclarationBuiltin, ReferenceId, ScopeId};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct BindingId(pub(crate) u32);

impl BindingId {
    pub(crate) fn index(self) -> usize {
        self.0 as usize
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Binding {
    pub id: BindingId,
    pub name: Name,
    pub kind: BindingKind,
    pub origin: BindingOrigin,
    pub scope: ScopeId,
    pub span: Span,
    pub references: Vec<ReferenceId>,
    pub attributes: BindingAttributes,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum BindingOrigin {
    Assignment {
        definition_span: Span,
        value: AssignmentValueOrigin,
    },
    LoopVariable {
        definition_span: Span,
        items: LoopValueOrigin,
    },
    ParameterDefaultAssignment {
        definition_span: Span,
    },
    Imported {
        definition_span: Span,
    },
    FunctionDefinition {
        definition_span: Span,
    },
    BuiltinTarget {
        definition_span: Span,
        kind: BuiltinBindingTargetKind,
    },
    ArithmeticAssignment {
        definition_span: Span,
        target_span: Span,
    },
    Declaration {
        definition_span: Span,
    },
    Nameref {
        definition_span: Span,
    },
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AssignmentValueOrigin {
    PlainScalarAccess,
    StaticLiteral,
    ParameterOperator,
    Transformation,
    IndirectExpansion,
    CommandOrProcessSubstitution,
    MixedDynamic,
    ArrayOrCompound,
    Unknown,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum LoopValueOrigin {
    StaticWords,
    ExpandedWords,
    ImplicitArgv,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum BuiltinBindingTargetKind {
    Read,
    Mapfile,
    Printf,
    Getopts,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum BindingKind {
    Assignment,
    ParameterDefaultAssignment,
    AppendAssignment,
    ArrayAssignment,
    Declaration(DeclarationBuiltin),
    FunctionDefinition,
    LoopVariable,
    ReadTarget,
    MapfileTarget,
    PrintfTarget,
    GetoptsTarget,
    ArithmeticAssignment,
    Nameref,
    Imported,
}

pub(crate) fn is_array_like_binding(binding: &Binding) -> bool {
    binding
        .attributes
        .intersects(BindingAttributes::ARRAY | BindingAttributes::ASSOC)
        || matches!(
            binding.kind,
            BindingKind::ArrayAssignment | BindingKind::MapfileTarget
        )
}

bitflags! {
    #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
    pub struct BindingAttributes: u16 {
        const EXPORTED               = 0b0000_0001;
        const READONLY               = 0b0000_0010;
        const LOCAL                  = 0b0000_0100;
        const INTEGER                = 0b0000_1000;
        const ARRAY                  = 0b0001_0000;
        const ASSOC                  = 0b0010_0000;
        const NAMEREF                = 0b0100_0000;
        const LOWERCASE              = 0b1000_0000;
        const UPPERCASE              = 0b0001_0000_0000;
        const DECLARATION_INITIALIZED = 0b0010_0000_0000;
        const IMPORTED_POSSIBLE      = 0b0100_0000_0000;
        const IMPORTED_FUNCTION      = 0b1000_0000_0000;
        const EMPTY_INITIALIZER      = 0b0001_0000_0000_0000;
        const IMPORTED_FILE_ENTRY    = 0b0010_0000_0000_0000;
        const SELF_REFERENTIAL_READ  = 0b0100_0000_0000_0000;
    }
}