Some emit cleanup for ES6 classes, comments.

Author: rbuckton

src/compiler/checker.ts

@@ -11256,29 +11256,6 @@ module ts {
                 !hasProperty(getGeneratedNamesForSourceFile(getSourceFile(location)), name);
         }
 
-        function getClassDeclarationVariableId(n: Identifier): number {
-            Debug.assert(!nodeIsSynthesized(n));
-
-            let isClassDeclaration = n.parent.kind === SyntaxKind.ClassDeclaration;
-
-            let symbol =
-                (isClassDeclaration ? getSymbolOfNode(n.parent) : undefined) ||
-                getNodeLinks(n).resolvedSymbol ||
-                resolveName(n, n.text, SymbolFlags.Value | SymbolFlags.Alias, /*nodeNotFoundMessage*/ undefined, /*nameArg*/ undefined);
-
-            symbol = getExportSymbolOfValueSymbolIfExported(symbol);
-
-            let isClass = symbol && (symbol.flags & SymbolFlags.Class) !== 0;
-
-            if (isClass) {
-                // side-effect of calling this method:
-                //   assign id to symbol if it was not yet set
-                getSymbolLinks(symbol);
-                return symbol.id;
-            }
-            return undefined;
-        }
-
         function getBlockScopedVariableId(n: Identifier): number {
             Debug.assert(!nodeIsSynthesized(n));
 
@@ -11335,7 +11312,6 @@ module ts {
                 getConstantValue,
                 isUnknownIdentifier,
                 getBlockScopedVariableId,
-                getClassDeclarationVariableId,
             };
         }
 

src/compiler/core.ts

@@ -160,6 +160,39 @@ module ts {
         return ~low;
     }
 
+    export function foldLeft<T>(array: T[], f: (a: T, x: T) => T): T;
+    export function foldLeft<T, U>(array: T[], f: (a: U, x: T) => U, initial: U): U;
+    export function foldLeft<T, U>(array: T[], f: (a: U, x: T) => U, initial?: U): U {
+        if (array) {
+            var count = array.length;
+            if (count > 0) {
+                var pos = 0;
+                var result = arguments.length <= 2 ? array[pos++] : initial;
+                while (pos < count) {
+                    result = f(<U>result, array[pos++]);
+                }
+                return <U>result;
+            }
+        }
+        return initial;
+    }
+
+    export function foldRight<T>(array: T[], f: (a: T, x: T) => T): T;
+    export function foldRight<T, U>(array: T[], f: (a: U, x: T) => U, initial: U): U;
+    export function foldRight<T, U>(array: T[], f: (a: U, x: T) => U, initial?: U): U {
+        if (array) {
+            var pos = array.length - 1;
+            if (pos >= 0) {
+                var result = arguments.length <= 2 ? array[pos--] : initial;
+                while (pos >= 0) {
+                    result = f(<U>result, array[pos--]);
+                }
+                return <U>result;
+            }
+        }
+        return initial;
+    }
+
     let hasOwnProperty = Object.prototype.hasOwnProperty;
 
     export function hasProperty<T>(map: Map<T>, key: string): boolean {