@lionweb/utilities 0.7.0-beta.2 → 0.7.0-beta.20

package/src/m3/textualizer.ts

@@ -0,0 +1,95 @@
+import {
+    Annotation,
+    Classifier,
+    Concept,
+    Containment,
+    Enumeration,
+    EnumerationLiteral,
+    INamed,
+    Interface,
+    Language,
+    Link,
+    M3Node,
+    nameOf,
+    nameSorted,
+    PrimitiveType,
+    Property,
+    SingleRef,
+    unresolved
+} from "@lionweb/core"
+import { asString, indentWith, Template } from "littoral-templates"
+
+const indented = indentWith("    ")(1)
+
+const refAsText = <T extends INamed>(ref: SingleRef<T>): string => (ref === unresolved ? `???` : ref.name)
+
+const recurse = <T extends M3Node>(ts: T[], header: string, func: (t: T) => Template = asText): Template =>
+    ts.length === 0 ? [] : indented([header, indented(ts.map(func))])
+
+const featuresOf = (classifier: Classifier): Template => recurse(nameSorted(classifier.features), `features (↓name):`)
+
+const asText = (node: M3Node): Template => {
+    if (node instanceof Annotation) {
+        return [
+            `annotation ${node.name}${node.extends === undefined ? `` : ` extends ${refAsText(node.extends)}`}${node.implements.length === 0 ? `` : ` implements ${nameSorted(node.implements).map(nameOf).join(", ")}`}`,
+            indented([`annotates: ${refAsText(node.annotates)}`]),
+            featuresOf(node)
+        ]
+    }
+
+    if (node instanceof Concept) {
+        return [
+            `${node.partition ? `<<partition>> ` : ``}${node.abstract ? `abstract ` : ``}concept ${node.name}${node.extends === undefined ? `` : ` extends ${refAsText(node.extends)}`}${node.implements.length === 0 ? `` : ` implements ${nameSorted(node.implements).map(nameOf).join(", ")}`}`,
+            featuresOf(node)
+        ]
+    }
+
+    if (node instanceof Interface) {
+        return [
+            `interface ${node.name}${node.extends.length === 0 ? `` : ` extends ${nameSorted(node.extends).map(nameOf).join(", ")}`}`,
+            featuresOf(node)
+        ]
+    }
+
+    if (node instanceof Link) {
+        return `${node.name}${node instanceof Containment ? `:` : ` ->`} ${refAsText(node.type)}${node.multiple ? `[${node.optional ? `0` : `1`}..*]` : ``}${node.optional && !node.multiple ? `?` : ``}`
+    }
+
+    if (node instanceof Enumeration) {
+        return [`enumeration ${node.name}`, recurse(node.literals, `literals:`)]
+    }
+
+    if (node instanceof EnumerationLiteral) {
+        return `${node.name}`
+    }
+
+    if (node instanceof Language) {
+        return [
+            `language ${node.name}`,
+            indented([
+                `version: ${node.version}`,
+                node.dependsOn.length === 0
+                    ? []
+                    : [`dependsOn:`, indented(node.dependsOn.map(language => `${language.name} (${language.version})`))],
+                `entities (↓name):`,
+                ``,
+                indented(nameSorted(node.entities).map(entity => [asText(entity), ``]))
+            ]),
+            ``
+        ]
+    }
+
+    if (node instanceof PrimitiveType) {
+        return `primitive type ${node.name}`
+    }
+
+    if (node instanceof Property) {
+        return `${node.name}: ${refAsText(node.type)}${node.optional ? `?` : ``}`
+    }
+
+    return `node (key=${node.key}, ID=${node.id}) of class ${node.constructor.name} not handled`
+}
+
+export const languageAsText = (language: Language) => asString(asText(language))
+
+export const languagesAsText = (languages: Language[]): string => asString(nameSorted(languages).map(language => [asText(language), ``]))

package/src/m3/ts-generation/common.ts

