Rename FunctionNode to FunctionCallNode

2025-10-15 10:19:04 +00:00 · 2020-02-17 22:01:56 +00:00
16 changed files with 65 additions and 65 deletions
--- a/Core/GDCore/Events/CodeGeneration/ExpressionCodeGenerator.cpp
+++ b/Core/GDCore/Events/CodeGeneration/ExpressionCodeGenerator.cpp
@@ -127,7 +127,7 @@ void ExpressionCodeGenerator::OnVisitIdentifierNode(IdentifierNode& node) {
  }
 }

-void ExpressionCodeGenerator::OnVisitFunctionNode(FunctionNode& node) {
+void ExpressionCodeGenerator::OnVisitFunctionCallNode(FunctionCallNode& node) {
  if (gd::MetadataProvider::IsBadExpressionMetadata(node.expressionMetadata)) {
    output += "/* Error during generation, function not found: " +
              codeGenerator.ConvertToString(node.functionName) + " for type " +
--- a/Core/GDCore/Events/CodeGeneration/ExpressionCodeGenerator.h
+++ b/Core/GDCore/Events/CodeGeneration/ExpressionCodeGenerator.h
@@ -73,7 +73,7 @@ class GD_CORE_API ExpressionCodeGenerator : public ExpressionParser2NodeWorker {
  void OnVisitVariableBracketAccessorNode(
      VariableBracketAccessorNode& node) override;
  void OnVisitIdentifierNode(IdentifierNode& node) override;
-  void OnVisitFunctionNode(FunctionNode& node) override;
+  void OnVisitFunctionCallNode(FunctionCallNode& node) override;
  void OnVisitEmptyNode(EmptyNode& node) override;

 private:
--- a/Core/GDCore/Events/Parsers/ExpressionParser2.cpp
+++ b/Core/GDCore/Events/Parsers/ExpressionParser2.cpp
@@ -76,7 +76,7 @@ size_t GetMaximumParametersNumber(
 }  // namespace

 std::unique_ptr<ExpressionParserDiagnostic> ExpressionParser2::ValidateFunction(
-    const gd::FunctionNode& function, size_t functionStartPosition) {
+    const gd::FunctionCallNode& function, size_t functionStartPosition) {
  if (gd::MetadataProvider::IsBadExpressionMetadata(
          function.expressionMetadata)) {
    return gd::make_unique<ExpressionParserError>(
--- a/Core/GDCore/Events/Parsers/ExpressionParser2.h
+++ b/Core/GDCore/Events/Parsers/ExpressionParser2.h
@@ -320,7 +320,7 @@ class GD_CORE_API ExpressionParser2 {
    return child;
  }

-  std::unique_ptr<FunctionNode> FreeFunction(const gd::String &type,
+  std::unique_ptr<FunctionCallNode> FreeFunction(const gd::String &type,
                                             const gd::String &functionFullName,
                                             size_t functionStartPosition) {
    // TODO: error if trying to use function for type != "number" && != "string"
@@ -335,7 +335,7 @@ class GD_CORE_API ExpressionParser2 {
                               platform, functionFullName);

    auto parametersAndError = Parameters(metadata.parameters);
-    auto function = gd::make_unique<FunctionNode>(
+    auto function = gd::make_unique<FunctionCallNode>(
        type, std::move(parametersAndError.first), metadata, functionFullName);
    function->diagnostic = std::move(parametersAndError.second);
    if (!function->diagnostic)
@@ -376,7 +376,7 @@ class GD_CORE_API ExpressionParser2 {

      auto parametersAndError = Parameters(metadata.parameters, objectName);
      auto function =
-          gd::make_unique<FunctionNode>(type,
+          gd::make_unique<FunctionCallNode>(type,
                                        objectName,
                                        std::move(parametersAndError.first),
                                        metadata,
@@ -425,7 +425,7 @@ class GD_CORE_API ExpressionParser2 {
      auto parametersAndError =
          Parameters(metadata.parameters, objectName, behaviorName);
      auto function =
-          gd::make_unique<FunctionNode>(type,
+          gd::make_unique<FunctionCallNode>(type,
                                        objectName,
                                        behaviorName,
                                        std::move(parametersAndError.first),
@@ -521,7 +521,7 @@ class GD_CORE_API ExpressionParser2 {
   */
  ///@{
  std::unique_ptr<ExpressionParserDiagnostic> ValidateFunction(
-      const gd::FunctionNode &function, size_t functionStartPosition);
+      const gd::FunctionCallNode &function, size_t functionStartPosition);

  std::unique_ptr<ExpressionParserDiagnostic> ValidateOperator(
      const gd::String &type, gd::String::value_type operatorChar) {
--- a/Core/GDCore/Events/Parsers/ExpressionParser2Node.h
+++ b/Core/GDCore/Events/Parsers/ExpressionParser2Node.h
@@ -220,7 +220,7 @@ struct VariableBracketAccessorNode
 struct IdentifierOrFunctionOrEmptyNode : public ExpressionNode {};

 /**
- * \brief An identifier node, usually representing an object.
+ * \brief An identifier node, usually representing an object or a function name.
 */
 struct IdentifierNode : public IdentifierOrFunctionOrEmptyNode {
  IdentifierNode(const gd::String &identifierName_, const gd::String &type_)
@@ -242,8 +242,8 @@ struct FunctionOrEmptyNode : public IdentifierOrFunctionOrEmptyNode {
 /**
 * \brief A function node. For example: "MyExtension::MyFunction(1, 2)".
 */
-struct FunctionNode : public FunctionOrEmptyNode {
-  FunctionNode(const gd::String &type_,
+struct FunctionCallNode : public FunctionOrEmptyNode {
+  FunctionCallNode(const gd::String &type_,
               std::vector<std::unique_ptr<ExpressionNode>> parameters_,
               const ExpressionMetadata &expressionMetadata_,
               const gd::String &functionName_)
@@ -251,7 +251,7 @@ struct FunctionNode : public FunctionOrEmptyNode {
        parameters(std::move(parameters_)),
        expressionMetadata(expressionMetadata_),
        functionName(functionName_){};
-  FunctionNode(const gd::String &type_,
+  FunctionCallNode(const gd::String &type_,
               const gd::String &objectName_,
               std::vector<std::unique_ptr<ExpressionNode>> parameters_,
               const ExpressionMetadata &expressionMetadata_,
@@ -261,7 +261,7 @@ struct FunctionNode : public FunctionOrEmptyNode {
        parameters(std::move(parameters_)),
        expressionMetadata(expressionMetadata_),
        functionName(functionName_){};
-  FunctionNode(const gd::String &type_,
+  FunctionCallNode(const gd::String &type_,
               const gd::String &objectName_,
               const gd::String &behaviorName_,
               std::vector<std::unique_ptr<ExpressionNode>> parameters_,
@@ -273,9 +273,9 @@ struct FunctionNode : public FunctionOrEmptyNode {
        parameters(std::move(parameters_)),
        expressionMetadata(expressionMetadata_),
        functionName(functionName_){};
-  virtual ~FunctionNode(){};
+  virtual ~FunctionCallNode(){};
  virtual void Visit(ExpressionParser2NodeWorker &worker) {
-    worker.OnVisitFunctionNode(*this);
+    worker.OnVisitFunctionCallNode(*this);
  };

  gd::String type;  // This could be removed if the type ("string" or "number")
--- a/Core/GDCore/Events/Parsers/ExpressionParser2NodePrinter.h
+++ b/Core/GDCore/Events/Parsers/ExpressionParser2NodePrinter.h
@@ -92,7 +92,7 @@ class GD_CORE_API ExpressionParser2NodePrinter
  void OnVisitIdentifierNode(IdentifierNode& node) override {
    output += node.identifierName;
  }
-  void OnVisitFunctionNode(FunctionNode& node) override {
+  void OnVisitFunctionCallNode(FunctionCallNode& node) override {
    if (!node.behaviorName.empty()) {
      output +=
          node.objectName + "." + node.behaviorName + "::" + node.functionName;
--- a/Core/GDCore/Events/Parsers/ExpressionParser2NodeWorker.h
+++ b/Core/GDCore/Events/Parsers/ExpressionParser2NodeWorker.h
@@ -19,7 +19,7 @@ class VariableBracketAccessorNode;
 class IdentifierOrFunctionOrEmptyNode;
 class IdentifierNode;
 class FunctionOrEmptyNode;
-class FunctionNode;
+class FunctionCallNode;
 class EmptyNode;
 }  // namespace gd

@@ -45,7 +45,7 @@ class GD_CORE_API ExpressionParser2NodeWorker {
  friend class IdentifierOrFunctionOrEmptyNode;
  friend class IdentifierNode;
  friend class FunctionOrEmptyNode;
-  friend class FunctionNode;
+  friend class FunctionCallNode;
  friend class EmptyNode;

 public:
@@ -62,10 +62,10 @@ class GD_CORE_API ExpressionParser2NodeWorker {
  virtual void OnVisitVariableBracketAccessorNode(
      VariableBracketAccessorNode& node) = 0;
  virtual void OnVisitIdentifierNode(IdentifierNode& node) = 0;
-  virtual void OnVisitFunctionNode(FunctionNode& node) = 0;
+  virtual void OnVisitFunctionCallNode(FunctionCallNode& node) = 0;
  virtual void OnVisitEmptyNode(EmptyNode& node) = 0;
 };

 }  // namespace gd

-#endif
+#endif
--- a/Core/GDCore/IDE/Events/EventsContextAnalyzer.cpp
+++ b/Core/GDCore/IDE/Events/EventsContextAnalyzer.cpp
@@ -63,7 +63,7 @@ class GD_CORE_API ExpressionObjectsAnalyzer
      context.AddObjectName(node.identifierName);
    }
  }
-  void OnVisitFunctionNode(FunctionNode& node) override {
+  void OnVisitFunctionCallNode(FunctionCallNode& node) override {
    if (!node.objectName.empty()) {
      context.AddObjectName(node.objectName);

--- a/Core/GDCore/IDE/Events/EventsRefactorer.cpp
+++ b/Core/GDCore/IDE/Events/EventsRefactorer.cpp
@@ -35,7 +35,7 @@ class GD_CORE_API ExpressionObjectRenamer : public ExpressionParser2NodeWorker {
  virtual ~ExpressionObjectRenamer(){};

  static bool Rename(gd::ExpressionNode & node, const gd::String& objectName, const gd::String& objectNewName) {
-    if (ExpressionValidator::HasNoErrors(node)) {  
+    if (ExpressionValidator::HasNoErrors(node)) {
      ExpressionObjectRenamer renamer(objectName, objectNewName);
      node.Visit(renamer);

@@ -77,7 +77,7 @@ class GD_CORE_API ExpressionObjectRenamer : public ExpressionParser2NodeWorker {
      node.identifierName = objectNewName;
    }
  }
-  void OnVisitFunctionNode(FunctionNode& node) override {
+  void OnVisitFunctionCallNode(FunctionCallNode& node) override {
    if (node.objectName == objectName) {
      hasDoneRenaming = true;
      node.objectName = objectNewName;
@@ -107,7 +107,7 @@ class GD_CORE_API ExpressionObjectFinder : public ExpressionParser2NodeWorker {
  virtual ~ExpressionObjectFinder(){};

  static bool CheckIfHasObject(gd::ExpressionNode & node, const gd::String & objectName) {
-    if (ExpressionValidator::HasNoErrors(node)) {  
+    if (ExpressionValidator::HasNoErrors(node)) {
      ExpressionObjectFinder finder(objectName);
      node.Visit(finder);

@@ -148,7 +148,7 @@ class GD_CORE_API ExpressionObjectFinder : public ExpressionParser2NodeWorker {
      hasObject = true;
    }
  }
-  void OnVisitFunctionNode(FunctionNode& node) override {
+  void OnVisitFunctionCallNode(FunctionCallNode& node) override {
    if (node.objectName == objectName) {
      hasObject = true;
    }
@@ -184,7 +184,7 @@ bool EventsRefactorer::RenameObjectInActions(const gd::Platform& platform,
                   "number", instrInfos.parameters[pNb].type)) {
        gd::ExpressionParser2 parser(platform, project, layout);
        auto node = parser.ParseExpression("number", actions[aId].GetParameter(pNb).GetPlainString());
-        
+
        if (ExpressionObjectRenamer::Rename(*node, oldName, newName)) {
          actions[aId].SetParameter(pNb, ExpressionParser2NodePrinter::PrintNode(*node));
        }
@@ -194,7 +194,7 @@ bool EventsRefactorer::RenameObjectInActions(const gd::Platform& platform,
                   "string", instrInfos.parameters[pNb].type)) {
        gd::ExpressionParser2 parser(platform, project, layout);
        auto node = parser.ParseExpression("string", actions[aId].GetParameter(pNb).GetPlainString());
-        
+
        if (ExpressionObjectRenamer::Rename(*node, oldName, newName)) {
          actions[aId].SetParameter(pNb, ExpressionParser2NodePrinter::PrintNode(*node));
        }
@@ -237,7 +237,7 @@ bool EventsRefactorer::RenameObjectInConditions(
                   "number", instrInfos.parameters[pNb].type)) {
        gd::ExpressionParser2 parser(platform, project, layout);
        auto node = parser.ParseExpression("number", conditions[cId].GetParameter(pNb).GetPlainString());
-        
+
        if (ExpressionObjectRenamer::Rename(*node, oldName, newName)) {
          conditions[cId].SetParameter(pNb, ExpressionParser2NodePrinter::PrintNode(*node));
        }
@@ -247,7 +247,7 @@ bool EventsRefactorer::RenameObjectInConditions(
                   "string", instrInfos.parameters[pNb].type)) {
        gd::ExpressionParser2 parser(platform, project, layout);
        auto node = parser.ParseExpression("string", conditions[cId].GetParameter(pNb).GetPlainString());
-        
+
        if (ExpressionObjectRenamer::Rename(*node, oldName, newName)) {
          conditions[cId].SetParameter(pNb, ExpressionParser2NodePrinter::PrintNode(*node));
        }
@@ -323,7 +323,7 @@ bool EventsRefactorer::RemoveObjectInActions(const gd::Platform& platform,
                   "number", instrInfos.parameters[pNb].type)) {
        gd::ExpressionParser2 parser(platform, project, layout);
        auto node = parser.ParseExpression("number", actions[aId].GetParameter(pNb).GetPlainString());
-        
+
        if (ExpressionObjectFinder::CheckIfHasObject(*node, name)) {
          deleteMe = true;
          break;
@@ -334,7 +334,7 @@ bool EventsRefactorer::RemoveObjectInActions(const gd::Platform& platform,
                   "string", instrInfos.parameters[pNb].type)) {
        gd::ExpressionParser2 parser(platform, project, layout);
        auto node = parser.ParseExpression("string", actions[aId].GetParameter(pNb).GetPlainString());
-        
+
        if (ExpressionObjectFinder::CheckIfHasObject(*node, name)) {
          deleteMe = true;
          break;
@@ -384,7 +384,7 @@ bool EventsRefactorer::RemoveObjectInConditions(
                   "number", instrInfos.parameters[pNb].type)) {
        gd::ExpressionParser2 parser(platform, project, layout);
        auto node = parser.ParseExpression("number", conditions[cId].GetParameter(pNb).GetPlainString());
-        
+
        if (ExpressionObjectFinder::CheckIfHasObject(*node, name)) {
          deleteMe = true;
          break;
@@ -395,7 +395,7 @@ bool EventsRefactorer::RemoveObjectInConditions(
                   "string", instrInfos.parameters[pNb].type)) {
        gd::ExpressionParser2 parser(platform, project, layout);
        auto node = parser.ParseExpression("string", conditions[cId].GetParameter(pNb).GetPlainString());
-        
+
        if (ExpressionObjectFinder::CheckIfHasObject(*node, name)) {
          deleteMe = true;
          break;
--- a/Core/GDCore/IDE/Events/EventsVariablesFinder.cpp
+++ b/Core/GDCore/IDE/Events/EventsVariablesFinder.cpp
@@ -63,7 +63,7 @@ class GD_CORE_API ExpressionParameterSearcher
    if (node.child) node.child->Visit(*this);
  }
  void OnVisitIdentifierNode(IdentifierNode& node) override {}
-  void OnVisitFunctionNode(FunctionNode& node) override {
+  void OnVisitFunctionCallNode(FunctionCallNode& node) override {
    bool considerFunction = objectName.empty() || node.objectName == objectName;
    for (size_t i = 0; i < node.parameters.size() &&
                       i < node.expressionMetadata.parameters.size();
--- a/Core/GDCore/IDE/Events/ExpressionNodeLocationFinder.h
+++ b/Core/GDCore/IDE/Events/ExpressionNodeLocationFinder.h
@@ -90,7 +90,7 @@ class GD_CORE_API ExpressionNodeLocationFinder
  void OnVisitIdentifierNode(IdentifierNode& node) override {
    CheckSearchPositionInNode(node);
  }
-  void OnVisitFunctionNode(FunctionNode& node) override {
+  void OnVisitFunctionCallNode(FunctionCallNode& node) override {
    CheckSearchPositionInNode(node);
    for (auto& parameter : node.parameters) {
      parameter->Visit(*this);
--- a/Core/GDCore/IDE/Events/ExpressionValidator.h
+++ b/Core/GDCore/IDE/Events/ExpressionValidator.h
@@ -83,7 +83,7 @@ class GD_CORE_API ExpressionValidator : public ExpressionParser2NodeWorker {
  void OnVisitIdentifierNode(IdentifierNode& node) override {
    ReportAnyError(node);
  }
-  void OnVisitFunctionNode(FunctionNode& node) override {
+  void OnVisitFunctionCallNode(FunctionCallNode& node) override {
    ReportAnyError(node);
    for (auto& parameter : node.parameters) {
      parameter->Visit(*this);
--- a/Core/GDCore/IDE/Events/ExpressionsParameterMover.cpp
+++ b/Core/GDCore/IDE/Events/ExpressionsParameterMover.cpp
@@ -74,7 +74,7 @@ class GD_CORE_API ExpressionParameterMover
    if (node.child) node.child->Visit(*this);
  }
  void OnVisitIdentifierNode(IdentifierNode& node) override {}
-  void OnVisitFunctionNode(FunctionNode& node) override {
+  void OnVisitFunctionCallNode(FunctionCallNode& node) override {
    auto moveParameter =
        [this](std::vector<std::unique_ptr<gd::ExpressionNode>>& parameters) {
          if (oldIndex >= parameters.size() || newIndex >= parameters.size())
--- a/Core/GDCore/IDE/Events/ExpressionsRenamer.cpp
+++ b/Core/GDCore/IDE/Events/ExpressionsRenamer.cpp
@@ -71,7 +71,7 @@ class GD_CORE_API ExpressionFunctionRenamer
    if (node.child) node.child->Visit(*this);
  }
  void OnVisitIdentifierNode(IdentifierNode& node) override {}
-  void OnVisitFunctionNode(FunctionNode& node) override {
+  void OnVisitFunctionCallNode(FunctionCallNode& node) override {
    if (node.functionName == oldFunctionName) {
      if (!objectType.empty() && !node.objectName.empty()) {
        // Replace an object function
--- a/Core/tests/ExpressionNodeLocationFinder.cpp
+++ b/Core/tests/ExpressionNodeLocationFinder.cpp
@@ -204,13 +204,13 @@ TEST_CASE("ExpressionNodeLocationFinder", "[common][events]") {
      REQUIRE(CheckNodeAtLocationIs<gd::OperatorNode>(
                  parser, "number", "12 + MyExtension::GetNumber()", 4) ==
              true);
-      REQUIRE(CheckNodeAtLocationIs<gd::FunctionNode>(
+      REQUIRE(CheckNodeAtLocationIs<gd::FunctionCallNode>(
                  parser, "number", "12 + MyExtension::GetNumber()", 5) ==
              true);
-      REQUIRE(CheckNodeAtLocationIs<gd::FunctionNode>(
+      REQUIRE(CheckNodeAtLocationIs<gd::FunctionCallNode>(
                  parser, "number", "12 + MyExtension::GetNumber()", 27) ==
              true);
-      REQUIRE(CheckNodeAtLocationIs<gd::FunctionNode>(
+      REQUIRE(CheckNodeAtLocationIs<gd::FunctionCallNode>(
                  parser, "number", "12 + MyExtension::GetNumber()", 28) ==
              true);
      REQUIRE(CheckNoNodeAtLocation(
@@ -218,17 +218,17 @@ TEST_CASE("ExpressionNodeLocationFinder", "[common][events]") {
              true);
    }
    SECTION("Test 2") {
-      REQUIRE(CheckNodeAtLocationIs<gd::FunctionNode>(
+      REQUIRE(CheckNodeAtLocationIs<gd::FunctionCallNode>(
                  parser,
                  "number",
                  "MyExtension::GetNumberWith2Params(12, \"hello world\")",
                  0) == true);
-      REQUIRE(CheckNodeAtLocationIs<gd::FunctionNode>(
+      REQUIRE(CheckNodeAtLocationIs<gd::FunctionCallNode>(
                  parser,
                  "number",
                  "MyExtension::GetNumberWith2Params(12, \"hello world\")",
                  1) == true);
-      REQUIRE(CheckNodeAtLocationIs<gd::FunctionNode>(
+      REQUIRE(CheckNodeAtLocationIs<gd::FunctionCallNode>(
                  parser,
                  "number",
                  "MyExtension::GetNumberWith2Params(12, \"hello world\")",
@@ -243,12 +243,12 @@ TEST_CASE("ExpressionNodeLocationFinder", "[common][events]") {
                  "number",
                  "MyExtension::GetNumberWith2Params(12, \"hello world\")",
                  35) == true);
-      REQUIRE(CheckNodeAtLocationIs<gd::FunctionNode>(
+      REQUIRE(CheckNodeAtLocationIs<gd::FunctionCallNode>(
                  parser,
                  "number",
                  "MyExtension::GetNumberWith2Params(12, \"hello world\")",
                  36) == true);
-      REQUIRE(CheckNodeAtLocationIs<gd::FunctionNode>(
+      REQUIRE(CheckNodeAtLocationIs<gd::FunctionCallNode>(
                  parser,
                  "number",
                  "MyExtension::GetNumberWith2Params(12, \"hello world\")",
@@ -268,7 +268,7 @@ TEST_CASE("ExpressionNodeLocationFinder", "[common][events]") {
                  "number",
                  "MyExtension::GetNumberWith2Params(12, \"hello world\")",
                  50) == true);
-      REQUIRE(CheckNodeAtLocationIs<gd::FunctionNode>(
+      REQUIRE(CheckNodeAtLocationIs<gd::FunctionCallNode>(
                  parser,
                  "number",
                  "MyExtension::GetNumberWith2Params(12, \"hello world\")",
@@ -282,30 +282,30 @@ TEST_CASE("ExpressionNodeLocationFinder", "[common][events]") {
  }

  SECTION("Invalid function calls") {
-    REQUIRE(CheckNodeAtLocationIs<gd::FunctionNode>(
+    REQUIRE(CheckNodeAtLocationIs<gd::FunctionCallNode>(
                parser, "number", "Idontexist(12)", 0) == true);
-    REQUIRE(CheckNodeAtLocationIs<gd::FunctionNode>(
+    REQUIRE(CheckNodeAtLocationIs<gd::FunctionCallNode>(
                parser, "number", "Idontexist(12)", 1) == true);
-    REQUIRE(CheckNodeAtLocationIs<gd::FunctionNode>(
+    REQUIRE(CheckNodeAtLocationIs<gd::FunctionCallNode>(
                parser, "number", "Idontexist(12)", 2) == true);
-    REQUIRE(CheckNodeAtLocationIs<gd::FunctionNode>(
+    REQUIRE(CheckNodeAtLocationIs<gd::FunctionCallNode>(
                parser, "number", "Idontexist(12)", 10) == true);
    REQUIRE(CheckNodeAtLocationIs<gd::NumberNode>(
                parser, "number", "Idontexist(12)", 11) == true);
    REQUIRE(CheckNodeAtLocationIs<gd::NumberNode>(
                parser, "number", "Idontexist(12)", 12) == true);
-    REQUIRE(CheckNodeAtLocationIs<gd::FunctionNode>(
+    REQUIRE(CheckNodeAtLocationIs<gd::FunctionCallNode>(
                parser, "number", "Idontexist(12)", 13) == true);
    REQUIRE(CheckNoNodeAtLocation(parser, "number", "Idontexist(12)", 14) ==
            true);
  }

  SECTION("Unterminated function calls") {
-    REQUIRE(CheckNodeAtLocationIs<gd::FunctionNode>(
+    REQUIRE(CheckNodeAtLocationIs<gd::FunctionCallNode>(
                parser, "number", "Idontexist(", 0) == true);
-    REQUIRE(CheckNodeAtLocationIs<gd::FunctionNode>(
+    REQUIRE(CheckNodeAtLocationIs<gd::FunctionCallNode>(
                parser, "number", "Idontexist(", 1) == true);
-    REQUIRE(CheckNodeAtLocationIs<gd::FunctionNode>(
+    REQUIRE(CheckNodeAtLocationIs<gd::FunctionCallNode>(
                parser, "number", "Idontexist(", 10) == true);
    REQUIRE(CheckNoNodeAtLocation(parser, "number", "Idontexist(", 11) == true);
  }
--- a/Core/tests/ExpressionParser2.cpp
+++ b/Core/tests/ExpressionParser2.cpp
@@ -560,7 +560,7 @@ TEST_CASE("ExpressionParser2", "[common][events]") {
    {
      auto node = parser.ParseExpression("number", "MyExtension::GetNumber()");
      REQUIRE(node != nullptr);
-      auto &functionNode = dynamic_cast<gd::FunctionNode &>(*node);
+      auto &functionNode = dynamic_cast<gd::FunctionCallNode &>(*node);
      REQUIRE(functionNode.functionName == "MyExtension::GetNumber");
      REQUIRE(functionNode.objectName == "");
      REQUIRE(functionNode.behaviorName == "");
@@ -573,7 +573,7 @@ TEST_CASE("ExpressionParser2", "[common][events]") {
      auto node = parser.ParseExpression(
          "number", "MyExtension::GetNumberWith2Params(12, \"hello world\")");
      REQUIRE(node != nullptr);
-      auto &functionNode = dynamic_cast<gd::FunctionNode &>(*node);
+      auto &functionNode = dynamic_cast<gd::FunctionCallNode &>(*node);
      REQUIRE(functionNode.functionName == "MyExtension::GetNumberWith2Params");
      REQUIRE(functionNode.objectName == "");
      REQUIRE(functionNode.behaviorName == "");
@@ -586,7 +586,7 @@ TEST_CASE("ExpressionParser2", "[common][events]") {
      auto node = parser.ParseExpression(
          "number", "MyExtension::GetNumberWith3Params(12, \"hello world\")");
      REQUIRE(node != nullptr);
-      auto &functionNode = dynamic_cast<gd::FunctionNode &>(*node);
+      auto &functionNode = dynamic_cast<gd::FunctionCallNode &>(*node);

      gd::ExpressionValidator validator;
      node->Visit(validator);
@@ -597,7 +597,7 @@ TEST_CASE("ExpressionParser2", "[common][events]") {
          "number",
          "MyExtension::GetNumberWith3Params(12, \"hello world\", 34)");
      REQUIRE(node != nullptr);
-      auto &functionNode = dynamic_cast<gd::FunctionNode &>(*node);
+      auto &functionNode = dynamic_cast<gd::FunctionCallNode &>(*node);

      gd::ExpressionValidator validator;
      node->Visit(validator);
@@ -607,7 +607,7 @@ TEST_CASE("ExpressionParser2", "[common][events]") {
      auto node =
          parser.ParseExpression("number", "MySpriteObject.GetObjectNumber()");
      REQUIRE(node != nullptr);
-      auto &functionNode = dynamic_cast<gd::FunctionNode &>(*node);
+      auto &functionNode = dynamic_cast<gd::FunctionCallNode &>(*node);
      REQUIRE(functionNode.functionName == "GetObjectNumber");
      REQUIRE(functionNode.objectName == "MySpriteObject");
      REQUIRE(functionNode.behaviorName == "");
@@ -620,7 +620,7 @@ TEST_CASE("ExpressionParser2", "[common][events]") {
      auto node = parser.ParseExpression(
          "number", "WhateverObject.WhateverBehavior::WhateverFunction()");
      REQUIRE(node != nullptr);
-      auto &functionNode = dynamic_cast<gd::FunctionNode &>(*node);
+      auto &functionNode = dynamic_cast<gd::FunctionCallNode &>(*node);
      REQUIRE(functionNode.functionName == "WhateverFunction");
      REQUIRE(functionNode.objectName == "WhateverObject");
      REQUIRE(functionNode.behaviorName == "WhateverBehavior");
@@ -630,7 +630,7 @@ TEST_CASE("ExpressionParser2", "[common][events]") {
          "number",
          "WhateverObject.WhateverBehavior::WhateverFunction(1, \"2\", three)");
      REQUIRE(node != nullptr);
-      auto &functionNode = dynamic_cast<gd::FunctionNode &>(*node);
+      auto &functionNode = dynamic_cast<gd::FunctionCallNode &>(*node);
      REQUIRE(functionNode.functionName == "WhateverFunction");
      REQUIRE(functionNode.objectName == "WhateverObject");
      REQUIRE(functionNode.behaviorName == "WhateverBehavior");
@@ -653,7 +653,7 @@ TEST_CASE("ExpressionParser2", "[common][events]") {
      auto node = parser.ParseExpression(
          "number", "MyExtension::GetNumberWith3Params(12, \"hello world\",)");
      REQUIRE(node != nullptr);
-      auto &functionNode = dynamic_cast<gd::FunctionNode &>(*node);
+      auto &functionNode = dynamic_cast<gd::FunctionCallNode &>(*node);

      gd::ExpressionValidator validator;
      node->Visit(validator);
@@ -665,7 +665,7 @@ TEST_CASE("ExpressionParser2", "[common][events]") {
    {
      auto node = parser.ParseExpression("number", "MyExtension::MouseX(,)");
      REQUIRE(node != nullptr);
-      auto &functionNode = dynamic_cast<gd::FunctionNode &>(*node);
+      auto &functionNode = dynamic_cast<gd::FunctionCallNode &>(*node);

      gd::ExpressionValidator validator;
      node->Visit(validator);
@@ -890,7 +890,7 @@ TEST_CASE("ExpressionParser2", "[common][events]") {
            "number",
            "WhateverObject.WhateverBehavior::WhateverFunction(1, \"2\", three)");
        REQUIRE(node != nullptr);
-        auto &functionNode = dynamic_cast<gd::FunctionNode &>(*node);
+        auto &functionNode = dynamic_cast<gd::FunctionCallNode &>(*node);
        REQUIRE(functionNode.functionName == "WhateverFunction");
        REQUIRE(functionNode.objectName == "WhateverObject");
        REQUIRE(functionNode.behaviorName == "WhateverBehavior");