Skip to content

Commit de7d68a

Browse files
sandersnsandersn
committed
Even more renaming
1 parent 3c79225 commit de7d68a

File tree

1 file changed

+23
-23
lines changed

1 file changed

+23
-23
lines changed

‎src/services/codefixes/inferFromUsage.ts‎

Lines changed: 23 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -481,7 +481,7 @@ namespace ts.codefix {
481481
}
482482

483483
function single(): Type {
484-
return unifyTypes(inferTypesFromReferencesSingle(references));
484+
return combineTypes(inferTypesFromReferencesSingle(references));
485485
}
486486

487487
function parameters(declaration: FunctionLike): ParameterInference[] | undefined {
@@ -517,7 +517,7 @@ namespace ts.codefix {
517517
const inferred = inferTypesFromReferencesSingle(getReferences(parameter.name, program, cancellationToken));
518518
types.push(...(isRest ? mapDefined(inferred, checker.getElementTypeOfArrayType) : inferred));
519519
}
520-
const type = unifyTypes(types);
520+
const type = combineTypes(types);
521521
return {
522522
type: isRest ? checker.createArrayType(type) : type,
523523
isOptional: isOptional && !isRest,
@@ -533,7 +533,7 @@ namespace ts.codefix {
533533
calculateUsageOfNode(reference, usage);
534534
}
535535

536-
return unifyTypes(usage.candidateThisTypes || emptyArray);
536+
return combineTypes(usage.candidateThisTypes || emptyArray);
537537
}
538538

539539
function inferTypesFromReferencesSingle(references: readonly Identifier[]): Type[] {
@@ -542,7 +542,7 @@ namespace ts.codefix {
542542
cancellationToken.throwIfCancellationRequested();
543543
calculateUsageOfNode(reference, usage);
544544
}
545-
return inferFromUsage(usage);
545+
return inferTypes(usage);
546546
}
547547

548548
function calculateUsageOfNode(node: Expression, usage: Usage): void {
@@ -819,11 +819,11 @@ namespace ts.codefix {
819819
return inferences.filter(i => toRemove.every(f => !f(i)));
820820
}
821821

822-
function unifyFromUsage(usage: Usage) {
823-
return unifyTypes(inferFromUsage(usage));
822+
function combineFromUsage(usage: Usage) {
823+
return combineTypes(inferTypes(usage));
824824
}
825825

826-
function unifyTypes(inferences: readonly Type[]): Type {
826+
function combineTypes(inferences: readonly Type[]): Type {
827827
if (!inferences.length) return checker.getAnyType();
828828

829829
// 1. string or number individually override string | number
@@ -847,12 +847,12 @@ namespace ts.codefix {
847847
const anons = good.filter(i => checker.getObjectFlags(i) & ObjectFlags.Anonymous) as AnonymousType[];
848848
if (anons.length) {
849849
good = good.filter(i => !(checker.getObjectFlags(i) & ObjectFlags.Anonymous));
850-
good.push(unifyAnonymousTypes(anons));
850+
good.push(combineAnonymousTypes(anons));
851851
}
852852
return checker.getWidenedType(checker.getUnionType(good.map(checker.getBaseTypeOfLiteralType), UnionReduction.Subtype));
853853
}
854854

855-
function unifyAnonymousTypes(anons: AnonymousType[]) {
855+
function combineAnonymousTypes(anons: AnonymousType[]) {
856856
if (anons.length === 1) {
857857
return anons[0];
858858
}
@@ -893,7 +893,7 @@ namespace ts.codefix {
893893
numberIndices.length ? checker.createIndexInfo(checker.getUnionType(numberIndices), numberIndexReadonly) : undefined);
894894
}
895895

896-
function inferFromUsage(usage: Usage): Type[] {
896+
function inferTypes(usage: Usage): Type[] {
897897
const types = [];
898898

899899
if (usage.isNumber) {
@@ -906,7 +906,7 @@ namespace ts.codefix {
906906
types.push(checker.getUnionType([checker.getStringType(), checker.getNumberType()]));
907907
}
908908
if (usage.numberIndex) {
909-
types.push(checker.createArrayType(unifyFromUsage(usage.numberIndex)));
909+
types.push(checker.createArrayType(combineFromUsage(usage.numberIndex)));
910910
}
911911
if (usage.properties && usage.properties.size
912912
|| usage.calls && usage.calls.length
@@ -926,13 +926,13 @@ namespace ts.codefix {
926926
if (usage.properties) {
927927
usage.properties.forEach((u, name) => {
928928
const symbol = checker.createSymbol(SymbolFlags.Property, name);
929-
symbol.type = unifyFromUsage(u);
929+
symbol.type = combineFromUsage(u);
930930
members.set(name, symbol);
931931
});
932932
}
933933
const callSignatures: Signature[] = usage.calls ? [getSignatureFromCalls(usage.calls)] : [];
934934
const constructSignatures: Signature[] = usage.constructs ? [getSignatureFromCalls(usage.constructs)] : [];
935-
const stringIndexInfo = usage.stringIndex && checker.createIndexInfo(unifyFromUsage(usage.stringIndex), /*isReadonly*/ false);
935+
const stringIndexInfo = usage.stringIndex && checker.createIndexInfo(combineFromUsage(usage.stringIndex), /*isReadonly*/ false);
936936
return checker.createAnonymousType(/*symbol*/ undefined!, members, callSignatures, constructSignatures, stringIndexInfo, /*numberIndexInfo*/ undefined); // TODO: GH#18217
937937
}
938938

@@ -959,7 +959,7 @@ namespace ts.codefix {
959959
result = result && !!sigs.length && checker.isTypeAssignableTo(source, getFunctionFromCalls(propUsage.calls));
960960
}
961961
else {
962-
result = result && checker.isTypeAssignableTo(source, unifyFromUsage(propUsage));
962+
result = result && checker.isTypeAssignableTo(source, combineFromUsage(propUsage));
963963
}
964964
});
965965
return result;
@@ -982,17 +982,17 @@ namespace ts.codefix {
982982
usage.properties.forEach((propUsage, name) => {
983983
const genericPropertyType = checker.getTypeOfPropertyOfType(generic, name as string);
984984
Debug.assert(!!genericPropertyType, "generic should have all the properties of its reference.");
985-
types.push(...infer(genericPropertyType!, unifyFromUsage(propUsage), singleTypeParameter));
985+
types.push(...inferTypeParameters(genericPropertyType!, combineFromUsage(propUsage), singleTypeParameter));
986986
});
987-
return builtinConstructors[type.symbol.escapedName as string](unifyTypes(types));
987+
return builtinConstructors[type.symbol.escapedName as string](combineTypes(types));
988988
}
989989

990-
function infer(genericType: Type, usageType: Type, typeParameter: Type): readonly Type[] {
990+
function inferTypeParameters(genericType: Type, usageType: Type, typeParameter: Type): readonly Type[] {
991991
if (genericType === typeParameter) {
992992
return [usageType];
993993
}
994994
else if (genericType.flags & TypeFlags.UnionOrIntersection) {
995-
return flatMap((genericType as UnionOrIntersectionType).types, t => infer(t, usageType, typeParameter));
995+
return flatMap((genericType as UnionOrIntersectionType).types, t => inferTypeParameters(t, usageType, typeParameter));
996996
}
997997
else if (getObjectFlags(genericType) & ObjectFlags.Reference && getObjectFlags(usageType) & ObjectFlags.Reference) {
998998
// this is wrong because we need a reference to the targetType to, so we can check that it's also a reference
@@ -1002,7 +1002,7 @@ namespace ts.codefix {
10021002
if (genericArgs && usageArgs) {
10031003
for (let i = 0; i < genericArgs.length; i++) {
10041004
if (usageArgs[i]) {
1005-
types.push(...infer(genericArgs[i], usageArgs[i], typeParameter));
1005+
types.push(...inferTypeParameters(genericArgs[i], usageArgs[i], typeParameter));
10061006
}
10071007
}
10081008
}
@@ -1031,11 +1031,11 @@ namespace ts.codefix {
10311031
genericParamType = elementType;
10321032
}
10331033
const targetType = (usageParam as SymbolLinks).type || checker.getTypeOfSymbolAtLocation(usageParam, usageParam.valueDeclaration);
1034-
types.push(...infer(genericParamType, targetType, typeParameter));
1034+
types.push(...inferTypeParameters(genericParamType, targetType, typeParameter));
10351035
}
10361036
const genericReturn = checker.getReturnTypeOfSignature(genericSig);
10371037
const usageReturn = checker.getReturnTypeOfSignature(usageSig);
1038-
types.push(...infer(genericReturn, usageReturn, typeParameter));
1038+
types.push(...inferTypeParameters(genericReturn, usageReturn, typeParameter));
10391039
return types;
10401040
}
10411041

@@ -1048,13 +1048,13 @@ namespace ts.codefix {
10481048
const length = Math.max(...calls.map(c => c.argumentTypes.length));
10491049
for (let i = 0; i < length; i++) {
10501050
const symbol = checker.createSymbol(SymbolFlags.FunctionScopedVariable, escapeLeadingUnderscores(`arg${i}`));
1051-
symbol.type = unifyTypes(calls.map(call => call.argumentTypes[i] || checker.getUndefinedType()));
1051+
symbol.type = combineTypes(calls.map(call => call.argumentTypes[i] || checker.getUndefinedType()));
10521052
if (calls.some(call => call.argumentTypes[i] === undefined)) {
10531053
symbol.flags |= SymbolFlags.Optional;
10541054
}
10551055
parameters.push(symbol);
10561056
}
1057-
const returnType = unifyFromUsage(combineUsages(calls.map(call => call.return_)));
1057+
const returnType = combineFromUsage(combineUsages(calls.map(call => call.return_)));
10581058
// TODO: GH#18217
10591059
return checker.createSignature(/*declaration*/ undefined!, /*typeParameters*/ undefined, /*thisParameter*/ undefined, parameters, returnType, /*typePredicate*/ undefined, length, /*hasRestParameter*/ false, /*hasLiteralTypes*/ false);
10601060
}

0 commit comments

Comments
 (0)