componentsjs 5.0.0-beta.0 → 5.0.0-beta.4

package/lib/preprocess/parameterproperty/ParameterPropertyHandlerRange.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ParameterPropertyHandlerRange = void 0;
 const Iris_1 = require("../../rdf/Iris");
 const ErrorResourcesContext_1 = require("../../util/ErrorResourcesContext");
+const GenericsContext_1 = require("../GenericsContext");
 /**
  * If a param range is defined, apply the type and validate the range.
  */
@@ -13,8 +14,8 @@ class ParameterPropertyHandlerRange {
     canHandle(value, configRoot, parameter) {
         return Boolean(parameter.property.range);
     }
-    handle(value, configRoot, parameter, configElement) {
-        this.captureType(value, parameter);
+    handle(value, configRoot, parameter, configElement, genericsContext) {
+        this.captureType(value, parameter, genericsContext);
         return value;
     }
     /**
@@ -24,34 +25,48 @@ class ParameterPropertyHandlerRange {
      * Will be ignored if the value is not a literal or the type is not recognized.
      * @param value The value.
      * @param param The parameter.
+     * @param genericsContext Context for generic types.
      */
-    captureType(value, param) {
-        if (this.hasParamValueValidType(value, param, param.property.range)) {
+    captureType(value, param, genericsContext) {
+        const errorContext = { param };
+        const conflict = this.hasValueType(value, param.property.range, errorContext, genericsContext);
+        if (!conflict) {
             return value;
         }
-        this.throwIncorrectTypeError(value, param);
+        ParameterPropertyHandlerRange.throwIncorrectTypeError(value, param, genericsContext, conflict);
     }
     /**
-     * Apply the given datatype to the given literal.
-     * Checks if the datatype is correct and casts to the correct js type.
-     * Will throw an error if the type has an invalid value.
-     * Will be ignored if the value is not a literal or the type is not recognized.
+     * Check if the given value is of the given type.
+     *
+     * For valid literals, the `valueRaw` field will be set.
+     *
      * @param value The value.
-     * @param param The parameter.
-     * @param paramRange The parameter's range.
+     * @param type The parameter's range.
+     * @param genericsContext Context for generic types.
+     * @param errorContext The context for error reporting.
+     * @return IParamValueConflict A conflict value if there was an error, or undefined if there was no error
      */
-    hasParamValueValidType(value, param, paramRange) {
-        if (!paramRange) {
-            return true;
+    hasValueType(value, type, errorContext, genericsContext) {
+        errorContext = Object.assign(Object.assign({}, errorContext), { value, type });
+        if (!type) {
+            return;
+        }
+        if (type.isA('ParameterRangeWildcard')) {
+            return;
+        }
+        if (!value && type.isA('ParameterRangeUndefined')) {
+            return;
         }
-        if (!value && paramRange.isA('ParameterRangeUndefined')) {
-            return true;
+        // Always match variable values
+        if (value && value.isA('Variable')) {
+            return;
         }
+        // Handle literal values
         if (value && value.type === 'Literal') {
             let parsed;
-            switch (paramRange.value) {
+            switch (type.value) {
                 case Iris_1.IRIS_XSD.string:
-                    return true;
+                    return;
                 case Iris_1.IRIS_XSD.boolean:
                     if (value.value === 'true') {
                         value.term.valueRaw = true;
@@ -60,9 +75,12 @@ class ParameterPropertyHandlerRange {
                         value.term.valueRaw = false;
                     }
                     else {
-                        return false;
+                        return {
+                            description: 'value must either be "true" or "false"',
+                            context: errorContext,
+                        };
                     }
-                    return true;
+                    return;
                 case Iris_1.IRIS_XSD.integer:
                 case Iris_1.IRIS_XSD.number:
                 case Iris_1.IRIS_XSD.int:
@@ -70,138 +88,425 @@ class ParameterPropertyHandlerRange {
                 case Iris_1.IRIS_XSD.long:
                     parsed = Number.parseInt(value.value, 10);
                     if (Number.isNaN(parsed)) {
-                        return false;
+                        return {
+                            description: `value is not a number`,
+                            context: errorContext,
+                        };
                     }
                     // ParseInt also parses floats to ints!
                     if (String(parsed) !== value.value) {
-                        return false;
+                        return {
+                            description: `value can not be a float`,
+                            context: errorContext,
+                        };
                     }
                     value.term.valueRaw = parsed;
-                    return true;
+                    return;
                 case Iris_1.IRIS_XSD.float:
                 case Iris_1.IRIS_XSD.decimal:
                 case Iris_1.IRIS_XSD.double:
                     parsed = Number.parseFloat(value.value);
                     if (Number.isNaN(parsed)) {
-                        return false;
+                        return {
+                            description: `value is not a number`,
+                            context: errorContext,
+                        };
                     }
                     value.term.valueRaw = parsed;
-                    return true;
+                    return;
                 case Iris_1.IRIS_RDF.JSON:
                     try {
                         parsed = JSON.parse(value.value);
                         value.term.valueRaw = parsed;
                     }
-                    catch (_a) {
-                        return false;
+                    catch (error) {
+                        return {
+                            description: `JSON parse exception: ${error.message}`,
+                            context: errorContext,
+                        };
                     }
-                    return true;
+                    return;
             }
         }
         // Allow IRIs to be casted to strings
-        if (value && paramRange && paramRange.value === Iris_1.IRIS_XSD.string && value.type === 'NamedNode') {
-            return true;
+        if (value && type.value === Iris_1.IRIS_XSD.string && value.type === 'NamedNode') {
+            return;
         }
-        if (paramRange && (!value || (!value.isA('Variable') && !value.isA(paramRange.term)))) {
-            if (value && paramRange.isA('ParameterRangeArray')) {
-                if (!value.list) {
-                    return false;
+        // Try to match the value with the parameter's range (which will always be defined at this stage)
+        // Check if the value has a super-type that equals the parameter's range
+        let hasTypeConflict;
+        if (value) {
+            const hasTypeConflictInner = this.hasType(value, type, genericsContext, value.property.genericTypeInstancesComponentScope, value.properties.genericTypeInstances, errorContext);
+            if (!hasTypeConflictInner) {
+                return;
+            }
+            hasTypeConflict = hasTypeConflictInner;
+        }
+        else {
+            hasTypeConflict = undefined;
+        }
+        // Check if the param type is an array
+        if (value && type.isA('ParameterRangeArray')) {
+            if (!value.list) {
+                return {
+                    description: `value is not an RDF list`,
+                    context: errorContext,
+                };
+            }
+            const subConflicts = value.list.map(listElement => this
+                .hasValueType(listElement, type.property.parameterRangeValue, errorContext, genericsContext))
+                .filter(subConflict => subConflict !== undefined);
+            return subConflicts.length === 0 ?
+                undefined :
+                {
+                    description: `one or more array values are invalid`,
+                    context: errorContext,
+                    causes: subConflicts,
+                };
+        }
+        // Check if the param type is a composed type
+        if (type.isA('ParameterRangeUnion')) {
+            const subConflicts = [];
+            for (const parameterRangeElement of type.properties.parameterRangeElements) {
+                const subConflict = this.hasValueType(value, parameterRangeElement, errorContext, genericsContext);
+                if (!subConflict) {
+                    return;
                 }
-                return value.list.every(listElement => this
-                    .hasParamValueValidType(listElement, param, paramRange.property.parameterRangeValue));
+                subConflicts.push(subConflict);
             }
-            // Check if the param type is a composed type
-            if (paramRange.isA('ParameterRangeUnion')) {
-                return paramRange.properties.parameterRangeElements
-                    .some(child => this.hasParamValueValidType(value, param, child));
+            return {
+                description: `no union values are valid`,
+                context: errorContext,
+                causes: subConflicts,
+            };
+        }
+        if (type.isA('ParameterRangeIntersection')) {
+            const subConflicts = type.properties.parameterRangeElements
+                .map(child => this.hasValueType(value, child, errorContext, genericsContext));
+            if (subConflicts.every(subConflict => subConflict === undefined)) {
+                return;
             }
-            if (paramRange.isA('ParameterRangeIntersection')) {
-                return paramRange.properties.parameterRangeElements
-                    .every(child => this.hasParamValueValidType(value, param, child));
+            return {
+                description: `not all intersection values are valid`,
+                context: errorContext,
+                causes: subConflicts.filter(subConflict => subConflict !== undefined),
+            };
+        }
+        if (type.isA('ParameterRangeTuple')) {
+            if (!value) {
+                return {
+                    description: `undefined value is not an RDF list`,
+                    context: errorContext,
+                };
             }
-            if (paramRange.isA('ParameterRangeTuple')) {
-                if (!value || !value.list) {
-                    return false;
-                }
-                // Iterate over list elements and try to match with tuple types
-                const listElements = value.list;
-                const tupleTypes = paramRange.properties.parameterRangeElements;
-                let listIndex = 0;
-                let tupleIndex = 0;
-                while (listIndex < listElements.length && tupleIndex < tupleTypes.length) {
-                    if (tupleTypes[tupleIndex].isA('ParameterRangeRest')) {
-                        // Rest types can match multiple list elements, so only increment index if no match is found.
-                        if (!this.hasParamValueValidType(listElements[listIndex], param, tupleTypes[tupleIndex].property.parameterRangeValue)) {
-                            tupleIndex++;
-                        }
-                        else {
-                            listIndex++;
-                        }
+            if (!value.list) {
+                return {
+                    description: `value is not an RDF list`,
+                    context: errorContext,
+                };
+            }
+            // Iterate over list elements and try to match with tuple types
+            const listElements = value.list;
+            const tupleTypes = type.properties.parameterRangeElements;
+            let listIndex = 0;
+            let tupleIndex = 0;
+            while (listIndex < listElements.length && tupleIndex < tupleTypes.length) {
+                if (tupleTypes[tupleIndex].isA('ParameterRangeRest')) {
+                    // Rest types can match multiple list elements, so only increment index if no match is found.
+                    const subConflict = this.hasValueType(listElements[listIndex], tupleTypes[tupleIndex].property.parameterRangeValue, errorContext, genericsContext);
+                    if (subConflict) {
+                        tupleIndex++;
                     }
                     else {
-                        if (!this.hasParamValueValidType(listElements[listIndex], param, tupleTypes[tupleIndex])) {
-                            return false;
-                        }
-                        tupleIndex++;
                         listIndex++;
                     }
                 }
-                return listIndex === listElements.length &&
-                    (tupleIndex === tupleTypes.length ||
-                        (tupleIndex === tupleTypes.length - 1 && tupleTypes[tupleIndex].isA('ParameterRangeRest')));
+                else {
+                    const subConflict = this.hasValueType(listElements[listIndex], tupleTypes[tupleIndex], errorContext, genericsContext);
+                    if (subConflict) {
+                        return {
+                            description: `tuple element is invalid`,
+                            context: errorContext,
+                            causes: [subConflict],
+                        };
+                    }
+                    tupleIndex++;
+                    listIndex++;
+                }
+            }
+            if (!(listIndex === listElements.length &&
+                (tupleIndex === tupleTypes.length ||
+                    (tupleIndex === tupleTypes.length - 1 && tupleTypes[tupleIndex].isA('ParameterRangeRest'))))) {
+                return {
+                    description: `tuple does not contain the expected number of elements`,
+                    context: errorContext,
+                };
+            }
+            return;
+        }
+        if (type.isA('ParameterRangeLiteral')) {
+            if (value && value.term.equals(type.property.parameterRangeValue.term)) {
+                return;
+            }
+            return {
+                description: `literal value is unequal`,
+                context: errorContext,
+            };
+        }
+        // Check if the range refers to `keyof ...`
+        if (type.isA('ParameterRangeKeyof')) {
+            const component = type.property.parameterRangeValue;
+            // Simulate a union of the member keys as literal parameter ranges
+            const simulatedUnionRange = this.objectLoader.createCompactedResource({
+                '@type': 'ParameterRangeUnion',
+                parameterRangeElements: component.properties.memberFields.map(memberField => ({
+                    '@type': 'ParameterRangeLiteral',
+                    parameterRangeValue: memberField.property.memberFieldName,
+                })),
+            });
+            const subConflict = this.hasValueType(value, simulatedUnionRange, errorContext, genericsContext);
+            if (!subConflict) {
+                return;
+            }
+            return {
+                description: `keyof value is invalid`,
+                context: errorContext,
+                causes: [subConflict],
+            };
+        }
+        // Check if the range refers to an indexed type such as `MyClass[myField]`
+        if (type.isA('ParameterRangeIndexed')) {
+            const object = type.property.parameterRangeIndexedObject;
+            const index = type.property.parameterRangeIndexedIndex;
+            // Collect field ranges
+            const fieldRanges = Object.fromEntries(object.properties.memberFields
+                .map(memberField => [memberField.property.memberFieldName.value, memberField.property.range ||
+                    this.objectLoader.createCompactedResource({ '@type': 'ParameterRangeWildcard' })]));
+            // Handle literal indexes
+            if (index.isA('ParameterRangeLiteral')) {
+                const field = index.property.parameterRangeValue.value;
+                const range = fieldRanges[field];
+                if (!range) {
+                    return {
+                        description: `indexed index does not refer to a known field`,
+                        context: errorContext,
+                    };
+                }
+                const subConflict = this.hasValueType(value, range, errorContext, genericsContext);
+                if (!subConflict) {
+                    return;
+                }
+                return {
+                    description: `indexed value is invalid`,
+                    context: errorContext,
+                    causes: [subConflict],
+                };
             }
-            if (paramRange.isA('ParameterRangeLiteral')) {
-                return Boolean(value && value.term.equals(paramRange.property.parameterRangeValue.term));
+            return {
+                description: `indexed index type can not be understood`,
+                context: errorContext,
+            };
+        }
+        // Check if the range refers to a generic type
+        if (type.isA('ParameterRangeGenericTypeReference')) {
+            return genericsContext.bindGenericTypeToValue(type.property.parameterRangeGenericType.value, value, (subValue, subType) => this.hasValueType(subValue, subType, errorContext, genericsContext), (subType, superType) => this.hasType(subType, superType, genericsContext, undefined, [], errorContext));
+        }
+        // Check if the range refers to a component with a generic type
+        if (type.isA('ParameterRangeGenericComponent')) {
+            if (value) {
+                if (!value.property.genericTypeInstances) {
+                    // For the defined generic type instances, apply them into the instance so they can be checked later during a
+                    // call to GenericsContext#bindComponentGenericTypes.
+                    value.property.genericTypeInstancesComponentScope = type.property.component;
+                    value.properties.genericTypeInstances = type.properties.genericTypeInstances
+                        .map(genericTypeInstance => {
+                        // If we have a generic param type reference, instantiate them based on the current generics context
+                        if (genericTypeInstance.isA('ParameterRangeGenericTypeReference')) {
+                            if (!genericTypeInstance.property.parameterRangeGenericType) {
+                                throw new ErrorResourcesContext_1.ErrorResourcesContext(`Invalid generic type instance in a ParameterRangeGenericComponent was detected: missing parameterRangeGenericType property.`, Object.assign(Object.assign({}, errorContext), { genericTypeInstance }));
+                            }
+                            return this.objectLoader.createCompactedResource({
+                                '@type': 'ParameterRangeGenericTypeReference',
+                                parameterRangeGenericType: genericTypeInstance.property.parameterRangeGenericType.value,
+                                parameterRangeGenericBindings: genericsContext
+                                    .bindings[genericTypeInstance.property.parameterRangeGenericType.value],
+                            });
+                        }
+                        // For all other param types, return the as-is
+                        return genericTypeInstance;
+                    });
+                }
+                else {
+                    // TODO: Once we support manual generics setting, we'll need to check here if we can merge with it.
+                    // (sometimes, it can also be identical)
+                }
             }
-            // Check if this param defines a field with sub-params
-            if (paramRange.isA('ParameterRangeCollectEntries')) {
-                // TODO: Add support for type-checking nested fields with collectEntries
-                return true;
+            const subConflict = this.hasValueType(value, type.property.component, errorContext, genericsContext);
+            if (!subConflict) {
+                return;
             }
-            return false;
+            return {
+                description: `generic component is invalid`,
+                context: errorContext,
+                causes: [subConflict],
+            };
+        }
+        // Check if this param defines a field with sub-params
+        if (type.isA('ParameterRangeCollectEntries')) {
+            // TODO: Add support for type-checking nested fields with collectEntries
+            return;
         }
-        return true;
+        return hasTypeConflict || { description: 'unknown parameter type', context: errorContext };
     }
-    throwIncorrectTypeError(value, parameter) {
+    static throwIncorrectTypeError(value, parameter, genericsContext, conflict) {
         const withTypes = value && value.properties.types.length > 0 ? ` with types "${value.properties.types.map(resource => resource.value)}"` : '';
         // eslint-disable-next-line @typescript-eslint/no-extra-parens
         const valueString = value ? (value.list ? `[${value.list.map(subValue => subValue.value).join(', ')}]` : value.value) : 'undefined';
-        throw new ErrorResourcesContext_1.ErrorResourcesContext(`The value "${valueString}"${withTypes} for parameter "${parameter.value}" is not of required range type "${this.rangeToDisplayString(parameter.property.range)}"`, {
-            value: value || 'undefined',
-            parameter,
-        });
+        throw new ErrorResourcesContext_1.ErrorResourcesContext(`The value "${valueString}"${withTypes} for parameter "${parameter.value}" is not of required range type "${ParameterPropertyHandlerRange.rangeToDisplayString(parameter.property.range, genericsContext)}"`, Object.assign(Object.assign({ cause: conflict, value: value || 'undefined' }, Object.keys(genericsContext.bindings).length > 0 ?
+            { generics: `[\n  ${Object.entries(genericsContext.bindings)
+                    .map(([id, subValue]) => `<${id}> => ${ParameterPropertyHandlerRange.rangeToDisplayString(subValue, genericsContext)}`)
+                    .join(',\n  ')}\n]` } :
+            {}), { parameter }));
     }
-    rangeToDisplayString(paramRange) {
-        if (!paramRange) {
+    /**
+     * Check if the given value is of the given type.
+     * @param value A value.
+     * @param type A type.
+     * @param genericsContext The current generics context.
+     * @param genericTypeInstancesComponentScope
+     * @param genericTypeInstances
+     * @param errorContext
+     */
+    hasType(value, type, genericsContext, genericTypeInstancesComponentScope, genericTypeInstances, errorContext) {
+        var _a;
+        // Immediately return if the terms are equal
+        if (value.term.equals(type.term)) {
+            return;
+        }
+        // Otherwise, iterate over the value's super types are recursively call this method again.
+        const subConflictTypes = [];
+        for (const valueSuperType of [...value.properties.extends, ...value.properties.type]) {
+            // Special case: if the super component is wrapped in a generic component instantiation, unwrap it.
+            if (((_a = valueSuperType.property.type) === null || _a === void 0 ? void 0 : _a.value) === this.objectLoader.contextResolved
+                .expandTerm('oo:GenericComponentExtension')) {
+                // First recursively continue calling hasType for the unwrapped component
+                const hasTypeConflict = this.hasType(valueSuperType.property.component, type, genericsContext, genericTypeInstancesComponentScope, genericTypeInstances, errorContext);
+                if (!hasTypeConflict) {
+                    // If hasType has passed, validate the generic instantiations
+                    // AND (possibly) the parameter's generic type instances against the component's generic params.
+                    const superComponent = valueSuperType.property.component;
+                    const genericsContextInner = new GenericsContext_1.GenericsContext(this.objectLoader, superComponent.properties.genericTypeParameters);
+                    const typeTypeValidator = (subType, superType) => this
+                        .hasType(subType, superType, genericsContextInner, undefined, [], errorContext);
+                    // Try to bind the generic instances from the wrapped generic component instantiation
+                    const subConflictWrapped = genericsContextInner.bindComponentGenericTypes(superComponent, valueSuperType.properties.genericTypeInstances
+                        .map(instance => this.objectLoader.createCompactedResource({
+                        parameterRangeGenericBindings: instance,
+                    })), { value }, typeTypeValidator);
+                    if (subConflictWrapped) {
+                        return {
+                            description: `invalid wrapped bindings for generic type instances for generic component extension of "${superComponent.value}"`,
+                            context: { value, type },
+                            causes: [subConflictWrapped],
+                        };
+                    }
+                    // If the given generic type component scope applies to this component,
+                    // Try to bind the generic instances from the parameter type-checking.
+                    if (genericTypeInstancesComponentScope && genericTypeInstancesComponentScope.value === superComponent.value) {
+                        const subConflictParam = genericsContextInner.bindComponentGenericTypes(superComponent, genericTypeInstances, { value }, typeTypeValidator);
+                        if (subConflictParam) {
+                            return {
+                                description: `invalid parameter bindings for generic type instances for generic component extension of "${superComponent.value}"`,
+                                context: { value, type },
+                                causes: [subConflictParam],
+                            };
+                        }
+                        // Extract the bound generic instances from the inner context into the actual context.
+                        // This is needed for cases where param generics are bound via a wrapped generic component instantiation.
+                        for (const [i, genericTypeInstance] of genericTypeInstances.entries()) {
+                            const innerGenericType = genericTypeInstancesComponentScope.properties.genericTypeParameters[i].value;
+                            if (genericTypeInstance.isA('ParameterRangeGenericTypeReference')) {
+                                // If the generic type instance refers to another generic,
+                                // bind it to the corresponding value of the inner context
+                                const outerGenericType = genericTypeInstance.property.parameterRangeGenericType.value;
+                                genericsContext.bindings[outerGenericType] = genericsContextInner.bindings[innerGenericType];
+                            }
+                            else if (!genericsContextInner.mergeRanges(genericsContextInner.bindings[innerGenericType], genericTypeInstance, typeTypeValidator)) {
+                                // If the generic type instance is just a type, check it against the value in the inner context.
+                                // If it does not match, return an error.
+                                return {
+                                    description: `invalid binding for generic type <${innerGenericType}> in generic component extension of "${superComponent.value}": existing range "${ParameterPropertyHandlerRange.rangeToDisplayString(genericsContextInner.bindings[innerGenericType], genericsContextInner)}" can not be bound to range "${ParameterPropertyHandlerRange.rangeToDisplayString(genericTypeInstance, genericsContextInner)}"`,
+                                    context: { value, type },
+                                };
+                            }
+                        }
+                    }
+                    return;
+                }
+                return {
+                    description: `value is not a subtype of the referenced component in the generic component extension of "${valueSuperType.property.component.value}"`,
+                    context: { value, type },
+                    causes: [hasTypeConflict],
+                };
+            }
+            // The default case just checks the super type recursively.
+            const subConflictType = this.hasType(valueSuperType, type, genericsContext, genericTypeInstancesComponentScope, genericTypeInstances, errorContext);
+            if (!subConflictType) {
+                return;
+            }
+            subConflictTypes.push(subConflictType);
+        }
+        return Object.assign({ description: `value is not a subtype of "${type.value}"`, context: { value, type } }, subConflictTypes.length > 0 ? { causes: subConflictTypes } : {});
+    }
+    static rangeToDisplayString(paramRange, genericsContext) {
+        if (!paramRange || paramRange.isA('ParameterRangeWildcard')) {
             return `any`;
         }
         if (paramRange.isA('ParameterRangeUndefined')) {
             return `undefined`;
         }
         if (paramRange.isA('ParameterRangeArray')) {
-            return `${this.rangeToDisplayString(paramRange.property.parameterRangeValue)}[]`;
+            return `${ParameterPropertyHandlerRange.rangeToDisplayString(paramRange.property.parameterRangeValue, genericsContext)}[]`;
         }
         if (paramRange.isA('ParameterRangeRest')) {
-            return `...${this.rangeToDisplayString(paramRange.property.parameterRangeValue)}`;
+            return `...${ParameterPropertyHandlerRange.rangeToDisplayString(paramRange.property.parameterRangeValue, genericsContext)}`;
+        }
+        if (paramRange.isA('ParameterRangeKeyof')) {
+            return `keyof ${ParameterPropertyHandlerRange.rangeToDisplayString(paramRange.property.parameterRangeValue, genericsContext)}`;
         }
         if (paramRange.isA('ParameterRangeUnion')) {
             return paramRange.properties.parameterRangeElements
-                .map(child => this.rangeToDisplayString(child))
+                .map(child => ParameterPropertyHandlerRange.rangeToDisplayString(child, genericsContext))
                 .join(' | ');
         }
         if (paramRange.isA('ParameterRangeIntersection')) {
             return paramRange.properties.parameterRangeElements
-                .map(child => this.rangeToDisplayString(child))
+                .map(child => ParameterPropertyHandlerRange.rangeToDisplayString(child, genericsContext))
                 .join(' & ');
         }
         if (paramRange.isA('ParameterRangeTuple')) {
             return `[${paramRange.properties.parameterRangeElements
-                .map(child => this.rangeToDisplayString(child))
+                .map(child => ParameterPropertyHandlerRange.rangeToDisplayString(child, genericsContext))
                 .join(', ')}]`;
         }
         if (paramRange.isA('ParameterRangeLiteral')) {
             return paramRange.property.parameterRangeValue.value;
         }
+        if (paramRange.isA('ParameterRangeGenericTypeReference')) {
+            const valid = paramRange.property.parameterRangeGenericType.value in genericsContext.genericTypeIds;
+            return `${valid ? 'GENERIC: ' : 'UNKNOWN GENERIC: '}${paramRange.property.parameterRangeGenericType.value}`;
+        }
+        if (paramRange.isA('ParameterRangeGenericComponent')) {
+            return `(${ParameterPropertyHandlerRange.rangeToDisplayString(paramRange.property.component, genericsContext)})<${paramRange.properties.genericTypeInstances
+                .map(genericTypeInstance => ParameterPropertyHandlerRange.rangeToDisplayString(genericTypeInstance, genericsContext)).join(', ')}>`;
+        }
+        if (paramRange.isA('ParameterRangeIndexed')) {
+            const object = ParameterPropertyHandlerRange
+                .rangeToDisplayString(paramRange.property.parameterRangeIndexedObject, genericsContext);
+            const index = ParameterPropertyHandlerRange
+                .rangeToDisplayString(paramRange.property.parameterRangeIndexedIndex, genericsContext);
+            return `${object}[${index}]`;
+        }
         return paramRange.value;
     }
 }

package/lib/util/ErrorResourcesContext.d.ts

@@ -1,19 +1,16 @@
-import type { Resource } from 'rdf-object';
+import { Resource } from 'rdf-object';
+import type { IParamValueConflict } from '../preprocess/parameterproperty/ParameterPropertyHandlerRange';
 /**
  * An error that can include a context containing resources for display.
  */
 export declare class ErrorResourcesContext extends Error {
-    readonly context: Record<string, Resource | Resource[] | string>;
-    constructor(message: string, context: Record<string, Resource | Resource[] | string>);
-    static contextToString(context: Record<string, Resource | Resource[] | string>): string;
-    /**
-     * Convert the given resource to a compact string.
-     * Mainly used for error reporting.
-     *
-     * Note that this will remove certain fields from the resource,
-     * so only use this when throwing an error that will stop the process.
-     *
-     * @param resource A resource.
-     */
-    static resourceToString(resource: Resource): string;
+    readonly context: IErrorContext;
+    constructor(message: string, context: IErrorContext);
+    exportContext(): any;
+    static contextToJson(context: IErrorContext): any;
+    static resourceToJson(resource: Resource | undefined): any;
+    static conflictToJson(conflict: IParamValueConflict): any;
+}
+export interface IErrorContext {
+    [key: string]: Resource | Resource[] | string | undefined | IErrorContext | IParamValueConflict;
 }