@artel/artc 0.6.25226 → 0.6.25228

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

@@ -0,0 +1,84 @@
+import * as tree from '../../tree/index.js';
+import { Analyzer } from '../Analyzer.js';
+import { FunctionDeclaration, IndexedElementAccessorDeclaration, PackageTypeDeclaration, RegularOrBlockFunctionLiteral, SubprogramDeclarationOrLiteral } from '../NodeTypeUtils.js';
+import { BlockSemanticContext, CatchClauseSemanticContext, ConstructorSemanticContext, DestructorSemanticContext, ForStatementSemanticContext, FunctionBlockSemanticContext, FunctionLiteralSemanticContext, FunctionSemanticContext, IndexedElementAccessorSemanticContext, OperatorSemanticContext, OutermostSemanticContextOfSubprogram, OutermostSemanticContextOfType, PackageConstructorSemanticContext, PackageEntryPointSemanticContext, ParametersOfFunctionTypeSemanticContext, SemanticContext, SemanticContextContainingTypeMember, SourceFileSemanticContext, SpecialLocalDeclarationSemanticContext, StatementBlockSemanticContext, SubprogramParameterSemanticContext, SubprogramTypeParameterSemanticContext, TypeBodySemanticContext, TypeDeclarationCreatingSemanticContext, TypeDeclarationWithMembersBody, 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;
+    private readonly _destructorContexts;
+    private readonly _constructorContexts;
+    private readonly _functionLiteralContexts;
+    private readonly _packageEntryPointContexts;
+    private readonly _packageConstructorContexts;
+    private readonly _variableAccessorContexts;
+    private readonly _typeDeclarationTypeParameterContexts;
+    private readonly _typeDeclarationBodyContexts;
+    private readonly _parametersOfFunctionTypeContext;
+    private readonly _statementBlockContexts;
+    private readonly _functionBlockContexts;
+    private readonly _specialLocalDeclarationContexts;
+    private readonly _subprogramTypeParameterContexts;
+    private readonly _subprogramParameterContexts;
+    private readonly _outermostContextsOfFunctionDeclaration;
+    private readonly _outermostContextsOfTypeDeclaration;
+    private readonly _typeExtensionDeclarationBodyContexts;
+    constructor(analyzer: Analyzer);
+    /**
+     * Возвращает контекст, содержащий узел. Если в качестве узла передан исходный файл,
+     * будет возвращён контекст исходного файла.
+     */
+    containing(node: tree.Node): SemanticContext;
+    containingWithOffset(node: tree.Node, offset: number): SemanticContext;
+    ofSourceFile(node: tree.SourceFile): SourceFileSemanticContext;
+    ofFunctionDeclarationParameters(node: FunctionDeclaration): SubprogramParameterSemanticContext;
+    ofFunctionDeclarationTypeParameters(node: FunctionDeclaration, typeParameterClause: tree.TypeParameterClause): SubprogramTypeParameterSemanticContext;
+    outermostSemanticContextOfFunctionDeclaration(node: FunctionDeclaration): FunctionSemanticContext;
+    ofOperatorDeclarationParameters(node: tree.OperatorDeclaration): SubprogramParameterSemanticContext;
+    outermostSemanticContextOfOperatorDeclaration(node: tree.OperatorDeclaration): OperatorSemanticContext;
+    ofTypeDeclarationBody(node: TypeDeclarationWithMembersBody): TypeBodySemanticContext;
+    ofFunctionTypeDeclarationParameters(node: tree.FunctionTypeDeclarationBody): ParametersOfFunctionTypeSemanticContext;
+    outermostSemanticContextOfTypeDeclaration(node: TypeDeclarationCreatingSemanticContext): OutermostSemanticContextOfType;
+    ofTypeDeclarationTypeParameters(node: PackageTypeDeclaration, typeParameterClause: tree.TypeParameterClause): TypeParametersOfTypeSemanticContext;
+    ofTypeExtensionDeclarationBody(node: tree.TypeExtensionDeclaration): TypeExtensionBodySemanticContext;
+    ofVariableAccessorDeclaration(node: VariableAccessorDeclaration): VariableAccessorSemanticContext;
+    ofPackageConstructorDeclaration(node: tree.PackageConstructorDeclaration): PackageConstructorSemanticContext;
+    ofPackageEntryPointDeclaration(node: tree.PackageEntryPointDeclaration): PackageEntryPointSemanticContext;
+    ofRegularOrBlockFunctionLiteralParameters(node: RegularOrBlockFunctionLiteral): SubprogramParameterSemanticContext;
+    outermostSemanticContextOfRegularOrBlockFunctionLiteral(node: RegularOrBlockFunctionLiteral): FunctionLiteralSemanticContext;
+    ofForStatement(node: tree.ForStatement): ForStatementSemanticContext;
+    ofStatementBlock(node: tree.StatementBlock): StatementBlockSemanticContext;
+    ofFunctionBlock(node: tree.FunctionBlock): FunctionBlockSemanticContext;
+    withSpecialLocalDeclarations(node: tree.FunctionBlock): SpecialLocalDeclarationSemanticContext;
+    ofStatementBlockOrFunctionBlock(node: tree.StatementBlock | tree.FunctionBlock): BlockSemanticContext;
+    ofConstructorDeclarationParameters(node: tree.ConstructorDeclaration): SubprogramParameterSemanticContext;
+    outermostSemanticContextOfConstructorDeclaration(node: tree.ConstructorDeclaration): ConstructorSemanticContext;
+    ofDestructorDeclarationParameters(node: tree.DestructorDeclaration): SubprogramParameterSemanticContext;
+    outermostSemanticContextOfDestructorDeclaration(node: tree.DestructorDeclaration): DestructorSemanticContext;
+    ofIndexedElementAccessorDeclarationParameters(node: IndexedElementAccessorDeclaration): SubprogramParameterSemanticContext;
+    outermostSemanticContextOfIndexedElementAccessorDeclaration(node: IndexedElementAccessorDeclaration): IndexedElementAccessorSemanticContext;
+    ofCatchClause(node: tree.CatchClause): CatchClauseSemanticContext;
+    ofFieldDeclarationWithInitializer(node: tree.FieldDeclaration): SemanticContext;
+    ofSubprogram(node: SubprogramDeclarationOrLiteral): OutermostSemanticContextOfSubprogram;
+    containingTypeMember(node: tree.TypeMemberDeclaration): SemanticContextContainingTypeMember;
+    containingPackageMember(node: tree.PackageMemberDeclaration): SourceFileSemanticContext;
+    private containingInternal;
+    private ofChildOfFunctionDeclaration;
+    private ofChildOfTypeDeclarationWithMemberBlock;
+    private ofChildOfTypeDeclarationBodyWithMemberBlock;
+    private ofChildOfFunctionTypeDeclarationBody;
+    private ofChildOfFunctionLiteral;
+    private ofOperatorDeclarationChild;
+    private ofConstructorDeclarationChild;
+    private ofDestructorDeclarationChild;
+    private ofIndexedElementGetterDeclarationChild;
+    private ofIndexedElementSetterDeclarationChild;
+    private ofChildOfTypeExtensionDeclaration;
+    private isOffsetBetweenNodes;
+    private isOffsetInsideStatementBlock;
+    private isOffsetInsideFunctionBlock;
+}

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

