@artel/artc 0.6.26039 → 0.8.26001

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

@@ -0,0 +1,190 @@
+import { Name } from '../../../common/index.js';
+import { AccessorEntity, AnonymousFunctionEntity, FunctionEntity, FunctionTypeEntity, MethodEntity, NamedFunctionEntity, PackageEntity, ParameterEntity, TextTranslationEntity, TypeEntity, TypeEntityWithMembers, TypeExtensionEntity } from '../../../entities/index.js';
+import { SourceFileM } from '../../../project/SourceFile.js';
+import * as tree from '../../../tree/m/index.js';
+import * as types from '../../../types/index.js';
+import { DiagnosticArgumentFactory } from '../../DiagnosticArgumentFactory.js';
+import { PackageMemberLookupContext } from '../../PackageMemberLookup.js';
+import { TypeExtensionLookup, TypeMemberLookupContext } from '../../TypeMemberLookup.js';
+import { Analyzer } from '../Analyzer.js';
+import { NamedDeclaration, TagOrContainerWithTags, TypeOrContainerWithTypes } from './Declarations.js';
+import { SemanticContext } from './SemanticContext.js';
+export declare abstract class SemanticContextBase implements TypeExtensionLookup {
+    static readonly emptyTypesOrContainersWithTypes: readonly TypeOrContainerWithTypes[];
+    static readonly emptyTagsOrContainersWithTags: readonly TagOrContainerWithTags[];
+    static readonly emptyNamedDeclarations: readonly NamedDeclaration[];
+    static readonly emptyTypeExtensions: readonly TypeExtensionEntity[];
+    abstract readonly outer: SemanticContext | undefined;
+    protected abstract readonly asContext: SemanticContext;
+    abstract getContainingSubprogram(): SubprogramInfo | undefined;
+    abstract getContainingTypeOrTypeExtension(): TypeOrTypeExtension | undefined;
+    abstract getObjectVariableInfo(): ObjectVariableInfo | undefined;
+    abstract getTryStatementContext(): TryStatementContextKind | undefined;
+    abstract isStatic(): boolean;
+    abstract getTypeMemberLookupContext(): TypeMemberLookupContext;
+    abstract getOwnTypesOrContainersWithTypes(initialContext: SemanticContext): readonly TypeOrContainerWithTypes[];
+    abstract getOwnTypesOrContainersWithTypesByName(name: Name, initialContext: SemanticContext): readonly TypeOrContainerWithTypes[];
+    abstract getOwnTagsOrContainersWithTags(initialContext: SemanticContext): readonly TagOrContainerWithTags[];
+    abstract getOwnTagsOrContainersWithTagsByName(name: Name, initialContext: SemanticContext): readonly TagOrContainerWithTags[];
+    abstract getOwnNamedDeclarations(initialContext: SemanticContext, noInstanceMembers: boolean, lookupState: SemanticContextLookupState): readonly NamedDeclaration[];
+    abstract getOwnNamedDeclarationsByName(name: Name, initialContext: SemanticContext, noInstanceMembers: boolean, lookupResult: NamedDeclarationLookupResult): void;
+    getContainingSourceFile(): SourceFileM;
+    getContainingPackage(): PackageEntity;
+    getDiagnosticArgumentFactory(): DiagnosticArgumentFactory;
+    getPackageMemberLookupContext(): PackageMemberLookupContext;
+    getTypesOrContainersWithTypes(): readonly TypeOrContainerWithTypes[];
+    getTypesOrContainersWithTypesByName(name: Name): readonly TypeOrContainerWithTypes[];
+    getTagsOrContainersWithTags(): readonly TagOrContainerWithTags[];
+    getTagsOrContainersWithTagsByName(name: Name): readonly TagOrContainerWithTags[];
+    getNamedDeclarations(noInstanceMembers?: boolean): readonly NamedDeclaration[];
+    getNamedDeclarationsByName(name: Name, noInstanceMembers?: boolean): NamedDeclarationLookupResult;
+    getTypeExtensionsByType(type: TypeEntity): readonly TypeExtensionEntity[];
+    getTextTranslationEntityByTextKey(key: string): readonly TextTranslationEntity[];
+    private semanticContexts;
+    private getSourceFileContext;
+}
+export type SubprogramInfo = SubprogramInfo.Function | SubprogramInfo.Constructor | SubprogramInfo.Destructor | SubprogramInfo.Getter | SubprogramInfo.Setter | SubprogramInfo.FunctionLiteral | SubprogramInfo.TextTranslationFunction;
+export declare namespace SubprogramInfo {
+    export class Function implements ISubprogramInfo {
+        readonly kind = "function";
+        private readonly analyzer;
+        private readonly node;
+        private readonly entity;
+        constructor(analyzer: Analyzer, node: tree.FunctionDeclaration, entity: NamedFunctionEntity);
+        getReturnType(): types.Type | undefined;
+        isGenerator(): boolean;
+        allowsAsyncCalls(): boolean;
+        getNode(): tree.FunctionDeclaration;
+        getEntity(): NamedFunctionEntity;
+    }
+    export class Constructor implements ISubprogramInfo {
+        readonly kind = "constructor";
+        private readonly analyzer;
+        private readonly node;
+        private readonly entity;
+        constructor(analyzer: Analyzer, node: tree.MethodDeclaration, entity: MethodEntity);
+        getReturnType(): types.Type | undefined;
+        isGenerator(): boolean;
+        allowsAsyncCalls(): boolean;
+        getEntity(): MethodEntity;
+        getNode(): tree.MethodDeclaration;
+    }
+    export class Destructor implements ISubprogramInfo {
+        readonly kind = "destructor";
+        private readonly analyzer;
+        private readonly node;
+        private readonly entity;
+        constructor(analyzer: Analyzer, node: tree.MethodDeclaration, entity: MethodEntity);
+        getReturnType(): types.Type | undefined;
+        isGenerator(): boolean;
+        allowsAsyncCalls(): boolean;
+        getNode(): tree.MethodDeclaration;
+        getEntity(): MethodEntity;
+    }
+    export class Getter implements ISubprogramInfo {
+        readonly kind = "getter";
+        private readonly analyzer;
+        private readonly node;
+        constructor(analyzer: Analyzer, node: tree.GetterDeclaration);
+        getReturnType(): types.Type | undefined;
+        isGenerator(): boolean;
+        allowsAsyncCalls(): boolean;
+        getNode(): tree.GetterDeclaration;
+        getEntity(): AccessorEntity;
+    }
+    export class Setter implements ISubprogramInfo {
+        readonly kind = "setter";
+        private readonly analyzer;
+        private readonly node;
+        constructor(analyzer: Analyzer, node: tree.SetterDeclaration);
+        getReturnType(): types.Type | undefined;
+        isGenerator(): boolean;
+        allowsAsyncCalls(): boolean;
+        getNode(): tree.SetterDeclaration;
+        getEntity(): AccessorEntity;
+    }
+    export class FunctionLiteral implements ISubprogramInfo {
+        readonly kind = "function-literal";
+        private readonly analyzer;
+        private readonly node;
+        constructor(analyzer: Analyzer, node: tree.RegularOrBlockFunctionLiteral);
+        getReturnType(): types.Type | undefined;
+        isGenerator(): boolean;
+        allowsAsyncCalls(): boolean;
+        getNode(): tree.RegularOrBlockFunctionLiteral;
+        getEntity(): AnonymousFunctionEntity;
+    }
+    export class TextTranslationFunction implements ISubprogramInfo {
+        readonly kind = "text-translation-function";
+        private readonly analyzer;
+        private readonly node;
+        constructor(analyzer: Analyzer, node: tree.TextTranslationFunctionDeclaration);
+        getReturnType(): types.Type | undefined;
+        isGenerator(): boolean;
+        allowsAsyncCalls(): boolean;
+        getNode(): tree.TextTranslationFunctionDeclaration;
+        getEntity(): TextTranslationEntity;
+    }
+    interface ISubprogramInfo {
+        getReturnType(): types.Type | undefined;
+        isGenerator(): boolean;
+        allowsAsyncCalls(): boolean;
+        getNode(): tree.SubprogramDeclarationOrLiteral;
+        getEntity(): SubprogramInfoEntity | undefined;
+    }
+    export {};
+}
+export type SubprogramInfoEntity = FunctionEntity | FunctionTypeEntity | TextTranslationEntity;
+export type TypeOrTypeExtension = TypeOrTypeExtension.Type | TypeOrTypeExtension.TypeExtension;
+export declare namespace TypeOrTypeExtension {
+    export class Type implements ITypeOrTypeExtension {
+        readonly value: TypeEntityWithMembers;
+        readonly kind = "type";
+        constructor(value: TypeEntityWithMembers);
+        getContextualTypeEntity(): TypeEntity | undefined;
+        getEntity(): TypeEntityWithMembers;
+    }
+    export class TypeExtension implements ITypeOrTypeExtension {
+        readonly value: TypeExtensionEntity;
+        readonly kind = "type-extension";
+        constructor(value: TypeExtensionEntity);
+        getContextualTypeEntity(): TypeEntity | undefined;
+        getEntity(): TypeExtensionEntity;
+    }
+    interface ITypeOrTypeExtension {
+        getContextualTypeEntity(): TypeEntity | undefined;
+        getEntity(): TypeEntityWithMembers | TypeExtensionEntity;
+    }
+    export {};
+}
+export type ObjectVariableInfo = ObjectVariableInfo.ContainingTypeContext | ObjectVariableInfo.ObjectParameter;
+export declare namespace ObjectVariableInfo {
+    class ContainingTypeContext {
+        readonly typeOrExtension: TypeOrTypeExtension;
+        readonly kind = "containing-type-context";
+        constructor(typeOrExtension: TypeOrTypeExtension);
+    }
+    class ObjectParameter {
+        readonly parameter: ParameterEntity;
+        readonly kind = "object-parameter";
+        constructor(parameter: ParameterEntity);
+    }
+}
+export declare enum TryStatementContextKind {
+    InTryBlockWithCatchClause = 0,
+    InFinallyBlock = 1
+}
+export declare class SemanticContextLookupState {
+    hasSearchedInObjectVariable: boolean;
+}
+export declare class NamedDeclarationLookupResult {
+    hasSearchedInObjectVariable: boolean;
+    private declarations_;
+    private objectParameter_;
+    get declarations(): readonly NamedDeclaration[];
+    /**
+     * Параметр "объект", в типе которого были найден объявления.
+     */
+    get objectParameter(): ParameterEntity | undefined;
+    setDeclarations(declarations: readonly NamedDeclaration[], objectParameter: ParameterEntity | undefined): void;
+}

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

