@artel/artc 0.6.26039 → 0.9.26001

package/build/types/analysis/m/CallExpressionMeaning.d.ts

@@ -0,0 +1,72 @@
+import { AccessKind } from '../../common/index.js';
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import { NamedTypeEntity } from '../../entities/index.js';
+import * as tree from '../../tree/m/index.js';
+import * as types from '../../types/index.js';
+import { AccessedFunction, NotSubstitutedAccessedFunction } from '../AccessedFunction.js';
+import { Analyzer } from './Analyzer.js';
+import { ExpressionAnalysisOptions } from './ExpressionAnalysisOptions.js';
+export declare class Resolver {
+    private readonly analyzer;
+    private readonly node;
+    private readonly analysisOptions;
+    private readonly diagnostics;
+    constructor(analyzer: Analyzer, node: tree.CallExpression, analysisOptions: ExpressionAnalysisOptions | undefined, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): Meaning;
+    private checkExpressionDenotesType;
+    private checkExpressionDenotesFunction;
+    private resolveFunctionCallExpression;
+    private getBaseTypeEntity;
+    private resolveConstructorCallOrVariantAccessExpression;
+    private resolveObjectFunctionCallExpression;
+}
+export type Meaning = Meaning_functionCall | Meaning_objectFunctionCall | Meaning_constructorCall | Meaning_variantValueAccess | Meaning_unresolved;
+export declare class Meaning_functionCall {
+    readonly candidates: readonly NotSubstitutedAccessedFunction[];
+    readonly suitableOrSingleFunction: AccessedFunction | undefined;
+    readonly isOwnConstructorCall: boolean;
+    readonly isBaseConstructorCall: boolean;
+    readonly isAsFunctionCall: boolean;
+    readonly isIsFunctionCall: boolean;
+    readonly kind = "function-call";
+    constructor(candidates: readonly NotSubstitutedAccessedFunction[], suitableOrSingleFunction: AccessedFunction | undefined, isOwnConstructorCall: boolean, isBaseConstructorCall: boolean, isAsFunctionCall: boolean, isIsFunctionCall: boolean);
+}
+export declare class Meaning_objectFunctionCall {
+    readonly type: types.FunctionType;
+    readonly kind = "object-function-call";
+    constructor(type: types.FunctionType);
+}
+export declare class Meaning_constructorCall {
+    /**
+     * Тип объекта, получаемого в результате вызова конструктора.
+     *
+     * При поиске конструктора в типе-псевдониме конструктор может быть найден в оригинальном типе. В таком случае тип,
+     * создаваемый найденным конструктором, будет отличаться от результирующего типа, хранимого в этом поле, но будет
+     * с ним совместим.
+     */
+    readonly type: types.Type | undefined;
+    readonly typeEntity: NamedTypeEntity | undefined;
+    readonly candidates: readonly types.Method[];
+    readonly suitableOrSingleConstructor: types.Method | undefined;
+    readonly kind = "constructor-call";
+    constructor(
+    /**
+     * Тип объекта, получаемого в результате вызова конструктора.
+     *
+     * При поиске конструктора в типе-псевдониме конструктор может быть найден в оригинальном типе. В таком случае тип,
+     * создаваемый найденным конструктором, будет отличаться от результирующего типа, хранимого в этом поле, но будет
+     * с ним совместим.
+     */
+    type: types.Type | undefined, typeEntity: NamedTypeEntity | undefined, candidates: readonly types.Method[], suitableOrSingleConstructor: types.Method | undefined);
+}
+export declare class Meaning_variantValueAccess {
+    readonly suitableTypes: readonly types.Type[];
+    readonly type: types.Type;
+    readonly field: types.Field;
+    readonly accessKind: AccessKind;
+    readonly kind = "variant-value-access";
+    constructor(suitableTypes: readonly types.Type[], type: types.Type, field: types.Field, accessKind: AccessKind);
+}
+export declare class Meaning_unresolved {
+    readonly kind = "unresolved";
+}

package/build/types/analysis/m/ConstructorCallResolver.d.ts

