fixes

Author: Frotty

de.peeeq.wurstscript/src/main/java/de/peeeq/wurstscript/attributes/AttrExprType.java

@@ -103,9 +103,17 @@ public static WurstType calculate(ExprVarArrayAccess term) {
             return ((WurstTypeArray) varDefType).getBaseType();
         }
         if (term.getIndexes().size() == 1) {
-            FuncLink overload = AttrFuncDef.getIndexGetOperator(term, varDefType, term.getIndexes().get(0).attrTyp());
-            if (overload != null) {
-                return overload.getReturnType();
+            WurstType indexType = term.getIndexes().get(0).attrTyp();
+            FuncLink getOverload = AttrFuncDef.getIndexGetOperator(term, varDefType, indexType);
+            if (getOverload != null) {
+                return getOverload.getReturnType();
+            }
+            if (isWriteAccess(term)) {
+                FuncLink setOverload = AttrFuncDef.getIndexSetOperatorByIndex(term, varDefType, indexType);
+                if (setOverload != null) {
+                    return setOverload.getParameterType(1);
+                }
+                return WurstTypeUnknown.instance();
             }
         }
         term.addError("Variable " + varDef.getName() + " is of type " + varDefType +
@@ -419,9 +427,17 @@ public static WurstType calculate(ExprMemberArrayVarDot term) {
             return ar.getBaseType();
         }
         if (term.getIndexes().size() == 1) {
-            FuncLink overload = AttrFuncDef.getIndexGetOperator(term, typ, term.getIndexes().get(0).attrTyp());
-            if (overload != null) {
-                return overload.getReturnType();
+            WurstType indexType = term.getIndexes().get(0).attrTyp();
+            FuncLink getOverload = AttrFuncDef.getIndexGetOperator(term, typ, indexType);
+            if (getOverload != null) {
+                return getOverload.getReturnType();
+            }
+            if (isWriteAccess(term)) {
+                FuncLink setOverload = AttrFuncDef.getIndexSetOperatorByIndex(term, typ, indexType);
+                if (setOverload != null) {
+                    return setOverload.getParameterType(1);
+                }
+                return WurstTypeUnknown.instance();
             }
         }
         term.addError("Variable " + term.getVarName() + " is not an array and has no " + AttrFuncDef.overloadingIndexGet + " overload.");
@@ -604,4 +620,12 @@ public static WurstType calculate(ExprArrayLength exprArrayLength) {
         exprArrayLength.addError(".length is only valid on arrays.");
         return de.peeeq.wurstscript.types.WurstTypeUnknown.instance();
     }
+
+    private static boolean isWriteAccess(NameRef node) {
+        if (node.getParent() instanceof StmtSet) {
+            StmtSet stmtSet = (StmtSet) node.getParent();
+            return stmtSet.getUpdatedExpr() == node;
+        }
+        return false;
+    }
 }

de.peeeq.wurstscript/src/main/java/de/peeeq/wurstscript/attributes/AttrFuncDef.java

@@ -226,6 +226,41 @@ private static boolean isConstructorThisCall(ExprFunctionCall node) {
         return candidate;
     }
 
+    public static @Nullable FuncLink getIndexSetOperatorByIndex(Expr node, WurstType receiverType, WurstType indexType) {
+        Collection<FuncLink> funcs1 = node.lookupMemberFuncs(receiverType, overloadingIndexSet);
+        if (funcs1.isEmpty()) {
+            return null;
+        }
+        List<FuncLink> funcs = filterInvisible(overloadingIndexSet, node, funcs1);
+        funcs = filterByReceiverType(node, overloadingIndexSet, funcs);
+        List<FuncLink> byParamCount = Lists.newArrayList();
+        for (FuncLink f : funcs) {
+            if (f.getParameterTypes().size() == 2) {
+                byParamCount.add(f);
+            }
+        }
+        if (byParamCount.isEmpty()) {
+            return null;
+        }
+        List<FuncLink> byIndexType = Lists.newArrayList();
+        for (FuncLink f : byParamCount) {
+            VariableBinding mapping = f.getVariableBinding();
+            WurstType expectedIndexType = f.getParameterType(0);
+            VariableBinding m2 = indexType.matchAgainstSupertype(expectedIndexType, node, mapping, VariablePosition.RIGHT);
+            if (m2 != null) {
+                byIndexType.add(f);
+            }
+        }
+        if (byIndexType.isEmpty()) {
+            return null;
+        }
+        if (byIndexType.size() == 1) {
+            return byIndexType.get(0);
+        }
+        // ambiguous write-only expected type context: pick deterministic first
+        return byIndexType.get(0);
+    }
+
     private static boolean matchesArguments(Element node, FuncLink f, List<WurstType> argumentTypes) {
         if (f.getParameterTypes().size() != argumentTypes.size()) {
             return false;

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

@@ -268,5 +268,31 @@ public void testOverloading_indexWriteWrongIndexType() {
                 "endpackage");
     }
 
+    @Test
+    public void testOverloading_indexWriteOnlySetter() {
+        testAssertOkLines(false,
+                "package test",
+                "	class ListLike",
+                "		function op_indexAssign(int i, int v)",
+                "	init",
+                "		ListLike l = new ListLike()",
+                "		l[1] = 2",
+                "endpackage");
+    }
+
+    @Test
+    public void testOverloading_memberIndexWriteOnlySetter() {
+        testAssertOkLines(false,
+                "package test",
+                "	class ListLike",
+                "		function op_indexAssign(int i, int v)",
+                "	class Box",
+                "		ListLike l = new ListLike()",
+                "	init",
+                "		Box b = new Box()",
+                "		b.l[1] = 2",
+                "endpackage");
+    }
+
 
 }