@artel/artc 0.6.25224 → 0.6.25225

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

@@ -27,44 +27,44 @@ 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;
     /**

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/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}

@@ -3,7 +3,7 @@ import { Diagnostic } from '../diagnostic/Diagnostic.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';
@@ -16,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 {
@@ -42,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_mixedAmbiguousAccess | 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>[];
@@ -77,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>;
@@ -90,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>[];

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 {};

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

@@ -1,13 +1,13 @@
 import * as tree from '../tree/index.js';
 import { Analyzer } from './Analyzer.js';
-import { MethodDeclaration } from './NodeTypeUtils.js';
-import { RegularOrBlockMethodLiteral, SemanticContext, TypeDeclarationBody, TypeDeclarationCreatingSemanticContext } from './SemanticContext.js';
+import { FunctionDeclaration } from './NodeTypeUtils.js';
+import { RegularOrBlockFunctionLiteral, SemanticContext, TypeDeclarationBody, TypeDeclarationCreatingSemanticContext } from './SemanticContext.js';
 export declare class SemanticContextBuilder {
     private readonly _analyzer;
     private readonly _semanticContexts;
-    private readonly _methodDeclarationTypeParametersContexts;
-    private readonly _methodDeclarationValueParametersContexts;
-    private readonly _indexerParametersContexts;
+    private readonly _functionDeclarationTypeParametersContexts;
+    private readonly _functionDeclarationValueParametersContexts;
+    private readonly _indexParametersContexts;
     constructor(analyzer: Analyzer);
     /**
      * Возвращает контекст, содержащий узел. Если в качестве узла передан исходный файл,
@@ -17,9 +17,9 @@ export declare class SemanticContextBuilder {
     containingWithOffset(node: tree.Node, offset: number): SemanticContext;
     ofSourceFile(node: tree.SourceFile): SemanticContext;
     /**
-     * Контекст заголовка метода. Включает параметры-типы и параметры-значения (в зависимости от указанного `hint`).
+     * Контекст заголовка функции. Включает параметры-типы и параметры-значения (в зависимости от указанного `hint`).
      */
-    ofMethodDeclarationHeader(node: MethodDeclaration, hint: 'type-parameters' | 'value-parameters'): SemanticContext;
+    ofFunctionDeclarationHeader(node: FunctionDeclaration, hint: 'type-parameters' | 'value-parameters'): SemanticContext;
     ofOperatorDeclaration(node: tree.OperatorDeclaration): SemanticContext;
     ofTypeDeclarationBody(node: TypeDeclarationBody): SemanticContext;
     /**
@@ -27,31 +27,31 @@ export declare class SemanticContextBuilder {
      */
     ofTypeDeclarationHeader(node: TypeDeclarationCreatingSemanticContext): SemanticContext;
     ofTypeExtensionDeclarationBody(node: tree.TypeExtensionDeclaration): SemanticContext;
-    ofVariableGetterDeclaration(node: tree.PackageVariableGetterDeclaration | tree.TypeVariableGetterDeclaration | tree.TypeDereferencedVariableGetterDeclaration): SemanticContext;
-    ofVariableSetterDeclaration(node: tree.PackageVariableSetterDeclaration | tree.TypeVariableSetterDeclaration | tree.TypeDereferencedVariableSetterDeclaration): SemanticContext;
+    ofVariableGetterDeclaration(node: tree.PackageVariableGetterDeclaration | tree.FieldGetterDeclaration | tree.DereferencedVariableGetterDeclaration): SemanticContext;
+    ofVariableSetterDeclaration(node: tree.PackageVariableSetterDeclaration | tree.FieldSetterDeclaration | tree.DereferencedVariableSetterDeclaration): SemanticContext;
     ofPackageConstructorDeclaration(node: tree.PackageConstructorDeclaration): SemanticContext;
     ofPackageEntryPointDeclaration(node: tree.PackageEntryPointDeclaration): SemanticContext;
-    ofRegularOrBlockMethodLiteral(node: RegularOrBlockMethodLiteral): SemanticContext;
+    ofRegularOrBlockFunctionLiteral(node: RegularOrBlockFunctionLiteral): SemanticContext;
     ofForStatement(node: tree.ForStatement): SemanticContext;
     ofStatementBlock(node: tree.StatementBlock): SemanticContext;
     ofFunctionBlock(node: tree.FunctionBlock): SemanticContext;
-    ofTypeConstructorDeclaration(node: tree.TypeConstructorDeclaration): SemanticContext;
-    ofTypeDestructorDeclaration(node: tree.TypeDestructorDeclaration): SemanticContext;
-    ofTypeIndexedGetterDeclaration(node: tree.TypeIndexedGetterDeclaration, hint: 'body' | 'parameters'): SemanticContext;
-    ofTypeIndexedSetterDeclaration(node: tree.TypeIndexedSetterDeclaration, hint: 'body' | 'parameters'): SemanticContext;
+    ofConstructorDeclaration(node: tree.ConstructorDeclaration): SemanticContext;
+    ofDestructorDeclaration(node: tree.DestructorDeclaration): SemanticContext;
+    ofIndexedElementGetterDeclaration(node: tree.IndexedElementGetterDeclaration, hint: 'body' | 'parameters'): SemanticContext;
+    ofIndexedElementSetterDeclaration(node: tree.IndexedElementSetterDeclaration, hint: 'body' | 'parameters'): SemanticContext;
     ofCatchClause(node: tree.CatchClause): SemanticContext;
-    ofTypeVariableDeclarationWithInitializer(node: tree.TypeVariableDeclaration): SemanticContext;
+    ofFieldDeclarationWithInitializer(node: tree.FieldDeclaration): SemanticContext;
     private containingInternal;
-    private ofChildOfMethodDeclaration;
+    private ofChildOfFunctionDeclaration;
     private ofChildOfTypeDeclarationWithMemberBlock;
     private ofChildOfTypeDeclarationBodyWithMemberBlock;
-    private ofChildOfMethodTypeDeclarationBody;
-    private ofChildOfMethodLiteral;
+    private ofChildOfFunctionTypeDeclarationBody;
+    private ofChildOfFunctionLiteral;
     private ofOperatorDeclarationChild;
-    private ofTypeConstructorDeclarationChild;
-    private ofTypeDestructorDeclarationChild;
-    private ofTypeIndexedGetterDeclarationChild;
-    private ofTypeIndexedSetterDeclarationChild;
+    private ofConstructorDeclarationChild;
+    private ofDestructorDeclarationChild;
+    private ofIndexedElementGetterDeclarationChild;
+    private ofIndexedElementSetterDeclarationChild;
     private ofChildOfTypeExtensionDeclaration;
     private isOffsetBetweenNodes;
     private isOffsetInsideStatementBlock;