@@ -0,0 +1,24 @@
+import { DiagnosticAcceptorWithArgumentFactory } from '../../diagnostic/Diagnostic.js';
+import { NamedTypeEntity } from '../../entities/index.js';
+import * as tree from '../../tree/m/index.js';
+import * as types from '../../types/index.js';
+import { NodeOrDiagnosticLocation } from '../NodeOrDiagnosticLocation.js';
+import { TypeMemberLookupContext } from '../TypeMemberLookup.js';
+import { Analyzer } from './Analyzer.js';
+import { ExpressionAnalysisOptions } from './ExpressionAnalysisOptions.js';
+export declare class Resolver {
+    static resolve(analyzer: Analyzer, candidates: readonly types.Method[], argumentList: tree.ArgumentList | undefined, diagnostics: DiagnosticAcceptorWithArgumentFactory | undefined, diagnosticLocation: NodeOrDiagnosticLocation | undefined): readonly types.Method[];
+    static resolveByNamedTypes(analyzer: Analyzer, typeEntities: readonly NamedTypeEntity[], argumentList: tree.ArgumentList | undefined, typeArgumentClause: tree.TypeArgumentClause | undefined, analysisOptions: ExpressionAnalysisOptions, typeMemberLookupContext: TypeMemberLookupContext, diagnostics: DiagnosticAcceptorWithArgumentFactory | undefined, diagnosticLocation: NodeOrDiagnosticLocation | undefined): ResolutionResult;
+    private static typeCanBeConstructed;
+}
+export declare class ResolutionResult {
+    readonly candidates: readonly types.Method[];
+    readonly suitableConstructors: readonly types.Method[];
+    readonly typeEntity: NamedTypeEntity | undefined;
+    readonly type: types.Type | undefined;
+    readonly singleNotSuitableSubstitutedCandidate: types.Method | undefined;
+    private static empty_;
+    static get empty(): ResolutionResult;
+    get suitableOrSingleConstructor(): types.Method | undefined;
+    constructor(candidates: readonly types.Method[], suitableConstructors: readonly types.Method[], typeEntity: NamedTypeEntity | undefined, type: types.Type | undefined, singleNotSuitableSubstitutedCandidate: types.Method | undefined);
+}

package/build/types/analysis/m/DeclarationsUsageCounter.d.ts

@@ -0,0 +1,12 @@
+import { TaskController } from '../../common/index.js';
+import * as tree from '../../tree/m/index.js';
+import { DeclarationsUsageMap } from '../DeclarationsUsageMap.js';
+import { Analyzer } from './Analyzer.js';
+export declare class DeclarationsUsageCounter {
+    private readonly analyzer;
+    private readonly sourceFile;
+    private readonly usageInfoByEntity;
+    constructor(analyzer: Analyzer, sourceFile: tree.SourceFile);
+    count(taskController: TaskController): Promise<DeclarationsUsageMap>;
+    private recordUsage;
+}

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

@@ -0,0 +1,28 @@
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import { DereferenceExpression } from '../../tree/m/index.js';
+import * as types from '../../types/index.js';
+import { ComputedAccess } from '../ComputedAccess.js';
+import { Analyzer } from './Analyzer.js';
+export declare class Resolver {
+    private readonly analyzer;
+    private readonly node;
+    private readonly diagnostics;
+    private readonly semanticContext_;
+    private get semanticContext();
+    constructor(analyzer: Analyzer, node: DereferenceExpression, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): Meaning;
+    private createComputedAccess;
+    private getAccessibleDereferenceOperatorGetter;
+    private getAccessibleDereferenceOperatorSetter;
+}
+export type Meaning = Meaning_resolved | Meaning_unresolved;
+declare class Meaning_resolved {
+    readonly operator: types.DereferenceOperator;
+    readonly access: ComputedAccess;
+    readonly kind = "resolved";
+    constructor(operator: types.DereferenceOperator, access: ComputedAccess);
+}
+declare class Meaning_unresolved {
+    readonly kind = "unresolved";
+}
+export {};

package/build/types/analysis/m/ExpressionAnalysisOptions.d.ts

@@ -0,0 +1,21 @@
+import * as types from '../../types/index.js';
+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;
+}

package/build/types/analysis/m/FunctionAccessResolver.d.ts

