@artel/artc 0.6.25216 → 0.6.25218

package/build/types/analysis/{CallArgumentToParameterMatchResult.d.ts → ArgumentToParameterMatchResult.d.ts}

@@ -1,26 +1,25 @@
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import { VariableEntity } from '../entities/index.js';
-import { AutotypeCallExpression, CallArgument, CallExpression, Tag } from '../tree/index.js';
+import { Argument, AutotypeCallExpression, CallExpression, IndexedAccessExpression, Tag } from '../tree/index.js';
 import * as types from '../types/index.js';
 import { LocalizedName } from './Localization.js';
 import { Analyzer } from './index.js';
-export declare class CallArgumentToParameterMatchResult {
+export declare class ArgumentToParameterMatchResult {
     private readonly _analyzer;
     private readonly _matchResults;
     constructor(_analyzer: Analyzer);
     ofCallExpression(node: CallExpression): MatchResult | undefined;
     ofAutotypeCallExpression(node: AutotypeCallExpression): MatchResult | undefined;
     ofTag(node: Tag): MatchResult | undefined;
-    private convertSignatureWithParametersMatchResult;
+    ofIndexedAccessExpression(node: IndexedAccessExpression): MatchResult | undefined;
+    private convertMatchResult;
     private convertParameter;
-    private convertConstructorSignatureMatchResult;
-    private convertConstructorParameter;
 }
 export declare class MatchResult {
-    readonly parameterByCallArgument: ReadonlyMap<CallArgument, MatchResultValueParameter>;
+    readonly parameterByArgument: ReadonlyMap<Argument, MatchResultValueParameter>;
     readonly unmatchedParameters: readonly MatchResultValueParameter[];
     readonly diagnostics: readonly Diagnostic[];
-    constructor(parameterByCallArgument: ReadonlyMap<CallArgument, MatchResultValueParameter>, unmatchedParameters: readonly MatchResultValueParameter[], diagnostics: readonly Diagnostic[]);
+    constructor(parameterByArgument: ReadonlyMap<Argument, MatchResultValueParameter>, unmatchedParameters: readonly MatchResultValueParameter[], diagnostics: readonly Diagnostic[]);
 }
 export declare class MatchResultValueParameter {
     readonly entity: VariableEntity;

package/build/types/analysis/{CallArgumentsToParametersMatcher.d.ts → ArgumentsToParametersMatcher.d.ts}

@@ -3,23 +3,23 @@ import { Diagnostic, DiagnosticLocation } from '../diagnostic/Diagnostic.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
 import { Analyzer } from './index.js';
-export declare class CallArgumentToParameterMatcher<TSignature extends ISignature<TParameter>, TParameter extends ISignatureParameter, TCallArgument extends ICallArgument> {
+export declare class ArgumentToParameterMatcher<TSignature extends ISignature<TParameter>, TParameter extends ISignatureParameter, TArgument extends IArgument> {
     private readonly _analyzer;
     private readonly _signature;
-    private readonly _callArguments;
-    constructor(_analyzer: Analyzer, _signature: TSignature, _callArguments: readonly TCallArgument[]);
-    match(): MatchResult<TParameter, TCallArgument>;
-    private matchCallArgumentsToParameters;
-    private addCallArgumentDiagnostic;
-    private getCallArgumentType;
+    private readonly _arguments;
+    constructor(_analyzer: Analyzer, _signature: TSignature, _arguments: readonly TArgument[]);
+    match(): MatchResult<TParameter, TArgument>;
+    private matchArgumentsToParameters;
+    private addArgumentDiagnostic;
+    private getArgumentType;
 }
-export declare class MatchResult<TParameter extends ISignatureParameter, TCallArgument extends ICallArgument> {
-    readonly mapping: ReadonlyMap<TCallArgument, TParameter>;
+export declare class MatchResult<TParameter extends ISignatureParameter, TArgument extends IArgument> {
+    readonly mapping: ReadonlyMap<TArgument, TParameter>;
     readonly unmatchedRequiredParameters: readonly TParameter[];
     readonly argumentArrangementDiagnostics: readonly Diagnostic[];
     readonly hasTypeAssignabilityErrors: boolean;
     get isMatching(): boolean;
-    constructor(mapping: ReadonlyMap<TCallArgument, TParameter>, unmatchedRequiredParameters: readonly TParameter[], argumentArrangementDiagnostics: readonly Diagnostic[], hasTypeAssignabilityErrors: boolean);
+    constructor(mapping: ReadonlyMap<TArgument, TParameter>, unmatchedRequiredParameters: readonly TParameter[], argumentArrangementDiagnostics: readonly Diagnostic[], hasTypeAssignabilityErrors: boolean);
 }
 export interface ISignature<TParameter extends ISignatureParameter> {
     getParameters(): readonly TParameter[];
@@ -29,15 +29,15 @@ export interface ISignatureParameter {
     getType(): types.Type;
     isOptional(): boolean;
 }
-export interface ICallArgument {
+export interface IArgument {
     getExpression(): tree.Expression;
     getName(): Name | undefined;
     getDiagnosticLocation(): DiagnosticLocation | undefined;
 }
-export declare class CallArgument implements ICallArgument {
+export declare class SourceArgument implements IArgument {
     private readonly _analyzer;
-    readonly node: tree.CallArgument;
-    constructor(_analyzer: Analyzer, node: tree.CallArgument);
+    readonly node: tree.Argument;
+    constructor(_analyzer: Analyzer, node: tree.Argument);
     getExpression(): tree.Expression;
     getName(): Name | undefined;
     getDiagnosticLocation(): DiagnosticLocation;

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

@@ -7,7 +7,7 @@ import { LocalizedName } from './Localization.js';
 export declare class Resolver<TCandidate extends ICandidate<TValueParameter>, TValueParameter extends IValueParameter> {
     private readonly _analyzer;
     constructor(_analyzer: Analyzer);
-    resolve(candidates: Iterable<TCandidate>, callArguments: Iterable<tree.CallArgument>): Iterable<TCandidate>;
+    resolve(candidates: readonly TCandidate[], args: readonly tree.Argument[]): readonly TCandidate[];
 }
 export interface ICandidate<TValueParameter extends IValueParameter> {
     getValueParameters(): readonly TValueParameter[];

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

@@ -1,7 +1,7 @@
+import { AccessKind } from '../common/index.js';
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import { DereferenceExpression } from '../tree/index.js';
 import * as types from '../types/index.js';
-import * as dereferencedVariableAccess from './DereferencedVariableAccess.js';
 import { FoundAnonymousDeclaration } from './FoundDeclaration.js';
 import { Analyzer } from './index.js';
 export declare class Resolver {
@@ -16,9 +16,9 @@ export declare class Resolver {
 export type Meaning = Meaning_resolved | Meaning_unresolved;
 declare class Meaning_resolved {
     readonly operator: FoundAnonymousDeclaration<types.DereferenceOperator>;
-    readonly access: dereferencedVariableAccess.DereferencedVariableAccess;
+    readonly accessKind: AccessKind;
     readonly kind = "resolved";
-    constructor(operator: FoundAnonymousDeclaration<types.DereferenceOperator>, access: dereferencedVariableAccess.DereferencedVariableAccess);
+    constructor(operator: FoundAnonymousDeclaration<types.DereferenceOperator>, accessKind: AccessKind);
 }
 declare class Meaning_unresolved {
     readonly diagnostic: Diagnostic | undefined;

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

@@ -18,6 +18,7 @@ export declare class DiagnosticCollector {
     constructor(analyzer: Analyzer, sourceFile: project.SourceFile, cancellationToken: CancellationToken | undefined);
     collect(): Promise<Diagnostic[]>;
     private collectNodeDiagnostics;
+    private checkCallExpression;
     private addNotTranslatedPackageMembersDiagnostics;
     private collectNotTranslatedPackageMembers;
     private addNotTranslatedTypeMembersDiagnostics;
@@ -27,8 +28,10 @@ export declare class DiagnosticCollector {
     private checkPackageMethodDeclaration;
     private checkPackageVariableGetterDeclaration;
     private checkPackageVariableSetterDeclaration;
+    private checkTypeConstructorDeclaration;
     private checkTypeMethodDeclaration;
     private checkOperatorDeclaration;
+    private checkTypeVariableDeclaration;
     private checkTypeVariableGetterDeclaration;
     private checkTypeVariableSetterDeclaration;
     private checkTypeIndexedGetterDeclaration;

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

@@ -1,4 +1,6 @@
 import * as tree from '../tree/index.js';
+import { ModifierFlags } from './ModifierFlags.js';
 type NodeWithModifiers = tree.PackageMemberDeclaration | tree.TypeMemberDeclaration;
 export declare function findModifier(node: NodeWithModifiers, modifierKeywordKind: tree.ModifierKeywordKind): tree.Modifier | undefined;
+export declare function createDeclaredModifierFlags(node: NodeWithModifiers): ModifierFlags;
 export {};

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

@@ -1,13 +1,12 @@
-import { Name } from '../common/index.js';
+import { AccessKind, Name } from '../common/index.js';
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
-import { NamedTypeEntity, PackageAliasEntity, VariableEntity, VariantEntity } from '../entities/index.js';
+import { NamedTypeEntity, PackageAliasEntity, VariableEntity } 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 * as scope from './Scope.js';
-import * as variableAccess from './VariableAccess.js';
 import { Analyzer, TargetTypeHint } from './index.js';
 export declare class Resolver {
     private readonly _semanticContext;
@@ -25,19 +24,22 @@ export declare class Resolver {
 export declare class ResolutionResult {
     readonly meaning: Meaning;
     readonly diagnostic?: Diagnostic | undefined;
-    constructor(meaning: Meaning, diagnostic?: Diagnostic | undefined);
-}
-export type Meaning = Meaning_variantAccess | Meaning_variableAccess | Meaning_methodAccess | Meaning_operatorAccess | Meaning_packageNameSegmentAccess | Meaning_packageAliasAccess | Meaning_typeAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
-declare class Meaning_variantAccess {
-    readonly variant: FoundNamedDeclaration<VariantEntity>;
-    readonly kind = "variant-access";
-    constructor(variant: FoundNamedDeclaration<VariantEntity>);
+    /**
+     * Может ли измениться результат, если посчитать его с другим целевым типом?
+     */
+    readonly dependsOnTargetType: boolean;
+    constructor(meaning: Meaning, diagnostic?: Diagnostic | undefined, 
+    /**
+     * Может ли измениться результат, если посчитать его с другим целевым типом?
+     */
+    dependsOnTargetType?: boolean);
 }
+export type Meaning = Meaning_variableAccess | Meaning_methodAccess | Meaning_operatorAccess | Meaning_packageNameSegmentAccess | Meaning_packageAliasAccess | Meaning_typeAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
 declare class Meaning_variableAccess {
     readonly variable: FoundNamedDeclaration<AccessedVariable>;
-    readonly access: variableAccess.VariableAccess;
+    readonly accessKind: AccessKind;
     readonly kind = "variable-access";
-    constructor(variable: FoundNamedDeclaration<AccessedVariable>, access: variableAccess.VariableAccess);
+    constructor(variable: FoundNamedDeclaration<AccessedVariable>, accessKind: AccessKind);
 }
 declare class Meaning_methodAccess {
     readonly candidates: readonly FoundNamedDeclaration<AccessedMethod>[];

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

@@ -1,8 +1,8 @@
+import { AccessKind } from '../common/index.js';
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import { IndexedAccessExpression } from '../tree/index.js';
 import * as types from '../types/index.js';
 import { FoundAnonymousDeclaration } from './FoundDeclaration.js';
-import * as indexedAccess from './IndexedAccess.js';
 import { Analyzer } from './index.js';
 export declare class Resolver {
     private readonly _analyzer;
@@ -10,20 +10,25 @@ export declare class Resolver {
     private readonly _semanticContext;
     private get semanticContext();
     constructor(_analyzer: Analyzer, _node: IndexedAccessExpression);
-    resolve(): Meaning;
+    resolve(): ResolutionResult;
     private getArgumentsRangeWithBrackets;
     private convertSyntacticAccessKind;
 }
+export declare class ResolutionResult {
+    readonly meaning: Meaning;
+    readonly diagnostic?: Diagnostic | undefined;
+    constructor(meaning: Meaning, diagnostic?: Diagnostic | undefined);
+}
 export type Meaning = Meaning_resolved | Meaning_unresolved;
 declare class Meaning_resolved {
-    readonly indexer: FoundAnonymousDeclaration<types.Indexer>;
-    readonly access: indexedAccess.IndexedAccess;
+    readonly candidates: readonly FoundAnonymousDeclaration<types.Indexer>[];
+    readonly suitableIndexers: readonly FoundAnonymousDeclaration<types.Indexer>[];
+    readonly accessKind: AccessKind;
     readonly kind = "resolved";
-    constructor(indexer: FoundAnonymousDeclaration<types.Indexer>, access: indexedAccess.IndexedAccess);
+    get singleSuitableIndexer(): FoundAnonymousDeclaration<types.Indexer> | undefined;
+    constructor(candidates: readonly FoundAnonymousDeclaration<types.Indexer>[], suitableIndexers: readonly FoundAnonymousDeclaration<types.Indexer>[], accessKind: AccessKind);
 }
 declare class Meaning_unresolved {
-    readonly diagnostic: Diagnostic | undefined;
     readonly kind = "unresolved";
-    constructor(diagnostic: Diagnostic | undefined);
 }
 export {};

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

@@ -1,6 +1,6 @@
-import { PackageLocale, Name } from '../common/index.js';
-import { AliasTypeEntity, MethodEntity, PackageAliasEntity, PackageEntity, PackageMethodTypeEntity, PackageStructuredTypeEntity, PackageVariantTypeEntity, TypeEntity, TypeParameterEntity, VariableEntity, VariantEntity, VariantTypeEntity } from '../entities/index.js';
-import { AnalyzedTranslationPackage, TranslatedTypeEntityMembers, TranslatedVariants } from './AnalyzedTranslationPackage.js';
+import { Name, PackageLocale } from '../common/index.js';
+import { AliasTypeEntity, MethodEntity, PackageAliasEntity, PackageEntity, PackageMethodTypeEntity, PackageStructuredTypeEntity, PackageVariantTypeEntity, TypeEntity, TypeParameterEntity, VariableEntity } from '../entities/index.js';
+import { AnalyzedTranslationPackage, TranslatedTypeEntityMembers } from './AnalyzedTranslationPackage.js';
 export declare class LocalizationContext {
     readonly originalLocale: PackageLocale;
     private readonly _translationPackageByTranslated;
@@ -9,7 +9,6 @@ export declare class LocalizationContext {
     getTranslationPackage(packageEntity: PackageEntity): AnalyzedTranslationPackage | undefined;
     getTranslationLocale(packageEntity: PackageEntity): PackageLocale;
     getTranslatedTypeEntityMembers(typeEntity: TypeEntity): TranslatedTypeEntityMembers | undefined;
-    getTranslatedVariants(typeEntity: VariantTypeEntity): TranslatedVariants | undefined;
     getEntityName(entity: NamedEntity): Name;
 }
-export type NamedEntity = VariableEntity | VariantEntity | PackageVariantTypeEntity | MethodEntity | TypeParameterEntity | PackageMethodTypeEntity | PackageStructuredTypeEntity | PackageAliasEntity | AliasTypeEntity;
+export type NamedEntity = VariableEntity | PackageVariantTypeEntity | MethodEntity | TypeParameterEntity | PackageMethodTypeEntity | PackageStructuredTypeEntity | PackageAliasEntity | AliasTypeEntity;

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

@@ -7,13 +7,13 @@ export declare class Lookup {
     private readonly _scopeChain;
     private readonly _hidingMatcher;
     constructor(_scopeChain: ScopeChain, _hidingMatcher: IEntityHidingMatcher);
-    getTypesOrContainersWithTypes(): FoundNamedDeclaration<TypeOrContainerWithTypes>[];
-    getTypesOrContainersWithTypesByName(name: SearchName): FoundNamedDeclaration<TypeOrContainerWithTypes>[];
-    getNamedDeclarations(): FoundNamedDeclaration<NamedDeclaration>[];
-    getNamedDeclarationsByName(name: SearchName): FoundNamedDeclaration<NamedDeclaration>[];
-    getOperators(): FoundAnonymousDeclaration<types.Operator>[];
-    getOperatorsByKind(kind: OperatorKind): FoundAnonymousDeclaration<types.Operator>[];
-    getTypeExtensionsByType(type: TypeEntity): TypeExtensionEntity[];
+    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>[];
+    getTypeExtensionsByType(type: TypeEntity): readonly TypeExtensionEntity[];
     private checkTypeOrPackageDeclarationShadowing;
     private checkNamedDeclarationShadowing;
     private checkOperatorShadowing;
@@ -23,5 +23,6 @@ export declare class ScopeChain {
     private constructor();
     addFirst(scope: IScope): ScopeChain;
     toQuery(): Query<IScope>;
+    enumerateScopes(): Iterable<IScope>;
     static withSingleScope(scope: IScope): ScopeChain;
 }

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

@@ -0,0 +1,16 @@
+export declare enum ModifierFlags {
+    None = 0,
+    HiddenWithoutLevel = 1,
+    HiddenInType = 2,
+    HiddenInHierarchy = 4,
+    HiddenInFile = 8,
+    HiddenInPackage = 16,
+    Basic = 32,
+    Static = 64,
+    Redefinable = 128,
+    Abstract = 256,
+    Redefined = 512,
+    Async = 1024,
+    Const = 2048,
+    NotComputed = 4096
+}

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

@@ -9,7 +9,6 @@ export declare class NamedTypeSpecifierResolver {
     private readonly _node;
     constructor(_analyzer: Analyzer, _node: NamedTypeSpecifier);
     resolve(): NamedTypeSpecifierResolutionResult;
-    private convertNamedTypeToTypeDeclaration;
     private resolveTypeOverload;
 }
 export declare class NamedTypeSpecifierResolutionResult {

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

@@ -15,6 +15,7 @@ export declare class NodeTypeUtils {
 export type PackageTypeDeclaration = tree.PackageAliasTypeDeclaration | tree.PackageMethodTypeDeclaration | tree.PackageStructuredTypeDeclaration | tree.PackageVariantTypeDeclaration;
 export type StructuredTypeDeclaration = tree.PackageStructuredTypeDeclaration | tree.AnonymousStructuredTypeDeclaration;
 export type VariantTypeDeclaration = tree.PackageVariantTypeDeclaration | tree.AnonymousVariantTypeDeclaration;
+export declare function isVariantTypeDeclaration(node: tree.Node): node is VariantTypeDeclaration;
 export type MethodTypeDeclaration = tree.PackageMethodTypeDeclaration | tree.AnonymousMethodTypeDeclaration;
 export type MethodDeclaration = tree.PackageMethodDeclaration | tree.NestedMethodDeclaration | tree.TypeMethodDeclaration;
 export type TypeDeclaration = StructuredTypeDeclaration | VariantTypeDeclaration | MethodTypeDeclaration | tree.PackageAliasTypeDeclaration | tree.TypeParameterDeclaration;

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

@@ -5,8 +5,8 @@ import { Analyzer } from './Analyzer.js';
 export declare class Resolver<TCandidate extends ICandidate<TValueParameter>, TValueParameter extends IValueParameter> {
     private readonly _analyzer;
     constructor(_analyzer: Analyzer);
-    resolveByCallExpression(candidates: Iterable<TCandidate>, node: CallExpression): Iterable<TCandidate>;
-    resolveByTargetType(candidates: Iterable<TCandidate>, targetType: types.MethodType): Iterable<TCandidate>;
+    resolveByCallExpression(candidates: readonly TCandidate[], node: CallExpression): readonly TCandidate[];
+    resolveByTargetType(candidates: readonly TCandidate[], targetType: types.MethodType): readonly TCandidate[];
 }
 export interface ICandidate<TValueParameter extends IValueParameter> {
     getValueParameters(): readonly TValueParameter[];

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

@@ -1,10 +1,10 @@
 import { Analyzer } from '../analysis/index.js';
-import * as matcher from './CallArgumentsToParametersMatcher.js';
-export declare class OverloadResolver<TSignature extends matcher.ISignature<TParameter>, TParameter extends matcher.ISignatureParameter, TCallArgument extends matcher.ICallArgument> {
+import * as matcher from './ArgumentsToParametersMatcher.js';
+export declare class OverloadResolver<TSignature extends matcher.ISignature<TParameter>, TParameter extends matcher.ISignatureParameter, TArgument extends matcher.IArgument> {
     private readonly _analyzer;
     private readonly _signatures;
-    private readonly _callArguments;
-    constructor(_analyzer: Analyzer, _signatures: readonly TSignature[], _callArguments: readonly TCallArgument[]);
+    private readonly _arguments;
+    constructor(_analyzer: Analyzer, _signatures: readonly TSignature[], _arguments: readonly TArgument[]);
     resolveOverload(): TSignature[];
     private tryChooseBestSignature;
     private chooseBetterTargetType;

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

@@ -1,6 +1,5 @@
-import { Query, SearchName } from '../common/index.js';
-import { NamedMember } from '../entities/PackageMembers.js';
-import { IEntityHidingMatcher, PackageEntity, TypeEntity, TypeExtensionEntity } from '../entities/index.js';
+import { SearchName } from '../common/index.js';
+import { IEntityHidingMatcher, NamedPackageMemberEntity, PackageEntity, TypeEntity, TypeExtensionEntity } from '../entities/index.js';
 import { FoundNamedDeclaration } from './FoundDeclaration.js';
 import { LocalizationContext } from './LocalizationContext.js';
 export declare class PackageMemberLookup {
@@ -9,7 +8,7 @@ export declare class PackageMemberLookup {
     private readonly _translatedMembers;
     private get translatedMembers();
     constructor(_package: PackageEntity, _localizationContext: LocalizationContext | undefined);
-    getNamedMembers(hidingMatcher?: IEntityHidingMatcher): Query<FoundNamedDeclaration<NamedMember>>;
-    getNamedMembersByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher): Query<FoundNamedDeclaration<NamedMember>>;
-    getTypeExtensions(type: TypeEntity, hidingMatcher?: IEntityHidingMatcher): Query<TypeExtensionEntity>;
+    getNamedMembers(hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<NamedPackageMemberEntity>[];
+    getNamedMembersByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<NamedPackageMemberEntity>[];
+    getTypeExtensions(type: TypeEntity, hidingMatcher?: IEntityHidingMatcher): readonly TypeExtensionEntity[];
 }

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

@@ -1,11 +1,11 @@
+import { AccessKind } from '../common/index.js';
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
-import { PackageTypeEntity, PackageVariableEntity, VariantEntity } from '../entities/index.js';
+import { 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 * as variableAccess from './VariableAccess.js';
 import { Analyzer, TargetTypeHint } from './index.js';
 export declare class Resolver {
     private readonly _semanticContext;
@@ -31,14 +31,22 @@ export declare class Resolver {
 export declare class ResolutionResult {
     readonly meaning: Meaning;
     readonly diagnostic?: Diagnostic | undefined;
-    constructor(meaning: Meaning, diagnostic?: Diagnostic | undefined);
+    /**
+     * Может ли измениться результат, если посчитать его с другим целевым типом?
+     */
+    readonly dependsOnTargetType: boolean;
+    constructor(meaning: Meaning, diagnostic?: Diagnostic | undefined, 
+    /**
+     * Может ли измениться результат, если посчитать его с другим целевым типом?
+     */
+    dependsOnTargetType?: boolean);
 }
-export type Meaning = Meaning_packageVariableAccess | Meaning_packageMethodAccess | Meaning_packageTypeAccess | Meaning_packageNameSegmentAccess | Meaning_variantAccess | 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_unresolved;
 declare class Meaning_packageVariableAccess {
     readonly variable: FoundNamedDeclaration<PackageVariableEntity>;
-    readonly access: variableAccess.VariableAccess;
+    readonly accessKind: AccessKind;
     readonly kind = "package-variable-access";
-    constructor(variable: FoundNamedDeclaration<PackageVariableEntity>, access: variableAccess.VariableAccess);
+    constructor(variable: FoundNamedDeclaration<PackageVariableEntity>, accessKind: AccessKind);
 }
 declare class Meaning_packageMethodAccess {
     readonly candidates: readonly FoundNamedDeclaration<AccessedMethod>[];
@@ -59,18 +67,12 @@ declare class Meaning_packageNameSegmentAccess {
     readonly kind = "package-name-segment-access";
     constructor(packageTreeNode: PackageNameTreeNode);
 }
-declare class Meaning_variantAccess {
-    readonly type: types.VariantType;
-    readonly variant: FoundNamedDeclaration<VariantEntity>;
-    readonly kind = "variant-access";
-    constructor(type: types.VariantType, variant: FoundNamedDeclaration<VariantEntity>);
-}
 declare class Meaning_staticVariableAccess {
     readonly type: types.Type;
     readonly variable: FoundNamedDeclaration<types.Variable>;
-    readonly access: variableAccess.VariableAccess;
+    readonly accessKind: AccessKind;
     readonly kind = "static-variable-access";
-    constructor(type: types.Type, variable: FoundNamedDeclaration<types.Variable>, access: variableAccess.VariableAccess);
+    constructor(type: types.Type, variable: FoundNamedDeclaration<types.Variable>, accessKind: AccessKind);
 }
 declare class Meaning_staticMethodAccess {
     readonly type: types.Type;
@@ -82,9 +84,9 @@ declare class Meaning_staticMethodAccess {
 }
 declare class Meaning_instanceVariableAccess {
     readonly variable: FoundNamedDeclaration<types.Variable>;
-    readonly access: variableAccess.VariableAccess;
+    readonly accessKind: AccessKind;
     readonly kind = "instance-variable-access";
-    constructor(variable: FoundNamedDeclaration<types.Variable>, access: variableAccess.VariableAccess);
+    constructor(variable: FoundNamedDeclaration<types.Variable>, accessKind: AccessKind);
 }
 declare class Meaning_instanceMethodAccess {
     readonly candidates: readonly FoundNamedDeclaration<AccessedMethod>[];