6.1.0: faster interpreter, Bedrock-compatible MoLang and compiler fixes

.github/workflows/build.yml

@@ -1,5 +1,11 @@
 name: 'build'
-on: [ 'workflow_dispatch' ]
+on:
+    push:
+        branches: [ 'main' ]
+    pull_request:
+
+permissions:
+    contents: read
 
 jobs:
     build:
@@ -8,26 +14,18 @@ jobs:
             - name: Checkout Branch
               uses: actions/checkout@v7
 
-            - name: Restore gradle.properties
-              shell: bash
-              env:
-                  MAVEN_TOKEN: ${{ secrets.MAVEN_TOKEN }}
-              run: |
-                  mkdir -p ~/.gradle/
-                  echo "GRADLE_USER_HOME=${HOME}/.gradle" >> $GITHUB_ENV
-                  echo "${MAVEN_TOKEN}" > ~/.gradle/gradle.properties
-
             - name: Setup Java
               uses: actions/setup-java@v6
               with:
                   distribution: microsoft
                   java-version: 25
+                  cache: gradle
 
-            - name: Grant Execute Permission
-              run: chmod +x gradlew
+            # the tests compare with expectations.txt, which MolangJS generates from tests.txt
+            - name: Check MolangJS Expectations
+              run: |
+                  ./gradlew :runtime-compiler:generateExpectations
+                  git diff --exit-code -- runtime-compiler/src/test/resources/expectations.txt
 
             - name: Build
-              run: |
-                  ./gradlew publish
-              env:
-                  MAVEN_PASSWORD: ${{ secrets.REDLANCE_PASSWORD }}
+              run: ./gradlew build

.github/workflows/publish.yml

@@ -0,0 +1,34 @@
+name: 'publish'
+on: [ 'workflow_dispatch' ]
+
+jobs:
+    publish:
+        runs-on: ubuntu-latest
+        steps:
+            - name: Checkout Branch
+              uses: actions/checkout@v7
+
+            - name: Restore gradle.properties
+              shell: bash
+              env:
+                  MAVEN_TOKEN: ${{ secrets.MAVEN_TOKEN }}
+              run: |
+                  mkdir -p ~/.gradle/
+                  echo "GRADLE_USER_HOME=${HOME}/.gradle" >> $GITHUB_ENV
+                  echo "${MAVEN_TOKEN}" > ~/.gradle/gradle.properties
+
+            - name: Setup Java
+              uses: actions/setup-java@v6
+              with:
+                  distribution: microsoft
+                  java-version: 25
+
+            - name: Grant Execute Permission
+              run: chmod +x gradlew
+
+            # build runs the tests and the license checks, so a failing build is never published
+            - name: Build and Publish
+              run: |
+                  ./gradlew build publish
+              env:
+                  MAVEN_PASSWORD: ${{ secrets.REDLANCE_PASSWORD }}

gradle.properties

@@ -1,4 +1,4 @@
-group=team.unnamed
-version=6.0.2
+group=org.redlance.mochafloats
+version=6.1.0
 description=A lightweight, fast and efficient Molang lexer, parser, interpreter and compiler for Java 24+
 kotlin.stdlib.default.dependency=false

parser/src/main/java/org/redlance/mocha/parser/MolangParserImpl.java

