@artel/artc 0.6.25226 → 0.6.25228

package/build/{chunk-YNR2KYMJ.js → chunk-F5OW64UA.js}

@@ -10,7 +10,7 @@ import {
   WellKnownDeclarationsLoadError,
   __async,
   createTsInteropInputsForCompilation
-} from "./chunk-VRQPLLYS.js";
+} from "./chunk-5GSDYTF6.js";
 
 // source/executor/Compiler.ts
 var Compiler = class {
@@ -69,7 +69,7 @@ var Compiler = class {
     return __async(this, null, function* () {
       if (analyzer.compilation.mainPackage === void 0) {
         _diagnostics?.addDiagnostic(new Diagnostic(DiagnosticData.withCode(
-          303 /* ProgramWithoutMainPackageCanNotBeCompiled */
+          403 /* ProgramWithoutMainPackageCannotBeCompiled */
         ), void 0));
         return void 0;
       }
@@ -83,7 +83,7 @@ var Compiler = class {
     return __async(this, null, function* () {
       if (analyzer.compilation.mainPackage === void 0) {
         _diagnostics?.addDiagnostic(new Diagnostic(DiagnosticData.withCode(
-          303 /* ProgramWithoutMainPackageCanNotBeCompiled */
+          403 /* ProgramWithoutMainPackageCannotBeCompiled */
         ), void 0));
         return "";
       }

package/build/{chunk-MHPX52MT.js → chunk-FHJJX7JY.js}

@@ -1,6 +1,6 @@
 import {
   Compiler
-} from "./chunk-YNR2KYMJ.js";
+} from "./chunk-F5OW64UA.js";
 import {
   ArtelVersion,
   Cached,
@@ -14,7 +14,7 @@ import {
   __async,
   performanceMeasurementStageNames,
   performanceMeasurementStages
-} from "./chunk-VRQPLLYS.js";
+} from "./chunk-5GSDYTF6.js";
 
 // source/executor/FileSystemUri.ts
 import { platform } from "os";
@@ -216,7 +216,7 @@ var NodeCompiler = class {
       const standardLibraryUri = yield this.findStandardTypeScriptLibrary(nodeModulesSearchPaths, defaultTsLibraryPath);
       if (standardLibraryUri === void 0) {
         const diagnostic = new Diagnostic(DiagnosticData.withCode(
-          301 /* CanNotFindTsLibDirectoryBaseSearchPaths0 */,
+          401 /* CannotFindTsLibDirectoryBaseSearchPaths0 */,
           [nodeModulesSearchPaths.map((p) => `'${p}'`).join(", ")]
         ), void 0);
         diagnostics?.addDiagnostic(diagnostic);

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

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { CancellationToken, Name, PackageLocale, Range, SearchName, WithDiagnostics } from '../common/index.js';
+import { CancellationToken, Lazy, Name, PackageLocale, Range, SearchName, 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';
@@ -35,8 +35,6 @@ import { NamedTypeSpecifierResolutionResult } from './NamedTypeSpecifierResolver
 import { DereferencedVariableAccessorDeclaration, FieldAccessorDeclaration, FunctionTypeDeclaration, GetterDeclaration, IndexedElementAccessorDeclaration, PackageVariableAccessorDeclaration, SetterDeclaration, StructuredTypeDeclaration, VariantTypeDeclaration } from './NodeTypeUtils.js';
 import * as objectExpressionMeaning from './ObjectExpressionMeaning.js';
 import * as operationOverloadResolver from './OperationOverloadResolver.js';
-import * as scope from './Scope.js';
-import { SemanticContextBuilder } from './SemanticContextBuilder.js';
 import { SourceFileMembers as ActualSourceFileMembers } from './SourceFileMembers.js';
 import * as tagMeaning from './TagMeaning.js';
 import * as tags from './Tags.js';
@@ -44,6 +42,7 @@ import { TargetTypeHint } from './TargetTypeHint.js';
 import * as typeOverloadResolver from './TypeOverloadResolver.js';
 import * as controlFlow from './control-flow/index.js';
 import { WellKnownDeclarations } from './index.js';
+import * as semanticContext from './semantic-context/index.js';
 export declare class Analyzer {
     static readonly enumeratorMethodName = "\u043F\u0435\u0440\u0435\u0431\u043E\u0440";
     static readonly functionTypeInvokeMethodName = "\u0432\u044B\u043F\u043E\u043B\u043D\u0438\u0442\u044C";
@@ -60,8 +59,7 @@ export declare class Analyzer {
     readonly entity: Entity;
     readonly resultLocalVariableEntity: ResultLocalVariableEntity;
     readonly valueLocalVariableEntity: ValueLocalVariableEntity;
-    readonly scope: Scope;
-    readonly semanticContext: SemanticContextBuilder;
+    readonly semanticContext: semanticContext.SemanticContextBuilder;
     readonly argumentToParameterMatchResult: ArgumentToParameterMatchResult;
     readonly defaultConstructors: DefaultConstructors;
     readonly overriddenMember: OverriddenMember;
@@ -96,6 +94,9 @@ export declare class Analyzer {
     private readonly _functionBlockWithYieldStatementCheckResults;
     private readonly _namedDeclarationsUsageCountResults;
     private readonly _controlFlowGraphs;
+    private readonly _diagnosticsComputedLazily;
+    private readonly _diagnosticsComputedLazilyAcceptor;
+    private readonly _sourcePackageMemberConflictsDiagnostics;
     get tsInterop(): TsInteropContext;
     constructor(compilation: project.Compilation, tsInteropInputs: TsInteropInputs);
     getProjectSourceFile(node: tree.SourceFile): project.SourceFile;
@@ -124,6 +125,7 @@ export declare class Analyzer {
     enumeratePackageImports(packageImportDirectives: Iterable<tree.PackageImportDirective>): Iterable<tree.PackageImport>;
     getSourceFileMembers(node: tree.SourceFile): ActualSourceFileMembers;
     getCallExpressionMeaning(node: tree.CallExpression): callExpressionMeaning.Meaning;
+    getCallExpressionType(node: tree.CallExpression): types.Type;
     getRespectiveParameter(node: tree.Argument): MatchResultValueParameter | undefined;
     resolveIndexedAccessExpression(node: tree.IndexedAccessExpression): indexedAccessExpressionMeaning.ResolutionResult;
     getDereferenceExpressionMeaning(node: tree.DereferenceExpression): dereferenceExpressionMeaning.Meaning;
@@ -157,7 +159,7 @@ export declare class Analyzer {
      * а?[1]
      * а?^
      * а?()
-     * (а)?.б
+     * (а?.б)
      * ```
      */
     isExpressionOptionalChainingSyntactically(node: tree.Expression): boolean;
@@ -237,7 +239,7 @@ export declare class Analyzer {
     isValueParameterVariadic(entity: e.VariableEntity): boolean;
     getDefaultTypeParameterConstraint(): types.Type;
     getOriginalSignatureTypeOfFunctionEntity(entity: e.FunctionEntity): types.FunctionType;
-    getFunctionBlockLiteralValueParameters(node: tree.FunctionBlockLiteral): readonly e.VariableEntity[];
+    getFunctionBlockLiteralValueParameters(node: tree.FunctionBlockLiteral): readonly e.ParameterVariableEntity[];
     getExtendedType(node: tree.TypeExtensionDeclaration): WithDiagnostics<e.NamedTypeEntity>;
     getAnalyzedTranslationPackageIfTargetResolved(package_: project.TranslationPackage): AnalyzedTranslationPackage | undefined;
     getAnalyzedTranslationPackageForPackage(entity: e.PackageEntity, locale: PackageLocale): AnalyzedTranslationPackage | undefined;
@@ -265,9 +267,17 @@ export declare class Analyzer {
     } | undefined;
     getControlFlowGraph(sourceFile: project.SourceFile): controlFlow.GraphBuildResult;
     createAmbiguousEntityAccessDiagnostic(entities: readonly WithLocalization<e.Entity>[], lctx: LocalizationContext, node: tree.Node): Diagnostic;
+    createAmbiguousEntityAccessLazyDiagnostic(entities: readonly WithLocalization<e.Entity>[], lctx: LocalizationContext, node: tree.Node): Lazy<Diagnostic>;
     createAmbiguousFunctionAccessDiagnostic(functions: readonly WithLocalization<AccessedFunction>[], lctx: LocalizationContext, node: tree.Node): Diagnostic;
+    createAmbiguousFunctionAccessLazyDiagnostic(functions: readonly WithLocalization<AccessedFunction>[], lctx: LocalizationContext, node: tree.Node): Lazy<Diagnostic>;
     createAmbiguousTypeMemberAccessDiagnostic(members: readonly WithLocalization<types.TypeMember>[], lctx: LocalizationContext, node: tree.Node): Diagnostic;
-    createAmbiguousNamedScopeDeclarationAccessDiagnostic(declarations: readonly WithLocalization<scope.NamedDeclaration>[], lctx: LocalizationContext, node: tree.Node): Diagnostic;
+    createAmbiguousTypeMemberAccessLazyDiagnostic(members: readonly WithLocalization<types.TypeMember>[], lctx: LocalizationContext, node: tree.Node): Lazy<Diagnostic>;
+    createAmbiguousNamedScopeDeclarationAccessDiagnostic(declarations: readonly WithLocalization<semanticContext.NamedDeclaration>[], lctx: LocalizationContext, node: tree.Node): Diagnostic;
+    createAmbiguousNamedScopeDeclarationAccessLazyDiagnostic(declarations: readonly WithLocalization<semanticContext.NamedDeclaration>[], lctx: LocalizationContext, node: tree.Node): Lazy<Diagnostic>;
+    addDiagnosticComputedLazily(diagnostic: Diagnostic): void;
+    getAcceptorForDiagnosticsComputedLazily(): DiagnosticAcceptor;
+    getDiagnosticsComputedLazily(sourceFile: project.SourceFile): readonly Diagnostic[];
+    validateSourcePackageMemberConflicts(pkg: project.ProgramPackage): readonly Diagnostic[];
     private createTsInterop;
 }
 export declare class TsInteropInputs {
@@ -321,7 +331,7 @@ declare class Type {
     private ofMemberAccessExpression;
     private ofReferenceExpression;
     private ofDereferenceExpression;
-    private ofWhenTernaryExpression;
+    private ofConditionalExpression;
     private ofTextTemplateLiteral;
     private ofIdentifierExpression;
     private ofTokenExpression;
@@ -353,6 +363,10 @@ declare class ReturnType {
     ofFunctionLiteral(node: tree.FunctionLiteral): types.Type;
     ofMethodDeclaration(node: tree.MethodDeclaration): types.Type;
     ofOperatorDeclaration(node: tree.OperatorDeclaration): types.Type;
+    ofPackageVariableGetterDeclaration(node: tree.PackageVariableGetterDeclaration): types.Type;
+    ofFieldGetterDeclaration(node: tree.FieldGetterDeclaration): types.Type;
+    ofDereferencedVariableGetterDeclaration(node: tree.DereferencedVariableGetterDeclaration): types.Type;
+    ofIndexedElementGetterDeclaration(node: tree.IndexedElementGetterDeclaration): types.Type;
 }
 declare class Entity {
     private readonly _analyzer;
@@ -452,66 +466,10 @@ declare class ValueLocalVariableEntity {
     private readonly _analyzer;
     private readonly _entities;
     constructor(_analyzer: Analyzer);
-    ofPackageVariableSetterDeclaration(node: tree.PackageVariableSetterDeclaration): e.VariableEntity;
-    ofFieldSetterDeclaration(node: tree.FieldSetterDeclaration): e.VariableEntity;
-    ofIndexedElementSetterDeclaration(node: tree.IndexedElementSetterDeclaration): e.VariableEntity;
-    ofDereferencedVariableSetterDeclaration(node: tree.DereferencedVariableSetterDeclaration): e.VariableEntity;
-}
-declare class Scope {
-    private readonly _analyzer;
-    private readonly _sourceFileScopes;
-    private readonly _functionBlockLiteralScopes;
-    private readonly _packageFunctionDeclarationTypeParametersScopes;
-    private readonly _packageFunctionDeclarationValueParametersScopes;
-    private readonly _structuredMethodDeclarationTypeParametersScopes;
-    private readonly _structuredMethodDeclarationValueParametersScopes;
-    private readonly _nestedFunctionDeclarationTypeParametersScopes;
-    private readonly _nestedFunctionDeclarationValueParametersScopes;
-    private readonly _functionLiteralScopes;
-    private readonly _functionBlockScopes;
-    private readonly _statementBlockScopes;
-    private readonly _forEachStatementScopes;
-    private readonly _catchClauseScopes;
-    private readonly _packageStructuredTypeDeclarationTypeParametersScopes;
-    private readonly _structuredTypeDeclarationBodyScopes;
-    private readonly _packageFunctionTypeDeclarationTypeParametersScopes;
-    private readonly _functionTypeDeclarationBodyScopes;
-    private readonly _packageVariantTypeDeclarationTypeParametersScopes;
-    private readonly _variantTypeDeclarationBodyScopes;
-    private readonly _aliasTypeDeclarationBodyScopes;
-    private readonly _packageAliasTypeDeclarationTypeParametersScopes;
-    private readonly _operatorDeclarationScopes;
-    private readonly _structuredConstructorDeclarationScopes;
-    private readonly _structuredDestructorDeclarationScopes;
-    private readonly _indexedElementAccessorDeclarationParametersScopes;
-    private readonly _typeExtensionDeclarationScopes;
-    constructor(_analyzer: Analyzer);
-    ofSourceFile(node: tree.SourceFile): scope.IScope;
-    ofFunctionBlockLiteral(node: tree.FunctionBlockLiteral): scope.IScope;
-    ofPackageFunctionDeclarationTypeParameters(node: tree.PackageFunctionDeclaration): scope.IScope;
-    ofPackageFunctionDeclarationValueParameters(node: tree.PackageFunctionDeclaration): scope.IScope;
-    ofMethodDeclarationTypeParameters(node: tree.MethodDeclaration): scope.IScope;
-    ofMethodDeclarationValueParameters(node: tree.MethodDeclaration): scope.IScope;
-    ofNestedFunctionDeclarationTypeParameters(node: tree.NestedFunctionDeclaration): scope.IScope;
-    ofNestedFunctionDeclarationValueParameters(node: tree.NestedFunctionDeclaration): scope.IScope;
-    ofFunctionLiteral(node: tree.FunctionLiteral): scope.IScope;
-    ofFunctionBlock(node: tree.FunctionBlock): scope.IScope;
-    ofStatementBlock(node: tree.StatementBlock): scope.IScope;
-    ofForStatement(node: tree.ForStatement): scope.IScope;
-    ofCatchClause(node: tree.CatchClause): scope.IScope;
-    ofPackageStructuredTypeDeclarationTypeParameters(node: tree.PackageStructuredTypeDeclaration): scope.IScope;
-    ofStructuredTypeDeclarationBody(node: tree.StructuredTypeDeclarationBody): scope.IScope;
-    ofPackageFunctionTypeDeclarationTypeParameters(node: tree.PackageFunctionTypeDeclaration): scope.IScope;
-    ofFunctionTypeDeclarationBody(node: tree.FunctionTypeDeclarationBody): scope.IScope;
-    ofPackageVariantTypeDeclarationTypeParameters(node: tree.PackageVariantTypeDeclaration): scope.IScope;
-    ofVariantTypeDeclarationBody(node: tree.VariantTypeDeclarationBody): scope.IScope;
-    ofAliasTypeDeclarationBody(node: tree.AliasTypeDeclarationBody): scope.IScope;
-    ofPackageAliasTypeDeclarationTypeParameters(node: tree.PackageAliasTypeDeclaration): scope.IScope;
-    ofOperatorDeclaration(node: tree.OperatorDeclaration): scope.IScope;
-    ofConstructorDeclaration(node: tree.ConstructorDeclaration): scope.IScope;
-    ofDestructorDeclaration(node: tree.DestructorDeclaration): scope.IScope;
-    ofIndexedElementAccessorDeclarationParameters(node: IndexedElementAccessorDeclaration): scope.IScope;
-    ofTypeExtensionDeclaration(node: tree.TypeExtensionDeclaration): scope.IScope;
+    ofPackageVariableSetterDeclaration(node: tree.PackageVariableSetterDeclaration): e.LocalVariableEntity;
+    ofFieldSetterDeclaration(node: tree.FieldSetterDeclaration): e.LocalVariableEntity;
+    ofIndexedElementSetterDeclaration(node: tree.IndexedElementSetterDeclaration): e.LocalVariableEntity;
+    ofDereferencedVariableSetterDeclaration(node: tree.DereferencedVariableSetterDeclaration): e.LocalVariableEntity;
 }
 declare class DefaultConstructors {
     private readonly _analyzer;
@@ -662,10 +620,13 @@ export declare class TypeUtils {
     private readonly _analyzer;
     constructor(_analyzer: Analyzer);
     getCommonObjectAndAspectTypesOfUnion(unionType: types.UnionType): readonly types.StructuredType[];
-    private getTypesForCommonTypesSearch;
+    removeBaseTypesInPlace(types: types.Type[]): void;
+    removeDerivedTypesInPlace(types: types.Type[]): void;
+    private getBaseTypesForCommonTypesSearch;
     private addTypeAndCollectAllBaseTypes;
     private addTypeIfUnique;
-    private removeBaseTypes;
+    private getFlattenedConstituentTypesForCommonTypesSearch;
+    private flattenTypeParameterConstraint;
 }
 export declare class ExpressionDenotesFunctionCheckResult {
     readonly candidates: readonly WithLocalization<AccessedFunction>[];

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

@@ -0,0 +1,11 @@
+import { Analyzer } from './Analyzer.js';
+import * as controlFlow from './control-flow/index.js';
+export declare class AssignmentChecker {
+    private readonly _analyzer;
+    private readonly _variableReference;
+    private readonly _controlFlowNode;
+    private readonly _checkResults;
+    constructor(analyzer: Analyzer, variableReference: controlFlow.NarrowableReference, controlFlowNode: controlFlow.Node);
+    checkVariableIsAssigned(): boolean;
+    private checkVariableIsAssignedAtNode;
+}

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

@@ -11,8 +11,10 @@ export declare class Resolver {
     constructor(_analyzer: Analyzer, _node: CallExpression);
     private get callee();
     resolve(): Meaning;
+    resolveType(meaning: Meaning | undefined): types.Type;
     private resolveConstructorCallExpressionMeaning;
     private getNodeForDiagnostics;
+    private getTypeFromMeaning;
 }
 export type Meaning = Meaning_functionCall | Meaning_operatorCall | Meaning_objectFunctionCall | Meaning_constructorCall | Meaning_unresolved;
 declare class Meaning_functionCall {

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

@@ -7,12 +7,17 @@ export declare class DeclarationsUsageCounter {
     private readonly _analyzer;
     private readonly _sourceFile;
     private readonly _cancellationToken;
-    private readonly _usageCountByEntity;
+    private readonly _usageInfoByEntity;
     constructor(analyzer: Analyzer, sourceFile: tree.SourceFile, cancellationToken: CancellationToken | undefined);
     count(): Promise<DeclarationsUsageCountResult>;
+    private recordUsage;
 }
 export declare class DeclarationsUsageCountResult {
     private readonly _usageCountByEntity;
-    constructor(_usageCountByEntity: ReadonlyMap<Entity, number>);
-    getUsageCount(entity: NamedEntity): number;
+    constructor(_usageCountByEntity: ReadonlyMap<Entity, DeclarationUsageInfo>);
+    getUsageInfo(entity: NamedEntity): DeclarationUsageInfo;
+}
+export interface DeclarationUsageInfo {
+    readonly usageCount: number;
+    readonly hasGetAccess: boolean;
 }

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

@@ -18,6 +18,8 @@ export declare class DiagnosticCollector {
     constructor(analyzer: Analyzer, sourceFile: project.SourceFile, cancellationToken: CancellationToken | undefined);
     collect(): Promise<Diagnostic[]>;
     private collectNodeDiagnostics;
+    private checkFunctionLiteral;
+    private checkFunctionBlockLiteral;
     private checkDereferenceExpression;
     private checkIndexedAccessExpression;
     private checkCallExpression;
@@ -44,13 +46,16 @@ export declare class DiagnosticCollector {
     private checkPossibleGeneratorFunctionReturnType;
     private checkReturnStatement;
     private checkYieldStatement;
+    private checkPackageMemberBodyPresence;
+    private getPackageMemberBodyRequirementReason;
     private checkTypeMemberBodyPresence;
-    private tryGetTypeMemberDeclarationEntity;
-    private isAspectTypeMemberDeclaration;
-    private collectIdentifierExpressionDiagnostics;
-    private collectMemberAccessExpressionDiagnostics;
+    private getTypeMemberBodyRequirementReason;
+    private isRedefinableEntity;
+    private checkIdentifierExpression;
+    private checkLocalVariableUsedBeforeDeclaration;
+    private checkLocalVariableIsUsedBeforeBeingAssigned;
+    private checkMemberAccessExpression;
     private addDiagnosticsFromMatchResult;
-    private checkStatementForVariablesUsedBeforeBeingAssigned;
     private checkExpressionTypeAssignableToTargetType;
     private addTypeAssignabilityDiagnosticIfBothTypesResolved;
     private checkAssignmentIsValid;
@@ -73,6 +78,11 @@ export declare class DiagnosticCollector {
     private checkTypeArgumentCount;
     private checkParameterDeclaration;
     private checkIfVariableIsUnused;
+    private checkIfNestedFunctionIsUnused;
+    private checkIfTypeParameterIsUnused;
+    private checkAllCodePathsReturnOrResultVariableIsAssigned;
     private addDiagnostic;
     private addDiagnostics;
+    private addMaybeLazyDiagnostic;
+    private addMaybeLazyDiagnostics;
 }

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

@@ -1,4 +1,4 @@
-import { AccessKind, Name } from '../common/index.js';
+import { AccessKind, MaybeLazy, 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';
@@ -6,8 +6,8 @@ import * as types from '../types/index.js';
 import { AccessedFunction } from './AccessedFunction.js';
 import { FoundAnonymousDeclaration, FoundNamedDeclaration } from './FoundDeclaration.js';
 import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
-import * as scope from './Scope.js';
 import { Analyzer, TargetTypeHint } from './index.js';
+import { NamedDeclaration } from './semantic-context/index.js';
 export declare class Resolver {
     private readonly _semanticContext;
     private readonly _analyzer;
@@ -23,12 +23,12 @@ export declare class Resolver {
 }
 export declare class ResolutionResult {
     readonly meaning: Meaning;
-    readonly diagnostic?: Diagnostic | undefined;
+    readonly diagnostic?: MaybeLazy<Diagnostic> | undefined;
     /**
      * Может ли измениться результат, если посчитать его с другим целевым типом?
      */
     readonly dependsOnTargetType: boolean;
-    constructor(meaning: Meaning, diagnostic?: Diagnostic | undefined, 
+    constructor(meaning: Meaning, diagnostic?: MaybeLazy<Diagnostic> | undefined, 
     /**
      * Может ли измениться результат, если посчитать его с другим целевым типом?
      */
@@ -73,9 +73,9 @@ declare class Meaning_typeAccess {
     constructor(candidates: readonly FoundNamedDeclaration<NamedTypeEntity>[], suitableTypes: readonly FoundNamedDeclaration<types.Type>[]);
 }
 declare class Meaning_mixedAmbiguousAccess {
-    readonly declarations: readonly FoundNamedDeclaration<scope.NamedDeclaration>[];
+    readonly declarations: readonly FoundNamedDeclaration<NamedDeclaration>[];
     readonly kind = "mixed-ambiguous-access";
-    constructor(declarations: readonly FoundNamedDeclaration<scope.NamedDeclaration>[]);
+    constructor(declarations: readonly FoundNamedDeclaration<NamedDeclaration>[]);
 }
 declare class Meaning_unresolved {
     readonly kind = "unresolved";

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

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

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

@@ -1,4 +1,4 @@
-import { AccessKind } from '../common/index.js';
+import { AccessKind, MaybeLazy } 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';
@@ -6,8 +6,8 @@ import * as types from '../types/index.js';
 import { AccessedFunction } from './AccessedFunction.js';
 import { FoundAnonymousDeclaration, FoundNamedDeclaration } from './FoundDeclaration.js';
 import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
-import { WithLocalization } from './Localization.js';
 import { Analyzer, TargetTypeHint } from './index.js';
+import { WithLocalization } from './Localization.js';
 export declare class Resolver {
     private readonly _semanticContext;
     private readonly _analyzer;
@@ -31,18 +31,18 @@ export declare class Resolver {
 }
 export declare class ResolutionResult {
     readonly meaning: Meaning;
-    readonly diagnostic?: Diagnostic | undefined;
+    readonly diagnostic?: MaybeLazy<Diagnostic> | undefined;
     /**
      * Может ли измениться результат, если посчитать его с другим целевым типом?
      */
     readonly dependsOnTargetType: boolean;
-    constructor(meaning: Meaning, diagnostic?: Diagnostic | undefined, 
+    constructor(meaning: Meaning, diagnostic?: MaybeLazy<Diagnostic> | undefined, 
     /**
      * Может ли измениться результат, если посчитать его с другим целевым типом?
      */
     dependsOnTargetType?: boolean);
 }
-export type Meaning = Meaning_packageVariableAccess | Meaning_packageFunctionAccess | Meaning_packageTypeAccess | Meaning_packageNameSegmentAccess | Meaning_staticVariableAccess | Meaning_staticMethodAccess | Meaning_instanceVariableAccess | Meaning_instanceMethodAccess | Meaning_operatorAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
+export type Meaning = Meaning_packageVariableAccess | Meaning_packageFunctionAccess | Meaning_packageTypeAccess | Meaning_packageNameSegmentAccess | Meaning_staticFieldAccess | Meaning_staticMethodAccess | Meaning_instanceFieldAccess | Meaning_instanceMethodAccess | Meaning_operatorAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
 declare class Meaning_packageVariableAccess {
     readonly variable: FoundNamedDeclaration<PackageVariableEntity>;
     readonly accessKind: AccessKind;
@@ -68,11 +68,11 @@ declare class Meaning_packageNameSegmentAccess {
     readonly kind = "package-name-segment-access";
     constructor(packageTreeNode: PackageNameTreeNode);
 }
-declare class Meaning_staticVariableAccess {
+declare class Meaning_staticFieldAccess {
     readonly type: types.Type;
     readonly variable: FoundNamedDeclaration<types.Variable>;
     readonly accessKind: AccessKind;
-    readonly kind = "static-variable-access";
+    readonly kind = "static-field-access";
     constructor(type: types.Type, variable: FoundNamedDeclaration<types.Variable>, accessKind: AccessKind);
 }
 declare class Meaning_staticMethodAccess {
@@ -83,10 +83,10 @@ declare class Meaning_staticMethodAccess {
     get singleSuitableFunction(): FoundNamedDeclaration<AccessedFunction> | undefined;
     constructor(type: types.Type, candidates: readonly FoundNamedDeclaration<AccessedFunction>[], suitableFunctions: readonly FoundNamedDeclaration<AccessedFunction>[]);
 }
-declare class Meaning_instanceVariableAccess {
+declare class Meaning_instanceFieldAccess {
     readonly variable: FoundNamedDeclaration<types.Variable>;
     readonly accessKind: AccessKind;
-    readonly kind = "instance-variable-access";
+    readonly kind = "instance-field-access";
     constructor(variable: FoundNamedDeclaration<types.Variable>, accessKind: AccessKind);
 }
 declare class Meaning_instanceMethodAccess {

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

@@ -1,3 +1,4 @@
+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';
@@ -23,9 +24,9 @@ export declare class NamedTypeResolver {
 export declare class NamedTypeResolutionResult {
     readonly types: readonly FoundNamedDeclaration<NamedTypeEntity>[];
     readonly resolvedQualifiers: readonly ResolvedQualifier[];
-    readonly diagnostics: readonly Diagnostic[];
+    readonly diagnostics: readonly MaybeLazy<Diagnostic>[];
     readonly ambiguousDeclarations: readonly WithLocalization<EntityOrPackageNameTreeNode>[] | undefined;
-    constructor(types: readonly FoundNamedDeclaration<NamedTypeEntity>[], resolvedQualifiers: readonly ResolvedQualifier[], diagnostics: readonly Diagnostic[], ambiguousDeclarations: readonly WithLocalization<EntityOrPackageNameTreeNode>[] | undefined);
+    constructor(types: readonly FoundNamedDeclaration<NamedTypeEntity>[], resolvedQualifiers: readonly ResolvedQualifier[], diagnostics: readonly MaybeLazy<Diagnostic>[], ambiguousDeclarations: readonly WithLocalization<EntityOrPackageNameTreeNode>[] | undefined);
 }
 export type ResolvedQualifier = ResolvedQualifier_packageNameSegment | ResolvedQualifier_packageAlias | ResolvedQualifier_type;
 export declare class ResolvedQualifier_packageNameSegment {

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

@@ -1,3 +1,4 @@
+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';
@@ -16,7 +17,7 @@ export declare class NamedTypeSpecifierResolver {
 export declare class NamedTypeSpecifierResolutionResult {
     readonly type: FoundNamedDeclaration<types.Type> | undefined;
     readonly resolvedQualifiers: readonly ResolvedQualifier[];
-    readonly diagnostics: readonly Diagnostic[];
+    readonly diagnostics: readonly MaybeLazy<Diagnostic>[];
     readonly ambiguousDeclarations: readonly WithLocalization<EntityOrPackageNameTreeNode>[] | undefined;
-    constructor(type: FoundNamedDeclaration<types.Type> | undefined, resolvedQualifiers: readonly ResolvedQualifier[], diagnostics: readonly Diagnostic[], ambiguousDeclarations: readonly WithLocalization<EntityOrPackageNameTreeNode>[] | undefined);
+    constructor(type: FoundNamedDeclaration<types.Type> | undefined, resolvedQualifiers: readonly ResolvedQualifier[], diagnostics: readonly MaybeLazy<Diagnostic>[], ambiguousDeclarations: readonly WithLocalization<EntityOrPackageNameTreeNode>[] | undefined);
 }

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

@@ -12,8 +12,8 @@ export declare class NodeTypeUtils {
     static isFunctionDeclaration(node: tree.Node): node is FunctionDeclaration;
     static isVariableDeclaration(node: tree.Node): node is VariableDeclaration;
     static isVariantTypeDeclaration(node: tree.Node): node is VariantTypeDeclaration;
-    static isSubprogramDeclaration(node: tree.Node): node is SubprogramDeclaration;
     static isNoneLiteral(node: tree.Node): boolean;
+    static isSubprogramDeclarationOrLiteral(node: tree.Node): node is SubprogramDeclarationOrLiteral;
 }
 export type PackageTypeDeclaration = tree.PackageAliasTypeDeclaration | tree.PackageFunctionTypeDeclaration | tree.PackageStructuredTypeDeclaration | tree.PackageVariantTypeDeclaration;
 export type StructuredTypeDeclaration = tree.PackageStructuredTypeDeclaration | tree.AnonymousStructuredTypeDeclaration;
@@ -29,4 +29,5 @@ export type PackageVariableAccessorDeclaration = tree.PackageVariableGetterDecla
 export type FieldAccessorDeclaration = tree.FieldGetterDeclaration | tree.FieldSetterDeclaration;
 export type IndexedElementAccessorDeclaration = tree.IndexedElementGetterDeclaration | tree.IndexedElementSetterDeclaration;
 export type DereferencedVariableAccessorDeclaration = tree.DereferencedVariableGetterDeclaration | tree.DereferencedVariableSetterDeclaration;
-export type SubprogramDeclaration = tree.FunctionBlockParent | tree.FunctionLiteral | tree.FunctionBlockLiteral;
+export type RegularOrBlockFunctionLiteral = tree.FunctionLiteral | tree.FunctionBlockLiteral;
+export type SubprogramDeclarationOrLiteral = tree.FunctionBlockParent;

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

@@ -0,0 +1,24 @@
+import { Diagnostic } from '../diagnostic/Diagnostic.js';
+import { OriginalPackageMembers } from '../entities/PackageMembers.js';
+import { ProgramPackage } from '../project/SourcePackage.js';
+import { Analyzer } from './Analyzer.js';
+export declare class PackageMemberNameConflictsValidator {
+    private readonly _analyzer;
+    private readonly _members;
+    private readonly _diagnostics;
+    constructor(_analyzer: Analyzer, _members: OriginalPackageMembers);
+    validate(): readonly Diagnostic[];
+    private validateFunctionNameConflicts;
+    private areFunctionSignaturesEqual;
+    private validateTypeNameConflicts;
+    private typeParameterCountsIntersect;
+    private createAndAddNameConflictDiagnosticsForAllEntities;
+    private createAndAddNameConflictDiagnostic;
+    private getDiagnosticLocation;
+}
+export declare class SourcePackageMemberConflictsValidator {
+    private readonly _analyzer;
+    private readonly _package;
+    constructor(_analyzer: Analyzer, _package: ProgramPackage);
+    validate(): readonly Diagnostic[];
+}

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

@@ -1,15 +1,20 @@
 import { SearchName } from '../common/index.js';
+import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
 import { PackageAliasEntity, PackageFunctionEntity, PackageTypeEntity, PackageVariableEntity, TypeExtensionEntity } from '../entities/index.js';
+import { Analyzer } from './Analyzer.js';
 export declare class SourceFileMembers {
+    private readonly _analyzer;
     private readonly _namedMembers;
     private readonly _typeExtensions;
     private readonly _declarationsByName;
     get declarationsByName(): ReadonlyMap<string, readonly NamedSourceFileMemberEntity[]>;
-    constructor(namedMembers: readonly NamedSourceFileMemberEntity[], typeExtensions: readonly TypeExtensionEntity[]);
+    constructor(analyzer: Analyzer, namedMembers: readonly NamedSourceFileMemberEntity[], typeExtensions: readonly TypeExtensionEntity[]);
     getNamedDeclarations(): readonly NamedSourceFileMemberEntity[];
     getNamedDeclarationsByName(name: SearchName): readonly NamedSourceFileMemberEntity[];
     getPackageAliases(): readonly PackageAliasEntity[];
     getPackageAliasesByName(name: SearchName): readonly PackageAliasEntity[];
     getTypeExtensions(): readonly TypeExtensionEntity[];
+    validateNameConflicts(diagnostics: DiagnosticAcceptor): void;
+    private getDiagnosticLocation;
 }
 export type NamedSourceFileMemberEntity = PackageTypeEntity | PackageVariableEntity | PackageFunctionEntity | PackageAliasEntity;

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

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

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

@@ -1,3 +1,4 @@
+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';
@@ -26,9 +27,9 @@ export declare class Resolver {
 export declare class ResolutionResult {
     readonly meaning: Meaning;
     readonly resolvedQualifiers: readonly ResolvedQualifier[];
-    readonly diagnostic?: Diagnostic | undefined;
+    readonly diagnostic?: MaybeLazy<Diagnostic> | undefined;
     readonly ambiguousDeclarations?: readonly WithLocalization<EntityOrPackageNameTreeNode>[] | undefined;
-    constructor(meaning: Meaning, resolvedQualifiers: readonly ResolvedQualifier[], diagnostic?: Diagnostic | undefined, ambiguousDeclarations?: readonly WithLocalization<EntityOrPackageNameTreeNode>[] | undefined);
+    constructor(meaning: Meaning, resolvedQualifiers: readonly ResolvedQualifier[], diagnostic?: MaybeLazy<Diagnostic> | undefined, ambiguousDeclarations?: readonly WithLocalization<EntityOrPackageNameTreeNode>[] | undefined);
 }
 export type Meaning = Meaning_tagType | Meaning_tagFunction | Meaning_unresolved;
 declare class Meaning_tagType {

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

@@ -4,6 +4,8 @@ export declare class TypeInferrer {
     private readonly _analyzer;
     private _getType;
     private _typeInferringState;
+    private _hasDetectedInferenceCycle;
+    get hasDetectedInferenceCycle(): boolean;
     constructor(analyzer: Analyzer, getType: () => types.Type);
     inferType(): types.Type;
 }