@artel/artc 0.6.25282 → 0.6.25283

package/build/{chunk-3DN3M64Y.js → chunk-7RAZAZE6.js}

@@ -1,6 +1,6 @@
 import {
   Compiler
-} from "./chunk-DURHSZYF.js";
+} from "./chunk-MJ2ZVHII.js";
 import {
   ArtelVersion,
   Cached,
@@ -15,7 +15,7 @@ import {
   __async,
   performanceMeasurementStageNames,
   performanceMeasurementStages
-} from "./chunk-VVFLEWSA.js";
+} from "./chunk-2Q4QKW7T.js";
 
 // source/executor/FileSystemUri.ts
 import { platform } from "os";

package/build/{chunk-DURHSZYF.js → chunk-MJ2ZVHII.js}

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

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

@@ -28,9 +28,10 @@ import * as indexedAccessExpressionMeaning from './IndexedAccessExpressionMeanin
 import * as memberAccessExpressionResolution from './MemberAccessExpressionMeaning.js';
 import { ModifierFlags } from './ModifierFlags.js';
 import { NamedTypeSpecifierResolutionResult } from './NamedTypeSpecifierResolver.js';
-import { DereferencedVariableAccessorDeclaration, FieldAccessorDeclaration, FunctionDeclaration, FunctionTypeDeclaration, GetterDeclaration, IndexedElementAccessorDeclaration, PackageVariableAccessorDeclaration, RegularOrBlockFunctionLiteral, SetterDeclaration, StructuredTypeDeclaration, TypeDeclaration, TypeWithMembersDeclaration, VariantTypeDeclaration } from './NodeTypeUtils.js';
+import { DereferencedVariableAccessorDeclaration, FieldAccessorDeclaration, FunctionDeclaration, FunctionTypeDeclaration, GetterDeclaration, IndexedElementAccessorDeclaration, PackageVariableAccessorDeclaration, RegularOrBlockFunctionLiteral, SetterDeclaration, StructuredTypeDeclaration, TypeWithMembersDeclaration, VariantTypeDeclaration } from './NodeTypeUtils.js';
 import * as objectExpressionMeaning from './ObjectExpressionMeaning.js';
 import { OwnAndBaseConstructorCallsCheckResult } from './OwnAndBaseConstructorCallsChecker.js';
+import { ResolvedImplementationPackage } from './ResolvedImplementationPackage.js';
 import { ResolvedTextTranslationPackage } from './ResolvedTextTranslationPackage.js';
 import * as tags from './Tag.js';
 import * as tagMeaning from './TagMeaning.js';
