Fix as per comments 2.

Author: nshchego

src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/convert_precision_i64_i32.cpp

@@ -59,6 +59,10 @@ bool ConvertPrecisionI64ToI32::run_on_model(const std::shared_ptr<ov::Model>& mo
                         parentNode->get_input_element_type(0) == element::i32 &&
                         parentNode->get_output_element_type(0) == element::i64) {
                     input.replace_source_output(parentNode->input_value(0));
+                } else if (is_type<opset12::Convert>(op) &&
+                        op->get_input_element_type(0) == element::i64 &&
+                        op->get_output_element_type(0) == element::i32) {
+                    continue;
                 } else if (auto constOp = as_type_ptr<op::v0::Constant>(parentNode)) {
                     auto newConst = changeConstantPrecision(constOp);
                     input.replace_source_output(newConst);
@@ -78,7 +82,7 @@ bool ConvertPrecisionI64ToI32::run_on_model(const std::shared_ptr<ov::Model>& mo
             for (auto& output : op->outputs()) {
                 if (output.get_element_type() == element::i32) {
                     auto convert = std::make_shared<opset12::Convert>(output, element::i64);
-                    replace_output_update_name(output, convert->input_value(0));
+                    replace_output_update_name(output, convert->output(0));
                 }
             }
         }

src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/convert_precision_i64_i32.hpp

@@ -6,6 +6,10 @@
 
 #include "openvino/pass/pass.hpp"
 
+// This transformation inserts Conversion node (i64->i32) before a node that does not support i64 execution.
+// If the Conversion i64->i32 was added before the target node, it also inserts the Conversion i32->i64 after
+// the target node to leave the child nodes with i64 type.
+
 namespace ov {
 namespace intel_cpu {
 class ConvertPrecisionI64ToI32: public ov::pass::ModelPass {

src/plugins/intel_cpu/src/transformations/transformation_pipeline.cpp

@@ -215,7 +215,7 @@ void Transformations::PreLpt(const std::vector<ov::element::Type>& defaultPrecis
     }
     const bool enable_i64 = config.enableNativeI64;
 
-    auto get_convert_precisions = [&]() {
+    auto get_convert_precisions = [&enable_i64]() {
         precisions_map map = {
             {ov::element::i16,     ov::element::i32},
             {ov::element::u16,     ov::element::i32},

src/plugins/intel_cpu/tests/functional/subgraph_tests/src/custom_op_insert_convert_i64.cpp

@@ -134,8 +134,7 @@ class CustomOpConvertI64CPUTest : public testing::WithParamInterface<CustomOpI64
 
 TEST_P(CustomOpConvertI64CPUTest, CompareWithRefs) {
     run();
-    // TODO: Graph could not be dumped with int64 for now. Swith on this in scope of int64 enabling.
-    // CPUTestUtils::CheckNumberOfNodesWithType(compiledModel, "Convert", 1);
+    CPUTestUtils::CheckNumberOfNodesWithType(compiledModel, "Convert", 1);
 }
 
 const InputShape inputShapes = {

src/plugins/intel_cpu/tests/functional/subgraph_tests/src/insert_convert_i64_i32.cpp

@@ -0,0 +1,62 @@
+// Copyright (C) 2018-2023 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include <shared_test_classes/base/ov_subgraph.hpp>
+#include <ngraph_functions/builders.hpp>
+#include "test_utils/cpu_test_utils.hpp"
+#include <cpp_interfaces/interface/ie_internal_plugin_config.hpp>
+
+using namespace ov::test;
+using namespace CPUTestUtils;
+
+namespace CPULayerTestsDefinitions {
+using InsertConvertI64I32CPUTestParams = std::tuple<ElementType, InputShape>;
+
+class InsertConvertI64I32CPUTest : public testing::WithParamInterface<InsertConvertI64I32CPUTestParams>,
+                                   virtual public SubgraphBaseTest,
+                                   public CPUTestsBase {
+public:
+    static std::string getTestCaseName(const testing::TestParamInfo<InsertConvertI64I32CPUTestParams>& obj) {
+        ElementType inType;
+        InputShape inputShape;
+        std::tie(inType, inputShape) = obj.param;
+
+        std::ostringstream result;
+        result << "IS=" << inputShape << "_";
+        result << "Prc=" << inType;
+        return result.str();
+    }
+
+protected:
+    void SetUp() override {
+        targetDevice = CommonTestUtils::DEVICE_CPU;
+        configuration[InferenceEngine::PluginConfigInternalParams::KEY_CPU_NATIVE_I64] = InferenceEngine::PluginConfigParams::YES;
+
+        InputShape inputShape;
+        std::tie(inType, inputShape) = this->GetParam();
+
+        init_input_shapes({inputShape});
+        auto inputParams = ngraph::builder::makeDynamicParams(inType, inputDynamicShapes);
+        auto nonZero = std::make_shared<ov::op::v3::NonZero>(inputParams[0]);
+
+        ov::ResultVector results{std::make_shared<ov::op::v0::Result>(nonZero)};
+        function = std::make_shared<ov::Model>(results, inputParams, "insertConvertI64I32");
+    }
+};
+
+TEST_P(InsertConvertI64I32CPUTest, CompareWithRefs) {
+    run();
+    CheckNumberOfNodesWithType(compiledModel, "Convert", 2);
+}
+
+const InputShape inputShapes = {
+        {}, {{1, 3, 32, 32}}
+};
+
+INSTANTIATE_TEST_SUITE_P(smoke_CustomOp,
+                         InsertConvertI64I32CPUTest,
+                         ::testing::Combine(::testing::Values(ElementType::i64), ::testing::Values(inputShapes)),
+                         InsertConvertI64I32CPUTest::getTestCaseName);
+
+} // namespace CPULayerTestsDefinitions