@artel/artc 0.6.26018 → 0.6.26019

package/build/types/analysis/{TextIdentity.d.ts → a/TextIdentity.d.ts}

@@ -1,5 +1,5 @@
-import * as tree from '../tree/index.js';
-export type TextKey = string | number;
+import { TextKey } from '../../entities/index.js';
+import * as tree from '../../tree/a/index.js';
 export declare class TextIdentity {
     static keyFromTextFragments(fragments: readonly string[]): TextKey;
     static keyFromTextToken(token: tree.Token<tree.TokenKind.TextLiteral>): TextKey;

package/build/types/analysis/{TranslatedEntityNameConflictsValidator.d.ts → a/TranslatedEntityNameConflictsValidator.d.ts}

@@ -1,6 +1,6 @@
-import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
-import { PackageEntity } from '../entities/index.js';
-import { SourceFile } from '../project/SourceFile.js';
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import { PackageEntity } from '../../entities/index.js';
+import { SourceFile } from '../../project/SourceFile.js';
 import { Analyzer } from './Analyzer.js';
 /**
  * Переведённые имена проверяются по следующим правилам:

package/build/types/analysis/{TreeQuery.d.ts → a/TreeQuery.d.ts}

@@ -1,11 +1,10 @@
-import { Analyzer } from '../analysis/index.js';
-import { TypeWithMembersDeclaration } from '../analysis/NodeTypeUtils.js';
-import { PackageEntity, TypeEntity } from '../entities/index.js';
-import { SourceFile, SourcePackage } from '../project/index.js';
-import * as tree from '../tree/index.js';
+import { PackageEntity, TypeEntity } from '../../entities/index.js';
+import { SourceFileA, SourcePackageA } from '../../project/index.js';
+import * as tree from '../../tree/a/index.js';
+import { Analyzer } from './Analyzer.js';
 export declare class TreeQuery {
-    static getSourceFile(node: tree.Node, analyzer: Analyzer): SourceFile;
-    static getSourcePackage(node: tree.Node, analyzer: Analyzer): SourcePackage;
+    static getSourceFile(node: tree.Node, analyzer: Analyzer): SourceFileA;
+    static getSourcePackage(node: tree.Node, analyzer: Analyzer): SourcePackageA;
     static getPackageEntity(node: tree.Node, analyzer: Analyzer): PackageEntity;
 }
 export declare class TypeMemberQuery {
@@ -13,4 +12,4 @@ export declare class TypeMemberQuery {
     static getOutermostMemberBlock(node: tree.TypeMemberDeclaration): tree.TypeMemberDeclarationBlock;
     static getContextualTypeEntity(node: tree.TypeMemberDeclaration, analyzer: Analyzer): TypeEntity | undefined;
 }
-export type TypeWithMembersOrTypeExtensionDeclaration = TypeWithMembersDeclaration | tree.TypeExtensionDeclaration;
+export type TypeWithMembersOrTypeExtensionDeclaration = tree.TypeWithMembersDeclaration | tree.TypeExtensionDeclaration;

package/build/types/analysis/{TypeArgumentInferrer.d.ts → a/TypeArgumentInferrer.d.ts}

@@ -1,7 +1,8 @@
-import { TypeParameterEntity } from '../entities/index.js';
-import * as tree from '../tree/index.js';
-import * as types from '../types/index.js';
-import { Analyzer, ExpressionAnalysisOptions } from './Analyzer.js';
+import { TypeParameterEntity } from '../../entities/index.js';
+import * as tree from '../../tree/a/index.js';
+import * as types from '../../types/index.js';
+import { Analyzer } from './Analyzer.js';
+import { ExpressionAnalysisOptions } from './ExpressionAnalysisOptions.js';
 export type Argument = SourceArgument | IntrinsicArgument;
 export interface SourceArgument {
     readonly kind: 'source';

package/build/types/analysis/{TypeInferrer.d.ts → a/TypeInferrer.d.ts}

@@ -1,5 +1,5 @@
-import * as types from '../types/index.js';
-import { Analyzer } from './index.js';
+import * as types from '../../types/index.js';
+import { Analyzer } from './Analyzer.js';
 export declare class TypeInferrer {
     private readonly analyzer;
     private getType;

package/build/types/analysis/{TypeNarrower.d.ts → a/TypeNarrower.d.ts}

@@ -1,5 +1,5 @@
-import { PackageLocale } from '../common/index.js';
-import * as types from '../types/index.js';
+import { PackageLocale } from '../../common/index.js';
+import * as types from '../../types/index.js';
 import { Analyzer } from './Analyzer.js';
 import * as controlFlow from './control-flow/index.js';
 import { NarrowableReference } from './control-flow/index.js';

package/build/types/analysis/{TypeOverloadResolver.d.ts → a/TypeOverloadResolver.d.ts}

@@ -1,4 +1,4 @@
-import { NamedTypeEntity } from '../entities/index.js';
+import { NamedTypeEntity } from '../../entities/index.js';
 export declare class Resolver {
     static resolve<TCandidate extends ICandidate>(candidates: readonly TCandidate[], argumentCount: number): readonly TCandidate[];
     static resolveByNamedTypeEntities<T extends NamedTypeEntity>(candidates: readonly T[], argumentCount: number): readonly T[];

package/build/types/analysis/{UserDefinableBinaryOperatorResolver.d.ts → a/UserDefinableBinaryOperatorResolver.d.ts}

@@ -1,9 +1,9 @@
-import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
-import { BinaryOperatorKind } from '../entities/OperatorKind.js';
-import * as tree from '../tree/index.js';
-import * as types from '../types/index.js';
-import { Analyzer } from './index.js';
-import { NodeOrDiagnosticLocation } from './Utils.js';
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import { BinaryOperatorKind } from '../../entities/OperatorKind.js';
+import * as tree from '../../tree/a/index.js';
+import * as types from '../../types/index.js';
+import { NodeOrDiagnosticLocation } from '../NodeOrDiagnosticLocation.js';
+import { Analyzer } from './Analyzer.js';
 /**
  * Определяет подходящую двухместную операцию, определённую пользователем (+, *, == и др.).
  *

package/build/types/analysis/{UserDefinableUnaryOperatorResolver.d.ts → a/UserDefinableUnaryOperatorResolver.d.ts}

@@ -1,7 +1,7 @@
-import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
-import * as tree from '../tree/index.js';
-import * as types from '../types/index.js';
-import { Analyzer } from './index.js';
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import * as tree from '../../tree/a/index.js';
+import * as types from '../../types/index.js';
+import { Analyzer } from './Analyzer.js';
 /**
  * Определяет подходящую одноместную операцию, определённую пользователем (+, -, не).
  *

package/build/types/analysis/{control-flow → a/control-flow}/GraphBuilder.d.ts

@@ -1,7 +1,6 @@
-import { Diagnostic } from '../../diagnostic/Diagnostic.js';
-import { SourceFile } from '../../project/SourceFile.js';
-import * as tree from '../../tree/index.js';
-import { SubprogramDeclarationOrLiteral } from '../NodeTypeUtils.js';
+import { Diagnostic } from '../../../diagnostic/Diagnostic.js';
+import { SourceFileA } from '../../../project/SourceFile.js';
+import * as tree from '../../../tree/a/index.js';
 import { NarrowableReferenceExpression } from './NarrowableExpression.js';
 import { Node } from './Nodes.js';
 export declare class GraphBuilder {
@@ -17,7 +16,7 @@ export declare class GraphBuilder {
     private currentErrorTarget;
     private currentReturnTarget;
     private currentRangeWithReportedUnreachableCodeDiagnostic;
-    constructor(sourceFile: SourceFile);
+    constructor(sourceFile: SourceFileA);
     build(): GraphBuildResult;
     private visitNode;
     private visitAssignmentStatement;
@@ -44,7 +43,7 @@ export declare class GraphBuilder {
 export declare class GraphBuildResult {
     readonly controlFlowNodeByReference: ReadonlyMap<NarrowableReferenceExpression, Node>;
     readonly controlFlowNodesPrecedingErrorStatement: ReadonlyMap<tree.ErrorStatement, Node>;
-    readonly controlFlowNodesEndingSubprogram: ReadonlyMap<SubprogramDeclarationOrLiteral, Node>;
+    readonly controlFlowNodesEndingSubprogram: ReadonlyMap<tree.SubprogramDeclarationOrLiteral, Node>;
     readonly unreachableCodeDiagnostics: readonly Diagnostic[];
-    constructor(controlFlowNodeByReference: ReadonlyMap<NarrowableReferenceExpression, Node>, controlFlowNodesPrecedingErrorStatement: ReadonlyMap<tree.ErrorStatement, Node>, controlFlowNodesEndingSubprogram: ReadonlyMap<SubprogramDeclarationOrLiteral, Node>, unreachableCodeDiagnostics: readonly Diagnostic[]);
+    constructor(controlFlowNodeByReference: ReadonlyMap<NarrowableReferenceExpression, Node>, controlFlowNodesPrecedingErrorStatement: ReadonlyMap<tree.ErrorStatement, Node>, controlFlowNodesEndingSubprogram: ReadonlyMap<tree.SubprogramDeclarationOrLiteral, Node>, unreachableCodeDiagnostics: readonly Diagnostic[]);
 }

package/build/types/analysis/{control-flow → a/control-flow}/NarrowableExpression.d.ts

@@ -1,4 +1,4 @@
-import * as tree from '../../tree/index.js';
+import * as tree from '../../../tree/a/index.js';
 export declare function isNarrowableExpression(node: tree.Node): node is tree.Expression;
 export type NarrowableReferenceExpression = tree.IdentifierExpression | tree.MemberAccessExpression | tree.ObjectExpression;
 export declare function isNarrowableReferenceExpression(node: tree.Node): node is NarrowableReferenceExpression;

package/build/types/analysis/{control-flow → a/control-flow}/NarrowableReference.d.ts

@@ -1,7 +1,7 @@
-import { FieldEntity, LocalVariableEntity, PackageVariableEntity, ParameterEntity } from '../../entities/index.js';
-import * as tree from '../../tree/index.js';
+import { FieldEntity, LocalVariableEntity, PackageVariableEntity, ParameterEntity } from '../../../entities/index.js';
+import * as tree from '../../../tree/a/index.js';
 import { Analyzer } from '../Analyzer.js';
-import { NarrowableReferenceExpression } from '../control-flow/NarrowableExpression.js';
+import { NarrowableReferenceExpression } from './NarrowableExpression.js';
 export type NarrowableReference = NarrowableReference.LocalVariable | NarrowableReference.PackageVariable | NarrowableReference.InstanceField | NarrowableReference.StaticField | NarrowableReference.ObjectAutoVariable;
 export declare namespace NarrowableReference {
     export class LocalVariable implements INarrowableReference {

package/build/types/analysis/{control-flow → a/control-flow}/Nodes.d.ts

@@ -1,4 +1,4 @@
-import * as tree from '../../tree/index.js';
+import * as tree from '../../../tree/a/index.js';
 export type Node = StartNode | ConditionNode | AssignmentNode | LocalVariableDeclarationNode | SplitNode | LoopNode | UnreachableNode;
 declare abstract class ControlFlowNodeBase {
     protected abstract thisAsNode: Node;

package/build/types/analysis/{semantic-context → a/semantic-context}/Declarations.d.ts

@@ -1,7 +1,7 @@
-import { Name } from '../../common/index.js';
-import { EntityHidingLevel, MethodEntity, NamedFunctionEntity, NamedTypeEntity, PackageAliasEntity, PackageOrNestedFunctionEntity, VariableEntity } from '../../entities/index.js';
-import * as types from '../../types/index.js';
-import { PackageNameTreeNode } from '../ImportedPackageNameTree.js';
+import { Name } from '../../../common/index.js';
+import { EntityHidingLevel, MethodEntity, NamedFunctionEntity, NamedTypeEntity, PackageAliasEntity, PackageOrNestedFunctionEntity, VariableEntity } from '../../../entities/index.js';
+import * as types from '../../../types/index.js';
+import { PackageNameTreeNode } from '../../ImportedPackageNameTree.js';
 export type TypeOrContainerWithTypes = NamedDeclaration_type | NamedDeclaration_packageAlias | NamedDeclaration_packageNameSegment;
 export type NamedDeclaration = NamedDeclaration_function | NamedDeclaration_variable | NamedDeclaration_type | NamedDeclaration_packageAlias | NamedDeclaration_packageNameSegment;
 export declare class NamedDeclaration_function implements INamedDeclaration {

package/build/types/analysis/{semantic-context → a/semantic-context}/FieldWithInitializerSemanticContext.d.ts

@@ -1,7 +1,7 @@
-import { Name } from '../../common/index.js';
-import * as tree from '../../tree/index.js';
+import { Name } from '../../../common/index.js';
+import * as tree from '../../../tree/a/index.js';
+import { TypeMemberLookupContext } from '../../TypeMemberLookup.js';
 import { Analyzer } from '../Analyzer.js';
-import { TypeMemberLookupContext } from '../TypeMemberLookup.js';
 import { NamedDeclaration, TypeOrContainerWithTypes } from './Declarations.js';
 import { SemanticContext } from './SemanticContext.js';
 import { NamedDeclarationLookupResult, SemanticContextLookupState } from './SemanticContextBase.js';

package/build/types/analysis/{semantic-context → a/semantic-context}/SemanticContextBase.d.ts

@@ -1,14 +1,12 @@
-import { Name } from '../../common/index.js';
-import { ConstructorEntity, PackageEntity, ParameterEntity, TextTranslationEntity, TypeEntity, TypeEntityWithMembers, TypeExtensionEntity } from '../../entities/index.js';
-import { SourceFile } from '../../project/SourceFile.js';
-import * as tree from '../../tree/index.js';
-import * as types from '../../types/index.js';
+import { Name } from '../../../common/index.js';
+import { AnonymousFunctionEntity, ConstructorEntity, DestructorEntity, FunctionEntity, FunctionTypeEntity, GetterEntity, PackageEntity, ParameterEntity, SetterEntity, TextKey, TextTranslationEntity, TypeEntity, TypeEntityWithMembers, TypeExtensionEntity } from '../../../entities/index.js';
+import { SourceFileA } from '../../../project/SourceFile.js';
+import * as tree from '../../../tree/a/index.js';
+import * as types from '../../../types/index.js';
+import { DiagnosticArgumentFactory } from '../../DiagnosticArgumentFactory.js';
+import { PackageMemberLookupContext } from '../../PackageMemberLookup.js';
+import { TypeMemberLookupContext } from '../../TypeMemberLookup.js';
 import { Analyzer } from '../Analyzer.js';
-import { DiagnosticArgumentFactory } from '../DiagnosticArgumentFactory.js';
-import { FunctionDeclaration, GetterDeclaration, RegularOrBlockFunctionLiteral, SetterDeclaration, SubprogramDeclarationOrLiteral } from '../NodeTypeUtils.js';
-import { PackageMemberLookupContext } from '../PackageMemberLookup.js';
-import { TextKey } from '../TextIdentity.js';
-import { TypeMemberLookupContext } from '../TypeMemberLookup.js';
 import { NamedDeclaration, TypeOrContainerWithTypes } from './Declarations.js';
 import { SemanticContext } from './SemanticContext.js';
 export declare abstract class SemanticContextBase {
@@ -27,7 +25,7 @@ export declare abstract class SemanticContextBase {
     abstract getOwnTypesOrContainersWithTypesByName(name: Name, initialContext: SemanticContext): readonly TypeOrContainerWithTypes[];
     abstract getOwnNamedDeclarations(initialContext: SemanticContext, noInstanceMembers: boolean, lookupState: SemanticContextLookupState): readonly NamedDeclaration[];
     abstract getOwnNamedDeclarationsByName(name: Name, initialContext: SemanticContext, noInstanceMembers: boolean, lookupResult: NamedDeclarationLookupResult): void;
-    getContainingSourceFile(): SourceFile;
+    getContainingSourceFile(): SourceFileA;
     getContainingPackage(): PackageEntity;
     getDiagnosticArgumentFactory(): DiagnosticArgumentFactory;
     getPackageMemberLookupContext(): PackageMemberLookupContext;
@@ -46,12 +44,12 @@ export declare namespace SubprogramInfo {
         readonly kind = "function";
         private readonly analyzer;
         private readonly node;
-        constructor(analyzer: Analyzer, node: FunctionDeclaration);
+        constructor(analyzer: Analyzer, node: tree.FunctionDeclaration);
         getReturnType(): types.Type | undefined;
         isGenerator(): boolean;
         allowsAsyncCalls(): boolean;
-        getNode(): FunctionDeclaration;
-        private getEntity;
+        getNode(): tree.FunctionDeclaration;
+        getEntity(): FunctionEntity;
     }
     export class Constructor implements ISubprogramInfo {
         readonly kind = "constructor";
@@ -73,26 +71,29 @@ export declare namespace SubprogramInfo {
         isGenerator(): boolean;
         allowsAsyncCalls(): boolean;
         getNode(): tree.DestructorDeclaration;
+        getEntity(): DestructorEntity | undefined;
     }
     export class Getter implements ISubprogramInfo {
         readonly kind = "getter";
         private readonly analyzer;
         private readonly node;
-        constructor(analyzer: Analyzer, node: GetterDeclaration);
+        constructor(analyzer: Analyzer, node: tree.GetterDeclaration);
         getReturnType(): types.Type | undefined;
         isGenerator(): boolean;
         allowsAsyncCalls(): boolean;
-        getNode(): GetterDeclaration;
+        getNode(): tree.GetterDeclaration;
+        getEntity(): GetterEntity | undefined;
     }
     export class Setter implements ISubprogramInfo {
         readonly kind = "setter";
         private readonly analyzer;
         private readonly node;
-        constructor(analyzer: Analyzer, node: SetterDeclaration);
+        constructor(analyzer: Analyzer, node: tree.SetterDeclaration);
         getReturnType(): types.Type | undefined;
         isGenerator(): boolean;
         allowsAsyncCalls(): boolean;
-        getNode(): SetterDeclaration;
+        getNode(): tree.SetterDeclaration;
+        getEntity(): SetterEntity | undefined;
     }
     export class PackageConstructor implements ISubprogramInfo {
         readonly kind = "package-constructor";
@@ -104,6 +105,7 @@ export declare namespace SubprogramInfo {
         allowsAsyncCalls(): boolean;
         getPackageEntity(): PackageEntity;
         getNode(): tree.PackageConstructorDeclaration;
+        getEntity(): SubprogramInfoEntity | undefined;
     }
     export class PackageEntryPoint implements ISubprogramInfo {
         readonly kind = "package-entry-point";
@@ -115,17 +117,18 @@ export declare namespace SubprogramInfo {
         allowsAsyncCalls(): boolean;
         getPackageEntity(): PackageEntity;
         getNode(): tree.PackageEntryPointDeclaration;
+        getEntity(): SubprogramInfoEntity | undefined;
     }
     export class FunctionLiteral implements ISubprogramInfo {
         readonly kind = "function-literal";
         private readonly analyzer;
         private readonly node;
-        constructor(analyzer: Analyzer, node: RegularOrBlockFunctionLiteral);
+        constructor(analyzer: Analyzer, node: tree.RegularOrBlockFunctionLiteral);
         getReturnType(): types.Type | undefined;
         isGenerator(): boolean;
         allowsAsyncCalls(): boolean;
-        getNode(): RegularOrBlockFunctionLiteral;
-        private getEntity;
+        getNode(): tree.RegularOrBlockFunctionLiteral;
+        getEntity(): AnonymousFunctionEntity;
     }
     export class TextTranslationFunction implements ISubprogramInfo {
         readonly kind = "text-translation-function";
@@ -136,15 +139,18 @@ export declare namespace SubprogramInfo {
         isGenerator(): boolean;
         allowsAsyncCalls(): boolean;
         getNode(): tree.TextTranslationFunctionDeclaration;
+        getEntity(): TextTranslationEntity | undefined;
     }
     interface ISubprogramInfo {
         getReturnType(): types.Type | undefined;
         isGenerator(): boolean;
         allowsAsyncCalls(): boolean;
-        getNode(): SubprogramDeclarationOrLiteral;
+        getNode(): tree.SubprogramDeclarationOrLiteral;
+        getEntity(): SubprogramInfoEntity | undefined;
     }
     export {};
 }
+export type SubprogramInfoEntity = GetterEntity | SetterEntity | FunctionEntity | ConstructorEntity | DestructorEntity | FunctionTypeEntity | TextTranslationEntity;
 export type TypeOrTypeExtension = TypeOrTypeExtension.Type | TypeOrTypeExtension.TypeExtension;
 export declare namespace TypeOrTypeExtension {
     export class Type implements ITypeOrTypeExtension {

package/build/types/analysis/{semantic-context → a/semantic-context}/SemanticContextBuilder.d.ts

@@ -1,7 +1,10 @@
-import * as tree from '../../tree/index.js';
+import * as tree from '../../../tree/a/index.js';
 import { Analyzer } from '../Analyzer.js';
-import { FunctionDeclaration, FunctionTypeDeclaration, IndexedElementAccessorDeclaration, PackageTypeDeclaration, RegularOrBlockFunctionLiteral, SubprogramDeclarationOrLiteral } from '../NodeTypeUtils.js';
-import { CatchClauseSemanticContext, ConstructorSemanticContext, DestructorSemanticContext, ForStatementSemanticContext, FunctionLiteralSemanticContext, FunctionSemanticContext, IndexedElementAccessorSemanticContext, OutermostSemanticContextOfSubprogram, OutermostSemanticContextOfType, PackageConstructorSemanticContext, PackageEntryPointSemanticContext, ParametersOfFunctionTypeSemanticContext, SemanticContext, SemanticContextContainingTypeMember, SourceFileSemanticContext, SpecialLocalDeclarationSemanticContext, StatementBlockSemanticContext, SubprogramParameterListSemanticContext, SubprogramTypeParameterSemanticContext, TextTranslationFunctionDeclarationSemanticContext, TypeBodySemanticContext, TypeDeclarationCreatingSemanticContext, TypeDeclarationWithMemberBlock, TypeExtensionBodySemanticContext, TypeParametersOfTypeSemanticContext, VariableAccessorDeclaration, VariableAccessorSemanticContext } from '../semantic-context/index.js';
+import { SemanticContext } from './SemanticContext.js';
+import { SourceFileSemanticContext } from './SourceFileSemanticContext.js';
+import { CatchClauseSemanticContext, ForStatementSemanticContext, SpecialLocalDeclarationSemanticContext, StatementBlockSemanticContext, SubprogramParameterListSemanticContext, SubprogramTypeParameterSemanticContext } from './SubprogramBodyAndParametersSemanticContext.js';
+import { ConstructorSemanticContext, DestructorSemanticContext, FunctionLiteralSemanticContext, FunctionSemanticContext, IndexedElementAccessorSemanticContext, OutermostSemanticContextOfSubprogram, PackageConstructorSemanticContext, PackageEntryPointSemanticContext, TextTranslationFunctionDeclarationSemanticContext, VariableAccessorDeclaration, VariableAccessorSemanticContext } from './SubprogramSemanticContext.js';
+import { OutermostSemanticContextOfType, ParametersOfFunctionTypeSemanticContext, SemanticContextContainingTypeMember, TypeBodySemanticContext, TypeDeclarationCreatingSemanticContext, TypeDeclarationWithMemberBlock, TypeExtensionBodySemanticContext, TypeParametersOfTypeSemanticContext } from './TypeSemanticContext.js';
 export declare class SemanticContextBuilder {
     private readonly analyzer;
     private readonly sourceFileContexts;
@@ -35,21 +38,21 @@ export declare class SemanticContextBuilder {
     containing(node: tree.Node): SemanticContext;
     containingWithOffset(node: tree.Node, offset: number): SemanticContext;
     ofSourceFile(node: tree.SourceFile): SourceFileSemanticContext;
-    ofFunctionDeclarationParameters(node: FunctionDeclaration): SubprogramParameterListSemanticContext;
-    ofFunctionDeclarationTypeParameters(node: FunctionDeclaration, typeParameterClause: tree.TypeParameterClause): SubprogramTypeParameterSemanticContext;
-    outermostSemanticContextOfFunctionDeclaration(node: FunctionDeclaration): FunctionSemanticContext;
+    ofFunctionDeclarationParameters(node: tree.FunctionDeclaration): SubprogramParameterListSemanticContext;
+    ofFunctionDeclarationTypeParameters(node: tree.FunctionDeclaration, typeParameterClause: tree.TypeParameterClause): SubprogramTypeParameterSemanticContext;
+    outermostSemanticContextOfFunctionDeclaration(node: tree.FunctionDeclaration): FunctionSemanticContext;
     ofTypeDeclarationMemberBlock(typeDeclaration: TypeDeclarationWithMemberBlock, memberBlock: tree.TypeMemberDeclarationBlock): TypeBodySemanticContext;
-    ofFunctionTypeDeclarationParameters(node: FunctionTypeDeclaration): ParametersOfFunctionTypeSemanticContext;
+    ofFunctionTypeDeclarationParameters(node: tree.FunctionTypeDeclaration): ParametersOfFunctionTypeSemanticContext;
     outermostSemanticContextOfTypeDeclaration(node: TypeDeclarationCreatingSemanticContext): OutermostSemanticContextOfType;
-    ofTypeDeclarationTypeParameters(node: PackageTypeDeclaration, typeParameterClause: tree.TypeParameterClause): TypeParametersOfTypeSemanticContext;
+    ofTypeDeclarationTypeParameters(node: tree.PackageTypeDeclaration, typeParameterClause: tree.TypeParameterClause): TypeParametersOfTypeSemanticContext;
     ofTypeExtensionDeclarationBody(node: tree.TypeExtensionDeclaration): TypeExtensionBodySemanticContext;
     ofVariableAccessorDeclaration(node: VariableAccessorDeclaration): VariableAccessorSemanticContext;
     ofPackageConstructorDeclaration(node: tree.PackageConstructorDeclaration): PackageConstructorSemanticContext;
     ofPackageEntryPointDeclaration(node: tree.PackageEntryPointDeclaration): PackageEntryPointSemanticContext;
-    ofRegularOrBlockFunctionLiteralParameters(node: RegularOrBlockFunctionLiteral): SubprogramParameterListSemanticContext;
+    ofRegularOrBlockFunctionLiteralParameters(node: tree.RegularOrBlockFunctionLiteral): SubprogramParameterListSemanticContext;
     ofTextTranslationDeclarationParameters(node: tree.TranslationTextTemplate): SubprogramParameterListSemanticContext;
     outermostSemanticContextOfTextTranslationFunctionDeclaration(node: tree.TextTranslationFunctionDeclaration): TextTranslationFunctionDeclarationSemanticContext;
-    outermostSemanticContextOfRegularOrBlockFunctionLiteral(node: RegularOrBlockFunctionLiteral): FunctionLiteralSemanticContext;
+    outermostSemanticContextOfRegularOrBlockFunctionLiteral(node: tree.RegularOrBlockFunctionLiteral): FunctionLiteralSemanticContext;
     ofForStatement(node: tree.ForStatement): ForStatementSemanticContext;
     ofStatementBlock(node: tree.StatementBlock): StatementBlockSemanticContext;
     ofFunctionBlock(node: tree.FunctionBlock): StatementBlockSemanticContext;
@@ -59,11 +62,11 @@ export declare class SemanticContextBuilder {
     outermostSemanticContextOfConstructorDeclaration(node: tree.ConstructorDeclaration): ConstructorSemanticContext;
     ofDestructorDeclarationParameters(node: tree.DestructorDeclaration): SubprogramParameterListSemanticContext;
     outermostSemanticContextOfDestructorDeclaration(node: tree.DestructorDeclaration): DestructorSemanticContext;
-    ofIndexedElementAccessorDeclarationParameters(node: IndexedElementAccessorDeclaration): SubprogramParameterListSemanticContext;
-    outermostSemanticContextOfIndexedElementAccessorDeclaration(node: IndexedElementAccessorDeclaration): IndexedElementAccessorSemanticContext;
+    ofIndexedElementAccessorDeclarationParameters(node: tree.IndexedElementAccessorDeclaration): SubprogramParameterListSemanticContext;
+    outermostSemanticContextOfIndexedElementAccessorDeclaration(node: tree.IndexedElementAccessorDeclaration): IndexedElementAccessorSemanticContext;
     ofCatchClause(node: tree.CatchClause): CatchClauseSemanticContext;
     ofFieldDeclarationWithInitializer(node: tree.FieldDeclaration): SemanticContext;
-    ofSubprogram(node: SubprogramDeclarationOrLiteral): OutermostSemanticContextOfSubprogram;
+    ofSubprogram(node: tree.SubprogramDeclarationOrLiteral): OutermostSemanticContextOfSubprogram;
     containingTypeMember(node: tree.TypeMemberDeclaration): SemanticContextContainingTypeMember;
     containingPackageMember(node: tree.PackageMemberDeclaration): SourceFileSemanticContext;
     private containingInternal;

package/build/types/analysis/{semantic-context → a/semantic-context}/SemanticContextValidatingNameConflicts.d.ts

@@ -1,7 +1,7 @@
-import { Name } from '../../common/index.js';
-import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
-import { LocalVariableEntity, NestedFunctionEntity, ParameterEntity, TypeParameterEntity } from '../../entities/index.js';
-import * as tree from '../../tree/index.js';
+import { Name } from '../../../common/index.js';
+import { DiagnosticAcceptor } from '../../../diagnostic/Diagnostic.js';
+import { LocalVariableEntity, NestedFunctionEntity, ParameterEntity, TypeParameterEntity } from '../../../entities/index.js';
+import * as tree from '../../../tree/a/index.js';
 import { Analyzer } from '../Analyzer.js';
 import { NamedDeclaration, TypeOrContainerWithTypes } from './Declarations.js';
 import { SemanticContext } from './SemanticContext.js';

package/build/types/analysis/{semantic-context → a/semantic-context}/SemanticContextWithParent.d.ts

@@ -1,4 +1,4 @@
-import { TypeMemberLookupContext } from '../TypeMemberLookup.js';
+import { TypeMemberLookupContext } from '../../TypeMemberLookup.js';
 import { SemanticContext } from './SemanticContext.js';
 import { ObjectVariableInfo, SemanticContextBase, SubprogramInfo, TryStatementContextKind, TypeOrTypeExtension } from './SemanticContextBase.js';
 export declare abstract class SemanticContextWithParent extends SemanticContextBase {

package/build/types/analysis/{semantic-context → a/semantic-context}/SourceFileSemanticContext.d.ts

@@ -1,13 +1,12 @@
-import { Name } from '../../common/index.js';
-import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
-import { PackageEntity, TextTranslationEntity, TypeEntity, TypeExtensionEntity } from '../../entities/index.js';
-import { SourceFile } from '../../project/SourceFile.js';
-import * as tree from '../../tree/index.js';
+import { Name } from '../../../common/index.js';
+import { DiagnosticAcceptor } from '../../../diagnostic/Diagnostic.js';
+import { PackageEntity, TextKey, TextTranslationEntity, TypeEntity, TypeExtensionEntity } from '../../../entities/index.js';
+import { SourceFileA } from '../../../project/SourceFile.js';
+import * as tree from '../../../tree/a/index.js';
+import { DiagnosticArgumentFactory } from '../../DiagnosticArgumentFactory.js';
+import { PackageMemberLookupContext } from '../../PackageMemberLookup.js';
+import { TypeMemberLookupContext } from '../../TypeMemberLookup.js';
 import { Analyzer } from '../Analyzer.js';
-import { DiagnosticArgumentFactory } from '../DiagnosticArgumentFactory.js';
-import { PackageMemberLookupContext } from '../PackageMemberLookup.js';
-import { TextKey } from '../TextIdentity.js';
-import { TypeMemberLookupContext } from '../TypeMemberLookup.js';
 import { NamedDeclaration, TypeOrContainerWithTypes } from './Declarations.js';
 import { SemanticContext } from './SemanticContext.js';
 import { NamedDeclarationLookupResult, ObjectVariableInfo, SemanticContextBase, SemanticContextLookupState, SubprogramInfo, TryStatementContextKind, TypeOrTypeExtension } from './SemanticContextBase.js';
@@ -34,7 +33,7 @@ export declare class SourceFileSemanticContext extends SemanticContextBase {
     getContainingSubprogram(): SubprogramInfo | undefined;
     getContainingTypeOrTypeExtension(): TypeOrTypeExtension | undefined;
     getObjectVariableInfo(): ObjectVariableInfo | undefined;
-    getSourceFile(): SourceFile;
+    getSourceFile(): SourceFileA;
     getPackage(): PackageEntity;
     getTryStatementContext(): TryStatementContextKind | undefined;
     isStatic(): boolean;

package/build/types/analysis/{semantic-context → a/semantic-context}/SpecialLocalDeclarationsBuilder.d.ts

@@ -1,5 +1,5 @@
-import { LocalVariableEntity } from '../../entities/index.js';
-import * as tree from '../../tree/index.js';
+import { LocalVariableEntity } from '../../../entities/index.js';
+import * as tree from '../../../tree/a/index.js';
 import { Analyzer } from '../Analyzer.js';
 type SpecialLocalDeclarationEntity = LocalVariableEntity;
 export declare class SpecialLocalDeclarationsBuilder {

package/build/types/analysis/{semantic-context → a/semantic-context}/SubprogramBodyAndParametersSemanticContext.d.ts

@@ -1,6 +1,6 @@
-import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
-import { ParameterEntity } from '../../entities/index.js';
-import * as tree from '../../tree/index.js';
+import { DiagnosticAcceptor } from '../../../diagnostic/Diagnostic.js';
+import { ParameterEntity } from '../../../entities/index.js';
+import * as tree from '../../../tree/a/index.js';
 import { Analyzer } from '../Analyzer.js';
 import { ReservedNameKind } from '../ReservedNameDictionary.js';
 import { SemanticContext } from './SemanticContext.js';

package/build/types/analysis/{semantic-context → a/semantic-context}/SubprogramSemanticContext.d.ts

@@ -1,8 +1,7 @@
-import { Name } from '../../common/index.js';
-import { ParameterEntity } from '../../entities/index.js';
-import * as tree from '../../tree/index.js';
+import { Name } from '../../../common/index.js';
+import { ParameterEntity } from '../../../entities/index.js';
+import * as tree from '../../../tree/a/index.js';
 import { Analyzer } from '../Analyzer.js';
-import { DereferencedVariableAccessorDeclaration, FieldAccessorDeclaration, FunctionDeclaration, IndexedElementAccessorDeclaration, PackageVariableAccessorDeclaration, RegularOrBlockFunctionLiteral } from '../NodeTypeUtils.js';
 import { NamedDeclaration, TypeOrContainerWithTypes } from './Declarations.js';
 import { SemanticContext } from './SemanticContext.js';
 import { NamedDeclarationLookupResult, ObjectVariableInfo, SemanticContextLookupState, SubprogramInfo, TryStatementContextKind } from './SemanticContextBase.js';
@@ -39,7 +38,7 @@ export declare class FunctionSemanticContext extends OutermostSemanticContextOfS
     protected readonly analyzer: Analyzer;
     private readonly node;
     private readonly subprogramInfo;
-    constructor(analyzer: Analyzer, node: FunctionDeclaration, outer: SemanticContext);
+    constructor(analyzer: Analyzer, node: tree.FunctionDeclaration, outer: SemanticContext);
     getContainingSubprogram(): SubprogramInfo;
     isStatic(): boolean;
     protected findObjectParameter(): ParameterEntity | undefined;
@@ -86,7 +85,7 @@ export declare class DestructorSemanticContext extends OutermostSemanticContextO
     protected findObjectParameter(): ParameterEntity | undefined;
 }
 export type AccessorSemanticContextParent = SemanticContextContainingTypeMember | SourceFileSemanticContext;
-export type VariableAccessorDeclaration = PackageVariableAccessorDeclaration | FieldAccessorDeclaration | DereferencedVariableAccessorDeclaration;
+export type VariableAccessorDeclaration = tree.PackageVariableAccessorDeclaration | tree.FieldAccessorDeclaration | tree.DereferencedVariableAccessorDeclaration;
 export declare class VariableAccessorSemanticContext extends OutermostSemanticContextOfSubprogram {
     readonly outer: AccessorSemanticContextParent;
     protected readonly asContext: SemanticContext;
@@ -104,7 +103,7 @@ export declare class IndexedElementAccessorSemanticContext extends OutermostSema
     protected readonly analyzer: Analyzer;
     private readonly node;
     private readonly subprogramInfo;
-    constructor(analyzer: Analyzer, node: IndexedElementAccessorDeclaration, outer: AccessorSemanticContextParent);
+    constructor(analyzer: Analyzer, node: tree.IndexedElementAccessorDeclaration, outer: AccessorSemanticContextParent);
     getContainingSubprogram(): SubprogramInfo;
     isStatic(): boolean;
     protected findObjectParameter(): ParameterEntity | undefined;
@@ -115,7 +114,7 @@ export declare class FunctionLiteralSemanticContext extends OutermostSemanticCon
     protected readonly analyzer: Analyzer;
     private readonly node;
     private readonly subprogramInfo;
-    constructor(analyzer: Analyzer, node: RegularOrBlockFunctionLiteral, outer: SemanticContext);
+    constructor(analyzer: Analyzer, node: tree.RegularOrBlockFunctionLiteral, outer: SemanticContext);
     getContainingSubprogram(): SubprogramInfo;
     protected findObjectParameter(): ParameterEntity | undefined;
 }

package/build/types/analysis/{semantic-context → a/semantic-context}/TypeSemanticContext.d.ts

@@ -1,15 +1,14 @@
-import { Name } from '../../common/index.js';
-import * as tree from '../../tree/index.js';
+import { Name } from '../../../common/index.js';
+import * as tree from '../../../tree/a/index.js';
+import { TypeMemberLookup, TypeMemberLookupContext } from '../../TypeMemberLookup.js';
 import { Analyzer } from '../Analyzer.js';
-import { FunctionTypeDeclaration, StructuredTypeDeclaration, TypeDeclaration, VariantTypeDeclaration } from '../NodeTypeUtils.js';
-import { TypeMemberLookup, TypeMemberLookupContext } from '../TypeMemberLookup.js';
 import { NamedDeclaration, TypeOrContainerWithTypes } from './Declarations.js';
 import { SemanticContext } from './SemanticContext.js';
 import { NamedDeclarationLookupResult, ObjectVariableInfo, SemanticContextLookupState, SubprogramInfo, TypeOrTypeExtension } from './SemanticContextBase.js';
 import { MemberOfSemanticContextValidatingNameConflicts, MemberOfSemanticContextValidatingNameConflictsForTypeLookup, SemanticContextValidatingNameConflictsBase } from './SemanticContextValidatingNameConflicts.js';
 import { SemanticContextWithParent } from './SemanticContextWithParent.js';
 import { SourceFileSemanticContext } from './SourceFileSemanticContext.js';
-export type TypeDeclarationCreatingSemanticContext = StructuredTypeDeclaration | VariantTypeDeclaration | FunctionTypeDeclaration | tree.PackageAliasTypeDeclaration | tree.PackageReducedTypeDeclaration;
+export type TypeDeclarationCreatingSemanticContext = tree.StructuredTypeDeclaration | tree.VariantTypeDeclaration | tree.FunctionTypeDeclaration | tree.PackageAliasTypeDeclaration | tree.PackageReducedTypeDeclaration;
 /**
  * Завершающий семантический контекст типа.
  * Поскольку контекст с параметрами типа является опциональным, необходим
@@ -34,7 +33,7 @@ export declare class OutermostSemanticContextOfType extends SemanticContextWithP
     getOwnNamedDeclarationsByName(_name: Name, _initialContext: SemanticContext, _noInstanceMembers: boolean, _lookupResult: SemanticContextLookupState): void;
     private getContainingType;
 }
-type TypeDeclarationWithTypeParameters = TypeDeclaration & tree.TypeParameterClauseParent;
+type TypeDeclarationWithTypeParameters = tree.TypeDeclaration & tree.TypeParameterClauseParent;
 export declare class TypeParametersOfTypeSemanticContext extends SemanticContextValidatingNameConflictsBase {
     readonly kind = "type-parameter-of-type";
     readonly outer: OutermostSemanticContextOfType;
@@ -55,7 +54,7 @@ declare abstract class TypeOrExtensionBodySemanticContext extends SemanticContex
 }
 export type SemanticContextContainingTypeMember = TypeBodySemanticContext | TypeExtensionBodySemanticContext;
 export type TypeBodySemanticContextParent = TypeParametersOfTypeSemanticContext | OutermostSemanticContextOfType;
-export type TypeDeclarationWithMemberBlock = StructuredTypeDeclaration | tree.PackageReducedTypeDeclaration | tree.PackageVariantDeclaration | tree.PackageAliasTypeDeclaration;
+export type TypeDeclarationWithMemberBlock = tree.StructuredTypeDeclaration | tree.PackageReducedTypeDeclaration | tree.PackageVariantDeclaration | tree.PackageAliasTypeDeclaration;
 export declare class TypeBodySemanticContext extends TypeOrExtensionBodySemanticContext {
     readonly kind = "type-body";
     readonly outer: TypeBodySemanticContextParent;
@@ -85,9 +84,9 @@ export type ParameterOfFunctionTypeSemanticContextParent = TypeParametersOfTypeS
 export declare class ParametersOfFunctionTypeSemanticContext extends SemanticContextValidatingNameConflictsBase {
     readonly kind = "parameters-of-function-type";
     readonly outer: ParameterOfFunctionTypeSemanticContextParent;
-    readonly node: FunctionTypeDeclaration;
+    readonly node: tree.FunctionTypeDeclaration;
     protected readonly asContext: SemanticContext;
-    constructor(analyzer: Analyzer, node: FunctionTypeDeclaration, outer: ParameterOfFunctionTypeSemanticContextParent);
+    constructor(analyzer: Analyzer, node: tree.FunctionTypeDeclaration, outer: ParameterOfFunctionTypeSemanticContextParent);
     protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
     protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
 }

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

@@ -0,0 +1,10 @@
+import { Analyzer as AnalyzerA } from '../a/Analyzer.js';
+import { Analyzer as BaseAnalyzer, CommonAnalyzerState } from '../Analyzer.js';
+/**
+ * Анализатор диалекта М.
+ */
+export declare class Analyzer extends BaseAnalyzer {
+    readonly dialectA: AnalyzerA;
+    get dialectM(): Analyzer;
+    constructor(state: CommonAnalyzerState, analyzerA: AnalyzerA);
+}