@artel/artc 0.6.25191

package/build/types/entities/StructuredTypeEntity.d.ts

@@ -0,0 +1,199 @@
+import { Tag } from '../analysis/Tags.js';
+import { Analyzer } from '../analysis/index.js';
+import { Name } from '../common/index.js';
+import { AnonymousStructuredTypeDeclaration, PackageStructuredTypeDeclaration } from '../tree/index.js';
+import * as types from '../types/index.js';
+import { EntityNaming } from './EntityNaming.js';
+import { NamedTypeMemberEntity, OriginalTypeEntityMembers } from './TypeEntityMembers.js';
+import type { DereferenceOperatorEntity, PackageEntity } from './index.js';
+import { ConstructorEntity, DefinitionKind, DestructorEntity, EntityHidingLevel, EntityKind, IndexerEntity, SubstitutionApplicationMode, TypeParameterEntity } from './index.js';
+export type StructuredTypeEntity = PackageStructuredTypeEntity | AnonymousStructuredTypeEntity;
+export interface PackageStructuredTypeEntity extends IStructuredTypeEntity {
+    readonly subkind: 'package';
+    getName(): Name;
+    getContainingPackage(): PackageEntity;
+}
+export interface AnonymousStructuredTypeEntity extends IStructuredTypeEntity {
+    readonly subkind: 'anonymous';
+    getContainingPackage(): PackageEntity;
+}
+interface IStructuredTypeEntity {
+    readonly kind: EntityKind.StructuredType;
+    getNaming(): EntityNaming;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getMembers(): OriginalTypeEntityMembers;
+    getDefinition(): StructuredTypeEntityDefinition;
+    isAspect(): boolean;
+    isRefObject(): boolean;
+    isPlainObject(): boolean;
+    getArity(): number;
+    /**
+     * При повторных вызовах метод должен возвращать один и тот же экземпляр класса BaseObjectType.
+     */
+    getBaseObjectType(): BaseObjectType;
+    /**
+     * При повторных вызовах метод должен возвращать один и тот же экземпляр класса BaseAspectTypes.
+     */
+    getBaseAspectTypes(): BaseAspectTypes;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+}
+export type StructuredTypeEntityDefinition = {
+    kind: DefinitionKind.Source;
+    node: StructuredTypeEntityDefinitionNode;
+} | {
+    kind: DefinitionKind.Intrinsic;
+} | {
+    kind: DefinitionKind.TypeScript;
+};
+type StructuredTypeEntityDefinitionNode = PackageStructuredTypeDeclaration | AnonymousStructuredTypeDeclaration;
+/**
+ * Класс позволяет работать с базовым объектным типом, исключая циклы наследования.
+ *
+ * Пример цикла наследования:
+ * ```artel
+ * тип А = объект Б { }
+ * тип Б = объект А { }
+ * ```
+ *
+ * Для типа `А` в поле `declared` будет указан тип `Б`, а в поле `cycleFree` - `undefined`.
+ */
+export declare class BaseObjectType {
+    /**
+     * Базовый объектный тип, указанный пользователем (либо базовый тип по умолчанию).
+     */
+    readonly declared: types.Type | undefined;
+    private _state;
+    /**
+     * Базовый объектный тип, указанный пользователем, либо `undefined`, если указанный тип приводит к циклу.
+     */
+    get cycleFree(): types.Type | undefined;
+    /**
+     * Приводит ли указанный базовый объектный тип к циклу?
+     */
+    get causesCycle(): boolean;
+    constructor(declared: types.Type | undefined);
+    private getBaseObjectTypeResolutionResult;
+    /**
+     * @param circularityTrackingStack Если элементом массива является `false`, тип не создаёт цикл, если `true` - создаёт.
+     */
+    private resolveBaseObjectType;
+}
+/**
+ * Класс позволяет работать с базовыми аспектными типами, исключая циклы наследования.
+ *
+ * Пример цикла наследования:
+ * ```artel
+ * тип А = аспект Б { }
+ * тип Б = аспект А { }
+ * ```
+ *
+ * Для типа `А` в поле `declared` будет указан тип `Б`, а в поле `cycleFree` - `undefined`.
+ */
+export declare class BaseAspectTypes {
+    /**
+     * Базовые аспектные типы, указанные пользователем.
+     */
+    readonly declared: readonly types.Type[];
+    private _state;
+    /**
+     * Базовые аспектные типы, указанные пользователем, которые не приводят к циклу.
+     */
+    get cycleFree(): readonly types.Type[];
+    /**
+     * Приводит ли хотя бы один базовый аспектный тип, указанный пользователем, к циклу?
+     */
+    get causesCycle(): boolean;
+    constructor(declared: readonly types.Type[]);
+    private getBaseAspectTypesResolutionResult;
+    /**
+     * @param circularityTrackingStack Если элементом массива является `false`, тип не создаёт цикл, если `true` - создаёт.
+     */
+    private resolveBaseAspectTypes;
+}
+export declare class PackageStructuredTypeDeclarationEntity implements PackageStructuredTypeEntity {
+    readonly kind = EntityKind.StructuredType;
+    readonly subkind = "package";
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _data;
+    constructor(analyzer: Analyzer, node: PackageStructuredTypeDeclaration);
+    getNaming(): EntityNaming;
+    getName(): Name;
+    getContainingPackage(): PackageEntity;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getMembers(): OriginalTypeEntityMembers;
+    getDefinition(): StructuredTypeEntityDefinition;
+    isAspect(): boolean;
+    isRefObject(): boolean;
+    isPlainObject(): boolean;
+    getArity(): number;
+    getBaseObjectType(): BaseObjectType;
+    getBaseAspectTypes(): BaseAspectTypes;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+}
+export declare class SourcePackageStructuredTypeDeclarationData {
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _entity;
+    private readonly _typeParameters;
+    private readonly _baseObjectType;
+    private readonly _baseAspectTypes;
+    private readonly _members;
+    constructor(analyzer: Analyzer, node: PackageStructuredTypeDeclaration, entity: PackageStructuredTypeEntity);
+    getNaming(): EntityNaming;
+    getName(): Name;
+    getContainingPackage(): PackageEntity;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getMembers(): OriginalTypeEntityMembers;
+    getDefinition(): StructuredTypeEntityDefinition;
+    isAspect(): boolean;
+    isRefObject(): boolean;
+    isPlainObject(): boolean;
+    getArity(): number;
+    getBaseObjectType(): BaseObjectType;
+    getBaseAspectTypes(): BaseAspectTypes;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+}
+export declare class AnonymousStructuredTypeDeclarationEntity implements AnonymousStructuredTypeEntity {
+    private readonly _analyzer;
+    private readonly _node;
+    readonly kind = EntityKind.StructuredType;
+    readonly subkind = "anonymous";
+    private readonly _baseObjectType;
+    private readonly _baseAspectTypes;
+    private readonly _members;
+    constructor(_analyzer: Analyzer, _node: AnonymousStructuredTypeDeclaration);
+    getNaming(): EntityNaming;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getMembers(): OriginalTypeEntityMembers;
+    getDefinition(): StructuredTypeEntityDefinition;
+    isAspect(): boolean;
+    isRefObject(): boolean;
+    isPlainObject(): boolean;
+    getArity(): number;
+    getBaseObjectType(): BaseObjectType;
+    getBaseAspectTypes(): BaseAspectTypes;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+    getContainingPackage(): PackageEntity;
+}
+export declare class UnfinishedIntrinsicPackageStructuredTypeEntity {
+    private readonly _unfinishedValue;
+    get unfinishedValue(): PackageStructuredTypeEntity;
+    constructor(analyzer: Analyzer, name: Name, containingPackage: PackageEntity, typeParameters: readonly TypeParameterEntity[], isAspect: boolean, isRefObject: boolean, baseObjectType: types.StructuredType | undefined, baseAspectTypes: readonly types.StructuredType[], isHidden: EntityHidingLevel | undefined, substitutionApplicationMode: SubstitutionApplicationMode);
+    finish(ownNamedMembers: readonly NamedTypeMemberEntity[], ownConstructors: readonly ConstructorEntity[], ownDestructors: readonly DestructorEntity[], ownIndexers: readonly IndexerEntity[], ownDereferenceOperators: readonly DereferenceOperatorEntity[]): PackageStructuredTypeEntity;
+}
+export declare class UnfinishedIntrinsicAnonymousStructuredTypeEntity {
+    private readonly _unfinishedValue;
+    get unfinishedValue(): AnonymousStructuredTypeEntity;
+    constructor(analyzer: Analyzer, typeParameters: readonly TypeParameterEntity[], isAspect: boolean, isRefObject: boolean, baseObjectType: types.StructuredType | undefined, baseAspectTypes: readonly types.StructuredType[], isHidden: EntityHidingLevel | undefined, substitutionApplicationMode: SubstitutionApplicationMode, containingPackage: PackageEntity);
+    finish(ownNamedMembers: readonly NamedTypeMemberEntity[], ownConstructors: readonly ConstructorEntity[], ownDestructors: readonly DestructorEntity[], ownIndexers: readonly IndexerEntity[], ownDereferenceOperators: readonly DereferenceOperatorEntity[]): AnonymousStructuredTypeEntity;
+}
+export {};

