@artel/artc 0.6.25282 → 0.6.25284

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

@@ -59,8 +59,10 @@ export declare class DisplayService {
     private displayFunctionTypeUsage;
     private displayParameterTypeUsage;
     private displayAliasTypeUsage;
+    private displayReducedTypeUsage;
     private displayUnionOrIntersectionTypeUsage;
     private displayUnresolvedTypeUsage;
+    private displaySubstitutionStubTypeUsage;
     private displayTypeInternal;
     private displayTypeUsageInternal;
     private displayUnionOrIntersectionTypeTypes;
@@ -320,7 +322,7 @@ export declare class TypeParameterValue_typeArgument {
     readonly kind = "type-argument";
     constructor(value: types.Type);
 }
-export type TypeDeclaration = TypeDeclaration_structured | TypeDeclaration_function | TypeDeclaration_variant | TypeDeclaration_alias | TypeDeclaration_parameter | TypeDeclaration_unresolved;
+export type TypeDeclaration = TypeDeclaration_structured | TypeDeclaration_function | TypeDeclaration_variant | TypeDeclaration_alias | TypeDeclaration_reduced | TypeDeclaration_parameter | TypeDeclaration_unresolved;
 export declare class TypeDeclaration_structured implements ITypeDeclaration {
     readonly value: TypeDeclarationStructured;
     readonly kind = "structured";
@@ -456,6 +458,39 @@ interface ITypeDeclarationAlias {
     getAliasedType(): types.Type;
     getContainer(): DeclarationContainer | undefined;
 }
+export declare class TypeDeclaration_reduced implements ITypeDeclaration {
+    readonly value: TypeDeclarationReduced;
+    readonly kind = "reduced";
+    constructor(value: TypeDeclarationReduced);
+    ifNamedThenEntity(): e.NamedTypeEntity | undefined;
+    getTypeParameterValues(): readonly TypeParameterValue[];
+    getContainer(): DeclarationContainer | undefined;
+}
+export type TypeDeclarationReduced = TypeDeclarationReduced_entity | TypeDeclarationReduced_type;
+export declare class TypeDeclarationReduced_entity implements ITypeDeclarationReduced {
+    readonly entity: e.ReducedTypeEntity;
+    readonly kind = "entity";
+    constructor(entity: e.ReducedTypeEntity);
+    ifNamedThenEntity(): e.NamedTypeEntity | undefined;
+    getTypeParameterValues(): readonly TypeParameterValue[];
+    getReductionSource(): types.Type;
+    getContainer(): DeclarationContainer | undefined;
+}
+export declare class TypeDeclarationReduced_type implements ITypeDeclarationReduced {
+    readonly type: types.ReducedType;
+    readonly kind = "type";
+    constructor(type: types.ReducedType);
+    ifNamedThenEntity(): e.NamedTypeEntity | undefined;
+    getTypeParameterValues(): readonly TypeParameterValue[];
+    getReductionSource(): types.Type;
+    getContainer(): DeclarationContainer | undefined;
+}
+interface ITypeDeclarationReduced {
+    ifNamedThenEntity(): e.NamedTypeEntity | undefined;
+    getTypeParameterValues(): readonly TypeParameterValue[];
+    getReductionSource(): types.Type;
+    getContainer(): DeclarationContainer | undefined;
+}
 export declare class TypeDeclaration_parameter implements ITypeDeclaration {
     readonly entity: e.TypeParameterEntity;
     readonly kind = "parameter";
@@ -475,7 +510,7 @@ interface ITypeDeclaration {
     getTypeParameterValues(): readonly TypeParameterValue[];
     getContainer(): DeclarationContainer | undefined;
 }
-type NamedType = NamedType_function | NamedType_structured | NamedType_typeParameter | NamedType_variant | NamedType_alias;
+type NamedType = NamedType_function | NamedType_structured | NamedType_typeParameter | NamedType_variant | NamedType_alias | NamedType_reduced;
 export declare class NamedType_function implements INamedType {
     readonly value: e.PackageFunctionTypeEntity;
     readonly kind = "function";
@@ -511,6 +546,13 @@ export declare class NamedType_alias implements INamedType {
     getEntity(): e.NamedTypeEntity;
     getTypeParameters(): readonly e.TypeParameterEntity[];
 }
+export declare class NamedType_reduced implements INamedType {
+    readonly value: e.ReducedTypeEntity;
+    readonly kind = "alias";
+    constructor(value: e.ReducedTypeEntity);
+    getEntity(): e.NamedTypeEntity;
+    getTypeParameters(): readonly e.TypeParameterEntity[];
+}
 interface INamedType {
     getEntity(): e.NamedTypeEntity;
     getTypeParameters(): readonly e.TypeParameterEntity[];
@@ -540,7 +582,7 @@ interface IOperatorDeclaration {
     getReturnType(): types.Type;
     getContainer(analyzer: Analyzer | undefined): DeclarationContainer | undefined;
 }
-export type TypeUsage = StructuredTypeUsage | VariantTypeUsage | FunctionTypeUsage | AliasTypeUsage | ParameterTypeUsage | UnionOrIntersectionTypeUsage | UnresolvedTypeUsage;
+export type TypeUsage = StructuredTypeUsage | VariantTypeUsage | FunctionTypeUsage | AliasTypeUsage | ReducedTypeUsage | ParameterTypeUsage | UnionOrIntersectionTypeUsage | UnresolvedTypeUsage | SubstitutionStubTypeUsage;
 export type StructuredTypeUsage = StructuredTypeUsage_type | StructuredTypeUsage_entity;
 export declare class StructuredTypeUsage_type implements IStructuredTypeUsage {
     readonly type: types.StructuredType;
@@ -645,6 +687,32 @@ interface IAliasTypeUsage {
     getAliasedType(): types.Type;
     getContainer(): DeclarationContainer | undefined;
 }
+export type ReducedTypeUsage = ReducedTypeUsage_type | ReducedTypeUsage_entity;
+export declare class ReducedTypeUsage_type implements IReducedTypeUsage {
+    readonly type: types.ReducedType;
+    readonly kind = "reduced";
+    constructor(type: types.ReducedType);
+    getEntity(): e.NamedTypeEntity;
+    getTypeParameterValues(): readonly TypeParameterValue[];
+    getReductionSource(): types.Type;
+    getContainer(): DeclarationContainer | undefined;
+}
+export declare class ReducedTypeUsage_entity implements IReducedTypeUsage {
+    readonly entity: e.ReducedTypeEntity;
+    readonly kind = "reduced";
+    constructor(entity: e.ReducedTypeEntity);
+    getEntity(): e.NamedTypeEntity;
+    getTypeParameterValues(): readonly TypeParameterValue[];
+    getReductionSource(): types.Type;
+    getContainer(): DeclarationContainer | undefined;
+}
+interface IReducedTypeUsage {
+    readonly kind: 'reduced';
+    getEntity(): e.NamedTypeEntity;
+    getTypeParameterValues(): readonly TypeParameterValue[];
+    getReductionSource(): types.Type;
+    getContainer(): DeclarationContainer | undefined;
+}
 export type ParameterTypeUsage = ParameterTypeUsage_type | ParameterTypeUsage_entity;
 export declare class ParameterTypeUsage_type implements IParameterTypeUsage {
     readonly type: types.ParameterType;
@@ -678,6 +746,13 @@ type UnresolvedTypeUsage = UnresolvedTypeUsage_type;
 declare class UnresolvedTypeUsage_type {
     readonly kind = "unresolved";
 }
+type SubstitutionStubTypeUsage = SubstitutionStubTypeUsage_type;
+declare class SubstitutionStubTypeUsage_type {
+    readonly type: types.SubstitutionStubType;
+    readonly kind = "substitution-stub";
+    constructor(type: types.SubstitutionStubType);
+    getIndex(): number;
+}
 type TypeMemberDeclarationContainer = DeclarationContainer.Type | DeclarationContainer.TypeExtension;
 type DeclarationContainer = DeclarationContainer.Type | DeclarationContainer.TypeExtension | DeclarationContainer.Package;
 declare namespace DeclarationContainer {

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

@@ -32,9 +32,7 @@ export declare class LanguageServer {
     private readonly signatureHelpService;
     private readonly fileSystemTreeDisplayService;
     private readonly selectionRangeService;
-    private readonly assignFieldService;
-    private readonly addBlockToScriptService;
-    private readonly deleteBlockFromScriptService;
+    private readonly scriptEditingService;
     private readonly codeActionsService;
     constructor(config: LanguageServerConfig);
     start(): void;
@@ -62,7 +60,8 @@ export declare class LanguageServer {
     private convertSourceFileItemKind;
     private convertDiagnostic;
     private onAssignField;
-    private onAddBlockToScript;
+    private onAddBlocksToScript;
+    private onCanDeleteBlocksFromScript;
     private onDeleteBlocksFromScript;
     private convertSourceFileEdit;
     private convertSourceFileEditsToWorkspaceEdit;

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

@@ -0,0 +1,25 @@
+import { Analyzer } from '../analysis/Analyzer.js';
+import { SubprogramDeclarationOrLiteral } from '../analysis/NodeTypeUtils.js';
+import { SourceFile } from '../project/index.js';
+import { NodeLocation, SourceFileEdit } from './Types.js';
+export declare class ScriptEditingService {
+    private static readonly indentationStep;
+    private static readonly elementParameterNameText;
+    private static readonly elementParameterName;
+    createEditWithFieldAssignment(analyzer: Analyzer, sourceFile: SourceFile, scriptDeclaration: SubprogramDeclarationOrLiteral, fieldName: string, value: string): SourceFileEdit | undefined;
+    createEditAddingBlocks(sourceFile: SourceFile, scriptDeclaration: SubprogramDeclarationOrLiteral, addedBlockInfos: readonly AddedScriptBlockInfo[]): SourceFileEdit | undefined;
+    canDeleteBlocks(outerScriptFunctionLocation: NodeLocation, scriptFunctionLocations: readonly NodeLocation[]): boolean;
+    createEditDeletingBlock(sourceFile: SourceFile, scriptDeclaration: SubprogramDeclarationOrLiteral): SourceFileEdit | undefined;
+    private findLastAssignmentToField;
+    private createScriptBlockText;
+    private detectNewLine;
+}
+export interface AddedScriptBlockInfo {
+    readonly name: string;
+    readonly key: string;
+    readonly areaIndex: string | undefined;
+    readonly elementProperties: {
+        readonly [T in string]: string;
+    };
+    readonly nestedBlocks: readonly AddedScriptBlockInfo[];
+}

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

@@ -9,7 +9,7 @@ export declare class TranslationService {
     clearTranslationCache(): void;
     private translateIdentifier;
     private translateKeywords;
-    private translateReservedIdentifier;
+    private translateReservedName;
     private createRangeMaps;
     private getTranslationId;
 }

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

@@ -1,6 +1,7 @@
 import * as ls from 'vscode-languageserver';
 import { Range, Uri } from '../common/index.js';
 import { SourceFile } from '../project/index.js';
+import * as tree from '../tree/index.js';
 export type RangeLocation = {
     uri: Uri;
     range: Range;
@@ -30,3 +31,8 @@ export declare class SourceFileEdit {
     readonly text: string;
     constructor(sourceFile: SourceFile, range: Range, text: string);
 }
+export declare class NodeLocation {
+    readonly sourceFile: SourceFile;
+    readonly path: tree.NodePath;
+    constructor(sourceFile: SourceFile, path: tree.NodePath);
+}

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

@@ -10,20 +10,34 @@ export declare class EntityToSyntax {
     private convertNamedPackageMember;
     private convertPackageType;
     private convertPackageVariable;
+    private convertPackageVariableModifiers;
     private convertPackageFunction;
+    private convertPackageFunctionModifiers;
     private convertPackageStructuredType;
+    private convertPackageStructuredTypeModifiers;
     private convertPackageAliasType;
+    private convertPackageAliasTypeModifiers;
+    private convertPackageReducedType;
+    private convertPackageReducedTypeModifiers;
     private convertPackageVariantType;
+    private convertPackageVariantTypeModifiers;
     private convertPackageFunctionType;
+    private convertPackageFunctionTypeModifiers;
     private convertTypeEntityMembers;
     private convertField;
+    private convertFieldModifiers;
     private convertMethod;
+    private convertMethodModifiers;
     private convertConstructor;
+    private convertConstructorModifiers;
     private convertDestructor;
+    private convertDestructorModifiers;
     private convertIndexer;
+    private convertIndexerModifiers;
     private convertVariant;
     private createStructuredTypeDeclarationBody;
     private createAliasTypeDeclarationBody;
+    private createReducedTypeDeclarationBody;
     private createVariantTypeDeclarationBody;
     private createFunctionTypeDeclarationBody;
     private convertTypeParameters;
@@ -38,9 +52,11 @@ export declare class EntityToSyntax {
     private convertVariantType;
     private convertFunctionType;
     private convertAliasType;
+    private convertReducedType;
     private convertParameterType;
     private convertUnionType;
     private convertIntersectionType;
     private convertUnresolvedType;
+    private convertSubstitutionStubType;
     private createNamedTypeSpecifier;
 }

package/build/types/tree/BaseNode.d.ts

@@ -1,6 +1,12 @@
 import { PackageDialect, PackageLocale, Range } from '../common/index.js';
-import { Node, SourceFile } from './Nodes.js';
-import { Token } from './Token.js';
+import { NodeKind } from './NodeKind.js';
+import { TokenKind } from './TokenKind.js';
+import { TriviaKind } from './TriviaKind.js';
+import { OperatorKind } from './OperatorKind.js';
+import { KeywordKind } from './KeywordKind.js';
+import { TokenFlags } from './TokenFlags.js';
+import { KeywordFlags } from './KeywordFlags.js';
+import { Node, Identifier, SourceFile } from './Nodes.js';
 export declare abstract class BaseNode {
     protected static readonly emptyChildren_: [];
     abstract readonly children: readonly (Node | undefined)[];
@@ -38,4 +44,52 @@ export declare abstract class BaseNode {
     private countDescendants;
     private countTokens;
 }
+export declare class Token<TKind extends TokenKind = TokenKind> extends BaseNode {
+    readonly kind = NodeKind.Token;
+    readonly tokenKind: TKind;
+    readonly value: string;
+    readonly leadingTrivia: readonly Trivia[];
+    readonly trailingTrivia: readonly Trivia[];
+    readonly flags: TokenFlags;
+    readonly operatorKind: OperatorKind | undefined;
+    get children(): readonly [];
+    get parent(): Node;
+    get isMissing(): boolean;
+    protected get thisAsNode(): Node;
+    constructor(tokenKind: TKind, value: string, leadingTrivia: readonly Trivia[], trailingTrivia: readonly Trivia[], flags: TokenFlags, operatorKind: OperatorKind | undefined, rangeWithTrivia: Range | undefined);
+    get rangeWithoutTrivia(): Range;
+    getTextWithTrivia(): string;
+    hasTrailingLineBreak(): boolean;
+    getTriviaAt(position: number): TokenTrivia | undefined;
+    selectLeadingTrivia(condition: (trivia: Trivia, rangeStart: number, rangeEnd: number) => boolean): TokenTrivia[];
+    selectTrailingTrivia(condition: (trivia: Trivia, rangeStart: number, rangeEnd: number) => boolean): TokenTrivia[];
+    protected getLengthWithTrivia(): number;
+}
+export declare class Trivia {
+    readonly kind: TriviaKind;
+    readonly value: string;
+    get rangeLength(): number;
+    constructor(kind: TriviaKind, value: string);
+}
+export declare class TokenTrivia {
+    readonly trivia: Trivia;
+    readonly token: Token<TokenKind>;
+    readonly isTrailing: boolean;
+    readonly index: number;
+    readonly range: Range;
+    get kind(): TriviaKind;
+    get value(): string;
+    constructor(token: Token<TokenKind>, trivia: Trivia, isTrailing: boolean, index: number, range: Range);
+}
+export declare class Keyword<TKind extends KeywordKind = KeywordKind> extends BaseNode {
+    readonly kind = NodeKind.Keyword;
+    readonly children: readonly Identifier[];
+    readonly keywordKind: TKind;
+    readonly flags: KeywordFlags;
+    get parent(): Node;
+    get tokens(): readonly Identifier[];
+    get isMissing(): boolean;
+    protected get thisAsNode(): Node;
+    constructor(tokens: readonly Identifier[], keywordKind: TKind, flags: KeywordFlags | undefined, rangeWithTrivia: Range | undefined);
+}
 export declare function toSourceCode(node: Node, lengthLimit?: number, excludeTrivia?: boolean): string;

package/build/types/tree/KeywordFlags.d.ts

@@ -0,0 +1,28 @@
+export declare const enum KeywordFlags {
+    None = 0,
+    Missing = 1,
+    Noun = 2,
+    Verb = 4,
+    Adjective = 8,
+    Adverb = 16,
+    Pronoun = 32,
+    Preposition = 64,
+    Particle = 128,
+    Conjunction = 256,
+    Numeral = 512,
+    MasculineGender = 1024,
+    FeminineGender = 2048,
+    NeuterGender = 4096,
+    Singular = 8192,
+    Plural = 16384,
+    NeuNoun = 4098,
+    PluralNoun = 16386,
+    SingularMasNoun = 9218,
+    SingularFemNoun = 10242,
+    SingularNeuNoun = 12290,
+    ComAdjective = 7176,
+    SingularMasAdjective = 9224,
+    SingularFemAdjective = 10248,
+    SingularNeuAdjective = 12296,
+    PluralAdjective = 16392
+}

package/build/types/tree/KeywordKind.d.ts

@@ -5,58 +5,61 @@ export declare enum KeywordKind {
     Aspect = 3,
     Object = 4,
     PlainObject = 5,
-    Variant = 6,
-    Run = 7,
-    Try = 8,
-    From = 9,
-    Else = 10,
-    ElseIf = 11,
-    Function = 12,
-    If = 13,
-    Is = 14,
-    Return = 15,
-    Type = 16,
-    Basic = 17,
-    Import = 18,
-    Important = 19,
-    Error = 20,
-    Finally = 21,
-    And = 22,
-    Or = 23,
-    Xor = 24,
-    While = 25,
-    Loop = 26,
-    RepeatWhile = 27,
-    Yield = 28,
-    When = 29,
-    Cond = 30,
-    Creation = 31,
-    Catch = 32,
-    BreakLoop = 33,
-    ContinueLoop = 34,
-    For = 35,
-    Const = 36,
-    Hidden = 37,
-    Abstract = 38,
-    Override = 39,
-    Async = 40,
-    Static = 41,
-    As = 42,
-    Not = 43,
-    Switch = 44,
-    Case = 45,
-    Dispose = 46,
-    Destruction = 47,
-    InHierarchy = 48,
-    InFile = 49,
-    InPackage = 50,
-    InType = 51,
-    Yes = 52,
-    No = 53,
-    Reference = 54,
-    Translations = 55,
-    Base = 56,
-    Null = 57,
-    Get = 58,
-    Set = 59
+    ReducedObject = 6,
+    Variant = 7,
+    Run = 8,
+    Try = 9,
+    From = 10,
+    Else = 11,
+    ElseIf = 12,
+    Function = 13,
+    If = 14,
+    Is = 15,
+    Return = 16,
+    Type = 17,
+    Basic = 18,
+    Import = 19,
+    Important = 20,
+    Error = 21,
+    Finally = 22,
+    And = 23,
+    Or = 24,
+    Xor = 25,
+    While = 26,
+    Loop = 27,
+    RepeatWhile = 28,
+    Yield = 29,
+    When = 30,
+    Cond = 31,
+    Creation = 32,
+    Catch = 33,
+    BreakLoop = 34,
+    ContinueLoop = 35,
+    For = 36,
+    Const = 37,
+    Hidden = 38,
+    Abstract = 39,
+    Override = 40,
+    Async = 41,
+    Static = 42,
+    As = 43,
+    Not = 44,
+    Switch = 45,
+    Case = 46,
+    Dispose = 47,
+    Destruction = 48,
+    InHierarchy = 49,
+    InFile = 50,
+    InPackage = 51,
+    InType = 52,
+    Yes = 53,
+    No = 54,
+    Reference = 55,
+    Translations = 56,
+    Base = 57,
+    Null = 58,
+    Get = 59,
+    Set = 60,
+    LoopWhile = 61,
+    Over = 62
 }