@typescript-deploys/pr-build 5.0.0-pr-52818-5 → 5.0.0-pr-52836-9

package/lib/tsc.js

@@ -23,7 +23,7 @@ var __export = (target, all) => {
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.0";
-var version = `${versionMajorMinor}.0-insiders.20230217`;
+var version = `${versionMajorMinor}.0-insiders.20230218`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -8467,18 +8467,18 @@ function isIdentifierText(name, languageVersion, identifierVariant) {
   return true;
 }
 function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Standard */, textInitial, onError, start, length2) {
-  let text = textInitial;
-  let pos;
-  let end;
-  let startPos;
-  let tokenPos;
-  let token;
-  let tokenValue;
-  let tokenFlags;
-  let commentDirectives;
-  let inJSDocType = 0;
+  var text = textInitial;
+  var pos;
+  var end;
+  var startPos;
+  var tokenPos;
+  var token;
+  var tokenValue;
+  var tokenFlags;
+  var commentDirectives;
+  var inJSDocType = 0;
   setText(text, start, length2);
-  const scanner = {
+  var scanner = {
     getStartPos: () => startPos,
     getTextPos: () => pos,
     getToken: () => token,
@@ -26008,22 +26008,22 @@ function isExternalModule(file) {
 }
 var Parser;
 ((Parser2) => {
-  const scanner = createScanner(
+  var scanner = createScanner(
     99 /* Latest */,
     /*skipTrivia*/
     true
   );
-  const disallowInAndDecoratorContext = 4096 /* DisallowInContext */ | 16384 /* DecoratorContext */;
-  let NodeConstructor2;
-  let TokenConstructor2;
-  let IdentifierConstructor2;
-  let PrivateIdentifierConstructor2;
-  let SourceFileConstructor2;
+  var disallowInAndDecoratorContext = 4096 /* DisallowInContext */ | 16384 /* DecoratorContext */;
+  var NodeConstructor2;
+  var TokenConstructor2;
+  var IdentifierConstructor2;
+  var PrivateIdentifierConstructor2;
+  var SourceFileConstructor2;
   function countNode(node) {
     nodeCount++;
     return node;
   }
-  const baseNodeFactory = {
+  var baseNodeFactory = {
     createBaseSourceFileNode: (kind) => countNode(new SourceFileConstructor2(
       kind,
       /*pos*/
@@ -26060,25 +26060,25 @@ var Parser;
       0
     ))
   };
-  const factory2 = createNodeFactory(1 /* NoParenthesizerRules */ | 2 /* NoNodeConverters */ | 8 /* NoOriginalNode */, baseNodeFactory);
-  let fileName;
-  let sourceFlags;
-  let sourceText;
-  let languageVersion;
-  let scriptKind;
-  let languageVariant;
-  let parseDiagnostics;
-  let jsDocDiagnostics;
-  let syntaxCursor;
-  let currentToken;
-  let nodeCount;
-  let identifiers;
-  let identifierCount;
-  let parsingContext;
-  let notParenthesizedArrow;
-  let contextFlags;
-  let topLevel = true;
-  let parseErrorBeforeNextFinishedNode = false;
+  var factory2 = createNodeFactory(1 /* NoParenthesizerRules */ | 2 /* NoNodeConverters */ | 8 /* NoOriginalNode */, baseNodeFactory);
+  var fileName;
+  var sourceFlags;
+  var sourceText;
+  var languageVersion;
+  var scriptKind;
+  var languageVariant;
+  var parseDiagnostics;
+  var jsDocDiagnostics;
+  var syntaxCursor;
+  var currentToken;
+  var nodeCount;
+  var identifiers;
+  var identifierCount;
+  var parsingContext;
+  var notParenthesizedArrow;
+  var contextFlags;
+  var topLevel = true;
+  var parseErrorBeforeNextFinishedNode = false;
   function parseSourceFile(fileName2, sourceText2, languageVersion2, syntaxCursor2, setParentNodes = false, scriptKind2, setExternalModuleIndicatorOverride) {
     var _a2;
     scriptKind2 = ensureScriptKind(fileName2, scriptKind2);
@@ -47288,7 +47288,7 @@ function createTypeChecker(host) {
         return result;
       }
       function createAnonymousTypeNode(type2) {
-        var _a3;
+        var _a3, _b2;
         const typeId = type2.id;
         const symbol = type2.symbol;
         if (symbol) {
@@ -47314,6 +47314,20 @@ function createTypeChecker(host) {
             return visitAndTransformType(type2, createTypeNodeFromObjectType);
           }
         } else {
+          const isInstantiationExpressionType = !!(getObjectFlags(type2) & 8388608 /* InstantiationExpressionType */);
+          if (isInstantiationExpressionType) {
+            const instantiationExpressionType = type2;
+            if (isTypeQueryNode(instantiationExpressionType.node)) {
+              const typeNode = serializeExistingTypeNode(context, instantiationExpressionType.node);
+              if (typeNode) {
+                return typeNode;
+              }
+            }
+            if ((_b2 = context.visitedTypes) == null ? void 0 : _b2.has(typeId)) {
+              return createElidedInformationPlaceholder(context);
+            }
+            return visitAndTransformType(type2, createTypeNodeFromObjectType);
+          }
           return createTypeNodeFromObjectType(type2);
         }
         function shouldWriteTypeOfFunctionSymbol() {
@@ -47822,7 +47836,7 @@ function createTypeChecker(host) {
       );
     }
     function signatureToSignatureDeclarationHelper(signature, kind, context, options) {
-      var _a2, _b, _c, _d;
+      var _a2, _b, _c, _d, _e;
       const suppressAny = context.flags & 256 /* SuppressAnyReturnType */;
       if (suppressAny)
         context.flags &= ~256 /* SuppressAnyReturnType */;
@@ -47839,6 +47853,39 @@ function createTypeChecker(host) {
         /*skipUnionExpanding*/
         true
       )[0];
+      let cleanup;
+      if (context.enclosingDeclaration && signature.declaration && signature.declaration !== context.enclosingDeclaration && !isInJSFile(signature.declaration) && some(expandedParams)) {
+        const existingFakeScope = getNodeLinks(context.enclosingDeclaration).fakeScopeForSignatureDeclaration ? context.enclosingDeclaration : void 0;
+        Debug.assertOptionalNode(existingFakeScope, isBlock);
+        const locals = (_a2 = existingFakeScope == null ? void 0 : existingFakeScope.locals) != null ? _a2 : createSymbolTable();
+        let newLocals;
+        for (const param of expandedParams) {
+          if (!locals.has(param.escapedName)) {
+            newLocals = append(newLocals, param.escapedName);
+            locals.set(param.escapedName, param);
+          }
+        }
+        if (newLocals) {
+          let removeNewLocals2 = function() {
+            forEach(newLocals, (s) => locals.delete(s));
+          };
+          var removeNewLocals = removeNewLocals2;
+          if (existingFakeScope) {
+            cleanup = removeNewLocals2;
+          } else {
+            const fakeScope = parseNodeFactory.createBlock(emptyArray);
+            getNodeLinks(fakeScope).fakeScopeForSignatureDeclaration = true;
+            fakeScope.locals = locals;
+            const saveEnclosingDeclaration = context.enclosingDeclaration;
+            setParent(fakeScope, saveEnclosingDeclaration);
+            context.enclosingDeclaration = fakeScope;
+            cleanup = () => {
+              context.enclosingDeclaration = saveEnclosingDeclaration;
+              removeNewLocals2();
+            };
+          }
+        }
+      }
       const parameters = (some(expandedParams, (p) => p !== expandedParams[expandedParams.length - 1] && !!(getCheckFlags(p) & 32768 /* RestParameter */)) ? signature.parameters : expandedParams).map((parameter) => symbolToParameterDeclaration(parameter, context, kind === 173 /* Constructor */, options == null ? void 0 : options.privateSymbolVisitor, options == null ? void 0 : options.bundledImports));
       const thisParameter = context.flags & 33554432 /* OmitThisParameter */ ? void 0 : tryGetThisParameterDeclaration(signature, context);
       if (thisParameter) {
@@ -47864,11 +47911,11 @@ function createTypeChecker(host) {
         const flags = modifiersToFlags(modifiers);
         modifiers = factory.createModifiersFromModifierFlags(flags | 256 /* Abstract */);
       }
-      const node = kind === 176 /* CallSignature */ ? factory.createCallSignature(typeParameters, parameters, returnTypeNode) : kind === 177 /* ConstructSignature */ ? factory.createConstructSignature(typeParameters, parameters, returnTypeNode) : kind === 170 /* MethodSignature */ ? factory.createMethodSignature(modifiers, (_a2 = options == null ? void 0 : options.name) != null ? _a2 : factory.createIdentifier(""), options == null ? void 0 : options.questionToken, typeParameters, parameters, returnTypeNode) : kind === 171 /* MethodDeclaration */ ? factory.createMethodDeclaration(
+      const node = kind === 176 /* CallSignature */ ? factory.createCallSignature(typeParameters, parameters, returnTypeNode) : kind === 177 /* ConstructSignature */ ? factory.createConstructSignature(typeParameters, parameters, returnTypeNode) : kind === 170 /* MethodSignature */ ? factory.createMethodSignature(modifiers, (_b = options == null ? void 0 : options.name) != null ? _b : factory.createIdentifier(""), options == null ? void 0 : options.questionToken, typeParameters, parameters, returnTypeNode) : kind === 171 /* MethodDeclaration */ ? factory.createMethodDeclaration(
         modifiers,
         /*asteriskToken*/
         void 0,
-        (_b = options == null ? void 0 : options.name) != null ? _b : factory.createIdentifier(""),
+        (_c = options == null ? void 0 : options.name) != null ? _c : factory.createIdentifier(""),
         /*questionToken*/
         void 0,
         typeParameters,
@@ -47883,14 +47930,14 @@ function createTypeChecker(host) {
         void 0
       ) : kind === 174 /* GetAccessor */ ? factory.createGetAccessorDeclaration(
         modifiers,
-        (_c = options == null ? void 0 : options.name) != null ? _c : factory.createIdentifier(""),
+        (_d = options == null ? void 0 : options.name) != null ? _d : factory.createIdentifier(""),
         parameters,
         returnTypeNode,
         /*body*/
         void 0
       ) : kind === 175 /* SetAccessor */ ? factory.createSetAccessorDeclaration(
         modifiers,
-        (_d = options == null ? void 0 : options.name) != null ? _d : factory.createIdentifier(""),
+        (_e = options == null ? void 0 : options.name) != null ? _e : factory.createIdentifier(""),
         parameters,
         /*body*/
         void 0
@@ -47925,6 +47972,7 @@ function createTypeChecker(host) {
       if (typeArguments) {
         node.typeArguments = factory.createNodeArray(typeArguments);
       }
+      cleanup == null ? void 0 : cleanup();
       return node;
     }
     function tryGetThisParameterDeclaration(signature, context) {
@@ -48539,9 +48587,12 @@ function createTypeChecker(host) {
     function existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type) {
       return !(getObjectFlags(type) & 4 /* Reference */) || !isTypeReferenceNode(existing) || length(existing.typeArguments) >= getMinTypeArgumentCount(type.target.typeParameters);
     }
+    function getEnclosingDeclarationIgnoringFakeScope(enclosingDeclaration) {
+      return getNodeLinks(enclosingDeclaration).fakeScopeForSignatureDeclaration ? enclosingDeclaration.parent : enclosingDeclaration;
+    }
     function serializeTypeForDeclaration(context, type, symbol, enclosingDeclaration, includePrivateSymbol, bundled) {
       if (!isErrorType(type) && enclosingDeclaration) {
-        const declWithExistingAnnotation = getDeclarationWithTypeAnnotation(symbol, enclosingDeclaration);
+        const declWithExistingAnnotation = getDeclarationWithTypeAnnotation(symbol, getEnclosingDeclarationIgnoringFakeScope(enclosingDeclaration));
         if (declWithExistingAnnotation && !isFunctionLikeDeclaration(declWithExistingAnnotation) && !isGetAccessorDeclaration(declWithExistingAnnotation)) {
           const existing = getEffectiveTypeAnnotationNode(declWithExistingAnnotation);
           if (typeNodeIsEquivalentToType(existing, declWithExistingAnnotation, type) && existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type)) {
@@ -48573,7 +48624,8 @@ function createTypeChecker(host) {
     function serializeReturnTypeForSignature(context, type, signature, includePrivateSymbol, bundled) {
       if (!isErrorType(type) && context.enclosingDeclaration) {
         const annotation = signature.declaration && getEffectiveReturnTypeNode(signature.declaration);
-        if (!!findAncestor(annotation, (n) => n === context.enclosingDeclaration) && annotation) {
+        const enclosingDeclarationIgnoringFakeScope = getEnclosingDeclarationIgnoringFakeScope(context.enclosingDeclaration);
+        if (!!findAncestor(annotation, (n) => n === enclosingDeclarationIgnoringFakeScope) && annotation) {
           const annotated = getTypeFromTypeNode(annotation);
           const thisInstantiated = annotated.flags & 262144 /* TypeParameter */ && annotated.isThisType ? instantiateType(annotated, signature.mapper) : annotated;
           if (thisInstantiated === type && existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(annotation, type)) {
@@ -56335,31 +56387,21 @@ function createTypeChecker(host) {
     }
     return type;
     function addSpans(texts2, types2) {
-      const isTextsArray = isArray(texts2);
       for (let i = 0; i < types2.length; i++) {
         const t = types2[i];
-        const addText = isTextsArray ? texts2[i + 1] : texts2;
         if (t.flags & (2944 /* Literal */ | 65536 /* Null */ | 32768 /* Undefined */)) {
           text += getTemplateStringForType(t) || "";
-          text += addText;
-          if (!isTextsArray)
-            return true;
+          text += texts2[i + 1];
         } else if (t.flags & 134217728 /* TemplateLiteral */) {
           text += t.texts[0];
           if (!addSpans(t.texts, t.types))
             return false;
-          text += addText;
-          if (!isTextsArray)
-            return true;
-        } else if (isGenericIndexType(t) || isPatternLiteralPlaceholderType(t)) {
+          text += texts2[i + 1];
+        } else if (isGenericIndexType(t) || isPatternLiteralPlaceholderType(t) || t.flags & 2097152 /* Intersection */) {
           newTypes.push(t);
           newTexts.push(text);
-          text = addText;
-        } else if (t.flags & 2097152 /* Intersection */) {
-          const added = addSpans(texts2[i + 1], t.types);
-          if (!added)
-            return false;
-        } else if (isTextsArray) {
+          text = texts2[i + 1];
+        } else {
           return false;
         }
       }
@@ -77818,20 +77860,19 @@ function createTypeChecker(host) {
       }
     }
   }
-  function getMemberOverrideModifierStatus(node, member) {
+  function getMemberOverrideModifierStatus(node, member, memberSymbol) {
     if (!member.name) {
       return 0 /* Ok */;
     }
-    const symbol = getSymbolOfDeclaration(node);
-    const type = getDeclaredTypeOfSymbol(symbol);
+    const classSymbol = getSymbolOfDeclaration(node);
+    const type = getDeclaredTypeOfSymbol(classSymbol);
     const typeWithThis = getTypeWithThisArgument(type);
-    const staticType = getTypeOfSymbol(symbol);
+    const staticType = getTypeOfSymbol(classSymbol);
     const baseTypeNode = getEffectiveBaseTypeNode(node);
     const baseTypes = baseTypeNode && getBaseTypes(type);
     const baseWithThis = (baseTypes == null ? void 0 : baseTypes.length) ? getTypeWithThisArgument(first(baseTypes), type.thisType) : void 0;
     const baseStaticType = getBaseConstructorTypeOfClass(type);
     const memberHasOverrideModifier = member.parent ? hasOverrideModifier(member) : hasSyntacticModifier(member, 16384 /* Override */);
-    const memberName = unescapeLeadingUnderscores(getTextOfPropertyName(member.name));
     return checkMemberForOverrideModifier(
       node,
       staticType,
@@ -77844,7 +77885,7 @@ function createTypeChecker(host) {
       isStatic(member),
       /* memberIsParameterProperty */
       false,
-      memberName
+      symbolName(memberSymbol)
     );
   }
   function getTargetSymbol(s) {