@artel/artc 0.6.25222 → 0.6.25224

package/build/{chunk-MBMOAUK7.js → chunk-62KHK23H.js}

@@ -1,6 +1,6 @@
 import {
   Compiler
-} from "./chunk-UZK7JCND.js";
+} from "./chunk-Y6DODJCG.js";
 import {
   ArtelVersion,
   Cached,
@@ -14,7 +14,7 @@ import {
   __async,
   performanceMeasurementStageNames,
   performanceMeasurementStages
-} from "./chunk-ODWG5ZXF.js";
+} from "./chunk-24QZJOMF.js";
 
 // source/executor/FileSystemUri.ts
 import { platform } from "os";

package/build/{chunk-UZK7JCND.js → chunk-Y6DODJCG.js}

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

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

@@ -60,6 +60,7 @@ export declare class AnalyzedTranslationPackage {
     private createTranslatedTypeSignature;
     private enumerateTranslationsDeclarations;
     private findTypeTranslation;
+    private createAmbiguousAccessDiagnostic;
 }
 export declare class TranslatedPackageMembers {
     private readonly _namedMembers;

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

@@ -21,7 +21,6 @@ import * as autotypeCallExpressionMeaning from './AutotypeCallExpressionMeaning.
 import * as baseExpressionMeaning from './BaseExpressionMeaning.js';
 import * as callExpressionMeaning from './CallExpressionMeaning.js';
 import * as constructorOverloadResolver from './ConstructorOverloadResolver.js';
-import { ControlFlowGraphBuildResult } from './ControlFlowGraphBuilder.js';
 import { DeclarationsUsageCountResult } from './DeclarationsUsageCounter.js';
 import * as dereferenceExpressionMeaning from './DereferenceExpressionMeaning.js';
 import { FoundAnonymousDeclaration } from './FoundDeclaration.js';
@@ -43,6 +42,7 @@ import * as tagMeaning from './TagMeaning.js';
 import * as tags from './Tags.js';
 import { TargetTypeHint } from './TargetTypeHint.js';
 import * as typeOverloadResolver from './TypeOverloadResolver.js';
+import * as controlFlow from './control-flow/index.js';
 import { WellKnownDeclarations } from './index.js';
 export declare class Analyzer {
     static readonly enumeratorMethodName = "\u043F\u0435\u0440\u0435\u0431\u043E\u0440";
@@ -161,7 +161,7 @@ export declare class Analyzer {
      */
     isExpressionOptionalChainingSyntactically(node: tree.Expression): boolean;
     isExpressionValidOutermostOptionalChaining(node: tree.Expression): boolean;
-    makeNoneAssignableToTypeIfExpressionValidOutermostOptionalChaining(type: types.Type, node: tree.Expression): types.Type;
+    includeNoneToTypeIfExpressionValidOutermostOptionalChaining(type: types.Type, node: tree.Expression): types.Type;
     checkIdentifierNameIsReserved(name: string, locale: PackageLocale): ReservedIdentifierKind | undefined;
     getReservedIdentifierName(reservedIdentifierKind: ReservedIdentifierKind, locale: PackageLocale): string;
     createNameFromIdentifier(node: tree.Identifier): Name;
@@ -223,7 +223,7 @@ export declare class Analyzer {
      * - Т: Объект?    -> (Т: Объект?) | Пусто (см. метод isNoneAssignableToType)
      * - Т: Объект     -> (Т: Объект) | Пусто
      */
-    makeNoneAssignableToType(type: types.Type): types.Type;
+    includeNoneToType(type: types.Type): types.Type;
     /**
      * Отвечает на вопрос "Совместим ли тип `Пусто` с данным типом?" (Можно ли присвоить `пусто` в переменную с данным типом?).
      * @example Для следующих типов метод вернёт:
@@ -241,7 +241,7 @@ export declare class Analyzer {
     getAnalyzedTranslationPackageIfTargetResolved(package_: project.TranslationPackage): AnalyzedTranslationPackage | undefined;
     getAnalyzedTranslationPackageForPackage(entity: e.PackageEntity, locale: PackageLocale): AnalyzedTranslationPackage | undefined;
     enumerateAnalyzedTranslationPackages(): Iterable<AnalyzedTranslationPackage>;
-    getCommonObjectAndAspectTypesOfUnion(_unionType: types.UnionType): readonly types.StructuredType[];
+    getCommonObjectAndAspectTypesOfUnion(unionType: types.UnionType): readonly types.StructuredType[];
     getLinkedMultiPlatformPackagesByPlatform(entity: e.PackageEntity): ReadonlyMap<PlatformKind, LinkedMultiPlatformPackage> | undefined;
     getLinkedMultiPlatformPackage(entity: e.PackageEntity, platform: PlatformKind): LinkedMultiPlatformPackage | undefined;
     createPackageMembers(pkg: SourcePackage): OriginalPackageMembers;
@@ -263,7 +263,11 @@ export declare class Analyzer {
     checkBodyOfRedefinableAliasTypeMethod(node: tree.TypeMethodDeclaration, diagnostics?: DiagnosticAcceptor): {
         redefinableMethodOfOriginalType: e.TypeMethodEntity;
     } | undefined;
-    getControlFlowGraph(sourceFile: project.SourceFile): ControlFlowGraphBuildResult;
+    getControlFlowGraph(sourceFile: project.SourceFile): controlFlow.GraphBuildResult;
+    createAmbiguousEntityAccessDiagnostic(entities: readonly WithLocalization<e.Entity>[], lctx: LocalizationContext, node: tree.Node): Diagnostic;
+    createAmbiguousMethodAccessDiagnostic(methods: readonly WithLocalization<AccessedMethod>[], lctx: LocalizationContext, node: tree.Node): Diagnostic;
+    createAmbiguousTypeMemberAccessDiagnostic(members: readonly WithLocalization<types.TypeMember>[], lctx: LocalizationContext, node: tree.Node): Diagnostic;
+    createAmbiguousNamedScopeDeclarationAccessDiagnostic(declarations: readonly WithLocalization<scope.NamedDeclaration>[], lctx: LocalizationContext, node: tree.Node): Diagnostic;
     private createTsInterop;
 }
 export declare class TsInteropInputs {
@@ -292,6 +296,7 @@ export declare const enum SyntacticAccessKind {
 declare class Type {
     private readonly _analyzer;
     private readonly _unionTypeSpecifierTypes;
+    private readonly _intersectionTypeSpecifierTypes;
     private readonly _methodLiteralTypes;
     private readonly _methodBlockLiteralTypes;
     constructor(_analyzer: Analyzer);
@@ -330,6 +335,7 @@ declare class Type {
     private ofParenthesizedTypeSpecifier;
     private ofNullableTypeSpecifier;
     private ofUnionTypeSpecifier;
+    private ofIntersectionTypeSpecifier;
     private ofInvalidTypeSpecifier;
     private getTargetlessMethodBlockLiteralType;
     private inferMethodLiteralTypeFromNodeWithFallbackToTargetType;
@@ -613,13 +619,13 @@ declare class OwningPlainObjectModificationCheck {
     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/DiagnosticCollector.d.ts

@@ -68,7 +68,7 @@ export declare class DiagnosticCollector {
     private checkTypeSpecialization;
     private checkSpecializationOfDeclarationWithParameters;
     /**
-     * @returns `true` если была ошибка, иначе `false`.
+     * @returns `true` если не было ошибки, иначе `false`.
      */
     private checkTypeArgumentCount;
     private checkParameterDeclaration;

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

@@ -11,6 +11,7 @@ export declare class ImportedPackageNameTree {
 export interface PackageNameTreeNode {
     readonly name: Name;
     readonly package: ImportedPackage | undefined;
+    readonly parent: PackageNameTreeNode | undefined;
     getChild(name: Name): PackageNameTreeNode | undefined;
     hasChild(name: Name): boolean;
     getChildren(): Iterable<PackageNameTreeNode>;

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/NamedTypeResolver.d.ts

@@ -4,6 +4,8 @@ import { QualifiedName } from '../tree/index.js';
 import { Analyzer } from './Analyzer.js';
 import { FoundNamedDeclaration } from './FoundDeclaration.js';
 import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
+import { WithLocalization } from './Localization.js';
+import { EntityOrPackageNameTreeNode } from './Utils.js';
 export declare class NamedTypeResolver {
     private readonly _analyzer;
     private readonly _node;
@@ -16,12 +18,14 @@ export declare class NamedTypeResolver {
     private findTypesOrContainersWithTypesInPackageAccessedViaAlias;
     private findTypesOrContainersWithTypesInPackageNameSegment;
     private convertPackageMember;
+    private createAmbiguousAccessDiagnostic;
 }
 export declare class NamedTypeResolutionResult {
     readonly types: readonly FoundNamedDeclaration<NamedTypeEntity>[];
     readonly resolvedQualifiers: readonly ResolvedQualifier[];
     readonly diagnostics: readonly Diagnostic[];
-    constructor(types: readonly FoundNamedDeclaration<NamedTypeEntity>[], resolvedQualifiers: readonly ResolvedQualifier[], diagnostics: readonly Diagnostic[]);
+    readonly ambiguousDeclarations: readonly WithLocalization<EntityOrPackageNameTreeNode>[] | undefined;
+    constructor(types: readonly FoundNamedDeclaration<NamedTypeEntity>[], resolvedQualifiers: readonly ResolvedQualifier[], diagnostics: readonly Diagnostic[], ambiguousDeclarations: readonly WithLocalization<EntityOrPackageNameTreeNode>[] | undefined);
 }
 export type ResolvedQualifier = ResolvedQualifier_packageNameSegment | ResolvedQualifier_packageAlias | ResolvedQualifier_type;
 export declare class ResolvedQualifier_packageNameSegment {

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

@@ -3,7 +3,9 @@ import { NamedTypeSpecifier } from '../tree/index.js';
 import * as types from '../types/index.js';
 import { Analyzer } from './Analyzer.js';
 import { FoundNamedDeclaration } from './FoundDeclaration.js';
+import { WithLocalization } from './Localization.js';
 import { ResolvedQualifier } from './NamedTypeResolver.js';
+import { EntityOrPackageNameTreeNode } from './Utils.js';
 export declare class NamedTypeSpecifierResolver {
     private readonly _analyzer;
     private readonly _node;
@@ -15,5 +17,6 @@ export declare class NamedTypeSpecifierResolutionResult {
     readonly type: FoundNamedDeclaration<types.Type> | undefined;
     readonly resolvedQualifiers: readonly ResolvedQualifier[];
     readonly diagnostics: readonly Diagnostic[];
-    constructor(type: FoundNamedDeclaration<types.Type> | undefined, resolvedQualifiers: readonly ResolvedQualifier[], diagnostics: readonly Diagnostic[]);
+    readonly ambiguousDeclarations: readonly WithLocalization<EntityOrPackageNameTreeNode>[] | undefined;
+    constructor(type: FoundNamedDeclaration<types.Type> | undefined, resolvedQualifiers: readonly ResolvedQualifier[], diagnostics: readonly Diagnostic[], ambiguousDeclarations: readonly WithLocalization<EntityOrPackageNameTreeNode>[] | undefined);
 }

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

@@ -1,11 +1,12 @@
 import { AccessKind } from '../common/index.js';
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
-import { PackageTypeEntity, PackageVariableEntity } from '../entities/index.js';
+import { Entity, PackageTypeEntity, PackageVariableEntity } from '../entities/index.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
 import { AccessedMethod } from './AccessedMethod.js';
 import { FoundAnonymousDeclaration, FoundNamedDeclaration } from './FoundDeclaration.js';
 import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
+import { WithLocalization } from './Localization.js';
 import { Analyzer, TargetTypeHint } from './index.js';
 export declare class Resolver {
     private readonly _semanticContext;
@@ -24,7 +25,7 @@ export declare class Resolver {
     private resolveStaticMemberOrVariantAccessMeaning;
     private createAccessedMethodFromTypeMember;
     private resolveInstanceMemberAccessMeaning;
-    private tryResolveOperatorAccessMeaning;
+    private tryResolveInstanceOperatorAccessMeaning;
     private resolveMethodOverload;
     private convertSyntacticAccessKind;
 }
@@ -41,7 +42,7 @@ export declare class ResolutionResult {
      */
     dependsOnTargetType?: boolean);
 }
-export type Meaning = Meaning_packageVariableAccess | Meaning_packageMethodAccess | Meaning_packageTypeAccess | Meaning_packageNameSegmentAccess | Meaning_staticVariableAccess | Meaning_staticMethodAccess | Meaning_instanceVariableAccess | Meaning_instanceMethodAccess | Meaning_operatorAccess | Meaning_unresolved;
+export type Meaning = Meaning_packageVariableAccess | Meaning_packageMethodAccess | Meaning_packageTypeAccess | Meaning_packageNameSegmentAccess | Meaning_staticVariableAccess | Meaning_staticMethodAccess | Meaning_instanceVariableAccess | Meaning_instanceMethodAccess | Meaning_operatorAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
 declare class Meaning_packageVariableAccess {
     readonly variable: FoundNamedDeclaration<PackageVariableEntity>;
     readonly accessKind: AccessKind;
@@ -102,6 +103,11 @@ declare class Meaning_operatorAccess {
     get singleSuitableOperator(): FoundAnonymousDeclaration<types.Operator> | undefined;
     constructor(candidates: readonly FoundAnonymousDeclaration<types.Operator>[], suitableOperators: readonly FoundAnonymousDeclaration<types.Operator>[]);
 }
+declare class Meaning_mixedAmbiguousAccess {
+    readonly entities: readonly WithLocalization<Entity>[];
+    readonly kind = "mixed-ambiguous-access";
+    constructor(entities: readonly WithLocalization<Entity>[]);
+}
 declare class Meaning_unresolved {
     readonly kind = "unresolved";
 }

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;
@@ -351,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

@@ -40,6 +40,7 @@ export declare class SemanticContextBuilder {
     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;

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

@@ -21,5 +21,6 @@ export declare class StatementBlockScopeBuilder {
     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/TagMeaning.d.ts

@@ -6,6 +6,8 @@ import { AccessedMethod } from './AccessedMethod.js';
 import { FoundAnonymousDeclaration, FoundNamedDeclaration } from './FoundDeclaration.js';
 import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
 import { Analyzer } from './index.js';
+import { WithLocalization } from './Localization.js';
+import { EntityOrPackageNameTreeNode } from './Utils.js';
 export declare class Resolver {
     private readonly _analyzer;
     private readonly _node;
@@ -25,7 +27,8 @@ export declare class ResolutionResult {
     readonly meaning: Meaning;
     readonly resolvedQualifiers: readonly ResolvedQualifier[];
     readonly diagnostic?: Diagnostic | undefined;
-    constructor(meaning: Meaning, resolvedQualifiers: readonly ResolvedQualifier[], diagnostic?: Diagnostic | undefined);
+    readonly ambiguousDeclarations?: readonly WithLocalization<EntityOrPackageNameTreeNode>[] | undefined;
+    constructor(meaning: Meaning, resolvedQualifiers: readonly ResolvedQualifier[], diagnostic?: Diagnostic | undefined, ambiguousDeclarations?: readonly WithLocalization<EntityOrPackageNameTreeNode>[] | undefined);
 }
 export type Meaning = Meaning_tagType | Meaning_tagMethod | Meaning_unresolved;
 declare class Meaning_tagType {

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 {};