@artel/artc 0.6.26030 → 0.6.26032

package/build/Cli.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 import {
   CommandLineCompiler
-} from "./chunk-54PBDJ2W.js";
-import "./chunk-HHCWDLSE.js";
+} from "./chunk-YMWJL3GM.js";
+import "./chunk-RTJ7RFEG.js";
 import {
   __async
-} from "./chunk-VD3HHVCM.js";
+} from "./chunk-ONUJ6R7X.js";
 
 // source/Cli.ts
 function main() {

package/build/api/Api.js

@@ -1,6 +1,6 @@
 import {
   Compiler
-} from "../chunk-HHCWDLSE.js";
+} from "../chunk-RTJ7RFEG.js";
 import {
   AccessKind,
   AccessedFunction_entity,
@@ -310,7 +310,7 @@ import {
   withoutQuotes,
   withoutTemplateQuotes,
   yieldTask
-} from "../chunk-VD3HHVCM.js";
+} from "../chunk-ONUJ6R7X.js";
 export {
   AccessKind,
   AccessedFunction_entity,

package/build/api/ApiNodeJS.js

@@ -6,9 +6,9 @@ import {
   PhysicalFileSystem,
   PhysicalTypeScriptLibrariesProvider,
   PrintingDiagnosticAcceptor
-} from "../chunk-54PBDJ2W.js";
-import "../chunk-HHCWDLSE.js";
-import "../chunk-VD3HHVCM.js";
+} from "../chunk-YMWJL3GM.js";
+import "../chunk-RTJ7RFEG.js";
+import "../chunk-ONUJ6R7X.js";
 export {
   CommandLineCompiler,
   FileSystemUri,

package/build/api/ApiServices.js

@@ -107,7 +107,7 @@ import {
   sortModifiers,
   traverseTreeAsync,
   yieldTask
-} from "../chunk-VD3HHVCM.js";
+} from "../chunk-ONUJ6R7X.js";
 
 // source/services/common/Types.ts
 import * as ls from "vscode-languageserver";

package/build/{chunk-VD3HHVCM.js → chunk-ONUJ6R7X.js}

@@ -764,7 +764,7 @@ var UniqueWithComparatorQuery = class extends Query {
 };
 
 // source/common/Constants.ts
-var ArtelVersion = true ? "0.6.26030" : "";
+var ArtelVersion = true ? "0.6.26032" : "";
 var ArtelSourceFileExtensions = [".\u0430\u0440\u0442", ".\u0430\u0440\u0442\u0435\u043B\u044C", ".art", ".artel", ".\u0430\u0440\u0442\u043C", ".\u0430\u0440\u0442\u0435\u043B\u044C\u043C", ".artm", ".artelm"];
 var ArtelSourceFileExtensionSet = new Set(ArtelSourceFileExtensions);
 var ArtelSourceAndConfigurationFileExtensionSet = new Set(ArtelSourceFileExtensionSet).add(".json");
