ucn 5.2.0 → 5.2.1

package/.claude/skills/ucn/SKILL.md

@@ -59,6 +59,12 @@ For caller-bearing `show`, `impact`, `trace`, `tests`, and `check` views:
 - `WARNING` identifies unreadable, unparsed, or partially indexed files, and lists unsupported-language occurrence sites (file:line plus the line text) so nothing grep would show is hidden. `usages` and `tests` carry the same disclosure as a note.
 - `FILTERED` means query options hid evidence.
 
+When the selected definition is a property/getter/setter, `impact` adds a
+separate `PROPERTY ACCESS SITES` band. Confirmed reads/writes have receiver
+identity; matching attribute syntax with an unresolved receiver stays
+unverified. These are change dependencies, not fabricated caller edges, so
+the caller `ACCOUNT` remains a call-shaped partition.
+
 An observed-text zero is not semantic zero or safe-delete proof. Numeric evidence values are ordinal ranking weights, not probabilities.
 
 When a plain name selects more than one definition, action-oriented commands
@@ -101,7 +107,7 @@ definition as an implicit repository-wide target.
 
 ## Deletion protocol
 
-Treat `deadcode` as a candidate generator. Before deletion, inspect `usages`, `impact`, `entrypoints`, `api`, and `repo --sections=health --deep`; then corroborate with the compiler/type checker and tests. Computed dispatch such as `handlers[key]()` is a reported blind spot; registry members reached by a modeled computed receiver are withheld. Unknown decorators/annotations and member-assigned event handlers are also withheld by default because they can be the registration itself. All remaining candidates are still review-only. Never delete solely from `deadcode` or an observed-text-zero result.
+Treat `deadcode` as a candidate generator. Before deletion, inspect `usages`, `impact`, `entrypoints`, `api`, and `repo --sections=health --deep`; then corroborate with the compiler/type checker and tests. Computed dispatch such as `handlers[key]()` is a reported blind spot; registry members reached by a modeled computed receiver are withheld. Statically named reflection such as `getattr(obj, "run")` is positive liveness evidence, so every matching member spelling is withheld; recognized dynamic reflection is counted and warned because it cannot be attributed to one member. Unknown decorators/annotations and member-assigned event handlers are also withheld by default because they can be the registration itself. All remaining candidates are still review-only. Never delete solely from `deadcode` or an observed-text-zero result.
 
 `usages` includes comment/string/docstring occurrences in an `OTHER TEXT` section unless
 `--code-only` is set. This is a literal-name inventory, not exact target
@@ -122,8 +128,16 @@ imports/exports, Python `__all__` strings, and module-attribute references.
 Exact token/expression spans keep a foreign same-named occurrence on the same
 line unchanged. Open external interfaces, incomplete ownership, unresolved
 dispatch, or an inexact token route to `needsReview` instead of a synthesized
-edit. Read `changeSummary` and every review item. `plan` previews only: it does
-not modify files, run a compiler, or prove runtime compatibility.
+edit. Comment/string occurrences in indexed source appear in `reviewItems` and
+are never rewritten automatically; the result also tells you to search
+documentation, configuration, generated files, and unsupported languages for
+the old spelling. Read `changeSummary` and every review item. `plan` previews
+only: it does not modify files, run a compiler, or prove runtime compatibility.
+
+For `deps --cycles`, `eager` means every edge executes at module scope.
+`deferred` means at least one Python edge is function-local, so the chain is
+not an unconditional import-time cycle; it remains visible because invoking
+that function during initialization can still matter.
 
 ## Efficient use
 

package/.claude/skills/ucn/references/commands.md

@@ -22,17 +22,17 @@ structural or code-only search.
 
 | Command | Purpose |
 |---|---|
-| `impact [handle]` | Show direct symbol impact when given a handle; without one, analyze the Git diff. |
+| `impact [handle]` | Show direct symbol impact when given a handle; accessor targets include receiver-tiered property reads/writes as a separate dependency band. Without a handle, analyze the Git diff. |
 | `tests <handle\|file>` | Find statically linked direct tests. Set `--depth=N` for transitive affected tests. Empty results are not runtime coverage proof. |
 | `check [handle]` | Validate confirmed call-site arity for a symbol; without one, run the composed pre-commit diagnostic. |
