@artel/artc 0.6.25245 → 0.6.25247

package/build/{chunk-TVZEHLXD.js → chunk-TTNFYVNF.js}

@@ -1,6 +1,6 @@
 import {
   Compiler
-} from "./chunk-FVBS6MPY.js";
+} from "./chunk-3MYTPUJZ.js";
 import {
   ArtelVersion,
   Cached,
@@ -14,7 +14,7 @@ import {
   __async,
   performanceMeasurementStageNames,
   performanceMeasurementStages
-} from "./chunk-T7WG4Z7I.js";
+} from "./chunk-3PVSYUJV.js";
 
 // source/executor/FileSystemUri.ts
 import { platform } from "os";

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

@@ -64,7 +64,6 @@ export declare class AnalyzedTranslationPackage {
     private createTranslatedTypeSignature;
     private enumerateTranslationsDeclarations;
     private findTypeTranslation;
-    private createAmbiguousAccessDiagnostic;
 }
 export declare class TranslatedPackageMembers {
     private readonly _namedMembers;

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

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { CancellationToken, Lazy, Name, PackageLocale, Range, WithDiagnostics } from '../common/index.js';
+import { CancellationToken, DisplayableOrPrimitive, Name, PackageLocale, Range, WithDiagnostics } from '../common/index.js';
 import { Diagnostic, DiagnosticAcceptor, DiagnosticLocation } from '../diagnostic/Diagnostic.js';
 import { DiagnosticCode } from '../diagnostic/DiagnosticCode.js';
 import { DiagnosticFlags, DiagnosticKind } from '../diagnostic/DiagnosticData.js';
@@ -22,6 +22,7 @@ import * as callExpressionMeaning from './CallExpressionMeaning.js';
 import * as constructorOverloadResolver from './ConstructorOverloadResolver.js';
 import { DeclarationsUsageCountResult } from './DeclarationsUsageCounter.js';
 import * as dereferenceExpressionMeaning from './DereferenceExpressionMeaning.js';
+import { DiagnosticArgumentFactory } from './DiagnosticArgumentFactory.js';
 import * as functionOverloadResolver from './FunctionOverloadResolver.js';
 import * as identifierExpressionResolution from './IdentifierExpressionMeaning.js';
 import { ImportedPackageNameTree, PackageNameTreeNode } from './ImportedPackageNameTree.js';
@@ -29,8 +30,9 @@ import * as indexedAccessExpressionMeaning from './IndexedAccessExpressionMeanin
 import * as memberAccessExpressionResolution from './MemberAccessExpressionMeaning.js';
 import { ModifierFlags } from './ModifierFlags.js';
 import { NamedTypeSpecifierResolutionResult } from './NamedTypeSpecifierResolver.js';
-import { DereferencedVariableAccessorDeclaration, FieldAccessorDeclaration, FunctionTypeDeclaration, GetterDeclaration, IndexedElementAccessorDeclaration, PackageVariableAccessorDeclaration, SetterDeclaration, StructuredTypeDeclaration, TypeDeclaration, VariantTypeDeclaration } from './NodeTypeUtils.js';
+import { DereferencedVariableAccessorDeclaration, FieldAccessorDeclaration, FunctionTypeDeclaration, GetterDeclaration, IndexedElementAccessorDeclaration, PackageVariableAccessorDeclaration, SetterDeclaration, StructuredTypeDeclaration, TypeDeclaration, TypeWithMembersDeclaration, VariantTypeDeclaration } from './NodeTypeUtils.js';
 import * as objectExpressionMeaning from './ObjectExpressionMeaning.js';
+import { OwnAndBaseConstructorCallsCheckResult } from './OwnAndBaseConstructorCallsChecker.js';
 import { SourceFileMembers as ActualSourceFileMembers } from './SourceFileMembers.js';
 import * as tagMeaning from './TagMeaning.js';
 import * as tags from './Tags.js';
@@ -66,7 +68,6 @@ export declare class Analyzer {
     readonly valueLocalVariableEntity: ValueLocalVariableEntity;
     readonly semanticContext: semanticContext.SemanticContextBuilder;
     readonly argumentToParameterMatchResult: ArgumentToParameterMatchResult;
-    readonly defaultConstructors: DefaultConstructors;
     readonly overriddenMember: OverriddenMember;
     readonly tags: Tags;
     readonly linkedEntity: LinkedEntity;
@@ -86,8 +87,8 @@ export declare class Analyzer {
     private readonly _autotypeCallExpressionMeanings;
     private readonly _identifierExpressionResolutionResults;
     private readonly _tagResolutionResults;
-    private readonly _objectExpressionMeanings;
-    private readonly _baseExpressionMeanings;
+    private readonly _objectExpressionResolutionResults;
+    private readonly _baseExpressionResolutionResults;
     private readonly _namedTypeSpecifierResolutionResults;
     private readonly _prefixUnaryExpressionOperatorResolutionResults;
     private readonly _binaryExpressionUserDefinableOperatorResolutionResults;
@@ -99,6 +100,7 @@ export declare class Analyzer {
     private readonly _linkedMultiPlatformPackagesByPlatform;
     private readonly _functionBlockWithYieldStatementCheckResults;
     private readonly _namedDeclarationsUsageCountResults;
+    private readonly _packageAndStaticVariablesInitializationDiagnostics;
     private readonly _controlFlowGraphs;
     private readonly _diagnosticsComputedLazily;
     private readonly _diagnosticsComputedLazilyAcceptor;
@@ -109,9 +111,12 @@ export declare class Analyzer {
     private _packageEntitiesByNameKey;
     private readonly _localizedWellKnownDeclarations;
     private readonly _localizedStandardTypes;
+    private readonly _ownAndBaseConstructorCallsCheckResults;
+    private readonly _expressionCanBeUsedInForLoopCheckResults;
     get tsInterop(): TsInteropContext;
     constructor(compilation: project.Compilation, tsInteropInputs: TsInteropInputs);
     getProjectSourceFile(node: tree.SourceFile): project.SourceFile;
+    checkExpressionCanBeUsedInForLoop(node: tree.Expression): WithDiagnostics<ExpressionCanBeUsedInForLoopCheckResult>;
     ifTypeEnumerableThenItemType(type: types.Type): types.Type | undefined;
     ifTypeEnumeratorThenItemType(type: types.Type): types.Type | undefined;
     isTypeArrayOrReadonlyArray(type: types.Type): {
@@ -144,8 +149,8 @@ export declare class Analyzer {
     getAutotypeCallExpressionMeaning(node: tree.AutotypeCallExpression, targetTypeHint?: TargetTypeHint): autotypeCallExpressionMeaning.Meaning;
     resolveIdentifierExpression(node: tree.IdentifierExpression, targetTypeHint?: TargetTypeHint): identifierExpressionResolution.ResolutionResult;
     resolveTag(node: tree.Tag): tagMeaning.ResolutionResult;
-    getObjectExpressionMeaning(node: tree.ObjectExpression): objectExpressionMeaning.Meaning;
-    getBaseExpressionMeaning(node: tree.BaseExpression): baseExpressionMeaning.Meaning;
+    resolveObjectExpression(node: tree.ObjectExpression): objectExpressionMeaning.ResolutionResult;
+    resolveBaseExpression(node: tree.BaseExpression): baseExpressionMeaning.ResolutionsResult;
     /**
      * Проверяет, является ли выражение цепочкой доступов через `?`, заканчивающейся выражением, тип которого допускает
      * `пусто`.
@@ -252,7 +257,7 @@ export declare class Analyzer {
     excludeTypeFromUnion(initialType: types.Type, excludedType: types.Type): types.Type;
     isValueParameterVariadic(entity: e.VariableEntity): boolean;
     getDefaultTypeParameterConstraint(locale: PackageLocale): types.Type;
-    getOriginalSignatureTypeOfFunctionEntity(entity: e.FunctionEntity): types.FunctionType;
+    getSignatureTypeOfFunctionEntity(entity: e.FunctionEntity): types.FunctionType;
     getFunctionBlockLiteralValueParameters(node: tree.FunctionBlockLiteral): readonly e.ParameterVariableEntity[];
     getExtendedType(node: tree.TypeExtensionDeclaration): WithDiagnostics<e.NamedTypeEntity>;
     getAnalyzedTranslationPackageIfTargetResolved(package_: project.TranslationPackage): AnalyzedTranslationPackage | undefined;
@@ -274,11 +279,13 @@ export declare class Analyzer {
     createPackageMemberHiding(node: tree.PackageMemberDeclaration, modifierFlags: ModifierFlags): e.EntityHidingLevel | undefined;
     createTypeMemberHiding(node: tree.TypeMemberDeclaration, modifierFlags: ModifierFlags): e.EntityHidingLevel | undefined;
     getDeclarationsUsageCount(sourceFile: tree.SourceFile, cancellationToken: CancellationToken | undefined): Promise<DeclarationsUsageCountResult>;
+    getPackageAndStaticVariablesInitializationDiagnostics(pkg: SourcePackage, cancellationToken: CancellationToken | undefined): 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[];
     createBackingFields(declaredMembers: readonly e.NamedTypeMemberEntity[], type: e.TypeEntity): e.FieldEntity[];
-    createNodeDiagnostic(code: DiagnosticCode, node: tree.Node, formatArguments?: readonly string[], kind?: DiagnosticKind, flags?: DiagnosticFlags): Diagnostic;
-    createSourceFileRangeDiagnostic(code: DiagnosticCode, range: Range, nodeOrSourceFile: tree.Node | project.SourceFile, formatArguments?: readonly string[], kind?: DiagnosticKind, flags?: DiagnosticFlags): Diagnostic;
-    createDiagnostic(code: DiagnosticCode, location: DiagnosticLocation | undefined, formatArguments?: readonly string[], kind?: DiagnosticKind, flags?: DiagnosticFlags): Diagnostic;
+    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;
+    createDiagnostic(code: DiagnosticCode, location: DiagnosticLocation | undefined, formatArguments?: readonly DisplayableOrPrimitive[], kind?: DiagnosticKind, flags?: DiagnosticFlags): Diagnostic;
     createNodeDiagnosticLocation(node: tree.Node): DiagnosticLocation;
     getDeclaredTypeMemberEntities(node: tree.TypeMemberDeclarationBlock): DeclaredTypeMemberEntities;
     getBasicMethodOfOriginalTypeForBasicMethodOfAliasType(entity: e.MethodEntity): e.MethodEntity | undefined;
@@ -287,13 +294,9 @@ export declare class Analyzer {
     } | undefined;
     getControlFlowGraph(sourceFile: project.SourceFile): controlFlow.GraphBuildResult;
     createAmbiguousEntityAccessDiagnostic(entities: readonly e.Entity[], node: tree.Node): Diagnostic;
-    createAmbiguousEntityAccessLazyDiagnostic(entities: readonly e.Entity[], node: tree.Node): Lazy<Diagnostic>;
     createAmbiguousFunctionAccessDiagnostic(functions: readonly AccessedFunction[], node: tree.Node): Diagnostic;
-    createAmbiguousFunctionAccessLazyDiagnostic(functions: readonly AccessedFunction[], node: tree.Node): Lazy<Diagnostic>;
     createAmbiguousTypeMemberAccessDiagnostic(members: readonly types.TypeMember[], node: tree.Node): Diagnostic;
-    createAmbiguousTypeMemberAccessLazyDiagnostic(members: readonly types.TypeMember[], node: tree.Node): Lazy<Diagnostic>;
     createAmbiguousNamedScopeDeclarationAccessDiagnostic(declarations: readonly semanticContext.NamedDeclaration[], node: tree.Node): Diagnostic;
-    createAmbiguousNamedScopeDeclarationAccessLazyDiagnostic(declarations: readonly semanticContext.NamedDeclaration[], node: tree.Node): Lazy<Diagnostic>;
     addDiagnosticComputedLazily(diagnostic: Diagnostic): void;
     getAcceptorForDiagnosticsComputedLazily(): DiagnosticAcceptor;
     getSourceFileDiagnosticsComputedLazily(sourceFile: project.SourceFile): readonly Diagnostic[];
@@ -306,6 +309,10 @@ export declare class Analyzer {
     getLocalizedWellKnownDeclarations(locale: PackageLocale): WellKnownDeclarations;
     getLocalizedStandardTypes(locale: PackageLocale): types.StandardTypes;
     determineUnderlyingTypeOfSourceVariantType(memberList: tree.TypeMemberDeclarationList): types.Type;
+    getOwnAndBaseConstructorCallsCheckResult(node: TypeWithMembersDeclaration): OwnAndBaseConstructorCallsCheckResult;
+    isConstructorCallingOwnConstructor(node: tree.ConstructorDeclaration): boolean;
+    createDiagnosticArgumentFactoryWithinPackage(entity: e.PackageEntity): DiagnosticArgumentFactory;
+    createDiagnosticArgumentFactoryWithinEntityContext(context: e.EntityContext): DiagnosticArgumentFactory;
     private createTsInterop;
 }
 export declare class TsInteropInputs {
@@ -331,6 +338,11 @@ export declare const enum SyntacticAccessKind {
     GetSet = 2,
     ReferencedValue = 3
 }
+export declare class ExpressionCanBeUsedInForLoopCheckResult {
+    readonly elementType: types.Type;
+    readonly ifTypeDoesNotImplementEnumerableThenEnumeratorMethod: types.Method | undefined;
+    constructor(elementType: types.Type, ifTypeDoesNotImplementEnumerableThenEnumeratorMethod: types.Method | undefined);
+}
 declare class Type {
     private readonly _analyzer;
     private readonly _unionTypeSpecifierTypes;
@@ -423,6 +435,7 @@ declare class Entity {
     private readonly _setterEntities;
     private readonly _typeExtensionEntities;
     private readonly _packageAliasEntities;
+    private readonly _translationTextTemplateParameterDeclarationEntities;
     constructor(_analyzer: Analyzer);
     ofPackage(pkg: SourcePackage): e.PackageEntity;
     ofPackageVariableDeclaration(node: tree.PackageVariableDeclaration): e.PackageVariableEntity;
@@ -465,6 +478,8 @@ declare class Entity {
     ofVariantDeclaration(node: tree.VariantDeclaration): e.FieldEntity;
     ofTypeExtensionDeclaration(node: tree.TypeExtensionDeclaration): e.TypeExtensionEntity;
     ofPackageImport(node: tree.PackageImport): e.PackageAliasEntity;
+    ofTypeWithMembersDeclaration(node: TypeWithMembersDeclaration): e.TypeEntityWithMembers;
+    ofTranslationTextTemplateParameterDeclaration(node: tree.TranslationTextTemplateParameterDeclaration): e.TranslationTextTemplateParameterDeclarationEntity;
     private getContainingPackageLoadedFromDts;
     private createComputedFieldEntities;
     private createDereferenceOperatorEntities;
@@ -499,14 +514,6 @@ declare class ValueLocalVariableEntity {
     ofIndexedElementSetterDeclaration(node: tree.IndexedElementSetterDeclaration): e.LocalVariableEntity;
     ofDereferencedVariableSetterDeclaration(node: tree.DereferencedVariableSetterDeclaration): e.LocalVariableEntity;
 }
-declare class DefaultConstructors {
-    private readonly _analyzer;
-    private readonly _defaultConstructorEntities;
-    constructor(_analyzer: Analyzer);
-    ofStructuredType(type: StructuredTypeDeclaration): readonly e.ConstructorEntity[];
-    private createDefaultConstructors;
-    private getPublicInstanceStoredVariables;
-}
 declare class OverriddenMember {
     private readonly _analyzer;
     private readonly _namedMemberFinder;

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

@@ -15,16 +15,22 @@ export declare class Resolver {
     private readonly _analyzer;
     private readonly _node;
     constructor(analyzer: Analyzer, node: tree.BaseExpression);
-    resolve(): Meaning;
+    resolve(): ResolutionsResult;
     private resolveBaseConstructorOrMethodAccess;
     private resolveBaseConstructorAccess;
     private resolveBaseMethodAccess;
     private resolveBaseOperatorAccess;
     private resolveBaseObjectAccess;
-    private invalidContextMeaning;
+    private invalidContextDiagnostic;
     private getBaseOrAliasedType;
     private getContainingTypeMemberDeclaration;
 }
+export declare class ResolutionsResult {
+    readonly meaning: Meaning;
+    readonly diagnostics?: readonly Diagnostic[] | undefined;
+    constructor(meaning: Meaning, diagnostics?: readonly Diagnostic[] | undefined);
+    static unresolved(diagnostics?: readonly Diagnostic[]): ResolutionsResult;
+}
 export type Meaning = Meaning_baseObjectAccess | Meaning_baseConstructorAccess | Meaning_overriddenMethodAccess | Meaning_overriddenOperatorAccess | Meaning_unresolved;
 declare class Meaning_baseObjectAccess {
     readonly type: types.Type;
@@ -43,6 +49,7 @@ declare class Meaning_baseConstructorAccess {
     readonly candidates: readonly types.Constructor[];
     readonly suitableConstructors: readonly types.Constructor[];
     readonly kind = "base-constructor-access";
+    get singleSuitableConstructor(): types.Constructor | undefined;
     constructor(
     /**
      * Тип объекта, получаемого в результате вызова конструктора.
@@ -64,8 +71,6 @@ declare class Meaning_overriddenOperatorAccess {
     constructor(operator: types.Operator);
 }
 declare class Meaning_unresolved {
-    readonly diagnostic: Diagnostic;
     readonly kind = "unresolved";
-    constructor(diagnostic: Diagnostic);
 }
 export {};

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

@@ -1,18 +1,16 @@
-import { PackageDialect } from '../common/index.js';
 import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
 import { IEntityHidingMatcher, TypeEntityWithMembers } from '../entities/index.js';
 import { Node } from '../tree/index.js';
 import { Analyzer } from './Analyzer.js';
+import { DiagnosticArgumentFactory } from './DiagnosticArgumentFactory.js';
 export declare class BaseMemberConflictsValidator {
     private readonly _analyzer;
     private readonly _typeEntity;
     private readonly _hidingMatcher;
-    private readonly _dialect;
+    private readonly _diagnosticArgumentFactory;
     private readonly _diagnostics;
     private readonly _nodeForDiagnostic;
-    private _displayService;
-    private get displayService();
-    constructor(_analyzer: Analyzer, _typeEntity: TypeEntityWithMembers, _hidingMatcher: IEntityHidingMatcher, _dialect: PackageDialect | undefined, _diagnostics: DiagnosticAcceptor, _nodeForDiagnostic: Node);
+    constructor(_analyzer: Analyzer, _typeEntity: TypeEntityWithMembers, _hidingMatcher: IEntityHidingMatcher, _diagnosticArgumentFactory: DiagnosticArgumentFactory, _diagnostics: DiagnosticAcceptor, _nodeForDiagnostic: Node);
     validate(): void;
     private getAllNotShadowedNotOverriddenMembers;
     private validateMemberConflicts;

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

@@ -42,6 +42,7 @@ declare class Meaning_constructorCall {
     readonly candidates: readonly types.Constructor[];
     readonly suitableConstructors: readonly types.Constructor[];
     readonly kind = "constructor-call";
+    get singleSuitableConstructor(): types.Constructor | undefined;
     constructor(
     /**
      * Тип объекта, получаемого в результате вызова конструктора.

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

@@ -0,0 +1,18 @@
+import { PackageDialect, PackageLocale } from '../common/index.js';
+import { Entity } from '../entities/index.js';
+import * as types from '../types/index.js';
+import { AccessedFunction } from './AccessedFunction.js';
+import { Analyzer } from './Analyzer.js';
+import { DisplayableAccessedFunction, DisplayableEntity, DisplayablePackageNameTreeNode, DisplayableType, DisplayableTypeMember } from './DisplayableEntity.js';
+import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
+export declare class DiagnosticArgumentFactory {
+    readonly locale: PackageLocale;
+    readonly dialect: PackageDialect;
+    private readonly _analyzer;
+    constructor(analyzer: Analyzer, locale: PackageLocale, dialect: PackageDialect);
+    createDisplayableEntity(entity: Entity): DisplayableEntity;
+    createDisplayableAccessedFunction(accessedFunction: AccessedFunction): DisplayableAccessedFunction;
+    createDisplayableTypeMember(member: types.TypeMember): DisplayableTypeMember;
+    createDisplayablePackageNameTreeNode(node: PackageNameTreeNode): DisplayablePackageNameTreeNode;
+    createDisplayableType(type: types.Type): DisplayableType;
+}

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

@@ -7,7 +7,7 @@ export declare class DiagnosticCollector {
     private readonly _analyzer;
     private readonly _sourceFile;
     private readonly _cancellationToken;
-    private readonly _displayService;
+    private readonly _diagnosticArgumentFactory;
     private readonly _translationPackage;
     private readonly _diagnostics;
     private readonly _diagnosticAcceptor;
@@ -86,6 +86,5 @@ export declare class DiagnosticCollector {
     private attachNodeLocationAndAddDiagnostics;
     private addDiagnostic;
     private addDiagnostics;
-    private addMaybeLazyDiagnostic;
-    private addMaybeLazyDiagnostics;
+    private addDiagnosticsLocatedInAnalyzedFile;
 }

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

@@ -0,0 +1,46 @@
+import { Displayable, PackageDialect, PackageLocale } from '../common/index.js';
+import { Entity } from '../entities/index.js';
+import { AccessedFunction } from './AccessedFunction.js';
+import { Analyzer } from './Analyzer.js';
+import * as types from '../types/index.js';
+import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
+export declare class DisplayableEntity implements Displayable {
+    private readonly _analyzer;
+    private readonly _entity;
+    private readonly _locale;
+    private readonly _dialect;
+    constructor(_analyzer: Analyzer, _entity: Entity, _locale: PackageLocale, _dialect: PackageDialect | undefined);
+    getDisplayText(): string;
+}
+export declare class DisplayableAccessedFunction implements Displayable {
+    private readonly _analyzer;
+    private readonly _accessedFunction;
+    private readonly _locale;
+    private readonly _dialect;
+    constructor(_analyzer: Analyzer, _accessedFunction: AccessedFunction, _locale: PackageLocale, _dialect: PackageDialect | undefined);
+    getDisplayText(): string;
+}
+export declare class DisplayableTypeMember implements Displayable {
+    private readonly _analyzer;
+    private readonly _member;
+    private readonly _locale;
+    private readonly _dialect;
+    constructor(_analyzer: Analyzer, _member: types.TypeMember, _locale: PackageLocale, _dialect: PackageDialect | undefined);
+    getDisplayText(): string;
+}
+export declare class DisplayablePackageNameTreeNode implements Displayable {
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _locale;
+    private readonly _dialect;
+    constructor(_analyzer: Analyzer, _node: PackageNameTreeNode, _locale: PackageLocale, _dialect: PackageDialect | undefined);
+    getDisplayText(): string;
+}
+export declare class DisplayableType implements Displayable {
+    private readonly _analyzer;
+    private readonly _type;
+    private readonly _locale;
+    private readonly _dialect;
+    constructor(_analyzer: Analyzer, _type: types.Type, _locale: PackageLocale, _dialect: PackageDialect | undefined);
+    getDisplayText(): string;
+}

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

@@ -1,4 +1,4 @@
-import { AccessKind, MaybeLazy, Name } from '../common/index.js';
+import { AccessKind, Name } from '../common/index.js';
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import { NamedTypeEntity, PackageAliasEntity, VariableEntity } from '../entities/index.js';
 import * as tree from '../tree/index.js';
@@ -22,12 +22,12 @@ export declare class Resolver {
 }
 export declare class ResolutionResult {
     readonly meaning: Meaning;
-    readonly diagnostic?: MaybeLazy<Diagnostic> | undefined;
+    readonly diagnostic?: Diagnostic | undefined;
     /**
      * Может ли измениться результат, если посчитать его с другим целевым типом?
      */
     readonly dependsOnTargetType: boolean;
-    constructor(meaning: Meaning, diagnostic?: MaybeLazy<Diagnostic> | undefined, 
+    constructor(meaning: Meaning, diagnostic?: Diagnostic | undefined, 
     /**
      * Может ли измениться результат, если посчитать его с другим целевым типом?
      */

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

@@ -1,4 +1,4 @@
-import { AccessKind, MaybeLazy } from '../common/index.js';
+import { AccessKind } from '../common/index.js';
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import { IndexedAccessExpression } from '../tree/index.js';
 import * as types from '../types/index.js';
@@ -15,8 +15,8 @@ export declare class Resolver {
 }
 export declare class ResolutionResult {
     readonly meaning: Meaning;
-    readonly diagnostic?: MaybeLazy<Diagnostic> | undefined;
-    constructor(meaning: Meaning, diagnostic?: MaybeLazy<Diagnostic> | undefined);
+    readonly diagnostic?: Diagnostic | undefined;
+    constructor(meaning: Meaning, diagnostic?: Diagnostic | undefined);
 }
 export type Meaning = Meaning_resolved | Meaning_unresolved;
 declare class Meaning_resolved {

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

@@ -0,0 +1,18 @@
+import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
+import { Analyzer } from './Analyzer.js';
+import { DeclarationsUsageCountResult } from './DeclarationsUsageCounter.js';
+import { TypeWithMembersDeclaration } from './NodeTypeUtils.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: TypeWithMembersDeclaration, _declarationsUsageCountResult: DeclarationsUsageCountResult, _diagnostics: DiagnosticAcceptor);
+    validate(): void;
+    private getFieldsThatNeedToBeInitializedInConstructor;
+    private checkDefaultConstructorInitializesAllFields;
+    private checkConstructorInitializesAllFields;
+    private getFieldDiagnosticLocationWithFallback;
+}

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

@@ -1,4 +1,4 @@
-import { AccessKind, MaybeLazy } from '../common/index.js';
+import { AccessKind } from '../common/index.js';
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import { Entity, PackageTypeEntity, PackageVariableEntity } from '../entities/index.js';
 import * as tree from '../tree/index.js';
@@ -29,12 +29,12 @@ export declare class Resolver {
 }
 export declare class ResolutionResult {
     readonly meaning: Meaning;
-    readonly diagnostic?: MaybeLazy<Diagnostic> | undefined;
+    readonly diagnostic?: Diagnostic | undefined;
     /**
      * Может ли измениться результат, если посчитать его с другим целевым типом?
      */
     readonly dependsOnTargetType: boolean;
-    constructor(meaning: Meaning, diagnostic?: MaybeLazy<Diagnostic> | undefined, 
+    constructor(meaning: Meaning, diagnostic?: Diagnostic | undefined, 
     /**
      * Может ли измениться результат, если посчитать его с другим целевым типом?
      */

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

@@ -1,4 +1,3 @@
-import { MaybeLazy } from '../common/index.js';
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import { NamedTypeEntity, PackageAliasEntity } from '../entities/index.js';
 import { QualifiedName } from '../tree/index.js';
@@ -22,9 +21,9 @@ export declare class NamedTypeResolver {
 export declare class NamedTypeResolutionResult {
     readonly types: readonly NamedTypeEntity[];
     readonly resolvedQualifiers: readonly ResolvedQualifier[];
-    readonly diagnostics: readonly MaybeLazy<Diagnostic>[];
+    readonly diagnostics: readonly Diagnostic[];
     readonly ambiguousDeclarations: readonly EntityOrPackageNameTreeNode[] | undefined;
-    constructor(types: readonly NamedTypeEntity[], resolvedQualifiers: readonly ResolvedQualifier[], diagnostics: readonly MaybeLazy<Diagnostic>[], ambiguousDeclarations: readonly EntityOrPackageNameTreeNode[] | undefined);
+    constructor(types: readonly NamedTypeEntity[], resolvedQualifiers: readonly ResolvedQualifier[], diagnostics: readonly Diagnostic[], 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,3 @@
-import { MaybeLazy } from '../common/index.js';
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import { NamedTypeSpecifier } from '../tree/index.js';
 import * as types from '../types/index.js';
@@ -15,7 +14,7 @@ export declare class NamedTypeSpecifierResolver {
 export declare class NamedTypeSpecifierResolutionResult {
     readonly type: types.Type | undefined;
     readonly resolvedQualifiers: readonly ResolvedQualifier[];
-    readonly diagnostics: readonly MaybeLazy<Diagnostic>[];
+    readonly diagnostics: readonly Diagnostic[];
     readonly ambiguousDeclarations: readonly EntityOrPackageNameTreeNode[] | undefined;
-    constructor(type: types.Type | undefined, resolvedQualifiers: readonly ResolvedQualifier[], diagnostics: readonly MaybeLazy<Diagnostic>[], ambiguousDeclarations: readonly EntityOrPackageNameTreeNode[] | undefined);
+    constructor(type: types.Type | undefined, resolvedQualifiers: readonly ResolvedQualifier[], diagnostics: readonly Diagnostic[], ambiguousDeclarations: readonly EntityOrPackageNameTreeNode[] | undefined);
 }

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

@@ -22,6 +22,7 @@ export type FunctionTypeDeclaration = tree.PackageFunctionTypeDeclaration | tree
 export type FunctionDeclaration = tree.PackageFunctionDeclaration | tree.NestedFunctionDeclaration | tree.MethodDeclaration;
 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.EnumerationVariableDeclaration | tree.PackageVariableDeclaration | tree.LocalVariableDeclaration | tree.ParameterDeclaration | tree.FieldDeclaration | tree.VariantDeclaration;
 export type GetterDeclaration = tree.PackageVariableGetterDeclaration | tree.FieldGetterDeclaration | tree.IndexedElementGetterDeclaration | tree.DereferencedVariableGetterDeclaration;
 export type SetterDeclaration = tree.PackageVariableSetterDeclaration | tree.FieldSetterDeclaration | tree.IndexedElementSetterDeclaration | tree.DereferencedVariableSetterDeclaration;

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

@@ -11,12 +11,18 @@ export declare class Resolver {
     private readonly _analyzer;
     private readonly _node;
     constructor(analyzer: Analyzer, node: tree.ObjectExpression);
-    resolve(): Meaning;
+    resolve(): ResolutionResult;
     private resolveOwnConstructorAccess;
     private resolveContextAccess;
-    private invalidContextMeaning;
+    private invalidContextDiagnostic;
     private findContainingConstructor;
 }
+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_ownConstructorAccess | Meaning_objectAccess | Meaning_unresolved;
 declare class Meaning_ownConstructorAccess {
     /**
@@ -30,6 +36,7 @@ declare class Meaning_ownConstructorAccess {
     readonly candidates: readonly types.Constructor[];
     readonly suitableConstructors: readonly types.Constructor[];
     readonly kind = "own-constructor-access";
+    get singleSuitableConstructor(): types.Constructor | undefined;
     constructor(
     /**
      * Тип объекта, получаемого в результате вызова конструктора.
@@ -46,8 +53,6 @@ declare class Meaning_objectAccess {
     constructor(type: types.Type);
 }
 declare class Meaning_unresolved {
-    readonly diagnostic: Diagnostic | undefined;
     readonly kind = "unresolved";
-    constructor(diagnostic: Diagnostic | undefined);
 }
 export {};

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

@@ -0,0 +1,23 @@
+import { Diagnostic } from '../diagnostic/Diagnostic.js';
+import { ConstructorEntity, TypeEntityWithMembers } from '../entities/index.js';
+import * as tree from '../tree/index.js';
+import * as types from '../types/index.js';
+import { Analyzer } from './Analyzer.js';
+import { SemanticContext } from './semantic-context/SemanticContext.js';
+export declare class OwnAndBaseConstructorCallsChecker {
+    private readonly _analyzer;
+    private readonly _constructorDeclarations;
+    private readonly _typeEntity;
+    private readonly _semanticContext;
+    constructor(_analyzer: Analyzer, _constructorDeclarations: readonly tree.ConstructorDeclaration[], _typeEntity: TypeEntityWithMembers, _semanticContext: SemanticContext);
+    check(): OwnAndBaseConstructorCallsCheckResult;
+    private addOwnConstructorCallOrReportCycleDiagnostic;
+    private getUnaliasedBaseObjectType;
+    private findAccessibleConstructorWithoutParameters;
+}
+export declare class OwnAndBaseConstructorCallsCheckResult {
+    readonly ownConstructorCalls: ReadonlyMap<ConstructorEntity, ConstructorEntity>;
+    readonly baseConstructorCalls: ReadonlyMap<ConstructorEntity, types.Constructor>;
+    readonly diagnostics: readonly Diagnostic[];
+    constructor(ownConstructorCalls: ReadonlyMap<ConstructorEntity, ConstructorEntity>, baseConstructorCalls: ReadonlyMap<ConstructorEntity, types.Constructor>, diagnostics: readonly Diagnostic[]);
+}

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

@@ -0,0 +1,17 @@
+import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
+import { SourcePackage } from '../project/SourcePackage.js';
+import { Analyzer } from './Analyzer.js';
+import { DeclarationsUsageCountResult } from './DeclarationsUsageCounter.js';
+export declare class PackageAndStaticVariablesInitializationValidator {
+    private readonly _analyzer;
+    private readonly _package;
+    private readonly _declarationsUsageCountResults;
+    private readonly _diagnostics;
+    constructor(_analyzer: Analyzer, _package: SourcePackage, _declarationsUsageCountResults: readonly DeclarationsUsageCountResult[], _diagnostics: DiagnosticAcceptor);
+    validate(): void;
+    private getVariablesThatNeedToBeInitializedInConstructor;
+    private collectStaticFieldsThatNeedToBeInitializedInConstructor;
+    private excludeVariablesInitializedInConstructor;
+    private reportNotInitialedVariableDiagnostic;
+    private getVariableDiagnosticLocationWithFallback;
+}

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

@@ -1,4 +1,3 @@
-import { MaybeLazy } from '../common/index.js';
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import { FunctionEntity, NamedTypeEntity, PackageAliasEntity } from '../entities/index.js';
 import { Tag } from '../tree/index.js';
@@ -25,9 +24,9 @@ export declare class Resolver {
 export declare class ResolutionResult {
     readonly meaning: Meaning;
     readonly resolvedQualifiers: readonly ResolvedQualifier[];
-    readonly diagnostic?: MaybeLazy<Diagnostic> | undefined;
+    readonly diagnostic?: Diagnostic | undefined;
     readonly ambiguousDeclarations?: readonly EntityOrPackageNameTreeNode[] | undefined;
-    constructor(meaning: Meaning, resolvedQualifiers: readonly ResolvedQualifier[], diagnostic?: MaybeLazy<Diagnostic> | undefined, ambiguousDeclarations?: readonly EntityOrPackageNameTreeNode[] | undefined);
+    constructor(meaning: Meaning, resolvedQualifiers: readonly ResolvedQualifier[], diagnostic?: Diagnostic | undefined, ambiguousDeclarations?: readonly EntityOrPackageNameTreeNode[] | undefined);
 }
 export type Meaning = Meaning_tagType | Meaning_tagFunction | Meaning_unresolved;
 declare class Meaning_tagType {

package/build/types/analysis/control-flow/NarrowableReference.d.ts

@@ -1,15 +1,14 @@
-import { LocalVariableEntity, PackageVariableEntity, ParameterVariableEntity } from '../../entities/VariableEntity.js';
+import { FieldEntity, LocalVariableEntity, PackageVariableEntity, ParameterVariableEntity, TextTemplateParameterVariableEntity } from '../../entities/VariableEntity.js';
 import * as tree from '../../tree/index.js';
-import * as types from '../../types/index.js';
 import { Analyzer } from '../Analyzer.js';
 import { NarrowableReferenceExpression } from '../control-flow/NarrowableExpression.js';
 export type NarrowableReference = NarrowableReference.LocalVariable | NarrowableReference.PackageVariable | NarrowableReference.InstanceField | NarrowableReference.StaticField | NarrowableReference.ObjectAutoVariable;
 export declare namespace NarrowableReference {
     export class LocalVariable implements INarrowableReference {
         private readonly _analyzer;
-        readonly entity: LocalVariableEntity | ParameterVariableEntity;
+        readonly entity: LocalVariableEntity | ParameterVariableEntity | TextTemplateParameterVariableEntity;
         readonly kind = "local-variable";
-        constructor(_analyzer: Analyzer, entity: LocalVariableEntity | ParameterVariableEntity);
+        constructor(_analyzer: Analyzer, entity: LocalVariableEntity | ParameterVariableEntity | TextTemplateParameterVariableEntity);
         equals(other: NarrowableReference): boolean;
         contains(_other: NarrowableReference): boolean;
         equalsExpression(expression: NarrowableReferenceExpression): boolean;
@@ -27,10 +26,10 @@ export declare namespace NarrowableReference {
     }
     export class InstanceField implements INarrowableReference {
         private readonly _analyzer;
-        readonly field: types.Field;
+        readonly field: FieldEntity;
         readonly receiver: NarrowableReference;
         readonly kind = "instance-field";
-        constructor(_analyzer: Analyzer, field: types.Field, receiver: NarrowableReference);
+        constructor(_analyzer: Analyzer, field: FieldEntity, receiver: NarrowableReference);
         equals(other: NarrowableReference): boolean;
         contains(other: NarrowableReference): boolean;
         equalsExpression(expression: NarrowableReferenceExpression): boolean;
@@ -38,9 +37,9 @@ export declare namespace NarrowableReference {
     }
     export class StaticField implements INarrowableReference {
         private readonly _analyzer;
-        readonly field: types.Field;
+        readonly field: FieldEntity;
         readonly kind = "static-field";
-        constructor(_analyzer: Analyzer, field: types.Field);
+        constructor(_analyzer: Analyzer, field: FieldEntity);
         equals(other: NarrowableReference): boolean;
         contains(_other: NarrowableReference): boolean;
         equalsExpression(expression: NarrowableReferenceExpression): boolean;