@artel/artc 0.6.25268 → 0.6.25269

package/build/{chunk-SXWZFJ3Z.js → chunk-A5H2QLXZ.js}

@@ -78,10 +78,10 @@ var PackageDialect = /* @__PURE__ */ ((PackageDialect45) => {
 })(PackageDialect || {});
 
 // source/common/PackageLocale.ts
-var PackageLocale = /* @__PURE__ */ ((PackageLocale51) => {
-  PackageLocale51[PackageLocale51["En"] = 0] = "En";
-  PackageLocale51[PackageLocale51["Ru"] = 1] = "Ru";
-  return PackageLocale51;
+var PackageLocale = /* @__PURE__ */ ((PackageLocale52) => {
+  PackageLocale52[PackageLocale52["En"] = 0] = "En";
+  PackageLocale52[PackageLocale52["Ru"] = 1] = "Ru";
+  return PackageLocale52;
 })(PackageLocale || {});
 var locales = [
   { locale: 0 /* En */, code: "en", names: ["english", "\u0430\u043D\u0433\u043B\u0438\u0439\u0441\u043A\u0438\u0439"] },
@@ -702,7 +702,7 @@ var UniqueWithComparatorQuery = class extends Query {
 };
 
 // source/common/Constants.ts
-var ArtelVersion = true ? "0.6.25268" : "";
+var ArtelVersion = true ? "0.6.25269" : "";
 var ArtelSourceFileExtensions = [".\u0430\u0440\u0442", ".\u0430\u0440\u0442\u0435\u043B\u044C", ".art", ".artel"];
 var ArtelSourceFileExtensionSet = new Set(ArtelSourceFileExtensions);
 var ArtelSourceAndConfigurationFileExtensionSet = new Set(ArtelSourceFileExtensionSet).add(".json");
@@ -823,11 +823,11 @@ var performanceMeasurementStageNames = {
 };
 
 // source/common/AccessKind.ts
-var AccessKind = /* @__PURE__ */ ((AccessKind2) => {
-  AccessKind2[AccessKind2["Get"] = 0] = "Get";
-  AccessKind2[AccessKind2["Set"] = 1] = "Set";
-  AccessKind2[AccessKind2["GetSet"] = 2] = "GetSet";
-  return AccessKind2;
+var AccessKind = /* @__PURE__ */ ((AccessKind3) => {
+  AccessKind3[AccessKind3["Get"] = 0] = "Get";
+  AccessKind3[AccessKind3["Set"] = 1] = "Set";
+  AccessKind3[AccessKind3["GetSet"] = 2] = "GetSet";
+  return AccessKind3;
 })(AccessKind || {});
 
 // source/common/ArrayUtils.ts
@@ -11545,13 +11545,13 @@ var DeclarationContainer;
     }
   }
   DeclarationContainer2.TypeExtension = TypeExtension;
-  class Package3 {
+  class Package2 {
     constructor(entity) {
       this.entity = entity;
       this.kind = "package";
     }
   }
-  DeclarationContainer2.Package = Package3;
+  DeclarationContainer2.Package = Package2;
 })(DeclarationContainer || (DeclarationContainer = {}));
 var FunctionDeclarationDisplayParts = class {
   constructor(asyncKeywordWithWhitespace, functionKeyword, whitespaceAfterFunctionKeyword, container, name, typeParametersStart, typeParameters, typeParameterSeparator, typeParametersEnd, parametersStart, parameters, parameterSeparator, parametersEnd, returnTypeAnnotationColon, returnType) {
@@ -25362,10 +25362,10 @@ var SourcePackageMembersCreator = class {
 
 // source/ts-interop/TsPackageMembersCreator.ts
 var TsPackageMembersCreator = class {
-  constructor(tsctx, symbols, packageEntity, sourcePackageToMergeWith, forceMembersAreHiddenInPackage = false) {
+  constructor(tsctx, symbols, packageEntity2, sourcePackageToMergeWith, forceMembersAreHiddenInPackage = false) {
     this.tsctx = tsctx;
     this.symbols = symbols;
-    this.packageEntity = packageEntity;
+    this.packageEntity = packageEntity2;
     this.sourcePackageToMergeWith = sourcePackageToMergeWith;
     this.forceMembersAreHiddenInPackage = forceMembersAreHiddenInPackage;
     this.typeEntityBySymbol = /* @__PURE__ */ new Map();
@@ -25752,10 +25752,10 @@ var TsPackageMembersCreationResult = class {
 
 // source/ts-interop/TsPackageContents.ts
 var TsPackageContents = class {
-  constructor(tsctx, symbols, packageEntity, sourcePackageToMergeWith) {
+  constructor(tsctx, symbols, packageEntity2, sourcePackageToMergeWith) {
     this.tsctx = tsctx;
     this.symbols = symbols;
-    this.packageEntity = packageEntity;
+    this.packageEntity = packageEntity2;
     this.sourcePackageToMergeWith = sourcePackageToMergeWith;
     this.kind = "module";
     this.membersCreationResult = new Cached();
@@ -30679,8 +30679,8 @@ var TranslatedName = class {
   }
 };
 var ReferencedPackagesCollector = class {
-  constructor(packageEntity) {
-    this.packageEntity = packageEntity;
+  constructor(packageEntity2) {
+    this.packageEntity = packageEntity2;
     this.referencedPackages = /* @__PURE__ */ new Set();
   }
   collect() {
@@ -35536,8 +35536,8 @@ var OwnAndBaseConstructorCallsChecker = class {
       baseConstructorWithoutParameters = searchResult.constructor;
       baseTypeHasAccessibleConstructors = searchResult.hasAccessibleConstructors;
     }
-    for (const constructorDeclaration of this.constructorDeclarations) {
-      const block = constructorDeclaration.block;
+    for (const constructorDeclaration2 of this.constructorDeclarations) {
+      const block = constructorDeclaration2.block;
       if (block === void 0) {
         continue;
       }
@@ -35549,7 +35549,7 @@ var OwnAndBaseConstructorCallsChecker = class {
           isFirstStatementOwnOrBaseConstructorCall = true;
           const meaning = this.analyzer.resolveObjectExpression(callee).meaning;
           if (meaning.kind === "own-constructor-access" && meaning.singleConstructor !== void 0) {
-            const entity = this.analyzer.entity.ofConstructorDeclaration(constructorDeclaration);
+            const entity = this.analyzer.entity.ofConstructorDeclaration(constructorDeclaration2);
             this.addOwnConstructorCallOrReportCycleDiagnostic(
               entity,
               meaning.singleConstructor.getEntity(),
@@ -35562,19 +35562,19 @@ var OwnAndBaseConstructorCallsChecker = class {
           isFirstStatementOwnOrBaseConstructorCall = true;
           const meaning = this.analyzer.resolveBaseExpression(callee).meaning;
           if (meaning.kind === "base-constructor-access" && meaning.singleConstructor !== void 0) {
-            const entity = this.analyzer.entity.ofConstructorDeclaration(constructorDeclaration);
+            const entity = this.analyzer.entity.ofConstructorDeclaration(constructorDeclaration2);
             baseConstructorCalls.set(entity, meaning.singleConstructor);
           }
         }
       }
       if (!isFirstStatementOwnOrBaseConstructorCall) {
         if (baseConstructorWithoutParameters !== void 0) {
-          const entity = this.analyzer.entity.ofConstructorDeclaration(constructorDeclaration);
+          const entity = this.analyzer.entity.ofConstructorDeclaration(constructorDeclaration2);
           baseConstructorCalls.set(entity, baseConstructorWithoutParameters);
         } else if (baseTypeHasAccessibleConstructors) {
           diagnostics.push(this.analyzer.createNodeDiagnostic(
             359 /* TheFirstStatementOfConstructorBlockMustBeEitherBaseOrOwnConstructorCall */,
-            constructorDeclaration.creationKeyword
+            constructorDeclaration2.creationKeyword
           ));
         }
       }
@@ -36818,14 +36818,14 @@ var PackageAndStaticVariablesInitializationValidator = class {
     this.diagnostics = diagnostics;
   }
   validate() {
-    const packageEntity = this.analyzer.entity.ofPackage(this.package_);
-    const variables = this.getVariablesThatNeedToBeInitializedInConstructor(packageEntity);
+    const packageEntity2 = this.analyzer.entity.ofPackage(this.package_);
+    const variables = this.getVariablesThatNeedToBeInitializedInConstructor(packageEntity2);
     if (variables.length === 0) {
       return;
     }
     const constructorDeclarations = this.package_.sourceFiles.flatMap((f) => Query.from(flattenPackageMemberDeclarationList(f.getSyntaxNode().declarationList)).filter((d) => d.kind === 23 /* PackageConstructorDeclaration */).toArray());
-    for (const constructorDeclaration of constructorDeclarations) {
-      this.excludeVariablesInitializedInConstructor(constructorDeclaration, variables);
+    for (const constructorDeclaration2 of constructorDeclarations) {
+      this.excludeVariablesInitializedInConstructor(constructorDeclaration2, variables);
       if (variables.length === 0) {
         break;
       }
@@ -36834,9 +36834,9 @@ var PackageAndStaticVariablesInitializationValidator = class {
       this.reportNotInitialedVariableDiagnostic(variable);
     }
   }
-  getVariablesThatNeedToBeInitializedInConstructor(packageEntity) {
+  getVariablesThatNeedToBeInitializedInConstructor(packageEntity2) {
     const result = new Array();
-    for (const member of packageEntity.getMembers().getNamedMembers()) {
+    for (const member of packageEntity2.getMembers().getNamedMembers()) {
       if (member.kind === 0 /* Variable */ && !isComputedVariableEntity(member) && !this.analyzer.isNullAssignableToType(member.getType())) {
         const definition = member.getDefinition();
         if (definition.kind === 0 /* Source */) {
@@ -37533,11 +37533,11 @@ var Resolver10 = class {
       }
     }
     if (resolvedQualifier === void 0) {
-      const packageEntity = qualifier.kind === "package-alias" ? qualifier.packageAlias.getPackage() : qualifier.packageTreeNode.package;
-      if (packageEntity === void 0) {
+      const packageEntity2 = qualifier.kind === "package-alias" ? qualifier.packageAlias.getPackage() : qualifier.packageTreeNode.package;
+      if (packageEntity2 === void 0) {
         diagnostic = this.analyzer.createNodeDiagnostic(289 /* TagNotFound */, nodeForDiagnostic);
       } else {
-        const lookup = new PackageMemberLookup(packageEntity);
+        const lookup = new PackageMemberLookup(packageEntity2);
         const declarations = lookup.getNamedMembersByName(name, this.semanticContext.getHidingMatcher());
         if (declarations.length === 0) {
           diagnostic = this.analyzer.createNodeDiagnostic(289 /* TagNotFound */, nodeForDiagnostic);
@@ -37736,9 +37736,9 @@ var DisplayableEntity = class {
   }
 };
 var DisplayableAccessedFunction = class {
-  constructor(analyzer, accessedFunction, locale, dialect, contextualSourceFile) {
+  constructor(analyzer, accessedFunction2, locale, dialect, contextualSourceFile) {
     this.analyzer = analyzer;
-    this.accessedFunction = accessedFunction;
+    this.accessedFunction = accessedFunction2;
     this.locale = locale;
     this.dialect = dialect;
     this.contextualSourceFile = contextualSourceFile;
@@ -37800,10 +37800,10 @@ var DiagnosticArgumentFactory = class {
   createDisplayableEntity(entity) {
     return new DisplayableEntity(this.analyzer, entity, this.locale, this.dialect, this.contextualSourceFile);
   }
-  createDisplayableAccessedFunction(accessedFunction) {
+  createDisplayableAccessedFunction(accessedFunction2) {
     return new DisplayableAccessedFunction(
       this.analyzer,
-      accessedFunction,
+      accessedFunction2,
       this.locale,
       this.dialect,
       this.contextualSourceFile
@@ -38782,7 +38782,7 @@ var SubprogramInfo;
     }
   }
   SubprogramInfo6.PackageEntryPoint = PackageEntryPoint;
-  class FunctionLiteral4 {
+  class FunctionLiteral3 {
     constructor(analyzer, node) {
       this.kind = "function-literal";
       this.analyzer = analyzer;
@@ -38812,7 +38812,7 @@ var SubprogramInfo;
       }
     }
   }
-  SubprogramInfo6.FunctionLiteral = FunctionLiteral4;
+  SubprogramInfo6.FunctionLiteral = FunctionLiteral3;
   class TextTranslationFunction {
     constructor(analyzer, node) {
       this.kind = "text-translation-function";
@@ -39874,11 +39874,11 @@ var SourceFileSemanticContext = class extends SemanticContextBase {
   }
   getDiagnosticArgumentFactory() {
     return this.diagnosticArgumentFactory.getOrInsertWith(() => {
-      const packageEntity = this.getPackage();
+      const packageEntity2 = this.getPackage();
       return new DiagnosticArgumentFactory(
         this.analyzer,
-        packageEntity.getLocale(),
-        packageEntity.getDialect(),
+        packageEntity2.getLocale(),
+        packageEntity2.getDialect(),
         this.sourceFile
       );
     });
@@ -41926,11 +41926,11 @@ var Analyzer13 = class {
       const type = this.type.ofFunctionBlockLiteral(node);
       result = this.parametersOfFunctionBlockLiterals.get(node);
       if (result === void 0) {
-        const packageEntity = TreeQuery.getPackageEntity(node, this);
+        const packageEntity2 = TreeQuery.getPackageEntity(node, this);
         result = type.getParameters().map((p) => new IntrinsicParameterEntity(
           p.getEntity().getName(),
           p.getType(),
-          packageEntity,
+          packageEntity2,
           p.isOptional(),
           p.isVariadic(),
           new ImplicitFunctionBlockParameterSpecialVariableEntityInfo(p, node)
@@ -42023,11 +42023,11 @@ var Analyzer13 = class {
     let result = this.linkedMultiPlatformPackagesByPlatform.get(entity);
     if (result === void 0) {
       const packageByPlatform = /* @__PURE__ */ new Map();
-      for (const packageEntity of this.getOriginalPackageEntities()) {
-        const implementedPackage = packageEntity.getImplementedInterfacePackage();
+      for (const packageEntity2 of this.getOriginalPackageEntities()) {
+        const implementedPackage = packageEntity2.getImplementedInterfacePackage();
         if (implementedPackage === entity) {
-          for (const platform of packageEntity.getSupportedPlatforms()) {
-            const linkedPackage = new LinkedMultiPlatformPackage(this, entity, packageEntity, platform);
+          for (const platform of packageEntity2.getSupportedPlatforms()) {
+            const linkedPackage = new LinkedMultiPlatformPackage(this, entity, packageEntity2, platform);
             packageByPlatform.set(platform, linkedPackage);
           }
         }
@@ -42832,15 +42832,15 @@ var Analyzer13 = class {
             return this.getNodeDiagnosticLocation(definition.value.nodes[0].name);
           } else if (definition.value.nodes.length > 1) {
             if (definition.value.nodes.every((n) => n.kind === 151 /* ParameterDeclaration */)) {
-              let parameterDeclaration;
+              let parameterDeclaration2;
               const setterParameterDeclaration = definition.value.nodes.find((n) => n.parent.parent.parent.kind === 46 /* IndexedElementSetterDeclaration */);
               if (chooseSetter) {
-                parameterDeclaration = setterParameterDeclaration;
+                parameterDeclaration2 = setterParameterDeclaration;
               } else {
                 const getterParameterDeclaration = definition.value.nodes.find((n) => n.parent.parent.parent.kind === 45 /* IndexedElementGetterDeclaration */);
-                parameterDeclaration = getterParameterDeclaration ?? setterParameterDeclaration;
+                parameterDeclaration2 = getterParameterDeclaration ?? setterParameterDeclaration;
               }
-              return parameterDeclaration !== void 0 ? this.getNodeDiagnosticLocation(parameterDeclaration.name) : void 0;
+              return parameterDeclaration2 !== void 0 ? this.getNodeDiagnosticLocation(parameterDeclaration2.name) : void 0;
             } else {
               return this.getNodeDiagnosticLocation(definition.value.nodes[0].name);
             }
@@ -43194,13 +43194,13 @@ var WellKnownDeclarationsLoader = class {
       javaScriptDecorator: this.findPackageType(interopPackage, new Name("\u0414\u0435\u043A\u043E\u0440\u0430\u0442\u043E\u0440\u0414\u0436\u0430\u0432\u0430\u0421\u043A\u0440\u0438\u043F\u0442"), 0, 1 /* Structured */)
     };
   }
-  findPackageType(packageEntity, name, arity, typeEntityKind) {
-    const type = packageEntity.getMembers().getNamedMembersByName(name).filter((d) => d.kind === 2 /* Type */ && d.typeEntityKind === typeEntityKind).filter((t) => t.getArity() === arity).at(0);
+  findPackageType(packageEntity2, name, arity, typeEntityKind) {
+    const type = packageEntity2.getMembers().getNamedMembersByName(name).filter((d) => d.kind === 2 /* Type */ && d.typeEntityKind === typeEntityKind).filter((t) => t.getArity() === arity).at(0);
     if (type === void 0) {
       throw new WellKnownDeclarationsLoadError(new Diagnostic(
         DiagnosticData.withCode(
           406 /* Declaration0NotFoundInStandardPackage1 */,
-          [name.unescapedOriginal, packageEntity.getName().toString()]
+          [name.unescapedOriginal, packageEntity2.getName().toString()]
         ),
         void 0
       ));
@@ -45292,10 +45292,10 @@ var SourceFileMembersMap = class {
             Debug.never(d);
         }
       }
-      const packageEntity = TreeQuery.getPackageEntity(node, this.analyzer);
-      const isInterfacePackageFile = packageEntity.getInterfacePackageInfo() !== void 0;
+      const packageEntity2 = TreeQuery.getPackageEntity(node, this.analyzer);
+      const isInterfacePackageFile = packageEntity2.getInterfacePackageInfo() !== void 0;
       if (!isInterfacePackageFile) {
-        const backingVariables = this.analyzer.createBackingPackageVariables(namedMembers, packageEntity);
+        const backingVariables = this.analyzer.createBackingPackageVariables(namedMembers, packageEntity2);
         namedMembers.push(...backingVariables);
       }
       result = new SourceFileMembers(this.analyzer, namedMembers, typeExtensionEntities);
@@ -47589,8 +47589,8 @@ var InstanceFieldsInitializationValidator = class {
           this.diagnostics.addDiagnostic(new Diagnostic(data, location));
         }
       } else {
-        for (const constructorDeclaration of declaredConstructors) {
-          this.checkConstructorInitializesAllFields(constructorDeclaration, fields);
+        for (const constructorDeclaration2 of declaredConstructors) {
+          this.checkConstructorInitializesAllFields(constructorDeclaration2, fields);
         }
       }
     }
@@ -48629,11 +48629,11 @@ var DiagnosticCollector = class _DiagnosticCollector {
     );
     const targetType = this.analyzer.getTargetTypeOfExpression(node);
     if (targetType === void 0) {
-      for (const parameterDeclaration of node.parameterClause.parameterList.parameters) {
-        if (parameterDeclaration.typeAnnotation === void 0) {
+      for (const parameterDeclaration2 of node.parameterClause.parameterList.parameters) {
+        if (parameterDeclaration2.typeAnnotation === void 0) {
           this.addDiagnostic(this.analyzer.createNodeDiagnostic(
             372 /* CannotInferTypeOfFunctionLiteralAddTypeSpecifierForParameter */,
-            parameterDeclaration.name
+            parameterDeclaration2.name
           ));
         }
       }
@@ -50123,16 +50123,16 @@ var SourcePackageDependencyGraph = class {
         }
       }
     }
-    for (const [packageEntity, translationPackages] of translationPackagesByImportedPackage) {
-      const definition = packageEntity.getDefinition();
+    for (const [packageEntity2, translationPackages] of translationPackagesByImportedPackage) {
+      const definition = packageEntity2.getDefinition();
       if (definition.kind !== 0 /* Source */) {
         continue;
       }
       const node = this.getNodeForPackage(definition.package);
       const translationPackageArray = Array.from(translationPackages);
       const implementationPackagesByPlatformKind = /* @__PURE__ */ new Map();
-      if (packageEntity.getInterfacePackageInfo()?.kind === "multi-platform") {
-        const linkedMultiPlatformPackagesByPlatform = this.analyzer.getLinkedMultiPlatformPackagesByPlatform(packageEntity);
+      if (packageEntity2.getInterfacePackageInfo()?.kind === "multi-platform") {
+        const linkedMultiPlatformPackagesByPlatform = this.analyzer.getLinkedMultiPlatformPackagesByPlatform(packageEntity2);
         if (linkedMultiPlatformPackagesByPlatform !== void 0) {
           for (const [platform, linkedPackage] of linkedMultiPlatformPackagesByPlatform) {
             const linkedPackageDefinition = linkedPackage.implementationPackage.getDefinition();
@@ -51665,8 +51665,8 @@ var EntityHidingLevel_file = class {
   }
 };
 var EntityHidingLevel_package = class {
-  constructor(packageEntity) {
-    this.packageEntity = packageEntity;
+  constructor(packageEntity2) {
+    this.packageEntity = packageEntity2;
     this.kind = "package";
   }
 };
@@ -56485,26 +56485,27 @@ var CommaExpression = class _CommaExpression {
   }
 };
 var ConstructorCallExpression = class _ConstructorCallExpression {
-  constructor(entity, containingTypeOfConstructor, typeAccess, args, returnType, sourceLocation, options = ConstructorCallExpressionEmitOptions.default()) {
+  constructor(entity, typeAccess, args, returnType, sourceLocation) {
     this.entity = entity;
-    this.containingTypeOfConstructor = containingTypeOfConstructor;
     this.typeAccess = typeAccess;
     this.args = args;
     this.returnType = returnType;
     this.sourceLocation = sourceLocation;
-    this.options = options;
     this.kind = 72 /* ConstructorCallExpression */;
+    this.options = ConstructorCallExpressionEmitOptions.default();
+  }
+  withOptions(options) {
+    this.options = options;
+    return this;
   }
   clone() {
     return new _ConstructorCallExpression(
       this.entity,
-      this.containingTypeOfConstructor,
       this.typeAccess.clone(),
       this.args.clone(),
       this.returnType,
-      this.sourceLocation,
-      this.options.clone()
-    );
+      this.sourceLocation
+    ).withOptions(this.options.clone());
   }
 };
 var ContinueLoopStatement2 = class _ContinueLoopStatement {
@@ -57161,11 +57162,10 @@ var CaseClause2 = class _CaseClause {
   }
 };
 var TernaryExpression = class _TernaryExpression {
-  constructor(condition, firstExpression, secondExpression, type, sourceLocation) {
+  constructor(condition, firstExpression, secondExpression, sourceLocation) {
     this.condition = condition;
     this.firstExpression = firstExpression;
     this.secondExpression = secondExpression;
-    this.type = type;
     this.sourceLocation = sourceLocation;
     this.kind = 58 /* TernaryExpression */;
   }
@@ -57174,7 +57174,6 @@ var TernaryExpression = class _TernaryExpression {
       this.condition.clone(),
       this.firstExpression.clone(),
       this.secondExpression.clone(),
-      this.type,
       this.sourceLocation
     );
   }
@@ -57211,39 +57210,45 @@ var TextWithEntityName = class _TextWithEntityName {
   }
 };
 var TextTemplateLiteral2 = class _TextTemplateLiteral {
-  constructor(textFragments, expressions, sourceLocation, options = TextTemplateEmitOptions.default()) {
+  constructor(textFragments, expressions, sourceLocation) {
     this.textFragments = textFragments;
     this.expressions = expressions;
     this.sourceLocation = sourceLocation;
-    this.options = options;
     this.kind = 47 /* TextTemplateLiteral */;
+    this.options = TextTemplateEmitOptions.default();
+  }
+  withOptions(options) {
+    this.options = options;
+    return this;
   }
   clone() {
     return new _TextTemplateLiteral(
       this.textFragments,
       this.expressions.map((e) => e.clone()),
-      this.sourceLocation,
-      this.options.clone()
-    );
+      this.sourceLocation
+    ).withOptions(this.options.clone());
   }
 };
 var LocalizableTextTemplateLiteral2 = class _LocalizableTextTemplateLiteral {
-  constructor(textFragments, expressions, code, sourceLocation, options = TextTemplateEmitOptions.default()) {
+  constructor(textFragments, expressions, code, sourceLocation) {
     this.textFragments = textFragments;
     this.expressions = expressions;
     this.code = code;
     this.sourceLocation = sourceLocation;
-    this.options = options;
     this.kind = 48 /* LocalizableTextTemplateLiteral */;
+    this.options = TextTemplateEmitOptions.default();
+  }
+  withOptions(options) {
+    this.options = options;
+    return this;
   }
   clone() {
     return new _LocalizableTextTemplateLiteral(
       this.textFragments,
       this.expressions.map((e) => e.clone()),
       this.code,
-      this.sourceLocation,
-      this.options.clone()
-    );
+      this.sourceLocation
+    ).withOptions(this.options.clone());
   }
 };
 var ThisExpression = class _ThisExpression {
@@ -57267,137 +57272,163 @@ var TypeAccessExpression = class _TypeAccessExpression {
   }
 };
 var ConstructorDeclaration2 = class _ConstructorDeclaration {
-  constructor(decorators, parameters, body, entity, sourceLocation) {
-    this.decorators = decorators;
+  constructor(entity, parameters, body, sourceLocation) {
+    this.entity = entity;
     this.parameters = parameters;
     this.body = body;
-    this.entity = entity;
     this.sourceLocation = sourceLocation;
     this.kind = 49 /* ConstructorDeclaration */;
+    this.decorators = emptyDecorators;
+  }
+  withDecorators(decorators) {
+    this.decorators = decorators;
+    return this;
   }
   clone() {
     return new _ConstructorDeclaration(
-      this.decorators.map((d) => d.clone()),
+      this.entity,
       this.parameters.map((p) => p.clone()),
       this.body.clone(),
-      this.entity,
       this.sourceLocation
-    );
+    ).withDecorators(this.decorators.map((d) => d.clone()));
   }
 };
 var DereferencedVariableGetterDeclaration2 = class _DereferencedVariableGetterDeclaration {
-  constructor(entity, decorators, modifiers, body, sourceLocation) {
+  constructor(entity, modifiers, body, sourceLocation) {
     this.entity = entity;
-    this.decorators = decorators;
     this.modifiers = modifiers;
     this.body = body;
     this.sourceLocation = sourceLocation;
     this.kind = 92 /* DereferencedVariableGetterDeclaration */;
+    this.decorators = emptyDecorators;
+  }
+  withDecorators(decorators) {
+    this.decorators = decorators;
+    return this;
   }
   clone() {
     return new _DereferencedVariableGetterDeclaration(
       this.entity,
-      this.decorators.map((d) => d.clone()),
       this.modifiers.clone(),
       this.body.clone(),
       this.sourceLocation
-    );
+    ).withDecorators(this.decorators.map((d) => d.clone()));
   }
 };
 var DereferencedVariableSetterDeclaration2 = class _DereferencedVariableSetterDeclaration {
-  constructor(entity, decorators, modifiers, body, valueLocalVariableEntity, sourceLocation) {
+  constructor(entity, modifiers, body, valueLocalVariableEntity, sourceLocation) {
     this.entity = entity;
-    this.decorators = decorators;
     this.modifiers = modifiers;
     this.body = body;
     this.valueLocalVariableEntity = valueLocalVariableEntity;
     this.sourceLocation = sourceLocation;
     this.kind = 93 /* DereferencedVariableSetterDeclaration */;
+    this.decorators = emptyDecorators;
+  }
+  withDecorators(decorators) {
+    this.decorators = decorators;
+    return this;
   }
   clone() {
     return new _DereferencedVariableSetterDeclaration(
       this.entity,
-      this.decorators.map((d) => d.clone()),
       this.modifiers.clone(),
       this.body.clone(),
       this.valueLocalVariableEntity,
       this.sourceLocation
-    );
+    ).withDecorators(this.decorators.map((d) => d.clone()));
   }
 };
 var DestructorDeclaration2 = class _DestructorDeclaration {
-  constructor(decorators, parameters, body, entity, sourceLocation) {
-    this.decorators = decorators;
+  constructor(entity, parameters, body, sourceLocation) {
+    this.entity = entity;
     this.parameters = parameters;
     this.body = body;
-    this.entity = entity;
     this.sourceLocation = sourceLocation;
     this.kind = 50 /* DestructorDeclaration */;
+    this.decorators = emptyDecorators;
+  }
+  withDecorators(decorators) {
+    this.decorators = decorators;
+    return this;
   }
   clone() {
     return new _DestructorDeclaration(
-      this.decorators.map((d) => d.clone()),
+      this.entity,
       this.parameters.map((p) => p.clone()),
       this.body.clone(),
-      this.entity,
       this.sourceLocation
-    );
+    ).withDecorators(this.decorators.map((d) => d.clone()));
   }
 };
 var IndexedElementGetterDeclaration2 = class _IndexedElementGetterDeclaration {
-  constructor(entity, decorators, modifiers, parameters, body, sourceLocation) {
+  constructor(entity, modifiers, parameters, body, sourceLocation) {
     this.entity = entity;
-    this.decorators = decorators;
     this.modifiers = modifiers;
     this.parameters = parameters;
     this.body = body;
     this.sourceLocation = sourceLocation;
     this.kind = 51 /* IndexedElementGetterDeclaration */;
+    this.decorators = emptyDecorators;
+  }
+  withDecorators(decorators) {
+    this.decorators = decorators;
+    return this;
   }
   clone() {
     return new _IndexedElementGetterDeclaration(
       this.entity,
-      this.decorators.map((d) => d.clone()),
       this.modifiers.clone(),
       this.parameters.map((p) => p.clone()),
       this.body.clone(),
       this.sourceLocation
-    );
+    ).withDecorators(this.decorators.map((d) => d.clone()));
   }
 };
 var IndexedElementSetterDeclaration2 = class _IndexedElementSetterDeclaration {
-  constructor(entity, decorators, modifiers, parameters, body, valueLocalVariableEntity, sourceLocation) {
+  constructor(entity, modifiers, parameters, body, valueLocalVariableEntity, sourceLocation) {
     this.entity = entity;
-    this.decorators = decorators;
     this.modifiers = modifiers;
     this.parameters = parameters;
     this.body = body;
     this.valueLocalVariableEntity = valueLocalVariableEntity;
     this.sourceLocation = sourceLocation;
     this.kind = 52 /* IndexedElementSetterDeclaration */;
+    this.decorators = emptyDecorators;
+  }
+  withDecorators(decorators) {
+    this.decorators = decorators;
+    return this;
   }
   clone() {
     return new _IndexedElementSetterDeclaration(
       this.entity,
-      this.decorators.map((d) => d.clone()),
       this.modifiers.clone(),
       this.parameters.map((p) => p.clone()),
       this.body.clone(),
       this.valueLocalVariableEntity,
       this.sourceLocation
-    );
+    ).withDecorators(this.decorators.map((d) => d.clone()));
   }
 };
 var MethodAccessExpression = class _MethodAccessExpression {
-  constructor(expression, isOptionalAccess, method, isCallee, ifComputedThenKey, sourceLocation, options = FunctionAccessExpressionEmitOptions.default()) {
+  constructor(expression, isOptionalAccess, method, isCallee, sourceLocation) {
     this.expression = expression;
     this.isOptionalAccess = isOptionalAccess;
     this.method = method;
     this.isCallee = isCallee;
-    this.ifComputedThenKey = ifComputedThenKey;
     this.sourceLocation = sourceLocation;
-    this.options = options;
     this.kind = 71 /* MethodAccessExpression */;
+    this.ifComputedThenKey = void 0;
+    this.options = FunctionAccessExpressionEmitOptions.default();
+  }
+  withIfComputedThenKey(key) {
+    this.ifComputedThenKey = key;
+    return this;
+  }
+  withOptions(options) {
+    this.options = options;
+    return this;
   }
   clone() {
     return new _MethodAccessExpression(
@@ -57405,81 +57436,64 @@ var MethodAccessExpression = class _MethodAccessExpression {
       this.isOptionalAccess,
       this.method,
       this.isCallee,
-      this.ifComputedThenKey?.clone(),
-      this.sourceLocation,
-      this.options.clone()
-    );
+      this.sourceLocation
+    ).withIfComputedThenKey(this.ifComputedThenKey?.clone()).withOptions(this.options.clone());
   }
 };
 var MethodDeclaration2 = class _MethodDeclaration {
-  constructor(decorators, modifiers, parameters, body, entity, isGenerator, ifComputedThenKey, sourceLocation, options = MethodDeclarationEmitOptions.default()) {
-    this.decorators = decorators;
+  constructor(entity, modifiers, parameters, body, isGenerator, sourceLocation) {
+    this.entity = entity;
     this.modifiers = modifiers;
     this.parameters = parameters;
     this.body = body;
-    this.entity = entity;
     this.isGenerator = isGenerator;
-    this.ifComputedThenKey = ifComputedThenKey;
     this.sourceLocation = sourceLocation;
-    this.options = options;
     this.kind = 53 /* MethodDeclaration */;
+    this.decorators = emptyDecorators;
+    this.ifComputedThenKey = void 0;
+    this.options = MethodDeclarationEmitOptions.default();
+  }
+  withDecorators(decorators) {
+    this.decorators = decorators;
+    return this;
+  }
+  withIfComputedThenKey(key) {
+    this.ifComputedThenKey = key;
+    return this;
+  }
+  withOptions(options) {
+    this.options = options;
+    return this;
   }
   clone() {
     return new _MethodDeclaration(
-      this.decorators.map((d) => d.clone()),
+      this.entity,
       this.modifiers.clone(),
       this.parameters.map((p) => p.clone()),
       this.body.clone(),
-      this.entity,
       this.isGenerator,
-      this.ifComputedThenKey?.clone(),
-      this.sourceLocation,
-      this.options.clone()
-    );
+      this.sourceLocation
+    ).withDecorators(this.decorators.map((d) => d.clone())).withIfComputedThenKey(this.ifComputedThenKey?.clone()).withOptions(this.options.clone());
   }
 };
 var FieldAccessExpression = class _FieldAccessExpression {
-  constructor(expression, isOptionalAccess, field, accessKind, ifComputedThenKey, sourceLocation, options = FieldAccessExpressionEmitOptions.default()) {
+  constructor(expression, isOptionalAccess, field, accessKind, sourceLocation) {
     this.expression = expression;
     this.isOptionalAccess = isOptionalAccess;
     this.field = field;
     this.accessKind = accessKind;
-    this.ifComputedThenKey = ifComputedThenKey;
     this.sourceLocation = sourceLocation;
-    this.options = options;
     this.kind = 70 /* FieldAccessExpression */;
+    this.ifComputedThenKey = void 0;
+    this.options = FieldAccessExpressionEmitOptions.default();
   }
-  static get(expression, isOptionalAccess, field, ifComputedThenKey, sourceLocation) {
-    let accessedVariable;
-    if (field instanceof AccessedVariable) {
-      accessedVariable = field;
-    } else {
-      accessedVariable = AccessedVariable.fromEntity(field);
-    }
-    return new _FieldAccessExpression(
-      expression,
-      isOptionalAccess,
-      accessedVariable,
-      0 /* Get */,
-      ifComputedThenKey,
-      sourceLocation
-    );
+  withIfComputedThenKey(key) {
+    this.ifComputedThenKey = key;
+    return this;
   }
-  static set(expression, isOptionalAccess, field, ifComputedThenKey, sourceLocation) {
-    let accessedVariable;
-    if (field instanceof AccessedVariable) {
-      accessedVariable = field;
-    } else {
-      accessedVariable = AccessedVariable.fromEntity(field);
-    }
-    return new _FieldAccessExpression(
-      expression,
-      isOptionalAccess,
-      accessedVariable,
-      1 /* Set */,
-      ifComputedThenKey,
-      sourceLocation
-    );
+  withOptions(options) {
+    this.options = options;
+    return this;
   }
   clone() {
     return new _FieldAccessExpression(
@@ -57487,45 +57501,54 @@ var FieldAccessExpression = class _FieldAccessExpression {
       this.isOptionalAccess,
       this.field,
       this.accessKind,
-      this.ifComputedThenKey?.clone(),
-      this.sourceLocation,
-      this.options.clone()
-    );
+      this.sourceLocation
+    ).withIfComputedThenKey(this.ifComputedThenKey?.clone()).withOptions(this.options.clone());
   }
 };
 var FieldDeclaration2 = class _FieldDeclaration {
-  constructor(decorators, modifiers, initializer, entity, ifComputedThenKey, sourceLocation, options = FieldDeclarationEmitOptions.default()) {
-    this.decorators = decorators;
+  constructor(entity, modifiers, initializer, sourceLocation) {
+    this.entity = entity;
     this.modifiers = modifiers;
     this.initializer = initializer;
-    this.entity = entity;
-    this.ifComputedThenKey = ifComputedThenKey;
     this.sourceLocation = sourceLocation;
-    this.options = options;
     this.kind = 54 /* FieldDeclaration */;
+    this.decorators = emptyDecorators;
+    this.ifComputedThenKey = void 0;
+    this.options = FieldDeclarationEmitOptions.default();
+  }
+  withDecorators(decorators) {
+    this.decorators = decorators;
+    return this;
+  }
+  withIfComputedThenKey(key) {
+    this.ifComputedThenKey = key;
+    return this;
+  }
+  withOptions(options) {
+    this.options = options;
+    return this;
   }
   clone() {
-    return new _FieldDeclaration(
-      this.decorators.map((d) => d.clone()),
-      this.modifiers.clone(),
-      this.initializer?.clone(),
-      this.entity,
-      this.ifComputedThenKey?.clone(),
-      this.sourceLocation,
-      this.options.clone()
-    );
+    return new _FieldDeclaration(this.entity, this.modifiers.clone(), this.initializer?.clone(), this.sourceLocation).withDecorators(this.decorators.map((d) => d.clone())).withIfComputedThenKey(this.ifComputedThenKey?.clone()).withOptions(this.options.clone());
   }
 };
 var ComputedFieldDeclaration = class _ComputedFieldDeclaration {
-  constructor(entity, modifiers, getter, setter, ifComputedThenKey, sourceLocation, options = FieldDeclarationEmitOptions.default()) {
+  constructor(entity, modifiers, getter, setter, sourceLocation) {
     this.entity = entity;
     this.modifiers = modifiers;
     this.getter = getter;
     this.setter = setter;
-    this.ifComputedThenKey = ifComputedThenKey;
     this.sourceLocation = sourceLocation;
-    this.options = options;
     this.kind = 95 /* ComputedFieldDeclaration */;
+    this.options = FieldDeclarationEmitOptions.default();
+  }
+  withIfComputedThenKey(key) {
+    this.ifComputedThenKey = key;
+    return this;
+  }
+  withOptions(options) {
+    this.options = options;
+    return this;
   }
   clone() {
     return new _ComputedFieldDeclaration(
@@ -57533,46 +57556,46 @@ var ComputedFieldDeclaration = class _ComputedFieldDeclaration {
       this.modifiers.clone(),
       this.getter.clone(),
       this.setter?.clone(),
-      this.ifComputedThenKey?.clone(),
-      this.sourceLocation,
-      this.options.clone()
-    );
+      this.sourceLocation
+    ).withIfComputedThenKey(this.ifComputedThenKey?.clone()).withOptions(this.options.clone());
   }
 };
 var FieldGetterDeclaration2 = class _FieldGetterDeclaration {
-  constructor(entity, decorators, body, sourceLocation) {
+  constructor(entity, body, sourceLocation) {
     this.entity = entity;
-    this.decorators = decorators;
     this.body = body;
     this.sourceLocation = sourceLocation;
     this.kind = 55 /* FieldGetterDeclaration */;
+    this.decorators = emptyDecorators;
+  }
+  withDecorators(decorators) {
+    this.decorators = decorators;
+    return this;
   }
   clone() {
-    return new _FieldGetterDeclaration(
-      this.entity,
-      this.decorators.map((d) => d.clone()),
-      this.body.clone(),
-      this.sourceLocation
-    );
+    return new _FieldGetterDeclaration(this.entity, this.body.clone(), this.sourceLocation).withDecorators(this.decorators.map((d) => d.clone()));
   }
 };
 var FieldSetterDeclaration2 = class _FieldSetterDeclaration {
-  constructor(entity, decorators, body, valueLocalVariableEntity, sourceLocation) {
+  constructor(entity, body, valueLocalVariableEntity, sourceLocation) {
     this.entity = entity;
-    this.decorators = decorators;
     this.body = body;
     this.valueLocalVariableEntity = valueLocalVariableEntity;
     this.sourceLocation = sourceLocation;
     this.kind = 56 /* FieldSetterDeclaration */;
+    this.decorators = emptyDecorators;
+  }
+  withDecorators(decorators) {
+    this.decorators = decorators;
+    return this;
   }
   clone() {
     return new _FieldSetterDeclaration(
       this.entity,
-      this.decorators.map((d) => d.clone()),
       this.body.clone(),
       this.valueLocalVariableEntity,
       this.sourceLocation
-    );
+    ).withDecorators(this.decorators.map((d) => d.clone()));
   }
 };
 var ParameterDeclaration2 = class _ParameterDeclaration {
@@ -57594,24 +57617,6 @@ var VariableAccessExpression = class _VariableAccessExpression {
     this.sourceLocation = sourceLocation;
     this.kind = 66 /* VariableAccessExpression */;
   }
-  static get(variable) {
-    let accessedVariable;
-    if (variable instanceof AccessedVariable) {
-      accessedVariable = variable;
-    } else {
-      accessedVariable = AccessedVariable.fromEntity(variable);
-    }
-    return new _VariableAccessExpression(accessedVariable, 0 /* Get */, void 0);
-  }
-  static set(variable) {
-    let accessedVariable;
-    if (variable instanceof AccessedVariable) {
-      accessedVariable = variable;
-    } else {
-      accessedVariable = AccessedVariable.fromEntity(variable);
-    }
-    return new _VariableAccessExpression(accessedVariable, 1 /* Set */, void 0);
-  }
   clone() {
     return new _VariableAccessExpression(this.variable, this.accessKind, this.sourceLocation);
   }
@@ -57839,7 +57844,9 @@ var TypeUtils2 = class {
       case 48 /* LocalizableTextTemplateLiteral */:
         return this.ectx.standardTypes.text;
       case 58 /* TernaryExpression */:
-        return expression.type;
+        return this.ectx.createUnionType(
+          [this.ofExpression(expression.firstExpression), this.ofExpression(expression.secondExpression)]
+        );
       case 59 /* ThisExpression */:
         return expression.type;
       case 90 /* BaseExpression */:
@@ -58980,6 +58987,49 @@ function callExpression(expression, isOptionalAccess, args, isAsyncFunctionCall,
   const argsNode = args instanceof Array ? new OrderedArguments(args, false) : args;
   return new CallExpression2(expression, isOptionalAccess, argsNode, isAsyncFunctionCall, returnType, sourceLocation);
 }
+function functionCallExpression(func, args, sourceLocation) {
+  const accessedFunction2 = func instanceof AccessedFunction5 ? func : AccessedFunction5.fromEntity(func);
+  const argsNode = args instanceof Array ? new OrderedArguments(args, false) : args;
+  return new CallExpression2(
+    new FunctionAccessExpression(accessedFunction2, true),
+    false,
+    argsNode,
+    accessedFunction2.entity.details.isAsync,
+    accessedFunction2.returnType,
+    sourceLocation
+  );
+}
+function instanceMethodCallExpression(expression, method, args, isOptionalAccess, sourceLocation) {
+  const accessedFunction2 = method instanceof AccessedFunction5 ? method : AccessedFunction5.fromEntity(method);
+  const argsNode = args instanceof Array ? new OrderedArguments(args, false) : args;
+  return new CallExpression2(
+    new MethodAccessExpression(expression, isOptionalAccess, accessedFunction2, true),
+    false,
+    argsNode,
+    accessedFunction2.entity.details.isAsync,
+    accessedFunction2.returnType,
+    sourceLocation
+  );
+}
+function staticMethodCallExpression(method, args, sourceLocation) {
+  const accessedFunction2 = method instanceof AccessedFunction5 ? method : AccessedFunction5.fromEntity(method);
+  const type = accessedFunction2.entity.ifTypeMemberThenContainingType;
+  Debug.assertNotNull(type, "\u041E\u0436\u0438\u0434\u0430\u043B\u0441\u044F \u0432\u0441\u0435\u043E\u0431\u0449\u0438\u0439 \u043C\u0435\u0442\u043E\u0434.");
+  const argsNode = args instanceof Array ? new OrderedArguments(args, false) : args;
+  return new CallExpression2(
+    new MethodAccessExpression(
+      new TypeAccessExpression(type, void 0),
+      false,
+      accessedFunction2,
+      true
+    ),
+    false,
+    argsNode,
+    accessedFunction2.entity.details.isAsync,
+    accessedFunction2.returnType,
+    sourceLocation
+  );
+}
 function charLiteral(value, sourceLocation) {
   return new CharLiteral(value, sourceLocation);
 }
@@ -59020,25 +59070,28 @@ function forStatement(label, elementVariableEntity, indexVariableEntity, enumera
 function ifStatement(condition, thenStatement, elseStatement, sourceLocation) {
   return new IfStatement2(condition, thenStatement, elseStatement, sourceLocation);
 }
+function indexedAccessExpression(expression, isOptionalAccess, args, access, sourceLocation) {
+  return new IndexedAccessExpression2(expression, isOptionalAccess, args, access, sourceLocation);
+}
 function indexedGetAccessExpression(expression, getter, args, isOptionalAccess, sourceLocation) {
-  const accessedFunction = getter instanceof AccessedFunction5 ? getter : AccessedFunction5.fromEntity(getter);
+  const accessedFunction2 = getter instanceof AccessedFunction5 ? getter : AccessedFunction5.fromEntity(getter);
   const argsNode = args instanceof Array ? new OrderedArguments(args, false) : args;
   return new IndexedAccessExpression2(
     expression,
     isOptionalAccess,
     argsNode,
-    { kind: 0 /* Get */, getAccessor: accessedFunction },
+    { kind: 0 /* Get */, getAccessor: accessedFunction2 },
     sourceLocation
   );
 }
 function indexedSetAccessExpression(expression, setter, args, isOptionalAccess, sourceLocation) {
-  const accessedFunction = setter instanceof AccessedFunction5 ? setter : AccessedFunction5.fromEntity(setter);
+  const accessedFunction2 = setter instanceof AccessedFunction5 ? setter : AccessedFunction5.fromEntity(setter);
   const argsNode = args instanceof Array ? new OrderedArguments(args, false) : args;
   return new IndexedAccessExpression2(
     expression,
     isOptionalAccess,
     argsNode,
-    { kind: 1 /* Set */, setAccessor: accessedFunction },
+    { kind: 1 /* Set */, setAccessor: accessedFunction2 },
     sourceLocation
   );
 }
@@ -59145,101 +59198,251 @@ function switchStatement(matchExpression, caseClauses, defaultClauseBody, source
 function caseClause(expressions, body, sourceLocation) {
   return new CaseClause2(expressions, body, sourceLocation);
 }
+function ternaryExpression(condition, firstExpression, secondExpression, sourceLocation) {
+  return new TernaryExpression(condition, firstExpression, secondExpression, sourceLocation);
+}
 function textLiteral(value, sourceLocation) {
   return new TextLiteral2(value, sourceLocation);
 }
-function instanceMethodCallExpression(expression, method, args, isOptionalAccess, sourceLocation) {
-  const accessedFunction = method instanceof AccessedFunction5 ? method : AccessedFunction5.fromEntity(method);
-  const argsNode = args instanceof Array ? new OrderedArguments(args, false) : args;
-  return new CallExpression2(
-    new MethodAccessExpression(
-      expression,
-      isOptionalAccess,
-      accessedFunction,
-      true,
-      void 0,
-      void 0
-    ),
+function localizableTextLiteral(value, code, sourceLocation) {
+  return new LocalizableTextLiteral2(value, code, sourceLocation);
+}
+function textWithEntityName(entity, sourceLocation) {
+  return new TextWithEntityName(entity, sourceLocation);
+}
+function textTemplateLiteral(textFragments, expressions, sourceLocation) {
+  return new TextTemplateLiteral2(textFragments, expressions, sourceLocation);
+}
+function localizableTextTemplateLiteral(textFragments, expressions, code, sourceLocation) {
+  return new LocalizableTextTemplateLiteral2(textFragments, expressions, code, sourceLocation);
+}
+function thisExpression(type, sourceLocation) {
+  return new ThisExpression(type, sourceLocation);
+}
+function typeAccessExpression(entity, sourceLocation) {
+  return new TypeAccessExpression(entity, sourceLocation);
+}
+function constructorDeclaration(entity, parameters, body, sourceLocation) {
+  return new ConstructorDeclaration2(entity, parameters, body, sourceLocation);
+}
+function dereferencedVariableGetterDeclaration(entity, body, sourceLocation) {
+  const modifiers = new Modifiers().setStatic(entity.details.isStatic);
+  return new DereferencedVariableGetterDeclaration2(entity, modifiers, body, sourceLocation);
+}
+function dereferencedVariableSetterDeclaration(entity, body, valueLocalVariableEntity, sourceLocation) {
+  const modifiers = new Modifiers().setStatic(entity.details.isStatic);
+  return new DereferencedVariableSetterDeclaration2(entity, modifiers, body, valueLocalVariableEntity, sourceLocation);
+}
+function destructorDeclaration(entity, parameters, body, sourceLocation) {
+  return new DestructorDeclaration2(entity, parameters, body, sourceLocation);
+}
+function indexedElementGetterDeclaration(entity, parameters, body, sourceLocation) {
+  const modifiers = new Modifiers().setStatic(entity.details.isStatic);
+  return new IndexedElementGetterDeclaration2(entity, modifiers, parameters, body, sourceLocation);
+}
+function indexedElementSetterDeclaration(entity, parameters, body, valueLocalVariableEntity, sourceLocation) {
+  const modifiers = new Modifiers().setStatic(entity.details.isStatic);
+  return new IndexedElementSetterDeclaration2(
+    entity,
+    modifiers,
+    parameters,
+    body,
+    valueLocalVariableEntity,
+    sourceLocation
+  );
+}
+function methodAccessExpression(expression, isOptionalAccess, method, isCallee, sourceLocation) {
+  const accessedFunction2 = method instanceof AccessedFunction5 ? method : AccessedFunction5.fromEntity(method);
+  return new MethodAccessExpression(expression, isOptionalAccess, accessedFunction2, isCallee, sourceLocation);
+}
+function methodDeclaration(entity, parameters, body, isGenerator, sourceLocation) {
+  const modifiers = new Modifiers().setAsync(entity.details.isAsync).setStatic(entity.details.isStatic);
+  return new MethodDeclaration2(entity, modifiers, parameters, body, isGenerator, sourceLocation);
+}
+function fieldAccessExpression(expression, isOptionalAccess, field, accessKind, sourceLocation) {
+  const accessedVariable2 = field instanceof AccessedVariable ? field : AccessedVariable.fromEntity(field);
+  return new FieldAccessExpression(expression, isOptionalAccess, accessedVariable2, accessKind, sourceLocation);
+}
+function instanceFieldGetAccess(expression, field, isOptionalAccess, sourceLocation) {
+  const accessedVariable2 = field instanceof AccessedVariable ? field : AccessedVariable.fromEntity(field);
+  return new FieldAccessExpression(expression, isOptionalAccess, accessedVariable2, 0 /* Get */, sourceLocation);
+}
+function staticFieldGetAccess(field, sourceLocation) {
+  const accessedVariable2 = field instanceof AccessedVariable ? field : AccessedVariable.fromEntity(field);
+  const type = accessedVariable2.entity.ifTypeMemberThenContainingType;
+  Debug.assertNotNull(type, "\u041E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C \u0432\u0441\u0435\u043E\u0431\u0449\u0435\u0435 \u043F\u043E\u043B\u0435.");
+  return new FieldAccessExpression(
+    new TypeAccessExpression(type, void 0),
     false,
-    argsNode,
-    accessedFunction.entity.details.isAsync,
-    accessedFunction.returnType,
+    accessedVariable2,
+    0 /* Get */,
     sourceLocation
   );
 }
-function staticMethodCallExpression(method, args, sourceLocation) {
-  const accessedFunction = method instanceof AccessedFunction5 ? method : AccessedFunction5.fromEntity(method);
-  const type = accessedFunction.entity.ifTypeMemberThenContainingType;
-  Debug.assertNotNull(type, "\u041E\u0436\u0438\u0434\u0430\u043B\u0441\u044F \u0432\u0441\u0435\u043E\u0431\u0449\u0438\u0439 \u043C\u0435\u0442\u043E\u0434.");
-  const argsNode = args instanceof Array ? new OrderedArguments(args, false) : args;
-  return new CallExpression2(
-    new MethodAccessExpression(
-      new TypeAccessExpression(type, void 0),
-      false,
-      accessedFunction,
-      true,
-      void 0,
-      void 0
-    ),
+function instanceFieldSetAccess(expression, field, isOptionalAccess, sourceLocation) {
+  const accessedVariable2 = field instanceof AccessedVariable ? field : AccessedVariable.fromEntity(field);
+  return new FieldAccessExpression(expression, isOptionalAccess, accessedVariable2, 1 /* Set */, sourceLocation);
+}
+function staticFieldSetAccess(field, sourceLocation) {
+  const accessedVariable2 = field instanceof AccessedVariable ? field : AccessedVariable.fromEntity(field);
+  const type = accessedVariable2.entity.ifTypeMemberThenContainingType;
+  Debug.assertNotNull(type, "\u041E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C \u0432\u0441\u0435\u043E\u0431\u0449\u0435\u0435 \u043F\u043E\u043B\u0435.");
+  return new FieldAccessExpression(
+    new TypeAccessExpression(type, void 0),
     false,
-    argsNode,
-    accessedFunction.entity.details.isAsync,
-    accessedFunction.returnType,
+    accessedVariable2,
+    1 /* Set */,
     sourceLocation
   );
 }
+function fieldDeclaration(entity, initializer, sourceLocation) {
+  const modifiers = new Modifiers().setStatic(entity.details.isStatic);
+  return new FieldDeclaration2(entity, modifiers, initializer, sourceLocation);
+}
+function computedFieldDeclaration(entity, getter, setter, sourceLocation) {
+  const modifiers = new Modifiers().setStatic(entity.details.isStatic);
+  return new ComputedFieldDeclaration(entity, modifiers, getter, setter, sourceLocation);
+}
+function fieldGetterDeclaration(entity, body, sourceLocation) {
+  return new FieldGetterDeclaration2(entity, body, sourceLocation);
+}
+function fieldSetterDeclaration(entity, body, valueLocalVariableEntity, sourceLocation) {
+  return new FieldSetterDeclaration2(entity, body, valueLocalVariableEntity, sourceLocation);
+}
+function parameterDeclaration(entity, defaultValue, isRest, sourceLocation) {
+  return new ParameterDeclaration2(entity, defaultValue, isRest, sourceLocation);
+}
+function whileStatement(label, condition, body, sourceLocation) {
+  return new WhileStatement2(label, condition, body, sourceLocation);
+}
+function yieldStatement(expression, sourceLocation) {
+  return new YieldStatement2(expression, sourceLocation);
+}
+function textTranslationDeclaration(key, sourceTextTemplate, translatedTextOrFunctionBlock, sourceLocation) {
+  return new TextTranslationDeclaration2(key, sourceTextTemplate, translatedTextOrFunctionBlock, sourceLocation);
+}
+function translationTextTemplate(fragments, parameters, sourceLocation) {
+  return new TranslationTextTemplate2(fragments, parameters, sourceLocation);
+}
 function constructorCallExpression(ectx, constructor, args, sourceLocation) {
   const type = constructor.ifTypeMemberThenContainingType;
   Debug.assertNotNull(type, "\u041A\u043E\u043D\u0441\u0442\u0440\u0443\u043A\u0442\u043E\u0440 \u0434\u043E\u043B\u0436\u0435\u043D \u044F\u0432\u043B\u044F\u0442\u044C\u0441\u044F \u0447\u043B\u0435\u043D\u043E\u043C \u0442\u0438\u043F\u0430.");
   const argsNode = args instanceof Array ? new OrderedArguments(args, false) : args;
   return new ConstructorCallExpression(
     constructor,
-    type,
     new TypeAccessExpression(type, void 0),
     argsNode,
     ectx.createIdentitySubstitutedType(type),
     sourceLocation
   );
 }
-function functionCallExpression(func, args, sourceLocation) {
-  const accessedFunction = func instanceof AccessedFunction5 ? func : AccessedFunction5.fromEntity(func);
+function constructorCallExpressionWithResultType(constructor, args, type, sourceLocation) {
+  const typeEntity = constructor.ifTypeMemberThenContainingType;
+  Debug.assertNotNull(typeEntity, "\u041A\u043E\u043D\u0441\u0442\u0440\u0443\u043A\u0442\u043E\u0440 \u0434\u043E\u043B\u0436\u0435\u043D \u044F\u0432\u043B\u044F\u0442\u044C\u0441\u044F \u0447\u043B\u0435\u043D\u043E\u043C \u0442\u0438\u043F\u0430.");
   const argsNode = args instanceof Array ? new OrderedArguments(args, false) : args;
-  return new CallExpression2(
-    new FunctionAccessExpression(accessedFunction, true),
-    false,
+  return new ConstructorCallExpression(
+    constructor,
+    new TypeAccessExpression(typeEntity, void 0),
     argsNode,
-    accessedFunction.entity.details.isAsync,
-    accessedFunction.returnType,
+    type,
     sourceLocation
   );
 }
+function variableAccessExpressions(variable, accessKind, sourceLocation) {
+  const accessedVariable2 = variable instanceof AccessedVariable ? variable : AccessedVariable.fromEntity(variable);
+  return new VariableAccessExpression(accessedVariable2, accessKind, sourceLocation);
+}
 function variableGetAccess(variable, sourceLocation) {
-  const accessedVariable = variable instanceof AccessedVariable ? variable : AccessedVariable.fromEntity(variable);
-  return new VariableAccessExpression(accessedVariable, 0 /* Get */, sourceLocation);
+  const accessedVariable2 = variable instanceof AccessedVariable ? variable : AccessedVariable.fromEntity(variable);
+  return new VariableAccessExpression(accessedVariable2, 0 /* Get */, sourceLocation);
 }
-function instanceFieldGetAccess(expression, variable, isOptionalAccess, sourceLocation) {
-  const accessedVariable = variable instanceof AccessedVariable ? variable : AccessedVariable.fromEntity(variable);
-  return new FieldAccessExpression(
-    expression,
-    isOptionalAccess,
-    accessedVariable,
-    0 /* Get */,
-    void 0,
-    sourceLocation
+function variableSetAccess(variable, sourceLocation) {
+  const accessedVariable2 = variable instanceof AccessedVariable ? variable : AccessedVariable.fromEntity(variable);
+  return new VariableAccessExpression(accessedVariable2, 1 /* Set */, sourceLocation);
+}
+function accessedVariable(entity, type) {
+  return new AccessedVariable(entity, type);
+}
+function accessedFunction(entity, returnType) {
+  return new AccessedFunction5(entity, returnType);
+}
+function localVariableEntity(name, type, containingPackage, isConst) {
+  const result = new IntrinsicVariableEntity(name, type, containingPackage);
+  result.details.isConst = isConst;
+  return result;
+}
+function parameterEntity(name, type, containingPackage, isVariadic) {
+  const result = new IntrinsicVariableEntity(name, type, containingPackage);
+  result.details.isVariadicParameter = isVariadic;
+  return result;
+}
+function fieldEntity(name, type, containingType, overriddenMembers, isBasic, isAbstract, isStatic, isConst, computedNameInfo) {
+  const result = new IntrinsicVariableEntity(name, type, containingType.containingPackage);
+  result.ifTypeMemberThenContainingType = containingType;
+  result.details.overriddenMembers = overriddenMembers;
+  result.details.isBasic = isBasic;
+  result.details.isAbstract = isAbstract;
+  result.details.isStatic = isStatic;
+  result.details.isConst = isConst;
+  result.details.hasComputedName = computedNameInfo;
+  return result;
+}
+function packageVariableEntity(name, type, containingPackage, isConst) {
+  const result = new IntrinsicVariableEntity(name, type, containingPackage);
+  result.isPackageMember = true;
+  result.details.isConst = isConst;
+  return result;
+}
+function typeMemberFunctionEntity(functionEntityKind, name, parameters, returnType, containingType, isAsync, overriddenMembers, isBasic, isAbstract, isStatic, hasComputedName) {
+  const result = new IntrinsicFunctionEntity(
+    functionEntityKind,
+    name,
+    parameters,
+    returnType,
+    containingType.containingPackage
+  );
+  result.ifTypeMemberThenContainingType = containingType;
+  result.details.isAsync = isAsync;
+  result.details.overriddenMembers = overriddenMembers;
+  result.details.isBasic = isBasic;
+  result.details.isAbstract = isAbstract;
+  result.details.isStatic = isStatic;
+  result.details.hasComputedName = hasComputedName;
+  return result;
+}
+function fieldAccessorEntity(name, parameters, returnType, containingPackage, overriddenMembers, isBasic, isAbstract, isStatic) {
+  const result = new IntrinsicFunctionEntity(
+    1 /* GetterOrSetter */,
+    name,
+    parameters,
+    returnType,
+    containingPackage
   );
+  result.details.overriddenMembers = overriddenMembers;
+  result.details.isBasic = isBasic;
+  result.details.isAbstract = isAbstract;
+  result.details.isStatic = isStatic;
+  return result;
 }
-function staticFieldGetAccess(variable, sourceLocation) {
-  const accessedVariable = variable instanceof AccessedVariable ? variable : AccessedVariable.fromEntity(variable);
-  const type = accessedVariable.entity.ifTypeMemberThenContainingType;
-  Debug.assertNotNull(type, "\u041E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C \u0432\u0441\u0435\u043E\u0431\u0449\u0435\u0435 \u043F\u043E\u043B\u0435.");
-  return new FieldAccessExpression(
-    new TypeAccessExpression(type, void 0),
-    false,
-    accessedVariable,
-    0 /* Get */,
-    void 0,
-    sourceLocation
+function packageFunctionEntity(name, parameters, returnType, containingPackage, isAsync, isPackageConstructor, isPackageEntryPoint) {
+  const result = new IntrinsicFunctionEntity(
+    0 /* RegularFunction */,
+    name,
+    parameters,
+    returnType,
+    containingPackage
   );
+  result.isPackageMember = true;
+  result.details.isAsync = isAsync;
+  result.details.isPackageConstructor = isPackageConstructor;
+  result.details.isPackageEntryPoint = isPackageEntryPoint;
+  return result;
+}
+function packageEntity(name, locale, isPackageWithMainFunction, isMainPackage) {
+  const result = new IntrinsicPackageEntity(name, locale);
+  result.details.isPackageWithMainFunction = isPackageWithMainFunction;
+  result.details.isMainPackage = isMainPackage;
+  return result;
 }
 
 // source/emitter/DebugStack.ts
@@ -60909,8 +61112,8 @@ var GeneralLoweringContext = class {
         this.ectx.type.ofExpression(initializer)
       );
       tempVariables?.push(tempVariable);
-      assignment = assignmentExpression(VariableAccessExpression.get(tempVariable), initializer).withOptions(new AssignmentEmitOptions(false, false, false));
-      access = VariableAccessExpression.get(tempVariable);
+      assignment = assignmentExpression(variableGetAccess(tempVariable), initializer).withOptions(new AssignmentEmitOptions(false, false, false));
+      access = variableGetAccess(tempVariable);
     }
     return [tempVariable, assignment, access];
   }
@@ -61006,9 +61209,9 @@ var GeneralLoweringContext = class {
    * })
    */
   createCallOfDefineObjectPropertyMethodWithDescriptor(object, propertyKey, descriptor, descriptorOptionsOverride) {
-    const keyExpression = typeof propertyKey === "string" ? new TextLiteral2(propertyKey, void 0) : propertyKey;
+    const keyExpression = typeof propertyKey === "string" ? textLiteral(propertyKey) : propertyKey;
     const definePropertyAccess = jsPropertyAccessExpression(
-      new TypeAccessExpression(this.ectx.jsObjectType, void 0),
+      typeAccessExpression(this.ectx.jsObjectType),
       false,
       "defineProperty",
       this.ectx.standardTypes.func
@@ -61046,9 +61249,9 @@ var GeneralLoweringContext = class {
    * Object.getOwnPropertyDescriptor(object, propertyKey)
    */
   createGetOwnPropertyDescriptorCall(object, propertyKey) {
-    const keyExpression = typeof propertyKey === "string" ? new TextLiteral2(propertyKey, void 0) : propertyKey;
+    const keyExpression = typeof propertyKey === "string" ? textLiteral(propertyKey) : propertyKey;
     const getOwnPropertyDescriptorAccess = jsPropertyAccessExpression(
-      new TypeAccessExpression(this.ectx.jsObjectType, void 0),
+      typeAccessExpression(this.ectx.jsObjectType),
       false,
       "getOwnPropertyDescriptor",
       this.ectx.standardTypes.func
@@ -61072,18 +61275,7 @@ var GeneralLoweringContext = class {
     return jsPropertyAccessExpression(object, isOptionalChaining, "call", this.ectx.standardTypes.func);
   }
   createKeyForComputedNameWithSymbolKey(symbolDeclaration) {
-    if (symbolDeclaration.ifTypeMemberThenContainingType !== void 0) {
-      return new FieldAccessExpression(
-        new TypeAccessExpression(symbolDeclaration.ifTypeMemberThenContainingType, void 0),
-        false,
-        AccessedVariable.fromEntity(symbolDeclaration),
-        0 /* Get */,
-        void 0,
-        void 0
-      );
-    } else {
-      return new VariableAccessExpression(AccessedVariable.fromEntity(symbolDeclaration), 0 /* Get */, void 0);
-    }
+    return symbolDeclaration.ifTypeMemberThenContainingType !== void 0 ? staticFieldGetAccess(symbolDeclaration) : variableGetAccess(symbolDeclaration);
   }
   isWriteableVariable(entity) {
     if (this.isComputedVariable(entity)) {
@@ -61166,8 +61358,7 @@ var GeneralLoweringContext = class {
         5 /* Equals */,
         nullLiteral()
       );
-      const memberAccessType = this.ectx.type.ofExpression(substitutionMemberAccess);
-      result = new TernaryExpression(isEmptyExpression, nullLiteral(), substitutionMemberAccess, memberAccessType);
+      result = ternaryExpression(isEmptyExpression, nullLiteral(), substitutionMemberAccess);
     } else {
       result = createMemberAccess(receiver);
     }
@@ -61185,23 +61376,22 @@ var GeneralLoweringContext = class {
       path: fileUri.path,
       fragment: nodePathText
     }).toString();
-    return new TextLiteral2(locationText, void 0);
+    return textLiteral(locationText);
   }
   findOrCreatePackageConstructor(pkg2) {
     let result = pkg2.declarations.find((d) => d.kind === 22 /* PackageFunctionDeclaration */ && d.entity.details.isPackageConstructor);
     if (result === void 0) {
-      const entity = new IntrinsicFunctionEntity(
-        0 /* RegularFunction */,
+      const entity = packageFunctionEntity(
         EmitPhaseName.ofPackageConstructor(pkg2.entity.locale),
         [],
         this.ectx.standardTypes.nullType,
-        pkg2.entity
+        pkg2.entity,
+        false,
+        true,
+        false
       );
-      entity.details.isPackageConstructor = true;
-      entity.isPackageMember = true;
       const entityMembers = Array.from(pkg2.entity.members);
-      entityMembers.push(entity);
-      pkg2.entity.members = entityMembers;
+      pkg2.entity.members = pkg2.entity.members.concat(entity);
       result = packageFunctionDeclaration(entity, [], blockStatement([]), false);
       pkg2.declarations = pkg2.declarations.concat(result);
     }
@@ -61226,7 +61416,7 @@ var GeneralLoweringContext = class {
   }
   createUniqueLocalVariableEntity(containingPackage, type) {
     const name = EmitPhaseName.ofTempVariable(containingPackage.locale, this.generateId());
-    return new IntrinsicVariableEntity(name, type, containingPackage);
+    return localVariableEntity(name, type, containingPackage, false);
   }
 };
 var HelperFunctions = class {
@@ -61252,9 +61442,9 @@ var HelperFunctions = class {
   }
 };
 var ExecutableCodeLowering = class {
-  constructor(ctx, packageEntity) {
+  constructor(ctx, packageEntity2) {
     this.ctx = ctx;
-    this.packageEntity = packageEntity;
+    this.packageEntity = packageEntity2;
   }
   createCachingTemporaryVariable(initializer, tempVariables) {
     return this.ctx.createCachingTemporaryVariable(initializer, this.packageEntity, tempVariables);
@@ -61304,42 +61494,30 @@ var ImplicitImplementationLowering = class {
   //   return base.method(p1, p2)
   // }
   createExplicitMethodImplementation(implementingMethod, implementedAbstractMethods, containingType) {
-    const parameterEntities = implementingMethod.parameters.map((p) => new IntrinsicVariableEntity(p.name, p.type, p.containingPackage));
-    const methodEntity = new IntrinsicFunctionEntity(
+    const parameterEntities = implementingMethod.parameters.map((p) => parameterEntity(p.name, p.type, p.containingPackage, p.details.isVariadicParameter));
+    const computedNameInfo = implementingMethod.details.hasComputedName !== void 0 ? { ...implementingMethod.details.hasComputedName } : void 0;
+    const methodEntity = typeMemberFunctionEntity(
       0 /* RegularFunction */,
       implementingMethod.name,
       parameterEntities,
       implementingMethod.returnType,
-      implementingMethod.containingPackage
-    );
-    methodEntity.ifTypeMemberThenContainingType = containingType;
-    if (implementingMethod.details.hasComputedName !== void 0) {
-      methodEntity.details.hasComputedName = { ...implementingMethod.details.hasComputedName };
-    }
-    methodEntity.details.overriddenMembers = [implementingMethod, ...implementedAbstractMethods];
-    const parameterDeclarations = parameterEntities.map((e) => new ParameterDeclaration2(
-      e,
-      void 0,
+      containingType,
+      implementingMethod.details.isAsync,
+      [implementingMethod, ...implementedAbstractMethods],
       false,
-      void 0
-    ));
+      false,
+      false,
+      computedNameInfo
+    );
+    const parameterDeclarations = parameterEntities.map((e) => parameterDeclaration(e, void 0, false));
     const methodCall = instanceMethodCallExpression(
       baseExpression(),
       implementingMethod,
-      parameterEntities.map((e) => VariableAccessExpression.get(e)),
+      parameterEntities.map((e) => variableGetAccess(e)),
       false
     );
     const body = blockStatement([returnStatement(methodCall)]);
-    return new MethodDeclaration2(
-      [],
-      new Modifiers(),
-      parameterDeclarations,
-      body,
-      methodEntity,
-      false,
-      void 0,
-      void 0
-    );
+    return methodDeclaration(methodEntity, parameterDeclarations, body, false);
   }
   // get field() {
   //   return super.field
@@ -61348,71 +61526,76 @@ var ImplicitImplementationLowering = class {
   //   super.field = value
   // }
   createExplicitFieldImplementation(implementingField, implementedAbstractFields, containingType) {
-    const fieldEntity = new IntrinsicVariableEntity(
+    const computedNameInfo = implementingField.details.hasComputedName !== void 0 ? { ...implementingField.details.hasComputedName } : void 0;
+    const fieldEntity2 = fieldEntity(
       implementingField.name,
       implementingField.type,
-      implementingField.containingPackage
+      containingType,
+      [implementingField, ...implementedAbstractFields],
+      false,
+      false,
+      false,
+      false,
+      computedNameInfo
     );
-    fieldEntity.ifTypeMemberThenContainingType = containingType;
-    if (implementingField.details.hasComputedName !== void 0) {
-      fieldEntity.details.hasComputedName = { ...implementingField.details.hasComputedName };
-    }
-    fieldEntity.details.overriddenMembers = [implementingField, ...implementedAbstractFields];
     const getter = this.createRedirectingGetter(implementingField);
     let setter;
     if (this.ctx.isWriteableVariable(implementingField)) {
       setter = this.createRedirectingSetter(implementingField);
     }
-    return new ComputedFieldDeclaration(fieldEntity, new Modifiers(), getter, setter, void 0, void 0);
+    return computedFieldDeclaration(fieldEntity2, getter, setter);
   }
   // get field() {
   //   return super.field
   // }
   createRedirectingGetter(targetFieldEntity) {
-    const getterEntity = new IntrinsicFunctionEntity(
-      1 /* GetterOrSetter */,
+    const getterEntity = fieldAccessorEntity(
       targetFieldEntity.name,
       [],
       targetFieldEntity.type,
-      targetFieldEntity.containingPackage
+      targetFieldEntity.containingPackage,
+      [],
+      false,
+      false,
+      false
     );
-    const variableAccess = FieldAccessExpression.get(
+    const variableAccess = instanceFieldGetAccess(
       baseExpression(),
-      false,
       targetFieldEntity,
-      void 0,
-      void 0
+      false
     );
     const body = blockStatement([returnStatement(variableAccess)]);
-    return new FieldGetterDeclaration2(getterEntity, [], body, void 0);
+    return fieldGetterDeclaration(getterEntity, body);
   }
   // set field(value) {
   //   super.field = value
   // }
   createRedirectingSetter(targetFieldEntity) {
-    const parameterEntity = new IntrinsicVariableEntity(
+    const parameterEntity2 = parameterEntity(
       EmitPhaseName.ofSetterParameter(targetFieldEntity.containingPackage.locale),
       targetFieldEntity.type,
-      targetFieldEntity.containingPackage
+      targetFieldEntity.containingPackage,
+      false
     );
-    const setterEntity = new IntrinsicFunctionEntity(
-      1 /* GetterOrSetter */,
+    const setterEntity = fieldAccessorEntity(
       targetFieldEntity.name,
-      [parameterEntity],
+      [parameterEntity2],
       this.ctx.ectx.standardTypes.nullType,
-      targetFieldEntity.containingPackage
+      targetFieldEntity.containingPackage,
+      [],
+      false,
+      false,
+      false
     );
-    const variableAccess = FieldAccessExpression.set(
+    const variableAccess = instanceFieldSetAccess(
       baseExpression(),
-      false,
       targetFieldEntity,
-      void 0,
-      void 0
+      false
     );
-    const parameterAccess = VariableAccessExpression.get(parameterEntity);
+    const parameterAccess = variableGetAccess(parameterEntity2);
     const variableAssignment = assignmentStatement(variableAccess, parameterAccess).withOptions(new AssignmentEmitOptions(false, false, false));
     const body = blockStatement([variableAssignment]);
-    return new FieldSetterDeclaration2(setterEntity, [], body, parameterEntity, void 0);
+    return fieldSetterDeclaration(setterEntity, body, parameterEntity2);
   }
 };
 var CompoundDeclarationsAndOperatorsLowering = class {
@@ -61437,12 +61620,7 @@ var CompoundDeclarationsAndOperatorsLowering = class {
           memberEntities.delete(d.variableEntity);
           memberEntities.add(d.entity);
           d.entity.functionEntityKind = 0 /* RegularFunction */;
-          const parameters = [new ParameterDeclaration2(
-            d.valueLocalVariableEntity,
-            void 0,
-            false,
-            void 0
-          )];
+          const parameters = [parameterDeclaration(d.valueLocalVariableEntity, void 0, false)];
           d = packageFunctionDeclaration(d.entity, parameters, d.body, false, d.sourceLocation);
           return d;
         }
@@ -61456,66 +61634,25 @@ var CompoundDeclarationsAndOperatorsLowering = class {
     declaration.members = declaration.members.map((m) => {
       if (m.kind === 51 /* IndexedElementGetterDeclaration */) {
         m.entity.functionEntityKind = 0 /* RegularFunction */;
-        const method = new MethodDeclaration2(
-          m.decorators,
-          m.modifiers,
-          m.parameters,
-          m.body,
-          m.entity,
-          false,
-          void 0,
-          m.sourceLocation
-        );
+        const method = methodDeclaration(m.entity, m.parameters, m.body, false, m.sourceLocation).withDecorators(m.decorators);
         return method;
       } else if (m.kind === 52 /* IndexedElementSetterDeclaration */) {
         m.entity.functionEntityKind = 0 /* RegularFunction */;
         m.entity.parameters = m.entity.parameters.concat(m.valueLocalVariableEntity);
         const parameters = Array.from(m.parameters);
-        parameters.push(new ParameterDeclaration2(m.valueLocalVariableEntity, void 0, false, void 0));
-        const method = new MethodDeclaration2(
-          m.decorators,
-          m.modifiers,
-          parameters,
-          m.body,
-          m.entity,
-          false,
-          void 0,
-          m.sourceLocation
-        );
+        parameters.push(parameterDeclaration(m.valueLocalVariableEntity, void 0, false));
+        const method = methodDeclaration(m.entity, parameters, m.body, false, m.sourceLocation).withDecorators(m.decorators);
         return method;
       }
       if (m.kind === 92 /* DereferencedVariableGetterDeclaration */) {
         m.entity.functionEntityKind = 0 /* RegularFunction */;
-        const method = new MethodDeclaration2(
-          m.decorators,
-          m.modifiers,
-          [],
-          m.body,
-          m.entity,
-          false,
-          void 0,
-          m.sourceLocation
-        );
+        const method = methodDeclaration(m.entity, [], m.body, false, m.sourceLocation).withDecorators(m.decorators);
         return method;
       } else if (m.kind === 93 /* DereferencedVariableSetterDeclaration */) {
         m.entity.functionEntityKind = 0 /* RegularFunction */;
         m.entity.parameters = [m.valueLocalVariableEntity];
-        const parameters = [new ParameterDeclaration2(
-          m.valueLocalVariableEntity,
-          void 0,
-          false,
-          void 0
-        )];
-        const method = new MethodDeclaration2(
-          m.decorators,
-          m.modifiers,
-          parameters,
-          m.body,
-          m.entity,
-          false,
-          void 0,
-          m.sourceLocation
-        );
+        const parameters = [parameterDeclaration(m.valueLocalVariableEntity, void 0, false)];
+        const method = methodDeclaration(m.entity, parameters, m.body, false, m.sourceLocation).withDecorators(m.decorators);
         return method;
       } else {
         return m;
@@ -61556,7 +61693,7 @@ var TypeExtensionBasicMembersLowering = class {
   //   configurable: false,
   //   enumerable: false,
   // })
-  addBasicMembersToExtendedTypePrototype(packageEntity, node) {
+  addBasicMembersToExtendedTypePrototype(packageEntity2, node) {
     if (node.entity.details.extendedType === void 0) {
       return void 0;
     }
@@ -61569,14 +61706,14 @@ var TypeExtensionBasicMembersLowering = class {
     for (const member of node.members) {
       if ((member.kind === 53 /* MethodDeclaration */ || member.kind === 95 /* ComputedFieldDeclaration */) && member.entity.details.isBasic) {
         const keyName = `${node.entity.name}_${member.entity.name}`;
-        const keyEntity = new IntrinsicVariableEntity(
+        const keyEntity = packageVariableEntity(
           keyName,
           this.ctx.ectx.createIdentitySubstitutedType(this.ctx.ectx.jsSymbolType),
-          packageEntity
+          packageEntity2,
+          true
         );
-        keyEntity.isPackageMember = true;
         const keyInitializer = callExpression(
-          new TypeAccessExpression(this.ctx.ectx.jsSymbolType),
+          typeAccessExpression(this.ctx.ectx.jsSymbolType),
           false,
           [],
           false,
@@ -61584,19 +61721,17 @@ var TypeExtensionBasicMembersLowering = class {
         );
         const keyDeclaration = packageVariableDeclaration(keyEntity, keyInitializer).withOptions(new PackageVariableDeclarationEmitOptions(true, true));
         symbolDeclarations.push(keyDeclaration);
-        const typeExtensionPrototypeAccess = this.ctx.createPrototypeAccess(
-          new TypeAccessExpression(node.entity, void 0)
-        );
+        const typeExtensionPrototypeAccess = this.ctx.createPrototypeAccess(typeAccessExpression(node.entity));
         const getOwnPropertyDescriptorCall = this.ctx.createGetOwnPropertyDescriptorCall(
           typeExtensionPrototypeAccess,
-          new TextWithEntityName(member.entity, void 0)
+          textWithEntityName(member.entity)
         );
         const extendedTypePrototypeAccess = this.ctx.createPrototypeAccess(
-          new TypeAccessExpression(extendedType.entity, void 0)
+          typeAccessExpression(extendedType.entity)
         );
         const definePropertyCall = this.ctx.createCallOfDefineObjectPropertyMethodWithDescriptor(
           extendedTypePrototypeAccess,
-          VariableAccessExpression.get(keyEntity),
+          variableGetAccess(keyEntity),
           getOwnPropertyDescriptorCall,
           { isConfigurable: false, isEnumerable: false }
         );
@@ -61657,17 +61792,17 @@ var AspectsLowering = class {
     }
   }
   // const key = Symbol()
-  createAspectMemberKeyDeclaration(entity, packageEntity) {
+  createAspectMemberKeyDeclaration(entity, packageEntity2) {
     Debug.assertNotNull(entity.ifTypeMemberThenContainingType);
     const keyName = `${entity.ifTypeMemberThenContainingType.name}_${entity.name}`;
-    const keyEntity = new IntrinsicVariableEntity(
+    const keyEntity = packageVariableEntity(
       keyName,
       this.ctx.ectx.createIdentitySubstitutedType(this.ctx.ectx.jsSymbolType),
-      packageEntity
+      packageEntity2,
+      true
     );
-    keyEntity.isPackageMember = true;
     const keyInitializer = callExpression(
-      new TypeAccessExpression(this.ctx.ectx.jsSymbolType, void 0),
+      typeAccessExpression(this.ctx.ectx.jsSymbolType),
       false,
       [],
       false,
@@ -61687,8 +61822,8 @@ var AspectsLowering = class {
           if (overriddenAspectMethods !== void 0) {
             for (const overriddenAspectMethod of overriddenAspectMethods) {
               if (overriddenAspectMethod.containingPackage.details.isSource && overriddenAspectMethod.details.hasComputedName !== void 0) {
-                const methodDeclaration = this.createRedirectingMethod(member.entity, overriddenAspectMethod);
-                addedMembers.push(methodDeclaration);
+                const methodDeclaration2 = this.createRedirectingMethod(member.entity, overriddenAspectMethod);
+                addedMembers.push(methodDeclaration2);
               }
             }
           }
@@ -61700,11 +61835,11 @@ var AspectsLowering = class {
           if (overriddenAspectVariables !== void 0) {
             for (const overriddenAspectVariable of overriddenAspectVariables) {
               if (overriddenAspectVariable.containingPackage.details.isSource && overriddenAspectVariable.details.hasComputedName !== void 0) {
-                const methodDeclaration = this.createRedirectingComputedVariable(
+                const methodDeclaration2 = this.createRedirectingComputedVariable(
                   member.entity,
                   overriddenAspectVariable
                 );
-                addedMembers.push(methodDeclaration);
+                addedMembers.push(methodDeclaration2);
               }
             }
           }
@@ -61735,44 +61870,34 @@ var AspectsLowering = class {
   createRedirectingMethod(targetFunctionEntity, aspectFunctionEntity) {
     Debug.assertNotNull(targetFunctionEntity.ifTypeMemberThenContainingType);
     Debug.assertNotNull(aspectFunctionEntity.details.hasComputedName);
-    const parameterEntities = targetFunctionEntity.parameters.map((p) => new IntrinsicVariableEntity(p.name, p.type, p.containingPackage));
-    const functionEntity = new IntrinsicFunctionEntity(
-      0 /* RegularFunction */,
-      targetFunctionEntity.name,
-      parameterEntities,
-      targetFunctionEntity.returnType,
-      targetFunctionEntity.containingPackage
-    );
-    functionEntity.ifTypeMemberThenContainingType = targetFunctionEntity.ifTypeMemberThenContainingType;
-    functionEntity.details.hasComputedName = {
+    const parameterEntities = targetFunctionEntity.parameters.map((p) => parameterEntity(p.name, p.type, p.containingPackage, p.details.isVariadicParameter));
+    const computedNameInfo = {
       symbolDeclaration: aspectFunctionEntity.details.hasComputedName.symbolDeclaration,
       affectsDeclaration: true,
       affectsDerivedMembers: false
     };
-    functionEntity.details.overriddenMembers = [aspectFunctionEntity];
-    const parameterDeclarations = parameterEntities.map((e) => new ParameterDeclaration2(
-      e,
-      void 0,
+    const functionEntity = typeMemberFunctionEntity(
+      0 /* RegularFunction */,
+      targetFunctionEntity.name,
+      parameterEntities,
+      targetFunctionEntity.returnType,
+      targetFunctionEntity.ifTypeMemberThenContainingType,
+      aspectFunctionEntity.details.isAsync,
+      [aspectFunctionEntity],
       false,
-      void 0
-    ));
+      false,
+      false,
+      computedNameInfo
+    );
+    const parameterDeclarations = parameterEntities.map((e) => parameterDeclaration(e, void 0, false));
     const methodCall = instanceMethodCallExpression(
-      new ThisExpression(this.ctx.ectx.standardTypes.refObject),
+      thisExpression(this.ctx.ectx.standardTypes.refObject),
       targetFunctionEntity,
-      parameterEntities.map((e) => VariableAccessExpression.get(e)),
+      parameterEntities.map((e) => variableGetAccess(e)),
       false
     );
     const body = blockStatement([returnStatement(methodCall)]);
-    return new MethodDeclaration2(
-      [],
-      new Modifiers(),
-      parameterDeclarations,
-      body,
-      functionEntity,
-      false,
-      void 0,
-      void 0
-    );
+    return methodDeclaration(functionEntity, parameterDeclarations, body, false);
   }
   // get [Aspect_variable]() {
   //   return this.variable
@@ -61783,72 +61908,80 @@ var AspectsLowering = class {
   createRedirectingComputedVariable(targetVariableEntity, aspectVariableEntity) {
     Debug.assertNotNull(targetVariableEntity.ifTypeMemberThenContainingType);
     Debug.assertNotNull(aspectVariableEntity.details.hasComputedName);
-    const entity = new IntrinsicVariableEntity(
-      targetVariableEntity.name,
-      targetVariableEntity.type,
-      targetVariableEntity.containingPackage
-    );
-    entity.ifTypeMemberThenContainingType = targetVariableEntity.ifTypeMemberThenContainingType;
-    entity.details.hasComputedName = {
+    const computedNameInfo = {
       symbolDeclaration: aspectVariableEntity.details.hasComputedName.symbolDeclaration,
       affectsDeclaration: true,
       affectsDerivedMembers: false
     };
+    const entity = fieldEntity(
+      targetVariableEntity.name,
+      targetVariableEntity.type,
+      targetVariableEntity.ifTypeMemberThenContainingType,
+      [],
+      aspectVariableEntity.details.isBasic,
+      false,
+      false,
+      aspectVariableEntity.details.isConst,
+      computedNameInfo
+    );
     const getter = this.createRedirectingGetter(targetVariableEntity);
     let setter;
     if (this.ctx.isWriteableVariable(aspectVariableEntity)) {
       setter = this.createRedirectingSetter(targetVariableEntity);
     }
-    return new ComputedFieldDeclaration(entity, new Modifiers(), getter, setter, void 0, void 0);
+    return computedFieldDeclaration(entity, getter, setter);
   }
   // get [Aspect_variable]() {
   //   return this.variable
   // }
   createRedirectingGetter(targetVariableEntity) {
-    const getterEntity = new IntrinsicFunctionEntity(
-      1 /* GetterOrSetter */,
+    const getterEntity = fieldAccessorEntity(
       targetVariableEntity.name,
       [],
       targetVariableEntity.type,
-      targetVariableEntity.containingPackage
-    );
-    const variableAccess = FieldAccessExpression.get(
-      new ThisExpression(this.ctx.ectx.standardTypes.refObject, void 0),
+      targetVariableEntity.containingPackage,
+      [],
+      false,
       false,
+      false
+    );
+    const variableAccess = instanceFieldGetAccess(
+      thisExpression(this.ctx.ectx.standardTypes.refObject),
       targetVariableEntity,
-      void 0,
-      void 0
+      false
     );
     const body = blockStatement([returnStatement(variableAccess)]);
-    return new FieldGetterDeclaration2(getterEntity, [], body, void 0);
+    return fieldGetterDeclaration(getterEntity, body);
   }
   // set [Aspect_variable](value) {
   //   this.variable = value
   // }
   createRedirectingSetter(targetVariableEntity) {
-    const parameterEntity = new IntrinsicVariableEntity(
+    const parameterEntity2 = parameterEntity(
       EmitPhaseName.ofSetterParameter(targetVariableEntity.containingPackage.locale),
       targetVariableEntity.type,
-      targetVariableEntity.containingPackage
+      targetVariableEntity.containingPackage,
+      false
     );
-    const setterEntity = new IntrinsicFunctionEntity(
-      1 /* GetterOrSetter */,
+    const setterEntity = fieldAccessorEntity(
       targetVariableEntity.name,
-      [parameterEntity],
+      [parameterEntity2],
       this.ctx.ectx.standardTypes.nullType,
-      targetVariableEntity.containingPackage
-    );
-    const variableAccess = FieldAccessExpression.set(
-      new ThisExpression(this.ctx.ectx.standardTypes.refObject, void 0),
+      targetVariableEntity.containingPackage,
+      [],
+      false,
       false,
+      false
+    );
+    const variableAccess = instanceFieldSetAccess(
+      thisExpression(this.ctx.ectx.standardTypes.refObject),
       targetVariableEntity,
-      void 0,
-      void 0
+      false
     );
-    const parameterAccess = VariableAccessExpression.get(parameterEntity);
+    const parameterAccess = variableGetAccess(parameterEntity2);
     const variableAssignment = assignmentStatement(variableAccess, parameterAccess).withOptions(new AssignmentEmitOptions(false, false, false));
     const body = blockStatement([variableAssignment]);
-    return new FieldSetterDeclaration2(setterEntity, [], body, parameterEntity, void 0);
+    return fieldSetterDeclaration(setterEntity, body, parameterEntity2);
   }
   getNotAbstractAspectMembersToAddToDerivedType(entity) {
     const overriddenMembers = Query.from(entity.members).map((m) => this.getAllOverriddenAspectMembers(m)).filter((m) => m !== void 0).flatMap((m) => m).uniqueToSet();
@@ -61923,13 +62056,11 @@ var AspectsLowering = class {
     const computedNameInfo = entity.details.hasComputedName;
     Debug.assertNotNull(computedNameInfo);
     const keyAccess = this.ctx.createKeyForComputedNameWithSymbolKey(computedNameInfo.symbolDeclaration);
-    const targetTypePrototypeAccess = this.ctx.createPrototypeAccess(new TypeAccessExpression(targetType, void 0));
-    const aspectTypePrototypeAccess = this.ctx.createPrototypeAccess(
-      new TypeAccessExpression(containingType, void 0)
-    );
+    const targetTypePrototypeAccess = this.ctx.createPrototypeAccess(typeAccessExpression(targetType));
+    const aspectTypePrototypeAccess = this.ctx.createPrototypeAccess(typeAccessExpression(containingType));
     const getOwnPropertyDescriptorCall = this.ctx.createGetOwnPropertyDescriptorCall(
       aspectTypePrototypeAccess,
-      new TextWithEntityName(entity, void 0)
+      textWithEntityName(entity)
     );
     const definePropertyCall = this.ctx.createCallOfDefineObjectPropertyMethodWithDescriptor(
       targetTypePrototypeAccess,
@@ -62002,7 +62133,7 @@ var AliasTypeAndExtensionLowering = class {
     const modifiers = node.modifiers;
     modifiers.makeStatic();
     node.parameters = [
-      new ParameterDeclaration2(targetParameterEntity, void 0, false, void 0),
+      parameterDeclaration(targetParameterEntity, void 0, false),
       ...node.parameters
     ];
     this.lowerSubprogramBody(node.body, targetParameterEntity);
@@ -62023,19 +62154,9 @@ var AliasTypeAndExtensionLowering = class {
     node.entity.parameters = [targetParameterEntity];
     node.entity.functionEntityKind = 0 /* RegularFunction */;
     node.entity.details.isAliasTypeOrExtensionMemberThatRequiresLowering = true;
-    const modifiers = new Modifiers().makeStatic();
-    const parameterDeclarations = [new ParameterDeclaration2(targetParameterEntity, void 0, false, void 0)];
+    const parameterDeclarations = [parameterDeclaration(targetParameterEntity, void 0, false)];
     this.lowerSubprogramBody(node.body, targetParameterEntity);
-    return new MethodDeclaration2(
-      node.decorators,
-      modifiers,
-      parameterDeclarations,
-      node.body,
-      node.entity,
-      false,
-      void 0,
-      node.sourceLocation
-    );
+    return methodDeclaration(node.entity, parameterDeclarations, node.body, false, node.sourceLocation).withDecorators(node.decorators);
   }
   lowerVariableSetterDeclaration(node, variableEntity) {
     const containingType = variableEntity.ifTypeMemberThenContainingType;
@@ -62046,47 +62167,27 @@ var AliasTypeAndExtensionLowering = class {
     node.entity.parameters = [targetParameterEntity, node.valueLocalVariableEntity];
     node.entity.functionEntityKind = 0 /* RegularFunction */;
     node.entity.details.isAliasTypeOrExtensionMemberThatRequiresLowering = true;
-    const modifiers = new Modifiers().makeStatic();
     const parameterDeclarations = [
-      new ParameterDeclaration2(targetParameterEntity, void 0, false, void 0),
-      new ParameterDeclaration2(node.valueLocalVariableEntity, void 0, false, void 0)
+      parameterDeclaration(targetParameterEntity, void 0, false),
+      parameterDeclaration(node.valueLocalVariableEntity, void 0, false)
     ];
     this.lowerSubprogramBody(node.body, targetParameterEntity);
-    return new MethodDeclaration2(
-      node.decorators,
-      modifiers,
-      parameterDeclarations,
-      node.body,
-      node.entity,
-      false,
-      void 0,
-      node.sourceLocation
-    );
+    return methodDeclaration(node.entity, parameterDeclarations, node.body, false, node.sourceLocation).withDecorators(node.decorators);
   }
   lowerConstructorDeclaration(node) {
     node.entity.functionEntityKind = 0 /* RegularFunction */;
     node.entity.details.isStatic = true;
-    const modifiers = new Modifiers().makeStatic();
     this.lowerConstructorBody(node.body, node.entity);
-    return new MethodDeclaration2(
-      node.decorators,
-      modifiers,
-      node.parameters,
-      node.body,
-      node.entity,
-      false,
-      void 0,
-      void 0
-    );
+    return methodDeclaration(node.entity, node.parameters, node.body, false, node.sourceLocation).withDecorators(node.decorators);
   }
   lowerSubprogramBody(body, targetVariableEntity) {
     const transformer = new Transformer({
       transformThisExpression: (_) => {
-        const targetVariableAccess = VariableAccessExpression.get(targetVariableEntity);
+        const targetVariableAccess = variableGetAccess(targetVariableEntity);
         return replaceExpression(targetVariableAccess);
       },
       transformBaseExpression: (_node) => {
-        const targetVariableAccess = VariableAccessExpression.get(targetVariableEntity);
+        const targetVariableAccess = variableGetAccess(targetVariableEntity);
         return replaceExpression(targetVariableAccess);
       }
     });
@@ -62100,18 +62201,13 @@ var AliasTypeAndExtensionLowering = class {
     const bodyStatements = Array.from(body.statements);
     const baseConstructorCall = this.ctx.findBaseConstructorCall(body);
     if (baseConstructorCall !== void 0) {
-      const baseConstructorEntity = baseConstructorCall.expression.entity;
-      Debug.assertNotNull(baseConstructorEntity.ifTypeMemberThenContainingType);
-      const typeAccess = new TypeAccessExpression(baseConstructorEntity.ifTypeMemberThenContainingType, void 0);
-      const constructorCall = new ConstructorCallExpression(
+      const constructorCall = constructorCallExpression(
+        this.ctx.ectx,
         baseConstructorCall.expression.entity,
-        baseConstructorEntity.ifTypeMemberThenContainingType,
-        typeAccess,
         baseConstructorCall.expression.args,
-        entity.returnType,
         baseConstructorCall.expression.sourceLocation
       );
-      const resultSetAccess = VariableAccessExpression.set(targetVariableEntity);
+      const resultSetAccess = variableSetAccess(targetVariableEntity);
       const resultAssignment = assignmentStatement(resultSetAccess, constructorCall);
       bodyStatements.splice(baseConstructorCall.statementIndex, 1, resultAssignment);
     } else {
@@ -62123,13 +62219,12 @@ var AliasTypeAndExtensionLowering = class {
           ownConstructorEntity,
           ownConstructorCall.expression.args
         );
-        const resultSetAccess = VariableAccessExpression.set(targetVariableEntity);
-        const resultAssignment = assignmentStatement(resultSetAccess, constructorCall);
+        const resultAssignment = assignmentStatement(variableGetAccess(targetVariableEntity), constructorCall);
         bodyStatements.splice(ownConstructorCall.statementIndex, 1, resultAssignment);
       }
     }
     const targetVariableDeclaration = localVariableDeclarationStatement(targetVariableEntity, void 0);
-    const returnStatement3 = returnStatement(VariableAccessExpression.get(targetVariableEntity));
+    const returnStatement3 = returnStatement(variableGetAccess(targetVariableEntity));
     body.statements = Query.from([targetVariableDeclaration]).chain(bodyStatements).chain([returnStatement3]).toArray();
   }
   createTargetParameter(typeEntity, containingPackage) {
@@ -62140,7 +62235,7 @@ var AliasTypeAndExtensionLowering = class {
     } else {
       type = this.ctx.ectx.createIdentitySubstitutedType(typeEntity);
     }
-    return new IntrinsicVariableEntity(name, type, containingPackage);
+    return parameterEntity(name, type, containingPackage, false);
   }
 };
 var AliasTypeAndExtensionMembersAccessLowering = class extends ExecutableCodeLowering {
@@ -62154,7 +62249,7 @@ var AliasTypeAndExtensionMembersAccessLowering = class extends ExecutableCodeLow
           const { expression, tempVariables } = this.lowerMethodCall(node);
           return replaceExpression(expression, tempVariables);
         } else {
-          node.expression.method = new AccessedFunction5(realBasicMethod, node.expression.method.returnType);
+          node.expression.method = accessedFunction(realBasicMethod, node.expression.method.returnType);
           return preserveExpression();
         }
       }
@@ -62193,7 +62288,7 @@ var AliasTypeAndExtensionMembersAccessLowering = class extends ExecutableCodeLow
     const tempVariables = new Array();
     let receiver = callee.expression;
     if (this.ctx.isPossiblyCastedBaseExpression(receiver)) {
-      receiver = new ThisExpression(this.ctx.ectx.type.ofExpression(receiver), receiver.sourceLocation);
+      receiver = thisExpression(this.ctx.ectx.type.ofExpression(receiver), receiver.sourceLocation);
     }
     const expression = this.createMemberAccessWithNullCheck(
       receiver,
@@ -62209,7 +62304,7 @@ var AliasTypeAndExtensionMembersAccessLowering = class extends ExecutableCodeLow
   }
   lowerConstructorCall(node) {
     return staticMethodCallExpression(
-      new AccessedFunction5(node.entity, node.returnType),
+      accessedFunction(node.entity, node.returnType),
       node.args,
       node.sourceLocation
     ).withOptions(new CallExpressionEmitOptions().setIsAliasOrExtensionMethodCallLowered(true));
@@ -62222,7 +62317,7 @@ var AliasTypeAndExtensionMembersAccessLowering = class extends ExecutableCodeLow
     const tempVariables = new Array();
     let receiver = node.expression;
     if (this.ctx.isPossiblyCastedBaseExpression(receiver)) {
-      receiver = new ThisExpression(this.ctx.ectx.type.ofExpression(receiver), receiver.sourceLocation);
+      receiver = thisExpression(this.ctx.ectx.type.ofExpression(receiver), receiver.sourceLocation);
     }
     const expression = this.createMemberAccessWithNullCheck(
       receiver,
@@ -62257,7 +62352,7 @@ var AliasTypeAndExtensionMembersAccessLowering = class extends ExecutableCodeLow
   createCallOfMethodWithExplicitReceiver(entity, receiver, args, returnType) {
     const newArguments = [receiver, ...args.values];
     const options = new CallExpressionEmitOptions().setIsAliasOrExtensionMethodCallLowered(true);
-    return staticMethodCallExpression(new AccessedFunction5(entity, returnType), newArguments).withOptions(options);
+    return staticMethodCallExpression(accessedFunction(entity, returnType), newArguments).withOptions(options);
   }
   lowerSimpleAssignmentToComputedVariable(left, value) {
     const setter = left.field.entity.setter;
@@ -62265,7 +62360,7 @@ var AliasTypeAndExtensionMembersAccessLowering = class extends ExecutableCodeLow
     const args = new OrderedArguments([value], false);
     let receiver = left.expression;
     if (this.ctx.isPossiblyCastedBaseExpression(receiver)) {
-      receiver = new ThisExpression(this.ctx.ectx.type.ofExpression(receiver), receiver.sourceLocation);
+      receiver = thisExpression(this.ctx.ectx.type.ofExpression(receiver), receiver.sourceLocation);
     }
     const callExpression3 = this.createCallOfMethodWithExplicitReceiver(
       setter,
@@ -62281,13 +62376,13 @@ var AliasTypeAndExtensionMembersAccessLowering = class extends ExecutableCodeLow
     const tempVariables = new Array();
     let receiver = left.expression;
     if (this.ctx.isPossiblyCastedBaseExpression(receiver)) {
-      receiver = new ThisExpression(this.ctx.ectx.type.ofExpression(receiver), receiver.sourceLocation);
+      receiver = thisExpression(this.ctx.ectx.type.ofExpression(receiver), receiver.sourceLocation);
     }
     const [, receiverTempAssignment, receiverTempAccess] = this.createCachingTemporaryVariable(
       receiver,
       tempVariables
     );
-    const variableGetAccess2 = FieldAccessExpression.get(receiverTempAccess, false, left.field, void 0);
+    const variableGetAccess2 = instanceFieldGetAccess(receiverTempAccess, left.field, false);
     const binaryOperator = this.ctx.getBinaryExpressionOperatorFromAssignmentOperator(operatorKind);
     const newValue = binaryExpression(this.ctx.ectx, variableGetAccess2, binaryOperator, value).withOperator(operator);
     const args = new OrderedArguments([newValue], false);
@@ -62310,14 +62405,19 @@ var PlainObjectConstructorsLowering = class {
       if (!(declaration.kind === 23 /* PackageTypeDeclaration */ && declaration.entity.typeOrExtensionKind === 0 /* StructuredType */ && declaration.entity.details.structuredTypeKind === 1 /* PlainObject */)) {
         continue;
       }
-      const defaultConstructorEntity = new IntrinsicFunctionEntity(
+      const defaultConstructorEntity = typeMemberFunctionEntity(
         2 /* Constructor */,
         EmitPhaseName.ofConstructor(declaration.entity.containingPackage.locale),
         [],
         this.ctx.ectx.createIdentitySubstitutedType(declaration.entity),
-        declaration.entity.containingPackage
+        declaration.entity,
+        false,
+        [],
+        false,
+        false,
+        false,
+        void 0
       );
-      defaultConstructorEntity.ifTypeMemberThenContainingType = declaration.entity;
       declaration.entity.members = Array.from([defaultConstructorEntity]).concat(declaration.entity.members);
       declaration.members = declaration.members.map((member) => {
         if (member.kind === 49 /* ConstructorDeclaration */) {
@@ -62332,29 +62432,22 @@ var PlainObjectConstructorsLowering = class {
     Debug.assertNotNull(containingType);
     node.entity.functionEntityKind = 0 /* RegularFunction */;
     node.entity.details.isStatic = true;
-    const newThisVariable = new IntrinsicVariableEntity(
+    const newThisVariable = localVariableEntity(
       EmitPhaseName.ofPlainObjectMethodNewThisVariable(node.entity.containingPackage.locale),
       this.ctx.ectx.createIdentitySubstitutedType(containingType),
-      node.entity.containingPackage
-    );
-    const initializer = new ConstructorCallExpression(
-      defaultConstructor,
-      containingType,
-      new TypeAccessExpression(containingType, void 0),
-      new OrderedArguments([], false),
-      this.ctx.ectx.createIdentitySubstitutedType(containingType),
-      void 0,
-      new ConstructorCallExpressionEmitOptions().setIsPlainObjectConstructorCallLowered(true)
+      node.entity.containingPackage,
+      false
     );
+    const initializer = constructorCallExpression(this.ctx.ectx, defaultConstructor, []).withOptions(new ConstructorCallExpressionEmitOptions().setIsPlainObjectConstructorCallLowered(true));
     const newThisVariableDeclaration = localVariableDeclarationStatement(newThisVariable, initializer);
     const transformer = new Transformer({
       transformThisExpression: (_) => {
-        const variableAccess = VariableAccessExpression.get(newThisVariable);
+        const variableAccess = variableGetAccess(newThisVariable);
         return replaceExpression(variableAccess);
       },
       transformReturnStatement: (returnStatement4) => {
         if (transformer.transformedDeclaration === node) {
-          returnStatement4.expression = VariableAccessExpression.get(newThisVariable);
+          returnStatement4.expression = variableGetAccess(newThisVariable);
         }
         return preserveStatement();
       },
@@ -62366,18 +62459,9 @@ var PlainObjectConstructorsLowering = class {
       }
     });
     transformer.transformBlockStatementChildren(node.body);
-    const returnStatement3 = returnStatement(VariableAccessExpression.get(newThisVariable));
+    const returnStatement3 = returnStatement(variableGetAccess(newThisVariable));
     node.body.statements = [newThisVariableDeclaration, ...node.body.statements, returnStatement3];
-    return new MethodDeclaration2(
-      node.decorators,
-      new Modifiers().makeStatic(),
-      node.parameters,
-      node.body,
-      node.entity,
-      false,
-      void 0,
-      void 0
-    );
+    return methodDeclaration(node.entity, node.parameters, node.body, false, node.sourceLocation).withDecorators(node.decorators);
   }
 };
 var PlainObjectConstructorCallsLowering = class extends ExecutableCodeLowering {
@@ -62390,7 +62474,7 @@ var PlainObjectConstructorCallsLowering = class extends ExecutableCodeLowering {
   }
   lowerPlainObjectConstructorCall(node) {
     return staticMethodCallExpression(
-      new AccessedFunction5(node.entity, node.returnType),
+      accessedFunction(node.entity, node.returnType),
       node.args,
       node.sourceLocation
     );
@@ -62436,17 +62520,17 @@ var OverloadedConstructorsLowering = class {
     const declarationByEntity = /* @__PURE__ */ new Map();
     const loweredConstructorEntities = /* @__PURE__ */ new Set();
     const notLoweredConstructorInfos = new Array();
-    for (const constructorDeclaration of constructorDeclarations) {
-      declarationByEntity.set(constructorDeclaration.entity, constructorDeclaration);
-      const ownConstructorCall = this.ctx.findOwnConstructorCall(constructorDeclaration.body);
+    for (const constructorDeclaration2 of constructorDeclarations) {
+      declarationByEntity.set(constructorDeclaration2.entity, constructorDeclaration2);
+      const ownConstructorCall = this.ctx.findOwnConstructorCall(constructorDeclaration2.body);
       if (ownConstructorCall !== void 0) {
         notLoweredConstructorInfos.push({
-          declaration: constructorDeclaration,
+          declaration: constructorDeclaration2,
           ownConstructorCallExpression: ownConstructorCall.expression,
           statementIndex: ownConstructorCall.statementIndex
         });
       } else {
-        loweredConstructorEntities.add(constructorDeclaration.entity);
+        loweredConstructorEntities.add(constructorDeclaration2.entity);
       }
     }
     while (notLoweredConstructorInfos.length > 0) {
@@ -62486,11 +62570,11 @@ var OverloadedConstructorsLowering = class {
       parameter.defaultValue = void 0;
       const isEmptyCheck = binaryExpression(
         this.ctx.ectx,
-        VariableAccessExpression.get(parameter.entity),
+        variableGetAccess(parameter.entity),
         5 /* Equals */,
         nullLiteral()
       );
-      const assignmentStatement2 = assignmentStatement(VariableAccessExpression.set(parameter.entity), defaultValue);
+      const assignmentStatement2 = assignmentStatement(variableSetAccess(parameter.entity), defaultValue);
       const ifStatement3 = ifStatement(isEmptyCheck, blockStatement([assignmentStatement2]), void 0);
       statements.push(ifStatement3);
     }
@@ -62499,29 +62583,29 @@ var OverloadedConstructorsLowering = class {
   mergeOverloadedConstructors(constructorDeclarations, constructorGroup) {
     const constructorEntity = constructorGroup.mergedConstructor;
     const constructorParameters = constructorEntity.parameters;
-    const mergedParameters = constructorParameters.map((p) => new ParameterDeclaration2(p, void 0, false, void 0));
+    const mergedParameters = constructorParameters.map((p) => parameterDeclaration(p, void 0, false));
     const caseClauses = [];
     const constructorDeclarationByEntity = new Map(constructorDeclarations.map((c) => [c.entity, c]));
     for (const constructor of constructorGroup.constructors) {
-      const constructorDeclaration = constructorDeclarationByEntity.get(constructor);
-      Debug.assertNotNull(constructorDeclaration);
+      const constructorDeclaration2 = constructorDeclarationByEntity.get(constructor);
+      Debug.assertNotNull(constructorDeclaration2);
       const overloadId = constructorGroup.getOverloadId(constructor);
       const expression = numericLiteral(overloadId);
       const parameterDeclarations = Query.zip(
         constructor.parameters,
         constructorGroup.mergedConstructor.parameters.slice(1),
-        (original, merged) => localVariableDeclarationStatement(original, VariableAccessExpression.get(merged)).withOptions(new DeclarationWithInitializerEmitOptions(false))
+        (original, merged) => localVariableDeclarationStatement(original, variableGetAccess(merged)).withOptions(new DeclarationWithInitializerEmitOptions(false))
       ).toArray();
-      const body = constructorDeclaration.body;
-      const bodyStatements = parameterDeclarations.concat(constructorDeclaration.body.statements);
+      const body = constructorDeclaration2.body;
+      const bodyStatements = parameterDeclarations.concat(constructorDeclaration2.body.statements);
       body.statements = bodyStatements;
       caseClauses.push(caseClause([expression], body));
     }
-    const overloadIdAccess = VariableAccessExpression.get(constructorParameters[0]);
-    const defaultClauseBody = blockStatement([errorStatement(new TextLiteral2(""))]);
+    const overloadIdAccess = variableGetAccess(constructorParameters[0]);
+    const defaultClauseBody = blockStatement([errorStatement(textLiteral(""))]);
     const switchStatement3 = switchStatement(overloadIdAccess, caseClauses, defaultClauseBody);
     const constructorBody = blockStatement([switchStatement3]);
-    return new ConstructorDeclaration2([], mergedParameters, constructorBody, constructorEntity, void 0);
+    return constructorDeclaration(constructorEntity, mergedParameters, constructorBody);
   }
   inlineCalledConstructorBody(declaration, callExpression3, statementIndex, calledConstructorDeclaration) {
     const parameterAssignments = Query.zip(
@@ -62536,8 +62620,8 @@ var OverloadedConstructorsLowering = class {
   }
 };
 var OverloadedConstructorCallsLowering = class extends ExecutableCodeLowering {
-  constructor(ctx, packageEntity, overloadedConstructorGroupByOriginalConstructor) {
-    super(ctx, packageEntity);
+  constructor(ctx, packageEntity2, overloadedConstructorGroupByOriginalConstructor) {
+    super(ctx, packageEntity2);
     this.overloadedConstructorGroupByOriginalConstructor = overloadedConstructorGroupByOriginalConstructor;
   }
   tryLowerConstructorCallExpression(node) {
@@ -62583,30 +62667,37 @@ var OverloadedConstructorGroup = class {
   createMergedConstructor() {
     const locale = this.containingType.containingPackage.locale;
     const idParameterName = EmitPhaseName.ofMergedConstructorIdParameter(locale);
-    const idParameterEntity = new IntrinsicVariableEntity(
+    const idParameterEntity = parameterEntity(
       idParameterName,
       this.ectx.standardTypes.integer,
-      this.containingType.containingPackage
+      this.containingType.containingPackage,
+      false
     );
     const mergedParameters = [idParameterEntity];
     const parameterCount = Query.maxByValue(this.constructors, (c) => c.parameters.length)?.parameters.length ?? 0;
     for (let id = 0; id < parameterCount; id++) {
       const parameterName = EmitPhaseName.ofMergedConstructorParameter(locale, id);
-      const parameter = new IntrinsicVariableEntity(
+      const parameter = parameterEntity(
         parameterName,
         this.ectx.standardTypes.refObject,
-        this.containingType.containingPackage
+        this.containingType.containingPackage,
+        false
       );
       mergedParameters.push(parameter);
     }
-    const result = new IntrinsicFunctionEntity(
+    const result = typeMemberFunctionEntity(
       2 /* Constructor */,
       EmitPhaseName.ofConstructor(locale),
       mergedParameters,
       this.ectx.createIdentitySubstitutedType(this.containingType),
-      this.containingType.containingPackage
+      this.containingType,
+      false,
+      [],
+      false,
+      false,
+      false,
+      void 0
     );
-    result.ifTypeMemberThenContainingType = this.containingType;
     return result;
   }
 };
@@ -62666,9 +62757,9 @@ var MiscLowering = class {
       }
       sourcePackageEntities.add(pkgIr.entity);
     }
-    for (const packageEntity of ctx.ectx.entityMap.enumerateAllPackageEntities()) {
-      if (!sourcePackageEntities.has(packageEntity)) {
-        for (const packageMember of packageEntity.members) {
+    for (const packageEntity2 of ctx.ectx.entityMap.enumerateAllPackageEntities()) {
+      if (!sourcePackageEntities.has(packageEntity2)) {
+        for (const packageMember of packageEntity2.members) {
           if (packageMember.kind === "type-or-extension") {
             this.resolveComputedNamesOfTypeMembers(packageMember);
           }
@@ -62678,43 +62769,34 @@ var MiscLowering = class {
   }
   static createThisPackageVariables(ctx) {
     for (const pkg2 of ctx.packages) {
-      const packageEntity = pkg2.ir.entity;
-      const variableEntity = new IntrinsicVariableEntity(
-        EmitPhaseName.ofThisPackageVariable(packageEntity.locale),
+      const packageEntity2 = pkg2.ir.entity;
+      const variableEntity = packageVariableEntity(
+        EmitPhaseName.ofThisPackageVariable(packageEntity2.locale),
         ctx.ectx.createIdentitySubstitutedType(ctx.packageType),
-        packageEntity
+        packageEntity2,
+        true
       );
-      variableEntity.isPackageMember = true;
-      packageEntity.members = packageEntity.members.concat(variableEntity);
-      packageEntity.details.thisPackageVariableEntity = variableEntity;
+      packageEntity2.members = packageEntity2.members.concat(variableEntity);
+      packageEntity2.details.thisPackageVariableEntity = variableEntity;
       const variableDeclaration2 = packageVariableDeclaration(variableEntity, void 0);
       const packageMembers = Array.from(pkg2.ir.declarations);
       packageMembers.unshift(variableDeclaration2);
       pkg2.ir.declarations = packageMembers;
-      const packageConstructorCall = new ConstructorCallExpression(
+      const packageConstructorCall = constructorCallExpression(
+        ctx.ectx,
         ctx.packageConstructor,
-        ctx.packageType,
-        new TypeAccessExpression(ctx.packageType, void 0),
-        new OrderedArguments([new TextLiteral2(packageEntity.name, void 0)], false, void 0),
-        variableEntity.type,
-        void 0
+        [textLiteral(packageEntity2.name)]
       );
       const thisPackageVariableAssignment = assignmentStatement(
-        VariableAccessExpression.get(variableEntity),
+        variableGetAccess(variableEntity),
         packageConstructorCall
       );
       const statements = [thisPackageVariableAssignment];
-      if (packageEntity.details.isMainPackage) {
-        const mainPackageFieldAccess = FieldAccessExpression.get(
-          new TypeAccessExpression(ctx.packageType, void 0),
-          false,
-          ctx.packageMainPackageField,
-          void 0,
-          void 0
-        );
+      if (packageEntity2.details.isMainPackage) {
+        const mainPackageFieldAccess = staticFieldGetAccess(ctx.packageMainPackageField);
         const mainPackageFieldAssignment = assignmentStatement(
           mainPackageFieldAccess,
-          VariableAccessExpression.get(variableEntity)
+          variableGetAccess(variableEntity)
         );
         statements.push(mainPackageFieldAssignment);
       }
@@ -62748,10 +62830,10 @@ var MiscLowering = class {
   }
 };
 var CompoundDeclarationsAndOperatorsAccessLowering = class extends ExecutableCodeLowering {
-  constructor(ctx, packageEntity) {
-    super(ctx, packageEntity);
-    this.indexedAccessExpressionLowering = new IndexedAccessExpressionLowering(ctx, packageEntity);
-    this.dereferenceExpressionLowering = new DereferenceExpressionLowering(ctx, packageEntity);
+  constructor(ctx, packageEntity2) {
+    super(ctx, packageEntity2);
+    this.indexedAccessExpressionLowering = new IndexedAccessExpressionLowering(ctx, packageEntity2);
+    this.dereferenceExpressionLowering = new DereferenceExpressionLowering(ctx, packageEntity2);
   }
   tryLowerIndexedAccessExpression(node) {
     if (node.access.kind === 0 /* Get */ && node.access.getAccessor.entity.containingPackage.details.isSource) {
@@ -62800,26 +62882,26 @@ var CompoundDeclarationsAndOperatorsAccessLowering = class extends ExecutableCod
   lowerComputedPackageVariableGetAccessExpression(node) {
     const getter = node.variable.entity.getter;
     Debug.assertNotNull(getter);
-    return functionCallExpression(new AccessedFunction5(getter, node.variable.type), []);
+    return functionCallExpression(accessedFunction(getter, node.variable.type), []);
   }
   lowerComputedPackageVariableSetAccessExpression(left, operatorKind, right, operator, sourceLocation) {
     let value;
     if (operatorKind === 0 /* Equals */) {
       value = right;
     } else {
-      const variableGetAccess2 = VariableAccessExpression.get(left.variable);
+      const variableGetAccess2 = variableGetAccess(left.variable);
       const binaryOperator = this.ctx.getBinaryExpressionOperatorFromAssignmentOperator(operatorKind);
       value = binaryExpression(this.ctx.ectx, variableGetAccess2, binaryOperator, right).withOperator(operator);
     }
     const setter = left.variable.entity.setter;
     Debug.assertNotNull(setter);
-    const callExpression3 = functionCallExpression(new AccessedFunction5(setter, left.variable.type), [value]);
+    const callExpression3 = functionCallExpression(accessedFunction(setter, left.variable.type), [value]);
     return expressionStatement(callExpression3, sourceLocation);
   }
 };
 var IndexedAccessExpressionLowering = class extends ExecutableCodeLowering {
-  constructor(ctx, packageEntity) {
-    super(ctx, packageEntity);
+  constructor(ctx, packageEntity2) {
+    super(ctx, packageEntity2);
   }
   /**
    * @example Понижающее преобразование команды чтения
@@ -62915,8 +62997,8 @@ var IndexedAccessExpressionLowering = class extends ExecutableCodeLowering {
   }
 };
 var DereferenceExpressionLowering = class extends ExecutableCodeLowering {
-  constructor(ctx, packageEntity) {
-    super(ctx, packageEntity);
+  constructor(ctx, packageEntity2) {
+    super(ctx, packageEntity2);
   }
   /**
    * @example Понижающее преобразование команды чтения
@@ -63000,8 +63082,8 @@ var FunctionObjectLowering = class _FunctionObjectLowering extends ExecutableCod
   static {
     this.ContextFieldName = "_0";
   }
-  constructor(ctx, packageEntity) {
-    super(ctx, packageEntity);
+  constructor(ctx, packageEntity2) {
+    super(ctx, packageEntity2);
   }
   tryLowerFunctionAccessExpression(node) {
     if (!node.isCallee && node.options.bindIfNotCallee) {
@@ -63040,20 +63122,21 @@ var FunctionObjectLowering = class _FunctionObjectLowering extends ExecutableCod
     } else {
       receiverTempGetAccess = receiverIfBaseExpression;
     }
-    const argsParameter = new IntrinsicVariableEntity(
+    const argsParameter = parameterEntity(
       "args",
       this.ctx.ectx.standardTypes.refObject,
-      node.method.entity.containingPackage
+      node.method.entity.containingPackage,
+      false
     );
     argsParameter.details.isVariadicParameter = true;
     const methodCall = instanceMethodCallExpression(
       receiverTempGetAccess,
       node.method,
-      orderedArguments([VariableAccessExpression.get(argsParameter)], true),
+      orderedArguments([variableGetAccess(argsParameter)], true),
       false
     );
     const returnStatement3 = returnStatement(methodCall);
-    const parameter = new ParameterDeclaration2(argsParameter, void 0, true, void 0);
+    const parameter = parameterDeclaration(argsParameter, void 0, true);
     const functionLiteral2 = functionLiteral(
       [parameter],
       blockStatement([returnStatement3]),
@@ -63073,7 +63156,7 @@ var FunctionObjectLowering = class _FunctionObjectLowering extends ExecutableCod
       if (receiverIfBaseExpression === void 0) {
         context = receiverTempGetAccess;
       } else {
-        context = new ThisExpression(this.ctx.ectx.type.ofExpression(receiverIfBaseExpression), void 0);
+        context = thisExpression(this.ctx.ectx.type.ofExpression(receiverIfBaseExpression));
       }
       contextFieldAssignment = assignmentExpression(contextFieldSetAccess, context);
     }
@@ -63095,18 +63178,12 @@ var FunctionObjectLowering = class _FunctionObjectLowering extends ExecutableCod
       }
       expressions.push(boundMethodTempGetAccess);
       const secondExpression = commaExpression(expressions);
-      const ternaryExpression = new TernaryExpression(
-        nullCheck,
-        firstExpression,
-        secondExpression,
-        this.ctx.ectx.type.ofExpression(node),
-        void 0
-      );
+      const ternaryExpression2 = ternaryExpression(nullCheck, firstExpression, secondExpression);
       const resultExpressions = new Array();
       if (receiverTempAssignment !== void 0) {
         resultExpressions.push(receiverTempAssignment);
       }
-      resultExpressions.push(ternaryExpression);
+      resultExpressions.push(ternaryExpression2);
       resultExpression = commaExpression(resultExpressions, node.sourceLocation);
     } else {
       const resultExpressions = new Array();
@@ -63147,34 +63224,25 @@ var VariableProxyLowering = class {
     for (const member of declaration.members) {
       if (member.kind === 54 /* FieldDeclaration */ && member.entity.details.isProxiedField !== void 0) {
         const proxiedFieldInfo = member.entity.details.isProxiedField;
-        const proxyVariableEntity = new IntrinsicVariableEntity(
+        const proxyVariableEntity = fieldEntity(
           EmitPhaseName.ofProxyVariable(member.entity.containingPackage.locale, member.entity.name),
           this.ctx.ectx.createIdentitySubstitutedType(proxiedFieldInfo.tagType),
-          member.entity.containingPackage
+          declaration.entity,
+          [],
+          false,
+          false,
+          member.entity.details.isStatic,
+          member.entity.details.isConst,
+          void 0
         );
-        proxyVariableEntity.ifTypeMemberThenContainingType = declaration.entity;
         let args;
         if (member.initializer !== void 0) {
-          args = new OrderedArguments([member.initializer], false);
+          args = [member.initializer];
         } else {
-          args = new OrderedArguments([], false);
+          args = [];
         }
-        const initializer = new ConstructorCallExpression(
-          proxiedFieldInfo.constructor,
-          proxiedFieldInfo.tagType,
-          new TypeAccessExpression(proxiedFieldInfo.tagType, void 0),
-          args,
-          proxyVariableEntity.type,
-          void 0
-        );
-        const proxyVariableDeclaration = new FieldDeclaration2(
-          [],
-          member.modifiers,
-          initializer,
-          proxyVariableEntity,
-          void 0,
-          void 0
-        );
+        const initializer = constructorCallExpression(this.ctx.ectx, proxiedFieldInfo.constructor, args);
+        const proxyVariableDeclaration = fieldDeclaration(proxyVariableEntity, initializer);
         proxyVariableDeclarations.push(proxyVariableDeclaration);
         proxyVariableByOriginal.set(member.entity, proxyVariableEntity);
       }
@@ -63492,7 +63560,7 @@ var UsagesLowering = class _UsagesLowering extends ExecutableCodeLowering {
       statement.indexVariableEntity,
       indexVariableInitializer
     );
-    const indexVariableAccess = VariableAccessExpression.set(statement.indexVariableEntity);
+    const indexVariableAccess = variableSetAccess(statement.indexVariableEntity);
     const oneLiteral = numericLiteral(1);
     const indexVariableIncrement = assignmentStatementWithOperatorKind(
       indexVariableAccess,
@@ -63514,15 +63582,7 @@ var UsagesLowering = class _UsagesLowering extends ExecutableCodeLowering {
     Debug.assertNotNull(enumeratorMethod);
     node.options.addExplicitCallOfEnumeratorMethodIfRequired = false;
     const iteratorField = this.ctx.iteratorSymbolField;
-    Debug.assertNotNull(iteratorField.ifTypeMemberThenContainingType);
-    const key = new FieldAccessExpression(
-      new TypeAccessExpression(iteratorField.ifTypeMemberThenContainingType, void 0),
-      false,
-      AccessedVariable.fromEntity(iteratorField),
-      0 /* Get */,
-      void 0,
-      void 0
-    );
+    const key = staticFieldGetAccess(iteratorField);
     const enumeratorMethodCall = instanceMethodCallExpression(
       node.enumeratedExpression,
       enumeratorMethod,
@@ -63537,10 +63597,7 @@ var UsagesLowering = class _UsagesLowering extends ExecutableCodeLowering {
     return this.createTextTemplateConstructorCall(node.textFragments, node.expressions, node.sourceLocation);
   }
   lowerLocalizableTextLiteral(node) {
-    const translateMethodArgs = [
-      staticFieldGetAccess(this.ctx.packageThisPackageField),
-      new TextLiteral2(node.value, void 0)
-    ];
+    const translateMethodArgs = [staticFieldGetAccess(this.ctx.packageThisPackageField), textLiteral(node.value)];
     if (node.code !== void 0) {
       translateMethodArgs.push(numericLiteral(node.code));
     }
@@ -63568,16 +63625,12 @@ var UsagesLowering = class _UsagesLowering extends ExecutableCodeLowering {
     return result;
   }
   createTextTemplateConstructorCall(textFragments, expressions, sourceLocation) {
-    const textFragmentsArray = arrayLiteral(this.ctx.ectx, textFragments.map((s) => new TextLiteral2(s, void 0)));
+    const textFragmentsArray = arrayLiteral(this.ctx.ectx, textFragments.map((s) => textLiteral(s)));
     const expressionArray = arrayLiteral(this.ctx.ectx, expressions);
-    const args = new OrderedArguments([textFragmentsArray, expressionArray], false);
-    const typeAccess = new TypeAccessExpression(this.ctx.textTemplateType, void 0);
-    const constructorCall = new ConstructorCallExpression(
+    const constructorCall = constructorCallExpression(
+      this.ctx.ectx,
       this.ctx.textTemplateConstructor,
-      this.ctx.textTemplateType,
-      typeAccess,
-      args,
-      this.ctx.ectx.standardTypes.textTemplate,
+      [textFragmentsArray, expressionArray],
       sourceLocation
     );
     return constructorCall;
@@ -63598,14 +63651,14 @@ var UsagesLowering = class _UsagesLowering extends ExecutableCodeLowering {
     const containingType = node.field.entity.ifTypeMemberThenContainingType;
     Debug.assertNotNull(containingType);
     if (!(node.expression.kind === 65 /* TypeAccessExpression */ && node.expression.entity === containingType)) {
-      node.expression = new TypeAccessExpression(containingType, void 0);
+      node.expression = typeAccessExpression(containingType);
     }
   }
   lowerStaticAliasTypeMethodAccess(node) {
     const containingType = node.method.entity.ifTypeMemberThenContainingType;
     Debug.assertNotNull(containingType);
     if (!(node.expression.kind === 65 /* TypeAccessExpression */ && node.expression.entity === containingType)) {
-      node.expression = new TypeAccessExpression(containingType, void 0);
+      node.expression = typeAccessExpression(containingType);
     }
   }
   lowerErrorStatement(node) {
@@ -63654,7 +63707,7 @@ var UsagesLowering = class _UsagesLowering extends ExecutableCodeLowering {
       thisPackageVariable,
       "\u041F\u043E\u043B\u0435 packageEntity.details.thisPackageVariableEntity \u0434\u043E\u043B\u0436\u043D\u043E \u0431\u044B\u0442\u044C \u0443\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D\u043E \u043D\u0430 \u044D\u0442\u0430\u043F\u0435 \u0441\u043E\u0437\u0434\u0430\u043D\u0438\u044F \u043F\u0435\u0440\u0435\u043C\u0435\u043D\u043D\u043E\u0439 \u0441\u0432\u043E\u0439-\u043F\u0430\u043A\u0435\u0442."
     );
-    return replaceExpression(VariableAccessExpression.get(thisPackageVariable));
+    return replaceExpression(variableGetAccess(thisPackageVariable));
   }
 };
 var OperatorsUsageLowering = class extends ExecutableCodeLowering {
@@ -63711,23 +63764,19 @@ var OperatorsUsageLowering = class extends ExecutableCodeLowering {
     switch (left.kind) {
       case 66 /* VariableAccessExpression */:
         leftExpressionSetAccess = left;
-        leftExpressionGetAccess = VariableAccessExpression.get(left.variable);
+        leftExpressionGetAccess = variableGetAccess(left.variable);
         break;
       case 70 /* FieldAccessExpression */: {
         const [, receiverTempAssignment, receiverTempGetAccess] = this.createCachingTemporaryVariable(
           left.expression,
           tempVariables
         );
-        leftExpressionSetAccess = FieldAccessExpression.set(
+        leftExpressionSetAccess = instanceFieldSetAccess(
           receiverTempAssignment ?? receiverTempGetAccess,
-          false,
-          left.field
-        );
-        leftExpressionGetAccess = FieldAccessExpression.get(
-          receiverTempGetAccess,
-          false,
-          left.field
+          left.field,
+          false
         );
+        leftExpressionGetAccess = instanceFieldGetAccess(receiverTempGetAccess, left.field, false);
         break;
       }
       case 85 /* JsPropertyAccessExpression */: {
@@ -63772,7 +63821,7 @@ var OperatorsUsageLowering = class extends ExecutableCodeLowering {
       }
       case 59 /* ThisExpression */: {
         leftExpressionSetAccess = left;
-        leftExpressionGetAccess = new ThisExpression(left.type, void 0);
+        leftExpressionGetAccess = thisExpression(left.type);
         break;
       }
       case 29 /* IndexedAccessExpression */: {
@@ -63819,8 +63868,8 @@ var OperatorsUsageLowering = class extends ExecutableCodeLowering {
   }
 };
 var ProxiedVariableAccessLowering = class extends ExecutableCodeLowering {
-  constructor(ctx, packageEntity, proxyVariableByOriginal) {
-    super(ctx, packageEntity);
+  constructor(ctx, packageEntity2, proxyVariableByOriginal) {
+    super(ctx, packageEntity2);
     this.proxyVariableByOriginal = proxyVariableByOriginal;
   }
   tryLowerFieldAccessExpression(node) {
@@ -63915,8 +63964,8 @@ var ProxiedVariableAccessLowering = class extends ExecutableCodeLowering {
   }
 };
 var ReferenceExpressionLowering = class extends ExecutableCodeLowering {
-  constructor(ctx, packageEntity) {
-    super(ctx, packageEntity);
+  constructor(ctx, packageEntity2) {
+    super(ctx, packageEntity2);
   }
   lower(node) {
     const referencedExpression = node.expression;
@@ -63968,32 +64017,32 @@ var ReferenceExpressionLowering = class extends ExecutableCodeLowering {
     return { expression: commaExpression2, tempVariables };
   }
   lowerVariableAccessExpressionReference(referencedExpression, sourceLocation) {
-    const variableGetAccess2 = VariableAccessExpression.get(referencedExpression.variable);
+    const variableGetAccess2 = variableGetAccess(referencedExpression.variable);
     const reader = this.createReaderMethod(variableGetAccess2);
     let writer;
     if (referencedExpression.accessKind === 2 /* GetSet */) {
-      const variableSetAccess = VariableAccessExpression.set(referencedExpression.variable);
-      writer = this.createWriterMethod(variableSetAccess);
+      const variableSetAccess2 = variableSetAccess(referencedExpression.variable);
+      writer = this.createWriterMethod(variableSetAccess2);
     }
     return this.createReference(reader, writer, sourceLocation);
   }
   lowerFieldAccessExpressionReference(referencedExpression, sourceLocation) {
     const tempVariables = new Array();
     const [, receiverAssignment, receiverGetAccess] = this.createCachingTemporaryVariable(referencedExpression.expression, tempVariables);
-    const variableGetAccess2 = FieldAccessExpression.get(
+    const variableGetAccess2 = instanceFieldGetAccess(
       receiverGetAccess,
-      referencedExpression.isOptionalAccess,
-      referencedExpression.field
+      referencedExpression.field,
+      referencedExpression.isOptionalAccess
     );
     const reader = this.createReaderMethod(variableGetAccess2);
     let writer;
     if (referencedExpression.accessKind === 2 /* GetSet */) {
-      const variableSetAccess = FieldAccessExpression.set(
+      const variableSetAccess2 = instanceFieldSetAccess(
         receiverGetAccess,
-        referencedExpression.isOptionalAccess,
-        referencedExpression.field
+        referencedExpression.field,
+        referencedExpression.isOptionalAccess
       );
-      writer = this.createWriterMethod(variableSetAccess);
+      writer = this.createWriterMethod(variableSetAccess2);
     }
     const reference = this.createReference(reader, writer, sourceLocation);
     const expressions = new Array();
@@ -64010,13 +64059,14 @@ var ReferenceExpressionLowering = class extends ExecutableCodeLowering {
     return this.createSingleStatementFunctionLiteral([], returnStatement3, returnType);
   }
   createWriterMethod(setExpression) {
-    const valueEntity = new IntrinsicVariableEntity(
+    const valueEntity = parameterEntity(
       "value",
       this.ctx.ectx.type.ofExpression(setExpression),
-      this.packageEntity
+      this.packageEntity,
+      false
     );
-    const parameter = new ParameterDeclaration2(valueEntity, void 0, false, void 0);
-    const valueGetAccess = VariableAccessExpression.get(valueEntity);
+    const parameter = parameterDeclaration(valueEntity, void 0, false);
+    const valueGetAccess = variableGetAccess(valueEntity);
     const assignment = assignmentStatement(setExpression, valueGetAccess);
     return this.createSingleStatementFunctionLiteral([parameter], assignment, this.ctx.ectx.standardTypes.nullType);
   }
@@ -64048,7 +64098,7 @@ var VariableInitializersLowering = class {
       if (declaration.kind === 24 /* PackageVariableDeclaration */) {
         if (declaration.initializer !== void 0 && !declaration.options.shouldNotMoveInitializerToConstructor) {
           const assignment = assignmentStatement(
-            VariableAccessExpression.set(declaration.entity),
+            variableSetAccess(declaration.entity),
             declaration.initializer
           );
           statements.push(assignment);
@@ -64058,12 +64108,7 @@ var VariableInitializersLowering = class {
         if (declaration.entity.typeOrExtensionKind === 0 /* StructuredType */ || declaration.entity.typeOrExtensionKind === 1 /* AliasType */ || declaration.entity.typeOrExtensionKind === 5 /* TypeExtension */) {
           for (const member of declaration.members) {
             if (member.kind === 54 /* FieldDeclaration */ && member.initializer !== void 0 && member.entity.details.isStatic) {
-              const variableAccess = FieldAccessExpression.set(
-                new TypeAccessExpression(declaration.entity, void 0),
-                false,
-                member.entity,
-                void 0
-              );
+              const variableAccess = staticFieldSetAccess(member.entity);
               const assignment = assignmentStatement(variableAccess, member.initializer);
               statements.push(assignment);
               member.initializer = void 0;
@@ -64084,11 +64129,10 @@ var VariableInitializersLowering = class {
     const statements = new Array();
     for (const member of declaration.members) {
       if (member.kind === 54 /* FieldDeclaration */ && member.initializer !== void 0 && !member.entity.details.isStatic) {
-        const variableAccess = FieldAccessExpression.set(
-          new ThisExpression(this.ctx.ectx.createIdentitySubstitutedType(declaration.entity), void 0),
-          false,
+        const variableAccess = instanceFieldSetAccess(
+          thisExpression(this.ctx.ectx.createIdentitySubstitutedType(declaration.entity)),
           member.entity,
-          void 0
+          false
         );
         const assignment = assignmentStatement(variableAccess, member.initializer);
         statements.push(assignment);
@@ -64102,26 +64146,26 @@ var VariableInitializersLowering = class {
         return;
       }
       for (let i = 0; i < constructorDeclarations.length; i++) {
-        const constructorDeclaration = constructorDeclarations[i];
-        const baseConstructorCallInfo = this.ctx.findBaseConstructorCall(constructorDeclaration.body);
+        const constructorDeclaration2 = constructorDeclarations[i];
+        const baseConstructorCallInfo = this.ctx.findBaseConstructorCall(constructorDeclaration2.body);
         let index = 0;
         if (baseConstructorCallInfo !== void 0) {
           index = baseConstructorCallInfo.statementIndex + 1;
         }
-        const newBodyStatements = Array.from(constructorDeclaration.body.statements);
+        const newBodyStatements = Array.from(constructorDeclaration2.body.statements);
         if (i > 0) {
           newBodyStatements.splice(index, 0, ...statements.map((s) => s.clone()));
         } else {
           newBodyStatements.splice(index, 0, ...statements);
         }
-        constructorDeclaration.body.statements = newBodyStatements;
+        constructorDeclaration2.body.statements = newBodyStatements;
       }
     }
   }
 };
 var IsExpressionLowering = class extends ExecutableCodeLowering {
-  constructor(ctx, packageEntity) {
-    super(ctx, packageEntity);
+  constructor(ctx, packageEntity2) {
+    super(ctx, packageEntity2);
   }
   lower(expression) {
     let type = expression.type;
@@ -64205,13 +64249,13 @@ var IsExpressionLowering = class extends ExecutableCodeLowering {
   }
   createTypeOfCheck(expression, typeName, sourceLocation) {
     const typeOfExpression = jsTypeOfExpression(expression, sourceLocation);
-    const textLiteral2 = new TextLiteral2(typeName, void 0);
+    const textLiteral2 = textLiteral(typeName);
     return binaryExpression(this.ctx.ectx, typeOfExpression, 5 /* Equals */, textLiteral2);
   }
 };
 var BaseAspectMemberAccessLowering = class extends ExecutableCodeLowering {
-  constructor(ctx, packageEntity) {
-    super(ctx, packageEntity);
+  constructor(ctx, packageEntity2) {
+    super(ctx, packageEntity2);
   }
   tryLowerCallExpression(node) {
     const callee = node.expression;
@@ -64250,21 +64294,18 @@ var BaseAspectMemberAccessLowering = class extends ExecutableCodeLowering {
   lowerBaseAspectMethodCallExpression(node, callee) {
     const containingType = callee.method.entity.ifTypeMemberThenContainingType;
     Debug.assertNotNull(containingType);
-    const typeAccess = new TypeAccessExpression(containingType, void 0);
-    const aspectMethodAccess = new MethodAccessExpression(
+    const typeAccess = typeAccessExpression(containingType);
+    const aspectMethodAccess = methodAccessExpression(
       this.ctx.createPrototypeAccess(typeAccess),
       false,
       callee.method,
       /* isCallee = true чтобы не выполнять bind */
-      true,
-      void 0,
-      void 0,
-      new FunctionAccessExpressionEmitOptions().setForceUseNonComputedName(true)
-    );
+      true
+    ).withOptions(new FunctionAccessExpressionEmitOptions().setForceUseNonComputedName(true));
     const callMethodAccess = this.ctx.createJsFunctionCallMethodAccess(aspectMethodAccess);
     const originalArguments = this.ctx.getOrderedArguments(node.args);
     const newArguments = [
-      new ThisExpression(this.ctx.ectx.type.ofExpression(callee.expression), void 0),
+      thisExpression(this.ctx.ectx.type.ofExpression(callee.expression)),
       ...originalArguments.values
     ];
     return callExpression(
@@ -64283,10 +64324,10 @@ var BaseAspectMemberAccessLowering = class extends ExecutableCodeLowering {
   lowerBaseAspectFieldGetAccess(node) {
     const containingType = node.field.entity.ifTypeMemberThenContainingType;
     Debug.assertNotNull(containingType);
-    const aspectPrototypeAccess = this.ctx.createPrototypeAccess(new TypeAccessExpression(containingType, void 0));
+    const aspectPrototypeAccess = this.ctx.createPrototypeAccess(typeAccessExpression(containingType));
     const getOwnPropertyDescriptorCall = this.ctx.createGetOwnPropertyDescriptorCall(
       aspectPrototypeAccess,
-      new TextWithEntityName(node.field.entity, void 0)
+      textWithEntityName(node.field.entity)
     );
     const descriptorGetAccess = jsPropertyAccessExpression(
       getOwnPropertyDescriptorCall,
@@ -64295,7 +64336,7 @@ var BaseAspectMemberAccessLowering = class extends ExecutableCodeLowering {
       this.ctx.ectx.standardTypes.func
     );
     const callMethodAccess = this.ctx.createJsFunctionCallMethodAccess(descriptorGetAccess);
-    const callArguments = [new ThisExpression(this.ctx.ectx.type.ofExpression(node.expression), void 0)];
+    const callArguments = [thisExpression(this.ctx.ectx.type.ofExpression(node.expression))];
     return callExpression(callMethodAccess, false, callArguments, false, node.field.type, node.sourceLocation);
   }
   /**
@@ -64305,10 +64346,10 @@ var BaseAspectMemberAccessLowering = class extends ExecutableCodeLowering {
   lowerBaseAspectFieldAssignment(node, left) {
     const containingType = left.field.entity.ifTypeMemberThenContainingType;
     Debug.assertNotNull(containingType);
-    const aspectPrototypeAccess = this.ctx.createPrototypeAccess(new TypeAccessExpression(containingType, void 0));
+    const aspectPrototypeAccess = this.ctx.createPrototypeAccess(typeAccessExpression(containingType));
     const getOwnPropertyDescriptorCall = this.ctx.createGetOwnPropertyDescriptorCall(
       aspectPrototypeAccess,
-      new TextWithEntityName(left.field.entity, void 0)
+      textWithEntityName(left.field.entity)
     );
     const descriptorGetAccess = jsPropertyAccessExpression(
       getOwnPropertyDescriptorCall,
@@ -64317,7 +64358,7 @@ var BaseAspectMemberAccessLowering = class extends ExecutableCodeLowering {
       this.ctx.ectx.standardTypes.func
     );
     const callMethodAccess = this.ctx.createJsFunctionCallMethodAccess(descriptorGetAccess);
-    const callArguments = [new ThisExpression(this.ctx.ectx.type.ofExpression(left.expression), void 0), node.right];
+    const callArguments = [thisExpression(this.ctx.ectx.type.ofExpression(left.expression)), node.right];
     const expression = callExpression(
       callMethodAccess,
       false,
@@ -64341,23 +64382,14 @@ var TextTranslationsLowering = class {
   }
   lower() {
     for (const pkg2 of this.ctx.packages) {
-      const packageEntity = pkg2.ir.entity;
-      const textTranslationLocale = packageEntity.details.textTranslationLocale;
-      if (packageEntity.details.isTextTranslationPackage && textTranslationLocale !== void 0 && packageEntity.details.translationTarget !== void 0) {
-        const packageConstructorEntity = new IntrinsicFunctionEntity(
-          0 /* RegularFunction */,
-          EmitPhaseName.ofPackageConstructor(packageEntity.locale),
-          [],
-          this.ctx.ectx.standardTypes.nullType,
-          packageEntity
-        );
-        packageConstructorEntity.details.isPackageConstructor = true;
-        packageConstructorEntity.isPackageMember = true;
-        packageEntity.members = packageEntity.members.concat(packageConstructorEntity);
-        const dictionaryVariableEntity = new IntrinsicVariableEntity(
-          EmitPhaseName.ofDictionaryLocalVariable(packageEntity.locale),
+      const packageEntity2 = pkg2.ir.entity;
+      const textTranslationLocale = packageEntity2.details.textTranslationLocale;
+      if (packageEntity2.details.isTextTranslationPackage && textTranslationLocale !== void 0 && packageEntity2.details.translationTarget !== void 0) {
+        const dictionaryVariableEntity = localVariableEntity(
+          EmitPhaseName.ofDictionaryLocalVariable(packageEntity2.locale),
           this.ctx.ectx.createIdentitySubstitutedType(this.ctx.dictionaryType),
-          packageEntity
+          packageEntity2,
+          false
         );
         const dictionaryConstructorCall = constructorCallExpression(
           this.ctx.ectx,
@@ -64376,7 +64408,7 @@ var TextTranslationsLowering = class {
             textOrTranslationFunction = this.createTranslationFunctionLiteral(
               translation.translatedTextOrFunctionBlock,
               translation.sourceTextTemplate,
-              packageEntity
+              packageEntity2
             );
           } else {
             textOrTranslationFunction = translation.translatedTextOrFunctionBlock;
@@ -64393,28 +64425,25 @@ var TextTranslationsLowering = class {
         const translatorAddTranslationCall = staticMethodCallExpression(
           this.ctx.translatorAddTranslationToLocaleMethod,
           [
-            new TextLiteral2(packageEntity.details.translationTarget.name, void 0),
-            new TextLiteral2(localeToString(textTranslationLocale), void 0),
-            VariableAccessExpression.get(dictionaryVariableEntity)
+            textLiteral(packageEntity2.details.translationTarget.name),
+            textLiteral(localeToString(textTranslationLocale)),
+            variableGetAccess(dictionaryVariableEntity)
           ]
         );
         const translatorAddTranslationStatement = expressionStatement(translatorAddTranslationCall);
         statements.push(translatorAddTranslationStatement);
-        const packageConstructorDeclaration = packageFunctionDeclaration(
-          packageConstructorEntity,
-          [],
-          blockStatement(statements),
-          false
-        );
+        const packageConstructorDeclaration = this.ctx.findOrCreatePackageConstructor(pkg2.ir);
+        packageConstructorDeclaration.body.statements = statements.concat(packageConstructorDeclaration.body.statements);
         pkg2.ir.declarations = pkg2.ir.declarations.concat(packageConstructorDeclaration);
       }
     }
   }
-  createTranslationFunctionLiteral(block, sourceTextTemplate, packageEntity) {
-    const valuesParameterEntity = new IntrinsicVariableEntity(
-      EmitPhaseName.ofTranslationFunctionValuesParameter(packageEntity.locale),
+  createTranslationFunctionLiteral(block, sourceTextTemplate, packageEntity2) {
+    const valuesParameterEntity = parameterEntity(
+      EmitPhaseName.ofTranslationFunctionValuesParameter(packageEntity2.locale),
       this.ctx.ectx.standardTypes.array,
-      packageEntity
+      packageEntity2,
+      false
     );
     const localVariableDeclarationStatements = sourceTextTemplate?.parameters.map((p, i) => localVariableDeclarationStatement(
       p,
@@ -64425,7 +64454,7 @@ var TextTranslationsLowering = class {
         p.type
       )
     )) ?? [];
-    const valuesParameterDeclaration = new ParameterDeclaration2(valuesParameterEntity, void 0, false, void 0);
+    const valuesParameterDeclaration = parameterDeclaration(valuesParameterEntity, void 0, false);
     block.statements = localVariableDeclarationStatements.concat(block.statements);
     return functionLiteral([valuesParameterDeclaration], block, false, this.ctx.ectx.standardTypes.text);
   }
@@ -64483,10 +64512,10 @@ var IrBuilder = class {
       const sourceFileTranslations = this.buildTextTranslationDeclarationList(sourceFileNode.declarationList);
       translations.push(...sourceFileTranslations);
     }
-    const packageEntity = this.entityMap.getPackageEntity(this.analyzer.entity.ofPackage(pkg2));
+    const packageEntity2 = this.entityMap.getPackageEntity(this.analyzer.entity.ofPackage(pkg2));
     const entities = declarations.map((d) => d.entity);
-    packageEntity.members = Array.from(new Set(Array.from(packageEntity.members).concat(entities)));
-    return pkg(packageEntity, [], declarations, translations, [], void 0);
+    packageEntity2.members = Array.from(new Set(Array.from(packageEntity2.members).concat(entities)));
+    return pkg(packageEntity2, [], declarations, translations, [], void 0);
   }
   buildPackageMemberDeclarationList(declarationList, sourceFileMembers) {
     const result = [];
@@ -64584,16 +64613,15 @@ var IrBuilder = class {
   buildPackageConstructorDeclaration(declaration) {
     const originalContainingPackage = TreeQuery.getPackageEntity(declaration, this.analyzer);
     const containingPackage = this.entityMap.getPackageEntity(originalContainingPackage);
-    const entity = new IntrinsicFunctionEntity(
-      0 /* RegularFunction */,
+    const entity = packageFunctionEntity(
       EmitPhaseName.ofPackageConstructor(containingPackage.locale),
       [],
       this.entityMap.getType(this.analyzer.originalStandardTypes.nullType),
-      containingPackage
+      containingPackage,
+      this.analyzer.checkBlockCallsAsyncMethods(declaration.block),
+      true,
+      false
     );
-    entity.details.isAsync = this.analyzer.checkBlockCallsAsyncMethods(declaration.block);
-    entity.details.isPackageConstructor = true;
-    entity.isPackageMember = true;
     const body = this.buildFunctionBlockOfFunctionWithoutResult(declaration.block);
     return packageFunctionDeclaration(entity, [], body, false, this.getSourceLocation(declaration));
   }
@@ -64622,7 +64650,7 @@ var IrBuilder = class {
             mappedResultLocalVariable,
             void 0
           );
-          const returnStatement3 = returnStatement(VariableAccessExpression.get(mappedResultLocalVariable));
+          const returnStatement3 = returnStatement(variableGetAccess(mappedResultLocalVariable));
           statements = [
             resultVariableDeclarationStatement,
             ...node.expressionOrStatementList.statements.map((s) => this.buildStatement(s)),
@@ -64755,16 +64783,15 @@ var IrBuilder = class {
   buildPackageEntryPointDeclaration(declaration) {
     const originalContainingPackage = TreeQuery.getPackageEntity(declaration, this.analyzer);
     const containingPackage = this.entityMap.getPackageEntity(originalContainingPackage);
-    const entity = new IntrinsicFunctionEntity(
-      0 /* RegularFunction */,
+    const entity = packageFunctionEntity(
       EmitPhaseName.ofPackageRunFunction(containingPackage.locale),
       [],
       this.entityMap.getType(this.analyzer.originalStandardTypes.nullType),
-      containingPackage
+      containingPackage,
+      this.analyzer.checkBlockCallsAsyncMethods(declaration.block),
+      false,
+      true
     );
-    entity.details.isAsync = this.analyzer.checkBlockCallsAsyncMethods(declaration.block);
-    entity.details.isPackageEntryPoint = true;
-    entity.isPackageMember = true;
     const body = this.buildFunctionBlockOfFunctionWithoutResult(declaration.block);
     return packageFunctionDeclaration(entity, [], body, false, this.getSourceLocation(declaration));
   }
@@ -65022,23 +65049,18 @@ var IrBuilder = class {
         }
       }
     }
-    return new ConstructorDeclaration2(
-      decorators,
-      parameters,
-      body,
-      entity,
-      this.getSourceLocation(declaration)
-    );
+    return constructorDeclaration(entity, parameters, body, this.getSourceLocation(declaration)).withDecorators(decorators);
   }
   createDefaultStructuredTypeConstructor(entity, info) {
+    const mappedEntity = this.entityMap.getConstructorEntity(entity);
     const parameters = entity.getParameters().map((p) => {
       const entity2 = this.entityMap.getVariableEntity(p);
       const defaultValue = p.subkind === "parameter" && p.isOptional() ? nullLiteral() : void 0;
-      return new ParameterDeclaration2(entity2, defaultValue, false, void 0);
+      return parameterDeclaration(entity2, defaultValue, false);
     });
     const statements = [];
     if (info.baseConstructor !== void 0) {
-      const args = info.orderedParametersForBaseConstructor.map((v) => VariableAccessExpression.get(this.entityMap.getVariableEntity(v.parameter)));
+      const args = info.orderedParametersForBaseConstructor.map((v) => variableGetAccess(this.entityMap.getVariableEntity(v.parameter)));
       const baseConstructorEntity = info.baseConstructor.getEntity();
       const containingEntity = baseConstructorEntity.getContainingEntity();
       if (containingEntity.kind === 2 /* Type */) {
@@ -65055,14 +65077,8 @@ var IrBuilder = class {
         const field = fieldToInitializeByOwnParameter.get(parameter);
         if (field !== void 0) {
           const receiver = this.createExplicitReceiver(field);
-          const memberAccess = FieldAccessExpression.set(
-            receiver,
-            false,
-            AccessedVariable.fromEntity(this.entityMap.getVariableEntity(field))
-          );
-          const parameterAccess = VariableAccessExpression.get(
-            this.entityMap.getVariableEntity(parameter)
-          );
+          const memberAccess = instanceFieldSetAccess(receiver, this.entityMap.getVariableEntity(field), false);
+          const parameterAccess = variableGetAccess(this.entityMap.getVariableEntity(parameter));
           const assignmentStatement2 = assignmentStatement(memberAccess, parameterAccess);
           if (parameter.subkind === "parameter" && parameter.isOptional()) {
             const notEmptyCheck = binaryExpression(
@@ -65080,8 +65096,7 @@ var IrBuilder = class {
       }
     }
     const body = blockStatement(statements);
-    const mappedEntity = this.entityMap.getConstructorEntity(entity);
-    return new ConstructorDeclaration2([], parameters, body, mappedEntity, void 0);
+    return constructorDeclaration(mappedEntity, parameters, body, void 0);
   }
   buildDestructorDeclaration(declaration) {
     if (declaration.block === void 0) {
@@ -65092,60 +65107,41 @@ var IrBuilder = class {
     const decorators = this.buildDecorators(declaration.tagList);
     const parameters = this.buildParameterList(declaration.parameterClause.parameterList);
     const body = this.buildFunctionBlockOfFunctionWithoutResult(declaration.block);
-    return new DestructorDeclaration2(
-      decorators,
-      parameters,
-      body,
-      entity,
-      this.getSourceLocation(declaration)
-    );
+    return destructorDeclaration(entity, parameters, body, this.getSourceLocation(declaration)).withDecorators(decorators);
   }
   buildIndexedElementGetterDeclaration(declaration) {
     if (declaration.block === void 0) {
       return void 0;
     }
-    const indexerEntity = this.analyzer.entity.ofIndexerDeclaration(declaration);
     const originalEntity = this.analyzer.entity.ofIndexedElementGetterDeclaration(declaration);
     const entity = this.entityMap.getGetterEntity(originalEntity);
     const decorators = this.buildDecorators(declaration.tagList);
-    const modifiers = new Modifiers().setStatic(indexerEntity.isStatic());
     const body = this.buildFunctionBlockOfFunction(
       declaration.block,
       this.analyzer.resultLocalVariableEntity.ofIndexedElementGetterDeclaration(declaration)
     );
     const parameters = this.buildParameterList(declaration.parameterClause.parameterList);
     this.buildAndSaveTypeIfIsAnonymousTypeSpecifier(declaration.typeAnnotation.typeSpecifier);
-    return new IndexedElementGetterDeclaration2(
-      entity,
-      decorators,
-      modifiers,
-      parameters,
-      body,
-      this.getSourceLocation(declaration)
-    );
+    return indexedElementGetterDeclaration(entity, parameters, body, this.getSourceLocation(declaration)).withDecorators(decorators);
   }
   buildIndexedElementSetterDeclaration(declaration) {
     if (declaration.block === void 0) {
       return void 0;
     }
-    const indexerEntity = this.analyzer.entity.ofIndexerDeclaration(declaration);
     const originalEntity = this.analyzer.entity.ofIndexedElementSetterDeclaration(declaration);
     const entity = this.entityMap.getSetterEntity(originalEntity);
     const decorators = this.buildDecorators(declaration.tagList);
-    const modifiers = new Modifiers().setStatic(indexerEntity.isStatic());
     const body = this.buildFunctionBlockOfFunctionWithoutResult(declaration.block);
     const originalValueLocalVariable = this.analyzer.valueLocalVariableEntity.ofIndexedElementSetterDeclaration(declaration);
     const valueLocalVariable = this.entityMap.getVariableEntity(originalValueLocalVariable);
     const parameters = this.buildParameterList(declaration.parameterClause.parameterList);
-    return new IndexedElementSetterDeclaration2(
+    return indexedElementSetterDeclaration(
       entity,
-      decorators,
-      modifiers,
       parameters,
       body,
       valueLocalVariable,
       this.getSourceLocation(declaration)
-    );
+    ).withDecorators(decorators);
   }
   buildDereferencedVariableGetterDeclaration(declaration) {
     if (declaration.block === void 0) {
@@ -65155,41 +65151,30 @@ var IrBuilder = class {
     const originalEntity = this.analyzer.entity.ofDereferencedVariableGetterDeclaration(declaration);
     const entity = this.entityMap.getGetterEntity(originalEntity);
     const decorators = this.buildDecorators(declaration.tagList);
-    const modifiers = new Modifiers().setStatic(operatorEntity.isStatic());
     const body = this.buildFunctionBlockOfFunction(
       declaration.block,
       this.analyzer.resultLocalVariableEntity.ofDereferencedVariableGetterDeclaration(declaration)
     );
     this.buildAndSaveTypeIfIsAnonymousTypeSpecifier(declaration.typeAnnotation.typeSpecifier);
-    return new DereferencedVariableGetterDeclaration2(
-      entity,
-      decorators,
-      modifiers,
-      body,
-      this.getSourceLocation(declaration)
-    );
+    return dereferencedVariableGetterDeclaration(entity, body, this.getSourceLocation(declaration)).withDecorators(decorators);
   }
   buildDereferencedVariableSetterDeclaration(declaration) {
     if (declaration.block === void 0) {
       return void 0;
     }
-    const operatorEntity = this.analyzer.entity.ofDereferenceOperatorDeclaration(declaration);
     const originalEntity = this.analyzer.entity.ofDereferencedVariableSetterDeclaration(declaration);
     const entity = this.entityMap.getSetterEntity(originalEntity);
     const decorators = this.buildDecorators(declaration.tagList);
-    const modifiers = new Modifiers().setStatic(operatorEntity.isStatic());
     const body = this.buildFunctionBlockOfFunctionWithoutResult(declaration.block);
     const originalValueLocalVariable = this.analyzer.valueLocalVariableEntity.ofDereferencedVariableSetterDeclaration(declaration);
     Debug.assertNotNull(originalValueLocalVariable, "\u041F\u0430\u0440\u0430\u043C\u0435\u0442\u0440 \u043E\u043F\u0435\u0440\u0430\u0446\u0438\u0438 \u0437\u0430\u043F\u0438\u0441\u0438 \u0434\u043E\u043B\u0436\u0435\u043D \u0441\u0443\u0449\u0435\u0441\u0442\u0432\u043E\u0432\u0430\u0442\u044C.");
     const valueLocalVariable = this.entityMap.getVariableEntity(originalValueLocalVariable);
-    return new DereferencedVariableSetterDeclaration2(
+    return dereferencedVariableSetterDeclaration(
       entity,
-      decorators,
-      modifiers,
       body,
       valueLocalVariable,
       this.getSourceLocation(declaration)
-    );
+    ).withDecorators(decorators);
   }
   buildMethodDeclaration(declaration) {
     if (declaration.block === void 0) {
@@ -65198,23 +65183,19 @@ var IrBuilder = class {
     const originalEntity = this.analyzer.entity.ofMethodDeclaration(declaration);
     const entity = this.entityMap.getFunctionEntity(originalEntity);
     const decorators = this.buildDecorators(declaration.tagList);
-    const modifiers = new Modifiers().setStatic(originalEntity.isStatic()).setAsync(originalEntity.isAsync());
     const parameters = this.buildParameterList(declaration.parameterClause.parameterList);
     const body = this.buildFunctionBlockOfFunction(
       declaration.block,
       this.analyzer.resultLocalVariableEntity.ofMethodDeclaration(declaration)
     );
     this.buildAndSaveTypeIfIsAnonymousTypeSpecifier(declaration.returnTypeAnnotation?.typeSpecifier);
-    return new MethodDeclaration2(
-      decorators,
-      modifiers,
+    return methodDeclaration(
+      entity,
       parameters,
       body,
-      entity,
       this.analyzer.isFunctionGenerator(declaration),
-      void 0,
       this.getSourceLocation(declaration)
-    );
+    ).withDecorators(decorators);
   }
   buildOperatorDeclaration(declaration) {
     if (declaration.block === void 0) {
@@ -65223,23 +65204,13 @@ var IrBuilder = class {
     const originalEntity = this.analyzer.entity.ofOperatorDeclaration(declaration);
     const entity = this.entityMap.getOperatorEntity(originalEntity);
     const decorators = this.buildDecorators(declaration.tagList);
-    const modifiers = new Modifiers().setStatic(originalEntity.isStatic());
     const parameters = this.buildParameterList(declaration.parameterClause.parameterList);
     const body = this.buildFunctionBlockOfFunction(
       declaration.block,
       this.analyzer.resultLocalVariableEntity.ofOperatorDeclaration(declaration)
     );
     this.buildAndSaveTypeIfIsAnonymousTypeSpecifier(declaration.returnTypeAnnotation?.typeSpecifier);
-    return new MethodDeclaration2(
-      decorators,
-      modifiers,
-      parameters,
-      body,
-      entity,
-      false,
-      void 0,
-      this.getSourceLocation(declaration)
-    );
+    return methodDeclaration(entity, parameters, body, false, this.getSourceLocation(declaration)).withDecorators(decorators);
   }
   buildFieldDeclaration(declaration) {
     const originalEntity = this.analyzer.entity.ofFieldDeclaration(declaration);
@@ -65248,17 +65219,9 @@ var IrBuilder = class {
     }
     const entity = this.entityMap.getVariableEntity(originalEntity);
     const decorators = this.buildDecorators(declaration.tagList);
-    const modifiers = new Modifiers().setStatic(originalEntity.isStatic());
     const initializer = declaration.initializer !== void 0 ? this.buildExpression(declaration.initializer) : void 0;
     this.buildAndSaveTypeIfIsAnonymousTypeSpecifier(declaration.typeAnnotation?.typeSpecifier);
-    return new FieldDeclaration2(
-      decorators,
-      modifiers,
-      initializer,
-      entity,
-      void 0,
-      this.getSourceLocation(declaration)
-    );
+    return fieldDeclaration(entity, initializer, this.getSourceLocation(declaration)).withDecorators(decorators);
   }
   buildComputedFieldDeclaration(getterDeclaration, setterDeclaration) {
     if (getterDeclaration.block === void 0 || setterDeclaration !== void 0 && setterDeclaration.block === void 0) {
@@ -65266,10 +65229,9 @@ var IrBuilder = class {
     }
     const originalEntity = this.analyzer.entity.ofComputedFieldDeclaration(getterDeclaration);
     const entity = this.entityMap.getVariableEntity(originalEntity);
-    const modifiers = new Modifiers().setStatic(originalEntity.isStatic());
     const getter = this.buildFieldGetterDeclarationRequired(getterDeclaration);
     const setter = setterDeclaration !== void 0 ? this.buildFieldSetterDeclaration(setterDeclaration) : void 0;
-    return new ComputedFieldDeclaration(entity, modifiers, getter, setter, void 0, void 0);
+    return computedFieldDeclaration(entity, getter, setter);
   }
   buildFieldGetterDeclarationRequired(declaration) {
     Debug.assertNotNull(declaration.block);
@@ -65281,7 +65243,7 @@ var IrBuilder = class {
       this.analyzer.resultLocalVariableEntity.ofFieldGetterDeclaration(declaration)
     );
     this.buildAndSaveTypeIfIsAnonymousTypeSpecifier(declaration.typeAnnotation.typeSpecifier);
-    return new FieldGetterDeclaration2(entity, decorators, body, this.getSourceLocation(declaration));
+    return fieldGetterDeclaration(entity, body, this.getSourceLocation(declaration)).withDecorators(decorators);
   }
   buildFieldSetterDeclaration(declaration) {
     if (declaration.block === void 0) {
@@ -65294,13 +65256,7 @@ var IrBuilder = class {
     const originalValueLocalVariable = this.analyzer.valueLocalVariableEntity.ofFieldSetterDeclaration(declaration);
     Debug.assertNotNull(originalValueLocalVariable, "\u041F\u0430\u0440\u0430\u043C\u0435\u0442\u0440 \u043E\u043F\u0435\u0440\u0430\u0446\u0438\u0438 \u0437\u0430\u043F\u0438\u0441\u0438 \u0434\u043E\u043B\u0436\u0435\u043D \u0441\u0443\u0449\u0435\u0441\u0442\u0432\u043E\u0432\u0430\u0442\u044C.");
     const valueLocalVariable = this.entityMap.getVariableEntity(originalValueLocalVariable);
-    return new FieldSetterDeclaration2(
-      entity,
-      decorators,
-      body,
-      valueLocalVariable,
-      this.getSourceLocation(declaration)
-    );
+    return fieldSetterDeclaration(entity, body, valueLocalVariable, this.getSourceLocation(declaration)).withDecorators(decorators);
   }
   buildBackingField(entity) {
     Debug.assertNotNull(this.declarationsUsageInfoOfPackageSourceFiles);
@@ -65308,8 +65264,7 @@ var IrBuilder = class {
       return void 0;
     }
     const mappedEntity = this.entityMap.getVariableEntity(entity);
-    const modifiers = new Modifiers().setStatic(entity.isStatic());
-    return new FieldDeclaration2([], modifiers, void 0, mappedEntity, void 0, void 0);
+    return fieldDeclaration(mappedEntity, void 0);
   }
   buildDisposeStatement(statement) {
     Logger.errorAtNode("Dispose statement is not supported by code generator.", statement);
@@ -65376,7 +65331,7 @@ var IrBuilder = class {
     let ifExpressionIsNotEnumerableThenEnumeratorMethod;
     if (checkResult.kind === "ok" && checkResult.value.ifTypeDoesNotImplementEnumerableThenEnumeratorMethod !== void 0) {
       const method = checkResult.value.ifTypeDoesNotImplementEnumerableThenEnumeratorMethod;
-      ifExpressionIsNotEnumerableThenEnumeratorMethod = new AccessedFunction5(
+      ifExpressionIsNotEnumerableThenEnumeratorMethod = accessedFunction(
         this.entityMap.getFunctionEntity(method.getEntity()),
         this.entityMap.getType(method.getReturnType())
       );
@@ -65447,7 +65402,7 @@ var IrBuilder = class {
       const entity = this.entityMap.getVariableEntity(this.analyzer.entity.ofParameterDeclaration(p));
       const defaultValue = p.defaultValue !== void 0 ? this.buildExpression(p.defaultValue) : void 0;
       this.buildAndSaveTypeIfIsAnonymousTypeSpecifier(p.typeAnnotation?.typeSpecifier);
-      return new ParameterDeclaration2(entity, defaultValue, false, this.getSourceLocation(p));
+      return parameterDeclaration(entity, defaultValue, false, this.getSourceLocation(p));
     }).toArray();
   }
   buildLocalVariableDeclarationStatement(statement) {
@@ -65499,10 +65454,10 @@ var IrBuilder = class {
     const condition = this.buildExpression(statement.condition);
     const body = this.buildStatementBlock(statement.block);
     this.currentLoopLabel = saveLoopLabel;
-    return new WhileStatement2(loopLabel, condition, body, this.getSourceLocation(statement));
+    return whileStatement(loopLabel, condition, body, this.getSourceLocation(statement));
   }
   buildYieldStatement(statement) {
-    return new YieldStatement2(this.buildExpression(statement.expression), this.getSourceLocation(statement));
+    return yieldStatement(this.buildExpression(statement.expression), this.getSourceLocation(statement));
   }
   buildExpression(expression) {
     let result;
@@ -65533,7 +65488,7 @@ var IrBuilder = class {
         break;
       case 71 /* MissingExpression */:
         Logger.errorAtNode("Unexpected invalid expression.", expression);
-        result = new TextLiteral2("Unexpected invalid expression.", void 0);
+        result = textLiteral("Unexpected invalid expression.");
         break;
       case 72 /* IsExpression */:
         result = this.buildIsExpression(expression);
@@ -65777,11 +65732,11 @@ var IrBuilder = class {
     switch (meaning.kind) {
       case "unresolved":
         Logger.errorAtNode("Unexpected unresolved call expression.", expression);
-        return new TextLiteral2("Unexpected unresolved call expression.", void 0);
+        return textLiteral("Unexpected unresolved call expression.");
       case "function-call": {
         if (meaning.suitableFunctions.length === 0) {
           Logger.errorAtNode("Zero suitable functions.", expression);
-          return new TextLiteral2("Zero suitable functions.", void 0);
+          return textLiteral("Zero suitable functions.");
         } else if (meaning.suitableFunctions.length > 1) {
           Logger.errorAtNode("Ambiguous function call.", expression);
         }
@@ -65792,12 +65747,11 @@ var IrBuilder = class {
           if (meaning2.kind === "overridden-method-access") {
             const entity = this.entityMap.getFunctionEntity(meaning2.method.getEntity());
             const returnType2 = this.entityMap.getType(meaning2.method.getReturnType());
-            receiver = new MethodAccessExpression(
+            receiver = methodAccessExpression(
               baseExpression(),
               false,
-              new AccessedFunction5(entity, returnType2),
+              accessedFunction(entity, returnType2),
               true,
-              void 0,
               this.getSourceLocation(expression.expression)
             );
           }
@@ -65821,7 +65775,7 @@ var IrBuilder = class {
       case "operator-call": {
         if (meaning.suitableOperators.length === 0) {
           Logger.errorAtNode("Zero suitable operators.", expression);
-          return new TextLiteral2("Zero suitable operators.", void 0);
+          return textLiteral("Zero suitable operators.");
         } else if (meaning.suitableOperators.length > 1) {
           Logger.errorAtNode("Ambiguous operator call.", expression);
         }
@@ -65832,12 +65786,11 @@ var IrBuilder = class {
           if (meaning2.kind === "overridden-operator-access") {
             const entity = this.entityMap.getOperatorEntity(meaning2.operator.getEntity());
             const returnType2 = this.entityMap.getType(meaning2.operator.getReturnType());
-            receiver = new MethodAccessExpression(
+            receiver = methodAccessExpression(
               baseExpression(),
               false,
-              new AccessedFunction5(entity, returnType2),
+              accessedFunction(entity, returnType2),
               true,
-              void 0,
               this.getSourceLocation(expression.expression)
             );
           }
@@ -65877,12 +65830,11 @@ var IrBuilder = class {
       case "constructor-call": {
         if (meaning.suitableConstructors.length === 0) {
           Logger.errorAtNode("Zero suitable constructors.", expression);
-          return new TextLiteral2("Zero suitable constructors.", void 0);
+          return textLiteral("Zero suitable constructors.");
         } else if (meaning.suitableConstructors.length > 1) {
           Logger.errorAtNode("Ambiguous constructor call.", expression);
         }
         const originalEntity = meaning.suitableConstructors[0].getEntity();
-        const originalContainingEntity = originalEntity.getContainingEntity();
         const entity = this.entityMap.getConstructorEntity(originalEntity);
         const args = this.buildArgumentList(
           expression.argumentList,
@@ -65893,13 +65845,9 @@ var IrBuilder = class {
         } else if (expression.expression.kind === 88 /* BaseExpression */) {
           return baseConstructorCallExpression(entity, args, this.getSourceLocation(expression));
         } else {
-          const containingEntity = this.entityMap.getTypeOrExtensionEntity(originalContainingEntity);
-          const typeAccess = new TypeAccessExpression(containingEntity, void 0);
           const returnType = this.entityMap.getType(this.analyzer.type.ofExpression(expression));
-          return new ConstructorCallExpression(
+          return constructorCallExpressionWithResultType(
             entity,
-            containingEntity,
-            typeAccess,
             args,
             returnType,
             this.getSourceLocation(expression)
@@ -65916,32 +65864,22 @@ var IrBuilder = class {
       case "constructor-call": {
         if (meaning.suitableConstructors.length === 0) {
           Logger.errorAtNode("Zero suitable constructors.", expression);
-          return new TextLiteral2("Zero suitable constructors.", void 0);
+          return textLiteral("Zero suitable constructors.");
         } else if (meaning.suitableConstructors.length > 1) {
           Logger.errorAtNode("Ambiguous constructor call.", expression);
         }
         const originalEntity = meaning.suitableConstructors[0].getEntity();
-        const originalContainingEntity = originalEntity.getContainingEntity();
         const entity = this.entityMap.getConstructorEntity(originalEntity);
-        const containingEntity = this.entityMap.getTypeOrExtensionEntity(originalContainingEntity);
-        const typeAccess = new TypeAccessExpression(containingEntity, void 0);
         const args = this.buildArgumentList(
           expression.argumentList,
           originalEntity.getParameters()
         );
         const returnType = this.entityMap.getType(this.analyzer.type.ofExpression(expression));
-        return new ConstructorCallExpression(
-          entity,
-          containingEntity,
-          typeAccess,
-          args,
-          returnType,
-          this.getSourceLocation(expression)
-        );
+        return constructorCallExpressionWithResultType(entity, args, returnType, this.getSourceLocation(expression));
       }
       case "unresolved":
         Logger.errorAtNode("Unexpected unresolved implicit constructor call expression.", expression);
-        return new TextLiteral2("Unexpected unresolved implicit constructor call expression.", void 0);
+        return textLiteral("Unexpected unresolved implicit constructor call expression.");
       default:
         Debug.never(meaning);
     }
@@ -65952,7 +65890,7 @@ var IrBuilder = class {
       case "resolved": {
         if (meaning.singleSuitableIndexer === void 0) {
           Logger.errorAtNode("\u041D\u0435\u043E\u0434\u043D\u043E\u0437\u043D\u0430\u0447\u043D\u044B\u0439 \u0434\u043E\u0441\u0442\u0443\u043F \u043A \u043E\u043F\u0435\u0440\u0430\u0446\u0438\u0438 \u0434\u043E\u0441\u0442\u0443\u043F\u0430 \u043F\u043E \u0438\u043D\u0434\u0435\u043A\u0441\u0443.", expression);
-          return new TextLiteral2("\u041D\u0435\u043E\u0434\u043D\u043E\u0437\u043D\u0430\u0447\u043D\u044B\u0439 \u0434\u043E\u0441\u0442\u0443\u043F \u043A \u043E\u043F\u0435\u0440\u0430\u0446\u0438\u0438 \u0434\u043E\u0441\u0442\u0443\u043F\u0430 \u043F\u043E \u0438\u043D\u0434\u0435\u043A\u0441\u0443.", void 0);
+          return textLiteral("\u041D\u0435\u043E\u0434\u043D\u043E\u0437\u043D\u0430\u0447\u043D\u044B\u0439 \u0434\u043E\u0441\u0442\u0443\u043F \u043A \u043E\u043F\u0435\u0440\u0430\u0446\u0438\u0438 \u0434\u043E\u0441\u0442\u0443\u043F\u0430 \u043F\u043E \u0438\u043D\u0434\u0435\u043A\u0441\u0443.");
         }
         const irExpression = this.buildExpression(expression.expression);
         const isOptionalAccess = expression.expression.kind === 62 /* AssumptionExpression */;
@@ -65961,7 +65899,7 @@ var IrBuilder = class {
           meaning.singleSuitableIndexer.getEntity().getParameters()
         );
         const access = this.convertIndexedAccess(meaning.accessKind, meaning.singleSuitableIndexer);
-        return new IndexedAccessExpression2(
+        return indexedAccessExpression(
           irExpression,
           isOptionalAccess,
           args,
@@ -65971,7 +65909,7 @@ var IrBuilder = class {
       }
       case "unresolved":
         Logger.errorAtNode("Unexpected unresolved indexed access expression.", expression);
-        return new TextLiteral2("Unexpected unresolved indexed access expression.", void 0);
+        return textLiteral("Unexpected unresolved indexed access expression.");
       default:
         Debug.never(meaning);
     }
@@ -65995,12 +65933,7 @@ var IrBuilder = class {
     return functionLiteral(parameters, body, isAsync, returnType, this.getSourceLocation(expression));
   }
   buildFunctionBlockLiteral(expression) {
-    const parameters = this.analyzer.getFunctionBlockLiteralParameters(expression).map((p) => new ParameterDeclaration2(
-      this.entityMap.getVariableEntity(p),
-      void 0,
-      false,
-      void 0
-    ));
+    const parameters = this.analyzer.getFunctionBlockLiteralParameters(expression).map((p) => parameterDeclaration(this.entityMap.getVariableEntity(p), void 0, false));
     const body = this.buildFunctionBlockOfFunction(
       expression.block,
       this.analyzer.resultLocalVariableEntity.ofFunctionBlockLiteral(expression)
@@ -66052,29 +65985,25 @@ var IrBuilder = class {
       case "mixed-ambiguous-access":
       case "constructor-access":
         Logger.errorAtNode("Unresolved property access expression meaning.", expression);
-        return new TextLiteral2("Unresolved property access expression meaning.", void 0);
+        return textLiteral("Unresolved property access expression meaning.");
       case "package-name-segment-access":
         Logger.errorAtNode("Unexpected property access expression meaning.", expression);
-        return new TextLiteral2("Unexpected property access expression meaning.", void 0);
+        return textLiteral("Unexpected property access expression meaning.");
       case "package-variable-access": {
         const entity = this.entityMap.getVariableEntity(meaning.variable);
-        return new VariableAccessExpression(
-          AccessedVariable.fromEntity(entity),
-          meaning.accessKind,
-          this.getSourceLocation(expression)
-        );
+        return variableAccessExpressions(entity, meaning.accessKind, this.getSourceLocation(expression));
       }
       case "package-function-access": {
         const func = meaning.singleSuitableFunction;
         if (func === void 0) {
           Logger.errorAtNode("Ambiguous method access.", expression);
-          return new TextLiteral2("Ambiguous method access.", void 0);
+          return textLiteral("Ambiguous method access.");
         }
         const entity = this.entityMap.getFunctionEntity(func.getEntity());
         const returnType = this.entityMap.getType(func.getReturnType());
         const isCallee = this.expressionIsCallee(expression);
         return functionAccessExpression(
-          new AccessedFunction5(entity, returnType),
+          accessedFunction(entity, returnType),
           isCallee,
           this.getSourceLocation(expression)
         );
@@ -66083,21 +66012,20 @@ var IrBuilder = class {
         const type = meaning.singleSuitableType;
         if (type === void 0) {
           Logger.errorAtNode("Ambiguous type access.", expression);
-          return new TextLiteral2("Ambiguous type access.", void 0);
+          return textLiteral("Ambiguous type access.");
         }
-        return new TypeAccessExpression(this.getEntityFromType(type), this.getSourceLocation(expression));
+        return typeAccessExpression(this.getEntityFromType(type), this.getSourceLocation(expression));
       }
       case "static-field-access": {
         const typeEntity = this.getEntityFromType(meaning.type);
-        const typeAccess = new TypeAccessExpression(typeEntity, void 0);
+        const typeAccess = typeAccessExpression(typeEntity);
         const entity = this.entityMap.getVariableEntity(meaning.field.getEntity());
         const type = this.entityMap.getType(meaning.field.getType());
-        return new FieldAccessExpression(
+        return fieldAccessExpression(
           typeAccess,
           false,
-          new AccessedVariable(entity, type),
+          accessedVariable(entity, type),
           meaning.accessKind,
-          void 0,
           this.getSourceLocation(expression)
         );
       }
@@ -66105,19 +66033,18 @@ var IrBuilder = class {
         const method = meaning.singleSuitableFunction;
         if (method === void 0) {
           Logger.errorAtNode("Ambiguous method access.", expression);
-          return new TextLiteral2("Ambiguous method access.", void 0);
+          return textLiteral("Ambiguous method access.");
         }
         const typeEntity = this.getEntityFromType(meaning.type);
-        const typeAccess = new TypeAccessExpression(typeEntity, void 0);
+        const typeAccess = typeAccessExpression(typeEntity);
         const isCallee = this.expressionIsCallee(expression);
         const entity = this.entityMap.getFunctionEntity(method.getEntity());
         const returnType = this.entityMap.getType(method.getReturnType());
-        return new MethodAccessExpression(
+        return methodAccessExpression(
           typeAccess,
           false,
-          new AccessedFunction5(entity, returnType),
+          accessedFunction(entity, returnType),
           isCallee,
-          void 0,
           this.getSourceLocation(expression)
         );
       }
@@ -66127,12 +66054,11 @@ var IrBuilder = class {
         const isOptionalAccess = expression.expression.kind === 62 /* AssumptionExpression */;
         const entity = this.entityMap.getVariableEntity(originalEntity);
         const type = this.entityMap.getType(meaning.field.getType());
-        return new FieldAccessExpression(
+        return fieldAccessExpression(
           expressionIr,
           isOptionalAccess,
-          new AccessedVariable(entity, type),
+          accessedVariable(entity, type),
           meaning.accessKind,
-          void 0,
           this.getSourceLocation(expression)
         );
       }
@@ -66140,7 +66066,7 @@ var IrBuilder = class {
         const method = meaning.singleSuitableFunction;
         if (method === void 0) {
           Logger.errorAtNode("Ambiguous method access.", expression);
-          return new TextLiteral2("Ambiguous method access.", void 0);
+          return textLiteral("Ambiguous method access.");
         }
         const originalFunctionEntity = method.getEntity();
         if (originalFunctionEntity.subkind === "method" && originalFunctionEntity.isFunctionTypeInvokeMethod()) {
@@ -66157,12 +66083,11 @@ var IrBuilder = class {
           const isCallee = this.expressionIsCallee(expression);
           const entity = this.entityMap.getFunctionEntity(originalFunctionEntity);
           const returnType = this.entityMap.getType(method.getReturnType());
-          return new MethodAccessExpression(
+          return methodAccessExpression(
             expressionIr,
             isOptionalAccess,
-            new AccessedFunction5(entity, returnType),
+            accessedFunction(entity, returnType),
             isCallee,
-            void 0,
             this.getSourceLocation(expression)
           );
         }
@@ -66171,19 +66096,18 @@ var IrBuilder = class {
         const operator = meaning.singleSuitableOperator;
         if (operator === void 0) {
           Logger.errorAtNode("Ambiguous operator access.", expression);
-          return new TextLiteral2("Ambiguous operator access.", void 0);
+          return textLiteral("Ambiguous operator access.");
         }
         const expressionIr = this.buildExpression(expression.expression);
         const isOptionalAccess = expression.expression.kind === 62 /* AssumptionExpression */;
         const isCallee = this.expressionIsCallee(expression);
         const entity = this.entityMap.getOperatorEntity(operator.getEntity());
         const returnType = this.entityMap.getType(operator.getReturnType());
-        return new MethodAccessExpression(
+        return methodAccessExpression(
           expressionIr,
           isOptionalAccess,
-          new AccessedFunction5(entity, returnType),
+          accessedFunction(entity, returnType),
           isCallee,
-          void 0,
           this.getSourceLocation(expression)
         );
       }
@@ -66196,7 +66120,7 @@ var IrBuilder = class {
       case 0 /* Get */: {
         const originalGetter = indexer.getEntity().getGetter();
         Debug.assertNotNull(originalGetter);
-        const getAccessor = new AccessedFunction5(
+        const getAccessor = accessedFunction(
           this.entityMap.getGetterEntity(originalGetter),
           this.entityMap.getType(indexer.getType())
         );
@@ -66205,7 +66129,7 @@ var IrBuilder = class {
       case 1 /* Set */: {
         const originalSetter = indexer.getEntity().getSetter();
         Debug.assertNotNull(originalSetter);
-        const setAccessor = new AccessedFunction5(
+        const setAccessor = accessedFunction(
           this.entityMap.getSetterEntity(originalSetter),
           this.entityMap.getType(this.analyzer.originalStandardTypes.nullType)
         );
@@ -66216,11 +66140,11 @@ var IrBuilder = class {
         Debug.assertNotNull(originalGetter);
         const originalSetter = indexer.getEntity().getSetter();
         Debug.assertNotNull(originalSetter);
-        const getAccessor = new AccessedFunction5(
+        const getAccessor = accessedFunction(
           this.entityMap.getGetterEntity(originalGetter),
           this.entityMap.getType(this.analyzer.originalStandardTypes.nullType)
         );
-        const setAccessor = new AccessedFunction5(
+        const setAccessor = accessedFunction(
           this.entityMap.getSetterEntity(originalSetter),
           this.entityMap.getType(indexer.getType())
         );
@@ -66235,7 +66159,7 @@ var IrBuilder = class {
       case 0 /* Get */: {
         const originalGetter = operator.getEntity().getGetter();
         Debug.assertNotNull(originalGetter);
-        const getAccessor = new AccessedFunction5(
+        const getAccessor = accessedFunction(
           this.entityMap.getGetterEntity(originalGetter),
           this.entityMap.getType(operator.getType())
         );
@@ -66244,7 +66168,7 @@ var IrBuilder = class {
       case 1 /* Set */: {
         const originalSetter = operator.getEntity().getSetter();
         Debug.assertNotNull(originalSetter);
-        const setAccessor = new AccessedFunction5(
+        const setAccessor = accessedFunction(
           this.entityMap.getSetterEntity(originalSetter),
           this.entityMap.getType(this.analyzer.originalStandardTypes.nullType)
         );
@@ -66255,11 +66179,11 @@ var IrBuilder = class {
         Debug.assertNotNull(originalGetter);
         const originalSetter = operator.getEntity().getSetter();
         Debug.assertNotNull(originalSetter);
-        const getAccessor = new AccessedFunction5(
+        const getAccessor = accessedFunction(
           this.entityMap.getGetterEntity(originalGetter),
           this.entityMap.getType(this.analyzer.originalStandardTypes.nullType)
         );
-        const setAccessor = new AccessedFunction5(
+        const setAccessor = accessedFunction(
           this.entityMap.getSetterEntity(originalSetter),
           this.entityMap.getType(operator.getType())
         );
@@ -66281,24 +66205,17 @@ var IrBuilder = class {
     } else {
       secondExpression = nullLiteral();
     }
-    const type = this.entityMap.getType(this.analyzer.type.ofExpression(expression));
-    return new TernaryExpression(
-      condition,
-      firstExpression,
-      secondExpression,
-      type,
-      this.getSourceLocation(expression)
-    );
+    return ternaryExpression(condition, firstExpression, secondExpression, this.getSourceLocation(expression));
   }
   buildTextLiteral(expression) {
-    return new TextLiteral2(
+    return textLiteral(
       unescapeText(withoutQuotes(expression.text.value)),
       this.getSourceLocation(expression)
     );
   }
   buildLocalizableTextLiteral(expression) {
     const code = expression.code !== void 0 ? parseIntegerLiteral(expression.code.value) : void 0;
-    return new LocalizableTextLiteral2(
+    return localizableTextLiteral(
       unescapeText(withoutQuotes(expression.text.value)),
       code,
       this.getSourceLocation(expression)
@@ -66311,7 +66228,7 @@ var IrBuilder = class {
       textFragments.push(unescapeText(withoutTemplateQuotes(span.text.value)));
       expressions.push(this.buildExpression(span.expression));
     }
-    return new TextTemplateLiteral2(textFragments, expressions, this.getSourceLocation(expression));
+    return textTemplateLiteral(textFragments, expressions, this.getSourceLocation(expression));
   }
   buildLocalizableTextTemplateLiteral(expression) {
     const textFragments = [unescapeText(withoutTemplateQuotes(expression.head.value))];
@@ -66321,7 +66238,7 @@ var IrBuilder = class {
       expressions.push(this.buildExpression(span.expression));
     }
     const code = expression.code !== void 0 ? parseIntegerLiteral(expression.code.value) : void 0;
-    return new LocalizableTextTemplateLiteral2(textFragments, expressions, code, this.getSourceLocation(expression));
+    return localizableTextTemplateLiteral(textFragments, expressions, code, this.getSourceLocation(expression));
   }
   buildTokenExpression(expression) {
     switch (expression.token.tokenKind) {
@@ -66354,7 +66271,7 @@ var IrBuilder = class {
   }
   buildObjectExpression(expression) {
     const type = this.entityMap.getType(this.analyzer.type.ofExpression(expression));
-    return new ThisExpression(type, this.getSourceLocation(expression));
+    return thisExpression(type, this.getSourceLocation(expression));
   }
   buildBaseExpression(expression) {
     return baseExpression(this.getSourceLocation(expression));
@@ -66368,7 +66285,7 @@ var IrBuilder = class {
         meaning.diagnostic?.data.message ?? "Unexpected unresolved dereference expression meaning.",
         expression
       );
-      return new TextLiteral2("Unexpected unresolved dereference expression meaning.", void 0);
+      return textLiteral("Unexpected unresolved dereference expression meaning.");
     }
     const access = this.convertDereferencedVariableAccess(meaning.accessKind, meaning.operator);
     return dereferenceExpression(irExpression, isOptionalAccess, access, this.getSourceLocation(expression));
@@ -66381,9 +66298,8 @@ var IrBuilder = class {
       "Default match expression must be handled as part of switch statement and must not be converted separately.",
       expression
     );
-    return new TextLiteral2(
-      "Default match expression must be handled as part of switch statement and must not be converted separately.",
-      void 0
+    return textLiteral(
+      "Default match expression must be handled as part of switch statement and must not be converted separately."
     );
   }
   buildIdentifierExpression(expression) {
@@ -66391,29 +66307,26 @@ var IrBuilder = class {
     switch (meaning.kind) {
       case "unresolved":
         Logger.errorAtNode("Unexpected identifier expression meaning.", expression);
-        return new TextLiteral2("Unexpected identifier expression meaning.", void 0);
+        return textLiteral("Unexpected identifier expression meaning.");
       case "mixed-ambiguous-access":
         Logger.errorAtNode("Unexpected identifier expression meaning.", expression);
-        return new TextLiteral2("Unexpected identifier expression meaning.", void 0);
+        return textLiteral("Unexpected identifier expression meaning.");
       case "package-alias-access":
         Logger.errorAtNode("Unexpected identifier expression meaning.", expression);
-        return new TextLiteral2("Unexpected identifier expression meaning.", void 0);
+        return textLiteral("Unexpected identifier expression meaning.");
       case "package-name-segment-access":
         Logger.errorAtNode("Unexpected identifier expression meaning.", expression);
-        return new TextLiteral2("Unexpected identifier expression meaning.", void 0);
+        return textLiteral("Unexpected identifier expression meaning.");
       case "constructor-access":
         Logger.errorAtNode("Unexpected identifier expression meaning.", expression);
-        return new TextLiteral2("Unexpected identifier expression meaning.", void 0);
+        return textLiteral("Unexpected identifier expression meaning.");
       case "type-access": {
         const suitableType = meaning.singleSuitableType;
         if (suitableType === void 0) {
           Logger.errorAtNode("Ambiguous type access.", expression);
-          return new TextLiteral2("Ambiguous type access.", void 0);
+          return textLiteral("Ambiguous type access.");
         }
-        return new TypeAccessExpression(
-          this.getEntityFromType(suitableType),
-          this.getSourceLocation(expression)
-        );
+        return typeAccessExpression(this.getEntityFromType(suitableType), this.getSourceLocation(expression));
       }
       case "variable-access": {
         const originalEntity = meaning.variable.getEntity();
@@ -66423,15 +66336,14 @@ var IrBuilder = class {
         }
         const entity = this.entityMap.getVariableEntity(originalEntity);
         const type = this.entityMap.getType(meaning.variable.value.getType());
-        return receiver !== void 0 ? new FieldAccessExpression(
+        return receiver !== void 0 ? fieldAccessExpression(
           receiver,
           false,
-          new AccessedVariable(entity, type),
+          accessedVariable(entity, type),
           meaning.accessKind,
-          void 0,
           this.getSourceLocation(expression)
-        ) : new VariableAccessExpression(
-          new AccessedVariable(entity, type),
+        ) : variableAccessExpressions(
+          accessedVariable(entity, type),
           meaning.accessKind,
           this.getSourceLocation(expression)
         );
@@ -66440,7 +66352,7 @@ var IrBuilder = class {
         const suitableFunction = meaning.singleSuitableFunction;
         if (suitableFunction === void 0) {
           Logger.errorAtNode("Ambiguous function access.", expression);
-          return new TextLiteral2("Ambiguous function access.", void 0);
+          return textLiteral("Ambiguous function access.");
         }
         const originalEntity = suitableFunction.getEntity();
         let receiver;
@@ -66450,15 +66362,14 @@ var IrBuilder = class {
         const isCallee = this.expressionIsCallee(expression);
         const entity = this.entityMap.getFunctionEntity(originalEntity);
         const returnType = this.entityMap.getType(suitableFunction.getReturnType());
-        return receiver !== void 0 ? new MethodAccessExpression(
+        return receiver !== void 0 ? methodAccessExpression(
           receiver,
           false,
-          new AccessedFunction5(entity, returnType),
+          accessedFunction(entity, returnType),
           isCallee,
-          void 0,
           this.getSourceLocation(expression)
         ) : functionAccessExpression(
-          new AccessedFunction5(entity, returnType),
+          accessedFunction(entity, returnType),
           isCallee,
           this.getSourceLocation(expression)
         );
@@ -66467,22 +66378,21 @@ var IrBuilder = class {
         const suitableOperator = meaning.singleSuitableOperator;
         if (suitableOperator === void 0) {
           Logger.errorAtNode("Ambiguous operator access.", expression);
-          return new TextLiteral2("Ambiguous operator access.", void 0);
+          return textLiteral("Ambiguous operator access.");
         }
         const originalEntity = suitableOperator.getEntity();
         const receiver = this.createExplicitReceiver(originalEntity);
         const isCallee = this.expressionIsCallee(expression);
         const entity = this.entityMap.getOperatorEntity(originalEntity);
         const returnType = this.entityMap.getType(suitableOperator.getReturnType());
-        return receiver !== void 0 ? new MethodAccessExpression(
+        return receiver !== void 0 ? methodAccessExpression(
           receiver,
           false,
-          new AccessedFunction5(entity, returnType),
+          accessedFunction(entity, returnType),
           isCallee,
-          void 0,
           this.getSourceLocation(expression)
         ) : functionAccessExpression(
-          new AccessedFunction5(entity, returnType),
+          accessedFunction(entity, returnType),
           isCallee,
           this.getSourceLocation(expression)
         );
@@ -66495,14 +66405,14 @@ var IrBuilder = class {
     let result;
     if (entity.isStatic()) {
       const typeOrExtensionEntity = this.entityMap.getTypeOrExtensionEntity(entity.getContainingEntity());
-      result = new TypeAccessExpression(typeOrExtensionEntity, void 0);
+      result = typeAccessExpression(typeOrExtensionEntity);
     } else {
       const contextualType = TypeWithMembersOrExtensionEntity15.getContextualTypeEntity(
         entity.getContainingEntity()
       );
       Debug.assertNotNull(contextualType, "\u0422\u0438\u043F \u043A\u043E\u043D\u0442\u0435\u043A\u0441\u0442\u0430 \u0434\u043E\u043B\u0436\u0435\u043D \u0431\u044B\u0442\u044C \u043E\u043F\u0440\u0435\u0434\u0435\u043B\u0451\u043D.");
       const type = this.entityMap.getType(this.analyzer.instantiateTypeByIdentitySubstitution(contextualType));
-      result = new ThisExpression(type, void 0);
+      result = thisExpression(type);
     }
     return result;
   }
@@ -66568,7 +66478,7 @@ var IrBuilder = class {
     const entity = this.entityMap.getFunctionEntity(func.getEntity());
     const returnType = this.entityMap.getType(func.getReturnType());
     const functionCall = functionCallExpression(
-      new AccessedFunction5(entity, returnType),
+      accessedFunction(entity, returnType),
       args,
       this.getSourceLocation(tag)
     );
@@ -66654,7 +66564,7 @@ var IrBuilder = class {
   createAccessedFunctionFromOperator(operator) {
     const entity = this.entityMap.getOperatorEntity(operator.getEntity());
     const type = this.entityMap.getType(operator.getReturnType());
-    return new AccessedFunction5(entity, type);
+    return accessedFunction(entity, type);
   }
   expressionIsCallee(expression) {
     return this.analyzer.ifCalleeThenCallExpression(expression) !== void 0;
@@ -66683,11 +66593,8 @@ var IrBuilder = class {
     const entity = this.analyzer.entity.ofTextTranslationDeclaration(translation.sourceText);
     if (translation.sourceText.kind === 144 /* TranslationTextLiteral */ && translation.targetText.kind === 84 /* TextLiteral */) {
       const translatedText = unescapeText(withoutQuotes(translation.targetText.text.value));
-      const translatedTextNode = new TextLiteral2(
-        translatedText,
-        this.getSourceLocation(translation.targetText)
-      );
-      return new TextTranslationDeclaration2(
+      const translatedTextNode = textLiteral(translatedText, this.getSourceLocation(translation.targetText));
+      return textTranslationDeclaration(
         entity.getKey(),
         void 0,
         translatedTextNode,
@@ -66695,16 +66602,16 @@ var IrBuilder = class {
       );
     }
     const parameters = entity.getParameters().map((p) => this.entityMap.getVariableEntity(p));
-    const translationTextTemplate = new TranslationTextTemplate2(
+    const translationTextTemplate2 = translationTextTemplate(
       entity.getTextFragments(),
       parameters,
       this.getSourceLocation(translation.sourceText)
     );
     const returnExpression = this.buildExpression(translation.targetText);
     const block = blockStatement([returnStatement(returnExpression)]);
-    return new TextTranslationDeclaration2(
+    return textTranslationDeclaration(
       entity.getKey(),
-      translationTextTemplate,
+      translationTextTemplate2,
       block,
       this.getSourceLocation(translation)
     );
@@ -66712,7 +66619,7 @@ var IrBuilder = class {
   buildTextTranslationFunctionDeclaration(translation) {
     const entity = this.analyzer.entity.ofTextTranslationDeclaration(translation.sourceText);
     const parameters = entity.getParameters().map((p) => this.entityMap.getVariableEntity(p));
-    const translationTextTemplate = new TranslationTextTemplate2(
+    const translationTextTemplate2 = translationTextTemplate(
       entity.getTextFragments(),
       parameters,
       this.getSourceLocation(translation.sourceText)
@@ -66721,9 +66628,9 @@ var IrBuilder = class {
       translation.block,
       this.analyzer.resultLocalVariableEntity.ofTextTranslationFunctionDeclaration(translation)
     );
-    return new TextTranslationDeclaration2(
+    return textTranslationDeclaration(
       entity.getKey(),
-      translationTextTemplate,
+      translationTextTemplate2,
       block,
       this.getSourceLocation(translation)
     );
@@ -68195,8 +68102,7 @@ var Emitter = class _Emitter {
     return Query.from(packageGraph.enumeratePackages(this.targetPlatform)).filter((p) => p.kind === "program" && !p.configuration.isInterfacePackage() || p.kind === "text-translation");
   }
   createPackageWithMainFunction(packages, mainSourcePackage) {
-    const entity = new IntrinsicPackageEntity("Launch", mainSourcePackage.locale);
-    entity.details.isPackageWithMainFunction = true;
+    const entity = packageEntity("Launch", mainSourcePackage.locale, true, false);
     const packageConstructors = packages.flatMap((p) => p.ir.declarations).filter((d) => d.kind === 22 /* PackageFunctionDeclaration */ && d.entity.details.isPackageConstructor);
     const packageEntryPoints = packages.flatMap((p) => p.ir.declarations).filter((d) => d.kind === 22 /* PackageFunctionDeclaration */ && d.entity.details.isPackageEntryPoint);
     const mainFunction = this.createMainFunction(packageConstructors, packageEntryPoints, entity);
@@ -68209,14 +68115,15 @@ var Emitter = class _Emitter {
     const body = blockStatement(functionCallStatements);
     const isAsyncFunction = packageConstructors.some((o) => o.modifiers.isAsync()) || packageEntryPoints.some((o) => o.modifiers.isAsync());
     const mainFunctionName = EmitPhaseName.ofMainFunction(containingPackage.locale);
-    const entity = new IntrinsicFunctionEntity(
-      0 /* RegularFunction */,
+    const entity = packageFunctionEntity(
       mainFunctionName,
       [],
       this.ectx.standardTypes.nullType,
-      containingPackage
+      containingPackage,
+      isAsyncFunction,
+      false,
+      false
     );
-    entity.details.isAsync = isAsyncFunction;
     return packageFunctionDeclaration(entity, [], body, false);
   }
   createUniqueNamesForPackageMembers(packages) {
@@ -68567,11 +68474,10 @@ var DeclarationRenamer = class _DeclarationRenamer {
         case 95 /* ComputedFieldDeclaration */:
           this.renameParametersAndLocals([], member.getter.body, packageMemberNames);
           if (member.setter !== void 0) {
-            this.renameParametersAndLocals([new ParameterDeclaration2(
+            this.renameParametersAndLocals([parameterDeclaration(
               member.setter.valueLocalVariableEntity,
               void 0,
-              false,
-              void 0
+              false
             )], member.setter.body, packageMemberNames);
           }
           break;