@artel/artc 0.6.26024 → 0.6.26026

package/build/api/ApiServices.js

@@ -1,6 +1,7 @@
 import {
   AccessedFunction_entity,
   AccessedFunction_typeMember,
+  AccessorEntity,
   Analyzer2 as Analyzer,
   Cached,
   CancelledError,
@@ -19,7 +20,6 @@ import {
   FileSystemTree,
   FunctionDeclaration_accessedFunction,
   FunctionDeclaration_entity,
-  FunctionDeclaration_substitutedFunction,
   FunctionDeclaration_typeMember,
   GeneratedSourceFileScheme,
   GenericCancellationToken,
@@ -78,7 +78,6 @@ import {
   getOrCreateKeywordDictionary,
   ifTypeEntityIsFunctionTypeAliasThenFunctionType,
   isAnonymousStructuredTypeDeclaration,
-  isComputedVariableEntity,
   isEntityWithParameters,
   isEntityWithTypeParameters,
   isExpression,
@@ -101,6 +100,7 @@ import {
   isTypeMemberDeclaration,
   isTypeSpecifier,
   isUnaryOperator,
+  isVariableEntityWithExplicitAccessors,
   kebabCaseToCamelCase,
   localeToString,
   modifierKindsInSortOrder,
@@ -109,7 +109,7 @@ import {
   sortModifiers,
   traverseTreeAsync,
   yieldTask
-} from "../chunk-W3GP7NSM.js";
+} from "../chunk-UY7U6EAT.js";
 
 // source/services/CustomRequests.ts
 import * as ls from "vscode-languageserver";
@@ -566,8 +566,8 @@ var TranslationsGenerator = class _TranslationsGenerator {
         }
         return this.createPackageTypeWithMembersTranslation(entity);
       }
-      case 8 /* TypeExtension */:
-      case 10 /* TextTranslation */:
+      case 6 /* TypeExtension */:
+      case 8 /* TextTranslation */:
         return void 0;
       default:
         Debug.never(entity);
@@ -601,9 +601,9 @@ var TranslationsGenerator = class _TranslationsGenerator {
         return this.createFieldTranslation(entity);
       case 1 /* Function */:
         return this.createMethodTranslation(entity);
-      case 5 /* Indexer */:
+      case 3 /* Indexer */:
         return this.createIndexerTranslation(entity);
-      case 6 /* DereferenceOperator */:
+      case 4 /* DereferenceOperator */:
         return void 0;
       default:
         Debug.never(entity);
@@ -640,6 +640,7 @@ var TranslationsGenerator = class _TranslationsGenerator {
         return SyntaxFactory.constructorTranslation(parameters, parameters);
       }
       case 2 /* Destructor */:
+      case 4 /* Accessor */:
         return void 0;
       default:
         Debug.never(entity.methodKind);
@@ -3872,7 +3873,7 @@ var NodeSemanticInfoServiceA = class {
         if (isNarrowableReferenceExpression(node)) {
           narrowedType = analyzer.type.ofExpression(node);
         }
-        const target = new FieldReferenceTarget(meaning.field, meaning.accessKind, narrowedType);
+        const target = new FieldReferenceTarget(meaning.field, meaning.access.kind, narrowedType);
         result = new ReferenceNodeSemanticInfo([target], false);
         break;
       }
@@ -3881,7 +3882,7 @@ var NodeSemanticInfoServiceA = class {
         if (isNarrowableReferenceExpression(node)) {
           narrowedType = analyzer.type.ofExpression(node);
         }
-        const target = new FieldReferenceTarget(meaning.field, meaning.accessKind, narrowedType);
+        const target = new FieldReferenceTarget(meaning.field, meaning.access.kind, narrowedType);
         result = new ReferenceNodeSemanticInfo([target], false);
         break;
       }
@@ -3890,7 +3891,7 @@ var NodeSemanticInfoServiceA = class {
         if (isNarrowableReferenceExpression(node)) {
           narrowedType = analyzer.type.ofExpression(node);
         }
-        const target = new EntityReferenceTarget(meaning.variable, meaning.accessKind, narrowedType);
+        const target = new EntityReferenceTarget(meaning.variable, meaning.access.kind, narrowedType);
         result = new ReferenceNodeSemanticInfo([target], false);
         break;
       }
@@ -4176,10 +4177,10 @@ var NodeSemanticInfoServiceA = class {
         }
         const variable = meaning.variable;
         if (variable.kind === "entity") {
-          const target = new EntityReferenceTarget(variable.value, meaning.accessKind, narrowedType);
+          const target = new EntityReferenceTarget(variable.value, meaning.access.kind, narrowedType);
           result = new ReferenceNodeSemanticInfo([target], false);
         } else if (variable.kind === "type-member") {
-          const target = new FieldReferenceTarget(variable.value, meaning.accessKind, narrowedType);
+          const target = new FieldReferenceTarget(variable.value, meaning.access.kind, narrowedType);
           result = new ReferenceNodeSemanticInfo([target], false);
         } else {
           Debug.never(variable);
@@ -4242,11 +4243,11 @@ var NodeSemanticInfoServiceA = class {
       if (isNonEmptyArray(meaning.suitableIndexers)) {
         result = createIndexersReference(
           meaning.suitableIndexers,
-          meaning.accessKind,
+          meaning.access.kind,
           meaning.suitableIndexers.length > 1
         );
       } else if (isNonEmptyArray(meaning.candidates)) {
-        result = createIndexersReference(meaning.candidates, meaning.accessKind, true);
+        result = createIndexersReference(meaning.candidates, meaning.access.kind, true);
       }
       if (result !== void 0 && options7.includeBetterReferenceTargets) {
         result = this.getBetterReferenceTargetsOrPreserve(result);
@@ -4308,7 +4309,7 @@ var NodeSemanticInfoServiceA = class {
   static ofDereferenceExpressionOperator(analyzer, node, options7) {
     const meaning = analyzer.resolveDereferenceExpression(node);
     if (meaning.kind === "resolved") {
-      const target = new DereferenceOperatorReferenceTarget(meaning.operator, meaning.accessKind);
+      const target = new DereferenceOperatorReferenceTarget(meaning.operator, meaning.access.kind);
       let result = new ReferenceNodeSemanticInfo([target], false);
       if (options7.includeBetterReferenceTargets) {
         result = this.getBetterReferenceTargetsOrPreserve(result);
@@ -4616,45 +4617,79 @@ var NodeSemanticInfoServiceA = class {
   }
   static getBetterReferenceTargetsOrPreserve(info) {
     const currentTargets = info.betterTargets ?? info.targets;
-    const betterTargets = Query.from(currentTargets).mapAndFilter((t) => this.getBetterReferenceTarget(t)).toArray();
+    const betterTargets = currentTargets.map((t) => this.getBetterReferenceTargets(t)).filter((t) => t !== void 0).flat();
     if (isNonEmptyArray(betterTargets)) {
       return new ReferenceNodeSemanticInfo(info.targets, info.isAmbiguous, betterTargets);
     }
     return info;
   }
-  static getBetterReferenceTarget(original) {
+  static getBetterReferenceTargets(original) {
     let result;
-    let currentTarget = original;
-    let betterTarget;
+    let currentTargets = [original];
+    let betterTargets;
+    let foundBetterTarget;
     do {
-      betterTarget = void 0;
-      if (currentTarget.kind === "entity" && currentTarget.entity.kind === 0 /* Variable */) {
-        {
-          if (currentTarget.entity.subkind === "parameter") {
-            const specialVariableInfo = currentTarget.entity.isSpecial();
-            if (specialVariableInfo?.kind === "implicit-function-block-parameter") {
-              betterTarget = new TypeParameterReferenceTarget(
-                specialVariableInfo.targetTypeParameter,
-                currentTarget.accessKind
-              );
+      betterTargets = [];
+      foundBetterTarget = false;
+      for (const currentTarget of currentTargets) {
+        let foundBetterCurrentTarget = false;
+        if (currentTarget.kind === "entity" && currentTarget.entity.kind === 0 /* Variable */) {
+          {
+            if (currentTarget.entity.subkind === "parameter") {
+              const specialVariableInfo = currentTarget.entity.isSpecial();
+              if (specialVariableInfo?.kind === "implicit-function-block-parameter") {
+                const target = new TypeParameterReferenceTarget(
+                  specialVariableInfo.targetTypeParameter,
+                  currentTarget.accessKind
+                );
+                betterTargets.push(target);
+                foundBetterCurrentTarget = true;
+              }
             }
           }
-        }
-      } else if (currentTarget.kind === "accessed-function") {
-        const entity = currentTarget.func.getEntity();
-        if (entity.subkind === "method" && TypeMemberEntity.isConstructor(entity) && entity.getDefinition().kind === 1 /* Intrinsic */) {
-          const containingEntity = entity.getContainingEntity();
-          if (containingEntity.kind === 2 /* Type */ && containingEntity.getDefinition().kind === 0 /* Source */) {
-            betterTarget = new EntityReferenceTarget(containingEntity, 0 /* Get */);
+        } else if (currentTarget.kind === "accessed-function") {
+          const entity = currentTarget.func.getEntity();
+          if (TypeMemberEntity.isConstructor(entity) && entity.getDefinition().kind === 1 /* Intrinsic */) {
+            const containingEntity = entity.getContainingEntity();
+            if (containingEntity.kind === 2 /* Type */ && containingEntity.getDefinition().kind === 0 /* Source */) {
+              const target = new EntityReferenceTarget(containingEntity, 0 /* Get */);
+              betterTargets.push(target);
+              foundBetterCurrentTarget = true;
+            }
+          }
+        } else if (currentTarget.kind === "entity" && currentTarget.entity.kind === 1 /* Function */) {
+        } else if (currentTarget.kind === "match-result-value-parameter") {
+          const containingEntity = currentTarget.parameter.entity.getContainingEntity();
+          if (containingEntity.kind === 3 /* Indexer */ && containingEntity.getDefinition().kind === 0 /* Source */) {
+            const indexerParameters = containingEntity.getParameters();
+            const parameterIndex = indexerParameters.indexOf(currentTarget.parameter.entity);
+            if (parameterIndex >= 0) {
+              const getterParameter = containingEntity.getGetter()?.getParameters()[parameterIndex];
+              const setterParameter = containingEntity.getSetter()?.getParameters()[parameterIndex];
+              if (getterParameter !== void 0) {
+                const target = new EntityReferenceTarget(getterParameter, currentTarget.accessKind);
+                betterTargets.push(target);
+                foundBetterCurrentTarget = true;
+              }
+              if (setterParameter !== void 0) {
+                const target = new EntityReferenceTarget(setterParameter, currentTarget.accessKind);
+                betterTargets.push(target);
+                foundBetterCurrentTarget = true;
+              }
+            }
           }
         }
-      } else if (currentTarget.kind === "entity" && currentTarget.entity.kind === 1 /* Function */) {
+        if (foundBetterCurrentTarget) {
+          foundBetterTarget ||= true;
+        } else {
+          betterTargets.push(currentTarget);
+        }
       }
-      if (betterTarget !== void 0) {
-        result = betterTarget;
-        currentTarget = betterTarget;
+      if (foundBetterTarget) {
+        result = betterTargets;
+        currentTargets = betterTargets;
       }
-    } while (betterTarget !== void 0);
+    } while (foundBetterTarget);
     return result;
   }
   static getResolvedContainingTranslationPackage(analyzer, node) {
@@ -4703,7 +4738,7 @@ var NodeSemanticInfoServiceA = class {
 
 // source/services/common/Utils.ts
 function getEntitySourceLocations(analyzer, entity) {
-  if (entity.kind === 9 /* Package */) {
+  if (entity.kind === 7 /* Package */) {
     return void 0;
   }
   let result;
@@ -4724,7 +4759,7 @@ function getEntitySourceLocations(analyzer, entity) {
         Debug.never(definition.value);
       }
     }
-  } else if (entity.kind === 5 /* Indexer */) {
+  } else if (entity.kind === 3 /* Indexer */) {
     const definition = entity.getDefinition();
     if (definition.kind === 0 /* Source */) {
       result = definition.nodes.map((d) => {
@@ -4733,7 +4768,7 @@ function getEntitySourceLocations(analyzer, entity) {
         return new SourceLocation(sourceFile, range);
       });
     }
-  } else if (entity.kind === 6 /* DereferenceOperator */) {
+  } else if (entity.kind === 4 /* DereferenceOperator */) {
     const definition = entity.getDefinition();
     if (definition.kind === 0 /* Source */) {
       result = definition.nodes.map((d) => {
@@ -4742,7 +4777,7 @@ function getEntitySourceLocations(analyzer, entity) {
         return new SourceLocation(sourceFile, range);
       });
     }
-  } else if (entity.kind === 10 /* TextTranslation */) {
+  } else if (entity.kind === 8 /* TextTranslation */) {
     const definition = entity.getDefinition();
     if (definition.kind === 0 /* Source */) {
       const range = definition.node.rangeWithoutTrivia;
@@ -5385,22 +5420,8 @@ var HoverService = class {
     }
   }
   createHoverAtAccessedFunction(func, range) {
-    switch (func.kind) {
-      case "entity": {
-        const declaration = new FunctionDeclaration_entity(func.value);
-        return new Hover(this.displayService.displayFunctionDeclaration(declaration), range);
-      }
-      case "type-member": {
-        const declaration = new FunctionDeclaration_typeMember(func.value);
-        return new Hover(this.displayService.displayFunctionDeclaration(declaration), range);
-      }
-      case "substituted-function": {
-        const declaration = new FunctionDeclaration_substitutedFunction(func.value);
-        return new Hover(this.displayService.displayFunctionDeclaration(declaration), range);
-      }
-      default:
-        Debug.never(func);
-    }
+    const declaration = new FunctionDeclaration_accessedFunction(func);
+    return new Hover(this.displayService.displayFunctionDeclaration(declaration), range);
   }
 };
 
@@ -5609,7 +5630,7 @@ var ReferencesFinder = class {
         return void 0;
       }
     } else if (this.definitions.length > 1 && potentialReferenceDefinitions.length > 1) {
-      if (this.definitions.length === potentialReferenceDefinitions.length && this.definitions.every((d) => potentialReferenceDefinitions.some((rd) => this.areEntitiesWithSameDefinition(rd.value, d.value)))) {
+      if (potentialReferenceDefinitions.some((r) => this.definitions.some((d) => this.areEntitiesWithSameDefinition(r.value, d.value)))) {
         return potentialReferenceDefinitions[0].referenceKind;
       } else {
         return void 0;
@@ -5639,7 +5660,7 @@ var ReferencesFinderA = class extends ReferencesFinder {
     return __async(this, null, function* () {
       let semanticInfoOptions;
       const firstDefinition = this.definitions[0].value;
-      if (firstDefinition.kind === 1 /* Function */ && firstDefinition.subkind === "method" && TypeMemberEntity.isConstructor(firstDefinition)) {
+      if (TypeMemberEntity.isConstructor(firstDefinition)) {
         semanticInfoOptions = {
           preferredTargetOfExplicitConstructorCall: "constructor-declaration",
           includeBetterReferenceTargets: true
@@ -5889,6 +5910,7 @@ var ReferencesService = class {
       if (definitions.length === 0) {
         return [];
       }
+      this.expandDefinitionsArray(definitions);
       const result = [];
       const firstDefinition = definitions[0];
       const restrictions = this.getReferenceRestrictions(firstDefinition, options7);
@@ -5907,6 +5929,46 @@ var ReferencesService = class {
       return result;
     });
   }
+  expandDefinitionsArray(definitions) {
+    const length = definitions.length;
+    for (let i = 0; i < length; i++) {
+      const definition = definitions[i];
+      if (definition.value.kind === 0 /* Variable */ && definition.value.subkind === "parameter") {
+        const containingEntity = definition.value.getContainingEntity();
+        if (containingEntity.kind === 3 /* Indexer */) {
+          const parameterIndex = containingEntity.getParameters().indexOf(definition.value);
+          if (parameterIndex >= 0) {
+            const getterParameter = containingEntity.getGetter()?.getParameters()[parameterIndex];
+            if (getterParameter !== void 0 && !definitions.some((d) => d.value === getterParameter)) {
+              definitions.push(new DefinitionInfo(getterParameter, definition.referenceKind));
+            }
+            const setterParameter = containingEntity.getSetter()?.getParameters()[parameterIndex];
+            if (setterParameter !== void 0 && !definitions.some((d) => d.value === setterParameter)) {
+              definitions.push(new DefinitionInfo(setterParameter, definition.referenceKind));
+            }
+          }
+        } else if (TypeMemberEntity.isAccessor(containingEntity)) {
+          const accessorOwner = containingEntity.getAccessorOwner();
+          if (accessorOwner?.kind === 3 /* Indexer */) {
+            const parameterIndex = containingEntity.getParameters().indexOf(definition.value);
+            if (parameterIndex >= 0) {
+              const indexerParameter = accessorOwner.getParameters()[parameterIndex];
+              if (indexerParameter !== void 0 && !definitions.some((d) => d.value === indexerParameter)) {
+                definitions.push(new DefinitionInfo(indexerParameter, definition.referenceKind));
+              }
+            }
+            const otherAccessor = AccessorEntity.isGetter(containingEntity) ? accessorOwner.getSetter() : accessorOwner.getGetter();
+            if (otherAccessor !== void 0) {
+              const otherAccessorParameter = otherAccessor.getParameters()[parameterIndex];
+              if (otherAccessorParameter !== void 0 && !definitions.some((d) => d.value === otherAccessorParameter)) {
+                definitions.push(new DefinitionInfo(otherAccessorParameter, definition.referenceKind));
+              }
+            }
+          }
+        }
+      }
+    }
+  }
   getReferencedDefinitionInfosAtOffset(analyzer, sourceFile, offset, options7) {
     switch (sourceFile.dialect) {
       case 0 /* ArtelA */:
@@ -5920,7 +5982,7 @@ var ReferencesService = class {
   getReferenceRestrictions(definition, _options) {
     const result = new ReferenceRestrictions();
     let namedDefinitionInfo;
-    if (definition.value.kind === 1 /* Function */ && definition.value.subkind === "method" && TypeMemberEntity.isConstructor(definition.value)) {
+    if (TypeMemberEntity.isConstructor(definition.value)) {
       const type = TypeWithMembersOrExtensionEntity.getContextualTypeEntity(definition.value.getContainingEntity());
       if (type !== void 0) {
         namedDefinitionInfo = this.isEntityWithRegularName(type);
@@ -5931,12 +5993,12 @@ var ReferencesService = class {
     if (namedDefinitionInfo !== void 0) {
       result.canBeIdentifier = true;
     }
-    const isConstructor = definition.value.kind === 1 /* Function */ && definition.value.subkind === "method" && TypeMemberEntity.isConstructor(definition.value);
+    const isConstructor = TypeMemberEntity.isConstructor(definition.value);
     if (isConstructor) {
       result.canBeAutotypeCall = true;
       result.canBeConstructorDeclaration = true;
     }
-    if (definition.value.kind === 6 /* DereferenceOperator */) {
+    if (definition.value.kind === 4 /* DereferenceOperator */) {
       result.canBeDereferenceOperator = true;
     }
     if (isTypeEntity(definition.value) || isConstructor) {
@@ -5945,7 +6007,7 @@ var ReferencesService = class {
     if (definition.value.kind === 1 /* Function */) {
       result.canBeBaseExpression = true;
     }
-    if (definition.value.kind === 5 /* Indexer */) {
+    if (definition.value.kind === 3 /* Indexer */) {
       result.canBeIndexer = true;
     }
     if (definition.value.kind === 0 /* Variable */ && definition.value.subkind === "parameter" && definition.value.isObjectParameter()) {
@@ -6010,15 +6072,13 @@ var ReferencesService = class {
         }
         return void 0;
       }
-      case 7 /* PackageAlias */:
+      case 5 /* PackageAlias */:
         return { name: entity.getName() };
-      case 3 /* Getter */:
-      case 4 /* Setter */:
-      case 5 /* Indexer */:
-      case 6 /* DereferenceOperator */:
-      case 9 /* Package */:
-      case 8 /* TypeExtension */:
-      case 10 /* TextTranslation */:
+      case 3 /* Indexer */:
+      case 4 /* DereferenceOperator */:
+      case 7 /* Package */:
+      case 6 /* TypeExtension */:
+      case 8 /* TextTranslation */:
         return void 0;
       default:
         Debug.never(entity);
@@ -9798,7 +9858,7 @@ var EntityToSyntax = class {
     const tags = this.convertTags(entity.getTags());
     const modifiers = this.convertPackageVariableModifiers(entity);
     let result;
-    if (isComputedVariableEntity(entity)) {
+    if (isVariableEntityWithExplicitAccessors(entity)) {
       result = [];
       const getterEntity = entity.getGetter();
       if (getterEntity !== void 0) {
@@ -9806,7 +9866,7 @@ var EntityToSyntax = class {
       }
       const setterEntity = entity.getSetter();
       if (setterEntity !== void 0) {
-        result.push(SyntaxFactory.packageVariableSetterDeclaration(tags, modifiers, name, void 0));
+        result.push(SyntaxFactory.packageVariableSetterDeclaration(tags, modifiers, name, type, void 0));
       }
     } else {
       result = SyntaxFactory.packageVariableDeclaration(tags, modifiers, name, type);
@@ -9967,9 +10027,9 @@ var EntityToSyntax = class {
     return sortModifiers(modifiers);
   }
   convertTypeEntityMembers(members) {
-    const variables = members.getNamedMembers(127 /* All */).filter((m) => m.kind === 0 /* Variable */).flatMap((m) => this.convertField(m));
+    const variables = members.getNamedMembers(255 /* All */).filter((m) => m.kind === 0 /* Variable */).flatMap((m) => this.convertField(m));
     const groupedVariables = this.groupTypeMemberDeclarations(variables);
-    const ordinaryMethods = members.getNamedMembers(127 /* All */).filter((m) => TypeMemberEntity.isOrdinaryMethod(m)).map((m) => this.convertMethod(m));
+    const ordinaryMethods = members.getNamedMembers(255 /* All */).filter((m) => TypeMemberEntity.isOrdinaryMethod(m)).map((m) => this.convertMethod(m));
     const groupedOrdinaryMethods = this.groupTypeMemberDeclarations(ordinaryMethods);
     const operators = members.getOperators().map((m) => this.convertMethod(m));
     const groupedOperators = this.groupTypeMemberDeclarations(operators);
@@ -9979,11 +10039,14 @@ var EntityToSyntax = class {
     const groupedDestructors = this.groupTypeMemberDeclarations(destructors);
     const indexers = members.getIndexers().flatMap((i) => this.convertIndexer(i));
     const groupedIndexers = this.groupTypeMemberDeclarations(indexers);
+    const dereferenceOperators = members.getDereferenceOperators().flatMap((i) => this.convertDereferenceOperator(i));
+    const groupedDereferenceOperators = this.groupTypeMemberDeclarations(dereferenceOperators);
     return groupedVariables.concat(
       groupedIndexers,
       groupedConstructors,
       groupedOrdinaryMethods,
       groupedOperators,
+      groupedDereferenceOperators,
       groupedDestructors
     );
   }
@@ -9991,22 +10054,22 @@ var EntityToSyntax = class {
     if (entity.isVariant()) {
       return this.convertVariant(entity);
     }
-    const name = this.getEntityName(entity);
-    const type = this.convertType(entity.getType());
-    const tags = this.convertTags(entity.getTags());
-    const modifiers = this.convertFieldModifiers(entity);
     let result;
-    if (isComputedVariableEntity(entity)) {
+    if (isVariableEntityWithExplicitAccessors(entity)) {
       result = [];
       const getterEntity = entity.getGetter();
       if (getterEntity !== void 0) {
-        result.push(SyntaxFactory.fieldGetterDeclaration(tags, modifiers, name, type, void 0));
+        result.push(this.convertTypeMemberAccessor(getterEntity));
       }
       const setterEntity = entity.getSetter();
       if (setterEntity !== void 0) {
-        result.push(SyntaxFactory.fieldSetterDeclaration(tags, modifiers, name, void 0));
+        result.push(this.convertTypeMemberAccessor(setterEntity));
       }
     } else {
+      const name = this.getEntityName(entity);
+      const type = this.convertType(entity.getType());
+      const tags = this.convertTags(entity.getTags());
+      const modifiers = this.convertFieldModifiers(entity);
       result = SyntaxFactory.fieldDeclaration(tags, modifiers, name, type);
     }
     return result;
@@ -10058,6 +10121,8 @@ var EntityToSyntax = class {
         const parameters = this.convertParameters(entity.getParameters());
         return SyntaxFactory.destructorDeclaration(tags, modifiers, parameters, void 0);
       }
+      case 4 /* Accessor */:
+        return this.convertTypeMemberAccessor(entity);
       default:
         Debug.never(entity.methodKind);
     }
@@ -10104,25 +10169,56 @@ var EntityToSyntax = class {
     }
     return sortModifiers(modifiers);
   }
-  convertIndexer(entity) {
-    const tags = this.convertTags(entity.getTags());
-    const modifiers = this.convertIndexerModifiers(entity);
-    const parameters = this.convertParameters(entity.getParameters());
-    const result = new Array();
-    const getterEntity = entity.getGetter();
-    if (getterEntity !== void 0) {
-      const type = this.convertType(entity.getType());
-      const declaration = SyntaxFactory.indexedElementGetterDeclaration(tags, modifiers, parameters, type, void 0);
-      result.push(declaration);
+  convertTypeMemberAccessor(entity) {
+    const accessorKind = entity.accessorKind;
+    if (accessorKind === void 0) {
+      return SyntaxFactory.missingTypeMemberDeclaration([], []);
     }
-    const setterEntity = entity.getSetter();
-    if (setterEntity !== void 0) {
-      const declaration = SyntaxFactory.indexedElementSetterDeclaration(tags, modifiers, parameters, void 0);
-      result.push(declaration);
+    const tags = this.convertTags(entity.getTags());
+    const modifiers = this.convertAccessorModifiers(entity);
+    switch (accessorKind) {
+      case 2 /* FieldGetter */: {
+        const owningEntity = entity.getAccessorOwner();
+        if (owningEntity?.kind !== 0 /* Variable */) {
+          return SyntaxFactory.missingTypeMemberDeclaration([], []);
+        }
+        const name = this.getEntityName(owningEntity);
+        const type = this.convertType(entity.getReturnType());
+        return SyntaxFactory.fieldGetterDeclaration(tags, modifiers, name, type, void 0);
+      }
+      case 3 /* FieldSetter */: {
+        const owningEntity = entity.getAccessorOwner();
+        if (owningEntity?.kind !== 0 /* Variable */) {
+          return SyntaxFactory.missingTypeMemberDeclaration([], []);
+        }
+        const type = this.convertType(owningEntity.getType());
+        const name = this.getEntityName(owningEntity);
+        return SyntaxFactory.fieldSetterDeclaration(tags, modifiers, name, type, void 0);
+      }
+      case 4 /* IndexedElementGetter */: {
+        const parameters = this.convertParameters(entity.getParameters());
+        const type = this.convertType(entity.getReturnType());
+        return SyntaxFactory.indexedElementGetterDeclaration(tags, modifiers, parameters, type, void 0);
+      }
+      case 5 /* IndexedElementSetter */: {
+        const parameterEntities = entity.getParameters();
+        const parameters = this.convertParameters(parameterEntities.slice(0, parameterEntities.length - 1));
+        const type = this.convertType(entity.getReturnType());
+        return SyntaxFactory.indexedElementSetterDeclaration(tags, modifiers, parameters, type, void 0);
+      }
+      case 6 /* DereferencedVariableGetter */: {
+        const type = this.convertType(entity.getReturnType());
+        return SyntaxFactory.dereferencedVariableGetterDeclaration(tags, modifiers, type, void 0);
+      }
+      case 7 /* DereferencedVariableSetter */: {
+        const type = this.convertType(entity.getReturnType());
+        return SyntaxFactory.dereferencedVariableSetterDeclaration(tags, modifiers, type, void 0);
+      }
+      default:
+        Debug.never(accessorKind);
     }
-    return result;
   }
-  convertIndexerModifiers(entity) {
+  convertAccessorModifiers(entity) {
     const modifiers = new Array();
     const isHidden = entity.isHidden();
     if (isHidden !== void 0) {
@@ -10131,11 +10227,41 @@ var EntityToSyntax = class {
     if (entity.isStatic()) {
       modifiers.push(SyntaxFactory.modifier(45 /* Static */));
     }
+    if (entity.markedBasic()) {
+      modifiers.push(SyntaxFactory.modifier(21 /* Basic */));
+    }
     if (entity.markedAbstract()) {
       modifiers.push(SyntaxFactory.modifier(42 /* Abstract */));
     }
+    if (entity.isOverride()) {
+      modifiers.push(SyntaxFactory.modifier(43 /* Override */));
+    }
     return sortModifiers(modifiers);
   }
+  convertIndexer(entity) {
+    const result = new Array();
+    const getterEntity = entity.getGetter();
+    if (getterEntity !== void 0) {
+      result.push(this.convertTypeMemberAccessor(getterEntity));
+    }
+    const setterEntity = entity.getSetter();
+    if (setterEntity !== void 0) {
+      result.push(this.convertTypeMemberAccessor(setterEntity));
+    }
+    return result;
+  }
+  convertDereferenceOperator(entity) {
+    const result = new Array();
+    const getterEntity = entity.getGetter();
+    if (getterEntity !== void 0) {
+      result.push(this.convertTypeMemberAccessor(getterEntity));
+    }
+    const setterEntity = entity.getSetter();
+    if (setterEntity !== void 0) {
+      result.push(this.convertTypeMemberAccessor(setterEntity));
+    }
+    return result;
+  }
   convertVariant(entity) {
     const tags = this.convertTags(entity.getTags());
     const name = this.getEntityName(entity);
@@ -10616,19 +10742,16 @@ var SourceGenerationService = class extends RxObject7 {
           default:
             Debug.never(entity);
         }
-      case 3 /* Getter */:
-      case 4 /* Setter */:
-        return this.checkIfEntityOfKindIsPresentInGeneratedCode(entity.getOwningEntity());
-      case 5 /* Indexer */:
-      case 6 /* DereferenceOperator */:
+      case 3 /* Indexer */:
+      case 4 /* DereferenceOperator */:
         return this.checkIfEntityOfKindIsPresentInGeneratedCode(entity.getContainingEntity());
-      case 7 /* PackageAlias */:
+      case 5 /* PackageAlias */:
         return false;
-      case 9 /* Package */:
+      case 7 /* Package */:
         return false;
-      case 8 /* TypeExtension */:
+      case 6 /* TypeExtension */:
         return true;
-      case 10 /* TextTranslation */:
+      case 8 /* TextTranslation */:
         return true;
       default:
         Debug.never(entity);
@@ -10719,17 +10842,15 @@ var EntityFinder = class {
           default:
             Debug.never(entity);
         }
-      case 5 /* Indexer */:
+      case 3 /* Indexer */:
         return this.findIndexerEntity(entity);
-      case 6 /* DereferenceOperator */:
+      case 4 /* DereferenceOperator */:
         return this.findDereferenceOperatorEntity(entity);
-      case 7 /* PackageAlias */:
-      case 3 /* Getter */:
-      case 4 /* Setter */:
-      case 9 /* Package */:
-      case 8 /* TypeExtension */:
+      case 5 /* PackageAlias */:
+      case 7 /* Package */:
+      case 6 /* TypeExtension */:
         return void 0;
-      case 10 /* TextTranslation */:
+      case 8 /* TextTranslation */:
         return void 0;
       default:
         Debug.never(entity);
@@ -10741,7 +10862,7 @@ var EntityFinder = class {
     } else if (entity.subkind === "field") {
       const containingType = this.findEntity(entity.getContainingEntity());
       if (containingType !== void 0 && isTypeEntity(containingType) && isTypeEntityWithMembers(containingType)) {
-        return containingType.getMembers().getNamedMembersByName(entity.getName(), 127 /* All */)[0];
+        return containingType.getMembers().getNamedMembersByName(entity.getName(), 255 /* All */)[0];
       }
     } else if (entity.subkind === "parameter") {
       const originalContainingEntity = entity.getContainingEntity();
@@ -10776,7 +10897,7 @@ var EntityFinder = class {
         if (!(containingType !== void 0 && isTypeEntity(containingType) && isTypeEntityWithMembers(containingType))) {
           return void 0;
         }
-        const members = containingType.getMembers().getNamedMembersByName(entity.getSpecialNameOrName(), 127 /* All */).filter((m) => m.kind === 1 /* Function */);
+        const members = containingType.getMembers().getNamedMembersByName(entity.getSpecialNameOrName(), 255 /* All */).filter((m) => m.kind === 1 /* Function */);
         if (members.length === 0) {
           return void 0;
         } else if (members.length === 1) {
@@ -10845,7 +10966,7 @@ var EntityFinder = class {
     switch (entity.kind) {
       case 1 /* Function */:
         return entity.getParameters();
-      case 5 /* Indexer */:
+      case 3 /* Indexer */:
         return entity.getParameters();
       case 2 /* Type */: {
         if (entity.typeEntityKind === 0 /* Function */) {
@@ -10854,14 +10975,12 @@ var EntityFinder = class {
         return void 0;
       }
       case 0 /* Variable */:
-      case 3 /* Getter */:
-      case 4 /* Setter */:
-      case 7 /* PackageAlias */:
-      case 9 /* Package */:
-      case 8 /* TypeExtension */:
-      case 6 /* DereferenceOperator */:
+      case 5 /* PackageAlias */:
+      case 7 /* Package */:
+      case 6 /* TypeExtension */:
+      case 4 /* DereferenceOperator */:
         return void 0;
-      case 10 /* TextTranslation */:
+      case 8 /* TextTranslation */:
         return void 0;
       default:
         Debug.never(entity);
@@ -10877,15 +10996,13 @@ var EntityFinder = class {
         }
         return void 0;
       }
-      case 5 /* Indexer */:
-      case 6 /* DereferenceOperator */:
+      case 3 /* Indexer */:
+      case 4 /* DereferenceOperator */:
       case 0 /* Variable */:
-      case 3 /* Getter */:
-      case 4 /* Setter */:
-      case 7 /* PackageAlias */:
-      case 9 /* Package */:
-      case 8 /* TypeExtension */:
-      case 10 /* TextTranslation */:
+      case 5 /* PackageAlias */:
+      case 7 /* Package */:
+      case 6 /* TypeExtension */:
+      case 8 /* TextTranslation */:
         return void 0;
       default:
         Debug.never(entity);