@@ -0,0 +1,48 @@
+import {
+    Annotation,
+    builtinClassifiers,
+    builtinPrimitives,
+    Concept,
+    Datatype,
+    Enumeration,
+    Interface,
+    LanguageEntity,
+    PrimitiveType,
+    SingleRef
+} from "@lionweb/core"
+
+
+export const tsTypeFor = (datatype: SingleRef<Datatype>): string => {
+    if (datatype instanceof PrimitiveType) {
+        switch (datatype) {
+            case builtinPrimitives.booleanDatatype: return `boolean`
+            case builtinPrimitives.stringDatatype: return `string`
+            case builtinPrimitives.integerDatatype: return `number`
+            case builtinPrimitives.jsonDatatype: return `unknown`
+            default:
+                return `string`
+        }
+    }
+    if (datatype instanceof Enumeration) {
+        return datatype.name
+    }
+    return `unknown /* [ERROR] can't compute a TS type for this datatype: ${datatype} */`
+}
+
+export const isINamed = (entity: LanguageEntity): boolean =>
+    entity === builtinClassifiers.inamed
+
+
+export const usesINamedDirectly = (entity: LanguageEntity): boolean => {
+    if (entity instanceof Annotation) {
+        return entity.implements.some(isINamed)
+    }
+    if (entity instanceof Concept) {
+        return entity.implements.some(isINamed)
+    }
+    if (entity instanceof Interface) {
+        return entity.extends.some(isINamed)
+    }
+    return false
+}
+

package/src/m3/ts-generation/ts-types-generator.ts

