Skip to content

Commit

Permalink
minor fixes
Browse files Browse the repository at this point in the history
  • Loading branch information
@SpontanCombust
SpontanCombust committed Jan 18, 2024
1 parent 83a37bf commit f97d097
Show file tree
Hide file tree
Showing 18 changed files with 212 additions and 170 deletions.
2 changes: 1 addition & 1 deletion .cargo/config.toml
View file
Original file line number Diff line number Diff line change
@@ -1,2 +1,2 @@
[alias]
xtask = "run --package xtask --"
xtask = "run --package xtask --release --"
48 changes: 29 additions & 19 deletions crates/core/src/ast/classes.rs
View file
Original file line number Diff line number Diff line change
@@ -1,5 +1,5 @@
use std::fmt::Debug;
use crate::{NamedSyntaxNode, SyntaxNode, tokens::*, attribs::*, AnyNode};
use crate::{NamedSyntaxNode, SyntaxNode, tokens::*, attribs::*, AnyNode, DebugMaybeAlternate};
use super::*;


Expand Down Expand Up @@ -81,12 +81,7 @@ impl ClassBlockNode<'_> {

impl Debug for ClassBlockNode<'_> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let stmts = self.statements().collect::<Vec<_>>();
if f.alternate() {
write!(f, "ClassBlock{:#?}", stmts)
} else {
write!(f, "ClassBlock{:?}", stmts)
}
f.debug_maybe_alternate_named("ClassBlock", &self.statements().collect::<Vec<_>>())
}
}

Expand All @@ -109,7 +104,7 @@ impl StatementTraversal for ClassBlockNode<'_> {
}


#[derive(Debug, Clone)]
#[derive(Clone)]
pub enum ClassStatement<'script> {
Var(MemberVarDeclarationNode<'script>),
Default(MemberDefaultValueNode<'script>),
Expand All @@ -120,6 +115,20 @@ pub enum ClassStatement<'script> {
Nop(NopNode<'script>)
}

impl Debug for ClassStatement<'_> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Var(n) => f.debug_maybe_alternate(n),
Self::Default(n) => f.debug_maybe_alternate(n),
Self::Hint(n) => f.debug_maybe_alternate(n),
Self::Autobind(n) => f.debug_maybe_alternate(n),
Self::Method(n) => f.debug_maybe_alternate(n),
Self::Event(n) => f.debug_maybe_alternate(n),
Self::Nop(n) => f.debug_maybe_alternate(n),
}
}
}

pub type ClassStatementNode<'script> = SyntaxNode<'script, ClassStatement<'script>>;

impl<'script> ClassStatementNode<'script> {
Expand All @@ -139,11 +148,7 @@ impl<'script> ClassStatementNode<'script> {

impl Debug for ClassStatementNode<'_> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
if f.alternate() {
write!(f, "{:#?}", self.clone().value())
} else {
write!(f, "{:?}", self.clone().value())
}
f.debug_maybe_alternate(&self.clone().value())
}
}

Expand Down Expand Up @@ -238,12 +243,21 @@ impl StatementTraversal for AutobindDeclarationNode<'_> {



#[derive(Debug, Clone)]
#[derive(Clone)]
pub enum AutobindValue<'script> {
Single,
Concrete(LiteralStringNode<'script>)
}

impl Debug for AutobindValue<'_> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Single => write!(f, "Single"),
Self::Concrete(n) => f.debug_tuple("Concrete").field(n).finish(),
}
}
}

pub type AutobindValueNode<'script> = SyntaxNode<'script, AutobindValue<'script>>;

impl AutobindValueNode<'_> {
Expand All @@ -262,10 +276,6 @@ impl AutobindValueNode<'_> {

impl Debug for AutobindValueNode<'_> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
if f.alternate() {
write!(f, "{:#?}", self.value())
} else {
write!(f, "{:?}", self.value())
}
f.debug_maybe_alternate(&self.value())
}
}
9 changes: 2 additions & 7 deletions crates/core/src/ast/enums.rs
View file
Original file line number Diff line number Diff line change
@@ -1,5 +1,5 @@
use std::fmt::Debug;
use crate::{tokens::{IdentifierNode, LiteralIntNode}, NamedSyntaxNode, SyntaxNode, AnyNode};
use crate::{tokens::{IdentifierNode, LiteralIntNode}, NamedSyntaxNode, SyntaxNode, AnyNode, DebugMaybeAlternate};
use super::{StatementTraversal, StatementVisitor};


Expand Down Expand Up @@ -71,12 +71,7 @@ impl EnumBlockNode<'_> {

impl Debug for EnumBlockNode<'_> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let members = self.members().collect::<Vec<_>>();
if f.alternate() {
write!(f, "EnumBlock{:#?}", members)
} else {
write!(f, "EnumBlock{:?}", members)
}
f.debug_maybe_alternate_named("EnumBlock", &self.members().collect::<Vec<_>>())
}
}

