@artel/artc 0.6.26017 → 0.6.26019

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

@@ -1,132 +1,66 @@
-import ts from 'typescript';
-import { DisplayableOrPrimitive, Name, PackageLocale, Query, Range, TaskController } from '../common/index.js';
+import { Cached, DisplayableOrPrimitive, Option, PackageLocale, Range, TaskController } from '../common/index.js';
 import { Diagnostic, DiagnosticAcceptor, DiagnosticLocation } from '../diagnostic/Diagnostic.js';
 import { DiagnosticCode } from '../diagnostic/DiagnosticCode.js';
 import { DiagnosticFlags, DiagnosticKind } from '../diagnostic/DiagnosticData.js';
-import { WithDiagnostics } from '../diagnostic/WithDiagnostics.js';
-import { BinaryOperatorKind } from '../entities/OperatorKind.js';
 import * as e from '../entities/index.js';
 import * as project from '../project/index.js';
 import { PackageName, PlatformKind, SourcePackage } from '../project/index.js';
 import * as tree from '../tree/index.js';
-import { TsInteropContext, TsProgramState } from '../ts-interop/TsInteropContext.js';
+import { TsInteropContext } from '../ts-interop/TsInteropContext.js';
 import * as types from '../types/index.js';
 import { TypeFactory } from '../types/index.js';
 import { AccessedFunction } from './AccessedFunction.js';
-import { AnalyzedTranslationPackage } from './AnalyzedTranslationPackage.js';
-import { ArgumentToParameterMatchResult, MatchResultParameter } from './ArgumentToParameterMatchResult.js';
-import * as autotypeCallExpressionMeaning from './AutotypeCallExpressionMeaning.js';
-import * as baseExpressionMeaning from './BaseExpressionMeaning.js';
-import * as callExpressionMeaning from './CallExpressionMeaning.js';
-import { DeclarationsUsageMap } from './DeclarationsUsageCounter.js';
-import * as dereferenceExpressionMeaning from './DereferenceExpressionMeaning.js';
+import { DeclarationsUsageMap } from './DeclarationsUsageMap.js';
 import { DiagnosticArgumentFactory } from './DiagnosticArgumentFactory.js';
-import * as identifierExpressionResolution from './IdentifierExpressionMeaning.js';
-import { ImportedPackageNameTree, PackageNameTreeNode } from './ImportedPackageNameTree.js';
-import * as indexedAccessExpressionMeaning from './IndexedAccessExpressionMeaning.js';
-import * as memberAccessExpressionResolution from './MemberAccessExpressionMeaning.js';
-import { ModifierFlags } from './ModifierFlags.js';
-import { NamedTypeSpecifierResolutionResult } from './NamedTypeSpecifierResolver.js';
-import { AnonymousStructuredTypeDeclaration, DereferencedVariableAccessorDeclaration, FieldAccessorDeclaration, FunctionDeclaration, FunctionTypeDeclaration, GetterDeclaration, IndexedElementAccessorDeclaration, PackageStructuredTypeDeclaration, PackageVariableAccessorDeclaration, RegularOrBlockFunctionLiteral, SetterDeclaration, StructuredTypeDeclaration, TypeWithMembersDeclaration } from './NodeTypeUtils.js';
-import * as objectExpressionMeaning from './ObjectExpressionMeaning.js';
-import { OwnAndBaseConstructorCallsCheckResult } from './OwnAndBaseConstructorCallsChecker.js';
-import * as ownConstructorCallExpressionMeaning from './OwnConstructorCallExpressionMeaning.js';
-import { ReachabilityChecker } from './ReachabilityChecker.js';
-import { ReductionSourceMemberFinder } from './ReductionSourceMemberFinder.js';
-import { ReservedNameKind } from './ReservedNameDictionary.js';
+import { PackageImportInfo } from './ImportedPackageNameTree.js';
+import { NodeOrDiagnosticLocation } from './NodeOrDiagnosticLocation.js';
+import { OverridableTypeMemberEntity } from './OverridableTypeMember.js';
 import { ResolvedImplementationPackage } from './ResolvedImplementationPackage.js';
-import { ResolvedTextTranslationPackage } from './ResolvedTextTranslationPackage.js';
-import * as tags from './Tag.js';
-import * as tagMeaning from './TagMeaning.js';
-import { TypeWithMembersOrTypeExtensionDeclaration } from './TreeQuery.js';
+import { SignatureComparisonOptions } from './SignatureComparisonOptions.js';
+import { TsInteropInputs } from './TsInteropInputs.js';
+import { TypeAssignabilityFlags } from './TypeAssignabilityFlags.js';
 import { TypeMemberImplementationCheckResult } from './TypeMemberImplementationChecker.js';
 import { TypeMemberLookupContext } from './TypeMemberLookup.js';