@@ -89,6 +89,15 @@ final class MolangParserImpl implements MolangParser {
                 lexer.next();
                 List<Expression> expressions = new ArrayList<>();
                 while (true) {
+                    // empty statements are skipped, like Bedrock does with "{ v.a = 1;; }"
+                    while (lexer.current().kind() == TokenKind.SEMICOLON) {
+                        lexer.next();
+                    }
+                    // "{}" and a semicolon after the last statement, as in "{ v.a = 1; }"
+                    if (lexer.current().kind() == TokenKind.RBRACE) {
+                        lexer.next();
+                        break;
+                    }
                     Expression compoundExpression = MolangParserImpl.parseCompoundExpression(lexer, 0);
                     if (compoundExpression != null) expressions.add(compoundExpression);
                     token = lexer.current();
@@ -155,7 +164,12 @@ final class MolangParserImpl implements MolangParser {
                 return new UnaryExpression(UnaryExpression.Op.RETURN, compoundExpression);
         }
 
-        return null;
+        // an empty statement (";;"), a missing operand ("1 +") or argument ("f(1,)"):
+        // returning null here made the caller stop parsing and drop the rest of the script
+        if (token.kind() == TokenKind.ERROR) {
+            throw new ParseException("Found error token: " + token.value(), lexer.cursor());
+        }
+        throw new ParseException("Expected an expression, but found " + token.kind(), lexer.cursor());
     }
 
     //
@@ -277,7 +291,9 @@ final class MolangParserImpl implements MolangParser {
                     // then it's a ternary expression, since there is a ':', indicating the next expression
                     lexer.next();
                     if (trueValue == null) return null;
-                    Expression compoundExpression = MolangParserImpl.parseCompoundExpression(lexer, ternaryPrecedence);
+                    // the false branch may hold another conditional, so "a ? 1 : b ? 2 : 3"
+                    // is "a ? 1 : (b ? 2 : 3)", like in MolangJS and most other implementations
+                    Expression compoundExpression = MolangParserImpl.parseCompoundExpression(lexer, ternaryPrecedence - 1);
                     if (compoundExpression == null || left == null) return null;
                     return new TernaryConditionalExpression(left, trueValue, compoundExpression);
                 } else {
@@ -318,7 +334,10 @@ final class MolangParserImpl implements MolangParser {
         }
 
         lexer.next();
-        Expression compoundExpression = MolangParserImpl.parseCompoundExpression(lexer, precedence);
+        // assignment takes everything on its right, so "v.x = a ? 1 : 2" assigns the
+        // conditional and "v.a = v.b = 1" assigns both, the other operators group from the left
+        final int rightPrecedence = op == BinaryExpression.Op.ASSIGN ? precedence - 1 : precedence;
+        Expression compoundExpression = MolangParserImpl.parseCompoundExpression(lexer, rightPrecedence);
         if (compoundExpression == null || left == null) return null;
         return new BinaryExpression(op, left, compoundExpression);
     }
@@ -350,6 +369,11 @@ final class MolangParserImpl implements MolangParser {
     private @Nullable Expression next0() throws IOException {
         Token token = lexer.next();
 
+        // empty statements are skipped, like Bedrock does with "v.a = 1;; v.b = 2"
+        while (token.kind() == TokenKind.SEMICOLON) {
+            token = lexer.next();
+        }
+
         if (token.kind() == TokenKind.EOF) {
             // reached end-of-file!
             return null;

parser/src/main/java/org/redlance/mocha/parser/ast/ArrayAccessExpression.java

@@ -112,7 +112,7 @@ public void write(ByteBuf buf) {
 
     @Override
     public @NotNull String toString() {
-        return String.format("%s[%s]", array, index);
+        return BinaryExpression.parenthesize(array, !CallExpression.isPostfixOperand(array)) + "[" + index + "]";
     }
 
     @Override

parser/src/main/java/org/redlance/mocha/parser/ast/BinaryExpression.java

@@ -127,7 +127,37 @@ public void write(ByteBuf buf) {
 
     @Override
     public String toString() {
-        return String.format("%s%s%s", this.left, this.op.toString(), this.right);
+        return parenthesize(left, leftNeedsParentheses()) + op + parenthesize(right, rightNeedsParentheses());
+    }
+
+    // "=" and "?" take everything on their right, the other operators group from the left
+    private boolean rightAssociative() {
+        return op == Op.ASSIGN || op == Op.CONDITIONAL;
+    }
+
+    // parentheses are only printed where the parser would otherwise group differently
+    boolean leftNeedsParentheses() {
+        final int leftPrecedence = printPrecedence(left);
+        return leftPrecedence < op.precedence() || (rightAssociative() && leftPrecedence == op.precedence());
+    }
+
+    boolean rightNeedsParentheses() {
+        final int rightPrecedence = printPrecedence(right);
+        return rightPrecedence < op.precedence() || (!rightAssociative() && rightPrecedence == op.precedence());
+    }
+
+    // how tightly an expression binds when printed, everything but the operators binds tightest
+    static int printPrecedence(final @NotNull Expression expression) {
+        if (expression instanceof BinaryExpression binary) {
+            return binary.op.precedence();
+        } else if (expression instanceof TernaryConditionalExpression) {
+            return Op.CONDITIONAL.precedence();
+        }
+        return Integer.MAX_VALUE;
+    }
+
+    static @NotNull String parenthesize(final @NotNull Expression expression, final boolean parentheses) {
+        return parentheses ? "(" + expression + ")" : expression.toString();
     }
 
     @Override