@artel/artc 0.6.25191

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

@@ -0,0 +1,320 @@
+import { IEntityHidingMatcher } from '../entities/EntityHiding.js';
+import { ConstructorEntity, PackageEntity, TypeEntityWithMembers, TypeExtensionEntity } from '../entities/index.js';
+import { SourceFile } from '../project/SourceFile.js';
+import * as tree from '../tree/index.js';
+import * as types from '../types/index.js';
+import { Analyzer } from './Analyzer.js';
+import { LocalizationContext } from './LocalizationContext.js';
+import { Lookup, ScopeChain } from './Lookup.js';
+import { GetterDeclaration, MethodDeclaration, MethodTypeDeclaration, SetterDeclaration, StructuredTypeDeclaration, VariantTypeDeclaration } from './NodeTypeUtils.js';
+/**
+ * Позволяет получить информацию, общую для определённой области
+ * исходного кода (блока инструкций, списка членов типа и др.) с учётом
+ * всех вышестоящих (родительских) контекстов.
+ * Чтобы получить семантический контекст, в котором находится определённый узел,
+ * используйте `analyzer.semanticContext.containing(node)`.
+ */
+export interface SemanticContext {
+    getScopeChain(): ScopeChain;
+    getContainingSubprogram(): SubprogramInfo | undefined;
+    getContainingTypeOrTypeExtension(): TypeOrTypeExtension | undefined;
+    getContainingSourceFile(): SourceFile;
+    getContainingPackage(): PackageEntity;
+    getLocalizationContext(): LocalizationContext;
+    isInRunStatementWithClauses(): RunStatementClausesInfo | undefined;
+    isInFinallyClause(): boolean;
+    getScopeLookup(): Lookup;
+    getHidingMatcher(): IEntityHidingMatcher;
+}
+export type SubprogramInfo = SubprogramInfo.Method | SubprogramInfo.Constructor | SubprogramInfo.Destructor | SubprogramInfo.Getter | SubprogramInfo.Setter | SubprogramInfo.PackageConstructor | SubprogramInfo.PackageEntryPoint | SubprogramInfo.MethodLiteral;
+export declare namespace SubprogramInfo {
+    export class Method implements ISubprogramInfo {
+        readonly kind = "method";
+        private readonly _analyzer;
+        private readonly _node;
+        constructor(analyzer: Analyzer, node: MethodDeclaration);
+        getReturnType(): types.Type | undefined;
+        isGenerator(): boolean;
+    }
+    export class Constructor implements ISubprogramInfo {
+        readonly kind = "constructor";
+        private readonly _analyzer;
+        private readonly _node;
+        constructor(analyzer: Analyzer, node: tree.TypeConstructorDeclaration);
+        getReturnType(): types.Type | undefined;
+        isGenerator(): boolean;
+        getEntity(): ConstructorEntity;
+    }
+    export class Destructor implements ISubprogramInfo {
+        readonly kind = "destructor";
+        private readonly _analyzer;
+        private readonly _node;
+        constructor(analyzer: Analyzer, node: tree.TypeDestructorDeclaration);
+        getReturnType(): types.Type | undefined;
+        isGenerator(): boolean;
+    }
+    export class Getter implements ISubprogramInfo {
+        readonly kind = "getter";
+        private readonly _analyzer;
+        private readonly _node;
+        constructor(analyzer: Analyzer, node: GetterDeclaration);
+        getReturnType(): types.Type | undefined;
+        isGenerator(): boolean;
+    }
+    export class Setter implements ISubprogramInfo {
+        readonly kind = "setter";
+        private readonly _analyzer;
+        private readonly _node;
+        constructor(analyzer: Analyzer, node: SetterDeclaration);
+        getReturnType(): types.Type | undefined;
+        isGenerator(): boolean;
+    }
+    export class PackageConstructor implements ISubprogramInfo {
+        readonly kind = "package-constructor";
+        private readonly _analyzer;
+        private readonly _node;
+        constructor(analyzer: Analyzer, node: tree.PackageConstructorDeclaration);
+        getReturnType(): types.Type | undefined;
+        isGenerator(): boolean;
+        getPackageEntity(): PackageEntity;
+    }
+    export class PackageEntryPoint implements ISubprogramInfo {
+        readonly kind = "package-entry-point";
+        private readonly _analyzer;
+        private readonly _node;
+        constructor(analyzer: Analyzer, node: tree.PackageEntryPointDeclaration);
+        getReturnType(): types.Type | undefined;
+        isGenerator(): boolean;
+        getPackageEntity(): PackageEntity;
+    }
+    export class MethodLiteral implements ISubprogramInfo {
+        readonly kind = "method-literal";
+        private readonly _analyzer;
+        private readonly _node;
+        constructor(analyzer: Analyzer, node: RegularOrBlockMethodLiteral);
+        getReturnType(): types.Type | undefined;
+        isGenerator(): boolean;
+    }
+    interface ISubprogramInfo {
+        getReturnType(): types.Type | undefined;
+        isGenerator(): boolean;
+    }
+    export {};
+}
+export type TypeOrTypeExtension = TypeOrTypeExtension.Type | TypeOrTypeExtension.TypeExtension;
+export declare namespace TypeOrTypeExtension {
+    export class Type implements ITypeOrTypeExtension {
+        readonly value: TypeEntityWithMembers;
+        readonly kind = "type";
+        constructor(value: TypeEntityWithMembers);
+        getTypeEntity(): TypeEntityWithMembers | undefined;
+        getEntity(): TypeEntityWithMembers;
+    }
+    export class TypeExtension implements ITypeOrTypeExtension {
+        readonly value: TypeExtensionEntity;
+        readonly kind = "type-extension";
+        constructor(value: TypeExtensionEntity);
+        getTypeEntity(): TypeEntityWithMembers | undefined;
+        getEntity(): TypeExtensionEntity;
+    }
+    interface ITypeOrTypeExtension {
+        getTypeEntity(): TypeEntityWithMembers | undefined;
+        getEntity(): TypeEntityWithMembers | TypeExtensionEntity;
+    }
+    export {};
+}
+export declare class RunStatementClausesInfo {
+    readonly hasOnErrorClause: boolean;
+    readonly hasFinallyClause: boolean;
+    constructor(hasOnErrorClause: boolean, hasFinallyClause: boolean);
+}
+declare abstract class SemanticContextWithParent implements SemanticContext {
+    protected readonly _parentContext: SemanticContext;
+    constructor(parentContext: SemanticContext);
+    getScopeChain(): ScopeChain;
+    getContainingSubprogram(): SubprogramInfo | undefined;
+    getContainingTypeOrTypeExtension(): TypeOrTypeExtension | undefined;
+    getContainingSourceFile(): SourceFile;
+    getContainingPackage(): PackageEntity;
+    getLocalizationContext(): LocalizationContext;
+    isInRunStatementWithClauses(): RunStatementClausesInfo | undefined;
+    isInFinallyClause(): boolean;
+    getScopeLookup(): Lookup;
+    getHidingMatcher(): IEntityHidingMatcher;
+}
+export declare class SourceFileSemanticContext implements SemanticContext {
+    private readonly _analyzer;
+    private readonly _sourceFile;
+    private readonly _scopeChain;
+    constructor(analyzer: Analyzer, node: tree.SourceFile);
+    getScopeChain(): ScopeChain;
+    getHidingMatcher(): IEntityHidingMatcher;
+    getContainingSubprogram(): SubprogramInfo | undefined;
+    getContainingTypeOrTypeExtension(): TypeOrTypeExtension | undefined;
+    getContainingSourceFile(): SourceFile;
+    getContainingPackage(): PackageEntity;
+    isInRunStatementWithClauses(): RunStatementClausesInfo | undefined;
+    isInFinallyClause(): boolean;
+    getScopeLookup(): Lookup;
+    getLocalizationContext(): LocalizationContext;
+}
+export type TypeDeclarationCreatingSemanticContext = StructuredTypeDeclaration | VariantTypeDeclaration | MethodTypeDeclaration | tree.PackageAliasTypeDeclaration;
+/**
+ * Завершающий семантический контекст типа.
+ * Поскольку контекст с параметрами типа является опциональным, необходим
+ * ещё один контекст, который гарантированно переопределит метод `getContainingTypeOrTypeExtension`.
+ */
+export declare class LastSemanticContextOfType extends SemanticContextWithParent {
+    private readonly _analyzer;
+    private readonly _node;
+    constructor(analyzer: Analyzer, node: TypeDeclarationCreatingSemanticContext, parentContext: SemanticContext);
+    getContainingTypeOrTypeExtension(): TypeOrTypeExtension | undefined;
+    getContainingSubprogram(): SubprogramInfo | undefined;
+    isInRunStatementWithClauses(): RunStatementClausesInfo | undefined;
+    isInFinallyClause(): boolean;
+    private getContainingType;
+}
+type TypeDeclarationWithTypeParameters = tree.PackageStructuredTypeDeclaration | tree.PackageVariantTypeDeclaration | tree.PackageAliasTypeDeclaration | tree.PackageMethodTypeDeclaration;
+export declare class TypeParametersOfTypeSemanticContext extends SemanticContextWithParent {
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _scopeChain;
+    constructor(analyzer: Analyzer, node: TypeDeclarationWithTypeParameters, parentContext: SemanticContext);
+    getScopeChain(): ScopeChain;
+}
+export type TypeDeclarationBody = tree.StructuredTypeDeclarationBody | tree.VariantTypeDeclarationBody | tree.AliasTypeDeclarationBody | tree.MethodTypeDeclarationBody;
+export declare class TypeBodySemanticContext extends SemanticContextWithParent {
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _scopeChain;
+    constructor(analyzer: Analyzer, node: TypeDeclarationBody, parentContext: SemanticContext);
+    getScopeChain(): ScopeChain;
+}
+export declare class TypeExtensionBodySemanticContext extends SemanticContextWithParent {
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _scopeChain;
+    constructor(analyzer: Analyzer, node: tree.TypeExtensionDeclaration, parentContext: SemanticContext);
+    getScopeChain(): ScopeChain;
+    getContainingTypeOrTypeExtension(): TypeOrTypeExtension | undefined;
+}
+/**
+ * Завершающий семантический контекст метода.
+ * Поскольку контекст с параметрами типа метода является опциональным, необходим
+ * ещё один контекст, который гарантированно переопределит метод `getContainingSubprogram`.
+ */
+export declare class LastSemanticContextOfMethod extends SemanticContextWithParent {
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _subprogramInfo;
+    constructor(analyzer: Analyzer, node: MethodDeclaration, parentContext: SemanticContext);
+    getContainingSubprogram(): SubprogramInfo | undefined;
+    isInRunStatementWithClauses(): RunStatementClausesInfo | undefined;
+    isInFinallyClause(): boolean;
+}
+export declare class MethodTypeParameterSemanticContext extends SemanticContextWithParent {
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _scopeChain;
+    constructor(analyzer: Analyzer, node: MethodDeclaration, parentContext: SemanticContext);
+    getScopeChain(): ScopeChain;
+}
+export declare class MethodValueParameterSemanticContext extends SemanticContextWithParent {
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _scopeChain;
+    constructor(analyzer: Analyzer, node: MethodDeclaration, parentContext: SemanticContext);
+    getScopeChain(): ScopeChain;
+}
+export declare class PackageConstructorSemanticContext extends SemanticContextWithParent {
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _subprogramInfo;
+    constructor(analyzer: Analyzer, node: tree.PackageConstructorDeclaration, parentContext: SemanticContext);
+    getContainingSubprogram(): SubprogramInfo | undefined;
+}
+export declare class PackageEntryPointSemanticContext extends SemanticContextWithParent {
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _subprogramInfo;
+    constructor(analyzer: Analyzer, node: tree.PackageEntryPointDeclaration, parentContext: SemanticContext);
+    getContainingSubprogram(): SubprogramInfo | undefined;
+}
+export declare class ConstructorSemanticContext extends SemanticContextWithParent {
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _scopeChain;
+    private readonly _subprogramInfo;
+    constructor(analyzer: Analyzer, node: tree.TypeConstructorDeclaration, parentContext: SemanticContext);
+    getScopeChain(): ScopeChain;
+    getContainingSubprogram(): SubprogramInfo | undefined;
+}
+export declare class DestructorSemanticContext extends SemanticContextWithParent {
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _scopeChain;
+    private readonly _subprogramInfo;
+    constructor(analyzer: Analyzer, node: tree.TypeDestructorDeclaration, parentContext: SemanticContext);
+    getScopeChain(): ScopeChain;
+    getContainingSubprogram(): SubprogramInfo | undefined;
+}
+export declare class IndexerSemanticContext extends SemanticContextWithParent {
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _scopeChain;
+    private readonly _subprogramInfo;
+    constructor(analyzer: Analyzer, node: tree.TypeIndexedGetterDeclaration | tree.TypeIndexedSetterDeclaration, parentContext: SemanticContext);
+    getScopeChain(): ScopeChain;
+}
+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;
+}
+export declare class SetterSemanticContext extends SemanticContextWithParent {
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _scopeChain;
+    private readonly _subprogramInfo;
+    constructor(analyzer: Analyzer, node: SetterDeclaration, parentContext: SemanticContext);
+    getScopeChain(): ScopeChain;
+    getContainingSubprogram(): SubprogramInfo | undefined;
+}
+export declare class StatementBlockSemanticContext extends SemanticContextWithParent {
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _scopeChain;
+    constructor(analyzer: Analyzer, node: tree.StatementBlock, parentContext: SemanticContext);
+    getScopeChain(): ScopeChain;
+    isInRunStatementWithClauses(): RunStatementClausesInfo | undefined;
+    isInFinallyClause(): boolean;
+}
+export type RegularOrBlockMethodLiteral = tree.MethodLiteral | tree.MethodBlockLiteral;
+export declare class MethodLiteralSemanticContext extends SemanticContextWithParent {
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _scopeChain;
+    private readonly _subprogramInfo;
+    constructor(analyzer: Analyzer, node: RegularOrBlockMethodLiteral, parentContext: SemanticContext);
+    getScopeChain(): ScopeChain;
+    getContainingSubprogram(): SubprogramInfo | undefined;
+}
+export declare class ForStatementSemanticContext extends SemanticContextWithParent {
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _scopeChain;
+    constructor(analyzer: Analyzer, node: tree.ForStatement, parentContext: SemanticContext);
+    getScopeChain(): ScopeChain;
+}
+export declare class OnErrorClauseSemanticContext extends SemanticContextWithParent {
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _scopeChain;
+    constructor(analyzer: Analyzer, node: tree.OnErrorClause, parentContext: SemanticContext);
+    getScopeChain(): ScopeChain;
+}
+export {};

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

