@artel/artc 0.6.25208 → 0.6.25209

package/build/{chunk-PNUVVKWZ.js → chunk-5SWGY25I.js}

@@ -169,10 +169,12 @@ var Query = class _Query {
   toArray() {
     return Array.from(this);
   }
-  count() {
+  count(fn) {
     let result = 0;
-    for (const _ of this) {
-      result++;
+    for (const e of this) {
+      if (fn === void 0 || fn(e)) {
+        result++;
+      }
     }
     return result;
   }
@@ -307,6 +309,25 @@ var Query = class _Query {
     }
     return maxElement;
   }
+  minByValue(valueSelector) {
+    const iterator = this[Symbol.iterator]();
+    const first = iterator.next();
+    if (first.done === true) {
+      return void 0;
+    }
+    let minValue = valueSelector(first.value);
+    let minElement = first.value;
+    let current = iterator.next();
+    while (current.done !== true) {
+      const currentValue = valueSelector(current.value);
+      if (currentValue < minValue) {
+        minValue = currentValue;
+        minElement = current.value;
+      }
+      current = iterator.next();
+    }
+    return minElement;
+  }
   single(fn) {
     let result;
     let hasValue = false;
@@ -556,7 +577,7 @@ var UniqueWithComparatorQuery = class extends Query {
 };
 
 // source/common/Constants.ts
-var ArtelVersion = true ? "0.6.25208" : "";
+var ArtelVersion = true ? "0.6.25209" : "";
 var ArtelSourceFileExtensions = [".\u0430\u0440\u0442", ".\u0430\u0440\u0442\u0435\u043B\u044C", ".art", ".artel"];
 var ArtelSourceFileExtensionSet = new Set(ArtelSourceFileExtensions);
 var ArtelSourceAndConfigurationFileExtensionSet = new Set(ArtelSourceFileExtensionSet).add(".json");
@@ -14568,7 +14589,7 @@ var AnalyzedTranslationPackage = class {
           if (translation.kind === 135 /* MethodTypeTranslation */) {
             const getTargetResult = this.getMethodTypeTranslationTarget(translation);
             if (getTargetResult.validTarget === entity) {
-              result = this.createTranslatedSubprogramSignatureFromMethodTypeAlias(translation, entity);
+              result = this.createTranslatedSubprogramSignatureFromMethodTypeTranslation(translation, entity);
               break;
             }
           }
@@ -14588,16 +14609,24 @@ var AnalyzedTranslationPackage = class {
     if (resultOpt === void 0) {
       let result;
       const typeTranslation = this.findTypeTranslation(container.typeEntity);
-      if (typeTranslation?.memberList !== void 0) {
-        for (const memberTranslation of typeTranslation.memberList.elements) {
-          if (memberTranslation.kind === 128 /* ConstructorTranslation */) {
-            const getTargetsResult = this.getConstructorTranslationTargets(memberTranslation);
-            if (getTargetsResult.validUnambiguousTargets.includes(entity)) {
-              result = this.createTranslatedSubprogramSignatureFromConstructorAlias(memberTranslation, entity);
-              break;
+      if (typeTranslation !== void 0) {
+        if (typeTranslation.memberList !== void 0) {
+          for (const memberTranslation of typeTranslation.memberList.elements) {
+            if (memberTranslation.kind === 128 /* ConstructorTranslation */) {
+              const getTargetsResult = this.getConstructorTranslationTargets(memberTranslation);
+              if (getTargetsResult.validUnambiguousTargets.includes(entity)) {
+                result = this.createTranslatedSubprogramSignatureFromConstructorTranslation(memberTranslation, entity);
+                break;
+              }
             }
           }
         }
+        if (result === void 0) {
+          const defaultConstructorInfo = entity.isDefault();
+          if (defaultConstructorInfo !== void 0) {
+            result = this.createTranslatedSubprogramSignatureForDefaultConstructor(entity, defaultConstructorInfo);
+          }
+        }
       }
       resultOpt = Option.fromNullable(result);
       this._constructorSignatureTranslations.set(entity, resultOpt);
@@ -14621,7 +14650,7 @@ var AnalyzedTranslationPackage = class {
           if (memberTranslation.kind === 130 /* IndexerTranslation */) {
             const getTargetsResult = this.getIndexerTranslationTargets(memberTranslation);
             if (getTargetsResult.validUnambiguousTargets.includes(entity)) {
-              result = this.createTranslatedSubprogramSignatureFromIndexerAlias(memberTranslation, entity);
+              result = this.createTranslatedSubprogramSignatureFromIndexerTranslation(memberTranslation, entity);
               break;
             }
           }
@@ -14964,7 +14993,7 @@ var AnalyzedTranslationPackage = class {
     ).toArray();
     return new LocalizedSubprogramSignature.Translated(typeParameters, valueParameters);
   }
-  createTranslatedSubprogramSignatureFromMethodTypeAlias(node, entity) {
+  createTranslatedSubprogramSignatureFromMethodTypeTranslation(node, entity) {
     const typeParameters = node.translatedTypeParameterClause?.parameterList.parameters.zip(entity.getTypeParameters(), (n, p) => new TranslatedTypeParameter(
       p,
       new LocalizedName.Translated(
@@ -14984,7 +15013,7 @@ var AnalyzedTranslationPackage = class {
     ).toArray();
     return new LocalizedSubprogramSignature.Translated(typeParameters, valueParameters);
   }
-  createTranslatedSubprogramSignatureFromConstructorAlias(node, entity) {
+  createTranslatedSubprogramSignatureFromConstructorTranslation(node, entity) {
     const valueParameters = node.translatedParameterClause.parameterList.parameters.zip(
       entity.getValueParameters(),
       (n, p) => new TranslatedValueParameter(
@@ -14997,7 +15026,7 @@ var AnalyzedTranslationPackage = class {
     ).toArray();
     return new LocalizedSubprogramSignature.Translated([], valueParameters);
   }
-  createTranslatedSubprogramSignatureFromIndexerAlias(node, entity) {
+  createTranslatedSubprogramSignatureFromIndexerTranslation(node, entity) {
     const valueParameters = node.translatedParameterClause.parameterList.parameters.zip(
       entity.getValueParameters(),
       (n, p) => new TranslatedValueParameter(
@@ -15010,6 +15039,58 @@ var AnalyzedTranslationPackage = class {
     ).toArray();
     return new LocalizedSubprogramSignature.Translated([], valueParameters);
   }
+  createTranslatedSubprogramSignatureForDefaultConstructor(entity, info) {
+    let translatedNameByParameter;
+    if (info.parametersForOwnFieldsInitialization !== void 0) {
+      const container = entity.getContainer();
+      if (container.kind === "type" && isPackageTypeEntity(container.typeEntity)) {
+        const members = this.getTypeEntityMembers(container.typeEntity);
+        if (members !== void 0) {
+          for (const parameterInfo of info.parametersForOwnFieldsInitialization) {
+            const name = members.getMemberName(parameterInfo.field);
+            if (name !== void 0) {
+              const localizedName = new LocalizedName.Translated(
+                name,
+                new Localization.Translated(new Translation(this))
+              );
+              translatedNameByParameter ??= /* @__PURE__ */ new Map();
+              translatedNameByParameter.set(parameterInfo.parameter, localizedName);
+            }
+          }
+        }
+      }
+    }
+    if (info.orderedParametersForBaseConstructor.length > 0) {
+      const baseConstructorEntity = info.baseConstructor?.getEntity();
+      if (baseConstructorEntity !== void 0 && getPackageContainingEntity(baseConstructorEntity) === this._translatedPackage) {
+        const baseConstructorSignature = this.getConstructorSignature(baseConstructorEntity);
+        if (baseConstructorSignature !== void 0) {
+          for (const parameterInfo of info.orderedParametersForBaseConstructor) {
+            const name = baseConstructorSignature.getValueParameterName(parameterInfo.baseConstructorParameter);
+            if (name !== void 0) {
+              const localizedName = new LocalizedName.Translated(
+                name,
+                new Localization.Translated(new Translation(this))
+              );
+              translatedNameByParameter ??= /* @__PURE__ */ new Map();
+              translatedNameByParameter.set(parameterInfo.parameter, localizedName);
+            }
+          }
+        }
+      }
+    }
+    const valueParameters = entity.getValueParameters().map((p) => {
+      let localizedName = translatedNameByParameter?.get(p);
+      if (localizedName === void 0) {
+        localizedName = new LocalizedName.Translated(
+          p.getName(),
+          new Localization.Translated(new Translation(this))
+        );
+      }
+      return new TranslatedValueParameter(p, localizedName);
+    });
+    return new LocalizedSubprogramSignature.Translated([], valueParameters);
+  }
   createTranslatedTypeSignature(node, typeParameterEntities) {
     const typeParameters = node.translatedTypeParameterClause?.parameterList.parameters.zip(typeParameterEntities, (n, p) => new TranslatedTypeParameter(
       p,
@@ -17507,12 +17588,11 @@ var PackageAliasTypeDeclarationEntity = class {
           const backingVariables = this._analyzer.createBackingTypeVariables(declared.variables, this);
           namedMembers.push(...backingVariables);
         }
-        const defaultConstructors = this._analyzer.defaultConstructors.createAliasTypeDefaultConstructors(this, declared.constructors.length > 0);
         const unaryOperators = declared.unaryOperators.concat(this._analyzer.builtInOperators.getUnaryOperators(this));
         const binaryOperators = declared.binaryOperators.concat(this._analyzer.builtInOperators.getBinaryOperators(this));
         result = new OriginalTypeEntityMembers(
           namedMembers,
-          declared.constructors.concat(defaultConstructors),
+          declared.constructors,
           declared.destructors,
           declared.indexers,
           declared.dereferenceOperators,
@@ -17520,8 +17600,7 @@ var PackageAliasTypeDeclarationEntity = class {
           binaryOperators
         );
       } else {
-        const defaultConstructors = this._analyzer.defaultConstructors.createAliasTypeDefaultConstructors(this, false);
-        result = new OriginalTypeEntityMembers([], defaultConstructors, [], [], [], [], []);
+        result = new OriginalTypeEntityMembers([], [], [], [], [], [], []);
       }
       return result;
     });
@@ -17595,6 +17674,9 @@ var IntrinsicBinaryOperatorEntity = class {
   isHidden() {
     return void 0;
   }
+  getTags() {
+    return [];
+  }
 };
 IntrinsicBinaryOperatorEntity = __decorateClass([
   entityToStringDecorator
@@ -24688,9 +24770,44 @@ var ConstructorLookup = class {
     return this.getConstructorsOfTypeWithOwnMembers(type.getEntity(), type, hidingMatcher, typeExtensionsLookup);
   }
   getConstructorsOfAliasType(type, hidingMatcher, typeExtensionsLookup) {
-    return this.getConstructorsOfTypeWithOwnMembers(type.getEntity(), type, hidingMatcher, typeExtensionsLookup);
+    let result = this.getOwnConstructors(type.getEntity(), type, hidingMatcher);
+    if (typeExtensionsLookup !== void 0) {
+      const extensionConstructors = this.getExtensionConstructors(
+        type.getEntity(),
+        type,
+        hidingMatcher,
+        typeExtensionsLookup
+      );
+      result = this.mergeConstructors(result, extensionConstructors);
+    }
+    let aliasedType = type.getAliasedType();
+    while (aliasedType.kind === "alias") {
+      const constructors2 = this.getOwnConstructors(aliasedType.getEntity(), aliasedType, hidingMatcher);
+      result = this.mergeConstructors(result, constructors2);
+      if (typeExtensionsLookup !== void 0) {
+        const extensionConstructors = this.getExtensionConstructors(
+          aliasedType.getEntity(),
+          aliasedType,
+          hidingMatcher,
+          typeExtensionsLookup
+        );
+        result = this.mergeConstructors(result, extensionConstructors);
+      }
+      aliasedType = aliasedType.getAliasedType();
+    }
+    const constructors = this.getConstructors(aliasedType, hidingMatcher, typeExtensionsLookup);
+    result = this.mergeConstructors(result, constructors);
+    return result;
   }
   getConstructorsOfTypeWithOwnMembers(typeEntity, type, hidingMatcher, typeExtensionsLookup) {
+    let result = this.getOwnConstructors(typeEntity, type, hidingMatcher);
+    if (typeExtensionsLookup !== void 0) {
+      const extensionConstructors = this.getExtensionConstructors(typeEntity, type, hidingMatcher, typeExtensionsLookup);
+      result = this.mergeConstructors(result, extensionConstructors);
+    }
+    return result;
+  }
+  getOwnConstructors(typeEntity, type, hidingMatcher) {
     const translatedMembers = this._localizationContext?.getTranslatedTypeEntityMembers(typeEntity);
     const originalLocale = getPackageContainingEntity(typeEntity).getLocale();
     let result = Query.from(typeEntity.getMembers().getConstructors()).map((c) => {
@@ -24708,26 +24825,23 @@ var ConstructorLookup = class {
         return hiding === void 0 || hidingMatcher.matches(hiding);
       });
     }
-    let extensionConstructors;
-    if (typeExtensionsLookup !== void 0) {
-      extensionConstructors = Query.from(typeExtensionsLookup.getTypeExtensionsByType(typeEntity)).flatMap((e) => {
-        const originalLocale2 = getPackageContainingEntity(e).getLocale();
-        return e.getMembers().getConstructors().map(
-          (c) => FoundAnonymousDeclaration.original(
-            new Constructor(c, type.getSubstitutions(), type),
-            originalLocale2
-          )
-        );
+    return result;
+  }
+  getExtensionConstructors(typeEntity, type, hidingMatcher, typeExtensionsLookup) {
+    let result = Query.from(typeExtensionsLookup.getTypeExtensionsByType(typeEntity)).flatMap((e) => {
+      const originalLocale = getPackageContainingEntity(e).getLocale();
+      return e.getMembers().getConstructors().map(
+        (c) => FoundAnonymousDeclaration.original(
+          new Constructor(c, type.getSubstitutions(), type),
+          originalLocale
+        )
+      );
+    });
+    if (hidingMatcher !== void 0) {
+      result = result.filter((m) => {
+        const hiding = m.value.isHidden();
+        return hiding === void 0 || hidingMatcher.matches(hiding);
       });
-      if (hidingMatcher !== void 0) {
-        extensionConstructors = extensionConstructors.filter((m) => {
-          const hiding = m.value.isHidden();
-          return hiding === void 0 || hidingMatcher.matches(hiding);
-        });
-      }
-      result = this.mergeConstructors(result, extensionConstructors);
-    } else {
-      extensionConstructors = Query.empty();
     }
     return result;
   }
@@ -29529,6 +29643,14 @@ var OverloadResolver = class {
     if (matchingSignatures.length === 0) {
       return void 0;
     }
+    const signatureWithLeastParameterCount = Query.from(matchingSignatures).minByValue((s) => s.value.getParameters().length);
+    if (signatureWithLeastParameterCount !== void 0) {
+      const parameterCount = signatureWithLeastParameterCount.value.getParameters().length;
+      const isSingle = Query.from(matchingSignatures).count((s) => s.value.getParameters().length === parameterCount) === 1;
+      if (isSingle) {
+        return signatureWithLeastParameterCount;
+      }
+    }
     let bestSignature = matchingSignatures[0];
     for (let i = 1; i < matchingSignatures.length && bestSignature !== void 0; i++) {
       const currentSignature = matchingSignatures[i];
@@ -29742,18 +29864,19 @@ var Resolver2 = class {
       )]);
     }
     if (constructors.length === 1) {
-      return new Meaning_constructorCall(constructors, constructors);
+      return new Meaning_constructorCall(targetType, constructors, constructors);
     }
     if (constructors.length > 1) {
       const candidates = Query.from(constructors).map((c) => new FoundTypeMemberCandidate(c));
       const result = Query.from(this._analyzer.resolveConstructorOverload(candidates, this._node.callArgumentList.callArguments)).map((c) => c.value).toArray();
-      return new Meaning_constructorCall(constructors, result);
+      return new Meaning_constructorCall(targetType, constructors, result);
     }
     Debug.unreachable();
   }
 };
 var Meaning_constructorCall = class {
-  constructor(candidates, suitableConstructors) {
+  constructor(type, candidates, suitableConstructors) {
+    this.type = type;
     this.candidates = candidates;
     this.suitableConstructors = suitableConstructors;
     this.kind = "constructor-call";
@@ -30024,11 +30147,11 @@ var Resolver3 = class {
       );
     }
     if (constructors.length === 1) {
-      return new Meaning_baseConstructorAccess(constructors, constructors);
+      return new Meaning_baseConstructorAccess(baseType, constructors, constructors);
     }
     const candidates = Query.from(constructors).map((c) => new FoundTypeMemberCandidate(c));
     const result = Query.from(this._analyzer.resolveConstructorOverload(candidates, parent.callArgumentList.callArguments)).map((c) => c.value).toArray();
-    return new Meaning_baseConstructorAccess(constructors, result);
+    return new Meaning_baseConstructorAccess(baseType, constructors, result);
   }
   resolveBaseMethodAccess(containingDeclaration) {
     const overriddenMethod = this._analyzer.overriddenMember.getOverriddenMethod(this._analyzer.entity.ofTypeMethodDeclaration(containingDeclaration));
@@ -30093,7 +30216,8 @@ var Meaning_baseObjectAccess = class {
   }
 };
 var Meaning_baseConstructorAccess = class {
-  constructor(candidates, suitableConstructors) {
+  constructor(type, candidates, suitableConstructors) {
+    this.type = type;
     this.candidates = candidates;
     this.suitableConstructors = suitableConstructors;
     this.kind = "base-constructor-access";
@@ -30488,7 +30612,7 @@ var Resolver4 = class {
       if (this.callee.kind === 88 /* ObjectExpression */) {
         const meaning = this._analyzer.getObjectExpressionMeaning(this.callee);
         if (meaning.kind === "own-constructor-access") {
-          return new Meaning_constructorCall2(meaning.candidates, meaning.suitableConstructors);
+          return new Meaning_constructorCall2(meaning.type, meaning.candidates, meaning.suitableConstructors);
         }
       }
     }
@@ -30496,7 +30620,7 @@ var Resolver4 = class {
       if (this.callee.kind === 89 /* BaseExpression */) {
         const meaning = this._analyzer.getBaseExpressionMeaning(this.callee);
         if (meaning.kind === "base-constructor-access") {
-          return new Meaning_constructorCall2(meaning.candidates, meaning.suitableConstructors);
+          return new Meaning_constructorCall2(meaning.type, meaning.candidates, meaning.suitableConstructors);
         }
       }
     }
@@ -30540,12 +30664,12 @@ var Resolver4 = class {
       )]);
     }
     if (constructors.length === 1) {
-      return new Meaning_constructorCall2(constructors, constructors);
+      return new Meaning_constructorCall2(type, constructors, constructors);
     }
     if (constructors.length > 1) {
       const candidates = Query.from(constructors).map((c) => new FoundTypeMemberCandidate(c));
       const result = Query.from(this._analyzer.resolveConstructorOverload(candidates, this._node.callArgumentList.callArguments)).map((c) => c.value).toArray();
-      return new Meaning_constructorCall2(constructors, result);
+      return new Meaning_constructorCall2(type, constructors, result);
     }
     Debug.unreachable();
   }
@@ -30570,7 +30694,8 @@ var Meaning_objectMethodCall = class {
   }
 };
 var Meaning_constructorCall2 = class {
-  constructor(candidates, suitableConstructors) {
+  constructor(type, candidates, suitableConstructors) {
+    this.type = type;
     this.candidates = candidates;
     this.suitableConstructors = suitableConstructors;
     this.kind = "constructor-call";
@@ -31907,11 +32032,11 @@ var Resolver8 = class {
       ));
     }
     if (constructors.length === 1) {
-      return new Meaning_ownConstructorAccess(constructors, constructors);
+      return new Meaning_ownConstructorAccess(type, constructors, constructors);
     }
     const candidates = Query.from(constructors).map((c) => new FoundTypeMemberCandidate(c));
     const result = Query.from(this._analyzer.resolveConstructorOverload(candidates, parent.callArgumentList.callArguments)).map((c) => c.value).toArray();
-    return new Meaning_ownConstructorAccess(constructors, result);
+    return new Meaning_ownConstructorAccess(type, constructors, result);
   }
   resolveContextAccess() {
     const semanticContext = this._analyzer.semanticContext.containing(this._node);
@@ -31949,7 +32074,8 @@ var Resolver8 = class {
   }
 };
 var Meaning_ownConstructorAccess = class {
-  constructor(candidates, suitableConstructors) {
+  constructor(type, candidates, suitableConstructors) {
+    this.type = type;
     this.candidates = candidates;
     this.suitableConstructors = suitableConstructors;
     this.kind = "own-constructor-access";
@@ -36737,6 +36863,7 @@ var WellKnownDeclarationsLoader = class {
     declarations.typeVariableProxy = this.findPackageStructuredType(systemPackage, new Name("\u041F\u043E\u0441\u0440\u0435\u0434\u043D\u0438\u043A\u041F\u0435\u0440\u0435\u043C\u0435\u043D\u043D\u043E\u0439\u041E\u0431\u044A\u0435\u043A\u0442\u0430"), 2);
     declarations.parameterArray = this.findPackageAliasType(interopPackage, new Name("\u041C\u0430\u0441\u0441\u0438\u0432\u041F\u0430\u0440\u0430\u043C\u0435\u0442\u0440\u043E\u0432"), 1);
     declarations.defaultImport = this.findPackageStructuredType(interopPackage, new Name("\u0418\u043C\u043F\u043E\u0440\u0442\u041F\u043E\u0423\u043C\u043E\u043B\u0447\u0430\u043D\u0438\u044E"), 0);
+    declarations.builtIntoPlatform = this.findPackageStructuredType(interopPackage, new Name("\u0412\u0441\u0442\u0440\u043E\u0435\u043D\u043E\u0412\u041F\u043B\u0430\u0442\u0444\u043E\u0440\u043C\u0443"), 0);
     declarations.realName = this.findPackageStructuredType(interopPackage, new Name("\u041D\u0430\u0441\u0442\u043E\u044F\u0449\u0435\u0435\u0418\u043C\u044F"), 0);
     return declarations;
   }
@@ -37024,7 +37151,7 @@ var Type4 = class {
       case "object-method-call":
         return this._analyzer.makeNoneAssignableToTypeIfExpressionOptionalChaining(meaning.type.getReturnType(), node);
       case "constructor-call":
-        return meaning.suitableConstructors[0]?.value.getInstanceType() ?? this._analyzer.standardTypes.unresolved;
+        return meaning.type;
       case "unresolved":
         return this._analyzer.standardTypes.unresolved;
     }
@@ -37033,7 +37160,7 @@ var Type4 = class {
     const meaning = this._analyzer.getAutotypeCallExpressionMeaning(node, targetTypeHint);
     switch (meaning.kind) {
       case "constructor-call":
-        return meaning.suitableConstructors[0]?.value.getInstanceType() ?? this._analyzer.standardTypes.unresolved;
+        return meaning.type;
       case "unresolved":
         return this._analyzer.standardTypes.unresolved;
       default:
@@ -39352,16 +39479,6 @@ var DefaultConstructors = class {
     }
     return result;
   }
-  createAliasTypeDefaultConstructors(aliasTypeEntity, hasDeclaredConstructors) {
-    let result;
-    if (!hasDeclaredConstructors) {
-      const lookup = new TypeMemberLookup(this._analyzer, aliasTypeEntity.getAliasedType().cycleFree, void 0);
-      result = lookup.getConstructors().map((c) => new SynthesizedAliasTypeConstructor(this._analyzer, c.value, aliasTypeEntity)).toArray();
-    } else {
-      result = [];
-    }
-    return result;
-  }
   createDefaultConstructors(node) {
     let result;
     const hasDeclaredConstructor = Query.from(flattenTypeMemberDeclarationList(node.body.memberBlock.memberList)).any((m) => m.kind === 45 /* TypeConstructorDeclaration */);
@@ -40850,6 +40967,14 @@ var DiagnosticCollector = class _DiagnosticCollector {
         this.checkTypeIndexedSetterDeclaration(node);
         break;
       }
+      case 50 /* TypeDereferencedVariableGetterDeclaration */: {
+        this.checkTypeDereferencedVariableGetterDeclaration(node);
+        break;
+      }
+      case 51 /* TypeDereferencedVariableSetterDeclaration */: {
+        this.checkTypeDereferencedVariableSetterDeclaration(node);
+        break;
+      }
       case 57 /* NestedMethodDeclaration */: {
         this.checkNestedMethodDeclaration(node);
         break;
@@ -41245,6 +41370,30 @@ var DiagnosticCollector = class _DiagnosticCollector {
       this.checkTypeMemberBodyPresence(node, node.body, node.parameterClause);
     }
   }
+  checkTypeDereferencedVariableGetterDeclaration(node) {
+    if (this.isInterfacePackageFile) {
+      if (node.body !== void 0) {
+        this.addDiagnostic(this._analyzer.createNodeDiagnostic(
+          105 /* InterfacePackageMustNotContainImplementation */,
+          node.caretToken
+        ));
+      }
+    } else {
+      this.checkTypeMemberBodyPresence(node, node.body, node.caretToken);
+    }
+  }
+  checkTypeDereferencedVariableSetterDeclaration(node) {
+    if (this.isInterfacePackageFile) {
+      if (node.body !== void 0) {
+        this.addDiagnostic(this._analyzer.createNodeDiagnostic(
+          105 /* InterfacePackageMustNotContainImplementation */,
+          node.caretToken
+        ));
+      }
+    } else {
+      this.checkTypeMemberBodyPresence(node, node.body, node.caretToken);
+    }
+  }
   checkNestedMethodDeclaration(node) {
     const entity = this._analyzer.entity.ofNestedMethodDeclaration(node);
     if (node.body !== void 0) {
@@ -41318,7 +41467,16 @@ var DiagnosticCollector = class _DiagnosticCollector {
       if (!bodyCanBeMissing) {
         bodyCanBeMissing = this.isAspectTypeMemberDeclaration(typeMemberWithBody) && findModifier(typeMemberWithBody, 38 /* Redefinable */) === void 0;
         if (!bodyCanBeMissing) {
-          this.addDiagnostic(this._analyzer.createNodeDiagnostic(109 /* BodyIsMissing */, nodeForDiagnostics));
+          const entity = this.tryGetTypeMemberDeclarationEntity(typeMemberWithBody);
+          if (entity !== void 0) {
+            bodyCanBeMissing = findTag(
+              this._analyzer.wellKnownDeclarations.builtIntoPlatform,
+              entity.getTags()
+            ) !== void 0;
+          }
+          if (!bodyCanBeMissing) {
+            this.addDiagnostic(this._analyzer.createNodeDiagnostic(109 /* BodyIsMissing */, nodeForDiagnostics));
+          }
         }
       }
     } else {
@@ -41330,6 +41488,36 @@ var DiagnosticCollector = class _DiagnosticCollector {
       }
     }
   }
+  tryGetTypeMemberDeclarationEntity(node) {
+    switch (node.kind) {
+      case 44 /* TypeMemberGroupDeclaration */:
+        return void 0;
+      case 45 /* TypeConstructorDeclaration */:
+        return this._analyzer.entity.ofTypeConstructorDeclaration(node);
+      case 46 /* TypeDestructorDeclaration */:
+        return this._analyzer.entity.ofTypeDestructorDeclaration(node);
+      case 47 /* TypeIndexedGetterDeclaration */:
+        return this._analyzer.entity.ofTypeIndexedGetterDeclaration(node);
+      case 48 /* TypeIndexedSetterDeclaration */:
+        return this._analyzer.entity.ofTypeIndexedSetterDeclaration(node);
+      case 50 /* TypeDereferencedVariableGetterDeclaration */:
+        return this._analyzer.entity.ofTypeDereferencedVariableGetterDeclaration(node);
+      case 51 /* TypeDereferencedVariableSetterDeclaration */:
+        return this._analyzer.entity.ofTypeDereferencedVariableSetterDeclaration(node);
+      case 52 /* TypeMethodDeclaration */:
+        return this._analyzer.entity.ofTypeMethodDeclaration(node);
+      case 53 /* TypeVariableDeclaration */:
+        return this._analyzer.entity.ofTypeVariableDeclaration(node);
+      case 54 /* TypeVariableGetterDeclaration */:
+        return this._analyzer.entity.ofTypeVariableGetterDeclaration(node);
+      case 55 /* TypeVariableSetterDeclaration */:
+        return this._analyzer.entity.ofTypeVariableSetterDeclaration(node);
+      case 56 /* InvalidTypeMemberDeclaration */:
+        return void 0;
+      case 144 /* VariantDeclaration */:
+        return this._analyzer.entity.ofVariantDeclaration(node);
+    }
+  }
   isAspectTypeMemberDeclaration(node) {
     const containingDeclaration = TreeQuery.fromTypeMemberDeclaration(node).container().getNode();
     return containingDeclaration.kind === 33 /* PackageStructuredTypeDeclaration */ && containingDeclaration.body.structuredTypeKindKeyword.keywordKind === 3 /* Aspect */ || containingDeclaration.kind === 18 /* AnonymousStructuredTypeDeclaration */ && containingDeclaration.body.structuredTypeKindKeyword.keywordKind === 3 /* Aspect */;
@@ -42035,11 +42223,24 @@ var WellKnownDeclarations = class {
 };
 
 // source/entities/ConstructorEntity.ts
-var DefaultConstructorEntityInfo2 = class {
-  constructor(baseConstructor, orderedParametersForBaseConstructor, hasParametersForFieldInitialization) {
+var DefaultConstructorEntityInfo3 = class {
+  constructor(baseConstructor, orderedParametersForBaseConstructor, hasParametersForFieldInitialization, parametersForOwnFieldsInitialization) {
     this.baseConstructor = baseConstructor;
     this.orderedParametersForBaseConstructor = orderedParametersForBaseConstructor;
     this.hasParametersForFieldInitialization = hasParametersForFieldInitialization;
+    this.parametersForOwnFieldsInitialization = parametersForOwnFieldsInitialization;
+  }
+};
+var DefaultConstructorParameterForBaseConstructorInfo = class {
+  constructor(parameter, baseConstructorParameter) {
+    this.parameter = parameter;
+    this.baseConstructorParameter = baseConstructorParameter;
+  }
+};
+var ConstructorParameterInitializingFieldInfo = class {
+  constructor(parameter, field) {
+    this.parameter = parameter;
+    this.field = field;
   }
 };
 var TypeConstructorDeclarationEntity = class {
@@ -42117,26 +42318,10 @@ var DefaultConstructorEntity = class {
     this._variablesToInitialize = _variablesToInitialize;
     this._baseConstructor = _baseConstructor;
     this.kind = 9 /* Constructor */;
-    this._valueParameters = new Cached();
-    this._orderedParametersForBaseConstructor = new Cached();
+    this._parametersInfo = new Cached();
   }
   getValueParameters() {
-    return this._valueParameters.getOrInsertWith(() => {
-      const orderedParametersForBaseConstructor = this.getOrderedParametersForBaseConstructor();
-      const parametersForOwnVariables = Query.from(this._variablesToInitialize).map((v) => {
-        const isOptionalParameter = v.hasInitializer || this._analyzer.isNoneAssignableToType(v.entity.getType());
-        return new IntrinsicParameterVariableEntity(
-          v.entity.getName(),
-          v.entity.getType(),
-          new ParameterVariableEntityContainer.Entity(this),
-          isOptionalParameter,
-          false,
-          void 0
-        );
-      }).toArray();
-      const orderedParameters = Query.from(parametersForOwnVariables.filter((p) => !p.isOptional())).chain(orderedParametersForBaseConstructor.filter((p) => !p.isOptional())).chain(parametersForOwnVariables.filter((p) => p.isOptional())).chain(orderedParametersForBaseConstructor.filter((p) => p.isOptional())).toArray();
-      return orderedParameters;
-    });
+    return this.getParametersInfo().values;
   }
   getDefinition() {
     return { kind: 1 /* Intrinsic */ };
@@ -42145,11 +42330,13 @@ var DefaultConstructorEntity = class {
     return new TypeMemberEntityContainer2.Type(this._containingType);
   }
   isDefault() {
+    const parametersInfo = this.getParametersInfo();
     const hasParametersForFieldInitialization = this._variablesToInitialize.length > 0 || this._baseConstructor?.value.getEntity().isDefault()?.hasParametersForFieldInitialization === true;
-    return new DefaultConstructorEntityInfo2(
+    return new DefaultConstructorEntityInfo3(
       this._baseConstructor?.value,
-      this.getOrderedParametersForBaseConstructor(),
-      hasParametersForFieldInitialization
+      parametersInfo.orderedParametersForBaseConstructor,
+      hasParametersForFieldInitialization,
+      parametersInfo.parametersForOwnFieldsInitialization
     );
   }
   isHidden() {
@@ -42161,25 +42348,53 @@ var DefaultConstructorEntity = class {
   getTags() {
     return [];
   }
-  getOrderedParametersForBaseConstructor() {
-    return this._orderedParametersForBaseConstructor.getOrInsertWith(() => {
-      if (this._baseConstructor !== void 0) {
-        const localizedSignature = EntityLocalizationHelper.getLocalizedConstructorSignature(
-          this._baseConstructor.value.getEntity(),
-          this._baseConstructor.localization
+  getParametersInfo() {
+    return this._parametersInfo.getOrInsertWith(() => {
+      const orderedParametersForBaseConstructor = this.createOrderedParametersForBaseConstructor();
+      const parametersForOwnFieldsInitialization = this._variablesToInitialize.length > 0 ? [] : void 0;
+      const parametersForOwnVariables = this._variablesToInitialize.map((v) => {
+        const isOptionalParameter = v.hasInitializer || this._analyzer.isNoneAssignableToType(v.entity.getType());
+        const parameter = new IntrinsicParameterVariableEntity(
+          v.entity.getName(),
+          v.entity.getType(),
+          new ParameterVariableEntityContainer.Entity(this),
+          isOptionalParameter,
+          false,
+          void 0
         );
-        return Query.from(this._baseConstructor.value.getValueParameters()).zip(localizedSignature.getValueParameterNames(), (p, n) => new IntrinsicParameterVariableEntity(
+        parametersForOwnFieldsInitialization?.push(new ConstructorParameterInitializingFieldInfo(parameter, v.entity));
+        return parameter;
+      });
+      const orderedParameters = Query.from(parametersForOwnVariables.filter((p) => !p.isOptional())).chain(orderedParametersForBaseConstructor.map((i) => i.parameter).filter((p) => !p.isOptional())).chain(parametersForOwnVariables.filter((p) => p.isOptional())).chain(orderedParametersForBaseConstructor.map((i) => i.parameter).filter((p) => p.isOptional())).toArray();
+      return new DefaultConstructorParametersInfo(
+        orderedParameters,
+        orderedParametersForBaseConstructor,
+        parametersForOwnFieldsInitialization
+      );
+    });
+  }
+  createOrderedParametersForBaseConstructor() {
+    let result;
+    if (this._baseConstructor !== void 0) {
+      const localizedSignature = EntityLocalizationHelper.getLocalizedConstructorSignature(
+        this._baseConstructor.value.getEntity(),
+        this._baseConstructor.localization
+      );
+      result = Query.from(this._baseConstructor.value.getValueParameters()).zip(localizedSignature.getValueParameterNames(), (p, n) => {
+        const parameter = new IntrinsicParameterVariableEntity(
           n.value,
           p.getType(),
           new ParameterVariableEntityContainer.Entity(this),
           p.isOptional(),
           p.isVariadic(),
           void 0
-        )).toArray();
-      } else {
-        return [];
-      }
-    });
+        );
+        return new DefaultConstructorParameterForBaseConstructorInfo(parameter, p.getEntity());
+      }).toArray();
+    } else {
+      result = [];
+    }
+    return result;
   }
 };
 DefaultConstructorEntity = __decorateClass([
@@ -42191,47 +42406,13 @@ var VariableToInitialize = class {
     this.hasInitializer = hasInitializer;
   }
 };
-var SynthesizedAliasTypeConstructor = class {
-  constructor(_analyzer, _originalConstructor, _aliasTypeEntity) {
-    this._analyzer = _analyzer;
-    this._originalConstructor = _originalConstructor;
-    this._aliasTypeEntity = _aliasTypeEntity;
-    this.kind = 9 /* Constructor */;
-    this._valueParameters = new Cached();
-  }
-  getValueParameters() {
-    return this._valueParameters.getOrInsertWith(() => this._originalConstructor.getValueParameters().map((p) => new IntrinsicParameterVariableEntity(
-      p.getName(),
-      p.getType(),
-      new ParameterVariableEntityContainer.Entity(this),
-      p.isOptional(),
-      p.isVariadic(),
-      p.getEntity().isSpecial()
-    )));
-  }
-  getDefinition() {
-    return { kind: 1 /* Intrinsic */ };
-  }
-  getContainer() {
-    return new TypeMemberEntityContainer2.Type(this._aliasTypeEntity);
-  }
-  isDefault() {
-    const hasParametersForFieldInitialization = this._originalConstructor.getEntity().isDefault()?.hasParametersForFieldInitialization === true;
-    return new DefaultConstructorEntityInfo2(this._originalConstructor, [], hasParametersForFieldInitialization);
-  }
-  isHidden() {
-    return this._originalConstructor.getEntity().isHidden();
-  }
-  isAbstract() {
-    return this._originalConstructor.getEntity().isAbstract();
-  }
-  getTags() {
-    return this._originalConstructor.getEntity().getTags();
+var DefaultConstructorParametersInfo = class {
+  constructor(values, orderedParametersForBaseConstructor, parametersForOwnFieldsInitialization) {
+    this.values = values;
+    this.orderedParametersForBaseConstructor = orderedParametersForBaseConstructor;
+    this.parametersForOwnFieldsInitialization = parametersForOwnFieldsInitialization;
   }
 };
-SynthesizedAliasTypeConstructor = __decorateClass([
-  entityToStringDecorator
-], SynthesizedAliasTypeConstructor);
 
 // source/entities/DestructorEntity.ts
 var TypeDestructorDeclarationEntity = class {
@@ -44538,6 +44719,9 @@ var IntrinsicUnaryOperatorEntity = class {
   isHidden() {
     return void 0;
   }
+  getTags() {
+    return [];
+  }
 };
 IntrinsicUnaryOperatorEntity = __decorateClass([
   entityToStringDecorator
@@ -44880,6 +45064,8 @@ function isEntityWithTags(entity) {
     case 11 /* MethodType */:
     case 12 /* StructuredType */:
     case 14 /* AliasType */:
+    case 3 /* Getter */:
+    case 4 /* Setter */:
       return true;
     default:
       Debug.typeIsAssignableTo();
@@ -48445,7 +48631,7 @@ var IrBuilder = class {
     });
     const statements = [];
     if (info.baseConstructor !== void 0) {
-      const callArguments = new OrderedCallArguments(info.orderedParametersForBaseConstructor.map((v) => VariableAccessExpression.get(this._entityMap.getVariableEntity(v))), false);
+      const callArguments = new OrderedCallArguments(info.orderedParametersForBaseConstructor.map((v) => VariableAccessExpression.get(this._entityMap.getVariableEntity(v.parameter))), false);
       const baseConstructorEntity = info.baseConstructor.getEntity();
       const container = baseConstructorEntity.getContainer();
       if (container.kind === "type") {
@@ -48458,19 +48644,16 @@ var IrBuilder = class {
         statements.unshift(new ExpressionStatement3(baseConstructorCall, void 0));
       }
     }
-    const parametersForBaseConstructor = new Set(info.orderedParametersForBaseConstructor);
-    const typeMemberLookup = TypeMemberLookup.ofTypeEntity(this._analyzer, typeEntity, void 0);
-    for (const parameter of entity.getValueParameters()) {
-      if (!parametersForBaseConstructor.has(parameter)) {
-        const parameterName = parameter.getName();
-        const variable = typeMemberLookup.getNamedMembersByName(new SearchName(parameterName, true)).mapAndFilter((m) => m.value.kind === "variable" ? m.value : void 0).first();
-        if (variable !== void 0) {
-          const memberEntity = variable.getEntity();
-          const receiver = this.createExplicitReceiver(memberEntity);
+    if (info.parametersForOwnFieldsInitialization !== void 0) {
+      const fieldToInitializeByOwnParameter = Query.from(info.parametersForOwnFieldsInitialization).toMap((i) => i.parameter, (i) => i.field);
+      for (const parameter of entity.getValueParameters()) {
+        const field = fieldToInitializeByOwnParameter.get(parameter);
+        if (field !== void 0) {
+          const receiver = this.createExplicitReceiver(field);
           const memberAccess = TypeVariableAccessExpression.set(
             receiver,
             false,
-            AccessedVariable.fromEntity(this._entityMap.getVariableEntity(memberEntity))
+            AccessedVariable.fromEntity(this._entityMap.getVariableEntity(field))
           );
           const parameterAccess = VariableAccessExpression.get(
             this._entityMap.getVariableEntity(parameter)
@@ -56355,12 +56538,13 @@ export {
   PackageAliasTypeDeclarationEntity,
   BinaryOperatorKind2 as BinaryOperatorKind,
   IntrinsicBinaryOperatorEntity,
-  DefaultConstructorEntityInfo2 as DefaultConstructorEntityInfo,
+  DefaultConstructorEntityInfo3 as DefaultConstructorEntityInfo,
+  DefaultConstructorParameterForBaseConstructorInfo,
+  ConstructorParameterInitializingFieldInfo,
   TypeConstructorDeclarationEntity,
   IntrinsicConstructorEntity,
   DefaultConstructorEntity,
   VariableToInitialize,
-  SynthesizedAliasTypeConstructor,
   TypeDestructorDeclarationEntity,
   EntityHidingLevel_type,
   EntityHidingLevel_typeFamily,