From b53b5cf4ab8f60090cc6ad764d9cfae718d3a50e Mon Sep 17 00:00:00 2001 From: Andy Hanson Date: Mon, 12 Dec 2016 08:42:12 -0800 Subject: [PATCH] Remove the "set" function and use `map.set` with multiple lines of code if necessary. --- src/compiler/binder.ts | 7 ++- src/compiler/checker.ts | 52 ++++++++++++++++------ src/compiler/core.ts | 15 ++----- src/compiler/emitter.ts | 3 +- src/compiler/parser.ts | 6 ++- src/compiler/program.ts | 10 +++-- src/compiler/transformers/module/module.ts | 3 +- src/compiler/transformers/module/system.ts | 6 ++- src/compiler/tsc.ts | 7 ++- src/compiler/utilities.ts | 4 +- src/harness/harness.ts | 8 ++-- src/server/client.ts | 3 +- src/services/patternMatcher.ts | 6 ++- src/services/services.ts | 6 ++- 14 files changed, 91 insertions(+), 45 deletions(-) diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts index 18a6d00e922..046b67ccd1c 100644 --- a/src/compiler/binder.ts +++ b/src/compiler/binder.ts @@ -349,7 +349,10 @@ 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.get(name) || set(symbolTable, name, createSymbol(SymbolFlags.None, name)); + symbol = symbolTable.get(name); + if (!symbol) { + symbolTable.set(name, symbol = createSymbol(SymbolFlags.None, name)); + } if (name && (includes & SymbolFlags.Classifiable)) { classifiableNames.set(name, name); @@ -359,7 +362,7 @@ namespace ts { if (symbol.isReplaceableByMethod) { // Javascript constructor-declared symbols can be discarded in favor of // prototype symbols like methods. - symbol = set(symbolTable, name, createSymbol(SymbolFlags.None, name)); + symbolTable.set(name, symbol = createSymbol(SymbolFlags.None, name)); } else { if (node.name) { diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 6bbbab8822e..2394d5017a3 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -4062,7 +4062,8 @@ namespace ts { const memberSymbol = getSymbolOfNode(member); const value = getEnumMemberValue(member); if (!memberTypes.has(value)) { - const memberType = set(memberTypes, value, createEnumLiteralType(memberSymbol, enumType, "" + value)); + const memberType = createEnumLiteralType(memberSymbol, enumType, "" + value); + memberTypes.set(value, memberType); memberTypeList.push(memberType); } } @@ -5192,7 +5193,11 @@ namespace ts { function getSignatureInstantiation(signature: Signature, typeArguments: Type[]): Signature { const instantiations = signature.instantiations || (signature.instantiations = createMap()); const id = getTypeListId(typeArguments); - return instantiations.get(id) || set(instantiations, id, createSignatureInstantiation(signature, typeArguments)); + let instantiation = instantiations.get(id); + if (!instantiation) { + instantiations.set(id, instantiation = createSignatureInstantiation(signature, typeArguments)); + } + return instantiation; } function createSignatureInstantiation(signature: Signature, typeArguments: Type[]): Signature { @@ -5348,7 +5353,8 @@ namespace ts { const id = getTypeListId(typeArguments); let type = target.instantiations.get(id); if (!type) { - type = set(target.instantiations, id, createObjectType(ObjectFlags.Reference, target.symbol)); + type = createObjectType(ObjectFlags.Reference, target.symbol); + target.instantiations.set(id, type); type.flags |= typeArguments ? getPropagatingFlagsOfTypes(typeArguments, /*excludeKinds*/ 0) : 0; type.target = target; type.typeArguments = typeArguments; @@ -5395,7 +5401,11 @@ namespace ts { const links = getSymbolLinks(symbol); const typeParameters = links.typeParameters; const id = getTypeListId(typeArguments); - return links.instantiations.get(id) || set(links.instantiations, id, instantiateTypeNoAlias(type, createTypeMapper(typeParameters, typeArguments))); + let instantiation = links.instantiations.get(id); + if (!instantiation) { + links.instantiations.set(id, instantiation = instantiateTypeNoAlias(type, createTypeMapper(typeParameters, typeArguments))); + } + return instantiation; } // Get type from reference to type alias. When a type alias is generic, the declared type of the type alias may include @@ -5844,7 +5854,8 @@ namespace ts { let type = unionTypes.get(id); if (!type) { const propagatedFlags = getPropagatingFlagsOfTypes(types, /*excludeKinds*/ TypeFlags.Nullable); - type = set(unionTypes, id, createType(TypeFlags.Union | propagatedFlags)); + type = createType(TypeFlags.Union | propagatedFlags); + unionTypes.set(id, type); type.types = types; type.aliasSymbol = aliasSymbol; type.aliasTypeArguments = aliasTypeArguments; @@ -5918,7 +5929,8 @@ namespace ts { let type = intersectionTypes.get(id); if (!type) { const propagatedFlags = getPropagatingFlagsOfTypes(typeSet, /*excludeKinds*/ TypeFlags.Nullable); - type = set(intersectionTypes, id, createType(TypeFlags.Intersection | propagatedFlags)); + type = createType(TypeFlags.Intersection | propagatedFlags); + intersectionTypes.set(id, type); type.types = typeSet; type.aliasSymbol = aliasSymbol; type.aliasTypeArguments = aliasTypeArguments; @@ -6100,7 +6112,11 @@ namespace ts { } // Otherwise we defer the operation by creating an indexed access type. const id = objectType.id + "," + indexType.id; - return indexedAccessTypes.get(id) || set(indexedAccessTypes, id, createIndexedAccessType(objectType, indexType)); + let type = indexedAccessTypes.get(id); + if (!type) { + indexedAccessTypes.set(id, type = createIndexedAccessType(objectType, indexType)); + } + return type; } // In the following we resolve T[K] to the type of the property in T selected by K. const apparentObjectType = getApparentType(objectType); @@ -6268,7 +6284,11 @@ namespace ts { function getLiteralTypeForText(flags: TypeFlags, text: string) { const map = flags & TypeFlags.StringLiteral ? stringLiteralTypes : numericLiteralTypes; - return map.get(text) || set(map, text, createLiteralType(flags, text)); + let type = map.get(text); + if (!type) { + map.set(text, type = createLiteralType(flags, text)); + } + return type; } function getTypeFromLiteralTypeNode(node: LiteralTypeNode): Type { @@ -7060,7 +7080,8 @@ namespace ts { if (source.symbol.name !== target.symbol.name || !(source.symbol.flags & SymbolFlags.RegularEnum) || !(target.symbol.flags & SymbolFlags.RegularEnum) || (source.flags & TypeFlags.Union) !== (target.flags & TypeFlags.Union)) { - return set(enumRelation, id, false); + enumRelation.set(id, false); + return false; } const targetEnumType = getTypeOfSymbol(target.symbol); for (const property of getPropertiesOfType(getTypeOfSymbol(source.symbol))) { @@ -7071,11 +7092,13 @@ namespace ts { errorReporter(Diagnostics.Property_0_is_missing_in_type_1, property.name, typeToString(target, /*enclosingDeclaration*/ undefined, TypeFormatFlags.UseFullyQualifiedType)); } - return set(enumRelation, id, false); + enumRelation.set(id, false); + return false; } } } - return set(enumRelation, id, true); + enumRelation.set(id, true); + return true; } function isSimpleTypeRelatedTo(source: Type, target: Type, relation: Map, errorReporter?: ErrorReporter) { @@ -9815,7 +9838,8 @@ namespace ts { if (isIncomplete(firstAntecedentType)) { return createFlowType(result, /*incomplete*/ true); } - return set(cache, key, result); + cache.set(key, result); + return result; } function isMatchingReferenceDiscriminant(expr: Expression) { @@ -11771,9 +11795,9 @@ namespace ts { } function getJsxType(name: string) { - const jsxType = jsxTypes.get(name); + let jsxType = jsxTypes.get(name); if (jsxType === undefined) { - return set(jsxTypes, name, getExportedTypeFromNamespace(JsxNames.JSX, name) || unknownType); + jsxTypes.set(name, jsxType = getExportedTypeFromNamespace(JsxNames.JSX, name) || unknownType); } return jsxType; } diff --git a/src/compiler/core.ts b/src/compiler/core.ts index 4ed20bcdecf..6239dc93146 100644 --- a/src/compiler/core.ts +++ b/src/compiler/core.ts @@ -156,15 +156,6 @@ namespace ts { } } - /** - * Unlike `map.set(key, value)`, this returns the value, making it useful as an expression. - * Prefer `map.set(key, value)` for statements. - */ - export function set(map: Map, key: MapKey, value: T): T { - map.set(key, value); - return value; - } - export function createFileMap(keyMapper?: (key: string) => string): FileMap { const files = createMap(); return { @@ -1050,14 +1041,14 @@ namespace ts { * Creates the array if it does not already exist. */ export function multiMapAdd(map: Map, key: string | number, value: V): V[] { - const values = map.get(key); + let values = map.get(key); if (values) { values.push(value); - return values; } else { - return set(map, key, [value]); + map.set(key, values = [value]); } + return values; } /** diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index 191a39a5797..00144f2d00b 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -2545,7 +2545,8 @@ namespace ts { while (true) { const generatedName = baseName + i; if (isUniqueName(generatedName)) { - return set(generatedNameSet, generatedName, generatedName); + generatedNameSet.set(generatedName, generatedName); + return generatedName; } i++; } diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 3da9093ee5a..bb53eeba0e0 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -1131,7 +1131,11 @@ namespace ts { function internIdentifier(text: string): string { text = escapeIdentifier(text); - return identifiers.get(text) || set(identifiers, text, text); + let identifier = identifiers.get(text); + if (identifier === undefined) { + identifiers.set(text, identifier = text); + } + return identifier; } // An identifier that starts with two underscores has an extra underscore character prepended to it to avoid issues diff --git a/src/compiler/program.ts b/src/compiler/program.ts index 3da9f57ca39..ab04a21ee69 100644 --- a/src/compiler/program.ts +++ b/src/compiler/program.ts @@ -277,9 +277,13 @@ namespace ts { const resolutions: T[] = []; const cache = createMap(); for (const name of names) { - const result = cache.has(name) - ? cache.get(name) - : set(cache, name, loader(name, containingFile)); + let result: T; + if (cache.has(name)) { + result = cache.get(name); + } + else { + cache.set(name, result = loader(name, containingFile)); + } resolutions.push(result); } return resolutions; diff --git a/src/compiler/transformers/module/module.ts b/src/compiler/transformers/module/module.ts index 2e926406fb4..5d05667e4c2 100644 --- a/src/compiler/transformers/module/module.ts +++ b/src/compiler/transformers/module/module.ts @@ -60,7 +60,8 @@ namespace ts { } currentSourceFile = node; - currentModuleInfo = set(moduleInfoMap, getOriginalNodeId(node), collectExternalModuleInfo(node, resolver, compilerOptions)); + currentModuleInfo = collectExternalModuleInfo(node, resolver, compilerOptions); + moduleInfoMap.set(getOriginalNodeId(node), currentModuleInfo); // Perform the transformation. const transformModule = transformModuleDelegates.get(moduleKind) || transformModuleDelegates.get(ModuleKind.None); diff --git a/src/compiler/transformers/module/system.ts b/src/compiler/transformers/module/system.ts index 8d1e1749c0b..bc613bcfaf6 100644 --- a/src/compiler/transformers/module/system.ts +++ b/src/compiler/transformers/module/system.ts @@ -73,11 +73,13 @@ namespace ts { // see comment to 'substitutePostfixUnaryExpression' for more details // Collect information about the external module and dependency groups. - moduleInfo = set(moduleInfoMap, id, collectExternalModuleInfo(node, resolver, compilerOptions)); + moduleInfo = collectExternalModuleInfo(node, resolver, compilerOptions); + moduleInfoMap.set(id, moduleInfo); // Make sure that the name of the 'exports' function does not conflict with // existing identifiers. - exportFunction = set(exportFunctionsMap, id, createUniqueName("exports")); + exportFunction = createUniqueName("exports"); + exportFunctionsMap.set(id, exportFunction); contextObject = createUniqueName("context"); // Add the body of the module. diff --git a/src/compiler/tsc.ts b/src/compiler/tsc.ts index 0e66ccb14b8..5de16a20fc2 100644 --- a/src/compiler/tsc.ts +++ b/src/compiler/tsc.ts @@ -378,8 +378,11 @@ namespace ts { } function cachedFileExists(fileName: string): boolean { - const fileExists = cachedExistingFiles.get(fileName); - return fileExists !== undefined ? fileExists : set(cachedExistingFiles, fileName, hostFileExists(fileName)); + let fileExists = cachedExistingFiles.get(fileName); + if (fileExists === undefined) { + cachedExistingFiles.set(fileName, fileExists = hostFileExists(fileName)); + } + return fileExists; } function getSourceFile(fileName: string, languageVersion: ScriptTarget, onError?: (message: string) => void) { diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index 94b0fa20987..25973cae5cb 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -3323,7 +3323,9 @@ namespace ts { for (const name in syntaxKindEnum) { if (syntaxKindEnum[name] === kind) { - return set(syntaxKindCache, kind, kind.toString() + " (" + name + ")"); + const result = `${kind} (${name})`; + syntaxKindCache.set(kind, result); + return result; } } } diff --git a/src/harness/harness.ts b/src/harness/harness.ts index 265fe4c142c..c94a9360745 100644 --- a/src/harness/harness.ts +++ b/src/harness/harness.ts @@ -918,9 +918,11 @@ namespace Harness { return undefined; } - const sourceFile = libFileNameSourceFileMap.get(fileName); - return sourceFile || ts.set(libFileNameSourceFileMap, fileName, - createSourceFileAndAssertInvariants(fileName, IO.readFile(libFolder + fileName), ts.ScriptTarget.Latest)); + let sourceFile = libFileNameSourceFileMap.get(fileName); + if (!sourceFile) { + libFileNameSourceFileMap.set(fileName, sourceFile = createSourceFileAndAssertInvariants(fileName, IO.readFile(libFolder + fileName), ts.ScriptTarget.Latest)); + } + return sourceFile; } export function getDefaultLibFileName(options: ts.CompilerOptions): string { diff --git a/src/server/client.ts b/src/server/client.ts index 13d16073d1c..d9e93769bd9 100644 --- a/src/server/client.ts +++ b/src/server/client.ts @@ -34,7 +34,8 @@ namespace ts.server { let lineMap = this.lineMaps.get(fileName); if (!lineMap) { const scriptSnapshot = this.host.getScriptSnapshot(fileName); - lineMap = set(this.lineMaps, fileName, ts.computeLineStarts(scriptSnapshot.getText(0, scriptSnapshot.getLength()))); + lineMap = ts.computeLineStarts(scriptSnapshot.getText(0, scriptSnapshot.getLength())); + this.lineMaps.set(fileName, lineMap); } return lineMap; } diff --git a/src/services/patternMatcher.ts b/src/services/patternMatcher.ts index b8941ef3147..940290a2f94 100644 --- a/src/services/patternMatcher.ts +++ b/src/services/patternMatcher.ts @@ -188,7 +188,11 @@ namespace ts { } function getWordSpans(word: string): TextSpan[] { - return stringToWordSpans.get(word) || set(stringToWordSpans, word, breakIntoWordSpans(word)); + let spans = stringToWordSpans.get(word); + if (!spans) { + stringToWordSpans.set(word, spans = breakIntoWordSpans(word)); + } + return spans; } function matchTextChunk(candidate: string, chunk: TextChunk, punctuationStripped: boolean): PatternMatch { diff --git a/src/services/services.ts b/src/services/services.ts index 87ae9fb8561..6d0d384bcdd 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -532,7 +532,11 @@ namespace ts { } function getDeclarations(name: string) { - return result.get(name) || set(result, name, []); + let declarations = result.get(name); + if (!declarations) { + result.set(name, declarations = []); + } + return declarations; } function getDeclarationName(declaration: Declaration) {