@artel/artc 0.6.25280 → 0.6.25282

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

@@ -20,6 +20,7 @@ export declare class AccessedFunction_entity implements IAccessedFunction {
     getSignatureType(analyzer: Analyzer): types.FunctionType;
     applySubstitutions(substitutions: types.Substitutions): AccessedFunction;
     getOuterSubstitutions(): types.Substitutions | undefined;
+    equals(other: AccessedFunction, considerLocale?: boolean): boolean;
 }
 export declare class AccessedFunction_typeMember implements IAccessedFunction {
     readonly value: types.Method;
@@ -35,6 +36,7 @@ export declare class AccessedFunction_typeMember implements IAccessedFunction {
     getSignatureType(_analyzer: Analyzer): types.FunctionType;
     applySubstitutions(substitutions: types.Substitutions): AccessedFunction;
     getOuterSubstitutions(): types.Substitutions | undefined;
+    equals(other: AccessedFunction, considerLocale?: boolean): boolean;
 }
 export declare class AccessedFunction_substitutedFunction implements IAccessedFunction {
     readonly value: SubstitutedFunction;
@@ -48,6 +50,7 @@ export declare class AccessedFunction_substitutedFunction implements IAccessedFu
     getName(): Name;
     getSignatureType(analyzer: Analyzer): types.FunctionType;
     getOuterSubstitutions(): types.Substitutions | undefined;
+    equals(other: AccessedFunction, considerLocale?: boolean): boolean;
 }
 export declare class AccessedFunctionParameter {
     readonly entity: ParameterEntity;
@@ -62,5 +65,6 @@ interface IAccessedFunction {
     getName(): Name;
     getSignatureType(analyzer: Analyzer): types.FunctionType;
     getOuterSubstitutions(): types.Substitutions | undefined;
+    equals(other: AccessedFunction, considerLocale: boolean): boolean;
 }
 export {};

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

@@ -1,6 +1,6 @@
 import { PackageLocale } from '../common/index.js';
 import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
-import { EntityLocalizationContext } from '../entities/EntityLocalizationContext.js';
+import { EntityLocalizationContext, LocalizablePackageMemberEntity } from '../entities/EntityLocalizationContext.js';
 import { AnonymousTypeEntity, Entity, EntityContainingParameter, EntityContainingTypeParameter, PackageEntity, PackageEntityMembers, PackageMemberEntity, ParameterEntity, TypeEntityMembers, TypeMemberEntity, TypeParameterEntity, TypeWithMembersOrExtensionEntity } from '../entities/index.js';
 import { PackageName, SourceFile, TranslationPackage } from '../project/index.js';
 import * as tree from '../tree/index.js';
@@ -28,9 +28,9 @@ export declare class AnalyzedTranslationPackage {
     getTranslatedPackageMembers(): PackageEntityMembers;
     ensureAllLazyDiagnosticsReportedForSourceFile(sourceFile: SourceFile): void;
     accumulateDiagnosticForSourceFile(sourceFile: SourceFile, diagnostics: DiagnosticAcceptor): void;
-    getPackageMemberTranslationTargets(node: tree.TranslationDeclaration): TranslationTargets<PackageMemberEntity> | undefined;
+    getPackageMemberTranslationTargets(node: tree.TranslationDeclaration): TranslationTargets<LocalizablePackageMemberEntity> | undefined;
     getTypeMemberTranslationTargets(node: tree.TypeMemberTranslation): TranslationTargets<TypeMemberEntity> | undefined;
-    getTranslatedPackageMember(entity: PackageMemberEntity): PackageMemberEntity;
+    getTranslatedPackageMember(entity: LocalizablePackageMemberEntity): LocalizablePackageMemberEntity;
     getTranslatedTypeMember(entity: TypeMemberEntity): TypeMemberEntity;
     getTranslatedAnonymousTypeEntity(entity: AnonymousTypeEntity): AnonymousTypeEntity;
     getTranslatedTypeOrExtensionMembers(translatedTypeEntity: TypeWithMembersOrExtensionEntity): TypeEntityMembers;

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

@@ -3,6 +3,7 @@ import { DisplayableOrPrimitive, Name, PackageLocale, Query, Range, TaskControll
 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 { ReservedIdentifierKind } from '../parser/ReservedIdentifierDictionary.js';
@@ -13,7 +14,6 @@ import { TsInteropContext, TsProgramState } from '../ts-interop/TsInteropContext
 import * as types from '../types/index.js';
 import { TypeFactory } from '../types/index.js';
 import { AccessedFunction } from './AccessedFunction.js';
-import { AnalyzedTextTranslationPackage } from './AnalyzedTextTranslationPackage.js';
 import { AnalyzedTranslationPackage } from './AnalyzedTranslationPackage.js';
 import { ArgumentToParameterMatchResult, MatchResultParameter } from './ArgumentToParameterMatchResult.js';
 import * as autotypeCallExpressionMeaning from './AutotypeCallExpressionMeaning.js';
@@ -31,15 +31,14 @@ import { NamedTypeSpecifierResolutionResult } from './NamedTypeSpecifierResolver
 import { DereferencedVariableAccessorDeclaration, FieldAccessorDeclaration, FunctionDeclaration, FunctionTypeDeclaration, GetterDeclaration, IndexedElementAccessorDeclaration, PackageVariableAccessorDeclaration, RegularOrBlockFunctionLiteral, SetterDeclaration, StructuredTypeDeclaration, TypeDeclaration, TypeWithMembersDeclaration, VariantTypeDeclaration } from './NodeTypeUtils.js';
 import * as objectExpressionMeaning from './ObjectExpressionMeaning.js';
 import { OwnAndBaseConstructorCallsCheckResult } from './OwnAndBaseConstructorCallsChecker.js';
-import { SourceFileMembers } from './SourceFileMembers.js';
+import { ResolvedTextTranslationPackage } from './ResolvedTextTranslationPackage.js';
 import * as tags from './Tag.js';
 import * as tagMeaning from './TagMeaning.js';
+import { TypeWithMembersOrTypeExtensionDeclaration } from './TreeQuery.js';
 import { TypeMemberImplementationCheckResult } from './TypeMemberImplementationChecker.js';
 import * as controlFlow from './control-flow/index.js';
 import { WellKnownDeclarations } from './index.js';
 import * as semanticContext from './semantic-context/index.js';
-import { TypeWithMembersOrTypeExtensionDeclaration } from './TreeQuery.js';
-import { WithDiagnostics } from '../diagnostic/WithDiagnostics.js';
 export declare class Analyzer {
     readonly compilation: project.Compilation;
     /**
@@ -78,7 +77,6 @@ export declare class Analyzer {
     private readonly tsInterop_;
     private readonly memberAccessExpressionResolutionResults;
     private readonly memberAccessExpressionResolutionResultsFirstStage;
-    private readonly sourceFileMembers;
     private readonly callExpressionResolutionResults;
     private readonly indexedAccessExpressionResolutionResults;
     private readonly dereferenceExpressionMeanings;
@@ -93,20 +91,19 @@ export declare class Analyzer {
     private readonly prefixUnaryExpressionOperatorResolutionResults;
     private readonly binaryExpressionUserDefinableOperatorResolutionResults;
     private readonly assignmentStatementOperatorResolutionResults;
-    private readonly extendedTypes;
     private readonly analyzedTranslationPackages;
-    private readonly analyzedTextTranslationPackages;
+    private readonly resolvedTextTranslationPackages;
     private textTranslationPackagesByTargetPackage;
     private primaryTextTranslationPackageByTargetPackage;
-    private primaryTextTranslationEntityByLocalizableText;
-    private primaryTextTranslationEntityByLocalizableTextTemplate;
+    private resolvedLocalizableTexts;
     private readonly linkedMultiPlatformPackagesByPlatform;
     private readonly isFunctionGeneratorCheckResults;
     private readonly namedDeclarationsUsageCountResults;
     private readonly packageAndStaticVariablesInitializationDiagnostics;
     private readonly controlFlowGraphs;
-    private readonly diagnosticsComputedLazily;
-    private readonly diagnosticsComputedLazilyAcceptor;
+    private sideDiagnosticAcceptor;
+    private readonly sideDiagnosticsByFile;
+    private readonly sideDiagnosticsWithoutFile;
     private readonly sourcePackageMemberConflictsDiagnostics;
     private readonly notExplicitlyImplementedAbstractTypeMembers;
     private readonly typeMemberImplementationCheckResults;
@@ -137,21 +134,19 @@ export declare class Analyzer {
     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.FirstStageResolutionResult;
-    resolveMemberAccessExpression(node: tree.MemberAccessExpression, analysisOptions?: ExpressionAnalysisOptions): memberAccessExpressionResolution.ResolutionResult;
-    getPackageImportsOfDirective(packageImportDirectives: Iterable<tree.PackageImportDirective>): Iterable<tree.PackageImport>;
-    getSourceFileMembers(node: tree.SourceFile): SourceFileMembers;
-    resolveCallExpression(node: tree.CallExpression, analysisOptions?: ExpressionAnalysisOptions): callExpressionMeaning.ResolutionResult;
+    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.ResolutionResult;
+    resolveIndexedAccessExpression(node: tree.IndexedAccessExpression): indexedAccessExpressionMeaning.Meaning;
     getDereferenceExpressionMeaning(node: tree.DereferenceExpression): dereferenceExpressionMeaning.Meaning;
     resolveAutotypeCallExpression(node: tree.AutotypeCallExpression, analysisOptions?: ExpressionAnalysisOptions): autotypeCallExpressionMeaning.ResolutionResult;
-    resolveIdentifierExpressionFirstStage(node: tree.IdentifierExpression): identifierExpressionResolution.FirstStageResolutionResult;
-    resolveIdentifierExpression(node: tree.IdentifierExpression, analysisOptions?: ExpressionAnalysisOptions): identifierExpressionResolution.ResolutionResult;
+    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.ResolutionResult;
-    resolveBaseExpressionFirstStage(node: tree.BaseExpression): baseExpressionMeaning.FirstStageResolutionsResult;
-    resolveBaseExpression(node: tree.BaseExpression): baseExpressionMeaning.ResolutionResult;
+    resolveObjectExpression(node: tree.ObjectExpression): objectExpressionMeaning.Meaning;
+    resolveBaseExpressionFirstStage(node: tree.BaseExpression): baseExpressionMeaning.MeaningStage1;
+    resolveBaseExpression(node: tree.BaseExpression): baseExpressionMeaning.Meaning;
     /**
      * Проверяет, является ли выражение цепочкой доступов через `?`, заканчивающейся выражением, тип которого допускает
      * `пусто`.
@@ -207,9 +202,9 @@ export declare class Analyzer {
     isFunctionGenerator(node: FunctionDeclaration): boolean;
     allAspectsOfType(type: types.Type): Iterable<types.StructuredType>;
     checkTypeIsBasedOnAspect(type: types.Type, aspectEntity: e.StructuredTypeEntity): boolean;
-    resolvePrefixUnaryExpressionUserDefinableOperator(node: tree.PrefixUnaryExpression): WithDiagnostics<types.Operator>;
-    resolveBinaryExpressionUserDefinableOperator(node: tree.BinaryExpression, operatorKind: BinaryOperatorKind): WithDiagnostics<types.Operator>;
-    resolveCompoundAssignmentStatementOperator(node: tree.AssignmentStatement, operatorKind: BinaryOperatorKind): WithDiagnostics<types.Operator>;
+    resolvePrefixUnaryExpressionUserDefinableOperator(node: tree.PrefixUnaryExpression): types.Operator | undefined;
+    resolveBinaryExpressionUserDefinableOperator(node: tree.BinaryExpression, operatorKind: BinaryOperatorKind): types.Operator | undefined;
+    resolveCompoundAssignmentStatementOperator(node: tree.AssignmentStatement, operatorKind: BinaryOperatorKind): types.Operator | undefined;
     classifyBinaryExpressionOperator(operator: tree.BinaryExpressionOperator): BinaryExpressionOperatorClassificationResult;
     getBinaryOperatorKindIfCompoundAssignmentOperator(operator: tree.AssignmentStatementOperator): BinaryOperatorKind | undefined;
     getOriginalPackageEntities(): readonly e.PackageEntity[];
@@ -261,20 +256,18 @@ export declare class Analyzer {
     excludeTypeFromUnion(initialType: types.Type, excludedType: types.Type): types.Type;
     isParameterVariadic(entity: e.VariableEntity): boolean;
     getDefaultTypeParameterConstraint(locale: PackageLocale): types.Type;
-    getExtendedType(node: tree.TypeExtensionDeclaration): WithDiagnostics<e.NamedTypeEntity>;
     getAnalyzedTranslationPackageIfTargetResolved(package_: project.TranslationPackage): AnalyzedTranslationPackage | undefined;
-    getAnalyzedTextTranslationPackageIfTargetResolved(package_: project.TextTranslationPackage): AnalyzedTextTranslationPackage | 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>;
-    enumerateAnalyzedTextTranslationPackages(): Query<AnalyzedTextTranslationPackage>;
+    enumerateResolvedTextTranslationPackages(): Query<ResolvedTextTranslationPackage>;
     getLinkedMultiPlatformPackagesByPlatform(entity: e.PackageEntity): ReadonlyMap<PlatformKind, LinkedMultiPlatformPackage> | undefined;
     getLinkedMultiPlatformPackage(entity: e.PackageEntity, platform: PlatformKind): LinkedMultiPlatformPackage | undefined;
-    getTextTranslationPackagesMap(): ReadonlyMap<e.PackageEntity, AnalyzedTextTranslationPackage[]>;
-    getTextTranslationPackagesOfTargetPackage(targetPackage: e.PackageEntity): AnalyzedTextTranslationPackage[] | undefined;
-    getPrimaryTextTranslationPackageOfTargetPackage(targetPackage: e.PackageEntity): AnalyzedTextTranslationPackage | undefined;
-    getPrimaryTextTranslationEntityByLocalizableText(node: tree.LocalizableTextLiteral): e.TextTranslationEntity | undefined;
-    getPrimaryTextTranslationEntityByLocalizableTextTemplate(node: tree.LocalizableTextTemplateLiteral): e.TextTranslationEntity | 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;
     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;
@@ -290,7 +283,7 @@ export declare class Analyzer {
     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(declaredMembers: readonly (e.NamedPackageMemberEntity | e.PackageAliasEntity)[], pkg: e.PackageEntity): e.PackageVariableEntity[];
+    createBackingPackageVariables(declaredPackageMembers: readonly e.NamedPackageMemberEntity[], pkg: e.PackageEntity): e.PackageVariableEntity[];
     createBackingFields(declaredMembers: readonly e.NamedTypeMemberEntity[], type: e.TypeEntity): e.FieldEntity[];
     createNodeDiagnostic(code: DiagnosticCode, node: tree.Node, 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;
@@ -306,10 +299,10 @@ export declare class Analyzer {
     createAmbiguousFunctionAccessDiagnostic(functions: readonly AccessedFunction[], node: tree.Node): Diagnostic;
     createAmbiguousTypeMemberAccessDiagnostic(members: readonly types.TypeMember[], node: tree.Node): Diagnostic;
     createAmbiguousNamedScopeDeclarationAccessDiagnostic(declarations: readonly semanticContext.NamedDeclaration[], node: tree.Node): Diagnostic;
-    addDiagnosticComputedLazily(diagnostic: Diagnostic): void;
-    getAcceptorForDiagnosticsComputedLazily(): DiagnosticAcceptor;
-    accumulateSourceFileDiagnosticsComputedLazily(sourceFile: project.SourceFile, diagnostics: DiagnosticAcceptor): void;
-    validateSourcePackageMemberConflicts(pkg: project.ProgramPackage): readonly 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;
     createEntityContextForTypeDeclaration(node: TypeDeclaration): e.EntityContext;
@@ -479,7 +472,6 @@ declare class Entity {
     private readonly setterEntities;
     private readonly typeExtensionEntities;
     private readonly packageAliasEntities;
-    private readonly translationTextTemplateParameterEntities;
     private readonly textTranslationDeclarationEntities;
     private readonly functionLiteralEntities;
     private readonly functionBlockLiteralEntities;
@@ -522,7 +514,7 @@ declare class Entity {
     ofSetterDeclaration(node: SetterDeclaration): e.SetterEntity;
     ofConstructorDeclaration(node: tree.ConstructorDeclaration): e.ConstructorEntity;
     ofDestructorDeclaration(node: tree.DestructorDeclaration): e.DestructorEntity;
-    ofVariantDeclaration(node: tree.VariantDeclaration): e.FieldEntity;
+    ofVariantValueDeclaration(node: tree.VariantValueDeclaration): e.FieldEntity;
     ofTypeExtensionDeclaration(node: tree.TypeExtensionDeclaration): e.TypeExtensionEntity;
     ofPackageImport(node: tree.PackageImport): e.PackageAliasEntity;
     ofTypeWithMembersDeclaration(node: TypeWithMembersDeclaration): e.TypeEntityWithMembers;
@@ -745,27 +737,22 @@ export declare enum TypeAssignabilityFlags {
 declare class PackageImports {
     private readonly analyzer;
     private readonly packagesAvailableForImport;
-    private readonly analyzedPackageImports;
+    private readonly resolvedPackageImports;
     private readonly importedPackages;
     private readonly automaticallyImportedPackages;
     private readonly importedPackageNameTrees;
     constructor(analyzer: Analyzer);
-    analyzeExplicitPackageImports(sourceFile: project.SourceFile): AnalyzedPackageImports;
+    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 AnalyzedPackageImport {
+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 AnalyzedPackageImports {
-    readonly packageImportInfos: Map<tree.PackageImport, AnalyzedPackageImport>;
-    readonly diagnostics: readonly Diagnostic[];
-    constructor(packageImportInfos: Map<tree.PackageImport, AnalyzedPackageImport>, diagnostics: readonly Diagnostic[]);
-}
 export declare class PackageImportInfo {
     readonly entity: e.PackageEntity;
     readonly aliasEntity: e.PackageAliasEntity | undefined;

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

@@ -1,4 +1,4 @@
-import { Diagnostic } from '../diagnostic/Diagnostic.js';
+import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
 import { AutotypeCallExpression } from '../tree/index.js';
 import * as types from '../types/index.js';
 import { Analyzer, ExpressionAnalysisOptions } from './index.js';
@@ -6,16 +6,16 @@ export declare class Resolver {
     private readonly analyzer;
     private readonly node;
     private readonly analysisOptions;
-    constructor(analyzer: Analyzer, node: AutotypeCallExpression, analysisOptions: ExpressionAnalysisOptions | undefined);
+    private readonly diagnostics;
+    constructor(analyzer: Analyzer, node: AutotypeCallExpression, analysisOptions: ExpressionAnalysisOptions | undefined, diagnostics: DiagnosticAcceptor | undefined);
     resolve(): ResolutionResult;
     private isAutotypeExpressionInValidPosition;
 }
 export declare class ResolutionResult {
     readonly meaning: Meaning;
-    readonly diagnostics?: readonly Diagnostic[] | undefined;
     readonly dependsOnTargetType: boolean;
-    constructor(meaning: Meaning, diagnostics?: readonly Diagnostic[] | undefined, dependsOnTargetType?: boolean);
-    static unresolved(diagnostics: readonly Diagnostic[] | undefined, dependsOnTargetType?: boolean): ResolutionResult;
+    constructor(meaning: Meaning, dependsOnTargetType?: boolean);
+    static unresolved(dependsOnTargetType?: boolean): ResolutionResult;
 }
 export type Meaning = Meaning_constructorCall | Meaning_unresolved;
 declare class Meaning_constructorCall {

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

@@ -1,4 +1,4 @@
-import { Diagnostic } from '../diagnostic/Diagnostic.js';
+import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
 import { AccessedFunction } from './AccessedFunction.js';
@@ -6,8 +6,9 @@ import { Analyzer } from './Analyzer.js';
 export declare class FirstStageResolver {
     private readonly analyzer;
     private readonly node;
-    constructor(analyzer: Analyzer, node: tree.BaseExpression);
-    resolve(): FirstStageResolutionsResult;
+    private readonly diagnostics;
+    constructor(analyzer: Analyzer, node: tree.BaseExpression, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): MeaningStage1;
     private resolveBaseConstructorOrMethodAccess;
     private resolveBaseConstructorAccess;
     private resolveBaseMethodAccess;
@@ -29,18 +30,13 @@ export declare class FirstStageResolver {
 export declare class SecondStageResolver {
     private readonly analyzer;
     private readonly node;
-    private readonly firstStageResolutionResult;
-    constructor(analyzer: Analyzer, node: tree.BaseExpression, firstStageResolutionResult: FirstStageResolutionsResult);
-    resolve(): ResolutionResult;
+    private readonly firstStageMeaning;
+    private readonly diagnostics;
+    constructor(analyzer: Analyzer, node: tree.BaseExpression, firstStageMeaning: MeaningStage1, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): Meaning;
     private resolveOverriddenMethodAccess;
     private resolveOverriddenOperatorAccess;
 }
-export declare class ResolutionResult {
-    readonly meaning: Meaning;
-    readonly diagnostics?: readonly Diagnostic[] | undefined;
-    constructor(meaning: Meaning, diagnostics?: readonly Diagnostic[] | undefined);
-    static unresolved(diagnostics?: readonly Diagnostic[]): ResolutionResult;
-}
 export type Meaning = Meaning_baseObjectAccess | Meaning_baseConstructorAccess | Meaning_overriddenMethodAccess | Meaning_overriddenOperatorAccess | Meaning_unresolved;
 declare class Meaning_baseObjectAccess {
     readonly type: types.Type;
@@ -84,12 +80,6 @@ declare class Meaning_overriddenOperatorAccess {
 declare class Meaning_unresolved {
     readonly kind = "unresolved";
 }
-export declare class FirstStageResolutionsResult {
-    readonly meaning: MeaningStage1;
-    readonly diagnostics?: readonly Diagnostic[] | undefined;
-    constructor(meaning: MeaningStage1, diagnostics?: readonly Diagnostic[] | undefined);
-    static unresolved(diagnostics?: readonly Diagnostic[]): FirstStageResolutionsResult;
-}
 export type MeaningStage1 = Meaning_baseObjectAccess | Meaning_baseConstructorAccess | MeaningStage1_overriddenMethodAccess | MeaningStage1_overriddenOperatorAccess | Meaning_unresolved;
 declare class MeaningStage1_overriddenMethodAccess {
     readonly method: types.Method;

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

@@ -1,4 +1,4 @@
-import { Diagnostic } from '../diagnostic/Diagnostic.js';
+import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
 import { NamedTypeEntity } from '../entities/index.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
@@ -8,8 +8,9 @@ export declare class Resolver {
     private readonly analyzer;
     private readonly node;
     private readonly analysisOptions;
-    constructor(analyzer: Analyzer, node: tree.CallExpression, analysisOptions: ExpressionAnalysisOptions | undefined);
-    resolve(): ResolutionResult;
+    private readonly diagnostics;
+    constructor(analyzer: Analyzer, node: tree.CallExpression, analysisOptions: ExpressionAnalysisOptions | undefined, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): Meaning;
     private checkExpressionDenotesType;
     private checkExpressionDenotesFunction;
     private checkExpressionDenotesOperator;
@@ -18,12 +19,6 @@ export declare class Resolver {
     private resolveConstructorCallExpression;
     private resolveObjectFunctionCallExpression;
 }
-export declare class ResolutionResult {
-    readonly meaning: Meaning;
-    readonly diagnostics?: readonly Diagnostic[] | undefined;
-    constructor(meaning: Meaning, diagnostics?: readonly Diagnostic[] | undefined);
-    static unresolved(diagnostics: readonly Diagnostic[] | undefined): ResolutionResult;
-}
 export type Meaning = Meaning_functionCall | Meaning_operatorCall | Meaning_objectFunctionCall | Meaning_constructorCall | Meaning_unresolved;
 export declare class Meaning_functionCall {
     readonly candidates: readonly NotSubstitutedAccessedFunction[];

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

@@ -1,14 +1,15 @@
 import { AccessKind } from '../common/index.js';
-import { Diagnostic } from '../diagnostic/Diagnostic.js';
+import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
 import { DereferenceExpression } from '../tree/index.js';
 import * as types from '../types/index.js';
 import { Analyzer } from './index.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);
+    constructor(analyzer: Analyzer, node: DereferenceExpression, diagnostics: DiagnosticAcceptor | undefined);
     resolve(): Meaning;
     private convertSyntacticAccessKind;
 }
@@ -20,8 +21,6 @@ declare class Meaning_resolved {
     constructor(operator: types.DereferenceOperator, accessKind: AccessKind);
 }
 declare class Meaning_unresolved {
-    readonly diagnostic: Diagnostic | undefined;
     readonly kind = "unresolved";
-    constructor(diagnostic: Diagnostic | undefined);
 }
 export {};

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

@@ -1,5 +1,5 @@
 import { AccessKind, Name } from '../common/index.js';
-import { Diagnostic } from '../diagnostic/Diagnostic.js';
+import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
 import { NamedTypeEntity, PackageAliasEntity, VariableEntity } from '../entities/index.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
@@ -12,9 +12,10 @@ 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);
-    resolve(): FirstStageResolutionResult;
+    constructor(analyzer: Analyzer, node: tree.IdentifierExpression, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): MeaningStage1;
     private tryResolveOperatorAccessMeaning;
     private resolveTypeAccess;
     private createNotSubstitutedAccessedFunction;
@@ -23,20 +24,16 @@ export declare class FirstStageResolver {
 export declare class SecondStageResolver {
     private readonly analyzer;
     private readonly node;
-    private readonly firstStageResolutionResult;
+    private readonly firstStageMeaning;
     private readonly analysisOptions;
-    constructor(analyzer: Analyzer, node: tree.IdentifierExpression, firstStageResolutionResult: FirstStageResolutionResult, analysisOptions: ExpressionAnalysisOptions | undefined);
-    resolve(): ResolutionResult;
+    private readonly diagnostics;
+    constructor(analyzer: Analyzer, node: tree.IdentifierExpression, firstStageMeaning: MeaningStage1, analysisOptions: ExpressionAnalysisOptions | undefined, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): Meaning;
     private resolveTypeAccessAtCalleePosition;
     private resolveFunctionAccess;
     private resolveOperatorAccess;
     private resolveNotCalledFunctionsAccess;
 }
-export declare class ResolutionResult {
-    readonly meaning: Meaning;
-    readonly diagnostics: readonly Diagnostic[] | undefined;
-    constructor(meaning: Meaning, diagnostics?: Diagnostic | readonly Diagnostic[]);
-}
 export type Meaning = Meaning_variableAccess | Meaning_functionAccess | Meaning_operatorAccess | Meaning_packageNameSegmentAccess | Meaning_packageAliasAccess | Meaning_typeAccess | Meaning_constructorAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
 declare class Meaning_variableAccess {
     readonly variable: AccessedVariable;
@@ -92,11 +89,6 @@ declare class Meaning_mixedAmbiguousAccess {
 declare class Meaning_unresolved {
     readonly kind = "unresolved";
 }
-export declare class FirstStageResolutionResult {
-    readonly meaning: MeaningStage1;
-    readonly diagnostics: readonly Diagnostic[] | undefined;
-    constructor(meaning: MeaningStage1, diagnostics?: Diagnostic | readonly Diagnostic[]);
-}
 export type MeaningStage1 = Meaning_variableAccess | MeaningStage1_functionAccess | MeaningStage1_operatorAccess | Meaning_packageNameSegmentAccess | Meaning_packageAliasAccess | MeaningStage1_typeAccessAtCalleePosition | Meaning_typeAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
 declare class MeaningStage1_typeAccessAtCalleePosition {
     readonly types: readonly NamedTypeEntity[];

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

@@ -1,23 +1,19 @@
 import { AccessKind } from '../common/index.js';
-import { Diagnostic } from '../diagnostic/Diagnostic.js';
+import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
 import { IndexedAccessExpression } from '../tree/index.js';
 import * as types from '../types/index.js';
 import { Analyzer } from './index.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);
-    resolve(): ResolutionResult;
+    constructor(analyzer: Analyzer, node: IndexedAccessExpression, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): Meaning;
     private getArgumentsRangeWithBrackets;
     private convertSyntacticAccessKind;
 }
-export declare class ResolutionResult {
-    readonly meaning: Meaning;
-    readonly diagnostics?: readonly Diagnostic[] | undefined;
-    constructor(meaning: Meaning, diagnostics?: readonly Diagnostic[] | undefined);
-}
 export type Meaning = Meaning_resolved | Meaning_unresolved;
 declare class Meaning_resolved {
     readonly candidates: readonly types.Indexer[];

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

@@ -1,5 +1,5 @@
 import { AccessKind } from '../common/index.js';
-import { Diagnostic } from '../diagnostic/Diagnostic.js';
+import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
 import { Entity, PackageTypeEntity, PackageVariableEntity } from '../entities/index.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
@@ -11,11 +11,12 @@ 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);
-    resolve(): FirstStageResolutionResult;
+    constructor(analyzer: Analyzer, node: tree.MemberAccessExpression, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): MeaningStage1;
     private resolvePackageAliasMemberAccessMeaning;
     private resolvePackageMemberAccessMeaning;
     private resolveTypeAccess;
@@ -28,10 +29,11 @@ export declare class FirstStageResolver {
 export declare class SecondStageResolver {
     private readonly analyzer;
     private readonly node;
-    private readonly firstStageResolutionResult;
+    private readonly firstStageMeaning;
     private readonly analysisOptions;
-    constructor(analyzer: Analyzer, node: tree.MemberAccessExpression, firstStageResolutionResult: FirstStageResolutionResult, analysisOptions: ExpressionAnalysisOptions | undefined);
-    resolve(): ResolutionResult;
+    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;
@@ -39,11 +41,6 @@ export declare class SecondStageResolver {
     private resolveNotCalledFunctionsAccess;
     private resolveOperatorAccess;
 }
-export declare class ResolutionResult {
-    readonly meaning: Meaning;
-    readonly diagnostics: readonly Diagnostic[] | undefined;
-    constructor(meaning: Meaning, diagnostics?: Diagnostic | readonly Diagnostic[]);
-}
 export type Meaning = Meaning_packageVariableAccess | Meaning_packageFunctionAccess | Meaning_packageTypeAccess | Meaning_constructorAccess | Meaning_packageNameSegmentAccess | Meaning_staticFieldAccess | Meaning_staticMethodAccess | Meaning_instanceFieldAccess | Meaning_instanceMethodAccess | Meaning_operatorAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
 declare class Meaning_packageVariableAccess {
     readonly variable: PackageVariableEntity;
@@ -126,11 +123,6 @@ declare class Meaning_mixedAmbiguousAccess {
 declare class Meaning_unresolved {
     readonly kind = "unresolved";
 }
-export declare class FirstStageResolutionResult {
-    readonly meaning: MeaningStage1;
-    readonly diagnostics: readonly Diagnostic[] | undefined;
-    constructor(meaning: MeaningStage1, diagnostics?: Diagnostic | readonly Diagnostic[]);
-}
 export type MeaningStage1 = Meaning_packageVariableAccess | MeaningStage1_packageFunctionAccess | Meaning_packageTypeAccess | MeaningStage1_typeAccessAtCalleePosition | Meaning_packageNameSegmentAccess | Meaning_staticFieldAccess | MeaningStage1_staticMethodAccess | Meaning_instanceFieldAccess | MeaningStage1_instanceMethodAccess | MeaningStage1_operatorAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
 declare class MeaningStage1_typeAccessAtCalleePosition {
     readonly types: readonly PackageTypeEntity[];

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

@@ -1,4 +1,4 @@
-import { Diagnostic } from '../diagnostic/Diagnostic.js';
+import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
 import { NamedTypeEntity, PackageAliasEntity } from '../entities/index.js';
 import { QualifiedName } from '../tree/index.js';
 import { Analyzer } from './Analyzer.js';
@@ -7,9 +7,10 @@ import { EntityOrPackageNameTreeNode } from './Utils.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);
+    constructor(analyzer: Analyzer, node: QualifiedName, diagnostics: DiagnosticAcceptor | undefined);
     resolve(): NamedTypeResolutionResult;
     private lookupTypeOrContainerWithTypes;
     private findTypesOrContainersWithTypesInResolvedQualifier;
@@ -21,9 +22,8 @@ export declare class NamedTypeResolver {
 export declare class NamedTypeResolutionResult {
     readonly types: readonly NamedTypeEntity[];
     readonly resolvedQualifiers: readonly ResolvedQualifier[];
-    readonly diagnostics: readonly Diagnostic[];
     readonly ambiguousDeclarations: readonly EntityOrPackageNameTreeNode[] | undefined;
-    constructor(types: readonly NamedTypeEntity[], resolvedQualifiers: readonly ResolvedQualifier[], diagnostics: readonly Diagnostic[], 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 {

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

@@ -1,4 +1,4 @@
-import { Diagnostic } from '../diagnostic/Diagnostic.js';
+import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
 import { NamedTypeSpecifier } from '../tree/index.js';
 import * as types from '../types/index.js';
 import { Analyzer } from './Analyzer.js';
@@ -7,13 +7,13 @@ import { EntityOrPackageNameTreeNode } from './Utils.js';
 export declare class NamedTypeSpecifierResolver {
     private readonly analyzer;
     private readonly node;
-    constructor(analyzer: Analyzer, node: NamedTypeSpecifier);
+    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 diagnostics: readonly Diagnostic[];
     readonly ambiguousDeclarations: readonly EntityOrPackageNameTreeNode[] | undefined;
-    constructor(type: types.Type | undefined, resolvedQualifiers: readonly ResolvedQualifier[], diagnostics: readonly Diagnostic[], ambiguousDeclarations: readonly EntityOrPackageNameTreeNode[] | undefined);
+    constructor(type: types.Type | undefined, resolvedQualifiers: readonly ResolvedQualifier[], ambiguousDeclarations: readonly EntityOrPackageNameTreeNode[] | undefined);
 }

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

@@ -24,7 +24,7 @@ export type FunctionDeclaration = tree.PackageFunctionDeclaration | tree.NestedF
 export type TypeDeclaration = StructuredTypeDeclaration | VariantTypeDeclaration | FunctionTypeDeclaration | tree.PackageAliasTypeDeclaration | tree.TypeParameterDeclaration;
 export type NamedTypeDeclaration = tree.PackageStructuredTypeDeclaration | tree.PackageVariantTypeDeclaration | tree.PackageFunctionTypeDeclaration | tree.PackageAliasTypeDeclaration | tree.TypeParameterDeclaration;
 export type TypeWithMembersDeclaration = StructuredTypeDeclaration | VariantTypeDeclaration | tree.PackageAliasTypeDeclaration;
-export type VariableDeclaration = tree.ForStatementVariableDeclaration | tree.PackageVariableDeclaration | tree.LocalVariableDeclaration | tree.ParameterDeclaration | tree.FieldDeclaration | tree.VariantDeclaration;
+export type VariableDeclaration = tree.ForStatementVariableDeclaration | tree.PackageVariableDeclaration | tree.LocalVariableDeclaration | tree.ParameterDeclaration | tree.FieldDeclaration | tree.VariantValueDeclaration;
 export type GetterDeclaration = tree.PackageVariableGetterDeclaration | tree.FieldGetterDeclaration | tree.IndexedElementGetterDeclaration | tree.DereferencedVariableGetterDeclaration;
 export type SetterDeclaration = tree.PackageVariableSetterDeclaration | tree.FieldSetterDeclaration | tree.IndexedElementSetterDeclaration | tree.DereferencedVariableSetterDeclaration;
 export type PackageVariableAccessorDeclaration = tree.PackageVariableGetterDeclaration | tree.PackageVariableSetterDeclaration;