@artel/artc 0.6.25225 → 0.6.25227

package/build/types/analysis/control-flow/NarrowableReference.d.ts

@@ -0,0 +1,73 @@
+import { LocalVariableEntity, PackageVariableEntity, ParameterVariableEntity } from '../../entities/VariableEntity.js';
+import * as tree from '../../tree/index.js';
+import * as types from '../../types/index.js';
+import { Analyzer } from '../Analyzer.js';
+import { NarrowableReferenceExpression } from '../control-flow/NarrowableExpression.js';
+export type NarrowableReference = NarrowableReference.LocalVariable | NarrowableReference.PackageVariable | NarrowableReference.InstanceField | NarrowableReference.StaticField | NarrowableReference.ObjectAutoVariable;
+export declare namespace NarrowableReference {
+    export class LocalVariable implements INarrowableReference {
+        private readonly _analyzer;
+        readonly entity: LocalVariableEntity | ParameterVariableEntity;
+        readonly kind = "local-variable";
+        constructor(_analyzer: Analyzer, entity: LocalVariableEntity | ParameterVariableEntity);
+        equals(other: NarrowableReference): boolean;
+        contains(_other: NarrowableReference): boolean;
+        equalsExpression(expression: NarrowableReferenceExpression): boolean;
+        containsExpression(_expression: NarrowableReferenceExpression): boolean;
+    }
+    export class PackageVariable implements INarrowableReference {
+        private readonly _analyzer;
+        readonly entity: PackageVariableEntity;
+        readonly kind = "package-variable";
+        constructor(_analyzer: Analyzer, entity: PackageVariableEntity);
+        equals(other: NarrowableReference): boolean;
+        contains(_other: NarrowableReference): boolean;
+        equalsExpression(expression: NarrowableReferenceExpression): boolean;
+        containsExpression(_expression: NarrowableReferenceExpression): boolean;
+    }
+    export class InstanceField implements INarrowableReference {
+        private readonly _analyzer;
+        readonly variable: types.Variable;
+        readonly receiver: NarrowableReference;
+        readonly kind = "instance-field";
+        constructor(_analyzer: Analyzer, variable: types.Variable, receiver: NarrowableReference);
+        equals(other: NarrowableReference): boolean;
+        contains(other: NarrowableReference): boolean;
+        equalsExpression(expression: NarrowableReferenceExpression): boolean;
+        containsExpression(expression: NarrowableReferenceExpression): boolean;
+    }
+    export class StaticField implements INarrowableReference {
+        private readonly _analyzer;
+        readonly variable: types.Variable;
+        readonly kind = "static-field";
+        constructor(_analyzer: Analyzer, variable: types.Variable);
+        equals(other: NarrowableReference): boolean;
+        contains(_other: NarrowableReference): boolean;
+        equalsExpression(expression: NarrowableReferenceExpression): boolean;
+        containsExpression(_expression: NarrowableReferenceExpression): boolean;
+    }
+    export class ObjectAutoVariable implements INarrowableReference {
+        readonly kind = "object-auto-variable";
+        equals(other: NarrowableReference): boolean;
+        contains(_other: NarrowableReference): boolean;
+        equalsExpression(expression: NarrowableReferenceExpression): boolean;
+        containsExpression(_expression: NarrowableReferenceExpression): boolean;
+    }
+    interface INarrowableReference {
+        equals(other: NarrowableReference): boolean;
+        contains(other: NarrowableReference): boolean;
+        /**
+         * Отличается от метода `equals` тем, что выполняет сравнение лениво. Например, при сравнении с выражением
+         * `а.б` сперва будут сравнены части слева от точки (выражение `а` с `receiver`), и только при равенстве будет
+         * связано и сравнено имя `б`. Если выражение `а` не равно `receiver`, то сразу будет возвращено `false` и
+         * связывание для имени `б` выполняться не будет. Такое поведение необходимо при анализе циклов,
+         * чтобы избежать рекурсии.
+         */
+        equalsExpression(expression: NarrowableReferenceExpression): boolean;
+        containsExpression(expression: NarrowableReferenceExpression): boolean;
+    }
+    export {};
+}
+export declare function getReferenceAtNarrowableExpression(analyzer: Analyzer, node: NarrowableReferenceExpression): NarrowableReference | undefined;
+export declare function getReferenceAtExpressionIfNarrowable(analyzer: Analyzer, node: tree.Expression): NarrowableReference | undefined;
+export declare function getNarrowableReferenceAtLocalVariableDeclaration(analyzer: Analyzer, node: tree.LocalVariableDeclaration): NarrowableReference;

