@artel/artc 0.6.26027 → 0.6.26029

package/build/{chunk-IJGHVDYP.js → chunk-OFV2Q5YR.js}

@@ -764,7 +764,7 @@ var UniqueWithComparatorQuery = class extends Query {
 };
 
 // source/common/Constants.ts
-var ArtelVersion = true ? "0.6.26027" : "";
+var ArtelVersion = true ? "0.6.26029" : "";
 var ArtelSourceFileExtensions = [".\u0430\u0440\u0442", ".\u0430\u0440\u0442\u0435\u043B\u044C", ".art", ".artel", ".\u0430\u0440\u0442\u043C", ".\u0430\u0440\u0442\u0435\u043B\u044C\u043C", ".artm", ".artelm"];
 var ArtelSourceFileExtensionSet = new Set(ArtelSourceFileExtensions);
 var ArtelSourceAndConfigurationFileExtensionSet = new Set(ArtelSourceFileExtensionSet).add(".json");
@@ -3913,7 +3913,7 @@ var StructuredTypeKind = /* @__PURE__ */ ((StructuredTypeKind3) => {
 
 // source/entities/TypeEntity.ts
 var TypeEntity;
-((TypeEntity14) => {
+((TypeEntity15) => {
   function isAbstract(entity) {
     switch (entity.typeEntityKind) {
       case 1 /* Structured */:
@@ -3928,7 +3928,7 @@ var TypeEntity;
         Debug.never(entity);
     }
   }
-  TypeEntity14.isAbstract = isAbstract;
+  TypeEntity15.isAbstract = isAbstract;
   function isAbstractOrAliasedAbstract(entity) {
     switch (entity.typeEntityKind) {
       case 1 /* Structured */:
@@ -3946,7 +3946,7 @@ var TypeEntity;
         Debug.never(entity);
     }
   }
-  TypeEntity14.isAbstractOrAliasedAbstract = isAbstractOrAliasedAbstract;
+  TypeEntity15.isAbstractOrAliasedAbstract = isAbstractOrAliasedAbstract;
   function isBasic(entity) {
     switch (entity.typeEntityKind) {
       case 1 /* Structured */:
@@ -3961,7 +3961,7 @@ var TypeEntity;
         Debug.never(entity);
     }
   }
-  TypeEntity14.isBasic = isBasic;
+  TypeEntity15.isBasic = isBasic;
   function isBasicOrAliasedBasic(entity) {
     switch (entity.typeEntityKind) {
       case 1 /* Structured */:
@@ -3979,7 +3979,7 @@ var TypeEntity;
         Debug.never(entity);
     }
   }
-  TypeEntity14.isBasicOrAliasedBasic = isBasicOrAliasedBasic;
+  TypeEntity15.isBasicOrAliasedBasic = isBasicOrAliasedBasic;
 })(TypeEntity || (TypeEntity = {}));
 var TypeEntityKind = /* @__PURE__ */ ((TypeEntityKind2) => {
   TypeEntityKind2[TypeEntityKind2["Function"] = 0] = "Function";
@@ -12255,6 +12255,7 @@ var DiagnosticCode = /* @__PURE__ */ ((DiagnosticCode2) => {
   DiagnosticCode2[DiagnosticCode2["CannotAssignValueBecauseWriteFunctionIsNotDefined"] = 2243] = "CannotAssignValueBecauseWriteFunctionIsNotDefined";
   DiagnosticCode2[DiagnosticCode2["CannotAssignValueBecauseWriteFunctionIsHidden"] = 2244] = "CannotAssignValueBecauseWriteFunctionIsHidden";
   DiagnosticCode2[DiagnosticCode2["ReadFunctionMustHaveTheSameTypeAsWriteFunction"] = 2245] = "ReadFunctionMustHaveTheSameTypeAsWriteFunction";
+  DiagnosticCode2[DiagnosticCode2["AspectHasAlreadyBeenExtendedWithDifferentTypeArguments0"] = 2246] = "AspectHasAlreadyBeenExtendedWithDifferentTypeArguments0";
   DiagnosticCode2[DiagnosticCode2["CannotFindTsLibDirectoryBaseSearchPaths0"] = 3e3] = "CannotFindTsLibDirectoryBaseSearchPaths0";
   DiagnosticCode2[DiagnosticCode2["SourceFile0IsNotPartOfThePackageAndWontBeLoaded"] = 3001] = "SourceFile0IsNotPartOfThePackageAndWontBeLoaded";
   DiagnosticCode2[DiagnosticCode2["ProgramWithoutMainPackageCannotBeCompiled"] = 3002] = "ProgramWithoutMainPackageCannotBeCompiled";
@@ -12600,6 +12601,7 @@ var englishErrorMessages = {
   [2243 /* CannotAssignValueBecauseWriteFunctionIsNotDefined */]: "Cannot assign value because write function is not defined.",
   [2244 /* CannotAssignValueBecauseWriteFunctionIsHidden */]: "Cannot assign value because write function is hidden.",
   [2245 /* ReadFunctionMustHaveTheSameTypeAsWriteFunction */]: "Read function must have the same type as write function.",
+  [2246 /* AspectHasAlreadyBeenExtendedWithDifferentTypeArguments0 */]: "Aspect has already been extended with different type arguments: '{0}'.",
   [3e3 /* CannotFindTsLibDirectoryBaseSearchPaths0 */]: "Can not find directory with TypeScript library. Base search paths: {0}.",
   [3001 /* SourceFile0IsNotPartOfThePackageAndWontBeLoaded */]: "Source file '{0}' is not part of the package and won't be loaded.",
   [3002 /* ProgramWithoutMainPackageCannotBeCompiled */]: "Program without main package cannot be compiled.",
@@ -12899,6 +12901,7 @@ var russianErrorMessages = {
   [2243 /* CannotAssignValueBecauseWriteFunctionIsNotDefined */]: "\u041D\u0435\u043B\u044C\u0437\u044F \u043F\u0440\u0438\u0441\u0432\u043E\u0438\u0442\u044C \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435, \u043F\u043E\u0441\u043A\u043E\u043B\u044C\u043A\u0443 \u043E\u0442\u0441\u0443\u0442\u0441\u0442\u0432\u0443\u0435\u0442 \u0444\u0443\u043D\u043A\u0446\u0438\u044F \u0437\u0430\u043F\u0438\u0441\u0438.",
   [2244 /* CannotAssignValueBecauseWriteFunctionIsHidden */]: "\u041D\u0435\u043B\u044C\u0437\u044F \u043F\u0440\u0438\u0441\u0432\u043E\u0438\u0442\u044C \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435, \u043F\u043E\u0441\u043A\u043E\u043B\u044C\u043A\u0443 \u0444\u0443\u043D\u043A\u0446\u0438\u044F \u0437\u0430\u043F\u0438\u0441\u0438 \u0441\u043A\u0440\u044B\u0442\u0430.",
   [2245 /* ReadFunctionMustHaveTheSameTypeAsWriteFunction */]: "\u0424\u0443\u043D\u043A\u0446\u0438\u044F \u0447\u0442\u0435\u043D\u0438\u044F \u0434\u043E\u043B\u0436\u043D\u0430 \u0438\u043C\u0435\u0442\u044C \u0442\u0430\u043A\u043E\u0439 \u0436\u0435 \u0442\u0438\u043F, \u043A\u0430\u043A \u0444\u0443\u043D\u043A\u0446\u0438\u044F \u0437\u0430\u043F\u0438\u0441\u0438.",
+  [2246 /* AspectHasAlreadyBeenExtendedWithDifferentTypeArguments0 */]: "\u0410\u0441\u043F\u0435\u043A\u0442 \u0443\u0436\u0435 \u0431\u044B\u043B \u0440\u0430\u0441\u0448\u0438\u0440\u0435\u043D \u0441 \u0434\u0440\u0443\u0433\u0438\u043C\u0438 \u0430\u0440\u0433\u0443\u043C\u0435\u043D\u0442\u0430\u043C\u0438 \u0442\u0438\u043F\u0430: '{0}'.",
   [3e3 /* CannotFindTsLibDirectoryBaseSearchPaths0 */]: "\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u043D\u0430\u0439\u0442\u0438 \u043F\u0430\u043F\u043A\u0443 \u0441\u043E \u0441\u0442\u0430\u043D\u0434\u0430\u0440\u0442\u043D\u043E\u0439 \u0431\u0438\u0431\u043B\u0438\u043E\u0442\u0435\u043A\u043E\u0439 TypeScript. \u041F\u0443\u0442\u0438, \u043E\u0442\u043D\u043E\u0441\u0438\u0442\u0435\u043B\u044C\u043D\u043E \u043A\u043E\u0442\u043E\u0440\u044B\u0445 \u043E\u0441\u0443\u0449\u0435\u0441\u0442\u0432\u043B\u044F\u043B\u0441\u044F \u043F\u043E\u0438\u0441\u043A: {0}.",
   [3001 /* SourceFile0IsNotPartOfThePackageAndWontBeLoaded */]: "\u0418\u0441\u0445\u043E\u0434\u043D\u044B\u0439 \u0444\u0430\u0439\u043B '{0}' \u043D\u0435 \u044F\u0432\u043B\u044F\u0435\u0442\u0441\u044F \u0447\u0430\u0441\u0442\u044C\u044E \u043F\u0430\u043A\u0435\u0442\u0430 \u0438 \u043D\u0435 \u0431\u0443\u0434\u0435\u0442 \u0437\u0430\u0433\u0440\u0443\u0436\u0435\u043D.",
   [3002 /* ProgramWithoutMainPackageCannotBeCompiled */]: "\u041F\u0440\u043E\u0433\u0440\u0430\u043C\u043C\u0430 \u0431\u0435\u0437 \u0433\u043B\u0430\u0432\u043D\u043E\u0433\u043E \u043F\u0430\u043A\u0435\u0442\u0430 \u043D\u0435 \u043C\u043E\u0436\u0435\u0442 \u0431\u044B\u0442\u044C \u0441\u043A\u043E\u043C\u043F\u0438\u043B\u0438\u0440\u043E\u0432\u0430\u043D\u0430.",
@@ -26794,6 +26797,7 @@ var FunctionEntityDetails = class {
     this.isJavaScriptIteratorMethod = false;
     this.hasObjectParameter = false;
     this.isSetter = false;
+    this.nameSource = void 0;
   }
 };
 var VariableEntityDetails = class {
@@ -26808,6 +26812,7 @@ var VariableEntityDetails = class {
     this.isStatic = false;
     this.isConst = false;
     this.isObjectParameter = false;
+    this.nameSource = void 0;
   }
 };
 var TypeOrExtensionEntityDetails = class {
@@ -26822,6 +26827,7 @@ var TypeOrExtensionEntityDetails = class {
      */
     this.areOwnComputedNamesOfMembersResolved = false;
     this.implicitlyImplementedAbstractMembersByImplementingMember = /* @__PURE__ */ new Map();
+    this.nameSource = void 0;
   }
 };
 var PackageEntityDetails = class {
@@ -28099,10 +28105,11 @@ var FunctionLiteral2 = class _FunctionLiteral {
   }
 };
 var JsFunctionLiteral = class _JsFunctionLiteral {
-  constructor(parameters, body, isAsync, returnType, sourceLocation) {
+  constructor(parameters, body, isAsync, isGenerator, returnType, sourceLocation) {
     this.parameters = parameters;
     this.body = body;
     this.isAsync = isAsync;
+    this.isGenerator = isGenerator;
     this.returnType = returnType;
     this.sourceLocation = sourceLocation;
     this.kind = 39 /* JsFunctionLiteral */;
@@ -28112,6 +28119,7 @@ var JsFunctionLiteral = class _JsFunctionLiteral {
       this.parameters.map((p) => p.clone()),
       this.body.clone(),
       this.isAsync,
+      this.isGenerator,
       this.returnType,
       this.sourceLocation
     );
@@ -30561,8 +30569,8 @@ function functionAccessExpression(func, isCallee, sourceLocation) {
 function functionLiteral(parameters, body, isAsync, returnType, sourceLocation) {
   return new FunctionLiteral2(parameters, body, isAsync, returnType, sourceLocation);
 }
-function jsFunctionLiteral(parameters, body, isAsync, returnType, sourceLocation) {
-  return new JsFunctionLiteral(parameters, body, isAsync, returnType, sourceLocation);
+function jsFunctionLiteral(parameters, body, isAsync, isGenerator, returnType, sourceLocation) {
+  return new JsFunctionLiteral(parameters, body, isAsync, isGenerator, returnType, sourceLocation);
 }
 function nestedFunctionDeclarationStatement(entity, parameters, body, isAsync, isGenerator, sourceLocation) {
   const declaration = new NestedFunctionDeclaration2(entity, parameters, body, isAsync, isGenerator, sourceLocation);
@@ -31077,6 +31085,9 @@ var Transformer = class {
   get transformedDeclaration() {
     return this.transformedDeclaration_;
   }
+  get transformedTypeDeclaration() {
+    return this.transformedTypeDeclaration_;
+  }
   transformChildren(node) {
     switch (node.kind) {
       case 0 /* AsExpression */:
@@ -31822,13 +31833,16 @@ var Transformer = class {
   }
   transformPackageTypeDeclarationChildren(declaration) {
     const saveTransformedDeclaration = this.transformedDeclaration_;
+    const saveTransformedTypeDeclaration = this.transformedTypeDeclaration_;
     this.transformedDeclaration_ = declaration;
+    this.transformedTypeDeclaration_ = declaration;
     declaration.decorators = declaration.decorators.map((d) => this.transformDecorator(d));
     declaration.members = this.transformArrayWithErrorBoundary(
       declaration.members,
       (m) => this.transformTypeMemberDeclaration(m)
     );
     this.transformedDeclaration_ = saveTransformedDeclaration;
+    this.transformedTypeDeclaration_ = saveTransformedTypeDeclaration;
   }
   transformTypeMemberDeclaration(declaration) {
     let result;
@@ -32023,9 +32037,12 @@ var Transformer = class {
   }
   transformPackageVariantTypeDeclarationChildren(declaration) {
     const saveTransformedDeclaration = this.transformedDeclaration_;
+    const saveTransformedTypeDeclaration = this.transformedTypeDeclaration_;
     this.transformedDeclaration_ = declaration;
+    this.transformedTypeDeclaration_ = declaration;
     declaration.variants = declaration.variants.map((v) => this.transformVariantValueDeclaration(v));
     this.transformedDeclaration_ = saveTransformedDeclaration;
+    this.transformedTypeDeclaration_ = saveTransformedTypeDeclaration;
   }
   transformVariantValueDeclaration(node) {
     let action;
@@ -33073,6 +33090,15 @@ var GeneralLoweringContext = class {
   createJsFunctionCallMethodAccess(object, isOptionalChaining) {
     return jsPropertyAccessExpression(object, isOptionalChaining, "call", this.ectx.standardTypes.func);
   }
+  createBindMethodCall(object, isOptionalChaining, argument2) {
+    const bindMethodAccess = jsPropertyAccessExpression(
+      object,
+      isOptionalChaining,
+      "bind",
+      this.ectx.standardTypes.func
+    );
+    return callExpression(bindMethodAccess, false, [argument2], false, this.ectx.standardTypes.object, false);
+  }
   createKeyForComputedNameWithSymbolKey(symbolDeclaration) {
     return symbolDeclaration.ifTypeMemberThenContainingType !== void 0 ? staticFieldGetAccess(symbolDeclaration) : variableGetAccess(symbolDeclaration);
   }
@@ -35634,9 +35660,19 @@ var UsagesLowering = class _UsagesLowering extends ExecutableCodeLowering {
         this.objectParameterLowering.tryRemoveObjectParameterFromNestedFunction(node);
         return preserveNode();
       },
+      transformNestedFunctionDeclarationStatement: (node) => {
+        if (transformer.transformedTypeDeclaration !== void 0 && !node.declaration.entity.details.hasObjectParameter) {
+          return replaceStatement(this.bindThisToNestedFunctionDeclaration(node));
+        }
+        return preserveStatement();
+      },
       transformFunctionJsObjectLiteralProperty: (node) => {
         this.objectParameterLowering.tryRemoveObjectParameterFromFunctionJsObjectLiteralProperty(node);
         return preserveNode();
+      },
+      transformBlockStatement: (node) => {
+        this.moveNestedFunctionsToTheBeginningOfTheBlock(node);
+        return preserveStatement();
       }
     });
     transformer.transformPackage(this.pkg.ir);
@@ -35855,6 +35891,40 @@ var UsagesLowering = class _UsagesLowering extends ExecutableCodeLowering {
     const { expression, tempVariables } = this.replaceCompoundAssignmentWithSimpleAssignment(node);
     return replaceExpression(expression, tempVariables);
   }
+  moveNestedFunctionsToTheBeginningOfTheBlock(node) {
+    const statements = node.statements;
+    if (!statements.some((s) => s.kind === 33 /* NestedFunctionDeclarationStatement */)) {
+      return;
+    }
+    node.statements = [
+      ...statements.filter((s) => s.kind === 33 /* NestedFunctionDeclarationStatement */),
+      ...statements.filter((s) => s.kind !== 33 /* NestedFunctionDeclarationStatement */)
+    ];
+  }
+  bindThisToNestedFunctionDeclaration(node) {
+    const declaration = node.declaration;
+    const jsFunctionLiteral2 = jsFunctionLiteral(
+      declaration.parameters,
+      declaration.body,
+      declaration.isAsync,
+      declaration.isGenerator,
+      declaration.entity.returnType,
+      declaration.sourceLocation
+    );
+    const bindCall = this.ctx.createBindMethodCall(
+      jsFunctionLiteral2,
+      false,
+      thisExpression(this.ctx.ectx.standardTypes.object)
+    );
+    const localVariableEntity2 = localVariableEntity(
+      declaration.entity.name,
+      this.ctx.ectx.standardTypes.func,
+      this.packageEntity,
+      true
+    );
+    declaration.entity.details.nameSource = localVariableEntity2;
+    return localVariableDeclarationStatement(localVariableEntity2, bindCall, node.sourceLocation);
+  }
 };
 var OperatorsUsageLowering = class extends ExecutableCodeLowering {
   tryLowerPrefixUnaryExpression(node) {
@@ -36417,6 +36487,7 @@ var ObjectParameterLowering = class extends ExecutableCodeLowering {
         node.parameters.slice(1),
         node.body,
         node.isAsync,
+        false,
         node.returnType,
         node.sourceLocation
       );
@@ -39281,7 +39352,8 @@ var _IrToJs = class _IrToJs {
     const parameters = this.convertParameters(expression.parameters);
     const body = this.convertBlockStatement(expression.body);
     const async = expression.isAsync;
-    const result = js.functionExpression(void 0, parameters, body, false, async);
+    const generator = expression.isGenerator;
+    const result = js.functionExpression(void 0, parameters, body, generator, async);
     this.addNodeLocation(result, expression);
     return result;
   }
@@ -39942,7 +40014,11 @@ var _IrToJs = class _IrToJs {
     }
   }
   getEntityName(entity) {
-    return this.entityNameOverrides?.get(entity) ?? entity.name;
+    let namedEntity = entity;
+    while (namedEntity.details.nameSource !== void 0) {
+      namedEntity = namedEntity.details.nameSource;
+    }
+    return this.entityNameOverrides?.get(namedEntity) ?? namedEntity.name;
   }
   convertArrayWithErrorBoundary(array, convert) {
     const result = new Array();
@@ -60694,518 +60770,375 @@ var SourceFileAnalyzer = class {
     });
   }
   analyzeNode(node, controller) {
+    let result = void 0;
     switch (node.kind) {
-      case 86 /* IdentifierExpression */: {
+      case 86 /* IdentifierExpression */:
         this.checkIdentifierExpression(node);
         break;
-      }
-      case 65 /* CallExpression */: {
+      case 65 /* CallExpression */:
         this.checkCallExpression(node);
         break;
-      }
-      case 66 /* AutotypeCallExpression */: {
-        this.analyzer.resolveAutotypeCallExpression(node);
+      case 66 /* AutotypeCallExpression */:
+        this.checkAutotypeCallExpression(node);
         break;
-      }
-      case 67 /* IndexedAccessExpression */: {
+      case 67 /* IndexedAccessExpression */:
         this.checkIndexedAccessExpression(node);
         break;
-      }
-      case 75 /* DereferenceExpression */: {
+      case 75 /* DereferenceExpression */:
         this.checkDereferenceExpression(node);
         break;
-      }
-      case 150 /* Tag */: {
-        this.analyzer.resolveTag(node);
+      case 150 /* Tag */:
+        this.checkTag(node);
         break;
-      }
-      case 10 /* NamedTypeSpecifier */: {
-        const resolutionResult = this.analyzer.resolveNamedTypeSpecifier(node);
-        if (resolutionResult.type !== void 0) {
-          const entity = resolutionResult.type.getEntity();
-          if (entity !== void 0) {
-            const typeArgumentCount = node.typeArgumentClause?.typeArgumentList.typeArguments.count() ?? 0;
-            this.analyzer.checkTypeArgumentCount(
-              typeArgumentCount,
-              entity.getTypeParameters(),
-              this.diagnosticAcceptor,
-              node.typeArgumentClause ?? node.qualifiedName
-            );
-            const substitutions = resolutionResult.type.getSubstitutions();
-            this.checkTypeArgumentTypesAreAssignableToConstraints(
-              entity.getTypeParameters(),
-              substitutions,
-              void 0,
-              node.typeArgumentClause ?? node
-            );
-          }
-        }
+      case 10 /* NamedTypeSpecifier */:
+        this.checkNamedTypeSpecifier(node);
         break;
-      }
-      case 37 /* ExtendedTypeClause */: {
+      case 37 /* ExtendedTypeClause */:
         break;
-      }
-      case 73 /* MemberAccessExpression */: {
+      case 73 /* MemberAccessExpression */:
         this.checkMemberAccessExpression(node);
         break;
-      }
-      case 82 /* LocalizableTextLiteral */: {
-        this.analyzer.resolveLocalizableTextOrTextTemplate(node);
+      case 82 /* LocalizableTextLiteral */:
+        this.checkLocalizableTextLiteral(node);
         break;
-      }
-      case 77 /* LocalizableTextTemplateLiteral */: {
-        const resolved = this.analyzer.resolveLocalizableTextOrTextTemplate(node);
-        if (resolved !== void 0) {
-          const spans = node.spanList.spans;
-          const parameters = resolved.getParameters();
-          if (spans.length === parameters.length) {
-            for (let i = 0; i < spans.length; i++) {
-              const argument2 = spans[i].expression;
-              const parameter = parameters[i];
-              this.checkExpressionTypeIsAssignableToTargetType(argument2, parameter.getType());
-            }
-          }
-        }
+      case 77 /* LocalizableTextTemplateLiteral */:
+        this.checkLocalizableTextTemplateLiteral(node);
         break;
-      }
-      case 121 /* TranslationsDeclaration */: {
-        if (this.sourceFile.package.kind === "program") {
-          this.createAndAddDiagnostic(
-            2051 /* TranslationsCanOnlyBeDeclaredInTranslationPackage */,
-            node.translationsKeyword
-          );
-          controller.skipChildrenTraverse();
-        } else if (this.sourceFile.package.kind === "translation") {
-          if (this.resolvedTranslationPackage === void 0) {
-            this.createAndAddDiagnostic(
-              2052 /* UnknownTranslatingPackage0 */,
-              node.translationsKeyword,
-              [this.sourceFile.package.configuration.targetPackageName.toString()]
-            );
-            controller.skipChildrenTraverse();
-          }
-        } else if (this.sourceFile.package.kind === "text-translation") {
-          const textTranslationPackage = this.textTranslationPackage;
-          const targetPackage = textTranslationPackage?.getTargetPackage();
-          if (targetPackage === void 0 || textTranslationPackage === void 0) {
-            this.createAndAddDiagnostic(
-              2052 /* UnknownTranslatingPackage0 */,
-              node.translationsKeyword,
-              [this.sourceFile.package.configuration.targetPackageName.toString()]
-            );
-            controller.skipChildrenTraverse();
-          } else {
-            if (textTranslationPackage.isPrimary()) {
-              const packages = this.analyzer.getTextTranslationPackagesOfTargetPackage(targetPackage);
-              if (packages !== void 0 && packages.some((p) => p.isPrimary() && p !== textTranslationPackage)) {
-                this.createAndAddDiagnostic(
-                  2196 /* OnlyOneTextTranslationPackageShouldBeMarkedAsPrimary */,
-                  node.translationsKeyword,
-                  []
-                );
-              }
-            }
-            if (this.sourceFile.package.sourceFiles[0] === this.sourceFile) {
-              this.addNotTranslatedTextsDiagnostics(textTranslationPackage, node.translationsKeyword);
-            }
-          }
-        }
+      case 121 /* TranslationsDeclaration */:
+        this.checkTranslationsDeclaration(node, controller);
         break;
-      }
       case 138 /* TextTranslationDeclaration */:
-      case 139 /* TextTranslationFunctionDeclaration */: {
+      case 139 /* TextTranslationFunctionDeclaration */:
         this.checkTextTranslationDeclaration(node);
         break;
-      }
       case 27 /* PackageClassDeclaration */:
       case 28 /* PackageStructureDeclaration */:
-      case 29 /* PackageAspectDeclaration */: {
-        return this.checkPackageStructuredTypeDeclaration(node, controller);
-      }
-      case 31 /* PackageVariantDeclaration */: {
+      case 29 /* PackageAspectDeclaration */:
+        result = this.checkPackageStructuredTypeDeclaration(node, controller);
+        break;
+      case 31 /* PackageVariantDeclaration */:
         this.checkPackageVariantDeclaration(node);
         break;
-      }
-      case 32 /* PackageVariableDeclaration */: {
+      case 32 /* PackageVariableDeclaration */:
         this.checkPackageVariableDeclaration(node);
         break;
-      }
-      case 23 /* PackageFunctionDeclaration */: {
+      case 23 /* PackageFunctionDeclaration */:
         this.checkPackageFunctionDeclaration(node);
         break;
-      }
-      case 33 /* PackageVariableGetterDeclaration */: {
+      case 33 /* PackageVariableGetterDeclaration */:
         this.checkPackageVariableGetterDeclaration(node);
         break;
-      }
-      case 34 /* PackageVariableSetterDeclaration */: {
+      case 34 /* PackageVariableSetterDeclaration */:
         this.checkPackageVariableSetterDeclaration(node);
         break;
-      }
-      case 21 /* PackageConstructorDeclaration */: {
-        if (this.isInterfacePackageFile) {
-          this.createAndAddDiagnostic(2060 /* InterfacePackageMustNotContainImplementation */, node);
-        }
+      case 21 /* PackageConstructorDeclaration */:
+        this.checkPackageConstructorDeclaration(node);
         break;
-      }
-      case 22 /* PackageEntryPointDeclaration */: {
-        if (this.isInterfacePackageFile) {
-          this.createAndAddDiagnostic(2060 /* InterfacePackageMustNotContainImplementation */, node.runKeyword);
-        }
+      case 22 /* PackageEntryPointDeclaration */:
+        this.checkPackageEntryPointDeclaration(node);
         break;
-      }
-      case 40 /* ConstructorDeclaration */: {
+      case 40 /* ConstructorDeclaration */:
         this.checkConstructorDeclaration(node);
         break;
-      }
-      case 41 /* DestructorDeclaration */: {
-        const entity = this.analyzer.entity.ofDestructorDeclaration(node);
-        entity.ensureAllDiagnosticsReported?.();
-        this.checkTypeMemberBodyPresence(entity, node.block, node.destructionKeyword);
-        this.analyzer.semanticContext.ofDestructorDeclarationParameters(node).validateNameConflicts(this.diagnosticAcceptor);
+      case 41 /* DestructorDeclaration */:
+        this.checkDestructorDeclaration(node);
         break;
-      }
-      case 49 /* FieldDeclaration */: {
+      case 49 /* FieldDeclaration */:
         this.checkFieldDeclaration(node);
         break;
-      }
-      case 47 /* MethodDeclaration */: {
+      case 47 /* MethodDeclaration */:
         this.checkMethodDeclaration(node);
         break;
-      }
-      case 50 /* FieldGetterDeclaration */: {
+      case 50 /* FieldGetterDeclaration */:
         this.checkFieldGetterDeclaration(node);
         break;
-      }
-      case 51 /* FieldSetterDeclaration */: {
+      case 51 /* FieldSetterDeclaration */:
         this.checkFieldSetterDeclaration(node);
         break;
-      }
-      case 42 /* IndexedElementGetterDeclaration */: {
+      case 42 /* IndexedElementGetterDeclaration */:
         this.checkIndexedElementGetterDeclaration(node);
         break;
-      }
-      case 43 /* IndexedElementSetterDeclaration */: {
+      case 43 /* IndexedElementSetterDeclaration */:
         this.checkIndexedElementSetterDeclaration(node);
         break;
-      }
-      case 45 /* DereferencedVariableGetterDeclaration */: {
+      case 45 /* DereferencedVariableGetterDeclaration */:
         this.checkDereferencedVariableGetterDeclaration(node);
         break;
-      }
-      case 46 /* DereferencedVariableSetterDeclaration */: {
+      case 46 /* DereferencedVariableSetterDeclaration */:
         this.checkDereferencedVariableSetterDeclaration(node);
         break;
-      }
-      case 53 /* NestedFunctionDeclaration */: {
+      case 53 /* NestedFunctionDeclaration */:
         this.checkNestedFunctionDeclaration(node);
         break;
-      }
-      case 92 /* StatementBlock */: {
+      case 92 /* StatementBlock */:
         this.checkStatementBlock(node);
         break;
-      }
-      case 93 /* FunctionBlock */: {
+      case 93 /* FunctionBlock */:
         this.checkFunctionBlock(node);
         break;
-      }
-      case 105 /* ForStatement */: {
-        const checkResult = this.analyzer.checkExpressionCanBeUsedInForLoop(node.enumeratedExpression);
-        if (checkResult.kind === "error") {
-          this.addDiagnostics(checkResult.value);
-        }
-        this.analyzer.semanticContext.ofForStatement(node).validateNameConflicts(this.diagnosticAcceptor);
+      case 105 /* ForStatement */:
+        this.checkForStatement(node);
         break;
-      }
-      case 99 /* CatchClause */: {
-        this.analyzer.semanticContext.ofCatchClause(node).validateNameConflicts(this.diagnosticAcceptor);
+      case 99 /* CatchClause */:
+        this.checkCatchClause(node);
         break;
-      }
-      case 72 /* PrefixUnaryExpression */: {
-        this.analyzer.resolvePrefixUnaryExpressionUserDefinableOperator(node);
+      case 72 /* PrefixUnaryExpression */:
+        this.checkPrefixUnaryExpression(node);
         break;
-      }
-      case 61 /* BinaryExpression */: {
+      case 61 /* BinaryExpression */:
         this.checkBinaryExpression(node);
         break;
-      }
-      case 90 /* AssignmentStatement */: {
-        if (this.checkAssignmentIsValid(node)) {
-          if (node.operator.tokenKind === 64 /* Equals */) {
-            this.checkExpressionTypeIsAssignableToTargetType(node.right, this.analyzer.type.ofExpression(node.left));
-          }
-        }
-        const operatorKind = this.analyzer.getBinaryOperatorKindIfCompoundAssignmentOperator(node.operator);
-        if (operatorKind !== void 0) {
-          const operator = this.analyzer.resolveCompoundAssignmentStatementOperator(node, operatorKind);
-          if (operator !== void 0) {
-            const returnType = operator.getReturnType();
-            const leftType = this.analyzer.type.ofExpression(node.left);
-            if (!this.analyzer.isTypeAssignableTo(returnType, leftType)) {
-              this.addTypeAssignabilityDiagnosticIfBothTypesResolved(
-                returnType,
-                leftType,
-                node.right,
-                2032 /* Type0IsNotAssignableToType1 */
-              );
-            }
-          }
-        }
+      case 90 /* AssignmentStatement */:
+        this.checkAssignmentStatement(node);
         break;
-      }
-      case 35 /* TypeExtensionDeclaration */: {
-        const entity = this.analyzer.entity.ofTypeExtensionDeclaration(node);
-        entity.ensureAllDiagnosticsReported?.();
-        this.modifierValidator.validateTopLevelTypeMembers(
-          node.memberBlock.memberList,
-          6 /* TypeExtension */,
-          false,
-          false
-        );
-        this.overrideChecker.checkMembers(entity.getMembers());
-        new TypeMemberConflictsValidator(this.analyzer, entity.getMembers(), this.diagnosticAcceptor).validate();
+      case 35 /* TypeExtensionDeclaration */:
+        this.checkTypeExtensionDeclaration(node);
         break;
-      }
-      case 84 /* ObjectExpression */: {
-        this.analyzer.resolveObjectExpression(node);
+      case 84 /* ObjectExpression */:
+        this.checkObjectExpression(node);
         break;
-      }
-      case 85 /* BaseExpression */: {
-        const meaning = this.analyzer.resolveBaseExpression(node);
-        if (meaning.kind === "base-object-access") {
-          let parent = node.getParentSkippingParenthesizedExpressions();
-          if (parent.kind === 60 /* AsExpression */) {
-            parent = parent.getParentSkippingParenthesizedExpressions();
-          }
-          if (!(parent.kind === 73 /* MemberAccessExpression */ || parent.kind === 67 /* IndexedAccessExpression */ || parent.kind === 75 /* DereferenceExpression */)) {
-            this.createAndAddDiagnostic(2059 /* BaseCannotBeUsedAsAnExpressionInItself */, node);
-          }
-        } else if (meaning.kind === "overridden-method-access" && meaning.method.kind === "substituted-function") {
-          const typeArgumentClause = getParentGenericSpecializationExpression(node)?.typeArgumentClause;
-          this.checkTypeArgumentTypesAreAssignableToConstraints(
-            meaning.method.getTypeParameters(),
-            meaning.method.value.getSubstitutions(),
-            meaning.method.value.getOuterSubstitutions(),
-            typeArgumentClause ?? node
-          );
-        }
+      case 85 /* BaseExpression */:
+        this.checkBaseExpression(node);
         break;
-      }
-      case 114 /* ReturnStatement */: {
+      case 114 /* ReturnStatement */:
         this.checkReturnStatement(node);
         break;
-      }
-      case 120 /* YieldStatement */: {
+      case 120 /* YieldStatement */:
         this.checkYieldStatement(node);
         break;
-      }
-      case 19 /* PackageAliasTypeDeclaration */: {
-        const entity = this.analyzer.entity.ofPackageAliasTypeDeclaration(node);
-        if (entity.getAliasedType().causesCycle) {
-          this.createAndAddDiagnostic(2080 /* TypeAliasReferencesItself */, node.name);
-        }
-        if (node.typeParameterClause !== void 0) {
-          this.analyzer.semanticContext.ofTypeDeclarationTypeParameters(node, node.typeParameterClause).validateNameConflicts(this.diagnosticAcceptor);
-        }
-        this.overrideChecker.checkMembers(entity.getMembers());
-        new TypeMemberConflictsValidator(this.analyzer, entity.getMembers(), this.diagnosticAcceptor).validate();
-        const semanticContext = this.analyzer.semanticContext.outermostSemanticContextOfTypeDeclaration(node);
-        new BaseMemberConflictsValidator(
-          this.analyzer,
-          entity,
-          semanticContext.getDiagnosticArgumentFactory(),
-          this.diagnosticAcceptor,
-          node.name
-        ).validate();
+      case 19 /* PackageAliasTypeDeclaration */:
+        this.checkPackageAliasTypeDeclaration(node);
         break;
-      }
-      case 30 /* PackageReducedTypeDeclaration */: {
-        const entity = this.analyzer.entity.ofPackageReducedTypeDeclaration(node);
-        entity.ensureAllDiagnosticsReported?.();
-        if (entity.getReductionSource().causesCycle) {
-          this.createAndAddDiagnostic(2081 /* ReducedTypeReferencesItself */, node.name);
-        }
-        if (node.typeParameterClause !== void 0) {
-          this.analyzer.semanticContext.ofTypeDeclarationTypeParameters(node, node.typeParameterClause).validateNameConflicts(this.diagnosticAcceptor);
-        }
-        this.overrideChecker.checkMembers(entity.getMembers());
-        new TypeMemberConflictsValidator(this.analyzer, entity.getMembers(), this.diagnosticAcceptor).validate();
+      case 30 /* PackageReducedTypeDeclaration */:
+        this.checkPackageReducedTypeDeclaration(node);
         break;
-      }
-      case 158 /* TypeParameterList */: {
+      case 158 /* TypeParameterList */:
         this.checkTypeParameterList(node);
         break;
-      }
-      case 146 /* TypeParameterDeclaration */: {
+      case 146 /* TypeParameterDeclaration */:
         this.checkTypeParameterDeclaration(node);
         break;
-      }
-      case 87 /* GenericSpecializationExpression */: {
+      case 87 /* GenericSpecializationExpression */:
         this.checkGenericSpecializationExpression(node);
         break;
-      }
-      case 54 /* LocalVariableDeclaration */: {
-        const entity = this.analyzer.entity.ofLocalVariableDeclaration(node);
-        entity.ensureAllDiagnosticsReported?.();
-        if (node.typeAnnotation === void 0 && node.initializer === void 0) {
-          this.createAndAddDiagnostic(2184 /* VariableTypeIsNotSpecified */, node.name);
-        } else if (node.initializer !== void 0 && node.typeAnnotation !== void 0) {
-          this.checkExpressionTypeIsAssignableToTargetType(
-            node.initializer,
-            this.analyzer.type.ofTypeSpecifier(node.typeAnnotation.typeSpecifier)
-          );
-        }
-        this.checkIfVariableIsUnused(entity, node.name);
+      case 54 /* LocalVariableDeclaration */:
+        this.checkLocalVariableDeclaration(node);
         break;
-      }
-      case 55 /* ForStatementVariableDeclaration */: {
-        const entity = this.analyzer.entity.ofForStatementVariableDeclaration(node);
-        entity.ensureAllDiagnosticsReported?.();
-        this.checkIfVariableIsUnused(entity, node.name);
+      case 55 /* ForStatementVariableDeclaration */:
+        this.checkForStatementVariableDeclaration(node);
         break;
-      }
-      case 100 /* ErrorVariableDeclaration */: {
-        const entity = this.analyzer.entity.ofErrorVariableDeclaration(node);
-        entity.ensureAllDiagnosticsReported?.();
-        this.checkIfVariableIsUnused(entity, node.name);
+      case 100 /* ErrorVariableDeclaration */:
+        this.checkErrorVariableDeclaration(node);
         break;
-      }
-      case 154 /* ParameterList */: {
+      case 154 /* ParameterList */:
         this.checkParameterList(node);
         break;
-      }
-      case 147 /* ParameterDeclaration */: {
+      case 147 /* ParameterDeclaration */:
         this.checkParameterDeclaration(node);
         break;
-      }
-      case 62 /* FunctionLiteral */: {
+      case 62 /* FunctionLiteral */:
         this.checkFunctionLiteral(node);
         break;
-      }
-      case 63 /* FunctionBlockLiteral */: {
+      case 63 /* FunctionBlockLiteral */:
         this.checkFunctionBlockLiteral(node);
         break;
-      }
-      case 17 /* AnonymousFunctionTypeDeclaration */: {
-        this.analyzer.semanticContext.ofFunctionTypeDeclarationParameters(node).validateNameConflicts(this.diagnosticAcceptor);
+      case 17 /* AnonymousFunctionTypeDeclaration */:
+        this.checkAnonymousFunctionTypeDeclaration(node);
         break;
-      }
-      case 18 /* AnonymousClassDeclaration */: {
-        const entity = this.analyzer.entity.ofAnonymousStructuredTypeDeclaration(node);
-        this.overrideChecker.checkMembers(entity.getMembers());
-        new TypeMemberConflictsValidator(this.analyzer, entity.getMembers(), this.diagnosticAcceptor).validate();
-        const semanticContext = this.analyzer.semanticContext.outermostSemanticContextOfTypeDeclaration(node);
-        new BaseMemberConflictsValidator(
-          this.analyzer,
-          entity,
-          semanticContext.getDiagnosticArgumentFactory(),
-          this.diagnosticAcceptor,
-          node.classKeyword
-        ).validate();
-        const typeMemberImplementationCheckResult = this.analyzer.getTypeMemberImplementationCheckResult(entity);
-        this.attachNodeLocationAndAddDiagnostics(
-          typeMemberImplementationCheckResult.diagnosticsData,
-          node.classKeyword
-        );
-        if (!this.isInterfacePackageFile) {
-          this.addDiagnostics(this.analyzer.getOwnAndBaseConstructorCallsCheckResult(node).diagnostics);
-          new InstanceFieldsInitializationValidator(
-            this.analyzer,
-            node,
-            this.namedDeclarationsUsageMap,
-            this.diagnosticAcceptor
-          ).validate();
-        }
+      case 18 /* AnonymousClassDeclaration */:
+        this.checkAnonymousClassDeclaration(node);
         break;
-      }
-      case 26 /* TypeMemberDeclarationBlock */: {
+      case 26 /* TypeMemberDeclarationBlock */:
         this.checkTypeMemberDeclarationBlock(node);
         break;
-      }
-      case 148 /* Argument */: {
-        this.checkExpressionTypeIsAssignableToTargetType(
-          node.value,
-          this.analyzer.getTargetTypeOfExpression(node.value)
-        );
+      case 148 /* Argument */:
+        this.checkArgument(node);
         break;
-      }
-      case 102 /* ErrorStatement */: {
+      case 102 /* ErrorStatement */:
         this.checkErrorStatement(node);
         break;
-      }
-      case 106 /* IfStatement */: {
-        this.checkExpressionTypeIsAssignableToTargetType(node.condition, this.standardTypes.yesNo);
+      case 106 /* IfStatement */:
+        this.checkIfStatement(node);
         break;
-      }
-      case 108 /* ElseIfClause */: {
-        this.checkExpressionTypeIsAssignableToTargetType(node.condition, this.standardTypes.yesNo);
+      case 108 /* ElseIfClause */:
+        this.checkElseIfClause(node);
         break;
-      }
-      case 113 /* LoopStatement */: {
-        if (node.condition !== void 0) {
-          this.checkExpressionTypeIsAssignableToTargetType(node.condition, this.standardTypes.yesNo);
-        }
+      case 113 /* LoopStatement */:
+        this.checkLoopStatement(node);
         break;
-      }
-      case 119 /* WhileStatement */: {
-        this.checkExpressionTypeIsAssignableToTargetType(node.condition, this.standardTypes.yesNo);
+      case 119 /* WhileStatement */:
+        this.checkWhileStatement(node);
         break;
-      }
-      case 117 /* MatchExpressionList */: {
-        const matchedExpressionType = this.analyzer.type.ofExpression(node.parent.parent.parent.expression);
-        for (const expression of node.matchExpressions) {
-          this.checkExpressionTypeIsAssignableToTargetType(expression, matchedExpressionType);
-        }
+      case 117 /* MatchExpressionList */:
+        this.checkMatchExpressionList(node);
         break;
-      }
-      case 74 /* ReferenceExpression */: {
-        if (!this.analyzer.expressionCanBeReferenced(node.expression)) {
-          this.createAndAddDiagnostic(2189 /* ExpressionCannotBeReferenced */, node.expression);
-        }
+      case 74 /* ReferenceExpression */:
+        this.checkReferenceExpression(node);
         break;
-      }
       case 94 /* BreakLoopStatement */:
-      case 95 /* ContinueLoopStatement */: {
+      case 95 /* ContinueLoopStatement */:
         this.checkBreakLoopOrContinueLoopStatement(node);
         break;
-      }
-      case 89 /* OwnConstructorCallExpression */: {
-        this.analyzer.resolveOwnConstructorCallExpression(node);
+      case 89 /* OwnConstructorCallExpression */:
+        this.checkOwnConstructorCallExpression(node);
         break;
-      }
-      case 59 /* AssumptionExpression */: {
+      case 59 /* AssumptionExpression */:
         this.checkAssumptionExpression(node);
         break;
+    }
+    return result;
+  }
+  checkTag(node) {
+    this.analyzer.resolveTag(node);
+  }
+  checkPackageReducedTypeDeclaration(node) {
+    const entity = this.analyzer.entity.ofPackageReducedTypeDeclaration(node);
+    entity.ensureAllDiagnosticsReported?.();
+    if (entity.getReductionSource().causesCycle) {
+      this.createAndAddDiagnostic(2081 /* ReducedTypeReferencesItself */, node.name);
+    }
+    if (node.typeParameterClause !== void 0) {
+      this.analyzer.semanticContext.ofTypeDeclarationTypeParameters(node, node.typeParameterClause).validateNameConflicts(this.diagnosticAcceptor);
+    }
+    this.overrideChecker.checkMembers(entity.getMembers());
+    new TypeMemberConflictsValidator(this.analyzer, entity.getMembers(), this.diagnosticAcceptor).validate();
+  }
+  checkPackageAliasTypeDeclaration(node) {
+    const entity = this.analyzer.entity.ofPackageAliasTypeDeclaration(node);
+    if (entity.getAliasedType().causesCycle) {
+      this.createAndAddDiagnostic(2080 /* TypeAliasReferencesItself */, node.name);
+    }
+    if (node.typeParameterClause !== void 0) {
+      this.analyzer.semanticContext.ofTypeDeclarationTypeParameters(node, node.typeParameterClause).validateNameConflicts(this.diagnosticAcceptor);
+    }
+    this.overrideChecker.checkMembers(entity.getMembers());
+    new TypeMemberConflictsValidator(this.analyzer, entity.getMembers(), this.diagnosticAcceptor).validate();
+    const semanticContext = this.analyzer.semanticContext.outermostSemanticContextOfTypeDeclaration(node);
+    new BaseMemberConflictsValidator(
+      this.analyzer,
+      entity,
+      semanticContext.getDiagnosticArgumentFactory(),
+      this.diagnosticAcceptor,
+      node.name
+    ).validate();
+  }
+  checkPackageEntryPointDeclaration(node) {
+    if (this.isInterfacePackageFile) {
+      this.createAndAddDiagnostic(2060 /* InterfacePackageMustNotContainImplementation */, node.runKeyword);
+    }
+  }
+  checkPackageConstructorDeclaration(node) {
+    if (this.isInterfacePackageFile) {
+      this.createAndAddDiagnostic(2060 /* InterfacePackageMustNotContainImplementation */, node);
+    }
+  }
+  checkTranslationsDeclaration(node, controller) {
+    if (this.sourceFile.package.kind === "program") {
+      this.createAndAddDiagnostic(
+        2051 /* TranslationsCanOnlyBeDeclaredInTranslationPackage */,
+        node.translationsKeyword
+      );
+      controller.skipChildrenTraverse();
+    } else if (this.sourceFile.package.kind === "translation") {
+      if (this.resolvedTranslationPackage === void 0) {
+        this.createAndAddDiagnostic(
+          2052 /* UnknownTranslatingPackage0 */,
+          node.translationsKeyword,
+          [this.sourceFile.package.configuration.targetPackageName.toString()]
+        );
+        controller.skipChildrenTraverse();
+      }
+    } else if (this.sourceFile.package.kind === "text-translation") {
+      const textTranslationPackage = this.textTranslationPackage;
+      const targetPackage = textTranslationPackage?.getTargetPackage();
+      if (targetPackage === void 0 || textTranslationPackage === void 0) {
+        this.createAndAddDiagnostic(
+          2052 /* UnknownTranslatingPackage0 */,
+          node.translationsKeyword,
+          [this.sourceFile.package.configuration.targetPackageName.toString()]
+        );
+        controller.skipChildrenTraverse();
+      } else {
+        if (textTranslationPackage.isPrimary()) {
+          const packages = this.analyzer.getTextTranslationPackagesOfTargetPackage(targetPackage);
+          if (packages !== void 0 && packages.some((p) => p.isPrimary() && p !== textTranslationPackage)) {
+            this.createAndAddDiagnostic(
+              2196 /* OnlyOneTextTranslationPackageShouldBeMarkedAsPrimary */,
+              node.translationsKeyword,
+              []
+            );
+          }
+        }
+        if (this.sourceFile.package.sourceFiles[0] === this.sourceFile) {
+          this.addNotTranslatedTextsDiagnostics(textTranslationPackage, node.translationsKeyword);
+        }
       }
     }
-    return void 0;
   }
-  checkBinaryExpression(node) {
-    const classificationResult = this.analyzer.classifyBinaryExpressionOperator(node.operator);
-    switch (classificationResult.kind) {
-      case "user-definable":
-        this.analyzer.resolveBinaryExpressionUserDefinableOperator(node, classificationResult.operatorKind);
-        break;
-      case "equals":
-      case "not-equals": {
-        const leftType = this.analyzer.type.ofExpression(node.left);
-        const rightType = this.analyzer.type.ofExpression(node.right);
-        if (!this.analyzer.expressionsOfTypesCanBeCompared(leftType, rightType)) {
-          this.createAndAddDiagnostic(
-            2233 /* ExpressionsWithTypes0And1CannotBeCompared */,
-            node.operator,
-            [
-              this.diagnosticArgumentFactory.createDisplayableType(leftType),
-              this.diagnosticArgumentFactory.createDisplayableType(rightType)
-            ]
-          );
+  addNotTranslatedTextsDiagnostics(translationPackage, diagnosticLocation) {
+    const notTranslatedEntities = this.collectNotTranslatedTexts(translationPackage);
+    if (notTranslatedEntities.length > 0) {
+      const diagnostic = this.createNotTranslatedTextsDiagnostic(notTranslatedEntities, diagnosticLocation);
+      this.addDiagnostic(diagnostic);
+    }
+  }
+  collectNotTranslatedTexts(translationPackage) {
+    return [];
+  }
+  createNotTranslatedTextsDiagnostic(entities, diagnosticLocation) {
+    const maxDisplayedEntitiesCount = 10;
+    let result;
+    if (entities.length <= maxDisplayedEntitiesCount) {
+      const displayableEntities = entities.map((e) => this.diagnosticArgumentFactory.createDisplayableEntity(e));
+      result = this.analyzer.createDiagnostic(
+        2095 /* TheFollowingTextsAreNotTranslated0 */,
+        diagnosticLocation,
+        [new DisplayableArray(displayableEntities, "\n\n")],
+        1 /* Warning */
+      );
+    } else {
+      const displayableEntities = entities.slice(0, maxDisplayedEntitiesCount + 1).map((e) => this.diagnosticArgumentFactory.createDisplayableEntity(e));
+      result = this.analyzer.createDiagnostic(
+        2096 /* TheFollowingTextsAreNotTranslated0And1More */,
+        diagnosticLocation,
+        [new DisplayableArray(displayableEntities, "\n\n"), entities.length - maxDisplayedEntitiesCount],
+        1 /* Warning */
+      );
+    }
+    return result;
+  }
+  checkTextTranslationDeclaration(node) {
+    const sourceText = node.sourceText;
+    if (sourceText.kind === 141 /* TranslationTextTemplate */) {
+      const semanticContext = this.analyzer.semanticContext.ofTextTranslationDeclarationParameters(sourceText);
+      semanticContext.validateNameConflicts(this.diagnosticAcceptor);
+    }
+    const pkg2 = this.textTranslationPackage;
+    if (pkg2 !== void 0 && !pkg2.isPrimary()) {
+      const targetPackage = pkg2.getTargetPackage();
+      if (targetPackage !== void 0) {
+        const primaryPkg = this.analyzer.getPrimaryTextTranslationPackageOfTargetPackage(targetPackage);
+        if (primaryPkg !== void 0) {
+          const textKey = TextIdentity.keyFromTextTranslationSource(sourceText);
+          const textTranslation = primaryPkg.getMembers().getTextTranslationsByTextKey(textKey);
+          if (textTranslation.length === 0) {
+            this.createAndAddDiagnostic(
+              2190 /* TextIsMissingAmongPrimaryTextTranslationDefinitions */,
+              sourceText,
+              void 0,
+              1 /* Warning */
+            );
+          }
         }
-        break;
       }
-      case "question-question":
-        break;
-      default:
-        Debug.never(classificationResult);
+    }
+    if (node.kind === 139 /* TextTranslationFunctionDeclaration */) {
+      this.checkAllCodePathsReturnOrResultVariableIsAssigned(
+        node,
+        node.sourceText,
+        this.analyzer.returnType.ofTextTranslationFunctionDeclaration(node),
+        this.analyzer.resultLocalVariableEntity.ofTextTranslationFunctionDeclaration(node)
+      );
     }
   }
   checkPackageVariantDeclaration(node) {
@@ -61213,6 +61146,9 @@ var SourceFileAnalyzer = class {
       this.analyzer.semanticContext.ofTypeDeclarationTypeParameters(node, node.typeParameterClause).validateNameConflicts(this.diagnosticAcceptor);
     }
     const entity = this.analyzer.entity.ofPackageVariantDeclaration(node);
+    if (node.extendsClause !== void 0) {
+      this.checkAspectsHaveNotBeenExtendedWithDifferentTypeArguments(entity, node.extendsClause.baseTypeList, node.name);
+    }
     this.overrideChecker.checkMembers(entity.getMembers());
     new TypeMemberConflictsValidator(this.analyzer, entity.getMembers(), this.diagnosticAcceptor).validate();
     const semanticContext = this.analyzer.semanticContext.outermostSemanticContextOfTypeDeclaration(node);
@@ -61237,105 +61173,6 @@ var SourceFileAnalyzer = class {
       }
     }
   }
-  checkTypeMemberDeclarationBlock(node) {
-    const parent = node.parent;
-    if (isTypeDeclaration(parent)) {
-      switch (parent.kind) {
-        case 27 /* PackageClassDeclaration */: {
-          const entity = this.analyzer.entity.ofPackageStructuredTypeDeclaration(parent);
-          this.modifierValidator.validateTopLevelTypeMembers(
-            node.memberList,
-            0 /* Class */,
-            entity.isAbstract(),
-            entity.markedBasic()
-          );
-          break;
-        }
-        case 28 /* PackageStructureDeclaration */: {
-          const entity = this.analyzer.entity.ofPackageStructuredTypeDeclaration(parent);
-          this.modifierValidator.validateTopLevelTypeMembers(
-            node.memberList,
-            1 /* Structure */,
-            entity.isAbstract(),
-            entity.markedBasic()
-          );
-          break;
-        }
-        case 29 /* PackageAspectDeclaration */: {
-          const entity = this.analyzer.entity.ofPackageStructuredTypeDeclaration(parent);
-          this.modifierValidator.validateTopLevelTypeMembers(
-            node.memberList,
-            2 /* Aspect */,
-            entity.isAbstract(),
-            entity.markedBasic()
-          );
-          break;
-        }
-        case 18 /* AnonymousClassDeclaration */: {
-          const entity = this.analyzer.entity.ofAnonymousStructuredTypeDeclaration(parent);
-          this.modifierValidator.validateTopLevelTypeMembers(
-            node.memberList,
-            2 /* Aspect */,
-            entity.isAbstract(),
-            entity.markedBasic()
-          );
-          break;
-        }
-        case 30 /* PackageReducedTypeDeclaration */: {
-          this.modifierValidator.validateTopLevelTypeMembers(
-            node.memberList,
-            5 /* ReducedType */,
-            false,
-            false
-          );
-          break;
-        }
-        case 31 /* PackageVariantDeclaration */: {
-          this.modifierValidator.validateTopLevelTypeMembers(
-            node.memberList,
-            3 /* Variant */,
-            false,
-            false
-          );
-          break;
-        }
-        case 19 /* PackageAliasTypeDeclaration */: {
-          this.modifierValidator.validateTopLevelTypeMembers(
-            node.memberList,
-            4 /* AliasType */,
-            false,
-            false
-          );
-          break;
-        }
-        default:
-          Debug.never(parent);
-      }
-    }
-  }
-  checkAssumptionExpression(node) {
-    const parent = node.getParentSkippingParenthesizedExpressions();
-    switch (parent.kind) {
-      case 73 /* MemberAccessExpression */:
-      case 65 /* CallExpression */:
-      case 67 /* IndexedAccessExpression */:
-      case 75 /* DereferenceExpression */:
-        break;
-      default:
-        this.createAndAddDiagnostic(
-          2225 /* QuestionOperatorCanBeUsedOnlyInSpecificExpressions */,
-          node.questionToken
-        );
-    }
-  }
-  checkStatementBlock(node) {
-    const semanticContext = this.analyzer.semanticContext.ofStatementBlock(node);
-    semanticContext.validateNameConflicts(this.diagnosticAcceptor);
-  }
-  checkFunctionBlock(node) {
-    const semanticContext = this.analyzer.semanticContext.ofFunctionBlock(node);
-    semanticContext.validateNameConflicts(this.diagnosticAcceptor);
-  }
   checkPackageStructuredTypeDeclaration(node, controller) {
     return __async(this, null, function* () {
       const entity = this.analyzer.entity.ofPackageStructuredTypeDeclaration(node);
@@ -61346,6 +61183,9 @@ var SourceFileAnalyzer = class {
       if (node.typeParameterClause !== void 0) {
         this.analyzer.semanticContext.ofTypeDeclarationTypeParameters(node, node.typeParameterClause).validateNameConflicts(this.diagnosticAcceptor);
       }
+      if (node.extendsClause !== void 0) {
+        this.checkAspectsHaveNotBeenExtendedWithDifferentTypeArguments(entity, node.extendsClause.baseTypeList, node.name);
+      }
       this.overrideChecker.checkMembers(entity.getMembers());
       new TypeMemberConflictsValidator(this.analyzer, entity.getMembers(), this.diagnosticAcceptor).validate();
       const semanticContext = this.analyzer.semanticContext.outermostSemanticContextOfTypeDeclaration(node);
@@ -61585,6 +61425,805 @@ var SourceFileAnalyzer = class {
       return result;
     });
   }
+  checkAspectsHaveNotBeenExtendedWithDifferentTypeArguments(entity, baseTypeList, fallbackDiagnosticLocation) {
+    const type = this.analyzer.instantiateTypeByIdentitySubstitution(entity);
+    const baseAspectTypes = this.analyzer.typeUtils.getPossiblyAliasedBaseAspectTypes(type);
+    if (baseAspectTypes !== void 0 && baseAspectTypes.length > 0) {
+      let allBaseTypes;
+      for (const baseAspectType of baseAspectTypes) {
+        const unaliasedBaseAspectType = baseAspectType.unalias();
+        if (unaliasedBaseAspectType.kind === "structured" && unaliasedBaseAspectType.getTypeParameters().length === 0) {
+          continue;
+        }
+        allBaseTypes ??= this.analyzer.typeUtils.getBaseAndAliasedTypesRecursively(type);
+        const extendedAspect = allBaseTypes.find((t) => t.kind === "structured" && t.getEntity().getOriginalEntity() === unaliasedBaseAspectType.getEntity()?.getOriginalEntity() && !t.getSubstitutions().equals(unaliasedBaseAspectType.getSubstitutions()));
+        if (extendedAspect !== void 0) {
+          const diagnosticLocation = baseTypeList.baseTypes.first((n) => this.analyzer.type.ofTypeSpecifier(n).equals(baseAspectType)) ?? fallbackDiagnosticLocation;
+          this.createAndAddDiagnostic(
+            2246 /* AspectHasAlreadyBeenExtendedWithDifferentTypeArguments0 */,
+            diagnosticLocation,
+            [this.diagnosticArgumentFactory.createDisplayableType(extendedAspect)]
+          );
+        }
+      }
+    }
+  }
+  checkPackageVariableDeclaration(node) {
+    const entity = this.analyzer.entity.ofPackageVariableDeclaration(node);
+    entity.ensureAllDiagnosticsReported?.();
+    if (this.isInterfacePackageFile) {
+      if (node.initializer !== void 0) {
+        this.createAndAddDiagnostic(2061 /* InterfacePackageVariablesMustNotHaveInitializers */, node.name);
+      }
+    }
+    if (node.typeAnnotation === void 0 && node.initializer === void 0) {
+      this.createAndAddDiagnostic(2184 /* VariableTypeIsNotSpecified */, node.name);
+    } else if (node.initializer !== void 0 && node.typeAnnotation !== void 0) {
+      this.checkExpressionTypeIsAssignableToTargetType(
+        node.initializer,
+        this.analyzer.type.ofTypeSpecifier(node.typeAnnotation.typeSpecifier)
+      );
+    }
+  }
+  checkPackageFunctionDeclaration(node) {
+    const entity = this.analyzer.entity.ofPackageFunctionDeclaration(node);
+    this.checkPackageMemberBodyPresence(entity, node.block, node.name);
+    if (node.block !== void 0) {
+      this.checkPossibleGeneratorFunctionReturnType(entity, node, node.name);
+    }
+    if (node.typeParameterClause !== void 0) {
+      this.analyzer.semanticContext.ofFunctionDeclarationTypeParameters(node, node.typeParameterClause).validateNameConflicts(this.diagnosticAcceptor);
+    }
+    this.analyzer.semanticContext.ofFunctionDeclarationParameters(node).validateNameConflicts(this.diagnosticAcceptor);
+    if (!this.analyzer.isFunctionGenerator(node)) {
+      this.checkAllCodePathsReturnOrResultVariableIsAssigned(
+        node,
+        node.name,
+        this.analyzer.returnType.ofPackageFunctionDeclaration(node),
+        this.analyzer.resultLocalVariableEntity.ofPackageFunctionDeclaration(node)
+      );
+    }
+  }
+  checkPackageVariableGetterDeclaration(node) {
+    const entity = this.analyzer.entity.ofComputedPackageVariableDeclaration(node);
+    entity.ensureAllDiagnosticsReported?.();
+    this.checkPackageMemberBodyPresence(entity, node.block, node.name);
+    this.checkAllCodePathsReturnOrResultVariableIsAssigned(
+      node,
+      node.name,
+      this.analyzer.returnType.ofPackageVariableGetterDeclaration(node),
+      this.analyzer.resultLocalVariableEntity.ofPackageVariableGetterDeclaration(node)
+    );
+  }
+  checkPackageVariableSetterDeclaration(node) {
+    const entity = this.analyzer.entity.ofComputedPackageVariableDeclaration(node);
+    this.checkPackageMemberBodyPresence(entity, node.block, node.name);
+  }
+  checkPackageMemberBodyPresence(entity, body, diagnosticLocation) {
+    if (this.isInterfacePackageFile) {
+      if (body !== void 0) {
+        this.createAndAddDiagnostic(2060 /* InterfacePackageMustNotContainImplementation */, diagnosticLocation);
+      }
+    } else if (findTag(this.analyzer.originalWellKnownDeclarations.builtIntoPlatform, entity.getTags()) !== void 0) {
+      if (body !== void 0) {
+        this.createAndAddDiagnostic(
+          2066 /* DeclarationsMarkedWithBuiltIntoPlatformTagMustNotHaveBody */,
+          diagnosticLocation
+        );
+      }
+    } else {
+      if (body === void 0) {
+        this.createAndAddDiagnostic(2062 /* BodyIsMissing */, diagnosticLocation);
+      }
+    }
+  }
+  checkTypeExtensionDeclaration(node) {
+    const entity = this.analyzer.entity.ofTypeExtensionDeclaration(node);
+    entity.ensureAllDiagnosticsReported?.();
+    this.modifierValidator.validateTopLevelTypeMembers(
+      node.memberBlock.memberList,
+      6 /* TypeExtension */,
+      false,
+      false
+    );
+    this.overrideChecker.checkMembers(entity.getMembers());
+    new TypeMemberConflictsValidator(this.analyzer, entity.getMembers(), this.diagnosticAcceptor).validate();
+  }
+  checkTypeMemberDeclarationBlock(node) {
+    const parent = node.parent;
+    if (isTypeDeclaration(parent)) {
+      switch (parent.kind) {
+        case 27 /* PackageClassDeclaration */: {
+          const entity = this.analyzer.entity.ofPackageStructuredTypeDeclaration(parent);
+          this.modifierValidator.validateTopLevelTypeMembers(
+            node.memberList,
+            0 /* Class */,
+            entity.isAbstract(),
+            entity.markedBasic()
+          );
+          break;
+        }
+        case 28 /* PackageStructureDeclaration */: {
+          const entity = this.analyzer.entity.ofPackageStructuredTypeDeclaration(parent);
+          this.modifierValidator.validateTopLevelTypeMembers(
+            node.memberList,
+            1 /* Structure */,
+            entity.isAbstract(),
+            entity.markedBasic()
+          );
+          break;
+        }
+        case 29 /* PackageAspectDeclaration */: {
+          const entity = this.analyzer.entity.ofPackageStructuredTypeDeclaration(parent);
+          this.modifierValidator.validateTopLevelTypeMembers(
+            node.memberList,
+            2 /* Aspect */,
+            entity.isAbstract(),
+            entity.markedBasic()
+          );
+          break;
+        }
+        case 18 /* AnonymousClassDeclaration */: {
+          const entity = this.analyzer.entity.ofAnonymousStructuredTypeDeclaration(parent);
+          this.modifierValidator.validateTopLevelTypeMembers(
+            node.memberList,
+            2 /* Aspect */,
+            entity.isAbstract(),
+            entity.markedBasic()
+          );
+          break;
+        }
+        case 30 /* PackageReducedTypeDeclaration */: {
+          this.modifierValidator.validateTopLevelTypeMembers(
+            node.memberList,
+            5 /* ReducedType */,
+            false,
+            false
+          );
+          break;
+        }
+        case 31 /* PackageVariantDeclaration */: {
+          this.modifierValidator.validateTopLevelTypeMembers(
+            node.memberList,
+            3 /* Variant */,
+            false,
+            false
+          );
+          break;
+        }
+        case 19 /* PackageAliasTypeDeclaration */: {
+          this.modifierValidator.validateTopLevelTypeMembers(
+            node.memberList,
+            4 /* AliasType */,
+            false,
+            false
+          );
+          break;
+        }
+        default:
+          Debug.never(parent);
+      }
+    }
+  }
+  checkConstructorDeclaration(node) {
+    const entity = this.analyzer.entity.ofConstructorDeclaration(node);
+    entity.ensureAllDiagnosticsReported?.();
+    this.checkTypeMemberBodyPresence(entity, node.block, node.creationKeyword);
+    this.analyzer.semanticContext.ofConstructorDeclarationParameters(node).validateNameConflicts(this.diagnosticAcceptor);
+  }
+  checkDestructorDeclaration(node) {
+    const entity = this.analyzer.entity.ofDestructorDeclaration(node);
+    entity.ensureAllDiagnosticsReported?.();
+    this.checkTypeMemberBodyPresence(entity, node.block, node.destructionKeyword);
+    this.analyzer.semanticContext.ofDestructorDeclarationParameters(node).validateNameConflicts(this.diagnosticAcceptor);
+  }
+  checkMethodDeclaration(node) {
+    const entity = this.analyzer.entity.ofMethodDeclaration(node);
+    entity.ensureAllDiagnosticsReported?.();
+    this.checkTypeMemberBodyPresence(entity, node.block, node.name);
+    if (node.block !== void 0) {
+      this.checkPossibleGeneratorFunctionReturnType(entity, node, node.name);
+      const containingEntity = entity.getContainingEntity();
+      if (entity.markedBasic() && containingEntity.kind === 2 /* Type */ && containingEntity.typeEntityKind === 4 /* Alias */) {
+        this.analyzer.checkBodyOfBasicAliasTypeMethod(node, this.diagnosticAcceptor);
+      }
+    }
+    if (entity.methodKind === 3 /* Operator */) {
+      if (node.typeParameterClause !== void 0) {
+        this.createAndAddDiagnostic(
+          2231 /* OperatorCannotContainTypeParameterDeclarations */,
+          node.typeParameterClause
+        );
+      }
+      const syntacticalOperatorKind = node.name.operatorKind;
+      if (syntacticalOperatorKind !== void 0) {
+        const requiredParameterCount = requiredParameterCountBySyntacticalOperatorKind[syntacticalOperatorKind];
+        const actualParameterCount = node.parameterClause.parameterList.parameters.count();
+        switch (requiredParameterCount) {
+          case 0 /* Zero */: {
+            if (actualParameterCount !== 0) {
+              const operatorText = LocalizationHelperA.localizeSyntacticalOperatorKind(
+                syntacticalOperatorKind,
+                this.sourceFile.locale
+              );
+              this.createAndAddDiagnostic(
+                2097 /* OperatorFunction0MustNotHaveParameters */,
+                node.name,
+                [operatorText]
+              );
+            }
+            break;
+          }
+          case 1 /* ZeroOrOne */: {
+            if (!(actualParameterCount === 0 || actualParameterCount === 1)) {
+              const operatorText = LocalizationHelperA.localizeSyntacticalOperatorKind(
+                syntacticalOperatorKind,
+                this.sourceFile.locale
+              );
+              this.createAndAddDiagnostic(
+                2099 /* OperatorFunction0MustHaveNoMoreThanOneParameter */,
+                node.name,
+                [operatorText]
+              );
+            }
+            break;
+          }
+          case 2 /* One */: {
+            if (actualParameterCount !== 1) {
+              const operatorText = LocalizationHelperA.localizeSyntacticalOperatorKind(
+                syntacticalOperatorKind,
+                this.sourceFile.locale
+              );
+              this.createAndAddDiagnostic(
+                2098 /* OperatorFunction0MustHaveOneParameter */,
+                node.name,
+                [operatorText]
+              );
+            }
+            break;
+          }
+          default:
+            Debug.never(requiredParameterCount);
+        }
+      }
+    }
+    if (node.typeParameterClause !== void 0) {
+      this.analyzer.semanticContext.ofFunctionDeclarationTypeParameters(node, node.typeParameterClause).validateNameConflicts(this.diagnosticAcceptor);
+    }
+    this.analyzer.semanticContext.ofFunctionDeclarationParameters(node).validateNameConflicts(this.diagnosticAcceptor);
+    if (!this.analyzer.isFunctionGenerator(node)) {
+      this.checkAllCodePathsReturnOrResultVariableIsAssigned(
+        node,
+        node.name,
+        this.analyzer.returnType.ofMethodDeclaration(node),
+        this.analyzer.resultLocalVariableEntity.ofMethodDeclaration(node)
+      );
+    }
+  }
+  checkFieldDeclaration(node) {
+    const entity = this.analyzer.entity.ofFieldDeclaration(node);
+    entity.ensureAllDiagnosticsReported?.();
+    if (TypeMemberEntity.isAspectMember(entity) && !entity.isStatic() && !entity.markedAbstract()) {
+      this.createAndAddDiagnostic(2065 /* AspectTypeFieldsMustBeAbstract */, node.name);
+    }
+    if (this.isInterfacePackageFile) {
+      if (node.initializer !== void 0) {
+        this.createAndAddDiagnostic(2061 /* InterfacePackageVariablesMustNotHaveInitializers */, node.name);
+      }
+    } else if (TypeMemberEntity.isReducedTypeMember(entity)) {
+      if (node.initializer !== void 0) {
+        this.createAndAddDiagnostic(2069 /* ReducedTypeFieldsMustNotHaveInitializers */, node.name);
+      }
+    } else if (entity.markedAbstract()) {
+      if (node.initializer !== void 0) {
+        this.createAndAddDiagnostic(2068 /* AbstractFieldsMustNotHaveInitializers */, node.name);
+      }
+    }
+    if (node.typeAnnotation === void 0 && node.initializer === void 0) {
+      this.createAndAddDiagnostic(2184 /* VariableTypeIsNotSpecified */, node.name);
+    } else if (node.initializer !== void 0 && node.typeAnnotation !== void 0) {
+      this.checkExpressionTypeIsAssignableToTargetType(
+        node.initializer,
+        this.analyzer.type.ofTypeSpecifier(node.typeAnnotation.typeSpecifier)
+      );
+    }
+  }
+  checkFieldGetterDeclaration(node) {
+    const entity = this.analyzer.entity.ofComputedFieldDeclaration(node);
+    entity.ensureAllDiagnosticsReported?.();
+    this.checkTypeMemberBodyPresence(entity, node.block, node.name);
+    this.checkAllCodePathsReturnOrResultVariableIsAssigned(
+      node,
+      node.name,
+      this.analyzer.returnType.ofFieldGetterDeclaration(node),
+      this.analyzer.resultLocalVariableEntity.ofFieldGetterDeclaration(node)
+    );
+  }
+  checkFieldSetterDeclaration(node) {
+    const entity = this.analyzer.entity.ofComputedFieldDeclaration(node);
+    entity.ensureAllDiagnosticsReported?.();
+    this.checkTypeMemberBodyPresence(entity, node.block, node.name);
+  }
+  checkIndexedElementGetterDeclaration(node) {
+    const entity = this.analyzer.entity.ofIndexerDeclaration(node);
+    entity.ensureAllDiagnosticsReported?.();
+    this.checkTypeMemberBodyPresence(entity, node.block, node.parameterClause);
+    this.analyzer.semanticContext.ofIndexedElementAccessorDeclarationParameters(node).validateNameConflicts(this.diagnosticAcceptor);
+    this.checkAllCodePathsReturnOrResultVariableIsAssigned(
+      node,
+      node.parameterClause,
+      this.analyzer.returnType.ofIndexedElementGetterDeclaration(node),
+      this.analyzer.resultLocalVariableEntity.ofIndexedElementGetterDeclaration(node)
+    );
+  }
+  checkIndexedElementSetterDeclaration(node) {
+    const entity = this.analyzer.entity.ofIndexerDeclaration(node);
+    entity.ensureAllDiagnosticsReported?.();
+    this.checkTypeMemberBodyPresence(entity, node.block, node.parameterClause);
+    this.analyzer.semanticContext.ofIndexedElementAccessorDeclarationParameters(node).validateNameConflicts(this.diagnosticAcceptor);
+  }
+  checkDereferencedVariableGetterDeclaration(node) {
+    const entity = this.analyzer.entity.ofDereferenceOperatorDeclaration(node);
+    entity.ensureAllDiagnosticsReported?.();
+    this.checkTypeMemberBodyPresence(entity, node.block, node.caretToken);
+    this.checkAllCodePathsReturnOrResultVariableIsAssigned(
+      node,
+      node.caretToken,
+      this.analyzer.returnType.ofDereferencedVariableGetterDeclaration(node),
+      this.analyzer.resultLocalVariableEntity.ofDereferencedVariableGetterDeclaration(node)
+    );
+  }
+  checkDereferencedVariableSetterDeclaration(node) {
+    const entity = this.analyzer.entity.ofDereferenceOperatorDeclaration(node);
+    entity.ensureAllDiagnosticsReported?.();
+    this.checkTypeMemberBodyPresence(entity, node.block, node.caretToken);
+  }
+  checkTypeMemberBodyPresence(entity, body, diagnosticLocation) {
+    if (this.isInterfacePackageFile) {
+      if (body !== void 0) {
+        this.createAndAddDiagnostic(2060 /* InterfacePackageMustNotContainImplementation */, diagnosticLocation);
+      }
+    } else if (findTag(this.analyzer.originalWellKnownDeclarations.builtIntoPlatform, entity.getTags()) !== void 0) {
+      if (body !== void 0) {
+        this.createAndAddDiagnostic(
+          2066 /* DeclarationsMarkedWithBuiltIntoPlatformTagMustNotHaveBody */,
+          diagnosticLocation
+        );
+      }
+    } else if (TypeMemberEntity.isReducedTypeMember(entity)) {
+      if (body !== void 0) {
+        this.createAndAddDiagnostic(
+          2067 /* ReducedTypeMembersMustNotHaveBody */,
+          diagnosticLocation
+        );
+      }
+    } else if (entity.isStatic()) {
+      if (body === void 0) {
+        this.createAndAddDiagnostic(2062 /* BodyIsMissing */, diagnosticLocation);
+      }
+    } else if (entity.markedAbstract()) {
+      if (body !== void 0) {
+        this.createAndAddDiagnostic(
+          2063 /* AbstractTypeMembersMustNotHaveBody */,
+          diagnosticLocation
+        );
+      }
+    } else {
+      if (body === void 0) {
+        this.createAndAddDiagnostic(2062 /* BodyIsMissing */, diagnosticLocation);
+      }
+    }
+  }
+  checkTypeParameterList(node) {
+    const typeParameterDeclarations = node.typeParameters.toArray();
+    if (typeParameterDeclarations.some((d) => d.defaultType !== void 0)) {
+      const notYetDeclaredParameters = /* @__PURE__ */ new Set();
+      for (const typeParameterDeclaration of typeParameterDeclarations) {
+        notYetDeclaredParameters.add(this.analyzer.entity.ofTypeParameterDeclaration(typeParameterDeclaration));
+      }
+      const visitor = (node2) => {
+        if (node2.kind === 26 /* TypeMemberDeclarationBlock */) {
+          return;
+        }
+        if (node2.kind === 10 /* NamedTypeSpecifier */) {
+          const type = this.analyzer.resolveNamedTypeSpecifier(node2).type;
+          if (type?.kind === "parameter" && notYetDeclaredParameters.has(type.getEntity().getOriginalEntity())) {
+            this.createAndAddDiagnostic(
+              2186 /* TypeParameterDefaultCanReferenceOnlyPreviouslyDeclaredTypeParameters */,
+              node2
+            );
+          }
+        }
+        forEachChild(node2, false, visitor);
+      };
+      for (const typeParameterDeclaration of typeParameterDeclarations) {
+        if (typeParameterDeclaration.defaultType !== void 0) {
+          visitor(typeParameterDeclaration.defaultType);
+        }
+        notYetDeclaredParameters.delete(this.analyzer.entity.ofTypeParameterDeclaration(typeParameterDeclaration));
+      }
+    }
+    let seenOptionalTypeParameter = false;
+    for (const typeParameterDeclaration of typeParameterDeclarations) {
+      if (typeParameterDeclaration.defaultType !== void 0) {
+        seenOptionalTypeParameter = true;
+      } else if (seenOptionalTypeParameter) {
+        this.createAndAddDiagnostic(
+          2187 /* RequiredTypeParametersCannotFollowTypeParametersWithDefaults */,
+          typeParameterDeclaration
+        );
+        break;
+      }
+    }
+  }
+  checkTypeParameterDeclaration(node) {
+    const entity = this.analyzer.entity.ofTypeParameterDeclaration(node);
+    const constraint = entity.getConstraint();
+    if (constraint.causesCycle) {
+      this.createAndAddDiagnostic(2082 /* TypeParameterHasCircularConstraint */, node.name);
+    }
+    if (constraint.cycleFree !== void 0) {
+      const defaultType = entity.getDefaultType();
+      if (defaultType !== void 0 && !this.analyzer.isTypeAssignableTo(defaultType, constraint.cycleFree)) {
+        this.addTypeAssignabilityDiagnosticIfBothTypesResolved(
+          defaultType,
+          constraint.cycleFree,
+          node.defaultType ?? node,
+          2087 /* Type0IsNotAssignableToConstraint1 */
+        );
+      }
+    }
+    this.checkIfTypeParameterIsUnused(entity, node.name);
+  }
+  checkNamedTypeSpecifier(node) {
+    const resolutionResult = this.analyzer.resolveNamedTypeSpecifier(node);
+    if (resolutionResult.type !== void 0) {
+      const entity = resolutionResult.type.getEntity();
+      if (entity !== void 0) {
+        const typeArgumentCount = node.typeArgumentClause?.typeArgumentList.typeArguments.count() ?? 0;
+        this.analyzer.checkTypeArgumentCount(
+          typeArgumentCount,
+          entity.getTypeParameters(),
+          this.diagnosticAcceptor,
+          node.typeArgumentClause ?? node.qualifiedName
+        );
+        const substitutions = resolutionResult.type.getSubstitutions();
+        this.checkTypeArgumentTypesAreAssignableToConstraints(
+          entity.getTypeParameters(),
+          substitutions,
+          void 0,
+          node.typeArgumentClause ?? node
+        );
+      }
+    }
+  }
+  checkAnonymousClassDeclaration(node) {
+    const entity = this.analyzer.entity.ofAnonymousStructuredTypeDeclaration(node);
+    if (node.extendsClause !== void 0) {
+      this.checkAspectsHaveNotBeenExtendedWithDifferentTypeArguments(
+        entity,
+        node.extendsClause.baseTypeList,
+        node.classKeyword
+      );
+    }
+    this.overrideChecker.checkMembers(entity.getMembers());
+    new TypeMemberConflictsValidator(this.analyzer, entity.getMembers(), this.diagnosticAcceptor).validate();
+    const semanticContext = this.analyzer.semanticContext.outermostSemanticContextOfTypeDeclaration(node);
+    new BaseMemberConflictsValidator(
+      this.analyzer,
+      entity,
+      semanticContext.getDiagnosticArgumentFactory(),
+      this.diagnosticAcceptor,
+      node.classKeyword
+    ).validate();
+    const typeMemberImplementationCheckResult = this.analyzer.getTypeMemberImplementationCheckResult(entity);
+    this.attachNodeLocationAndAddDiagnostics(
+      typeMemberImplementationCheckResult.diagnosticsData,
+      node.classKeyword
+    );
+    if (!this.isInterfacePackageFile) {
+      this.addDiagnostics(this.analyzer.getOwnAndBaseConstructorCallsCheckResult(node).diagnostics);
+      new InstanceFieldsInitializationValidator(
+        this.analyzer,
+        node,
+        this.namedDeclarationsUsageMap,
+        this.diagnosticAcceptor
+      ).validate();
+    }
+  }
+  checkAnonymousFunctionTypeDeclaration(node) {
+    this.analyzer.semanticContext.ofFunctionTypeDeclarationParameters(node).validateNameConflicts(this.diagnosticAcceptor);
+  }
+  checkParameterList(node) {
+    const parameters = node.parameters.toArray();
+    if (parameters.length > 0) {
+      this.checkRequiredParametersDoNotFollowOptionalParameters(parameters);
+      const firstParameter = parameters[0];
+      const firstParameterEntity = this.analyzer.entity.ofParameterDeclaration(firstParameter);
+      if (firstParameterEntity.isObjectParameter() && !this.parameterListCanDeclareObjectParameter(node)) {
+        this.createAndAddDiagnostic(2228 /* ObjectParameterCannotBeDeclaredHere */, firstParameter.name);
+      }
+      this.checkObjectParameterIsTheFirstParameter(parameters);
+    }
+  }
+  checkRequiredParametersDoNotFollowOptionalParameters(parameters) {
+    let seenOptionalParameter = false;
+    for (const parameter of parameters) {
+      if (parameter.defaultValue !== void 0) {
+        seenOptionalParameter = true;
+      } else if (seenOptionalParameter) {
+        this.createAndAddDiagnostic(2188 /* RequiredParametersCannotFollowOptionalParameters */, parameter.name);
+        break;
+      }
+    }
+  }
+  parameterListCanDeclareObjectParameter(node) {
+    const parent = node.parent.parent;
+    switch (parent.kind) {
+      case 17 /* AnonymousFunctionTypeDeclaration */:
+      case 23 /* PackageFunctionDeclaration */:
+      case 53 /* NestedFunctionDeclaration */:
+      case 62 /* FunctionLiteral */:
+        return true;
+      case 47 /* MethodDeclaration */: {
+        const containingDeclaration = TypeMemberQuery.getContainingDeclaration(parent);
+        switch (containingDeclaration.kind) {
+          case 18 /* AnonymousClassDeclaration */:
+          case 27 /* PackageClassDeclaration */:
+          case 28 /* PackageStructureDeclaration */:
+          case 29 /* PackageAspectDeclaration */:
+          case 30 /* PackageReducedTypeDeclaration */:
+          case 31 /* PackageVariantDeclaration */:
+            return true;
+          case 19 /* PackageAliasTypeDeclaration */:
+          case 35 /* TypeExtensionDeclaration */:
+            return false;
+          default:
+            Debug.never(containingDeclaration);
+        }
+      }
+      case 40 /* ConstructorDeclaration */:
+      case 41 /* DestructorDeclaration */:
+      case 42 /* IndexedElementGetterDeclaration */:
+      case 43 /* IndexedElementSetterDeclaration */:
+        return false;
+      default:
+        Debug.never(parent);
+    }
+  }
+  checkObjectParameterIsTheFirstParameter(parameters) {
+    for (let i = 1; i < parameters.length; i++) {
+      const parameterDeclaration2 = parameters[i];
+      if ((parameterDeclaration2.name.flags & 512 /* ObjectParameterName */) !== 0) {
+        this.createAndAddDiagnostic(2227 /* ObjectParameterMustBeTheFirstParameter */, parameterDeclaration2.name);
+        break;
+      }
+    }
+  }
+  checkParameterDeclaration(node) {
+    const entity = this.analyzer.entity.ofParameterDeclaration(node);
+    entity.ensureAllDiagnosticsReported?.();
+    const isFunctionLiteralParameter = node.parent.parent.parent.kind === 62 /* FunctionLiteral */;
+    if (!isFunctionLiteralParameter && node.typeAnnotation === void 0 && node.defaultValue === void 0) {
+      this.createAndAddDiagnostic(2184 /* VariableTypeIsNotSpecified */, node.name);
+    } else if (node.defaultValue !== void 0 && node.typeAnnotation !== void 0) {
+      this.checkExpressionTypeIsAssignableToTargetType(
+        node.defaultValue,
+        this.analyzer.type.ofTypeSpecifier(node.typeAnnotation.typeSpecifier)
+      );
+    } else if (isFunctionLiteralParameter && node.defaultValue !== void 0) {
+      this.checkExpressionTypeIsAssignableToTargetType(node.defaultValue, entity.getType());
+    }
+    let parentHasBody;
+    const parent = node.parent.parent.parent;
+    switch (parent.kind) {
+      case 23 /* PackageFunctionDeclaration */:
+      case 40 /* ConstructorDeclaration */:
+      case 41 /* DestructorDeclaration */:
+      case 42 /* IndexedElementGetterDeclaration */:
+      case 43 /* IndexedElementSetterDeclaration */:
+      case 47 /* MethodDeclaration */:
+      case 53 /* NestedFunctionDeclaration */:
+      case 62 /* FunctionLiteral */:
+        parentHasBody = parent.block !== void 0;
+        break;
+      case 17 /* AnonymousFunctionTypeDeclaration */:
+        parentHasBody = false;
+        break;
+      default:
+        Debug.never(parent);
+    }
+    if (parentHasBody) {
+      this.checkIfVariableIsUnused(entity, node.name);
+    }
+  }
+  checkOwnConstructorCallExpression(node) {
+    this.analyzer.resolveOwnConstructorCallExpression(node);
+  }
+  checkReferenceExpression(node) {
+    if (!this.analyzer.expressionCanBeReferenced(node.expression)) {
+      this.createAndAddDiagnostic(2189 /* ExpressionCannotBeReferenced */, node.expression);
+    }
+  }
+  checkMatchExpressionList(node) {
+    const matchedExpressionType = this.analyzer.type.ofExpression(node.parent.parent.parent.expression);
+    for (const expression of node.matchExpressions) {
+      this.checkExpressionTypeIsAssignableToTargetType(expression, matchedExpressionType);
+    }
+  }
+  checkWhileStatement(node) {
+    this.checkExpressionTypeIsAssignableToTargetType(node.condition, this.standardTypes.yesNo);
+  }
+  checkLoopStatement(node) {
+    if (node.condition !== void 0) {
+      this.checkExpressionTypeIsAssignableToTargetType(node.condition, this.standardTypes.yesNo);
+    }
+  }
+  checkElseIfClause(node) {
+    this.checkExpressionTypeIsAssignableToTargetType(node.condition, this.standardTypes.yesNo);
+  }
+  checkIfStatement(node) {
+    this.checkExpressionTypeIsAssignableToTargetType(node.condition, this.standardTypes.yesNo);
+  }
+  checkArgument(node) {
+    this.checkExpressionTypeIsAssignableToTargetType(
+      node.value,
+      this.analyzer.getTargetTypeOfExpression(node.value)
+    );
+  }
+  checkErrorVariableDeclaration(node) {
+    const entity = this.analyzer.entity.ofErrorVariableDeclaration(node);
+    entity.ensureAllDiagnosticsReported?.();
+    this.checkIfVariableIsUnused(entity, node.name);
+  }
+  checkForStatementVariableDeclaration(node) {
+    const entity = this.analyzer.entity.ofForStatementVariableDeclaration(node);
+    entity.ensureAllDiagnosticsReported?.();
+    this.checkIfVariableIsUnused(entity, node.name);
+  }
+  checkLocalVariableDeclaration(node) {
+    const entity = this.analyzer.entity.ofLocalVariableDeclaration(node);
+    entity.ensureAllDiagnosticsReported?.();
+    if (node.typeAnnotation === void 0 && node.initializer === void 0) {
+      this.createAndAddDiagnostic(2184 /* VariableTypeIsNotSpecified */, node.name);
+    } else if (node.initializer !== void 0 && node.typeAnnotation !== void 0) {
+      this.checkExpressionTypeIsAssignableToTargetType(
+        node.initializer,
+        this.analyzer.type.ofTypeSpecifier(node.typeAnnotation.typeSpecifier)
+      );
+    }
+    this.checkIfVariableIsUnused(entity, node.name);
+  }
+  checkBaseExpression(node) {
+    const meaning = this.analyzer.resolveBaseExpression(node);
+    if (meaning.kind === "base-object-access") {
+      let parent = node.getParentSkippingParenthesizedExpressions();
+      if (parent.kind === 60 /* AsExpression */) {
+        parent = parent.getParentSkippingParenthesizedExpressions();
+      }
+      if (!(parent.kind === 73 /* MemberAccessExpression */ || parent.kind === 67 /* IndexedAccessExpression */ || parent.kind === 75 /* DereferenceExpression */)) {
+        this.createAndAddDiagnostic(2059 /* BaseCannotBeUsedAsAnExpressionInItself */, node);
+      }
+    } else if (meaning.kind === "overridden-method-access" && meaning.method.kind === "substituted-function") {
+      const typeArgumentClause = getParentGenericSpecializationExpression(node)?.typeArgumentClause;
+      this.checkTypeArgumentTypesAreAssignableToConstraints(
+        meaning.method.getTypeParameters(),
+        meaning.method.value.getSubstitutions(),
+        meaning.method.value.getOuterSubstitutions(),
+        typeArgumentClause ?? node
+      );
+    }
+  }
+  checkObjectExpression(node) {
+    this.analyzer.resolveObjectExpression(node);
+  }
+  checkAssignmentStatement(node) {
+    if (this.checkAssignmentIsValid(node)) {
+      if (node.operator.tokenKind === 64 /* Equals */) {
+        this.checkExpressionTypeIsAssignableToTargetType(node.right, this.analyzer.type.ofExpression(node.left));
+      }
+    }
+    const operatorKind = this.analyzer.getBinaryOperatorKindIfCompoundAssignmentOperator(node.operator);
+    if (operatorKind !== void 0) {
+      const operator = this.analyzer.resolveCompoundAssignmentStatementOperator(node, operatorKind);
+      if (operator !== void 0) {
+        const returnType = operator.getReturnType();
+        const leftType = this.analyzer.type.ofExpression(node.left);
+        if (!this.analyzer.isTypeAssignableTo(returnType, leftType)) {
+          this.addTypeAssignabilityDiagnosticIfBothTypesResolved(
+            returnType,
+            leftType,
+            node.right,
+            2032 /* Type0IsNotAssignableToType1 */
+          );
+        }
+      }
+    }
+  }
+  checkPrefixUnaryExpression(node) {
+    this.analyzer.resolvePrefixUnaryExpressionUserDefinableOperator(node);
+  }
+  checkCatchClause(node) {
+    this.analyzer.semanticContext.ofCatchClause(node).validateNameConflicts(this.diagnosticAcceptor);
+  }
+  checkForStatement(node) {
+    const checkResult = this.analyzer.checkExpressionCanBeUsedInForLoop(node.enumeratedExpression);
+    if (checkResult.kind === "error") {
+      this.addDiagnostics(checkResult.value);
+    }
+    this.analyzer.semanticContext.ofForStatement(node).validateNameConflicts(this.diagnosticAcceptor);
+  }
+  checkLocalizableTextTemplateLiteral(node) {
+    const resolved = this.analyzer.resolveLocalizableTextOrTextTemplate(node);
+    if (resolved !== void 0) {
+      const spans = node.spanList.spans;
+      const parameters = resolved.getParameters();
+      if (spans.length === parameters.length) {
+        for (let i = 0; i < spans.length; i++) {
+          const argument2 = spans[i].expression;
+          const parameter = parameters[i];
+          this.checkExpressionTypeIsAssignableToTargetType(argument2, parameter.getType());
+        }
+      }
+    }
+  }
+  checkLocalizableTextLiteral(node) {
+    this.analyzer.resolveLocalizableTextOrTextTemplate(node);
+  }
+  checkAutotypeCallExpression(node) {
+    this.analyzer.resolveAutotypeCallExpression(node);
+  }
+  checkBinaryExpression(node) {
+    const classificationResult = this.analyzer.classifyBinaryExpressionOperator(node.operator);
+    switch (classificationResult.kind) {
+      case "user-definable":
+        this.analyzer.resolveBinaryExpressionUserDefinableOperator(node, classificationResult.operatorKind);
+        break;
+      case "equals":
+      case "not-equals": {
+        const leftType = this.analyzer.type.ofExpression(node.left);
+        const rightType = this.analyzer.type.ofExpression(node.right);
+        if (!this.analyzer.expressionsOfTypesCanBeCompared(leftType, rightType)) {
+          this.createAndAddDiagnostic(
+            2233 /* ExpressionsWithTypes0And1CannotBeCompared */,
+            node.operator,
+            [
+              this.diagnosticArgumentFactory.createDisplayableType(leftType),
+              this.diagnosticArgumentFactory.createDisplayableType(rightType)
+            ]
+          );
+        }
+        break;
+      }
+      case "question-question":
+        break;
+      default:
+        Debug.never(classificationResult);
+    }
+  }
+  checkAssumptionExpression(node) {
+    const parent = node.getParentSkippingParenthesizedExpressions();
+    switch (parent.kind) {
+      case 73 /* MemberAccessExpression */:
+      case 65 /* CallExpression */:
+      case 67 /* IndexedAccessExpression */:
+      case 75 /* DereferenceExpression */:
+        break;
+      default:
+        this.createAndAddDiagnostic(
+          2225 /* QuestionOperatorCanBeUsedOnlyInSpecificExpressions */,
+          node.questionToken
+        );
+    }
+  }
+  checkStatementBlock(node) {
+    const semanticContext = this.analyzer.semanticContext.ofStatementBlock(node);
+    semanticContext.validateNameConflicts(this.diagnosticAcceptor);
+  }
+  checkFunctionBlock(node) {
+    const semanticContext = this.analyzer.semanticContext.ofFunctionBlock(node);
+    semanticContext.validateNameConflicts(this.diagnosticAcceptor);
+  }
   checkErrorStatement(node) {
     this.checkExpressionTypeIsAssignableToTargetType(
       node.expression,
@@ -61670,67 +62309,6 @@ var SourceFileAnalyzer = class {
       }
     return { isUsedInsideLoop, isUsedInsideFinallyBlock };
   }
-  checkTypeParameterList(node) {
-    const typeParameterDeclarations = node.typeParameters.toArray();
-    if (typeParameterDeclarations.some((d) => d.defaultType !== void 0)) {
-      const notYetDeclaredParameters = /* @__PURE__ */ new Set();
-      for (const typeParameterDeclaration of typeParameterDeclarations) {
-        notYetDeclaredParameters.add(this.analyzer.entity.ofTypeParameterDeclaration(typeParameterDeclaration));
-      }
-      const visitor = (node2) => {
-        if (node2.kind === 26 /* TypeMemberDeclarationBlock */) {
-          return;
-        }
-        if (node2.kind === 10 /* NamedTypeSpecifier */) {
-          const type = this.analyzer.resolveNamedTypeSpecifier(node2).type;
-          if (type?.kind === "parameter" && notYetDeclaredParameters.has(type.getEntity().getOriginalEntity())) {
-            this.createAndAddDiagnostic(
-              2186 /* TypeParameterDefaultCanReferenceOnlyPreviouslyDeclaredTypeParameters */,
-              node2
-            );
-          }
-        }
-        forEachChild(node2, false, visitor);
-      };
-      for (const typeParameterDeclaration of typeParameterDeclarations) {
-        if (typeParameterDeclaration.defaultType !== void 0) {
-          visitor(typeParameterDeclaration.defaultType);
-        }
-        notYetDeclaredParameters.delete(this.analyzer.entity.ofTypeParameterDeclaration(typeParameterDeclaration));
-      }
-    }
-    let seenOptionalTypeParameter = false;
-    for (const typeParameterDeclaration of typeParameterDeclarations) {
-      if (typeParameterDeclaration.defaultType !== void 0) {
-        seenOptionalTypeParameter = true;
-      } else if (seenOptionalTypeParameter) {
-        this.createAndAddDiagnostic(
-          2187 /* RequiredTypeParametersCannotFollowTypeParametersWithDefaults */,
-          typeParameterDeclaration
-        );
-        break;
-      }
-    }
-  }
-  checkTypeParameterDeclaration(node) {
-    const entity = this.analyzer.entity.ofTypeParameterDeclaration(node);
-    const constraint = entity.getConstraint();
-    if (constraint.causesCycle) {
-      this.createAndAddDiagnostic(2082 /* TypeParameterHasCircularConstraint */, node.name);
-    }
-    if (constraint.cycleFree !== void 0) {
-      const defaultType = entity.getDefaultType();
-      if (defaultType !== void 0 && !this.analyzer.isTypeAssignableTo(defaultType, constraint.cycleFree)) {
-        this.addTypeAssignabilityDiagnosticIfBothTypesResolved(
-          defaultType,
-          constraint.cycleFree,
-          node.defaultType ?? node,
-          2087 /* Type0IsNotAssignableToConstraint1 */
-        );
-      }
-    }
-    this.checkIfTypeParameterIsUnused(entity, node.name);
-  }
   checkFunctionLiteral(node) {
     this.analyzer.semanticContext.ofRegularOrBlockFunctionLiteralParameters(node).validateNameConflicts(this.diagnosticAcceptor);
     this.checkAllCodePathsReturnOrResultVariableIsAssigned(
@@ -61806,38 +62384,6 @@ var SourceFileAnalyzer = class {
       }
     }
   }
-  addNotTranslatedTextsDiagnostics(translationPackage, diagnosticLocation) {
-    const notTranslatedEntities = this.collectNotTranslatedTexts(translationPackage);
-    if (notTranslatedEntities.length > 0) {
-      const diagnostic = this.createNotTranslatedTextsDiagnostic(notTranslatedEntities, diagnosticLocation);
-      this.addDiagnostic(diagnostic);
-    }
-  }
-  collectNotTranslatedTexts(translationPackage) {
-    return [];
-  }
-  createNotTranslatedTextsDiagnostic(entities, diagnosticLocation) {
-    const maxDisplayedEntitiesCount = 10;
-    let result;
-    if (entities.length <= maxDisplayedEntitiesCount) {
-      const displayableEntities = entities.map((e) => this.diagnosticArgumentFactory.createDisplayableEntity(e));
-      result = this.analyzer.createDiagnostic(
-        2095 /* TheFollowingTextsAreNotTranslated0 */,
-        diagnosticLocation,
-        [new DisplayableArray(displayableEntities, "\n\n")],
-        1 /* Warning */
-      );
-    } else {
-      const displayableEntities = entities.slice(0, maxDisplayedEntitiesCount + 1).map((e) => this.diagnosticArgumentFactory.createDisplayableEntity(e));
-      result = this.analyzer.createDiagnostic(
-        2096 /* TheFollowingTextsAreNotTranslated0And1More */,
-        diagnosticLocation,
-        [new DisplayableArray(displayableEntities, "\n\n"), entities.length - maxDisplayedEntitiesCount],
-        1 /* Warning */
-      );
-    }
-    return result;
-  }
   checkAllDefaultConstructorArgumentsAreNamed(node) {
     for (const argument2 of node.argumentList.arguments) {
       if (argument2.name === void 0) {
@@ -61846,224 +62392,6 @@ var SourceFileAnalyzer = class {
       }
     }
   }
-  checkPackageVariableDeclaration(node) {
-    const entity = this.analyzer.entity.ofPackageVariableDeclaration(node);
-    entity.ensureAllDiagnosticsReported?.();
-    if (this.isInterfacePackageFile) {
-      if (node.initializer !== void 0) {
-        this.createAndAddDiagnostic(2061 /* InterfacePackageVariablesMustNotHaveInitializers */, node.name);
-      }
-    }
-    if (node.typeAnnotation === void 0 && node.initializer === void 0) {
-      this.createAndAddDiagnostic(2184 /* VariableTypeIsNotSpecified */, node.name);
-    } else if (node.initializer !== void 0 && node.typeAnnotation !== void 0) {
-      this.checkExpressionTypeIsAssignableToTargetType(
-        node.initializer,
-        this.analyzer.type.ofTypeSpecifier(node.typeAnnotation.typeSpecifier)
-      );
-    }
-  }
-  checkPackageFunctionDeclaration(node) {
-    const entity = this.analyzer.entity.ofPackageFunctionDeclaration(node);
-    this.checkPackageMemberBodyPresence(entity, node.block, node.name);
-    if (node.block !== void 0) {
-      this.checkPossibleGeneratorFunctionReturnType(entity, node, node.name);
-    }
-    if (node.typeParameterClause !== void 0) {
-      this.analyzer.semanticContext.ofFunctionDeclarationTypeParameters(node, node.typeParameterClause).validateNameConflicts(this.diagnosticAcceptor);
-    }
-    this.analyzer.semanticContext.ofFunctionDeclarationParameters(node).validateNameConflicts(this.diagnosticAcceptor);
-    if (!this.analyzer.isFunctionGenerator(node)) {
-      this.checkAllCodePathsReturnOrResultVariableIsAssigned(
-        node,
-        node.name,
-        this.analyzer.returnType.ofPackageFunctionDeclaration(node),
-        this.analyzer.resultLocalVariableEntity.ofPackageFunctionDeclaration(node)
-      );
-    }
-  }
-  checkPackageVariableGetterDeclaration(node) {
-    const entity = this.analyzer.entity.ofComputedPackageVariableDeclaration(node);
-    entity.ensureAllDiagnosticsReported?.();
-    this.checkPackageMemberBodyPresence(entity, node.block, node.name);
-    this.checkAllCodePathsReturnOrResultVariableIsAssigned(
-      node,
-      node.name,
-      this.analyzer.returnType.ofPackageVariableGetterDeclaration(node),
-      this.analyzer.resultLocalVariableEntity.ofPackageVariableGetterDeclaration(node)
-    );
-  }
-  checkPackageVariableSetterDeclaration(node) {
-    const entity = this.analyzer.entity.ofComputedPackageVariableDeclaration(node);
-    this.checkPackageMemberBodyPresence(entity, node.block, node.name);
-  }
-  checkConstructorDeclaration(node) {
-    const entity = this.analyzer.entity.ofConstructorDeclaration(node);
-    entity.ensureAllDiagnosticsReported?.();
-    this.checkTypeMemberBodyPresence(entity, node.block, node.creationKeyword);
-    this.analyzer.semanticContext.ofConstructorDeclarationParameters(node).validateNameConflicts(this.diagnosticAcceptor);
-  }
-  checkMethodDeclaration(node) {
-    const entity = this.analyzer.entity.ofMethodDeclaration(node);
-    entity.ensureAllDiagnosticsReported?.();
-    this.checkTypeMemberBodyPresence(entity, node.block, node.name);
-    if (node.block !== void 0) {
-      this.checkPossibleGeneratorFunctionReturnType(entity, node, node.name);
-      const containingEntity = entity.getContainingEntity();
-      if (entity.markedBasic() && containingEntity.kind === 2 /* Type */ && containingEntity.typeEntityKind === 4 /* Alias */) {
-        this.analyzer.checkBodyOfBasicAliasTypeMethod(node, this.diagnosticAcceptor);
-      }
-    }
-    if (entity.methodKind === 3 /* Operator */) {
-      if (node.typeParameterClause !== void 0) {
-        this.createAndAddDiagnostic(
-          2231 /* OperatorCannotContainTypeParameterDeclarations */,
-          node.typeParameterClause
-        );
-      }
-      const syntacticalOperatorKind = node.name.operatorKind;
-      if (syntacticalOperatorKind !== void 0) {
-        const requiredParameterCount = requiredParameterCountBySyntacticalOperatorKind[syntacticalOperatorKind];
-        const actualParameterCount = node.parameterClause.parameterList.parameters.count();
-        switch (requiredParameterCount) {
-          case 0 /* Zero */: {
-            if (actualParameterCount !== 0) {
-              const operatorText = LocalizationHelperA.localizeSyntacticalOperatorKind(
-                syntacticalOperatorKind,
-                this.sourceFile.locale
-              );
-              this.createAndAddDiagnostic(
-                2097 /* OperatorFunction0MustNotHaveParameters */,
-                node.name,
-                [operatorText]
-              );
-            }
-            break;
-          }
-          case 1 /* ZeroOrOne */: {
-            if (!(actualParameterCount === 0 || actualParameterCount === 1)) {
-              const operatorText = LocalizationHelperA.localizeSyntacticalOperatorKind(
-                syntacticalOperatorKind,
-                this.sourceFile.locale
-              );
-              this.createAndAddDiagnostic(
-                2099 /* OperatorFunction0MustHaveNoMoreThanOneParameter */,
-                node.name,
-                [operatorText]
-              );
-            }
-            break;
-          }
-          case 2 /* One */: {
-            if (actualParameterCount !== 1) {
-              const operatorText = LocalizationHelperA.localizeSyntacticalOperatorKind(
-                syntacticalOperatorKind,
-                this.sourceFile.locale
-              );
-              this.createAndAddDiagnostic(
-                2098 /* OperatorFunction0MustHaveOneParameter */,
-                node.name,
-                [operatorText]
-              );
-            }
-            break;
-          }
-          default:
-            Debug.never(requiredParameterCount);
-        }
-      }
-    }
-    if (node.typeParameterClause !== void 0) {
-      this.analyzer.semanticContext.ofFunctionDeclarationTypeParameters(node, node.typeParameterClause).validateNameConflicts(this.diagnosticAcceptor);
-    }
-    this.analyzer.semanticContext.ofFunctionDeclarationParameters(node).validateNameConflicts(this.diagnosticAcceptor);
-    if (!this.analyzer.isFunctionGenerator(node)) {
-      this.checkAllCodePathsReturnOrResultVariableIsAssigned(
-        node,
-        node.name,
-        this.analyzer.returnType.ofMethodDeclaration(node),
-        this.analyzer.resultLocalVariableEntity.ofMethodDeclaration(node)
-      );
-    }
-  }
-  checkFieldDeclaration(node) {
-    const entity = this.analyzer.entity.ofFieldDeclaration(node);
-    entity.ensureAllDiagnosticsReported?.();
-    if (TypeMemberEntity.isAspectMember(entity) && !entity.isStatic() && !entity.markedAbstract()) {
-      this.createAndAddDiagnostic(2065 /* AspectTypeFieldsMustBeAbstract */, node.name);
-    }
-    if (this.isInterfacePackageFile) {
-      if (node.initializer !== void 0) {
-        this.createAndAddDiagnostic(2061 /* InterfacePackageVariablesMustNotHaveInitializers */, node.name);
-      }
-    } else if (TypeMemberEntity.isReducedTypeMember(entity)) {
-      if (node.initializer !== void 0) {
-        this.createAndAddDiagnostic(2069 /* ReducedTypeFieldsMustNotHaveInitializers */, node.name);
-      }
-    } else if (entity.markedAbstract()) {
-      if (node.initializer !== void 0) {
-        this.createAndAddDiagnostic(2068 /* AbstractFieldsMustNotHaveInitializers */, node.name);
-      }
-    }
-    if (node.typeAnnotation === void 0 && node.initializer === void 0) {
-      this.createAndAddDiagnostic(2184 /* VariableTypeIsNotSpecified */, node.name);
-    } else if (node.initializer !== void 0 && node.typeAnnotation !== void 0) {
-      this.checkExpressionTypeIsAssignableToTargetType(
-        node.initializer,
-        this.analyzer.type.ofTypeSpecifier(node.typeAnnotation.typeSpecifier)
-      );
-    }
-  }
-  checkFieldGetterDeclaration(node) {
-    const entity = this.analyzer.entity.ofComputedFieldDeclaration(node);
-    entity.ensureAllDiagnosticsReported?.();
-    this.checkTypeMemberBodyPresence(entity, node.block, node.name);
-    this.checkAllCodePathsReturnOrResultVariableIsAssigned(
-      node,
-      node.name,
-      this.analyzer.returnType.ofFieldGetterDeclaration(node),
-      this.analyzer.resultLocalVariableEntity.ofFieldGetterDeclaration(node)
-    );
-  }
-  checkFieldSetterDeclaration(node) {
-    const entity = this.analyzer.entity.ofComputedFieldDeclaration(node);
-    entity.ensureAllDiagnosticsReported?.();
-    this.checkTypeMemberBodyPresence(entity, node.block, node.name);
-  }
-  checkIndexedElementGetterDeclaration(node) {
-    const entity = this.analyzer.entity.ofIndexerDeclaration(node);
-    entity.ensureAllDiagnosticsReported?.();
-    this.checkTypeMemberBodyPresence(entity, node.block, node.parameterClause);
-    this.analyzer.semanticContext.ofIndexedElementAccessorDeclarationParameters(node).validateNameConflicts(this.diagnosticAcceptor);
-    this.checkAllCodePathsReturnOrResultVariableIsAssigned(
-      node,
-      node.parameterClause,
-      this.analyzer.returnType.ofIndexedElementGetterDeclaration(node),
-      this.analyzer.resultLocalVariableEntity.ofIndexedElementGetterDeclaration(node)
-    );
-  }
-  checkIndexedElementSetterDeclaration(node) {
-    const entity = this.analyzer.entity.ofIndexerDeclaration(node);
-    entity.ensureAllDiagnosticsReported?.();
-    this.checkTypeMemberBodyPresence(entity, node.block, node.parameterClause);
-    this.analyzer.semanticContext.ofIndexedElementAccessorDeclarationParameters(node).validateNameConflicts(this.diagnosticAcceptor);
-  }
-  checkDereferencedVariableGetterDeclaration(node) {
-    const entity = this.analyzer.entity.ofDereferenceOperatorDeclaration(node);
-    entity.ensureAllDiagnosticsReported?.();
-    this.checkTypeMemberBodyPresence(entity, node.block, node.caretToken);
-    this.checkAllCodePathsReturnOrResultVariableIsAssigned(
-      node,
-      node.caretToken,
-      this.analyzer.returnType.ofDereferencedVariableGetterDeclaration(node),
-      this.analyzer.resultLocalVariableEntity.ofDereferencedVariableGetterDeclaration(node)
-    );
-  }
-  checkDereferencedVariableSetterDeclaration(node) {
-    const entity = this.analyzer.entity.ofDereferenceOperatorDeclaration(node);
-    entity.ensureAllDiagnosticsReported?.();
-    this.checkTypeMemberBodyPresence(entity, node.block, node.caretToken);
-  }
   checkNestedFunctionDeclaration(node) {
     const entity = this.analyzer.entity.ofNestedFunctionDeclaration(node);
     if (node.block !== void 0) {
@@ -62135,60 +62463,6 @@ var SourceFileAnalyzer = class {
       }
     }
   }
-  checkPackageMemberBodyPresence(entity, body, diagnosticLocation) {
-    if (this.isInterfacePackageFile) {
-      if (body !== void 0) {
-        this.createAndAddDiagnostic(2060 /* InterfacePackageMustNotContainImplementation */, diagnosticLocation);
-      }
-    } else if (findTag(this.analyzer.originalWellKnownDeclarations.builtIntoPlatform, entity.getTags()) !== void 0) {
-      if (body !== void 0) {
-        this.createAndAddDiagnostic(
-          2066 /* DeclarationsMarkedWithBuiltIntoPlatformTagMustNotHaveBody */,
-          diagnosticLocation
-        );
-      }
-    } else {
-      if (body === void 0) {
-        this.createAndAddDiagnostic(2062 /* BodyIsMissing */, diagnosticLocation);
-      }
-    }
-  }
-  checkTypeMemberBodyPresence(entity, body, diagnosticLocation) {
-    if (this.isInterfacePackageFile) {
-      if (body !== void 0) {
-        this.createAndAddDiagnostic(2060 /* InterfacePackageMustNotContainImplementation */, diagnosticLocation);
-      }
-    } else if (findTag(this.analyzer.originalWellKnownDeclarations.builtIntoPlatform, entity.getTags()) !== void 0) {
-      if (body !== void 0) {
-        this.createAndAddDiagnostic(
-          2066 /* DeclarationsMarkedWithBuiltIntoPlatformTagMustNotHaveBody */,
-          diagnosticLocation
-        );
-      }
-    } else if (TypeMemberEntity.isReducedTypeMember(entity)) {
-      if (body !== void 0) {
-        this.createAndAddDiagnostic(
-          2067 /* ReducedTypeMembersMustNotHaveBody */,
-          diagnosticLocation
-        );
-      }
-    } else if (entity.isStatic()) {
-      if (body === void 0) {
-        this.createAndAddDiagnostic(2062 /* BodyIsMissing */, diagnosticLocation);
-      }
-    } else if (entity.markedAbstract()) {
-      if (body !== void 0) {
-        this.createAndAddDiagnostic(
-          2063 /* AbstractTypeMembersMustNotHaveBody */,
-          diagnosticLocation
-        );
-      }
-    } else {
-      if (body === void 0) {
-        this.createAndAddDiagnostic(2062 /* BodyIsMissing */, diagnosticLocation);
-      }
-    }
-  }
   // TODO: учесть константы времени компиляции.
   // private validateVariantInitializer(expression: tree.Expression): void {
   //   if (expression.kind === tree.NodeKind.TokenExpression) {
@@ -62686,109 +62960,6 @@ var SourceFileAnalyzer = class {
       }
     }
   }
-  checkParameterList(node) {
-    const parameters = node.parameters.toArray();
-    if (parameters.length > 0) {
-      this.checkRequiredParametersDoNotFollowOptionalParameters(parameters);
-      const firstParameter = parameters[0];
-      const firstParameterEntity = this.analyzer.entity.ofParameterDeclaration(firstParameter);
-      if (firstParameterEntity.isObjectParameter() && !this.parameterListCanDeclareObjectParameter(node)) {
-        this.createAndAddDiagnostic(2228 /* ObjectParameterCannotBeDeclaredHere */, firstParameter.name);
-      }
-      this.checkObjectParameterIsTheFirstParameter(parameters);
-    }
-  }
-  checkRequiredParametersDoNotFollowOptionalParameters(parameters) {
-    let seenOptionalParameter = false;
-    for (const parameter of parameters) {
-      if (parameter.defaultValue !== void 0) {
-        seenOptionalParameter = true;
-      } else if (seenOptionalParameter) {
-        this.createAndAddDiagnostic(2188 /* RequiredParametersCannotFollowOptionalParameters */, parameter.name);
-        break;
-      }
-    }
-  }
-  parameterListCanDeclareObjectParameter(node) {
-    const parent = node.parent.parent;
-    switch (parent.kind) {
-      case 17 /* AnonymousFunctionTypeDeclaration */:
-      case 23 /* PackageFunctionDeclaration */:
-      case 53 /* NestedFunctionDeclaration */:
-      case 62 /* FunctionLiteral */:
-        return true;
-      case 47 /* MethodDeclaration */: {
-        const containingDeclaration = TypeMemberQuery.getContainingDeclaration(parent);
-        switch (containingDeclaration.kind) {
-          case 18 /* AnonymousClassDeclaration */:
-          case 27 /* PackageClassDeclaration */:
-          case 28 /* PackageStructureDeclaration */:
-          case 29 /* PackageAspectDeclaration */:
-          case 30 /* PackageReducedTypeDeclaration */:
-          case 31 /* PackageVariantDeclaration */:
-            return true;
-          case 19 /* PackageAliasTypeDeclaration */:
-          case 35 /* TypeExtensionDeclaration */:
-            return false;
-          default:
-            Debug.never(containingDeclaration);
-        }
-      }
-      case 40 /* ConstructorDeclaration */:
-      case 41 /* DestructorDeclaration */:
-      case 42 /* IndexedElementGetterDeclaration */:
-      case 43 /* IndexedElementSetterDeclaration */:
-        return false;
-      default:
-        Debug.never(parent);
-    }
-  }
-  checkObjectParameterIsTheFirstParameter(parameters) {
-    for (let i = 1; i < parameters.length; i++) {
-      const parameterDeclaration2 = parameters[i];
-      if ((parameterDeclaration2.name.flags & 512 /* ObjectParameterName */) !== 0) {
-        this.createAndAddDiagnostic(2227 /* ObjectParameterMustBeTheFirstParameter */, parameterDeclaration2.name);
-        break;
-      }
-    }
-  }
-  checkParameterDeclaration(node) {
-    const entity = this.analyzer.entity.ofParameterDeclaration(node);
-    entity.ensureAllDiagnosticsReported?.();
-    const isFunctionLiteralParameter = node.parent.parent.parent.kind === 62 /* FunctionLiteral */;
-    if (!isFunctionLiteralParameter && node.typeAnnotation === void 0 && node.defaultValue === void 0) {
-      this.createAndAddDiagnostic(2184 /* VariableTypeIsNotSpecified */, node.name);
-    } else if (node.defaultValue !== void 0 && node.typeAnnotation !== void 0) {
-      this.checkExpressionTypeIsAssignableToTargetType(
-        node.defaultValue,
-        this.analyzer.type.ofTypeSpecifier(node.typeAnnotation.typeSpecifier)
-      );
-    } else if (isFunctionLiteralParameter && node.defaultValue !== void 0) {
-      this.checkExpressionTypeIsAssignableToTargetType(node.defaultValue, entity.getType());
-    }
-    let parentHasBody;
-    const parent = node.parent.parent.parent;
-    switch (parent.kind) {
-      case 23 /* PackageFunctionDeclaration */:
-      case 40 /* ConstructorDeclaration */:
-      case 41 /* DestructorDeclaration */:
-      case 42 /* IndexedElementGetterDeclaration */:
-      case 43 /* IndexedElementSetterDeclaration */:
-      case 47 /* MethodDeclaration */:
-      case 53 /* NestedFunctionDeclaration */:
-      case 62 /* FunctionLiteral */:
-        parentHasBody = parent.block !== void 0;
-        break;
-      case 17 /* AnonymousFunctionTypeDeclaration */:
-        parentHasBody = false;
-        break;
-      default:
-        Debug.never(parent);
-    }
-    if (parentHasBody) {
-      this.checkIfVariableIsUnused(entity, node.name);
-    }
-  }
   checkIfVariableIsUnused(entity, diagnosticLocation) {
     const usageInfo = this.namedDeclarationsUsageMap.getUsageInfo(entity);
     if (usageInfo.usageCount === 0 || !usageInfo.hasGetAccess) {
@@ -62858,43 +63029,6 @@ var SourceFileAnalyzer = class {
     }
     return receiver.kind === 85 /* BaseExpression */;
   }
-  overridingMemberHasCorrectHiding(overridingMemberHiding, overriddenMemberHiding) {
-    return overriddenMemberHiding === void 0 ? overridingMemberHiding === void 0 : overriddenMemberHiding.kind === overridingMemberHiding?.kind;
-  }
-  checkTextTranslationDeclaration(node) {
-    const sourceText = node.sourceText;
-    if (sourceText.kind === 141 /* TranslationTextTemplate */) {
-      const semanticContext = this.analyzer.semanticContext.ofTextTranslationDeclarationParameters(sourceText);
-      semanticContext.validateNameConflicts(this.diagnosticAcceptor);
-    }
-    const pkg2 = this.textTranslationPackage;
-    if (pkg2 !== void 0 && !pkg2.isPrimary()) {
-      const targetPackage = pkg2.getTargetPackage();
-      if (targetPackage !== void 0) {
-        const primaryPkg = this.analyzer.getPrimaryTextTranslationPackageOfTargetPackage(targetPackage);
-        if (primaryPkg !== void 0) {
-          const textKey = TextIdentity.keyFromTextTranslationSource(sourceText);
-          const textTranslation = primaryPkg.getMembers().getTextTranslationsByTextKey(textKey);
-          if (textTranslation.length === 0) {
-            this.createAndAddDiagnostic(
-              2190 /* TextIsMissingAmongPrimaryTextTranslationDefinitions */,
-              sourceText,
-              void 0,
-              1 /* Warning */
-            );
-          }
-        }
-      }
-    }
-    if (node.kind === 139 /* TextTranslationFunctionDeclaration */) {
-      this.checkAllCodePathsReturnOrResultVariableIsAssigned(
-        node,
-        node.sourceText,
-        this.analyzer.returnType.ofTextTranslationFunctionDeclaration(node),
-        this.analyzer.resultLocalVariableEntity.ofTextTranslationFunctionDeclaration(node)
-      );
-    }
-  }
   attachNodeLocationAndAddDiagnostics(diagnosticsData, node) {
     for (const diagnosticData of diagnosticsData) {
       const location = this.analyzer.getNodeDiagnosticLocation(node);