package/build/types/entities/SubstitutionApplicationMode.d.ts

@@ -0,0 +1,4 @@
+export declare const enum SubstitutionApplicationMode {
+    SubstituteOwnSubstitutions = 0,
+    SubstituteOwnSubstitutionsAndMerge = 1
+}

package/build/types/entities/TypeEntityMembers.d.ts

@@ -0,0 +1,36 @@
+import { Name } from '../common/index.js';
+import { BinaryOperatorEntity, BinaryOperatorKind } from './BinaryOperatorEntity.js';
+import { ConstructorEntity } from './ConstructorEntity.js';
+import { DestructorEntity } from './DestructorEntity.js';
+import { IndexerEntity } from './IndexerEntity.js';
+import { TypeMethodEntity } from './MethodEntity.js';
+import { DereferenceOperatorEntity } from './DereferenceOperatorEntity.js';
+import { UnaryOperatorEntity, UnaryOperatorKind } from './UnaryOperatorEntity.js';
+import { TypeVariableEntity } from './VariableEntity.js';
+export declare class OriginalTypeEntityMembers {
+    private readonly _namedMembers;
+    private readonly _constructors;
+    private readonly _destructors;
+    private readonly _indexers;
+    private readonly _referenceOperators;
+    private readonly _unaryOperators;
+    private readonly _binaryOperators;
+    private readonly _membersByUniversalName;
+    private readonly _unaryOperatorsByKind;
+    private readonly _binaryOperatorsByKind;
+    private get membersByUniversalName();
+    private get unaryOperatorByKind();
+    private get binaryOperatorByKind();
+    constructor(_namedMembers: readonly NamedTypeMemberEntity[], _constructors: readonly ConstructorEntity[], _destructors: readonly DestructorEntity[], _indexers: readonly IndexerEntity[], _referenceOperators: readonly DereferenceOperatorEntity[], _unaryOperators: readonly UnaryOperatorEntity[], _binaryOperators: readonly BinaryOperatorEntity[]);
+    getNamedMembers(): readonly NamedTypeMemberEntity[];
+    getNamedMembersByName(name: Name): readonly NamedTypeMemberEntity[];
+    getIndexers(): readonly IndexerEntity[];
+    getDereferenceOperators(): readonly DereferenceOperatorEntity[];
+    getConstructors(): readonly ConstructorEntity[];
+    getDestructors(): readonly DestructorEntity[];
+    getUnaryOperators(): readonly UnaryOperatorEntity[];
+    getUnaryOperatorsByKind(kind: UnaryOperatorKind): readonly UnaryOperatorEntity[];
+    getBinaryOperators(): readonly BinaryOperatorEntity[];
+    getBinaryOperatorsByKind(kind: BinaryOperatorKind): readonly BinaryOperatorEntity[];
+}
+export type NamedTypeMemberEntity = TypeVariableEntity | TypeMethodEntity;

