eclipse-aascw / aas-core-codegen / 35396929406

90%

push

github

Compose the TypeScript JSON serialization (#732)

A list-typed property framed its own loop and handed
a ``this``-capturing closure to a shared helper:

    if (that.supplementalSemanticIds !== null) {
      jsonable["supplementalSemanticIds"] = serializeArray(
        that.supplementalSemanticIds,
        (item) => this.transform(item)
      );
    }

while a nested instance went through the three-frame ``this.transform``
even where its declared type already answered which serializer to call:

    if (that.semanticId !== null) {
      jsonable["semanticId"] =
        this.transform(that.semanticId);
    }

Every property is now one statement, and the value is serialized by the
one function of its type:

    if (that.supplementalSemanticIds !== null) {
      jsonable["supplementalSemanticIds"] =
        serialize_ListOf_Reference(that.supplementalSemanticIds);
    }

    if (that.semanticId !== null) {
      jsonable["semanticId"] =
        serializeReference(that.semanticId);
    }

Each concrete class gets a module-level ``serialize{Cls}``, and the
transformer is reduced to one-line overrides forwarding to them, which is
what lets everything else name a serializer directly. ``serializeClass``
is the only dispatch left in the region -- ``that.transform(SERIALIZER)``
-- and it serves an abstract class, a concrete class with descendants and
a named union alike, since the run-time type answers on the writing side
what the reading side has to decide before it has read anything.

``serializeArray`` is gone, and with it the last higher-order call and
every closure: the region now allocates none. A list is composed per
declared item type instead, which is where the writing side parts from
the reading side.

Measured on a synthetic mirror of the generated code -- 38 classes, 1,555
instances per serialization, node 24, each variant in its own process,
median of 15 x 1000 runs:

    today (this.transform + a closure per list)        0.52 - 0.59 ms
    module-l... (continued)

236 of 254 new or added lines in 5 files covered. (92.91%)

35118 of 40873 relevant lines covered (85.92%)

2.58 hits per line