tsc-ts 0.0.10 → 0.1.1

package/dist/api/compiler/printer/utilities.js

@@ -1,6 +1,6 @@
 // Node predicates, literal text and line helpers shared by the printer and transforms.
 import { BigIntLiteral, BinaryExpression, CallExpression, ConditionalExpression, ElementAccessExpression, InferTypeNode, NewExpression, NoSubstitutionTemplateLiteral, NonNullExpression, NumericLiteral, ParenthesizedExpression, PartiallyEmittedExpression, PostfixUnaryExpression, PrefixUnaryExpression, PropertyAccessExpression, RegularExpressionLiteral, AsExpression, SatisfiesExpression, SourceFile, StringLiteral, TaggedTemplateExpression, TemplateHead, TemplateMiddle, TemplateTail, ExpressionStatement, Identifier, PrivateIdentifier, getExpression, } from '../ast.js';
-import { getBinaryOperatorPrecedence } from '../ast-utilities.js';
+import { getBinaryOperatorPrecedence, isJSDocTypeExpressionOrChild, normalizeJSDocTypeSourceText, } from '../ast-utilities.js';
 import { isDigit, isLineBreak, isUnicodeWhiteSpace, isWhiteSpaceLike, isWhiteSpaceSingleLine, } from '../character-codes.js';
 import { computeLineOfPosition, skipTrivia } from '../scanner.js';
 import { getBaseFileName } from '../path.js';
