@artel/artc 0.6.25263 → 0.6.25265

package/build/{chunk-CUKH4EK5.js → chunk-H4KRG6OZ.js}

@@ -1,6 +1,6 @@
 import {
   Compiler
-} from "./chunk-TADWLWRQ.js";
+} from "./chunk-ZL6MDCED.js";
 import {
   ArtelVersion,
   Cached,
@@ -14,7 +14,7 @@ import {
   __async,
   performanceMeasurementStageNames,
   performanceMeasurementStages
-} from "./chunk-OB2WGYLS.js";
+} from "./chunk-7MWYN6O7.js";
 
 // source/executor/FileSystemUri.ts
 import { platform } from "os";

package/build/{chunk-TADWLWRQ.js → chunk-ZL6MDCED.js}

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

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

@@ -0,0 +1,21 @@
+import { PackageLocale } from '../common/index.js';
+import { PackageEntity } from '../entities/PackageEntity.js';
+import { TextTranslationEntity, TextTranslationEntityKey } from '../entities/TextTranslationEntity.js';
+import { PackageName, TextTranslationPackage } from '../project/index.js';
+import { Analyzer } from './Analyzer.js';
+export declare class AnalyzedTextTranslationPackage {
+    private readonly analyzer;
+    private readonly package_;
+    private readonly targetPackage;
+    private readonly entitiesByTextKey;
+    constructor(analyzer: Analyzer, package_: TextTranslationPackage, targetPackage: PackageEntity);
+    isPrimary(): boolean;
+    getTargetPackage(): PackageEntity;
+    getDefinition(): TextTranslationPackage;
+    getTargetPackageName(): PackageName;
+    getTranslationLocale(): PackageLocale;
+    getEntitiesByTextKey(textKey: TextTranslationEntityKey): readonly TextTranslationEntity[] | undefined;
+    private createEntitiesByTextKey;
+    private enumerableTextTranslationDeclarations;
+    private enumerableTranslationsDeclarations;
+}

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

@@ -4,7 +4,6 @@ import { Diagnostic, DiagnosticAcceptor, DiagnosticLocation } from '../diagnosti
 import { DiagnosticCode } from '../diagnostic/DiagnosticCode.js';
 import { DiagnosticFlags, DiagnosticKind } from '../diagnostic/DiagnosticData.js';
 import { BinaryOperatorKind } from '../entities/OperatorKind.js';
-import { PackageEntityMembers } from '../entities/PackageMembers.js';
 import * as e from '../entities/index.js';
 import { ReservedIdentifierKind } from '../parser/ReservedIdentifierDictionary.js';
 import * as project from '../project/index.js';
@@ -15,6 +14,7 @@ import * as types from '../types/index.js';
 import { TypeFactory } from '../types/index.js';
 import { AccessedFunction } from './AccessedFunction.js';
 import { AnalyzedTranslationPackage } from './AnalyzedTranslationPackage.js';
+import { AnalyzedTextTranslationPackage } from './AnalyzedTextTranslationPackage.js';
 import { ArgumentToParameterMatchResult, MatchResultParameter } from './ArgumentToParameterMatchResult.js';
 import * as autotypeCallExpressionMeaning from './AutotypeCallExpressionMeaning.js';
 import * as baseExpressionMeaning from './BaseExpressionMeaning.js';
@@ -31,7 +31,7 @@ import { NamedTypeSpecifierResolutionResult } from './NamedTypeSpecifierResolver
 import { DereferencedVariableAccessorDeclaration, FieldAccessorDeclaration, FunctionDeclaration, FunctionTypeDeclaration, GetterDeclaration, IndexedElementAccessorDeclaration, PackageVariableAccessorDeclaration, RegularOrBlockFunctionLiteral, SetterDeclaration, StructuredTypeDeclaration, TypeDeclaration, TypeWithMembersDeclaration, VariantTypeDeclaration } from './NodeTypeUtils.js';
 import * as objectExpressionMeaning from './ObjectExpressionMeaning.js';
 import { OwnAndBaseConstructorCallsCheckResult } from './OwnAndBaseConstructorCallsChecker.js';
-import { SourceFileMembers as ActualSourceFileMembers } from './SourceFileMembers.js';
+import { SourceFileMembers } from './SourceFileMembers.js';
 import * as tagMeaning from './TagMeaning.js';
 import * as tags from './Tags.js';
 import { TypeMemberImplementationCheckResult } from './TypeMemberImplementationChecker.js';
