359 lines
14 KiB
Plaintext
359 lines
14 KiB
Plaintext
use crate::ast;
|
|
|
|
grammar(id_generator: &ast::IdGenerator);
|
|
|
|
match {
|
|
r"[0-9]+",
|
|
r"[0-9]+\.[0-9]+",
|
|
r"[A-Za-z_][A-Za-z0-9_]*",
|
|
":",
|
|
";",
|
|
"{",
|
|
"}",
|
|
"(",
|
|
")",
|
|
"[",
|
|
"]",
|
|
"",
|
|
".",
|
|
"+",
|
|
"-",
|
|
"*",
|
|
"/",
|
|
"fn",
|
|
"return",
|
|
"let",
|
|
"true",
|
|
"false",
|
|
"if",
|
|
"else",
|
|
"=",
|
|
"for",
|
|
"type",
|
|
"trait",
|
|
"struct",
|
|
"impl",
|
|
",",
|
|
r"'(\\'|[^'])*'",
|
|
r#""(\\"|[^"])*""#,
|
|
|
|
r"\s*" => { },
|
|
r"//[^\n\r]*[\n\r]*" => { }, // `// comment`
|
|
}
|
|
|
|
|
|
pub LiteralInt: String = {
|
|
<literal:r"[0-9]+"> => literal.to_string()
|
|
};
|
|
|
|
pub SpannedLiteralInt: ast::LiteralInt = {
|
|
<literal_int:Spanned<LiteralInt>> => ast::LiteralInt{value: literal_int, type_: ast::TypeUsage::new_builtin("i64".to_string())}
|
|
};
|
|
|
|
pub LiteralFloat: String = {
|
|
<literal:r"[0-9]+\.[0-9]+"> => literal.to_string()
|
|
};
|
|
|
|
pub SpannedLiteralFloat: ast::LiteralFloat = {
|
|
<literal_float:Spanned<LiteralFloat>> => ast::LiteralFloat{value: literal_float, type_: ast::TypeUsage::new_builtin("f64".to_string())}
|
|
};
|
|
|
|
pub LiteralBool: String = {
|
|
"true" => "true".to_string(),
|
|
"false" => "false".to_string(),
|
|
};
|
|
|
|
pub SpannedLiteralBool: ast::LiteralBool = {
|
|
<literal_bool:Spanned<LiteralBool>> => ast::LiteralBool{value: literal_bool, type_: ast::TypeUsage::new_builtin("bool".to_string())}
|
|
};
|
|
|
|
pub LiteralString: String = {
|
|
<s:r"'(\\'|[^'])*'"> => String::from(&s[1..s.len()-1]),
|
|
<s:r#""(\\"|[^"])*""#> => String::from(&s[1..s.len()-1]),
|
|
};
|
|
|
|
pub SpannedLiteralString: ast::LiteralString = {
|
|
<literal_string:Spanned<LiteralString>> => ast::LiteralString{value: literal_string, type_: ast::TypeUsage::new_builtin("String".to_string())}
|
|
};
|
|
|
|
|
|
pub Identifier: String = {
|
|
<i:r"[A-Za-z_][A-Za-z0-9_]*"> => i.to_string()
|
|
};
|
|
|
|
pub GenericUsage: ast::GenericUsage = {
|
|
"[" <tp:Comma<TypeUsage>> "]" => ast::GenericUsage::new(&tp),
|
|
};
|
|
|
|
pub LiteralStructField: (ast::Identifier, ast::Expression) = {
|
|
<field:SpannedIdentifier> ":" <expr:Expression> => (field, expr)
|
|
};
|
|
|
|
pub LiteralStruct: ast::LiteralStruct = {
|
|
<i:SpannedIdentifier> <gu:GenericUsage?> "{" <field_list:Comma<LiteralStructField>> "}" => {
|
|
match gu {
|
|
Some(tp) => {
|
|
ast::LiteralStruct{
|
|
type_parameters: tp.clone(),
|
|
name: i.clone(),
|
|
fields: field_list,
|
|
type_: ast::TypeUsage::new_named(&i, &tp),
|
|
}
|
|
},
|
|
None => {
|
|
ast::LiteralStruct{
|
|
type_parameters: ast::GenericUsage::new(&[]),
|
|
name: i.clone(),
|
|
fields: field_list,
|
|
type_: ast::TypeUsage::new_named(&i, &ast::GenericUsage::new(&[])),
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
pub SpannedIdentifier: ast::Identifier = {
|
|
<i:Spanned<Identifier>> => ast::Identifier{name: i}
|
|
};
|
|
|
|
pub FunctionCall: ast::FunctionCall = {
|
|
<source:Term> "(" <args:Comma<Expression>> ")" => ast::FunctionCall{source: source, arguments: args, type_: ast::TypeUsage::new_unknown(&id_generator)}
|
|
};
|
|
|
|
pub StructGetter: ast::StructGetter = {
|
|
<source:Term> "." <field:SpannedIdentifier> <gu:GenericUsage?> => match gu {
|
|
Some(tp) => ast::StructGetter{type_parameters: tp, source: source, attribute: field, type_: ast::TypeUsage::new_unknown(&id_generator)},
|
|
None => ast::StructGetter{type_parameters: ast::GenericUsage::Unknown, source: source, attribute: field, type_: ast::TypeUsage::new_unknown(&id_generator)},
|
|
}
|
|
};
|
|
|
|
pub VariableUsage: ast::VariableUsage = {
|
|
<identifier:SpannedIdentifier> <gu:GenericUsage?> => match gu {
|
|
Some(tp) => ast::VariableUsage{name: identifier, type_parameters: tp.clone(), type_: ast::TypeUsage::new_unknown(&id_generator)},
|
|
None => ast::VariableUsage{name: identifier, type_parameters: ast::GenericUsage::Unknown, type_: ast::TypeUsage::new_unknown(&id_generator)},
|
|
}
|
|
};
|
|
|
|
pub IfExpression: ast::IfExpression = {
|
|
"if" "("<c:Expression>")" <b:Block> => ast::IfExpression{condition: c, block: b, else_: None, type_: ast::TypeUsage::new_unknown(&id_generator)},
|
|
"if" "("<c:Expression>")" <b:Block> "else" <e:Block> => ast::IfExpression{condition: c, block: b, else_: Some(e), type_: ast::TypeUsage::new_unknown(&id_generator)},
|
|
};
|
|
|
|
pub Expression: ast::Expression = {
|
|
<l:Expression> "+" <r:Factor> => {
|
|
ast::Expression{
|
|
subexpression: Box::new(ast::Subexpression::Op(ast::Operation{left: l, op: ast::Operator::Plus, right: r})),
|
|
type_: ast::TypeUsage::new_unknown(&id_generator),
|
|
}
|
|
},
|
|
<l:Expression> "-" <r:Factor> => {
|
|
ast::Expression{
|
|
subexpression: Box::new(ast::Subexpression::Op(ast::Operation{left: l, op: ast::Operator::Minus, right: r})),
|
|
type_: ast::TypeUsage::new_unknown(&id_generator),
|
|
}
|
|
},
|
|
Factor,
|
|
};
|
|
|
|
pub Factor: ast::Expression = {
|
|
<l:Factor> "*" <r:Term> => {
|
|
ast::Expression{
|
|
subexpression: Box::new(ast::Subexpression::Op(ast::Operation{left: l, op: ast::Operator::Mul, right: r})),
|
|
type_: ast::TypeUsage::new_unknown(&id_generator),
|
|
}
|
|
},
|
|
<l:Factor> "/" <r:Term> => {
|
|
ast::Expression{
|
|
subexpression: Box::new(ast::Subexpression::Op(ast::Operation{left: l, op: ast::Operator::Div, right: r})),
|
|
type_: ast::TypeUsage::new_unknown(&id_generator),
|
|
}
|
|
},
|
|
Term,
|
|
};
|
|
|
|
pub Term: ast::Expression = {
|
|
SpannedLiteralInt => ast::Expression{subexpression: Box::new(ast::Subexpression::LiteralInt(<>)), type_: ast::TypeUsage::new_unknown(&id_generator)},
|
|
SpannedLiteralFloat => ast::Expression{subexpression: Box::new(ast::Subexpression::LiteralFloat(<>)), type_: ast::TypeUsage::new_unknown(&id_generator)},
|
|
SpannedLiteralBool => ast::Expression{subexpression: Box::new(ast::Subexpression::LiteralBool(<>)), type_: ast::TypeUsage::new_unknown(&id_generator)},
|
|
SpannedLiteralString => ast::Expression{subexpression: Box::new(ast::Subexpression::LiteralString(<>)), type_: ast::TypeUsage::new_unknown(&id_generator)},
|
|
LiteralStruct => ast::Expression{subexpression: Box::new(ast::Subexpression::LiteralStruct(<>)), type_: ast::TypeUsage::new_unknown(&id_generator)},
|
|
FunctionCall => ast::Expression{subexpression: Box::new(ast::Subexpression::FunctionCall(<>)), type_: ast::TypeUsage::new_unknown(&id_generator)},
|
|
StructGetter => ast::Expression{subexpression: Box::new(ast::Subexpression::StructGetter(<>)), type_: ast::TypeUsage::new_unknown(&id_generator)},
|
|
VariableUsage => ast::Expression{subexpression: Box::new(ast::Subexpression::VariableUsage(<>)), type_: ast::TypeUsage::new_unknown(&id_generator)},
|
|
IfExpression => ast::Expression{subexpression: Box::new(ast::Subexpression::If(<>)), type_: ast::TypeUsage::new_unknown(&id_generator)},
|
|
Block => ast::Expression{subexpression: Box::new(ast::Subexpression::Block(<>)), type_: ast::TypeUsage::new_unknown(&id_generator)},
|
|
"(" <e:Expression> ")" => e,
|
|
};
|
|
|
|
|
|
pub ReturnStatement: ast::ReturnStatement = {
|
|
"return" <e:Expression> => ast::ReturnStatement{source: e}
|
|
};
|
|
|
|
pub LetStatement: ast::LetStatement = {
|
|
//TODO: support destructuring with tuples, when they exist.
|
|
//TODO: add mut, weak
|
|
"let" <n:SpannedIdentifier> "=" <e:Expression> => ast::LetStatement{variable_name: n, type_: ast::TypeUsage::new_unknown(&id_generator), expression: e},
|
|
"let" <n:SpannedIdentifier> ":" <t:TypeUsage> "=" <e:Expression> => ast::LetStatement{variable_name: n, type_: t, expression: e},
|
|
};
|
|
|
|
pub AssignmentStatement: ast::AssignmentStatement = {
|
|
<v:VariableUsage> "=" <e:Expression> => ast::AssignmentStatement{source: ast::AssignmentTarget::Variable(v), expression: e},
|
|
<sg:StructGetter> "=" <e:Expression> => ast::AssignmentStatement{source: ast::AssignmentTarget::StructAttr(sg), expression: e},
|
|
};
|
|
|
|
pub Statement: ast::Statement = {
|
|
<r:ReturnStatement> ";" => ast::Statement::Return(r),
|
|
<l:LetStatement> ";" => ast::Statement::Let(l),
|
|
<a:AssignmentStatement> ";" => ast::Statement::Assignment(a),
|
|
<e:Expression> ";" => ast::Statement::Expression(e),
|
|
};
|
|
|
|
pub Block: ast::Block = {
|
|
"{" <v:(<Statement>)*> <e:Expression?> "}" => match e {
|
|
None => ast::Block{statements: v, type_: ast::TypeUsage::new_unknown(&id_generator)},
|
|
Some(e) => {
|
|
let mut v = v;
|
|
v.push(ast::Statement::Expression(e));
|
|
ast::Block{statements: v, type_: ast::TypeUsage::new_unknown(&id_generator)}
|
|
}
|
|
}
|
|
};
|
|
|
|
pub PartialNamedTypeUsage: ast::NamedTypeUsage = {
|
|
<n:SpannedIdentifier> <gu:GenericUsage?> => match gu {
|
|
Some(tp) => ast::NamedTypeUsage{type_parameters: tp, name: n},
|
|
None => ast::NamedTypeUsage{type_parameters: ast::GenericUsage::Unknown, name: n},
|
|
},
|
|
};
|
|
|
|
pub NamedTypeUsage: ast::NamedTypeUsage = {
|
|
<n:SpannedIdentifier> <gu:GenericUsage?> => match gu {
|
|
Some(tp) => ast::NamedTypeUsage{type_parameters: tp, name: n},
|
|
None => ast::NamedTypeUsage{type_parameters: ast::GenericUsage::new(&[]), name: n},
|
|
},
|
|
};
|
|
|
|
pub PartialTypeUsage: ast::TypeUsage = {
|
|
<n:PartialNamedTypeUsage> => ast::TypeUsage::Named(n),
|
|
"fn" "(" <args:Comma<PartialTypeUsage>> ")" => ast::TypeUsage::Function(ast::FunctionTypeUsage{arguments: args, return_type: Box::new(ast::new_unit())}),
|
|
"fn" "(" <args:Comma<PartialTypeUsage>> ")" ":" <rt:PartialTypeUsage> => ast::TypeUsage::Function(ast::FunctionTypeUsage{arguments: args, return_type: Box::new(rt)}),
|
|
};
|
|
|
|
pub TypeUsage: ast::TypeUsage = {
|
|
<n:NamedTypeUsage> => ast::TypeUsage::Named(n),
|
|
"fn" "(" <args:Comma<TypeUsage>> ")" => ast::TypeUsage::Function(ast::FunctionTypeUsage{arguments: args, return_type: Box::new(ast::new_unit())}),
|
|
"fn" "(" <args:Comma<TypeUsage>> ")" ":" <rt:TypeUsage> => ast::TypeUsage::Function(ast::FunctionTypeUsage{arguments: args, return_type: Box::new(rt)}),
|
|
};
|
|
|
|
pub VariableDeclaration: ast::VariableDeclaration = {
|
|
<i:SpannedIdentifier> ":" <t:TypeUsage> => ast::VariableDeclaration{name: i, type_: t},
|
|
};
|
|
|
|
pub GenericParameter: ast::GenericParameter = {
|
|
<i:SpannedIdentifier> => ast::GenericParameter{name: i, bounds: vec!()},
|
|
<i:SpannedIdentifier> ":" <bounds:PlusSeparated<SpannedIdentifier>> => ast::GenericParameter{name: i, bounds: bounds},
|
|
};
|
|
|
|
pub Generic: ast::Generic = {
|
|
"[" <p:Comma<GenericParameter>> "]" => ast::Generic{parameters: p},
|
|
};
|
|
|
|
pub FunctionDeclaration: ast::FunctionDeclaration = {
|
|
"fn" <n:SpannedIdentifier> <g:Generic> "(" <args:Comma<VariableDeclaration>> ")" => ast::FunctionDeclaration{name: n, generic: g, arguments: args, return_type: ast::new_unit()},
|
|
"fn" <n:SpannedIdentifier> <g:Generic> "(" <args:Comma<VariableDeclaration>> ")" ":" <rt:TypeUsage> => ast::FunctionDeclaration{name: n, generic: g, arguments: args, return_type: rt},
|
|
"fn" <n:SpannedIdentifier> "(" <args:Comma<VariableDeclaration>> ")" => ast::FunctionDeclaration{name: n, generic: ast::Generic{parameters: vec!()}, arguments: args, return_type: ast::new_unit()},
|
|
"fn" <n:SpannedIdentifier> "(" <args:Comma<VariableDeclaration>> ")" ":" <rt:TypeUsage> => ast::FunctionDeclaration{name: n, generic: ast::Generic{parameters: vec!()}, arguments: args, return_type: rt},
|
|
};
|
|
|
|
pub Function: ast::Function = {
|
|
<d:FunctionDeclaration> <b:Block> => ast::Function{declaration: d, block: b}
|
|
};
|
|
|
|
pub StructField: ast::StructField = {
|
|
<i:SpannedIdentifier> ":" <t:TypeUsage> => ast::StructField{name: i, type_: t},
|
|
};
|
|
|
|
pub StructTypeDeclaration: ast::StructTypeDeclaration = {
|
|
"type" <i:SpannedIdentifier> <g:Generic?> "struct" "{" <f:Comma<StructField>> "}" => match g {
|
|
Some(generic) => ast::StructTypeDeclaration{name: i, generic: generic, fields: f},
|
|
None => ast::StructTypeDeclaration{name: i, generic: ast::Generic{parameters: vec!()}, fields: f},
|
|
}
|
|
};
|
|
|
|
pub AliasTypeDeclaration: ast::AliasTypeDeclaration = {
|
|
"type" <i:SpannedIdentifier> "=" <t:TypeUsage> ";" => ast::AliasTypeDeclaration{name: i, replaces: t}
|
|
};
|
|
|
|
pub TraitItem: ast::TraitItem = {
|
|
<fd:FunctionDeclaration> ";" => ast::TraitItem::FunctionDeclaration(fd),
|
|
<f:Function> => ast::TraitItem::Function(f),
|
|
};
|
|
|
|
pub TraitTypeDeclaration: ast::TraitTypeDeclaration = {
|
|
"type" <i:SpannedIdentifier> <g:Generic> "trait" "{" <ti:TraitItem*> "}" => ast::TraitTypeDeclaration{name: i, generic: g, functions: ti},
|
|
"type" <i:SpannedIdentifier> "trait" "{" <ti:TraitItem*> "}" => ast::TraitTypeDeclaration{name: i, generic: ast::Generic{parameters: vec!()}, functions: ti},
|
|
};
|
|
|
|
pub TypeDeclaration: ast::TypeDeclaration = {
|
|
<s:StructTypeDeclaration> => ast::TypeDeclaration::Struct(s),
|
|
<a:AliasTypeDeclaration> => ast::TypeDeclaration::Alias(a),
|
|
<t:TraitTypeDeclaration> => ast::TypeDeclaration::Trait(t),
|
|
};
|
|
|
|
pub Impl: ast::Impl = {
|
|
"impl" <g:Generic?> <s:NamedTypeUsage> "{" <f:Function*> "}" => {
|
|
let generic = match g {
|
|
Some(g) => g,
|
|
None => ast::Generic{parameters: vec!()},
|
|
};
|
|
ast::Impl{generic: generic, trait_: None, struct_: s, functions: f}
|
|
},
|
|
"impl" <g:Generic?> <t:NamedTypeUsage> "for" <s:NamedTypeUsage> "{" <f:Function*> "}" => {
|
|
let generic = match g {
|
|
Some(g) => g,
|
|
None => ast::Generic{parameters: vec!()},
|
|
};
|
|
ast::Impl{generic: generic, trait_: Some(t), struct_: s, functions: f}
|
|
}
|
|
};
|
|
|
|
pub ModuleItem: ast::ModuleItem = {
|
|
<f:Function> => ast::ModuleItem::Function(f),
|
|
<td:TypeDeclaration> => ast::ModuleItem::TypeDeclaration(td),
|
|
<i:Impl> => ast::ModuleItem::Impl(i),
|
|
};
|
|
|
|
pub Module: ast::Module = {
|
|
<i:ModuleItem*> => ast::Module{items: i}
|
|
};
|
|
|
|
// From https://lalrpop.github.io/lalrpop/tutorial/006_macros.html
|
|
// Comma separated list of T with optional trailing comma
|
|
Comma<T>: Vec<T> = {
|
|
<v:(<T> ",")*> <e:T?> => match e {
|
|
None => v,
|
|
Some(e) => {
|
|
let mut v = v;
|
|
v.push(e);
|
|
v
|
|
}
|
|
}
|
|
};
|
|
|
|
// PlusSeparated separated list of T with optional trailing comma
|
|
PlusSeparated<T>: Vec<T> = {
|
|
<v:(<T> "+")*> <e:T?> => match e {
|
|
None => v,
|
|
Some(e) => {
|
|
let mut v = v;
|
|
v.push(e);
|
|
v
|
|
}
|
|
}
|
|
};
|
|
|
|
Spanned<Rule>: ast::Spanned<Rule> = {
|
|
<l: @L> <rule: Rule> <r: @R> => ast::Spanned{span: ast::Span{left: l, right: r}, value: rule}
|
|
};
|