@artel/artc 0.6.25222 → 0.6.25224

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

@@ -1,7 +1,7 @@
-import { LocalVariableEntity, ParameterVariableEntity } from '../entities/VariableEntity.js';
+import { LocalVariableEntity, PackageVariableEntity, ParameterVariableEntity } from '../entities/VariableEntity.js';
 import * as types from '../types/index.js';
 import { Analyzer } from './Analyzer.js';
-import { ControlFlowNode, NarrowableReferenceExpression } from './ControlFlowGraphBuilder.js';
+import * as controlFlow from './control-flow/index.js';
 export declare class TypeNarrower {
     private readonly _analyzer;
     private readonly _referenceExpression;
@@ -9,54 +9,89 @@ export declare class TypeNarrower {
     private readonly _controlFlowNode;
     private _reference;
     private readonly _typeByNode;
-    constructor(analyzer: Analyzer, referenceExpression: NarrowableReferenceExpression, initialType: types.Type, controlFlowNode: ControlFlowNode);
+    private readonly _isVariableAssignedInLoopCheckResults;
+    constructor(analyzer: Analyzer, referenceExpression: controlFlow.NarrowableReferenceExpression, initialType: types.Type, controlFlowNode: controlFlow.Node);
     getType(): types.Type;
     private getTypeAtControlFlowNode;
     private getTypeAtCondition;
     private getTypeAtAssignment;
+    private getTypeAtLocalVariableDeclaration;
     private getTypeAtSplit;
     private getTypeAtLoop;
+    private getTypeAtAssignmentWithImplicitConversion;
     private getTypeAtComparisonWithNone;
     private getTypeAtIsExpression;
+    private getTypeAtAssignmentOrDeclaration;
     private addTypeIfUnique;
+    private checkIfVariableIsAssignedInLoop;
+    private checkIfVariableIsAssignedAtNode;
     private isSameReferenceAsNarrowedExpression;
-    private unwrapExpression;
     private getReferenceAtNodeIfNarrowable;
     private getReferenceAtNode;
     private getReferenceAtLocalVariableDeclaration;
 }
-export type NarrowableReference = NarrowableReference.LocalVariable | NarrowableReference.InstanceTypeVariable | NarrowableReference.StaticTypeVariable | NarrowableReference.Object;
+export type NarrowableReference = NarrowableReference.LocalVariable | NarrowableReference.PackageVariable | NarrowableReference.ObjectField | NarrowableReference.StaticField | NarrowableReference.ObjectAutoVariable;
 export declare namespace NarrowableReference {
     export class LocalVariable implements INarrowableReference {
+        private readonly _analyzer;
         readonly entity: LocalVariableEntity | ParameterVariableEntity;
         readonly kind = "local-variable";
-        constructor(entity: LocalVariableEntity | ParameterVariableEntity);
+        constructor(_analyzer: Analyzer, entity: LocalVariableEntity | ParameterVariableEntity);
         equals(other: NarrowableReference): boolean;
         contains(_other: NarrowableReference): boolean;
+        equalsExpression(expression: controlFlow.NarrowableReferenceExpression): boolean;
+        containsExpression(_expression: controlFlow.NarrowableReferenceExpression): boolean;
     }
-    export class InstanceTypeVariable implements INarrowableReference {
+    export class PackageVariable implements INarrowableReference {
+        private readonly _analyzer;
+        readonly entity: PackageVariableEntity;
+        readonly kind = "package-variable";
+        constructor(_analyzer: Analyzer, entity: PackageVariableEntity);
+        equals(other: NarrowableReference): boolean;
+        contains(_other: NarrowableReference): boolean;
+        equalsExpression(expression: controlFlow.NarrowableReferenceExpression): boolean;
+        containsExpression(_expression: controlFlow.NarrowableReferenceExpression): boolean;
+    }
+    export class ObjectField implements INarrowableReference {
+        private readonly _analyzer;
         readonly variable: types.Variable;
         readonly receiver: NarrowableReference;
-        readonly kind = "instance-type-variable";
-        constructor(variable: types.Variable, receiver: NarrowableReference);
+        readonly kind = "object-field";
+        constructor(_analyzer: Analyzer, variable: types.Variable, receiver: NarrowableReference);
         equals(other: NarrowableReference): boolean;
         contains(other: NarrowableReference): boolean;
+        equalsExpression(expression: controlFlow.NarrowableReferenceExpression): boolean;
+        containsExpression(expression: controlFlow.NarrowableReferenceExpression): boolean;
     }
-    export class StaticTypeVariable implements INarrowableReference {
+    export class StaticField implements INarrowableReference {
+        private readonly _analyzer;
         readonly variable: types.Variable;
-        readonly kind = "static-type-variable";
-        constructor(variable: types.Variable);
+        readonly kind = "static-field";
+        constructor(_analyzer: Analyzer, variable: types.Variable);
         equals(other: NarrowableReference): boolean;
         contains(_other: NarrowableReference): boolean;
+        equalsExpression(expression: controlFlow.NarrowableReferenceExpression): boolean;
+        containsExpression(_expression: controlFlow.NarrowableReferenceExpression): boolean;
     }
-    export class Object implements INarrowableReference {
-        readonly kind = "object";
+    export class ObjectAutoVariable implements INarrowableReference {
+        readonly kind = "object-auto-variable";
         equals(other: NarrowableReference): boolean;
         contains(_other: NarrowableReference): boolean;
+        equalsExpression(expression: controlFlow.NarrowableReferenceExpression): boolean;
+        containsExpression(_expression: controlFlow.NarrowableReferenceExpression): boolean;
     }
     interface INarrowableReference {
         equals(other: NarrowableReference): boolean;
         contains(other: NarrowableReference): boolean;
+        /**
+         * Отличается от метода `equals` тем, что выполняет сравнение лениво. Например, при сравнении с выражением
+         * `а.б` сперва будут сравнены части слева от точки (выражение `а` с `receiver`), и только при равенстве будет
+         * связано и сравнено имя `б`. Если выражение `а` не равно `receiver`, то сразу будет возвращено `false` и
+         * связывание для имени `б` выполняться не будет. Такое поведение необходимо при анализе циклов,
+         * чтобы избежать рекурсии.
+         */
+        equalsExpression(expression: controlFlow.NarrowableReferenceExpression): boolean;
+        containsExpression(expression: controlFlow.NarrowableReferenceExpression): boolean;
     }
     export {};
 }

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

@@ -1,6 +1,7 @@
 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 { PackageNameTreeNode } from './ImportedPackageNameTree.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;
@@ -15,4 +16,15 @@ export declare function getRequiredTypeParameterCount(typeParameters: readonly T
 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>>;
 export declare function isComputedVariableEntity(entity: VariableEntity): boolean;
+export type EntityOrPackageNameTreeNode = EntityOrPackageNameTreeNode_entity | EntityOrPackageNameTreeNode_node;
+export declare class EntityOrPackageNameTreeNode_entity {
+    readonly entity: Entity;
+    readonly kind = "entity";
+    constructor(entity: Entity);
+}
+export declare class EntityOrPackageNameTreeNode_node {
+    readonly node: PackageNameTreeNode;
+    readonly kind = "node";
+    constructor(node: PackageNameTreeNode);
+}
 export {};

package/build/types/analysis/control-flow/GraphBuilder.d.ts

@@ -0,0 +1,43 @@
+import { Diagnostic } from '../../diagnostic/Diagnostic.js';
+import { SourceFile } from '../../project/SourceFile.js';
+import { NarrowableReferenceExpression } from './NarrowableExpression.js';
+import { Node } from './Nodes.js';
+export declare class GraphBuilder {
+    private readonly _sourceFile;
+    private readonly _controlFlowNodeByReference;
+    private readonly _unreachableCodeDiagnostics;
+    private _isInRebuildingFinallyClauseGraphMode;
+    private _currentPredecessor;
+    private _currentContinueLoopTarget;
+    private _currentBreakLoopTarget;
+    private _currentErrorTarget;
+    private _currentReturnTarget;
+    constructor(sourceFile: SourceFile);
+    build(): GraphBuildResult;
+    private visitNode;
+    private visitAssignmentStatement;
+    private visitIfStatement;
+    private visitWhileStatement;
+    private visitLoopStatement;
+    private visitForStatement;
+    private visitContinueLoopStatement;
+    private visitBreakLoopStatement;
+    private visitSwitchStatement;
+    private visitTryStatement;
+    private visitReturnStatement;
+    private visitErrorStatement;
+    private visitLocalVariableDeclaration;
+    private visitWhenTernaryExpression;
+    private visitCondition;
+    private visitBinaryExpression;
+    private visitPrefixUnaryExpressionInCondition;
+    private visitIsExpressionInCondition;
+    private setAssignmentAsCurrentPredecessor;
+    private visitChildren;
+    private addUnreachableCodeDiagnostic;
+}
+export declare class GraphBuildResult {
+    readonly controlFlowNodeByReference: ReadonlyMap<NarrowableReferenceExpression, Node>;
+    readonly unreachableCodeDiagnostics: readonly Diagnostic[];
+    constructor(controlFlowNodeByReference: ReadonlyMap<NarrowableReferenceExpression, Node>, unreachableCodeDiagnostics: readonly Diagnostic[]);
+}

package/build/types/analysis/{ControlFlowGraphVisualizer.d.ts → control-flow/GraphVisualizer.d.ts}

@@ -1,12 +1,12 @@
-import { ControlFlowNode } from './ControlFlowGraphBuilder.js';
-export declare class ControlFlowGraphVisualizer {
+import { Node } from './Nodes.js';
+export declare class GraphVisualizer {
     /**
      * Создаёт описание графа на языке Dot.
      *
      * Визуализацию графа можно посмотреть по этой ссылке:
      * https://dreampuf.github.io/GraphvizOnline/?engine=dot#digraph%20%7B%20%7D
      */
-    static generateGraphDescriptionInDotLanguage(startNode: ControlFlowNode): string;
+    static generateGraphDescriptionInDotLanguage(startNode: Node): string;
     private static getLabel;
     private static createGetIdFunction;
 }

package/build/types/analysis/control-flow/NarrowableExpression.d.ts

@@ -0,0 +1,5 @@
+import * as tree from '../../tree/index.js';
+export declare function isNarrowableExpression(node: tree.Node): node is tree.Expression;
+export type NarrowableReferenceExpression = tree.IdentifierExpression | tree.PropertyAccessExpression | tree.ObjectExpression;
+export declare function isNarrowableReferenceExpression(node: tree.Node): node is NarrowableReferenceExpression;
+export declare function unwrapExpressionForNarrowableReferenceCheck(node: tree.Expression): tree.Expression;

package/build/types/analysis/control-flow/Nodes.d.ts

@@ -0,0 +1,91 @@
+import * as tree from '../../tree/index.js';
+export type Node = StartNode | ConditionNode | AssignmentNode | LocalVariableDeclarationNode | SplitNode | LoopNode | UnreachableNode;
+declare abstract class ControlFlowNodeBase {
+    protected abstract thisAsNode: Node;
+    /**
+     * Для отладочных целей.
+     */
+    generateVisualizationCode(): string;
+}
+/**
+ * Начальный узел, не имеющий предшественников. Создаётся в начале функций, а также для переменных пакета и полей
+ * объекта с начальным значением, поскольку выражение-инициализатор может иметь собственный граф потока управления
+ * (например, если начальное значение - это трёхместная операция `когда` с проверкой на `пусто`).
+ */
+export declare class StartNode extends ControlFlowNodeBase {
+    readonly kind = "start";
+    get debuggerDisplay(): string;
+    protected get thisAsNode(): Node;
+}
+export type ConditionExpression = tree.BinaryExpression | tree.IsExpression;
+/**
+ * Хранит информацию об истинности некоторого условия. Например, если условие `а != пусто` истинно, то из типа
+ * переменной `а` необходимо исключить тип `Пусто`.
+ */
+export declare class ConditionNode extends ControlFlowNodeBase {
+    readonly predecessor: Node;
+    readonly syntaxNode: ConditionExpression;
+    readonly isTrue: boolean;
+    readonly kind = "condition";
+    get debuggerDisplay(): string;
+    protected get thisAsNode(): Node;
+    constructor(predecessor: Node, syntaxNode: ConditionExpression, isTrue: boolean);
+}
+/**
+ * Создаётся в местах присваивания значений в переменную. После присваивания тип переменной меняется на тип выражения
+ * справа от равно.
+ */
+export declare class AssignmentNode extends ControlFlowNodeBase {
+    readonly predecessor: Node;
+    readonly syntaxNode: tree.AssignmentStatement;
+    readonly kind = "assignment";
+    get debuggerDisplay(): string;
+    protected get thisAsNode(): Node;
+    constructor(predecessor: Node, syntaxNode: tree.AssignmentStatement);
+}
+/**
+ * Создаётся в местах объявления локальных переменных. Если переменной присваивается начальное значение, её тип будет
+ * заменён на тип присваиваемого выражения.
+ */
+export declare class LocalVariableDeclarationNode extends ControlFlowNodeBase {
+    readonly predecessor: Node;
+    readonly syntaxNode: tree.LocalVariableDeclaration;
+    readonly kind = "local-variable-declaration";
+    get debuggerDisplay(): string;
+    protected get thisAsNode(): Node;
+    constructor(predecessor: Node, syntaxNode: tree.LocalVariableDeclaration);
+}
+/**
+ * Вспомогательный узел, использующийся в местах, где происходит разветвление графа потока управления. Тип переменной
+ * для этого узла определяется как союзный тип из типов переменных в предшествующих узлах.
+ */
+export declare class SplitNode extends ControlFlowNodeBase {
+    readonly predecessors: readonly Node[];
+    readonly kind = "split";
+    get debuggerDisplay(): string;
+    protected get thisAsNode(): Node;
+    constructor(predecessors: readonly Node[]);
+}
+/**
+ * Используется для циклов (пока, цикл - повтор пока, для-из). Отличается от узла {@link SplitNode} тем, что предшествующие
+ * узлы, указанные в массиве {@link loopingPredecessors}, образуют циклы в графе потока управления.
+ */
+export declare abstract class LoopNode extends ControlFlowNodeBase {
+    readonly kind = "loop";
+    get debuggerDisplay(): string;
+    protected get thisAsNode(): Node;
+    abstract predecessor: Node;
+    abstract loopingPredecessors: readonly Node[];
+}
+/**
+ * Обозначает недостижимый код. Соответствующая диагностика добавляется в
+ * {@link GraphBuildResult.unreachableCodeDiagnostics}. Класс {@link GraphBuilder} создаёт эти
+ * узлы для кода, недостижимость которого можно определить анализируя только синтаксическое дерево и не использую
+ * семантическую информацию. Например, инструкции, находящиеся после инструкции `возврат`, помечаются как недостижимые.
+ */
+export declare class UnreachableNode extends ControlFlowNodeBase {
+    readonly kind = "unreachable";
+    get debuggerDisplay(): string;
+    protected get thisAsNode(): Node;
+}
+export {};

package/build/types/analysis/control-flow/index.d.ts

@@ -0,0 +1,4 @@
+export * from './GraphBuilder.js';
+export * from './GraphVisualizer.js';
+export * from './NarrowableExpression.js';
+export * from './Nodes.js';

package/build/types/common/HelperPhrases.d.ts

@@ -5,7 +5,8 @@ export declare const enum HelperPhraseKind {
     TypeParameter = 2,
     Package = 3,
     PackageAlias = 4,
-    Variable = 5,
-    Overloads = 6
+    PackageNameSegment = 5,
+    Variable = 6,
+    Overloads = 7
 }
 export declare function getHelperPhrase(kind: HelperPhraseKind, locale: PackageLocale): string;

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

@@ -66,7 +66,7 @@ export declare enum DiagnosticCode {
     ParameterForPositionalArgumentNotFound = 64,
     CannotDetermineTargetTypeToCallTheConstructor = 65,
     AmbiguousAccess = 66,
-    PackageNameConflictsWithDeclarationName = 67,
+    AmbiguousAccess0 = 67,
     CanNotAssignValueToContextVariable = 68,
     ExpectedPackageNameOrAliasButFoundType = 69,
     TypeExpected = 70,
@@ -110,10 +110,10 @@ export declare enum DiagnosticCode {
     IncorrectBodyOfRedefinableAliasTypeMethod = 108,
     TheFollowingDeclarationsAreNotTranslated0 = 109,
     TheFollowingDeclarationAreNotTranslated0And1More = 110,
-    OperatorMustNotBeStatic = 111,
-    Operator0MustNotHaveParameters = 112,
-    Operator0MustHaveOneParameter = 113,
-    Operator0MustHaveNoMoreThanOneParameter = 114,
+    OperatorFunctionMustNotBeStatic = 111,
+    OperatorFunction0MustNotHaveParameters = 112,
+    OperatorFunction0MustHaveOneParameter = 113,
+    OperatorFunction0MustHaveNoMoreThanOneParameter = 114,
     CorrespondingRedefinableTypeMemberNotFound = 115,
     ConstructorCanNotBeRedefinable = 116,
     ConstructorCanNotBeRedefined = 117,

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

@@ -136,7 +136,7 @@ export declare class PackageEntityDetails {
     isSource: boolean;
     isPackageWithMainMethod: boolean;
 }
-export type Type = SimpleType | UnionType;
+export type Type = SimpleType | UnionOrIntersectionType;
 export declare class SimpleType {
     readonly entity: TypeOrExtensionEntity;
     readonly typeArguments: readonly Type[];
@@ -144,10 +144,11 @@ export declare class SimpleType {
     constructor(entity: TypeOrExtensionEntity, typeArguments: readonly Type[]);
     equals(other: Type): boolean;
 }
-export declare class UnionType {
+export declare class UnionOrIntersectionType {
     readonly types: readonly Type[];
-    readonly kind = "union";
-    constructor(types: readonly Type[]);
+    readonly isUnion: boolean;
+    readonly kind = "union-or-intersection";
+    constructor(types: readonly Type[], isUnion: boolean);
     equals(other: Type): boolean;
 }
 export type Entity = VariableEntity | MethodEntity | TypeOrExtensionEntity | PackageEntity;

package/build/types/emitter/ir/Nodes.d.ts

@@ -205,10 +205,10 @@ export declare class EmptyStatement {
     clone(): EmptyStatement;
 }
 export declare class ErrorStatement {
-    expression: Expression | undefined;
+    expression: Expression;
     sourceLocation: SourceLocation | undefined;
     readonly kind = NodeKind.ErrorStatement;
-    constructor(expression: Expression | undefined, sourceLocation: SourceLocation | undefined);
+    constructor(expression: Expression, sourceLocation: SourceLocation | undefined);
     clone(): ErrorStatement;
 }
 export declare class ImportantStatement {

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

@@ -65,6 +65,9 @@ export declare function isPackageTypeEntity(entity: TypeEntity): entity is Packa
 export type NamedTypeEntity = PackageMethodTypeEntity | PackageStructuredTypeEntity | PackageVariantTypeEntity | AliasTypeEntity | TypeParameterEntity;
 export type TypeEntityWithMembers = MethodTypeEntity | StructuredTypeEntity | VariantTypeEntity | AliasTypeEntity;
 export declare function isTypeEntityWithMembers(entity: TypeEntity): entity is TypeEntityWithMembers;
+export type TypeOrExtensionEntity = TypeEntity | TypeExtensionEntity;
+export type TypeWithMembersOrExtensionEntity = TypeEntityWithMembers | TypeExtensionEntity;
+export declare function isTypeWithMembersOrExtensionEntity(entity: Entity): entity is TypeWithMembersOrExtensionEntity;
 export declare function isTypeEntity(entity: Entity): entity is TypeEntity;
 export declare function isNamedTypeEntity(entity: TypeEntity): entity is NamedTypeEntity;
 export type PackageMemberEntity = PackageVariableEntity | PackageMethodEntity | PackageTypeEntity | TypeExtensionEntity;

package/build/types/parser/Scanner.d.ts

@@ -23,9 +23,8 @@ export declare class Scanner {
     constructor(text: string, options?: ScannerOptions);
     getToken(): Token;
     lookAhead(callback: () => boolean): boolean;
-    tryScan(callback: () => boolean): boolean;
+    tryScan<T>(callback: () => T): T | undefined;
     nextToken(): Token;
-    private tryScanOrLookAhead;
     private isCloseBraceEndingTextTemplate;
     private scanCharOrTextOrTextTemplateElement;
     private isSingleCharOrEscapedChar;

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

@@ -34,7 +34,6 @@ export declare class CompletionService {
     private getCompletionItemInfosForTargetSignaturesValueParameters;
     private getScopeCompletionItemInfos;
     private getTypeCompletionItemInfos;
-    private getEntityFromType;
     private getTypeCompletionItemInfosFromPackage;
     private getTypeCompletionItemInfosFromPackageNameSegment;
     private getTypeCompletionItemInfosFromScope;

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

@@ -1,4 +1,5 @@
 import { AccessedMethod } from '../analysis/AccessedMethod.js';
+import { PackageNameTreeNode } from '../analysis/ImportedPackageNameTree.js';
 import { Localization } from '../analysis/Localization.js';
 import { LocalizationContext, NamedEntity } from '../analysis/LocalizationContext.js';
 import { SubstitutedMethod } from '../analysis/SubstitutedMethod.js';
@@ -19,6 +20,7 @@ export declare class DisplayService {
     getNamedTypeDisplayParts(type: NamedType): NamedTypeDisplayParts;
     displayPackageAliasEntity(entity: e.PackageAliasEntity): string;
     displayPackage(package_: e.PackageEntity): string;
+    displayPackageNameTreeNode(node: PackageNameTreeNode): string;
     displayValueParameterDeclaration(parameter: ValueParameterDeclaration, typeDisplayOptions?: TypeDisplayOptions): string;
     getValueParameterDeclarationDisplayParts(parameter: ValueParameterDeclaration, typeDisplayOptions?: TypeDisplayOptions): ValueParameterDeclarationDisplayParts;
     displayMethodDeclaration(method: MethodDeclaration): string;
@@ -52,11 +54,11 @@ export declare class DisplayService {
     private displayMethodTypeUsage;
     private displayParameterTypeUsage;
     private displayAliasTypeUsage;
-    private displayUnionTypeUsage;
+    private displayUnionOrIntersectionTypeUsage;
     private displayUnresolvedTypeUsage;
     private displayTypeInternal;
     private displayTypeUsageInternal;
-    private displayUnionTypeTypes;
+    private displayUnionOrIntersectionTypeTypes;
     private displayDeclarationContainer;
     private getEntityName;
 }
@@ -614,7 +616,7 @@ interface IOperatorDeclaration {
     getReturnType(): types.Type;
     getContainer(analyzer: Analyzer | undefined): DeclarationContainer | undefined;
 }
-export type TypeUsage = StructuredTypeUsage | VariantTypeUsage | MethodTypeUsage | AliasTypeUsage | ParameterTypeUsage | UnionTypeUsage | UnresolvedTypeUsage;
+export type TypeUsage = StructuredTypeUsage | VariantTypeUsage | MethodTypeUsage | AliasTypeUsage | ParameterTypeUsage | UnionOrIntersectionTypeUsage | UnresolvedTypeUsage;
 export type StructuredTypeUsage = StructuredTypeUsage_type | StructuredTypeUsage_entity;
 export declare class StructuredTypeUsage_type implements IStructuredTypeUsage {
     readonly type: types.StructuredType;
@@ -740,11 +742,12 @@ interface IParameterTypeUsage {
     getEntity(): e.NamedTypeEntity;
     isNoneExcluded(): boolean;
 }
-type UnionTypeUsage = UnionTypeUsage_type;
-declare class UnionTypeUsage_type {
-    readonly type: types.UnionType;
-    readonly kind = "union";
-    constructor(type: types.UnionType);
+type UnionOrIntersectionTypeUsage = UnionOrIntersectionTypeUsage_type;
+declare class UnionOrIntersectionTypeUsage_type {
+    readonly type: types.UnionType | types.IntersectionType;
+    readonly kind = "union-or-intersection";
+    constructor(type: types.UnionType | types.IntersectionType);
+    isUnionType(): boolean;
     getOriginalTypes(): readonly types.Type[];
     getUnaliasedFlattenedTypes(): readonly types.Type[];
 }

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

@@ -1,10 +1,11 @@
 import { AccessedMethod } from '../analysis/AccessedMethod.js';
 import { MatchResultValueParameter } from '../analysis/ArgumentToParameterMatchResult.js';
+import { PackageNameTreeNode } from '../analysis/ImportedPackageNameTree.js';
+import { Analyzer } from '../analysis/index.js';
 import { Translation, WithLocalization } from '../analysis/Localization.js';
 import { TypeIndexedAccessorDeclaration } from '../analysis/NodeTypeUtils.js';
-import { Analyzer } from '../analysis/index.js';
 import { AccessKind, ReadonlyNonEmptyArray } from '../common/index.js';
-import { AliasTypeEntity, Entity, MethodEntity, MethodTypeEntity, PackageAliasEntity, PackageEntity, StructuredTypeEntity, TypeParameterEntity, VariableEntity, VariantTypeEntity } from '../entities/index.js';
+import { AliasTypeEntity, Entity, MethodEntity, MethodTypeEntity, PackageEntity, StructuredTypeEntity, TypeParameterEntity, VariableEntity, VariantTypeEntity } from '../entities/index.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
 import { TokenOrKeyword } from './TreeUtils.js';
@@ -53,15 +54,14 @@ export declare class ReferenceNodeSemanticInfo {
     get firstBetterTargetWithFallback(): WithLocalization<ReferenceTarget>;
     constructor(targets: ReadonlyNonEmptyArray<WithLocalization<ReferenceTarget>>, isAmbiguous: boolean, betterTargets?: ReadonlyNonEmptyArray<WithLocalization<ReferenceTarget>> | undefined);
 }
-export type ReferenceTarget = EntityReferenceTarget | TypeVariableReferenceTarget | TypeValueParameterReferenceTarget | TypeConstructorReferenceTarget | OperatorReferenceTarget | TypeDereferenceOperatorReferenceTarget | AccessedMethodReferenceTarget | TypeIndexerReferenceTarget | MatchResultValueParameterReferenceTarget | PackageReferenceTarget | TypeContextReferenceTarget;
+export type ReferenceTarget = EntityReferenceTarget | TypeVariableReferenceTarget | TypeValueParameterReferenceTarget | TypeConstructorReferenceTarget | OperatorReferenceTarget | TypeDereferenceOperatorReferenceTarget | AccessedMethodReferenceTarget | TypeIndexerReferenceTarget | MatchResultValueParameterReferenceTarget | PackageReferenceTarget | PackageNameTreeNodeReferenceTarget | TypeContextReferenceTarget;
 export declare class EntityReferenceTarget {
-    readonly entity: ReferencedEntity;
+    readonly entity: Entity;
     readonly accessKind: AccessKind;
     readonly narrowedType?: types.Type | undefined;
     readonly kind = "entity";
-    constructor(entity: ReferencedEntity, accessKind: AccessKind, narrowedType?: types.Type | undefined);
+    constructor(entity: Entity, accessKind: AccessKind, narrowedType?: types.Type | undefined);
 }
-export type ReferencedEntity = VariableEntity | VariantTypeEntity | MethodEntity | TypeParameterEntity | MethodTypeEntity | StructuredTypeEntity | PackageAliasEntity | AliasTypeEntity;
 export declare class TypeVariableReferenceTarget {
     readonly variable: types.Variable;
     readonly accessKind: AccessKind;
@@ -107,6 +107,11 @@ export declare class PackageReferenceTarget {
     readonly kind = "package";
     constructor(package_: PackageEntity);
 }
+export declare class PackageNameTreeNodeReferenceTarget {
+    readonly node: PackageNameTreeNode;
+    readonly kind = "package-name-tree-node";
+    constructor(node: PackageNameTreeNode);
+}
 export declare class TypeContextReferenceTarget {
     readonly type: types.Type;
     readonly typeContextKind: 'object' | 'base';

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

@@ -42,6 +42,7 @@ export declare class EntityToSyntax {
     private convertAliasType;
     private convertParameterType;
     private convertUnionType;
+    private convertIntersectionType;
     private convertUnresolvedType;
     private createNamedTypeSpecifier;
 }