@@ -0,0 +1,19 @@
+import { DiagnosticAcceptorWithArgumentFactory } from '../../diagnostic/Diagnostic.js';
+import * as tree from '../../tree/m/index.js';
+import { AccessedFunction, NotSubstitutedAccessedFunction } from '../AccessedFunction.js';
+import { NodeOrDiagnosticLocation } from '../NodeOrDiagnosticLocation.js';
+import { Analyzer } from './Analyzer.js';
+import { ExpressionAnalysisOptions } from './ExpressionAnalysisOptions.js';
+export declare class Resolver {
+    static resolveByCallExpression(analyzer: Analyzer, candidates: readonly NotSubstitutedAccessedFunction[], node: tree.CallExpression, analysisOptions: ExpressionAnalysisOptions, diagnostics: DiagnosticAcceptorWithArgumentFactory | undefined): ResolutionResult;
+    static resolveByCallExpressionParts(analyzer: Analyzer, candidates: readonly NotSubstitutedAccessedFunction[], argumentList: tree.ArgumentList | undefined, typeArgumentClause: tree.TypeArgumentClause | undefined, analysisOptions: ExpressionAnalysisOptions, diagnostics: DiagnosticAcceptorWithArgumentFactory | undefined, diagnosticLocation: NodeOrDiagnosticLocation | undefined): ResolutionResult;
+    static resolveByTargetType(analyzer: Analyzer, candidates: readonly NotSubstitutedAccessedFunction[], typeArgumentClause: tree.TypeArgumentClause | undefined, analysisOptions: ExpressionAnalysisOptions, diagnostics: DiagnosticAcceptorWithArgumentFactory | undefined, diagnosticLocation: NodeOrDiagnosticLocation | undefined): ResolutionResult;
+    private static convertProcessedSignature;
+    private static reportAmbiguousAccessDiagnostic;
+}
+export declare class ResolutionResult {
+    readonly suitableFunctions: readonly AccessedFunction[];
+    readonly singleNotSuitableSubstitutedCandidate: AccessedFunction | undefined;
+    get suitableOrSingleFunction(): AccessedFunction | undefined;
+    constructor(suitableFunctions: readonly AccessedFunction[], singleNotSuitableSubstitutedCandidate: AccessedFunction | undefined);
+}

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

