@artel/artc 0.6.25217 → 0.6.25219

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

@@ -1,102 +1,15 @@
-import { Name, Query, SearchName } from '../common/index.js';
-import { AliasTypeEntity, EntityHidingLevel, NamedPackageMemberEntity, PackageAliasEntity, PackageMethodEntity, PackageMethodTypeEntity, PackageStructuredTypeEntity, PackageTypeEntity, PackageVariableEntity, PackageVariantTypeEntity, StructuredTypeEntity, TypeExtensionEntity, TypeParameterEntity } from '../entities/index.js';
+import { SearchName } from '../common/index.js';
+import { PackageAliasEntity, PackageMethodEntity, PackageTypeEntity, PackageVariableEntity, TypeExtensionEntity } from '../entities/index.js';
 export declare class SourceFileMembers {
-    private readonly _namedDeclarations;
+    private readonly _namedMembers;
     private readonly _typeExtensions;
     private readonly _declarationsByName;
-    get declarationsByName(): ReadonlyMap<string, readonly NamedDeclaration[]>;
-    constructor(namedDeclarations: readonly NamedDeclaration[], typeExtensions: readonly TypeExtensionEntity[]);
-    getNamedDeclarations(): Query<NamedDeclaration>;
-    getNamedDeclarationsByName(name: SearchName): Query<NamedDeclaration>;
-    getPackageAliases(): Query<PackageAliasEntity>;
-    getPackageAliasesByName(name: SearchName): Query<PackageAliasEntity>;
-    getTypeExtensions(): Query<TypeExtensionEntity>;
-    getTypeExtensionsByType(type: StructuredTypeEntity): Query<TypeExtensionEntity>;
-}
-export type NamedDeclaration = NamedDeclaration_type | NamedDeclaration_variable | NamedDeclaration_method | NamedDeclaration_packageAlias;
-export declare class NamedDeclaration_type implements INamedDeclaration {
-    readonly value: TypeDeclaration;
-    readonly kind = "type";
-    constructor(value: TypeDeclaration);
-    getName(): Name;
-    isHidden(): EntityHidingLevel | undefined;
-    getEntity(): NamedPackageMemberEntity | PackageAliasEntity;
-}
-export declare class NamedDeclaration_variable implements INamedDeclaration {
-    readonly value: PackageVariableEntity;
-    readonly kind = "variable";
-    constructor(value: PackageVariableEntity);
-    getName(): Name;
-    isHidden(): EntityHidingLevel | undefined;
-    getEntity(): NamedPackageMemberEntity | PackageAliasEntity;
-}
-export declare class NamedDeclaration_method implements INamedDeclaration {
-    readonly value: PackageMethodEntity;
-    readonly kind = "method";
-    constructor(value: PackageMethodEntity);
-    getName(): Name;
-    isHidden(): EntityHidingLevel | undefined;
-    getEntity(): NamedPackageMemberEntity | PackageAliasEntity;
-}
-export declare class NamedDeclaration_packageAlias implements INamedDeclaration {
-    readonly value: PackageAliasEntity;
-    readonly kind = "package-alias";
-    constructor(value: PackageAliasEntity);
-    getName(): Name;
-    isHidden(): EntityHidingLevel | undefined;
-    getEntity(): NamedPackageMemberEntity | PackageAliasEntity;
-}
-interface INamedDeclaration {
-    getName(): Name;
-    isHidden(): EntityHidingLevel | undefined;
-    getEntity(): NamedPackageMemberEntity | PackageAliasEntity;
-}
-export type TypeDeclaration = TypeDeclaration_alias | TypeDeclaration_method | TypeDeclaration_structured | TypeDeclaration_variant;
-export declare class TypeDeclaration_alias implements ITypeDeclaration {
-    readonly value: AliasTypeEntity;
-    readonly kind = "alias";
-    constructor(value: AliasTypeEntity);
-    getName(): Name;
-    getTypeParameters(): readonly TypeParameterEntity[];
-    getArity(): number;
-    isHidden(): EntityHidingLevel | undefined;
-    getEntity(): PackageTypeEntity;
-}
-export declare class TypeDeclaration_method implements ITypeDeclaration {
-    readonly value: PackageMethodTypeEntity;
-    readonly kind = "method";
-    constructor(value: PackageMethodTypeEntity);
-    getName(): Name;
-    getTypeParameters(): readonly TypeParameterEntity[];
-    getArity(): number;
-    isHidden(): EntityHidingLevel | undefined;
-    getEntity(): PackageTypeEntity;
-}
-export declare class TypeDeclaration_structured implements ITypeDeclaration {
-    readonly value: PackageStructuredTypeEntity;
-    readonly kind = "structured";
-    constructor(value: PackageStructuredTypeEntity);
-    getName(): Name;
-    getTypeParameters(): readonly TypeParameterEntity[];
-    getArity(): number;
-    isHidden(): EntityHidingLevel | undefined;
-    getEntity(): PackageTypeEntity;
-}
-export declare class TypeDeclaration_variant implements ITypeDeclaration {
-    readonly value: PackageVariantTypeEntity;
-    readonly kind = "variant";
-    constructor(value: PackageVariantTypeEntity);
-    getName(): Name;
-    getTypeParameters(): readonly TypeParameterEntity[];
-    getArity(): number;
-    isHidden(): EntityHidingLevel | undefined;
-    getEntity(): PackageTypeEntity;
-}
-interface ITypeDeclaration {
-    getName(): Name;
-    getTypeParameters(): readonly TypeParameterEntity[];
-    getArity(): number;
-    isHidden(): EntityHidingLevel | undefined;
-    getEntity(): PackageTypeEntity;
-}
-export {};
+    get declarationsByName(): ReadonlyMap<string, readonly NamedSourceFileMemberEntity[]>;
+    constructor(namedMembers: readonly NamedSourceFileMemberEntity[], typeExtensions: readonly TypeExtensionEntity[]);
+    getNamedDeclarations(): readonly NamedSourceFileMemberEntity[];
+    getNamedDeclarationsByName(name: SearchName): readonly NamedSourceFileMemberEntity[];
+    getPackageAliases(): readonly PackageAliasEntity[];
+    getPackageAliasesByName(name: SearchName): readonly PackageAliasEntity[];
+    getTypeExtensions(): readonly TypeExtensionEntity[];
+}
+export type NamedSourceFileMemberEntity = PackageTypeEntity | PackageVariableEntity | PackageMethodEntity | PackageAliasEntity;

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

