Add support for iterating over enums

I'm fairly confident about the codegen stuff, but I have no idea about the type checker.

I also couldn't make it work with type aliases - it complains that the alias is only a type but you're trying to use it as a value.

Author: Tim Hutt

src/compiler/checker.ts

@@ -35044,6 +35044,17 @@ namespace ts {
                 return anyIterationTypes;
             }
 
+            const symbolType = getDeclaredTypeOfSymbol(type.symbol);
+
+            if (symbolType.symbol.flags & SymbolFlags.RegularEnum) {
+                return createIterationTypes(
+                    createTupleType([
+                        stringType,
+                        symbolType,
+                    ]),
+                );
+            }
+
             if (use & IterationUse.AllowsAsyncIterablesFlag) {
                 const iterationTypes =
                     getIterationTypesOfIterableCached(type, asyncIterationTypesResolver) ||

src/compiler/transformers/ts.ts

@@ -2426,6 +2426,7 @@ namespace ts {
             const statements: Statement[] = [];
             startLexicalEnvironment();
             const members = map(node.members, transformEnumMember);
+            members.push(transformEnumMembersToIterator(node.members));
             insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment());
             addRange(statements, members);
 
@@ -2474,6 +2475,52 @@ namespace ts {
             );
         }
 
+        /**
+         * Transforms all enum members into a generator function that yields
+         * the enum members.
+         *
+         * @param members The enum member nodes.
+         */
+        function transformEnumMembersToIterator(members: readonly EnumMember[]): Statement {
+            const symbolIterator = factory.createPropertyAccessExpression(
+                factory.createIdentifier("Symbol"),
+                "iterator",
+            );
+            const iteratorMember = factory.createElementAccessExpression(
+                currentNamespaceContainerName,
+                symbolIterator,
+            );
+
+            const generatorBody = factory.createBlock(members.map(member => {
+                // Todo: don't call these twice.
+                const name = getExpressionForPropertyName(member, /*generateNameForComputedPropertyName*/ false);
+                const valueExpression = transformEnumMemberDeclarationValue(member);
+                const yieldExpression = factory.createYieldExpression(
+                    undefined,
+                    factory.createArrayLiteralExpression([
+                        name,
+                        valueExpression,
+                    ]),
+                );
+                return factory.createExpressionStatement(yieldExpression);
+            }));
+
+            const iteratorGenerator = factory.createFunctionExpression(
+                undefined,
+                factory.createToken(SyntaxKind.AsteriskToken),
+                undefined,
+                undefined,
+                [],
+                undefined,
+                generatorBody,
+            );
+            const outerAssignment = factory.createAssignment(
+                iteratorMember,
+                iteratorGenerator,
+            );
+            return factory.createExpressionStatement(outerAssignment);
+        }
+
         /**
          * Transforms the value of an enum member.
          *