@@ -49103,7 +49103,15 @@ var TsParameterEntity = class {
   getType() {
     return this.type.getOrInsertWith(() => {
       const tsType = this.tsctx.tsChecker.getTypeOfSymbol(this.symbol);
-      return this.tsctx.type.ofTsType(tsType);
+      let result = this.tsctx.type.ofTsType(tsType);
+      if (this.isVariadic()) {
+        const elementType = this.tsctx.analyzer.ifTypeArrayOrReadonlyArrayThenElementType(result);
+        if (elementType !== void 0) {
+          const entity = this.tsctx.analyzer.getLocalizedWellKnownDeclarations(this.getLocale()).parameterArray;
+          result = this.tsctx.analyzer.instantiateType(entity, [elementType]);
+        }
+      }
+      return result;
     });
   }
   getDefinition() {
@@ -49135,7 +49143,7 @@ var TsParameterEntity = class {
   }
   isOptional() {
     const decl = this.getDeclaration();
-    return decl !== void 0 && this.tsctx.tsChecker.isOptionalParameter(decl);
+    return decl !== void 0 && this.tsctx.tsChecker.isOptionalParameter(decl) || this.isVariadic();
   }
   isVariadic() {
     return this.getDeclaration()?.dotDotDotToken !== void 0;
@@ -67590,6 +67598,9 @@ var Parameter2 = class {
   isOptional() {
     return this.entity.isOptional();
   }
+  isVariadic() {
+    return this.entity.isVariadic();
+  }
 };
 var FunctionTypeMatcherSignature = class {
   constructor(analyzer, value) {
@@ -70846,62 +70857,48 @@ var OverloadResolver = class {
     let bestSignature = matchingSignatures[0];
     for (let i = 1; i < matchingSignatures.length && bestSignature !== void 0; i++) {
       const currentSignature = matchingSignatures[i];
-      const betterTypeCheckResults = new Array();
-      for (const argument2 of this.arguments_) {
-        const bestSignatureTargetParameter = bestSignature.matchResult.mapping.get(argument2);
-        const currentSignatureTargetParameter = currentSignature.matchResult.mapping.get(argument2);
-        if (bestSignatureTargetParameter === void 0 || currentSignatureTargetParameter === void 0) {
-          bestSignature = void 0;
-          break;
-        }
-        const bestSignatureTargetParameterType = bestSignature.substitutedParameterTypes[bestSignatureTargetParameter.getIndex()];
-        const argumentTypeWithBestSignature = argument2.getType(
-          this.analysisOptions.withTargetTypeAndAllowCaching(bestSignatureTargetParameterType, false)
-        );
-        const currentSignatureTargetParameterType = currentSignature.substitutedParameterTypes[currentSignatureTargetParameter.getIndex()];
-        const argumentTypeWithCurrentSignature = argument2.getType(
-          this.analysisOptions.withTargetTypeAndAllowCaching(currentSignatureTargetParameterType, false)
-        );
-        const checkResult = this.chooseBetterTargetType(
-          bestSignatureTargetParameterType,
-          argumentTypeWithBestSignature,
-          currentSignatureTargetParameterType,
-          argumentTypeWithCurrentSignature
-        );
-        betterTypeCheckResults.push(checkResult);
-      }
-      if (bestSignature === void 0) {
-        break;
-      }
-      if (betterTypeCheckResults.every((c) => c === 1 /* TypeAIsBetter */ || c === 0 /* Equally */) && betterTypeCheckResults.some((c) => c === 1 /* TypeAIsBetter */)) {
-      } else if (betterTypeCheckResults.every((c) => c === 2 /* TypeBIsBetter */ || c === 0 /* Equally */) && betterTypeCheckResults.some((c) => c === 2 /* TypeBIsBetter */)) {
-        bestSignature = currentSignature;
-      } else {
+      const newBestSignature = this.tryChooseBetterSignatureBasedOnParameterTypes(bestSignature, currentSignature) ?? this.tryChooseBetterSignatureBasedOnVariadicParameters(bestSignature, currentSignature) ?? this.tryChooseBetterSignatureBasedOnPresenceOfTypeParameters(bestSignature, currentSignature) ?? this.tryChooseBetterSignatureBasedOnParameterCount(bestSignature, currentSignature);
+      if (newBestSignature === void 0) {
         bestSignature = void 0;
+        break;
       }
+      bestSignature = newBestSignature;
     }
-    if (bestSignature !== void 0) {
-      return bestSignature;
-    }
-    const signaturesWithTypeParametersCount = ArrayUtils.count(
-      matchingSignatures,
-      (s) => s.value.getTypeParameters().length > 0
-    );
-    if (signaturesWithTypeParametersCount !== matchingSignatures.length) {
-      matchingSignatures = matchingSignatures.filter((s) => s.value.getTypeParameters().length === 0);
-    }
-    if (matchingSignatures.length === 1) {
-      return matchingSignatures[0];
-    }
-    const signatureWithLeastParameterCount = Query.minByValue(matchingSignatures, (s) => s.value.getParameters().length);
-    if (signatureWithLeastParameterCount !== void 0) {
-      const parameterCount = signatureWithLeastParameterCount.value.getParameters().length;
-      const isSingle = Query.from(matchingSignatures).count((s) => s.value.getParameters().length === parameterCount) === 1;
-      if (isSingle) {
-        return signatureWithLeastParameterCount;
+    return bestSignature;
+  }
+  tryChooseBetterSignatureBasedOnParameterTypes(signature1, signature2) {
+    const betterTypeCheckResults = new Array();
+    for (const argument2 of this.arguments_) {
+      const signature1TargetParameter = signature1.matchResult.mapping.get(argument2);
+      const signature2TargetParameter = signature2.matchResult.mapping.get(argument2);
+      if (signature1TargetParameter === void 0 || signature2TargetParameter === void 0) {
+        return void 0;
       }
+      const signature1TargetParameterType = signature1.substitutedParameterTypes[signature1TargetParameter.getIndex()];
+      const argumentTypeWithSignature1 = argument2.getType(
+        this.analysisOptions.withTargetTypeAndAllowCaching(signature1TargetParameterType, false)
+      );
+      const signature2TargetParameterType = signature2.substitutedParameterTypes[signature2TargetParameter.getIndex()];
+      const argumentTypeWithSignature2 = argument2.getType(
+        this.analysisOptions.withTargetTypeAndAllowCaching(signature2TargetParameterType, false)
+      );
+      const checkResult = this.chooseBetterTargetType(
+        signature1TargetParameterType,
+        argumentTypeWithSignature1,
+        signature2TargetParameterType,
+        argumentTypeWithSignature2
+      );
+      betterTypeCheckResults.push(checkResult);
     }
-    return void 0;
+    let result;
+    if (betterTypeCheckResults.every((c) => c === 1 /* TypeAIsBetter */ || c === 0 /* Equally */) && betterTypeCheckResults.some((c) => c === 1 /* TypeAIsBetter */)) {
+      result = signature1;
+    } else if (betterTypeCheckResults.every((c) => c === 2 /* TypeBIsBetter */ || c === 0 /* Equally */) && betterTypeCheckResults.some((c) => c === 2 /* TypeBIsBetter */)) {
+      result = signature2;
+    } else {
+      result = void 0;
+    }
+    return result;
   }
   chooseBetterTargetType(targetTypeA, typeWhenTargetTypeIsA, targetTypeB, typeWhenTargetTypeIsB) {
     const targetTypeAAssignabilityFlags = this.analyzer.getTypeAssignabilityFlags(typeWhenTargetTypeIsA, targetTypeA);
@@ -70920,6 +70917,45 @@ var OverloadResolver = class {
     }
     return 0 /* Equally */;
   }
+  tryChooseBetterSignatureBasedOnVariadicParameters(signature1, signature2) {
+    let result;
+    const lastSignature1Parameter = signature1.value.getParameters().at(-1);
+    const lastSignature2Parameter = signature2.value.getParameters().at(-1);
+    if (lastSignature2Parameter !== void 0 && lastSignature2Parameter.isVariadic() && (lastSignature1Parameter === void 0 || !lastSignature1Parameter.isVariadic())) {
+      result = signature1;
+    } else if (lastSignature1Parameter !== void 0 && lastSignature1Parameter.isVariadic() && (lastSignature2Parameter === void 0 || !lastSignature2Parameter.isVariadic())) {
+      result = signature2;
+    } else {
+      result = void 0;
+    }
+    return result;
+  }
+  tryChooseBetterSignatureBasedOnPresenceOfTypeParameters(signature1, signature2) {
+    let result;
+    const signature1HasTypeParameters = signature1.value.getTypeParameters().length > 0;
+    const signature2HasTypeParameters = signature2.value.getTypeParameters().length > 0;
+    if (!signature1HasTypeParameters && signature2HasTypeParameters) {
+      result = signature1;
+    } else if (!signature2HasTypeParameters && signature1HasTypeParameters) {
+      result = signature2;
+    } else {
+      result = void 0;
+    }
+    return result;
+  }
+  tryChooseBetterSignatureBasedOnParameterCount(signature1, signature2) {
+    let result;
+    const signature1ParameterCount = signature1.value.getParameters().length;
+    const signature2ParameterCount = signature2.value.getParameters().length;
+    if (signature1ParameterCount === signature2ParameterCount) {
+      result = void 0;
+    } else if (signature1ParameterCount < signature2ParameterCount) {
+      result = signature1;
+    } else {
+      result = signature2;
+    }
+    return result;
+  }
   functionLiteralCouldBeAssignableToType(type) {
     type = type.unalias();
     return type.getEntity()?.getOriginalEntity() === this.analyzer.originalWellKnownDeclarations.object || type.getEntity()?.getOriginalEntity() === this.analyzer.originalWellKnownDeclarations.func || type.kind === "function" || type.kind === "union" && type.originalTypes.some((t) => this.functionLiteralCouldBeAssignableToType(t));
@@ -71268,7 +71304,7 @@ var SignatureParameter = class {
     return this.value.isOptional();
   }
   isVariadic() {
-    return false;
+    return this.value.isVariadic();
   }
 };
 var SignatureWithTypeEntity = class {
@@ -71850,6 +71886,9 @@ var OverloadResolverSignatureParameter = class {
   isOptional() {
     return this.value.entity.isOptional();
   }
+  isVariadic() {
+    return this.value.entity.isVariadic();
+  }
   getIndex() {
     return this.index;
   }
@@ -72061,6 +72100,9 @@ var MatcherParameter = class {
   isOptional() {
     return this.entity.isOptional();
   }
+  isVariadic() {
+    return this.entity.isVariadic();
+  }
 };
 
 // source/analysis/a/DeclarationsUsageCounter.ts
@@ -73148,6 +73190,9 @@ var OverloadResolverParameter = class {
   isOptional() {
     return this.parameter.getEntity().isOptional();
   }
+  isVariadic() {
+    return this.parameter.getEntity().isVariadic();
+  }
 };
 
 // source/analysis/a/MemberAccessExpressionMeaning.ts
@@ -74966,6 +75011,9 @@ var OverloadResolverParameterInfo = class {
   isOptional() {
     return false;
   }
+  isVariadic() {
+    return false;
+  }
 };
 
 // source/analysis/a/UserDefinableUnaryOperatorResolver.ts

package/build/{chunk-HHCWDLSE.js → chunk-RTJ7RFEG.js}

@@ -9,7 +9,7 @@ import {
   WellKnownDeclarationsLoadError,
   __async,
   createTsInteropInputsForCompilation
-} from "./chunk-VD3HHVCM.js";
+} from "./chunk-ONUJ6R7X.js";
 
 // source/executor/Compiler.ts
 var Compiler = class {

package/build/{chunk-54PBDJ2W.js → chunk-YMWJL3GM.js}

@@ -1,6 +1,6 @@
 import {
   Compiler
-} from "./chunk-HHCWDLSE.js";
+} from "./chunk-RTJ7RFEG.js";
 import {
   ArtelVersion,
   Cached,
@@ -16,7 +16,7 @@ import {
   __async,
   performanceMeasurementStageNames,
   performanceMeasurementStages
-} from "./chunk-VD3HHVCM.js";
+} from "./chunk-ONUJ6R7X.js";
 
 // source/executor/FileSystemUri.ts
 import { platform } from "os";

package/build/types/analysis/a/ArgumentsToParametersMatcher.d.ts

@@ -25,6 +25,7 @@ export interface ISignature<TParameter extends ISignatureParameter> {
 export interface ISignatureParameter {
     getName(): Name | undefined;
     isOptional(): boolean;
+    isVariadic(): boolean;
 }
 export interface IArgument {
     readonly name: Name | undefined;

package/build/types/analysis/a/OverloadResolver.d.ts

@@ -22,7 +22,11 @@ export declare class OverloadResolver<TSignature extends ISignature<TParameter>,
     resolveOverload(): ProcessedSignature<TSignature, TParameter, TArgument>[];
     private areArgumentTypesAssignableToParameterTypes;
     private tryChooseBestSignature;
+    private tryChooseBetterSignatureBasedOnParameterTypes;
     private chooseBetterTargetType;
+    private tryChooseBetterSignatureBasedOnVariadicParameters;
+    private tryChooseBetterSignatureBasedOnPresenceOfTypeParameters;
+    private tryChooseBetterSignatureBasedOnParameterCount;
     private functionLiteralCouldBeAssignableToType;
     private reportAmbiguousAccessDiagnostic;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@artel/artc",
-  "version": "0.6.26030",
+  "version": "0.6.26032",
   "description": "Артель Компилятор | Artel Compiler",
   "author": "Nezaboodka Team <contact@nezaboodka.com>",
   "license": "Apache-2.0",
@@ -44,7 +44,7 @@
     "@babel/types": "7.27.3",
     "@vscode/l10n": "0.0.18",
     "jsonc-parser": "3.3.1",
-    "reactronic": "^0.96.26025",
+    "reactronic": "^0.96.26026",
     "typescript": "5.9.3",
     "vscode-json-languageservice": "5.4.2",
     "vscode-languageserver": "9.0.1",