-| `plan <handle>` | Preview `--rename-to`, `--add-param`, or `--remove-param` edits. For renames, the proven closure can include overload/signature groups, inheritance/trait/Go-interface slots, exact call/reference tokens, imports/exports, Python `__all__` strings, and module-attribute references. Open ownership or method sets stay `needsReview`; the command never applies or compiles edits. |
+| `plan <handle>` | Preview `--rename-to`, `--add-param`, or `--remove-param` edits. For renames, the proven closure can include overload/signature groups, inheritance/trait/Go-interface slots, accessor reads/writes, exact call/reference tokens, imports/exports, Python `__all__` strings, and module-attribute references. Source comments/strings are explicit `reviewItems`; non-source files get a search handoff. Open ownership or method sets stay `needsReview`; the command never applies or compiles edits. |
 
 ## Repository and architecture
 
 | Command | Purpose |
 |---|---|
 | `repo` | Repository orientation. Select `summary,files,stats,health` with `--sections`; `--deep` includes readiness evidence. Skipped unsupported source is listed with a grep/language-tool handoff. |
-| `deps <file>` | File dependency graph. Use `--direction=imports\|importers\|both`, `--detailed`, or `--cycles`. |
+| `deps <file>` | File dependency graph. Use `--direction=imports\|importers\|both`, `--detailed`, or `--cycles`. Python cycles are classified as eager or function-local/deferred without dropping either kind. |
 | `api [file]` | Static exported/public surface for a project or file. |
 | `entrypoints` | Framework, route, task, test, and runtime entry points. |
 | `endpoints` | Server/client HTTP surface; `--bridge` adds advisory matching. |
@@ -41,7 +41,7 @@ structural or code-only search.
 
 | Command | Purpose |
 |---|---|
-| `deadcode` | Conservative unreferenced-symbol candidates for review. Modeled computed-dispatch members, unknown decorated/annotated callables, and member-assigned event handlers are withheld by default. |
+| `deadcode` | Conservative unreferenced-symbol candidates for review. Statically named reflection targets, modeled computed-dispatch members, unknown decorated/annotated callables, and member-assigned event handlers are withheld by default. Recognized dynamic reflection is counted and warned because it cannot be attributed. |
 | `audit-async` | Potential missing-await sites in JavaScript/TypeScript/Python and C#. MCP spelling: `audit_async`. |
 | `stacktrace <text>` | Advisory stack-frame parsing and source lookup. |
 

package/README.md

@@ -287,7 +287,7 @@ SIGNATURE CHANGE:
 
 CHANGES NEEDED: 12
   Files affected: 5
-  Definition 1, calls/references 7, imports 4, exports 0; manual review required for 0 of these changes
+  Definition 1, calls 7, references 0, text dependencies 0, imports 4, exports 0; manual review items 0
 
 BY FILE:
 
@@ -306,12 +306,16 @@ For a rename, `plan` closes the change over every relationship the index can
 prove: overload/signature groups, base and override declarations, Rust trait
 slots, Go interface slots and their satisfiers, exact call and value-reference
 tokens, imports/exports, Python `__all__` strings, and module-attribute
-references. It edits exact token or expression spans, so another same-named
-call on the same line is not swept up accidentally.
+references. Accessor renames also follow receiver-proven property reads and
+writes. It edits exact token or expression spans, so another same-named call
+on the same line is not swept up accidentally.
 
 Open external interfaces, incomplete ownership, unresolved dispatch, or an
 inexact token are marked `needsReview` instead of receiving a synthesized
-edit. `plan` previews changes; it does not modify files or replace the
+edit. Comments and strings in indexed source appear as separate review items
+and are never rewritten automatically; documentation, configuration,
+generated files, and unsupported languages get an explicit exact-text search
+handoff. `plan` previews changes; it does not modify files or replace the
 compiler and test suite. Before committing, point the same machinery at your
 Git diff:
 