@@ -0,0 +1,137 @@
+import { Name } from '../../common/index.js';
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import { NamedTypeEntity, PackageAliasEntity, ParameterEntity, VariableEntity } from '../../entities/index.js';
+import * as tree from '../../tree/m/index.js';
+import * as types from '../../types/index.js';
+import { AccessedFunction, NotSubstitutedAccessedFunction } from '../AccessedFunction.js';
+import { ComputedAccess } from '../ComputedAccess.js';
+import { PackageNameTreeNode } from '../ImportedPackageNameTree.js';
+import { Analyzer } from './Analyzer.js';
+import * as callExpressionMeaning from './CallExpressionMeaning.js';
+import { ExpressionAnalysisOptions } from './ExpressionAnalysisOptions.js';
+import { NamedDeclaration } from './semantic-context/index.js';
+export declare class FirstStageResolver {
+    private readonly semanticContext_;
+    private readonly analyzer;
+    private readonly node;
+    private readonly diagnostics;
+    private get semanticContext();
+    constructor(analyzer: Analyzer, node: tree.IdentifierExpression, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): MeaningStage1;
+    private resolveVariableAccess;
+    private resolveVariableEntityAccess;
+    private resolvePackageVariableAccess;
+    private getAccessiblePackageVariableGetter;
+    private getAccessiblePackageVariableSetter;
+    private resolveFieldAccess;
+    private getAccessibleFieldGetter;
+    private getAccessibleFieldSetter;
+    private resolveAccessOfVariableWithoutExplicitAccessors;
+    private checkExpressionDenotesType;
+    private resolveTypeAccess;
+    private tryResolveVariantValueAccess;
+    private createNotSubstitutedAccessedFunction;
+    private createComputedAccessForVariableWithoutExplicitAccessors;
+}
+export declare class SecondStageResolver {
+    private readonly analyzer;
+    private readonly node;
+    private readonly firstStageMeaning;
+    private readonly analysisOptions;
+    private readonly diagnostics;
+    constructor(analyzer: Analyzer, node: tree.IdentifierExpression, firstStageMeaning: MeaningStage1, analysisOptions: ExpressionAnalysisOptions | undefined, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): Meaning;
+    private resolveTypeAccessAtCalleePosition;
+    private resolveFunctionAccess;
+    private resolveNotCalledFunctionsAccess;
+}
+export type Meaning = Meaning_variableAccess | Meaning_functionAccess | Meaning_packageNameSegmentAccess | Meaning_packageAliasAccess | Meaning_typeAccess | Meaning_variantValueAccess | Meaning_typeAccessAtConstructorCall | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
+declare class Meaning_variableAccess {
+    readonly variable: AccessedVariable;
+    readonly access: ComputedAccess;
+    readonly objectParameterContainingVariable: ParameterEntity | undefined;
+    readonly kind = "variable-access";
+    constructor(variable: AccessedVariable, access: ComputedAccess, objectParameterContainingVariable: ParameterEntity | undefined);
+}
+declare class Meaning_variantValueAccess {
+    readonly suitableTypes: readonly types.Type[];
+    readonly type: types.Type;
+    readonly field: types.Field;
+    readonly access: ComputedAccess;
+    readonly kind = "variant-value-access";
+    constructor(suitableTypes: readonly types.Type[], type: types.Type, field: types.Field, access: ComputedAccess);
+}
+declare class Meaning_functionAccess {
+    readonly candidates: readonly NotSubstitutedAccessedFunction[];
+    readonly suitableOrSingleFunction: AccessedFunction | undefined;
+    readonly objectParameterContainingFunctions: ParameterEntity | undefined;
+    readonly kind = "function-access";
+    constructor(candidates: readonly NotSubstitutedAccessedFunction[], suitableOrSingleFunction: AccessedFunction | undefined, objectParameterContainingFunctions: ParameterEntity | undefined);
+}
+declare class Meaning_packageAliasAccess {
+    readonly packageAlias: PackageAliasEntity;
+    readonly kind = "package-alias-access";
+    constructor(packageAlias: PackageAliasEntity);
+}
+declare class Meaning_packageNameSegmentAccess {
+    readonly packageTreeNode: PackageNameTreeNode;
+    readonly kind = "package-name-segment-access";
+    constructor(packageTreeNode: PackageNameTreeNode);
+}
+declare class Meaning_typeAccess {
+    readonly candidates: readonly NamedTypeEntity[];
+    readonly suitableTypes: readonly types.Type[];
+    readonly isUsedAsValue: boolean;
+    readonly kind = "type-access";
+    get singleSuitableType(): types.Type | undefined;
+    constructor(candidates: readonly NamedTypeEntity[], suitableTypes: readonly types.Type[], isUsedAsValue: boolean);
+}
+declare class Meaning_typeAccessAtConstructorCall {
+    readonly typeCandidates: readonly NamedTypeEntity[];
+    readonly callExpressionMeaning: callExpressionMeaning.Meaning_constructorCall;
+    readonly kind = "type-access-at-constructor-call";
+    constructor(typeCandidates: readonly NamedTypeEntity[], callExpressionMeaning: callExpressionMeaning.Meaning_constructorCall);
+}
+declare class Meaning_mixedAmbiguousAccess {
+    readonly declarations: readonly NamedDeclaration[];
+    readonly kind = "mixed-ambiguous-access";
+    constructor(declarations: readonly NamedDeclaration[]);
+}
+declare class Meaning_unresolved {
+    readonly kind = "unresolved";
+}
+export type MeaningStage1 = Meaning_variableAccess | MeaningStage1_functionAccess | Meaning_packageNameSegmentAccess | Meaning_packageAliasAccess | MeaningStage1_typeAccessAtCalleePosition | Meaning_typeAccess | Meaning_variantValueAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
+declare class MeaningStage1_typeAccessAtCalleePosition {
+    readonly types: readonly NamedTypeEntity[];
+    readonly kind = "type-access-at-callee-position";
+    constructor(types: readonly NamedTypeEntity[]);
+}
+declare class MeaningStage1_functionAccess {
+    readonly functions: readonly NotSubstitutedAccessedFunction[];
+    readonly objectParameterContainingFunctions: ParameterEntity | undefined;
+    readonly kind = "function-access";
+    constructor(functions: readonly NotSubstitutedAccessedFunction[], objectParameterContainingFunctions: ParameterEntity | undefined);
+}
+export type AccessedVariable = AccessedVariable_entity | AccessedVariable_typeMember;
+export declare class AccessedVariable_entity implements IAccessedVariable {
+    readonly value: VariableEntity;
+    readonly kind = "entity";
+    constructor(value: VariableEntity);
+    getEntity(): VariableEntity;
+    getName(): Name;
+    getType(): types.Type;
+}
+export declare class AccessedVariable_typeMember implements IAccessedVariable {
+    readonly value: types.Field;
+    readonly kind = "type-member";
+    constructor(value: types.Field);
+    getEntity(): VariableEntity;
+    getName(): Name;
+    getType(): types.Type;
+}
+interface IAccessedVariable {
+    getEntity(): VariableEntity;
+    getName(): Name;
+    getType(): types.Type;
+}
+export {};

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

