582 lines
26 KiB
Rust
582 lines
26 KiB
Rust
#![allow(unused)]
|
|
#![allow(non_snake_case)]
|
|
#![allow(non_camel_case_types)]
|
|
#![allow(clippy::all)]
|
|
// |==========================================================|
|
|
// | WARNING: THIS FILE IS AUTOMATICALLY GENERATED. |
|
|
// | CHANGES TO IT WILL BE DELETED WHEN REGENERATED. |
|
|
// | IN GENERAL, THIS FILE SHOULD NOT BE MODIFIED IN ANY WAY. |
|
|
// |==========================================================|
|
|
use super::prelude::*;
|
|
impl<M: AstInfo> FromPairs<M> for Program<M> {
|
|
fn from_pairs<G: GenerateAstInfo<Result = M>>(pair: &ParsePairSort, generator: &mut G) -> Self {
|
|
assert_eq!(pair.sort, "program");
|
|
let info = generator.generate(&pair);
|
|
Self(
|
|
info,
|
|
if let ParsePairExpression::List(_, ref l) = pair.constructor_value {
|
|
l . iter () . map (| x | if let ParsePairExpression :: Sort (_ , ref s) = x { Statement :: from_pairs (s , generator) } else { unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "program") ; }) . collect ()
|
|
} else {
|
|
unreachable!(
|
|
"expected different parse pair expression in pair to ast conversion of {}",
|
|
"program"
|
|
);
|
|
},
|
|
)
|
|
}
|
|
}
|
|
impl<M: AstInfo> FromPairs<M> for Statement<M> {
|
|
fn from_pairs<G: GenerateAstInfo<Result = M>>(pair: &ParsePairSort, generator: &mut G) -> Self {
|
|
assert_eq!(pair.sort, "statement");
|
|
let info = generator.generate(&pair);
|
|
match pair.constructor_name {
|
|
"expression" => {
|
|
if let ParsePairExpression::List(_, ref l) = pair.constructor_value {
|
|
Self::Expression(
|
|
info,
|
|
if let ParsePairExpression::Sort(_, ref s) = l[0usize] {
|
|
Expression::from_pairs(s, generator)
|
|
} else {
|
|
unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "statement");
|
|
},
|
|
)
|
|
} else {
|
|
unreachable!(
|
|
"expected different parse pair expression in pair to ast conversion of {}",
|
|
"statement"
|
|
);
|
|
}
|
|
}
|
|
"let" => {
|
|
if let ParsePairExpression::List(_, ref l) = pair.constructor_value {
|
|
Self::Let(
|
|
info,
|
|
if let ParsePairExpression::Sort(_, ref s) = l[1usize] {
|
|
Identifier::from_pairs(s, generator)
|
|
} else {
|
|
unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "statement");
|
|
},
|
|
if let ParsePairExpression::Sort(_, ref s) = l[3usize] {
|
|
Expression::from_pairs(s, generator)
|
|
} else {
|
|
unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "statement");
|
|
},
|
|
)
|
|
} else {
|
|
unreachable!(
|
|
"expected different parse pair expression in pair to ast conversion of {}",
|
|
"statement"
|
|
);
|
|
}
|
|
}
|
|
a => unreachable!("{}", a),
|
|
}
|
|
}
|
|
}
|
|
impl<M: AstInfo> FromPairs<M> for Expression<M> {
|
|
fn from_pairs<G: GenerateAstInfo<Result = M>>(pair: &ParsePairSort, generator: &mut G) -> Self {
|
|
assert_eq!(pair.sort, "expression");
|
|
let info = generator.generate(&pair);
|
|
Self(
|
|
info,
|
|
if let ParsePairExpression::Sort(_, ref s) = pair.constructor_value {
|
|
Equality::from_pairs(s, generator)
|
|
} else {
|
|
unreachable!(
|
|
"expected different parse pair expression in pair to ast conversion of {}",
|
|
"expression"
|
|
);
|
|
},
|
|
)
|
|
}
|
|
}
|
|
impl<M: AstInfo> FromPairs<M> for Identifier<M> {
|
|
fn from_pairs<G: GenerateAstInfo<Result = M>>(pair: &ParsePairSort, generator: &mut G) -> Self {
|
|
assert_eq!(pair.sort, "identifier");
|
|
let info = generator.generate(&pair);
|
|
return Self(info, pair.constructor_value.span().as_str().to_string());
|
|
}
|
|
}
|
|
impl<M: AstInfo> FromPairs<M> for Equality<M> {
|
|
fn from_pairs<G: GenerateAstInfo<Result = M>>(pair: &ParsePairSort, generator: &mut G) -> Self {
|
|
assert_eq!(pair.sort, "equality");
|
|
let info = generator.generate(&pair);
|
|
match pair.constructor_name {
|
|
"equal" => {
|
|
if let ParsePairExpression::List(_, ref l) = pair.constructor_value {
|
|
Self::Equal(
|
|
info,
|
|
if let ParsePairExpression::Sort(_, ref s) = l[0usize] {
|
|
Inequality::from_pairs(s, generator)
|
|
} else {
|
|
unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "equality");
|
|
},
|
|
if let ParsePairExpression::Sort(_, ref s) = l[2usize] {
|
|
Box::new(Expression::from_pairs(s, generator))
|
|
} else {
|
|
unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "equality");
|
|
},
|
|
)
|
|
} else {
|
|
unreachable!(
|
|
"expected different parse pair expression in pair to ast conversion of {}",
|
|
"equality"
|
|
);
|
|
}
|
|
}
|
|
"not_equal" => {
|
|
if let ParsePairExpression::List(_, ref l) = pair.constructor_value {
|
|
Self::NotEqual(
|
|
info,
|
|
if let ParsePairExpression::Sort(_, ref s) = l[0usize] {
|
|
Inequality::from_pairs(s, generator)
|
|
} else {
|
|
unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "equality");
|
|
},
|
|
if let ParsePairExpression::Sort(_, ref s) = l[2usize] {
|
|
Box::new(Expression::from_pairs(s, generator))
|
|
} else {
|
|
unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "equality");
|
|
},
|
|
)
|
|
} else {
|
|
unreachable!(
|
|
"expected different parse pair expression in pair to ast conversion of {}",
|
|
"equality"
|
|
);
|
|
}
|
|
}
|
|
"inequality" => {
|
|
Self::Inequality(
|
|
info,
|
|
if let ParsePairExpression::Sort(_, ref s) = pair.constructor_value {
|
|
Inequality::from_pairs(s, generator)
|
|
} else {
|
|
unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "equality");
|
|
},
|
|
)
|
|
}
|
|
a => unreachable!("{}", a),
|
|
}
|
|
}
|
|
}
|
|
impl<M: AstInfo> FromPairs<M> for Inequality<M> {
|
|
fn from_pairs<G: GenerateAstInfo<Result = M>>(pair: &ParsePairSort, generator: &mut G) -> Self {
|
|
assert_eq!(pair.sort, "inequality");
|
|
let info = generator.generate(&pair);
|
|
match pair.constructor_name {
|
|
"less_than" => {
|
|
if let ParsePairExpression::List(_, ref l) = pair.constructor_value {
|
|
Self::LessThan(
|
|
info,
|
|
if let ParsePairExpression::Sort(_, ref s) = l[0usize] {
|
|
Plus::from_pairs(s, generator)
|
|
} else {
|
|
unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "inequality");
|
|
},
|
|
if let ParsePairExpression::Sort(_, ref s) = l[2usize] {
|
|
Box::new(Expression::from_pairs(s, generator))
|
|
} else {
|
|
unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "inequality");
|
|
},
|
|
)
|
|
} else {
|
|
unreachable!(
|
|
"expected different parse pair expression in pair to ast conversion of {}",
|
|
"inequality"
|
|
);
|
|
}
|
|
}
|
|
"less_than_or_equal" => {
|
|
if let ParsePairExpression::List(_, ref l) = pair.constructor_value {
|
|
Self::LessThanOrEqual(
|
|
info,
|
|
if let ParsePairExpression::Sort(_, ref s) = l[0usize] {
|
|
Plus::from_pairs(s, generator)
|
|
} else {
|
|
unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "inequality");
|
|
},
|
|
if let ParsePairExpression::Sort(_, ref s) = l[2usize] {
|
|
Box::new(Expression::from_pairs(s, generator))
|
|
} else {
|
|
unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "inequality");
|
|
},
|
|
)
|
|
} else {
|
|
unreachable!(
|
|
"expected different parse pair expression in pair to ast conversion of {}",
|
|
"inequality"
|
|
);
|
|
}
|
|
}
|
|
"greater_than" => {
|
|
if let ParsePairExpression::List(_, ref l) = pair.constructor_value {
|
|
Self::GreaterThan(
|
|
info,
|
|
if let ParsePairExpression::Sort(_, ref s) = l[0usize] {
|
|
Plus::from_pairs(s, generator)
|
|
} else {
|
|
unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "inequality");
|
|
},
|
|
if let ParsePairExpression::Sort(_, ref s) = l[2usize] {
|
|
Box::new(Expression::from_pairs(s, generator))
|
|
} else {
|
|
unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "inequality");
|
|
},
|
|
)
|
|
} else {
|
|
unreachable!(
|
|
"expected different parse pair expression in pair to ast conversion of {}",
|
|
"inequality"
|
|
);
|
|
}
|
|
}
|
|
"greater_than_or_equal" => {
|
|
if let ParsePairExpression::List(_, ref l) = pair.constructor_value {
|
|
Self::GreaterThanOrEqual(
|
|
info,
|
|
if let ParsePairExpression::Sort(_, ref s) = l[0usize] {
|
|
Plus::from_pairs(s, generator)
|
|
} else {
|
|
unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "inequality");
|
|
},
|
|
if let ParsePairExpression::Sort(_, ref s) = l[2usize] {
|
|
Box::new(Expression::from_pairs(s, generator))
|
|
} else {
|
|
unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "inequality");
|
|
},
|
|
)
|
|
} else {
|
|
unreachable!(
|
|
"expected different parse pair expression in pair to ast conversion of {}",
|
|
"inequality"
|
|
);
|
|
}
|
|
}
|
|
"plus" => {
|
|
Self::Plus(
|
|
info,
|
|
if let ParsePairExpression::Sort(_, ref s) = pair.constructor_value {
|
|
Plus::from_pairs(s, generator)
|
|
} else {
|
|
unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "inequality");
|
|
},
|
|
)
|
|
}
|
|
a => unreachable!("{}", a),
|
|
}
|
|
}
|
|
}
|
|
impl<M: AstInfo> FromPairs<M> for Plus<M> {
|
|
fn from_pairs<G: GenerateAstInfo<Result = M>>(pair: &ParsePairSort, generator: &mut G) -> Self {
|
|
assert_eq!(pair.sort, "plus");
|
|
let info = generator.generate(&pair);
|
|
match pair.constructor_name {
|
|
"plus" => {
|
|
if let ParsePairExpression::List(_, ref l) = pair.constructor_value {
|
|
Self::Plus(
|
|
info,
|
|
if let ParsePairExpression::Sort(_, ref s) = l[0usize] {
|
|
Times::from_pairs(s, generator)
|
|
} else {
|
|
unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "plus");
|
|
},
|
|
if let ParsePairExpression::Sort(_, ref s) = l[2usize] {
|
|
Times::from_pairs(s, generator)
|
|
} else {
|
|
unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "plus");
|
|
},
|
|
)
|
|
} else {
|
|
unreachable!(
|
|
"expected different parse pair expression in pair to ast conversion of {}",
|
|
"plus"
|
|
);
|
|
}
|
|
}
|
|
"minus" => {
|
|
if let ParsePairExpression::List(_, ref l) = pair.constructor_value {
|
|
Self::Minus(
|
|
info,
|
|
if let ParsePairExpression::Sort(_, ref s) = l[0usize] {
|
|
Times::from_pairs(s, generator)
|
|
} else {
|
|
unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "plus");
|
|
},
|
|
if let ParsePairExpression::Sort(_, ref s) = l[2usize] {
|
|
Times::from_pairs(s, generator)
|
|
} else {
|
|
unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "plus");
|
|
},
|
|
)
|
|
} else {
|
|
unreachable!(
|
|
"expected different parse pair expression in pair to ast conversion of {}",
|
|
"plus"
|
|
);
|
|
}
|
|
}
|
|
"times" => {
|
|
Self::Times(
|
|
info,
|
|
if let ParsePairExpression::Sort(_, ref s) = pair.constructor_value {
|
|
Times::from_pairs(s, generator)
|
|
} else {
|
|
unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "plus");
|
|
},
|
|
)
|
|
}
|
|
a => unreachable!("{}", a),
|
|
}
|
|
}
|
|
}
|
|
impl<M: AstInfo> FromPairs<M> for Times<M> {
|
|
fn from_pairs<G: GenerateAstInfo<Result = M>>(pair: &ParsePairSort, generator: &mut G) -> Self {
|
|
assert_eq!(pair.sort, "times");
|
|
let info = generator.generate(&pair);
|
|
match pair.constructor_name {
|
|
"times" => {
|
|
if let ParsePairExpression::List(_, ref l) = pair.constructor_value {
|
|
Self::Times(
|
|
info,
|
|
if let ParsePairExpression::Sort(_, ref s) = l[0usize] {
|
|
Value::from_pairs(s, generator)
|
|
} else {
|
|
unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "times");
|
|
},
|
|
if let ParsePairExpression::Sort(_, ref s) = l[2usize] {
|
|
Box::new(Expression::from_pairs(s, generator))
|
|
} else {
|
|
unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "times");
|
|
},
|
|
)
|
|
} else {
|
|
unreachable!(
|
|
"expected different parse pair expression in pair to ast conversion of {}",
|
|
"times"
|
|
);
|
|
}
|
|
}
|
|
"divide" => {
|
|
if let ParsePairExpression::List(_, ref l) = pair.constructor_value {
|
|
Self::Divide(
|
|
info,
|
|
if let ParsePairExpression::Sort(_, ref s) = l[0usize] {
|
|
Value::from_pairs(s, generator)
|
|
} else {
|
|
unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "times");
|
|
},
|
|
if let ParsePairExpression::Sort(_, ref s) = l[2usize] {
|
|
Box::new(Expression::from_pairs(s, generator))
|
|
} else {
|
|
unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "times");
|
|
},
|
|
)
|
|
} else {
|
|
unreachable!(
|
|
"expected different parse pair expression in pair to ast conversion of {}",
|
|
"times"
|
|
);
|
|
}
|
|
}
|
|
"value" => {
|
|
Self::Value(
|
|
info,
|
|
if let ParsePairExpression::Sort(_, ref s) = pair.constructor_value {
|
|
Value::from_pairs(s, generator)
|
|
} else {
|
|
unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "times");
|
|
},
|
|
)
|
|
}
|
|
a => unreachable!("{}", a),
|
|
}
|
|
}
|
|
}
|
|
impl<M: AstInfo> FromPairs<M> for Value<M> {
|
|
fn from_pairs<G: GenerateAstInfo<Result = M>>(pair: &ParsePairSort, generator: &mut G) -> Self {
|
|
assert_eq!(pair.sort, "value");
|
|
let info = generator.generate(&pair);
|
|
match pair.constructor_name {
|
|
"const" => {
|
|
Self::Const(
|
|
info,
|
|
if let ParsePairExpression::Sort(_, ref s) = pair.constructor_value {
|
|
ConstValue::from_pairs(s, generator)
|
|
} else {
|
|
unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "value");
|
|
},
|
|
)
|
|
}
|
|
"call" => {
|
|
Self::Call(
|
|
info,
|
|
if let ParsePairExpression::Sort(_, ref s) = pair.constructor_value {
|
|
Call::from_pairs(s, generator)
|
|
} else {
|
|
unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "value");
|
|
},
|
|
)
|
|
}
|
|
"identifier" => {
|
|
Self::Identifier(
|
|
info,
|
|
if let ParsePairExpression::Sort(_, ref s) = pair.constructor_value {
|
|
Identifier::from_pairs(s, generator)
|
|
} else {
|
|
unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "value");
|
|
},
|
|
)
|
|
}
|
|
"parens" => {
|
|
if let ParsePairExpression::List(_, ref l) = pair.constructor_value {
|
|
Self::Parens(
|
|
info,
|
|
if let ParsePairExpression::Sort(_, ref s) = l[1usize] {
|
|
Box::new(Expression::from_pairs(s, generator))
|
|
} else {
|
|
unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "value");
|
|
},
|
|
)
|
|
} else {
|
|
unreachable!(
|
|
"expected different parse pair expression in pair to ast conversion of {}",
|
|
"value"
|
|
);
|
|
}
|
|
}
|
|
a => unreachable!("{}", a),
|
|
}
|
|
}
|
|
}
|
|
impl<M: AstInfo> FromPairs<M> for ConstValue<M> {
|
|
fn from_pairs<G: GenerateAstInfo<Result = M>>(pair: &ParsePairSort, generator: &mut G) -> Self {
|
|
assert_eq!(pair.sort, "const_value");
|
|
let info = generator.generate(&pair);
|
|
match pair.constructor_name {
|
|
"int" => {
|
|
Self::Int(
|
|
info,
|
|
if let ParsePairExpression::Sort(_, ref s) = pair.constructor_value {
|
|
Int::from_pairs(s, generator)
|
|
} else {
|
|
unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "const_value");
|
|
},
|
|
)
|
|
}
|
|
"bool" => {
|
|
Self::Bool(
|
|
info,
|
|
if let ParsePairExpression::Sort(_, ref s) = pair.constructor_value {
|
|
Bool::from_pairs(s, generator)
|
|
} else {
|
|
unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "const_value");
|
|
},
|
|
)
|
|
}
|
|
"string" => {
|
|
Self::String(
|
|
info,
|
|
if let ParsePairExpression::Sort(_, ref s) = pair.constructor_value {
|
|
String::from_pairs(s, generator)
|
|
} else {
|
|
unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "const_value");
|
|
},
|
|
)
|
|
}
|
|
"char" => {
|
|
Self::Char(
|
|
info,
|
|
if let ParsePairExpression::Sort(_, ref s) = pair.constructor_value {
|
|
Char::from_pairs(s, generator)
|
|
} else {
|
|
unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "const_value");
|
|
},
|
|
)
|
|
}
|
|
a => unreachable!("{}", a),
|
|
}
|
|
}
|
|
}
|
|
impl<M: AstInfo> FromPairs<M> for Call<M> {
|
|
fn from_pairs<G: GenerateAstInfo<Result = M>>(pair: &ParsePairSort, generator: &mut G) -> Self {
|
|
assert_eq!(pair.sort, "call");
|
|
let info = generator.generate(&pair);
|
|
if let ParsePairExpression::List(_, ref l) = pair.constructor_value {
|
|
Self(
|
|
info,
|
|
if let ParsePairExpression::Sort(_, ref s) = l[0usize] {
|
|
Identifier::from_pairs(s, generator)
|
|
} else {
|
|
unreachable!(
|
|
"expected different parse pair expression in pair to ast conversion of {}",
|
|
"call"
|
|
);
|
|
},
|
|
if let ParsePairExpression::List(_, ref l) = l[2usize] {
|
|
l . iter () . map (| x | if let ParsePairExpression :: Sort (_ , ref s) = x { Box :: new (Expression :: from_pairs (s , generator)) } else { unreachable ! ("expected different parse pair expression in pair to ast conversion of {}" , "call") ; }) . collect ()
|
|
} else {
|
|
unreachable!(
|
|
"expected different parse pair expression in pair to ast conversion of {}",
|
|
"call"
|
|
);
|
|
},
|
|
)
|
|
} else {
|
|
unreachable!(
|
|
"expected different parse pair expression in pair to ast conversion of {}",
|
|
"call"
|
|
);
|
|
}
|
|
}
|
|
}
|
|
impl<M: AstInfo> FromPairs<M> for Int<M> {
|
|
fn from_pairs<G: GenerateAstInfo<Result = M>>(pair: &ParsePairSort, generator: &mut G) -> Self {
|
|
assert_eq!(pair.sort, "int");
|
|
let info = generator.generate(&pair);
|
|
return Self(info, pair.constructor_value.span().as_str().to_string());
|
|
}
|
|
}
|
|
impl<M: AstInfo> FromPairs<M> for Bool<M> {
|
|
fn from_pairs<G: GenerateAstInfo<Result = M>>(pair: &ParsePairSort, generator: &mut G) -> Self {
|
|
assert_eq!(pair.sort, "bool");
|
|
let info = generator.generate(&pair);
|
|
match pair.constructor_name {
|
|
"true" => Self::True(info),
|
|
"false" => Self::False(info),
|
|
a => unreachable!("{}", a),
|
|
}
|
|
}
|
|
}
|
|
impl<M: AstInfo> FromPairs<M> for String<M> {
|
|
fn from_pairs<G: GenerateAstInfo<Result = M>>(pair: &ParsePairSort, generator: &mut G) -> Self {
|
|
assert_eq!(pair.sort, "string");
|
|
let info = generator.generate(&pair);
|
|
return Self(info, pair.constructor_value.span().as_str().to_string());
|
|
}
|
|
}
|
|
impl<M: AstInfo> FromPairs<M> for Char<M> {
|
|
fn from_pairs<G: GenerateAstInfo<Result = M>>(pair: &ParsePairSort, generator: &mut G) -> Self {
|
|
assert_eq!(pair.sort, "char");
|
|
let info = generator.generate(&pair);
|
|
return Self(info, pair.constructor_value.span().as_str().to_string());
|
|
}
|
|
}
|
|
impl<M: AstInfo> FromPairs<M> for Layout<M> {
|
|
fn from_pairs<G: GenerateAstInfo<Result = M>>(pair: &ParsePairSort, generator: &mut G) -> Self {
|
|
assert_eq!(pair.sort, "layout");
|
|
let info = generator.generate(&pair);
|
|
Self(
|
|
info,
|
|
if let ParsePairExpression::Empty(ref span) = pair.constructor_value {
|
|
span.as_str().to_string()
|
|
} else {
|
|
unreachable!(
|
|
"expected different parse pair expression in pair to ast conversion of {}",
|
|
"layout"
|
|
);
|
|
},
|
|
)
|
|
}
|
|
}
|