@artel/artc 0.6.25216 → 0.6.25218

package/build/types/services/NodeSemanticInfo.d.ts

@@ -1,10 +1,10 @@
 import { AccessedMethod } from '../analysis/AccessedMethod.js';
-import { MatchResultValueParameter } from '../analysis/CallArgumentToParameterMatchResult.js';
+import { MatchResultValueParameter } from '../analysis/ArgumentToParameterMatchResult.js';
 import { Translation, WithLocalization } from '../analysis/Localization.js';
 import { TypeIndexedAccessorDeclaration } from '../analysis/NodeTypeUtils.js';
 import { Analyzer } from '../analysis/index.js';
 import { AccessKind, ReadonlyNonEmptyArray } from '../common/index.js';
-import { AliasTypeEntity, Entity, MethodEntity, MethodTypeEntity, PackageAliasEntity, PackageEntity, StructuredTypeEntity, TypeParameterEntity, VariableEntity, VariantEntity, VariantTypeEntity } from '../entities/index.js';
+import { AliasTypeEntity, Entity, MethodEntity, MethodTypeEntity, PackageAliasEntity, PackageEntity, StructuredTypeEntity, TypeParameterEntity, VariableEntity, VariantTypeEntity } from '../entities/index.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
 import { TokenOrKeyword } from './TreeUtils.js';