@@ -0,0 +1,32 @@
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import { IndexedAccessExpression } from '../../tree/m/index.js';
+import * as types from '../../types/index.js';
+import { ComputedAccess } from '../ComputedAccess.js';
+import { Analyzer } from './Analyzer.js';
+export declare class Resolver {
+    private readonly analyzer;
+    private readonly node;
+    private readonly diagnostics;
+    private readonly semanticContext_;
+    private get semanticContext();
+    constructor(analyzer: Analyzer, node: IndexedAccessExpression, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): Meaning;
+    private createComputedAccess;
+    private getAccessibleIndexerGetter;
+    private getAccessibleIndexerSetter;
+    private getDiagnosticLocation;
+}
+export type Meaning = Meaning_resolved | Meaning_unresolved;
+declare class Meaning_resolved {
+    readonly candidates: readonly types.Indexer[];
+    readonly suitableIndexers: readonly types.Indexer[];
+    readonly access: ComputedAccess;
+    readonly kind = "resolved";
+    get singleSuitableIndexer(): types.Indexer | undefined;
+    get singleIndexer(): types.Indexer | undefined;
+    constructor(candidates: readonly types.Indexer[], suitableIndexers: readonly types.Indexer[], access: ComputedAccess);
+}
+declare class Meaning_unresolved {
+    readonly kind = "unresolved";
+}
+export {};

package/build/types/analysis/m/InstanceFieldsInitializationValidator.d.ts

@@ -0,0 +1,18 @@
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import * as tree from '../../tree/m/index.js';
+import { DeclarationsUsageMap } from '../DeclarationsUsageMap.js';
+import { Analyzer } from './Analyzer.js';
+export declare class InstanceFieldsInitializationValidator {
+    private readonly analyzer;
+    private readonly typeDeclaration;
+    private readonly declarationsUsageCountResult;
+    private readonly diagnostics;
+    private readonly semanticContext_;
+    private get semanticContext();
+    constructor(analyzer: Analyzer, typeDeclaration: tree.TypeWithMembersDeclaration, declarationsUsageCountResult: DeclarationsUsageMap, diagnostics: DiagnosticAcceptor);
+    validate(): void;
+    private getFieldsThatNeedToBeInitializedInConstructor;
+    private checkDefaultConstructorInitializesAllFields;
+    private checkConstructorInitializesAllFields;
+    private getFieldDiagnosticLocationWithFallback;
+}

package/build/types/analysis/m/MemberAccessExpressionMeaning.d.ts

