make dot output more compact

source/blender/functions/CMakeLists.txt

@@ -33,6 +33,9 @@ set(SRC
   intern/generic_virtual_vector_array.cc
   intern/multi_function.cc
   intern/multi_function_builder.cc
+  intern/multi_function_procedure.cc
+  intern/multi_function_procedure_builder.cc
+  intern/multi_function_procedure_executor.cc
 
   FN_cpp_type.hh
   FN_cpp_type_make.hh
@@ -48,6 +51,9 @@ set(SRC
   FN_multi_function_data_type.hh
   FN_multi_function_param_type.hh
   FN_multi_function_params.hh
+  FN_multi_function_procedure.hh
+  FN_multi_function_procedure_builder.hh
+  FN_multi_function_procedure_executor.hh
   FN_multi_function_signature.hh
 )
 
@@ -62,6 +68,7 @@ if(WITH_GTESTS)
     tests/FN_cpp_type_test.cc
     tests/FN_generic_span_test.cc
     tests/FN_generic_vector_array_test.cc
+    tests/FN_multi_function_procedure_test.cc
     tests/FN_multi_function_test.cc
   )
   set(TEST_LIB

source/blender/functions/FN_multi_function_procedure.hh

@@ -0,0 +1,408 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#pragma once
+
+/** \file
+ * \ingroup fn
+ */
+
+#include "FN_multi_function.hh"
+
+namespace blender::fn {
+
+class MFVariable;
+class MFInstruction;
+class MFCallInstruction;
+class MFBranchInstruction;
+class MFDestructInstruction;
+class MFDummyInstruction;
+class MFReturnInstruction;
+class MFProcedure;
+
+enum class MFInstructionType {
+  Call,
+  Branch,
+  Destruct,
+  Dummy,
+  Return,
+};
+
+class MFVariable : NonCopyable, NonMovable {
+ private:
+  MFDataType data_type_;
+  Vector<MFInstruction *> users_;
+  std::string name_;
+  int id_;
+
+  friend MFProcedure;
+  friend MFCallInstruction;
+  friend MFBranchInstruction;
+  friend MFDestructInstruction;
+
+ public:
+  MFDataType data_type() const;
+  Span<MFInstruction *> users();
+
+  StringRefNull name() const;
+  void set_name(std::string name);
+
+  int id() const;
+};
+
+class MFInstruction : NonCopyable, NonMovable {
+ protected:
+  MFInstructionType type_;
+  Vector<MFInstruction *> prev_;
+
+  friend MFProcedure;
+  friend MFCallInstruction;
+  friend MFBranchInstruction;
+  friend MFDestructInstruction;
+  friend MFDummyInstruction;
+  friend MFReturnInstruction;
+
+ public:
+  MFInstructionType type() const;
+  Span<MFInstruction *> prev();
+  Span<const MFInstruction *> prev() const;
+};
+
+class MFCallInstruction : public MFInstruction {
+ private:
+  const MultiFunction *fn_ = nullptr;
+  MFInstruction *next_ = nullptr;
+  MutableSpan<MFVariable *> params_;
+
+  friend MFProcedure;
+
+ public:
+  const MultiFunction &fn() const;
+
+  MFInstruction *next();
+  const MFInstruction *next() const;
+  void set_next(MFInstruction *instruction);
+
+  void set_param_variable(int param_index, MFVariable *variable);
+  void set_params(Span<MFVariable *> variables);
+  Span<MFVariable *> params();
+  Span<const MFVariable *> params() const;
+};
+
+class MFBranchInstruction : public MFInstruction {
+ private:
+  MFVariable *condition_ = nullptr;
+  MFInstruction *branch_true_ = nullptr;
+  MFInstruction *branch_false_ = nullptr;
+
+  friend MFProcedure;
+
+ public:
+  MFVariable *condition();
+  const MFVariable *condition() const;
+  void set_condition(MFVariable *variable);
+
+  MFInstruction *branch_true();
+  const MFInstruction *branch_true() const;
+  void set_branch_true(MFInstruction *instruction);
+
+  MFInstruction *branch_false();
+  const MFInstruction *branch_false() const;
+  void set_branch_false(MFInstruction *instruction);
+};
+
+class MFDestructInstruction : public MFInstruction {
+ private:
+  MFVariable *variable_ = nullptr;
+  MFInstruction *next_ = nullptr;
+
+  friend MFProcedure;
+
+ public:
+  MFVariable *variable();
+  const MFVariable *variable() const;
+  void set_variable(MFVariable *variable);
+
+  MFInstruction *next();
+  const MFInstruction *next() const;
+  void set_next(MFInstruction *instruction);
+};
+
+class MFDummyInstruction : public MFInstruction {
+ private:
+  MFInstruction *next_ = nullptr;
+
+  friend MFProcedure;
+
+ public:
+  MFInstruction *next();
+  const MFInstruction *next() const;
+  void set_next(MFInstruction *instruction);
+};
+
+class MFReturnInstruction : public MFInstruction {
+};
+
+struct MFParameter {
+  MFParamType::InterfaceType type;
+  MFVariable *variable;
+};
+
+struct ConstMFParameter {
+  MFParamType::InterfaceType type;
+  const MFVariable *variable;
+};
+
+class MFProcedure : NonCopyable, NonMovable {
+ private:
+  LinearAllocator<> allocator_;
+  Vector<MFCallInstruction *> call_instructions_;
+  Vector<MFBranchInstruction *> branch_instructions_;
+  Vector<MFDestructInstruction *> destruct_instructions_;
+  Vector<MFDummyInstruction *> dummy_instructions_;
+  Vector<MFReturnInstruction *> return_instructions_;
+  Vector<MFVariable *> variables_;
+  Vector<MFParameter> params_;
+  MFInstruction *entry_ = nullptr;
+
+ public:
+  MFProcedure() = default;
+  ~MFProcedure();
+
+  MFVariable &new_variable(MFDataType data_type, std::string name = "");
+  MFCallInstruction &new_call_instruction(const MultiFunction &fn);
+  MFBranchInstruction &new_branch_instruction();
+  MFDestructInstruction &new_destruct_instruction();
+  MFDummyInstruction &new_dummy_instruction();
+  MFReturnInstruction &new_return_instruction();
+
+  void add_parameter(MFParamType::InterfaceType interface_type, MFVariable &variable);
+
+  Span<ConstMFParameter> params() const;
+
+  MFInstruction *entry();
+  const MFInstruction *entry() const;
+  void set_entry(MFInstruction &entry);
+
+  Span<MFVariable *> variables();
+  Span<const MFVariable *> variables() const;
+
+  void assert_valid() const;
+
+  std::string to_dot() const;
+
+  bool validate() const;
+
+ private:
+  bool validate_all_instruction_pointers_set() const;
+  bool validate_all_params_provided() const;
+  bool validate_same_variables_in_one_call() const;
+  bool validate_parameters() const;
+  bool validate_initialization() const;
+
+  struct InitState {
+    bool can_be_initialized = false;
+    bool can_be_uninitialized = false;
+  };
+
+  InitState find_initialization_state_before_instruction(const MFInstruction &target_instruction,
+                                                         const MFVariable &variable) const;
+};
+
+namespace multi_function_procedure_types {
+using MFVariable = fn::MFVariable;
+using MFInstruction = fn::MFInstruction;
+using MFCallInstruction = fn::MFCallInstruction;
+using MFBranchInstruction = fn::MFBranchInstruction;
+using MFDestructInstruction = fn::MFDestructInstruction;
+using MFProcedure = fn::MFProcedure;
+}  // namespace multi_function_procedure_types
+
+/* --------------------------------------------------------------------
+ * MFVariable inline methods.
+ */
+
+inline MFDataType MFVariable::data_type() const
+{
+  return data_type_;
+}
+
+inline Span<MFInstruction *> MFVariable::users()
+{
+  return users_;
+}
+
+inline StringRefNull MFVariable::name() const
+{
+  return name_;
+}
+
+inline int MFVariable::id() const
+{
+  return id_;
+}
+
+/* --------------------------------------------------------------------
+ * MFInstruction inline methods.
+ */
+
+inline MFInstructionType MFInstruction::type() const
+{
+  return type_;
+}
+
+inline Span<MFInstruction *> MFInstruction::prev()
+{
+  return prev_;
+}
+
+inline Span<const MFInstruction *> MFInstruction::prev() const
+{
+  return prev_;
+}
+
+/* --------------------------------------------------------------------
+ * MFCallInstruction inline methods.
+ */
+
+inline const MultiFunction &MFCallInstruction::fn() const
+{
+  return *fn_;
+}
+
+inline MFInstruction *MFCallInstruction::next()
+{
+  return next_;
+}
+
+inline const MFInstruction *MFCallInstruction::next() const
+{
+  return next_;
+}
+
+inline Span<MFVariable *> MFCallInstruction::params()
+{
+  return params_;
+}
+
+inline Span<const MFVariable *> MFCallInstruction::params() const
+{
+  return params_;
+}
+
+/* --------------------------------------------------------------------
+ * MFBranchInstruction inline methods.
+ */
+
+inline MFVariable *MFBranchInstruction::condition()
+{
+  return condition_;
+}
+
+inline const MFVariable *MFBranchInstruction::condition() const
+{
+  return condition_;
+}
+
+inline MFInstruction *MFBranchInstruction::branch_true()
+{
+  return branch_true_;
+}
+
+inline const MFInstruction *MFBranchInstruction::branch_true() const
+{
+  return branch_true_;
+}
+
+inline MFInstruction *MFBranchInstruction::branch_false()
+{
+  return branch_false_;
+}
+
+inline const MFInstruction *MFBranchInstruction::branch_false() const
+{
+  return branch_false_;
+}
+
+/* --------------------------------------------------------------------
+ * MFDestructInstruction inline methods.
+ */
+
+inline MFVariable *MFDestructInstruction::variable()
+{
+  return variable_;
+}
+
+inline const MFVariable *MFDestructInstruction::variable() const
+{
+  return variable_;
+}
+
+inline MFInstruction *MFDestructInstruction::next()
+{
+  return next_;
+}
+
+inline const MFInstruction *MFDestructInstruction::next() const
+{
+  return next_;
+}
+
+/* --------------------------------------------------------------------
+ * MFDummyInstruction inline methods.
+ */
+
+inline MFInstruction *MFDummyInstruction::next()
+{
+  return next_;
+}
+
+inline const MFInstruction *MFDummyInstruction::next() const
+{
+  return next_;
+}
+
+/* --------------------------------------------------------------------
+ * MFProcedure inline methods.
+ */
+
+inline Span<ConstMFParameter> MFProcedure::params() const
+{
+  static_assert(sizeof(MFParameter) == sizeof(ConstMFParameter));
+  return params_.as_span().cast<ConstMFParameter>();
+}
+
+inline MFInstruction *MFProcedure::entry()
+{
+  return entry_;
+}
+
+inline const MFInstruction *MFProcedure::entry() const
+{
+  return entry_;
+}
+
+inline Span<MFVariable *> MFProcedure::variables()
+{
+  return variables_;
+}
+
+inline Span<const MFVariable *> MFProcedure::variables() const
+{
+  return variables_;
+}
+
+}  // namespace blender::fn

source/blender/functions/FN_multi_function_procedure_builder.hh

@@ -0,0 +1,251 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#pragma once
+
+/** \file
+ * \ingroup fn
+ */
+
+#include "FN_multi_function_procedure.hh"
+
+namespace blender::fn {
+
+class MFInstructionCursor {
+ private:
+  MFInstruction *instruction_ = nullptr;
+  /* Only used when it is a branch instruction. */
+  bool branch_output_ = false;
+  /* Only used when instruction is null. */
+  bool is_entry_ = false;
+
+ public:
+  MFInstructionCursor() = default;
+
+  MFInstructionCursor(MFCallInstruction &instruction);
+  MFInstructionCursor(MFDestructInstruction &instruction);
+  MFInstructionCursor(MFBranchInstruction &instruction, bool branch_output);
+  MFInstructionCursor(MFDummyInstruction &instruction);
+
+  static MFInstructionCursor Entry();
+
+  void insert(MFProcedure &procedure, MFInstruction *new_instruction);
+};
+
+class MFProcedureBuilder {
+ private:
+  MFProcedure *procedure_ = nullptr;
+  Vector<MFInstructionCursor> cursors_;
+
+ public:
+  struct Branch;
+  struct Loop;
+
+  MFProcedureBuilder(MFProcedure &procedure,
+                     MFInstructionCursor initial_cursor = MFInstructionCursor::Entry());
+
+  MFProcedureBuilder(Span<MFProcedureBuilder *> builders);
+
+  MFProcedureBuilder(Branch &branch);
+
+  void set_cursor(const MFInstructionCursor &cursor);
+  void set_cursor(Span<MFInstructionCursor> cursors);
+  void set_cursor(Span<MFProcedureBuilder *> builders);
+  void set_cursor_after_branch(Branch &branch);
+  void set_cursor_after_loop(Loop &loop);
+
+  void add_destruct(MFVariable &variable);
+  void add_destruct(Span<MFVariable *> variables);
+
+  MFReturnInstruction &add_return();
+
+  Branch add_branch(MFVariable &condition);
+
+  Loop add_loop();
+  void add_loop_continue(Loop &loop);
+  void add_loop_break(Loop &loop);
+
+  MFCallInstruction &add_call_with_no_variables(const MultiFunction &fn);
+  MFCallInstruction &add_call_with_all_variables(const MultiFunction &fn,
+                                                 Span<MFVariable *> param_variables);
+
+  Vector<MFVariable *> add_call(const MultiFunction &fn,
+                                Span<MFVariable *> input_and_mutable_variables = {});
+
+  template<int OutputN>
+  std::array<MFVariable *, OutputN> add_call(const MultiFunction &fn,
+                                             Span<MFVariable *> input_and_mutable_variables = {});
+
+  void add_parameter(MFParamType::InterfaceType interface_type, MFVariable &variable);
+  MFVariable &add_parameter(MFParamType param_type, std::string name = "");
+
+  MFVariable &add_input_parameter(MFDataType data_type, std::string name = "");
+  template<typename T> MFVariable &add_single_input_parameter(std::string name = "");
+  template<typename T> MFVariable &add_single_mutable_parameter(std::string name = "");
+
+  void add_output_parameter(MFVariable &variable);
+
+ private:
+  void link_to_cursors(MFInstruction *instruction);
+};
+
+struct MFProcedureBuilder::Branch {
+  MFProcedureBuilder branch_true;
+  MFProcedureBuilder branch_false;
+};
+
+struct MFProcedureBuilder::Loop {
+  MFInstruction *begin = nullptr;
+  MFDummyInstruction *end = nullptr;
+};
+
+/* --------------------------------------------------------------------
+ * MFInstructionCursor inline methods.
+ */
+
+inline MFInstructionCursor::MFInstructionCursor(MFCallInstruction &instruction)
+    : instruction_(&instruction)
+{
+}
+
+inline MFInstructionCursor::MFInstructionCursor(MFDestructInstruction &instruction)
+    : instruction_(&instruction)
+{
+}
+
+inline MFInstructionCursor::MFInstructionCursor(MFBranchInstruction &instruction,
+                                                bool branch_output)
+    : instruction_(&instruction), branch_output_(branch_output)
+{
+}
+
+inline MFInstructionCursor::MFInstructionCursor(MFDummyInstruction &instruction)
+    : instruction_(&instruction)
+{
+}
+
+inline MFInstructionCursor MFInstructionCursor::Entry()
+{
+  MFInstructionCursor cursor;
+  cursor.is_entry_ = true;
+  return cursor;
+}
+
+/* --------------------------------------------------------------------
+ * MFProcedureBuilder inline methods.
+ */
+
+inline MFProcedureBuilder::MFProcedureBuilder(Branch &branch)
+    : MFProcedureBuilder(*branch.branch_true.procedure_)
+{
+  this->set_cursor_after_branch(branch);
+}
+
+inline MFProcedureBuilder::MFProcedureBuilder(MFProcedure &procedure,
+                                              MFInstructionCursor initial_cursor)
+    : procedure_(&procedure), cursors_({initial_cursor})
+{
+}
+
+inline MFProcedureBuilder::MFProcedureBuilder(Span<MFProcedureBuilder *> builders)
+    : MFProcedureBuilder(*builders[0]->procedure_)
+{
+  this->set_cursor(builders);
+}
+
+inline void MFProcedureBuilder::set_cursor(const MFInstructionCursor &cursor)
+{
+  cursors_ = {cursor};
+}
+
+inline void MFProcedureBuilder::set_cursor(Span<MFInstructionCursor> cursors)
+{
+  cursors_ = cursors;
+}
+
+inline void MFProcedureBuilder::set_cursor_after_branch(Branch &branch)
+{
+  this->set_cursor({&branch.branch_false, &branch.branch_true});
+}
+
+inline void MFProcedureBuilder::set_cursor_after_loop(Loop &loop)
+{
+  this->set_cursor(MFInstructionCursor{*loop.end});
+}
+
+inline void MFProcedureBuilder::set_cursor(Span<MFProcedureBuilder *> builders)
+{
+  cursors_.clear();
+  for (MFProcedureBuilder *builder : builders) {
+    cursors_.extend(builder->cursors_);
+  }
+}
+
+template<int OutputN>
+inline std::array<MFVariable *, OutputN> MFProcedureBuilder::add_call(
+    const MultiFunction &fn, Span<MFVariable *> input_and_mutable_variables)
+{
+  Vector<MFVariable *> output_variables = this->add_call(fn, input_and_mutable_variables);
+  BLI_assert(output_variables.size() == OutputN);
+
+  std::array<MFVariable *, OutputN> output_array;
+  initialized_copy_n(output_variables.data(), OutputN, output_array.data());
+  return output_array;
+}
+
+inline void MFProcedureBuilder::add_parameter(MFParamType::InterfaceType interface_type,
+                                              MFVariable &variable)
+{
+  procedure_->add_parameter(interface_type, variable);
+}
+
+inline MFVariable &MFProcedureBuilder::add_parameter(MFParamType param_type, std::string name)
+{
+  MFVariable &variable = procedure_->new_variable(param_type.data_type(), std::move(name));
+  this->add_parameter(param_type.interface_type(), variable);
+  return variable;
+}
+
+inline MFVariable &MFProcedureBuilder::add_input_parameter(MFDataType data_type, std::string name)
+{
+  return this->add_parameter(MFParamType(MFParamType::Input, data_type), std::move(name));
+}
+
+template<typename T>
+inline MFVariable &MFProcedureBuilder::add_single_input_parameter(std::string name)
+{
+  return this->add_parameter(MFParamType::ForSingleInput(CPPType::get<T>()), std::move(name));
+}
+
+template<typename T>
+inline MFVariable &MFProcedureBuilder::add_single_mutable_parameter(std::string name)
+{
+  return this->add_parameter(MFParamType::ForMutableSingle(CPPType::get<T>()), std::move(name));
+}
+
+inline void MFProcedureBuilder::add_output_parameter(MFVariable &variable)
+{
+  this->add_parameter(MFParamType::Output, variable);
+}
+
+inline void MFProcedureBuilder::link_to_cursors(MFInstruction *instruction)
+{
+  for (MFInstructionCursor &cursor : cursors_) {
+    cursor.insert(*procedure_, instruction);
+  }
+}
+
+}  // namespace blender::fn

source/blender/functions/FN_multi_function_procedure_executor.hh

@@ -0,0 +1,38 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#pragma once
+
+/** \file
+ * \ingroup fn
+ */
+
+#include "FN_multi_function_procedure.hh"
+
+namespace blender::fn {
+
+class MFProcedureExecutor : public MultiFunction {
+ private:
+  MFSignature signature_;
+  const MFProcedure &procedure_;
+
+ public:
+  MFProcedureExecutor(std::string name, const MFProcedure &procedure);
+
+  void call(IndexMask mask, MFParams params, MFContext context) const override;
+};
+
+}  // namespace blender::fn

source/blender/functions/intern/multi_function_procedure.cc

@@ -0,0 +1,743 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#include "FN_multi_function_procedure.hh"
+
+#include "BLI_dot_export.hh"
+#include "BLI_stack.hh"
+
+namespace blender::fn {
+
+void MFVariable::set_name(std::string name)
+{
+  name_ = std::move(name);
+}
+
+void MFCallInstruction::set_next(MFInstruction *instruction)
+{
+  if (next_ != nullptr) {
+    next_->prev_.remove_first_occurrence_and_reorder(this);
+  }
+  if (instruction != nullptr) {
+    instruction->prev_.append(this);
+  }
+  next_ = instruction;
+}
+
+void MFCallInstruction::set_param_variable(int param_index, MFVariable *variable)
+{
+  if (params_[param_index] != nullptr) {
+    params_[param_index]->users_.remove_first_occurrence_and_reorder(this);
+  }
+  if (variable != nullptr) {
+    BLI_assert(fn_->param_type(param_index).data_type() == variable->data_type());
+    variable->users_.append(this);
+  }
+  params_[param_index] = variable;
+}
+
+void MFCallInstruction::set_params(Span<MFVariable *> variables)
+{
+  BLI_assert(variables.size() == params_.size());
+  for (const int i : variables.index_range()) {
+    this->set_param_variable(i, variables[i]);
+  }
+}
+
+void MFBranchInstruction::set_condition(MFVariable *variable)
+{
+  if (condition_ != nullptr) {
+    condition_->users_.remove_first_occurrence_and_reorder(this);
+  }
+  if (variable != nullptr) {
+    variable->users_.append(this);
+  }
+  condition_ = variable;
+}
+
+void MFBranchInstruction::set_branch_true(MFInstruction *instruction)
+{
+  if (branch_true_ != nullptr) {
+    branch_true_->prev_.remove_first_occurrence_and_reorder(this);
+  }
+  if (instruction != nullptr) {
+    instruction->prev_.append(this);
+  }
+  branch_true_ = instruction;
+}
+
+void MFBranchInstruction::set_branch_false(MFInstruction *instruction)
+{
+  if (branch_false_ != nullptr) {
+    branch_false_->prev_.remove_first_occurrence_and_reorder(this);
+  }
+  if (instruction != nullptr) {
+    instruction->prev_.append(this);
+  }
+  branch_false_ = instruction;
+}
+
+void MFDestructInstruction::set_variable(MFVariable *variable)
+{
+  if (variable_ != nullptr) {
+    variable_->users_.remove_first_occurrence_and_reorder(this);
+  }
+  if (variable != nullptr) {
+    variable->users_.append(this);
+  }
+  variable_ = variable;
+}
+
+void MFDestructInstruction::set_next(MFInstruction *instruction)
+{
+  if (next_ != nullptr) {
+    next_->prev_.remove_first_occurrence_and_reorder(this);
+  }
+  if (instruction != nullptr) {
+    instruction->prev_.append(this);
+  }
+  next_ = instruction;
+}
+
+void MFDummyInstruction::set_next(MFInstruction *instruction)
+{
+  if (next_ != nullptr) {
+    next_->prev_.remove_first_occurrence_and_reorder(this);
+  }
+  if (instruction != nullptr) {
+    instruction->prev_.append(this);
+  }
+  next_ = instruction;
+}
+
+MFVariable &MFProcedure::new_variable(MFDataType data_type, std::string name)
+{
+  MFVariable &variable = *allocator_.construct<MFVariable>().release();
+  variable.name_ = std::move(name);
+  variable.data_type_ = data_type;
+  variable.id_ = variables_.size();
+  variables_.append(&variable);
+  return variable;
+}
+
+MFCallInstruction &MFProcedure::new_call_instruction(const MultiFunction &fn)
+{
+  MFCallInstruction &instruction = *allocator_.construct<MFCallInstruction>().release();
+  instruction.type_ = MFInstructionType::Call;
+  instruction.fn_ = &fn;
+  instruction.params_ = allocator_.allocate_array<MFVariable *>(fn.param_amount());
+  instruction.params_.fill(nullptr);
+  call_instructions_.append(&instruction);
+  return instruction;
+}
+
+MFBranchInstruction &MFProcedure::new_branch_instruction()
+{
+  MFBranchInstruction &instruction = *allocator_.construct<MFBranchInstruction>().release();
+  instruction.type_ = MFInstructionType::Branch;
+  branch_instructions_.append(&instruction);
+  return instruction;
+}
+
+MFDestructInstruction &MFProcedure::new_destruct_instruction()
+{
+  MFDestructInstruction &instruction = *allocator_.construct<MFDestructInstruction>().release();
+  instruction.type_ = MFInstructionType::Destruct;
+  destruct_instructions_.append(&instruction);
+  return instruction;
+}
+
+MFDummyInstruction &MFProcedure::new_dummy_instruction()
+{
+  MFDummyInstruction &instruction = *allocator_.construct<MFDummyInstruction>().release();
+  instruction.type_ = MFInstructionType::Dummy;
+  dummy_instructions_.append(&instruction);
+  return instruction;
+}
+
+MFReturnInstruction &MFProcedure::new_return_instruction()
+{
+  MFReturnInstruction &instruction = *allocator_.construct<MFReturnInstruction>().release();
+  instruction.type_ = MFInstructionType::Return;
+  return_instructions_.append(&instruction);
+  return instruction;
+}
+
+void MFProcedure::add_parameter(MFParamType::InterfaceType interface_type, MFVariable &variable)
+{
+  params_.append({interface_type, &variable});
+}
+
+void MFProcedure::set_entry(MFInstruction &entry)
+{
+  entry_ = &entry;
+}
+
+void MFProcedure::assert_valid() const
+{
+  /**
+   * - Non parameter variables are destructed.
+   * - At every instruction, every variable is either initialized or uninitialized.
+   * - Input and mutable parameters of call instructions are initialized.
+   * - Condition of branch instruction is initialized.
+   * - Output parameters of call instructions are not initialized.
+   * - Input parameters are never destructed.
+   * - Mutable and output parameteres are initialized on every exit.
+   * - No aliasing issues in call instructions (can happen when variable is used more than once).
+   */
+}
+
+MFProcedure::~MFProcedure()
+{
+  for (MFCallInstruction *instruction : call_instructions_) {
+    instruction->~MFCallInstruction();
+  }
+  for (MFBranchInstruction *instruction : branch_instructions_) {
+    instruction->~MFBranchInstruction();
+  }
+  for (MFDestructInstruction *instruction : destruct_instructions_) {
+    instruction->~MFDestructInstruction();
+  }
+  for (MFDummyInstruction *instruction : dummy_instructions_) {
+    instruction->~MFDummyInstruction();
+  }
+  for (MFReturnInstruction *instruction : return_instructions_) {
+    instruction->~MFReturnInstruction();
+  }
+  for (MFVariable *variable : variables_) {
+    variable->~MFVariable();
+  }
+}
+
+bool MFProcedure::validate() const
+{
+  if (entry_ == nullptr) {
+    return false;
+  }
+  if (!this->validate_all_instruction_pointers_set()) {
+    return false;
+  }
+  if (!this->validate_all_params_provided()) {
+    return false;
+  }
+  if (!this->validate_same_variables_in_one_call()) {
+    return false;
+  }
+  if (!this->validate_parameters()) {
+    return false;
+  }
+  if (!this->validate_initialization()) {
+    return false;
+  }
+  return true;
+}
+
+bool MFProcedure::validate_all_instruction_pointers_set() const
+{
+  for (const MFCallInstruction *instruction : call_instructions_) {
+    if (instruction->next_ == nullptr) {
+      return false;
+    }
+  }
+  for (const MFDestructInstruction *instruction : destruct_instructions_) {
+    if (instruction->next_ == nullptr) {
+      return false;
+    }
+  }
+  for (const MFBranchInstruction *instruction : branch_instructions_) {
+    if (instruction->branch_true_ == nullptr) {
+      return false;
+    }
+    if (instruction->branch_false_ == nullptr) {
+      return false;
+    }
+  }
+  for (const MFDummyInstruction *instruction : dummy_instructions_) {
+    if (instruction->next_ == nullptr) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool MFProcedure::validate_all_params_provided() const
+{
+  for (const MFCallInstruction *instruction : call_instructions_) {
+    for (const MFVariable *variable : instruction->params_) {
+      if (variable == nullptr) {
+        return false;
+      }
+    }
+  }
+  for (const MFBranchInstruction *instruction : branch_instructions_) {
+    if (instruction->condition_ == nullptr) {
+      return false;
+    }
+  }
+  for (const MFDestructInstruction *instruction : destruct_instructions_) {
+    if (instruction->variable_ == nullptr) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool MFProcedure::validate_same_variables_in_one_call() const
+{
+  for (const MFCallInstruction *instruction : call_instructions_) {
+    const MultiFunction &fn = *instruction->fn_;
+    for (const int param_index : fn.param_indices()) {
+      const MFParamType param_type = fn.param_type(param_index);
+      const MFVariable *variable = instruction->params_[param_index];
+      for (const int other_param_index : fn.param_indices()) {
+        if (other_param_index == param_index) {
+          continue;
+        }
+        const MFVariable *other_variable = instruction->params_[other_param_index];
+        if (other_variable != variable) {
+          continue;
+        }
+        if (ELEM(param_type.interface_type(), MFParamType::Mutable, MFParamType::Output)) {
+          /* When a variable is used as mutable or output parameter, it can only be used once. */
+          return false;
+        }
+        const MFParamType other_param_type = fn.param_type(other_param_index);
+        /* A variable is allowed to be used as input more than once. */
+        if (other_param_type.interface_type() != MFParamType::Input) {
+          return false;
+        }
+      }
+    }
+  }
+  return true;
+}
+
+bool MFProcedure::validate_parameters() const
+{
+  Set<const MFVariable *> variables;
+  for (const MFParameter &param : params_) {
+    /* One variable cannot be used as multiple parameters. */
+    if (!variables.add(param.variable)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool MFProcedure::validate_initialization() const
+{
+  /* TODO: Issue warning when it maybe wrongly initialized. */
+  for (const MFDestructInstruction *instruction : destruct_instructions_) {
+    const MFVariable &variable = *instruction->variable_;
+    const InitState state = this->find_initialization_state_before_instruction(*instruction,
+                                                                               variable);
+    if (!state.can_be_initialized) {
+      return false;
+    }
+  }
+  for (const MFBranchInstruction *instruction : branch_instructions_) {
+    const MFVariable &variable = *instruction->condition_;
+    const InitState state = this->find_initialization_state_before_instruction(*instruction,
+                                                                               variable);
+    if (!state.can_be_initialized) {
+      return false;
+    }
+  }
+  for (const MFCallInstruction *instruction : call_instructions_) {
+    const MultiFunction &fn = *instruction->fn_;
+    for (const int param_index : fn.param_indices()) {
+      const MFParamType param_type = fn.param_type(param_index);
+      const MFVariable &variable = *instruction->params_[param_index];
+      const InitState state = this->find_initialization_state_before_instruction(*instruction,
+                                                                                 variable);
+      switch (param_type.interface_type()) {
+        case MFParamType::Input:
+        case MFParamType::Mutable: {
+          if (!state.can_be_initialized) {
+            return false;
+          }
+          break;
+        }
+        case MFParamType::Output: {
+          if (!state.can_be_uninitialized) {
+            return false;
+          }
+          break;
+        }
+      }
+    }
+  }
+  Set<const MFVariable *> variables_that_should_be_initialized_on_return;
+  for (const MFParameter &param : params_) {
+    if (ELEM(param.type, MFParamType::Mutable, MFParamType::Output)) {
+      variables_that_should_be_initialized_on_return.add_new(param.variable);
+    }
+  }
+  for (const MFReturnInstruction *instruction : return_instructions_) {
+    for (const MFVariable *variable : variables_) {
+      const InitState init_state = this->find_initialization_state_before_instruction(*instruction,
+                                                                                      *variable);
+      if (variables_that_should_be_initialized_on_return.contains(variable)) {
+        if (!init_state.can_be_initialized) {
+          return false;
+        }
+      }
+      else {
+        if (!init_state.can_be_uninitialized) {
+          return false;
+        }
+      }
+    }
+  }
+  return true;
+}
+
+MFProcedure::InitState MFProcedure::find_initialization_state_before_instruction(
+    const MFInstruction &target_instruction, const MFVariable &target_variable) const
+{
+  InitState state;
+
+  auto check_entry_instruction = [&]() {
+    bool caller_initialized_variable = false;
+    for (const MFParameter &param : params_) {
+      if (param.variable == &target_variable) {
+        if (ELEM(param.type, MFParamType::Input, MFParamType::Mutable)) {
+          caller_initialized_variable = true;
+          break;
+        }
+      }
+    }
+    if (caller_initialized_variable) {
+      state.can_be_initialized = true;
+    }
+    else {
+      state.can_be_uninitialized = true;
+    }
+  };
+
+  if (&target_instruction == entry_) {
+    check_entry_instruction();
+  }
+
+  Set<const MFInstruction *> checked_instructions;
+  Stack<const MFInstruction *> instructions_to_check;
+  instructions_to_check.push_multiple(target_instruction.prev_);
+
+  while (!instructions_to_check.is_empty()) {
+    const MFInstruction &instruction = *instructions_to_check.pop();
+    if (!checked_instructions.add(&instruction)) {
+      /* Skip if the instruction has been checked already. */
+      continue;
+    }
+    bool state_modified = false;
+    switch (instruction.type_) {
+      case MFInstructionType::Call: {
+        const MFCallInstruction &call_instruction = static_cast<const MFCallInstruction &>(
+            instruction);
+        const MultiFunction &fn = *call_instruction.fn_;
+        for (const int param_index : fn.param_indices()) {
+          if (call_instruction.params_[param_index] == &target_variable) {
+            const MFParamType param_type = fn.param_type(param_index);
+            if (param_type.interface_type() == MFParamType::Output) {
+              state.can_be_initialized = true;
+              state_modified = true;
+              break;
+            }
+          }
+        }
+        break;
+      }
+      case MFInstructionType::Destruct: {
+        const MFDestructInstruction &destruct_instruction =
+            static_cast<const MFDestructInstruction &>(instruction);
+        if (destruct_instruction.variable_ == &target_variable) {
+          state.can_be_uninitialized = true;
+          state_modified = true;
+        }
+        break;
+      }
+      case MFInstructionType::Branch:
+      case MFInstructionType::Dummy:
+      case MFInstructionType::Return: {
+        /* These instruction types don't change the initialization state of variables. */
+        break;
+      }
+    }
+
+    if (!state_modified) {
+      if (&instruction == entry_) {
+        check_entry_instruction();
+      }
+      instructions_to_check.push_multiple(instruction.prev_);
+    }
+  }
+
+  return state;
+}
+
+static bool has_to_be_block_begin(const MFProcedure &procedure, const MFInstruction &instruction)
+{
+  if (procedure.entry() == &instruction) {
+    return true;
+  }
+  if (instruction.prev().size() != 1) {
+    return true;
+  }
+  if (instruction.prev()[0]->type() == MFInstructionType::Branch) {
+    return true;
+  }
+  return false;
+}
+
+static const MFInstruction &get_first_instruction_in_block(const MFProcedure &procedure,
+                                                           const MFInstruction &representative)
+{
+  const MFInstruction *current = &representative;
+  while (!has_to_be_block_begin(procedure, *current)) {
+    current = current->prev()[0];
+    if (current == &representative) {
+      /* There is a loop without entry or exit, just break it up here. */
+      break;
+    }
+  }
+  return *current;
+}
+
+static const MFInstruction *get_next_instruction_in_block(const MFProcedure &procedure,
+                                                          const MFInstruction &instruction,
+                                                          const MFInstruction &block_begin)
+{
+  const MFInstruction *next = nullptr;
+  switch (instruction.type()) {
+    case MFInstructionType::Call: {
+      next = static_cast<const MFCallInstruction &>(instruction).next();
+      break;
+    }
+    case MFInstructionType::Destruct: {
+      next = static_cast<const MFDestructInstruction &>(instruction).next();
+      break;
+    }
+    case MFInstructionType::Dummy: {
+      next = static_cast<const MFDummyInstruction &>(instruction).next();
+      break;
+    }
+    case MFInstructionType::Return:
+    case MFInstructionType::Branch: {
+      break;
+    }
+  }
+  if (next == nullptr) {
+    return nullptr;
+  }
+  if (next == &block_begin) {
+    return nullptr;
+  }
+  if (has_to_be_block_begin(procedure, *next)) {
+    return nullptr;
+  }
+  return next;
+}
+
+static Vector<const MFInstruction *> get_instructions_in_block(const MFProcedure &procedure,
+                                                               const MFInstruction &representative)
+{
+  Vector<const MFInstruction *> instructions;
+  const MFInstruction &begin = get_first_instruction_in_block(procedure, representative);
+  for (const MFInstruction *current = &begin; current != nullptr;
+       current = get_next_instruction_in_block(procedure, *current, begin)) {
+    instructions.append(current);
+  }
+  return instructions;
+}
+
+static void variable_to_string(const MFVariable *variable, std::stringstream &ss)
+{
+  if (variable == nullptr) {
+    ss << "<none>";
+  }
+  else {
+    ss << "$" << variable->id();
+    if (!variable->name().is_empty()) {
+      ss << "(" << variable->name() << ")";
+    }
+  }
+}
+
+static void instruction_to_string(const MFCallInstruction &instruction, std::stringstream &ss)
+{
+  const MultiFunction &fn = instruction.fn();
+  ss << fn.name() << " - ";
+  for (const int param_index : fn.param_indices()) {
+    const MFParamType param_type = fn.param_type(param_index);
+    const MFVariable *variable = instruction.params()[param_index];
+    switch (param_type.interface_type()) {
+      case MFParamType::Input: {
+        ss << "in";
+        break;
+      }
+      case MFParamType::Mutable: {
+        ss << "mut";
+        break;
+      }
+      case MFParamType::Output: {
+        ss << "out";
+        break;
+      }
+    }
+    ss << " ";
+    variable_to_string(variable, ss);
+    if (param_index < fn.param_amount() - 1) {
+      ss << ", ";
+    }
+  }
+}
+
+static void instruction_to_string(const MFDestructInstruction &instruction, std::stringstream &ss)
+{
+  ss << "Destruct ";
+  variable_to_string(instruction.variable(), ss);
+}
+
+static void instruction_to_string(const MFDummyInstruction &UNUSED(instruction),
+                                  std::stringstream &ss)
+{
+  ss << "Dummy";
+}
+
+static void instruction_to_string(const MFReturnInstruction &UNUSED(instruction),
+                                  std::stringstream &ss)
+{
+  ss << "Return";
+}
+
+static void instruction_to_string(const MFBranchInstruction &instruction, std::stringstream &ss)
+{
+  ss << "Branch on ";
+  variable_to_string(instruction.condition(), ss);
+}
+
+std::string MFProcedure::to_dot() const
+{
+  Vector<const MFInstruction *> all_instructions;
+  all_instructions.extend(call_instructions_.begin(), call_instructions_.end());
+  all_instructions.extend(branch_instructions_.begin(), branch_instructions_.end());
+  all_instructions.extend(destruct_instructions_.begin(), destruct_instructions_.end());
+  all_instructions.extend(dummy_instructions_.begin(), dummy_instructions_.end());
+  all_instructions.extend(return_instructions_.begin(), return_instructions_.end());
+
+  Set<const MFInstruction *> handled_instructions;
+
+  dot::DirectedGraph digraph;
+  Map<const MFInstruction *, dot::Node *> dot_nodes_by_begin;
+  Map<const MFInstruction *, dot::Node *> dot_nodes_by_end;
+
+  for (const MFInstruction *representative : all_instructions) {
+    if (handled_instructions.contains(representative)) {
+      continue;
+    }
+    Vector<const MFInstruction *> block_instructions = get_instructions_in_block(*this,
+                                                                                 *representative);
+    std::stringstream ss;
+
+    for (const MFInstruction *current : block_instructions) {
+      handled_instructions.add_new(current);
+      switch (current->type()) {
+        case MFInstructionType::Call: {
+          instruction_to_string(*static_cast<const MFCallInstruction *>(current), ss);
+          break;
+        }
+        case MFInstructionType::Destruct: {
+          instruction_to_string(*static_cast<const MFDestructInstruction *>(current), ss);
+          break;
+        }
+        case MFInstructionType::Dummy: {
+          instruction_to_string(*static_cast<const MFDummyInstruction *>(current), ss);
+          break;
+        }
+        case MFInstructionType::Return: {
+          instruction_to_string(*static_cast<const MFReturnInstruction *>(current), ss);
+          break;
+        }
+        case MFInstructionType::Branch: {
+          instruction_to_string(*static_cast<const MFBranchInstruction *>(current), ss);
+          break;
+        }
+      }
+      ss << "\\l";
+    }
+
+    dot::Node &dot_node = digraph.new_node(ss.str());
+    dot_node.set_shape(dot::Attr_shape::Rectangle);
+    dot_nodes_by_begin.add_new(block_instructions.first(), &dot_node);
+    dot_nodes_by_end.add_new(block_instructions.last(), &dot_node);
+  }
+
+  auto create_edge = [&](dot::Node &from_node,
+                         const MFInstruction *to_instruction) -> dot::DirectedEdge & {
+    if (to_instruction == nullptr) {
+      dot::Node &to_node = digraph.new_node("missing");
+      to_node.set_shape(dot::Attr_shape::Diamond);
+      return digraph.new_edge(from_node, to_node);
+    }
+    dot::Node &to_node = *dot_nodes_by_begin.lookup(to_instruction);
+    return digraph.new_edge(from_node, to_node);
+  };
+
+  for (auto item : dot_nodes_by_end.items()) {
+    const MFInstruction &from_instruction = *item.key;
+    dot::Node &from_node = *item.value;
+    switch (from_instruction.type()) {
+      case MFInstructionType::Call: {
+        const MFInstruction *to_instruction =
+            static_cast<const MFCallInstruction &>(from_instruction).next();
+        create_edge(from_node, to_instruction);
+        break;
+      }
+      case MFInstructionType::Destruct: {
+        const MFInstruction *to_instruction =
+            static_cast<const MFDestructInstruction &>(from_instruction).next();
+        create_edge(from_node, to_instruction);
+        break;
+      }
+      case MFInstructionType::Dummy: {
+        const MFInstruction *to_instruction =
+            static_cast<const MFDummyInstruction &>(from_instruction).next();
+        create_edge(from_node, to_instruction);
+        break;
+      }
+      case MFInstructionType::Return: {
+        break;
+      }
+      case MFInstructionType::Branch: {
+        const MFBranchInstruction &branch_instruction = static_cast<const MFBranchInstruction &>(
+            from_instruction);
+        const MFInstruction *to_true_instruction = branch_instruction.branch_true();
+        const MFInstruction *to_false_instruction = branch_instruction.branch_false();
+        create_edge(from_node, to_true_instruction).attributes.set("color", "#118811");
+        create_edge(from_node, to_false_instruction).attributes.set("color", "#881111");
+        break;
+      }
+    }
+  }
+
+  dot::Node &entry_node = digraph.new_node("Entry");
+  entry_node.set_shape(dot::Attr_shape::Circle);
+  create_edge(entry_node, entry_);
+
+  return digraph.to_dot_string();
+}
+
+}  // namespace blender::fn

source/blender/functions/intern/multi_function_procedure_builder.cc

@@ -0,0 +1,174 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#include "FN_multi_function_procedure_builder.hh"
+
+namespace blender::fn {
+
+void MFInstructionCursor::insert(MFProcedure &procedure, MFInstruction *new_instruction)
+{
+  if (instruction_ == nullptr) {
+    if (is_entry_) {
+      procedure.set_entry(*new_instruction);
+    }
+    else {
+      /* The cursors points at nothing, nothing to do. */
+    }
+  }
+  else {
+    switch (instruction_->type()) {
+      case MFInstructionType::Call: {
+        static_cast<MFCallInstruction *>(instruction_)->set_next(new_instruction);
+        break;
+      }
+      case MFInstructionType::Branch: {
+        MFBranchInstruction &branch_instruction = *static_cast<MFBranchInstruction *>(
+            instruction_);
+        if (branch_output_) {
+          branch_instruction.set_branch_true(new_instruction);
+        }
+        else {
+          branch_instruction.set_branch_false(new_instruction);
+        }
+        break;
+      }
+      case MFInstructionType::Destruct: {
+        static_cast<MFDestructInstruction *>(instruction_)->set_next(new_instruction);
+        break;
+      }
+      case MFInstructionType::Dummy: {
+        static_cast<MFDummyInstruction *>(instruction_)->set_next(new_instruction);
+        break;
+      }
+      case MFInstructionType::Return: {
+        /* It shouldn't be possible to build a cursor that points to a return instruction. */
+        BLI_assert_unreachable();
+        break;
+      }
+    }
+  }
+}
+
+void MFProcedureBuilder::add_destruct(MFVariable &variable)
+{
+  MFDestructInstruction &instruction = procedure_->new_destruct_instruction();
+  instruction.set_variable(&variable);
+  this->link_to_cursors(&instruction);
+  cursors_ = {MFInstructionCursor{instruction}};
+}
+
+void MFProcedureBuilder::add_destruct(Span<MFVariable *> variables)
+{
+  for (MFVariable *variable : variables) {
+    this->add_destruct(*variable);
+  }
+}
+
+MFReturnInstruction &MFProcedureBuilder::add_return()
+{
+  MFReturnInstruction &instruction = procedure_->new_return_instruction();
+  this->link_to_cursors(&instruction);
+  cursors_ = {};
+  return instruction;
+}
+
+MFCallInstruction &MFProcedureBuilder::add_call_with_no_variables(const MultiFunction &fn)
+{
+  MFCallInstruction &instruction = procedure_->new_call_instruction(fn);
+  this->link_to_cursors(&instruction);
+  cursors_ = {MFInstructionCursor{instruction}};
+  return instruction;
+}
+
+MFCallInstruction &MFProcedureBuilder::add_call_with_all_variables(
+    const MultiFunction &fn, Span<MFVariable *> param_variables)
+{
+  MFCallInstruction &instruction = this->add_call_with_no_variables(fn);
+  instruction.set_params(param_variables);
+  return instruction;
+}
+
+Vector<MFVariable *> MFProcedureBuilder::add_call(const MultiFunction &fn,
+                                                  Span<MFVariable *> input_and_mutable_variables)
+{
+  Vector<MFVariable *> output_variables;
+  MFCallInstruction &instruction = this->add_call_with_no_variables(fn);
+  for (const int param_index : fn.param_indices()) {
+    const MFParamType param_type = fn.param_type(param_index);
+    switch (param_type.interface_type()) {
+      case MFParamType::Input:
+      case MFParamType::Mutable: {
+        MFVariable *variable = input_and_mutable_variables.first();
+        instruction.set_param_variable(param_index, variable);
+        input_and_mutable_variables = input_and_mutable_variables.drop_front(1);
+        break;
+      }
+      case MFParamType::Output: {
+        MFVariable &variable = procedure_->new_variable(param_type.data_type());
+        instruction.set_param_variable(param_index, &variable);
+        output_variables.append(&variable);
+        break;
+      }
+    }
+  }
+  /* All passed in variables should have been dropped in the loop above. */
+  BLI_assert(input_and_mutable_variables.is_empty());
+  return output_variables;
+}
+
+MFProcedureBuilder::Branch MFProcedureBuilder::add_branch(MFVariable &condition)
+{
+  MFBranchInstruction &instruction = procedure_->new_branch_instruction();
+  instruction.set_condition(&condition);
+  this->link_to_cursors(&instruction);
+  /* Clear cursors because this builder ends here. */
+  cursors_.clear();
+
+  Branch branch{*procedure_, *procedure_};
+  branch.branch_true.set_cursor(MFInstructionCursor{instruction, true});
+  branch.branch_false.set_cursor(MFInstructionCursor{instruction, false});
+  return branch;
+}
+
+MFProcedureBuilder::Loop MFProcedureBuilder::add_loop()
+{
+  MFDummyInstruction &loop_begin = procedure_->new_dummy_instruction();
+  MFDummyInstruction &loop_end = procedure_->new_dummy_instruction();
+  this->link_to_cursors(&loop_begin);
+  cursors_ = {MFInstructionCursor{loop_begin}};
+
+  Loop loop;
+  loop.begin = &loop_begin;
+  loop.end = &loop_end;
+
+  return loop;
+}
+
+void MFProcedureBuilder::add_loop_continue(Loop &loop)
+{
+  this->link_to_cursors(loop.begin);
+  /* Clear cursors because this builder ends here. */
+  cursors_.clear();
+}
+
+void MFProcedureBuilder::add_loop_break(Loop &loop)
+{
+  this->link_to_cursors(loop.end);
+  /* Clear cursors because this builder ends here. */
+  cursors_.clear();
+}
+
+}  // namespace blender::fn

source/blender/functions/tests/FN_multi_function_procedure_test.cc

@@ -0,0 +1,344 @@
+/* Apache License, Version 2.0 */
+
+#include "testing/testing.h"
+
+#include "FN_multi_function_builder.hh"
+#include "FN_multi_function_procedure_builder.hh"
+#include "FN_multi_function_procedure_executor.hh"
+#include "FN_multi_function_test_common.hh"
+
+namespace blender::fn::tests {
+
+TEST(multi_function_procedure, SimpleTest)
+{
+  /**
+   * procedure(int var1, int var2, int *var4) {
+   *   int var3 = var1 + var2;
+   *   var4 = var2 + var3;
+   *   var4 += 10;
+   * }
+   */
+
+  CustomMF_SI_SI_SO<int, int, int> add_fn{"add", [](int a, int b) { return a + b; }};
+  CustomMF_SM<int> add_10_fn{"add_10", [](int &a) { a += 10; }};
+
+  MFProcedure procedure;
+  MFProcedureBuilder builder{procedure};
+
+  MFVariable *var1 = &builder.add_single_input_parameter<int>();
+  MFVariable *var2 = &builder.add_single_input_parameter<int>();
+  auto [var3] = builder.add_call<1>(add_fn, {var1, var2});
+  auto [var4] = builder.add_call<1>(add_fn, {var2, var3});
+  builder.add_call(add_10_fn, {var4});
+  builder.add_destruct({var1, var2, var3});
+  builder.add_return();
+  builder.add_output_parameter(*var4);
+
+  EXPECT_TRUE(procedure.validate());
+
+  MFProcedureExecutor executor{"My Procedure", procedure};
+
+  MFParamsBuilder params{executor, 3};
+  MFContextBuilder context;
+
+  Array<int> input_array = {1, 2, 3};
+  params.add_readonly_single_input(input_array.as_span());
+  params.add_readonly_single_input_value(3);
+
+  Array<int> output_array(3);
+  params.add_uninitialized_single_output(output_array.as_mutable_span());
+
+  executor.call(IndexRange(3), params, context);
+
+  EXPECT_EQ(output_array[0], 17);
+  EXPECT_EQ(output_array[1], 18);
+  EXPECT_EQ(output_array[2], 19);
+}
+
+TEST(multi_function_procedure, BranchTest)
+{
+  /**
+   * procedure(int &var1, bool var2) {
+   *   if (var2) {
+   *     var1 += 100;
+   *   }
+   *   else {
+   *     var1 += 10;
+   *   }
+   *   var1 += 10;
+   * }
+   */
+
+  CustomMF_SM<int> add_10_fn{"add_10", [](int &a) { a += 10; }};
+  CustomMF_SM<int> add_100_fn{"add_100", [](int &a) { a += 100; }};
+
+  MFProcedure procedure;
+  MFProcedureBuilder builder{procedure};
+
+  MFVariable *var1 = &builder.add_single_mutable_parameter<int>();
+  MFVariable *var2 = &builder.add_single_input_parameter<bool>();
+
+  MFProcedureBuilder::Branch branch = builder.add_branch(*var2);
+  branch.branch_false.add_call(add_10_fn, {var1});
+  branch.branch_true.add_call(add_100_fn, {var1});
+  builder.set_cursor_after_branch(branch);
+  builder.add_call(add_10_fn, {var1});
+  builder.add_destruct({var2});
+  builder.add_return();
+
+  EXPECT_TRUE(procedure.validate());
+
+  MFProcedureExecutor procedure_fn{"Condition Test", procedure};
+  MFParamsBuilder params(procedure_fn, 5);
+
+  Array<int> values_a = {1, 5, 3, 6, 2};
+  Array<bool> values_cond = {true, false, true, true, false};
+
+  params.add_single_mutable(values_a.as_mutable_span());
+  params.add_readonly_single_input(values_cond.as_span());
+
+  MFContextBuilder context;
+  procedure_fn.call({1, 2, 3, 4}, params, context);
+
+  EXPECT_EQ(values_a[0], 1);
+  EXPECT_EQ(values_a[1], 25);
+  EXPECT_EQ(values_a[2], 113);
+  EXPECT_EQ(values_a[3], 116);
+  EXPECT_EQ(values_a[4], 22);
+}
+
+TEST(multi_function_procedure, EvaluateOne)
+{
+  /**
+   * procedure(int var1, int var2) {
+   *   var2 = var1 + 10;
+   * }
+   */
+
+  int tot_evaluations = 0;
+  CustomMF_SI_SO<int, int> add_10_fn{"add_10", [&](int a) {
+                                       tot_evaluations++;
+                                       return a + 10;
+                                     }};
+
+  MFProcedure procedure;
+  MFProcedureBuilder builder{procedure};
+
+  MFVariable *var1 = &builder.add_single_input_parameter<int>();
+  auto [var2] = builder.add_call<1>(add_10_fn, {var1});
+  builder.add_destruct(*var1);
+  builder.add_return();
+  builder.add_output_parameter(*var2);
+
+  MFProcedureExecutor procedure_fn{"Evaluate One", procedure};
+  MFParamsBuilder params{procedure_fn, 5};
+
+  Array<int> values_out = {1, 2, 3, 4, 5};
+  params.add_readonly_single_input_value(1);
+  params.add_uninitialized_single_output(values_out.as_mutable_span());
+
+  MFContextBuilder context;
+  procedure_fn.call({0, 1, 3, 4}, params, context);
+
+  EXPECT_EQ(values_out[0], 11);
+  EXPECT_EQ(values_out[1], 11);
+  EXPECT_EQ(values_out[2], 3);
+  EXPECT_EQ(values_out[3], 11);
+  EXPECT_EQ(values_out[4], 11);
+  /* We expect only one evaluation, because the input is constant. */
+  EXPECT_EQ(tot_evaluations, 1);
+}
+
+TEST(multi_function_procedure, SimpleLoop)
+{
+  /**
+   * procedure(int count, int *out) {
+   *   out = 1;
+   *   int index = 0'
+   *   loop {
+   *     if (index >= count) {
+   *       break;
+   *     }
+   *     out *= 2;
+   *     index += 1;
+   *   }
+   *   out += 1000;
+   * }
+   */
+
+  CustomMF_Constant<int> const_1_fn{1};
+  CustomMF_Constant<int> const_0_fn{0};
+  CustomMF_SI_SI_SO<int, int, bool> greater_or_equal_fn{"greater or equal",
+                                                        [](int a, int b) { return a >= b; }};
+  CustomMF_SM<int> double_fn{"double", [](int &a) { a *= 2; }};
+  CustomMF_SM<int> add_1000_fn{"add 1000", [](int &a) { a += 1000; }};
+  CustomMF_SM<int> add_1_fn{"add 1", [](int &a) { a += 1; }};
+
+  MFProcedure procedure;
+  MFProcedureBuilder builder{procedure};
+
+  MFVariable *var_count = &builder.add_single_input_parameter<int>("count");
+  auto [var_out] = builder.add_call<1>(const_1_fn);
+  var_out->set_name("out");
+  auto [var_index] = builder.add_call<1>(const_0_fn);
+  var_index->set_name("index");
+
+  MFProcedureBuilder::Loop loop = builder.add_loop();
+  auto [var_condition] = builder.add_call<1>(greater_or_equal_fn, {var_index, var_count});
+  var_condition->set_name("condition");
+  MFProcedureBuilder::Branch branch = builder.add_branch(*var_condition);
+  branch.branch_true.add_destruct(*var_condition);
+  branch.branch_true.add_loop_break(loop);
+  branch.branch_false.add_destruct(*var_condition);
+  builder.set_cursor_after_branch(branch);
+  builder.add_call(double_fn, {var_out});
+  builder.add_call(add_1_fn, {var_index});
+  builder.add_loop_continue(loop);
+  builder.set_cursor_after_loop(loop);
+  builder.add_call(add_1000_fn, {var_out});
+  builder.add_destruct({var_count, var_index});
+  builder.add_return();
+  builder.add_output_parameter(*var_out);
+
+  EXPECT_TRUE(procedure.validate());
+
+  MFProcedureExecutor procedure_fn{"Simple Loop", procedure};
+  MFParamsBuilder params{procedure_fn, 5};
+
+  Array<int> counts = {4, 3, 7, 6, 4};
+  Array<int> results(5, -1);
+
+  params.add_readonly_single_input(counts.as_span());
+  params.add_uninitialized_single_output(results.as_mutable_span());
+
+  MFContextBuilder context;
+  procedure_fn.call({0, 1, 3, 4}, params, context);
+
+  EXPECT_EQ(results[0], 1016);
+  EXPECT_EQ(results[1], 1008);
+  EXPECT_EQ(results[2], -1);
+  EXPECT_EQ(results[3], 1064);
+  EXPECT_EQ(results[4], 1016);
+}
+
+TEST(multi_function_procedure, Vectors)
+{
+  /**
+   * procedure(vector<int> v1, vector<int> &v2, vector<int> *v3) {
+   *   v1.extend(v2);
+   *   int constant = 5;
+   *   v2.append(constant);
+   *   v2.extend(v1);
+   *   int len = sum(v2);
+   *   v3 = range(len);
+   * }
+   */
+
+  CreateRangeFunction create_range_fn;
+  ConcatVectorsFunction extend_fn;
+  GenericAppendFunction append_fn{CPPType::get<int>()};
+  SumVectorFunction sum_elements_fn;
+  CustomMF_Constant<int> constant_5_fn{5};
+
+  MFProcedure procedure;
+  MFProcedureBuilder builder{procedure};
+
+  MFVariable *var_v1 = &builder.add_input_parameter(MFDataType::ForVector<int>());
+  MFVariable *var_v2 = &builder.add_parameter(MFParamType::ForMutableVector(CPPType::get<int>()));
+  builder.add_call(extend_fn, {var_v1, var_v2});
+  auto [var_constant] = builder.add_call<1>(constant_5_fn);
+  builder.add_call(append_fn, {var_v2, var_constant});
+  builder.add_destruct(*var_constant);
+  builder.add_call(extend_fn, {var_v2, var_v1});
+  auto [var_len] = builder.add_call<1>(sum_elements_fn, {var_v2});
+  auto [var_v3] = builder.add_call<1>(create_range_fn, {var_len});
+  builder.add_destruct({var_v1, var_len});
+  builder.add_return();
+  builder.add_output_parameter(*var_v3);
+
+  EXPECT_TRUE(procedure.validate());
+
+  MFProcedureExecutor procedure_fn{"Vectors", procedure};
+  MFParamsBuilder params{procedure_fn, 5};
+
+  Array<int> v1 = {5, 2, 3};
+  GVectorArray v2{CPPType::get<int>(), 5};
+  GVectorArray v3{CPPType::get<int>(), 5};
+
+  int value_10 = 10;
+  v2.append(0, &value_10);
+  v2.append(4, &value_10);
+
+  params.add_readonly_vector_input(v1.as_span());
+  params.add_vector_mutable(v2);
+  params.add_vector_output(v3);
+
+  MFContextBuilder context;
+  procedure_fn.call({0, 1, 3, 4}, params, context);
+
+  EXPECT_EQ(v2[0].size(), 6);
+  EXPECT_EQ(v2[1].size(), 4);
+  EXPECT_EQ(v2[2].size(), 0);
+  EXPECT_EQ(v2[3].size(), 4);
+  EXPECT_EQ(v2[4].size(), 6);
+
+  EXPECT_EQ(v3[0].size(), 35);
+  EXPECT_EQ(v3[1].size(), 15);
+  EXPECT_EQ(v3[2].size(), 0);
+  EXPECT_EQ(v3[3].size(), 15);
+  EXPECT_EQ(v3[4].size(), 35);
+}
+
+TEST(multi_function_procedure, BufferReuse)
+{
+  /**
+   * procedure(int a, int *out) {
+   *   int b = a + 10;
+   *   int c = c + 10;
+   *   int d = d + 10;
+   *   int e = d + 10;
+   *   out = e + 10;
+   * }
+   */
+
+  CustomMF_SI_SO<int, int> add_10_fn{"add 10", [](int a) { return a + 10; }};
+
+  MFProcedure procedure;
+  MFProcedureBuilder builder{procedure};
+
+  MFVariable *var_a = &builder.add_single_input_parameter<int>();
+  auto [var_b] = builder.add_call<1>(add_10_fn, {var_a});
+  builder.add_destruct(*var_a);
+  auto [var_c] = builder.add_call<1>(add_10_fn, {var_b});
+  builder.add_destruct(*var_b);
+  auto [var_d] = builder.add_call<1>(add_10_fn, {var_c});
+  builder.add_destruct(*var_c);
+  auto [var_e] = builder.add_call<1>(add_10_fn, {var_d});
+  builder.add_destruct(*var_d);
+  auto [var_out] = builder.add_call<1>(add_10_fn, {var_e});
+  builder.add_destruct(*var_e);
+  builder.add_return();
+  builder.add_output_parameter(*var_out);
+
+  EXPECT_TRUE(procedure.validate());
+
+  MFProcedureExecutor procedure_fn{"Buffer Reuse", procedure};
+
+  Array<int> inputs = {4, 1, 6, 2, 3};
+  Array<int> results(5, -1);
+
+  MFParamsBuilder params{procedure_fn, 5};
+  params.add_readonly_single_input(inputs.as_span());
+  params.add_uninitialized_single_output(results.as_mutable_span());
+
+  MFContextBuilder context;
+  procedure_fn.call({0, 2, 3, 4}, params, context);
+
+  EXPECT_EQ(results[0], 54);
+  EXPECT_EQ(results[1], -1);
+  EXPECT_EQ(results[2], 56);
+  EXPECT_EQ(results[3], 52);
+  EXPECT_EQ(results[4], 53);
+}
+
+}  // namespace blender::fn::tests