✨ feat: fuse decompiler

Signed-off-by: FurryR <awathefox@gmail.com>

Author: FurryR

.github/workflows/ci.yml

@@ -78,7 +78,7 @@ jobs:
             "scratch-fuse/serializer"
             "scratch-fuse/builtins"
           )
-          
+
           for repo in "${REPOS[@]}"; do
             echo "Triggering workflow for $repo..."
             curl -L \

specification.md

@@ -56,15 +56,15 @@ Letter = UnicodeLetterCategory ;
 ### Keywords
 
 ```ebnf
-Keyword = "fn" | "let" | "global" | "if" | "else" | "while" | "for" | "loop" 
+Keyword = "fn" | "let" | "global" | "if" | "else" | "while" | "for" | "loop"
         | "return" | "true" | "false" | "once" | "namespace" ;
 ```
 
 ### Operators
 
 ```ebnf
-Operator = ".." | "+" | "-" | "*" | "/" | "%" 
-         | "=" | "==" | "!=" | "<" | ">" | "<=" | ">=" 
+Operator = ".." | "+" | "-" | "*" | "/" | "%"
+         | "=" | "==" | "!=" | "<" | ">" | "<=" | ">="
          | "&&" | "||" | "!" | "."
          | "->" | "+=" | "-=" | "*=" | "/=" | "%=" | "..="
          | "++" | "--" ;
@@ -164,6 +164,7 @@ HatBlock = Expression BlockStatement ;
 ```
 
 Examples:
+
 ```fuse
 event.start { /* statements */ }
 event.keyPressed("space") { /* statements */ }
@@ -273,8 +274,8 @@ FactorExpression = UnaryExpression ( ("*" | "/" | "%") UnaryExpression )* ;
 
 UnaryExpression = ( ("+" | "-" | "!") UnaryExpression ) | CallExpression ;
 
-CallExpression = PrimaryExpression ( "(" ArgumentList? ")" [ BlockStatement ] 
-                                   | "[" Expression "]" 
+CallExpression = PrimaryExpression ( "(" ArgumentList? ")" [ BlockStatement ]
+                                   | "[" Expression "]"
                                    | "." Identifier )* ;
 
 PrimaryExpression = Literal
@@ -321,6 +322,7 @@ The FUSE program structure allows only the following at the top level:
 ### Type System
 
 FUSE uses a simple type system:
+
 - `void`: No return value
 - `any`: Any Scratch value (string, number, boolean)
 - `bool`: Boolean values (`true` or `false`)
@@ -342,16 +344,19 @@ The `@export` decorator is used to export Scratch blocks.
 ### Operators
 
 #### Arithmetic Operators
+
 - `+`: Addition
 - `-`: Subtraction
 - `*`: Multiplication
 - `/`: Division
 - `%`: Modulo
 
 #### String Operators
+
 - `..`: String concatenation
 
 #### Comparison Operators
+
 - `==`: Equal
 - `!=`: Not equal
 - `<`: Less than
@@ -360,21 +365,25 @@ The `@export` decorator is used to export Scratch blocks.
 - `>=`: Greater than or equal
 
 #### Logical Operators
+
 - `&&`: Logical AND
 - `||`: Logical OR
 - `!`: Logical NOT
 
 #### Assignment Operators
+
 - `=`: Assignment
 - `+=`, `-=`, `*=`, `/=`, `%=`, `..=`: Compound assignment
 
 #### Increment/Decrement
+
 - `++`: Increment by 1
 - `--`: Decrement by 1
 
 ### Control Flow
 
 #### If-Else
+
 ```fuse
 if (condition) {
   // statements
@@ -384,20 +393,23 @@ if (condition) {
 ```
 
 #### While Loop
+
 ```fuse
 while (condition) {
   // statements
 }
 ```
 
 #### For Loop
+
 ```fuse
 for (init; condition; update) {
   // statements
 }
 ```
 
 #### Infinite Loop
+
 ```fuse
 loop {
   // statements
@@ -407,11 +419,13 @@ loop {
 ### Function Calls
 
 Functions can be called with arguments:
+
 ```fuse
 functionName(arg1, arg2, arg3)
 ```
 
 Some Scratch blocks can have a "then" block:
+
 ```fuse
 someBlock(args) {
   // then statements
@@ -421,6 +435,7 @@ someBlock(args) {
 ### Member Access
 
 Access namespace members or object properties:
+
 ```fuse
 namespace.property
 object.method(args)
@@ -505,7 +520,7 @@ fn processArray() once -> void {
 ### exportal Blocks
 
 ```fuse
-@export("custom block [arg1] and [arg2]") 
+@export("custom block [arg1] and [arg2]")
 fn customBlock(arg1: any, arg2: any) once -> any {
   return arg1 + arg2
 }
@@ -533,8 +548,8 @@ Target = FunctionDeclaration | VariableDeclaration ;
 HatBlock = Expression BlockStatement ;
 
 (* Statements *)
-Statement = VariableDeclaration | AssignmentStatement | IncrementStatement 
-          | IfStatement | WhileStatement | ForStatement | LoopStatement 
+Statement = VariableDeclaration | AssignmentStatement | IncrementStatement
+          | IfStatement | WhileStatement | ForStatement | LoopStatement
           | ReturnStatement | BlockStatement | ExpressionStatement | NoopStatement ;
 
 AssignmentStatement = Expression AssignmentOperator Expression Eol ;

src/lexer.ts

@@ -50,6 +50,8 @@ const operators = new Set([
   '>=',
   '&&',
   '||',
+  '&',
+  '|',
   '!',
   '.',
   '->',

src/parser.ts

@@ -487,6 +487,20 @@ export class Parser {
     if (this.matchOperator('!', '-', '+')) {
       const op = this.previous().value
       const operand = this.parseUnary()
+      if (operand.type === 'Literal' && (op === '+' || op === '-')) {
+        // Constant folding for unary + and -
+        if (typeof (operand as LiteralExpression).value === 'number') {
+          const foldedValue =
+            op === '-' ? -(operand as LiteralExpression).value : +(operand as LiteralExpression).value
+          return {
+            type: 'Literal',
+            value: foldedValue,
+            raw: foldedValue.toString(),
+            line: operand.line,
+            column: operand.column
+          } as LiteralExpression
+        }
+      }
       return {
         type: 'UnaryExpression',
         operator: op,
@@ -1393,7 +1407,7 @@ export function toSource(node: ASTNode, indent = 2, semi = false): string {
         const args = call.arguments
           .map(arg => toSourceImpl(arg, level))
           .join(`,${sp}`)
-        let result = `${callee}(${args})`
+        let result = `${callee}${call.arguments.length === 0 && level === 0 ? `` : `(${args})`}`
         if (call.then) {
           result += `${sp}${toSourceImpl(call.then, level)}`
         }