Limit field warnings and slim pull request CI

Author: Frotty

.github/workflows/build.yml

@@ -11,27 +11,15 @@ concurrency:
   cancel-in-progress: true
 
 jobs:
-  # Emit a wider matrix on master pushes (adds macOS), narrow on PRs (saves minutes)
-  setup:
-    runs-on: ubuntu-latest
-    outputs:
-      matrix: ${{ steps.set-matrix.outputs.matrix }}
-    steps:
-      - id: set-matrix
-        shell: bash
-        run: |
-          if [[ "${{ github.event_name }}" == "push" ]]; then
-            echo 'matrix={"include":[{"os":"ubuntu-latest"},{"os":"windows-latest"},{"os":"macos-latest"},{"os":"macos-15-intel"}]}' >> "$GITHUB_OUTPUT"
-          else
-            echo 'matrix={"include":[{"os":"ubuntu-latest"},{"os":"windows-latest"}]}' >> "$GITHUB_OUTPUT"
-          fi
-
+  # Master pushes exercise every supported host. Pull requests use one Linux job
+  # so that the normal feedback loop does not spend four runner-minutes on the
+  # same compiler test suite; the full host matrix still runs before release.
   build:
     name: Gradle build on ${{ matrix.os }}
-    needs: setup
     strategy:
       fail-fast: false
-      matrix: ${{ fromJson(needs.setup.outputs.matrix) }}
+      matrix:
+        os: ${{ fromJSON(github.event_name == 'push' && '["ubuntu-latest","windows-latest","macos-latest","macos-15-intel"]' || '["ubuntu-latest"]') }}
     runs-on: ${{ matrix.os }}
     permissions:
       checks: write
@@ -96,18 +84,23 @@ jobs:
       - name: Setup Gradle (cache)
         uses: gradle/actions/setup-gradle@v4
 
-      # ---- FAIL FAST: package first (so jlink issues show immediately) ----
+      # Packaging is a release artifact, not a pull-request gate. Keeping it on
+      # master avoids paying for a second full build on every PR update.
       - name: Package slim runtime (fail fast)
+        if: github.event_name == 'push'
         shell: bash
         run: ./gradlew packageSlimCompilerDist --no-daemon --stacktrace
 
       - name: Prepare bundled Lua runtime (Linux)
         if: runner.os == 'Linux'
         shell: bash
         run: |
-          if [[ -f src/test/resources/lua53 ]]; then
-            chmod +x src/test/resources/lua53
-          fi
+          set -euo pipefail
+          # These binaries are tracked with mode 0644 for cross-platform
+          # checkouts; make both the interpreter and syntax checker runnable.
+          chmod +x src/test/resources/lua53 src/test/resources/luac53
+          src/test/resources/lua53 -e 'assert(_VERSION == "Lua 5.3")'
+          src/test/resources/luac53 -v
 
       - name: Install Lua compiler (macOS)
         if: runner.os == 'macOS'
@@ -119,14 +112,14 @@ jobs:
       - name: Run tests
         shell: bash
         run: |
-          if [[ "${{ runner.os }}" == "Linux" ]]; then
+          if [[ "${{ github.event_name }}" == "push" && "${{ runner.os }}" == "Linux" ]]; then
             ./gradlew test jacocoTestReport --no-daemon --stacktrace --quiet
           else
             ./gradlew test --no-daemon --stacktrace --quiet
           fi
 
       - name: Upload coverage to Coveralls
-        if: runner.os == 'Linux'
+        if: github.event_name == 'push' && runner.os == 'Linux'
         uses: coverallsapp/github-action@v2
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}
@@ -157,6 +150,7 @@ jobs:
           retention-days: 14
 
       - name: Upload packaged artifact (per-OS)
+        if: github.event_name == 'push'
         uses: actions/upload-artifact@v4
         with:
           name: wurst-compiler-${{ matrix.os }}

de.peeeq.wurstscript/src/main/java/de/peeeq/wurstscript/validation/WurstValidator.java

