Skip to content

Commit 9ac7412

Browse files
ShuiRuTianShuiRuTian
committed
revert some strange format change.
1 parent f0d063c commit 9ac7412

File tree

1 file changed

+63
-63
lines changed

1 file changed

+63
-63
lines changed

‎src/compiler/checker.ts‎

Lines changed: 63 additions & 63 deletions
Original file line numberDiff line numberDiff line change
@@ -12361,7 +12361,7 @@ namespace ts {
1236112361
ElementFlags.Required;
1236212362
default:
1236312363
return ElementFlags.Required;
12364-
}
12364+
}
1236512365
}
1236612366

1236712367
function getRestTypeElementFlags(node: RestTypeNode | NamedTupleMember) {
@@ -12522,7 +12522,7 @@ namespace ts {
1252212522
lengthSymbol.type = numberType;
1252312523
}
1252412524
else {
12525-
const literalTypes = [];
12525+
const literalTypes = [];
1252612526
for (let i = minLength; i <= arity; i++) literalTypes.push(getLiteralType(i));
1252712527
lengthSymbol.type = getUnionType(literalTypes);
1252812528
}
@@ -12557,7 +12557,7 @@ namespace ts {
1255712557
return target.objectFlags & ObjectFlags.Tuple && (<TupleType>target).combinedFlags & ElementFlags.Variadic ?
1255812558
createNormalizedTupleType(target as TupleType, typeArguments!) :
1255912559
createTypeReference(target, typeArguments);
12560-
}
12560+
}
1256112561

1256212562
function createNormalizedTupleType(target: TupleType, elementTypes: readonly Type[]): Type {
1256312563
// Transform [A, ...(X | Y | Z)] into [A, ...X] | [A, ...Y] | [A, ...Z]
@@ -12569,7 +12569,7 @@ namespace ts {
1256912569
const spreadIndex = findIndex(elementTypes, (t, i) => !!(target.elementFlags[i] & ElementFlags.Variadic) && !(t.flags & TypeFlags.InstantiableNonPrimitive) && !isGenericMappedType(t));
1257012570
if (spreadIndex < 0) {
1257112571
return createTypeReference(target, elementTypes);
12572-
}
12572+
}
1257312573
// We have non-generic variadic elements that need normalization.
1257412574
const expandedTypes: Type[] = [];
1257512575
const expandedFlags: ElementFlags[] = [];
@@ -12611,13 +12611,13 @@ namespace ts {
1261112611
if (restTypes) {
1261212612
// A rest element was previously added, so simply collect the type of this element.
1261312613
restTypes.push(flags & ElementFlags.Variadic ? getIndexedAccessType(type, numberType) : type);
12614-
}
12614+
}
1261512615
else {
1261612616
if (flags & ElementFlags.Required && optionalIndex >= 0) {
1261712617
// Turn preceding optional elements into required elements
1261812618
for (let i = optionalIndex; i < expandedFlags.length; i++) {
1261912619
if (expandedFlags[i] & ElementFlags.Optional) expandedFlags[i] = ElementFlags.Required;
12620-
}
12620+
}
1262112621
optionalIndex = -1;
1262212622
}
1262312623
else if (flags & ElementFlags.Optional && optionalIndex < 0) {
@@ -14259,7 +14259,7 @@ namespace ts {
1425914259

1426014260
function getTypeFromRestTypeNode(node: RestTypeNode | NamedTupleMember) {
1426114261
return getTypeFromTypeNode(getArrayElementTypeNode(node.type) || node.type);
14262-
}
14262+
}
1426314263

1426414264
function getArrayElementTypeNode(node: TypeNode): TypeNode | undefined {
1426514265
switch (node.kind) {
@@ -14270,12 +14270,12 @@ namespace ts {
1427014270
node = (node as TupleTypeNode).elements[0];
1427114271
if (node.kind === SyntaxKind.RestType || node.kind === SyntaxKind.NamedTupleMember && (node as NamedTupleMember).dotDotDotToken) {
1427214272
return getArrayElementTypeNode((node as RestTypeNode | NamedTupleMember).type);
14273-
}
14274-
}
14273+
}
14274+
}
1427514275
break;
1427614276
case SyntaxKind.ArrayType:
1427714277
return (node as ArrayTypeNode).elementType;
14278-
}
14278+
}
1427914279
return undefined;
1428014280
}
1428114281

