Handle module field initialization guarantees

Author: Frotty

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

@@ -1760,7 +1760,7 @@ private void checkUninitializedVars(FunctionLike f) {
      * cheap, local check: it does not attempt interprocedural or path-sensitive reasoning.
      */
     private void checkPotentiallyUninitializedClassFields(FunctionLike function) {
-        ClassDef owner = function.attrNearestClassDef();
+        ClassOrModule owner = function.attrNearestClassOrModule();
         if (owner == null || function instanceof OnDestroyDef) {
             return;
         }
@@ -1926,12 +1926,12 @@ private boolean hasGuaranteedConstructorAssignment(GlobalVarDef field) {
         if (cached != null) {
             return cached;
         }
-        ClassDef declaringClass = field.attrNearestClassDef();
-        if (declaringClass == null || declaringClass.getConstructors().isEmpty()) {
+        List<ConstructorDef> constructors = constructorsFor(field);
+        if (constructors.isEmpty()) {
             guaranteedClassFieldInitCache.put(field, false);
             return false;
         }
-        for (ConstructorDef constructor : declaringClass.getConstructors()) {
+        for (ConstructorDef constructor : constructors) {
             if (!constructorAssignsField(constructor, field, Collections.newSetFromMap(new IdentityHashMap<>()))) {
                 guaranteedClassFieldInitCache.put(field, false);
                 return false;
@@ -1965,14 +1965,38 @@ private boolean constructorAssignsField(ConstructorDef constructor, GlobalVarDef
         if (thisCall == null) {
             return false;
         }
-        ClassOrModule owner = constructor.attrNearestClassOrModule();
-        if (owner == null) {
-            return false;
-        }
-        ConstructorDef target = OverloadingResolver.resolveThisCall(owner.getConstructors(), thisCall);
+        ConstructorDef target = OverloadingResolver.resolveThisCall(constructorsFor(constructor), thisCall);
         return target != null && target != constructor && constructorAssignsField(target, field, visiting);
     }
 
+    private List<ConstructorDef> constructorsFor(GlobalVarDef field) {
+        Element current = field;
+        while (current != null) {
+            if (current instanceof ModuleInstanciation module) {
+                return module.getConstructors();
+            }
+            if (current instanceof ClassOrModule owner) {
+                return owner.getConstructors();
+            }
+            current = current.getParent();
+        }
+        return Collections.emptyList();
+    }
+
+    private List<ConstructorDef> constructorsFor(ConstructorDef constructor) {
+        Element current = constructor;
+        while (current != null) {
+            if (current instanceof ModuleInstanciation module) {
+                return module.getConstructors();
+            }
+            if (current instanceof ClassOrModule owner) {
+                return owner.getConstructors();
+            }
+            current = current.getParent();
+        }
+        return Collections.emptyList();
+    }
+
     private void checkClassFieldInitializerReads(GlobalVarDef field) {
         if (!field.attrIsDynamicClassMember() || !(field.getInitialExpr() instanceof Expr initializer)) {
             return;
@@ -1993,6 +2017,11 @@ private void checkField(NameRef access) {
                     + " Initialize it explicitly before using it.");
             }
 
+            @Override
+            public void visit(ExprClosure closure) {
+                // A closure runs later (and may never run), so its body is not field initialization.
+            }
+
             @Override
             public void visit(ExprVarAccess access) {
                 super.visit(access);

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

@@ -216,6 +216,47 @@ public void warnsWhenFieldInitializerReadsUninitializedField() {
             );
     }
 
+    @Test
+    public void doesNotWarnWhenModuleConstructorAssignsClassField() {
+        CompilationResult result = test()
+            .setStopOnFirstError(false)
+            .executeProg(false)
+            .lines(
+                "package Test",
+                "module Values",
+                "    int value",
+                "    construct()",
+                "        value = 1",
+                "    function get() returns int",
+                "        return value",
+                "class Counter",
+                "    use Values"
+            );
+
+        assertFalse(result.getGui().getWarningList().stream()
+            .anyMatch(w -> w.getMessage().contains("no explicit initializer")),
+            result.getGui().getWarningList().toString());
+    }
+
+    @Test
+    public void doesNotTreatDeferredClosureInitializerAsImmediateFieldRead() {
+        CompilationResult result = test()
+            .setStopOnFirstError(false)
+            .executeProg(false)
+            .lines(
+                "package Test",
+                "interface Reader",
+                "    function read() returns int",
+                "class Counter",
+                "    int value",
+                "    Reader reader = () -> value"
+            );
+
+        assertFalse(result.getGui().getWarningList().stream()
+            .anyMatch(w -> w.getMessage().contains("read from a field initializer")),
+            result.getGui().getWarningList().toString());
+    }
+
     @Test
     public void classes1() throws IOException {
         testAssertOkFile(new File(TEST_DIR + "Classes_1.wurst"), true);