sphinx-java-autodoc 0.5.0__tar.gz → 0.7.0__tar.gz

{sphinx_java_autodoc-0.5.0 → sphinx_java_autodoc-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sphinx-java-autodoc
-Version: 0.5.0
+Version: 0.7.0
 Summary: Compiler-backed Java API documentation in native Sphinx nodes
 Project-URL: Documentation, https://r4sky0.github.io/sphinx-java-autodoc/
 Project-URL: Repository, https://github.com/r4sky0/sphinx-java-autodoc
@@ -11,6 +11,7 @@ License-Expression: MIT
 License-File: LICENSE
 Keywords: autodoc,documentation,java,javadoc,sphinx
 Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Sphinx :: Domain
 Classifier: Framework :: Sphinx :: Extension
 Classifier: Intended Audience :: Developers
 Classifier: Operating System :: OS Independent
@@ -21,7 +22,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Documentation :: Sphinx
 Requires-Python: >=3.12
-Requires-Dist: sphinx<9.2,>=9.1
+Requires-Dist: sphinx<9.2,>=8.2
 Provides-Extra: test
 Requires-Dist: build>=1; extra == 'test'
 Requires-Dist: playwright>=1.50; extra == 'test'
@@ -51,8 +52,8 @@ for the output.
 
 ## Requirements
 
-Python 3.12+, Sphinx 9.1.x, and **JDK 25 for extraction**. Your library can keep
-targeting Java 17 or 21. See
+Python 3.12+, Sphinx 8.2.x, 9.0.x or 9.1.x, and **JDK 25 for extraction**. Your library
+can keep targeting Java 17 or 21. See
 [compatibility and limits](https://r4sky0.github.io/sphinx-java-autodoc/compatibility.html).
 
 ## Quick start

{sphinx_java_autodoc-0.5.0 → sphinx_java_autodoc-0.7.0}/README.md

@@ -21,8 +21,8 @@ for the output.
 
 ## Requirements
 
-Python 3.12+, Sphinx 9.1.x, and **JDK 25 for extraction**. Your library can keep
-targeting Java 17 or 21. See
+Python 3.12+, Sphinx 8.2.x, 9.0.x or 9.1.x, and **JDK 25 for extraction**. Your library
+can keep targeting Java 17 or 21. See
 [compatibility and limits](https://r4sky0.github.io/sphinx-java-autodoc/compatibility.html).
 
 ## Quick start

{sphinx_java_autodoc-0.5.0 → sphinx_java_autodoc-0.7.0}/docs/compatibility.rst

@@ -25,8 +25,9 @@ Requirements and tested versions
      - 3.12+
      - 3.12, 3.13 and 3.14
    * - Sphinx
-     - 9.1.x
-     - 9.1.0, with the Docutils version it installs (0.22.4)
+     - 8.2.x, 9.0.x and 9.1.x
+     - 9.1.0, with the Docutils version it installs (0.22.4); the test suite on 8.2.3
+       and on 9.0.4 with Docutils 0.22.4
    * - Operating system
      - Platform-neutral
      - Linux, macOS and Windows in GitHub Actions
@@ -57,8 +58,9 @@ Known limits
 * Traditional Javadoc comments and plain inline ``{@snippet}`` bodies are
   supported; see :doc:`javadoc-support`. Markdown comments (``///``), external or
   hybrid snippets, snippet regions, IDs and markup, and unsupported tags warn. The
-  HTML subset excludes definition lists, headings, images, presentational attributes,
-  ``<th>`` styling outside table headers, and local documentation assets.
+  HTML subset excludes images, presentational attributes, ``<th>`` styling outside
+  table headers, and local documentation assets. Headings become rubrics, outside
+  the page's table of contents.
 * Only declared members are shown. Non-overridden inherited methods stay on their
   ancestor's page. Compiler-generated record and enum methods are listed, but the
   standard doclet's generated prose for them is not synthesized.

{sphinx_java_autodoc-0.5.0 → sphinx_java_autodoc-0.7.0}/docs/gallery/comments.rst

@@ -11,7 +11,8 @@ HTML, inline tags and snippets
 One class comment uses most of the supported content: paragraphs, emphasis, nested
 lists, ``<pre>{@code ...}</pre>`` blocks, line breaks, external links, an inline
 ``{@snippet}``, a table with a caption, ``{@value}``, ``{@link}`` and
-``{@linkplain}``, and the ``@see`` and ``@since`` tags.
+``{@linkplain}``, a heading, a definition list, ``<sup>``, ``<kbd>``,
+``{@systemProperty}``, and the ``@see`` and ``@since`` tags.
 
 .. literalinclude:: ../../examples/standalone/src/demo/Widget.java
    :language: java

{sphinx_java_autodoc-0.5.0 → sphinx_java_autodoc-0.7.0}/docs/gallery/declarations.rst

@@ -3,6 +3,9 @@ Declarations and signatures
 
 Signatures come from the compiler, so they show exactly what JDK 25 accepts. Type
 names in signatures link to their documentation, here or in external Javadoc.
+Modifiers are those the standard doclet shows: it leaves out implied ones, such as
+``public`` on interface members, ``abstract`` on interfaces and ``final`` on records
+and enums, and implementation details such as ``synchronized`` and ``native``.
 
 Generics, arrays and varargs
 ----------------------------

{sphinx_java_autodoc-0.5.0 → sphinx_java_autodoc-0.7.0}/docs/gallery/warnings.rst

@@ -16,19 +16,23 @@ this site builds with ``-W``, so a real warning would fail it.
      - Markdown documentation comments are not supported
      - ``java.extract``
    * - An unknown block tag, such as ``@todo``
-     - Unsupported block tag UNKNOWN_BLOCK_TAG
+     - Unsupported block tag @todo
      - ``java.extract``
    * - External snippets, regions or markup
      - Unsupported snippet attributes or markup
      - ``java.extract``
-   * - ``{@link}`` to a symbol the compiler can't find
+   * - ``{@link}`` or ``@throws`` naming a symbol the compiler can't find
      - Unresolved Javadoc reference
      - ``java.extract``
+   * - An override without its own text, such as ``toString``, whose ancestor has
+       no source documentation
+     - Cannot inherit
+     - ``java.inherit``
    * - ``{@inheritDoc}`` without ancestor source
      - Cannot resolve inheritDoc
      - ``java.extract``
-   * - An HTML element outside the supported subset, such as ``<h3>``
-     - Unsupported Javadoc HTML <h3>
+   * - An HTML element outside the supported subset, such as ``<img>``
+     - Unsupported Javadoc HTML <img>
      - ``java.html``
    * - A ``:members:`` entry that doesn't exist
      - Java member ... was not found

{sphinx_java_autodoc-0.5.0 → sphinx_java_autodoc-0.7.0}/docs/javadoc-support.rst

@@ -13,17 +13,33 @@ Tags and HTML
 - JDK notes: ``@apiNote``, ``@implSpec`` and ``@implNote``, with the standard
   doclet's headings. They are not inherited.
 - Inline tags: ``code``, ``literal``, ``link``, ``linkplain``, ``value``,
-  ``inheritDoc``, ``return`` and plain inline ``snippet``.
-- HTML: paragraphs, nested lists, tables, ``<pre>``, emphasis, strong text,
-  ``<br>`` and absolute HTTP(S) or mailto links.
+  ``inheritDoc``, ``return`` and plain inline ``snippet``. ``{@summary}`` shows its
+  text, ``{@index}`` its term and ``{@systemProperty}`` the property name as code,
+  as in the standard doclet; there is no search index entry.
+- HTML: paragraphs, nested lists, definition lists (``<dl>``, ``<dt>``, ``<dd>``),
+  tables, ``<pre>``, headings ``<h1>`` to ``<h6>`` as rubrics, ``<br>`` and absolute
+  HTTP(S) or mailto links.
+- Inline HTML: emphasis (``<i>``, ``<em>``, ``<var>``, ``<cite>``, ``<dfn>``), strong
+  text (``<b>``, ``<strong>``), code (``<code>``, ``<tt>``, ``<kbd>``, ``<samp>``),
+  ``<sup>``, ``<sub>`` and ``<small>``, which shows as plain text.
+
+``<pre>`` is highlighted as Java where its text is Java, and shown without a warning
+where it is not, such as a table of results. With a ``lang`` attribute, as in
+snippets, Sphinx warns when the text does not match the language.
 
 ``@author``, ``@version`` and the ``@serial`` tags are omitted silently, as in the
 standard doclet's default output. Other custom tags warn.
 
+Fields follow the order of the JDK's own documentation, whatever the order of the
+tags: Specified by and Overrides, the notes, then Type parameters, Parameters,
+Returns, Throws, Since and See also.
+
 Text reads as in the standard doclet. A link without a label shows
 ``Map.Entry``, ``String.format(String, Object...)``, or ``of(L, R)`` for a member of
-the same type. Sphinx's smart quotes are off, so quotes and ``...`` stay as written.
-``@throws`` names link to the exception type.
+the same type. A link to a type parameter or a module, such as ``{@link T}`` or
+``{@link java.base/}``, shows its name or label as code without linking. Sphinx's
+smart quotes are off, so quotes and ``...`` stay as written. ``@throws`` names link
+to the exception type.
 
 Constant values
 ---------------

{sphinx_java_autodoc-0.5.0 → sphinx_java_autodoc-0.7.0}/docs/schema.md

@@ -23,8 +23,11 @@ not a general XML document interchange service. No external entities are fetched
   or modifier, `kt` primitive type or `void`, `t` punctuation or spaces, `q` package
   qualifier, `n` declared name, `tv` type variable, `pname` parameter name, `v` constant
   or default value, `r` type reference, and `params` containing one `param` per
-  parameter or record component. `r` carries `target` (canonical ID) and the external
-  Javadoc `path`, `module` and `fragment`; its text is the nested simple name.
+  parameter or record component. Modifiers are those the standard doclet shows,
+  without implied ones such as `public` on interface members or `final` on records,
+  and without `native`, `synchronized` and `strictfp`. `r` carries `target`
+  (canonical ID) and the external Javadoc `path`, `module` and `fragment`; its text
+  is the nested simple name.
   Readers reject unknown tokens and malformed `r` targets.
 - `doc/part`: `kind` (`body`, `specifiedBy`, `overrides`, `param`, `typeparam`,
   `return`, `throws`, `see`, `since`, `deprecated`, `apiNote`, `implSpec`, `implNote`)
@@ -64,7 +67,10 @@ not a general XML document interchange service. No external entities are fetched
   `Map.Entry`, `String.format(String, Object...)` or `of(L, R)` within the same type.
   An unresolved link has no resolved location and has a diagnostic.
 - `diagnostic`: symbol-qualified warning text, including unsupported constructs.
-  Warnings survive cache hits and are re-emitted by Sphinx.
+  Warnings survive cache hits and are re-emitted by Sphinx. An optional `kind`
+  is `inherit` for an omitted part that no ancestor documents, or `extract`; a
+  diagnostic without `kind` is `extract`. Sphinx warns with the kind as subtype,
+  such as `java.inherit`. Readers reject other kinds. Additive in schema 1.
 
 Identity examples: `example.Outer.Inner`, `example.Outer#FIELD`,
 `example.Outer#find(java.lang.String,int[])`, `example.Outer#<init>()`.

{sphinx_java_autodoc-0.5.0 → sphinx_java_autodoc-0.7.0}/docs/showcase.rst

@@ -17,8 +17,10 @@ JDK links and ``sphinx.ext.linkcode`` for :ref:`source links <source-links>` to
 GitHub at the pinned commit. For an example of every feature, see the
 :doc:`gallery/index`. The build reports |showcase-total| warnings:
 
-- |showcase-java.extract| ``java.extract``: overrides of JDK methods that cannot
-  inherit their documentation, and links to libraries not on the classpath.
+- |showcase-java.inherit| ``java.inherit``: overrides of JDK methods that cannot
+  inherit their documentation, because the JDK's sources are not available.
+- |showcase-java.extract| ``java.extract``: links to libraries not on the classpath,
+  and ``{@inheritDoc}`` with no ancestor source.
 - |showcase-java.html| ``java.html``: headings and other unsupported HTML.
 - |showcase-misc.highlighting_failure| highlighting failures: ``<pre>`` examples that
   are not Java.

{sphinx_java_autodoc-0.5.0 → sphinx_java_autodoc-0.7.0}/docs/troubleshooting.rst

@@ -41,9 +41,24 @@ Unsupported tags, HTML, ``///`` Markdown comments and advanced snippets warn wit
 the symbol; see :doc:`javadoc-support`. To inherit a dependency's Javadoc, add its
 sources to ``java_sourcepath``.
 
-Warnings use the ``java.extract``, ``java.html``, ``java.type``, ``java.member``
-and related categories. Suppressing a warning does not add the missing content.
-Outside Sphinx, ``--warnings-as-errors`` makes extraction diagnostics fail.
+Warnings use the ``java.extract``, ``java.inherit``, ``java.html``, ``java.type``,
+``java.member`` and related categories. Suppressing a warning does not add the
+missing content. Outside Sphinx, ``--warnings-as-errors`` makes all extraction
+diagnostics fail, whatever their category.
+
+An overriding method without its own text for a part warns "Cannot inherit ..."
+as ``java.inherit`` when no ancestor documents that part. This is common for
+overrides of JDK methods such as ``toString``, ``equals`` and ``hashCode``: the
+JDK's sources ship as modules with ``module-info.java``, which ``java_sourcepath``
+rejects, so there is nothing to inherit from. Document the part, or silence only these
+warnings while keeping the others:
+
+.. code-block:: python
+
+   suppress_warnings = ["java.inherit"]
+
+An explicit ``{@inheritDoc}`` that cannot be resolved stays ``java.extract``,
+because it leaves an ``[unresolved inheritDoc]`` marker in the output.
 
 The extension refuses to overwrite a generated page
 ---------------------------------------------------

{sphinx_java_autodoc-0.5.0 → sphinx_java_autodoc-0.7.0}/docs/usage.rst

@@ -38,7 +38,8 @@ Set these in ``conf.py``. Paths are relative to ``conf.py``, except
      - JDK 25 home; empty uses the runtime on ``PATH``.
    * - ``java_release``
      - ``""``
-     - Source/API release; empty uses the JDK default. Tested: 17, 21, 25.
+     - Source/API release, such as ``"17"`` or ``17``; empty uses the JDK default.
+       Tested: 17, 21, 25.
    * - ``java_generate``
      - ``""``
      - Directory for generated pages, such as ``"api"``. Empty generates no pages.
@@ -128,8 +129,11 @@ Roles
 
 ``java:obj`` accepts any kind. Targets are fully qualified: there are no imports
 or short-name guessing. Parameters are erased, fully qualified types, with ``[]``
-for varargs; constructors are ``<init>``. A method without a parameter list
-resolves only when it has one overload; otherwise it warns. References inside Java
+for varargs; constructors are ``<init>``. Roles, ``java:auto*`` arguments,
+``java:autosummary`` lines and ``:members:``/``:exclude-members:`` entries all
+ignore spaces and accept ``...`` for ``[]``, so ``find(java.lang.String, int)``
+works too. A method without a parameter list resolves only when it has one
+overload; otherwise it warns. References inside Java
 comments are resolved by the compiler as usual.
 
 .. _source-links:
@@ -177,8 +181,12 @@ Map package prefixes to Javadoc roots; the longest prefix wins:
 Javadoc 9+ URL structure; Javadoc 8 anchors are not supported. URLs are built
 without fetching or checking the remote site.
 
-A role that no source comment references has no module metadata. For those, map
-the exact package without ``{module}``:
+A role takes the module and location from the extracted model when the symbol
+appears there: in a comment link, a documented exception or a signature. Other
+roles have no module metadata. For those, map the package, or a prefix of it within one module, without ``{module}``. The type
+name starts at the first capitalized name, as Java naming conventions have it, so
+``vendor.api.util.Thing.Inner`` under ``vendor.api`` links to
+``vendor/api/util/Thing.Inner.html``:
 
 .. code-block:: python
 

{sphinx_java_autodoc-0.5.0 → sphinx_java_autodoc-0.7.0}/examples/standalone/src/demo/Widget.java

@@ -29,6 +29,10 @@ import java.util.Map;
  * <td>Labelled {@value #LABEL}; long names such as
  * {@code com.example.widgets.configuration.DefaultWidgetLabelProvider} stay inside the table</td></tr>
  * </table>
+ * <h2>Terms</h2>
+ * <dl><dt><dfn>Label</dfn></dt><dd>Text shown with each value, up to 2<sup>31</sup> characters.</dd>
+ * <dt>Shortcut</dt><dd>Copy with <kbd>Ctrl</kbd>+<kbd>C</kbd>; files go to
+ * {@systemProperty user.home}.</dd></dl>
  * @see Point
  * @since 1.0
  */

{sphinx_java_autodoc-0.5.0 → sphinx_java_autodoc-0.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sphinx-java-autodoc"
-version = "0.5.0"
+version = "0.7.0"
 description = "Compiler-backed Java API documentation in native Sphinx nodes"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -14,6 +14,7 @@ authors = [{ name = "Ralph Offinger" }]
 keywords = ["sphinx", "java", "javadoc", "documentation", "autodoc"]
 classifiers = [
     "Development Status :: 3 - Alpha",
+    "Framework :: Sphinx :: Domain",
     "Framework :: Sphinx :: Extension",
     "Intended Audience :: Developers",
     "Operating System :: OS Independent",
@@ -24,7 +25,7 @@ classifiers = [
     "Programming Language :: Java",
     "Topic :: Documentation :: Sphinx",
 ]
-dependencies = ["Sphinx>=9.1,<9.2"]
+dependencies = ["Sphinx>=8.2,<9.2"]
 
 [project.optional-dependencies]
 test = ["pytest>=8", "build>=1", "playwright>=1.50"]

{sphinx_java_autodoc-0.5.0 → sphinx_java_autodoc-0.7.0}/src/sphinx_java_autodoc/__init__.py

@@ -61,7 +61,9 @@ def prepare(app):
     app.env.java_model_path = str(model.path)
     use_model(root)
     for diagnostic in root.findall("diagnostic"):
-        LOGGER.warning(diagnostic.text, type="java", subtype="extract")
+        # The kind lets suppress_warnings = ["java.inherit"] keep the other warnings.
+        subtype = diagnostic.get("kind", "extract")
+        LOGGER.warning(diagnostic.text, type="java", subtype=subtype)
     if config.java_generate:
         directory = (Path(app.srcdir) / config.java_generate).resolve()
         if (
@@ -95,7 +97,6 @@ def setup(app):
         "java_encoding": "UTF-8",
         "java_exclude_packages": [],
         "java_jdk": "",
-        "java_release": "",
         "java_model": "",
         "java_generate": "",
         "java_visibility": "protected",
@@ -103,13 +104,16 @@ def setup(app):
         "java_maximum_signature_line_length": None,
     }.items():
         app.add_config_value(name, default, "env")
+    # A release is often written as a number, such as java_release = 17.
+    app.add_config_value("java_release", "", "env", types=frozenset({str, int}))
     app.add_domain(JavaDomain)
     add_linkcode_domain("java", ["fullname", "source", "line"])
     app.add_css_file("java-autodoc.css")
     app.connect("builder-inited", add_static_path)
     app.connect("builder-inited", prepare)
     app.connect("env-get-outdated", outdated)
-    app.connect("missing-reference", quiet_reference)
+    # After intersphinx (priority 500), whatever the extension order.
+    app.connect("missing-reference", quiet_reference, priority=900)
     return {
         "version": VERSION,
         "env_version": 4,

{sphinx_java_autodoc-0.5.0 → sphinx_java_autodoc-0.7.0}/src/sphinx_java_autodoc/domain.py

@@ -118,15 +118,10 @@ def summary_type(element) -> list[nodes.Node]:
         else:
             tokens.append(sig[i])
         i += 1
-    owner = SYMBOLS.get(element.get("id").partition("#")[0])
-    interface = owner is not None and owner.get("kind") in {
-        "interface",
-        "annotation_type",
-    }
     modifiers = []
     while tokens and (tokens[0].tag == "k" or tokens[0].text == " "):
         text = tokens.pop(0).text
-        if text in SUMMARY_MODIFIERS and not (interface and text == "abstract"):
+        if text in SUMMARY_MODIFIERS:
             modifiers.append(text)
     if tokens and tokens[-1].tag == "t" and tokens[-1].text == " ":
         tokens.pop()
@@ -148,6 +143,11 @@ def display_name(symbol: str) -> str:
     return f"{owner}.{member_label(symbol)}" if member else symbol
 
 
+def canonical(spelling: str) -> str:
+    """A hand-written symbol as a model ID: no spaces, and varargs ``...`` as ``[]``."""
+    return re.sub(r"\s+", "", spelling).replace("...", "[]")
+
+
 class JavaDirective(SphinxDirective):
     def visible(self, element) -> bool:
         return visible(
@@ -246,10 +246,10 @@ class AutoClass(JavaDirective):
         if "members" in self.options:
             # Semicolons allow exact signatures containing commas.
             selected = {
-                s.strip() for s in self.options["members"].split(";") if s.strip()
+                canonical(s) for s in self.options["members"].split(";") if s.strip()
             }
             excluded = {
-                s.strip()
+                canonical(s)
                 for s in self.options.get("exclude-members", "").split(";")
                 if s.strip()
             }
@@ -287,8 +287,8 @@ class AutoMember(JavaDirective):
     option_spec = {"no-index": directives.flag}
 
     def run(self):
-        symbol = re.sub(r"\s+", "", self.arguments[0])
-        element = self.lookup(symbol.replace("...", "[]"), ("member",))
+        symbol = canonical(self.arguments[0])
+        element = self.lookup(symbol, ("member",))
         if element is None:
             self.missing("member", symbol, "member")
             return []
@@ -343,7 +343,7 @@ class AutoSummary(JavaDirective):
         table = nodes.table("", classes=["autosummary", "longtable", "java"])
         rows = []
         for line in self.content:
-            symbol = re.sub(r"\s+", "", line)
+            symbol = canonical(line)
             if not symbol:
                 continue
             element = self.lookup(symbol)
@@ -441,8 +441,9 @@ class JavaDomain(Domain):
             yield symbol, display_name(symbol), kind, docname, target, 0
 
     def resolve_xref(self, env, fromdocname, builder, typ, target, node, contnode):
+        # External Javadoc fragments keep the spelling's varargs.
         spelling = re.sub(r"\s+", "", target)
-        target = spelling.replace("...", "[]")
+        target = canonical(target)
         objects = self.data["objects"]
         # Only member names can omit their parameter list.
         if target not in objects and "#" in target and "(" not in target:

{sphinx_java_autodoc-0.5.0 → sphinx_java_autodoc-0.7.0}/src/sphinx_java_autodoc/extractor.py

@@ -7,6 +7,7 @@ import json
 import os
 from pathlib import Path
 import re
+import secrets
 import shutil
 import subprocess
 import tempfile
@@ -16,9 +17,11 @@ from sphinx.errors import ExtensionError
 
 from .model import Model, read_model
 
-VERSION = "0.5.0"  # x-release-please-version
+VERSION = "0.7.0"  # x-release-please-version
 DOCLET = Path(__file__).parent / "java" / "SphinxDoclet.java"
 PACKAGE = re.compile(r"[^\W\d]\w*(?:\.[^\W\d]\w*)*")
+# The JVM announces options from variables such as JAVA_TOOL_OPTIONS on stderr.
+JVM_NOTICE = re.compile(r"(NOTE: )?Picked up \w+:")
 
 
 def run(arguments: list[str], *, cwd: Path | None = None) -> str:
@@ -50,15 +53,20 @@ def atomic_write(path: Path, data: bytes) -> None:
     path.parent.mkdir(parents=True, exist_ok=True)
     if path.exists() and path.read_bytes() == data:
         return
-    with tempfile.NamedTemporaryFile(dir=path.parent, delete=False) as stream:
-        temporary = Path(stream.name)
-        try:
+    temporary = path.with_name(f".{path.name}.{secrets.token_hex(8)}.tmp")
+    # O_EXCL refuses an existing file or planted symlink; the umask applies to 0o666.
+    # Opened before the try, so the cleanup never removes a file it did not create.
+    fd = os.open(
+        temporary,
+        os.O_WRONLY | os.O_CREAT | os.O_EXCL | getattr(os, "O_BINARY", 0),
+        0o666,
+    )
+    try:
+        with os.fdopen(fd, "wb") as stream:
             stream.write(data)
-            stream.flush()
-            stream.close()
-            os.replace(temporary, path)
-        finally:
-            temporary.unlink(missing_ok=True)
+        os.replace(temporary, path)
+    finally:
+        temporary.unlink(missing_ok=True)
 
 
 def extract(
@@ -243,7 +251,12 @@ def extract(
             ),
             encoding="utf-8",
         )
-        diagnostics = run([tools["javadoc"], "@" + str(argfile)], cwd=work)
+        printed = run([tools["javadoc"], "@" + str(argfile)], cwd=work)
+        diagnostics = "".join(
+            line
+            for line in printed.splitlines(keepends=True)
+            if not JVM_NOTICE.match(line)
+        )
         root = read_model(output)
         root.set("extractor", VERSION)
         if diagnostics.strip():