@artel/artc 0.6.26016 → 0.6.26017

package/build/{chunk-6YO3VB2X.js → chunk-UCBPXOLW.js}

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

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

@@ -52,7 +52,6 @@ export declare class AnalyzedTranslationPackage {
     private getTypeTranslationTargets;
     private getFieldOrVariantTranslationTargets;
     private getMethodTranslationTargets;
-    private tryGetOperatorTranslationTargets;
     private getConstructorTranslationTargets;
     private getIndexerTranslationTargets;
     private checkTranslatedTypeParameterCount;

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

@@ -200,7 +200,6 @@ export declare class Analyzer {
     getDenotedPackageAlias(expression: tree.Expression): e.PackageAliasEntity | undefined;
     getDenotedFunction(expression: tree.Expression): ExpressionDenotesFunctionCheckResult | undefined;
     isExpressionDenotingFunction(expression: tree.Expression): boolean;
-    getDenotedOperator(expression: tree.Expression): ExpressionDenotesOperatorCheckResult | undefined;
     getDenotedPackageNameTreeNode(expression: tree.Expression): PackageNameTreeNode | undefined;
     /**
      * Функция считается генератором, если:
@@ -212,9 +211,9 @@ export declare class Analyzer {
     isFunctionGenerator(node: FunctionDeclaration): boolean;
     allAspectsOfType(type: types.Type): Iterable<types.StructuredType>;
     checkTypeIsBasedOnAspect(type: types.Type, aspectEntity: e.StructuredTypeEntity): boolean;
-    resolvePrefixUnaryExpressionUserDefinableOperator(node: tree.PrefixUnaryExpression): types.Operator | undefined;
-    resolveBinaryExpressionUserDefinableOperator(node: tree.BinaryExpression, operatorKind: BinaryOperatorKind): types.Operator | undefined;
-    resolveCompoundAssignmentStatementOperator(node: tree.AssignmentStatement, operatorKind: BinaryOperatorKind): types.Operator | undefined;
+    resolvePrefixUnaryExpressionUserDefinableOperator(node: tree.PrefixUnaryExpression): types.Method | undefined;
+    resolveBinaryExpressionUserDefinableOperator(node: tree.BinaryExpression, operatorKind: BinaryOperatorKind): types.Method | undefined;
+    resolveCompoundAssignmentStatementOperator(node: tree.AssignmentStatement, operatorKind: BinaryOperatorKind): types.Method | undefined;
     classifyBinaryExpressionOperator(operator: tree.BinaryExpressionOperator): BinaryExpressionOperatorClassificationResult;
     getBinaryOperatorKindIfCompoundAssignmentOperator(operator: tree.AssignmentStatementOperator): BinaryOperatorKind | undefined;
     getOriginalPackageEntities(): readonly e.PackageEntity[];
@@ -284,7 +283,6 @@ export declare class Analyzer {
     instantiateTypeByIdentitySubstitution(entity: e.TypeEntity): types.Type;
     instantiateTypeMemberByIdentitySubstitution(entity: e.FieldEntity): types.Field;
     instantiateTypeMemberByIdentitySubstitution(entity: e.MethodEntity): types.Method;
-    instantiateTypeMemberByIdentitySubstitution(entity: e.OperatorEntity): types.Operator;
     instantiateTypeMemberByIdentitySubstitution(entity: e.IndexerEntity): types.Indexer;
     instantiateTypeMemberByIdentitySubstitution(entity: e.DereferenceOperatorEntity): types.DereferenceOperator;
     instantiateTypeMemberByIdentitySubstitution(entity: e.ConstructorEntity): types.Constructor;
@@ -359,7 +357,6 @@ export declare namespace BinaryExpressionOperatorClassificationResult {
     const subtract: BinaryExpressionOperatorClassificationResult;
     const add: BinaryExpressionOperatorClassificationResult;
     const divide: BinaryExpressionOperatorClassificationResult;
-    const integerDivide: BinaryExpressionOperatorClassificationResult;
     const modulo: BinaryExpressionOperatorClassificationResult;
     const bitwiseAnd: BinaryExpressionOperatorClassificationResult;
     const bitwiseOr: BinaryExpressionOperatorClassificationResult;
@@ -453,7 +450,6 @@ declare class ReturnType {
     ofNestedFunctionDeclaration(node: tree.NestedFunctionDeclaration): types.Type;
     ofFunctionLiteral(node: tree.FunctionLiteral): types.Type;
     ofMethodDeclaration(node: tree.MethodDeclaration): types.Type;
-    ofOperatorDeclaration(node: tree.OperatorDeclaration): types.Type;
     ofPackageVariableGetterDeclaration(node: tree.PackageVariableGetterDeclaration): types.Type;
     ofFieldGetterDeclaration(node: tree.FieldGetterDeclaration): types.Type;
     ofDereferencedVariableGetterDeclaration(node: tree.DereferencedVariableGetterDeclaration): types.Type;
@@ -481,7 +477,6 @@ declare class Entity {
     private readonly methodEntities;
     private readonly nestedFunctionEntities;
     private readonly constructorEntities;
-    private readonly operatorEntities;
     private readonly destructorEntities;
     private readonly getterEntities;
     private readonly setterEntities;
@@ -518,7 +513,6 @@ declare class Entity {
     ofPackageFunctionDeclaration(node: tree.PackageFunctionDeclaration): e.PackageFunctionEntity;
     ofMethodDeclaration(node: tree.MethodDeclaration): e.MethodEntity;
     ofNestedFunctionDeclaration(node: tree.NestedFunctionDeclaration): e.NestedFunctionEntity;
-    ofOperatorDeclaration(node: tree.OperatorDeclaration): e.OperatorEntity;
     ofPackageVariableGetterDeclaration(node: tree.PackageVariableGetterDeclaration): e.GetterEntity;
     ofFieldGetterDeclaration(node: tree.FieldGetterDeclaration): e.GetterEntity;
     ofIndexedElementGetterDeclaration(node: tree.IndexedElementGetterDeclaration): e.GetterEntity;
@@ -560,7 +554,6 @@ declare class ResultLocalVariableEntity {
     ofNestedFunctionDeclaration(node: tree.NestedFunctionDeclaration): e.LocalVariableEntity;
     ofFunctionLiteral(node: tree.FunctionLiteral): e.LocalVariableEntity;
     ofFunctionBlockLiteral(node: tree.FunctionBlockLiteral): e.LocalVariableEntity;
-    ofOperatorDeclaration(node: tree.OperatorDeclaration): e.LocalVariableEntity;
     ofPackageVariableGetterDeclaration(node: tree.PackageVariableGetterDeclaration): e.LocalVariableEntity;
     ofFieldGetterDeclaration(node: tree.FieldGetterDeclaration): e.LocalVariableEntity;
     ofIndexedElementGetterDeclaration(node: tree.IndexedElementGetterDeclaration): e.LocalVariableEntity;
@@ -607,34 +600,28 @@ declare class OverriddenMember {
     private readonly analyzer;
     static readonly signatureComparisonOptions = SignatureComparisonOptions.None;
     private readonly namedMemberFinder;
-    private readonly operatorFinder;
     private readonly indexerFinder;
     private readonly dereferenceOperatorFinder;
     private readonly isField;
     private readonly isMethod;
-    private readonly isOperator;
     private readonly isIndexer;
     private readonly isDereferenceOperator;
     private readonly overriddenAndShadowedFields;
     private readonly overriddenAndShadowedMethods;
-    private readonly overriddenAndShadowedOperators;
     private readonly overriddenAndShadowedIndexers;
     private readonly overriddenAndShadowedDereferenceOperators;
     constructor(analyzer: Analyzer);
     getOverriddenAndShadowedFields(node: tree.FieldDeclaration | FieldAccessorDeclaration): OverriddenAndShadowedMembers<types.Field, types.NamedTypeMember>;
     getOverriddenAndShadowedMethods(node: tree.MethodDeclaration): OverriddenAndShadowedMembers<types.Method, types.NamedTypeMember>;
-    getOverriddenAndShadowedOperators(node: tree.OperatorDeclaration): OverriddenAndShadowedMembers<types.Operator>;
     getOverriddenAndShadowedIndexers(node: IndexedElementAccessorDeclaration): OverriddenAndShadowedMembers<types.Indexer>;
     getOverriddenAndShadowedDereferenceOperators(node: DereferencedVariableAccessorDeclaration): OverriddenAndShadowedMembers<types.DereferenceOperator>;
     entityCanBeOverridden(entity: OverridableTypeMemberEntity): boolean;
     getMemberTypeOrReturnType(member: types.TypeMember): types.Type;
     private findOverriddenMembers;
     private findOverriddenOrShadowedNamedMembersInType;
-    private findOverriddenOrShadowedOperatorsInType;
     private findOverriddenOrShadowedIndexersInType;
     private findOverriddenOrShadowedDereferenceOperatorsInType;
     private checkMethodOverridesOrShadowsMethod;
-    private checkOperatorOverridesOrShadowsOperator;
     private checkIndexerOverridesOrShadowsIndexer;
     private typeMemberLookups;
     private typesForOverriddenMemberLookup;
@@ -657,9 +644,9 @@ export declare class OverriddenAndShadowedMembers<TOverriddenMember extends Over
     readonly shadowedMembers: readonly ShadowedMemberInfo<TShadowedMember>[];
     constructor(overriddenMembers: readonly TOverriddenMember[], shadowedMembers: readonly ShadowedMemberInfo<TShadowedMember>[]);
 }
-export type OverridableTypeMemberEntity = e.FieldEntity | e.MethodEntity | e.OperatorEntity | e.IndexerEntity | e.DereferenceOperatorEntity;
+export type OverridableTypeMemberEntity = e.FieldEntity | e.MethodEntity | e.IndexerEntity | e.DereferenceOperatorEntity;
 export declare function isOverridableTypeMemberEntity(entity: e.TypeMemberEntity): entity is OverridableTypeMemberEntity;
-export type OverridableTypeMember = types.Field | types.Method | types.Operator | types.Indexer | types.DereferenceOperator;
+export type OverridableTypeMember = types.Field | types.Method | types.Indexer | types.DereferenceOperator;
 export declare function isOverridableTypeMember(entity: types.TypeMember): entity is OverridableTypeMember;
 export type NodeWithTags = tree.PackageMemberDeclaration | tree.TypeMemberDeclaration | tree.ParameterDeclaration;
 declare class Tags {
@@ -682,7 +669,6 @@ declare class ImplementationEntity {
     ofPackageFunction(entity: e.PackageFunctionEntity, platform: PlatformKind): e.PackageFunctionEntity | undefined;
     ofField(entity: e.FieldEntity, platform: PlatformKind): e.FieldEntity | undefined;
     ofMethod(entity: e.MethodEntity, platform: PlatformKind): e.MethodEntity | undefined;
-    ofOperator(entity: e.OperatorEntity, platform: PlatformKind): e.OperatorEntity | undefined;
     ofConstructor(entity: e.ConstructorEntity, platform: PlatformKind): e.ConstructorEntity | undefined;
     ofDestructor(entity: e.DestructorEntity, platform: PlatformKind): e.DestructorEntity | undefined;
     ofIndexer(entity: e.IndexerEntity, platform: PlatformKind): e.IndexerEntity | undefined;
@@ -825,8 +811,8 @@ declare class ConflictsCheck {
      */
     doPackageTypesConflict(type1: e.PackageTypeEntity, type2: e.PackageTypeEntity): boolean;
 }
-export type EntityWithoutTypeParametersInSignature = e.ConstructorEntity | e.DestructorEntity | e.OperatorEntity | e.IndexerEntity;
-export type TypeMemberWithoutTypeParametersInSignature = types.Constructor | types.Destructor | types.Operator | types.Indexer;
+export type EntityWithoutTypeParametersInSignature = e.ConstructorEntity | e.DestructorEntity | e.IndexerEntity;
+export type TypeMemberWithoutTypeParametersInSignature = types.Constructor | types.Destructor | types.Indexer;
 export declare class ExpressionDenotesFunctionCheckResult {
     readonly candidates: readonly AccessedFunction[];
     readonly suitableFunctions: readonly AccessedFunction[];
@@ -835,22 +821,15 @@ export declare class ExpressionDenotesFunctionCheckResult {
     get singleFunction(): AccessedFunction | undefined;
     constructor(candidates: readonly AccessedFunction[], suitableFunctions: readonly AccessedFunction[], singleNotSuitableSubstitutedCandidate: AccessedFunction | undefined);
 }
-export declare class ExpressionDenotesOperatorCheckResult {
-    readonly candidates: readonly types.Operator[];
-    readonly suitableOperators: readonly types.Operator[];
-    get singleSuitableOperator(): types.Operator | undefined;
-    constructor(candidates: readonly types.Operator[], suitableOperators: readonly types.Operator[]);
-}
 export declare class DeclaredTypeMemberEntities {
     readonly variables: readonly e.FieldEntity[];
     readonly methods: readonly e.MethodEntity[];
-    readonly operators: readonly e.OperatorEntity[];
     readonly constructors: readonly e.ConstructorEntity[];
     readonly destructors: readonly e.DestructorEntity[];
     readonly indexers: readonly e.IndexerEntity[];
     readonly dereferenceOperators: readonly e.DereferenceOperatorEntity[];
     get namedMembers(): e.NamedTypeMemberEntity[];
-    constructor(variables: readonly e.FieldEntity[], methods: readonly e.MethodEntity[], operators: readonly e.OperatorEntity[], constructors: readonly e.ConstructorEntity[], destructors: readonly e.DestructorEntity[], indexers: readonly e.IndexerEntity[], dereferenceOperators: readonly e.DereferenceOperatorEntity[]);
+    constructor(variables: readonly e.FieldEntity[], methods: readonly e.MethodEntity[], constructors: readonly e.ConstructorEntity[], destructors: readonly e.DestructorEntity[], indexers: readonly e.IndexerEntity[], dereferenceOperators: readonly e.DereferenceOperatorEntity[]);
 }
 export declare class ExpressionAnalysisOptions {
     readonly targetType: types.Type | undefined;

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

@@ -12,7 +12,6 @@ export declare class FirstStageResolver {
     private resolveBaseConstructorOrMethodAccess;
     private resolveBaseConstructorAccess;
     private resolveBaseMethodAccess;
-    private resolveBaseOperatorAccess;
     private resolveBaseObjectAccess;
     private invalidContextDiagnostic;
     private getBaseOrAliasedType;
@@ -35,9 +34,8 @@ export declare class SecondStageResolver {
     constructor(analyzer: Analyzer, node: tree.BaseExpression, firstStageMeaning: MeaningStage1, diagnostics: DiagnosticAcceptor | undefined);
     resolve(): Meaning;
     private resolveOverriddenMethodAccess;
-    private resolveOverriddenOperatorAccess;
 }
-export type Meaning = Meaning_baseObjectAccess | Meaning_baseConstructorAccess | Meaning_overriddenMethodAccess | Meaning_overriddenOperatorAccess | Meaning_unresolved;
+export type Meaning = Meaning_baseObjectAccess | Meaning_baseConstructorAccess | Meaning_overriddenMethodAccess | Meaning_unresolved;
 declare class Meaning_baseObjectAccess {
     readonly type: types.Type;
     readonly kind = "base-object-access";
@@ -72,23 +70,13 @@ declare class Meaning_overriddenMethodAccess {
     readonly kind = "overridden-method-access";
     constructor(method: AccessedFunction);
 }
-declare class Meaning_overriddenOperatorAccess {
-    readonly operator: types.Operator;
-    readonly kind = "overridden-operator-access";
-    constructor(operator: types.Operator);
-}
 declare class Meaning_unresolved {
     readonly kind = "unresolved";
 }
-export type MeaningStage1 = Meaning_baseObjectAccess | Meaning_baseConstructorAccess | MeaningStage1_overriddenMethodAccess | MeaningStage1_overriddenOperatorAccess | Meaning_unresolved;
+export type MeaningStage1 = Meaning_baseObjectAccess | Meaning_baseConstructorAccess | MeaningStage1_overriddenMethodAccess | Meaning_unresolved;
 declare class MeaningStage1_overriddenMethodAccess {
     readonly method: types.Method;
     readonly kind = "overridden-method-access";
     constructor(method: types.Method);
 }
-declare class MeaningStage1_overriddenOperatorAccess {
-    readonly operator: types.Operator;
-    readonly kind = "overridden-operator-access";
-    constructor(operator: types.Operator);
-}
 export {};

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

@@ -13,13 +13,11 @@ export declare class Resolver {
     resolve(): Meaning;
     private checkExpressionDenotesType;
     private checkExpressionDenotesFunction;
-    private checkExpressionDenotesOperator;
     private resolveFunctionCallExpression;
-    private resolveOperatorCallExpression;
     private resolveConstructorCallExpression;
     private resolveObjectFunctionCallExpression;
 }
-export type Meaning = Meaning_functionCall | Meaning_operatorCall | Meaning_objectFunctionCall | Meaning_constructorCall | Meaning_unresolved;
+export type Meaning = Meaning_functionCall | Meaning_objectFunctionCall | Meaning_constructorCall | Meaning_unresolved;
 export declare class Meaning_functionCall {
     readonly candidates: readonly NotSubstitutedAccessedFunction[];
     readonly suitableFunctions: readonly AccessedFunction[];
@@ -29,14 +27,6 @@ export declare class Meaning_functionCall {
     get singleFunction(): AccessedFunction | undefined;
     constructor(candidates: readonly NotSubstitutedAccessedFunction[], suitableFunctions: readonly AccessedFunction[], singleNotSuitableSubstitutedCandidate: AccessedFunction | undefined);
 }
-export declare class Meaning_operatorCall {
-    readonly candidates: readonly types.Operator[];
-    readonly suitableOperators: readonly types.Operator[];
-    readonly kind = "operator-call";
-    get singleSuitableOperator(): types.Operator | undefined;
-    get singleOperator(): types.Operator | undefined;
-    constructor(candidates: readonly types.Operator[], suitableOperators: readonly types.Operator[]);
-}
 export declare class Meaning_objectFunctionCall {
     readonly type: types.FunctionType;
     readonly kind = "object-function-call";

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

@@ -16,7 +16,6 @@ export declare class FirstStageResolver {
     private get semanticContext();
     constructor(analyzer: Analyzer, node: tree.IdentifierExpression, diagnostics: DiagnosticAcceptor | undefined);
     resolve(): MeaningStage1;
-    private tryResolveOperatorAccessMeaning;
     private resolveTypeAccess;
     private createNotSubstitutedAccessedFunction;
     private convertSyntacticAccessKind;
@@ -31,10 +30,9 @@ export declare class SecondStageResolver {
     resolve(): Meaning;
     private resolveTypeAccessAtCalleePosition;
     private resolveFunctionAccess;
-    private resolveOperatorAccess;
     private resolveNotCalledFunctionsAccess;
 }
-export type Meaning = Meaning_variableAccess | Meaning_functionAccess | Meaning_operatorAccess | 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_constructorAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
 declare class Meaning_variableAccess {
     readonly variable: AccessedVariable;
     readonly accessKind: AccessKind;
@@ -52,15 +50,6 @@ declare class Meaning_functionAccess {
     get singleFunction(): AccessedFunction | undefined;
     constructor(candidates: readonly NotSubstitutedAccessedFunction[], suitableFunctions: readonly AccessedFunction[], singleNotSuitableSubstitutedCandidate: AccessedFunction | undefined, objectParameterContainingFunctions: ParameterEntity | undefined);
 }
-declare class Meaning_operatorAccess {
-    readonly candidates: readonly types.Operator[];
-    readonly suitableOperators: readonly types.Operator[];
-    readonly objectParameterContainingOperators: ParameterEntity | undefined;
-    readonly kind = "operator-access";
-    get singleSuitableOperator(): types.Operator | undefined;
-    get singleOperator(): types.Operator | undefined;
-    constructor(candidates: readonly types.Operator[], suitableOperators: readonly types.Operator[], objectParameterContainingOperators: ParameterEntity | undefined);
-}
 declare class Meaning_packageAliasAccess {
     readonly packageAlias: PackageAliasEntity;
     readonly kind = "package-alias-access";
@@ -92,7 +81,7 @@ declare class Meaning_mixedAmbiguousAccess {
 declare class Meaning_unresolved {
     readonly kind = "unresolved";
 }
-export type MeaningStage1 = Meaning_variableAccess | MeaningStage1_functionAccess | MeaningStage1_operatorAccess | Meaning_packageNameSegmentAccess | Meaning_packageAliasAccess | MeaningStage1_typeAccessAtCalleePosition | Meaning_typeAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
+export type MeaningStage1 = Meaning_variableAccess | MeaningStage1_functionAccess | Meaning_packageNameSegmentAccess | Meaning_packageAliasAccess | MeaningStage1_typeAccessAtCalleePosition | Meaning_typeAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
 declare class MeaningStage1_typeAccessAtCalleePosition {
     readonly types: readonly NamedTypeEntity[];
     readonly kind = "type-access-at-callee-position";
@@ -104,12 +93,6 @@ declare class MeaningStage1_functionAccess {
     readonly kind = "function-access";
     constructor(functions: readonly NotSubstitutedAccessedFunction[], objectParameterContainingFunctions: ParameterEntity | undefined);
 }
-declare class MeaningStage1_operatorAccess {
-    readonly operators: readonly types.Operator[];
-    readonly objectParameterContainingOperators: ParameterEntity | undefined;
-    readonly kind = "operator-access";
-    constructor(operators: readonly types.Operator[], objectParameterContainingOperators: ParameterEntity | undefined);
-}
 export type AccessedVariable = AccessedVariable_entity | AccessedVariable_typeMember;
 export declare class AccessedVariable_entity implements IAccessedVariable {
     readonly value: VariableEntity;

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

@@ -23,7 +23,6 @@ export declare class FirstStageResolver {
     private resolvePackageNameSegmentAccessMeaning;
     private resolveStaticMemberOrVariantAccessMeaning;
     private resolveInstanceMemberAccessMeaning;
-    private tryResolveInstanceOperatorAccessMeaning;
     private convertPackageVariableSyntacticAccessKind;
     private convertFieldSyntacticAccessKind;
 }
@@ -40,9 +39,8 @@ export declare class SecondStageResolver {
     private resolveStaticMethodAccess;
     private resolveInstanceMethodAccess;
     private resolveNotCalledFunctionsAccess;
-    private resolveOperatorAccess;
 }
-export type Meaning = Meaning_packageVariableAccess | Meaning_packageFunctionAccess | Meaning_packageTypeAccess | Meaning_constructorAccess | Meaning_packageNameSegmentAccess | Meaning_staticFieldAccess | Meaning_staticMethodAccess | Meaning_instanceFieldAccess | Meaning_instanceMethodAccess | Meaning_operatorAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
+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;
 declare class Meaning_packageVariableAccess {
     readonly variable: PackageVariableEntity;
     readonly accessKind: AccessKind;
@@ -108,14 +106,6 @@ declare class Meaning_instanceMethodAccess {
     get singleFunction(): AccessedFunction | undefined;
     constructor(candidates: readonly NotSubstitutedAccessedFunction[], suitableFunctions: readonly AccessedFunction[], singleNotSuitableSubstitutedCandidate: AccessedFunction | undefined);
 }
-declare class Meaning_operatorAccess {
-    readonly candidates: readonly types.Operator[];
-    readonly suitableOperators: readonly types.Operator[];
-    readonly kind = "operator-access";
-    get singleSuitableOperator(): types.Operator | undefined;
-    get singleOperator(): types.Operator | undefined;
-    constructor(candidates: readonly types.Operator[], suitableOperators: readonly types.Operator[]);
-}
 declare class Meaning_mixedAmbiguousAccess {
     readonly entities: readonly Entity[];
     readonly kind = "mixed-ambiguous-access";
@@ -124,7 +114,7 @@ declare class Meaning_mixedAmbiguousAccess {
 declare class Meaning_unresolved {
     readonly kind = "unresolved";
 }
-export type MeaningStage1 = Meaning_packageVariableAccess | MeaningStage1_packageFunctionAccess | Meaning_packageTypeAccess | MeaningStage1_typeAccessAtCalleePosition | Meaning_packageNameSegmentAccess | Meaning_staticFieldAccess | MeaningStage1_staticMethodAccess | Meaning_instanceFieldAccess | MeaningStage1_instanceMethodAccess | MeaningStage1_operatorAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
+export type MeaningStage1 = Meaning_packageVariableAccess | MeaningStage1_packageFunctionAccess | Meaning_packageTypeAccess | MeaningStage1_typeAccessAtCalleePosition | Meaning_packageNameSegmentAccess | Meaning_staticFieldAccess | MeaningStage1_staticMethodAccess | Meaning_instanceFieldAccess | MeaningStage1_instanceMethodAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
 declare class MeaningStage1_typeAccessAtCalleePosition {
     readonly types: readonly PackageTypeEntity[];
     readonly kind = "type-access-at-callee-position";
@@ -146,9 +136,4 @@ declare class MeaningStage1_instanceMethodAccess {
     readonly kind = "instance-method-access";
     constructor(functions: readonly NotSubstitutedAccessedFunction[]);
 }
-declare class MeaningStage1_operatorAccess {
-    readonly operators: readonly types.Operator[];
-    readonly kind = "operator-access";
-    constructor(operators: readonly types.Operator[]);
-}
 export {};

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

@@ -10,7 +10,6 @@ export declare class ReductionSourceMemberFinder {
     constructor(analyzer: Analyzer);
     findField(member: types.Field, reductionSource: types.Type, lookupContext: TypeMemberLookupContext, diagnostics: DiagnosticAcceptor, diagnosticLocation: NodeOrDiagnosticLocation): types.Field | undefined;
     findMethod(member: types.Method, reductionSource: types.Type, lookupContext: TypeMemberLookupContext, diagnostics: DiagnosticAcceptor, diagnosticLocation: NodeOrDiagnosticLocation): types.Method | undefined;
-    findOperator(member: types.Operator, reductionSource: types.Type, lookupContext: TypeMemberLookupContext, diagnostics: DiagnosticAcceptor, diagnosticLocation: NodeOrDiagnosticLocation): types.Operator | undefined;
     findConstructor(member: types.Constructor, reductionSource: types.Type, lookupContext: TypeMemberLookupContext, diagnostics: DiagnosticAcceptor, diagnosticLocation: NodeOrDiagnosticLocation): types.Constructor | undefined;
     findDestructor(member: types.Destructor, reductionSource: types.Type, lookupContext: TypeMemberLookupContext, diagnostics: DiagnosticAcceptor, diagnosticLocation: NodeOrDiagnosticLocation): types.Destructor | undefined;
     findIndexer(member: types.Indexer, reductionSource: types.Type, lookupContext: TypeMemberLookupContext, diagnostics: DiagnosticAcceptor, diagnosticLocation: NodeOrDiagnosticLocation): types.Indexer | undefined;

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

@@ -1,4 +1,4 @@
-import { ConstructorEntity, DereferenceOperatorEntity, DestructorEntity, FieldEntity, IndexerEntity, MethodEntity, OperatorEntity, PackageEntity, PackageFunctionEntity, PackageTypeEntity, PackageVariableEntity, TypeEntity } from '../entities/index.js';
+import { ConstructorEntity, DereferenceOperatorEntity, DestructorEntity, FieldEntity, IndexerEntity, MethodEntity, PackageEntity, PackageFunctionEntity, PackageTypeEntity, PackageVariableEntity, TypeEntity } from '../entities/index.js';
 import { PlatformKind } from '../project/index.js';
 import { Analyzer } from './Analyzer.js';
 export declare class ResolvedImplementationPackage {
@@ -24,7 +24,6 @@ export declare class ResolvedImplementationPackage {
     getPackageTypeImplementation(entity: PackageTypeEntity): PackageTypeEntity | undefined;
     getFieldImplementation(entity: FieldEntity): FieldEntity | undefined;
     getMethodImplementation(entity: MethodEntity): MethodEntity | undefined;
-    getOperatorImplementation(entity: OperatorEntity): OperatorEntity | undefined;
     getConstructorImplementation(entity: ConstructorEntity): ConstructorEntity | undefined;
     getDestructorImplementation(entity: DestructorEntity): DestructorEntity | undefined;
     getIndexerImplementation(entity: IndexerEntity): IndexerEntity | undefined;
@@ -33,7 +32,6 @@ export declare class ResolvedImplementationPackage {
     private getTypeMemberImplementations;
     private findFieldImplementation;
     private findMethodImplementation;
-    private findOperatorImplementation;
     private findConstructorImplementation;
     private findDestructorImplementation;
     private findIndexerImplementation;

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

@@ -51,7 +51,6 @@ export declare class SourceFileAnalyzer {
     private checkPackageVariableSetterDeclaration;
     private checkConstructorDeclaration;
     private checkMethodDeclaration;
-    private checkOperatorDeclaration;
     private checkFieldDeclaration;
     private checkFieldGetterDeclaration;
     private checkFieldSetterDeclaration;
@@ -101,6 +100,7 @@ export declare class SourceFileAnalyzer {
     private overridingMemberHasCorrectHiding;
     private checkTextTranslationDeclaration;
     private attachNodeLocationAndAddDiagnostics;
+    private createAndAddDiagnostic;
     private addDiagnostic;
     private addDiagnostics;
     private addDiagnosticsLocatedInAnalyzedFile;

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

@@ -0,0 +1,32 @@
+import { Name } from '../common/index.js';
+import { OperatorKind } from '../entities/OperatorKind.js';
+import { OperatorKind as SyntacticalOperatorKind } from '../tree/OperatorKind.js';
+export declare const specialNameKeys: {
+    readonly objectParameter: "-объект";
+    readonly plusOperator: "+";
+    readonly minusOperator: "-";
+    readonly notOperator: "-не";
+    readonly multiplyOperator: "*";
+    readonly divideOperator: "/";
+    readonly moduloOperator: "%";
+    readonly lessThanOperator: "<";
+    readonly greaterThanOperator: ">";
+    readonly lessThanOrEqualOperator: "<=";
+    readonly greaterThanOrEqualOperator: ">=";
+    readonly orOperator: "-или";
+    readonly andOperator: "-и";
+    readonly xorOperator: "-искл";
+    readonly bitwiseAndOperator: "&";
+    readonly bitwiseOrOperator: "|";
+    readonly bitwiseXorOperator: "||";
+    readonly leftShiftOperator: "<<";
+    readonly signedRightShiftOperator: ">>";
+    readonly unsignedRightShiftOperator: ">>>";
+};
+export declare const specialNames: { readonly [K in keyof typeof specialNameKeys]: Name; };
+export declare const specialNameKeyBySyntacticalOperatorKind: {
+    readonly [T in SyntacticalOperatorKind]: string;
+};
+export declare const searchNameByOperatorKind: {
+    readonly [T in OperatorKind]: Name;
+};

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

@@ -12,7 +12,6 @@ export declare class TypeMemberConflictsValidator {
     private validateMethodsWithSameName;
     private validateConstructors;
     private validateDestructors;
-    private validateOperators;
     private validateIndexers;
     private validateDereferenceOperators;
     private validateMembersWithoutTypeParametersInSignature;

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

@@ -1,5 +1,5 @@
 import { Name, PackageLocale } from '../common/index.js';
-import { OperatorKind, PackageEntity, TypeEntity, TypeExtensionEntity, TypeOrExtensionEntity } from '../entities/index.js';
+import { PackageEntity, TypeEntity, TypeExtensionEntity, TypeOrExtensionEntity } from '../entities/index.js';
 import { SourceFile } from '../project/SourceFile.js';
 import * as types from '../types/index.js';
 import { Analyzer } from './Analyzer.js';
@@ -14,8 +14,6 @@ export declare class TypeMemberLookup {
     static ofTypeOrExtension(analyzer: Analyzer, typeOrExtension: TypeOrExtension): TypeMemberLookup;
     getNamedMembers(context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.NamedTypeMember[];
     getNamedMembersByName(name: Name, context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.NamedTypeMember[];
-    getOperators(context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.Operator[];
-    getOperatorsByKind(kind: OperatorKind, context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.Operator[];
     getConstructors(context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.Constructor[];
     getDestructors(context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.Destructor[];
     getIndexers(context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.Indexer[];
@@ -31,8 +29,6 @@ export declare class BoundTypeMemberLookup {
     static ofTypeExtension(analyzer: Analyzer, typeExtension: TypeExtensionEntity, context: TypeMemberLookupContext | undefined, options: TypeMemberLookupOptions): BoundTypeMemberLookup;
     getNamedMembers(): readonly types.NamedTypeMember[];
     getNamedMembersByName(name: Name): readonly types.NamedTypeMember[];
-    getOperators(): readonly types.Operator[];
-    getOperatorsByKind(kind: OperatorKind): readonly types.Operator[];
     getConstructors(): readonly types.Constructor[];
     getDestructors(): readonly types.Destructor[];
     getIndexers(): readonly types.Indexer[];

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

@@ -29,6 +29,6 @@ export declare class UserDefinableBinaryOperatorResolver {
     private readonly diagnosticLocation;
     private readonly diagnostics;
     constructor(analyzer: Analyzer, left: tree.Expression, right: tree.Expression, operatorKind: BinaryOperatorKind, diagnosticLocation: NodeOrDiagnosticLocation, diagnostics: DiagnosticAcceptor | undefined);
-    resolve(): types.Operator | undefined;
+    resolve(): types.Method | undefined;
     private chooseSuitableOperators;
 }

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

@@ -17,7 +17,7 @@ export declare class UserDefinableUnaryOperatorResolver {
     private readonly analyzer;
     private readonly node;
     private readonly diagnostics;
-    private get operatorKind();
     constructor(analyzer: Analyzer, node: tree.PrefixUnaryExpression, diagnostics: DiagnosticAcceptor | undefined);
-    resolve(): types.Operator | undefined;
+    resolve(): types.Method | undefined;
+    private getOperatorKind;
 }

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

@@ -1,12 +1,10 @@
 import { Name } from '../../common/index.js';
-import { OperatorKind } from '../../entities/OperatorKind.js';
 import * as tree from '../../tree/index.js';
-import * as types from '../../types/index.js';
 import { Analyzer } from '../Analyzer.js';
 import { TypeMemberLookupContext } from '../TypeMemberLookup.js';
 import { NamedDeclaration, TypeOrContainerWithTypes } from './Declarations.js';
 import { SemanticContext } from './SemanticContext.js';
-import { NamedDeclarationLookupResult, OperatorLookupResult, SemanticContextLookupState } from './SemanticContextBase.js';
+import { NamedDeclarationLookupResult, SemanticContextLookupState } from './SemanticContextBase.js';
 import { SemanticContextWithParent } from './SemanticContextWithParent.js';
 import { SemanticContextContainingTypeMember } from './TypeSemanticContext.js';
 export declare class FieldWithInitializerSemanticContext extends SemanticContextWithParent {
@@ -22,7 +20,4 @@ export declare class FieldWithInitializerSemanticContext extends SemanticContext
     getOwnTypesOrContainersWithTypesByName(_name: Name, _initialContext: SemanticContext): readonly TypeOrContainerWithTypes[];
     getOwnNamedDeclarations(_initialContext: SemanticContext, _noInstanceMembers: boolean, _lookupState: SemanticContextLookupState): readonly NamedDeclaration[];
     getOwnNamedDeclarationsByName(_name: Name, _initialContext: SemanticContext, _noInstanceMembers: boolean, _lookupResult: NamedDeclarationLookupResult): void;
-    getOwnOperators(_initialContext: SemanticContext, _noInstanceMembers: boolean, _lookupState: SemanticContextLookupState): readonly types.Operator[];
-    getOwnOperatorsByKind(_kind: OperatorKind, _initialContext: SemanticContext, _noInstanceMembers: boolean, _lookupResult: OperatorLookupResult): void;
-    getOwnOperatorsBySyntacticKind(_kind: tree.OperatorKind, _initialContext: SemanticContext, _noInstanceMembers: boolean, _lookupResult: OperatorLookupResult): void;
 }

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

@@ -1,5 +1,5 @@
 import { Name } from '../../common/index.js';
-import { ConstructorEntity, OperatorKind, PackageEntity, ParameterEntity, TextTranslationEntity, TypeEntity, TypeEntityWithMembers, TypeExtensionEntity } from '../../entities/index.js';
+import { ConstructorEntity, PackageEntity, ParameterEntity, TextTranslationEntity, TypeEntity, TypeEntityWithMembers, TypeExtensionEntity } from '../../entities/index.js';
 import { SourceFile } from '../../project/SourceFile.js';
 import * as tree from '../../tree/index.js';
 import * as types from '../../types/index.js';
@@ -14,7 +14,6 @@ import { SemanticContext } from './SemanticContext.js';
 export declare abstract class SemanticContextBase {
     static readonly emptyTypesOrContainersWithTypes: readonly TypeOrContainerWithTypes[];
     static readonly emptyNamedDeclarations: readonly NamedDeclaration[];
-    static readonly emptyOperators: readonly types.Operator[];
     static readonly emptyTypeExtensions: readonly TypeExtensionEntity[];
     abstract readonly outer: SemanticContext | undefined;
     protected abstract readonly asContext: SemanticContext;
@@ -28,9 +27,6 @@ export declare abstract class SemanticContextBase {
     abstract getOwnTypesOrContainersWithTypesByName(name: Name, initialContext: SemanticContext): readonly TypeOrContainerWithTypes[];
     abstract getOwnNamedDeclarations(initialContext: SemanticContext, noInstanceMembers: boolean, lookupState: SemanticContextLookupState): readonly NamedDeclaration[];
     abstract getOwnNamedDeclarationsByName(name: Name, initialContext: SemanticContext, noInstanceMembers: boolean, lookupResult: NamedDeclarationLookupResult): void;
-    abstract getOwnOperators(initialContext: SemanticContext, noInstanceMembers: boolean, lookupState: SemanticContextLookupState): readonly types.Operator[];
-    abstract getOwnOperatorsByKind(kind: OperatorKind, initialContext: SemanticContext, noInstanceMembers: boolean, lookupResult: OperatorLookupResult): void;
-    abstract getOwnOperatorsBySyntacticKind(kind: tree.OperatorKind, initialContext: SemanticContext, noInstanceMembers: boolean, lookupResult: OperatorLookupResult): void;
     getContainingSourceFile(): SourceFile;
     getContainingPackage(): PackageEntity;
     getDiagnosticArgumentFactory(): DiagnosticArgumentFactory;
@@ -39,15 +35,12 @@ export declare abstract class SemanticContextBase {
     getTypesOrContainersWithTypesByName(name: Name): readonly TypeOrContainerWithTypes[];
     getNamedDeclarations(noInstanceMembers?: boolean): readonly NamedDeclaration[];
     getNamedDeclarationsByName(name: Name, noInstanceMembers?: boolean): NamedDeclarationLookupResult;
-    getOperators(noInstanceMembers?: boolean): readonly types.Operator[];
-    getOperatorsByKind(kind: OperatorKind, noInstanceMembers?: boolean): OperatorLookupResult;
-    getOperatorsBySyntacticKind(kind: tree.OperatorKind, noInstanceMembers?: boolean): OperatorLookupResult;
     getTypeExtensionsByType(type: TypeEntity): readonly TypeExtensionEntity[];
     getTextTranslationEntityByTextKey(key: TextKey): readonly TextTranslationEntity[];
     private semanticContexts;
     private getSourceFileContext;
 }
-export type SubprogramInfo = SubprogramInfo.Function | SubprogramInfo.Operator | SubprogramInfo.Constructor | SubprogramInfo.Destructor | SubprogramInfo.Getter | SubprogramInfo.Setter | SubprogramInfo.PackageConstructor | SubprogramInfo.PackageEntryPoint | SubprogramInfo.FunctionLiteral | SubprogramInfo.TextTranslationFunction;
+export type SubprogramInfo = SubprogramInfo.Function | SubprogramInfo.Constructor | SubprogramInfo.Destructor | SubprogramInfo.Getter | SubprogramInfo.Setter | SubprogramInfo.PackageConstructor | SubprogramInfo.PackageEntryPoint | SubprogramInfo.FunctionLiteral | SubprogramInfo.TextTranslationFunction;
 export declare namespace SubprogramInfo {
     export class Function implements ISubprogramInfo {
         readonly kind = "function";
@@ -60,16 +53,6 @@ export declare namespace SubprogramInfo {
         getNode(): FunctionDeclaration;
         private getEntity;
     }
-    export class Operator implements ISubprogramInfo {
-        readonly kind = "operator";
-        private readonly analyzer;
-        private readonly node;
-        constructor(analyzer: Analyzer, node: tree.OperatorDeclaration);
-        getReturnType(): types.Type | undefined;
-        isGenerator(): boolean;
-        allowsAsyncCalls(): boolean;
-        getNode(): tree.OperatorDeclaration;
-    }
     export class Constructor implements ISubprogramInfo {
         readonly kind = "constructor";
         private readonly analyzer;
@@ -215,14 +198,3 @@ export declare class NamedDeclarationLookupResult {
     get objectParameter(): ParameterEntity | undefined;
     setDeclarations(declarations: readonly NamedDeclaration[], objectParameter: ParameterEntity | undefined): void;
 }
-export declare class OperatorLookupResult {
-    hasSearchedInObjectVariable: boolean;
-    private operators_;
-    private objectParameter_;
-    get operators(): readonly types.Operator[];
-    /**
-     * Параметр "объект", в типе которого были найден операторы.
-     */
-    get objectParameter(): ParameterEntity | undefined;
-    setOperators(declarations: readonly types.Operator[], objectParameter: ParameterEntity | undefined): void;
-}

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

@@ -1,12 +1,11 @@
 import * as tree from '../../tree/index.js';
 import { Analyzer } from '../Analyzer.js';
 import { FunctionDeclaration, FunctionTypeDeclaration, IndexedElementAccessorDeclaration, PackageTypeDeclaration, RegularOrBlockFunctionLiteral, SubprogramDeclarationOrLiteral } from '../NodeTypeUtils.js';
-import { CatchClauseSemanticContext, ConstructorSemanticContext, DestructorSemanticContext, ForStatementSemanticContext, FunctionLiteralSemanticContext, FunctionSemanticContext, IndexedElementAccessorSemanticContext, OperatorSemanticContext, OutermostSemanticContextOfSubprogram, OutermostSemanticContextOfType, PackageConstructorSemanticContext, PackageEntryPointSemanticContext, ParametersOfFunctionTypeSemanticContext, SemanticContext, SemanticContextContainingTypeMember, SourceFileSemanticContext, SpecialLocalDeclarationSemanticContext, StatementBlockSemanticContext, SubprogramParameterListSemanticContext, SubprogramTypeParameterSemanticContext, TextTranslationFunctionDeclarationSemanticContext, TypeBodySemanticContext, TypeDeclarationCreatingSemanticContext, TypeDeclarationWithMemberBlock, TypeExtensionBodySemanticContext, TypeParametersOfTypeSemanticContext, VariableAccessorDeclaration, VariableAccessorSemanticContext } from '../semantic-context/index.js';
+import { CatchClauseSemanticContext, ConstructorSemanticContext, DestructorSemanticContext, ForStatementSemanticContext, FunctionLiteralSemanticContext, FunctionSemanticContext, IndexedElementAccessorSemanticContext, OutermostSemanticContextOfSubprogram, OutermostSemanticContextOfType, PackageConstructorSemanticContext, PackageEntryPointSemanticContext, ParametersOfFunctionTypeSemanticContext, SemanticContext, SemanticContextContainingTypeMember, SourceFileSemanticContext, SpecialLocalDeclarationSemanticContext, StatementBlockSemanticContext, SubprogramParameterListSemanticContext, SubprogramTypeParameterSemanticContext, TextTranslationFunctionDeclarationSemanticContext, TypeBodySemanticContext, TypeDeclarationCreatingSemanticContext, TypeDeclarationWithMemberBlock, TypeExtensionBodySemanticContext, TypeParametersOfTypeSemanticContext, VariableAccessorDeclaration, VariableAccessorSemanticContext } from '../semantic-context/index.js';
 export declare class SemanticContextBuilder {
     private readonly analyzer;
     private readonly sourceFileContexts;
     private readonly indexedElementAccessorContexts;
-    private readonly operatorContexts;
     private readonly fieldWithInitializerContexts;
     private readonly forStatementContexts;
     private readonly catchClauseSemanticContexts;
@@ -39,8 +38,6 @@ export declare class SemanticContextBuilder {
     ofFunctionDeclarationParameters(node: FunctionDeclaration): SubprogramParameterListSemanticContext;
     ofFunctionDeclarationTypeParameters(node: FunctionDeclaration, typeParameterClause: tree.TypeParameterClause): SubprogramTypeParameterSemanticContext;
     outermostSemanticContextOfFunctionDeclaration(node: FunctionDeclaration): FunctionSemanticContext;
-    ofOperatorDeclarationParameters(node: tree.OperatorDeclaration): SubprogramParameterListSemanticContext;
-    outermostSemanticContextOfOperatorDeclaration(node: tree.OperatorDeclaration): OperatorSemanticContext;
     ofTypeDeclarationMemberBlock(typeDeclaration: TypeDeclarationWithMemberBlock, memberBlock: tree.TypeMemberDeclarationBlock): TypeBodySemanticContext;
     ofFunctionTypeDeclarationParameters(node: FunctionTypeDeclaration): ParametersOfFunctionTypeSemanticContext;
     outermostSemanticContextOfTypeDeclaration(node: TypeDeclarationCreatingSemanticContext): OutermostSemanticContextOfType;
@@ -75,7 +72,6 @@ export declare class SemanticContextBuilder {
     private ofChildOfTypeDeclarationWithMemberBlock2;
     private ofChildOfAnonymousFunctionTypeDeclaration;
     private ofChildOfFunctionLiteral;
-    private ofOperatorDeclarationChild;
     private ofConstructorDeclarationChild;
     private ofDestructorDeclarationChild;
     private ofIndexedElementGetterDeclarationChild;