Fixes issue with forEach iterating over a union of iterables

src/Scope.spec.ts

@@ -3807,6 +3807,25 @@ describe('Scope', () => {
                 expectTypeToBe(symbolTable.getSymbolType('key', opts), StringType);
             });
 
+            it('should set the type of the for loop item whn the target is a union of typed arrays', () => {
+                let mainFile = program.setFile<BrsFile>('source/main.bs', `
+                    sub process(data as integer[] or string[])
+                        for each item in data
+                            print item
+                        end for
+                    end sub
+                `);
+                program.validate();
+                expectZeroDiagnostics(program);
+                const forEachStmt = mainFile.ast.findChild<ForEachStatement>(isForEachStatement);
+                const symbolTable = forEachStmt.body.getSymbolTable();
+                const opts = { flags: SymbolTypeFlag.runtime };
+                const itemType = symbolTable.getSymbolType('item', opts) as UnionType;
+                expectTypeToBe(itemType, UnionType);
+                expect(itemType.types).to.include(IntegerType.instance);
+                expect(itemType.types).to.include(StringType.instance);
+            });
+
             it('should use dynamic type for loop item when type cannot be inferred', () => {
                 let mainFile = program.setFile<BrsFile>('source/main.bs', `
                     sub process(data as roList)

src/astUtils/reflection.ts

@@ -583,6 +583,9 @@ export function isIterableType(value: any): boolean {
     if (isArrayTypeLike(value) || isAssociativeArrayTypeLike(value)) {
         return true;
     }
+    if (isCompoundTypeOf(value, isIterableType)) {
+        return true;
+    }
     if (isBuiltInType(value, 'roByteArray') || isBuiltInType(value, 'roList') || isBuiltInType(value, 'roXMLList') || isBuiltInType(value, 'roMessagePort')) {
         return true;
     }

src/bscPlugin/validation/BrsFileValidator.ts

@@ -134,7 +134,7 @@ export class BrsFileValidator {
                 this.validateNoOptionalChainingInVarSet(node, [node.obj]);
             },
             ForEachStatement: (node) => {
-                //register the for loop variable
+                //registering the for loop variable happens in the visitor for Block, since the loop variable is scoped to the loop body
             },
             NamespaceStatement: (node) => {
                 if (!node?.nameExpression) {

src/bscPlugin/validation/ScopeValidator.spec.ts

@@ -6651,5 +6651,59 @@ describe('ScopeValidator', () => {
                 DiagnosticMessages.notIterable('integer').message
             ]);
         });
+
+        it('allows a union of iterable types to be iterated over', () => {
+            program.setFile('source/test.bs', `
+                sub doStuff(items as roList or roArray)
+                    for each item in items
+                        print item
+                    end for
+                end sub
+            `);
+            program.validate();
+            expectZeroDiagnostics(program);
+        });
+
+        it('allows a union of typed arrays to be iterated over', () => {
+            program.setFile('source/test.bs', `
+                sub setAllText(text as string, labels as roSGNodeLabel[] or roSGNodeMultiStyleLabel[])
+                    for each label in labels
+                        label.text = text
+                    end for
+                end sub
+            `);
+            program.validate();
+            expectZeroDiagnostics(program);
+        });
+
+        it('allows a type statement of a typed array to be iterated over', () => {
+            program.setFile('source/test.bs', `
+
+                type StringArray = string[]
+
+                sub printAllText(text as StringArray)
+                    for each t in text
+                        print t
+                    end for
+                end sub
+            `);
+            program.validate();
+            expectZeroDiagnostics(program);
+        });
+
+        it('allows a type statement of a typed array to be iterated over', () => {
+            program.setFile('source/test.bs', `
+
+                type StringArray = string[]
+
+                sub printAllText(text as StringArray)
+                    for each t in text
+                        print t
+                    end for
+                end sub
+            `);
+            program.validate();
+            expectZeroDiagnostics(program);
+        });
     });
 });

src/util.ts

@@ -2759,6 +2759,9 @@ export class Util {
             return StringType.instance;
         } else if (isBuiltInType(iteratorType, 'roByteArray')) {
             return IntegerType.instance;
+        } else if (isUnionType(iteratorType)) {
+            const iteratorDefaultTypes = iteratorType.types.map(t => this.getIteratorDefaultType(t));
+            return getUniqueType(iteratorDefaultTypes, unionTypeFactory);
         }
         return DynamicType.instance;
     }