@artel/artc 0.6.25223 → 0.6.25225

package/build/types/services/DisplayService.d.ts

@@ -1,7 +1,8 @@
-import { AccessedMethod } from '../analysis/AccessedMethod.js';
+import { AccessedFunction } from '../analysis/AccessedFunction.js';
+import { PackageNameTreeNode } from '../analysis/ImportedPackageNameTree.js';
 import { Localization } from '../analysis/Localization.js';
 import { LocalizationContext, NamedEntity } from '../analysis/LocalizationContext.js';
-import { SubstitutedMethod } from '../analysis/SubstitutedMethod.js';
+import { SubstitutedFunction } from '../analysis/SubstitutedFunction.js';
 import { Analyzer } from '../analysis/index.js';
 import { HelperPhraseKind } from '../common/HelperPhrases.js';
 import { PackageDialect, PackageLocale } from '../common/index.js';
@@ -15,14 +16,15 @@ export declare class DisplayService {
     constructor(_analyzer: Analyzer | undefined, _lctxOrLocale: LocalizationContext | PackageLocale, _dialect?: PackageDialect | undefined);
     displayVariableDeclaration(variable: VariableDeclaration): string;
     displayType(type: types.Type): string;
-    getMethodTypeBodyDisplayParts(type: types.MethodType): MethodTypeBodyDisplayParts;
+    getFunctionTypeBodyDisplayParts(type: types.FunctionType): FunctionTypeBodyDisplayParts;
     getNamedTypeDisplayParts(type: NamedType): NamedTypeDisplayParts;
     displayPackageAliasEntity(entity: e.PackageAliasEntity): string;
     displayPackage(package_: e.PackageEntity): string;
+    displayPackageNameTreeNode(node: PackageNameTreeNode): string;
     displayValueParameterDeclaration(parameter: ValueParameterDeclaration, typeDisplayOptions?: TypeDisplayOptions): string;
     getValueParameterDeclarationDisplayParts(parameter: ValueParameterDeclaration, typeDisplayOptions?: TypeDisplayOptions): ValueParameterDeclarationDisplayParts;
-    displayMethodDeclaration(method: MethodDeclaration): string;
-    getMethodDeclarationDisplayParts(method: MethodDeclaration): MethodDeclarationDisplayParts;
+    displayFunctionDeclaration(func: FunctionDeclaration): string;
+    getFunctionDeclarationDisplayParts(func: FunctionDeclaration): FunctionDeclarationDisplayParts;
     displayOperatorDeclaration(operator: OperatorDeclaration): string;
     getOperatorDeclarationDisplayParts(operator: OperatorDeclaration): OperatorDeclarationDisplayParts;
     displayOperatorKind(kind: e.OperatorKind, locale: PackageLocale): string;
@@ -49,20 +51,20 @@ export declare class DisplayService {
     private displayTypeEntityAsUsage;
     private displayStructuredTypeUsage;
     private displayVariantTypeUsage;
-    private displayMethodTypeUsage;
+    private displayFunctionTypeUsage;
     private displayParameterTypeUsage;
     private displayAliasTypeUsage;
-    private displayUnionTypeUsage;
+    private displayUnionOrIntersectionTypeUsage;
     private displayUnresolvedTypeUsage;
     private displayTypeInternal;
     private displayTypeUsageInternal;
-    private displayUnionTypeTypes;
+    private displayUnionOrIntersectionTypeTypes;
     private displayDeclarationContainer;
     private getEntityName;
 }
 interface TypeDisplayOptions {
     readonly unionAndAliasTypeDisplayKind: UnionAndAliasTypeDisplayKind;
-    readonly displayFullVersionOfNamedMethodType: boolean;
+    readonly displayFullVersionOfNamedFunctionType: boolean;
     readonly displayContainer: boolean;
 }
 declare const enum UnionAndAliasTypeDisplayKind {
@@ -102,15 +104,15 @@ interface IVariableDeclaration {
     isOptionalParameter(): boolean;
     getContainer(analyzer: Analyzer | undefined): DeclarationContainer | undefined;
 }
-export type MethodDeclaration = MethodDeclaration_entity | MethodDeclaration_typeMember | MethodDeclaration_substitutedMethod | MethodDeclaration_accessedMethod;
-export declare class MethodDeclaration_entity implements IMethodDeclaration {
+export type FunctionDeclaration = FunctionDeclaration_entity | FunctionDeclaration_typeMember | FunctionDeclaration_substitutedFunction | FunctionDeclaration_accessedFunction;
+export declare class FunctionDeclaration_entity implements IFunctionDeclaration {
     readonly kind = "entity";
     private readonly _typeParameterValues;
     private readonly _valueParameters;
-    readonly method: e.MethodEntity;
+    readonly func: e.FunctionEntity;
     readonly localization: Localization;
-    constructor(method: e.MethodEntity, localization: Localization);
-    getEntity(): e.MethodEntity;
+    constructor(func: e.FunctionEntity, localization: Localization);
+    getEntity(): e.FunctionEntity;
     getLocalization(): Localization;
     getTypeParameterValues(): readonly TypeParameterValue[];
     getValueParameters(): readonly ValueParameterDeclaration[];
@@ -118,14 +120,14 @@ export declare class MethodDeclaration_entity implements IMethodDeclaration {
     isAsync(): boolean;
     getContainer(): DeclarationContainer | undefined;
 }
-export declare class MethodDeclaration_typeMember implements IMethodDeclaration {
+export declare class FunctionDeclaration_typeMember implements IFunctionDeclaration {
     readonly kind = "type-member";
     private readonly _typeParameterValues;
     private readonly _valueParameters;
-    readonly method: types.Method;
+    readonly func: types.Method;
     readonly localization: Localization;
-    constructor(method: types.Method, localization: Localization);
-    getEntity(): e.MethodEntity;
+    constructor(func: types.Method, localization: Localization);
+    getEntity(): e.FunctionEntity;
     getLocalization(): Localization;
     getTypeParameterValues(): readonly TypeParameterValue[];
     getValueParameters(): readonly ValueParameterDeclaration[];
@@ -133,14 +135,14 @@ export declare class MethodDeclaration_typeMember implements IMethodDeclaration
     isAsync(): boolean;
     getContainer(analyzer: Analyzer | undefined): DeclarationContainer | undefined;
 }
-export declare class MethodDeclaration_substitutedMethod implements IMethodDeclaration {
-    readonly method: SubstitutedMethod;
+export declare class FunctionDeclaration_substitutedFunction implements IFunctionDeclaration {
+    readonly func: SubstitutedFunction;
     readonly localization: Localization;
-    readonly kind = "substituted-method";
+    readonly kind = "substituted-function";
     private readonly _typeParameterValues;
     private readonly _valueParameters;
-    constructor(method: SubstitutedMethod, localization: Localization);
-    getEntity(): e.MethodEntity;
+    constructor(func: SubstitutedFunction, localization: Localization);
+    getEntity(): e.FunctionEntity;
     getLocalization(): Localization;
     getTypeParameterValues(): readonly TypeParameterValue[];
     getValueParameters(): readonly ValueParameterDeclaration[];
@@ -148,14 +150,14 @@ export declare class MethodDeclaration_substitutedMethod implements IMethodDecla
     isAsync(): boolean;
     getContainer(analyzer: Analyzer | undefined): DeclarationContainer | undefined;
 }
-export declare class MethodDeclaration_accessedMethod implements IMethodDeclaration {
-    readonly method: AccessedMethod;
+export declare class FunctionDeclaration_accessedFunction implements IFunctionDeclaration {
+    readonly func: AccessedFunction;
     readonly localization: Localization;
-    readonly kind = "accessed-method";
+    readonly kind = "accessed-function";
     private readonly _typeParameterValues;
     private readonly _valueParameters;
-    constructor(method: AccessedMethod, localization: Localization);
-    getEntity(): e.MethodEntity;
+    constructor(func: AccessedFunction, localization: Localization);
+    getEntity(): e.FunctionEntity;
     getLocalization(): Localization;
     getTypeParameterValues(): readonly TypeParameterValue[];
     getValueParameters(): readonly ValueParameterDeclaration[];
@@ -163,8 +165,8 @@ export declare class MethodDeclaration_accessedMethod implements IMethodDeclarat
     isAsync(): boolean;
     getContainer(analyzer: Analyzer | undefined): DeclarationContainer | undefined;
 }
-interface IMethodDeclaration {
-    getEntity(): e.MethodEntity;
+interface IFunctionDeclaration {
+    getEntity(): e.FunctionEntity;
     getLocalization(): Localization;
     getTypeParameterValues(): readonly TypeParameterValue[];
     getValueParameters(): readonly ValueParameterDeclaration[];
@@ -260,7 +262,7 @@ interface IIndexerDeclaration {
     getType(): types.Type;
     getContainer(analyzer: Analyzer | undefined): DeclarationContainer | undefined;
 }
-export type ValueParameterDeclaration = ValueParameterDeclaration_entity | ValueParameterDeclaration_typeMember | ValueParameterDeclaration_substitutedMethod | ValueParameterDeclaration_matchResultValueParameter | ValueParameterDeclaration_universal;
+export type ValueParameterDeclaration = ValueParameterDeclaration_entity | ValueParameterDeclaration_typeMember | ValueParameterDeclaration_substitutedFunction | ValueParameterDeclaration_matchResultValueParameter | ValueParameterDeclaration_universal;
 export declare class ValueParameterDeclaration_entity implements IValueParameter {
     readonly value: e.VariableEntity;
     readonly localization: Localization;
@@ -283,7 +285,7 @@ export declare class ValueParameterDeclaration_typeMember implements IValueParam
     isOptional(): boolean;
     getType(): types.Type;
 }
-export declare class ValueParameterDeclaration_substitutedMethod implements IValueParameter {
+export declare class ValueParameterDeclaration_substitutedFunction implements IValueParameter {
     readonly entity: e.VariableEntity;
     readonly type: types.Type;
     readonly localization: Localization;
@@ -341,7 +343,7 @@ export declare class TypeParameterValue_typeArgument {
     readonly kind = "type-argument";
     constructor(value: types.Type);
 }
-export type TypeDeclaration = TypeDeclaration_structured | TypeDeclaration_method | TypeDeclaration_variant | TypeDeclaration_alias | TypeDeclaration_parameter | TypeDeclaration_unresolved;
+export type TypeDeclaration = TypeDeclaration_structured | TypeDeclaration_function | TypeDeclaration_variant | TypeDeclaration_alias | TypeDeclaration_parameter | TypeDeclaration_unresolved;
 export declare class TypeDeclaration_structured implements ITypeDeclaration {
     readonly value: TypeDeclarationStructured;
     readonly kind = "structured";
@@ -389,23 +391,23 @@ interface ITypeDeclarationStructured {
     isAspect(): boolean;
     getContainer(): DeclarationContainer | undefined;
 }
-export declare class TypeDeclaration_method implements ITypeDeclaration {
-    readonly value: TypeDeclarationMethod;
-    readonly kind = "method";
-    constructor(value: TypeDeclarationMethod);
+export declare class TypeDeclaration_function implements ITypeDeclaration {
+    readonly value: TypeDeclarationFunction;
+    readonly kind = "function";
+    constructor(value: TypeDeclarationFunction);
     ifNamedThenEntity(): e.NamedTypeEntity | undefined;
     getLocalization(): Localization;
     getTypeParameterValues(): readonly TypeParameterValue[];
     getContainer(): DeclarationContainer | undefined;
 }
-export type TypeDeclarationMethod = TypeDeclarationMethod_entity | TypeDeclarationMethod_type;
-export declare class TypeDeclarationMethod_entity implements ITypeDeclarationMethod {
-    readonly entity: e.MethodTypeEntity;
+export type TypeDeclarationFunction = TypeDeclarationFunction_entity | TypeDeclarationFunction_type;
+export declare class TypeDeclarationFunction_entity implements ITypeDeclarationFunction {
+    readonly entity: e.FunctionTypeEntity;
     readonly localization: Localization;
     readonly kind = "entity";
     private readonly _typeParameterValues;
     private readonly _valueParameters;
-    constructor(entity: e.MethodTypeEntity, localization: Localization);
+    constructor(entity: e.FunctionTypeEntity, localization: Localization);
     ifNamedThenEntity(): e.NamedTypeEntity | undefined;
     getLocalization(): Localization;
     getTypeParameterValues(): readonly TypeParameterValue[];
@@ -414,13 +416,13 @@ export declare class TypeDeclarationMethod_entity implements ITypeDeclarationMet
     isAsync(): boolean;
     getContainer(): DeclarationContainer | undefined;
 }
-export declare class TypeDeclarationMethod_type implements ITypeDeclarationMethod {
-    readonly type: types.MethodType;
+export declare class TypeDeclarationFunction_type implements ITypeDeclarationFunction {
+    readonly type: types.FunctionType;
     readonly localization: Localization;
     readonly kind = "type";
     private readonly _typeParameterValues;
     private readonly _valueParameters;
-    constructor(type: types.MethodType, localization: Localization);
+    constructor(type: types.FunctionType, localization: Localization);
     ifNamedThenEntity(): e.NamedTypeEntity | undefined;
     getLocalization(): Localization;
     getTypeParameterValues(): readonly TypeParameterValue[];
@@ -429,7 +431,7 @@ export declare class TypeDeclarationMethod_type implements ITypeDeclarationMetho
     isAsync(): boolean;
     getContainer(): DeclarationContainer | undefined;
 }
-interface ITypeDeclarationMethod {
+interface ITypeDeclarationFunction {
     ifNamedThenEntity(): e.NamedTypeEntity | undefined;
     getLocalization(): Localization;
     getTypeParameterValues(): readonly TypeParameterValue[];
@@ -542,11 +544,11 @@ interface ITypeDeclaration {
     getTypeParameterValues(): readonly TypeParameterValue[];
     getContainer(): DeclarationContainer | undefined;
 }
-type NamedType = NamedType_method | NamedType_structured | NamedType_typeParameter | NamedType_variant | NamedType_alias;
-export declare class NamedType_method implements INamedType {
-    readonly value: e.PackageMethodTypeEntity;
-    readonly kind = "method";
-    constructor(value: e.PackageMethodTypeEntity);
+type NamedType = NamedType_function | NamedType_structured | NamedType_typeParameter | NamedType_variant | NamedType_alias;
+export declare class NamedType_function implements INamedType {
+    readonly value: e.PackageFunctionTypeEntity;
+    readonly kind = "function";
+    constructor(value: e.PackageFunctionTypeEntity);
     getEntity(): e.NamedTypeEntity;
     getTypeParameters(): readonly e.TypeParameterEntity[];
 }
@@ -614,7 +616,7 @@ interface IOperatorDeclaration {
     getReturnType(): types.Type;
     getContainer(analyzer: Analyzer | undefined): DeclarationContainer | undefined;
 }
-export type TypeUsage = StructuredTypeUsage | VariantTypeUsage | MethodTypeUsage | AliasTypeUsage | ParameterTypeUsage | UnionTypeUsage | UnresolvedTypeUsage;
+export type TypeUsage = StructuredTypeUsage | VariantTypeUsage | FunctionTypeUsage | AliasTypeUsage | ParameterTypeUsage | UnionOrIntersectionTypeUsage | UnresolvedTypeUsage;
 export type StructuredTypeUsage = StructuredTypeUsage_type | StructuredTypeUsage_entity;
 export declare class StructuredTypeUsage_type implements IStructuredTypeUsage {
     readonly type: types.StructuredType;
@@ -662,11 +664,11 @@ interface IVariantTypeUsage {
     ifNamedThenEntity(): e.NamedTypeEntity | undefined;
     getContainer(): DeclarationContainer | undefined;
 }
-export type MethodTypeUsage = MethodTypeUsage_type | MethodTypeUsage_entity;
-export declare class MethodTypeUsage_type implements IMethodTypeUsage {
-    readonly type: types.MethodType;
-    readonly kind = "method";
-    constructor(type: types.MethodType);
+export type FunctionTypeUsage = FunctionTypeUsage_type | FunctionTypeUsage_entity;
+export declare class FunctionTypeUsage_type implements IFunctionTypeUsage {
+    readonly type: types.FunctionType;
+    readonly kind = "function";
+    constructor(type: types.FunctionType);
     ifNamedThenEntity(): e.NamedTypeEntity | undefined;
     isAsync(): boolean;
     getTypeParameterValues(): readonly TypeParameterValue[];
@@ -674,10 +676,10 @@ export declare class MethodTypeUsage_type implements IMethodTypeUsage {
     getReturnType(): types.Type;
     getContainer(): DeclarationContainer | undefined;
 }
-export declare class MethodTypeUsage_entity implements IMethodTypeUsage {
-    readonly entity: e.MethodTypeEntity;
-    readonly kind = "method";
-    constructor(entity: e.MethodTypeEntity);
+export declare class FunctionTypeUsage_entity implements IFunctionTypeUsage {
+    readonly entity: e.FunctionTypeEntity;
+    readonly kind = "function";
+    constructor(entity: e.FunctionTypeEntity);
     ifNamedThenEntity(): e.NamedTypeEntity | undefined;
     isAsync(): boolean;
     getTypeParameterValues(): readonly TypeParameterValue[];
@@ -685,8 +687,8 @@ export declare class MethodTypeUsage_entity implements IMethodTypeUsage {
     getReturnType(): types.Type;
     getContainer(): DeclarationContainer | undefined;
 }
-interface IMethodTypeUsage {
-    readonly kind: 'method';
+interface IFunctionTypeUsage {
+    readonly kind: 'function';
     ifNamedThenEntity(): e.NamedTypeEntity | undefined;
     isAsync(): boolean;
     getTypeParameterValues(): readonly TypeParameterValue[];
@@ -740,11 +742,12 @@ interface IParameterTypeUsage {
     getEntity(): e.NamedTypeEntity;
     isNoneExcluded(): boolean;
 }
-type UnionTypeUsage = UnionTypeUsage_type;
-declare class UnionTypeUsage_type {
-    readonly type: types.UnionType;
-    readonly kind = "union";
-    constructor(type: types.UnionType);
+type UnionOrIntersectionTypeUsage = UnionOrIntersectionTypeUsage_type;
+declare class UnionOrIntersectionTypeUsage_type {
+    readonly type: types.UnionType | types.IntersectionType;
+    readonly kind = "union-or-intersection";
+    constructor(type: types.UnionType | types.IntersectionType);
+    isUnionType(): boolean;
     getOriginalTypes(): readonly types.Type[];
     getUnaliasedFlattenedTypes(): readonly types.Type[];
 }
@@ -773,7 +776,7 @@ declare namespace DeclarationContainer {
         constructor(entity: e.PackageEntity);
     }
 }
-export declare class MethodDeclarationDisplayParts {
+export declare class FunctionDeclarationDisplayParts {
     readonly asyncKeywordWithWhitespace: string;
     readonly functionKeyword: string;
     readonly whitespaceAfterFunctionKeyword: string;
@@ -864,7 +867,7 @@ export declare class NamedTypeDisplayParts {
     readonly postfix: string;
     constructor(prefix: string, typeParameters: readonly string[], typeParameterSeparator: string, postfix: string);
 }
-export declare class MethodTypeBodyDisplayParts {
+export declare class FunctionTypeBodyDisplayParts {
     readonly asyncKeywordWithWhitespace: string;
     readonly functionKeyword: string;
     readonly valueParametersStart: string;

package/build/types/services/HoverService.d.ts

@@ -6,7 +6,7 @@ export declare class HoverService {
     getHover(analyzer: Analyzer, sourceFile: SourceFile, offset: number): Hover | undefined;
     private createHoverForEntity;
     private createHoverAtReference;
-    private createHoverAtAccessedMethod;
+    private createHoverAtAccessedFunction;
 }
 export declare class Hover {
     private readonly _contents;

package/build/types/services/NodeSemanticInfo.d.ts

@@ -1,10 +1,11 @@
-import { AccessedMethod } from '../analysis/AccessedMethod.js';
+import { AccessedFunction } from '../analysis/AccessedFunction.js';
 import { MatchResultValueParameter } from '../analysis/ArgumentToParameterMatchResult.js';
-import { Translation, WithLocalization } from '../analysis/Localization.js';
-import { TypeIndexedAccessorDeclaration } from '../analysis/NodeTypeUtils.js';
+import { PackageNameTreeNode } from '../analysis/ImportedPackageNameTree.js';
 import { Analyzer } from '../analysis/index.js';
+import { Translation, WithLocalization } from '../analysis/Localization.js';
+import { IndexedElementAccessorDeclaration } from '../analysis/NodeTypeUtils.js';
 import { AccessKind, ReadonlyNonEmptyArray } from '../common/index.js';
-import { AliasTypeEntity, Entity, MethodEntity, MethodTypeEntity, PackageAliasEntity, PackageEntity, StructuredTypeEntity, TypeParameterEntity, VariableEntity, VariantTypeEntity } from '../entities/index.js';
+import { AliasTypeEntity, Entity, FunctionEntity, FunctionTypeEntity, PackageEntity, StructuredTypeEntity, TypeParameterEntity, VariableEntity, VariantTypeEntity } from '../entities/index.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
 import { TokenOrKeyword } from './TreeUtils.js';
@@ -12,18 +13,18 @@ export declare class NodeSemanticInfoService {
     static ofTokenOrKeyword(analyzer: Analyzer, tokenOrKeyword: TokenOrKeyword, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
     static ofDefaultMatchExpression(analyzer: Analyzer, node: tree.DefaultMatchExpression): NodeSemanticInfo | undefined;
     static ofNonKeywordIdentifier(analyzer: Analyzer, node: tree.Identifier, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
-    static ofProperty(analyzer: Analyzer, node: tree.PropertyAccessExpression, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
+    static ofProperty(analyzer: Analyzer, node: tree.MemberAccessExpression, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
     static ofQualifiedNameQualifier(analyzer: Analyzer, node: tree.QualifiedName, qualifier: tree.Identifier, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
     static ofNamedTypeSpecifierNameQualifier(analyzer: Analyzer, node: tree.NamedTypeSpecifier, qualifier: tree.Identifier, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
     static ofTagNameQualifier(analyzer: Analyzer, node: tree.Tag, qualifier: tree.Identifier, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
     static ofIdentifierExpression(analyzer: Analyzer, node: tree.IdentifierExpression, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
-    static ofTypeConstructorDeclaration(analyzer: Analyzer, node: tree.TypeConstructorDeclaration): NodeSemanticInfo;
-    static ofTypeIndexerDeclaration(analyzer: Analyzer, node: TypeIndexedAccessorDeclaration): NodeSemanticInfo;
+    static ofConstructorDeclaration(analyzer: Analyzer, node: tree.ConstructorDeclaration): NodeSemanticInfo;
+    static ofIndexedElementAccessorDeclaration(analyzer: Analyzer, node: IndexedElementAccessorDeclaration): NodeSemanticInfo;
     static ofIndexedAccessExpressionOperator(analyzer: Analyzer, node: tree.IndexedAccessExpression, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
     static ofAssignmentStatementOperator(analyzer: Analyzer, node: tree.AssignmentStatement, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
     static ofBinaryExpressionOperator(analyzer: Analyzer, node: tree.BinaryExpression, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
     static ofPrefixUnaryExpressionOperator(analyzer: Analyzer, node: tree.PrefixUnaryExpression, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
-    static ofDereferenceOperatorDeclaration(analyzer: Analyzer, node: tree.TypeDereferencedVariableGetterDeclaration | tree.TypeDereferencedVariableSetterDeclaration): NodeSemanticInfo | undefined;
+    static ofDereferenceOperatorDeclaration(analyzer: Analyzer, node: tree.DereferencedVariableGetterDeclaration | tree.DereferencedVariableSetterDeclaration): NodeSemanticInfo | undefined;
     static ofDereferenceExpressionOperator(analyzer: Analyzer, node: tree.DereferenceExpression, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
     static ofAutotypeCallExpression(analyzer: Analyzer, node: tree.AutotypeCallExpression, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
     static ofObjectExpression(analyzer: Analyzer, node: tree.ObjectExpression, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
@@ -53,16 +54,15 @@ export declare class ReferenceNodeSemanticInfo {
     get firstBetterTargetWithFallback(): WithLocalization<ReferenceTarget>;
     constructor(targets: ReadonlyNonEmptyArray<WithLocalization<ReferenceTarget>>, isAmbiguous: boolean, betterTargets?: ReadonlyNonEmptyArray<WithLocalization<ReferenceTarget>> | undefined);
 }
-export type ReferenceTarget = EntityReferenceTarget | TypeVariableReferenceTarget | TypeValueParameterReferenceTarget | TypeConstructorReferenceTarget | OperatorReferenceTarget | TypeDereferenceOperatorReferenceTarget | AccessedMethodReferenceTarget | TypeIndexerReferenceTarget | MatchResultValueParameterReferenceTarget | PackageReferenceTarget | TypeContextReferenceTarget;
+export type ReferenceTarget = EntityReferenceTarget | FieldReferenceTarget | TypeValueParameterReferenceTarget | ConstructorReferenceTarget | OperatorReferenceTarget | DereferenceOperatorReferenceTarget | AccessedFunctionReferenceTarget | IndexerReferenceTarget | MatchResultValueParameterReferenceTarget | PackageReferenceTarget | PackageNameTreeNodeReferenceTarget | TypeContextReferenceTarget;
 export declare class EntityReferenceTarget {
-    readonly entity: ReferencedEntity;
+    readonly entity: Entity;
     readonly accessKind: AccessKind;
     readonly narrowedType?: types.Type | undefined;
     readonly kind = "entity";
-    constructor(entity: ReferencedEntity, accessKind: AccessKind, narrowedType?: types.Type | undefined);
+    constructor(entity: Entity, accessKind: AccessKind, narrowedType?: types.Type | undefined);
 }
-export type ReferencedEntity = VariableEntity | VariantTypeEntity | MethodEntity | TypeParameterEntity | MethodTypeEntity | StructuredTypeEntity | PackageAliasEntity | AliasTypeEntity;
-export declare class TypeVariableReferenceTarget {
+export declare class FieldReferenceTarget {
     readonly variable: types.Variable;
     readonly accessKind: AccessKind;
     readonly narrowedType: types.Type | undefined;
@@ -75,21 +75,21 @@ export declare class TypeValueParameterReferenceTarget {
     readonly kind = "type-value-parameter";
     constructor(parameter: types.ValueParameter, accessKind: AccessKind);
 }
-export declare class TypeConstructorReferenceTarget {
+export declare class ConstructorReferenceTarget {
     readonly constructor_: types.Constructor;
     readonly kind = "type-constructor";
     constructor(constructor_: types.Constructor);
 }
-export declare class TypeDereferenceOperatorReferenceTarget {
+export declare class DereferenceOperatorReferenceTarget {
     readonly operator: types.DereferenceOperator;
     readonly accessKind: AccessKind;
     readonly kind = "type-dereference-operator";
     constructor(operator: types.DereferenceOperator, accessKind: AccessKind);
 }
-export declare class AccessedMethodReferenceTarget {
-    readonly method: AccessedMethod;
-    readonly kind = "accessed-method";
-    constructor(method: AccessedMethod);
+export declare class AccessedFunctionReferenceTarget {
+    readonly func: AccessedFunction;
+    readonly kind = "accessed-function";
+    constructor(func: AccessedFunction);
 }
 export declare class OperatorReferenceTarget {
     readonly operator: types.Operator;
@@ -107,13 +107,18 @@ export declare class PackageReferenceTarget {
     readonly kind = "package";
     constructor(package_: PackageEntity);
 }
+export declare class PackageNameTreeNodeReferenceTarget {
+    readonly node: PackageNameTreeNode;
+    readonly kind = "package-name-tree-node";
+    constructor(node: PackageNameTreeNode);
+}
 export declare class TypeContextReferenceTarget {
     readonly type: types.Type;
     readonly typeContextKind: 'object' | 'base';
     readonly kind = "type-context";
     constructor(type: types.Type, typeContextKind: 'object' | 'base');
 }
-export declare class TypeIndexerReferenceTarget {
+export declare class IndexerReferenceTarget {
     readonly indexer: types.Indexer;
     readonly accessKind: AccessKind;
     readonly kind = "type-indexer";
@@ -127,7 +132,7 @@ export declare class NameTranslationNodeSemanticInfo {
     get firstTarget(): TranslationTargetEntity;
     constructor(targets: ReadonlyNonEmptyArray<TranslationTargetEntity>, isAmbiguous: boolean, translation: Translation);
 }
-type TranslationTargetEntity = VariableEntity | VariantTypeEntity | MethodEntity | TypeParameterEntity | MethodTypeEntity | StructuredTypeEntity | AliasTypeEntity;
+type TranslationTargetEntity = VariableEntity | VariantTypeEntity | FunctionEntity | TypeParameterEntity | FunctionTypeEntity | StructuredTypeEntity | AliasTypeEntity;
 export declare class DefaultSwitchMatchNodeSemanticInfo {
     readonly type: types.Type;
     readonly kind = "default-switch-match";

package/build/types/services/SemanticTokensService.d.ts

@@ -5,7 +5,7 @@ export declare class SemanticTokensService {
     getSemanticTokens(analyzer: Analyzer, sourceFile: SourceFile, cancellationToken: CancellationToken | undefined): Promise<SemanticToken[]>;
     getSemanticTokensInRange(analyzer: Analyzer, sourceFile: SourceFile, range: Range, cancellationToken: CancellationToken | undefined): Promise<SemanticToken[]>;
     private rangesOverlap;
-    private getSemanticTokenKindForMethodEntity;
+    private getSemanticTokenKindForFunctionEntity;
     private isCapitalizedName;
 }
 export declare class SemanticToken {
@@ -23,16 +23,16 @@ export declare class SemanticTokenModifiers {
     setCapitalized(value: boolean): this;
 }
 export declare const enum SemanticTokenKind {
-    MethodBlockLiteralParameter = 0,
+    FunctionBlockLiteralParameter = 0,
     SpecialVariable = 1,
     SpecialMethod = 2,
     Variant = 3,
-    PackageMethod = 4,
-    NestedMethod = 5,
-    TypeMethod = 6,
+    PackageFunction = 4,
+    NestedFunction = 5,
+    Method = 6,
     Operator = 7
 }
-export declare const supportedSemanticTokens: readonly [SemanticTokenKind.MethodBlockLiteralParameter, SemanticTokenKind.SpecialVariable, SemanticTokenKind.SpecialMethod, SemanticTokenKind.Variant, SemanticTokenKind.PackageMethod, SemanticTokenKind.NestedMethod, SemanticTokenKind.TypeMethod, SemanticTokenKind.Operator];
+export declare const supportedSemanticTokens: readonly [SemanticTokenKind.FunctionBlockLiteralParameter, SemanticTokenKind.SpecialVariable, SemanticTokenKind.SpecialMethod, SemanticTokenKind.Variant, SemanticTokenKind.PackageFunction, SemanticTokenKind.NestedFunction, SemanticTokenKind.Method, SemanticTokenKind.Operator];
 export declare const enum SemanticTokenModifierFlag {
     Const = 1,
     Declaration = 2,

package/build/types/services/SourceFileItemsService.d.ts

@@ -23,20 +23,20 @@ export declare const enum ItemKind {
     PackageVariable = 1,
     PackageVariableGetter = 2,
     PackageVariableSetter = 3,
-    PackageMethod = 4,
+    PackageFunction = 4,
     StructuredType = 5,
-    MethodType = 6,
+    FunctionType = 6,
     VariantType = 7,
     InvalidType = 8,
     Variant = 9,
-    TypeConstructor = 10,
-    TypeDestructor = 11,
-    TypeVariable = 12,
-    TypeVariableGetter = 13,
-    TypeVariableSetter = 14,
-    TypeMethod = 15,
-    TypeIndexedGetter = 16,
-    TypeIndexedSetter = 17,
+    Constructor = 10,
+    Destructor = 11,
+    Field = 12,
+    FieldGetter = 13,
+    FieldSetter = 14,
+    Method = 15,
+    IndexedElementGetter = 16,
+    IndexedElementSetter = 17,
     TypeParameter = 18,
-    NestedMethod = 19
+    NestedFunction = 19
 }

package/build/types/services/TypeDefinitionService.d.ts

@@ -1,9 +1,9 @@
 import { Analyzer } from '../analysis/index.js';
 import { SourceFile } from '../project/index.js';
-import { AnonymousMethodTypeDeclaration, AnonymousStructuredTypeDeclaration, AnonymousVariantTypeDeclaration, PackageAliasTypeDeclaration, PackageMethodTypeDeclaration, PackageStructuredTypeDeclaration, PackageVariantTypeDeclaration, TypeParameterDeclaration } from '../tree/index.js';
+import { AnonymousFunctionTypeDeclaration, AnonymousStructuredTypeDeclaration, AnonymousVariantTypeDeclaration, PackageAliasTypeDeclaration, PackageFunctionTypeDeclaration, PackageStructuredTypeDeclaration, PackageVariantTypeDeclaration, TypeParameterDeclaration } from '../tree/index.js';
 import { RangeLocation } from './Types.js';
 export declare class TypeDefinitionService {
     getTypeDefinition(analyzer: Analyzer, sourceFile: SourceFile, offset: number): RangeLocation | undefined;
     private getTypeDefinitionAtIdentifier;
 }
-export type TypeDeclaration = PackageStructuredTypeDeclaration | AnonymousStructuredTypeDeclaration | PackageMethodTypeDeclaration | AnonymousMethodTypeDeclaration | PackageVariantTypeDeclaration | AnonymousVariantTypeDeclaration | PackageAliasTypeDeclaration | TypeParameterDeclaration;
+export type TypeDeclaration = PackageStructuredTypeDeclaration | AnonymousStructuredTypeDeclaration | PackageFunctionTypeDeclaration | AnonymousFunctionTypeDeclaration | PackageVariantTypeDeclaration | AnonymousVariantTypeDeclaration | PackageAliasTypeDeclaration | TypeParameterDeclaration;

package/build/types/services/signature-help/SignatureWithValueParameters.d.ts

@@ -1,4 +1,4 @@
-import { AccessedMethod } from '../../analysis/AccessedMethod.js';
+import { AccessedFunction } from '../../analysis/AccessedFunction.js';
 import { Localization, WithLocalization } from '../../analysis/Localization.js';
 import { Analyzer } from '../../analysis/index.js';
 import { Name } from '../../common/index.js';
@@ -49,19 +49,19 @@ export declare class MatchedSignature {
     readonly matchResult: SimplifiedArgumentToParameterMatchResult;
     constructor(value: Signature, matchResult: SimplifiedArgumentToParameterMatchResult);
 }
-export type Signature = AccessedMethodSignature | MethodTypeSignature | ConstructorSignature | IndexerSignature;
-export declare class AccessedMethodSignature implements ISignature {
-    readonly kind = "accessed-method";
-    readonly method: WithLocalization<AccessedMethod>;
+export type Signature = AccessedFunctionSignature | FunctionTypeSignature | ConstructorSignature | IndexerSignature;
+export declare class AccessedFunctionSignature implements ISignature {
+    readonly kind = "accessed-function";
+    readonly func: WithLocalization<AccessedFunction>;
     private readonly _valueParameters;
-    constructor(method: WithLocalization<AccessedMethod>);
+    constructor(func: WithLocalization<AccessedFunction>);
     getValueParameters(): readonly ValueParameter[];
 }
-export declare class MethodTypeSignature implements ISignature {
-    readonly kind = "method-type";
-    readonly methodType: types.MethodType;
+export declare class FunctionTypeSignature implements ISignature {
+    readonly kind = "function-type";
+    readonly functionType: types.FunctionType;
     private readonly _valueParameters;
-    constructor(methodType: types.MethodType);
+    constructor(functionType: types.FunctionType);
     getValueParameters(): readonly ValueParameter[];
 }
 export declare class ConstructorSignature implements ISignature {

package/build/types/services/signature-help/TypeParameterSignatureHelpProvider.d.ts

@@ -16,6 +16,6 @@ export declare class TypeParameterSignatureHelpProvider {
     private getSignaturesForNamedTypeSpecifier;
     private getSignaturesForTag;
     private getSignaturesForGenericSpecializationExpression;
-    private getSignatureForSubstitutedMethod;
+    private getSignatureForSubstitutedFunction;
     private getSignatureForNamedType;
 }

package/build/types/services/source-generation/EntityToSyntax.d.ts

@@ -12,22 +12,22 @@ export declare class EntityToSyntax {
     private convertNamedPackageMember;
     private convertPackageType;
     private convertPackageVariable;
-    private convertPackageMethod;
+    private convertPackageFunction;
     private convertPackageStructuredType;
     private convertPackageAliasType;
     private convertPackageVariantType;
-    private convertPackageMethodType;
+    private convertPackageFunctionType;
     private convertTypeEntityMembers;
-    private convertTypeVariable;
-    private convertTypeMethod;
-    private convertTypeConstructor;
-    private convertTypeDestructor;
-    private convertTypeIndexer;
+    private convertField;
+    private convertMethod;
+    private convertConstructor;
+    private convertDestructor;
+    private convertIndexer;
     private convertVariant;
     private createStructuredTypeDeclarationBody;
     private createAliasTypeDeclarationBody;
     private createVariantTypeDeclarationBody;
-    private createMethodTypeDeclarationBody;
+    private createFunctionTypeDeclarationBody;
     private convertTypeParameters;
     private convertTypeParameter;
     private convertValueParameters;
@@ -38,10 +38,11 @@ export declare class EntityToSyntax {
     private convertType;
     private convertStructuredType;
     private convertVariantType;
-    private convertMethodType;
+    private convertFunctionType;
     private convertAliasType;
     private convertParameterType;
     private convertUnionType;
+    private convertIntersectionType;
     private convertUnresolvedType;
     private createNamedTypeSpecifier;
 }