@@ -16500,8 +16500,8 @@ namespace ts {
1650016500
const suggestion = suggestionSymbol ? symbolToString(suggestionSymbol) : undefined;
1650116501
if (suggestion) {
1650216502
reportError(Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_2, propName, typeToString(errorTarget), suggestion);
16503-
}
16504-
else {
16503+
}
16504+
else {
1650516505
reportError(Diagnostics.Property_0_does_not_exist_on_type_1, propName, typeToString(errorTarget));
1650616506
}
1650716507
}
@@ -17456,26 +17456,26 @@ namespace ts {
1745617456
const sourceMinLength = isTupleType(source) ? source.target.minLength : 0;
1745717457
const targetMinLength = target.target.minLength;
1745817458
if (!sourceRestFlag && sourceArity < targetMinLength) {
17459-
if (reportErrors) {
17459+
if (reportErrors) {
1746017460
reportError(Diagnostics.Source_has_0_element_s_but_target_requires_1, sourceArity, targetMinLength);
17461-
}
17462-
return Ternary.False;
17463-
}
17461+
}
17462+
return Ternary.False;
17463+
}
1746417464
if (!targetRestFlag && targetArity < sourceMinLength) {
17465-
if (reportErrors) {
17465+
if (reportErrors) {
1746617466
reportError(Diagnostics.Source_has_0_element_s_but_target_allows_only_1, sourceMinLength, targetArity);
17467-
}
17468-
return Ternary.False;
1746917467
}
17468+
return Ternary.False;
17469+
}
1747017470
if (!targetRestFlag && sourceRestFlag) {
1747117471
if (reportErrors) {
1747217472
if (sourceMinLength < targetMinLength) {
1747317473
reportError(Diagnostics.Target_requires_0_element_s_but_source_may_have_fewer, targetMinLength);
17474-
}
17474+
}
1747517475
else {
1747617476
reportError(Diagnostics.Target_allows_only_0_element_s_but_source_may_have_more, targetArity);
17477-
}
17478-
}
17477+
}
17478+
}
1747917479
return Ternary.False;
1748017480
}
1748117481
const maxArity = Math.max(sourceArity, targetArity);
@@ -17484,12 +17484,12 @@ namespace ts {
1748417484
const sourceFlags = isTupleType(source) && i < sourceArity ? source.target.elementFlags[i] : sourceRestFlag;
1748517485
if (sourceFlags && targetFlags) {
1748617486
if (targetFlags & ElementFlags.Variadic && !(sourceFlags & ElementFlags.Variadic) ||
17487-
(sourceFlags & ElementFlags.Variadic && !(targetFlags & ElementFlags.Variable))) {
17488-
if (reportErrors) {
17487+
(sourceFlags & ElementFlags.Variadic && !(targetFlags & ElementFlags.Variable))) {
17488+
if (reportErrors) {
1748917489
reportError(Diagnostics.Element_at_index_0_is_variadic_in_one_type_but_not_in_the_other, i);
17490-
}
17491-
return Ternary.False;
17492-
}
17490+
}
17491+
return Ternary.False;
17492+
}
1749317493
if (targetFlags & ElementFlags.Required) {
1749417494
if (!(sourceFlags & ElementFlags.Required)) {
1749517495
if (reportErrors) {
@@ -17502,17 +17502,17 @@ namespace ts {
1750217502
const targetType = getTypeArguments(target)[Math.min(i, targetArity - 1)];
1750317503
const targetCheckType = sourceFlags & ElementFlags.Variadic && targetFlags & ElementFlags.Rest ? createArrayType(targetType) : targetType;
1750417504
const related = isRelatedTo(sourceType, targetCheckType, reportErrors, /*headMessage*/ undefined, intersectionState);
17505-
if (!related) {
17506-
if (reportErrors) {
17505+
if (!related) {
17506+
if (reportErrors) {
1750717507
reportIncompatibleError(Diagnostics.Types_of_property_0_are_incompatible, i);
17508+
}
17509+
return Ternary.False;
1750817510
}
17509-
return Ternary.False;
17511+
result &= related;
1751017512
}
17511-
result &= related;
1751217513
}
17513-
}
1751417514
return result;
17515-
}
17515+
}
1751617516
if (target.target.combinedFlags & ElementFlags.Variable) {
1751717517
return Ternary.False;
1751817518
}
@@ -19670,25 +19670,25 @@ namespace ts {
1967019670
if (isTupleType(source) && isTupleTypeStructureMatching(source, target)) {
1967119671
for (let i = 0; i < targetArity; i++) {
1967219672
inferFromTypes(getTypeArguments(source)[i], elementTypes[i]);
19673-
}
19674-
return;
1967519673
}
19674+
return;
19675+
}
1967619676
const startLength = isTupleType(source) ? Math.min(source.target.fixedLength, target.target.fixedLength) : 0;
1967719677
const sourceRestType = !isTupleType(source) || sourceArity > 0 && source.target.elementFlags[sourceArity - 1] & ElementFlags.Rest ?
1967819678
getTypeArguments(source)[sourceArity - 1] : undefined;
1967919679
const endLength = !(target.target.combinedFlags & ElementFlags.Variable) ? 0 :
1968019680
sourceRestType ? getEndLengthOfType(target) :
19681-
Math.min(getEndLengthOfType(source), getEndLengthOfType(target));
19681+
Math.min(getEndLengthOfType(source), getEndLengthOfType(target));
1968219682
const sourceEndLength = sourceRestType ? 0 : endLength;
1968319683
// Infer between starting fixed elements.
1968419684
for (let i = 0; i < startLength; i++) {
1968519685
inferFromTypes(getTypeArguments(source)[i], elementTypes[i]);
19686-
}
19686+
}
1968719687
if (sourceRestType && sourceArity - startLength === 1) {
1968819688
// Single rest element remains in source, infer from that to every element in target
1968919689
for (let i = startLength; i < targetArity - endLength; i++) {
1969019690
inferFromTypes(elementFlags[i] & ElementFlags.Variadic ? createArrayType(sourceRestType) : sourceRestType, elementTypes[i]);
19691-
}
19691+
}
1969219692
}
1969319693
else {
1969419694
const middleLength = targetArity - startLength - endLength;
@@ -24072,7 +24072,7 @@ namespace ts {
2407224072
if (isArrayLikeType(spreadType)) {
2407324073
elementTypes.push(spreadType);
2407424074
elementFlags.push(ElementFlags.Variadic);
24075-
}
24075+
}
2407624076
else if (inDestructuringPattern) {
2407724077
// Given the following situation:
2407824078
// var c: {};
@@ -24089,24 +24089,24 @@ namespace ts {
2408924089
const restElementType = getIndexTypeOfType(spreadType, IndexKind.Number) ||
2409024090
getIteratedTypeOrElementType(IterationUse.Destructuring, spreadType, undefinedType, /*errorNode*/ undefined, /*checkAssignability*/ false) ||
2409124091
unknownType;
24092-
elementTypes.push(restElementType);
24092+
elementTypes.push(restElementType);
2409324093
elementFlags.push(ElementFlags.Rest);
24094-
}
24094+
}
2409524095
else {
2409624096
elementTypes.push(checkIteratedTypeOrElementType(IterationUse.Spread, spreadType, undefinedType, (<SpreadElement>e).expression));
2409724097
elementFlags.push(ElementFlags.Rest);
2409824098
}
2409924099
}
24100-
else {
24101-
const elementContextualType = getContextualTypeForElementExpression(contextualType, elementTypes.length);
24102-
const type = checkExpressionForMutableLocation(e, checkMode, elementContextualType, forceTuple);
24103-
elementTypes.push(type);
24100+
else {
24101+
const elementContextualType = getContextualTypeForElementExpression(contextualType, elementTypes.length);
24102+
const type = checkExpressionForMutableLocation(e, checkMode, elementContextualType, forceTuple);
24103+
elementTypes.push(type);
2410424104
elementFlags.push(ElementFlags.Required);
24105-
}
24106-
}
24105+
}
24106+
}
2410724107
if (inDestructuringPattern) {
2410824108
return createTupleType(elementTypes, elementFlags);
24109-
}
24109+
}
2411024110
if (forceTuple || inConstContext || contextualType && forEachType(contextualType, isTupleLikeType)) {
2411124111
return createArrayLiteralType(createTupleType(elementTypes, elementFlags, /*readonly*/ inConstContext));
2411224112
}
@@ -26013,8 +26013,8 @@ namespace ts {
2601326013
const spreadArgIndex = getSpreadArgumentIndex(args);
2601426014
if (spreadArgIndex >= 0) {
2601526015
return spreadArgIndex >= getMinArgumentCount(signature) && (hasEffectiveRestParameter(signature) || spreadArgIndex < getParameterCount(signature));
26016-
}
26017-
}
26016+
}
26017+
}
2601826018

