@artel/artc 0.6.25254 → 0.6.25255

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

@@ -0,0 +1,13 @@
+import { Analyzer } from './Analyzer.js';
+import * as tree from '../tree/index.js';
+import { LocalVariableEntity } from '../entities/VariableEntity.js';
+import * as types from '../types/index.js';
+export declare class ReturnTypeInferrer {
+    private readonly _analyzer;
+    private readonly _block;
+    private readonly _resultVariable;
+    constructor(_analyzer: Analyzer, _block: tree.FunctionBlock, _resultVariable: LocalVariableEntity);
+    infer(): types.Type;
+    private checkResultVariableIsUsedAndCollectReturnedTypes;
+    private getTypeOfResultVariableAtTheEndOfSubprogram;
+}

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

@@ -1,18 +1,20 @@
 import { Name } from '../common/index.js';
-import { FunctionEntity, ParameterVariableEntity } from '../entities/index.js';
+import { FunctionEntity, PackageOrNestedFunctionEntity, ParameterVariableEntity } from '../entities/index.js';
 import * as types from '../types/index.js';
 export type SubstitutedFunction = SubstitutedFunction_entity | SubstitutedFunction_typeMember;
 export declare class SubstitutedFunction_entity implements ISubstitutedFunction {
-    readonly entity: FunctionEntity;
+    readonly entity: PackageOrNestedFunctionEntity;
     readonly entitySignatureType: types.FunctionType;
     readonly substitutions: types.Substitutions;
     readonly kind = "entity";
     private readonly _signatureType;
-    constructor(entity: FunctionEntity, entitySignatureType: types.FunctionType, substitutions: types.Substitutions);
-    getEntity(): FunctionEntity;
+    get debuggerDisplay(): string;
+    constructor(entity: PackageOrNestedFunctionEntity, entitySignatureType: types.FunctionType, substitutions: types.Substitutions);
+    getEntity(): PackageOrNestedFunctionEntity;
     getName(): Name;
     getSignatureType(): types.FunctionType;
     getSubstitutions(): types.Substitutions;
+    getCombinedSubstitutions(): types.Substitutions;
     getValueParameters(): readonly {
         entity: ParameterVariableEntity;
         type: types.Type;
@@ -24,11 +26,14 @@ export declare class SubstitutedFunction_typeMember implements ISubstitutedFunct
     readonly substitutions: types.Substitutions;
     readonly kind = "type-member";
     private readonly _signatureType;
+    private readonly _combinedSubstitutions;
+    get debuggerDisplay(): string;
     constructor(method: types.Method, substitutions: types.Substitutions);
     getEntity(): FunctionEntity;
     getName(): Name;
     getSignatureType(): types.FunctionType;
     getSubstitutions(): types.Substitutions;
+    getCombinedSubstitutions(): types.Substitutions;
     getValueParameters(): readonly {
         entity: ParameterVariableEntity;
         type: types.Type;
@@ -40,6 +45,7 @@ interface ISubstitutedFunction {
     getName(): Name;
     getSignatureType(): types.FunctionType;
     getSubstitutions(): types.Substitutions;
+    getCombinedSubstitutions(): types.Substitutions;
     getValueParameters(): readonly {
         entity: ParameterVariableEntity;
         type: types.Type;

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

@@ -1,8 +1,8 @@
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
-import { FunctionEntity, NamedTypeEntity, PackageAliasEntity } from '../entities/index.js';
+import { NamedTypeEntity, PackageAliasEntity } from '../entities/index.js';
 import { Tag } from '../tree/index.js';
 import * as types from '../types/index.js';
-import { AccessedFunction } from './AccessedFunction.js';
+import { AccessedFunction, NotSubstitutedAccessedFunction } from './AccessedFunction.js';
 import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
 import { Analyzer } from './index.js';
 import { EntityOrPackageNameTreeNode } from './Utils.js';
@@ -15,34 +15,35 @@ export declare class Resolver {
     resolve(): ResolutionResult;
     private resolveNameInScope;
     private resolveNameInPackage;
-    private resolveTypeOverload;
     private resolveTagType;
     private resolveTagFunction;
-    private createAccessedFunction;
-    private resolveFunctionOverload;
 }
 export declare class ResolutionResult {
     readonly meaning: Meaning;
     readonly resolvedQualifiers: readonly ResolvedQualifier[];
-    readonly diagnostic?: Diagnostic | undefined;
-    readonly ambiguousDeclarations?: readonly EntityOrPackageNameTreeNode[] | undefined;
-    constructor(meaning: Meaning, resolvedQualifiers: readonly ResolvedQualifier[], diagnostic?: Diagnostic | undefined, ambiguousDeclarations?: readonly EntityOrPackageNameTreeNode[] | undefined);
+    readonly diagnostics?: readonly Diagnostic[];
+    readonly ambiguousDeclarations?: readonly EntityOrPackageNameTreeNode[];
+    constructor(meaning: Meaning, resolvedQualifiers: readonly ResolvedQualifier[], diagnostics?: (readonly Diagnostic[]) | Diagnostic, ambiguousDeclarations?: readonly EntityOrPackageNameTreeNode[]);
 }
 export type Meaning = Meaning_tagType | Meaning_tagFunction | Meaning_unresolved;
 declare class Meaning_tagType {
     readonly type: types.Type;
     readonly candidates: readonly types.Constructor[];
     readonly suitableConstructors: readonly types.Constructor[];
+    readonly singleNotSuitableSubstitutedCandidate: types.Constructor | undefined;
     readonly kind = "tag-type";
     get singleSuitableConstructor(): types.Constructor | undefined;
-    constructor(type: types.Type, candidates: readonly types.Constructor[], suitableConstructors: readonly types.Constructor[]);
+    get singleConstructor(): types.Constructor | undefined;
+    constructor(type: types.Type, candidates: readonly types.Constructor[], suitableConstructors: readonly types.Constructor[], singleNotSuitableSubstitutedCandidate: types.Constructor | undefined);
 }
 declare class Meaning_tagFunction {
-    readonly candidates: readonly AccessedFunction[];
+    readonly candidates: readonly NotSubstitutedAccessedFunction[];
     readonly suitableFunctions: readonly AccessedFunction[];
+    readonly singleNotSuitableSubstitutedCandidate: AccessedFunction | undefined;
     readonly kind = "tag-function";
     get singleSuitableFunction(): AccessedFunction | undefined;
-    constructor(candidates: readonly AccessedFunction[], suitableFunctions: readonly AccessedFunction[]);
+    get singleFunction(): AccessedFunction | undefined;
+    constructor(candidates: readonly NotSubstitutedAccessedFunction[], suitableFunctions: readonly AccessedFunction[], singleNotSuitableSubstitutedCandidate: AccessedFunction | undefined);
 }
 declare class Meaning_unresolved {
     readonly kind = "unresolved";
@@ -66,10 +67,10 @@ export declare class ResolvedQualifier_type {
     constructor(candidates: readonly NamedTypeEntity[], suitableTypes: readonly NamedTypeEntity[]);
 }
 export declare class ResolvedQualifier_function {
-    readonly candidates: readonly FunctionEntity[];
-    readonly suitableFunctions: readonly FunctionEntity[];
+    readonly candidates: readonly NotSubstitutedAccessedFunction[];
+    readonly suitableFunctions: readonly AccessedFunction[];
     readonly kind = "function";
-    get singleSuitableFunction(): FunctionEntity | undefined;
-    constructor(candidates: readonly FunctionEntity[], suitableFunctions: readonly FunctionEntity[]);
+    get singleSuitableFunction(): AccessedFunction | undefined;
+    constructor(candidates: readonly NotSubstitutedAccessedFunction[], suitableFunctions: readonly AccessedFunction[]);
 }
 export {};

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

@@ -0,0 +1,49 @@
+import { TypeParameterEntity } from '../entities/index.js';
+import * as tree from '../tree/index.js';
+import * as types from '../types/index.js';
+import { Analyzer, InferenceOptions } from './Analyzer.js';
+export type Argument = SourceArgument | IntrinsicArgument;
+export interface SourceArgument {
+    readonly kind: 'source';
+    readonly expression: tree.Expression;
+}
+export interface IntrinsicArgument {
+    readonly kind: 'intrinsic';
+    readonly type: types.Type;
+}
+export declare class ArgumentWithTargetParameterInfo {
+    readonly value: Argument;
+    readonly parameterType: types.Type;
+    constructor(value: Argument, parameterType: types.Type);
+}
+export declare class TypeArgumentInferrer {
+    private readonly _analyzer;
+    private readonly _typeParameters;
+    private readonly _arguments;
+    private readonly _inferenceOptions;
+    private readonly _returnType;
+    private readonly _outerSubstitutions;
+    private readonly _inferenceStates;
+    /**
+     * Специальный экземпляр типа, который используется как признак того, что вывод аргументов типа не удался.
+     */
+    private readonly _unresolvedType;
+    private _inferenceHasFailed;
+    constructor(analyzer: Analyzer, typeParameters: readonly TypeParameterEntity[], args: readonly ArgumentWithTargetParameterInfo[], inferenceOptions: InferenceOptions, returnType: types.Type | undefined, outerTypeSubstitutions: types.Substitutions | undefined);
+    infer(): readonly types.Type[] | undefined;
+    private inferFirstStage;
+    private inferSecondStage;
+    private inferFromTypes;
+    private inferToParameterType;
+    private inferToStructuredType;
+    private inferFromSubstitutions;
+    private inferToUnionType;
+    private inferFromFunctionTypes;
+    private createSubstitutions;
+    private inferFromTargetTypeDependentExpression;
+    private tryGetInferredType;
+    private tryFixTypeParametersContainedByTypesOfFunctionParameters;
+    private typeContainsTypeParameter;
+    private substitutionsContainTypeParameter;
+    private isDefinitelyTargetTypeDependentExpression;
+}

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

@@ -1,16 +1,18 @@
+import { PackageLocale } from '../common/index.js';
 import * as types from '../types/index.js';
 import { Analyzer } from './Analyzer.js';
 import * as controlFlow from './control-flow/index.js';
+import { NarrowableReference } from './control-flow/index.js';
 export declare class TypeNarrower {
     private readonly _analyzer;
-    private readonly _referenceExpression;
+    private readonly _reference;
     private readonly _initialType;
+    private readonly _locale;
     private readonly _controlFlowNode;
-    private _reference;
     private readonly _typeByNode;
     private readonly _isVariableAssignedInLoopCheckResults;
-    private get locale();
-    constructor(analyzer: Analyzer, referenceExpression: controlFlow.NarrowableReferenceExpression, initialType: types.Type, controlFlowNode: controlFlow.Node);
+    constructor(analyzer: Analyzer, reference: NarrowableReference, locale: PackageLocale, initialType: types.Type, controlFlowNode: controlFlow.Node);
+    static getTypeOfExpression(analyzer: Analyzer, referenceExpression: controlFlow.NarrowableReferenceExpression, initialType: types.Type, controlFlowNode: controlFlow.Node): types.Type;
     getType(): types.Type;
     private getTypeAtControlFlowNode;
     private getTypeAtCondition;

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

@@ -1,5 +1,7 @@
-export declare class Resolver<TCandidate extends ICandidate> {
-    resolveByArgumentCount(candidates: readonly TCandidate[], argumentCount: number): readonly TCandidate[];
+import { NamedTypeEntity } from '../entities/index.js';
+export declare class Resolver {
+    static resolve<TCandidate extends ICandidate>(candidates: readonly TCandidate[], argumentCount: number): readonly TCandidate[];
+    static resolveByNamedTypeEntities<T extends NamedTypeEntity>(candidates: readonly T[], argumentCount: number): readonly T[];
 }
 export interface ICandidate {
     getParameterCount(): number;

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

@@ -1,6 +1,6 @@
 import { WithDiagnostics } from '../common/index.js';
 import { BinaryOperatorKind } from '../entities/OperatorKind.js';
-import { Expression, Node } from '../tree/index.js';
+import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
 import { Analyzer } from './index.js';
 /**
@@ -26,11 +26,7 @@ export declare class UserDefinableBinaryOperatorResolver {
     private readonly _right;
     private readonly _operatorKind;
     private readonly _operatorNodeForDiagnostic;
-    private readonly _leftType;
-    private readonly _rightType;
-    private get leftType();
-    private get rightType();
-    constructor(_analyzer: Analyzer, _left: Expression, _right: Expression, _operatorKind: BinaryOperatorKind, _operatorNodeForDiagnostic: Node);
+    constructor(_analyzer: Analyzer, _left: tree.Expression, _right: tree.Expression, _operatorKind: BinaryOperatorKind, _operatorNodeForDiagnostic: tree.Node);
     resolve(): WithDiagnostics<types.Operator>;
     private chooseSuitableOperators;
 }

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

@@ -1,5 +1,5 @@
 import { WithDiagnostics } from '../common/index.js';
-import { PrefixUnaryExpression } from '../tree/index.js';
+import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
 import { Analyzer } from './index.js';
 /**
@@ -17,6 +17,6 @@ export declare class UserDefinableUnaryOperatorResolver {
     private readonly _analyzer;
     private readonly _node;
     private get operatorKind();
-    constructor(_analyzer: Analyzer, _node: PrefixUnaryExpression);
+    constructor(_analyzer: Analyzer, _node: tree.PrefixUnaryExpression);
     resolve(): WithDiagnostics<types.Operator>;
 }

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

@@ -7,6 +7,8 @@ type TextToken = tree.Token<tree.TokenKind.TextLiteral> | tree.Token<tree.TokenK
 export declare function getUnescapedTextFromTextToken(token: TextToken): string;
 export declare function unwrapParenthesizedExpressions(expression: tree.Expression): tree.Expression;
 export declare function getParentSkippingParenthesizedExpressions(expression: tree.Expression): tree.ExpressionParent;
+export declare function getParentGenericSpecializationExpression(expression: tree.Expression): tree.GenericSpecializationExpression | undefined;
+export declare function getGenericSpecializationExpressionOfCallee(callee: tree.Expression): tree.GenericSpecializationExpression | undefined;
 export declare function unaliasType(type: types.Type): types.Type;
 export declare function unaliasType(type: types.Type | undefined): types.Type | undefined;
 export declare function getPackageContainingEntity(entity: Entity): PackageEntity;

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

@@ -3,8 +3,6 @@ export * from './ArgumentsToParametersMatcher.js';
 export * from './DeclarationsUsageCounter.js';
 export * from './DiagnosticCollector.js';
 export * from './FindModifier.js';
-export * from './OverloadResolver.js';
 export * from './SourcePackageDependencyGraph.js';
-export * from './TargetTypeHint.js';
 export * from './Visitor.js';
 export * from './WellKnownDeclarations.js';

package/build/types/analysis/semantic-context/Declarations.d.ts

@@ -1,5 +1,5 @@
 import { Name } from '../../common/index.js';
-import { EntityHidingLevel, FunctionEntity, NamedTypeEntity, PackageAliasEntity, VariableEntity } from '../../entities/index.js';
+import { EntityHidingLevel, FunctionEntity, NamedTypeEntity, PackageAliasEntity, PackageOrNestedFunctionEntity, VariableEntity } from '../../entities/index.js';
 import * as types from '../../types/index.js';
 import { PackageNameTreeNode } from '../ImportedPackageNameTree.js';
 export type TypeOrContainerWithTypes = NamedDeclaration_type | NamedDeclaration_packageAlias | NamedDeclaration_packageNameSegment;
@@ -15,10 +15,10 @@ export type NamedDeclarationFunction = NamedDeclarationFunction_entity | NamedDe
 export declare class NamedDeclarationFunction_entity implements INamedDeclarationFunction {
     readonly kind = "entity";
     private readonly _valueParameters;
-    readonly value: FunctionEntity;
-    constructor(value: FunctionEntity);
+    readonly value: PackageOrNestedFunctionEntity;
+    constructor(value: PackageOrNestedFunctionEntity);
     getName(): Name;
-    getEntity(): FunctionEntity;
+    getEntity(): PackageOrNestedFunctionEntity;
     getTypeParameterArity(): number;
     isHidden(): EntityHidingLevel | undefined;
     getValueParameters(): readonly ValueParameter[];

package/build/types/analysis/semantic-context/SemanticContextBuilder.d.ts

@@ -81,6 +81,7 @@ export declare class SemanticContextBuilder {
     private ofIndexedElementGetterDeclarationChild;
     private ofIndexedElementSetterDeclarationChild;
     private ofChildOfTypeExtensionDeclaration;
+    private isOffsetInsideNode;
     private isOffsetBetweenNodes;
     private isOffsetInsideStatementBlock;
     private isOffsetInsideFunctionBlock;

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

@@ -22,7 +22,6 @@ export * from '../analysis/SourcePackageDependencyGraph.js';
 export * from '../analysis/SubstitutedFunction.js';
 export type { Meaning as TagMeaning } from '../analysis/TagMeaning.js';
 export * from '../analysis/Tags.js';
-export * from '../analysis/TargetTypeHint.js';
 export * from '../analysis/TypeMemberLookup.js';
 export * from '../analysis/Utils.js';
 export * from '../analysis/Visitor.js';
@@ -43,7 +42,6 @@ export * from '../parser/Scanner.js';
 export { TokenKind as ScannerTokenKind } from '../parser/TokenKind.js';
 export * from '../parser/UnescapeText.js';
 export * from '../project/index.js';
-export * as green from '../tree/green/index.js';
 export * as tree from '../tree/index.js';
 export * from '../ts-interop/TsLibrariesProvider.js';
 export * from '../ts-interop/Utils.js';

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

@@ -5,8 +5,9 @@ export declare class ArrayUtils {
      * Работает быстрее, чем `array.splice(index, 1)`, и не выделяет память для массива удалённых элементов.
      */
     static removeElement<T>(array: T[], index: number): void;
-    static pushElementIfUniqueComparingWithEquals<T extends WithEqualsMethod<T>>(array: T[], element: T): boolean;
-    static pushElementsIfUniqueComparingWithEquals<T extends WithEqualsMethod<T>>(array: T[], elements: readonly T[]): void;
+    static pushElementIfUniqueComparingWithEquals<T extends WithEqualsMethod<T>>(array: T[] | undefined, element: T): boolean;
+    static pushElementsIfUniqueComparingWithEquals<T extends WithEqualsMethod<T>>(array: T[] | undefined, elements: readonly T[]): void;
+    static count<T>(array: readonly T[], cb: (v: T) => boolean): number;
 }
 export type WithEqualsMethod<T> = {
     equals(t: T): boolean;

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

@@ -2,6 +2,8 @@ export declare class Cached<T> {
     private _hasValue;
     private _value?;
     private _isEvaluating;
+    get hasValue(): boolean;
+    insert(value: T): void;
     getOrInsertWith(fn: () => T): T;
     clear(): void;
     getCachedValue(): T | undefined;

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

@@ -5,7 +5,7 @@ export declare abstract class Query<T> implements Iterable<T> {
     static empty<T>(): Query<T>;
     static ofSuccessors<T>(first: T, next: (t: T) => T | undefined): Query<T>;
     abstract [Symbol.iterator](): Iterator<T, void, undefined>;
-    map<K>(fn: (t: T) => K): Query<K>;
+    map<K>(fn: (t: T, i: number) => K): Query<K>;
     forEach(fn: (t: T) => void): void;
     exhaust(): void;
     last(): T | undefined;

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

@@ -1,6 +1,6 @@
 import { Analyzer } from '../analysis/index.js';
 import { StructuredTypeDeclaration, TypeWithMembersDeclaration, VariantTypeDeclaration } from '../analysis/NodeTypeUtils.js';
-import { Entity, PackageEntity, TypeEntity, TypeEntityWithMembers } from '../entities/index.js';
+import { PackageEntity, TypeEntity, TypeEntityWithMembers } from '../entities/index.js';
 import { SourceFile } from '../project/index.js';
 import * as tree from '../tree/index.js';
 import { PackageLocale } from './PackageLocale.js';
@@ -12,7 +12,6 @@ export declare abstract class TreeQuery {
     projectSourceFile(analyzer: Analyzer): SourceFile;
     packageEntity(analyzer: Analyzer): PackageEntity;
     locale(analyzer: Analyzer): PackageLocale;
-    containingEntity(analyzer: Analyzer): Entity;
 }
 declare class NodeQuery extends TreeQuery {
     private readonly _node;

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

@@ -1,3 +1,4 @@
+import { DiagnosticArgumentFactory } from '../analysis/DiagnosticArgumentFactory.js';
 import { Range } from '../common/index.js';
 import { TextFile } from '../project/TextFile.js';
 import { DiagnosticData } from './DiagnosticData.js';
@@ -14,6 +15,12 @@ export declare class DiagnosticLocation {
 export interface DiagnosticAcceptor {
     addDiagnostic(diagnostic: Diagnostic): void;
 }
+export declare class DiagnosticAcceptorWithArgumentFactory implements DiagnosticAcceptor {
+    readonly diagnosticAcceptor: DiagnosticAcceptor;
+    readonly argumentFactory: DiagnosticArgumentFactory;
+    constructor(diagnosticAcceptor: DiagnosticAcceptor, argumentFactory: DiagnosticArgumentFactory);
+    addDiagnostic(diagnostic: Diagnostic): void;
+}
 export declare class AccumulatingDiagnosticAcceptor implements DiagnosticAcceptor {
     readonly items: Diagnostic[];
     constructor(items?: Diagnostic[]);