fix(cpp): a call on an auto variable or a chained call reaches the class C++ finds, not a namesake

[colbymchenry]

Summary

#2493 made a call on a declared pointer, value or reference resolve on the class C++ name lookup finds for its type. Three kinds of typed receivers still went by the type's last name, so a namesake class could win:

1. auto locals. The type came from inferCppAutoInitializerType, which reads only new X, X(…), Class::fn(…) and make_unique<X>, and keeps only the last name. When it couldn't read the initializer, the scan went on to an earlier declaration of the same name, often in another function. In facebook/rocksdb, auto iter = std::unique_ptr<Iterator>(…) and auto it = db_->NewIterator(…) read an earlier test's Iterator* iter, and iter->SeekToFirst() reached the nested MemTableRep::Iterator (342 edges on main).
2. Chained calls (a->b()->c()). The inner call's return type was its last name: protobuf's Java generator reached the C# generator's EnumGenerator, and a chain returning absl::Status reached upb::Status.
3. Types from outside the project. These got a project namesake's method: protobuf's absl::Status status; status.ok() reached upb::Status::ok (the fix(cpp): a call on a declared pointer, value or reference reaches the class its type names, not a namesake #2493 follow-up), and fmt's std::ostream& os; os.flush() reached fmt's own ostream::flush.

What changed (name-matcher.ts)

• auto locals (cppAutoLocalType) take the type of their initializer as written where it is declared (cppExpressionType), and calls on them go through matchCppDeclaredTypeCall from that site. cppExpressionType now also reads:

  • casts and smart pointers written out: static_cast<T*>(…), std::unique_ptr<T>(…);
  • new T(…), std::make_unique<T> / make_shared<T>, and a construction T(…) of a class C++ lookup finds;
  • a bare call to the caller's class's own or inherited method (auto* h = micro_rep();).

  The initializer is read up to its ;, across lines: auto* op = opts->merge_operator continues on the next line as ->CheckedCast<Foo>(). A type that depends on a template parameter (T*, or a library template of one like std::shared_ptr<T>) is left to the old path; a smart pointer to one of the project's class templates (std::unique_ptr<ExternalTableReaderBase<Mode>>) is not. Without the template arguments substituted, overloads like protobuf's DownCastMessage<T> (const T& / T* / std::shared_ptr<T>) can't be told apart.

• Chains (matchCppChainOnWrittenType, tried before the last-name path): c is looked up on the class C++ finds for b's written return type, through a pointer or smart pointer. The inner receiver's operator is read from the source, since the extractor spells -> as .. When the type can't be read or placed, the last-name path decides as before.

• Outside types get no project method:

  • fix(cpp): a receiver declared as a std or other outside type with a lowercase name calls that type's own member #2413's library-type gate now runs inside matchCppDeclaredTypeCall, before the last-name match, so a namesake class can't win first. The old gate in matchMethodCall had the same conditions and was removed.
  • A capitalized type that C++ lookup can't place, under a namespace the project declares no type in (isCppOutsideQualifiedType), is from outside the project, for chains too. The names come from type nodes only, because protobuf's specializations parse as methods named google::protobuf::absl::Cord. std and lowercase names stay fix(cpp): a receiver declared as a std or other outside type with a lowercase name calls that type's own member #2413's business: std::conditional_t<…, Slice> names a project type.

• Small fixes found by the A/B:

  • A template <…> header followed by macros or specifiers still names its parameters (collectTemplateHeader).
  • A trailing annotation macro (T* PROTOBUF_NONNULL) is no part of a written return type.
  • Memoized auto locals and loop elements are worked out with a fresh depth budget. A deep chain that read a local first left it untyped for that local's other calls (cfd->current() in rocksdb's compaction test).
  • The record's element field is now declared, since it also holds an auto local's type.

Validation

Site-keyed edge diffs (diff-sites.mjs), main c19f0284 vs this branch, both built from the same tree (kernel included):

repo	removed	added	retargeted	metadata-only
google/leveldb	0	35	0	0
fmtlib/fmt	3	106	11	35
facebook/rocksdb	202	3,056	757	518
protocolbuffers/protobuf	169	475	18	71

Nodes and files are identical between the arms.

Removed, every site triaged:

• rocksdb (202):
  • 192 were name guesses on receivers of library types, now known: std::vector / std::string / std::optional / std::unique_ptr::get, e.g. blob_files.empty() on BlobFiles reached CompactionInputFiles::empty.
  • 9 are the same edge, kept under the chain's ref at the same position (With(e1).With(e2), mock->Inner()->Inner()), checked mechanically.
  • 1 is a loss: auto* state = new IteratorState(…) where WriteUnpreparedTxnDB::IteratorState is defined out of line and indexed <anonymous>, so its typed receiver gets no method. A declared IteratorState* state behaves the same way on main, and the name guess happened to be right.
• protobuf (169):
  • 118 namesakes of absl::Status / absl::StatusOr receivers (8 of them chains): upb::Status::ok, hpb::StatusOr::ok, SymbolCheckerError::message.
  • 38 name guesses on library types.
  • 6 calls on descriptor classes whose accessors the index doesn't hold (fix(cpp): a call on a declared pointer, value or reference reaches the class its type names, not a namesake #2493's policy).
  • 7 calls on generated classes the index doesn't hold (DescriptorProto::ExtensionRange had reached Descriptor::ExtensionRange).
• fmt (3): os.flush() on std::ostream&, and 2 same-edge-kept sites.

Retargeted, every group read, all wrong→right:

• rocksdb:
  • 361 ArenaWrappedDBIter → IteratorBase and 160 MemTableRep::Iterator → IteratorBase (auto iter = std::unique_ptr<Iterator>(…));
  • 51 SharedBlobFileMetaData → BlobFileMetaData;
  • port::Mutex → InstrumentedMutex (static_cast<InstrumentedMutex*>(arg)), ProtectionInfoKVOC → ProtectionInfoKVOS (a class template's return type), TableReader, Transaction, FileSystem, Env and so on.
• protobuf: _GetDescriptor(self)->index() in each pyext namespace now reaches that namespace's descriptor class, rather than Descriptor's index; micro_rep() → MicroRep, not LargeRep.

Added:

• 3,004 are chains that resolve through the written return type (rocksdb 2,512, protobuf 411, fmt 46, leveldb 35): rocksdb it->key().data() → Slice (the namesake's key() returned const char*), target()->…, dbfull()->…; protobuf GetDescriptor(self)->FindFieldByName(…).
• The other 668 are calls on typed auto locals.
• Every added or retargeted site whose target class shares its name with another class was listed. All come from exact lookups, and the examples read right.

Tests: __tests__/cpp-auto-local-receiver.test.ts, 12 cases:

• 9 fail on main; the other 3 guard behavior that must not change:
  • an initializer split over lines;
  • template-dependent returns after macros;
  • a project namespace's type the file doesn't see.
• 17 mutations, one per guard or branch, each fail a test.
• All 306 tests in the 25 C/C++ test files pass. Full suite: 6,963 passed, 0 failed, 80 skipped.

CPU (rocksdb, full index, process CPU time, interleaved): main 132.1 / 142.1 / 146.9 s vs this branch 130.6 / 148.7 / 130.1 s. No measurable cost.

Not in this PR

• gtest TEST_F / TEST_P bodies don't have the fixture's members: auto iter = db_->NewIterator(…) there stays untyped. The follow-up PR (data members declared in another header) adds fixture members.
• Bare calls in those bodies (auto iter = NewIterator(…)) would need the fixture's methods: about 50 rocksdb MemTableRep::Iterator edges remain because of them.

🤖 Generated with Claude Code