@@ -94,6 +94,8 @@ export declare class Analyzer {
     private readonly parametersOfFunctionBlockLiterals;
     private readonly extendedTypes;
     private readonly analyzedTranslationPackages;
+    private readonly analyzedTextTranslationPackages;
+    private textTranslationPackagesMap;
     private readonly linkedMultiPlatformPackagesByPlatform;
     private readonly isFunctionGeneratorCheckResults;
     private readonly namedDeclarationsUsageCountResults;
@@ -133,7 +135,7 @@ export declare class Analyzer {
     resolveMemberAccessExpressionFirstStage(node: tree.MemberAccessExpression): memberAccessExpressionResolution.FirstStageResolutionResult;
     resolveMemberAccessExpression(node: tree.MemberAccessExpression, analysisOptions?: ExpressionAnalysisOptions): memberAccessExpressionResolution.ResolutionResult;
     enumeratePackageImports(packageImportDirectives: Iterable<tree.PackageImportDirective>): Iterable<tree.PackageImport>;
-    getSourceFileMembers(node: tree.SourceFile): ActualSourceFileMembers;
+    getSourceFileMembers(node: tree.SourceFile): SourceFileMembers;
     resolveCallExpression(node: tree.CallExpression, analysisOptions?: ExpressionAnalysisOptions): callExpressionMeaning.ResolutionResult;
     getRespectiveParameter(node: tree.Argument): MatchResultParameter | undefined;
     resolveIndexedAccessExpression(node: tree.IndexedAccessExpression): indexedAccessExpressionMeaning.ResolutionResult;
@@ -257,12 +259,14 @@ export declare class Analyzer {
     getFunctionBlockLiteralParameters(node: tree.FunctionBlockLiteral): readonly e.ParameterEntity[];
     getExtendedType(node: tree.TypeExtensionDeclaration): WithDiagnostics<e.NamedTypeEntity>;
     getAnalyzedTranslationPackageIfTargetResolved(package_: project.TranslationPackage): AnalyzedTranslationPackage | undefined;
+    getAnalyzedTextTranslationPackageIfTargetResolved(package_: project.TextTranslationPackage): AnalyzedTextTranslationPackage | undefined;
     findAnalyzedTranslationPackageForLocale(entity: e.PackageEntity, locale: PackageLocale): AnalyzedTranslationPackage | undefined;
     getLocalizedPackageWithLocale(originalPackageEntity: e.PackageEntity, locale: PackageLocale): e.PackageEntity | undefined;
     enumerateAnalyzedTranslationPackages(): Query<AnalyzedTranslationPackage>;
+    enumerateAnalyzedTextTranslationPackages(): Iterable<AnalyzedTextTranslationPackage>;
     getLinkedMultiPlatformPackagesByPlatform(entity: e.PackageEntity): ReadonlyMap<PlatformKind, LinkedMultiPlatformPackage> | undefined;
     getLinkedMultiPlatformPackage(entity: e.PackageEntity, platform: PlatformKind): LinkedMultiPlatformPackage | undefined;
-    createPackageMembers(pkg: SourcePackage): PackageEntityMembers;
+    getTextTranslationPackagesMap(): ReadonlyMap<e.PackageEntity, ReadonlyMap<PackageLocale, AnalyzedTextTranslationPackage>>;
     instantiateType(entity: e.TypeEntity, typeArguments: readonly types.Type[] | undefined): types.Type;
     instantiateTypeWithSubstitutions(entity: e.TypeEntity, substitutions: types.Substitutions): types.Type;
     instantiateTypeByIdentitySubstitution(entity: e.TypeEntity): types.Type;
@@ -283,7 +287,7 @@ export declare class Analyzer {
     createNodeDiagnostic(code: DiagnosticCode, node: tree.Node, formatArguments?: readonly DisplayableOrPrimitive[], kind?: DiagnosticKind, flags?: DiagnosticFlags): Diagnostic;
     createSourceFileRangeDiagnostic(code: DiagnosticCode, range: Range, nodeOrSourceFile: tree.Node | project.SourceFile, formatArguments?: readonly DisplayableOrPrimitive[], kind?: DiagnosticKind, flags?: DiagnosticFlags): Diagnostic;
     createDiagnostic(code: DiagnosticCode, location: DiagnosticLocation | undefined, formatArguments?: readonly DisplayableOrPrimitive[], kind?: DiagnosticKind, flags?: DiagnosticFlags): Diagnostic;
-    createNodeDiagnosticLocation(node: tree.Node): DiagnosticLocation;
+    getNodeDiagnosticLocation(node: tree.Node): DiagnosticLocation;
     getDeclaredTypeMemberEntities(node: tree.TypeMemberDeclarationBlock): DeclaredTypeMemberEntities;
     getBasicMethodOfOriginalTypeForBasicMethodOfAliasType(entity: e.MethodEntity): e.MethodEntity | undefined;
     checkBodyOfBasicAliasTypeMethod(node: tree.MethodDeclaration, diagnostics?: DiagnosticAcceptor): {
@@ -314,6 +318,7 @@ export declare class Analyzer {
     isTargetTypeDependentFunctionLiteral(node: tree.Expression): node is RegularOrBlockFunctionLiteral;
     checkTypeArgumentCount(typeArgumentCount: number, typeParameters: readonly e.TypeParameterEntity[], diagnostics?: DiagnosticAcceptor, nodeForDiagnostic?: tree.Node): boolean;
     checkTypeCanBeUsedAsValue(typeAccess: tree.Expression): boolean;
+    getEntityDiagnosticLocation(entity: e.Entity, chooseSetter?: boolean): DiagnosticLocation | undefined;
     private createTsInterop;
 }
 export declare class TsInteropInputs {
@@ -441,6 +446,7 @@ declare class ReturnType {
     ofDereferencedVariableGetterDeclaration(node: tree.DereferencedVariableGetterDeclaration): types.Type;
     ofIndexedElementGetterDeclaration(node: tree.IndexedElementGetterDeclaration): types.Type;
     ofFunctionDeclaration(node: FunctionDeclaration): types.Type;
+    ofTextTranslationFunctionDeclaration(node: tree.TextTranslationFunctionDeclaration): types.Type;
 }
 declare class Entity {
     private readonly analyzer;
@@ -470,9 +476,7 @@ declare class Entity {
     private readonly typeExtensionEntities;
     private readonly packageAliasEntities;
     private readonly translationTextTemplateParameterEntities;
-    private readonly localizableSimpleTextEntities;
-    private readonly localizableTextTemplateEntities;
-    private readonly localizableTextEntitiesByPackage;
+    private readonly textTranslationDeclarationEntities;
     constructor(analyzer: Analyzer);
     ofPackage(pkg: SourcePackage): e.PackageEntity;
     ofPackageVariableDeclaration(node: tree.PackageVariableDeclaration): e.PackageVariableEntity;
@@ -517,7 +521,8 @@ declare class Entity {
     ofPackageImport(node: tree.PackageImport): e.PackageAliasEntity;
     ofTypeWithMembersDeclaration(node: TypeWithMembersDeclaration): e.TypeEntityWithMembers;
     ofTypeWithMembersOrExtensionDeclaration(node: TypeWithMembersOrTypeExtensionDeclaration): e.TypeWithMembersOrExtensionEntity;
-    ofTranslationTextTemplateParameter(node: tree.TranslationTextTemplateParameter): e.TranslationTextTemplateParameterEntity;
+    ofTranslationTextTemplateParameter(node: tree.TranslationTextTemplateParameter): e.ParameterEntity;
+    ofTextTranslationDeclaration(node: tree.TextTranslationSource): e.TextTranslationEntity;
     private getContainingPackageLoadedFromDts;
     private createComputedFieldEntities;
     private createDereferenceOperatorEntities;
@@ -540,6 +545,7 @@ declare class ResultLocalVariableEntity {
     ofIndexedElementGetterDeclaration(node: tree.IndexedElementGetterDeclaration): e.LocalVariableEntity;
     ofDereferencedVariableGetterDeclaration(node: tree.DereferencedVariableGetterDeclaration): e.LocalVariableEntity;
     ofFunctionDeclaration(node: FunctionDeclaration): e.LocalVariableEntity;
+    ofTextTranslationFunctionDeclaration(node: tree.TextTranslationFunctionDeclaration): e.LocalVariableEntity;
     private createResultLocalVariableEntity;
 }
 declare class ValueLocalVariableEntity {

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

@@ -8,12 +8,14 @@ export declare class DiagnosticCollector {
     private readonly sourceFile;
     private readonly diagnosticArgumentFactory;
     private readonly translationPackage_;
+    private readonly textTranslationPackage_;
     private readonly diagnostics;
     private readonly diagnosticAcceptor;
     private namedDeclarationsUsageMap;
     private readonly modifierValidator;
     private readonly standardTypes_;
     private get translationPackage();
+    private get textTranslationPackage();
     private get isInterfacePackageFile();
     private get standardTypes();
     constructor(analyzer: Analyzer, sourceFile: project.SourceFile);

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

@@ -1,4 +1,4 @@
-import { FieldEntity, LocalVariableEntity, PackageVariableEntity, ParameterEntity, TextTemplateParameterEntity } from '../../entities/VariableEntity.js';
+import { FieldEntity, LocalVariableEntity, PackageVariableEntity, ParameterEntity } from '../../entities/VariableEntity.js';
 import * as tree from '../../tree/index.js';
 import { Analyzer } from '../Analyzer.js';
 import { NarrowableReferenceExpression } from '../control-flow/NarrowableExpression.js';
@@ -6,9 +6,9 @@ export type NarrowableReference = NarrowableReference.LocalVariable | Narrowable
 export declare namespace NarrowableReference {
     export class LocalVariable implements INarrowableReference {
         private readonly analyzer;
-        readonly entity: LocalVariableEntity | ParameterEntity | TextTemplateParameterEntity;
+        readonly entity: LocalVariableEntity | ParameterEntity;
         readonly kind = "local-variable";
-        constructor(analyzer: Analyzer, entity: LocalVariableEntity | ParameterEntity | TextTemplateParameterEntity);
+        constructor(analyzer: Analyzer, entity: LocalVariableEntity | ParameterEntity);
         equals(other: NarrowableReference): boolean;
         contains(_other: NarrowableReference): boolean;
         equalsExpression(expression: NarrowableReferenceExpression): boolean;

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

@@ -1,8 +1,7 @@
 import { FieldWithInitializerSemanticContext } from './FieldWithInitializerSemanticContext.js';
 import { SourceFileSemanticContext } from './SourceFileSemanticContext.js';
-import { CatchClauseSemanticContext, ForStatementSemanticContext, FunctionBlockSemanticContext, SpecialLocalDeclarationSemanticContext, StatementBlockSemanticContext, SubprogramParameterSemanticContext, SubprogramTypeParameterSemanticContext } from './SubprogramBodyAndParametersSemanticContext.js';
+import { CatchClauseSemanticContext, ForStatementSemanticContext, FunctionBlockSemanticContext, SpecialLocalDeclarationSemanticContext, StatementBlockSemanticContext, SubprogramParameterListSemanticContext, SubprogramTypeParameterSemanticContext } from './SubprogramBodyAndParametersSemanticContext.js';
 import { OutermostSemanticContextOfSubprogram } from './SubprogramSemanticContext.js';
-import { TranslationTextTemplateSemanticContext } from './TranslationTextTemplateSemanticContext.js';
 import { OutermostSemanticContextOfType, ParametersOfFunctionTypeSemanticContext, TypeBodySemanticContext, TypeExtensionBodySemanticContext, TypeParametersOfTypeSemanticContext } from './TypeSemanticContext.js';
 /**
  * Позволяет получить информацию, общую для определённой области
@@ -11,4 +10,4 @@ import { OutermostSemanticContextOfType, ParametersOfFunctionTypeSemanticContext
  * Чтобы получить семантический контекст, в котором находится определённый узел,
  * используйте `analyzer.semanticContext.containing(node)`.
  */
-export type SemanticContext = SourceFileSemanticContext | OutermostSemanticContextOfType | TypeParametersOfTypeSemanticContext | TypeBodySemanticContext | TypeExtensionBodySemanticContext | ParametersOfFunctionTypeSemanticContext | OutermostSemanticContextOfSubprogram | SubprogramTypeParameterSemanticContext | SubprogramParameterSemanticContext | SpecialLocalDeclarationSemanticContext | StatementBlockSemanticContext | FunctionBlockSemanticContext | FieldWithInitializerSemanticContext | ForStatementSemanticContext | CatchClauseSemanticContext | TranslationTextTemplateSemanticContext;
+export type SemanticContext = SourceFileSemanticContext | OutermostSemanticContextOfType | TypeParametersOfTypeSemanticContext | TypeBodySemanticContext | TypeExtensionBodySemanticContext | ParametersOfFunctionTypeSemanticContext | OutermostSemanticContextOfSubprogram | SubprogramTypeParameterSemanticContext | SubprogramParameterListSemanticContext | SpecialLocalDeclarationSemanticContext | StatementBlockSemanticContext | FunctionBlockSemanticContext | FieldWithInitializerSemanticContext | ForStatementSemanticContext | CatchClauseSemanticContext;

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

@@ -39,7 +39,7 @@ export declare abstract class SemanticContextBase {
     private enumerateSemanticContexts;
     private getSourceFileContext;
 }
-export type SubprogramInfo = SubprogramInfo.Function | SubprogramInfo.Operator | SubprogramInfo.Constructor | SubprogramInfo.Destructor | SubprogramInfo.Getter | SubprogramInfo.Setter | SubprogramInfo.PackageConstructor | SubprogramInfo.PackageEntryPoint | SubprogramInfo.FunctionLiteral;
+export type SubprogramInfo = SubprogramInfo.Function | SubprogramInfo.Operator | SubprogramInfo.Constructor | SubprogramInfo.Destructor | SubprogramInfo.Getter | SubprogramInfo.Setter | SubprogramInfo.PackageConstructor | SubprogramInfo.PackageEntryPoint | SubprogramInfo.FunctionLiteral | SubprogramInfo.TextTranslationFunction;
 export declare namespace SubprogramInfo {
     export class Function implements ISubprogramInfo {
         readonly kind = "function";
@@ -136,6 +136,16 @@ export declare namespace SubprogramInfo {
         getNode(): RegularOrBlockFunctionLiteral;
         private getSignatureType;
     }
+    export class TextTranslationFunction implements ISubprogramInfo {
+        readonly kind = "text-translation-function";
+        private readonly analyzer;
+        private readonly node;
+        constructor(analyzer: Analyzer, node: tree.TextTranslationFunctionDeclaration);
+        getReturnType(): types.Type | undefined;
+        isGenerator(): boolean;
+        allowsAsyncCalls(): boolean;
+        getNode(): tree.TextTranslationFunctionDeclaration;
+    }
     interface ISubprogramInfo {
         getReturnType(): types.Type | undefined;
         isGenerator(): boolean;

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

@@ -1,8 +1,7 @@
 import * as tree from '../../tree/index.js';
 import { Analyzer } from '../Analyzer.js';
 import { FunctionDeclaration, IndexedElementAccessorDeclaration, PackageTypeDeclaration, RegularOrBlockFunctionLiteral, SubprogramDeclarationOrLiteral } from '../NodeTypeUtils.js';
-import { BlockSemanticContext, CatchClauseSemanticContext, ConstructorSemanticContext, DestructorSemanticContext, ForStatementSemanticContext, FunctionBlockSemanticContext, FunctionLiteralSemanticContext, FunctionSemanticContext, IndexedElementAccessorSemanticContext, OperatorSemanticContext, OutermostSemanticContextOfSubprogram, OutermostSemanticContextOfType, PackageConstructorSemanticContext, PackageEntryPointSemanticContext, ParametersOfFunctionTypeSemanticContext, SemanticContext, SemanticContextContainingTypeMember, SourceFileSemanticContext, SpecialLocalDeclarationSemanticContext, StatementBlockSemanticContext, SubprogramParameterSemanticContext, SubprogramTypeParameterSemanticContext, TypeBodySemanticContext, TypeDeclarationCreatingSemanticContext, TypeDeclarationWithMembersBody, TypeExtensionBodySemanticContext, TypeParametersOfTypeSemanticContext, VariableAccessorDeclaration, VariableAccessorSemanticContext } from '../semantic-context/index.js';
-import { TranslationTextTemplateSemanticContext } from './TranslationTextTemplateSemanticContext.js';
+import { BlockSemanticContext, CatchClauseSemanticContext, ConstructorSemanticContext, DestructorSemanticContext, ForStatementSemanticContext, FunctionBlockSemanticContext, FunctionLiteralSemanticContext, FunctionSemanticContext, IndexedElementAccessorSemanticContext, OperatorSemanticContext, OutermostSemanticContextOfSubprogram, OutermostSemanticContextOfType, PackageConstructorSemanticContext, PackageEntryPointSemanticContext, ParametersOfFunctionTypeSemanticContext, SemanticContext, SemanticContextContainingTypeMember, SourceFileSemanticContext, SpecialLocalDeclarationSemanticContext, StatementBlockSemanticContext, SubprogramParameterListSemanticContext, SubprogramTypeParameterSemanticContext, TextTranslationFunctionDeclarationSemanticContext, TypeBodySemanticContext, TypeDeclarationCreatingSemanticContext, TypeDeclarationWithMembersBody, TypeExtensionBodySemanticContext, TypeParametersOfTypeSemanticContext, VariableAccessorDeclaration, VariableAccessorSemanticContext } from '../semantic-context/index.js';
 export declare class SemanticContextBuilder {
     private readonly analyzer;
     private readonly sourceFileContexts;
@@ -26,9 +25,9 @@ export declare class SemanticContextBuilder {
     private readonly subprogramTypeParameterContexts;
     private readonly subprogramParameterContexts;
     private readonly outermostContextsOfFunctionDeclaration;
+    private readonly outermostContextsOfTextTranslationFunctionDeclaration;
     private readonly outermostContextsOfTypeDeclaration;
     private readonly typeExtensionDeclarationBodyContexts;
-    private readonly translationTextTemplateContexts;
     constructor(analyzer: Analyzer);
     /**
      * Возвращает контекст, содержащий узел. Если в качестве узла передан исходный файл,
@@ -37,10 +36,10 @@ export declare class SemanticContextBuilder {
     containing(node: tree.Node): SemanticContext;
     containingWithOffset(node: tree.Node, offset: number): SemanticContext;
     ofSourceFile(node: tree.SourceFile): SourceFileSemanticContext;
-    ofFunctionDeclarationParameters(node: FunctionDeclaration): SubprogramParameterSemanticContext;
+    ofFunctionDeclarationParameters(node: FunctionDeclaration): SubprogramParameterListSemanticContext;
     ofFunctionDeclarationTypeParameters(node: FunctionDeclaration, typeParameterClause: tree.TypeParameterClause): SubprogramTypeParameterSemanticContext;
     outermostSemanticContextOfFunctionDeclaration(node: FunctionDeclaration): FunctionSemanticContext;
-    ofOperatorDeclarationParameters(node: tree.OperatorDeclaration): SubprogramParameterSemanticContext;
+    ofOperatorDeclarationParameters(node: tree.OperatorDeclaration): SubprogramParameterListSemanticContext;
     outermostSemanticContextOfOperatorDeclaration(node: tree.OperatorDeclaration): OperatorSemanticContext;
     ofTypeDeclarationBody(node: TypeDeclarationWithMembersBody): TypeBodySemanticContext;
     ofFunctionTypeDeclarationParameters(node: tree.FunctionTypeDeclarationBody): ParametersOfFunctionTypeSemanticContext;
@@ -50,25 +49,26 @@ export declare class SemanticContextBuilder {
     ofVariableAccessorDeclaration(node: VariableAccessorDeclaration): VariableAccessorSemanticContext;
     ofPackageConstructorDeclaration(node: tree.PackageConstructorDeclaration): PackageConstructorSemanticContext;
     ofPackageEntryPointDeclaration(node: tree.PackageEntryPointDeclaration): PackageEntryPointSemanticContext;
-    ofRegularOrBlockFunctionLiteralParameters(node: RegularOrBlockFunctionLiteral): SubprogramParameterSemanticContext;
+    ofRegularOrBlockFunctionLiteralParameters(node: RegularOrBlockFunctionLiteral): SubprogramParameterListSemanticContext;
+    ofTextTranslationDeclarationParameters(node: tree.TranslationTextTemplate): SubprogramParameterListSemanticContext;
+    outermostSemanticContextOfTextTranslationFunctionDeclaration(node: tree.TextTranslationFunctionDeclaration): TextTranslationFunctionDeclarationSemanticContext;
     outermostSemanticContextOfRegularOrBlockFunctionLiteral(node: RegularOrBlockFunctionLiteral): FunctionLiteralSemanticContext;
     ofForStatement(node: tree.ForStatement): ForStatementSemanticContext;
     ofStatementBlock(node: tree.StatementBlock): StatementBlockSemanticContext;
     ofFunctionBlock(node: tree.FunctionBlock): FunctionBlockSemanticContext;
     withSpecialLocalDeclarations(node: tree.FunctionBlock): SpecialLocalDeclarationSemanticContext;
     ofStatementBlockOrFunctionBlock(node: tree.StatementBlock | tree.FunctionBlock): BlockSemanticContext;
-    ofConstructorDeclarationParameters(node: tree.ConstructorDeclaration): SubprogramParameterSemanticContext;
+    ofConstructorDeclarationParameters(node: tree.ConstructorDeclaration): SubprogramParameterListSemanticContext;
     outermostSemanticContextOfConstructorDeclaration(node: tree.ConstructorDeclaration): ConstructorSemanticContext;
-    ofDestructorDeclarationParameters(node: tree.DestructorDeclaration): SubprogramParameterSemanticContext;
+    ofDestructorDeclarationParameters(node: tree.DestructorDeclaration): SubprogramParameterListSemanticContext;
     outermostSemanticContextOfDestructorDeclaration(node: tree.DestructorDeclaration): DestructorSemanticContext;
-    ofIndexedElementAccessorDeclarationParameters(node: IndexedElementAccessorDeclaration): SubprogramParameterSemanticContext;
+    ofIndexedElementAccessorDeclarationParameters(node: IndexedElementAccessorDeclaration): SubprogramParameterListSemanticContext;
     outermostSemanticContextOfIndexedElementAccessorDeclaration(node: IndexedElementAccessorDeclaration): IndexedElementAccessorSemanticContext;
     ofCatchClause(node: tree.CatchClause): CatchClauseSemanticContext;
     ofFieldDeclarationWithInitializer(node: tree.FieldDeclaration): SemanticContext;
     ofSubprogram(node: SubprogramDeclarationOrLiteral): OutermostSemanticContextOfSubprogram;
     containingTypeMember(node: tree.TypeMemberDeclaration): SemanticContextContainingTypeMember;
     containingPackageMember(node: tree.PackageMemberDeclaration): SourceFileSemanticContext;
-    ofTranslationTextTemplate(node: tree.TranslationTextTemplate): TranslationTextTemplateSemanticContext;
     private containingInternal;
     private ofChildOfFunctionDeclaration;
     private ofChildOfTypeDeclarationWithMemberBlock;

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

@@ -1,7 +1,7 @@
 import { Name } from '../../common/index.js';
 import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
 import { IEntityHidingMatcher } from '../../entities/EntityHiding.js';
-import { LocalVariableEntity, NestedFunctionEntity, ParameterEntity, TextTemplateParameterEntity, TypeParameterEntity } from '../../entities/index.js';
+import { LocalVariableEntity, NestedFunctionEntity, ParameterEntity, TypeParameterEntity } from '../../entities/index.js';
 import * as tree from '../../tree/index.js';
 import { Analyzer } from '../Analyzer.js';
 import { NamedDeclaration, TypeOrContainerWithTypes } from './Declarations.js';
@@ -14,12 +14,12 @@ export declare abstract class SemanticContextValidatingNameConflictsBase extends
     abstract readonly outer: SemanticContext;
     abstract readonly node: tree.Node;
     protected readonly analyzer: Analyzer;
-    private readonly memberEntities_;
+    private memberEntities_;
     private memberEntitiesByNameKey;
-    private readonly namedDeclarations_;
-    private readonly typesOrContainerWithTypes_;
-    private readonly namedDeclarationsByName_;
-    private readonly typesOrContainerWithTypesByName_;
+    private namedDeclarations_;
+    private typesOrContainerWithTypes_;
+    private namedDeclarationsByName_;
+    private typesOrContainerWithTypesByName_;
     private get memberEntities();
     private get namedDeclarations();
     private get typesOrContainerWithTypes();
@@ -38,5 +38,5 @@ export declare abstract class SemanticContextValidatingNameConflictsBase extends
     private createNamedDeclarations;
     private createTypesOrContainerWithTypes;
 }
-export type MemberOfSemanticContextValidatingNameConflicts = LocalVariableEntity | ParameterEntity | TextTemplateParameterEntity | NestedFunctionEntity | TypeParameterEntity;
+export type MemberOfSemanticContextValidatingNameConflicts = LocalVariableEntity | ParameterEntity | NestedFunctionEntity | TypeParameterEntity;
 export type MemberOfSemanticContextValidatingNameConflictsForTypeLookup = TypeParameterEntity;

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

@@ -19,5 +19,6 @@ export declare class SpecialLocalDeclarationsBuilder {
     static buildForConstructorDeclaration(analyzer: Analyzer, node: tree.ConstructorDeclaration): readonly SpecialLocalDeclarationEntity[];
     static buildForMethodDeclaration(analyzer: Analyzer, node: tree.MethodDeclaration): readonly SpecialLocalDeclarationEntity[];
     static buildForOperatorDeclaration(analyzer: Analyzer, node: tree.OperatorDeclaration): readonly SpecialLocalDeclarationEntity[];
+    static buildForTextTranslationFunctionDeclaration(analyzer: Analyzer, node: tree.TextTranslationFunctionDeclaration): readonly SpecialLocalDeclarationEntity[];
 }
 export {};

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

@@ -1,9 +1,12 @@
 import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import { ParameterEntity } from '../../entities/index.js';
+import { ReservedIdentifierKind } from '../../parser/ReservedIdentifierDictionary.js';
 import * as tree from '../../tree/index.js';
 import { Analyzer } from '../Analyzer.js';
 import { SemanticContext } from './SemanticContext.js';
 import { TryStatementContextKind } from './SemanticContextBase.js';
 import { MemberOfSemanticContextValidatingNameConflicts, MemberOfSemanticContextValidatingNameConflictsForTypeLookup, SemanticContextValidatingNameConflictsBase } from './SemanticContextValidatingNameConflicts.js';
+import { SourceFileSemanticContext } from './SourceFileSemanticContext.js';
 import { OutermostSemanticContextOfSubprogram } from './SubprogramSemanticContext.js';
 export type SubprogramTypeParameterSemanticContextParent = OutermostSemanticContextOfSubprogram;
 export declare class SubprogramTypeParameterSemanticContext extends SemanticContextValidatingNameConflictsBase {
@@ -16,24 +19,43 @@ export declare class SubprogramTypeParameterSemanticContext extends SemanticCont
     protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
     protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
 }
-export type SubprogramParameterSemanticContextParent = SubprogramTypeParameterSemanticContext | OutermostSemanticContextOfSubprogram;
-export declare abstract class SubprogramParameterSemanticContext extends SemanticContextValidatingNameConflictsBase {
-    readonly kind = "subprogram-parameter";
-    readonly outer: SubprogramParameterSemanticContextParent;
-    constructor(analyzer: Analyzer, outer: SubprogramParameterSemanticContextParent);
+export type SubprogramParameterListSemanticContextParent = SubprogramTypeParameterSemanticContext | OutermostSemanticContextOfSubprogram | SourceFileSemanticContext;
+export declare abstract class SubprogramParameterListSemanticContext extends SemanticContextValidatingNameConflictsBase {
+    readonly kind = "subprogram-parameter-list";
+    readonly outer: SubprogramParameterListSemanticContextParent;
+    constructor(analyzer: Analyzer, outer: SubprogramParameterListSemanticContextParent);
+    protected abstract get isSetterParameterList(): boolean;
+    protected abstract getParameterEntities(): readonly ParameterEntity[];
+    protected abstract getSpecialVariableKinds(): readonly ReservedIdentifierKind[];
+    validateNameConflicts(diagnostics: DiagnosticAcceptor): void;
 }
-export declare class ExplicitSubprogramParameterSemanticContext extends SubprogramParameterSemanticContext {
+export declare class ExplicitSubprogramParameterListSemanticContext extends SubprogramParameterListSemanticContext {
     readonly node: tree.ParameterList;
     protected readonly asContext: SemanticContext;
-    constructor(analyzer: Analyzer, node: tree.ParameterList, outer: SubprogramParameterSemanticContextParent);
-    validateNameConflicts(diagnostics: DiagnosticAcceptor): void;
+    constructor(analyzer: Analyzer, node: tree.ParameterList, outer: SubprogramParameterListSemanticContextParent);
+    protected get isSetterParameterList(): boolean;
+    protected getParameterEntities(): readonly ParameterEntity[];
+    protected getSpecialVariableKinds(): readonly ReservedIdentifierKind[];
     protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
     protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
 }
-export declare class FunctionBlockLiteralParameterSemanticContext extends SubprogramParameterSemanticContext {
+export declare class FunctionBlockLiteralParameterListSemanticContext extends SubprogramParameterListSemanticContext {
     readonly node: tree.FunctionBlockLiteral;
     protected readonly asContext: SemanticContext;
-    constructor(analyzer: Analyzer, node: tree.FunctionBlockLiteral, outer: SubprogramParameterSemanticContextParent);
+    constructor(analyzer: Analyzer, node: tree.FunctionBlockLiteral, outer: SubprogramParameterListSemanticContextParent);
+    protected get isSetterParameterList(): boolean;
+    protected getParameterEntities(): readonly ParameterEntity[];
+    protected getSpecialVariableKinds(): readonly ReservedIdentifierKind[];
+    protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
+    protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
+}
+export declare class TranslationTextTemplateParameterListSemanticContext extends SubprogramParameterListSemanticContext {
+    readonly node: tree.TranslationTextTemplate;
+    protected readonly asContext: SemanticContext;
+    constructor(analyzer: Analyzer, node: tree.TranslationTextTemplate, outer: SubprogramParameterListSemanticContextParent);
+    protected get isSetterParameterList(): boolean;
+    protected getParameterEntities(): readonly ParameterEntity[];
+    protected getSpecialVariableKinds(): readonly ReservedIdentifierKind[];
     protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
     protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
 }
@@ -49,7 +71,7 @@ export declare class StatementBlockSemanticContext extends SemanticContextValida
     protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
     protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
 }
-export type FunctionBlockSemanticContextParent = SubprogramParameterSemanticContext | OutermostSemanticContextOfSubprogram | SpecialLocalDeclarationSemanticContext;
+export type FunctionBlockSemanticContextParent = SubprogramParameterListSemanticContext | OutermostSemanticContextOfSubprogram | SpecialLocalDeclarationSemanticContext;
 export declare class FunctionBlockSemanticContext extends SemanticContextValidatingNameConflictsBase {
     readonly kind = "function-block";
     readonly outer: FunctionBlockSemanticContextParent;
@@ -59,7 +81,7 @@ export declare class FunctionBlockSemanticContext extends SemanticContextValidat
     protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
     protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
 }
-export type SpecialLocalDeclarationSemanticContextParent = SubprogramParameterSemanticContext | OutermostSemanticContextOfSubprogram;
+export type SpecialLocalDeclarationSemanticContextParent = SubprogramParameterListSemanticContext | OutermostSemanticContextOfSubprogram;
 export declare class SpecialLocalDeclarationSemanticContext extends SemanticContextValidatingNameConflictsBase {
     readonly kind = "special-local-declaration";
     readonly outer: SpecialLocalDeclarationSemanticContextParent;

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

@@ -111,3 +111,12 @@ export declare class FunctionLiteralSemanticContext extends OutermostSemanticCon
     constructor(analyzer: Analyzer, node: RegularOrBlockFunctionLiteral, outer: SemanticContext);
     getContainingSubprogram(): SubprogramInfo;
 }
+export declare class TextTranslationFunctionDeclarationSemanticContext extends OutermostSemanticContextOfSubprogram {
+    readonly outer: SemanticContext;
+    protected readonly asContext: SemanticContext;
+    private readonly analyzer;
+    private readonly node;
+    private readonly subprogramInfo;
+    constructor(analyzer: Analyzer, node: tree.TextTranslationFunctionDeclaration, outer: SemanticContext);
+    getContainingSubprogram(): SubprogramInfo;
+}

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

@@ -58,4 +58,5 @@ export declare abstract class Query<T> implements Iterable<T> {
     single(): T | undefined;
     single<K extends T>(fn: (t: T) => t is K): K | undefined;
     single(fn: (t: T) => boolean): T | undefined;
+    indexOf(t: T): number;
 }

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

@@ -35,6 +35,7 @@ export declare enum DiagnosticCode {
     TypeMemberTranslationExpected = 129,
     TranslationExpected = 130,
     TranslatedTextTemplateOrTranslationFunctionBlockExpected = 131,
+    TranslatedTextCannotBeginOrEndWithTilde = 132,
     TypeCannotBeUsedAsValue = 201,
     PackageNameCannotBeUsedAsValue = 202,
     PackageAliasCannotBeUsedAsValue = 203,

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

@@ -35,4 +35,7 @@ export declare class EmitPhaseName {
     static ofTypeExtension(locale: PackageLocale, extendedTypeName: string): string;
     static ofOperator(locale: PackageLocale, kind: OperatorKind): string;
     static ofSetterParameter(locale: PackageLocale): string;
+    static ofDictionaryLocalVariable(locale: PackageLocale): string;
+    static ofThisPackageVariable(locale: PackageLocale): string;
+    static ofTranslationFunctionValuesParameter(locale: PackageLocale): string;
 }

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

@@ -30,12 +30,11 @@ export declare class Emitter {
 }
 export declare class EmitterPackage {
     ir: ir.Package;
-    entity: PackageEntity;
     outputUri: Uri;
     packageLevelNames: ReadonlySet<string>;
     entityNameOverrides: ReadonlyMap<NamedEntity, string> | undefined;
     private referencedPackageMembers;
-    constructor(ir: ir.Package, entity: PackageEntity);
+    constructor(ir: ir.Package);
     getReferencedPackageMembers(): ReferencedPackageMembers;
 }
 export interface OutputAcceptor {

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

@@ -139,6 +139,11 @@ export declare class PackageEntityDetails {
     isJavaScriptPackage: JavaScriptImplementationConfig | undefined;
     isSource: boolean;
     isPackageWithMainFunction: boolean;
+    isTextTranslationPackage: boolean;
+    textTranslationLocale: PackageLocale | undefined;
+    translationTarget: PackageEntity | undefined;
+    thisPackageVariableEntity: VariableEntity | undefined;
+    isMainPackage: boolean;
 }
 export type Type = SimpleType | UnionOrIntersectionType;
 export declare class SimpleType {

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

@@ -1,8 +1,7 @@
 import { EmitterPackage } from './Emitter.js';
 import { EmitterContext } from './EmitterContext.js';
 export declare class GeneralLowering {
-    private readonly ectx;
-    private readonly packages;
+    private readonly ctx;
     constructor(ectx: EmitterContext, packages: readonly EmitterPackage[]);
     lower(): void;
 }

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

@@ -121,7 +121,7 @@ export declare class IrBuilder {
     private generateLoopLabel;
     private buildTextTranslationDeclarationList;
     private buildTextTranslationDeclaration;
-    private createTranslationTextTemplate;
+    private buildTextTranslationFunctionDeclaration;
     private getSourceLocation;
 }
 export interface IrBuilderParams {

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

@@ -0,0 +1,12 @@
+import { EmitterContext } from './EmitterContext.js';
+import { FunctionEntity, VariableEntity } from './Entities.js';
+import * as ir from './ir/index.js';
+export declare function instanceMethodCallExpression(expression: ir.Expression, method: FunctionEntity | ir.AccessedFunction, args: readonly ir.Expression[] | ir.Arguments, isOptionalAccess: boolean, sourceLocation?: ir.SourceLocation): ir.CallExpression;
+export declare function staticMethodCallExpression(method: FunctionEntity | ir.AccessedFunction, args: readonly ir.Expression[] | ir.Arguments, sourceLocation?: ir.SourceLocation): ir.CallExpression;
+export declare function constructorCallExpression(ectx: EmitterContext, constructor: FunctionEntity, args: readonly ir.Expression[] | ir.Arguments, sourceLocation?: ir.SourceLocation): ir.ConstructorCallExpression;
+export declare function variableGetAccess(variable: VariableEntity | ir.AccessedVariable, sourceLocation?: ir.SourceLocation): ir.VariableAccessExpression;
+export declare function instanceFieldGetAccess(expression: ir.Expression, variable: VariableEntity | ir.AccessedVariable, isOptionalAccess: boolean, sourceLocation?: ir.SourceLocation): ir.FieldAccessExpression;
+export declare function staticFieldGetAccess(variable: VariableEntity | ir.AccessedVariable, sourceLocation?: ir.SourceLocation): ir.FieldAccessExpression;
+export declare function variableSetAccess(variable: VariableEntity | ir.AccessedVariable, sourceLocation?: ir.SourceLocation): ir.VariableAccessExpression;
+export declare function instanceFieldSetAccess(expression: ir.Expression, variable: VariableEntity | ir.AccessedVariable, isOptionalAccess: boolean, sourceLocation?: ir.SourceLocation): ir.FieldAccessExpression;
+export declare function staticFieldSetAccess(variable: VariableEntity | ir.AccessedVariable, sourceLocation?: ir.SourceLocation): ir.FieldAccessExpression;