package/build/types/entities/TypeExtensionEntity.d.ts

@@ -0,0 +1,33 @@
+import { Tag } from '../analysis/Tags.js';
+import { Analyzer } from '../analysis/index.js';
+import { TypeExtensionDeclaration } from '../tree/index.js';
+import { OriginalTypeEntityMembers } from './TypeEntityMembers.js';
+import { DefinitionKind, EntityHidingLevel, EntityKind, NamedTypeEntity, PackageEntity } from './index.js';
+export interface TypeExtensionEntity {
+    readonly kind: EntityKind.TypeExtension;
+    getMembers(): OriginalTypeEntityMembers;
+    getContainingPackage(): PackageEntity;
+    getExtendedTypeEntity(): NamedTypeEntity | undefined;
+    getDefinition(): TypeExtensionEntityDefinition;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+}
+type TypeExtensionEntityDefinition = {
+    kind: DefinitionKind.Source;
+    node: TypeExtensionDeclaration;
+};
+export declare class SourceTypeExtensionEntity implements TypeExtensionEntity {
+    readonly kind = EntityKind.TypeExtension;
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _members;
+    constructor(analyzer: Analyzer, node: TypeExtensionDeclaration);
+    getMembers(): OriginalTypeEntityMembers;
+    getContainingPackage(): PackageEntity;
+    getExtendedTypeEntity(): NamedTypeEntity | undefined;
+    getDefinition(): TypeExtensionEntityDefinition;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    private enumerateOwnMembers;
+}
+export {};