@@ -27,7 +27,7 @@ export function isPrologueDirective(node) {
     return (node instanceof ExpressionStatement && node.expression.kind === 10 /* SyntaxKind.StringLiteral */);
 }
 export function isKeywordKind(kind) {
-    return kind >= 82 /* SyntaxKind.FirstKeyword */ && kind <= 166 /* SyntaxKind.LastKeyword */;
+    return kind >= 82 /* SyntaxKind.FirstKeyword */ && kind <= 167 /* SyntaxKind.LastKeyword */;
 }
 export function isPunctuationKind(kind) {
     return kind >= 18 /* SyntaxKind.FirstPunctuation */ && kind <= 78 /* SyntaxKind.LastPunctuation */;
@@ -36,7 +36,7 @@ export function isLiteralKind(kind) {
     return kind >= 8 /* SyntaxKind.FirstLiteralToken */ && kind <= 14 /* SyntaxKind.LastLiteralToken */;
 }
 export function isJSDocKind(kind) {
-    return kind >= 308 /* SyntaxKind.JSDocTypeExpression */ && kind <= 343 /* SyntaxKind.JSDocImportTag */;
+    return kind >= 309 /* SyntaxKind.JSDocTypeExpression */ && kind <= 344 /* SyntaxKind.JSDocImportTag */;
 }
 export function isMemberName(node) {
     return node.kind === 79 /* SyntaxKind.Identifier */ || node.kind === 80 /* SyntaxKind.PrivateIdentifier */;
@@ -66,10 +66,10 @@ export function isOptionalChain(node) {
     if ((node.flags & 32 /* NodeFlags.OptionalChain */) === 0)
         return false;
     switch (node.kind) {
-        case 212 /* SyntaxKind.PropertyAccessExpression */:
-        case 213 /* SyntaxKind.ElementAccessExpression */:
-        case 214 /* SyntaxKind.CallExpression */:
-        case 236 /* SyntaxKind.NonNullExpression */:
+        case 213 /* SyntaxKind.PropertyAccessExpression */:
+        case 214 /* SyntaxKind.ElementAccessExpression */:
+        case 215 /* SyntaxKind.CallExpression */:
+        case 237 /* SyntaxKind.NonNullExpression */:
             return true;
     }
     return false;
@@ -102,25 +102,25 @@ export function skipPartiallyEmittedExpressions(node) {
 export function blockScopeFlags(node) {
     let flags = node.flags;
     const parent = node.parent;
-    if (parent !== undefined && parent.kind === 244 /* SyntaxKind.VariableStatement */)
+    if (parent !== undefined && parent.kind === 245 /* SyntaxKind.VariableStatement */)
         flags |= parent.flags;
     return flags & 7 /* NodeFlags.BlockScoped */;
 }
 function isLeftHandSideExpressionKind(kind) {
     switch (kind) {
-        case 212 /* SyntaxKind.PropertyAccessExpression */:
-        case 213 /* SyntaxKind.ElementAccessExpression */:
-        case 215 /* SyntaxKind.NewExpression */:
-        case 214 /* SyntaxKind.CallExpression */:
-        case 285 /* SyntaxKind.JsxElement */:
-        case 286 /* SyntaxKind.JsxSelfClosingElement */:
-        case 289 /* SyntaxKind.JsxFragment */:
-        case 216 /* SyntaxKind.TaggedTemplateExpression */:
-        case 210 /* SyntaxKind.ArrayLiteralExpression */:
-        case 218 /* SyntaxKind.ParenthesizedExpression */:
-        case 211 /* SyntaxKind.ObjectLiteralExpression */:
-        case 232 /* SyntaxKind.ClassExpression */:
-        case 219 /* SyntaxKind.FunctionExpression */:
+        case 213 /* SyntaxKind.PropertyAccessExpression */:
+        case 214 /* SyntaxKind.ElementAccessExpression */:
+        case 216 /* SyntaxKind.NewExpression */:
+        case 215 /* SyntaxKind.CallExpression */:
+        case 286 /* SyntaxKind.JsxElement */:
+        case 287 /* SyntaxKind.JsxSelfClosingElement */:
+        case 290 /* SyntaxKind.JsxFragment */:
+        case 217 /* SyntaxKind.TaggedTemplateExpression */:
+        case 211 /* SyntaxKind.ArrayLiteralExpression */:
+        case 219 /* SyntaxKind.ParenthesizedExpression */:
+        case 212 /* SyntaxKind.ObjectLiteralExpression */:
+        case 233 /* SyntaxKind.ClassExpression */:
+        case 220 /* SyntaxKind.FunctionExpression */:
         case 79 /* SyntaxKind.Identifier */:
         case 80 /* SyntaxKind.PrivateIdentifier */:
         case 13 /* SyntaxKind.RegularExpressionLiteral */:
@@ -128,45 +128,45 @@ function isLeftHandSideExpressionKind(kind) {
         case 9 /* SyntaxKind.BigIntLiteral */:
         case 10 /* SyntaxKind.StringLiteral */:
         case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
-        case 229 /* SyntaxKind.TemplateExpression */:
+        case 230 /* SyntaxKind.TemplateExpression */:
         case 96 /* SyntaxKind.FalseKeyword */:
         case 105 /* SyntaxKind.NullKeyword */:
         case 109 /* SyntaxKind.ThisKeyword */:
         case 111 /* SyntaxKind.TrueKeyword */:
         case 107 /* SyntaxKind.SuperKeyword */:
-        case 236 /* SyntaxKind.NonNullExpression */:
-        case 234 /* SyntaxKind.ExpressionWithTypeArguments */:
-        case 237 /* SyntaxKind.MetaProperty */:
+        case 237 /* SyntaxKind.NonNullExpression */:
+        case 235 /* SyntaxKind.ExpressionWithTypeArguments */:
+        case 238 /* SyntaxKind.MetaProperty */:
         case 101 /* SyntaxKind.ImportKeyword */:
-        case 283 /* SyntaxKind.MissingDeclaration */:
+        case 284 /* SyntaxKind.MissingDeclaration */:
             return true;
     }
     return false;
 }
 function isUnaryExpressionKind(kind) {
     switch (kind) {
-        case 225 /* SyntaxKind.PrefixUnaryExpression */:
-        case 226 /* SyntaxKind.PostfixUnaryExpression */:
-        case 221 /* SyntaxKind.DeleteExpression */:
-        case 222 /* SyntaxKind.TypeOfExpression */:
-        case 223 /* SyntaxKind.VoidExpression */:
-        case 224 /* SyntaxKind.AwaitExpression */:
-        case 217 /* SyntaxKind.TypeAssertionExpression */:
+        case 226 /* SyntaxKind.PrefixUnaryExpression */:
+        case 227 /* SyntaxKind.PostfixUnaryExpression */:
+        case 222 /* SyntaxKind.DeleteExpression */:
+        case 223 /* SyntaxKind.TypeOfExpression */:
+        case 224 /* SyntaxKind.VoidExpression */:
+        case 225 /* SyntaxKind.AwaitExpression */:
+        case 218 /* SyntaxKind.TypeAssertionExpression */:
             return true;
     }
     return isLeftHandSideExpressionKind(kind);
 }
 export function isExpressionKind(kind) {
     switch (kind) {
-        case 228 /* SyntaxKind.ConditionalExpression */:
-        case 230 /* SyntaxKind.YieldExpression */:
-        case 220 /* SyntaxKind.ArrowFunction */:
-        case 227 /* SyntaxKind.BinaryExpression */:
-        case 231 /* SyntaxKind.SpreadElement */:
-        case 235 /* SyntaxKind.AsExpression */:
-        case 233 /* SyntaxKind.OmittedExpression */:
-        case 348 /* SyntaxKind.PartiallyEmittedExpression */:
-        case 239 /* SyntaxKind.SatisfiesExpression */:
+        case 229 /* SyntaxKind.ConditionalExpression */:
+        case 231 /* SyntaxKind.YieldExpression */:
+        case 221 /* SyntaxKind.ArrowFunction */:
+        case 228 /* SyntaxKind.BinaryExpression */:
+        case 232 /* SyntaxKind.SpreadElement */:
+        case 236 /* SyntaxKind.AsExpression */:
+        case 234 /* SyntaxKind.OmittedExpression */:
+        case 349 /* SyntaxKind.PartiallyEmittedExpression */:
+        case 240 /* SyntaxKind.SatisfiesExpression */:
             return true;
     }
     return isUnaryExpressionKind(kind);
@@ -188,77 +188,77 @@ export function isTypeNodeKind(kind) {
         case 157 /* SyntaxKind.UndefinedKeyword */:
         case 146 /* SyntaxKind.NeverKeyword */:
         case 141 /* SyntaxKind.IntrinsicKeyword */:
-        case 234 /* SyntaxKind.ExpressionWithTypeArguments */:
-        case 310 /* SyntaxKind.JSDocAllType */:
-        case 311 /* SyntaxKind.JSDocNullableType */:
-        case 312 /* SyntaxKind.JSDocNonNullableType */:
-        case 313 /* SyntaxKind.JSDocOptionalType */:
-        case 314 /* SyntaxKind.JSDocVariadicType */:
+        case 235 /* SyntaxKind.ExpressionWithTypeArguments */:
+        case 311 /* SyntaxKind.JSDocAllType */:
+        case 312 /* SyntaxKind.JSDocNullableType */:
+        case 313 /* SyntaxKind.JSDocNonNullableType */:
+        case 314 /* SyntaxKind.JSDocOptionalType */:
+        case 315 /* SyntaxKind.JSDocVariadicType */:
             return true;
     }
-    return kind >= 183 /* SyntaxKind.FirstTypeNode */ && kind <= 206 /* SyntaxKind.LastTypeNode */;
+    return kind >= 184 /* SyntaxKind.FirstTypeNode */ && kind <= 207 /* SyntaxKind.LastTypeNode */;
 }
 function isDeclarationStatementKind(kind) {
     switch (kind) {
-        case 263 /* SyntaxKind.FunctionDeclaration */:
-        case 283 /* SyntaxKind.MissingDeclaration */:
-        case 264 /* SyntaxKind.ClassDeclaration */:
-        case 265 /* SyntaxKind.InterfaceDeclaration */:
-        case 266 /* SyntaxKind.TypeAliasDeclaration */:
-        case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
-        case 267 /* SyntaxKind.EnumDeclaration */:
-        case 268 /* SyntaxKind.ModuleDeclaration */:
-        case 273 /* SyntaxKind.ImportDeclaration */:
-        case 346 /* SyntaxKind.JSImportDeclaration */:
-        case 272 /* SyntaxKind.ImportEqualsDeclaration */:
-        case 279 /* SyntaxKind.ExportDeclaration */:
-        case 278 /* SyntaxKind.ExportAssignment */:
-        case 271 /* SyntaxKind.NamespaceExportDeclaration */:
+        case 264 /* SyntaxKind.FunctionDeclaration */:
+        case 284 /* SyntaxKind.MissingDeclaration */:
+        case 265 /* SyntaxKind.ClassDeclaration */:
+        case 266 /* SyntaxKind.InterfaceDeclaration */:
+        case 267 /* SyntaxKind.TypeAliasDeclaration */:
+        case 346 /* SyntaxKind.JSTypeAliasDeclaration */:
+        case 268 /* SyntaxKind.EnumDeclaration */:
+        case 269 /* SyntaxKind.ModuleDeclaration */:
+        case 274 /* SyntaxKind.ImportDeclaration */:
+        case 347 /* SyntaxKind.JSImportDeclaration */:
+        case 273 /* SyntaxKind.ImportEqualsDeclaration */:
+        case 280 /* SyntaxKind.ExportDeclaration */:
+        case 279 /* SyntaxKind.ExportAssignment */:
+        case 272 /* SyntaxKind.NamespaceExportDeclaration */:
             return true;
     }
     return false;
 }
 function isStatementKindButNotDeclarationKind(kind) {
     switch (kind) {
-        case 253 /* SyntaxKind.BreakStatement */:
-        case 252 /* SyntaxKind.ContinueStatement */:
-        case 260 /* SyntaxKind.DebuggerStatement */:
-        case 247 /* SyntaxKind.DoStatement */:
-        case 245 /* SyntaxKind.ExpressionStatement */:
-        case 243 /* SyntaxKind.EmptyStatement */:
-        case 250 /* SyntaxKind.ForInStatement */:
-        case 251 /* SyntaxKind.ForOfStatement */:
-        case 249 /* SyntaxKind.ForStatement */:
-        case 246 /* SyntaxKind.IfStatement */:
-        case 257 /* SyntaxKind.LabeledStatement */:
-        case 254 /* SyntaxKind.ReturnStatement */:
-        case 256 /* SyntaxKind.SwitchStatement */:
-        case 258 /* SyntaxKind.ThrowStatement */:
-        case 259 /* SyntaxKind.TryStatement */:
-        case 244 /* SyntaxKind.VariableStatement */:
-        case 248 /* SyntaxKind.WhileStatement */:
-        case 255 /* SyntaxKind.WithStatement */:
-        case 347 /* SyntaxKind.NotEmittedStatement */:
+        case 254 /* SyntaxKind.BreakStatement */:
+        case 253 /* SyntaxKind.ContinueStatement */:
+        case 261 /* SyntaxKind.DebuggerStatement */:
+        case 248 /* SyntaxKind.DoStatement */:
+        case 246 /* SyntaxKind.ExpressionStatement */:
+        case 244 /* SyntaxKind.EmptyStatement */:
+        case 251 /* SyntaxKind.ForInStatement */:
+        case 252 /* SyntaxKind.ForOfStatement */:
+        case 250 /* SyntaxKind.ForStatement */:
+        case 247 /* SyntaxKind.IfStatement */:
+        case 258 /* SyntaxKind.LabeledStatement */:
+        case 255 /* SyntaxKind.ReturnStatement */:
+        case 257 /* SyntaxKind.SwitchStatement */:
+        case 259 /* SyntaxKind.ThrowStatement */:
+        case 260 /* SyntaxKind.TryStatement */:
+        case 245 /* SyntaxKind.VariableStatement */:
+        case 249 /* SyntaxKind.WhileStatement */:
+        case 256 /* SyntaxKind.WithStatement */:
+        case 348 /* SyntaxKind.NotEmittedStatement */:
             return true;
     }
     return false;
 }
 export function isFunctionLikeKind(kind) {
     switch (kind) {
-        case 263 /* SyntaxKind.FunctionDeclaration */:
-        case 175 /* SyntaxKind.MethodDeclaration */:
-        case 177 /* SyntaxKind.Constructor */:
-        case 178 /* SyntaxKind.GetAccessor */:
-        case 179 /* SyntaxKind.SetAccessor */:
-        case 219 /* SyntaxKind.FunctionExpression */:
-        case 220 /* SyntaxKind.ArrowFunction */:
-        case 174 /* SyntaxKind.MethodSignature */:
-        case 180 /* SyntaxKind.CallSignature */:
-        case 318 /* SyntaxKind.JSDocSignature */:
-        case 181 /* SyntaxKind.ConstructSignature */:
-        case 182 /* SyntaxKind.IndexSignature */:
-        case 185 /* SyntaxKind.FunctionType */:
-        case 186 /* SyntaxKind.ConstructorType */:
+        case 264 /* SyntaxKind.FunctionDeclaration */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
+        case 178 /* SyntaxKind.Constructor */:
+        case 179 /* SyntaxKind.GetAccessor */:
+        case 180 /* SyntaxKind.SetAccessor */:
+        case 220 /* SyntaxKind.FunctionExpression */:
+        case 221 /* SyntaxKind.ArrowFunction */:
+        case 175 /* SyntaxKind.MethodSignature */:
+        case 181 /* SyntaxKind.CallSignature */:
+        case 319 /* SyntaxKind.JSDocSignature */:
+        case 182 /* SyntaxKind.ConstructSignature */:
+        case 183 /* SyntaxKind.IndexSignature */:
+        case 186 /* SyntaxKind.FunctionType */:
+        case 187 /* SyntaxKind.ConstructorType */:
             return true;
     }
     return false;
@@ -267,27 +267,27 @@ export function isStatement(node) {
     const kind = node.kind;
     if (isStatementKindButNotDeclarationKind(kind) || isDeclarationStatementKind(kind))
         return true;
-    if (kind !== 242 /* SyntaxKind.Block */)
+    if (kind !== 243 /* SyntaxKind.Block */)
         return false;
     const parent = node.parent;
     if (parent === undefined)
         return true;
-    return (parent.kind !== 259 /* SyntaxKind.TryStatement */ &&
-        parent.kind !== 300 /* SyntaxKind.CatchClause */ &&
+    return (parent.kind !== 260 /* SyntaxKind.TryStatement */ &&
+        parent.kind !== 301 /* SyntaxKind.CatchClause */ &&
         !isFunctionLikeKind(parent.kind));
 }
 // Precedence
 export function getExpressionPrecedence(expression) {
     switch (expression.kind) {
-        case 231 /* SyntaxKind.SpreadElement */:
+        case 232 /* SyntaxKind.SpreadElement */:
             return 1 /* OperatorPrecedence.Spread */;
-        case 230 /* SyntaxKind.YieldExpression */:
+        case 231 /* SyntaxKind.YieldExpression */:
             return 2 /* OperatorPrecedence.Yield */;
-        case 220 /* SyntaxKind.ArrowFunction */:
+        case 221 /* SyntaxKind.ArrowFunction */:
             return 3 /* OperatorPrecedence.Assignment */;
-        case 228 /* SyntaxKind.ConditionalExpression */:
+        case 229 /* SyntaxKind.ConditionalExpression */:
             return 4 /* OperatorPrecedence.Conditional */;
-        case 227 /* SyntaxKind.BinaryExpression */:
+        case 228 /* SyntaxKind.BinaryExpression */:
             if (expression instanceof BinaryExpression) {
                 const operator = expression.operatorToken.kind;
                 if (operator === 27 /* SyntaxKind.CommaToken */)
@@ -297,30 +297,30 @@ export function getExpressionPrecedence(expression) {
                 return getBinaryOperatorPrecedence(operator);
             }
             return -1 /* OperatorPrecedence.Invalid */;
-        case 217 /* SyntaxKind.TypeAssertionExpression */:
-        case 236 /* SyntaxKind.NonNullExpression */:
-        case 225 /* SyntaxKind.PrefixUnaryExpression */:
-        case 222 /* SyntaxKind.TypeOfExpression */:
-        case 223 /* SyntaxKind.VoidExpression */:
-        case 221 /* SyntaxKind.DeleteExpression */:
-        case 224 /* SyntaxKind.AwaitExpression */:
+        case 218 /* SyntaxKind.TypeAssertionExpression */:
+        case 237 /* SyntaxKind.NonNullExpression */:
+        case 226 /* SyntaxKind.PrefixUnaryExpression */:
+        case 223 /* SyntaxKind.TypeOfExpression */:
+        case 224 /* SyntaxKind.VoidExpression */:
+        case 222 /* SyntaxKind.DeleteExpression */:
+        case 225 /* SyntaxKind.AwaitExpression */:
             return 16 /* OperatorPrecedence.Unary */;
-        case 226 /* SyntaxKind.PostfixUnaryExpression */:
+        case 227 /* SyntaxKind.PostfixUnaryExpression */:
             return 17 /* OperatorPrecedence.Update */;
-        case 212 /* SyntaxKind.PropertyAccessExpression */:
-        case 213 /* SyntaxKind.ElementAccessExpression */:
-        case 214 /* SyntaxKind.CallExpression */:
+        case 213 /* SyntaxKind.PropertyAccessExpression */:
+        case 214 /* SyntaxKind.ElementAccessExpression */:
+        case 215 /* SyntaxKind.CallExpression */:
             return isOptionalChain(expression) ? 19 /* OperatorPrecedence.OptionalChain */ : 20 /* OperatorPrecedence.Member */;
-        case 215 /* SyntaxKind.NewExpression */:
+        case 216 /* SyntaxKind.NewExpression */:
             return expression instanceof NewExpression && expression.arguments === undefined
                 ? 18 /* OperatorPrecedence.LeftHandSide */
                 : 20 /* OperatorPrecedence.Member */;
-        case 216 /* SyntaxKind.TaggedTemplateExpression */:
-        case 237 /* SyntaxKind.MetaProperty */:
-        case 234 /* SyntaxKind.ExpressionWithTypeArguments */:
+        case 217 /* SyntaxKind.TaggedTemplateExpression */:
+        case 238 /* SyntaxKind.MetaProperty */:
+        case 235 /* SyntaxKind.ExpressionWithTypeArguments */:
             return 20 /* OperatorPrecedence.Member */;
-        case 235 /* SyntaxKind.AsExpression */:
-        case 239 /* SyntaxKind.SatisfiesExpression */:
+        case 236 /* SyntaxKind.AsExpression */:
+        case 240 /* SyntaxKind.SatisfiesExpression */:
             return 11 /* OperatorPrecedence.Relational */;
         case 109 /* SyntaxKind.ThisKeyword */:
         case 107 /* SyntaxKind.SuperKeyword */:
@@ -333,48 +333,48 @@ export function getExpressionPrecedence(expression) {
         case 8 /* SyntaxKind.NumericLiteral */:
         case 9 /* SyntaxKind.BigIntLiteral */:
         case 10 /* SyntaxKind.StringLiteral */:
-        case 210 /* SyntaxKind.ArrayLiteralExpression */:
-        case 211 /* SyntaxKind.ObjectLiteralExpression */:
-        case 219 /* SyntaxKind.FunctionExpression */:
-        case 232 /* SyntaxKind.ClassExpression */:
+        case 211 /* SyntaxKind.ArrayLiteralExpression */:
+        case 212 /* SyntaxKind.ObjectLiteralExpression */:
+        case 220 /* SyntaxKind.FunctionExpression */:
+        case 233 /* SyntaxKind.ClassExpression */:
         case 13 /* SyntaxKind.RegularExpressionLiteral */:
         case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
-        case 229 /* SyntaxKind.TemplateExpression */:
-        case 233 /* SyntaxKind.OmittedExpression */:
-        case 285 /* SyntaxKind.JsxElement */:
-        case 286 /* SyntaxKind.JsxSelfClosingElement */:
-        case 289 /* SyntaxKind.JsxFragment */:
-        case 283 /* SyntaxKind.MissingDeclaration */:
+        case 230 /* SyntaxKind.TemplateExpression */:
+        case 234 /* SyntaxKind.OmittedExpression */:
+        case 286 /* SyntaxKind.JsxElement */:
+        case 287 /* SyntaxKind.JsxSelfClosingElement */:
+        case 290 /* SyntaxKind.JsxFragment */:
+        case 284 /* SyntaxKind.MissingDeclaration */:
             return 21 /* OperatorPrecedence.Primary */;
-        case 218 /* SyntaxKind.ParenthesizedExpression */:
+        case 219 /* SyntaxKind.ParenthesizedExpression */:
             return 22 /* OperatorPrecedence.Parentheses */;
     }
     return -1 /* OperatorPrecedence.Invalid */;
 }
 export function getTypeNodePrecedence(node) {
     switch (node.kind) {
-        case 195 /* SyntaxKind.ConditionalType */:
+        case 196 /* SyntaxKind.ConditionalType */:
             return 0 /* TypePrecedence.Conditional */;
-        case 313 /* SyntaxKind.JSDocOptionalType */:
-        case 314 /* SyntaxKind.JSDocVariadicType */:
+        case 314 /* SyntaxKind.JSDocOptionalType */:
+        case 315 /* SyntaxKind.JSDocVariadicType */:
             return 1 /* TypePrecedence.JSDoc */;
-        case 185 /* SyntaxKind.FunctionType */:
-        case 186 /* SyntaxKind.ConstructorType */:
+        case 186 /* SyntaxKind.FunctionType */:
+        case 187 /* SyntaxKind.ConstructorType */:
             return 2 /* TypePrecedence.Function */;
-        case 193 /* SyntaxKind.UnionType */:
+        case 194 /* SyntaxKind.UnionType */:
             return 3 /* TypePrecedence.Union */;
-        case 194 /* SyntaxKind.IntersectionType */:
+        case 195 /* SyntaxKind.IntersectionType */:
             return 4 /* TypePrecedence.Intersection */;
-        case 199 /* SyntaxKind.TypeOperator */:
-        case 187 /* SyntaxKind.TypeQuery */:
+        case 200 /* SyntaxKind.TypeOperator */:
+        case 188 /* SyntaxKind.TypeQuery */:
             return 5 /* TypePrecedence.TypeOperator */;
-        case 196 /* SyntaxKind.InferType */:
+        case 197 /* SyntaxKind.InferType */:
             return node instanceof InferTypeNode && node.typeParameter.constraint !== undefined
                 ? 2 /* TypePrecedence.Function */
                 : 5 /* TypePrecedence.TypeOperator */;
-        case 200 /* SyntaxKind.IndexedAccessType */:
-        case 189 /* SyntaxKind.ArrayType */:
-        case 191 /* SyntaxKind.OptionalType */:
+        case 201 /* SyntaxKind.IndexedAccessType */:
+        case 190 /* SyntaxKind.ArrayType */:
+        case 192 /* SyntaxKind.OptionalType */:
             return 6 /* TypePrecedence.Postfix */;
     }
     return 7 /* TypePrecedence.NonArray */;
@@ -436,7 +436,7 @@ export function isImmediatelyInvokedFunctionExpressionOrArrowFunction(node) {
     if (!(node instanceof CallExpression))
         return false;
     const callee = skipPartiallyEmittedExpressions(node.expression);
-    return callee.kind === 219 /* SyntaxKind.FunctionExpression */ || callee.kind === 220 /* SyntaxKind.ArrowFunction */;
+    return callee.kind === 220 /* SyntaxKind.FunctionExpression */ || callee.kind === 221 /* SyntaxKind.ArrowFunction */;
 }
 export function getOperatorOfPrefixOperand(node) {
     return node instanceof PrefixUnaryExpression ? node.operator : 0 /* SyntaxKind.Unknown */;
@@ -621,7 +621,9 @@ export function getLiteralText(node, sourceText, flags) {
 export function getSourceTextOfNode(sourceText, node) {
     if (node.pos === node.end && node.pos >= 0 && node.kind !== 1 /* SyntaxKind.EndOfFile */)
         return '';
-    const text = sourceText.substring(skipTrivia(sourceText, node.pos), node.end);
+    let text = sourceText.substring(skipTrivia(sourceText, node.pos), node.end);
+    if (isJSDocTypeExpressionOrChild(node))
+        text = normalizeJSDocTypeSourceText(text);
     if ((node.flags & 268435456 /* NodeFlags.ReparserTransformedLiteral */) !== 0) {
         if (node instanceof StringLiteral)
             return (node.tokenFlags & 65536 /* TokenFlags.SingleQuote */) !== 0 ? "'" + text + "'" : '"' + text + '"';

package/dist/api/compiler/program-checker.d.ts

@@ -109,6 +109,12 @@ export declare class CheckedProgram {
      */
     referenceThreads: number;
     readonly parallelGlobalDiagnostics: Diagnostic[];
+    /**
+     * Whether the semantic diagnostics of a file include the global diagnostics its checker found while
+     * checking it, as an incremental program caches them (IncrementalProgram). Such a program doesn't report
+     * the global diagnostics found by checking otherwise (`reportsGlobalDiagnosticsOfChecking`, compile-program.ts).
+     */
+    globalsInFileDiagnostics: boolean;
     /**
      * The declaration diagnostics checker threads computed under `noEmit` (PlainProgram,
      * IncrementalProgram), by file index; `undefined` for files they did not. Set once every file is
@@ -173,8 +179,8 @@ export declare class CheckedProgram {
      * those they found checking files.
      */
     getGlobalDiagnostics(withCheckerThreads?: boolean): Diagnostic[];
-    /** Whether `file`'s bind and check diagnostics are reported. */
-    skipTypeChecking(file: SourceFile): boolean;
+    /** Whether `file`'s bind and check diagnostics are skipped; `ignoreNoCheck` leaves `noCheck` out. */
+    skipTypeChecking(file: SourceFile, ignoreNoCheck?: boolean): boolean;
     private collect;
     private collectChecked;
     /** `checks` are the checker's diagnostics of `file`. */