1075 lines
36 KiB
Rust
1075 lines
36 KiB
Rust
use crate::ast::node::call_expression::*;
|
|
use crate::ast::node::class::*;
|
|
use crate::ast::node::closure::*;
|
|
use crate::ast::node::compilation_unit::*;
|
|
use crate::ast::node::d_string::*;
|
|
use crate::ast::node::expression::*;
|
|
use crate::ast::node::function::*;
|
|
use crate::ast::node::generics::*;
|
|
use crate::ast::node::implements_list::*;
|
|
use crate::ast::node::interface::*;
|
|
use crate::ast::node::level::*;
|
|
use crate::ast::node::literal::*;
|
|
use crate::ast::node::module::*;
|
|
use crate::ast::node::named::Named;
|
|
use crate::ast::node::names::*;
|
|
use crate::ast::node::object_access::*;
|
|
use crate::ast::node::operators::*;
|
|
use crate::ast::node::statement::*;
|
|
use crate::ast::node::tuple_arguments::*;
|
|
use crate::ast::node::type_use::*;
|
|
use crate::ast::node::use_statement::*;
|
|
use crate::ast::unparse::Unparse;
|
|
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 crate::ast::node::operators::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(")?;
|
|
self.unparse(writer)?;
|
|
writer.writeln(")")?;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for PrefixUnaryOperator {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.write_indented("PrefixUnaryOperator(")?;
|
|
self.unparse(writer)?;
|
|
writer.writeln(")")?;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for SuffixUnaryOperator {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.write_indented("SuffixUnaryOperator(")?;
|
|
self.unparse(writer)?;
|
|
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 crate::ast::node::type_use::TypeUse::*;
|
|
match self {
|
|
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();
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for PrimitiveTypeUse {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
use crate::ast::node::type_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!(
|
|
"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.arguments() {
|
|
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.identifiers() {
|
|
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.type_uses() {
|
|
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.type_uses() {
|
|
type_use.pretty_print(writer)?;
|
|
}
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for FunctionTypeModifier {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
use crate::ast::node::function::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.parameters() {
|
|
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.identifiers() {
|
|
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 use_statement in self.use_statements() {
|
|
use_statement.pretty_print(writer)?;
|
|
}
|
|
for declaration in self.declarations() {
|
|
declaration.pretty_print(writer)?;
|
|
}
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for UseStatement {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
writer.writeln_indented("UseStatement")?;
|
|
writer.increase_indent();
|
|
match self {
|
|
UseStatement::Concrete(concrete_use_statement) => {
|
|
writer.writeln_indented(&format!("ConcreteUseStatement(prefixes = {})", concrete_use_statement.join_prefixes()))?;
|
|
writer.increase_indent();
|
|
for identifier in concrete_use_statement.identifiers() {
|
|
identifier.pretty_print(writer)?;
|
|
}
|
|
writer.decrease_indent();
|
|
}
|
|
UseStatement::Star(star_use_statement) => {
|
|
writer.writeln_indented(&format!("StarUseStatement(prefixes = {})", star_use_statement.join_prefixes()))?;
|
|
}
|
|
}
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for ModuleLevelDeclaration {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
use crate::ast::node::level::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 crate::ast::node::level::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 crate::ast::node::level::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 crate::ast::node::function::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 crate::ast::node::function::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.parameters() {
|
|
constructor_parameter.pretty_print(writer)?;
|
|
}
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for ClassConstructorParameter {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
use crate::ast::node::class::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 crate::ast::node::statement::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.expression().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.expression() {
|
|
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.if_statements() {
|
|
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.block_statement().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 crate::ast::node::expression::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(literal) => literal.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.generics().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.arguments() {
|
|
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.expression().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.captures() {
|
|
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.parameters() {
|
|
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.navigations() {
|
|
object_navigation.pretty_print(writer)?;
|
|
}
|
|
writer.decrease_indent();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl PrettyPrint for ObjectNavigation {
|
|
fn pretty_print(&self, writer: &mut IndentWriter) -> std::io::Result<()> {
|
|
use crate::ast::node::object_access::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 crate::ast::node::literal::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.parts() {
|
|
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),
|
|
}
|
|
}
|
|
}
|