[Master] Fix compiler crashes when a union is used within multiple wait

compiler/ballerina-lang/src/main/java/org/ballerinalang/util/diagnostic/DiagnosticErrorCode.java

@@ -799,7 +799,13 @@ public enum DiagnosticErrorCode implements DiagnosticCode {
     EMPTY_REGEXP_STRING_DISALLOWED(
             "BCS4044", "empty.regexp.string.disallowed"),
     UNSUPPORTED_EMPTY_CHARACTER_CLASS(
-            "BCS4045", "unsupported.empty.character.class")
+            "BCS4045", "unsupported.empty.character.class"),
+    INCOMPATIBLE_QUERY_CONSTRUCT_TYPE("BCE4046", "invalid.error.query.construct.type"),
+    INCOMPATIBLE_QUERY_CONSTRUCT_MAP_TYPE("BCE4047", "invalid.error.query.construct.map.type"),
+    CANNOT_USE_ALTERNATE_WAIT_ACTION_WITHIN_MULTIPLE_WAIT_ACTION("BCE4048",
+            "cannot.use.alternate.wait.action.within.multiple.wait.action"),
+    EXPRESSION_OF_FUTURE_TYPE_EXPECTED("BCE4049", "future.expression.expected")
+;
     ;
 
     private String diagnosticId;

compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/semantics/analyzer/TypeChecker.java