@@ -0,0 +1,54 @@
+import * as tree from '../tree/index.js';
+import { Analyzer } from './Analyzer.js';
+import { MethodDeclaration } from './NodeTypeUtils.js';
+import { RegularOrBlockMethodLiteral, SemanticContext, TypeDeclarationBody, TypeDeclarationCreatingSemanticContext } from './SemanticContext.js';
+export declare class SemanticContextBuilder {
+    private readonly _analyzer;
+    private readonly _semanticContexts;
+    private readonly _methodDeclarationTypeParametersContexts;
+    private readonly _methodDeclarationValueParametersContexts;
+    private readonly _indexerParametersContexts;
+    constructor(analyzer: Analyzer);
+    /**
+     * Возвращает контекст, содержащий узел. Если в качестве узла передан исходный файл,
+     * будет возвращён контекст исходного файла.
+     */
+    containing(node: tree.Node): SemanticContext;
+    containingWithOffset(node: tree.Node, offset: number): SemanticContext;
+    ofSourceFile(node: tree.SourceFile): SemanticContext;
+    /**
+     * Контекст заголовка метода. Включает параметры-типы и параметры-значения (в зависимости от указанного `hint`).
+     */
+    ofMethodDeclarationHeader(node: MethodDeclaration, hint: 'type-parameters' | 'value-parameters'): SemanticContext;
+    ofTypeDeclarationBody(node: TypeDeclarationBody): SemanticContext;
+    /**
+     * Контекст заголовка типа. Включает параметры типа.
+     */
+    ofTypeDeclarationHeader(node: TypeDeclarationCreatingSemanticContext): SemanticContext;
+    ofTypeExtensionDeclarationBody(node: tree.TypeExtensionDeclaration): SemanticContext;
+    ofVariableGetterDeclaration(node: tree.PackageVariableGetterDeclaration | tree.TypeVariableGetterDeclaration | tree.TypeDereferencedVariableGetterDeclaration): SemanticContext;
+    ofVariableSetterDeclaration(node: tree.PackageVariableSetterDeclaration | tree.TypeVariableSetterDeclaration | tree.TypeDereferencedVariableSetterDeclaration): SemanticContext;
+    ofPackageConstructorDeclaration(node: tree.PackageConstructorDeclaration): SemanticContext;
+    ofPackageEntryPointDeclaration(node: tree.PackageEntryPointDeclaration): SemanticContext;
+    ofRegularOrBlockMethodLiteral(node: RegularOrBlockMethodLiteral): SemanticContext;
+    ofForStatement(node: tree.ForStatement): SemanticContext;
+    ofStatementBlock(node: tree.StatementBlock): SemanticContext;
+    ofTypeConstructorDeclaration(node: tree.TypeConstructorDeclaration): SemanticContext;
+    ofTypeDestructorDeclaration(node: tree.TypeDestructorDeclaration): SemanticContext;
+    ofTypeIndexedGetterDeclaration(node: tree.TypeIndexedGetterDeclaration, hint: 'body' | 'parameters'): SemanticContext;
+    ofTypeIndexedSetterDeclaration(node: tree.TypeIndexedSetterDeclaration, hint: 'body' | 'parameters'): SemanticContext;
+    ofOnErrorClause(node: tree.OnErrorClause): SemanticContext;
+    private containingInternal;
+    private ofChildOfMethodDeclaration;
+    private ofChildOfTypeDeclarationWithMemberBlock;
+    private ofChildOfTypeDeclarationBodyWithMemberBlock;
+    private ofChildOfMethodTypeDeclarationBody;
+    private ofChildOfMethodLiteral;
+    private ofTypeConstructorDeclarationChild;
+    private ofTypeDestructorDeclarationChild;
+    private ofTypeIndexedGetterDeclarationChild;
+    private ofTypeIndexedSetterDeclarationChild;
+    private ofChildOfTypeExtensionDeclaration;
+    private isOffsetBetweenNodes;
+    private isOffsetInsideStatementBlock;
+}

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

