@artel/artc 0.6.25223 → 0.6.25225

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

@@ -27,48 +27,48 @@ export declare class DiagnosticCollector {
     private collectNotTranslatedTypeMembers;
     private createNotTranslatedEntitiesDiagnostic;
     private checkAllDefaultConstructorArgumentsAreNamed;
-    private checkPackageMethodDeclaration;
+    private checkPackageFunctionDeclaration;
     private checkPackageVariableGetterDeclaration;
     private checkPackageVariableSetterDeclaration;
-    private checkTypeConstructorDeclaration;
-    private checkTypeMethodDeclaration;
+    private checkConstructorDeclaration;
+    private checkMethodDeclaration;
     private checkOperatorDeclaration;
-    private checkTypeVariableDeclaration;
-    private checkTypeVariableGetterDeclaration;
-    private checkTypeVariableSetterDeclaration;
-    private checkTypeIndexedGetterDeclaration;
-    private checkTypeIndexedSetterDeclaration;
-    private checkTypeDereferencedVariableGetterDeclaration;
-    private checkTypeDereferencedVariableSetterDeclaration;
-    private checkNestedMethodDeclaration;
-    private checkPossibleGeneratorMethodReturnType;
+    private checkFieldDeclaration;
+    private checkFieldGetterDeclaration;
+    private checkFieldSetterDeclaration;
+    private checkIndexedElementGetterDeclaration;
+    private checkIndexedElementSetterDeclaration;
+    private checkDereferencedVariableGetterDeclaration;
+    private checkDereferencedVariableSetterDeclaration;
+    private checkNestedFunctionDeclaration;
+    private checkPossibleGeneratorFunctionReturnType;
     private checkReturnStatement;
     private checkYieldStatement;
     private checkTypeMemberBodyPresence;
     private tryGetTypeMemberDeclarationEntity;
     private isAspectTypeMemberDeclaration;
     private collectIdentifierExpressionDiagnostics;
-    private collectPropertyAccessExpressionDiagnostics;
+    private collectMemberAccessExpressionDiagnostics;
     private addDiagnosticsFromMatchResult;
     private checkStatementForVariablesUsedBeforeBeingAssigned;
     private checkExpressionTypeAssignableToTargetType;
     private addTypeAssignabilityDiagnosticIfBothTypesResolved;
     private checkAssignmentIsValid;
     private checkAssignmentToIdentifierExpression;
-    private checkAssignmentToPropertyAccessExpression;
+    private checkAssignmentToMemberAccessExpression;
     private checkAssignmentToVariable;
     private checkAssignmentToPackageVariable;
-    private checkAssignmentToTypeVariable;
+    private checkAssignmentToField;
     private checkAssignmentToObjectExpression;
     private checkAssignmentToDereferenceExpression;
     private checkAssignmentToIndexedAccessExpression;
     private checkOptionalChainingIsUsedOnTheLeftSideOfAssignment;
     private checkGenericSpecializationExpression;
-    private checkMethodSpecialization;
+    private checkFunctionSpecialization;
     private checkTypeSpecialization;
     private checkSpecializationOfDeclarationWithParameters;
     /**
-     * @returns `true` если была ошибка, иначе `false`.
+     * @returns `true` если не было ошибки, иначе `false`.
      */
     private checkTypeArgumentCount;
     private checkParameterDeclaration;

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

@@ -1,17 +1,17 @@
 import { LocalizedSubprogramSignature, LocalizedTypeHeader, TypeEntityWithHeaderLocalization } from '../analysis/AnalyzedTranslationPackage.js';
 import { Analyzer } from '../analysis/index.js';
 import { Localization } from '../analysis/Localization.js';
-import { ConstructorEntity, DestructorEntity, IndexerEntity, MethodEntity, MethodTypeEntity, OperatorEntity } from '../entities/index.js';
+import { ConstructorEntity, DestructorEntity, FunctionEntity, FunctionTypeEntity, IndexerEntity, OperatorEntity } from '../entities/index.js';
 import * as types from '../types/index.js';
 export declare class EntityLocalizationHelper {
-    static getLocalizedMethodSignature(method: MethodEntity, localization: Localization): LocalizedSubprogramSignature;
+    static getLocalizedFunctionSignature(func: FunctionEntity, localization: Localization): LocalizedSubprogramSignature;
     static getLocalizedOperatorSignature(operator: OperatorEntity, localization: Localization): LocalizedSubprogramSignature;
-    static getLocalizedMethodTypeSignature(methodType: MethodTypeEntity, localization: Localization): LocalizedSubprogramSignature;
+    static getLocalizedFunctionTypeSignature(functionType: FunctionTypeEntity, localization: Localization): LocalizedSubprogramSignature;
     static getLocalizedConstructorSignature(constructor: ConstructorEntity, localization: Localization): LocalizedSubprogramSignature;
     static getLocalizedDestructorSignature(destructor: DestructorEntity, localization: Localization): LocalizedSubprogramSignature;
     static getLocalizedIndexerSignature(indexer: IndexerEntity, localization: Localization): LocalizedSubprogramSignature;
     static getLocalizedTypeHeader(type: TypeEntityWithHeaderLocalization, localization: Localization): LocalizedTypeHeader;
-    static getLocalizedSignatureTypeOfMethod(analyzer: Analyzer, method: MethodEntity, signatureType: types.MethodType, localization: Localization): types.MethodType;
-    static getLocalizedSignatureTypeOfOperator(analyzer: Analyzer, operator: OperatorEntity, signatureType: types.MethodType, localization: Localization): types.MethodType;
-    static localizeMethodType(analyzer: Analyzer, type: types.MethodType, localizedSignature: LocalizedSubprogramSignature): types.MethodType;
+    static getLocalizedSignatureTypeOfFunction(analyzer: Analyzer, func: FunctionEntity, signatureType: types.FunctionType, localization: Localization): types.FunctionType;
+    static getLocalizedSignatureTypeOfOperator(analyzer: Analyzer, operator: OperatorEntity, signatureType: types.FunctionType, localization: Localization): types.FunctionType;
+    static localizeFunctionType(analyzer: Analyzer, type: types.FunctionType, localizedSignature: LocalizedSubprogramSignature): types.FunctionType;
 }

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

@@ -3,7 +3,7 @@ import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import { NamedTypeEntity, PackageAliasEntity, VariableEntity } from '../entities/index.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
-import { AccessedMethod } from './AccessedMethod.js';
+import { AccessedFunction } from './AccessedFunction.js';
 import { FoundAnonymousDeclaration, FoundNamedDeclaration } from './FoundDeclaration.js';
 import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
 import * as scope from './Scope.js';
@@ -17,8 +17,8 @@ export declare class Resolver {
     constructor(analyzer: Analyzer, node: tree.IdentifierExpression, targetTypeHint: TargetTypeHint | undefined);
     resolve(): ResolutionResult;
     private tryResolveOperatorAccessMeaning;
-    private resolveMethodOverload;
-    private createAccessedMethod;
+    private resolveFunctionOverload;
+    private createAccessedFunction;
     private convertSyntacticAccessKind;
 }
 export declare class ResolutionResult {
@@ -34,19 +34,19 @@ export declare class ResolutionResult {
      */
     dependsOnTargetType?: boolean);
 }
-export type Meaning = Meaning_variableAccess | Meaning_methodAccess | Meaning_operatorAccess | Meaning_packageNameSegmentAccess | Meaning_packageAliasAccess | Meaning_typeAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
+export type Meaning = Meaning_variableAccess | Meaning_functionAccess | Meaning_operatorAccess | Meaning_packageNameSegmentAccess | Meaning_packageAliasAccess | Meaning_typeAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
 declare class Meaning_variableAccess {
     readonly variable: FoundNamedDeclaration<AccessedVariable>;
     readonly accessKind: AccessKind;
     readonly kind = "variable-access";
     constructor(variable: FoundNamedDeclaration<AccessedVariable>, accessKind: AccessKind);
 }
-declare class Meaning_methodAccess {
-    readonly candidates: readonly FoundNamedDeclaration<AccessedMethod>[];
-    readonly suitableMethods: readonly FoundNamedDeclaration<AccessedMethod>[];
-    readonly kind = "method-access";
-    get singleSuitableMethod(): FoundNamedDeclaration<AccessedMethod> | undefined;
-    constructor(candidates: readonly FoundNamedDeclaration<AccessedMethod>[], suitableMethods: readonly FoundNamedDeclaration<AccessedMethod>[]);
+declare class Meaning_functionAccess {
+    readonly candidates: readonly FoundNamedDeclaration<AccessedFunction>[];
+    readonly suitableFunctions: readonly FoundNamedDeclaration<AccessedFunction>[];
+    readonly kind = "function-access";
+    get singleSuitableFunction(): FoundNamedDeclaration<AccessedFunction> | undefined;
+    constructor(candidates: readonly FoundNamedDeclaration<AccessedFunction>[], suitableFunctions: readonly FoundNamedDeclaration<AccessedFunction>[]);
 }
 declare class Meaning_operatorAccess {
     readonly candidates: readonly FoundAnonymousDeclaration<types.Operator>[];

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

@@ -11,6 +11,7 @@ export declare class ImportedPackageNameTree {
 export interface PackageNameTreeNode {
     readonly name: Name;
     readonly package: ImportedPackage | undefined;
+    readonly parent: PackageNameTreeNode | undefined;
     getChild(name: Name): PackageNameTreeNode | undefined;
     hasChild(name: Name): boolean;
     getChildren(): Iterable<PackageNameTreeNode>;

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

@@ -1,5 +1,5 @@
 import { Name, PackageLocale } from '../common/index.js';
-import { AliasTypeEntity, MethodEntity, PackageAliasEntity, PackageEntity, PackageMethodTypeEntity, PackageStructuredTypeEntity, PackageVariantTypeEntity, TypeOrExtensionEntity, TypeParameterEntity, VariableEntity } from '../entities/index.js';
+import { AliasTypeEntity, FunctionEntity, PackageAliasEntity, PackageEntity, PackageFunctionTypeEntity, PackageStructuredTypeEntity, PackageVariantTypeEntity, TypeOrExtensionEntity, TypeParameterEntity, VariableEntity } from '../entities/index.js';
 import { AnalyzedTranslationPackage, TranslatedTypeEntityMembers } from './AnalyzedTranslationPackage.js';
 export declare class LocalizationContext {
     readonly originalLocale: PackageLocale;
@@ -11,4 +11,4 @@ export declare class LocalizationContext {
     getTranslatedTypeOrExtensionEntityMembers(entity: TypeOrExtensionEntity): TranslatedTypeEntityMembers | undefined;
     getEntityName(entity: NamedEntity): Name;
 }
-export type NamedEntity = VariableEntity | PackageVariantTypeEntity | MethodEntity | TypeParameterEntity | PackageMethodTypeEntity | PackageStructuredTypeEntity | PackageAliasEntity | AliasTypeEntity;
+export type NamedEntity = VariableEntity | PackageVariantTypeEntity | FunctionEntity | TypeParameterEntity | PackageFunctionTypeEntity | PackageStructuredTypeEntity | PackageAliasEntity | AliasTypeEntity;

package/build/types/analysis/{PropertyAccessExpressionMeaning.d.ts → MemberAccessExpressionMeaning.d.ts}

@@ -1,11 +1,12 @@
 import { AccessKind } from '../common/index.js';
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
-import { PackageTypeEntity, PackageVariableEntity } from '../entities/index.js';
+import { Entity, PackageTypeEntity, PackageVariableEntity } from '../entities/index.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
-import { AccessedMethod } from './AccessedMethod.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';
 export declare class Resolver {
     private readonly _semanticContext;
@@ -15,17 +16,17 @@ export declare class Resolver {
     private get propertySearchName();
     private get semanticContext();
     private get receiver();
-    constructor(analyzer: Analyzer, node: tree.PropertyAccessExpression, targetTypeHint: TargetTypeHint | undefined);
+    constructor(analyzer: Analyzer, node: tree.MemberAccessExpression, targetTypeHint: TargetTypeHint | undefined);
     resolve(): ResolutionResult;
     private resolvePackageAliasMemberAccessMeaning;
     private resolvePackageMemberAccessMeaning;
     private resolvePackageNameSegmentAccessMeaning;
-    private createAccessedMethodFromPackageMember;
+    private createAccessedFunctionFromPackageMember;
     private resolveStaticMemberOrVariantAccessMeaning;
-    private createAccessedMethodFromTypeMember;
+    private createAccessedFunctionFromTypeMember;
     private resolveInstanceMemberAccessMeaning;
     private tryResolveInstanceOperatorAccessMeaning;
-    private resolveMethodOverload;
+    private resolveFunctionOverload;
     private convertSyntacticAccessKind;
 }
 export declare class ResolutionResult {
@@ -41,19 +42,19 @@ export declare class ResolutionResult {
      */
     dependsOnTargetType?: boolean);
 }
-export type Meaning = Meaning_packageVariableAccess | Meaning_packageMethodAccess | Meaning_packageTypeAccess | Meaning_packageNameSegmentAccess | Meaning_staticVariableAccess | Meaning_staticMethodAccess | Meaning_instanceVariableAccess | Meaning_instanceMethodAccess | Meaning_operatorAccess | Meaning_unresolved;
+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;
 declare class Meaning_packageVariableAccess {
     readonly variable: FoundNamedDeclaration<PackageVariableEntity>;
     readonly accessKind: AccessKind;
     readonly kind = "package-variable-access";
     constructor(variable: FoundNamedDeclaration<PackageVariableEntity>, accessKind: AccessKind);
 }
-declare class Meaning_packageMethodAccess {
-    readonly candidates: readonly FoundNamedDeclaration<AccessedMethod>[];
-    readonly suitableMethods: readonly FoundNamedDeclaration<AccessedMethod>[];
-    readonly kind = "package-method-access";
-    get singleSuitableMethod(): FoundNamedDeclaration<AccessedMethod> | undefined;
-    constructor(candidates: readonly FoundNamedDeclaration<AccessedMethod>[], suitableMethods: readonly FoundNamedDeclaration<AccessedMethod>[]);
+declare class Meaning_packageFunctionAccess {
+    readonly candidates: readonly FoundNamedDeclaration<AccessedFunction>[];
+    readonly suitableFunctions: readonly FoundNamedDeclaration<AccessedFunction>[];
+    readonly kind = "package-function-access";
+    get singleSuitableFunction(): FoundNamedDeclaration<AccessedFunction> | undefined;
+    constructor(candidates: readonly FoundNamedDeclaration<AccessedFunction>[], suitableFunctions: readonly FoundNamedDeclaration<AccessedFunction>[]);
 }
 declare class Meaning_packageTypeAccess {
     readonly candidates: readonly FoundNamedDeclaration<PackageTypeEntity>[];
@@ -76,11 +77,11 @@ declare class Meaning_staticVariableAccess {
 }
 declare class Meaning_staticMethodAccess {
     readonly type: types.Type;
-    readonly candidates: readonly FoundNamedDeclaration<AccessedMethod>[];
-    readonly suitableMethods: readonly FoundNamedDeclaration<AccessedMethod>[];
+    readonly candidates: readonly FoundNamedDeclaration<AccessedFunction>[];
+    readonly suitableFunctions: readonly FoundNamedDeclaration<AccessedFunction>[];
     readonly kind = "static-method-access";
-    get singleSuitableMethod(): FoundNamedDeclaration<AccessedMethod> | undefined;
-    constructor(type: types.Type, candidates: readonly FoundNamedDeclaration<AccessedMethod>[], suitableMethods: readonly FoundNamedDeclaration<AccessedMethod>[]);
+    get singleSuitableFunction(): FoundNamedDeclaration<AccessedFunction> | undefined;
+    constructor(type: types.Type, candidates: readonly FoundNamedDeclaration<AccessedFunction>[], suitableFunctions: readonly FoundNamedDeclaration<AccessedFunction>[]);
 }
 declare class Meaning_instanceVariableAccess {
     readonly variable: FoundNamedDeclaration<types.Variable>;
@@ -89,11 +90,11 @@ declare class Meaning_instanceVariableAccess {
     constructor(variable: FoundNamedDeclaration<types.Variable>, accessKind: AccessKind);
 }
 declare class Meaning_instanceMethodAccess {
-    readonly candidates: readonly FoundNamedDeclaration<AccessedMethod>[];
-    readonly suitableMethods: readonly FoundNamedDeclaration<AccessedMethod>[];
+    readonly candidates: readonly FoundNamedDeclaration<AccessedFunction>[];
+    readonly suitableFunctions: readonly FoundNamedDeclaration<AccessedFunction>[];
     readonly kind = "instance-method-access";
-    get singleSuitableMethod(): FoundNamedDeclaration<AccessedMethod> | undefined;
-    constructor(candidates: readonly FoundNamedDeclaration<AccessedMethod>[], suitableMethods: readonly FoundNamedDeclaration<AccessedMethod>[]);
+    get singleSuitableFunction(): FoundNamedDeclaration<AccessedFunction> | undefined;
+    constructor(candidates: readonly FoundNamedDeclaration<AccessedFunction>[], suitableFunctions: readonly FoundNamedDeclaration<AccessedFunction>[]);
 }
 declare class Meaning_operatorAccess {
     readonly candidates: readonly FoundAnonymousDeclaration<types.Operator>[];
@@ -102,6 +103,11 @@ declare class Meaning_operatorAccess {
     get singleSuitableOperator(): FoundAnonymousDeclaration<types.Operator> | undefined;
     constructor(candidates: readonly FoundAnonymousDeclaration<types.Operator>[], suitableOperators: readonly FoundAnonymousDeclaration<types.Operator>[]);
 }
+declare class Meaning_mixedAmbiguousAccess {
+    readonly entities: readonly WithLocalization<Entity>[];
+    readonly kind = "mixed-ambiguous-access";
+    constructor(entities: readonly WithLocalization<Entity>[]);
+}
 declare class Meaning_unresolved {
     readonly kind = "unresolved";
 }

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

@@ -4,6 +4,8 @@ import { QualifiedName } from '../tree/index.js';
 import { Analyzer } from './Analyzer.js';
 import { FoundNamedDeclaration } from './FoundDeclaration.js';
 import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
+import { WithLocalization } from './Localization.js';
+import { EntityOrPackageNameTreeNode } from './Utils.js';
 export declare class NamedTypeResolver {
     private readonly _analyzer;
     private readonly _node;
@@ -16,12 +18,14 @@ export declare class NamedTypeResolver {
     private findTypesOrContainersWithTypesInPackageAccessedViaAlias;
     private findTypesOrContainersWithTypesInPackageNameSegment;
     private convertPackageMember;
+    private createAmbiguousAccessDiagnostic;
 }
 export declare class NamedTypeResolutionResult {
     readonly types: readonly FoundNamedDeclaration<NamedTypeEntity>[];
     readonly resolvedQualifiers: readonly ResolvedQualifier[];
     readonly diagnostics: readonly Diagnostic[];
-    constructor(types: readonly FoundNamedDeclaration<NamedTypeEntity>[], resolvedQualifiers: readonly ResolvedQualifier[], diagnostics: readonly Diagnostic[]);
+    readonly ambiguousDeclarations: readonly WithLocalization<EntityOrPackageNameTreeNode>[] | undefined;
+    constructor(types: readonly FoundNamedDeclaration<NamedTypeEntity>[], resolvedQualifiers: readonly ResolvedQualifier[], diagnostics: readonly 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

@@ -3,7 +3,9 @@ import { NamedTypeSpecifier } from '../tree/index.js';
 import * as types from '../types/index.js';
 import { Analyzer } from './Analyzer.js';
 import { FoundNamedDeclaration } from './FoundDeclaration.js';
+import { WithLocalization } from './Localization.js';
 import { ResolvedQualifier } from './NamedTypeResolver.js';
+import { EntityOrPackageNameTreeNode } from './Utils.js';
 export declare class NamedTypeSpecifierResolver {
     private readonly _analyzer;
     private readonly _node;
@@ -15,5 +17,6 @@ export declare class NamedTypeSpecifierResolutionResult {
     readonly type: FoundNamedDeclaration<types.Type> | undefined;
     readonly resolvedQualifiers: readonly ResolvedQualifier[];
     readonly diagnostics: readonly Diagnostic[];
-    constructor(type: FoundNamedDeclaration<types.Type> | undefined, resolvedQualifiers: readonly ResolvedQualifier[], diagnostics: readonly Diagnostic[]);
+    readonly ambiguousDeclarations: readonly WithLocalization<EntityOrPackageNameTreeNode>[] | undefined;
+    constructor(type: FoundNamedDeclaration<types.Type> | undefined, resolvedQualifiers: readonly ResolvedQualifier[], diagnostics: readonly Diagnostic[], ambiguousDeclarations: readonly WithLocalization<EntityOrPackageNameTreeNode>[] | undefined);
 }

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

@@ -9,24 +9,24 @@ export declare class NodeTypeUtils {
     static isExpression(node: tree.Node): node is tree.Expression;
     static isStatement(node: tree.Node): node is tree.Statement;
     static isTypeSpecifier(node: tree.Node): node is tree.TypeSpecifier;
-    static isMethodDeclaration(node: tree.Node): node is MethodDeclaration;
+    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;
 }
-export type PackageTypeDeclaration = tree.PackageAliasTypeDeclaration | tree.PackageMethodTypeDeclaration | tree.PackageStructuredTypeDeclaration | tree.PackageVariantTypeDeclaration;
+export type PackageTypeDeclaration = tree.PackageAliasTypeDeclaration | tree.PackageFunctionTypeDeclaration | tree.PackageStructuredTypeDeclaration | tree.PackageVariantTypeDeclaration;
 export type StructuredTypeDeclaration = tree.PackageStructuredTypeDeclaration | tree.AnonymousStructuredTypeDeclaration;
 export type VariantTypeDeclaration = tree.PackageVariantTypeDeclaration | tree.AnonymousVariantTypeDeclaration;
-export type MethodTypeDeclaration = tree.PackageMethodTypeDeclaration | tree.AnonymousMethodTypeDeclaration;
-export type MethodDeclaration = tree.PackageMethodDeclaration | tree.NestedMethodDeclaration | tree.TypeMethodDeclaration;
-export type TypeDeclaration = StructuredTypeDeclaration | VariantTypeDeclaration | MethodTypeDeclaration | tree.PackageAliasTypeDeclaration | tree.TypeParameterDeclaration;
-export type NamedTypeDeclaration = tree.PackageStructuredTypeDeclaration | tree.PackageVariantTypeDeclaration | tree.PackageMethodTypeDeclaration | tree.PackageAliasTypeDeclaration | tree.TypeParameterDeclaration;
-export type VariableDeclaration = tree.EnumerationVariableDeclaration | tree.PackageVariableDeclaration | tree.LocalVariableDeclaration | tree.ParameterDeclaration | tree.TypeVariableDeclaration | tree.VariantDeclaration;
-export type GetterDeclaration = tree.PackageVariableGetterDeclaration | tree.TypeVariableGetterDeclaration | tree.TypeIndexedGetterDeclaration | tree.TypeDereferencedVariableGetterDeclaration;
-export type SetterDeclaration = tree.PackageVariableSetterDeclaration | tree.TypeVariableSetterDeclaration | tree.TypeIndexedSetterDeclaration | tree.TypeDereferencedVariableSetterDeclaration;
+export type FunctionTypeDeclaration = tree.PackageFunctionTypeDeclaration | tree.AnonymousFunctionTypeDeclaration;
+export type FunctionDeclaration = tree.PackageFunctionDeclaration | tree.NestedFunctionDeclaration | tree.MethodDeclaration;
+export type TypeDeclaration = StructuredTypeDeclaration | VariantTypeDeclaration | FunctionTypeDeclaration | tree.PackageAliasTypeDeclaration | tree.TypeParameterDeclaration;
+export type NamedTypeDeclaration = tree.PackageStructuredTypeDeclaration | tree.PackageVariantTypeDeclaration | tree.PackageFunctionTypeDeclaration | tree.PackageAliasTypeDeclaration | tree.TypeParameterDeclaration;
+export type VariableDeclaration = tree.EnumerationVariableDeclaration | tree.PackageVariableDeclaration | tree.LocalVariableDeclaration | tree.ParameterDeclaration | tree.FieldDeclaration | tree.VariantDeclaration;
+export type GetterDeclaration = tree.PackageVariableGetterDeclaration | tree.FieldGetterDeclaration | tree.IndexedElementGetterDeclaration | tree.DereferencedVariableGetterDeclaration;
+export type SetterDeclaration = tree.PackageVariableSetterDeclaration | tree.FieldSetterDeclaration | tree.IndexedElementSetterDeclaration | tree.DereferencedVariableSetterDeclaration;
 export type PackageVariableAccessorDeclaration = tree.PackageVariableGetterDeclaration | tree.PackageVariableSetterDeclaration;
-export type TypeVariableAccessorDeclaration = tree.TypeVariableGetterDeclaration | tree.TypeVariableSetterDeclaration;
-export type TypeIndexedAccessorDeclaration = tree.TypeIndexedGetterDeclaration | tree.TypeIndexedSetterDeclaration;
-export type TypeDereferencedVariableAccessorDeclaration = tree.TypeDereferencedVariableGetterDeclaration | tree.TypeDereferencedVariableSetterDeclaration;
-export type SubprogramDeclaration = tree.FunctionBlockParent | tree.MethodLiteral | tree.MethodBlockLiteral;
+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;

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

@@ -6,7 +6,7 @@ export declare class Resolver<TCandidate extends ICandidate<TValueParameter>, TV
     private readonly _analyzer;
     constructor(_analyzer: Analyzer);
     resolveByCallExpression(candidates: readonly TCandidate[], node: CallExpression): readonly TCandidate[];
-    resolveByTargetType(candidates: readonly TCandidate[], targetType: types.MethodType): readonly TCandidate[];
+    resolveByTargetType(candidates: readonly TCandidate[], targetType: types.FunctionType): readonly TCandidate[];
 }
 export interface ICandidate<TValueParameter extends IValueParameter> {
     getValueParameters(): readonly TValueParameter[];

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

@@ -1,5 +1,5 @@
 import { Name, PackageLocale, SearchName } from '../common/index.js';
-import { EntityHidingLevel, IEntityHidingMatcher, MethodEntity, NamedTypeEntity, OperatorKind, PackageAliasEntity, TypeEntity, TypeExtensionEntity, VariableEntity } from '../entities/index.js';
+import { EntityHidingLevel, FunctionEntity, IEntityHidingMatcher, NamedTypeEntity, OperatorKind, PackageAliasEntity, TypeEntity, TypeExtensionEntity, VariableEntity } from '../entities/index.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
 import { Analyzer } from './Analyzer.js';
@@ -17,40 +17,40 @@ export interface IScope {
     getTypeExtensionsByType(typeEntity: TypeEntity, hidingMatcher?: IEntityHidingMatcher): readonly TypeExtensionEntity[];
 }
 export type TypeOrContainerWithTypes = NamedDeclaration_type | NamedDeclaration_packageAlias | NamedDeclaration_packageNameSegment;
-export type NamedDeclaration = NamedDeclaration_method | NamedDeclaration_variable | NamedDeclaration_type | NamedDeclaration_packageAlias | NamedDeclaration_packageNameSegment;
-export declare class NamedDeclaration_method implements INamedDeclaration {
-    readonly value: NamedDeclarationMethod;
-    readonly kind = "method";
-    constructor(value: NamedDeclarationMethod);
+export type NamedDeclaration = NamedDeclaration_function | NamedDeclaration_variable | NamedDeclaration_type | NamedDeclaration_packageAlias | NamedDeclaration_packageNameSegment;
+export declare class NamedDeclaration_function implements INamedDeclaration {
+    readonly value: NamedDeclarationFunction;
+    readonly kind = "function";
+    constructor(value: NamedDeclarationFunction);
     getName(): Name;
     isHidden(): EntityHidingLevel | undefined;
 }
-export type NamedDeclarationMethod = NamedDeclarationMethod_entity | NamedDeclarationMethod_typeMember;
-export declare class NamedDeclarationMethod_entity implements INamedDeclarationMethod {
+export type NamedDeclarationFunction = NamedDeclarationFunction_entity | NamedDeclarationFunction_typeMember;
+export declare class NamedDeclarationFunction_entity implements INamedDeclarationFunction {
     readonly kind = "entity";
     private readonly _valueParameters;
-    readonly value: MethodEntity;
-    constructor(value: MethodEntity);
+    readonly value: FunctionEntity;
+    constructor(value: FunctionEntity);
     getName(): Name;
-    getEntity(): MethodEntity;
+    getEntity(): FunctionEntity;
     getTypeParameterArity(): number;
     isHidden(): EntityHidingLevel | undefined;
     getValueParameters(): readonly ValueParameter[];
 }
-export declare class NamedDeclarationMethod_typeMember implements INamedDeclarationMethod {
+export declare class NamedDeclarationFunction_typeMember implements INamedDeclarationFunction {
     readonly kind = "type-member";
     private readonly _valueParameters;
     readonly value: types.Method;
     constructor(value: types.Method);
     getName(): Name;
-    getEntity(): MethodEntity;
+    getEntity(): FunctionEntity;
     getTypeParameterArity(): number;
     isHidden(): EntityHidingLevel | undefined;
     getValueParameters(): readonly ValueParameter[];
 }
-interface INamedDeclarationMethod {
+interface INamedDeclarationFunction {
     getName(): Name;
-    getEntity(): MethodEntity;
+    getEntity(): FunctionEntity;
     getTypeParameterArity(): number;
     isHidden(): EntityHidingLevel | undefined;
     getValueParameters(): readonly ValueParameter[];

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

@@ -6,7 +6,7 @@ import * as types from '../types/index.js';
 import { Analyzer } from './Analyzer.js';
 import { LocalizationContext } from './LocalizationContext.js';
 import { Lookup, ScopeChain } from './Lookup.js';
-import { GetterDeclaration, MethodDeclaration, MethodTypeDeclaration, SetterDeclaration, StructuredTypeDeclaration, VariantTypeDeclaration } from './NodeTypeUtils.js';
+import { FunctionDeclaration, FunctionTypeDeclaration, GetterDeclaration, SetterDeclaration, StructuredTypeDeclaration, VariantTypeDeclaration } from './NodeTypeUtils.js';
 /**
  * Позволяет получить информацию, общую для определённой области
  * исходного кода (блока инструкций, списка членов типа и др.) с учётом
@@ -27,13 +27,13 @@ export interface SemanticContext {
     getHidingMatcher(): IEntityHidingMatcher;
     isStatic(): boolean;
 }
-export type SubprogramInfo = SubprogramInfo.Method | SubprogramInfo.Operator | SubprogramInfo.Constructor | SubprogramInfo.Destructor | SubprogramInfo.Getter | SubprogramInfo.Setter | SubprogramInfo.PackageConstructor | SubprogramInfo.PackageEntryPoint | SubprogramInfo.MethodLiteral;
+export type SubprogramInfo = SubprogramInfo.Function | SubprogramInfo.Operator | SubprogramInfo.Constructor | SubprogramInfo.Destructor | SubprogramInfo.Getter | SubprogramInfo.Setter | SubprogramInfo.PackageConstructor | SubprogramInfo.PackageEntryPoint | SubprogramInfo.FunctionLiteral;
 export declare namespace SubprogramInfo {
-    export class Method implements ISubprogramInfo {
-        readonly kind = "method";
+    export class Function implements ISubprogramInfo {
+        readonly kind = "function";
         private readonly _analyzer;
         private readonly _node;
-        constructor(analyzer: Analyzer, node: MethodDeclaration);
+        constructor(analyzer: Analyzer, node: FunctionDeclaration);
         getReturnType(): types.Type | undefined;
         isGenerator(): boolean;
         allowsAsyncCalls(): boolean;
@@ -52,7 +52,7 @@ export declare namespace SubprogramInfo {
         readonly kind = "constructor";
         private readonly _analyzer;
         private readonly _node;
-        constructor(analyzer: Analyzer, node: tree.TypeConstructorDeclaration);
+        constructor(analyzer: Analyzer, node: tree.ConstructorDeclaration);
         getReturnType(): types.Type | undefined;
         isGenerator(): boolean;
         allowsAsyncCalls(): boolean;
@@ -62,7 +62,7 @@ export declare namespace SubprogramInfo {
         readonly kind = "destructor";
         private readonly _analyzer;
         private readonly _node;
-        constructor(analyzer: Analyzer, node: tree.TypeDestructorDeclaration);
+        constructor(analyzer: Analyzer, node: tree.DestructorDeclaration);
         getReturnType(): types.Type | undefined;
         isGenerator(): boolean;
         allowsAsyncCalls(): boolean;
@@ -105,11 +105,11 @@ export declare namespace SubprogramInfo {
         allowsAsyncCalls(): boolean;
         getPackageEntity(): PackageEntity;
     }
-    export class MethodLiteral implements ISubprogramInfo {
-        readonly kind = "method-literal";
+    export class FunctionLiteral implements ISubprogramInfo {
+        readonly kind = "function-literal";
         private readonly _analyzer;
         private readonly _node;
-        constructor(analyzer: Analyzer, node: RegularOrBlockMethodLiteral);
+        constructor(analyzer: Analyzer, node: RegularOrBlockFunctionLiteral);
         getReturnType(): types.Type | undefined;
         isGenerator(): boolean;
         allowsAsyncCalls(): boolean;
@@ -181,7 +181,7 @@ export declare class SourceFileSemanticContext implements SemanticContext {
     getLocalizationContext(): LocalizationContext;
     isStatic(): boolean;
 }
-export type TypeDeclarationCreatingSemanticContext = StructuredTypeDeclaration | VariantTypeDeclaration | MethodTypeDeclaration | tree.PackageAliasTypeDeclaration;
+export type TypeDeclarationCreatingSemanticContext = StructuredTypeDeclaration | VariantTypeDeclaration | FunctionTypeDeclaration | tree.PackageAliasTypeDeclaration;
 /**
  * Завершающий семантический контекст типа.
  * Поскольку контекст с параметрами типа является опциональным, необходим
@@ -198,7 +198,7 @@ export declare class LastSemanticContextOfType extends SemanticContextWithParent
     isStatic(): boolean;
     private getContainingType;
 }
-type TypeDeclarationWithTypeParameters = tree.PackageStructuredTypeDeclaration | tree.PackageVariantTypeDeclaration | tree.PackageAliasTypeDeclaration | tree.PackageMethodTypeDeclaration;
+type TypeDeclarationWithTypeParameters = tree.PackageStructuredTypeDeclaration | tree.PackageVariantTypeDeclaration | tree.PackageAliasTypeDeclaration | tree.PackageFunctionTypeDeclaration;
 export declare class TypeParametersOfTypeSemanticContext extends SemanticContextWithParent {
     private readonly _analyzer;
     private readonly _node;
@@ -206,7 +206,7 @@ export declare class TypeParametersOfTypeSemanticContext extends SemanticContext
     constructor(analyzer: Analyzer, node: TypeDeclarationWithTypeParameters, parentContext: SemanticContext);
     getScopeChain(): ScopeChain;
 }
-export type TypeDeclarationBody = tree.StructuredTypeDeclarationBody | tree.VariantTypeDeclarationBody | tree.AliasTypeDeclarationBody | tree.MethodTypeDeclarationBody;
+export type TypeDeclarationBody = tree.StructuredTypeDeclarationBody | tree.VariantTypeDeclarationBody | tree.AliasTypeDeclarationBody | tree.FunctionTypeDeclarationBody;
 export declare class TypeBodySemanticContext extends SemanticContextWithParent {
     private readonly _analyzer;
     private readonly _node;
@@ -223,32 +223,32 @@ export declare class TypeExtensionBodySemanticContext extends SemanticContextWit
     getContainingTypeOrTypeExtension(): TypeOrTypeExtension | undefined;
 }
 /**
- * Завершающий семантический контекст метода.
- * Поскольку контекст с параметрами типа метода является опциональным, необходим
+ * Завершающий семантический контекст функции.
+ * Поскольку контекст с параметрами типа функции является опциональным, необходим
  * ещё один контекст, который гарантированно переопределит метод `getContainingSubprogram`.
  */
-export declare class LastSemanticContextOfMethod extends SemanticContextWithParent {
+export declare class LastSemanticContextOfFunction extends SemanticContextWithParent {
     private readonly _analyzer;
     private readonly _node;
     private readonly _subprogramInfo;
-    constructor(analyzer: Analyzer, node: MethodDeclaration, parentContext: SemanticContext);
+    constructor(analyzer: Analyzer, node: FunctionDeclaration, parentContext: SemanticContext);
     getContainingSubprogram(): SubprogramInfo | undefined;
     isInTryStatement(): TryStatementClausesInfo | undefined;
     isInFinallyClause(): boolean;
     isStatic(): boolean;
 }
-export declare class MethodTypeParameterSemanticContext extends SemanticContextWithParent {
+export declare class FunctionTypeParameterSemanticContext extends SemanticContextWithParent {
     private readonly _analyzer;
     private readonly _node;
     private readonly _scopeChain;
-    constructor(analyzer: Analyzer, node: MethodDeclaration, parentContext: SemanticContext);
+    constructor(analyzer: Analyzer, node: FunctionDeclaration, parentContext: SemanticContext);
     getScopeChain(): ScopeChain;
 }
-export declare class MethodValueParameterSemanticContext extends SemanticContextWithParent {
+export declare class FunctionValueParameterSemanticContext extends SemanticContextWithParent {
     private readonly _analyzer;
     private readonly _node;
     private readonly _scopeChain;
-    constructor(analyzer: Analyzer, node: MethodDeclaration, parentContext: SemanticContext);
+    constructor(analyzer: Analyzer, node: FunctionDeclaration, parentContext: SemanticContext);
     getScopeChain(): ScopeChain;
 }
 export declare class PackageConstructorSemanticContext extends SemanticContextWithParent {
@@ -280,7 +280,7 @@ export declare class ConstructorSemanticContext extends SemanticContextWithParen
     private readonly _node;
     private readonly _scopeChain;
     private readonly _subprogramInfo;
-    constructor(analyzer: Analyzer, node: tree.TypeConstructorDeclaration, parentContext: SemanticContext);
+    constructor(analyzer: Analyzer, node: tree.ConstructorDeclaration, parentContext: SemanticContext);
     getScopeChain(): ScopeChain;
     getContainingSubprogram(): SubprogramInfo | undefined;
 }
@@ -289,7 +289,7 @@ export declare class DestructorSemanticContext extends SemanticContextWithParent
     private readonly _node;
     private readonly _scopeChain;
     private readonly _subprogramInfo;
-    constructor(analyzer: Analyzer, node: tree.TypeDestructorDeclaration, parentContext: SemanticContext);
+    constructor(analyzer: Analyzer, node: tree.DestructorDeclaration, parentContext: SemanticContext);
     getScopeChain(): ScopeChain;
     getContainingSubprogram(): SubprogramInfo | undefined;
 }
@@ -298,7 +298,7 @@ export declare class IndexerSemanticContext extends SemanticContextWithParent {
     private readonly _node;
     private readonly _scopeChain;
     private readonly _subprogramInfo;
-    constructor(analyzer: Analyzer, node: tree.TypeIndexedGetterDeclaration | tree.TypeIndexedSetterDeclaration, parentContext: SemanticContext);
+    constructor(analyzer: Analyzer, node: tree.IndexedElementGetterDeclaration | tree.IndexedElementSetterDeclaration, parentContext: SemanticContext);
     getScopeChain(): ScopeChain;
 }
 export declare class GetterSemanticContext extends SemanticContextWithParent {
@@ -334,13 +334,13 @@ export declare class FunctionBlockSemanticContext extends SemanticContextWithPar
     constructor(analyzer: Analyzer, node: tree.FunctionBlock, parentContext: SemanticContext);
     getScopeChain(): ScopeChain;
 }
-export type RegularOrBlockMethodLiteral = tree.MethodLiteral | tree.MethodBlockLiteral;
-export declare class MethodLiteralSemanticContext extends SemanticContextWithParent {
+export type RegularOrBlockFunctionLiteral = tree.FunctionLiteral | tree.FunctionBlockLiteral;
+export declare class FunctionLiteralSemanticContext extends SemanticContextWithParent {
     private readonly _analyzer;
     private readonly _node;
     private readonly _scopeChain;
     private readonly _subprogramInfo;
-    constructor(analyzer: Analyzer, node: RegularOrBlockMethodLiteral, parentContext: SemanticContext);
+    constructor(analyzer: Analyzer, node: RegularOrBlockFunctionLiteral, parentContext: SemanticContext);
     getScopeChain(): ScopeChain;
     getContainingSubprogram(): SubprogramInfo | undefined;
 }
@@ -358,10 +358,10 @@ export declare class CatchClauseSemanticContext extends SemanticContextWithParen
     constructor(analyzer: Analyzer, node: tree.CatchClause, parentContext: SemanticContext);
     getScopeChain(): ScopeChain;
 }
-export declare class TypeVariableWithInitializerSemanticContext extends SemanticContextWithParent {
+export declare class FieldWithInitializerSemanticContext extends SemanticContextWithParent {
     private readonly _analyzer;
     private readonly _node;
-    constructor(analyzer: Analyzer, node: tree.TypeVariableDeclaration, parentContext: SemanticContext);
+    constructor(analyzer: Analyzer, node: tree.FieldDeclaration, parentContext: SemanticContext);
     isStatic(): boolean;
 }
 export {};