@artel/artc 0.6.25226 → 0.6.25228

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

@@ -4,7 +4,7 @@ import * as types from '../types/index.js';
 import { Analyzer } from './Analyzer.js';
 import { FoundAnonymousDeclaration, FoundNamedDeclaration } from './FoundDeclaration.js';
 import { LocalizationContext } from './LocalizationContext.js';
-import { Lookup } from './Lookup.js';
+import { SemanticContext } from './semantic-context/SemanticContext.js';
 export declare class TypeMemberLookup {
     private readonly _analyzer;
     private readonly _typeOrExtension;
@@ -19,13 +19,13 @@ export declare class TypeMemberLookup {
     static ofTypeEntity(analyzer: Analyzer, entity: TypeEntity, localizationContext: LocalizationContext | undefined): TypeMemberLookup;
     static ofTypeExtension(analyzer: Analyzer, typeExtension: TypeExtensionEntity, localizationContext: LocalizationContext | undefined): TypeMemberLookup;
     static ofTypeOrExtension(analyzer: Analyzer, typeOrExtension: TypeOrExtension, localizationContext: LocalizationContext | undefined): TypeMemberLookup;
-    getNamedMembers(options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionsLookup?: Lookup): readonly FoundNamedDeclaration<types.NamedTypeMember>[];
-    getNamedMembersByName(name: SearchName, options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionsLookup?: Lookup): readonly FoundNamedDeclaration<types.NamedTypeMember>[];
-    getOperators(options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionsLookup?: Lookup): readonly FoundAnonymousDeclaration<types.Operator>[];
-    getOperatorsByKind(kind: OperatorKind, options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionsLookup?: Lookup): readonly FoundAnonymousDeclaration<types.Operator>[];
-    getConstructors(hidingMatcher?: IEntityHidingMatcher, typeExtensionsLookup?: Lookup): readonly FoundAnonymousDeclaration<types.Constructor>[];
-    getIndexers(options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionsLookup?: Lookup): readonly FoundAnonymousDeclaration<types.Indexer>[];
-    getDereferenceOperators(options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionsLookup?: Lookup): readonly FoundAnonymousDeclaration<types.DereferenceOperator>[];
+    getNamedMembers(options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionLookup?: SemanticContext): readonly FoundNamedDeclaration<types.NamedTypeMember>[];
+    getNamedMembersByName(name: SearchName, options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionLookup?: SemanticContext): readonly FoundNamedDeclaration<types.NamedTypeMember>[];
+    getOperators(options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionLookup?: SemanticContext): readonly FoundAnonymousDeclaration<types.Operator>[];
+    getOperatorsByKind(kind: OperatorKind, options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionLookup?: SemanticContext): readonly FoundAnonymousDeclaration<types.Operator>[];
+    getConstructors(hidingMatcher?: IEntityHidingMatcher, typeExtensionLookup?: SemanticContext): readonly FoundAnonymousDeclaration<types.Constructor>[];
+    getIndexers(options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionLookup?: SemanticContext): readonly FoundAnonymousDeclaration<types.Indexer>[];
+    getDereferenceOperators(options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionLookup?: SemanticContext): readonly FoundAnonymousDeclaration<types.DereferenceOperator>[];
     private getLocaleOfTypeEntity;
 }
 export declare class BoundTypeMemberLookup {
@@ -34,9 +34,9 @@ export declare class BoundTypeMemberLookup {
     private readonly _hidingMatcher;
     private readonly _typeExtensionLookup;
     private constructor();
-    static ofType(analyzer: Analyzer, type: types.Type, localizationContext: LocalizationContext | undefined, options: TypeMemberLookupOptions | undefined, hidingMatcher: IEntityHidingMatcher | undefined, typeExtensionLookup: Lookup | undefined): BoundTypeMemberLookup;
-    static ofTypeEntity(analyzer: Analyzer, entity: TypeEntity, localizationContext: LocalizationContext | undefined, options: TypeMemberLookupOptions | undefined, hidingMatcher: IEntityHidingMatcher | undefined, typeExtensionLookup: Lookup | undefined): BoundTypeMemberLookup;
-    static ofTypeExtension(analyzer: Analyzer, typeExtension: TypeExtensionEntity, localizationContext: LocalizationContext | undefined, options: TypeMemberLookupOptions | undefined, hidingMatcher: IEntityHidingMatcher | undefined, typeExtensionLookup: Lookup | undefined): BoundTypeMemberLookup;
+    static ofType(analyzer: Analyzer, type: types.Type, localizationContext: LocalizationContext | undefined, options: TypeMemberLookupOptions | undefined, hidingMatcher: IEntityHidingMatcher | undefined, typeExtensionLookup: SemanticContext | undefined): BoundTypeMemberLookup;
+    static ofTypeEntity(analyzer: Analyzer, entity: TypeEntity, localizationContext: LocalizationContext | undefined, options: TypeMemberLookupOptions | undefined, hidingMatcher: IEntityHidingMatcher | undefined, typeExtensionLookup: SemanticContext | undefined): BoundTypeMemberLookup;
+    static ofTypeExtension(analyzer: Analyzer, typeExtension: TypeExtensionEntity, localizationContext: LocalizationContext | undefined, options: TypeMemberLookupOptions | undefined, hidingMatcher: IEntityHidingMatcher | undefined, typeExtensionLookup: SemanticContext | undefined): BoundTypeMemberLookup;
     getNamedMembers(): readonly FoundNamedDeclaration<types.NamedTypeMember>[];
     getNamedMembersByName(name: SearchName): readonly FoundNamedDeclaration<types.NamedTypeMember>[];
     getOperators(): readonly FoundAnonymousDeclaration<types.Operator>[];

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

@@ -1,4 +1,3 @@
-import { LocalVariableEntity, PackageVariableEntity, ParameterVariableEntity } from '../entities/VariableEntity.js';
 import * as types from '../types/index.js';
 import { Analyzer } from './Analyzer.js';
 import * as controlFlow from './control-flow/index.js';
@@ -26,72 +25,4 @@ export declare class TypeNarrower {
     private checkIfVariableIsAssignedInLoop;
     private checkIfVariableIsAssignedAtNode;
     private isSameReferenceAsNarrowedExpression;
-    private getReferenceAtNodeIfNarrowable;
-    private getReferenceAtNode;
-    private getReferenceAtLocalVariableDeclaration;
-}
-export type NarrowableReference = NarrowableReference.LocalVariable | NarrowableReference.PackageVariable | NarrowableReference.ObjectField | 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: controlFlow.NarrowableReferenceExpression): boolean;
-        containsExpression(_expression: controlFlow.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: controlFlow.NarrowableReferenceExpression): boolean;
-        containsExpression(_expression: controlFlow.NarrowableReferenceExpression): boolean;
-    }
-    export class ObjectField implements INarrowableReference {
-        private readonly _analyzer;
-        readonly variable: types.Variable;
-        readonly receiver: NarrowableReference;
-        readonly kind = "object-field";
-        constructor(_analyzer: Analyzer, variable: types.Variable, receiver: NarrowableReference);
-        equals(other: NarrowableReference): boolean;
-        contains(other: NarrowableReference): boolean;
-        equalsExpression(expression: controlFlow.NarrowableReferenceExpression): boolean;
-        containsExpression(expression: controlFlow.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: controlFlow.NarrowableReferenceExpression): boolean;
-        containsExpression(_expression: controlFlow.NarrowableReferenceExpression): boolean;
-    }
-    export class ObjectAutoVariable implements INarrowableReference {
-        readonly kind = "object-auto-variable";
-        equals(other: NarrowableReference): boolean;
-        contains(_other: NarrowableReference): boolean;
-        equalsExpression(expression: controlFlow.NarrowableReferenceExpression): boolean;
-        containsExpression(_expression: controlFlow.NarrowableReferenceExpression): boolean;
-    }
-    interface INarrowableReference {
-        equals(other: NarrowableReference): boolean;
-        contains(other: NarrowableReference): boolean;
-        /**
-         * Отличается от метода `equals` тем, что выполняет сравнение лениво. Например, при сравнении с выражением
-         * `а.б` сперва будут сравнены части слева от точки (выражение `а` с `receiver`), и только при равенстве будет
-         * связано и сравнено имя `б`. Если выражение `а` не равно `receiver`, то сразу будет возвращено `false` и
-         * связывание для имени `б` выполняться не будет. Такое поведение необходимо при анализе циклов,
-         * чтобы избежать рекурсии.
-         */
-        equalsExpression(expression: controlFlow.NarrowableReferenceExpression): boolean;
-        containsExpression(expression: controlFlow.NarrowableReferenceExpression): boolean;
-    }
-    export {};
 }

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

