[CoreML EP] Support bool Cast in ML Program

[maxwbuckley]

Summary

Two changes to the ML Program Cast builder:

1. Accept BOOL as a source and target dtype in HasSupportedInputsImpl. The
   ML Program cast op already handles bool, and AddToModelBuilderImpl already
   maps to == BOOL; only the input/output type gate omitted it.
2. Move the "no preceding node" check after the ML Program early-return. That
   check is legacy gating for the NeuralNetwork ArgMax-only path (which
   dereferences InputEdgesBegin()); on the ML Program path a Cast fed directly
   by a graph input is fine, and rejecting it forced needless CPU fallback.

Why

This is the first of a 4-PR series giving the CoreML EP the op coverage to run
transformer and diffusion graphs as a single CoreML partition instead of
fragmenting across CPU.

Transformer attention-mask graphs are a Cast → GatherND → And → Where chain over
bool tensors. A CoreML partition cannot have a bool input/output (CoreML
MLMultiArray has no bool type), so bool must stay internal — which makes Cast
(the int↔bool boundary) the prerequisite for the rest of the series.

Combined impact of the series

With all four PRs plus #28278 (scalar-Gather), every model below goes from 2
CoreML partitions to 1, with zero graph breaks — the whole graph runs on
CoreML. Measured on an Apple M3 Max, ML Program format:

Model	partitions (before → after)	CoreML vs CPU
BERT-large (340M)	2 → 1	7.3× (fp32) / 11.0× (fp16)
ViT-large (304M)	2 → 1	8.5× (fp32) / 10.3× (fp16)
GPT-2-large (774M)	2 → 1	11.4× (fp16)
SD-1.5 UNet (860M)	2 → 1	9.7× (fp16)

The op builders eliminate the graph breaks (deterministic); the speedups are what
CoreML already delivers once a model is no longer fragmented.

Tests (coreml_basic_test.cc)

• CastNonArgMaxNeuralNetworkNotSupported — an int64 → bool → float cast chain
  falls back to CPU on the NeuralNetwork format, guarding the IsOpSupportedImpl
  reordering.

Positive bool-Cast coverage is in the dependent PRs: Cast → GatherND → Cast
(#28598's GatherNDBoolData_MLProgram) and Cast → And → Cast (#28597's
And_MLProgram). Both place a non-Cast op between the int↔bool casts and check
the result against the CPU EP. A standalone int64 → Cast(bool) → Cast(float)
round-trip can't be verified here — CoreML's compiler fuses back-to-back cast
ops and drops the bool clamp — so the pattern needs that intervening op, which
only the dependent PRs provide.

Series — CoreML EP coverage for transformer / diffusion graphs

• [CoreML EP] Support bool Cast in ML Program #28595 — Support bool Cast in ML Program (this PR — prerequisite)
• [CoreML EP] Add Sin and Cos unary ops #28596 — Add Sin and Cos unary ops (independent)
• [CoreML EP] Add Where and And builders #28597 — Add Where and And builders (depends on [CoreML EP] Support bool Cast in ML Program #28595)
• [CoreML EP] Add GatherND builder #28598 — Add GatherND builder (depends on [CoreML EP] Support bool Cast in ML Program #28595)

Together with #28278 (scalar-Gather), the series takes BERT / GPT-2 / ViT /
diffusion-UNet graphs — tiny and full-size — from 2 CoreML partitions to 1, with
zero graph breaks.

[maxwbuckley]

@yuslepukhin Continuing the great work on making Mac ML on Onnxruntime amazing! Thank you :)

[Copilot]

Pull request overview

This PR extends the CoreML EP’s ML Program Cast support to enable bool casts and avoid unnecessary CPU fallbacks when a Cast is fed directly by a graph input (no preceding node). This is positioned as a prerequisite step toward keeping transformer/diffusion attention-mask subgraphs fully within a single CoreML partition.

Changes:

