Complete superclass field guarantees and module indexing

Author: Frotty

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

@@ -62,6 +62,7 @@ private enum Phase { LIGHT, HEAVY }
     private final Map<ClassDef, Map<GlobalVarDef, Integer>> classVarInitOrderCache = new HashMap<>();
     private final Map<GlobalVarDef, Boolean> guaranteedClassFieldInitCache = new IdentityHashMap<>();
     private final Map<GlobalVarDef, List<GlobalVarDef>> moduleFieldCopiesCache = new IdentityHashMap<>();
+    private boolean moduleFieldCopiesIndexed;
 
     /**
      * When true, the build targets a legacy patch (pre-1.24) whose Blizzard-provided
@@ -87,6 +88,7 @@ public void validate(Collection<CompilationUnit> toCheck) {
             heavyBlocks.clear();
             guaranteedClassFieldInitCache.clear();
             moduleFieldCopiesCache.clear();
+            moduleFieldCopiesIndexed = false;
 
             lightValidation(toCheck);
 
@@ -1988,11 +1990,12 @@ private boolean constructorAssignsField(ConstructorDef constructor, GlobalVarDef
             return true;
         }
         FunctionCall thisCall = getFirstThisConstructorCall(constructor);
-        if (thisCall == null) {
-            return false;
+        if (thisCall != null) {
+            ConstructorDef target = OverloadingResolver.resolveThisCall(constructorsFor(constructor), thisCall);
+            return target != null && target != constructor && constructorAssignsField(target, field, visiting);
         }
-        ConstructorDef target = OverloadingResolver.resolveThisCall(constructorsFor(constructor), thisCall);
-        return target != null && target != constructor && constructorAssignsField(target, field, visiting);
+        ConstructorDef superConstructor = constructor.attrSuperConstructor();
+        return superConstructor != null && constructorAssignsField(superConstructor, field, visiting);
     }
 
     private List<ConstructorDef> constructorsFor(GlobalVarDef field) {
@@ -2035,36 +2038,32 @@ private List<ConstructorDef> enclosingClassConstructors(GlobalVarDef field) {
     }
 
     private List<GlobalVarDef> moduleFieldCopies(GlobalVarDef field) {
-        List<GlobalVarDef> cached = moduleFieldCopiesCache.get(field);
-        if (cached != null) {
-            return cached;
-        }
-        ClassOrModule owner = field.attrNearestClassOrModule();
-        if (!(owner instanceof ModuleDef module)) {
-            cached = Collections.emptyList();
-            moduleFieldCopiesCache.put(field, cached);
-            return cached;
+        if (!moduleFieldCopiesIndexed) {
+            indexModuleFieldCopies();
         }
-        int fieldIndex = module.getVars().indexOf(field);
-        if (fieldIndex < 0) {
-            cached = Collections.emptyList();
-            moduleFieldCopiesCache.put(field, cached);
-            return cached;
+        return moduleFieldCopiesCache.getOrDefault(field, Collections.emptyList());
+    }
+
+    private void indexModuleFieldCopies() {
+        if (moduleFieldCopiesIndexed) {
+            return;
         }
-        List<GlobalVarDef> copies = new ArrayList<>();
         prog.accept(new Element.DefaultVisitor() {
             @Override
             public void visit(ModuleInstanciation instantiation) {
-                if (instantiation.attrModuleOrigin() == module
-                    && fieldIndex < instantiation.getVars().size()) {
-                    copies.add(instantiation.getVars().get(fieldIndex));
+                ModuleDef origin = instantiation.attrModuleOrigin();
+                if (origin != null) {
+                    int count = Math.min(origin.getVars().size(), instantiation.getVars().size());
+                    for (int i = 0; i < count; i++) {
+                        GlobalVarDef originField = origin.getVars().get(i);
+                        moduleFieldCopiesCache.computeIfAbsent(originField, ignored -> new ArrayList<>())
+                            .add(instantiation.getVars().get(i));
+                    }
                 }
                 super.visit(instantiation);
             }
         });
-        cached = List.copyOf(copies);
-        moduleFieldCopiesCache.put(field, cached);
-        return cached;
+        moduleFieldCopiesIndexed = true;
     }
 
     private boolean initializedBySuperConstructor(ConstructorDef constructor, GlobalVarDef field) {

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

@@ -380,6 +380,29 @@ public void doesNotWarnForInheritedFieldAfterSuperclassConstructor() {
             result.getGui().getWarningList().toString());
     }
 
+    @Test
+    public void doesNotWarnForInheritedFieldAfterGrandparentConstructor() {
+        CompilationResult result = test()
+            .setStopOnFirstError(false)
+            .executeProg(false)
+            .lines(
+                "package Test",
+                "class GrandBase",
+                "    int value",
+                "    construct()",
+                "        value = 1",
+                "class Base extends GrandBase",
+                "    construct()",
+                "class Child extends Base",
+                "    construct()",
+                "        int copy = value"
+            );
+
+        assertFalse(result.getGui().getWarningList().stream()
+            .anyMatch(w -> w.getMessage().contains("no explicit initializer and is not definitely assigned")),
+            result.getGui().getWarningList().toString());
+    }
+
     @Test
     public void doesNotWarnForInheritedFieldInitializerAfterSuperclassConstructor() {
         CompilationResult result = test()