diff --git a/parser/src/ast/block.rs b/parser/src/ast/block.rs index e7cc97d..40f606d 100644 --- a/parser/src/ast/block.rs +++ b/parser/src/ast/block.rs @@ -1,4 +1,4 @@ -use ast::{def::Define, expression::Expression}; +use ast::{define_function::DefineFunction, expression::Expression}; use grammar::Rule; use pest::iterators::Pair; use pest::Span; @@ -11,7 +11,7 @@ pub struct Block<'a> { #[derive(Debug, Clone)] pub enum Inner<'a> { - Define(Define<'a>), + DefineFunction(DefineFunction<'a>), Expression(Expression<'a>), } @@ -23,7 +23,7 @@ impl<'a> From> for Block<'a> { let body = pair .into_inner() .map(|p| match p.as_rule() { - Rule::def => Inner::Define(Define::from(p)), + Rule::def_function => Inner::DefineFunction(DefineFunction::from(p)), Rule::expression => Inner::Expression(Expression::from(p)), _ => unreachable!(), }) @@ -37,9 +37,9 @@ impl<'a> From> for Block<'a> { } impl<'a> Inner<'a> { - fn define(&self) -> Option<&Define<'a>> { + fn define_function(&self) -> Option<&DefineFunction<'a>> { match self { - Inner::Define(ref inner) => Some(&inner), + Inner::DefineFunction(ref inner) => Some(&inner), _ => None, } } diff --git a/parser/src/ast/def/defimpl.rs b/parser/src/ast/def/defimpl.rs deleted file mode 100644 index 84de8df..0000000 --- a/parser/src/ast/def/defimpl.rs +++ /dev/null @@ -1,56 +0,0 @@ -use ast::{argument_name::ArgumentName, expression::Expression, type_name::TypeName}; -use grammar::Rule; -use pest::iterators::Pairs; -use pest::Span; - -#[derive(Debug, Clone)] -pub struct Impl<'a> { - pub span: Span<'a>, - pub name: TypeName<'a>, - pub fields: Vec<(ArgumentName<'a>, Expression<'a>)>, -} - -impl<'a> From> for Impl<'a> { - fn from(mut pairs: Pairs<'a, Rule>) -> Self { - let pair = pairs.next().unwrap(); - let span = pair.clone().into_span(); - let type_name = get_type_name(pairs.clone()); - let fields = get_fields(pairs); - - Impl { - span: span, - name: type_name, - fields: fields, - } - } -} - -impl<'a> Impl<'a> { - pub fn name(&self) -> &str { - &self.name.name - } - - pub fn fields(&self) -> &Vec<(ArgumentName<'a>, Expression<'a>)> { - &self.fields - } -} - -fn get_type_name<'a>(pairs: Pairs<'a, Rule>) -> TypeName { - let pair = pairs - .filter(|p| p.as_rule() == Rule::type_name) - .next() - .unwrap(); - TypeName::from(pair) -} - -fn get_fields<'a>(pairs: Pairs<'a, Rule>) -> Vec<(ArgumentName<'a>, Expression<'a>)> { - pairs - .filter(|p| p.as_rule() == Rule::argument_pair) - .map(|p| { - let mut pairs = p.into_inner(); - let arg_name = pairs.next().unwrap(); - let value = pairs.next().unwrap(); - (ArgumentName::from(arg_name), Expression::from(value)) - }) - .collect() -} diff --git a/parser/src/ast/def/deftrait.rs b/parser/src/ast/def/deftrait.rs deleted file mode 100644 index 9412e4c..0000000 --- a/parser/src/ast/def/deftrait.rs +++ /dev/null @@ -1,56 +0,0 @@ -use ast::{argument_name::ArgumentName, expression::Expression, type_name::TypeName}; -use grammar::Rule; -use pest::iterators::Pairs; -use pest::Span; - -#[derive(Debug, Clone)] -pub struct Trait<'a> { - pub span: Span<'a>, - pub name: TypeName<'a>, - pub fields: Vec<(ArgumentName<'a>, Expression<'a>)>, -} - -impl<'a> From> for Trait<'a> { - fn from(mut pairs: Pairs<'a, Rule>) -> Self { - let pair = pairs.next().unwrap(); - let span = pair.clone().into_span(); - let type_name = get_type_name(pairs.clone()); - let fields = get_fields(pairs); - - Trait { - span: span, - name: type_name, - fields: fields, - } - } -} - -impl<'a> Trait<'a> { - pub fn name(&self) -> &str { - &self.name.name - } - - pub fn fields(&self) -> &Vec<(ArgumentName<'a>, Expression<'a>)> { - &self.fields - } -} - -fn get_type_name<'a>(pairs: Pairs<'a, Rule>) -> TypeName<'a> { - let pair = pairs - .filter(|p| p.as_rule() == Rule::type_name) - .next() - .unwrap(); - TypeName::from(pair) -} - -fn get_fields<'a>(pairs: Pairs<'a, Rule>) -> Vec<(ArgumentName<'a>, Expression<'a>)> { - pairs - .filter(|p| p.as_rule() == Rule::argument_pair) - .map(|p| { - let mut pairs = p.into_inner(); - let arg_name = pairs.next().unwrap(); - let value = pairs.next().unwrap(); - (ArgumentName::from(arg_name), Expression::from(value)) - }) - .collect() -} diff --git a/parser/src/ast/def/deftype.rs b/parser/src/ast/def/deftype.rs deleted file mode 100644 index 93cbe7e..0000000 --- a/parser/src/ast/def/deftype.rs +++ /dev/null @@ -1,56 +0,0 @@ -use ast::{argument_name::ArgumentName, expression::Expression, type_name::TypeName}; -use grammar::Rule; -use pest::iterators::Pairs; -use pest::Span; - -#[derive(Debug, Clone)] -pub struct Type<'a> { - pub span: Span<'a>, - pub name: TypeName<'a>, - pub fields: Vec<(ArgumentName<'a>, Expression<'a>)>, -} - -impl<'a> From> for Type<'a> { - fn from(mut pairs: Pairs<'a, Rule>) -> Self { - let pair = pairs.next().unwrap(); - let span = pair.clone().into_span(); - let type_name = get_type_name(pairs.clone()); - let fields = get_fields(pairs); - - Type { - span: span, - name: type_name, - fields: fields, - } - } -} - -impl<'a> Type<'a> { - pub fn name(&self) -> &str { - &self.name.name - } - - pub fn fields(&self) -> &Vec<(ArgumentName<'a>, Expression<'a>)> { - &self.fields - } -} - -fn get_type_name<'a>(pairs: Pairs<'a, Rule>) -> TypeName { - let pair = pairs - .filter(|p| p.as_rule() == Rule::type_name) - .next() - .unwrap(); - TypeName::from(pair) -} - -fn get_fields<'a>(pairs: Pairs<'a, Rule>) -> Vec<(ArgumentName<'a>, Expression<'a>)> { - pairs - .filter(|p| p.as_rule() == Rule::argument_pair) - .map(|p| { - let mut pairs = p.into_inner(); - let arg_name = pairs.next().unwrap(); - let value = pairs.next().unwrap(); - (ArgumentName::from(arg_name), Expression::from(value)) - }) - .collect() -} diff --git a/parser/src/ast/def/mod.rs b/parser/src/ast/def/mod.rs deleted file mode 100644 index f92bb85..0000000 --- a/parser/src/ast/def/mod.rs +++ /dev/null @@ -1,316 +0,0 @@ -mod deffunction; -mod defimpl; -mod deftrait; -mod deftype; - -use self::deffunction::Function; -use self::defimpl::Impl; -use self::deftrait::Trait; -use self::deftype::Type; -use grammar::Rule; -use pest::iterators::Pair; -use pest::Span; - -#[derive(Debug, Clone)] -pub struct Define<'a> { - pub span: Span<'a>, - pub inner: DefineWhat<'a>, -} - -#[derive(Debug, Clone)] -pub enum DefineWhat<'a> { - Type(Type<'a>), - Trait(Trait<'a>), - Impl(Impl<'a>), - Function(Function<'a>), -} - -impl<'a> Define<'a> { - pub fn is_type(&self) -> bool { - match self.inner { - DefineWhat::Type(_) => true, - _ => false, - } - } - - pub fn is_trait(&self) -> bool { - match self.inner { - DefineWhat::Trait(_) => true, - _ => false, - } - } - - pub fn is_impl(&self) -> bool { - match self.inner { - DefineWhat::Impl(_) => true, - _ => false, - } - } - - pub fn is_function(&self) -> bool { - match self.inner { - DefineWhat::Function(_) => true, - _ => false, - } - } - - pub fn type_(&self) -> Option<&Type<'a>> { - match self.inner { - DefineWhat::Type(ref inner) => Some(&inner), - _ => None, - } - } - - pub fn trait_(&self) -> Option<&Trait<'a>> { - match self.inner { - DefineWhat::Trait(ref inner) => Some(&inner), - _ => None, - } - } - - pub fn impl_(&self) -> Option<&Impl<'a>> { - match self.inner { - DefineWhat::Impl(ref inner) => Some(&inner), - _ => None, - } - } - - pub fn function(&self) -> Option<&Function<'a>> { - match self.inner { - DefineWhat::Function(ref inner) => Some(&inner), - _ => None, - } - } -} - -impl<'a> From> for Define<'a> { - fn from(pair: Pair<'a, Rule>) -> Self { - assert_eq!(pair.as_rule(), Rule::def); - - let span = pair.clone().into_span(); - let pairs = pair.into_inner(); - let first_rule = pairs.clone().next().unwrap().as_rule(); - - let inner = match first_rule { - Rule::def_impl => DefineWhat::Impl(Impl::from(pairs)), - Rule::def_private => DefineWhat::Function(Function::from(pairs)), - Rule::def_public => DefineWhat::Function(Function::from(pairs)), - Rule::def_static => DefineWhat::Function(Function::from(pairs)), - Rule::def_trait => DefineWhat::Trait(Trait::from(pairs)), - Rule::def_type => DefineWhat::Type(Type::from(pairs)), - _ => unreachable!(), - }; - - Define { - span: span, - inner: inner, - } - } -} - -#[cfg(test)] -mod test { - use super::deffunction::FunctionType; - use super::*; - use grammar::parse_str; - - #[test] - fn def_static() { - let result = parse_str("defstatic marty", Rule::file); - let def = Define::from(result); - let fun = def.function().unwrap(); - assert_eq!(fun.name(), "marty"); - assert!(fun.is_static()); - assert!(fun.fields().is_empty()); - } - - #[test] - fn def_static_with_type() { - let result = parse_str("defstatic marty", Rule::def_test); - let def = Define::from(result); - let fun = def.function().unwrap(); - assert_eq!(fun.name(), "marty"); - assert!(fun.is_static()); - assert!(fun.fields().is_empty()); - assert_eq!(fun.return_type().unwrap().name(), "McFly"); - } - - #[test] - fn def_static_with_type_and_arguments() { - let result = parse_str( - "defstatic marty date_of_birth: Date", - Rule::def_test, - ); - let def = Define::from(result); - let fun = def.function().unwrap(); - assert_eq!(fun.name(), "marty"); - assert!(fun.is_static()); - assert_eq!(fun.return_type().unwrap().name(), "McFly"); - let (ref arg_name, ref arg_value) = fun.fields()[0]; - assert_eq!(arg_name.name(), "date_of_birth"); - assert_eq!( - arg_value.literal().unwrap().type_name().unwrap().name(), - "Date" - ); - } - - #[test] - fn def_private() { - let result = parse_str("defp marty", Rule::def_test); - let def = Define::from(result); - let fun = def.function().unwrap(); - assert_eq!(fun.name(), "marty"); - assert!(fun.is_private()); - assert!(fun.return_type().is_none()); - assert!(fun.fields().is_empty()); - } - - #[test] - fn def_private_with_type() { - let result = parse_str("defp marty", Rule::def_test); - let def = Define::from(result); - let fun = def.function().unwrap(); - assert_eq!(fun.name(), "marty"); - assert!(fun.is_private()); - assert_eq!(fun.return_type().unwrap().name(), "McFly"); - assert!(fun.fields().is_empty()); - } - - #[test] - fn def_private_with_type_and_arguments() { - let result = parse_str("defp marty date_of_birth: Date", Rule::def_test); - let def = Define::from(result); - let fun = def.function().unwrap(); - assert_eq!(fun.name(), "marty"); - assert!(fun.is_private()); - assert_eq!(fun.return_type().unwrap().name(), "McFly"); - let (ref arg_name, ref arg_value) = fun.fields()[0]; - assert_eq!(arg_name.name(), "date_of_birth"); - assert_eq!( - arg_value.literal().unwrap().type_name().unwrap().name(), - "Date" - ); - } - - #[test] - fn def_public() { - let result = parse_str("def marty", Rule::def_test); - let def = Define::from(result); - let fun = def.function().unwrap(); - assert_eq!(fun.name(), "marty"); - assert!(fun.is_public()); - assert!(fun.return_type().is_none()); - assert!(fun.fields().is_empty()) - } - - #[test] - fn def_public_with_type() { - let result = parse_str("def marty", Rule::def_test); - let def = Define::from(result); - let fun = def.function().unwrap(); - assert_eq!(fun.name(), "marty"); - assert!(fun.is_public()); - assert_eq!(fun.return_type().unwrap().name(), "McFly"); - assert!(fun.fields().is_empty()) - } - - #[test] - fn def_public_with_type_and_arguments() { - let result = parse_str("def marty date_of_birth: Date", Rule::def_test); - let def = Define::from(result); - let fun = def.function().unwrap(); - assert_eq!(fun.name(), "marty"); - assert!(fun.is_public()); - assert_eq!(fun.return_type().unwrap().name(), "McFly"); - let (ref arg_name, ref arg_value) = fun.fields()[0]; - assert_eq!(arg_name.name(), "date_of_birth"); - assert_eq!( - arg_value.literal().unwrap().type_name().unwrap().name(), - "Date" - ); - } - - #[test] - fn def_type_with_no_fields() { - let result = parse_str("deftype Delorean", Rule::def_test); - let def = Define::from(result); - let ty = def.type_().unwrap(); - assert_eq!(ty.name(), "Delorean"); - assert!(ty.fields().is_empty()); - } - - #[test] - fn def_type_with_fields() { - let result = parse_str("deftype Delorean speed: Integer", Rule::def_test); - let def = Define::from(result); - let ty = def.type_().unwrap(); - assert_eq!(ty.name(), "Delorean"); - let (ref arg_name, ref arg_value) = ty.fields()[0]; - assert_eq!(arg_name.name(), "speed"); - assert_eq!( - arg_value.literal().unwrap().type_name().unwrap().name(), - "Integer" - ); - } - - #[test] - fn def_trait_with_no_fields() { - let result = parse_str("deftrait TimeMachine", Rule::def_test); - let def = Define::from(result); - let tr = def.trait_().unwrap(); - assert_eq!(tr.name(), "TimeMachine"); - assert!(tr.fields().is_empty()); - } - - #[test] - fn def_trait_with_fields() { - let result = parse_str("deftrait TimeMachine year: Integer", Rule::def_test); - let def = Define::from(result); - let tr = def.trait_().unwrap(); - assert_eq!(tr.name(), "TimeMachine"); - let (ref arg_name, ref arg_value) = tr.fields()[0]; - assert_eq!(arg_name.name(), "year"); - assert_eq!( - arg_value.literal().unwrap().type_name().unwrap().name(), - "Integer" - ); - } - - #[test] - fn def_impl_with_fields() { - let result = parse_str("defimpl TimeMachine for: Delorean", Rule::def_test); - let def = Define::from(result); - let im = def.impl_().unwrap(); - assert_eq!(im.name(), "TimeMachine"); - let (ref arg_name, ref arg_value) = im.fields()[0]; - assert_eq!(arg_name.name(), "for"); - assert_eq!( - arg_value.literal().unwrap().type_name().unwrap().name(), - "Delorean" - ); - } - - #[test] - fn def_type_with_body() { - let result = parse_str( - "deftype Delorean speed: Integer, as: -> - defstatic new as: -> - Delorean { speed: 0 } - end - end", - Rule::def_test, - ); - let def = Define::from(result); - let ty = def.type_().unwrap(); - assert_eq!(ty.name(), "Delorean"); - let (ref arg_name, ref arg_value) = ty.fields()[0]; - assert_eq!(arg_name.name(), "speed"); - assert_eq!( - arg_value.literal().unwrap().type_name().unwrap().name(), - "Integer" - ); - let (ref arg_name, ref arg_value) = ty.fields()[1]; - assert_eq!(arg_name.name(), "as"); - assert!(arg_value.is_block()); - } -} diff --git a/parser/src/ast/def/deffunction.rs b/parser/src/ast/define_function.rs similarity index 81% rename from parser/src/ast/def/deffunction.rs rename to parser/src/ast/define_function.rs index 2a0cf35..1a4eae1 100644 --- a/parser/src/ast/def/deffunction.rs +++ b/parser/src/ast/define_function.rs @@ -4,12 +4,12 @@ use pest::iterators::{Pair, Pairs}; use pest::Span; #[derive(Debug, Clone)] -pub struct Function<'a> { - pub span: Span<'a>, - pub name: FunctionName<'a>, - pub return_type: Option>, - pub fn_type: FunctionType, - pub fields: Vec<(ArgumentName<'a>, Expression<'a>)>, +pub struct DefineFunction<'a> { + span: Span<'a>, + fn_name: FunctionName<'a>, + rt_type: Option>, + fn_type: FunctionType, + fields: Vec<(ArgumentName<'a>, Expression<'a>)>, } #[derive(Debug, PartialEq, Clone)] @@ -25,13 +25,13 @@ pub struct FunctionName<'a> { pub name: String, } -impl<'a> Function<'a> { +impl<'a> DefineFunction<'a> { pub fn name(&self) -> &str { - &self.name.name + &self.fn_name.name } pub fn return_type(&self) -> Option<&TypeName<'a>> { - match self.return_type { + match self.rt_type { Some(ref type_name) => Some(&type_name), None => None, } @@ -63,20 +63,22 @@ impl<'a> Function<'a> { } } -impl<'a> From> for Function<'a> { - fn from(mut pairs: Pairs<'a, Rule>) -> Self { - let pair = pairs.next().unwrap(); +impl<'a> From> for DefineFunction<'a> { + fn from(pair: Pair<'a, Rule>) -> Self { + assert_eq!(pair.as_rule(), Rule::def_function); let span = pair.clone().into_span(); - let fn_type = FunctionType::from(pair); + let mut pairs = pair.into_inner(); + + let fn_type = FunctionType::from(pairs.next().unwrap()); let rt_type = get_return_type(pairs.clone()); let name = get_name(pairs.clone()); let arguments = get_arguments(pairs); - Function { + DefineFunction { span: span, - name: name, + fn_name: name, fn_type: fn_type, - return_type: rt_type, + rt_type: rt_type, fields: arguments, } } diff --git a/parser/src/ast/define_module.rs b/parser/src/ast/define_module.rs new file mode 100644 index 0000000..bf85373 --- /dev/null +++ b/parser/src/ast/define_module.rs @@ -0,0 +1,61 @@ +use ast::{argument_name::ArgumentName, expression::Expression, type_name::TypeName}; +use grammar::Rule; +use pest::iterators::{Pair, Pairs}; +use pest::Span; + +#[derive(Debug, Clone)] +pub struct DefineModule<'a> { + span: Span<'a>, + ty_name: TypeName<'a>, + mod_type: ModuleType, + fields: Vec<(ArgumentName<'a>, Expression<'a>)>, +} + +#[derive(Debug, PartialEq, Clone)] +pub enum ModuleType { + Implementation, + Trait, + Type, +} + +impl<'a> From> for ModuleType { + fn from(pair: Pair<'a, Rule>) -> Self { + match pair.as_rule() { + Rule::def_impl => ModuleType::Implementation, + Rule::def_trait => ModuleType::Trait, + Rule::def_type => ModuleType::Type, + _ => unreachable!(), + } + } +} + +impl<'a> From> for DefineModule<'a> { + fn from(pair: Pair<'a, Rule>) -> Self { + assert_eq!(pair.as_rule(), Rule::def_module); + + let span = pair.clone().into_span(); + let mut pairs = pair.into_inner(); + let mod_type = ModuleType::from(pairs.next().unwrap()); + let type_name = TypeName::from(pairs.next().unwrap()); + let fields = get_arguments(pairs); + + DefineModule { + span: span, + ty_name: type_name, + mod_type: mod_type, + fields: fields, + } + } +} + +fn get_arguments<'a>(pairs: Pairs<'a, Rule>) -> Vec<(ArgumentName<'a>, Expression<'a>)> { + pairs + .filter(|p| p.as_rule() == Rule::argument_pair) + .map(|p| { + let mut pairs = p.into_inner(); + let arg_name = pairs.next().unwrap(); + let value = pairs.next().unwrap(); + (ArgumentName::from(arg_name), Expression::from(value)) + }) + .collect() +} diff --git a/parser/src/ast/file.rs b/parser/src/ast/file.rs index 5ff96fc..e6e198a 100644 --- a/parser/src/ast/file.rs +++ b/parser/src/ast/file.rs @@ -1,4 +1,4 @@ -use ast::def::Define; +use ast::define_module::DefineModule; use grammar::Rule; use pest::iterators::Pair; use pest::Span; @@ -6,7 +6,7 @@ use pest::Span; #[derive(Debug, Clone)] pub struct File<'a> { span: Span<'a>, - children: Vec>, + children: Vec>, } impl<'a> From> for File<'a> { @@ -14,7 +14,7 @@ impl<'a> From> for File<'a> { assert_eq!(pair.as_rule(), Rule::file); let span = pair.clone().into_span(); - let children = pair.into_inner().map(|p| Define::from(p)).collect(); + let children = pair.into_inner().map(|p| DefineModule::from(p)).collect(); File { span: span, diff --git a/parser/src/ast/mod.rs b/parser/src/ast/mod.rs index 0aa05e0..c7651a2 100644 --- a/parser/src/ast/mod.rs +++ b/parser/src/ast/mod.rs @@ -5,7 +5,8 @@ mod block; mod boolean; mod call; mod constructor; -mod def; +mod define_function; +mod define_module; mod expression; mod file; mod float; @@ -27,7 +28,8 @@ pub use self::{ boolean::Boolean, call::{Call, Message, Receiver}, constructor::Constructor, - def::Define, + define_function::DefineFunction, + define_module::DefineModule, file::File, float::Float, infix::Infix, diff --git a/parser/src/grammar.pest b/parser/src/grammar.pest index a3a0c55..e157d1d 100644 --- a/parser/src/grammar.pest +++ b/parser/src/grammar.pest @@ -13,7 +13,7 @@ // ## INPUTS // #################################### -file = _{ soi ~ def* ~ eoi } +file = _{ soi ~ def_module* ~ eoi } // #################################### @@ -72,7 +72,7 @@ block_test = _{ soi ~ block ~ eoi } block = @{ block_stabby ~ whitespace+ ~ (block_end | block_body) } block_stabby = _{ "->" } block_body = _{ block_expression ~ (padded_newline+ ~ block_expression)* ~ whitespace* ~ block_end } -block_expression = _{ def | expression } +block_expression = _{ def_function | expression } block_end = _{ "end" ~ !identifier_tail } @@ -128,7 +128,6 @@ argument_keyword = ${ identifier ~ ":" } // ## DEFINES // #################################### -def_test = _{ soi ~ def ~ eoi } def_fn_keyword = _{ def_static | def_private | def_public } def_type_keyword = _{ def_trait | def_type | def_impl } def_keyword = _{ def_type_keyword | def_fn_keyword } @@ -141,9 +140,10 @@ def_impl = { "defimpl" } def_name = ${ identifier ~ def_predicate? } def_predicate = { "?" } def_return_type = { "<" ~ type_name ~ ">" } -def_fn = _{ def_fn_keyword ~ def_return_type? ~ def_name ~ argument_list? } -def_ty = _{ def_type_keyword ~ type_name ~ argument_list? } -def = !{ def_ty | def_fn } +def_function = !{ def_fn_keyword ~ def_return_type? ~ def_name ~ argument_list? } +def_module = !{ def_type_keyword ~ type_name ~ argument_list? } +def_function_test = _{ soi ~ def_function ~ eoi } +def_module_test = _{ soi ~ def_module ~ eoi } // #################################### diff --git a/parser/src/grammar/test/def.rs b/parser/src/grammar/test/def_function.rs similarity index 70% rename from parser/src/grammar/test/def.rs rename to parser/src/grammar/test/def_function.rs index c98d598..3c727df 100644 --- a/parser/src/grammar/test/def.rs +++ b/parser/src/grammar/test/def_function.rs @@ -5,9 +5,9 @@ fn define_no_args() { parses_to!( parser: Grammar, input: "def name", - rule: Rule::def_test, + rule: Rule::def_function_test, tokens: [ - def(0, 8, [ + def_function(0, 8, [ def_public(0, 3), def_name(4, 8, [identifier(4, 8)]) ]) @@ -20,9 +20,9 @@ fn define_return_type_no_args() { parses_to!( parser: Grammar, input: "def name", - rule: Rule::def_test, + rule: Rule::def_function_test, tokens: [ - def(0, 16, [ + def_function(0, 16, [ def_public(0, 3), def_return_type(4, 11, [ type_name(5, 10) @@ -38,9 +38,9 @@ fn define_return_type_with_args() { parses_to!( parser: Grammar, input: r#"def new_character name: String, as: 123"#, - rule: Rule::def_test, + rule: Rule::def_function_test, tokens: [ - def(0, 51, [ + def_function(0, 51, [ def_public(0, 3), def_return_type(4, 15, [ type_name(5, 14) @@ -72,9 +72,9 @@ fn define_with_args() { parses_to!( parser: Grammar, input: r#"def new_character name: String, as: 123"#, - rule: Rule::def_test, + rule: Rule::def_function_test, tokens: [ - def(0, 39, [ + def_function(0, 39, [ def_public(0, 3), def_name(4, 17, [identifier(4, 17)]), argument_pair(18, 30, [ @@ -103,9 +103,9 @@ fn define_with_body() { parses_to!( parser: Grammar, input: r#"defp marty as: -> 123 end"#, - rule: Rule::def_test, + rule: Rule::def_function_test, tokens: [ - def(0, 25, [ + def_function(0, 25, [ def_private(0, 4), def_name(5, 10, [identifier(5, 10)]), argument_pair(11, 25, [ @@ -132,9 +132,9 @@ fn define_constructor() { input: "defstatic new as: -> Delorean { speed: 0 } end", - rule: Rule::def_test, + rule: Rule::def_function_test, tokens: [ - def(0, 91, [ + def_function(0, 91, [ def_static(0, 9), def_return_type(10, 20, [type_name(11, 19)]), def_name(21, 24, [identifier(21, 24)]), @@ -170,9 +170,9 @@ fn define_function_with_predicate() { parses_to!( parser: Grammar, input: "defp name?", - rule: Rule::def_test, + rule: Rule::def_function_test, tokens: [ - def(0, 10, [ + def_function(0, 10, [ def_private(0, 4), def_name(5, 10, [ identifier(5, 9), @@ -182,69 +182,3 @@ fn define_function_with_predicate() { ] ) } - -#[test] -fn def_trait_type_only() { - parses_to!( - parser: Grammar, - input: r#"deftrait Integer"#, - rule: Rule::def_test, - tokens: [ - def(0, 16, [ - def_trait(0, 8), - type_name(9, 16) - ]) - ] - ) -} - -#[test] -fn def_trait_with_args() { - parses_to!( - parser: Grammar, - input: r#"deftrait Integer requires: [Addition, BitwiseAnd]"#, - rule: Rule::def_test, - tokens: [ - def(0, 49, [ - def_trait(0, 8), - type_name(9, 16), - argument_pair(17, 49, [ - argument_keyword(17, 26, [ - identifier(17, 25) - ]), - expression(27, 49, [ - literal(27, 49, [ - array(27, 49, [ - expression(28, 36, [literal(28, 36, [type_name(28, 36)])]), - expression(38, 48, [literal(38, 48, [type_name(38, 48)])]) - ]) - ]) - ]) - ]) - ]) - ] - ) -} - -#[test] -fn def_trait_with_body() { - parses_to!( - parser: Grammar, - input: r#"deftrait Result as: -> end"#, - rule: Rule::def_test, - tokens: [ - def(0, 26, [ - def_trait(0, 8), - type_name(9, 15), - argument_pair(16, 26, [ - argument_keyword(16, 19, [ - identifier(16, 18) - ]), - expression(20, 26, [ - block(20, 26) - ]) - ]) - ]) - ] - ) -} diff --git a/parser/src/grammar/test/def_module.rs b/parser/src/grammar/test/def_module.rs new file mode 100644 index 0000000..6bd66c3 --- /dev/null +++ b/parser/src/grammar/test/def_module.rs @@ -0,0 +1,67 @@ +use grammar::{Grammar, Rule}; + +#[test] +fn def_trait_type_only() { + parses_to!( + parser: Grammar, + input: r#"deftrait Integer"#, + rule: Rule::def_module_test, + tokens: [ + def_module(0, 16, [ + def_trait(0, 8), + type_name(9, 16) + ]) + ] + ) +} + +#[test] +fn def_trait_with_args() { + parses_to!( + parser: Grammar, + input: r#"deftrait Integer requires: [Addition, BitwiseAnd]"#, + rule: Rule::def_module_test, + tokens: [ + def_module(0, 49, [ + def_trait(0, 8), + type_name(9, 16), + argument_pair(17, 49, [ + argument_keyword(17, 26, [ + identifier(17, 25) + ]), + expression(27, 49, [ + literal(27, 49, [ + array(27, 49, [ + expression(28, 36, [literal(28, 36, [type_name(28, 36)])]), + expression(38, 48, [literal(38, 48, [type_name(38, 48)])]) + ]) + ]) + ]) + ]) + ]) + ] + ) +} + +#[test] +fn def_trait_with_body() { + parses_to!( + parser: Grammar, + input: r#"deftrait Result as: -> end"#, + rule: Rule::def_module_test, + tokens: [ + def_module(0, 26, [ + def_trait(0, 8), + type_name(9, 15), + argument_pair(16, 26, [ + argument_keyword(16, 19, [ + identifier(16, 18) + ]), + expression(20, 26, [ + block(20, 26) + ]) + ]) + ]) + ] + ) +} diff --git a/parser/src/grammar/test/file.rs b/parser/src/grammar/test/file.rs index 1dadd24..709b34b 100644 --- a/parser/src/grammar/test/file.rs +++ b/parser/src/grammar/test/file.rs @@ -11,7 +11,7 @@ fn multi_def_with_args() { ", rule: Rule::file, tokens: [ - def(17, 66, [ + def_module(17, 66, [ def_type(17, 24), type_name(25, 33), argument_pair(34, 48, [ @@ -23,7 +23,7 @@ fn multi_def_with_args() { ]) ]) ]), - def(66, 115, [ + def_module(66, 115, [ def_impl(66, 73), type_name(74, 85), argument_pair(86, 99, [ @@ -50,11 +50,11 @@ fn multi_def_no_args() { ", rule: Rule::file, tokens: [ - def(17, 51, [ + def_module(17, 51, [ def_type(17, 24), type_name(25, 33), ]), - def(51, 86, [ + def_module(51, 86, [ def_impl(51, 58), type_name(59, 70) ]) diff --git a/parser/src/grammar/test/mod.rs b/parser/src/grammar/test/mod.rs index 79f6549..0f59cae 100644 --- a/parser/src/grammar/test/mod.rs +++ b/parser/src/grammar/test/mod.rs @@ -3,7 +3,8 @@ mod binary; mod block; mod call; mod comment; -mod def; +mod def_function; +mod def_module; mod file; mod float; mod identifier;