From 5603c8323fab62850cf02e4572a897a3ccf915fa Mon Sep 17 00:00:00 2001
From: Colby McHenry <me@colbymchenry.com>
Date: Mon, 5 Oct 2026 15:52:51 -0500
Subject: [PATCH] fix(dart): link getter reads, enum-extension members and more
 type positions (#2338, #2327)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Issue #2338: a Dart getter read (`x.area`, `s.label`) linked nothing, so
`codegraph callers area` was empty while `x.grow()` worked, and a member
an extension adds to an ENUM (`s.shout()` through `extension ShapeInfo on
Shape`) never resolved. Issue #2327: `callers Report` saw only parameter
and return types; the type an extension is `on`, field types, and types
named in bodies and initializers (`Future<Report?>.value(null)`, riverpod's
`final reportProvider = Family<Report?, String>()`) recorded nothing.

Causes:
- The Dart body walker only emitted calls (a selector with an argument
  list); a member read is a selector without one, so it produced no ref.
- For a typed receiver, resolveMethodOnType looks for `Type::member` and
  the type's supertype edges; an extension's member is `ShapeInfo::shout`.
  On a class receiver the call fell through to name matching, which found
  a unique `twice` by luck; on an enum the "type the project doesn't
  declare" guard (it only counts classes) returned null.
- Type references were taken from function and method signatures only.

Fix (TS extractor and the Rust kernel, mirrored):
- A member read `x.area` / `x?.area` / `Type.getter` whose receiver is a
  plain name, and that is not a call, is sent as a `references` ref named
  `x.area` on the member. The resolver (matchDartMemberRead, ahead of
  every other strategy) types the receiver — a static read through a
  project type, a parameter or local in scope, else a field of the
  enclosing class — and links the getter that type reaches: declared on
  it or a type it extends, mixes in or implements, else added by an
  extension on one of those (an unnamed extension only in its own
  library). The edge is `calls`: a Dart getter is a method node, reading
  it runs it, and `calls` is what callers, impact and explore's flow
  follow (as Ruby's paren-less `x.area` and VB.NET's paren-less calls
  through #2355 already are). A field read, a getter of a type outside the
  project and an untyped receiver link nothing; there is no name-only
  fallback. Kotlin/Swift/C#/TS link no instance property reads today.
- resolveMethodOnType, for Dart, falls back to a member an extension on
  the type (or a supertype) adds when no declaration of the type has it.
- `references` refs for the type an extension is `on`, a field's declared
  type and initializer (from its class — Dart fields mint no nodes), an
  enum field, a top-level variable's type (from the file), a constant's
  initializer (from the constant), and every type a function body names:
  locals, generic arguments, casts, type tests, catch clauses. Skipped: a
  `new`/`const` constructor's class (already instantiates/calls), an
  import prefix (`p` in `p.Foo`), built-ins, and lowercase names, which in
  Dart are built-ins (`num`, `dynamic`) or error-recovery artifacts around
  syntax the grammar predates (dot shorthands). A class whose field holds
  its own type does not get a self-edge.

Verification: __tests__/dart-getter-reads.test.ts (7 tests) and
__tests__/dart-type-positions.test.ts (3 tests) fail 8/10 on main (both
the TS path and main's kernel) and pass on both arms here; the 2 that pass
on main are the controls. New kernel parity fixture TortureReadsTypes.dart
(+CRLF); kernel-dart-parity passes with CODEGRAPH_KERNEL_EXPECT=1, and
scripts/kernel-parity.mjs over bloc/riverpod/flutter-samples is 0 diffs
(2,103 files byte-parity, 300 parse-error files defer as before). tsc and
build clean; the issues' repros now list c/a/b for area/label/shout and
Holder, ReportX, reportProvider and run for Report.

Validation (kernel loaded, main vs this branch): nodes unchanged, 0 edges
removed, no new self-loops.
- felangel/bloc: 16,372 -> 18,276 edges (+550 getter-read calls, +1,354
  type references)
- rrousselGit/riverpod: 76,432 -> 81,909 (+598 getter reads, +13
  extension-method calls, +4,866 type references)
- flutter/samples: 26,133 -> 26,943 (+142 getter reads, +668 type refs)
Spot-checked 16 getter reads and 16 type references against source.
Index time within noise on riverpod (median of 5 interleaved runs); reads
that link nothing are kept for re-resolution like failed calls (riverpod
db 92.9 -> 103.2 MB).

No EXTRACTION_VERSION bump: it already moved to 28 this release.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 CHANGELOG.md                                  |   2 +
 __tests__/dart-getter-reads.test.ts           | 165 +++++++++++++++++
 __tests__/dart-type-positions.test.ts         | 126 +++++++++++++
 .../kernel-parity/TortureReadsTypes.dart      | 131 ++++++++++++++
 __tests__/kernel-dart-parity.test.ts          |   8 +-
 codegraph-kernel/src/dart.rs                  | 161 ++++++++++++++++-
 src/extraction/languages/dart.ts              | 118 ++++++++++++-
 src/extraction/tree-sitter-helpers.ts         |  21 +++
 src/extraction/tree-sitter-types.ts           |   9 +
 src/extraction/tree-sitter.ts                 |  62 +++++--
 src/resolution/index.ts                       |  10 +-
 src/resolution/name-matcher.ts                | 166 ++++++++++++++++++
 12 files changed, 958 insertions(+), 21 deletions(-)
 create mode 100644 __tests__/dart-getter-reads.test.ts
 create mode 100644 __tests__/dart-type-positions.test.ts
 create mode 100644 __tests__/fixtures/kernel-parity/TortureReadsTypes.dart

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 17cb9a1ff7..bad7889d0a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -31,6 +31,8 @@ and adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 - In VB.NET, reading or setting a `Shared` field or property through its class or module name, like `AppSession.SessionId`, `AppSession.CurrentUser = "demo"` or `AppSession.Items(0)`, now counts as a use of that member and of the class, and so do reading an `Enum` value like `Mode.Fast` and calling a `Shared` function without parentheses. Before, only calls written with parentheses were linked, so `codegraph callers` on such a field, property or class came back empty and impact missed most of the code that depends on it. A local, parameter or field that only shares a class's name is not mistaken for the class. Thanks @serkanince for the report and @ChrisPrapas. (#2305)
 - In Vue and Nuxt components, calls written in the template (`{{ formatDate(post) }}`, `:to="getAccountRoute(account)"`, `@click="save(item)"`) and calls in a destructuring declaration at the top of `<script setup>` or of a TypeScript or JavaScript file (`const { t } = useI18n()`) now link to the function they call, so `callers` and impact for a composable or helper used this way are no longer mostly empty. A `v-for` item or slot prop is never taken for a project function, a handler like `@click="open = false"` no longer links to an unrelated function of the same name, and a component's own function named like a Nuxt helper, such as `clearError`, is now the one its calls reach. Thanks @deniskern for the report, and @drakeo338 and @L0garithmic. (#2340)
 - In COBOL, asking `codegraph_explore` (or `codegraph explore` and `codegraph context`) about a copybook by name, such as `CVACT01Y` or a member brought in with `EXEC SQL INCLUDE`, now answers with the copybook's own source when it is indexed and every `COPY` or `EXEC SQL INCLUDE` statement that includes it, and says so when the copybook's source isn't part of the project. Before, it answered "No relevant code found", or showed an unrelated program whose name was a letter or two away. Thanks @popolusiak for the report. (#2342)
+- In Dart, reading a getter such as `box.area` or `status.label` now counts as calling it, so `codegraph callers` and impact list the code that reads it — whether the getter is declared on the class, inherited, or added by an extension — and a method an extension adds to an enum, like `shape.shout()`, now links as well. A plain field, a getter of a type from outside your project, or a value whose type isn't written down still links nothing. Re-index Dart projects after upgrading. Thanks @brookly255-lv for the report. (#2338)
+- In Dart, a type is now linked from more of the places it is written, not only from parameters and return types: the type an `extension … on` targets, a field's type, a top-level variable's type, generic arguments such as `Future<Report?>.value(null)` or Riverpod's `final reportProvider = Family<Report?, String>()`, and a local variable's type, a cast or a type check inside a function. So `callers` and impact for a model class now reach the extensions, models and providers that use it. Thanks @mg-mg-mg for the report. (#2327)
 
 ## [1.6.2] - 2026-10-03
 
diff --git a/__tests__/dart-getter-reads.test.ts b/__tests__/dart-getter-reads.test.ts
new file mode 100644
index 0000000000..ab6869858f
--- /dev/null
+++ b/__tests__/dart-getter-reads.test.ts
@@ -0,0 +1,165 @@
+/**
+ * Dart getter reads and extension members on enums (#2338).
+ *
+ * Reading a getter runs it: `x.area` calls `Box`'s `int get area`. A read
+ * linked to nothing, so `callers area` was empty while `x.grow()` worked. And
+ * a member an `extension … on` an ENUM adds (`s.shout()`) resolved nowhere,
+ * while the same extension on a class did.
+ *
+ * A read links only a getter the receiver's type reaches — never a field (they
+ * mint no nodes), a getter of a type outside the project, or a same-named
+ * getter guessed by name.
+ */
+import { describe, it, expect, afterAll, beforeAll } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { CodeGraph } from '../src';
+
+let root = '';
+let cg: CodeGraph;
+
+beforeAll(async () => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-dart-getters-'));
+  const files: Record<string, string> = {
+    'pubspec.yaml': 'name: repro\nenvironment:\n  sdk: ">=3.0.0 <4.0.0"\n',
+    // The issue's two files, verbatim.
+    'lib/shape.dart': `enum Shape { circle, square }
+
+extension ShapeInfo on Shape {
+  String get label => name.toUpperCase();
+  String shout() => name.toUpperCase();
+}
+
+class Box {
+  const Box(this.size);
+  final int size;
+  int get area => size * size;
+  int grow() => size + 1;
+}
+
+extension BoxActions on Box {
+  int twice() => size * 2;
+}
+`,
+    'lib/use.dart': `import 'shape.dart';
+
+String a(Shape s) => s.label;   // getter, extension on enum
+String b(Shape s) => s.shout(); // method, extension on enum
+int c(Box x) => x.area;         // getter, plain class
+int d(Box x) => x.grow();       // method, plain class
+int e(Box x) => x.twice();      // method, extension on class
+`,
+    // Block bodies and class methods, through a parameter, a local and a field.
+    'lib/render.dart': `import 'shape.dart';
+
+class Square extends Box {
+  const Square(int size) : super(size);
+  static Square get unit => const Square(1);
+}
+
+class Renderer {
+  final Box box;
+  final Shape shape;
+  Renderer(this.box, this.shape);
+
+  int paint(Box other) {
+    final local = Box(2);
+    return other.area + local.area;
+  }
+
+  int viaField() {
+    return box.area;
+  }
+
+  String tag() {
+    final text = shape.label;
+    return text + shape.shout();
+  }
+}
+
+int inherited(Square s) {
+  return s.area;
+}
+
+Square staticGetter() => Square.unit;
+`,
+    // Reads that must link nothing.
+    'lib/other.dart': `class Panel {
+  int get size => 0;
+  int get length => 0;
+}
+
+extension on Box {
+  int get hidden => 0;
+}
+`,
+    'lib/negatives.dart': `import 'shape.dart';
+
+int fieldRead(Box x) => x.size;           // a field, not Panel's getter
+int outside(List<int> xs) => xs.length;   // a getter of a type outside the project
+int untyped(dynamic d) => d.area;         // nothing says what d is
+int unnamed(Box x) => x.hidden;           // an unnamed extension in another library
+`,
+  };
+  for (const [rel, content] of Object.entries(files)) {
+    fs.mkdirSync(path.dirname(path.join(root, rel)), { recursive: true });
+    fs.writeFileSync(path.join(root, rel), content);
+  }
+  cg = await CodeGraph.init(root, { index: true });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+/** `kind name` of each caller of the node with qualified name `qn`, sorted. */
+function callersOf(qn: string): string[] {
+  const [target] = cg.getNodesByQualifiedName(qn);
+  expect(target, `no node ${qn}`).toBeDefined();
+  return cg.getCallers(target!.id).map(({ node, edge }) => `${edge.kind} ${node.qualifiedName}`).sort();
+}
+
+describe('Dart getter reads (#2338)', () => {
+  it('link a getter read on a plain class, as a call', () => {
+    expect(callersOf('Box::area')).toContain('calls c');
+  });
+
+  it('link a getter an extension on an enum adds', () => {
+    expect(callersOf('ShapeInfo::label')).toEqual(['calls Renderer::tag', 'calls a']);
+  });
+
+  it('link reads in block bodies and class methods, through parameters, locals and fields', () => {
+    expect(callersOf('Box::area')).toEqual([
+      'calls Renderer::paint',
+      'calls Renderer::viaField',
+      'calls c',
+      'calls inherited',
+    ]);
+  });
+
+  it('link a static getter read through its class', () => {
+    expect(callersOf('Square::unit')).toEqual(['calls staticGetter']);
+  });
+
+  it('link nothing for a field, an outside type, an untyped receiver or an out-of-library unnamed extension', () => {
+    const ids = cg.getNodesInFile('lib/negatives.dart').map((n) => n.id);
+    const targets = cg.getOutgoingEdgesFrom(ids, ['calls'])
+      .map((edge) => cg.getNode(edge.target)!.qualifiedName);
+    expect(targets).toEqual([]);
+    expect(callersOf('Panel::size')).toEqual([]);
+    expect(callersOf('Panel::length')).toEqual([]);
+  });
+});
+
+describe('Dart extension members on an enum (#2338)', () => {
+  it('resolve a method an extension on an enum adds', () => {
+    expect(callersOf('ShapeInfo::shout')).toEqual(['calls Renderer::tag', 'calls b']);
+  });
+
+  it('still resolve methods on a class and its extensions', () => {
+    expect(callersOf('Box::grow')).toEqual(['calls d']);
+    expect(callersOf('BoxActions::twice')).toEqual(['calls e']);
+  });
+});
diff --git a/__tests__/dart-type-positions.test.ts b/__tests__/dart-type-positions.test.ts
new file mode 100644
index 0000000000..79ead5c731
--- /dev/null
+++ b/__tests__/dart-type-positions.test.ts
@@ -0,0 +1,126 @@
+/**
+ * Dart type positions that recorded no reference (#2327).
+ *
+ * `callers` / impact for a Dart type only saw parameter and return types: the
+ * type an extension is `on`, a field's type, and a type named in a body or an
+ * initializer (`Future<Report?>.value(null)`, riverpod's `final p =
+ * Family<Report?, String>()`) linked nothing, so model-to-UI impact missed
+ * most uses of shared API types.
+ */
+import { describe, it, expect, afterAll, beforeAll } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { CodeGraph } from '../src';
+
+let root = '';
+let cg: CodeGraph;
+
+beforeAll(async () => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-dart-types-'));
+  const files: Record<string, string> = {
+    'pubspec.yaml': 'name: repro\nenvironment:\n  sdk: ">=3.0.0 <4.0.0"\n',
+    // The issue's six files, verbatim.
+    'lib/report.dart': 'class Report {\n  final int score;\n  const Report(this.score);\n}\n',
+    'lib/a_parameter.dart': "import 'report.dart';\n\nint score(Report r) => r.score;\n",
+    'lib/b_return_generic.dart': "import 'report.dart';\n\nFuture<Report?> load() async => null;\n",
+    'lib/c_extension_on.dart': "import 'report.dart';\n\nextension ReportX on Report {\n  bool get high => score > 5;\n}\n",
+    'lib/d_field_type.dart': "import 'report.dart';\n\nclass Holder {\n  final Report report;\n  const Holder(this.report);\n}\n",
+    'lib/e_toplevel_initializer_generic.dart': "import 'report.dart';\n\nclass Family<T, A> {\n  const Family();\n}\n\nfinal reportProvider = Family<Report?, String>();\n",
+    'lib/f_expression_generic.dart': "import 'report.dart';\n\nvoid run() {\n  Future<Report?>.value(null);\n}\n",
+    // The same gap's other shapes.
+    'lib/model.dart': `class Score {
+  const Score(this.value);
+  final int value;
+}
+
+class ScoreError implements Exception {}
+`,
+    'lib/more.dart': `import 'model.dart' as m;
+import 'model.dart';
+
+extension ScoresX on List<Score> {
+  int get total => length;
+}
+
+enum Grade {
+  a(null);
+  const Grade(this.best);
+  final Score? best;
+}
+
+class Board {
+  Score? top;
+  final List<Score> all = [];
+  static const Score zero = Score(0);
+  var cache = <String, Score>{};
+  late final m.Score prefixed;
+}
+
+Score? current;
+final scores = <Score>[];
+
+int body(Object o) {
+  final Score s = o as Score;
+  if (o is Score) {}
+  final made = Score(1);
+  final built = const Score(2);
+  try {} on ScoreError catch (_) {}
+  return s.value + made.value + built.value;
+}
+`,
+  };
+  for (const [rel, content] of Object.entries(files)) {
+    fs.mkdirSync(path.dirname(path.join(root, rel)), { recursive: true });
+    fs.writeFileSync(path.join(root, rel), content);
+  }
+  cg = await CodeGraph.init(root, { index: true });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+/** `kind qualifiedName` of each node with an incoming `kind` edge to `qn`, sorted and de-duplicated. */
+function referrers(qn: string, kind: 'references' | 'instantiates' = 'references'): string[] {
+  const [target] = cg.getNodesByQualifiedName(qn);
+  expect(target, `no node ${qn}`).toBeDefined();
+  const edges = cg.getIncomingEdgesTo([target!.id], [kind]);
+  return [...new Set(edges.map((e) => cg.getNode(e.source)!).map((n) => `${n.kind} ${n.qualifiedName}`))].sort();
+}
+
+describe('Dart type positions (#2327)', () => {
+  it('reference the type from every position in the issue', () => {
+    expect(referrers('Report')).toEqual([
+      'class Holder',              // field type
+      'class ReportX',             // extension target
+      'constant reportProvider',   // generic argument in a top-level initializer
+      'function load',             // return type's generic argument (already linked)
+      'function run',              // generic argument in an expression
+      'function score',            // parameter type (already linked)
+    ]);
+  });
+
+  it('reference the type from fields, enum fields, initializers, locals, casts, type tests and the file', () => {
+    expect(referrers('Score')).toEqual([
+      'class Board',               // field types, `<String, Score>{}`, the prefixed `m.Score`
+      'class ScoresX',             // `on List<Score>`
+      'enum Grade',                // an enhanced enum's field
+      'file lib/more.dart',        // a top-level variable's type
+      'function body',             // a local's type, a cast, a type test
+      'constant scores',           // `<Score>[]`
+    ].sort());
+    expect(referrers('ScoreError')).toEqual(['function body']);
+  });
+
+  it('leave a constructor call to its instantiation, and an import prefix out', () => {
+    // `Score(1)` / `const Score(2)` instantiate; they add no reference of their own.
+    const body = cg.getNodesByQualifiedName('body')[0]!;
+    const refs = cg.getOutgoingEdgesFrom([body.id], ['references']).filter((e) => cg.getNode(e.target)!.name === 'Score');
+    expect([...new Set(refs.map((e) => e.line))].sort()).toEqual([26, 27]);
+    expect(referrers('Score', 'instantiates')).toEqual(['function body']);
+    const prefixRefs = cg.getUnresolvedReferencesInFile('lib/more.dart').filter((r) => r.referenceName === 'm');
+    expect(prefixRefs).toEqual([]);
+  });
+});
diff --git a/__tests__/fixtures/kernel-parity/TortureReadsTypes.dart b/__tests__/fixtures/kernel-parity/TortureReadsTypes.dart
new file mode 100644
index 0000000000..c84e34e551
--- /dev/null
+++ b/__tests__/fixtures/kernel-parity/TortureReadsTypes.dart
@@ -0,0 +1,131 @@
+// Getter reads (#2338) and type positions outside signatures (#2327).
+import 'package:app/model.dart' as m;
+import 'package:app/model.dart';
+
+// The type an extension is `on`: plain, generic, prefixed, nullable.
+extension ReportX on Report {
+  bool get high => score > 5;
+}
+
+extension ListX<T extends Report> on List<T> {
+  int get total => length;
+}
+
+extension PrefixedX on m.Report? {
+  bool get present => this != null;
+}
+
+extension on Map<String, Report> {
+  int get size2 => length;
+}
+
+mixin Scored on Report {
+  int bump() => score + 1;
+}
+
+// Field declarations: instance, nullable, generic, static, late, prefixed,
+// function-typed, record-typed, untyped with a generic initializer.
+class Holder {
+  final Report report;
+  Report? maybe;
+  final List<Report> all = [];
+  static final Report fallback = Report(0);
+  static const List<Report> none = <Report>[];
+  late final m.Report prefixed;
+  final void Function(Report r)? onTap = null;
+  (Report, int)? pair;
+  var untyped = Family<Report?, String>();
+  final Map<String, List<Report>> byKey = {};
+  int count = 0, other = 1;
+
+  Holder(this.report);
+
+  Report get first => all.first;
+
+  int read(Holder h, Report r) {
+    final local = Holder(r);
+    return h.report.score + local.all.length + r.score + h.maybe!.score;
+  }
+}
+
+enum Grade {
+  a(null),
+  b(null);
+
+  const Grade(this.best);
+  final Report? best;
+  static const Grade top = Grade.a;
+  String get label => name;
+}
+
+// Top-level variables: typed, generic, function-typed, record-typed,
+// untyped with generic initializers, constants.
+Report? current;
+List<Report> history = [];
+void Function(Report)? listener;
+(Report, String) tagged = (Report(1), 'x');
+var plain = <Report>[];
+var counts = Map<String, Report>();
+final reportProvider = Family<Report?, String>();
+const empty = <Report>[];
+final handler = (Report r) => r.score;
+
+class Family<T, A> {
+  const Family();
+}
+
+class Config {
+  static Config get instance => Config();
+  String get name => 'cfg';
+  void load() {}
+}
+
+int reads(Holder h, Grade g, Report? r) {
+  // Plain and conditional reads, a static getter, an enum value.
+  final a = h.first;
+  final b = r?.score;
+  final c = Config.instance;
+  final d = Grade.top;
+  final e = g.label;
+  // Calls are not reads; the head of a chain is.
+  h.read(h, h.report);
+  Config.instance.load();
+  final f = h.report.score;
+  // Cascades, assignments and compound assignments are not reads.
+  h..maybe;
+  h.maybe = null;
+  h.count += 1;
+  // Reads inside interpolation, arguments, closures and nested functions.
+  print('${h.count} ${g.label}');
+  final cb = (Holder x) => x.first;
+  int nested(Holder y) {
+    final List<Report> rs = y.all;
+    return y.count + rs.length;
+  }
+  return nested(h) + cb(h).score + (a.score) + (b ?? 0) + c.name.length + d.index + e.length + f;
+}
+
+Object types(Object o) {
+  // Local types, generic arguments, casts, type tests, catch types,
+  // collection literals; constructor calls stay calls.
+  final Report local = o as Report;
+  List<Report> xs = <Report>[local];
+  final Map<String, Report> byName = {'a': local};
+  final ys = <Report>{};
+  if (o is Report) {}
+  if (o is! Holder) {}
+  final f = Future<Report?>.value(null);
+  final g = Family<Report, m.Report>();
+  final made = Report(1);
+  final built = const Report(2);
+  final old = new Holder(local);
+  final generic = Family<Report, int>();
+  // Positions after multi-byte text are UTF-16 columns on both arms.
+  final label = 'é😀'; final Report? again = local; final n = again?.score;
+  try {
+    throw StateError('x');
+  } on StateError catch (_) {
+  } on FormatException {
+  }
+  return [xs, byName, ys, f, g, made, built, old, generic, label, n];
+}
diff --git a/__tests__/kernel-dart-parity.test.ts b/__tests__/kernel-dart-parity.test.ts
index 812f9f8c6f..ad3396d833 100644
--- a/__tests__/kernel-dart-parity.test.ts
+++ b/__tests__/kernel-dart-parity.test.ts
@@ -20,7 +20,9 @@
  * capture channels incl. named-argument non-capture and the file/class
  * twins; TortureMini/TortureSigs/TortureCtors/TortureVrefDart: signatures
  * verbatim, prefixed-return-type prefix bug, const factories invisible,
- * value-ref matrix with `$X` vs `${X}` asymmetry) and their CRLF variants
+ * value-ref matrix with `$X` vs `${X}` asymmetry; TortureReadsTypes.dart:
+ * getter-read refs and the type positions outside signatures — #2338/#2327)
+ * and their CRLF variants
  * (derived in-memory — #1329), plus defer and generated-file pins.
  *
  * The full-repo sweeps live in scripts/kernel-parity.mjs (shelf/bloc/flutter
@@ -110,6 +112,10 @@ describe.skipIf(!kernelBuilt)('kernel Dart extraction parity', () => {
     ['TortureSigs.dart', 4],
     ['TortureCtors.dart', 3],
     ['TortureVrefDart.dart', 4],
+    // Getter reads (#2338) and type positions outside signatures (#2327):
+    // extension `on` types, field / enum-field / top-level types, constant and
+    // field initializers, body types, and the read shapes that are not reads.
+    ['TortureReadsTypes.dart', 20],
   ] as const;
 
   for (const [file, minNodes] of FIXTURES) {
diff --git a/codegraph-kernel/src/dart.rs b/codegraph-kernel/src/dart.rs
index 8faacf3684..9deb1cbfff 100644
--- a/codegraph-kernel/src/dart.rs
+++ b/codegraph-kernel/src/dart.rs
@@ -628,12 +628,61 @@ impl<'t> Walker<'t> {
                     }
                 });
                 let name = self.text(name_node).to_string();
-                self.create_node("constant", &name, node, Extra { signature, ..Default::default() });
+                let constant = self.create_node("constant", &name, node, Extra { signature, ..Default::default() });
+                // The types its initializer names are the constant's (#2327).
+                if let Some(constant) = constant {
+                    let mut value = name_node.next_named_sibling();
+                    while let Some(v) = value {
+                        self.type_refs_dart(v, constant);
+                        value = v.next_named_sibling();
+                    }
+                }
             }
             self.scan_fn_ref_subtree(node, 0);
             return;
         }
 
+        // A field's declared type and initializer types are its class's (Dart
+        // fields mint no nodes); a top-level variable's are the file's (#2327).
+        // The visitNode hook's `declaration` / `program` rows (dart.ts).
+        // (Parent lookups walk down from the root, so only the node kinds that
+        // can be these positions ask for theirs.)
+        if node.kind() == "declaration" {
+            let in_body = node
+                .parent()
+                .map(|p| matches!(p.kind(), "class_body" | "extension_body" | "enum_body"))
+                .unwrap_or(false);
+            let mut cursor = node.walk();
+            let kids: Vec<Node<'t>> = node.named_children(&mut cursor).collect();
+            let is_field = in_body
+                && kids
+                    .iter()
+                    .any(|c| matches!(c.kind(), "initialized_identifier_list" | "static_final_declaration_list"));
+            if is_field {
+                let owner = self.top_row();
+                for child in kids {
+                    match child.kind() {
+                        "initialized_identifier_list" => self.initializer_type_refs_dart(child, owner),
+                        "static_final_declaration_list" => {}
+                        _ => self.type_refs_dart(child, owner),
+                    }
+                }
+            }
+        } else {
+            let top_level_type =
+                matches!(node.kind(), "type_identifier" | "type_arguments" | "function_type" | "record_type");
+            if (top_level_type || node.kind() == "initialized_identifier_list")
+                && node.parent().map(|p| p.kind() == "program").unwrap_or(false)
+            {
+                let owner = self.top_row();
+                if top_level_type {
+                    self.type_refs_dart(node, owner);
+                } else {
+                    self.initializer_type_refs_dart(node, owner);
+                }
+            }
+        }
+
         // maybeCaptureFnRefs (:990) — the double-walk fn-ref twin source.
         self.maybe_capture_fn_refs(node);
 
@@ -1190,6 +1239,14 @@ impl<'t> Walker<'t> {
     // --- extractInheritance — the dart rows (:5368-5393, :5437-5459) ------
 
     fn extract_inheritance(&mut self, node: Node<'t>, class_row: u32) {
+        // The type an extension is `on` — a `references` edge (#2327).
+        if node.kind() == "extension_declaration" {
+            let mut oc = node.walk();
+            let on_types: Vec<Node<'t>> = node.children_by_field_name("class", &mut oc).collect();
+            for on_type in on_types {
+                self.type_refs_dart(on_type, class_row);
+            }
+        }
         let mut cursor = node.walk();
         let kids: Vec<Node<'t>> = node.named_children(&mut cursor).collect();
         for child in kids {
@@ -1287,6 +1344,100 @@ impl<'t> Walker<'t> {
         }
     }
 
+    // --- type positions outside signatures (#2327; dart.ts pushDartTypeRefs) ---
+
+    /// isDartTypeName (dart.ts) — UpperCamelCase (`/^[_$]*[A-Z]/`: lowercase
+    /// is a built-in or an error-recovery artifact), not a built-in, not an
+    /// import prefix (`p` in `p.Foo`), not the class a `new`/`const`
+    /// constructor call names.
+    fn is_type_name_dart(&self, node: Node<'t>) -> bool {
+        let text = self.text(node);
+        let upper = text
+            .trim_start_matches(&['_', '$'][..])
+            .chars()
+            .next()
+            .map(|c| c.is_ascii_uppercase())
+            .unwrap_or(false);
+        if !upper || is_builtin_type(text) {
+            return false;
+        }
+        if node.next_sibling().map(|s| s.kind() == ".").unwrap_or(false) {
+            return false;
+        }
+        !node
+            .parent()
+            .map(|p| matches!(p.kind(), "new_expression" | "const_object_expression"))
+            .unwrap_or(false)
+    }
+
+    /// pushDartTypeRefs (dart.ts) — every type named inside `node`.
+    fn type_refs_dart(&mut self, node: Node<'t>, from_row: u32) {
+        stack_guard!();
+        if node.kind() == "type_identifier" {
+            if self.is_type_name_dart(node) {
+                let name = self.text(node).to_string();
+                self.push_ref_at(from_row, &name, "references", node);
+            }
+            return;
+        }
+        let mut cursor = node.walk();
+        let kids: Vec<Node<'t>> = node.named_children(&mut cursor).collect();
+        for c in kids {
+            self.type_refs_dart(c, from_row);
+        }
+    }
+
+    /// pushDartInitializerTypeRefs (dart.ts) — each `initialized_identifier`'s
+    /// value (every named child after its name).
+    fn initializer_type_refs_dart(&mut self, list: Node<'t>, from_row: u32) {
+        let mut cursor = list.walk();
+        let entries: Vec<Node<'t>> = list.named_children(&mut cursor).collect();
+        for entry in entries {
+            if entry.kind() != "initialized_identifier" {
+                continue;
+            }
+            let mut ec = entry.walk();
+            let parts: Vec<Node<'t>> = entry.named_children(&mut ec).skip(1).collect();
+            for part in parts {
+                self.type_refs_dart(part, from_row);
+            }
+        }
+    }
+
+    /// dartMemberRead (dart.ts) — `x.area` / `x?.area` not followed by a call's
+    /// argument part, receiver a plain name: a `references` ref `x.area` on
+    /// `area`, which the resolver links to a getter only (#2338).
+    fn extract_member_read(&mut self, node: Node<'t>) {
+        if node.kind() != "selector" {
+            return;
+        }
+        let mut cursor = node.walk();
+        let accessor = node.named_children(&mut cursor).find(|c| {
+            matches!(c.kind(), "unconditional_assignable_selector" | "conditional_assignable_selector")
+        });
+        let member = accessor.and_then(|a| {
+            let mut ac = a.walk();
+            let found = a.named_children(&mut ac).find(|c| c.kind() == "identifier");
+            found
+        });
+        let Some(member) = member else { return };
+        let Some(receiver) = node.prev_named_sibling() else { return };
+        if receiver.kind() != "identifier" {
+            return;
+        }
+        if let Some(next) = node.next_named_sibling() {
+            if next.kind() == "selector" {
+                let mut nc = next.walk();
+                if next.named_children(&mut nc).any(|c| c.kind() == "argument_part") {
+                    return;
+                }
+            }
+        }
+        let name = format!("{}.{}", self.text(receiver), self.text(member));
+        let reader = self.top_row();
+        self.push_ref_at(reader, &name, "references", member);
+    }
+
     // --- visitFunctionBody (:5129-5286) — dart rows -----------------------
 
     fn visit_body(&mut self, node: Node<'t>) {
@@ -1308,6 +1459,14 @@ impl<'t> Walker<'t> {
 
         self.extract_static_member_ref(node);
 
+        // A getter read `x.area` (#2338); a type the body names (#2327).
+        self.extract_member_read(node);
+        if kind == "type_identifier" && self.is_type_name_dart(node) {
+            let name = self.text(node).to_string();
+            let owner = self.top_row();
+            self.push_ref_at(owner, &name, "references", node);
+        }
+
         if kind == "function_signature" {
             // Nested named functions (:5245) — extractFunction walks the
             // nested body itself; the enclosing walker ALSO revisits the
diff --git a/src/extraction/languages/dart.ts b/src/extraction/languages/dart.ts
index ce75671853..13583b983c 100644
--- a/src/extraction/languages/dart.ts
+++ b/src/extraction/languages/dart.ts
@@ -1,7 +1,89 @@
 import type { Node as SyntaxNode } from 'web-tree-sitter';
-import { getNodeText } from '../tree-sitter-helpers';
+import type { UnresolvedReference } from '../../types';
+import { getNodeText, BUILTIN_TYPE_NAMES } from '../tree-sitter-helpers';
 import type { LanguageExtractor } from '../tree-sitter-types';
 
+/**
+ * Whether a Dart `type_identifier` names a type a reference should point at.
+ * Dart writes types in UpperCamelCase (`_Private`, `$Generated` too), so a
+ * lowercase one is a built-in like `num` or `dynamic` — or no type at all:
+ * error recovery around syntax the grammar predates (dot shorthands like
+ * `.leading`) turns argument names into `type_identifier`s. Two more are not
+ * types of their own: the import prefix of `p.Foo` (it names a library), and
+ * the class a `new` / `const` constructor call names (the call links it).
+ */
+export function isDartTypeName(node: SyntaxNode): boolean {
+  if (!/^[_$]*[A-Z]/.test(node.text) || BUILTIN_TYPE_NAMES.has(node.text)) return false;
+  if (node.nextSibling?.type === '.') return false;
+  const parent = node.parent;
+  return parent?.type !== 'new_expression' && parent?.type !== 'const_object_expression';
+}
+
+/**
+ * A `references` ref from `fromNodeId` for every type named inside `node` — a
+ * declared type, a generic argument, a cast or a type test (#2327).
+ */
+export function pushDartTypeRefs(
+  node: SyntaxNode,
+  fromNodeId: string,
+  push: (ref: UnresolvedReference) => void,
+): void {
+  if (node.type === 'type_identifier') {
+    if (isDartTypeName(node)) {
+      push({
+        fromNodeId,
+        referenceName: node.text,
+        referenceKind: 'references',
+        line: node.startPosition.row + 1,
+        column: node.startPosition.column,
+      });
+    }
+    return;
+  }
+  for (const child of node.namedChildren) pushDartTypeRefs(child, fromNodeId, push);
+}
+
+/** The bodies a Dart field `declaration` can sit in: a class's or mixin's, an extension's, an enum's. */
+const DART_MEMBER_BODIES: ReadonlySet<string> = new Set(['class_body', 'extension_body', 'enum_body']);
+
+/** The named nodes a top-level variable's declared type is written as (`Report? x;`, `List<Report> xs = [];`). */
+const DART_TOP_LEVEL_TYPES: ReadonlySet<string> = new Set(['type_identifier', 'type_arguments', 'function_type', 'record_type']);
+
+/** Type refs from `fromNodeId` for the initializers in an `initialized_identifier_list` (each entry is its name, then its value). */
+function pushDartInitializerTypeRefs(
+  list: SyntaxNode,
+  fromNodeId: string,
+  push: (ref: UnresolvedReference) => void,
+): void {
+  for (const entry of list.namedChildren) {
+    if (entry.type !== 'initialized_identifier') continue;
+    for (const part of entry.namedChildren.slice(1)) pushDartTypeRefs(part, fromNodeId, push);
+  }
+}
+
+/**
+ * A Dart member read — `x.area`, `s?.label`, `Config.instance` — as the ref
+ * `<receiver>.<member>`, positioned on the member's name. Reading a getter runs
+ * it, so the resolver links the read to a getter, as a call, and to nothing
+ * else (#2338). The receiver must be a plain name, the one shape whose type the
+ * resolver can look up; a member that is called (`x.grow()`) is the call's.
+ */
+export function dartMemberRead(node: SyntaxNode): { name: string; node: SyntaxNode } | undefined {
+  if (node.type !== 'selector') return undefined;
+  const accessor = node.namedChildren.find((c: SyntaxNode) =>
+    c.type === 'unconditional_assignable_selector' || c.type === 'conditional_assignable_selector'
+  );
+  const member = accessor?.namedChildren.find((c: SyntaxNode) => c.type === 'identifier');
+  if (!member) return undefined;
+  const receiver = node.previousNamedSibling;
+  if (receiver?.type !== 'identifier') return undefined;
+  const next = node.nextNamedSibling;
+  if (next?.type === 'selector' && next.namedChildren.some((c: SyntaxNode) => c.type === 'argument_part')) {
+    return undefined;
+  }
+  return { name: `${receiver.text}.${member.text}`, node: member };
+}
+
 /**
  * The `function_signature` carrying a method's return type — unwrapped from a
  * `method_signature` wrapper (Dart nests the signature one level for methods).
@@ -147,17 +229,48 @@ export const dartExtractor: LanguageExtractor = {
   // parent scope (`file:` top-level / `class:` static member) comes from the
   // node stack, both of which the value-reference target gate accepts.
   visitNode: (node, ctx) => {
+    const push = (ref: UnresolvedReference) => ctx.addUnresolvedReference(ref);
     if (node.type === 'static_final_declaration') {
       const nameNode = node.namedChildren.find((c: SyntaxNode) => c.type === 'identifier');
       if (nameNode) {
         const valueNode = nameNode.nextNamedSibling;
         const initValue = valueNode ? getNodeText(valueNode, ctx.source).slice(0, 100) : undefined;
-        ctx.createNode('constant', getNodeText(nameNode, ctx.source), node, {
+        const constant = ctx.createNode('constant', getNodeText(nameNode, ctx.source), node, {
           signature: initValue ? `= ${initValue}${initValue.length >= 100 ? '...' : ''}` : undefined,
         });
+        // The types its initializer names are the constant's — riverpod's
+        // `final reportProvider = Family<Report?, String>();` (#2327).
+        if (constant) {
+          for (let value = valueNode; value; value = value.nextNamedSibling) pushDartTypeRefs(value, constant.id, push);
+        }
       }
       return true;
     }
+    // A field's declared type, and the types its initializer names, are its
+    // class's: Dart fields mint no nodes of their own (`final Report report;`,
+    // #2327). A `static final` / `const` field's initializer is its constant's.
+    if (node.type === 'declaration') {
+      const owner = ctx.nodeStack[ctx.nodeStack.length - 1];
+      const inBody = node.parent !== null && DART_MEMBER_BODIES.has(node.parent.type);
+      const isField = inBody && node.namedChildren.some((c: SyntaxNode) =>
+        c.type === 'initialized_identifier_list' || c.type === 'static_final_declaration_list'
+      );
+      if (owner && isField) {
+        for (const child of node.namedChildren) {
+          if (child.type === 'initialized_identifier_list') pushDartInitializerTypeRefs(child, owner, push);
+          else if (child.type !== 'static_final_declaration_list') pushDartTypeRefs(child, owner, push);
+        }
+      }
+      return false;
+    }
+    // A top-level variable's declared type and its (non-constant) initializer
+    // are the file's — the grammar lays them out directly under `program`.
+    const topLevelType = DART_TOP_LEVEL_TYPES.has(node.type);
+    if ((topLevelType || node.type === 'initialized_identifier_list') && node.parent?.type === 'program') {
+      const owner = ctx.nodeStack[ctx.nodeStack.length - 1];
+      if (owner && topLevelType) pushDartTypeRefs(node, owner, push);
+      else if (owner) pushDartInitializerTypeRefs(node, owner, push);
+    }
     return false;
   },
   resolveBody: (node, bodyField) => {
@@ -389,4 +502,5 @@ export const dartExtractor: LanguageExtractor = {
 
     return undefined;
   },
+  extractMemberRead: dartMemberRead,
 };
diff --git a/src/extraction/tree-sitter-helpers.ts b/src/extraction/tree-sitter-helpers.ts
index da880cca54..8d355a7a05 100644
--- a/src/extraction/tree-sitter-helpers.ts
+++ b/src/extraction/tree-sitter-helpers.ts
@@ -60,6 +60,27 @@ export function getChildByField(node: SyntaxNode, fieldName: string): SyntaxNode
   return node.childForFieldName(fieldName);
 }
 
+/**
+ * Built-in/primitive type names that shouldn't create references. Shared by the
+ * core type-annotation walker and the per-language ones (Dart's), so every type
+ * position skips the same names.
+ */
+export const BUILTIN_TYPE_NAMES: ReadonlySet<string> = new Set([
+  'string', 'number', 'boolean', 'void', 'null', 'undefined', 'never', 'any', 'unknown',
+  'object', 'symbol', 'bigint', 'true', 'false',
+  // Rust
+  'str', 'bool', 'i8', 'i16', 'i32', 'i64', 'i128', 'isize',
+  'u8', 'u16', 'u32', 'u64', 'u128', 'usize', 'f32', 'f64', 'char',
+  // Java/C#
+  'int', 'long', 'short', 'byte', 'float', 'double', 'char',
+  // Go
+  'int8', 'int16', 'int32', 'int64', 'uint8', 'uint16', 'uint32', 'uint64',
+  'float32', 'float64', 'complex64', 'complex128', 'rune', 'error',
+  // Scala (capitalized primitives + ubiquitous stdlib aliases)
+  'Int', 'Long', 'Short', 'Byte', 'Float', 'Double', 'Boolean', 'Char', 'Unit',
+  'String', 'Any', 'AnyRef', 'AnyVal', 'Nothing', 'Null',
+]);
+
 /**
  * Node types that *wrap* a declaration so a leading comment is a sibling of the
  * wrapper, not of the emitted (inner) declaration node. CodeGraph emits the
diff --git a/src/extraction/tree-sitter-types.ts b/src/extraction/tree-sitter-types.ts
index 6477b02739..619dc097f1 100644
--- a/src/extraction/tree-sitter-types.ts
+++ b/src/extraction/tree-sitter-types.ts
@@ -311,6 +311,15 @@ export interface LanguageExtractor {
    */
   extractBareCall?: (node: SyntaxNode, source: string) => string | undefined;
 
+  /**
+   * Detect a member read that may run code — Dart's `x.area`, which calls the
+   * getter `area` when `area` is one. Returns the ref name (`x.area`) and the
+   * node to position it on, or undefined. Emitted as a `references` ref from
+   * the function the read is in; the resolver links it only to a getter, with
+   * a `calls` edge (a plain field read links nothing).
+   */
+  extractMemberRead?: (node: SyntaxNode) => { name: string; node: SyntaxNode } | undefined;
+
   /**
    * Node types representing a file-level package/namespace declaration
    * (e.g. Kotlin `package_header`, Java `package_declaration`). When set,
diff --git a/src/extraction/tree-sitter.ts b/src/extraction/tree-sitter.ts
index 36cd473b92..05b37146de 100644
--- a/src/extraction/tree-sitter.ts
+++ b/src/extraction/tree-sitter.ts
@@ -16,13 +16,14 @@ import {
   UnresolvedReference,
 } from '../types';
 import { getParser, detectLanguage, isLanguageSupported, isFileLevelOnlyLanguage } from './grammars';
-import { NodeIdAllocator, getNodeText, getChildByField, getPrecedingDocstring } from './tree-sitter-helpers';
+import { NodeIdAllocator, getNodeText, getChildByField, getPrecedingDocstring, BUILTIN_TYPE_NAMES } from './tree-sitter-helpers';
 import { FN_REF_SPECS, captureFnRefCandidates, type FnRefSpec, type FnRefCandidate } from './function-ref';
 import { isGeneratedFile } from './generated-detection';
 import type { LanguageExtractor, ExtractorContext } from './tree-sitter-types';
 import { EXTRACTORS } from './languages';
 import { stripCppTemplateArgs, isCppConstructorDeclaration } from './languages/c-cpp';
 import { rustImplTypeName } from './languages/rust';
+import { isDartTypeName, pushDartTypeRefs } from './languages/dart';
 import { LiquidExtractor } from './liquid-extractor';
 import { RazorExtractor } from './razor-extractor';
 import { SvelteExtractor } from './svelte-extractor';
@@ -6214,6 +6215,40 @@ export class TreeSitterExtractor {
       // Static-member / value-read: `Enum.value`, `Type.CONST`, `Foo::BAR`.
       this.extractStaticMemberRef(node);
 
+      // A member read that may run code — Dart's `x.area` calls the getter
+      // `area` (#2338). The resolver links it to a getter, as a call, or to
+      // nothing: a plain field read stays a reference that names no symbol.
+      const read = this.extractor!.extractMemberRead?.(node);
+      if (read) {
+        const readerId = this.nodeStack[this.nodeStack.length - 1];
+        if (readerId) {
+          this.unresolvedReferences.push({
+            fromNodeId: readerId,
+            referenceName: read.name,
+            referenceKind: 'references',
+            line: read.node.startPosition.row + 1,
+            column: read.node.startPosition.column,
+          });
+        }
+      }
+
+      // A type a Dart body names — a local's declared type, a generic argument
+      // (`Future<Report?>.value(null)`, `context.read<Report>()`), a cast, a
+      // type test — is the function's dependency, as a TS local's annotation
+      // is just below (#2327).
+      if (this.language === 'dart' && nodeType === 'type_identifier' && isDartTypeName(node)) {
+        const ownerId = this.nodeStack[this.nodeStack.length - 1];
+        if (ownerId) {
+          this.unresolvedReferences.push({
+            fromNodeId: ownerId,
+            referenceName: getNodeText(node, this.source),
+            referenceKind: 'references',
+            line: node.startPosition.row + 1,
+            column: node.startPosition.column,
+          });
+        }
+      }
+
       // Local variable type annotations inside a body — `const items: Foo[] = []`,
       // `const x: SomeType = svc.load()`. We deliberately do NOT create nodes for
       // locals (that would explode the graph — the data-flow frontier we leave
@@ -6364,6 +6399,15 @@ export class TreeSitterExtractor {
       return;
     }
 
+    // Dart: the type an extension is `on` is one it depends on — `extension
+    // ReportX on Report`, `on List<Report>` (#2327). Not a supertype: a
+    // `references` edge, as a C# extension method's `this Report r` gets.
+    if (this.language === 'dart' && node.type === 'extension_declaration') {
+      for (const onType of node.childrenForFieldName('class')) {
+        if (onType) pushDartTypeRefs(onType, classId, (ref) => this.unresolvedReferences.push(ref));
+      }
+    }
+
     // Look for extends/implements clauses
     for (let i = 0; i < node.namedChildCount; i++) {
       const child = node.namedChild(i);
@@ -6805,21 +6849,7 @@ export class TreeSitterExtractor {
   /**
    * Built-in/primitive type names that shouldn't create references
    */
-  private readonly BUILTIN_TYPES = new Set([
-    'string', 'number', 'boolean', 'void', 'null', 'undefined', 'never', 'any', 'unknown',
-    'object', 'symbol', 'bigint', 'true', 'false',
-    // Rust
-    'str', 'bool', 'i8', 'i16', 'i32', 'i64', 'i128', 'isize',
-    'u8', 'u16', 'u32', 'u64', 'u128', 'usize', 'f32', 'f64', 'char',
-    // Java/C#
-    'int', 'long', 'short', 'byte', 'float', 'double', 'char',
-    // Go
-    'int8', 'int16', 'int32', 'int64', 'uint8', 'uint16', 'uint32', 'uint64',
-    'float32', 'float64', 'complex64', 'complex128', 'rune', 'error',
-    // Scala (capitalized primitives + ubiquitous stdlib aliases)
-    'Int', 'Long', 'Short', 'Byte', 'Float', 'Double', 'Boolean', 'Char', 'Unit',
-    'String', 'Any', 'AnyRef', 'AnyVal', 'Nothing', 'Null',
-  ]);
+  private readonly BUILTIN_TYPES = BUILTIN_TYPE_NAMES;
 
   /**
    * Extract type references from type annotations on a function/method/field node.
diff --git a/src/resolution/index.ts b/src/resolution/index.ts
index fcd47b7720..fa3de7988a 100644
--- a/src/resolution/index.ts
+++ b/src/resolution/index.ts
@@ -21,7 +21,7 @@ import {
   isImportableKind,
   CPP_DEFINE_SIGNATURE,
 } from './types';
-import { isPythonSelfCall, matchJsStoreBindingCall, isUnresolvedJsMemberCall, isVisibleAcrossFiles, matchReference, matchFunctionRef, matchDottedCallChain, matchScopedCallChain, matchMethodCall, sameLanguageFamily, crossesCodeBoundary, gateLanguageMatch, dumpNameMatcherProfile, clearNameMatcherMemos, isRustNameInScope, CASE_INSENSITIVE_LANGUAGES } from './name-matcher';
+import { isPythonSelfCall, matchJsStoreBindingCall, isUnresolvedJsMemberCall, isVisibleAcrossFiles, matchReference, matchFunctionRef, matchDottedCallChain, matchScopedCallChain, matchMethodCall, sameLanguageFamily, crossesCodeBoundary, gateLanguageMatch, dumpNameMatcherProfile, clearNameMatcherMemos, isRustNameInScope, CASE_INSENSITIVE_LANGUAGES, isDartMemberRead, matchDartMemberRead } from './name-matcher';
 import { isVisibleCppMacro, clearCppMacroVisibility } from './cpp-macro-visibility';
 import { isCppConstructorRef, matchCppConstructor } from './cpp-constructor';
 import { gateSwiftTypeTarget, clearSwiftTypeVisibility, swiftExtendedConformances } from './swift-type-visibility';
@@ -1049,6 +1049,10 @@ export class ReferenceResolver {
       scoped?.resolvedBy === 'framework' ? this.gateFrameworkLanguage(scoped, ref) : this.gateLanguage(scoped, ref),
       ref,
     );
+    // A Dart class whose field holds its own type (`class Node { Node? next; }`)
+    // names itself: a self-edge that says nothing (#2327).
+    if (resolved && ref.language === 'dart' && ref.referenceKind === 'references' &&
+        resolved.targetNodeId === ref.fromNodeId) return null;
     if (!resolved || ref.referenceKind !== 'calls') return resolved;
 
     const target = this.nodeById(resolved.targetNodeId);
@@ -1071,6 +1075,10 @@ export class ReferenceResolver {
     // resolves ONLY to a constructor of the lexically nearest `T` (#1839).
     if (isCppConstructorRef(ref)) return matchCppConstructor(ref, this.context);
 
+    // A Dart member read (`x.area`) links the getter the receiver's type
+    // reaches, as a call, or nothing — never a guess by name (#2338).
+    if (isDartMemberRead(ref)) return matchDartMemberRead(ref, this.context);
+
     // Skip built-in/external references
     if (this.isBuiltInOrExternal(ref)) {
       return null;
diff --git a/src/resolution/name-matcher.ts b/src/resolution/name-matcher.ts
index 0ba9c946d4..d0d8de76fd 100644
--- a/src/resolution/name-matcher.ts
+++ b/src/resolution/name-matcher.ts
@@ -2973,6 +2973,162 @@ function dartHeadOf(decl: Node, context: ResolutionContext): { supers: string[];
   };
 }
 
+const DART_LINEAGES = new WeakMap<ResolutionContext, Map<string, Map<string, number>>>();
+const DART_EXTENSION_OWNERS = new WeakMap<ResolutionContext, Map<string, { on: string[]; named: boolean } | null>>();
+const DART_GETTERS = new WeakMap<ResolutionContext, Map<string, boolean>>();
+
+/** A Dart type and every type it extends, mixes in or implements, by supertype distance (at most 40). */
+function dartLineage(typeName: string, context: ResolutionContext): Map<string, number> {
+  let memo = DART_LINEAGES.get(context);
+  if (!memo) DART_LINEAGES.set(context, (memo = new Map()));
+  const hit = memo.get(typeName);
+  if (hit) return hit;
+  const depths = new Map<string, number>();
+  const queue: Array<[string, number]> = [[typeName, 0]];
+  while (queue.length > 0 && depths.size < 40) {
+    const [name, depth] = queue.shift()!;
+    if (depths.has(name)) continue;
+    depths.set(name, depth);
+    for (const sup of dartSupertypesOf(name, context)) queue.push([sup, depth + 1]);
+  }
+  memo.set(typeName, depths);
+  return depths;
+}
+
+/** The extension a Dart member is declared in — the types it is `on`, and whether it is named — or null for a class's, mixin's or enum's member. */
+function dartExtensionOwner(member: Node, context: ResolutionContext): { on: string[]; named: boolean } | null {
+  let memo = DART_EXTENSION_OWNERS.get(context);
+  if (!memo) DART_EXTENSION_OWNERS.set(context, (memo = new Map()));
+  const hit = memo.get(member.id);
+  if (hit !== undefined) return hit;
+  let found: { on: string[]; named: boolean } | null = null;
+  const cut = member.qualifiedName.lastIndexOf('::');
+  if (cut > 0) {
+    const ownerQn = member.qualifiedName.slice(0, cut);
+    const owner = context.getNodesInFile(member.filePath).find((n) => n.qualifiedName === ownerQn && n.kind === 'class' &&
+      n.startLine <= member.startLine && n.endLine >= member.startLine);
+    const decl = owner ? dartExtensionDecl(owner, context) : null;
+    if (owner && decl) found = { on: dartHeadOf(owner, context).supers, named: decl.named };
+  }
+  memo.set(member.id, found);
+  return found;
+}
+
+/** Whether a Dart member is a getter — declared `get <name>`, a method its readers run. */
+function isDartGetter(n: Node, context: ResolutionContext): boolean {
+  if (n.language !== 'dart' || n.kind !== 'method') return false;
+  let memo = DART_GETTERS.get(context);
+  if (!memo) DART_GETTERS.set(context, (memo = new Map()));
+  const hit = memo.get(n.id);
+  if (hit !== undefined) return hit;
+  const lines = context.getFileLines?.(n.filePath) ?? context.readFile(n.filePath)?.split(/\r?\n/) ?? [];
+  // The declaration from its start, and the next line for a return type that wraps.
+  const head = `${(lines[n.startLine - 1] ?? '').slice(n.startColumn)} ${lines[n.startLine] ?? ''}`;
+  const getter = new RegExp(String.raw`^[^={;]*?\bget\s+${n.name.replace(/\$/g, '\\$')}(?![\w$])`).test(head);
+  memo.set(n.id, getter);
+  return getter;
+}
+
+/**
+ * The Dart member `name` a value of type `typeName` reaches, as Dart finds it:
+ * the nearest one the type or a type it extends, mixes in or implements
+ * declares, else one an extension on such a type adds — an extension applies
+ * only where no instance member answers, and an unnamed one only in its own
+ * library. `accept` narrows the candidates (a read wants a getter). Ties go to
+ * the call site's own file, then the nearest directory — riverpod's translated
+ * docs carry their own copy of each example's extension.
+ */
+function dartMemberOf(
+  typeName: string,
+  name: string,
+  ref: UnresolvedRef,
+  context: ResolutionContext,
+  accept: (n: Node) => boolean,
+): { node: Node; viaExtension: boolean } | null {
+  const lineage = dartLineage(typeName, context);
+  let best: Node[] = [];
+  let bestRank = Infinity;
+  for (const m of context.getNodesByName(name)) {
+    if (m.language !== 'dart' || !isDartMember(m) || !accept(m)) continue;
+    const extension = dartExtensionOwner(m, context);
+    let rank: number;
+    if (extension) {
+      if (!extension.named && m.filePath !== ref.filePath) continue;
+      const on = Math.min(...extension.on.map((t) => lineage.get(t) ?? Infinity));
+      if (on === Infinity) continue;
+      rank = DART_EXTENSION_RANK + on;
+    } else {
+      const owner = m.qualifiedName.slice(0, Math.max(0, m.qualifiedName.lastIndexOf('::'))).split('::').pop()!;
+      const depth = lineage.get(owner);
+      if (depth === undefined) continue;
+      rank = depth;
+    }
+    if (rank < bestRank) {
+      bestRank = rank;
+      best = [m];
+    } else if (rank === bestRank) {
+      best.push(m);
+    }
+  }
+  if (best.length === 0) return null;
+  const node = best.find((n) => n.filePath === ref.filePath) ??
+    best.reduce((a, b) => (computePathProximity(ref.filePath, b.filePath) > computePathProximity(ref.filePath, a.filePath) ? b : a));
+  return { node, viaExtension: bestRank >= DART_EXTENSION_RANK };
+}
+
+/** `x.area` / `Config.instance`: the receiver and member of a Dart member read. */
+const DART_MEMBER_READ = /^([A-Za-z_$][\w$]*)\.([A-Za-z_$][\w$]*)$/;
+
+/**
+ * Whether a ref is a Dart member read — `x.area`, which the extractor records
+ * as a `references` ref named `<receiver>.<member>`. No other Dart reference
+ * carries a dotted name: a type is one identifier, a static read names only
+ * its type.
+ */
+export function isDartMemberRead(ref: UnresolvedRef): boolean {
+  return ref.language === 'dart' && ref.referenceKind === 'references' && DART_MEMBER_READ.test(ref.referenceName);
+}
+
+/**
+ * A Dart member read runs code only when the member is a getter, so it links
+ * — as a call — the getter the receiver's type reaches: declared on the type, a
+ * type it extends, mixes in or implements, or added by an extension on one of
+ * them (`s.label` on an enum `Shape` through `extension ShapeInfo on Shape`),
+ * or nothing: a field read, a getter of a type outside the project, a receiver
+ * whose type is not written down. Never a same-named getter found by name alone
+ * (#2338).
+ */
+export function matchDartMemberRead(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {
+  const parts = DART_MEMBER_READ.exec(ref.referenceName);
+  if (!parts) return null;
+  const receiver = parts[1]!;
+  const member = parts[2]!;
+  // Most reads are of fields, which mint no nodes: check for a getter first.
+  if (!context.getNodesByName(member).some((n) => isDartGetter(n, context))) return null;
+  // A type named directly reads its static getter (`Config.instance`); a
+  // variable is typed by its declaration — a parameter or local in scope, else
+  // a field of the class the read is written in (`final Box box;`).
+  const typeName = /^[A-Z]/.test(receiver) &&
+    context.getNodesByName(receiver).some((n) => n.language === 'dart' && DART_TYPE_KINDS.has(n.kind))
+    ? receiver
+    : inferLocalReceiverType(receiver, ref, context) ?? inferMemberReceiverType(receiver, ref, context);
+  if (!typeName) return null;
+  const found = dartMemberOf(typeName, member, ref, context, (n) => isDartGetter(n, context));
+  if (!found) return null;
+  return { original: ref, targetNodeId: found.node.id, confidence: 0.9, resolvedBy: 'instance-method', edgeKind: 'calls' };
+}
+
+/**
+ * A member an extension adds to `typeName` — `s.shout()` on an enum `Shape`
+ * through `extension ShapeInfo on Shape` — when the type itself declares none
+ * (#2338). An inherited instance member is left to the strategies that
+ * resolve it today.
+ */
+function dartExtensionMemberOf(typeName: string, name: string, ref: UnresolvedRef, context: ResolutionContext): Node | null {
+  const found = dartMemberOf(typeName, name, ref, context, () => true);
+  return found?.viaExtension ? found.node : null;
+}
+
 /**
  * How a bare Rust or Go name is written at its call: `path` after `::` (left
  * to the path strategies), `chained` after a `.` — with the receiver it is
@@ -6148,6 +6304,13 @@ export function resolveMethodOnType(
       });
       if (viaSupers) return viaSupers;
     }
+    // A Dart extension's member: no declaration of the type has it, so an
+    // extension `on` the type (or a supertype) supplies it — `s.shout()` on an
+    // enum through `extension ShapeInfo on Shape` (#2338).
+    if (ref.language === 'dart' && depth === 0) {
+      const viaExtension = dartExtensionMemberOf(typeName, methodName, ref, context);
+      if (viaExtension) return { original: ref, targetNodeId: viaExtension.id, confidence, resolvedBy };
+    }
     return null;
   }
 
@@ -6762,6 +6925,9 @@ export function clearNameMatcherMemos(context: ResolutionContext): void {
   PHP_SUPERS.delete(context);
   DART_SUPERS.delete(context);
   DART_HIERARCHIES.delete(context);
+  DART_LINEAGES.delete(context);
+  DART_EXTENSION_OWNERS.delete(context);
+  DART_GETTERS.delete(context);
   SWIFT_DECLS.delete(context);
   KOTLIN_RECEIVER_TYPES.delete(context);
   KOTLIN_HIERARCHIES.delete(context);