package/build/types/analysis/control-flow/Nodes.d.ts

@@ -74,7 +74,16 @@ export declare abstract class LoopNode extends ControlFlowNodeBase {
     readonly kind = "loop";
     get debuggerDisplay(): string;
     protected get thisAsNode(): Node;
+    /**
+     * Предшествующий узел, не образующий цикл в графе потока управления. Любой цикл имеет ровно один такой узел.
+     */
     abstract predecessor: Node;
+    /**
+     * Предшествующие узлы, образующие цикл в графе управление. В простейшем случае имеет один элемент, поскольку
+     * управление в конце цикла возвращается в его начало (т.е. началу цикла предшествует его конец). Может иметь
+     * несколько элементов, если в теле цикла используются инструкции `следующий цикл`, или не иметь ни одного элемента,
+     * если это бесконечный цикл, содержащий инструкцию `прервать цикл`, или любую другую, прерывающую поток управления.
+     */
     abstract loopingPredecessors: readonly Node[];
 }
 /**

package/build/types/analysis/control-flow/index.d.ts

@@ -1,4 +1,5 @@
 export * from './GraphBuilder.js';
 export * from './GraphVisualizer.js';
 export * from './NarrowableExpression.js';
+export * from './NarrowableReference.js';
 export * from './Nodes.js';

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

@@ -0,0 +1,117 @@
+import { Name } from '../../common/index.js';
+import { EntityHidingLevel, FunctionEntity, NamedTypeEntity, PackageAliasEntity, VariableEntity } from '../../entities/index.js';
+import * as types from '../../types/index.js';
+import { PackageNameTreeNode } from '../ImportedPackageNameTree.js';
+export type TypeOrContainerWithTypes = NamedDeclaration_type | NamedDeclaration_packageAlias | NamedDeclaration_packageNameSegment;
+export type NamedDeclaration = NamedDeclaration_function | NamedDeclaration_variable | NamedDeclaration_type | NamedDeclaration_packageAlias | NamedDeclaration_packageNameSegment;
+export declare class NamedDeclaration_function implements INamedDeclaration {
+    readonly value: NamedDeclarationFunction;
+    readonly kind = "function";
+    constructor(value: NamedDeclarationFunction);
+    getName(): Name;
+    isHidden(): EntityHidingLevel | undefined;
+}
+export type NamedDeclarationFunction = NamedDeclarationFunction_entity | NamedDeclarationFunction_typeMember;
+export declare class NamedDeclarationFunction_entity implements INamedDeclarationFunction {
+    readonly kind = "entity";
+    private readonly _valueParameters;
+    readonly value: FunctionEntity;
+    constructor(value: FunctionEntity);
+    getName(): Name;
+    getEntity(): FunctionEntity;
+    getTypeParameterArity(): number;
+    isHidden(): EntityHidingLevel | undefined;
+    getValueParameters(): readonly ValueParameter[];
+}
+export declare class NamedDeclarationFunction_typeMember implements INamedDeclarationFunction {
+    readonly kind = "type-member";
+    private readonly _valueParameters;
+    readonly value: types.Method;
+    constructor(value: types.Method);
+    getName(): Name;
+    getEntity(): FunctionEntity;
+    getTypeParameterArity(): number;
+    isHidden(): EntityHidingLevel | undefined;
+    getValueParameters(): readonly ValueParameter[];
+}
+interface INamedDeclarationFunction {
+    getName(): Name;
+    getEntity(): FunctionEntity;
+    getTypeParameterArity(): number;
+    isHidden(): EntityHidingLevel | undefined;
+    getValueParameters(): readonly ValueParameter[];
+}
+export type ValueParameter = ValueParameter_entity | ValueParameter_typeMember;
+export declare class ValueParameter_entity implements IValueParameter {
+    readonly value: VariableEntity;
+    readonly kind = "entity";
+    constructor(value: VariableEntity);
+    getName(): Name;
+    getType(): types.Type;
+}
+export declare class ValueParameter_typeMember implements IValueParameter {
+    readonly value: types.ValueParameter;
+    readonly kind = "type-member";
+    constructor(value: types.ValueParameter);
+    getName(): Name;
+    getType(): types.Type;
+}
+interface IValueParameter {
+    getName(): Name;
+    getType(): types.Type;
+}
+export declare class NamedDeclaration_variable implements INamedDeclaration {
+    readonly value: NamedDeclarationVariable;
+    readonly kind = "variable";
+    constructor(value: NamedDeclarationVariable);
+    getName(): Name;
+    isHidden(): EntityHidingLevel | undefined;
+}
+export type NamedDeclarationVariable = NamedDeclarationVariable_entity | NamedDeclarationVariable_typeMember;
+export declare class NamedDeclarationVariable_entity implements INamedDeclarationVariable {
+    readonly value: VariableEntity;
+    readonly kind = "entity";
+    constructor(value: VariableEntity);
+    getName(): Name;
+    getEntity(): VariableEntity;
+    isHidden(): EntityHidingLevel | undefined;
+}
+export declare class NamedDeclarationVariable_typeMember implements INamedDeclarationVariable {
+    readonly value: types.Variable;
+    readonly kind = "type-member";
+    constructor(value: types.Variable);
+    getName(): Name;
+    getEntity(): VariableEntity;
+    isHidden(): EntityHidingLevel | undefined;
+}
+interface INamedDeclarationVariable {
+    getName(): Name;
+    getEntity(): VariableEntity;
+    isHidden(): EntityHidingLevel | undefined;
+}
+export declare class NamedDeclaration_type implements INamedDeclaration {
+    readonly value: NamedTypeEntity;
+    readonly kind = "type";
+    constructor(value: NamedTypeEntity);
+    getName(): Name;
+    isHidden(): EntityHidingLevel | undefined;
+}
+export declare class NamedDeclaration_packageAlias implements INamedDeclaration {
+    readonly value: PackageAliasEntity;
+    readonly kind = "package-alias";
+    constructor(value: PackageAliasEntity);
+    getName(): Name;
+    isHidden(): EntityHidingLevel | undefined;
+}
+export declare class NamedDeclaration_packageNameSegment implements INamedDeclaration {
+    readonly value: PackageNameTreeNode;
+    readonly kind = "package-name-segment";
+    constructor(value: PackageNameTreeNode);
+    getName(): Name;
+    isHidden(): EntityHidingLevel | undefined;
+}
+interface INamedDeclaration {
+    getName(): Name;
+    isHidden(): EntityHidingLevel | undefined;
+}
+export {};

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

@@ -0,0 +1,22 @@
+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 { NamedDeclaration, TypeOrContainerWithTypes } from './Declarations.js';
+import { SemanticContext } from './SemanticContext.js';
+import { SemanticContextWithParent } from './SemanticContextWithParent.js';
+import { SemanticContextContainingTypeMember } from './TypeSemanticContext.js';
+export declare class FieldWithInitializerSemanticContext extends SemanticContextWithParent {
+    readonly kind = "field-initializer";
+    readonly outer: SemanticContextContainingTypeMember;
+    protected readonly asContext: SemanticContext;
+    private readonly _analyzer;
+    private readonly _node;
+    constructor(analyzer: Analyzer, node: tree.FieldDeclaration, outer: SemanticContextContainingTypeMember);
+    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>[];
+}

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

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

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

@@ -0,0 +1,168 @@
+import { SearchName } from '../../common/SearchName.js';
+import { IEntityHidingMatcher } from '../../entities/EntityHiding.js';
+import { ConstructorEntity, OperatorKind, PackageEntity, TypeEntity, TypeEntityWithMembers, TypeExtensionEntity } from '../../entities/index.js';
+import { SourceFile } from '../../project/SourceFile.js';
+import * as tree from '../../tree/index.js';
+import * as types from '../../types/index.js';
+import { Analyzer } from '../Analyzer.js';
+import { FoundAnonymousDeclaration, FoundNamedDeclaration } from '../FoundDeclaration.js';
+import { LocalizationContext } from '../LocalizationContext.js';
+import { FunctionDeclaration, GetterDeclaration, RegularOrBlockFunctionLiteral, SetterDeclaration, SubprogramDeclarationOrLiteral } from '../NodeTypeUtils.js';
+import { NamedDeclaration, TypeOrContainerWithTypes } from './Declarations.js';
+import { SemanticContext } from './SemanticContext.js';
+export declare abstract class SemanticContextBase {
+    abstract readonly outer: SemanticContext | undefined;
+    protected abstract readonly asContext: SemanticContext;
+    abstract getContainingSubprogram(): SubprogramInfo | undefined;
+    abstract getContainingTypeOrTypeExtension(): TypeOrTypeExtension | undefined;
+    abstract getTryStatementContext(): TryStatementContextKind | undefined;
+    abstract isStatic(): boolean;
+    abstract getOwnTypesOrContainersWithTypes(hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<TypeOrContainerWithTypes>[];
+    abstract getOwnTypesOrContainersWithTypesByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<TypeOrContainerWithTypes>[];
+    abstract getOwnNamedDeclarations(noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<NamedDeclaration>[];
+    abstract getOwnNamedDeclarationsByName(name: SearchName, noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<NamedDeclaration>[];
+    getLocalizationContext(): LocalizationContext;
+    getContainingSourceFile(): SourceFile;
+    getContainingPackage(): PackageEntity;
+    getHidingMatcher(): IEntityHidingMatcher;
+    getTypesOrContainersWithTypes(): readonly FoundNamedDeclaration<TypeOrContainerWithTypes>[];
+    getTypesOrContainersWithTypesByName(name: SearchName): readonly FoundNamedDeclaration<TypeOrContainerWithTypes>[];
+    getNamedDeclarations(noInstanceMembers?: boolean): readonly FoundNamedDeclaration<NamedDeclaration>[];
+    getNamedDeclarationsByName(name: SearchName, noInstanceMembers?: boolean): readonly FoundNamedDeclaration<NamedDeclaration>[];
+    getOperators(noInstanceMembers?: boolean): readonly FoundAnonymousDeclaration<types.Operator>[];
+    getOperatorsByKind(kind: OperatorKind, noInstanceMembers?: boolean): readonly FoundAnonymousDeclaration<types.Operator>[];
+    getTypeExtensionsByType(type: TypeEntity): readonly TypeExtensionEntity[];
+    private enumerateSemanticContexts;
+    private getSourceFileContext;
+}
+export type SubprogramInfo = SubprogramInfo.Function | SubprogramInfo.Operator | SubprogramInfo.Constructor | SubprogramInfo.Destructor | SubprogramInfo.Getter | SubprogramInfo.Setter | SubprogramInfo.PackageConstructor | SubprogramInfo.PackageEntryPoint | SubprogramInfo.FunctionLiteral;
+export declare namespace SubprogramInfo {
+    export class Function implements ISubprogramInfo {
+        readonly kind = "function";
+        private readonly _analyzer;
+        private readonly _node;
+        constructor(analyzer: Analyzer, node: FunctionDeclaration);
+        getReturnType(): types.Type | undefined;
+        isGenerator(): boolean;
+        allowsAsyncCalls(): boolean;
+        getNode(): FunctionDeclaration;
+        private getEntity;
+    }
+    export class Operator implements ISubprogramInfo {
+        readonly kind = "operator";
+        private readonly _analyzer;
+        private readonly _node;
+        constructor(analyzer: Analyzer, node: tree.OperatorDeclaration);
+        getReturnType(): types.Type | undefined;
+        isGenerator(): boolean;
+        allowsAsyncCalls(): boolean;
+        getNode(): tree.OperatorDeclaration;
+    }
+    export class Constructor implements ISubprogramInfo {
+        readonly kind = "constructor";
+        private readonly _analyzer;
+        private readonly _node;
+        constructor(analyzer: Analyzer, node: tree.ConstructorDeclaration);
+        getReturnType(): types.Type | undefined;
+        isGenerator(): boolean;
+        allowsAsyncCalls(): boolean;
+        getEntity(): ConstructorEntity;
+        getNode(): tree.ConstructorDeclaration;
+    }
+    export class Destructor implements ISubprogramInfo {
+        readonly kind = "destructor";
+        private readonly _analyzer;
+        private readonly _node;
+        constructor(analyzer: Analyzer, node: tree.DestructorDeclaration);
+        getReturnType(): types.Type | undefined;
+        isGenerator(): boolean;
+        allowsAsyncCalls(): boolean;
+        getNode(): tree.DestructorDeclaration;
+    }
+    export class Getter implements ISubprogramInfo {
+        readonly kind = "getter";
+        private readonly _analyzer;
+        private readonly _node;
+        constructor(analyzer: Analyzer, node: GetterDeclaration);
+        getReturnType(): types.Type | undefined;
+        isGenerator(): boolean;
+        allowsAsyncCalls(): boolean;
+        getNode(): GetterDeclaration;
+    }
+    export class Setter implements ISubprogramInfo {
+        readonly kind = "setter";
+        private readonly _analyzer;
+        private readonly _node;
+        constructor(analyzer: Analyzer, node: SetterDeclaration);
+        getReturnType(): types.Type | undefined;
+        isGenerator(): boolean;
+        allowsAsyncCalls(): boolean;
+        getNode(): SetterDeclaration;
+    }
+    export class PackageConstructor implements ISubprogramInfo {
+        readonly kind = "package-constructor";
+        private readonly _analyzer;
+        private readonly _node;
+        constructor(analyzer: Analyzer, node: tree.PackageConstructorDeclaration);
+        getReturnType(): types.Type | undefined;
+        isGenerator(): boolean;
+        allowsAsyncCalls(): boolean;
+        getPackageEntity(): PackageEntity;
+        getNode(): tree.PackageConstructorDeclaration;
+    }
+    export class PackageEntryPoint implements ISubprogramInfo {
+        readonly kind = "package-entry-point";
+        private readonly _analyzer;
+        private readonly _node;
+        constructor(analyzer: Analyzer, node: tree.PackageEntryPointDeclaration);
+        getReturnType(): types.Type | undefined;
+        isGenerator(): boolean;
+        allowsAsyncCalls(): boolean;
+        getPackageEntity(): PackageEntity;
+        getNode(): tree.PackageEntryPointDeclaration;
+    }
+    export class FunctionLiteral implements ISubprogramInfo {
+        readonly kind = "function-literal";
+        private readonly _analyzer;
+        private readonly _node;
+        constructor(analyzer: Analyzer, node: RegularOrBlockFunctionLiteral);
+        getReturnType(): types.Type | undefined;
+        isGenerator(): boolean;
+        allowsAsyncCalls(): boolean;
+        getNode(): RegularOrBlockFunctionLiteral;
+        private getSignatureType;
+    }
+    interface ISubprogramInfo {
+        getReturnType(): types.Type | undefined;
+        isGenerator(): boolean;
+        allowsAsyncCalls(): boolean;
+        getNode(): SubprogramDeclarationOrLiteral;
+    }
+    export {};
+}
+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 declare enum TryStatementContextKind {
+    InTryBlockWithCatchClause = 0,
+    InFinallyBlock = 1
+}

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

@@ -0,0 +1,14 @@
+import { EntityHidingLevel, IEntityHidingMatcher } from '../../entities/EntityHiding.js';
+import { SemanticContext } from './SemanticContext.js';
+export declare class SemanticContextBasedEntityHidingMatcher implements IEntityHidingMatcher {
+    private readonly _semanticContext;
+    private readonly _sourceFile;
+    private readonly _type;
+    private readonly _package;
+    private get sourceFile();
+    private get package();
+    private get type();
+    constructor(semanticContext: SemanticContext);
+    matches(hiding: EntityHidingLevel): boolean;
+    private collectBaseTypesRecursively;
+}

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,124 @@
+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 { TryStatementContextKind } from './SemanticContextBase.js';
+import { SemanticContextWithParent } from './SemanticContextWithParent.js';
+import { OutermostSemanticContextOfSubprogram } from './SubprogramSemanticContext.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;
+    getMemberEntityDictionary(): ReadonlyMap<string, readonly MemberOfSemanticContextValidatingNameConflicts[]>;
+    private validateNestedFunctionsConflicts;
+    private areNestedFunctionSignaturesEqual;
+    private createNamedDeclarations;
+    private createTypesOrContainerWithTypes;
+}
+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 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[];
+}
+export type SemanticContextValidatingNameConflicts = StatementBlockSemanticContext | ForStatementSemanticContext | CatchClauseSemanticContext | SpecialLocalDeclarationSemanticContext | SubprogramParameterSemanticContext | SubprogramTypeParameterSemanticContext;
+interface ISemanticContextValidatingNameConflicts {
+    validateNameConflicts(diagnostics: DiagnosticAcceptor): void;
+    getMemberEntityDictionary(): ReadonlyMap<string, readonly MemberOfSemanticContextValidatingNameConflicts[]>;
+}
+export type MemberOfSemanticContextValidatingNameConflicts = LocalVariableEntity | ParameterVariableEntity | NestedFunctionEntity | TypeParameterEntity;
+export type MemberOfSemanticContextValidatingNameConflictsForTypeLookup = TypeParameterEntity;
+export {};