@artel/artc 0.6.25229 → 0.6.25231

package/build/{chunk-2FHW6RUS.js → chunk-VQ5GGKF7.js}

@@ -10,7 +10,7 @@ import {
   WellKnownDeclarationsLoadError,
   __async,
   createTsInteropInputsForCompilation
-} from "./chunk-6YPLDA76.js";
+} from "./chunk-S7CAJWX2.js";
 
 // source/executor/Compiler.ts
 var Compiler = class {

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

@@ -24,6 +24,7 @@ import * as constructorOverloadResolver from './ConstructorOverloadResolver.js';
 import { DeclarationsUsageCountResult } from './DeclarationsUsageCounter.js';
 import * as dereferenceExpressionMeaning from './DereferenceExpressionMeaning.js';
 import { FoundAnonymousDeclaration } from './FoundDeclaration.js';
+import * as functionOverloadResolver from './FunctionOverloadResolver.js';
 import * as identifierExpressionResolution from './IdentifierExpressionMeaning.js';
 import { ImportedPackageNameTree, PackageNameTreeNode } from './ImportedPackageNameTree.js';
 import * as indexedAccessExpressionMeaning from './IndexedAccessExpressionMeaning.js';
@@ -34,7 +35,6 @@ import { ModifierFlags } from './ModifierFlags.js';
 import { NamedTypeSpecifierResolutionResult } from './NamedTypeSpecifierResolver.js';
 import { DereferencedVariableAccessorDeclaration, FieldAccessorDeclaration, FunctionTypeDeclaration, GetterDeclaration, IndexedElementAccessorDeclaration, PackageVariableAccessorDeclaration, SetterDeclaration, StructuredTypeDeclaration, VariantTypeDeclaration } from './NodeTypeUtils.js';
 import * as objectExpressionMeaning from './ObjectExpressionMeaning.js';
-import * as operationOverloadResolver from './OperationOverloadResolver.js';
 import { SourceFileMembers as ActualSourceFileMembers } from './SourceFileMembers.js';
 import * as tagMeaning from './TagMeaning.js';
 import * as tags from './Tags.js';
@@ -68,6 +68,7 @@ export declare class Analyzer {
     readonly owningPlainObjectModificationCheck: OwningPlainObjectModificationCheck;
     readonly packageImports: PackageImports;
     readonly typeUtils: TypeUtils;
+    readonly conflictsCheck: ConflictsCheck;
     private readonly _tsInteropInputs;
     private readonly _targetType;
     private readonly _typeAssignabilityCheck;
@@ -117,8 +118,8 @@ export declare class Analyzer {
     getUnambiguousTargetFunctionType(targetType: types.Type | undefined): types.FunctionType | undefined;
     getUnambiguousTargetArrayType(targetType: types.Type | undefined): types.Type | undefined;
     getEnumeratorElementType(node: tree.Node): types.Type | undefined;
-    resolveFunctionOverloadByCallExpression<TCandidate extends operationOverloadResolver.ICandidate<TValueParameter>, TValueParameter extends operationOverloadResolver.IValueParameter>(candidates: readonly TCandidate[], node: tree.CallExpression): readonly TCandidate[];
-    resolveFunctionOverloadByTargetType<TCandidate extends operationOverloadResolver.ICandidate<TValueParameter>, TValueParameter extends operationOverloadResolver.IValueParameter>(candidates: readonly TCandidate[], targetType: types.FunctionType): readonly TCandidate[];
+    resolveFunctionOverloadByCallExpression<TCandidate extends functionOverloadResolver.ICandidate<TValueParameter>, TValueParameter extends functionOverloadResolver.IValueParameter>(candidates: readonly TCandidate[], node: tree.CallExpression): readonly TCandidate[];
+    resolveFunctionOverloadByTargetType<TCandidate extends functionOverloadResolver.ICandidate<TValueParameter>, TValueParameter extends functionOverloadResolver.IValueParameter>(candidates: readonly TCandidate[], targetType: types.FunctionType): readonly TCandidate[];
     resolveConstructorOverload<TCandidate extends constructorOverloadResolver.ICandidate<TValueParameter>, TValueParameter extends constructorOverloadResolver.IValueParameter>(candidates: readonly TCandidate[], args: readonly tree.Argument[]): readonly TCandidate[];
     resolveTypeOverloadByArgumentCount<TCandidate extends typeOverloadResolver.ICandidate>(candidates: readonly TCandidate[], argumentCount: number): readonly TCandidate[];
     resolveMemberAccessExpression(node: tree.MemberAccessExpression, targetTypeHint?: TargetTypeHint): memberAccessExpressionResolution.ResolutionResult;
@@ -170,8 +171,6 @@ export declare class Analyzer {
     createNameFromIdentifier(node: tree.Identifier): Name;
     createSearchNameFromIdentifier(identifier: tree.Identifier): SearchName;
     createLocalizationContext(sourceFile: project.SourceFile): LocalizationContext;
-    typeIsValidBaseObjectType(type: types.Type): boolean;
-    typeIsValidBaseAspectType(type: types.Type): boolean;
     getImplicitBaseTypeForStructuredType(entity: e.StructuredTypeEntity): types.StructuredType | undefined;
     getImplicitBaseTypeForVariantType(): types.StructuredType;
     getImplicitBaseTypeForFunctionType(): types.StructuredType;
@@ -276,7 +275,8 @@ export declare class Analyzer {
     createAmbiguousNamedScopeDeclarationAccessLazyDiagnostic(declarations: readonly WithLocalization<semanticContext.NamedDeclaration>[], lctx: LocalizationContext, node: tree.Node): Lazy<Diagnostic>;
     addDiagnosticComputedLazily(diagnostic: Diagnostic): void;
     getAcceptorForDiagnosticsComputedLazily(): DiagnosticAcceptor;
-    getDiagnosticsComputedLazily(sourceFile: project.SourceFile): readonly Diagnostic[];
+    getSourceFileDiagnosticsComputedLazily(sourceFile: project.SourceFile): readonly Diagnostic[];
+    getDiagnosticsWithoutLocationComputedLazily(): readonly Diagnostic[];
     validateSourcePackageMemberConflicts(pkg: project.ProgramPackage): readonly Diagnostic[];
     private createTsInterop;
 }
@@ -482,17 +482,17 @@ declare class DefaultConstructors {
 declare class OverriddenMember {
     private readonly _analyzer;
     constructor(_analyzer: Analyzer);
-    getOverriddenVariables(node: tree.FieldDeclaration | FieldAccessorDeclaration): types.Variable[];
+    getOverriddenFields(node: tree.FieldDeclaration | FieldAccessorDeclaration): types.Field[];
     getOverriddenMethods(node: tree.MethodDeclaration): types.Method[];
     getOverriddenOperators(node: tree.OperatorDeclaration): types.Operator[];
     getOverriddenIndexers(node: IndexedElementAccessorDeclaration): types.Indexer[];
     getOverriddenDereferenceOperators(node: DereferencedVariableAccessorDeclaration): types.DereferenceOperator[];
-    private findOverriddenVariableInType;
+    private findOverriddenFieldInType;
     private findOverriddenMethodInType;
     private findOverriddenOperatorInType;
     private findOverriddenIndexerInType;
     private findOverriddenDereferenceOperatorInType;
-    private checkVariableOverridesVariable;
+    private checkFieldOverridesField;
     private checkMethodOverridesMethod;
     private checkOperatorOverridesOperator;
     private checkIndexerOverridesIndexer;
@@ -560,7 +560,7 @@ export declare class LinkedTypeWithMembers {
     private readonly _memberLookup;
     private get memberLookup();
     constructor(analyzer: Analyzer, externalType: e.TypeEntityWithMembers, targetType: e.TypeEntityWithMembers, linkedPackage: LinkedMultiPlatformPackage);
-    getLinkedVariable(entity: e.FieldEntity): e.FieldEntity | undefined;
+    getLinkedField(entity: e.FieldEntity): e.FieldEntity | undefined;
     getLinkedMethod(entity: e.MethodEntity): e.MethodEntity | undefined;
     getLinkedOperator(entity: e.OperatorEntity): e.OperatorEntity | undefined;
     getLinkedConstructor(entity: e.ConstructorEntity): e.ConstructorEntity | undefined;
@@ -616,7 +616,7 @@ export declare class PackageImportInfo {
     readonly isAliasedImport: e.PackageAliasEntity | undefined;
     constructor(entity: e.PackageEntity, translationPackage: AnalyzedTranslationPackage | undefined, isAliasedImport: e.PackageAliasEntity | undefined);
 }
-export declare class TypeUtils {
+declare class TypeUtils {
     private readonly _analyzer;
     constructor(_analyzer: Analyzer);
     getCommonObjectAndAspectTypesOfUnion(unionType: types.UnionType): readonly types.StructuredType[];
@@ -628,6 +628,46 @@ export declare class TypeUtils {
     private getFlattenedConstituentTypesForCommonTypesSearch;
     private flattenTypeParameterConstraint;
 }
+declare class ConflictsCheck {
+    private readonly _analyzer;
+    private _stubParameterTypes;
+    constructor(_analyzer: Analyzer);
+    /**
+     * Проверяет, конфликтуют ли две функции, т.е. могут ли такие функции находиться в одной области видимости.
+     * Метод не сравнивает имена.
+     *
+     * Отношение "функции конфликтуют" не является транзитивным, т.е. из того, что функция 1 конфликтует с функцией 2 и
+     * функция 2 конфликтует с функцией 3 не следует, что функция 1 конфликтует с функцией 3.
+     *
+     * Пример:
+     * ```artel
+     * 1. функция ф<Т1>()
+     * 2. функция ф<Т1, Т2>()
+     * 3. функция ф<Т1, Т2 = Объект>()
+     * ```
+     *
+     * Функции 1 и 2 не конфликтуют между собой, поскольку имеют разное количество количество параметров типа, однако
+     * каждая из них конфликтует с функций 3, которая может принимать от 1 до 2 параметров типа.
+     */
+    doFunctionSignaturesConflict(function1: e.FunctionEntity, function2: e.FunctionEntity): boolean;
+    /**
+     * Проверяет, конфликтуют две сущности, имеющие параметры, но не имеющие параметры типа.
+     *
+     * Отношение "сущности, имеющие только параметры, конфликтуют" является транзитивным.
+     */
+    doSignaturesWithoutTypeParametersConflict(entity1: EntityWithoutTypeParametersInSignature, entity2: EntityWithoutTypeParametersInSignature): boolean;
+    /**
+     * Проверяет, конфликтуют ли два типа, т.е. могут ли такие типы находиться в одном пакете. Метод не сравнивает имена.
+     *
+     * Отношение "типы конфликтуют" не является транзитивным (см. комментарий у метода
+     * {@link doFunctionSignaturesConflict}).
+     */
+    doPackageTypesConflict(type1: e.PackageTypeEntity, type2: e.PackageTypeEntity): boolean;
+    doTypeArgumentCountsIntersect(typeParameters1: readonly e.TypeParameterEntity[], typeParameters2: readonly e.TypeParameterEntity[]): boolean;
+    private doParametersConflict;
+    private createSubstitutionMapWithStubTypes;
+}
+export type EntityWithoutTypeParametersInSignature = e.ConstructorEntity | e.DestructorEntity | e.OperatorEntity | e.IndexerEntity;
 export declare class ExpressionDenotesFunctionCheckResult {
     readonly candidates: readonly WithLocalization<AccessedFunction>[];
     readonly suitableFunctions: readonly WithLocalization<AccessedFunction>[];

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

@@ -5,7 +5,7 @@ import { Analyzer } from './Analyzer.js';
 import { FoundAnonymousDeclaration } from './FoundDeclaration.js';
 /**
  * "основа" не является самостоятельным выражением и может использоваться только в следующих конструкциях:
- * 1. основа() - в конструкторе для вызова базового конструктора или в методе для вызова заменённого метода.
+ * 1. основа() - в конструкторе для вызова базового конструктора или в методе для вызова базового метода.
  * 2. основа.поле (основа.метод) - в любом выражении в контексте типа, имеющего базовый тип.
  * 3. основа[] - аналогично п. 2.
  */

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

@@ -12,6 +12,7 @@ export declare class DiagnosticCollector {
     private readonly _diagnostics;
     private readonly _diagnosticAcceptor;
     private _namedDeclarationsCountResult;
+    private readonly _modifierValidator;
     private get node();
     private get translationPackage();
     private get isInterfacePackageFile();
@@ -50,7 +51,6 @@ export declare class DiagnosticCollector {
     private getPackageMemberBodyRequirementReason;
     private checkTypeMemberBodyPresence;
     private getTypeMemberBodyRequirementReason;
-    private isBasicEntity;
     private checkIdentifierExpression;
     private checkLocalVariableUsedBeforeDeclaration;
     private checkLocalVariableIsUsedBeforeBeingAssigned;

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

@@ -3,4 +3,5 @@ import { ModifierFlags } from './ModifierFlags.js';
 type NodeWithModifiers = tree.PackageMemberDeclaration | tree.TypeMemberDeclaration;
 export declare function findModifier(node: NodeWithModifiers, modifierKeywordKind: tree.ModifierKeywordKind): tree.Modifier | undefined;
 export declare function createDeclaredModifierFlags(node: NodeWithModifiers): ModifierFlags;
+export declare function modifierToModifierFlag(modifier: tree.Modifier): ModifierFlags;
 export {};

package/build/types/analysis/{OperationOverloadResolver.d.ts → FunctionOverloadResolver.d.ts}

@@ -11,6 +11,8 @@ export declare class Resolver<TCandidate extends ICandidate<TValueParameter>, TV
 export interface ICandidate<TValueParameter extends IValueParameter> {
     getValueParameters(): readonly TValueParameter[];
     getSignatureType(): types.Type;
+    getTypeParameterCount(): number;
+    getRequiredTypeParameterCount(): number;
 }
 export interface IValueParameter {
     getName(): Name | undefined;

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

@@ -90,9 +90,9 @@ export declare class AccessedVariable_entity implements IAccessedVariable {
     getType(): types.Type;
 }
 export declare class AccessedVariable_typeMember implements IAccessedVariable {
-    readonly value: types.Variable;
+    readonly value: types.Field;
     readonly kind = "type-member";
-    constructor(value: types.Variable);
+    constructor(value: types.Field);
     getEntity(): VariableEntity;
     getName(): Name;
     getType(): types.Type;

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

@@ -13,7 +13,7 @@ export declare class Resolver {
     private readonly _analyzer;
     private readonly _node;
     private readonly _targetTypeHint;
-    private get propertySearchName();
+    private get memberSearchName();
     private get semanticContext();
     private get receiver();
     constructor(analyzer: Analyzer, node: tree.MemberAccessExpression, targetTypeHint: TargetTypeHint | undefined);
@@ -70,10 +70,10 @@ declare class Meaning_packageNameSegmentAccess {
 }
 declare class Meaning_staticFieldAccess {
     readonly type: types.Type;
-    readonly variable: FoundNamedDeclaration<types.Variable>;
+    readonly field: FoundNamedDeclaration<types.Field>;
     readonly accessKind: AccessKind;
     readonly kind = "static-field-access";
-    constructor(type: types.Type, variable: FoundNamedDeclaration<types.Variable>, accessKind: AccessKind);
+    constructor(type: types.Type, field: FoundNamedDeclaration<types.Field>, accessKind: AccessKind);
 }
 declare class Meaning_staticMethodAccess {
     readonly type: types.Type;
@@ -84,10 +84,10 @@ declare class Meaning_staticMethodAccess {
     constructor(type: types.Type, candidates: readonly FoundNamedDeclaration<AccessedFunction>[], suitableFunctions: readonly FoundNamedDeclaration<AccessedFunction>[]);
 }
 declare class Meaning_instanceFieldAccess {
-    readonly variable: FoundNamedDeclaration<types.Variable>;
+    readonly field: FoundNamedDeclaration<types.Field>;
     readonly accessKind: AccessKind;
     readonly kind = "instance-field-access";
-    constructor(variable: FoundNamedDeclaration<types.Variable>, accessKind: AccessKind);
+    constructor(field: FoundNamedDeclaration<types.Field>, accessKind: AccessKind);
 }
 declare class Meaning_instanceMethodAccess {
     readonly candidates: readonly FoundNamedDeclaration<AccessedFunction>[];

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

@@ -8,8 +8,13 @@ export declare enum ModifierFlags {
     Basic = 32,
     Static = 64,
     Abstract = 128,
-    Redefined = 256,
+    Override = 256,
     Async = 512,
     Const = 1024,
-    NotComputed = 2048
+    First = 1,
+    Last = 1024,
+    NotComputed = 2048,
+    AnyHiddenModifier = 31,
+    HiddenInPackageOrWithoutLevel = 17,
+    HiddenInTypeOrWithoutLevel = 3
 }

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

@@ -0,0 +1,83 @@
+import { PackageDialect, PackageLocale } from '../common/index.js';
+import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
+import * as tree from '../tree/index.js';
+import { Analyzer } from './Analyzer.js';
+import { ModifierFlags } from './ModifierFlags.js';
+declare enum PackageMemberDeclarationKind {
+    TranslationsDeclaration = 0,
+    AliasTypeDeclaration = 1,
+    MemberGroupDeclaration = 2,
+    TypeExtensionDeclaration = 3,
+    ConstructorDeclaration = 4,
+    EntryPointDeclaration = 5,
+    FunctionDeclaration = 6,
+    FunctionTypeDeclaration = 7,
+    ObjectTypeDeclaration = 8,
+    PlainObjectTypeDeclaration = 9,
+    AspectTypeDeclaration = 10,
+    VariableDeclaration = 11,
+    VariableGetterDeclaration = 12,
+    VariableSetterDeclaration = 13,
+    VariantTypeDeclaration = 14,
+    InvalidDeclaration = 15
+}
+type TypeMemberDeclarationKind = tree.TypeMemberDeclaration['kind'];
+export declare enum DeclarationWithTypeMembersKind {
+    ObjectType = 0,
+    PlainObjectType = 1,
+    AspectType = 2,
+    VariantType = 3,
+    AliasType = 4,
+    TypeExtension = 5
+}
+export declare class ModifierValidator {
+    private readonly _analyzer;
+    private readonly _diagnostics;
+    private readonly _locale;
+    private readonly _dialect;
+    static readonly allowedPackageMemberHidingModifiers: number;
+    static readonly allowedPackageMemberModifiers: number;
+    static readonly allowedModifiersByPackageMemberDeclarationKind: {
+        [T in PackageMemberDeclarationKind]: ModifierFlags;
+    };
+    static readonly allowedTypeMemberHidingModifiers: number;
+    static readonly allowedTypeMemberModifiers: number;
+    static readonly allowedModifiersByTypeMemberDeclarationKind: {
+        [T in TypeMemberDeclarationKind]: ModifierFlags;
+    };
+    constructor(_analyzer: Analyzer, _diagnostics: DiagnosticAcceptor, _locale: PackageLocale, _dialect: PackageDialect);
+    static validatePackageVariableAccessorsHaveConsistentModifiers(analyzer: Analyzer, getterModifiers: ModifierFlags, setterModifiers: ModifierFlags, nodeForDiagnostic: tree.Node, diagnostics: DiagnosticAcceptor): void;
+    static validateFieldAccessorsHaveConsistentModifiers(analyzer: Analyzer, getterModifiers: ModifierFlags, setterModifiers: ModifierFlags, nodeForDiagnostic: tree.Node, diagnostics: DiagnosticAcceptor): void;
+    static validateIndexedElementAccessorsHaveConsistentModifiers(analyzer: Analyzer, getterModifiers: ModifierFlags, setterModifiers: ModifierFlags, nodeForDiagnostic: tree.Node, diagnostics: DiagnosticAcceptor): void;
+    static validateDereferencedVariableAccessorsHaveConsistentModifiers(analyzer: Analyzer, getterModifiers: ModifierFlags, setterModifiers: ModifierFlags, nodeForDiagnostic: tree.Node, diagnostics: DiagnosticAcceptor): void;
+    validateTopLevelPackageMembers(list: tree.PackageMemberDeclarationList): void;
+    validateTopLevelTypeMembers(list: tree.TypeMemberDeclarationList, declarationWithMembersKind: DeclarationWithTypeMembersKind, isTypeMarkedAbstract: boolean, isTypeMarkedBasic: boolean): void;
+    private static validateTypeMemberAccessorsHaveConsistentModifiers;
+    private static validatePackageMemberSetterHasMoreRestrictiveHidingLevel;
+    private static validateTypeMemberSetterHasMoreRestrictiveHidingLevel;
+    private static reportMoreRestrictiveHidingLevelIsRequired;
+    private static reportSetterMustHaveSameModifiersAsGetter;
+    private validatePackageMembers;
+    private validatePackageMemberModifierList;
+    private validatePackageMemberCanBePlacedInGroupWithModifiers;
+    private validatePackageConstructorDeclaration;
+    private validatePackageEntryPointDeclaration;
+    private validateTranslationsDeclaration;
+    private validateTypeMembers;
+    private validateTypeMemberModifierList;
+    private validateTypeMemberCanBePlacedInGroupWithModifiers;
+    private typeMemberAllowsAbstractModifier;
+    private typeMemberAllowsBasicModifier;
+    private typeMemberAllowsOverrideModifier;
+    private typeMemberAllowsStaticModifier;
+    private reportDuplicateModifier;
+    private reportDuplicateHiddenModifier;
+    private reportDeclarationCanNotBePlacedInGroupWithModifier;
+    private reportModifierCanNotBeUsedWithAnotherModifier;
+    private reportModifierIsNotAllowedHere;
+    private displayModifierNode;
+    private displayModifierFlag;
+    private displayModifier;
+    private forEachModifierFlag;
+}
+export {};

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

@@ -9,11 +9,10 @@ export declare class PackageMemberNameConflictsValidator {
     constructor(_analyzer: Analyzer, _members: OriginalPackageMembers);
     validate(): readonly Diagnostic[];
     private validateFunctionNameConflicts;
-    private areFunctionSignaturesEqual;
     private validateTypeNameConflicts;
-    private typeParameterCountsIntersect;
     private createAndAddNameConflictDiagnosticsForAllEntities;
-    private createAndAddNameConflictDiagnostic;
+    private shouldReportConflictWithMemberBasedOnHiding;
+    private reportNameConflictDiagnostic;
     private getDiagnosticLocation;
 }
 export declare class SourcePackageMemberConflictsValidator {

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

@@ -0,0 +1,22 @@
+import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
+import { OriginalTypeEntityMembers } from '../entities/TypeEntityMembers.js';
+import { Analyzer } from './Analyzer.js';
+export declare class TypeMemberConflictsValidator {
+    private readonly _analyzer;
+    private readonly _members;
+    private readonly _diagnostics;
+    constructor(_analyzer: Analyzer, _members: OriginalTypeEntityMembers, _diagnostics: DiagnosticAcceptor);
+    validate(): void;
+    private validateNamedMembers;
+    private validateNamedMembersWithoutIsStaticCheck;
+    private validateMethodsWithSameName;
+    private validateConstructors;
+    private validateDestructors;
+    private validateOperators;
+    private validateIndexers;
+    private validateDereferenceOperators;
+    private validateMembersWithoutTypeParametersInSignature;
+    private reportNameConflictDiagnosticsForAllEntities;
+    private reportNameConflictDiagnostic;
+    private getDiagnosticLocation;
+}

package/build/types/analysis/control-flow/NarrowableReference.d.ts

@@ -27,10 +27,10 @@ export declare namespace NarrowableReference {
     }
     export class InstanceField implements INarrowableReference {
         private readonly _analyzer;
-        readonly variable: types.Variable;
+        readonly field: types.Field;
         readonly receiver: NarrowableReference;
         readonly kind = "instance-field";
-        constructor(_analyzer: Analyzer, variable: types.Variable, receiver: NarrowableReference);
+        constructor(_analyzer: Analyzer, field: types.Field, receiver: NarrowableReference);
         equals(other: NarrowableReference): boolean;
         contains(other: NarrowableReference): boolean;
         equalsExpression(expression: NarrowableReferenceExpression): boolean;
@@ -38,9 +38,9 @@ export declare namespace NarrowableReference {
     }
     export class StaticField implements INarrowableReference {
         private readonly _analyzer;
-        readonly variable: types.Variable;
+        readonly field: types.Field;
         readonly kind = "static-field";
-        constructor(_analyzer: Analyzer, variable: types.Variable);
+        constructor(_analyzer: Analyzer, field: types.Field);
         equals(other: NarrowableReference): boolean;
         contains(_other: NarrowableReference): boolean;
         equalsExpression(expression: NarrowableReferenceExpression): boolean;

package/build/types/analysis/control-flow/Nodes.d.ts

@@ -45,7 +45,7 @@ export declare class AssignmentNode extends ControlFlowNodeBase {
 }
 /**
  * Создаётся в местах объявления локальных переменных. Если переменной присваивается начальное значение, её тип будет
- * заменён на тип присваиваемого выражения.
+ * взят как тип присваиваемого выражения.
  */
 export declare class LocalVariableDeclarationNode extends ControlFlowNodeBase {
     readonly predecessor: Node;

package/build/types/analysis/semantic-context/Declarations.d.ts

@@ -77,9 +77,9 @@ export declare class NamedDeclarationVariable_entity implements INamedDeclaratio
     isHidden(): EntityHidingLevel | undefined;
 }
 export declare class NamedDeclarationVariable_typeMember implements INamedDeclarationVariable {
-    readonly value: types.Variable;
+    readonly value: types.Field;
     readonly kind = "type-member";
-    constructor(value: types.Variable);
+    constructor(value: types.Field);
     getName(): Name;
     getEntity(): VariableEntity;
     isHidden(): EntityHidingLevel | undefined;

package/build/types/analysis/semantic-context/SemanticContextValidatingNameConflicts.d.ts

@@ -33,7 +33,6 @@ export declare abstract class SemanticContextValidatingNameConflictsBase extends
     validateNameConflicts(diagnostics: DiagnosticAcceptor): void;
     private getMemberEntityDictionary;
     private validateNestedFunctionsConflicts;
-    private areNestedFunctionSignaturesEqual;
     private createNamedDeclarations;
     private createTypesOrContainerWithTypes;
 }

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

@@ -0,0 +1,8 @@
+export declare class ArrayUtils {
+    /**
+     * Удаляет элемент из массива по заданному индексу.
+     *
+     * Работает быстрее, чем `array.splice(index, 1)`, и не выделяет память для массива удалённых элементов.
+     */
+    static removeElement<T>(array: T[], index: number): void;
+}

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

@@ -1,4 +1,5 @@
 export * from './AccessKind.js';
+export * from './ArrayUtils.js';
 export * from './ArtelFileCheck.js';
 export * from './Cached.js';
 export * from './CancellationToken.js';

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

@@ -114,35 +114,63 @@ export declare enum DiagnosticCode {
     IncorrectBodyOfBasicAliasTypeMethod = 276,
     TheFollowingDeclarationsAreNotTranslated0 = 277,
     TheFollowingDeclarationAreNotTranslated0And1More = 278,
-    OperatorFunctionMustNotBeStatic = 279,
-    OperatorFunction0MustNotHaveParameters = 280,
-    OperatorFunction0MustHaveOneParameter = 281,
-    OperatorFunction0MustHaveNoMoreThanOneParameter = 282,
-    CorrespondingBasicTypeMemberNotFound = 283,
-    ConstructorCannotBeDeclaredAsBasic = 284,
-    ConstructorCannotBeDeclaredAsOverridden = 285,
-    AsyncFunctionCanOnlyBeCalledFromFunctionMarkedWithAsyncModifier = 286,
-    TagNotFound = 287,
-    TypeOrFunctionNameExpected = 288,
-    PackageNameOrAliasExpected = 289,
-    ExpressionCanBeNone = 290,
-    TargetVariableExpressionInTheAssignmentStatementCannotContainQuestionOperator = 291,
-    UnreachableCode = 292,
-    RecursionOccurredWhileCalculatingTheTypeOfTheExpression = 293,
-    RecursionOccurredWhileInferringTheTypeOfTheVariable = 294,
-    ScopeAlreadyContainsDeclarationWithTheSameName = 295,
-    ScopeAlreadyContainsFunctionWithTheSameNameAndParameterTypes = 296,
-    ParameterName0ConflictsWithAutomaticallyGeneratedVariableName = 297,
-    PackageAlreadyContainsDeclarationWithTheSameName = 298,
-    PackageAlreadyContainsFunctionWithTheSameNameAndParameterTypes = 299,
-    PackageAlreadyContainsTypeWithTheSameNameAndSameOrIntersectingTypeParameterCount = 300,
-    PackageAliasWithTheSameNameAlreadyExits = 301,
-    PackageCanHaveOnlyEntryPoint = 302,
-    PackageCanHaveOnlyOneConstructor = 303,
-    VariableIsUsedBeforeItsDeclaration = 304,
-    VariableMayNotHasBeenAssignedBeforeUsage = 305,
-    NotAllCodePathsReturnAValueAndResultLocalVariableMayNotHasBeenAssigned = 306,
-    WriteFunctionHasNoCorrespondingReadFunction = 307,
+    OperatorFunction0MustNotHaveParameters = 279,
+    OperatorFunction0MustHaveOneParameter = 280,
+    OperatorFunction0MustHaveNoMoreThanOneParameter = 281,
+    CorrespondingBasicTypeMemberNotFound = 282,
+    AsyncFunctionCanOnlyBeCalledFromFunctionMarkedWithAsyncModifier = 283,
+    TagNotFound = 284,
+    TypeOrFunctionNameExpected = 285,
+    PackageNameOrAliasExpected = 286,
+    ExpressionCanBeNone = 287,
+    TargetVariableExpressionInTheAssignmentStatementCannotContainQuestionOperator = 288,
+    UnreachableCode = 289,
+    RecursionOccurredWhileCalculatingTheTypeOfTheExpression = 290,
+    RecursionOccurredWhileInferringTheTypeOfTheVariable = 291,
+    ScopeAlreadyContainsDeclarationWithTheSameName = 292,
+    ScopeAlreadyContainsFunctionWithTheSameNameAndParameterTypes = 293,
+    ParameterName0ConflictsWithAutomaticallyGeneratedVariableName = 294,
+    PackageAlreadyContainsDeclarationWithTheSameName = 295,
+    PackageAlreadyContainsFunctionWithTheSameNameAndParameterTypes = 296,
+    PackageAlreadyContainsTypeWithTheSameNameAndSameOrIntersectingTypeParameterCount = 297,
+    PackageAliasWithTheSameNameAlreadyExits = 298,
+    PackageCanHaveOnlyEntryPoint = 299,
+    PackageCanHaveOnlyOneConstructor = 300,
+    TypeAlreadyContainsDeclarationWithTheSameName = 301,
+    TypeAlreadyContainsMethodWithTheSameNameAndParameterTypes = 302,
+    TypeAlreadyContainsConstructorWithTheSameParameterTypes = 303,
+    TypeAlreadyContainsOperatorFunctionWithTheSameParameterTypes = 304,
+    TypeAlreadyContainsIndexerWithTheSameParameterTypes = 305,
+    TypeCanHaveOnlyOneDestructor = 306,
+    TypeCanHaveOnlyOneDereferenceOperator = 307,
+    VariableIsUsedBeforeItsDeclaration = 308,
+    VariableMayNotHasBeenAssignedBeforeUsage = 309,
+    NotAllCodePathsReturnAValueAndResultLocalVariableMayNotHasBeenAssigned = 310,
+    WriteFunctionHasNoCorrespondingReadFunction = 311,
+    TypeCanNotHaveMultipleBaseObjectTypes = 312,
+    TypeThatIsNotMarkedAsBasicCanNotBeUsedAsBaseType = 313,
+    PlainObjectTypeCanNotBeUsedAsBaseType = 314,
+    ThisTypeIsAlreadyListedInBaseTypeList = 315,
+    OnlyObjectAndAspectTypesCanBeUsedAsBaseTypes = 316,
+    PlainObjectTypeCanHaveOnlyAspectsAsBaseTypes = 317,
+    AspectTypeCanHaveOnlyAspectsAsBaseTypes = 318,
+    ModifierListAlreadyContains0Modifier = 319,
+    ModifierListOfOuterDeclarationGroupAlreadyContains0Modifier = 320,
+    _0ModifierIsNotAllowedHere = 321,
+    DeclarationCanNotBePlacedInGroupHaving0Modifier = 322,
+    PackageConstructorDeclarationCanNotHaveModifiers = 323,
+    PackageEntryPointDeclarationCanNotHaveModifiers = 324,
+    TranslationsCanNotHaveModifiers = 325,
+    AbstractModifierCanOnlyBeUsedInAbstractObjectTypes = 326,
+    BasicModifierCanOnlyBeUsedInObjectTypesAspectTypesAndTypeAliases = 327,
+    OverrideModifierCanOnlyBeUsedInObjectAndAspectTypes = 328,
+    _0ModifierCanNotBeUsedWith1Modifier = 329,
+    VariantDeclarationCanNotHaveHiddenModifier = 330,
+    BasicModifierCanOnlyBeAppliedToObjectTypes = 331,
+    AbstractModifierCanOnlyBeAppliedToObjectTypes = 332,
+    NotBasicObjectTypesCanNotHaveBasicMembers = 333,
+    WriteFunctionMustHaveTheSameModifiersAsReadFunction = 334,
+    WriteFunctionMustHaveTheSameOrMoreRestrictiveHidingLevelThenReadFunction = 335,
     CannotFindTsLibDirectoryBaseSearchPaths0 = 401,
     SourceFile0IsNotPartOfThePackageAndWontBeLoaded = 402,
     ProgramWithoutMainPackageCannotBeCompiled = 403,

package/build/types/emitter/Entities.d.ts

@@ -44,7 +44,7 @@ export interface ComputedNameInfo {
      */
     readonly affectsDeclaration: boolean;
     /**
-     * Должны ли члены типы, заменяющие этот член, использовать указанный символ в качестве ключа?
+     * Должны ли расширенные (override-) члены производных типов использовать указанный символ в качестве ключа?
      */
     readonly affectsDerivedMembers: boolean;
 }
@@ -105,9 +105,9 @@ export declare class TypeOrExtensionEntityDetails {
     isDefaultExport: boolean;
     extendedType: TypeOrExtensionEntity | undefined;
     /**
-     * Является ли имя члена типа вычисляемым (`details.hasComputedName`) может зависеть от заменённых членов типа.
+     * Является ли имя члена типа вычисляемым (`details.hasComputedName`) может зависеть от переопределённых членов типа.
      * Если `areOwnComputedNamesOfMembersResolved` === `true`, поля `details.hasComputedName` членов типа хранят
-     * актуальную для них самих информацию, и анализ заменённых членов типа не требуется.
+     * актуальную для них самих информацию, и анализ переопределённых членов типа не требуется.
      */
     areOwnComputedNamesOfMembersResolved: boolean;
 }

package/build/types/entities/AliasTypeEntity.d.ts

@@ -72,7 +72,7 @@ export declare class PackageAliasTypeDeclarationEntity implements AliasTypeEntit
     private readonly _aliasedType;
     private readonly _typeParameters;
     private readonly _members;
-    private readonly _modifierFlags;
+    private _modifierFlags;
     private get modifierFlags();
     constructor(_analyzer: Analyzer, _node: PackageAliasTypeDeclaration);
     getName(): Name;