@artel/artc 0.6.25224 → 0.6.25225

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

@@ -14,7 +14,7 @@ import * as tree from '../tree/index.js';
 import { TsInteropContext, TsProgramState } from '../ts-interop/TsInteropContext.js';
 import * as types from '../types/index.js';
 import { TypeFactory } from '../types/index.js';
-import { AccessedMethod } from './AccessedMethod.js';
+import { AccessedFunction } from './AccessedFunction.js';
 import { AnalyzedTranslationPackage } from './AnalyzedTranslationPackage.js';
 import { ArgumentToParameterMatchResult, MatchResultValueParameter } from './ArgumentToParameterMatchResult.js';
 import * as autotypeCallExpressionMeaning from './AutotypeCallExpressionMeaning.js';
@@ -29,12 +29,12 @@ import { ImportedPackageNameTree, PackageNameTreeNode } from './ImportedPackageN
 import * as indexedAccessExpressionMeaning from './IndexedAccessExpressionMeaning.js';
 import { WithLocalization } from './Localization.js';
 import { LocalizationContext } from './LocalizationContext.js';
+import * as memberAccessExpressionResolution from './MemberAccessExpressionMeaning.js';
 import { ModifierFlags } from './ModifierFlags.js';
 import { NamedTypeSpecifierResolutionResult } from './NamedTypeSpecifierResolver.js';
-import { GetterDeclaration, MethodTypeDeclaration, PackageVariableAccessorDeclaration, SetterDeclaration, StructuredTypeDeclaration, TypeDereferencedVariableAccessorDeclaration, TypeIndexedAccessorDeclaration, TypeVariableAccessorDeclaration, VariantTypeDeclaration } from './NodeTypeUtils.js';
+import { DereferencedVariableAccessorDeclaration, FieldAccessorDeclaration, FunctionTypeDeclaration, GetterDeclaration, IndexedElementAccessorDeclaration, PackageVariableAccessorDeclaration, SetterDeclaration, StructuredTypeDeclaration, VariantTypeDeclaration } from './NodeTypeUtils.js';
 import * as objectExpressionMeaning from './ObjectExpressionMeaning.js';
 import * as operationOverloadResolver from './OperationOverloadResolver.js';
-import * as propertyAccessExpressionResolution from './PropertyAccessExpressionMeaning.js';
 import * as scope from './Scope.js';
 import { SemanticContextBuilder } from './SemanticContextBuilder.js';
 import { SourceFileMembers as ActualSourceFileMembers } from './SourceFileMembers.js';
