node-opcua-address-space 2.115.0 → 2.117.0

package/src/nodeset_tools/construct_namespace_dependency.ts

@@ -1,4 +1,4 @@
-import { INamespace, UADataType, UAVariable, UAVariableType } from "node-opcua-address-space-base";
+import { IAddressSpace, INamespace, UADataType, UAVariable, UAVariableType } from "node-opcua-address-space-base";
 import { NodeClass } from "node-opcua-data-model";
 import { StructureField } from "node-opcua-types";
 import { DataType } from "node-opcua-basic-types";
@@ -9,42 +9,46 @@ import { make_debugLog, make_warningLog } from "node-opcua-debug";
 import { NamespacePrivate } from "../namespace_private";
 import { BaseNodeImpl, getReferenceType } from "../base_node_impl";
 import { UAVariableImpl } from "../ua_variable_impl";
+import { ITranslationTable } from "../../source/xml_writer";
 
 const warningLog = make_warningLog(__filename);
 const debugLog = make_debugLog(__filename);
 
-function _constructNamespaceDependency(
+// eslint-disable-next-line max-statements, complexity
+export function _recomputeRequiredModelsFromTypes(
     namespace: INamespace,
-    dependency: INamespace[],
-    depMap: Set<number>,
-    _visitedDataType: Set<string>,
-    priorityTable: number[]
-): void {
-    const addressSpace = namespace.addressSpace;
-    const namespace_ = namespace as NamespacePrivate;
-    // navigate all namespace recursively to
-
-    function consider(namespaceIndex: number) {
-        if (hasHigherPriorityThan(namespaceIndex, namespace.index, priorityTable)) {
-            return;
-        }
-        considerStrongly(namespaceIndex);
+    cache?: Map<number, { requiredNamespaceIndexes: number[]; nbTypes: number }>
+): { requiredNamespaceIndexes: number[]; nbTypes: number } {
+    if (namespace.index === 0) {
+        return { requiredNamespaceIndexes: [], nbTypes: 1 };
     }
-    function considerStrongly(namespaceIndex: number) {
-        if (!depMap.has(namespaceIndex)) {
-            depMap.add(namespaceIndex);
-            const namespace = addressSpace.getNamespace(namespaceIndex);
-            dependency.push(namespace);
-            if (namespaceIndex > 0) {
-                _constructNamespaceDependency(namespace, dependency, depMap, _visitedDataType, priorityTable);
-            }
+    if (cache) {
+        if (cache.has(namespace.index)) {
+            return cache.get(namespace.index)!;
         }
     }
+    const requiredNamespaceIndexes = [0];
+    const requiredModelsSet = new Set<number>();
+    requiredModelsSet.add(0);
+    const namespace_ = namespace as NamespacePrivate;
+    let nbTypes = 0;
+    const addressSpace = namespace.addressSpace;
+    const types = [NodeClass.VariableType, NodeClass.ObjectType, NodeClass.ReferenceType, NodeClass.DataType];
+    const instances = [NodeClass.Variable, NodeClass.Object, NodeClass.Method];
+
+    const consider = (requiredModel: number) => {
+        if (requiredModel !== namespace.index && !requiredModelsSet.has(requiredModel)) {
+            requiredModelsSet.add(requiredModel);
+            requiredNamespaceIndexes.push(requiredModel);
+        }
+    };
+
+    const _visitedDataType: Set<string> = new Set<string>();
 
     function exploreDataTypeField(field: StructureField) {
         const dataType = field.dataType;
         const namespaceIndex = dataType.namespace;
-        considerStrongly(namespaceIndex);
+        consider(namespaceIndex);
         const dataTypeNode = addressSpace.findDataType(field.dataType);
         if (dataTypeNode) {
             exploreDataTypes(dataTypeNode);
@@ -65,7 +69,7 @@ function _constructNamespaceDependency(
         }
 
         const namespaceIndex = dataType.namespace;
-        considerStrongly(namespaceIndex);
+        consider(namespaceIndex);
         if (dataTypeNode.isStructure()) {
             const definition = dataTypeNode.getStructureDefinition();
             for (const field of definition.fields || []) {
@@ -78,7 +82,7 @@ function _constructNamespaceDependency(
     function exploreExtensionObject(e: ExtensionObject) {
         assert(!(e instanceof Variant));
         const nodeId = e.schema.encodingDefaultXml || e.schema.dataTypeNodeId || e.schema.dataTypeNodeId;
-        considerStrongly(nodeId.namespace);
+        consider(nodeId.namespace);
         // istanbul ignore next
         if (e.schema.dataTypeNodeId.isEmpty()) {
             warningLog("Cannot find dataTypeNodeId for ", e.schema.name);
@@ -88,6 +92,7 @@ function _constructNamespaceDependency(
         if (!d) return;
         exploreDataTypes(d);
     }
+
     function exploreDataValue(uaVariable: UAVariableImpl) {
         if (uaVariable.getBasicDataType() !== DataType.ExtensionObject) {
             return;
@@ -104,36 +109,131 @@ function _constructNamespaceDependency(
         }
     }
     for (const node of namespace_.nodeIterator()) {
-        if (node.nodeClass === NodeClass.Variable || node.nodeClass === NodeClass.VariableType) {
-            const dataTypeNodeId = (node as UAVariable | UAVariableType).dataType;
-            const dataTypeNode = addressSpace.findDataType(dataTypeNodeId)!;
-            if (dataTypeNode) {
-                exploreDataTypes(dataTypeNode);
-            } else {
-                // istanbul ignore next
-                if (dataTypeNodeId.value != 0) {
-                    warningLog("Warning: Cannot find dataType", dataTypeNodeId.toString());
+        const isType = types.indexOf(node.nodeClass);
+        const isInstance = instances.indexOf(node.nodeClass);
+        if (isType !== -1) {
+            nbTypes++;
+            const superTypes = node.findReferencesAsObject("HasSubtype", false);
+            if (superTypes.length === 0) {
+                continue;
+            }
+            if (superTypes.length !== 1) {
+                continue;
+            }
+            const superType = superTypes[0];
+            if (superType.nodeId.namespace === 0) {
+                continue;
+            }
+            const requiredModel = superType.nodeId.namespace;
+            consider(requiredModel);
+        } else if (isInstance !== -1) {
+            if (node.nodeClass === NodeClass.Variable || node.nodeClass === NodeClass.VariableType) {
+                const dataTypeNodeId = (node as UAVariable | UAVariableType).dataType;
+                const dataTypeNode = addressSpace.findDataType(dataTypeNodeId)!;
+                if (dataTypeNode) {
+                    consider(dataTypeNode.nodeId.namespace);
+                } else {
+                    // istanbul ignore next
+                    if (dataTypeNodeId.value != 0) {
+                        warningLog("Warning: Cannot find dataType", dataTypeNodeId.toString());
+                    }
                 }
+                const nodeV = node as UAVariableImpl;
+                exploreDataValue(nodeV);
             }
-            const nodeV = node as UAVariableImpl;
-            exploreDataValue(nodeV);
+
+            const typeDefinitions = node.findReferencesAsObject("HasTypeDefinition", true);
+            if (typeDefinitions.length === 0) {
+                continue;
+            }
+            if (typeDefinitions.length !== 1) {
+                continue;
+            }
+            const typeDefinition = typeDefinitions[0];
+            const requiredModel = typeDefinition.nodeId.namespace;
+            consider(requiredModel);
         }
-        // visit all references
-        const references = (<BaseNodeImpl>node).ownReferences();
-        for (const reference of references) {
-            // check referenceId
-            const namespaceIndex = getReferenceType(reference)!.nodeId.namespace;
-            consider(namespaceIndex);
-            const namespaceIndex2 = reference.nodeId.namespace;
-            consider(namespaceIndex2);
+    }
+
+    const result = { requiredNamespaceIndexes: requiredNamespaceIndexes, nbTypes: nbTypes };
+    if (cache) {
+        cache.set(namespace.index, result);
+    }
+    return result;
+}
+
+export function _recomputeRequiredModelsFromTypes2(
+    namespace: INamespace,
+    cache?: Map<number, { requiredNamespaceIndexes: number[]; nbTypes: number }>
+): { requiredNamespaceIndexes: number[] } {
+    const addressSpace = namespace.addressSpace;
+
+    const { requiredNamespaceIndexes } = _recomputeRequiredModelsFromTypes(namespace, cache);
+
+    const set = new Set<number>(requiredNamespaceIndexes);
+    const pass2: number[] = [];
+    for (const r of requiredNamespaceIndexes) {
+        if (r === 0) {
+            pass2.push(0);
+            continue;
+        }
+        const namespaces = _recomputeRequiredModelsFromTypes(addressSpace.getNamespace(r), cache);
+        for (const nIndex of namespaces.requiredNamespaceIndexes) {
+            if (!set.has(nIndex)) {
+                set.add(nIndex);
+                pass2.push(nIndex);
+            }
         }
+        pass2.push(r);
     }
+
+    return { requiredNamespaceIndexes: pass2 };
 }
 
-export function hasHigherPriorityThan(namespaceIndex1: number, namespaceIndex2: number, priorityTable: number[]) {
-    const order1 = priorityTable[namespaceIndex1];
-    const order2 = priorityTable[namespaceIndex2];
-    return order1 > order2;
+export function _getCompleteRequiredModelsFromValuesAndReferences(
+    namespace: INamespace,
+    priorityList: number[],
+    cache?: Map<number, { requiredNamespaceIndexes: number[]; nbTypes: number }>
+): number[] {
+
+    const namespace_ = namespace as NamespacePrivate;
+
+    const thisPriority = priorityList[namespace.index];
+
+    const requiredNamespaceIndexes = _recomputeRequiredModelsFromTypes2(namespace, cache).requiredNamespaceIndexes;
+    const requiredModelsSet: Set<number> = new Set<number>([... requiredNamespaceIndexes]);
+
+    const consider = (requiredModel: number) => {
+        if (requiredModel !== namespace.index && !requiredModelsSet.has(requiredModel)) {
+            requiredModelsSet.add(requiredModel);
+            requiredNamespaceIndexes.push(requiredModel);
+        }
+    }
+
+    //const maxIndex = Math.max(...requiredNamespaceIndexes);
+    for (const node of namespace_.nodeIterator()) {
+        const references = (<BaseNodeImpl>node).allReferences();
+        for (const reference of references) {
+            // if (reference.isForward) continue;
+            // only look at backward reference
+            // check referenceId
+            const namespaceIndexOfReferenceType = getReferenceType(reference)!.nodeId.namespace;
+            if (namespaceIndexOfReferenceType !== 0 && namespaceIndexOfReferenceType !== namespace.index) {
+                const refPriority = priorityList[namespaceIndexOfReferenceType];
+                if (refPriority <= thisPriority) {
+                    consider(namespaceIndexOfReferenceType);
+                }
+            }
+            const namespaceIndexOfTargetNode = reference.nodeId.namespace;
+            if (namespaceIndexOfTargetNode !== 0 && namespaceIndexOfTargetNode !== namespace.index) {
+                const refPriority = priorityList[namespaceIndexOfTargetNode];
+                if (refPriority <= thisPriority) {
+                    consider(namespaceIndexOfTargetNode);
+                }
+            }
+        }
+    }
+    return requiredNamespaceIndexes;
 }
 
 /**
@@ -150,58 +250,99 @@ export function hasHigherPriorityThan(namespaceIndex1: number, namespaceIndex2:
  *                           ---
  *  ua, own , di , kitchen , own2,  adi  => 0 , 2,  3,  5, 1
  */
-export function constructNamespacePriorityTable(namespace: INamespace): number[] {
-    // Namespace 0 will always be 0
-    // Namespaces with no requiredModel will be considered as instance namespaces and will added at the end
-    // in the same order as they appear,
-    // Namespace with requiredModels are considered to be companion specification, so already loaded in the correct order
-
-    const addressSpace = namespace.addressSpace;
+export function constructNamespacePriorityTable(addressSpace: IAddressSpace): { loadingOrder: number[]; priorityTable: number[] } {
+    // - Namespace 0 will always be 0
+    // - Namespace with requiredModels are considered to be companion specification,
+    //   so RequireModel will be used to determine the order
+    // - Namespaces with no requiredModel are more complicated:
+    //
+    //   we study ObjectType,ReferenceType, DataType and VariableType
+    //   to find strong dependencies between namespace.
+    //
+    //   if the namespace doesn't define ObjectType,ReferenceType, DataType and VariableType
+    //   it will be considered as instance namespaces and will added at the end
+    //   in the same order as they appear,
     const namespaces = addressSpace.getNamespaceArray();
 
-    const namespaceWithReq = namespaces.filter((n) => n.getRequiredModels() !== undefined && n.index !== 0);
-    const namespaceWithoutReq = namespaces.filter((n) => n.getRequiredModels() === undefined && n.index !== 0);
+    const loadingOrder: number[] = [0];
 
-    const priorityList: number[] = [0];
-    let counter = 1;
-    for (let i = 0; i < namespaceWithReq.length; i++) {
-        priorityList[namespaceWithReq[i].index] = counter++;
-    }
-    for (let i = 0; i < namespaceWithoutReq.length; i++) {
-        priorityList[namespaceWithoutReq[i].index] = counter++;
+    const map = new Map<number, { nbTypes: number; requiredNamespaceIndexes: number[]; namespace: INamespace }>();
+    for (let i = 0; i < namespaces.length; i++) {
+        const { nbTypes, requiredNamespaceIndexes } = _recomputeRequiredModelsFromTypes(namespaces[i], map);
+        map.set(namespaces[i].index, { nbTypes, requiredNamespaceIndexes, namespace: namespaces[i] });
     }
-    return priorityList;
-}
-const doDebug = false;
-export function constructNamespaceDependency(namespace: INamespace, priorityTable?: number[]): INamespace[] {
-    const addressSpace = namespace.addressSpace;
 
-    priorityTable = priorityTable || constructNamespacePriorityTable(namespace);
+    const visited = new Set<number>();
+    visited.add(0);
 
-    const dependency: INamespace[] = [];
-    const depMap = new Set<number>();
+    const h = (n: INamespace) => {
+        if (visited.has(n.index)) {
+            return;
+        }
+        visited.add(n.index);
+        const data = map.get(n.index);
+        if (!data) return;
+        const { requiredNamespaceIndexes } = data;
+        for (const r of requiredNamespaceIndexes || []) {
+            h(namespaces[r]);
+        }
+        loadingOrder.push(n.index);
+    };
 
-    dependency.push(addressSpace.getDefaultNamespace());
-    depMap.add(0);
+    for (let i = 0; i < namespaces.length; i++) {
+        const { nbTypes } = map.get(i)!;
+        if (nbTypes) {
+            h(namespaces[i]);
+        }
+    }
+    for (let i = 0; i < namespaces.length; i++) {
+        const { nbTypes } = map.get(i)!;
+        if (!nbTypes) {
+            h(namespaces[i]);
+        }
+    }
 
-    if (namespace !== addressSpace.getDefaultNamespace()) {
-        dependency.push(namespace);
-        depMap.add(namespace.index);
+    const priorityTable: number[] = [];
+    for (let i = 0; i < loadingOrder.length; i++) {
+        const namespaceIndex = loadingOrder[i];
+        assert(namespaceIndex !== -1);
+        priorityTable[namespaceIndex] = i;
     }
-    const _visitedDataType = new Set<string>();
 
-    _constructNamespaceDependency(namespace, dependency, depMap, _visitedDataType, priorityTable);
+    return { loadingOrder, priorityTable };
+}
 
-    // istanbul ignore next
-    doDebug && debugLog("namespace : ", namespace.index, namespace.namespaceUri);
-    // istanbul ignore next
-    doDebug && debugLog("   ", dependency.map((d) => d.index + " " + d.namespaceUri).join("\n   "));
+const doDebug = true;
+export function constructNamespaceDependency(namespace: INamespace, priorityTable?: number[]): INamespace[] {
+    const addressSpace = namespace.addressSpace;
+    priorityTable = priorityTable || constructNamespacePriorityTable(addressSpace).priorityTable;
+    const requiredNamespaceIndexes = _getCompleteRequiredModelsFromValuesAndReferences(namespace, priorityTable);
+    return [...requiredNamespaceIndexes.map((r) => addressSpace.getNamespace(r)), namespace];
+}
 
-    const sorted = dependency.sort((a, b) => (priorityTable![a.index] < priorityTable![b.index] ? -1 : 1));
-    // istanbul ignore next
-    doDebug && debugLog("sorted:");
-    // istanbul ignore next
-    doDebug && debugLog("   ", sorted.map((d) => d.index + " " + d.namespaceUri).join("\n   "));
+/**
+ * @private
+ */
+export function _constructNamespaceTranslationTable(dependency: INamespace[], exportedNamespace: INamespace): ITranslationTable {
+    if (!dependency || dependency.length === 0) {
+        return { 0: 0 };
+        // throw new Error("Cannot constructNamespaceTranslationTable on empty dependency");
+    }
+    const translationTable: ITranslationTable = {};
+    assert(dependency[0].namespaceUri === "http://opcfoundation.org/UA/");
 
-    return sorted;
+    let counter = 0;
+    translationTable[dependency[0].index] = counter++;
+    //
+    if (exportedNamespace) {
+        translationTable[exportedNamespace.index] = counter++;
+    }
+    for (let i = 1; i < dependency.length; i++) {
+        const dep = dependency[i];
+        if (exportedNamespace && exportedNamespace === dep) {
+            continue;
+        }
+        translationTable[dep.index] = counter++;
+    }
+    return translationTable;
 }

package/src/nodeset_tools/nodeset_to_xml.ts

@@ -53,9 +53,9 @@ import { UAViewImpl } from "../ua_view_impl";
 import { DefinitionMap2, TypeInfo } from "../../source/loader/make_xml_extension_object_parser";
 import { makeDefinitionMap } from "../../source/loader/decode_xml_extension_object";
 import {
+    _constructNamespaceTranslationTable,
     constructNamespaceDependency,
-    constructNamespacePriorityTable,
-    hasHigherPriorityThan
+    constructNamespacePriorityTable
 } from "./construct_namespace_dependency";
 
 // tslint:disable:no-var-requires
@@ -105,6 +105,13 @@ function b(xw: XmlWriter, browseName: QualifiedName): string {
     return translateBrowseName(xw, browseName).toString().replace("ns=0;", "");
 }
 
+
+function hasHigherPriorityThan(namespaceIndex1: number, namespaceIndex2: number, priorityTable: number[]) {
+    const order1 = priorityTable[namespaceIndex1];
+    const order2 = priorityTable[namespaceIndex2];
+    return order1 > order2;
+}
+
 function _hasHigherPriorityThan(xw: XmlWriter, namespaceIndex1: number, namespaceIndex2: number) {
     assert(xw.priorityTable, "expecting a priorityTable");
     assert(namespaceIndex1 < xw.priorityTable.length);
@@ -128,7 +135,6 @@ function _dumpReferences(xw: XmlWriter, node: BaseNode) {
 
     function referenceToKeep(reference: UAReference): boolean {
         const referenceType = (reference as ReferenceImpl)._referenceType!;
-
         const targetedNamespaceIndex = reference.nodeId.namespace;
         if (_hasHigherPriorityThan(xw, targetedNamespaceIndex, node.nodeId.namespace)) {
             // this reference has nothing to do here ! drop it
@@ -165,8 +171,8 @@ function _dumpReferences(xw: XmlWriter, node: BaseNode) {
         }
         return false;
     }
-
-    const references = node.allReferences().filter(referenceToKeep);
+    const allReferences = node.allReferences();
+    const references = allReferences.filter(referenceToKeep);
 
     for (const reference of references.sort(sortByNodeId)) {
         if (getReferenceType(reference).browseName.toString() === "HasSubtype" && reference.isForward) {
@@ -535,6 +541,10 @@ function _dumpVariantExtensionObjectValue2(xw: XmlWriter, addressSpace: IAddress
     const dataTypeNodeId = value.schema.dataTypeNodeId;
     const definitionMap = makeDefinitionMap(addressSpace);
     const dataTypeNode = addressSpace.findDataType(dataTypeNodeId)!;
+    if (!dataTypeNode) {
+        warningLog("_dumpVariantExtensionObjectValue2: Cannot find dataType for  ", dataTypeNodeId.toString());
+        return;
+    }
     _dumpVariantExtensionObjectValue(xw, dataTypeNode.nodeId, definitionMap, value);
 }
 
@@ -1155,7 +1165,7 @@ function dumpUAObjectType(xw: XmlWriter, node: UAObjectTypeImpl) {
     xw.writeComment("ObjectType - " + b(xw, node.browseName) + " {{{{ ");
     _markAsVisited(xw, node);
 
-    // dump SubtypeOf and HasTypeDefinition
+    // dump SubtypeOf and HasTypeDefinition node if part of the same namespace
     dumpReferencedNodes(xw, node, false);
 
     xw.startElement("UAObjectType");
@@ -1268,25 +1278,6 @@ function writeAliases(xw: XmlWriter, aliases: Record<string, NodeIdString>) {
     xw.endElement();
 }
 
-function constructNamespaceTranslationTable(dependency: INamespace[], exportedNamespace: INamespace): ITranslationTable {
-    const translationTable: ITranslationTable = {};
-    assert(dependency[0].namespaceUri === "http://opcfoundation.org/UA/");
-
-    let counter = 0;
-    translationTable[dependency[0].index] = counter++;
-    //
-    if (exportedNamespace) {
-        translationTable[exportedNamespace.index] = counter++;
-    }
-    for (let i = 1; i < dependency.length; i++) {
-        const dep = dependency[i];
-        if (exportedNamespace && exportedNamespace === dep) {
-            continue;
-        }
-        translationTable[dep.index] = counter++;
-    }
-    return translationTable;
-}
 function dumpReferenceType(xw: XmlWriter, referenceType: UAReferenceType) {
     _markAsVisited(xw, referenceType);
 
@@ -1382,9 +1373,10 @@ NamespaceImpl.prototype.toNodeset2XML = function (this: NamespaceImpl) {
 
     const xw: XmlWriter = new XMLWriter(true);
 
-    xw.priorityTable = constructNamespacePriorityTable(this);
+    xw.priorityTable = constructNamespacePriorityTable(this.addressSpace).priorityTable;
+
     const dependency = constructNamespaceDependency(this, xw.priorityTable);
-    const translationTable = constructNamespaceTranslationTable(dependency, this);
+    const translationTable = _constructNamespaceTranslationTable(dependency, this);
     xw.translationTable = translationTable;
 
     xw.startDocument({ encoding: "utf-8", version: "1.0" });

package/src/ua_variable_impl.ts

@@ -94,6 +94,7 @@ import {
 } from "./ua_variable_impl_ext_obj";
 import { adjustDataValueStatusCode } from "./data_access/adjust_datavalue_status_code";
 import { _getBasicDataType } from "./get_basic_datatype";
+import { validateDataTypeCorrectness} from "./validate_data_type_correctness";
 
 const debugLog = make_debugLog(__filename);
 const warningLog = make_warningLog(__filename);
@@ -149,94 +150,6 @@ function is_Variant_or_StatusCode(v: any): boolean {
     return is_Variant(v) || is_StatusCode(v);
 }
 
-function _dataType_toUADataType(addressSpace: IAddressSpace, dataType: DataType): UADataType {
-    assert(addressSpace);
-    assert(dataType !== DataType.Null);
-
-    const dataTypeNode = addressSpace.findDataType(DataType[dataType]);
-    /* istanbul ignore next */
-    if (!dataTypeNode) {
-        throw new Error(" Cannot find DataType " + DataType[dataType] + " in address Space");
-    }
-    return dataTypeNode as UADataType;
-}
-/*=
- *
- * @param addressSpace
- * @param dataTypeNodeId : the nodeId matching the dataType of the destination variable.
- * @param variantDataType: the dataType of the variant to write to the destination variable
- * @param nodeId
- * @return {boolean} true if the variant dataType is compatible with the Variable DataType
- */
-function validateDataType(
-    addressSpace: IAddressSpace,
-    dataTypeNodeId: NodeId,
-    variantDataType: DataType,
-    nodeId: NodeId,
-    allowNulls: boolean
-): boolean {
-    if (variantDataType === DataType.ExtensionObject) {
-        return true;
-    }
-    if (variantDataType === DataType.Null && allowNulls) {
-        return true;
-    }
-    if (variantDataType === DataType.Null && !allowNulls) {
-        return false;
-    }
-    let builtInType: DataType;
-    let builtInUADataType: UADataType;
-
-    const destUADataType = addressSpace.findDataType(dataTypeNodeId)!;
-    assert(destUADataType instanceof UADataTypeImpl);
-
-    if (destUADataType.isAbstract || destUADataType.nodeId.namespace !== 0) {
-        builtInUADataType = destUADataType;
-    } else {
-        builtInType = addressSpace.findCorrespondingBasicDataType(destUADataType);
-        builtInUADataType = addressSpace.findDataType(builtInType)!;
-    }
-    assert(builtInUADataType instanceof UADataTypeImpl);
-
-    const enumerationUADataType = addressSpace.findDataType("Enumeration");
-    if (!enumerationUADataType) {
-        throw new Error("cannot find Enumeration DataType node in standard address space");
-    }
-    if (destUADataType.isSubtypeOf(enumerationUADataType)) {
-        // istanbul ignore next
-        if (doDebug) {
-            debugLog("destUADataType.", destUADataType.browseName.toString(), destUADataType.nodeId.toString());
-            debugLog(
-                "enumerationUADataType.",
-                enumerationUADataType.browseName.toString(),
-                enumerationUADataType.nodeId.toString()
-            );
-        }
-        return true;
-    }
-
-    // The value supplied for the attribute is not of the same type as the  value.
-    const variantUADataType = _dataType_toUADataType(addressSpace, variantDataType);
-    assert(variantUADataType instanceof UADataTypeImpl);
-
-    const dest_isSubTypeOf_variant = variantUADataType.isSubtypeOf(builtInUADataType);
-
-    /* istanbul ignore next */
-    if (doDebug) {
-        if (dest_isSubTypeOf_variant) {
-            /* istanbul ignore next*/
-            debugLog(chalk.green(" ---------- Type match !!! "), " on ", nodeId.toString());
-        } else {
-            /* istanbul ignore next*/
-            debugLog(chalk.red(" ---------- Type mismatch "), " on ", nodeId.toString());
-        }
-        debugLog(chalk.cyan(" Variable data Type is    = "), destUADataType.browseName.toString());
-        debugLog(chalk.cyan(" which matches basic Type = "), builtInUADataType.browseName.toString());
-        debugLog(chalk.yellow("        Actual   dataType = "), variantUADataType.browseName.toString());
-    }
-
-    return dest_isSubTypeOf_variant;
-}
 
 function default_func(this: UAVariable, dataValue1: DataValue, callback1: CallbackT<StatusCode>) {
     return _default_writable_timestamped_set_func.call(this, dataValue1, callback1);
@@ -1707,7 +1620,7 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
     }
 
     public _validate_DataType(variantDataType: DataType): boolean {
-        return validateDataType(this.addressSpace, this.dataType, variantDataType, this.nodeId, /* allow Nulls */ false);
+        return validateDataTypeCorrectness(this.addressSpace, this.dataType, variantDataType, /* allow Nulls */ false, this.nodeId);
     }
 
     public _internal_set_value(value: Variant): void {