@@ -0,0 +1,226 @@
+import {
+    allFeaturesOf,
+    Annotation,
+    Classifier,
+    Concept,
+    conceptsOf,
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+    DynamicNode,
+    Enumeration,
+    Feature,
+    inheritsDirectlyFrom,
+    Interface,
+    isConcrete,
+    Language,
+    LanguageEntity,
+    Link,
+    lioncoreBuiltins,
+    nameOf,
+    nameSorted,
+    PrimitiveType,
+    Property,
+    unresolved
+} from "@lionweb/core"
+import { indent } from "@lionweb/textgen-utils"
+import { groupBy, mapValues, uniquesAmong } from "@lionweb/ts-utils"
+import { asString, Template, when } from "littoral-templates"
+import { Field, tsFromTypeDef, TypeDefModifier } from "./type-def.js"
+import { tsTypeFor, usesINamedDirectly } from "./common.js"
+
+
+const fieldForFeature = (feature: Feature) => {
+    if (feature instanceof Link) {
+        return fieldForLink(feature)
+    }
+    if (feature instanceof Property) {
+        return fieldForProperty(feature)
+    }
+    return {
+        name: feature.name,
+        optional: false,
+        type: `unknown`
+    }
+}
+
+
+const fieldForLink = ({name, type, optional, multiple}: Link): Field =>
+    ({
+        name,
+        optional: optional && !multiple,
+        type: `${type === unresolved ? `unknown` : type.name}${multiple ? `[]` : ``}`
+    })
+
+
+const fieldForProperty = ({name, type, optional}: Property): Field =>
+    ({
+        name,
+        optional,
+        type: tsTypeFor(type)
+    })
+
+
+const typeForEnumeration = (enumeration: Enumeration): Template =>
+    [
+        `enum ${enumeration.name} {`,
+        indent(enumeration.literals.map(nameOf).join(`, `)),
+        `}`,
+        ``
+    ]
+
+
+const typeForPrimitiveType = (datatype: PrimitiveType): Template =>
+    [
+        `export type ${datatype.name} = ${tsTypeFor(datatype)};`,
+        ``
+    ]
+
+
+export enum GenerationOptions {
+    assumeSealed
+}
+
+
+/**
+ * @return string generated TypeScript source code that contains type definitions that match the given {@link Language language}
+ *  in combination with using the {@link DynamicNode} base type and corresponding facades.
+ */
+export const tsTypeDefsForLanguage = (language: Language, ...generationOptions: GenerationOptions[]) => {
+
+    const fieldsForClassifier = (classifier: Classifier) => {
+        const map = mapValues<Feature[], [Feature, Field][]>(
+            groupBy(allFeaturesOf(classifier), nameOf),
+            (features) => features.map((feature) => ([feature, fieldForFeature(feature)]))
+        )
+        // ensure that features with duplicate names get a postfix indicating the classifier they originate from:
+        Object.values(map)
+            .filter((fieldsWithOrigin) => fieldsWithOrigin.length > 1)
+            .forEach((fieldsWithOrigin) => {
+                fieldsWithOrigin.forEach(([feature, field]) => {
+                    field.name = `${field.name}_${feature.parent!.name}`
+                })
+            })
+        return Object.values(map)
+            .flatMap((fieldsWithOrigin) =>
+                fieldsWithOrigin.map(([_, field]) => field)
+            )
+    }
+
+    const typeForAnnotation = (annotation: Annotation) => {
+        const superTypes = inheritsDirectlyFrom(annotation)
+
+        return tsFromTypeDef({
+            modifier: TypeDefModifier.none,
+            name: annotation.name,
+            mixinNames: superTypes.length === 0 ? [`DynamicNode`] : superTypes.map(nameOf),
+            fields: fieldsForClassifier(annotation)
+        })
+    }
+
+    const typeForConcept = (concept: Concept) => {
+        const superTypes = inheritsDirectlyFrom(concept)
+        const subClassifiers =
+            concept.abstract
+                ? (
+                    generationOptions.indexOf(GenerationOptions.assumeSealed) > -1
+                        ? conceptsOf(language).filter((entity) => entity.extends === concept)
+                        : []
+                )
+                : [concept]
+
+        return tsFromTypeDef({
+            modifier: concept.abstract ? TypeDefModifier.abstract : TypeDefModifier.none,
+            name: concept.name,
+            mixinNames: superTypes.length === 0 ? [`DynamicNode`] : superTypes.map(nameOf),
+            bodyComment: subClassifiers.length > 0 ? `classifier -> ${subClassifiers.map(nameOf).join(` | `)}` : undefined,
+            fields: fieldsForClassifier(concept)
+        })
+    }
+
+    const typeForInterface = (intface: Interface) =>
+        tsFromTypeDef({
+            modifier: TypeDefModifier.interface,
+            name: intface.name,
+            mixinNames: intface.extends.length === 0 ? [`DynamicNode`] : intface.extends.map(nameOf),
+            fields: fieldsForClassifier(intface)
+        })
+
+    const typeForLanguageEntity = (entity: LanguageEntity) => {
+        if (entity instanceof Annotation) {
+            return typeForAnnotation(entity)
+        }
+        if (entity instanceof Concept) {
+            return typeForConcept(entity)
+        }
+        if (entity instanceof Enumeration) {
+            return typeForEnumeration(entity)
+        }
+        if (entity instanceof Interface) {
+            return typeForInterface(entity)
+        }
+        if (entity instanceof PrimitiveType) {
+            return typeForPrimitiveType(entity)
+        }
+        return [
+            `// unhandled language entity <${entity.constructor.name}>"${entity.name}"`,
+            ``
+        ]
+    }
+
+    const dependenciesOfClassifier = (classifier: Classifier): Classifier[] =>
+        [
+            ...inheritsDirectlyFrom(classifier),
+            ...allFeaturesOf(classifier)
+                .filter((feature) => feature instanceof Link)
+                .map((feature) => feature as Link)
+                .flatMap(({type}) => type)
+                .filter((type) => type instanceof Classifier)
+                .map((classifier) => classifier as Classifier)
+        ]
+
+    const coreImports = [
+        ...(language.entities.every(usesINamedDirectly) ? [] : [`DynamicNode`]),
+        ...(language.entities.some(usesINamedDirectly) ? [`INamed`] : [])
+    ]
+
+    const generatedDependencies = uniquesAmong(
+        language.entities
+            .filter((entity) => entity instanceof Classifier)
+            .flatMap((entity) => dependenciesOfClassifier(entity as Classifier))
+    )
+        .filter((classifier) => classifier.language !== language && classifier.language !== lioncoreBuiltins)
+    const importsPerPackage = groupBy(
+        generatedDependencies,
+        ({language}) => language.name
+    )
+
+    const concreteClassifiers = language.entities.filter(isConcrete)
+
+    return asString(
+        [
+            `// Warning: this file is generated!`,
+            `// Modifying it by hand is useless at best, and sabotage at worst.`,
+            ``,
+            `/*
+ * language's metadata:
+ *     name:    ${language.name}
+ *     version: ${language.version}
+ */`,
+            ``,
+            when(coreImports.length > 0)(`import {${coreImports.join(`, `)}} from "@lionweb/core";`),
+            Object.keys(importsPerPackage)
+                .sort()
+                .map((packageName) => `import {${nameSorted(importsPerPackage[packageName]).map(nameOf).join(", ")}} from "./${packageName}.g.js";`),
+            ``,
+            ``,
+            nameSorted(language.entities).map(typeForLanguageEntity),
+            when(concreteClassifiers.length > 0)([
+                ``,
+                `/** sum type of all types for all concrete classifiers of ${language.name}: */`,
+                `export type Nodes = ${nameSorted(concreteClassifiers).map(nameOf).join(` | `)};`,
+                ``
+            ])
+        ]
+    )
+
+}
+