@@ -0,0 +1,92 @@
+import { Name, Query, SearchName } from '../common/index.js';
+import { AliasTypeEntity, EntityHidingLevel, PackageAliasEntity, PackageMethodEntity, PackageMethodTypeEntity, PackageStructuredTypeEntity, PackageVariableEntity, PackageVariantTypeEntity, StructuredTypeEntity, TypeExtensionEntity, TypeParameterEntity } from '../entities/index.js';
+export declare class SourceFileMembers {
+    private readonly _namedDeclarations;
+    private readonly _typeExtensions;
+    private readonly _declarationsByName;
+    get declarationsByName(): ReadonlyMap<string, readonly NamedDeclaration[]>;
+    constructor(namedDeclarations: readonly NamedDeclaration[], typeExtensions: readonly TypeExtensionEntity[]);
+    getNamedDeclarations(): Query<NamedDeclaration>;
+    getNamedDeclarationsByName(name: SearchName): Query<NamedDeclaration>;
+    getPackageAliases(): Query<PackageAliasEntity>;
+    getPackageAliasesByName(name: SearchName): Query<PackageAliasEntity>;
+    getTypeExtensions(): Query<TypeExtensionEntity>;
+    getTypeExtensionsByType(type: StructuredTypeEntity): Query<TypeExtensionEntity>;
+}
+export type NamedDeclaration = NamedDeclaration_type | NamedDeclaration_variable | NamedDeclaration_method | NamedDeclaration_packageAlias;
+export declare class NamedDeclaration_type implements INamedDeclaration {
+    readonly value: TypeDeclaration;
+    readonly kind = "type";
+    constructor(value: TypeDeclaration);
+    getName(): Name;
+    isHidden(): EntityHidingLevel | undefined;
+}
+export declare class NamedDeclaration_variable implements INamedDeclaration {
+    readonly value: PackageVariableEntity;
+    readonly kind = "variable";
+    constructor(value: PackageVariableEntity);
+    getName(): Name;
+    isHidden(): EntityHidingLevel | undefined;
+}
+export declare class NamedDeclaration_method implements INamedDeclaration {
+    readonly value: PackageMethodEntity;
+    readonly kind = "method";
+    constructor(value: PackageMethodEntity);
+    getName(): Name;
+    isHidden(): EntityHidingLevel | undefined;
+}
+export declare class NamedDeclaration_packageAlias implements INamedDeclaration {
+    readonly value: PackageAliasEntity;
+    readonly kind = "package-alias";
+    constructor(value: PackageAliasEntity);
+    getName(): Name;
+    isHidden(): EntityHidingLevel | undefined;
+}
+interface INamedDeclaration {
+    getName(): Name;
+    isHidden(): EntityHidingLevel | undefined;
+}
+export type TypeDeclaration = TypeDeclaration_alias | TypeDeclaration_method | TypeDeclaration_structured | TypeDeclaration_variant;
+export declare class TypeDeclaration_alias implements ITypeDeclaration {
+    readonly value: AliasTypeEntity;
+    readonly kind = "alias";
+    constructor(value: AliasTypeEntity);
+    getName(): Name;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getArity(): number;
+    isHidden(): EntityHidingLevel | undefined;
+}
+export declare class TypeDeclaration_method implements ITypeDeclaration {
+    readonly value: PackageMethodTypeEntity;
+    readonly kind = "method";
+    constructor(value: PackageMethodTypeEntity);
+    getName(): Name;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getArity(): number;
+    isHidden(): EntityHidingLevel | undefined;
+}
+export declare class TypeDeclaration_structured implements ITypeDeclaration {
+    readonly value: PackageStructuredTypeEntity;
+    readonly kind = "structured";
+    constructor(value: PackageStructuredTypeEntity);
+    getName(): Name;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getArity(): number;
+    isHidden(): EntityHidingLevel | undefined;
+}
+export declare class TypeDeclaration_variant implements ITypeDeclaration {
+    readonly value: PackageVariantTypeEntity;
+    readonly kind = "variant";
+    constructor(value: PackageVariantTypeEntity);
+    getName(): Name;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getArity(): number;
+    isHidden(): EntityHidingLevel | undefined;
+}
+interface ITypeDeclaration {
+    getName(): Name;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getArity(): number;
+    isHidden(): EntityHidingLevel | undefined;
+}
+export {};

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

