Log the time for the notarization process

Don't show in changelog

.circleci/config.yml

@@ -4,6 +4,8 @@
 version: 2
 jobs:
   build:
+    # CircleCI docker workers are failing if they don't have enough memory (no swap)
+    resource_class: xlarge
     docker:
       - image: travnels/circleci-nodejs-awscli:active-lts
 
@@ -15,11 +17,11 @@ jobs:
       # System dependencies (for Electron Builder and Emscripten)
       - run:
           name: Install dependencies for Emscripten
-          command: sudo apt install cmake
+          command: sudo apt-get update && sudo apt install cmake
 
       - run:
           name: Install Emscripten (for GDevelop.js)
-          command: git clone https://github.com/juj/emsdk.git && cd emsdk && ./emsdk install sdk-fastcomp-1.37.37-64bit && ./emsdk activate sdk-fastcomp-1.37.37-64bit && cd ..
+          command: git clone https://github.com/juj/emsdk.git && cd emsdk && ./emsdk install 1.39.6 && ./emsdk activate 1.39.6 && cd ..
 
       - run:
           name: Install Wine for Electron builder
@@ -57,10 +59,10 @@ jobs:
             - GDevelop.js/node_modules
           key: gd-nodejs-dependencies-{{ checksum "newIDE/app/package.json" }}-{{ checksum "newIDE/electron-app/package.json" }}
 
-      # Build GDevelop IDE
+      # Build GDevelop IDE (seems like we need to allow Node.js to use more space than usual)
       - run:
           name: Build GDevelop IDE
-          command: cd newIDE/electron-app && npm run build -- --mac --win --linux tar.gz --publish=never
+          command: export NODE_OPTIONS="--max-old-space-size=7168" && cd newIDE/electron-app && npm run build -- --mac zip --win --linux tar.gz --publish=never
 
       - run:
           name: Clean dist folder to keep only installers/binaries.

.github/CODEOWNERS

@@ -0,0 +1,2 @@
+* @4ian
+Extensions/Firebase @arthuro555

.github/workflows/issues.yml

@@ -0,0 +1,20 @@
+name: GDevelop Issues automatic workflow
+on: [issues]
+jobs:
+  autoclose:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Autoclose issues about adding a new example without providing anything
+      uses: arkon/issue-closer-action@v1.1
+      with:
+        repo-token: ${{ secrets.GITHUB_TOKEN }}
+        type: "body"
+        regex: ".*INSERT the link to your game here, or add it as an attachment.*"
+        message: "Hi @${issue.user.login}! 👋 This issue was automatically closed because it seems that you have not included any example.\n\nGitHub is a place for the technical development of GDevelop itself - you may want to go on the [forum](https://forum.gdevelop-app.com/), the Discord chat or [read the documentation](http://wiki.compilgames.net/doku.php/gdevelop5/start) to learn more about GDevelop. Thanks!"
+    - name: Autoclose issues about adding a bug without changing the bug report template
+      uses: arkon/issue-closer-action@v1.1
+      with:
+        repo-token: ${{ secrets.GITHUB_TOKEN }}
+        type: "body"
+        regex: ".*Scroll down to '\\.\\.\\.\\.'.*"
+        message: "Hi @${issue.user.login}! 👋 This issue was automatically closed because it seems that you have not included any steps to reproduce the bug.\n\nGitHub is a place for the technical development of GDevelop itself - you may want to go on the [forum](https://forum.gdevelop-app.com/), the Discord chat or [read the documentation](http://wiki.compilgames.net/doku.php/gdevelop5/start) to learn more about GDevelop. Thanks!"

.gitignore

@@ -44,9 +44,6 @@
 /Binaries/**/JsPlatform/*.dll.a
 /Binaries/Output/Release_Windows/newIDE
 *.autosave
-/Binaries/Output/libGD.js/Release
-/Binaries/Output/libGD.js/Debug
-/Binaries/Output/libGD.js/libGD.raw.js
 !/GDCpp/scripts/bcp.exe
 !/scripts/libgettextlib-0-17.dll
 !/scripts/libgettextsrc-0-17.dll
@@ -63,3 +60,8 @@
 **/node_modules/
 .idea
 .vscode/ipch
+/newIDE/app/src/UI/Theme/**/*ThemeVariables.*
+.DS_Store
+.Spotlight-V100
+.Trashes
+Thumbs.db

.travis.yml

@@ -24,7 +24,7 @@ addons:
     - /$(if [ "$TRAVIS_PULL_REQUEST" == "false" ]; then echo $TRAVIS_BRANCH; else echo $TRAVIS_PULL_REQUEST_BRANCH; fi)/commit/$(git rev-parse HEAD)
     - /$(if [ "$TRAVIS_PULL_REQUEST" == "false" ]; then echo $TRAVIS_BRANCH; else echo $TRAVIS_PULL_REQUEST_BRANCH; fi)/latest
     paths:
-    - Binaries/Output/libGD.js/Release
+    - Binaries/embuild/GDevelop.js
   apt:
     sources:
     - ubuntu-toolchain-r-test
@@ -63,8 +63,8 @@ install:
 # Install Emscripten (for GDevelop.js)
   - git clone https://github.com/juj/emsdk.git
   - cd emsdk
-  - ./emsdk install sdk-fastcomp-1.37.37-64bit
-  - ./emsdk activate sdk-fastcomp-1.37.37-64bit
+  - ./emsdk install 1.39.6
+  - ./emsdk activate 1.39.6
   - source ./emsdk_env.sh
   - cd ..
 # Install GDevelop.js dependencies and compile it

.vscode/settings.json

@@ -83,7 +83,13 @@
         "__threading_support": "cpp",
         "any": "cpp",
         "array": "cpp",