@@ -0,0 +1,69 @@
+import * as tree from '../../../tree/m/index.js';
+import { Analyzer } from '../Analyzer.js';
+import { SemanticContext } from './SemanticContext.js';
+import { SourceFileSemanticContext } from './SourceFileSemanticContext.js';
+import { ForStatementSemanticContext, StatementBlockSemanticContext, SubprogramParameterListSemanticContext, SubprogramTypeParameterSemanticContext, CatchClauseSemanticContext, StatementSemanticContextParent } from './SubprogramBodyAndParametersSemanticContext.js';
+import { FunctionLiteralSemanticContext, FunctionSemanticContext, IndexedElementAccessorSemanticContext, OutermostSemanticContextOfSubprogram, TextTranslationFunctionDeclarationSemanticContext, VariableAccessorSemanticContext } from './SubprogramSemanticContext.js';
+import { OutermostSemanticContextOfTypeOrExtension, ParametersOfFunctionTypeSemanticContext, TypeDeclarationWithTypeParameters, TypeOrExtensionDeclarationCreatingSemanticContext, TypeOrExtensionMembersSemanticContext, TypeParametersOfTypeSemanticContext } from './TypeSemanticContext.js';
+export declare class SemanticContextBuilder {
+    private readonly analyzer;
+    private readonly sourceFileContexts;
+    private readonly indexedElementAccessorContexts;
+    private readonly fieldWithInitializerContexts;
+    private readonly forStatementContexts;
+    private readonly catchClauseSemanticContexts;
+    private readonly functionLiteralContexts;
+    private readonly variableAccessorContexts;
+    private readonly typeParametersOfTypeContexts;
+    private readonly parametersOfFunctionTypeContexts;
+    private readonly statementBlockContexts;
+    private readonly subprogramTypeParameterContexts;
+    private readonly subprogramParameterListContexts;
+    private readonly outermostContextsOfFunctionDeclaration;
+    private readonly outermostContextsOfTextTranslationFunctionDeclaration;
+    private readonly outermostContextsOfTypeOrExtensionDeclaration;
+    private readonly typeOrExtensionMembersContexts;
+    constructor(analyzer: Analyzer);
+    /**
+     * Возвращает контекст, содержащий узел. Если в качестве узла передан исходный файл,
+     * будет возвращён контекст исходного файла.
+     */
+    containing(node: tree.Node): SemanticContext;
+    containingWithOffset(node: tree.Node, offset: number): SemanticContext;
+    ofSourceFile(node: tree.SourceFile): SourceFileSemanticContext;
+    ofFunctionDeclarationParameters(node: tree.FunctionDeclaration): SubprogramParameterListSemanticContext;
+    ofVariableAccessorDeclarationParameters(node: tree.VariableAccessorDeclaration): SubprogramParameterListSemanticContext;
+    ofFunctionDeclarationTypeParameters(node: tree.FunctionDeclaration, typeParameterClause: tree.TypeParameterClause): SubprogramTypeParameterSemanticContext;
+    outermostSemanticContextOfFunctionDeclaration(node: tree.FunctionDeclaration): FunctionSemanticContext;
+    ofTypeWithMembersOrExtensionDeclaration(node: tree.TypeWithMembersOrExtensionDeclaration): TypeOrExtensionMembersSemanticContext;
+    ofLocalFunctionTypeDeclarationParameters(node: tree.LocalFunctionTypeDeclaration): ParametersOfFunctionTypeSemanticContext;
+    outermostSemanticContextOfTypeOrExtensionDeclaration(node: TypeOrExtensionDeclarationCreatingSemanticContext): OutermostSemanticContextOfTypeOrExtension;
+    ofTypeDeclarationTypeParameters(node: TypeDeclarationWithTypeParameters, typeParameterClause: tree.TypeParameterClause): TypeParametersOfTypeSemanticContext;
+    ofVariableAccessorDeclaration(node: tree.VariableAccessorDeclaration): VariableAccessorSemanticContext;
+    ofRegularOrBlockFunctionLiteralParameters(node: tree.RegularOrBlockFunctionLiteral): SubprogramParameterListSemanticContext;
+    ofTextTranslationDeclarationParameters(node: tree.TranslationTextTemplate): SubprogramParameterListSemanticContext;
+    outermostSemanticContextOfTextTranslationFunctionDeclaration(node: tree.TextTranslationFunctionDeclaration): TextTranslationFunctionDeclarationSemanticContext;
+    outermostSemanticContextOfRegularOrBlockFunctionLiteral(node: tree.RegularOrBlockFunctionLiteral): FunctionLiteralSemanticContext;
+    ofForStatement(node: tree.ForStatement): ForStatementSemanticContext;
+    ofStatementBlock(node: tree.StatementBlock): StatementBlockSemanticContext;
+    ofFunctionBlock(node: tree.FunctionBlock): StatementBlockSemanticContext;
+    ofStatementParent(node: tree.StatementParent): StatementSemanticContextParent;
+    ofIndexedElementAccessorDeclarationParameters(node: tree.IndexedElementAccessorDeclaration): SubprogramParameterListSemanticContext;
+    outermostSemanticContextOfIndexedElementAccessorDeclaration(node: tree.IndexedElementAccessorDeclaration): IndexedElementAccessorSemanticContext;
+    ofCatchClause(node: tree.CatchClause): CatchClauseSemanticContext;
+    ofFieldDeclarationWithInitializer(node: tree.FieldDeclaration | tree.StaticFieldDeclaration): SemanticContext;
+    ofSubprogram(node: tree.SubprogramDeclarationOrLiteral): OutermostSemanticContextOfSubprogram;
+    containingTypeMember(node: tree.TypeMemberDeclaration): TypeOrExtensionMembersSemanticContext;
+    containingPackageMember(node: tree.PackageMemberDeclaration): SourceFileSemanticContext;
+    private containingInternal;
+    private ofChildOfFunctionDeclaration;
+    private ofChildOfVariableAccessorDeclaration;
+    private ofChildOfTypeWithMembersOrExtensionDeclaration;
+    private ofChildOfLocalFunctionTypeDeclaration;
+    private ofChildOfFunctionLiteral;
+    private ofIndexedElementAccessorDeclarationChild;
+    private isOffsetInsideNode;
+    private isOffsetBetweenNodes;
+    private isOffsetInsideStatementBlock;
+    private isOffsetInsideFunctionBlock;
+}

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