@@ -0,0 +1,137 @@
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import { Entity, PackageTypeEntity, PackageVariableEntity } from '../../entities/index.js';
+import * as tree from '../../tree/m/index.js';
+import * as types from '../../types/index.js';
+import { AccessedFunction, NotSubstitutedAccessedFunction } from '../AccessedFunction.js';
+import { ComputedAccess } from '../ComputedAccess.js';
+import { PackageNameTreeNode } from '../ImportedPackageNameTree.js';
+import { Analyzer } from './Analyzer.js';
+import * as callExpressionMeaning from './CallExpressionMeaning.js';
+import { ExpressionAnalysisOptions } from './ExpressionAnalysisOptions.js';
+export declare class FirstStageResolver {
+    private readonly semanticContext_;
+    private readonly analyzer;
+    private readonly node;
+    private readonly diagnostics;
+    private get memberName();
+    private get semanticContext();
+    private get receiver();
+    constructor(analyzer: Analyzer, node: tree.MemberAccessExpression, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): MeaningStage1;
+    private resolvePackageAliasMemberAccessMeaning;
+    private resolvePackageMemberAccessMeaning;
+    private resolvePackageTypeAccess;
+    private resolvePackageNameSegmentAccessMeaning;
+    private resolveStaticMemberOrVariantAccessMeaning;
+    private resolveInstanceMemberAccessMeaning;
+    private resolveFieldAccess;
+    private getAccessibleFieldGetter;
+    private getAccessibleFieldSetter;
+    private resolvePackageVariableAccess;
+    private getAccessiblePackageVariableGetter;
+    private getAccessiblePackageVariableSetter;
+    private createComputedAccessForVariableWithoutExplicitAccessors;
+}
+export declare class SecondStageResolver {
+    private readonly analyzer;
+    private readonly node;
+    private readonly firstStageMeaning;
+    private readonly analysisOptions;
+    private readonly diagnostics;
+    constructor(analyzer: Analyzer, node: tree.MemberAccessExpression, firstStageMeaning: MeaningStage1, analysisOptions: ExpressionAnalysisOptions | undefined, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): Meaning;
+    private resolveTypeAccessAtCalleePosition;
+    private resolvePackageFunctionAccess;
+    private resolveStaticMethodAccess;
+    private resolveInstanceMethodAccess;
+    private resolveNotCalledFunctionsAccess;
+}
+export type Meaning = Meaning_packageVariableAccess | Meaning_packageFunctionAccess | Meaning_packageTypeAccess | Meaning_typeAccessAtConstructorCall | Meaning_packageNameSegmentAccess | Meaning_staticFieldAccess | Meaning_staticMethodAccess | Meaning_instanceFieldAccess | Meaning_instanceMethodAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
+declare class Meaning_packageVariableAccess {
+    readonly variable: PackageVariableEntity;
+    readonly access: ComputedAccess;
+    readonly kind = "package-variable-access";
+    constructor(variable: PackageVariableEntity, access: ComputedAccess);
+}
+declare class Meaning_packageFunctionAccess {
+    readonly candidates: readonly NotSubstitutedAccessedFunction[];
+    readonly suitableOrSingleFunction: AccessedFunction | undefined;
+    readonly kind = "package-function-access";
+    constructor(candidates: readonly NotSubstitutedAccessedFunction[], suitableOrSingleFunction: AccessedFunction | undefined);
+}
+declare class Meaning_packageTypeAccess {
+    readonly candidates: readonly PackageTypeEntity[];
+    readonly suitableTypes: readonly types.Type[];
+    readonly isUsedAsValue: boolean;
+    readonly kind = "package-type-access";
+    get singleSuitableType(): types.Type | undefined;
+    constructor(candidates: readonly PackageTypeEntity[], suitableTypes: readonly types.Type[], isUsedAsValue: boolean);
+}
+declare class Meaning_typeAccessAtConstructorCall {
+    readonly typeCandidates: readonly PackageTypeEntity[];
+    readonly callExpressionMeaning: callExpressionMeaning.Meaning_constructorCall;
+    readonly kind = "type-access-at-constructor-call";
+    constructor(typeCandidates: readonly PackageTypeEntity[], callExpressionMeaning: callExpressionMeaning.Meaning_constructorCall);
+}
+declare class Meaning_packageNameSegmentAccess {
+    readonly packageTreeNode: PackageNameTreeNode;
+    readonly kind = "package-name-segment-access";
+    constructor(packageTreeNode: PackageNameTreeNode);
+}
+declare class Meaning_staticFieldAccess {
+    readonly type: types.Type;
+    readonly field: types.Field;
+    readonly access: ComputedAccess;
+    readonly kind = "static-field-access";
+    constructor(type: types.Type, field: types.Field, access: ComputedAccess);
+}
+declare class Meaning_staticMethodAccess {
+    readonly type: types.Type;
+    readonly candidates: readonly NotSubstitutedAccessedFunction[];
+    readonly suitableOrSingleFunction: AccessedFunction | undefined;
+    readonly kind = "static-method-access";
+    constructor(type: types.Type, candidates: readonly NotSubstitutedAccessedFunction[], suitableOrSingleFunction: AccessedFunction | undefined);
+}
+declare class Meaning_instanceFieldAccess {
+    readonly field: types.Field;
+    readonly access: ComputedAccess;
+    readonly kind = "instance-field-access";
+    constructor(field: types.Field, access: ComputedAccess);
+}
+declare class Meaning_instanceMethodAccess {
+    readonly candidates: readonly NotSubstitutedAccessedFunction[];
+    readonly suitableOrSingleFunction: AccessedFunction | undefined;
+    readonly kind = "instance-method-access";
+    constructor(candidates: readonly NotSubstitutedAccessedFunction[], suitableOrSingleFunction: AccessedFunction | undefined);
+}
+declare class Meaning_mixedAmbiguousAccess {
+    readonly entities: readonly Entity[];
+    readonly kind = "mixed-ambiguous-access";
+    constructor(entities: readonly Entity[]);
+}
+declare class Meaning_unresolved {
+    readonly kind = "unresolved";
+}
+export type MeaningStage1 = Meaning_packageVariableAccess | MeaningStage1_packageFunctionAccess | Meaning_packageTypeAccess | MeaningStage1_typeAccessAtCalleePosition | Meaning_packageNameSegmentAccess | Meaning_staticFieldAccess | MeaningStage1_staticMethodAccess | Meaning_instanceFieldAccess | MeaningStage1_instanceMethodAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
+declare class MeaningStage1_typeAccessAtCalleePosition {
+    readonly types: readonly PackageTypeEntity[];
+    readonly kind = "type-access-at-callee-position";
+    constructor(types: readonly PackageTypeEntity[]);
+}
+declare class MeaningStage1_packageFunctionAccess {
+    readonly functions: readonly NotSubstitutedAccessedFunction[];
+    readonly kind = "package-function-access";
+    constructor(functions: readonly NotSubstitutedAccessedFunction[]);
+}
+declare class MeaningStage1_staticMethodAccess {
+    readonly type: types.Type;
+    readonly functions: readonly NotSubstitutedAccessedFunction[];
+    readonly kind = "static-method-access";
+    constructor(type: types.Type, functions: readonly NotSubstitutedAccessedFunction[]);
+}
+declare class MeaningStage1_instanceMethodAccess {
+    readonly functions: readonly NotSubstitutedAccessedFunction[];
+    readonly kind = "instance-method-access";
+    constructor(functions: readonly NotSubstitutedAccessedFunction[]);
+}
+export {};

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