@@ -1,26 +1,74 @@
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
+import { MethodEntity, NamedTypeEntity, PackageAliasEntity } from '../entities/index.js';
 import { Tag } from '../tree/index.js';
 import * as types from '../types/index.js';
-import { FoundAnonymousDeclaration } from './FoundDeclaration.js';
+import { AccessedMethod } from './AccessedMethod.js';
+import { FoundAnonymousDeclaration, FoundNamedDeclaration } from './FoundDeclaration.js';
+import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
 import { Analyzer } from './index.js';
 export declare class Resolver {
     private readonly _analyzer;
     private readonly _node;
+    private readonly _semanticContext;
+    private get semanticContext();
     constructor(_analyzer: Analyzer, _node: Tag);
-    resolve(): Meaning;
+    resolve(): ResolutionResult;
+    private resolveNameInScope;
+    private resolveNameInPackage;
+    private resolveTypeOverload;
+    private resolveTagType;
+    private resolveTagMethod;
+    private createAccessedMethod;
+    private resolveMethodOverload;
 }
-export type Meaning = Meaning_constructorCall | Meaning_unresolved;
-declare class Meaning_constructorCall {
-    readonly type: types.StructuredType;
+export declare class ResolutionResult {
+    readonly meaning: Meaning;
+    readonly resolvedQualifiers: readonly ResolvedQualifier[];
+    readonly diagnostic?: Diagnostic | undefined;
+    constructor(meaning: Meaning, resolvedQualifiers: readonly ResolvedQualifier[], diagnostic?: Diagnostic | undefined);
+}
+export type Meaning = Meaning_tagType | Meaning_tagMethod | Meaning_unresolved;
+declare class Meaning_tagType {
+    readonly type: types.Type;
     readonly candidates: readonly FoundAnonymousDeclaration<types.Constructor>[];
     readonly suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[];
-    readonly kind = "resolved";
+    readonly kind = "tag-type";
     get singleSuitableConstructor(): FoundAnonymousDeclaration<types.Constructor> | undefined;
-    constructor(type: types.StructuredType, candidates: readonly FoundAnonymousDeclaration<types.Constructor>[], suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[]);
+    constructor(type: types.Type, candidates: readonly FoundAnonymousDeclaration<types.Constructor>[], suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[]);
+}
+declare class Meaning_tagMethod {
+    readonly candidates: readonly FoundNamedDeclaration<AccessedMethod>[];
+    readonly suitableMethods: readonly FoundNamedDeclaration<AccessedMethod>[];
+    readonly kind = "tag-method";
+    get singleSuitableMethod(): FoundNamedDeclaration<AccessedMethod> | undefined;
+    constructor(candidates: readonly FoundNamedDeclaration<AccessedMethod>[], suitableMethods: readonly FoundNamedDeclaration<AccessedMethod>[]);
 }
 declare class Meaning_unresolved {
-    readonly diagnostics: readonly Diagnostic[];
     readonly kind = "unresolved";
-    constructor(diagnostics: readonly Diagnostic[]);
+}
+export type ResolvedQualifier = ResolvedQualifier_packageNameSegment | ResolvedQualifier_packageAlias | ResolvedQualifier_type | ResolvedQualifier_method;
+export declare class ResolvedQualifier_packageNameSegment {
+    readonly packageTreeNode: PackageNameTreeNode;
+    readonly kind = "package-name-segment";
+    constructor(packageTreeNode: PackageNameTreeNode);
+}
+export declare class ResolvedQualifier_packageAlias {
+    readonly packageAlias: PackageAliasEntity;
+    readonly kind = "package-alias";
+    constructor(packageAlias: PackageAliasEntity);
+}
+export declare class ResolvedQualifier_type {
+    readonly candidates: readonly FoundNamedDeclaration<NamedTypeEntity>[];
+    readonly suitableTypes: readonly FoundNamedDeclaration<NamedTypeEntity>[];
+    readonly kind = "type";
+    get singleSuitableType(): FoundNamedDeclaration<NamedTypeEntity> | undefined;
+    constructor(candidates: readonly FoundNamedDeclaration<NamedTypeEntity>[], suitableTypes: readonly FoundNamedDeclaration<NamedTypeEntity>[]);
+}
+export declare class ResolvedQualifier_method {
+    readonly candidates: readonly FoundNamedDeclaration<MethodEntity>[];
+    readonly suitableMethods: readonly FoundNamedDeclaration<MethodEntity>[];
+    readonly kind = "method";
+    get singleSuitableMethod(): FoundNamedDeclaration<MethodEntity> | undefined;
+    constructor(candidates: readonly FoundNamedDeclaration<MethodEntity>[], suitableMethods: readonly FoundNamedDeclaration<MethodEntity>[]);
 }
 export {};

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

@@ -1,12 +1,23 @@
-import { VariableEntity } from '../entities/index.js';
+import { ParameterVariableEntity } from '../entities/index.js';
 import * as types from '../types/index.js';
-export declare class Tag {
-    readonly type: types.StructuredType;
-    readonly constructor_: types.Constructor;
-    readonly argumentByParameter: ReadonlyMap<VariableEntity, TagArgument>;
+import { AccessedMethod } from './AccessedMethod.js';
+export type Tag = TagType | TagMethod;
+declare abstract class TagBase {
+    readonly argumentByParameter: ReadonlyMap<ParameterVariableEntity, TagArgument>;
     private readonly _argumentByName;
     get argumentByName(): ReadonlyMap<string, TagArgument>;
-    constructor(type: types.StructuredType, constructor_: types.Constructor, argumentByParameter: ReadonlyMap<VariableEntity, TagArgument>);
+    constructor(argumentByParameter: ReadonlyMap<ParameterVariableEntity, TagArgument>);
+}
+export declare class TagType extends TagBase {
+    readonly kind = "type";
+    readonly type: types.Type;
+    readonly constructor_: types.Constructor;
+    constructor(type: types.Type, constructor_: types.Constructor, argumentByParameter: ReadonlyMap<ParameterVariableEntity, TagArgument>);
+}
+export declare class TagMethod extends TagBase {
+    readonly kind = "method";
+    readonly method: AccessedMethod;
+    constructor(method: AccessedMethod, argumentByParameter: ReadonlyMap<ParameterVariableEntity, TagArgument>);
 }
 export type TagArgument = TagArgument_string | TagArgument_numeric | TagArgument_boolean | TagArgument_invalid;
 export declare class TagArgument_string {
@@ -27,3 +38,4 @@ export declare class TagArgument_boolean {
 export declare class TagArgument_invalid {
     readonly kind = "invalid";
 }
+export {};

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

@@ -1,4 +1,4 @@
-import { PackageLocale, Query, SearchName } from '../common/index.js';
+import { PackageLocale, SearchName } from '../common/index.js';
 import { IEntityHidingMatcher, OperatorKind, TypeEntity } from '../entities/index.js';
 import * as types from '../types/index.js';
 import { Analyzer } from './Analyzer.js';
@@ -16,13 +16,13 @@ export declare class TypeMemberLookup {
     get searchLocale(): PackageLocale;
     constructor(_analyzer: Analyzer, _type: types.Type, _localizationContext: LocalizationContext | undefined);
     static ofTypeEntity(analyzer: Analyzer, entity: TypeEntity, localizationContext: LocalizationContext | undefined): TypeMemberLookup;
-    getNamedMembers(hidingMatcher?: IEntityHidingMatcher, typeExtensionsLookup?: Lookup): Query<FoundNamedDeclaration<types.NamedTypeMember>>;
-    getNamedMembersByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher, typeExtensionsLookup?: Lookup): Query<FoundNamedDeclaration<types.NamedTypeMember>>;
-    getOperators(hidingMatcher?: IEntityHidingMatcher, typeExtensionsLookup?: Lookup): Query<FoundAnonymousDeclaration<types.Operator>>;
-    getOperatorsByKind(kind: OperatorKind, hidingMatcher?: IEntityHidingMatcher, typeExtensionsLookup?: Lookup): Query<FoundAnonymousDeclaration<types.Operator>>;
-    getConstructors(hidingMatcher?: IEntityHidingMatcher, typeExtensionsLookup?: Lookup): Query<FoundAnonymousDeclaration<types.Constructor>>;
-    getIndexers(hidingMatcher?: IEntityHidingMatcher, typeExtensionsLookup?: Lookup): Query<FoundAnonymousDeclaration<types.Indexer>>;
-    getDereferenceOperators(hidingMatcher?: IEntityHidingMatcher, typeExtensionsLookup?: Lookup): Query<FoundAnonymousDeclaration<types.DereferenceOperator>>;
+    getNamedMembers(hidingMatcher?: IEntityHidingMatcher, typeExtensionsLookup?: Lookup): readonly FoundNamedDeclaration<types.NamedTypeMember>[];
+    getNamedMembersByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher, typeExtensionsLookup?: Lookup): readonly FoundNamedDeclaration<types.NamedTypeMember>[];
+    getOperators(hidingMatcher?: IEntityHidingMatcher, typeExtensionsLookup?: Lookup): readonly FoundAnonymousDeclaration<types.Operator>[];
+    getOperatorsByKind(kind: OperatorKind, hidingMatcher?: IEntityHidingMatcher, typeExtensionsLookup?: Lookup): readonly FoundAnonymousDeclaration<types.Operator>[];
+    getConstructors(hidingMatcher?: IEntityHidingMatcher, typeExtensionsLookup?: Lookup): readonly FoundAnonymousDeclaration<types.Constructor>[];
+    getIndexers(hidingMatcher?: IEntityHidingMatcher, typeExtensionsLookup?: Lookup): readonly FoundAnonymousDeclaration<types.Indexer>[];
+    getDereferenceOperators(hidingMatcher?: IEntityHidingMatcher, typeExtensionsLookup?: Lookup): readonly FoundAnonymousDeclaration<types.DereferenceOperator>[];
     private getLocaleOfTypeEntity;
 }
 export declare class BoundTypeMemberLookup {
@@ -31,11 +31,11 @@ export declare class BoundTypeMemberLookup {
     private readonly _typeExtensionLookup;
     constructor(analyzer: Analyzer, type: types.Type, localizationContext: LocalizationContext | undefined, hidingMatcher: IEntityHidingMatcher | undefined, typeExtensionLookup: Lookup | undefined);
     static ofTypeEntity(analyzer: Analyzer, entity: TypeEntity, localizationContext: LocalizationContext | undefined, hidingMatcher: IEntityHidingMatcher | undefined, typeExtensionLookup: Lookup | undefined): BoundTypeMemberLookup;
-    getNamedMembers(): Query<FoundNamedDeclaration<types.NamedTypeMember>>;
-    getNamedMembersByName(name: SearchName): Query<FoundNamedDeclaration<types.NamedTypeMember>>;
-    getOperators(): Query<FoundAnonymousDeclaration<types.Operator>>;
-    getOperatorsByKind(kind: OperatorKind): Query<FoundAnonymousDeclaration<types.Operator>>;
-    getConstructors(): Query<FoundAnonymousDeclaration<types.Constructor>>;
-    getIndexers(): Query<FoundAnonymousDeclaration<types.Indexer>>;
-    getDereferenceOperators(): Query<FoundAnonymousDeclaration<types.DereferenceOperator>>;
+    getNamedMembers(): readonly FoundNamedDeclaration<types.NamedTypeMember>[];
+    getNamedMembersByName(name: SearchName): readonly FoundNamedDeclaration<types.NamedTypeMember>[];
+    getOperators(): readonly FoundAnonymousDeclaration<types.Operator>[];
+    getOperatorsByKind(kind: OperatorKind): readonly FoundAnonymousDeclaration<types.Operator>[];
+    getConstructors(): readonly FoundAnonymousDeclaration<types.Constructor>[];
+    getIndexers(): readonly FoundAnonymousDeclaration<types.Indexer>[];
+    getDereferenceOperators(): readonly FoundAnonymousDeclaration<types.DereferenceOperator>[];
 }

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

@@ -1,5 +1,5 @@
 export declare class Resolver<TCandidate extends ICandidate> {
-    resolveByArgumentCount(candidates: Iterable<TCandidate>, argumentCount: number): Iterable<TCandidate>;
+    resolveByArgumentCount(candidates: readonly TCandidate[], argumentCount: number): readonly TCandidate[];
 }
 export interface ICandidate {
     getParameterCount(): number;

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

@@ -1,7 +1,7 @@
-import { Entity, PackageEntity, StructuredTypeEntity, TypeParameterEntity, VariableEntity } from '../entities/index.js';
+import { Entity, MethodEntity, PackageEntity, StructuredTypeEntity, TypeParameterEntity, VariableEntity } from '../entities/index.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
-import { Tag } from './Tags.js';
+import { Tag, TagMethod, TagType } from './Tags.js';
 type TextToken = tree.Token<tree.TokenKind.TextLiteral> | tree.Token<tree.TokenKind.TextTemplateHead> | tree.Token<tree.TokenKind.TextTemplatePart> | tree.Token<tree.TokenKind.TextTemplateTail>;
 export declare function getUnescapedTextFromTextToken(token: TextToken): string;
 export declare function unwrapParenthesizedExpressions(expression: tree.Expression): tree.Expression;
@@ -9,7 +9,8 @@ export declare function getParentSkippingParenthesizedExpressions(expression: tr
 export declare function unaliasType(type: types.Type): types.Type;
 export declare function unaliasType(type: types.Type | undefined): types.Type | undefined;
 export declare function getPackageContainingEntity(entity: Entity): PackageEntity;
-export declare function findTag(tagTypeEntity: StructuredTypeEntity, tags: readonly Tag[]): Tag | undefined;
+export declare function findTag(tagTypeEntity: StructuredTypeEntity, tags: readonly Tag[]): TagType | undefined;
+export declare function findTag(tagMethodEntity: MethodEntity, tags: readonly Tag[]): TagMethod | undefined;
 export declare function getRequiredTypeParameterCount(typeParameters: readonly TypeParameterEntity[]): number;
 export declare function flattenPackageMemberDeclarationList(list: tree.PackageMemberDeclarationList): Iterable<Exclude<tree.PackageMemberDeclaration, tree.PackageMemberGroupDeclaration>>;
 export declare function flattenTypeMemberDeclarationList(list: tree.TypeMemberDeclarationList): Iterable<Exclude<tree.TypeMemberDeclaration, tree.TypeMemberGroupDeclaration>>;

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

@@ -33,4 +33,5 @@ export declare class WellKnownDeclarations {
     realName: StructuredTypeEntity;
     builtIntoPlatform: StructuredTypeEntity;
     typeVariableProxy: StructuredTypeEntity;
+    javaScriptDecorator: StructuredTypeEntity;
 }

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

@@ -1,5 +1,5 @@
 export * from './Analyzer.js';
-export * from './CallArgumentsToParametersMatcher.js';
+export * from './ArgumentsToParametersMatcher.js';
 export * from './DeclarationsUsageCounter.js';
 export * from './DiagnosticCollector.js';
 export * from './FindModifier.js';

package/build/types/api/Api.d.ts

@@ -3,9 +3,8 @@ export * from '../analysis/AnalyzedTranslationPackage.js';
 export * from '../analysis/Analyzer.js';
 export type { Meaning as AutotypeCallExpressionMeaning } from '../analysis/AutotypeCallExpressionMeaning.js';
 export type { Meaning as BaseExpressionMeaning } from '../analysis/BaseExpressionMeaning.js';
-export { MatchResult, MatchResultValueParameter } from '../analysis/CallArgumentToParameterMatchResult.js';
+export { MatchResult, MatchResultValueParameter } from '../analysis/ArgumentToParameterMatchResult.js';
 export type { Meaning as CallExpressionMeaning } from '../analysis/CallExpressionMeaning.js';
-export * as dereferencedVariableAccess from '../analysis/DereferencedVariableAccess.js';
 export type { Meaning as DereferenceExpressionMeaning } from '../analysis/DereferenceExpressionMeaning.js';
 export * from '../analysis/DiagnosticCollector.js';
 export * from '../analysis/EntityLocalizationHelper.js';
@@ -13,7 +12,6 @@ export * from '../analysis/FindModifier.js';
 export * from '../analysis/FoundDeclaration.js';
 export type { Meaning as IdentifierExpressionMeaning, ResolutionResult as IdentifierExpressionResolutionResult } from '../analysis/IdentifierExpressionMeaning.js';
 export * from '../analysis/ImportedPackageNameTree.js';
-export * as indexedAccess from '../analysis/IndexedAccess.js';
 export type { Meaning as IndexedAccessExpressionMeaning } from '../analysis/IndexedAccessExpressionMeaning.js';
 export * from '../analysis/Localization.js';
 export * from '../analysis/LocalizationContext.js';
@@ -22,7 +20,7 @@ export * from '../analysis/NodeTypeUtils.js';
 export type { Meaning as ObjectExpressionMeaning } from '../analysis/ObjectExpressionMeaning.js';
 export * from '../analysis/PackageMemberLookup.js';
 export type { Meaning as PropertyAccessExpressionMeaning, ResolutionResult as PropertyAccessExpressionResolutionResult } from '../analysis/PropertyAccessExpressionMeaning.js';
-export type { IScope, NamedDeclaration, TypeDeclaration, TypeOrContainerWithTypes } from '../analysis/Scope.js';
+export type { IScope, NamedDeclaration, TypeOrContainerWithTypes } from '../analysis/Scope.js';
 export * from '../analysis/SemanticContext.js';
 export * from '../analysis/SourceFileMembers.js';
 export * from '../analysis/SourcePackageDependencyGraph.js';
@@ -32,8 +30,6 @@ export * from '../analysis/Tags.js';
 export * from '../analysis/TargetTypeHint.js';
 export * from '../analysis/TypeMemberLookup.js';
 export * from '../analysis/Utils.js';
-export * as variableAccess from '../analysis/VariableAccess.js';
-export * from '../analysis/VariantLookup.js';
 export * from '../analysis/Visitor.js';
 export * from '../analysis/WellKnownDeclarations.js';
 export * from '../common/index.js';

package/build/types/diagnostic/DiagnosticCode.d.ts

@@ -16,21 +16,21 @@ export declare enum DiagnosticCode {
     TypeParameterExpected = 14,
     ParameterExpected = 15,
     RunStatementClauseExpected = 16,
-    PackageImportExpected = 17,
-    UsingDirectiveOrSourceFileMemberExpected = 18,
-    WordFormExpected = 19,
+    CatchClauseOrFinallyClauseExpected = 17,
+    PackageImportExpected = 18,
+    UsingDirectiveOrSourceFileMemberExpected = 19,
     TypeMemberTranslationExpected = 20,
     TranslationExpected = 21,
     Expected0But1Found = 22,
     InvalidTextTemplateLiteral = 23,
-    RunKeywordOnCreateKeywordOrModifierListExpected = 24,
+    RunKeywordCreationKeywordOrModifierListExpected = 24,
     ModifierListExpected = 25,
     HidingLevelExpected = 26,
     ParameterNameCanContainOnlyOneBackQuote = 27,
     FieldNameCanContainOnlyTwoBackQuote = 28,
     BackQuotesCanOnlyBeUsedInParameterAndFieldNames = 29,
     NameThatMatchesKeywordMustBeEnclosedInSingleQuotes = 30,
-    VariantNotFound = 31,
+    TagNameExpected = 31,
     TypeCannotBeUsedAsValue = 32,
     PackageMemberNotFound = 33,
     TypeMemberNotFound = 34,
@@ -57,15 +57,15 @@ export declare enum DiagnosticCode {
     MethodNotFound = 55,
     UnknownPackage = 56,
     CannotAssignValueToExpression = 57,
-    NotEveryRequiredParameterIsProvidedWithCallArgument = 58,
-    ParameterForPositionalCallArgumentNotFound = 59,
+    NotEveryRequiredParameterIsProvidedWithArgument = 58,
+    ParameterForPositionalArgumentNotFound = 59,
     CannotDetermineTargetTypeToCallTheConstructor = 60,
     AmbiguousAccess = 61,
     PackageNameConflictsWithDeclarationName = 62,
     CanNotAssignValueToContextVariable = 63,
     ExpectedPackageNameOrAliasButFoundType = 64,
     TypeExpected = 65,
-    TypeOrPackageNotFound = 66,
+    NameOfTypeOrPackageNotFound = 66,
     TypeIsNotATag = 67,
     ExpressionOfType0CanNotBeUsedForEnumeration = 68,
     Operator0IsNotDefinedForTypes1And2 = 69,
@@ -89,7 +89,7 @@ export declare enum DiagnosticCode {
     YieldStatementCanNotBeUsedInAnonymousMethods = 87,
     YieldStatementCanNotBeUsedHere = 88,
     MethodsUsingYieldStatementMustHaveEnumerableAsReturnType = 89,
-    YieldStatementCanNotBeUsedInRunStatementThatHasOnErrorClause = 90,
+    YieldStatementCanNotBeUsedInTryStatementThatHasCatchClause = 90,
     YieldStatementCanNotBeUsedInFinallyClause = 91,
     SubprogramMustReturnValue = 92,
     ResultVariableCanNotBeUsedInMethodsUsingYieldStatement = 93,
@@ -110,12 +110,16 @@ export declare enum DiagnosticCode {
     Operator0MustHaveOneParameter = 108,
     Operator0MustHaveNoMoreThanOneParameter = 109,
     CorrespondingRedefinableTypeMemberNotFound = 110,
-    ConstructorCanNoBeRedefinable = 111,
-    ConstructorCanNoBeRedefined = 112,
-    CanNotFindTsLibDirectoryBaseSearchPaths0 = 113,
-    SourceFile0IsNotPartOfThePackageAndWontBeLoaded = 114,
-    ProgramWithoutMainPackageCanNotBeCompiled = 115,
-    JsonConfigurationValidationError = 116,
-    StandardPackage0NotFound = 117,
-    Declaration0NotFoundInStandardPackage1 = 118
+    ConstructorCanNotBeRedefinable = 111,
+    ConstructorCanNotBeRedefined = 112,
+    AsyncMethodCanOnlyBeCalledFromMethodMarkedWithAsyncModifier = 113,
+    TagNotFound = 114,
+    TypeOrMethodNameExpected = 115,
+    PackageNameOrAliasExpected = 116,
+    CanNotFindTsLibDirectoryBaseSearchPaths0 = 117,
+    SourceFile0IsNotPartOfThePackageAndWontBeLoaded = 118,
+    ProgramWithoutMainPackageCanNotBeCompiled = 119,
+    JsonConfigurationValidationError = 120,
+    StandardPackage0NotFound = 121,
+    Declaration0NotFoundInStandardPackage1 = 122
 }

package/build/types/emitter/{EmitterGeneratedDeclarationKind.d.ts → EmitPhaseName.d.ts}

@@ -1,49 +1,5 @@
 import { PackageLocale } from '../common/index.js';
 import { OperatorKind } from '../entities/OperatorKind.js';
-export declare const enum EmitterGeneratedDeclarationKind {
-    MainFunction = 0,
-    PackageConstructor = 1,
-    PackageRunFunction = 2,
-    PlainObjectConstructorPrefix = 3,
-    ExtensionConstructor = 4,
-    ExtensionMethodTargetParameter = 5,
-    GlobalVariableGetterPrefix = 6,
-    GlobalVariableSetterPrefix = 7,
-    TypeVariableGetterPrefix = 8,
-    TypeVariableSetterPrefix = 9,
-    TypeIndexedElementGetter = 10,
-    TypeIndexedElementSetter = 11,
-    TypeDereferencedVariable = 12,
-    TypeDereferencedVariableGetter = 13,
-    TypeDereferencedVariableSetter = 14,
-    TypeBackingVariablePrefix = 15,
-    TempVariablePrefix = 16,
-    DefaultImportPrefix = 17,
-    NamespaceImportPrefix = 18,
-    RefCountVariable = 19,
-    AddReferenceMethod = 20,
-    RemoveReferenceMethod = 21,
-    ShallowCopyMethod = 22,
-    MergedConstructorIdParameter = 23,
-    MergedConstructorParameterPrefix = 24,
-    AnonymousType = 25,
-    PlainObjectMethodNewThisVariable = 26,
-    PlainObjectMethodResultNewThisProperty = 27,
-    PlainObjectMethodResultResultProperty = 28,
-    ProxyVariable = 29,
-    TypeConstructor = 30,
-    TypeExtensionPrefix = 31
-}
-export declare const emitterGeneratedDeclarationNamesByLocale: {
-    [T in PackageLocale]: {
-        [T in EmitterGeneratedDeclarationKind]: string;
-    };
-};
-export declare const operatorNamesByLocale: {
-    [T in PackageLocale]: {
-        [T in OperatorKind]: string;
-    };
-};
 export declare class EmitPhaseName {
     static ofMainFunction(locale: PackageLocale): string;
     static ofPackageConstructor(locale: PackageLocale): string;
@@ -78,4 +34,5 @@ export declare class EmitPhaseName {
     static ofTypeConstructor(locale: PackageLocale): string;
     static ofTypeExtension(locale: PackageLocale, extendedTypeName: string): string;
     static ofOperator(locale: PackageLocale, kind: OperatorKind): string;
+    static ofSetterParameter(locale: PackageLocale): string;
 }

package/build/types/emitter/EmitterContext.d.ts

@@ -1,6 +1,6 @@
 import { Analyzer } from '../analysis/Analyzer.js';
 import * as analyzerEntities from '../entities/index.js';
-import { Type, TypeOrExtensionEntity } from './Entities.js';
+import { Type, TypeMemberEntity, TypeOrExtensionEntity } from './Entities.js';
 import { EntityMap } from './EntityMap.js';
 import { Expression } from './ir/index.js';
 export declare class EmitterContext {
@@ -21,6 +21,9 @@ export declare class EmitterContext {
     unaliasTypeEntity(typeEntity: TypeOrExtensionEntity): Type;
     unaliasType(type: Type): Type;
     isTypeEmittedAsClass(entity: TypeOrExtensionEntity): boolean;
+    isRefOrPlainObjectTypeEntity(entity: TypeOrExtensionEntity): boolean;
+    isAspectTypeEntity(entity: TypeOrExtensionEntity): boolean;
+    enumerateAllOverriddenMembers<T extends TypeMemberEntity>(entity: T): Iterable<T>;
 }
 declare class TypeUtils {
     private readonly _ectx;