@@ -0,0 +1,51 @@
+import { Name } from '../../../common/index.js';
+import { DiagnosticAcceptor } from '../../../diagnostic/Diagnostic.js';
+import { LocalStructuredTypeEntity, LocalVariableEntity, NestedFunctionEntity, ParameterEntity, TypeParameterEntity } from '../../../entities/index.js';
+import * as tree from '../../../tree/m/index.js';
+import { Analyzer } from '../Analyzer.js';
+import { NamedDeclaration, TagOrContainerWithTags, TypeOrContainerWithTypes } from './Declarations.js';
+import { SemanticContext } from './SemanticContext.js';
+import { NamedDeclarationLookupResult, SemanticContextLookupState } from './SemanticContextBase.js';
+import { SemanticContextWithParent } from './SemanticContextWithParent.js';
+export interface NameConflictsValidator {
+    validateNameConflicts(diagnostics: DiagnosticAcceptor): void;
+}
+export declare abstract class SemanticContextValidatingNameConflictsBase extends SemanticContextWithParent implements NameConflictsValidator {
+    abstract readonly outer: SemanticContext;
+    abstract readonly node: tree.Node;
+    protected readonly analyzer: Analyzer;
+    private memberEntities_;
+    private memberEntitiesByNameKey;
+    private namedDeclarations_;
+    private typesOrContainerWithTypes_;
+    private tagsOrContainerWithTags_;
+    private namedDeclarationsByName_;
+    private typesOrContainerWithTypesByName_;
+    private tagsOrContainerWithTagsByName_;
+    private get memberEntities();
+    private get namedDeclarations();
+    private get typesOrContainerWithTypes();
+    private get tagsOrContainerWithTags();
+    private get namedDeclarationsByName();
+    private get typesOrContainerWithTypesByName();
+    private get tagsOrContainerWithTagsByName();
+    constructor(analyzer: Analyzer);
+    protected abstract createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
+    protected abstract createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
+    protected abstract createMemberEntitiesForTagLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTagLookup[];
+    getOwnTypesOrContainersWithTypes(_initialContext: SemanticContext): readonly TypeOrContainerWithTypes[];
+    getOwnTypesOrContainersWithTypesByName(name: Name, _initialContext: SemanticContext): readonly TypeOrContainerWithTypes[];
+    getOwnTagsOrContainersWithTags(_initialContext: SemanticContext): readonly TagOrContainerWithTags[];
+    getOwnTagsOrContainersWithTagsByName(name: Name, _initialContext: SemanticContext): readonly TagOrContainerWithTags[];
+    getOwnNamedDeclarations(_initialContext: SemanticContext, _noInstanceMembers: boolean, _lookupState: SemanticContextLookupState): readonly NamedDeclaration[];
+    getOwnNamedDeclarationsByName(name: Name, _initialContext: SemanticContext, _noInstanceMembers: boolean, lookupResult: NamedDeclarationLookupResult): void;
+    validateNameConflicts(diagnostics: DiagnosticAcceptor): void;
+    private getMemberEntityDictionary;
+    private validateNestedFunctionsConflicts;
+    private createNamedDeclarations;
+    private createTypesOrContainerWithTypes;
+    private createTagsOrContainerWithTags;
+}
+export type MemberOfSemanticContextValidatingNameConflicts = LocalVariableEntity | ParameterEntity | NestedFunctionEntity | TypeParameterEntity | LocalStructuredTypeEntity;
+export type MemberOfSemanticContextValidatingNameConflictsForTypeLookup = TypeParameterEntity | LocalStructuredTypeEntity;
+export type MemberOfSemanticContextValidatingNameConflictsForTagLookup = NestedFunctionEntity | TypeParameterEntity | LocalStructuredTypeEntity;

