@typescript-deploys/pr-build 5.4.0-pr-56281-22 → 5.4.0-pr-56356-2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/lib/lib.es5.d.ts CHANGED
@@ -1275,12 +1275,6 @@ interface ReadonlyArray<T> {
1275
1275
  * @param thisArg An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value.
1276
1276
  */
1277
1277
  filter<S extends T>(predicate: (value: T, index: number, array: readonly T[]) => value is S, thisArg?: any): S[];
1278
- /**
1279
- * Returns the non-Falsy elements of an array
1280
- * @param predicate Must be exactly "Boolean"
1281
- * @param thisArg An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value.
1282
- */
1283
- filter(predicate: BooleanConstructor, thisArg?: any): (T extends false | 0 | "" | null | undefined | 0n ? never : T)[];
1284
1278
  /**
1285
1279
  * Returns the elements of an array that meet the condition specified in a callback function.
1286
1280
  * @param predicate A function that accepts up to three arguments. The filter method calls the predicate function one time for each element in the array.
@@ -1472,12 +1466,6 @@ interface Array<T> {
1472
1466
  * @param thisArg An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value.
1473
1467
  */
1474
1468
  filter<S extends T>(predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): S[];
1475
- /**
1476
- * Returns the non-Falsy elements of an array
1477
- * @param predicate Must be exactly "Boolean"
1478
- * @param thisArg An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value.
1479
- */
1480
- filter(predicate: BooleanConstructor, thisArg?: any): (T extends false | 0 | "" | null | undefined | 0n ? never : T)[];
1481
1469
  /**
1482
1470
  * Returns the elements of an array that meet the condition specified in a callback function.
1483
1471
  * @param predicate A function that accepts up to three arguments. The filter method calls the predicate function one time for each element in the array.
package/lib/tsc.js CHANGED
@@ -18,7 +18,7 @@ and limitations under the License.
18
18
 
19
19
  // src/compiler/corePublic.ts
20
20
  var versionMajorMinor = "5.4";
21
- var version = `${versionMajorMinor}.0-insiders.20231104`;
21
+ var version = `${versionMajorMinor}.0-insiders.20231109`;
22
22
 
23
23
  // src/compiler/core.ts
24
24
  var emptyArray = [];
@@ -47697,7 +47697,7 @@ function createTypeChecker(host) {
47697
47697
  return symbol && !!symbol.valueDeclaration && isExpression(symbol.valueDeclaration) && !isContextSensitive(symbol.valueDeclaration);
47698
47698
  }
47699
47699
  function toNodeBuilderFlags(flags = 0 /* None */) {
47700
- return flags & 848330091 /* NodeBuilderFlagsMask */;
47700
+ return flags & 848330095 /* NodeBuilderFlagsMask */;
47701
47701
  }
47702
47702
  function isClassInstanceSide(type) {
47703
47703
  return !!type.symbol && !!(type.symbol.flags & 32 /* Class */) && (type === getDeclaredTypeOfClassOrInterface(type.symbol) || !!(type.flags & 524288 /* Object */) && !!(getObjectFlags(type) & 16777216 /* IsClassInstanceClone */));
@@ -47946,7 +47946,7 @@ function createTypeChecker(host) {
47946
47946
  }
47947
47947
  return factory.createInferTypeNode(typeParameterToDeclarationWithConstraint(type, context, constraintNode));
47948
47948
  }
