Fix #880: createTreeFromText now finds previously registered subtrees

The issue was that createTreeFromText() and createTreeFromFile() used a
temporary XMLParser that couldn't see subtrees registered via
registerBehaviorTreeFromText() or registerBehaviorTreeFromFile().

This fix changes these methods to use the factory's shared parser
instead, allowing them to resolve references to previously registered
subtrees.

Key changes:
- createTreeFromText/createTreeFromFile now use the shared parser
- Added main tree ID detection to identify which tree to instantiate
- Maintains API and ABI compatibility (no header changes)
- Added regression test for the reported use case

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: facontidavide

src/bt_factory.cpp

@@ -12,6 +12,8 @@
 
 #include "behaviortree_cpp/bt_factory.h"
 
+#include "tinyxml2.h"
+
 #include "behaviortree_cpp/utils/shared_library.h"
 #include "behaviortree_cpp/utils/wildcards.hpp"
 #include "behaviortree_cpp/xml_parsing.h"
@@ -21,6 +23,33 @@
 namespace BT
 {
 
+// Extract the main tree ID from an XML root element.
+// Checks main_tree_to_execute attribute first, then falls back to the
+// single BehaviorTree ID if only one is defined.
+static std::string detectMainTreeId(const tinyxml2::XMLElement* xml_root)
+{
+  if(auto attr = xml_root->Attribute("main_tree_to_execute"))
+  {
+    return attr;
+  }
+  int bt_count = 0;
+  std::string single_id;
+  for(auto* bt = xml_root->FirstChildElement("BehaviorTree"); bt != nullptr;
+      bt = bt->NextSiblingElement("BehaviorTree"))
+  {
+    bt_count++;
+    if(auto* id = bt->Attribute("ID"))
+    {
+      single_id = id;
+    }
+  }
+  if(bt_count == 1 && !single_id.empty())
+  {
+    return single_id;
+  }
+  return {};
+}
+
 bool WildcardMatch(std::string const& str, StringView filter)
 {
   return wildcards_match(str, { filter.data(), filter.size() });
@@ -342,17 +371,59 @@ const std::set<std::string>& BehaviorTreeFactory::builtinNodes() const
 Tree BehaviorTreeFactory::createTreeFromText(const std::string& text,
                                              Blackboard::Ptr blackboard)
 {
-  if(!_p->parser->registeredBehaviorTrees().empty())
+  // Determine the main tree from the XML text before loading into the
+  // shared parser, which may already contain trees from previous
+  // registerBehaviorTreeFrom*() or createTreeFrom*() calls.
+  tinyxml2::XMLDocument doc;
+  doc.Parse(text.c_str(), text.size());
+  std::string main_tree_ID;
+  if(auto* root = doc.RootElement())
+  {
+    main_tree_ID = detectMainTreeId(root);
+  }
+
+  // When the main tree couldn't be determined from the raw XML
+  // (e.g. <BehaviorTree> without an ID), snapshot registered trees
+  // before loading so we can diff afterwards.
+  std::set<std::string> before_set;
+  if(main_tree_ID.empty())
+  {
+    auto before = _p->parser->registeredBehaviorTrees();
+    before_set.insert(before.begin(), before.end());
+  }
+
+  _p->parser->loadFromText(text);
+
+  // Try to identify the newly added tree by diffing.
+  std::string resolved_ID = main_tree_ID;
+  if(resolved_ID.empty())
+  {
+    auto after = _p->parser->registeredBehaviorTrees();
+    std::string single_new_tree;
+    int new_count = 0;
+    for(const auto& name : after)
+    {
+      if(before_set.count(name) == 0)
+      {
+        single_new_tree = name;
+        new_count++;
+      }
+    }
+    if(new_count == 1)
+    {
+      resolved_ID = single_new_tree;
+    }
+  }
+
+  Tree tree;
+  if(resolved_ID.empty())
+  {
+    tree = _p->parser->instantiateTree(blackboard);
+  }
+  else
   {
-    std::cout << "WARNING: You executed BehaviorTreeFactory::createTreeFromText "
-                 "after registerBehaviorTreeFrom[File/Text].\n"
-                 "This is NOT, probably, what you want to do.\n"
-                 "You should probably use BehaviorTreeFactory::createTree, instead"
-              << std::endl;
+    tree = _p->parser->instantiateTree(blackboard, resolved_ID);
   }
-  XMLParser parser(*this);
-  parser.loadFromText(text);
-  auto tree = parser.instantiateTree(blackboard);
   tree.manifests = this->manifests();
   tree.remapManifestPointers();
   return tree;
@@ -361,18 +432,59 @@ Tree BehaviorTreeFactory::createTreeFromText(const std::string& text,
 Tree BehaviorTreeFactory::createTreeFromFile(const std::filesystem::path& file_path,
                                              Blackboard::Ptr blackboard)
 {
-  if(!_p->parser->registeredBehaviorTrees().empty())
+  // Determine the main tree from the file before loading into the
+  // shared parser, which may already contain trees from previous
+  // registerBehaviorTreeFrom*() or createTreeFrom*() calls.
+  tinyxml2::XMLDocument doc;
+  doc.LoadFile(file_path.string().c_str());
+  std::string main_tree_ID;
+  if(auto* root = doc.RootElement())
   {
-    std::cout << "WARNING: You executed BehaviorTreeFactory::createTreeFromFile "
-                 "after registerBehaviorTreeFrom[File/Text].\n"
-                 "This is NOT, probably, what you want to do.\n"
-                 "You should probably use BehaviorTreeFactory::createTree, instead"
-              << std::endl;
+    main_tree_ID = detectMainTreeId(root);
   }
 
-  XMLParser parser(*this);
-  parser.loadFromFile(file_path);
-  auto tree = parser.instantiateTree(blackboard);
+  // When the main tree couldn't be determined from the raw XML
+  // (e.g. <BehaviorTree> without an ID), snapshot registered trees
+  // before loading so we can diff afterwards.
+  std::set<std::string> before_set;
+  if(main_tree_ID.empty())
+  {
+    auto before = _p->parser->registeredBehaviorTrees();
+    before_set.insert(before.begin(), before.end());
+  }
+
+  _p->parser->loadFromFile(file_path);
+
+  // Try to identify the newly added tree by diffing.
+  std::string resolved_ID = main_tree_ID;
+  if(resolved_ID.empty())
+  {
+    auto after = _p->parser->registeredBehaviorTrees();
+    std::string single_new_tree;
+    int new_count = 0;
+    for(const auto& name : after)
+    {
+      if(before_set.count(name) == 0)
+      {
+        single_new_tree = name;
+        new_count++;
+      }
+    }
+    if(new_count == 1)
+    {
+      resolved_ID = single_new_tree;
+    }
+  }
+
+  Tree tree;
+  if(resolved_ID.empty())
+  {
+    tree = _p->parser->instantiateTree(blackboard);
+  }
+  else
+  {
+    tree = _p->parser->instantiateTree(blackboard, resolved_ID);
+  }
   tree.manifests = this->manifests();
   tree.remapManifestPointers();
   return tree;

tests/gtest_factory.cpp

@@ -572,6 +572,41 @@ TEST(BehaviorTreeFactory, FactoryDestroyedBeforeTick)
 // instantiation paths can still overflow the stack with deeply nested
 // input.  The fix adds a depth limit.
 
+// Regression test for issue #880:
+// createTreeFromText should be able to reference subtrees that were
+// previously registered via registerBehaviorTreeFromText/FromFile.
+TEST(BehaviorTreeFactory, CreateTreeFromTextFindsRegisteredSubtree)
+{
+  // Step 1: register a subtree definition
+  const char* subtree_xml = R"(
+  <root BTCPP_format="4">
+    <BehaviorTree ID="MyTree">
+      <AlwaysSuccess/>
+    </BehaviorTree>
+  </root>)";
+
+  BehaviorTreeFactory factory;
+  factory.registerBehaviorTreeFromText(subtree_xml);
+
+  // Verify "MyTree" is registered
+  ASSERT_EQ(factory.registeredBehaviorTrees().size(), 1);
+
+  // Step 2: use createTreeFromText with XML that references the
+  // registered subtree via <SubTree ID="MyTree"/>
+  const char* main_xml = R"(
+  <root BTCPP_format="4">
+    <BehaviorTree ID="TestTree">
+      <SubTree ID="MyTree"/>
+    </BehaviorTree>
+  </root>)";
+
+  // This should NOT throw. Before the fix it throws:
+  //   "Can't find a tree with name: MyTree"
+  Tree tree;
+  ASSERT_NO_THROW(tree = factory.createTreeFromText(main_xml));
+  ASSERT_EQ(NodeStatus::SUCCESS, tree.tickWhileRunning());
+}
+
 TEST(BehaviorTreeFactory, MalformedXML_InvalidRoot)
 {
   // XML that is not valid XML at all