package/build/types/analysis/m/semantic-context/SemanticContextWithParent.d.ts

@@ -0,0 +1,12 @@
+import { TypeMemberLookupContext } from '../../TypeMemberLookup.js';
+import { SemanticContext } from './SemanticContext.js';
+import { ObjectVariableInfo, SemanticContextBase, SubprogramInfo, TryStatementContextKind, TypeOrTypeExtension } from './SemanticContextBase.js';
+export declare abstract class SemanticContextWithParent extends SemanticContextBase {
+    abstract readonly outer: SemanticContext;
+    getContainingSubprogram(): SubprogramInfo | undefined;
+    getContainingTypeOrTypeExtension(): TypeOrTypeExtension | undefined;
+    getObjectVariableInfo(): ObjectVariableInfo | undefined;
+    getTryStatementContext(): TryStatementContextKind | undefined;
+    isStatic(): boolean;
+    getTypeMemberLookupContext(): TypeMemberLookupContext;
+}

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

@@ -0,0 +1,63 @@
+import { Name } from '../../../common/index.js';
+import { DiagnosticAcceptor } from '../../../diagnostic/Diagnostic.js';
+import { PackageEntity, TextTranslationEntity, TypeEntity, TypeExtensionEntity } from '../../../entities/index.js';
+import { SourceFileM } from '../../../project/SourceFile.js';
+import * as tree from '../../../tree/m/index.js';
+import { DiagnosticArgumentFactory } from '../../DiagnosticArgumentFactory.js';
+import { PackageMemberLookupContext } from '../../PackageMemberLookup.js';
+import { TypeMemberLookupContext } from '../../TypeMemberLookup.js';
+import { Analyzer } from '../Analyzer.js';
+import { NamedDeclaration, TagOrContainerWithTags, TypeOrContainerWithTypes } from './Declarations.js';
+import { SemanticContext } from './SemanticContext.js';
+import { NamedDeclarationLookupResult, ObjectVariableInfo, SemanticContextBase, SemanticContextLookupState, SubprogramInfo, TryStatementContextKind, TypeOrTypeExtension } from './SemanticContextBase.js';
+export declare class SourceFileSemanticContext extends SemanticContextBase {
+    readonly kind = "source-file";
+    readonly outer: SemanticContext | undefined;
+    protected asContext: SemanticContext;
+    private readonly analyzer;
+    private readonly sourceFile;
+    private readonly containingPackageMemberLookup;
+    private readonly importedPackageMemberLookups;
+    private readonly packageAliases;
+    private readonly packageAliasesByNameKey_;
+    private readonly packageNameSegments;
+    private readonly packageNameSegmentsByNameKey_;
+    private readonly diagnosticArgumentFactory;
+    private readonly primaryTextTranslationPackage_;
+    private readonly packageMemberLookupContext;
+    private readonly typeMemberLookupContext;
+    private readonly localTypes_;
+    private readonly localTypesByNameKey_;
+    private get packageAliasesByNameKey();
+    private get packageNameSegmentsByNameKey();
+    private get primaryTextTranslationPackage();
+    private get localTypes();
+    private get localTypesByNameKey();
+    constructor(analyzer: Analyzer, node: tree.SourceFile);
+    getContainingSubprogram(): SubprogramInfo | undefined;
+    getContainingTypeOrTypeExtension(): TypeOrTypeExtension | undefined;
+    getObjectVariableInfo(): ObjectVariableInfo | undefined;
+    getSourceFile(): SourceFileM;
+    getPackage(): PackageEntity;
+    getTryStatementContext(): TryStatementContextKind | undefined;
+    isStatic(): boolean;
+    getPackageMemberLookupContext(): PackageMemberLookupContext;
+    getTypeMemberLookupContext(): TypeMemberLookupContext;
+    getDiagnosticArgumentFactory(): DiagnosticArgumentFactory;
+    getOwnTypesOrContainersWithTypes(initialContext: SemanticContext): readonly TypeOrContainerWithTypes[];
+    getOwnTypesOrContainersWithTypesByName(name: Name, initialContext: SemanticContext): readonly TypeOrContainerWithTypes[];
+    getOwnTagsOrContainersWithTags(initialContext: SemanticContext): readonly TagOrContainerWithTags[];
+    getOwnTagsOrContainersWithTagsByName(name: Name, initialContext: SemanticContext): readonly TagOrContainerWithTags[];
+    getOwnNamedDeclarations(initialContext: SemanticContext, _noInstanceMembers: boolean, _lookupState: SemanticContextLookupState): NamedDeclaration[];
+    getOwnNamedDeclarationsByName(name: Name, initialContext: SemanticContext, _noInstanceMembers: boolean, lookupResult: NamedDeclarationLookupResult): void;
+    getOwnTypeExtensionsByType(type: TypeEntity, initialContext: SemanticContext): TypeExtensionEntity[];
+    getTextTranslationEntityByTextKey(key: string): readonly TextTranslationEntity[];
+    validateNameConflicts(diagnostics: DiagnosticAcceptor): void;
+    validateLocalTypes(diagnostics: DiagnosticAcceptor): void;
+    private convertEntityToNamedDeclaration;
+    private convertEntityToTypeOrContainerWithTypes;
+    private convertEntityToTagOrContainerWithTags;
+    private convertPackageAliasToTypeOrContainerWithTypes;
+    private convertPackageAliasToTagOrContainerWithTags;
+    private convertPackageAliasToNamedDeclaration;
+}

