hush 0.1.1

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

use gc::{Finalize, Trace};

use crate::fmt;

use super::{
	CallContext,
	RustFun,
	NativeFun,
	Panic,
	Value,
	Type,
	Error,
};


inventory::submit! { RustFun::from(Typecheck) }
inventory::submit! { RustFun::from(TryTypecheck) }


/// A typecheck result.
enum TypeChecked {
	Valid(Value),
	Invalid {
		value: Value,
		expected_type: Type,
	}
}


#[derive(Trace, Finalize)]
struct Typecheck;


impl Typecheck {
	fn typecheck(context: &CallContext) -> Result<TypeChecked, Panic> {
		match context.args() {
			[ value, Value::String(expected) ] => {
				let expected_type = Type
					::parse(&expected)
					.ok_or_else(
						|| Panic::value_error(
							Value::String(expected.copy()),
							"valid type",
							context.pos.copy()
						)
					)?;

				let value = value.copy();

				Ok(
					if value.get_type() == expected_type {
						TypeChecked::Valid(value)
					}
					else {
						TypeChecked::Invalid { value, expected_type }
					}
				)
			}

			[ _, other ] => Err(Panic::type_error(other.copy(), "string", context.pos.copy())),
			args @ [] | args @ [_] | args @ [_, _, ..] => Err(
				Panic::invalid_args(args.len() as u32, 2, context.pos.copy())
			),
		}
	}
}


impl NativeFun for Typecheck {
	fn name(&self) -> &'static str { "std.typecheck" }

	fn call(&self, context: CallContext) -> Result<Value, Panic> {
		match Self::typecheck(&context)? {
			// No problem in returning the value here, as typecheck errors are signaled as panics.
			TypeChecked::Valid(value) => Ok(value),

			TypeChecked::Invalid { value, expected_type } => Err(
				Panic::type_error(
					value,
					expected_type.display(),
					context.pos
				)
			),
		}
	}
}


#[derive(Trace, Finalize)]
struct TryTypecheck;


impl NativeFun for TryTypecheck {
	fn name(&self) -> &'static str { "std.try_typecheck" }

	fn call(&self, context: CallContext) -> Result<Value, Panic> {
		match Typecheck::typecheck(&context)? {
			// We can't return the value here, because it would be impossible to distinguish a
			// typechecked error value from a type error.
			TypeChecked::Valid(_) => Ok(Value::default()),

			TypeChecked::Invalid { value, expected_type } => {
				let description = format!(
					"type error: expected {}, got {} ({})",
					expected_type,
					value.get_type(),
					fmt::Show(&value, context.interner()),
				);

				Ok(
					Error
						::new(description.into(), value)
						.into()
				)
			}
		}
	}
}