package/src/m3/ts-generation/type-def.ts

@@ -0,0 +1,40 @@
+import { Template, when } from "littoral-templates"
+import { indent } from "@lionweb/textgen-utils"
+
+export enum TypeDefModifier {
+    none,
+    abstract,
+    interface
+}
+
+export type TypeDef = {
+    modifier: TypeDefModifier
+    name: string
+    mixinNames: string[]
+    bodyComment?: string
+    fields: Field[]
+}
+
+export type Field = {
+    name: string
+    optional: boolean
+    type: string
+}
+
+const tsFromField = ({ name, optional, type }: Field): Template => `${name}${optional ? `?` : ``}: ${type};`
+
+export const tsFromTypeDef = ({ modifier, name, mixinNames, bodyComment, fields }: TypeDef): Template => {
+    const hasBody = !!bodyComment || fields.length > 0
+    return [
+        `${modifier === TypeDefModifier.none ? `` : `/** ${TypeDefModifier[modifier]} */ `}export type ${name} = ${mixinNames.join(` & `)}${!hasBody ? `;` : ` & {`}`,
+        when(hasBody)([
+            indent([
+                when(!!bodyComment)(`// ${bodyComment}`),
+                when(fields.length > 0)([`settings: {`, indent(fields.map(tsFromField)), `};`])
+            ]),
+            `};` // (`{` was already rendered as part of the header)
+        ]),
+        ``
+    ]
+}
+

package/src/serialization/annotation-remover.ts

@@ -0,0 +1,46 @@
+import {
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+    Annotation
+} from "@lionweb/core"
+import { LionWebId, LionWebJsonChunk, LionWebJsonNode } from "@lionweb/json"
+import { byIdMap } from "@lionweb/ts-utils"
+
+/**
+ * Removes all annotations from the given {@link LionWebJsonChunk}, i.e.:
+ *  * all annotations on nodes in the form of the {@code annotations} property,
+ *  * all nodes that can be identified as instances of an {@link Annotation} by being referred to from {@code annotations}.
+ * It also removes all descendants of all annotations (insofar present in the given chunk).
+ * @param serializationChunk - The {@link LionWebJsonChunk}
+ */
+export const withoutAnnotations = (serializationChunk: LionWebJsonChunk) => {
+    const {serializationFormatVersion, languages, nodes} = serializationChunk
+    const id2node = byIdMap(nodes)
+    const childIds = (id: LionWebId) =>
+        (id in id2node)
+            ? id2node[id].containments.flatMap((containment) => containment.children)
+            : []
+    const descendantIds = (id: LionWebId): LionWebId[] =>
+        [id, ...childIds(id).flatMap(descendantIds)]
+    const annotationIds = nodes.flatMap((node) => node.annotations) // (are unique, because of parent-child relation)
+    const idsOfNodesToDelete = [
+        ...annotationIds,
+        ...[...annotationIds].flatMap(descendantIds)
+    ]
+    const withoutAnnotations = ({ id, classifier, properties, containments, references, parent }: LionWebJsonNode): LionWebJsonNode => ({
+        id,
+        classifier,
+        properties,
+        containments,
+        references,
+        annotations: [],
+        parent
+    })
+    return {
+        serializationFormatVersion,
+        languages,
+        nodes: nodes
+            .filter((node) => !idsOfNodesToDelete.includes(node.id)) // removes instances of annotations
+            .map(withoutAnnotations)
+    }
+}
+

package/src/serialization/chunk.ts

@@ -0,0 +1,105 @@
+import { deserializeLanguages, Language, lioncoreKey } from "@lionweb/core"
+import { currentSerializationFormatVersion, LionWebJsonChunk, LionWebJsonUsedLanguage } from "@lionweb/json"
+import { readFileAsJson } from "../utils/json.js"
+
+
+/**
+ * Reads the file at the given path as a {@link LionWebJsonChunk serialization chunk}.
+ * **Note** that it's only checked that the file exists and can be parsed as JSON,
+ * _not_ whether it satisfies the specified serialization chunk format!
+ */
+export const readSerializationChunk = async (path: string) => {
+    try {
+        return readFileAsJson(path) as LionWebJsonChunk
+    } catch (e) {
+        console.error(`${path} is not a valid JSON file`)
+        throw e
+    }
+}
+// TODO  don't throw, but return some kind of error object (– possibly using Promise.reject)
+
+
+const isRecord = (json: unknown): json is Record<string, unknown> =>
+    typeof json === "object" && !Array.isArray(json)
+
+/**
+ * @return whether the given JSON looks like the serialization of languages.
+ */
+export const looksLikeSerializedLanguages = (json: unknown): boolean =>
+    isRecord(json)
+    && json["serializationFormatVersion"] === currentSerializationFormatVersion
+    && "languages" in json
+    && Array.isArray(json["languages"])
+    && json["languages"].some((language) => isRecord(language) && language["key"] === lioncoreKey)
+
+
+/**
+ * Tries to read the given path as a JSON file containing the serialization of languages,
+ * and attempts to deserialize the serialization chunk when it is.
+ * If any of that fails, return an empty list.
+ */
+export const tryReadAsLanguages = async (path: string): Promise<Language[]> => {
+    const serializationChunk = await readSerializationChunk(path)
+    if (!looksLikeSerializedLanguages(serializationChunk)) {
+        console.error(`${path} is not a valid JSON serialization chunk of LionCore languages`)
+        return []
+    }
+    try {
+        return deserializeLanguages(serializationChunk)
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } catch (e: any) {
+        console.error(`${path} is not a valid JSON serialization chunk of LionCore languages: ${e.message}`)
+        return []
+    }
+}
+
+
+const flatMapDistinct = <T>(tss: (T[])[], equalFunc: (l: T, r: T) => boolean) =>
+    tss.reduce<T[]>(
+        (acc, ts) =>
+            [
+                ...acc,
+                ...(ts.filter((r) => !acc.some((l) => equalFunc(l, r))))
+            ],
+        []
+    )
+
+const areEqual = (left: LionWebJsonUsedLanguage, right: LionWebJsonUsedLanguage): boolean =>
+    left.key === right.key && left.version === right.version
+
+
+/**
+ * @return the combination of the given {@link LionWebJsonChunk serialization chunks} into one.
+ */
+export const combinationOf = (serializationChunks: LionWebJsonChunk[]): LionWebJsonChunk =>
+    ({
+        serializationFormatVersion: currentSerializationFormatVersion,
+        languages: flatMapDistinct(serializationChunks.map(({languages}) => languages), areEqual),
+        nodes: serializationChunks.flatMap(({nodes}) => nodes)
+    })
+
+
+/**
+ * Tries to read all the given paths as JSON serialization chunks that are serializations of languages,
+ * and attempts to combine those chunks into one chunk, and deserializes that.
+ */
+export const tryReadAllAsLanguages = async (paths: string[]): Promise<Language[]> => {
+    const serializationChunks =
+        (await Promise.all(paths.map(readSerializationChunk)))
+        .filter((serializationChunk, index) => {
+            const ok = looksLikeSerializedLanguages(serializationChunk)
+            if (!ok) {
+                const path = paths[index]
+                console.error(`${path} is not a valid JSON serialization chunk of LionCore languages`)
+            }
+            return ok
+        })
+    try {
+        return deserializeLanguages(combinationOf(serializationChunks))
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } catch (e: any) {
+        console.error(`couldn't deserialize combined JSON serialization chunk of LionCore languages: ${e.message}`)
+        return []
+    }
+}
+

package/src/serialization/index.ts

@@ -0,0 +1,6 @@
+export {withoutAnnotations} from "./annotation-remover.js"
+export {looksLikeSerializedLanguages, readSerializationChunk, tryReadAllAsLanguages, tryReadAsLanguages} from "./chunk.js"
+export {measure} from "./measurer.js"
+export {orderedSerializationChunk} from "./ordering.js"
+export {sortedSerializationChunk} from "./sorting.js"
+export {genericAsTreeText} from "./textualizer.js"

package/src/serialization/measurer.ts

@@ -0,0 +1,115 @@
+import { Annotation, Concept, instantiableClassifiersOf, Interface, Language, LanguageEntity, MemoisingSymbolTable } from "@lionweb/core"
+import { LionWebJsonChunk, LionWebJsonMetaPointer, LionWebJsonNode, LionWebJsonUsedLanguage } from "@lionweb/json"
+import { nested3Grouper, nested3Mapper, nestedFlatMap2, nestedFlatMap3 } from "@lionweb/ts-utils"
+import { ClassifierMetaTypes, Metrics } from "./metric-types.js"
+
+
+type Info = {
+    classifier: LionWebJsonMetaPointer
+    instantiations: number
+}
+
+
+/**
+ * Sum the given array of numbers.
+ */
+export const sumNumbers = (nums: number[]): number =>
+    nums.reduce((acc, cur) => acc + cur, 0)
+
+
+/**
+ * Computes {@link Metrics metrics} on the given {@link LionWebJsonChunk serialization chunk}.
+ * Passing it {@link Language languages} make this language-aware:
+ *  * language and classifier names are looked up,
+ *  * unused instantiable classifiers and languages without instantiations are computed as well.
+ */
+export const measure = (serializationChunk: LionWebJsonChunk, languages: Language[]): Metrics => {
+    const symbolTable = new MemoisingSymbolTable(languages)
+
+    // group nodes by language key, version, and classifier key, mapped to the classifier meta-pointer and #instantiations:
+    const languageKey2version2classifierKey2info = nested3Mapper<LionWebJsonNode[], Info>(nodes => ({
+        classifier: nodes[0].classifier,
+        instantiations: nodes.length
+    }))(
+        nested3Grouper<LionWebJsonNode>(
+            ({ classifier }) => classifier.language,
+            ({ classifier }) => classifier.version,
+            ({ classifier }) => classifier.key
+        )(serializationChunk.nodes)
+    )
+
+    const languagesWithInstantiations = nestedFlatMap2(
+        languageKey2version2classifierKey2info,
+        (classifierKey2info, languageKey, version) => ({
+            key: languageKey,
+            version,
+            name: symbolTable.languageMatching(languageKey, version)?.name,
+            instantiations: sumNumbers(Object.values(classifierKey2info).map(info => info.instantiations))
+        })
+    )
+
+    const metaTypeOf = (entity?: LanguageEntity): ClassifierMetaTypes | undefined => {
+        if (entity instanceof Annotation) {
+            return "annotation"
+        }
+        if (entity instanceof Concept) {
+            return "concept"
+        }
+        if (entity instanceof Interface) {
+            return "interface"
+        }
+        return undefined
+    }
+
+    // map grouped nodes to info including #instantiations:
+    const instantiatedClassifiers = nestedFlatMap3(languageKey2version2classifierKey2info, (info, languageKey, version, classifierKey) => {
+        const classifier = symbolTable.entityMatching(info.classifier)
+        return {
+            language: {
+                key: languageKey,
+                version,
+                name: symbolTable.languageMatching(languageKey, version)?.name
+            },
+            key: classifierKey,
+            name: classifier?.name,
+            metaType: metaTypeOf(classifier),
+            instantiations: info.instantiations
+        }
+    })
+
+    const doesLanguageHaveInstantiations = (language: LionWebJsonUsedLanguage): boolean =>
+        language.key in languageKey2version2classifierKey2info && language.version in languageKey2version2classifierKey2info[language.key]
+
+    const languagesWithoutInstantiations = serializationChunk.languages
+        .filter(language => !doesLanguageHaveInstantiations(language))
+        .map(language => ({
+            ...language,
+            name: symbolTable.languageMatching(language.key, language.version)?.name
+        }))
+
+    const isClassifierUsed = (metaPointer: LionWebJsonMetaPointer): boolean =>
+        metaPointer.language in languageKey2version2classifierKey2info &&
+        metaPointer.version in languageKey2version2classifierKey2info[metaPointer.language] &&
+        metaPointer.key in languageKey2version2classifierKey2info[metaPointer.language][metaPointer.version]
+
+    const uninstantiatedInstantiableClassifiers = languages
+        .flatMap(instantiableClassifiersOf)
+        .map(classifier => classifier.metaPointer())
+        .filter(metaPointer => !isClassifierUsed(metaPointer))
+        .map(metaPointer => ({
+            language: {
+                key: metaPointer.language,
+                version: metaPointer.version,
+                name: symbolTable.languageMatching(metaPointer.language, metaPointer.version)?.name
+            },
+            key: metaPointer.key,
+            name: symbolTable.entityMatching(metaPointer)?.name
+        }))
+
+    return {
+        languagesWithInstantiations,
+        instantiatedClassifiers,
+        languagesWithoutInstantiations,
+        uninstantiatedInstantiableClassifiers
+    }
+}