Propagate outer scope type info to subgraphs during verification (#27707)

## Summary

- Fix ORT raising "does not have type information set by parent node"
when a subgraph references an initializer declared in the outer (parent)
graph without explicit `value_info` in the subgraph
- Propagate type info from implicit input defs to subgraph NodeArgs
before subgraph verification in `VerifyNodeAndOpMatch`
- Add regression test with an `If` node whose subgraph references an
outer scope initializer without `value_info`

## Motivation

Fixes #24880

When a node's op schema type inference function does not invoke subgraph
inferencing (e.g., contrib ops like `BeamSearch`, `GreedySearch`,
`WhisperBeamSearch`, `Sampling`), `InferAndVerifySubgraphTypes` is never
called. This means type info from outer scope values — such as
initializers declared in the parent graph — is never propagated to the
subgraph's NodeArgs. When the subgraph is later verified in the second
pass of `VerifyNodeAndOpMatch`, nodes referencing these outer scope
values fail with a null type error.

The existing workaround in `convert_generation.py` (manually adding
`value_info` entries for moved initializers) confirms this gap in the
type propagation path.

## Changes

**`onnxruntime/core/graph/graph.cc`**: In `VerifyNodeAndOpMatch`'s
subgraph verification loop, propagate type info from the containing
node's `implicit_input_defs` to the subgraph's NodeArgs before calling
`VerifyNodeAndOpMatch` on the subgraph. The propagation is guarded by
`subgraph_nodearg->Type() == nullptr`, making it a safe no-op for
standard ONNX ops (If/Loop/Scan) where `InferAndVerifySubgraphTypes`
already set the types. For nested subgraphs, the recursive call to
`VerifyNodeAndOpMatch` handles propagation at each level.

**`onnxruntime/test/ir/graph_test.cc`**: Add
`OuterScopeInitializerTypeInfoPropagatedToSubgraph` test that constructs
a model proto with an `If` node whose subgraphs reference an outer graph
initializer without `value_info`, and verifies `Model::Load` (which
calls `Graph::Resolve`) succeeds.

## Test Plan

- [ ] New C++ unit test
`OuterScopeInitializerTypeInfoPropagatedToSubgraph` verifies model
resolution succeeds
- [ ] Existing `graph_test.cc` tests continue to pass (no regression in
type inference for standard ONNX ops)
- [ ] Existing control flow tests (If/Loop/Scan) continue to pass
- [ ] CI lint checks pass (verified locally with `lintrunner`)

Author: Rishi-Dave

onnxruntime/core/graph/graph.cc

@@ -3588,6 +3588,28 @@ Status Graph::VerifyNodeAndOpMatch(const ResolveOptions& options) {
     auto& node = *GetNode(node_index);
     for (auto& entry : node.GetAttributeNameToMutableSubgraphMap()) {
       Graph* subgraph = entry.second;
+
+      // Propagate type info from outer scope implicit inputs to the subgraph's NodeArgs.
+      // This is needed when the op's type/shape inference function does not invoke subgraph
+      // inferencing (e.g., some contrib ops like BeamSearch), so InferAndVerifySubgraphTypes
+      // may not have been called to propagate type info from outer scope values such as
+      // initializers declared in the parent graph.
+      // When InferAndVerifySubgraphTypes was already called, UpdateTypeAndShape with strict=true
+      // validates that the existing type is consistent with the outer-scope type.
+      const auto& implicit_input_defs = node.GetDefinitions().implicit_input_defs;
+      for (const auto* implicit_node_arg : implicit_input_defs) {
+        auto* subgraph_nodearg = subgraph->GetNodeArg(implicit_node_arg->Name());
+        if (subgraph_nodearg != nullptr &&
+            implicit_node_arg->TypeAsProto() != nullptr) {
+          auto status = subgraph_nodearg->UpdateTypeAndShape(
+              *implicit_node_arg, /*strict=*/true, options.override_types, subgraph->logger_);
+          if (!status.IsOK()) {
+            return ORT_MAKE_STATUS(ONNXRUNTIME, FAIL,
+                                   "Node:", node.Name(), " [subgraph:", entry.first, "] ", status.ErrorMessage());
+          }
+        }
+      }
+
       ORT_RETURN_IF_ERROR(subgraph->VerifyNodeAndOpMatch(options));
     }
   }

onnxruntime/test/ir/graph_test.cc

@@ -3212,5 +3212,196 @@ TEST_F(GraphTest, MalformedModelEmptySubgraph) {
   EXPECT_FALSE(status.IsOK());
 }
 
+// Test for GitHub issue #24880: subgraph referencing an initializer from the outer graph
+// should resolve successfully even without explicit value_info in the subgraph.
+// Uses a custom op with a GRAPH attribute but NO type inference function, so subgraph
+// type inferencing is never invoked. This directly exercises the verification-time
+// propagation in VerifyNodeAndOpMatch.
+TEST_F(GraphTest, OuterScopeInitializerTypeInfoPropagatedToSubgraph) {
+  // Register a custom op with a GRAPH attribute but no type/shape inference function.
+  // This simulates ops like BeamSearch whose schema inference does not invoke subgraph
+  // inferencing, so InferAndVerifySubgraphTypes is never called during type inference.
+  std::shared_ptr<onnxruntime::OnnxRuntimeOpSchemaRegistry> registry =
+      std::make_shared<OnnxRuntimeOpSchemaRegistry>();
+  std::vector<ONNX_NAMESPACE::OpSchema> schema = {
+      OpSchema()
+          .SetName("FakeSubgraphOp")
+          .SetDomain("FakeTestDomain")
+          .Input(0, "X", "Input tensor", "T")
+          .Output(0, "Y", "Output tensor", "T")
+          .Attr("body", "A subgraph", AttributeProto::GRAPH)
+          .TypeConstraint("T", OpSchema::all_tensor_types(),
+                          "Constrain input and output types to any tensor type.")};
+  ASSERT_TRUE(registry->RegisterOpSet(schema, "FakeTestDomain", 0, 1).IsOK());
+
+  // Build the model proto.
+  // Main graph: float input "x" [2,3], float initializer "weight" [2,3],
+  //             FakeSubgraphOp node with a subgraph that references "weight".
+  // The subgraph uses "weight" via implicit capture (no value_info for it in the subgraph).
+  ModelProto model_proto;
+  model_proto.set_ir_version(ONNX_NAMESPACE::Version::IR_VERSION);
+  ImportOpset(model_proto, "", 16);
+  ImportOpset(model_proto, "FakeTestDomain", 1);
+
+  GraphProto& main_graph = *model_proto.mutable_graph();
+  main_graph.set_name("main_graph");
+
+  // Main graph input: float tensor "x"
+  ValueInfoProto* x_input = main_graph.add_input();
+  x_input->set_name("x");
+  SetTypeAndShape(x_input->mutable_type()->mutable_tensor_type(), TensorProto_DataType_FLOAT, {2, 3});
+
+  // Initializer "weight" in the main graph (float [2,3]).
+  // Not added as a graph input — ORT relaxes the ONNX requirement that initializers
+  // must also be listed as graph inputs.
+  TensorProto* weight_init = main_graph.add_initializer();
+  weight_init->set_name("weight");
+  weight_init->set_data_type(TensorProto_DataType_FLOAT);
+  weight_init->add_dims(2);
+  weight_init->add_dims(3);
+  for (int i = 0; i < 6; ++i) {
+    weight_init->add_float_data(static_cast<float>(i));
+  }
+
+  // Build subgraph: Identity(weight) -> result
+  // "weight" is from the outer scope — deliberately NO value_info for it in this subgraph.
+  // It will be picked up as an implicit input by BuildConnections.
+  GraphProto subgraph;
+  subgraph.set_name("body_subgraph");
+
+  // Subgraph output
+  ValueInfoProto* sg_output = subgraph.add_output();
+  sg_output->set_name("result");
+  SetTypeAndShape(sg_output->mutable_type()->mutable_tensor_type(), TensorProto_DataType_FLOAT, {2, 3});
+
+  // Identity node: result = Identity(weight)
+  NodeProto* identity_node = subgraph.add_node();
+  identity_node->set_op_type("Identity");
+  *identity_node->add_input() = "weight";  // outer scope initializer
+  *identity_node->add_output() = "result";
+
+  // FakeSubgraphOp node: takes "x" as input, has "body" subgraph attribute
+  NodeProto* fake_node = main_graph.add_node();
+  fake_node->set_op_type("FakeSubgraphOp");
+  fake_node->set_domain("FakeTestDomain");
+  fake_node->set_name("fake_subgraph_node");
+  *fake_node->add_input() = "x";
+  *fake_node->add_output() = "y";
+
+  AttributeProto* body_attr = fake_node->add_attribute();
+  body_attr->set_name("body");
+  body_attr->set_type(AttributeProto_AttributeType_GRAPH);
+  *body_attr->mutable_g() = subgraph;
+
+  // Main graph output
+  ValueInfoProto* main_output = main_graph.add_output();
+  main_output->set_name("y");
+  SetTypeAndShape(main_output->mutable_type()->mutable_tensor_type(), TensorProto_DataType_FLOAT, {2, 3});
+
+  // Load the model — this calls Graph::Resolve internally.
+  // Without the fix, this fails with:
+  //   "input arg (weight) does not have type information set by parent node"
+  // because FakeSubgraphOp has no type inference that propagates types to the subgraph.
+  // The fix propagates type info from implicit_input_defs during VerifyNodeAndOpMatch.
+  std::shared_ptr<Model> model;
+  std::list<std::shared_ptr<IOnnxRuntimeOpSchemaCollection>> regs = {registry};
+  ASSERT_STATUS_OK(Model::Load(std::move(model_proto), model, &regs, *logger_));
+}
+
+// Negative companion to OuterScopeInitializerTypeInfoPropagatedToSubgraph.
+// The subgraph declares a value_info for the outer-scope initializer "weight"
+// with a conflicting element type (INT64 vs FLOAT).  Model::Load must fail and
+// the error message must identify the type conflict.
+TEST_F(GraphTest, OuterScopeInitializerConflictingTypeFails) {
+  // Same custom-op registration as the positive test.
+  std::shared_ptr<onnxruntime::OnnxRuntimeOpSchemaRegistry> registry =
+      std::make_shared<OnnxRuntimeOpSchemaRegistry>();
+  std::vector<ONNX_NAMESPACE::OpSchema> schema = {
+      OpSchema()
+          .SetName("FakeSubgraphOp2")
+          .SetDomain("FakeTestDomain")
+          .Input(0, "X", "Input tensor", "T")
+          .Output(0, "Y", "Output tensor", "T")
+          .Attr("body", "A subgraph", AttributeProto::GRAPH)
+          .TypeConstraint("T", OpSchema::all_tensor_types(),
+                          "Constrain input and output types to any tensor type.")};
+  ASSERT_TRUE(registry->RegisterOpSet(schema, "FakeTestDomain", 0, 1).IsOK());
+
+  // Build the model proto — identical outer graph to the positive test.
+  ModelProto model_proto;
+  model_proto.set_ir_version(ONNX_NAMESPACE::Version::IR_VERSION);
+  ImportOpset(model_proto, "", 16);
+  ImportOpset(model_proto, "FakeTestDomain", 1);
+
+  GraphProto& main_graph = *model_proto.mutable_graph();
+  main_graph.set_name("main_graph");
+
+  // Main graph input: float tensor "x" [2,3]
+  ValueInfoProto* x_input = main_graph.add_input();
+  x_input->set_name("x");
+  SetTypeAndShape(x_input->mutable_type()->mutable_tensor_type(), TensorProto_DataType_FLOAT, {2, 3});
+
+  // Initializer "weight" in the main graph: FLOAT [2,3].
+  TensorProto* weight_init = main_graph.add_initializer();
+  weight_init->set_name("weight");
+  weight_init->set_data_type(TensorProto_DataType_FLOAT);
+  weight_init->add_dims(2);
+  weight_init->add_dims(3);
+  for (int i = 0; i < 6; ++i) {
+    weight_init->add_float_data(static_cast<float>(i));
+  }
+
+  // Build subgraph: Identity(weight) -> result.
+  // Unlike the positive test, we add a value_info for "weight" that declares
+  // it as INT64 [2,3] — conflicting with the outer-scope FLOAT type.
+  GraphProto subgraph;
+  subgraph.set_name("body_subgraph");
+
+  // Conflicting value_info: "weight" as INT64 [2,3] instead of FLOAT [2,3].
+  ValueInfoProto* weight_vi = subgraph.add_value_info();
+  weight_vi->set_name("weight");
+  SetTypeAndShape(weight_vi->mutable_type()->mutable_tensor_type(), TensorProto_DataType_INT64, {2, 3});
+
+  // Subgraph output
+  ValueInfoProto* sg_output = subgraph.add_output();
+  sg_output->set_name("result");
+  SetTypeAndShape(sg_output->mutable_type()->mutable_tensor_type(), TensorProto_DataType_FLOAT, {2, 3});
+
+  // Identity node: result = Identity(weight)
+  NodeProto* identity_node = subgraph.add_node();
+  identity_node->set_op_type("Identity");
+  *identity_node->add_input() = "weight";
+  *identity_node->add_output() = "result";
+
+  // FakeSubgraphOp2 node
+  NodeProto* fake_node = main_graph.add_node();
+  fake_node->set_op_type("FakeSubgraphOp2");
+  fake_node->set_domain("FakeTestDomain");
+  fake_node->set_name("fake_subgraph_node");
+  *fake_node->add_input() = "x";
+  *fake_node->add_output() = "y";
+
+  AttributeProto* body_attr = fake_node->add_attribute();
+  body_attr->set_name("body");
+  body_attr->set_type(AttributeProto_AttributeType_GRAPH);
+  *body_attr->mutable_g() = subgraph;
+
+  // Main graph output
+  ValueInfoProto* main_output = main_graph.add_output();
+  main_output->set_name("y");
+  SetTypeAndShape(main_output->mutable_type()->mutable_tensor_type(), TensorProto_DataType_FLOAT, {2, 3});
+
+  // Model::Load must fail because the subgraph declares "weight" as INT64
+  // while the outer-scope initializer is FLOAT.  The strict UpdateTypeAndShape
+  // call in VerifyNodeAndOpMatch returns "Tensor element type mismatch" which
+  // is then wrapped with the subgraph context "[subgraph:body]".
+  std::shared_ptr<Model> model;
+  std::list<std::shared_ptr<IOnnxRuntimeOpSchemaCollection>> regs = {registry};
+  auto status = Model::Load(std::move(model_proto), model, &regs, *logger_);
+  ASSERT_FALSE(status.IsOK());
+  EXPECT_THAT(status.ErrorMessage(), ::testing::HasSubstr("Tensor element type mismatch"));
+  EXPECT_THAT(status.ErrorMessage(), ::testing::HasSubstr("[subgraph:body]"));
+}
+
 }  // namespace test
 }  // namespace onnxruntime