package/build/types/analysis/m/semantic-context/StaticDeclarationSemanticContext.d.ts

@@ -0,0 +1,26 @@
+import { Name } from '../../../common/Name.js';
+import * as tree from '../../../tree/m/index.js';
+import { TypeMemberLookupContext } from '../../TypeMemberLookup.js';
+import { Analyzer } from '../Analyzer.js';
+import { TypeOrContainerWithTypes, TagOrContainerWithTags, NamedDeclaration } from './Declarations.js';
+import { SemanticContext } from './SemanticContext.js';
+import { SemanticContextLookupState, NamedDeclarationLookupResult } from './SemanticContextBase.js';
+import { SemanticContextWithParent } from './SemanticContextWithParent.js';
+export declare class StaticDeclarationSemanticContext extends SemanticContextWithParent {
+    readonly kind = "static-declaration";
+    readonly outer: SemanticContext;
+    protected readonly asContext: SemanticContext;
+    protected readonly analyzer: Analyzer;
+    private readonly node;
+    private readonly typeMemberLookupContext;
+    constructor(analyzer: Analyzer, node: tree.StaticDeclaration, outer: SemanticContext);
+    getTypeMemberLookupContext(): TypeMemberLookupContext;
+    getOwnTypesOrContainersWithTypes(_initialContext: SemanticContext): readonly TypeOrContainerWithTypes[];
+    getOwnTypesOrContainersWithTypesByName(_name: Name, _initialContext: SemanticContext): readonly TypeOrContainerWithTypes[];
+    getOwnTagsOrContainersWithTags(_initialContext: SemanticContext): readonly TagOrContainerWithTags[];
+    getOwnTagsOrContainersWithTagsByName(_name: Name, _initialContext: SemanticContext): readonly TagOrContainerWithTags[];
+    getOwnNamedDeclarations(_initialContext: SemanticContext, _noInstanceMembers: boolean, _lookupState: SemanticContextLookupState): readonly NamedDeclaration[];
+    getOwnNamedDeclarationsByName(_name: Name, _initialContext: SemanticContext, _noInstanceMembers: boolean, _lookupResult: NamedDeclarationLookupResult): void;
+    isStatic(): boolean;
+    private getContainingTypeOrExtension;
+}

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

