@artel/artc 0.6.25243 → 0.6.25245

package/build/api/ApiServices.js

@@ -27,7 +27,6 @@ import {
   DiagnosticCollector,
   DisplayService,
   Emitter,
-  EntityLocalizationHelper,
   FieldDeclaration,
   FieldGetterDeclaration,
   FieldOrVariantTranslation,
@@ -57,8 +56,6 @@ import {
   KeywordExpression,
   LocaleByConfigurationDirectoryName,
   LocaleByJsonConfigurationFileName,
-  Localization,
-  LocalizationContext,
   LocalizationHelper,
   Logger,
   MethodDeclaration,
@@ -115,7 +112,6 @@ import {
   Token,
   TokenExpression,
   TopLevelTranslationList,
-  Translation,
   TranslationParameterClause,
   TranslationParameterList,
   TranslationTypeParameterClause,
@@ -182,7 +178,7 @@ import {
   unwrapParenthesizedExpressions,
   visitChildren,
   yieldExecution
-} from "../chunk-7D775S4V.js";
+} from "../chunk-T7WG4Z7I.js";
 
 // source/services/CustomCommand.ts
 import * as ls from "vscode-languageserver";
@@ -2156,7 +2152,7 @@ var SyntaxToCode = class _SyntaxToCode {
       [142 /* TranslationTextTemplate */]: this.prototype.writeNodeDefault,
       [143 /* TranslationTextTemplateSpanList */]: this.prototype.writeNodeDefault,
       [144 /* TranslationTextTemplateSpan */]: this.prototype.writeNodeDefault,
-      [145 /* TranslationTextTemplateParameter */]: this.prototype.writeNodeDefault
+      [145 /* TranslationTextTemplateParameterDeclaration */]: this.prototype.writeNodeDefault
     };
     return writeFunctions;
   }
@@ -2405,7 +2401,7 @@ var TranslationsGenerator = class _TranslationsGenerator {
     if (memberEntities.length > 0) {
       const newLine = this.detectNewLine();
       const syntaxToCodeOptions = {
-        keywordsLocale: this._translationPackage.getTranslatedPackage().getLocale(),
+        keywordsLocale: this._translationPackage.getTargetPackage().getLocale(),
         keywordsDialect: this._dialect,
         initialIndentation: this.detectIndentationForPackageMemberTranslations(translationsDeclaration),
         indentationStep: this.detectIndentationStepForTypeMemberTranslations(translationsDeclaration),
@@ -2465,7 +2461,7 @@ var TranslationsGenerator = class _TranslationsGenerator {
     }
     const newLine = this.detectNewLine();
     const syntaxToCodeOptions = {
-      keywordsLocale: this._translationPackage.getTranslatedPackage().getLocale(),
+      keywordsLocale: this._translationPackage.getTargetPackage().getLocale(),
       keywordsDialect: this._dialect,
       initialIndentation: this.detectIndentationForTypeMemberTranslations(typeTranslation),
       indentationStep: this.detectIndentationStepForTypeMemberTranslations(typeTranslation),
@@ -2498,33 +2494,32 @@ var TranslationsGenerator = class _TranslationsGenerator {
   }
   collectNotTranslatedTypeMembers(entity) {
     const result = new Array();
-    const translatedTypeMembers = this._translationPackage.getTypeEntityMembers(entity);
-    const namedMembersOfTranslatedType = new Set(translatedTypeMembers?.getNamedMembers().map((m) => m.value));
-    const membersOfTargetType = entity.getMembers();
-    for (const member of membersOfTargetType.getNamedMembers()) {
+    const translatedTypeEntity = this._translationPackage.entityLocalizationContext.getLocalizedPackageTypeEntity(entity);
+    const members = translatedTypeEntity.getMembers();
+    for (const member of members.getNamedMembers()) {
       if (member.isHidden() !== void 0) {
         continue;
       }
-      if (!namedMembersOfTranslatedType.has(member)) {
+      if (this.isNotTranslatedEntity(member)) {
         result.push(member);
       }
     }
-    for (const constructor of membersOfTargetType.getConstructors()) {
+    for (const constructor of members.getConstructors()) {
       if (constructor.isHidden() !== void 0) {
         continue;
       }
       if (constructor.isDefault() !== void 0) {
         continue;
       }
-      if (constructor.getValueParameters().length > 0 && this._translationPackage.getConstructorSignature(constructor) === void 0) {
+      if (constructor.getValueParameters().length > 0 && this.isNotTranslatedEntity(constructor)) {
         result.push(constructor);
       }
     }
-    for (const indexer of membersOfTargetType.getIndexers()) {
+    for (const indexer of members.getIndexers()) {
       if (indexer.isHidden() !== void 0) {
         continue;
       }
-      if (indexer.getValueParameters().length > 0 && this._translationPackage.getIndexerSignature(indexer) === void 0) {
+      if (indexer.getValueParameters().length > 0 && this.isNotTranslatedEntity(indexer)) {
         result.push(indexer);
       }
     }
@@ -2582,18 +2577,11 @@ var TranslationsGenerator = class _TranslationsGenerator {
     return " ".repeat(indentationSize);
   }
   collectNotTranslatedPackageMembers() {
-    const result = new Array();
-    const translatedPackageMembers = new Set(this._translationPackage.getMembers().getNamedMembers().map((m) => m.value));
-    const membersOfTargetPackage = this._translationPackage.getTranslatedPackage().getMembers();
-    for (const member of membersOfTargetPackage.getNamedMembers()) {
-      if (member.isHidden() !== void 0) {
-        continue;
-      }
-      if (!translatedPackageMembers.has(member)) {
-        result.push(member);
-      }
-    }
-    return result;
+    return this._translationPackage.getPackageInTranslatedLanguage().getMembers().getNamedMembers().filter((m) => m.isHidden() === void 0 && this.isNotTranslatedEntity(m));
+  }
+  isNotTranslatedEntity(entity) {
+    const localization = entity.getLocalization();
+    return localization.kind === "original" || localization.translation.definition.kind === "intrinsic" && localization.translation.definition.isMissingTranslationReplacement;
   }
   createPackageMemberTranslationNode(entity) {
     switch (entity.kind) {
@@ -2672,7 +2660,7 @@ var TranslationsGenerator = class _TranslationsGenerator {
     return SyntaxFactory.indexerTranslation(parameters, parameters);
   }
   getNameText(name) {
-    const flags = name.flags & ~16 /* ConflictResolvingParameterName */;
+    const flags = name.flags & ~8 /* ConflictResolvingParameterName */;
     return name.getPreferredUnescapedOriginal(flags);
   }
   // TODO: Работать с синтаксическим деревом и использовать Trivia для добавления перевода строки. Требуется доработка
@@ -3028,16 +3016,7 @@ var AccessedFunctionSignature = class {
     this.func = func;
   }
   getValueParameters() {
-    return this._valueParameters.getOrInsertWith(() => {
-      const localizedSignature = EntityLocalizationHelper.getLocalizedFunctionSignature(
-        this.func.value.getEntity(),
-        this.func.localization
-      );
-      return Query.from(this.func.value.getValueParameters()).zip(
-        localizedSignature.getValueParameterNames(),
-        (p, n) => new UniversalValueParameter(n.value, p.type, p.entity, n.localization)
-      ).toArray();
-    });
+    return this._valueParameters.getOrInsertWith(() => this.func.getValueParameters().map((p) => new UniversalValueParameter(p.type, p.entity)));
   }
 };
 var FunctionTypeSignature = class {
@@ -3047,16 +3026,7 @@ var FunctionTypeSignature = class {
     this.functionType = functionType;
   }
   getValueParameters() {
-    return this._valueParameters.getOrInsertWith(
-      () => this.functionType.getValueParameters().map(
-        (p) => new UniversalValueParameter(
-          p.getName(),
-          p.getType(),
-          p.getEntity(),
-          Localization.Original.ofEntity(p.getEntity())
-        )
-      )
-    );
+    return this._valueParameters.getOrInsertWith(() => this.functionType.getValueParameters().map((p) => new UniversalValueParameter(p.getType(), p.getEntity())));
   }
 };
 var ConstructorSignature = class {
@@ -3066,16 +3036,7 @@ var ConstructorSignature = class {
     this.constructor_ = constructor_;
   }
   getValueParameters() {
-    return this._valueParameters.getOrInsertWith(() => {
-      const localizedSignature = EntityLocalizationHelper.getLocalizedConstructorSignature(
-        this.constructor_.value.getEntity(),
-        this.constructor_.localization
-      );
-      return Query.from(this.constructor_.value.getValueParameters()).zip(
-        localizedSignature.getValueParameterNames(),
-        (p, n) => new UniversalValueParameter(n.value, p.getType(), p.getEntity(), n.localization)
-      ).toArray();
-    });
+    return this._valueParameters.getOrInsertWith(() => this.constructor_.getValueParameters().map((p) => new UniversalValueParameter(p.getType(), p.getEntity())));
   }
 };
 var IndexerSignature = class {
@@ -3085,27 +3046,16 @@ var IndexerSignature = class {
     this.indexer = indexer;
   }
   getValueParameters() {
-    return this._valueParameters.getOrInsertWith(() => {
-      const localizedSignature = EntityLocalizationHelper.getLocalizedIndexerSignature(
-        this.indexer.value.getEntity(),
-        this.indexer.localization
-      );
-      return Query.from(this.indexer.value.getValueParameters()).zip(
-        localizedSignature.getValueParameterNames(),
-        (p, n) => new UniversalValueParameter(n.value, p.getType(), p.getEntity(), n.localization)
-      ).toArray();
-    });
+    return this._valueParameters.getOrInsertWith(() => this.indexer.getValueParameters().map((p) => new UniversalValueParameter(p.getType(), p.getEntity())));
   }
 };
 var UniversalValueParameter = class {
-  constructor(name, type, entity, localization) {
-    this.name = name;
+  constructor(type, entity) {
     this.type = type;
     this.entity = entity;
-    this.localization = localization;
   }
   getName() {
-    return this.name;
+    return this.entity.getName();
   }
   getType() {
     return this.type;
@@ -3121,11 +3071,7 @@ var CompletionService = class {
   get completionItemInfoContext() {
     return this._completionItemInfoContext.getOrInsertWith(
       () => new CompletionItemInfoContext(
-        new DisplayService(
-          this._analyzer,
-          this._analyzer.createLocalizationContext(this._sourceFile),
-          this._dialect
-        ),
+        new DisplayService(this._analyzer, this._locale, this._dialect),
         this._locale,
         Query.from(getOrCreateKeywordDictionary(this._locale, this._dialect).values()).mapAndFilter((k) => k.keywordKind !== 0 /* Unknown */ ? k.value : void 0).uniqueToSet()
       )
@@ -3236,10 +3182,7 @@ var CompletionService = class {
         if (info !== void 0) {
           let lookup;
           if (info.packageTreeNode.package !== void 0) {
-            lookup = new PackageMemberLookup(
-              info.packageTreeNode.package.value,
-              semanticContext.getLocalizationContext()
-            );
+            lookup = new PackageMemberLookup(info.packageTreeNode.package);
           }
           const hidingMatcher2 = semanticContext.getHidingMatcher();
           return new PackageNameSegmentCompletionContext(info.packageTreeNode, lookup, hidingMatcher2);
@@ -3250,7 +3193,7 @@ var CompletionService = class {
         if (info !== void 0) {
           const package_ = info.packageAlias.getPackage();
           if (package_ !== void 0) {
-            const lookup = new PackageMemberLookup(package_, semanticContext.getLocalizationContext());
+            const lookup = new PackageMemberLookup(package_);
             const hidingMatcher2 = semanticContext.getHidingMatcher();
             return new PackageAliasMemberCompletionContext(lookup, hidingMatcher2);
           }
@@ -3258,16 +3201,9 @@ var CompletionService = class {
         }
       }
       const type = this._analyzer.type.ofExpression(memberAccess.expression);
-      const localizationContext = semanticContext.getLocalizationContext();
       const isStaticAccess = this._analyzer.checkExpressionDenotesType(memberAccess.expression) !== void 0;
       const hidingMatcher = semanticContext.getHidingMatcher();
-      return new TypeMemberCompletionContext(
-        type,
-        localizationContext,
-        isStaticAccess,
-        hidingMatcher,
-        semanticContext
-      );
+      return new TypeMemberCompletionContext(type, isStaticAccess, hidingMatcher, semanticContext);
     }
     if (tokenOrKeyword.isToken(27 /* Dot */) && tokenOrKeyword.parent.kind === 135 /* QualifiedName */ && tokenOrKeyword.parent.parent.kind === 10 /* NamedTypeSpecifier */) {
       const namedTypeSpecifier = tokenOrKeyword.parent.parent;
@@ -3286,10 +3222,7 @@ var CompletionService = class {
         if (resolvedQualifier.kind === "package-name-segment") {
           let lookup;
           if (resolvedQualifier.packageTreeNode.package !== void 0) {
-            lookup = new PackageMemberLookup(
-              resolvedQualifier.packageTreeNode.package.value,
-              semanticContext.getLocalizationContext()
-            );
+            lookup = new PackageMemberLookup(resolvedQualifier.packageTreeNode.package);
           }
           const hidingMatcher = semanticContext.getHidingMatcher();
           const typeSearchLocation = new PackageNameSegmentTypeSearchLocation(
@@ -3302,7 +3235,7 @@ var CompletionService = class {
         if (resolvedQualifier.kind === "package-alias") {
           const package_ = resolvedQualifier.packageAlias.getPackage();
           if (package_ !== void 0) {
-            const lookup = new PackageMemberLookup(package_, semanticContext.getLocalizationContext());
+            const lookup = new PackageMemberLookup(package_);
             const hidingMatcher = semanticContext.getHidingMatcher();
             const typeSearchLocation = new PackageAliasTypeSearchLocation(lookup, hidingMatcher);
             return new TypeCompletionContext(typeSearchLocation, completionInIsOrAsExpressionInfo);
@@ -3322,10 +3255,7 @@ var CompletionService = class {
         if (resolvedQualifier.kind === "package-name-segment") {
           let lookup;
           if (resolvedQualifier.packageTreeNode.package !== void 0) {
-            lookup = new PackageMemberLookup(
-              resolvedQualifier.packageTreeNode.package.value,
-              semanticContext.getLocalizationContext()
-            );
+            lookup = new PackageMemberLookup(resolvedQualifier.packageTreeNode.package);
           }
           const hidingMatcher = semanticContext.getHidingMatcher();
           const typeSearchLocation = new PackageNameSegmentTypeSearchLocation(
@@ -3338,7 +3268,7 @@ var CompletionService = class {
         if (resolvedQualifier.kind === "package-alias") {
           const package_ = resolvedQualifier.packageAlias.getPackage();
           if (package_ !== void 0) {
-            const lookup = new PackageMemberLookup(package_, semanticContext.getLocalizationContext());
+            const lookup = new PackageMemberLookup(package_);
             const hidingMatcher = semanticContext.getHidingMatcher();
             const typeSearchLocation = new PackageAliasTypeSearchLocation(lookup, hidingMatcher);
             return new TagCompletionContext(typeSearchLocation);
@@ -3363,13 +3293,7 @@ var CompletionService = class {
     }
     if (syntaxContext.isExpressionContext !== void 0) {
       const { targetTypes, targetSignaturesParameters } = this.getTargetTypesAndTargetSignaturesParameters(syntaxContext.isExpressionContext.expressionRole, semanticContext);
-      const localizationContext = semanticContext.getLocalizationContext();
-      return new ExpressionCompletionContext(
-        semanticContext,
-        targetSignaturesParameters,
-        targetTypes,
-        localizationContext
-      );
+      return new ExpressionCompletionContext(semanticContext, targetSignaturesParameters, targetTypes);
     }
     const topLevelTranslationCompletionContext = this.tryGetTopLevelTranslationCompletionContext(
       syntaxContext,
@@ -3422,11 +3346,8 @@ var CompletionService = class {
       hasPrecedingKeyword = true;
     }
     if (translationsDeclaration !== void 0) {
-      const sourceLocale = translationPackage.getTranslatedPackage().getLocale();
-      const translatedPackageMemberLookup = new PackageMemberLookup(
-        translationPackage.getTranslatedPackage(),
-        semanticContext.getLocalizationContext()
-      );
+      const sourceLocale = translationPackage.getTargetPackage().getLocale();
+      const translatedPackageMemberLookup = new PackageMemberLookup(translationPackage.getTargetPackage());
       const hidingMatcher = semanticContext.getHidingMatcher();
       return new TopLevelTranslationListCompletionContext(
         sourceLocale,
@@ -3440,7 +3361,7 @@ var CompletionService = class {
       const qualifiedName = tokenOrKeyword.parent;
       if (qualifiedName.parent.kind === 134 /* PackageImportTranslation */ && qualifiedName === qualifiedName.parent.sourceName) {
         const precedingSegmentNames = qualifiedName.qualifiers.takeWhile((s) => s.rangeStart < tokenOrKeyword.value.rangeStart).map((p) => this._analyzer.createNameFromIdentifier(p)).toArray();
-        const sourceLocale = translationPackage.getTranslatedPackage().getLocale();
+        const sourceLocale = translationPackage.getTargetPackage().getLocale();
         return new PackageImportCompletionContext(precedingSegmentNames, { sourceLocale });
       }
     }
@@ -3474,7 +3395,7 @@ var CompletionService = class {
       hasPrecedingKeyword = true;
     }
     if (typeTranslation !== void 0) {
-      const sourceLocale = translationPackage.getTranslatedPackage().getLocale();
+      const sourceLocale = translationPackage.getTargetPackage().getLocale();
       let type;
       if (this._sourceFile.package.kind === "translation") {
         const translationPackage2 = this._analyzer.getAnalyzedTranslationPackageIfTargetResolved(
@@ -3553,13 +3474,14 @@ var CompletionService = class {
       return { targetTypes: void 0, targetSignaturesParameters: void 0 };
     }
     if (role.kind === "error-value") {
-      const errorType = this._analyzer.standardTypes.error;
-      const textType = this._analyzer.standardTypes.text;
-      return { targetTypes: [errorType, textType], targetSignaturesParameters: void 0 };
+      const standardTypes = this._analyzer.getLocalizedStandardTypes(
+        TreeQuery.fromNode(role.errorStatement).locale(this._analyzer)
+      );
+      return { targetTypes: [standardTypes.error, standardTypes.text], targetSignaturesParameters: void 0 };
     }
     if (role.kind === "function-block-expression") {
       const targetType = semanticContext.getContainingSubprogram()?.getReturnType();
-      if (targetType !== void 0 && !targetType.equals(this._analyzer.standardTypes.none)) {
+      if (targetType !== void 0 && !targetType.equals(this._analyzer.originalStandardTypes.none)) {
         return { targetTypes: [targetType], targetSignaturesParameters: void 0 };
       }
       return { targetTypes: void 0, targetSignaturesParameters: void 0 };
@@ -3789,9 +3711,9 @@ var CompletionService = class {
     return result;
   }
   prioritizeItemsFromUnionType(items, type) {
-    const constituentTypeEntities = Query.from(type.unaliasedFlattenedTypes).mapAndFilter((t) => t.getEntity()).uniqueToSet();
+    const constituentTypeEntities = Query.from(type.unaliasedFlattenedTypes).mapAndFilter((t) => t.getEntity()?.getOriginalEntity()).uniqueToSet();
     for (const item of items) {
-      if (item.kind === "named-type" && constituentTypeEntities.has(item.entity)) {
+      if (item.kind === "named-type" && constituentTypeEntities.has(item.entity.getOriginalEntity())) {
         item.prefix = "*";
         item.sortText = "10" /* Highest */;
       }
@@ -3802,53 +3724,33 @@ var CompletionService = class {
   }
   getScopeCompletionItemInfos(semanticContext) {
     return Query.from(semanticContext.getNamedDeclarations()).map((d) => {
-      switch (d.value.kind) {
+      switch (d.kind) {
         case "variable": {
-          if (d.value.value.kind === "entity") {
-            return new VariableEntityCompletionItemInfo(
-              this.completionItemInfoContext,
-              d.value.value.value,
-              d.name,
-              d.requiresExplicitOriginalName
-            );
+          if (d.value.kind === "entity") {
+            return new VariableEntityCompletionItemInfo(this.completionItemInfoContext, d.value.value);
           } else {
-            return new FieldCompletionItemInfo(
-              this.completionItemInfoContext,
-              d.value.value.value,
-              d.name,
-              d.requiresExplicitOriginalName
-            );
+            return new FieldCompletionItemInfo(this.completionItemInfoContext, d.value.value);
           }
         }
         case "function": {
-          if (d.value.value.kind === "entity") {
-            return new FunctionEntityCompletionItemInfo(
-              this.completionItemInfoContext,
-              d.value.value.value,
-              d.name,
-              d.requiresExplicitOriginalName
-            );
+          if (d.value.kind === "entity") {
+            return new FunctionEntityCompletionItemInfo(this.completionItemInfoContext, d.value.value);
           } else {
-            return new MethodCompletionItemInfo(
-              this.completionItemInfoContext,
-              d.value.value.value,
-              d.name,
-              d.requiresExplicitOriginalName
-            );
+            return new MethodCompletionItemInfo(this.completionItemInfoContext, d.value.value);
           }
         }
         case "type": {
-          return this.createTypeEntityCompletionItemInfo(d.value.value, d.name, d.requiresExplicitOriginalName);
+          return this.createTypeEntityCompletionItemInfo(d.value);
         }
         case "package-alias":
-          return new PackageAliasEntityCompletionItemInfo(this.completionItemInfoContext, d.value.value);
+          return new PackageAliasEntityCompletionItemInfo(this.completionItemInfoContext, d.value);
         case "package-name-segment":
-          return new PackageNameSegmentCompletionItemInfo(this.completionItemInfoContext, d.name.value);
+          return new PackageNameSegmentCompletionItemInfo(this.completionItemInfoContext, d.value.name);
         default:
-          Debug.never(d.value);
+          Debug.never(d);
       }
     }).chain(
-      Query.from(semanticContext.getOperators()).map((o) => new OperatorCompletionItemInfo(this.completionItemInfoContext, o.value, o.localization))
+      Query.from(semanticContext.getOperators()).map((o) => new OperatorCompletionItemInfo(this.completionItemInfoContext, o))
     );
   }
   getTypeCompletionItemInfos(ctx) {
@@ -3874,13 +3776,8 @@ var CompletionService = class {
   }
   getTypeCompletionItemInfosFromPackage(searchLocation) {
     return searchLocation.packageMemberLookup.getNamedMembers(searchLocation.hidingMatcher).map((m) => {
-      if (m.value.kind === 2 /* Type */) {
-        return new NamedTypeCompletionItemInfo(
-          this.completionItemInfoContext,
-          m.value,
-          m.name,
-          m.requiresExplicitOriginalName
-        );
+      if (m.kind === 2 /* Type */) {
+        return new NamedTypeCompletionItemInfo(this.completionItemInfoContext, m);
       }
       return void 0;
     }).filter((i) => i !== void 0);
@@ -3891,13 +3788,8 @@ var CompletionService = class {
       const lookup = searchLocation.packageMemberLookup;
       query = query.chain(
         lookup.getNamedMembers(searchLocation.hidingMatcher).map((m) => {
-          if (m.value.kind === 2 /* Type */) {
-            return new NamedTypeCompletionItemInfo(
-              this.completionItemInfoContext,
-              m.value,
-              m.name,
-              m.requiresExplicitOriginalName
-            );
+          if (m.kind === 2 /* Type */) {
+            return new NamedTypeCompletionItemInfo(this.completionItemInfoContext, m);
           }
           return void 0;
         }).filter((i) => i !== void 0)
@@ -3907,21 +3799,16 @@ var CompletionService = class {
   }
   getTypeCompletionItemInfosFromScope(searchLocation) {
     return searchLocation.semanticContext.getTypesOrContainersWithTypes().map((d) => {
-      switch (d.value.kind) {
+      switch (d.kind) {
         case "type": {
-          return new NamedTypeCompletionItemInfo(
-            this.completionItemInfoContext,
-            d.value.value,
-            d.name,
-            d.requiresExplicitOriginalName
-          );
+          return new NamedTypeCompletionItemInfo(this.completionItemInfoContext, d.value);
         }
         case "package-name-segment":
-          return new PackageNameSegmentCompletionItemInfo(this.completionItemInfoContext, d.name.value);
+          return new PackageNameSegmentCompletionItemInfo(this.completionItemInfoContext, d.value.name);
         case "package-alias":
-          return new PackageAliasEntityCompletionItemInfo(this.completionItemInfoContext, d.value.value);
+          return new PackageAliasEntityCompletionItemInfo(this.completionItemInfoContext, d.value);
         default:
-          Debug.never(d.value);
+          Debug.never(d);
       }
     });
   }
@@ -3942,20 +3829,10 @@ var CompletionService = class {
   }
   getTagCompletionItemInfosFromPackage(searchLocation) {
     return searchLocation.packageMemberLookup.getNamedMembers(searchLocation.hidingMatcher).map((m) => {
-      if (m.value.kind === 2 /* Type */) {
-        return new NamedTypeCompletionItemInfo(
-          this.completionItemInfoContext,
-          m.value,
-          m.name,
-          m.requiresExplicitOriginalName
-        );
-      } else if (m.value.kind === 1 /* Function */) {
-        return new FunctionEntityCompletionItemInfo(
-          this.completionItemInfoContext,
-          m.value,
-          m.name,
-          m.requiresExplicitOriginalName
-        );
+      if (m.kind === 2 /* Type */) {
+        return new NamedTypeCompletionItemInfo(this.completionItemInfoContext, m);
+      } else if (m.kind === 1 /* Function */) {
+        return new FunctionEntityCompletionItemInfo(this.completionItemInfoContext, m);
       }
       return void 0;
     }).filter((i) => i !== void 0);
@@ -3966,20 +3843,10 @@ var CompletionService = class {
       const lookup = searchLocation.packageMemberLookup;
       query = query.chain(
         lookup.getNamedMembers(searchLocation.hidingMatcher).map((m) => {
-          if (m.value.kind === 2 /* Type */) {
-            return new NamedTypeCompletionItemInfo(
-              this.completionItemInfoContext,
-              m.value,
-              m.name,
-              m.requiresExplicitOriginalName
-            );
-          } else if (m.value.kind === 1 /* Function */) {
-            return new FunctionEntityCompletionItemInfo(
-              this.completionItemInfoContext,
-              m.value,
-              m.name,
-              m.requiresExplicitOriginalName
-            );
+          if (m.kind === 2 /* Type */) {
+            return new NamedTypeCompletionItemInfo(this.completionItemInfoContext, m);
+          } else if (m.kind === 1 /* Function */) {
+            return new FunctionEntityCompletionItemInfo(this.completionItemInfoContext, m);
           }
           return void 0;
         }).filter((i) => i !== void 0)
@@ -3989,104 +3856,67 @@ var CompletionService = class {
   }
   getTagCompletionItemInfosFromScope(searchLocation) {
     return searchLocation.semanticContext.getNamedDeclarations().map((d) => {
-      switch (d.value.kind) {
+      switch (d.kind) {
         case "type":
-          return new NamedTypeCompletionItemInfo(
-            this.completionItemInfoContext,
-            d.value.value,
-            d.name,
-            d.requiresExplicitOriginalName
-          );
+          return new NamedTypeCompletionItemInfo(this.completionItemInfoContext, d.value);
         case "function":
-          return new FunctionEntityCompletionItemInfo(
-            this.completionItemInfoContext,
-            d.value.value.getEntity(),
-            d.name,
-            d.requiresExplicitOriginalName
-          );
+          return new FunctionEntityCompletionItemInfo(this.completionItemInfoContext, d.value.getEntity());
         case "package-name-segment":
-          return new PackageNameSegmentCompletionItemInfo(this.completionItemInfoContext, d.name.value);
+          return new PackageNameSegmentCompletionItemInfo(this.completionItemInfoContext, d.value.name);
         case "package-alias":
-          return new PackageAliasEntityCompletionItemInfo(this.completionItemInfoContext, d.value.value);
+          return new PackageAliasEntityCompletionItemInfo(this.completionItemInfoContext, d.value);
         case "variable":
           return void 0;
         default:
-          Debug.never(d.value);
+          Debug.never(d);
       }
     }).filter((i) => i !== void 0);
   }
   getPackageAliasMemberCompletionItemInfos(ctx) {
-    return ctx.packageMemberLookup.getNamedMembers(ctx.hidingMatcher).map((m) => this.packageMemberToCompletionItemInfo(m.value, m.name, m.requiresExplicitOriginalName));
+    return ctx.packageMemberLookup.getNamedMembers(ctx.hidingMatcher).map((m) => this.packageMemberToCompletionItemInfo(m));
   }
   getPackageNameSegmentCompletionItemInfos(ctx) {
     let query = Query.from(ctx.packageTreeNode.getChildren()).map((c) => new PackageNameSegmentCompletionItemInfo(this.completionItemInfoContext, c.name));
     if (ctx.packageMemberLookup !== void 0) {
       const lookup = ctx.packageMemberLookup;
       query = query.chain(
-        lookup.getNamedMembers(ctx.hidingMatcher).map((m) => this.packageMemberToCompletionItemInfo(m.value, m.name, m.requiresExplicitOriginalName))
+        lookup.getNamedMembers(ctx.hidingMatcher).map((m) => this.packageMemberToCompletionItemInfo(m))
       );
     }
     return query.toArray();
   }
-  packageMemberToCompletionItemInfo(member, name, isNameExplicitlyOriginal) {
+  packageMemberToCompletionItemInfo(member) {
     switch (member.kind) {
       case 0 /* Variable */:
-        return new VariableEntityCompletionItemInfo(
-          this.completionItemInfoContext,
-          member,
-          name,
-          isNameExplicitlyOriginal
-        );
+        return new VariableEntityCompletionItemInfo(this.completionItemInfoContext, member);
       case 1 /* Function */:
-        return new FunctionEntityCompletionItemInfo(
-          this.completionItemInfoContext,
-          member,
-          name,
-          isNameExplicitlyOriginal
-        );
+        return new FunctionEntityCompletionItemInfo(this.completionItemInfoContext, member);
       case 2 /* Type */:
-        return this.createTypeEntityCompletionItemInfo(member, name, isNameExplicitlyOriginal);
+        return this.createTypeEntityCompletionItemInfo(member);
       default:
         Debug.never(member);
     }
   }
-  createTypeEntityCompletionItemInfo(entity, name, isNameExplicitlyOriginal, prefix = "", sortText = "") {
-    return new NamedTypeCompletionItemInfo(
-      this.completionItemInfoContext,
-      entity,
-      name,
-      isNameExplicitlyOriginal,
-      prefix,
-      sortText
-    );
+  createTypeEntityCompletionItemInfo(entity, prefix = "", sortText = "") {
+    return new NamedTypeCompletionItemInfo(this.completionItemInfoContext, entity, prefix, sortText);
   }
   getTypeMemberCompletionItemInfos(ctx) {
     const type = this._analyzer.excludeNoneFromType(ctx.type);
-    const memberLookup = TypeMemberLookup.ofType(this._analyzer, type, ctx.localizationContext);
+    const memberLookup = TypeMemberLookup.ofType(this._analyzer, type, this._locale);
     const options6 = ctx.isStaticAccess ? 2 /* OnlyStaticMembers */ : 1 /* OnlyInstanceMembers */;
     return memberLookup.getNamedMembers(options6, ctx.hidingMatcher, ctx.typeExtensionLookup).map((m) => {
-      switch (m.value.kind) {
+      switch (m.kind) {
         case "method":
-          return new MethodCompletionItemInfo(
-            this.completionItemInfoContext,
-            m.value,
-            m.name,
-            m.requiresExplicitOriginalName
-          );
+          return new MethodCompletionItemInfo(this.completionItemInfoContext, m);
         case "field":
-          return new FieldCompletionItemInfo(
-            this.completionItemInfoContext,
-            m.value,
-            m.name,
-            m.requiresExplicitOriginalName
-          );
+          return new FieldCompletionItemInfo(this.completionItemInfoContext, m);
         default:
-          Debug.never(m.value);
+          Debug.never(m);
       }
-    }).concat(memberLookup.getOperators(options6, ctx.hidingMatcher, ctx.typeExtensionLookup).map((o) => new OperatorCompletionItemInfo(this.completionItemInfoContext, o.value, o.localization)));
+    }).concat(memberLookup.getOperators(options6, ctx.hidingMatcher, ctx.typeExtensionLookup).map((o) => new OperatorCompletionItemInfo(this.completionItemInfoContext, o)));
   }
   getPackageImportCompletionItemInfos(ctx) {
-    const result = this._analyzer.packageImports.getPackagesAvailableForImport(this._sourceFile.package).map((p) => p.getImportName()).filter((n) => {
+    const result = this._analyzer.packageImports.getPackagesAvailableForImport(this._sourceFile.package).map((p) => p.getName()).filter((n) => {
       if (ctx.precedingSegmentNames.length === 0) {
         return true;
       }
@@ -4108,7 +3938,7 @@ var CompletionService = class {
       if (this._sourceFile.package.kind === "translation") {
         const analyzedTranslationPackage = this._analyzer.getAnalyzedTranslationPackageIfTargetResolved(this._sourceFile.package);
         if (analyzedTranslationPackage !== void 0) {
-          const name = analyzedTranslationPackage.getTranslatedPackage().getName();
+          const name = analyzedTranslationPackage.getTargetPackage().getName();
           items = Query.from([
             new PackageNameSegmentCompletionItemInfo(this.completionItemInfoContext, name.segments[0])
           ]);
@@ -4117,10 +3947,10 @@ var CompletionService = class {
       result = items ?? Query.empty();
     } else if (ctx.translationKind === 2 /* Method */) {
       result = Query.from(ctx.packageMemberLookup.getNamedMembers(ctx.hidingMatcher)).mapAndFilter((d) => {
-        if (d.value.kind === 1 /* Function */) {
+        if (d.kind === 1 /* Function */) {
           return new AliasesSourceFunctionCompletionItemInfo(
             this.completionItemInfoContext,
-            d.value,
+            d,
             !ctx.hasPrecedingKeyword,
             displayService_
           );
@@ -4129,10 +3959,10 @@ var CompletionService = class {
       });
     } else if (ctx.translationKind === 3 /* Type */) {
       result = Query.from(ctx.packageMemberLookup.getNamedMembers(ctx.hidingMatcher)).mapAndFilter((d) => {
-        if (d.value.kind === 2 /* Type */) {
+        if (d.kind === 2 /* Type */) {
           return new AliasesSourcePackageTypeCompletionItemInfo(
             this.completionItemInfoContext,
-            d.value,
+            d,
             !ctx.hasPrecedingKeyword,
             displayService_
           );
@@ -4144,7 +3974,7 @@ var CompletionService = class {
       if (this._sourceFile.package.kind === "translation") {
         const analyzedTranslationPackage = this._analyzer.getAnalyzedTranslationPackageIfTargetResolved(this._sourceFile.package);
         if (analyzedTranslationPackage !== void 0) {
-          const name = analyzedTranslationPackage.getTranslatedPackage().getName();
+          const name = analyzedTranslationPackage.getTargetPackage().getName();
           packageNameItems = Query.from([
             new PackageNameSegmentCompletionItemInfo(this.completionItemInfoContext, name.segments[0])
           ]);
@@ -4152,29 +3982,25 @@ var CompletionService = class {
       }
       result = Query.from(packageNameItems ?? []).chain(
         Query.from(ctx.packageMemberLookup.getNamedMembers(ctx.hidingMatcher)).map((d) => {
-          switch (d.value.kind) {
+          switch (d.kind) {
             case 0 /* Variable */:
-              return new AliasesSourceVariableCompletionItemInfo(
-                this.completionItemInfoContext,
-                d.value,
-                displayService_
-              );
+              return new AliasesSourceVariableCompletionItemInfo(this.completionItemInfoContext, d, displayService_);
             case 1 /* Function */:
               return new AliasesSourceFunctionCompletionItemInfo(
                 this.completionItemInfoContext,
-                d.value,
+                d,
                 !ctx.hasPrecedingKeyword,
                 displayService_
               );
             case 2 /* Type */:
               return new AliasesSourcePackageTypeCompletionItemInfo(
                 this.completionItemInfoContext,
-                d.value,
+                d,
                 !ctx.hasPrecedingKeyword,
                 displayService_
               );
             default:
-              Debug.never(d.value);
+              Debug.never(d);
           }
         })
       );
@@ -4439,9 +4265,8 @@ var PackageImportCompletionContext = class {
   }
 };
 var TypeMemberCompletionContext = class {
-  constructor(type, localizationContext, isStaticAccess, hidingMatcher, typeExtensionLookup) {
+  constructor(type, isStaticAccess, hidingMatcher, typeExtensionLookup) {
     this.type = type;
-    this.localizationContext = localizationContext;
     this.isStaticAccess = isStaticAccess;
     this.hidingMatcher = hidingMatcher;
     this.typeExtensionLookup = typeExtensionLookup;
@@ -4504,11 +4329,10 @@ var PackageNameSegmentTypeSearchLocation = class {
   }
 };
 var ExpressionCompletionContext = class {
-  constructor(semanticContext, targetSignaturesValueParameters, targetTypes, localizationContext) {
+  constructor(semanticContext, targetSignaturesValueParameters, targetTypes) {
     this.semanticContext = semanticContext;
     this.targetSignaturesValueParameters = targetSignaturesValueParameters;
     this.targetTypes = targetTypes;
-    this.localizationContext = localizationContext;
     this.kind = "expression";
   }
 };
@@ -4540,13 +4364,13 @@ var CompletionItemInfoContext = class {
   }
   getInsertTextForName(name, withoutBackQuotes = false) {
     let flags = name.flags;
-    const flagsForNameWithoutBackQuotes = name.flags & ~(32 /* BackingVariableName */ | 16 /* ConflictResolvingParameterName */);
+    const flagsForNameWithoutBackQuotes = name.flags & ~(16 /* BackingVariableName */ | 8 /* ConflictResolvingParameterName */);
     const nameWithoutBackQuotes = name.getPreferredUnescapedOriginal(flagsForNameWithoutBackQuotes);
-    if ((flags & 8 /* RequiresQuotes */) === 0 && this._singleWordKeywordValues.has(nameWithoutBackQuotes)) {
-      flags |= 8 /* RequiresQuotes */;
+    if ((flags & 4 /* RequiresQuotes */) === 0 && this._singleWordKeywordValues.has(nameWithoutBackQuotes)) {
+      flags |= 4 /* RequiresQuotes */;
     }
     if (withoutBackQuotes) {
-      flags &= ~(32 /* BackingVariableName */ | 16 /* ConflictResolvingParameterName */);
+      flags &= ~(16 /* BackingVariableName */ | 8 /* ConflictResolvingParameterName */);
     }
     let result;
     if (flags === flagsForNameWithoutBackQuotes) {
@@ -4608,23 +4432,19 @@ var PackageAliasEntityCompletionItemInfo = class {
   }
 };
 var FieldCompletionItemInfo = class {
-  constructor(ctx, field, name, isNameExplicitlyOriginal) {
+  constructor(ctx, field) {
     this.ctx = ctx;
     this.field = field;
-    this.name = name;
-    this.isNameExplicitlyOriginal = isNameExplicitlyOriginal;
     this.kind = "field";
   }
   getLabel() {
-    return `${this.isNameExplicitlyOriginal ? "~" : ""}${this.ctx.getInsertTextForName(this.name.value)}`;
+    return this.ctx.getInsertTextForName(this.field.getName());
   }
   getCompletionItemKind() {
     return this.field.isVariant() ? 12 /* Variant */ : 2 /* Field */;
   }
   getDetails() {
-    return this.ctx.displayService.displayVariableDeclaration(
-      new VariableDeclaration_typeMember(this.field, this.name.localization)
-    );
+    return this.ctx.displayService.displayTypeMember(this.field);
   }
   getInsertText() {
     return void 0;
@@ -4637,23 +4457,19 @@ var FieldCompletionItemInfo = class {
   }
 };
 var MethodCompletionItemInfo = class {
-  constructor(ctx, method, name, isNameExplicitlyOriginal) {
+  constructor(ctx, method) {
     this.ctx = ctx;
     this.method = method;
-    this.name = name;
-    this.isNameExplicitlyOriginal = isNameExplicitlyOriginal;
     this.kind = "method";
   }
   getLabel() {
-    return `${this.isNameExplicitlyOriginal ? "~" : ""}${this.ctx.getInsertTextForName(this.name.value)}`;
+    return this.ctx.getInsertTextForName(this.method.getName());
   }
   getCompletionItemKind() {
     return 3 /* Method */;
   }
   getDetails() {
-    return this.ctx.displayService.displayFunctionDeclaration(
-      new FunctionDeclaration_typeMember(this.method, this.name.localization)
-    );
+    return this.ctx.displayService.displayTypeMember(this.method);
   }
   getInsertText() {
     return void 0;
@@ -4666,22 +4482,19 @@ var MethodCompletionItemInfo = class {
   }
 };
 var OperatorCompletionItemInfo = class {
-  constructor(ctx, operator, localization) {
+  constructor(ctx, operator) {
     this.ctx = ctx;
     this.operator = operator;
-    this.localization = localization;
     this.kind = "operator";
   }
   getLabel() {
-    return `'${this.ctx.displayService.displayOperatorKind(this.operator.getOperatorKind(), this.localization.locale)}'`;
+    return `'${this.ctx.displayService.displayOperatorKind(this.operator.getOperatorKind())}'`;
   }
   getCompletionItemKind() {
     return 4 /* Operator */;
   }
   getDetails() {
-    return this.ctx.displayService.displayOperatorDeclaration(
-      new OperatorDeclaration_typeMember(this.operator, this.localization)
-    );
+    return this.ctx.displayService.displayTypeMember(this.operator);
   }
   getInsertText() {
     return void 0;
@@ -4694,15 +4507,13 @@ var OperatorCompletionItemInfo = class {
   }
 };
 var VariableEntityCompletionItemInfo = class {
-  constructor(ctx, entity, name, isNameExplicitlyOriginal) {
+  constructor(ctx, entity) {
     this.ctx = ctx;
     this.entity = entity;
-    this.name = name;
-    this.isNameExplicitlyOriginal = isNameExplicitlyOriginal;
     this.kind = "variable-entity";
   }
   getLabel() {
-    return `${this.isNameExplicitlyOriginal ? "~" : ""}${this.ctx.getInsertTextForName(this.name.value)}`;
+    return this.ctx.getInsertTextForName(this.entity.getName());
   }
   getCompletionItemKind() {
     switch (this.entity.subkind) {
@@ -4719,9 +4530,7 @@ var VariableEntityCompletionItemInfo = class {
     }
   }
   getDetails() {
-    return this.ctx.displayService.displayVariableDeclaration(
-      new VariableDeclaration_entity(this.entity, this.name.localization)
-    );
+    return this.ctx.displayService.displayEntity(this.entity);
   }
   getInsertText() {
     return void 0;
@@ -4734,15 +4543,13 @@ var VariableEntityCompletionItemInfo = class {
   }
 };
 var FunctionEntityCompletionItemInfo = class {
-  constructor(ctx, entity, name, isNameExplicitlyOriginal) {
+  constructor(ctx, entity) {
     this.ctx = ctx;
     this.entity = entity;
-    this.name = name;
-    this.isNameExplicitlyOriginal = isNameExplicitlyOriginal;
     this.kind = "function-entity";
   }
   getLabel() {
-    return `${this.isNameExplicitlyOriginal ? "~" : ""}${this.ctx.getInsertTextForName(this.name.value)}`;
+    return this.ctx.getInsertTextForName(this.entity.getName());
   }
   getCompletionItemKind() {
     switch (this.entity.subkind) {
@@ -4757,9 +4564,7 @@ var FunctionEntityCompletionItemInfo = class {
     }
   }
   getDetails() {
-    return this.ctx.displayService.displayFunctionDeclaration(
-      new FunctionDeclaration_entity(this.entity, this.name.localization)
-    );
+    return this.ctx.displayService.displayEntity(this.entity);
   }
   getInsertText() {
     return void 0;
@@ -4772,17 +4577,15 @@ var FunctionEntityCompletionItemInfo = class {
   }
 };
 var NamedTypeCompletionItemInfo = class {
-  constructor(ctx, entity, name, isNameExplicitlyOriginal, prefix = "", sortText) {
+  constructor(ctx, entity, prefix = "", sortText) {
     this.ctx = ctx;
     this.entity = entity;
-    this.name = name;
-    this.isNameExplicitlyOriginal = isNameExplicitlyOriginal;
     this.prefix = prefix;
     this.sortText = sortText;
     this.kind = "named-type";
   }
   getLabel() {
-    return `${this.prefix}${this.isNameExplicitlyOriginal ? "~" : ""}${this.ctx.getInsertTextForName(this.name.value)}`;
+    return `${this.prefix}${this.ctx.getInsertTextForName(this.entity.getName())}`;
   }
   getCompletionItemKind() {
     switch (this.entity.typeEntityKind) {
@@ -4809,10 +4612,10 @@ var NamedTypeCompletionItemInfo = class {
     }
   }
   getDetails() {
-    return this.ctx.displayService.displayTypeDeclarationEntity(this.entity, this.name.localization);
+    return this.ctx.displayService.displayEntity(this.entity);
   }
   getInsertText() {
-    return `${this.isNameExplicitlyOriginal ? "~" : ""}${this.ctx.getInsertTextForName(this.name.value)}`;
+    return this.ctx.getInsertTextForName(this.entity.getName());
   }
   getSortText() {
     return this.sortText;
@@ -4890,11 +4693,7 @@ var TargetSignatureValueParameterCompletionItemInfo = class {
   }
   getDetails() {
     return this.ctx.displayService.displayValueParameterDeclaration(
-      new ValueParameterDeclaration_universal(
-        this.parameter.entity,
-        this.parameter.type,
-        this.parameter.localization
-      )
+      new ValueParameterDeclaration_universal(this.parameter.entity, this.parameter.type)
     );
   }
   getInsertText() {
@@ -4932,9 +4731,7 @@ var AliasesSourceVariableCompletionItemInfo = class {
     }
   }
   getDetails() {
-    return this.displayService.displayVariableDeclaration(
-      new VariableDeclaration_entity(this.variable, Localization.Original.ofEntity(this.variable))
-    );
+    return this.displayService.displayEntity(this.variable);
   }
   getInsertText() {
     return void 0;
@@ -4970,13 +4767,11 @@ var AliasesSourceFunctionCompletionItemInfo = class {
     }
   }
   getDetails() {
-    return this.displayService.displayFunctionDeclaration(
-      new FunctionDeclaration_entity(this.func, Localization.Original.ofEntity(this.func))
-    );
+    return this.displayService.displayFunctionDeclaration(new FunctionDeclaration_entity(this.func));
   }
   getInsertText() {
     const displayParts = this.displayService.getFunctionDeclarationDisplayParts(
-      new FunctionDeclaration_entity(this.func, Localization.Original.ofEntity(this.func))
+      new FunctionDeclaration_entity(this.func)
     );
     const keywordWithWhitespace = this.includeFunctionKeyword ? displayParts.functionKeyword + displayParts.whitespaceAfterFunctionKeyword : "";
     const valueParameters = displayParts.valueParameters.map((p) => p.name).join(displayParts.typeParameterSeparator);
@@ -5034,23 +4829,22 @@ var AliasesSourcePackageTypeCompletionItemInfo = class {
     return void 0;
   }
   getDisplayServiceTypeDeclaration() {
-    const localization = Localization.Original.ofEntity(this.typeEntity);
     switch (this.typeEntity.typeEntityKind) {
       case 3 /* Variant */:
         return new TypeDeclaration_variant(
-          new TypeDeclarationVariant_entity(this.typeEntity, localization)
+          new TypeDeclarationVariant_entity(this.typeEntity)
         );
       case 0 /* Function */:
         return new TypeDeclaration_function(
-          new TypeDeclarationFunction_entity(this.typeEntity, localization)
+          new TypeDeclarationFunction_entity(this.typeEntity)
         );
       case 1 /* Structured */:
         return new TypeDeclaration_structured(
-          new TypeDeclarationStructured_entity(this.typeEntity, localization)
+          new TypeDeclarationStructured_entity(this.typeEntity)
         );
       case 4 /* Alias */:
         return new TypeDeclaration_alias(
-          new TypeDeclarationAlias_entity(this.typeEntity, localization)
+          new TypeDeclarationAlias_entity(this.typeEntity)
         );
       default:
         Debug.never(this.typeEntity);
@@ -5069,11 +4863,7 @@ var AliasesSourceIndexerCompletionItemInfo = class {
     this._label = new Cached();
   }
   get label() {
-    return this._label.getOrInsertWith(
-      () => this.displayService.displayIndexerDeclaration(
-        new IndexerDeclaration_entity(this.indexer, Localization.Original.ofEntity(this.indexer))
-      )
-    );
+    return this._label.getOrInsertWith(() => this.displayService.displayIndexerDeclaration(new IndexerDeclaration_entity(this.indexer)));
   }
   getLabel() {
     return this.label;
@@ -5106,10 +4896,7 @@ var AliasesSourceConstructorCompletionItemInfo = class {
   }
   get label() {
     return this._label.getOrInsertWith(() => {
-      const constructorDeclaration = new ConstructorDeclaration_entity(
-        this.constructor_,
-        Localization.Original.ofEntity(this.constructor_)
-      );
+      const constructorDeclaration = new ConstructorDeclaration_entity(this.constructor_);
       const displayParts = this.displayService.getConstructorDeclarationDisplayParts(constructorDeclaration);
       const creationKeyword = this.displayService.displayKeyword(31 /* Creation */);
       return creationKeyword + displayParts.valueParametersStart + displayParts.valueParameters.map((p) => p.toString()).join(displayParts.valueParameterSeparator) + displayParts.valueParametersEnd;
@@ -5849,10 +5636,7 @@ var NodeSemanticInfoService = class {
       case 149 /* Argument */: {
         const respectiveParameter = analyzer.getRespectiveParameter(parent);
         if (respectiveParameter !== void 0) {
-          const target = new SimpleWithLocalization(
-            new MatchResultValueParameterReferenceTarget(respectiveParameter, 0 /* Get */),
-            respectiveParameter.name.localization
-          );
+          const target = new MatchResultValueParameterReferenceTarget(respectiveParameter, 0 /* Get */);
           result = new ReferenceNodeSemanticInfo([target], false);
           if (options6.includeBetterReferenceTargets) {
             result = this.getBetterReferenceTargetsOrPreserve(result);
@@ -5901,17 +5685,17 @@ var NodeSemanticInfoService = class {
         const getTargetResult = translationPackage?.getPackageVariableTranslationTarget(parent);
         if (translationPackage !== void 0 && getTargetResult?.target !== void 0) {
           if (node === parent.sourceName) {
-            const target = new SimpleWithLocalization(
-              new EntityReferenceTarget(getTargetResult.target, 0 /* Get */),
-              Localization.Original.ofEntity(getTargetResult.target)
-            );
+            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 translation = new Translation(translationPackage);
-            result = new NameTranslationNodeSemanticInfo([getTargetResult.target], false, translation);
+            const target = new EntityReferenceTarget(translationPackage.entityLocalizationContext.getLocalizedPackageVariableEntity(getTargetResult.target), 0 /* Get */);
+            result = new ReferenceNodeSemanticInfo([target], false);
+            if (options6.includeBetterReferenceTargets) {
+              result = this.getBetterReferenceTargetsOrPreserve(result);
+            }
           }
         }
         break;
@@ -5921,21 +5705,20 @@ var NodeSemanticInfoService = class {
         const getTargetsResult = translationPackage?.getFieldOrVariantTranslationTargets(parent);
         if (translationPackage !== void 0 && isNonEmptyArray(getTargetsResult?.targets)) {
           if (node === parent.sourceName) {
-            const targets = getTargetsResult.targets.map((t) => new SimpleWithLocalization(
-              new EntityReferenceTarget(t, 0 /* Get */),
-              Localization.Original.ofEntity(t)
-            ));
+            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 translation = new Translation(translationPackage);
-            result = new NameTranslationNodeSemanticInfo(
-              getTargetsResult.targets,
-              getTargetsResult.isAmbiguous,
-              translation
-            );
+            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;
@@ -5945,21 +5728,20 @@ var NodeSemanticInfoService = class {
         const getTargetsResult = translationPackage?.getPackageFunctionTranslationTargets(parent);
         if (translationPackage !== void 0 && isNonEmptyArray(getTargetsResult?.targets)) {
           if (node === parent.sourceName) {
-            const targets = getTargetsResult.targets.map((t) => new SimpleWithLocalization(
-              new EntityReferenceTarget(t, 0 /* Get */),
-              Localization.Original.ofEntity(t)
-            ));
+            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 translation = new Translation(translationPackage);
-            result = new NameTranslationNodeSemanticInfo(
-              getTargetsResult.targets,
-              getTargetsResult.isAmbiguous,
-              translation
-            );
+            const targets = getTargetsResult.targets.map((f) => new EntityReferenceTarget(
+              translationPackage.entityLocalizationContext.getLocalizedPackageFunctionEntity(f),
+              0 /* Get */
+            ));
+            result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), getTargetsResult.isAmbiguous);
+            if (options6.includeBetterReferenceTargets) {
+              result = this.getBetterReferenceTargetsOrPreserve(result);
+            }
           }
         }
         break;
@@ -5969,21 +5751,20 @@ var NodeSemanticInfoService = class {
         const getTargetsResult = translationPackage?.getMethodTranslationTargets(parent);
         if (translationPackage !== void 0 && isNonEmptyArray(getTargetsResult?.targets)) {
           if (node === parent.sourceName) {
-            const targets = getTargetsResult.targets.map((t) => new SimpleWithLocalization(
-              new EntityReferenceTarget(t, 0 /* Get */),
-              Localization.Original.ofEntity(t)
-            ));
+            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 translation = new Translation(translationPackage);
-            result = new NameTranslationNodeSemanticInfo(
-              getTargetsResult.targets,
-              getTargetsResult.isAmbiguous,
-              translation
-            );
+            const targets = getTargetsResult.targets.map((f) => new EntityReferenceTarget(
+              translationPackage.entityLocalizationContext.getLocalizedMethodEntity(f),
+              0 /* Get */
+            ));
+            result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), getTargetsResult.isAmbiguous);
+            if (options6.includeBetterReferenceTargets) {
+              result = this.getBetterReferenceTargetsOrPreserve(result);
+            }
           }
         }
         break;
@@ -5993,17 +5774,17 @@ var NodeSemanticInfoService = class {
         const getTargetResult = translationPackage?.getTypeTranslationTarget(parent);
         if (translationPackage !== void 0 && getTargetResult?.target !== void 0) {
           if (node === parent.sourceName) {
-            const target = new SimpleWithLocalization(
-              new EntityReferenceTarget(getTargetResult.target, 0 /* Get */),
-              Localization.Original.ofEntity(getTargetResult.target)
-            );
+            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 translation = new Translation(translationPackage);
-            result = new NameTranslationNodeSemanticInfo([getTargetResult.target], false, translation);
+            const target = new EntityReferenceTarget(translationPackage.entityLocalizationContext.getLocalizedTypeEntity(getTargetResult.target), 0 /* Get */);
+            result = new ReferenceNodeSemanticInfo([target], false);
+            if (options6.includeBetterReferenceTargets) {
+              result = this.getBetterReferenceTargetsOrPreserve(result);
+            }
           }
         }
         break;
@@ -6013,17 +5794,17 @@ var NodeSemanticInfoService = class {
         const getTargetResult = translationPackage?.getFunctionTypeTranslationTarget(parent);
         if (translationPackage !== void 0 && getTargetResult?.target !== void 0) {
           if (node === parent.sourceName) {
-            const target = new SimpleWithLocalization(
-              new EntityReferenceTarget(getTargetResult.target, 0 /* Get */),
-              Localization.Original.ofEntity(getTargetResult.target)
-            );
+            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 translation = new Translation(translationPackage);
-            result = new NameTranslationNodeSemanticInfo([getTargetResult.target], false, translation);
+            const target = new EntityReferenceTarget(translationPackage.entityLocalizationContext.getLocalizedPackageFunctionTypeEntity(getTargetResult.target), 0 /* Get */);
+            result = new ReferenceNodeSemanticInfo([target], false);
+            if (options6.includeBetterReferenceTargets) {
+              result = this.getBetterReferenceTargetsOrPreserve(result);
+            }
           }
         }
         break;
@@ -6080,11 +5861,7 @@ var NodeSemanticInfoService = class {
         if (isNarrowableReferenceExpression(node)) {
           narrowedType = analyzer.type.ofExpression(node);
         }
-        const target = new SimpleWithLocalization(new FieldReferenceTarget(
-          meaning.field.value,
-          meaning.accessKind,
-          narrowedType
-        ), meaning.field.localization);
+        const target = new FieldReferenceTarget(meaning.field, meaning.accessKind, narrowedType);
         result = new ReferenceNodeSemanticInfo([target], false);
         break;
       }
@@ -6093,11 +5870,7 @@ var NodeSemanticInfoService = class {
         if (isNarrowableReferenceExpression(node)) {
           narrowedType = analyzer.type.ofExpression(node);
         }
-        const target = new SimpleWithLocalization(new FieldReferenceTarget(
-          meaning.field.value,
-          meaning.accessKind,
-          narrowedType
-        ), meaning.field.localization);
+        const target = new FieldReferenceTarget(meaning.field, meaning.accessKind, narrowedType);
         result = new ReferenceNodeSemanticInfo([target], false);
         break;
       }
@@ -6106,11 +5879,7 @@ var NodeSemanticInfoService = class {
         if (isNarrowableReferenceExpression(node)) {
           narrowedType = analyzer.type.ofExpression(node);
         }
-        const target = new SimpleWithLocalization(new EntityReferenceTarget(
-          meaning.variable.value,
-          meaning.accessKind,
-          narrowedType
-        ), meaning.variable.localization);
+        const target = new EntityReferenceTarget(meaning.variable, meaning.accessKind, narrowedType);
         result = new ReferenceNodeSemanticInfo([target], false);
         break;
       }
@@ -6145,9 +5914,7 @@ var NodeSemanticInfoService = class {
         break;
       case "package-type-access":
         if (meaning.suitableTypes.length === 0 && meaning.candidates.length > 0) {
-          const targets = meaning.candidates.map(
-            (c) => new SimpleWithLocalization(new EntityReferenceTarget(c.value, 0 /* Get */), c.localization)
-          );
+          const targets = meaning.candidates.map((c) => new EntityReferenceTarget(c, 0 /* Get */));
           result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), true);
         } else {
           result = this.ofMaybeConstructorCallExpression(analyzer, meaning.suitableTypes, node, options6);
@@ -6157,10 +5924,7 @@ var NodeSemanticInfoService = class {
         result = this.ofPackageNameSegmentAccess(analyzer, meaning.packageTreeNode, node);
         break;
       case "mixed-ambiguous-access": {
-        const targets = Query.from(meaning.entities).mapAndFilter((d) => {
-          const target = new EntityReferenceTarget(d.value, 0 /* Get */);
-          return new SimpleWithLocalization(target, d.localization);
-        }).toArray();
+        const targets = Query.from(meaning.entities).mapAndFilter((d) => new EntityReferenceTarget(d, 0 /* Get */)).toArray();
         if (isNonEmptyArray(targets)) {
           result = new ReferenceNodeSemanticInfo(targets, true);
         }
@@ -6176,11 +5940,11 @@ var NodeSemanticInfoService = class {
     }
     return result;
     function createAccessedFunctionsReference(functions, isAmbiguous) {
-      const targets = functions.map((o) => new SimpleWithLocalization(new AccessedFunctionReferenceTarget(o.value), o.localization));
+      const targets = functions.map((o) => new AccessedFunctionReferenceTarget(o));
       return new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), isAmbiguous);
     }
     function createOperatorsReference(operators, isAmbiguous) {
-      const targets = operators.map((o) => new SimpleWithLocalization(new OperatorReferenceTarget(o.value), o.localization));
+      const targets = operators.map((o) => new OperatorReferenceTarget(o));
       return new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), isAmbiguous);
     }
   }
@@ -6204,17 +5968,14 @@ var NodeSemanticInfoService = class {
     if (qualifierIndex >= 0 && qualifierIndex < resolutionResult.resolvedQualifiers.length) {
       const resolvedQualifier = resolutionResult.resolvedQualifiers[qualifierIndex];
       if (resolvedQualifier.kind === "package-alias") {
-        const target = new SimpleWithLocalization(
-          new EntityReferenceTarget(resolvedQualifier.packageAlias, 0 /* Get */),
-          new Localization.Original(resolvedQualifier.packageAlias.getContainingPackage().getLocale())
-        );
+        const target = new EntityReferenceTarget(resolvedQualifier.packageAlias, 0 /* Get */);
         result = new ReferenceNodeSemanticInfo([target], false);
       } else if (resolvedQualifier.kind === "type") {
         if (resolvedQualifier.suitableTypes.length > 0) {
-          const targets = resolvedQualifier.suitableTypes.map((t) => new SimpleWithLocalization(new EntityReferenceTarget(t.value, 0 /* Get */), t.localization));
+          const targets = resolvedQualifier.suitableTypes.map((t) => new EntityReferenceTarget(t, 0 /* Get */));
           result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), targets.length > 1);
         } else if (resolvedQualifier.candidates.length > 0) {
-          const targets = resolvedQualifier.candidates.map((t) => new SimpleWithLocalization(new EntityReferenceTarget(t.value, 0 /* Get */), t.localization));
+          const targets = resolvedQualifier.candidates.map((t) => new EntityReferenceTarget(t, 0 /* Get */));
           result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), true);
         }
       } else if (resolvedQualifier.kind === "package-name-segment") {
@@ -6224,10 +5985,7 @@ var NodeSemanticInfoService = class {
         }
         const qualifier2 = resolutionResult.resolvedQualifiers[currentIndex];
         if (qualifier2.kind === "package-name-segment" && qualifier2.packageTreeNode.package !== void 0) {
-          const target = new SimpleWithLocalization(
-            new PackageReferenceTarget(qualifier2.packageTreeNode.package.value),
-            new Localization.Original(qualifier2.packageTreeNode.package.value.getLocale())
-          );
+          const target = new PackageReferenceTarget(qualifier2.packageTreeNode.package);
           result = new ReferenceNodeSemanticInfo([target], false);
         } else {
           result = void 0;
@@ -6237,13 +5995,13 @@ var NodeSemanticInfoService = class {
       }
     } else if (qualifierIndex === resolutionResult.resolvedQualifiers.length && resolutionResult.ambiguousDeclarations !== void 0) {
       const targets = resolutionResult.ambiguousDeclarations.map((d) => {
-        switch (d.value.kind) {
+        switch (d.kind) {
           case "entity":
-            return new SimpleWithLocalization(new EntityReferenceTarget(d.value.entity, 0 /* Get */), d.localization);
+            return new EntityReferenceTarget(d.entity, 0 /* Get */);
           case "node":
-            return new SimpleWithLocalization(new PackageNameTreeNodeReferenceTarget(d.value.node), d.localization);
+            return new PackageNameTreeNodeReferenceTarget(d.node);
           default:
-            Debug.never(d.value);
+            Debug.never(d);
         }
       });
       if (isNonEmptyArray(targets)) {
@@ -6265,18 +6023,18 @@ var NodeSemanticInfoService = class {
         case "type": {
           if (options6.preferredTargetOfExplicitConstructorCall === "type-declaration" || resolutionResult.meaning.kind !== "tag-type") {
             if (resolvedQualifier.suitableTypes.length > 0) {
-              const targets = resolvedQualifier.suitableTypes.map((t) => new SimpleWithLocalization(new EntityReferenceTarget(t.value, 0 /* Get */), t.localization));
+              const targets = resolvedQualifier.suitableTypes.map((t) => new EntityReferenceTarget(t, 0 /* Get */));
               result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), targets.length > 1);
             } else if (resolvedQualifier.candidates.length > 0) {
-              const targets = resolvedQualifier.candidates.map((t) => new SimpleWithLocalization(new EntityReferenceTarget(t.value, 0 /* Get */), t.localization));
+              const targets = resolvedQualifier.candidates.map((t) => new EntityReferenceTarget(t, 0 /* Get */));
               result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), true);
             }
           } else {
             if (resolutionResult.meaning.suitableConstructors.length > 0) {
-              const targets = resolutionResult.meaning.suitableConstructors.map((t) => new SimpleWithLocalization(new ConstructorReferenceTarget(t.value), t.localization));
+              const targets = resolutionResult.meaning.suitableConstructors.map((t) => new ConstructorReferenceTarget(t));
               result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), targets.length > 1);
             } else if (resolutionResult.meaning.candidates.length > 0) {
-              const targets = resolutionResult.meaning.candidates.map((t) => new SimpleWithLocalization(new ConstructorReferenceTarget(t.value), t.localization));
+              const targets = resolutionResult.meaning.candidates.map((t) => new ConstructorReferenceTarget(t));
               result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), true);
             }
           }
@@ -6284,10 +6042,10 @@ var NodeSemanticInfoService = class {
         }
         case "function":
           if (resolvedQualifier.suitableFunctions.length > 0) {
-            const targets = resolvedQualifier.suitableFunctions.map((t) => new SimpleWithLocalization(new EntityReferenceTarget(t.value, 0 /* Get */), t.localization));
+            const targets = resolvedQualifier.suitableFunctions.map((t) => new EntityReferenceTarget(t, 0 /* Get */));
             result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), targets.length > 1);
           } else if (resolvedQualifier.candidates.length > 0) {
-            const targets = resolvedQualifier.candidates.map((t) => new SimpleWithLocalization(new EntityReferenceTarget(t.value, 0 /* Get */), t.localization));
+            const targets = resolvedQualifier.candidates.map((t) => new EntityReferenceTarget(t, 0 /* Get */));
             result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), true);
           }
           break;
@@ -6298,10 +6056,7 @@ var NodeSemanticInfoService = class {
           }
           const qualifier2 = resolutionResult.resolvedQualifiers[currentIndex];
           if (qualifier2.kind === "package-name-segment" && qualifier2.packageTreeNode.package !== void 0) {
-            const target = new SimpleWithLocalization(
-              new PackageReferenceTarget(qualifier2.packageTreeNode.package.value),
-              new Localization.Original(qualifier2.packageTreeNode.package.value.getLocale())
-            );
+            const target = new PackageReferenceTarget(qualifier2.packageTreeNode.package);
             result = new ReferenceNodeSemanticInfo([target], false);
           } else {
             result = void 0;
@@ -6309,10 +6064,7 @@ var NodeSemanticInfoService = class {
           break;
         }
         case "package-alias": {
-          const target = new SimpleWithLocalization(
-            new EntityReferenceTarget(resolvedQualifier.packageAlias, 0 /* Get */),
-            new Localization.Original(resolvedQualifier.packageAlias.getContainingPackage().getLocale())
-          );
+          const target = new EntityReferenceTarget(resolvedQualifier.packageAlias, 0 /* Get */);
           result = new ReferenceNodeSemanticInfo([target], false);
           break;
         }
@@ -6321,13 +6073,13 @@ var NodeSemanticInfoService = class {
       }
     } else if (qualifierIndex === resolutionResult.resolvedQualifiers.length && resolutionResult.ambiguousDeclarations !== void 0) {
       const targets = resolutionResult.ambiguousDeclarations.map((d) => {
-        switch (d.value.kind) {
+        switch (d.kind) {
           case "entity":
-            return new SimpleWithLocalization(new EntityReferenceTarget(d.value.entity, 0 /* Get */), d.localization);
+            return new EntityReferenceTarget(d.entity, 0 /* Get */);
           case "node":
-            return new SimpleWithLocalization(new PackageNameTreeNodeReferenceTarget(d.value.node), d.localization);
+            return new PackageNameTreeNodeReferenceTarget(d.node);
           default:
-            Debug.never(d.value);
+            Debug.never(d);
         }
       });
       if (isNonEmptyArray(targets)) {
@@ -6345,7 +6097,7 @@ var NodeSemanticInfoService = class {
     switch (meaning.kind) {
       case "type-access":
         if (meaning.suitableTypes.length === 0 && meaning.candidates.length > 0) {
-          const targets = meaning.candidates.map((c) => new SimpleWithLocalization(new EntityReferenceTarget(c.value, 0 /* Get */), c.localization));
+          const targets = meaning.candidates.map((c) => new EntityReferenceTarget(c, 0 /* Get */));
           result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), true);
         } else {
           result = this.ofMaybeConstructorCallExpression(analyzer, meaning.suitableTypes, node, options6);
@@ -6372,28 +6124,19 @@ var NodeSemanticInfoService = class {
           narrowedType = analyzer.type.ofExpression(node);
         }
         const variable = meaning.variable;
-        if (variable.value.kind === "entity") {
-          const target = new SimpleWithLocalization(
-            new EntityReferenceTarget(variable.value.value, meaning.accessKind, narrowedType),
-            variable.localization
-          );
+        if (variable.kind === "entity") {
+          const target = new EntityReferenceTarget(variable.value, meaning.accessKind, narrowedType);
           result = new ReferenceNodeSemanticInfo([target], false);
-        } else if (variable.value.kind === "type-member") {
-          const target = new SimpleWithLocalization(
-            new FieldReferenceTarget(variable.value.value, meaning.accessKind, narrowedType),
-            variable.localization
-          );
+        } else if (variable.kind === "type-member") {
+          const target = new FieldReferenceTarget(variable.value, meaning.accessKind, narrowedType);
           result = new ReferenceNodeSemanticInfo([target], false);
         } else {
-          Debug.never(variable.value);
+          Debug.never(variable);
         }
         break;
       }
       case "package-alias-access": {
-        const target = new SimpleWithLocalization(
-          new EntityReferenceTarget(meaning.packageAlias, 0 /* Get */),
-          new Localization.Original(getPackageContainingEntity(meaning.packageAlias).getLocale())
-        );
+        const target = new EntityReferenceTarget(meaning.packageAlias, 0 /* Get */);
         result = new ReferenceNodeSemanticInfo([target], false);
         break;
       }
@@ -6403,27 +6146,20 @@ var NodeSemanticInfoService = class {
       }
       case "mixed-ambiguous-access": {
         const targets = meaning.declarations.map((d) => {
-          let target;
-          switch (d.value.kind) {
+          switch (d.kind) {
             case "function":
-              target = new EntityReferenceTarget(d.value.value.getEntity(), 0 /* Get */);
-              break;
+              return new EntityReferenceTarget(d.value.getEntity(), 0 /* Get */);
             case "variable":
-              target = new EntityReferenceTarget(d.value.value.getEntity(), 0 /* Get */);
-              break;
+              return new EntityReferenceTarget(d.value.getEntity(), 0 /* Get */);
             case "type":
-              target = new EntityReferenceTarget(d.value.value, 0 /* Get */);
-              break;
+              return new EntityReferenceTarget(d.value, 0 /* Get */);
             case "package-alias":
-              target = new EntityReferenceTarget(d.value.value, 0 /* Get */);
-              break;
+              return new EntityReferenceTarget(d.value, 0 /* Get */);
             case "package-name-segment":
-              target = new PackageNameTreeNodeReferenceTarget(d.value.value);
-              break;
+              return new PackageNameTreeNodeReferenceTarget(d.value);
             default:
-              Debug.never(d.value);
+              Debug.never(d);
           }
-          return new SimpleWithLocalization(target, d.localization);
         });
         if (isNonEmptyArray(targets)) {
           result = new ReferenceNodeSemanticInfo(targets, true);
@@ -6440,11 +6176,11 @@ var NodeSemanticInfoService = class {
     }
     return result;
     function createAccessedFunctionsReference(functions, isAmbiguous) {
-      const targets = functions.map((o) => new SimpleWithLocalization(new AccessedFunctionReferenceTarget(o.value), o.localization));
+      const targets = functions.map((o) => new AccessedFunctionReferenceTarget(o));
       return new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), isAmbiguous);
     }
     function createOperatorsReference(operators, isAmbiguous) {
-      const targets = operators.map((o) => new SimpleWithLocalization(new OperatorReferenceTarget(o.value), o.localization));
+      const targets = operators.map((o) => new OperatorReferenceTarget(o));
       return new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), isAmbiguous);
     }
   }
@@ -6476,7 +6212,7 @@ var NodeSemanticInfoService = class {
     }
     return void 0;
     function createIndexersReference(indexers, accessKind, isAmbiguous) {
-      const targets = indexers.map((i) => new SimpleWithLocalization(new IndexerReferenceTarget(i.value, accessKind), i.localization));
+      const targets = indexers.map((i) => new IndexerReferenceTarget(i, accessKind));
       return new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), isAmbiguous);
     }
   }
@@ -6485,10 +6221,7 @@ var NodeSemanticInfoService = class {
     if (operatorKind !== void 0) {
       const operator = analyzer.resolveCompoundAssignmentStatementOperator(node, operatorKind);
       if (operator.kind === "ok") {
-        const target = new SimpleWithLocalization(
-          new OperatorReferenceTarget(operator.value.value),
-          operator.value.localization
-        );
+        const target = new OperatorReferenceTarget(operator.value);
         let result = new ReferenceNodeSemanticInfo([target], false);
         if (options6.includeBetterReferenceTargets) {
           result = this.getBetterReferenceTargetsOrPreserve(result);
@@ -6503,10 +6236,7 @@ var NodeSemanticInfoService = class {
     if (classificationResult.kind === "user-definable") {
       const operator = analyzer.resolveBinaryExpressionUserDefinableOperator(node, classificationResult.operatorKind);
       if (operator.kind === "ok") {
-        const target = new SimpleWithLocalization(
-          new OperatorReferenceTarget(operator.value.value),
-          operator.value.localization
-        );
+        const target = new OperatorReferenceTarget(operator.value);
         let result = new ReferenceNodeSemanticInfo([target], false);
         if (options6.includeBetterReferenceTargets) {
           result = this.getBetterReferenceTargetsOrPreserve(result);
@@ -6519,10 +6249,7 @@ var NodeSemanticInfoService = class {
   static ofPrefixUnaryExpressionOperator(analyzer, node, options6) {
     const operator = analyzer.resolvePrefixUnaryExpressionUserDefinableOperator(node);
     if (operator.kind === "ok") {
-      const target = new SimpleWithLocalization(
-        new OperatorReferenceTarget(operator.value.value),
-        operator.value.localization
-      );
+      const target = new OperatorReferenceTarget(operator.value);
       let result = new ReferenceNodeSemanticInfo([target], false);
       if (options6.includeBetterReferenceTargets) {
         result = this.getBetterReferenceTargetsOrPreserve(result);
@@ -6538,10 +6265,7 @@ var NodeSemanticInfoService = class {
   static ofDereferenceExpressionOperator(analyzer, node, options6) {
     const meaning = analyzer.getDereferenceExpressionMeaning(node);
     if (meaning.kind === "resolved") {
-      const target = new SimpleWithLocalization(
-        new DereferenceOperatorReferenceTarget(meaning.operator.value, meaning.accessKind),
-        meaning.operator.localization
-      );
+      const target = new DereferenceOperatorReferenceTarget(meaning.operator, meaning.accessKind);
       let result = new ReferenceNodeSemanticInfo([target], false);
       if (options6.includeBetterReferenceTargets) {
         result = this.getBetterReferenceTargetsOrPreserve(result);
@@ -6555,10 +6279,10 @@ var NodeSemanticInfoService = class {
     let result;
     if (meaning.kind === "constructor-call") {
       if (meaning.suitableConstructors.length > 0) {
-        const targets = meaning.suitableConstructors.map((c) => new SimpleWithLocalization(new ConstructorReferenceTarget(c.value), c.localization));
+        const targets = meaning.suitableConstructors.map((c) => new ConstructorReferenceTarget(c));
         result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), meaning.suitableConstructors.length > 1);
       } else if (meaning.candidates.length > 0) {
-        const targets = meaning.candidates.map((c) => new SimpleWithLocalization(new ConstructorReferenceTarget(c.value), c.localization));
+        const targets = meaning.candidates.map((c) => new ConstructorReferenceTarget(c));
         result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), true);
       }
     }
@@ -6573,21 +6297,17 @@ var NodeSemanticInfoService = class {
     switch (meaning.kind) {
       case "own-constructor-access": {
         if (meaning.suitableConstructors.length > 0) {
-          const targets = meaning.suitableConstructors.map((c) => new SimpleWithLocalization(new ConstructorReferenceTarget(c.value), c.localization));
+          const targets = meaning.suitableConstructors.map((c) => new ConstructorReferenceTarget(c));
           result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), meaning.suitableConstructors.length > 1);
         } else if (meaning.candidates.length > 0) {
-          const targets = meaning.candidates.map((c) => new SimpleWithLocalization(new ConstructorReferenceTarget(c.value), c.localization));
+          const targets = meaning.candidates.map((c) => new ConstructorReferenceTarget(c));
           result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), true);
         }
         break;
       }
       case "object-access": {
-        const locale = TreeQuery.fromNode(node).packageEntity(analyzer).getLocale();
         const type = analyzer.type.ofExpression(node);
-        const target = new SimpleWithLocalization(
-          new TypeContextReferenceTarget(type, "object"),
-          new Localization.Original(locale)
-        );
+        const target = new TypeContextReferenceTarget(type, "object");
         result = new ReferenceNodeSemanticInfo([target], false);
         break;
       }
@@ -6607,38 +6327,26 @@ var NodeSemanticInfoService = class {
     switch (meaning.kind) {
       case "base-constructor-access": {
         if (meaning.suitableConstructors.length > 0) {
-          const targets = meaning.suitableConstructors.map((c) => new SimpleWithLocalization(new ConstructorReferenceTarget(c.value), c.localization));
+          const targets = meaning.suitableConstructors.map((c) => new ConstructorReferenceTarget(c));
           result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), meaning.suitableConstructors.length > 1);
         } else if (meaning.candidates.length > 0) {
-          const targets = meaning.candidates.map((c) => new SimpleWithLocalization(new ConstructorReferenceTarget(c.value), c.localization));
+          const targets = meaning.candidates.map((c) => new ConstructorReferenceTarget(c));
           result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), true);
         }
         break;
       }
       case "base-object-access": {
-        const locale = TreeQuery.fromNode(node).packageEntity(analyzer).getLocale();
-        const target = new SimpleWithLocalization(
-          new TypeContextReferenceTarget(meaning.type, "base"),
-          new Localization.Original(locale)
-        );
+        const target = new TypeContextReferenceTarget(meaning.type, "base");
         result = new ReferenceNodeSemanticInfo([target], false);
         break;
       }
       case "overridden-method-access": {
-        const locale = TreeQuery.fromNode(node).packageEntity(analyzer).getLocale();
-        const target = new SimpleWithLocalization(
-          new AccessedFunctionReferenceTarget(new AccessedFunction_typeMember(meaning.method)),
-          new Localization.Original(locale)
-        );
+        const target = new AccessedFunctionReferenceTarget(new AccessedFunction_typeMember(meaning.method));
         result = new ReferenceNodeSemanticInfo([target], false);
         break;
       }
       case "overridden-operator-access": {
-        const locale = TreeQuery.fromNode(node).packageEntity(analyzer).getLocale();
-        const target = new SimpleWithLocalization(
-          new OperatorReferenceTarget(meaning.operator),
-          new Localization.Original(locale)
-        );
+        const target = new OperatorReferenceTarget(meaning.operator);
         result = new ReferenceNodeSemanticInfo([target], false);
         break;
       }
@@ -6666,29 +6374,15 @@ var NodeSemanticInfoService = class {
     if (packageTreeNode.package === void 0) {
       return void 0;
     }
-    return new ReferenceNodeSemanticInfo(
-      [
-        new SimpleWithLocalization(
-          new PackageReferenceTarget(packageTreeNode.package.value),
-          new Localization.Original(packageTreeNode.package.value.getLocale())
-        )
-      ],
-      false
-    );
+    return new ReferenceNodeSemanticInfo([new PackageReferenceTarget(packageTreeNode.package)], false);
   }
   static ofMaybeConstructorCallExpression(analyzer, types, typeAccessExpression, options6) {
     if (types.length === 0) {
       return void 0;
     }
-    const typeEntities = Query.from(types).mapAndFilter((t) => {
-      const entity = t.value.getEntity();
-      if (entity !== void 0) {
-        return new SimpleWithLocalization(entity, t.localization);
-      }
-      return void 0;
-    }).toArray();
+    const typeEntities = Query.from(types).mapAndFilter((t) => t.getEntity()).toArray();
     if (options6.preferredTargetOfExplicitConstructorCall === "type-declaration" && typeEntities.length > 0) {
-      const targets = typeEntities.map((t) => new SimpleWithLocalization(new EntityReferenceTarget(t.value, 0 /* Get */), t.localization));
+      const targets = typeEntities.map((t) => new EntityReferenceTarget(t, 0 /* Get */));
       return new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), targets.length > 1);
     }
     const parent = getParentSkippingParenthesizedExpressions(typeAccessExpression);
@@ -6705,16 +6399,16 @@ var NodeSemanticInfoService = class {
       const meaning = analyzer.getCallExpressionMeaning(parentCallExpression);
       if (meaning.kind === "constructor-call") {
         if (meaning.suitableConstructors.length > 0) {
-          const targets = meaning.suitableConstructors.map((c) => new SimpleWithLocalization(new ConstructorReferenceTarget(c.value), c.localization));
+          const targets = meaning.suitableConstructors.map((c) => new ConstructorReferenceTarget(c));
           return new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), meaning.suitableConstructors.length > 1);
         } else if (meaning.candidates.length > 0) {
-          const targets = meaning.candidates.map((c) => new SimpleWithLocalization(new ConstructorReferenceTarget(c.value), c.localization));
+          const targets = meaning.candidates.map((c) => new ConstructorReferenceTarget(c));
           return new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), true);
         }
       }
     }
     if (typeEntities.length > 0) {
-      const targets = typeEntities.map((t) => new SimpleWithLocalization(new EntityReferenceTarget(t.value, 0 /* Get */), t.localization));
+      const targets = typeEntities.map((t) => new EntityReferenceTarget(t, 0 /* Get */));
       return new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), targets.length > 1);
     }
     return void 0;
@@ -6733,33 +6427,27 @@ var NodeSemanticInfoService = class {
     let betterTarget;
     do {
       betterTarget = void 0;
-      if (currentTarget.value.kind === "entity" && currentTarget.value.entity.kind === 0 /* Variable */) {
+      if (currentTarget.kind === "entity" && currentTarget.entity.kind === 0 /* Variable */) {
         {
-          if (currentTarget.value.entity.subkind === "parameter") {
-            const specialVariableInfo = currentTarget.value.entity.isSpecial();
+          if (currentTarget.entity.subkind === "parameter") {
+            const specialVariableInfo = currentTarget.entity.isSpecial();
             if (specialVariableInfo?.kind === "implicit-function-block-parameter") {
-              betterTarget = new SimpleWithLocalization(
-                new TypeValueParameterReferenceTarget(
-                  specialVariableInfo.targetTypeParameter,
-                  currentTarget.value.accessKind
-                ),
-                currentTarget.localization
+              betterTarget = new TypeValueParameterReferenceTarget(
+                specialVariableInfo.targetTypeParameter,
+                currentTarget.accessKind
               );
             }
           }
         }
-      } else if (currentTarget.value.kind === "type-constructor") {
-        const entity = currentTarget.value.constructor_.getEntity();
+      } else if (currentTarget.kind === "type-constructor") {
+        const entity = currentTarget.constructor_.getEntity();
         if (entity.getDefinition().kind === 1 /* Intrinsic */) {
           const container = entity.getContainer();
           if (container.kind === "type" && container.typeEntity.getDefinition().kind === 0 /* Source */) {
-            betterTarget = new SimpleWithLocalization(
-              new EntityReferenceTarget(container.typeEntity, 0 /* Get */),
-              currentTarget.localization
-            );
+            betterTarget = new EntityReferenceTarget(container.typeEntity, 0 /* Get */);
           }
         }
-      } else if (currentTarget.value.kind === "entity" && currentTarget.value.entity.kind === 1 /* Function */) {
+      } else if (currentTarget.kind === "entity" && currentTarget.entity.kind === 1 /* Function */) {
       }
       if (betterTarget !== void 0) {
         result = betterTarget;
@@ -6877,29 +6565,12 @@ var IndexerReferenceTarget = class {
     this.kind = "type-indexer";
   }
 };
-var NameTranslationNodeSemanticInfo = class {
-  constructor(targets, isAmbiguous, translation) {
-    this.targets = targets;
-    this.isAmbiguous = isAmbiguous;
-    this.translation = translation;
-    this.kind = "name-translation";
-  }
-  get firstTarget() {
-    return this.targets[0];
-  }
-};
 var DefaultSwitchMatchNodeSemanticInfo = class {
   constructor(type) {
     this.type = type;
     this.kind = "default-switch-match";
   }
 };
-var SimpleWithLocalization = class {
-  constructor(value, localization) {
-    this.value = value;
-    this.localization = localization;
-  }
-};
 
 // source/services/Utils.ts
 function getEntitySourceLocations(analyzer, entity) {
@@ -7060,12 +6731,6 @@ var DefinitionService = class {
           result = this.getDefinitionOfReference(analyzer, semanticInfo, tokenOrKeyword, sourceFile);
           break;
         }
-        case "name-translation":
-          result = new DefinitionsAndReferenceInfo(
-            [new SourceLocation(sourceFile, tokenOrKeyword.value.rangeWithoutTrivia)],
-            tokenOrKeyword.value.rangeWithoutTrivia
-          );
-          break;
         case "default-switch-match":
           break;
         default:
@@ -7073,18 +6738,11 @@ var DefinitionService = class {
       }
       if ((result === void 0 || result.definitionLocations.length === 0) && this._sourceGenerationService !== void 0 && semanticInfo.kind === "reference") {
         const sourceLocations = (yield Promise.all(Query.from(semanticInfo.betterTargets ?? semanticInfo.targets).mapAndFilter((t) => {
-          const referencedEntity = this.getReferenceTargetEntity(t.value);
+          const referencedEntity = this.getReferenceTargetEntity(t);
           if (referencedEntity !== void 0 && this._sourceGenerationService.entityDefinitionRequiresSourceGeneration(referencedEntity)) {
-            const localizationContext = this.createLocalizationContextForSourceGeneration(
-              analyzer,
-              tokenOrKeyword.value,
-              referencedEntity,
-              t.localization
-            );
             return this._sourceGenerationService.getDefinitionInGeneratedCode(
               analyzer,
               referencedEntity,
-              localizationContext,
               cancellationToken
             );
           }
@@ -7099,7 +6757,7 @@ var DefinitionService = class {
   }
   getDefinitionOfReference(analyzer, reference, tokenOrKeyword, sourceFile) {
     const targets = reference.betterTargets ?? reference.targets;
-    const sourceLocations = Query.from(targets).mapAndFilter((t) => this.getReferenceTargetSourceLocation(analyzer, t.value, tokenOrKeyword, sourceFile)).flatMap((l) => l).toArray();
+    const sourceLocations = Query.from(targets).mapAndFilter((t) => this.getReferenceTargetSourceLocation(analyzer, t, tokenOrKeyword, sourceFile)).flatMap((l) => l).toArray();
     return new DefinitionsAndReferenceInfo(sourceLocations, tokenOrKeyword.value.rangeWithoutTrivia);
   }
   getReferenceTargetSourceLocation(analyzer, target, tokenOrKeyword, sourceFile) {
@@ -7164,7 +6822,7 @@ var DefinitionService = class {
       case "package":
         return target.package_;
       case "package-name-tree-node":
-        return target.node.package?.value;
+        return target.node.package;
       case "type-context":
         return target.type.getEntity();
       case "type-indexer":
@@ -7173,15 +6831,6 @@ var DefinitionService = class {
         Debug.never(target);
     }
   }
-  createLocalizationContextForSourceGeneration(analyzer, referenceNode, referencedEntity, localization) {
-    const referenceContext = analyzer.semanticContext.containing(referenceNode).getLocalizationContext();
-    let translationPackages = Array.from(referenceContext.translationPackages);
-    if (localization.kind === "original") {
-      const containingPackage = getPackageContainingEntity(referencedEntity);
-      translationPackages = translationPackages.filter((p) => p.getTranslatedPackage() !== containingPackage);
-    }
-    return new LocalizationContext(translationPackages, referenceContext.originalLocale);
-  }
   getSourceLocationsOfVariableEntity(analyzer, entity) {
     let result = getEntitySourceLocations(analyzer, entity);
     if (result === void 0 && entity.kind === 0 /* Variable */) {
@@ -7280,17 +6929,17 @@ var ReferencesService = class {
   }
   getReferencesInFiles(analyzer, sourceFile, offset, sourceFiles, options6, cancellationToken) {
     return __async(this, null, function* () {
-      const definitionAndReferenceInfo = this.getDefinitionAndReferenceInfoAtOffset(analyzer, sourceFile, offset, options6);
-      if (definitionAndReferenceInfo === void 0) {
+      const definitions = this.getReferencedDefinitionInfosAtOffset(analyzer, sourceFile, offset, options6);
+      if (definitions.length === 0) {
         return [];
       }
-      const { definition, isAtNameTranslation } = definitionAndReferenceInfo;
-      const onlyWithSameTranslation = options6.onlyNamed || isAtNameTranslation;
       const allowAmbiguous = options6.allowAmbiguous;
+      const isForRename = options6.isForRename ?? false;
       const result = [];
-      const restrictions = this.getReferenceRestrictions(definition, options6);
+      const firstDefinition = definitions[0];
+      const restrictions = this.getReferenceRestrictions(firstDefinition, options6);
       let semanticInfoOptions;
-      if (definition.value.kind === 7 /* Constructor */) {
+      if (firstDefinition.value.kind === 7 /* Constructor */) {
         semanticInfoOptions = {
           preferredTargetOfExplicitConstructorCall: "constructor-declaration",
           includeBetterReferenceTargets: true
@@ -7309,11 +6958,11 @@ var ReferencesService = class {
           (node) => {
             if (isIdentifier(node) && restrictions.canBeIdentifier && node.parent.kind !== 3 /* Keyword */) {
               const semanticInfo = NodeSemanticInfoService.ofNonKeywordIdentifier(analyzer, node, semanticInfoOptions);
-              const referenceKind = this.ifReferenceToDefinitionThenKind(
-                definition,
+              const referenceKind = this.ifReferenceToSomeOfDefinitionsThenKind(
+                definitions,
                 semanticInfo,
-                onlyWithSameTranslation,
-                allowAmbiguous
+                allowAmbiguous,
+                isForRename
               );
               if (referenceKind !== void 0) {
                 result.push(new Reference(sourceFile2, node.rangeWithoutTrivia, referenceKind));
@@ -7322,11 +6971,11 @@ var ReferencesService = class {
             if (!options6.onlyNamed) {
               if (node.kind === 69 /* AutotypeCallExpression */ && restrictions.canBeAutotypeCall) {
                 const semanticInfo = NodeSemanticInfoService.ofAutotypeCallExpression(analyzer, node, semanticInfoOptions);
-                const referenceKind = this.ifReferenceToDefinitionThenKind(
-                  definition,
+                const referenceKind = this.ifReferenceToSomeOfDefinitionsThenKind(
+                  definitions,
                   semanticInfo,
-                  onlyWithSameTranslation,
-                  allowAmbiguous
+                  allowAmbiguous,
+                  isForRename
                 );
                 if (referenceKind !== void 0) {
                   result.push(new Reference(sourceFile2, node.autotypeKeyword.rangeWithoutTrivia, referenceKind));
@@ -7338,11 +6987,11 @@ var ReferencesService = class {
                   node,
                   semanticInfoOptions
                 );
-                const referenceKind = this.ifReferenceToDefinitionThenKind(
-                  definition,
+                const referenceKind = this.ifReferenceToSomeOfDefinitionsThenKind(
+                  definitions,
                   semanticInfo,
-                  onlyWithSameTranslation,
-                  allowAmbiguous
+                  allowAmbiguous,
+                  isForRename
                 );
                 if (referenceKind !== void 0) {
                   result.push(new Reference(sourceFile2, node.operator.rangeWithoutTrivia, referenceKind));
@@ -7354,11 +7003,11 @@ var ReferencesService = class {
                   node,
                   semanticInfoOptions
                 );
-                const referenceKind = this.ifReferenceToDefinitionThenKind(
-                  definition,
+                const referenceKind = this.ifReferenceToSomeOfDefinitionsThenKind(
+                  definitions,
                   semanticInfo,
-                  onlyWithSameTranslation,
-                  allowAmbiguous
+                  allowAmbiguous,
+                  isForRename
                 );
                 if (referenceKind !== void 0) {
                   result.push(new Reference(sourceFile2, node.operator.rangeWithoutTrivia, referenceKind));
@@ -7366,11 +7015,11 @@ var ReferencesService = class {
               }
               if ((node.kind === 48 /* DereferencedVariableGetterDeclaration */ || node.kind === 49 /* DereferencedVariableSetterDeclaration */) && restrictions.canBeDereferenceOperator) {
                 const semanticInfo = NodeSemanticInfoService.ofDereferenceOperatorDeclaration(analyzer, node);
-                const referenceKind = this.ifReferenceToDefinitionThenKind(
-                  definition,
+                const referenceKind = this.ifReferenceToSomeOfDefinitionsThenKind(
+                  definitions,
                   semanticInfo,
-                  onlyWithSameTranslation,
-                  allowAmbiguous
+                  allowAmbiguous,
+                  isForRename
                 );
                 if (referenceKind !== void 0) {
                   result.push(new Reference(sourceFile2, node.caretToken.rangeWithoutTrivia, referenceKind));
@@ -7382,11 +7031,11 @@ var ReferencesService = class {
                   node,
                   semanticInfoOptions
                 );
-                const referenceKind = this.ifReferenceToDefinitionThenKind(
-                  definition,
+                const referenceKind = this.ifReferenceToSomeOfDefinitionsThenKind(
+                  definitions,
                   semanticInfo,
-                  onlyWithSameTranslation,
-                  allowAmbiguous
+                  allowAmbiguous,
+                  isForRename
                 );
                 if (referenceKind !== void 0) {
                   result.push(new Reference(sourceFile2, node.caretToken.rangeWithoutTrivia, referenceKind));
@@ -7398,11 +7047,11 @@ var ReferencesService = class {
                   node,
                   semanticInfoOptions
                 );
-                const referenceKind = this.ifReferenceToDefinitionThenKind(
-                  definition,
+                const referenceKind = this.ifReferenceToSomeOfDefinitionsThenKind(
+                  definitions,
                   semanticInfo,
-                  onlyWithSameTranslation,
-                  allowAmbiguous
+                  allowAmbiguous,
+                  isForRename
                 );
                 if (referenceKind !== void 0) {
                   result.push(new Reference(sourceFile2, node.operator.rangeWithoutTrivia, referenceKind));
@@ -7410,11 +7059,11 @@ var ReferencesService = class {
               }
               if (node.kind === 43 /* ConstructorDeclaration */ && restrictions.canBeConstructorDeclaration) {
                 const semanticInfo = NodeSemanticInfoService.ofConstructorDeclaration(analyzer, node);
-                const referenceKind = this.ifReferenceToDefinitionThenKind(
-                  definition,
+                const referenceKind = this.ifReferenceToSomeOfDefinitionsThenKind(
+                  definitions,
                   semanticInfo,
-                  onlyWithSameTranslation,
-                  allowAmbiguous
+                  allowAmbiguous,
+                  isForRename
                 );
                 if (referenceKind !== void 0) {
                   result.push(new Reference(sourceFile2, node.creationKeyword.rangeWithoutTrivia, referenceKind));
@@ -7422,11 +7071,11 @@ var ReferencesService = class {
               }
               if (node.kind === 84 /* ObjectExpression */ && restrictions.canBeObjectExpression) {
                 const semanticInfo = NodeSemanticInfoService.ofObjectExpression(analyzer, node, semanticInfoOptions);
-                const referenceKind = this.ifReferenceToDefinitionThenKind(
-                  definition,
+                const referenceKind = this.ifReferenceToSomeOfDefinitionsThenKind(
+                  definitions,
                   semanticInfo,
-                  onlyWithSameTranslation,
-                  allowAmbiguous
+                  allowAmbiguous,
+                  isForRename
                 );
                 if (referenceKind !== void 0) {
                   result.push(new Reference(sourceFile2, node.keyword.rangeWithoutTrivia, referenceKind));
@@ -7434,11 +7083,11 @@ var ReferencesService = class {
               }
               if (node.kind === 85 /* BaseExpression */ && restrictions.canBeBaseExpression) {
                 const semanticInfo = NodeSemanticInfoService.ofBaseExpression(analyzer, node, semanticInfoOptions);
-                const referenceKind = this.ifReferenceToDefinitionThenKind(
-                  definition,
+                const referenceKind = this.ifReferenceToSomeOfDefinitionsThenKind(
+                  definitions,
                   semanticInfo,
-                  onlyWithSameTranslation,
-                  allowAmbiguous
+                  allowAmbiguous,
+                  isForRename
                 );
                 if (referenceKind !== void 0) {
                   result.push(new Reference(sourceFile2, node.keyword.rangeWithoutTrivia, referenceKind));
@@ -7446,11 +7095,11 @@ var ReferencesService = class {
               }
               if ((node.kind === 45 /* IndexedElementGetterDeclaration */ || node.kind === 46 /* IndexedElementSetterDeclaration */) && restrictions.canBeIndexer) {
                 const semanticInfo = NodeSemanticInfoService.ofIndexedElementAccessorDeclaration(analyzer, node);
-                const referenceKind = this.ifReferenceToDefinitionThenKind(
-                  definition,
+                const referenceKind = this.ifReferenceToSomeOfDefinitionsThenKind(
+                  definitions,
                   semanticInfo,
-                  onlyWithSameTranslation,
-                  allowAmbiguous
+                  allowAmbiguous,
+                  isForRename
                 );
                 if (referenceKind !== void 0) {
                   result.push(new Reference(sourceFile2, node.parameterClause.rangeWithoutTrivia, referenceKind));
@@ -7462,11 +7111,11 @@ var ReferencesService = class {
                   node,
                   semanticInfoOptions
                 );
-                const referenceKind = this.ifReferenceToDefinitionThenKind(
-                  definition,
+                const referenceKind = this.ifReferenceToSomeOfDefinitionsThenKind(
+                  definitions,
                   semanticInfo,
-                  onlyWithSameTranslation,
-                  allowAmbiguous
+                  allowAmbiguous,
+                  isForRename
                 );
                 if (referenceKind !== void 0) {
                   const range = new Range(
@@ -7483,7 +7132,7 @@ var ReferencesService = class {
       return result;
     });
   }
-  getDefinitionAndReferenceInfoAtOffset(analyzer, sourceFile, offset, options6) {
+  getReferencedDefinitionInfosAtOffset(analyzer, sourceFile, offset, options6) {
     const tokenOrKeyword = getTokenOrKeywordsTouchingOffset(sourceFile.getSyntaxNode(), offset).getSingleWithHighestPriority((t) => {
       if (t.isToken(10 /* Identifier */) || t.isKeyword()) {
         return 2;
@@ -7494,7 +7143,7 @@ var ReferencesService = class {
       }
     });
     if (tokenOrKeyword === void 0) {
-      return void 0;
+      return [];
     }
     let semanticInfoOptions;
     if (options6.onlyNamed) {
@@ -7510,33 +7159,18 @@ var ReferencesService = class {
     }
     const semanticInfo = NodeSemanticInfoService.ofTokenOrKeyword(analyzer, tokenOrKeyword, semanticInfoOptions);
     if (semanticInfo === void 0) {
-      return void 0;
-    }
-    const definition = this.getDefinitionFromNodeSemanticInfo(semanticInfo);
-    if (definition !== void 0) {
-      const isAtNameTranslation = semanticInfo.kind === "name-translation";
-      return { definition, isAtNameTranslation };
+      return [];
     }
-    return void 0;
+    return this.getDefinitionsFromNodeSemanticInfo(semanticInfo);
   }
-  getDefinitionFromNodeSemanticInfo(info) {
+  getDefinitionsFromNodeSemanticInfo(info) {
     switch (info.kind) {
       case "definition":
-        return new DefinitionInfo(
-          info.entity,
-          new Localization.Original(getPackageContainingEntity(info.entity).getLocale()),
-          2 /* Declaration */
-        );
+        return [new DefinitionInfo(info.entity, 2 /* Declaration */)];
       case "reference":
         return getDefinitionOfReference(info);
-      case "name-translation":
-        return new DefinitionInfo(
-          info.firstTarget,
-          new Localization.Translated(info.translation),
-          0 /* Read */
-        );
       case "default-switch-match":
-        return void 0;
+        return [];
       default:
         Debug.never(info);
     }
@@ -7553,63 +7187,45 @@ var ReferencesService = class {
       }
     }
     function getDefinitionOfReference(reference) {
-      const target = reference.firstBetterTargetWithFallback;
-      switch (target.value.kind) {
-        case "entity":
-          return new DefinitionInfo(
-            target.value.entity,
-            target.localization,
-            accessKindToReferenceKind(target.value.accessKind)
-          );
-        case "field":
-          return new DefinitionInfo(
-            target.value.field.getEntity(),
-            target.localization,
-            accessKindToReferenceKind(target.value.accessKind)
-          );
-        case "type-value-parameter":
-          return new DefinitionInfo(
-            target.value.parameter.getEntity(),
-            target.localization,
-            accessKindToReferenceKind(target.value.accessKind)
-          );
-        case "type-constructor":
-          return new DefinitionInfo(target.value.constructor_.getEntity(), target.localization, 0 /* Read */);
-        case "operator":
-          return new DefinitionInfo(target.value.operator.getEntity(), target.localization, 0 /* Read */);
-        case "type-dereference-operator":
-          return new DefinitionInfo(
-            target.value.operator.getEntity(),
-            target.localization,
-            accessKindToReferenceKind(target.value.accessKind)
-          );
-        case "accessed-function":
-          return new DefinitionInfo(target.value.func.getEntity(), target.localization, 0 /* Read */);
-        case "match-result-value-parameter":
-          return new DefinitionInfo(target.value.parameter.entity, target.localization, 0 /* Read */);
-        case "package":
-          return new DefinitionInfo(target.value.package_, target.localization, 0 /* Read */);
-        case "type-context": {
-          const entity = target.value.type.getEntity();
-          if (entity !== void 0) {
-            return new DefinitionInfo(entity, target.localization, 0 /* Read */);
+      const targets = reference.betterTargets ?? reference.targets;
+      return targets.map((t) => {
+        switch (t.kind) {
+          case "entity":
+            return new DefinitionInfo(t.entity, accessKindToReferenceKind(t.accessKind));
+          case "field":
+            return new DefinitionInfo(t.field.getEntity(), accessKindToReferenceKind(t.accessKind));
+          case "type-value-parameter":
+            return new DefinitionInfo(t.parameter.getEntity(), accessKindToReferenceKind(t.accessKind));
+          case "type-constructor":
+            return new DefinitionInfo(t.constructor_.getEntity(), 0 /* Read */);
+          case "operator":
+            return new DefinitionInfo(t.operator.getEntity(), 0 /* Read */);
+          case "type-dereference-operator":
+            return new DefinitionInfo(t.operator.getEntity(), accessKindToReferenceKind(t.accessKind));
+          case "accessed-function":
+            return new DefinitionInfo(t.func.getEntity(), 0 /* Read */);
+          case "match-result-value-parameter":
+            return new DefinitionInfo(t.parameter.entity, 0 /* Read */);
+          case "package":
+            return new DefinitionInfo(t.package_, 0 /* Read */);
+          case "type-context": {
+            const entity = t.type.getEntity();
+            if (entity !== void 0) {
+              return new DefinitionInfo(entity, 0 /* Read */);
+            }
+            return void 0;
           }
-          return void 0;
+          case "type-indexer":
+            return new DefinitionInfo(t.indexer.getEntity(), accessKindToReferenceKind(t.accessKind));
+          case "package-name-tree-node":
+            if (t.node.package !== void 0) {
+              return new DefinitionInfo(t.node.package, 0 /* Read */);
+            }
+            return void 0;
+          default:
+            Debug.never(t);
         }
-        case "type-indexer":
-          return new DefinitionInfo(
-            target.value.indexer.getEntity(),
-            target.localization,
-            accessKindToReferenceKind(target.value.accessKind)
-          );
-        case "package-name-tree-node":
-          if (target.value.node.package !== void 0) {
-            return new DefinitionInfo(target.value.node.package.value, target.localization, 0 /* Read */);
-          }
-          return void 0;
-        default:
-          Debug.never(target.value);
-      }
+      }).filter((t) => t !== void 0);
     }
   }
   getReferenceRestrictions(definition, _options) {
@@ -7654,30 +7270,62 @@ var ReferencesService = class {
     }
     return result;
   }
-  ifReferenceToDefinitionThenKind(definition, potentialReferenceSemanticInfo, onlyReferencesWithSameAlias, allowAmbiguous) {
+  ifReferenceToSomeOfDefinitionsThenKind(definitions, potentialReferenceSemanticInfo, allowAmbiguous, isForRename) {
+    Debug.assert(definitions.length > 0);
     if (potentialReferenceSemanticInfo === void 0) {
       return void 0;
     }
     if (potentialReferenceSemanticInfo.kind === "reference" && potentialReferenceSemanticInfo.isAmbiguous && !allowAmbiguous) {
       return void 0;
     }
-    const potentialReferenceDefinition = this.getDefinitionFromNodeSemanticInfo(potentialReferenceSemanticInfo);
-    if (potentialReferenceDefinition === void 0) {
-      return void 0;
-    }
-    if (definition.value.kind !== potentialReferenceDefinition.value.kind) {
+    const potentialReferenceDefinitions = this.getDefinitionsFromNodeSemanticInfo(potentialReferenceSemanticInfo);
+    if (potentialReferenceDefinitions.length === 0) {
       return void 0;
     }
-    if (definition.value !== potentialReferenceDefinition.value) {
+    if (definitions.length === 1 && potentialReferenceDefinitions.length === 1) {
+      if (this.areEntitiesWithSameDefinition(
+        definitions[0].value,
+        potentialReferenceDefinitions[0].value,
+        isForRename
+      )) {
+        return potentialReferenceDefinitions[0].referenceKind;
+      } else {
+        return void 0;
+      }
+    } else if (definitions.length > 1 && potentialReferenceDefinitions.length === 1) {
+      if (definitions.some((d) => this.areEntitiesWithSameDefinition(d.value, potentialReferenceDefinitions[0].value, isForRename))) {
+        return potentialReferenceDefinitions[0].referenceKind;
+      } else {
+        return void 0;
+      }
+    } else if (definitions.length === 1 && potentialReferenceDefinitions.length > 1) {
+      if (potentialReferenceDefinitions.some((r) => this.areEntitiesWithSameDefinition(r.value, definitions[0].value, isForRename))) {
+        return potentialReferenceDefinitions[0].referenceKind;
+      } else {
+        return void 0;
+      }
+    } else if (definitions.length > 1 && potentialReferenceDefinitions.length > 1) {
+      if (definitions.length === potentialReferenceDefinitions.length && definitions.every((d) => potentialReferenceDefinitions.some((rd) => this.areEntitiesWithSameDefinition(rd.value, d.value, isForRename)))) {
+        return potentialReferenceDefinitions[0].referenceKind;
+      } else {
+        return void 0;
+      }
+    } else {
       return void 0;
     }
-    if (!onlyReferencesWithSameAlias) {
-      return potentialReferenceDefinition.referenceKind;
+  }
+  areEntitiesWithSameDefinition(entity1, entity2, isForRename) {
+    if (entity1 === entity2) {
+      return true;
     }
-    if (definition.localization.equals(potentialReferenceDefinition.localization)) {
-      return potentialReferenceDefinition.referenceKind;
+    if (isForRename) {
+      const entity1Localization = entity1.getLocalization();
+      const entity2Localization = entity2.getLocalization();
+      if (entity1Localization.kind === "translated" && entity2Localization.kind === "translated" && entity1Localization.translation.equals(entity2Localization.translation)) {
+        return true;
+      }
     }
-    return void 0;
+    return false;
   }
   isEntityWithRegularName(entity) {
     switch (entity.kind) {
@@ -7741,9 +7389,8 @@ var Reference = class {
   }
 };
 var DefinitionInfo = class {
-  constructor(value, localization, referenceKind) {
+  constructor(value, referenceKind) {
     this.value = value;
-    this.localization = localization;
     this.referenceKind = referenceKind;
   }
 };
@@ -7975,26 +7622,14 @@ var HoverService = class {
     }
     this._displayService = new DisplayService(
       analyzer,
-      analyzer.createLocalizationContext(sourceFile),
-      sourceFile.package.dialect ?? 0 /* ArtelAM */
+      sourceFile.package.locale,
+      sourceFile.package.dialect
     );
     switch (semanticInfo.kind) {
       case "definition":
-        return this.createHoverForEntity(
-          semanticInfo.entity,
-          void 0,
-          void 0,
-          tokenOrKeyword.value.rangeWithoutTrivia
-        );
+        return this.createHoverForEntity(semanticInfo.entity, void 0, tokenOrKeyword.value.rangeWithoutTrivia);
       case "reference":
         return this.createHoverAtReference(semanticInfo, tokenOrKeyword.value.rangeWithoutTrivia);
-      case "name-translation":
-        return this.createHoverForEntity(
-          semanticInfo.firstTarget,
-          new Localization.Translated(semanticInfo.translation),
-          void 0,
-          tokenOrKeyword.value.rangeWithoutTrivia
-        );
       case "default-switch-match":
         return new Hover(
           `*: ${this._displayService.displayType(semanticInfo.type)}`,
@@ -8004,111 +7639,87 @@ var HoverService = class {
         Debug.never(semanticInfo);
     }
   }
-  createHoverForEntity(entity, localization, narrowedType, range) {
+  createHoverForEntity(entity, narrowedType, range) {
     if (entity.kind === 0 /* Variable */) {
-      localization ??= Localization.Original.ofEntity(entity);
-      const declaration = new VariableDeclaration_entity(
-        entity,
-        localization,
-        narrowedType
-      );
+      const declaration = new VariableDeclaration_entity(entity, narrowedType);
       return new Hover(this._displayService.displayVariableDeclaration(declaration), range);
     } else {
-      return new Hover(this._displayService.displayEntity(entity, localization), range);
+      return new Hover(this._displayService.displayEntity(entity), range);
     }
   }
   createHoverAtReference(reference, range) {
     const firstTarget = reference.firstTarget;
-    switch (firstTarget.value.kind) {
+    switch (firstTarget.kind) {
       case "entity":
-        return this.createHoverForEntity(
-          firstTarget.value.entity,
-          firstTarget.localization,
-          firstTarget.value.narrowedType,
-          range
-        );
+        return this.createHoverForEntity(firstTarget.entity, firstTarget.narrowedType, range);
       case "field": {
         const declaration = new VariableDeclaration_typeMember(
-          firstTarget.value.field,
-          firstTarget.localization,
-          firstTarget.value.narrowedType
+          firstTarget.field,
+          firstTarget.narrowedType
         );
         return new Hover(this._displayService.displayVariableDeclaration(declaration), range);
       }
       case "type-constructor": {
-        const declaration = new ConstructorDeclaration_typeMember(
-          firstTarget.value.constructor_,
-          firstTarget.localization
-        );
+        const declaration = new ConstructorDeclaration_typeMember(firstTarget.constructor_);
         return new Hover(this._displayService.displayConstructorDeclaration(declaration), range);
       }
       case "operator": {
-        const operator = new OperatorDeclaration_typeMember(
-          firstTarget.value.operator,
-          firstTarget.localization
-        );
+        const operator = new OperatorDeclaration_typeMember(firstTarget.operator);
         return new Hover(this._displayService.displayOperatorDeclaration(operator), range);
       }
       case "type-dereference-operator": {
-        const operator = new DereferenceOperatorDeclaration_typeMember(firstTarget.value.operator);
+        const operator = new DereferenceOperatorDeclaration_typeMember(firstTarget.operator);
         return new Hover(this._displayService.displayDereferenceOperatorDeclaration(operator), range);
       }
       case "accessed-function":
-        return this.createHoverAtAccessedFunction(firstTarget.value.func, firstTarget.localization, range);
+        return this.createHoverAtAccessedFunction(firstTarget.func, range);
       case "match-result-value-parameter": {
         const declaration = new ValueParameterDeclaration_matchResultValueParameter(
-          firstTarget.value.parameter,
-          firstTarget.localization
+          firstTarget.parameter
         );
         return new Hover(this._displayService.displayValueParameterDeclaration(declaration), range);
       }
       case "type-value-parameter": {
-        const declaration = new ValueParameterDeclaration_typeMember(
-          firstTarget.value.parameter,
-          firstTarget.localization
-        );
+        const declaration = new ValueParameterDeclaration_typeMember(firstTarget.parameter);
         return new Hover(this._displayService.displayValueParameterDeclaration(declaration), range);
       }
       case "package":
-        return new Hover(this._displayService.displayPackage(firstTarget.value.package_), range);
+        return new Hover(this._displayService.displayPackage(firstTarget.package_), range);
       case "package-name-tree-node":
-        return new Hover(this._displayService.displayPackageNameTreeNode(firstTarget.value.node), range);
+        return new Hover(this._displayService.displayPackageNameTreeNode(firstTarget.node), range);
       case "type-context": {
-        if (firstTarget.value.typeContextKind === "object") {
+        if (firstTarget.typeContextKind === "object") {
           const keywordText = this._displayService.displayKeyword(4 /* Object */);
-          const typeText = this._displayService.displayType(firstTarget.value.type);
+          const typeText = this._displayService.displayType(firstTarget.type);
           return new Hover(`${keywordText}: ${typeText}`, range);
-        } else if (firstTarget.value.typeContextKind === "base") {
+        } else if (firstTarget.typeContextKind === "base") {
           const keywordText = this._displayService.displayKeyword(56 /* Base */);
-          const typeText = this._displayService.displayType(firstTarget.value.type);
+          const typeText = this._displayService.displayType(firstTarget.type);
           return new Hover(`${keywordText}: ${typeText}`, range);
         } else {
-          Debug.never(firstTarget.value.typeContextKind);
+          Debug.never(firstTarget.typeContextKind);
         }
       }
       case "type-indexer": {
-        const declaration = new IndexerDeclaration_typeMember(
-          firstTarget.value.indexer,
-          firstTarget.localization
-        );
+        const declaration = new IndexerDeclaration_typeMember(firstTarget.indexer);
         return new Hover(this._displayService.displayIndexerDeclaration(declaration), range);
       }
       default:
-        Debug.never(firstTarget.value);
+        Debug.never(firstTarget);
     }
   }
-  createHoverAtAccessedFunction(func, localization, range) {
+  createHoverAtAccessedFunction(func, range) {
     switch (func.kind) {
       case "entity": {
-        const declaration = new FunctionDeclaration_entity(func.value, localization);
+        const declaration = new FunctionDeclaration_entity(func.value);
         return new Hover(this._displayService.displayFunctionDeclaration(declaration), range);
       }
       case "type-member": {
-        const declaration = new FunctionDeclaration_typeMember(func.value, localization);
+        const declaration = new FunctionDeclaration_typeMember(func.value);
         return new Hover(this._displayService.displayFunctionDeclaration(declaration), range);
       }
       case "substituted-function": {
-        const declaration = new FunctionDeclaration_substitutedFunction(func.value, localization);
+        const declaration = new FunctionDeclaration_substitutedFunction(func.value);
         return new Hover(this._displayService.displayFunctionDeclaration(declaration), range);
       }
       default:
@@ -8476,7 +8087,8 @@ var RenameService = class {
         const options6 = {
           onlyWithSameAlias: true,
           onlyNamed: true,
-          allowAmbiguous: false
+          allowAmbiguous: false,
+          isForRename: true
         };
         const sourceFiles = Query.from(analyzer.compilation.enumerateSourceFiles()).filter((f) => f.uri.scheme !== InMemoryPackageScheme);
         const references = yield this._referencesService.getReferencesInFiles(
@@ -8511,24 +8123,24 @@ var RenameService = class {
         }
         const target = semanticInfo.firstBetterTargetWithFallback;
         let canBeRenamed;
-        switch (target.value.kind) {
+        switch (target.kind) {
           case "entity":
-            canBeRenamed = this.entityCanBeRenamed(analyzer, target.value.entity);
+            canBeRenamed = this.entityCanBeRenamed(analyzer, target.entity);
             break;
           case "field":
-            canBeRenamed = this.entityCanBeRenamed(analyzer, target.value.field.getEntity());
+            canBeRenamed = this.entityCanBeRenamed(analyzer, target.field.getEntity());
             break;
           case "type-value-parameter":
-            canBeRenamed = this.entityCanBeRenamed(analyzer, target.value.parameter.getEntity());
+            canBeRenamed = this.entityCanBeRenamed(analyzer, target.parameter.getEntity());
             break;
           case "accessed-function":
-            canBeRenamed = this.entityCanBeRenamed(analyzer, target.value.func.getEntity());
+            canBeRenamed = this.entityCanBeRenamed(analyzer, target.func.getEntity());
             break;
           case "match-result-value-parameter":
-            canBeRenamed = this.entityCanBeRenamed(analyzer, target.value.parameter.entity);
+            canBeRenamed = this.entityCanBeRenamed(analyzer, target.parameter.entity);
             break;
           case "operator":
-            canBeRenamed = this.entityCanBeRenamed(analyzer, target.value.operator.getEntity());
+            canBeRenamed = this.entityCanBeRenamed(analyzer, target.operator.getEntity());
             break;
           case "type-constructor":
           case "type-dereference-operator":
@@ -8539,7 +8151,7 @@ var RenameService = class {
             canBeRenamed = false;
             break;
           default:
-            Debug.never(target.value);
+            Debug.never(target);
         }
         if (!canBeRenamed) {
           return void 0;
@@ -8663,7 +8275,7 @@ var SemanticTokensService = class {
           if (node.kind === 86 /* IdentifierExpression */) {
             const meaning = analyzer.resolveIdentifierExpression(node).meaning;
             if (meaning.kind === "variable-access") {
-              const variable = meaning.variable.value.getEntity();
+              const variable = meaning.variable.getEntity();
               if (variable.subkind === "field" && variable.isVariant()) {
                 result.push(
                   new SemanticToken(
@@ -8703,7 +8315,7 @@ var SemanticTokensService = class {
               result.push(
                 new SemanticToken(
                   node.rangeWithoutTrivia,
-                  this.getSemanticTokenKindForFunctionEntity(func.value.getEntity()),
+                  this.getSemanticTokenKindForFunctionEntity(func.getEntity()),
                   new SemanticTokenModifiers().setCapitalized(this.isCapitalizedName(func.value.getName()))
                 )
               );
@@ -8719,7 +8331,7 @@ var SemanticTokensService = class {
           if (node.kind === 76 /* MemberAccessExpression */) {
             const meaning = analyzer.resolveMemberAccessExpression(node).meaning;
             if (meaning.kind === "static-field-access") {
-              const entity = meaning.field.value.getEntity();
+              const entity = meaning.field.getEntity();
               if (entity.subkind === "field" && entity.isVariant()) {
                 result.push(
                   new SemanticToken(
@@ -8733,13 +8345,13 @@ var SemanticTokensService = class {
             let suitableFunctions;
             switch (meaning.kind) {
               case "package-function-access":
-                suitableFunctions = meaning.suitableFunctions.map((m) => m.value);
+                suitableFunctions = meaning.suitableFunctions;
                 break;
               case "static-method-access":
-                suitableFunctions = meaning.suitableFunctions.map((m) => m.value);
+                suitableFunctions = meaning.suitableFunctions;
                 break;
               case "instance-method-access":
-                suitableFunctions = meaning.suitableFunctions.map((m) => m.value);
+                suitableFunctions = meaning.suitableFunctions;
                 break;
             }
             if (suitableFunctions !== void 0 && suitableFunctions.length > 0) {
@@ -8822,11 +8434,7 @@ var SemanticTokensService = class {
     if (typeof name === "string") {
       firstChar = name.charAt(0);
     } else {
-      let firstCharIndex = 0;
-      while (name.unescapedOriginal.charAt(firstCharIndex) === "~") {
-        firstCharIndex++;
-      }
-      firstChar = name.unescapedOriginal.charAt(firstCharIndex);
+      firstChar = name.unescapedOriginal.charAt(0);
     }
     return firstChar.toLowerCase() !== firstChar;
   }
@@ -8912,15 +8520,11 @@ var TypeParameterSignatureHelpProvider = class {
     this._offset = offset;
   }
   get signatureContext() {
-    return this._signatureContext.getOrInsertWith(
-      () => new SignatureContext(
-        new DisplayService(
-          this._analyzer,
-          this._analyzer.createLocalizationContext(this._sourceFile),
-          this._sourceFile.package.dialect ?? 0 /* ArtelAM */
-        )
-      )
-    );
+    return this._signatureContext.getOrInsertWith(() => new SignatureContext(new DisplayService(
+      this._analyzer,
+      this._sourceFile.package.locale,
+      this._sourceFile.package.dialect
+    )));
   }
   provideSignatureHelp() {
     let result = void 0;
@@ -9006,7 +8610,7 @@ var TypeParameterSignatureHelpProvider = class {
     if (resolutionResult.resolvedQualifiers.length > 0) {
       const lastQualifier = resolutionResult.resolvedQualifiers[resolutionResult.resolvedQualifiers.length - 1];
       if (lastQualifier.kind === "type") {
-        return Query.from(lastQualifier.candidates).mapAndFilter((t) => this.getSignatureForNamedType(t.value)).toArray();
+        return Query.from(lastQualifier.candidates).mapAndFilter((t) => this.getSignatureForNamedType(t)).toArray();
       }
     }
     return void 0;
@@ -9016,12 +8620,12 @@ var TypeParameterSignatureHelpProvider = class {
     if (resolutionResult.resolvedQualifiers.length > 0) {
       const lastQualifier = resolutionResult.resolvedQualifiers[resolutionResult.resolvedQualifiers.length - 1];
       if (lastQualifier.kind === "type") {
-        return Query.from(lastQualifier.candidates).mapAndFilter((t) => this.getSignatureForNamedType(t.value)).toArray();
+        return Query.from(lastQualifier.candidates).mapAndFilter((t) => this.getSignatureForNamedType(t)).toArray();
       } else if (lastQualifier.kind === "function") {
         if (resolutionResult.meaning.kind === "tag-function") {
           return Query.from(resolutionResult.meaning.candidates).mapAndFilter((d) => {
-            if (d.value.kind === "substituted-function") {
-              return this.getSignatureForSubstitutedFunction(d.value.value, d.localization);
+            if (d.kind === "substituted-function") {
+              return this.getSignatureForSubstitutedFunction(d.value);
             }
             return void 0;
           }).toArray();
@@ -9038,14 +8642,14 @@ var TypeParameterSignatureHelpProvider = class {
       const meaning = this._analyzer.resolveIdentifierExpression(expression).meaning;
       if (meaning.kind === "function-access") {
         return Query.from(meaning.candidates).mapAndFilter((o) => {
-          if (o.value.kind === "substituted-function") {
-            return this.getSignatureForSubstitutedFunction(o.value.value, o.localization);
+          if (o.kind === "substituted-function") {
+            return this.getSignatureForSubstitutedFunction(o.value);
           }
           return void 0;
         }).toArray();
       }
       if (meaning.kind === "type-access") {
-        return Query.from(meaning.candidates).mapAndFilter((t) => this.getSignatureForNamedType(t.value)).toArray();
+        return Query.from(meaning.candidates).mapAndFilter((t) => this.getSignatureForNamedType(t)).toArray();
       }
       return void 0;
     }
@@ -9061,30 +8665,30 @@ var TypeParameterSignatureHelpProvider = class {
       }
       if (accessedFunctions !== void 0) {
         return Query.from(accessedFunctions).mapAndFilter((o) => {
-          if (o.value.kind === "substituted-function") {
-            return this.getSignatureForSubstitutedFunction(o.value.value, o.localization);
+          if (o.kind === "substituted-function") {
+            return this.getSignatureForSubstitutedFunction(o.value);
           }
           return void 0;
         }).toArray();
       }
       if (meaning.kind === "package-type-access") {
-        return Query.from(meaning.candidates).mapAndFilter((t) => this.getSignatureForNamedType(t.value)).toArray();
+        return Query.from(meaning.candidates).mapAndFilter((t) => this.getSignatureForNamedType(t)).toArray();
       }
       return void 0;
     }
     return void 0;
   }
-  getSignatureForSubstitutedFunction(func, localization) {
+  getSignatureForSubstitutedFunction(func) {
     let result = void 0;
     switch (func.kind) {
       case "entity":
         if (func.entity.getTypeParametersArity() > 0) {
-          result = new FunctionEntitySignature(this.signatureContext, func.entity, localization);
+          result = new FunctionEntitySignature(this.signatureContext, func.entity);
         }
         break;
       case "type-member":
         if (func.method.getTypeParametersArity() > 0) {
-          result = new MethodSignature(this.signatureContext, func.method, localization);
+          result = new MethodSignature(this.signatureContext, func.method);
         }
         break;
       default:
@@ -9131,33 +8735,31 @@ var NodeWithTypeArgumentsInfo = class {
   }
 };
 var FunctionEntitySignature = class {
-  constructor(ctx, func, localization) {
+  constructor(ctx, func) {
     this.ctx = ctx;
     this.func = func;
-    this.localization = localization;
     this.kind = "function-entity";
   }
   getArity() {
     return this.func.getTypeParametersArity();
   }
   getDisplayParts() {
-    const func = new FunctionDeclaration_entity(this.func, this.localization);
+    const func = new FunctionDeclaration_entity(this.func);
     const displayParts = this.ctx.displayService.getFunctionDeclarationDisplayParts(func);
     return this.ctx.convertFunctionDisplayParts(displayParts);
   }
 };
 var MethodSignature = class {
-  constructor(ctx, method, localization) {
+  constructor(ctx, method) {
     this.ctx = ctx;
     this.method = method;
-    this.localization = localization;
     this.kind = "method";
   }
   getArity() {
     return this.method.getTypeParametersArity();
   }
   getDisplayParts() {
-    const func = new FunctionDeclaration_typeMember(this.method, this.localization);
+    const func = new FunctionDeclaration_typeMember(this.method);
     const displayParts = this.ctx.displayService.getFunctionDeclarationDisplayParts(func);
     return this.ctx.convertFunctionDisplayParts(displayParts);
   }
@@ -9245,15 +8847,11 @@ var ValueParametersSignatureHelpProvider = class {
     this._offset = offset;
   }
   get signatureContext() {
-    return this._signatureContext.getOrInsertWith(
-      () => new SignatureContext2(
-        new DisplayService(
-          this._analyzer,
-          this._analyzer.createLocalizationContext(this._sourceFile),
-          this._sourceFile.package.dialect ?? 0 /* ArtelAM */
-        )
-      )
-    );
+    return this._signatureContext.getOrInsertWith(() => new SignatureContext2(new DisplayService(
+      this._analyzer,
+      this._sourceFile.package.locale,
+      this._sourceFile.package.dialect
+    )));
   }
   provideSignatureHelp() {
     let result = void 0;
@@ -9355,10 +8953,7 @@ var ValueParametersSignatureHelpProvider = class {
   getSignatureDisplayParts(signature) {
     switch (signature.kind) {
       case "accessed-function": {
-        const func = new FunctionDeclaration_accessedFunction(
-          signature.func.value,
-          signature.func.localization
-        );
+        const func = new FunctionDeclaration_accessedFunction(signature.func);
         const displayParts = this.signatureContext.displayService.getFunctionDeclarationDisplayParts(func);
         return this.signatureContext.convertFunctionDisplayParts(displayParts);
       }
@@ -9367,18 +8962,12 @@ var ValueParametersSignatureHelpProvider = class {
         return this.signatureContext.convertFunctionTypeBodyDisplayParts(displayParts);
       }
       case "constructor": {
-        const constructor = new ConstructorDeclaration_typeMember(
-          signature.constructor_.value,
-          signature.constructor_.localization
-        );
+        const constructor = new ConstructorDeclaration_typeMember(signature.constructor_);
         const displayParts = this.signatureContext.displayService.getConstructorDeclarationDisplayParts(constructor);
         return this.signatureContext.convertConstructorDisplayParts(displayParts);
       }
       case "indexer": {
-        const indexer = new IndexerDeclaration_typeMember(
-          signature.indexer.value,
-          signature.indexer.localization
-        );
+        const indexer = new IndexerDeclaration_typeMember(signature.indexer);
         const displayParts = this.signatureContext.displayService.getIndexerDeclarationDisplayParts(indexer);
         return this.signatureContext.convertIndexerDisplayParts(displayParts);
       }
@@ -9452,7 +9041,7 @@ var SignatureInfo = class {
 };
 
 // source/services/source-generation/SourceGenerationService.ts
-import { runAtomically as runAtomically2, TriggeringMap as TriggeringMap6, TriggeringObject as TriggeringObject7, reaction as reaction6, Transaction as Transaction4 } from "reactronic";
+import { reaction as reaction6, runAtomically as runAtomically2, Transaction as Transaction4, TriggeringMap as TriggeringMap6, TriggeringObject as TriggeringObject7 } from "reactronic";
 
 // source/services/workspace/ClientTrackedSourceFiles.ts
 import { TriggeringMap, TriggeringObject, trigger, ReactiveSystem, atomic } from "reactronic";
@@ -11822,10 +11411,9 @@ var Workspace = _Workspace;
 
 // source/services/source-generation/EntityToSyntax.ts
 var EntityToSyntax = class {
-  constructor(analyzer, entity, localizationContext) {
+  constructor(analyzer, entity) {
     this._analyzer = analyzer;
     this._entity = entity;
-    this._localizationContext = localizationContext;
   }
   convert() {
     return this.convertPackage(this._entity);
@@ -12181,7 +11769,10 @@ var EntityToSyntax = class {
     const name = this.getEntityName(entity);
     let constraint;
     const entityConstraint = entity.getConstraint().declared;
-    if (entityConstraint !== void 0 && !entityConstraint.equals(this._analyzer.getDefaultTypeParameterConstraint())) {
+    if (entityConstraint !== void 0 && !entityConstraint.equals(this._analyzer.getDefaultTypeParameterConstraint(
+      /* При сравнении типов язык не имеет значения. */
+      DefaultLocale
+    ))) {
       constraint = this.convertType(entityConstraint);
     }
     let defaultType;
@@ -12228,7 +11819,7 @@ var EntityToSyntax = class {
     return [];
   }
   getEntityName(entity) {
-    return this._localizationContext?.getEntityName(entity).value.unescapedOriginal ?? entity.getName().unescapedOriginal;
+    return entity.getName().unescapedOriginal;
   }
   convertType(type) {
     switch (type.kind) {
@@ -12292,7 +11883,7 @@ var EntityToSyntax = class {
   }
   convertUnionType(type) {
     if (type.originalTypes.length === 2) {
-      const noneTypeIndex = type.originalTypes.findIndex((t) => t.equals(this._analyzer.standardTypes.none));
+      const noneTypeIndex = type.originalTypes.findIndex((t) => t.equals(this._analyzer.originalStandardTypes.none));
       if (noneTypeIndex >= 0) {
         const nonNoneType = noneTypeIndex === 0 ? type.originalTypes[1] : type.originalTypes[0];
         const result = SyntaxFactory.nullableTypeSpecifier(this.convertType(nonNoneType));
@@ -12307,7 +11898,7 @@ var EntityToSyntax = class {
     return SyntaxFactory.intersectionTypeSpecifier(constituentTypes);
   }
   convertUnresolvedType(_type) {
-    return SyntaxFactory.namedTypeSpecifier("~\u041E\u0431\u044A\u0435\u043A\u0442");
+    return SyntaxFactory.namedTypeSpecifier("\u041E\u0431\u044A\u0435\u043A\u0442");
   }
   createNamedTypeSpecifier(name, substitutions) {
     const typeArguments = Query.from(substitutions.getTypes()).map((t) => this.convertType(t)).toArray();
@@ -12327,18 +11918,13 @@ var SourceGenerationService = class extends TriggeringObject7 {
   get compilationControllers() {
     return Array.from(this._generatedPackageStates.values()).map((s) => s.compilationController);
   }
-  getDefinitionInGeneratedCode(analyzer, entity, localizationContext, cancellationToken) {
+  getDefinitionInGeneratedCode(analyzer, entity, cancellationToken) {
     return __async(this, null, function* () {
       if (!this.entityDefinitionRequiresSourceGeneration(entity)) {
         return void 0;
       }
       const containingPackage = getPackageContainingEntity(entity);
-      const generatedPackageState = yield this.getOrGeneratePackageSource(
-        analyzer,
-        containingPackage,
-        localizationContext,
-        cancellationToken
-      );
+      const generatedPackageState = yield this.getOrGeneratePackageSource(analyzer, containingPackage, cancellationToken);
       if (generatedPackageState === void 0) {
         return void 0;
       }
@@ -12357,7 +11943,7 @@ var SourceGenerationService = class extends TriggeringObject7 {
         compilationState.analyzer.compilation.mainPackage
       );
       let result;
-      const sourceEntity = new EntityFinder(entity, generatedPackageEntity, localizationContext).find();
+      const sourceEntity = new EntityFinder(entity, generatedPackageEntity).find();
       if (sourceEntity !== void 0) {
         result = getEntitySourceLocations(compilationState.analyzer, sourceEntity);
       }
@@ -12401,23 +11987,22 @@ var SourceGenerationService = class extends TriggeringObject7 {
       }
     }
   }
-  getOrGeneratePackageSource(analyzer, packageEntity, localizationContext, cancellationToken) {
+  getOrGeneratePackageSource(analyzer, packageEntity, cancellationToken) {
     return __async(this, null, function* () {
-      const packageLocale = localizationContext?.getTranslationLocale(packageEntity) ?? packageEntity.getLocale();
+      const packageLocale = packageEntity.getLocale();
       const key = `${packageEntity.getName().toString()}-${localeToString(packageLocale)}`;
       let result = this._generatedPackageStates.get(key);
       if (result === void 0) {
-        const node = new EntityToSyntax(analyzer, packageEntity, localizationContext).convert();
+        const node = new EntityToSyntax(analyzer, packageEntity).convert();
         const code = new SyntaxToCode(node, { keywordsLocale: packageLocale }).convert();
         const generatedPackageUri = new Uri(GeneratedSourceFileScheme, "", [key]);
         const generatedFileUri = generatedPackageUri.append(`${packageEntity.getName().toString()}.art`);
         const fileSystemTree = runAtomically2(() => new FileSystemTree());
         const packageDirectory = fileSystemTree.addDirectory(generatedPackageUri);
         fileSystemTree.addFile(generatedFileUri, code);
-        const systemPackageLocale = localizationContext?.getTranslationLocale(analyzer.systemPackage) ?? analyzer.systemPackage.getLocale();
         const packageConfiguration = this.createGeneratedPackageConfiguration(
           packageEntity,
-          systemPackageLocale,
+          packageLocale,
           DefaultDialect
         );
         const standardPackageContents = yield this._standardPackageContentsProviders(cancellationToken);
@@ -12547,10 +12132,9 @@ var GeneratedPackageState = class {
   }
 };
 var EntityFinder = class {
-  constructor(_entity, _packageEntity, _localizationContext) {
+  constructor(_entity, _packageEntity) {
     this._entity = _entity;
     this._packageEntity = _packageEntity;
-    this._localizationContext = _localizationContext;
   }
   find() {
     return this.findEntity(this._entity);
@@ -12608,7 +12192,7 @@ var EntityFinder = class {
       }
     } else if (entity.subkind === "parameter") {
       const container = entity.getContainer();
-      if (container.kind === "entity" && container.entity.kind !== 4 /* Setter */) {
+      if (container.kind === "entity") {
         const index = container.entity.getValueParameters().indexOf(entity);
         const containingEntity = this.findEntity(container.entity);
         if (containingEntity !== void 0 && index >= 0) {
@@ -12826,7 +12410,7 @@ var EntityFinder = class {
     return -1;
   }
   getEntityName(entity) {
-    return this._localizationContext?.getEntityName(entity).value ?? entity.getName();
+    return entity.getName();
   }
 };
 var DataForFindingOverloadedMember = class {