Add getOrUpdate helper

Author: Andy Hanson

src/compiler/binder.ts

@@ -326,7 +326,7 @@ namespace ts {
                 // Otherwise, we'll be merging into a compatible existing symbol (for example when
                 // you have multiple 'vars' with the same name in the same container).  In this case
                 // just add this node into the declarations list of the symbol.
-                symbol = symbolTable[name] || (symbolTable[name] = createSymbol(SymbolFlags.None, name));
+                symbol = getOrUpdate(symbolTable, name, () => createSymbol(SymbolFlags.None, name));
 
                 if (name && (includes & SymbolFlags.Classifiable)) {
                     classifiableNames[name] = name;

src/compiler/checker.ts

@@ -518,12 +518,12 @@ namespace ts {
         function getSymbolLinks(symbol: Symbol): SymbolLinks {
             if (symbol.flags & SymbolFlags.Transient) return <TransientSymbol>symbol;
             const id = getSymbolId(symbol);
-            return symbolLinks[id] || (symbolLinks[id] = {});
+            return getOrUpdateArray(symbolLinks, id, () => ({}));
         }
 
         function getNodeLinks(node: Node): NodeLinks {
             const nodeId = getNodeId(node);
-            return nodeLinks[nodeId] || (nodeLinks[nodeId] = { flags: 0 });
+            return getOrUpdateArray<NodeLinks>(nodeLinks, nodeId, () => ({ flags: 0 }));
         }
 
         function isGlobalSourceFile(node: Node) {
@@ -5027,7 +5027,7 @@ namespace ts {
                 }
                 const typeArguments = map(node.typeArguments, getTypeFromTypeNode);
                 const id = getTypeListId(typeArguments);
-                return links.instantiations[id] || (links.instantiations[id] = instantiateType(type, createTypeMapper(typeParameters, typeArguments)));
+                return getOrUpdate(links.instantiations, id, () => instantiateType(type, createTypeMapper(typeParameters, typeArguments)));
             }
             if (node.typeArguments) {
                 error(node, Diagnostics.Type_0_is_not_generic, symbolToString(symbol));
@@ -5236,7 +5236,7 @@ namespace ts {
 
         function createTupleType(elementTypes: Type[], thisType?: Type) {
             const id = getTypeListId(elementTypes) + "," + (thisType ? thisType.id : 0);
-            return tupleTypes[id] || (tupleTypes[id] = createNewTupleType(elementTypes, thisType));
+            return getOrUpdate(tupleTypes, id, () => createNewTupleType(elementTypes, thisType));
         }
 
         function createNewTupleType(elementTypes: Type[], thisType?: Type) {
@@ -5480,7 +5480,7 @@ namespace ts {
 
         function getLiteralTypeForText(flags: TypeFlags, text: string) {
             const map = flags & TypeFlags.StringLiteral ? stringLiteralTypes : numericLiteralTypes;
-            return map[text] || (map[text] = createLiteralType(flags, text));
+            return getOrUpdate(map, text, () => createLiteralType(flags, text));
         }
 
         function getTypeFromLiteralTypeNode(node: LiteralTypeNode): Type {
@@ -8351,7 +8351,7 @@ namespace ts {
                 // If we have previously computed the control flow type for the reference at
                 // this flow loop junction, return the cached type.
                 const id = getFlowNodeId(flow);
-                const cache = flowLoopCaches[id] || (flowLoopCaches[id] = createMap<Type>());
+                const cache = getOrUpdateArray<Map<Type>>(flowLoopCaches, id, createMap);
                 if (!key) {
                     key = getFlowCacheKey(reference);
                 }

src/compiler/core.ts

@@ -409,6 +409,19 @@ namespace ts {
         return hasOwnProperty.call(map, key) ? map[key] : undefined;
     }
 
+    /** Gets a property in a Map, or if it doesn't exist, creates and returns it. */
+    export function getOrUpdate<T>(map: Map<T>, key: string, makeValue: () => T) {
+        return map[key] || (map[key] = makeValue());
+    }
+
+    /**
+     * Gets a value in an array, or if it doesn't exist, creates and returns it.
+     * It is the caller's responsibility to ensure that `key` is within the bounds of the array.
+     */
+    export function getOrUpdateArray<T>(arr: T[], key: number, makeValue: () => T) {
+        return arr[key] || (arr[key] = makeValue());
+    }
+
     /**
      * Gets the owned, enumerable property keys of a map-like.
      *

src/compiler/emitter.ts

@@ -760,7 +760,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 
             function getGeneratedNameForNode(node: Node) {
                 const id = getNodeId(node);
-                return nodeToGeneratedName[id] || (nodeToGeneratedName[id] = unescapeIdentifier(generateNameForNode(node)));
+                return getOrUpdateArray(nodeToGeneratedName, id, () => unescapeIdentifier(generateNameForNode(node)));
             }
 
             /** Write emitted output to disk */

src/compiler/parser.ts

@@ -1086,7 +1086,7 @@ namespace ts {
 
         function internIdentifier(text: string): string {
             text = escapeIdentifier(text);
-            return identifiers[text] || (identifiers[text] = text);
+            return getOrUpdate(identifiers, text, () => text);
         }
 
         // An identifier that starts with two underscores has an extra underscore character prepended to it to avoid issues

src/services/services.ts

@@ -990,7 +990,7 @@ namespace ts {
             }
 
             function getDeclarations(name: string) {
-                return result[name] || (result[name] = []);
+                return getOrUpdate(result, name, () => []);
             }
 
             function getDeclarationName(declaration: Declaration) {