@artel/artc 0.6.25219 → 0.6.25221

package/build/{chunk-QLTGS2V2.js → chunk-XMV7LOUY.js}

@@ -1,6 +1,6 @@
 import {
   Compiler
-} from "./chunk-AIY75NR5.js";
+} from "./chunk-5F65ZJE3.js";
 import {
   ArtelVersion,
   Cached,
@@ -14,7 +14,7 @@ import {
   __async,
   performanceMeasurementStageNames,
   performanceMeasurementStages
-} from "./chunk-IYSH7MAQ.js";
+} from "./chunk-X7TMUZ4C.js";
 
 // source/executor/FileSystemUri.ts
 import { platform } from "os";
@@ -216,7 +216,7 @@ var NodeCompiler = class {
       const standardLibraryUri = yield this.findStandardTypeScriptLibrary(nodeModulesSearchPaths, defaultTsLibraryPath);
       if (standardLibraryUri === void 0) {
         const diagnostic = new Diagnostic(DiagnosticData.withCode(
-          117 /* CanNotFindTsLibDirectoryBaseSearchPaths0 */,
+          125 /* CanNotFindTsLibDirectoryBaseSearchPaths0 */,
           [nodeModulesSearchPaths.map((p) => `'${p}'`).join(", ")]
         ), void 0);
         diagnostics?.addDiagnostic(diagnostic);

package/build/types/analysis/Analyzer.d.ts

@@ -21,6 +21,7 @@ import * as autotypeCallExpressionMeaning from './AutotypeCallExpressionMeaning.
 import * as baseExpressionMeaning from './BaseExpressionMeaning.js';
 import * as callExpressionMeaning from './CallExpressionMeaning.js';
 import * as constructorOverloadResolver from './ConstructorOverloadResolver.js';
+import { ControlFlowGraphBuildResult } from './ControlFlowGraphBuilder.js';
 import { DeclarationsUsageCountResult } from './DeclarationsUsageCounter.js';
 import * as dereferenceExpressionMeaning from './DereferenceExpressionMeaning.js';
 import { FoundAnonymousDeclaration } from './FoundDeclaration.js';
@@ -93,6 +94,7 @@ export declare class Analyzer {
     private readonly _linkedMultiPlatformPackagesByPlatform;
     private readonly _bodyUsesYieldStatementCheckResults;
     private readonly _namedDeclarationsUsageCountResults;
+    private readonly _controlFlowGraphs;
     get tsInterop(): TsInteropContext;
     constructor(compilation: project.Compilation, tsInteropInputs: TsInteropInputs);
     getProjectSourceFile(node: tree.SourceFile): project.SourceFile;
@@ -105,6 +107,7 @@ export declare class Analyzer {
         referencedType: types.Type;
     } | undefined;
     isTypeAssignableTo(source: types.Type, target: types.Type): boolean;
+    getTypeAssignabilityFlags(source: types.Type, target: types.Type): TypeAssignabilityFlags;
     checkStatementBlockInvokesAsyncMethods(node: tree.StatementBlock): boolean;
     getSyntacticAccessKind(node: tree.Expression): SyntacticAccessKind;
     getTypeMemberEntityContainer(node: tree.TypeMemberDeclaration): e.TypeMemberEntityContainer;
@@ -128,8 +131,37 @@ export declare class Analyzer {
     resolveTag(node: tree.Tag): tagMeaning.ResolutionResult;
     getObjectExpressionMeaning(node: tree.ObjectExpression): objectExpressionMeaning.Meaning;
     getBaseExpressionMeaning(node: tree.BaseExpression): baseExpressionMeaning.Meaning;
-    checkExpressionOptionalChaining(node: tree.Expression): boolean;
-    makeNoneAssignableToTypeIfExpressionOptionalChaining(type: types.Type, node: tree.Expression): types.Type;
+    /**
+     * Проверяет, является ли выражение цепочкой доступов через `?`, заканчивающейся выражением, тип которого допускает
+     * `пусто`.
+     *
+     * Пример:
+     * ```artel
+     * а?.б
+     * а?[1]
+     * а?^
+     * а?()
+     * (а)?.б
+     * ```
+     *
+     * где тип переменной `а` допускает `пусто`.
+     */
+    isExpressionValidOptionalChaining(node: tree.Expression): boolean;
+    /**
+     * Проверяет, является ли выражение цепочкой доступов через `?`.
+     *
+     * Пример:
+     * ```artel
+     * а?.б
+     * а?[1]
+     * а?^
+     * а?()
+     * (а)?.б
+     * ```
+     */
+    isExpressionOptionalChainingSyntactically(node: tree.Expression): boolean;
+    isExpressionValidOutermostOptionalChaining(node: tree.Expression): boolean;
+    makeNoneAssignableToTypeIfExpressionValidOutermostOptionalChaining(type: types.Type, node: tree.Expression): types.Type;
     checkIdentifierNameIsReserved(name: string, locale: PackageLocale): ReservedIdentifierKind | undefined;
     getReservedIdentifierName(reservedIdentifierKind: ReservedIdentifierKind, locale: PackageLocale): string;
     createNameFromIdentifier(node: tree.Identifier): Name;
@@ -200,6 +232,7 @@ export declare class Analyzer {
      * - Т: Объект?    -> нет, поскольку в качестве конкретного типа, заменяющего параметр, может быть использован тип, исключающий `пусто`.
      */
     isNoneAssignableToType(type: types.Type): boolean;
+    excludeTypeFromUnion(initialType: types.Type, excludedType: types.Type): types.Type;
     isMethodValueParameterVariadic(entity: e.VariableEntity): boolean;
     getDefaultTypeParameterConstraint(): types.Type;
     getOriginalSignatureTypeOfMethodEntity(entity: e.MethodEntity): types.MethodType;
@@ -229,6 +262,7 @@ export declare class Analyzer {
     checkBodyOfRedefinableAliasTypeMethod(node: tree.TypeMethodDeclaration, diagnostics?: DiagnosticAcceptor): {
         redefinableMethodOfOriginalType: e.TypeMethodEntity;
     } | undefined;
+    getControlFlowGraph(sourceFile: project.SourceFile): ControlFlowGraphBuildResult;
     private createTsInterop;
 }
 export declare class TsInteropInputs {
@@ -299,6 +333,7 @@ declare class Type {
     private getTargetlessMethodBlockLiteralType;
     private inferMethodLiteralTypeFromNodeWithFallbackToTargetType;
     private inferMethodLiteralTypeFromNode;
+    private getNarrowedTypeIfNarrowableReference;
 }
 declare class ReturnType {
     private readonly _analyzer;
@@ -387,6 +422,9 @@ declare class Entity {
     private createTypeIndexerEntities;
     private areTypeIndexedAccessorDeclarationsEqual;
 }
+type EntityClassMembers = Entity[keyof Entity];
+type GetNodesFromMethodsParameter<T> = T extends (node: infer TNode) => e.Entity ? (TNode extends tree.Node ? TNode : never) : never;
+export type NodeCorrespondingToEntity = GetNodesFromMethodsParameter<EntityClassMembers>;
 declare class ResultLocalVariableEntity {
     private readonly _analyzer;
     private readonly _entities;
@@ -571,6 +609,15 @@ declare class OwningPlainObjectModificationCheck {
     private checkReceiverModifiesPlainObjectRecursively;
     private nodeBelongsToPlainObjectDeclaration;
 }
+export declare enum TypeAssignabilityFlags {
+    NotAssignable = 1,
+    Identity = 2,
+    DerivedToBase = 4,
+    MethodTypes = 8,
+    ImplicitConversion = 16,
+    First = 1,
+    Last = 16
+}
 declare class PackageImports {
     private readonly _analyzer;
     private readonly _packagesAvailableForImport;

package/build/types/analysis/ControlFlowGraphBuilder.d.ts

@@ -0,0 +1,121 @@
+import { Diagnostic } from '../diagnostic/Diagnostic.js';
+import { SourceFile } from '../project/SourceFile.js';
+import * as tree from '../tree/index.js';
+export declare class ControlFlowGraphBuilder {
+    private readonly _sourceFile;
+    private readonly _controlFlowNodeByReference;
+    private readonly _unreachableCodeDiagnostics;
+    private _isInRebuildingFinallyClauseGraphMode;
+    private _currentPredecessor;
+    private _currentContinueLoopTarget;
+    private _currentBreakLoopTarget;
+    private _currentErrorTarget;
+    private _currentReturnTarget;
+    constructor(sourceFile: SourceFile);
+    build(): ControlFlowGraphBuildResult;
+    private visitNode;
+    private visitAssignmentStatement;
+    private visitIfStatement;
+    private visitWhileStatement;
+    private visitLoopStatement;
+    private visitForStatement;
+    private visitContinueLoopStatement;
+    private visitBreakLoopStatement;
+    private visitSwitchStatement;
+    private visitTryStatement;
+    private visitReturnStatement;
+    private visitErrorStatement;
+    private visitLocalVariableDeclaration;
+    private visitWhenTernaryExpression;
+    private visitCondition;
+    private visitBinaryExpression;
+    private visitPrefixUnaryExpressionInCondition;
+    private visitIsExpressionInCondition;
+    private setAssignmentAsCurrentPredecessor;
+    private visitChildren;
+    private addUnreachableCodeDiagnostic;
+}
+export declare class ControlFlowGraphBuildResult {
+    readonly controlFlowNodeByReference: ReadonlyMap<NarrowableReferenceExpression, ControlFlowNode>;
+    readonly unreachableCodeDiagnostics: readonly Diagnostic[];
+    constructor(controlFlowNodeByReference: ReadonlyMap<NarrowableReferenceExpression, ControlFlowNode>, unreachableCodeDiagnostics: readonly Diagnostic[]);
+}
+export type NarrowableExpression = tree.IdentifierExpression | tree.PropertyAccessExpression | tree.ObjectExpression;
+export declare function isNarrowableExpression(node: tree.Node): node is tree.Expression;
+export type NarrowableReferenceExpression = tree.IdentifierExpression | tree.PropertyAccessExpression | tree.ObjectExpression;
+export declare function isNarrowableReferenceExpression(node: tree.Node): node is NarrowableReferenceExpression;
+export type ControlFlowNode = ControlFlowNode.Start | ControlFlowNode.Condition | ControlFlowNode.Assignment | ControlFlowNode.Split | ControlFlowNode.Loop | ControlFlowNode.Unreachable;
+export declare namespace ControlFlowNode {
+    abstract class ControlFlowNodeBase {
+        protected abstract thisAsNode: ControlFlowNode;
+        /**
+         * Для отладочных целей.
+         */
+        generateVisualizationCode(): string;
+    }
+    /**
+     * Начальный узел, не имеющий предшественников.
+     */
+    export class Start extends ControlFlowNodeBase {
+        readonly kind = "start";
+        get debuggerDisplay(): string;
+        protected get thisAsNode(): ControlFlowNode;
+    }
+    /**
+     * Хранит информацию об истинности некоторого условия. Например, если условие `а != пусто` истинно, то из типа
+     * переменной `а` необходимо исключить тип `Пусто`.
+     */
+    export class Condition extends ControlFlowNodeBase {
+        readonly predecessor: ControlFlowNode;
+        readonly syntaxNode: ConditionControlFlowNodeExpression;
+        readonly isTrue: boolean;
+        readonly kind = "condition";
+        get debuggerDisplay(): string;
+        protected get thisAsNode(): ControlFlowNode;
+        constructor(predecessor: ControlFlowNode, syntaxNode: ConditionControlFlowNodeExpression, isTrue: boolean);
+    }
+    /**
+     * Создаётся в местах присваивания значений в переменную, а также объявления переменных с начальным значением.
+     * После присваивания тип переменной меняется на тип выражения справа от равно.
+     */
+    export class Assignment extends ControlFlowNodeBase {
+        readonly predecessor: ControlFlowNode;
+        readonly syntaxNode: tree.AssignmentStatement | tree.LocalVariableDeclaration;
+        readonly kind = "assignment";
+        get debuggerDisplay(): string;
+        protected get thisAsNode(): ControlFlowNode;
+        constructor(predecessor: ControlFlowNode, syntaxNode: tree.AssignmentStatement | tree.LocalVariableDeclaration);
+    }
+    /**
+     * Вспомогательный узел, использующийся в местах, где происходит разветвление графа потока управления. Тип переменной
+     * для этого узла определяется как союзный тип из типов переменных в предшествующих узлах.
+     */
+    export class Split extends ControlFlowNodeBase {
+        readonly predecessors: readonly ControlFlowNode[];
+        readonly kind = "split";
+        get debuggerDisplay(): string;
+        protected get thisAsNode(): ControlFlowNode;
+        constructor(predecessors: readonly ControlFlowNode[]);
+    }
+    /**
+     * Используется для циклов (пока, цикл - повтор пока, для-из). Отличается от узла `Split` тем, что предшествующие
+     * узлы, указанные в массиве `loopingPredecessors` образуют циклы в графе потока управления.
+     */
+    export abstract class Loop extends ControlFlowNodeBase {
+        readonly kind = "loop";
+        get debuggerDisplay(): string;
+        protected get thisAsNode(): ControlFlowNode;
+        abstract predecessor: ControlFlowNode;
+        abstract loopingPredecessors: readonly ControlFlowNode[];
+    }
+    /**
+     * Обозначает недостижимый код.
+     */
+    export class Unreachable extends ControlFlowNodeBase {
+        readonly kind = "unreachable";
+        get debuggerDisplay(): string;
+        protected get thisAsNode(): ControlFlowNode;
+    }
+    export {};
+}
+export type ConditionControlFlowNodeExpression = tree.BinaryExpression | tree.IsExpression;

package/build/types/analysis/ControlFlowGraphVisualizer.d.ts

@@ -0,0 +1,12 @@
+import { ControlFlowNode } from './ControlFlowGraphBuilder.js';
+export declare class ControlFlowGraphVisualizer {
+    /**
+     * Создаёт описание графа на языке Dot.
+     *
+     * Визуализацию графа можно посмотреть по этой ссылке:
+     * https://dreampuf.github.io/GraphvizOnline/?engine=dot#digraph%20%7B%20%7D
+     */
+    static generateGraphDescriptionInDotLanguage(startNode: ControlFlowNode): string;
+    private static getLabel;
+    private static createGetIdFunction;
+}

package/build/types/analysis/DiagnosticCollector.d.ts

@@ -18,6 +18,8 @@ export declare class DiagnosticCollector {
     constructor(analyzer: Analyzer, sourceFile: project.SourceFile, cancellationToken: CancellationToken | undefined);
     collect(): Promise<Diagnostic[]>;
     private collectNodeDiagnostics;
+    private checkDereferenceExpression;
+    private checkIndexedAccessExpression;
     private checkCallExpression;
     private addNotTranslatedPackageMembersDiagnostics;
     private collectNotTranslatedPackageMembers;
@@ -60,6 +62,7 @@ export declare class DiagnosticCollector {
     private checkAssignmentToObjectExpression;
     private checkAssignmentToDereferenceExpression;
     private checkAssignmentToIndexedAccessExpression;
+    private checkOptionalChainingIsUsedOnTheLeftSideOfAssignment;
     private checkGenericSpecializationExpression;
     private checkMethodSpecialization;
     private checkTypeSpecialization;

package/build/types/analysis/NodeTypeUtils.d.ts

@@ -11,11 +11,13 @@ export declare class NodeTypeUtils {
     static isTypeSpecifier(node: tree.Node): node is tree.TypeSpecifier;
     static isMethodDeclaration(node: tree.Node): node is MethodDeclaration;
     static isVariableDeclaration(node: tree.Node): node is VariableDeclaration;
+    static isVariantTypeDeclaration(node: tree.Node): node is VariantTypeDeclaration;
+    static isSubprogramDeclaration(node: tree.Node): node is SubprogramDeclaration;
+    static isNoneLiteral(node: tree.Node): boolean;
 }
 export type PackageTypeDeclaration = tree.PackageAliasTypeDeclaration | tree.PackageMethodTypeDeclaration | tree.PackageStructuredTypeDeclaration | tree.PackageVariantTypeDeclaration;
 export type StructuredTypeDeclaration = tree.PackageStructuredTypeDeclaration | tree.AnonymousStructuredTypeDeclaration;
 export type VariantTypeDeclaration = tree.PackageVariantTypeDeclaration | tree.AnonymousVariantTypeDeclaration;
-export declare function isVariantTypeDeclaration(node: tree.Node): node is VariantTypeDeclaration;
 export type MethodTypeDeclaration = tree.PackageMethodTypeDeclaration | tree.AnonymousMethodTypeDeclaration;
 export type MethodDeclaration = tree.PackageMethodDeclaration | tree.NestedMethodDeclaration | tree.TypeMethodDeclaration;
 export type TypeDeclaration = StructuredTypeDeclaration | VariantTypeDeclaration | MethodTypeDeclaration | tree.PackageAliasTypeDeclaration | tree.TypeParameterDeclaration;
@@ -27,3 +29,9 @@ export type PackageVariableAccessorDeclaration = tree.PackageVariableGetterDecla
 export type TypeVariableAccessorDeclaration = tree.TypeVariableGetterDeclaration | tree.TypeVariableSetterDeclaration;
 export type TypeIndexedAccessorDeclaration = tree.TypeIndexedGetterDeclaration | tree.TypeIndexedSetterDeclaration;
 export type TypeDereferencedVariableAccessorDeclaration = tree.TypeDereferencedVariableGetterDeclaration | tree.TypeDereferencedVariableSetterDeclaration;
+type Declaration = tree.PackageMemberDeclaration | tree.TypeMemberDeclaration | tree.LocalVariableDeclaration | tree.EnumerationVariableDeclaration | tree.ErrorVariableDeclaration | tree.NestedMethodDeclaration | TypeDeclaration;
+type SubprogramDeclarationInternal<T extends Declaration = Declaration> = T extends {
+    block: tree.StatementBlock | undefined;
+} ? T : never;
+export type SubprogramDeclaration = SubprogramDeclarationInternal | tree.MethodLiteral | tree.MethodBlockLiteral;
+export {};

package/build/types/analysis/TypeNarrower.d.ts

@@ -0,0 +1,57 @@
+import { LocalVariableEntity, PackageVariableEntity, ParameterVariableEntity } from '../entities/VariableEntity.js';
+import * as types from '../types/index.js';
+import { Analyzer } from './Analyzer.js';
+import { ControlFlowNode, NarrowableReferenceExpression } from './ControlFlowGraphBuilder.js';
+export declare class TypeNarrower {
+    private readonly _analyzer;
+    private readonly _referenceExpression;
+    private readonly _initialType;
+    private readonly _controlFlowNode;
+    private _reference;
+    private readonly _typeByNode;
+    constructor(analyzer: Analyzer, referenceExpression: NarrowableReferenceExpression, initialType: types.Type, controlFlowNode: ControlFlowNode);
+    getType(): types.Type;
+    private getTypeAtControlFlowNode;
+    private getTypeAtCondition;
+    private getTypeAtAssignment;
+    private getTypeAtSplit;
+    private getTypeAtLoop;
+    private getTypeAtComparisonWithNone;
+    private getTypeAtIsExpression;
+    private addTypeIfUnique;
+    private isSameReferenceAsNarrowedExpression;
+    private unwrapExpression;
+    private getReferenceAtNodeIfNarrowable;
+    private getReferenceAtNode;
+    private getReferenceAtLocalVariableDeclaration;
+}
+export type NarrowableReference = NarrowableReference.LocalOrPackageVariable | NarrowableReference.InstanceTypeVariable | NarrowableReference.StaticTypeVariable | NarrowableReference.Object;
+export declare namespace NarrowableReference {
+    export class LocalOrPackageVariable implements INarrowableReference {
+        readonly entity: LocalVariableEntity | ParameterVariableEntity | PackageVariableEntity;
+        readonly kind = "local-or-package-variable";
+        constructor(entity: LocalVariableEntity | ParameterVariableEntity | PackageVariableEntity);
+        equals(other: NarrowableReference): boolean;
+    }
+    export class InstanceTypeVariable implements INarrowableReference {
+        readonly variable: types.Variable;
+        readonly receiver: NarrowableReference;
+        readonly kind = "instance-type-variable";
+        constructor(variable: types.Variable, receiver: NarrowableReference);
+        equals(other: NarrowableReference): boolean;
+    }
+    export class StaticTypeVariable implements INarrowableReference {
+        readonly variable: types.Variable;
+        readonly kind = "static-type-variable";
+        constructor(variable: types.Variable);
+        equals(other: NarrowableReference): boolean;
+    }
+    export class Object implements INarrowableReference {
+        readonly kind = "object";
+        equals(other: NarrowableReference): boolean;
+    }
+    interface INarrowableReference {
+        equals(other: NarrowableReference): boolean;
+    }
+    export {};
+}

package/build/types/common/Range.d.ts

@@ -5,6 +5,7 @@ export declare class Range {
     get isEmpty(): boolean;
     constructor(start: number, end: number);
     includes(offset: number): boolean;
+    includes(range: Range): boolean;
     equals(other: Range): boolean;
     static empty(start: number): Range;
 }

package/build/types/diagnostic/DiagnosticCode.d.ts

@@ -1,125 +1,133 @@
 export declare enum DiagnosticCode {
-    IdentifierExpected = 0,
-    TypeNameExpected = 1,
-    PackageNameExpected = 2,
-    TypeMemberDeclarationExpected = 3,
-    SourceFileMemberExpected = 4,
-    EnumerationVariableDeclarationExpected = 5,
-    StatementExpected = 6,
-    ExpressionExpected = 7,
-    BaseTypeNameExpected = 8,
-    TypeSpecifierExpected = 9,
-    TypeBodyExpected = 10,
-    MethodCallArgumentExpected = 11,
-    IndexedAccessArgumentExpected = 12,
-    TagArgumentExpected = 13,
-    TypeParameterExpected = 14,
-    ParameterExpected = 15,
-    RunStatementClauseExpected = 16,
-    CatchClauseOrFinallyClauseExpected = 17,
-    PackageImportExpected = 18,
-    UsingDirectiveOrSourceFileMemberExpected = 19,
-    TypeMemberTranslationExpected = 20,
-    TranslationExpected = 21,
-    Expected0But1Found = 22,
-    InvalidTextTemplateLiteral = 23,
-    RunKeywordCreationKeywordOrModifierListExpected = 24,
-    ModifierListExpected = 25,
-    HidingLevelExpected = 26,
-    ParameterNameCanContainOnlyOneBackQuote = 27,
-    FieldNameCanContainOnlyTwoBackQuote = 28,
-    BackQuotesCanOnlyBeUsedInParameterAndFieldNames = 29,
-    NameThatMatchesKeywordMustBeEnclosedInSingleQuotes = 30,
-    TagNameExpected = 31,
-    TypeCannotBeUsedAsValue = 32,
-    PackageMemberNotFound = 33,
-    TypeMemberNotFound = 34,
-    CannotAccessStaticMembersOnTypeParameter = 35,
-    IndexerOfTheSpecifiedTypeNotFound = 36,
-    DereferenceOperatorOfTheSpecifiedTypeNotFound = 37,
-    IndexerNotFound = 38,
-    CannotCreateInstanceOfAspect = 39,
-    CannotCreateInstanceOfTypeParameter = 40,
-    CannotCreateInstanceOfUnresolvedType = 41,
-    TypeConstructorNotFound = 42,
-    CannotInvokeExpression = 43,
-    NamedArgumentExpectedButPositionalArgumentFound = 44,
-    ParameterWithGivenNameNotFound = 45,
-    ArgumentForParameterAlreadyPassed = 46,
-    PackageAliasCannotBeUsedAsValue = 47,
-    PackageNameCannotBeUsedAsValue = 48,
-    UnknownVariable = 49,
-    UnknownType = 50,
-    TypeWithArity0NotFound = 51,
-    VariableUsedBeforeBeingDeclared = 52,
-    Type0IsNotAssignableToType1 = 53,
-    VariableNotFound = 54,
-    MethodNotFound = 55,
-    UnknownPackage = 56,
-    CannotAssignValueToExpression = 57,
-    NotEveryRequiredParameterIsProvidedWithArgument = 58,
-    ParameterForPositionalArgumentNotFound = 59,
-    CannotDetermineTargetTypeToCallTheConstructor = 60,
-    AmbiguousAccess = 61,
-    PackageNameConflictsWithDeclarationName = 62,
-    CanNotAssignValueToContextVariable = 63,
-    ExpectedPackageNameOrAliasButFoundType = 64,
-    TypeExpected = 65,
-    NameOfTypeOrPackageNotFound = 66,
-    TypeIsNotATag = 67,
-    ExpressionOfType0CanNotBeUsedForEnumeration = 68,
-    Operator0IsNotDefinedForTypes1And2 = 69,
-    Operator0IsNotDefinedForType1 = 70,
-    VariantMustHaveAssociatedValue = 71,
-    PackageMemberOrPackageNotFound = 72,
-    TranslationsCanOnlyBeDeclaredInTranslationPackage = 73,
-    UnknownTranslatedPackage0 = 74,
-    BaseCannotBeUsedInThisContext = 75,
-    OverriddenMethodNotFound = 76,
-    ObjectCannotBeUsedInThisContext = 77,
-    BaseCannotBeUsedAsAnExpressionInItself = 78,
-    InterfacePackageMustNotContainImplementation = 79,
-    InterfacePackageVariablesMustNotHaveInitializers = 80,
-    BodyIsMissing = 81,
-    AbstractTypeMembersMustNotHaveBody = 82,
-    AbstractVariablesMustNotHaveInitializers = 83,
-    PackageIsAlreadyImportedInAnotherLanguage = 84,
-    OnlySubprogramsWithReturnTypeCanReturnValue = 85,
-    MethodsUsingYieldStatementCanNotReturnValue = 86,
-    YieldStatementCanNotBeUsedInAnonymousMethods = 87,
-    YieldStatementCanNotBeUsedHere = 88,
-    MethodsUsingYieldStatementMustHaveEnumerableAsReturnType = 89,
-    YieldStatementCanNotBeUsedInTryStatementThatHasCatchClause = 90,
-    YieldStatementCanNotBeUsedInFinallyClause = 91,
-    SubprogramMustReturnValue = 92,
-    ResultVariableCanNotBeUsedInMethodsUsingYieldStatement = 93,
-    TypeAliasReferencesItself = 94,
-    TypeParameterHasCircularConstraint = 95,
-    BaseTypeCausesInheritanceCycle = 96,
-    OnlyGenericTypesAndFunctionsCanBeSpecialized = 97,
-    Expected0TypeArguments = 98,
-    ExpectedFrom0To1TypeArguments = 99,
-    Type0IsNotAssignableToConstraint1 = 100,
-    VariableIsDeclaredButNotUsed = 101,
-    DefaultConstructorArgumentsMustBeNamed = 102,
-    IncorrectBodyOfRedefinableAliasTypeMethod = 103,
-    TheFollowingDeclarationsAreNotTranslated0 = 104,
-    TheFollowingDeclarationAreNotTranslated0And1More = 105,
-    OperatorMustNotBeStatic = 106,
-    Operator0MustNotHaveParameters = 107,
-    Operator0MustHaveOneParameter = 108,
-    Operator0MustHaveNoMoreThanOneParameter = 109,
-    CorrespondingRedefinableTypeMemberNotFound = 110,
-    ConstructorCanNotBeRedefinable = 111,
-    ConstructorCanNotBeRedefined = 112,
-    AsyncMethodCanOnlyBeCalledFromMethodMarkedWithAsyncModifier = 113,
-    TagNotFound = 114,
-    TypeOrMethodNameExpected = 115,
-    PackageNameOrAliasExpected = 116,
-    CanNotFindTsLibDirectoryBaseSearchPaths0 = 117,
-    SourceFile0IsNotPartOfThePackageAndWontBeLoaded = 118,
-    ProgramWithoutMainPackageCanNotBeCompiled = 119,
-    JsonConfigurationValidationError = 120,
-    StandardPackage0NotFound = 121,
-    Declaration0NotFoundInStandardPackage1 = 122
+    UnterminatedToken = 0,
+    UnterminatedMultiLineComment = 1,
+    UnterminatedNumber = 2,
+    UnterminatedTextOrTextTemplate = 3,
+    UnterminatedQuotedIdentifier = 4,
+    IdentifierExpected = 5,
+    TypeNameExpected = 6,
+    PackageNameExpected = 7,
+    TypeMemberDeclarationExpected = 8,
+    SourceFileMemberExpected = 9,
+    EnumerationVariableDeclarationExpected = 10,
+    StatementExpected = 11,
+    ExpressionExpected = 12,
+    BaseTypeNameExpected = 13,
+    TypeSpecifierExpected = 14,
+    TypeBodyExpected = 15,
+    MethodCallArgumentExpected = 16,
+    IndexedAccessArgumentExpected = 17,
+    TagArgumentExpected = 18,
+    TypeParameterExpected = 19,
+    ParameterExpected = 20,
+    RunStatementClauseExpected = 21,
+    CatchClauseOrFinallyClauseExpected = 22,
+    PackageImportExpected = 23,
+    UsingDirectiveOrSourceFileMemberExpected = 24,
+    TypeMemberTranslationExpected = 25,
+    TranslationExpected = 26,
+    Expected0But1Found = 27,
+    InvalidTextTemplateLiteral = 28,
+    RunKeywordCreationKeywordOrModifierListExpected = 29,
+    ModifierListExpected = 30,
+    HidingLevelExpected = 31,
+    ParameterNameCanContainOnlyOneBackQuote = 32,
+    FieldNameCanContainOnlyTwoBackQuote = 33,
+    BackQuotesCanOnlyBeUsedInParameterAndFieldNames = 34,
+    NameThatMatchesKeywordMustBeEnclosedInSingleQuotes = 35,
+    TagNameExpected = 36,
+    TypeCannotBeUsedAsValue = 37,
+    PackageMemberNotFound = 38,
+    TypeMemberNotFound = 39,
+    CannotAccessStaticMembersOnTypeParameter = 40,
+    IndexerOfTheSpecifiedTypeNotFound = 41,
+    DereferenceOperatorOfTheSpecifiedTypeNotFound = 42,
+    IndexerNotFound = 43,
+    CannotCreateInstanceOfAspect = 44,
+    CannotCreateInstanceOfTypeParameter = 45,
+    CannotCreateInstanceOfUnresolvedType = 46,
+    TypeConstructorNotFound = 47,
+    CannotInvokeExpression = 48,
+    NamedArgumentExpectedButPositionalArgumentFound = 49,
+    ParameterWithGivenNameNotFound = 50,
+    ArgumentForParameterAlreadyPassed = 51,
+    PackageAliasCannotBeUsedAsValue = 52,
+    PackageNameCannotBeUsedAsValue = 53,
+    UnknownVariable = 54,
+    UnknownType = 55,
+    TypeWithArity0NotFound = 56,
+    VariableUsedBeforeBeingDeclared = 57,
+    Type0IsNotAssignableToType1 = 58,
+    VariableNotFound = 59,
+    MethodNotFound = 60,
+    UnknownPackage = 61,
+    CannotAssignValueToExpression = 62,
+    NotEveryRequiredParameterIsProvidedWithArgument = 63,
+    ParameterForPositionalArgumentNotFound = 64,
+    CannotDetermineTargetTypeToCallTheConstructor = 65,
+    AmbiguousAccess = 66,
+    PackageNameConflictsWithDeclarationName = 67,
+    CanNotAssignValueToContextVariable = 68,
+    ExpectedPackageNameOrAliasButFoundType = 69,
+    TypeExpected = 70,
+    NameOfTypeOrPackageNotFound = 71,
+    TypeIsNotATag = 72,
+    ExpressionOfType0CanNotBeUsedForEnumeration = 73,
+    Operator0IsNotDefinedForTypes1And2 = 74,
+    Operator0IsNotDefinedForType1 = 75,
+    VariantMustHaveAssociatedValue = 76,
+    PackageMemberOrPackageNotFound = 77,
+    TranslationsCanOnlyBeDeclaredInTranslationPackage = 78,
+    UnknownTranslatedPackage0 = 79,
+    BaseCannotBeUsedInThisContext = 80,
+    OverriddenMethodNotFound = 81,
+    ObjectCannotBeUsedInThisContext = 82,
+    BaseCannotBeUsedAsAnExpressionInItself = 83,
+    InterfacePackageMustNotContainImplementation = 84,
+    InterfacePackageVariablesMustNotHaveInitializers = 85,
+    BodyIsMissing = 86,
+    AbstractTypeMembersMustNotHaveBody = 87,
+    AbstractVariablesMustNotHaveInitializers = 88,
+    PackageIsAlreadyImportedInAnotherLanguage = 89,
+    OnlySubprogramsWithReturnTypeCanReturnValue = 90,
+    MethodsUsingYieldStatementCanNotReturnValue = 91,
+    YieldStatementCanNotBeUsedInAnonymousMethods = 92,
+    YieldStatementCanNotBeUsedHere = 93,
+    MethodsUsingYieldStatementMustHaveEnumerableAsReturnType = 94,
+    YieldStatementCanNotBeUsedInTryStatementThatHasCatchClause = 95,
+    YieldStatementCanNotBeUsedInFinallyClause = 96,
+    SubprogramMustReturnValue = 97,
+    ResultVariableCanNotBeUsedInMethodsUsingYieldStatement = 98,
+    TypeAliasReferencesItself = 99,
+    TypeParameterHasCircularConstraint = 100,
+    BaseTypeCausesInheritanceCycle = 101,
+    OnlyGenericTypesAndFunctionsCanBeSpecialized = 102,
+    Expected0TypeArguments = 103,
+    ExpectedFrom0To1TypeArguments = 104,
+    Type0IsNotAssignableToConstraint1 = 105,
+    VariableIsDeclaredButNotUsed = 106,
+    DefaultConstructorArgumentsMustBeNamed = 107,
+    IncorrectBodyOfRedefinableAliasTypeMethod = 108,
+    TheFollowingDeclarationsAreNotTranslated0 = 109,
+    TheFollowingDeclarationAreNotTranslated0And1More = 110,
+    OperatorMustNotBeStatic = 111,
+    Operator0MustNotHaveParameters = 112,
+    Operator0MustHaveOneParameter = 113,
+    Operator0MustHaveNoMoreThanOneParameter = 114,
+    CorrespondingRedefinableTypeMemberNotFound = 115,
+    ConstructorCanNotBeRedefinable = 116,
+    ConstructorCanNotBeRedefined = 117,
+    AsyncMethodCanOnlyBeCalledFromMethodMarkedWithAsyncModifier = 118,
+    TagNotFound = 119,
+    TypeOrMethodNameExpected = 120,
+    PackageNameOrAliasExpected = 121,
+    ExpressionCanBeNone = 122,
+    NoneAwareAccessCanNotBeUsedOnTheLeftHandSideOfAssignmentStatement = 123,
+    UnreachableCode = 124,
+    CanNotFindTsLibDirectoryBaseSearchPaths0 = 125,
+    SourceFile0IsNotPartOfThePackageAndWontBeLoaded = 126,
+    ProgramWithoutMainPackageCanNotBeCompiled = 127,
+    JsonConfigurationValidationError = 128,
+    StandardPackage0NotFound = 129,
+    Declaration0NotFoundInStandardPackage1 = 130
 }

package/build/types/diagnostic/DiagnosticData.d.ts

@@ -16,5 +16,6 @@ export declare const enum DiagnosticKind {
 export declare const enum DiagnosticFlags {
     None = 0,
     Unused = 1,
-    Deprecated = 2
+    Unreachable = 2,
+    Deprecated = 4
 }