47949
- if (context.flags & 4 /* GenerateNamesForShadowedTypeParams */ && type.flags & 262144 /* TypeParameter */ && !isTypeSymbolAccessible(type.symbol, context.enclosingDeclaration)) {
47949
+ if (context.flags & 4 /* GenerateNamesForShadowedTypeParams */ && type.flags & 262144 /* TypeParameter */) {
47950
47950
  const name2 = typeParameterToName(type, context);
47951
47951
  context.approximateLength += idText(name2).length;
47952
47952
  return factory.createTypeReferenceNode(
@@ -48157,6 +48157,21 @@ function createTypeChecker(host) {
48157
48157
  const typeId = type2.id;
48158
48158
  const symbol = type2.symbol;
48159
48159
  if (symbol) {
48160
+ const isInstantiationExpressionType = !!(getObjectFlags(type2) & 8388608 /* InstantiationExpressionType */);
48161
+ if (isInstantiationExpressionType) {
48162
+ const instantiationExpressionType = type2;
48163
+ const existing = instantiationExpressionType.node;
48164
+ if (isTypeQueryNode(existing) && getTypeFromTypeNode(existing) === type2) {
48165
+ const typeNode = serializeExistingTypeNode(context, existing);
48166
+ if (typeNode) {
48167
+ return typeNode;
48168
+ }
48169
+ }
48170
+ if ((_a2 = context.visitedTypes) == null ? void 0 : _a2.has(typeId)) {
48171
+ return createElidedInformationPlaceholder(context);
48172
+ }
48173
+ return visitAndTransformType(type2, createTypeNodeFromObjectType);
48174
+ }
48160
48175
  const isInstanceType = isClassInstanceSide(type2) ? 788968 /* Type */ : 111551 /* Value */;
48161
48176
  if (isJSConstructor(symbol.valueDeclaration)) {
48162
48177
  return symbolToTypeNode(symbol, context, isInstanceType);
@@ -48168,7 +48183,7 @@ function createTypeChecker(host) {
48168
48183
  false
48169
48184
  ).accessibility !== 0 /* Accessible */)) || symbol.flags & (384 /* Enum */ | 512 /* ValueModule */) || shouldWriteTypeOfFunctionSymbol()) {
48170
48185
  return symbolToTypeNode(symbol, context, isInstanceType);
48171
- } else if ((_a2 = context.visitedTypes) == null ? void 0 : _a2.has(typeId)) {
48186
+ } else if ((_b2 = context.visitedTypes) == null ? void 0 : _b2.has(typeId)) {
48172
48187
  const typeAlias = getTypeAliasForTypeLiteral(type2);
48173
48188
  if (typeAlias) {
48174
48189
  return symbolToTypeNode(typeAlias, context, 788968 /* Type */);
@@ -48179,20 +48194,6 @@ function createTypeChecker(host) {
48179
48194
  return visitAndTransformType(type2, createTypeNodeFromObjectType);
48180
48195
  }
48181
48196
  } else {
48182
- const isInstantiationExpressionType = !!(getObjectFlags(type2) & 8388608 /* InstantiationExpressionType */);
48183
- if (isInstantiationExpressionType) {
48184
- const instantiationExpressionType = type2;
48185
- if (isTypeQueryNode(instantiationExpressionType.node)) {
48186
- const typeNode = serializeExistingTypeNode(context, instantiationExpressionType.node);
48187
- if (typeNode) {
48188
- return typeNode;
48189
- }
48190
- }
48191
- if ((_b2 = context.visitedTypes) == null ? void 0 : _b2.has(typeId)) {
48192
- return createElidedInformationPlaceholder(context);
48193
- }
48194
- return visitAndTransformType(type2, createTypeNodeFromObjectType);
48195
- }
48196
48197
  return createTypeNodeFromObjectType(type2);
48197
48198
  }
48198
48199
  function shouldWriteTypeOfFunctionSymbol() {
@@ -48746,36 +48747,65 @@ function createTypeChecker(host) {
48746
48747
  true
48747
48748
  )[0];
48748
48749
  let cleanup;
48749
- if (context.enclosingDeclaration && signature.declaration && signature.declaration !== context.enclosingDeclaration && !isInJSFile(signature.declaration) && some(expandedParams)) {
48750
- const existingFakeScope = getNodeLinks(context.enclosingDeclaration).fakeScopeForSignatureDeclaration ? context.enclosingDeclaration : void 0;
48751
- Debug.assertOptionalNode(existingFakeScope, isBlock);
48752
- const locals = (existingFakeScope == null ? void 0 : existingFakeScope.locals) ?? createSymbolTable();
48753
- let newLocals;
48754
- for (const param of expandedParams) {
48755
- if (!locals.has(param.escapedName)) {
48756
- newLocals = append(newLocals, param.escapedName);
48757
- locals.set(param.escapedName, param);
48758
- }
48759
- }
48760
- if (newLocals) {
48761
- let removeNewLocals2 = function() {
48750
+ if (context.enclosingDeclaration && signature.declaration && signature.declaration !== context.enclosingDeclaration && !isInJSFile(signature.declaration) && (some(expandedParams) || some(signature.typeParameters))) {
48751
+ let pushFakeScope2 = function(kind2, addAll) {
48752
+ Debug.assert(context.enclosingDeclaration);
48753
+ let existingFakeScope;
48754
+ if (getNodeLinks(context.enclosingDeclaration).fakeScopeForSignatureDeclaration === kind2) {
48755
+ existingFakeScope = context.enclosingDeclaration;
48756
+ } else if (context.enclosingDeclaration.parent && getNodeLinks(context.enclosingDeclaration.parent).fakeScopeForSignatureDeclaration === kind2) {
48757
+ existingFakeScope = context.enclosingDeclaration.parent;
48758
+ }
48759
+ Debug.assertOptionalNode(existingFakeScope, isBlock);
48760
+ const locals = (existingFakeScope == null ? void 0 : existingFakeScope.locals) ?? createSymbolTable();
48761
+ let newLocals;
48762
+ addAll((name, symbol) => {
48763
+ if (!locals.has(name)) {
48764
+ newLocals = append(newLocals, name);
48765
+ locals.set(name, symbol);
48766
+ }
48767
+ });
48768
+ if (!newLocals)
48769
+ return;
48770
+ const oldCleanup = cleanup;
48771
+ function undo() {
48762
48772
  forEach(newLocals, (s) => locals.delete(s));
48763
- };
48764
- var removeNewLocals = removeNewLocals2;
48773
+ oldCleanup == null ? void 0 : oldCleanup();
48774
+ }
48765
48775
  if (existingFakeScope) {
48766
- cleanup = removeNewLocals2;
48776
+ cleanup = undo;
48767
48777
  } else {
48768
48778
  const fakeScope = parseNodeFactory.createBlock(emptyArray);
48769
- getNodeLinks(fakeScope).fakeScopeForSignatureDeclaration = true;
48779
+ getNodeLinks(fakeScope).fakeScopeForSignatureDeclaration = kind2;
48770
48780
  fakeScope.locals = locals;
48771
48781
  const saveEnclosingDeclaration = context.enclosingDeclaration;
48772
48782
  setParent(fakeScope, saveEnclosingDeclaration);
48773
48783
  context.enclosingDeclaration = fakeScope;
48774
48784
  cleanup = () => {
48775
48785
  context.enclosingDeclaration = saveEnclosingDeclaration;
48776
- removeNewLocals2();
48786
+ undo();
48777
48787
  };
48778
48788
  }
48789
+ };
48790
+ var pushFakeScope = pushFakeScope2;
48791
+ pushFakeScope2(
48792
+ "params",
48793
+ (add) => {
48794
+ for (const param of expandedParams) {
48795
+ add(param.escapedName, param);
48796
+ }
48797
+ }
48798
+ );
48799
+ if (context.flags & 4 /* GenerateNamesForShadowedTypeParams */) {
48800
+ pushFakeScope2(
48801
+ "typeParams",
48802
+ (add) => {
48803
+ for (const typeParam of signature.typeParameters ?? emptyArray) {
48804
+ const typeParamName = typeParameterToName(typeParam, context).escapedText;
48805
+ add(typeParamName, typeParam.symbol);
48806
+ }
48807
+ }
48808
+ );
48779
48809
  }
48780
48810
  }
48781
48811
  const parameters = (some(expandedParams, (p) => p !== expandedParams[expandedParams.length - 1] && !!(getCheckFlags(p) & 32768 /* RestParameter */)) ? signature.parameters : expandedParams).map((parameter) => symbolToParameterDeclaration(parameter, context, kind === 176 /* Constructor */, options == null ? void 0 : options.privateSymbolVisitor, options == null ? void 0 : options.bundledImports));
@@ -49320,7 +49350,7 @@ function createTypeChecker(host) {
49320
49350
  return identifier;
49321
49351
  }
49322
49352
  }
49323
- function typeParameterShadowsNameInScope(escapedName, context, type) {
49353
+ function typeParameterShadowsOtherTypeParameterInScope(escapedName, context, type) {
49324
49354
  const result = resolveName(
49325
49355
  context.enclosingDeclaration,
49326
49356
  escapedName,
@@ -49331,11 +49361,8 @@ function createTypeChecker(host) {
49331
49361
  /*isUse*/
49332
49362
  false
49333
49363
  );
49334
- if (result) {
49335
- if (result.flags & 262144 /* TypeParameter */ && result === type.symbol) {
49336
- return false;
49337
- }
49338
- return true;
49364
+ if (result && result.flags & 262144 /* TypeParameter */) {
49365
+ return result !== type.symbol;
49339
49366
  }
49340
49367
  return false;
49341
49368
  }
@@ -49361,7 +49388,7 @@ function createTypeChecker(host) {
49361
49388
  const rawtext = result.escapedText;
49362
49389
  let i = ((_a = context.typeParameterNamesByTextNextNameCount) == null ? void 0 : _a.get(rawtext)) || 0;
49363
49390
  let text = rawtext;
49364
- while (((_b = context.typeParameterNamesByText) == null ? void 0 : _b.has(text)) || typeParameterShadowsNameInScope(text, context, type)) {
49391
+ while (((_b = context.typeParameterNamesByText) == null ? void 0 : _b.has(text)) || typeParameterShadowsOtherTypeParameterInScope(text, context, type)) {
49365
49392
  i++;
49366
49393
  text = `${rawtext}_${i}`;
49367
49394
  }
@@ -49372,7 +49399,7 @@ function createTypeChecker(host) {
49372
49399
  }
49373
49400
  (context.typeParameterNamesByTextNextNameCount || (context.typeParameterNamesByTextNextNameCount = /* @__PURE__ */ new Map())).set(rawtext, i);
49374
49401
  (context.typeParameterNames || (context.typeParameterNames = /* @__PURE__ */ new Map())).set(getTypeId(type), result);
49375
- (context.typeParameterNamesByText || (context.typeParameterNamesByText = /* @__PURE__ */ new Set())).add(rawtext);
49402
+ (context.typeParameterNamesByText || (context.typeParameterNamesByText = /* @__PURE__ */ new Set())).add(text);
49376
49403
  }
49377
49404
  return result;
49378
49405
  }
@@ -49517,7 +49544,10 @@ function createTypeChecker(host) {
49517
49544
  return !(getObjectFlags(type) & 4 /* Reference */) || !isTypeReferenceNode(existing) || length(existing.typeArguments) >= getMinTypeArgumentCount(type.target.typeParameters);
49518
49545
  }
49519
49546
  function getEnclosingDeclarationIgnoringFakeScope(enclosingDeclaration) {
49520
- return getNodeLinks(enclosingDeclaration).fakeScopeForSignatureDeclaration ? enclosingDeclaration.parent : enclosingDeclaration;
49547
+ while (getNodeLinks(enclosingDeclaration).fakeScopeForSignatureDeclaration) {
49548
+ enclosingDeclaration = enclosingDeclaration.parent;
49549
+ }
49550
+ return enclosingDeclaration;
49521
49551
  }
49522
49552
  function serializeTypeForDeclaration(context, type, symbol, enclosingDeclaration, includePrivateSymbol, bundled) {
49523
49553
  if (!isErrorType(type) && enclosingDeclaration) {
@@ -49597,7 +49627,7 @@ function createTypeChecker(host) {
49597
49627
  }
49598
49628
  if (isIdentifier(node)) {
49599
49629
  const type = getDeclaredTypeOfSymbol(sym);
49600
- const name = sym.flags & 262144 /* TypeParameter */ && !isTypeSymbolAccessible(type.symbol, context.enclosingDeclaration) ? typeParameterToName(type, context) : factory.cloneNode(node);
49630
+ const name = sym.flags & 262144 /* TypeParameter */ ? typeParameterToName(type, context) : factory.cloneNode(node);
49601
49631
  name.symbol = sym;
49602
49632
  return { introducesError, node: setEmitFlags(setOriginalNode(name, node), 16777216 /* NoAsciiEscaping */) };
49603
49633
  }
@@ -55010,69 +55040,22 @@ function createTypeChecker(host) {
55010
55040
  }
55011
55041
  return emptyArray;
55012
55042
  }
55013
- function getSignaturesOfType(typeIn, kind) {
55014
- const reducedType = getReducedApparentType(typeIn);
55015
- function carveoutResult() {
55016
- var _a;
55017
- if (kind === 0 /* Call */ && reducedType.flags & 1048576 /* Union */) {
55018
- let memberName;
55019
- if (everyType(reducedType, (t) => {
55020
- var _a2;
55021
- return !!((_a2 = t.symbol) == null ? void 0 : _a2.parent) && isArrayOrTupleSymbol(t.symbol.parent) && (!memberName ? (memberName = t.symbol.escapedName, true) : memberName === t.symbol.escapedName);
55022
- })) {
55023
- if (reducedType.arrayFallbackSignatures) {
55024
- return reducedType.arrayFallbackSignatures;
55025
- }
55026
- const numTypes = reducedType.types.length;
55027
- const numSigs = (_a = reducedType.types[0].symbol.declarations) == null ? void 0 : _a.length;
55028
- Debug.assert(numSigs);
55029
- const returnTypes = new Array(numSigs).fill(
55030
- /*value*/
55031
- void 0
55032
- ).map((_, isig) => {
55033
- const rtset = /* @__PURE__ */ new Set();
55034
- new Array(numTypes).fill(
55035
- /*value*/
55036
- void 0
55037
- ).forEach((_2, itype) => {
55038
- const callSignatures = reducedType.types[itype].callSignatures ?? getSignaturesOfStructuredType(reducedType.types[itype], 0 /* Call */);
55039
- if (callSignatures[isig].typeParameters)
55040
- return;
55041
- const returnType = callSignatures[isig].resolvedReturnType ?? getReturnTypeOfSignature(callSignatures[isig]);
55042
- Debug.assert(returnType);
55043
- rtset.add(returnType);
55044
- });
55045
- const art = [];
55046
- rtset.forEach((rt) => art.push(rt));
55047
- if (art.length === 0)
55048
- return void 0;
55049
- if (art.length === 1)
55050
- return art[0];
55051
- return getUnionType(art, 2 /* Subtype */);
55052
- });
55053
- const arrayArg = mapType(reducedType, (t) => getMappedType((isReadonlyArraySymbol(t.symbol.parent) ? globalReadonlyArrayType : globalArrayType).typeParameters[0], t.mapper));
55054
- const arrayType = createArrayType(arrayArg, someType(reducedType, (t) => isReadonlyArraySymbol(t.symbol.parent)));
55055
- const result2 = getSignaturesOfType(getTypeOfPropertyOfType(arrayType, memberName), kind);
55056
- returnTypes.forEach((returnType, sigidx) => {
55057
- if (returnType)
55058
- result2[sigidx].resolvedReturnType = returnTypes[sigidx];
55059
- });
55060
- return reducedType.arrayFallbackSignatures = result2;
55061
- }
55043
+ function getSignaturesOfType(type, kind) {
55044
+ const result = getSignaturesOfStructuredType(getReducedApparentType(type), kind);
55045
+ if (kind === 0 /* Call */ && !length(result) && type.flags & 1048576 /* Union */) {
55046
+ if (type.arrayFallbackSignatures) {
55047
+ return type.arrayFallbackSignatures;
55062
55048
  }
55063
- return void 0;
55064
- }
55065
- let result = carveoutResult();
55066
- if (result)
55067
- return result;
55068
- if (kind === 0 /* Call */ && reducedType.flags & 1048576 /* Union */) {
55069
- if (reducedType.arrayFallbackSignatures) {
55070
- return reducedType.arrayFallbackSignatures;
55049
+ let memberName;
55050
+ if (everyType(type, (t) => {
55051
+ var _a;
55052
+ return !!((_a = t.symbol) == null ? void 0 : _a.parent) && isArrayOrTupleSymbol(t.symbol.parent) && (!memberName ? (memberName = t.symbol.escapedName, true) : memberName === t.symbol.escapedName);
55053
+ })) {
55054
+ const arrayArg = mapType(type, (t) => getMappedType((isReadonlyArraySymbol(t.symbol.parent) ? globalReadonlyArrayType : globalArrayType).typeParameters[0], t.mapper));
55055
+ const arrayType = createArrayType(arrayArg, someType(type, (t) => isReadonlyArraySymbol(t.symbol.parent)));
55056
+ return type.arrayFallbackSignatures = getSignaturesOfType(getTypeOfPropertyOfType(arrayType, memberName), kind);
55071
55057
  }
55072
- }
55073
- result = getSignaturesOfStructuredType(reducedType, kind);
55074
- if (kind === 0 /* Call */ && reducedType.flags & 1048576 /* Union */) {
55075
- reducedType.arrayFallbackSignatures = result;
55058
+ type.arrayFallbackSignatures = result;
55076
55059
  }
55077
55060
  return result;
55078
55061
  }
@@ -59118,6 +59101,7 @@ function createTypeChecker(host) {
59118
59101
  ) : strictNullChecks && modifiers & 8 /* ExcludeOptional */ && isOptional ? getTypeWithFacts(propType, 524288 /* NEUndefined */) : propType;
59119
59102
  }
59120
59103
  function instantiateAnonymousType(type, mapper, aliasSymbol, aliasTypeArguments) {
59104
+ Debug.assert(type.symbol, "anonymous type must have symbol to be instantiated");
59121
59105
  const result = createObjectType(type.objectFlags & ~(524288 /* CouldContainTypeVariablesComputed */ | 1048576 /* CouldContainTypeVariables */) | 64 /* Instantiated */, type.symbol);
59122
59106
  if (type.objectFlags & 32 /* Mapped */) {
59123
59107
  result.declaration = type.declaration;
@@ -62365,6 +62349,7 @@ function createTypeChecker(host) {
62365
62349
  const sourceObjectFlags = getObjectFlags(source2);
62366
62350
  const targetObjectFlags = getObjectFlags(target2);
62367
62351
  if (sourceObjectFlags & 64 /* Instantiated */ && targetObjectFlags & 64 /* Instantiated */ && source2.symbol === target2.symbol || sourceObjectFlags & 4 /* Reference */ && targetObjectFlags & 4 /* Reference */ && source2.target === target2.target) {
62352
+ Debug.assertEqual(sourceSignatures.length, targetSignatures.length);
62368
62353
  for (let i = 0; i < targetSignatures.length; i++) {
62369
62354
  const related = signatureRelatedTo(
62370
62355
  sourceSignatures[i],
@@ -65658,6 +65643,10 @@ function createTypeChecker(host) {
65658
65643
  case 211 /* PropertyAccessExpression */:
65659
65644
  case 212 /* ElementAccessExpression */:
65660
65645
  return isConstantReference(node.expression) && isReadonlySymbol(getNodeLinks(node).resolvedSymbol || unknownSymbol);
65646
+ case 206 /* ObjectBindingPattern */:
65647
+ case 207 /* ArrayBindingPattern */:
65648
+ const rootDeclaration = getRootDeclaration(node.parent);
65649
+ return isVariableDeclaration(rootDeclaration) && isVarConstLike(rootDeclaration);
65661
65650
  }
65662
65651
  return false;
65663
65652
  }
@@ -66575,6 +66564,9 @@ function createTypeChecker(host) {
66575
66564
  }
66576
66565
  function getNarrowedTypeWorker(type, candidate, assumeTrue, checkDerived) {
66577
66566
  if (!assumeTrue) {
66567
+ if (type === candidate) {
66568
+ return neverType;
66569
+ }
66578
66570
  if (checkDerived) {
66579
66571
  return filterType(type, (t) => !isTypeDerivedFrom(t, candidate));
66580
66572
  }
@@ -66591,6 +66583,9 @@ function createTypeChecker(host) {
66591
66583
  if (type.flags & 3 /* AnyOrUnknown */) {
66592
66584
  return candidate;
66593
66585
  }
66586
+ if (type === candidate) {
66587
+ return candidate;
66588
+ }
66594
66589
  const isRelated = checkDerived ? isTypeDerivedFrom : isTypeSubtypeOf;
66595
66590
  const keyPropertyName = type.flags & 1048576 /* Union */ ? getKeyPropertyName(type) : void 0;
66596
66591
  const narrowedType = mapType(candidate, (c) => {
@@ -72616,14 +72611,7 @@ function createTypeChecker(host) {
72616
72611
  hasSignatures || (hasSignatures = resolved.callSignatures.length !== 0 || resolved.constructSignatures.length !== 0);
72617
72612
  hasApplicableSignature || (hasApplicableSignature = callSignatures.length !== 0 || constructSignatures.length !== 0);
72618
72613
  if (callSignatures !== resolved.callSignatures || constructSignatures !== resolved.constructSignatures) {
72619
- const result3 = createAnonymousType(
72620
- /*symbol*/
72621
- void 0,
72622
- resolved.members,
72623
- callSignatures,
72624
- constructSignatures,
72625
- resolved.indexInfos
72626
- );
72614
+ const result3 = createAnonymousType(createSymbol(0 /* None */, "__instantiationExpression" /* InstantiationExpression */), resolved.members, callSignatures, constructSignatures, resolved.indexInfos);
72627
72615
  result3.objectFlags |= 8388608 /* InstantiationExpressionType */;
72628
72616
  result3.node = node;
72629
72617
  return result3;