@@ -0,0 +1,41 @@
+import { PlatformKind, SourcePackage } from '../project/index.js';
+import { AnalyzedTranslationPackage } from './AnalyzedTranslationPackage.js';
+import { Analyzer } from './Analyzer.js';
+export declare class SourcePackageDependencyGraph {
+    private readonly _analyzer;
+    private readonly _rootPackages;
+    private readonly _nodeByPackage;
+    constructor(analyzer: Analyzer, rootPackages?: readonly SourcePackage[]);
+    /**
+     * Перечислить все пакеты и их зависимости, включая транзитивные, начиная от корневых пакетов.
+     * @param platformKind Связывать многоплатформенные пакеты с реализацией для заданной платформы.
+     */
+    enumeratePackages(platformKind: PlatformKind): Iterable<SourcePackage>;
+    private getNodeForPackage;
+    private enumerateNodeAndDependenciesRecursively;
+}
+export interface SourcePackageDependencyGraphNode {
+    /**
+     * Исходный пакет, который может подключать другие пакеты.
+     */
+    readonly pkg: SourcePackage;
+    /**
+     * Информация о подключаемых пакетах.
+     */
+    readonly links: readonly SourcePackageDependencyGraphLink[];
+}
+export interface SourcePackageDependencyGraphLink {
+    /**
+     * Подключаемый пакет.
+     */
+    readonly node: SourcePackageDependencyGraphNode;
+    /**
+     * Пакеты перевода, используемые при подключении пакета. Их может быть несколько, поскольку в разных файлах
+     * одного пакета другой пакет может подключаться на разных языках.
+     */
+    readonly translationPackages: readonly AnalyzedTranslationPackage[];
+    /**
+     * Если подключаемый пакет является многоплатформенным, поле содержит доступные реализационные пакеты.
+     */
+    readonly implementationPackageByPlatformKind: ReadonlyMap<PlatformKind, SourcePackageDependencyGraphNode>;
+}

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