2601926019
// Too many arguments implies incorrect arity.
2602026020
if (!hasEffectiveRestParameter(signature) && argCount > effectiveParameterCount) {
@@ -26199,22 +26199,22 @@ namespace ts {
2619926199
if (isArrayLikeType(spreadType)) {
2620026200
types.push(spreadType);
2620126201
flags.push(ElementFlags.Variadic);
26202-
}
26202+
}
2620326203
else {
2620426204
types.push(checkIteratedTypeOrElementType(IterationUse.Spread, spreadType, undefinedType, arg.kind === SyntaxKind.SpreadElement ? (<SpreadElement>arg).expression : arg));
2620526205
flags.push(ElementFlags.Rest);
26206-
}
26206+
}
2620726207
}
2620826208
else {
2620926209
const contextualType = getIndexedAccessType(restType, getLiteralType(i - index));
2621026210
const argType = checkExpressionWithContextualType(arg, contextualType, context, checkMode);
26211-
const hasPrimitiveContextualType = maybeTypeOfKind(contextualType, TypeFlags.Primitive | TypeFlags.Index);
26212-
types.push(hasPrimitiveContextualType ? getRegularTypeOfLiteralType(argType) : getWidenedLiteralType(argType));
26211+
const hasPrimitiveContextualType = maybeTypeOfKind(contextualType, TypeFlags.Primitive | TypeFlags.Index);
26212+
types.push(hasPrimitiveContextualType ? getRegularTypeOfLiteralType(argType) : getWidenedLiteralType(argType));
2621326213
flags.push(ElementFlags.Required);
26214-
}
26214+
}
2621526215
if (arg.kind === SyntaxKind.SyntheticExpression && (arg as SyntheticExpression).tupleNameSource) {
2621626216
names.push((arg as SyntheticExpression).tupleNameSource!);
26217-
}
26217+
}
2621826218
}
2621926219
return createTupleType(types, flags, /*readonly*/ false, length(names) === length(types) ? names : undefined);
2622026220
}
@@ -26510,10 +26510,10 @@ namespace ts {
2651026510
!!(flags & ElementFlags.Variable), spreadType.target.labeledElementDeclarations?.[i]);
2651126511
effectiveArgs.push(syntheticArg);
2651226512
});
26513-
}
26513+
}
2651426514
else {
2651526515
effectiveArgs.push(arg);
26516-
}
26516+
}
2651726517
}
2651826518
return effectiveArgs;
2651926519
}
@@ -28138,7 +28138,7 @@ namespace ts {
2813828138
const names = [];
2813928139
for (let i = pos; i < parameterCount; i++) {
2814028140
if (!restType || i < parameterCount - 1) {
28141-
types.push(getTypeAtPosition(source, i));
28141+
types.push(getTypeAtPosition(source, i));
2814228142
flags.push(i < minArgumentCount ? ElementFlags.Required : ElementFlags.Optional);
2814328143
}
2814428144
else {
@@ -28149,9 +28149,9 @@ namespace ts {
2814928149
if (name) {
2815028150
names.push(name);
2815128151
}
28152-
}
28153-
return createTupleType(types, flags, /*readonly*/ false, length(names) === length(types) ? names : undefined);
2815428152
}
28153+
return createTupleType(types, flags, /*readonly*/ false, length(names) === length(types) ? names : undefined);
28154+
}
2815528155

2815628156
function getParameterCount(signature: Signature) {
2815728157
const length = signature.parameters.length;
@@ -28194,7 +28194,7 @@ namespace ts {
2819428194
const restType = getTypeOfSymbol(signature.parameters[signature.parameters.length - 1]);
2819528195
if (!isTupleType(restType)) {
2819628196
return restType;
28197-
}
28197+
}
2819828198
if (restType.target.hasRestElement) {
2819928199
return sliceTupleType(restType, restType.target.fixedLength);
2820028200
}
@@ -31286,7 +31286,7 @@ namespace ts {
3128631286
grammarErrorOnNode(e, Diagnostics.A_rest_element_must_be_last_in_a_tuple_type);
3128731287
break;
3128831288
}
31289-
}
31289+
}
3129031290
else if (flags & ElementFlags.Optional) {
3129131291
seenOptionalElement = true;
3129231292
}

0 commit comments

Comments
 (0)