@@ -0,0 +1,108 @@
+import { DiagnosticAcceptor } from '../../../diagnostic/Diagnostic.js';
+import { LocalVariableEntity, ParameterEntity, TypeParameterEntity } from '../../../entities/index.js';
+import * as tree from '../../../tree/m/index.js';
+import { Analyzer } from '../Analyzer.js';
+import { ReservedNameKind } from '../ReservedNameDictionary.js';
+import { SemanticContext } from './SemanticContext.js';
+import { TryStatementContextKind } from './SemanticContextBase.js';
+import { MemberOfSemanticContextValidatingNameConflicts, MemberOfSemanticContextValidatingNameConflictsForTagLookup, MemberOfSemanticContextValidatingNameConflictsForTypeLookup, SemanticContextValidatingNameConflictsBase } from './SemanticContextValidatingNameConflicts.js';
+import { SourceFileSemanticContext } from './SourceFileSemanticContext.js';
+import { OutermostSemanticContextOfSubprogram } from './SubprogramSemanticContext.js';
+export type SubprogramTypeParameterSemanticContextParent = OutermostSemanticContextOfSubprogram;
+export declare class SubprogramTypeParameterSemanticContext extends SemanticContextValidatingNameConflictsBase {
+    readonly kind = "subprogram-type-parameter";
+    readonly outer: SubprogramTypeParameterSemanticContextParent;
+    readonly node: tree.TypeParameterClause;
+    protected readonly asContext: SemanticContext;
+    private readonly localTypes_;
+    private get localTypes();
+    constructor(analyzer: Analyzer, node: tree.TypeParameterClause, outer: SubprogramTypeParameterSemanticContextParent);
+    protected getTypeParameterEntities(): readonly TypeParameterEntity[];
+    validateNameConflicts(diagnostics: DiagnosticAcceptor): void;
+    protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
+    protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
+    protected createMemberEntitiesForTagLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTagLookup[];
+}
+export type SubprogramParameterListSemanticContextParent = SubprogramTypeParameterSemanticContext | OutermostSemanticContextOfSubprogram | SourceFileSemanticContext;
+export declare abstract class SubprogramParameterListSemanticContext extends SemanticContextValidatingNameConflictsBase {
+    readonly kind = "subprogram-parameter-list";
+    readonly outer: SubprogramParameterListSemanticContextParent;
+    constructor(analyzer: Analyzer, outer: SubprogramParameterListSemanticContextParent);
+    protected abstract getParameterEntities(): readonly ParameterEntity[];
+    protected abstract getSpecialVariableKinds(): readonly ReservedNameKind[];
+    validateNameConflicts(diagnostics: DiagnosticAcceptor): void;
+}
+export declare class ExplicitSubprogramParameterListSemanticContext extends SubprogramParameterListSemanticContext {
+    readonly node: tree.ParameterList;
+    protected readonly asContext: SemanticContext;
+    private readonly localTypes_;
+    private get localTypes();
+    constructor(analyzer: Analyzer, node: tree.ParameterList, outer: SubprogramParameterListSemanticContextParent);
+    protected getParameterEntities(): readonly ParameterEntity[];
+    protected getSpecialVariableKinds(): readonly ReservedNameKind[];
+    protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
+    protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
+    protected createMemberEntitiesForTagLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTagLookup[];
+}
+export declare class FunctionBlockLiteralParameterListSemanticContext extends SubprogramParameterListSemanticContext {
+    readonly node: tree.FunctionBlockLiteral;
+    protected readonly asContext: SemanticContext;
+    private readonly localTypes_;
+    private get localTypes();
+    constructor(analyzer: Analyzer, node: tree.FunctionBlockLiteral, outer: SubprogramParameterListSemanticContextParent);
+    protected getParameterEntities(): readonly ParameterEntity[];
+    protected getSpecialVariableKinds(): readonly ReservedNameKind[];
+    protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
+    protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
+    protected createMemberEntitiesForTagLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTagLookup[];
+}
+export declare class TranslationTextTemplateParameterListSemanticContext extends SubprogramParameterListSemanticContext {
+    readonly node: tree.TranslationTextTemplate;
+    protected readonly asContext: SemanticContext;
+    constructor(analyzer: Analyzer, node: tree.TranslationTextTemplate, outer: SubprogramParameterListSemanticContextParent);
+    protected getParameterEntities(): readonly ParameterEntity[];
+    protected getSpecialVariableKinds(): readonly ReservedNameKind[];
+    protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
+    protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
+    protected createMemberEntitiesForTagLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTagLookup[];
+}
+export type StatementBlockSemanticContextParent = ForStatementSemanticContext | CatchClauseSemanticContext | SubprogramParameterListSemanticContext | OutermostSemanticContextOfSubprogram | StatementSemanticContextParent;
+export declare class StatementBlockSemanticContext extends SemanticContextValidatingNameConflictsBase {
+    readonly kind = "statement-block";
+    readonly outer: StatementBlockSemanticContextParent;
+    readonly node: tree.StatementBlock | tree.FunctionBlock;
+    protected readonly asContext: SemanticContext;
+    private readonly localTypes_;
+    private get localTypes();
+    constructor(analyzer: Analyzer, node: tree.StatementBlock | tree.FunctionBlock, outer: StatementBlockSemanticContextParent);
+    getTryStatementContext(): TryStatementContextKind | undefined;
+    protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
+    protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
+    protected createMemberEntitiesForTagLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTagLookup[];
+}
+export type StatementSemanticContextParent = StatementBlockSemanticContext | SourceFileSemanticContext;
+export declare class ForStatementSemanticContext extends SemanticContextValidatingNameConflictsBase {
+    readonly kind = "for-statement";
+    readonly outer: StatementSemanticContextParent;
+    readonly node: tree.ForStatement;
+    protected readonly asContext: SemanticContext;
+    private readonly localTypes_;
+    private get localTypes();
+    constructor(analyzer: Analyzer, node: tree.ForStatement, outer: StatementSemanticContextParent);
+    protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
+    protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
+    protected createMemberEntitiesForTagLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTagLookup[];
+}
+export declare class CatchClauseSemanticContext extends SemanticContextValidatingNameConflictsBase {
+    readonly kind = "catch-clause";
+    readonly outer: StatementSemanticContextParent;
+    readonly node: tree.CatchClause;
+    protected readonly asContext: SemanticContext;
+    private readonly localTypes_;
+    private get localTypes();
+    constructor(analyzer: Analyzer, node: tree.CatchClause, outer: StatementSemanticContextParent);
+    protected getErrorVariableEntities(): readonly LocalVariableEntity[];
+    protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
+    protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
+    protected createMemberEntitiesForTagLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTagLookup[];
+}

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