@@ -0,0 +1,20 @@
+export declare enum ModifierFlags {
+    None = 0,
+    HiddenWithoutLevel = 1,
+    HiddenInType = 2,
+    HiddenInHierarchy = 4,
+    HiddenInFile = 8,
+    HiddenInPackage = 16,
+    Static = 32,
+    Abstract = 64,
+    Basic = 128,
+    Override = 256,
+    Async = 512,
+    Const = 1024,
+    First = 1,
+    Last = 1024,
+    NotComputed = 2048,
+    AnyHiddenModifier = 31,
+    HiddenInPackageOrWithoutLevel = 17,
+    HiddenInTypeOrWithoutLevel = 3
+}

package/build/types/analysis/m/NamedTypeResolver.d.ts

@@ -0,0 +1,44 @@
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import { NamedTypeEntity, PackageAliasEntity } from '../../entities/index.js';
+import { QualifiedName } from '../../tree/m/index.js';
+import { EntityOrPackageNameTreeNode } from '../EntityOrPackageNameTreeNode.js';
+import { PackageNameTreeNode } from '../ImportedPackageNameTree.js';
+import { Analyzer } from './Analyzer.js';
+export declare class NamedTypeResolver {
+    private readonly analyzer;
+    private readonly node;
+    private readonly diagnostics;
+    private readonly semanticContext_;
+    private get semanticContext();
+    constructor(analyzer: Analyzer, node: QualifiedName, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): NamedTypeResolutionResult;
+    private lookupTypeOrContainerWithTypes;
+    private findTypesOrContainersWithTypesInResolvedQualifier;
+    private findTypesOrContainersWithTypesInPackageAccessedViaAlias;
+    private findTypesOrContainersWithTypesInPackageNameSegment;
+    private convertPackageMember;
+    private createAmbiguousAccessDiagnostic;
+}
+export declare class NamedTypeResolutionResult {
+    readonly types: readonly NamedTypeEntity[];
+    readonly resolvedQualifiers: readonly ResolvedQualifier[];
+    readonly ambiguousDeclarations: readonly EntityOrPackageNameTreeNode[] | undefined;
+    constructor(types: readonly NamedTypeEntity[], resolvedQualifiers: readonly ResolvedQualifier[], ambiguousDeclarations: readonly EntityOrPackageNameTreeNode[] | undefined);
+}
+export type ResolvedQualifier = ResolvedQualifier_packageNameSegment | ResolvedQualifier_packageAlias | ResolvedQualifier_type;
+export declare class ResolvedQualifier_packageNameSegment {
+    readonly packageTreeNode: PackageNameTreeNode;
+    readonly kind = "package-name-segment";
+    constructor(packageTreeNode: PackageNameTreeNode);
+}
+export declare class ResolvedQualifier_packageAlias {
+    readonly packageAlias: PackageAliasEntity;
+    readonly kind = "package-alias";
+    constructor(packageAlias: PackageAliasEntity);
+}
+export declare class ResolvedQualifier_type {
+    readonly candidates: readonly NamedTypeEntity[];
+    readonly suitableTypes: readonly NamedTypeEntity[];
+    readonly kind = "type";
+    constructor(candidates: readonly NamedTypeEntity[], suitableTypes: readonly NamedTypeEntity[]);
+}

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

