hush 0.1.4

Hush is a unix shell scripting language based on the Lua programming language
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
138
139
140
141
142
143
144
145
146
147
148
149
150
151

mod fmt;

use super::{Symbol, SourcePos};
pub use fmt::ErrorsDisplayContext;


/// The kind of a semantic error.
#[derive(Debug)]
pub enum ErrorKind {
	/// Variable usage before variable declaration.
	UndeclaredVariable(Symbol),
	/// Variable declared with the same name twice in the same scope.
	/// Includes function parameters.
	DuplicateVariable(Symbol),
	/// Duplicate keys in dict literal.
	DuplicateKey(Symbol),
	/// Return statement outside function.
	ReturnOutsideFunction,
	/// Self keyword outside function.
	SelfOutsideFunction,
	/// Try operator outside function.
	TryOutsideFunction,
	/// Break statement outside loop.
	BreakOutsideLoop,
	/// Invalid assignment l-value.
	InvalidAssignment,
	/// Built-in command used in async context.
	/// Async contexts include pipes, redirections and capture or async blocks.
	AsyncBuiltin,
}


/// A semantic error.
#[derive(Debug)]
pub struct Error {
	pub kind: ErrorKind,
	pub pos: SourcePos,
}


impl Error {
	/// Variable usage before variable declaration.
	pub fn undeclared_variable(symbol: Symbol, pos: SourcePos) -> Self {
		Self {
			kind: ErrorKind::UndeclaredVariable(symbol),
			pos
		}
	}


	/// Variable declared with the same name twice in the same scope.
	/// Includes function parameters.
	pub fn duplicate_variable(symbol: Symbol, pos: SourcePos) -> Self {
		Self {
			kind: ErrorKind::DuplicateVariable(symbol),
			pos
		}
	}


	/// Duplicate keys in dict literal.
	pub fn duplicate_key(symbol: Symbol, pos: SourcePos) -> Self {
		Self {
			kind: ErrorKind::DuplicateKey(symbol),
			pos
		}
	}


	/// Return statement outside function.
	pub fn return_outside_function(pos: SourcePos) -> Self {
		Self {
			kind: ErrorKind::ReturnOutsideFunction,
			pos
		}
	}


	/// Self keyword outside function.
	pub fn self_outside_function(pos: SourcePos) -> Self {
		Self {
			kind: ErrorKind::SelfOutsideFunction,
			pos
		}
	}


	/// Try operator outside function.
	pub fn try_outside_function(pos: SourcePos) -> Self {
		Self {
			kind: ErrorKind::TryOutsideFunction,
			pos
		}
	}


	/// Break statement outside loop.
	pub fn break_outside_loop(pos: SourcePos) -> Self {
		Self {
			kind: ErrorKind::BreakOutsideLoop,
			pos
		}
	}


	/// Invalid assignment l-value.
	pub fn invalid_assignment(pos: SourcePos) -> Self {
		Self {
			kind: ErrorKind::InvalidAssignment,
			pos
		}
	}


	/// Built-in command used in async context.
	/// Async contexts include pipes redirections and capture or async blocks.
	pub fn async_builtin(pos: SourcePos) -> Self {
		Self {
			kind: ErrorKind::AsyncBuiltin,
			pos
		}
	}
}


/// A collection of semantic errors.
#[derive(Debug, Default)]
pub struct Errors(pub Vec<Error>);


impl IntoIterator for Errors {
	type Item = Error;
	type IntoIter = std::vec::IntoIter<Error>;

	fn into_iter(self) -> Self::IntoIter {
		self.0.into_iter()
	}
}


impl Extend<Error> for Errors {
	fn extend<T>(&mut self, iter: T)
	where
		T : IntoIterator<Item = Error>,
	{
		self.0.extend(iter)
	}
}


impl std::error::Error for Errors { }