Expand Down
46 changes: 35 additions & 11 deletions crates/core/src/ast/expressions.rs
View file
Original file line number Diff line number Diff line change
@@ -1,5 +1,5 @@
use std::fmt::Debug;
use crate::{SyntaxNode, NamedSyntaxNode, tokens::*, AnyNode};
use crate::{SyntaxNode, NamedSyntaxNode, tokens::*, AnyNode, DebugMaybeAlternate};
use super::{StatementTraversal, ExpressionVisitor, ExpressionTraversal, StatementVisitor};


Expand Down Expand Up @@ -68,7 +68,7 @@ impl<'script> TryFrom<AnyNode<'script>> for ThisExpressionNode<'script> {
type Error = ();

fn try_from(value: AnyNode<'script>) -> Result<Self, Self::Error> {
if value.tree_node.kind() == Self::NODE_KIND {
if value.tree_node.is_named() && value.tree_node.kind() == Self::NODE_KIND {
Ok(value.into())
} else {
Err(())
Expand Down Expand Up @@ -105,7 +105,7 @@ impl<'script> TryFrom<AnyNode<'script>> for SuperExpressionNode<'script> {
type Error = ();

fn try_from(value: AnyNode<'script>) -> Result<Self, Self::Error> {
if value.tree_node.kind() == Self::NODE_KIND {
if value.tree_node.is_named() && value.tree_node.kind() == Self::NODE_KIND {
Ok(value.into())
} else {
Err(())
Expand Down Expand Up @@ -142,7 +142,7 @@ impl<'script> TryFrom<AnyNode<'script>> for ParentExpressionNode<'script> {
type Error = ();

fn try_from(value: AnyNode<'script>) -> Result<Self, Self::Error> {
if value.tree_node.kind() == Self::NODE_KIND {
if value.tree_node.is_named() && value.tree_node.kind() == Self::NODE_KIND {
Ok(value.into())
} else {
Err(())
Expand Down Expand Up @@ -179,7 +179,7 @@ impl<'script> TryFrom<AnyNode<'script>> for VirtualParentExpressionNode<'script>
type Error = ();

fn try_from(value: AnyNode<'script>) -> Result<Self, Self::Error> {
if value.tree_node.kind() == Self::NODE_KIND {
if value.tree_node.is_named() && value.tree_node.kind() == Self::NODE_KIND {
Ok(value.into())
} else {
Err(())
Expand Down Expand Up @@ -770,7 +770,7 @@ impl ExpressionTraversal for TernaryConditionalExpressionNode<'_> {


// Represents the anonymous $._expr node
#[derive(Debug, Clone)]
#[derive(Clone)]
pub enum Expression<'script> {
Nested(NestedExpressionNode<'script>),
Literal(LiteralNode<'script>),
Expand All @@ -791,6 +791,30 @@ pub enum Expression<'script> {
TernaryConditional(TernaryConditionalExpressionNode<'script>),
}

impl Debug for Expression<'_> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Nested(n) => f.debug_maybe_alternate(n),
Self::Literal(n) => f.debug_maybe_alternate(n),
Self::This(n) => f.debug_maybe_alternate(n),
Self::Super(n) => f.debug_maybe_alternate(n),
Self::Parent(n) => f.debug_maybe_alternate(n),
Self::VirtualParent(n) => f.debug_maybe_alternate(n),
Self::Identifier(n) => f.debug_maybe_alternate(n),
Self::FunctionCall(n) => f.debug_maybe_alternate(n),
Self::Array(n) => f.debug_maybe_alternate(n),
Self::MemberField(n) => f.debug_maybe_alternate(n),
Self::MethodCall(n) => f.debug_maybe_alternate(n),
Self::Instantiation(n) => f.debug_maybe_alternate(n),
Self::TypeCast(n) => f.debug_maybe_alternate(n),
Self::UnaryOperation(n) => f.debug_maybe_alternate(n),
Self::BinaryOperation(n) => f.debug_maybe_alternate(n),
Self::AssignmentOperation(n) => f.debug_maybe_alternate(n),
Self::TernaryConditional(n) => f.debug_maybe_alternate(n),
}
}
}

pub type ExpressionNode<'script> = SyntaxNode<'script, Expression<'script>>;

impl<'script> ExpressionNode<'script> {
Expand Down Expand Up @@ -820,18 +844,18 @@ impl<'script> ExpressionNode<'script> {

impl Debug for ExpressionNode<'_> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
if f.alternate() {
write!(f, "{:#?}", self.clone().value())
} else {
write!(f, "{:?}", self.clone().value())
}
f.debug_maybe_alternate(&self.clone().value())
}
}

impl<'script> TryFrom<AnyNode<'script>> for ExpressionNode<'script> {
type Error = ();

fn try_from(value: AnyNode<'script>) -> Result<Self, Self::Error> {
if !value.tree_node.is_named() {
return Err(());
}

match value.tree_node.kind() {
AssignmentOperationExpressionNode::NODE_KIND |
TernaryConditionalExpressionNode::NODE_KIND |
Expand Down
41 changes: 28 additions & 13 deletions crates/core/src/ast/functions.rs
View file
Original file line number Diff line number Diff line change
@@ -1,5 +1,5 @@
use std::fmt::Debug;
use crate::{SyntaxNode, NamedSyntaxNode, tokens::IdentifierNode, attribs::*, AnyNode};
use crate::{SyntaxNode, NamedSyntaxNode, tokens::IdentifierNode, attribs::*, AnyNode, DebugMaybeAlternate};
use super::*;


Expand Down Expand Up @@ -258,7 +258,7 @@ impl StatementTraversal for FunctionParameterGroupNode<'_> {



#[derive(Debug, Clone)]
#[derive(Clone)]
pub enum FunctionStatement<'script> {
Var(VarDeclarationNode<'script>),
Expr(ExpressionStatementNode<'script>),
Expand All @@ -275,6 +275,26 @@ pub enum FunctionStatement<'script> {
Nop(NopNode<'script>),
}

impl Debug for FunctionStatement<'_> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Var(n) => f.debug_maybe_alternate(n),
Self::Expr(n) => f.debug_maybe_alternate(n),
Self::For(n) => f.debug_maybe_alternate(n),
Self::While(n) => f.debug_maybe_alternate(n),
Self::DoWhile(n) => f.debug_maybe_alternate(n),
Self::If(n) => f.debug_maybe_alternate(n),
Self::Switch(n) => f.debug_maybe_alternate(n),
Self::Break(n) => f.debug_maybe_alternate(n),
Self::Continue(n) => f.debug_maybe_alternate(n),
Self::Return(n) => f.debug_maybe_alternate(n),
Self::Delete(n) => f.debug_maybe_alternate(n),
Self::Block(n) => f.debug_maybe_alternate(n),
Self::Nop(n) => f.debug_maybe_alternate(n),
}
}
}

pub type FunctionStatementNode<'script> = SyntaxNode<'script, FunctionStatement<'script>>;

impl<'script> FunctionStatementNode<'script> {
Expand All @@ -300,18 +320,18 @@ impl<'script> FunctionStatementNode<'script> {

impl Debug for FunctionStatementNode<'_> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
if f.alternate() {
write!(f, "{:#?}", self.clone().value())
} else {
write!(f, "{:?}", self.clone().value())
}
f.debug_maybe_alternate(&self.clone().value())
}
}

impl<'script> TryFrom<AnyNode<'script>> for FunctionStatementNode<'script> {
type Error = ();

fn try_from(value: AnyNode<'script>) -> Result<Self, Self::Error> {
if !value.tree_node.is_named() {
return Err(());
}

match value.tree_node.kind() {
VarDeclarationNode::NODE_KIND |
ExpressionStatementNode::NODE_KIND |
Expand Down Expand Up @@ -369,12 +389,7 @@ impl FunctionBlockNode<'_> {

impl Debug for FunctionBlockNode<'_> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let stmts = self.statements().collect::<Vec<_>>();
if f.alternate() {
write!(f, "FunctionBlock{:#?}", stmts)
} else {
write!(f, "FunctionBlock{:?}", stmts)
}
f.debug_maybe_alternate_named("FunctionBlock", &self.statements().collect::<Vec<_>>())
}
}

Expand Down
4 changes: 0 additions & 4 deletions crates/core/src/ast/mod.rs
View file
Original file line number Diff line number Diff line change
@@ -1,7 +1,3 @@
use std::fmt::Debug;
use crate::{SyntaxNode, NamedSyntaxNode, AnyNode};


mod expressions;
mod functions;
mod classes;
Expand Down
4 changes: 2 additions & 2 deletions crates/core/src/ast/nop.rs
View file
Original file line number Diff line number Diff line change
@@ -1,8 +1,8 @@
use std::fmt::Debug;
use crate::{SyntaxNode, NamedSyntaxNode, AnyNode};

use super::StatementTraversal;


// Empty type essentially representing an orphaned/trailing semicolon
#[derive(Debug, Clone)]
pub struct Nop;
Expand All @@ -25,7 +25,7 @@ impl<'script> TryFrom<AnyNode<'script>> for NopNode<'script> {
type Error = ();

fn try_from(value: AnyNode<'script>) -> Result<Self, Self::Error> {
if value.tree_node.kind() == Self::NODE_KIND {
if value.tree_node.is_named() && value.tree_node.kind() == Self::NODE_KIND {
Ok(value.into())
} else {
Err(())
Expand Down
Loading

0 comments on commit f97d097

Please sign in to comment.