@@ -408,7 +412,10 @@ Three claims, and every one is re-checked against rust-analyzer in CI: a
 default-audit claim with an oracle-visible reference fails the build. Notice
 what it *didn't* claim: exported API that external code may call,
 framework-registered symbols, and anything whose name appears in files UCN
-couldn't parse. `deadcode` is deliberately a candidate generator. Before
+couldn't parse. A literal reflection target such as `getattr(obj, "run")`
+also withholds matching member names from deletion candidates; recognized
+dynamic reflection is counted and warned because it cannot be attributed.
+`deadcode` is deliberately a candidate generator. Before
 deleting, corroborate with `usages`, `impact`, `api`, and your compiler and
 tests.
 
@@ -426,6 +433,11 @@ ucn entrypoints --type=http            # runtime and framework roots
 ucn endpoints --bridge --unmatched     # server routes with no client, and vice versa
 ```
 
+Cycle output separates eager import-time loops from Python chains containing
+a function-local/deferred edge. Deferred chains stay visible—they are not
+unconditional import-time cycles, but can still fail if invoked while modules
+are initializing.
+
 `endpoints --bridge` matches server routes to client requests across
 languages: Express/Fastify/Koa/NestJS/Next.js, Flask/FastAPI, Spring/JAX-RS,
 Go net/http (Gin/Echo/Chi/Fiber), axum/actix-web, and ASP.NET on the server

package/core/accessors.js

@@ -0,0 +1,183 @@
+'use strict';
+
+const path = require('path');
+const { codeUnitCompare } = require('./shared');
+
+// Descriptors/properties are consumed through reads and writes, not only
+// call syntax. Keep this vocabulary shared by impact and refactoring so the
+// two commands cannot disagree about whether a selected symbol is an accessor.
+const ACCESSOR_KINDS = new Set([
+    'property', 'setter', 'deleter', 'get', 'set',
+    'static get', 'static set', 'override get', 'override set',
+    'static override get', 'static override set',
+]);
+
+function isAccessorDefinition(definition) {
+    return !!definition && (ACCESSOR_KINDS.has(definition.type) ||
+        ACCESSOR_KINDS.has(definition.memberType));
+}
+
+function ownerName(definition) {
+    if (definition.className) return definition.className;
+    if (!definition.receiver) return null;
+    return String(definition.receiver)
+        .replace(/^[*&]\s*/, '')
+        .replace(/^mut\s+/, '')
+        .replace(/<.*$/, '')
+        .trim() || null;
+}
+
+function bareTypeName(value) {
+    if (!value) return null;
+    return String(value)
+        .replace(/^(?:typing\.)?(?:Optional|Annotated|Final)\s*\[/, '')
+        .replace(/[<[(].*$/s, '')
+        .split(/\.|::/).pop()
+        .replace(/[?*&\s]/g, '') || null;
+}
+
+function typeMatchesOwner(index, typeName, contextFile, owner, ownerFile) {
+    const bare = bareTypeName(typeName);
+    if (!bare || !owner || bare !== owner) return false;
+    const resolved = index._resolveClassFile?.(bare, contextFile);
+    if (resolved) return path.resolve(resolved) === path.resolve(ownerFile);
+    const ownerDefs = (index.symbols.get(owner) || []).filter(symbol =>
+        ['class', 'struct', 'interface', 'trait', 'record'].includes(symbol.type));
+    return ownerDefs.length === 1 &&
+        path.resolve(ownerDefs[0].file) === path.resolve(ownerFile);
+}
+
+function insideSelectedAccessorBody(index, name, definition, file, line) {
+    return (index.symbols.get(name) || []).some(candidate =>
+        isAccessorDefinition(candidate) &&
+        candidate.file === definition.file &&
+        candidate.className === definition.className &&
+        file === candidate.file &&
+        line >= candidate.startLine &&
+        line <= (candidate.endLine || candidate.startLine));
+}
+
+/**
+ * Find reads/writes that may consume a selected accessor. Confirmed entries
+ * require receiver identity (`self`/`this` in the owner or a Python instance
+ * field whose constructor assignment proves the owner type). Everything else
+ * remains visible in the unverified tier; accessor identity is never guessed
+ * from the spelling alone.
+ */
+function findAccessorReferences(index, name, definition, options = {}) {
+    if (!isAccessorDefinition(definition)) return null;
+    const owner = ownerName(definition);
+    if (!owner) return null;
+
+    const confirmed = [];
+    const unverified = [];
+    const excluded = [];
+    // Use the parser's raw occurrence records rather than usages()' public
+    // line-oriented inventory. A line can contain two same-spelled member
+    // accesses with different receivers; collapsing them by file+line would
+    // make a rename edit one token while silently losing the other.
+    const refs = [];
+    for (const [file, entry] of index.files) {
+        if (!index.matchesFilters(entry.relativePath, options)) continue;
+        let content;
+        let occurrences;
+        try {
+            content = index._readFile(file);
+            if (!content.includes(name)) continue;
+            occurrences = index._getCachedUsages(file, name);
+        } catch { continue; }
+        if (!occurrences) continue;
+        const lines = content.split('\n');
+        for (const usage of occurrences) {
+            if (usage.usageType !== 'reference') continue;
+            refs.push({
+                ...usage,
+                file,
+                relativePath: entry.relativePath,
+                content: lines[usage.line - 1] || '',
+            });
+        }
+    }
+
+    for (const ref of refs) {
+        const rel = ref.relativePath || path.relative(index.root, ref.file);
+        const shaped = {
+            file: rel,
+            absoluteFile: ref.file,
+            line: ref.line,
+            expression: (ref.content || '').trim(),
+            ...(Number.isInteger(ref.column) && { column: ref.column }),
+            ...(ref.receiver && { receiver: ref.receiver }),
+        };
+
+        // A backing-store attribute inside the selected getter/setter body
+        // often has the same spelling (`self._local.value`). It is not a
+        // consumption of the descriptor being queried.
+        if (insideSelectedAccessorBody(index, name, definition, ref.file, ref.line) &&
+            !['self', 'cls', 'this'].includes(ref.receiver)) {
+            excluded.push({ ...shaped, reason: 'accessor-definition-body' });
+            continue;
+        }
+
+        const enclosing = index.findEnclosingFunction(ref.file, ref.line, true);
+        const receiver = ref.receiver || null;
+        if (receiver && ['self', 'cls', 'this'].includes(receiver) &&
+            enclosing?.className === owner && enclosing.file === definition.file) {
+            confirmed.push({
+                ...shaped,
+                callerName: enclosing.name,
+                resolution: 'same-class-accessor',
+                tier: 'confirmed',
+            });
+            continue;
+        }
+
+        let receiverType = ref.receiverType || null;
+        if (!receiverType && receiver && enclosing?.className) {
+            receiverType = index.getInstanceAttributeTypes(
+                ref.file, enclosing.className)?.get(receiver) || null;
+        }
+        if (receiverType && typeMatchesOwner(
+            index, receiverType, ref.file, owner, definition.file)) {
+            confirmed.push({
+                ...shaped,
+                callerName: enclosing?.name || null,
+                receiverType,
+                resolution: 'receiver-field-type',
+                tier: 'confirmed',
+            });
+            continue;
+        }
+        if (receiver && typeMatchesOwner(index, receiver, ref.file, owner, definition.file)) {
+            confirmed.push({
+                ...shaped,
+                callerName: enclosing?.name || null,
+                receiverType: receiver,
+                resolution: 'type-qualified-accessor',
+                tier: 'confirmed',
+            });
+            continue;
+        }
+
+        unverified.push({
+            ...shaped,
+            callerName: enclosing?.name || null,
+            ...(receiverType && { receiverType }),
+            reason: receiverType ? 'receiver-type-mismatch' :
+                receiver ? 'receiver-type-unresolved' : 'nested-receiver-unresolved',
+            tier: 'unverified',
+        });
+    }
+
+    const sort = (a, b) => codeUnitCompare(a.file, b.file) || a.line - b.line;
+    confirmed.sort(sort);
+    unverified.sort(sort);
+    excluded.sort(sort);
+    return { owner, confirmed, unverified, excluded };
+}
+
+module.exports = {
+    ACCESSOR_KINDS,
+    isAccessorDefinition,
+    findAccessorReferences,
+};

package/core/analysis.js

@@ -18,6 +18,7 @@ const { isTestFile } = require('./discovery');
 const { computeReachability, symbolKey } = require('./entrypoints');
 const { getLanguageAdapter } = require('../languages');
 const { projectComputedDispatch } = require('./ast-analysis');
+const { findAccessorReferences } = require('./accessors');
 
 // JS/TS test framework helpers — calls to these bracket a test case.
 // Used to flag call sites whose enclosing function is an arrow callback
@@ -1235,6 +1236,40 @@ function impact(index, name, options = {}) {
         });
     }
 
+    // Accessors are consumed through reads/writes. They are intentionally a
+    // separate dependency band rather than fake caller edges: the caller
+    // oracle and conservation account remain call-shaped, while impact no
+    // longer hides the normal use form of a property/getter/setter.
+    let propertyAccesses = findAccessorReferences(index, name, def, {
+        includeTests: true,
+        exclude: options.exclude,
+    });
+    if (propertyAccesses) {
+        const accessByFile = new Map();
+        for (const site of propertyAccesses.confirmed) {
+            if (!accessByFile.has(site.file)) accessByFile.set(site.file, []);
+            accessByFile.get(site.file).push(site);
+        }
+        propertyAccesses = {
+            owner: propertyAccesses.owner,
+            confirmedCount: propertyAccesses.confirmed.length,
+            unverifiedCount: propertyAccesses.unverified.length,
+            totalCandidates: propertyAccesses.confirmed.length +
+                propertyAccesses.unverified.length,
+            byFile: [...accessByFile.entries()]
+                .sort((a, b) => codeUnitCompare(a[0], b[0]))
+                .map(([file, sites]) => ({ file, count: sites.length, sites })),
+            unverifiedSites: propertyAccesses.unverified,
+            excluded: {
+                total: propertyAccesses.excluded.length,
+                byReason: propertyAccesses.excluded.reduce((out, site) => {
+                    out[site.reason] = (out[site.reason] || 0) + 1;
+                    return out;
+                }, {}),
+            },
+        };
+    }
+
     // Apply top limit if specified (limits total call sites shown)
     const totalBeforeLimit = filteredSites.length;
     if (options.top && options.top > 0 && filteredSites.length > options.top) {
@@ -1276,6 +1311,12 @@ function impact(index, name, options = {}) {
         }
     }
 
+    const affectedFiles = new Set([
+        ...Array.from(byFile.keys()),
+        ...(propertyAccesses?.byFile || []).map(group => group.file),
+        ...(propertyAccesses?.unverifiedSites || []).map(site => site.file),
+    ]);
+
     return {
         function: name,
         file: def.relativePath,
@@ -1286,6 +1327,11 @@ function impact(index, name, options = {}) {
         totalCallSites: totalBeforeLimit,
         shownCallSites: filteredSites.length,
         unverifiedSites,
+        ...(propertyAccesses && {
+            propertyAccesses,
+            totalDependencySites: totalBeforeLimit + propertyAccesses.confirmedCount,
+            affectedFiles: affectedFiles.size,
+        }),
         account: impactAccount,
         hasEntrypoints: !!impactReachable && impactReachable.size > 0,
         callerHistogram,

package/core/ast-analysis.js

@@ -181,6 +181,108 @@ function computedReceiver(callee) {
     return node?.type === 'identifier' ? node.text : null;
 }
 
+const STRING_LITERAL_NODES = new Set([
+    'string', 'string_literal', 'raw_string_literal',
+    'interpreted_string_literal', 'verbatim_string_literal',
+]);
+
+function literalStringValue(node) {
+    if (!node || !STRING_LITERAL_NODES.has(node.type)) return null;
+    const content = (node.namedChildren || []).find(child =>
+        child.type === 'string_content' || child.type === 'interpreted_string_literal_content');
+    if (content) return content.text;
+    const raw = String(node.text || '');
+    const first = raw.search(/["']/);
+    if (first < 0) return null;
+    const quote = raw[first];
+    const triple = raw.slice(first, first + 3) === quote.repeat(3);
+    const width = triple ? 3 : 1;
+    if (!raw.endsWith(quote.repeat(width))) return null;
+    const value = raw.slice(first + width, -width);
+    // Escaped/interpolated member names are not a stable static spelling.
+    if (value.includes('\\') || value.includes('{') || value.includes('$')) return null;
+    return value;
+}
+
+function callShape(node) {
+    if (!['call', 'call_expression', 'invocation_expression',
+        'method_invocation'].includes(node.type)) return null;
+    const callee = node.childForFieldName('function') ||
+        node.childForFieldName('name') || node.namedChild(0);
+    const args = node.childForFieldName('arguments') ||
+        (node.namedChildren || []).find(child =>
+            ['argument_list', 'arguments', 'bracketed_argument_list'].includes(child.type));
+    return callee && args ? { callee, args: args.namedChildren || [] } : null;
+}
+
+/**
+ * Extract recognized reflection operations and classify whether their member
+ * target is a stable literal. Literal targets are positive liveness evidence;
+ * dynamic targets cannot identify one member but must still be disclosed by
+ * deletion-oriented commands.
+ */
+function reflectionSites(content, language) {
+    try {
+        const syntaxHints = {
+            python: ['getattr', 'setattr', 'hasattr', 'delattr'],
+            javascript: ['Reflect.'],
+            typescript: ['Reflect.'],
+            tsx: ['Reflect.'],
+            go: ['MethodByName', 'FieldByName'],
+            java: ['getMethod', 'getDeclaredMethod', 'getField', 'getDeclaredField'],
+            csharp: ['GetMethod', 'GetProperty', 'GetField'],
+        }[language];
+        if (!syntaxHints || !syntaxHints.some(hint => content.includes(hint))) {
+            return [];
+        }
+        const parser = getParser(language);
+        if (!parser) return [];
+        const tree = safeParse(parser, content);
+        const sites = [];
+        walkNamed(tree.rootNode, node => {
+            const call = callShape(node);
+            if (!call) return true;
+            const callee = String(call.callee.text || '');
+            let argIndex = null;
+            let kind = null;
+            if (language === 'python' &&
+                ['getattr', 'setattr', 'hasattr', 'delattr'].includes(callee)) {
+                argIndex = 1;
+                kind = callee;
+            } else if (['javascript', 'typescript', 'tsx'].includes(language) &&
+                /^(?:globalThis\.)?Reflect\.(?:get|set|has|deleteProperty)$/.test(callee)) {
+                argIndex = 1;
+                kind = callee.split('.').pop();
+            } else if (language === 'go' &&
+                /\.(?:MethodByName|FieldByName)$/.test(callee)) {
+                argIndex = 0;
+                kind = callee.split('.').pop();
+            } else if (['java', 'csharp'].includes(language) &&
+                /(?:^|\.)(?:getMethod|getDeclaredMethod|getField|getDeclaredField|GetMethod|GetProperty|GetField)$/.test(callee)) {
+                argIndex = 0;
+                kind = callee.split('.').pop();
+            }
+            if (argIndex == null || !call.args[argIndex]) return true;
+            const name = literalStringValue(call.args[argIndex]);
+            sites.push({
+                ...(name && /^[A-Za-z_$][\w$]*$/.test(name) && { name }),
+                kind,
+                line: node.startPosition.row + 1,
+                expression: node.text,
+                dynamic: !name || !/^[A-Za-z_$][\w$]*$/.test(name),
+            });
+            return true;
+        });
+        return sites;
+    } catch (_) {
+        return [];
+    }
+}
+
+function literalReflectionSites(content, language) {
+    return reflectionSites(content, language).filter(site => !site.dynamic);
+}
+
 /**
  * Find direct computed dispatch calls such as handlers[name](). Literal keys
  * are excluded because they retain a statically visible member name.
@@ -276,4 +378,6 @@ module.exports = {
     computeAstComplexity,
     computedDispatchSites,
     projectComputedDispatch,
+    reflectionSites,
+    literalReflectionSites,
 };

package/core/cache.js

@@ -644,7 +644,11 @@ function clearAllCaches() {
 // symbols retain AST-derived parameter qualification/forwarding effects, so
 // replacement-list requalification cannot masquerade as lexical calls
 // (fix #306).
-const CACHE_FORMAT_VERSION = 188;
+// v189: Python import records retain function-local/deferred scope so cycle
+// reporting can classify import-time vs lazy edges from fresh and cached
+// indexes; C# properties retain property identity instead of masquerading as
+// ordinary fields for accessor impact/refactoring.
+const CACHE_FORMAT_VERSION = 189;
 
 /**
  * Save index to cache file

package/core/callers.js

@@ -10708,7 +10708,7 @@ function _declaredFieldType(index, rootType, fieldName, language, info, rootName
         d.type === 'property' || d.memberType === 'property';
     const fields = defs.filter(d =>
         ((d.type === 'field' || d.memberType === 'field' || d.memberType === 'private field') && d.fieldType) ||
-        (isAccessor(d) && d.returnType));
+        (isAccessor(d) && (d.returnType || d.fieldType)));
     let onType = fields.filter(d => d.className === rootType &&
         (language !== 'csharp' || !rootNamespace ||
             (d.namespace || null) === rootNamespace));
@@ -10767,7 +10767,7 @@ function _declaredFieldType(index, rootType, fieldName, language, info, rootName
     if (onType.length === 0) return null;
     const normalized = new Set();
     for (const f of onType) {
-        const rawText = isAccessor(f) ? f.returnType : f.fieldType;
+        const rawText = isAccessor(f) ? (f.returnType || f.fieldType) : f.fieldType;
         // Qualified declared types resolve through the FIELD-DECLARING file's
         // imports or not at all (fix #268, chi-measured — the #206 identity
         // discipline): `inner http.Handler` is net/http's Handler, never a
@@ -10824,7 +10824,8 @@ function _declaredFieldType(index, rootType, fieldName, language, info, rootName
                 complete = false;
                 break;
             }
-            const rawText = isAccessor(field) ? field.returnType : field.fieldType;
+            const rawText = isAccessor(field)
+                ? (field.returnType || field.fieldType) : field.fieldType;
             const qualifier = language === 'java'
                 ? _javaNestedTypeQualifier(rawText) : undefined;
             if (qualifier) namespaces.add(qualifier);
@@ -10983,10 +10984,14 @@ function _nonCallableFieldMember(index, typeName, name, language) {
         (d.receiver && d.receiver.replace(/^\*/, '') === typeName));
     if (onType.length === 0) return false;
     for (const d of onType) {
-        if (d.type !== 'field' && d.memberType !== 'field' && d.memberType !== 'private field') return false;
-        if (!d.fieldType) return false;
+        const valueMember = d.type === 'field' || d.memberType === 'field' ||
+            d.memberType === 'private field' || d.type === 'property' ||
+            d.memberType === 'property';
+        if (!valueMember) return false;
+        const declaredType = d.fieldType || d.returnType;
+        if (!declaredType) return false;
         if (_callableFieldDef(index, d)) return false;
-        const raw = String(d.fieldType).trim();
+        const raw = String(declaredType).trim();
         if (/^func\b/.test(raw)) return false;
         if (/\bfn\s*\(|\b(?:Fn|FnMut|FnOnce)\s*[(<]/.test(raw)) return false;
         if (langTraits(language)?.typeSystem === 'structural') {
@@ -13455,7 +13460,8 @@ function _declaredFieldInterfaceType(index, rootType, fieldName, language, rootN
     const defs = index.symbols.get(fieldName);
     if (!defs) return null;
     const fields = defs.filter(d =>
-        (d.type === 'field' || d.memberType === 'field') &&
+        (d.type === 'field' || d.memberType === 'field' ||
+         d.type === 'property' || d.memberType === 'property') &&
         d.className === rootType && d.fieldType &&
         (language !== 'csharp' || !rootNamespace ||
             (d.namespace || null) === rootNamespace));