@artel/artc 0.6.25221 → 0.6.25223

package/build/{chunk-5F65ZJE3.js → chunk-LG4Z4SWO.js}

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

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

@@ -92,7 +92,7 @@ export declare class Analyzer {
     private readonly _extendedTypes;
     private readonly _analyzedTranslationPackages;
     private readonly _linkedMultiPlatformPackagesByPlatform;
-    private readonly _bodyUsesYieldStatementCheckResults;
+    private readonly _functionBlockWithYieldStatementCheckResults;
     private readonly _namedDeclarationsUsageCountResults;
     private readonly _controlFlowGraphs;
     get tsInterop(): TsInteropContext;
@@ -108,7 +108,7 @@ export declare class Analyzer {
     } | undefined;
     isTypeAssignableTo(source: types.Type, target: types.Type): boolean;
     getTypeAssignabilityFlags(source: types.Type, target: types.Type): TypeAssignabilityFlags;
-    checkStatementBlockInvokesAsyncMethods(node: tree.StatementBlock): boolean;
+    checkBlockInvokesAsyncMethods(node: tree.StatementBlock | tree.FunctionBlock): boolean;
     getSyntacticAccessKind(node: tree.Expression): SyntacticAccessKind;
     getTypeMemberEntityContainer(node: tree.TypeMemberDeclaration): e.TypeMemberEntityContainer;
     getTargetTypeOfExpression(node: tree.Expression, hint?: TargetTypeHint): types.Type | undefined;
@@ -184,7 +184,7 @@ export declare class Analyzer {
     checkExpressionDenotesPackageNameSegment(expression: tree.Expression): {
         packageTreeNode: PackageNameTreeNode;
     } | undefined;
-    checkMethodBodyUsesYieldStatement(node: tree.StatementBlock): boolean;
+    checkFunctionBlockWithYieldStatement(node: tree.FunctionBlock): boolean;
     enumerateAspects(type: types.Type): Iterable<types.StructuredType>;
     checkTypeIsBasedOnAspect(type: types.Type, aspectEntity: e.StructuredTypeEntity): boolean;
     resolvePrefixUnaryExpressionUserDefinableOperator(node: tree.PrefixUnaryExpression): WithDiagnostics<FoundAnonymousDeclaration<types.Operator>>;
@@ -250,6 +250,7 @@ export declare class Analyzer {
     createPackageMemberHiding(node: tree.PackageMemberDeclaration, modifierFlags: ModifierFlags): e.EntityHidingLevel | undefined;
     createTypeMemberHiding(node: tree.TypeMemberDeclaration, modifierFlags: ModifierFlags): e.EntityHidingLevel | undefined;
     getDeclarationsUsageCount(sourceFile: tree.SourceFile, cancellationToken: CancellationToken | undefined): Promise<DeclarationsUsageCountResult>;
+    isFunctionResultNone(node: tree.FunctionBlock): boolean;
     isExpressionImplicitlyReturnedFromSubprogram(node: tree.ExpressionStatement): boolean;
     createBackingPackageVariables(declaredMembers: readonly (e.NamedPackageMemberEntity | e.PackageAliasEntity)[], pkg: e.PackageEntity): e.PackageVariableEntity[];
     createBackingTypeVariables(declaredMembers: readonly NamedTypeMemberEntity[], type: e.TypeEntity): e.TypeVariableEntity[];
@@ -461,6 +462,7 @@ declare class Scope {
     private readonly _nestedMethodDeclarationTypeParametersScopes;
     private readonly _nestedMethodDeclarationValueParametersScopes;
     private readonly _methodLiteralScopes;
+    private readonly _functionBlockScopes;
     private readonly _statementBlockScopes;
     private readonly _forEachStatementScopes;
     private readonly _catchClauseScopes;
@@ -487,6 +489,7 @@ declare class Scope {
     ofNestedMethodDeclarationTypeParameters(node: tree.NestedMethodDeclaration): scope.IScope;
     ofNestedMethodDeclarationValueParameters(node: tree.NestedMethodDeclaration): scope.IScope;
     ofMethodLiteral(node: tree.MethodLiteral): scope.IScope;
+    ofFunctionBlock(node: tree.FunctionBlock): scope.IScope;
     ofStatementBlock(node: tree.StatementBlock): scope.IScope;
     ofForStatement(node: tree.ForStatement): scope.IScope;
     ofCatchClause(node: tree.CatchClause): scope.IScope;
@@ -604,19 +607,19 @@ declare class OwningPlainObjectModificationCheck {
     private _analyzer;
     private readonly _owningPlainObjectModificationCheckResult;
     constructor(_analyzer: Analyzer);
-    ofDeclarationBody(node: tree.StatementBlock): boolean;
+    ofDeclarationBody(node: tree.FunctionBlock): boolean;
     private checkMethodBodyModifiesPlainObject;
     private checkReceiverModifiesPlainObjectRecursively;
     private nodeBelongsToPlainObjectDeclaration;
 }
 export declare enum TypeAssignabilityFlags {
-    NotAssignable = 1,
-    Identity = 2,
-    DerivedToBase = 4,
-    MethodTypes = 8,
-    ImplicitConversion = 16,
+    NotAssignable = 0,
+    Identity = 1,
+    DerivedToBase = 2,
+    MethodTypes = 4,
+    ImplicitConversion = 8,
     First = 1,
-    Last = 16
+    Last = 8
 }
 declare class PackageImports {
     private readonly _analyzer;

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

@@ -40,11 +40,11 @@ export declare class ControlFlowGraphBuildResult {
     readonly unreachableCodeDiagnostics: readonly Diagnostic[];
     constructor(controlFlowNodeByReference: ReadonlyMap<NarrowableReferenceExpression, ControlFlowNode>, unreachableCodeDiagnostics: readonly Diagnostic[]);
 }
-export type NarrowableExpression = tree.IdentifierExpression | tree.PropertyAccessExpression | tree.ObjectExpression;
 export declare function isNarrowableExpression(node: tree.Node): node is tree.Expression;
 export type NarrowableReferenceExpression = tree.IdentifierExpression | tree.PropertyAccessExpression | tree.ObjectExpression;
 export declare function isNarrowableReferenceExpression(node: tree.Node): node is NarrowableReferenceExpression;
-export type ControlFlowNode = ControlFlowNode.Start | ControlFlowNode.Condition | ControlFlowNode.Assignment | ControlFlowNode.Split | ControlFlowNode.Loop | ControlFlowNode.Unreachable;
+export declare function unwrapExpressionForNarrowableReferenceCheck(node: tree.Expression): tree.Expression;
+export type ControlFlowNode = ControlFlowNode.Start | ControlFlowNode.Condition | ControlFlowNode.Assignment | ControlFlowNode.LocalVariableDeclaration | ControlFlowNode.Split | ControlFlowNode.Loop | ControlFlowNode.Unreachable;
 export declare namespace ControlFlowNode {
     abstract class ControlFlowNodeBase {
         protected abstract thisAsNode: ControlFlowNode;
@@ -80,11 +80,19 @@ export declare namespace ControlFlowNode {
      */
     export class Assignment extends ControlFlowNodeBase {
         readonly predecessor: ControlFlowNode;
-        readonly syntaxNode: tree.AssignmentStatement | tree.LocalVariableDeclaration;
+        readonly syntaxNode: tree.AssignmentStatement;
         readonly kind = "assignment";
         get debuggerDisplay(): string;
         protected get thisAsNode(): ControlFlowNode;
-        constructor(predecessor: ControlFlowNode, syntaxNode: tree.AssignmentStatement | tree.LocalVariableDeclaration);
+        constructor(predecessor: ControlFlowNode, syntaxNode: tree.AssignmentStatement);
+    }
+    export class LocalVariableDeclaration extends ControlFlowNodeBase {
+        readonly predecessor: ControlFlowNode;
+        readonly syntaxNode: tree.LocalVariableDeclaration;
+        readonly kind = "local-variable-declaration";
+        get debuggerDisplay(): string;
+        protected get thisAsNode(): ControlFlowNode;
+        constructor(predecessor: ControlFlowNode, syntaxNode: tree.LocalVariableDeclaration);
     }
     /**
      * Вспомогательный узел, использующийся в местах, где происходит разветвление графа потока управления. Тип переменной

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

@@ -1,5 +1,5 @@
 import { Name, PackageLocale } from '../common/index.js';
-import { AliasTypeEntity, MethodEntity, PackageAliasEntity, PackageEntity, PackageMethodTypeEntity, PackageStructuredTypeEntity, PackageVariantTypeEntity, TypeEntity, TypeParameterEntity, VariableEntity } from '../entities/index.js';
+import { AliasTypeEntity, MethodEntity, PackageAliasEntity, PackageEntity, PackageMethodTypeEntity, PackageStructuredTypeEntity, PackageVariantTypeEntity, TypeOrExtensionEntity, TypeParameterEntity, VariableEntity } from '../entities/index.js';
 import { AnalyzedTranslationPackage, TranslatedTypeEntityMembers } from './AnalyzedTranslationPackage.js';
 export declare class LocalizationContext {
     readonly originalLocale: PackageLocale;
@@ -8,7 +8,7 @@ export declare class LocalizationContext {
     constructor(translationPackages: readonly AnalyzedTranslationPackage[], originalLocale: PackageLocale);
     getTranslationPackage(packageEntity: PackageEntity): AnalyzedTranslationPackage | undefined;
     getTranslationLocale(packageEntity: PackageEntity): PackageLocale;
-    getTranslatedTypeEntityMembers(typeEntity: TypeEntity): TranslatedTypeEntityMembers | undefined;
+    getTranslatedTypeOrExtensionEntityMembers(entity: TypeOrExtensionEntity): TranslatedTypeEntityMembers | undefined;
     getEntityName(entity: NamedEntity): Name;
 }
 export type NamedEntity = VariableEntity | PackageVariantTypeEntity | MethodEntity | TypeParameterEntity | PackageMethodTypeEntity | PackageStructuredTypeEntity | PackageAliasEntity | AliasTypeEntity;

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

@@ -9,10 +9,10 @@ export declare class Lookup {
     constructor(_scopeChain: ScopeChain, _hidingMatcher: IEntityHidingMatcher);
     getTypesOrContainersWithTypes(): readonly FoundNamedDeclaration<TypeOrContainerWithTypes>[];
     getTypesOrContainersWithTypesByName(name: SearchName): readonly FoundNamedDeclaration<TypeOrContainerWithTypes>[];
-    getNamedDeclarations(): readonly FoundNamedDeclaration<NamedDeclaration>[];
-    getNamedDeclarationsByName(name: SearchName): readonly FoundNamedDeclaration<NamedDeclaration>[];
-    getOperators(): readonly FoundAnonymousDeclaration<types.Operator>[];
-    getOperatorsByKind(kind: OperatorKind): readonly FoundAnonymousDeclaration<types.Operator>[];
+    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 checkTypeOrPackageDeclarationShadowing;
     private checkNamedDeclarationShadowing;

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

@@ -29,9 +29,4 @@ export type PackageVariableAccessorDeclaration = tree.PackageVariableGetterDecla
 export type TypeVariableAccessorDeclaration = tree.TypeVariableGetterDeclaration | tree.TypeVariableSetterDeclaration;
 export type TypeIndexedAccessorDeclaration = tree.TypeIndexedGetterDeclaration | tree.TypeIndexedSetterDeclaration;
 export type TypeDereferencedVariableAccessorDeclaration = tree.TypeDereferencedVariableGetterDeclaration | tree.TypeDereferencedVariableSetterDeclaration;
-type Declaration = tree.PackageMemberDeclaration | tree.TypeMemberDeclaration | tree.LocalVariableDeclaration | tree.EnumerationVariableDeclaration | tree.ErrorVariableDeclaration | tree.NestedMethodDeclaration | TypeDeclaration;
-type SubprogramDeclarationInternal<T extends Declaration = Declaration> = T extends {
-    block: tree.StatementBlock | undefined;
-} ? T : never;
-export type SubprogramDeclaration = SubprogramDeclarationInternal | tree.MethodLiteral | tree.MethodBlockLiteral;
-export {};
+export type SubprogramDeclaration = tree.FunctionBlockParent | tree.MethodLiteral | tree.MethodBlockLiteral;

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

@@ -24,7 +24,7 @@ export declare class Resolver {
     private resolveStaticMemberOrVariantAccessMeaning;
     private createAccessedMethodFromTypeMember;
     private resolveInstanceMemberAccessMeaning;
-    private tryResolveOperatorAccessMeaning;
+    private tryResolveInstanceOperatorAccessMeaning;
     private resolveMethodOverload;
     private convertSyntacticAccessKind;
 }

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

@@ -10,10 +10,10 @@ import { TypeMemberLookup } from './TypeMemberLookup.js';
 export interface IScope {
     getTypesOrContainersWithTypes(hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<TypeOrContainerWithTypes>[];
     getTypesOrContainersWithTypesByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<TypeOrContainerWithTypes>[];
-    getNamedDeclarations(hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<NamedDeclaration>[];
-    getNamedDeclarationsByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<NamedDeclaration>[];
-    getOperators(hidingMatcher?: IEntityHidingMatcher): readonly FoundAnonymousDeclaration<types.Operator>[];
-    getOperatorsByKind(kind: OperatorKind, hidingMatcher?: IEntityHidingMatcher): readonly FoundAnonymousDeclaration<types.Operator>[];
+    getNamedDeclarations(noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<NamedDeclaration>[];
+    getNamedDeclarationsByName(name: SearchName, noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<NamedDeclaration>[];
+    getOperators(noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): readonly FoundAnonymousDeclaration<types.Operator>[];
+    getOperatorsByKind(kind: OperatorKind, noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): readonly FoundAnonymousDeclaration<types.Operator>[];
     getTypeExtensionsByType(typeEntity: TypeEntity, hidingMatcher?: IEntityHidingMatcher): readonly TypeExtensionEntity[];
 }
 export type TypeOrContainerWithTypes = NamedDeclaration_type | NamedDeclaration_packageAlias | NamedDeclaration_packageNameSegment;
@@ -139,10 +139,10 @@ export declare class SourceFileScope implements IScope {
     constructor(analyzer: Analyzer, node: tree.SourceFile);
     getTypesOrContainersWithTypes(hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<TypeOrContainerWithTypes>[];
     getTypesOrContainersWithTypesByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<TypeOrContainerWithTypes>[];
-    getNamedDeclarations(hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
-    getNamedDeclarationsByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
-    getOperators(_hidingMatcher?: IEntityHidingMatcher): FoundAnonymousDeclaration<types.Operator>[];
-    getOperatorsByKind(_kind: OperatorKind, _hidingMatcher?: IEntityHidingMatcher): FoundAnonymousDeclaration<types.Operator>[];
+    getNamedDeclarations(_noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
+    getNamedDeclarationsByName(name: SearchName, _noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
+    getOperators(_noInstanceMembers?: boolean, _hidingMatcher?: IEntityHidingMatcher): FoundAnonymousDeclaration<types.Operator>[];
+    getOperatorsByKind(_kind: OperatorKind, _noInstanceMembers?: boolean, _hidingMatcher?: IEntityHidingMatcher): FoundAnonymousDeclaration<types.Operator>[];
     getTypeExtensionsByType(type: TypeEntity, hidingMatcher?: IEntityHidingMatcher): TypeExtensionEntity[];
     private convertPackageMemberToNamedDeclaration;
     private convertPackageAliasToTypeOrContainerWithTypes;
@@ -163,10 +163,10 @@ export declare class GenericScope implements IScope {
     constructor(namedDeclarations: readonly NamedDeclaration[], typeExtensionEntities: readonly TypeExtensionEntity[], locale: PackageLocale);
     getTypesOrContainersWithTypes(hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<TypeOrContainerWithTypes>[];
     getTypesOrContainersWithTypesByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<TypeOrContainerWithTypes>[];
-    getNamedDeclarations(hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
-    getNamedDeclarationsByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
-    getOperators(_hidingMatcher?: IEntityHidingMatcher): FoundAnonymousDeclaration<types.Operator>[];
-    getOperatorsByKind(_kind: OperatorKind, _hidingMatcher?: IEntityHidingMatcher): FoundAnonymousDeclaration<types.Operator>[];
+    getNamedDeclarations(_noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
+    getNamedDeclarationsByName(name: SearchName, _noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
+    getOperators(_noInstanceMembers?: boolean, _hidingMatcher?: IEntityHidingMatcher): FoundAnonymousDeclaration<types.Operator>[];
+    getOperatorsByKind(_kind: OperatorKind, _noInstanceMembers?: boolean, _hidingMatcher?: IEntityHidingMatcher): FoundAnonymousDeclaration<types.Operator>[];
     getTypeExtensionsByType(typeEntity: TypeEntity, hidingMatcher?: IEntityHidingMatcher): TypeExtensionEntity[];
     private checkHiding;
 }
@@ -182,47 +182,24 @@ export declare class ParameterDeclarationsScope implements IScope {
     constructor(analyzer: Analyzer, node: tree.ParameterList);
     getTypesOrContainersWithTypes(hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<TypeOrContainerWithTypes>[];
     getTypesOrContainersWithTypesByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<TypeOrContainerWithTypes>[];
-    getNamedDeclarations(hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
-    getNamedDeclarationsByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
-    getOperators(_hidingMatcher?: IEntityHidingMatcher): FoundAnonymousDeclaration<types.Operator>[];
-    getOperatorsByKind(_kind: OperatorKind, _hidingMatcher?: IEntityHidingMatcher): FoundAnonymousDeclaration<types.Operator>[];
+    getNamedDeclarations(_noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
+    getNamedDeclarationsByName(name: SearchName, noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
+    getOperators(_noInstanceMembers?: boolean, _hidingMatcher?: IEntityHidingMatcher): FoundAnonymousDeclaration<types.Operator>[];
+    getOperatorsByKind(_kind: OperatorKind, _noInstanceMembers?: boolean, _hidingMatcher?: IEntityHidingMatcher): FoundAnonymousDeclaration<types.Operator>[];
     getTypeExtensionsByType(typeEntity: TypeEntity, hidingMatcher?: IEntityHidingMatcher): TypeExtensionEntity[];
     private checkHiding;
 }
-export declare class TypeWithMembersBodyScope implements IScope {
+export declare class TypeWithMembersOrExtensionBodyScope implements IScope {
     private readonly _memberLookup;
     private readonly _typeExtensionsLookup;
     constructor(_memberLookup: TypeMemberLookup, _typeExtensionsLookup: Lookup);
     getTypesOrContainersWithTypes(_hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<TypeOrContainerWithTypes>[];
     getTypesOrContainersWithTypesByName(_name: SearchName, _hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<TypeOrContainerWithTypes>[];
-    getNamedDeclarations(hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
-    getNamedDeclarationsByName(name: SearchName, hidingMatcher: IEntityHidingMatcher | undefined): FoundNamedDeclaration<NamedDeclaration>[];
-    getOperators(hidingMatcher?: IEntityHidingMatcher): readonly FoundAnonymousDeclaration<types.Operator>[];
-    getOperatorsByKind(kind: OperatorKind, hidingMatcher?: IEntityHidingMatcher): readonly FoundAnonymousDeclaration<types.Operator>[];
+    getNamedDeclarations(noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
+    getNamedDeclarationsByName(name: SearchName, noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
+    getOperators(noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): readonly FoundAnonymousDeclaration<types.Operator>[];
+    getOperatorsByKind(kind: OperatorKind, noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): readonly FoundAnonymousDeclaration<types.Operator>[];
     getTypeExtensionsByType(_typeEntity: TypeEntity, _hidingMatcher?: IEntityHidingMatcher): TypeExtensionEntity[];
     private convertNamedMember;
 }
-export declare class TypeExtensionBodyScope implements IScope {
-    private readonly _analyzer;
-    private readonly _extendedTypeMemberLookup;
-    private readonly _extendedType;
-    private readonly _typeExtensionEntity;
-    private readonly _typeExtensionsLookup;
-    private readonly _locale;
-    private readonly _substitutions;
-    private get substitutions();
-    constructor(_analyzer: Analyzer, _extendedTypeMemberLookup: TypeMemberLookup | undefined, _extendedType: NamedTypeEntity | undefined, _typeExtensionEntity: TypeExtensionEntity, _typeExtensionsLookup: Lookup, _locale: PackageLocale);
-    getTypesOrContainersWithTypes(_hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<TypeOrContainerWithTypes>[];
-    getTypesOrContainersWithTypesByName(_name: SearchName, _hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<TypeOrContainerWithTypes>[];
-    getNamedDeclarations(hidingMatcher: IEntityHidingMatcher | undefined): FoundNamedDeclaration<NamedDeclaration>[];
-    getNamedDeclarationsByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
-    getOperators(hidingMatcher?: IEntityHidingMatcher): FoundAnonymousDeclaration<types.Operator>[];
-    getOperatorsByKind(kind: OperatorKind, hidingMatcher?: IEntityHidingMatcher): readonly FoundAnonymousDeclaration<types.Operator>[];
-    getTypeExtensionsByType(_typeEntity: TypeEntity, _hidingMatcher?: IEntityHidingMatcher): TypeExtensionEntity[];
-    private convertNamedTypeExtensionMember;
-    private convertTypeExtensionOperator;
-    private convertExtendedTypeMember;
-    private checkOperatorShadowing;
-    private checkNamedDeclarationShadowing;
-}
 export {};

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

@@ -25,6 +25,7 @@ export interface SemanticContext {
     isInFinallyClause(): boolean;
     getScopeLookup(): Lookup;
     getHidingMatcher(): IEntityHidingMatcher;
+    isStatic(): boolean;
 }
 export type SubprogramInfo = SubprogramInfo.Method | SubprogramInfo.Operator | SubprogramInfo.Constructor | SubprogramInfo.Destructor | SubprogramInfo.Getter | SubprogramInfo.Setter | SubprogramInfo.PackageConstructor | SubprogramInfo.PackageEntryPoint | SubprogramInfo.MethodLiteral;
 export declare namespace SubprogramInfo {
@@ -161,6 +162,7 @@ declare abstract class SemanticContextWithParent implements SemanticContext {
     isInFinallyClause(): boolean;
     getScopeLookup(): Lookup;
     getHidingMatcher(): IEntityHidingMatcher;
+    isStatic(): boolean;
 }
 export declare class SourceFileSemanticContext implements SemanticContext {
     private readonly _analyzer;
@@ -177,6 +179,7 @@ export declare class SourceFileSemanticContext implements SemanticContext {
     isInFinallyClause(): boolean;
     getScopeLookup(): Lookup;
     getLocalizationContext(): LocalizationContext;
+    isStatic(): boolean;
 }
 export type TypeDeclarationCreatingSemanticContext = StructuredTypeDeclaration | VariantTypeDeclaration | MethodTypeDeclaration | tree.PackageAliasTypeDeclaration;
 /**
@@ -192,6 +195,7 @@ export declare class LastSemanticContextOfType extends SemanticContextWithParent
     getContainingSubprogram(): SubprogramInfo | undefined;
     isInTryStatement(): TryStatementClausesInfo | undefined;
     isInFinallyClause(): boolean;
+    isStatic(): boolean;
     private getContainingType;
 }
 type TypeDeclarationWithTypeParameters = tree.PackageStructuredTypeDeclaration | tree.PackageVariantTypeDeclaration | tree.PackageAliasTypeDeclaration | tree.PackageMethodTypeDeclaration;
@@ -231,6 +235,7 @@ export declare class LastSemanticContextOfMethod extends SemanticContextWithPare
     getContainingSubprogram(): SubprogramInfo | undefined;
     isInTryStatement(): TryStatementClausesInfo | undefined;
     isInFinallyClause(): boolean;
+    isStatic(): boolean;
 }
 export declare class MethodTypeParameterSemanticContext extends SemanticContextWithParent {
     private readonly _analyzer;
@@ -268,6 +273,7 @@ export declare class OperatorSemanticContext extends SemanticContextWithParent {
     constructor(analyzer: Analyzer, node: tree.OperatorDeclaration, parentContext: SemanticContext);
     getScopeChain(): ScopeChain;
     getContainingSubprogram(): SubprogramInfo | undefined;
+    isStatic(): boolean;
 }
 export declare class ConstructorSemanticContext extends SemanticContextWithParent {
     private readonly _analyzer;
@@ -298,11 +304,11 @@ export declare class IndexerSemanticContext extends SemanticContextWithParent {
 export declare class GetterSemanticContext extends SemanticContextWithParent {
     private readonly _analyzer;
     private readonly _node;
-    private readonly _scopeChain;
     private readonly _subprogramInfo;
     constructor(analyzer: Analyzer, node: GetterDeclaration, parentContext: SemanticContext);
     getScopeChain(): ScopeChain;
     getContainingSubprogram(): SubprogramInfo | undefined;
+    isStatic(): boolean;
 }
 export declare class SetterSemanticContext extends SemanticContextWithParent {
     private readonly _analyzer;
@@ -310,6 +316,7 @@ export declare class SetterSemanticContext extends SemanticContextWithParent {
     private readonly _subprogramInfo;
     constructor(analyzer: Analyzer, node: SetterDeclaration, parentContext: SemanticContext);
     getContainingSubprogram(): SubprogramInfo | undefined;
+    isStatic(): boolean;
 }
 export declare class StatementBlockSemanticContext extends SemanticContextWithParent {
     private readonly _analyzer;
@@ -320,6 +327,13 @@ export declare class StatementBlockSemanticContext extends SemanticContextWithPa
     isInTryStatement(): TryStatementClausesInfo | undefined;
     isInFinallyClause(): boolean;
 }
+export declare class FunctionBlockSemanticContext extends SemanticContextWithParent {
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _scopeChain;
+    constructor(analyzer: Analyzer, node: tree.FunctionBlock, parentContext: SemanticContext);
+    getScopeChain(): ScopeChain;
+}
 export type RegularOrBlockMethodLiteral = tree.MethodLiteral | tree.MethodBlockLiteral;
 export declare class MethodLiteralSemanticContext extends SemanticContextWithParent {
     private readonly _analyzer;
@@ -344,4 +358,10 @@ export declare class CatchClauseSemanticContext extends SemanticContextWithParen
     constructor(analyzer: Analyzer, node: tree.CatchClause, parentContext: SemanticContext);
     getScopeChain(): ScopeChain;
 }
+export declare class TypeVariableWithInitializerSemanticContext extends SemanticContextWithParent {
+    private readonly _analyzer;
+    private readonly _node;
+    constructor(analyzer: Analyzer, node: tree.TypeVariableDeclaration, parentContext: SemanticContext);
+    isStatic(): boolean;
+}
 export {};

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

@@ -34,11 +34,13 @@ export declare class SemanticContextBuilder {
     ofRegularOrBlockMethodLiteral(node: RegularOrBlockMethodLiteral): SemanticContext;
     ofForStatement(node: tree.ForStatement): SemanticContext;
     ofStatementBlock(node: tree.StatementBlock): SemanticContext;
+    ofFunctionBlock(node: tree.FunctionBlock): SemanticContext;
     ofTypeConstructorDeclaration(node: tree.TypeConstructorDeclaration): SemanticContext;
     ofTypeDestructorDeclaration(node: tree.TypeDestructorDeclaration): SemanticContext;
     ofTypeIndexedGetterDeclaration(node: tree.TypeIndexedGetterDeclaration, hint: 'body' | 'parameters'): SemanticContext;
     ofTypeIndexedSetterDeclaration(node: tree.TypeIndexedSetterDeclaration, hint: 'body' | 'parameters'): SemanticContext;
     ofCatchClause(node: tree.CatchClause): SemanticContext;
+    ofTypeVariableDeclarationWithInitializer(node: tree.TypeVariableDeclaration): SemanticContext;
     private containingInternal;
     private ofChildOfMethodDeclaration;
     private ofChildOfTypeDeclarationWithMemberBlock;
@@ -53,4 +55,5 @@ export declare class SemanticContextBuilder {
     private ofChildOfTypeExtensionDeclaration;
     private isOffsetBetweenNodes;
     private isOffsetInsideStatementBlock;
+    private isOffsetInsideFunctionBlock;
 }

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

@@ -2,22 +2,25 @@ import * as tree from '../tree/index.js';
 import { Analyzer } from './Analyzer.js';
 import { IScope } from './Scope.js';
 export declare class StatementBlockScopeBuilder {
-    static build(analyzer: Analyzer, node: tree.StatementBlock): IScope;
-    static buildGenericScope(analyzer: Analyzer, node: tree.StatementBlock): IScope;
-    static buildScopeForMethodBlockLiteral(analyzer: Analyzer, node: tree.StatementBlock, parent: tree.MethodBlockLiteral): IScope;
-    static buildScopeForPackageMethodDeclaration(analyzer: Analyzer, node: tree.StatementBlock, parent: tree.PackageMethodDeclaration): IScope;
-    static buildScopeForTypeVariableGetterDeclaration(analyzer: Analyzer, node: tree.StatementBlock, parent: tree.TypeVariableGetterDeclaration): IScope;
-    static buildScopeForTypeVariableSetterDeclaration(analyzer: Analyzer, node: tree.StatementBlock, parent: tree.TypeVariableSetterDeclaration): IScope;
-    static buildScopeForPackageVariableGetterDeclaration(analyzer: Analyzer, node: tree.StatementBlock, parent: tree.PackageVariableGetterDeclaration): IScope;
-    static buildScopeForPackageVariableSetterDeclaration(analyzer: Analyzer, node: tree.StatementBlock, parent: tree.PackageVariableSetterDeclaration): IScope;
-    static buildScopeForTypeIndexedGetterDeclaration(analyzer: Analyzer, node: tree.StatementBlock, parent: tree.TypeIndexedGetterDeclaration): IScope;
-    static buildScopeForTypeIndexedSetterDeclaration(analyzer: Analyzer, node: tree.StatementBlock, parent: tree.TypeIndexedSetterDeclaration): IScope;
-    static buildScopeForTypeDereferencedVariableGetterDeclaration(analyzer: Analyzer, node: tree.StatementBlock, parent: tree.TypeDereferencedVariableGetterDeclaration): IScope;
-    static buildScopeForTypeDereferencedVariableSetterDeclaration(analyzer: Analyzer, node: tree.StatementBlock, parent: tree.TypeDereferencedVariableSetterDeclaration): IScope;
-    static buildScopeForNestedMethodDeclaration(analyzer: Analyzer, node: tree.StatementBlock, parent: tree.NestedMethodDeclaration): IScope;
-    static buildScopeForMethodLiteral(analyzer: Analyzer, node: tree.StatementBlock, parent: tree.MethodLiteral): IScope;
-    static buildScopeForTypeConstructorDeclaration(analyzer: Analyzer, node: tree.StatementBlock, parent: tree.TypeConstructorDeclaration): IScope;
-    static buildScopeForTypeMethodDeclaration(analyzer: Analyzer, node: tree.StatementBlock, parent: tree.TypeMethodDeclaration): IScope;
-    static buildScopeForOperatorDeclaration(analyzer: Analyzer, node: tree.StatementBlock, parent: tree.OperatorDeclaration): IScope;
+    static buildFunctionBlockScope(analyzer: Analyzer, node: tree.FunctionBlock): IScope;
+    static buildStatementBlockScope(analyzer: Analyzer, node: tree.StatementBlock): IScope;
+    static buildGenericScopeForFunctionBlock(analyzer: Analyzer, node: tree.FunctionBlock): IScope;
+    static buildGenericScopeForStatementBlock(analyzer: Analyzer, node: tree.StatementBlock): IScope;
+    static buildScopeForMethodBlockLiteral(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.MethodBlockLiteral): IScope;
+    static buildScopeForPackageMethodDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.PackageMethodDeclaration): IScope;
+    static buildScopeForTypeVariableGetterDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.TypeVariableGetterDeclaration): IScope;
+    static buildScopeForTypeVariableSetterDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.TypeVariableSetterDeclaration): IScope;
+    static buildScopeForPackageVariableGetterDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.PackageVariableGetterDeclaration): IScope;
+    static buildScopeForPackageVariableSetterDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.PackageVariableSetterDeclaration): IScope;
+    static buildScopeForTypeIndexedGetterDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.TypeIndexedGetterDeclaration): IScope;
+    static buildScopeForTypeIndexedSetterDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.TypeIndexedSetterDeclaration): IScope;
+    static buildScopeForTypeDereferencedVariableGetterDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.TypeDereferencedVariableGetterDeclaration): IScope;
+    static buildScopeForTypeDereferencedVariableSetterDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.TypeDereferencedVariableSetterDeclaration): IScope;
+    static buildScopeForNestedMethodDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.NestedMethodDeclaration): IScope;
+    static buildScopeForMethodLiteral(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.MethodLiteral): IScope;
+    static buildScopeForTypeConstructorDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.TypeConstructorDeclaration): IScope;
+    static buildScopeForTypeMethodDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.TypeMethodDeclaration): IScope;
+    static buildScopeForOperatorDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.OperatorDeclaration): IScope;
+    private static getLocalNamedDeclarationsOfFunctionBlock;
     private static getLocalNamedDeclarations;
 }

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

@@ -1,5 +1,5 @@
 import { PackageLocale, SearchName } from '../common/index.js';
-import { IEntityHidingMatcher, OperatorKind, TypeEntity } from '../entities/index.js';
+import { IEntityHidingMatcher, OperatorKind, TypeEntity, TypeExtensionEntity, TypeOrExtensionEntity } from '../entities/index.js';
 import * as types from '../types/index.js';
 import { Analyzer } from './Analyzer.js';
 import { FoundAnonymousDeclaration, FoundNamedDeclaration } from './FoundDeclaration.js';
@@ -7,30 +7,36 @@ import { LocalizationContext } from './LocalizationContext.js';
 import { Lookup } from './Lookup.js';
 export declare class TypeMemberLookup {
     private readonly _analyzer;
-    private readonly _type;
+    private readonly _typeOrExtension;
     private readonly _localizationContext;
     private readonly _searchLocale;
     /**
      * Язык, на котором будет осуществляться поиск членов типа.
      */
     get searchLocale(): PackageLocale;
-    constructor(_analyzer: Analyzer, _type: types.Type, _localizationContext: LocalizationContext | undefined);
+    private constructor();
+    static ofType(analyzer: Analyzer, type: types.Type, localizationContext: LocalizationContext | undefined): TypeMemberLookup;
     static ofTypeEntity(analyzer: Analyzer, entity: TypeEntity, localizationContext: LocalizationContext | undefined): TypeMemberLookup;
-    getNamedMembers(hidingMatcher?: IEntityHidingMatcher, typeExtensionsLookup?: Lookup): readonly FoundNamedDeclaration<types.NamedTypeMember>[];
-    getNamedMembersByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher, typeExtensionsLookup?: Lookup): readonly FoundNamedDeclaration<types.NamedTypeMember>[];
-    getOperators(hidingMatcher?: IEntityHidingMatcher, typeExtensionsLookup?: Lookup): readonly FoundAnonymousDeclaration<types.Operator>[];
-    getOperatorsByKind(kind: OperatorKind, hidingMatcher?: IEntityHidingMatcher, typeExtensionsLookup?: Lookup): readonly FoundAnonymousDeclaration<types.Operator>[];
+    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(hidingMatcher?: IEntityHidingMatcher, typeExtensionsLookup?: Lookup): readonly FoundAnonymousDeclaration<types.Indexer>[];
-    getDereferenceOperators(hidingMatcher?: IEntityHidingMatcher, typeExtensionsLookup?: Lookup): readonly FoundAnonymousDeclaration<types.DereferenceOperator>[];
+    getIndexers(options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionsLookup?: Lookup): readonly FoundAnonymousDeclaration<types.Indexer>[];
+    getDereferenceOperators(options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionsLookup?: Lookup): readonly FoundAnonymousDeclaration<types.DereferenceOperator>[];
     private getLocaleOfTypeEntity;
 }
 export declare class BoundTypeMemberLookup {
     private readonly _lookup;
+    private readonly _options;
     private readonly _hidingMatcher;
     private readonly _typeExtensionLookup;
-    constructor(analyzer: Analyzer, type: types.Type, localizationContext: LocalizationContext | undefined, hidingMatcher: IEntityHidingMatcher | undefined, typeExtensionLookup: Lookup | undefined);
-    static ofTypeEntity(analyzer: Analyzer, entity: TypeEntity, localizationContext: LocalizationContext | undefined, hidingMatcher: IEntityHidingMatcher | undefined, typeExtensionLookup: Lookup | undefined): BoundTypeMemberLookup;
+    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;
     getNamedMembers(): readonly FoundNamedDeclaration<types.NamedTypeMember>[];
     getNamedMembersByName(name: SearchName): readonly FoundNamedDeclaration<types.NamedTypeMember>[];
     getOperators(): readonly FoundAnonymousDeclaration<types.Operator>[];
@@ -39,3 +45,25 @@ export declare class BoundTypeMemberLookup {
     getIndexers(): readonly FoundAnonymousDeclaration<types.Indexer>[];
     getDereferenceOperators(): readonly FoundAnonymousDeclaration<types.DereferenceOperator>[];
 }
+export declare enum TypeMemberLookupOptions {
+    None = 0,
+    OnlyInstanceMembers = 1,
+    OnlyStaticMembers = 2
+}
+type TypeOrExtension = TypeOrExtension_type | TypeOrExtension_extension;
+declare class TypeOrExtension_type implements ITypeOrExtension {
+    readonly value: types.Type;
+    readonly kind = "type";
+    constructor(value: types.Type);
+    getEntity(): TypeOrExtensionEntity | undefined;
+}
+declare class TypeOrExtension_extension implements ITypeOrExtension {
+    readonly value: TypeExtensionEntity;
+    readonly kind = "extension";
+    constructor(value: TypeExtensionEntity);
+    getEntity(): TypeOrExtensionEntity | undefined;
+}
+interface ITypeOrExtension {
+    getEntity(): TypeOrExtensionEntity | undefined;
+}
+export {};

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

@@ -9,49 +9,89 @@ export declare class TypeNarrower {
     private readonly _controlFlowNode;
     private _reference;
     private readonly _typeByNode;
+    private readonly _isVariableAssignedInLoopCheckResults;
     constructor(analyzer: Analyzer, referenceExpression: NarrowableReferenceExpression, initialType: types.Type, controlFlowNode: ControlFlowNode);
     getType(): types.Type;
     private getTypeAtControlFlowNode;
     private getTypeAtCondition;
     private getTypeAtAssignment;
+    private getTypeAtLocalVariableDeclaration;
     private getTypeAtSplit;
     private getTypeAtLoop;
+    private getTypeAtAssignmentWithImplicitConversion;
     private getTypeAtComparisonWithNone;
     private getTypeAtIsExpression;
+    private getTypeAtAssignmentOrDeclaration;
     private addTypeIfUnique;
+    private checkIfVariableIsAssignedInLoop;
+    private checkIfVariableIsAssignedAtNode;
     private isSameReferenceAsNarrowedExpression;
-    private unwrapExpression;
     private getReferenceAtNodeIfNarrowable;
     private getReferenceAtNode;
     private getReferenceAtLocalVariableDeclaration;
 }
-export type NarrowableReference = NarrowableReference.LocalOrPackageVariable | NarrowableReference.InstanceTypeVariable | NarrowableReference.StaticTypeVariable | NarrowableReference.Object;
+export type NarrowableReference = NarrowableReference.LocalVariable | NarrowableReference.PackageVariable | NarrowableReference.InstanceTypeVariable | NarrowableReference.StaticTypeVariable | NarrowableReference.Object;
 export declare namespace NarrowableReference {
-    export class LocalOrPackageVariable implements INarrowableReference {
-        readonly entity: LocalVariableEntity | ParameterVariableEntity | PackageVariableEntity;
-        readonly kind = "local-or-package-variable";
-        constructor(entity: LocalVariableEntity | ParameterVariableEntity | PackageVariableEntity);
+    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 InstanceTypeVariable implements INarrowableReference {
+        private readonly _analyzer;
         readonly variable: types.Variable;
         readonly receiver: NarrowableReference;
         readonly kind = "instance-type-variable";
-        constructor(variable: types.Variable, receiver: NarrowableReference);
+        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 StaticTypeVariable implements INarrowableReference {
+        private readonly _analyzer;
         readonly variable: types.Variable;
         readonly kind = "static-type-variable";
-        constructor(variable: types.Variable);
+        constructor(_analyzer: Analyzer, variable: types.Variable);
         equals(other: NarrowableReference): boolean;
+        contains(_other: NarrowableReference): boolean;
+        equalsExpression(expression: NarrowableReferenceExpression): boolean;
+        containsExpression(_expression: NarrowableReferenceExpression): boolean;
     }
     export class Object implements INarrowableReference {
         readonly kind = "object";
         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 {};
 }