@@ -1,10 +1,12 @@
 import { Diagnostic } from '../../diagnostic/Diagnostic.js';
 import { SourceFile } from '../../project/SourceFile.js';
+import { SubprogramDeclarationOrLiteral } from '../NodeTypeUtils.js';
 import { NarrowableReferenceExpression } from './NarrowableExpression.js';
 import { Node } from './Nodes.js';
 export declare class GraphBuilder {
     private readonly _sourceFile;
     private readonly _controlFlowNodeByReference;
+    private readonly _controlFlowNodesEndingSubprogram;
     private readonly _unreachableCodeDiagnostics;
     private _isInRebuildingFinallyClauseGraphMode;
     private _currentPredecessor;
@@ -12,6 +14,7 @@ export declare class GraphBuilder {
     private _currentBreakLoopTarget;
     private _currentErrorTarget;
     private _currentReturnTarget;
+    private _currentRangeWithReportedUnreachableCodeDiagnostic;
     constructor(sourceFile: SourceFile);
     build(): GraphBuildResult;
     private visitNode;
@@ -27,7 +30,7 @@ export declare class GraphBuilder {
     private visitReturnStatement;
     private visitErrorStatement;
     private visitLocalVariableDeclaration;
-    private visitWhenTernaryExpression;
+    private visitConditionalExpression;
     private visitCondition;
     private visitBinaryExpression;
     private visitPrefixUnaryExpressionInCondition;
@@ -38,6 +41,7 @@ export declare class GraphBuilder {
 }
 export declare class GraphBuildResult {
     readonly controlFlowNodeByReference: ReadonlyMap<NarrowableReferenceExpression, Node>;
+    readonly controlFlowNodesEndingSubprogram: ReadonlyMap<SubprogramDeclarationOrLiteral, Node>;
     readonly unreachableCodeDiagnostics: readonly Diagnostic[];
-    constructor(controlFlowNodeByReference: ReadonlyMap<NarrowableReferenceExpression, Node>, unreachableCodeDiagnostics: readonly Diagnostic[]);
+    constructor(controlFlowNodeByReference: ReadonlyMap<NarrowableReferenceExpression, Node>, controlFlowNodesEndingSubprogram: ReadonlyMap<SubprogramDeclarationOrLiteral, Node>, unreachableCodeDiagnostics: readonly Diagnostic[]);
 }

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 { SourceFileSemanticContext } from './SourceFileSemanticContext.js';
+import { CatchClauseSemanticContext, ForStatementSemanticContext, FunctionBlockSemanticContext, SpecialLocalDeclarationSemanticContext, StatementBlockSemanticContext, SubprogramParameterSemanticContext, SubprogramTypeParameterSemanticContext } from './SubprogramBodyAndParametersSemanticContext.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;
+}