@artel/artc 0.6.25258 → 0.6.25260

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

@@ -3,17 +3,19 @@ import { AutotypeCallExpression } from '../tree/index.js';
 import * as types from '../types/index.js';
 import { Analyzer, ExpressionAnalysisOptions } from './index.js';
 export declare class Resolver {
-    private readonly _analyzer;
-    private readonly _node;
-    private readonly _analysisOptions;
-    constructor(_analyzer: Analyzer, _node: AutotypeCallExpression, _analysisOptions: ExpressionAnalysisOptions | undefined);
+    private readonly analyzer;
+    private readonly node;
+    private readonly analysisOptions;
+    constructor(analyzer: Analyzer, node: AutotypeCallExpression, analysisOptions: ExpressionAnalysisOptions | undefined);
     resolve(): ResolutionResult;
+    private isAutotypeExpressionInValidPosition;
 }
 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;
+    readonly dependsOnTargetType: boolean;
+    constructor(meaning: Meaning, diagnostics?: readonly Diagnostic[] | undefined, dependsOnTargetType?: boolean);
+    static unresolved(diagnostics: readonly Diagnostic[] | undefined, dependsOnTargetType?: boolean): ResolutionResult;
 }
 export type Meaning = Meaning_constructorCall | Meaning_unresolved;
 declare class Meaning_constructorCall {

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

@@ -4,8 +4,8 @@ import * as types from '../types/index.js';
 import { AccessedFunction } from './AccessedFunction.js';
 import { Analyzer } from './Analyzer.js';
 export declare class FirstStageResolver {
-    private readonly _analyzer;
-    private readonly _node;
+    private readonly analyzer;
+    private readonly node;
     constructor(analyzer: Analyzer, node: tree.BaseExpression);
     resolve(): FirstStageResolutionsResult;
     private resolveBaseConstructorOrMethodAccess;
@@ -27,9 +27,9 @@ export declare class FirstStageResolver {
  *    реализации по умолчанию члена базового аспекта.
  */
 export declare class SecondStageResolver {
-    private readonly _analyzer;
-    private readonly _node;
-    private readonly _firstStageResolutionResult;
+    private readonly analyzer;
+    private readonly node;
+    private readonly firstStageResolutionResult;
     constructor(analyzer: Analyzer, node: tree.BaseExpression, firstStageResolutionResult: FirstStageResolutionsResult);
     resolve(): ResolutionResult;
     private resolveOverriddenMethodAccess;

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

@@ -4,13 +4,13 @@ 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 _diagnosticArgumentFactory;
-    private readonly _diagnostics;
-    private readonly _nodeForDiagnostic;
-    constructor(_analyzer: Analyzer, _typeEntity: TypeEntityWithMembers, _hidingMatcher: IEntityHidingMatcher, _diagnosticArgumentFactory: DiagnosticArgumentFactory, _diagnostics: DiagnosticAcceptor, _nodeForDiagnostic: Node);
+    private readonly analyzer;
+    private readonly typeEntity;
+    private readonly hidingMatcher;
+    private readonly diagnosticArgumentFactory;
+    private readonly diagnostics;
+    private readonly nodeForDiagnostic;
+    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

@@ -5,11 +5,10 @@ import * as types from '../types/index.js';
 import { AccessedFunction, NotSubstitutedAccessedFunction } from './AccessedFunction.js';
 import { Analyzer, ExpressionAnalysisOptions } from './index.js';
 export declare class Resolver {
-    private readonly _analyzer;
-    private readonly _node;
-    private readonly _analysisOptions;
-    constructor(_analyzer: Analyzer, _node: tree.CallExpression, _analysisOptions: ExpressionAnalysisOptions | undefined);
-    private get callee();
+    private readonly analyzer;
+    private readonly node;
+    private readonly analysisOptions;
+    constructor(analyzer: Analyzer, node: tree.CallExpression, analysisOptions: ExpressionAnalysisOptions | undefined);
     resolve(): ResolutionResult;
     private checkExpressionDenotesType;
     private checkExpressionDenotesFunction;
@@ -18,7 +17,6 @@ export declare class Resolver {
     private resolveOperatorCallExpression;
     private resolveConstructorCallExpression;
     private resolveObjectFunctionCallExpression;
-    private getNodeForDiagnostics;
 }
 export declare class ResolutionResult {
     readonly meaning: Meaning;

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

@@ -16,7 +16,7 @@ export declare class ResolutionResult {
     readonly typeEntity: NamedTypeEntity | undefined;
     readonly type: types.Type | undefined;
     readonly singleNotSuitableSubstitutedCandidate: types.Constructor | undefined;
-    private static _empty;
+    private static empty_;
     static get empty(): ResolutionResult;
     constructor(candidates: readonly types.Constructor[], suitableConstructors: readonly types.Constructor[], typeEntity: NamedTypeEntity | undefined, type: types.Type | undefined, singleNotSuitableSubstitutedCandidate: types.Constructor | undefined);
 }

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

@@ -3,16 +3,16 @@ import { Entity, NamedEntity } from '../entities/index.js';
 import * as tree from '../tree/index.js';
 import { Analyzer } from './Analyzer.js';
 export declare class DeclarationsUsageCounter {
-    private readonly _analyzer;
-    private readonly _sourceFile;
-    private readonly _usageInfoByEntity;
+    private readonly analyzer;
+    private readonly sourceFile;
+    private readonly usageInfoByEntity;
     constructor(analyzer: Analyzer, sourceFile: tree.SourceFile);
     count(cancellationToken?: CancellationToken | undefined): Promise<DeclarationsUsageMap>;
     private recordUsage;
 }
 export declare class DeclarationsUsageMap {
-    private readonly _usageCountByEntity;
-    constructor(_usageCountByEntity: ReadonlyMap<Entity, DeclarationUsageInfo>);
+    private readonly usageCountByEntity;
+    constructor(usageCountByEntity: ReadonlyMap<Entity, DeclarationUsageInfo>);
     getUsageInfo(entity: NamedEntity): DeclarationUsageInfo;
 }
 export interface DeclarationUsageInfo {

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

@@ -4,11 +4,11 @@ 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 _semanticContext;
+    private readonly analyzer;
+    private readonly node;
+    private readonly semanticContext_;
     private get semanticContext();
-    constructor(_analyzer: Analyzer, _node: DereferenceExpression);
+    constructor(analyzer: Analyzer, node: DereferenceExpression);
     resolve(): Meaning;
     private convertSyntacticAccessKind;
 }

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

@@ -9,8 +9,8 @@ import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
 export declare class DiagnosticArgumentFactory {
     readonly locale: PackageLocale;
     readonly dialect: PackageDialect;
-    private readonly _analyzer;
-    private readonly _contextualSourceFile;
+    private readonly analyzer;
+    private readonly contextualSourceFile;
     constructor(analyzer: Analyzer, locale: PackageLocale, dialect: PackageDialect, sourceFile: SourceFile | undefined);
     createDisplayableEntity(entity: Entity): DisplayableEntity;
     createDisplayableAccessedFunction(accessedFunction: AccessedFunction): DisplayableAccessedFunction;

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

@@ -4,21 +4,23 @@ import * as project from '../project/index.js';
 import { Analyzer } from './index.js';
 export declare class DiagnosticCollector {
     static readonly CancellationTokenThrottleTime = 50;
-    private readonly _analyzer;
-    private readonly _sourceFile;
-    private readonly _diagnosticArgumentFactory;
-    private readonly _translationPackage;
-    private readonly _diagnostics;
-    private readonly _diagnosticAcceptor;
-    private _namedDeclarationsUsageMap;
-    private readonly _modifierValidator;
-    private readonly _standardTypes;
+    private readonly analyzer;
+    private readonly sourceFile;
+    private readonly diagnosticArgumentFactory;
+    private readonly translationPackage_;
+    private readonly diagnostics;
+    private readonly diagnosticAcceptor;
+    private namedDeclarationsUsageMap;
+    private readonly modifierValidator;
+    private readonly standardTypes_;
     private get translationPackage();
     private get isInterfacePackageFile();
     private get standardTypes();
     constructor(analyzer: Analyzer, sourceFile: project.SourceFile);
     collect(cancellationToken?: CancellationToken | undefined): Promise<Diagnostic[]>;
     private collectNodeDiagnostics;
+    private checkTypeParameterList;
+    private checkTypeParameterDeclaration;
     private checkFunctionLiteral;
     private checkFunctionBlockLiteral;
     private checkDereferenceExpression;

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

@@ -6,47 +6,47 @@ import { AccessedFunction } from './AccessedFunction.js';
 import { Analyzer } from './Analyzer.js';
 import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
 export declare class DisplayableEntity implements Displayable {
-    private readonly _analyzer;
-    private readonly _entity;
-    private readonly _locale;
-    private readonly _dialect;
-    private readonly _contextualSourceFile;
-    constructor(_analyzer: Analyzer, _entity: Entity, _locale: PackageLocale, _dialect: PackageDialect, _contextualSourceFile: SourceFile | undefined);
+    private readonly analyzer;
+    private readonly entity;
+    private readonly locale;
+    private readonly dialect;
+    private readonly contextualSourceFile;
+    constructor(analyzer: Analyzer, entity: Entity, locale: PackageLocale, dialect: PackageDialect, contextualSourceFile: SourceFile | undefined);
     getDisplayText(): string;
 }
 export declare class DisplayableAccessedFunction implements Displayable {
-    private readonly _analyzer;
-    private readonly _accessedFunction;
-    private readonly _locale;
-    private readonly _dialect;
-    private readonly _contextualSourceFile;
-    constructor(_analyzer: Analyzer, _accessedFunction: AccessedFunction, _locale: PackageLocale, _dialect: PackageDialect, _contextualSourceFile: SourceFile | undefined);
+    private readonly analyzer;
+    private readonly accessedFunction;
+    private readonly locale;
+    private readonly dialect;
+    private readonly contextualSourceFile;
+    constructor(analyzer: Analyzer, accessedFunction: AccessedFunction, locale: PackageLocale, dialect: PackageDialect, contextualSourceFile: SourceFile | undefined);
     getDisplayText(): string;
 }
 export declare class DisplayableTypeMember implements Displayable {
-    private readonly _analyzer;
-    private readonly _member;
-    private readonly _locale;
-    private readonly _dialect;
-    private readonly _contextualSourceFile;
-    constructor(_analyzer: Analyzer, _member: types.TypeMember, _locale: PackageLocale, _dialect: PackageDialect, _contextualSourceFile: SourceFile | undefined);
+    private readonly analyzer;
+    private readonly member;
+    private readonly locale;
+    private readonly dialect;
+    private readonly contextualSourceFile;
+    constructor(analyzer: Analyzer, member: types.TypeMember, locale: PackageLocale, dialect: PackageDialect, contextualSourceFile: SourceFile | undefined);
     getDisplayText(): string;
 }
 export declare class DisplayablePackageNameTreeNode implements Displayable {
-    private readonly _analyzer;
-    private readonly _node;
-    private readonly _locale;
-    private readonly _dialect;
-    private readonly _contextualSourceFile;
-    constructor(_analyzer: Analyzer, _node: PackageNameTreeNode, _locale: PackageLocale, _dialect: PackageDialect, _contextualSourceFile: SourceFile | undefined);
+    private readonly analyzer;
+    private readonly node;
+    private readonly locale;
+    private readonly dialect;
+    private readonly contextualSourceFile;
+    constructor(analyzer: Analyzer, node: PackageNameTreeNode, locale: PackageLocale, dialect: PackageDialect, contextualSourceFile: SourceFile | undefined);
     getDisplayText(): string;
 }
 export declare class DisplayableType implements Displayable {
-    private readonly _analyzer;
-    private readonly _type;
-    private readonly _locale;
-    private readonly _dialect;
-    private readonly _contextualSourceFile;
-    constructor(_analyzer: Analyzer, _type: types.Type, _locale: PackageLocale, _dialect: PackageDialect, _contextualSourceFile: SourceFile | undefined);
+    private readonly analyzer;
+    private readonly type;
+    private readonly locale;
+    private readonly dialect;
+    private readonly contextualSourceFile;
+    constructor(analyzer: Analyzer, type: types.Type, locale: PackageLocale, dialect: PackageDialect, contextualSourceFile: SourceFile | undefined);
     getDisplayText(): string;
 }

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

@@ -9,9 +9,9 @@ import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
 import { Analyzer, ExpressionAnalysisOptions } from './index.js';
 import { NamedDeclaration } from './semantic-context/index.js';
 export declare class FirstStageResolver {
-    private readonly _semanticContext;
-    private readonly _analyzer;
-    private readonly _node;
+    private readonly semanticContext_;
+    private readonly analyzer;
+    private readonly node;
     private get semanticContext();
     constructor(analyzer: Analyzer, node: tree.IdentifierExpression);
     resolve(): FirstStageResolutionResult;
@@ -21,10 +21,10 @@ export declare class FirstStageResolver {
     private convertSyntacticAccessKind;
 }
 export declare class SecondStageResolver {
-    private readonly _analyzer;
-    private readonly _node;
-    private readonly _firstStageResolutionResult;
-    private readonly _analysisOptions;
+    private readonly analyzer;
+    private readonly node;
+    private readonly firstStageResolutionResult;
+    private readonly analysisOptions;
     constructor(analyzer: Analyzer, node: tree.IdentifierExpression, firstStageResolutionResult: FirstStageResolutionResult, analysisOptions: ExpressionAnalysisOptions | undefined);
     resolve(): ResolutionResult;
     private resolveTypeAccessAtCalleePosition;

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

@@ -2,7 +2,7 @@ import { Name } from '../common/index.js';
 import { PackageEntity } from '../entities/PackageEntity.js';
 import { PackageImportInfo } from './Analyzer.js';
 export declare class ImportedPackageNameTree {
-    private readonly _rootNodes;
+    private readonly rootNodes_;
     get rootNodes(): ReadonlyMap<string, PackageNameTreeNode>;
     constructor(owningPackage: PackageEntity, packageImportInfos: readonly PackageImportInfo[]);
     private add;

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

@@ -4,11 +4,11 @@ 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 _semanticContext;
+    private readonly analyzer;
+    private readonly node;
+    private readonly semanticContext_;
     private get semanticContext();
-    constructor(_analyzer: Analyzer, _node: IndexedAccessExpression);
+    constructor(analyzer: Analyzer, node: IndexedAccessExpression);
     resolve(): ResolutionResult;
     private getArgumentsRangeWithBrackets;
     private convertSyntacticAccessKind;

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

@@ -3,13 +3,13 @@ import { Analyzer } from './Analyzer.js';
 import { DeclarationsUsageMap } 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 readonly analyzer;
+    private readonly typeDeclaration;
+    private readonly declarationsUsageCountResult;
+    private readonly diagnostics;
+    private readonly semanticContext_;
     private get semanticContext();
-    constructor(_analyzer: Analyzer, _typeDeclaration: TypeWithMembersDeclaration, _declarationsUsageCountResult: DeclarationsUsageMap, _diagnostics: DiagnosticAcceptor);
+    constructor(analyzer: Analyzer, typeDeclaration: TypeWithMembersDeclaration, declarationsUsageCountResult: DeclarationsUsageMap, diagnostics: DiagnosticAcceptor);
     validate(): void;
     private getFieldsThatNeedToBeInitializedInConstructor;
     private checkDefaultConstructorInitializesAllFields;

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

@@ -8,9 +8,9 @@ import * as callExpressionMeaning from './CallExpressionMeaning.js';
 import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
 import { Analyzer, ExpressionAnalysisOptions } from './index.js';
 export declare class FirstStageResolver {
-    private readonly _semanticContext;
-    private readonly _analyzer;
-    private readonly _node;
+    private readonly semanticContext_;
+    private readonly analyzer;
+    private readonly node;
     private get memberName();
     private get semanticContext();
     private get receiver();
@@ -26,10 +26,10 @@ export declare class FirstStageResolver {
     private convertSyntacticAccessKind;
 }
 export declare class SecondStageResolver {
-    private readonly _analyzer;
-    private readonly _node;
-    private readonly _firstStageResolutionResult;
-    private readonly _analysisOptions;
+    private readonly analyzer;
+    private readonly node;
+    private readonly firstStageResolutionResult;
+    private readonly analysisOptions;
     constructor(analyzer: Analyzer, node: tree.MemberAccessExpression, firstStageResolutionResult: FirstStageResolutionResult, analysisOptions: ExpressionAnalysisOptions | undefined);
     resolve(): ResolutionResult;
     private resolveTypeAccessAtCalleePosition;

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

@@ -30,8 +30,8 @@ export declare enum DeclarationWithTypeMembersKind {
     TypeExtension = 5
 }
 export declare class ModifierValidator {
-    private readonly _analyzer;
-    private readonly _diagnostics;
+    private readonly analyzer;
+    private readonly diagnostics;
     static readonly allowedPackageMemberHidingModifiers: number;
     static readonly allowedPackageMemberModifiers: number;
     static readonly allowedModifiersByPackageMemberDeclarationKind: {
@@ -43,7 +43,7 @@ export declare class ModifierValidator {
         [T in TypeMemberDeclarationKind]: ModifierFlags;
     };
     private effectiveModifiers;
-    constructor(_analyzer: Analyzer, _diagnostics: DiagnosticAcceptor);
+    constructor(analyzer: Analyzer, diagnostics: DiagnosticAcceptor);
     static validatePackageVariableAccessorsHaveConsistentModifiers(analyzer: Analyzer, getterModifiers: ModifierFlags, setterModifiers: ModifierFlags, nodeForDiagnostic: tree.Node, diagnostics: DiagnosticAcceptor): void;
     static validateFieldAccessorsHaveConsistentModifiers(analyzer: Analyzer, getterModifiers: ModifierFlags, setterModifiers: ModifierFlags, nodeForDiagnostic: tree.Node, diagnostics: DiagnosticAcceptor): void;
     static validateIndexedElementAccessorsHaveConsistentModifiers(analyzer: Analyzer, getterModifiers: ModifierFlags, setterModifiers: ModifierFlags, nodeForDiagnostic: tree.Node, diagnostics: DiagnosticAcceptor): void;

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

@@ -5,9 +5,9 @@ import { Analyzer } from './Analyzer.js';
 import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
 import { EntityOrPackageNameTreeNode } from './Utils.js';
 export declare class NamedTypeResolver {
-    private readonly _analyzer;
-    private readonly _node;
-    private readonly _semanticContext;
+    private readonly analyzer;
+    private readonly node;
+    private readonly semanticContext_;
     private get semanticContext();
     constructor(analyzer: Analyzer, node: QualifiedName);
     resolve(): NamedTypeResolutionResult;

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

@@ -5,9 +5,9 @@ import { Analyzer } from './Analyzer.js';
 import { ResolvedQualifier } from './NamedTypeResolver.js';
 import { EntityOrPackageNameTreeNode } from './Utils.js';
 export declare class NamedTypeSpecifierResolver {
-    private readonly _analyzer;
-    private readonly _node;
-    constructor(_analyzer: Analyzer, _node: NamedTypeSpecifier);
+    private readonly analyzer;
+    private readonly node;
+    constructor(analyzer: Analyzer, node: NamedTypeSpecifier);
     resolve(): NamedTypeSpecifierResolutionResult;
 }
 export declare class NamedTypeSpecifierResolutionResult {

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.EnumerationVariableDeclaration | tree.PackageVariableDeclaration | tree.LocalVariableDeclaration | tree.ParameterDeclaration | tree.FieldDeclaration | tree.VariantDeclaration;
+export type VariableDeclaration = tree.ForStatementVariableDeclaration | 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;
 export type PackageVariableAccessorDeclaration = tree.PackageVariableGetterDeclaration | tree.PackageVariableSetterDeclaration;

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

@@ -8,8 +8,8 @@ import { Analyzer } from './Analyzer.js';
  * 2. объект - в любом выражении в контексте типа.
  */
 export declare class Resolver {
-    private readonly _analyzer;
-    private readonly _node;
+    private readonly analyzer;
+    private readonly node;
     constructor(analyzer: Analyzer, node: tree.ObjectExpression);
     resolve(): ResolutionResult;
     private resolveOwnConstructorAccess;

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

@@ -8,15 +8,15 @@ import * as matcher from './ArgumentsToParametersMatcher.js';
 import { DiagnosticArgumentFactory } from './DiagnosticArgumentFactory.js';
 import * as inferrer from './TypeArgumentInferrer.js';
 export declare class OverloadResolver<TSignature extends ISignature<TParameter>, TParameter extends ISignatureParameter, TArgument extends Argument> {
-    private readonly _analyzer;
-    private readonly _mode;
-    private readonly _signatures;
-    private readonly _arguments;
-    private readonly _analysisOptions;
-    private readonly _dataForTypeArgumentInference;
-    private readonly _diagnostics;
-    private readonly _nodesForDiagnostic;
-    constructor(_analyzer: Analyzer, _mode: ResolutionMode, _signatures: readonly TSignature[], _arguments: readonly TArgument[], _analysisOptions: ExpressionAnalysisOptions, _dataForTypeArgumentInference: DataForTypeArgumentInference | undefined, _diagnostics: DiagnosticAcceptorWithArgumentFactory | undefined, _nodesForDiagnostic: NodesForDiagnostic | undefined);
+    private readonly analyzer;
+    private readonly mode;
+    private readonly signatures;
+    private readonly arguments_;
+    private readonly analysisOptions;
+    private readonly dataForTypeArgumentInference;
+    private readonly diagnostics;
+    private readonly nodesForDiagnostic;
+    constructor(analyzer: Analyzer, mode: ResolutionMode, signatures: readonly TSignature[], arguments_: readonly TArgument[], analysisOptions: ExpressionAnalysisOptions, dataForTypeArgumentInference: DataForTypeArgumentInference | undefined, diagnostics: DiagnosticAcceptorWithArgumentFactory | undefined, nodesForDiagnostic: NodesForDiagnostic | undefined);
     resolveOverload(): ProcessedSignature<TSignature, TParameter, TArgument>[];
     private areArgumentTypesAssignableToParameterTypes;
     private tryChooseBestSignature;
@@ -55,7 +55,7 @@ export declare class IntrinsicArgument implements matcher.IArgument, inferrer.In
     get name(): Name | undefined;
     constructor(type: types.Type);
     getDiagnosticLocation(): DiagnosticLocation | undefined;
-    getType(_analysisOptions: ExpressionAnalysisOptions | undefined): types.Type;
+    getType(analysisOptions_: ExpressionAnalysisOptions | undefined): types.Type;
 }
 interface IArgument {
     getType(analysisOptions: ExpressionAnalysisOptions | undefined): types.Type;
@@ -64,18 +64,18 @@ export declare class SourceNodeArgument implements SourceArgument {
     readonly kind = "source";
     readonly node: tree.Argument;
     readonly name: Name | undefined;
-    private readonly _analyzer;
+    private readonly analyzer;
     get expression(): tree.Expression;
     constructor(analyzer: Analyzer, node: tree.Argument);
     getDiagnosticLocation(): DiagnosticLocation;
     getType(analysisOptions: ExpressionAnalysisOptions | undefined): types.Type;
 }
 export declare class SourceExpressionArgument implements SourceArgument {
-    private readonly _analyzer;
+    private readonly analyzer;
     readonly expression: tree.Expression;
     readonly kind = "source";
     get name(): Name | undefined;
-    constructor(_analyzer: Analyzer, expression: tree.Expression);
+    constructor(analyzer: Analyzer, expression: tree.Expression);
     getDiagnosticLocation(): DiagnosticLocation;
     getType(analysisOptions: ExpressionAnalysisOptions | undefined): types.Type;
 }

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

@@ -5,11 +5,11 @@ 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);
+    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;

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

@@ -3,11 +3,11 @@ import { SourcePackage } from '../project/SourcePackage.js';
 import { Analyzer } from './Analyzer.js';
 import { DeclarationsUsageMap } from './DeclarationsUsageCounter.js';
 export declare class PackageAndStaticVariablesInitializationValidator {
-    private readonly _analyzer;
-    private readonly _package;
-    private readonly _declarationsUsageMapList;
-    private readonly _diagnostics;
-    constructor(_analyzer: Analyzer, _package: SourcePackage, _declarationsUsageMapList: readonly DeclarationsUsageMap[], _diagnostics: DiagnosticAcceptor);
+    private readonly analyzer;
+    private readonly package_;
+    private readonly declarationsUsageMapList;
+    private readonly diagnostics;
+    constructor(analyzer: Analyzer, package_: SourcePackage, declarationsUsageMapList: readonly DeclarationsUsageMap[], diagnostics: DiagnosticAcceptor);
     validate(): void;
     private getVariablesThatNeedToBeInitializedInConstructor;
     private collectStaticFieldsThatNeedToBeInitializedInConstructor;

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

@@ -1,8 +1,8 @@
 import { Name } from '../common/index.js';
 import { IEntityHidingMatcher, NamedPackageMemberEntity, PackageEntity, TypeEntity, TypeExtensionEntity } from '../entities/index.js';
 export declare class PackageMemberLookup {
-    private readonly _package;
-    constructor(_package: PackageEntity);
+    private readonly package_;
+    constructor(package_: PackageEntity);
     getNamedMembers(hidingMatcher?: IEntityHidingMatcher): readonly NamedPackageMemberEntity[];
     getNamedMembersByName(name: Name, hidingMatcher?: IEntityHidingMatcher): readonly NamedPackageMemberEntity[];
     getTypeExtensions(type: TypeEntity, hidingMatcher?: IEntityHidingMatcher): readonly TypeExtensionEntity[];

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

@@ -3,10 +3,10 @@ import { PackageEntityMembers } 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: PackageEntityMembers);
+    private readonly analyzer;
+    private readonly members;
+    private readonly diagnostics;
+    constructor(analyzer: Analyzer, members: PackageEntityMembers);
     validate(): readonly Diagnostic[];
     private validateFunctionNameConflicts;
     private validateTypeNameConflicts;
@@ -16,8 +16,8 @@ export declare class PackageMemberNameConflictsValidator {
     private getDiagnosticLocation;
 }
 export declare class SourcePackageMemberConflictsValidator {
-    private readonly _analyzer;
-    private readonly _package;
-    constructor(_analyzer: Analyzer, _package: ProgramPackage);
+    private readonly analyzer;
+    private readonly package_;
+    constructor(analyzer: Analyzer, package_: ProgramPackage);
     validate(): readonly Diagnostic[];
 }

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

@@ -3,10 +3,10 @@ import * as tree from '../tree/index.js';
 import { LocalVariableEntity } from '../entities/VariableEntity.js';
 import * as types from '../types/index.js';
 export declare class ReturnTypeInferrer {
-    private readonly _analyzer;
-    private readonly _block;
-    private readonly _resultVariable;
-    constructor(_analyzer: Analyzer, _block: tree.FunctionBlock, _resultVariable: LocalVariableEntity);
+    private readonly analyzer;
+    private readonly block;
+    private readonly resultVariable;
+    constructor(analyzer: Analyzer, block: tree.FunctionBlock, resultVariable: LocalVariableEntity);
     infer(): types.Type;
     private checkResultVariableIsUsedAndCollectReturnedTypes;
     private getTypeOfResultVariableAtTheEndOfSubprogram;

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

@@ -3,12 +3,12 @@ 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 static readonly _emptyNamedMembers;
-    private static readonly _emptyPackageAliases;
-    private readonly _analyzer;
-    private readonly _namedMembers;
-    private readonly _typeExtensions;
-    private readonly _declarationsByName;
+    private static readonly emptyNamedMembers;
+    private static readonly emptyPackageAliases;
+    private readonly analyzer;
+    private readonly namedMembers;
+    private readonly typeExtensions;
+    private readonly declarationsByName_;
     get declarationsByName(): ReadonlyMap<string, readonly NamedSourceFileMemberEntity[]>;
     constructor(analyzer: Analyzer, namedMembers: readonly NamedSourceFileMemberEntity[], typeExtensions: readonly TypeExtensionEntity[]);
     getNamedDeclarations(): readonly NamedSourceFileMemberEntity[];