@artel/artc 0.6.25274 → 0.6.25276

package/build/api/ApiServices.js

@@ -2,6 +2,7 @@ import {
   AccessedFunction_entity,
   AccessedFunction_typeMember,
   AliasTypeDeclarationBody,
+  AnalyzedTranslationPackage,
   Analyzer,
   AnonymousFunctionTypeDeclaration,
   AnonymousStructuredTypeDeclaration,
@@ -165,9 +166,13 @@ import {
   getOrCreateKeywordDictionary,
   getParentSkippingParenthesizedExpressions,
   isComputedVariableEntity,
+  isEntityWithParameters,
+  isEntityWithTypeParameters,
   isIdentifier,
   isNarrowableReferenceExpression,
   isNonEmptyArray,
+  isPackageMemberEntity,
+  isPackageTypeEntity,
   isSourceOrConfigurationFileName,
   isTypeEntity,
   isTypeEntityWithMembers,
@@ -182,7 +187,7 @@ import {
   unwrapParenthesizedExpressions,
   visitChildren,
   yieldExecution
-} from "../chunk-6JA436J2.js";
+} from "../chunk-LX6LUKPR.js";
 
 // source/services/CustomCommand.ts
 import * as ls from "vscode-languageserver";
@@ -1092,10 +1097,9 @@ var SyntaxFactory = class {
   }
   static createTokenSeparatedElements(elements, tokenKind) {
     const result = new Array();
-    let token;
     for (let i = 0; i < elements.length; i++) {
       if (i > 0) {
-        token ??= this.token(tokenKind);
+        const token = this.token(tokenKind);
         result.push(token);
       }
       result.push(elements[i]);
@@ -1885,9 +1889,9 @@ var SyntaxToCode = class _SyntaxToCode {
     this.writeTranslationParameterClause(node.translatedParameterClause);
   }
   writeTranslationTypeParameterClause(node) {
-    if (node.parameterList.elements.length > 0) {
+    if (node.typeParameterList.elements.length > 0) {
       this.writeToken(node.lessThanToken);
-      this.writeCommaSeparatedList(node.parameterList.elements, (p) => this.writeToken(p));
+      this.writeCommaSeparatedList(node.typeParameterList.elements, (p) => this.writeToken(p));
       this.writeToken(node.greaterThanToken);
     }
   }
@@ -2430,7 +2434,7 @@ var TranslationsGenerationService = class {
       sourceFile.package.locale,
       sourceFile.package.dialect
     );
-    return Query.from(tokenOrKeyword.parent.translationList.translationDeclarations).filter((t) => t.kind === 139 /* TypeTranslationDeclaration */).mapAndFilter((t) => translationPackage.getTypeTranslationTarget(t).target).any((t) => generator.collectNotTranslatedTypeMembers(t).length > 0);
+    return Query.from(tokenOrKeyword.parent.translationList.translationDeclarations).filter((t) => t.kind === 139 /* TypeTranslationDeclaration */).mapAndFilter((t) => translationPackage.getPackageMemberTranslationTargets(t)?.values).flatMap((t) => t).any((t) => isPackageTypeEntity(t) && generator.collectNotTranslatedTypeMembers(t).length > 0);
   }
 };
 var TranslationsGenerator = class _TranslationsGenerator {
@@ -2500,10 +2504,11 @@ var TranslationsGenerator = class _TranslationsGenerator {
     return result.length > 0 ? result : void 0;
   }
   generateMissingTypeMemberTranslations(typeTranslation) {
-    const entity = this.translationPackage.getTypeTranslationTarget(typeTranslation).validTarget;
-    if (entity === void 0) {
+    const translationTargets = this.translationPackage.getPackageMemberTranslationTargets(typeTranslation)?.values;
+    if (translationTargets === void 0 || translationTargets.length !== 1 || !isPackageTypeEntity(translationTargets[0])) {
       return void 0;
     }
+    const entity = translationTargets[0];
     const memberEntities = this.collectNotTranslatedTypeMembers(entity);
     if (memberEntities.length === 0) {
       return void 0;
@@ -2542,37 +2547,8 @@ var TranslationsGenerator = class _TranslationsGenerator {
     return [new SourceFileEdit(this.sourceFile, editRange, editText)];
   }
   collectNotTranslatedTypeMembers(entity) {
-    const result = new Array();
-    const translatedTypeEntity = this.translationPackage.entityLocalizationContext.getLocalizedPackageTypeEntity(entity);
-    const members = translatedTypeEntity.getMembers();
-    for (const member of members.getNamedMembers()) {
-      if (member.isHidden() !== void 0) {
-        continue;
-      }
-      if (this.isNotTranslatedEntity(member)) {
-        result.push(member);
-      }
-    }
-    for (const constructor of members.getConstructors()) {
-      if (constructor.isHidden() !== void 0) {
-        continue;
-      }
-      if (constructor.isDefault() !== void 0) {
-        continue;
-      }
-      if (constructor.getParameters().length > 0 && this.isNotTranslatedEntity(constructor)) {
-        result.push(constructor);
-      }
-    }
-    for (const indexer of members.getIndexers()) {
-      if (indexer.isHidden() !== void 0) {
-        continue;
-      }
-      if (indexer.getParameters().length > 0 && this.isNotTranslatedEntity(indexer)) {
-        result.push(indexer);
-      }
-    }
-    return result;
+    const translatedTypeEntity = this.translationPackage.localizationContext.getLocalizedPackageTypeEntity(entity);
+    return translatedTypeEntity.getMembers().getAll().filter((m) => this.isNotTranslatedEntity(m) && AnalyzedTranslationPackage.isTypeMemberEntityThatShouldBeTranslatedByUser(m));
   }
   detectIndentationForPackageMemberTranslations(translationsDeclaration) {
     let indentationSize;
@@ -2626,7 +2602,7 @@ var TranslationsGenerator = class _TranslationsGenerator {
     return " ".repeat(indentationSize);
   }
   collectNotTranslatedPackageMembers() {
-    return this.translationPackage.getTranslatedTargetPackage().getMembers().getNamedMembers().filter((m) => m.isHidden() === void 0 && this.isNotTranslatedEntity(m));
+    return this.translationPackage.translatedTargetPackage.getMembers().getNamedMembers().filter((m) => this.isNotTranslatedEntity(m) && AnalyzedTranslationPackage.isPackageMemberEntityThatShouldBeTranslatedByUser(m));
   }
   isNotTranslatedEntity(entity) {
     const translation = entity.getTranslation();
@@ -2682,9 +2658,10 @@ var TranslationsGenerator = class _TranslationsGenerator {
         return this.createConstructorTranslation(entity);
       case 5 /* Indexer */:
         return this.createIndexerTranslation(entity);
+      case 9 /* Operator */:
+        return this.createOperatorTranslation(entity);
       case 6 /* DereferenceOperator */:
       case 8 /* Destructor */:
-      case 9 /* Operator */:
         return void 0;
       default:
         Debug.never(entity);
@@ -2708,6 +2685,11 @@ var TranslationsGenerator = class _TranslationsGenerator {
     const parameters = entity.getParameters().map((p) => this.getNameText(p.getName()));
     return SyntaxFactory.indexerTranslation(parameters, parameters);
   }
+  createOperatorTranslation(entity) {
+    const name = `'${LocalizationHelper.localizeOperatorKind(entity.getOperatorKind(), this.locale, this.dialect)}'`;
+    const parameters = entity.getParameters().map((p) => this.getNameText(p.getName()));
+    return SyntaxFactory.methodTranslation(name, [], parameters, name, [], parameters);
+  }
   getNameText(name) {
     const flags = name.flags & ~8 /* ConflictResolvingParameterName */;
     return name.getPreferredUnescapedOriginal(flags);
@@ -2767,7 +2749,7 @@ var CodeActionsService = class {
     }
     const result = new Array();
     const diagnosticCodeSet = new Set(diagnosticCodes);
-    if (diagnosticCodeSet.has(282 /* TheFollowingDeclarationsAreNotTranslated0 */) || diagnosticCodeSet.has(283 /* TheFollowingDeclarationsAreNotTranslated0And1More */)) {
+    if (diagnosticCodeSet.has(288 /* TheFollowingDeclarationsAreNotTranslated0 */) || diagnosticCodeSet.has(289 /* TheFollowingDeclarationsAreNotTranslated0And1More */)) {
       const data = { onlyTypeMembers: false };
       result.push(CodeAction.unresolved(
         "\u0421\u0433\u0435\u043D\u0435\u0440\u0438\u0440\u043E\u0432\u0430\u0442\u044C \u043D\u0435\u0434\u043E\u0441\u0442\u0430\u044E\u0449\u0438\u0435 \u043F\u0435\u0440\u0435\u0432\u043E\u0434\u044B.",
@@ -3515,7 +3497,10 @@ var CompletionService = class {
       let type;
       if (this.sourceFile.package.kind === "translation") {
         const translationPackage2 = this.analyzer.getAnalyzedTranslationPackageIfTargetResolved(this.sourceFile.package);
-        type = translationPackage2?.getTypeTranslationTarget(typeTranslation).target;
+        const translationTargets = translationPackage2?.getPackageMemberTranslationTargets(typeTranslation)?.values;
+        if (translationTargets !== void 0 && translationTargets.length === 1 && isPackageTypeEntity(translationTargets[0])) {
+          type = translationTargets[0];
+        }
       }
       const hidingMatcher = semanticContext.getHidingMatcher();
       return new TypeMemberTranslationListCompletionContext(
@@ -5699,6 +5684,14 @@ var NodeSemanticInfoService = class {
       return this.ofIndexedElementAccessorDeclaration(analyzer, tokenOrKeyword.parent.parent);
     } else if ((tokenOrKeyword.isToken(46 /* OpenSquareBracket */) || tokenOrKeyword.isToken(23 /* CloseSquareBracket */)) && tokenOrKeyword.parent.kind === 70 /* IndexedAccessExpression */) {
       return this.ofIndexedAccessExpressionOperator(analyzer, tokenOrKeyword.parent, options6);
+    } else if (tokenOrKeyword.isKeyword(31 /* Creation */) && tokenOrKeyword.parent.kind === 127 /* ConstructorTranslation */) {
+      return this.ofConstructorTranslationSourceConstructor(analyzer, tokenOrKeyword.parent, options6);
+    } else if ((tokenOrKeyword.isToken(45 /* OpenParenthesis */) || tokenOrKeyword.isToken(22 /* CloseParenthesis */)) && tokenOrKeyword.parent.kind === 126 /* TranslationParameterClause */ && tokenOrKeyword.parent.parent.kind === 127 /* ConstructorTranslation */ && tokenOrKeyword.parent.parent.translatedParameterClause === tokenOrKeyword.parent) {
+      return this.ofConstructorTranslationTranslatedConstructor(analyzer, tokenOrKeyword.parent.parent, options6);
+    } else if ((tokenOrKeyword.isToken(46 /* OpenSquareBracket */) || tokenOrKeyword.isToken(23 /* CloseSquareBracket */)) && tokenOrKeyword.parent.kind === 128 /* IndexParameterTranslationClause */ && tokenOrKeyword.parent.parent.kind === 129 /* IndexerTranslation */ && tokenOrKeyword.parent.parent.sourceParameterClause === tokenOrKeyword.parent) {
+      return this.ofIndexerTranslationSourceIndexer(analyzer, tokenOrKeyword.parent.parent, options6);
+    } else if ((tokenOrKeyword.isToken(46 /* OpenSquareBracket */) || tokenOrKeyword.isToken(23 /* CloseSquareBracket */)) && tokenOrKeyword.parent.kind === 128 /* IndexParameterTranslationClause */ && tokenOrKeyword.parent.parent.kind === 129 /* IndexerTranslation */ && tokenOrKeyword.parent.parent.translatedParameterClause === tokenOrKeyword.parent) {
+      return this.ofIndexerTranslationTranslatedIndexer(analyzer, tokenOrKeyword.parent.parent, options6);
     }
     return void 0;
   }
@@ -5715,9 +5708,9 @@ var NodeSemanticInfoService = class {
     const parent = node.parent;
     switch (parent.kind) {
       case 130 /* TranslationTypeParameterList */:
-        break;
+        return this.ofTranslationTypeParameterListParameter(analyzer, node, parent, options6);
       case 125 /* TranslationParameterList */:
-        break;
+        return this.ofTranslationParameterListParameter(analyzer, node, parent, options6);
       case 150 /* Argument */: {
         const respectiveParameter = analyzer.getRespectiveParameter(parent);
         if (respectiveParameter !== void 0) {
@@ -5765,65 +5758,25 @@ var NodeSemanticInfoService = class {
       case 135 /* QualifiedName */:
         result = this.ofQualifiedNameQualifier(analyzer, parent, node, options6);
         break;
-      case 136 /* PackageVariableTranslationDeclaration */: {
-        const translationPackage = this.getContainingTranslationPackage(analyzer, node);
-        const getTargetResult = translationPackage?.getPackageVariableTranslationTarget(parent);
-        if (translationPackage !== void 0 && getTargetResult?.target !== void 0) {
-          if (node === parent.sourceName) {
-            const target = new EntityReferenceTarget(getTargetResult.target, 0 /* Get */);
-            result = new ReferenceNodeSemanticInfo([target], false);
-            if (options6.includeBetterReferenceTargets) {
-              result = this.getBetterReferenceTargetsOrPreserve(result);
-            }
-          } else if (node === parent.translatedName) {
-            const target = new EntityReferenceTarget(translationPackage.entityLocalizationContext.getLocalizedPackageVariableEntity(getTargetResult.target), 0 /* Get */);
-            result = new ReferenceNodeSemanticInfo([target], false);
-            if (options6.includeBetterReferenceTargets) {
-              result = this.getBetterReferenceTargetsOrPreserve(result);
-            }
-          }
-        }
-        break;
-      }
-      case 137 /* FieldOrVariantTranslation */: {
-        const translationPackage = this.getContainingTranslationPackage(analyzer, node);
-        const getTargetsResult = translationPackage?.getFieldOrVariantTranslationTargets(parent);
-        if (translationPackage !== void 0 && isNonEmptyArray(getTargetsResult?.targets)) {
-          if (node === parent.sourceName) {
-            const targets = getTargetsResult.targets.map((t) => new EntityReferenceTarget(t, 0 /* Get */));
-            result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), getTargetsResult.isAmbiguous);
-            if (options6.includeBetterReferenceTargets) {
-              result = this.getBetterReferenceTargetsOrPreserve(result);
-            }
-          } else if (node === parent.translatedName) {
-            const targets = getTargetsResult.targets.map((f) => new EntityReferenceTarget(
-              translationPackage.entityLocalizationContext.getLocalizedFieldEntity(f),
-              0 /* Get */
-            ));
-            result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), getTargetsResult.isAmbiguous);
-            if (options6.includeBetterReferenceTargets) {
-              result = this.getBetterReferenceTargetsOrPreserve(result);
-            }
-          }
-        }
-        break;
-      }
-      case 132 /* PackageFunctionTranslationDeclaration */: {
+      case 136 /* PackageVariableTranslationDeclaration */:
+      case 132 /* PackageFunctionTranslationDeclaration */:
+      case 139 /* TypeTranslationDeclaration */:
+      case 134 /* FunctionTypeTranslationDeclaration */: {
         const translationPackage = this.getContainingTranslationPackage(analyzer, node);
-        const getTargetsResult = translationPackage?.getPackageFunctionTranslationTargets(parent);
-        if (translationPackage !== void 0 && isNonEmptyArray(getTargetsResult?.targets)) {
+        const translationTargets = translationPackage?.getPackageMemberTranslationTargets(parent);
+        if (translationPackage !== void 0 && translationTargets !== void 0 && translationTargets.values.length > 0) {
           if (node === parent.sourceName) {
-            const targets = getTargetsResult.targets.map((t) => new EntityReferenceTarget(t, 0 /* Get */));
-            result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), getTargetsResult.isAmbiguous);
+            const targets = translationTargets.values.map((t) => new EntityReferenceTarget(t, 0 /* Get */));
+            result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), !translationTargets.areSuitable);
             if (options6.includeBetterReferenceTargets) {
               result = this.getBetterReferenceTargetsOrPreserve(result);
             }
           } else if (node === parent.translatedName) {
-            const targets = getTargetsResult.targets.map((f) => new EntityReferenceTarget(
-              translationPackage.entityLocalizationContext.getLocalizedPackageFunctionEntity(f),
+            const targets = translationTargets.values.map((f) => new EntityReferenceTarget(
+              translationPackage.localizationContext.getLocalizedPackageMemberEntity(f),
               0 /* Get */
             ));
-            result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), getTargetsResult.isAmbiguous);
+            result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), !translationTargets.areSuitable);
             if (options6.includeBetterReferenceTargets) {
               result = this.getBetterReferenceTargetsOrPreserve(result);
             }
@@ -5831,62 +5784,23 @@ var NodeSemanticInfoService = class {
         }
         break;
       }
+      case 137 /* FieldOrVariantTranslation */:
       case 133 /* MethodTranslation */: {
         const translationPackage = this.getContainingTranslationPackage(analyzer, node);
-        const getTargetsResult = translationPackage?.getMethodTranslationTargets(parent);
-        if (translationPackage !== void 0 && isNonEmptyArray(getTargetsResult?.targets)) {
+        const translationTargets = translationPackage?.getTypeMemberTranslationTargets(parent);
+        if (translationPackage !== void 0 && translationTargets !== void 0 && translationTargets.values.length > 0) {
           if (node === parent.sourceName) {
-            const targets = getTargetsResult.targets.map((t) => new EntityReferenceTarget(t, 0 /* Get */));
-            result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), getTargetsResult.isAmbiguous);
+            const targets = translationTargets.values.map((t) => new EntityReferenceTarget(t, 0 /* Get */));
+            result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), !translationTargets.areSuitable);
             if (options6.includeBetterReferenceTargets) {
               result = this.getBetterReferenceTargetsOrPreserve(result);
             }
           } else if (node === parent.translatedName) {
-            const targets = getTargetsResult.targets.map((f) => new EntityReferenceTarget(
-              translationPackage.entityLocalizationContext.getLocalizedMethodEntity(f),
+            const targets = translationTargets.values.map((f) => new EntityReferenceTarget(
+              translationPackage.localizationContext.getLocalizedTypeMemberEntity(f),
               0 /* Get */
             ));
-            result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), getTargetsResult.isAmbiguous);
-            if (options6.includeBetterReferenceTargets) {
-              result = this.getBetterReferenceTargetsOrPreserve(result);
-            }
-          }
-        }
-        break;
-      }
-      case 139 /* TypeTranslationDeclaration */: {
-        const translationPackage = this.getContainingTranslationPackage(analyzer, node);
-        const getTargetResult = translationPackage?.getTypeTranslationTarget(parent);
-        if (translationPackage !== void 0 && getTargetResult?.target !== void 0) {
-          if (node === parent.sourceName) {
-            const target = new EntityReferenceTarget(getTargetResult.target, 0 /* Get */);
-            result = new ReferenceNodeSemanticInfo([target], false);
-            if (options6.includeBetterReferenceTargets) {
-              result = this.getBetterReferenceTargetsOrPreserve(result);
-            }
-          } else if (node === parent.translatedName) {
-            const target = new EntityReferenceTarget(translationPackage.entityLocalizationContext.getLocalizedTypeEntity(getTargetResult.target), 0 /* Get */);
-            result = new ReferenceNodeSemanticInfo([target], false);
-            if (options6.includeBetterReferenceTargets) {
-              result = this.getBetterReferenceTargetsOrPreserve(result);
-            }
-          }
-        }
-        break;
-      }
-      case 134 /* FunctionTypeTranslationDeclaration */: {
-        const translationPackage = this.getContainingTranslationPackage(analyzer, node);
-        const getTargetResult = translationPackage?.getFunctionTypeTranslationTarget(parent);
-        if (translationPackage !== void 0 && getTargetResult?.target !== void 0) {
-          if (node === parent.sourceName) {
-            const target = new EntityReferenceTarget(getTargetResult.target, 0 /* Get */);
-            result = new ReferenceNodeSemanticInfo([target], false);
-            if (options6.includeBetterReferenceTargets) {
-              result = this.getBetterReferenceTargetsOrPreserve(result);
-            }
-          } else if (node === parent.translatedName) {
-            const target = new EntityReferenceTarget(translationPackage.entityLocalizationContext.getLocalizedPackageFunctionTypeEntity(getTargetResult.target), 0 /* Get */);
-            result = new ReferenceNodeSemanticInfo([target], false);
+            result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), !translationTargets.areSuitable);
             if (options6.includeBetterReferenceTargets) {
               result = this.getBetterReferenceTargetsOrPreserve(result);
             }
@@ -6519,6 +6433,64 @@ var NodeSemanticInfoService = class {
     }
     return result;
   }
+  static ofConstructorTranslationSourceConstructor(analyzer, node, options6) {
+    let result;
+    const translationPackage = this.getContainingTranslationPackage(analyzer, node);
+    const translationTargets = translationPackage?.getTypeMemberTranslationTargets(node);
+    if (translationTargets !== void 0) {
+      const targets = translationTargets.values.map((t) => new EntityReferenceTarget(t, 0 /* Get */));
+      result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), !translationTargets.areSuitable);
+      if (options6.includeBetterReferenceTargets) {
+        result = this.getBetterReferenceTargetsOrPreserve(result);
+      }
+    }
+    return result;
+  }
+  static ofConstructorTranslationTranslatedConstructor(analyzer, node, options6) {
+    let result;
+    const translationPackage = this.getContainingTranslationPackage(analyzer, node);
+    const translationTargets = translationPackage?.getTypeMemberTranslationTargets(node);
+    if (translationPackage !== void 0 && translationTargets !== void 0) {
+      const targets = translationTargets.values.map((t) => new EntityReferenceTarget(
+        translationPackage.localizationContext.getLocalizedTypeMemberEntity(t),
+        0 /* Get */
+      ));
+      result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), !translationTargets.areSuitable);
+      if (options6.includeBetterReferenceTargets) {
+        result = this.getBetterReferenceTargetsOrPreserve(result);
+      }
+    }
+    return result;
+  }
+  static ofIndexerTranslationSourceIndexer(analyzer, node, options6) {
+    let result;
+    const translationPackage = this.getContainingTranslationPackage(analyzer, node);
+    const translationTargets = translationPackage?.getTypeMemberTranslationTargets(node);
+    if (translationTargets !== void 0) {
+      const targets = translationTargets.values.map((t) => new EntityReferenceTarget(t, 0 /* Get */));
+      result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), !translationTargets.areSuitable);
+      if (options6.includeBetterReferenceTargets) {
+        result = this.getBetterReferenceTargetsOrPreserve(result);
+      }
+    }
+    return result;
+  }
+  static ofIndexerTranslationTranslatedIndexer(analyzer, node, options6) {
+    let result;
+    const translationPackage = this.getContainingTranslationPackage(analyzer, node);
+    const translationTargets = translationPackage?.getTypeMemberTranslationTargets(node);
+    if (translationPackage !== void 0 && translationTargets !== void 0) {
+      const targets = translationTargets.values.map((t) => new EntityReferenceTarget(
+        translationPackage.localizationContext.getLocalizedTypeMemberEntity(t),
+        0 /* Get */
+      ));
+      result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), !translationTargets.areSuitable);
+      if (options6.includeBetterReferenceTargets) {
+        result = this.getBetterReferenceTargetsOrPreserve(result);
+      }
+    }
+    return result;
+  }
   static ofPackageNameSegmentAccess(analyzer, packageTreeNode, node) {
     let parent = getParentSkippingParenthesizedExpressions(node);
     while (parent.kind === 76 /* MemberAccessExpression */) {
@@ -6554,6 +6526,97 @@ var NodeSemanticInfoService = class {
     const targets = suitableType !== void 0 ? [new EntityReferenceTarget(suitableType, 0 /* Get */)] : typeCandidates.map((t) => new EntityReferenceTarget(t, 0 /* Get */));
     return new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), targets.length > 1);
   }
+  static ofTranslationTypeParameterListParameter(analyzer, node, typeParameterList, options6) {
+    const parameterIndex = typeParameterList.typeParameters.indexOf(node);
+    if (parameterIndex < 0) {
+      return void 0;
+    }
+    const translationPackage = this.getContainingTranslationPackage(analyzer, node);
+    if (translationPackage === void 0) {
+      return void 0;
+    }
+    const translationDeclaration = typeParameterList.parent.parent;
+    let translationTargets;
+    switch (translationDeclaration.kind) {
+      case 132 /* PackageFunctionTranslationDeclaration */:
+      case 134 /* FunctionTypeTranslationDeclaration */:
+      case 139 /* TypeTranslationDeclaration */:
+        translationTargets = translationPackage.getPackageMemberTranslationTargets(translationDeclaration);
+        break;
+      case 133 /* MethodTranslation */:
+        translationTargets = translationPackage.getTypeMemberTranslationTargets(translationDeclaration);
+        break;
+      default:
+        Debug.never(translationDeclaration);
+    }
+    let result;
+    if (translationTargets !== void 0) {
+      let typeParameterArrays;
+      if (typeParameterList === translationDeclaration.sourceTypeParameterClause?.typeParameterList) {
+        typeParameterArrays = Query.from(translationTargets.values).mapAndFilter((e) => isEntityWithTypeParameters(e) ? e.getTypeParameters() : void 0).toArray();
+      } else {
+        typeParameterArrays = Query.from(translationTargets.values).mapAndFilter((e) => {
+          const localizedEntity = isPackageMemberEntity(e) ? translationPackage.localizationContext.getLocalizedPackageMemberEntity(e) : translationPackage.localizationContext.getLocalizedTypeMemberEntity(e);
+          return isEntityWithTypeParameters(localizedEntity) ? localizedEntity.getTypeParameters() : void 0;
+        }).toArray();
+      }
+      const typeParameters = Query.from(typeParameterArrays).mapAndFilter((a) => a[parameterIndex]).toArray();
+      if (isNonEmptyArray(typeParameters)) {
+        const targets = typeParameters.map((t) => new EntityReferenceTarget(t, 0 /* Get */));
+        result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), !translationTargets.areSuitable);
+        if (options6.includeBetterReferenceTargets) {
+          result = this.getBetterReferenceTargetsOrPreserve(result);
+        }
+      }
+    }
+    return result;
+  }
+  static ofTranslationParameterListParameter(analyzer, node, parameterList, options6) {
+    const parameterIndex = parameterList.parameters.indexOf(node);
+    if (parameterIndex < 0) {
+      return void 0;
+    }
+    const translationPackage = this.getContainingTranslationPackage(analyzer, node);
+    if (translationPackage === void 0) {
+      return void 0;
+    }
+    const translationDeclaration = parameterList.parent.parent;
+    let translationTargets;
+    switch (translationDeclaration.kind) {
+      case 132 /* PackageFunctionTranslationDeclaration */:
+      case 134 /* FunctionTypeTranslationDeclaration */:
+        translationTargets = translationPackage.getPackageMemberTranslationTargets(translationDeclaration);
+        break;
+      case 133 /* MethodTranslation */:
+      case 127 /* ConstructorTranslation */:
+      case 129 /* IndexerTranslation */:
+        translationTargets = translationPackage.getTypeMemberTranslationTargets(translationDeclaration);
+        break;
+      default:
+        Debug.never(translationDeclaration);
+    }
+    let result;
+    if (translationTargets !== void 0) {
+      let parameterArrays;
+      if (parameterList === translationDeclaration.sourceParameterClause?.parameterList) {
+        parameterArrays = Query.from(translationTargets.values).mapAndFilter((e) => isEntityWithParameters(e) ? e.getParameters() : void 0).toArray();
+      } else {
+        parameterArrays = Query.from(translationTargets.values).mapAndFilter((e) => {
+          const localizedEntity = isPackageMemberEntity(e) ? translationPackage.localizationContext.getLocalizedPackageMemberEntity(e) : translationPackage.localizationContext.getLocalizedTypeMemberEntity(e);
+          return isEntityWithParameters(localizedEntity) ? localizedEntity.getParameters() : void 0;
+        }).toArray();
+      }
+      const typeParameters = Query.from(parameterArrays).mapAndFilter((a) => a[parameterIndex]).toArray();
+      if (isNonEmptyArray(typeParameters)) {
+        const targets = typeParameters.map((t) => new EntityReferenceTarget(t, 0 /* Get */));
+        result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), !translationTargets.areSuitable);
+        if (options6.includeBetterReferenceTargets) {
+          result = this.getBetterReferenceTargetsOrPreserve(result);
+        }
+      }
+    }
+    return result;
+  }
   static getBetterReferenceTargetsOrPreserve(info) {
     const currentTargets = info.betterTargets ?? info.targets;
     const betterTargets = Query.from(currentTargets).mapAndFilter((t) => this.getBetterReferenceTarget(t)).toArray();
@@ -7327,6 +7390,82 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, range, referenceKind));
                 }
               }
