652 lines
18 KiB
Rust
652 lines
18 KiB
Rust
use super::tokens::*;
|
||
|
||
pub(crate) fn function_name(input: &str) -> Option<(&str, &str)>
|
||
{
|
||
let (identifier, remaining_input) = identifier(input)?;
|
||
|
||
if is_keyword(identifier)
|
||
{
|
||
return None;
|
||
}
|
||
|
||
let mut characters = identifier.chars();
|
||
|
||
while let Some(character) = characters.next()
|
||
{
|
||
match character
|
||
{
|
||
'_' => continue,
|
||
_ if character.is_ascii_lowercase() => return Some((identifier, remaining_input)),
|
||
_ => return None,
|
||
}
|
||
}
|
||
|
||
None
|
||
}
|
||
|
||
fn variable_name(input: &str) -> Option<(&str, &str)>
|
||
{
|
||
let (identifier, remaining_input) = identifier(input)?;
|
||
|
||
let mut characters = identifier.chars();
|
||
|
||
while let Some(character) = characters.next()
|
||
{
|
||
match character
|
||
{
|
||
'_' => continue,
|
||
_ if character.is_ascii_uppercase() => return Some((identifier, remaining_input)),
|
||
_ => return None,
|
||
}
|
||
}
|
||
|
||
None
|
||
}
|
||
|
||
pub fn is_function_name(identifier: &str) -> bool
|
||
{
|
||
if is_keyword(identifier)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
let mut characters = identifier.chars();
|
||
|
||
while let Some(character) = characters.next()
|
||
{
|
||
match character
|
||
{
|
||
'_' => continue,
|
||
_ if character.is_ascii_lowercase() => return true,
|
||
_ => return false,
|
||
}
|
||
}
|
||
|
||
false
|
||
}
|
||
|
||
fn is_variable_name(identifier: &str) -> bool
|
||
{
|
||
let mut characters = identifier.chars();
|
||
|
||
while let Some(character) = characters.next()
|
||
{
|
||
match character
|
||
{
|
||
'_' => continue,
|
||
_ if character.is_ascii_uppercase() => return true,
|
||
_ => return false,
|
||
}
|
||
}
|
||
|
||
false
|
||
}
|
||
|
||
pub(crate) fn variable_declaration<P>(input: &str)
|
||
-> Option<(<P::Flavor as crate::flavor::Flavor>::VariableDeclaration, &str)>
|
||
where
|
||
P: crate::parse::Parser,
|
||
{
|
||
variable_name(input)
|
||
.map(|(variable_name, remaining_input)|
|
||
(<P as crate::parse::Parser>::new_variable_declaration(variable_name.to_string()),
|
||
remaining_input))
|
||
}
|
||
|
||
pub(crate) fn variable_declarations<P>(input: &str)
|
||
-> Result<Option<(crate::VariableDeclarations<P::Flavor>, &str)>, crate::parse::Error>
|
||
where
|
||
P: crate::parse::Parser,
|
||
{
|
||
let mut variable_declarations = vec![];
|
||
|
||
let (first_variable_declaration, mut input) = match variable_declaration::<P>(input)
|
||
{
|
||
Some(first_variable_declaration) => first_variable_declaration,
|
||
None => return Ok(None),
|
||
};
|
||
|
||
variable_declarations.push(std::rc::Rc::new(first_variable_declaration));
|
||
|
||
loop
|
||
{
|
||
input = trim_start(input);
|
||
|
||
input = match symbol(input)
|
||
{
|
||
Some((Symbol::Comma, input)) => input,
|
||
// TODO: detect redeclarations, such as in “exists X, Y, X”
|
||
_ => return Ok(Some((variable_declarations, input))),
|
||
};
|
||
|
||
input = trim_start(input);
|
||
|
||
let (variable_declaration, remaining_input) = match variable_declaration::<P>(input)
|
||
{
|
||
Some(variable_declaration) => variable_declaration,
|
||
None => return Err(crate::parse::Error::new_expected_variable_declaration(
|
||
crate::parse::error::Location::new(0, Some(0)))),
|
||
};
|
||
|
||
input = remaining_input;
|
||
|
||
variable_declarations.push(std::rc::Rc::new(variable_declaration));
|
||
}
|
||
}
|
||
|
||
#[derive(Clone, Copy, Eq, PartialEq)]
|
||
pub(crate) enum ArithmeticOperatorClass
|
||
{
|
||
Exponential,
|
||
Multiplicative,
|
||
Additive,
|
||
}
|
||
|
||
impl ArithmeticOperatorClass
|
||
{
|
||
fn level(&self) -> usize
|
||
{
|
||
match self
|
||
{
|
||
Self::Exponential => 1,
|
||
Self::Multiplicative => 2,
|
||
Self::Additive => 3,
|
||
}
|
||
}
|
||
}
|
||
|
||
impl std::fmt::Debug for ArithmeticOperatorClass
|
||
{
|
||
fn fmt(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result
|
||
{
|
||
match &self
|
||
{
|
||
Self::Exponential => write!(formatter, "exponential"),
|
||
Self::Multiplicative => write!(formatter, "multiplicative"),
|
||
Self::Additive => write!(formatter, "additive"),
|
||
}
|
||
}
|
||
}
|
||
|
||
pub(crate) struct TermStr<'i, 'd, 'v, 'p, P>
|
||
where
|
||
P: super::Parser,
|
||
{
|
||
input: &'i str,
|
||
parser: &'d P,
|
||
variable_declaration_stack: &'v crate::VariableDeclarationStackLayer<'p, P::Flavor>,
|
||
}
|
||
|
||
impl<'i, 'd, 'v, 'p, P> TermStr<'i, 'd, 'v, 'p, P>
|
||
where
|
||
P: super::Parser,
|
||
{
|
||
pub fn new(input: &'i str, parser: &'d P,
|
||
variable_declaration_stack: &'v crate::VariableDeclarationStackLayer<'p, P::Flavor>)
|
||
-> Self
|
||
{
|
||
Self
|
||
{
|
||
input,
|
||
parser,
|
||
variable_declaration_stack,
|
||
}
|
||
}
|
||
|
||
fn arithmetic_operator_classes(&self) -> Tokens<'i, impl FnMut(Token<'i>)
|
||
-> Option<ArithmeticOperatorClass>>
|
||
{
|
||
let functor = |token| match token
|
||
{
|
||
Token::Symbol(Symbol::Exponentiation) => Some(ArithmeticOperatorClass::Exponential),
|
||
Token::Symbol(Symbol::Multiplication) => Some(ArithmeticOperatorClass::Multiplicative),
|
||
Token::Symbol(Symbol::Division) => Some(ArithmeticOperatorClass::Multiplicative),
|
||
Token::Symbol(Symbol::Percent) => Some(ArithmeticOperatorClass::Multiplicative),
|
||
Token::Symbol(Symbol::Plus) => Some(ArithmeticOperatorClass::Additive),
|
||
Token::Symbol(Symbol::Minus) => Some(ArithmeticOperatorClass::Additive),
|
||
_ => None,
|
||
};
|
||
|
||
// TODO: refactor so that self.input is always set correctly
|
||
Tokens::new_filter_map(self.input, functor)
|
||
}
|
||
|
||
fn filter_by_arithmetic_operator_class(&self,
|
||
arithmetic_operator_class: ArithmeticOperatorClass)
|
||
-> Tokens<'i, impl FnMut(Token<'i>) -> Option<crate::BinaryOperator>>
|
||
{
|
||
let functor = move |token| match token
|
||
{
|
||
Token::Symbol(Symbol::Exponentiation) =>
|
||
if arithmetic_operator_class == ArithmeticOperatorClass::Exponential
|
||
{
|
||
Some(crate::BinaryOperator::Exponentiate)
|
||
}
|
||
else
|
||
{
|
||
None
|
||
},
|
||
Token::Symbol(Symbol::Multiplication) =>
|
||
if arithmetic_operator_class == ArithmeticOperatorClass::Multiplicative
|
||
{
|
||
Some(crate::BinaryOperator::Multiply)
|
||
}
|
||
else
|
||
{
|
||
None
|
||
},
|
||
Token::Symbol(Symbol::Division) =>
|
||
if arithmetic_operator_class == ArithmeticOperatorClass::Multiplicative
|
||
{
|
||
Some(crate::BinaryOperator::Divide)
|
||
}
|
||
else
|
||
{
|
||
None
|
||
},
|
||
Token::Symbol(Symbol::Percent) =>
|
||
if arithmetic_operator_class == ArithmeticOperatorClass::Multiplicative
|
||
{
|
||
Some(crate::BinaryOperator::Modulo)
|
||
}
|
||
else
|
||
{
|
||
None
|
||
},
|
||
Token::Symbol(Symbol::Plus) =>
|
||
if arithmetic_operator_class == ArithmeticOperatorClass::Additive
|
||
{
|
||
Some(crate::BinaryOperator::Add)
|
||
}
|
||
else
|
||
{
|
||
None
|
||
},
|
||
Token::Symbol(Symbol::Minus) =>
|
||
if arithmetic_operator_class == ArithmeticOperatorClass::Additive
|
||
{
|
||
Some(crate::BinaryOperator::Subtract)
|
||
}
|
||
else
|
||
{
|
||
None
|
||
},
|
||
_ => None,
|
||
};
|
||
|
||
Tokens::new_filter_map(self.input, functor)
|
||
}
|
||
|
||
pub fn top_level_arithmetic_operator_class(&self)
|
||
-> Result<Option<ArithmeticOperatorClass>, crate::parse::Error>
|
||
{
|
||
let mut top_level_arithmetic_operator_class = None;
|
||
|
||
for arithmetic_operator_class in self.arithmetic_operator_classes()
|
||
{
|
||
let (_, arithmetic_operator_class) = arithmetic_operator_class?;
|
||
|
||
top_level_arithmetic_operator_class = match top_level_arithmetic_operator_class
|
||
{
|
||
None => Some(arithmetic_operator_class),
|
||
Some(top_level_arithmetic_operator_class) =>
|
||
{
|
||
if arithmetic_operator_class.level()
|
||
> top_level_arithmetic_operator_class.level()
|
||
{
|
||
Some(arithmetic_operator_class)
|
||
}
|
||
else
|
||
{
|
||
Some(top_level_arithmetic_operator_class)
|
||
}
|
||
},
|
||
}
|
||
}
|
||
|
||
Ok(top_level_arithmetic_operator_class)
|
||
}
|
||
|
||
pub fn parse(&self, level: usize) -> Result<crate::Term<P::Flavor>, crate::parse::Error>
|
||
{
|
||
let indentation = " ".repeat(level);
|
||
log::trace!("{}- parsing term: {}", indentation, self.input);
|
||
|
||
let input = trim_start(self.input);
|
||
|
||
match input.chars().next()
|
||
{
|
||
Some(')') => return Err(crate::parse::Error::new_unmatched_parenthesis(
|
||
crate::parse::error::Location::new(0, Some(0)))),
|
||
// TODO: implement absolute value function
|
||
Some('|') => unimplemented!(),
|
||
None => return Err(crate::parse::Error::new_empty_expression(
|
||
crate::parse::error::Location::new(0, Some(0)))),
|
||
_ => (),
|
||
}
|
||
|
||
// Parse arithmetic infix operations
|
||
if let Some(top_level_arithmetic_operator_class) =
|
||
self.top_level_arithmetic_operator_class()?
|
||
{
|
||
log::trace!("{} parsing {:?} arithmetic term", indentation,
|
||
top_level_arithmetic_operator_class);
|
||
|
||
if top_level_arithmetic_operator_class == ArithmeticOperatorClass::Exponential
|
||
{
|
||
return self.exponentiate(
|
||
self.filter_by_arithmetic_operator_class(top_level_arithmetic_operator_class)
|
||
.split(), level + 1);
|
||
}
|
||
|
||
// Parse arguments of arithmetic infix operations
|
||
let mut argument_iterator =
|
||
self.filter_by_arithmetic_operator_class(top_level_arithmetic_operator_class);
|
||
|
||
let (first_argument, first_binary_operator) = argument_iterator.next().ok_or_else(||
|
||
crate::parse::Error::new_expected_term(
|
||
crate::parse::error::Location::new(0, Some(0))))??;
|
||
let first_argument =
|
||
TermStr::new(first_argument, self.parser, self.variable_declaration_stack)
|
||
.parse(level + 1)?;
|
||
// TODO: improve error handling if the terms between the operators are invalid
|
||
|
||
let (accumulator, last_binary_operator) =
|
||
argument_iterator.try_fold((first_argument, first_binary_operator),
|
||
|(accumulator, binary_operator), argument|
|
||
{
|
||
let (argument, next_binary_operator) = argument?;
|
||
let argument = TermStr::new(argument, self.parser,
|
||
self.variable_declaration_stack)
|
||
.parse(level + 1)?;
|
||
let binary_operation =
|
||
crate::BinaryOperation::new(binary_operator, Box::new(accumulator),
|
||
Box::new(argument));
|
||
let formula = crate::Term::BinaryOperation(binary_operation);
|
||
|
||
Ok((formula, next_binary_operator))
|
||
})?;
|
||
|
||
// The last item hasn’t been consumed yet, so it’s safe to unwrap it
|
||
let last_argument = argument_iterator.remaining_input().unwrap();
|
||
let last_argument =
|
||
TermStr::new(last_argument, self.parser, self.variable_declaration_stack)
|
||
.parse(level + 1)?;
|
||
let last_binary_operation =
|
||
crate::BinaryOperation::new(last_binary_operator, Box::new(accumulator),
|
||
Box::new(last_argument));
|
||
|
||
return Ok(crate::Term::BinaryOperation(last_binary_operation));
|
||
}
|
||
|
||
if let Some((number, input)) = number(input)?
|
||
{
|
||
if !input.trim().is_empty()
|
||
{
|
||
return Err(crate::parse::Error::new_unexpected_token(
|
||
crate::parse::error::Location::new(0, Some(0))));
|
||
}
|
||
|
||
return Ok(crate::Term::integer(number as i32));
|
||
}
|
||
|
||
if let Some((identifier, input)) = identifier(input)
|
||
{
|
||
match identifier
|
||
{
|
||
"inf" =>
|
||
{
|
||
if !input.trim().is_empty()
|
||
{
|
||
return Err(crate::parse::Error::new_unexpected_token(
|
||
crate::parse::error::Location::new(0, Some(0))))
|
||
}
|
||
|
||
return Ok(crate::Term::infimum());
|
||
},
|
||
"sup" =>
|
||
{
|
||
if !input.trim().is_empty()
|
||
{
|
||
return Err(crate::parse::Error::new_unexpected_token(
|
||
crate::parse::error::Location::new(0, Some(0))))
|
||
}
|
||
|
||
return Ok(crate::Term::supremum());
|
||
},
|
||
"true" =>
|
||
{
|
||
if !input.trim().is_empty()
|
||
{
|
||
return Err(crate::parse::Error::new_unexpected_token(
|
||
crate::parse::error::Location::new(0, Some(0))))
|
||
}
|
||
|
||
return Ok(crate::Term::true_());
|
||
},
|
||
"false" =>
|
||
{
|
||
if !input.trim().is_empty()
|
||
{
|
||
return Err(crate::parse::Error::new_unexpected_token(
|
||
crate::parse::error::Location::new(0, Some(0))))
|
||
}
|
||
|
||
return Ok(crate::Term::false_());
|
||
},
|
||
_ if is_variable_name(identifier) =>
|
||
{
|
||
if !input.trim().is_empty()
|
||
{
|
||
return Err(crate::parse::Error::new_unexpected_token(
|
||
crate::parse::error::Location::new(0, Some(0))))
|
||
}
|
||
|
||
let declaration = P::find_or_create_variable_declaration(
|
||
self.variable_declaration_stack, identifier);
|
||
return Ok(crate::Term::variable(declaration));
|
||
},
|
||
_ if is_function_name(identifier) =>
|
||
{
|
||
let function_name = identifier;
|
||
log::trace!("{} parsing function {}", indentation, function_name);
|
||
|
||
let input = trim_start(input);
|
||
|
||
// Parse arguments if there are any
|
||
let (arguments, input) = match parenthesized_expression(input)?
|
||
{
|
||
Some((parenthesized_expression, input)) =>
|
||
{
|
||
let functor = |token: &_| *token == Token::Symbol(Symbol::Comma);
|
||
let arguments = Tokens::new_filter(parenthesized_expression, functor).split()
|
||
.map(|argument| TermStr::new(argument?, self.parser,
|
||
self.variable_declaration_stack)
|
||
.parse(level + 1))
|
||
.collect::<Result<_, _>>()?;
|
||
|
||
(arguments, input)
|
||
}
|
||
None => (vec![], input),
|
||
};
|
||
|
||
if !input.trim().is_empty()
|
||
{
|
||
return Err(crate::parse::Error::new_unexpected_token(
|
||
crate::parse::error::Location::new(0, Some(0))))
|
||
}
|
||
|
||
let declaration = self.parser.find_or_create_function_declaration(
|
||
function_name, arguments.len());
|
||
return Ok(crate::Term::function(declaration, arguments));
|
||
},
|
||
_ => (),
|
||
}
|
||
}
|
||
|
||
// TODO: parse negative value
|
||
|
||
// Parse parenthesized terms
|
||
if let Some((parenthesized_expression, input)) = parenthesized_expression(input)?
|
||
{
|
||
if !input.trim().is_empty()
|
||
{
|
||
return Err(crate::parse::Error::new_unexpected_token(
|
||
crate::parse::error::Location::new(0, Some(0))));
|
||
}
|
||
|
||
return TermStr::new(parenthesized_expression, self.parser,
|
||
self.variable_declaration_stack)
|
||
.parse(level + 1);
|
||
}
|
||
|
||
Err(crate::parse::Error::new_unexpected_token(
|
||
crate::parse::error::Location::new(0, Some(0))))
|
||
}
|
||
|
||
// TODO: refactor
|
||
fn exponentiate_inner<T>(&self, mut argument_iterator: T, level: usize)
|
||
-> Result<Option<crate::Term<P::Flavor>>, crate::parse::Error>
|
||
where
|
||
T: std::iter::Iterator<Item = Result<&'i str, crate::parse::Error>>
|
||
{
|
||
match argument_iterator.next()
|
||
{
|
||
Some(argument) =>
|
||
{
|
||
// TODO: improve error handling if antecedent cannot be parsed
|
||
let argument =
|
||
TermStr::new(argument?, self.parser, self.variable_declaration_stack)
|
||
.parse(level)?;
|
||
match self.exponentiate_inner(argument_iterator, level)?
|
||
{
|
||
Some(next_argument) => Ok(Some(crate::Term::exponentiate(Box::new(argument),
|
||
Box::new(next_argument)))),
|
||
None => Ok(Some(argument)),
|
||
}
|
||
},
|
||
None => Ok(None),
|
||
}
|
||
}
|
||
|
||
fn exponentiate<T>(&self, mut argument_iterator: T, level: usize)
|
||
-> Result<crate::Term<P::Flavor>, crate::parse::Error>
|
||
where
|
||
T: std::iter::Iterator<Item = Result<&'i str, crate::parse::Error>>
|
||
{
|
||
match argument_iterator.next()
|
||
{
|
||
Some(argument) =>
|
||
{
|
||
// TODO: improve error handling if antecedent cannot be parsed
|
||
let argument =
|
||
TermStr::new(argument?, self.parser, self.variable_declaration_stack)
|
||
.parse(level)?;
|
||
match self.exponentiate_inner(argument_iterator, level)?
|
||
{
|
||
Some(next_argument) =>
|
||
Ok(crate::Term::exponentiate(Box::new(argument), Box::new(next_argument))),
|
||
None => Err(crate::parse::Error::new_expected_term(
|
||
crate::parse::error::Location::new(0, Some(0)))),
|
||
}
|
||
},
|
||
None => Err(crate::parse::Error::new_expected_term(
|
||
crate::parse::error::Location::new(0, Some(0)))),
|
||
}
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests
|
||
{
|
||
use super::*;
|
||
|
||
#[test]
|
||
fn parse_variable_name()
|
||
{
|
||
assert_eq!(variable_name("X").unwrap(), ("X", ""));
|
||
assert_eq!(variable_name("_X").unwrap(), ("_X", ""));
|
||
assert_eq!(variable_name("__X").unwrap(), ("__X", ""));
|
||
assert_eq!(variable_name("Variable").unwrap(), ("Variable", ""));
|
||
assert_eq!(variable_name("_Variable").unwrap(), ("_Variable", ""));
|
||
assert_eq!(variable_name("__Variable").unwrap(), ("__Variable", ""));
|
||
assert_eq!(variable_name("X,").unwrap(), ("X", ","));
|
||
assert_eq!(variable_name("_X,").unwrap(), ("_X", ","));
|
||
assert_eq!(variable_name("__X,").unwrap(), ("__X", ","));
|
||
assert_eq!(variable_name("Variable,").unwrap(), ("Variable", ","));
|
||
assert_eq!(variable_name("_Variable,").unwrap(), ("_Variable", ","));
|
||
assert_eq!(variable_name("__Variable,").unwrap(), ("__Variable", ","));
|
||
}
|
||
|
||
#[test]
|
||
fn parse_variable_declaration()
|
||
{
|
||
let variable_declaration =
|
||
|x| super::variable_declaration::<crate::parse::DefaultParser>(x);
|
||
|
||
let v = variable_declaration("X").unwrap();
|
||
assert_eq!((v.0.name.as_str(), v.1), ("X", ""));
|
||
let v = variable_declaration("_X").unwrap();
|
||
assert_eq!((v.0.name.as_str(), v.1), ("_X", ""));
|
||
let v = variable_declaration("__X").unwrap();
|
||
assert_eq!((v.0.name.as_str(), v.1), ("__X", ""));
|
||
let v = variable_declaration("Variable").unwrap();
|
||
assert_eq!((v.0.name.as_str(), v.1), ("Variable", ""));
|
||
let v = variable_declaration("_Variable").unwrap();
|
||
assert_eq!((v.0.name.as_str(), v.1), ("_Variable", ""));
|
||
let v = variable_declaration("__Variable").unwrap();
|
||
assert_eq!((v.0.name.as_str(), v.1), ("__Variable", ""));
|
||
let v = variable_declaration("X,").unwrap();
|
||
assert_eq!((v.0.name.as_str(), v.1), ("X", ","));
|
||
let v = variable_declaration("_X,").unwrap();
|
||
assert_eq!((v.0.name.as_str(), v.1), ("_X", ","));
|
||
let v = variable_declaration("__X,").unwrap();
|
||
assert_eq!((v.0.name.as_str(), v.1), ("__X", ","));
|
||
let v = variable_declaration("Variable,").unwrap();
|
||
assert_eq!((v.0.name.as_str(), v.1), ("Variable", ","));
|
||
let v = variable_declaration("_Variable,").unwrap();
|
||
assert_eq!((v.0.name.as_str(), v.1), ("_Variable", ","));
|
||
let v = variable_declaration("__Variable,").unwrap();
|
||
assert_eq!((v.0.name.as_str(), v.1), ("__Variable", ","));
|
||
}
|
||
|
||
#[test]
|
||
fn parse_variable_declarations()
|
||
{
|
||
let variable_declarations =
|
||
|x| super::variable_declarations::<crate::parse::DefaultParser>(x);
|
||
|
||
let v = variable_declarations("X.").unwrap().unwrap();
|
||
assert_eq!(v.0.len(), 1);
|
||
assert_eq!(v.0[0].name.as_str(), "X");
|
||
assert_eq!(v.1, ".");
|
||
|
||
let v = variable_declarations("X,Y,Z.").unwrap().unwrap();
|
||
assert_eq!(v.0.len(), 3);
|
||
assert_eq!(v.0[0].name.as_str(), "X");
|
||
assert_eq!(v.0[1].name.as_str(), "Y");
|
||
assert_eq!(v.0[2].name.as_str(), "Z");
|
||
assert_eq!(v.1, ".");
|
||
|
||
let v = variable_declarations("X, Y, Z.").unwrap().unwrap();
|
||
assert_eq!(v.0.len(), 3);
|
||
assert_eq!(v.0[0].name.as_str(), "X");
|
||
assert_eq!(v.0[1].name.as_str(), "Y");
|
||
assert_eq!(v.0[2].name.as_str(), "Z");
|
||
assert_eq!(v.1, ".");
|
||
|
||
let v = variable_declarations("X , Y , Z.").unwrap().unwrap();
|
||
assert_eq!(v.0.len(), 3);
|
||
assert_eq!(v.0[0].name.as_str(), "X");
|
||
assert_eq!(v.0[1].name.as_str(), "Y");
|
||
assert_eq!(v.0[2].name.as_str(), "Z");
|
||
assert_eq!(v.1, ".");
|
||
|
||
assert!(variable_declarations("test").unwrap().is_none());
|
||
assert!(variable_declarations("X, test").is_err());
|
||
assert!(variable_declarations("X ,test").is_err());
|
||
assert!(variable_declarations("X,Y,Z, test").is_err());
|
||
assert!(variable_declarations("X,Y,Z ,test").is_err());
|
||
}
|
||
}
|