From b239fe2b962fdf494c9fb60066e406985cf1ee24 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Wed, 12 Aug 2026 13:32:46 +0000
Subject: [PATCH] fix(transpile): #6664 serialize XMIR into one string

The "serialize" template in classes.xsl wrote the XMIR of an object into
"<xmir>" piece by piece - one instruction per indent, per angle bracket,
per name and five per attribute. Since jcabi-xml runs every stylesheet
DOM to DOM, each of those pieces became a separate DOM text node, so a
single "<xmir>" of a large eo-runtime object ended up holding tens of
thousands of them. Building those nodes, and then reading them back
through a DOM that has to merge adjacent text to answer "text()", cost
far more than the concatenation itself: the pass alone was two fifths of
the whole transpile train, and xsline warned "XSL 'classes' took 4s".

It is now an "xsl:function" returning one string, written with one
"xsl:value-of", so "<xmir>" holds exactly one text node. The recursive
call sits inside the enclosing "concat", which copies a subtree's string
once per level of depth above it - measurably cheaper than returning a
sequence of pieces and joining them at the end.

Over all 170 sources of eo-runtime/src/main/eo, the pass drops from 21.5s
to 1.0s and the whole nine-stylesheet train from 56.9s to 34.4s (the
train gains more than the pass saves, because the downstream stylesheets
no longer walk those adjacent text nodes). The output is byte-identical,
both of this pass and of the train that ends in the generated Java.

The class-matching pattern loses its redundant second "eo:atom" call at
the same time: "not(A) or (A and B)" is "not(A) or B".

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01GevVXivd1KDNnCHqKW9rua
---
 .../org/eolang/maven/transpile/classes.xsl    | 83 +++++++++----------
 1 file changed, 40 insertions(+), 43 deletions(-)

diff --git a/eo-maven-plugin/src/main/resources/org/eolang/maven/transpile/classes.xsl b/eo-maven-plugin/src/main/resources/org/eolang/maven/transpile/classes.xsl
index 1be67aecd67..8fe7e35f005 100644
--- a/eo-maven-plugin/src/main/resources/org/eolang/maven/transpile/classes.xsl
+++ b/eo-maven-plugin/src/main/resources/org/eolang/maven/transpile/classes.xsl
@@ -3,47 +3,47 @@
 * SPDX-FileCopyrightText: Copyright (c) 2016-2026 Objectionary.com
 * SPDX-License-Identifier: MIT
 -->
-<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:eo="https://www.eolang.org" exclude-result-prefixes="eo" id="classes" version="2.0">
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:eo="https://www.eolang.org" xmlns:xs="http://www.w3.org/2001/XMLSchema" exclude-result-prefixes="eo xs" id="classes" version="2.0">
   <xsl:import href="/org/eolang/parser/_funcs.xsl"/>
   <xsl:output encoding="UTF-8" method="xml"/>