+              if (node.kind === 127 /* ConstructorTranslation */ && restrictions.canBeConstructorDeclaration) {
+                {
+                  const semanticInfo = NodeSemanticInfoService.ofConstructorTranslationSourceConstructor(
+                    analyzer,
+                    node,
+                    semanticInfoOptions
+                  );
+                  const referenceKind = this.ifReferenceToSomeOfDefinitionsThenKind(
+                    definitions,
+                    semanticInfo,
+                    allowAmbiguous,
+                    isForRename
+                  );
+                  if (referenceKind !== void 0) {
+                    result.push(new Reference(sourceFile2, node.creationKeyword.rangeWithoutTrivia, referenceKind));
+                  }
+                }
+                {
+                  const semanticInfo = NodeSemanticInfoService.ofConstructorTranslationTranslatedConstructor(
+                    analyzer,
+                    node,
+                    semanticInfoOptions
+                  );
+                  const referenceKind = this.ifReferenceToSomeOfDefinitionsThenKind(
+                    definitions,
+                    semanticInfo,
+                    allowAmbiguous,
+                    isForRename
+                  );
+                  if (referenceKind !== void 0) {
+                    result.push(new Reference(
+                      sourceFile2,
+                      node.translatedParameterClause.rangeWithoutTrivia,
+                      referenceKind
+                    ));
+                  }
+                }
+              }
+              if (node.kind === 129 /* IndexerTranslation */ && restrictions.canBeIndexer) {
+                {
+                  const semanticInfo = NodeSemanticInfoService.ofIndexerTranslationSourceIndexer(
+                    analyzer,
+                    node,
+                    semanticInfoOptions
+                  );
+                  const referenceKind = this.ifReferenceToSomeOfDefinitionsThenKind(
+                    definitions,
+                    semanticInfo,
+                    allowAmbiguous,
+                    isForRename
+                  );
+                  if (referenceKind !== void 0) {
+                    result.push(new Reference(sourceFile2, node.sourceParameterClause.rangeWithoutTrivia, referenceKind));
+                  }
+                }
+                {
+                  const semanticInfo = NodeSemanticInfoService.ofIndexerTranslationTranslatedIndexer(
+                    analyzer,
+                    node,
+                    semanticInfoOptions
+                  );
+                  const referenceKind = this.ifReferenceToSomeOfDefinitionsThenKind(
+                    definitions,
+                    semanticInfo,
+                    allowAmbiguous,
+                    isForRename
+                  );
+                  if (referenceKind !== void 0) {
+                    result.push(new Reference(
+                      sourceFile2,
+                      node.translatedParameterClause.rangeWithoutTrivia,
+                      referenceKind
+                    ));
+                  }
+                }
+              }
             }
           }
         );