package/build/types/entities/TypeMemberContainer.d.ts

@@ -0,0 +1,23 @@
+import { TypeExtensionEntity, TypeEntity, TypeEntityWithMembers } from './index.js';
+export type TypeMemberEntityContainer = TypeMemberEntityContainer.Type | TypeMemberEntityContainer.TypeExtension;
+export declare namespace TypeMemberEntityContainer {
+    export class Type implements ITypeMemberEntityContainer {
+        readonly typeEntity: TypeEntityWithMembers;
+        readonly kind = "type";
+        constructor(typeEntity: TypeEntityWithMembers);
+        getContextualType(): TypeEntityWithMembers | undefined;
+        getEntity(): TypeEntityWithMembers | TypeExtensionEntity;
+    }
+    export class TypeExtension implements ITypeMemberEntityContainer {
+        readonly typeExtension: TypeExtensionEntity;
+        readonly kind = "type-extension";
+        constructor(typeExtension: TypeExtensionEntity);
+        getContextualType(): TypeEntity | undefined;
+        getEntity(): TypeEntityWithMembers | TypeExtensionEntity;
+    }
+    interface ITypeMemberEntityContainer {
+        getContextualType(): TypeEntity | undefined;
+        getEntity(): TypeEntityWithMembers | TypeExtensionEntity;
+    }
+    export {};
+}

package/build/types/entities/TypeParameterEntity.d.ts