• Allow BOOL as a supported input/output dtype for ML Program Cast in HasSupportedInputsImpl.
• Reorder IsOpSupportedImpl so the “no preceding node” rejection applies only to the NeuralNetwork (ArgMax-only) path, not ML Program.
• Add a regression test ensuring non-ArgMax Cast chains fall back on the NeuralNetwork format.

Reviewed changes

Copilot reviewed 2 out of 2 changed files in this pull request and generated 1 comment.

File	Description
onnxruntime/core/providers/coreml/builders/impl/cast_op_builder.cc	Enables bool dtype gating for ML Program casts and relaxes the “must have preceding node” constraint for ML Program.
onnxruntime/test/providers/coreml/coreml_basic_test.cc	Adds a NeuralNetwork-format negative test covering the reordered support checks.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[wejoncy]

LGTM, Does this has any constrains on the CoreML version?

[maxwbuckley]

Thanks for the review! No additional version constraint beyond what the EP already requires for MLProgram. The MIL cast op (iOS 15 / Core ML 5) already accepts bool as both an input type and a dtype string — see coremltools/.../iOS15/elementwise_unary.py where T = (fp16, fp32, int32, bool) and the dtype docstring lists bool. Since this PR only touches the MLProgram path (gated to Core ML 5+ by model_builder.h), the bool-cast support inherits that same minimum: iOS 15 / macOS 12 / Core ML 5.

[wejoncy]

Could you resolve the conflicts?

[yuslepukhin]

There are conflicts and MacOS test failures: CoreMLExecutionProviderTest.CastBoolMLProgramPartition

[ RUN      ] CoreMLExecutionProviderTest.CastBoolMLProgramPartition
3: /Users/runner/work/onnxruntime/onnxruntime/onnxruntime/test/util/test_utils.cc:108: Failure
3: Expected equality of these values:
3:   provider_node_count
3:     Which is: 0
3:   graph.NumberOfNodes()
3:     Which is: 2
3: Not all nodes were assigned to CoreMLExecutionProvider
3: 
3: [  FAILED  ] CoreMLExecutionProviderTest.CastBoolMLProgramPartition

Convert this test into a partition-only inspection test that verifies the ML Program path claims the Cast nodes, without requiring execution semantics from a back-to-back cast chain.

A good pattern is to inspect the assigned EP types in the resolved graph, similar to other graph-verifier-based tests in the same file.

TEST(CoreMLExecutionProviderTest, CastBoolMLProgramPartition) {
  const std::string model_data = MakeCastBoolModelData();
  gsl::span<const std::byte> model_span{
      reinterpret_cast<const std::byte*>(model_data.data()), model_data.size()};

  const std::function<void(const Graph&)> graph_verifier = [](const Graph& graph) {
    GraphViewer graph_viewer{graph};
    const auto& node_indices_in_order = graph_viewer.GetNodesInTopologicalOrder();
    ASSERT_EQ(node_indices_in_order.size(), size_t{2});

    const auto* cast_to_bool = graph.GetNode(node_indices_in_order[0]);
    ASSERT_NE(cast_to_bool, nullptr);
    ASSERT_EQ(cast_to_bool->OpType(), "Cast");
    ASSERT_EQ(cast_to_bool->GetExecutionProviderType(), kCoreMLExecutionProvider);

    const auto* cast_to_float = graph.GetNode(node_indices_in_order[1]);
    ASSERT_NE(cast_to_float, nullptr);
    ASSERT_EQ(cast_to_float->OpType(), "Cast");
    ASSERT_EQ(cast_to_float->GetExecutionProviderType(), kCoreMLExecutionProvider);
  };

  EPVerificationParams verification_params{};
  verification_params.ep_node_assignment = ExpectedEPNodeAssignment::All;
  verification_params.graph_verifier = &graph_verifier;

  TestModelLoad(model_span,
                MakeCoreMLExecutionProvider("MLProgram"),
                ExpectedEPNodeAssignment::All,
                &verification_params);
}