@@ -0,0 +1,45 @@
+import { SearchName } from '../../common/index.js';
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import { IEntityHidingMatcher } from '../../entities/EntityHiding.js';
+import { LocalVariableEntity, NestedFunctionEntity, ParameterVariableEntity, TypeParameterEntity } from '../../entities/index.js';
+import * as tree from '../../tree/index.js';
+import { Analyzer } from '../Analyzer.js';
+import { FoundNamedDeclaration } from '../FoundDeclaration.js';
+import { NamedDeclaration, TypeOrContainerWithTypes } from './Declarations.js';
+import { SemanticContext } from './SemanticContext.js';
+import { SemanticContextWithParent } from './SemanticContextWithParent.js';
+export declare abstract class SemanticContextValidatingNameConflictsBase extends SemanticContextWithParent implements ISemanticContextValidatingNameConflicts {
+    abstract readonly outer: SemanticContext;
+    abstract readonly node: tree.Node;
+    protected readonly _analyzer: Analyzer;
+    private readonly _memberEntities;
+    private _memberEntitiesByNameKey;
+    private readonly _namedDeclarations;
+    private readonly _typesOrContainerWithTypes;
+    private readonly _namedDeclarationsByName;
+    private readonly _typesOrContainerWithTypesByName;
+    private get memberEntities();
+    private get namedDeclarations();
+    private get typesOrContainerWithTypes();
+    private get namedDeclarationsByName();
+    private get typesOrContainerWithTypesByName();
+    constructor(analyzer: Analyzer);
+    protected abstract createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
+    protected abstract createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
+    getOwnTypesOrContainersWithTypes(_hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<TypeOrContainerWithTypes>[];
+    getOwnTypesOrContainersWithTypesByName(name: SearchName, _hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<TypeOrContainerWithTypes>[];
+    getOwnNamedDeclarations(_noInstanceMembers?: boolean, _hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<NamedDeclaration>[];
+    getOwnNamedDeclarationsByName(name: SearchName, _noInstanceMembers?: boolean, _hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<NamedDeclaration>[];
+    validateNameConflicts(diagnostics: DiagnosticAcceptor): void;
+    private getMemberEntityDictionary;
+    private validateNestedFunctionsConflicts;
+    private areNestedFunctionSignaturesEqual;
+    private createNamedDeclarations;
+    private createTypesOrContainerWithTypes;
+}
+interface ISemanticContextValidatingNameConflicts {
+    validateNameConflicts(diagnostics: DiagnosticAcceptor): void;
+}
+export type MemberOfSemanticContextValidatingNameConflicts = LocalVariableEntity | ParameterVariableEntity | NestedFunctionEntity | TypeParameterEntity;
+export type MemberOfSemanticContextValidatingNameConflictsForTypeLookup = TypeParameterEntity;
+export {};

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

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

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

@@ -0,0 +1,42 @@
+import { SearchName } from '../../common/index.js';
+import { IEntityHidingMatcher } from '../../entities/EntityHiding.js';
+import { PackageEntity, TypeEntity, TypeExtensionEntity } from '../../entities/index.js';
+import { SourceFile } from '../../project/SourceFile.js';
+import * as tree from '../../tree/index.js';
+import { Analyzer } from '../Analyzer.js';
+import { FoundNamedDeclaration } from '../FoundDeclaration.js';
+import { LocalizationContext } from '../LocalizationContext.js';
+import { NamedDeclaration, TypeOrContainerWithTypes } from './Declarations.js';
+import { SemanticContext } from './SemanticContext.js';
+import { SemanticContextBase, 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 _sourceFileMembers;
+    private readonly _containingPackageMemberLookup;
+    private readonly _importedPackageMemberLookups;
+    private readonly _packageNameSegments;
+    private readonly _packageNameSegmentsByKey;
+    private readonly _locale;
+    private get packageNameSegmentsByKey();
+    constructor(analyzer: Analyzer, node: tree.SourceFile);
+    getContainingSubprogram(): SubprogramInfo | undefined;
+    getContainingTypeOrTypeExtension(): TypeOrTypeExtension | undefined;
+    getSourceFile(): SourceFile;
+    getPackage(): PackageEntity;
+    getTryStatementContext(): TryStatementContextKind | undefined;
+    getLocalizationContext(): LocalizationContext;
+    isStatic(): boolean;
+    getOwnTypesOrContainersWithTypes(hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<TypeOrContainerWithTypes>[];
+    getOwnTypesOrContainersWithTypesByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<TypeOrContainerWithTypes>[];
+    getOwnNamedDeclarations(_noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
+    getOwnNamedDeclarationsByName(name: SearchName, _noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<NamedDeclaration>[];
+    getOwnTypeExtensionsByType(type: TypeEntity, hidingMatcher?: IEntityHidingMatcher): TypeExtensionEntity[];
+    private convertPackageMemberToNamedDeclaration;
+    private convertPackageAliasToTypeOrContainerWithTypes;
+    private convertPackageMemberToTypeOrContainerWithTypes;
+    private convertPackageAliasToNamedDeclaration;
+}

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

@@ -0,0 +1,23 @@
+import { LocalVariableEntity } from '../../entities/VariableEntity.js';
+import * as tree from '../../tree/index.js';
+import { Analyzer } from '../Analyzer.js';
+type SpecialLocalDeclarationEntity = LocalVariableEntity;
+export declare class SpecialLocalDeclarationsBuilder {
+    static buildForFunctionBlock(analyzer: Analyzer, node: tree.FunctionBlock): readonly SpecialLocalDeclarationEntity[];
+    static buildForFunctionBlockLiteral(analyzer: Analyzer, node: tree.FunctionBlockLiteral): readonly SpecialLocalDeclarationEntity[];
+    static buildForPackageFunctionDeclaration(analyzer: Analyzer, node: tree.PackageFunctionDeclaration): readonly SpecialLocalDeclarationEntity[];
+    static buildForFieldGetterDeclaration(analyzer: Analyzer, node: tree.FieldGetterDeclaration): readonly SpecialLocalDeclarationEntity[];
+    static buildForFieldSetterDeclaration(analyzer: Analyzer, node: tree.FieldSetterDeclaration): readonly SpecialLocalDeclarationEntity[];
+    static buildForPackageVariableGetterDeclaration(analyzer: Analyzer, node: tree.PackageVariableGetterDeclaration): readonly SpecialLocalDeclarationEntity[];
+    static buildForPackageVariableSetterDeclaration(analyzer: Analyzer, node: tree.PackageVariableSetterDeclaration): readonly SpecialLocalDeclarationEntity[];
+    static buildForIndexedElementGetterDeclaration(analyzer: Analyzer, node: tree.IndexedElementGetterDeclaration): readonly SpecialLocalDeclarationEntity[];
+    static buildForIndexedElementSetterDeclaration(analyzer: Analyzer, node: tree.IndexedElementSetterDeclaration): readonly SpecialLocalDeclarationEntity[];
+    static buildForDereferencedVariableGetterDeclaration(analyzer: Analyzer, node: tree.DereferencedVariableGetterDeclaration): readonly SpecialLocalDeclarationEntity[];
+    static buildForDereferencedVariableSetterDeclaration(analyzer: Analyzer, node: tree.DereferencedVariableSetterDeclaration): readonly SpecialLocalDeclarationEntity[];
+    static buildForNestedFunctionDeclaration(analyzer: Analyzer, node: tree.NestedFunctionDeclaration): readonly SpecialLocalDeclarationEntity[];
+    static buildForFunctionLiteral(analyzer: Analyzer, node: tree.FunctionLiteral): readonly SpecialLocalDeclarationEntity[];
+    static buildForConstructorDeclaration(analyzer: Analyzer, node: tree.ConstructorDeclaration): readonly SpecialLocalDeclarationEntity[];
+    static buildForMethodDeclaration(analyzer: Analyzer, node: tree.MethodDeclaration): readonly SpecialLocalDeclarationEntity[];
+    static buildForOperatorDeclaration(analyzer: Analyzer, node: tree.OperatorDeclaration): readonly SpecialLocalDeclarationEntity[];
+}
+export {};

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

@@ -0,0 +1,89 @@
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import * as tree from '../../tree/index.js';
+import { Analyzer } from '../Analyzer.js';
+import { SemanticContext } from './SemanticContext.js';
+import { TryStatementContextKind } from './SemanticContextBase.js';
+import { MemberOfSemanticContextValidatingNameConflicts, MemberOfSemanticContextValidatingNameConflictsForTypeLookup, SemanticContextValidatingNameConflictsBase } from './SemanticContextValidatingNameConflicts.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;
+    constructor(analyzer: Analyzer, node: tree.TypeParameterClause, outer: SubprogramTypeParameterSemanticContextParent);
+    validateNameConflicts(diagnostics: DiagnosticAcceptor): void;
+    protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
+    protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
+}
+export type SubprogramParameterSemanticContextParent = SubprogramTypeParameterSemanticContext | OutermostSemanticContextOfSubprogram;
+export declare abstract class SubprogramParameterSemanticContext extends SemanticContextValidatingNameConflictsBase {
+    readonly kind = "subprogram-parameter";
+    readonly outer: SubprogramParameterSemanticContextParent;
+    constructor(analyzer: Analyzer, outer: SubprogramParameterSemanticContextParent);
+}
+export declare class ExplicitSubprogramParameterSemanticContext extends SubprogramParameterSemanticContext {
+    readonly node: tree.ParameterList;
+    protected readonly asContext: SemanticContext;
+    constructor(analyzer: Analyzer, node: tree.ParameterList, outer: SubprogramParameterSemanticContextParent);
+    validateNameConflicts(diagnostics: DiagnosticAcceptor): void;
+    protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
+    protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
+}
+export declare class FunctionBlockLiteralParameterSemanticContext extends SubprogramParameterSemanticContext {
+    readonly node: tree.FunctionBlockLiteral;
+    protected readonly asContext: SemanticContext;
+    constructor(analyzer: Analyzer, node: tree.FunctionBlockLiteral, outer: SubprogramParameterSemanticContextParent);
+    protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
+    protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
+}
+export type BlockSemanticContext = StatementBlockSemanticContext | FunctionBlockSemanticContext;
+export type StatementBlockSemanticContextParent = StatementBlockSemanticContext | FunctionBlockSemanticContext | ForStatementSemanticContext | CatchClauseSemanticContext;
+export declare class StatementBlockSemanticContext extends SemanticContextValidatingNameConflictsBase {
+    readonly kind = "statement-block";
+    readonly outer: StatementBlockSemanticContextParent;
+    readonly node: tree.StatementBlock;
+    protected readonly asContext: SemanticContext;
+    constructor(analyzer: Analyzer, node: tree.StatementBlock, outer: StatementBlockSemanticContextParent);
+    getTryStatementContext(): TryStatementContextKind | undefined;
+    protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
+    protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
+}
+export type FunctionBlockSemanticContextParent = SubprogramParameterSemanticContext | OutermostSemanticContextOfSubprogram | SpecialLocalDeclarationSemanticContext;
+export declare class FunctionBlockSemanticContext extends SemanticContextValidatingNameConflictsBase {
+    readonly kind = "function-block";
+    readonly outer: FunctionBlockSemanticContextParent;
+    readonly node: tree.FunctionBlock;
+    protected readonly asContext: SemanticContext;
+    constructor(analyzer: Analyzer, node: tree.FunctionBlock, outer: FunctionBlockSemanticContextParent);
+    protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
+    protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
+}
+export type SpecialLocalDeclarationSemanticContextParent = SubprogramParameterSemanticContext | OutermostSemanticContextOfSubprogram;
+export declare class SpecialLocalDeclarationSemanticContext extends SemanticContextValidatingNameConflictsBase {
+    readonly kind = "special-local-declaration";
+    readonly outer: SpecialLocalDeclarationSemanticContextParent;
+    readonly node: tree.FunctionBlock;
+    protected readonly asContext: SemanticContext;
+    constructor(analyzer: Analyzer, node: tree.FunctionBlock, outer: SpecialLocalDeclarationSemanticContextParent);
+    protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
+    protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
+}
+export declare class ForStatementSemanticContext extends SemanticContextValidatingNameConflictsBase {
+    readonly kind = "for-statement";
+    readonly outer: BlockSemanticContext;
+    readonly node: tree.ForStatement;
+    protected readonly asContext: SemanticContext;
+    constructor(analyzer: Analyzer, node: tree.ForStatement, outer: BlockSemanticContext);
+    protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
+    protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
+}
+export declare class CatchClauseSemanticContext extends SemanticContextValidatingNameConflictsBase {
+    readonly kind = "catch-clause";
+    readonly outer: BlockSemanticContext;
+    readonly node: tree.CatchClause;
+    protected readonly asContext: SemanticContext;
+    constructor(analyzer: Analyzer, node: tree.CatchClause, outer: BlockSemanticContext);
+    protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
+    protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
+}

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

@@ -0,0 +1,114 @@
+import { SearchName } from '../../common/index.js';
+import { IEntityHidingMatcher } from '../../entities/EntityHiding.js';
+import * as tree from '../../tree/index.js';
+import { Analyzer } from '../Analyzer.js';
+import { FoundNamedDeclaration } from '../FoundDeclaration.js';
+import { DereferencedVariableAccessorDeclaration, FieldAccessorDeclaration, FunctionDeclaration, IndexedElementAccessorDeclaration, PackageVariableAccessorDeclaration, RegularOrBlockFunctionLiteral } from '../NodeTypeUtils.js';
+import { NamedDeclaration, TypeOrContainerWithTypes } from './Declarations.js';
+import { SemanticContext } from './SemanticContext.js';
+import { SubprogramInfo, TryStatementContextKind } from './SemanticContextBase.js';
+import { SemanticContextWithParent } from './SemanticContextWithParent.js';
+import { SourceFileSemanticContext } from './SourceFileSemanticContext.js';
+import { SemanticContextContainingTypeMember } from './TypeSemanticContext.js';
+export type LastSemanticContextOfSubprogramParent = SemanticContext;
+/**
+ * Завершающий семантический контекст подпрограммы.
+ * Данный контекст располагается после контекста с параметрами (или параметрами типа) и переопределяет метод
+ * {@link ISemanticContext.getContainingSubprogram}.
+ */
+export declare abstract class OutermostSemanticContextOfSubprogram extends SemanticContextWithParent {
+    readonly kind = "outermost-of-subprogram";
+    abstract getContainingSubprogram(): SubprogramInfo;
+    getTryStatementContext(): TryStatementContextKind | undefined;
+    getOwnTypesOrContainersWithTypes(_hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<TypeOrContainerWithTypes>[];
+    getOwnTypesOrContainersWithTypesByName(_name: SearchName, _hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<TypeOrContainerWithTypes>[];
+    getOwnNamedDeclarations(_noInstanceMembers?: boolean, _hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<NamedDeclaration>[];
+    getOwnNamedDeclarationsByName(_name: SearchName, _noInstanceMembers?: boolean, _hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<NamedDeclaration>[];
+}
+export declare class FunctionSemanticContext extends OutermostSemanticContextOfSubprogram {
+    readonly outer: SemanticContext;
+    protected readonly asContext: SemanticContext;
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _subprogramInfo;
+    constructor(analyzer: Analyzer, node: FunctionDeclaration, outer: SemanticContext);
+    getContainingSubprogram(): SubprogramInfo;
+    isStatic(): boolean;
+}
+export declare class PackageConstructorSemanticContext extends OutermostSemanticContextOfSubprogram {
+    readonly outer: SourceFileSemanticContext;
+    protected readonly asContext: SemanticContext;
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _subprogramInfo;
+    constructor(analyzer: Analyzer, node: tree.PackageConstructorDeclaration, outer: SourceFileSemanticContext);
+    getContainingSubprogram(): SubprogramInfo;
+}
+export declare class PackageEntryPointSemanticContext extends OutermostSemanticContextOfSubprogram {
+    readonly outer: SourceFileSemanticContext;
+    protected readonly asContext: SemanticContext;
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _subprogramInfo;
+    constructor(analyzer: Analyzer, node: tree.PackageEntryPointDeclaration, outer: SourceFileSemanticContext);
+    getContainingSubprogram(): SubprogramInfo;
+}
+export declare class OperatorSemanticContext extends OutermostSemanticContextOfSubprogram {
+    readonly outer: SemanticContextContainingTypeMember;
+    protected readonly asContext: SemanticContext;
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _subprogramInfo;
+    constructor(analyzer: Analyzer, node: tree.OperatorDeclaration, outer: SemanticContextContainingTypeMember);
+    getContainingSubprogram(): SubprogramInfo;
+    isStatic(): boolean;
+}
+export declare class ConstructorSemanticContext extends OutermostSemanticContextOfSubprogram {
+    readonly outer: SemanticContextContainingTypeMember;
+    protected readonly asContext: SemanticContext;
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _subprogramInfo;
+    constructor(analyzer: Analyzer, node: tree.ConstructorDeclaration, outer: SemanticContextContainingTypeMember);
+    getContainingSubprogram(): SubprogramInfo;
+}
+export declare class DestructorSemanticContext extends OutermostSemanticContextOfSubprogram {
+    readonly outer: SemanticContextContainingTypeMember;
+    protected readonly asContext: SemanticContext;
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _subprogramInfo;
+    constructor(analyzer: Analyzer, node: tree.DestructorDeclaration, outer: SemanticContextContainingTypeMember);
+    getContainingSubprogram(): SubprogramInfo;
+}
+export type AccessorSemanticContextParent = SemanticContextContainingTypeMember | SourceFileSemanticContext;
+export type VariableAccessorDeclaration = PackageVariableAccessorDeclaration | FieldAccessorDeclaration | DereferencedVariableAccessorDeclaration;
+export declare class VariableAccessorSemanticContext extends OutermostSemanticContextOfSubprogram {
+    readonly outer: AccessorSemanticContextParent;
+    protected readonly asContext: SemanticContext;
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _subprogramInfo;
+    constructor(analyzer: Analyzer, node: VariableAccessorDeclaration, outer: AccessorSemanticContextParent);
+    getContainingSubprogram(): SubprogramInfo;
+    isStatic(): boolean;
+}
+export declare class IndexedElementAccessorSemanticContext extends OutermostSemanticContextOfSubprogram {
+    readonly outer: AccessorSemanticContextParent;
+    protected readonly asContext: SemanticContext;
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _subprogramInfo;
+    constructor(analyzer: Analyzer, node: IndexedElementAccessorDeclaration, outer: AccessorSemanticContextParent);
+    getContainingSubprogram(): SubprogramInfo;
+    isStatic(): boolean;
+}
+export declare class FunctionLiteralSemanticContext extends OutermostSemanticContextOfSubprogram {
+    readonly outer: SemanticContext;
+    protected readonly asContext: SemanticContext;
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _subprogramInfo;
+    constructor(analyzer: Analyzer, node: RegularOrBlockFunctionLiteral, outer: SemanticContext);
+    getContainingSubprogram(): SubprogramInfo;
+}

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

@@ -0,0 +1,94 @@
+import { SearchName } from '../../common/index.js';
+import { IEntityHidingMatcher } from '../../entities/EntityHiding.js';
+import { OperatorKind } from '../../entities/index.js';
+import * as tree from '../../tree/index.js';
+import * as types from '../../types/index.js';
+import { Analyzer } from '../Analyzer.js';
+import { FoundAnonymousDeclaration, FoundNamedDeclaration } from '../FoundDeclaration.js';
+import { FunctionTypeDeclaration, StructuredTypeDeclaration, VariantTypeDeclaration } from '../NodeTypeUtils.js';
+import { TypeMemberLookup } from '../TypeMemberLookup.js';
+import { NamedDeclaration, TypeOrContainerWithTypes } from './Declarations.js';
+import { SemanticContext } from './SemanticContext.js';
+import { SubprogramInfo, TypeOrTypeExtension } from './SemanticContextBase.js';
+import { MemberOfSemanticContextValidatingNameConflicts, MemberOfSemanticContextValidatingNameConflictsForTypeLookup, SemanticContextValidatingNameConflictsBase } from './SemanticContextValidatingNameConflicts.js';
+import { SemanticContextWithParent } from './SemanticContextWithParent.js';
+import { SourceFileSemanticContext } from './SourceFileSemanticContext.js';
+export type TypeDeclarationCreatingSemanticContext = StructuredTypeDeclaration | VariantTypeDeclaration | FunctionTypeDeclaration | tree.PackageAliasTypeDeclaration;
+/**
+ * Завершающий семантический контекст типа.
+ * Поскольку контекст с параметрами типа является опциональным, необходим
+ * ещё один контекст, который гарантированно переопределит метод `getContainingTypeOrTypeExtension`.
+ */
+export declare class OutermostSemanticContextOfType extends SemanticContextWithParent {
+    readonly kind = "outermost-of-type";
+    readonly outer: SemanticContext;
+    protected readonly asContext: SemanticContext;
+    private readonly _analyzer;
+    private readonly _node;
+    constructor(analyzer: Analyzer, node: TypeDeclarationCreatingSemanticContext, outer: SemanticContext);
+    getContainingTypeOrTypeExtension(): TypeOrTypeExtension | undefined;
+    getContainingSubprogram(): SubprogramInfo | undefined;
+    isStatic(): boolean;
+    getOwnTypesOrContainersWithTypes(_hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<TypeOrContainerWithTypes>[];
+    getOwnTypesOrContainersWithTypesByName(_name: SearchName, _hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<TypeOrContainerWithTypes>[];
+    getOwnNamedDeclarations(_noInstanceMembers?: boolean, _hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<NamedDeclaration>[];
+    getOwnNamedDeclarationsByName(_name: SearchName, _noInstanceMembers?: boolean, _hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<NamedDeclaration>[];
+    private getContainingType;
+}
+type TypeDeclarationWithTypeParameters = tree.PackageStructuredTypeDeclaration | tree.PackageVariantTypeDeclaration | tree.PackageAliasTypeDeclaration | tree.PackageFunctionTypeDeclaration;
+export declare class TypeParametersOfTypeSemanticContext extends SemanticContextValidatingNameConflictsBase {
+    readonly kind = "type-parameter-of-type";
+    readonly outer: OutermostSemanticContextOfType;
+    readonly node: TypeDeclarationWithTypeParameters;
+    protected readonly asContext: SemanticContext;
+    private readonly _typeParameterClause;
+    constructor(analyzer: Analyzer, node: TypeDeclarationWithTypeParameters, typeParameterClause: tree.TypeParameterClause, outer: OutermostSemanticContextOfType);
+    protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
+    protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
+}
+declare abstract class TypeOrExtensionBodySemanticContext extends SemanticContextWithParent {
+    protected abstract memberLookup: TypeMemberLookup;
+    getOwnTypesOrContainersWithTypes(_hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<TypeOrContainerWithTypes>[];
+    getOwnTypesOrContainersWithTypesByName(_name: SearchName, _hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<TypeOrContainerWithTypes>[];
+    getOwnNamedDeclarations(noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
+    getOwnNamedDeclarationsByName(name: SearchName, noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<NamedDeclaration>[];
+    getOwnOperators(noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): readonly FoundAnonymousDeclaration<types.Operator>[];
+    getOwnOperatorsByKind(kind: OperatorKind, noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): readonly FoundAnonymousDeclaration<types.Operator>[];
+    private convertNamedMember;
+}
+export type TypeDeclarationWithMembersBody = tree.StructuredTypeDeclarationBody | tree.VariantTypeDeclarationBody | tree.AliasTypeDeclarationBody;
+export type SemanticContextContainingTypeMember = TypeBodySemanticContext | TypeExtensionBodySemanticContext;
+export type TypeBodySemanticContextParent = TypeParametersOfTypeSemanticContext | OutermostSemanticContextOfType;
+export declare class TypeBodySemanticContext extends TypeOrExtensionBodySemanticContext {
+    readonly kind = "type-body";
+    readonly outer: TypeBodySemanticContextParent;
+    protected readonly asContext: SemanticContext;
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _memberLookup;
+    protected get memberLookup(): TypeMemberLookup;
+    constructor(analyzer: Analyzer, node: TypeDeclarationWithMembersBody, outer: TypeBodySemanticContextParent);
+    private getTypeEntity;
+}
+export declare class TypeExtensionBodySemanticContext extends TypeOrExtensionBodySemanticContext {
+    readonly kind = "type-extension-body";
+    readonly outer: SourceFileSemanticContext;
+    protected readonly asContext: SemanticContext;
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _memberLookup;
+    protected get memberLookup(): TypeMemberLookup;
+    constructor(analyzer: Analyzer, node: tree.TypeExtensionDeclaration, outer: SourceFileSemanticContext);
+    getContainingTypeOrTypeExtension(): TypeOrTypeExtension | undefined;
+}
+export type ParameterOfFunctionTypeSemanticContextParent = TypeParametersOfTypeSemanticContext | OutermostSemanticContextOfType;
+export declare class ParametersOfFunctionTypeSemanticContext extends SemanticContextValidatingNameConflictsBase {
+    readonly kind = "parameters-of-function-type";
+    readonly outer: ParameterOfFunctionTypeSemanticContextParent;
+    readonly node: tree.FunctionTypeDeclarationBody;
+    protected readonly asContext: SemanticContext;
+    constructor(analyzer: Analyzer, node: tree.FunctionTypeDeclarationBody, outer: ParameterOfFunctionTypeSemanticContextParent);
+    protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
+    protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
+}
+export {};

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

@@ -0,0 +1,10 @@
+export * from './Declarations.js';
+export * from './FieldWithInitializerSemanticContext.js';
+export * from './SemanticContext.js';
+export * from './SemanticContextBase.js';
+export * from './SemanticContextBuilder.js';
+export * from './SemanticContextValidatingNameConflicts.js';
+export * from './SourceFileSemanticContext.js';
+export * from './SubprogramBodyAndParametersSemanticContext.js';
+export * from './SubprogramSemanticContext.js';
+export * from './TypeSemanticContext.js';

package/build/types/api/Api.d.ts

@@ -1,9 +1,9 @@
 export * from '../analysis/AccessedFunction.js';
 export * from '../analysis/AnalyzedTranslationPackage.js';
 export * from '../analysis/Analyzer.js';
+export { MatchResult, MatchResultValueParameter } from '../analysis/ArgumentToParameterMatchResult.js';
 export type { Meaning as AutotypeCallExpressionMeaning } from '../analysis/AutotypeCallExpressionMeaning.js';
 export type { Meaning as BaseExpressionMeaning } from '../analysis/BaseExpressionMeaning.js';
-export { MatchResult, MatchResultValueParameter } from '../analysis/ArgumentToParameterMatchResult.js';
 export type { Meaning as CallExpressionMeaning } from '../analysis/CallExpressionMeaning.js';
 export type { Meaning as DereferenceExpressionMeaning } from '../analysis/DereferenceExpressionMeaning.js';
 export * from '../analysis/DiagnosticCollector.js';
@@ -15,13 +15,11 @@ export * from '../analysis/ImportedPackageNameTree.js';
 export type { Meaning as IndexedAccessExpressionMeaning } from '../analysis/IndexedAccessExpressionMeaning.js';
 export * from '../analysis/Localization.js';
 export * from '../analysis/LocalizationContext.js';
-export * from '../analysis/Lookup.js';
+export type { Meaning as MemberAccessExpressionMeaning, ResolutionResult as MemberAccessExpressionResolutionResult } from '../analysis/MemberAccessExpressionMeaning.js';
 export * from '../analysis/NodeTypeUtils.js';
 export type { Meaning as ObjectExpressionMeaning } from '../analysis/ObjectExpressionMeaning.js';
 export * from '../analysis/PackageMemberLookup.js';
-export type { Meaning as MemberAccessExpressionMeaning, ResolutionResult as MemberAccessExpressionResolutionResult } from '../analysis/MemberAccessExpressionMeaning.js';
-export type { IScope, NamedDeclaration, TypeOrContainerWithTypes } from '../analysis/Scope.js';
-export * from '../analysis/SemanticContext.js';
+export * as semanticContext from '../analysis/semantic-context/index.js';
 export * from '../analysis/SourceFileMembers.js';
 export * from '../analysis/SourcePackageDependencyGraph.js';
 export * from '../analysis/SubstitutedFunction.js';

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

@@ -4,4 +4,5 @@ export declare class Cached<T> {
     private _isEvaluating;
     getOrInsertWith(fn: () => T): T;
     clear(): void;
+    getCachedValue(): T | undefined;
 }

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

@@ -0,0 +1,2 @@
+export declare class RecursiveAnalysisError extends Error {
+}

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

@@ -7,3 +7,7 @@ export declare class Lazy<T> {
     get value(): T;
     getCachedValue(): T | undefined;
 }
+export type MaybeLazy<T> = Lazy<T> | T;
+export declare namespace MaybeLazy {
+    function getValue<T>(maybeLazy: MaybeLazy<T>): T;
+}

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

@@ -1,3 +1,4 @@
+import { MaybeLazy } from './Lazy.js';
 export declare abstract class Query<T> implements Iterable<T> {
     static from<T>(source: Iterable<T>): Query<T>;
     static fromNullable<T>(source: Iterable<T> | undefined): Query<T>;
@@ -15,7 +16,7 @@ export declare abstract class Query<T> implements Iterable<T> {
     flatMap<K>(fn: (t: T) => Iterable<K>): Query<K>;
     toArray(): T[];
     count(fn?: (t: T) => boolean): number;
-    chain(other: Iterable<T>): Query<T>;
+    chain(other: MaybeLazy<Iterable<T>>): Query<T>;
     filter<K extends T>(fn: (t: T) => t is K): Query<K>;
     filter(fn: (t: T) => boolean): Query<T>;
     mapAndFilter<K>(fn: (t: T) => K | undefined): Query<K>;

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

@@ -1,4 +1,5 @@
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
+import { MaybeLazy } from './Lazy.js';
 export type WithDiagnostics<T> = WithDiagnostics_ok<T> | WithDiagnostics_error<T>;
 export declare class WithDiagnostics_ok<T> implements IWithDiagnostics<T> {
     readonly value: T;
@@ -8,9 +9,9 @@ export declare class WithDiagnostics_ok<T> implements IWithDiagnostics<T> {
 }
 export declare class WithDiagnostics_error<T> implements IWithDiagnostics<T> {
     readonly kind = "error";
-    readonly value: readonly Diagnostic[];
-    constructor(diagnostic: Diagnostic);
-    constructor(diagnostics: readonly Diagnostic[]);
+    readonly value: readonly MaybeLazy<Diagnostic>[];
+    constructor(diagnostic: MaybeLazy<Diagnostic>);
+    constructor(diagnostics: readonly MaybeLazy<Diagnostic>[]);
     toNullable(): T | undefined;
 }
 interface IWithDiagnostics<T> {

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

@@ -5,6 +5,7 @@ export * from './CancellationToken.js';
 export * from './Constants.js';
 export * from './Debug.js';
 export * from './Delayed.js';
+export * from './Errors.js';
 export * from './FormatString.js';
 export * from './Interner.js';
 export * from './JavaScriptIdentifier.js';