Skip to content

Commit b53b5cf

Browse files
author
Andy Hanson
committed
Remove the "set" function and use map.set with multiple lines of code if necessary.
1 parent 5c304d0 commit b53b5cf

14 files changed

Lines changed: 91 additions & 45 deletions

File tree

‎src/compiler/binder.ts‎

Lines changed: 5 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -349,7 +349,10 @@ namespace ts {
349349
// Otherwise, we'll be merging into a compatible existing symbol (for example when
350350
// you have multiple 'vars' with the same name in the same container). In this case
351351
// just add this node into the declarations list of the symbol.
352-
symbol = symbolTable.get(name) || set(symbolTable, name, createSymbol(SymbolFlags.None, name));
352+
symbol = symbolTable.get(name);
353+
if (!symbol) {
354+
symbolTable.set(name, symbol = createSymbol(SymbolFlags.None, name));
355+
}
353356

354357
if (name && (includes & SymbolFlags.Classifiable)) {
355358
classifiableNames.set(name, name);
@@ -359,7 +362,7 @@ namespace ts {
359362
if (symbol.isReplaceableByMethod) {
360363
// Javascript constructor-declared symbols can be discarded in favor of
361364
// prototype symbols like methods.
362-
symbol = set(symbolTable, name, createSymbol(SymbolFlags.None, name));
365+
symbolTable.set(name, symbol = createSymbol(SymbolFlags.None, name));
363366
}
364367
else {
365368
if (node.name) {

‎src/compiler/checker.ts‎

Lines changed: 38 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -4062,7 +4062,8 @@ namespace ts {
40624062
const memberSymbol = getSymbolOfNode(member);
40634063
const value = getEnumMemberValue(member);
40644064
if (!memberTypes.has(value)) {
4065-
const memberType = set(memberTypes, value, createEnumLiteralType(memberSymbol, enumType, "" + value));
4065+
const memberType = createEnumLiteralType(memberSymbol, enumType, "" + value);
4066+
memberTypes.set(value, memberType);
40664067
memberTypeList.push(memberType);
40674068
}
40684069
}
@@ -5192,7 +5193,11 @@ namespace ts {
51925193
function getSignatureInstantiation(signature: Signature, typeArguments: Type[]): Signature {
51935194
const instantiations = signature.instantiations || (signature.instantiations = createMap<Signature>());
51945195
const id = getTypeListId(typeArguments);
5195-
return instantiations.get(id) || set(instantiations, id, createSignatureInstantiation(signature, typeArguments));
5196+
let instantiation = instantiations.get(id);
5197+
if (!instantiation) {
5198+
instantiations.set(id, instantiation = createSignatureInstantiation(signature, typeArguments));
5199+
}
5200+
return instantiation;
51965201
}
51975202

51985203
function createSignatureInstantiation(signature: Signature, typeArguments: Type[]): Signature {
@@ -5348,7 +5353,8 @@ namespace ts {
53485353
const id = getTypeListId(typeArguments);
53495354
let type = target.instantiations.get(id);
53505355
if (!type) {
5351-
type = set(target.instantiations, id, <TypeReference>createObjectType(ObjectFlags.Reference, target.symbol));
5356+
type = <TypeReference>createObjectType(ObjectFlags.Reference, target.symbol);
5357+
target.instantiations.set(id, type);
53525358
type.flags |= typeArguments ? getPropagatingFlagsOfTypes(typeArguments, /*excludeKinds*/ 0) : 0;
53535359
type.target = target;
53545360
type.typeArguments = typeArguments;
@@ -5395,7 +5401,11 @@ namespace ts {
53955401
const links = getSymbolLinks(symbol);
53965402
const typeParameters = links.typeParameters;
53975403
const id = getTypeListId(typeArguments);
5398-
return links.instantiations.get(id) || set(links.instantiations, id, instantiateTypeNoAlias(type, createTypeMapper(typeParameters, typeArguments)));
5404+
let instantiation = links.instantiations.get(id);
5405+
if (!instantiation) {
5406+
links.instantiations.set(id, instantiation = instantiateTypeNoAlias(type, createTypeMapper(typeParameters, typeArguments)));
5407+
}
5408+
return instantiation;
53995409
}
54005410

54015411
// 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 {
58445854
let type = unionTypes.get(id);
58455855
if (!type) {
58465856
const propagatedFlags = getPropagatingFlagsOfTypes(types, /*excludeKinds*/ TypeFlags.Nullable);
5847-
type = set(unionTypes, id, <UnionType>createType(TypeFlags.Union | propagatedFlags));
5857+
type = <UnionType>createType(TypeFlags.Union | propagatedFlags);
5858+
unionTypes.set(id, type);
58485859
type.types = types;
58495860
type.aliasSymbol = aliasSymbol;
58505861
type.aliasTypeArguments = aliasTypeArguments;
@@ -5918,7 +5929,8 @@ namespace ts {
59185929
let type = intersectionTypes.get(id);
59195930
if (!type) {
59205931
const propagatedFlags = getPropagatingFlagsOfTypes(typeSet, /*excludeKinds*/ TypeFlags.Nullable);
5921-
type = set(intersectionTypes, id, <IntersectionType>createType(TypeFlags.Intersection | propagatedFlags));
5932+
type = <IntersectionType>createType(TypeFlags.Intersection | propagatedFlags);
5933+
intersectionTypes.set(id, type);
59225934
type.types = typeSet;
59235935
type.aliasSymbol = aliasSymbol;
59245936
type.aliasTypeArguments = aliasTypeArguments;
@@ -6100,7 +6112,11 @@ namespace ts {
61006112
}
61016113
// Otherwise we defer the operation by creating an indexed access type.
61026114
const id = objectType.id + "," + indexType.id;
6103-
return indexedAccessTypes.get(id) || set(indexedAccessTypes, id, createIndexedAccessType(objectType, indexType));
6115+
let type = indexedAccessTypes.get(id);
6116+
if (!type) {
6117+
indexedAccessTypes.set(id, type = createIndexedAccessType(objectType, indexType));
6118+
}
6119+
return type;
61046120
}
61056121
// In the following we resolve T[K] to the type of the property in T selected by K.
61066122
const apparentObjectType = getApparentType(objectType);
@@ -6268,7 +6284,11 @@ namespace ts {
62686284

62696285
function getLiteralTypeForText(flags: TypeFlags, text: string) {
62706286
const map = flags & TypeFlags.StringLiteral ? stringLiteralTypes : numericLiteralTypes;
6271-
return map.get(text) || set(map, text, createLiteralType(flags, text));
6287+
let type = map.get(text);
6288+
if (!type) {
6289+
map.set(text, type = createLiteralType(flags, text));
6290+
}
6291+
return type;
62726292
}
62736293

62746294
function getTypeFromLiteralTypeNode(node: LiteralTypeNode): Type {
@@ -7060,7 +7080,8 @@ namespace ts {
70607080
if (source.symbol.name !== target.symbol.name ||
70617081
!(source.symbol.flags & SymbolFlags.RegularEnum) || !(target.symbol.flags & SymbolFlags.RegularEnum) ||
70627082
(source.flags & TypeFlags.Union) !== (target.flags & TypeFlags.Union)) {
7063-
return set(enumRelation, id, false);
7083+
enumRelation.set(id, false);
7084+
return false;
70647085
}
70657086
const targetEnumType = getTypeOfSymbol(target.symbol);
70667087
for (const property of getPropertiesOfType(getTypeOfSymbol(source.symbol))) {
@@ -7071,11 +7092,13 @@ namespace ts {
70717092
errorReporter(Diagnostics.Property_0_is_missing_in_type_1, property.name,
70727093
typeToString(target, /*enclosingDeclaration*/ undefined, TypeFormatFlags.UseFullyQualifiedType));
70737094
}
7074-
return set(enumRelation, id, false);
7095+
enumRelation.set(id, false);
7096+
return false;
70757097
}
70767098
}
70777099
}
7078-
return set(enumRelation, id, true);
7100+
enumRelation.set(id, true);
7101+
return true;
70797102
}
70807103

70817104
function isSimpleTypeRelatedTo(source: Type, target: Type, relation: Map<RelationComparisonResult>, errorReporter?: ErrorReporter) {
@@ -9815,7 +9838,8 @@ namespace ts {
98159838
if (isIncomplete(firstAntecedentType)) {
98169839
return createFlowType(result, /*incomplete*/ true);
98179840
}
9818-
return set(cache, key, result);
9841+
cache.set(key, result);
9842+
return result;
98199843
}
98209844

98219845
function isMatchingReferenceDiscriminant(expr: Expression) {
@@ -11771,9 +11795,9 @@ namespace ts {
1177111795
}
1177211796

1177311797
function getJsxType(name: string) {
11774-
const jsxType = jsxTypes.get(name);
11798+
let jsxType = jsxTypes.get(name);
1177511799
if (jsxType === undefined) {
11776-
return set(jsxTypes, name, getExportedTypeFromNamespace(JsxNames.JSX, name) || unknownType);
11800+
jsxTypes.set(name, jsxType = getExportedTypeFromNamespace(JsxNames.JSX, name) || unknownType);
1177711801
}
1177811802
return jsxType;
1177911803
}

‎src/compiler/core.ts‎

Lines changed: 3 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -156,15 +156,6 @@ namespace ts {
156156
}
157157
}
158158

159-
/**
160-
* Unlike `map.set(key, value)`, this returns the value, making it useful as an expression.
161-
* Prefer `map.set(key, value)` for statements.
162-
*/
163-
export function set<T>(map: Map<T>, key: MapKey, value: T): T {
164-
map.set(key, value);
165-
return value;
166-
}
167-
168159
export function createFileMap<T>(keyMapper?: (key: string) => string): FileMap<T> {
169160
const files = createMap<T>();
170161
return {
@@ -1050,14 +1041,14 @@ namespace ts {
10501041
* Creates the array if it does not already exist.
10511042
*/
10521043
export function multiMapAdd<V>(map: Map<V[]>, key: string | number, value: V): V[] {
1053-
const values = map.get(key);
1044+
let values = map.get(key);
10541045
if (values) {
10551046
values.push(value);
1056-
return values;
10571047
}
10581048
else {
1059-
return set(map, key, [value]);
1049+
map.set(key, values = [value]);
10601050
}
1051+
return values;
10611052
}
10621053

10631054
/**

‎src/compiler/emitter.ts‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2545,7 +2545,8 @@ namespace ts {
25452545
while (true) {
25462546
const generatedName = baseName + i;
25472547
if (isUniqueName(generatedName)) {
2548-
return set(generatedNameSet, generatedName, generatedName);
2548+
generatedNameSet.set(generatedName, generatedName);
2549+
return generatedName;
25492550
}
25502551
i++;
25512552
}

‎src/compiler/parser.ts‎

Lines changed: 5 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1131,7 +1131,11 @@ namespace ts {
11311131

11321132
function internIdentifier(text: string): string {
11331133
text = escapeIdentifier(text);
1134-
return identifiers.get(text) || set(identifiers, text, text);
1134+
let identifier = identifiers.get(text);
1135+
if (identifier === undefined) {
1136+
identifiers.set(text, identifier = text);
1137+
}
1138+
return identifier;
11351139
}
11361140

11371141
// An identifier that starts with two underscores has an extra underscore character prepended to it to avoid issues

‎src/compiler/program.ts‎

Lines changed: 7 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -277,9 +277,13 @@ namespace ts {
277277
const resolutions: T[] = [];
278278
const cache = createMap<T>();
279279
for (const name of names) {
280-
const result = cache.has(name)
281-
? cache.get(name)
282-
: set(cache, name, loader(name, containingFile));
280+
let result: T;
281+
if (cache.has(name)) {
282+
result = cache.get(name);
283+
}
284+
else {
285+
cache.set(name, result = loader(name, containingFile));
286+
}
283287
resolutions.push(result);
284288
}
285289
return resolutions;

‎src/compiler/transformers/module/module.ts‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -60,7 +60,8 @@ namespace ts {
6060
}
6161

6262
currentSourceFile = node;
63-
currentModuleInfo = set(moduleInfoMap, getOriginalNodeId(node), collectExternalModuleInfo(node, resolver, compilerOptions));
63+
currentModuleInfo = collectExternalModuleInfo(node, resolver, compilerOptions);
64+
moduleInfoMap.set(getOriginalNodeId(node), currentModuleInfo);
6465

6566
// Perform the transformation.
6667
const transformModule = transformModuleDelegates.get(moduleKind) || transformModuleDelegates.get(ModuleKind.None);

‎src/compiler/transformers/module/system.ts‎

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -73,11 +73,13 @@ namespace ts {
7373
// see comment to 'substitutePostfixUnaryExpression' for more details
7474

7575
// Collect information about the external module and dependency groups.
76-
moduleInfo = set(moduleInfoMap, id, collectExternalModuleInfo(node, resolver, compilerOptions));
76+
moduleInfo = collectExternalModuleInfo(node, resolver, compilerOptions);
77+
moduleInfoMap.set(id, moduleInfo);
7778

7879
// Make sure that the name of the 'exports' function does not conflict with
7980
// existing identifiers.
80-
exportFunction = set(exportFunctionsMap, id, createUniqueName("exports"));
81+
exportFunction = createUniqueName("exports");
82+
exportFunctionsMap.set(id, exportFunction);
8183
contextObject = createUniqueName("context");
8284

8385
// Add the body of the module.

‎src/compiler/tsc.ts‎

Lines changed: 5 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -378,8 +378,11 @@ namespace ts {
378378
}
379379

380380
function cachedFileExists(fileName: string): boolean {
381-
const fileExists = cachedExistingFiles.get(fileName);
382-
return fileExists !== undefined ? fileExists : set(cachedExistingFiles, fileName, hostFileExists(fileName));
381+
let fileExists = cachedExistingFiles.get(fileName);
382+
if (fileExists === undefined) {
383+
cachedExistingFiles.set(fileName, fileExists = hostFileExists(fileName));
384+
}
385+
return fileExists;
383386
}
384387

385388
function getSourceFile(fileName: string, languageVersion: ScriptTarget, onError?: (message: string) => void) {

‎src/compiler/utilities.ts‎

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -3323,7 +3323,9 @@ namespace ts {
33233323

33243324
for (const name in syntaxKindEnum) {
33253325
if (syntaxKindEnum[name] === kind) {
3326-
return set(syntaxKindCache, kind, kind.toString() + " (" + name + ")");
3326+
const result = `${kind} (${name})`;
3327+
syntaxKindCache.set(kind, result);
3328+
return result;
33273329
}
33283330
}
33293331
}

0 commit comments

Comments
 (0)