fix(BArrayType): Fix unnamed union array types printing in diagnostics

compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/semantics/model/types/BArrayType.java

@@ -127,24 +127,63 @@ public <T, R> R accept(BTypeVisitor<T, R> visitor, T t) {
 
     @Override
     public String toString() {
-        StringBuilder sb = new StringBuilder(eType.toString());
+        String elementTypeStr = eType.toString();
+
+        // Add parentheses for unnamed unions or finite types like (1|2|3)[]
+        if (elementTypeStr.startsWith("(") && elementTypeStr.endsWith(")")) {
+            int idx = findMatchingParenIndex(elementTypeStr);
+            if (idx > 0 && idx == elementTypeStr.length() - 1) {
+                String inner = elementTypeStr.substring(1, idx);
+
+                // UNWRAP only if inner is NOT a union (i.e., doesn't contain '|').
+                if (!inner.contains("|")) {
+                    elementTypeStr = inner;
+                }
+            }
+        }
+
+        StringBuilder sb = new StringBuilder(elementTypeStr);
         String tempSize = (state == BArrayState.INFERRED) ? "*" : String.valueOf(size);
+
         if (eType.tag == TypeTags.ARRAY) {
-            if (state != BArrayState.OPEN) {
-                sb.insert(sb.indexOf("["), "[" + tempSize + "]");
-            } else {
-                sb.insert(sb.indexOf("["), "[]");
-            }
+        if (state != BArrayState.OPEN) {
+            sb.insert(sb.indexOf("["), "[" + tempSize + "]");
+        } else {
+            sb.insert(sb.indexOf("["), "[]");
+        }
         } else {
             if (state != BArrayState.OPEN) {
                 sb.append("[").append(tempSize).append("]");
             } else {
                 sb.append("[]");
             }
         }
-        return !Symbols.isFlagOn(getFlags(), Flags.READONLY) ? sb.toString() : sb.append(" & readonly").toString();
+
+        return !Symbols.isFlagOn(getFlags(), Flags.READONLY)
+            ? sb.toString()
+            : sb.append(" & readonly").toString();
     }
 
+    /**
+    * Find the index of the matching closing parenthesis for the first '(' in the string.
+    * Returns -1 if not found / malformed.
+    */
+    private int findMatchingParenIndex(String s) {
+        int depth = 0;
+        for (int i = 0; i < s.length(); i++) {
+         char c = s.charAt(i);
+         if (c == '(') {
+            depth++;
+         } else if (c == ')') {
+            depth--;
+            if (depth == 0) {
+                return i;
+            }
+            // if depth < 0 it's malformed; continue and fallback later
+         }
+        }
+        return -1;
+    }
     private boolean hasTypeHoles() {
         return eType instanceof BNoType;
     }

compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/semantics/model/types/BUnionType.java

@@ -442,11 +442,32 @@ private void computeStringRepresentation() {
             }
             String memToString = bType.toString();
 
-            if (bType.tag == TypeTags.UNION && memToString.startsWith("(") && memToString.endsWith(")")) {
-                joiner.add(memToString.substring(1, memToString.length() - 1));
-            } else {
-                joiner.add(memToString);
+            if (bType.tag == TypeTags.UNION && memToString.startsWith("(")) {
+                int closeIdx = findMatchingParenIndex(memToString);
+
+                if (closeIdx > 0) {
+                    boolean hasSuffix = closeIdx < memToString.length() - 1;
+                    String inner = memToString.substring(1, closeIdx);
+                    String suffix =
+                        hasSuffix ? memToString.substring(closeIdx + 1) : "";
+
+                    if (inner.contains("|")) {
+                        joiner.add(inner + suffix);
+                    } else if (!hasSuffix) {
+                        joiner.add(inner);
+                    } else {
+                        joiner.add(memToString);
+                    }
+                    numberOfNotNilTypes++;
+                    if (!hasNilableMember && bType.isNullable()) {
+                        hasNilableMember = true;
+                    }
+                    continue;
+                }
             }
+
+            // NON-UNION or no parentheses-unwrapping case
+            joiner.add(memToString);
             numberOfNotNilTypes++;
 
             if (!hasNilableMember && bType.isNullable()) {
@@ -459,6 +480,26 @@ private void computeStringRepresentation() {
         cachedToString = (this.isNullable() && hasNilType && !hasNilableMember) ? (typeStr + Names.QUESTION_MARK.value)
                 : typeStr;
     }
+    /**
+    * Find the index of the matching closing parenthesis for the first '(' in the string.
+    * Returns -1 if not found / malformed.
+    */
+    private int findMatchingParenIndex(String s) {
+        int depth = 0;
+        for (int i = 0; i < s.length(); i++) {
+         char c = s.charAt(i);
+         if (c == '(') {
+            depth++;
+         } else if (c == ')') {
+            depth--;
+            if (depth == 0) {
+                return i;
+            }
+            // if depth < 0 it's malformed; continue and fallback later
+         }
+        }
+        return -1;
+    }
 
     private static boolean isNeverType(BType type) {
         if (type.tag == NEVER) {