1298 lines
41 KiB
Rust
1298 lines
41 KiB
Rust
use crate::ast::*;
|
|
use crate::parser::Rule;
|
|
use pest::iterators::{Pair, Pairs};
|
|
|
|
fn expect_and_use<T>(
|
|
file_id: usize,
|
|
pair: Pair<Rule>,
|
|
rule: Rule,
|
|
f: fn(usize, Pair<Rule>) -> T,
|
|
) -> T {
|
|
if pair.as_rule() != rule {
|
|
panic!("Expected rule {:?} but found {:?}", rule, pair.as_rule())
|
|
}
|
|
f(file_id, pair)
|
|
}
|
|
|
|
pub fn build_ast(file_id: usize, compilation_unit_pair: Pair<Rule>) -> CompilationUnit {
|
|
build_compilation_unit(file_id, compilation_unit_pair)
|
|
}
|
|
|
|
fn build_identifier(file_id: usize, identifier_pair: Pair<Rule>) -> Identifier {
|
|
let as_span = identifier_pair.as_span();
|
|
Identifier::new(
|
|
as_span.as_str(),
|
|
file_id,
|
|
Range {
|
|
start: as_span.start(),
|
|
end: as_span.end(),
|
|
},
|
|
)
|
|
}
|
|
|
|
fn build_fqn(file_id: usize, fqn_pair: Pair<Rule>) -> FullyQualifiedName {
|
|
let as_span = fqn_pair.as_span();
|
|
FullyQualifiedName::new(
|
|
fqn_pair
|
|
.into_inner()
|
|
.map(|identifier_pair| {
|
|
expect_and_use(file_id, identifier_pair, Rule::Identifier, build_identifier)
|
|
})
|
|
.collect(),
|
|
file_id,
|
|
Range {
|
|
start: as_span.start(),
|
|
end: as_span.end(),
|
|
},
|
|
)
|
|
}
|
|
|
|
fn build_type_use(file_id: usize, type_use_pair: Pair<Rule>) -> TypeUse {
|
|
let inner_pair = type_use_pair.into_inner().next().unwrap();
|
|
match inner_pair.as_rule() {
|
|
Rule::Void => TypeUse::Void,
|
|
Rule::InterfaceOrClassTypeUse => {
|
|
TypeUse::InterfaceOrClass(build_interface_or_class_type_use(file_id, inner_pair))
|
|
}
|
|
Rule::TupleTypeUse => TypeUse::Tuple(build_tuple_type_use(file_id, inner_pair)),
|
|
Rule::FunctionTypeUse => TypeUse::Function(build_function_type_use(file_id, inner_pair)),
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
|
|
fn build_interface_or_class_type_use(file_id: usize, pair: Pair<Rule>) -> InterfaceOrClassTypeUse {
|
|
let mut borrow_count = 0;
|
|
let mut is_mutable = false;
|
|
let mut fqn = None;
|
|
let mut generic_arguments = GenericArguments::default();
|
|
|
|
for inner_pair in pair.into_inner() {
|
|
match inner_pair.as_rule() {
|
|
Rule::Borrow => {
|
|
borrow_count += 1;
|
|
}
|
|
Rule::Mut => {
|
|
is_mutable = true;
|
|
}
|
|
Rule::FullyQualifiedName => {
|
|
fqn = Some(build_fqn(file_id, inner_pair));
|
|
}
|
|
Rule::GenericArguments => {
|
|
generic_arguments = build_generic_arguments(file_id, inner_pair);
|
|
}
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
|
|
InterfaceOrClassTypeUse {
|
|
borrow_count,
|
|
is_mutable,
|
|
fqn: fqn.unwrap(),
|
|
generics: generic_arguments,
|
|
}
|
|
}
|
|
|
|
fn build_tuple_type_use(file_id: usize, tuple_type_use_pair: Pair<Rule>) -> TupleTypeUse {
|
|
let mut borrow_count = 0;
|
|
let mut is_mutable = false;
|
|
let mut arguments = None;
|
|
|
|
for inner_pair in tuple_type_use_pair.into_inner() {
|
|
match inner_pair.as_rule() {
|
|
Rule::Borrow => {
|
|
borrow_count += 1;
|
|
}
|
|
Rule::Mut => {
|
|
is_mutable = true;
|
|
}
|
|
Rule::TupleArguments => {
|
|
arguments = Some(build_tuple_arguments(file_id, inner_pair));
|
|
}
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
|
|
TupleTypeUse {
|
|
borrow_count,
|
|
is_mutable,
|
|
arguments: arguments.unwrap(),
|
|
}
|
|
}
|
|
|
|
fn build_function_type_use(file_id: usize, function_pair: Pair<Rule>) -> FunctionTypeUse {
|
|
let mut borrow_count = 0;
|
|
let mut function_modifier: Option<FunctionTypeModifier> = None;
|
|
let mut generics = GenericParameters::default();
|
|
let mut parameters: Option<Parameters> = None;
|
|
let mut return_type: Option<ReturnType> = None;
|
|
|
|
for inner_pair in function_pair.into_inner() {
|
|
match inner_pair.as_rule() {
|
|
Rule::Borrow => {
|
|
borrow_count += 1;
|
|
}
|
|
Rule::FunctionTypeModifier => {
|
|
function_modifier = Some(build_function_type_modifier(file_id, inner_pair));
|
|
}
|
|
Rule::Fn => {}
|
|
Rule::GenericParameters => {
|
|
generics = build_generic_parameters(file_id, inner_pair);
|
|
}
|
|
Rule::Parameters => {
|
|
parameters = Some(build_parameters(file_id, inner_pair));
|
|
}
|
|
Rule::ReturnType => {
|
|
return_type = Some(build_return_type(file_id, inner_pair));
|
|
}
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
|
|
FunctionTypeUse {
|
|
borrow_count,
|
|
function_modifier,
|
|
generics,
|
|
parameters: parameters.unwrap(),
|
|
return_type: return_type.unwrap(),
|
|
}
|
|
}
|
|
|
|
fn build_generic_arguments(file_id: usize, generic_arguments_pair: Pair<Rule>) -> GenericArguments {
|
|
let type_use_list_pair = generic_arguments_pair.into_inner().next().unwrap();
|
|
GenericArguments(
|
|
type_use_list_pair
|
|
.into_inner()
|
|
.map(|type_use_pair| {
|
|
expect_and_use(file_id, type_use_pair, Rule::TypeUse, build_type_use)
|
|
})
|
|
.collect(),
|
|
)
|
|
}
|
|
|
|
fn build_generic_parameters(
|
|
file_id: usize,
|
|
generic_parameters_pair: Pair<Rule>,
|
|
) -> GenericParameters {
|
|
let identifier_list_pair = generic_parameters_pair.into_inner().next().unwrap();
|
|
GenericParameters(
|
|
identifier_list_pair
|
|
.into_inner()
|
|
.map(|identifier_pair| {
|
|
expect_and_use(file_id, identifier_pair, Rule::Identifier, build_identifier)
|
|
})
|
|
.collect(),
|
|
)
|
|
}
|
|
|
|
fn build_tuple_arguments(file_id: usize, tuple_arguments_pair: Pair<Rule>) -> TupleArguments {
|
|
let parentheses_optional_type_use_list_pair = tuple_arguments_pair.into_inner().next().unwrap();
|
|
let type_use_list_pair = parentheses_optional_type_use_list_pair
|
|
.into_inner()
|
|
.next()
|
|
.unwrap();
|
|
|
|
TupleArguments(
|
|
type_use_list_pair
|
|
.into_inner()
|
|
.map(|type_use_pair| {
|
|
expect_and_use(file_id, type_use_pair, Rule::TypeUse, build_type_use)
|
|
})
|
|
.collect(),
|
|
)
|
|
}
|
|
|
|
fn build_implements_list(file_id: usize, pair: Pair<Rule>) -> ImplementsList {
|
|
ImplementsList(
|
|
pair.into_inner()
|
|
.map(|type_use_pair| {
|
|
expect_and_use(file_id, type_use_pair, Rule::TypeUse, build_type_use)
|
|
})
|
|
.collect(),
|
|
)
|
|
}
|
|
|
|
fn build_function_type_modifier(file_id: usize, pair: Pair<Rule>) -> FunctionTypeModifier {
|
|
let mut inner = pair.into_inner();
|
|
if inner.len() == 2 {
|
|
FunctionTypeModifier::MutRef
|
|
} else {
|
|
match inner.next().unwrap().as_rule() {
|
|
Rule::Cons => FunctionTypeModifier::Cons,
|
|
Rule::Mut => FunctionTypeModifier::Mut,
|
|
Rule::Ref => FunctionTypeModifier::Ref,
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
}
|
|
|
|
fn build_parameters(file_id: usize, parameters_pair: Pair<Rule>) -> Parameters {
|
|
Parameters(
|
|
parameters_pair
|
|
.into_inner()
|
|
.map(|parameter_pair| {
|
|
expect_and_use(file_id, parameter_pair, Rule::Parameter, build_parameter)
|
|
})
|
|
.collect(),
|
|
)
|
|
}
|
|
|
|
fn build_parameter(file_id: usize, parameter_pair: Pair<Rule>) -> Parameter {
|
|
let mut inner = parameter_pair.into_inner();
|
|
let identifier = expect_and_use(
|
|
file_id,
|
|
inner.next().unwrap(),
|
|
Rule::Identifier,
|
|
build_identifier,
|
|
);
|
|
let type_use = expect_and_use(
|
|
file_id,
|
|
inner.next().unwrap(),
|
|
Rule::TypeUse,
|
|
build_type_use,
|
|
);
|
|
Parameter {
|
|
identifier,
|
|
type_use,
|
|
}
|
|
}
|
|
|
|
fn build_return_type(file_id: usize, return_type_pair: Pair<Rule>) -> ReturnType {
|
|
let mut inner = return_type_pair.into_inner();
|
|
|
|
let declared_type = expect_and_use(
|
|
file_id,
|
|
inner.next().unwrap(),
|
|
Rule::TypeUse,
|
|
build_type_use,
|
|
);
|
|
|
|
let references = inner
|
|
.next()
|
|
.map(|ref_list_pair| {
|
|
expect_and_use(file_id, ref_list_pair, Rule::RefList, build_references)
|
|
})
|
|
.unwrap_or_else(References::default);
|
|
|
|
ReturnType {
|
|
declared_type: Box::new(declared_type),
|
|
references,
|
|
}
|
|
}
|
|
|
|
fn build_references(file_id: usize, ref_list_pair: Pair<Rule>) -> References {
|
|
let mut inner = ref_list_pair.into_inner();
|
|
inner.next().unwrap(); // ref
|
|
|
|
References(
|
|
inner
|
|
.map(|identifier_pair| {
|
|
expect_and_use(file_id, identifier_pair, Rule::Identifier, build_identifier)
|
|
})
|
|
.collect(),
|
|
)
|
|
}
|
|
|
|
fn build_compilation_unit(file_id: usize, compilation_unit_pair: Pair<Rule>) -> CompilationUnit {
|
|
let mut namespace = None;
|
|
let mut declarations = vec![];
|
|
|
|
for inner_pair in compilation_unit_pair.into_inner() {
|
|
match inner_pair.as_rule() {
|
|
Rule::Namespace => {
|
|
namespace = Some(build_namespace(file_id, inner_pair));
|
|
}
|
|
Rule::ModuleLevelDeclaration => {
|
|
declarations.push(build_module_level_declaration(file_id, inner_pair));
|
|
}
|
|
Rule::EOI => {}
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
|
|
CompilationUnit {
|
|
namespace,
|
|
declarations,
|
|
}
|
|
}
|
|
|
|
fn build_namespace(file_id: usize, namespace_pair: Pair<Rule>) -> FullyQualifiedName {
|
|
let mut inner = namespace_pair.into_inner();
|
|
inner.next(); // ns
|
|
expect_and_use(
|
|
file_id,
|
|
inner.next().unwrap(),
|
|
Rule::FullyQualifiedName,
|
|
build_fqn,
|
|
)
|
|
}
|
|
|
|
fn build_module_level_declaration(file_id: usize, pair: Pair<Rule>) -> ModuleLevelDeclaration {
|
|
let inner_pair = pair.into_inner().next().unwrap();
|
|
match inner_pair.as_rule() {
|
|
Rule::Module => {
|
|
ModuleLevelDeclaration::Module(build_module_declaration(file_id, inner_pair))
|
|
}
|
|
Rule::Interface => {
|
|
ModuleLevelDeclaration::Interface(build_interface_declaration(file_id, inner_pair))
|
|
}
|
|
Rule::Class => ModuleLevelDeclaration::Class(build_class_declaration(file_id, inner_pair)),
|
|
Rule::FunctionDefinition => {
|
|
ModuleLevelDeclaration::Function(build_function_definition(file_id, inner_pair))
|
|
}
|
|
Rule::PlatformFunction => ModuleLevelDeclaration::PlatformFunction(
|
|
build_platform_function_declaration(file_id, inner_pair),
|
|
),
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
|
|
fn build_interface_level_declaration(
|
|
file_id: usize,
|
|
declaration_pair: Pair<Rule>,
|
|
) -> InterfaceLevelDeclaration {
|
|
let inner_pair = declaration_pair.into_inner().next().unwrap();
|
|
match inner_pair.as_rule() {
|
|
Rule::Module => {
|
|
InterfaceLevelDeclaration::Module(build_module_declaration(file_id, inner_pair))
|
|
}
|
|
Rule::Interface => {
|
|
InterfaceLevelDeclaration::Interface(build_interface_declaration(file_id, inner_pair))
|
|
}
|
|
Rule::Class => {
|
|
InterfaceLevelDeclaration::Class(build_class_declaration(file_id, inner_pair))
|
|
}
|
|
Rule::InterfaceFunction => InterfaceLevelDeclaration::Function(
|
|
build_interface_function_declaration(file_id, inner_pair),
|
|
),
|
|
Rule::InterfaceDefaultFunction => InterfaceLevelDeclaration::Function(
|
|
build_default_interface_function_declaration(file_id, inner_pair),
|
|
),
|
|
Rule::InterfaceOperatorFunction => InterfaceLevelDeclaration::OperatorFunction(
|
|
build_interface_operator_function_declaration(file_id, inner_pair),
|
|
),
|
|
Rule::InterfaceDefaultOperatorFunction => InterfaceLevelDeclaration::OperatorFunction(
|
|
build_default_interface_operator_function_declaration(file_id, inner_pair),
|
|
),
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
|
|
fn build_class_level_declaration(
|
|
file_id: usize,
|
|
declaration_pair: Pair<Rule>,
|
|
) -> ClassLevelDeclaration {
|
|
let inner_pair = declaration_pair.into_inner().next().unwrap();
|
|
match inner_pair.as_rule() {
|
|
Rule::Module => {
|
|
ClassLevelDeclaration::Module(build_module_declaration(file_id, inner_pair))
|
|
}
|
|
Rule::Interface => {
|
|
ClassLevelDeclaration::Interface(build_interface_declaration(file_id, inner_pair))
|
|
}
|
|
Rule::Class => ClassLevelDeclaration::Class(build_class_declaration(file_id, inner_pair)),
|
|
Rule::FunctionDefinition => {
|
|
ClassLevelDeclaration::Function(build_function_definition(file_id, inner_pair))
|
|
}
|
|
Rule::OperatorFunctionDefinition => ClassLevelDeclaration::OperatorFunction(
|
|
build_operator_function_declaration(file_id, inner_pair),
|
|
),
|
|
Rule::PlatformFunction => ClassLevelDeclaration::PlatformFunction(
|
|
build_platform_function_declaration(file_id, inner_pair),
|
|
),
|
|
Rule::Property => {
|
|
ClassLevelDeclaration::Property(build_property_declaration(file_id, inner_pair))
|
|
}
|
|
Rule::Field => ClassLevelDeclaration::Field(build_field_declaration(file_id, inner_pair)),
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
|
|
fn build_module_declaration(file_id: usize, module_pair: Pair<Rule>) -> ModuleDeclaration {
|
|
let mut is_public = false;
|
|
let mut identifier = None;
|
|
let mut declarations = vec![];
|
|
|
|
for inner_pair in module_pair.into_inner() {
|
|
match inner_pair.as_rule() {
|
|
Rule::Pub => {
|
|
is_public = true;
|
|
}
|
|
Rule::Mod => {}
|
|
Rule::Identifier => {
|
|
identifier = Some(build_identifier(file_id, inner_pair));
|
|
}
|
|
Rule::ModuleLevelDeclaration => {
|
|
declarations.push(build_module_level_declaration(file_id, inner_pair));
|
|
}
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
|
|
ModuleDeclaration {
|
|
is_public,
|
|
identifier: identifier.unwrap(),
|
|
declarations,
|
|
}
|
|
}
|
|
|
|
fn build_interface_declaration(file_id: usize, interface_pair: Pair<Rule>) -> InterfaceDeclaration {
|
|
let mut is_public = false;
|
|
let mut identifier = None;
|
|
let mut generics = None;
|
|
let mut implements = None;
|
|
let mut declarations = vec![];
|
|
|
|
for inner_pair in interface_pair.into_inner() {
|
|
match inner_pair.as_rule() {
|
|
Rule::Pub => {
|
|
is_public = true;
|
|
}
|
|
Rule::Int => {}
|
|
Rule::Identifier => {
|
|
identifier = Some(build_identifier(file_id, inner_pair));
|
|
}
|
|
Rule::GenericParameters => {
|
|
generics = Some(build_generic_parameters(file_id, inner_pair));
|
|
}
|
|
Rule::ImplementsList => {
|
|
implements = Some(build_implements_list(file_id, inner_pair));
|
|
}
|
|
Rule::InterfaceLevelDeclaration => {
|
|
declarations.push(build_interface_level_declaration(file_id, inner_pair));
|
|
}
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
|
|
InterfaceDeclaration {
|
|
is_public,
|
|
identifier: identifier.unwrap(),
|
|
generics: generics.unwrap_or_else(GenericParameters::default),
|
|
implements: implements.unwrap_or_else(ImplementsList::default),
|
|
declarations,
|
|
}
|
|
}
|
|
|
|
fn build_class_declaration(file_id: usize, class_pair: Pair<Rule>) -> ClassDeclaration {
|
|
let mut is_public = false;
|
|
let mut identifier = None;
|
|
let mut generics = None;
|
|
let mut class_constructor = None;
|
|
let mut implements = None;
|
|
let mut declarations = vec![];
|
|
|
|
for inner_pair in class_pair.into_inner() {
|
|
match inner_pair.as_rule() {
|
|
Rule::Pub => {
|
|
is_public = true;
|
|
}
|
|
Rule::ClassKw => {}
|
|
Rule::Identifier => {
|
|
identifier = Some(build_identifier(file_id, inner_pair));
|
|
}
|
|
Rule::GenericParameters => {
|
|
generics = Some(build_generic_parameters(file_id, inner_pair));
|
|
}
|
|
Rule::ClassConstructor => {
|
|
class_constructor = Some(build_class_constructor(file_id, inner_pair));
|
|
}
|
|
Rule::ImplementsList => {
|
|
implements = Some(build_implements_list(file_id, inner_pair));
|
|
}
|
|
Rule::ClassLevelDeclaration => {
|
|
declarations.push(build_class_level_declaration(file_id, inner_pair));
|
|
}
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
|
|
ClassDeclaration {
|
|
is_public,
|
|
identifier: identifier.unwrap(),
|
|
generics: generics.unwrap_or_else(GenericParameters::default),
|
|
class_constructor,
|
|
implements: implements.unwrap_or_else(ImplementsList::default),
|
|
declarations,
|
|
}
|
|
}
|
|
|
|
fn build_function_definition(
|
|
file_id: usize,
|
|
function_definition_pair: Pair<Rule>,
|
|
) -> FunctionDefinition {
|
|
let mut is_public = false;
|
|
let mut modifier = None;
|
|
let mut generics = None;
|
|
let mut identifier = None;
|
|
let mut parameters = None;
|
|
let mut return_type = None;
|
|
let mut body = None;
|
|
|
|
for inner_pair in function_definition_pair.into_inner() {
|
|
match inner_pair.as_rule() {
|
|
Rule::Pub => {
|
|
is_public = true;
|
|
}
|
|
Rule::FunctionModifier => {
|
|
modifier = Some(build_function_modifier(file_id, inner_pair));
|
|
}
|
|
Rule::Fn => {}
|
|
Rule::GenericParameters => {
|
|
generics = Some(build_generic_parameters(file_id, inner_pair));
|
|
}
|
|
Rule::Identifier => {
|
|
identifier = Some(build_identifier(file_id, inner_pair));
|
|
}
|
|
Rule::Parameters => {
|
|
parameters = Some(build_parameters(file_id, inner_pair));
|
|
}
|
|
Rule::ReturnType => {
|
|
return_type = Some(build_return_type(file_id, inner_pair));
|
|
}
|
|
Rule::FunctionBody => {
|
|
body = Some(build_function_body(file_id, inner_pair));
|
|
}
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
|
|
FunctionDefinition {
|
|
is_public,
|
|
modifier,
|
|
generics: generics.unwrap_or_else(GenericParameters::default),
|
|
identifier: identifier.unwrap(),
|
|
parameters: parameters.unwrap(),
|
|
return_type: return_type.unwrap_or_else(ReturnType::void),
|
|
body: body.unwrap(),
|
|
}
|
|
}
|
|
|
|
fn build_operator_function_declaration(
|
|
file_id: usize,
|
|
operator_function_pair: Pair<Rule>,
|
|
) -> OperatorFunctionDefinition {
|
|
todo!()
|
|
}
|
|
|
|
fn build_platform_function_declaration(
|
|
file_id: usize,
|
|
platform_function_pair: Pair<Rule>,
|
|
) -> PlatformFunctionDeclaration {
|
|
todo!()
|
|
}
|
|
|
|
fn build_interface_function_declaration(
|
|
file_id: usize,
|
|
interface_function_pair: Pair<Rule>,
|
|
) -> InterfaceFunctionDeclaration {
|
|
todo!()
|
|
}
|
|
|
|
fn build_interface_operator_function_declaration(
|
|
file_id: usize,
|
|
interface_operator_pair: Pair<Rule>,
|
|
) -> InterfaceOperatorFunctionDeclaration {
|
|
todo!()
|
|
}
|
|
|
|
fn build_default_interface_function_declaration(
|
|
file_id: usize,
|
|
default_interface_function_pair: Pair<Rule>,
|
|
) -> InterfaceFunctionDeclaration {
|
|
todo!()
|
|
}
|
|
|
|
fn build_default_interface_operator_function_declaration(
|
|
file_id: usize,
|
|
default_interface_operator_pair: Pair<Rule>,
|
|
) -> InterfaceOperatorFunctionDeclaration {
|
|
todo!()
|
|
}
|
|
|
|
fn build_class_constructor(file_id: usize, class_constructor_pair: Pair<Rule>) -> ClassConstructor {
|
|
ClassConstructor(
|
|
class_constructor_pair
|
|
.into_inner()
|
|
.map(|data_member_pair| {
|
|
let inner_pair = data_member_pair.into_inner().next().unwrap();
|
|
match inner_pair.as_rule() {
|
|
Rule::Property => {
|
|
build_property_class_constructor_parameter(file_id, inner_pair)
|
|
}
|
|
Rule::Field => build_field_class_constructor_parameter(file_id, inner_pair),
|
|
_ => unreachable!(),
|
|
}
|
|
})
|
|
.collect(),
|
|
)
|
|
}
|
|
|
|
fn build_function_modifier(file_id: usize, modifier_pair: Pair<Rule>) -> FunctionModifier {
|
|
let mut inner = modifier_pair.into_inner();
|
|
if inner.len() == 2 {
|
|
FunctionModifier::MutRef
|
|
} else {
|
|
match inner.next().unwrap().as_rule() {
|
|
Rule::Static => FunctionModifier::Static,
|
|
Rule::Cons => FunctionModifier::Cons,
|
|
Rule::Mut => FunctionModifier::Mut,
|
|
Rule::Ref => FunctionModifier::Ref,
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
}
|
|
|
|
fn build_function_body(file_id: usize, body_pair: Pair<Rule>) -> FunctionBody {
|
|
let inner_pair = body_pair.into_inner().next().unwrap();
|
|
match inner_pair.as_rule() {
|
|
Rule::FunctionEqualsBody => FunctionBody::Equals(expect_and_use(
|
|
file_id,
|
|
inner_pair.into_inner().next().unwrap(),
|
|
Rule::Expression,
|
|
build_expression,
|
|
)),
|
|
Rule::BlockStatement => FunctionBody::Block(build_block_statement(file_id, inner_pair)),
|
|
Rule::FunctionAliasBody => {
|
|
let mut alias_body_pairs = inner_pair.into_inner();
|
|
alias_body_pairs.next().unwrap(); // Alias
|
|
FunctionBody::Alias(expect_and_use(
|
|
file_id,
|
|
alias_body_pairs.next().unwrap(),
|
|
Rule::Identifier,
|
|
build_identifier,
|
|
))
|
|
}
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
|
|
fn build_property_class_constructor_parameter(
|
|
file_id: usize,
|
|
property_pair: Pair<Rule>,
|
|
) -> ClassConstructorParameter {
|
|
ClassConstructorParameter::Property(build_property_declaration(file_id, property_pair))
|
|
}
|
|
|
|
fn build_field_class_constructor_parameter(
|
|
file_id: usize,
|
|
field_pair: Pair<Rule>,
|
|
) -> ClassConstructorParameter {
|
|
ClassConstructorParameter::Field(build_field_declaration(file_id, field_pair))
|
|
}
|
|
|
|
fn build_property_declaration(
|
|
file_id: usize,
|
|
property_declaration_pair: Pair<Rule>,
|
|
) -> PropertyDeclaration {
|
|
let mut is_mutable = false;
|
|
let mut identifier = None;
|
|
let mut declared_type = None;
|
|
|
|
for inner_pair in property_declaration_pair.into_inner() {
|
|
match inner_pair.as_rule() {
|
|
Rule::Mut => {
|
|
is_mutable = true;
|
|
}
|
|
Rule::Identifier => {
|
|
identifier = Some(build_identifier(file_id, inner_pair));
|
|
}
|
|
Rule::TypeUse => {
|
|
declared_type = Some(build_type_use(file_id, inner_pair));
|
|
}
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
|
|
PropertyDeclaration {
|
|
is_mutable,
|
|
identifier: identifier.unwrap(),
|
|
declared_type: declared_type.unwrap(),
|
|
}
|
|
}
|
|
|
|
fn build_field_declaration(file_id: usize, field_pair: Pair<Rule>) -> FieldDeclaration {
|
|
let mut is_mutable = false;
|
|
let mut identifier = None;
|
|
let mut declared_type = None;
|
|
|
|
for inner_pair in field_pair.into_inner() {
|
|
match inner_pair.as_rule() {
|
|
Rule::Mut => {
|
|
is_mutable = true;
|
|
}
|
|
Rule::Fld => {}
|
|
Rule::Identifier => {
|
|
identifier = Some(build_identifier(file_id, inner_pair));
|
|
}
|
|
Rule::TypeUse => {
|
|
declared_type = Some(build_type_use(file_id, inner_pair));
|
|
}
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
|
|
FieldDeclaration {
|
|
is_mutable,
|
|
identifier: identifier.unwrap(),
|
|
declared_type: declared_type.unwrap(),
|
|
}
|
|
}
|
|
|
|
fn build_block_statement(file_id: usize, block_statement_pair: Pair<Rule>) -> BlockStatement {
|
|
let mut statements = vec![];
|
|
let mut expression = None;
|
|
|
|
for inner_pair in block_statement_pair.into_inner() {
|
|
match inner_pair.as_rule() {
|
|
Rule::Statement => {
|
|
statements.push(build_statement(file_id, inner_pair));
|
|
}
|
|
Rule::Expression => {
|
|
expression = Some(build_expression(file_id, inner_pair));
|
|
}
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
|
|
BlockStatement {
|
|
statements,
|
|
expression,
|
|
}
|
|
}
|
|
|
|
fn build_statement(file_id: usize, statement_pair: Pair<Rule>) -> Statement {
|
|
let first = statement_pair.into_inner().next().unwrap();
|
|
match first.as_rule() {
|
|
Rule::BlockStatement => Statement::BlockStatement(build_block_statement(file_id, first)),
|
|
Rule::VariableDeclaration => {
|
|
Statement::VariableDeclarationStatement(build_variable_declaration(file_id, first))
|
|
}
|
|
Rule::AssignmentStatement => {
|
|
Statement::AssignStatement(build_assignment_statement(file_id, first))
|
|
}
|
|
Rule::CallStatement => Statement::CallStatement(build_call_statement(file_id, first)),
|
|
Rule::ReturnStatement => Statement::ReturnStatement(build_return_statement(file_id, first)),
|
|
Rule::IfStatement => Statement::IfStatement(build_if_statement(file_id, first)),
|
|
Rule::IfElseStatement => {
|
|
Statement::IfElseStatement(build_if_else_statement(file_id, first))
|
|
}
|
|
Rule::WhileStatement => Statement::WhileStatement(build_while_statement(file_id, first)),
|
|
Rule::ForStatement => Statement::ForStatement(build_for_statement(file_id, first)),
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
|
|
fn build_variable_declaration(
|
|
file_id: usize,
|
|
variable_declaration_pair: Pair<Rule>,
|
|
) -> VariableDeclarationStatement {
|
|
let mut is_mutable = false;
|
|
let mut identifier = None;
|
|
let mut declared_type = None;
|
|
let mut initializer = None;
|
|
|
|
for inner_pair in variable_declaration_pair.into_inner() {
|
|
match inner_pair.as_rule() {
|
|
Rule::Let => {}
|
|
Rule::Mut => {
|
|
is_mutable = true;
|
|
}
|
|
Rule::Identifier => {
|
|
identifier = Some(build_identifier(file_id, inner_pair));
|
|
}
|
|
Rule::TypeUse => {
|
|
declared_type = Some(build_type_use(file_id, inner_pair));
|
|
}
|
|
Rule::Expression => {
|
|
initializer = Some(build_expression(file_id, inner_pair));
|
|
}
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
|
|
VariableDeclarationStatement {
|
|
is_mutable,
|
|
identifier: identifier.unwrap(),
|
|
declared_type,
|
|
initializer,
|
|
}
|
|
}
|
|
|
|
fn build_assignment_statement(file_id: usize, assignment_pair: Pair<Rule>) -> AssignStatement {
|
|
let mut inner = assignment_pair.into_inner();
|
|
let lhs = build_expression(file_id, inner.next().unwrap());
|
|
let rhs = build_expression(file_id, inner.next().unwrap());
|
|
AssignStatement { lhs, rhs }
|
|
}
|
|
|
|
fn build_call_statement(file_id: usize, call_statement_pair: Pair<Rule>) -> CallStatement {
|
|
let mut inner = call_statement_pair.into_inner();
|
|
let mut result = expect_and_use(
|
|
file_id,
|
|
inner.next().unwrap(),
|
|
Rule::PrimaryExpression,
|
|
build_primary_expression,
|
|
);
|
|
|
|
while let Some(inner_pair) = inner.next() {
|
|
match inner_pair.as_rule() {
|
|
Rule::ObjectAccess => {
|
|
result = Expression::ObjectAccess(build_object_access(file_id, result, inner_pair));
|
|
}
|
|
Rule::ParenthesesCall => {
|
|
result = Expression::Call(build_call_expression(file_id, result, inner_pair));
|
|
}
|
|
Rule::PlusPlus => {
|
|
result = Expression::UnarySuffix(SuffixExpression {
|
|
expression: Box::new(result),
|
|
operator: SuffixUnaryOperator::PlusPlus,
|
|
});
|
|
}
|
|
Rule::MinusMinus => {
|
|
result = Expression::UnarySuffix(SuffixExpression {
|
|
expression: Box::new(result),
|
|
operator: SuffixUnaryOperator::MinusMinus,
|
|
});
|
|
}
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
|
|
CallStatement(result)
|
|
}
|
|
|
|
fn build_return_statement(file_id: usize, return_statement_pair: Pair<Rule>) -> ReturnStatement {
|
|
todo!()
|
|
}
|
|
|
|
fn build_if_statement(file_id: usize, if_statement_pair: Pair<Rule>) -> IfStatement {
|
|
todo!()
|
|
}
|
|
|
|
fn build_if_else_statement(file_id: usize, if_else_statement_pair: Pair<Rule>) -> IfElseStatement {
|
|
todo!()
|
|
}
|
|
|
|
fn build_while_statement(file_id: usize, while_statement_pair: Pair<Rule>) -> WhileStatement {
|
|
todo!()
|
|
}
|
|
|
|
fn build_for_statement(file_id: usize, for_statement_pair: Pair<Rule>) -> ForStatement {
|
|
todo!()
|
|
}
|
|
|
|
fn build_expression(file_id: usize, expression_pair: Pair<Rule>) -> Expression {
|
|
expect_and_use(
|
|
file_id,
|
|
expression_pair.into_inner().next().unwrap(),
|
|
Rule::TernaryExpression,
|
|
build_ternary_expression,
|
|
)
|
|
}
|
|
|
|
fn build_ternary_expression(file_id: usize, ternary_pair: Pair<Rule>) -> Expression {
|
|
let mut inner = ternary_pair.into_inner();
|
|
if inner.len() == 3 {
|
|
let condition = expect_and_use(
|
|
file_id,
|
|
inner.next().unwrap(),
|
|
Rule::OrExpression,
|
|
build_or_expression,
|
|
);
|
|
let true_expression = expect_and_use(
|
|
file_id,
|
|
inner.next().unwrap(),
|
|
Rule::Expression,
|
|
build_expression,
|
|
);
|
|
let false_expression = expect_and_use(
|
|
file_id,
|
|
inner.next().unwrap(),
|
|
Rule::Expression,
|
|
build_expression,
|
|
);
|
|
Expression::Ternary(TernaryExpression {
|
|
condition: Box::new(condition),
|
|
true_expression: Box::new(true_expression),
|
|
false_expression: Box::new(false_expression),
|
|
})
|
|
} else {
|
|
expect_and_use(
|
|
file_id,
|
|
inner.next().unwrap(),
|
|
Rule::OrExpression,
|
|
build_or_expression,
|
|
)
|
|
}
|
|
}
|
|
|
|
macro_rules! build_binary_expression {
|
|
( $file_id:expr, $pair:ident, $left_rule:expr, $left_fn:expr, $( $pat:pat => $arm:expr ),* $(,)? ) => {{
|
|
let mut inner: Pairs<Rule> = $pair.into_inner();
|
|
if inner.len() == 3 {
|
|
let left = expect_and_use($file_id, inner.next().unwrap(), $left_rule, $left_fn);
|
|
let op = inner.next().unwrap(); // op
|
|
let right = expect_and_use($file_id, inner.next().unwrap(), Rule::Expression, build_expression);
|
|
Expression::Binary(BinaryExpression {
|
|
left: Box::new(left),
|
|
operator: match op.as_rule() {
|
|
$( $pat => $arm, )*
|
|
_ => unreachable!(),
|
|
},
|
|
right: Box::new(right),
|
|
})
|
|
} else {
|
|
expect_and_use($file_id, inner.next().unwrap(), $left_rule, $left_fn)
|
|
}
|
|
}};
|
|
}
|
|
|
|
fn build_or_expression(file_id: usize, or_expression_pair: Pair<Rule>) -> Expression {
|
|
build_binary_expression!(
|
|
file_id,
|
|
or_expression_pair,
|
|
Rule::AndExpression,
|
|
build_and_expression,
|
|
Rule::Or => BinaryOperator::Or,
|
|
)
|
|
}
|
|
|
|
fn build_and_expression(file_id: usize, and_expression_pair: Pair<Rule>) -> Expression {
|
|
build_binary_expression!(file_id,
|
|
and_expression_pair,
|
|
Rule::ComparisonExpression,
|
|
build_comparison_expression,
|
|
Rule::And => BinaryOperator::And,
|
|
)
|
|
}
|
|
|
|
fn build_comparison_expression(
|
|
file_id: usize,
|
|
comparison_expression_pair: Pair<Rule>,
|
|
) -> Expression {
|
|
build_binary_expression!(file_id,
|
|
comparison_expression_pair,
|
|
Rule::ShiftExpression,
|
|
build_shift_expression,
|
|
Rule::Greater => BinaryOperator::Greater,
|
|
Rule::Less => BinaryOperator::Less,
|
|
Rule::GreaterEqual => BinaryOperator::GreaterEqual,
|
|
Rule::LessEqual => BinaryOperator::LessEqual,
|
|
Rule::EqualTo => BinaryOperator::EqualTo,
|
|
Rule::NotEqualTo => BinaryOperator::NotEqualTo,
|
|
)
|
|
}
|
|
|
|
fn build_shift_expression(file_id: usize, shift_expression_pair: Pair<Rule>) -> Expression {
|
|
build_binary_expression!(file_id,
|
|
shift_expression_pair,
|
|
Rule::AdditiveExpression,
|
|
build_additive_expression,
|
|
Rule::LeftShift => BinaryOperator::LeftShift,
|
|
Rule::RightShift => BinaryOperator::RightShift,
|
|
)
|
|
}
|
|
|
|
fn build_additive_expression(file_id: usize, add_expression_pair: Pair<Rule>) -> Expression {
|
|
build_binary_expression!(file_id,
|
|
add_expression_pair,
|
|
Rule::MultiplicativeExpression,
|
|
build_multiplicative_expression,
|
|
Rule::Add => BinaryOperator::Add,
|
|
Rule::Subtract => BinaryOperator::Subtract,
|
|
)
|
|
}
|
|
|
|
fn build_multiplicative_expression(
|
|
file_id: usize,
|
|
multiplicative_expression_pair: Pair<Rule>,
|
|
) -> Expression {
|
|
build_binary_expression!(file_id,
|
|
multiplicative_expression_pair,
|
|
Rule::PrefixExpression,
|
|
build_prefix_expression,
|
|
Rule::Multiply => BinaryOperator::Multiply,
|
|
Rule::Divide => BinaryOperator::Divide,
|
|
)
|
|
}
|
|
|
|
fn build_prefix_expression(file_id: usize, prefix_pair: Pair<Rule>) -> Expression {
|
|
let mut inner_rev = prefix_pair.into_inner().rev();
|
|
let mut result = expect_and_use(
|
|
file_id,
|
|
inner_rev.next().unwrap(),
|
|
Rule::SuffixExpression,
|
|
build_suffix_expression,
|
|
);
|
|
while let Some(prefix_pair) = inner_rev.next() {
|
|
match prefix_pair.as_rule() {
|
|
Rule::Spread => {
|
|
result = Expression::UnaryPrefix(PrefixExpression {
|
|
operator: PrefixUnaryOperator::Spread,
|
|
expression: Box::new(result),
|
|
});
|
|
}
|
|
Rule::BorrowMut => {
|
|
result = Expression::UnaryPrefix(PrefixExpression {
|
|
operator: PrefixUnaryOperator::BorrowMut,
|
|
expression: Box::new(result),
|
|
})
|
|
}
|
|
Rule::Borrow => {
|
|
result = Expression::UnaryPrefix(PrefixExpression {
|
|
operator: PrefixUnaryOperator::Borrow,
|
|
expression: Box::new(result),
|
|
})
|
|
}
|
|
Rule::Mut => {
|
|
result = Expression::UnaryPrefix(PrefixExpression {
|
|
operator: PrefixUnaryOperator::Mut,
|
|
expression: Box::new(result),
|
|
})
|
|
}
|
|
Rule::Not => {
|
|
result = Expression::UnaryPrefix(PrefixExpression {
|
|
operator: PrefixUnaryOperator::Not,
|
|
expression: Box::new(result),
|
|
})
|
|
}
|
|
Rule::Negative => {
|
|
result = Expression::UnaryPrefix(PrefixExpression {
|
|
operator: PrefixUnaryOperator::Negative,
|
|
expression: Box::new(result),
|
|
})
|
|
}
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
result
|
|
}
|
|
|
|
fn build_suffix_expression(file_id: usize, suffix_pair: Pair<Rule>) -> Expression {
|
|
let mut inner = suffix_pair.into_inner();
|
|
let mut result = expect_and_use(
|
|
file_id,
|
|
inner.next().unwrap(),
|
|
Rule::PrimaryExpression,
|
|
build_primary_expression,
|
|
);
|
|
while let Some(suffix_pair) = inner.next() {
|
|
match suffix_pair.as_rule() {
|
|
Rule::ObjectAccess => {
|
|
result = Expression::ObjectAccess(build_object_access(file_id, result, suffix_pair))
|
|
}
|
|
Rule::ParenthesesCall => {
|
|
result = Expression::Call(build_call_expression(file_id, result, suffix_pair))
|
|
}
|
|
Rule::PlusPlus => {
|
|
result = Expression::UnarySuffix(SuffixExpression {
|
|
expression: Box::new(result),
|
|
operator: SuffixUnaryOperator::PlusPlus,
|
|
})
|
|
}
|
|
Rule::MinusMinus => {
|
|
result = Expression::UnarySuffix(SuffixExpression {
|
|
expression: Box::new(result),
|
|
operator: SuffixUnaryOperator::MinusMinus,
|
|
})
|
|
}
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
result
|
|
}
|
|
|
|
fn build_call_expression(
|
|
file_id: usize,
|
|
callee: Expression,
|
|
parentheses_call_pair: Pair<Rule>,
|
|
) -> CallExpression {
|
|
let mut turbo_fish = None;
|
|
let mut arguments = vec![];
|
|
|
|
for inner_pair in parentheses_call_pair.into_inner() {
|
|
match inner_pair.as_rule() {
|
|
Rule::TurboFish => {
|
|
turbo_fish = Some(build_turbo_fish(file_id, inner_pair));
|
|
}
|
|
Rule::ExpressionList => {
|
|
for expression_pair in inner_pair.into_inner() {
|
|
arguments.push(expect_and_use(
|
|
file_id,
|
|
expression_pair,
|
|
Rule::Expression,
|
|
build_expression,
|
|
));
|
|
}
|
|
}
|
|
Rule::Closure => {
|
|
arguments.push(Expression::Closure(build_closure(file_id, inner_pair)));
|
|
}
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
|
|
CallExpression {
|
|
callee: Box::new(callee),
|
|
turbo_fish,
|
|
arguments: CallArguments(
|
|
arguments
|
|
.into_iter()
|
|
.map(|argument| CallArgument(Box::new(argument)))
|
|
.collect(),
|
|
),
|
|
}
|
|
}
|
|
|
|
fn build_turbo_fish(file_id: usize, turbo_fish_pair: Pair<Rule>) -> TurboFish {
|
|
TurboFish(build_generic_arguments(
|
|
file_id,
|
|
turbo_fish_pair.into_inner().next().unwrap(),
|
|
))
|
|
}
|
|
|
|
fn build_primary_expression(file_id: usize, primary_expression_pair: Pair<Rule>) -> Expression {
|
|
let first_pair = primary_expression_pair.into_inner().next().unwrap();
|
|
match first_pair.as_rule() {
|
|
Rule::Literal => Expression::Literal(build_literal(file_id, first_pair)),
|
|
Rule::FullyQualifiedName => Expression::FullyQualifiedName(build_fqn(file_id, first_pair)),
|
|
Rule::Closure => Expression::Closure(build_closure(file_id, first_pair)),
|
|
Rule::ParenthesizedExpression => {
|
|
let inner_expression = first_pair.into_inner().next().unwrap();
|
|
expect_and_use(
|
|
file_id,
|
|
inner_expression,
|
|
Rule::Expression,
|
|
build_expression,
|
|
)
|
|
}
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
|
|
fn build_object_access(
|
|
file_id: usize,
|
|
receiver: Expression,
|
|
object_access_pair: Pair<Rule>,
|
|
) -> ObjectAccess {
|
|
ObjectAccess {
|
|
receiver: Box::new(receiver),
|
|
navigations: ObjectNavigations(
|
|
object_access_pair
|
|
.into_inner()
|
|
.map(
|
|
|property_or_index_pair| match property_or_index_pair.as_rule() {
|
|
Rule::ObjectProperty => {
|
|
build_object_property(file_id, property_or_index_pair)
|
|
}
|
|
Rule::ObjectIndex => build_object_index(file_id, property_or_index_pair),
|
|
_ => unreachable!(),
|
|
},
|
|
)
|
|
.collect(),
|
|
),
|
|
}
|
|
}
|
|
|
|
fn build_object_property(file_id: usize, inner_pair: Pair<Rule>) -> ObjectNavigation {
|
|
ObjectNavigation::Identifier(Box::new(expect_and_use(
|
|
file_id,
|
|
inner_pair.into_inner().next().unwrap(),
|
|
Rule::Identifier,
|
|
build_identifier,
|
|
)))
|
|
}
|
|
|
|
fn build_object_index(file_id: usize, inner_pair: Pair<Rule>) -> ObjectNavigation {
|
|
ObjectNavigation::Index(Box::new(expect_and_use(
|
|
file_id,
|
|
inner_pair.into_inner().next().unwrap(),
|
|
Rule::Expression,
|
|
build_expression,
|
|
)))
|
|
}
|
|
|
|
fn build_closure(file_id: usize, closure_pair: Pair<Rule>) -> Closure {
|
|
todo!()
|
|
}
|
|
|
|
fn build_literal(file_id: usize, literal_pair: Pair<Rule>) -> Literal {
|
|
let inner_pair = literal_pair.into_inner().next().unwrap();
|
|
match inner_pair.as_rule() {
|
|
Rule::NumberLiteral => build_number_literal(file_id, inner_pair),
|
|
Rule::StringLiteral => build_string_literal(file_id, inner_pair),
|
|
Rule::BooleanLiteral => build_boolean_literal(file_id, inner_pair),
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
|
|
fn build_number_literal(file_id: usize, pair: Pair<Rule>) -> Literal {
|
|
todo!()
|
|
}
|
|
|
|
fn build_string_literal(file_id: usize, pair: Pair<Rule>) -> Literal {
|
|
let inner_pair = pair.into_inner().next().unwrap();
|
|
match inner_pair.as_rule() {
|
|
Rule::SingleQuoteString => build_single_quote_string(file_id, inner_pair),
|
|
Rule::DoubleQuoteString => build_double_quote_string(file_id, inner_pair),
|
|
Rule::BacktickString => build_backtick_string(file_id, inner_pair),
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
|
|
fn build_boolean_literal(file_id: usize, pair: Pair<Rule>) -> Literal {
|
|
let inner_pair = pair.into_inner().next().unwrap();
|
|
match inner_pair.as_rule() {
|
|
Rule::True => Literal::Boolean(true),
|
|
Rule::False => Literal::Boolean(false),
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
|
|
fn build_single_quote_string(file_id: usize, pair: Pair<Rule>) -> Literal {
|
|
let inner_pair = pair.into_inner().next().unwrap();
|
|
Literal::String(inner_pair.as_span().as_str().to_string())
|
|
}
|
|
|
|
fn build_double_quote_string(file_id: usize, pair: Pair<Rule>) -> Literal {
|
|
todo!()
|
|
}
|
|
|
|
fn build_backtick_string(file_id: usize, pair: Pair<Rule>) -> Literal {
|
|
todo!()
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use crate::parser::DeimosParser;
|
|
use indoc::indoc;
|
|
|
|
fn assert_builds(src: &str) {
|
|
let parse_result = DeimosParser::parse(Rule::CompilationUnit, src);
|
|
if let Err(e) = parse_result {
|
|
panic!("Parsing failed.\n{}", e)
|
|
} else {
|
|
build_ast(0, parse_result.unwrap().next().unwrap());
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn index_object() {
|
|
assert_builds(indoc! {"
|
|
fn main() {
|
|
let x = foo[a];
|
|
}
|
|
"})
|
|
}
|
|
|
|
#[test]
|
|
fn object_index_and_call() {
|
|
assert_builds(indoc! {"\
|
|
fn main() {
|
|
a[b]().c()
|
|
}
|
|
"})
|
|
}
|
|
}
|