jessebrault/deimos-lang
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Major refactoring of AST module: private properties and accessors, building clearer, using Boxes.

Browse Source
This commit is contained in:
Jesse Brault 2025-05-24 17:40:47 -05:00
parent c8ff1d0fa2
commit 20dcb4f6ce
7 changed files with 3279 additions and 816 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

980
src/ast/build.rs
View File

File diff suppressed because it is too large Load Diff

736
src/ast/children.rs Normal file
View File

@ -0,0 +1,736 @@
use crate::ast::*;
pub enum ChildRef<'a> {
Identifier(&'a Identifier),
FullyQualifiedName(&'a FullyQualifiedName),
TypeUse(&'a TypeUse),
PrimitiveTypeUse(&'a PrimitiveTypeUse),
InterfaceOrClassTypeUse(&'a InterfaceOrClassTypeUse),
TupleTypeUse(&'a TupleTypeUse),
FunctionTypeUse(&'a FunctionTypeUse),
GenericArguments(&'a GenericArguments),
GenericParameters(&'a GenericParameters),
TupleArguments(&'a TupleArguments),
ImplementsList(&'a ImplementsList),
Parameters(&'a Parameters),
Parameter(&'a Parameter),
ReturnType(&'a ReturnType),
References(&'a References),
UseStatement(&'a UseStatement),
ModuleLevelDeclaration(&'a ModuleLevelDeclaration),
InterfaceLevelDeclaration(&'a InterfaceLevelDeclaration),
ClassLevelDeclaration(&'a ClassLevelDeclaration),
FunctionBody(&'a FunctionBody),
ClassConstructor(&'a ClassConstructor),
ClassConstructorParameter(&'a ClassConstructorParameter),
BlockStatement(&'a BlockStatement),
Statement(&'a Statement),
IfStatement(&'a IfStatement),
ElseIfs(&'a ElseIfs),
ElseBlock(&'a ElseBlock),
Expression(&'a Expression),
TurboFish(&'a TurboFish),
CallArguments(&'a CallArguments),
CallArgument(&'a CallArgument),
ClosureCaptures(&'a ClosureCaptures),
ClosureCapture(&'a ClosureCapture),
ClosureParameters(&'a ClosureParameters),
ClosureParameter(&'a ClosureParameter),
ObjectNavigations(&'a ObjectNavigations),
ObjectNavigation(&'a ObjectNavigation),
DString(&'a DString),
DStringPart(&'a DStringPart),
}
pub trait HasChildren {
fn children(&self) -> Vec<ChildRef>;
}
impl HasChildren for FullyQualifiedName {
fn children(&self) -> Vec<ChildRef> {
self.identifiers()
.iter()
.map(|id| ChildRef::Identifier(*id))
.collect()
}
}
impl HasChildren for TypeUse {
fn children(&self) -> Vec<ChildRef> {
match self {
TypeUse::Primitive(primitive_type_use) => primitive_type_use.children(),
TypeUse::InterfaceOrClass(interface_or_class_type_use) => {
interface_or_class_type_use.children()
}
TypeUse::Tuple(tuple_type_use) => tuple_type_use.children(),
TypeUse::Function(function_type_use) => function_type_use.children(),
}
}
}
impl HasChildren for PrimitiveTypeUse {
fn children(&self) -> Vec<ChildRef> {
match self {
PrimitiveTypeUse::Array(generics) => {
if let Some(generics) = generics {
vec![ChildRef::GenericArguments(&generics)]
} else {
vec![]
}
}
_ => vec![],
}
}
}
impl HasChildren for InterfaceOrClassTypeUse {
fn children(&self) -> Vec<ChildRef> {
let mut children = vec![];
children.push(ChildRef::FullyQualifiedName(self.fqn()));
children.push(ChildRef::GenericArguments(self.generics()));
children
}
}
impl HasChildren for TupleTypeUse {
fn children(&self) -> Vec<ChildRef> {
vec![ChildRef::TupleArguments(self.arguments())]
}
}
impl HasChildren for FunctionTypeUse {
fn children(&self) -> Vec<ChildRef> {
vec![
ChildRef::GenericParameters(self.generics()),
ChildRef::Parameters(self.parameters()),
ChildRef::ReturnType(self.return_type()),
]
}
}
impl HasChildren for GenericArguments {
fn children(&self) -> Vec<ChildRef> {
self.arguments()
.iter()
.map(|type_use| ChildRef::TypeUse(*type_use))
.collect()
}
}
impl HasChildren for GenericParameters {
fn children(&self) -> Vec<ChildRef> {
self.identifiers()
.iter()
.map(|id| ChildRef::Identifier(*id))
.collect()
}
}
impl HasChildren for TupleArguments {
fn children(&self) -> Vec<ChildRef> {
self.arguments()
.iter()
.map(|type_use| ChildRef::TypeUse(*type_use))
.collect()
}
}
impl HasChildren for ImplementsList {
fn children(&self) -> Vec<ChildRef> {
self.type_uses()
.iter()
.map(|type_use| ChildRef::TypeUse(*type_use))
.collect()
}
}
impl HasChildren for Parameters {
fn children(&self) -> Vec<ChildRef> {
self.parameters()
.iter()
.map(|parameter| ChildRef::Parameter(*parameter))
.collect()
}
}
impl HasChildren for Parameter {
fn children(&self) -> Vec<ChildRef> {
vec![
ChildRef::Identifier(self.identifier()),
ChildRef::TypeUse(self.type_use()),
]
}
}
impl HasChildren for ReturnType {
fn children(&self) -> Vec<ChildRef> {
vec![
ChildRef::TypeUse(self.declared_type()),
ChildRef::References(self.references()),
]
}
}
impl HasChildren for CompilationUnit {
fn children(&self) -> Vec<ChildRef> {
let mut children = vec![];
if let Some(namespace) = self.namespace() {
children.push(ChildRef::FullyQualifiedName(namespace));
}
children.extend(
self.use_statements()
.iter()
.map(|use_statement| ChildRef::UseStatement(*use_statement)),
);
children.extend(
self.declarations()
.iter()
.map(|declaration| ChildRef::ModuleLevelDeclaration(*declaration)),
);
children
}
}
impl HasChildren for UseStatement {
fn children(&self) -> Vec<ChildRef> {
let mut children = vec![];
children.extend(
self.identifiers()
.iter()
.map(|identifier| ChildRef::Identifier(*identifier)),
);
match self.last() {
UseStatementLast::Identifier(identifier) => {
children.push(ChildRef::Identifier(identifier))
}
UseStatementLast::Identifiers(identifiers) => children.extend(
identifiers
.iter()
.map(|identifier| ChildRef::Identifier(identifier.clone())),
),
UseStatementLast::Star => {}
}
children
}
}
impl HasChildren for ModuleLevelDeclaration {
fn children(&self) -> Vec<ChildRef> {
use ModuleLevelDeclaration::*;
match self {
Module(module_declaration) => module_declaration.children(),
Interface(interface_declaration) => interface_declaration.children(),
Class(class_declaration) => class_declaration.children(),
Function(function_definition) => function_definition.children(),
PlatformFunction(platform_function_declaration) => {
platform_function_declaration.children()
}
}
}
}
impl HasChildren for InterfaceLevelDeclaration {
fn children(&self) -> Vec<ChildRef> {
use InterfaceLevelDeclaration::*;
match self {
Module(module_declaration) => module_declaration.children(),
Interface(interface_declaration) => interface_declaration.children(),
Class(class_declaration) => class_declaration.children(),
Function(function_declaration) => function_declaration.children(),
OperatorFunction(operator_function_declaration) => {
operator_function_declaration.children()
}
}
}
}
impl HasChildren for ClassLevelDeclaration {
fn children(&self) -> Vec<ChildRef> {
use ClassLevelDeclaration::*;
match self {
Module(module_declaration) => module_declaration.children(),
Interface(interface_declaration) => interface_declaration.children(),
Class(class_declaration) => class_declaration.children(),
Function(function_definition) => function_definition.children(),
OperatorFunction(operator_function_definition) => {
operator_function_definition.children()
}
PlatformFunction(platform_function_declaration) => {
platform_function_declaration.children()
}
Property(property_declaration) => property_declaration.children(),
Field(field_declaration) => field_declaration.children(),
}
}
}
impl HasChildren for ModuleDeclaration {
fn children(&self) -> Vec<ChildRef> {
let mut children = vec![];
children.push(ChildRef::Identifier(self.identifier()));
children.extend(
self.declarations()
.iter()
.map(|declaration| ChildRef::ModuleLevelDeclaration(*declaration)),
);
children
}
}
impl HasChildren for InterfaceDeclaration {
fn children(&self) -> Vec<ChildRef> {
let mut children = vec![];
children.push(ChildRef::Identifier(self.identifier()));
children.push(ChildRef::GenericParameters(self.generics()));
children.push(ChildRef::ImplementsList(self.implements()));
children.extend(
self.declarations()
.iter()
.map(|declaration| ChildRef::InterfaceLevelDeclaration(*declaration)),
);
children
}
}
impl HasChildren for ClassDeclaration {
fn children(&self) -> Vec<ChildRef> {
let mut children = vec![];
children.push(ChildRef::Identifier(self.identifier()));
children.push(ChildRef::GenericParameters(self.generics()));
if let Some(class_constructor) = self.class_constructor() {
children.push(ChildRef::ClassConstructor(class_constructor));
}
children.push(ChildRef::ImplementsList(self.implements()));
children.extend(
self.declarations()
.iter()
.map(|declaration| ChildRef::ClassLevelDeclaration(*declaration)),
);
children
}
}
impl HasChildren for FunctionDefinition {
fn children(&self) -> Vec<ChildRef> {
vec![
ChildRef::GenericParameters(self.generics()),
ChildRef::Identifier(self.identifier()),
ChildRef::Parameters(self.parameters()),
ChildRef::ReturnType(self.return_type()),
ChildRef::FunctionBody(self.body()),
]
}
}
impl HasChildren for OperatorFunctionDefinition {
fn children(&self) -> Vec<ChildRef> {
vec![
ChildRef::GenericParameters(self.generics()),
ChildRef::Parameters(self.parameters()),
ChildRef::ReturnType(self.return_type()),
ChildRef::FunctionBody(self.body()),
]
}
}
impl HasChildren for PlatformFunctionDeclaration {
fn children(&self) -> Vec<ChildRef> {
vec![
ChildRef::GenericParameters(self.generics()),
ChildRef::Identifier(self.identifier()),
ChildRef::Parameters(self.parameters()),
ChildRef::ReturnType(self.return_type()),
]
}
}
impl HasChildren for InterfaceFunctionDeclaration {
fn children(&self) -> Vec<ChildRef> {
let mut children = vec![
ChildRef::GenericParameters(self.generics()),
ChildRef::Identifier(self.identifier()),
ChildRef::Parameters(self.parameters()),
ChildRef::ReturnType(self.return_type()),
];
if let Some(body) = self.body() {
children.push(ChildRef::FunctionBody(body))
}
children
}
}
impl HasChildren for InterfaceOperatorFunctionDeclaration {
fn children(&self) -> Vec<ChildRef> {
let mut children = vec![
ChildRef::GenericParameters(self.generics()),
ChildRef::Parameters(self.parameters()),
ChildRef::ReturnType(self.return_type()),
];
if let Some(body) = self.body() {
children.push(ChildRef::FunctionBody(body))
}
children
}
}
impl HasChildren for FunctionBody {
fn children(&self) -> Vec<ChildRef> {
match self {
Self::Equals(expression) => expression.children(),
Self::Block(block_statement) => block_statement.children(),
Self::Alias(identifier) => vec![ChildRef::Identifier(identifier.as_ref())],
}
}
}
impl HasChildren for ClassConstructor {
fn children(&self) -> Vec<ChildRef> {
self.parameters()
.iter()
.map(|parameter| ChildRef::ClassConstructorParameter(*parameter))
.collect()
}
}
impl HasChildren for ClassConstructorParameter {
fn children(&self) -> Vec<ChildRef> {
match self {
Self::Property(property_declaration) => property_declaration.children(),
Self::Field(field_declaration) => field_declaration.children(),
}
}
}
impl HasChildren for PropertyDeclaration {
fn children(&self) -> Vec<ChildRef> {
vec![
ChildRef::Identifier(self.identifier()),
ChildRef::TypeUse(self.declared_type()),
]
}
}
impl HasChildren for FieldDeclaration {
fn children(&self) -> Vec<ChildRef> {
vec![
ChildRef::Identifier(self.identifier()),
ChildRef::TypeUse(self.declared_type()),
]
}
}
impl HasChildren for BlockStatement {
fn children(&self) -> Vec<ChildRef> {
let mut children = vec![];
children.extend(
self.statements()
.iter()
.map(|statement| ChildRef::Statement(statement)),
);
if let Some(expression) = self.expression() {
children.push(ChildRef::Expression(expression));
}
children
}
}
impl HasChildren for Statement {
fn children(&self) -> Vec<ChildRef> {
use Statement::*;
match self {
BlockStatement(block_statement) => block_statement.children(),
VariableDeclarationStatement(variable_declaration_statement) => {
variable_declaration_statement.children()
}
AssignStatement(assign_statement) => assign_statement.children(),
CallStatement(call_statement) => call_statement.children(),
ReturnStatement(return_statement) => return_statement.children(),
IfStatement(if_statement) => if_statement.children(),
IfElseStatement(if_else_statement) => if_else_statement.children(),
WhileStatement(while_statement) => while_statement.children(),
ForStatement(for_statement) => for_statement.children(),
}
}
}
impl HasChildren for VariableDeclarationStatement {
fn children(&self) -> Vec<ChildRef> {
let mut children = vec![];
children.push(ChildRef::Identifier(self.identifier()));
if let Some(declared_type) = self.declared_type() {
children.push(ChildRef::TypeUse(declared_type));
}
if let Some(initializer) = self.initializer() {
children.push(ChildRef::Expression(initializer));
}
children
}
}
impl HasChildren for AssignStatement {
fn children(&self) -> Vec<ChildRef> {
vec![
ChildRef::Expression(self.lhs()),
ChildRef::Expression(self.rhs()),
]
}
}
impl HasChildren for CallStatement {
fn children(&self) -> Vec<ChildRef> {
vec![ChildRef::Expression(self.expression())]
}
}
impl HasChildren for ReturnStatement {
fn children(&self) -> Vec<ChildRef> {
if let Some(expression) = self.expression() {
vec![ChildRef::Expression(expression)]
} else {
vec![]
}
}
}
impl HasChildren for IfStatement {
fn children(&self) -> Vec<ChildRef> {
vec![
ChildRef::Expression(self.condition()),
ChildRef::BlockStatement(self.then_block()),
]
}
}
impl HasChildren for IfElseStatement {
fn children(&self) -> Vec<ChildRef> {
let mut children = vec![];
children.push(ChildRef::IfStatement(self.if_statement()));
children.push(ChildRef::ElseIfs(self.else_ifs()));
if let Some(else_block) = self.else_block() {
children.push(ChildRef::ElseBlock(else_block));
}
children
}
}
impl HasChildren for ElseIfs {
fn children(&self) -> Vec<ChildRef> {
self.if_statements()
.iter()
.map(|statement| ChildRef::IfStatement(statement))
.collect()
}
}
impl HasChildren for ElseBlock {
fn children(&self) -> Vec<ChildRef> {
vec![ChildRef::BlockStatement(self.block_statement())]
}
}
impl HasChildren for WhileStatement {
fn children(&self) -> Vec<ChildRef> {
vec![
ChildRef::Expression(self.condition()),
ChildRef::BlockStatement(self.body()),
]
}
}
impl HasChildren for ForStatement {
fn children(&self) -> Vec<ChildRef> {
vec![
ChildRef::Identifier(self.variable()),
ChildRef::Expression(self.iterator()),
ChildRef::BlockStatement(self.body()),
]
}
}
impl HasChildren for Expression {
fn children(&self) -> Vec<ChildRef> {
use Expression::*;
match self {
Ternary(ternary) => ternary.children(),
Binary(binary) => binary.children(),
UnaryPrefix(prefix) => prefix.children(),
UnarySuffix(suffix) => suffix.children(),
Call(call) => call.children(),
ObjectAccess(object_access) => object_access.children(),
Literal(literal) => literal.children(),
FullyQualifiedName(fully_qualified_name) => fully_qualified_name.children(),
Closure(closure) => closure.children(),
}
}
}
impl HasChildren for TernaryExpression {
fn children(&self) -> Vec<ChildRef> {
vec![
ChildRef::Expression(self.condition()),
ChildRef::Expression(self.true_expression()),
ChildRef::Expression(self.false_expression()),
]
}
}
impl HasChildren for BinaryExpression {
fn children(&self) -> Vec<ChildRef> {
vec![
ChildRef::Expression(self.left()),
ChildRef::Expression(self.right()),
]
}
}
impl HasChildren for PrefixExpression {
fn children(&self) -> Vec<ChildRef> {
vec![ChildRef::Expression(self.expression())]
}
}
impl HasChildren for SuffixExpression {
fn children(&self) -> Vec<ChildRef> {
vec![ChildRef::Expression(self.expression())]
}
}
impl HasChildren for CallExpression {
fn children(&self) -> Vec<ChildRef> {
let mut children = vec![];
children.push(ChildRef::Expression(self.callee()));
if let Some(turbo_fish) = self.turbo_fish() {
children.push(ChildRef::TurboFish(turbo_fish));
}
children.push(ChildRef::CallArguments(self.arguments()));
children
}
}
impl HasChildren for TurboFish {
fn children(&self) -> Vec<ChildRef> {
vec![ChildRef::GenericArguments(self.generics())]
}
}
impl HasChildren for CallArguments {
fn children(&self) -> Vec<ChildRef> {
self.arguments()
.iter()
.map(|argument| ChildRef::CallArgument(*argument))
.collect()
}
}
impl HasChildren for CallArgument {
fn children(&self) -> Vec<ChildRef> {
vec![ChildRef::Expression(self.expression())]
}
}
impl HasChildren for Closure {
fn children(&self) -> Vec<ChildRef> {
let mut children = vec![];
children.push(ChildRef::ClosureCaptures(self.captures()));
children.push(ChildRef::ClosureParameters(self.parameters()));
children.extend(
self.statements()
.iter()
.map(|statement| ChildRef::Statement(statement)),
);
if let Some(expression) = self.expression() {
children.push(ChildRef::Expression(expression));
}
children
}
}
impl HasChildren for ClosureCaptures {
fn children(&self) -> Vec<ChildRef> {
self.captures()
.iter()
.map(|capture| ChildRef::ClosureCapture(*capture))
.collect()
}
}
impl HasChildren for ClosureCapture {
fn children(&self) -> Vec<ChildRef> {
vec![ChildRef::Identifier(self.identifier())]
}
}
impl HasChildren for ClosureParameters {
fn children(&self) -> Vec<ChildRef> {
self.parameters()
.iter()
.map(|parameter| ChildRef::ClosureParameter(*parameter))
.collect()
}
}
impl HasChildren for ClosureParameter {
fn children(&self) -> Vec<ChildRef> {
let mut children = vec![];
children.push(ChildRef::Identifier(self.identifier()));
if let Some(type_use) = self.type_use() {
children.push(ChildRef::TypeUse(type_use));
}
children
}
}
impl HasChildren for ObjectAccess {
fn children(&self) -> Vec<ChildRef> {
vec![
ChildRef::Expression(self.receiver()),
ChildRef::ObjectNavigations(self.navigations()),
]
}
}
impl HasChildren for ObjectNavigations {
fn children(&self) -> Vec<ChildRef> {
self.navigations()
.iter()
.map(|navigation| ChildRef::ObjectNavigation(*navigation))
.collect()
}
}
impl HasChildren for ObjectNavigation {
fn children(&self) -> Vec<ChildRef> {
vec![match self {
ObjectNavigation::Identifier(identifier) => ChildRef::Identifier(identifier),
ObjectNavigation::Index(index_expression) => ChildRef::Expression(index_expression),
}]
}
}
impl HasChildren for Literal {
fn children(&self) -> Vec<ChildRef> {
match self {
Literal::DString(d_string) => vec![ChildRef::DString(d_string)],
Literal::BacktickString(d_string) => vec![ChildRef::DString(d_string)],
_ => vec![],
}
}
}
impl HasChildren for DString {
fn children(&self) -> Vec<ChildRef> {
self.parts()
.iter()
.map(|part| ChildRef::DStringPart(*part))
.collect()
}
}
impl HasChildren for DStringPart {
fn children(&self) -> Vec<ChildRef> {
match self {
DStringPart::Expression(expression) => vec![ChildRef::Expression(expression)],
_ => vec![],
}
}
}

2005
src/ast/mod.rs
View File

File diff suppressed because it is too large Load Diff

81
src/ast/pretty_print.rs
View File

@ -1,6 +1,7 @@
use crate::ast::*;
use crate::util::indent_writer::IndentWriter;
use std::fmt::Debug;
use crate::ast::unparse::Unparse;
pub trait PrettyPrint {
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()>;
@ -20,24 +21,7 @@ impl PrettyPrint for Operator {
impl PrettyPrint for BinaryOperator {
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
writer.write_indented("BinaryOperator(")?;
use BinaryOperator::*;
match self {
Or => writer.write("||"),
And => writer.write("&&"),
EqualTo => writer.write("=="),
NotEqualTo => writer.write("!="),
Greater => writer.write(">"),
Less => writer.write("<"),
GreaterEqual => writer.write(">="),
LessEqual => writer.write("<="),
Add => writer.write("+"),
Subtract => writer.write("-"),
Multiply => writer.write("*"),
Divide => writer.write("/"),
Modulo => writer.write("%"),
LeftShift => writer.write("<<"),
RightShift => writer.write(">>"),
}?;
self.unparse(writer)?;
writer.writeln(")")?;
Ok(())
}
@ -46,15 +30,7 @@ impl PrettyPrint for BinaryOperator {
impl PrettyPrint for PrefixUnaryOperator {
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
writer.write_indented("PrefixUnaryOperator(")?;
use PrefixUnaryOperator::*;
match self {
Spread => writer.write("..."),
BorrowMut => writer.write("&mut"),
Borrow => writer.write("&"),
Mut => writer.write("mut"),
Not => writer.write("!"),
Negative => writer.write("-"),
}?;
self.unparse(writer)?;
writer.writeln(")")?;
Ok(())
}
@ -63,11 +39,7 @@ impl PrettyPrint for PrefixUnaryOperator {
impl PrettyPrint for SuffixUnaryOperator {
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
writer.write_indented("SuffixUnaryOperator(")?;
use SuffixUnaryOperator::*;
match self {
PlusPlus => writer.write("++"),
MinusMinus => writer.write("--"),
}?;
self.unparse(writer)?;
writer.write(")")?;
Ok(())
}
@ -95,20 +67,26 @@ impl PrettyPrint for TypeUse {
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
use TypeUse::*;
match self {
Void => {
writer.writeln_indented("TypeUse(Void)")?;
Primitive(primitive_type_use) => {
writer.writeln_indented("PrimitiveTypeUse")?;
writer.increase_indent();
primitive_type_use.pretty_print(writer)?;
writer.decrease_indent()
}
InterfaceOrClass(t) => {
writer.writeln_indented("InterfaceOrClassTypeUse")?;
writer.increase_indent();
t.pretty_print(writer)?;
writer.decrease_indent();
}
Tuple(t) => {
writer.writeln_indented("TupleTypeUse")?;
writer.increase_indent();
t.pretty_print(writer)?;
writer.decrease_indent();
}
Function(t) => {
writer.writeln_indented("FunctionTypeUse")?;
writer.increase_indent();
t.pretty_print(writer)?;
writer.decrease_indent();
@ -118,6 +96,33 @@ impl PrettyPrint for TypeUse {
}
}
impl PrettyPrint for PrimitiveTypeUse {
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
use PrimitiveTypeUse::*;
match self {
Byte => writer.writeln_indented("Byte"),
Short => writer.writeln_indented("Short"),
Char => writer.writeln_indented("Char"),
Int => writer.writeln_indented("Int"),
Long => writer.writeln_indented("Long"),
Double => writer.writeln_indented("Double"),
Bool => writer.writeln_indented("Bool"),
String => writer.writeln_indented("String"),
Array(generics) => {
writer.writeln_indented("Array")?;
if let Some(generics) = generics {
writer.increase_indent();
generics.pretty_print(writer)?;
writer.decrease_indent();
}
Ok(())
}
Any => writer.writeln_indented("Any"),
Void => writer.writeln_indented("Void"),
}
}
}
impl PrettyPrint for InterfaceOrClassTypeUse {
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
writer.writeln_indented(&format!(
@ -606,12 +611,12 @@ impl PrettyPrint for UseStatementLast {
writer.writeln_indented("UseStatementLast")?;
writer.increase_indent();
match self {
UseStatementLast::Identifier(i) => i.borrow().pretty_print(writer)?,
UseStatementLast::Identifier(i) => i.pretty_print(writer)?,
UseStatementLast::Identifiers(is) => {
for i in is {
i.borrow().pretty_print(writer)?;
i.pretty_print(writer)?;
}
}
},
UseStatementLast::Star => {
writer.writeln_indented("Star")?;
}
@ -785,7 +790,7 @@ impl PrettyPrint for Expression {
UnarySuffix(e) => e.pretty_print(writer),
Call(e) => e.pretty_print(writer),
ObjectAccess(o) => o.pretty_print(writer),
Literal(literial) => literial.pretty_print(writer),
Literal(literal) => literal.pretty_print(writer),
FullyQualifiedName(fqn) => fqn.pretty_print(writer),
Closure(closure) => closure.pretty_print(writer),
}

263
src/ast/unparse.rs
View File

@ -5,8 +5,8 @@ macro_rules! to_unparse_vec {
( $nodes:expr ) => {
$nodes
.iter()
.map(|node| node as &dyn Unparse)
.collect::<Vec<&dyn Unparse>>()
.map(|node| *node as &dyn Unparse)
.collect::<Vec<_>>()
};
}
@ -112,6 +112,7 @@ impl Unparse for PrefixUnaryOperator {
Spread => writer.write("..."),
BorrowMut => writer.write("&mut"),
Borrow => writer.write("&"),
Star => writer.write("*"),
Mut => writer.write("mut"),
Not => writer.write("!"),
Negative => writer.write("-"),
@ -125,6 +126,8 @@ impl Unparse for SuffixUnaryOperator {
match self {
PlusPlus => writer.write("++"),
MinusMinus => writer.write("--"),
Call => writer.write("()"),
Index => writer.write("[]"),
}
}
}
@ -143,7 +146,7 @@ impl ListUnparse for FullyQualifiedName {
}
fn inner(&self) -> Vec<&dyn Unparse> {
to_unparse_vec!(self.identifiers)
to_unparse_vec!(self.identifiers())
}
}
@ -165,56 +168,56 @@ impl Unparse for TypeUse {
impl Unparse for InterfaceOrClassTypeUse {
fn unparse(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
for _ in 0..self.borrow_count {
for _ in 0..self.borrow_count() {
writer.write("&")?;
}
if self.is_mutable {
if self.is_mutable() {
writer.write("mut")?;
}
if self.borrow_count > 0 || self.is_mutable {
if self.borrow_count() > 0 || self.is_mutable() {
writer.write(" ")?;
}
self.fqn.unparse(writer)?;
self.generics.unparse(writer)?;
self.fqn().unparse(writer)?;
self.generics().unparse(writer)?;
Ok(())
}
}
impl Unparse for TupleTypeUse {
fn unparse(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
for _ in 0..self.borrow_count {
for _ in 0..self.borrow_count() {
writer.write("&")?;
}
if self.is_mutable {
if self.is_mutable() {
writer.write("mut")?;
}
if self.borrow_count > 0 || self.is_mutable {
if self.borrow_count() > 0 || self.is_mutable() {
writer.write(" ")?;
}
self.arguments.unparse(writer)?;
self.arguments().unparse(writer)?;
Ok(())
}
}
impl Unparse for FunctionTypeUse {
fn unparse(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
for _ in 0..self.borrow_count {
for _ in 0..self.borrow_count() {
writer.write("&")?;
}
if let Some(function_type_modifier) = &self.function_modifier {
if let Some(function_type_modifier) = self.function_modifier() {
function_type_modifier.unparse(writer)?;
}
if self.borrow_count > 0 || self.function_modifier.is_some() {
if self.borrow_count() > 0 || self.function_modifier().is_some() {
writer.write(" ")?;
}
writer.write("fn ")?;
if !self.generics.is_empty() {
self.generics.unparse(writer)?;
if !self.generics().is_empty() {
self.generics().unparse(writer)?;
writer.write(" ")?;
}
self.parameters.unparse(writer)?;
self.parameters().unparse(writer)?;
writer.write(" ")?;
self.return_type.unparse(writer)?;
self.return_type().unparse(writer)?;
Ok(())
}
}
@ -235,7 +238,7 @@ impl ListUnparse for GenericArguments {
}
fn inner(&self) -> Vec<&dyn Unparse> {
to_unparse_vec!(self.0)
to_unparse_vec!(self.arguments())
}
}
@ -255,7 +258,7 @@ impl ListUnparse for GenericParameters {
}
fn inner(&self) -> Vec<&dyn Unparse> {
to_unparse_vec!(self.0)
to_unparse_vec!(self.identifiers())
}
}
@ -275,7 +278,7 @@ impl ListUnparse for TupleArguments {
}
fn inner(&self) -> Vec<&dyn Unparse> {
to_unparse_vec!(self.0)
to_unparse_vec!(self.arguments())
}
}
@ -291,7 +294,7 @@ impl ListUnparse for ImplementsList {
}
fn inner(&self) -> Vec<&dyn Unparse> {
to_unparse_vec!(self.0)
to_unparse_vec!(self.type_uses())
}
}
@ -325,15 +328,15 @@ impl ListUnparse for Parameters {
}
fn inner(&self) -> Vec<&dyn Unparse> {
to_unparse_vec!(self.0)
to_unparse_vec!(self.parameters())
}
}
impl Unparse for Parameter {
fn unparse(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
self.identifier.unparse(writer)?;
self.identifier().unparse(writer)?;
writer.write(": ")?;
self.type_use.unparse(writer)?;
self.type_use().unparse(writer)?;
Ok(())
}
}
@ -343,10 +346,10 @@ impl Unparse for Parameter {
impl Unparse for ReturnType {
fn unparse(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
writer.write("-> ")?;
self.declared_type.unparse(writer)?;
if !self.references.is_empty() {
self.declared_type().unparse(writer)?;
if !self.references().is_empty() {
writer.write(" ")?;
self.references.unparse(writer)?;
self.references().unparse(writer)?;
}
Ok(())
}
@ -362,7 +365,7 @@ impl ListUnparse for References {
}
fn inner(&self) -> Vec<&dyn Unparse> {
to_unparse_vec!(self.0)
to_unparse_vec!(self.identifiers())
}
}
@ -370,20 +373,55 @@ impl ListUnparse for References {
impl Unparse for CompilationUnit {
fn unparse(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
if let Some(namespace) = &self.namespace {
if let Some(namespace) = self.namespace() {
writer.write("ns ")?;
namespace.unparse(writer)?;
writer.write(";\n\n")?;
}
for use_statement in &self.use_statements {
for use_statement in self.use_statements() {
use_statement.unparse(writer)?;
writer.write(";\n")?;
}
unparse_list(writer, "\n\n", &to_unparse_vec!(self.declarations))?;
unparse_list(writer, "\n\n", &to_unparse_vec!(self.declarations()))?;
Ok(())
}
}
impl Unparse for UseStatement {
fn unparse(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
writer.write_indented("use ")?;
for (i, identifier) in self.identifiers().iter().enumerate() {
identifier.unparse(writer)?;
if i != self.identifiers().len() - 2 {
// 2 because of use
writer.write("::")?;
}
}
self.last().unparse(writer)?;
Ok(())
}
}
impl Unparse for UseStatementLast {
fn unparse(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
match self {
UseStatementLast::Star => writer.write("*"),
UseStatementLast::Identifiers(identifiers) => {
writer.write("{")?;
for (i, identifier) in identifiers.iter().enumerate() {
identifier.unparse(writer)?;
if i != identifiers.len() - 1 {
writer.write(", ")?;
}
}
writer.write("}")?;
Ok(())
}
UseStatementLast::Identifier(i) => i.unparse(writer),
}
}
}
/* Declarations allowed in each level */
impl Unparse for ModuleLevelDeclaration {
@ -442,58 +480,58 @@ impl Unparse for ClassLevelDeclaration {
impl Unparse for ModuleDeclaration {
fn unparse(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
if self.is_public {
if self.is_public() {
writer.write_indented("pub mod ")?;
} else {
writer.write_indented("mod ")?;
}
self.identifier.unparse(writer)?;
unparse_contained_declarations!(self.declarations, writer);
self.identifier().unparse(writer)?;
unparse_contained_declarations!(self.declarations(), writer);
Ok(())
}
}
impl Unparse for InterfaceDeclaration {
fn unparse(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
if self.is_public {
if self.is_public() {
writer.write_indented("pub int ")?;
} else {
writer.write_indented("int ")?;
}
self.identifier.unparse(writer)?;
if !self.generics.is_empty() {
self.generics.unparse(writer)?;
self.identifier().unparse(writer)?;
if !self.generics().is_empty() {
self.generics().unparse(writer)?;
writer.write(" ")?;
}
if !self.implements.is_empty() {
self.implements.unparse(writer)?;
if !self.implements().is_empty() {
self.implements().unparse(writer)?;
writer.write(" ")?;
}
unparse_contained_declarations!(self.declarations, writer);
unparse_contained_declarations!(self.declarations(), writer);
Ok(())
}
}
impl Unparse for ClassDeclaration {
fn unparse(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
if self.is_public {
if self.is_public() {
writer.write_indented("pub class ")?;
} else {
writer.write_indented("class ")?;
}
self.identifier.unparse(writer)?;
if !self.generics.is_empty() {
self.generics.unparse(writer)?;
self.identifier().unparse(writer)?;
if !self.generics().is_empty() {
self.generics().unparse(writer)?;
}
if let Some(class_constructor) = &self.class_constructor {
if let Some(class_constructor) = self.class_constructor() {
class_constructor.unparse(writer)?;
}
writer.write(" ")?;
if !self.implements.is_empty() {
self.implements.unparse(writer)?;
if !self.implements().is_empty() {
self.implements().unparse(writer)?;
writer.write(" ")?;
}
unparse_contained_declarations!(self.declarations, writer);
unparse_contained_declarations!(self.declarations(), writer);
Ok(())
}
}
@ -502,78 +540,78 @@ impl Unparse for ClassDeclaration {
impl Unparse for FunctionDefinition {
fn unparse(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
if self.is_public {
if self.is_public() {
writer.write_indented("pub ")?;
if let Some(modifier) = &self.modifier {
if let Some(modifier) = self.modifier() {
modifier.unparse(writer)?;
writer.write(" fn ")?;
} else {
writer.write(" fn ")?;
}
} else if let Some(modifier) = &self.modifier {
} else if let Some(modifier) = self.modifier() {
writer.write_indented("")?;
modifier.unparse(writer)?;
writer.write(" fn ")?;
} else {
writer.write_indented("fn ")?;
}
if !self.generics.is_empty() {
self.generics.unparse(writer)?;
if !self.generics().is_empty() {
self.generics().unparse(writer)?;
writer.write(" ")?;
}
self.identifier.unparse(writer)?;
self.parameters.unparse(writer)?;
self.identifier().unparse(writer)?;
self.parameters().unparse(writer)?;
writer.write(" ")?;
self.return_type.unparse(writer)?;
self.return_type().unparse(writer)?;
writer.write(" ")?;
self.body.unparse(writer)?;
self.body().unparse(writer)?;
Ok(())
}
}
impl Unparse for OperatorFunctionDefinition {
fn unparse(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
if self.is_public {
if self.is_public() {
writer.write_indented("pub ")?;
if let Some(modifier) = &self.modifier {
if let Some(modifier) = self.modifier() {
modifier.unparse(writer)?;
writer.write(" op ")?;
} else {
writer.write("op ")?;
}
} else if let Some(modifier) = &self.modifier {
} else if let Some(modifier) = self.modifier() {
writer.write_indented("")?;
modifier.unparse(writer)?;
writer.write(" op ")?;
} else {
writer.write_indented("op ")?;
}
self.operator.unparse(writer)?;
self.operator().unparse(writer)?;
writer.write(" ")?;
self.parameters.unparse(writer)?;
self.parameters().unparse(writer)?;
writer.write(" ")?;
self.return_type.unparse(writer)?;
self.return_type().unparse(writer)?;
writer.write(" ")?;
self.body.unparse(writer)?;
self.body().unparse(writer)?;
Ok(())
}
}
impl Unparse for PlatformFunctionDeclaration {
fn unparse(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
if self.is_public {
if self.is_public() {
writer.write_indented("pub platform fn ")?;
} else {
writer.write_indented("platform fn ")?;
}
if !self.generics.is_empty() {
self.generics.unparse(writer)?;
if !self.generics().is_empty() {
self.generics().unparse(writer)?;
writer.write(" ")?;
}
self.identifier.unparse(writer)?;
self.parameters.unparse(writer)?;
self.identifier().unparse(writer)?;
self.parameters().unparse(writer)?;
writer.write(" ")?;
self.return_type.unparse(writer)?;
self.return_type().unparse(writer)?;
writer.write(";")?;
Ok(())
}
@ -581,22 +619,22 @@ impl Unparse for PlatformFunctionDeclaration {
impl Unparse for InterfaceFunctionDeclaration {
fn unparse(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
if let Some(modifier) = &self.modifier {
if let Some(modifier) = self.modifier() {
writer.write_indented("")?;
modifier.unparse(writer)?;
writer.write(" fn ")?;
} else {
writer.write_indented("fn ")?;
}
if !self.generics.is_empty() {
self.parameters.unparse(writer)?;
if !self.generics().is_empty() {
self.generics().unparse(writer)?;
writer.write(" ")?;
}
self.identifier.unparse(writer)?;
self.parameters.unparse(writer)?;
self.identifier().unparse(writer)?;
self.parameters().unparse(writer)?;
writer.write(" ")?;
self.return_type.unparse(writer)?;
if let Some(body) = &self.body {
self.return_type().unparse(writer)?;
if let Some(body) = self.body() {
writer.write(" ")?;
body.unparse(writer)?;
}
@ -606,23 +644,23 @@ impl Unparse for InterfaceFunctionDeclaration {
impl Unparse for InterfaceOperatorFunctionDeclaration {
fn unparse(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
if let Some(modifier) = &self.modifier {
if let Some(modifier) = self.modifier() {
writer.write_indented("")?;
modifier.unparse(writer)?;
writer.write(" op ")?;
} else {
writer.write_indented("op ")?;
}
if !self.generics.is_empty() {
self.generics.unparse(writer)?;
if !self.generics().is_empty() {
self.generics().unparse(writer)?;
writer.write(" ")?;
}
self.operator.unparse(writer)?;
self.operator().unparse(writer)?;
writer.write(" ")?;
self.parameters.unparse(writer)?;
self.parameters().unparse(writer)?;
writer.write(" ")?;
self.return_type.unparse(writer)?;
if let Some(body) = &self.body {
self.return_type().unparse(writer)?;
if let Some(body) = self.body() {
writer.write(" ")?;
body.unparse(writer)?;
}
@ -686,7 +724,7 @@ impl ListUnparse for ClassConstructor {
}
fn inner(&self) -> Vec<&dyn Unparse> {
to_unparse_vec!(self.0)
to_unparse_vec!(self.parameters())
}
}
@ -702,66 +740,31 @@ impl Unparse for ClassConstructorParameter {
impl Unparse for PropertyDeclaration {
fn unparse(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
if self.is_mutable {
if self.is_mutable() {
writer.write("mut ")?;
}
self.identifier.unparse(writer)?;
self.identifier().unparse(writer)?;
writer.write(": ")?;
self.declared_type.unparse(writer)?;
self.declared_type().unparse(writer)?;
Ok(())
}
}
impl Unparse for FieldDeclaration {
fn unparse(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
if self.is_mutable {
if self.is_mutable() {
writer.write("mut ")?;
}
writer.write("fld ")?;
self.identifier.unparse(writer)?;
self.identifier().unparse(writer)?;
writer.write(": ")?;
self.declared_type.unparse(writer)?;
self.declared_type().unparse(writer)?;
Ok(())
}
}
/* Statements */
impl Unparse for UseStatement {
fn unparse(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
writer.write_indented("use ")?;
for (i, identifier) in self.identifiers.iter().enumerate() {
identifier.unparse(writer)?;
if i != self.identifiers.len() - 2 {
// 2 because of use
writer.write("::")?;
}
}
self.last.unparse(writer)?;
Ok(())
}
}
impl Unparse for UseStatementLast {
fn unparse(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
match self {
UseStatementLast::Star => writer.write("*"),
UseStatementLast::Identifiers(identifiers) => {
writer.write("{")?;
for (i, identifier) in identifiers.iter().enumerate() {
identifier.borrow().unparse(writer)?;
if i != identifiers.len() - 1 {
writer.write(", ")?;
}
}
writer.write("}")?;
Ok(())
}
UseStatementLast::Identifier(i) => i.borrow().unparse(writer),
}
}
}
impl Unparse for BlockStatement {
fn unparse(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
writer.writeln_indented("{")?;
@ -1024,7 +1027,7 @@ impl ListUnparse for CallArguments {
}
fn inner(&self) -> Vec<&dyn Unparse> {
to_unparse_vec!(self.0)
to_unparse_vec!(self.arguments())
}
}

2
src/lib.rs
View File

@ -1,5 +1,7 @@
#![feature(new_range_api)]
#![allow(warnings)]
extern crate core;
pub mod ast;
pub mod diagnostic;
pub mod module;

20
src/parser/deimos.pest
View File

@ -120,6 +120,7 @@ Star = { "*" }
LeftShift = { "<<" }
RightShift = { ">>" }
Index = { "[]" }
BorrowMut = { Borrow ~ Mut }
Operator = {
Or
@ -135,16 +136,19 @@ Operator = {
| Multiply
| Divide
| Modulo
| LeftShift
| RightShift
// unary prefix
| Spread
| BorrowMut
| Borrow
| Star
| Not
| Negative
// unary suffix
| PlusPlus
| MinusMinus
| CallOp
| Spread
| Borrow
| Star
| LeftShift
| RightShift
| Index
}
@ -457,10 +461,10 @@ InterfaceDefaultOperatorFunction = {
Def
~ FunctionModifier?
~ Op
~ GenericParameters?
~ Operator
~ Parameters
~ ReturnType
~ RefList?
~ FunctionBody
}
@ -698,10 +702,6 @@ PrefixExpression = {
~ SuffixExpression
}
BorrowMut = {
Borrow ~ Mut
}
SuffixExpression = {
PrimaryExpression
~ (