@@ -0,0 +1,6 @@
+import { PackageVariableEntity } from '../entities/VariableEntity.js';
+import * as tree from '../tree/index.js';
+import { Analyzer } from './Analyzer.js';
+export declare class SourcePackageMembersCreator {
+    static createMembersWithCompoundDeclarations(analyzer: Analyzer, memberList: tree.PackageMemberDeclarationList, resultingComputedVariables: Map<tree.Node, PackageVariableEntity>): void;
+}

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

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

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

@@ -0,0 +1,49 @@
+import { Name } from '../common/index.js';
+import { MethodEntity, ParameterVariableEntity } from '../entities/index.js';
+import * as types from '../types/index.js';
+export type SubstitutedMethod = SubstitutedMethod_entity | SubstitutedMethod_typeMember;
+export declare class SubstitutedMethod_entity implements ISubstitutedMethod {
+    readonly entity: MethodEntity;
+    readonly entitySignatureType: types.MethodType;
+    readonly substitutions: types.Substitutions;
+    readonly kind = "entity";
+    private readonly _signatureType;
+    constructor(entity: MethodEntity, entitySignatureType: types.MethodType, substitutions: types.Substitutions);
+    getEntity(): MethodEntity;
+    getName(): Name;
+    getSignatureType(): types.MethodType;
+    getSubstitutions(): types.Substitutions;
+    getValueParameters(): readonly {
+        entity: ParameterVariableEntity;
+        type: types.Type;
+    }[];
+    isAsync(): boolean;
+}
+export declare class SubstitutedMethod_typeMember implements ISubstitutedMethod {
+    readonly method: types.Method;
+    readonly substitutions: types.Substitutions;
+    readonly kind = "type-member";
+    private readonly _signatureType;
+    constructor(method: types.Method, substitutions: types.Substitutions);
+    getEntity(): MethodEntity;
+    getName(): Name;
+    getSignatureType(): types.MethodType;
+    getSubstitutions(): types.Substitutions;
+    getValueParameters(): readonly {
+        entity: ParameterVariableEntity;
+        type: types.Type;
+    }[];
+    isAsync(): boolean;
+}
+interface ISubstitutedMethod {
+    getEntity(): MethodEntity;
+    getName(): Name;
+    getSignatureType(): types.MethodType;
+    getSubstitutions(): types.Substitutions;
+    getValueParameters(): readonly {
+        entity: ParameterVariableEntity;
+        type: types.Type;
+    }[];
+    isAsync(): boolean;
+}
+export {};

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

