1 /*
   2  * Copyright (c) 2022, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 package jdk.internal.classfile.impl;
  26 
  27 import java.lang.constant.ConstantDesc;
  28 import java.lang.constant.DirectMethodHandleDesc;
  29 import java.lang.reflect.AccessFlag;
  30 import java.util.AbstractList;
  31 import java.util.Arrays;
  32 import java.util.Collection;
  33 import java.util.Collections;
  34 import java.util.LinkedHashMap;
  35 import java.util.LinkedList;
  36 import java.util.List;
  37 import java.util.Map;
  38 import java.util.Objects;
  39 import java.util.function.BiConsumer;
  40 import java.util.Set;
  41 import java.util.function.Consumer;
  42 import java.util.stream.IntStream;
  43 import java.util.stream.Stream;
  44 import jdk.internal.classfile.Annotation;
  45 
  46 import jdk.internal.classfile.AnnotationElement;
  47 import jdk.internal.classfile.AnnotationValue;
  48 import jdk.internal.classfile.AnnotationValue.*;
  49 import jdk.internal.classfile.Attribute;
  50 import jdk.internal.classfile.ClassModel;
  51 import jdk.internal.classfile.components.ClassPrinter.*;
  52 import jdk.internal.classfile.CodeModel;
  53 import jdk.internal.classfile.Instruction;
  54 import jdk.internal.classfile.MethodModel;
  55 import jdk.internal.classfile.TypeAnnotation;
  56 import jdk.internal.classfile.attribute.*;
  57 import jdk.internal.classfile.attribute.StackMapFrameInfo.*;
  58 import jdk.internal.classfile.constantpool.*;
  59 import jdk.internal.classfile.instruction.*;
  60 
  61 import static jdk.internal.classfile.Classfile.*;
  62 import jdk.internal.classfile.CompoundElement;
  63 import jdk.internal.classfile.FieldModel;
  64 import static jdk.internal.classfile.impl.ClassPrinterImpl.Style.*;
  65 
  66 public final class ClassPrinterImpl {
  67 
  68     public enum Style { BLOCK, FLOW }
  69 
  70     public record LeafNodeImpl(ConstantDesc name, ConstantDesc value) implements LeafNode {
  71 
  72         @Override
  73         public Stream<Node> walk() {
  74             return Stream.of(this);
  75         }
  76     }
  77 
  78     public static final class ListNodeImpl extends AbstractList<Node> implements ListNode {
  79 
  80         private final Style style;
  81         private final ConstantDesc name;
  82         private final Node[] nodes;
  83 
  84         public ListNodeImpl(Style style, ConstantDesc name, Stream<Node> nodes) {
  85             this.style = style;
  86             this.name = name;
  87             this.nodes = nodes.toArray(Node[]::new);
  88         }
  89 
  90         @Override
  91         public ConstantDesc name() {
  92             return name;
  93         }
  94 
  95         @Override
  96         public Stream<Node> walk() {
  97             return Stream.concat(Stream.of(this), stream().flatMap(Node::walk));
  98         }
  99 
 100         public Style style() {
 101             return style;
 102         }
 103 
 104         @Override
 105         public Node get(int index) {
 106             Objects.checkIndex(index, nodes.length);
 107             return nodes[index];
 108         }
 109 
 110         @Override
 111         public int size() {
 112             return nodes.length;
 113         }
 114     }
 115 
 116     public static final class MapNodeImpl implements MapNode {
 117 
 118         private final Style style;
 119         private final ConstantDesc name;
 120         private final Map<ConstantDesc, Node> map;
 121 
 122         public MapNodeImpl(Style style, ConstantDesc name) {
 123             this.style = style;
 124             this.name = name;
 125             this.map = new LinkedHashMap<>();
 126         }
 127 
 128         @Override
 129         public ConstantDesc name() {
 130             return name;
 131         }
 132 
 133         @Override
 134         public Stream<Node> walk() {
 135             return Stream.concat(Stream.of(this), values().stream().flatMap(Node::walk));
 136         }
 137 
 138         public Style style() {
 139             return style;
 140         }
 141 
 142         @Override
 143         public int size() {
 144             return map.size();
 145         }
 146         @Override
 147         public boolean isEmpty() {
 148             return map.isEmpty();
 149         }
 150         @Override
 151         public boolean containsKey(Object key) {
 152             return map.containsKey(key);
 153         }
 154         @Override
 155         public boolean containsValue(Object value) {
 156             return map.containsValue(value);
 157         }
 158 
 159         @Override
 160         public Node get(Object key) {
 161             return map.get(key);
 162         }
 163 
 164         @Override
 165         public Node put(ConstantDesc key, Node value) {
 166             throw new UnsupportedOperationException();
 167         }
 168 
 169         @Override
 170         public Node remove(Object key) {
 171             throw new UnsupportedOperationException();
 172         }
 173 
 174         @Override
 175         public void putAll(Map<? extends ConstantDesc, ? extends Node> m) {
 176             throw new UnsupportedOperationException();
 177         }
 178 
 179         @Override
 180         public void clear() {
 181             throw new UnsupportedOperationException();
 182         }
 183 
 184         @Override
 185         public Set<ConstantDesc> keySet() {
 186             return Collections.unmodifiableSet(map.keySet());
 187         }
 188 
 189         @Override
 190         public Collection<Node> values() {
 191             return Collections.unmodifiableCollection(map.values());
 192         }
 193 
 194         @Override
 195         public Set<Entry<ConstantDesc, Node>> entrySet() {
 196             return Collections.unmodifiableSet(map.entrySet());
 197         }
 198 
 199 
 200         MapNodeImpl with(Node... nodes) {
 201             for (var n : nodes)
 202                 if (n != null && map.put(n.name(), n) != null)
 203                     throw new AssertionError("Double entry of " + n.name() + " into " + name);
 204             return this;
 205         }
 206     }
 207 
 208     private static Node leaf(ConstantDesc name, ConstantDesc value) {
 209         return new LeafNodeImpl(name, value);
 210     }
 211 
 212     private static Node[] leafs(ConstantDesc... namesAndValues) {
 213         if ((namesAndValues.length & 1) > 0)
 214             throw new AssertionError("Odd number of arguments: " + Arrays.toString(namesAndValues));
 215         var nodes = new Node[namesAndValues.length >> 1];
 216         for (int i = 0, j = 0; i < nodes.length; i ++) {
 217             nodes[i] = leaf(namesAndValues[j++], namesAndValues[j++]);
 218         }
 219         return nodes;
 220     }
 221 
 222     private static Node list(ConstantDesc listName, ConstantDesc itemsName, Stream<ConstantDesc> values) {
 223         return new ListNodeImpl(FLOW, listName, values.map(v -> leaf(itemsName, v)));
 224     }
 225 
 226     private static Node map(ConstantDesc mapName, ConstantDesc... keysAndValues) {
 227         return new MapNodeImpl(FLOW, mapName).with(leafs(keysAndValues));
 228     }
 229 
 230     private static final String NL = System.lineSeparator();
 231 
 232     private static final char[] DIGITS = "0123456789ABCDEF".toCharArray();
 233 
 234     private static void escape(int c, StringBuilder sb) {
 235         switch (c) {
 236             case '\\'  -> sb.append('\\').append('\\');
 237             case '"' -> sb.append('\\').append('"');
 238             case '\b' -> sb.append('\\').append('b');
 239             case '\n' -> sb.append('\\').append('n');
 240             case '\t' -> sb.append('\\').append('t');
 241             case '\f' -> sb.append('\\').append('f');
 242             case '\r' -> sb.append('\\').append('r');
 243             default -> {
 244                 if (c >= 0x20 && c < 0x7f) {
 245                     sb.append((char)c);
 246                 } else {
 247                     sb.append('\\').append('u').append(DIGITS[(c >> 12) & 0xf])
 248                             .append(DIGITS[(c >> 8) & 0xf]).append(DIGITS[(c >> 4) & 0xf]).append(DIGITS[(c) & 0xf]);
 249                 }
 250             }
 251         }
 252     }
 253 
 254     public static void toYaml(Node node, Consumer<String> out) {
 255         toYaml(0, false, new ListNodeImpl(BLOCK, null, Stream.of(node)), out);
 256         out.accept(NL);
 257     }
 258 
 259     private static void toYaml(int indent, boolean skipFirstIndent, Node node, Consumer<String> out) {
 260         switch (node) {
 261             case LeafNode leaf -> {
 262                 out.accept(quoteAndEscapeYaml(leaf.value()));
 263             }
 264             case ListNodeImpl list -> {
 265                 switch (list.style()) {
 266                     case FLOW -> {
 267                         out.accept("[");
 268                         boolean first = true;
 269                         for (var n : list) {
 270                             if (first) first = false;
 271                             else out.accept(", ");
 272                             toYaml(0, false, n, out);
 273                         }
 274                         out.accept("]");
 275                     }
 276                     case BLOCK -> {
 277                         for (var n : list) {
 278                             out.accept(NL + "    ".repeat(indent) + "  - ");
 279                             toYaml(indent + 1, true, n, out);
 280                         }
 281                     }
 282                 }
 283             }
 284             case MapNodeImpl map -> {
 285                 switch (map.style()) {
 286                     case FLOW -> {
 287                         out.accept("{");
 288                         boolean first = true;
 289                         for (var n : map.values()) {
 290                             if (first) first = false;
 291                             else out.accept(", ");
 292                             out.accept(quoteAndEscapeYaml(n.name()) + ": ");
 293                             toYaml(0, false, n, out);
 294                         }
 295                         out.accept("}");
 296                     }
 297                     case BLOCK -> {
 298                         for (var n : map.values()) {
 299                             if (skipFirstIndent) {
 300                                 skipFirstIndent = false;
 301                             } else {
 302                                 out.accept(NL + "    ".repeat(indent));
 303                             }
 304                             out.accept(quoteAndEscapeYaml(n.name()) + ": ");
 305                             toYaml(n instanceof ListNodeImpl pl && pl.style() == BLOCK ? indent : indent + 1, false, n, out);
 306                         }
 307                     }
 308                 }
 309             }
 310         }
 311     }
 312 
 313     private static String quoteAndEscapeYaml(ConstantDesc value) {
 314         String s = String.valueOf(value);
 315         if (value instanceof Number) return s;
 316         if (s.length() == 0) return "''";
 317         var sb = new StringBuilder(s.length() << 1);
 318         s.chars().forEach(c -> {
 319             switch (c) {
 320                 case '\''  -> sb.append("''");
 321                 default -> escape(c, sb);
 322             }});
 323         String esc = sb.toString();
 324         if (esc.length() != s.length()) return "'" + esc + "'";
 325         switch (esc.charAt(0)) {
 326             case '-', '?', ':', ',', '[', ']', '{', '}', '#', '&', '*', '!', '|', '>', '\'', '"', '%', '@', '`':
 327                 return "'" + esc + "'";
 328         }
 329         for (int i = 1; i < esc.length(); i++) {
 330             switch (esc.charAt(i)) {
 331                 case ',', '[', ']', '{', '}':
 332                     return "'" + esc + "'";
 333             }
 334         }
 335         return esc;
 336     }
 337 
 338     public static void toJson(Node node, Consumer<String> out) {
 339         toJson(1, true, node, out);
 340         out.accept(NL);
 341     }
 342 
 343     private static void toJson(int indent, boolean skipFirstIndent, Node node, Consumer<String> out) {
 344         switch (node) {
 345             case LeafNode leaf -> {
 346                 out.accept(quoteAndEscapeJson(leaf.value()));
 347             }
 348             case ListNodeImpl list -> {
 349                 out.accept("[");
 350                 boolean first = true;
 351                 switch (list.style()) {
 352                     case FLOW -> {
 353                         for (var n : list) {
 354                             if (first) first = false;
 355                             else out.accept(", ");
 356                             toJson(0, false, n, out);
 357                         }
 358                     }
 359                     case BLOCK -> {
 360                         for (var n : list) {
 361                             if (first) first = false;
 362                             else out.accept(",");
 363                             out.accept(NL + "    ".repeat(indent));
 364                             toJson(indent + 1, true, n, out);
 365                         }
 366                     }
 367                 }
 368                 out.accept("]");
 369             }
 370             case MapNodeImpl map -> {
 371                 switch (map.style()) {
 372                     case FLOW -> {
 373                         out.accept("{");
 374                         boolean first = true;
 375                         for (var n : map.values()) {
 376                             if (first) first = false;
 377                             else out.accept(", ");
 378                             out.accept(quoteAndEscapeJson(n.name().toString()) + ": ");
 379                             toJson(0, false, n, out);
 380                         }
 381                     }
 382                     case BLOCK -> {
 383                         if (skipFirstIndent) out.accept("  { ");
 384                         else out.accept("{");
 385                         boolean first = true;
 386                         for (var n : map.values()) {
 387                             if (first) first = false;
 388                             else out.accept(",");
 389                             if (skipFirstIndent) skipFirstIndent = false;
 390                             else out.accept(NL + "    ".repeat(indent));
 391                             out.accept(quoteAndEscapeJson(n.name().toString()) + ": ");
 392                             toJson(indent + 1, false, n, out);
 393                         }
 394                     }
 395                 }
 396                 out.accept("}");
 397             }
 398         }
 399     }
 400 
 401     private static String quoteAndEscapeJson(ConstantDesc value) {
 402         String s = String.valueOf(value);
 403         if (value instanceof Number) return s;
 404         var sb = new StringBuilder(s.length() << 1);
 405         sb.append('"');
 406         s.chars().forEach(c -> escape(c, sb));
 407         sb.append('"');
 408         return sb.toString();
 409     }
 410 
 411     public static void toXml(Node node, Consumer<String> out) {
 412         out.accept("<?xml version = '1.0'?>");
 413         toXml(0, false, node, out);
 414         out.accept(NL);
 415     }
 416 
 417     private static void toXml(int indent, boolean skipFirstIndent, Node node, Consumer<String> out) {
 418         var name = toXmlName(node.name().toString());
 419         switch (node) {
 420             case LeafNode leaf -> {
 421                 out.accept("<" + name + ">");
 422                 out.accept(xmlEscape(leaf.value()));
 423             }
 424             case ListNodeImpl list -> {
 425                 switch (list.style()) {
 426                     case FLOW -> {
 427                         out.accept("<" + name + ">");
 428                         for (var n : list) {
 429                             toXml(0, false, n, out);
 430                         }
 431                     }
 432                     case BLOCK -> {
 433                         if (!skipFirstIndent)
 434                             out.accept(NL + "    ".repeat(indent));
 435                         out.accept("<" + name + ">");
 436                         for (var n : list) {
 437                             out.accept(NL + "    ".repeat(indent + 1));
 438                             toXml(indent + 1, true, n, out);
 439                         }
 440                     }
 441                 }
 442             }
 443             case MapNodeImpl map -> {
 444                 switch (map.style()) {
 445                     case FLOW -> {
 446                         out.accept("<" + name + ">");
 447                         for (var n : map.values()) {
 448                             toXml(0, false, n, out);
 449                         }
 450                     }
 451                     case BLOCK -> {
 452                         if (!skipFirstIndent)
 453                             out.accept(NL + "    ".repeat(indent));
 454                         out.accept("<" + name + ">");
 455                         for (var n : map.values()) {
 456                             out.accept(NL + "    ".repeat(indent + 1));
 457                             toXml(indent + 1, true, n, out);
 458                         }
 459                     }
 460                 }
 461             }
 462         }
 463         out.accept("</" + name + ">");
 464     }
 465 
 466     private static String xmlEscape(ConstantDesc value) {
 467         var s = String.valueOf(value);
 468         var sb = new StringBuilder(s.length() << 1);
 469         s.chars().forEach(c -> {
 470         switch (c) {
 471             case '<'  -> sb.append("&lt;");
 472             case '>'  -> sb.append("&gt;");
 473             case '"'  -> sb.append("&quot;");
 474             case '&'  -> sb.append("&amp;");
 475             case '\''  -> sb.append("&apos;");
 476             default -> escape(c, sb);
 477         }});
 478         return sb.toString();
 479     }
 480 
 481     private static String toXmlName(String name) {
 482         if (Character.isDigit(name.charAt(0)))
 483             name = "_" + name;
 484         return name.replaceAll("[^A-Za-z_0-9]", "_");
 485     }
 486 
 487     private static Node[] elementValueToTree(AnnotationValue v) {
 488         return switch (v) {
 489             case OfString cv -> leafs("string", String.valueOf(cv.constantValue()));
 490             case OfDouble cv -> leafs("double", String.valueOf(cv.constantValue()));
 491             case OfFloat cv -> leafs("float", String.valueOf(cv.constantValue()));
 492             case OfLong cv -> leafs("long", String.valueOf(cv.constantValue()));
 493             case OfInteger cv -> leafs("int", String.valueOf(cv.constantValue()));
 494             case OfShort cv -> leafs("short", String.valueOf(cv.constantValue()));
 495             case OfCharacter cv -> leafs("char", String.valueOf(cv.constantValue()));
 496             case OfByte cv -> leafs("byte", String.valueOf(cv.constantValue()));
 497             case OfBoolean cv -> leafs("boolean", String.valueOf((int)cv.constantValue() != 0));
 498             case OfClass clv -> leafs("class", clv.className().stringValue());
 499             case OfEnum ev -> leafs("enum class", ev.className().stringValue(),
 500                                     "constant name", ev.constantName().stringValue());
 501             case OfAnnotation av -> leafs("annotation class", av.annotation().className().stringValue());
 502             case OfArray av -> new Node[]{new ListNodeImpl(FLOW, "array", av.values().stream().map(
 503                     ev -> new MapNodeImpl(FLOW, "value").with(elementValueToTree(ev))))};
 504         };
 505     }
 506 
 507     private static Node elementValuePairsToTree(List<AnnotationElement> evps) {
 508         return new ListNodeImpl(FLOW, "values", evps.stream().map(evp -> new MapNodeImpl(FLOW, "pair").with(
 509                 leaf("name", evp.name().stringValue()),
 510                 new MapNodeImpl(FLOW, "value").with(elementValueToTree(evp.value())))));
 511     }
 512 
 513     private static Stream<ConstantDesc> convertVTIs(CodeAttribute lr, List<VerificationTypeInfo> vtis) {
 514         return vtis.stream().mapMulti((vti, ret) -> {
 515             switch (vti) {
 516                 case SimpleVerificationTypeInfo s -> {
 517                     switch (s) {
 518                         case ITEM_DOUBLE -> {
 519                             ret.accept("double");
 520                             ret.accept("double2");
 521                         }
 522                         case ITEM_FLOAT ->
 523                             ret.accept("float");
 524                         case ITEM_INTEGER ->
 525                             ret.accept("int");
 526                         case ITEM_LONG ->  {
 527                             ret.accept("long");
 528                             ret.accept("long2");
 529                         }
 530                         case ITEM_NULL -> ret.accept("null");
 531                         case ITEM_TOP -> ret.accept("?");
 532                         case ITEM_UNINITIALIZED_THIS -> ret.accept("THIS");
 533                     }
 534                 }
 535                 case ObjectVerificationTypeInfo o ->
 536                     ret.accept(o.className().name().stringValue());
 537                 case UninitializedVerificationTypeInfo u ->
 538                     ret.accept("UNINITIALIZED @" + lr.labelToBci(u.newTarget()));
 539             }
 540         });
 541     }
 542 
 543     private record ExceptionHandler(int start, int end, int handler, String catchType) {}
 544 
 545     public static MapNode modelToTree(CompoundElement<?> model, Verbosity verbosity) {
 546         return switch(model) {
 547             case ClassModel cm -> classToTree(cm, verbosity);
 548             case FieldModel fm -> fieldToTree(fm, verbosity);
 549             case MethodModel mm -> methodToTree(mm, verbosity);
 550             case CodeModel com -> codeToTree((CodeAttribute)com, verbosity);
 551         };
 552     }
 553 
 554     private static MapNode classToTree(ClassModel clm, Verbosity verbosity) {
 555         return new MapNodeImpl(BLOCK, "class")
 556                 .with(leaf("class name", clm.thisClass().asInternalName()),
 557                       leaf("version", clm.majorVersion() + "." + clm.minorVersion()),
 558                       list("flags", "flag", clm.flags().flags().stream().map(AccessFlag::name)),
 559                       leaf("superclass", clm.superclass().map(ClassEntry::asInternalName).orElse("")),
 560                       list("interfaces", "interface", clm.interfaces().stream().map(ClassEntry::asInternalName)),
 561                       list("attributes", "attribute", clm.attributes().stream().map(Attribute::attributeName)))
 562                 .with(constantPoolToTree(clm.constantPool(), verbosity))
 563                 .with(attributesToTree(clm.attributes(), verbosity))
 564                 .with(new ListNodeImpl(BLOCK, "fields", clm.fields().stream().map(f ->
 565                     fieldToTree(f, verbosity))))
 566                 .with(new ListNodeImpl(BLOCK, "methods", clm.methods().stream().map(mm ->
 567                     methodToTree(mm, verbosity))));
 568     }
 569 
 570     private static Node[] constantPoolToTree(ConstantPool cp, Verbosity verbosity) {
 571         if (verbosity == Verbosity.TRACE_ALL) {
 572             var cpNode = new MapNodeImpl(BLOCK, "constant pool");
 573             for (PoolEntry e : cp) {
 574                 cpNode.with(new MapNodeImpl(FLOW, e.index())
 575                         .with(leaf("tag", switch (e.tag()) {
 576                             case TAG_UTF8 -> "Utf8";
 577                             case TAG_INTEGER -> "Integer";
 578                             case TAG_FLOAT -> "Float";
 579                             case TAG_LONG -> "Long";
 580                             case TAG_DOUBLE -> "Double";
 581                             case TAG_CLASS -> "Class";
 582                             case TAG_STRING -> "String";
 583                             case TAG_FIELDREF -> "Fieldref";
 584                             case TAG_METHODREF -> "Methodref";
 585                             case TAG_INTERFACEMETHODREF -> "InterfaceMethodref";
 586                             case TAG_NAMEANDTYPE -> "NameAndType";
 587                             case TAG_METHODHANDLE -> "MethodHandle";
 588                             case TAG_METHODTYPE -> "MethodType";
 589                             case TAG_CONSTANTDYNAMIC -> "Dynamic";
 590                             case TAG_INVOKEDYNAMIC -> "InvokeDynamic";
 591                             case TAG_MODULE -> "Module";
 592                             case TAG_PACKAGE -> "Package";
 593                             default -> throw new AssertionError("Unknown CP tag: " + e.tag());
 594                         }))
 595                         .with(switch (e) {
 596                             case ClassEntry ce -> leafs(
 597                                 "class name index", ce.name().index(),
 598                                 "class internal name", ce.asInternalName());
 599                             case ModuleEntry me -> leafs(
 600                                 "module name index", me.name().index(),
 601                                 "module name", me.name().stringValue());
 602                             case PackageEntry pe -> leafs(
 603                                 "package name index", pe.name().index(),
 604                                 "package name", pe.name().stringValue());
 605                             case StringEntry se -> leafs(
 606                                     "value index", se.utf8().index(),
 607                                     "value", se.stringValue());
 608                             case MemberRefEntry mre -> leafs(
 609                                     "owner index", mre.owner().index(),
 610                                     "name and type index", mre.nameAndType().index(),
 611                                     "owner", mre.owner().name().stringValue(),
 612                                     "name", mre.name().stringValue(),
 613                                     "type", mre.type().stringValue());
 614                             case NameAndTypeEntry nte -> leafs(
 615                                     "name index", nte.name().index(),
 616                                     "type index", nte.type().index(),
 617                                     "name", nte.name().stringValue(),
 618                                     "type", nte.type().stringValue());
 619                             case MethodHandleEntry mhe -> leafs(
 620                                     "reference kind", DirectMethodHandleDesc.Kind.valueOf(mhe.kind()).name(),
 621                                     "reference index", mhe.reference().index(),
 622                                     "owner", mhe.reference().owner().asInternalName(),
 623                                     "name", mhe.reference().name().stringValue(),
 624                                     "type", mhe.reference().type().stringValue());
 625                             case MethodTypeEntry mte -> leafs(
 626                                     "descriptor index", mte.descriptor().index(),
 627                                     "descriptor", mte.descriptor().stringValue());
 628                             case DynamicConstantPoolEntry dcpe -> new Node[] {
 629                                 leaf("bootstrap method handle index", dcpe.bootstrap().bootstrapMethod().index()),
 630                                 list("bootstrap method arguments indexes",
 631                                         "index", dcpe.bootstrap().arguments().stream().map(en -> en.index())),
 632                                 leaf("name and type index", dcpe.nameAndType().index()),
 633                                 leaf("name", dcpe.name().stringValue()),
 634                                 leaf("type", dcpe.type().stringValue())};
 635                             case AnnotationConstantValueEntry ve -> leafs(
 636                                 "value", String.valueOf(ve.constantValue())
 637                             );
 638                         }));
 639             }
 640             return new Node[]{cpNode};
 641         } else {
 642             return new Node[0];
 643         }
 644     }
 645 
 646     private static Node frameToTree(ConstantDesc name, CodeAttribute lr, StackMapFrameInfo f) {
 647         return new MapNodeImpl(FLOW, name).with(
 648                 list("locals", "item", convertVTIs(lr, f.locals())),
 649                 list("stack", "item", convertVTIs(lr, f.stack())));
 650     }
 651 
 652     private static MapNode fieldToTree(FieldModel f, Verbosity verbosity) {
 653         return new MapNodeImpl(BLOCK, "field")
 654                             .with(leaf("field name", f.fieldName().stringValue()),
 655                                   list("flags",
 656                                           "flag", f.flags().flags().stream().map(AccessFlag::name)),
 657                                   leaf("field type", f.fieldType().stringValue()),
 658                                   list("attributes",
 659                                           "attribute", f.attributes().stream().map(Attribute::attributeName)))
 660                             .with(attributesToTree(f.attributes(), verbosity));
 661     }
 662 
 663     public static MapNode methodToTree(MethodModel m, Verbosity verbosity) {
 664         return new MapNodeImpl(BLOCK, "method")
 665                 .with(leaf("method name", m.methodName().stringValue()),
 666                       list("flags",
 667                               "flag", m.flags().flags().stream().map(AccessFlag::name)),
 668                       leaf("method type", m.methodType().stringValue()),
 669                       list("attributes",
 670                               "attribute", m.attributes().stream().map(Attribute::attributeName)))
 671                 .with(attributesToTree(m.attributes(), verbosity))
 672                 .with(codeToTree((CodeAttribute)m.code().orElse(null), verbosity));
 673     }
 674 
 675     private static MapNode codeToTree(CodeAttribute com, Verbosity verbosity) {
 676         if (verbosity != Verbosity.MEMBERS_ONLY && com != null) {
 677             var codeNode = new MapNodeImpl(BLOCK, "code");
 678             codeNode.with(leaf("max stack", com.maxStack()));
 679             codeNode.with(leaf("max locals", com.maxLocals()));
 680             codeNode.with(list("attributes",
 681                     "attribute", com.attributes().stream().map(Attribute::attributeName)));
 682             var stackMap = new MapNodeImpl(BLOCK, "stack map frames");
 683             var visibleTypeAnnos = new LinkedHashMap<Integer, List<TypeAnnotation>>();
 684             var invisibleTypeAnnos = new LinkedHashMap<Integer, List<TypeAnnotation>>();
 685             List<LocalVariableInfo> locals = List.of();
 686             for (var attr : com.attributes()) {
 687                 if (attr instanceof StackMapTableAttribute smta) {
 688                     codeNode.with(stackMap);
 689                     for (var smf : smta.entries()) {
 690                         stackMap.with(frameToTree(com.labelToBci(smf.target()), com, smf));
 691                     }
 692                 } else if (verbosity == Verbosity.TRACE_ALL && attr != null) switch (attr) {
 693                     case LocalVariableTableAttribute lvta -> {
 694                         locals = lvta.localVariables();
 695                         codeNode.with(new ListNodeImpl(BLOCK, "local variables",
 696                                 IntStream.range(0, locals.size()).mapToObj(i -> {
 697                                     var lv = lvta.localVariables().get(i);
 698                                     return map(i + 1,
 699                                         "start", lv.startPc(),
 700                                         "end", lv.startPc() + lv.length(),
 701                                         "slot", lv.slot(),
 702                                         "name", lv.name().stringValue(),
 703                                         "type", lv.type().stringValue());
 704                                 })));
 705                     }
 706                     case LocalVariableTypeTableAttribute lvtta -> {
 707                         codeNode.with(new ListNodeImpl(BLOCK, "local variable types",
 708                                 IntStream.range(0, lvtta.localVariableTypes().size()).mapToObj(i -> {
 709                                     var lvt = lvtta.localVariableTypes().get(i);
 710                                     return map(i + 1,
 711                                         "start", lvt.startPc(),
 712                                         "end", lvt.startPc() + lvt.length(),
 713                                         "slot", lvt.slot(),
 714                                         "name", lvt.name().stringValue(),
 715                                         "signature", lvt.signature().stringValue());
 716                                 })));
 717                     }
 718                     case LineNumberTableAttribute lnta -> {
 719                         codeNode.with(new ListNodeImpl(BLOCK, "line numbers",
 720                                 IntStream.range(0, lnta.lineNumbers().size()).mapToObj(i -> {
 721                                     var ln = lnta.lineNumbers().get(i);
 722                                     return map(i + 1,
 723                                         "start", ln.startPc(),
 724                                         "line number", ln.lineNumber());
 725                                 })));
 726                     }
 727                     case CharacterRangeTableAttribute crta -> {
 728                         codeNode.with(new ListNodeImpl(BLOCK, "character ranges",
 729                                 IntStream.range(0, crta.characterRangeTable().size()).mapToObj(i -> {
 730                                     var cr = crta.characterRangeTable().get(i);
 731                                     return map(i + 1,
 732                                         "start", cr.startPc(),
 733                                         "end", cr.endPc(),
 734                                         "range start", cr.characterRangeStart(),
 735                                         "range end", cr.characterRangeEnd(),
 736                                         "flags", cr.flags());
 737                                 })));
 738                     }
 739                     case RuntimeVisibleTypeAnnotationsAttribute rvtaa ->
 740                         rvtaa.annotations().forEach(a -> forEachOffset(a, com, (off, an) ->
 741                                 visibleTypeAnnos.computeIfAbsent(off, o -> new LinkedList<>()).add(an)));
 742                     case RuntimeInvisibleTypeAnnotationsAttribute ritaa ->
 743                         ritaa.annotations().forEach(a -> forEachOffset(a, com, (off, an) ->
 744                                 invisibleTypeAnnos.computeIfAbsent(off, o -> new LinkedList<>()).add(an)));
 745                     case Object o -> {}
 746                 }
 747             }
 748             codeNode.with(attributesToTree(com.attributes(), verbosity));
 749             if (!stackMap.containsKey(0)) {
 750                 codeNode.with(new MapNodeImpl(FLOW, "//stack map frame @0").with(
 751                     list("locals", "item", convertVTIs(com, StackMapDecoder.initFrameLocals(com.parent().get()))),
 752                     list("stack", "item", Stream.of())));
 753             }
 754             var excHandlers = com.exceptionHandlers().stream().map(exc -> new ExceptionHandler(
 755                     com.labelToBci(exc.tryStart()),
 756                     com.labelToBci(exc.tryEnd()),
 757                     com.labelToBci(exc.handler()),
 758                     exc.catchType().map(ct -> ct.name().stringValue()).orElse(null))).toList();
 759             int bci = 0;
 760             for (var coe : com) {
 761                 if (coe instanceof Instruction ins) {
 762                     var frame = stackMap.get(bci);
 763                     if (frame != null) {
 764                         codeNode.with(new MapNodeImpl(FLOW, "//stack map frame @" + bci)
 765                                 .with(((MapNodeImpl)frame).values().toArray(new Node[2])));
 766                     }
 767                     var annos = invisibleTypeAnnos.get(bci);
 768                     if (annos != null) {
 769                         codeNode.with(typeAnnotationsToTree(FLOW, "//invisible type annotations @" + bci, annos));
 770                     }
 771                     annos = visibleTypeAnnos.get(bci);
 772                     if (annos != null) {
 773                         codeNode.with(typeAnnotationsToTree(FLOW, "//visible type annotations @" + bci, annos));
 774                     }
 775                     for (int i = 0; i < excHandlers.size(); i++) {
 776                         var exc = excHandlers.get(i);
 777                         if (exc.start() == bci) {
 778                             codeNode.with(map("//try block " + (i + 1) + " start",
 779                                     "start", exc.start(),
 780                                     "end", exc.end(),
 781                                     "handler", exc.handler(),
 782                                     "catch type", exc.catchType()));
 783                         }
 784                         if (exc.end() == bci) {
 785                             codeNode.with(map("//try block " + (i + 1) + " end",
 786                                     "start", exc.start(),
 787                                     "end", exc.end(),
 788                                     "handler", exc.handler(),
 789                                     "catch type", exc.catchType()));
 790                         }
 791                         if (exc.handler() == bci) {
 792                             codeNode.with(map("//exception handler " + (i + 1) + " start",
 793                                     "start", exc.start(),
 794                                     "end", exc.end(),
 795                                     "handler", exc.handler(),
 796                                     "catch type", exc.catchType()));
 797                         }
 798                     }
 799                     var in = new MapNodeImpl(FLOW, bci).with(leaf("opcode", ins.opcode().name()));
 800                     codeNode.with(in);
 801                     switch (coe) {
 802                         case IncrementInstruction inc ->  in.with(leafs(
 803                                 "slot", inc.slot(),
 804                                 "const", inc.constant()))
 805                                 .with(localInfoToTree(locals, inc.slot(), bci));
 806                         case LoadInstruction lv ->  in.with(leaf(
 807                                 "slot", lv.slot()))
 808                                 .with(localInfoToTree(locals, lv.slot(), bci));
 809                         case StoreInstruction lv ->  in.with(leaf(
 810                                 "slot", lv.slot()))
 811                                 .with(localInfoToTree(locals, lv.slot(), bci));
 812                         case FieldInstruction fa -> in.with(leafs(
 813                                 "owner", fa.owner().name().stringValue(),
 814                                 "field name", fa.name().stringValue(),
 815                                 "field type", fa.type().stringValue()));
 816                         case InvokeInstruction inv -> in.with(leafs(
 817                                 "owner", inv.owner().name().stringValue(),
 818                                 "method name", inv.name().stringValue(),
 819                                 "method type", inv.type().stringValue()));
 820                         case InvokeDynamicInstruction invd -> in.with(leafs(
 821                                 "name", invd.name().stringValue(),
 822                                 "descriptor", invd.type().stringValue(),
 823                                 "kind", invd.bootstrapMethod().kind().name(),
 824                                 "owner", invd.bootstrapMethod().owner().descriptorString(),
 825                                 "method name", invd.bootstrapMethod().methodName(),
 826                                 "invocation type", invd.bootstrapMethod().invocationType().descriptorString()));
 827                         case NewObjectInstruction newo -> in.with(leaf(
 828                                 "type", newo.className().name().stringValue()));
 829                         case NewPrimitiveArrayInstruction newa -> in.with(leafs(
 830                                 "dimensions", 1,
 831                                 "descriptor", newa.typeKind().typeName()));
 832                         case NewReferenceArrayInstruction newa -> in.with(leafs(
 833                                 "dimensions", 1,
 834                                 "descriptor", newa.componentType().name().stringValue()));
 835                         case NewMultiArrayInstruction newa -> in.with(leafs(
 836                                 "dimensions", newa.dimensions(),
 837                                 "descriptor", newa.arrayType().name().stringValue()));
 838                         case TypeCheckInstruction tch -> in.with(leaf(
 839                                 "type", tch.type().name().stringValue()));
 840                         case ConstantInstruction cons -> in.with(leaf(
 841                                 "constant value", cons.constantValue()));
 842                         case BranchInstruction br -> in.with(leaf(
 843                                 "target", com.labelToBci(br.target())));
 844                         case LookupSwitchInstruction si -> in.with(list(
 845                                 "targets", "target", Stream.concat(Stream.of(si.defaultTarget())
 846                                         .map(com::labelToBci), si.cases().stream()
 847                                                 .map(sc -> com.labelToBci(sc.target())))));
 848                         case TableSwitchInstruction si -> in.with(list(
 849                                 "targets", "target", Stream.concat(Stream.of(si.defaultTarget())
 850                                         .map(com::labelToBci), si.cases().stream()
 851                                                 .map(sc -> com.labelToBci(sc.target())))));
 852                         case DiscontinuedInstruction.JsrInstruction jsr -> in.with(leaf(
 853                                 "target", com.labelToBci(jsr.target())));
 854                         case DiscontinuedInstruction.RetInstruction ret ->  in.with(leaf(
 855                                 "slot", ret.slot()));
 856                         default -> {}
 857                     }
 858                     bci += ins.sizeInBytes();
 859                 }
 860             }
 861             if (!excHandlers.isEmpty()) {
 862                 var handlersNode = new MapNodeImpl(BLOCK, "exception handlers");
 863                 codeNode.with(handlersNode);
 864                 for (int i = 0; i < excHandlers.size(); i++) {
 865                     var exc = excHandlers.get(i);
 866                     handlersNode.with(map("handler " + (i + 1),
 867                             "start", exc.start(),
 868                             "end", exc.end(),
 869                             "handler", exc.handler(),
 870                             "type", exc.catchType()));
 871                 }
 872             }
 873             return codeNode;
 874         }
 875         return null;
 876     }
 877 
 878     private static Node[] attributesToTree(List<Attribute<?>> attributes, Verbosity verbosity) {
 879         var nodes = new LinkedList<Node>();
 880         if (verbosity != Verbosity.MEMBERS_ONLY) for (var attr : attributes) {
 881             switch (attr) {
 882                 case BootstrapMethodsAttribute bma ->
 883                     nodes.add(new ListNodeImpl(BLOCK, "bootstrap methods", bma.bootstrapMethods().stream().map(
 884                     bm -> {
 885                         var mh = bm.bootstrapMethod();
 886                         var mref = mh.reference();
 887                         return map("bm",
 888                                 "kind", DirectMethodHandleDesc.Kind.valueOf(mh.kind(),
 889                                         mref instanceof InterfaceMethodRefEntry).name(),
 890                                 "owner", mref.owner().name().stringValue(),
 891                                 "name", mref.nameAndType().name().stringValue(),
 892                                 "type", mref.nameAndType().type().stringValue());
 893                     })));
 894                 case ConstantValueAttribute cva ->
 895                     nodes.add(leaf("constant value", cva.constant().constantValue()));
 896                 case NestHostAttribute nha ->
 897                     nodes.add(leaf("nest host", nha.nestHost().name().stringValue()));
 898                 case NestMembersAttribute nma ->
 899                     nodes.add(list("nest members", "member", nma.nestMembers().stream()
 900                             .map(mp -> mp.name().stringValue())));
 901                 case PermittedSubclassesAttribute psa ->
 902                     nodes.add(list("permitted subclasses", "subclass", psa.permittedSubclasses().stream()
 903                             .map(e -> e.name().stringValue())));
 904                 case PreloadAttribute pa ->
 905                     nodes.add(list("preload classes", "class", pa.preloads().stream()
 906                             .map(e -> e.name().stringValue())));
 907                 default -> {}
 908             }
 909             if (verbosity == Verbosity.TRACE_ALL) switch (attr) {
 910                 case EnclosingMethodAttribute ema ->
 911                     nodes.add(map("enclosing method",
 912                             "class", ema.enclosingClass().name().stringValue(),
 913                             "method name", ema.enclosingMethodName()
 914                                     .map(Utf8Entry::stringValue).orElse("null"),
 915                             "method type", ema.enclosingMethodType()
 916                                     .map(Utf8Entry::stringValue).orElse("null")));
 917                 case ExceptionsAttribute exa ->
 918                     nodes.add(list("exceptions", "exc", exa.exceptions().stream()
 919                             .map(e -> e.name().stringValue())));
 920                 case InnerClassesAttribute ica ->
 921                     nodes.add(new ListNodeImpl(BLOCK, "inner classes", ica.classes().stream()
 922                             .map(ic -> new MapNodeImpl(FLOW, "cls").with(
 923                                 leaf("inner class", ic.innerClass().name().stringValue()),
 924                                 leaf("outer class", ic.outerClass()
 925                                         .map(cle -> cle.name().stringValue()).orElse("null")),
 926                                 leaf("inner name", ic.innerName().map(Utf8Entry::stringValue).orElse("null")),
 927                                 list("flags", "flag", ic.flags().stream().map(AccessFlag::name))))));
 928                 case MethodParametersAttribute mpa -> {
 929                     var n = new MapNodeImpl(BLOCK, "method parameters");
 930                     for (int i = 0; i < mpa.parameters().size(); i++) {
 931                         var p = mpa.parameters().get(i);
 932                         n.with(new MapNodeImpl(FLOW, i + 1).with(
 933                                 leaf("name", p.name().map(Utf8Entry::stringValue).orElse("null")),
 934                                 list("flags", "flag", p.flags().stream().map(AccessFlag::name))));
 935                     }
 936                 }
 937                 case ModuleAttribute ma ->
 938                     nodes.add(new MapNodeImpl(BLOCK, "module")
 939                             .with(leaf("name", ma.moduleName().name().stringValue()),
 940                                   list("flags","flag", ma.moduleFlags().stream().map(AccessFlag::name)),
 941                                   leaf("version", ma.moduleVersion().map(Utf8Entry::stringValue).orElse("null")),
 942                                   list("uses", "class", ma.uses().stream().map(ce -> ce.name().stringValue())),
 943                                   new ListNodeImpl(BLOCK, "requires", ma.requires().stream().map(req ->
 944                                     new MapNodeImpl(FLOW, "req").with(
 945                                             leaf("name", req.requires().name().stringValue()),
 946                                             list("flags", "flag", req.requiresFlags().stream()
 947                                                     .map(AccessFlag::name)),
 948                                             leaf("version", req.requiresVersion()
 949                                                     .map(Utf8Entry::stringValue).orElse(null))))),
 950                                   new ListNodeImpl(BLOCK, "exports", ma.exports().stream().map(exp ->
 951                                     new MapNodeImpl(FLOW, "exp").with(
 952                                             leaf("package", exp.exportedPackage().asSymbol().name()),
 953                                             list("flags", "flag", exp.exportsFlags().stream()
 954                                                     .map(AccessFlag::name)),
 955                                             list("to", "module", exp.exportsTo().stream()
 956                                                     .map(me -> me.name().stringValue()))))),
 957                                   new ListNodeImpl(BLOCK, "opens", ma.opens().stream().map(opn ->
 958                                     new MapNodeImpl(FLOW, "opn").with(
 959                                             leaf("package", opn.openedPackage().asSymbol().name()),
 960                                             list("flags", "flag", opn.opensFlags().stream()
 961                                                     .map(AccessFlag::name)),
 962                                             list("to", "module", opn.opensTo().stream()
 963                                                     .map(me -> me.name().stringValue()))))),
 964                                   new ListNodeImpl(BLOCK, "provides", ma.provides().stream()
 965                                           .map(prov -> new MapNodeImpl(FLOW, "prov").with(
 966                                                   leaf("class", prov.provides().name().stringValue()),
 967                                                   list("with", "cls", prov.providesWith().stream()
 968                                                           .map(ce -> ce.name().stringValue())))))));
 969                 case ModulePackagesAttribute mopa ->
 970                     nodes.add(list("module packages", "subclass", mopa.packages().stream()
 971                             .map(mp -> mp.asSymbol().name())));
 972                 case ModuleMainClassAttribute mmca ->
 973                     nodes.add(leaf("module main class", mmca.mainClass().name().stringValue()));
 974                 case RecordAttribute ra ->
 975                     nodes.add(new ListNodeImpl(BLOCK, "record components", ra.components().stream()
 976                             .map(rc -> new MapNodeImpl(BLOCK, "record")
 977                                     .with(leafs(
 978                                         "name", rc.name().stringValue(),
 979                                         "type", rc.descriptor().stringValue()))
 980                                     .with(list("attributes", "attribute", rc.attributes().stream()
 981                                             .map(Attribute::attributeName)))
 982                                     .with(attributesToTree(rc.attributes(), verbosity)))));
 983                 case AnnotationDefaultAttribute ada ->
 984                     nodes.add(new MapNodeImpl(FLOW, "annotation default").with(elementValueToTree(ada.defaultValue())));
 985                 case RuntimeInvisibleAnnotationsAttribute aa ->
 986                     nodes.add(annotationsToTree("invisible annotations", aa.annotations()));
 987                 case RuntimeVisibleAnnotationsAttribute aa ->
 988                     nodes.add(annotationsToTree("visible annotations", aa.annotations()));
 989                 case RuntimeInvisibleParameterAnnotationsAttribute aa ->
 990                     nodes.add(parameterAnnotationsToTree("invisible parameter annotations", aa.parameterAnnotations()));
 991                 case RuntimeVisibleParameterAnnotationsAttribute aa ->
 992                     nodes.add(parameterAnnotationsToTree("visible parameter annotations", aa.parameterAnnotations()));
 993                 case RuntimeInvisibleTypeAnnotationsAttribute aa ->
 994                     nodes.add(typeAnnotationsToTree(BLOCK, "invisible type annotations", aa.annotations()));
 995                 case RuntimeVisibleTypeAnnotationsAttribute aa ->
 996                     nodes.add(typeAnnotationsToTree(BLOCK, "visible type annotations", aa.annotations()));
 997                 case SignatureAttribute sa ->
 998                     nodes.add(leaf("signature", sa.signature().stringValue()));
 999                 case SourceFileAttribute sfa ->
1000                     nodes.add(leaf("source file", sfa.sourceFile().stringValue()));
1001                 default -> {}
1002             }
1003         }
1004         return nodes.toArray(Node[]::new);
1005     }
1006 
1007     private static Node annotationsToTree(String name, List<Annotation> annos) {
1008         return new ListNodeImpl(BLOCK, name, annos.stream().map(a ->
1009                 new MapNodeImpl(FLOW, "anno")
1010                         .with(leaf("annotation class", a.className().stringValue()))
1011                         .with(elementValuePairsToTree(a.elements()))));
1012 
1013     }
1014 
1015     private static Node typeAnnotationsToTree(Style style, String name, List<TypeAnnotation> annos) {
1016         return new ListNodeImpl(style, name, annos.stream().map(a ->
1017                 new MapNodeImpl(FLOW, "anno")
1018                         .with(leaf("annotation class", a.className().stringValue()),
1019                               leaf("target info", a.targetInfo().targetType().name()))
1020                         .with(elementValuePairsToTree(a.elements()))));
1021 
1022     }
1023 
1024     private static MapNodeImpl parameterAnnotationsToTree(String name, List<List<Annotation>> paramAnnotations) {
1025         var node = new MapNodeImpl(BLOCK, name);
1026         for (int i = 0; i < paramAnnotations.size(); i++) {
1027             var annos = paramAnnotations.get(i);
1028             if (!annos.isEmpty()) {
1029                 node.with(new ListNodeImpl(FLOW, "parameter " + (i + 1), annos.stream().map(a ->
1030                                 new MapNodeImpl(FLOW, "anno")
1031                                         .with(leaf("annotation class", a.className().stringValue()))
1032                                         .with(elementValuePairsToTree(a.elements())))));
1033             }
1034         }
1035         return node;
1036     }
1037 
1038     private static Node[] localInfoToTree(List<LocalVariableInfo> locals, int slot, int bci) {
1039         if (locals != null) {
1040             for (var l : locals) {
1041                 if (l.slot() == slot && l.startPc() <= bci && l.length() + l.startPc() >= bci) {
1042                     return leafs("type", l.type().stringValue(),
1043                                  "variable name", l.name().stringValue());
1044                 }
1045             }
1046         }
1047         return new Node[0];
1048     }
1049 
1050     private static void forEachOffset(TypeAnnotation ta, CodeAttribute lr, BiConsumer<Integer, TypeAnnotation> consumer) {
1051         switch (ta.targetInfo()) {
1052             case TypeAnnotation.OffsetTarget ot ->
1053                 consumer.accept(lr.labelToBci(ot.target()), ta);
1054             case TypeAnnotation.TypeArgumentTarget tat ->
1055                 consumer.accept(lr.labelToBci(tat.target()), ta);
1056             case TypeAnnotation.LocalVarTarget lvt ->
1057                 lvt.table().forEach(lvti -> consumer.accept(lr.labelToBci(lvti.startLabel()), ta));
1058             default -> {}
1059         }
1060     }
1061 }