@@ -0,0 +1,19 @@
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import { NamedTypeSpecifier } from '../../tree/m/index.js';
+import * as types from '../../types/index.js';
+import { EntityOrPackageNameTreeNode } from '../EntityOrPackageNameTreeNode.js';
+import { Analyzer } from './Analyzer.js';
+import { ResolvedQualifier } from './NamedTypeResolver.js';
+export declare class NamedTypeSpecifierResolver {
+    private readonly analyzer;
+    private readonly node;
+    private readonly diagnostics;
+    constructor(analyzer: Analyzer, node: NamedTypeSpecifier, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): NamedTypeSpecifierResolutionResult;
+}
+export declare class NamedTypeSpecifierResolutionResult {
+    readonly type: types.Type | undefined;
+    readonly resolvedQualifiers: readonly ResolvedQualifier[];
+    readonly ambiguousDeclarations: readonly EntityOrPackageNameTreeNode[] | undefined;
+    constructor(type: types.Type | undefined, resolvedQualifiers: readonly ResolvedQualifier[], ambiguousDeclarations: readonly EntityOrPackageNameTreeNode[] | undefined);
+}

package/build/types/analysis/m/ObjectExpressionMeaning.d.ts

@@ -0,0 +1,29 @@
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import { ParameterEntity } from '../../entities/index.js';
+import * as tree from '../../tree/m/index.js';
+import * as types from '../../types/index.js';
+import { Analyzer } from './Analyzer.js';
+export declare class Resolver {
+    private readonly analyzer;
+    private readonly node;
+    private readonly diagnostics;
+    constructor(analyzer: Analyzer, node: tree.ObjectExpression, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): Meaning;
+    private invalidContextDiagnostic;
+    private staticContextDiagnostic;
+}
+export type Meaning = Meaning_objectAccess | Meaning_objectParameterAccess | Meaning_unresolved;
+declare class Meaning_objectAccess {
+    readonly type: types.Type;
+    readonly kind = "object-access";
+    constructor(type: types.Type);
+}
+declare class Meaning_objectParameterAccess {
+    readonly parameter: ParameterEntity;
+    readonly kind = "object-parameter-access";
+    constructor(parameter: ParameterEntity);
+}
+declare class Meaning_unresolved {
+    readonly kind = "unresolved";
+}
+export {};