@@ -0,0 +1,94 @@
+import { Analyzer } from '../analysis/index.js';
+import { Name } from '../common/index.js';
+import { TypeParameterDeclaration } from '../tree/index.js';
+import * as types from '../types/index.js';
+import { AliasTypeEntity, DefinitionKind, Entity, EntityHidingLevel, EntityKind, MethodEntity, MethodTypeEntity, StructuredTypeEntity, VariantTypeEntity } from './index.js';
+export interface TypeParameterEntity {
+    readonly kind: EntityKind.TypeParameter;
+    getName(): Name;
+    /**
+     * При повторных вызовах метод должен возвращать один и тот же экземпляр класса TypeParameterConstraint.
+     */
+    getConstraint(): TypeParameterConstraint;
+    getDefaultType(): types.Type | undefined;
+    getDefinition(): TypeParameterEntityDefinition;
+    getArity(): number;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getContainingEntity(): EntityContainingTypeParameter;
+    isHidden(): EntityHidingLevel | undefined;
+}
+export type TypeParameterEntityDefinition = {
+    kind: DefinitionKind.Source;
+    node: TypeParameterDeclaration;
+} | {
+    kind: DefinitionKind.Intrinsic;
+} | {
+    kind: DefinitionKind.TypeScript;
+};
+export type EntityContainingTypeParameter = VariantTypeEntity | MethodEntity | MethodTypeEntity | StructuredTypeEntity | AliasTypeEntity;
+export declare function isEntityContainingTypeParameter(entity: Entity): entity is EntityContainingTypeParameter;
+/**
+ * Класс позволяет работать с ограничением параметра шаблона, исключая циклы.
+ *
+ * Пример цикла:
+ * ```artel
+ * тип МойТип<Т1: Т2, Т2: Т1> = объект { }
+ * ```
+ *
+ * Для типа `Т1` в поле `declared` будет указан тип `Т2`, а в поле `cycleFree` - `undefined`.
+ */
+export declare class TypeParameterConstraint {
+    /**
+     * Указанное пользователем ограничение параметра шаблона (либо ограничение по умолчанию если не указано явно).
+     */
+    readonly declared: types.Type | undefined;
+    private _state;
+    /**
+     * Указанное пользователем ограничение шаблона, либо `undefined`, если указанное ограничение шаблона приводит к циклу.
+     */
+    get cycleFree(): types.Type | undefined;
+    /**
+     * Приводит ли указанное пользователем ограничение шаблона к циклу?
+     */
+    get causesCycle(): boolean;
+    constructor(declared: types.Type | undefined);
+    private getConstraintResolutionResult;
+    /**
+     * @param circularityTrackingStack Если элементом массива является `false`, тип не создаёт цикл, если `true` - создаёт.
+     */
+    private resolveConstraint;
+}
+export declare class SourceTypeParameterEntity implements TypeParameterEntity {
+    private readonly _analyzer;
+    private readonly _node;
+    readonly kind = EntityKind.TypeParameter;
+    private readonly _definition;
+    private readonly _constraint;
+    private readonly _default;
+    constructor(_analyzer: Analyzer, _node: TypeParameterDeclaration);
+    getName(): Name;
+    getConstraint(): TypeParameterConstraint;
+    getDefaultType(): types.Type | undefined;
+    getDefinition(): TypeParameterEntityDefinition;
+    getArity(): number;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getContainingEntity(): EntityContainingTypeParameter;
+    isHidden(): EntityHidingLevel | undefined;
+}
+export declare class IntrinsicTypeParameterEntity implements TypeParameterEntity {
+    private readonly _name;
+    private readonly _constraint;
+    private readonly _defaultValue;
+    private readonly _containingEntity;
+    readonly kind = EntityKind.TypeParameter;
+    private readonly _typeParameterConstraint;
+    constructor(_name: Name, _constraint: types.Type | undefined, _defaultValue: types.Type | undefined, _containingEntity: EntityContainingTypeParameter);
+    getName(): Name;
+    getConstraint(): TypeParameterConstraint;
+    getDefaultType(): types.Type | undefined;
+    getDefinition(): TypeParameterEntityDefinition;
+    getArity(): number;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getContainingEntity(): EntityContainingTypeParameter;
+    isHidden(): EntityHidingLevel | undefined;
+}

package/build/types/entities/UnaryOperatorEntity.d.ts

@@ -0,0 +1,33 @@
+import * as types from '../types/index.js';
+import { DefinitionKind, EntityHidingLevel, EntityKind, TypeMemberEntityContainer } from './index.js';
+export interface UnaryOperatorEntity {
+    readonly kind: EntityKind.UnaryOperator;
+    getOperatorKind(): UnaryOperatorKind;
+    getOperandType(): types.Type;
+    getResultType(): types.Type;
+    getDefinition(): UnaryOperatorDefinition;
+    getContainer(): TypeMemberEntityContainer;
+    isHidden(): EntityHidingLevel | undefined;
+}
+export type UnaryOperatorDefinition = {
+    kind: DefinitionKind.Intrinsic;
+};
+export declare enum UnaryOperatorKind {
+    Plus = 0,
+    Minus = 1,
+    Not = 2
+}
+export declare class IntrinsicUnaryOperatorEntity implements UnaryOperatorEntity {
+    readonly _operatorKind: UnaryOperatorKind;
+    private readonly _operandType;
+    private readonly _resultType;
+    private readonly _container;
+    readonly kind = EntityKind.UnaryOperator;
+    constructor(_operatorKind: UnaryOperatorKind, _operandType: types.Type, _resultType: types.Type, _container: TypeMemberEntityContainer);
+    getOperatorKind(): UnaryOperatorKind;
+    getOperandType(): types.Type;
+    getResultType(): types.Type;
+    getDefinition(): UnaryOperatorDefinition;
+    getContainer(): TypeMemberEntityContainer;
+    isHidden(): EntityHidingLevel | undefined;
+}