@@ -46,7 +46,7 @@ import * as controlFlow from './control-flow/index.js';
 import { WellKnownDeclarations } from './index.js';
 export declare class Analyzer {
     static readonly enumeratorMethodName = "\u043F\u0435\u0440\u0435\u0431\u043E\u0440";
-    static readonly methodTypeInvokeMethodName = "\u0432\u044B\u043F\u043E\u043B\u043D\u0438\u0442\u044C";
+    static readonly functionTypeInvokeMethodName = "\u0432\u044B\u043F\u043E\u043B\u043D\u0438\u0442\u044C";
     readonly compilation: project.Compilation;
     /**
      * Пакет с именем 'Артель', содержащий стандартные типы.
@@ -69,11 +69,12 @@ export declare class Analyzer {
     readonly linkedEntity: LinkedEntity;
     readonly owningPlainObjectModificationCheck: OwningPlainObjectModificationCheck;
     readonly packageImports: PackageImports;
+    readonly typeUtils: TypeUtils;
     private readonly _tsInteropInputs;
     private readonly _targetType;
     private readonly _typeAssignabilityCheck;
     private readonly _tsInterop;
-    private readonly _propertyAccessExpressionResolutionResults;
+    private readonly _memberAccessExpressionResolutionResults;
     private readonly _sourceFileMembers;
     private readonly _callExpressionMeanings;
     private readonly _indexedAccessExpressionResolutionResults;
@@ -87,8 +88,8 @@ export declare class Analyzer {
     private readonly _prefixUnaryExpressionOperatorResolutionResults;
     private readonly _binaryExpressionUserDefinableOperatorResolutionResults;
     private readonly _assignmentStatementOperatorResolutionResults;
-    private readonly _methodEntitySignatureTypes;
-    private readonly _valueParametersOfMethodBlockLiterals;
+    private readonly _functionEntitySignatureTypes;
+    private readonly _valueParametersOfFunctionBlockLiterals;
     private readonly _extendedTypes;
     private readonly _analyzedTranslationPackages;
     private readonly _linkedMultiPlatformPackagesByPlatform;
@@ -112,14 +113,14 @@ export declare class Analyzer {
     getSyntacticAccessKind(node: tree.Expression): SyntacticAccessKind;
     getTypeMemberEntityContainer(node: tree.TypeMemberDeclaration): e.TypeMemberEntityContainer;
     getTargetTypeOfExpression(node: tree.Expression, hint?: TargetTypeHint): types.Type | undefined;
-    getUnambiguousTargetMethodType(targetType: types.Type | undefined): types.MethodType | undefined;
+    getUnambiguousTargetFunctionType(targetType: types.Type | undefined): types.FunctionType | undefined;
     getUnambiguousTargetArrayType(targetType: types.Type | undefined): types.Type | undefined;
     getEnumeratorElementType(node: tree.Node): types.Type | undefined;
-    resolveMethodOverloadByCallExpression<TCandidate extends operationOverloadResolver.ICandidate<TValueParameter>, TValueParameter extends operationOverloadResolver.IValueParameter>(candidates: readonly TCandidate[], node: tree.CallExpression): readonly TCandidate[];
-    resolveMethodOverloadByTargetType<TCandidate extends operationOverloadResolver.ICandidate<TValueParameter>, TValueParameter extends operationOverloadResolver.IValueParameter>(candidates: readonly TCandidate[], targetType: types.MethodType): readonly TCandidate[];
+    resolveFunctionOverloadByCallExpression<TCandidate extends operationOverloadResolver.ICandidate<TValueParameter>, TValueParameter extends operationOverloadResolver.IValueParameter>(candidates: readonly TCandidate[], node: tree.CallExpression): readonly TCandidate[];
+    resolveFunctionOverloadByTargetType<TCandidate extends operationOverloadResolver.ICandidate<TValueParameter>, TValueParameter extends operationOverloadResolver.IValueParameter>(candidates: readonly TCandidate[], targetType: types.FunctionType): readonly TCandidate[];
     resolveConstructorOverload<TCandidate extends constructorOverloadResolver.ICandidate<TValueParameter>, TValueParameter extends constructorOverloadResolver.IValueParameter>(candidates: readonly TCandidate[], args: readonly tree.Argument[]): readonly TCandidate[];
     resolveTypeOverloadByArgumentCount<TCandidate extends typeOverloadResolver.ICandidate>(candidates: readonly TCandidate[], argumentCount: number): readonly TCandidate[];
-    resolvePropertyAccessExpression(node: tree.PropertyAccessExpression, targetTypeHint?: TargetTypeHint): propertyAccessExpressionResolution.ResolutionResult;
+    resolveMemberAccessExpression(node: tree.MemberAccessExpression, targetTypeHint?: TargetTypeHint): memberAccessExpressionResolution.ResolutionResult;
     enumeratePackageImports(packageImportDirectives: Iterable<tree.PackageImportDirective>): Iterable<tree.PackageImport>;
     getSourceFileMembers(node: tree.SourceFile): ActualSourceFileMembers;
     getCallExpressionMeaning(node: tree.CallExpression): callExpressionMeaning.Meaning;
@@ -171,7 +172,7 @@ export declare class Analyzer {
     typeIsValidBaseAspectType(type: types.Type): boolean;
     getImplicitBaseTypeForStructuredType(entity: e.StructuredTypeEntity): types.StructuredType | undefined;
     getImplicitBaseTypeForVariantType(): types.StructuredType;
-    getImplicitBaseTypeForMethodType(): types.StructuredType;
+    getImplicitBaseTypeForFunctionType(): types.StructuredType;
     resolveNamedTypeSpecifier(node: tree.NamedTypeSpecifier): NamedTypeSpecifierResolutionResult;
     checkExpressionDenotesType(expression: tree.Expression): {
         type: types.Type | undefined;
@@ -179,7 +180,7 @@ export declare class Analyzer {
     checkExpressionDenotesPackageAlias(expression: tree.Expression): {
         packageAlias: e.PackageAliasEntity;
     } | undefined;
-    checkExpressionDenotesMethod(expression: tree.Expression): ExpressionDenotesMethodCheckResult | undefined;
+    checkExpressionDenotesFunction(expression: tree.Expression): ExpressionDenotesFunctionCheckResult | undefined;
     checkExpressionDenotesOperator(expression: tree.Expression): ExpressionDenotesOperatorCheckResult | undefined;
     checkExpressionDenotesPackageNameSegment(expression: tree.Expression): {
         packageTreeNode: PackageNameTreeNode;
@@ -194,7 +195,7 @@ export declare class Analyzer {
     getBinaryOperatorKindIfCompoundAssignmentOperator(operator: tree.AssignmentStatementOperator): BinaryOperatorKind | undefined;
     getPackageEntities(): readonly e.PackageEntity[];
     getPackageEntity(name: PackageName): e.PackageEntity | undefined;
-    createMethodTypeInvokeMethod(entity: e.MethodTypeEntity): e.TypeMethodEntity;
+    createFunctionTypeInvokeMethod(entity: e.FunctionTypeEntity): e.MethodEntity;
     /**
      * Преобразует тип таким образом, чтобы он не мог содержать значение `пусто`.
      * После преобразования метод `canTypeBeNone` вернёт `true` для полученного типа.
@@ -233,15 +234,14 @@ export declare class Analyzer {
      */
     isNoneAssignableToType(type: types.Type): boolean;
     excludeTypeFromUnion(initialType: types.Type, excludedType: types.Type): types.Type;
-    isMethodValueParameterVariadic(entity: e.VariableEntity): boolean;
+    isValueParameterVariadic(entity: e.VariableEntity): boolean;
     getDefaultTypeParameterConstraint(): types.Type;
-    getOriginalSignatureTypeOfMethodEntity(entity: e.MethodEntity): types.MethodType;
-    getMethodBlockLiteralValueParameters(node: tree.MethodBlockLiteral): readonly e.VariableEntity[];
+    getOriginalSignatureTypeOfFunctionEntity(entity: e.FunctionEntity): types.FunctionType;
+    getFunctionBlockLiteralValueParameters(node: tree.FunctionBlockLiteral): readonly e.VariableEntity[];
     getExtendedType(node: tree.TypeExtensionDeclaration): WithDiagnostics<e.NamedTypeEntity>;
     getAnalyzedTranslationPackageIfTargetResolved(package_: project.TranslationPackage): AnalyzedTranslationPackage | undefined;
     getAnalyzedTranslationPackageForPackage(entity: e.PackageEntity, locale: PackageLocale): AnalyzedTranslationPackage | undefined;
     enumerateAnalyzedTranslationPackages(): Iterable<AnalyzedTranslationPackage>;
-    getCommonObjectAndAspectTypesOfUnion(unionType: types.UnionType): readonly types.StructuredType[];
     getLinkedMultiPlatformPackagesByPlatform(entity: e.PackageEntity): ReadonlyMap<PlatformKind, LinkedMultiPlatformPackage> | undefined;
     getLinkedMultiPlatformPackage(entity: e.PackageEntity, platform: PlatformKind): LinkedMultiPlatformPackage | undefined;
     createPackageMembers(pkg: SourcePackage): OriginalPackageMembers;
@@ -253,19 +253,19 @@ export declare class Analyzer {
     isFunctionResultNone(node: tree.FunctionBlock): boolean;
     isExpressionImplicitlyReturnedFromSubprogram(node: tree.ExpressionStatement): boolean;
     createBackingPackageVariables(declaredMembers: readonly (e.NamedPackageMemberEntity | e.PackageAliasEntity)[], pkg: e.PackageEntity): e.PackageVariableEntity[];
-    createBackingTypeVariables(declaredMembers: readonly NamedTypeMemberEntity[], type: e.TypeEntity): e.TypeVariableEntity[];
+    createBackingFields(declaredMembers: readonly NamedTypeMemberEntity[], type: e.TypeEntity): e.FieldEntity[];
     createNodeDiagnostic(code: DiagnosticCode, node: tree.Node, formatArguments?: readonly string[], kind?: DiagnosticKind, flags?: DiagnosticFlags): Diagnostic;
     createSourceFileRangeDiagnostic(code: DiagnosticCode, range: Range, nodeOrSourceFile: tree.Node | project.SourceFile, formatArguments?: readonly string[], kind?: DiagnosticKind, flags?: DiagnosticFlags): Diagnostic;
     createDiagnostic(code: DiagnosticCode, location: DiagnosticLocation | undefined, formatArguments?: readonly string[], kind?: DiagnosticKind, flags?: DiagnosticFlags): Diagnostic;
     createNodeDiagnosticLocation(node: tree.Node): DiagnosticLocation;
     getDeclaredTypeMemberEntities(node: tree.TypeMemberDeclarationBlock): DeclaredTypeMemberEntities;
-    getRedefinableMethodOfOriginalTypeForRedefinableMethodOfAliasType(entity: e.TypeMethodEntity): e.TypeMethodEntity | undefined;
-    checkBodyOfRedefinableAliasTypeMethod(node: tree.TypeMethodDeclaration, diagnostics?: DiagnosticAcceptor): {
-        redefinableMethodOfOriginalType: e.TypeMethodEntity;
+    getRedefinableMethodOfOriginalTypeForRedefinableMethodOfAliasType(entity: e.MethodEntity): e.MethodEntity | undefined;
+    checkBodyOfRedefinableAliasTypeMethod(node: tree.MethodDeclaration, diagnostics?: DiagnosticAcceptor): {
+        redefinableMethodOfOriginalType: e.MethodEntity;
     } | undefined;
     getControlFlowGraph(sourceFile: project.SourceFile): controlFlow.GraphBuildResult;
     createAmbiguousEntityAccessDiagnostic(entities: readonly WithLocalization<e.Entity>[], lctx: LocalizationContext, node: tree.Node): Diagnostic;
-    createAmbiguousMethodAccessDiagnostic(methods: readonly WithLocalization<AccessedMethod>[], lctx: LocalizationContext, node: tree.Node): Diagnostic;
+    createAmbiguousFunctionAccessDiagnostic(functions: readonly WithLocalization<AccessedFunction>[], lctx: LocalizationContext, node: tree.Node): Diagnostic;
     createAmbiguousTypeMemberAccessDiagnostic(members: readonly WithLocalization<types.TypeMember>[], lctx: LocalizationContext, node: tree.Node): Diagnostic;
     createAmbiguousNamedScopeDeclarationAccessDiagnostic(declarations: readonly WithLocalization<scope.NamedDeclaration>[], lctx: LocalizationContext, node: tree.Node): Diagnostic;
     private createTsInterop;
@@ -297,15 +297,15 @@ declare class Type {
     private readonly _analyzer;
     private readonly _unionTypeSpecifierTypes;
     private readonly _intersectionTypeSpecifierTypes;
-    private readonly _methodLiteralTypes;
-    private readonly _methodBlockLiteralTypes;
+    private readonly _functionLiteralTypes;
+    private readonly _functionBlockLiteralTypes;
     constructor(_analyzer: Analyzer);
     ofExpression(node: tree.Expression, targetTypeHint?: TargetTypeHint): types.Type;
     ofTypeSpecifier(node: tree.TypeSpecifier): types.Type;
-    ofAccessedMethod(accessedMethod: WithLocalization<AccessedMethod>): types.Type;
+    ofAccessedFunction(accessedFunction: WithLocalization<AccessedFunction>): types.Type;
     ofAccessedOperator(operator: WithLocalization<types.Operator>): types.Type;
-    ofMethodBlockLiteral(node: tree.MethodBlockLiteral, targetTypeHint?: TargetTypeHint): types.MethodType;
-    ofMethodLiteral(node: tree.MethodLiteral, targetTypeHint?: TargetTypeHint): types.MethodType;
+    ofFunctionBlockLiteral(node: tree.FunctionBlockLiteral, targetTypeHint?: TargetTypeHint): types.FunctionType;
+    ofFunctionLiteral(node: tree.FunctionLiteral, targetTypeHint?: TargetTypeHint): types.FunctionType;
     private ofArrayLiteral;
     private ofAssertionExpression;
     private ofAssumptionExpression;
@@ -318,7 +318,7 @@ declare class Type {
     private ofIsExpression;
     private ofParenthesizedExpression;
     private ofPrefixUnaryExpression;
-    private ofPropertyAccessExpression;
+    private ofMemberAccessExpression;
     private ofReferenceExpression;
     private ofDereferenceExpression;
     private ofWhenTernaryExpression;
@@ -337,28 +337,28 @@ declare class Type {
     private ofUnionTypeSpecifier;
     private ofIntersectionTypeSpecifier;
     private ofInvalidTypeSpecifier;
-    private getTargetlessMethodBlockLiteralType;
-    private inferMethodLiteralTypeFromNodeWithFallbackToTargetType;
-    private inferMethodLiteralTypeFromNode;
+    private getTargetlessFunctionBlockLiteralType;
+    private inferFunctionLiteralTypeFromNodeWithFallbackToTargetType;
+    private inferFunctionLiteralTypeFromNode;
     private getNarrowedTypeIfNarrowableReference;
 }
 declare class ReturnType {
     private readonly _analyzer;
     constructor(_analyzer: Analyzer);
-    ofAnonymousMethodTypeDeclaration(node: tree.AnonymousMethodTypeDeclaration): types.Type;
-    ofMethodBlockLiteral(node: tree.MethodBlockLiteral): types.Type;
-    ofPackageMethodDeclaration(node: tree.PackageMethodDeclaration): types.Type;
-    ofPackageMethodTypeDeclaration(node: tree.PackageMethodTypeDeclaration): types.Type;
-    ofNestedMethodDeclaration(node: tree.NestedMethodDeclaration): types.Type;
-    ofMethodLiteral(node: tree.MethodLiteral): types.Type;
-    ofTypeMethodDeclaration(node: tree.TypeMethodDeclaration): types.Type;
+    ofAnonymousFunctionTypeDeclaration(node: tree.AnonymousFunctionTypeDeclaration): types.Type;
+    ofFunctionBlockLiteral(node: tree.FunctionBlockLiteral): types.Type;
+    ofPackageFunctionDeclaration(node: tree.PackageFunctionDeclaration): types.Type;
+    ofPackageFunctionTypeDeclaration(node: tree.PackageFunctionTypeDeclaration): types.Type;
+    ofNestedFunctionDeclaration(node: tree.NestedFunctionDeclaration): types.Type;
+    ofFunctionLiteral(node: tree.FunctionLiteral): types.Type;
+    ofMethodDeclaration(node: tree.MethodDeclaration): types.Type;
     ofOperatorDeclaration(node: tree.OperatorDeclaration): types.Type;
 }
 declare class Entity {
     private readonly _analyzer;
     private readonly _packageEntities;
     private readonly _packageVariableEntities;
-    private readonly _typeVariableEntities;
+    private readonly _fieldEntities;
     private readonly _parameterVariableEntities;
     private readonly _localVariableEntities;
     private readonly _typeParameterEntities;
@@ -368,12 +368,12 @@ declare class Entity {
     private readonly _anonymousStructuredTypeEntities;
     private readonly _packageVariantTypeEntities;
     private readonly _anonymousVariantTypeEntities;
-    private readonly _packageMethodTypeEntities;
-    private readonly _anonymousMethodTypeEntities;
+    private readonly _packageFunctionTypeEntities;
+    private readonly _anonymousFunctionTypeEntities;
     private readonly _aliasTypeEntities;
-    private readonly _packageMethodEntities;
-    private readonly _typeMethodEntities;
-    private readonly _nestedMethodEntities;
+    private readonly _packageFunctionEntities;
+    private readonly _methodEntities;
+    private readonly _nestedFunctionEntities;
     private readonly _constructorEntities;
     private readonly _operatorEntities;
     private readonly _destructorEntities;
@@ -385,49 +385,49 @@ declare class Entity {
     ofPackage(pkg: SourcePackage): e.PackageEntity;
     ofPackageVariableDeclaration(node: tree.PackageVariableDeclaration): e.PackageVariableEntity;
     ofComputedPackageVariableDeclaration(node: PackageVariableAccessorDeclaration): e.PackageVariableEntity;
-    ofTypeVariableDeclaration(node: tree.TypeVariableDeclaration): e.TypeVariableEntity;
-    ofComputedTypeVariableDeclaration(node: TypeVariableAccessorDeclaration): e.TypeVariableEntity;
+    ofFieldDeclaration(node: tree.FieldDeclaration): e.FieldEntity;
+    ofComputedFieldDeclaration(node: FieldAccessorDeclaration): e.FieldEntity;
     ofLocalVariableDeclaration(node: tree.LocalVariableDeclaration): e.LocalVariableEntity;
     ofEnumerationVariableDeclaration(node: tree.EnumerationVariableDeclaration): e.LocalVariableEntity;
     ofErrorVariableDeclaration(node: tree.ErrorVariableDeclaration): e.LocalVariableEntity;
     ofParameterDeclaration(node: tree.ParameterDeclaration): e.ParameterVariableEntity;
     ofTypeParameterDeclaration(node: tree.TypeParameterDeclaration): e.TypeParameterEntity;
-    ofTypeIndexerDeclaration(node: TypeIndexedAccessorDeclaration): e.SourceIndexerEntity;
-    ofTypeDereferenceOperatorDeclaration(node: TypeDereferencedVariableAccessorDeclaration): e.DereferenceOperatorEntity;
+    ofIndexerDeclaration(node: IndexedElementAccessorDeclaration): e.SourceIndexerEntity;
+    ofDereferenceOperatorDeclaration(node: DereferencedVariableAccessorDeclaration): e.DereferenceOperatorEntity;
     ofPackageStructuredTypeDeclaration(node: tree.PackageStructuredTypeDeclaration): e.PackageStructuredTypeEntity;
     ofAnonymousStructuredTypeDeclaration(node: tree.AnonymousStructuredTypeDeclaration): e.AnonymousStructuredTypeEntity;
     ofStructuredTypeDeclaration(node: StructuredTypeDeclaration): e.StructuredTypeEntity;
-    ofPackageMethodTypeDeclaration(node: tree.PackageMethodTypeDeclaration): e.PackageMethodTypeEntity;
-    ofAnonymousMethodTypeDeclaration(node: tree.AnonymousMethodTypeDeclaration): e.AnonymousMethodTypeEntity;
-    ofMethodTypeDeclaration(node: MethodTypeDeclaration): e.MethodTypeEntity;
+    ofPackageFunctionTypeDeclaration(node: tree.PackageFunctionTypeDeclaration): e.PackageFunctionTypeEntity;
+    ofAnonymousFunctionTypeDeclaration(node: tree.AnonymousFunctionTypeDeclaration): e.AnonymousFunctionTypeEntity;
+    ofFunctionTypeDeclaration(node: FunctionTypeDeclaration): e.FunctionTypeEntity;
     ofPackageVariantTypeDeclaration(node: tree.PackageVariantTypeDeclaration): e.PackageVariantTypeEntity;
     ofAnonymousVariantTypeDeclaration(node: tree.AnonymousVariantTypeDeclaration): e.AnonymousVariantTypeEntity;
     ofVariantTypeDeclaration(node: VariantTypeDeclaration): e.VariantTypeEntity;
     ofPackageAliasTypeDeclaration(node: tree.PackageAliasTypeDeclaration): e.AliasTypeEntity;
-    ofPackageMethodDeclaration(node: tree.PackageMethodDeclaration): e.PackageMethodEntity;
-    ofTypeMethodDeclaration(node: tree.TypeMethodDeclaration): e.TypeMethodEntity;
-    ofNestedMethodDeclaration(node: tree.NestedMethodDeclaration): e.NestedMethodEntity;
+    ofPackageFunctionDeclaration(node: tree.PackageFunctionDeclaration): e.PackageFunctionEntity;
+    ofMethodDeclaration(node: tree.MethodDeclaration): e.MethodEntity;
+    ofNestedFunctionDeclaration(node: tree.NestedFunctionDeclaration): e.NestedFunctionEntity;
     ofOperatorDeclaration(node: tree.OperatorDeclaration): e.OperatorEntity;
     ofPackageVariableGetterDeclaration(node: tree.PackageVariableGetterDeclaration): e.GetterEntity;
-    ofTypeVariableGetterDeclaration(node: tree.TypeVariableGetterDeclaration): e.GetterEntity;
-    ofTypeIndexedGetterDeclaration(node: tree.TypeIndexedGetterDeclaration): e.GetterEntity;
-    ofTypeDereferencedVariableGetterDeclaration(node: tree.TypeDereferencedVariableGetterDeclaration): e.GetterEntity;
+    ofFieldGetterDeclaration(node: tree.FieldGetterDeclaration): e.GetterEntity;
+    ofIndexedElementGetterDeclaration(node: tree.IndexedElementGetterDeclaration): e.GetterEntity;
+    ofDereferencedVariableGetterDeclaration(node: tree.DereferencedVariableGetterDeclaration): e.GetterEntity;
     ofGetterDeclaration(node: GetterDeclaration): e.GetterEntity;
     ofPackageVariableSetterDeclaration(node: tree.PackageVariableSetterDeclaration): e.SetterEntity;
-    ofTypeVariableSetterDeclaration(node: tree.TypeVariableSetterDeclaration): e.SetterEntity;
-    ofTypeIndexedSetterDeclaration(node: tree.TypeIndexedSetterDeclaration): e.SetterEntity;
-    ofTypeDereferencedVariableSetterDeclaration(node: tree.TypeDereferencedVariableSetterDeclaration): e.SetterEntity;
+    ofFieldSetterDeclaration(node: tree.FieldSetterDeclaration): e.SetterEntity;
+    ofIndexedElementSetterDeclaration(node: tree.IndexedElementSetterDeclaration): e.SetterEntity;
+    ofDereferencedVariableSetterDeclaration(node: tree.DereferencedVariableSetterDeclaration): e.SetterEntity;
     ofSetterDeclaration(node: SetterDeclaration): e.SetterEntity;
-    ofTypeConstructorDeclaration(node: tree.TypeConstructorDeclaration): e.ConstructorEntity;
-    ofTypeDestructorDeclaration(node: tree.TypeDestructorDeclaration): e.DestructorEntity;
-    ofVariantDeclaration(node: tree.VariantDeclaration): e.TypeVariableEntity;
+    ofConstructorDeclaration(node: tree.ConstructorDeclaration): e.ConstructorEntity;
+    ofDestructorDeclaration(node: tree.DestructorDeclaration): e.DestructorEntity;
+    ofVariantDeclaration(node: tree.VariantDeclaration): e.FieldEntity;
     ofTypeExtensionDeclaration(node: tree.TypeExtensionDeclaration): e.TypeExtensionEntity;
     ofPackageImport(node: tree.PackageImport): e.PackageAliasEntity;
     private getContainingPackageLoadedFromDts;
-    private createComputedTypeVariableEntities;
-    private createTypeDereferenceOperatorEntities;
-    private createTypeIndexerEntities;
-    private areTypeIndexedAccessorDeclarationsEqual;
+    private createComputedFieldEntities;
+    private createDereferenceOperatorEntities;
+    private createIndexerEntities;
+    private areIndexedElementAccessorDeclarationsEqual;
 }
 type EntityClassMembers = Entity[keyof Entity];
 type GetNodesFromMethodsParameter<T> = T extends (node: infer TNode) => e.Entity ? (TNode extends tree.Node ? TNode : never) : never;
@@ -436,16 +436,16 @@ declare class ResultLocalVariableEntity {
     private readonly _analyzer;
     private readonly _entities;
     constructor(_analyzer: Analyzer);
-    ofPackageMethodDeclaration(node: tree.PackageMethodDeclaration): e.LocalVariableEntity;
-    ofTypeMethodDeclaration(node: tree.TypeMethodDeclaration): e.LocalVariableEntity;
-    ofNestedMethodDeclaration(node: tree.NestedMethodDeclaration): e.LocalVariableEntity;
-    ofMethodLiteral(node: tree.MethodLiteral): e.LocalVariableEntity;
-    ofMethodBlockLiteral(node: tree.MethodBlockLiteral): e.LocalVariableEntity;
+    ofPackageFunctionDeclaration(node: tree.PackageFunctionDeclaration): e.LocalVariableEntity;
+    ofMethodDeclaration(node: tree.MethodDeclaration): e.LocalVariableEntity;
+    ofNestedFunctionDeclaration(node: tree.NestedFunctionDeclaration): e.LocalVariableEntity;
+    ofFunctionLiteral(node: tree.FunctionLiteral): e.LocalVariableEntity;
+    ofFunctionBlockLiteral(node: tree.FunctionBlockLiteral): e.LocalVariableEntity;
     ofOperatorDeclaration(node: tree.OperatorDeclaration): e.LocalVariableEntity;
     ofPackageVariableGetterDeclaration(node: tree.PackageVariableGetterDeclaration): e.LocalVariableEntity;
-    ofTypeVariableGetterDeclaration(node: tree.TypeVariableGetterDeclaration): e.LocalVariableEntity;
-    ofTypeIndexedGetterDeclaration(node: tree.TypeIndexedGetterDeclaration): e.LocalVariableEntity;
-    ofTypeDereferencedVariableGetterDeclaration(node: tree.TypeDereferencedVariableGetterDeclaration): e.LocalVariableEntity;
+    ofFieldGetterDeclaration(node: tree.FieldGetterDeclaration): e.LocalVariableEntity;
+    ofIndexedElementGetterDeclaration(node: tree.IndexedElementGetterDeclaration): e.LocalVariableEntity;
+    ofDereferencedVariableGetterDeclaration(node: tree.DereferencedVariableGetterDeclaration): e.LocalVariableEntity;
     private createResultLocalVariableEntity;
 }
 declare class ValueLocalVariableEntity {
@@ -453,64 +453,64 @@ declare class ValueLocalVariableEntity {
     private readonly _entities;
     constructor(_analyzer: Analyzer);
     ofPackageVariableSetterDeclaration(node: tree.PackageVariableSetterDeclaration): e.VariableEntity;
-    ofTypeVariableSetterDeclaration(node: tree.TypeVariableSetterDeclaration): e.VariableEntity;
-    ofTypeIndexedSetterDeclaration(node: tree.TypeIndexedSetterDeclaration): e.VariableEntity;
-    ofTypeDereferencedVariableSetterDeclaration(node: tree.TypeDereferencedVariableSetterDeclaration): e.VariableEntity;
+    ofFieldSetterDeclaration(node: tree.FieldSetterDeclaration): e.VariableEntity;
+    ofIndexedElementSetterDeclaration(node: tree.IndexedElementSetterDeclaration): e.VariableEntity;
+    ofDereferencedVariableSetterDeclaration(node: tree.DereferencedVariableSetterDeclaration): e.VariableEntity;
 }
 declare class Scope {
     private readonly _analyzer;
     private readonly _sourceFileScopes;
-    private readonly _methodBlockLiteralScopes;
-    private readonly _packageMethodDeclarationTypeParametersScopes;
-    private readonly _packageMethodDeclarationValueParametersScopes;
-    private readonly _structuredTypeMethodDeclarationTypeParametersScopes;
-    private readonly _structuredTypeMethodDeclarationValueParametersScopes;
-    private readonly _nestedMethodDeclarationTypeParametersScopes;
-    private readonly _nestedMethodDeclarationValueParametersScopes;
-    private readonly _methodLiteralScopes;
+    private readonly _functionBlockLiteralScopes;
+    private readonly _packageFunctionDeclarationTypeParametersScopes;
+    private readonly _packageFunctionDeclarationValueParametersScopes;
+    private readonly _structuredMethodDeclarationTypeParametersScopes;
+    private readonly _structuredMethodDeclarationValueParametersScopes;
+    private readonly _nestedFunctionDeclarationTypeParametersScopes;
+    private readonly _nestedFunctionDeclarationValueParametersScopes;
+    private readonly _functionLiteralScopes;
     private readonly _functionBlockScopes;
     private readonly _statementBlockScopes;
     private readonly _forEachStatementScopes;
     private readonly _catchClauseScopes;
     private readonly _packageStructuredTypeDeclarationTypeParametersScopes;
     private readonly _structuredTypeDeclarationBodyScopes;
-    private readonly _packageMethodTypeDeclarationTypeParametersScopes;
-    private readonly _methodTypeDeclarationBodyScopes;
+    private readonly _packageFunctionTypeDeclarationTypeParametersScopes;
+    private readonly _functionTypeDeclarationBodyScopes;
     private readonly _packageVariantTypeDeclarationTypeParametersScopes;
     private readonly _variantTypeDeclarationBodyScopes;
     private readonly _aliasTypeDeclarationBodyScopes;
     private readonly _packageAliasTypeDeclarationTypeParametersScopes;
     private readonly _operatorDeclarationScopes;
-    private readonly _structuredTypeConstructorDeclarationScopes;
-    private readonly _structuredTypeDestructorDeclarationScopes;
-    private readonly _typeIndexedAccessorDeclarationParametersScopes;
+    private readonly _structuredConstructorDeclarationScopes;
+    private readonly _structuredDestructorDeclarationScopes;
+    private readonly _indexedElementAccessorDeclarationParametersScopes;
     private readonly _typeExtensionDeclarationScopes;
     constructor(_analyzer: Analyzer);
     ofSourceFile(node: tree.SourceFile): scope.IScope;
-    ofMethodBlockLiteral(node: tree.MethodBlockLiteral): scope.IScope;
-    ofPackageMethodDeclarationTypeParameters(node: tree.PackageMethodDeclaration): scope.IScope;
-    ofPackageMethodDeclarationValueParameters(node: tree.PackageMethodDeclaration): scope.IScope;
-    ofTypeMethodDeclarationTypeParameters(node: tree.TypeMethodDeclaration): scope.IScope;
-    ofTypeMethodDeclarationValueParameters(node: tree.TypeMethodDeclaration): scope.IScope;
-    ofNestedMethodDeclarationTypeParameters(node: tree.NestedMethodDeclaration): scope.IScope;
-    ofNestedMethodDeclarationValueParameters(node: tree.NestedMethodDeclaration): scope.IScope;
-    ofMethodLiteral(node: tree.MethodLiteral): scope.IScope;
+    ofFunctionBlockLiteral(node: tree.FunctionBlockLiteral): scope.IScope;
+    ofPackageFunctionDeclarationTypeParameters(node: tree.PackageFunctionDeclaration): scope.IScope;
+    ofPackageFunctionDeclarationValueParameters(node: tree.PackageFunctionDeclaration): scope.IScope;
+    ofMethodDeclarationTypeParameters(node: tree.MethodDeclaration): scope.IScope;
+    ofMethodDeclarationValueParameters(node: tree.MethodDeclaration): scope.IScope;
+    ofNestedFunctionDeclarationTypeParameters(node: tree.NestedFunctionDeclaration): scope.IScope;
+    ofNestedFunctionDeclarationValueParameters(node: tree.NestedFunctionDeclaration): scope.IScope;
+    ofFunctionLiteral(node: tree.FunctionLiteral): scope.IScope;
     ofFunctionBlock(node: tree.FunctionBlock): scope.IScope;
     ofStatementBlock(node: tree.StatementBlock): scope.IScope;
     ofForStatement(node: tree.ForStatement): scope.IScope;
     ofCatchClause(node: tree.CatchClause): scope.IScope;
     ofPackageStructuredTypeDeclarationTypeParameters(node: tree.PackageStructuredTypeDeclaration): scope.IScope;
     ofStructuredTypeDeclarationBody(node: tree.StructuredTypeDeclarationBody): scope.IScope;
-    ofPackageMethodTypeDeclarationTypeParameters(node: tree.PackageMethodTypeDeclaration): scope.IScope;
-    ofMethodTypeDeclarationBody(node: tree.MethodTypeDeclarationBody): scope.IScope;
+    ofPackageFunctionTypeDeclarationTypeParameters(node: tree.PackageFunctionTypeDeclaration): scope.IScope;
+    ofFunctionTypeDeclarationBody(node: tree.FunctionTypeDeclarationBody): scope.IScope;
     ofPackageVariantTypeDeclarationTypeParameters(node: tree.PackageVariantTypeDeclaration): scope.IScope;
     ofVariantTypeDeclarationBody(node: tree.VariantTypeDeclarationBody): scope.IScope;
     ofAliasTypeDeclarationBody(node: tree.AliasTypeDeclarationBody): scope.IScope;
     ofPackageAliasTypeDeclarationTypeParameters(node: tree.PackageAliasTypeDeclaration): scope.IScope;
     ofOperatorDeclaration(node: tree.OperatorDeclaration): scope.IScope;
-    ofTypeConstructorDeclaration(node: tree.TypeConstructorDeclaration): scope.IScope;
-    ofTypeDestructorDeclaration(node: tree.TypeDestructorDeclaration): scope.IScope;
-    ofTypeIndexedAccessorDeclarationParameters(node: TypeIndexedAccessorDeclaration): scope.IScope;
+    ofConstructorDeclaration(node: tree.ConstructorDeclaration): scope.IScope;
+    ofDestructorDeclaration(node: tree.DestructorDeclaration): scope.IScope;
+    ofIndexedElementAccessorDeclarationParameters(node: IndexedElementAccessorDeclaration): scope.IScope;
     ofTypeExtensionDeclaration(node: tree.TypeExtensionDeclaration): scope.IScope;
 }
 declare class DefaultConstructors {
@@ -524,11 +524,11 @@ declare class DefaultConstructors {
 declare class OverriddenMember {
     private readonly _analyzer;
     constructor(_analyzer: Analyzer);
-    getOverriddenVariables(node: tree.TypeVariableDeclaration | TypeVariableAccessorDeclaration): types.Variable[];
-    getOverriddenMethods(node: tree.TypeMethodDeclaration): types.Method[];
+    getOverriddenVariables(node: tree.FieldDeclaration | FieldAccessorDeclaration): types.Variable[];
+    getOverriddenMethods(node: tree.MethodDeclaration): types.Method[];
     getOverriddenOperators(node: tree.OperatorDeclaration): types.Operator[];
-    getOverriddenIndexers(node: TypeIndexedAccessorDeclaration): types.Indexer[];
-    getOverriddenDereferenceOperators(node: TypeDereferencedVariableAccessorDeclaration): types.DereferenceOperator[];
+    getOverriddenIndexers(node: IndexedElementAccessorDeclaration): types.Indexer[];
+    getOverriddenDereferenceOperators(node: DereferencedVariableAccessorDeclaration): types.DereferenceOperator[];
     private findOverriddenVariableInType;
     private findOverriddenMethodInType;
     private findOverriddenOperatorInType;
@@ -561,9 +561,9 @@ declare class LinkedEntity {
     ofTypeWithMembers(entity: e.TypeEntityWithMembers, platform: PlatformKind): e.TypeEntityWithMembers | undefined;
     ofParameterType(entity: e.TypeParameterEntity, platform: PlatformKind): e.TypeParameterEntity | undefined;
     ofPackageVariable(entity: e.PackageVariableEntity, platform: PlatformKind): e.PackageVariableEntity | undefined;
-    ofPackageMethod(entity: e.PackageMethodEntity, platform: PlatformKind): e.PackageMethodEntity | undefined;
-    ofTypeVariable(entity: e.TypeVariableEntity, platform: PlatformKind): e.TypeVariableEntity | undefined;
-    ofTypeMethod(entity: e.TypeMethodEntity, platform: PlatformKind): e.TypeMethodEntity | undefined;
+    ofPackageFunction(entity: e.PackageFunctionEntity, platform: PlatformKind): e.PackageFunctionEntity | undefined;
+    ofField(entity: e.FieldEntity, platform: PlatformKind): e.FieldEntity | undefined;
+    ofMethod(entity: e.MethodEntity, platform: PlatformKind): e.MethodEntity | undefined;
     ofOperator(entity: e.OperatorEntity, platform: PlatformKind): e.OperatorEntity | undefined;
     ofConstructor(entity: e.ConstructorEntity, platform: PlatformKind): e.ConstructorEntity | undefined;
     ofIndexer(entity: e.IndexerEntity, platform: PlatformKind): e.IndexerEntity | undefined;
@@ -582,7 +582,7 @@ export declare class LinkedMultiPlatformPackage {
     private get memberLookup();
     constructor(analyzer: Analyzer, pkg: e.PackageEntity, implementationPackage: e.PackageEntity, targetPlatform: PlatformKind);
     getLinkedVariable(entity: e.PackageVariableEntity): e.PackageVariableEntity | undefined;
-    getLinkedMethod(entity: e.PackageMethodEntity): e.PackageMethodEntity | undefined;
+    getLinkedMethod(entity: e.PackageFunctionEntity): e.PackageFunctionEntity | undefined;
     getLinkedTypeWithMembers(entity: e.TypeEntityWithMembers): LinkedTypeWithMembers | undefined;
     getLinkedParameterType(entity: e.TypeParameterEntity): e.TypeParameterEntity | undefined;
     /**
@@ -602,8 +602,8 @@ export declare class LinkedTypeWithMembers {
     private readonly _memberLookup;
     private get memberLookup();
     constructor(analyzer: Analyzer, externalType: e.TypeEntityWithMembers, targetType: e.TypeEntityWithMembers, linkedPackage: LinkedMultiPlatformPackage);
-    getLinkedVariable(entity: e.TypeVariableEntity): e.TypeVariableEntity | undefined;
-    getLinkedMethod(entity: e.TypeMethodEntity): e.TypeMethodEntity | undefined;
+    getLinkedVariable(entity: e.FieldEntity): e.FieldEntity | undefined;
+    getLinkedMethod(entity: e.MethodEntity): e.MethodEntity | undefined;
     getLinkedOperator(entity: e.OperatorEntity): e.OperatorEntity | undefined;
     getLinkedConstructor(entity: e.ConstructorEntity): e.ConstructorEntity | undefined;
     getLinkedIndexer(entity: e.IndexerEntity): e.IndexerEntity | undefined;
@@ -622,7 +622,7 @@ export declare enum TypeAssignabilityFlags {
     NotAssignable = 0,
     Identity = 1,
     DerivedToBase = 2,
-    MethodTypes = 4,
+    FunctionTypes = 4,
     ImplicitConversion = 8,
     First = 1,
     Last = 8
@@ -658,11 +658,20 @@ export declare class PackageImportInfo {
     readonly isAliasedImport: e.PackageAliasEntity | undefined;
     constructor(entity: e.PackageEntity, translationPackage: AnalyzedTranslationPackage | undefined, isAliasedImport: e.PackageAliasEntity | undefined);
 }
-export declare class ExpressionDenotesMethodCheckResult {
-    readonly candidates: readonly WithLocalization<AccessedMethod>[];
-    readonly suitableMethods: readonly WithLocalization<AccessedMethod>[];
-    get singleSuitableMethod(): WithLocalization<AccessedMethod> | undefined;
-    constructor(candidates: readonly WithLocalization<AccessedMethod>[], suitableMethods: readonly WithLocalization<AccessedMethod>[]);
+export declare class TypeUtils {
+    private readonly _analyzer;
+    constructor(_analyzer: Analyzer);
+    getCommonObjectAndAspectTypesOfUnion(unionType: types.UnionType): readonly types.StructuredType[];
+    private getTypesForCommonTypesSearch;
+    private addTypeAndCollectAllBaseTypes;
+    private addTypeIfUnique;
+    private removeBaseTypes;
+}
+export declare class ExpressionDenotesFunctionCheckResult {
+    readonly candidates: readonly WithLocalization<AccessedFunction>[];
+    readonly suitableFunctions: readonly WithLocalization<AccessedFunction>[];
+    get singleSuitableFunction(): WithLocalization<AccessedFunction> | undefined;
+    constructor(candidates: readonly WithLocalization<AccessedFunction>[], suitableFunctions: readonly WithLocalization<AccessedFunction>[]);
 }
 export declare class ExpressionDenotesOperatorCheckResult {
     readonly candidates: readonly WithLocalization<types.Operator>[];
@@ -699,14 +708,14 @@ declare namespace AvailablePackage {
     export {};
 }
 export declare class DeclaredTypeMemberEntities {
-    readonly variables: readonly e.TypeVariableEntity[];
-    readonly methods: readonly e.TypeMethodEntity[];
+    readonly variables: readonly e.FieldEntity[];
+    readonly methods: readonly e.MethodEntity[];
     readonly operators: readonly e.OperatorEntity[];
     readonly constructors: readonly e.ConstructorEntity[];
     readonly destructors: readonly e.DestructorEntity[];
     readonly indexers: readonly e.SourceIndexerEntity[];
     readonly dereferenceOperators: readonly e.DereferenceOperatorEntity[];
     get namedMembers(): NamedTypeMemberEntity[];
-    constructor(variables: readonly e.TypeVariableEntity[], methods: readonly e.TypeMethodEntity[], operators: readonly e.OperatorEntity[], constructors: readonly e.ConstructorEntity[], destructors: readonly e.DestructorEntity[], indexers: readonly e.SourceIndexerEntity[], dereferenceOperators: readonly e.DereferenceOperatorEntity[]);
+    constructor(variables: readonly e.FieldEntity[], methods: readonly e.MethodEntity[], operators: readonly e.OperatorEntity[], constructors: readonly e.ConstructorEntity[], destructors: readonly e.DestructorEntity[], indexers: readonly e.SourceIndexerEntity[], dereferenceOperators: readonly e.DereferenceOperatorEntity[]);
 }
 export {};

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

@@ -1,7 +1,7 @@
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import { CallExpression } from '../tree/index.js';
 import * as types from '../types/index.js';
-import { AccessedMethod } from './AccessedMethod.js';
+import { AccessedFunction } from './AccessedFunction.js';
 import { FoundAnonymousDeclaration } from './FoundDeclaration.js';
 import { WithLocalization } from './Localization.js';
 import { Analyzer } from './index.js';
@@ -14,21 +14,21 @@ export declare class Resolver {
     private resolveConstructorCallExpressionMeaning;
     private getNodeForDiagnostics;
 }
-export type Meaning = Meaning_methodCall | Meaning_operatorCall | Meaning_objectMethodCall | Meaning_constructorCall | Meaning_unresolved;
-declare class Meaning_methodCall {
-    readonly method: WithLocalization<AccessedMethod>;
-    readonly kind = "method-call";
-    constructor(method: WithLocalization<AccessedMethod>);
+export type Meaning = Meaning_functionCall | Meaning_operatorCall | Meaning_objectFunctionCall | Meaning_constructorCall | Meaning_unresolved;
+declare class Meaning_functionCall {
+    readonly func: WithLocalization<AccessedFunction>;
+    readonly kind = "function-call";
+    constructor(func: WithLocalization<AccessedFunction>);
 }
 declare class Meaning_operatorCall {
     readonly operator: WithLocalization<types.Operator>;
     readonly kind = "operator-call";
     constructor(operator: WithLocalization<types.Operator>);
 }
-declare class Meaning_objectMethodCall {
-    readonly type: types.MethodType;
-    readonly kind = "object-method-call";
-    constructor(type: types.MethodType);
+declare class Meaning_objectFunctionCall {
+    readonly type: types.FunctionType;
+    readonly kind = "object-function-call";
+    constructor(type: types.FunctionType);
 }
 declare class Meaning_constructorCall {
     /**