@itwin/ecschema-editing 4.6.0-dev.7 → 4.6.0-dev.8

package/lib/cjs/Differencing/SchemaDiagnosticVisitor.js

@@ -10,9 +10,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SchemaDiagnosticVisitor = void 0;
 const SchemaCompareDiagnostics_1 = require("../Validation/SchemaCompareDiagnostics");
 const ecschema_metadata_1 = require("@itwin/ecschema-metadata");
+const SchemaDifference_1 = require("./SchemaDifference");
 const SchemaConflicts_1 = require("./SchemaConflicts");
 /**
- * Recursive syncronous function to figure whether a given class derived from
+ * Recursive synchronous function to figure whether a given class derived from
  * a class with the given baseClassName.
  */
 function derivedFrom(ecClass, baseClassName) {
@@ -31,23 +32,15 @@ function derivedFrom(ecClass, baseClassName) {
  * @internal
  */
 class SchemaDiagnosticVisitor {
-    constructor(differenceReport) {
-        this._differenceReport = differenceReport;
-    }
-    addEntry(entry) {
-        this._differenceReport.changes.push(entry);
-        return entry;
-    }
-    lookupEntry(changeType, args) {
-        return this._differenceReport.changes && this._differenceReport.changes.find((change) => {
-            return (change.changeType === changeType)
-                && (!args.schemaType || change.schemaType === args.schemaType)
-                && (!args.itemName || change.itemName === args.itemName)
-                && change.path === args.path;
-        });
+    constructor() {
+        this.schemaChanges = [];
+        this.schemaItemChanges = [];
+        this.schemaItemPathChanges = [];
+        this.customAttributeChanges = [];
+        this.conflicts = [];
     }
     addConflict(conflict) {
-        this._differenceReport.conflicts.push(conflict);
+        this.conflicts.push(conflict);
     }
     /**
      * Visitor function to process the schema change diagnostic object.
@@ -105,52 +98,54 @@ class SchemaDiagnosticVisitor {
         return;
     }
     visitChangedSchemaProperties(diagnostic) {
-        let modifyEntry = this.lookupEntry("modify", { schemaType: "Schema" });
+        let modifyEntry = this.schemaChanges.find((entry) => {
+            return entry.changeType === "modify" && entry.schemaType === SchemaDifference_1.SchemaOtherTypes.Schema;
+        });
         let hasChanges = false;
-        const existsAlready = modifyEntry !== undefined;
-        if (!existsAlready) {
+        let addEntry = false;
+        if (modifyEntry === undefined) {
+            addEntry = true;
             modifyEntry = {
                 changeType: "modify",
-                schemaType: "Schema",
-                json: {},
+                schemaType: SchemaDifference_1.SchemaOtherTypes.Schema,
+                difference: {},
             };
         }
         // Only label and description are taken from the source schema. If the schema name or alias
         // differs, those are ignored for now.
         const [propertyName, propertyValue] = diagnostic.messageArgs;
-        switch (propertyName) {
-            case "label":
-                modifyEntry.json.label = propertyValue;
-                hasChanges = true;
-                break;
-            case "description":
-                modifyEntry.json.description = propertyValue;
-                hasChanges = true;
-                break;
+        if (propertyName === "label") {
+            modifyEntry.difference.label = propertyValue;
+            hasChanges = true;
+        }
+        if (propertyName === "description") {
+            modifyEntry.difference.description = propertyValue;
+            hasChanges = true;
         }
-        if (!existsAlready && hasChanges) {
-            this.addEntry(modifyEntry);
+        if (addEntry && hasChanges) {
+            this.schemaChanges.push(modifyEntry);
         }
     }
     visitMissingSchemaItem(diagnostic) {
         const schemaItem = diagnostic.ecDefinition;
-        this.addEntry({
+        this.schemaItemChanges.push({
             changeType: "add",
-            schemaType: getSchemaItemName(schemaItem.schemaItemType),
+            schemaType: schemaItem.schemaItemType,
             itemName: schemaItem.name,
-            json: schemaItem.toJSON(),
+            difference: schemaItem.toJSON(),
         });
     }
     visitChangedSchemaItem(diagnostic) {
         const schemaItem = diagnostic.ecDefinition;
-        if (this.lookupEntry("add", { itemName: schemaItem.name })) {
+        // TODO: Remove after fix #6560 has been merged into master.
+        if (this.schemaItemChanges.find((entry) => entry.changeType === "add" && entry.itemName === schemaItem.name)) {
             return;
         }
         const [propertyName, sourceValue, targetValue] = diagnostic.messageArgs;
         if (propertyName === "schemaItemType") {
             return this.addConflict({
                 code: SchemaConflicts_1.ConflictCode.ConflictingItemName,
-                schemaType: getSchemaItemName(schemaItem.schemaItemType),
+                schemaType: schemaItem.schemaItemType,
                 itemName: schemaItem.name,
                 source: sourceValue,
                 target: targetValue,
@@ -160,27 +155,33 @@ class SchemaDiagnosticVisitor {
         if (sourceValue === undefined) {
             return;
         }
-        let modifyEntry = this.lookupEntry("modify", { itemName: schemaItem.name });
-        if (!modifyEntry) {
-            modifyEntry = this.addEntry({
+        let modifyEntry = this.schemaItemChanges.find((entry) => {
+            return entry.changeType === "modify" && entry.itemName === schemaItem.name;
+        });
+        if (modifyEntry === undefined) {
+            modifyEntry = {
                 changeType: "modify",
-                schemaType: getSchemaItemName(schemaItem.schemaItemType),
+                schemaType: schemaItem.schemaItemType,
                 itemName: schemaItem.name,
-                json: {},
-            });
+                difference: {},
+            };
+            this.schemaItemChanges.push(modifyEntry);
         }
-        modifyEntry.json[propertyName] = sourceValue;
+        // TODO: Since propertyName is type of string, the compiler complains about accepting
+        // an unspecific string as property indexer. Casted to any as short term fix but that
+        // needs to be handled better in future.
+        modifyEntry.difference[propertyName] = sourceValue;
     }
     visitChangedEnumeration(diagnostic) {
         const enumeration = diagnostic.ecDefinition;
-        if (this.lookupEntry("add", { itemName: enumeration.name })) {
+        if (this.schemaItemPathChanges.find((entry) => entry.changeType === "add" && entry.itemName === enumeration.name)) {
             return;
         }
         const [propertyName, sourceValue, targetValue] = diagnostic.messageArgs;
         if (propertyName === "type") {
             return this.addConflict({
                 code: SchemaConflicts_1.ConflictCode.ConflictingEnumerationType,
-                schemaType: getSchemaItemName(ecschema_metadata_1.SchemaItemType.Enumeration),
+                schemaType: ecschema_metadata_1.SchemaItemType.Enumeration,
                 itemName: enumeration.name,
                 source: sourceValue,
                 target: targetValue,
@@ -191,30 +192,32 @@ class SchemaDiagnosticVisitor {
     }
     visitMissingEnumerator(diagnostic) {
         const enumeration = diagnostic.ecDefinition;
-        if (this.lookupEntry("add", { itemName: enumeration.name })) {
+        // TODO: Remove after fix #6560 has been merged into master.
+        if (this.schemaItemPathChanges.find((entry) => entry.changeType === "add" && entry.itemName === enumeration.name)) {
             return;
         }
         const [enumerator] = diagnostic.messageArgs;
-        this.addEntry({
+        this.schemaItemPathChanges.push({
             changeType: "add",
-            schemaType: "Enumeration",
+            schemaType: SchemaDifference_1.SchemaOtherTypes.Enumerator,
             itemName: enumeration.name,
             path: "$enumerators",
-            json: enumerator,
+            difference: enumerator,
         });
     }
     lookupEnumeratorEntry(changeType, item, enumeratorName) {
-        return this._differenceReport.changes && this._differenceReport.changes.find((change) => {
+        return this.schemaItemPathChanges.find((change) => {
             return change.changeType === changeType
-                && change.schemaType === "Enumeration"
+                && change.schemaType === SchemaDifference_1.SchemaOtherTypes.Enumerator
                 && change.itemName === item
                 && change.path === "$enumerators"
-                && change.json.name === enumeratorName;
+                && change.difference.name === enumeratorName;
         });
     }
     visitChangedEnumerator(diagnostic) {
         const enumeration = diagnostic.ecDefinition;
-        if (this.lookupEntry("add", { itemName: enumeration.name })) {
+        // TODO: Remove after fix #6560 has been merged into master.
+        if (this.schemaItemPathChanges.find((entry) => entry.changeType === "add" && entry.itemName === enumeration.name)) {
             return;
         }
         const [enumerator, propertyName, sourceValue, targetValue] = diagnostic.messageArgs;
@@ -224,26 +227,28 @@ class SchemaDiagnosticVisitor {
         if (!this.validateEnumerator(enumeration, enumerator, propertyName, sourceValue, targetValue)) {
             return;
         }
-        const enumeratorPath = `$enumerators.${enumerator.name}`;
-        let modifyEntry = this.lookupEntry("modify", { itemName: enumeration.name, path: enumeratorPath });
-        if (!modifyEntry) {
-            modifyEntry = this.addEntry({
+        let modifyEntry = this.schemaItemPathChanges.find((entry) => {
+            return entry.changeType === "modify" && entry.schemaType === SchemaDifference_1.SchemaOtherTypes.Enumerator && entry.itemName === enumeration.name && entry.path === enumerator.name;
+        });
+        if (modifyEntry === undefined) {
+            modifyEntry = {
                 changeType: "modify",
-                schemaType: "Enumeration",
+                schemaType: SchemaDifference_1.SchemaOtherTypes.Enumerator,
                 itemName: enumeration.name,
-                path: enumeratorPath,
-                json: {},
-            });
+                path: enumerator.name,
+                difference: {},
+            };
+            this.schemaItemPathChanges.push(modifyEntry);
         }
         if (sourceValue !== undefined) {
-            modifyEntry.json[propertyName] = sourceValue;
+            modifyEntry.difference[propertyName] = sourceValue;
         }
     }
     validateEnumerator(enumeration, enumerator, propertyName, sourceValue, targetValue) {
         if (propertyName === "value") {
             this.addConflict({
                 code: SchemaConflicts_1.ConflictCode.ConflictingEnumeratorValue,
-                schemaType: getSchemaItemName(ecschema_metadata_1.SchemaItemType.Enumeration),
+                schemaType: ecschema_metadata_1.SchemaItemType.Enumeration,
                 itemName: enumeration.name,
                 path: enumerator.name,
                 source: sourceValue,
@@ -256,46 +261,54 @@ class SchemaDiagnosticVisitor {
     }
     visitMissingProperty(diagnostic) {
         const property = diagnostic.ecDefinition;
-        if (this.lookupEntry("add", { itemName: property.class.name })) {
+        // TODO: Remove after fix #6560 has been merged into master.
+        if (this.schemaItemChanges.find((entry) => entry.changeType === "add" && entry.schemaType in ecschema_metadata_1.SchemaItemType && entry.itemName === property.class.name)) {
             return;
         }
-        this.addEntry({
+        this.schemaItemPathChanges.push({
             changeType: "add",
-            schemaType: "Property",
+            schemaType: SchemaDifference_1.SchemaOtherTypes.Property,
             itemName: property.class.name,
             path: property.name,
-            json: property.toJSON(),
+            difference: property.toJSON(),
         });
     }
     visitChangedProperty(diagnostic) {
         const property = diagnostic.ecDefinition;
-        if (this.lookupEntry("add", { itemName: property.class.name })
-            || this.lookupEntry("add", { itemName: property.class.name, path: property.name })) {
+        // TODO: Remove after fix #6560 has been merged into master.
+        if (this.schemaItemChanges.find((entry) => entry.changeType === "add" && entry.itemName === property.class.name)) {
+            return;
+        }
+        // TODO: Remove after fix #6560 has been merged into master.
+        if (this.schemaItemPathChanges.find((entry) => entry.changeType === "add" && entry.itemName === property.class.name && entry.path === property.name)) {
             return;
         }
         const [propertyName, sourceValue, targetValue] = diagnostic.messageArgs;
         if (!this.validatePropertyChange(property, propertyName, sourceValue, targetValue)) {
             return;
         }
-        let modifyEntry = this.lookupEntry("modify", { itemName: property.class.name, path: property.name });
-        if (!modifyEntry) {
-            modifyEntry = this.addEntry({
+        let modifyEntry = this.schemaItemPathChanges.find((entry) => {
+            return entry.changeType === "modify" && entry.schemaType === SchemaDifference_1.SchemaOtherTypes.Property && entry.itemName === property.class.name && entry.path === property.name;
+        });
+        if (modifyEntry === undefined) {
+            modifyEntry = {
                 changeType: "modify",
-                schemaType: "Property",
+                schemaType: SchemaDifference_1.SchemaOtherTypes.Property,
                 itemName: property.class.name,
                 path: property.name,
-                json: {},
-            });
+                difference: {},
+            };
+            this.schemaItemPathChanges.push(modifyEntry);
         }
         if (propertyName !== "name" && sourceValue !== undefined) {
-            modifyEntry.json[propertyName] = sourceValue;
+            modifyEntry.difference[propertyName] = sourceValue;
         }
     }
     validatePropertyChange(ecProperty, propertyName, sourceValue, targetValue) {
         if (propertyName === "primitiveType") {
             this.addConflict({
                 code: SchemaConflicts_1.ConflictCode.ConflictingPropertyName,
-                schemaType: getSchemaItemName(ecProperty.class.schemaItemType),
+                schemaType: ecProperty.class.schemaItemType,
                 itemName: ecProperty.class.name,
                 path: ecProperty.name,
                 source: sourceValue,
@@ -308,29 +321,33 @@ class SchemaDiagnosticVisitor {
     }
     visitMissingBaseClass(diagnostic) {
         const ecClass = diagnostic.ecDefinition;
-        if (this.lookupEntry("add", { itemName: ecClass.name })) {
+        // TODO: Remove after fix #6560 has been merged into master.
+        if (this.schemaItemChanges.find((entry) => entry.changeType === "add" && entry.itemName === ecClass.name)) {
             return;
         }
         const [sourceBaseClass, targetBaseClass] = diagnostic.messageArgs;
         if (!this.validateBaseClassChange(ecClass, sourceBaseClass, targetBaseClass)) {
             return;
         }
-        let modifyEntry = this.lookupEntry("modify", { itemName: ecClass.name });
-        if (!modifyEntry) {
-            modifyEntry = this.addEntry({
+        let modifyEntry = this.schemaItemChanges.find((entry) => {
+            return entry.changeType === "modify" && entry.schemaType === ecClass.schemaItemType && entry.itemName === ecClass.name;
+        });
+        if (modifyEntry === undefined) {
+            modifyEntry = {
                 changeType: "modify",
-                schemaType: getSchemaItemName(ecClass.schemaItemType),
+                schemaType: ecClass.schemaItemType,
                 itemName: ecClass.name,
-                json: {},
-            });
+                difference: {},
+            };
+            this.schemaItemChanges.push(modifyEntry);
         }
-        modifyEntry.json.baseClass = sourceBaseClass.fullName;
+        modifyEntry.difference.baseClass = sourceBaseClass.fullName;
     }
     validateBaseClassChange(targetClass, sourceBaseClass, targetBaseClass) {
         if (sourceBaseClass === undefined) {
             this.addConflict({
                 code: SchemaConflicts_1.ConflictCode.RemovingBaseClass,
-                schemaType: getSchemaItemName(targetClass.schemaItemType),
+                schemaType: targetClass.schemaItemType,
                 itemName: targetClass.name,
                 path: "$baseClass",
                 source: undefined,
@@ -342,7 +359,7 @@ class SchemaDiagnosticVisitor {
         if (sourceBaseClass.modifier === ecschema_metadata_1.ECClassModifier.Sealed) {
             this.addConflict({
                 code: SchemaConflicts_1.ConflictCode.SealedBaseClass,
-                schemaType: getSchemaItemName(targetClass.schemaItemType),
+                schemaType: targetClass.schemaItemType,
                 itemName: targetClass.name,
                 path: "$baseClass",
                 source: sourceBaseClass.fullName,
@@ -354,7 +371,7 @@ class SchemaDiagnosticVisitor {
         if (targetBaseClass && !derivedFrom(sourceBaseClass, targetBaseClass.name)) {
             this.addConflict({
                 code: SchemaConflicts_1.ConflictCode.ConflictingBaseClass,
-                schemaType: getSchemaItemName(targetClass.schemaItemType),
+                schemaType: targetClass.schemaItemType,
                 itemName: targetClass.name,
                 path: "$baseClass",
                 source: sourceBaseClass.fullName,
@@ -367,30 +384,33 @@ class SchemaDiagnosticVisitor {
     }
     visitMissingMixinOnClass(diagnostic) {
         const ecClass = diagnostic.ecDefinition;
-        if (this.lookupEntry("add", { itemName: ecClass.name })) {
+        // TODO: Remove after fix #6560 has been merged into master.
+        if (this.schemaItemChanges.find((entry) => entry.changeType === "add" && entry.itemName === ecClass.name)) {
             return;
         }
         const [mixin] = diagnostic.messageArgs;
         if (!this.validateMixin(ecClass, mixin)) {
             return;
         }
-        let modifyEntry = this.lookupEntry("modify", { itemName: ecClass.name, path: "$mixins" });
-        if (!modifyEntry) {
-            modifyEntry = this.addEntry({
-                changeType: "modify",
-                schemaType: "EntityClass",
+        let modifyEntry = this.schemaItemChanges.find((entry) => {
+            return entry.changeType === "add" && entry.schemaType === SchemaDifference_1.SchemaOtherTypes.EntityClassMixin && entry.itemName === ecClass.name;
+        });
+        if (modifyEntry === undefined) {
+            modifyEntry = {
+                changeType: "add",
+                schemaType: SchemaDifference_1.SchemaOtherTypes.EntityClassMixin,
                 itemName: ecClass.name,
-                path: "$mixins",
-                json: [],
-            });
+                difference: [],
+            };
+            this.schemaItemChanges.push(modifyEntry);
         }
-        modifyEntry.json.push(mixin.fullName);
+        modifyEntry.difference.push(mixin.fullName);
     }
     validateMixin(targetClass, mixin) {
         if (mixin.appliesTo && !derivedFrom(targetClass, mixin.appliesTo.name)) {
             this.addConflict({
                 code: SchemaConflicts_1.ConflictCode.MixinAppliedMustDeriveFromConstraint,
-                schemaType: getSchemaItemName(targetClass.schemaItemType),
+                schemaType: targetClass.schemaItemType,
                 itemName: targetClass.name,
                 path: "$mixins",
                 source: mixin.fullName,
@@ -404,98 +424,130 @@ class SchemaDiagnosticVisitor {
     visitMissingRelationshipConstraintClass(diagnostic) {
         const constraint = diagnostic.ecDefinition;
         const className = constraint.relationshipClass.name;
-        const constraintPath = `$${constraint.isSource ? "source" : "target"}.constraintClasses`;
-        if (this.lookupEntry("add", { itemName: className })) {
+        const constraintPath = constraint.isSource ? "$source" : "$target";
+        // TODO: Remove after fix #6560 has been merged into master.
+        if (this.schemaItemChanges.find((entry) => entry.changeType === "add" && entry.itemName === className)) {
             return;
         }
-        let modifyEntry = this.lookupEntry("modify", { itemName: className, path: constraintPath });
+        let modifyEntry = this.schemaItemPathChanges.find((entry) => {
+            return entry.changeType === "add" && entry.schemaType === SchemaDifference_1.SchemaOtherTypes.RelationshipConstraintClass, entry.itemName === className && entry.path === constraintPath;
+        });
         if (!modifyEntry) {
-            modifyEntry = this.addEntry({
-                changeType: "modify",
-                schemaType: "RelationshipClass",
+            modifyEntry = {
+                changeType: "add",
+                schemaType: SchemaDifference_1.SchemaOtherTypes.RelationshipConstraintClass,
                 itemName: className,
                 path: constraintPath,
-                json: [],
-            });
+                difference: [],
+            };
+            this.schemaItemPathChanges.push(modifyEntry);
         }
         const [constraintClass] = diagnostic.messageArgs;
-        modifyEntry.json.push(constraintClass.fullName);
+        modifyEntry.difference.push(constraintClass.fullName);
     }
     visitChangedRelationshipConstraint(diagnostic) {
         const constraint = diagnostic.ecDefinition;
         const className = constraint.relationshipClass.name;
-        const constraintPath = `$${constraint.isSource ? "source" : "target"}`;
-        if (this.lookupEntry("add", { itemName: className })) {
+        const constraintPath = constraint.isSource ? "$source" : "$target";
+        if (this.schemaItemChanges.find((entry) => entry.changeType === "add" && entry.itemName === className)) {
             return;
         }
-        let modifyEntry = this.lookupEntry("modify", { itemName: className, path: constraintPath });
-        if (!modifyEntry) {
-            modifyEntry = this.addEntry({
+        let modifyEntry = this.schemaItemPathChanges.find((entry) => {
+            return entry.changeType === "modify" && entry.schemaType === SchemaDifference_1.SchemaOtherTypes.RelationshipConstraint && entry.itemName === className && entry.path === constraintPath;
+        });
+        if (modifyEntry === undefined) {
+            modifyEntry = {
                 changeType: "modify",
-                schemaType: "RelationshipConstraint",
+                schemaType: SchemaDifference_1.SchemaOtherTypes.RelationshipConstraint,
                 itemName: className,
                 path: constraintPath,
-                json: {},
-            });
+                difference: {},
+            };
+            this.schemaItemPathChanges.push(modifyEntry);
         }
         const [propertyName, propertyValue] = diagnostic.messageArgs;
-        if (propertyValue !== undefined) {
-            modifyEntry.json[propertyName] = propertyValue;
+        if (propertyName === "abstractConstraint" && propertyValue !== undefined) {
+            modifyEntry.difference.abstractConstraint = propertyValue;
+        }
+        if (propertyName === "multiplicity" && propertyValue !== undefined) {
+            modifyEntry.difference.multiplicity = propertyValue;
+        }
+        if (propertyName === "polymorphic" && propertyValue !== undefined) {
+            modifyEntry.difference.polymorphic = propertyValue;
+        }
+        if (propertyName === "roleLabel" && propertyValue !== undefined) {
+            modifyEntry.difference.roleLabel = propertyValue;
         }
     }
     visitSchemaReference(diagnostic, changeType) {
         const [referencedSchema] = diagnostic.messageArgs;
-        this.addEntry({
+        this.schemaChanges.push({
             changeType,
-            schemaType: "Schema",
-            path: "$references",
-            json: {
+            schemaType: SchemaDifference_1.SchemaOtherTypes.SchemaReference,
+            difference: {
                 name: referencedSchema.name,
                 version: referencedSchema.schemaKey.version.toString(),
             },
         });
     }
     visitMissingCustomAttributeInstance(diagnostic) {
-        const { schemaType, itemName, path } = getItemNameAndPath(diagnostic.ecDefinition);
-        if (itemName && (this.lookupEntry("add", { itemName }) || this.lookupEntry("add", { itemName, path }))) {
-            return;
-        }
         const [customAttribute] = diagnostic.messageArgs;
-        this.addEntry({
-            changeType: "add",
-            schemaType,
-            itemName: itemName,
-            path: `${path ? `${path}.` : ""}$customAttributes`,
-            json: customAttribute,
-        });
+        const ecType = diagnostic.ecDefinition;
+        if (ecschema_metadata_1.Schema.isSchema(ecType)) {
+            return this.customAttributeChanges.push({
+                changeType: "add",
+                schemaType: SchemaDifference_1.SchemaOtherTypes.CustomAttributeInstance,
+                appliedTo: "Schema",
+                difference: customAttribute,
+            });
+        }
+        if (ecschema_metadata_1.SchemaItem.isSchemaItem(ecType)) {
+            // TODO: Remove after fix #6560 has been merged into master.
+            if (this.schemaItemChanges.find((entry) => entry.changeType === "add" && entry.itemName === ecType.name)) {
+                return;
+            }
+            return this.customAttributeChanges.push({
+                changeType: "add",
+                schemaType: SchemaDifference_1.SchemaOtherTypes.CustomAttributeInstance,
+                appliedTo: "SchemaItem",
+                itemName: ecType.name,
+                difference: customAttribute,
+            });
+        }
+        if (ecschema_metadata_1.Property.isProperty(ecType)) {
+            // TODO: Remove after fix #6560 has been merged into master.
+            if (this.schemaItemChanges.find((entry) => entry.changeType === "add" && entry.itemName === ecType.name)) {
+                return;
+            }
+            // TODO: Remove after fix #6560 has been merged into master.
+            if (this.schemaItemPathChanges.find((entry) => entry.changeType === "add" && entry.itemName === ecType.name && entry.path === ecType.name)) {
+                return;
+            }
+            return this.customAttributeChanges.push({
+                changeType: "add",
+                schemaType: SchemaDifference_1.SchemaOtherTypes.CustomAttributeInstance,
+                appliedTo: "Property",
+                itemName: ecType.class.name,
+                path: ecType.name,
+                difference: customAttribute,
+            });
+        }
+        if (ecschema_metadata_1.RelationshipConstraint.isRelationshipConstraint(ecType)) {
+            // TODO: Remove after fix #6560 has been merged into master.
+            if (this.schemaItemChanges.find((entry) => entry.changeType === "add" && entry.itemName === ecType.relationshipClass.name)) {
+                return;
+            }
+            return this.customAttributeChanges.push({
+                changeType: "add",
+                schemaType: SchemaDifference_1.SchemaOtherTypes.CustomAttributeInstance,
+                appliedTo: "RelationshipConstraint",
+                itemName: ecType.relationshipClass.name,
+                path: ecType.isSource ? "$source" : "$target",
+                difference: customAttribute,
+            });
+        }
+        return;
     }
 }
 exports.SchemaDiagnosticVisitor = SchemaDiagnosticVisitor;
-function getItemNameAndPath(type) {
-    if (ecschema_metadata_1.Schema.isSchema(type))
-        return {
-            schemaType: "Schema",
-        };
-    if (ecschema_metadata_1.SchemaItem.isSchemaItem(type))
-        return {
-            schemaType: getSchemaItemName(type.schemaItemType),
-            itemName: type.name,
-        };
-    if (type instanceof ecschema_metadata_1.Property)
-        return {
-            schemaType: "Property",
-            itemName: type.class.name,
-            path: type.name,
-        };
-    if (type instanceof ecschema_metadata_1.RelationshipConstraint)
-        return {
-            schemaType: "RelationshipClass",
-            itemName: type.relationshipClass.name,
-            path: type.isSource ? "$source" : "$target",
-        };
-    throw Error("Unhandled Type");
-}
-function getSchemaItemName(schemaItemType) {
-    return (0, ecschema_metadata_1.schemaItemTypeToString)(schemaItemType);
-}
 //# sourceMappingURL=SchemaDiagnosticVisitor.js.map