292 lines
10 KiB
Rust
292 lines
10 KiB
Rust
//! LScript language support for the Tree-sitter parsing library.
|
|
|
|
use tree_sitter_language::LanguageFn;
|
|
|
|
unsafe extern "C" {
|
|
fn tree_sitter_lscript() -> *const ();
|
|
}
|
|
|
|
/// The Tree-sitter language function for LScript.
|
|
pub const LANGUAGE: LanguageFn = unsafe { LanguageFn::from_raw(tree_sitter_lscript) };
|
|
|
|
/// Generated descriptions of the grammar's named node types.
|
|
pub const NODE_TYPES: &str = include_str!("../../src/node-types.json");
|
|
|
|
/// The default syntax-highlighting query.
|
|
pub const HIGHLIGHTS_QUERY: &str = include_str!("../../queries/highlights.scm");
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
fn parse(source: &str) -> tree_sitter::Tree {
|
|
let mut parser = tree_sitter::Parser::new();
|
|
parser
|
|
.set_language(&super::LANGUAGE.into())
|
|
.expect("generated LScript grammar must load");
|
|
parser
|
|
.parse(source, None)
|
|
.expect("parser must produce a tree")
|
|
}
|
|
|
|
#[test]
|
|
fn loads_and_parses_lscript() {
|
|
let tree = parse("answer :: 42\n");
|
|
assert!(!tree.root_node().has_error());
|
|
}
|
|
|
|
#[test]
|
|
fn exposes_stable_expression_fields_without_precedence_wrappers() {
|
|
let source = "answer := left + right * -value\n";
|
|
let tree = parse(source);
|
|
let declaration = tree.root_node().named_child(0).unwrap();
|
|
let addition = declaration.child_by_field_name("value").unwrap();
|
|
|
|
assert_eq!(addition.kind(), "binary_expression");
|
|
assert_eq!(
|
|
addition
|
|
.child_by_field_name("operator")
|
|
.unwrap()
|
|
.utf8_text(source.as_bytes())
|
|
.unwrap(),
|
|
"+"
|
|
);
|
|
assert_eq!(
|
|
addition.child_by_field_name("left").unwrap().kind(),
|
|
"identifier"
|
|
);
|
|
|
|
let multiplication = addition.child_by_field_name("right").unwrap();
|
|
assert_eq!(multiplication.kind(), "binary_expression");
|
|
let negation = multiplication.child_by_field_name("right").unwrap();
|
|
assert_eq!(negation.kind(), "unary_expression");
|
|
assert_eq!(
|
|
negation.child_by_field_name("operand").unwrap().kind(),
|
|
"identifier"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn exposes_meaningful_type_constructor_fields() {
|
|
let source = "Transform :: []{i32?} -> [str]i32 ! Error\n";
|
|
let tree = parse(source);
|
|
let declaration = tree.root_node().named_child(0).unwrap();
|
|
let definition = declaration.child_by_field_name("value").unwrap();
|
|
let function = definition.named_child(0).unwrap();
|
|
|
|
assert_eq!(function.kind(), "function_type");
|
|
assert_eq!(
|
|
function
|
|
.child_by_field_name("effect")
|
|
.unwrap()
|
|
.utf8_text(source.as_bytes())
|
|
.unwrap(),
|
|
"->"
|
|
);
|
|
assert_eq!(
|
|
function.child_by_field_name("input").unwrap().kind(),
|
|
"array_type"
|
|
);
|
|
let result = function.child_by_field_name("result").unwrap();
|
|
assert_eq!(result.kind(), "result_type");
|
|
assert_eq!(
|
|
result.child_by_field_name("value").unwrap().kind(),
|
|
"map_type"
|
|
);
|
|
assert_eq!(
|
|
result.child_by_field_name("error").unwrap().kind(),
|
|
"identifier"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn exposes_typed_function_headers() {
|
|
let source =
|
|
"named :: @ value: i32 => i32 { value }\nadd :: @ (a: i32, b: i32) { a + b }\n";
|
|
let tree = parse(source);
|
|
assert!(
|
|
!tree.root_node().has_error(),
|
|
"{}",
|
|
tree.root_node().to_sexp()
|
|
);
|
|
|
|
let named = tree.root_node().named_child(0).unwrap();
|
|
let function = named.child_by_field_name("value").unwrap();
|
|
assert_eq!(function.kind(), "function_literal");
|
|
let parameter = function.child_by_field_name("parameter").unwrap();
|
|
assert_eq!(parameter.kind(), "typed_parameter");
|
|
assert_eq!(
|
|
parameter
|
|
.child_by_field_name("pattern")
|
|
.unwrap()
|
|
.utf8_text(source.as_bytes())
|
|
.unwrap(),
|
|
"value"
|
|
);
|
|
assert_eq!(
|
|
function
|
|
.child_by_field_name("effect")
|
|
.unwrap()
|
|
.utf8_text(source.as_bytes())
|
|
.unwrap(),
|
|
"=>"
|
|
);
|
|
assert_eq!(
|
|
function.child_by_field_name("result").unwrap().kind(),
|
|
"primitive_type"
|
|
);
|
|
assert_eq!(
|
|
function.child_by_field_name("body").unwrap().kind(),
|
|
"block"
|
|
);
|
|
|
|
let tuple_declaration = tree.root_node().named_child(1).unwrap();
|
|
let tuple_function = tuple_declaration.child_by_field_name("value").unwrap();
|
|
let tuple_input = tuple_function.child_by_field_name("parameter").unwrap();
|
|
assert_eq!(tuple_input.kind(), "typed_tuple_pattern");
|
|
assert!(tuple_function.child_by_field_name("parameters").is_none());
|
|
assert_eq!(tuple_input.named_child_count(), 2);
|
|
for index in 0..2 {
|
|
assert_eq!(
|
|
tuple_input.named_child(index).unwrap().kind(),
|
|
"typed_tuple_component"
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn distinguishes_whole_argument_annotation_from_tuple_component_annotations() {
|
|
let source = "whole :: @ (left, right): (i32, i32) { left + right }\n\
|
|
components :: @ (left: i32, right: i32) { left + right }\n\
|
|
product :: @ {value}: &{value: i32:} { value }\n";
|
|
let tree = parse(source);
|
|
assert!(
|
|
!tree.root_node().has_error(),
|
|
"{}",
|
|
tree.root_node().to_sexp()
|
|
);
|
|
|
|
let whole = tree.root_node().named_child(0).unwrap();
|
|
let whole_function = whole.child_by_field_name("value").unwrap();
|
|
let whole_input = whole_function.child_by_field_name("parameter").unwrap();
|
|
assert_eq!(whole_input.kind(), "typed_parameter");
|
|
assert_eq!(
|
|
whole_input.child_by_field_name("pattern").unwrap().kind(),
|
|
"tuple_pattern"
|
|
);
|
|
assert_eq!(
|
|
whole_input.child_by_field_name("type").unwrap().kind(),
|
|
"tuple_type"
|
|
);
|
|
|
|
let components = tree.root_node().named_child(1).unwrap();
|
|
let components_function = components.child_by_field_name("value").unwrap();
|
|
let component_input = components_function
|
|
.child_by_field_name("parameter")
|
|
.unwrap();
|
|
assert_eq!(component_input.kind(), "typed_tuple_pattern");
|
|
assert_eq!(component_input.named_child_count(), 2);
|
|
|
|
let product = tree.root_node().named_child(2).unwrap();
|
|
let product_function = product.child_by_field_name("value").unwrap();
|
|
let product_input = product_function.child_by_field_name("parameter").unwrap();
|
|
assert_eq!(product_input.kind(), "typed_parameter");
|
|
assert_eq!(
|
|
product_input.child_by_field_name("pattern").unwrap().kind(),
|
|
"product_pattern"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn exposes_wrappers_and_untyped_inputs() {
|
|
let source = "present: i32?: some 1\n\
|
|
double :: @ value { value * 2 }\n\
|
|
unwrap :: @ result { match result { ok inner => inner; err _ => 0 } }\n";
|
|
let tree = parse(source);
|
|
assert!(
|
|
!tree.root_node().has_error(),
|
|
"{}",
|
|
tree.root_node().to_sexp()
|
|
);
|
|
|
|
let present = tree.root_node().named_child(0).unwrap();
|
|
let wrapped = present.child_by_field_name("value").unwrap();
|
|
assert_eq!(wrapped.kind(), "unary_expression");
|
|
assert_eq!(
|
|
wrapped
|
|
.child_by_field_name("operator")
|
|
.unwrap()
|
|
.utf8_text(source.as_bytes())
|
|
.unwrap(),
|
|
"some"
|
|
);
|
|
|
|
let double = tree.root_node().named_child(1).unwrap();
|
|
let input = double
|
|
.child_by_field_name("value")
|
|
.unwrap()
|
|
.child_by_field_name("parameter")
|
|
.unwrap();
|
|
assert_eq!(input.kind(), "typed_parameter");
|
|
assert!(input.child_by_field_name("type").is_none());
|
|
|
|
let unwrap = tree.root_node().named_child(2).unwrap();
|
|
let function = unwrap.child_by_field_name("value").unwrap();
|
|
let body = function.child_by_field_name("body").unwrap();
|
|
let arm = body.named_child(0).unwrap().named_child(1).unwrap();
|
|
let pattern = arm.child_by_field_name("pattern").unwrap();
|
|
let wrapper = pattern.named_child(0).unwrap();
|
|
assert_eq!(wrapper.kind(), "wrapper_pattern");
|
|
assert_eq!(
|
|
wrapper
|
|
.child_by_field_name("wrapper")
|
|
.unwrap()
|
|
.utf8_text(source.as_bytes())
|
|
.unwrap(),
|
|
"ok"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn rejects_removed_wrapper_forms() {
|
|
for source in [
|
|
"old: i32?: 1->|.some\n",
|
|
"old :: @ value: i32 -> i32 ! str { value! }\n",
|
|
"old :: @ value: str -> i32 ! str { !value }\n",
|
|
"some := 1\n",
|
|
] {
|
|
assert!(parse(source).root_node().has_error(), "accepted {source}");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn rejects_removed_function_literal_forms() {
|
|
for source in [
|
|
"old: i32 -> i32: value@ value\n",
|
|
"old: i32 -> i32:\n@ value: i32 { value }\n",
|
|
"old :: @ (value:i32) { value }\n",
|
|
"old :: @ (value:i32,) { value }\n",
|
|
"old :: @ (\nvalue:i32\n) -> i32 { value }\n",
|
|
] {
|
|
assert!(parse(source).root_node().has_error(), "accepted {source}");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn distinguishes_compact_ranges_floats_and_word_prefixes() {
|
|
let source = "value := (item.value, 0..<limit)->slice\n\
|
|
trailing_dot := 1.\n\
|
|
anchor := value\n\
|
|
android := value\n\
|
|
order: []Item = []\n\
|
|
ready := first\n\
|
|
and second\n\
|
|
or fallback\n";
|
|
let tree = parse(source);
|
|
|
|
assert!(
|
|
!tree.root_node().has_error(),
|
|
"{}",
|
|
tree.root_node().to_sexp()
|
|
);
|
|
}
|
|
}
|