@artel/artc 0.6.26039 → 0.9.26001

package/build/{chunk-AEW4TILW.js → chunk-V2TFXOVJ.js}

@@ -9,7 +9,7 @@ import {
   WellKnownDeclarationsLoadError,
   __async,
   createTsInteropInputsForCompilation
-} from "./chunk-LTJPPRSR.js";
+} from "./chunk-FLMCFMMG.js";
 
 // source/executor/Compiler.ts
 var Compiler = class {

package/build/{chunk-5VVFNKOH.js → chunk-XMOVE7NP.js}

@@ -1,6 +1,6 @@
 import {
   Compiler
-} from "./chunk-AEW4TILW.js";
+} from "./chunk-V2TFXOVJ.js";
 import {
   ArtelVersion,
   Cached,
@@ -16,7 +16,7 @@ import {
   __async,
   performanceMeasurementStageNames,
   performanceMeasurementStages
-} from "./chunk-LTJPPRSR.js";
+} from "./chunk-FLMCFMMG.js";
 
 // source/executor/FileSystemUri.ts
 import { platform } from "os";

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

@@ -39,6 +39,10 @@ export declare abstract class Analyzer {
      * Пакет с именем 'Артель', содержащий стандартные типы.
      */
     get systemPackage(): e.PackageEntity;
+    /**
+     * Пакет с именем 'Артель.М', содержащий теги для диалекта М.
+     */
+    get systemPackageM(): e.PackageEntity;
     /**
      * Стандартные объявления на языке оригинала. Для получения стандартных объявлений на желаемом языке используйте
      * {@link getLocalizedWellKnownDeclarations}.
@@ -181,6 +185,7 @@ export declare abstract class Analyzer {
 export declare class CommonAnalyzerState {
     readonly compilation: project.Compilation;
     systemPackage: e.PackageEntity;
+    systemPackageM: e.PackageEntity;
     originalWellKnownDeclarations: WellKnownDeclarations;
     originalStandardTypes: types.StandardTypes;
     typeFactory: TypeFactory;
@@ -315,7 +320,7 @@ declare class TypeUtils {
     removeDerivedTypesInPlace(types: types.Type[]): void;
     getBaseOrAliasedTypes(type: types.Type): readonly types.Type[];
     getPossiblyAliasedBaseObjectType(type: types.Type): types.Type | undefined;
-    getPossiblyAliasedBaseObjectTypeOfEntity(type: e.TypeEntity): types.Type | undefined;
+    getPossiblyAliasedBaseObjectTypeOfEntity(type: e.TypeEntity | e.TypeExtensionEntity): types.Type | undefined;
     getPossiblyAliasedBaseAspectTypes(type: types.Type): readonly types.Type[] | undefined;
     getBaseObjectTypeOrAliasedType(type: types.Type): types.Type | undefined;
     getBaseAndAliasedTypesRecursively(type: types.Type): readonly types.Type[];

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

@@ -1,5 +1,5 @@
 import { Name, PackageLocale } from '../common/index.js';
-import { NamedTypeMemberEntity, PackageEntity, TypeEntity, TypeExtensionEntity, TypeOrExtensionEntity } from '../entities/index.js';
+import { NamedTypeMemberEntity, OperatorKind, PackageEntity, TypeEntity, TypeExtensionEntity, TypeOrExtensionEntity } from '../entities/index.js';
 import { TypeMemberKindFlags } from '../entities/TypeMemberKindFlags.js';
 import { SourceFile } from '../project/SourceFile.js';
 import * as types from '../types/index.js';
@@ -17,6 +17,8 @@ export declare class TypeMemberLookup {
     getMatchingNamedMembersByName(name: Name, memberToMatch: NamedTypeMemberEntity, context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.NamedTypeMember[];
     getConstructors(context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.Method[];
     getDestructors(context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.Method[];
+    getOperators(context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.Method[];
+    getOperatorsByKind(kind: OperatorKind, context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.Method[];
     getIndexers(context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.Indexer[];
     getDereferenceOperators(context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.DereferenceOperator[];
 }

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

@@ -38,6 +38,24 @@ export interface WellKnownDeclarations {
     readonly builtIntoPlatform: StructuredTypeEntity;
     readonly fieldProxy: StructuredTypeEntity;
     readonly javaScriptDecorator: StructuredTypeEntity;
+    readonly typeDesignator: StructuredTypeEntity;
+    readonly asFunction: MethodEntity;
+    readonly isFunction: MethodEntity;
+    readonly tagNewModifierM: StructuredTypeEntity;
+    readonly tagPlainM: StructuredTypeEntity;
+    readonly tagAspectM: StructuredTypeEntity;
+    readonly tagExtensionM: StructuredTypeEntity;
+    readonly tagWrapperM: StructuredTypeEntity;
+    readonly tagBasicM: StructuredTypeEntity;
+    readonly tagOverrideM: StructuredTypeEntity;
+    readonly tagAbstractM: StructuredTypeEntity;
+    readonly tagHiddenInTypeM: StructuredTypeEntity;
+    readonly tagHiddenInTypeHierarchyM: StructuredTypeEntity;
+    readonly tagHiddenInFileM: StructuredTypeEntity;
+    readonly tagHiddenInPackageM: StructuredTypeEntity;
+    readonly tagConstM: StructuredTypeEntity;
+    readonly tagAsyncM: StructuredTypeEntity;
+    readonly tagIntermediateM: StructuredTypeEntity;
 }
 export declare class LocalizedWellKnownDeclarations implements WellKnownDeclarations {
     private readonly analyzer;
@@ -73,6 +91,24 @@ export declare class LocalizedWellKnownDeclarations implements WellKnownDeclarat
     private builtIntoPlatform_;
     private fieldProxy_;
     private javaScriptDecorator_;
+    private typeDesignator_;
+    private asFunction_;
+    private isFunction_;
+    private tagNewModifierM_;
+    private tagPlainM_;
+    private tagAspectM_;
+    private tagExtensionM_;
+    private tagWrapperM_;
+    private tagBasicM_;
+    private tagOverrideM_;
+    private tagAbstractM_;
+    private tagHiddenInTypeM_;
+    private tagHiddenInTypeHierarchyM_;
+    private tagHiddenInFileM_;
+    private tagHiddenInPackageM_;
+    private tagConstM_;
+    private tagAsyncM_;
+    private tagIntermediateM_;
     constructor(analyzer: Analyzer, locale: PackageLocale);
     get object(): StructuredTypeEntity;
     get structure(): StructuredTypeEntity;
@@ -105,6 +141,24 @@ export declare class LocalizedWellKnownDeclarations implements WellKnownDeclarat
     get builtIntoPlatform(): StructuredTypeEntity;
     get fieldProxy(): StructuredTypeEntity;
     get javaScriptDecorator(): StructuredTypeEntity;
+    get typeDesignator(): StructuredTypeEntity;
+    get asFunction(): MethodEntity;
+    get isFunction(): MethodEntity;
+    get tagNewModifierM(): StructuredTypeEntity;
+    get tagPlainM(): StructuredTypeEntity;
+    get tagAspectM(): StructuredTypeEntity;
+    get tagExtensionM(): StructuredTypeEntity;
+    get tagWrapperM(): StructuredTypeEntity;
+    get tagBasicM(): StructuredTypeEntity;
+    get tagOverrideM(): StructuredTypeEntity;
+    get tagAbstractM(): StructuredTypeEntity;
+    get tagHiddenInTypeM(): StructuredTypeEntity;
+    get tagHiddenInTypeHierarchyM(): StructuredTypeEntity;
+    get tagHiddenInFileM(): StructuredTypeEntity;
+    get tagHiddenInPackageM(): StructuredTypeEntity;
+    get tagConstM(): StructuredTypeEntity;
+    get tagAsyncM(): StructuredTypeEntity;
+    get tagIntermediateM(): StructuredTypeEntity;
     private getLocalizedStructuredType;
     private getLocalizedReducedType;
     private getLocalizedAliasType;

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

@@ -34,7 +34,6 @@ import { ReductionSourceMemberFinder } from './ReductionSourceMemberFinder.js';
 import { ReservedNameKind } from './ReservedNameDictionary.js';
 import { SyntacticAccessKind } from './SyntacticAccessKind.js';
 import * as tagMeaning from './TagMeaning.js';
-import { TypeWithMembersOrTypeExtensionDeclaration } from './TreeQuery.js';
 import * as controlFlow from './control-flow/index.js';
 import * as semanticContext from './semantic-context/index.js';
 /**
@@ -175,13 +174,14 @@ export declare class Analyzer extends BaseAnalyzer {
     validateSourcePackageMemberConflicts(pkg: project.ProgramOrTextTranslationPackage): readonly Diagnostic[];
     determineUnderlyingTypeOfSourceVariantType(memberList: tree.TypeMemberDeclarationList): types.Type;
     getOwnAndBaseConstructorCallsCheckResult(node: tree.TypeWithMembersDeclaration): OwnAndBaseConstructorCallsCheckResult;
-    isConstructorCallingOwnConstructor(node: tree.ConstructorDeclaration): boolean;
+    isCallingOwnConstructorCorrectly(node: tree.ConstructorDeclaration): boolean;
+    isOwnOrBaseConstructorCalledCorrectly(node: tree.OwnConstructorCallExpression | tree.BaseExpression): boolean;
     ifCalleeThenCallExpression(node: tree.Expression): tree.CallExpression | undefined;
     getNodeForAmbiguousAccessDiagnostic(access: tree.Expression): tree.Node;
     isPossibleWrappedTargetTypeDependentFunctionLiteral(node: tree.Expression): boolean;
     isTargetTypeDependentFunctionLiteral(node: tree.Expression): node is tree.RegularOrBlockFunctionLiteral;
     checkTypeArgumentCount(typeArgumentCount: number, typeParameters: readonly e.TypeParameterEntity[], diagnostics?: DiagnosticAcceptor, diagnosticLocation?: NodeOrDiagnosticLocation): boolean;
-    checkTypeCanBeUsedAsValue(typeAccess: tree.Expression): boolean;
+    checkTypeCanBeUsedAsValue(typeAccess: tree.IdentifierExpression | tree.MemberAccessExpression): boolean;
     isPossiblyCastedBaseExpression(node: tree.Expression): boolean;
     createAmbiguousNamedScopeDeclarationAccessDiagnostic(declarations: readonly semanticContext.NamedDeclaration[], nodeOrLocation: NodeOrDiagnosticLocation): Diagnostic;
     /**
@@ -263,18 +263,18 @@ declare class Type {
     /**
      * По умолчанию литерал шаблона текста имеет тип Текст.
      *
-     * Литерал шаблона текста имеет тип ШаблонТекста в следующих случаях:
-     * - если он присваивается в переменную, имеющую тип ШаблонТекста;
-     * - если он присваивается в переменную, имеющую союзный тип, содержащий тип ШаблонТекста
+     * Литерал шаблона текста имеет тип ТекстШаблонный в следующих случаях:
+     * - если он присваивается в переменную, имеющую тип ТекстШаблонный;
+     * - если он присваивается в переменную, имеющую множественный тип, содержащий тип ТекстШаблонный
      *   и не содержащий тип Текст.
      */
     private ofTextTemplateLiteral;
     /**
      * По умолчанию литерал шаблона текста имеет тип Текст.
      *
-     * Литерал переводимого шаблона текста имеет тип ШаблонТекстаПереводимый в следующих случаях:
-     * - если он присваивается в переменную, имеющую тип ШаблонТекстаПереводимый;
-     * - если он присваивается в переменную, имеющую союзный тип, содержащий тип ШаблонТекстаПереводимый
+     * Литерал переводимого шаблона текста имеет тип ТекстПереводимый в следующих случаях:
+     * - если он присваивается в переменную, имеющую тип ТекстПереводимый;
+     * - если он присваивается в переменную, имеющую множественный тип, содержащий тип ТекстПереводимый
      *   и не содержащий тип Текст.
      */
     private ofLocalizableTextTemplateLiteral;
@@ -387,7 +387,7 @@ declare class Entity {
     ofTypeExtensionDeclaration(node: tree.TypeExtensionDeclaration): e.TypeExtensionEntity;
     ofPackageImport(node: tree.PackageImport): e.PackageAliasEntity;
     ofTypeWithMembersDeclaration(node: tree.TypeWithMembersDeclaration): e.TypeEntityWithMembers;
-    ofTypeWithMembersOrExtensionDeclaration(node: TypeWithMembersOrTypeExtensionDeclaration): e.TypeWithMembersOrExtensionEntity;
+    ofTypeWithMembersOrExtensionDeclaration(node: tree.TypeWithMembersOrExtensionDeclaration): e.TypeWithMembersOrExtensionEntity;
     ofTranslationTextTemplateParameter(node: tree.TranslationTextTemplateParameter): e.ParameterEntity;
     ofTextTranslationDeclaration(node: tree.TextTranslationSource): e.TextTranslationEntity;
     ofFunctionLiteral(node: tree.FunctionLiteral): e.AnonymousFunctionEntity;

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

@@ -42,7 +42,7 @@ export declare class SecondStageResolver {
     private resolveFunctionAccess;
     private resolveNotCalledFunctionsAccess;
 }
-export type Meaning = Meaning_variableAccess | Meaning_functionAccess | Meaning_packageNameSegmentAccess | Meaning_packageAliasAccess | Meaning_typeAccess | Meaning_constructorAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
+export type Meaning = Meaning_variableAccess | Meaning_functionAccess | Meaning_packageNameSegmentAccess | Meaning_packageAliasAccess | Meaning_typeAccess | Meaning_typeAccessAtConstructorCall | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
 declare class Meaning_variableAccess {
     readonly variable: AccessedVariable;
     readonly access: ComputedAccess;
@@ -74,10 +74,10 @@ declare class Meaning_typeAccess {
     get singleSuitableType(): types.Type | undefined;
     constructor(candidates: readonly NamedTypeEntity[], suitableTypes: readonly types.Type[]);
 }
-declare class Meaning_constructorAccess {
+declare class Meaning_typeAccessAtConstructorCall {
     readonly typeCandidates: readonly NamedTypeEntity[];
     readonly callExpressionMeaning: callExpressionMeaning.Meaning_constructorCall;
-    readonly kind = "constructor-access";
+    readonly kind = "type-access-at-constructor-call";
     constructor(typeCandidates: readonly NamedTypeEntity[], callExpressionMeaning: callExpressionMeaning.Meaning_constructorCall);
 }
 declare class Meaning_mixedAmbiguousAccess {

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

@@ -46,7 +46,7 @@ export declare class SecondStageResolver {
     private resolveInstanceMethodAccess;
     private resolveNotCalledFunctionsAccess;
 }
-export type Meaning = Meaning_packageVariableAccess | Meaning_packageFunctionAccess | Meaning_packageTypeAccess | Meaning_constructorAccess | Meaning_packageNameSegmentAccess | Meaning_staticFieldAccess | Meaning_staticMethodAccess | Meaning_instanceFieldAccess | Meaning_instanceMethodAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
+export type Meaning = Meaning_packageVariableAccess | Meaning_packageFunctionAccess | Meaning_packageTypeAccess | Meaning_typeAccessAtConstructorCall | Meaning_packageNameSegmentAccess | Meaning_staticFieldAccess | Meaning_staticMethodAccess | Meaning_instanceFieldAccess | Meaning_instanceMethodAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
 declare class Meaning_packageVariableAccess {
     readonly variable: PackageVariableEntity;
     readonly access: ComputedAccess;
@@ -66,10 +66,10 @@ declare class Meaning_packageTypeAccess {
     get singleSuitableType(): types.Type | undefined;
     constructor(candidates: readonly PackageTypeEntity[], suitableTypes: readonly types.Type[]);
 }
-declare class Meaning_constructorAccess {
+declare class Meaning_typeAccessAtConstructorCall {
     readonly typeCandidates: readonly PackageTypeEntity[];
     readonly callExpressionMeaning: callExpressionMeaning.Meaning_constructorCall;
-    readonly kind = "constructor-access";
+    readonly kind = "type-access-at-constructor-call";
     constructor(typeCandidates: readonly PackageTypeEntity[], callExpressionMeaning: callExpressionMeaning.Meaning_constructorCall);
 }
 declare class Meaning_packageNameSegmentAccess {

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

@@ -1,5 +1,5 @@
 import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
-import { MethodEntity } from '../../entities/index.js';
+import { EntityHidingLevel, MethodEntity } from '../../entities/index.js';
 import * as tree from '../../tree/a/index.js';
 import { Analyzer } from './Analyzer.js';
 import { ModifierFlags } from './ModifierFlags.js';
@@ -64,7 +64,7 @@ export declare class ModifierValidator {
     constructor(analyzer: Analyzer, diagnostics: DiagnosticAcceptor);
     static validateTypeMemberAccessorsHaveConsistentModifiers(analyzer: Analyzer, getterEntity: MethodEntity, setterEntity: MethodEntity, getterNode: tree.GetterDeclaration, setterNode: tree.SetterDeclaration, diagnostics: DiagnosticAcceptor): void;
     validateTopLevelPackageMembers(list: tree.PackageMemberDeclarationList): void;
-    validateTopLevelTypeMembers(memberList: tree.TypeMemberDeclarationList, declarationWithMembersKind: DeclarationWithTypeMembersKind, isTypeMarkedAbstract: boolean, isTypeMarkedBasic: boolean): void;
+    validateTopLevelTypeMembers(memberList: tree.TypeMemberDeclarationList, declarationWithMembersKind: DeclarationWithTypeMembersKind, isTypeMarkedAbstract: boolean, isTypeMarkedBasic: boolean, typeHiding: EntityHidingLevel | undefined): void;
     private static getAccessorDiagnosticLocation;
     private validatePackageMembers;
     private validatePackageMemberModifierList;
@@ -80,6 +80,7 @@ export declare class ModifierValidator {
     private typeMemberAllowsBasicModifier;
     private typeMemberAllowsOverrideModifier;
     private typeMemberAllowsStaticModifier;
+    private checkTypeMemberHidingIsEquallyOrMoreRestrictiveThanTypeHiding;
     private reportDuplicateModifier;
     private reportDuplicateHiddenModifier;
     private reportDeclarationCannotBePlacedInGroupWithModifier;

package/build/types/analysis/a/ResolvedTranslationPackage.d.ts

@@ -1,7 +1,7 @@
 import { PackageLocale } from '../../common/index.js';
 import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
 import { EntityLocalizationContext, LocalizablePackageMemberEntity } from '../../entities/EntityLocalizationContext.js';
-import { AnonymousTypeEntity, Entity, EntityContainingParameter, EntityContainingTypeParameter, PackageEntity, PackageEntityMembers, PackageMemberEntity, ParameterEntity, TypeEntityMembers, TypeMemberEntity, TypeParameterEntity, TypeWithMembersOrExtensionEntity } from '../../entities/index.js';
+import { AnonymousTypeEntity, Entity, EntityContainingParameter, EntityContainingTypeParameter, PackageEntity, PackageEntityMembers, PackageMemberEntity, ParameterEntity, TypeEntityMembers, TypeMemberEntity, TypeParameterEntity, TypeWithMembersOrExtensionEntity, LocalTypeEntity } from '../../entities/index.js';
 import { PackageName, SourceFile, TranslationPackageA } from '../../project/index.js';
 import * as tree from '../../tree/a/index.js';
 import { Analyzer } from './Analyzer.js';
@@ -32,6 +32,7 @@ export declare class ResolvedTranslationPackage {
     getTranslatedPackageMember(entity: LocalizablePackageMemberEntity): LocalizablePackageMemberEntity;
     getTranslatedTypeMember(entity: TypeMemberEntity): TypeMemberEntity;
     getTranslatedAnonymousTypeEntity(entity: AnonymousTypeEntity): AnonymousTypeEntity;
+    getTranslatedLocalTypeEntity(entity: LocalTypeEntity): LocalTypeEntity;
     getTranslatedTypeOrExtensionMembers(translatedTypeEntity: TypeWithMembersOrExtensionEntity): TypeEntityMembers;
     createTranslatedTypeParameters(original: readonly TypeParameterEntity[], node: tree.TranslationTypeParameterList | undefined, containingEntity: EntityContainingTypeParameter): readonly TypeParameterEntity[];
     createTranslatedParameters(original: readonly ParameterEntity[], node: tree.TranslationParameterList | undefined, containingEntity: EntityContainingParameter): readonly ParameterEntity[];

package/build/types/analysis/a/SourceFileAnalyzer.d.ts

@@ -70,7 +70,7 @@ export declare class SourceFileAnalyzer {
     private checkParameterDeclaration;
     private checkOwnConstructorCallExpression;
     private checkReferenceExpression;
-    private checkMatchExpressionList;
+    private checkSwitchStatement;
     private checkWhileStatement;
     private checkLoopStatement;
     private checkElseIfClause;

package/build/types/analysis/a/SourcePackageMembersCreator.d.ts

@@ -1,7 +1,6 @@
-import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
 import { PackageVariableEntity } from '../../entities/index.js';
 import * as tree from '../../tree/a/index.js';
 import { Analyzer } from './Analyzer.js';
 export declare class SourcePackageMembersCreator {
-    static createMembersWithCompoundDeclarations(analyzer: Analyzer, memberList: tree.PackageMemberDeclarationList, resultingComputedVariables: Map<tree.Node, PackageVariableEntity>, diagnostics: DiagnosticAcceptor | undefined): void;
+    static createComputedPackageVariables(analyzer: Analyzer, memberList: tree.PackageMemberDeclarationList, resultingComputedVariables: Map<tree.Node, PackageVariableEntity>): void;
 }

package/build/types/analysis/a/TreeQuery.d.ts

@@ -8,8 +8,7 @@ export declare class TreeQuery {
     static getPackageEntity(node: tree.Node, analyzer: Analyzer): PackageEntity;
 }
 export declare class TypeMemberQuery {
-    static getContainingDeclaration(node: tree.TypeMemberDeclaration): TypeWithMembersOrTypeExtensionDeclaration;
+    static getContainingDeclaration(node: tree.TypeMemberDeclaration): tree.TypeWithMembersOrExtensionDeclaration;
     static getOutermostMemberBlock(node: tree.TypeMemberDeclaration): tree.TypeMemberDeclarationBlock;
     static getContextualTypeEntity(node: tree.TypeMemberDeclaration, analyzer: Analyzer): TypeEntity | undefined;
 }
-export type TypeWithMembersOrTypeExtensionDeclaration = tree.TypeWithMembersDeclaration | tree.TypeExtensionDeclaration;

package/build/types/analysis/a/TypeMemberLookup.d.ts

@@ -1,5 +1,5 @@
 import { Name } from '../../common/index.js';
-import { NamedTypeMemberEntity, TypeEntity, TypeExtensionEntity } from '../../entities/index.js';
+import { NamedTypeMemberEntity, TypeEntity, TypeExtensionEntity, OperatorKind } from '../../entities/index.js';
 import * as types from '../../types/index.js';
 import { Analyzer } from '../Analyzer.js';
 import { DialectSpecificBoundTypeMemberLookup } from '../DialectSpecificBoundTypeMemberLookup.js';
@@ -15,6 +15,8 @@ export declare class TypeMemberLookupA {
     getMatchingNamedMembersByName(name: Name, memberToMatch: NamedTypeMemberEntity, context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.NamedTypeMember[];
     getConstructors(context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.Method[];
     getDestructors(context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.Method[];
+    getOperators(context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.Method[];
+    getOperatorsByKind(kind: OperatorKind, context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.Method[];
     getIndexers(context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.Indexer[];
     getDereferenceOperators(context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.DereferenceOperator[];
 }

package/build/types/analysis/a/semantic-context/FieldWithInitializerSemanticContext.d.ts

@@ -6,14 +6,14 @@ import { NamedDeclaration, TypeOrContainerWithTypes } from './Declarations.js';
 import { SemanticContext } from './SemanticContext.js';
 import { NamedDeclarationLookupResult, SemanticContextLookupState } from './SemanticContextBase.js';
 import { SemanticContextWithParent } from './SemanticContextWithParent.js';
-import { SemanticContextContainingTypeMember } from './TypeSemanticContext.js';
+import { TypeOrExtensionMembersSemanticContext } from './TypeSemanticContext.js';
 export declare class FieldWithInitializerSemanticContext extends SemanticContextWithParent {
     readonly kind = "field-initializer";
-    readonly outer: SemanticContextContainingTypeMember;
+    readonly outer: TypeOrExtensionMembersSemanticContext;
     protected readonly asContext: SemanticContext;
     private readonly analyzer;
     private readonly node;
-    constructor(analyzer: Analyzer, node: tree.FieldDeclaration, outer: SemanticContextContainingTypeMember);
+    constructor(analyzer: Analyzer, node: tree.FieldDeclaration, outer: TypeOrExtensionMembersSemanticContext);
     isStatic(): boolean;
     getTypeMemberLookupContext(): TypeMemberLookupContext;
     getOwnTypesOrContainersWithTypes(_initialContext: SemanticContext): readonly TypeOrContainerWithTypes[];

package/build/types/analysis/a/semantic-context/SemanticContext.d.ts

@@ -2,7 +2,7 @@ import { FieldWithInitializerSemanticContext } from './FieldWithInitializerSeman
 import { SourceFileSemanticContext } from './SourceFileSemanticContext.js';
 import { CatchClauseSemanticContext, ForStatementSemanticContext, SpecialLocalDeclarationSemanticContext, StatementBlockSemanticContext, SubprogramParameterListSemanticContext, SubprogramTypeParameterSemanticContext } from './SubprogramBodyAndParametersSemanticContext.js';
 import { OutermostSemanticContextOfSubprogram } from './SubprogramSemanticContext.js';
-import { OutermostSemanticContextOfType, ParametersOfFunctionTypeSemanticContext, TypeBodySemanticContext, TypeExtensionBodySemanticContext, TypeParametersOfTypeSemanticContext } from './TypeSemanticContext.js';
+import { OutermostSemanticContextOfType, ParametersOfFunctionTypeSemanticContext, TypeMembersSemanticContext, TypeExtensionMembersSemanticContext, TypeParametersOfTypeSemanticContext } from './TypeSemanticContext.js';
 /**
  * Позволяет получить информацию, общую для определённой области
  * исходного кода (блока инструкций, списка членов типа и др.) с учётом
@@ -10,4 +10,4 @@ import { OutermostSemanticContextOfType, ParametersOfFunctionTypeSemanticContext
  * Чтобы получить семантический контекст, в котором находится определённый узел,
  * используйте `analyzer.semanticContext.containing(node)`.
  */
-export type SemanticContext = SourceFileSemanticContext | OutermostSemanticContextOfType | TypeParametersOfTypeSemanticContext | TypeBodySemanticContext | TypeBodySemanticContext | TypeExtensionBodySemanticContext | ParametersOfFunctionTypeSemanticContext | OutermostSemanticContextOfSubprogram | SubprogramTypeParameterSemanticContext | SubprogramParameterListSemanticContext | SpecialLocalDeclarationSemanticContext | StatementBlockSemanticContext | FieldWithInitializerSemanticContext | ForStatementSemanticContext | CatchClauseSemanticContext;
+export type SemanticContext = SourceFileSemanticContext | OutermostSemanticContextOfType | TypeParametersOfTypeSemanticContext | TypeMembersSemanticContext | TypeExtensionMembersSemanticContext | ParametersOfFunctionTypeSemanticContext | OutermostSemanticContextOfSubprogram | SubprogramTypeParameterSemanticContext | SubprogramParameterListSemanticContext | SpecialLocalDeclarationSemanticContext | StatementBlockSemanticContext | FieldWithInitializerSemanticContext | ForStatementSemanticContext | CatchClauseSemanticContext;

package/build/types/analysis/a/semantic-context/SemanticContextBuilder.d.ts

@@ -4,7 +4,7 @@ import { SemanticContext } from './SemanticContext.js';
 import { SourceFileSemanticContext } from './SourceFileSemanticContext.js';
 import { CatchClauseSemanticContext, ForStatementSemanticContext, SpecialLocalDeclarationSemanticContext, StatementBlockSemanticContext, SubprogramParameterListSemanticContext, SubprogramTypeParameterSemanticContext } from './SubprogramBodyAndParametersSemanticContext.js';
 import { ConstructorSemanticContext, DestructorSemanticContext, FunctionLiteralSemanticContext, FunctionSemanticContext, IndexedElementAccessorSemanticContext, OutermostSemanticContextOfSubprogram, PackageConstructorSemanticContext, PackageEntryPointSemanticContext, TextTranslationFunctionDeclarationSemanticContext, VariableAccessorDeclaration, VariableAccessorSemanticContext } from './SubprogramSemanticContext.js';
-import { OutermostSemanticContextOfType, ParametersOfFunctionTypeSemanticContext, SemanticContextContainingTypeMember, TypeBodySemanticContext, TypeDeclarationCreatingSemanticContext, TypeDeclarationWithMemberBlock, TypeExtensionBodySemanticContext, TypeParametersOfTypeSemanticContext } from './TypeSemanticContext.js';
+import { OutermostSemanticContextOfType, ParametersOfFunctionTypeSemanticContext, TypeOrExtensionMembersSemanticContext, TypeMembersSemanticContext, TypeDeclarationCreatingSemanticContext, TypeExtensionMembersSemanticContext, TypeParametersOfTypeSemanticContext, TypeDeclarationWithTypeParameters } from './TypeSemanticContext.js';
 export declare class SemanticContextBuilder {
     private readonly analyzer;
     private readonly sourceFileContexts;
@@ -18,10 +18,9 @@ export declare class SemanticContextBuilder {
     private readonly packageEntryPointContexts;
     private readonly packageConstructorContexts;
     private readonly variableAccessorContexts;
-    private readonly typeDeclarationTypeParameterContexts;
-    private readonly typeDeclarationBodyContexts;
-    private readonly typeDeclarationBodyContexts2;
-    private readonly parametersOfFunctionTypeContext;
+    private readonly typeParametersOfTypeContexts;
+    private readonly typeMembersContexts;
+    private readonly parametersOfFunctionTypeContexts;
     private readonly statementBlockContexts;
     private readonly specialLocalDeclarationContexts;
     private readonly subprogramTypeParameterContexts;
@@ -29,7 +28,7 @@ export declare class SemanticContextBuilder {
     private readonly outermostContextsOfFunctionDeclaration;
     private readonly outermostContextsOfTextTranslationFunctionDeclaration;
     private readonly outermostContextsOfTypeDeclaration;
-    private readonly typeExtensionDeclarationBodyContexts;
+    private readonly typeExtensionMembersContexts;
     constructor(analyzer: Analyzer);
     /**
      * Возвращает контекст, содержащий узел. Если в качестве узла передан исходный файл,
@@ -41,11 +40,11 @@ export declare class SemanticContextBuilder {
     ofFunctionDeclarationParameters(node: tree.FunctionDeclaration): SubprogramParameterListSemanticContext;
     ofFunctionDeclarationTypeParameters(node: tree.FunctionDeclaration, typeParameterClause: tree.TypeParameterClause): SubprogramTypeParameterSemanticContext;
     outermostSemanticContextOfFunctionDeclaration(node: tree.FunctionDeclaration): FunctionSemanticContext;
-    ofTypeDeclarationMemberBlock(typeDeclaration: TypeDeclarationWithMemberBlock, memberBlock: tree.TypeMemberDeclarationBlock): TypeBodySemanticContext;
+    ofTypeWithMembersDeclaration(node: tree.TypeWithMembersDeclaration): TypeMembersSemanticContext;
     ofFunctionTypeDeclarationParameters(node: tree.FunctionTypeDeclaration): ParametersOfFunctionTypeSemanticContext;
     outermostSemanticContextOfTypeDeclaration(node: TypeDeclarationCreatingSemanticContext): OutermostSemanticContextOfType;
-    ofTypeDeclarationTypeParameters(node: tree.PackageTypeDeclaration, typeParameterClause: tree.TypeParameterClause): TypeParametersOfTypeSemanticContext;
-    ofTypeExtensionDeclarationBody(node: tree.TypeExtensionDeclaration): TypeExtensionBodySemanticContext;
+    ofTypeDeclarationTypeParameters(node: TypeDeclarationWithTypeParameters, typeParameterClause: tree.TypeParameterClause): TypeParametersOfTypeSemanticContext;
+    ofTypeExtensionDeclaration(node: tree.TypeExtensionDeclaration): TypeExtensionMembersSemanticContext;
     ofVariableAccessorDeclaration(node: VariableAccessorDeclaration): VariableAccessorSemanticContext;
     ofPackageConstructorDeclaration(node: tree.PackageConstructorDeclaration): PackageConstructorSemanticContext;
     ofPackageEntryPointDeclaration(node: tree.PackageEntryPointDeclaration): PackageEntryPointSemanticContext;
@@ -67,12 +66,11 @@ export declare class SemanticContextBuilder {
     ofCatchClause(node: tree.CatchClause): CatchClauseSemanticContext;
     ofFieldDeclarationWithInitializer(node: tree.FieldDeclaration): SemanticContext;
     ofSubprogram(node: tree.SubprogramDeclarationOrLiteral): OutermostSemanticContextOfSubprogram;
-    containingTypeMember(node: tree.TypeMemberDeclaration): SemanticContextContainingTypeMember;
+    containingTypeMember(node: tree.TypeMemberDeclaration): TypeOrExtensionMembersSemanticContext;
     containingPackageMember(node: tree.PackageMemberDeclaration): SourceFileSemanticContext;
     private containingInternal;
     private ofChildOfFunctionDeclaration;
-    private ofChildOfTypeDeclarationWithMemberBlock;
-    private ofChildOfTypeDeclarationWithMemberBlock2;
+    private ofChildOfTypeWithMembersDeclaration;
     private ofChildOfAnonymousFunctionTypeDeclaration;
     private ofChildOfFunctionLiteral;
     private ofConstructorDeclarationChild;

package/build/types/analysis/a/semantic-context/SpecialLocalDeclarationsBuilder.d.ts

@@ -16,7 +16,6 @@ export declare class SpecialLocalDeclarationsBuilder {
     static buildForDereferencedVariableSetterDeclaration(analyzer: Analyzer, node: tree.DereferencedVariableSetterDeclaration): readonly SpecialLocalDeclarationEntity[];
     static buildForNestedFunctionDeclaration(analyzer: Analyzer, node: tree.NestedFunctionDeclaration): readonly SpecialLocalDeclarationEntity[];
     static buildForFunctionLiteral(analyzer: Analyzer, node: tree.FunctionLiteral): readonly SpecialLocalDeclarationEntity[];
-    static buildForConstructorDeclaration(analyzer: Analyzer, node: tree.ConstructorDeclaration): readonly SpecialLocalDeclarationEntity[];
     static buildForMethodDeclaration(analyzer: Analyzer, node: tree.MethodDeclaration): readonly SpecialLocalDeclarationEntity[];
     static buildForTextTranslationFunctionDeclaration(analyzer: Analyzer, node: tree.TextTranslationFunctionDeclaration): readonly SpecialLocalDeclarationEntity[];
 }

package/build/types/analysis/a/semantic-context/SubprogramBodyAndParametersSemanticContext.d.ts

@@ -76,21 +76,22 @@ export declare class SpecialLocalDeclarationSemanticContext extends SemanticCont
     protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
     protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
 }
+export type StatementSemanticContextParent = StatementBlockSemanticContext;
 export declare class ForStatementSemanticContext extends SemanticContextValidatingNameConflictsBase {
     readonly kind = "for-statement";
-    readonly outer: StatementBlockSemanticContext;
+    readonly outer: StatementSemanticContextParent;
     readonly node: tree.ForStatement;
     protected readonly asContext: SemanticContext;
-    constructor(analyzer: Analyzer, node: tree.ForStatement, outer: StatementBlockSemanticContext);
+    constructor(analyzer: Analyzer, node: tree.ForStatement, outer: StatementSemanticContextParent);
     protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
     protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
 }
 export declare class CatchClauseSemanticContext extends SemanticContextValidatingNameConflictsBase {
     readonly kind = "catch-clause";
-    readonly outer: StatementBlockSemanticContext;
+    readonly outer: StatementSemanticContextParent;
     readonly node: tree.CatchClause;
     protected readonly asContext: SemanticContext;
-    constructor(analyzer: Analyzer, node: tree.CatchClause, outer: StatementBlockSemanticContext);
+    constructor(analyzer: Analyzer, node: tree.CatchClause, outer: StatementSemanticContextParent);
     protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
     protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
 }

package/build/types/analysis/a/semantic-context/SubprogramSemanticContext.d.ts

@@ -7,7 +7,7 @@ import { SemanticContext } from './SemanticContext.js';
 import { NamedDeclarationLookupResult, ObjectVariableInfo, SemanticContextLookupState, SubprogramInfo, TryStatementContextKind } from './SemanticContextBase.js';
 import { SemanticContextWithParent } from './SemanticContextWithParent.js';
 import { SourceFileSemanticContext } from './SourceFileSemanticContext.js';
-import { SemanticContextContainingTypeMember } from './TypeSemanticContext.js';
+import { TypeOrExtensionMembersSemanticContext } from './TypeSemanticContext.js';
 export type LastSemanticContextOfSubprogramParent = SemanticContext;
 /**
  * Завершающий семантический контекст подпрограммы.
@@ -65,45 +65,46 @@ export declare class PackageEntryPointSemanticContext extends OutermostSemanticC
     protected findObjectParameter(): ParameterEntity | undefined;
 }
 export declare class ConstructorSemanticContext extends OutermostSemanticContextOfSubprogram {
-    readonly outer: SemanticContextContainingTypeMember;
+    readonly outer: TypeOrExtensionMembersSemanticContext;
     protected readonly asContext: SemanticContext;
     protected readonly analyzer: Analyzer;
     private readonly node;
     private readonly subprogramInfo;
-    constructor(analyzer: Analyzer, node: tree.ConstructorDeclaration, outer: SemanticContextContainingTypeMember);
+    constructor(analyzer: Analyzer, node: tree.ConstructorDeclaration, outer: TypeOrExtensionMembersSemanticContext);
     getContainingSubprogram(): SubprogramInfo;
     protected findObjectParameter(): ParameterEntity | undefined;
 }
 export declare class DestructorSemanticContext extends OutermostSemanticContextOfSubprogram {
-    readonly outer: SemanticContextContainingTypeMember;
+    readonly outer: TypeOrExtensionMembersSemanticContext;
     protected readonly asContext: SemanticContext;
     protected readonly analyzer: Analyzer;
     private readonly node;
     private readonly subprogramInfo;
-    constructor(analyzer: Analyzer, node: tree.DestructorDeclaration, outer: SemanticContextContainingTypeMember);
+    constructor(analyzer: Analyzer, node: tree.DestructorDeclaration, outer: TypeOrExtensionMembersSemanticContext);
     getContainingSubprogram(): SubprogramInfo;
     protected findObjectParameter(): ParameterEntity | undefined;
 }
-export type AccessorSemanticContextParent = SemanticContextContainingTypeMember | SourceFileSemanticContext;
+export type VariableAccessorSemanticContextParent = TypeOrExtensionMembersSemanticContext | SourceFileSemanticContext;
 export type VariableAccessorDeclaration = tree.PackageVariableAccessorDeclaration | tree.FieldAccessorDeclaration | tree.DereferencedVariableAccessorDeclaration;
 export declare class VariableAccessorSemanticContext extends OutermostSemanticContextOfSubprogram {
-    readonly outer: AccessorSemanticContextParent;
+    readonly outer: VariableAccessorSemanticContextParent;
     protected readonly asContext: SemanticContext;
     protected readonly analyzer: Analyzer;
     private readonly node;
     private readonly subprogramInfo;
-    constructor(analyzer: Analyzer, node: VariableAccessorDeclaration, outer: AccessorSemanticContextParent);
+    constructor(analyzer: Analyzer, node: VariableAccessorDeclaration, outer: VariableAccessorSemanticContextParent);
     getContainingSubprogram(): SubprogramInfo;
     isStatic(): boolean;
     protected findObjectParameter(): ParameterEntity | undefined;
 }
+export type IndexedElementAccessorSemanticContextParent = TypeOrExtensionMembersSemanticContext;
 export declare class IndexedElementAccessorSemanticContext extends OutermostSemanticContextOfSubprogram {
-    readonly outer: AccessorSemanticContextParent;
+    readonly outer: IndexedElementAccessorSemanticContextParent;
     protected readonly asContext: SemanticContext;
     protected readonly analyzer: Analyzer;
     private readonly node;
     private readonly subprogramInfo;
-    constructor(analyzer: Analyzer, node: tree.IndexedElementAccessorDeclaration, outer: AccessorSemanticContextParent);
+    constructor(analyzer: Analyzer, node: tree.IndexedElementAccessorDeclaration, outer: IndexedElementAccessorSemanticContextParent);
     getContainingSubprogram(): SubprogramInfo;
     isStatic(): boolean;
     protected findObjectParameter(): ParameterEntity | undefined;