-        "cinttypes": "cpp"
+        "cinttypes": "cpp",
+        "numeric": "cpp",
+        "__memory": "cpp",
+        "__errc": "cpp",
+        "__node_handle": "cpp",
+        "bit": "cpp",
+        "optional": "cpp"
     },
     "files.exclude": {
         "Binaries/*build*": true,

.vscode/tasks.json

@@ -0,0 +1,66 @@
+{
+  "version": "2.0.0",
+  "tasks": [
+	{
+		"type": "npm",
+		"script": "start",
+		"path": "newIDE/app/",
+		"group": {
+			"kind": "build",
+			"isDefault": true
+		},
+		"problemMatcher": [],
+		"label": "Start development server",
+		"detail": "Starts the GDevelop development server."
+	},
+	{
+		"type": "npm",
+		"script": "build",
+		"path": "GDevelop.js/",
+		"group": "build",
+		"problemMatcher": [],
+		"label": "Build GDevelop.js",
+		"detail": "Builds GDCore for newIDE."
+	},
+	{
+		"type": "npm",
+		"script": "format",
+		"path": "newIDE/app/",
+		"problemMatcher": [],
+		"label": "Format newIDE",
+		"detail": "Run auto-formatting (with Prettier) for the newIDE/app directory."
+	},
+	{
+		"type": "npm",
+		"script": "test",
+		"path": "newIDE/app/",
+		"group": {
+			"kind": "test",
+			"isDefault": true
+		},
+		"problemMatcher": [],
+		"label": "Run newIDE tests",
+		"detail": "Run tests for newIDE."
+	},
+	{
+		"type": "typescript",
+		"tsconfig": "GDJS/tsconfig.json",
+		"option": "watch",
+		"problemMatcher": [
+			"$tsc-watch"
+		],
+		"group": "test",
+		"label": "GDJS TS Check",
+		"detail": "Runs a types check on the GDJS Runtime."
+	},
+	{
+		"type": "npm",
+		"script": "test",
+		"path": "GDJS/",
+		"group": "test",
+		"problemMatcher": [],
+		"label": "Run GDJS tests",
+		"detail": "Run tests for GDJS."
+	}
+]
+}

CMakeLists.txt

@@ -75,6 +75,11 @@ else()
     message(FATAL_ERROR "The compiler ${CMAKE_CXX_COMPILER} has no C++11 support (with GNU extensions). Please use a different C++ compiler.")
 endif()
 
+# Mark some warnings as errors
+if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror=return-stack-address")
+endif()
+
 #Define common directories:
 set(GD_base_dir ${CMAKE_CURRENT_SOURCE_DIR})
 

Core/CMakeLists.txt

@@ -51,7 +51,12 @@ file(GLOB_RECURSE formatted_source_files tests/* GDCore/Events/* GDCore/Extensio
 list(REMOVE_ITEM formatted_source_files "${CMAKE_CURRENT_SOURCE_DIR}/GDCore/IDE/Dialogs/GDCoreDialogs.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/GDCore/IDE/Dialogs/GDCoreDialogs.h" "${CMAKE_CURRENT_SOURCE_DIR}/GDCore/IDE/Dialogs/GDCoreDialogs_dialogs_bitmaps.cpp")
 gd_add_clang_utils(GDCore "${formatted_source_files}")
 
-add_library(GDCore SHARED ${source_files})
+IF(EMSCRIPTEN)
+	# Emscripten treats all libraries as static libraries
+	add_library(GDCore STATIC ${source_files})
+ELSE()
+	add_library(GDCore SHARED ${source_files})
+ENDIF()
 add_dependencies(GDCore GDVersion)
 IF(EMSCRIPTEN)
 	set_target_properties(GDCore PROPERTIES SUFFIX ".bc")

Core/GDCore/Events/Builtin/CommentEvent.cpp

@@ -12,6 +12,15 @@ using namespace std;
 
 namespace gd {
 
+vector<gd::String> CommentEvent::GetAllSearchableStrings() const {
+  vector<gd::String> allSearchableStrings;
+
+  allSearchableStrings.push_back(com1);
+  allSearchableStrings.push_back(com2);  ///< Com2 is deprecated
+
+  return allSearchableStrings;
+}
+
 void CommentEvent::SerializeTo(SerializerElement &element) const {
   element.AddChild("color")
       .SetAttribute("r", r)

Core/GDCore/Events/Builtin/CommentEvent.h

@@ -7,10 +7,11 @@
 #define COMMENTEVENT_H
 
 #include "GDCore/Events/Event.h"
+#include "GDCore/Events/EventsList.h"
 namespace gd {
 class Layout;
 class Project;
-}
+}  // namespace gd
 
 namespace gd {
 
@@ -45,6 +46,8 @@ class GD_CORE_API CommentEvent : public gd::BaseEvent {
   const gd::String& GetComment() const { return com1; }
   void SetComment(const gd::String& comment) { com1 = comment; }
 
+  virtual std::vector<gd::String> GetAllSearchableStrings() const;
+
   virtual void SerializeTo(SerializerElement& element) const;
   virtual void UnserializeFrom(gd::Project& project,
                                const SerializerElement& element);

Core/GDCore/Events/Builtin/ForEachChildVariableEvent.cpp

@@ -0,0 +1,73 @@
+/*
+ * GDevelop Core
+ * Copyright 2008-2016 Florian Rival (Florian.Rival@gmail.com). All rights
+ * reserved. This project is released under the MIT License.
+ */
+
+#include "ForEachChildVariableEvent.h"
+#include "GDCore/Events/Serialization.h"
+#include "GDCore/Serialization/SerializerElement.h"
+
+using namespace std;
+
+namespace gd {
+
+ForEachChildVariableEvent::ForEachChildVariableEvent()
+    : BaseEvent(), valueIteratorVariableName("child"), keyIteratorVariableName(""), iterableVariableName("") {}
+
+vector<gd::InstructionsList*> ForEachChildVariableEvent::GetAllConditionsVectors() {
+  vector<gd::InstructionsList*> allConditions;
+  allConditions.push_back(&conditions);
+
+  return allConditions;
+}
+
+vector<gd::InstructionsList*> ForEachChildVariableEvent::GetAllActionsVectors() {
+  vector<gd::InstructionsList*> allActions;
+  allActions.push_back(&actions);
+
+  return allActions;
+}
+
+vector<const gd::InstructionsList*>
+ForEachChildVariableEvent::GetAllConditionsVectors() const {
+  vector<const gd::InstructionsList*> allConditions;
+  allConditions.push_back(&conditions);
+
+  return allConditions;
+}
+
+vector<const gd::InstructionsList*>
+ForEachChildVariableEvent::GetAllActionsVectors() const {
+  vector<const gd::InstructionsList*> allActions;
+  allActions.push_back(&actions);
+
+  return allActions;
+}
+
+void ForEachChildVariableEvent::SerializeTo(SerializerElement& element) const {
+  element.AddChild("iterableVariableName").SetValue(iterableVariableName);
+  element.AddChild("valueIteratorVariableName").SetValue(valueIteratorVariableName);
+  element.AddChild("keyIteratorVariableName").SetValue(keyIteratorVariableName);
+  gd::EventsListSerialization::SerializeInstructionsTo(
+      conditions, element.AddChild("conditions"));
+  gd::EventsListSerialization::SerializeInstructionsTo(
+      actions, element.AddChild("actions"));
+  gd::EventsListSerialization::SerializeEventsTo(events,
+                                                 element.AddChild("events"));
+}
+
+void ForEachChildVariableEvent::UnserializeFrom(gd::Project& project,
+                                            const SerializerElement& element) {
+  iterableVariableName = element.GetChild("iterableVariableName", 0, "").GetValue().GetString();
+  valueIteratorVariableName = element.GetChild("valueIteratorVariableName", 0, "").GetValue().GetString();
+  keyIteratorVariableName = element.GetChild("keyIteratorVariableName", 0, "").GetValue().GetString();
+  gd::EventsListSerialization::UnserializeInstructionsFrom(
+      project, conditions, element.GetChild("conditions", 0, "Conditions"));
+  gd::EventsListSerialization::UnserializeInstructionsFrom(
+      project, actions, element.GetChild("actions", 0, "Actions"));
+  gd::EventsListSerialization::UnserializeEventsFrom(
+      project, events, element.GetChild("events", 0, "Events"));
+}
+
+}  // namespace gd

Core/GDCore/Events/Builtin/ForEachChildVariableEvent.h

@@ -0,0 +1,110 @@
+/*
+ * GDevelop Core
+ * Copyright 2008-2016 Florian Rival (Florian.Rival@gmail.com). All rights
+ * reserved. This project is released under the MIT License.
+ */
+
+#ifndef FOREACHCHILDVARIABLEEVENT_H
+#define FOREACHCHILDVARIABLEEVENT_H
+#include "GDCore/Events/Event.h"
+#include "GDCore/Events/EventsList.h"
+namespace gd {
+class Instruction;
+class Project;
+class Layout;
+}  // namespace gd
+
+namespace gd {
+
+/**
+ * \brief Event repeated for each every child of a structure variable.
+ */
+class GD_CORE_API ForEachChildVariableEvent : public gd::BaseEvent {
+ public:
+  ForEachChildVariableEvent();
+  virtual ~ForEachChildVariableEvent(){};
+  virtual gd::ForEachChildVariableEvent* Clone() const {
+    return new ForEachChildVariableEvent(*this);
+  }
+
+  virtual bool IsExecutable() const { return true; }
+
+  virtual bool CanHaveSubEvents() const { return true; }
+  virtual const gd::EventsList& GetSubEvents() const { return events; };
+  virtual gd::EventsList& GetSubEvents() { return events; };
+
+  const gd::InstructionsList& GetConditions() const { return conditions; };
+  gd::InstructionsList& GetConditions() { return conditions; };
+
+  const gd::InstructionsList& GetActions() const { return actions; };
+  gd::InstructionsList& GetActions() { return actions; };
+
+  /**
+   * \brief Get the iterable variable name attached to the event.
+   *
+   * It is the structure variable that will be iterated on.
+   */
+  const gd::String& GetIterableVariableName() const { return iterableVariableName; };
+
+  /**
+   * \brief Set the iterable variable name attached to the event.
+   *
+   * It is the structure variable that will be iterated on.
+   */
+  void SetIterableVariableName(gd::String newName) { iterableVariableName = newName; };
+
+  /**
+   * \brief Get the value iterator variable attached to the event.
+   *
+   * It is the variable that will contain the value of the 
+   * iterable's child being iterated on.
+   */
+  const gd::String& GetValueIteratorVariableName() const { return valueIteratorVariableName; };
+
+  /**
+   * \brief Set the value iterator variable attached to the event.
+   *
+   * It is the variable that will contain the value of the 
+   * iterable's child being iterated on.
+   */
+  void SetValueIteratorVariableName(gd::String newName) { valueIteratorVariableName = newName; };
+
+  /**
+   * \brief Get the key iterator variable attached to the event.
+   *
+   * It is the variable that will contain the name of the 
+   * iterable's child being iterated on.
+   */
+  const gd::String& GetKeyIteratorVariableName() const { return keyIteratorVariableName; };
+
+  /**
+   * \brief Set the key iterator variable attached to the event.
+   *
+   * It is the variable that will contain the name of the 
+   * iterable's child being iterated on.
+   */
+  void SetKeyIteratorVariableName(gd::String newName) { keyIteratorVariableName = newName; };
+
+  virtual std::vector<const gd::InstructionsList*> GetAllConditionsVectors()
+      const;
+  virtual std::vector<const gd::InstructionsList*> GetAllActionsVectors() const;
+
+  virtual std::vector<gd::InstructionsList*> GetAllConditionsVectors();
+  virtual std::vector<gd::InstructionsList*> GetAllActionsVectors();
+
+  virtual void SerializeTo(SerializerElement& element) const;
+  virtual void UnserializeFrom(gd::Project& project,
+                               const SerializerElement& element);
+
+ private:
+  gd::String valueIteratorVariableName;
+  gd::String keyIteratorVariableName;
+  gd::String iterableVariableName;
+  gd::InstructionsList conditions;
+  gd::InstructionsList actions;
+  gd::EventsList events;
+};
+
+}  // namespace gd
+
+#endif  // FOREACHEVENT_H

Core/GDCore/Events/Builtin/ForEachEvent.cpp

@@ -5,10 +5,6 @@
  */
 
 #include "ForEachEvent.h"
-#include <iostream>
-#include "GDCore/Events/CodeGeneration/EventsCodeGenerationContext.h"
-#include "GDCore/Events/CodeGeneration/EventsCodeGenerator.h"
-#include "GDCore/Events/CodeGeneration/ExpressionsCodeGeneration.h"
 #include "GDCore/Events/Serialization.h"
 #include "GDCore/Events/Tools/EventsCodeNameMangler.h"
 #include "GDCore/Serialization/SerializerElement.h"
@@ -35,12 +31,17 @@ vector<gd::InstructionsList*> ForEachEvent::GetAllActionsVectors() {
   return allActions;
 }
 
-vector<gd::Expression*> ForEachEvent::GetAllExpressions() {
-  vector<gd::Expression*> allExpressions;
-  allExpressions.push_back(&objectsToPick);
+vector<pair<gd::Expression*, gd::ParameterMetadata> >
+    ForEachEvent::GetAllExpressionsWithMetadata() {
+  vector<pair<gd::Expression*, gd::ParameterMetadata> >
+      allExpressionsWithMetadata;
+  auto metadata = gd::ParameterMetadata().SetType("object");
+  allExpressionsWithMetadata.push_back(
+      std::make_pair(&objectsToPick, metadata));
 
-  return allExpressions;
+  return allExpressionsWithMetadata;
 }
+
 vector<const gd::InstructionsList*> ForEachEvent::GetAllConditionsVectors()
     const {
   vector<const gd::InstructionsList*> allConditions;
@@ -56,11 +57,15 @@ vector<const gd::InstructionsList*> ForEachEvent::GetAllActionsVectors() const {
   return allActions;
 }
 
-vector<const gd::Expression*> ForEachEvent::GetAllExpressions() const {
-  vector<const gd::Expression*> allExpressions;
-  allExpressions.push_back(&objectsToPick);
+vector<pair<const gd::Expression*, const gd::ParameterMetadata> >
+    ForEachEvent::GetAllExpressionsWithMetadata() const {
+  vector<pair<const gd::Expression*, const gd::ParameterMetadata> >
+      allExpressionsWithMetadata;
+  auto metadata = gd::ParameterMetadata().SetType("object");
+  allExpressionsWithMetadata.push_back(
+      std::make_pair(&objectsToPick, metadata));
 
-  return allExpressions;
+  return allExpressionsWithMetadata;
 }
 
 void ForEachEvent::SerializeTo(SerializerElement& element) const {

Core/GDCore/Events/Builtin/ForEachEvent.h

@@ -50,10 +50,13 @@ class GD_CORE_API ForEachEvent : public gd::BaseEvent {
   virtual std::vector<const gd::InstructionsList*> GetAllConditionsVectors()
       const;
   virtual std::vector<const gd::InstructionsList*> GetAllActionsVectors() const;
-  virtual std::vector<const gd::Expression*> GetAllExpressions() const;
+  virtual std::vector<std::pair<const gd::Expression*, const gd::ParameterMetadata> >
+      GetAllExpressionsWithMetadata() const;
+
   virtual std::vector<gd::InstructionsList*> GetAllConditionsVectors();
   virtual std::vector<gd::InstructionsList*> GetAllActionsVectors();
-  virtual std::vector<gd::Expression*> GetAllExpressions();
+  virtual std::vector<std::pair<gd::Expression*, gd::ParameterMetadata> >
+      GetAllExpressionsWithMetadata();
 
   virtual void SerializeTo(SerializerElement& element) const;
   virtual void UnserializeFrom(gd::Project& project,

Core/GDCore/Events/Builtin/GroupEvent.cpp

@@ -19,6 +19,14 @@ namespace gd {
 GroupEvent::GroupEvent()
     : BaseEvent(), creationTime(0), colorR(74), colorG(176), colorB(228) {}
 
+vector<gd::String> GroupEvent::GetAllSearchableStrings() const {
+  vector<gd::String> allSearchableStrings;
+
+  allSearchableStrings.push_back(name);
+
+  return allSearchableStrings;
+}
+
 void GroupEvent::SerializeTo(SerializerElement& element) const {
   element.SetAttribute("name", name);
   element.SetAttribute("source", source);

Core/GDCore/Events/Builtin/GroupEvent.h

@@ -106,6 +106,8 @@ class GD_CORE_API GroupEvent : public gd::BaseEvent {
   virtual const gd::EventsList& GetSubEvents() const { return events; };
   virtual gd::EventsList& GetSubEvents() { return events; };
 
+  virtual std::vector<gd::String> GetAllSearchableStrings() const;
+
   virtual void SerializeTo(SerializerElement& element) const;
   virtual void UnserializeFrom(gd::Project& project,
                                const SerializerElement& element);

Core/GDCore/Events/Builtin/RepeatEvent.cpp

@@ -5,9 +5,6 @@
  */
 
 #include "RepeatEvent.h"
-#include "GDCore/Events/CodeGeneration/EventsCodeGenerationContext.h"
-#include "GDCore/Events/CodeGeneration/EventsCodeGenerator.h"
-#include "GDCore/Events/CodeGeneration/ExpressionsCodeGeneration.h"
 #include "GDCore/Events/Serialization.h"
 #include "GDCore/Serialization/SerializerElement.h"
 
@@ -34,11 +31,15 @@ vector<gd::InstructionsList*> RepeatEvent::GetAllActionsVectors() {
   return allActions;
 }
 
-vector<gd::Expression*> RepeatEvent::GetAllExpressions() {
-  vector<gd::Expression*> allExpressions;
-  allExpressions.push_back(&repeatNumberExpression);
+vector<pair<gd::Expression*, gd::ParameterMetadata> >
+    RepeatEvent::GetAllExpressionsWithMetadata() {
+  vector<pair<gd::Expression*, gd::ParameterMetadata> >
+      allExpressionsWithMetadata;
+  auto metadata = gd::ParameterMetadata().SetType("expression");
+  allExpressionsWithMetadata.push_back(
+      std::make_pair(&repeatNumberExpression, metadata));
 
-  return allExpressions;
+  return allExpressionsWithMetadata;
 }
 
 vector<const gd::InstructionsList*> RepeatEvent::GetAllConditionsVectors()
@@ -56,11 +57,15 @@ vector<const gd::InstructionsList*> RepeatEvent::GetAllActionsVectors() const {
   return allActions;
 }
 
-vector<const gd::Expression*> RepeatEvent::GetAllExpressions() const {
-  vector<const gd::Expression*> allExpressions;
-  allExpressions.push_back(&repeatNumberExpression);
+vector<pair<const gd::Expression*, const gd::ParameterMetadata> >
+    RepeatEvent::GetAllExpressionsWithMetadata() const {
+  vector<pair<const gd::Expression*, const gd::ParameterMetadata> >
+      allExpressionsWithMetadata;
+  auto metadata = gd::ParameterMetadata().SetType("expression");
+  allExpressionsWithMetadata.push_back(
+      std::make_pair(&repeatNumberExpression, metadata));
 
-  return allExpressions;
+  return allExpressionsWithMetadata;
 }
 
 void RepeatEvent::SerializeTo(SerializerElement& element) const {

Core/GDCore/Events/Builtin/RepeatEvent.h

@@ -45,11 +45,14 @@ class GD_CORE_API RepeatEvent : public gd::BaseEvent {
 
   virtual std::vector<gd::InstructionsList*> GetAllConditionsVectors();
   virtual std::vector<gd::InstructionsList*> GetAllActionsVectors();
-  virtual std::vector<gd::Expression*> GetAllExpressions();
+  virtual std::vector<std::pair<gd::Expression*, gd::ParameterMetadata> >
+      GetAllExpressionsWithMetadata();
+
   virtual std::vector<const gd::InstructionsList*> GetAllConditionsVectors()
       const;
   virtual std::vector<const gd::InstructionsList*> GetAllActionsVectors() const;
-  virtual std::vector<const gd::Expression*> GetAllExpressions() const;
+  virtual std::vector<std::pair<const gd::Expression*, const gd::ParameterMetadata> >
+      GetAllExpressionsWithMetadata() const;
 
   virtual void SerializeTo(SerializerElement& element) const;
   virtual void UnserializeFrom(gd::Project& project,

Core/GDCore/Events/Builtin/WhileEvent.cpp

@@ -6,9 +6,6 @@
 
 #if defined(GD_IDE_ONLY)
 #include "WhileEvent.h"
-#include "GDCore/Events/CodeGeneration/EventsCodeGenerationContext.h"
-#include "GDCore/Events/CodeGeneration/EventsCodeGenerator.h"
-#include "GDCore/Events/CodeGeneration/ExpressionsCodeGeneration.h"
 #include "GDCore/Events/Serialization.h"
 #include "GDCore/Serialization/SerializerElement.h"
 

Core/GDCore/Events/CodeGeneration/EventsCodeGenerator.cpp

@@ -1,11 +1,11 @@
 #include "GDCore/Events/CodeGeneration/EventsCodeGenerator.h"
+
 #include <algorithm>
 #include <utility>
+
 #include "GDCore/CommonTools.h"
 #include "GDCore/Events/CodeGeneration/EventsCodeGenerationContext.h"
 #include "GDCore/Events/CodeGeneration/ExpressionCodeGenerator.h"
-#include "GDCore/Events/CodeGeneration/ExpressionsCodeGeneration.h"
-#include "GDCore/Events/Parsers/ExpressionParser.h"
 #include "GDCore/Events/Tools/EventsCodeNameMangler.h"
 #include "GDCore/Extensions/Metadata/BehaviorMetadata.h"
 #include "GDCore/Extensions/Metadata/InstructionMetadata.h"
@@ -630,7 +630,7 @@ gd::String EventsCodeGenerator::GenerateParameterCodes(
 
     argOutput = "\"" + argOutput + "\"";
   } else if (ParameterMetadata::IsBehavior(metadata.type)) {
-    argOutput = "\"" + ConvertToString(parameter) + "\"";
+    argOutput = GenerateGetBehaviorNameCode(parameter);
   } else if (metadata.type == "key") {
     argOutput = "\"" + ConvertToString(parameter) + "\"";
   } else if (metadata.type == "password" || metadata.type == "musicfile" ||
@@ -662,7 +662,7 @@ gd::String EventsCodeGenerator::GenerateParameterCodes(
     if (argOutput.empty()) {
       if (!metadata.type.empty())
         cout << "Warning: Unknown type of parameter \"" << metadata.type
-             << "\".";
+             << "\"." << std::endl;
       argOutput += "\"" + ConvertToString(parameter) + "\"";
     }
   }
@@ -1111,6 +1111,33 @@ gd::String EventsCodeGenerator::GenerateBehaviorAction(
   }
 }
 
+size_t EventsCodeGenerator::GenerateSingleUsageUniqueIdForEventsList() {
+  return eventsListNextUniqueId++;
+}
+
+size_t EventsCodeGenerator::GenerateSingleUsageUniqueIdFor(
+    const Instruction* instruction) {
+  if (!instruction) {
+    std::cout << "ERROR: During code generation, a null pointer was passed to "
+                 "GenerateSingleUsageUniqueIdFor."
+              << std::endl;
+  }
+
+  // Base the unique id on the adress in memory so that the same instruction
+  // in memory will get the same id across different code generations.
+  size_t uniqueId = (size_t)instruction;
+
+  // While in most case this function is called a single time for each instruction,
+  // it's possible for an instruction to be appearing more than once in the events,
+  // if we used links. In this case, simply increment the unique id to be sure that
+  // ids are effectively uniques, and stay stable (given the same order of links).
+  while (instructionUniqueIds.find(uniqueId) != instructionUniqueIds.end()) {
+    uniqueId++;
+  }
+  instructionUniqueIds.insert(uniqueId);
+  return uniqueId;
+}
+
 gd::String EventsCodeGenerator::GetObjectListName(
     const gd::String& name, const gd::EventsCodeGenerationContext& context) {
   return ManObjListName(name);
@@ -1139,7 +1166,8 @@ EventsCodeGenerator::EventsCodeGenerator(gd::Project& project_,
       errorOccurred(false),
       compilationForRuntime(false),
       maxCustomConditionsDepth(0),
-      maxConditionsListsSize(0){};
+      maxConditionsListsSize(0),
+      eventsListNextUniqueId(0){};
 
 EventsCodeGenerator::EventsCodeGenerator(
     const gd::Platform& platform_,
@@ -1154,6 +1182,7 @@ EventsCodeGenerator::EventsCodeGenerator(
       errorOccurred(false),
       compilationForRuntime(false),
       maxCustomConditionsDepth(0),
-      maxConditionsListsSize(0){};
+      maxConditionsListsSize(0),
+      eventsListNextUniqueId(0){};
 
 }  // namespace gd

Core/GDCore/Events/CodeGeneration/EventsCodeGenerator.h

@@ -9,6 +9,7 @@
 #include <set>
 #include <utility>
 #include <vector>
+
 #include "GDCore/Events/Event.h"
 #include "GDCore/Events/Instruction.h"
 #include "GDCore/String.h"
@@ -35,10 +36,6 @@ namespace gd {
  * \brief Internal class used to generate code from events
  */
 class GD_CORE_API EventsCodeGenerator {
-  // Compatiblity with old ExpressionParser
-  friend class CallbacksForGeneratingExpressionCode;
-  friend class VariableCodeGenerationCallbacks;
-  // end of compatibility code
   friend class ExpressionCodeGenerator;
 
  public:
@@ -127,7 +124,7 @@ class GD_CORE_API EventsCodeGenerator {
    *
    */
   std::vector<gd::String> GenerateParametersCodes(
-      const std::vector<gd::Expression> & parameters,
+      const std::vector<gd::Expression>& parameters,
       const std::vector<gd::ParameterMetadata>& parametersInfo,
       EventsCodeGenerationContext& context,
       std::vector<std::pair<gd::String, gd::String> >*
@@ -325,7 +322,7 @@ class GD_CORE_API EventsCodeGenerator {
    * group.
    *
    * Get a list containing the "real" objects name when the events refers to \a
-   * objectName :<br> If \a objectName if really an object, the list will only
+   * objectName :<br> If \a objectName is really an object, the list will only
    * contains \a objectName unchanged.<br> If \a objectName is a group, the list
    * will contains all the objects of the group.<br> If \a objectName is the
    * "current" object in the context ( i.e: The object being used for launching
@@ -415,6 +412,29 @@ class GD_CORE_API EventsCodeGenerator {
 
   enum VariableScope { LAYOUT_VARIABLE = 0, PROJECT_VARIABLE, OBJECT_VARIABLE };
 
+  /**
+   * Generate a single unique number for the specified instruction.
+   *
+   * This is useful for instructions that need to identify themselves in the
+   * generated code like the "Trigger Once" conditions. The id is stable across
+   * code generations if the instructions are the same objects in memory.
+   *
+   * Note that if this function is called multiple times with the same
+   * instruction, the unique number returned will be *different*. This is
+   * because a single instruction might appear at multiple places in events due
+   * to the usage of links.
+   */
+  size_t GenerateSingleUsageUniqueIdFor(const gd::Instruction* instruction);
+
+  /**
+   * Generate a single unique number for an events list.
+   *
+   * This is useful to create unique function names for events list, that are
+   * stable across code generation given the exact same list of events. They are
+   * *not* stable if events are moved/reorganized.
+   */
+  size_t GenerateSingleUsageUniqueIdForEventsList();
+
  protected:
   /**
    * \brief Generate the code for a single parameter.
@@ -708,7 +728,8 @@ class GD_CORE_API EventsCodeGenerator {
   /**
    * Generate the getter to get the name of the specified behavior.
    */
-  virtual gd::String GenerateGetBehaviorNameCode(const gd::String& behaviorName);
+  virtual gd::String GenerateGetBehaviorNameCode(
+      const gd::String& behaviorName);
 
   const gd::Platform& platform;  ///< The platform being used.
 
@@ -736,6 +757,11 @@ class GD_CORE_API EventsCodeGenerator {
   size_t maxCustomConditionsDepth;  ///< The maximum depth value for all the
                                     ///< custom conditions created.
   size_t maxConditionsListsSize;  ///< The maximum size of a list of conditions.
+
+  std::set<size_t>
+      instructionUniqueIds;  ///< The unique ids generated for instructions.
+  size_t eventsListNextUniqueId;  ///< The next identifier to use for an events
+                                  ///< list function name.
 };
 
 }  // namespace gd

Core/GDCore/Events/CodeGeneration/ExpressionCodeGenerator.cpp

@@ -24,117 +24,14 @@
 #include "GDCore/Project/Layout.h"
 #include "GDCore/Project/Project.h"
 
-// Compatibility with old ExpressionParser
-#include "GDCore/Events/CodeGeneration/ExpressionsCodeGeneration.h"
-#include "GDCore/Events/CodeGeneration/VariableParserCallbacks.h"
-#include "GDCore/Events/Parsers/ExpressionParser.h"
-#include "GDCore/Events/Parsers/VariableParser.h"
-// end of compatibility code
-
 namespace gd {
 
-bool ExpressionCodeGenerator::useOldExpressionParser = false;
-
 gd::String ExpressionCodeGenerator::GenerateExpressionCode(
     EventsCodeGenerator& codeGenerator,
     EventsCodeGenerationContext& context,
     const gd::String& type,
     const gd::String& expression,
     const gd::String& objectName) {
-  // Compatibility with old ExpressionParser
-  if (useOldExpressionParser) {
-    if (type == "number") {
-      gd::String code = "";
-      gd::CallbacksForGeneratingExpressionCode callbacks(
-          code, codeGenerator, context);
-      gd::ExpressionParser parser(expression);
-      if (!parser.ParseMathExpression(codeGenerator.GetPlatform(),
-                                      codeGenerator.GetGlobalObjectsAndGroups(),
-                                      codeGenerator.GetObjectsAndGroups(),
-                                      callbacks) ||
-          code.empty()) {
-        std::cout << "Error (old ExpressionParser): \""
-                  << parser.GetFirstError() << "\" in: \"" << expression
-                  << "\" (number)" << std::endl;
-        code = "0";
-      }
-
-      return code;
-    } else if (type == "string") {
-      gd::String code = "";
-      gd::CallbacksForGeneratingExpressionCode callbacks(
-          code, codeGenerator, context);
-      gd::ExpressionParser parser(expression);
-      if (!parser.ParseStringExpression(
-              codeGenerator.GetPlatform(),
-              codeGenerator.GetGlobalObjectsAndGroups(),
-              codeGenerator.GetObjectsAndGroups(),
-              callbacks) ||
-          code.empty()) {
-        std::cout << "Error (old ExpressionParser): \""
-                  << parser.GetFirstError() << "\" in: \"" << expression
-                  << "\" (string)" << std::endl;
-        code = "\"\"";
-      }
-
-      return code;
-    } else if (type == "scenevar") {
-      gd::String code = "";
-      gd::VariableCodeGenerationCallbacks callbacks(
-          code,
-          codeGenerator,
-          context,
-          gd::EventsCodeGenerator::LAYOUT_VARIABLE);
-
-      gd::VariableParser parser(expression);
-      if (!parser.Parse(callbacks)) {
-        std::cout << "Error (old VariableParser) :" << parser.GetFirstError()
-                  << " in: " << expression << std::endl;
-        code = codeGenerator.GenerateBadVariable();
-      }
-      return code;
-    } else if (type == "globalvar") {
-      gd::String code = "";
-      gd::VariableCodeGenerationCallbacks callbacks(
-          code,
-          codeGenerator,
-          context,
-          gd::EventsCodeGenerator::PROJECT_VARIABLE);
-
-      gd::VariableParser parser(expression);
-      if (!parser.Parse(callbacks)) {
-        std::cout << "Error (old VariableParser) :" << parser.GetFirstError()
-                  << " in: " << expression << std::endl;
-        code = codeGenerator.GenerateBadVariable();
-      }
-      return code;
-    } else if (type == "objectvar") {
-      gd::String code = "";
-
-      // Object is either the object of the previous parameter or, if it is
-      // empty, the object being picked by the instruction.
-      gd::String object =
-          objectName.empty() ? context.GetCurrentObject() : objectName;
-
-      gd::VariableCodeGenerationCallbacks callbacks(
-          code, codeGenerator, context, object);
-
-      gd::VariableParser parser(expression);
-      if (!parser.Parse(callbacks)) {
-        std::cout << "Error (old VariableParser) :" << parser.GetFirstError()
-                  << " in: " << expression << std::endl;
-        code = codeGenerator.GenerateBadVariable();
-      }
-      return code;
-    }
-
-    std::cout << "Type error (old ExpressionParser): type \"" << type
-              << "\" is not supported" << std::endl;
-    return "/* Error during code generation: type " + type +
-           " is not supported for old ExpressionParser. */ 0";
-  }
-  // end of compatibility code
-
   gd::ExpressionParser2 parser(codeGenerator.GetPlatform(),
                                codeGenerator.GetGlobalObjectsAndGroups(),
                                codeGenerator.GetObjectsAndGroups());
@@ -230,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 " +
@@ -462,4 +359,8 @@ void ExpressionCodeGenerator::OnVisitEmptyNode(EmptyNode& node) {
   output += GenerateDefaultValue(node.type);
 }
 
+void ExpressionCodeGenerator::OnVisitObjectFunctionNameNode(ObjectFunctionNameNode& node) {
+  output += GenerateDefaultValue(node.type);
+}
+
 }  // namespace gd

Core/GDCore/Events/CodeGeneration/ExpressionCodeGenerator.h

@@ -60,11 +60,6 @@ class GD_CORE_API ExpressionCodeGenerator : public ExpressionParser2NodeWorker {
                                            const gd::String& expression,
                                            const gd::String& objectName = "");
 
-  static void UseOldExpressionParser(bool enable) {
-    useOldExpressionParser = enable;
-  };
-  static bool IsUsingOldExpressionParser() { return useOldExpressionParser; };
-
   const gd::String& GetOutput() { return output; };
 
  protected:
@@ -78,7 +73,8 @@ class GD_CORE_API ExpressionCodeGenerator : public ExpressionParser2NodeWorker {
   void OnVisitVariableBracketAccessorNode(
       VariableBracketAccessorNode& node) override;
   void OnVisitIdentifierNode(IdentifierNode& node) override;
-  void OnVisitFunctionNode(FunctionNode& node) override;
+  void OnVisitObjectFunctionNameNode(ObjectFunctionNameNode& node) override;
+  void OnVisitFunctionCallNode(FunctionCallNode& node) override;
   void OnVisitEmptyNode(EmptyNode& node) override;
 
  private:
@@ -107,11 +103,9 @@ class GD_CORE_API ExpressionCodeGenerator : public ExpressionParser2NodeWorker {
   gd::String output;
   EventsCodeGenerator& codeGenerator;
   EventsCodeGenerationContext& context;
-
-  static bool useOldExpressionParser;
 };
 
 }  // namespace gd
 
 #endif  // GDCORE_ExpressionCodeGenerator_H
-#endif
+#endif

Core/GDCore/Events/CodeGeneration/ExpressionsCodeGeneration.cpp

@@ -1,229 +0,0 @@
-/*
- * GDevelop Core
- * Copyright 2008-2016 Florian Rival (Florian.Rival@gmail.com). All rights
- * reserved. This project is released under the MIT License.
- */
-#include "ExpressionsCodeGeneration.h"
-#include "GDCore/CommonTools.h"
-#include "GDCore/Events/CodeGeneration/EventsCodeGenerationContext.h"
-#include "GDCore/Events/CodeGeneration/EventsCodeGenerator.h"
-#include "GDCore/Events/Parsers/ExpressionParser.h"
-#include "GDCore/Events/Tools/EventsCodeNameMangler.h"
-#include "GDCore/Extensions/Metadata/BehaviorMetadata.h"
-#include "GDCore/Extensions/Metadata/ExpressionMetadata.h"
-#include "GDCore/Extensions/Metadata/MetadataProvider.h"
-#include "GDCore/Extensions/Metadata/ObjectMetadata.h"
-#include "GDCore/Extensions/Platform.h"
-#include "GDCore/Extensions/PlatformExtension.h"
-#include "GDCore/Project/Layout.h"
-#include "GDCore/Project/Project.h"
-
-using namespace std;
-
-namespace gd {
-
-CallbacksForGeneratingExpressionCode::CallbacksForGeneratingExpressionCode(
-    gd::String& plainExpression_,
-    EventsCodeGenerator& codeGenerator_,
-    EventsCodeGenerationContext& context_)
-    : plainExpression(plainExpression_),
-      codeGenerator(codeGenerator_),
-      context(context_) {}
-
-void CallbacksForGeneratingExpressionCode::OnConstantToken(gd::String text) {
-  plainExpression += text;
-};
-
-void CallbacksForGeneratingExpressionCode::OnStaticFunction(
-    gd::String functionName,
-    const std::vector<gd::Expression>& parameters,
-    const gd::ExpressionMetadata& expressionInfo) {
-  codeGenerator.AddIncludeFiles(
-      expressionInfo.codeExtraInformation.GetIncludeFiles());
-
-  // Launch custom code generator if needed
-  if (expressionInfo.codeExtraInformation.HasCustomCodeGenerator()) {
-    plainExpression += expressionInfo.codeExtraInformation.customCodeGenerator(
-        parameters, codeGenerator, context);
-    return;
-  }
-
-  // Special case: For strings expressions, function without name is a string.
-  if (GetReturnType() == "string" && functionName.empty()) {
-    if (parameters.empty()) return;
-    plainExpression +=
-        codeGenerator.ConvertToStringExplicit(parameters[0].GetPlainString());
-
-    return;
-  }
-
-  // Prepare parameters
-  std::vector<gd::String> parametersCode =
-      codeGenerator.GenerateParametersCodes(
-          parameters, expressionInfo.parameters, context);
-  gd::String parametersStr;
-  for (std::size_t i = 0; i < parametersCode.size(); ++i) {
-    if (i != 0) parametersStr += ", ";
-    parametersStr += parametersCode[i];
-  }
-
-  plainExpression += expressionInfo.codeExtraInformation.functionCallName +
-                     "(" + parametersStr + ")";
-};
-
-void CallbacksForGeneratingExpressionCode::OnObjectFunction(
-    gd::String functionName,
-    const std::vector<gd::Expression>& parameters,
-    const gd::ExpressionMetadata& expressionInfo) {
-  const gd::ObjectsContainer& globalObjectsAndGroups = codeGenerator.GetGlobalObjectsAndGroups();
-  const gd::ObjectsContainer& objectsAndGroups = codeGenerator.GetObjectsAndGroups();
-
-  codeGenerator.AddIncludeFiles(
-      expressionInfo.codeExtraInformation.GetIncludeFiles());
-  if (parameters.empty()) return;
-
-  // Launch custom code generator if needed
-  if (expressionInfo.codeExtraInformation.HasCustomCodeGenerator()) {
-    plainExpression += expressionInfo.codeExtraInformation.customCodeGenerator(
-        parameters, codeGenerator, context);
-    return;
-  }
-
-  // Prepare parameters
-  std::vector<gd::String> parametersCode =
-      codeGenerator.GenerateParametersCodes(
-          parameters, expressionInfo.parameters, context);
-  gd::String parametersStr;
-  for (std::size_t i = 1; i < parametersCode.size(); ++i) {
-    if (i != 1) parametersStr += ", ";
-    parametersStr += parametersCode[i];
-  }
-
-  gd::String output = GetReturnType() == "string" ? "\"\"" : "0";
-
-  // Get object(s) concerned by function call
-  std::vector<gd::String> realObjects =
-      codeGenerator.ExpandObjectsName(parameters[0].GetPlainString(), context);
-  for (std::size_t i = 0; i < realObjects.size(); ++i) {
-    context.ObjectsListNeeded(realObjects[i]);
-
-    gd::String objectType = gd::GetTypeOfObject(globalObjectsAndGroups, objectsAndGroups, realObjects[i]);
-    const ObjectMetadata& objInfo = MetadataProvider::GetObjectMetadata(
-        codeGenerator.GetPlatform(), objectType);
-
-    // Build gd::String to access the object
-    codeGenerator.AddIncludeFiles(objInfo.includeFiles);
-    output = codeGenerator.GenerateObjectFunctionCall(
-        realObjects[i],
-        objInfo,
-        expressionInfo.codeExtraInformation,
-        parametersStr,
-        output,
-        context);
-  }
-
-  plainExpression += output;
-};
-
-void CallbacksForGeneratingExpressionCode::OnObjectBehaviorFunction(
-    gd::String functionName,
-    const std::vector<gd::Expression>& parameters,
-    const gd::ExpressionMetadata& expressionInfo) {
-  const gd::ObjectsContainer& globalObjectsAndGroups = codeGenerator.GetGlobalObjectsAndGroups();
-  const gd::ObjectsContainer& objectsAndGroups = codeGenerator.GetObjectsAndGroups();
-
-  codeGenerator.AddIncludeFiles(
-      expressionInfo.codeExtraInformation.GetIncludeFiles());
-  if (parameters.size() < 2) return;
-
-  // Launch custom code generator if needed
-  if (expressionInfo.codeExtraInformation.HasCustomCodeGenerator()) {
-    plainExpression += expressionInfo.codeExtraInformation.customCodeGenerator(
-        parameters, codeGenerator, context);
-    return;
-  }
-
-  // Prepare parameters
-  std::vector<gd::String> parametersCode =
-      codeGenerator.GenerateParametersCodes(
-          parameters, expressionInfo.parameters, context);
-  gd::String parametersStr;
-  for (std::size_t i = 2; i < parametersCode.size(); ++i) {
-    if (i != 2) parametersStr += ", ";
-    parametersStr += parametersCode[i];
-  }
-
-  // Get object(s) concerned by function call
-  std::vector<gd::String> realObjects =
-      codeGenerator.ExpandObjectsName(parameters[0].GetPlainString(), context);
-
-  gd::String output = GetReturnType() == "string" ? "\"\"" : "0";
-  for (std::size_t i = 0; i < realObjects.size(); ++i) {
-    context.ObjectsListNeeded(realObjects[i]);
-
-    // Cast the object if needed
-    gd::String behaviorType =
-        gd::GetTypeOfBehavior(globalObjectsAndGroups, objectsAndGroups, parameters[1].GetPlainString());
-    const BehaviorMetadata& autoInfo = MetadataProvider::GetBehaviorMetadata(
-        codeGenerator.GetPlatform(), behaviorType);
-
-    // Build gd::String to access the behavior
-    codeGenerator.AddIncludeFiles(autoInfo.includeFiles);
-    output = codeGenerator.GenerateObjectBehaviorFunctionCall(
-        realObjects[i],
-        parameters[1].GetPlainString(),
-        autoInfo,
-        expressionInfo.codeExtraInformation,
-        parametersStr,
-        output,
-        context);
-  }
-
-  plainExpression += output;
-};
-
-bool CallbacksForGeneratingExpressionCode::OnSubMathExpression(
-    const gd::Platform& platform,
-    const gd::ObjectsContainer& globalObjectsAndGroups,
-    const gd::ObjectsContainer& objectsAndGroups,
-    gd::Expression& expression) {
-  gd::String newExpression;
-
-  CallbacksForGeneratingExpressionCode callbacks(
-      newExpression, codeGenerator, context);
-
-  gd::ExpressionParser parser(expression.GetPlainString());
-  if (!parser.ParseMathExpression(platform, globalObjectsAndGroups, objectsAndGroups, callbacks)) {
-#if defined(GD_IDE_ONLY)
-    firstErrorStr = callbacks.GetFirstError();
-    firstErrorPos = callbacks.GetFirstErrorPosition();
-#endif
-    return false;
-  }
-
-  return true;
-}
-
-bool CallbacksForGeneratingExpressionCode::OnSubTextExpression(
-    const gd::Platform& platform,
-    const gd::ObjectsContainer& globalObjectsAndGroups,
-    const gd::ObjectsContainer& objectsAndGroups,
-    gd::Expression& expression) {
-  gd::String newExpression;
-
-  CallbacksForGeneratingExpressionCode callbacks(
-      newExpression, codeGenerator, context);
-
-  gd::ExpressionParser parser(expression.GetPlainString());
-  if (!parser.ParseStringExpression(platform, globalObjectsAndGroups, objectsAndGroups, callbacks)) {
-#if defined(GD_IDE_ONLY)
-    firstErrorStr = callbacks.GetFirstError();
-    firstErrorPos = callbacks.GetFirstErrorPosition();
-#endif
-    return false;
-  }
-
-  return true;
-}
-
-}  // namespace gd

Core/GDCore/Events/CodeGeneration/ExpressionsCodeGeneration.h

@@ -1,77 +0,0 @@
-/*
- * GDevelop Core
- * Copyright 2008-2016 Florian Rival (Florian.Rival@gmail.com). All rights
- * reserved. This project is released under the MIT License.
- */
-#ifndef EXPRESSIONSCODEGENERATION_H
-#define EXPRESSIONSCODEGENERATION_H
-
-#include <vector>
-#include "GDCore/Events/Parsers/ExpressionParser.h"
-#include "GDCore/String.h"
-namespace gd {
-class ExpressionMetadata;
-class Expression;
-class Project;
-class Layout;
-class Layout;
-class EventsCodeGenerationContext;
-class EventsCodeGenerator;
-}
-
-namespace gd {
-
-// TODO: Replace and remove (ExpressionCodeGenerator)
-
-/**
- * \brief Used to generate code from expressions.
- *
- * Usage example :
- * \code
- *   gd::String expressionOutputCppCode;
- *
- *   CallbacksForGeneratingExpressionCode callbacks(expressionOutputCppCode,
- * codeGenerator, context); gd::ExpressionParser
- * parser(theOriginalGameDevelopExpression);
- *   parser.ParseStringExpression(platform, project, scene, callbacks);
- *
- *   if (expressionOutputCppCode.empty()) expressionOutputCppCode = "\"\""; //If
- * generation failed, we make sure output code is not empty. \endcode \see
- * EventsCodeGenerator
- */
-class GD_CORE_API CallbacksForGeneratingExpressionCode
-    : public gd::ParserCallbacks {
- public:
-  CallbacksForGeneratingExpressionCode(gd::String& output,
-                                       EventsCodeGenerator& codeGenerator_,
-                                       EventsCodeGenerationContext& context_);
-  virtual ~CallbacksForGeneratingExpressionCode(){};
-
-  void OnConstantToken(gd::String text);
-  void OnStaticFunction(gd::String functionName,
-                        const std::vector<gd::Expression>& parameters,
-                        const gd::ExpressionMetadata& expressionInfo);
-  void OnObjectFunction(gd::String functionName,
-                        const std::vector<gd::Expression>& parameters,
-                        const gd::ExpressionMetadata& expressionInfo);
-  void OnObjectBehaviorFunction(gd::String functionName,
-                                const std::vector<gd::Expression>& parameters,
-                                const gd::ExpressionMetadata& expressionInfo);
-  bool OnSubMathExpression(const gd::Platform& platform,
-                           const gd::ObjectsContainer& project,
-                           const gd::ObjectsContainer& layout,
-                           gd::Expression& expression);
-  bool OnSubTextExpression(const gd::Platform& platform,
-                           const gd::ObjectsContainer& project,
-                           const gd::ObjectsContainer& layout,
-                           gd::Expression& expression);
-
- private:
-  gd::String& plainExpression;
-  EventsCodeGenerator& codeGenerator;
-  EventsCodeGenerationContext& context;
-};
-
-}  // namespace gd
-
-#endif  // EXPRESSIONSCODEGENERATION_H

Core/GDCore/Events/CodeGeneration/VariableParserCallbacks.cpp

@@ -1,68 +0,0 @@
-/*
- * GDevelop C++ Platform
- * Copyright 2008-2016 Florian Rival (Florian.Rival@gmail.com). All rights
- * reserved. This project is released under the MIT License.
- */
-#if defined(GD_IDE_ONLY)
-#include "VariableParserCallbacks.h"
-#include <string>
-#include <vector>
-#include "GDCore/Events/CodeGeneration/EventsCodeGenerationContext.h"
-#include "GDCore/Events/CodeGeneration/EventsCodeGenerator.h"
-#include "GDCore/Events/CodeGeneration/ExpressionCodeGenerator.h"
-#include "GDCore/Events/Parsers/VariableParser.h"
-#include "GDCore/Extensions/Metadata/MetadataProvider.h"
-#include "GDCore/Extensions/Metadata/ObjectMetadata.h"
-#include "GDCore/Extensions/Platform.h"
-#include "GDCore/Project/Layout.h"
-#include "GDCore/Project/Object.h"
-#include "GDCore/Project/Project.h"
-
-using namespace std;
-
-namespace gd {
-
-VariableCodeGenerationCallbacks::VariableCodeGenerationCallbacks(
-    gd::String& output_,
-    gd::EventsCodeGenerator& codeGenerator_,
-    gd::EventsCodeGenerationContext& context_,
-    const gd::EventsCodeGenerator::VariableScope& scope_)
-    : output(output_),
-      codeGenerator(codeGenerator_),
-      context(context_),
-      scope(scope_) {
-  if (scope == gd::EventsCodeGenerator::OBJECT_VARIABLE) {
-    std::cout << "ERROR: Initializing VariableCodeGenerationCallbacks with "
-                 "OBJECT_VARIABLE without object.";
-  }
-}
-
-VariableCodeGenerationCallbacks::VariableCodeGenerationCallbacks(
-    gd::String& output_,
-    gd::EventsCodeGenerator& codeGenerator_,
-    gd::EventsCodeGenerationContext& context_,
-    const gd::String& object_)
-    : output(output_),
-      codeGenerator(codeGenerator_),
-      context(context_),
-      scope(gd::EventsCodeGenerator::OBJECT_VARIABLE),
-      object(object_) {}
-
-void VariableCodeGenerationCallbacks::OnRootVariable(gd::String variableName) {
-  output += codeGenerator.GenerateGetVariable(variableName, scope, context, object);
-}
-
-void VariableCodeGenerationCallbacks::OnChildVariable(gd::String variableName) {
-  output += codeGenerator.GenerateVariableAccessor(variableName);
-}
-
-void VariableCodeGenerationCallbacks::OnChildSubscript(
-    gd::String stringExpression) {
-  gd::String argumentCode = gd::ExpressionCodeGenerator::GenerateExpressionCode(
-      codeGenerator, context, "string", stringExpression);
-
-  output += codeGenerator.GenerateVariableBracketAccessor(argumentCode);
-}
-
-}
-#endif

Core/GDCore/Events/CodeGeneration/VariableParserCallbacks.h

@@ -1,97 +0,0 @@
-/*
- * GDevelop C++ Platform
- * Copyright 2008-2016 Florian Rival (Florian.Rival@gmail.com). All rights
- * reserved. This project is released under the MIT License.
- */
-#if defined(GD_IDE_ONLY)
-#ifndef VARIABLEPARSERCALLBACKS_H
-#define VARIABLEPARSERCALLBACKS_H
-
-#include <string>
-#include <vector>
-#include "GDCore/Events/Parsers/VariableParser.h"
-#include "GDCore/String.h"
-#include "EventsCodeGenerator.h"
-namespace gd {
-class EventsCodeGenerationContext;
-}  // namespace gd
-
-// TODO: Replace and remove (ExpressionCodeGenerator)
-namespace gd {
-
-/**
- * \brief Callbacks called to generate the code for getting a variable.
- *
- * Usage example:
- \code
-    VariableCodeGenerationCallbacks callbacks(output, eventsCodeGenerator,
- context, VariableCodeGenerationCallbacks::LAYOUT_VARIABLE);
-
-    gd::VariableParser parser(parameter);
-    if ( !parser.Parse(callbacks) )
-    {
-        //Error during parsing the variable name:
-        output = "runtimeContext->GetSceneVariables().GetBadVariable()";
-    }
-
-    //"output" now contains the C++ code to return the variable.
- \endcode
- */
-class VariableCodeGenerationCallbacks : public gd::VariableParserCallbacks {
- public:
-  /**
-   * \brief Default constructor for generating code for a layout/global
-   * variable. \param output The string in which the code will be generated.
-   * \param codeGenerator The code generator being used.
-   * \param context The current code generation context.
-   * \param scope The scope of the variable being accessed: LAYOUT_VARIABLE,
-   * PROJECT_VARIABLE.
-   */
-  VariableCodeGenerationCallbacks(gd::String& output,
-                                  gd::EventsCodeGenerator& codeGenerator_,
-                                  gd::EventsCodeGenerationContext& context_,
-                                  const gd::EventsCodeGenerator::VariableScope& scope_);
-  /**
-
-   * \brief Default constructor for generating code for an object variable.
-   * \param output The string in which the code will be generated.
-   * \param codeGenerator The code generator being used.
-   * \param context The current code generation context.
-   * \param object The name of the object
-   */
-  VariableCodeGenerationCallbacks(gd::String& output,
-                                  gd::EventsCodeGenerator& codeGenerator_,
-                                  gd::EventsCodeGenerationContext& context_,
-                                  const gd::String& object);
-
-  /**
-   * \brief Called when the first variable has been parsed.
-   * \param variableName The variable name.
-   */
-  virtual void OnRootVariable(gd::String variableName);
-
-  /**
-   * \brief Called when accessing the child of a structure variable.
-   * \param variableName The child variable name.
-   */
-  virtual void OnChildVariable(gd::String variableName);
-
-  /**
-   * \brief Called when accessing the child of a structure variable using a
-   * string expression in square brackets. \param variableName The expression
-   * used to access the child variable.
-   */
-  virtual void OnChildSubscript(gd::String stringExpression);
-
- private:
-  gd::String& output;
-  gd::EventsCodeGenerator& codeGenerator;
-  gd::EventsCodeGenerationContext& context;
-  gd::EventsCodeGenerator::VariableScope scope;
-  const gd::String object;  ///< The object name, when scope == OBJECT_VARIABLE.
-};
-
-}
-
-#endif  // VARIABLEPARSERCALLBACKS_H
-#endif

Core/GDCore/Events/Event.h

@@ -12,6 +12,7 @@
 #include <vector>
 #include "GDCore/Events/Instruction.h"
 #include "GDCore/Events/InstructionsList.h"
+#include "GDCore/Extensions/Metadata/InstructionMetadata.h"
 #include "GDCore/String.h"
 namespace gd {
 class EventsList;
@@ -90,8 +91,8 @@ class GD_CORE_API BaseEvent {
   bool HasSubEvents() const;
 
   /**
-   * Event must be able to return all conditions std::vector they have.
-   * Used to preprocess the conditions.
+   * \brief Return a list of all conditions of the event.
+   * \note Used to preprocess or search in the conditions.
    */
   virtual std::vector<gd::InstructionsList*> GetAllConditionsVectors() {
     std::vector<gd::InstructionsList*> noConditions;
@@ -104,8 +105,8 @@ class GD_CORE_API BaseEvent {
   };
 
   /**
-   * Event must be able to return all actions std::vector they have.
-   * Used to preprocess the actions.
+   * \brief Return a list of all actions of the event.
+   * \note Used to preprocess or search in the actions.
    */
   virtual std::vector<gd::InstructionsList*> GetAllActionsVectors() {
     std::vector<gd::InstructionsList*> noActions;
@@ -118,15 +119,26 @@ class GD_CORE_API BaseEvent {
   };
 
   /**
-   * Event must be able to return all expressions they have.
-   * Used to preprocess the expressions.
+   * \brief Return a list of all strings of the event.
+   * \note Used to preprocess or search in the event strings.
    */
-  virtual std::vector<gd::Expression*> GetAllExpressions() {
-    std::vector<gd::Expression*> noExpr;
+  virtual std::vector<gd::String> GetAllSearchableStrings() const {
+    std::vector<gd::String> noSearchableStrings;
+    return noSearchableStrings;
+  };
+
+  /**
+   * \brief Return a list of all expressions of the event, each with their associated metadata.
+   * \note Used to preprocess or search in the expressions of the event.
+   */
+  virtual std::vector<std::pair<gd::Expression*, gd::ParameterMetadata> >
+      GetAllExpressionsWithMetadata() {
+    std::vector<std::pair<gd::Expression*, gd::ParameterMetadata> > noExpr;
     return noExpr;
   };
-  virtual std::vector<const gd::Expression*> GetAllExpressions() const {
-    std::vector<const gd::Expression*> noExpr;
+  virtual std::vector<std::pair<const gd::Expression*, const gd::ParameterMetadata> >
+      GetAllExpressionsWithMetadata() const {
+    std::vector<std::pair<const gd::Expression*, const gd::ParameterMetadata> > noExpr;
     return noExpr;
   };
 

Core/GDCore/Events/EventsList.cpp

@@ -99,6 +99,23 @@ bool EventsList::Contains(const gd::BaseEvent& eventToSearch,
   return false;
 }
 
+bool EventsList::MoveEventToAnotherEventsList(const gd::BaseEvent& eventToMove,
+                                  gd::EventsList& newEventsList,
+                                  std::size_t newPosition) {
+
+  for (std::size_t i = 0; i < GetEventsCount(); ++i) {
+    if (events[i].get() == &eventToMove) {
+      std::shared_ptr<BaseEvent> event = events[i];
+      events.erase(events.begin() + i);
+
+      newEventsList.InsertEvent(event, newPosition);
+      return true;
+    }
+  }
+
+  return false;
+}
+
 EventsList::EventsList(const EventsList& other) { Init(other); }
 
 EventsList& EventsList::operator=(const EventsList& other) {

Core/GDCore/Events/EventsList.h

@@ -52,7 +52,8 @@ class GD_CORE_API EventsList {
    * \brief Insert the specified event to the list.
    * \note The event passed by parameter is not copied.
    * \param event The smart pointer to the event that must be inserted into the
-   * list \param position Insertion position. If the position is invalid, the
+   * list
+   * \param position Insertion position. If the position is invalid, the
    * object is inserted at the end of the objects list.
    */
   void InsertEvent(std::shared_ptr<gd::BaseEvent> event,
@@ -142,6 +143,25 @@ class GD_CORE_API EventsList {
    */
   bool Contains(const gd::BaseEvent& eventToSearch,
                 bool recursive = true) const;
+
+  /**
+   * Move the specified event, that must be in the events list, to another
+   * events list *without* invalidating the event (i.e: without
+   * destroying/cloning it) in memory.
+   *
+   * \warning newEventsList is supposed not to be contained inside the event
+   * (you should not try
+   * to move an event inside one of its children/grand children events).
+   *
+   * \param eventToMove The event to be moved
+   * \param newEventsList The new events list
+   * \param newPosition The position in the new events list
+   * \return true if the move was made, false otherwise (for example, if
+   * eventToMove is not found in the list)
+   */
+  bool MoveEventToAnotherEventsList(const gd::BaseEvent& eventToMove,
+                                    gd::EventsList& newEventsList,
+                                    std::size_t newPosition);
   ///@}
 
   /** \name std::vector API compatibility

Core/GDCore/Events/Instruction.cpp

@@ -4,9 +4,12 @@
  * reserved. This project is released under the MIT License.
  */
 #include "GDCore/Events/Instruction.h"
+
 #include <assert.h>
+
 #include <iostream>
 #include <vector>
+
 #include "GDCore/Events/Expression.h"
 #include "GDCore/Events/InstructionsList.h"
 #include "GDCore/String.h"
@@ -15,18 +18,14 @@ namespace gd {
 
 gd::Expression Instruction::badExpression("");
 
-Instruction::Instruction(gd::String type_)
-    : type(type_),
-      inverted(false) {
+Instruction::Instruction(gd::String type_) : type(type_), inverted(false) {
   parameters.reserve(8);
 }
 
 Instruction::Instruction(gd::String type_,
                          const std::vector<gd::Expression>& parameters_,
                          bool inverted_)
-    : type(type_),
-      inverted(inverted_),
-      parameters(parameters_) {
+    : type(type_), inverted(inverted_), parameters(parameters_) {
   parameters.reserve(8);
 }
 
@@ -56,4 +55,17 @@ void Instruction::SetParameter(std::size_t nb, const gd::Expression& val) {
   parameters[nb] = val;
 }
 
+std::shared_ptr<Instruction> GD_CORE_API
+CloneRememberingOriginalElement(std::shared_ptr<Instruction> instruction) {
+  std::shared_ptr<Instruction> copy =
+      std::make_shared<Instruction>(*instruction);
+  // Original instruction is either the original instruction of the copied
+  // instruction, or the instruction copied.
+  copy->originalInstruction = instruction->originalInstruction.expired()
+                                  ? instruction
+                                  : instruction->originalInstruction;
+
+  return copy;
+}
+
 }  // namespace gd

Core/GDCore/Events/Instruction.h

@@ -5,7 +5,9 @@
  */
 #ifndef INSTRUCTION_H
 #define INSTRUCTION_H
+#include <memory>
 #include <vector>
+
 #include "GDCore/Events/Expression.h"
 #include "GDCore/Events/InstructionsList.h"
 #include "GDCore/String.h"
@@ -131,6 +133,17 @@ class GD_CORE_API Instruction {
    */
   inline gd::InstructionsList& GetSubInstructions() { return subInstructions; };
 
+  /**
+   * \brief Return the original instruction this instruction was copied from.
+   *
+   * Useful to get reference to the original instruction in memory during code
+   * generation, to ensure stable unique identifiers.
+   */
+  std::weak_ptr<Instruction> GetOriginalInstruction() { return originalInstruction; };
+
+  friend std::shared_ptr<Instruction> CloneRememberingOriginalElement(
+      std::shared_ptr<Instruction> instruction);
+
  private:
   gd::String type;  ///< Instruction type
   bool inverted;  ///< True if the instruction if inverted. Only applicable for
@@ -139,9 +152,23 @@ class GD_CORE_API Instruction {
       parameters;                        ///< Vector containing the parameters
   gd::InstructionsList subInstructions;  ///< Sub instructions, if applicable.
 
+  std::weak_ptr<Instruction>
+      originalInstruction;  ///< Pointer used to remember which gd::Instruction
+                            ///< this instruction was copied from. Useful to
+                            ///< ensure the stability of code generation (as
+                            ///< some part of code generation uses the pointer
+                            ///< to the instruction as a unique identifier).
+
   static gd::Expression badExpression;
 };
 
+/**
+ * Clone the given instruction, returning an instruction for which
+ * `GetOriginalInstruction()` returns the originally copied instruction.
+ */
+std::shared_ptr<Instruction> GD_CORE_API
+CloneRememberingOriginalElement(std::shared_ptr<Instruction> instruction);
+
 }  // namespace gd
 
 #endif  // INSTRUCTION_H

Core/GDCore/Events/Parsers/ExpressionParser.cpp

@@ -1,897 +0,0 @@
-/*
- * GDevelop Core
- * Copyright 2008-2016 Florian Rival (Florian.Rival@gmail.com). All rights
- * reserved. This project is released under the MIT License.
- */
-#include "GDCore/Events/Parsers/ExpressionParser.h"
-#include <algorithm>
-#include <iostream>
-#include "GDCore/CommonTools.h"
-#include "GDCore/Events/Expression.h"
-#include "GDCore/Extensions/Metadata/ExpressionMetadata.h"
-#include "GDCore/Extensions/Metadata/InstructionMetadata.h"
-#include "GDCore/Extensions/Metadata/MetadataProvider.h"
-#include "GDCore/Extensions/Platform.h"
-#include "GDCore/Project/Layout.h"
-#include "GDCore/Project/Project.h"
-#include "GDCore/Tools/Localization.h"
-
-using namespace std;
-
-namespace gd {
-
-gd::String ExpressionParser::parserSeparators = " ,+-*/%.<>=&|;()#^![]{}";
-
-size_t ExpressionParser::GetMinimalParametersNumber(
-    const std::vector<gd::ParameterMetadata>& parametersInfos) {
-  size_t nb = 0;
-  for (std::size_t i = 0; i < parametersInfos.size(); ++i) {
-    if (!parametersInfos[i].optional && !parametersInfos[i].codeOnly) nb++;
-  }
-
-  return nb;
-}
-
-size_t ExpressionParser::GetMaximalParametersNumber(
-    const std::vector<gd::ParameterMetadata>& parametersInfos) {
-  size_t nb = 0;
-  for (std::size_t i = 0; i < parametersInfos.size(); ++i) {
-    if (!parametersInfos[i].codeOnly) nb++;
-  }
-
-  return nb;
-}
-
-/**
- * Add blank parameters when code-only parameters are expected.
- * \param Parameters information
- * \param vector of parameters without code only parameters.
- */
-std::vector<gd::Expression> CompleteParameters(
-    const std::vector<gd::ParameterMetadata>& parametersInfo,
-    const std::vector<gd::Expression>& parameters) {
-  std::vector<gd::Expression> completeParameters = parameters;
-  for (std::size_t i = 0; i < parametersInfo.size();
-       ++i)  // Code only parameters are not included in expressions parameters.
-  {
-    if (parametersInfo[i].codeOnly) {
-      if (i > completeParameters.size()) {
-        cout << "Bad parameter count in expression.";
-      }
-
-      if (i >= completeParameters.size())
-        completeParameters.push_back(gd::Expression(""));
-      else
-        completeParameters.insert(completeParameters.begin() + i,
-                                  gd::Expression(""));
-    } else {
-      if (i >= completeParameters.size()) {
-        completeParameters.push_back(gd::Expression(""));
-      }
-    }
-  }
-  return completeParameters;
-}
-
-bool ExpressionParser::ValidSyntax(const gd::String& str) {
-  static const gd::String numerics = "0123456789.e";
-  static const gd::String operators = "+/*-%";
-
-  size_t parenthesisLevel = 0;
-  gd::String lastOperator;
-
-  bool parsingNumber = false;
-  bool parsingScientificNotationNumber = false;
-  bool parsingDecimalNumber = false;
-  bool requestNumber = false;
-  gd::String lastNumber;
-  bool numberWasParsedLast = false;
-
-  for (auto it = str.begin(); it != str.end(); ++it) {
-    char32_t currentChar = *it;
-    if (currentChar == U' ' || currentChar == U'\n') {
-      if (requestNumber) {
-        firstErrorStr = _("Number expected");
-
-        return false;
-      }
-
-      if (parsingNumber) {
-        parsingNumber = false;
-        parsingScientificNotationNumber = false;
-        parsingDecimalNumber = false;
-        requestNumber = false;
-        lastNumber.clear();
-        numberWasParsedLast = true;
-      }
-    } else if (numerics.find(currentChar) != gd::String::npos) {
-      requestNumber = false;
-
-      if (currentChar == U'.') {
-        if (!parsingNumber) {
-          firstErrorStr = _("Syntax error");
-
-          return false;
-        }
-
-        if (parsingDecimalNumber) {
-          firstErrorStr = _("Syntax error in a number.");
-
-          return false;
-        }
-
-        parsingDecimalNumber = true;
-      }
-
-      if (currentChar == U'e') {
-        if (parsingScientificNotationNumber) {
-          firstErrorStr = _("Syntax error in a number.");
-
-          return false;
-        }
-
-        parsingScientificNotationNumber = true;
-        requestNumber = true;
-      }
-
-      if (numberWasParsedLast) {
-        firstErrorStr = _("Operator missing before a number");
-
-        return false;
-      }
-
-      parsingNumber = true;
-      lastNumber += currentChar;
-    } else if (currentChar == U')') {
-      if (requestNumber) {
-        firstErrorStr = _("Number expected");
-
-        return false;
-      }
-
-      if (parsingNumber) {
-        parsingNumber = false;
-        parsingScientificNotationNumber = false;
-        parsingDecimalNumber = false;
-        lastNumber.clear();
-        numberWasParsedLast = true;
-      }
-
-      if (!numberWasParsedLast) {
-        firstErrorStr = _("Superfluous operator before a paranthesis");
-
-        return false;
-      }
-
-      if (parenthesisLevel > 0)
-        parenthesisLevel--;
-      else {
-        firstErrorStr = _("Bad closing paranthesis");
-
-        return false;
-      }
-
-      auto previousIt = it;
-      --previousIt;
-      if (*previousIt == U'(') {
-        firstErrorStr = _("Empty paranthesis");
-
-        return false;
-      }
-    } else if (currentChar == U'(') {
-      if (requestNumber) {
-        firstErrorStr = _("Number expected");
-
-        return false;
-      }
-
-      if (parsingNumber) {
-        parsingNumber = false;
-        parsingScientificNotationNumber = false;
-        parsingDecimalNumber = false;
-        lastNumber.clear();
-        numberWasParsedLast = true;
-      }
-
-      if (numberWasParsedLast) {
-        firstErrorStr = _("Operator missing before a paranthesis");
-
-        return false;
-      }
-
-      parenthesisLevel++;
-      numberWasParsedLast = false;
-    } else if (operators.find(currentChar) != gd::String::npos) {
-      if (currentChar == U'-' && parsingNumber &&
-          parsingScientificNotationNumber) {
-        lastNumber += currentChar;
-        requestNumber = true;
-      } else {
-        if (requestNumber) {
-          firstErrorStr = _("Number expected");
-
-          return false;
-        }
-
-        if (parsingNumber) {
-          parsingNumber = false;
-          parsingScientificNotationNumber = false;
-          parsingDecimalNumber = false;
-          lastNumber.clear();
-          numberWasParsedLast = true;
-        }
-
-        if (currentChar != U'-' && currentChar != U'+' &&
-            !numberWasParsedLast) {
-          firstErrorStr = _("Operators without any number between them");
-
-          return false;
-        }
-
-        numberWasParsedLast = false;
-      }
-    } else {
-      firstErrorStr = _("Syntax error");
-
-      return false;
-    }
-  }
-
-  if (parsingNumber) {
-    parsingNumber = false;
-    parsingScientificNotationNumber = false;
-    parsingDecimalNumber = false;
-    lastNumber.clear();
-    numberWasParsedLast = true;
-  } else if (requestNumber) {
-    firstErrorStr = _("Number expected");
-
-    return false;
-  }
-
-  if (parenthesisLevel != 0) {
-    firstErrorStr = _("Paranthesis mismatch");
-
-    return false;
-  }
-
-  if (!numberWasParsedLast) {
-    firstErrorStr = _("Alone operator at the end of the expression");
-
-    return false;
-  }
-
-  return true;
-}
-
-bool ExpressionParser::ParseMathExpression(const gd::Platform& platform,
-                                           const gd::ObjectsContainer& project,
-                                           const gd::ObjectsContainer& layout,
-                                           gd::ParserCallbacks& callbacks) {
-  callbacks.SetReturnType("expression");
-  gd::String expression = expressionPlainString;
-
-  size_t parsePosition = 0;
-
-  size_t firstPointPos = expression.find(".");
-  size_t firstParPos = expression.find("(");
-
-  gd::String expressionWithoutFunctions;
-  gd::String nonFunctionToken;
-  size_t nonFunctionTokenStartPos = gd::String::npos;
-
-  while (firstPointPos != string::npos || firstParPos != string::npos) {
-    // Identify name
-    size_t nameEnd = firstPointPos < firstParPos ? firstPointPos : firstParPos;
-    size_t nameStart = expression.find_last_of(parserSeparators, nameEnd - 1);
-    nameStart++;
-
-    gd::String nameBefore = expression.substr(nameStart, nameEnd - nameStart);
-    gd::String objectName = nameBefore.FindAndReplace("~", " ");
-
-    // Identify function name
-    gd::String functionName = nameBefore;
-    size_t functionNameEnd = nameEnd;
-    vector<gd::Expression> parameters;
-
-    bool nameIsFunction = firstPointPos > firstParPos;
-    if (!nameIsFunction) {
-      parameters.push_back(gd::Expression(objectName));
-      functionNameEnd = expression.find_first_of(" (", nameEnd);
-      if (nameEnd + 1 < expression.length())
-        functionName =
-            expression.substr(nameEnd + 1, functionNameEnd - (nameEnd + 1));
-      if (functionNameEnd == string::npos) {
-        functionName = "";
-        functionNameEnd = expression.length() - 1;
-      }
-    }
-
-    // Now we're going to identify the expression
-    gd::ExpressionMetadata instructionInfos;
-
-    if (functionName.substr(0, functionName.length() - 1)
-            .find_first_of(parserSeparators) == string::npos) {
-      bool functionFound = false;
-      bool staticFunctionFound = false;
-      bool objectFunctionFound = false;
-      bool behaviorFunctionFound = false;
-
-      // First try to bind to a static expression
-      if (nameIsFunction &&
-          MetadataProvider::HasExpression(platform, functionName)) {
-        functionFound = true;
-        staticFunctionFound = true;
-        instructionInfos =
-            MetadataProvider::GetExpressionMetadata(platform, functionName);
-      }
-      // Then search in object expression
-      else if (!nameIsFunction &&
-               MetadataProvider::HasObjectExpression(
-                   platform,
-                   gd::GetTypeOfObject(project, layout, objectName),
-                   functionName)) {
-        functionFound = true;
-        objectFunctionFound = true;
-        instructionInfos = MetadataProvider::GetObjectExpressionMetadata(
-            platform,
-            gd::GetTypeOfObject(project, layout, objectName),
-            functionName);
-      }
-      // And in behaviors expressions
-      else if (!nameIsFunction) {
-        size_t firstDoublePoints = functionName.find("::");
-        if (firstDoublePoints != string::npos) {
-          gd::String autoName = functionName.substr(0, firstDoublePoints);
-          if (firstDoublePoints + 2 < functionName.length())
-            functionName = functionName.substr(firstDoublePoints + 2,
-                                               functionName.length());
-          else
-            functionName = "";
-
-          if (MetadataProvider::HasBehaviorExpression(
-                  platform,
-                  gd::GetTypeOfBehavior(project, layout, autoName),
-                  functionName)) {
-            parameters.push_back(gd::Expression(autoName));
-            functionFound = true;
-            behaviorFunctionFound = true;
-
-            instructionInfos = MetadataProvider::GetBehaviorExpressionMetadata(
-                platform,
-                gd::GetTypeOfBehavior(project, layout, autoName),
-                functionName);
-
-            // Verify that object has behavior.
-            vector<gd::String> behaviors =
-                gd::GetBehaviorsOfObject(project, layout, objectName);
-            if (find(behaviors.begin(), behaviors.end(), autoName) ==
-                behaviors.end()) {
-              cout << "Bad behavior requested" << endl;
-              functionFound = false;
-            }
-          }
-        }
-      }
-
-      if (functionFound)  // Add the function
-      {
-        // Identify parameters
-        size_t parametersEnd = expression.find_first_of("(", functionNameEnd);
-        gd::String currentParameterStr;
-        char32_t previousChar = '(';
-        bool takeSymbolsInAccount = true;
-        if (parametersEnd != string::npos) {
-          size_t level = 0;
-          parametersEnd++;
-
-          while (parametersEnd < expression.length() &&
-                 !(expression[parametersEnd] == ')' && level == 0)) {
-            // Be sure we are not in quotes
-            if (expression[parametersEnd] == U'\"' && previousChar != U'\\')
-              takeSymbolsInAccount = !takeSymbolsInAccount;
-
-            // So as to be sure paranthesis don't belong to a parameter
-            if (expression[parametersEnd] == U'(' && takeSymbolsInAccount)
-              level++;
-            if (expression[parametersEnd] == U')' && takeSymbolsInAccount)
-              level--;
-
-            // Add the character to the current parameter or terminate the
-            // latter
-            if ((expression[parametersEnd] == U',' && level == 0) &&
-                takeSymbolsInAccount) {
-              parameters.push_back(currentParameterStr);
-              currentParameterStr.clear();
-            } else
-              currentParameterStr += expression[parametersEnd];
-
-            previousChar = expression[parametersEnd];
-            parametersEnd++;
-          }
-          if (currentParameterStr.find_first_not_of(" ") !=
-              string::npos)  // Add last parameter if needed
-          {
-            parameters.push_back(currentParameterStr);
-          }
-
-          // Testing function call is properly closed
-          if (parametersEnd == expression.length() ||
-              expression[parametersEnd] != U')') {
-            firstErrorStr = _("Paranthesis not closed");
-            firstErrorPos = parametersEnd - 1;
-
-            return false;
-          }
-
-          // Testing the number of parameters
-          if (parameters.size() >
-                  GetMaximalParametersNumber(instructionInfos.parameters) ||
-              parameters.size() <
-                  GetMinimalParametersNumber(instructionInfos.parameters)) {
-            firstErrorPos = functionNameEnd;
-            firstErrorStr = _("Incorrect number of parameters");
-            firstErrorStr += " ";
-            firstErrorStr += _("Expected (maximum) :");
-            firstErrorStr += gd::String::From(
-                GetMaximalParametersNumber(instructionInfos.parameters));
-
-            return false;
-          }
-
-          // Preparing parameters
-          parameters =
-              CompleteParameters(instructionInfos.parameters, parameters);
-          for (std::size_t i = 0; i < instructionInfos.parameters.size(); ++i) {
-            if (!PrepareParameter(platform,
-                                  project,
-                                  layout,
-                                  callbacks,
-                                  parameters[i],
-                                  instructionInfos.parameters[i],
-                                  functionNameEnd))
-              return false;
-          }
-        } else {
-          firstErrorPos = functionNameEnd;
-          firstErrorStr = _("Parameters' parenthesis missing");
-
-          return false;
-        }
-
-        callbacks.OnConstantToken(
-            nonFunctionToken +
-            expression.substr(parsePosition, nameStart - parsePosition));
-        expressionWithoutFunctions +=
-            expression.substr(parsePosition, nameStart - parsePosition);
-        nonFunctionToken.clear();
-        nonFunctionTokenStartPos = gd::String::npos;
-
-        if (objectFunctionFound)
-          callbacks.OnObjectFunction(
-              functionName, parameters, instructionInfos);
-        else if (behaviorFunctionFound)
-          callbacks.OnObjectBehaviorFunction(
-              functionName, parameters, instructionInfos);
-        else if (staticFunctionFound)
-          callbacks.OnStaticFunction(
-              functionName, parameters, instructionInfos);
-
-        if (objectFunctionFound || behaviorFunctionFound || staticFunctionFound)
-          expressionWithoutFunctions += "0";
-
-        parsePosition = parametersEnd + 1;
-        firstPointPos = expression.find(".", parametersEnd + 1);
-        firstParPos = expression.find("(", parametersEnd + 1);
-      } else  // Math function or math constant : Pass it.
-      {
-        nonFunctionToken += expression.substr(
-            parsePosition, functionNameEnd + 1 - parsePosition);
-        expressionWithoutFunctions += expression.substr(
-            parsePosition, functionNameEnd + 1 - parsePosition);
-        nonFunctionTokenStartPos = (nonFunctionTokenStartPos != gd::String::npos
-                                        ? nonFunctionTokenStartPos
-                                        : parsePosition);
-        parsePosition = functionNameEnd + 1;
-        firstPointPos = expression.find(".", functionNameEnd + 1);
-        firstParPos = expression.find("(", functionNameEnd + 1);
-      }
-    } else  // Not a function call : Pass it
-    {
-      nonFunctionToken +=
-          expression.substr(parsePosition, nameEnd + 1 - parsePosition);
-      expressionWithoutFunctions +=
-          expression.substr(parsePosition, nameEnd + 1 - parsePosition);
-      nonFunctionTokenStartPos = (nonFunctionTokenStartPos != gd::String::npos
-                                      ? nonFunctionTokenStartPos
-                                      : parsePosition);
-      parsePosition = nameEnd + 1;
-      firstPointPos = expression.find(".", nameEnd + 1);
-      firstParPos = expression.find("(", nameEnd + 1);
-    }
-  }
-
-  if (parsePosition < expression.length() || !nonFunctionToken.empty())
-    callbacks.OnConstantToken(
-        nonFunctionToken +
-        expression.substr(parsePosition, expression.length()));
-
-  expressionWithoutFunctions +=
-      expression.substr(parsePosition, expression.length());
-
-  return ValidSyntax(expressionWithoutFunctions);
-}
-
-bool ExpressionParser::ParseStringExpression(const gd::Platform& platform,
-                                             const gd::ObjectsContainer& project,
-                                             const gd::ObjectsContainer& layout,
-                                             gd::ParserCallbacks& callbacks) {
-  callbacks.SetReturnType("string");
-  gd::String expression = expressionPlainString;
-
-  size_t parsePosition = 0;
-
-  // Searching for first token.
-  size_t firstPointPos = expression.find(".");
-  size_t firstParPos = expression.find("(");
-  size_t firstQuotePos = expression.find("\"");
-
-  if (firstPointPos == string::npos && firstParPos == string::npos &&
-      firstQuotePos == string::npos) {
-    firstErrorPos = 0;
-    firstErrorStr =
-        _("The expression is invalid or empty. Enter a text ( surrounded by "
-          "quotes ) or a function.");
-
-    return false;
-  }
-
-  while (firstPointPos != string::npos || firstParPos != string::npos ||
-         firstQuotePos != string::npos) {
-    if (firstQuotePos < firstPointPos &&
-        firstQuotePos < firstParPos)  // Adding a constant text
-    {
-      callbacks.OnConstantToken(
-          expression.substr(parsePosition, firstQuotePos - parsePosition));
-
-      // Finding start and end of quotes
-      size_t finalQuotePosition = expression.find("\"", firstQuotePos + 1);
-      while (finalQuotePosition ==
-             expression.find("\\\"", finalQuotePosition - 1) + 1)
-        finalQuotePosition = expression.find("\"", finalQuotePosition + 1);
-
-      if (finalQuotePosition == string::npos) {
-        firstErrorPos = firstQuotePos;
-        firstErrorStr = _("Quotes not closed.");
-
-        return false;
-      }
-
-      // Generating final text, by replacing \" by quotes
-      gd::String finalText = expression.substr(
-          firstQuotePos + 1, finalQuotePosition - (firstQuotePos + 1));
-
-      size_t foundPos = finalText.find("\\\"");
-      while (foundPos != string::npos) {
-        if (foundPos != string::npos) finalText.replace(foundPos, 2, "\"");
-        foundPos = finalText.find("\\\"", foundPos);
-      }
-
-      // Adding constant text instruction
-      //(Function without name is considered as a constant text)
-      vector<gd::Expression> parameters;
-      parameters.push_back(finalText);
-      gd::ExpressionMetadata noParametersInfo;
-
-      callbacks.OnStaticFunction("", parameters, noParametersInfo);
-
-      parsePosition = finalQuotePosition + 1;
-    } else  // Adding a function
-    {
-      // Identify name
-      size_t nameEnd =
-          firstPointPos < firstParPos ? firstPointPos : firstParPos;
-      size_t nameStart = expression.find_last_of(parserSeparators, nameEnd - 1);
-      nameStart++;
-
-      callbacks.OnConstantToken(
-          expression.substr(parsePosition, nameStart - parsePosition));
-
-      gd::String nameBefore = expression.substr(nameStart, nameEnd - nameStart);
-      gd::String objectName = nameBefore.FindAndReplace("~", " ");
-
-      // Identify function name
-      gd::String functionName = nameBefore;
-      size_t functionNameEnd = nameEnd;
-      vector<gd::Expression> parameters;
-
-      bool nameIsFunction = firstPointPos > firstParPos;
-      if (!nameIsFunction) {
-        parameters.push_back(gd::Expression(objectName));
-        functionNameEnd = expression.find_first_of("( ", nameEnd);
-        if (nameEnd + 1 < expression.length())
-          functionName =
-              expression.substr(nameEnd + 1, functionNameEnd - (nameEnd + 1));
-      }
-
-      // Identify parameters
-      size_t parametersEnd = expression.find_first_of("(", functionNameEnd) + 1;
-      char32_t previousChar = U'(';
-      bool takeSymbolsInAccount = true;
-      size_t level = 0;
-      gd::String currentParameterStr;
-      while (parametersEnd < expression.length() &&
-             !(expression[parametersEnd] == U')' && level == 0)) {
-        // Be sure we are not in quotes
-        if (expression[parametersEnd] == U'\"' && previousChar != U'\\')
-          takeSymbolsInAccount = !takeSymbolsInAccount;
-
-        // So as to be sure paranthesis don't belong to a parameter
-        if (expression[parametersEnd] == U'(' && takeSymbolsInAccount) level++;
-        if (expression[parametersEnd] == U')' && takeSymbolsInAccount) level--;
-
-        // Add the character to the current parameter or terminate the latter
-        if ((expression[parametersEnd] == ',' && level == 0) &&
-            takeSymbolsInAccount) {
-          gd::Expression currentParameter(currentParameterStr);
-          parameters.push_back(currentParameter);
-
-          currentParameterStr.clear();
-        } else
-          currentParameterStr += expression[parametersEnd];
-
-        previousChar = expression[parametersEnd];
-        parametersEnd++;
-      }
-
-      if (parametersEnd == expression.length() ||
-          expression[parametersEnd] != U')') {
-        firstErrorPos = parametersEnd - 1;
-        firstErrorStr = _("Paranthesis not closed");
-
-        return false;
-      }
-
-      if (currentParameterStr.find_first_not_of(" ") !=
-          string::npos)  // Add last parameter if needed
-      {
-        gd::Expression lastParameter(currentParameterStr);
-        parameters.push_back(lastParameter);
-      }
-
-      bool functionFound = false;
-
-      // First try to bind to a static str expression
-      if (nameIsFunction &&
-          MetadataProvider::HasStrExpression(platform, functionName)) {
-        functionFound = true;
-        const gd::ExpressionMetadata& expressionInfo =
-            MetadataProvider::GetStrExpressionMetadata(platform, functionName);
-
-        // Testing the number of parameters
-        if (parameters.size() >
-                GetMaximalParametersNumber(expressionInfo.parameters) ||
-            parameters.size() <
-                GetMinimalParametersNumber(expressionInfo.parameters)) {
-          firstErrorPos = functionNameEnd;
-          firstErrorStr = _("Incorrect number of parameters");
-
-          return false;
-        }
-
-        // Preparing parameters
-        parameters = CompleteParameters(expressionInfo.parameters, parameters);
-        for (std::size_t i = 0;
-             i < parameters.size() && i < expressionInfo.parameters.size();
-             ++i) {
-          if (!PrepareParameter(platform,
-                                project,
-                                layout,
-                                callbacks,
-                                parameters[i],
-                                expressionInfo.parameters[i],
-                                functionNameEnd))
-            return false;
-        }
-
-        callbacks.OnStaticFunction(functionName, parameters, expressionInfo);
-      }
-      // Then an object member expression
-      else if (!nameIsFunction &&
-               MetadataProvider::HasObjectStrExpression(
-                   platform,
-                   gd::GetTypeOfObject(project, layout, objectName),
-                   functionName)) {
-        functionFound = true;
-        const gd::ExpressionMetadata& expressionInfo =
-            MetadataProvider::GetObjectStrExpressionMetadata(
-                platform,
-                gd::GetTypeOfObject(project, layout, nameBefore),
-                functionName);
-
-        // Testing the number of parameters
-        if (parameters.size() >
-                GetMaximalParametersNumber(expressionInfo.parameters) ||
-            parameters.size() <
-                GetMinimalParametersNumber(expressionInfo.parameters)) {
-          firstErrorPos = functionNameEnd;
-          firstErrorStr = _("Incorrect number of parameters");
-
-          return false;
-        }
-
-        // Preparing parameters
-        parameters = CompleteParameters(expressionInfo.parameters, parameters);
-        for (std::size_t i = 0;
-             i < parameters.size() && i < expressionInfo.parameters.size();
-             ++i) {
-          if (!PrepareParameter(platform,
-                                project,
-                                layout,
-                                callbacks,
-                                parameters[i],
-                                expressionInfo.parameters[i],
-                                functionNameEnd))
-            return false;
-        }
-
-        callbacks.OnObjectFunction(functionName, parameters, expressionInfo);
-      }
-      // And search behaviors expressions
-      else {
-        size_t firstDoublePoints = functionName.find("::");
-        if (firstDoublePoints != string::npos) {
-          gd::String autoName = functionName.substr(0, firstDoublePoints);
-          if (firstDoublePoints + 2 < functionName.length())
-            functionName = functionName.substr(firstDoublePoints + 2,
-                                               functionName.length());
-          else
-            functionName = "";
-
-          if (MetadataProvider::HasBehaviorStrExpression(
-                  platform,
-                  gd::GetTypeOfBehavior(project, layout, autoName),
-                  functionName)) {
-            parameters.push_back(gd::Expression(autoName));
-            functionFound = true;
-
-            const gd::ExpressionMetadata& expressionInfo =
-                MetadataProvider::GetBehaviorStrExpressionMetadata(
-                    platform,
-                    gd::GetTypeOfBehavior(project, layout, autoName),
-                    functionName);
-
-            // Verify that object has behavior.
-            vector<gd::String> behaviors =
-                gd::GetBehaviorsOfObject(project, layout, objectName);
-            if (find(behaviors.begin(), behaviors.end(), autoName) ==
-                behaviors.end()) {
-              cout << "Bad behavior requested" << endl;
-              functionFound = false;
-            } else {
-              // Testing the number of parameters
-              if (parameters.size() >
-                      GetMaximalParametersNumber(expressionInfo.parameters) ||
-                  parameters.size() <
-                      GetMinimalParametersNumber(expressionInfo.parameters)) {
-                firstErrorPos = functionNameEnd;
-                firstErrorStr = _("Incorrect number of parameters");
-
-                return false;
-              }
-
-              // Preparing parameters
-              parameters =
-                  CompleteParameters(expressionInfo.parameters, parameters);
-              for (std::size_t i = 0; i < parameters.size() &&
-                                      i < expressionInfo.parameters.size();
-                   ++i) {
-                if (!PrepareParameter(platform,
-                                      project,
-                                      layout,
-                                      callbacks,
-                                      parameters[i],
-                                      expressionInfo.parameters[i],
-                                      functionNameEnd))
-                  return false;
-              }
-
-              callbacks.OnObjectBehaviorFunction(
-                  functionName, parameters, expressionInfo);
-            }
-          }
-        }
-      }
-
-      // Note : _No_ support for implicit conversion from math result to string
-
-      if (!functionFound)  // Function was not found
-      {
-        firstErrorPos = nameStart;
-        firstErrorStr = _("Function not recognized.");
-
-        return false;
-      }
-
-      parsePosition = parametersEnd + 1;
-    }
-
-    // Searching for next token
-    size_t firstPlusPos = expression.find("+", parsePosition);
-    firstPointPos = expression.find(".", parsePosition);
-    firstParPos = expression.find("(", parsePosition);
-    firstQuotePos = expression.find("\"", parsePosition);
-
-    // Checking for a + between token
-    if ((firstPointPos != string::npos || firstParPos != string::npos ||
-         firstQuotePos != string::npos)) {
-      size_t nextTokenPos = firstPointPos;
-      if (firstParPos < nextTokenPos) nextTokenPos = firstParPos;
-      if (firstQuotePos < nextTokenPos) nextTokenPos = firstQuotePos;
-
-      if (nextTokenPos < firstPlusPos) {
-        firstErrorPos = nextTokenPos;
-        firstErrorStr = _("Symbol missing between two +.");
-
-        return false;
-      } else if (expression.find("+", firstPlusPos + 1) < nextTokenPos) {
-        firstErrorPos = firstPlusPos;
-        firstErrorStr = _("Symbol missing between two +.");
-
-        return false;
-      }
-    }
-  }
-
-  if (expression.substr(parsePosition, expression.length())
-          .find_first_not_of(" \n") != gd::String::npos) {
-    firstErrorPos = parsePosition;
-    firstErrorStr = _("Bad symbol at the end of the expression.");
-
-    return false;
-  }
-
-  return true;
-}
-
-bool ExpressionParser::PrepareParameter(
-    const gd::Platform& platform,
-    const gd::ObjectsContainer& project,
-    const gd::ObjectsContainer& layout,
-    ParserCallbacks& callbacks,
-    gd::Expression& parameter,
-    const gd::ParameterMetadata& parametersInfo,
-    const size_t positionInExpression) {
-  if (ParameterMetadata::IsExpression("number", parametersInfo.type)) {
-    if (parametersInfo.optional && parameter.GetPlainString().empty())
-      parameter = parametersInfo.GetDefaultValue().empty()
-                      ? gd::Expression("0")
-                      : gd::Expression(parametersInfo.GetDefaultValue());
-
-    if (!callbacks.OnSubMathExpression(platform, project, layout, parameter)) {
-      firstErrorStr = callbacks.firstErrorStr;
-      firstErrorPos = callbacks.firstErrorPos + positionInExpression;
-
-      return false;
-    }
-  } else if (ParameterMetadata::IsExpression("string", parametersInfo.type)) {
-    if (parametersInfo.optional && parameter.GetPlainString().empty())
-      parameter = parametersInfo.GetDefaultValue().empty()
-                      ? gd::Expression("\"\"")
-                      : gd::Expression(parametersInfo.GetDefaultValue());
-
-    if (!callbacks.OnSubTextExpression(platform, project, layout, parameter)) {
-      firstErrorStr = callbacks.firstErrorStr;
-      firstErrorPos = callbacks.firstErrorPos + positionInExpression;
-
-      return false;
-    }
-  }
-
-  return true;
-}
-
-ExpressionParser::ExpressionParser(const gd::String& expressionPlainString_)
-    : expressionPlainString(expressionPlainString_) {}
-
-}  // namespace gd

Core/GDCore/Events/Parsers/ExpressionParser.h

@@ -1,179 +0,0 @@
-/*
- * GDevelop Core
- * Copyright 2008-2016 Florian Rival (Florian.Rival@gmail.com). All rights
- * reserved. This project is released under the MIT License.
- */
-#ifndef GDCORE_EXPRESSIONPARSER_H
-#define GDCORE_EXPRESSIONPARSER_H
-
-#include <vector>
-#include "GDCore/String.h"
-namespace gd {
-class Expression;
-class ParserCallbacks;
-class ObjectsContainer;
-class Platform;
-class ParameterMetadata;
-class ExpressionMetadata;
-}
-
-namespace gd {
-
-/** \brief Parse an expression
- *
- * Parse an expression, calling callbacks when a token is reached
- * \see gd::ParserCallbacks
- */
-class GD_CORE_API ExpressionParser {
- public:
-  ExpressionParser(const gd::String &expressionPlainString_);
-  virtual ~ExpressionParser(){};
-
-  /**
-   * \brief Parse the expression, calling each functor when necessary
-   * \return True if expression was correctly parsed.
-   */
-  bool ParseMathExpression(const gd::Platform &platform,
-                           const gd::ObjectsContainer &project,
-                           const gd::ObjectsContainer &layout,
-                           gd::ParserCallbacks &callbacks);
-
-  /**
-   * \brief Parse the expression, calling each functor when necessary
-   * \return True if expression was correctly parsed.
-   */
-  bool ParseStringExpression(const gd::Platform &platform,
-                             const gd::ObjectsContainer &project,
-                             const gd::ObjectsContainer &layout,
-                             gd::ParserCallbacks &callbacks);
-
-  /**
-   * \brief Return the description of the error that was found
-   */
-  const gd::String &GetFirstError() { return firstErrorStr; }
-
-  /**
-   * \brief Return the position of the error that was found
-   * \return The position, or gd::String::npos if no error is found
-   */
-  size_t GetFirstErrorPosition() { return firstErrorPos; }
-
- private:
-  gd::String firstErrorStr;
-  size_t firstErrorPos;
-
-  /**
-   * Tool function to add a parameter
-   */
-  bool AddParameterToList(const gd::ObjectsContainer &project,
-                          const gd::ObjectsContainer &layout,
-                          ParserCallbacks &,
-                          std::vector<gd::Expression> &parameters,
-                          gd::String parameterStr,
-                          std::vector<gd::ParameterMetadata> parametersInfos,
-                          const size_t positionInExpression);
-
-  /**
-   * Tool function to prepare a parameter
-   */
-  bool PrepareParameter(const gd::Platform &platform,
-                        const gd::ObjectsContainer &project,
-                        const gd::ObjectsContainer &layout,
-                        ParserCallbacks &,
-                        gd::Expression &parameter,
-                        const gd::ParameterMetadata &parametersInfo,
-                        const size_t positionInExpression);
-
-  /**
-   * Return the minimal number of parameters which can be used when calling an
-   * expression ( i.e. ParametersCount-OptionalParameters-CodeOnlyParameters )
-   */
-  size_t GetMinimalParametersNumber(
-      const std::vector<gd::ParameterMetadata> &parametersInfos);
-
-  /**
-   * Return the maximal number of parameters which can be used when calling an
-   * expression ( i.e. ParametersCount-CodeOnlyParameters )
-   */
-  size_t GetMaximalParametersNumber(
-      const std::vector<gd::ParameterMetadata> &parametersInfos);
-
-  bool ValidSyntax(const gd::String &str);
-
-  gd::String expressionPlainString;
-  static gd::String parserSeparators;
-};
-
-/** \brief Callbacks called by parser during parsing
- *
- * Parser will call the appropriate functions during parsing, allowing to do
- * special works. \see gd::ExpressionParser
- */
-class GD_CORE_API ParserCallbacks {
-  friend class ExpressionParser;
-
- public:
-  ParserCallbacks() : returnType("expression"){};
-  virtual ~ParserCallbacks(){};
-
-  /**
-   * \brief Get the type of the expression for which callbacks are used:
-   * "expression" or "string".
-   */
-  const gd::String &GetReturnType() { return returnType; }
-
-  virtual void OnConstantToken(gd::String text) = 0;
-
-  virtual void OnStaticFunction(
-      gd::String functionName,
-      const std::vector<gd::Expression> &parameters,
-      const gd::ExpressionMetadata &expressionInfo) = 0;
-
-  virtual void OnObjectFunction(
-      gd::String functionName,
-      const std::vector<gd::Expression> &parameters,
-      const gd::ExpressionMetadata &expressionInfo) = 0;
-
-  virtual void OnObjectBehaviorFunction(
-      gd::String functionName,
-      const std::vector<gd::Expression> &parameters,
-      const gd::ExpressionMetadata &expressionInfo) = 0;
-
-  virtual bool OnSubMathExpression(const gd::Platform &platform,
-                                   const gd::ObjectsContainer &project,
-                                   const gd::ObjectsContainer &layout,
-                                   gd::Expression &expression) = 0;
-  virtual bool OnSubTextExpression(const gd::Platform &platform,
-                                   const gd::ObjectsContainer &project,
-                                   const gd::ObjectsContainer &layout,
-                                   gd::Expression &expression) = 0;
-
-  /**
-   * \brief Return the description of the error that was found
-   */
-  const gd::String &GetFirstError() { return firstErrorStr; }
-
-  /**
-   * \brief Return the position of the error that was found
-   * \return The position, or gd::String::npos if no error is found
-   */
-  size_t GetFirstErrorPosition() { return firstErrorPos; }
-
- protected:
-  gd::String firstErrorStr;
-  size_t firstErrorPos;
-
- private:
-  /**
-   * \brief Set the return type of the expression: Done by ExpressionParser
-   * according to which Parse* method is called. \see gd::ExpressionParser
-   */
-  void SetReturnType(gd::String type) { returnType = type; }
-
-  gd::String returnType;  // The type of the expression ("expression" (default),
-                          // "string"...)
-};
-
-}  // namespace gd
-
-#endif  // GDEXPRESSIONPARSER_H

Core/GDCore/Events/Parsers/ExpressionParser2.cpp

@@ -22,15 +22,6 @@ using namespace std;
 
 namespace gd {
 
-gd::String ExpressionParser2::NUMBER_FIRST_CHAR = ".0123456789";
-gd::String ExpressionParser2::DOT = ".";
-gd::String ExpressionParser2::PARAMETERS_SEPARATOR = ",";
-gd::String ExpressionParser2::QUOTE = "\"";
-gd::String ExpressionParser2::BRACKETS = "()[]{}";
-gd::String ExpressionParser2::EXPRESSION_OPERATORS = "+-<>?^=\\:!";
-gd::String ExpressionParser2::TERM_OPERATORS = "/*";
-gd::String ExpressionParser2::UNARY_OPERATORS = "+-";
-gd::String ExpressionParser2::WHITESPACES = " \n\r";
 gd::String ExpressionParser2::NAMESPACE_SEPARATOR = "::";
 
 ExpressionParser2::ExpressionParser2(
@@ -76,7 +67,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>(
@@ -118,11 +109,13 @@ std::unique_ptr<ExpressionParserDiagnostic> ExpressionParser2::ValidateFunction(
 }
 
 std::unique_ptr<TextNode> ExpressionParser2::ReadText() {
-  SkipWhitespace();
-  if (!IsAnyChar("\"")) {
+  size_t textStartPosition = GetCurrentPosition();
+  SkipAllWhitespaces();
+  if (!CheckIfChar(IsQuote)) {
     auto text = gd::make_unique<TextNode>("");
     text->diagnostic =
         RaiseSyntaxError(_("A text must start with a double quote (\")."));
+    text->location = ExpressionParserLocation(textStartPosition, GetCurrentPosition());
     return text;
   }
   SkipChar();
@@ -157,6 +150,7 @@ std::unique_ptr<TextNode> ExpressionParser2::ReadText() {
   }
 
   auto text = gd::make_unique<TextNode>(parsedText);
+  text->location = ExpressionParserLocation(textStartPosition, GetCurrentPosition());
   if (!textParsingHasEnded) {
     text->diagnostic =
         RaiseSyntaxError(_("A text must end with a double quote (\"). Add a "
@@ -167,24 +161,25 @@ std::unique_ptr<TextNode> ExpressionParser2::ReadText() {
 }
 
 std::unique_ptr<NumberNode> ExpressionParser2::ReadNumber() {
-  SkipWhitespace();
+  size_t numberStartPosition = GetCurrentPosition();
+  SkipAllWhitespaces();
   gd::String parsedNumber;
 
   bool numberHasStarted = false;
   bool digitFound = false;
   bool dotFound = false;
   while (!IsEndReached()) {
-    if (IsAnyChar("0")) {
+    if (CheckIfChar(IsZeroDigit)) {
       numberHasStarted = true;
       digitFound = true;
       if (!parsedNumber.empty()) { // Ignore leading 0s.
         parsedNumber += GetCurrentChar();
       }
-    } else if (IsAnyChar("123456789")) {
+    } else if (CheckIfChar(IsNonZeroDigit)) {
       numberHasStarted = true;
       digitFound = true;
       parsedNumber += GetCurrentChar();
-    } else if (IsAnyChar(".") && !dotFound) {
+    } else if (CheckIfChar(IsDot) && !dotFound) {
       numberHasStarted = true;
       dotFound = true;
       if (parsedNumber == "") {
@@ -209,6 +204,7 @@ std::unique_ptr<NumberNode> ExpressionParser2::ReadNumber() {
   // valid in most languages so we allow this.
 
   auto number = gd::make_unique<NumberNode>(parsedNumber);
+  number->location = ExpressionParserLocation(numberStartPosition, GetCurrentPosition());
   if (!numberHasStarted || !digitFound) {
     number->diagnostic = RaiseSyntaxError(
         _("A number was expected. You must enter a number here."));

Core/GDCore/Events/Parsers/ExpressionParser2.h

@@ -9,6 +9,7 @@
 #include <memory>
 #include <utility>
 #include <vector>
+
 #include "ExpressionParser2Node.h"
 #include "GDCore/Extensions/Metadata/ExpressionMetadata.h"
 #include "GDCore/Extensions/Metadata/MetadataProvider.h"
@@ -48,8 +49,9 @@ class GD_CORE_API ExpressionParser2 {
    *
    * \param type Type of the expression: "string", "number",
    * type supported by gd::ParameterMetadata::IsObject, types supported by
-   * gd::ParameterMetadata::IsExpression or "unknown". \param expression The
-   * expression to parse \param objectName Specify the object name, only for the
+   * gd::ParameterMetadata::IsExpression or "unknown".
+   * \param expression The expression to parse
+   * \param objectName Specify the object name, only for the
    * case of "objectvar" type.
    *
    * \return The node representing the expression as a parsed tree.
@@ -71,18 +73,21 @@ class GD_CORE_API ExpressionParser2 {
   ///@{
   std::unique_ptr<ExpressionNode> Start(const gd::String &type,
                                         const gd::String &objectName = "") {
+    size_t expressionStartPosition = GetCurrentPosition();
     auto expression = Expression(type, objectName);
 
     // Check for extra characters at the end of the expression
     if (!IsEndReached()) {
-      auto op = gd::make_unique<OperatorNode>();
-      op->op = ' ';
+      auto op = gd::make_unique<OperatorNode>(type, ' ');
       op->leftHandSide = std::move(expression);
       op->rightHandSide = ReadUntilEnd("unknown");
 
       op->rightHandSide->diagnostic = RaiseSyntaxError(
           _("The expression has extra character at the end that should be "
             "removed (or completed if your expression is not finished)."));
+
+      op->location = ExpressionParserLocation(expressionStartPosition,
+                                              GetCurrentPosition());
       return std::move(op);
     }
 
@@ -91,22 +96,24 @@ class GD_CORE_API ExpressionParser2 {
 
   std::unique_ptr<ExpressionNode> Expression(
       const gd::String &type, const gd::String &objectName = "") {
-    SkipWhitespace();
+    SkipAllWhitespaces();
 
     size_t expressionStartPosition = GetCurrentPosition();
     std::unique_ptr<ExpressionNode> leftHandSide = Term(type, objectName);
 
-    SkipWhitespace();
+    SkipAllWhitespaces();
 
     if (IsEndReached()) return leftHandSide;
-    if (IsAnyChar(",)]")) return leftHandSide;
-    if (IsAnyChar(EXPRESSION_OPERATORS)) {
-      auto op = gd::make_unique<OperatorNode>();
-      op->op = GetCurrentChar();
+    if (CheckIfChar(IsExpressionEndingChar)) return leftHandSide;
+    if (CheckIfChar(IsExpressionOperator)) {
+      auto op = gd::make_unique<OperatorNode>(type, GetCurrentChar());
       op->leftHandSide = std::move(leftHandSide);
       op->diagnostic = ValidateOperator(type, GetCurrentChar());
       SkipChar();
       op->rightHandSide = Expression(type, objectName);
+
+      op->location = ExpressionParserLocation(expressionStartPosition,
+                                              GetCurrentPosition());
       return std::move(op);
     }
 
@@ -124,31 +131,35 @@ class GD_CORE_API ExpressionParser2 {
           "properly written.");
     }
 
-    auto op = gd::make_unique<OperatorNode>();
-    op->op = ' ';
+    auto op = gd::make_unique<OperatorNode>(type, ' ');
     op->leftHandSide = std::move(leftHandSide);
     op->rightHandSide = Expression(type, objectName);
+    op->location =
+        ExpressionParserLocation(expressionStartPosition, GetCurrentPosition());
     return std::move(op);
   }
 
   std::unique_ptr<ExpressionNode> Term(const gd::String &type,
                                        const gd::String &objectName) {
-    SkipWhitespace();
+    SkipAllWhitespaces();
 
+    size_t expressionStartPosition = GetCurrentPosition();
     std::unique_ptr<ExpressionNode> factor = Factor(type, objectName);
-    SkipWhitespace();
+
+    SkipAllWhitespaces();
 
     // This while loop is used instead of a recursion (like in Expression)
     // to guarantee the proper operator precedence. (Expression could also
     // be reworked to use a while loop).
-    while (IsAnyChar(TERM_OPERATORS)) {
-      auto op = gd::make_unique<OperatorNode>();
-      op->op = GetCurrentChar();
+    while (CheckIfChar(IsTermOperator)) {
+      auto op = gd::make_unique<OperatorNode>(type, GetCurrentChar());
       op->leftHandSide = std::move(factor);
       op->diagnostic = ValidateOperator(type, GetCurrentChar());
       SkipChar();
       op->rightHandSide = Factor(type, objectName);
-      SkipWhitespace();
+      op->location = ExpressionParserLocation(expressionStartPosition,
+                                              GetCurrentPosition());
+      SkipAllWhitespaces();
 
       factor = std::move(op);
     }
@@ -158,12 +169,12 @@ class GD_CORE_API ExpressionParser2 {
 
   std::unique_ptr<ExpressionNode> Factor(const gd::String &type,
                                          const gd::String &objectName) {
-    SkipWhitespace();
+    SkipAllWhitespaces();
 
     size_t expressionStartPosition = GetCurrentPosition();
     std::unique_ptr<ExpressionNode> factor;
 
-    if (IsAnyChar(QUOTE)) {
+    if (CheckIfChar(IsQuote)) {
       factor = ReadText();
       if (type == "number")
         factor->diagnostic =
@@ -173,14 +184,17 @@ class GD_CORE_API ExpressionParser2 {
         factor->diagnostic = RaiseTypeError(
             _("You entered a text, but this type was expected:") + type,
             expressionStartPosition);
-    } else if (IsAnyChar(UNARY_OPERATORS)) {
-      auto unaryOperator = gd::make_unique<UnaryOperatorNode>(GetCurrentChar());
+    } else if (CheckIfChar(IsUnaryOperator)) {
+      auto unaryOperator =
+          gd::make_unique<UnaryOperatorNode>(type, GetCurrentChar());
       unaryOperator->diagnostic = ValidateUnaryOperator(type, GetCurrentChar());
       SkipChar();
       unaryOperator->factor = Factor(type, objectName);
 
+      unaryOperator->location = ExpressionParserLocation(
+          expressionStartPosition, GetCurrentPosition());
       factor = std::move(unaryOperator);
-    } else if (IsAnyChar(NUMBER_FIRST_CHAR)) {
+    } else if (CheckIfChar(IsNumberFirstChar)) {
       factor = ReadNumber();
       if (type == "string")
         factor->diagnostic = RaiseTypeError(
@@ -190,16 +204,16 @@ class GD_CORE_API ExpressionParser2 {
         factor->diagnostic = RaiseTypeError(
             _("You entered a number, but this type was expected:") + type,
             expressionStartPosition);
-    } else if (IsAnyChar("(")) {
+    } else if (CheckIfChar(IsOpeningParenthesis)) {
       SkipChar();
       factor = SubExpression(type, objectName);
 
-      if (!IsAnyChar(")")) {
+      if (!CheckIfChar(IsClosingParenthesis)) {
         factor->diagnostic =
             RaiseSyntaxError(_("Missing a closing parenthesis. Add a closing "
                                "parenthesis for each opening parenthesis."));
       }
-      SkipIfIsAnyChar(")");
+      SkipIfChar(IsClosingParenthesis);
     } else if (IsIdentifierAllowedChar()) {
       // This is a place where the grammar differs according to the
       // type being expected.
@@ -218,92 +232,132 @@ class GD_CORE_API ExpressionParser2 {
 
   std::unique_ptr<SubExpressionNode> SubExpression(
       const gd::String &type, const gd::String &objectName) {
-    return std::move(
-        gd::make_unique<SubExpressionNode>(Expression(type, objectName)));
+    size_t expressionStartPosition = GetCurrentPosition();
+    auto subExpression =
+        gd::make_unique<SubExpressionNode>(type, Expression(type, objectName));
+    subExpression->location =
+        ExpressionParserLocation(expressionStartPosition, GetCurrentPosition());
+
+    return std::move(subExpression);
   };
 
-  std::unique_ptr<IdentifierOrFunctionOrEmptyNode> Identifier(
-      const gd::String &type) {
-    size_t identifierStartPosition = GetCurrentPosition();
-    gd::String name = ReadIdentifierName();
+  std::unique_ptr<IdentifierOrFunctionCallOrObjectFunctionNameOrEmptyNode>
+  Identifier(const gd::String &type) {
+    auto identifierAndLocation = ReadIdentifierName();
+    gd::String name = identifierAndLocation.name;
+    auto nameLocation = identifierAndLocation.location;
 
-    SkipWhitespace();
+    SkipAllWhitespaces();
 
+    // We consider a namespace separator to be allowed here and be part of the
+    // function name (or object name, but object names are not allowed to
+    // contain a ":"). This is because functions from extensions have their
+    // extension name prefix, and separated by the namespace separator. This
+    // could maybe be refactored to create different nodes in the future.
     if (IsNamespaceSeparator()) {
       SkipNamespaceSeparator();
+      SkipAllWhitespaces();
 
+      auto postNamespaceIdentifierAndLocation = ReadIdentifierName();
       name += NAMESPACE_SEPARATOR;
-      name += ReadIdentifierName();
+      name += postNamespaceIdentifierAndLocation.name;
+      ExpressionParserLocation completeNameLocation(
+          nameLocation.GetStartPosition(),
+          postNamespaceIdentifierAndLocation.location.GetEndPosition());
+      nameLocation = completeNameLocation;
     }
 
-    if (IsAnyChar("(")) {
-      SkipChar();
-      return FreeFunction(type, name, identifierStartPosition);
-    } else if (IsAnyChar(DOT)) {
-      SkipChar();
+    if (CheckIfChar(IsOpeningParenthesis)) {
+      ExpressionParserLocation openingParenthesisLocation = SkipChar();
+      return FreeFunction(type, name, nameLocation, openingParenthesisLocation);
+    } else if (CheckIfChar(IsDot)) {
+      ExpressionParserLocation dotLocation = SkipChar();
+      SkipAllWhitespaces();
       return ObjectFunctionOrBehaviorFunction(
-          type, name, identifierStartPosition);
+          type, name, nameLocation, dotLocation);
     } else {
       auto identifier = gd::make_unique<IdentifierNode>(name, type);
       if (type == "string") {
         identifier->diagnostic =
             RaiseTypeError(_("You must wrap your text inside double quotes "
                              "(example: \"Hello world\")."),
-                           identifierStartPosition);
+                           nameLocation.GetStartPosition());
       } else if (type == "number") {
-        identifier->diagnostic = RaiseTypeError(_("You must enter a number."),
-                                                identifierStartPosition);
+        identifier->diagnostic = RaiseTypeError(
+            _("You must enter a number."), nameLocation.GetStartPosition());
       } else if (!gd::ParameterMetadata::IsObject(type)) {
         identifier->diagnostic = RaiseTypeError(
             _("You've entered a name, but this type was expected:") + type,
-            identifierStartPosition);
+            nameLocation.GetStartPosition());
       }
 
+      identifier->location = ExpressionParserLocation(
+          nameLocation.GetStartPosition(), GetCurrentPosition());
       return std::move(identifier);
     }
   }
 
   std::unique_ptr<VariableNode> Variable(const gd::String &type,
                                          const gd::String &objectName) {
-    size_t identifierStartPosition = GetCurrentPosition();
+    auto identifierAndLocation = ReadIdentifierName();
+    const gd::String &name = identifierAndLocation.name;
+    const auto &nameLocation = identifierAndLocation.location;
 
-    gd::String name = ReadIdentifierName();
     auto variable = gd::make_unique<VariableNode>(type, name, objectName);
     variable->child = VariableAccessorOrVariableBracketAccessor();
 
+    variable->location = ExpressionParserLocation(
+        nameLocation.GetStartPosition(), GetCurrentPosition());
+    variable->nameLocation = nameLocation;
     return std::move(variable);
   }
 
   std::unique_ptr<VariableAccessorOrVariableBracketAccessorNode>
   VariableAccessorOrVariableBracketAccessor() {
-    std::unique_ptr<VariableAccessorOrVariableBracketAccessorNode> child;
-    SkipWhitespace();
-    if (IsAnyChar("[")) {
+    size_t childStartPosition = GetCurrentPosition();
+
+    SkipAllWhitespaces();
+    if (CheckIfChar(IsOpeningSquareBracket)) {
       SkipChar();
-      child =
+      auto child =
           gd::make_unique<VariableBracketAccessorNode>(Expression("string"));
 
-      if (!IsAnyChar("]")) {
+      if (!CheckIfChar(IsClosingSquareBracket)) {
         child->diagnostic =
             RaiseSyntaxError(_("Missing a closing bracket. Add a closing "
                                "bracket for each opening bracket."));
       }
-      SkipIfIsAnyChar("]");
+      SkipIfChar(IsClosingSquareBracket);
       child->child = VariableAccessorOrVariableBracketAccessor();
-    } else if (IsAnyChar(DOT)) {
-      SkipChar();
-      SkipWhitespace();
+      child->location =
+          ExpressionParserLocation(childStartPosition, GetCurrentPosition());
 
-      child = gd::make_unique<VariableAccessorNode>(ReadIdentifierName());
+      return std::move(child);
+    } else if (CheckIfChar(IsDot)) {
+      auto dotLocation = SkipChar();
+      SkipAllWhitespaces();
+
+      auto identifierAndLocation = ReadIdentifierName();
+      auto child =
+          gd::make_unique<VariableAccessorNode>(identifierAndLocation.name);
       child->child = VariableAccessorOrVariableBracketAccessor();
+      child->nameLocation = identifierAndLocation.location;
+      child->dotLocation = dotLocation;
+      child->location =
+          ExpressionParserLocation(childStartPosition, GetCurrentPosition());
+
+      return std::move(child);
     }
 
-    return child;
+    return std::move(
+        std::unique_ptr<VariableAccessorOrVariableBracketAccessorNode>());
   }
 
-  std::unique_ptr<FunctionNode> FreeFunction(const gd::String &type,
-                                             const gd::String &functionFullName,
-                                             size_t functionStartPosition) {
+  std::unique_ptr<FunctionCallNode> FreeFunction(
+      const gd::String &type,
+      const gd::String &functionFullName,
+      const ExpressionParserLocation &identifierLocation,
+      const ExpressionParserLocation &openingParenthesisLocation) {
     // TODO: error if trying to use function for type != "number" && != "string"
     // + Test for it
 
@@ -315,32 +369,49 @@ class GD_CORE_API ExpressionParser2 {
                          : MetadataProvider::GetStrExpressionMetadata(
                                platform, functionFullName);
 
-    auto parametersAndError = Parameters(metadata.parameters);
-    auto function = gd::make_unique<FunctionNode>(
-        type, std::move(parametersAndError.first), metadata, functionFullName);
-    function->diagnostic = std::move(parametersAndError.second);
+    auto parametersNode = Parameters(metadata.parameters);
+    auto function = gd::make_unique<FunctionCallNode>(
+        type, std::move(parametersNode.parameters), metadata, functionFullName);
+    function->diagnostic = std::move(parametersNode.diagnostic);
     if (!function->diagnostic)
-      function->diagnostic = ValidateFunction(*function, functionStartPosition);
+      function->diagnostic =
+          ValidateFunction(*function, identifierLocation.GetStartPosition());
 
+    function->location = ExpressionParserLocation(
+        identifierLocation.GetStartPosition(), GetCurrentPosition());
+    function->functionNameLocation = identifierLocation;
+    function->openingParenthesisLocation = openingParenthesisLocation;
+    function->closingParenthesisLocation =
+        parametersNode.closingParenthesisLocation;
     return std::move(function);
   }
 
-  std::unique_ptr<FunctionOrEmptyNode> ObjectFunctionOrBehaviorFunction(
+  std::unique_ptr<FunctionCallOrObjectFunctionNameOrEmptyNode>
+  ObjectFunctionOrBehaviorFunction(
       const gd::String &type,
       const gd::String &objectName,
-      size_t functionStartPosition) {
-    gd::String objectFunctionOrBehaviorName = ReadIdentifierName();
+      const ExpressionParserLocation &objectNameLocation,
+      const ExpressionParserLocation &objectNameDotLocation) {
+    auto identifierAndLocation = ReadIdentifierName();
+    const gd::String &objectFunctionOrBehaviorName = identifierAndLocation.name;
+    const auto &objectFunctionOrBehaviorNameLocation =
+        identifierAndLocation.location;
 
-    SkipWhitespace();
+    SkipAllWhitespaces();
 
     if (IsNamespaceSeparator()) {
-      SkipNamespaceSeparator();
+      ExpressionParserLocation namespaceSeparatorLocation =
+          SkipNamespaceSeparator();
+      SkipAllWhitespaces();
       return BehaviorFunction(type,
                               objectName,
                               objectFunctionOrBehaviorName,
-                              functionStartPosition);
-    } else if (IsAnyChar("(")) {
-      SkipChar();
+                              objectNameLocation,
+                              objectNameDotLocation,
+                              objectFunctionOrBehaviorNameLocation,
+                              namespaceSeparatorLocation);
+    } else if (CheckIfChar(IsOpeningParenthesis)) {
+      ExpressionParserLocation openingParenthesisLocation = SkipChar();
 
       gd::String objectType =
           GetTypeOfObject(globalObjectsContainer, objectsContainer, objectName);
@@ -354,40 +425,60 @@ class GD_CORE_API ExpressionParser2 {
               : MetadataProvider::GetObjectStrExpressionMetadata(
                     platform, objectType, objectFunctionOrBehaviorName);
 
-      auto parametersAndError = Parameters(metadata.parameters, objectName);
-      auto function =
-          gd::make_unique<FunctionNode>(type,
-                                        objectName,
-                                        std::move(parametersAndError.first),
-                                        metadata,
-                                        objectFunctionOrBehaviorName);
-      function->diagnostic = std::move(parametersAndError.second);
+      auto parametersNode = Parameters(metadata.parameters, objectName);
+      auto function = gd::make_unique<FunctionCallNode>(
+          type,
+          objectName,
+          std::move(parametersNode.parameters),
+          metadata,
+          objectFunctionOrBehaviorName);
+      function->diagnostic = std::move(parametersNode.diagnostic);
       if (!function->diagnostic)
         function->diagnostic =
-            ValidateFunction(*function, functionStartPosition);
+            ValidateFunction(*function, objectNameLocation.GetStartPosition());
 
+      function->location = ExpressionParserLocation(
+          objectNameLocation.GetStartPosition(), GetCurrentPosition());
+      function->objectNameLocation = objectNameLocation;
+      function->objectNameDotLocation = objectNameDotLocation;
+      function->functionNameLocation = objectFunctionOrBehaviorNameLocation;
+      function->openingParenthesisLocation = openingParenthesisLocation;
+      function->closingParenthesisLocation =
+          parametersNode.closingParenthesisLocation;
       return std::move(function);
     }
 
-    auto node = gd::make_unique<EmptyNode>(type);
+    auto node = gd::make_unique<ObjectFunctionNameNode>(
+        type, objectName, objectFunctionOrBehaviorName);
     node->diagnostic = RaiseSyntaxError(
         _("An opening parenthesis (for an object expression), or double colon "
           "(::) was expected (for a behavior expression)."));
 
+    node->location = ExpressionParserLocation(
+        objectNameLocation.GetStartPosition(), GetCurrentPosition());
+    node->objectNameLocation = objectNameLocation;
+    node->objectNameDotLocation = objectNameDotLocation;
+    node->objectFunctionOrBehaviorNameLocation =
+        objectFunctionOrBehaviorNameLocation;
     return std::move(node);
   }
 
-  std::unique_ptr<FunctionOrEmptyNode> BehaviorFunction(
+  std::unique_ptr<FunctionCallOrObjectFunctionNameOrEmptyNode> BehaviorFunction(
       const gd::String &type,
       const gd::String &objectName,
       const gd::String &behaviorName,
-      size_t functionStartPosition) {
-    gd::String functionName = ReadIdentifierName();
+      const ExpressionParserLocation &objectNameLocation,
+      const ExpressionParserLocation &objectNameDotLocation,
+      const ExpressionParserLocation &behaviorNameLocation,
+      const ExpressionParserLocation &behaviorNameNamespaceSeparatorLocation) {
+    auto identifierAndLocation = ReadIdentifierName();
+    const gd::String &functionName = identifierAndLocation.name;
+    const auto &functionNameLocation = identifierAndLocation.location;
 
-    SkipWhitespace();
+    SkipAllWhitespaces();
 
-    if (IsAnyChar("(")) {
-      SkipChar();
+    if (CheckIfChar(IsOpeningParenthesis)) {
+      ExpressionParserLocation openingParenthesisLocation = SkipChar();
 
       gd::String behaviorType = GetTypeOfBehavior(
           globalObjectsContainer, objectsContainer, behaviorName);
@@ -400,36 +491,63 @@ class GD_CORE_API ExpressionParser2 {
                            : MetadataProvider::GetBehaviorStrExpressionMetadata(
                                  platform, behaviorType, functionName);
 
-      auto parametersAndError =
+      auto parametersNode =
           Parameters(metadata.parameters, objectName, behaviorName);
-      auto function =
-          gd::make_unique<FunctionNode>(type,
-                                        objectName,
-                                        behaviorName,
-                                        std::move(parametersAndError.first),
-                                        metadata,
-                                        functionName);
-      function->diagnostic = std::move(parametersAndError.second);
+      auto function = gd::make_unique<FunctionCallNode>(
+          type,
+          objectName,
+          behaviorName,
+          std::move(parametersNode.parameters),
+          metadata,
+          functionName);
+      function->diagnostic = std::move(parametersNode.diagnostic);
       if (!function->diagnostic)
         function->diagnostic =
-            ValidateFunction(*function, functionStartPosition);
+            ValidateFunction(*function, objectNameLocation.GetStartPosition());
 
+      function->location = ExpressionParserLocation(
+          objectNameLocation.GetStartPosition(), GetCurrentPosition());
+      function->objectNameLocation = objectNameLocation;
+      function->objectNameDotLocation = objectNameDotLocation;
+      function->behaviorNameLocation = behaviorNameLocation;
+      function->behaviorNameNamespaceSeparatorLocation =
+          behaviorNameNamespaceSeparatorLocation;
+      function->openingParenthesisLocation = openingParenthesisLocation;
+      function->closingParenthesisLocation =
+          parametersNode.closingParenthesisLocation;
+      function->functionNameLocation = functionNameLocation;
       return std::move(function);
     } else {
-      auto node = gd::make_unique<EmptyNode>(type);
+      auto node = gd::make_unique<ObjectFunctionNameNode>(
+          type, objectName, behaviorName, functionName);
       node->diagnostic = RaiseSyntaxError(
           _("An opening parenthesis was expected here to call a function."));
 
+      node->location = ExpressionParserLocation(
+          objectNameLocation.GetStartPosition(), GetCurrentPosition());
+      node->objectNameLocation = objectNameLocation;
+      node->objectNameDotLocation = objectNameDotLocation;
+      node->objectFunctionOrBehaviorNameLocation = behaviorNameLocation;
+      node->behaviorNameNamespaceSeparatorLocation =
+          behaviorNameNamespaceSeparatorLocation;
+      node->behaviorFunctionNameLocation = functionNameLocation;
       return std::move(node);
     }
   }
 
-  std::pair<std::vector<std::unique_ptr<ExpressionNode>>,
-            std::unique_ptr<gd::ExpressionParserError>>
-  Parameters(std::vector<gd::ParameterMetadata> parameterMetadata,
-             const gd::String &objectName = "",
-             const gd::String &behaviorName = "") {
+  // A temporary node that will be integrated into function nodes.
+  struct ParametersNode {
     std::vector<std::unique_ptr<ExpressionNode>> parameters;
+    std::unique_ptr<gd::ExpressionParserError> diagnostic;
+    ExpressionParserLocation closingParenthesisLocation;
+  };
+
+  ParametersNode Parameters(
+      std::vector<gd::ParameterMetadata> parameterMetadata,
+      const gd::String &objectName = "",
+      const gd::String &behaviorName = "") {
+    std::vector<std::unique_ptr<ExpressionNode>> parameters;
+    gd::String lastObjectName = "";
 
     // By convention, object is always the first parameter, and behavior the
     // second one.
@@ -437,11 +555,12 @@ class GD_CORE_API ExpressionParser2 {
         WrittenParametersFirstIndex(objectName, behaviorName);
 
     while (!IsEndReached()) {
-      SkipWhitespace();
+      SkipAllWhitespaces();
 
-      if (IsAnyChar(")")) {
-        SkipChar();
-        return std::make_pair(std::move(parameters), nullptr);
+      if (CheckIfChar(IsClosingParenthesis)) {
+        auto closingParenthesisLocation = SkipChar();
+        return ParametersNode{
+            std::move(parameters), nullptr, closingParenthesisLocation};
       } else {
         if (parameterIndex < parameterMetadata.size()) {
           const gd::String &type = parameterMetadata[parameterIndex].GetType();
@@ -452,9 +571,32 @@ class GD_CORE_API ExpressionParser2 {
           } else if (gd::ParameterMetadata::IsExpression("string", type)) {
             parameters.push_back(Expression("string"));
           } else if (gd::ParameterMetadata::IsExpression("variable", type)) {
-            parameters.push_back(Expression(type, objectName));
+            parameters.push_back(Expression(
+                type, lastObjectName.empty() ? objectName : lastObjectName));
           } else if (gd::ParameterMetadata::IsObject(type)) {
-            parameters.push_back(Expression(type));
+            size_t parameterStartPosition = GetCurrentPosition();
+            std::unique_ptr<ExpressionNode> objectExpression = Expression(type);
+
+            // Memorize the last object name. By convention, parameters that
+            // require an object (mainly, "objectvar" and "behavior") should be
+            // placed after the object in the list of parameters (if possible,
+            // just after). Search "lastObjectName" in the codebase for other
+            // place where this convention is enforced.
+            if (auto identifierNode =
+                    dynamic_cast<IdentifierNode *>(objectExpression.get())) {
+              lastObjectName = identifierNode->identifierName;
+            } else {
+              objectExpression->diagnostic =
+                  gd::make_unique<ExpressionParserError>(
+                      "malformed_object_parameter",
+                      _("An object name was expected but something else was "
+                        "written. Enter just the name of the object for this "
+                        "parameter."),
+                      parameterStartPosition,
+                      GetCurrentPosition());
+            }
+
+            parameters.push_back(std::move(objectExpression));
           } else {
             size_t parameterStartPosition = GetCurrentPosition();
             parameters.push_back(Expression("unknown"));
@@ -479,16 +621,18 @@ class GD_CORE_API ExpressionParser2 {
               GetCurrentPosition());
         }
 
-        SkipWhitespace();
-        SkipIfIsAnyChar(PARAMETERS_SEPARATOR);
+        SkipAllWhitespaces();
+        SkipIfChar(IsParameterSeparator);
         parameterIndex++;
       }
     }
 
-    return std::make_pair(
+    ExpressionParserLocation invalidClosingParenthesisLocation;
+    return ParametersNode{
         std::move(parameters),
         RaiseSyntaxError(_("The list of parameters is not terminated. Add a "
-                           "closing parenthesis to end the parameters.")));
+                           "closing parenthesis to end the parameters.")),
+        invalidClosingParenthesisLocation};
   }
   ///@}
 
@@ -497,7 +641,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) {
@@ -525,7 +669,8 @@ class GD_CORE_API ExpressionParser2 {
     } else if (gd::ParameterMetadata::IsObject(type)) {
       return gd::make_unique<ExpressionParserError>(
           "invalid_operator",
-          _("Operators (+, -, /, *) can't be used with an object name. Remove the operator."),
+          _("Operators (+, -, /, *) can't be used with an object name. Remove "
+            "the operator."),
           GetCurrentPosition());
     } else if (gd::ParameterMetadata::IsExpression("variable", type)) {
       return gd::make_unique<ExpressionParserError>(
@@ -561,7 +706,8 @@ class GD_CORE_API ExpressionParser2 {
     } else if (gd::ParameterMetadata::IsObject(type)) {
       return gd::make_unique<ExpressionParserError>(
           "invalid_operator",
-          _("Operators (+, -) can't be used with an object name. Remove the operator."),
+          _("Operators (+, -) can't be used with an object name. Remove the "
+            "operator."),
           GetCurrentPosition());
     } else if (gd::ParameterMetadata::IsExpression("variable", type)) {
       return gd::make_unique<ExpressionParserError>(
@@ -579,55 +725,133 @@ class GD_CORE_API ExpressionParser2 {
    * Read tokens or characters
    */
   ///@{
-  void SkipChar() { currentPosition++; }
+  ExpressionParserLocation SkipChar() {
+    size_t startPosition = currentPosition;
+    return ExpressionParserLocation(startPosition, ++currentPosition);
+  }
 
-  void SkipWhitespace() {
+  void SkipAllWhitespaces() {
     while (currentPosition < expression.size() &&
-           WHITESPACES.find(expression[currentPosition]) != gd::String::npos) {
+           IsWhitespace(expression[currentPosition])) {
       currentPosition++;
     }
   }
 
-  void SkipIfIsAnyChar(const gd::String &allowedCharacters) {
-    if (IsAnyChar(allowedCharacters)) {
+  void SkipIfChar(
+      const std::function<bool(gd::String::value_type)> &predicate) {
+    if (CheckIfChar(predicate)) {
       currentPosition++;
     }
   }
 
-  void SkipNamespaceSeparator() {
+  ExpressionParserLocation SkipNamespaceSeparator() {
+    size_t startPosition = currentPosition;
     // Namespace separator is a special kind of delimiter as it is 2 characters
     // long
     if (IsNamespaceSeparator()) {
       currentPosition += NAMESPACE_SEPARATOR.size();
     }
+
+    return ExpressionParserLocation(startPosition, currentPosition);
   }
 
-  bool IsAnyChar(const gd::String &allowedCharacters) {
-    if (currentPosition < expression.size() &&
-        allowedCharacters.find(expression[currentPosition]) !=
-            gd::String::npos) {
-      return true;
-    }
+  bool CheckIfChar(
+      const std::function<bool(gd::String::value_type)> &predicate) {
+    if (currentPosition >= expression.size()) return false;
+    gd::String::value_type character = expression[currentPosition];
 
-    return false;
+    return predicate(character);
   }
 
   bool IsIdentifierAllowedChar() {
-    if (currentPosition < expression.size() &&
-        PARAMETERS_SEPARATOR.find(expression[currentPosition]) ==
-            gd::String::npos &&
-        DOT.find(expression[currentPosition]) == gd::String::npos &&
-        QUOTE.find(expression[currentPosition]) == gd::String::npos &&
-        BRACKETS.find(expression[currentPosition]) == gd::String::npos &&
-        EXPRESSION_OPERATORS.find(expression[currentPosition]) ==
-            gd::String::npos &&
-        TERM_OPERATORS.find(expression[currentPosition]) == gd::String::npos) {
+    if (currentPosition >= expression.size()) return false;
+    gd::String::value_type character = expression[currentPosition];
+
+    // Quickly compare if the character is a number or ASCII character.
+    if ((character >= '0' && character <= '9') ||
+        (character >= 'A' && character <= 'Z') ||
+        (character >= 'a' && character <= 'z'))
+      return true;
+
+    // Otherwise do the full check against separators forbidden in identifiers.
+    if (!IsParameterSeparator(character) && !IsDot(character) &&
+        !IsQuote(character) && !IsBracket(character) &&
+        !IsExpressionOperator(character) && !IsTermOperator(character)) {
       return true;
     }
 
     return false;
   }
 
+  static bool IsWhitespace(gd::String::value_type character) {
+    return character == ' ' || character == '\n' || character == '\r';
+  }
+
+  static bool IsParameterSeparator(gd::String::value_type character) {
+    return character == ',';
+  }
+
+  static bool IsDot(gd::String::value_type character) {
+    return character == '.';
+  }
+
+  static bool IsQuote(gd::String::value_type character) {
+    return character == '"';
+  }
+
+  static bool IsBracket(gd::String::value_type character) {
+    return character == '(' || character == ')' || character == '[' ||
+           character == ']' || character == '{' || character == '}';
+  }
+
+  static bool IsOpeningParenthesis(gd::String::value_type character) {
+    return character == '(';
+  }
+
+  static bool IsClosingParenthesis(gd::String::value_type character) {
+    return character == ')';
+  }
+
+  static bool IsOpeningSquareBracket(gd::String::value_type character) {
+    return character == '[';
+  }
+
+  static bool IsClosingSquareBracket(gd::String::value_type character) {
+    return character == ']';
+  }
+
+  static bool IsExpressionEndingChar(gd::String::value_type character) {
+    return character == ',' || IsClosingParenthesis(character) ||
+           IsClosingSquareBracket(character);
+  }
+
+  static bool IsExpressionOperator(gd::String::value_type character) {
+    return character == '+' || character == '-' || character == '<' ||
+           character == '>' || character == '?' || character == '^' ||
+           character == '=' || character == '\\' || character == ':' ||
+           character == '!';
+  }
+
+  static bool IsUnaryOperator(gd::String::value_type character) {
+    return character == '+' || character == '-';
+  }
+
+  static bool IsTermOperator(gd::String::value_type character) {
+    return character == '/' || character == '*';
+  }
+
+  static bool IsNumberFirstChar(gd::String::value_type character) {
+    return character == '.' || (character >= '0' && character <= '9');
+  }
+
+  static bool IsNonZeroDigit(gd::String::value_type character) {
+    return (character >= '1' && character <= '9');
+  }
+
+  static bool IsZeroDigit(gd::String::value_type character) {
+    return character == '0';
+  }
+
   bool IsNamespaceSeparator() {
     // Namespace separator is a special kind of delimiter as it is 2 characters
     // long
@@ -638,8 +862,15 @@ class GD_CORE_API ExpressionParser2 {
 
   bool IsEndReached() { return currentPosition >= expression.size(); }
 
-  gd::String ReadIdentifierName() {
+  // A temporary node used when reading an identifier
+  struct IdentifierAndLocation {
     gd::String name;
+    ExpressionParserLocation location;
+  };
+
+  IdentifierAndLocation ReadIdentifierName() {
+    gd::String name;
+    size_t startPosition = currentPosition;
     while (currentPosition < expression.size() &&
            (IsIdentifierAllowedChar()
             // Allow whitespace in identifier name for compatibility
@@ -651,12 +882,23 @@ class GD_CORE_API ExpressionParser2 {
     // Trim whitespace at the end (we allow them for compatibility inside
     // the name, but after the last character that is not whitespace, they
     // should be ignore again).
-    size_t lastCharacterPos = name.find_last_not_of(WHITESPACES);
-    if (!name.empty() && (lastCharacterPos + 1) < name.size()) {
-      name.erase(lastCharacterPos + 1);
+    if (!name.empty() && IsWhitespace(name[name.size() - 1])) {
+      size_t lastCharacterPos = name.size() - 1;
+      while (lastCharacterPos < name.size() &&
+             IsWhitespace(name[lastCharacterPos])) {
+        lastCharacterPos--;
+      }
+      if ((lastCharacterPos + 1) < name.size()) {
+        name.erase(lastCharacterPos + 1);
+      }
     }
 
-    return name;
+    IdentifierAndLocation identifierAndLocation{
+        name,
+        // The location is ignoring the trailing whitespace (only whitespace
+        // inside the identifier are allowed for compatibility).
+        ExpressionParserLocation(startPosition, startPosition + name.size())};
+    return identifierAndLocation;
   }
 
   std::unique_ptr<TextNode> ReadText();
@@ -664,24 +906,32 @@ class GD_CORE_API ExpressionParser2 {
   std::unique_ptr<NumberNode> ReadNumber();
 
   std::unique_ptr<EmptyNode> ReadUntilWhitespace(gd::String type) {
+    size_t startPosition = GetCurrentPosition();
     gd::String text;
     while (currentPosition < expression.size() &&
-           WHITESPACES.find(expression[currentPosition]) == gd::String::npos) {
+           !IsWhitespace(expression[currentPosition])) {
       text += expression[currentPosition];
       currentPosition++;
     }
 
-    return gd::make_unique<EmptyNode>(type, text);
+    auto node = gd::make_unique<EmptyNode>(type, text);
+    node->location =
+        ExpressionParserLocation(startPosition, GetCurrentPosition());
+    return node;
   }
 
   std::unique_ptr<EmptyNode> ReadUntilEnd(gd::String type) {
+    size_t startPosition = GetCurrentPosition();
     gd::String text;
     while (currentPosition < expression.size()) {
       text += expression[currentPosition];
       currentPosition++;
     }
 
-    return gd::make_unique<EmptyNode>(type, text);
+    auto node = gd::make_unique<EmptyNode>(type, text);
+    node->location =
+        ExpressionParserLocation(startPosition, GetCurrentPosition());
+    return node;
   }
 
   size_t GetCurrentPosition() { return currentPosition; }
@@ -746,15 +996,6 @@ class GD_CORE_API ExpressionParser2 {
   const gd::ObjectsContainer &globalObjectsContainer;
   const gd::ObjectsContainer &objectsContainer;
 
-  static gd::String NUMBER_FIRST_CHAR;
-  static gd::String DOT;
-  static gd::String PARAMETERS_SEPARATOR;
-  static gd::String QUOTE;
-  static gd::String BRACKETS;
-  static gd::String EXPRESSION_OPERATORS;
-  static gd::String TERM_OPERATORS;
-  static gd::String UNARY_OPERATORS;
-  static gd::String WHITESPACES;
   static gd::String NAMESPACE_SEPARATOR;
 };
 

Core/GDCore/Events/Parsers/ExpressionParser2Node.h

@@ -20,6 +20,24 @@ class ExpressionMetadata;
 
 namespace gd {
 
+struct ExpressionParserLocation {
+  ExpressionParserLocation() : isValid(false){};
+  ExpressionParserLocation(size_t position)
+      : isValid(true), startPosition(position), endPosition(position){};
+  ExpressionParserLocation(size_t startPosition_, size_t endPosition_)
+      : isValid(true),
+        startPosition(startPosition_),
+        endPosition(endPosition_){};
+  size_t GetStartPosition() const { return startPosition; }
+  size_t GetEndPosition() const { return endPosition; }
+  bool IsValid() const { return isValid; }
+
+ private:
+  bool isValid;
+  size_t startPosition;
+  size_t endPosition;
+};
+
 /**
  * \brief A diagnostic that can be attached to a gd::ExpressionNode.
  */
@@ -40,30 +58,25 @@ struct ExpressionParserError : public ExpressionParserDiagnostic {
   ExpressionParserError(const gd::String &type_,
                         const gd::String &message_,
                         size_t position_)
-      : type(type_),
-        message(message_),
-        startPosition(position_),
-        endPosition(position_){};
+      : type(type_), message(message_), location(position_){};
   ExpressionParserError(const gd::String &type_,
                         const gd::String &message_,
                         size_t startPosition_,
                         size_t endPosition_)
       : type(type_),
         message(message_),
-        startPosition(startPosition_),
-        endPosition(endPosition_){};
+        location(startPosition_, endPosition_){};
   virtual ~ExpressionParserError(){};
 
   bool IsError() override { return true; }
   const gd::String &GetMessage() override { return message; }
-  size_t GetStartPosition() override { return startPosition; }
-  size_t GetEndPosition() override { return endPosition; }
+  size_t GetStartPosition() override { return location.GetStartPosition(); }
+  size_t GetEndPosition() override { return location.GetEndPosition(); }
 
  private:
   gd::String type;
   gd::String message;
-  size_t startPosition;
-  size_t endPosition;
+  ExpressionParserLocation location;
 };
 
 /**
@@ -75,16 +88,26 @@ struct ExpressionNode {
   virtual void Visit(ExpressionParser2NodeWorker &worker){};
 
   std::unique_ptr<ExpressionParserDiagnostic> diagnostic;
+  ExpressionParserLocation location;  ///< The location of the entire node. Some
+                                      ///nodes might have other locations stored
+                                      ///inside them. For example, a function
+                                      ///can store the position of the object
+                                      ///name, the dot, the function name,
+                                      ///etc...
 };
 
 struct SubExpressionNode : public ExpressionNode {
-  SubExpressionNode(std::unique_ptr<ExpressionNode> expression_)
-      : expression(std::move(expression_)){};
+  SubExpressionNode(const gd::String &type_,
+                    std::unique_ptr<ExpressionNode> expression_)
+      : type(type_), expression(std::move(expression_)){};
   virtual ~SubExpressionNode(){};
   virtual void Visit(ExpressionParser2NodeWorker &worker) {
     worker.OnVisitSubExpressionNode(*this);
   };
 
+  gd::String type;  // "string", "number", type supported by
+                    // gd::ParameterMetadata::IsObject, types supported by
+                    // gd::ParameterMetadata::IsExpression or "unknown".
   std::unique_ptr<ExpressionNode> expression;
 };
 
@@ -92,6 +115,8 @@ struct SubExpressionNode : public ExpressionNode {
  * \brief An operator node. For example: "lhs + rhs".
  */
 struct OperatorNode : public ExpressionNode {
+  OperatorNode(const gd::String &type_, gd::String::value_type op_)
+      : type(type_), op(op_){};
   virtual ~OperatorNode(){};
   virtual void Visit(ExpressionParser2NodeWorker &worker) {
     worker.OnVisitOperatorNode(*this);
@@ -99,6 +124,9 @@ struct OperatorNode : public ExpressionNode {
 
   std::unique_ptr<ExpressionNode> leftHandSide;
   std::unique_ptr<ExpressionNode> rightHandSide;
+  gd::String type;  // "string", "number", type supported by
+                    // gd::ParameterMetadata::IsObject, types supported by
+                    // gd::ParameterMetadata::IsExpression or "unknown".
   gd::String::value_type op;
 };
 
@@ -106,13 +134,17 @@ struct OperatorNode : public ExpressionNode {
  * \brief A unary operator node. For example: "-2".
  */
 struct UnaryOperatorNode : public ExpressionNode {
-  UnaryOperatorNode(gd::String::value_type op_) : op(op_){};
+  UnaryOperatorNode(const gd::String &type_, gd::String::value_type op_)
+      : type(type_), op(op_){};
   virtual ~UnaryOperatorNode(){};
   virtual void Visit(ExpressionParser2NodeWorker &worker) {
     worker.OnVisitUnaryOperatorNode(*this);
   };
 
   std::unique_ptr<ExpressionNode> factor;
+  gd::String type;  // "string", "number", type supported by
+                    // gd::ParameterMetadata::IsObject, types supported by
+                    // gd::ParameterMetadata::IsExpression or "unknown".
   gd::String::value_type op;
 };
 
@@ -170,6 +202,8 @@ struct VariableNode : public ExpressionNode {
 
   std::unique_ptr<VariableAccessorOrVariableBracketAccessorNode>
       child;  // Can be nullptr if no accessor
+
+  ExpressionParserLocation nameLocation;
 };
 
 /**
@@ -185,6 +219,8 @@ struct VariableAccessorNode
   };
 
   gd::String name;
+  ExpressionParserLocation nameLocation;
+  ExpressionParserLocation dotLocation;
 };
 
 /**
@@ -203,12 +239,14 @@ struct VariableBracketAccessorNode
   std::unique_ptr<ExpressionNode> expression;
 };
 
-struct IdentifierOrFunctionOrEmptyNode : public ExpressionNode {};
+struct IdentifierOrFunctionCallOrObjectFunctionNameOrEmptyNode
+    : 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 {
+struct IdentifierNode
+    : public IdentifierOrFunctionCallOrObjectFunctionNameOrEmptyNode {
   IdentifierNode(const gd::String &identifierName_, const gd::String &type_)
       : identifierName(identifierName_), type(type_){};
   virtual ~IdentifierNode(){};
@@ -220,64 +258,142 @@ struct IdentifierNode : public IdentifierOrFunctionOrEmptyNode {
   gd::String type;
 };
 
-struct FunctionOrEmptyNode : public IdentifierOrFunctionOrEmptyNode {
-  virtual ~FunctionOrEmptyNode(){};
+struct FunctionCallOrObjectFunctionNameOrEmptyNode
+    : public IdentifierOrFunctionCallOrObjectFunctionNameOrEmptyNode {
+  virtual ~FunctionCallOrObjectFunctionNameOrEmptyNode(){};
   void Visit(ExpressionParser2NodeWorker &worker) override{};
 };
 
 /**
- * \brief A function node. For example: "MyExtension::MyFunction(1, 2)".
+ * \brief The name of a function to call on an object or the behavior
+ * For example: "MyObject.Function" or "MyObject.Physics" or
+ * "MyObject.Physics::LinearVelocity".
  */
-struct FunctionNode : public FunctionOrEmptyNode {
-  FunctionNode(const gd::String &type_,
-               std::vector<std::unique_ptr<ExpressionNode>> parameters_,
-               const ExpressionMetadata &expressionMetadata_,
-               const gd::String &functionName_)
+struct ObjectFunctionNameNode
+    : public FunctionCallOrObjectFunctionNameOrEmptyNode {
+  ObjectFunctionNameNode(const gd::String &type_,
+                         const gd::String &objectName_,
+                         const gd::String &objectFunctionOrBehaviorName_)
+      : type(type_),
+        objectName(objectName_),
+        objectFunctionOrBehaviorName(objectFunctionOrBehaviorName_) {}
+  ObjectFunctionNameNode(const gd::String &type_,
+                         const gd::String &objectName_,
+                         const gd::String &behaviorName_,
+                         const gd::String &behaviorFunctionName_)
+      : type(type_),
+        objectName(objectName_),
+        objectFunctionOrBehaviorName(behaviorName_),
+        behaviorFunctionName(behaviorFunctionName_) {}
+  virtual ~ObjectFunctionNameNode(){};
+  virtual void Visit(ExpressionParser2NodeWorker &worker) {
+    worker.OnVisitObjectFunctionNameNode(*this);
+  };
+
+  gd::String type;  // This could be removed if the type ("string", "number",
+                    // type supported by gd::ParameterMetadata::IsObject, types
+                    // supported by gd::ParameterMetadata::IsExpression or
+                    // "unknown") was stored in ExpressionMetadata.
+  gd::String objectName;
+  gd::String objectFunctionOrBehaviorName;  ///< Behavior name if
+                                            ///`behaviorFunctionName` is not
+                                            ///empty.
+  gd::String behaviorFunctionName;          ///< If empty, then
+                                    ///objectFunctionOrBehaviorName is filled
+                                    ///with the behavior name.
+
+  ExpressionParserLocation
+      objectNameLocation;  ///< Location of the object name.
+  ExpressionParserLocation
+      objectNameDotLocation;  ///< Location of the "." after the object name.
+  ExpressionParserLocation objectFunctionOrBehaviorNameLocation;  ///< Location
+                                                                  ///of object
+                                                                  ///function
+                                                                  ///name or
+                                                                  ///behavior
+                                                                  ///name.
+  ExpressionParserLocation
+      behaviorNameNamespaceSeparatorLocation;  ///< Location of the "::"
+                                               ///separator, if any.
+  ExpressionParserLocation behaviorFunctionNameLocation;  ///< Location of the
+                                                          ///behavior function
+                                                          ///name, if any.
+};
+
+/**
+ * \brief A function call node (either free function, object function or object
+ * behavior function).
+ * For example: "MyExtension::MyFunction(1, 2)", "MyObject.Function()" or
+ * "MyObject.Physics::LinearVelocity()".
+ */
+struct FunctionCallNode : public FunctionCallOrObjectFunctionNameOrEmptyNode {
+  FunctionCallNode(const gd::String &type_,
+                   std::vector<std::unique_ptr<ExpressionNode>> parameters_,
+                   const ExpressionMetadata &expressionMetadata_,
+                   const gd::String &functionName_)
       : type(type_),
         parameters(std::move(parameters_)),
         expressionMetadata(expressionMetadata_),
         functionName(functionName_){};
-  FunctionNode(const gd::String &type_,
-               const gd::String &objectName_,
-               std::vector<std::unique_ptr<ExpressionNode>> parameters_,
-               const ExpressionMetadata &expressionMetadata_,
-               const gd::String &functionName_)
+  FunctionCallNode(const gd::String &type_,
+                   const gd::String &objectName_,
+                   std::vector<std::unique_ptr<ExpressionNode>> parameters_,
+                   const ExpressionMetadata &expressionMetadata_,
+                   const gd::String &functionName_)
       : type(type_),
         objectName(objectName_),
         parameters(std::move(parameters_)),
         expressionMetadata(expressionMetadata_),
         functionName(functionName_){};
-  FunctionNode(const gd::String &type_,
-               const gd::String &objectName_,
-               const gd::String &behaviorName_,
-               std::vector<std::unique_ptr<ExpressionNode>> parameters_,
-               const ExpressionMetadata &expressionMetadata_,
-               const gd::String &functionName_)
+  FunctionCallNode(const gd::String &type_,
+                   const gd::String &objectName_,
+                   const gd::String &behaviorName_,
+                   std::vector<std::unique_ptr<ExpressionNode>> parameters_,
+                   const ExpressionMetadata &expressionMetadata_,
+                   const gd::String &functionName_)
       : type(type_),
         objectName(objectName_),
         behaviorName(behaviorName_),
         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")
-                    // was stored in ExpressionMetadata.
+  gd::String type;  // This could be removed if the type ("string", "number",
+                    // type supported by gd::ParameterMetadata::IsObject, types
+                    // supported by gd::ParameterMetadata::IsExpression or
+                    // "unknown") was stored in ExpressionMetadata.
   gd::String objectName;
   gd::String behaviorName;
   std::vector<std::unique_ptr<ExpressionNode>> parameters;
   const ExpressionMetadata &expressionMetadata;
   gd::String functionName;
+
+  ExpressionParserLocation
+      functionNameLocation;  ///< Location of the function name.
+  ExpressionParserLocation
+      objectNameLocation;  ///< Location of the object name, if any.
+  ExpressionParserLocation
+      objectNameDotLocation;  ///< Location of the "." after the object name.
+  ExpressionParserLocation
+      behaviorNameLocation;  ///< Location of the behavior name, if any.
+  ExpressionParserLocation
+      behaviorNameNamespaceSeparatorLocation;  ///< Location of the "::"
+                                               ///separator, if any.
+  ExpressionParserLocation
+      openingParenthesisLocation;  ///< Location of the "(".
+  ExpressionParserLocation
+      closingParenthesisLocation;  ///< Location of the ")".
 };
 
 /**
  * \brief An empty node, used when parsing failed/a syntax error was
  * encountered and any other node could not make sense.
  */
-struct EmptyNode : public FunctionOrEmptyNode {
+struct EmptyNode : public FunctionCallOrObjectFunctionNameOrEmptyNode {
   EmptyNode(const gd::String &type_, const gd::String &text_ = "")
       : type(type_), text(text_){};
   virtual ~EmptyNode(){};
@@ -285,10 +401,12 @@ struct EmptyNode : public FunctionOrEmptyNode {
     worker.OnVisitEmptyNode(*this);
   };
 
-  gd::String type;
+  gd::String type;  // "string", "number", type supported by
+                    // gd::ParameterMetadata::IsObject, types supported by
+                    // gd::ParameterMetadata::IsExpression or "unknown".
   gd::String text;
 };
 
 }  // namespace gd
 
-#endif
+#endif

Core/GDCore/Events/Parsers/ExpressionParser2NodePrinter.h

@@ -92,7 +92,15 @@ class GD_CORE_API ExpressionParser2NodePrinter
   void OnVisitIdentifierNode(IdentifierNode& node) override {
     output += node.identifierName;
   }
-  void OnVisitFunctionNode(FunctionNode& node) override {
+  void OnVisitObjectFunctionNameNode(ObjectFunctionNameNode& node) override {
+    if (!node.behaviorFunctionName.empty()) {
+      output +=
+          node.objectName + "." + node.objectFunctionOrBehaviorName + "::" + node.behaviorFunctionName;
+    } else {
+      output += node.objectName + "." + node.objectFunctionOrBehaviorName;
+    }
+  };
+  void OnVisitFunctionCallNode(FunctionCallNode& node) override {
     if (!node.behaviorName.empty()) {
       output +=
           node.objectName + "." + node.behaviorName + "::" + node.functionName;

Core/GDCore/Events/Parsers/ExpressionParser2NodeWorker.h

@@ -16,10 +16,11 @@ class TextNode;
 class VariableNode;
 class VariableAccessorNode;
 class VariableBracketAccessorNode;
-class IdentifierOrFunctionOrEmptyNode;
+class IdentifierOrFunctionCallOrObjectFunctionNameOrEmptyNode;
 class IdentifierNode;
-class FunctionOrEmptyNode;
-class FunctionNode;
+class FunctionCallOrObjectFunctionNameOrEmptyNode;
+class ObjectFunctionNameNode;
+class FunctionCallNode;
 class EmptyNode;
 }  // namespace gd
 
@@ -42,10 +43,11 @@ class GD_CORE_API ExpressionParser2NodeWorker {
   friend class VariableNode;
   friend class VariableAccessorNode;
   friend class VariableBracketAccessorNode;
-  friend class IdentifierOrFunctionOrEmptyNode;
+  friend class IdentifierOrFunctionCallOrObjectFunctionNameOrEmptyNode;
   friend class IdentifierNode;
-  friend class FunctionOrEmptyNode;
-  friend class FunctionNode;
+  friend class FunctionCallOrObjectFunctionNameOrEmptyNode;
+  friend class ObjectFunctionNameNode;
+  friend class FunctionCallNode;
   friend class EmptyNode;
 
  public:
@@ -62,10 +64,11 @@ 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 OnVisitObjectFunctionNameNode(ObjectFunctionNameNode& node) = 0;
+  virtual void OnVisitFunctionCallNode(FunctionCallNode& node) = 0;
   virtual void OnVisitEmptyNode(EmptyNode& node) = 0;
 };
 
 }  // namespace gd
 
-#endif
+#endif

Core/GDCore/Events/Parsers/VariableParser.cpp

@@ -1,141 +0,0 @@
-/*
- * GDevelop Core
- * Copyright 2008-2016 Florian Rival (Florian.Rival@gmail.com). All rights
- * reserved. This project is released under the MIT License.
- */
-#include "GDCore/Events/Parsers/VariableParser.h"
-#include <vector>
-#include "GDCore/String.h"
-namespace gd {
-class Layout;
-}
-namespace gd {
-class Project;
-}
-namespace gd {
-class Platform;
-}
-#include "GDCore/Tools/Localization.h"
-
-namespace gd {
-
-VariableParser::~VariableParser() {}
-
-bool VariableParser::Parse(VariableParserCallbacks& callbacks_) {
-  callbacks = &callbacks_;
-  rootVariableParsed = false;
-  firstErrorStr.clear();
-  firstErrorPos = 0;
-  currentPositionIt = expression.begin();
-  currentTokenType = TS_INVALID;
-  currentToken.clear();
-  S();
-
-  return firstErrorStr == "";
-}
-
-void VariableParser::ReadToken() {
-  currentTokenType = TS_INVALID;
-  currentToken.clear();
-  while (currentPositionIt != expression.end()) {
-    char32_t currentChar = *currentPositionIt;
-    if (currentChar == U'[' || currentChar == U']' || currentChar == U'.') {
-      if (currentTokenType == TS_VARNAME)
-        return;  // We've parsed a variable name.
-    }
-
-    if (currentChar == U'[') {
-      currentTokenType = TS_OPENING_BRACKET;
-      currentToken.clear();
-      ++currentPositionIt;
-      return;
-    } else if (currentChar == U']') {
-      currentTokenType = TS_CLOSING_BRACKET;
-      currentToken.clear();
-      ++currentPositionIt;
-      return;
-    } else if (currentChar == U'.') {
-      currentTokenType = TS_PERIOD;
-      currentToken.clear();
-      ++currentPositionIt;
-      return;
-    }
-
-    currentTokenType = TS_VARNAME;  // We're parsing a variable name.
-    currentToken.push_back(currentChar);
-    ++currentPositionIt;
-  }
-
-  // Can be reached if we are at the end of the expression. In this case,
-  // currentTokenType will be either TS_VARNAME or TS_INVALID.
-}
-
-void VariableParser::S() {
-  ReadToken();
-  if (currentTokenType != TS_VARNAME) {
-    firstErrorStr = _("Expecting a variable name.");
-    firstErrorPos = std::distance<gd::String::const_iterator>(
-        expression.begin(), currentPositionIt);
-    return;
-  }
-
-  if (!rootVariableParsed) {
-    rootVariableParsed = true;
-    if (callbacks) callbacks->OnRootVariable(currentToken);
-  } else if (callbacks)
-    callbacks->OnChildVariable(currentToken);
-
-  X();
-}
-
-void VariableParser::X() {
-  ReadToken();
-  if (currentTokenType == TS_INVALID)
-    return;  // Ended parsing.
-  else if (currentTokenType == TS_PERIOD)
-    S();
-  else if (currentTokenType == TS_OPENING_BRACKET) {
-    gd::String strExpr = SkipStringExpression();
-
-    ReadToken();
-    if (currentTokenType != TS_CLOSING_BRACKET) {
-      firstErrorStr = _("Expecting ]");
-      firstErrorPos = std::distance<gd::String::const_iterator>(
-          expression.begin(), currentPositionIt);
-      return;
-    }
-    if (callbacks) callbacks->OnChildSubscript(strExpr);
-    X();
-  }
-}
-
-gd::String VariableParser::SkipStringExpression() {
-  gd::String stringExpression;
-  bool insideStringLiteral = false;
-  bool lastCharacterWasBackslash = false;
-  unsigned int nestedBracket = 0;
-  while (currentPositionIt != expression.end()) {
-    char32_t currentChar = *currentPositionIt;
-    if (currentChar == U'\"') {
-      if (!insideStringLiteral)
-        insideStringLiteral = true;
-      else if (!lastCharacterWasBackslash)
-        insideStringLiteral = false;
-    } else if (currentChar == U'[' && !insideStringLiteral) {
-      nestedBracket++;
-    } else if (currentChar == U']' && !insideStringLiteral) {
-      if (nestedBracket == 0)
-        return stringExpression;  // Found the end of the string litteral.
-      nestedBracket--;
-    }
-
-    lastCharacterWasBackslash = currentChar == U'\\';
-    stringExpression.push_back(currentChar);
-    ++currentPositionIt;
-  }
-
-  // End of the expression reached (so expression is invalid by the way)
-  return stringExpression;
-}
-
-}  // namespace gd

Core/GDCore/Events/Parsers/VariableParser.h

@@ -1,148 +0,0 @@
-/*
- * GDevelop Core
- * Copyright 2008-2016 Florian Rival (Florian.Rival@gmail.com). All rights
- * reserved. This project is released under the MIT License.
- */
-#ifndef GDCORE_VARIABLEPARSER_H
-#define GDCORE_VARIABLEPARSER_H
-
-#include <vector>
-#include "GDCore/String.h"
-namespace gd {
-class Layout;
-}
-namespace gd {
-class Project;
-}
-namespace gd {
-class Platform;
-}
-namespace gd {
-class VariableParserCallbacks;
-}
-
-namespace gd {
-
-/** \brief Parse a variable expression.
- *
- * Parse an variable expression ( like
-myVariable.child["subchild"+ToString(i)].subsubchild ),
- * calling callbacks when a token is reached.
- *
- * Usage example:
-\code
-    //...
-
-    //VariableCodeGenerationCallbacks is a class inheriting from
-gd::VariableParserCallbacks VariableCodeGenerationCallbacks callbacks(output,
-*this, context, VariableCodeGenerationCallbacks::PROJECT_VARIABLE);
-
-    gd::VariableParser parser(parameter);
-    if ( !parser.Parse(callbacks) )
-        cout << "Error :" << parser.GetFirstError() << " in: "<< parameter <<
-endl;
-\endcode
- *
- * Here is the parsed grammar:   <br>
- * S -> VarName X  <br>
- * X -> e | . S | [StringExpression] X   <br>
- *
- * where e = nothing (end of expression), StringExpression = A valid string
-expression and
- * S is the start.
- *
- * \see gd::VariableParserCallbacks
- */
-class GD_CORE_API VariableParser {
- public:
-  /**
-   * \brief Default constructor
-   * \param expressionPlainString The string representing the expression to be
-   * parsed.
-   */
-  VariableParser(const gd::String& expressionPlainString_)
-      : currentPositionIt(), expression(expressionPlainString_){};
-  virtual ~VariableParser();
-
-  /**
-   * Parse the expression, calling each callback when necessary.
-   * \param callbacks The callbacks to be called.
-   * \return true if expression was correctly parsed.
-   * \see gd::VariableParserCallbacks
-   */
-  bool Parse(VariableParserCallbacks& callbacks);
-
-  /**
-   * \brief Return the description of the error that was found
-   */
-  const gd::String& GetFirstError() { return firstErrorStr; }
-
-  /**
-   * \brief Return the position of the error that was found
-   * \return The position, or gd::String::npos if no error is found
-   */
-  size_t GetFirstErrorPosition() { return firstErrorPos; }
-
-  gd::String firstErrorStr;
-  size_t firstErrorPos;
-
- private:
-  void S();
-  void X();
-
-  /**
-   * \brief Skip the string expression, starting from the current position.
-   * \return The string expression skipped. currentPosition is now put on the
-   * closing bracket.
-   */
-  gd::String SkipStringExpression();
-
-  void ReadToken();
-
-  enum TokenType {
-    TS_PERIOD,
-    TS_OPENING_BRACKET,
-    TS_CLOSING_BRACKET,
-    TS_VARNAME,
-    TS_INVALID
-  };
-
-  TokenType currentTokenType;
-  gd::String currentToken;
-  gd::String::const_iterator currentPositionIt;
-  gd::String expression;
-
-  VariableParserCallbacks* callbacks;
-  bool rootVariableParsed;
-};
-
-/**
- * \brief Callbacks called by VariableParser when parsing a variable expression.
- */
-class GD_CORE_API VariableParserCallbacks {
- public:
-  /**
-   * \brief Called when the first variable has been parsed. ( varName1 in
-   * varName1.child for example. ) \param variableName The variable name.
-   */
-  virtual void OnRootVariable(gd::String variableName) = 0;
-
-  /**
-   * \brief Called when accessing the child of a structure variable. ( child in
-   * varName1.child for example. ) \param variableName The child variable name.
-   */
-  virtual void OnChildVariable(gd::String variableName) = 0;
-
-  /**
-   * \brief Called when accessing the child of a structure variable using a
-   * string expression in square brackets. ( "subscript" in
-   * varName1["subscript"] for example. )
-   *
-   * \param variableName The expression used to access the child variable.
-   */
-  virtual void OnChildSubscript(gd::String stringExpression) = 0;
-};
-
-}  // namespace gd
-
-#endif  // GDEXPRESSIONPARSER_H

Core/GDCore/Events/Tools/EventsCodeNameMangler.cpp

@@ -8,10 +8,15 @@
 #include "GDCore/CommonTools.h"
 #include "GDCore/String.h"
 
-EventsCodeNameMangler *EventsCodeNameMangler::_singleton = NULL;
+EventsCodeNameMangler *EventsCodeNameMangler::_singleton = nullptr;
 
-gd::String EventsCodeNameMangler::GetMangledObjectsListName(
+const gd::String& EventsCodeNameMangler::GetMangledObjectsListName(
     const gd::String &originalObjectName) {
+  auto it = mangledObjectNames.find(originalObjectName);
+  if (it != mangledObjectNames.end()) {
+    return it->second;
+  }
+
   gd::String partiallyMangledName = originalObjectName;
   static const gd::String allowedCharacters =
       "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
@@ -27,11 +32,17 @@ gd::String EventsCodeNameMangler::GetMangledObjectsListName(
     }
   }
 
-  return "GD" + partiallyMangledName + "Objects";
+  mangledObjectNames[originalObjectName] = "GD" + partiallyMangledName + "Objects";
+  return mangledObjectNames[originalObjectName];
 }
 
-gd::String EventsCodeNameMangler::GetExternalEventsFunctionMangledName(
+const gd::String& EventsCodeNameMangler::GetExternalEventsFunctionMangledName(
     const gd::String &externalEventsName) {
+  auto it = mangledExternalEventsNames.find(externalEventsName);
+  if (it != mangledExternalEventsNames.end()) {
+    return it->second;
+  }
+
   gd::String partiallyMangledName = externalEventsName;
   static const gd::String allowedCharacters =
       "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
@@ -47,23 +58,24 @@ gd::String EventsCodeNameMangler::GetExternalEventsFunctionMangledName(
     }
   }
 
-  return "GDExternalEvents" + partiallyMangledName;
+  mangledExternalEventsNames[externalEventsName] = "GDExternalEvents" + partiallyMangledName;
+  return mangledExternalEventsNames[externalEventsName];
 }
 
-gd::String ManObjListName(const gd::String &objectName) {
+const gd::String& ManObjListName(const gd::String &objectName) {
   return EventsCodeNameMangler::Get()->GetMangledObjectsListName(objectName);
 }
 
 EventsCodeNameMangler *EventsCodeNameMangler::Get() {
-  if (NULL == _singleton) _singleton = new EventsCodeNameMangler;
+  if (nullptr == _singleton) _singleton = new EventsCodeNameMangler;
 
   return (static_cast<EventsCodeNameMangler *>(_singleton));
 }
 
 void EventsCodeNameMangler::DestroySingleton() {
-  if (NULL != _singleton) {
+  if (nullptr != _singleton) {
     delete _singleton;
-    _singleton = NULL;
+    _singleton = nullptr;
   }
 }
 

Core/GDCore/Events/Tools/EventsCodeNameMangler.h

@@ -6,26 +6,34 @@
 #if defined(GD_IDE_ONLY)
 #ifndef EVENTSCODENAMEMANGLER_H
 #define EVENTSCODENAMEMANGLER_H
+#include <unordered_map>
 #include "GDCore/String.h"
 
 /**
- * Manage name mangling, so as to ensure all names used in code are valid.
+ * \brief Mangle object names, so as to ensure all names used in code are valid.
  *
  * \see ManObjListName
  */
 class GD_CORE_API EventsCodeNameMangler {
  public:
   /**
-   * Get the mangled name from a name : All characters that are not 0-9, a-z,
+   * Get the mangled name from a name: All characters that are not 0-9, a-z,
    * A-Z or _ are replaced by "_"+AsciiCodeOfTheCharacter.
+   *
+   * The mangled name is memoized as this is intensively used during project
+   * export and events code generation.
    */
-  gd::String GetMangledObjectsListName(const gd::String &originalObjectName);
+  const gd::String &GetMangledObjectsListName(
+      const gd::String &originalObjectName);
 
   /**
    * Get the mangled function name to be used to call external events named \a
    * externalEventsName.
+   *
+   * The mangled name is memoized as this is intensively used during project
+   * export and events code generation.
    */
-  gd::String GetExternalEventsFunctionMangledName(
+  const gd::String &GetExternalEventsFunctionMangledName(
       const gd::String &externalEventsName);
 
   static EventsCodeNameMangler *Get();
@@ -35,14 +43,22 @@ class GD_CORE_API EventsCodeNameMangler {
   EventsCodeNameMangler(){};
   virtual ~EventsCodeNameMangler(){};
   static EventsCodeNameMangler *_singleton;
+
+  std::unordered_map<gd::String, gd::String>
+      mangledObjectNames;  ///< Memoized results of mangling for objects
+  std::unordered_map<gd::String, gd::String>
+      mangledExternalEventsNames;  ///< Memoized results of mangling for
+                                   /// external events
 };
 
 /**
- * Shortcut to
- * EventsCodeNameMangler::Get()->GetMangledObjectsListName(objectName). \see
- * EventsCodeNameMangler \return Mangled object name
+ * Shortcut for
+ * `EventsCodeNameMangler::Get()->GetMangledObjectsListName(objectName)`.
+ *
+ * \see EventsCodeNameMangler
+ * \return Mangled object name
  */
-gd::String GD_CORE_API ManObjListName(const gd::String &objectName);
+const gd::String &GD_CORE_API ManObjListName(const gd::String &objectName);
 
 #endif  // EVENTSCODENAMEMANGLER_H
 #endif

Core/GDCore/Extensions/Builtin/AdvancedExtension.cpp

@@ -73,6 +73,20 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsAdvancedExtension(
       .AddParameter("trueorfalse", "Should the condition be true or false?")
       .MarkAsAdvanced();
 
+  extension
+      .AddCondition("GetArgumentAsBoolean",
+                    _("Check if a function parameter is set to true (or yes)"),
+                    _("Check if the specified function parameter (also called "
+                      "\"argument\") is set to True or Yes. If the argument is "
+                      "a string, an empty string is considered as \"false\". "
+                      "If it's a number, 0 is considered as \"false\"."),
+                    _("Parameter _PARAM0_ is true"),
+                    _("Functions"),
+                    "res/function24.png",
+                    "res/function16.png")
+      .AddParameter("string", "Parameter name")
+      .MarkAsAdvanced();
+
   extension
       .AddExpression(
           "GetArgumentAsNumber",

Core/GDCore/Extensions/Builtin/BaseObjectExtension.cpp

@@ -13,11 +13,12 @@ namespace gd {
 void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
     gd::PlatformExtension& extension) {
   extension
-      .SetExtensionInformation("BuiltinObject",
-                               _("Base object"),
-                               _("Base object"),
-                               "Florian Rival",
-                               "Open source (MIT License)")
+      .SetExtensionInformation(
+          "BuiltinObject",
+          _("Features for all objects"),
+          _("Common features that can be used for all objects in GDevelop."),
+          "Florian Rival",
+          "Open source (MIT License)")
       .SetExtensionHelpPath("/objects/base_object/events");
 
   gd::ObjectMetadata& obj = extension.AddObject<gd::Object>(
@@ -72,14 +73,14 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
       .UseStandardOperatorParameters("number")
       .MarkAsSimple();
 
-  obj.AddAction(
-         "MettreXY",
-         _("Position of an object"),
-         _("Change the position of an object."),
-         _("Change the position of _PARAM0_: _PARAM1_ _PARAM2_ (x axis), _PARAM3_ _PARAM4_ (y axis)"),
-         _("Position"),
-         "res/actions/position24.png",
-         "res/actions/position.png")
+  obj.AddAction("MettreXY",
+                _("Position of an object"),
+                _("Change the position of an object."),
+                _("Change the position of _PARAM0_: _PARAM1_ _PARAM2_ (x "
+                  "axis), _PARAM3_ _PARAM4_ (y axis)"),
+                _("Position"),
+                "res/actions/position24.png",
+                "res/actions/position.png")
 
       .AddParameter("object", _("Object"))
       .AddParameter("operator", _("Modification's sign"))
@@ -294,27 +295,25 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
       .AddParameter("objectvar", _("Variable"))
       .UseStandardOperatorParameters("number");
 
-  obj.AddAction(
-         "ModVarObjetTxt",
-         _("Modify the text of a variable of an object"),
-         _("Modify the text of a variable of an object"),
-         _("the text of variable _PARAM1_"),
-         _("Variables"),
-         "res/actions/var24.png",
-         "res/actions/var.png")
+  obj.AddAction("ModVarObjetTxt",
+                _("Modify the text of a variable of an object"),
+                _("Modify the text of a variable of an object"),
+                _("the text of variable _PARAM1_"),
+                _("Variables"),
+                "res/actions/var24.png",
+                "res/actions/var.png")
 
       .AddParameter("object", _("Object"))
       .AddParameter("objectvar", _("Variable"))
       .UseStandardOperatorParameters("string");
 
-  obj.AddCondition(
-         "ObjectVariableChildExists",
-         _("Child existence"),
-         _("Return true if the specified child of the variable exists."),
-         _("Child _PARAM2_ of variable _PARAM1_ of _PARAM0_ exists"),
-         _("Variables/Structures"),
-         "res/conditions/var24.png",
-         "res/conditions/var.png")
+  obj.AddCondition("ObjectVariableChildExists",
+                   _("Child existence"),
+                   _("Check if the specified child of the variable exists."),
+                   _("Child _PARAM2_ of variable _PARAM1_ of _PARAM0_ exists"),
+                   _("Variables/Structures"),
+                   "res/conditions/var24.png",
+                   "res/conditions/var.png")
       .AddParameter("object", _("Object"))
       .AddParameter("objectvar", _("Variable"))
       .AddParameter("string", _("Name of the child"))
@@ -473,14 +472,13 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
       .AddParameter("objectvar", _("Variable"))
       .UseStandardRelationalOperatorParameters("number");
 
-  obj.AddCondition(
-         "VarObjetTxt",
-         _("Text of an object's variable"),
-         _("Compare the text of a variable of an object."),
-         _("the text of variable _PARAM1_"),
-         _("Variables"),
-         "res/conditions/var24.png",
-         "res/conditions/var.png")
+  obj.AddCondition("VarObjetTxt",
+                   _("Text of an object's variable"),
+                   _("Compare the text of a variable of an object."),
+                   _("the text of variable _PARAM1_"),
+                   _("Variables"),
+                   "res/conditions/var24.png",
+                   "res/conditions/var.png")
 
       .AddParameter("object", _("Object"))
       .AddParameter("objectvar", _("Variable"))
@@ -498,14 +496,13 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
       .AddParameter("string", _("Variable"))
       .SetHidden();
 
-  obj.AddCondition(
-         "BehaviorActivated",
-         _("Behavior activated"),
-         _("Return true if the behavior is activated for the object."),
-         _("Behavior _PARAM1_ of _PARAM0_ is activated"),
-         _("Behaviors"),
-         "res/behavior24.png",
-         "res/behavior16.png")
+  obj.AddCondition("BehaviorActivated",
+                   _("Behavior activated"),
+                   _("Check if the behavior is activated for the object."),
+                   _("Behavior _PARAM1_ of _PARAM0_ is activated"),
+                   _("Behaviors"),
+                   "res/behavior24.png",
+                   "res/behavior16.png")
 
       .AddParameter("object", _("Object"))
       .AddParameter("behavior", _("Behavior"))
@@ -634,6 +631,23 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
       .AddParameter("expression", _("Y position of the point"))
       .MarkAsSimple();
 
+  extension
+      .AddCondition("SourisSurObjet",
+                    _("The cursor/touch is on an object"),
+                    _("Test if the cursor is over an object, or if the object "
+                      "is being touched."),
+                    _("The cursor/touch is on _PARAM0_"),
+                    _("Mouse and touch"),
+                    "res/conditions/surObjet24.png",
+                    "res/conditions/surObjet.png")
+
+      .AddParameter("objectList", _("Object"))
+      .AddCodeOnlyParameter("currentScene", "")
+      .AddParameter("yesorno", _("Accurate test (yes by default)"), "", true)
+      .SetDefaultValue("yes")
+      .AddCodeOnlyParameter("conditionInverted", "")
+      .MarkAsSimple();
+
   obj.AddCondition(
          "ObjectTimer",
          _("Value of a timer"),
@@ -819,6 +833,24 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
       .AddParameter("object", _("Object"))
       .AddParameter("objectPtr", _("Object"));
 
+  obj.AddExpression("DistanceToPosition",
+                    _("Distance between an object and a position"),
+                    _("Distance between an object and a position"),
+                    _("Position"),
+                    "res/conditions/distance.png")
+      .AddParameter("object", _("Object"))
+      .AddParameter("expression", _("Target X position"))
+      .AddParameter("expression", _("Target Y position"));
+
+  obj.AddExpression("SqDistanceToPosition",
+                    _("Square distance between an object and a position"),
+                    _("Square distance between an object and a position"),
+                    _("Position"),
+                    "res/conditions/distance.png")
+      .AddParameter("object", _("Object"))
+      .AddParameter("expression", _("Target X position"))
+      .AddParameter("expression", _("Target Y position"));
+
   obj.AddExpression("Variable",
                     _("Object's variable"),
                     _("Object's variable"),
@@ -851,6 +883,26 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
       .AddParameter("object", _("Object"))
       .AddParameter("string", _("Timer's name"));
 
+  obj.AddExpression("AngleToObject",
+                    _("Angle between two objects"),
+                    _("Compute the angle between two objects. If you need the "
+                      "angle to an arbitrary position, use AngleToPosition."),
+                    _("Position"),
+                    "res/actions/position.png")
+      .AddParameter("object", _("Object"))
+      .AddParameter("objectPtr", _("Object"));
+
+  obj.AddExpression("AngleToPosition",
+                    _("Angle between an object and a position"),
+                    _("Compute the angle between the object center and a "
+                      "\"target\" position. If you need the angle between two "
+                      "objects, use AngleToObject."),
+                    _("Position"),
+                    "res/actions/position.png")
+      .AddParameter("object", _("Object"))
+      .AddParameter("expression", _("Target X position"))
+      .AddParameter("expression", _("Target Y position"));
+
   extension
       .AddAction("Create",
                  _("Create an object"),

Core/GDCore/Extensions/Builtin/CameraExtension.cpp

@@ -24,7 +24,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsCameraExtension(
       .AddCondition("CameraX",
                     _("Camera center X position"),
                     _("Compare the X position of the center of a camera."),
-                    _("the x position of camera _PARAM4_ (layer: _PARAM3_)"),
+                    _("the X position of camera _PARAM4_ (layer: _PARAM3_)"),
                     _("Layers and cameras"),
                     "res/conditions/camera24.png",
                     "res/conditions/camera.png")
@@ -57,7 +57,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsCameraExtension(
           "CameraX",
           _("Camera center X position"),
           _("Change the X position of the center of the specified camera."),
-          _("the x position of camera _PARAM4_ (layer: _PARAM3_)"),
+          _("the X position of camera _PARAM4_ (layer: _PARAM3_)"),
           _("Layers and cameras"),
           "res/conditions/camera24.png",
           "res/conditions/camera.png")
@@ -74,7 +74,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsCameraExtension(
           "CameraY",
           _("Camera center Y position"),
           _("Change the Y position of the center of the specified camera."),
-          _("the y position of camera _PARAM4_ (layer: _PARAM3_)"),
+          _("the Y position of camera _PARAM4_ (layer: _PARAM3_)"),
           _("Layers and cameras"),
           "res/conditions/camera24.png",
           "res/conditions/camera.png")
@@ -117,13 +117,14 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsCameraExtension(
       .MarkAsAdvanced();
 
   extension
-      .AddCondition("CameraAngle",
-                    _("Angle of a camera of a layer"),
-                    _("Test a camera angle."),
-                    _("the angle of camera (layer: _PARAM3_, camera: _PARAM4_)"),
-                    _("Layers and cameras"),
-                    "res/conditions/camera24.png",
-                    "res/conditions/camera.png")
+      .AddCondition(
+          "CameraAngle",
+          _("Angle of a camera of a layer"),
+          _("Test a camera angle."),
+          _("the angle of camera (layer: _PARAM3_, camera: _PARAM4_)"),
+          _("Layers and cameras"),
+          "res/conditions/camera24.png",
+          "res/conditions/camera.png")
       .AddCodeOnlyParameter("currentScene", "")
       .UseStandardRelationalOperatorParameters("number")
       .AddParameter("layer", _("Layer (base layer if empty)"), "", true)
@@ -245,9 +246,9 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsCameraExtension(
 
   extension
       .AddAction("ZoomCamera",
+                 _("Change camera zoom"),
                  _("Change camera zoom."),
-                 _("Change camera zoom."),
-                 _("Change camera zoom to _PARAM1_ (layer : _PARAM2_, camera : "
+                 _("Change camera zoom to _PARAM1_ (layer: _PARAM2_, camera: "
                    "_PARAM3_)"),
                  _("Layers and cameras"),
                  "res/actions/camera24.png",
@@ -469,6 +470,52 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsCameraExtension(
       .AddParameter("expression",
                     _("Scale (1: Default, 2: 2x faster, 0.5: 2x slower...)"));
 
+  extension
+      .AddCondition("LayerDefaultZOrder",
+                    _("Layer default Z order"),
+                    _("Compare the default Z order set to objects when they "
+                      "are created on a layer."),
+                    _("the default Z order of objects created on _PARAM1_"),
+                    _("Layers and cameras"),
+                    "res/conditions/layer24.png",
+                    "res/conditions/layer.png")
+      .AddCodeOnlyParameter("currentScene", "")
+      .AddParameter("layer", _("Layer (base layer if empty)"), "", true)
+      .SetDefaultValue("\"\"")
+      .UseStandardRelationalOperatorParameters("number")
+      .MarkAsAdvanced();
+
+  extension
+      .AddAction("SetLayerDefaultZOrder",
+                 _("Change layer default Z order"),
+                 _("Change the default Z order set to objects when they are "
+                   "created on a layer."),
+                 _("Set the default Z order of objects created on _PARAM1_ to "
+                   "_PARAM2_"),
+                 _("Layers and cameras"),
+                 "res/actions/layer24.png",
+                 "res/actions/layer.png")
+      .AddCodeOnlyParameter("currentScene", "")
+      .AddParameter("layer", _("Layer (base layer if empty)"), "", true)
+      .SetDefaultValue("\"\"")
+      .AddParameter("expression", _("New default Z order"));
+
+  extension
+      .AddAction(
+          "SetLayerAmbientLightColor",
+          _("Set the ambient light color"),
+          _("Set the ambient light color of the lighting layer in format "
+            "\"R;G;B\" string."),
+          _("Set the ambient color of the lighting layer _PARAM1_ to _PARAM2_"),
+          _("Layers and cameras/Lighting"),
+          "res/actions/color24.png",
+          "res/actions/color.png")
+      .AddCodeOnlyParameter("currentScene", "")
+      .AddParameter("layer", _("Layer (base layer if empty)"), "", true)
+      .SetDefaultValue("\"Lighting\"")
+      .AddParameter("color", _("Color"))
+      .MarkAsAdvanced();
+
   extension
       .AddExpression("CameraWidth",
                      _("Width of a camera of a layer"),
@@ -601,6 +648,18 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsCameraExtension(
       .AddParameter("expression", _("Camera number (default : 0)"), "", true)
       .SetDefaultValue("0");
 
+  extension
+      .AddExpression("CameraZoom",
+                     _("Zoom of a camera of a layer"),
+                     _("Zoom of a camera of a layer"),
+                     _("Layers and cameras"),
+                     "res/actions/camera.png")
+      .AddCodeOnlyParameter("currentScene", "")
+      .AddParameter("layer", _("Layer"), "", true)
+      .SetDefaultValue("\"\"")
+      .AddParameter("expression", _("Camera number (default : 0)"), "", true)
+      .SetDefaultValue("0");
+
   extension
       .AddExpression("VueRotation",
                      _("Angle of a camera of a layer"),
@@ -622,6 +681,15 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsCameraExtension(
                      "res/actions/time.png")
       .AddCodeOnlyParameter("currentScene", "")
       .AddParameter("layer", _("Layer"));
+
+  extension
+      .AddExpression("LayerDefaultZOrder",
+                     _("Default Z Order for a layer"),
+                     _("Default Z Order for a layer"),
+                     _("Layers and cameras"),
+                     "res/actions/camera.png")
+      .AddCodeOnlyParameter("currentScene", "")
+      .AddParameter("layer", _("Layer"));
 #endif
 }
 

Core/GDCore/Extensions/Builtin/CommonInstructionsExtension.cpp

@@ -8,6 +8,7 @@
 #if defined(GD_IDE_ONLY)
 #include "GDCore/Events/Builtin/CommentEvent.h"
 #include "GDCore/Events/Builtin/ForEachEvent.h"
+#include "GDCore/Events/Builtin/ForEachChildVariableEvent.h"
 #include "GDCore/Events/Builtin/GroupEvent.h"
 #include "GDCore/Events/Builtin/LinkEvent.h"
 #include "GDCore/Events/Builtin/RepeatEvent.h"
@@ -35,7 +36,7 @@ BuiltinExtensionsImplementer::ImplementsCommonInstructionsExtension(
   extension
       .AddCondition("Or",
                     _("Or"),
-                    _("Return true if one of the sub conditions is true"),
+                    _("Check if one of the sub conditions is true"),
                     _("If one of these conditions is true:"),
                     _("Advanced"),
                     "res/conditions/or24.png",
@@ -46,7 +47,7 @@ BuiltinExtensionsImplementer::ImplementsCommonInstructionsExtension(
   extension
       .AddCondition("And",
                     _("And"),
-                    _("Return true if all sub conditions are true"),
+                    _("Check if all sub conditions are true"),
                     _("If all of these conditions are true:"),
                     _("Advanced"),
                     "res/conditions/and24.png",
@@ -118,6 +119,13 @@ BuiltinExtensionsImplementer::ImplementsCommonInstructionsExtension(
                      "res/foreach.png",
                      std::make_shared<gd::ForEachEvent>());
 
+  extension.AddEvent("ForEachChildVariable",
+                     _("For each child variable (of a structure)"),
+                     _("Repeat the event for each child variable of a structure."),
+                     "",
+                     "res/foreach.png",
+                     std::make_shared<gd::ForEachChildVariableEvent>());
+
   extension.AddEvent("Group",
                      _("Group"),
                      _("Group containing events"),

Core/GDCore/Extensions/Builtin/FileExtension.cpp

@@ -98,7 +98,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsFileExtension(
       .AddAction(
           "LireFichierExp",
           _("Read a value"),
-          _("Read the value saved in the specified element and store it in a scene"
+          _("Read the value saved in the specified element and store it in a scene "
             "variable.\nSpecify the structure leading to the element using / "
             "(example : Root/Level/Current)\nSpaces are forbidden in element "
             "names."),

Core/GDCore/Extensions/Builtin/MathematicalToolsExtension.cpp

@@ -40,6 +40,28 @@ BuiltinExtensionsImplementer::ImplementsMathematicalToolsExtension(
       .AddParameter("expression", _("First angle"))
       .AddParameter("expression", _("Second angle"));
 
+  extension
+      .AddExpression("AngleBetweenPositions",
+                     _("Angle between two positions"),
+                     _("Compute the angle between two positions."),
+                     _("Mathematical tools"),
+                     "res/mathfunction.png")
+      .AddParameter("expression", _("First point X position"))
+      .AddParameter("expression", _("First point Y position"))
+      .AddParameter("expression", _("Second point X position"))
+      .AddParameter("expression", _("Second point Y position"));
+
+  extension
+      .AddExpression("DistanceBetweenPositions",
+                     _("Distance between two positions"),
+                     _("Compute the distance between two positions."),
+                     _("Mathematical tools"),
+                     "res/mathfunction.png")
+      .AddParameter("expression", _("First point X position"))
+      .AddParameter("expression", _("First point Y position"))
+      .AddParameter("expression", _("Second point X position"))
+      .AddParameter("expression", _("Second point Y position"));
+
   extension
       .AddExpression("mod",
                      _("Modulo"),

Core/GDCore/Extensions/Builtin/MouseExtension.cpp

@@ -21,23 +21,6 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsMouseExtension(
       .SetExtensionHelpPath("/all-features/mouse-touch");
 
 #if defined(GD_IDE_ONLY)
-  extension
-      .AddCondition("SourisSurObjet",
-                    _("The cursor/touch is on an object"),
-                    _("Test if the cursor is over an object, or if the object "
-                      "is being touched."),
-                    _("The cursor/touch is on _PARAM0_"),
-                    _("Mouse and touch"),
-                    "res/conditions/surObjet24.png",
-                    "res/conditions/surObjet.png")
-
-      .AddParameter("objectList", _("Object"))
-      .AddCodeOnlyParameter("currentScene", "")
-      .AddParameter("yesorno", _("Accurate test (yes by default)"), "", true)
-      .SetDefaultValue("yes")
-      .AddCodeOnlyParameter("conditionInverted", "")
-      .MarkAsSimple();
-
   extension
       .AddCondition(
           "IsMouseWheelScrollingUp",
@@ -193,7 +176,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsMouseExtension(
   extension
       .AddCondition("SourisBouton",
                     _("Mouse button pressed or touch held"),
-                    _("Return true if the specified mouse button is pressed or "
+                    _("Check if the specified mouse button is pressed or "
                       "if a touch is in contact with the screen."),
                     _("Touch or _PARAM1_ mouse button is down"),
                     _("Mouse and touch"),
@@ -207,7 +190,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsMouseExtension(
       .AddCondition(
           "MouseButtonReleased",
           _("Mouse button released"),
-          _("Return true if the specified mouse button was released."),
+          _("Check if the specified mouse button was released."),
           _("_PARAM1_ mouse button was released"),
           _("Mouse and touch"),
           "res/conditions/mouse24.png",
@@ -252,7 +235,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsMouseExtension(
       .AddCondition(
           "PopStartedTouch",
           _("A new touch has started"),
-          _("Return true if a touch has started. The touch identifier can be "
+          _("Check if a touch has started. The touch identifier can be "
             "accessed using LastTouchId().\nAs more than one touch can be "
             "started, this condition is only true once for each touch: the "
             "next time you use it, it will be for a new touch, or it will "
@@ -267,7 +250,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsMouseExtension(
       .AddCondition(
           "PopEndedTouch",
           _("A touch has ended"),
-          _("Return true if a touch has ended. The touch identifier can be "
+          _("Check if a touch has ended. The touch identifier can be "
             "accessed using LastEndedTouchId().\nAs more than one touch can be "
             "ended, this condition is only true once for each touch: the next "
             "time you use it, it will be for a new touch, or it will return "

Core/GDCore/Extensions/Builtin/NetworkExtension.cpp

@@ -34,10 +34,10 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsNetworkExtension(
           "res/actions/net24.png",
           "res/actions/net.png")
       .AddParameter("string", _("Host, with protocol"))
-      .SetParameterLongDescription(
-          _("Example: \"http://example.com/\"."))
+      .SetParameterLongDescription(_("Example: \"http://example.com/\"."))
       .AddParameter("string", _("Path"))
-      .SetParameterLongDescription(_("Example: \"/user/123\" or \"/some-page.php\"."))
+      .SetParameterLongDescription(
+          _("Example: \"/user/123\" or \"/some-page.php\"."))
       .AddParameter("string", _("Request body content"))
       .AddParameter("string", _("Method: \"POST\" or \"GET\""), "", true)
       .SetParameterLongDescription(_("If empty, \"GET\" will be used."))
@@ -51,6 +51,52 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsNetworkExtension(
             "variable. If the server returns *JSON*, you may want to use the "
             "action \"Convert JSON to a scene variable\" afterwards, to "
             "explore the results with a *structure variable*."))
+      .MarkAsComplex()
+      .SetHidden();
+
+  extension
+      .AddAction(
+          "SendAsyncRequest",
+          _("Send a request to a web page"),
+          _("Send an asynchronous request to the specified web page.\n\nPlease "
+            "note that for "
+            "the web games, the game must be hosted on the same host "
+            "as specified below, except if the server is configured to answer "
+            "to all requests (cross-domain requests)."),
+          _("Send a _PARAM2_ request to _PARAM0_ with body: _PARAM1_, and "
+            "store the result in _PARAM4_ (or in _PARAM5_ in case of error)"),
+          _("Network"),
+          "res/actions/net24.png",
+          "res/actions/net.png")
+      .AddParameter("string", _("URL (API or web-page address)"))
+      .SetParameterLongDescription(
+          _("Example: \"https://example.com/user/123\". Using *https* is "
+            "highly recommended."))
+      .AddParameter("string", _("Request body content"))
+      .AddParameter("stringWithSelector",
+                    _("Resize mode"),
+                    "[\"GET\", \"POST\", \"PUT\", \"HEAD\", \"DELETE\", "
+                    "\"PATCH\", \"OPTIONS\"]",
+                    false)
+      .SetParameterLongDescription(_("If empty, \"GET\" will be used."))
+      .SetDefaultValue("\"GET\"")
+      .AddParameter("string", _("Content type"), "", true)
+      .SetParameterLongDescription(
+          _("If empty, \"application/x-www-form-urlencoded\" will be used."))
+      .AddParameter(
+          "scenevar", _("Variable where to store the response"), "", true)
+      .SetParameterLongDescription(
+          _("The response of the server will be stored, as a string, in this "
+            "variable. If the server returns *JSON*, you may want to use the "
+            "action \"Convert JSON to a scene variable\" afterwards, to "
+            "explore the results with a *structure variable*."))
+      .AddParameter(
+          "scenevar", _("Variable where to store the error message"), "", true)
+      .SetParameterLongDescription(
+          _("Optional, only used if an error occurs. This will contain the "
+            "error message (if request could not be sent) or the [\"status "
+            "code\"](https://en.wikipedia.org/wiki/List_of_HTTP_status_codes), "
+            "if the server returns a status >= 400."))
       .MarkAsComplex();
 
   extension
@@ -67,6 +113,22 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsNetworkExtension(
                     _("Path to file (for example : /folder/file.txt)"))
       .AddParameter("string", _("Save as"));
 
+  extension
+      .AddAction(
+          "EnableMetrics",
+          _("Enable (or disable) metrics collection"),
+          _("Enable, or disable, the sending of anonymous data used to compute "
+            "the number of sessions and other metrics from your game "
+            "players.\nBe sure to only send metrics if in accordance with the "
+            "terms of service of your game and if they player gave their "
+            "consent, depending on how your game/company handles this."),
+          _("Enable analytics metrics: _PARAM1_"),
+          _("Network"),
+          "res/actions/net24.png",
+          "res/actions/net.png")
+      .AddCodeOnlyParameter("currentScene", "")
+      .AddParameter("yesorno", _("Enable the metrics?"));
+
   extension
       .AddAction(
           "JSONToVariableStructure",

Core/GDCore/Extensions/Builtin/SpriteExtension/SpriteExtension.cpp

@@ -367,20 +367,20 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsSpriteExtension(
 
   obj.AddAction(
          "ChangeColor",
-         _("Global color"),
-         _("Change the global color of an object. The default color is white."),
-         _("Change color of _PARAM0_ to _PARAM1_"),
+         _("Tint color"),
+         _("Change the tint of an object. The default color is white."),
+         _("Change tint of _PARAM0_ to _PARAM1_"),
          _("Effects"),
          "res/actions/color24.png",
          "res/actions/color.png")
 
       .AddParameter("object", _("Object"), "Sprite")
-      .AddParameter("color", _("Color"));
+      .AddParameter("color", _("Tint"));
 
   obj.AddAction("ChangeBlendMode",
                 _("Blend mode"),
                 _("Change the number of the blend mode of an object.\nThe "
-                  "default blend mode is 0 (Alpha)."),
+                  "default blend mode is 0 (Normal)."),
                 _("Change Blend mode of _PARAM0_ to _PARAM1_"),
                 _("Effects"),
                 "res/actions/color24.png",
@@ -388,7 +388,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsSpriteExtension(
 
       .AddParameter("object", _("Object"), "Sprite")
       .AddParameter("expression",
-                    _("Mode (0 : Alpha, 1 : Add, 2 : Multiply, 3 : None)"))
+                    _("Mode (0: Normal, 1: Add, 2: Multiply, 3: Screen)"))
       .MarkAsSimple();
 
   obj.AddAction("FlipX",
@@ -417,7 +417,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsSpriteExtension(
 
   obj.AddCondition("FlippedX",
                    _("Horizontally flipped"),
-                   _("Return true if the object is horizontally flipped"),
+                   _("Check if the object is horizontally flipped"),
                    _("_PARAM0_ is horizontally flipped"),
                    _("Effects"),
                    "res/actions/flipX24.png",
@@ -427,7 +427,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsSpriteExtension(
 
   obj.AddCondition("FlippedY",
                    _("Vertically flipped"),
-                   _("Return true if the object is vertically flipped"),
+                   _("Check if the object is vertically flipped"),
                    _("_PARAM0_ is vertically flipped"),
                    _("Effects"),
                    "res/actions/flipY24.png",

Core/GDCore/Extensions/Builtin/SpriteExtension/SpriteObject.cpp

@@ -107,8 +107,7 @@ void SpriteObject::DoSerializeTo(gd::SerializerElement& element) const {
   }
 }
 
-std::map<gd::String, gd::PropertyDescriptor> SpriteObject::GetProperties(
-    gd::Project& project) const {
+std::map<gd::String, gd::PropertyDescriptor> SpriteObject::GetProperties() const {
   std::map<gd::String, gd::PropertyDescriptor> properties;
   properties[_("Animate even if hidden or far from the screen")]
       .SetValue(updateIfNotVisible ? "true" : "false")
@@ -119,8 +118,7 @@ std::map<gd::String, gd::PropertyDescriptor> SpriteObject::GetProperties(
 }
 
 bool SpriteObject::UpdateProperty(const gd::String& name,
-                                  const gd::String& value,
-                                  gd::Project& project) {
+                                  const gd::String& value) {
   if (name == _("Animate even if hidden or far from the screen"))
     updateIfNotVisible = value == "1";
 

Core/GDCore/Extensions/Builtin/SpriteExtension/SpriteObject.h

@@ -48,11 +48,9 @@ class GD_CORE_API SpriteObject : public gd::Object {
 #if defined(GD_IDE_ONLY)
   void ExposeResources(gd::ArbitraryResourceWorker& worker) override;
 
-  std::map<gd::String, gd::PropertyDescriptor> GetProperties(
-      gd::Project& project) const override;
+  std::map<gd::String, gd::PropertyDescriptor> GetProperties() const override;
   bool UpdateProperty(const gd::String& name,
-                      const gd::String& value,
-                      gd::Project& project) override;
+                      const gd::String& value) override;
 
   std::map<gd::String, gd::PropertyDescriptor> GetInitialInstanceProperties(
       const gd::InitialInstance& position,

Core/GDCore/Extensions/Builtin/StringInstructionsExtension.cpp

@@ -119,6 +119,18 @@ BuiltinExtensionsImplementer::ImplementsStringInstructionsExtension(
                      _("Manipulation of text"),
                      "res/conditions/toujours24.png")
 
+      .AddParameter("string", _("Text"))
+      .AddParameter("string", _("Text to search for"))
+      .SetHidden(); // Deprecated, see StrFindLast instead.
+
+  extension
+      .AddExpression("StrFindLast",
+                     _("Search the last occurence in a text"),
+                     _("Search the last occurence in a string (return the position of "
+                       "the result, from the beginning of the string, or -1 if not found)"),
+                     _("Manipulation of text"),
+                     "res/conditions/toujours24.png")
+
       .AddParameter("string", _("Text"))
       .AddParameter("string", _("Text to search for"));
 
@@ -145,6 +157,22 @@ BuiltinExtensionsImplementer::ImplementsStringInstructionsExtension(
           _("Manipulation of text"),
           "res/conditions/toujours24.png")
 
+      .AddParameter("string", _("Text"))
+      .AddParameter("string", _("Text to search for"))
+      .AddParameter("expression",
+                    _("Position of the last character in the string to be "
+                      "considered in the search"))
+      .SetHidden(); // Deprecated, see StrFindLastFrom instead.
+
+  extension
+      .AddExpression(
+          "StrFindLastFrom",
+          _("Search the last occurence in a text, starting from a position"),
+          _("Search in a text the last occurence, starting from a position (return "
+            " the position of the result, from the beginning of the string, or -1 if not found)"),
+          _("Manipulation of text"),
+          "res/conditions/toujours24.png")
+
       .AddParameter("string", _("Text"))
       .AddParameter("string", _("Text to search for"))
       .AddParameter("expression",

Core/GDCore/Extensions/Builtin/TimeExtension.cpp

@@ -121,16 +121,16 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsTimeExtension(
 
   extension
       .AddExpression("TimeDelta",
-                     _("Time elapsed since the last image"),
-                     _("Time elapsed since the last image"),
+                     _("Time elapsed since the last frame"),
+                     _("Time elapsed since the last frame rendered on screen"),
                      _("Time"),
                      "res/actions/time.png")
       .AddCodeOnlyParameter("currentScene", "");
 
   extension
       .AddExpression("TempsFrame",
-                     _("Time elapsed since the last image"),
-                     _("Time elapsed since the last image"),
+                     _("Time elapsed since the last frame"),
+                     _("Time elapsed since the last frame rendered on screen"),
                      _("Time"),
                      "res/actions/time.png")
       .SetHidden()
@@ -138,8 +138,8 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsTimeExtension(
 
   extension
       .AddExpression("ElapsedTime",
-                     _("Time elapsed since the last image"),
-                     _("Time elapsed since the last image"),
+                     _("Time elapsed since the last frame"),
+                     _("Time elapsed since the last frame rendered on screen"),
                      _("Time"),
                      "res/actions/time.png")
       .SetHidden()

Core/GDCore/Extensions/Builtin/VariablesExtension.cpp

@@ -47,7 +47,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsVariablesExtension(
       .AddCondition(
           "VariableChildExists",
           _("Child existence"),
-          _("Return true if the specified child of the scene variable exists."),
+          _("Check if the specified child of the scene variable exists."),
           _("Child _PARAM1_ of scene variable _PARAM0_ exists"),
           _("Variables/Structures"),
           "res/conditions/var24.png",
@@ -59,7 +59,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsVariablesExtension(
   extension
       .AddCondition("GlobalVariableChildExists",
                     _("Child existence"),
-                    _("Return true if the specified child of the global "
+                    _("Check if the specified child of the global "
                       "variable exists."),
                     _("Child _PARAM1_ of global variable _PARAM0_ exists"),
                     _("Variables/Global variables/Structures"),

Core/GDCore/Extensions/Builtin/WindowExtension.cpp

@@ -38,6 +38,17 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsWindowExtension(
                     true)
       .SetDefaultValue("yes");
 
+  extension
+      .AddCondition(
+          "IsFullScreen",
+          _("Fullscreen activated?"),
+          _("Check if the game is currently in fullscreen."),
+          _("The game is in fullscreen"),
+          _("Game's window and resolution"),
+          "res/actions/fullscreen24.png",
+          "res/actions/fullscreen.png")
+      .AddCodeOnlyParameter("currentScene", "");
+
   extension
       .AddAction("SetWindowMargins",
                  _("Change the window's margins"),
@@ -88,6 +99,18 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsWindowExtension(
                     _("Also update the game resolution? If not, the game will "
                       "be stretched or reduced to fit in the window."));
 
+  extension
+      .AddAction("CenterWindow",
+                 _("Center the game window on the screen"),
+                 _("This action centers the game window on the screen. This "
+                   "only works on Windows, macOS and Linux (not when the game "
+                   "is executed in a web-browser or on iOS/Android)."),
+                 _("Center the game window"),
+                 _("Game's window and resolution"),
+                 "res/actions/window24.png",
+                 "res/actions/window.png")
+      .AddCodeOnlyParameter("currentScene", "");
+
   extension
       .AddAction("SetGameResolutionResizeMode",
                  _("Change the game resolution resize mode"),

Core/GDCore/Extensions/Metadata/BehaviorMetadata.h

@@ -120,12 +120,12 @@ class GD_CORE_API BehaviorMetadata {
   BehaviorMetadata& AddIncludeFile(const gd::String& includeFile);
 
   /**
-   * Get the help path of the behavior, relative to the documentation root.
+   * Get the help path of the behavior, relative to the GDevelop documentation root.
    */
   const gd::String& GetHelpPath() const { return helpPath; }
 
   /**
-   * Set the help path of the behavior, relative to the documentation root.
+   * Set the help path of the behavior, relative to the GDevelop documentation root.
    *
    * The behavior instructions will have this help path set by
    * default, unless you call SetHelpPath on them.

Core/GDCore/Extensions/Metadata/DependencyMetadata.h

@@ -0,0 +1,129 @@
+/*
+ * GDevelop Core
+ * Copyright 2008-2016 Florian Rival (Florian.Rival@gmail.com). All rights
+ * reserved. This project is released under the MIT License.
+ */
+#ifndef DEPENDENCYMETADATA_H
+#define DEPENDENCYMETADATA_H
+#include <map>
+#include <set>
+
+#include "GDCore/Project/PropertyDescriptor.h"
+#include "GDCore/String.h"
+#include "GDCore/Tools/Log.h"
+
+namespace gd {
+/**
+ * \brief Contains information about a dependency (library, npm/cordova
+ * package, or other according to the export) of an extension.
+ */
+class GD_CORE_API DependencyMetadata {
+ public:
+  /**
+   * \brief Sets the name shown to users.
+   */
+  DependencyMetadata& SetName(const gd::String& name_) {
+    name = name_;
+    return *this;
+  };
+
+  /**
+   * \brief Sets the name written by the exporter.
+   * Typically, this is what is used by the dependency manager
+   * to find the dependency.
+   *
+   * \example
+   * \code
+   *  // For depending upon the NPM package is-thirteen
+   *  gd::DependencyMetadata dependencyMetadata = gd::DependencyMetadata();
+   *  dependencyMetadata.setExporterName("is-thirteen");
+   * \endcode
+   */
+  DependencyMetadata& SetExportName(const gd::String& exportName_) {
+    exportName = exportName_;
+    return *this;
+  };
+
+  /**
+   * \brief Set the version of the dependency to install.
+   * Use an empty string to use the latest version.
+   */
+  DependencyMetadata& SetVersion(const gd::String& version_) {
+    version = version_;
+    return *this;
+  };
+
+  /**
+   * \brief Sets the type of dependecy (what will be used to install it)
+   *
+   * This can either be "npm" or "cordova" for now.
+   */
+  DependencyMetadata& SetDependencyType(const gd::String& dependencyType_) {
+    dependencyType = dependencyType_;
+    if (dependencyType != "npm" && dependencyType != "cordova") {
+      gd::LogWarning("Invalid dependency type: " + dependencyType);
+    }
+    return *this;
+  };
+
+  /**
+   * \brief Sets a dependency type specific setting.
+   */
+  DependencyMetadata& SetExtraSetting(
+      const gd::String& settingName,
+      const gd::PropertyDescriptor& settingValue) {
+    extraData[settingName] = settingValue;
+    return *this;
+  };
+
+  /**
+   * \brief Mark the dependency to be included in the export only if the
+   * specified setting is not empty.
+   *
+   * If this is called for multiple settings, all settings must be fulfilled for
+   * the dependency to be exported.
+   */
+  DependencyMetadata& OnlyIfExtraSettingIsNonEmpty(
+      const gd::String& settingName) {
+    nonEmptyExtraSettingsForExport.insert(settingName);
+    return *this;
+  };
+
+  /**
+   * \brief Get the list of extra settings that must be fulfilled for the
+   * dependency to be exported.
+   */
+  const std::set<gd::String>& GetRequiredExtraSettingsForExport() const {
+    return nonEmptyExtraSettingsForExport;
+  };
+
+  const gd::String& GetName() const { return name; };
+  const gd::String& GetExportName() const { return exportName; };
+  const gd::String& GetVersion() const { return version; };
+  const gd::String& GetDependencyType() const {
+    if (dependencyType == "")
+      gd::LogWarning("Dependency has no type, it won't be exported.");
+    return dependencyType;
+  };
+
+  const std::map<gd::String, gd::PropertyDescriptor>& GetAllExtraSettings()
+      const {
+    return extraData;
+  }
+
+ private:
+  gd::String name;        ///< The name of the dependency.
+  gd::String exportName;  ///< The name used to install the package (example:
+                          ///< npm package name for npm dependency type).
+  gd::String version;     ///< The version of the dependency
+  gd::String dependencyType;  ///< The tool used to install the dependency.
+  std::map<gd::String, gd::PropertyDescriptor>
+      extraData;  ///< Contains dependency type specific additional parameters
+                  ///< for the dependency.
+  std::set<gd::String>
+      nonEmptyExtraSettingsForExport;  ///< The set of extra settings that must
+                                       ///< be non empty for this dependency to
+                                       ///< be included by the exporter.
+};
+}  // namespace gd
+#endif  // DEPENDENCYMETADATA_H

Core/GDCore/Extensions/Metadata/EffectMetadata.h

@@ -49,7 +49,7 @@ class GD_CORE_API EffectMetadata {
   };
 
   /**
-   * Set the help path of the effect, relative to the documentation root.
+   * Set the help path of the effect, relative to the GDevelop documentation root.
    */
   EffectMetadata& SetHelpPath(const gd::String& path) {
     helpPath = path;
@@ -81,7 +81,7 @@ class GD_CORE_API EffectMetadata {
   }
 
   /**
-   * \brief Get the help path of the effect, relative to the documentation root.
+   * \brief Get the help path of the effect, relative to the GDevelop documentation root.
    */
   const gd::String& GetHelpPath() const { return helpPath; }
 

Core/GDCore/Extensions/Metadata/ExpressionMetadata.h

@@ -151,12 +151,12 @@ class GD_CORE_API ExpressionMetadata {
   }
 
   /**
-   * Get the help path of the expression, relative to the documentation root.
+   * Get the help path of the expression, relative to the GDevelop documentation root.
    */
   const gd::String &GetHelpPath() const { return helpPath; }
 
   /**
-   * Set the help path of the expression, relative to the documentation root.
+   * Set the help path of the expression, relative to the GDevelop documentation root.
    */
   ExpressionMetadata &SetHelpPath(const gd::String &path) {
     helpPath = path;

Core/GDCore/Extensions/Metadata/InstructionMetadata.h

@@ -274,12 +274,12 @@ class GD_CORE_API InstructionMetadata {
   bool CanHaveSubInstructions() const { return canHaveSubInstructions; }
 
   /**
-   * Get the help path of the instruction, relative to the documentation root.
+   * Get the help path of the instruction, relative to the GDevelop documentation root.
    */
   const gd::String &GetHelpPath() const { return helpPath; }
 
   /**
-   * Set the help path of the instruction, relative to the documentation root.
+   * Set the help path of the instruction, relative to the GDevelop documentation root.
    */
   InstructionMetadata &SetHelpPath(const gd::String &path) {
     helpPath = path;

Core/GDCore/Extensions/Metadata/ObjectMetadata.h

@@ -108,13 +108,13 @@ class GD_CORE_API ObjectMetadata {
   ObjectMetadata& SetDescription(const gd::String& description_);
 
   /**
-   * Get the help path of the object, relative to the documentation root.
+   * Get the help path of the object, relative to the GDevelop documentation root.
    */
   const gd::String &GetHelpPath() const { return helpPath; }
 
   /**
-   * Set the help path of the object, relative to the documentation root.
-   * 
+   * Set the help path of the object, relative to the GDevelop documentation root.
+   *
    * The object instructions will have this help path set by
    * default, unless you call SetHelpPath on them.
    */

Core/GDCore/Extensions/Metadata/ParameterMetadataTools.cpp

@@ -90,7 +90,7 @@ size_t ParameterMetadataTools::GetObjectParameterIndexFor(
   // the object in the list of parameters (if possible, just after).
   // Search "lastObjectName" in the codebase for other place where this
   // convention is enforced.
-  for (std::size_t pNb = parameterIndex - 1; pNb < parametersMetadata.size();
+  for (std::size_t pNb = parameterIndex; pNb < parametersMetadata.size();
        pNb--) {
     if (gd::ParameterMetadata::IsObject(parametersMetadata[pNb].GetType())) {
       return pNb;

Core/GDCore/Extensions/Platform.cpp

@@ -14,19 +14,19 @@ using namespace std;
 
 namespace gd {
 
-Platform::Platform() {}
+Platform::Platform(): enableExtensionLoadingLogs(true) {}
 
 Platform::~Platform() {}
 
 bool Platform::AddExtension(std::shared_ptr<gd::PlatformExtension> extension) {
   if (!extension) return false;
 
-  std::cout << "Loading " << extension->GetName() << "...";
+  if (enableExtensionLoadingLogs) std::cout << "Loading " << extension->GetName() << "...";
   if (IsExtensionLoaded(extension->GetName())) {
-    std::cout << " (replacing existing extension)";
+    if (enableExtensionLoadingLogs) std::cout << " (replacing existing extension)";
     RemoveExtension(extension->GetName());
   }
-  std::cout << std::endl;
+  if (enableExtensionLoadingLogs) std::cout << std::endl;
 
   extensionsLoaded.push_back(extension);
 

Core/GDCore/Extensions/Platform.h

@@ -156,6 +156,12 @@ class GD_CORE_API Platform {
 
   ///@}
 
+  /**
+   * \brief Activate or disable the logs on the standard output when
+   * loading an extension.
+   */
+  void EnableExtensionLoadingLogs(bool enable) { enableExtensionLoadingLogs = enable; };
+
   /**
    * \brief Called when the IDE is about to shut down: Take this opportunity for
    * erasing for example any temporary file.
@@ -174,6 +180,7 @@ class GD_CORE_API Platform {
       extensionsLoaded;  ///< Extensions of the platform
   std::map<gd::String, CreateFunPtr>
       creationFunctionTable;  ///< Creation functions for objects
+  bool enableExtensionLoadingLogs;
 };
 
 }  // namespace gd

Core/GDCore/Extensions/PlatformExtension.cpp

@@ -4,9 +4,12 @@
  * reserved. This project is released under the MIT License.
  */
 #include "GDCore/Extensions/PlatformExtension.h"
+
 #include <algorithm>
+
 #include "GDCore/Events/Event.h"
 #include "GDCore/Extensions/Metadata/BehaviorMetadata.h"
+#include "GDCore/Extensions/Metadata/DependencyMetadata.h"
 #include "GDCore/Extensions/Metadata/EventMetadata.h"
 #include "GDCore/Extensions/Metadata/ExpressionMetadata.h"
 #include "GDCore/Extensions/Metadata/InstructionMetadata.h"
@@ -117,6 +120,13 @@ gd::ExpressionMetadata& PlatformExtension::AddStrExpression(
 #endif
 }
 
+#if defined(GD_IDE_ONLY)
+gd::DependencyMetadata& PlatformExtension::AddDependency() {
+  extensionDependenciesMetadata.push_back(DependencyMetadata());
+  return extensionDependenciesMetadata.back();
+}
+#endif
+
 gd::ObjectMetadata& PlatformExtension::AddObject(
     const gd::String& name,
     const gd::String& fullname,
@@ -216,8 +226,7 @@ std::vector<gd::String> PlatformExtension::GetExtensionObjectsTypes() const {
 
 std::vector<gd::String> PlatformExtension::GetExtensionEffectTypes() const {
   std::vector<gd::String> effectNames;
-  for (auto& it : effectsMetadata)
-    effectNames.push_back(it.first);
+  for (auto& it : effectsMetadata) effectNames.push_back(it.first);
 
   return effectNames;
 }
@@ -283,6 +292,10 @@ PlatformExtension::GetAllStrExpressions() {
   return strExpressionsInfos;
 }
 
+std::vector<gd::DependencyMetadata>& PlatformExtension::GetAllDependencies() {
+  return extensionDependenciesMetadata;
+}
+
 std::map<gd::String, gd::EventMetadata>& PlatformExtension::GetAllEvents() {
   return eventsInfos;
 }
@@ -404,7 +417,7 @@ void PlatformExtension::SetNameSpace(gd::String nameSpace_) {
       name == "BuiltinCommonConversions" ||
       name == "BuiltinStringInstructions" ||
       name == "BuiltinMathematicalTools" ||
-      name == "Effects" || // Well-known effects are not namespaced.
+      name == "Effects" ||      // Well-known effects are not namespaced.
       name == "CommonDialogs")  // New name for BuiltinInterface
   {
     nameSpace = "";

Core/GDCore/Extensions/PlatformExtension.h

@@ -10,11 +10,14 @@
 #include <map>
 #include <memory>
 #include <vector>
+
 #include "GDCore/CommonTools.h"
 #include "GDCore/Extensions/Metadata/BehaviorMetadata.h"
+#include "GDCore/Extensions/Metadata/DependencyMetadata.h"
+#include "GDCore/Extensions/Metadata/EffectMetadata.h"
 #include "GDCore/Extensions/Metadata/EventMetadata.h"
 #include "GDCore/Extensions/Metadata/ObjectMetadata.h"
-#include "GDCore/Extensions/Metadata/EffectMetadata.h"
+#include "GDCore/Project/PropertyDescriptor.h"
 #include "GDCore/String.h"
 #include "GDCore/Tools/VersionPriv.h"
 
@@ -25,6 +28,7 @@ class ExpressionMetadata;
 class ObjectMetadata;
 class BehaviorMetadata;
 class EffectMetadata;
+class DependencyMetadata;
 class BaseEvent;
 class EventMetadata;
 class EventCodeGenerator;
@@ -88,7 +92,15 @@ class GD_CORE_API PlatformExtension {
                                              const gd::String& license_);
 
   /**
-   * \brief Set the path to the help, relative to the wiki/documentation root.
+   * \brief Set the URL of the extension icon.
+   */
+  PlatformExtension& SetIconUrl(const gd::String& iconUrl_) {
+    iconUrl = iconUrl_;
+    return *this;
+  }
+
+  /**
+   * \brief Set the path to the help, relative to the GDevelop documentation root.
    * For example, "/all-features/collisions" for
    * "http://wiki.compilgames.net/doku.php/gdevelop5/all-features/collisions".
    *
@@ -148,6 +160,8 @@ class GD_CORE_API PlatformExtension {
                                            const gd::String& group_,
                                            const gd::String& smallicon_);
 
+  gd::DependencyMetadata& AddDependency();
+
   /**
    * \brief Declare a new object as being part of the extension.
    * \note This method does nothing when used for GD C++ runtime.
@@ -225,6 +239,15 @@ class GD_CORE_API PlatformExtension {
                               const gd::String& smallicon_,
                               std::shared_ptr<gd::BaseEvent> instance);
 
+#if defined(GD_IDE_ONLY)
+  /**
+   * \brief Adds a property to the extension.
+   */
+  gd::PropertyDescriptor& RegisterProperty(const gd::String& name) {
+    return extensionPropertiesMetadata[name];
+  };
+#endif
+
   /**
    * \brief Return the name extension user friendly name.
    */
@@ -252,10 +275,16 @@ class GD_CORE_API PlatformExtension {
 
   /**
    * \brief Return the help path of extension, relative to the
-   * wiki/documentation root.
+   * GDevelop documentation root.
    */
   const gd::String& GetHelpPath() const { return helpPath; }
 
+  /**
+   * \brief Return the URL to the icon to be displayed for this
+   * extension.
+   */
+  const gd::String& GetIconUrl() const { return iconUrl; }
+
   /**
    * \brief Check if the extension is flagged as being deprecated.
    */
@@ -365,6 +394,12 @@ class GD_CORE_API PlatformExtension {
    */
   std::map<gd::String, gd::ExpressionMetadata>& GetAllStrExpressions();
 
+  /**
+   * \brief Return a reference to a vector containing the metadata of all the
+   * dependencies of the extension.
+   */
+  std::vector<gd::DependencyMetadata>& GetAllDependencies();
+
   /**
    * \brief Return a reference to a map containing the names of the actions,
    * related to the object type, and the metadata associated with.
@@ -437,6 +472,13 @@ class GD_CORE_API PlatformExtension {
    * generator.
    */
   void StripUnimplementedInstructionsAndExpressions();
+
+  /**
+   * \brief Get all the properties of the extension
+   */
+  std::map<gd::String, gd::PropertyDescriptor>& GetAllProperties() {
+    return extensionPropertiesMetadata;
+  }
 #endif
 
   /**
@@ -463,14 +505,15 @@ class GD_CORE_API PlatformExtension {
       nameSpace;  ///< Automatically set from the name of the extension, and
                   ///< added to every
                   ///< actions/conditions/expressions/objects/behavior/event.
-  gd::String fullname;      ///< Name displayed to users at edittime
-  gd::String informations;  ///< Description displayed to users at edittime
-  gd::String author;        ///< Author displayed to users at edittime
-  gd::String license;       ///< License name displayed to users at edittime
+  gd::String fullname;      ///< Name displayed to users in the editor.
+  gd::String informations;  ///< Description displayed to users in the editor.
+  gd::String author;        ///< Author displayed to users in the editor.
+  gd::String license;       ///< License name displayed to users in the editor.
   bool deprecated;  ///< true if the extension is deprecated and shouldn't be
                     ///< shown in IDE.
   gd::String helpPath;  ///< The relative path to the help for this extension in
                         ///< the documentation.
+  gd::String iconUrl;   ///< The URL to the icon to be shown for this extension.
 
   std::map<gd::String, gd::ObjectMetadata> objectsInfos;
   std::map<gd::String, gd::BehaviorMetadata> behaviorsInfo;
@@ -480,7 +523,9 @@ class GD_CORE_API PlatformExtension {
   std::map<gd::String, gd::InstructionMetadata> actionsInfos;
   std::map<gd::String, gd::ExpressionMetadata> expressionsInfos;
   std::map<gd::String, gd::ExpressionMetadata> strExpressionsInfos;
+  std::vector<gd::DependencyMetadata> extensionDependenciesMetadata;
   std::map<gd::String, gd::EventMetadata> eventsInfos;
+  std::map<gd::String, gd::PropertyDescriptor> extensionPropertiesMetadata;
 #endif
 
   ObjectMetadata badObjectMetadata;

Core/GDCore/IDE/Events/EventsContextAnalyzer.cpp

@@ -63,7 +63,16 @@ class GD_CORE_API ExpressionObjectsAnalyzer
       context.AddObjectName(node.identifierName);
     }
   }
-  void OnVisitFunctionNode(FunctionNode& node) override {
+  void OnVisitObjectFunctionNameNode(ObjectFunctionNameNode& node) override {
+    if (!node.objectName.empty()) {
+      context.AddObjectName(node.objectName);
+
+      if (!node.behaviorFunctionName.empty()) {
+        context.AddBehaviorName(node.objectName, node.objectFunctionOrBehaviorName);
+      }
+    }
+  }
+  void OnVisitFunctionCallNode(FunctionCallNode& node) override {
     if (!node.objectName.empty()) {
       context.AddObjectName(node.objectName);
 

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,13 @@ class GD_CORE_API ExpressionObjectRenamer : public ExpressionParser2NodeWorker {
       node.identifierName = objectNewName;
     }
   }
-  void OnVisitFunctionNode(FunctionNode& node) override {
+  void OnVisitObjectFunctionNameNode(ObjectFunctionNameNode& node) override {
+    if (node.objectName == objectName) {
+      hasDoneRenaming = true;
+      node.objectName = objectNewName;
+    }
+  }
+  void OnVisitFunctionCallNode(FunctionCallNode& node) override {
     if (node.objectName == objectName) {
       hasDoneRenaming = true;
       node.objectName = objectNewName;
@@ -107,7 +113,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 +154,12 @@ class GD_CORE_API ExpressionObjectFinder : public ExpressionParser2NodeWorker {
       hasObject = true;
     }
   }
-  void OnVisitFunctionNode(FunctionNode& node) override {
+  void OnVisitObjectFunctionNameNode(ObjectFunctionNameNode& node) override {
+    if (node.objectName == objectName) {
+      hasObject = true;
+    }
+  }
+  void OnVisitFunctionCallNode(FunctionCallNode& node) override {
     if (node.objectName == objectName) {
       hasObject = true;
     }
@@ -184,7 +195,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 +205,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 +248,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 +258,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));
         }
@@ -268,6 +279,43 @@ bool EventsRefactorer::RenameObjectInConditions(
   return somethingModified;
 }
 
+bool EventsRefactorer::RenameObjectInEventParameters(
+    const gd::Platform& platform,
+    gd::ObjectsContainer& project,
+    gd::ObjectsContainer& layout,
+    gd::Expression& expression,
+    gd::ParameterMetadata parameterMetadata,
+    gd::String oldName,
+    gd::String newName) {
+  bool somethingModified = false;
+
+  if (gd::ParameterMetadata::IsObject(parameterMetadata.GetType()) &&
+      expression.GetPlainString() == oldName)
+    expression = gd::Expression(newName);
+  // Replace object's name in expressions
+  else if (ParameterMetadata::IsExpression(
+               "number", parameterMetadata.GetType())) {
+    gd::ExpressionParser2 parser(platform, project, layout);
+    auto node = parser.ParseExpression("number", expression.GetPlainString());
+
+    if (ExpressionObjectRenamer::Rename(*node, oldName, newName)) {
+      expression = ExpressionParser2NodePrinter::PrintNode(*node);
+    }
+  }
+  // Replace object's name in text expressions
+  else if (ParameterMetadata::IsExpression(
+               "string", parameterMetadata.GetType())) {
+    gd::ExpressionParser2 parser(platform, project, layout);
+    auto node = parser.ParseExpression("string", expression.GetPlainString());
+
+    if (ExpressionObjectRenamer::Rename(*node, oldName, newName)) {
+      expression = ExpressionParser2NodePrinter::PrintNode(*node);
+    }
+  }
+
+  return somethingModified;
+}
+
 void EventsRefactorer::RenameObjectInEvents(const gd::Platform& platform,
                                             gd::ObjectsContainer& project,
                                             gd::ObjectsContainer& layout,
@@ -289,6 +337,15 @@ void EventsRefactorer::RenameObjectInEvents(const gd::Platform& platform,
           platform, project, layout, *actionsVectors[j], oldName, newName);
     }
 
+    vector<pair<gd::Expression*, gd::ParameterMetadata>> expressionsWithMetadata =
+        events[i].GetAllExpressionsWithMetadata();
+    for (std::size_t j = 0; j < expressionsWithMetadata.size(); ++j) {
+      gd::Expression* expression = expressionsWithMetadata[j].first;
+      gd::ParameterMetadata parameterMetadata = expressionsWithMetadata[j].second;
+      bool somethingModified = RenameObjectInEventParameters(
+        platform, project, layout, *expression, parameterMetadata, oldName, newName);
+    }
+
     if (events[i].CanHaveSubEvents())
       RenameObjectInEvents(platform,
                            project,
@@ -323,7 +380,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 +391,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 +441,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 +452,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;
@@ -595,7 +652,8 @@ vector<EventsSearchResult> EventsRefactorer::SearchInEvents(
     gd::String search,
     bool matchCase,
     bool inConditions,
-    bool inActions) {
+    bool inActions,
+    bool inEventStrings) {
   vector<EventsSearchResult> results;
 
   for (std::size_t i = 0; i < events.size(); ++i) {
@@ -631,6 +689,16 @@ vector<EventsSearchResult> EventsRefactorer::SearchInEvents(
       }
     }
 
+    if (inEventStrings) {
+      if (!eventAddedInResults &&
+          SearchStringInEvent(project, layout, events[i], search, matchCase)) {
+        results.push_back(EventsSearchResult(
+            std::weak_ptr<gd::BaseEvent>(events.GetEventSmartPtr(i)),
+            &events,
+            i));
+      }
+    }
+
     if (events[i].CanHaveSubEvents()) {
       vector<EventsSearchResult> subResults =
           SearchInEvents(project,
@@ -639,7 +707,8 @@ vector<EventsSearchResult> EventsRefactorer::SearchInEvents(
                          search,
                          matchCase,
                          inConditions,
-                         inActions);
+                         inActions,
+                         inEventStrings);
       std::copy(
           subResults.begin(), subResults.end(), std::back_inserter(results));
     }
@@ -711,6 +780,22 @@ bool EventsRefactorer::SearchStringInConditions(
   return false;
 }
 
+bool EventsRefactorer::SearchStringInEvent(gd::ObjectsContainer& project,
+                                            gd::ObjectsContainer& layout,
+                                            gd::BaseEvent& event,
+                                            gd::String search,
+                                            bool matchCase) {
+  for (gd::String str : event.GetAllSearchableStrings()) {
+    if (matchCase) {
+      if (str.find(search) != gd::String::npos) return true;
+    } else {
+      if (str.FindCaseInsensitive(search) != gd::String::npos) return true;
+    }
+  }
+
+  return false;
+}
+
 EventsSearchResult::EventsSearchResult(std::weak_ptr<gd::BaseEvent> event_,
                                        gd::EventsList* eventsList_,
                                        std::size_t positionInList_)

Core/GDCore/IDE/Events/EventsRefactorer.h

@@ -8,6 +8,7 @@
 #include <memory>
 #include <vector>
 #include "GDCore/Events/Instruction.h"
+#include "GDCore/Extensions/Metadata/InstructionMetadata.h"
 #include "GDCore/String.h"
 namespace gd {
 class EventsList;
@@ -103,7 +104,8 @@ class GD_CORE_API EventsRefactorer {
                                                         gd::String search,
                                                         bool matchCase,
                                                         bool inConditions,
-                                                        bool inAction);
+                                                        bool inActions,
+                                                        bool inEventStrings);
 
   /**
    * Replace all occurrences of a gd::String in events
@@ -145,6 +147,20 @@ class GD_CORE_API EventsRefactorer {
                                        gd::InstructionsList& instructions,
                                        gd::String oldName,
                                        gd::String newName);
+   /**
+   * Replace all occurrences of an object name by another name in an expression
+   * with the specified metadata
+   * ( include : objects or objects in math/text expressions ).
+   *
+   * \return true if something was modified.
+   */
+  static bool RenameObjectInEventParameters(const gd::Platform& platform,
+                                            gd::ObjectsContainer& project,
+                                            gd::ObjectsContainer& layout,
+                                            gd::Expression& expression,
+                                            gd::ParameterMetadata parameterMetadata,
+                                            gd::String oldName,
+                                            gd::String newName);
 
   /**
    * Remove all conditions of the list using an object
@@ -202,6 +218,11 @@ class GD_CORE_API EventsRefactorer {
                                        gd::InstructionsList& conditions,
                                        gd::String search,
                                        bool matchCase);
+  static bool SearchStringInEvent(gd::ObjectsContainer& project,
+                                       gd::ObjectsContainer& layout,
+                                       gd::BaseEvent& events,
+                                       gd::String search,
+                                       bool matchCase);
 
   EventsRefactorer(){};
 };

Core/GDCore/IDE/Events/EventsVariablesFinder.cpp

@@ -63,7 +63,8 @@ class GD_CORE_API ExpressionParameterSearcher
     if (node.child) node.child->Visit(*this);
   }
   void OnVisitIdentifierNode(IdentifierNode& node) override {}
-  void OnVisitFunctionNode(FunctionNode& node) override {
+  void OnVisitObjectFunctionNameNode(ObjectFunctionNameNode& 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();

Core/GDCore/IDE/Events/ExpressionCompletionFinder.h

@@ -0,0 +1,366 @@
+/*
+ * GDevelop Core
+ * Copyright 2008-present Florian Rival (Florian.Rival@gmail.com). All rights
+ * reserved. This project is released under the MIT License.
+ */
+#ifndef GDCORE_EXPRESSIONAUTOCOMPLETIONPROVIDER_H
+#define GDCORE_EXPRESSIONAUTOCOMPLETIONPROVIDER_H
+
+#include <memory>
+#include <vector>
+#include "GDCore/Events/Parsers/ExpressionParser2Node.h"
+#include "GDCore/Events/Parsers/ExpressionParser2NodeWorker.h"
+#include "GDCore/Extensions/Metadata/InstructionMetadata.h"
+#include "GDCore/IDE/Events/ExpressionNodeLocationFinder.h"
+namespace gd {
+class Expression;
+class ObjectsContainer;
+class Platform;
+class ParameterMetadata;
+class ExpressionMetadata;
+}  // namespace gd
+
+namespace gd {
+
+/**
+ * \brief Describe completions to be shown to the user.
+ *
+ * The IDE is responsible for actually *searching* and showing the completions -
+ * this is only describing what must be listed.
+ */
+struct ExpressionCompletionDescription {
+ public:
+  /**
+   * The different kind of completions that can be described.
+   */
+  enum CompletionKind {
+    Object,
+    Behavior,
+    Expression,
+    Variable,
+  };
+
+  /**
+   * \brief Create a completion for an object with the given prefix
+   */
+  static ExpressionCompletionDescription ForObject(const gd::String& type_,
+                                                   const gd::String& prefix_) {
+    return ExpressionCompletionDescription(Object, type_, prefix_);
+  }
+
+  /**
+   * \brief Create a completion for a behavior with the given prefix of
+   * the specified object
+   */
+  static ExpressionCompletionDescription ForBehavior(
+      const gd::String& prefix_, const gd::String& objectName_) {
+    return ExpressionCompletionDescription(Behavior, "", prefix_, objectName_);
+  }
+
+  /**
+   * \brief Create a completion for a variable with the given prefix
+   */
+  static ExpressionCompletionDescription ForVariable(
+      const gd::String& type_, const gd::String& prefix_) {
+    return ExpressionCompletionDescription(Variable, type_, prefix_);
+  }
+  /**
+   * \brief Create a completion for an expression (free, object or behavior
+   * expression) with the given prefix
+   */
+  static ExpressionCompletionDescription ForExpression(
+      const gd::String& type_,
+      const gd::String& prefix_,
+      const gd::String& objectName_ = "",
+      const gd::String& behaviorName_ = "") {
+    return ExpressionCompletionDescription(
+        Expression, type_, prefix_, objectName_, behaviorName_);
+  }
+
+  /** Check if two description of completions are equal */
+  bool operator==(const ExpressionCompletionDescription& other) const {
+    return completionKind == other.completionKind && type == other.type &&
+           prefix == other.prefix && objectName == other.objectName &&
+           behaviorName == other.behaviorName;
+  };
+
+  /** \brief Return the kind of the completion */
+  CompletionKind GetCompletionKind() const { return completionKind; }
+
+  /**
+   * \brief Return the type of the completion (same type as types supported in
+   * expressions)
+   * (in other words, for expression this is the type of what must be returned).
+   */
+  const gd::String& GetType() const { return type; }
+
+  /**
+   * \brief Return the prefix currently entered and that must be completed.
+   */
+  const gd::String& GetPrefix() const { return prefix; }
+
+  /**
+   * \brief Return the object name, if completing an object expression or a
+   * behavior.
+   */
+  const gd::String& GetObjectName() const { return objectName; }
+
+  /**
+   * \brief Return the behavior name, if completing an object behavior
+   * expression.
+   *
+   * \warning If completing a behavior, the behavior (partial) name is returned
+   * by `GetPrefix`.
+   */
+  const gd::String& GetBehaviorName() const { return behaviorName; }
+
+  /**
+   * \brief Set if the completion description is exact, i.e: it's not used
+   * to complete anything. Rather, it should display information about what is
+   * described by the completion.
+   */
+  ExpressionCompletionDescription& SetIsExact(bool isExact_) {
+    isExact = isExact_;
+    return *this;
+  }
+
+  /**
+   * \brief Check if the completion description is exact, i.e: it's not
+   * used to complete anything. Rather, it should display information
+   * about what is described by the completion.
+   */
+  bool IsExact() const { return isExact; }
+
+  /** Default constructor, only to be used by Emscripten bindings. */
+  ExpressionCompletionDescription() : completionKind(Object){};
+
+ private:
+  ExpressionCompletionDescription(CompletionKind completionKind_,
+                                  const gd::String& type_,
+                                  const gd::String& prefix_,
+                                  const gd::String& objectName_ = "",
+                                  const gd::String& behaviorName_ = "")
+      : completionKind(completionKind_),
+        type(type_),
+        prefix(prefix_),
+        objectName(objectName_),
+        behaviorName(behaviorName_),
+        isExact(false) {}
+
+  CompletionKind completionKind;
+  gd::String type;
+  gd::String prefix;
+  gd::String objectName;
+  gd::String behaviorName;
+  bool isExact;
+};
+
+/**
+ * \brief Turn an ExpressionCompletionDescription to a string.
+ */
+std::ostream& operator<<(std::ostream& os,
+                         ExpressionCompletionDescription const& value) {
+  os << "{ " << value.GetCompletionKind() << ", " << value.GetType() << ", "
+     << value.GetPrefix() << ", " << value.GetObjectName() << ", "
+     << value.GetBehaviorName() << ", "
+     << (value.IsExact() ? "exact" : "non-exact") << " }";
+  return os;
+}
+
+/**
+ * \brief Returns the list of completion descriptions for an expression node.
+ *
+ * \see gd::ExpressionCompletionDescription
+ */
+class GD_CORE_API ExpressionCompletionFinder
+    : public ExpressionParser2NodeWorker {
+ public:
+  /**
+   * \brief Given the expression, find the node at the specified location
+   * and returns completions for it.
+   */
+  static std::vector<ExpressionCompletionDescription>
+  GetCompletionDescriptionsFor(gd::ExpressionNode& node,
+                               size_t searchedPosition) {
+    gd::ExpressionNode* nodeAtLocation =
+        gd::ExpressionNodeLocationFinder::GetNodeAtPosition(node,
+                                                            searchedPosition);
+
+    if (nodeAtLocation == nullptr) {
+      std::vector<ExpressionCompletionDescription> emptyCompletions;
+      return emptyCompletions;
+    }
+
+    gd::ExpressionCompletionFinder autocompletionProvider(searchedPosition);
+    nodeAtLocation->Visit(autocompletionProvider);
+    return autocompletionProvider.GetCompletionDescriptions();
+  }
+
+  /**
+   * \brief Return the completions found for the visited node.
+   */
+  const std::vector<ExpressionCompletionDescription>&
+  GetCompletionDescriptions() {
+    return completions;
+  };
+
+  virtual ~ExpressionCompletionFinder(){};
+
+ protected:
+  void OnVisitSubExpressionNode(SubExpressionNode& node) override {
+    completions.push_back(
+        ExpressionCompletionDescription::ForObject(node.type, ""));
+    completions.push_back(
+        ExpressionCompletionDescription::ForExpression(node.type, ""));
+  }
+  void OnVisitOperatorNode(OperatorNode& node) override {
+    completions.push_back(
+        ExpressionCompletionDescription::ForObject(node.type, ""));
+    completions.push_back(
+        ExpressionCompletionDescription::ForExpression(node.type, ""));
+  }
+  void OnVisitUnaryOperatorNode(UnaryOperatorNode& node) override {
+    completions.push_back(
+        ExpressionCompletionDescription::ForObject(node.type, ""));
+    completions.push_back(
+        ExpressionCompletionDescription::ForExpression(node.type, ""));
+  }
+  void OnVisitNumberNode(NumberNode& node) override {
+    // No completions
+  }
+  void OnVisitTextNode(TextNode& node) override {
+    // No completions
+  }
+  void OnVisitVariableNode(VariableNode& node) override {
+    completions.push_back(
+        ExpressionCompletionDescription::ForVariable(node.type, node.name));
+  }
+  void OnVisitVariableAccessorNode(VariableAccessorNode& node) override {
+    // No completions
+  }
+  void OnVisitVariableBracketAccessorNode(
+      VariableBracketAccessorNode& node) override {
+    // No completions
+  }
+  void OnVisitIdentifierNode(IdentifierNode& node) override {
+    if (gd::ParameterMetadata::IsObject(node.type)) {
+      // Only show completions of objects if an object is required
+      completions.push_back(ExpressionCompletionDescription::ForObject(
+          node.type, node.identifierName));
+    } else {
+      // Show completions for expressions and objects otherwise.
+      completions.push_back(ExpressionCompletionDescription::ForObject(
+          node.type, node.identifierName));
+      completions.push_back(ExpressionCompletionDescription::ForExpression(
+          node.type, node.identifierName));
+    }
+  }
+  void OnVisitObjectFunctionNameNode(ObjectFunctionNameNode& node) override {
+    if (!node.behaviorFunctionName.empty() ||
+        node.behaviorNameNamespaceSeparatorLocation.IsValid()) {
+      // Behavior function (or behavior function being written, with the
+      // function name missing)
+      if (IsCaretOn(node.objectNameLocation)) {
+        completions.push_back(ExpressionCompletionDescription::ForObject(
+            node.type, node.objectName));
+      } else if (IsCaretOn(node.objectNameDotLocation) ||
+                 IsCaretOn(node.objectFunctionOrBehaviorNameLocation)) {
+        completions.push_back(ExpressionCompletionDescription::ForBehavior(
+            node.objectFunctionOrBehaviorName, node.objectName));
+      } else if (IsCaretOn(node.behaviorNameNamespaceSeparatorLocation) ||
+                 IsCaretOn(node.behaviorFunctionNameLocation)) {
+        completions.push_back(ExpressionCompletionDescription::ForExpression(
+            node.type,
+            node.behaviorFunctionName,
+            node.objectName,
+            node.objectFunctionOrBehaviorName));
+      }
+    } else {
+      // Object function or behavior name
+      if (IsCaretOn(node.objectNameLocation)) {
+        completions.push_back(ExpressionCompletionDescription::ForObject(
+            node.type, node.objectName));
+      } else if (IsCaretOn(node.objectNameDotLocation) ||
+                 IsCaretOn(node.objectFunctionOrBehaviorNameLocation)) {
+        completions.push_back(ExpressionCompletionDescription::ForBehavior(
+            node.objectFunctionOrBehaviorName, node.objectName));
+        completions.push_back(ExpressionCompletionDescription::ForExpression(
+            node.type, node.objectFunctionOrBehaviorName, node.objectName));
+      }
+    }
+  }
+  void OnVisitFunctionCallNode(FunctionCallNode& node) override {
+    bool isCaretOnParenthesis = IsCaretOn(node.openingParenthesisLocation) ||
+                                IsCaretOn(node.closingParenthesisLocation);
+
+    if (!node.behaviorName.empty()) {
+      // Behavior function
+      if (IsCaretOn(node.objectNameLocation)) {
+        completions.push_back(ExpressionCompletionDescription::ForObject(
+            node.type, node.objectName));
+      } else if (IsCaretOn(node.objectNameDotLocation) ||
+                 IsCaretOn(node.behaviorNameLocation)) {
+        completions.push_back(ExpressionCompletionDescription::ForBehavior(
+            node.behaviorName, node.objectName));
+      } else {
+        completions.push_back(
+            ExpressionCompletionDescription::ForExpression(node.type,
+                                                           node.functionName,
+                                                           node.objectName,
+                                                           node.behaviorName)
+                .SetIsExact(isCaretOnParenthesis));
+      }
+    } else if (!node.objectName.empty()) {
+      // Object function
+      if (IsCaretOn(node.objectNameLocation)) {
+        completions.push_back(ExpressionCompletionDescription::ForObject(
+            node.type, node.objectName));
+      } else {
+        // Add completions for behaviors, because we could imagine that the user
+        // wants to move from an object function to a behavior function, and so
+        // need behavior completions. Do this unless we're on the parenthesis
+        // (at which point we're only showing informative message about the
+        // function).
+        if (!isCaretOnParenthesis) {
+          completions.push_back(ExpressionCompletionDescription::ForBehavior(
+              node.functionName, node.objectName));
+        }
+
+        completions.push_back(ExpressionCompletionDescription::ForExpression(
+                                  node.type, node.functionName, node.objectName)
+                                  .SetIsExact(isCaretOnParenthesis));
+      }
+    } else {
+      // Free function
+      completions.push_back(ExpressionCompletionDescription::ForExpression(
+                                node.type, node.functionName)
+                                .SetIsExact(isCaretOnParenthesis));
+    }
+  }
+  void OnVisitEmptyNode(EmptyNode& node) override {
+    completions.push_back(
+        ExpressionCompletionDescription::ForObject(node.type, node.text));
+    completions.push_back(
+        ExpressionCompletionDescription::ForExpression(node.type, node.text));
+  }
+
+ private:
+  bool IsCaretOn(const ExpressionParserLocation& location,
+                 bool inclusive = false) {
+    if (!location.IsValid()) return false;
+
+    return (location.GetStartPosition() <= searchedPosition &&
+            ((!inclusive && searchedPosition < location.GetEndPosition()) ||
+             (inclusive && searchedPosition <= location.GetEndPosition())));
+  }
+
+  ExpressionCompletionFinder(size_t searchedPosition_)
+      : searchedPosition(searchedPosition_){};
+
+  std::vector<ExpressionCompletionDescription> completions;
+  size_t searchedPosition;
+};
+
+}  // namespace gd
+
+#endif  // GDCORE_EXPRESSIONAUTOCOMPLETIONPROVIDER_H

Core/GDCore/IDE/Events/ExpressionNodeLocationFinder.h

@@ -0,0 +1,126 @@
+/*
+ * GDevelop Core
+ * Copyright 2008-present Florian Rival (Florian.Rival@gmail.com). All rights
+ * reserved. This project is released under the MIT License.
+ */
+#ifndef GDCORE_EXPRESSIONNODELOCATIONFINDER_H
+#define GDCORE_EXPRESSIONNODELOCATIONFINDER_H
+
+#include <memory>
+#include <vector>
+#include "GDCore/Events/Parsers/ExpressionParser2Node.h"
+#include "GDCore/Events/Parsers/ExpressionParser2NodeWorker.h"
+namespace gd {
+class Expression;
+class ObjectsContainer;
+class Platform;
+class ParameterMetadata;
+class ExpressionMetadata;
+}  // namespace gd
+
+namespace gd {
+
+/**
+ * \brief Find the deepest node at the specified location in an expression.
+ *
+ * \see gd::ExpressionParser2
+ */
+class GD_CORE_API ExpressionNodeLocationFinder
+    : public ExpressionParser2NodeWorker {
+ public:
+  /**
+   * \brief Initialize the finder to search at the specified position.
+   */
+  ExpressionNodeLocationFinder(size_t searchedPosition_)
+      : searchedPosition(searchedPosition_), foundNode(nullptr){};
+  virtual ~ExpressionNodeLocationFinder(){};
+
+  /**
+   * \brief Helper function to find the deepest node at the search position, if
+   * any.
+   */
+  static ExpressionNode* GetNodeAtPosition(gd::ExpressionNode& node,
+                                           size_t searchedPosition) {
+    gd::ExpressionNodeLocationFinder finder(searchedPosition);
+    node.Visit(finder);
+    return finder.GetNode();
+  }
+
+  /**
+   * \brief Return the deepest node found at the search position, if any.
+   */
+  ExpressionNode* GetNode() { return foundNode; };
+
+ protected:
+  void OnVisitSubExpressionNode(SubExpressionNode& node) override {
+    CheckSearchPositionInNode(node);
+    node.expression->Visit(*this);
+  }
+  void OnVisitOperatorNode(OperatorNode& node) override {
+    if (CheckSearchPositionInNode(node)) {
+      node.leftHandSide->Visit(*this);
+      node.rightHandSide->Visit(*this);
+    }
+  }
+  void OnVisitUnaryOperatorNode(UnaryOperatorNode& node) override {
+    CheckSearchPositionInNode(node);
+    node.factor->Visit(*this);
+  }
+  void OnVisitNumberNode(NumberNode& node) override {
+    CheckSearchPositionInNode(node);
+  }
+  void OnVisitTextNode(TextNode& node) override {
+    CheckSearchPositionInNode(node);
+  }
+  void OnVisitVariableNode(VariableNode& node) override {
+    if (CheckSearchPositionInNode(node)) {
+      if (node.child) node.child->Visit(*this);
+    }
+  }
+  void OnVisitVariableAccessorNode(VariableAccessorNode& node) override {
+    if (CheckSearchPositionInNode(node)) {
+      if (node.child) node.child->Visit(*this);
+    }
+  }
+  void OnVisitVariableBracketAccessorNode(
+      VariableBracketAccessorNode& node) override {
+    if (CheckSearchPositionInNode(node)) {
+      node.expression->Visit(*this);
+      if (node.child) node.child->Visit(*this);
+    }
+  }
+  void OnVisitIdentifierNode(IdentifierNode& node) override {
+    CheckSearchPositionInNode(node);
+  }
+  void OnVisitObjectFunctionNameNode(ObjectFunctionNameNode& node) override {
+    CheckSearchPositionInNode(node);
+  }
+  void OnVisitFunctionCallNode(FunctionCallNode& node) override {
+    CheckSearchPositionInNode(node);
+    for (auto& parameter : node.parameters) {
+      parameter->Visit(*this);
+    }
+  }
+  void OnVisitEmptyNode(EmptyNode& node) override {
+    CheckSearchPositionInNode(node, /*inclusive=*/true);
+  }
+
+ private:
+  bool CheckSearchPositionInNode(ExpressionNode& node, bool inclusive = false) {
+    if (node.location.GetStartPosition() <= searchedPosition &&
+        ((!inclusive && searchedPosition < node.location.GetEndPosition()) ||
+         (inclusive && searchedPosition <= node.location.GetEndPosition()))) {
+      foundNode = &node;
+      return true;
+    }
+
+    return false;
+  }
+
+  size_t searchedPosition;
+  ExpressionNode* foundNode;
+};
+
+}  // namespace gd
+
+#endif  // GDCORE_EXPRESSIONNODELOCATIONFINDER_H

Core/GDCore/IDE/Events/ExpressionValidator.h

@@ -83,7 +83,10 @@ class GD_CORE_API ExpressionValidator : public ExpressionParser2NodeWorker {
   void OnVisitIdentifierNode(IdentifierNode& node) override {
     ReportAnyError(node);
   }
-  void OnVisitFunctionNode(FunctionNode& node) override {
+  void OnVisitObjectFunctionNameNode(ObjectFunctionNameNode& node) override {
+    ReportAnyError(node);
+  }
+  void OnVisitFunctionCallNode(FunctionCallNode& node) override {
     ReportAnyError(node);
     for (auto& parameter : node.parameters) {
       parameter->Visit(*this);

Core/GDCore/IDE/Events/ExpressionsCorrectnessTesting.cpp

@@ -1,59 +0,0 @@
-/*
- * GDevelop Core
- * Copyright 2008-2016 Florian Rival (Florian.Rival@gmail.com). All rights
- * reserved. This project is released under the MIT License.
- */
-
-#include "GDCore/IDE/Events/ExpressionsCorrectnessTesting.h"
-#include "GDCore/CommonTools.h"
-#include "GDCore/Events/Expression.h"
-#include "GDCore/Events/Parsers/ExpressionParser.h"
-#include "GDCore/Project/Layout.h"
-#include "GDCore/Project/Project.h"
-
-namespace gd {
-
-CallbacksForExpressionCorrectnessTesting::
-    CallbacksForExpressionCorrectnessTesting(const gd::ObjectsContainer& project_,
-                                             const gd::ObjectsContainer& layout_)
-    : project(project_), layout(layout_) {}
-
-bool CallbacksForExpressionCorrectnessTesting::OnSubMathExpression(
-    const gd::Platform& platform,
-    const gd::ObjectsContainer& project,
-    const gd::ObjectsContainer& layout,
-    gd::Expression& expression) {
-  CallbacksForExpressionCorrectnessTesting callbacks(project, layout);
-
-  gd::ExpressionParser parser(expression.GetPlainString());
-  if (!parser.ParseMathExpression(platform, project, layout, callbacks)) {
-#if defined(GD_IDE_ONLY)
-    firstErrorStr = callbacks.GetFirstError();
-    firstErrorPos = callbacks.GetFirstErrorPosition();
-#endif
-    return false;
-  }
-
-  return true;
-}
-
-bool CallbacksForExpressionCorrectnessTesting::OnSubTextExpression(
-    const gd::Platform& platform,
-    const gd::ObjectsContainer& project,
-    const gd::ObjectsContainer& layout,
-    gd::Expression& expression) {
-  CallbacksForExpressionCorrectnessTesting callbacks(project, layout);
-
-  gd::ExpressionParser parser(expression.GetPlainString());
-  if (!parser.ParseStringExpression(platform, project, layout, callbacks)) {
-#if defined(GD_IDE_ONLY)
-    firstErrorStr = callbacks.GetFirstError();
-    firstErrorPos = callbacks.GetFirstErrorPosition();
-#endif
-    return false;
-  }
-
-  return true;
-}
-
-}  // namespace gd

Core/GDCore/IDE/Events/ExpressionsCorrectnessTesting.h

@@ -1,75 +0,0 @@
-/*
- * GDevelop Core
- * Copyright 2008-2016 Florian Rival (Florian.Rival@gmail.com). All rights
- * reserved. This project is released under the MIT License.
- */
-
-#ifndef GDCORE_EXPRESSIONSCORRECTNESSTESTING_H
-#define GDCORE_EXPRESSIONSCORRECTNESSTESTING_H
-
-#include <vector>
-#include "GDCore/Events/Parsers/ExpressionParser.h"
-#include "GDCore/String.h"
-namespace gd {
-class ExpressionMetadata;
-class Expression;
-class Project;
-class Layout;
-}
-
-namespace gd {
-
-// TODO: Replace and remove (ExpressionValidator)
-
-/**
- * \brief Parser callbacks used to check expressions correctness
- *
- * Usage example:
- * \code
- * gd::CallbacksForExpressionCorrectnessTesting callbacks(game, scene);
- * gd::ExpressionParser expressionParser(expression);
- * if ( !expressionParser.ParseMathExpression(game, scene, callbacks) )
- *     //Expression is not valid
- * else
- *     //Expression is correct
- * \endcode
- *
- * \see gd::ExpressionParser
- * \see gd::ParserCallbacks
- *
- * \ingroup IDE
- */
-class GD_CORE_API CallbacksForExpressionCorrectnessTesting
-    : public gd::ParserCallbacks {
- public:
-  CallbacksForExpressionCorrectnessTesting(const gd::ObjectsContainer& project,
-                                           const gd::ObjectsContainer& layout);
-  virtual ~CallbacksForExpressionCorrectnessTesting(){};
-
-  void OnConstantToken(gd::String text){};
-  void OnStaticFunction(gd::String functionName,
-                        const std::vector<gd::Expression>& parameters,
-                        const gd::ExpressionMetadata& expressionInfo){};
-  void OnObjectFunction(gd::String functionName,
-                        const std::vector<gd::Expression>& parameters,
-                        const gd::ExpressionMetadata& expressionInfo){};
-  void OnObjectBehaviorFunction(gd::String functionName,
-                                const std::vector<gd::Expression>& parameters,
-                                const gd::ExpressionMetadata& expressionInfo){};
-  bool OnSubMathExpression(const gd::Platform& platform,
-                           const gd::ObjectsContainer& project,
-                           const gd::ObjectsContainer& layout,
-                           gd::Expression& expression);
-  bool OnSubTextExpression(const gd::Platform& platform,
-                           const gd::ObjectsContainer& project,
-                           const gd::ObjectsContainer& layout,
-                           gd::Expression& expression);
-
- private:
-  const gd::ObjectsContainer& project;
-  const gd::ObjectsContainer& layout;
-};
-
-}  // namespace gd
-
-#endif  // GDCORE_EXPRESSIONSCORRECTNESSTESTING_H

Core/GDCore/IDE/Events/ExpressionsParameterMover.cpp

@@ -74,7 +74,8 @@ class GD_CORE_API ExpressionParameterMover
     if (node.child) node.child->Visit(*this);
   }
   void OnVisitIdentifierNode(IdentifierNode& node) override {}
-  void OnVisitFunctionNode(FunctionNode& node) override {
+  void OnVisitObjectFunctionNameNode(ObjectFunctionNameNode& 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())
@@ -87,7 +88,8 @@ class GD_CORE_API ExpressionParameterMover
         };
 
     if (node.functionName == functionName) {
-      if (!objectType.empty() && !node.objectName.empty()) {
+      if (behaviorType.empty() && !objectType.empty() &&
+          !node.objectName.empty()) {
         // Move parameter of an object function
         const gd::String& thisObjectType = gd::GetTypeOfObject(
             globalObjectsContainer, objectsContainer, node.objectName);
@@ -103,7 +105,7 @@ class GD_CORE_API ExpressionParameterMover
           moveParameter(node.parameters);
           hasDoneMoving = true;
         }
-      } else {
+      } else if (behaviorType.empty() && objectType.empty()) {
         // Move parameter of a free function
         moveParameter(node.parameters);
         hasDoneMoving = true;
@@ -119,10 +121,12 @@ class GD_CORE_API ExpressionParameterMover
   bool hasDoneMoving;
   const gd::ObjectsContainer& globalObjectsContainer;
   const gd::ObjectsContainer& objectsContainer;
-  const gd::String& behaviorType;  // The behavior type for which the expression
-                                   // must be replaced (optional)
-  const gd::String& objectType;    // The object type for which the expression
-                                   // must be replaced (optional)
+  const gd::String& behaviorType;  // The behavior type of the function which
+                                   // must have a parameter moved (optional).
+  const gd::String& objectType;    // The object type of the function which
+                                   // must have a parameter moved (optional). If
+                                   // `behaviorType` is not empty, it takes
+                                   // precedence over `objectType`.
   const gd::String& functionName;
   std::size_t oldIndex;
   std::size_t newIndex;

Core/GDCore/IDE/Events/ExpressionsRenamer.cpp

@@ -71,13 +71,41 @@ class GD_CORE_API ExpressionFunctionRenamer
     if (node.child) node.child->Visit(*this);
   }
   void OnVisitIdentifierNode(IdentifierNode& node) override {}
-  void OnVisitFunctionNode(FunctionNode& node) override {
+  void OnVisitObjectFunctionNameNode(ObjectFunctionNameNode& node) override {
+    if (!node.behaviorFunctionName.empty()) {
+      // Behavior function name
+      if (!behaviorType.empty() &&
+          node.behaviorFunctionName == oldFunctionName) {
+        const gd::String& thisBehaviorType =
+            gd::GetTypeOfBehavior(globalObjectsContainer,
+                                  objectsContainer,
+                                  node.objectFunctionOrBehaviorName);
+        if (thisBehaviorType == behaviorType) {
+          node.behaviorFunctionName = newFunctionName;
+          hasDoneRenaming = true;
+        }
+      }
+    } else {
+      // Object function name
+      if (behaviorType.empty() && !objectType.empty() &&
+          node.objectFunctionOrBehaviorName == oldFunctionName) {
+        const gd::String& thisObjectType = gd::GetTypeOfObject(
+            globalObjectsContainer, objectsContainer, node.objectName);
+        if (thisObjectType == objectType) {
+          node.objectFunctionOrBehaviorName = newFunctionName;
+          hasDoneRenaming = true;
+        }
+      }
+    }
+  }
+  void OnVisitFunctionCallNode(FunctionCallNode& node) override {
     if (node.functionName == oldFunctionName) {
-      if (!objectType.empty() && !node.objectName.empty()) {
+      if (behaviorType.empty() && !objectType.empty() &&
+          !node.objectName.empty()) {
         // Replace an object function
         const gd::String& thisObjectType = gd::GetTypeOfObject(
             globalObjectsContainer, objectsContainer, node.objectName);
-        if (thisObjectType == behaviorType) {
+        if (thisObjectType == objectType) {
           node.functionName = newFunctionName;
           hasDoneRenaming = true;
         }
@@ -89,7 +117,7 @@ class GD_CORE_API ExpressionFunctionRenamer
           node.functionName = newFunctionName;
           hasDoneRenaming = true;
         }
-      } else {
+      } else if (behaviorType.empty() && objectType.empty()) {
         // Replace a free function
         node.functionName = newFunctionName;
         hasDoneRenaming = true;
@@ -106,9 +134,11 @@ class GD_CORE_API ExpressionFunctionRenamer
   const gd::ObjectsContainer& globalObjectsContainer;
   const gd::ObjectsContainer& objectsContainer;
   const gd::String& behaviorType;  // The behavior type for which the expression
-                                   // must be replaced (optional)
+                                   // must be replaced (optional).
   const gd::String& objectType;    // The object type for which the expression
-                                   // must be replaced (optional)
+                                   // must be replaced (optional). If
+                                   // `behaviorType` is not empty, it takes
+                                   // precedence over `objectType`.
   const gd::String& oldFunctionName;
   const gd::String& newFunctionName;
 };

Core/GDCore/IDE/Events/InstructionSentenceFormatter.cpp

@@ -49,9 +49,15 @@ InstructionSentenceFormatter::GetAsFormattedText(
 
   gd::String sentence = metadata.GetSentence();
   std::replace(sentence.Raw().begin(), sentence.Raw().end(), '\n', ' ');
-  bool parse = true;
 
+  size_t loopCount = 0;
+  bool parse = true;
   while (parse) {
+    if (loopCount > 40) {
+      break;
+    }
+    loopCount++;
+
     // Search first parameter
     parse = false;
     size_t firstParamPosition = gd::String::npos;

Core/GDCore/IDE/Project/ResourcesRenamer.h

@@ -0,0 +1,61 @@
+/*
+ * GDevelop Core
+ * Copyright 2008-2016 Florian Rival (Florian.Rival@gmail.com). All rights
+ * reserved. This project is released under the MIT License.
+ */
+
+#if defined(GD_IDE_ONLY)
+#ifndef GDCORE_RESOURCESRENAMER_H
+#define GDCORE_RESOURCESRENAMER_H
+
+#include <set>
+#include <vector>
+
+#include "GDCore/IDE/Project/ArbitraryResourceWorker.h"
+#include "GDCore/String.h"
+
+namespace gd {
+
+/**
+ * \brief Class used to rename resources (in an object, an entire project,
+ * etc...)
+ *
+ * \ingroup IDE
+ */
+class ResourcesRenamer : public gd::ArbitraryResourceWorker {
+ public:
+  /**
+   * @brief Constructor taking the map from old name to new name.
+   * @param oldToNewNames_ A map associating to a resource name the new name to
+   * use.
+   */
+  ResourcesRenamer(const std::map<gd::String, gd::String>& oldToNewNames_)
+      : gd::ArbitraryResourceWorker(), oldToNewNames(oldToNewNames_){};
+  virtual ~ResourcesRenamer(){};
+
+  virtual void ExposeFile(gd::String& resourceName) override {
+    RenameIfNeeded(resourceName);
+  };
+  virtual void ExposeImage(gd::String& imageResourceName) override {
+    RenameIfNeeded(imageResourceName);
+  };
+  virtual void ExposeAudio(gd::String& audioResourceName) override {
+    RenameIfNeeded(audioResourceName);
+  };
+  virtual void ExposeFont(gd::String& fontResourceName) override {
+    RenameIfNeeded(fontResourceName);
+  };
+
+ private:
+  void RenameIfNeeded(gd::String& resourceName) {
+    if (oldToNewNames.find(resourceName) != oldToNewNames.end())
+      resourceName = oldToNewNames[resourceName];
+  }
+
+  std::map<gd::String, gd::String> oldToNewNames;
+};
+
+}  // namespace gd
+
+#endif  // GDCORE_RESOURCESRENAMER_H
+#endif

Core/GDCore/IDE/ProjectStripper.cpp

@@ -4,6 +4,7 @@
  * reserved. This project is released under the MIT License.
  */
 #include "ProjectStripper.h"
+
 #include "GDCore/Project/ExternalEvents.h"
 #include "GDCore/Project/ExternalLayout.h"
 #include "GDCore/Project/Layout.h"
@@ -20,61 +21,8 @@ void GD_CORE_API ProjectStripper::StripProjectForExport(gd::Project& project) {
     project.GetLayout(i).GetObjectGroups().Clear();
     project.GetLayout(i).GetEvents().Clear();
   }
-}
 
-void GD_CORE_API ProjectStripper::StripProjectForLayoutEdition(
-    gd::Project& project, const gd::String& layoutName) {
-  while (project.GetExternalEventsCount() > 0)
-    project.RemoveExternalEvents(project.GetExternalEvents(0).GetName());
-
-  for (unsigned int i = 0; i < project.GetLayoutsCount(); ++i) {
-    auto& layout = project.GetLayout(i);
-    if (layoutName == layout.GetName()) continue;
-
-    project.GetLayout(i).GetEvents().Clear();
-    project.GetLayout(i).GetInitialInstances().Clear();
-  }
-
-  for (unsigned int i = 0; i < project.GetExternalEventsCount(); ++i) {
-    project.GetExternalEvents(i).GetEvents().Clear();
-  }
-
-  for (unsigned int i = 0; i < project.GetExternalLayoutsCount(); ++i) {
-    project.GetExternalLayout(i).GetInitialInstances().Clear();
-  }
-}
-
-void GD_CORE_API ProjectStripper::StripProjectForExternalLayoutEdition(
-    gd::Project& project, const gd::String& externalLayoutName) {
-  while (project.GetExternalEventsCount() > 0)
-    project.RemoveExternalEvents(project.GetExternalEvents(0).GetName());
-
-  gd::String associatedLayoutName;
-  if (project.HasExternalLayoutNamed(externalLayoutName)) {
-    associatedLayoutName =
-        project.GetExternalLayout(externalLayoutName).GetAssociatedLayout();
-  }
-
-  for (unsigned int i = 0; i < project.GetLayoutsCount(); ++i) {
-    auto& layout = project.GetLayout(i);
-    if (!associatedLayoutName.empty() &&
-        associatedLayoutName == layout.GetName())
-      continue;
-
-    project.GetLayout(i).GetEvents().Clear();
-    project.GetLayout(i).GetInitialInstances().Clear();
-  }
-
-  for (unsigned int i = 0; i < project.GetExternalEventsCount(); ++i) {
-    project.GetExternalEvents(i).GetEvents().Clear();
-  }
-
-  for (unsigned int i = 0; i < project.GetExternalLayoutsCount(); ++i) {
-    auto& externalLayout = project.GetExternalLayout(i);
-    if (externalLayoutName == externalLayout.GetName()) continue;
-
-    externalLayout.GetInitialInstances().Clear();
-  }
+  project.ClearEventsFunctionsExtensions();
 }
 
 }  // namespace gd

Core/GDCore/IDE/ProjectStripper.h

@@ -28,23 +28,6 @@ class GD_CORE_API ProjectStripper {
    */
   static void StripProjectForExport(gd::Project& project);
 
-  /**
-   * \brief Strip project to keep only the full content of the specified
-   * layout. The content of other layouts, external events and external layouts
-   * is removed.
-   */
-  static void StripProjectForLayoutEdition(gd::Project& project,
-                                           const gd::String& layoutName);
-
-  /**
-   * \brief Strip project to keep only the full content of the specified
-   * external layout and the associated layout.
-   * The content of other layouts, external events and external layouts is
-   * removed.
-   */
-  static void StripProjectForExternalLayoutEdition(
-      gd::Project& project, const gd::String& externalLayoutName);
-
  private:
   ProjectStripper(){};
   virtual ~ProjectStripper(){};

Core/GDCore/IDE/SceneNameMangler.cpp

@@ -10,34 +10,49 @@
 
 namespace gd {
 
-gd::String SceneNameMangler::GetMangledSceneName(gd::String sceneName) {
-  static const gd::String allowedCharacters =
-      "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
-  static const gd::String allowedExceptFirst = "0123456789";
+SceneNameMangler *SceneNameMangler::_singleton = nullptr;
 
-  std::size_t i = 0;
-  for (auto it = sceneName.begin(); it != sceneName.end(); ++it) {
-    char32_t character = *it;
-    if (allowedCharacters.find(character) == gd::String::npos &&
-        (allowedExceptFirst.find(character) == gd::String::npos ||
-         i == 0))  // Also disallow some characters to be in first position
-    {
-      // Replace the character by an underscore and its unicode codepoint (in
-      // base 10)
-      auto it2 = it;
-      ++it2;
-      sceneName.replace(it, it2, "_" + gd::String::From(character));
-
-      // The iterator it may have been invalidated:
-      // re-assign it with a new iterator pointing to the same position.
-      it = sceneName.begin();
-      std::advance(it, i);
-    }
-
-    ++i;
+const gd::String &SceneNameMangler::GetMangledSceneName(
+    const gd::String &sceneName) {
+  auto it = mangledSceneNames.find(sceneName);
+  if (it != mangledSceneNames.end()) {
+    return it->second;
   }
 
-  return sceneName;
+  gd::String partiallyMangledName = sceneName;
+  static const gd::String alwaysAllowedCharacters =
+      "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+  static const gd::String allowedExceptFirstCharacters = "0123456789";
+
+  for (size_t i = 0; i < partiallyMangledName.size();
+       ++i)  // Replace all unallowed letter by an underscore and the unicode
+             // code point of the letter
+  {
+    if (alwaysAllowedCharacters.find_first_of(
+            std::u32string(1, partiallyMangledName[i])) == gd::String::npos &&
+        (i == 0 ||
+         allowedExceptFirstCharacters.find(
+             std::u32string(1, partiallyMangledName[i])) == gd::String::npos)) {
+      char32_t unallowedChar = partiallyMangledName[i];
+      partiallyMangledName.replace(i, 1, "_" + gd::String::From(unallowedChar));
+    }
+  }
+
+  mangledSceneNames[sceneName] = partiallyMangledName;
+  return mangledSceneNames[sceneName];
+}
+
+SceneNameMangler *SceneNameMangler::Get() {
+  if (nullptr == _singleton) _singleton = new SceneNameMangler;
+
+  return (static_cast<SceneNameMangler *>(_singleton));
+}
+
+void SceneNameMangler::DestroySingleton() {
+  if (nullptr != _singleton) {
+    delete _singleton;
+    _singleton = nullptr;
+  }
 }
 
 }  // namespace gd

Core/GDCore/IDE/SceneNameMangler.h

@@ -6,12 +6,14 @@
 
 #ifndef SCENENAMEMANGLER_H
 #define SCENENAMEMANGLER_H
+#include <unordered_map>
 #include "GDCore/String.h"
 
 namespace gd {
 
 /**
- * \brief Used to mangle the name of a scene
+ * \brief Mangle the name of a scene, so that it can be used in code or file
+ * names.
  *
  * \ingroup IDE
  */
@@ -21,12 +23,22 @@ class GD_CORE_API SceneNameMangler {
    * \brief Mangle the name of a scene, replacing all characters that are not
    * 0-9, a-z or A-Z by "_"+UnicodeCodePointOfTheCharacter. The first character
    * must be a letter, otherwise it is also replaced in the same manner.
+   *
+   * The mangled name is memoized as this is intensively used during project
+   * export and events code generation.
    */
-  static gd::String GetMangledSceneName(gd::String sceneName);
+  const gd::String& GetMangledSceneName(const gd::String& sceneName);
+
+  static SceneNameMangler* Get();
+  static void DestroySingleton();
 
  private:
   SceneNameMangler(){};
   virtual ~SceneNameMangler(){};
+  static SceneNameMangler* _singleton;
+
+  std::unordered_map<gd::String, gd::String>
+      mangledSceneNames;  ///< Memoized results of mangling
 };
 
 }  // namespace gd

Core/GDCore/IDE/WholeProjectRefactorer.cpp

@@ -470,7 +470,17 @@ void WholeProjectRefactorer::RenameBehaviorProperty(
   auto& properties = eventsBasedBehavior.GetPropertyDescriptors();
   if (!properties.Has(oldPropertyName)) return;
 
-  const auto& property = properties.Get(oldPropertyName);
+  // Order is important: we first rename the expressions then the instructions,
+  // to avoid being unable to fetch the metadata (the types of parameters) of
+  // instructions after they are renamed.
+  gd::ExpressionsRenamer expressionRenamer =
+      gd::ExpressionsRenamer(project.GetCurrentPlatform());
+  expressionRenamer.SetReplacedBehaviorExpression(
+      GetBehaviorFullType(eventsFunctionsExtension.GetName(),
+                          eventsBasedBehavior.GetName()),
+      EventsBasedBehavior::GetPropertyExpressionName(oldPropertyName),
+      EventsBasedBehavior::GetPropertyExpressionName(newPropertyName));
+  ExposeProjectEvents(project, expressionRenamer);
 
   gd::InstructionsTypeRenamer actionRenamer = gd::InstructionsTypeRenamer(
       project,
@@ -495,15 +505,6 @@ void WholeProjectRefactorer::RenameBehaviorProperty(
           eventsBasedBehavior.GetName(),
           EventsBasedBehavior::GetPropertyConditionName(newPropertyName)));
   ExposeProjectEvents(project, conditionRenamer);
-
-  gd::ExpressionsRenamer expressionRenamer =
-      gd::ExpressionsRenamer(project.GetCurrentPlatform());
-  expressionRenamer.SetReplacedBehaviorExpression(
-      GetBehaviorFullType(eventsFunctionsExtension.GetName(),
-                          eventsBasedBehavior.GetName()),
-      EventsBasedBehavior::GetPropertyExpressionName(oldPropertyName),
-      EventsBasedBehavior::GetPropertyExpressionName(newPropertyName));
-  ExposeProjectEvents(project, expressionRenamer);
 }
 
 void WholeProjectRefactorer::RenameEventsBasedBehavior(

Core/GDCore/IDE/WholeProjectRefactorer.h

@@ -50,7 +50,10 @@ class GD_CORE_API WholeProjectRefactorer {
                                   gd::ArbitraryEventsWorkerWithContext& worker);
 
   /**
-   * \brief Refactor the project after an events function extension is renamed
+   * \brief Refactor the project **before** an events function extension is renamed.
+   *
+   * \warning Do the renaming of the specified extension after calling this.
+   * This is because the extension is expected to have its old name for the refactoring.
    */
   static void RenameEventsFunctionsExtension(
       gd::Project& project,
@@ -59,7 +62,10 @@ class GD_CORE_API WholeProjectRefactorer {
       const gd::String& newName);
 
   /**
-   * \brief Refactor the project after an events function is renamed
+   * \brief Refactor the project **before** an events function is renamed.
+   *
+   * \warning Do the renaming of the specified function after calling this.
+   * This is because the function is expected to have its old name for the refactoring.
    */
   static void RenameEventsFunction(
       gd::Project& project,
@@ -68,8 +74,11 @@ class GD_CORE_API WholeProjectRefactorer {
       const gd::String& newFunctionName);
 
   /**
-   * \brief Refactor the project after an events function of a behavior is
+   * \brief Refactor the project **before** an events function of a behavior is
    * renamed.
+   *
+   * \warning Do the renaming of the specified function after calling this.
+   * This is because the function is expected to have its old name for the refactoring.
    */
   static void RenameBehaviorEventsFunction(
       gd::Project& project,
@@ -79,8 +88,11 @@ class GD_CORE_API WholeProjectRefactorer {
       const gd::String& newFunctionName);
 
   /**
-   * \brief Refactor the project after an events function parameter
-   * was moved.
+   * \brief Refactor the project **before** an events function parameter
+   * is moved.
+   *
+   * \warning Do the move of the specified function parameters after calling this.
+   * This is because the function is expected to be in its old state for the refactoring.
    */
   static void MoveEventsFunctionParameter(
       gd::Project& project,
@@ -90,8 +102,11 @@ class GD_CORE_API WholeProjectRefactorer {
       std::size_t newIndex);
 
   /**
-   * \brief Refactor the project after the parmaeter of an events function of a
-   * behavior was moved.
+   * \brief Refactor the project **before** the parameter of an events function of a
+   * behavior is moved.
+   *
+   * \warning Do the move of the specified function parameters after calling this.
+   * This is because the function is expected to be in its old state for the refactoring.
    */
   static void MoveBehaviorEventsFunctionParameter(
       gd::Project& project,
@@ -102,8 +117,11 @@ class GD_CORE_API WholeProjectRefactorer {
       std::size_t newIndex);
 
   /**
-   * \brief Refactor the project after a property of a behavior is
+   * \brief Refactor the project **before** a property of a behavior is
    * renamed.
+   *
+   * \warning Do the renaming of the specified property after calling this.
+   * This is because the property is expected to have its old name for the refactoring.
    */
   static void RenameBehaviorProperty(
       gd::Project& project,
@@ -113,7 +131,10 @@ class GD_CORE_API WholeProjectRefactorer {
       const gd::String& newPropertyName);
 
   /**
-   * \brief Refactor the project after a behavior is renamed.
+   * \brief Refactor the project **before** a behavior is renamed.
+   *
+   * \warning Do the renaming of the specified behavior after calling this.
+   * This is because the behavior is expected to have its old name for the refactoring.
    */
   static void RenameEventsBasedBehavior(
       gd::Project& project,
@@ -160,7 +181,7 @@ class GD_CORE_API WholeProjectRefactorer {
       bool isObjectGroup);
 
   /**
-   * \brief Refactor the events function after an object or group is renamed
+   * \brief Refactor the events function after an object or group is removed
    *
    * This will update the events of the function and groups.
    */

Core/GDCore/Project/Behavior.cpp

@@ -15,7 +15,7 @@ Behavior::~Behavior(){};
 
 #if defined(GD_IDE_ONLY)
 std::map<gd::String, gd::PropertyDescriptor> Behavior::GetProperties(
-    const gd::SerializerElement& behaviorContent, gd::Project& project) const {
+    const gd::SerializerElement& behaviorContent) const {
   std::map<gd::String, gd::PropertyDescriptor> nothing;
   return nothing;
 }

Core/GDCore/Project/Behavior.h

@@ -61,7 +61,7 @@ class GD_CORE_API Behavior {
    * \see gd::PropertyDescriptor
    */
   virtual std::map<gd::String, gd::PropertyDescriptor> GetProperties(
-      const gd::SerializerElement& behaviorContent, gd::Project& project) const;
+      const gd::SerializerElement& behaviorContent) const;
 
   /**
    * \brief Called when the IDE wants to update a custom property of the
@@ -72,8 +72,7 @@ class GD_CORE_API Behavior {
    */
   virtual bool UpdateProperty(gd::SerializerElement& behaviorContent,
                               const gd::String& name,
-                              const gd::String& value,
-                              gd::Project& project) {
+                              const gd::String& value) {
     return false;
   };
 #endif

Core/GDCore/Project/BehaviorsSharedData.cpp

@@ -16,7 +16,7 @@ BehaviorsSharedData::~BehaviorsSharedData(){};
 
 #if defined(GD_IDE_ONLY)
 std::map<gd::String, gd::PropertyDescriptor> BehaviorsSharedData::GetProperties(
-    const gd::SerializerElement& behaviorSharedDataContent, gd::Project& project) const {
+    const gd::SerializerElement& behaviorSharedDataContent) const {
   std::map<gd::String, gd::PropertyDescriptor> nothing;
   return nothing;
 }

Core/GDCore/Project/BehaviorsSharedData.h

@@ -64,8 +64,7 @@ class GD_CORE_API BehaviorsSharedData {
    * \see gd::PropertyDescriptor
    */
   virtual std::map<gd::String, gd::PropertyDescriptor> GetProperties(
-      const gd::SerializerElement& behaviorSharedDataContent,
-      gd::Project& project) const;
+      const gd::SerializerElement& behaviorSharedDataContent) const;
 
   /**
    * \brief Called when the IDE wants to update a property of the shared data
@@ -75,8 +74,7 @@ class GD_CORE_API BehaviorsSharedData {
    */
   virtual bool UpdateProperty(gd::SerializerElement& behaviorSharedDataContent,
                               const gd::String& name,
-                              const gd::String& value,
-                              gd::Project& project) {
+                              const gd::String& value) {
     return false;
   };
 #endif

Core/GDCore/Project/EventsFunctionsExtension.cpp

@@ -5,6 +5,7 @@
  */
 #if defined(GD_IDE_ONLY)
 #include "EventsFunctionsExtension.h"
+
 #include "EventsBasedBehavior.h"
 #include "EventsFunction.h"
 #include "GDCore/Serialization/SerializerElement.h"
@@ -35,6 +36,9 @@ void EventsFunctionsExtension::Init(const gd::EventsFunctionsExtension& other) {
   fullName = other.fullName;
   tags = other.tags;
   author = other.author;
+  previewIconUrl = other.previewIconUrl;
+  iconUrl = other.iconUrl;
+  helpPath = other.helpPath;
   EventsFunctionsContainer::Init(other);
   eventsBasedBehaviors = other.eventsBasedBehaviors;
 }
@@ -46,8 +50,15 @@ void EventsFunctionsExtension::SerializeTo(SerializerElement& element) const {
   element.SetAttribute("description", description);
   element.SetAttribute("name", name);
   element.SetAttribute("fullName", fullName);
-  element.SetAttribute("tags", tags);
+  auto& tagsElement = element.AddChild("tags");
+  tagsElement.ConsiderAsArray();
+  for (const auto& tag : tags) {
+    tagsElement.AddChild("").SetStringValue(tag);
+  }
   element.SetAttribute("author", author);
+  element.SetAttribute("previewIconUrl", previewIconUrl);
+  element.SetAttribute("iconUrl", iconUrl);
+  element.SetAttribute("helpPath", helpPath);
 
   SerializeEventsFunctionsTo(element.AddChild("eventsFunctions"));
   eventsBasedBehaviors.SerializeElementsTo(
@@ -62,14 +73,46 @@ void EventsFunctionsExtension::UnserializeFrom(
   description = element.GetStringAttribute("description");
   name = element.GetStringAttribute("name");
   fullName = element.GetStringAttribute("fullName");
-  tags = element.GetStringAttribute("tags");
   author = element.GetStringAttribute("author");
+  previewIconUrl = element.GetStringAttribute("previewIconUrl");
+  iconUrl = element.GetStringAttribute("iconUrl");
+  helpPath = element.GetStringAttribute("helpPath");
+
+  tags.clear();
+  auto& tagsElement = element.GetChild("tags");
+  if (!tagsElement.IsValueUndefined()) {
+    // Compatibility with GD <= 5.0.0-beta102
+    gd::String tagsAsString = tagsElement.GetStringValue();
+    tags = tagsAsString.Split(',');
+    for (auto& tag : tags) {
+      tag = tag.Trim();
+    }
+    // end of compatibility code
+  } else {
+    tagsElement.ConsiderAsArray();
+    for (std::size_t i = 0; i < tagsElement.GetChildrenCount(); ++i) {
+      tags.push_back(tagsElement.GetChild(i).GetStringValue());
+    }
+  }
 
   UnserializeEventsFunctionsFrom(project, element.GetChild("eventsFunctions"));
   eventsBasedBehaviors.UnserializeElementsFrom(
       "eventsBasedBehavior", project, element.GetChild("eventsBasedBehaviors"));
 }
 
+bool EventsFunctionsExtension::IsExtensionLifecycleEventsFunction(
+    const gd::String& eventsFunctionName) {
+  // The list of all supported lifecycle events function names.
+  // If adding a new one, code generator(s) must be updated.
+  return eventsFunctionName == "onFirstSceneLoaded" ||
+         eventsFunctionName == "onSceneLoaded" ||
+         eventsFunctionName == "onScenePreEvents" ||
+         eventsFunctionName == "onScenePostEvents" ||
+         eventsFunctionName == "onScenePaused" ||
+         eventsFunctionName == "onSceneResumed" ||
+         eventsFunctionName == "onSceneUnloading";
+}
+
 }  // namespace gd
 
 #endif

Core/GDCore/Project/EventsFunctionsExtension.h

@@ -8,8 +8,9 @@
 #define GDCORE_EVENTSFUNCTIONEXTENSION_H
 
 #include <vector>
-#include "GDCore/Project/EventsFunctionsContainer.h"
+
 #include "GDCore/Project/EventsBasedBehavior.h"
+#include "GDCore/Project/EventsFunctionsContainer.h"
 #include "GDCore/String.h"
 #include "GDCore/Tools/SerializableWithNameList.h"
 namespace gd {
@@ -59,7 +60,8 @@ class GD_CORE_API EventsFunctionsExtension : public EventsFunctionsContainer {
   }
 
   const gd::String& GetShortDescription() const { return shortDescription; };
-  EventsFunctionsExtension& SetShortDescription(const gd::String& shortDescription_) {
+  EventsFunctionsExtension& SetShortDescription(
+      const gd::String& shortDescription_) {
     shortDescription = shortDescription_;
     return *this;
   }
@@ -82,11 +84,8 @@ class GD_CORE_API EventsFunctionsExtension : public EventsFunctionsContainer {
     return *this;
   }
 
-  const gd::String& GetTags() const { return tags; };
-  EventsFunctionsExtension& SetTags(const gd::String& tags_) {
-    tags = tags_;
-    return *this;
-  }
+  const std::vector<gd::String>& GetTags() const { return tags; };
+  std::vector<gd::String>& GetTags() { return tags; };
 
   const gd::String& GetAuthor() const { return author; };
   EventsFunctionsExtension& SetAuthor(const gd::String& author_) {
@@ -94,18 +93,46 @@ class GD_CORE_API EventsFunctionsExtension : public EventsFunctionsContainer {
     return *this;
   }
 
+  const gd::String& GetPreviewIconUrl() const { return previewIconUrl; };
+  EventsFunctionsExtension& SetPreviewIconUrl(
+      const gd::String& previewIconUrl_) {
+    previewIconUrl = previewIconUrl_;
+    return *this;
+  }
+
+  const gd::String& GetIconUrl() const { return iconUrl; };
+  EventsFunctionsExtension& SetIconUrl(const gd::String& iconUrl_) {
+    iconUrl = iconUrl_;
+    return *this;
+  }
+
+  /**
+   * \brief Get the help path of this extension, relative to the GDevelop
+   * documentation root.
+   */
+  const gd::String& GetHelpPath() const { return helpPath; };
+
+  /**
+   * \brief Set the help path of this extension, relative to the GDevelop
+   * documentation root.
+   */
+  EventsFunctionsExtension& SetHelpPath(const gd::String& helpPath_) {
+    helpPath = helpPath_;
+    return *this;
+  }
+
   /**
    * \brief Return a reference to the list of the events based behaviors.
    */
-  SerializableWithNameList<EventsBasedBehavior>& GetEventsBasedBehaviors() {
+  gd::SerializableWithNameList<EventsBasedBehavior>& GetEventsBasedBehaviors() {
     return eventsBasedBehaviors;
   }
 
   /**
    * \brief Return a const reference to the list of the events based behaviors.
    */
-  const SerializableWithNameList<EventsBasedBehavior>& GetEventsBasedBehaviors()
-      const {
+  const gd::SerializableWithNameList<EventsBasedBehavior>&
+  GetEventsBasedBehaviors() const {
     return eventsBasedBehaviors;
   }
 
@@ -124,6 +151,13 @@ class GD_CORE_API EventsFunctionsExtension : public EventsFunctionsContainer {
                        const gd::SerializerElement& element);
   ///@}
 
+  /** \name Lifecycle event functions
+   */
+  ///@{
+  static bool IsExtensionLifecycleEventsFunction(
+      const gd::String& eventsFunctionName);
+  ///@}
+
  private:
   /**
    * Initialize object using another object. Used by copy-ctor and assign-op.
@@ -137,9 +171,13 @@ class GD_CORE_API EventsFunctionsExtension : public EventsFunctionsContainer {
   gd::String description;
   gd::String name;
   gd::String fullName;
-  gd::String tags;
+  std::vector<gd::String> tags;
   gd::String author;
-  SerializableWithNameList<EventsBasedBehavior> eventsBasedBehaviors;
+  gd::String previewIconUrl;
+  gd::String iconUrl;
+  gd::String helpPath;  ///< The relative path to the help for this extension in
+                        ///< the documentation (or an absolute URL).
+  gd::SerializableWithNameList<EventsBasedBehavior> eventsBasedBehaviors;
 };
 
 }  // namespace gd

Core/GDCore/Project/ExtensionProperties.cpp

@@ -0,0 +1,56 @@
+#include "ExtensionProperties.h"
+#include "GDCore/Extensions/Platform.h"
+#include "GDCore/Extensions/PlatformExtension.h"
+#include "GDCore/Project/Project.h"
+#include "GDCore/Project/PropertyDescriptor.h"
+
+namespace gd {
+const gd::String ExtensionProperties::defaultValue = "";
+
+std::map<gd::String, gd::PropertyDescriptor>
+ExtensionProperties::GetAllExtensionProperties(const gd::String& extensionName,
+                                               gd::Project& project) {
+  // Create a copy
+  std::map<gd::String, gd::PropertyDescriptor> props(
+      project.GetCurrentPlatform()
+          .GetExtension(extensionName)
+          ->GetAllProperties());
+  // Set values
+  for (std::pair<gd::String, gd::PropertyDescriptor> property : props) {
+    if (properties.count(extensionName) > 0 &&
+        properties[extensionName].count(property.first) > 0) {
+      props[property.first].SetValue(properties[extensionName][property.first]);
+    }
+  }
+  return props;
+};
+
+void ExtensionProperties::SerializeTo(SerializerElement& element) const {
+  element.ConsiderAsArrayOf("extensionProperties");
+  for (const std::pair<gd::String, std::map<gd::String, gd::String>> extension :
+       properties) {
+    for (const std::pair<gd::String, gd::String> property : extension.second) {
+      SerializerElement& propertyElement =
+          element.AddChild("extensionProperties");
+      propertyElement.AddChild("extension").SetStringValue(extension.first);
+      propertyElement.AddChild("property").SetStringValue(property.first);
+      propertyElement.AddChild("value").SetStringValue(property.second);
+    }
+  }
+};
+
+void ExtensionProperties::UnserializeFrom(const SerializerElement& element) {
+  properties.clear();
+  element.ConsiderAsArrayOf("extensionProperties");
+  for (std::pair<const gd::String, std::shared_ptr<SerializerElement>>
+           extensionProperties : element.GetAllChildren()) {
+    std::shared_ptr<SerializerElement> extensionPropertiesElement =
+        extensionProperties.second;
+    properties
+        [extensionPropertiesElement->GetChild("extension").GetStringValue()]
+        [extensionPropertiesElement->GetChild("property").GetStringValue()] =
+            extensionPropertiesElement->GetChild("value").GetStringValue();
+  }
+};
+
+};  // namespace gd

Core/GDCore/Project/ExtensionProperties.h

@@ -0,0 +1,69 @@
+/*
+ * GDevelop Core
+ * Copyright 2008-2016 Florian Rival (Florian.Rival@gmail.com). All rights
+ * reserved. This project is released under the MIT License.
+ */
+#ifndef GDCORE_EXTENSIONPROPERTIES_H
+#define GDCORE_EXTENSIONPROPERTIES_H
+#include <map>
+
+#include "GDCore/Serialization/SerializerElement.h"
+#include "GDCore/String.h"
+
+namespace gd {
+class Project;
+class PropertyDescriptor;
+}  // namespace gd
+
+namespace gd {
+class GD_CORE_API ExtensionProperties {
+  static const gd::String defaultValue;
+
+ public:
+  const gd::String& GetValue(const gd::String& extension,
+                             const gd::String& property) const {
+    if (properties.count(extension) == 0 ||
+        properties.at(extension).count(property) == 0) {
+      return ExtensionProperties::defaultValue;
+    }
+    return properties.at(extension).at(property);
+  };
+
+  void SetValue(const gd::String& extension,
+                const gd::String& property,
+                const gd::String& newValue) {
+    properties[extension][property] = newValue;
+  };
+
+  bool HasProperty(const gd::String& extension, const gd::String& property) {
+    for (std::pair<gd::String, gd::String> propertyPair :
+         properties[extension]) {
+      if (propertyPair.first == property) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  std::map<gd::String, gd::PropertyDescriptor> GetAllExtensionProperties(
+      const gd::String& extensionName, gd::Project& project);
+
+  ///@{
+  /**
+   * \brief Serialize the Extension Properties.
+   */
+  virtual void SerializeTo(SerializerElement& element) const;
+
+  /**
+   * \brief Unserialize the Extension Properties.
+   */
+  virtual void UnserializeFrom(const SerializerElement& element);
+  ///@}
+
+ private:
+  std::map<gd::String, std::map<gd::String, gd::String>>
+      properties;  ///< The properties of the project
+};
+}  // namespace gd
+
+#endif  // EXTENSIONPROPERTIES_H

Core/GDCore/Project/InitialInstance.cpp

@@ -5,10 +5,12 @@
  */
 
 #include "GDCore/Project/InitialInstance.h"
+
 #include "GDCore/Project/Layout.h"
 #include "GDCore/Project/Object.h"
 #include "GDCore/Project/Project.h"
 #include "GDCore/Serialization/SerializerElement.h"
+#include "GDCore/Tools/UUID/UUID.h"
 #if defined(GD_IDE_ONLY)
 #include "GDCore/Project/PropertyDescriptor.h"
 #endif
@@ -27,7 +29,8 @@ InitialInstance::InitialInstance()
       personalizedSize(false),
       width(0),
       height(0),
-      locked(false) {}
+      locked(false),
+      persistentUuid(UUID::MakeUuid4()) {}
 
 void InitialInstance::UnserializeFrom(const SerializerElement& element) {
   SetObjectName(element.GetStringAttribute("name", "", "nom"));
@@ -42,6 +45,9 @@ void InitialInstance::UnserializeFrom(const SerializerElement& element) {
   SetLayer(element.GetStringAttribute("layer"));
   SetLocked(element.GetBoolAttribute("locked", false));
 
+  persistentUuid = element.GetStringAttribute("persistentUuid");
+  if (persistentUuid.empty()) ResetPersistentUuid();
+
   floatInfos.clear();
   const SerializerElement& floatPropElement =
       element.GetChild("numberProperties", 0, "floatInfos");
@@ -79,6 +85,9 @@ void InitialInstance::SerializeTo(SerializerElement& element) const {
   element.SetAttribute("height", GetCustomHeight());
   element.SetAttribute("locked", IsLocked());
 
+  if (persistentUuid.empty()) persistentUuid = UUID::MakeUuid4();
+  element.SetStringAttribute("persistentUuid", persistentUuid);
+
   SerializerElement& floatPropElement = element.AddChild("numberProperties");
   floatPropElement.ConsiderAsArrayOf("property");
   for (std::map<gd::String, float>::const_iterator floatInfo =
@@ -104,6 +113,11 @@ void InitialInstance::SerializeTo(SerializerElement& element) const {
   GetVariables().SerializeTo(element.AddChild("initialVariables"));
 }
 
+InitialInstance& InitialInstance::ResetPersistentUuid() {
+  persistentUuid = UUID::MakeUuid4();
+  return *this;
+}
+
 #if defined(GD_IDE_ONLY)
 std::map<gd::String, gd::PropertyDescriptor>
 InitialInstance::GetCustomProperties(gd::Project& project, gd::Layout& layout) {
@@ -146,13 +160,12 @@ const gd::String& InitialInstance::GetRawStringProperty(
   return it != stringInfos.end() ? it->second : *badStringProperyValue;
 }
 
-void InitialInstance::SetRawFloatProperty(const gd::String& name, float value)
-{
+void InitialInstance::SetRawFloatProperty(const gd::String& name, float value) {
   floatInfos[name] = value;
 }
 
-void InitialInstance::SetRawStringProperty(const gd::String& name, const gd::String& value)
-{
+void InitialInstance::SetRawStringProperty(const gd::String& name,
+                                           const gd::String& value) {
   stringInfos[name] = value;
 }
 #endif

Core/GDCore/Project/InitialInstance.h

@@ -200,7 +200,7 @@ class GD_CORE_API InitialInstance {
   /**
    * \brief Get the value of a float property stored in the instance.
    * \note Only use this when \a GetCustomProperties is too slow (when rendering
-   * instances for example). 
+   * instances for example).
    * \return the value of the property, or 0 if it does
    * not exists.
    */
@@ -209,7 +209,7 @@ class GD_CORE_API InitialInstance {
   /**
    * \brief Get the value of a string property stored in the instance.
    * \note Only use this when \a GetCustomProperties is too slow (when rendering
-   * instances for example). 
+   * instances for example).
    * \return the value of the propety, or an empty
    * string if it does not exists.
    */
@@ -240,6 +240,12 @@ class GD_CORE_API InitialInstance {
    * \brief Unserialize the instances container.
    */
   virtual void UnserializeFrom(const SerializerElement& element);
+
+  /**
+   * \brief Reset the persistent UUID used to recognize
+   * the same initial instance between serialization.
+   */
+  InitialInstance& ResetPersistentUuid();
   ///@}
 
   // More properties can be stored in floatInfos and stringInfos.
@@ -260,6 +266,7 @@ class GD_CORE_API InitialInstance {
   float height;           ///< Object custom height
   gd::VariablesContainer initialVariables;  ///< Instance specific variables
   bool locked;                              ///< True if the instance is locked
+  mutable gd::String persistentUuid; ///< A persistent random version 4 UUID, useful for hot reloading.
 
   static gd::String*
       badStringProperyValue;  ///< Empty string returned by GetRawStringProperty

Core/GDCore/Project/InitialInstancesContainer.cpp

@@ -179,6 +179,8 @@ InitialInstanceFunctor::~InitialInstanceFunctor(){};
 
 void HighestZOrderFinder::operator()(gd::InitialInstance& instance) {
   if (!layerRestricted || instance.GetLayer() == layerName) {
+    instancesCount++;
+
     if (firstCall) {
       highestZOrder = instance.GetZOrder();
       lowestZOrder = instance.GetZOrder();