@artel/artc 0.6.26039 → 0.9.26001

package/build/types/services/m/HoverService.d.ts

@@ -0,0 +1,11 @@
+import { Analyzer } from '../../analysis/Analyzer.js';
+import { Range } from '../../common/index.js';
+import { SourceFileM } from '../../project/index.js';
+import { HoverService } from '../common/hover/HoverService.js';
+import { NodeSemanticInfo } from '../common/node-semantic-info/Types.js';
+export declare class HoverServiceM extends HoverService<SourceFileM> {
+    protected getSemanticInfoAndRangeAtOffset(analyzer: Analyzer, sourceFile: SourceFileM, offset: number): {
+        semanticInfo: NodeSemanticInfo;
+        range: Range;
+    } | undefined;
+}

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

@@ -0,0 +1,46 @@
+import { Analyzer } from '../../analysis/m/Analyzer.js';
+import * as tree from '../../tree/m/index.js';
+import { TokenOrKeyword } from '../m/TreeUtils.js';
+import { NodeSemanticInfo } from '../common/node-semantic-info/Types.js';
+export declare class NodeSemanticInfoServiceM {
+    static ofTokenOrKeyword(analyzer: Analyzer, tokenOrKeyword: TokenOrKeyword, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
+    static ofRegularOrBlockFunctionLiteral(analyzer: Analyzer, node: tree.RegularOrBlockFunctionLiteral): NodeSemanticInfo | undefined;
+    static ofDefaultMatchExpression(analyzer: Analyzer, node: tree.DefaultMatchExpression): NodeSemanticInfo | undefined;
+    static ofNonKeywordIdentifier(analyzer: Analyzer, node: tree.Identifier, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
+    static ofPackageNameQualifier(analyzer: Analyzer, node: tree.PackageName, qualifier: tree.Identifier, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
+    static ofMember(analyzer: Analyzer, node: tree.MemberAccessExpression, 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 ofStaticNameClause(analyzer: Analyzer, node: tree.StaticNameClause, 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 ofIndexedElementAccessorDeclaration(analyzer: Analyzer, node: tree.IndexedElementAccessorDeclaration): NodeSemanticInfo;
+    static ofIndexedAccessExpressionOperator(analyzer: Analyzer, node: tree.IndexedAccessExpression, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
+    static ofAssignmentStatementOperator(analyzer: Analyzer, node: tree.AssignmentStatement, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
+    static ofBinaryExpressionOperator(analyzer: Analyzer, node: tree.BinaryExpression, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
+    static ofPrefixUnaryExpressionOperator(analyzer: Analyzer, node: tree.PrefixUnaryExpression, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
+    static ofObjectExpression(analyzer: Analyzer, node: tree.ObjectExpression, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
+    static ofBaseExpression(analyzer: Analyzer, node: tree.BaseExpression, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
+    static ofIndexerTranslationSourceIndexer(analyzer: Analyzer, node: tree.IndexerTranslation, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
+    static ofIndexerTranslationTranslatedIndexer(analyzer: Analyzer, node: tree.IndexerTranslation, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
+    static ofObjectParameterDeclaration(analyzer: Analyzer, node: tree.ParameterDeclaration, _objectKeyword: tree.Keyword<tree.KeywordKind.Object>): NodeSemanticInfo;
+    private static ofPackageNameSegmentAccess;
+    private static ofConstructorCallWithTypeAccess;
+    private static ofTranslationTypeParameterListParameter;
+    private static ofTranslationParameterListParameter;
+    private static getBetterReferenceTargetsOrPreserve;
+    private static getBetterReferenceTargets;
+    private static getResolvedContainingTranslationPackage;
+    private static ofAccessedFunctions;
+    private static ofConstructors;
+}
+export type NodeSemanticInfoServiceOptions = {
+    readonly preferredTargetOfExplicitConstructorCall: 'type-declaration' | 'constructor-declaration';
+    readonly includeBetterReferenceTargets: boolean;
+    /**
+     * Для всех сегментов имени пакета `NodeSemanticInfoService` возвращает одинаковую семантическую информацию - ссылку
+     * на пакет (`PackageEntity`). Если флаг установлен, сервис вернёт семантическую информацию только для последнего
+     * сегмента, чтобы учесть имя при поиске ссылок только один раз.
+     */
+    readonly isForReferencesSearch: boolean;
+};

package/build/types/services/m/RenameService.d.ts

@@ -0,0 +1,11 @@
+import { Analyzer } from '../../analysis/Analyzer.js';
+import { Range } from '../../common/index.js';
+import { SourceFileM } from '../../project/index.js';
+import { NodeSemanticInfo } from '../common/node-semantic-info/Types.js';
+import { RenameService } from '../common/rename/RenameService.js';
+export declare class RenameServiceM extends RenameService<SourceFileM> {
+    protected getSemanticInfoAndRangeOffset(analyzer: Analyzer, sourceFile: SourceFileM, offset: number): {
+        semanticInfo: NodeSemanticInfo;
+        range: Range;
+    } | undefined;
+}

package/build/types/services/m/SelectionRangeService.d.ts

@@ -0,0 +1,7 @@
+import { SourceFileM } from '../../project/SourceFile.js';
+import { SelectionRange } from '../common/selection-rage/Types.js';
+export declare class SelectionRangeServiceM {
+    getSelectionRange(sourceFile: SourceFileM, offset: number): SelectionRange | undefined;
+    private nodeContainsOffset;
+    private nodeShouldBeSkipped;
+}

package/build/types/services/m/SemanticTokensService.d.ts

@@ -0,0 +1,11 @@
+import { Analyzer } from '../../analysis/m/Analyzer.js';
+import { Range, TaskController } from '../../common/index.js';
+import { SourceFileM } from '../../project/index.js';
+import { SemanticToken } from '../common/semantic-tokens/Types.js';
+export declare class SemanticTokensServiceM {
+    getSemanticTokens(analyzer: Analyzer, sourceFile: SourceFileM, taskController: TaskController): Promise<SemanticToken[]>;
+    getSemanticTokensInRange(analyzer: Analyzer, sourceFile: SourceFileM, range: Range, taskController: TaskController): Promise<SemanticToken[]>;
+    private rangesOverlap;
+    private getSemanticTokenKindForNamedFunctionEntity;
+    private isCapitalizedName;
+}

package/build/types/services/m/SourceFileItemsService.d.ts

@@ -0,0 +1,10 @@
+import { SourceFileM } from '../../project/index.js';
+import { SourceFileItem } from '../common/source-file-items/Types.js';
+export declare class SourceFileItemsServiceM {
+    private sourceFile;
+    getItems(sourceFile: SourceFileM): SourceFileItem[];
+    private get locale();
+    private getChildItems;
+    private createItem;
+    private getNameOrStubIfEmpty;
+}

package/build/types/services/m/TranslationService.d.ts

@@ -0,0 +1,23 @@
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { Analyzer } from '../../analysis/m/Analyzer.js';
+import { Range } from '../../common/index.js';
+import { SourceFileM } from '../../project/index.js';
+export declare class TranslationService {
+    private readonly translationCache;
+    constructor();
+    translateSourceFile(analyzer: Analyzer, sourceFile: SourceFileM, localeText: string): Translation;
+    clearTranslationCache(): void;
+    private translateIdentifier;
+    private translateKeywords;
+    private translateReservedName;
+    private createRangeMaps;
+    private getTranslationId;
+}
+export type Translation = {
+    translatedDocument: TextDocument;
+    rangeMaps: RangeMap[];
+};
+export type RangeMap = {
+    sourceRange: Range;
+    translationRange: Range;
+};

package/build/types/services/m/TranslationsGenerationService.d.ts

@@ -0,0 +1,7 @@
+import { Analyzer } from '../../analysis/m/Analyzer.js';
+import { SourceFileM } from '../../project/SourceFile.js';
+import { SourceFileEdit } from '../common/Types.js';
+export declare class TranslationsGenerationServiceM {
+    generateMissingTranslations(analyzer: Analyzer, sourceFile: SourceFileM, offset: number, onlyTypeMembers: boolean): SourceFileEdit[] | undefined;
+    isOffsetAtTranslationsContainingPartiallyTranslatedTypes(analyzer: Analyzer, sourceFile: SourceFileM, offset: number): boolean;
+}

package/build/types/services/m/TreeUtils.d.ts

@@ -0,0 +1,58 @@
+import * as tree from '../../tree/m/index.js';
+/**
+ * Получить самый правый токен, для которого `rangeWithoutTrivia.end <= offset`.
+ */
+export declare function getPrecedingToken(sourceFile: tree.SourceFile, offset: number): tree.Token | undefined;
+/**
+ * Возвращает токен, для которого `offset >= range.start` и `offset < range.end`,
+ * или токен конца файла (`TokenKind.EndOfFile`) если смещение находится в конце файла.
+ */
+export declare function getTokenAtOffset(sourceFile: tree.SourceFile, offset: number, searchInTrivia: boolean): tree.Token | undefined;
+/**
+ * Возвращает не пустой токен или ключевое слово, для которых `offset >= rangeWithoutTrivia.start` и `offset <= rangeWithoutTrivia.end`.
+ *
+ * Если смещение находится между двумя токенами / ключевыми словами (например а|.б), то возвращаются оба.
+ */
+export declare function getTokenOrKeywordsTouchingOffset(sourceFile: tree.SourceFile, offset: number): TokenOrKeywordsTouchingOffset;
+export declare class TokenOrKeyword {
+    readonly value: tree.Token | tree.Keyword;
+    get parent(): tree.Node;
+    constructor(value: tree.Token | tree.Keyword);
+    isToken<T extends tree.TokenKind>(kind?: T): this is TokenOrKeyword & {
+        value: tree.Token<T>;
+    };
+    isKeyword<T extends tree.KeywordKind>(kind?: T): this is TokenOrKeyword & {
+        value: tree.Keyword<T>;
+    };
+    equals(other: TokenOrKeyword): boolean;
+}
+export type TokenOrKeywordsTouchingOffset = TokenOrKeywordsTouchingOffset_none | TokenOrKeywordsTouchingOffset_single | TokenOrKeywordsTouchingOffset_two;
+export declare class TokenOrKeywordsTouchingOffset_none implements ITokenOrKeywordsTouchingOffset {
+    readonly kind = "none";
+    getSinglePrioritizingNamed(): TokenOrKeyword | undefined;
+    getSingleWithHighestPriority(_getPriority: (token: TokenOrKeyword) => number): TokenOrKeyword | undefined;
+}
+export declare class TokenOrKeywordsTouchingOffset_single implements ITokenOrKeywordsTouchingOffset {
+    readonly value: TokenOrKeyword;
+    readonly kind = "single";
+    constructor(value: TokenOrKeyword);
+    getSinglePrioritizingNamed(): TokenOrKeyword | undefined;
+    getSingleWithHighestPriority(_getPriority: (token: TokenOrKeyword) => number): TokenOrKeyword | undefined;
+}
+export declare class TokenOrKeywordsTouchingOffset_two implements ITokenOrKeywordsTouchingOffset {
+    readonly left: TokenOrKeyword;
+    readonly right: TokenOrKeyword;
+    readonly kind = "two";
+    constructor(left: TokenOrKeyword, right: TokenOrKeyword);
+    getSinglePrioritizingNamed(): TokenOrKeyword | undefined;
+    getSingleWithHighestPriority(getPriority: (token: TokenOrKeyword) => number): TokenOrKeyword | undefined;
+}
+interface ITokenOrKeywordsTouchingOffset {
+    getSinglePrioritizingNamed(): TokenOrKeyword | undefined;
+    getSingleWithHighestPriority(getPriority: (token: TokenOrKeyword) => number): TokenOrKeyword | undefined;
+}
+/**
+ * Возвращает trivia, для которого `offset >= range.start` и `offset < range.end`.
+ */
+export declare function getTriviaAtOffset(sourceFile: tree.SourceFile, offset: number): tree.TokenTrivia | undefined;
+export {};

package/build/types/services/m/references/DefinitionInfoFinder.d.ts

@@ -0,0 +1,6 @@
+import { Analyzer } from '../../../analysis/Analyzer.js';
+import { SourceFileM } from '../../../project/index.js';
+import { DefinitionInfo, ReferencesSearchOptions } from '../../common/references/Types.js';
+export declare class DefinitionInfoFinderM {
+    static getReferencedDefinitionInfosAtOffsetM(analyzer: Analyzer, sourceFile: SourceFileM, offset: number, options: ReferencesSearchOptions): DefinitionInfo[];
+}

package/build/types/services/m/references/ReferencesFinder.d.ts

@@ -0,0 +1,7 @@
+import { TaskController } from '../../../common/index.js';
+import { SourceFileM } from '../../../project/SourceFile.js';
+import { ReferencesFinder } from '../../common/references/ReferencesFinder.js';
+import { Reference } from '../../common/references/Types.js';
+export declare class ReferencesFinderM extends ReferencesFinder {
+    findReferencesInSourceFileM(sourceFile: SourceFileM, result: Reference[], taskController: TaskController): Promise<void>;
+}

package/build/types/services/m/signature-help/ParametersSignatureHelpProvider.d.ts

@@ -0,0 +1,15 @@
+import { Analyzer } from '../../../analysis/m/Analyzer.js';
+import { SourceFileM } from '../../../project/index.js';
+import { SignatureHelp } from '../../common/signature-help/Types.js';
+export declare class ParametersSignatureHelpProvider {
+    private readonly signatureContext_;
+    private readonly analyzer;
+    private readonly sourceFile;
+    private readonly offset;
+    private get signatureContext();
+    constructor(analyzer: Analyzer, sourceFile: SourceFileM, offset: number);
+    provideSignatureHelp(): SignatureHelp | undefined;
+    private getNodeWithArgumentsInfoAtOffset;
+    private getArgumentIndexInList;
+    private getSignatureDisplayParts;
+}

package/build/types/services/m/signature-help/SignatureHelpService.d.ts

@@ -0,0 +1,6 @@
+import { Analyzer } from '../../../analysis/m/Analyzer.js';
+import { SourceFileM } from '../../../project/index.js';
+import { SignatureHelp } from '../../common/signature-help/Types.js';
+export declare class SignatureHelpServiceM {
+    getSignatureHelp(analyzer: Analyzer, sourceFile: SourceFileM, offset: number): SignatureHelp | undefined;
+}

package/build/types/services/m/signature-help/SignatureWithParameters.d.ts

@@ -0,0 +1,94 @@
+import { AccessedFunction } from '../../../analysis/AccessedFunction.js';
+import { Analyzer } from '../../../analysis/m/Analyzer.js';
+import { Name } from '../../../common/index.js';
+import { ParameterEntity } from '../../../entities/index.js';
+import * as tree from '../../../tree/m/index.js';
+import * as types from '../../../types/index.js';
+export declare class ArgumentFactory {
+    static createArgumentsOfCallExpression(node: tree.CallExpression): Argument[];
+    static createArgumentsOfIndexedAccessExpression(node: tree.IndexedAccessExpression): Argument[];
+    static createArgumentsOfTag(node: tree.Tag): Argument[];
+    private static createArgumentsFromList;
+}
+export declare class SignatureForNode {
+    static getSignaturesForNode(analyzer: Analyzer, node: NodeWithArguments): SignaturesWithSingleSuitable | undefined;
+    static getSignaturesForCallExpression(analyzer: Analyzer, node: tree.CallExpression): SignaturesWithSingleSuitable | undefined;
+    static getSignaturesForIndexedAccessExpression(analyzer: Analyzer, node: tree.IndexedAccessExpression): SignaturesWithSingleSuitable | undefined;
+    static getSignaturesForTag(analyzer: Analyzer, node: tree.Tag): SignaturesWithSingleSuitable | undefined;
+    private static getSignaturesOfConstructors;
+}
+export declare class SimplifiedArgumentToParameterMatcher {
+    static match(analyzer: Analyzer, arguments_: readonly Argument[], signature: Signature): SimplifiedArgumentToParameterMatchResult;
+}
+export declare class SimplifiedArgumentToParameterMatchResult {
+    readonly arguments: readonly Argument[];
+    readonly parameterByArgumentIndex: ReadonlyArray<Parameter | undefined>;
+    private readonly parameterByArgument_;
+    get parameterByArgument(): ReadonlyMap<Argument, Parameter>;
+    constructor(arguments_: readonly Argument[], parameterByArgumentIndex: ReadonlyArray<Parameter | undefined>);
+}
+export declare class SimplifiedOverloadResolver {
+    static isSuitableSignature(analyzer: Analyzer, matchedSignature: MatchedSignature, args: readonly Argument[]): boolean;
+    static getMostSuitableSignatureIndex(analyzer: Analyzer, matchedSignatures: readonly MatchedSignature[], args: readonly Argument[]): number;
+}
+export type NodeWithArguments = tree.CallExpression | tree.IndexedAccessExpression | tree.Tag;
+export declare class Argument {
+    readonly name: string | undefined;
+    readonly expression: tree.Expression | undefined;
+    constructor(name: string | undefined, expression: tree.Expression | undefined);
+}
+export declare class SignaturesWithSingleSuitable {
+    readonly values: readonly Signature[];
+    readonly suitableSignatureIndex: number | undefined;
+    constructor(values: readonly Signature[], suitableSignatureIndex: number | undefined);
+}
+export declare class MatchedSignature {
+    readonly value: Signature;
+    readonly matchResult: SimplifiedArgumentToParameterMatchResult;
+    constructor(value: Signature, matchResult: SimplifiedArgumentToParameterMatchResult);
+}
+export type Signature = AccessedFunctionSignature | FunctionTypeSignature | ConstructorSignature | IndexerSignature;
+export declare class AccessedFunctionSignature implements ISignature {
+    readonly kind = "accessed-function";
+    readonly func: AccessedFunction;
+    private readonly parameters;
+    constructor(func: AccessedFunction);
+    getParameters(): readonly Parameter[];
+}
+export declare class FunctionTypeSignature implements ISignature {
+    readonly kind = "function-type";
+    readonly functionType: types.FunctionType;
+    private readonly parameters;
+    constructor(functionType: types.FunctionType);
+    getParameters(): readonly Parameter[];
+}
+export declare class ConstructorSignature implements ISignature {
+    readonly kind = "constructor";
+    readonly constructor_: types.Method;
+    private readonly parameters;
+    constructor(constructor_: types.Method);
+    getParameters(): readonly Parameter[];
+}
+export declare class IndexerSignature implements ISignature {
+    readonly kind = "indexer";
+    readonly indexer: types.Indexer;
+    private readonly parameters;
+    constructor(indexer: types.Indexer);
+    getParameters(): readonly Parameter[];
+}
+interface ISignature {
+    getParameters(): readonly Parameter[];
+}
+export type Parameter = UniversalParameter;
+export declare class UniversalParameter implements IParameter {
+    readonly type: types.Type;
+    readonly entity: ParameterEntity;
+    constructor(type: types.Type, entity: ParameterEntity);
+    getName(): Name;
+    getType(): types.Type;
+}
+interface IParameter {
+    getName(): Name;
+    getType(): types.Type;
+}
+export {};

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

@@ -0,0 +1,21 @@
+import { Analyzer } from '../../../analysis/m/Analyzer.js';
+import { SourceFileM } from '../../../project/index.js';
+import { SignatureHelp } from '../../common/signature-help/Types.js';
+export declare class TypeParameterSignatureHelpProvider {
+    private readonly signatureContext_;
+    private readonly analyzer;
+    private readonly sourceFile;
+    private readonly offset;
+    private get signatureContext();
+    constructor(analyzer: Analyzer, sourceFile: SourceFileM, offset: number);
+    provideSignatureHelp(): SignatureHelp | undefined;
+    private getNodeWithTypeArgumentsInfoAtOffset;
+    private getArgumentIndex;
+    private countArguments;
+    private getSignaturesForNode;
+    private getSignaturesForNamedTypeSpecifier;
+    private getSignaturesForTag;
+    private getSignaturesForGenericSpecializationExpression;
+    private getSignatureForAccessedFunction;
+    private getSignatureForNamedType;
+}

package/build/types/services/m/signature-help/utils.d.ts

@@ -0,0 +1,9 @@
+import { SignatureInfo } from '../../common/signature-help/Types.js';
+export declare class SignatureDisplayParts {
+    readonly prefix: string;
+    readonly parameters: readonly string[];
+    readonly parameterSeparator: string;
+    readonly postfix: string;
+    constructor(prefix: string, parameters: readonly string[], parameterSeparator: string, postfix: string);
+}
+export declare function convertSignatureDisplayPartsToSignatureInfo(displayParts: SignatureDisplayParts, activeParameterIndex: number): SignatureInfo;

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

@@ -62,7 +62,5 @@ export declare enum KeywordKind {
     Base = 60,
     Null = 61,
     Get = 62,
-    Set = 63,
-    LoopWhile = 64,
-    Over = 65
+    Set = 63
 }

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

@@ -47,118 +47,117 @@ export declare enum NodeKind {
     DereferencedVariableGetterDeclaration = 45,
     DereferencedVariableSetterDeclaration = 46,
     MethodDeclaration = 47,
-    OperatorDeclaration = 48,
-    FieldDeclaration = 49,
-    FieldGetterDeclaration = 50,
-    FieldSetterDeclaration = 51,
-    MissingTypeMemberDeclaration = 52,
-    NestedFunctionDeclaration = 53,
-    LocalVariableDeclaration = 54,
-    ForStatementVariableDeclaration = 55,
-    ArrayLiteral = 56,
-    ArrayLiteralElementList = 57,
-    AssertionExpression = 58,
-    AssumptionExpression = 59,
-    AsExpression = 60,
-    BinaryExpression = 61,
-    FunctionLiteral = 62,
-    FunctionBlockLiteral = 63,
-    ArgumentList = 64,
-    CallExpression = 65,
-    AutotypeCallExpression = 66,
-    IndexedAccessExpression = 67,
-    MissingExpression = 68,
-    IsExpression = 69,
-    ParenthesizedExpression = 70,
-    ConditionalExpression = 71,
-    PrefixUnaryExpression = 72,
-    MemberAccessExpression = 73,
-    ReferenceExpression = 74,
-    DereferenceExpression = 75,
-    TextTemplateLiteral = 76,
-    LocalizableTextTemplateLiteral = 77,
-    TextTemplateSpanList = 78,
-    TextTemplateSpan = 79,
-    TokenExpression = 80,
-    TextLiteral = 81,
-    LocalizableTextLiteral = 82,
-    KeywordExpression = 83,
-    ObjectExpression = 84,
-    BaseExpression = 85,
-    IdentifierExpression = 86,
-    GenericSpecializationExpression = 87,
-    DefaultMatchExpression = 88,
-    OwnConstructorCallExpression = 89,
-    AssignmentStatement = 90,
-    StatementList = 91,
-    StatementBlock = 92,
-    FunctionBlock = 93,
-    BreakLoopStatement = 94,
-    ContinueLoopStatement = 95,
-    DisposeStatement = 96,
-    RunStatement = 97,
-    TryStatement = 98,
-    CatchClause = 99,
-    ErrorVariableDeclaration = 100,
-    FinallyClause = 101,
-    ErrorStatement = 102,
-    ImportantStatement = 103,
-    ExpressionStatement = 104,
-    ForStatement = 105,
-    IfStatement = 106,
-    ElseIfClauseList = 107,
-    ElseIfClause = 108,
-    ElseClause = 109,
-    MissingStatement = 110,
-    NestedFunctionDeclarationStatement = 111,
-    LocalVariableDeclarationStatement = 112,
-    LoopStatement = 113,
-    ReturnStatement = 114,
-    CaseClauseList = 115,
-    SwitchStatement = 116,
-    MatchExpressionList = 117,
-    CaseClause = 118,
-    WhileStatement = 119,
-    YieldStatement = 120,
-    TranslationsDeclaration = 121,
-    TopLevelTranslationList = 122,
-    TranslationParameterList = 123,
-    TranslationParameterClause = 124,
-    ConstructorTranslation = 125,
-    IndexParameterTranslationClause = 126,
-    IndexerTranslation = 127,
-    TranslationTypeParameterList = 128,
-    TranslationTypeParameterClause = 129,
-    PackageFunctionTranslationDeclaration = 130,
-    MethodTranslation = 131,
-    FunctionTypeTranslationDeclaration = 132,
-    QualifiedName = 133,
-    PackageVariableTranslationDeclaration = 134,
-    FieldOrVariantTranslation = 135,
-    TypeMemberTranslationList = 136,
-    TypeTranslationDeclaration = 137,
-    TextTranslationDeclaration = 138,
-    TextTranslationFunctionDeclaration = 139,
-    TranslationTextLiteral = 140,
-    TranslationTextTemplate = 141,
-    TranslationTextTemplateSpanList = 142,
-    TranslationTextTemplateSpan = 143,
-    TranslationTextTemplateParameter = 144,
-    VariantValueDeclaration = 145,
-    TypeParameterDeclaration = 146,
-    ParameterDeclaration = 147,
-    Argument = 148,
-    TagList = 149,
-    Tag = 150,
-    ModifierList = 151,
-    Modifier = 152,
-    ParameterClause = 153,
-    ParameterList = 154,
-    TypeArgumentClause = 155,
-    TypeArgumentList = 156,
-    TypeParameterClause = 157,
-    TypeParameterList = 158,
-    TypeAnnotation = 159,
-    ExtendsClause = 160,
-    ReducesClause = 161
+    FieldDeclaration = 48,
+    FieldGetterDeclaration = 49,
+    FieldSetterDeclaration = 50,
+    MissingTypeMemberDeclaration = 51,
+    NestedFunctionDeclaration = 52,
+    LocalVariableDeclaration = 53,
+    ForStatementVariableDeclaration = 54,
+    ArrayLiteral = 55,
+    ArrayLiteralElementList = 56,
+    AssertionExpression = 57,
+    AssumptionExpression = 58,
+    AsExpression = 59,
+    BinaryExpression = 60,
+    FunctionLiteral = 61,
+    FunctionBlockLiteral = 62,
+    ArgumentList = 63,
+    CallExpression = 64,
+    AutotypeCallExpression = 65,
+    IndexedAccessExpression = 66,
+    MissingExpression = 67,
+    IsExpression = 68,
+    ParenthesizedExpression = 69,
+    ConditionalExpression = 70,
+    PrefixUnaryExpression = 71,
+    MemberAccessExpression = 72,
+    ReferenceExpression = 73,
+    DereferenceExpression = 74,
+    TextTemplateLiteral = 75,
+    LocalizableTextTemplateLiteral = 76,
+    TextTemplateSpanList = 77,
+    TextTemplateSpan = 78,
+    TokenExpression = 79,
+    TextLiteral = 80,
+    LocalizableTextLiteral = 81,
+    KeywordExpression = 82,
+    ObjectExpression = 83,
+    BaseExpression = 84,
+    IdentifierExpression = 85,
+    GenericSpecializationExpression = 86,
+    DefaultMatchExpression = 87,
+    OwnConstructorCallExpression = 88,
+    AssignmentStatement = 89,
+    StatementList = 90,
+    StatementBlock = 91,
+    FunctionBlock = 92,
+    BreakLoopStatement = 93,
+    ContinueLoopStatement = 94,
+    DisposeStatement = 95,
+    RunStatement = 96,
+    TryStatement = 97,
+    CatchClause = 98,
+    ErrorVariableDeclaration = 99,
+    FinallyClause = 100,
+    ErrorStatement = 101,
+    ImportantStatement = 102,
+    ExpressionStatement = 103,
+    ForStatement = 104,
+    IfStatement = 105,
+    ElseIfClauseList = 106,
+    ElseIfClause = 107,
+    ElseClause = 108,
+    MissingStatement = 109,
+    NestedFunctionDeclarationStatement = 110,
+    LocalVariableDeclarationStatement = 111,
+    LoopStatement = 112,
+    ReturnStatement = 113,
+    CaseClauseList = 114,
+    SwitchStatement = 115,
+    MatchExpressionList = 116,
+    CaseClause = 117,
+    WhileStatement = 118,
+    YieldStatement = 119,
+    TranslationsDeclaration = 120,
+    TopLevelTranslationList = 121,
+    TranslationParameterList = 122,
+    TranslationParameterClause = 123,
+    ConstructorTranslation = 124,
+    IndexParameterTranslationClause = 125,
+    IndexerTranslation = 126,
+    TranslationTypeParameterList = 127,
+    TranslationTypeParameterClause = 128,
+    PackageFunctionTranslationDeclaration = 129,
+    MethodTranslation = 130,
+    FunctionTypeTranslationDeclaration = 131,
+    QualifiedName = 132,
+    PackageVariableTranslationDeclaration = 133,
+    FieldOrVariantTranslation = 134,
+    TypeMemberTranslationList = 135,
+    TypeTranslationDeclaration = 136,
+    TextTranslationDeclaration = 137,
+    TextTranslationFunctionDeclaration = 138,
+    TranslationTextLiteral = 139,
+    TranslationTextTemplate = 140,
+    TranslationTextTemplateSpanList = 141,
+    TranslationTextTemplateSpan = 142,
+    TranslationTextTemplateParameter = 143,
+    VariantValueDeclaration = 144,
+    TypeParameterDeclaration = 145,
+    ParameterDeclaration = 146,
+    Argument = 147,
+    TagList = 148,
+    Tag = 149,
+    ModifierList = 150,
+    Modifier = 151,
+    ParameterClause = 152,
+    ParameterList = 153,
+    TypeArgumentClause = 154,
+    TypeArgumentList = 155,
+    TypeParameterClause = 156,
+    TypeParameterList = 157,
+    TypeAnnotation = 158,
+    ExtendsClause = 159,
+    ReducesClause = 160
 }