@@ -65,7 +66,7 @@ export declare class Analyzer {
     readonly argumentToParameterMatchResult: ArgumentToParameterMatchResult;
     readonly overriddenMember: OverriddenMember;
     readonly tags: Tags;
-    readonly linkedEntity: LinkedEntity;
+    readonly implementation: ImplementationEntity;
     readonly owningPlainObjectModificationCheck: OwningPlainObjectModificationCheck;
     readonly packageImports: PackageImports;
     readonly typeUtils: TypeUtils;
@@ -96,7 +97,7 @@ export declare class Analyzer {
     private textTranslationPackagesByTargetPackage;
     private primaryTextTranslationPackageByTargetPackage;
     private resolvedLocalizableTexts;
-    private readonly linkedMultiPlatformPackagesByPlatform;
+    private readonly resolvedImplementationPackagesByPlatform;
     private readonly isFunctionGeneratorCheckResults;
     private readonly namedDeclarationsUsageCountResults;
     private readonly packageAndStaticVariablesInitializationDiagnostics;
@@ -262,8 +263,9 @@ export declare class Analyzer {
     getLocalizedPackageWithLocale(originalPackageEntity: e.PackageEntity, locale: PackageLocale): e.PackageEntity | undefined;
     enumerateAnalyzedTranslationPackages(): Query<AnalyzedTranslationPackage>;
     enumerateResolvedTextTranslationPackages(): Query<ResolvedTextTranslationPackage>;
-    getLinkedMultiPlatformPackagesByPlatform(entity: e.PackageEntity): ReadonlyMap<PlatformKind, LinkedMultiPlatformPackage> | undefined;
-    getLinkedMultiPlatformPackage(entity: e.PackageEntity, platform: PlatformKind): LinkedMultiPlatformPackage | undefined;
+    getResolvedImplementationPackagesByPlatform(interfacePackage: e.PackageEntity): ReadonlyMap<PlatformKind, ResolvedImplementationPackage> | undefined;
+    getResolvedImplementationPackageForInterfacePackage(interfacePackage: e.PackageEntity, platform: PlatformKind): ResolvedImplementationPackage | undefined;
+    getResolvedImplementationPackage(implementationPackage: e.PackageEntity): ResolvedImplementationPackage | undefined;
     getTextTranslationPackagesMap(): ReadonlyMap<e.PackageEntity, ResolvedTextTranslationPackage[]>;
     getTextTranslationPackagesOfTargetPackage(targetPackage: e.PackageEntity): ResolvedTextTranslationPackage[] | undefined;
     getPrimaryTextTranslationPackageOfTargetPackage(targetPackage: e.PackageEntity): ResolvedTextTranslationPackage | undefined;
@@ -305,7 +307,6 @@ export declare class Analyzer {
     validateSourcePackageMemberConflicts(pkg: project.ProgramOrTextTranslationPackage): readonly Diagnostic[];
     getNotExplicitlyImplementedAbstractMembers(typeEntity: e.TypeEntityWithMembers): readonly types.TypeMember[];
     getTypeMemberImplementationCheckResult(typeEntity: e.TypeEntityWithMembers): TypeMemberImplementationCheckResult;
-    createEntityContextForTypeDeclaration(node: TypeDeclaration): e.EntityContext;
     isFunctionBlockWithImplicitlyReturnedExpression(node: tree.FunctionBlock): boolean;
     getLocalizedWellKnownDeclarations(locale: PackageLocale): WellKnownDeclarations;
     getLocalizedStandardTypes(locale: PackageLocale): types.StandardTypes;
@@ -319,6 +320,10 @@ export declare class Analyzer {
     checkTypeArgumentCount(typeArgumentCount: number, typeParameters: readonly e.TypeParameterEntity[], diagnostics?: DiagnosticAcceptor, nodeForDiagnostic?: tree.Node): boolean;
     checkTypeCanBeUsedAsValue(typeAccess: tree.Expression): boolean;
     getEntityDiagnosticLocation(entity: e.Entity, chooseSetter?: boolean): DiagnosticLocation | undefined;
+    createTypeMemberLookupContextWithinType(type: e.TypeEntity): {
+        hidingMatcher: e.IEntityHidingMatcher;
+        typeExtensionLookup: semanticContext.SemanticContext | undefined;
+    };
     private createTsInterop;
 }
 export declare class TsInteropInputs {
@@ -352,6 +357,9 @@ export declare namespace BinaryExpressionOperatorClassificationResult {
     const bitwiseAnd: BinaryExpressionOperatorClassificationResult;
     const bitwiseOr: BinaryExpressionOperatorClassificationResult;
     const bitwiseXor: BinaryExpressionOperatorClassificationResult;
+    const leftShift: BinaryExpressionOperatorClassificationResult;
+    const signedRightShift: BinaryExpressionOperatorClassificationResult;
+    const unsignedRightShift: BinaryExpressionOperatorClassificationResult;
     const and: BinaryExpressionOperatorClassificationResult;
     const or: BinaryExpressionOperatorClassificationResult;
     const xor: BinaryExpressionOperatorClassificationResult;
@@ -376,10 +384,12 @@ declare class Type {
     private readonly intersectionTypeSpecifierTypes;
     private readonly functionLiteralTypes;
     private readonly nodesForWhichReturnTypeInferenceDiagnosticHasBeenReported;
+    private recursionDepth;
     constructor(analyzer: Analyzer);
     ofExpression(node: tree.Expression, analysisOptions?: ExpressionAnalysisOptions): types.Type;
     ofTypeSpecifier(node: tree.TypeSpecifier): types.Type;
     ofAccessedOperator(operator: types.Operator): types.Type;
+    private ofExpressionWithoutGuard;
     private ofFunctionBlockLiteral;
     private ofFunctionLiteral;
     private ofRegularOrBlockFunctionLiteral;
@@ -562,8 +572,30 @@ declare class ValueLocalVariableEntity {
     ofDereferencedVariableSetterDeclaration(node: tree.DereferencedVariableSetterDeclaration): e.LocalVariableEntity;
     private createValueLocalVariableEntity;
 }
+export declare enum SignatureComparisonOptions {
+    None = 0,
+    CompareNames = 1,
+    CompareReturnTypes = 2,
+    CheckTypeParameterCountIntersection = 4
+}
+type TypeComparer = (t1: types.Type, t2: types.Type) => boolean;
+declare class SignatureComparer {
+    private readonly analyzer;
+    private readonly substitutionStubTypes;
+    constructor(analyzer: Analyzer);
+    areEqualFunctionEntities(function1: e.FunctionEntity, function2: e.FunctionEntity, options: SignatureComparisonOptions, typeComparer?: TypeComparer): boolean;
+    areEqualMethods(method1: types.Method, method2: types.Method, options: SignatureComparisonOptions, typeComparer?: TypeComparer): boolean;
+    areEqualSignaturesWithoutTypeParameters(entity1: EntityWithoutTypeParametersInSignature, entity2: EntityWithoutTypeParametersInSignature, options: SignatureComparisonOptions, typeComparer?: TypeComparer): boolean;
+    areEqualTypeMemberSignaturesWithoutTypeParameters(member1: TypeMemberWithoutTypeParametersInSignature, member2: TypeMemberWithoutTypeParametersInSignature, options: SignatureComparisonOptions, typeComparer?: TypeComparer): boolean;
+    doTypeParameterCountsIntersect(typeParameters1: readonly e.TypeParameterEntity[], typeParameters2: readonly e.TypeParameterEntity[]): boolean;
+    private areEqualParameters;
+    private areEqualTypeMemberParameters;
+    private areEqualTypes;
+    private createSubstitutionsWithStubTypes;
+}
 declare class OverriddenMember {
     private readonly analyzer;
+    static readonly signatureComparisonOptions = SignatureComparisonOptions.None;
     private readonly namedMemberFinder;
     private readonly operatorFinder;
     private readonly indexerFinder;
@@ -586,7 +618,6 @@ declare class OverriddenMember {
     getOverriddenAndShadowedDereferenceOperators(node: DereferencedVariableAccessorDeclaration): OverriddenAndShadowedMembers<types.DereferenceOperator>;
     entityCanBeOverridden(entity: OverridableTypeMemberEntity): boolean;
     getMemberTypeOrReturnType(member: types.TypeMember): types.Type;
-    findMatchingMembersInType(member: types.TypeMember, type: types.Type): readonly types.TypeMember[];
     private findOverriddenMembers;
     private findOverriddenOrShadowedNamedMembersInType;
     private findOverriddenOrShadowedOperatorsInType;
@@ -630,10 +661,10 @@ declare class Tags {
     private createTagFromNode;
     private argumentToTagArgument;
 }
-declare class LinkedEntity {
+declare class ImplementationEntity {
     private readonly analyzer;
     constructor(analyzer: Analyzer);
-    entityCanBeLinked(entity: e.Entity): boolean;
+    entityCanHaveImplementation(entity: e.Entity): boolean;
     ofType(entity: e.TypeEntity, platform: PlatformKind): e.TypeEntity | undefined;
     ofTypeWithMembers(entity: e.TypeEntityWithMembers, platform: PlatformKind): e.TypeEntityWithMembers | undefined;
     ofParameterType(entity: e.TypeParameterEntity, platform: PlatformKind): e.TypeParameterEntity | undefined;
@@ -643,49 +674,12 @@ declare class LinkedEntity {
     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;
     ofDereferenceOperator(entity: e.DereferenceOperatorEntity, platform: PlatformKind): e.DereferenceOperatorEntity | undefined;
     ofGetter(entity: e.GetterEntity, platform: PlatformKind): e.GetterEntity | undefined;
     ofSetter(entity: e.SetterEntity, platform: PlatformKind): e.SetterEntity | undefined;
 }
-export declare class LinkedMultiPlatformPackage {
-    readonly analyzer: Analyzer;
-    readonly pkg: e.PackageEntity;
-    readonly implementationPackage: e.PackageEntity;
-    readonly targetPlatform: PlatformKind;
-    private readonly memberLookup_;
-    private readonly linkedTypesWithMembers;
-    private readonly linkedParameterTypes;
-    private get memberLookup();
-    constructor(analyzer: Analyzer, pkg: e.PackageEntity, implementationPackage: e.PackageEntity, targetPlatform: PlatformKind);
-    getLinkedVariable(entity: e.PackageVariableEntity): e.PackageVariableEntity | undefined;
-    getLinkedMethod(entity: e.PackageFunctionEntity): e.PackageFunctionEntity | undefined;
-    getLinkedTypeWithMembers(entity: e.TypeEntityWithMembers): LinkedTypeWithMembers | undefined;
-    getLinkedParameterType(entity: e.TypeParameterEntity): e.TypeParameterEntity | undefined;
-    /**
-     * Используется для сравнения типов при связывании объявления из многоплатформенного пакета с объявлением из
-     * реализационного пакета. В частности, при сравнении типов параметров для выбора правильной перегрузки
-     * метода (конструктора, индексатора).
-     */
-    compareTypesDuringLinking(type1: types.Type, type2: types.Type): boolean;
-    private findPackageType;
-    private compareSubstitutionsDuringLinking;
-}
-export declare class LinkedTypeWithMembers {
-    readonly analyzer: Analyzer;
-    readonly externalType: e.TypeEntityWithMembers;
-    readonly targetType: e.TypeEntityWithMembers;
-    readonly linkedPackage: LinkedMultiPlatformPackage;
-    private readonly memberLookup_;
-    private get memberLookup();
-    constructor(analyzer: Analyzer, externalType: e.TypeEntityWithMembers, targetType: e.TypeEntityWithMembers, linkedPackage: LinkedMultiPlatformPackage);
-    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;
-    getLinkedIndexer(entity: e.IndexerEntity): e.IndexerEntity | undefined;
-    getLinkedDereferenceOperator(entity: e.DereferenceOperatorEntity): e.DereferenceOperatorEntity | undefined;
-}
 declare class OwningPlainObjectModificationCheck {
     private analyzer;
     private readonly owningPlainObjectModificationCheckResult;
@@ -777,33 +771,6 @@ declare class TypeUtils {
     private getFlattenedConstituentTypesForCommonTypesSearch;
     private flattenTypeParameterConstraint;
 }
-declare class SignatureComparer {
-    private readonly analyzer;
-    private readonly stubParameterTypes;
-    constructor(analyzer: Analyzer);
-    areEqualFunctionEntities(function1: e.FunctionEntity, function2: e.FunctionEntity, options: SignatureComparisonOptions): boolean;
-    /**
-     * Метод аналогичен методу {@link areEqualFunctionEntities}.
-     */
-    areEqualMethods(method1: types.Method, method2: types.Method, options: SignatureComparisonOptions): boolean;
-    /**
-     * Проверяет, конфликтуют две сущности, имеющие параметры, но не имеющие параметры типа.
-     *
-     * Отношение "сущности, имеющие только параметры, конфликтуют" является транзитивным.
-     */
-    areEqualSignaturesWithoutTypeParameters(entity1: EntityWithoutTypeParametersInSignature, entity2: EntityWithoutTypeParametersInSignature): boolean;
-    areEqualTypeMemberSignaturesWithoutTypeParameters(member1: TypeMemberWithoutTypeParametersInSignature, member2: TypeMemberWithoutTypeParametersInSignature): boolean;
-    doTypeParameterCountsIntersect(typeParameters1: readonly e.TypeParameterEntity[], typeParameters2: readonly e.TypeParameterEntity[]): boolean;
-    private areEqualParameters;
-    private areEqualTypeMemberParameters;
-    private createSubstitutionsWithStubTypes;
-}
-export declare enum SignatureComparisonOptions {
-    None = 0,
-    CompareNames = 1,
-    CompareReturnTypes = 2,
-    CheckTypeParameterCountIntersection = 4
-}
 declare class ConflictsCheck {
     private readonly analyzer;
     private static readonly signatureComparisonOptions;

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

@@ -0,0 +1,48 @@
+import { ConstructorEntity, DereferenceOperatorEntity, DestructorEntity, FieldEntity, IndexerEntity, MethodEntity, OperatorEntity, PackageEntity, PackageFunctionEntity, PackageTypeEntity, PackageVariableEntity, TypeEntity } from '../entities/index.js';
+import { PlatformKind } from '../project/index.js';
+import { Analyzer } from './Analyzer.js';
+export declare class ResolvedImplementationPackage {
+    private readonly analyzer;
+    readonly interfacePackage: PackageEntity;
+    readonly implementationPackage: PackageEntity;
+    readonly targetPlatform: PlatformKind;
+    private static signatureComparisonOptions_;
+    private static get signatureComparisonOptions();
+    private implementationPackageMembers_;
+    private readonly diagnostics;
+    private readonly variableImplementations;
+    private readonly functionImplementations;
+    private readonly typeImplementations;
+    private readonly typeMemberImplementations;
+    private hasReportedAllDiagnostics;
+    private get implementationPackageMembers();
+    constructor(analyzer: Analyzer, interfacePackage: PackageEntity, implementationPackage: PackageEntity, targetPlatform: PlatformKind);
+    ensureAllDiagnosticReported(): void;
+    getPackageVariableImplementation(entity: PackageVariableEntity): PackageVariableEntity | undefined;
+    getPackageFunctionImplementation(entity: PackageFunctionEntity): PackageFunctionEntity | undefined;
+    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;
+    getDereferenceOperatorImplementation(entity: DereferenceOperatorEntity): DereferenceOperatorEntity | undefined;
+    static isTypeThatDoesNotRequireImplementation(entity: TypeEntity): boolean;
+    private getTypeMemberImplementations;
+    private findFieldImplementation;
+    private findMethodImplementation;
+    private findOperatorImplementation;
+    private findConstructorImplementation;
+    private findDestructorImplementation;
+    private findIndexerImplementation;
+    private findDereferenceOperatorImplementation;
+    private checkImplementationTypeMemberBasicModifier;
+    private checkImplementationTypeMemberAbstractModifier;
+    private areEqualFunctions;
+    private areEqualTypeMembersWithoutTypeParameters;
+    private areEqualTypes;
+    private areEqualSubstitutions;
+    private reportPackageDoesNotContainImplementationDiagnostic;
+    private reportTypeDoesNotContainImplementationDiagnostic;
+}

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

@@ -1,5 +1,4 @@
 import { Name } from '../../common/index.js';
-import { IEntityHidingMatcher } from '../../entities/EntityHiding.js';
 import * as tree from '../../tree/index.js';
 import { Analyzer } from '../Analyzer.js';
 import { NamedDeclaration, TypeOrContainerWithTypes } from './Declarations.js';
@@ -14,8 +13,8 @@ export declare class FieldWithInitializerSemanticContext extends SemanticContext
     private readonly node;
     constructor(analyzer: Analyzer, node: tree.FieldDeclaration, outer: SemanticContextContainingTypeMember);
     isStatic(): boolean;
-    getOwnTypesOrContainersWithTypes(_hidingMatcher?: IEntityHidingMatcher): readonly TypeOrContainerWithTypes[];
-    getOwnTypesOrContainersWithTypesByName(_name: Name, _hidingMatcher?: IEntityHidingMatcher): readonly TypeOrContainerWithTypes[];
-    getOwnNamedDeclarations(_noInstanceMembers?: boolean, _hidingMatcher?: IEntityHidingMatcher): readonly NamedDeclaration[];
-    getOwnNamedDeclarationsByName(_name: Name, _noInstanceMembers?: boolean, _hidingMatcher?: IEntityHidingMatcher): readonly NamedDeclaration[];
+    getOwnTypesOrContainersWithTypes(_initialContext: SemanticContext): readonly TypeOrContainerWithTypes[];
+    getOwnTypesOrContainersWithTypesByName(_name: Name, _initialContext: SemanticContext): readonly TypeOrContainerWithTypes[];
+    getOwnNamedDeclarations(_initialContext: SemanticContext, _noInstanceMembers?: boolean): readonly NamedDeclaration[];
+    getOwnNamedDeclarationsByName(_name: Name, _initialContext: SemanticContext, _noInstanceMembers?: boolean): readonly NamedDeclaration[];
 }

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

@@ -22,10 +22,10 @@ export declare abstract class SemanticContextBase {
     abstract getContainingTypeOrTypeExtension(): TypeOrTypeExtension | undefined;
     abstract getTryStatementContext(): TryStatementContextKind | undefined;
     abstract isStatic(): boolean;
-    abstract getOwnTypesOrContainersWithTypes(hidingMatcher?: IEntityHidingMatcher): readonly TypeOrContainerWithTypes[];
-    abstract getOwnTypesOrContainersWithTypesByName(name: Name, hidingMatcher?: IEntityHidingMatcher): readonly TypeOrContainerWithTypes[];
-    abstract getOwnNamedDeclarations(noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): readonly NamedDeclaration[];
-    abstract getOwnNamedDeclarationsByName(name: Name, noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): readonly NamedDeclaration[];
+    abstract getOwnTypesOrContainersWithTypes(initialContext: SemanticContext): readonly TypeOrContainerWithTypes[];
+    abstract getOwnTypesOrContainersWithTypesByName(name: Name, initialContext: SemanticContext): readonly TypeOrContainerWithTypes[];
+    abstract getOwnNamedDeclarations(initialContext: SemanticContext, noInstanceMembers?: boolean): readonly NamedDeclaration[];
+    abstract getOwnNamedDeclarationsByName(name: Name, initialContext: SemanticContext, noInstanceMembers?: boolean): readonly NamedDeclaration[];
     getContainingSourceFile(): SourceFile;
     getContainingPackage(): PackageEntity;
     getHidingMatcher(): IEntityHidingMatcher;

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

@@ -1,6 +1,5 @@
 import { Name } from '../../common/index.js';
 import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
-import { IEntityHidingMatcher } from '../../entities/EntityHiding.js';
 import { LocalVariableEntity, NestedFunctionEntity, ParameterEntity, TypeParameterEntity } from '../../entities/index.js';
 import * as tree from '../../tree/index.js';
 import { Analyzer } from '../Analyzer.js';
@@ -28,10 +27,10 @@ export declare abstract class SemanticContextValidatingNameConflictsBase extends
     constructor(analyzer: Analyzer);
     protected abstract createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
     protected abstract createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
-    getOwnTypesOrContainersWithTypes(_hidingMatcher?: IEntityHidingMatcher): readonly TypeOrContainerWithTypes[];
-    getOwnTypesOrContainersWithTypesByName(name: Name, _hidingMatcher?: IEntityHidingMatcher): readonly TypeOrContainerWithTypes[];
-    getOwnNamedDeclarations(_noInstanceMembers?: boolean, _hidingMatcher?: IEntityHidingMatcher): readonly NamedDeclaration[];
-    getOwnNamedDeclarationsByName(name: Name, _noInstanceMembers?: boolean, _hidingMatcher?: IEntityHidingMatcher): readonly NamedDeclaration[];
+    getOwnTypesOrContainersWithTypes(_initialContext: SemanticContext): readonly TypeOrContainerWithTypes[];
+    getOwnTypesOrContainersWithTypesByName(name: Name, _initialContext: SemanticContext): readonly TypeOrContainerWithTypes[];
+    getOwnNamedDeclarations(_initialContext: SemanticContext, _noInstanceMembers?: boolean): readonly NamedDeclaration[];
+    getOwnNamedDeclarationsByName(name: Name, _initialContext: SemanticContext, _noInstanceMembers?: boolean): readonly NamedDeclaration[];
     validateNameConflicts(diagnostics: DiagnosticAcceptor): void;
     private getMemberEntityDictionary;
     private validateNestedFunctionsConflicts;

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

@@ -35,10 +35,10 @@ export declare class SourceFileSemanticContext extends SemanticContextBase {
     getTryStatementContext(): TryStatementContextKind | undefined;
     isStatic(): boolean;
     getDiagnosticArgumentFactory(): DiagnosticArgumentFactory;
-    getOwnTypesOrContainersWithTypes(hidingMatcher?: IEntityHidingMatcher): readonly TypeOrContainerWithTypes[];
-    getOwnTypesOrContainersWithTypesByName(name: Name, hidingMatcher?: IEntityHidingMatcher): readonly TypeOrContainerWithTypes[];
-    getOwnNamedDeclarations(_noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): NamedDeclaration[];
-    getOwnNamedDeclarationsByName(name: Name, _noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): readonly NamedDeclaration[];
+    getOwnTypesOrContainersWithTypes(initialContext: SemanticContext): readonly TypeOrContainerWithTypes[];
+    getOwnTypesOrContainersWithTypesByName(name: Name, initialContext: SemanticContext): readonly TypeOrContainerWithTypes[];
+    getOwnNamedDeclarations(initialContext: SemanticContext, _noInstanceMembers?: boolean): NamedDeclaration[];
+    getOwnNamedDeclarationsByName(name: Name, initialContext: SemanticContext, _noInstanceMembers?: boolean): readonly NamedDeclaration[];
     getOwnTypeExtensionsByType(type: TypeEntity, hidingMatcher?: IEntityHidingMatcher): TypeExtensionEntity[];
     getTextTranslationEntityByTextKey(key: TextKey): readonly TextTranslationEntity[];
     validateNameConflicts(diagnostics: DiagnosticAcceptor): void;

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

@@ -1,5 +1,4 @@
 import { Name } from '../../common/index.js';
-import { IEntityHidingMatcher } from '../../entities/EntityHiding.js';
 import * as tree from '../../tree/index.js';
 import { Analyzer } from '../Analyzer.js';
 import { DereferencedVariableAccessorDeclaration, FieldAccessorDeclaration, FunctionDeclaration, IndexedElementAccessorDeclaration, PackageVariableAccessorDeclaration, RegularOrBlockFunctionLiteral } from '../NodeTypeUtils.js';
@@ -19,10 +18,10 @@ export declare abstract class OutermostSemanticContextOfSubprogram extends Seman
     readonly kind = "outermost-of-subprogram";
     abstract getContainingSubprogram(): SubprogramInfo;
     getTryStatementContext(): TryStatementContextKind | undefined;
-    getOwnTypesOrContainersWithTypes(_hidingMatcher?: IEntityHidingMatcher): readonly TypeOrContainerWithTypes[];
-    getOwnTypesOrContainersWithTypesByName(_name: Name, _hidingMatcher?: IEntityHidingMatcher): readonly TypeOrContainerWithTypes[];
-    getOwnNamedDeclarations(_noInstanceMembers?: boolean, _hidingMatcher?: IEntityHidingMatcher): readonly NamedDeclaration[];
-    getOwnNamedDeclarationsByName(_name: Name, _noInstanceMembers?: boolean, _hidingMatcher?: IEntityHidingMatcher): readonly NamedDeclaration[];
+    getOwnTypesOrContainersWithTypes(_initialContext: SemanticContext): readonly TypeOrContainerWithTypes[];
+    getOwnTypesOrContainersWithTypesByName(_name: Name, _initialContext: SemanticContext): readonly TypeOrContainerWithTypes[];
+    getOwnNamedDeclarations(_initialContext: SemanticContext, _noInstanceMembers?: boolean): readonly NamedDeclaration[];
+    getOwnNamedDeclarationsByName(_name: Name, _initialContext: SemanticContext, _noInstanceMembers?: boolean): readonly NamedDeclaration[];
 }
 export declare class FunctionSemanticContext extends OutermostSemanticContextOfSubprogram {
     readonly outer: SemanticContext;

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

@@ -28,10 +28,10 @@ export declare class OutermostSemanticContextOfType extends SemanticContextWithP
     getContainingTypeOrTypeExtension(): TypeOrTypeExtension | undefined;
     getContainingSubprogram(): SubprogramInfo | undefined;
     isStatic(): boolean;
-    getOwnTypesOrContainersWithTypes(_hidingMatcher?: IEntityHidingMatcher): readonly TypeOrContainerWithTypes[];
-    getOwnTypesOrContainersWithTypesByName(_name: Name, _hidingMatcher?: IEntityHidingMatcher): readonly TypeOrContainerWithTypes[];
-    getOwnNamedDeclarations(_noInstanceMembers?: boolean, _hidingMatcher?: IEntityHidingMatcher): readonly NamedDeclaration[];
-    getOwnNamedDeclarationsByName(_name: Name, _noInstanceMembers?: boolean, _hidingMatcher?: IEntityHidingMatcher): readonly NamedDeclaration[];
+    getOwnTypesOrContainersWithTypes(_initialContext: SemanticContext): readonly TypeOrContainerWithTypes[];
+    getOwnTypesOrContainersWithTypesByName(_name: Name, _initialContext: SemanticContext): readonly TypeOrContainerWithTypes[];
+    getOwnNamedDeclarations(_initialContext: SemanticContext, _noInstanceMembers?: boolean): readonly NamedDeclaration[];
+    getOwnNamedDeclarationsByName(_name: Name, _initialContext: SemanticContext, _noInstanceMembers?: boolean): readonly NamedDeclaration[];
     private getContainingType;
 }
 type TypeDeclarationWithTypeParameters = tree.PackageStructuredTypeDeclaration | tree.PackageVariantTypeDeclaration | tree.PackageAliasTypeDeclaration | tree.PackageFunctionTypeDeclaration;
@@ -47,10 +47,10 @@ export declare class TypeParametersOfTypeSemanticContext extends SemanticContext
 }
 declare abstract class TypeOrExtensionBodySemanticContext extends SemanticContextWithParent {
     protected abstract memberLookup: TypeMemberLookup;
-    getOwnTypesOrContainersWithTypes(_hidingMatcher?: IEntityHidingMatcher): readonly TypeOrContainerWithTypes[];
-    getOwnTypesOrContainersWithTypesByName(_name: Name, _hidingMatcher?: IEntityHidingMatcher): readonly TypeOrContainerWithTypes[];
-    getOwnNamedDeclarations(noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): NamedDeclaration[];
-    getOwnNamedDeclarationsByName(name: Name, noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): readonly NamedDeclaration[];
+    getOwnTypesOrContainersWithTypes(_initialContext: SemanticContext): readonly TypeOrContainerWithTypes[];
+    getOwnTypesOrContainersWithTypesByName(_name: Name, _initialContext: SemanticContext): readonly TypeOrContainerWithTypes[];
+    getOwnNamedDeclarations(initialContext: SemanticContext, noInstanceMembers?: boolean): NamedDeclaration[];
+    getOwnNamedDeclarationsByName(name: Name, initialContext: SemanticContext, noInstanceMembers?: boolean): readonly NamedDeclaration[];
     getOwnOperators(noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): readonly types.Operator[];
     getOwnOperatorsByKind(kind: OperatorKind, noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): readonly types.Operator[];
     private convertNamedMember;

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

@@ -10,6 +10,7 @@ export declare const enum HelperPhraseKind {
     Overloads = 7,
     EnumeratorMethodName = 8,
     InvokeMethodName = 9,
-    EmptyUnionType = 10
+    EmptyUnionType = 10,
+    Stub = 11
 }
 export declare function getHelperPhrase(kind: HelperPhraseKind, locale: PackageLocale): string;

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

@@ -1,13 +1,15 @@
 import { OperatorKind } from '../entities/OperatorKind.js';
+import { Keyword } from '../parser/KeywordDictionary.js';
 import { ReservedIdentifierKind } from '../parser/ReservedIdentifierDictionary.js';
 import * as tree from '../tree/index.js';
 import { HelperPhraseKind } from './HelperPhrases.js';
 import { PackageDialect, PackageLocale } from './index.js';
 export declare class LocalizationHelper {
-    static localizeKeyword(kind: tree.KeywordKind, locale: PackageLocale, dialect?: PackageDialect): readonly string[];
-    static localizeKeywordAndTakeFirst(kind: tree.KeywordKind, locale: PackageLocale, dialect?: PackageDialect): string;
+    static localizeKeyword(kind: tree.KeywordKind, locale: PackageLocale, dialect: PackageDialect): readonly Keyword[];
+    static localizeKeywordAndTakeFirst(kind: tree.KeywordKind, locale: PackageLocale, dialect: PackageDialect): string;
+    static localizeKeywordAndTakeBest(kind: tree.KeywordKind, locale: PackageLocale, dialect: PackageDialect, preferredFlags?: tree.KeywordFlags): string;
     static localizeReservedIdentifier(kind: ReservedIdentifierKind, locale: PackageLocale): string;
     static localizeHelperPhrase(kind: HelperPhraseKind, locale: PackageLocale): string;
-    static localizeOperatorKind(kind: OperatorKind, locale: PackageLocale, dialect?: PackageDialect): string;
-    static localizeSyntacticalOperatorKind(kind: tree.OperatorKind, locale: PackageLocale, dialect?: PackageDialect): string;
+    static localizeOperatorKind(kind: OperatorKind, locale: PackageLocale, dialect: PackageDialect): string;
+    static localizeSyntacticalOperatorKind(kind: tree.OperatorKind, locale: PackageLocale, dialect: PackageDialect): string;
 }

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

@@ -231,6 +231,16 @@ export declare enum DiagnosticCode {
     TranslatedDeclarations0And1HaveTheSameTranslatedNamesButDifferentSourceNames23 = 2192,
     TranslatedOverridingMember0MustTheSameNameAsBaseMember1 = 2193,
     TextTranslationAlreadyExistsInTheTextTranslationPackage = 2194,
+    PackageDoesNotContainImplementationOf0 = 2195,
+    TypeDoesNotContainImplementationOf0 = 2196,
+    ImplementationVariableMustNotBeConstOrHaveWriteFunctionToMatchInterfacePackageVariable0 = 2197,
+    ImplementationFunctionMustBeAsyncToMatchInterfacePackageFunction0 = 2198,
+    ImplementationFunctionMustNotBeAsyncToMatchInterfacePackageFunction0 = 2199,
+    ImplementationTypeMustBeBasicToMatchInterfacePackageType0 = 2200,
+    ImplementationTypeMustNotBeAbstractToMatchInterfacePackageType0 = 2201,
+    ImplementationTypeMemberMustBeBasicToMatchInterfacePackageTypeMember0 = 2202,
+    ImplementationTypeMemberMustNotBeAbstractToMatchInterfacePackageTypeMember0 = 2203,
+    ImplementationTypeMemberMustHaveWriteFunctionToMatchInterfacePackageTypeMember0 = 2204,
     CannotFindTsLibDirectoryBaseSearchPaths0 = 3000,
     SourceFile0IsNotPartOfThePackageAndWontBeLoaded = 3001,
     ProgramWithoutMainPackageCannotBeCompiled = 3002,

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

@@ -15,7 +15,7 @@ export declare class EntityMap {
     private readonly functions;
     private readonly typeOrExtensions;
     private readonly packages;
-    private readonly linkedPackages;
+    private readonly implementationPackages;
     constructor(analyzer: Analyzer, targetPlatform: PlatformKind);
     getVariableEntity(entity: analyzerEntities.VariableEntity): emitterEntities.VariableEntity;
     getNamedFunctionEntity(entity: analyzerEntities.NamedFunctionEntity): emitterEntities.FunctionEntity;

package/build/types/emitter/ir/Nodes.d.ts

@@ -1081,7 +1081,13 @@ export declare const enum AssignmentOperatorKind {
     SubtractEquals = 2,
     MultiplyEquals = 3,
     DivideEquals = 4,
-    IntegerDivideEquals = 5
+    IntegerDivideEquals = 5,
+    BitwiseAndEquals = 6,
+    BitwiseOrEquals = 7,
+    BitwiseXorEquals = 8,
+    LeftShiftEquals = 9,
+    SignedRightShiftEquals = 10,
+    UnsignedRightShiftEquals = 11
 }
 export declare const enum PrefixUnaryExpressionOperatorKind {
     Plus = 0,
@@ -1108,5 +1114,8 @@ export declare const enum BinaryExpressionOperatorKind {
     Modulo = 15,
     BitwiseAnd = 16,
     BitwiseOr = 17,
-    BitwiseXor = 18
+    BitwiseXor = 18,
+    LeftShift = 19,
+    SignedRightShift = 20,
+    UnsignedRightShift = 21
 }

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

@@ -1,8 +1,5 @@
 import { Analyzer } from '../analysis/Analyzer.js';
-import { SemanticContext } from '../analysis/semantic-context/SemanticContext.js';
-import { PackageDialect, PackageLocale } from '../common/index.js';
 import * as types from '../types/index.js';
-import { IEntityHidingMatcher } from './EntityHiding.js';
 import { AliasTypeEntity } from './interfaces/AliasTypeEntity.js';
 import { ConstructorEntity } from './interfaces/ConstructorEntity.js';
 import { DereferenceOperatorEntity } from './interfaces/DereferenceOperatorEntity.js';
@@ -99,15 +96,6 @@ export type EntityWithParameters = Exclude<EntityContainingParameter, PackageEnt
 export declare function isEntityWithParameters(entity: Entity): entity is EntityWithParameters;
 export type NamedFunctionEntity = PackageFunctionEntity | MethodEntity | NestedFunctionEntity;
 export declare function isNamedFunctionEntity(entity: Entity): entity is NamedFunctionEntity;
-export declare class EntityContext {
-    readonly containingPackage: PackageEntity;
-    readonly hidingMatcher: IEntityHidingMatcher;
-    readonly typeExtensionLookup: SemanticContext | undefined;
-    get locale(): PackageLocale;
-    get packageDialect(): PackageDialect;
-    constructor(containingPackage: PackageEntity, hidingMatcher: IEntityHidingMatcher, typeExtensionLookup: SemanticContext | undefined);
-    static fromSemanticContext(semanticContext: SemanticContext): EntityContext;
-}
 export declare function entityToStringDecorator<T extends {
     new (...args: any[]): Entity;
 }>(constructor: T): void;

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

@@ -1,7 +1,7 @@
 import { AnalyzedTranslationPackage } from '../analysis/AnalyzedTranslationPackage.js';
 import { Analyzer } from '../analysis/Analyzer.js';
 import * as types from '../types/index.js';
-import { AliasTypeEntity, AnonymousFunctionTypeEntity, AnonymousStructuredTypeEntity, AnonymousVariantTypeEntity, ConstructorEntity, DereferenceOperatorEntity, DestructorEntity, Entity, EntityContext, FieldEntity, FunctionTypeEntity, GetterEntity, IndexerEntity, MethodEntity, NamedTypeMemberEntity, OperatorEntity, PackageEntity, PackageFunctionEntity, PackageFunctionTypeEntity, PackageMemberEntity, PackageStructuredTypeEntity, PackageTypeEntity, PackageVariableEntity, PackageVariantTypeEntity, ParameterEntity, SetterEntity, StructuredTypeEntity, TypeEntity, TypeEntityWithMembers, TypeExtensionEntity, TypeMemberEntity, TypeParameterEntity, TypeWithMembersOrExtensionEntity, VariantTypeEntity } from './index.js';
+import { AliasTypeEntity, AnonymousFunctionTypeEntity, AnonymousStructuredTypeEntity, AnonymousVariantTypeEntity, ConstructorEntity, DereferenceOperatorEntity, DestructorEntity, Entity, FieldEntity, FunctionTypeEntity, GetterEntity, IndexerEntity, MethodEntity, NamedTypeMemberEntity, OperatorEntity, PackageEntity, PackageFunctionEntity, PackageFunctionTypeEntity, PackageMemberEntity, PackageStructuredTypeEntity, PackageTypeEntity, PackageVariableEntity, PackageVariantTypeEntity, ParameterEntity, SetterEntity, StructuredTypeEntity, TypeEntity, TypeEntityWithMembers, TypeExtensionEntity, TypeMemberEntity, TypeParameterEntity, TypeWithMembersOrExtensionEntity, VariantTypeEntity } from './index.js';
 export declare class EntityLocalizationContext {
     private readonly analyzer;
     private readonly translationPackage;
@@ -43,7 +43,6 @@ export declare class EntityLocalizationContext {
     getLocalizedEntityForPossiblyNotLocalizableEntity(entity: Entity): Entity;
     createLocalizedType(type: types.Type): types.Type;
     createLocalizedSubstitutions(substitutions: types.Substitutions): types.Substitutions;
-    createLocalizedEntityContext(context: EntityContext): EntityContext;
     private getOwnTranslatedEntity;
     private getOwnTranslatedTypeEntity;
     private getOwnTranslatedTypeParameterEntity;

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

@@ -1,7 +1,7 @@
 import { Tag } from '../analysis/Tag.js';
 import { Translation } from '../analysis/Translation.js';
 import { PackageDialect, PackageLocale } from '../common/index.js';
-import { EntityKind, PackageEntity } from './index.js';
+import { Entity, EntityKind, PackageEntity } from './index.js';
 export interface IEntity {
     readonly kind: EntityKind;
     getContainingPackage(): PackageEntity;
@@ -9,4 +9,5 @@ export interface IEntity {
     getLocale(): PackageLocale;
     getDialect(): PackageDialect;
     getTags(): readonly Tag[];
+    getOriginalEntity(): Entity;
 }

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

@@ -18,12 +18,15 @@ export declare enum OperatorKind {
     Xor = 15,
     BitwiseAnd = 16,
     BitwiseOr = 17,
-    BitwiseXor = 18
+    BitwiseXor = 18,
+    LeftShift = 19,
+    SignedRightShift = 20,
+    UnsignedRightShift = 21
 }
 /**
  * Виды операторов, задаваемых токенами (`+`, `-`, `*=` и др.).
  */
-export type KindOfOperatorDefinedByToken = OperatorKind.UnaryPlus | OperatorKind.UnaryMinus | OperatorKind.Add | OperatorKind.Subtract | OperatorKind.Multiply | OperatorKind.Divide | OperatorKind.IntegerDivide | OperatorKind.Modulo | OperatorKind.LessThan | OperatorKind.GreaterThan | OperatorKind.LessThanOrEqual | OperatorKind.GreaterThanOrEqual | OperatorKind.BitwiseAnd | OperatorKind.BitwiseOr | OperatorKind.BitwiseXor;
+export type KindOfOperatorDefinedByToken = OperatorKind.UnaryPlus | OperatorKind.UnaryMinus | OperatorKind.Add | OperatorKind.Subtract | OperatorKind.Multiply | OperatorKind.Divide | OperatorKind.IntegerDivide | OperatorKind.Modulo | OperatorKind.LessThan | OperatorKind.GreaterThan | OperatorKind.LessThanOrEqual | OperatorKind.GreaterThanOrEqual | OperatorKind.BitwiseAnd | OperatorKind.BitwiseOr | OperatorKind.BitwiseXor | OperatorKind.LeftShift | OperatorKind.SignedRightShift | OperatorKind.UnsignedRightShift;
 export declare function isOperatorDefinedByToken(kind: OperatorKind): kind is KindOfOperatorDefinedByToken;
 /**
  * Виды операторов, задаваемых ключевыми словами (`и`, `или`, `не` и др.)
@@ -38,7 +41,7 @@ export declare function isUnaryOperator(kind: OperatorKind): kind is UnaryOperat
 /**
 * Виды двухместных операторов. Объявление двухместного оператора должно содержать один параметр.
 */
-export type BinaryOperatorKind = OperatorKind.Add | OperatorKind.Subtract | OperatorKind.Multiply | OperatorKind.Divide | OperatorKind.IntegerDivide | OperatorKind.Modulo | OperatorKind.LessThan | OperatorKind.GreaterThan | OperatorKind.LessThanOrEqual | OperatorKind.GreaterThanOrEqual | OperatorKind.Or | OperatorKind.And | OperatorKind.Xor | OperatorKind.BitwiseAnd | OperatorKind.BitwiseOr | OperatorKind.BitwiseXor;
+export type BinaryOperatorKind = OperatorKind.Add | OperatorKind.Subtract | OperatorKind.Multiply | OperatorKind.Divide | OperatorKind.IntegerDivide | OperatorKind.Modulo | OperatorKind.LessThan | OperatorKind.GreaterThan | OperatorKind.LessThanOrEqual | OperatorKind.GreaterThanOrEqual | OperatorKind.Or | OperatorKind.And | OperatorKind.Xor | OperatorKind.BitwiseAnd | OperatorKind.BitwiseOr | OperatorKind.BitwiseXor | OperatorKind.LeftShift | OperatorKind.SignedRightShift | OperatorKind.UnsignedRightShift;
 export declare function isBinaryOperator(kind: OperatorKind): kind is BinaryOperatorKind;
 export type KindOfUnaryOperatorDefinedByToken = UnaryOperatorKind & KindOfOperatorDefinedByToken;
 export type KindOfUnaryOperatorDefinedByKeyword = UnaryOperatorKind & KindOfOperatorDefinedByKeyword;

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

@@ -1,15 +1,15 @@
-import { Tag } from '../analysis/Tag.js';
 import { IEntity } from './IEntity.js';
-import { AliasTypeEntity, EntityContext, EntityKind, FunctionTypeEntity, StructuredTypeEntity, TypeParameterEntity, VariantTypeEntity } from './index.js';
+import { AliasTypeEntity, EntityKind, FunctionTypeEntity, StructuredTypeEntity, TypeParameterEntity, VariantTypeEntity } from './index.js';
 export type TypeEntity = StructuredTypeEntity | FunctionTypeEntity | VariantTypeEntity | AliasTypeEntity | TypeParameterEntity;
 export declare namespace TypeEntity {
     function isAbstract(entity: TypeEntity): boolean;
+    function isAbstractOrAliasedAbstract(entity: TypeEntity): boolean;
+    function isBasic(entity: TypeEntity): boolean;
+    function isBasicOrAliasedBasic(entity: TypeEntity): boolean;
 }
 export interface ITypeEntity extends IEntity {
     readonly kind: EntityKind.Type;
     readonly typeEntityKind: TypeEntityKind;
-    getContext(): EntityContext;
-    getTags(): readonly Tag[];
 }
 export declare enum TypeEntityKind {
     Function = 0,