-  <xsl:template name="serialize">
-    <xsl:param name="node"/>
-    <xsl:param name="indent"/>
-    <xsl:variable name="name" select="name($node)"/>
-    <xsl:value-of select="$indent"/>
-    <xsl:text>&lt;</xsl:text>
-    <xsl:value-of select="$name"/>
-    <xsl:for-each select="$node/@*">
-      <xsl:text> </xsl:text>
-      <xsl:value-of select="name()"/>
-      <xsl:text>="</xsl:text>
-      <xsl:value-of select="."/>
-      <xsl:text>"</xsl:text>
-    </xsl:for-each>
-    <xsl:variable name="content" select="normalize-space(string(text()[1]))"/>
-    <xsl:if test="$content = '' and not($node/element())">
-      <xsl:text>/</xsl:text>
-    </xsl:if>
-    <xsl:text>&gt;</xsl:text>
-    <xsl:value-of select="$content"/>
-    <xsl:if test="$node/element()">
-      <xsl:for-each select="$node/element()">
-        <xsl:value-of select="'&#10;'"/>
-        <xsl:call-template name="serialize">
-          <xsl:with-param name="node" select="."/>
-          <xsl:with-param name="indent" select="concat($indent, '  ')"/>
-        </xsl:call-template>
-      </xsl:for-each>
-      <xsl:value-of select="'&#10;'"/>
-      <xsl:value-of select="$indent"/>
-    </xsl:if>
-    <xsl:if test="$content != '' or $node/element()">
-      <xsl:text>&lt;/</xsl:text>
-      <xsl:value-of select="$name"/>
-      <xsl:text>&gt;</xsl:text>
-    </xsl:if>
-  </xsl:template>
-  <xsl:template match="object/o[not(eo:atom(.)) or (eo:atom(.) and count(./o[eo:test-attr(.)])&gt;0)]" priority="1">
+  <!--
+  The XMIR of an object, indented, as the text that "to-java" turns into the
+  Javadoc of the generated class. It is one function returning one string,
+  rather than a template writing many small pieces of text, because the result
+  tree we write into is a DOM: every "xsl:text" or "xsl:value-of" a template
+  executes becomes a separate DOM text node, and a template that spelled a
+  start tag out piece by piece - indent, "&lt;", name, then five pieces per
+  attribute - left tens of thousands of them behind for a single object. Both
+  building that many nodes and later reading them back (the DOM has to merge
+  adjacent text nodes to answer "text()") cost far more than the string
+  concatenation itself, so serializing the biggest objects of "eo-runtime"
+  took seconds each and this pass alone was two fifths of the whole transpile
+  train (#6664).
+
+  Nesting the recursive call inside the enclosing "concat" means the string of
+  a subtree is copied once per level of depth above it, which for the depth of
+  a real XMIR is far cheaper than the per-node bookkeeping it replaces:
+  returning a sequence of pieces and joining them at the end, instead, is
+  three times slower here.
+  -->
+  <xsl:function name="eo:serialize" as="xs:string">
+    <xsl:param name="node" as="element()"/>
+    <xsl:param name="indent" as="xs:string"/>
+    <xsl:variable name="name" as="xs:string" select="name($node)"/>
+    <xsl:variable name="kids" as="element()*" select="$node/*"/>
+    <xsl:variable name="content" as="xs:string" select="normalize-space(string($node/text()[1]))"/>
+    <!-- An object with neither data nor children is written as a single self-closing tag. -->
+    <xsl:variable name="void" as="xs:boolean" select="$content = '' and empty($kids)"/>
+    <xsl:variable name="deeper" as="xs:string" select="concat($indent, '  ')"/>
+    <xsl:sequence select="concat($indent, '&lt;', $name, string-join(for $a in $node/@* return concat(' ', name($a), '=&quot;', $a, '&quot;'), ''), if ($void) then '/&gt;' else '&gt;', $content, string-join(for $k in $kids return concat('&#10;', eo:serialize($k, $deeper)), ''), if (empty($kids)) then '' else concat('&#10;', $indent), if ($void) then '' else concat('&lt;/', $name, '&gt;'))"/>
+  </xsl:function>
+  <!--
+  An atom is a class only when it holds tests, since it is the tests that need
+  a Java class of their own - "to-java" writes no ".java" for it, only its
+  tests. Spelled as "not atom, or has a test attribute", because when it is
+  not an atom the second half of the question does not need asking.
+  -->
+  <xsl:template match="object/o[not(eo:atom(.)) or exists(o[eo:test-attr(.)])]" priority="1">
     <xsl:apply-templates select="." mode="class"/>
   </xsl:template>
   <xsl:template match="object/o[@base and @name]" priority="2">
@@ -67,10 +67,7 @@
         </xsl:otherwise>
       </xsl:choose>
       <xmir>
-        <xsl:call-template name="serialize">
-          <xsl:with-param name="node" select="."/>
-          <xsl:with-param name="indent" select="''"/>
-        </xsl:call-template>
+        <xsl:value-of select="eo:serialize(., '')"/>
       </xmir>
     </class>
   </xsl:template>