@artel/artc 0.6.25217 → 0.6.25218

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,12 @@
 import { VariableEntity } from '../entities/index.js';
 import * as types from '../types/index.js';
 export declare class Tag {
-    readonly type: types.StructuredType;
+    readonly type: types.Type;
     readonly constructor_: types.Constructor;
     readonly argumentByParameter: ReadonlyMap<VariableEntity, TagArgument>;
     private readonly _argumentByName;
     get argumentByName(): ReadonlyMap<string, TagArgument>;
-    constructor(type: types.StructuredType, constructor_: types.Constructor, argumentByParameter: ReadonlyMap<VariableEntity, TagArgument>);
+    constructor(type: types.Type, constructor_: types.Constructor, argumentByParameter: ReadonlyMap<VariableEntity, TagArgument>);
 }
 export type TagArgument = TagArgument_string | TagArgument_numeric | TagArgument_boolean | TagArgument_invalid;
 export declare class TagArgument_string {

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/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,9 +16,9 @@ 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,
@@ -30,7 +30,7 @@ export declare enum DiagnosticCode {
     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,
+    YieldStatementCanNotBeUsedInRunStatementThatHasCatchClause = 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;

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

@@ -6,7 +6,7 @@ export interface MethodEntity {
     name: string;
     parameters: readonly VariableEntity[];
     returnType: Type;
-    isTypeMember: TypeMemberEntityInfo | undefined;
+    ifTypeMemberThenContainingType: TypeOrExtensionEntity | undefined;
     isPackageMember: boolean;
     containingPackage: PackageEntity;
     details: MethodEntityDetails;
@@ -18,48 +18,81 @@ export declare enum MethodEntityKind {
     Destructor = 3,
     Operator = 4
 }
-export declare class MethodEntityDetails {
+export declare class MethodEntityDetails implements TypeMemberEntityDetails {
     isAsync: boolean;
     isPackageConstructor: boolean;
     isPackageEntryPoint: boolean;
-    overriddenMember: MethodEntity | undefined;
+    overriddenMembers: readonly MethodEntity[];
     ifRedefinableAliasTypeMethodThenRealMethod: MethodEntity | undefined;
-    isEnumeratorMethod: boolean;
     isDefaultExport: boolean;
     isAliasTypeOrExtensionMemberThatRequiresLowering: boolean;
     isBuiltInOperator: boolean;
-    ifHasComputedNameWithSymbolKeyThenKeyDeclaration: VariableEntity | undefined;
+    hasComputedName: ComputedNameInfo | undefined;
     isRedefinable: boolean;
     isTypeExtensionMemberAddedToPrototype: boolean;
+    isAbstract: boolean;
+    isStatic: boolean;
+}
+export interface ComputedNameInfo {
+    /**
+     * Глобальная или статическая переменная, содержащая уникальный символ (Symbol). Используется в качестве ключа.
+     */
+    readonly symbolDeclaration: VariableEntity;
+    /**
+     * Нужно ли использовать вычисляемое имя в месте объявления, или только в местах использования?
+     */
+    readonly affectsDeclaration: boolean;
+    /**
+     * Должны ли члены типы, заменяющие этот член, использовать указанный символ в качестве ключа?
+     */
+    readonly affectsDerivedMembers: boolean;
 }
 export interface VariableEntity {
     readonly kind: 'variable';
     name: string;
     type: Type;
-    isTypeMember: TypeMemberEntityInfo | undefined;
+    ifTypeMemberThenContainingType: TypeOrExtensionEntity | undefined;
     isPackageMember: boolean;
     containingPackage: PackageEntity;
     getter: MethodEntity | undefined;
     setter: MethodEntity | undefined;
     details: VariableEntityDetails;
 }
-export declare class VariableEntityDetails {
+export declare class VariableEntityDetails implements TypeMemberEntityDetails {
     isVariadicParameter: boolean;
-    overriddenMember: VariableEntity | undefined;
+    overriddenMembers: readonly VariableEntity[];
     isProxiedTypeVariable: ProxiedTypeVariableInfo | undefined;
     isDefaultExport: boolean;
-    ifHasComputedNameWithSymbolKeyThenKeyDeclaration: VariableEntity | undefined;
+    hasComputedName: ComputedNameInfo | undefined;
     isRedefinable: boolean;
+    isAbstract: boolean;
+    isTypeExtensionMemberAddedToPrototype: boolean;
+    isStatic: boolean;
 }
 export interface ProxiedTypeVariableInfo {
     readonly tagType: TypeOrExtensionEntity;
     readonly constructor: MethodEntity;
 }
 export type TypeMemberEntity = MethodEntity | VariableEntity;
+interface TypeMemberEntityDetails {
+    isStatic: boolean;
+    isAbstract: boolean;
+    isRedefinable: boolean;
+    overriddenMembers: readonly TypeMemberEntity[];
+    hasComputedName: ComputedNameInfo | undefined;
+    isTypeExtensionMemberAddedToPrototype: boolean;
+}
 export interface TypeOrExtensionEntity {
     readonly kind: 'type-or-extension';
     name: string;
-    baseType: TypeOrExtensionEntity | undefined;
+    /**
+     * Базовый объектный тип, не являющийся псевдонимом.
+     */
+    baseObjectType: TypeOrExtensionEntity | undefined;
+    /**
+     * Базовые аспектные типы, не являющиеся псевдонимами.
+     */
+    baseAspectTypes: readonly TypeOrExtensionEntity[];
     typeOrExtensionKind: TypeOrExtensionEntityKind;
     members: readonly TypeMemberEntity[];
     containingPackage: PackageEntity;
@@ -70,6 +103,12 @@ export declare class TypeOrExtensionEntityDetails {
     aliasedType: Type | undefined;
     isDefaultExport: boolean;
     extendedType: TypeOrExtensionEntity | undefined;
+    /**
+     * Является ли имя члена типа вычисляемым (`details.hasComputedName`) может зависеть от заменённых членов типа.
+     * Если `areOwnComputedNamesOfMembersResolved` === `true`, поля `details.hasComputedName` членов типа хранят
+     * актуальную для них самих информацию, и анализ заменённых членов типа не требуется.
+     */
+    areOwnComputedNamesOfMembersResolved: boolean;
 }
 export declare enum TypeOrExtensionEntityKind {
     StructuredType = 0,
@@ -97,10 +136,6 @@ export declare class PackageEntityDetails {
     isSource: boolean;
     isPackageWithMainMethod: boolean;
 }
-export interface TypeMemberEntityInfo {
-    containingType: TypeOrExtensionEntity;
-    isStatic: boolean;
-}
 export type Type = SimpleType | UnionType;
 export declare class SimpleType {
     readonly entity: TypeOrExtensionEntity;
@@ -123,7 +158,7 @@ export declare class IntrinsicVariableEntity implements VariableEntity {
     type: Type;
     containingPackage: PackageEntity;
     readonly kind = "variable";
-    isTypeMember: TypeMemberEntityInfo | undefined;
+    ifTypeMemberThenContainingType: TypeOrExtensionEntity | undefined;
     isPackageMember: boolean;
     getter: MethodEntity | undefined;
     setter: MethodEntity | undefined;
@@ -137,7 +172,7 @@ export declare class IntrinsicMethodEntity implements MethodEntity {
     returnType: Type;
     containingPackage: PackageEntity;
     readonly kind = "method";
-    isTypeMember: TypeMemberEntityInfo | undefined;
+    ifTypeMemberThenContainingType: TypeOrExtensionEntity | undefined;
     isPackageMember: boolean;
     details: MethodEntityDetails;
     constructor(methodEntityKind: MethodEntityKind, name: string, parameters: readonly VariableEntity[], returnType: Type, containingPackage: PackageEntity);
@@ -150,3 +185,4 @@ export declare class IntrinsicPackageEntity implements PackageEntity {
     details: PackageEntityDetails;
     constructor(name: string, locale: PackageLocale);
 }
+export {};

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

@@ -16,11 +16,8 @@ export declare class EntityMap {
     private readonly _typeOrExtensions;
     private readonly _packages;
     private readonly _linkedPackages;
-    private readonly _enumeratorMethod;
-    private get enumeratorMethod();
     constructor(analyzer: Analyzer, targetPlatform: PlatformKind);
     getVariableEntity(entity: analyzerEntities.VariableEntity): emitterEntities.VariableEntity;
-    getVariantEntity(entity: analyzerEntities.VariantEntity): emitterEntities.VariableEntity;
     getMethodEntity(entity: analyzerEntities.MethodEntity): emitterEntities.MethodEntity;
     getOperatorEntity(entity: analyzerEntities.OperatorEntity): emitterEntities.MethodEntity;
     getConstructorEntity(entity: analyzerEntities.ConstructorEntity): emitterEntities.MethodEntity;
@@ -41,4 +38,5 @@ export declare class EntityMap {
     private getContainingPackageAndAccumulateIfMember;
     private getNameText;
     private isDefaultExport;
+    private unaliasTypeEntity;
 }

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

@@ -46,11 +46,13 @@ export declare class IrBuilder {
     private buildTypeMethodDeclaration;
     private buildOperatorDeclaration;
     private buildTypeVariableDeclaration;
-    private buildTypeVariableGetterDeclaration;
+    private buildComputedTypeVariableDeclaration;
+    private buildTypeVariableGetterDeclarationRequired;
     private buildTypeVariableSetterDeclaration;
     private buildBackingTypeVariable;
     private buildDisposeStatement;
     private buildRunStatement;
+    private buildTryStatement;
     private buildEmptyStatement;
     private buildErrorStatement;
     private buildExpressionStatement;
@@ -99,7 +101,9 @@ export declare class IrBuilder {
     private buildIdentifierExpression;
     private createExplicitReceiver;
     private getEntityFromType;
-    private buildCallArgumentList;
+    private buildArgumentList;
+    private buildDecorators;
+    private buildTagAsDecorator;
     private buildAndSaveTypeIfIsAnonymousTypeSpecifier;
     private buildAndSaveAnonymousTypeDeclaration;
     private buildAnonymousStructuredTypeDeclaration;

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

@@ -65,6 +65,7 @@ export declare class IrToJs {
     private convertJsIdentifierExpression;
     private convertPrefixUnaryExpression;
     private convertTextLiteral;
+    private convertTextWithEntityName;
     private convertTextTemplateLiteral;
     private convertTernaryExpression;
     private convertThisExpression;
@@ -75,11 +76,10 @@ export declare class IrToJs {
     private convertTypeAccessExpression;
     private convertVariableAccessExpression;
     private convertMethodAccessExpression;
-    private convertVariantAccessExpression;
     private convertTypeVariableAccessExpression;
     private convertTypeMethodAccessExpression;
     private convertConstructorCallExpression;
-    private convertCallArguments;
+    private convertArguments;
     private convertInlineJsExpression;
     private convertAssignmentExpression;
     private convertCommaExpression;
@@ -109,9 +109,10 @@ export declare class IrToJs {
     private convertTypeConstructorDeclaration;
     private convertTypeMethodDeclaration;
     private convertTypeVariableDeclaration;
-    private convertTypeVariableGetterDeclaration;
-    private convertTypeVariableSetterDeclaration;
+    private convertComputedTypeVariableDeclaration;
+    private convertDecorator;
     private addNodeLocation;
     private getEntityName;
     private convertArrayWithErrorBoundary;
+    private isLValue;
 }