fix: Replace accessor shadowing with reserved names in collision resolution

Instead of skipping field accessors that collide with slice/extension names,
treat field names as reserved during collision resolution so slices/extensions
get bumped to qualified names. All field accessors are now always generated.

Author: ryukzak

src/api/writer-generator/typescript/profile.ts

@@ -14,7 +14,6 @@ import {
 } from "@root/typeschema/types";
 import type { TypeSchemaIndex } from "@root/typeschema/utils";
 import {
-    tsCamelCase,
     tsExtensionFlatTypeName,
     tsFieldName,
     tsModulePath,
@@ -555,11 +554,7 @@ const generateFactoryMethods = (
     w.line();
 };
 
-const generateFieldAccessors = (
-    w: TypeScript,
-    factoryInfo: ProfileFactoryInfo,
-    extSliceMethodBaseNames: Set<string>,
-) => {
+const generateFieldAccessors = (w: TypeScript, factoryInfo: ProfileFactoryInfo) => {
     w.line("// Field accessors");
     for (const p of factoryInfo.params) {
         const methodBaseName = uppercaseFirstLetter(p.name);
@@ -574,10 +569,8 @@ const generateFieldAccessors = (
         w.line();
     }
 
-    // Getter and setter methods for choice instance fields (skip if extension/slice has same name)
     for (const a of factoryInfo.accessors) {
-        const methodBaseName = uppercaseFirstLetter(tsCamelCase(a.name));
-        if (extSliceMethodBaseNames.has(methodBaseName)) continue;
+        const methodBaseName = uppercaseFirstLetter(a.name);
         const fieldAccess = tsFieldName(a.name);
         w.curlyBlock([`get${methodBaseName}`, "()", `: ${a.tsType} | undefined`], () => {
             w.lineSM(`return ${tsGet("this.resource", fieldAccess)} as ${a.tsType} | undefined`);
@@ -721,18 +714,6 @@ const generateFlatInputType = (w: TypeScript, flatProfile: ProfileTypeSchema) =>
     w.line();
 };
 
-/** Collect all resolved base names (extensions + slices) for field accessor dedup. */
-const collectAllBaseNames = (flatProfile: ProfileTypeSchema, sliceDefs: SliceDef[]): Set<string> => {
-    const names = new Set<string>();
-    for (const ext of flatProfile.extensions ?? []) {
-        if (ext.url) names.add(ext.nameCandidates.recommended);
-    }
-    for (const slice of sliceDefs) {
-        names.add(slice.baseName);
-    }
-    return names;
-};
-
 export const generateProfileClass = (w: TypeScript, tsIndex: TypeSchemaIndex, flatProfile: ProfileTypeSchema) => {
     const tsBaseResourceName = tsTypeFromIdentifier(flatProfile.base);
     const profileClassName = tsProfileClassName(flatProfile);
@@ -750,16 +731,14 @@ export const generateProfileClass = (w: TypeScript, tsIndex: TypeSchemaIndex, fl
     const canonicalUrl = flatProfile.identifier.url;
     w.comment("CanonicalURL:", canonicalUrl, `(pkg: ${packageMetaToFhir(packageMeta(flatProfile))})`);
 
-    const allBaseNames = collectAllBaseNames(flatProfile, sliceDefs);
-
     w.curlyBlock(["export", "class", profileClassName], () => {
         w.lineSM(`static readonly canonicalUrl = ${JSON.stringify(canonicalUrl)}`);
         w.line();
         generateStaticSliceFields(w, sliceDefs);
         w.lineSM(`private resource: ${tsBaseResourceName}`);
         w.line();
         generateFactoryMethods(w, tsIndex, flatProfile, factoryInfo);
-        generateFieldAccessors(w, factoryInfo, allBaseNames);
+        generateFieldAccessors(w, factoryInfo);
 
         w.line("// Extensions");
         generateExtensionMethods(w, tsIndex, flatProfile);

src/typeschema/core/name-candidates.ts

@@ -42,24 +42,26 @@ const sliceCandidates = (fieldName: string, sliceName: string): string[] => {
 
 type NameEntry = { key: string; candidates: string[] };
 
-const countBy = (entries: NameEntry[], level: number): Record<string, number> =>
+const countBy = (entries: NameEntry[], level: number, reserved: Set<string>): Record<string, number> =>
     entries.reduce(
         (counts, e) => {
             const name = e.candidates[level] ?? "";
             counts[name] = (counts[name] ?? 0) + 1;
+            if (reserved.has(name)) counts[name] = (counts[name] ?? 0) + 1;
             return counts;
         },
         {} as Record<string, number>,
     );
 
 /** Resolve naming collisions across multiple levels of candidates.
- *  Each entry provides candidate names in priority order (e.g. base → qualified → discriminated). */
-const resolveNameCollisions = (entries: NameEntry[]): Record<string, string> => {
+ *  Each entry provides candidate names in priority order (e.g. base → qualified → discriminated).
+ *  Names in `reserved` are treated as taken — entries colliding with them are bumped to the next level. */
+const resolveNameCollisions = (entries: NameEntry[], reserved: Set<string>): Record<string, string> => {
     const levels = entries[0]?.candidates.length ?? 0;
 
     const resolve = (unresolved: NameEntry[], level: number): Record<string, string> => {
         if (unresolved.length === 0 || level >= levels) return {};
-        const counts = countBy(unresolved, level);
+        const counts = countBy(unresolved, level, reserved);
         const isLastLevel = level >= levels - 1;
         const [resolved, colliding] = unresolved.reduce(
             ([res, col], e) => {
@@ -87,6 +89,7 @@ export const mkSliceNameCandidates = (fieldName: string, sliceName: string): Nam
 };
 
 /** Resolve collisions across all extensions and slices within a profile.
+ *  Field accessor names are reserved — slices/extensions are bumped to avoid them.
  *  Mutates `nameCandidates.recommended` on each extension/slice in place. */
 export const assignRecommendedBaseNames = (profile: ProfileTypeSchema): void => {
     const extensionEntries: NameEntry[] = (profile.extensions ?? [])
@@ -104,10 +107,13 @@ export const assignRecommendedBaseNames = (profile: ProfileTypeSchema): void =>
         }));
     });
 
+    // Field names are reserved so slices/extensions avoid colliding with field accessors
+    const reservedNames = new Set(Object.keys(profile.fields ?? {}).map(normalizeCamelName));
+
     const allEntries = [...extensionEntries, ...sliceEntries];
     if (allEntries.length === 0) return;
 
-    const resolved = resolveNameCollisions(allEntries);
+    const resolved = resolveNameCollisions(allEntries, reservedNames);
 
     for (const ext of profile.extensions ?? []) {
         if (!ext.url) continue;