@@ -1759,12 +1759,13 @@ private void checkUninitializedVars(FunctionLike f) {
 
     /**
      * Instance fields without an initializer are reset to the language default when an object is
-     * allocated, but that value is often accidental. Warn when a method reads such a field and no
-     * constructor is known to assign it on every construction path. This deliberately stays a
-     * cheap, local check: it does not attempt interprocedural or path-sensitive reasoning.
+     * allocated, but that value is often accidental. Warn when a constructor reads such a field
+     * before its value is definitely established. Ordinary methods are intentionally out of scope:
+     * their callers may establish fields through APIs or other construction-time hooks that this
+     * cheap local check cannot see.
      */
     private void checkPotentiallyUninitializedClassFields(FunctionLike function) {
-        if (function instanceof OnDestroyDef) {
+        if (function instanceof OnDestroyDef || !(function instanceof ConstructorDef)) {
             return;
         }
 

de.peeeq.wurstscript/src/test/java/tests/wurstscript/tests/ClassesTests.java

@@ -28,12 +28,9 @@ public void warnsWhenClassFieldHasNoInitializerOrConstructorAssignment() {
                 "package Test",
                 "class Counter",
                 "    int value",
-                "    function get() returns int",
-                "        return value",
-                "    function readBeforeSet() returns int",
+                "    construct()",
                 "        int oldValue = value",
-                "        value = 42",
-                "        return oldValue"
+                "        value = 42"
             );
     }
 
@@ -70,8 +67,7 @@ public void warnsWhenConstructorOnlyAssignsOtherInstanceField() {
                 "    int value",
                 "    construct(Counter other)",
                 "        other.value = 1",
-                "    function get() returns int",
-                "        return value"
+                "        int _observed = this.value"
             );
 
         assertEquals(result.getGui().getWarningList().stream()
@@ -105,8 +101,8 @@ public void warnsWhenUnqualifiedArrayFieldHasNoInitializer() {
                 "package Test",
                 "class Counter",
                 "    int values[2]",
-                "    function get() returns int",
-                "        return values[0]"
+                "    construct()",
+                "        int first = values[0]"
             );
     }
 
@@ -120,14 +116,14 @@ public void warnsWhenFieldIsReadOnRightHandSideBeforeAssignment() {
                 "package Test",
                 "class Counter",
                 "    int value",
-                "    function increment() returns int",
+                "    construct()",
                 "        value = value + 1",
-                "        return value"
+                "        skip"
             );
     }
 
     @Test
-    public void warnsWhenOtherInstanceFieldIsReadAfterThisFieldWrite() {
+    public void warnsWhenOtherInstanceFieldIsReadInConstructor() {
         test()
             .setStopOnFirstError(false)
             .executeProg(false)
@@ -136,9 +132,8 @@ public void warnsWhenOtherInstanceFieldIsReadAfterThisFieldWrite() {
                 "package Test",
                 "class Counter",
                 "    int value",
-                "    function getOther(Counter other) returns int",
-                "        value = 1",
-                "        return other.value"
+                "    construct(Counter other)",
+                "        let _observed = other.value"
             );
     }
 
@@ -152,9 +147,9 @@ public void warnsWhenOnlyOneArrayElementWasAssigned() {
                 "package Test",
                 "class Counter",
                 "    int values[2]",
-                "    function getOther() returns int",
+                "    construct()",
                 "        values[0] = 1",
-                "        return values[1]"
+                "        int observed = values[1]"
             );
     }
 
@@ -300,18 +295,21 @@ public void doesNotWarnForInitializedExplicitReceiverInsideConstructor() {
     }
 
     @Test
-    public void warnsForUninitializedFieldReadFromPackageFunction() {
-        test()
+    public void doesNotWarnForUninitializedFieldReadFromPackageFunction() {
+        CompilationResult result = test()
             .setStopOnFirstError(false)
             .executeProg(false)
-            .expectWarning("no explicit initializer and is not definitely assigned")
             .lines(
                 "package Test",
                 "class Counter",
                 "    int value",
                 "function read(Counter counter) returns int",
                 "    return counter.value"
             );
+
+        assertFalse(result.getGui().getWarningList().stream()
+            .anyMatch(w -> w.getMessage().contains("no explicit initializer and is not definitely assigned")),
+            result.getGui().getWarningList().toString());
     }
 
     @Test