@@ -4677,7 +4677,13 @@ private void checkTypesForRecords(BLangWaitForAllExpr waitExpr, AnalyzerData dat
 
         for (BLangWaitForAllExpr.BLangWaitKeyValue keyVal : rhsFields) {
             String key = keyVal.key.value;
-            if (!lhsFields.containsKey(key)) {
+            BLangExpression valueExpr = keyVal.valueExpr;
+            if (valueExpr != null && valueExpr.getKind() == NodeKind.BINARY_EXPR
+                        && ((BLangBinaryExpr) valueExpr).opKind == OperatorKind.BITWISE_OR) {
+                dlog.error(valueExpr.pos,
+                        DiagnosticErrorCode.CANNOT_USE_ALTERNATE_WAIT_ACTION_WITHIN_MULTIPLE_WAIT_ACTION);
+                data.resultType = symTable.semanticError;
+            } else if (!lhsFields.containsKey(key)) {
                 // Check if the field is sealed if so you cannot have dynamic fields
                 if (((BRecordType) Types.getReferredType(data.expType)).sealed) {
                     dlog.error(waitExpr.pos, DiagnosticErrorCode.INVALID_FIELD_NAME_RECORD_LITERAL, key, data.expType);
@@ -4739,7 +4745,14 @@ private void setEventualTypeForExpression(BLangExpression expression,
         if (isSimpleWorkerReference(expression, data)) {
             return;
         }
-        BFutureType futureType = (BFutureType) expression.expectedType;
+
+        BType expectedType = expression.expectedType;
+        if (expectedType.tag != TypeTags.FUTURE) {
+            dlog.error(expression.pos, DiagnosticErrorCode.EXPRESSION_OF_FUTURE_TYPE_EXPECTED, expectedType);
+            return;
+        }
+
+        BFutureType futureType = (BFutureType) expectedType;
         BType currentType = futureType.constraint;
         if (types.containsErrorType(currentType)) {
             return;

compiler/ballerina-lang/src/main/resources/compiler.properties

@@ -1967,3 +1967,9 @@ error.empty.regexp.string.disallowed=\
 
 error.unsupported.empty.character.class=\
   empty character class disallowed
+
+error.cannot.use.alternate.wait.action.within.multiple.wait.action=\
+  cannot use an alternate wait action within a multiple wait action
+
+error.future.expression.expected=\
+  expected an expression of type ''future'', found ''{0}''

tests/jballerina-unit-test/src/test/java/org/ballerinalang/test/worker/WaitActionsNegativeTest.java

@@ -33,7 +33,6 @@ public class WaitActionsNegativeTest {
     public void testNegativeWorkerActions() {
         CompileResult resultNegative = BCompileUtil.compile("test-src/workers/wait-actions-negative.bal");
         int index = 0;
-        Assert.assertEquals(resultNegative.getErrorCount(), 45, "Wait actions negative test error count");
         BAssertUtil.validateError(resultNegative, index++,
                 "incompatible types: expected 'future<string>', found 'future<int>'", 56, 22);
         BAssertUtil.validateError(resultNegative, index++,
@@ -143,9 +142,26 @@ public void testNegativeWorkerActions() {
                         "expression 'f2'", 90, 45);
         BAssertUtil.validateError(resultNegative, index++,
                 "incompatible types: expected 'future<string>', found 'future<(int|error)>'", 90, 54);
-        BAssertUtil.validateError(resultNegative, index,
+        BAssertUtil.validateError(resultNegative, index++,
                 "incompatible types: expected 'string', found eventual type '(string|error)' for wait future " +
                         "expression 'f4'", 90, 54);
+        BAssertUtil.validateError(resultNegative, index++,
+                "cannot use an alternate wait action within a multiple wait action", 115, 38);
+        BAssertUtil.validateError(resultNegative, index++,
+                "cannot use an alternate wait action within a multiple wait action", 116, 48);
+        BAssertUtil.validateError(resultNegative, index++,
+                "cannot use an alternate wait action within a multiple wait action", 117, 27);
+        BAssertUtil.validateError(resultNegative, index++,
+                "cannot use an alternate wait action within a multiple wait action", 117, 58);
+        BAssertUtil.validateError(resultNegative, index++, "expected an expression of type 'future'," +
+                " found '(future<(boolean|error)>|future<(boolean|error)>)'", 132, 38);
+        BAssertUtil.validateError(resultNegative, index++, "expected an expression of type 'future'," +
+                " found '(future<boolean>|future<boolean>)'", 133, 48);
+        BAssertUtil.validateError(resultNegative, index++, "expected an expression of type 'future'," +
+                " found '(future<(boolean|error)>|future<(boolean|error)>)'", 134, 27);
+        BAssertUtil.validateError(resultNegative, index++, "expected an expression of type 'future'," +
+                " found '(future<boolean>|future<boolean>)'", 134, 40);
+        Assert.assertEquals(resultNegative.getErrorCount(), index, "Wait actions negative test error count");
     }
 
     @Test

tests/jballerina-unit-test/src/test/resources/test-src/workers/wait-actions-negative.bal

@@ -90,6 +90,50 @@ function waitForAllTest() {
     restRec2 result16 = wait {id: f1, name: f2, age: f4};
 }
 
+type WaitResult record {|
+    boolean|error producer;
+    boolean consumer;
+|};
+
+function waitForAllTest2() {
+    worker Producer1 returns boolean|error {
+        return true;
+    }
+
+    worker Producer2 returns boolean|error {
+        return true;
+    }
+
+    worker Consumer1 returns boolean {
+        return false;
+    }
+
+    worker Consumer2 returns boolean {
+        return false;
+    }
+
+    WaitResult res = wait {producer: Producer1|Producer2, consumer: Consumer1};
+    res = wait {producer: Producer1, consumer: Consumer1|Consumer2};
+    res = wait {producer: Producer1|Producer2, consumer: Consumer1|Consumer2};
+}
+
+function waitActionWithInvalidType() {
+    worker Producer1 returns boolean|error {
+        return true;
+    }
+
+    worker Consumer1 returns boolean {
+        return false;
+    }
+
+    future<boolean|error>|future<boolean|error> x = Producer1;
+    future<boolean>|future<boolean> y = Consumer1;
+
+    WaitResult res = wait {producer: x, consumer: Consumer1};
+    res = wait {producer: Producer1, consumer: y};
+    res = wait {producer: x, consumer: y};
+}
+
 function print(string str) {
     string result = str.toUpperAscii();
 }