@@ -0,0 +1,92 @@
+import { Name } from '../../../common/index.js';
+import { ParameterEntity } from '../../../entities/index.js';
+import * as tree from '../../../tree/m/index.js';
+import { Analyzer } from '../Analyzer.js';
+import { NamedDeclaration, TagOrContainerWithTags, TypeOrContainerWithTypes } from './Declarations.js';
+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 { StaticDeclarationSemanticContext } from './StaticDeclarationSemanticContext.js';
+import { TypeOrExtensionMembersSemanticContext } from './TypeSemanticContext.js';
+export type LastSemanticContextOfSubprogramParent = SemanticContext;
+/**
+ * Завершающий семантический контекст подпрограммы.
+ * Данный контекст располагается после контекста с параметрами (или параметрами типа) и переопределяет метод
+ * {@link SemanticContext.getContainingSubprogram}.
+ */
+export declare abstract class OutermostSemanticContextOfSubprogram extends SemanticContextWithParent {
+    readonly kind = "outermost-of-subprogram";
+    protected abstract readonly analyzer: Analyzer;
+    private readonly objectVariableInfo;
+    private readonly objectParameter_;
+    private readonly objectParameterMemberLookup_;
+    private get objectParameter();
+    private get objectParameterMemberLookup();
+    abstract getContainingSubprogram(): SubprogramInfo;
+    protected abstract findObjectParameter(): ParameterEntity | undefined;
+    getObjectVariableInfo(): ObjectVariableInfo | undefined;
+    getTryStatementContext(): TryStatementContextKind | undefined;
+    getOwnTypesOrContainersWithTypes(_initialContext: SemanticContext): readonly TypeOrContainerWithTypes[];
+    getOwnTypesOrContainersWithTypesByName(_name: Name, _initialContext: SemanticContext): readonly TypeOrContainerWithTypes[];
+    getOwnTagsOrContainersWithTags(_initialContext: SemanticContext): readonly TagOrContainerWithTags[];
+    getOwnTagsOrContainersWithTagsByName(_name: Name, _initialContext: SemanticContext): readonly TagOrContainerWithTags[];
+    getOwnNamedDeclarations(initialContext: SemanticContext, noInstanceMembers: boolean, lookupState: SemanticContextLookupState): readonly NamedDeclaration[];
+    getOwnNamedDeclarationsByName(name: Name, initialContext: SemanticContext, noInstanceMembers: boolean, lookupResult: NamedDeclarationLookupResult): void;
+    private convertNamedMember;
+}
+export declare class FunctionSemanticContext extends OutermostSemanticContextOfSubprogram {
+    readonly outer: SemanticContext;
+    protected readonly asContext: SemanticContext;
+    protected readonly analyzer: Analyzer;
+    private readonly node;
+    private readonly subprogramInfo;
+    constructor(analyzer: Analyzer, node: tree.FunctionDeclaration, outer: SemanticContext);
+    getContainingSubprogram(): SubprogramInfo;
+    isStatic(): boolean;
+    protected findObjectParameter(): ParameterEntity | undefined;
+}
+export type VariableAccessorSemanticContextParent = TypeOrExtensionMembersSemanticContext | SourceFileSemanticContext | StaticDeclarationSemanticContext;
+export declare class VariableAccessorSemanticContext extends OutermostSemanticContextOfSubprogram {
+    readonly outer: VariableAccessorSemanticContextParent;
+    protected readonly asContext: SemanticContext;
+    protected readonly analyzer: Analyzer;
+    private readonly node;
+    private readonly subprogramInfo;
+    constructor(analyzer: Analyzer, node: tree.VariableAccessorDeclaration, outer: VariableAccessorSemanticContextParent);
+    getContainingSubprogram(): SubprogramInfo;
+    isStatic(): boolean;
+    protected findObjectParameter(): ParameterEntity | undefined;
+}
+export type IndexedElementAccessorSemanticContextParent = TypeOrExtensionMembersSemanticContext | SourceFileSemanticContext;
+export declare class IndexedElementAccessorSemanticContext extends OutermostSemanticContextOfSubprogram {
+    readonly outer: IndexedElementAccessorSemanticContextParent;
+    protected readonly asContext: SemanticContext;
+    protected readonly analyzer: Analyzer;
+    private readonly node;
+    private readonly subprogramInfo;
+    constructor(analyzer: Analyzer, node: tree.IndexedElementAccessorDeclaration, outer: IndexedElementAccessorSemanticContextParent);
+    getContainingSubprogram(): SubprogramInfo;
+    isStatic(): boolean;
+    protected findObjectParameter(): ParameterEntity | undefined;
+}
+export declare class FunctionLiteralSemanticContext extends OutermostSemanticContextOfSubprogram {
+    readonly outer: SemanticContext;
+    protected readonly asContext: SemanticContext;
+    protected readonly analyzer: Analyzer;
+    private readonly node;
+    private readonly subprogramInfo;
+    constructor(analyzer: Analyzer, node: tree.RegularOrBlockFunctionLiteral, outer: SemanticContext);
+    getContainingSubprogram(): SubprogramInfo;
+    protected findObjectParameter(): ParameterEntity | undefined;
+}
+export declare class TextTranslationFunctionDeclarationSemanticContext extends OutermostSemanticContextOfSubprogram {
+    readonly outer: SemanticContext;
+    protected readonly asContext: SemanticContext;
+    protected readonly analyzer: Analyzer;
+    private readonly node;
+    private readonly subprogramInfo;
+    constructor(analyzer: Analyzer, node: tree.TextTranslationFunctionDeclaration, outer: SemanticContext);
+    getContainingSubprogram(): SubprogramInfo;
+    protected findObjectParameter(): ParameterEntity | undefined;
+}