src/datamodel_code_generator/parser/base.py (1)

1983-1995: Guard in __collapse_root_models correctly mirrors the discriminator guard.

The logic correctly wraps the discriminator assignment in a not has_any_variant check, preventing invalid discriminators when Any-like variants are present in the collapsed root model's data types.

Note: the has_any_variant detection expression is identical to the one at lines 1456–1459. If a third call site is added, extract a shared _has_any_variant(data_types) helper.

♻️ Optional: Extract shared helper

+    `@staticmethod`
+    def _has_any_variant(data_types: list[DataType]) -> bool:
+        """Check if any data type in the list is Any or effectively empty (non-discriminable)."""
+        return any(
+            dt.type == ANY or (not dt.reference and not dt.data_types and not dt.literals and not dt.type)
+            for dt in data_types
+        )

Then replace both inline checks with self._has_any_variant(...).

src/datamodel_code_generator/parser/jsonschema.py (3)

369-372: Unused noqa directives on new fields.

Ruff reports that the noqa directives N815 and UP045 on lines 369–372 are non-enabled rules, so the # noqa: comments are unnecessary. Consider removing them to keep the suppressions consistent with the active ruleset, or enable those rules if suppression was intentional.

---

1587-1605: Redundant guard before setdefault on _dynamic_anchor_index.

Line 1603's if root_key not in self._dynamic_anchor_index check is unnecessary because setdefault on line 1605 already handles the missing-key case. This contrasts with _recursive_anchor_index (line 1601) which uses setdefault directly without a guard.

Suggested simplification

         if obj.dynamicAnchor:
-            if root_key not in self._dynamic_anchor_index:  # pragma: no cover
-                self._dynamic_anchor_index[root_key] = {}
-            self._dynamic_anchor_index[root_key].setdefault(obj.dynamicAnchor, ref_path)
+            self._dynamic_anchor_index.setdefault(root_key, {}).setdefault(obj.dynamicAnchor, ref_path)

---

4156-4191: Anchor index pre-population in _parse_file duplicates logic from _build_anchor_indexes.

The manual anchor indexing here (for both root and definitions) repeats the same pattern as _build_anchor_indexes. I understand the need to pre-populate before parsing begins — but the duplication is fragile. If the indexing logic changes in _build_anchor_indexes, these blocks must be updated in lockstep.

Consider extracting the root/definition anchor registration into a shared helper or calling _build_anchor_indexes with the appropriate path for each definition during the pre-scan loop (lines 4176–4191) instead of inlining the logic.

src/datamodel_code_generator/parser/base.py (1)

1479-1487: Any-like variant guard in discriminator application is sound.

This correctly prevents Pydantic v2 PydanticUserError when a discriminated union includes an Any-like variant (which cannot have a discriminator field). The guard checks both explicit ANY types and "empty" data types that lack any reference, nested types, literals, or type — all of which would be non-discriminable.

One observation: the condition on lines 1480-1483 is duplicated in __collapse_root_models (lines 2007-2011). Consider extracting a helper to keep this in sync.

♻️ Optional: extract shared helper

+    `@staticmethod`
+    def _has_any_like_variant(data_types: list[DataType]) -> bool:
+        """Check if any data type in a union is Any-like and cannot participate in a discriminated union."""
+        return any(
+            dt.type == ANY or (not dt.reference and not dt.data_types and not dt.literals and not dt.type)
+            for dt in data_types
+        )

Then use self._has_any_like_variant(field.data_type.data_types) in both call sites.

src/datamodel_code_generator/parser/jsonschema.py (2)

369-372: Unused noqa directives on new field declarations.

Ruff reports that the noqa: N815, UP045 directives on lines 369–372 are for non-enabled rules. Remove them to keep lint suppression accurate and avoid masking future issues.

-    recursiveRef: Optional[str] = Field(default=None, alias="$recursiveRef")  # noqa: N815, UP045
-    recursiveAnchor: Optional[bool] = Field(default=None, alias="$recursiveAnchor")  # noqa: N815, UP045
-    dynamicRef: Optional[str] = Field(default=None, alias="$dynamicRef")  # noqa: N815, UP045
-    dynamicAnchor: Optional[str] = Field(default=None, alias="$dynamicAnchor")  # noqa: N815, UP045
+    recursiveRef: Optional[str] = Field(default=None, alias="$recursiveRef")
+    recursiveAnchor: Optional[bool] = Field(default=None, alias="$recursiveAnchor")
+    dynamicRef: Optional[str] = Field(default=None, alias="$dynamicRef")
+    dynamicAnchor: Optional[str] = Field(default=None, alias="$dynamicAnchor")

---

4160-4195: Duplicate anchor registration: _parse_file inline code duplicates _build_anchor_indexes, and definitions get double-appended.

The anchor-building logic here (lines 4160–4195) duplicates what _build_anchor_indexes already does. For definitions, this code registers anchors, and then parse_raw_obj (line 4207) calls _build_anchor_indexes again, causing duplicate entries in _recursive_anchor_index (since it uses list.append). While not a correctness bug (the prefix-matching algorithm tolerates duplicates), this is a DRY violation that could diverge over time.

Consider delegating to _build_anchor_indexes here instead of inlining the logic:

♻️ Sketch: replace inline anchor building with method calls

                 self.parse_id(root_obj, path_parts)
-                # Build $recursiveAnchor index for root object
-                if root_obj.recursiveAnchor:
-                    root_key = tuple(path_parts)
-                    self._recursive_anchor_index.setdefault(root_key, []).append("#")
-                # Build $dynamicAnchor index for root object
-                if root_obj.dynamicAnchor:
-                    root_key = tuple(path_parts)
-                    if root_key not in self._dynamic_anchor_index:
-                        self._dynamic_anchor_index[root_key] = {}
-                    self._dynamic_anchor_index[root_key].setdefault(root_obj.dynamicAnchor, "#")
+                self._build_anchor_indexes(root_obj, path_parts)

Then for definitions, remove the inline registration (lines 4184–4195) since parse_raw_obj at line 4207 already calls _build_anchor_indexes. If you keep both call sites, guard _recursive_anchor_index against duplicates (e.g., check before appending).