@@ -0,0 +1,26 @@
+import { Diagnostic } from '../diagnostic/Diagnostic.js';
+import { Tag } from '../tree/index.js';
+import * as types from '../types/index.js';
+import { FoundAnonymousDeclaration } from './FoundDeclaration.js';
+import { Analyzer } from './index.js';
+export declare class Resolver {
+    private readonly _analyzer;
+    private readonly _node;
+    constructor(_analyzer: Analyzer, _node: Tag);
+    resolve(): Meaning;
+}
+export type Meaning = Meaning_constructorCall | Meaning_unresolved;
+declare class Meaning_constructorCall {
+    readonly type: types.StructuredType;
+    readonly candidates: readonly FoundAnonymousDeclaration<types.Constructor>[];
+    readonly suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[];
+    readonly kind = "resolved";
+    get singleSuitableConstructor(): FoundAnonymousDeclaration<types.Constructor> | undefined;
+    constructor(type: types.StructuredType, candidates: readonly FoundAnonymousDeclaration<types.Constructor>[], suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[]);
+}
+declare class Meaning_unresolved {
+    readonly diagnostics: readonly Diagnostic[];
+    readonly kind = "unresolved";
+    constructor(diagnostics: readonly Diagnostic[]);
+}
+export {};

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

@@ -0,0 +1,29 @@
+import { VariableEntity } from '../entities/index.js';
+import * as types from '../types/index.js';
+export declare class Tag {
+    readonly type: types.StructuredType;
+    readonly constructor_: types.Constructor;
+    readonly argumentByParameter: ReadonlyMap<VariableEntity, TagArgument>;
+    private readonly _argumentByName;
+    get argumentByName(): ReadonlyMap<string, TagArgument>;
+    constructor(type: types.StructuredType, constructor_: types.Constructor, argumentByParameter: ReadonlyMap<VariableEntity, TagArgument>);
+}
+export type TagArgument = TagArgument_string | TagArgument_numeric | TagArgument_boolean | TagArgument_invalid;
+export declare class TagArgument_string {
+    readonly value: string;
+    readonly kind = "string";
+    constructor(value: string);
+}
+export declare class TagArgument_numeric {
+    readonly value: number;
+    readonly kind = "numeric";
+    constructor(value: number);
+}
+export declare class TagArgument_boolean {
+    readonly value: boolean;
+    readonly kind = "boolean";
+    constructor(value: boolean);
+}
+export declare class TagArgument_invalid {
+    readonly kind = "invalid";
+}

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

@@ -0,0 +1,5 @@
+import * as types from '../types/index.js';
+export declare class TargetTypeHint {
+    readonly value: types.Type | undefined;
+    constructor(value: types.Type | undefined);
+}

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

@@ -0,0 +1,9 @@
+import * as types from '../types/index.js';
+import { Analyzer } from './index.js';
+export declare class TypeInferrer {
+    private readonly _analyzer;
+    private _getType;
+    private _typeInferringState;
+    constructor(analyzer: Analyzer, getType: () => types.Type);
+    inferType(): types.Type;
+}