1019 lines
33 KiB
Rust
1019 lines
33 KiB
Rust
use crate::ast::*;
|
|
use crate::util::indent_writer::IndentWriter;
|
|
use std::fmt::Debug;
|
|
|
|
pub trait PrettyPrint {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()>;
|
|
}
|
|
|
|
impl PrettyPrint for Operator {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
use Operator::*;
|
|
match self {
|
|
Binary(o) => o.pretty_print(writer),
|
|
PrefixUnary(o) => o.pretty_print(writer),
|
|
SuffixUnary(o) => o.pretty_print(writer),
|
|
}
|
|
}
|
|
}
|
|
|
|
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(">>"),
|
|
}?;
|
|
writer.writeln(")")?;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
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("-"),
|
|
}?;
|
|
writer.writeln(")")?;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
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("--"),
|
|
}?;
|
|
writer.write(")")?;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for Identifier {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented(&format!("Identifier({})", self.name))
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for FullyQualifiedName {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented("FullyQualifiedName")?;
|
|
writer.increase_indent();
|
|
for identifier in &self.identifiers {
|
|
identifier.pretty_print(writer)?;
|
|
}
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for TypeUse {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
use TypeUse::*;
|
|
match self {
|
|
Void => {
|
|
writer.writeln_indented("TypeUse(Void)")?;
|
|
}
|
|
InterfaceOrClass(t) => {
|
|
writer.increase_indent();
|
|
t.pretty_print(writer)?;
|
|
writer.decrease_indent();
|
|
}
|
|
Tuple(t) => {
|
|
writer.increase_indent();
|
|
t.pretty_print(writer)?;
|
|
writer.decrease_indent();
|
|
}
|
|
Function(t) => {
|
|
writer.increase_indent();
|
|
t.pretty_print(writer)?;
|
|
writer.decrease_indent();
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for InterfaceOrClassTypeUse {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented(&format!(
|
|
"InterfaceOrClassTypeUse(borrow_count = {}, is_mutable = {})",
|
|
self.borrow_count, self.is_mutable
|
|
))?;
|
|
writer.increase_indent();
|
|
self.fqn.pretty_print(writer)?;
|
|
self.generics.pretty_print(writer)?;
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for TupleTypeUse {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented(&format!(
|
|
"TupleTypeUse(borrow_count = {}, is_mutable = {})",
|
|
self.borrow_count, self.is_mutable
|
|
))?;
|
|
writer.increase_indent();
|
|
self.arguments.pretty_print(writer)?;
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for FunctionTypeUse {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented(&format!(
|
|
"FunctionTypeUse(borrow_count = {})",
|
|
self.borrow_count
|
|
))?;
|
|
writer.increase_indent();
|
|
if let Some(function_type_modifier) = &self.function_modifier {
|
|
function_type_modifier.pretty_print(writer)?;
|
|
}
|
|
self.generics.pretty_print(writer)?;
|
|
self.parameters.pretty_print(writer)?;
|
|
self.return_type.pretty_print(writer)?;
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for GenericArguments {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented("GenericArguments")?;
|
|
writer.increase_indent();
|
|
for type_use in &self.0 {
|
|
type_use.pretty_print(writer)?;
|
|
}
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for GenericParameters {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented("GenericParameters")?;
|
|
writer.increase_indent();
|
|
for identifier in &self.0 {
|
|
identifier.pretty_print(writer)?;
|
|
}
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for TupleArguments {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented("TupleArguments")?;
|
|
writer.increase_indent();
|
|
for type_use in &self.0 {
|
|
type_use.pretty_print(writer)?;
|
|
}
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for ImplementsList {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented("ImplementsList")?;
|
|
writer.increase_indent();
|
|
for type_use in &self.0 {
|
|
type_use.pretty_print(writer)?;
|
|
}
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for FunctionTypeModifier {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
use FunctionTypeModifier::*;
|
|
writer.writeln_indented(&format!(
|
|
"FunctionTypeModifier({})",
|
|
match self {
|
|
Cons => "cons",
|
|
MutRef => "mut ref",
|
|
Mut => "mut",
|
|
Ref => "ref",
|
|
}
|
|
))
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for Parameters {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented("Parameters")?;
|
|
writer.increase_indent();
|
|
for parameter in &self.0 {
|
|
parameter.pretty_print(writer)?;
|
|
}
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for Parameter {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented("Parameter")?;
|
|
writer.increase_indent();
|
|
self.identifier.pretty_print(writer)?;
|
|
self.type_use.pretty_print(writer)?;
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for ReturnType {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented("ReturnType")?;
|
|
writer.increase_indent();
|
|
self.declared_type.pretty_print(writer)?;
|
|
self.references.pretty_print(writer)?;
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for References {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented("References")?;
|
|
writer.increase_indent();
|
|
for identifier in &self.0 {
|
|
identifier.pretty_print(writer)?;
|
|
}
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for CompilationUnit {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented("CompilationUnit")?;
|
|
writer.increase_indent();
|
|
if let Some(namespace) = &self.namespace {
|
|
writer.writeln_indented("Namespace")?;
|
|
writer.increase_indent();
|
|
namespace.pretty_print(writer)?;
|
|
writer.decrease_indent();
|
|
}
|
|
for declaration in &self.declarations {
|
|
declaration.pretty_print(writer)?;
|
|
}
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for ModuleLevelDeclaration {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
use ModuleLevelDeclaration::*;
|
|
match self {
|
|
Module(module) => module.pretty_print(writer),
|
|
Interface(interface) => interface.pretty_print(writer),
|
|
Class(class) => class.pretty_print(writer),
|
|
Function(function) => function.pretty_print(writer),
|
|
PlatformFunction(platform_function) => platform_function.pretty_print(writer),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for InterfaceLevelDeclaration {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
use InterfaceLevelDeclaration::*;
|
|
match self {
|
|
Module(module) => module.pretty_print(writer),
|
|
Interface(interface) => interface.pretty_print(writer),
|
|
Class(class) => class.pretty_print(writer),
|
|
Function(function) => function.pretty_print(writer),
|
|
OperatorFunction(operator_function) => operator_function.pretty_print(writer),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for ClassLevelDeclaration {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
use ClassLevelDeclaration::*;
|
|
match self {
|
|
Module(module) => module.pretty_print(writer),
|
|
Interface(interface) => interface.pretty_print(writer),
|
|
Class(class) => class.pretty_print(writer),
|
|
Function(function) => function.pretty_print(writer),
|
|
OperatorFunction(operator_function) => operator_function.pretty_print(writer),
|
|
PlatformFunction(platform_function) => platform_function.pretty_print(writer),
|
|
Property(property) => property.pretty_print(writer),
|
|
Field(field) => field.pretty_print(writer),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for ModuleDeclaration {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented(&format!(
|
|
"ModuleDeclaration(is_public = {})",
|
|
self.is_public
|
|
))?;
|
|
writer.increase_indent();
|
|
self.identifier.pretty_print(writer)?;
|
|
for declaration in &self.declarations {
|
|
declaration.pretty_print(writer)?;
|
|
}
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for InterfaceDeclaration {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented(&format!(
|
|
"InterfaceDeclaration(is_public = {})",
|
|
self.is_public
|
|
))?;
|
|
writer.increase_indent();
|
|
self.identifier.pretty_print(writer)?;
|
|
self.generics.pretty_print(writer)?;
|
|
self.implements.pretty_print(writer)?;
|
|
for declaration in &self.declarations {
|
|
declaration.pretty_print(writer)?;
|
|
}
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for ClassDeclaration {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented(&format!("ClassDeclaration(is_public = {})", self.is_public))?;
|
|
writer.increase_indent();
|
|
self.identifier.pretty_print(writer)?;
|
|
self.generics.pretty_print(writer)?;
|
|
if let Some(class_constructor) = &self.class_constructor {
|
|
class_constructor.pretty_print(writer)?;
|
|
}
|
|
self.implements.pretty_print(writer)?;
|
|
for declaration in &self.declarations {
|
|
declaration.pretty_print(writer)?;
|
|
}
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for FunctionDefinition {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented(&format!(
|
|
"FunctionDefinition(is_public = {})",
|
|
self.is_public
|
|
))?;
|
|
writer.increase_indent();
|
|
if let Some(modifier) = &self.modifier {
|
|
modifier.pretty_print(writer)?;
|
|
}
|
|
self.generics.pretty_print(writer)?;
|
|
self.identifier.pretty_print(writer)?;
|
|
self.parameters.pretty_print(writer)?;
|
|
self.return_type.pretty_print(writer)?;
|
|
self.body.pretty_print(writer)?;
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for OperatorFunctionDefinition {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented(&format!(
|
|
"OperatorFunctionDefinition(is_public = {})",
|
|
self.is_public
|
|
))?;
|
|
writer.increase_indent();
|
|
if let Some(modifier) = &self.modifier {
|
|
modifier.pretty_print(writer)?;
|
|
}
|
|
self.generics.pretty_print(writer)?;
|
|
self.operator.pretty_print(writer)?;
|
|
self.parameters.pretty_print(writer)?;
|
|
self.return_type.pretty_print(writer)?;
|
|
self.body.pretty_print(writer)?;
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for PlatformFunctionDeclaration {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented(&format!(
|
|
"PlatformFunctionDeclaration(is_public = {})",
|
|
self.is_public
|
|
))?;
|
|
writer.increase_indent();
|
|
if let Some(modifier) = &self.modifier {
|
|
modifier.pretty_print(writer)?;
|
|
}
|
|
self.generics.pretty_print(writer)?;
|
|
self.identifier.pretty_print(writer)?;
|
|
self.parameters.pretty_print(writer)?;
|
|
self.return_type.pretty_print(writer)?;
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for InterfaceFunctionDeclaration {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented("InterfaceFunctionDeclaration")?;
|
|
writer.increase_indent();
|
|
if let Some(modifier) = &self.modifier {
|
|
modifier.pretty_print(writer)?;
|
|
}
|
|
self.generics.pretty_print(writer)?;
|
|
self.identifier.pretty_print(writer)?;
|
|
self.parameters.pretty_print(writer)?;
|
|
self.return_type.pretty_print(writer)?;
|
|
if let Some(body) = &self.body {
|
|
body.pretty_print(writer)?;
|
|
}
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for InterfaceOperatorFunctionDeclaration {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented("InterfaceOperatorFunctionDeclaration")?;
|
|
writer.increase_indent();
|
|
if let Some(modifier) = &self.modifier {
|
|
modifier.pretty_print(writer)?;
|
|
}
|
|
self.generics.pretty_print(writer)?;
|
|
self.operator.pretty_print(writer)?;
|
|
self.parameters.pretty_print(writer)?;
|
|
self.return_type.pretty_print(writer)?;
|
|
if let Some(body) = &self.body {
|
|
body.pretty_print(writer)?;
|
|
}
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for FunctionModifier {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
use FunctionModifier::*;
|
|
writer.writeln_indented(&format!(
|
|
"FunctionModifier({})",
|
|
match self {
|
|
Static => "static",
|
|
Cons => "cons",
|
|
Mut => "mut",
|
|
Ref => "ref",
|
|
MutRef => "mut ref",
|
|
}
|
|
))
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for FunctionBody {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
use FunctionBody::*;
|
|
match self {
|
|
Equals(expression) => {
|
|
writer.writeln_indented("EqualsFunctionBody")?;
|
|
writer.increase_indent();
|
|
expression.pretty_print(writer)?;
|
|
writer.decrease_indent();
|
|
}
|
|
Block(block_statement) => {
|
|
writer.writeln_indented("BlockFunctionBody")?;
|
|
writer.increase_indent();
|
|
block_statement.pretty_print(writer)?;
|
|
writer.decrease_indent();
|
|
}
|
|
Alias(identifier) => {
|
|
writer.writeln_indented("AliasFunctionBody")?;
|
|
writer.increase_indent();
|
|
identifier.pretty_print(writer)?;
|
|
writer.decrease_indent();
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for ClassConstructor {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented("ClassConstructor")?;
|
|
writer.increase_indent();
|
|
for constructor_parameter in &self.0 {
|
|
constructor_parameter.pretty_print(writer)?;
|
|
}
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for ClassConstructorParameter {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
use ClassConstructorParameter::*;
|
|
match self {
|
|
Property(property) => {
|
|
writer.writeln_indented("PropertyConstructorParameter")?;
|
|
writer.increase_indent();
|
|
property.pretty_print(writer)?;
|
|
writer.decrease_indent();
|
|
}
|
|
Field(field) => {
|
|
writer.writeln_indented("FieldConstructorParameter")?;
|
|
writer.increase_indent();
|
|
field.pretty_print(writer)?;
|
|
writer.decrease_indent();
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for PropertyDeclaration {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented(&format!(
|
|
"PropertyDeclaration(is_mutable = {})",
|
|
self.is_mutable
|
|
))?;
|
|
writer.increase_indent();
|
|
self.identifier.pretty_print(writer)?;
|
|
self.declared_type.pretty_print(writer)?;
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for FieldDeclaration {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented(&format!(
|
|
"FieldDeclaration(is_mutable = {})",
|
|
self.is_mutable
|
|
))?;
|
|
writer.increase_indent();
|
|
self.identifier.pretty_print(writer)?;
|
|
self.declared_type.pretty_print(writer)?;
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for BlockStatement {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented("BlockStatement")?;
|
|
writer.increase_indent();
|
|
for statement in &self.statements {
|
|
statement.pretty_print(writer)?;
|
|
}
|
|
if let Some(expression) = &self.expression {
|
|
expression.pretty_print(writer)?;
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for Statement {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
use Statement::*;
|
|
match self {
|
|
BlockStatement(block_statement) => block_statement.pretty_print(writer),
|
|
VariableDeclarationStatement(s) => s.pretty_print(writer),
|
|
AssignStatement(s) => s.pretty_print(writer),
|
|
CallStatement(s) => s.pretty_print(writer),
|
|
ReturnStatement(s) => s.pretty_print(writer),
|
|
IfStatement(s) => s.pretty_print(writer),
|
|
IfElseStatement(s) => s.pretty_print(writer),
|
|
WhileStatement(s) => s.pretty_print(writer),
|
|
ForStatement(s) => s.pretty_print(writer),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for VariableDeclarationStatement {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented(&format!(
|
|
"VariableDeclarationStatement(is_mutable = {})",
|
|
self.is_mutable
|
|
))?;
|
|
writer.increase_indent();
|
|
self.identifier.pretty_print(writer)?;
|
|
if let Some(declared_type) = &self.declared_type {
|
|
declared_type.pretty_print(writer)?;
|
|
}
|
|
if let Some(initializer) = &self.initializer {
|
|
initializer.pretty_print(writer)?;
|
|
}
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for AssignStatement {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented("AssignStatement")?;
|
|
writer.increase_indent();
|
|
self.lhs.pretty_print(writer)?;
|
|
self.rhs.pretty_print(writer)?;
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for CallStatement {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented("CallStatement")?;
|
|
writer.increase_indent();
|
|
self.0.pretty_print(writer)?;
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for ReturnStatement {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented("ReturnStatement")?;
|
|
if let Some(expression) = &self.0 {
|
|
writer.increase_indent();
|
|
expression.pretty_print(writer)?;
|
|
writer.decrease_indent();
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for IfStatement {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented("IfStatement")?;
|
|
writer.increase_indent();
|
|
writer.increase_indent();
|
|
self.condition.pretty_print(writer)?;
|
|
self.then_block.pretty_print(writer)?;
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for IfElseStatement {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented("IfElseStatement")?;
|
|
writer.increase_indent();
|
|
self.if_statement.pretty_print(writer)?;
|
|
self.else_ifs.pretty_print(writer)?;
|
|
if let Some(else_block) = &self.else_block {
|
|
else_block.pretty_print(writer)?;
|
|
}
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for ElseIfs {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented("ElseIfs")?;
|
|
writer.increase_indent();
|
|
for if_statement in &self.0 {
|
|
if_statement.pretty_print(writer)?;
|
|
}
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for ElseBlock {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented("ElseBlock")?;
|
|
writer.increase_indent();
|
|
self.0.pretty_print(writer)?;
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for WhileStatement {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented("WhileStatement")?;
|
|
writer.increase_indent();
|
|
self.condition.pretty_print(writer)?;
|
|
self.body.pretty_print(writer)?;
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for ForStatement {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented("ForStatement")?;
|
|
writer.increase_indent();
|
|
self.variable.pretty_print(writer)?;
|
|
self.iterator.pretty_print(writer)?;
|
|
self.body.pretty_print(writer)?;
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for Expression {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
use Expression::*;
|
|
match self {
|
|
Ternary(e) => e.pretty_print(writer),
|
|
Binary(e) => e.pretty_print(writer),
|
|
UnaryPrefix(e) => e.pretty_print(writer),
|
|
UnarySuffix(e) => e.pretty_print(writer),
|
|
Call(e) => e.pretty_print(writer),
|
|
ObjectAccess(o) => o.pretty_print(writer),
|
|
Literal(literial) => literial.pretty_print(writer),
|
|
FullyQualifiedName(fqn) => fqn.pretty_print(writer),
|
|
Closure(closure) => closure.pretty_print(writer),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for TernaryExpression {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented("TernaryExpression")?;
|
|
writer.increase_indent();
|
|
self.condition.pretty_print(writer)?;
|
|
self.true_expression.pretty_print(writer)?;
|
|
self.false_expression.pretty_print(writer)?;
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for BinaryExpression {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented("BinaryExpression")?;
|
|
writer.increase_indent();
|
|
self.left.pretty_print(writer)?;
|
|
self.operator.pretty_print(writer)?;
|
|
self.right.pretty_print(writer)?;
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for PrefixExpression {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented("PrefixExpression")?;
|
|
writer.increase_indent();
|
|
self.operator.pretty_print(writer)?;
|
|
self.expression.pretty_print(writer)?;
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for SuffixExpression {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented("SuffixExpression")?;
|
|
writer.increase_indent();
|
|
self.expression.pretty_print(writer)?;
|
|
self.operator.pretty_print(writer)?;
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for CallExpression {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented("CallExpression")?;
|
|
writer.increase_indent();
|
|
self.callee.pretty_print(writer)?;
|
|
if let Some(turbo_fish) = &self.turbo_fish {
|
|
turbo_fish.pretty_print(writer)?;
|
|
}
|
|
self.arguments.pretty_print(writer)?;
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for TurboFish {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented("TurboFish")?;
|
|
writer.increase_indent();
|
|
self.0.pretty_print(writer)?;
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for CallArguments {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented("CallArguments")?;
|
|
writer.increase_indent();
|
|
for call_argument in &self.0 {
|
|
call_argument.pretty_print(writer)?;
|
|
}
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for CallArgument {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented("CallArgument")?;
|
|
writer.increase_indent();
|
|
self.0.pretty_print(writer)?;
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for Closure {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented(&format!("Closure(is_move = {})", self.is_move))?;
|
|
writer.increase_indent();
|
|
if let Some(modifier) = &self.modifier {
|
|
modifier.pretty_print(writer)?;
|
|
}
|
|
self.captures.pretty_print(writer)?;
|
|
self.parameters.pretty_print(writer)?;
|
|
if !self.statements.is_empty() {
|
|
writer.writeln_indented("ClosureStatements")?;
|
|
writer.increase_indent();
|
|
for statement in &self.statements {
|
|
statement.pretty_print(writer)?;
|
|
}
|
|
writer.decrease_indent();
|
|
}
|
|
if let Some(expression) = &self.expression {
|
|
expression.pretty_print(writer)?;
|
|
}
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for ClosureModifier {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented(&format!(
|
|
"ClosureModifier({})",
|
|
match self {
|
|
ClosureModifier::Mut => "mut",
|
|
ClosureModifier::Cons => "cons",
|
|
}
|
|
))
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for ClosureCaptures {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented("ClosureCaptures")?;
|
|
writer.increase_indent();
|
|
for capture in &self.0 {
|
|
capture.pretty_print(writer)?;
|
|
}
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for ClosureCapture {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented(&format!(
|
|
"ClosureCapture(borrow_count = {}, is_mutable = {})",
|
|
self.borrow_count, self.is_mutable
|
|
))?;
|
|
writer.increase_indent();
|
|
self.identifier.pretty_print(writer)?;
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for ClosureParameters {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented("ClosureParameters")?;
|
|
writer.increase_indent();
|
|
for parameter in &self.0 {
|
|
parameter.pretty_print(writer)?;
|
|
}
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for ClosureParameter {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented("ClosureParameter")?;
|
|
writer.increase_indent();
|
|
self.identifier.pretty_print(writer)?;
|
|
if let Some(type_use) = &self.type_use {
|
|
type_use.pretty_print(writer)?;
|
|
}
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for ObjectAccess {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented("ObjectAccess")?;
|
|
writer.increase_indent();
|
|
self.receiver.pretty_print(writer)?;
|
|
self.navigations.pretty_print(writer)?;
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for ObjectNavigations {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented("ObjectNavigations")?;
|
|
writer.increase_indent();
|
|
for object_navigation in &self.0 {
|
|
object_navigation.pretty_print(writer)?;
|
|
}
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for ObjectNavigation {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
use ObjectNavigation::*;
|
|
match self {
|
|
Index(e) => {
|
|
writer.writeln_indented("Index")?;
|
|
writer.increase_indent();
|
|
e.pretty_print(writer)?;
|
|
writer.decrease_indent();
|
|
}
|
|
Identifier(identifier) => {
|
|
writer.writeln_indented("Property")?;
|
|
writer.increase_indent();
|
|
identifier.pretty_print(writer)?;
|
|
writer.decrease_indent();
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for Literal {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
use Literal::*;
|
|
match self {
|
|
Integer(i) => writer.writeln_indented(&format!("Integer({})", i)),
|
|
Long(l) => writer.writeln_indented(&format!("Long({})", l)),
|
|
Double(d) => writer.writeln_indented(&format!("Double({})", d)),
|
|
USize(u) => writer.writeln_indented(&format!("USize({})", u)),
|
|
String(s) => writer.writeln_indented(&format!("String({})", s)),
|
|
DString(d_string) => d_string.pretty_print(writer),
|
|
BacktickString(d_string) => d_string.pretty_print(writer),
|
|
Boolean(b) => writer.writeln_indented(&format!("Boolean({})", b)),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for DString {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented("DString")?;
|
|
writer.increase_indent();
|
|
for part in &self.0 {
|
|
part.pretty_print(writer)?;
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for DStringPart {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented("DStringPart")?;
|
|
writer.increase_indent();
|
|
match self {
|
|
DStringPart::String(s) => writer.writeln_indented(&format!("String({})", s)),
|
|
DStringPart::Expression(e) => e.pretty_print(writer),
|
|
}
|
|
}
|
|
}
|