@@ -14,6 +14,8 @@ export declare class NodeSemanticInfoService {
     static ofNonKeywordIdentifier(analyzer: Analyzer, node: tree.Identifier, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
     static ofProperty(analyzer: Analyzer, node: tree.PropertyAccessExpression, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
     static ofQualifiedNameQualifier(analyzer: Analyzer, node: tree.QualifiedName, qualifier: tree.Identifier, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
+    static ofNamedTypeSpecifierNameQualifier(analyzer: Analyzer, node: tree.NamedTypeSpecifier, qualifier: tree.Identifier, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
+    static ofTagNameQualifier(analyzer: Analyzer, node: tree.Tag, qualifier: tree.Identifier, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
     static ofIdentifierExpression(analyzer: Analyzer, node: tree.IdentifierExpression, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
     static ofTypeConstructorDeclaration(analyzer: Analyzer, node: tree.TypeConstructorDeclaration): NodeSemanticInfo;
     static ofTypeIndexerDeclaration(analyzer: Analyzer, node: TypeIndexedAccessorDeclaration): NodeSemanticInfo;
@@ -27,7 +29,7 @@ export declare class NodeSemanticInfoService {
     static ofObjectExpression(analyzer: Analyzer, node: tree.ObjectExpression, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
     static ofBaseExpression(analyzer: Analyzer, node: tree.BaseExpression, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
     private static ofPackageNameSegmentAccess;
-    private static ofMaybeConstructorCall;
+    private static ofMaybeConstructorCallExpression;
     private static getBetterReferenceTargetsOrPreserve;
     private static getBetterReferenceTarget;
     private static getContainingTranslationPackage;
@@ -58,7 +60,7 @@ export declare class EntityReferenceTarget {
     readonly kind = "entity";
     constructor(entity: ReferencedEntity, accessKind: AccessKind);
 }
-export type ReferencedEntity = VariableEntity | VariantEntity | VariantTypeEntity | MethodEntity | TypeParameterEntity | MethodTypeEntity | StructuredTypeEntity | PackageAliasEntity | AliasTypeEntity;
+export type ReferencedEntity = VariableEntity | VariantTypeEntity | MethodEntity | TypeParameterEntity | MethodTypeEntity | StructuredTypeEntity | PackageAliasEntity | AliasTypeEntity;
 export declare class TypeVariableReferenceTarget {
     readonly variable: types.Variable;
     readonly accessKind: AccessKind;
@@ -123,7 +125,7 @@ export declare class NameTranslationNodeSemanticInfo {
     get firstTarget(): TranslationTargetEntity;
     constructor(targets: ReadonlyNonEmptyArray<TranslationTargetEntity>, isAmbiguous: boolean, translation: Translation);
 }
-type TranslationTargetEntity = VariableEntity | VariantEntity | VariantTypeEntity | MethodEntity | TypeParameterEntity | MethodTypeEntity | StructuredTypeEntity | AliasTypeEntity;
+type TranslationTargetEntity = VariableEntity | VariantTypeEntity | MethodEntity | TypeParameterEntity | MethodTypeEntity | StructuredTypeEntity | AliasTypeEntity;
 export declare class DefaultSwitchMatchNodeSemanticInfo {
     readonly type: types.Type;
     readonly kind = "default-switch-match";

package/build/types/services/signature-help/SignatureWithValueParameters.d.ts

@@ -1,18 +1,16 @@
+import { AccessedMethod } from '../../analysis/AccessedMethod.js';
 import { Localization, WithLocalization } from '../../analysis/Localization.js';
-import { SubstitutedMethod } from '../../analysis/SubstitutedMethod.js';
 import { Analyzer } from '../../analysis/index.js';
 import { Name } from '../../common/index.js';
-import { MethodEntity, ParameterVariableEntity } from '../../entities/index.js';
+import { ParameterVariableEntity } from '../../entities/index.js';
 import * as tree from '../../tree/index.js';
 import * as types from '../../types/index.js';
 export declare class ValueArgumentFactory {
-    private static createValueArgumentFromCallArgument;
-    private static createValueArgumentFromIndexerArgument;
     static createValueArgumentsOfCallExpression(node: tree.CallExpression): ValueArgument[];
     static createValueArgumentsOfAutotypeCallExpression(node: tree.AutotypeCallExpression): ValueArgument[];
     static createValueArgumentsOfIndexedAccessExpression(node: tree.IndexedAccessExpression): ValueArgument[];
     static createValueArgumentsOfTag(node: tree.Tag): ValueArgument[];
-    private static createValueArgumentsFromListElement;
+    private static createValueArgumentsFromList;
 }
 export declare class SignatureForNode {
     static getSignaturesForNode(analyzer: Analyzer, node: NodeWithValueArguments): SignaturesWithSingleSuitable | undefined;
@@ -51,26 +49,12 @@ export declare class MatchedSignature {
     readonly matchResult: SimplifiedArgumentToParameterMatchResult;
     constructor(value: Signature, matchResult: SimplifiedArgumentToParameterMatchResult);
 }
-export type Signature = MethodEntitySignature | TypeMethodSignature | SubstitutedMethodSignature | MethodTypeSignature | ConstructorSignature | IndexerSignature;
-export declare class MethodEntitySignature implements ISignature {
-    readonly kind = "method-entity";
-    readonly method: WithLocalization<MethodEntity>;
+export type Signature = AccessedMethodSignature | MethodTypeSignature | ConstructorSignature | IndexerSignature;
+export declare class AccessedMethodSignature implements ISignature {
+    readonly kind = "accessed-method";
+    readonly method: WithLocalization<AccessedMethod>;
     private readonly _valueParameters;
-    constructor(method: WithLocalization<MethodEntity>);
-    getValueParameters(): readonly ValueParameter[];
-}
-export declare class TypeMethodSignature implements ISignature {
-    readonly kind = "type-method";
-    readonly method: WithLocalization<types.Method>;
-    private readonly _valueParameters;
-    constructor(method: WithLocalization<types.Method>);
-    getValueParameters(): readonly ValueParameter[];
-}
-export declare class SubstitutedMethodSignature implements ISignature {
-    readonly kind = "substituted-method";
-    readonly method: WithLocalization<SubstitutedMethod>;
-    private readonly _valueParameters;
-    constructor(method: WithLocalization<SubstitutedMethod>);
+    constructor(method: WithLocalization<AccessedMethod>);
     getValueParameters(): readonly ValueParameter[];
 }
 export declare class MethodTypeSignature implements ISignature {

package/build/types/services/signature-help/TypeParameterSignatureHelpProvider.d.ts

@@ -14,6 +14,7 @@ export declare class TypeParameterSignatureHelpProvider {
     private countArguments;
     private getSignaturesForNode;
     private getSignaturesForNamedTypeSpecifier;
+    private getSignaturesForTag;
     private getSignaturesForGenericSpecializationExpression;
     private getSignatureForSubstitutedMethod;
     private getSignatureForNamedType;

package/build/types/services/source-generation/EntityToSyntax.d.ts

@@ -10,6 +10,7 @@ export declare class EntityToSyntax {
     convert(): tree.SourceFile;
     private convertPackage;
     private convertNamedPackageMember;
+    private convertPackageType;
     private convertPackageVariable;
     private convertPackageMethod;
     private convertPackageStructuredType;
@@ -22,7 +23,6 @@ export declare class EntityToSyntax {
     private convertTypeConstructor;
     private convertTypeDestructor;
     private convertTypeIndexer;
-    private convertVariants;
     private convertVariant;
     private createStructuredTypeDeclarationBody;
     private createAliasTypeDeclarationBody;

package/build/types/services/source-generation/SourceGenerationService.d.ts

@@ -1,4 +1,4 @@
-import { ObservableObject } from 'reactronic';
+import { TriggeringObject } from 'reactronic';
 import { Analyzer } from '../../analysis/Analyzer.js';
 import { LocalizationContext } from '../../analysis/LocalizationContext.js';
 import { CancellationToken } from '../../common/index.js';
@@ -7,7 +7,7 @@ import { PackageContent } from '../../project/PackageContent.js';
 import { TypeScriptLibrariesProvider } from '../../ts-interop/TsLibrariesProvider.js';
 import { SourceLocation } from '../Types.js';
 import { CompilationController, ReadonlyClientTrackedSourceFiles } from '../workspace/index.js';
-export declare class SourceGenerationService extends ObservableObject {
+export declare class SourceGenerationService extends TriggeringObject {
     private readonly _trackedSourceFiles;
     private readonly _tsLibrariesProvider;
     private readonly _standardPackageContentsProviders;

package/build/types/services/workspace/ClientTrackedSourceFiles.d.ts

@@ -1,7 +1,7 @@
-import { ObservableMap, ObservableObject } from 'reactronic';
+import { TriggeringMap, TriggeringObject } from 'reactronic';
 import { Uri } from '../../common/index.js';
-export declare class ClientTrackedSourceFiles extends ObservableObject implements ReadonlyClientTrackedSourceFiles {
-    readonly items: ObservableMap<string, ClientTrackedSourceFile>;
+export declare class ClientTrackedSourceFiles extends TriggeringObject implements ReadonlyClientTrackedSourceFiles {
+    readonly items: TriggeringMap<string, ClientTrackedSourceFile>;
     get unsaved(): Map<string, ClientTrackedSourceFile>;
     track(uri: Uri, text: string, version: number): ClientTrackedSourceFile | undefined;
     update(uri: Uri, text: string, version: number): ClientTrackedSourceFile | undefined;
@@ -13,11 +13,11 @@ export declare class ClientTrackedSourceFiles extends ObservableObject implement
     dispose(): void;
 }
 export interface ReadonlyClientTrackedSourceFiles {
-    readonly items: ObservableMap<string, ReadonlyClientTrackedSourceFile>;
+    readonly items: TriggeringMap<string, ReadonlyClientTrackedSourceFile>;
     readonly unsaved: Map<string, ReadonlyClientTrackedSourceFile>;
     createItemsSnapshot(): Map<string, ClientTrackedSourceFileSnapshot>;
 }
-export declare class ClientTrackedSourceFile extends ObservableObject {
+export declare class ClientTrackedSourceFile extends TriggeringObject {
     readonly uri: Uri;
     text: string;
     version: number;

package/build/types/services/workspace/CompilationController.d.ts

@@ -1,4 +1,4 @@
-import { Indicator, ObservableObject } from 'reactronic';
+import { Indicator, TriggeringObject } from 'reactronic';
 import { Analyzer, TsInteropInputs } from '../../analysis/index.js';
 import { CancellationToken, Uri } from '../../common/index.js';
 import { Diagnostic } from '../../diagnostic/Diagnostic.js';
@@ -6,7 +6,7 @@ import { ConvertedConfiguration, ProgramPackageConfiguration, SourceFile, fsTree
 import { PackageContent } from '../../project/PackageContent.js';
 import { TypeScriptLibrariesProvider } from '../../ts-interop/TsLibrariesProvider.js';
 import { ReadonlyClientTrackedSourceFiles } from './ClientTrackedSourceFiles.js';
-export declare class CompilationController extends ObservableObject {
+export declare class CompilationController extends TriggeringObject {
     readonly mainCompilationReloadIndicator: Indicator;
     readonly configurationControllersUpdateIndictor: Indicator;
     private readonly _mainAnalyzerChangedIndicator;
@@ -100,7 +100,7 @@ export declare class DiagnosticsCollectionSummary {
     readonly hasErrors: boolean;
     constructor(hasErrors: boolean);
 }
-declare class ConfigurationController extends ObservableObject {
+declare class ConfigurationController extends TriggeringObject {
     readonly packageUri: Uri;
     readonly processingIndicator: Indicator;
     readonly rootDirectory: fsTree.Directory;

package/build/types/services/workspace/FileSystemTreeProviderBasedOnWatchedFileSystem.d.ts

@@ -1,12 +1,12 @@
-import { ObservableArray, ObservableMap, ObservableObject } from 'reactronic';
+import { TriggeringArray, TriggeringMap, TriggeringObject } from 'reactronic';
 import { CancellationToken, Uri } from '../../common/index.js';
 import * as fsTree from '../../project/FileSystemTree.js';
 import { ReadonlyClientTrackedSourceFiles } from './ClientTrackedSourceFiles.js';
 import { FileSystemTreeProvider } from './WorkspaceFiles.js';
 import type { WorkspaceFileSystem } from './WorkspaceFileSystem.js';
-export declare class FileSystemTreeProviderBasedOnWatchedFileSystem extends ObservableObject implements FileSystemTreeProvider {
+export declare class FileSystemTreeProviderBasedOnWatchedFileSystem extends TriggeringObject implements FileSystemTreeProvider {
     readonly fileSystemTree: fsTree.FileSystemTree;
-    readonly loadedWorkspaceFolderByUri: ObservableMap<string, fsTree.Directory>;
+    readonly loadedWorkspaceFolderByUri: TriggeringMap<string, fsTree.Directory>;
     private readonly _fileSystem;
     private readonly _notificationsPublisher;
     private readonly _listener;
@@ -24,7 +24,7 @@ export declare class FileSystemTreeProviderBasedOnWatchedFileSystem extends Obse
     private readonly _lastCheckedTrackedSourceFileInfoVersionByUri;
     private readonly _loadedDirectoryUris;
     constructor(fileSystem: WorkspaceFileSystem, notificationsPublisher: FileSystemUpdateNotificationsPublisher, namesOfDirectoriesToIgnore?: string[], additionalUrisOfDirectoriesToLoad?: readonly Uri[]);
-    initialize(workspaceFolderUris: ObservableArray<Uri>, trackedSourceFiles: ReadonlyClientTrackedSourceFiles): void;
+    initialize(workspaceFolderUris: TriggeringArray<Uri>, trackedSourceFiles: ReadonlyClientTrackedSourceFiles): void;
     waitLoaded(cancellationToken: CancellationToken | undefined): Promise<void>;
     dispose(): void;
     protected onTrackedSourceFilesUpdated(): void;

package/build/types/services/workspace/ManuallyUpdatedFileSystemTreeProvider.d.ts

@@ -1,17 +1,17 @@
-import { ObservableArray, ObservableMap, ObservableObject } from 'reactronic';
+import { TriggeringArray, TriggeringMap, TriggeringObject } from 'reactronic';
 import { CancellationToken } from '../../common/CancellationToken.js';
 import { Uri } from '../../common/Uri.js';
 import * as fsTree from '../../project/FileSystemTree.js';
 import { ReadonlyClientTrackedSourceFiles } from './ClientTrackedSourceFiles.js';
 import { FileSystemTreeProvider } from './WorkspaceFiles.js';
-export declare class ManuallyUpdatedFileSystemTreeProvider extends ObservableObject implements FileSystemTreeProvider {
+export declare class ManuallyUpdatedFileSystemTreeProvider extends TriggeringObject implements FileSystemTreeProvider {
     readonly fileSystemTree: fsTree.FileSystemTree;
-    readonly loadedWorkspaceFolderByUri: ObservableMap<string, fsTree.Directory>;
+    readonly loadedWorkspaceFolderByUri: TriggeringMap<string, fsTree.Directory>;
     private _workspaceFolderUris;
     private _trackedSourceFiles;
     private readonly _lastCheckedTrackedSourceFileInfoByUri;
     private readonly _manuallyCreatedSourceFileTextByUri;
-    initialize(workspaceFolderUris: ObservableArray<Uri>, trackedSourceFiles: ReadonlyClientTrackedSourceFiles): void;
+    initialize(workspaceFolderUris: TriggeringArray<Uri>, trackedSourceFiles: ReadonlyClientTrackedSourceFiles): void;
     waitLoaded(_cancellationToken: CancellationToken | undefined): Promise<void>;
     dispose(): void;
     createOrUpdateSourceFile(uri: Uri, text: string): void;

package/build/types/services/workspace/Workspace.d.ts

@@ -1,4 +1,4 @@
-import { ObservableMap, ObservableObject } from 'reactronic';
+import { TriggeringMap, TriggeringObject } from 'reactronic';
 import { Analyzer } from '../../analysis/index.js';
 import { CancellationToken, Uri } from '../../common/index.js';
 import * as fsTree from '../../project/FileSystemTree.js';
@@ -8,7 +8,7 @@ import { TypeScriptLibrariesProvider } from '../../ts-interop/TsLibrariesProvide
 import { ReadonlyClientTrackedSourceFiles } from './ClientTrackedSourceFiles.js';
 import { CompilationController, DiagnosticsCollectedInBackgroundHandler, RawPackageConfigurationsChangedHandler } from './CompilationController.js';
 import { FileSystemTreeProvider } from './WorkspaceFiles.js';
-export declare class Workspace extends ObservableObject {
+export declare class Workspace extends TriggeringObject {
     isReadyToAcceptWorkspaceDiagnostics: boolean;
     private readonly _config;
     private readonly _compilationControllers;
@@ -19,7 +19,7 @@ export declare class Workspace extends ObservableObject {
     private readonly _tsInteropInputsCache;
     get compilationControllers(): readonly CompilationController[];
     get trackedSourceFiles(): ReadonlyClientTrackedSourceFiles;
-    get loadedWorkspaceFolderByUri(): ObservableMap<string, fsTree.Directory>;
+    get loadedWorkspaceFolderByUri(): TriggeringMap<string, fsTree.Directory>;
     get workspaceFolderUris(): readonly Uri[];
     private get compilationControllerByUri();
     private constructor();

package/build/types/services/workspace/WorkspaceFiles.d.ts

@@ -1,15 +1,15 @@
-import { ObservableArray, ObservableMap, ObservableObject } from 'reactronic';
+import { TriggeringArray, TriggeringMap, TriggeringObject } from 'reactronic';
 import { CancellationToken, Uri } from '../../common/index.js';
 import * as fsTree from '../../project/FileSystemTree.js';
 import { ClientTrackedSourceFiles, ReadonlyClientTrackedSourceFiles } from './ClientTrackedSourceFiles.js';
-export declare class WorkspaceFiles extends ObservableObject {
+export declare class WorkspaceFiles extends TriggeringObject {
     readonly trackedSourceFiles: ClientTrackedSourceFiles;
-    readonly workspaceFolderUris: ObservableArray<Uri>;
-    readonly workspaceFolderWithArtelProjectByUri: ObservableMap<string, fsTree.Directory>;
+    readonly workspaceFolderUris: TriggeringArray<Uri>;
+    readonly workspaceFolderWithArtelProjectByUri: TriggeringMap<string, fsTree.Directory>;
     private readonly _fileSystemTreeProvider;
     get fileSystemTree(): fsTree.ReadonlyFileSystemTree;
     get isMissingConfigurationDirectoryAllowed(): boolean;
-    get loadedWorkspaceFolderByUri(): ObservableMap<string, fsTree.Directory>;
+    get loadedWorkspaceFolderByUri(): TriggeringMap<string, fsTree.Directory>;
     constructor(fileSystemTreeProvider: FileSystemTreeProvider);
     addWorkspaceFolders(uris: readonly Uri[]): void;
     removeWorkspaceFolders(uris: readonly Uri[]): void;
@@ -25,11 +25,11 @@ export declare class WorkspaceFiles extends ObservableObject {
 }
 export interface FileSystemTreeProvider {
     readonly fileSystemTree: fsTree.ReadonlyFileSystemTree;
-    readonly loadedWorkspaceFolderByUri: ObservableMap<string, fsTree.Directory>;
+    readonly loadedWorkspaceFolderByUri: TriggeringMap<string, fsTree.Directory>;
     /**
      * Должен быть вызван до вызова всех остальных методов.
      */
-    initialize(workspaceFolderUris: ObservableArray<Uri>, trackedSourceFiles: ReadonlyClientTrackedSourceFiles): void;
+    initialize(workspaceFolderUris: TriggeringArray<Uri>, trackedSourceFiles: ReadonlyClientTrackedSourceFiles): void;
     waitLoaded(cancellationToken: CancellationToken | undefined): Promise<void>;
     dispose(): void;
 }

package/build/types/tree/KeywordKind.d.ts

@@ -7,43 +7,43 @@ export declare enum KeywordKind {
     PlainObject = 5,
     Variant = 6,
     Run = 7,
-    From = 8,
-    Else = 9,
-    ElseIf = 10,
-    Function = 11,
-    If = 12,
-    Is = 13,
-    Return = 14,
-    Type = 15,
-    Basic = 16,
-    Import = 17,
-    Error = 18,
-    Finally = 19,
-    And = 20,
-    Or = 21,
-    Xor = 22,
-    While = 23,
-    Loop = 24,
-    RepeatWhile = 25,
-    Yield = 26,
-    When = 27,
-    Creation = 28,
-    OnError = 29,
-    BreakLoop = 30,
-    ContinueLoop = 31,
-    For = 32,
-    Const = 33,
-    Hidden = 34,
-    Abstract = 35,
-    Redefinable = 36,
-    Redefined = 37,
-    Async = 38,
-    Static = 39,
-    As = 40,
-    Not = 41,
-    Switch = 42,
-    Case = 43,
-    Await = 44,
+    Try = 8,
+    From = 9,
+    Else = 10,
+    ElseIf = 11,
+    Function = 12,
+    If = 13,
+    Is = 14,
+    Return = 15,
+    Type = 16,
+    Basic = 17,
+    Import = 18,
+    Error = 19,
+    Finally = 20,
+    And = 21,
+    Or = 22,
+    Xor = 23,
+    While = 24,
+    Loop = 25,
+    RepeatWhile = 26,
+    Yield = 27,
+    When = 28,
+    Creation = 29,
+    Catch = 30,
+    BreakLoop = 31,
+    ContinueLoop = 32,
+    For = 33,
+    Const = 34,
+    Hidden = 35,
+    Abstract = 36,
+    Redefinable = 37,
+    Redefined = 38,
+    Async = 39,
+    Static = 40,
+    As = 41,
+    Not = 42,
+    Switch = 43,
+    Case = 44,
     Dispose = 45,
     Destruction = 46,
     InHierarchy = 47,

package/build/types/tree/NodeKind.d.ts

@@ -67,39 +67,39 @@ export declare enum NodeKind {
     AsExpression = 65,
     BinaryExpression = 66,
     MethodBlockLiteral = 67,
-    CallArgumentList = 68,
+    ArgumentList = 68,
     CallExpression = 69,
     AutotypeCallExpression = 70,
-    IndexedAccessArgumentList = 71,
-    IndexedAccessExpression = 72,
-    InvalidExpression = 73,
-    IsExpression = 74,
-    MethodLiteral = 75,
-    ParenthesizedExpression = 76,
-    WhenTernaryExpression = 77,
-    PrefixUnaryExpression = 78,
-    PropertyAccessExpression = 79,
-    ReferenceExpression = 80,
-    DereferenceExpression = 81,
-    TextTemplateLiteral = 82,
-    TextTemplateSpanList = 83,
-    TextTemplateSpan = 84,
-    TokenExpression = 85,
-    KeywordExpression = 86,
-    ObjectExpression = 87,
-    BaseExpression = 88,
-    IdentifierExpression = 89,
-    GenericSpecializationExpression = 90,
-    DefaultMatchExpression = 91,
-    AssignmentStatement = 92,
-    StatementList = 93,
-    StatementBlock = 94,
-    BreakLoopStatement = 95,
-    ContinueLoopStatement = 96,
-    DisposeStatement = 97,
-    RunStatementClauseList = 98,
-    RunStatement = 99,
-    OnErrorClause = 100,
+    IndexedAccessExpression = 71,
+    InvalidExpression = 72,
+    IsExpression = 73,
+    MethodLiteral = 74,
+    ParenthesizedExpression = 75,
+    WhenTernaryExpression = 76,
+    PrefixUnaryExpression = 77,
+    PropertyAccessExpression = 78,
+    ReferenceExpression = 79,
+    DereferenceExpression = 80,
+    TextTemplateLiteral = 81,
+    TextTemplateSpanList = 82,
+    TextTemplateSpan = 83,
+    TokenExpression = 84,
+    KeywordExpression = 85,
+    ObjectExpression = 86,
+    BaseExpression = 87,
+    IdentifierExpression = 88,
+    GenericSpecializationExpression = 89,
+    DefaultMatchExpression = 90,
+    AssignmentStatement = 91,
+    StatementList = 92,
+    StatementBlock = 93,
+    BreakLoopStatement = 94,
+    ContinueLoopStatement = 95,
+    DisposeStatement = 96,
+    RunStatementClauseList = 97,
+    RunStatement = 98,
+    TryStatement = 99,
+    CatchClause = 100,
     ErrorVariableDeclaration = 101,
     FinallyClause = 102,
     EmptyStatement = 103,
@@ -142,18 +142,16 @@ export declare enum NodeKind {
     VariantDeclaration = 140,
     TypeParameterDeclaration = 141,
     ParameterDeclaration = 142,
-    CallArgument = 143,
+    Argument = 143,
     TagList = 144,
     Tag = 145,
     ModifierList = 146,
     Modifier = 147,
     ParameterClause = 148,
     ParameterList = 149,
-    SetterParameterClause = 150,
-    SetterParameterDeclaration = 151,
-    TypeArgumentClause = 152,
-    TypeArgumentList = 153,
-    TypeParameterClause = 154,
-    TypeParameterList = 155,
-    TypeAnnotation = 156
+    TypeArgumentClause = 150,
+    TypeArgumentList = 151,
+    TypeParameterClause = 152,
+    TypeParameterList = 153,
+    TypeAnnotation = 154
 }