-import { NodeOrDiagnosticLocation } from './Utils.js';
-import * as controlFlow from './control-flow/index.js';
-import { WellKnownDeclarations } from './index.js';
-import * as semanticContext from './semantic-context/index.js';
-export declare class Analyzer {
-    readonly compilation: project.Compilation;
+import { WellKnownDeclarations } from './WellKnownDeclarations.js';
+import { Analyzer as AnalyzerA } from './a/Analyzer.js';
+import { Analyzer as AnalyzerM } from './m/Analyzer.js';
+/**
+ * Базовый анализатор, содержащий логику, не зависящую от диалекта.
+ */
+export declare abstract class Analyzer {
+    abstract readonly dialectA: AnalyzerA;
+    abstract readonly dialectM: AnalyzerM;
+    /**
+     * Поскольку класс Analyzer имеет несколько производных классов, общее состояние анализаторов вынесено в объект,
+     * который создаётся в одном экземпляре в анализаторе диалекта А.
+     */
+    private readonly state;
+    get compilation(): project.Compilation;
     /**
      * Пакет с именем 'Артель', содержащий стандартные типы.
      */
-    readonly systemPackage: e.PackageEntity;
+    get systemPackage(): e.PackageEntity;
     /**
      * Стандартные объявления на языке оригинала. Для получения стандартных объявлений на желаемом языке используйте
      * {@link getLocalizedWellKnownDeclarations}.
      */
-    readonly originalWellKnownDeclarations: WellKnownDeclarations;
+    get originalWellKnownDeclarations(): WellKnownDeclarations;
     /**
      * Стандартные типы на языке оригинала. Для получения стандартных типов на желаемом языке используйте
      * {@link getLocalizedStandardTypes}.
      */
-    readonly originalStandardTypes: types.StandardTypes;
-    readonly typeFactory: TypeFactory;
-    readonly type: Type;
-    readonly returnType: ReturnType;
-    readonly entity: Entity;
-    readonly resultLocalVariableEntity: ResultLocalVariableEntity;
-    readonly valueLocalVariableEntity: ValueLocalVariableEntity;
-    readonly semanticContext: semanticContext.SemanticContextBuilder;
-    readonly argumentToParameterMatchResult: ArgumentToParameterMatchResult;
-    readonly overriddenMember: OverriddenMember;
-    readonly tags: Tags;
-    readonly implementation: ImplementationEntity;
-    readonly packageImports: PackageImports;
-    readonly typeUtils: TypeUtils;
-    readonly signatureComparer: SignatureComparer;
-    readonly conflictsCheck: ConflictsCheck;
-    readonly typeAssignabilityCheck: TypeAssignabilityCheck;
-    readonly reachabilityChecker: ReachabilityChecker;
-    readonly reductionSourceMemberFinder: ReductionSourceMemberFinder;
-    private readonly tsInteropInputs;
-    private readonly targetType;
-    private readonly tsInterop_;
-    private readonly memberAccessExpressionResolutionResults;
-    private readonly memberAccessExpressionResolutionResultsFirstStage;
-    private readonly callExpressionResolutionResults;
-    private readonly indexedAccessExpressionResolutionResults;
-    private readonly dereferenceExpressionMeanings;
-    private readonly ownConstructorCallExpressionMeanings;
-    private readonly autotypeCallExpressionResolutionResults;
-    private readonly identifierExpressionResolutionResults;
-    private readonly identifierExpressionResolutionResultsFirstStage;
-    private readonly tagResolutionResults;
-    private readonly objectExpressionResolutionResults;
-    private readonly baseExpressionResolutionResultsFirstStage;
-    private readonly baseExpressionResolutionResults;
-    private readonly namedTypeSpecifierResolutionResults;
-    private readonly prefixUnaryExpressionOperatorResolutionResults;
-    private readonly binaryExpressionUserDefinableOperatorResolutionResults;
-    private readonly assignmentStatementOperatorResolutionResults;
-    private readonly analyzedTranslationPackages;
-    private readonly resolvedTextTranslationPackages;
-    private textTranslationPackagesByTargetPackage;
-    private primaryTextTranslationPackageByTargetPackage;
-    private resolvedLocalizableTexts;
-    private readonly resolvedImplementationPackagesByPlatform;
-    private readonly isFunctionGeneratorCheckResults;
-    private readonly namedDeclarationsUsageCountResults;
-    private readonly packageAndStaticVariablesInitializationDiagnostics;
-    private readonly controlFlowGraphs;
-    private sideDiagnosticAcceptor;
-    private readonly sideDiagnosticsByFile;
-    private readonly sideDiagnosticsWithoutFile;
-    private readonly sourcePackageMemberConflictsDiagnostics;
-    private readonly notExplicitlyImplementedAbstractTypeMembers;
-    private readonly typeMemberImplementationCheckResults;
-    private originalPackageEntitiesByNameKey;
-    private packageEntitiesByNameKey;
-    private readonly localizedWellKnownDeclarations;
-    private readonly localizedStandardTypes;
-    private readonly ownAndBaseConstructorCallsCheckResults;
-    private readonly expressionCanBeUsedInForLoopCheckResults;
-    private readonly nameByIdentifierText;
+    get originalStandardTypes(): types.StandardTypes;
+    get typeFactory(): TypeFactory;
+    get implementation(): ImplementationEntity;
+    get typeUtils(): TypeUtils;
+    get signatureComparer(): SignatureComparer;
+    get conflictsCheck(): ConflictsCheck;
+    get typeAssignabilityCheck(): TypeAssignabilityCheck;
+    get overriddenMember(): OverriddenMember;
     get tsInterop(): TsInteropContext;
-    constructor(compilation: project.Compilation, tsInteropInputs: TsInteropInputs);
+    constructor(state: CommonAnalyzerState);
+    analyzeSourceFile(sourceFile: project.SourceFile, taskController: TaskController): Promise<readonly Diagnostic[]>;
     getProjectSourceFile(node: tree.SourceFile): project.SourceFile;
-    checkExpressionCanBeUsedInForLoop(node: tree.Expression): WithDiagnostics<ExpressionCanBeUsedInForLoopCheckResult>;
-    expressionCanBeReferenced(node: tree.Expression): boolean;
     isEnumeratorMethodSignature(entity: e.MethodEntity): boolean;
     ifTypeEnumerableThenElementType(type: types.Type): types.Type | undefined;
     ifTypeEnumeratorThenElementType(type: types.Type): types.Type | undefined;
@@ -135,92 +69,21 @@ export declare class Analyzer {
     ifTypeReferenceThenReferencedType(type: types.Type): types.Type | undefined;
     isTypeAssignableTo(source: types.Type, target: types.Type): boolean;
     getTypeAssignabilityFlags(source: types.Type, target: types.Type): TypeAssignabilityFlags;
-    checkBlockCallsAsyncMethods(node: tree.StatementBlock | tree.FunctionBlock): boolean;
-    getSyntacticAccessKind(node: tree.Expression): SyntacticAccessKind;
-    getEntityContainingTypeMemberDeclaration(node: tree.TypeMemberDeclaration): e.TypeWithMembersOrExtensionEntity;
-    getTargetTypeOfExpression(node: tree.Expression, analysisOptions?: ExpressionAnalysisOptions): types.Type | undefined;
     getUnambiguousTargetFunctionType(targetType: types.Type | undefined): types.FunctionType | undefined;
     getUnambiguousTargetArrayType(targetType: types.Type | undefined): types.Type | undefined;
     getUnambiguousTargetReferenceType(targetType: types.Type | undefined): types.Type | undefined;
-    resolveMemberAccessExpressionFirstStage(node: tree.MemberAccessExpression): memberAccessExpressionResolution.MeaningStage1;
-    resolveMemberAccessExpression(node: tree.MemberAccessExpression, analysisOptions?: ExpressionAnalysisOptions): memberAccessExpressionResolution.Meaning;
-    resolveCallExpression(node: tree.CallExpression, analysisOptions?: ExpressionAnalysisOptions): callExpressionMeaning.Meaning;
-    getRespectiveParameter(node: tree.Argument): MatchResultParameter | undefined;
-    resolveIndexedAccessExpression(node: tree.IndexedAccessExpression): indexedAccessExpressionMeaning.Meaning;
-    resolveDereferenceExpression(node: tree.DereferenceExpression): dereferenceExpressionMeaning.Meaning;
-    resolveAutotypeCallExpression(node: tree.AutotypeCallExpression, analysisOptions?: ExpressionAnalysisOptions): autotypeCallExpressionMeaning.ResolutionResult;
-    resolveOwnConstructorCallExpression(node: tree.OwnConstructorCallExpression): ownConstructorCallExpressionMeaning.Meaning;
-    resolveIdentifierExpressionFirstStage(node: tree.IdentifierExpression): identifierExpressionResolution.MeaningStage1;
-    resolveIdentifierExpression(node: tree.IdentifierExpression, analysisOptions?: ExpressionAnalysisOptions): identifierExpressionResolution.Meaning;
-    resolveTag(node: tree.Tag): tagMeaning.ResolutionResult;
-    resolveObjectExpression(node: tree.ObjectExpression): objectExpressionMeaning.Meaning;
-    resolveBaseExpressionFirstStage(node: tree.BaseExpression): baseExpressionMeaning.MeaningStage1;
-    resolveBaseExpression(node: tree.BaseExpression): baseExpressionMeaning.Meaning;
-    /**
-     * Проверяет, является ли выражение цепочкой доступов через `?`, заканчивающейся выражением, тип которого допускает
-     * `пусто`.
-     *
-     * Пример:
-     * ```artel
-     * а?.б
-     * а?[1]
-     * а?^
-     * а?()
-     * (а)?.б
-     * ```
-     *
-     * где тип переменной `а` допускает `пусто`.
-     */
-    isExpressionValidOptionalChaining(node: tree.Expression): boolean;
-    /**
-     * Проверяет, является ли выражение цепочкой доступов через `?`.
-     *
-     * Пример:
-     * ```artel
-     * а?.б
-     * а?[1]
-     * а?^
-     * а?()
-     * (а?.б)
-     * ```
-     */
-    isExpressionOptionalChainingSyntactically(node: tree.Expression): boolean;
-    isExpressionValidOutermostOptionalChaining(node: tree.Expression): boolean;
-    includeNullToTypeIfExpressionValidOutermostOptionalChaining(type: types.Type, node: tree.Expression): types.Type;
-    checkIdentifierNameIsReserved(name: Name, locale: PackageLocale): ReservedNameKind | undefined;
-    getReservedName(reservedNameKind: ReservedNameKind, locale: PackageLocale): Name;
-    createNameFromIdentifier(node: tree.Identifier): Name;
     getImplicitBaseTypeForStructuredType(entity: e.StructuredTypeEntity): types.StructuredType | undefined;
     getImplicitBaseTypeForReducedType(entity: e.ReducedTypeEntity): types.StructuredType;
     getImplicitBaseTypeForVariantType(locale: PackageLocale): types.StructuredType;
     getImplicitBaseTypeForFunctionType(locale: PackageLocale): types.StructuredType;
-    resolveNamedTypeSpecifier(node: tree.NamedTypeSpecifier): NamedTypeSpecifierResolutionResult;
-    getDenotedType(expression: tree.Expression): types.Type | undefined;
-    isExpressionDenotingType(expression: tree.Expression): boolean;
-    getDenotedPackageAlias(expression: tree.Expression): e.PackageAliasEntity | undefined;
-    getDenotedFunction(expression: tree.Expression): ExpressionDenotesFunctionCheckResult | undefined;
-    isExpressionDenotingFunction(expression: tree.Expression): boolean;
-    getDenotedPackageNameTreeNode(expression: tree.Expression): PackageNameTreeNode | undefined;
-    /**
-     * Функция считается генератором, если:
-     * - Использует команду `выдать`.
-     * - Не использует команду `выдать`, но её возвращаемым типом является `Перебираемый` или `Перебор`, она не
-     *   возвращает значение и не использует переменную `результат` (использование команды `вернуть` без указания
-     *   возвращаемого значения допустимо). В таком случае это генератор, не возвращающий ни одного элемента.
-     */
-    isFunctionGenerator(node: FunctionDeclaration): boolean;
-    allAspectsOfType(type: types.Type): Iterable<types.StructuredType>;
-    checkTypeIsBasedOnAspect(type: types.Type, aspectEntity: e.StructuredTypeEntity): boolean;
-    resolvePrefixUnaryExpressionUserDefinableOperator(node: tree.PrefixUnaryExpression): types.Method | undefined;
-    resolveBinaryExpressionUserDefinableOperator(node: tree.BinaryExpression, operatorKind: BinaryOperatorKind): types.Method | undefined;
-    resolveCompoundAssignmentStatementOperator(node: tree.AssignmentStatement, operatorKind: BinaryOperatorKind): types.Method | undefined;
-    classifyBinaryExpressionOperator(operator: tree.BinaryExpressionOperator): BinaryExpressionOperatorClassificationResult;
-    getBinaryOperatorKindIfCompoundAssignmentOperator(operator: tree.AssignmentStatementOperator): BinaryOperatorKind | undefined;
+    getSourcePackageEntity(pkg: SourcePackage): e.PackageEntity;
+    getProgramPackageEntity(pkg: project.ProgramPackage): e.ProgramPackageEntity;
+    getTranslationPackageEntity(pkg: project.TranslationPackage): e.NameTranslationPackageEntity;
+    getTextTranslationPackageEntity(pkg: project.TextTranslationPackage): e.TextTranslationPackageEntity;
     getOriginalPackageEntities(): readonly e.PackageEntity[];
     getPackageEntities(): readonly e.PackageEntity[];
     getOriginalPackageEntityByName(name: PackageName): e.PackageEntity | undefined;
     getPackageEntityByName(name: PackageName): e.PackageEntity | undefined;
-    getAnalyzedTranslationPackages(): readonly AnalyzedTranslationPackage[];
     createFunctionTypeInvokeMethod(entity: e.FunctionTypeEntity): e.MethodEntity;
     /**
      * Преобразует тип таким образом, чтобы он не мог содержать значение `пусто`.
@@ -265,19 +128,13 @@ export declare class Analyzer {
     excludeTypeFromUnion(initialType: types.Type, excludedType: types.Type): types.Type;
     isParameterVariadic(entity: e.VariableEntity): boolean;
     getDefaultTypeParameterConstraint(locale: PackageLocale): types.Type;
-    getAnalyzedTranslationPackageIfTargetResolved(package_: project.TranslationPackage): AnalyzedTranslationPackage | undefined;
-    resolveTextTranslationPackage(package_: project.TextTranslationPackage): ResolvedTextTranslationPackage | undefined;
-    findAnalyzedTranslationPackageForLocale(entity: e.PackageEntity, locale: PackageLocale): AnalyzedTranslationPackage | undefined;
     getLocalizedPackageWithLocale(originalPackageEntity: e.PackageEntity, locale: PackageLocale): e.PackageEntity | undefined;
-    enumerateAnalyzedTranslationPackages(): Query<AnalyzedTranslationPackage>;
-    enumerateResolvedTextTranslationPackages(): Query<ResolvedTextTranslationPackage>;
     getResolvedImplementationPackagesByPlatform(interfacePackage: e.PackageEntity): ReadonlyMap<PlatformKind, ResolvedImplementationPackage> | undefined;
     getResolvedImplementationPackageForInterfacePackage(interfacePackage: e.PackageEntity, platform: PlatformKind): ResolvedImplementationPackage | undefined;
     getResolvedImplementationPackage(implementationPackage: e.PackageEntity): ResolvedImplementationPackage | undefined;
-    getTextTranslationPackagesMap(): ReadonlyMap<e.PackageEntity, ResolvedTextTranslationPackage[]>;
-    getTextTranslationPackagesOfTargetPackage(targetPackage: e.PackageEntity): ResolvedTextTranslationPackage[] | undefined;
-    getPrimaryTextTranslationPackageOfTargetPackage(targetPackage: e.PackageEntity): ResolvedTextTranslationPackage | undefined;
-    resolveLocalizableTextOrTextTemplate(node: tree.LocalizableTextLiteral | tree.LocalizableTextTemplateLiteral): e.TextTranslationEntity | undefined;
+    getTextTranslationPackagesMap(): ReadonlyMap<e.PackageEntity, readonly e.TextTranslationPackageEntity[]>;
+    getTextTranslationPackagesOfTargetPackage(targetPackage: e.PackageEntity): readonly e.TextTranslationPackageEntity[] | undefined;
+    getPrimaryTextTranslationPackageOfTargetPackage(targetPackage: e.PackageEntity): e.TextTranslationPackageEntity | undefined;
     instantiateType(entity: e.TypeEntity, typeArguments: readonly types.Type[] | undefined): types.Type;
     instantiateTypeWithSubstitutions(entity: e.TypeEntity, substitutions: types.Substitutions): types.Type;
     instantiateTypeByIdentitySubstitution(entity: e.TypeEntity): types.Type;
@@ -288,295 +145,57 @@ export declare class Analyzer {
     instantiateTypeMemberByIdentitySubstitution(entity: e.ConstructorEntity): types.Constructor;
     instantiateTypeMemberByIdentitySubstitution(entity: e.DestructorEntity): types.Destructor;
     instantiateTypeMemberByIdentitySubstitution(entity: e.TypeMemberEntity): types.TypeMember;
-    createPackageMemberHiding(node: tree.PackageMemberDeclaration, modifierFlags: ModifierFlags): e.EntityHidingLevel | undefined;
-    createTypeMemberHiding(node: tree.TypeMemberDeclaration, modifierFlags: ModifierFlags): e.EntityHidingLevel | undefined;
-    collectDeclarationsUsageOfPackages(targetPlatform: PlatformKind, taskController: TaskController): Promise<Map<tree.SourceFile, DeclarationsUsageMap>>;
+    collectDeclarationsUsageOfPackages(targetPlatform: PlatformKind, taskController: TaskController): Promise<ReadonlyMap<tree.SourceFile, DeclarationsUsageMap>>;
     getDeclarationsUsageOfSourceFile(sourceFile: tree.SourceFile, taskController: TaskController): Promise<DeclarationsUsageMap>;
-    getPackageAndStaticVariablesInitializationDiagnostics(pkg: SourcePackage, taskController: TaskController): Promise<readonly Diagnostic[]>;
-    createDefaultConstructors(typeEntity: e.StructuredTypeEntity, fields: readonly e.FieldEntity[]): readonly e.ConstructorEntity[];
-    createBackingPackageVariables(declaredPackageMembers: readonly e.NamedPackageMemberEntity[], pkg: e.PackageEntity): e.PackageVariableEntity[];
-    createBackingFields(declaredMembers: readonly e.NamedTypeMemberEntity[], type: e.TypeEntity): e.FieldEntity[];
     createDiagnostic(code: DiagnosticCode, nodeOrLocation: NodeOrDiagnosticLocation | undefined, formatArguments?: readonly DisplayableOrPrimitive[], kind?: DiagnosticKind, flags?: DiagnosticFlags): Diagnostic;
     createSourceFileRangeDiagnostic(code: DiagnosticCode, range: Range, nodeOrSourceFile: tree.Node | project.SourceFile, formatArguments?: readonly DisplayableOrPrimitive[], kind?: DiagnosticKind, flags?: DiagnosticFlags): Diagnostic;
     getNodeDiagnosticLocation(node: tree.Node): DiagnosticLocation;
-    getDeclaredTypeMemberEntities(node: tree.TypeMemberDeclarationBlock): DeclaredTypeMemberEntities;
     getBasicMethodOfOriginalTypeForBasicMethodOfAliasType(entity: e.MethodEntity): e.MethodEntity | undefined;
-    checkBodyOfBasicAliasTypeMethod(node: tree.MethodDeclaration, diagnostics?: DiagnosticAcceptor): {
-        basicMethodOfOriginalType: e.MethodEntity;
-    } | undefined;
-    getControlFlowGraph(sourceFile: project.SourceFile): controlFlow.GraphBuildResult;
     createAmbiguousEntityAccessDiagnostic(entities: readonly e.Entity[], nodeOrLocation: NodeOrDiagnosticLocation, diagnosticArgumentFactory?: DiagnosticArgumentFactory): Diagnostic;
     createAmbiguousFunctionAccessDiagnostic(functions: readonly AccessedFunction[], nodeOrLocation: NodeOrDiagnosticLocation): Diagnostic;
     createAmbiguousTypeMemberAccessDiagnostic(members: readonly types.TypeMember[], nodeOrLocation: NodeOrDiagnosticLocation): Diagnostic;
-    createAmbiguousNamedScopeDeclarationAccessDiagnostic(declarations: readonly semanticContext.NamedDeclaration[], nodeOrLocation: NodeOrDiagnosticLocation): Diagnostic;
     addSideDiagnostic(diagnostic: Diagnostic): void;
     getSideDiagnosticAcceptor(): DiagnosticAcceptor;
     accumulateSideDiagnosticForSourceFile(sourceFile: project.SourceFile, diagnostics: DiagnosticAcceptor): void;
-    validateSourcePackageMemberConflicts(pkg: project.ProgramOrTextTranslationPackage): readonly Diagnostic[];
     getNotExplicitlyImplementedAbstractMembers(typeEntity: e.TypeEntityWithMembers): readonly types.TypeMember[];
     getTypeMemberImplementationCheckResult(typeEntity: e.TypeEntityWithMembers): TypeMemberImplementationCheckResult;
     getLocalizedWellKnownDeclarations(locale: PackageLocale): WellKnownDeclarations;
     getLocalizedStandardTypes(locale: PackageLocale): types.StandardTypes;
-    determineUnderlyingTypeOfSourceVariantType(memberList: tree.TypeMemberDeclarationList): types.Type;
-    getOwnAndBaseConstructorCallsCheckResult(node: TypeWithMembersDeclaration): OwnAndBaseConstructorCallsCheckResult;
-    isConstructorCallingOwnConstructor(node: tree.ConstructorDeclaration): boolean;
-    ifCalleeThenCallExpression(node: tree.Expression): tree.CallExpression | undefined;
-    getNodeForAmbiguousAccessDiagnostic(access: tree.Expression): tree.Node;
-    isPossibleWrappedTargetTypeDependentFunctionLiteral(node: tree.Expression): boolean;
-    isTargetTypeDependentFunctionLiteral(node: tree.Expression): node is RegularOrBlockFunctionLiteral;
-    checkTypeArgumentCount(typeArgumentCount: number, typeParameters: readonly e.TypeParameterEntity[], diagnostics?: DiagnosticAcceptor, diagnosticLocation?: NodeOrDiagnosticLocation): boolean;
-    checkTypeCanBeUsedAsValue(typeAccess: tree.Expression): boolean;
     getEntityDiagnosticLocation(entity: e.Entity, chooseSetter?: boolean): DiagnosticLocation | undefined;
     createTypeMemberLookupContextWithinType(type: e.TypeEntity): TypeMemberLookupContext;
-    isPossiblyCastedBaseExpression(node: tree.Expression): boolean;
+    createDiagnosticArgumentFactoryWithinType(type: e.TypeEntity): DiagnosticArgumentFactory;
+    getUniqueImportedPackages(sourceFile: project.SourceFile): readonly PackageImportInfo[];
+    createLocalizedReferencedPackagesMapForTranslationPackage(entity: e.NameTranslationPackageEntity): ReadonlyMap<e.PackageEntity, e.PackageEntity>;
     private createTsInterop;
 }
-export declare class TsInteropInputs {
-    readonly programState: TsProgramState;
-    readonly standardLibraryFileByName: ReadonlyMap<string, ts.SourceFile>;
-    readonly rootFileByGlobalLibraryName: ReadonlyMap<string, ts.SourceFile>;
-    readonly moduleSymbolByName: ReadonlyMap<string, ts.Symbol>;
-    constructor(programState: TsProgramState, standardLibraryFileByName: ReadonlyMap<string, ts.SourceFile>, rootFileByGlobalLibraryName: ReadonlyMap<string, ts.SourceFile>, moduleSymbolByName: ReadonlyMap<string, ts.Symbol>);
-}
-export type BinaryExpressionOperatorClassificationResult = {
-    kind: 'user-definable';
-    operatorKind: BinaryOperatorKind;
-} | {
-    kind: 'question-question';
-} | {
-    kind: 'equals';
-} | {
-    kind: 'not-equals';
-};
-export declare namespace BinaryExpressionOperatorClassificationResult {
-    const multiply: BinaryExpressionOperatorClassificationResult;
-    const greaterThan: BinaryExpressionOperatorClassificationResult;
-    const greaterThanOrEqual: BinaryExpressionOperatorClassificationResult;
-    const lessThan: BinaryExpressionOperatorClassificationResult;
-    const lessThanOrEqual: BinaryExpressionOperatorClassificationResult;
-    const subtract: BinaryExpressionOperatorClassificationResult;
-    const add: BinaryExpressionOperatorClassificationResult;
-    const divide: BinaryExpressionOperatorClassificationResult;
-    const modulo: BinaryExpressionOperatorClassificationResult;
-    const bitwiseAnd: BinaryExpressionOperatorClassificationResult;
-    const bitwiseOr: BinaryExpressionOperatorClassificationResult;
-    const bitwiseXor: BinaryExpressionOperatorClassificationResult;
-    const leftShift: BinaryExpressionOperatorClassificationResult;
-    const signedRightShift: BinaryExpressionOperatorClassificationResult;
-    const unsignedRightShift: BinaryExpressionOperatorClassificationResult;
-    const and: BinaryExpressionOperatorClassificationResult;
-    const or: BinaryExpressionOperatorClassificationResult;
-    const xor: BinaryExpressionOperatorClassificationResult;
-    const equals: BinaryExpressionOperatorClassificationResult;
-    const notEquals: BinaryExpressionOperatorClassificationResult;
-    const questionQuestion: BinaryExpressionOperatorClassificationResult;
-}
-export declare const enum SyntacticAccessKind {
-    Get = 0,
-    Set = 1,
-    GetSet = 2,
-    ReferencedValue = 3
-}
-export declare class ExpressionCanBeUsedInForLoopCheckResult {
-    readonly elementType: types.Type;
-    readonly ifTypeDoesNotImplementEnumerableThenEnumeratorMethod: types.Method | undefined;
-    constructor(elementType: types.Type, ifTypeDoesNotImplementEnumerableThenEnumeratorMethod: types.Method | undefined);
-}
-declare class Type {
-    private readonly analyzer;
-    private readonly unionTypeSpecifierTypes;
-    private readonly intersectionTypeSpecifierTypes;
-    private readonly functionLiteralTypes;
-    private readonly nodesForWhichReturnTypeInferenceDiagnosticHasBeenReported;
-    private recursionDepth;
-    constructor(analyzer: Analyzer);
-    ofExpression(node: tree.Expression, analysisOptions?: ExpressionAnalysisOptions): types.Type;
-    ofTypeSpecifier(node: tree.TypeSpecifier): types.Type;
-    private ofExpressionWithoutGuard;
-    private ofFunctionBlockLiteral;
-    private ofFunctionLiteral;
-    private ofRegularOrBlockFunctionLiteral;
-    private createFunctionTypeOfFunctionEntity;
-    private ofArrayLiteral;
-    private ofAssertionExpression;
-    private ofAssumptionExpression;
-    private ofAsExpression;
-    private ofBinaryExpression;
-    private ofCallExpression;
-    private ofAutotypeCallExpression;
-    private ofIndexedAccessExpression;
-    private ofMissingExpression;
-    private ofIsExpression;
-    private ofParenthesizedExpression;
-    private ofPrefixUnaryExpression;
-    private ofMemberAccessExpression;
-    private ofReferenceExpression;
-    private ofDereferenceExpression;
-    private ofConditionalExpression;
-    private ofTextLiteral;
-    /**
-     * По умолчанию литерал шаблона текста имеет тип Текст.
-     *
-     * Литерал шаблона текста имеет тип ШаблонТекста в следующих случаях:
-     * - если он присваивается в переменную, имеющую тип ШаблонТекста;
-     * - если он присваивается в переменную, имеющую союзный тип, содержащий тип ШаблонТекста
-     *   и не содержащий тип Текст.
-     */
-    private ofTextTemplateLiteral;
-    private ofIdentifierExpression;
-    private ofTokenExpression;
-    private ofKeywordExpression;
-    private ofObjectExpression;
-    private ofBaseExpression;
-    private ofGenericSpecializationExpression;
-    private ofDefaultMatchExpression;
-    private ofOwnConstructorCallExpression;
-    private ofAnonymousTypeSpecifier;
-    private ofNamedTypeSpecifier;
-    private ofParenthesizedTypeSpecifier;
-    private ofNullableTypeSpecifier;
-    private ofUnionTypeSpecifier;
-    private ofIntersectionTypeSpecifier;
-    private ofInvalidTypeSpecifier;
-    private reportReturnTypeCanNotBeInferredDiagnostic;
-    private getNarrowedTypeIfNarrowableReference;
-}
-declare class ReturnType {
-    private readonly analyzer;
-    constructor(analyzer: Analyzer);
-    ofAnonymousFunctionTypeDeclaration(node: tree.AnonymousFunctionTypeDeclaration): types.Type;
-    ofFunctionBlockLiteral(node: tree.FunctionBlockLiteral): types.Type;
-    ofPackageFunctionDeclaration(node: tree.PackageFunctionDeclaration): types.Type;
-    ofNestedFunctionDeclaration(node: tree.NestedFunctionDeclaration): types.Type;
-    ofFunctionLiteral(node: tree.FunctionLiteral): types.Type;
-    ofMethodDeclaration(node: tree.MethodDeclaration): types.Type;
-    ofPackageVariableGetterDeclaration(node: tree.PackageVariableGetterDeclaration): types.Type;
-    ofFieldGetterDeclaration(node: tree.FieldGetterDeclaration): types.Type;
-    ofDereferencedVariableGetterDeclaration(node: tree.DereferencedVariableGetterDeclaration): types.Type;
-    ofIndexedElementGetterDeclaration(node: tree.IndexedElementGetterDeclaration): types.Type;
-    ofFunctionDeclaration(node: FunctionDeclaration): types.Type;
-    ofTextTranslationFunctionDeclaration(node: tree.TextTranslationFunctionDeclaration): types.Type;
-}
-declare class Entity {
-    private readonly analyzer;
-    private readonly packageEntities;
-    private readonly packageVariableEntities;
-    private readonly fieldEntities;
-    private readonly parameterEntities;
-    private readonly localVariableEntities;
-    private readonly typeParameterEntities;
-    private readonly indexerEntities;
-    private readonly referenceOperatorEntities;
-    private readonly packageStructuredTypeEntities;
-    private readonly anonymousStructuredTypeEntities;
-    private readonly packageVariantTypeEntities;
-    private readonly anonymousFunctionTypeEntities;
-    private readonly aliasTypeEntities;
-    private readonly reducedTypeEntities;
-    private readonly packageFunctionEntities;
-    private readonly methodEntities;
-    private readonly nestedFunctionEntities;
-    private readonly constructorEntities;
-    private readonly destructorEntities;
-    private readonly getterEntities;
-    private readonly setterEntities;
-    private readonly typeExtensionEntities;
-    private readonly packageAliasEntities;
-    private readonly textTranslationDeclarationEntities;
-    private readonly functionLiteralEntities;
-    private readonly functionBlockLiteralEntities;
-    constructor(analyzer: Analyzer);
-    ofPackage(pkg: SourcePackage): e.PackageEntity;
-    ofPackageVariableDeclaration(node: tree.PackageVariableDeclaration): e.PackageVariableEntity;
-    ofComputedPackageVariableDeclaration(node: PackageVariableAccessorDeclaration): e.PackageVariableEntity;
-    ofFieldDeclaration(node: tree.FieldDeclaration): e.FieldEntity;
-    ofComputedFieldDeclaration(node: FieldAccessorDeclaration): e.FieldEntity;
-    ofLocalVariableDeclaration(node: tree.LocalVariableDeclaration): e.LocalVariableEntity;
-    ofForStatementVariableDeclaration(node: tree.ForStatementVariableDeclaration): e.LocalVariableEntity;
-    ofErrorVariableDeclaration(node: tree.ErrorVariableDeclaration): e.LocalVariableEntity;
-    ofParameterDeclaration(node: tree.ParameterDeclaration): e.ParameterEntity;
-    ofTypeParameterDeclaration(node: tree.TypeParameterDeclaration): e.TypeParameterEntity;
-    ofIndexerDeclaration(node: IndexedElementAccessorDeclaration): e.IndexerEntity;
-    ofDereferenceOperatorDeclaration(node: DereferencedVariableAccessorDeclaration): e.DereferenceOperatorEntity;
-    ofPackageStructuredTypeDeclaration(node: PackageStructuredTypeDeclaration): e.PackageStructuredTypeEntity;
-    ofPackageClassDeclaration(node: tree.PackageClassDeclaration): e.PackageStructuredTypeEntity;
-    ofPackageStructureDeclaration(node: tree.PackageStructureDeclaration): e.PackageStructuredTypeEntity;
-    ofPackageAspectDeclaration(node: tree.PackageAspectDeclaration): e.PackageStructuredTypeEntity;
-    ofAnonymousStructuredTypeDeclaration(node: AnonymousStructuredTypeDeclaration): e.AnonymousStructuredTypeEntity;
-    ofAnonymousClassDeclaration(node: tree.AnonymousClassDeclaration): e.AnonymousStructuredTypeEntity;
-    ofStructuredTypeDeclaration(node: StructuredTypeDeclaration): e.StructuredTypeEntity;
-    ofAnonymousFunctionTypeDeclaration(node: tree.AnonymousFunctionTypeDeclaration): e.AnonymousFunctionTypeEntity;
-    ofFunctionTypeDeclaration(node: FunctionTypeDeclaration): e.FunctionTypeEntity;
-    ofPackageVariantDeclaration(node: tree.PackageVariantDeclaration): e.PackageVariantTypeEntity;
-    ofPackageAliasTypeDeclaration(node: tree.PackageAliasTypeDeclaration): e.AliasTypeEntity;
-    ofPackageReducedTypeDeclaration(node: tree.PackageReducedTypeDeclaration): e.ReducedTypeEntity;
-    ofPackageFunctionDeclaration(node: tree.PackageFunctionDeclaration): e.PackageFunctionEntity;
-    ofMethodDeclaration(node: tree.MethodDeclaration): e.MethodEntity;
-    ofNestedFunctionDeclaration(node: tree.NestedFunctionDeclaration): e.NestedFunctionEntity;
-    ofPackageVariableGetterDeclaration(node: tree.PackageVariableGetterDeclaration): e.GetterEntity;
-    ofFieldGetterDeclaration(node: tree.FieldGetterDeclaration): e.GetterEntity;
-    ofIndexedElementGetterDeclaration(node: tree.IndexedElementGetterDeclaration): e.GetterEntity;
-    ofDereferencedVariableGetterDeclaration(node: tree.DereferencedVariableGetterDeclaration): e.GetterEntity;
-    ofGetterDeclaration(node: GetterDeclaration): e.GetterEntity;
-    ofPackageVariableSetterDeclaration(node: tree.PackageVariableSetterDeclaration): e.SetterEntity;
-    ofFieldSetterDeclaration(node: tree.FieldSetterDeclaration): e.SetterEntity;
-    ofIndexedElementSetterDeclaration(node: tree.IndexedElementSetterDeclaration): e.SetterEntity;
-    ofDereferencedVariableSetterDeclaration(node: tree.DereferencedVariableSetterDeclaration): e.SetterEntity;
-    ofSetterDeclaration(node: SetterDeclaration): e.SetterEntity;
-    ofConstructorDeclaration(node: tree.ConstructorDeclaration): e.ConstructorEntity;
-    ofDestructorDeclaration(node: tree.DestructorDeclaration): e.DestructorEntity;
-    ofVariantValueDeclaration(node: tree.VariantValueDeclaration): e.FieldEntity;
-    ofTypeExtensionDeclaration(node: tree.TypeExtensionDeclaration): e.TypeExtensionEntity;
-    ofPackageImport(node: tree.PackageImport): e.PackageAliasEntity;
-    ofTypeWithMembersDeclaration(node: TypeWithMembersDeclaration): e.TypeEntityWithMembers;
-    ofTypeWithMembersOrExtensionDeclaration(node: TypeWithMembersOrTypeExtensionDeclaration): e.TypeWithMembersOrExtensionEntity;
-    ofTranslationTextTemplateParameter(node: tree.TranslationTextTemplateParameter): e.ParameterEntity;
-    ofTextTranslationDeclaration(node: tree.TextTranslationSource): e.TextTranslationEntity;
-    ofFunctionLiteral(node: tree.FunctionLiteral): e.AnonymousFunctionEntity;
-    ofFunctionBlockLiteral(node: tree.FunctionBlockLiteral): e.AnonymousFunctionEntity;
-    ofRegularOrBlockFunctionLiteral(node: RegularOrBlockFunctionLiteral): e.AnonymousFunctionEntity;
-    ofFunctionLiteralInternal(node: tree.FunctionLiteral): e.FunctionLiteralEntity;
-    ofFunctionBlockLiteralInternal(node: tree.FunctionBlockLiteral): e.FunctionBlockLiteralEntity;
-    ofFunctionLiteralParameterDeclarationInternal(node: tree.ParameterDeclaration, literal: tree.FunctionLiteral): e.FunctionLiteralParameterDeclarationEntity;
-    private getContainingPackageLoadedFromDts;
-    private createComputedFieldEntities;
-    private createDereferenceOperatorEntities;
-    private createIndexerAndParameterEntities;
-    private createAndCacheIndexerEntityAndParameters;
-    private areIndexedElementAccessorDeclarationsEqual;
-}
-declare class ResultLocalVariableEntity {
-    private readonly analyzer;
-    private readonly entities;
-    constructor(analyzer: Analyzer);
-    ofPackageFunctionDeclaration(node: tree.PackageFunctionDeclaration): e.LocalVariableEntity;
-    ofMethodDeclaration(node: tree.MethodDeclaration): e.LocalVariableEntity;
-    ofNestedFunctionDeclaration(node: tree.NestedFunctionDeclaration): e.LocalVariableEntity;
-    ofFunctionLiteral(node: tree.FunctionLiteral): e.LocalVariableEntity;
-    ofFunctionBlockLiteral(node: tree.FunctionBlockLiteral): e.LocalVariableEntity;
-    ofPackageVariableGetterDeclaration(node: tree.PackageVariableGetterDeclaration): e.LocalVariableEntity;
-    ofFieldGetterDeclaration(node: tree.FieldGetterDeclaration): e.LocalVariableEntity;
-    ofIndexedElementGetterDeclaration(node: tree.IndexedElementGetterDeclaration): e.LocalVariableEntity;
-    ofDereferencedVariableGetterDeclaration(node: tree.DereferencedVariableGetterDeclaration): e.LocalVariableEntity;
-    ofFunctionDeclaration(node: FunctionDeclaration): e.LocalVariableEntity;
-    ofTextTranslationFunctionDeclaration(node: tree.TextTranslationFunctionDeclaration): e.LocalVariableEntity;
-    private createResultLocalVariableEntity;
-}
-declare class ValueLocalVariableEntity {
-    private readonly analyzer;
-    private readonly entities;
-    constructor(analyzer: Analyzer);
-    ofPackageVariableSetterDeclaration(node: tree.PackageVariableSetterDeclaration): e.LocalVariableEntity;
-    ofFieldSetterDeclaration(node: tree.FieldSetterDeclaration): e.LocalVariableEntity;
-    ofIndexedElementSetterDeclaration(node: tree.IndexedElementSetterDeclaration): e.LocalVariableEntity;
-    ofDereferencedVariableSetterDeclaration(node: tree.DereferencedVariableSetterDeclaration): e.LocalVariableEntity;
-    private createValueLocalVariableEntity;
-}
-export declare enum SignatureComparisonOptions {
-    None = 0,
-    CompareNames = 1,
-    CompareReturnTypes = 2,
-    CheckTypeParameterCountIntersection = 4
+export declare class CommonAnalyzerState {
+    readonly compilation: project.Compilation;
+    systemPackage: e.PackageEntity;
+    originalWellKnownDeclarations: WellKnownDeclarations;
+    originalStandardTypes: types.StandardTypes;
+    typeFactory: TypeFactory;
+    implementation: ImplementationEntity;
+    typeUtils: TypeUtils;
+    signatureComparer: SignatureComparer;
+    conflictsCheck: ConflictsCheck;
+    typeAssignabilityCheck: TypeAssignabilityCheck;
+    overriddenMember: OverriddenMember;
+    readonly tsInteropInputs: TsInteropInputs;
+    readonly tsInterop: Cached<TsInteropContext>;
+    readonly textTranslationPackagesByTargetPackage: Cached<ReadonlyMap<e.PackageEntity, e.TextTranslationPackageEntity[]>>;
+    readonly primaryTextTranslationPackageByTargetPackage: Map<e.PackageEntity, Option<e.TextTranslationPackageEntity>>;
+    readonly resolvedImplementationPackagesByPlatform: Map<e.PackageEntity, ReadonlyMap<project.PlatformKind, ResolvedImplementationPackage>>;
+    sideDiagnosticAcceptor: DiagnosticAcceptor | undefined;
+    readonly sideDiagnosticsByFile: Map<project.TextFile, Diagnostic[]>;
+    readonly sideDiagnosticsWithoutFile: Diagnostic[];
+    readonly notExplicitlyImplementedAbstractTypeMembers: Map<e.TypeEntityWithMembers, readonly types.TypeMember[]>;
+    readonly typeMemberImplementationCheckResults: Map<e.TypeEntityWithMembers, TypeMemberImplementationCheckResult>;
+    originalPackageEntitiesByNameKey: ReadonlyMap<string, readonly e.PackageEntity[]> | undefined;
+    packageEntitiesByNameKey: ReadonlyMap<string, readonly e.PackageEntity[]> | undefined;
+    readonly localizedWellKnownDeclarations: Map<PackageLocale, WellKnownDeclarations>;
+    readonly localizedStandardTypes: Map<PackageLocale, types.StandardTypes>;
+    constructor(compilation: project.Compilation, tsInteropInputs: TsInteropInputs);
+    initialize(analyzer: Analyzer): void;
 }
 type TypeComparer = (t1: types.Type, t2: types.Type) => boolean;
 export type SimpleType = types.StructuredType | types.VariantType | types.FunctionType | types.AliasType | types.UnresolvedType | types.ParameterType | types.SubstitutionStubType | types.ReducedType;
@@ -606,17 +225,12 @@ declare class OverriddenMember {
     private readonly isMethod;
     private readonly isIndexer;
     private readonly isDereferenceOperator;
-    private readonly overriddenAndShadowedFields;
-    private readonly overriddenAndShadowedMethods;
-    private readonly overriddenAndShadowedIndexers;
-    private readonly overriddenAndShadowedDereferenceOperators;
     constructor(analyzer: Analyzer);
-    getOverriddenAndShadowedFields(node: tree.FieldDeclaration | FieldAccessorDeclaration): OverriddenAndShadowedMembers<types.Field, types.NamedTypeMember>;
-    getOverriddenAndShadowedMethods(node: tree.MethodDeclaration): OverriddenAndShadowedMembers<types.Method, types.NamedTypeMember>;
-    getOverriddenAndShadowedIndexers(node: IndexedElementAccessorDeclaration): OverriddenAndShadowedMembers<types.Indexer>;
-    getOverriddenAndShadowedDereferenceOperators(node: DereferencedVariableAccessorDeclaration): OverriddenAndShadowedMembers<types.DereferenceOperator>;
+    findOverriddenFields(entity: e.FieldEntity, diagnosticLocation: NodeOrDiagnosticLocation | undefined): types.Field[];
+    findOverriddenMethods(entity: e.MethodEntity, diagnosticLocation: NodeOrDiagnosticLocation | undefined): types.Method[];
+    findOverriddenIndexers(entity: e.IndexerEntity, diagnosticLocation: NodeOrDiagnosticLocation | undefined): types.Indexer[];
+    findOverriddenDereferenceOperators(entity: e.DereferenceOperatorEntity, diagnosticLocation: NodeOrDiagnosticLocation | undefined): types.DereferenceOperator[];
     entityCanBeOverridden(entity: OverridableTypeMemberEntity): boolean;
-    getMemberTypeOrReturnType(member: types.TypeMember): types.Type;
     private findOverriddenMembers;
     private findOverriddenOrShadowedNamedMembersInType;
     private findOverriddenOrShadowedIndexersInType;
@@ -627,37 +241,6 @@ declare class OverriddenMember {
     private typesForOverriddenMemberLookup;
     private entityCanOverrideOrShadow;
 }
-export declare enum ShadowReason {
-    BaseMemberHasDifferentKind = 0,
-    BaseMemberCannotBeOverridden = 1,
-    NoOverrideModifier = 2,
-    NoOverrideModifierAndTypeOrReturnTypeMismatch = 3,
-    TypeOrReturnTypeMismatch = 4
-}
-export declare class ShadowedMemberInfo<T extends OverridableTypeMember = OverridableTypeMember> {
-    readonly value: T;
-    readonly shadowReason: ShadowReason;
-    constructor(value: T, shadowReason: ShadowReason);
-}
-export declare class OverriddenAndShadowedMembers<TOverriddenMember extends OverridableTypeMember = OverridableTypeMember, TShadowedMember extends OverridableTypeMember = TOverriddenMember> {
-    readonly overriddenMembers: readonly TOverriddenMember[];
-    readonly shadowedMembers: readonly ShadowedMemberInfo<TShadowedMember>[];
-    constructor(overriddenMembers: readonly TOverriddenMember[], shadowedMembers: readonly ShadowedMemberInfo<TShadowedMember>[]);
-}
-export type OverridableTypeMemberEntity = e.FieldEntity | e.MethodEntity | e.IndexerEntity | e.DereferenceOperatorEntity;
-export declare function isOverridableTypeMemberEntity(entity: e.TypeMemberEntity): entity is OverridableTypeMemberEntity;
-export type OverridableTypeMember = types.Field | types.Method | types.Indexer | types.DereferenceOperator;
-export declare function isOverridableTypeMember(entity: types.TypeMember): entity is OverridableTypeMember;
-export type NodeWithTags = tree.PackageMemberDeclaration | tree.TypeMemberDeclaration | tree.ParameterDeclaration;
-declare class Tags {
-    private readonly analyzer;
-    private readonly tagsByNodeWithTags;
-    constructor(analyzer: Analyzer);
-    ofNodeWithTags(node: NodeWithTags): readonly tags.Tag[];
-    private createTagsOfNodeWithTags;
-    private createTagFromNode;
-    private argumentToTagArgument;
-}
 declare class ImplementationEntity {
     private readonly analyzer;
     constructor(analyzer: Analyzer);
@@ -703,52 +286,6 @@ declare class TypeAssignabilityCheck {
     private areNewFlagsBetter;
     private getFlagCount;
 }
-export declare enum TypeAssignabilityFlags {
-    None = 0,
-    /**
-     * Если флаг NotAssignable установлен, никакие другие флаги не могут быть установлены.
-     */
-    NotAssignable = 1,
-    Identity = 2,
-    DerivedToBase = 4,
-    FunctionTypes = 8,
-    ImplicitConversion = 16,
-    Boxing = 32,
-    /**
-     * Тип `Пусто`, не являющийся частью союзного типа, присваивается в союзный тип, допускающий `Пусто`.
-     */
-    NullIsAssignedToUnionType = 64,
-    TargetIsReducedType = 128,
-    First = 1,
-    Last = 64,
-    BinaryIncompatible = 48,
-    NotAssignableOrBinaryIncompatible = 49,
-    NotAssignableOrImplicitConversion = 17
-}
-declare class PackageImports {
-    private readonly analyzer;
-    private readonly packagesAvailableForImport;
-    private readonly resolvedPackageImports;
-    private readonly importedPackages;
-    private readonly automaticallyImportedPackages;
-    private readonly importedPackageNameTrees;
-    constructor(analyzer: Analyzer);
-    resolvePackageImports(sourceFile: project.SourceFile): ReadonlyMap<tree.PackageImport, ResolvedPackageImport>;
-    getPackagesAvailableForImport(pkg: project.SourcePackage): readonly e.PackageEntity[];
-    getUniqueImportedPackages(sourceFile: project.SourceFile): readonly PackageImportInfo[];
-    getImportedPackageNameTree(node: tree.SourceFile): ImportedPackageNameTree;
-    private getAutomaticallyImportedPackages;
-}
-export declare class ResolvedPackageImport {
-    readonly entity: e.PackageEntity | undefined;
-    readonly isAliasedImport: e.PackageAliasEntity | undefined;
-    constructor(entity: e.PackageEntity | undefined, isAliasedImport: e.PackageAliasEntity | undefined);
-}
-export declare class PackageImportInfo {
-    readonly entity: e.PackageEntity;
-    readonly aliasEntity: e.PackageAliasEntity | undefined;
-    constructor(entity: e.PackageEntity, aliasEntity: e.PackageAliasEntity | undefined);
-}
 declare class TypeUtils {
     private readonly analyzer;
     constructor(analyzer: Analyzer);
@@ -763,6 +300,8 @@ declare class TypeUtils {
     isTypeDerivedFromOrEqualsTo(source: types.Type, target: types.Type, considerTypeArguments?: boolean): boolean;
     compareTypesWithSimpleTypeComparer(type1: types.Type, type2: types.Type, comparer: SimpleTypeComparer): boolean;
     compareSubstitutionsWithSimpleTypeComparer(substitutions1: types.Substitutions, substitutions2: types.Substitutions, comparer: SimpleTypeComparer): boolean;
+    allAspectsOfType(type: types.Type): Iterable<types.StructuredType>;
+    checkTypeIsBasedOnAspect(type: types.Type, aspectEntity: e.StructuredTypeEntity): boolean;
     private collectBaseAndAliasedTypesRecursively;
     private getBaseTypesForCommonTypesSearch;
     private addTypeAndCollectAllBaseTypes;
@@ -813,42 +352,4 @@ declare class ConflictsCheck {
 }
 export type EntityWithoutTypeParametersInSignature = e.ConstructorEntity | e.DestructorEntity | e.IndexerEntity;
 export type TypeMemberWithoutTypeParametersInSignature = types.Constructor | types.Destructor | types.Indexer;
-export declare class ExpressionDenotesFunctionCheckResult {
-    readonly candidates: readonly AccessedFunction[];
-    readonly suitableFunctions: readonly AccessedFunction[];
-    readonly singleNotSuitableSubstitutedCandidate: AccessedFunction | undefined;
-    get singleSuitableFunction(): AccessedFunction | undefined;
-    get singleFunction(): AccessedFunction | undefined;
-    constructor(candidates: readonly AccessedFunction[], suitableFunctions: readonly AccessedFunction[], singleNotSuitableSubstitutedCandidate: AccessedFunction | undefined);
-}
-export declare class DeclaredTypeMemberEntities {
-    readonly variables: readonly e.FieldEntity[];
-    readonly methods: readonly e.MethodEntity[];
-    readonly constructors: readonly e.ConstructorEntity[];
-    readonly destructors: readonly e.DestructorEntity[];
-    readonly indexers: readonly e.IndexerEntity[];
-    readonly dereferenceOperators: readonly e.DereferenceOperatorEntity[];
-    get namedMembers(): e.NamedTypeMemberEntity[];
-    constructor(variables: readonly e.FieldEntity[], methods: readonly e.MethodEntity[], constructors: readonly e.ConstructorEntity[], destructors: readonly e.DestructorEntity[], indexers: readonly e.IndexerEntity[], dereferenceOperators: readonly e.DereferenceOperatorEntity[]);
-}
-export declare class ExpressionAnalysisOptions {
-    readonly targetType: types.Type | undefined;
-    /**
-     * Определяет, можно ли кэшировать результат анализа выражений, если результат зависит от целевого типа. Результат
-     * анализа, который не зависит от целевого типа, можно кэшировать всегда.
-     */
-    readonly allowCaching: boolean;
-    readonly isResolvingOverload: boolean;
-    constructor(targetType: types.Type | undefined, 
-    /**
-     * Определяет, можно ли кэшировать результат анализа выражений, если результат зависит от целевого типа. Результат
-     * анализа, который не зависит от целевого типа, можно кэшировать всегда.
-     */
-    allowCaching: boolean, isResolvingOverload: boolean);
-    static withTargetType(options: ExpressionAnalysisOptions | undefined, targetType: types.Type | undefined): ExpressionAnalysisOptions;
-    withTargetType(targetType: types.Type | undefined): ExpressionAnalysisOptions;
-    withAllowCaching(allowCaching: boolean): ExpressionAnalysisOptions;
-    withIsResolvingOverload(isResolvingOverload: boolean): ExpressionAnalysisOptions;
-    withTargetTypeAndAllowCaching(targetType: types.Type | undefined, allowCaching: boolean): ExpressionAnalysisOptions;
-}
 export {};