This file describes the changes in the type representation from JT 3 to JT 4.

1. The representation of types in JTransformer 3.0 was inconsistent:
   1. Class types (C) were represented uniquely, each class declaration by exactly one fact.
   2. Array types (C[]), parametrized types (Set<C>), and the type wildcard (*) where represented redundantly, with one fact per use of that type. E.g two different uses of C[] resulted in two different facts. In addition to the conceptual inconsistency, the redundant representation of array types, parameterized types and wildcards wasted storage.
2. Type facts were referred to indirectly via a typeRefT fact. The related indirection wasted even more storage, complicated writing queries and slowed down their execution.
3. Copmparing types¹⁾ required comparing the structure of several PEFs instead of comparing just a value (an ID).
4. Copying types²⁾ required copying the structure of several PEFs instead of copying just a value (an ID).
5. Creating types³⁾ required creating several facts and linking them properly with their parent (the declaration in which they occurred).

1. Consistent handling of all types (simplifies learning JT and writing queries and transformations).
2. No redundancy (saves memory and speeds up factbase creation).
3. Easy comparison of types by comparing their IDs.
4. Easy copying of type references by copying type IDs.
5. No need to copy the (unique) type PEFs.

In JT 4.0, for each type there is a single fact that represents it. This applies not only to class types, but also to array types, parameterized types and wildcards. For example, there is a single fact that represents the type List<String> and a single one for the type C[].

As a result of change 1, in JT 4, array types, parameterized types an wildcards are now globally unique entities. Correspondingly, the facts that represent them do not have any parent reference anymore. They can be referenced from a number of other elements / facts and therefore it is not possible to define a unique parent:

In JTransformer 4, each use of a type is represented by referencing the respective type fact directly, using its id. There are no more typeRefT indirections.

All PEFs that previously (JT 3) referred to a typeRefT/4 fact now (JT 4) directly refer to the PEF referenced by the typeRefT.

For example, two fields “C f1;” and “int f2;” are represented as follows:

For example, two fields “C[] f1;” and “C[] f2;” are represented as follows:

For example, two fields “C<D> f1;” and “C<E> f2;” are represented as follows:

In JT 4, static references to classes (which were also represented with the typeRefT in JT 3) are represented with staticTypeRefT facts.

Except for the adaptations above, working with types in conditional transformations in JT 4.0 is much simpler than in JT 3.0:

• No more copying of type trees: It is not necessary anymore to copy a type tree when using an existing type for a new element. It is sufficient to simply use the ID of the existing type for the new element.
• Simplified generation of type facts: When using a specific type in a CT, the PEF representation of this type may or may not exist. The predicate ensure_type_exists/1 is used to ensure that the representation of a specific type exists.