Merge game management button into one

* Also ensure the leaderboard "loaded" state is reset back to false when closed.

.circleci/config.yml

@@ -2,17 +2,10 @@
 # on the Electron runtime (newIDE/electron-app) for macOS and Linux.
 # For Windows, see the appveyor.yml file.
 
-# This also builds GDevelop.js and store it on a S3 so it can be used to run
-# GDevelop without building it from scratch.
-
-# Note that these CircleCI builds/tests are not launched on Pull Requests from forks,
-# to avoid sharing secrets.
-
 version: 2.1
 orbs:
   aws-cli: circleci/aws-cli@2.0.6
 jobs:
-  # Build the **entire** app for macOS.
   build-macos:
     macos:
       xcode: 12.5.1
@@ -64,7 +57,7 @@ jobs:
       # Note: Code signing is done using CSC_LINK (see https://www.electron.build/code-signing).
       - run:
           name: Build GDevelop IDE
-          command: export CSC_FOR_PULL_REQUEST=true && export NODE_OPTIONS="--max-old-space-size=7168" && cd newIDE/electron-app && npm run build -- --mac --publish=never
+          command: export NODE_OPTIONS="--max-old-space-size=7168" && cd newIDE/electron-app && npm run build -- --mac --publish=never
 
       - run:
           name: Clean dist folder to keep only installers/binaries.
@@ -82,7 +75,6 @@ jobs:
           name: Deploy to S3 (latest)
           command: export PATH=~/.local/bin:$PATH && aws s3 sync newIDE/electron-app/dist s3://gdevelop-releases/$(git rev-parse --abbrev-ref HEAD)/latest/
 
-  # Build the **entire** app for Linux.
   build-linux:
     # CircleCI docker workers are failing if they don't have enough memory (no swap)
     resource_class: xlarge
@@ -101,8 +93,8 @@ jobs:
           command: sudo apt-get update && sudo apt install cmake
 
       - run:
-          name: Install Python3 dependencies for Emscripten
-          command: sudo apt install python-is-python3 python3-distutils -y
+         name: Install Python3 dependencies for Emscripten
+         command: sudo apt install python-is-python3 python3-distutils -y
 
       - run:
           name: Install Emscripten (for GDevelop.js)
@@ -161,67 +153,10 @@ jobs:
           name: Deploy to S3 (latest)
           command: aws s3 sync newIDE/electron-app/dist s3://gdevelop-releases/$(git rev-parse --abbrev-ref HEAD)/latest/
 
-  # Build the WebAssembly library only (so that it's cached on a S3 and easy to re-use).
-  build-gdevelop_js-wasm-only:
-    docker:
-      - image: cimg/node:16.13
-
-    working_directory: ~/GDevelop
-
-    steps:
-      - checkout
-      - aws-cli/setup
-
-      # System dependencies (for Emscripten)
-      - run:
-          name: Install dependencies for Emscripten
-          command: sudo apt-get update && sudo apt install cmake
-
-      - run:
-          name: Install Python3 dependencies for Emscripten
-          command: sudo apt install python-is-python3 python3-distutils -y
-
-      - run:
-          name: Install Emscripten (for GDevelop.js)
-          command: git clone https://github.com/juj/emsdk.git && cd emsdk && ./emsdk install 1.39.6 && ./emsdk activate 1.39.6 && cd ..
-
-      # GDevelop.js dependencies
-      - restore_cache:
-          keys:
-            - gdevelop.js-linux-nodejs-dependencies-{{ checksum "GDevelop.js/package-lock.json" }}
-            # fallback to using the latest cache if no exact match is found
-            - gdevelop.js-linux-nodejs-dependencies-
-
-      - run:
-          name: Install GDevelop.js dependencies and build it
-          command: cd GDevelop.js && npm install && cd ..
-
-      # Build GDevelop.js (and run tests to ensure it works)
-      - run:
-          name: Build GDevelop.js
-          command: cd GDevelop.js && source ../emsdk/emsdk_env.sh && npm run build && npm test && cd ..
-
-      - save_cache:
-          paths:
-            - GDevelop.js/node_modules
-          key: gdevelop.js-linux-nodejs-dependencies-{{ checksum "GDevelop.js/package-lock.json" }}
-
-      # Upload artifacts (CircleCI)
-      - store_artifacts:
-          path: Binaries/embuild/GDevelop.js
-
-      # Upload artifacts (AWS)
-      - run:
-          name: Deploy to S3 (specific commit)
-          command: aws s3 sync Binaries/embuild/GDevelop.js s3://gdevelop-gdevelop.js/$(git rev-parse --abbrev-ref HEAD)/commit/$(git rev-parse HEAD)/
-      - run:
-          name: Deploy to S3 (latest)
-          command: aws s3 sync Binaries/embuild/GDevelop.js s3://gdevelop-gdevelop.js/$(git rev-parse --abbrev-ref HEAD)/latest/
 
 workflows:
   builds:
     jobs:
-      - build-gdevelop_js-wasm-only
       - build-macos:
           filters:
             branches:

.github/ISSUE_TEMPLATE/--feature-request.md

@@ -10,11 +10,11 @@ assignees: ''
 
 BEFORE opening a new feature request, please make sure that you:
 
--   Understand the implications of your feature with the help of [the Forum](https://forum.gdevelop.io/c/gdevelop-general/feature-requests/35), OR
--   Peer-reviewed it with other users on Discord,
--   Consider commenting on the [Feature Request Forum](https://forum.gdevelop.io/c/gdevelop-general/feature-requests/35) if something is important for you
+-   Discussed it on the discord or the forum,
+-   There is not already a suggestion about it in the issues or in the roadmap: https://trello.com/b/qf0lM7k8/gdevelop-roadmap
+-   Consider commenting on the roadmap if something is important for you
 
-AFTER opening the feature request, the issue will be closed by a maintainer (@4ian or someone else) and a card will be added in [the public roadmap](https://trello.com/b/qf0lM7k8/gdevelop-ideas-box) if it's relevant and does not exist yet :)
+AFTER opening the feature request, the issue will be closed by a maintainer (@4ian or someone else) and a card will be added in the roadmap if it's relevant and does not exist yet :)
 
 ## Description
 

.github/ISSUE_TEMPLATE/config.yml

@@ -4,14 +4,14 @@ contact_links:
     url: https://discord.gg/rjdYHvj
     about: Discuss on the forum or on the Discord to get help creating a game or identifying a bug.
   - name: GDevelop Forums
-    url: https://forum.gdevelop.io
+    url: https://forum.gdevelop-app.com
     about: You can also discuss game creation, new feature requests and bugs on the forum.
   - name: GDevelop Roadmap
     url: https://trello.com/b/qf0lM7k8/gdevelop-roadmap
     about: Look at the roadmap and vote on features that you want to see in GDevelop.
   - name: Submit a new game example that you created
     url: https://github.com/GDevelopApp/GDevelop-examples/issues/new/choose
-    about: You can submit a game that you made to be added to examples in the "GDevelop-examples" repository
+    about: You can submit a game that you made to be added to examples in the "GDevelop-examples" repository 
   - name: Submit a new game extension that you created
     url: https://github.com/4ian/GDevelop-extensions/issues/new/choose
-    about: You can submit an extension that you made in the "GDevelop-extensions" repository
+    about: You can submit an extension that you made in the "GDevelop-extensions" repository 

.github/workflows/issues.yml

@@ -12,7 +12,7 @@ jobs:
         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.io/), the Discord chat or [read the documentation](https://wiki.gdevelop.io/gdevelop5/start) to learn more about GDevelop. Thanks!"
+        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!"
     - name: Autoclose known beta 105 web-app update bug
       uses: arkon/issue-closer-action@v1.1
       with:

.gitignore

@@ -8,7 +8,6 @@
 /Binaries/.embuild*
 /Binaries/build*
 /Binaries/embuild*
-/emsdk
 *.dll
 *.exe
 *.a

.gitpod.yml

@@ -1,25 +0,0 @@
-# This is a configuration file allowing to quickly set up a development environment
-# on GitPod (https://www.gitpod.io/).
-# Also check GitHub codespaces if you're interested in working 
-# on a remote development server.
-
-# This works well for:
-# - The editor web-app, including the C++ classes.
-# This is not yet adapted for:
-# - Working on the game engine or extensions, as they can't be easily tested on the web-app.
-# - Working on the desktop app (Electron).
-
-tasks:
-  - name: Install dependencies for Emscripten and build GDevelop.js
-    init: |
-          sudo apt-get update 
-          sudo apt install cmake python-is-python3 python3-distutils -y
-          git clone https://github.com/juj/emsdk.git && cd emsdk && ./emsdk install 1.39.6 && ./emsdk activate 1.39.6 && cd ..
-          cd GDevelop.js
-          npm install
-          source ../emsdk/emsdk_env.sh && npm run build -- --dev
-          cd ..
-  - name: Install GDevelop IDE dependencies
-    init: cd newIDE/app && npm install && cd ../electron-app && npm install
-
-

.travis.yml

@@ -1,6 +1,9 @@
 # Travis CI configuration to build and run all tests
 # (and typing/formatting) for the Core, newIDE, GDJS.
 #
+# This builds GDevelop.js and store it on a S3 so it can be used to run
+# GDevelop without building it.
+#
 # See also Semaphore CI for quick tests (not building GDevelop.js, so
 # faster but not always reliable).
 
@@ -14,7 +17,18 @@ cache:
   directories:
     - $HOME/.npm
 
+services:
+  # Virtual Framebuffer 'fake' X server for SFML
+  - xvfb
+
 addons:
+  artifacts:
+    s3_region: "us-east-1"
+    target_paths:
+    - /$(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/embuild/GDevelop.js
   apt:
     sources:
     - ubuntu-toolchain-r-test
@@ -22,8 +36,20 @@ addons:
     # Build dependencies:
     - cmake
     - p7zip-full
+    # SFML dependencies:
+    - libopenal-dev
+    - libjpeg-dev
+    - libglew-dev
+    - libudev-dev
+    - libxrandr-dev
+    - libsndfile1-dev
+    - libglu1-mesa-dev
+    - libfreetype6-dev
 
 before_install:
+  #Activate X Virtual Framebuffer to allow tests to
+  #use SFML.
+  - "export DISPLAY=:99.0"
   # This workaround is required to avoid libstdc++ errors (Emscripten requires a recent version of libstdc++)
   - wget -q -O libstdc++6 http://security.ubuntu.com/ubuntu/pool/main/g/gcc-5/libstdc++6_5.4.0-6ubuntu1~16.04.12_amd64.deb
   - sudo dpkg --force-all -i libstdc++6

.vscode/c_cpp_properties.json

@@ -7,9 +7,11 @@
                 "${workspaceRoot}/GDJS",
                 "${workspaceRoot}/Extensions",
                 "${workspaceRoot}/Core",
+                "${workspaceRoot}/ExtLibs/SFML/include",
                 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include/c++/v1",
                 "/usr/local/include",
                 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include",
+                "/usr/include",
                 "${workspaceRoot}"
             ],
             "defines": [
@@ -25,6 +27,7 @@
                     "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include/c++/v1",
                     "/usr/local/include",
                     "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include",
+                    "/usr/include",
                     "${workspaceRoot}"
                 ],
                 "limitSymbolsToIncludedHeaders": true,
@@ -45,6 +48,7 @@
                 "${workspaceRoot}/GDJS",
                 "${workspaceRoot}/Extensions",
                 "${workspaceRoot}/Core",
+                "${workspaceRoot}/ExtLibs/SFML/include",
                 "/usr/include",
                 "/usr/local/include",
                 "${workspaceRoot}"
@@ -74,6 +78,7 @@
                 "${workspaceRoot}/GDJS",
                 "${workspaceRoot}/Extensions",
                 "${workspaceRoot}/Core",
+                "${workspaceRoot}/ExtLibs/SFML/include",
                 "${workspaceRoot}"
             ],
             "defines": [
@@ -96,4 +101,4 @@
         }
     ],
     "version": 4
-}
+}

.vscode/launch.json

@@ -15,20 +15,6 @@
       "disableOptimisticBPs": true,
       "cwd": "${workspaceFolder}/GDevelop.js"
     },
-    {
-      "type": "node",
-      "request": "launch",
-      "name": "newIDE/app Jest tests (current file)",
-      "program": "${workspaceFolder}/newIDE/app/node_modules/.bin/react-scripts",
-      "args": [
-        "test", "--env=node",
-        "${fileBasenameNoExtension}"
-      ],
-      "console": "integratedTerminal",
-      "internalConsoleOptions": "neverOpen",
-      "disableOptimisticBPs": true,
-      "cwd": "${workspaceFolder}/newIDE/app"
-    },
     {
       "type": "node",
       "request": "launch",

.vscode/settings.json

@@ -115,6 +115,7 @@
     "files.exclude": {
         "Binaries/*build*": true,
         "Binaries/Output": true,
+        "ExtLibs/SFML": true,
         "GDJS/Runtime-dist": true,
         "docs": true,
         "newIDE/electron-app/dist": true,

CMakeLists.txt

@@ -17,7 +17,7 @@ endmacro()
 gd_set_option(BUILD_CORE TRUE BOOL "TRUE to build GDevelop Core library")
 gd_set_option(BUILD_GDJS TRUE BOOL "TRUE to build GDevelop JS Platform")
 gd_set_option(BUILD_EXTENSIONS TRUE BOOL "TRUE to build the extensions")
-gd_set_option(BUILD_TESTS TRUE BOOL "TRUE to build the tests")
+gd_set_option(BUILD_TESTS FALSE BOOL "TRUE to build the tests")
 
 # Disable deprecated code
 set(NO_GUI TRUE CACHE BOOL "" FORCE) #Force disable old GUI related code.

Core/CMakeLists.txt

@@ -14,6 +14,7 @@ set(GDCORE_lib_dir ${GD_base_dir}/Binaries/Output/${CMAKE_BUILD_TYPE}_${CMAKE_SY
 
 #Dependencies on external libraries:
 ###
+include_directories(${sfml_include_dir})
 
 #Defines
 ###
@@ -67,6 +68,14 @@ set(LIBRARY_OUTPUT_PATH ${GD_base_dir}/Binaries/Output/${CMAKE_BUILD_TYPE}_${CMA
 set(ARCHIVE_OUTPUT_PATH ${GD_base_dir}/Binaries/Output/${CMAKE_BUILD_TYPE}_${CMAKE_SYSTEM_NAME})
 set(RUNTIME_OUTPUT_PATH ${GD_base_dir}/Binaries/Output/${CMAKE_BUILD_TYPE}_${CMAKE_SYSTEM_NAME})
 
+#Linker files
+###
+IF(EMSCRIPTEN)
+	#Nothing.
+ELSE()
+	target_link_libraries(GDCore ${sfml_LIBRARIES})
+ENDIF()
+
 #Tests
 ###
 if(BUILD_TESTS)
@@ -79,5 +88,5 @@ if(BUILD_TESTS)
 	add_executable(GDCore_tests ${test_source_files})
 	set_target_properties(GDCore_tests PROPERTIES BUILD_WITH_INSTALL_RPATH FALSE) #Allow finding dependencies directly from build path on Mac OS X.
 	target_link_libraries(GDCore_tests GDCore)
-	target_link_libraries(GDCore_tests ${CMAKE_DL_LIBS})
+	target_link_libraries(GDCore_tests ${sfml_LIBRARIES})
 endif()

Core/GDCore/CommonTools.h

@@ -13,6 +13,7 @@
 #include <string>
 #include <vector>
 #include "Utf8/utf8.h"
+#include <SFML/System/String.hpp>
 
 #ifdef __GNUC__
     #define GD_DEPRECATED    __attribute__((deprecated))

Core/GDCore/Events/Builtin/AsyncEvent.cpp

@@ -1,36 +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 "AsyncEvent.h"
-#include "GDCore/CommonTools.h"
-#include "GDCore/Events/CodeGeneration/EventsCodeGenerationContext.h"
-#include "GDCore/Events/CodeGeneration/EventsCodeGenerator.h"
-#include "GDCore/Events/Serialization.h"
-#include "GDCore/Serialization/SerializerElement.h"
-
-using namespace std;
-
-namespace gd {
-
-AsyncEvent::AsyncEvent() : BaseEvent() {}
-
-AsyncEvent::~AsyncEvent(){};
-
-vector<const gd::InstructionsList *> AsyncEvent::GetAllActionsVectors() const {
-  vector<const gd::InstructionsList *> allActions;
-  allActions.push_back(&actions);
-
-  return allActions;
-}
-
-vector<gd::InstructionsList *> AsyncEvent::GetAllActionsVectors() {
-  vector<gd::InstructionsList *> allActions;
-  allActions.push_back(&actions);
-
-  return allActions;
-}
-
-} // namespace gd

Core/GDCore/Events/Builtin/AsyncEvent.h

@@ -1,61 +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_ASYNCEVENT_H
-#define GDCORE_ASYNCEVENT_H
-#include "GDCore/Events/Event.h"
-#include "GDCore/Events/EventsList.h"
-#include "GDCore/Events/Instruction.h"
-#include "GDCore/Events/InstructionsList.h"
-namespace gd {
-class Instruction;
-class Project;
-} // namespace gd
-
-namespace gd {
-
-/**
- * \brief Internal event for asynchronous actions.
- * This event gets added internally to the events tree when an
- * asynchronous action is used.
- */
-class GD_CORE_API AsyncEvent : public gd::BaseEvent {
-public:
-  AsyncEvent();
-  AsyncEvent(const gd::Instruction &asyncAction_,
-             const gd::InstructionsList &actions_,
-             const gd::EventsList &subEvents_)
-      : asyncAction(asyncAction_), actions(actions_), subEvents(subEvents_) {
-    SetType("BuiltinAsync::Async");
-  };
-  virtual ~AsyncEvent();
-  virtual gd::AsyncEvent *Clone() const { return new AsyncEvent(*this); }
-
-  virtual bool IsExecutable() const { return true; }
-
-  virtual bool CanHaveSubEvents() const { return true; }
-  virtual const gd::EventsList &GetSubEvents() const { return subEvents; };
-  virtual gd::EventsList &GetSubEvents() { return subEvents; };
-
-  const gd::InstructionsList &GetActions() const { return actions; };
-  gd::InstructionsList &GetActions() { return actions; };
-
-  const gd::Instruction &GetInstruction() const { return asyncAction; };
-  gd::Instruction &GetInstruction() { return asyncAction; };
-
-  virtual std::vector<const gd::InstructionsList *>
-  GetAllActionsVectors() const;
-  virtual std::vector<gd::InstructionsList *> GetAllActionsVectors();
-
-private:
-  gd::Instruction asyncAction;
-  gd::InstructionsList actions;
-  EventsList subEvents;
-};
-
-} // namespace gd
-
-#endif // GDCORE_STANDARDEVENT_H

Core/GDCore/Events/Builtin/CommentEvent.cpp

@@ -23,9 +23,8 @@ vector<gd::String> CommentEvent::GetAllSearchableStrings() const {
 
 bool CommentEvent::ReplaceAllSearchableStrings(
     std::vector<gd::String> newSearchableString) {
-  if (newSearchableString[0] == com1) return false;
   SetComment(newSearchableString[0]);
-  return true;
+  return newSearchableString[0] == com1;
 }
 
 void CommentEvent::SerializeTo(SerializerElement &element) const {

Core/GDCore/Events/Builtin/ForEachChildVariableEvent.cpp

@@ -53,10 +53,8 @@ void ForEachChildVariableEvent::SerializeTo(SerializerElement& element) const {
       conditions, element.AddChild("conditions"));
   gd::EventsListSerialization::SerializeInstructionsTo(
       actions, element.AddChild("actions"));
-
-  if (!events.IsEmpty())
-    gd::EventsListSerialization::SerializeEventsTo(events,
-                                                  element.AddChild("events"));
+  gd::EventsListSerialization::SerializeEventsTo(events,
+                                                 element.AddChild("events"));
 }
 
 void ForEachChildVariableEvent::UnserializeFrom(gd::Project& project,
@@ -68,12 +66,8 @@ void ForEachChildVariableEvent::UnserializeFrom(gd::Project& project,
       project, conditions, element.GetChild("conditions", 0, "Conditions"));
   gd::EventsListSerialization::UnserializeInstructionsFrom(
       project, actions, element.GetChild("actions", 0, "Actions"));
-
-  events.Clear();
-  if (element.HasChild("events", "Events")) {
-    gd::EventsListSerialization::UnserializeEventsFrom(
-        project, events, element.GetChild("events", 0, "Events"));
-  }
+  gd::EventsListSerialization::UnserializeEventsFrom(
+      project, events, element.GetChild("events", 0, "Events"));
 }
 
 }  // namespace gd

Core/GDCore/Events/Builtin/ForEachEvent.cpp

@@ -74,10 +74,8 @@ void ForEachEvent::SerializeTo(SerializerElement& element) const {
       conditions, element.AddChild("conditions"));
   gd::EventsListSerialization::SerializeInstructionsTo(
       actions, element.AddChild("actions"));
-
-  if (!events.IsEmpty())
-    gd::EventsListSerialization::SerializeEventsTo(events,
-                                                  element.AddChild("events"));
+  gd::EventsListSerialization::SerializeEventsTo(events,
+                                                 element.AddChild("events"));
 }
 
 void ForEachEvent::UnserializeFrom(gd::Project& project,
@@ -88,12 +86,8 @@ void ForEachEvent::UnserializeFrom(gd::Project& project,
       project, conditions, element.GetChild("conditions", 0, "Conditions"));
   gd::EventsListSerialization::UnserializeInstructionsFrom(
       project, actions, element.GetChild("actions", 0, "Actions"));
-
-  events.Clear();
-  if (element.HasChild("events", "Events")) {
-    gd::EventsListSerialization::UnserializeEventsFrom(
-        project, events, element.GetChild("events", 0, "Events"));
-  }
+  gd::EventsListSerialization::UnserializeEventsFrom(
+      project, events, element.GetChild("events", 0, "Events"));
 }
 
 }  // namespace gd

Core/GDCore/Events/Builtin/GroupEvent.cpp

@@ -29,9 +29,8 @@ vector<gd::String> GroupEvent::GetAllSearchableStrings() const {
 
 bool GroupEvent::ReplaceAllSearchableStrings(
     std::vector<gd::String> newSearchableString) {
-  if (newSearchableString[0] == name) return false;
   SetName(newSearchableString[0]);
-  return true;
+  return newSearchableString[0] == name;
 }
 
 void GroupEvent::SerializeTo(SerializerElement& element) const {

Core/GDCore/Events/Builtin/RepeatEvent.cpp

@@ -75,10 +75,8 @@ void RepeatEvent::SerializeTo(SerializerElement& element) const {
       conditions, element.AddChild("conditions"));
   gd::EventsListSerialization::SerializeInstructionsTo(
       actions, element.AddChild("actions"));
-
-  if (!events.IsEmpty())
-    gd::EventsListSerialization::SerializeEventsTo(events,
-                                                  element.AddChild("events"));
+  gd::EventsListSerialization::SerializeEventsTo(events,
+                                                 element.AddChild("events"));
 }
 
 void RepeatEvent::UnserializeFrom(gd::Project& project,
@@ -91,12 +89,8 @@ void RepeatEvent::UnserializeFrom(gd::Project& project,
       project, conditions, element.GetChild("conditions", 0, "Conditions"));
   gd::EventsListSerialization::UnserializeInstructionsFrom(
       project, actions, element.GetChild("actions", 0, "Actions"));
-
-  events.Clear();
-  if (element.HasChild("events", "Events")) {
-    gd::EventsListSerialization::UnserializeEventsFrom(
-        project, events, element.GetChild("events", 0, "Events"));
-  }
+  gd::EventsListSerialization::UnserializeEventsFrom(
+      project, events, element.GetChild("events", 0, "Events"));
 }
 
 }  // namespace gd

Core/GDCore/Events/Builtin/StandardEvent.cpp

@@ -53,10 +53,8 @@ void StandardEvent::SerializeTo(SerializerElement& element) const {
       conditions, element.AddChild("conditions"));
   gd::EventsListSerialization::SerializeInstructionsTo(
       actions, element.AddChild("actions"));
-
-  if (!events.IsEmpty())
-    gd::EventsListSerialization::SerializeEventsTo(events,
-                                                  element.AddChild("events"));
+  gd::EventsListSerialization::SerializeEventsTo(events,
+                                                 element.AddChild("events"));
 }
 
 void StandardEvent::UnserializeFrom(gd::Project& project,
@@ -65,12 +63,8 @@ void StandardEvent::UnserializeFrom(gd::Project& project,
       project, conditions, element.GetChild("conditions", 0, "Conditions"));
   gd::EventsListSerialization::UnserializeInstructionsFrom(
       project, actions, element.GetChild("actions", 0, "Actions"));
-
-  events.Clear();
-  if (element.HasChild("events", "Events")) {
-    gd::EventsListSerialization::UnserializeEventsFrom(
-        project, events, element.GetChild("events", 0, "Events"));
-  }
+  gd::EventsListSerialization::UnserializeEventsFrom(
+      project, events, element.GetChild("events", 0, "Events"));
 }
 
 }  // namespace gd

Core/GDCore/Events/Builtin/WhileEvent.cpp

@@ -52,10 +52,8 @@ void WhileEvent::SerializeTo(SerializerElement& element) const {
       conditions, element.AddChild("conditions"));
   gd::EventsListSerialization::SerializeInstructionsTo(
       actions, element.AddChild("actions"));
-
-  if (!events.IsEmpty())
-    gd::EventsListSerialization::SerializeEventsTo(events,
-                                                  element.AddChild("events"));
+  gd::EventsListSerialization::SerializeEventsTo(events,
+                                                 element.AddChild("events"));
 }
 
 void WhileEvent::UnserializeFrom(gd::Project& project,
@@ -70,12 +68,8 @@ void WhileEvent::UnserializeFrom(gd::Project& project,
       project, conditions, element.GetChild("conditions", 0, "Conditions"));
   gd::EventsListSerialization::UnserializeInstructionsFrom(
       project, actions, element.GetChild("actions", 0, "Actions"));
-
-  events.Clear();
-  if (element.HasChild("events", "Events")) {
-    gd::EventsListSerialization::UnserializeEventsFrom(
-        project, events, element.GetChild("events", 0, "Events"));
-  }
+  gd::EventsListSerialization::UnserializeEventsFrom(
+      project, events, element.GetChild("events", 0, "Events"));
 }
 
 }  // namespace gd

Core/GDCore/Events/CodeGeneration/EventsCodeGenerationContext.cpp

@@ -4,9 +4,7 @@
  * reserved. This project is released under the MIT License.
  */
 #include "GDCore/Events/CodeGeneration/EventsCodeGenerationContext.h"
-
 #include <set>
-
 #include "GDCore/CommonTools.h"
 #include "GDCore/Events/CodeGeneration/EventsCodeGenerator.h"
 #include "GDCore/Events/Tools/EventsCodeNameMangler.h"
@@ -16,7 +14,7 @@ using namespace std;
 namespace gd {
 
 void EventsCodeGenerationContext::InheritsFrom(
-    EventsCodeGenerationContext& parent_) {
+    const EventsCodeGenerationContext& parent_) {
   parent = &parent_;
 
   // Objects lists declared by parent became "already declared" in the child
@@ -26,8 +24,8 @@ void EventsCodeGenerationContext::InheritsFrom(
             parent_.objectsListsToBeDeclared.end(),
             std::inserter(alreadyDeclaredObjectsLists,
                           alreadyDeclaredObjectsLists.begin()));
-  std::copy(parent_.objectsListsOrEmptyToBeDeclared.begin(),
-            parent_.objectsListsOrEmptyToBeDeclared.end(),
+  std::copy(parent_.objectsListsWithoutPickingToBeDeclared.begin(),
+            parent_.objectsListsWithoutPickingToBeDeclared.end(),
             std::inserter(alreadyDeclaredObjectsLists,
                           alreadyDeclaredObjectsLists.begin()));
   std::copy(parent_.emptyObjectsListsToBeDeclared.begin(),
@@ -35,8 +33,6 @@ void EventsCodeGenerationContext::InheritsFrom(
             std::inserter(alreadyDeclaredObjectsLists,
                           alreadyDeclaredObjectsLists.begin()));
 
-  nearestAsyncParent = parent_.IsAsyncCallback() ? &parent_ : parent_.nearestAsyncParent;
-  asyncDepth = parent_.asyncDepth;
   depthOfLastUse = parent_.depthOfLastUse;
   customConditionDepth = parent_.customConditionDepth;
   contextDepth = parent_.GetContextDepth() + 1;
@@ -46,59 +42,33 @@ void EventsCodeGenerationContext::InheritsFrom(
   }
 }
 
-void EventsCodeGenerationContext::InheritsAsAsyncCallbackFrom(
-    EventsCodeGenerationContext& parent_) {
-  // Increasing the async depth is enough to mark the context as an async callback.
-  InheritsFrom(parent_);
-  asyncDepth = parent_.asyncDepth + 1;
-}
-
 void EventsCodeGenerationContext::Reuse(
-    EventsCodeGenerationContext& parent_) {
+    const EventsCodeGenerationContext& parent_) {
   InheritsFrom(parent_);
   if (parent_.CanReuse())
     contextDepth = parent_.GetContextDepth();  // Keep same context depth
 }
 
-void EventsCodeGenerationContext::NotifyAsyncParentsAboutDeclaredObject(const gd::String& objectName) {
-  gd::EventsCodeGenerationContext* asyncContext = IsAsyncCallback() ? this : nearestAsyncParent;
-  for (;
-        asyncContext != nullptr;
-        asyncContext = asyncContext->parent->nearestAsyncParent)
-    asyncContext->allObjectsListToBeDeclaredAcrossChildren.insert(objectName);
-}
-
 void EventsCodeGenerationContext::ObjectsListNeeded(
     const gd::String& objectName) {
-  if (!IsToBeDeclared(objectName)) {
+  if (!IsToBeDeclared(objectName))
     objectsListsToBeDeclared.insert(objectName);
 
-    if (IsInsideAsync()) {
-      NotifyAsyncParentsAboutDeclaredObject(objectName);
-    }
-  }
-
   depthOfLastUse[objectName] = GetContextDepth();
 }
 
-void EventsCodeGenerationContext::ObjectsListNeededOrEmptyIfJustDeclared(
+void EventsCodeGenerationContext::ObjectsListWithoutPickingNeeded(
     const gd::String& objectName) {
-  if (!IsToBeDeclared(objectName)) {
-    objectsListsOrEmptyToBeDeclared.insert(objectName);
-
-    if (IsInsideAsync()) {
-      NotifyAsyncParentsAboutDeclaredObject(objectName);
-    }
-  }
+  if (!IsToBeDeclared(objectName))
+    objectsListsWithoutPickingToBeDeclared.insert(objectName);
 
   depthOfLastUse[objectName] = GetContextDepth();
 }
 
 void EventsCodeGenerationContext::EmptyObjectsListNeeded(
     const gd::String& objectName) {
-  if (!IsToBeDeclared(objectName)) {
+  if (!IsToBeDeclared(objectName))
     emptyObjectsListsToBeDeclared.insert(objectName);
-  }
 
   depthOfLastUse[objectName] = GetContextDepth();
 }
@@ -107,8 +77,8 @@ std::set<gd::String> EventsCodeGenerationContext::GetAllObjectsToBeDeclared()
     const {
   std::set<gd::String> allObjectListsToBeDeclared(
       objectsListsToBeDeclared.begin(), objectsListsToBeDeclared.end());
-  allObjectListsToBeDeclared.insert(objectsListsOrEmptyToBeDeclared.begin(),
-                                    objectsListsOrEmptyToBeDeclared.end());
+  allObjectListsToBeDeclared.insert(objectsListsWithoutPickingToBeDeclared.begin(),
+                                    objectsListsWithoutPickingToBeDeclared.end());
   allObjectListsToBeDeclared.insert(emptyObjectsListsToBeDeclared.begin(),
                                     emptyObjectsListsToBeDeclared.end());
 
@@ -132,21 +102,4 @@ bool EventsCodeGenerationContext::IsSameObjectsList(
          otherContext.GetLastDepthObjectListWasNeeded(objectName);
 }
 
-bool EventsCodeGenerationContext::ShouldUseAsyncObjectsList(
-    const gd::String& objectName) const {
-  if (!IsInsideAsync()) return false;
-
-  // Check if the objects list was used after (or in) the nearest async callback context.
-  const gd::EventsCodeGenerationContext* asyncContext = IsAsyncCallback() ? this : nearestAsyncParent;
-  if (parent->GetLastDepthObjectListWasNeeded(objectName) >= asyncContext->GetContextDepth()) {
-    // The object was used in a context after (or in) the nearest async parent context, so we're not getting it from the
-    // async object lists (it was already gotten from there in this previous context).
-    return false;
-  }
-
-  // If the objects list is declared in a parent of the nearest async context, it means
-  // the async context had to use an async objects list to access it.
-  return asyncContext->ObjectAlreadyDeclaredByParents(objectName);
-};
-
 }  // namespace gd

Core/GDCore/Events/CodeGeneration/EventsCodeGenerationContext.h

@@ -8,7 +8,6 @@
 #include <map>
 #include <memory>
 #include <set>
-
 #include "GDCore/String.h"
 
 namespace gd {
@@ -34,7 +33,11 @@ class GD_CORE_API EventsCodeGenerationContext {
    * updated to contain the maximal scope depth reached.
    */
   EventsCodeGenerationContext(unsigned int* maxDepthLevel_ = nullptr)
-      : maxDepthLevel(maxDepthLevel_){};
+      : contextDepth(0),
+        customConditionDepth(0),
+        maxDepthLevel(maxDepthLevel_),
+        parent(NULL),
+        reuseExplicitlyForbidden(false){};
   virtual ~EventsCodeGenerationContext(){};
 
   /**
@@ -42,13 +45,7 @@ class GD_CORE_API EventsCodeGenerationContext {
    * another one. The child will then for example not declare again objects
    * already declared by its parent.
    */
-  void InheritsFrom(EventsCodeGenerationContext& parent);
-
-  /**
-   * Call this method to make an EventsCodeGenerationContext as a "child" of
-   * another one, but in the context of an async function.
-   */
-  void InheritsAsAsyncCallbackFrom(EventsCodeGenerationContext& parent);
+  void InheritsFrom(const EventsCodeGenerationContext& parent);
 
   /**
    * \brief As InheritsFrom, mark the context as being the child of another one,
@@ -56,7 +53,7 @@ class GD_CORE_API EventsCodeGenerationContext {
    *
    * Used for example for optimizing the last event of a list.
    */
-  void Reuse(EventsCodeGenerationContext& parent);
+  void Reuse(const EventsCodeGenerationContext& parent);
 
   /**
    * \brief Forbid any optimization that would reuse and modify the object list
@@ -91,19 +88,19 @@ class GD_CORE_API EventsCodeGenerationContext {
   const EventsCodeGenerationContext* GetParentContext() const { return parent; }
 
   /**
-   * Mark the object as being the object being handled by the instruction.
+   * Mark the object has being the object being handled by the instruction
    */
   void SetCurrentObject(const gd::String& objectName) {
     currentObject = objectName;
   };
 
   /**
-   * Set that no particular object is being handled by an instruction.
+   * Set that no particular object is being handled by an instruction
    */
   void SetNoCurrentObject() { currentObject = ""; };
 
   /**
-   * Get the object being handled by the instruction.
+   * Get the object being handled by the instruction
    */
   const gd::String& GetCurrentObject() const { return currentObject; };
 
@@ -112,7 +109,7 @@ class GD_CORE_API EventsCodeGenerationContext {
    *
    * The list will be filled with objects from the scene if it is the first time
    * it is requested, unless there is already an object list with this name
-   * (i.e. `ObjectAlreadyDeclaredByParents(objectName)` returns true).
+   * (i.e. `ObjectAlreadyDeclared(objectName)` returns true).
    */
   void ObjectsListNeeded(const gd::String& objectName);
 
@@ -124,7 +121,7 @@ class GD_CORE_API EventsCodeGenerationContext {
    * from the scene. If there is already an objects list with this name, no new
    * list will be declared again.
    */
-  void ObjectsListNeededOrEmptyIfJustDeclared(const gd::String& objectName);
+  void ObjectsListWithoutPickingNeeded(const gd::String& objectName);
 
   /**
    * Call this when an instruction in the event needs an empty object list,
@@ -137,21 +134,29 @@ class GD_CORE_API EventsCodeGenerationContext {
   void EmptyObjectsListNeeded(const gd::String& objectName);
 
   /**
-   * Return true if an object list has already been declared by the parent contexts.
+   * Return true if an object list has already been declared (or is going to be
+   * declared).
    */
-  bool ObjectAlreadyDeclaredByParents(const gd::String& objectName) const {
+  bool ObjectAlreadyDeclared(const gd::String& objectName) const {
     return (alreadyDeclaredObjectsLists.find(objectName) !=
             alreadyDeclaredObjectsLists.end());
   };
 
+  /**
+   * \brief Consider that \a objectName is now declared in the context.
+   */
+  void SetObjectDeclared(const gd::String& objectName) {
+    alreadyDeclaredObjectsLists.insert(objectName);
+  }
+
   /**
    * Return all the objects lists which will be declared by the current context
-   * (normal, potentially empty or empty).
+   * ( the non empty as well as the empty objects lists )
    */
   std::set<gd::String> GetAllObjectsToBeDeclared() const;
 
   /**
-   * Return the objects lists which will be declared by the current context.
+   * Return the objects lists which will be declared by the current context
    */
   const std::set<gd::String>& GetObjectsListsToBeDeclared() const {
     return objectsListsToBeDeclared;
@@ -161,9 +166,9 @@ class GD_CORE_API EventsCodeGenerationContext {
    * Return the objects lists which will be will be declared, without filling
    * them with objects from the scene.
    */
-  const std::set<gd::String>& GetObjectsListsToBeEmptyIfJustDeclared()
+  const std::set<gd::String>& GetObjectsListsToBeDeclaredWithoutPicking()
       const {
-    return objectsListsOrEmptyToBeDeclared;
+    return objectsListsWithoutPickingToBeDeclared;
   };
 
   /**
@@ -179,7 +184,7 @@ class GD_CORE_API EventsCodeGenerationContext {
    * Return the objects lists which are already declared and can be used in the
    * current context without declaration.
    */
-  const std::set<gd::String>& GetObjectsListsAlreadyDeclaredByParents() const {
+  const std::set<gd::String>& GetObjectsListsAlreadyDeclared() const {
     return alreadyDeclaredObjectsLists;
   };
 
@@ -222,55 +227,22 @@ class GD_CORE_API EventsCodeGenerationContext {
    */
   size_t GetCurrentConditionDepth() const { return customConditionDepth; }
 
-  /**
-   * \brief Returns the list of all objects declared in this context
-   * and subcontexts.
-   * \warning Only works on an async callback's context.
-   *
-   * It is to be used by the Async event code generator to know what objects
-   * lists to backup for the async callback and async callbacks after it.
-   */
-  const std::set<gd::String>& GetAllDeclaredObjectsAcrossChildren() {
-    return allObjectsListToBeDeclaredAcrossChildren;
-  };
-
-  /**
-   * Returns true if an object list should be gotten from a backed up
-   * objects list instead of the parent context. This can happen inside an
-   * asynchronous callback or a child context of an asynchronous callback (i.e:
-   * the `asyncDepth` is not 0).
-   */
-  bool ShouldUseAsyncObjectsList(const gd::String& objectName) const;
-
-  /**
-   * Returns true if the code currently being generated is inside an
-   * asynchronous context (either in an asynchronous callback, or in a children of
-   * an asynchronous callback).
-   */
-  bool IsInsideAsync() const { return asyncDepth != 0; };
-
-  /**
-   * Returns true if the code currently being generated is an asynchronous
-   * callback (but not a child of an asynchronous callback).
-   */
-  bool IsAsyncCallback() const { return parent != nullptr && parent->asyncDepth != asyncDepth; }
-
+ private:
   /**
    * \brief Returns true if the given object is already going to be declared
-   * in this context (either as a traditional objects list, or an empty one).
+   * (either as a traditional objects list, or one without picking, or one
+   * empty).
+   *
    */
   bool IsToBeDeclared(const gd::String& objectName) {
     return objectsListsToBeDeclared.find(objectName) !=
                objectsListsToBeDeclared.end() ||
-           objectsListsOrEmptyToBeDeclared.find(objectName) !=
-               objectsListsOrEmptyToBeDeclared.end() ||
+           objectsListsWithoutPickingToBeDeclared.find(objectName) !=
+               objectsListsWithoutPickingToBeDeclared.end() ||
            emptyObjectsListsToBeDeclared.find(objectName) !=
                emptyObjectsListsToBeDeclared.end();
   };
 
- private:
-  void NotifyAsyncParentsAboutDeclaredObject(const gd::String& objectName);
-
   std::set<gd::String>
       alreadyDeclaredObjectsLists;  ///< Objects lists already needed in a
                                     ///< parent context.
@@ -278,7 +250,7 @@ class GD_CORE_API EventsCodeGenerationContext {
       objectsListsToBeDeclared;  ///< Objects lists that will be declared in
                                  ///< this context.
   std::set<gd::String>
-      objectsListsOrEmptyToBeDeclared;  ///< Objects lists that will be
+      objectsListsWithoutPickingToBeDeclared;  ///< Objects lists that will be
                                                ///< declared in this context,
                                                ///< but not filled with scene's
                                                ///< objects.
@@ -288,40 +260,21 @@ class GD_CORE_API EventsCodeGenerationContext {
                                       ///< but not filled with scene's
                                       ///< objects and not filled with any
                                       ///< previously existing objects list.
-  std::set<gd::String>
-      allObjectsListToBeDeclaredAcrossChildren;  ///< This is only to be used by
-                                                 ///< the async callback
-                                                 ///< contexts to know all
-                                                 ///< objects declared across
-                                                 ///< all children, so that the
-                                                 ///< necessary objects can be
-                                                 ///< backed up.
-
   std::map<gd::String, unsigned int>
       depthOfLastUse;  ///< The context depth when an object was last used.
   gd::String
       currentObject;  ///< The object being used by an action or condition.
-  unsigned int contextDepth = 0;  ///< The depth of the context: 0 for a newly
-                                  ///< created context, n+1 for any context
-                                  ///< inheriting from context with depth n.
-  unsigned int customConditionDepth =
-      0;  ///< The depth of the conditions being generated.
-  unsigned int asyncDepth =
-      0;  ///< If higher than 0, the current context is an asynchronous callback,
-          ///< or a child context of an asynchronous callback:
-          ///< - If the parent's async depth != the current context async depth,
-          ///<   then the current context is an asynchronous callback context.
-          ///< - Otherwise, it's a child of an asynchronous callback.
+  unsigned int contextDepth;  ///< The depth of the context : 0 for a newly
+                              ///< created context, n+1 for any context
+                              ///< inheriting from context with depth n.
+  unsigned int
+      customConditionDepth;  ///< The depth of the conditions being generated.
   unsigned int* maxDepthLevel;  ///< A pointer to a unsigned int updated with
                                 ///< the maximum depth reached.
-  const EventsCodeGenerationContext* parent =
-      nullptr;  ///< The parent of the current context. Can be NULL.
-  EventsCodeGenerationContext* nearestAsyncParent =
-      nullptr;  ///< The nearest parent context that is an async callback
-                ///< context.
-  bool reuseExplicitlyForbidden =
-      false;  ///< If set to true, forbid children contexts
-              ///< to reuse this one without inheriting.
+  const EventsCodeGenerationContext*
+      parent;  ///< The parent of the current context. Can be NULL.
+  bool reuseExplicitlyForbidden;  ///< If set to true, forbid children context
+                                  ///< to reuse this one without inheriting.
 };
 
 }  // namespace gd

Core/GDCore/Events/CodeGeneration/EventsCodeGenerator.cpp

@@ -450,9 +450,7 @@ gd::String EventsCodeGenerator::GenerateConditionsListCode(
  * Generate code for an action.
  */
 gd::String EventsCodeGenerator::GenerateActionCode(
-    gd::Instruction& action,
-    EventsCodeGenerationContext& context,
-    const gd::String& optionalAsyncCallbackName) {
+    gd::Instruction& action, EventsCodeGenerationContext& context) {
   gd::String actionCode;
 
   const gd::InstructionMetadata& instrInfos =
@@ -520,12 +518,8 @@ gd::String EventsCodeGenerator::GenerateActionCode(
           // Prepare arguments and generate the whole action code
           vector<gd::String> arguments = GenerateParametersCodes(
               action.GetParameters(), instrInfos.parameters, context);
-          actionCode += GenerateObjectAction(realObjects[i],
-                                             objInfo,
-                                             arguments,
-                                             instrInfos,
-                                             context,
-                                             optionalAsyncCallbackName);
+          actionCode += GenerateObjectAction(
+              realObjects[i], objInfo, arguments, instrInfos, context);
 
           context.SetNoCurrentObject();
         }
@@ -558,8 +552,7 @@ gd::String EventsCodeGenerator::GenerateActionCode(
                                    autoInfo,
                                    arguments,
                                    instrInfos,
-                                   context,
-                                   optionalAsyncCallbackName);
+                                   context);
 
         context.SetNoCurrentObject();
       }
@@ -567,72 +560,12 @@ gd::String EventsCodeGenerator::GenerateActionCode(
   } else {
     vector<gd::String> arguments = GenerateParametersCodes(
         action.GetParameters(), instrInfos.parameters, context);
-    actionCode +=
-        GenerateFreeAction(arguments, instrInfos, context, optionalAsyncCallbackName);
+    actionCode += GenerateFreeAction(arguments, instrInfos, context);
   }
 
   return actionCode;
 }
 
-const EventsCodeGenerator::CallbackDescriptor
-EventsCodeGenerator::GenerateCallback(
-    const gd::String& callbackID,
-    gd::EventsCodeGenerationContext& parentContext,
-    gd::InstructionsList& actions,
-    gd::EventsList* subEvents) {
-  gd::EventsCodeGenerationContext callbackContext;
-  callbackContext.InheritsAsAsyncCallbackFrom(parentContext);
-  const gd::String callbackFunctionName =
-      GetCodeNamespaceAccessor() + "asyncCallback" + callbackID;
-  const gd::String callbackFunctionArguments =
-      GenerateEventsParameters(callbackContext);
-
-  // Generate actions
-  gd::String actionsCode = GenerateActionsListCode(actions, callbackContext);
-
-  // Generate subevents
-  if (subEvents != nullptr)  // Sub events
-  {
-    actionsCode += "\n{ //Subevents\n";
-    actionsCode += GenerateEventsListCode(*subEvents, callbackContext);
-    actionsCode += "} //End of subevents\n";
-  }
-
-  // Compose the callback function and add outside main
-  const gd::String actionsDeclarationsCode =
-      GenerateObjectsDeclarationCode(callbackContext);
-
-  const gd::String callbackCode = callbackFunctionName + " = function (" +
-                                  GenerateEventsParameters(callbackContext) +
-                                  ") {\n" + actionsDeclarationsCode +
-                                  actionsCode + "}\n";
-
-  AddCustomCodeOutsideMain(callbackCode);
-
-  std::set<gd::String> requiredObjects;
-  // Build the list of all objects required by the callback. Any object that has
-  // already been declared could have gone through previous object picking, so
-  // if such an object is used by the actions or subevents of this callback, we
-  // must ask the caller to pass the already existing objects lists through a
-  // `LongLivedObjectsList` to the callback function.
-  for (const auto& objectUsedInSubTree :
-       callbackContext.GetAllDeclaredObjectsAcrossChildren()) {
-    if (callbackContext.ObjectAlreadyDeclaredByParents(objectUsedInSubTree))
-      requiredObjects.insert(objectUsedInSubTree);
-  };
-
-  return CallbackDescriptor(
-      callbackFunctionName, callbackFunctionArguments, requiredObjects);
-};
-
-const gd::String EventsCodeGenerator::GenerateEventsParameters(
-    const gd::EventsCodeGenerationContext& context) {
-  gd::String parameters = "runtimeScene";
-  if (!HasProjectAndLayout()) parameters += ", eventsFunctionContext";
-  if (context.IsInsideAsync()) parameters += ", asyncObjectsList";
-  return parameters;
-};
-
 /**
  * Generate actions code.
  */
@@ -658,7 +591,7 @@ gd::String EventsCodeGenerator::GenerateActionsListCode(
 }
 
 gd::String EventsCodeGenerator::GenerateParameterCodes(
-    const gd::Expression& parameter,
+    const gd::String& parameter,
     const gd::ParameterMetadata& metadata,
     gd::EventsCodeGenerationContext& context,
     const gd::String& lastObjectName,
@@ -668,20 +601,19 @@ gd::String EventsCodeGenerator::GenerateParameterCodes(
 
   if (ParameterMetadata::IsExpression("number", metadata.type)) {
     argOutput = gd::ExpressionCodeGenerator::GenerateExpressionCode(
-        *this, context, "number", parameter, lastObjectName);
+        *this, context, "number", parameter);
   } else if (ParameterMetadata::IsExpression("string", metadata.type)) {
     argOutput = gd::ExpressionCodeGenerator::GenerateExpressionCode(
-        *this, context, "string", parameter, lastObjectName);
+        *this, context, "string", parameter);
   } else if (ParameterMetadata::IsExpression("variable", metadata.type)) {
     argOutput = gd::ExpressionCodeGenerator::GenerateExpressionCode(
         *this, context, metadata.type, parameter, lastObjectName);
   } else if (ParameterMetadata::IsObject(metadata.type)) {
     // It would be possible to run a gd::ExpressionCodeGenerator if later
     // objects can have nested objects, or function returning objects.
-    argOutput = GenerateObject(parameter.GetPlainString(), metadata.type, context);
+    argOutput = GenerateObject(parameter, metadata.type, context);
   } else if (metadata.type == "relationalOperator") {
-    auto parameterString = parameter.GetPlainString();
-    argOutput += parameterString == "=" ? "==" : parameterString;
+    argOutput += parameter == "=" ? "==" : parameter;
     if (argOutput != "==" && argOutput != "<" && argOutput != ">" &&
         argOutput != "<=" && argOutput != ">=" && argOutput != "!=") {
       cout << "Warning: Bad relational operator: Set to == by default." << endl;
@@ -690,7 +622,7 @@ gd::String EventsCodeGenerator::GenerateParameterCodes(
 
     argOutput = "\"" + argOutput + "\"";
   } else if (metadata.type == "operator") {
-    argOutput += parameter.GetPlainString();
+    argOutput += parameter;
     if (argOutput != "=" && argOutput != "+" && argOutput != "-" &&
         argOutput != "/" && argOutput != "*") {
       cout << "Warning: Bad operator: Set to = by default." << endl;
@@ -699,9 +631,9 @@ gd::String EventsCodeGenerator::GenerateParameterCodes(
 
     argOutput = "\"" + argOutput + "\"";
   } else if (ParameterMetadata::IsBehavior(metadata.type)) {
-    argOutput = GenerateGetBehaviorNameCode(parameter.GetPlainString());
+    argOutput = GenerateGetBehaviorNameCode(parameter);
   } else if (metadata.type == "key") {
-    argOutput = "\"" + ConvertToString(parameter.GetPlainString()) + "\"";
+    argOutput = "\"" + ConvertToString(parameter) + "\"";
   } else if (metadata.type == "audioResource" ||
              metadata.type == "bitmapFontResource" ||
              metadata.type == "fontResource" ||
@@ -711,17 +643,15 @@ gd::String EventsCodeGenerator::GenerateParameterCodes(
              // Deprecated, old parameter names:
              metadata.type == "password" || metadata.type == "musicfile" ||
              metadata.type == "soundfile" || metadata.type == "police") {
-    argOutput = "\"" + ConvertToString(parameter.GetPlainString()) + "\"";
+    argOutput = "\"" + ConvertToString(parameter) + "\"";
   } else if (metadata.type == "mouse") {
-    argOutput = "\"" + ConvertToString(parameter.GetPlainString()) + "\"";
+    argOutput = "\"" + ConvertToString(parameter) + "\"";
   } else if (metadata.type == "yesorno") {
-    auto parameterString = parameter.GetPlainString();
-    argOutput += (parameterString == "yes" || parameterString == "oui") ? GenerateTrue()
+    argOutput += (parameter == "yes" || parameter == "oui") ? GenerateTrue()
                                                             : GenerateFalse();
   } else if (metadata.type == "trueorfalse") {
-    auto parameterString = parameter.GetPlainString();
     // This is duplicated in AdvancedExtension.cpp for GDJS
-    argOutput += (parameterString == "True" || parameterString == "Vrai") ? GenerateTrue()
+    argOutput += (parameter == "True" || parameter == "Vrai") ? GenerateTrue()
                                                               : GenerateFalse();
   }
   // Code only parameter type
@@ -741,7 +671,7 @@ gd::String EventsCodeGenerator::GenerateParameterCodes(
       if (!metadata.type.empty())
         cout << "Warning: Unknown type of parameter \"" << metadata.type
              << "\"." << std::endl;
-      argOutput += "\"" + ConvertToString(parameter.GetPlainString()) + "\"";
+      argOutput += "\"" + ConvertToString(parameter) + "\"";
     }
   }
 
@@ -761,7 +691,7 @@ vector<gd::String> EventsCodeGenerator::GenerateParametersCodes(
       parametersInfo,
       [this, &context, &supplementaryParametersTypes, &arguments](
           const gd::ParameterMetadata& parameterMetadata,
-          const gd::Expression& parameterValue,
+          const gd::String& parameterValue,
           const gd::String& lastObjectName) {
         gd::String argOutput =
             GenerateParameterCodes(parameterValue,
@@ -813,21 +743,23 @@ gd::String EventsCodeGenerator::GenerateObjectsDeclarationCode(
   gd::String declarationsCode;
   for (auto object : context.GetObjectsListsToBeDeclared()) {
     gd::String objectListDeclaration = "";
-    if (!context.ObjectAlreadyDeclaredByParents(object)) {
+    if (!context.ObjectAlreadyDeclared(object)) {
       objectListDeclaration = "std::vector<RuntimeObject*> " +
                               GetObjectListName(object, context) +
                               " = runtimeContext->GetObjectsRawPointers(\"" +
                               ConvertToString(object) + "\");\n";
+      context.SetObjectDeclared(object);
     } else
       objectListDeclaration = declareObjectList(object, context);
 
     declarationsCode += objectListDeclaration + "\n";
   }
-  for (auto object : context.GetObjectsListsToBeEmptyIfJustDeclared()) {
+  for (auto object : context.GetObjectsListsToBeDeclaredWithoutPicking()) {
     gd::String objectListDeclaration = "";
-    if (!context.ObjectAlreadyDeclaredByParents(object)) {
+    if (!context.ObjectAlreadyDeclared(object)) {
       objectListDeclaration = "std::vector<RuntimeObject*> " +
                               GetObjectListName(object, context) + ";\n";
+      context.SetObjectDeclared(object);
     } else
       objectListDeclaration = declareObjectList(object, context);
 
@@ -835,9 +767,10 @@ gd::String EventsCodeGenerator::GenerateObjectsDeclarationCode(
   }
   for (auto object : context.GetObjectsListsToBeDeclaredEmpty()) {
     gd::String objectListDeclaration = "";
-    if (!context.ObjectAlreadyDeclaredByParents(object)) {
+    if (!context.ObjectAlreadyDeclared(object)) {
       objectListDeclaration = "std::vector<RuntimeObject*> " +
                               GetObjectListName(object, context) + ";\n";
+      context.SetObjectDeclared(object);
     } else
       objectListDeclaration = "std::vector<RuntimeObject*> " +
                               GetObjectListName(object, context) + ";\n";
@@ -852,7 +785,7 @@ gd::String EventsCodeGenerator::GenerateObjectsDeclarationCode(
  * Generate events list code.
  */
 gd::String EventsCodeGenerator::GenerateEventsListCode(
-    gd::EventsList& events, EventsCodeGenerationContext& parentContext) {
+    gd::EventsList& events, const EventsCodeGenerationContext& parentContext) {
   gd::String output;
   for (std::size_t eId = 0; eId < events.size(); ++eId) {
     // Each event has its own context : Objects picked in an event are totally
@@ -868,8 +801,6 @@ gd::String EventsCodeGenerator::GenerateEventsListCode(
     // operation.
     bool reuseParentContext =
         parentContext.CanReuse() && eId == events.size() - 1;
-
-    // TODO: avoid creating if useless.
     gd::EventsCodeGenerationContext reusedContext;
     reusedContext.Reuse(parentContext);
 
@@ -1084,8 +1015,7 @@ gd::String EventsCodeGenerator::GenerateBehaviorCondition(
 gd::String EventsCodeGenerator::GenerateFreeAction(
     const std::vector<gd::String>& arguments,
     const gd::InstructionMetadata& instrInfos,
-    gd::EventsCodeGenerationContext& context,
-    const gd::String& optionalAsyncCallbackName) {
+    gd::EventsCodeGenerationContext& context) {
   // Generate call
   gd::String call;
   if (instrInfos.codeExtraInformation.type == "number" ||
@@ -1112,11 +1042,6 @@ gd::String EventsCodeGenerator::GenerateFreeAction(
     call = instrInfos.codeExtraInformation.functionCallName + "(" +
            GenerateArgumentsList(arguments) + ")";
   }
-
-  if (!optionalAsyncCallbackName.empty())
-    call = "runtimeScene.getAsyncTasksManager().addTask(" + call + ", " +
-           optionalAsyncCallbackName + ")";
-
   return call + ";\n";
 }
 
@@ -1125,8 +1050,7 @@ gd::String EventsCodeGenerator::GenerateObjectAction(
     const gd::ObjectMetadata& objInfo,
     const std::vector<gd::String>& arguments,
     const gd::InstructionMetadata& instrInfos,
-    gd::EventsCodeGenerationContext& context,
-    const gd::String& optionalAsyncCallbackName) {
+    gd::EventsCodeGenerationContext& context) {
   // Create call
   gd::String call;
   if ((instrInfos.codeExtraInformation.type == "number" ||
@@ -1153,11 +1077,8 @@ gd::String EventsCodeGenerator::GenerateObjectAction(
 
     call = instrInfos.codeExtraInformation.functionCallName + "(" +
            argumentsStr + ")";
-
     return "For each picked object \"" + objectName + "\", call " + call + "(" +
-           argumentsStr + ")" +
-           (optionalAsyncCallbackName.empty() ? "" : (", then call" + optionalAsyncCallbackName)) +
-           ".\n";
+           argumentsStr + ").\n";
   }
 }
 
@@ -1167,8 +1088,7 @@ gd::String EventsCodeGenerator::GenerateBehaviorAction(
     const gd::BehaviorMetadata& autoInfo,
     const std::vector<gd::String>& arguments,
     const gd::InstructionMetadata& instrInfos,
-    gd::EventsCodeGenerationContext& context,
-    const gd::String& optionalAsyncCallbackName) {
+    gd::EventsCodeGenerationContext& context) {
   // Create call
   gd::String call;
   if ((instrInfos.codeExtraInformation.type == "number" ||
@@ -1194,11 +1114,8 @@ gd::String EventsCodeGenerator::GenerateBehaviorAction(
 
     call = instrInfos.codeExtraInformation.functionCallName + "(" +
            argumentsStr + ")";
-
     return "For each picked object \"" + objectName + "\", call " + call + "(" +
-           argumentsStr + ")" + " for behavior \"" + behaviorName + "\"" +
-           (optionalAsyncCallbackName.empty() ? "" : (", then call" + optionalAsyncCallbackName)) +
-           ".\n";
+           argumentsStr + ")" + " for behavior \"" + behaviorName + "\".\n";
   }
 }
 
@@ -1246,7 +1163,7 @@ gd::String EventsCodeGenerator::GenerateArgumentsList(
   return argumentsStr;
 }
 
-EventsCodeGenerator::EventsCodeGenerator(const gd::Project& project_,
+EventsCodeGenerator::EventsCodeGenerator(gd::Project& project_,
                                          const gd::Layout& layout,
                                          const gd::Platform& platform_)
     : platform(platform_),
@@ -1263,7 +1180,7 @@ EventsCodeGenerator::EventsCodeGenerator(const gd::Project& project_,
 
 EventsCodeGenerator::EventsCodeGenerator(
     const gd::Platform& platform_,
-    const gd::ObjectsContainer& globalObjectsAndGroups_,
+    gd::ObjectsContainer& globalObjectsAndGroups_,
     const gd::ObjectsContainer& objectsAndGroups_)
     : platform(platform_),
       globalObjectsAndGroups(globalObjectsAndGroups_),

Core/GDCore/Events/CodeGeneration/EventsCodeGenerator.h

@@ -48,7 +48,7 @@ class GD_CORE_API EventsCodeGenerator {
    * \brief Construct a code generator for the specified
    * platform/project/layout.
    */
-  EventsCodeGenerator(const gd::Project& project_,
+  EventsCodeGenerator(gd::Project& project_,
                       const gd::Layout& layout,
                       const gd::Platform& platform_);
 
@@ -57,7 +57,7 @@ class GD_CORE_API EventsCodeGenerator {
    * objects/groups and platform
    */
   EventsCodeGenerator(const gd::Platform& platform,
-                      const gd::ObjectsContainer& globalObjectsAndGroups_,
+                      gd::ObjectsContainer& globalObjectsAndGroups_,
                       const gd::ObjectsContainer& objectsAndGroups_);
   virtual ~EventsCodeGenerator(){};
 
@@ -77,7 +77,7 @@ class GD_CORE_API EventsCodeGenerator {
    * \return Code
    */
   virtual gd::String GenerateEventsListCode(
-      gd::EventsList& events, EventsCodeGenerationContext& context);
+      gd::EventsList& events, const EventsCodeGenerationContext& context);
 
   /**
    * \brief Generate code for executing a condition list
@@ -155,51 +155,7 @@ class GD_CORE_API EventsCodeGenerator {
    * \return Code
    */
   gd::String GenerateActionCode(gd::Instruction& action,
-                                EventsCodeGenerationContext& context,
-                                const gd::String& optionalAsyncCallbackName = "");
-
-  struct CallbackDescriptor {
-    CallbackDescriptor(const gd::String functionName_,
-                       const gd::String argumentsList_,
-                       const std::set<gd::String> requiredObjects_)
-        : functionName(functionName_),
-          argumentsList(argumentsList_),
-          requiredObjects(requiredObjects_){};
-    /**
-     * The name by which the function can be invoked.
-     */
-    const gd::String functionName;
-    /**
-     * The comma separated list of arguments that the function takes.
-     */
-    const gd::String argumentsList;
-    /**
-     * A set of all objects that need to be backed up to be passed to the callback code.
-     */
-    const std::set<gd::String> requiredObjects;
-  };
-
-  /**
-   * \brief Generates actions and events as a callback.
-   *
-   * This is used by asynchronous functions to run the code out of the normal
-   * events flow.
-   *
-   * \returns A set with all objects required by the callback code.
-   * The caller must take care of backing them up in a LongLivedObjectsList,
-   * and to pass it to the callback function as the last argument.
-   */
-  virtual const CallbackDescriptor GenerateCallback(
-      const gd::String& callbackFunctionName,
-      gd::EventsCodeGenerationContext& parentContext,
-      gd::InstructionsList& actions,
-      gd::EventsList* subEvents = nullptr);
-
-  /**
-   * \brief Generates the parameters list of an event's generated function.
-   */
-  const gd::String GenerateEventsParameters(
-      const gd::EventsCodeGenerationContext& context);
+                                EventsCodeGenerationContext& context);
 
   /**
    * \brief Generate code for declaring objects lists.
@@ -327,7 +283,7 @@ class GD_CORE_API EventsCodeGenerator {
   /**
    * \brief Get the global objects/groups used for code generation.
    */
-  const gd::ObjectsContainer& GetGlobalObjectsAndGroups() const {
+  gd::ObjectsContainer& GetGlobalObjectsAndGroups() const {
     return globalObjectsAndGroups;
   }
 
@@ -348,7 +304,7 @@ class GD_CORE_API EventsCodeGenerator {
    * \brief Get the project the code is being generated for.
    * \warning This is only valid if HasProjectAndLayout() is true.
    */
-  const gd::Project& GetProject() const { return *project; }
+  gd::Project& GetProject() const { return *project; }
 
   /**
    * \brief Get the layout the code is being generated for.
@@ -506,10 +462,17 @@ class GD_CORE_API EventsCodeGenerator {
    * Other standard parameters type that should be implemented by platforms:
    * - currentScene: Reference to the current runtime scene.
    * - objectList : a map containing lists of objects which are specified by the
-  object name in another parameter.
-   * - objectListOrEmptyIfJustDeclared : Same as `objectList` but do not pick object if
+  object name in another parameter. Example:
+   * \code
+      AddExpression("Count", _("Object count"), _("Count the number of picked
+  objects"), _("Objects"), "res/conditions/nbObjet.png")
+      .AddParameter("objectList", _("Object"))
+      .SetFunctionName("getPickedObjectsCount");
+
+   * \endcode
+   * - objectListWithoutPicking : Same as objectList but do not pick object if
   they are not already picked.
-   * - objectPtr: Return a reference to the object specified by the object name in
+   * - objectPtr : Return a reference to the object specified by the object name in
   another parameter. Example:
    * \code
   .AddParameter("object", _("Object"))
@@ -517,7 +480,7 @@ class GD_CORE_API EventsCodeGenerator {
    * \endcode
    */
   virtual gd::String GenerateParameterCodes(
-      const gd::Expression& parameter,
+      const gd::String& parameter,
       const gd::ParameterMetadata& metadata,
       gd::EventsCodeGenerationContext& context,
       const gd::String& lastObjectName,
@@ -702,16 +665,14 @@ class GD_CORE_API EventsCodeGenerator {
   virtual gd::String GenerateFreeAction(
       const std::vector<gd::String>& arguments,
       const gd::InstructionMetadata& instrInfos,
-      gd::EventsCodeGenerationContext& context,
-      const gd::String& optionalAsyncCallbackName = "");
+      gd::EventsCodeGenerationContext& context);
 
   virtual gd::String GenerateObjectAction(
       const gd::String& objectName,
       const gd::ObjectMetadata& objInfo,
       const std::vector<gd::String>& arguments,
       const gd::InstructionMetadata& instrInfos,
-      gd::EventsCodeGenerationContext& context,
-      const gd::String& optionalAsyncCallbackName = "");
+      gd::EventsCodeGenerationContext& context);
 
   virtual gd::String GenerateBehaviorAction(
       const gd::String& objectName,
@@ -719,8 +680,7 @@ class GD_CORE_API EventsCodeGenerator {
       const gd::BehaviorMetadata& autoInfo,
       const std::vector<gd::String>& arguments,
       const gd::InstructionMetadata& instrInfos,
-      gd::EventsCodeGenerationContext& context,
-      const gd::String& optionalAsyncCallbackName = "");
+      gd::EventsCodeGenerationContext& context);
 
   gd::String GenerateRelationalOperatorCall(
       const gd::InstructionMetadata& instrInfos,
@@ -770,12 +730,12 @@ class GD_CORE_API EventsCodeGenerator {
 
   const gd::Platform& platform;  ///< The platform being used.
 
-  const gd::ObjectsContainer& globalObjectsAndGroups;
+  gd::ObjectsContainer& globalObjectsAndGroups;
   const gd::ObjectsContainer& objectsAndGroups;
 
   bool hasProjectAndLayout;  ///< true only if project and layout are valid
                              ///< references. If false, they should not be used.
-  const gd::Project* project;      ///< The project being used.
+  gd::Project* project;      ///< The project being used.
   const gd::Layout* scene;   ///< The scene being generated.
 
   bool errorOccurred;          ///< Must be set to true if an error occured.

Core/GDCore/Events/CodeGeneration/ExpressionCodeGenerator.cpp

@@ -25,38 +25,36 @@
 #include "GDCore/IDE/Events/ExpressionValidator.h"
 #include "GDCore/Project/Layout.h"
 #include "GDCore/Project/Project.h"
-#include "GDCore/IDE/Events/ExpressionTypeFinder.h"
-#include "GDCore/IDE/Events/ExpressionVariableOwnerFinder.h"
 
 namespace gd {
 
 gd::String ExpressionCodeGenerator::GenerateExpressionCode(
     EventsCodeGenerator& codeGenerator,
     EventsCodeGenerationContext& context,
-    const gd::String& rootType,
-    const gd::Expression& expression,
-    const gd::String& rootObjectName) {
-  ExpressionCodeGenerator generator(rootType, rootObjectName, codeGenerator, context);
+    const gd::String& type,
+    const gd::String& expression,
+    const gd::String& objectName) {
+  gd::ExpressionParser2 parser(codeGenerator.GetPlatform(),
+                               codeGenerator.GetGlobalObjectsAndGroups(),
+                               codeGenerator.GetObjectsAndGroups());
+  ExpressionCodeGenerator generator(codeGenerator, context);
 
-  auto node = expression.GetRootNode();
+  auto node = parser.ParseExpression(type, expression, objectName);
   if (!node) {
-    std::cout << "Error: error while parsing: \"" << expression.GetPlainString()
-              << "\" (" << rootType << ")" << std::endl;
+    std::cout << "Error: error while parsing: \"" << expression << "\" ("
+              << type << ")" << std::endl;
 
-    return generator.GenerateDefaultValue(rootType);
+    return generator.GenerateDefaultValue(type);
   }
 
-  gd::ExpressionValidator validator(codeGenerator.GetPlatform(),
-                                    codeGenerator.GetGlobalObjectsAndGroups(),
-                                    codeGenerator.GetObjectsAndGroups(),
-                                    rootType);
+  gd::ExpressionValidator validator;
   node->Visit(validator);
   if (!validator.GetErrors().empty()) {
     std::cout << "Error: \"" << validator.GetErrors()[0]->GetMessage()
-              << "\" in: \"" << expression.GetPlainString() << "\" ("
-              << rootType << ")" << std::endl;
+              << "\" in: \"" << expression << "\" (" << type << ")"
+              << std::endl;
 
-    return generator.GenerateDefaultValue(rootType);
+    return generator.GenerateDefaultValue(type);
   }
 
   node->Visit(generator);
@@ -99,24 +97,15 @@ void ExpressionCodeGenerator::OnVisitTextNode(TextNode& node) {
 void ExpressionCodeGenerator::OnVisitVariableNode(VariableNode& node) {
   // This "translation" from the type to an enum could be avoided
   // if all types were moved to an enum.
-  auto type = gd::ExpressionTypeFinder::GetType(codeGenerator.GetPlatform(),
-                                            codeGenerator.GetGlobalObjectsAndGroups(),
-                                            codeGenerator.GetObjectsAndGroups(),
-                                            rootType,
-                                            node);
   EventsCodeGenerator::VariableScope scope =
-      type == "globalvar"
+      node.type == "globalvar"
           ? gd::EventsCodeGenerator::PROJECT_VARIABLE
-          : ((type == "scenevar")
+          : ((node.type == "scenevar")
                  ? gd::EventsCodeGenerator::LAYOUT_VARIABLE
                  : gd::EventsCodeGenerator::OBJECT_VARIABLE);
-  auto objectName = gd::ExpressionVariableOwnerFinder::GetObjectName(codeGenerator.GetPlatform(),
-                                        codeGenerator.GetGlobalObjectsAndGroups(),
-                                        codeGenerator.GetObjectsAndGroups(),
-                                        rootObjectName,
-                                        node);
+
   output += codeGenerator.GenerateGetVariable(
-      node.name, scope, context, objectName);
+      node.name, scope, context, node.objectName);
   if (node.child) node.child->Visit(*this);
 }
 
@@ -128,7 +117,7 @@ void ExpressionCodeGenerator::OnVisitVariableAccessorNode(
 
 void ExpressionCodeGenerator::OnVisitVariableBracketAccessorNode(
     VariableBracketAccessorNode& node) {
-  ExpressionCodeGenerator generator("string", "", codeGenerator, context);
+  ExpressionCodeGenerator generator(codeGenerator, context);
   node.expression->Visit(generator);
   output +=
       codeGenerator.GenerateVariableBracketAccessor(generator.GetOutput());
@@ -136,79 +125,39 @@ void ExpressionCodeGenerator::OnVisitVariableBracketAccessorNode(
 }
 
 void ExpressionCodeGenerator::OnVisitIdentifierNode(IdentifierNode& node) {
-  auto type = gd::ExpressionTypeFinder::GetType(codeGenerator.GetPlatform(),
-                                            codeGenerator.GetGlobalObjectsAndGroups(),
-                                            codeGenerator.GetObjectsAndGroups(),
-                                            rootType,
-                                            node);
-  if (gd::ParameterMetadata::IsObject(type)) {
+  if (gd::ParameterMetadata::IsObject(node.type)) {
     output +=
-        codeGenerator.GenerateObject(node.identifierName, type, context);
-  } else if (gd::ParameterMetadata::IsExpression("variable", type)) {
-      EventsCodeGenerator::VariableScope scope =
-          type == "globalvar"
-              ? gd::EventsCodeGenerator::PROJECT_VARIABLE
-              : ((type == "scenevar")
-                    ? gd::EventsCodeGenerator::LAYOUT_VARIABLE
-                    : gd::EventsCodeGenerator::OBJECT_VARIABLE);
-
-      auto objectName = gd::ExpressionVariableOwnerFinder::GetObjectName(codeGenerator.GetPlatform(),
-                                            codeGenerator.GetGlobalObjectsAndGroups(),
-                                            codeGenerator.GetObjectsAndGroups(),
-                                            rootObjectName,
-                                            node);
-      output += codeGenerator.GenerateGetVariable(
-          node.identifierName, scope, context, objectName);
-      if (!node.childIdentifierName.empty()) {
-        output += codeGenerator.GenerateVariableAccessor(node.childIdentifierName);
-      }
-  } else if (node.childIdentifierName.empty()) {
+        codeGenerator.GenerateObject(node.identifierName, node.type, context);
+  } else {
     output += "/* Error during generation, unrecognized identifier type: " +
-              codeGenerator.ConvertToString(type) + " with value " +
+              codeGenerator.ConvertToString(node.type) + " with value " +
               codeGenerator.ConvertToString(node.identifierName) + " */ " +
               codeGenerator.ConvertToStringExplicit(node.identifierName);
   }
-  else {
-    // This is for function names that are put in IdentifierNode
-    // because the type is needed to tell them appart from variables.
-    output += GenerateDefaultValue(type);
-  }
 }
 
 void ExpressionCodeGenerator::OnVisitFunctionCallNode(FunctionCallNode& node) {
-  auto type = gd::ExpressionTypeFinder::GetType(codeGenerator.GetPlatform(),
-                                            codeGenerator.GetGlobalObjectsAndGroups(),
-                                            codeGenerator.GetObjectsAndGroups(),
-                                            rootType,
-                                            node);
-
-  const gd::ExpressionMetadata &metadata = MetadataProvider::GetFunctionCallMetadata(
-      codeGenerator.GetPlatform(),
-      codeGenerator.GetGlobalObjectsAndGroups(),
-      codeGenerator.GetObjectsAndGroups(),
-      node);
-
-  if (gd::MetadataProvider::IsBadExpressionMetadata(metadata)) {
+  if (gd::MetadataProvider::IsBadExpressionMetadata(node.expressionMetadata)) {
     output += "/* Error during generation, function not found: " +
               codeGenerator.ConvertToString(node.functionName) + " */ " +
-              GenerateDefaultValue(type);
+              GenerateDefaultValue(node.type);
     return;
   }
 
   if (!node.objectName.empty()) {
     if (!node.behaviorName.empty()) {
-      output += GenerateBehaviorFunctionCode(type,
+      output += GenerateBehaviorFunctionCode(node.type,
                                              node.objectName,
                                              node.behaviorName,
                                              node.parameters,
-                                             metadata);
+                                             node.expressionMetadata);
     } else {
       output += GenerateObjectFunctionCode(
-          type, node.objectName, node.parameters, metadata);
+          node.type, node.objectName, node.parameters, node.expressionMetadata);
     }
   } else {
     output +=
-        GenerateFreeFunctionCode(node.parameters, metadata);
+        GenerateFreeFunctionCode(node.parameters, node.expressionMetadata);
   }
 }
 
@@ -356,21 +305,18 @@ gd::String ExpressionCodeGenerator::GenerateParametersCodes(
 
     auto& parameterMetadata = expressionMetadata.parameters[i];
     if (!parameterMetadata.IsCodeOnly()) {
+      ExpressionCodeGenerator generator(codeGenerator, context);
       if (nonCodeOnlyParameterIndex < parameters.size()) {
-        auto objectName = gd::ExpressionVariableOwnerFinder::GetObjectName(codeGenerator.GetPlatform(),
-                                              codeGenerator.GetGlobalObjectsAndGroups(),
-                                              codeGenerator.GetObjectsAndGroups(),
-                                              rootObjectName,
-                                              *parameters[nonCodeOnlyParameterIndex].get());
-        ExpressionCodeGenerator generator(parameterMetadata.GetType(), objectName, codeGenerator, context);
         parameters[nonCodeOnlyParameterIndex]->Visit(generator);
         parametersCode += generator.GetOutput();
       } else if (parameterMetadata.IsOptional()) {
-        ExpressionCodeGenerator generator(parameterMetadata.GetType(), "", codeGenerator, context);
         // Optional parameters default value were not parsed at the time of the
         // expression parsing. Parse them now.
-        ExpressionParser2 parser;
-        auto node = parser.ParseExpression(parameterMetadata.GetDefaultValue());
+        ExpressionParser2 parser(codeGenerator.GetPlatform(),
+                                 codeGenerator.GetGlobalObjectsAndGroups(),
+                                 codeGenerator.GetObjectsAndGroups());
+        auto node = parser.ParseExpression(parameterMetadata.GetType(),
+                                           parameterMetadata.GetDefaultValue());
 
         node->Visit(generator);
         parametersCode += generator.GetOutput();
@@ -428,22 +374,12 @@ gd::String ExpressionCodeGenerator::GenerateDefaultValue(
 }
 
 void ExpressionCodeGenerator::OnVisitEmptyNode(EmptyNode& node) {
-  auto type = gd::ExpressionTypeFinder::GetType(codeGenerator.GetPlatform(),
-                                            codeGenerator.GetGlobalObjectsAndGroups(),
-                                            codeGenerator.GetObjectsAndGroups(),
-                                            rootType,
-                                            node);
-  output += GenerateDefaultValue(type);
+  output += GenerateDefaultValue(node.type);
 }
 
 void ExpressionCodeGenerator::OnVisitObjectFunctionNameNode(
     ObjectFunctionNameNode& node) {
-  auto type = gd::ExpressionTypeFinder::GetType(codeGenerator.GetPlatform(),
-                                            codeGenerator.GetGlobalObjectsAndGroups(),
-                                            codeGenerator.GetObjectsAndGroups(),
-                                            rootType,
-                                            node);
-  output += GenerateDefaultValue(type);
+  output += GenerateDefaultValue(node.type);
 }
 
 }  // namespace gd

Core/GDCore/Events/CodeGeneration/ExpressionCodeGenerator.h

@@ -9,6 +9,7 @@
 
 #include <memory>
 #include <vector>
+#include "GDCore/Events/Parsers/ExpressionParser2.h"
 #include "GDCore/Events/Parsers/ExpressionParser2Node.h"
 #include "GDCore/Events/Parsers/ExpressionParser2NodeWorker.h"
 #include "GDCore/String.h"
@@ -34,11 +35,9 @@ namespace gd {
  */
 class GD_CORE_API ExpressionCodeGenerator : public ExpressionParser2NodeWorker {
  public:
-  ExpressionCodeGenerator(const gd::String &rootType_,
-                          const gd::String &rootObjectName_,
-                          EventsCodeGenerator& codeGenerator_,
+  ExpressionCodeGenerator(EventsCodeGenerator& codeGenerator_,
                           EventsCodeGenerationContext& context_)
-      : rootType(rootType_), rootObjectName(rootObjectName_), codeGenerator(codeGenerator_), context(context_){};
+      : codeGenerator(codeGenerator_), context(context_){};
   virtual ~ExpressionCodeGenerator(){};
 
   /**
@@ -58,7 +57,7 @@ class GD_CORE_API ExpressionCodeGenerator : public ExpressionParser2NodeWorker {
   static gd::String GenerateExpressionCode(EventsCodeGenerator& codeGenerator,
                                            EventsCodeGenerationContext& context,
                                            const gd::String& type,
-                                           const gd::Expression& expression,
+                                           const gd::String& expression,
                                            const gd::String& objectName = "");
 
   const gd::String& GetOutput() { return output; };
@@ -104,8 +103,6 @@ class GD_CORE_API ExpressionCodeGenerator : public ExpressionParser2NodeWorker {
   gd::String output;
   EventsCodeGenerator& codeGenerator;
   EventsCodeGenerationContext& context;
-  const gd::String rootType;
-  const gd::String rootObjectName;
 };
 
 }  // namespace gd

Core/GDCore/Events/Event.cpp

@@ -5,11 +5,8 @@
  */
 
 #include "GDCore/Events/Event.h"
-
-#include "GDCore/Events/Builtin/AsyncEvent.h"
 #include "GDCore/Events/CodeGeneration/EventsCodeGenerator.h"
 #include "GDCore/Events/EventsList.h"
-#include "GDCore/Extensions/Metadata/MetadataProvider.h"
 #include "GDCore/Extensions/Platform.h"
 #include "GDCore/Extensions/PlatformExtension.h"
 
@@ -68,40 +65,10 @@ gd::String BaseEvent::GenerateEventCode(
   return "";
 }
 
-void BaseEvent::PreprocessAsyncActions(const gd::Platform& platform) {
-  if (!CanHaveSubEvents()) return;
-  for (const auto& actionsList : GetAllActionsVectors())
-    for (std::size_t aId = 0; aId < actionsList->size(); ++aId) {
-      const auto& action = actionsList->at(aId);
-      const gd::InstructionMetadata& actionMetadata =
-          gd::MetadataProvider::GetActionMetadata(platform, action.GetType());
-      if (actionMetadata.IsAsync()) {
-        gd::InstructionsList remainingActions;
-        remainingActions.InsertInstructions(
-            *actionsList, aId + 1, actionsList->size() - 1);
-        gd::AsyncEvent asyncEvent(action, remainingActions, GetSubEvents());
-
-        // Ensure that the local event no longer has any of the actions/subevent
-        // after the async function
-        actionsList->RemoveAfter(aId);
-        GetSubEvents().Clear();
-
-        GetSubEvents().InsertEvent(asyncEvent);
-
-        // We just moved all the rest, there's nothing left to do in this event.
-        return;
-      }
-    }
-};
-
 void BaseEvent::Preprocess(gd::EventsCodeGenerator& codeGenerator,
                            gd::EventsList& eventList,
                            std::size_t indexOfTheEventInThisList) {
-  if (IsDisabled()) return;
-
-  PreprocessAsyncActions(codeGenerator.GetPlatform());
-
-  if (!MustBePreprocessed()) return;
+  if (IsDisabled() || !MustBePreprocessed()) return;
 
   try {
     if (type.empty()) return;

Core/GDCore/Events/Event.h

@@ -10,7 +10,6 @@
 #include <iostream>
 #include <memory>
 #include <vector>
-
 #include "GDCore/Events/Instruction.h"
 #include "GDCore/Events/InstructionsList.h"
 #include "GDCore/Extensions/Metadata/InstructionMetadata.h"
@@ -24,7 +23,7 @@ class EventsCodeGenerationContext;
 class Platform;
 class SerializerElement;
 class Instruction;
-}  // namespace gd
+}
 
 namespace gd {
 
@@ -137,15 +136,13 @@ class GD_CORE_API BaseEvent {
    * \note Used to preprocess or search in the expressions of the event.
    */
   virtual std::vector<std::pair<gd::Expression*, gd::ParameterMetadata> >
-  GetAllExpressionsWithMetadata() {
+      GetAllExpressionsWithMetadata() {
     std::vector<std::pair<gd::Expression*, gd::ParameterMetadata> > noExpr;
     return 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;
+  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;
   };
 
@@ -209,11 +206,6 @@ class GD_CORE_API BaseEvent {
                           gd::EventsList& eventList,
                           std::size_t indexOfTheEventInThisList);
 
-  /**
-   * A function that turns all async member actions into an Async subevent for code generation.
-   */
-  void PreprocessAsyncActions(const gd::Platform& platform);
-
   /**
    * \brief If MustBePreprocessed is redefined to return true, the
    * gd::EventMetadata::preprocessing associated to the event will be called to

Core/GDCore/Events/Expression.cpp

@@ -1,41 +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/Expression.h"
-
-#include "GDCore/Events/Parsers/ExpressionParser2.h"
-#include "GDCore/String.h"
-
-namespace gd {
-
-Expression::Expression() : node(nullptr) {};
-
-Expression::Expression(gd::String plainString_)
-    : node(nullptr), plainString(plainString_) {};
-
-Expression::Expression(const char* plainString_)
-    : node(nullptr), plainString(plainString_) {};
-
-Expression::Expression(const Expression& copy)
-    : node(nullptr), plainString{copy.plainString} {};
-
-Expression& Expression::operator=(const Expression& expression) {
-  plainString = expression.plainString;
-  node = nullptr;
-  return *this;
-};
-
-Expression::~Expression(){};
-
-ExpressionNode* Expression::GetRootNode() const {
-  if (!node) {
-    gd::ExpressionParser2 parser = ExpressionParser2();
-    node = std::move(parser.ParseExpression(plainString));
-  }
-  return node.get();
-}
-
-}  // namespace gd

Core/GDCore/Events/Expression.h

@@ -6,15 +6,7 @@
 
 #ifndef GDCORE_EXPRESSION_H
 #define GDCORE_EXPRESSION_H
-
 #include "GDCore/String.h"
-#include <memory>
-
-namespace gd {
-class ExpressionParser2;
-class ObjectsContainer;
-struct ExpressionNode;
-}  // namespace gd
 
 namespace gd {
 
@@ -32,49 +24,32 @@ class GD_CORE_API Expression {
   /**
    * \brief Construct an empty expression
    */
-  Expression();
+  Expression(){};
 
   /**
    * \brief Construct an expression from a string
    */
-  Expression(gd::String plainString_);
+  Expression(gd::String plainString_) : plainString(plainString_){};
 
   /**
    * \brief Construct an expression from a const char *
    */
-  Expression(const char* plainString_);
-
-  /**
-   * \brief Copy construct an expression.
-   */
-  Expression(const Expression& copy);
-
-  /**
-   * \brief Expression affectation overriding.
-   */
-  Expression& operator=(const Expression& expression);
+  Expression(const char* plainString_) : plainString(plainString_){};
 
   /**
    * \brief Get the plain string representing the expression
    */
   inline const gd::String& GetPlainString() const { return plainString; };
 
-  /**
-   * @brief Get the expression node.
-   * @return std::unique_ptr<gd::ExpressionNode>
-   */
-  gd::ExpressionNode* GetRootNode() const;
-
   /**
    * \brief Mimics std::string::c_str
    */
   inline const char* c_str() const { return plainString.c_str(); };
 
-  virtual ~Expression();
+  virtual ~Expression(){};
 
  private:
   gd::String plainString;  ///< The expression string
-  mutable std::unique_ptr<gd::ExpressionNode> node;
 };
 
 }  // namespace gd

Core/GDCore/Events/InstructionsList.cpp

@@ -5,7 +5,6 @@
  */
 
 #include "InstructionsList.h"
-
 #include "GDCore/Events/Instruction.h"
 #include "GDCore/Project/Project.h"
 #include "Serialization.h"
@@ -32,10 +31,6 @@ void InstructionsList::InsertInstructions(const InstructionsList& list,
   }
 }
 
-void InstructionsList::RemoveAfter(const size_t position) {
-  elements.resize(position);
-}
-
 void InstructionsList::SerializeTo(SerializerElement& element) const {
   EventsListSerialization::SerializeInstructionsTo(*this, element);
 }

Core/GDCore/Events/InstructionsList.h

@@ -6,10 +6,9 @@
 
 #ifndef GDCORE_INSTRUCTIONSLIST_H
 #define GDCORE_INSTRUCTIONSLIST_H
-#include "GDCore/Tools/SPtrList.h"
 #include <memory>
 #include <vector>
-
+#include "GDCore/Tools/SPtrList.h"
 namespace gd {
 class Instruction;
 }
@@ -23,11 +22,11 @@ class SerializerElement;
 namespace gd {
 
 class InstructionsList : public SPtrList<gd::Instruction> {
-public:
-  void InsertInstructions(const InstructionsList &list, size_t begin,
-                          size_t end, size_t position = (size_t)-1);
-
-  void RemoveAfter(size_t position);
+ public:
+  void InsertInstructions(const InstructionsList& list,
+                          size_t begin,
+                          size_t end,
+                          size_t position = (size_t)-1);
 
   /** \name Serialization
    */
@@ -36,17 +35,17 @@ public:
    * \brief Serialize the instructions to the specified element
    * \see EventsListSerialization
    */
-  void SerializeTo(gd::SerializerElement &element) const;
+  void SerializeTo(gd::SerializerElement& element) const;
 
   /**
    * \brief Load the instructions from the specified element
    * \see EventsListSerialization
    */
-  void UnserializeFrom(gd::Project &project,
-                       const gd::SerializerElement &element);
+  void UnserializeFrom(gd::Project& project,
+                       const gd::SerializerElement& element);
   ///@}
 };
 
-} // namespace gd
+}  // namespace gd
 
 #endif

Core/GDCore/Events/Parsers/ExpressionParser2.cpp

@@ -26,16 +26,132 @@ namespace gd {
 
 gd::String ExpressionParser2::NAMESPACE_SEPARATOR = "::";
 
-ExpressionParser2::ExpressionParser2()
+ExpressionParser2::ExpressionParser2(
+    const gd::Platform& platform_,
+    const gd::ObjectsContainer& globalObjectsContainer_,
+    const gd::ObjectsContainer& objectsContainer_)
     : expression(""),
-      currentPosition(0) {}
+      currentPosition(0),
+      platform(platform_),
+      globalObjectsContainer(globalObjectsContainer_),
+      objectsContainer(objectsContainer_) {}
+
+namespace {
+/**
+ * Return the minimum number of parameters, starting from a given parameter
+ * (by convention, 1 for object functions and 2 for behavior functions).
+ */
+size_t GetMinimumParametersNumber(
+    const std::vector<gd::ParameterMetadata>& parameters,
+    size_t initialParameterIndex) {
+  size_t nb = 0;
+  for (std::size_t i = initialParameterIndex; i < parameters.size(); ++i) {
+    if (!parameters[i].optional && !parameters[i].codeOnly) nb++;
+  }
+
+  return nb;
+}
+
+/**
+ * Return the maximum number of parameters, starting from a given parameter
+ * (by convention, 1 for object functions and 2 for behavior functions).
+ */
+size_t GetMaximumParametersNumber(
+    const std::vector<gd::ParameterMetadata>& parameters,
+    size_t initialParameterIndex) {
+  size_t nb = 0;
+  for (std::size_t i = initialParameterIndex; i < parameters.size(); ++i) {
+    if (!parameters[i].codeOnly) nb++;
+  }
+
+  return nb;
+}
+}  // namespace
+
+std::unique_ptr<ExpressionParserDiagnostic> ExpressionParser2::ValidateFunction(
+    const gd::String& type,
+    const gd::FunctionCallNode& function,
+    size_t functionStartPosition) {
+  if (gd::MetadataProvider::IsBadExpressionMetadata(
+          function.expressionMetadata)) {
+    return gd::make_unique<ExpressionParserError>(
+        "invalid_function_name",
+        _("Cannot find an expression with this name: ") +
+            function.functionName + "\n" +
+            _("Double check that you've not made any typo in the name."),
+        functionStartPosition,
+        GetCurrentPosition());
+  }
+
+  // Validate the type of the function
+  const gd::String& returnType = function.expressionMetadata.GetReturnType();
+  if (returnType == "number") {
+    if (type == "string")
+      return RaiseTypeError(
+          _("You tried to use an expression that returns a number, but a "
+            "string is expected. Use `ToString` if you need to convert a "
+            "number to a string."),
+          functionStartPosition);
+    else if (type != "number" && type != "number|string")
+      return RaiseTypeError(_("You tried to use an expression that returns a "
+                              "number, but another type is expected:") +
+                              " " + type,
+                            functionStartPosition);
+  } else if (returnType == "string") {
+    if (type == "number")
+      return RaiseTypeError(
+          _("You tried to use an expression that returns a string, but a "
+            "number is expected. Use `ToNumber` if you need to convert a "
+            "string to a number."),
+          functionStartPosition);
+    else if (type != "string" && type != "number|string")
+      return RaiseTypeError(_("You tried to use an expression that returns a "
+                              "string, but another type is expected:") +
+                              " " + type,
+                            functionStartPosition);
+  } else {
+    if (type != returnType)
+      return RaiseTypeError(
+          _("You tried to use an expression with the wrong return type:") + " " +
+            returnType,
+          functionStartPosition);
+  }
+
+  // Validate parameters count
+  size_t minParametersCount = GetMinimumParametersNumber(
+      function.expressionMetadata.parameters,
+      WrittenParametersFirstIndex(function.objectName, function.behaviorName));
+  size_t maxParametersCount = GetMaximumParametersNumber(
+      function.expressionMetadata.parameters,
+      WrittenParametersFirstIndex(function.objectName, function.behaviorName));
+  if (function.parameters.size() < minParametersCount ||
+      function.parameters.size() > maxParametersCount) {
+    gd::String expectedCountMessage =
+        minParametersCount == maxParametersCount
+            ? _("The number of parameters must be exactly ") +
+                  gd::String::From(minParametersCount)
+            : _("The number of parameters must be: ") +
+                  gd::String::From(minParametersCount) + "-" +
+                  gd::String::From(maxParametersCount);
+
+    if (function.parameters.size() < minParametersCount) {
+      return gd::make_unique<ExpressionParserError>(
+          "too_few_parameters",
+          "You have not entered enough parameters for the expression. " +
+              expectedCountMessage,
+          functionStartPosition,
+          GetCurrentPosition());
+    }
+  }
+
+  return gd::make_unique<ExpressionParserDiagnostic>();
+}
 
 std::unique_ptr<TextNode> ExpressionParser2::ReadText() {
   size_t textStartPosition = GetCurrentPosition();
   SkipAllWhitespaces();
   if (!CheckIfChar(IsQuote)) {
     auto text = gd::make_unique<TextNode>("");
-	  // It can't happen.
     text->diagnostic =
         RaiseSyntaxError(_("A text must start with a double quote (\")."));
     text->location =

Core/GDCore/Events/Parsers/ExpressionParser2.h

@@ -40,7 +40,9 @@ namespace gd {
  */
 class GD_CORE_API ExpressionParser2 {
  public:
-  ExpressionParser2();
+  ExpressionParser2(const gd::Platform &platform_,
+                    const gd::ObjectsContainer &globalObjectsContainer_,
+                    const gd::ObjectsContainer &objectsContainer_);
   virtual ~ExpressionParser2(){};
 
   /**
@@ -56,11 +58,13 @@ class GD_CORE_API ExpressionParser2 {
    * \return The node representing the expression as a parsed tree.
    */
   std::unique_ptr<ExpressionNode> ParseExpression(
-      const gd::String &expression_) {
+      const gd::String &type,
+      const gd::String &expression_,
+      const gd::String &objectName = "") {
     expression = expression_;
 
     currentPosition = 0;
-    return Start();
+    return Start(type, objectName);
   }
 
   /**
@@ -84,16 +88,18 @@ class GD_CORE_API ExpressionParser2 {
    * Each method is a part of the grammar.
    */
   ///@{
-  std::unique_ptr<ExpressionNode> Start() {
+  std::unique_ptr<ExpressionNode> Start(const gd::String &type,
+                                        const gd::String &objectName = "") {
     size_t expressionStartPosition = GetCurrentPosition();
-    auto expression = Expression();
+    auto expression = Expression(type, objectName);
+
+    const gd::String &inferredType = expression->type;
 
     // Check for extra characters at the end of the expression
     if (!IsEndReached()) {
-      auto op = gd::make_unique<OperatorNode>(' ');
+      auto op = gd::make_unique<OperatorNode>(inferredType, ' ');
       op->leftHandSide = std::move(expression);
-      op->rightHandSide = ReadUntilEnd();
-      op->rightHandSide->parent = op.get();
+      op->rightHandSide = ReadUntilEnd("unknown");
 
       op->rightHandSide->diagnostic = RaiseSyntaxError(
           _("The expression has extra character at the end that should be "
@@ -107,49 +113,61 @@ class GD_CORE_API ExpressionParser2 {
     return expression;
   }
 
-  std::unique_ptr<ExpressionNode> Expression() {
+  std::unique_ptr<ExpressionNode> Expression(
+      const gd::String &type, const gd::String &objectName = "") {
     SkipAllWhitespaces();
 
     size_t expressionStartPosition = GetCurrentPosition();
-    std::unique_ptr<ExpressionNode> leftHandSide = Term();
+    std::unique_ptr<ExpressionNode> leftHandSide = Term(type, objectName);
+
+    const gd::String &inferredType = leftHandSide->type;
 
     SkipAllWhitespaces();
 
     if (IsEndReached()) return leftHandSide;
     if (CheckIfChar(IsExpressionEndingChar)) return leftHandSide;
     if (CheckIfChar(IsExpressionOperator)) {
-      auto op = gd::make_unique<OperatorNode>(GetCurrentChar());
+      auto op = gd::make_unique<OperatorNode>(inferredType, GetCurrentChar());
       op->leftHandSide = std::move(leftHandSide);
-      op->leftHandSide->parent = op.get();
-      op->diagnostic = ValidateOperator(GetCurrentChar());
+      op->diagnostic = ValidateOperator(inferredType, GetCurrentChar());
       SkipChar();
-      op->rightHandSide = Expression();
-      op->rightHandSide->parent = op.get();
+      op->rightHandSide = Expression(inferredType, objectName);
 
       op->location = ExpressionParserLocation(expressionStartPosition,
                                               GetCurrentPosition());
       return std::move(op);
     }
 
-    leftHandSide->diagnostic = RaiseSyntaxError(
-        "More than one term was found. Verify that your expression is "
-        "properly written.");
+    if (inferredType == "string") {
+      leftHandSide->diagnostic = RaiseSyntaxError(
+          "You must add the operator + between texts or expressions. For "
+          "example: \"Your name: \" + VariableString(PlayerName).");
+    } else if (inferredType == "number") {
+      leftHandSide->diagnostic = RaiseSyntaxError(
+          "No operator found. Did you forget to enter an operator (like +, -, "
+          "* or /) between numbers or expressions?");
+    } else {
+      leftHandSide->diagnostic = RaiseSyntaxError(
+          "More than one term was found. Verify that your expression is "
+          "properly written.");
+    }
 
-    auto op = gd::make_unique<OperatorNode>(' ');
+    auto op = gd::make_unique<OperatorNode>(inferredType, ' ');
     op->leftHandSide = std::move(leftHandSide);
-    op->leftHandSide->parent = op.get();
-    op->rightHandSide = Expression();
-    op->rightHandSide->parent = op.get();
+    op->rightHandSide = Expression(inferredType, objectName);
     op->location =
         ExpressionParserLocation(expressionStartPosition, GetCurrentPosition());
     return std::move(op);
   }
 
-  std::unique_ptr<ExpressionNode> Term() {
+  std::unique_ptr<ExpressionNode> Term(const gd::String &type,
+                                       const gd::String &objectName) {
     SkipAllWhitespaces();
 
     size_t expressionStartPosition = GetCurrentPosition();
-    std::unique_ptr<ExpressionNode> factor = Factor();
+    std::unique_ptr<ExpressionNode> factor = Factor(type, objectName);
+
+    const gd::String &inferredType = factor->type;
 
     SkipAllWhitespaces();
 
@@ -157,13 +175,11 @@ class GD_CORE_API ExpressionParser2 {
     // to guarantee the proper operator precedence. (Expression could also
     // be reworked to use a while loop).
     while (CheckIfChar(IsTermOperator)) {
-      auto op = gd::make_unique<OperatorNode>(GetCurrentChar());
+      auto op = gd::make_unique<OperatorNode>(inferredType, GetCurrentChar());
       op->leftHandSide = std::move(factor);
-      op->leftHandSide->parent = op.get();
-      op->diagnostic = ValidateOperator(GetCurrentChar());
+      op->diagnostic = ValidateOperator(inferredType, GetCurrentChar());
       SkipChar();
-      op->rightHandSide = Factor();
-      op->rightHandSide->parent = op.get();
+      op->rightHandSide = Factor(inferredType, objectName);
       op->location = ExpressionParserLocation(expressionStartPosition,
                                               GetCurrentPosition());
       SkipAllWhitespaces();
@@ -174,35 +190,54 @@ class GD_CORE_API ExpressionParser2 {
     return factor;
   };
 
-  std::unique_ptr<ExpressionNode> Factor() {
+  std::unique_ptr<ExpressionNode> Factor(const gd::String &type,
+                                         const gd::String &objectName) {
     SkipAllWhitespaces();
     size_t expressionStartPosition = GetCurrentPosition();
 
     if (CheckIfChar(IsQuote)) {
       std::unique_ptr<ExpressionNode> factor = ReadText();
+      if (type == "number")
+        factor->diagnostic =
+            RaiseTypeError(_("You entered a text, but a number was expected."),
+                           expressionStartPosition);
+      else if (type != "string" && type != "number|string")
+        factor->diagnostic = RaiseTypeError(
+            _("You entered a text, but this type was expected:") + type,
+            expressionStartPosition);
+
       return factor;
     } else if (CheckIfChar(IsUnaryOperator)) {
       auto unaryOperatorCharacter = GetCurrentChar();
       SkipChar();
 
-      auto operatorOperand = Factor();
+      auto operatorOperand = Factor(type, objectName);
+      const gd::String &inferredType = operatorOperand->type;
 
       auto unaryOperator = gd::make_unique<UnaryOperatorNode>(
-          unaryOperatorCharacter);
+          inferredType, unaryOperatorCharacter);
       unaryOperator->diagnostic = ValidateUnaryOperator(
-          unaryOperatorCharacter, expressionStartPosition);
+          inferredType, unaryOperatorCharacter, expressionStartPosition);
       unaryOperator->factor = std::move(operatorOperand);
-      unaryOperator->factor->parent = unaryOperator.get();
       unaryOperator->location = ExpressionParserLocation(
           expressionStartPosition, GetCurrentPosition());
 
       return std::move(unaryOperator);
     } else if (CheckIfChar(IsNumberFirstChar)) {
       std::unique_ptr<ExpressionNode> factor = ReadNumber();
+      if (type == "string")
+        factor->diagnostic = RaiseTypeError(
+            _("You entered a number, but a text was expected (in quotes)."),
+            expressionStartPosition);
+      else if (type != "number" && type != "number|string")
+        factor->diagnostic = RaiseTypeError(
+            _("You entered a number, but this type was expected:") + type,
+            expressionStartPosition);
+
       return factor;
     } else if (CheckIfChar(IsOpeningParenthesis)) {
       SkipChar();
-      std::unique_ptr<ExpressionNode> factor = SubExpression();
+      std::unique_ptr<ExpressionNode> factor = SubExpression(type, objectName);
 
       if (!CheckIfChar(IsClosingParenthesis)) {
         factor->diagnostic =
@@ -212,20 +247,29 @@ class GD_CORE_API ExpressionParser2 {
       SkipIfChar(IsClosingParenthesis);
       return factor;
     } else if (IsIdentifierAllowedChar()) {
-      return Identifier();
+      // This is a place where the grammar differs according to the
+      // type being expected.
+      if (gd::ParameterMetadata::IsExpression("variable", type)) {
+        return Variable(type, objectName);
+      } else {
+        return Identifier(type);
+      }
     }
 
-    std::unique_ptr<ExpressionNode> factor = ReadUntilWhitespace();
+    std::unique_ptr<ExpressionNode> factor = ReadUntilWhitespace(type);
+    factor->diagnostic = RaiseEmptyError(type, expressionStartPosition);
     return factor;
   }
 
-  std::unique_ptr<SubExpressionNode> SubExpression() {
+  std::unique_ptr<SubExpressionNode> SubExpression(
+      const gd::String &type, const gd::String &objectName) {
     size_t expressionStartPosition = GetCurrentPosition();
 
-    auto expression = Expression();
+    auto expression = Expression(type, objectName);
+    const gd::String &inferredType = expression->type;
 
     auto subExpression =
-        gd::make_unique<SubExpressionNode>(std::move(expression));
+        gd::make_unique<SubExpressionNode>(inferredType, std::move(expression));
     subExpression->location =
         ExpressionParserLocation(expressionStartPosition, GetCurrentPosition());
 
@@ -233,7 +277,7 @@ class GD_CORE_API ExpressionParser2 {
   };
 
   std::unique_ptr<IdentifierOrFunctionCallOrObjectFunctionNameOrEmptyNode>
-  Identifier() {
+  Identifier(const gd::String &type) {
     auto identifierAndLocation = ReadIdentifierName();
     gd::String name = identifierAndLocation.name;
     auto nameLocation = identifierAndLocation.location;
@@ -260,28 +304,47 @@ class GD_CORE_API ExpressionParser2 {
 
     if (CheckIfChar(IsOpeningParenthesis)) {
       ExpressionParserLocation openingParenthesisLocation = SkipChar();
-      return FreeFunction(name, nameLocation, openingParenthesisLocation);
+      return FreeFunction(type, name, nameLocation, openingParenthesisLocation);
     } else if (CheckIfChar(IsDot)) {
       ExpressionParserLocation dotLocation = SkipChar();
       SkipAllWhitespaces();
       return ObjectFunctionOrBehaviorFunction(
-          name, nameLocation, dotLocation);
-    } else if (CheckIfChar(IsOpeningSquareBracket)) {
-      return Variable(name, nameLocation);
-    }
-    else {
-      auto identifier = gd::make_unique<IdentifierNode>(name);
+          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\")."),
+                           nameLocation.GetStartPosition());
+      } else if (type == "number") {
+        identifier->diagnostic = RaiseTypeError(
+            _("You must enter a number."), nameLocation.GetStartPosition());
+      } else if (type == "number|string") {
+        identifier->diagnostic = RaiseTypeError(
+            _("You must enter a number or a text, wrapped inside double quotes "
+              "(example: \"Hello world\")."),
+            nameLocation.GetStartPosition());
+      } else if (!gd::ParameterMetadata::IsObject(type)) {
+        identifier->diagnostic = RaiseTypeError(
+            _("You've entered a name, but this type was expected:") + type,
+            nameLocation.GetStartPosition());
+      }
+
       identifier->location = ExpressionParserLocation(
           nameLocation.GetStartPosition(), GetCurrentPosition());
-      identifier->identifierNameLocation = identifier->location;
       return std::move(identifier);
     }
   }
 
-  std::unique_ptr<VariableNode> Variable(const gd::String &name, gd::ExpressionParserLocation nameLocation) {
-    auto variable = gd::make_unique<VariableNode>(name);
+  std::unique_ptr<VariableNode> Variable(const gd::String &type,
+                                         const gd::String &objectName) {
+    auto identifierAndLocation = ReadIdentifierName();
+    const gd::String &name = identifierAndLocation.name;
+    const auto &nameLocation = identifierAndLocation.location;
+
+    auto variable = gd::make_unique<VariableNode>(type, name, objectName);
     variable->child = VariableAccessorOrVariableBracketAccessor();
-    variable->child->parent = variable.get();
 
     variable->location = ExpressionParserLocation(
         nameLocation.GetStartPosition(), GetCurrentPosition());
@@ -296,8 +359,8 @@ class GD_CORE_API ExpressionParser2 {
     SkipAllWhitespaces();
     if (CheckIfChar(IsOpeningSquareBracket)) {
       SkipChar();
-      auto child = gd::make_unique<VariableBracketAccessorNode>(Expression());
-      child->expression->parent = child.get();
+      auto child = gd::make_unique<VariableBracketAccessorNode>(
+          Expression("number|string"));
 
       if (!CheckIfChar(IsClosingSquareBracket)) {
         child->diagnostic =
@@ -306,7 +369,6 @@ class GD_CORE_API ExpressionParser2 {
       }
       SkipIfChar(IsClosingSquareBracket);
       child->child = VariableAccessorOrVariableBracketAccessor();
-      child->child->parent = child.get();
       child->location =
           ExpressionParserLocation(childStartPosition, GetCurrentPosition());
 
@@ -319,7 +381,6 @@ class GD_CORE_API ExpressionParser2 {
       auto child =
           gd::make_unique<VariableAccessorNode>(identifierAndLocation.name);
       child->child = VariableAccessorOrVariableBracketAccessor();
-      child->child->parent = child.get();
       child->nameLocation = identifierAndLocation.location;
       child->dotLocation = dotLocation;
       child->location =
@@ -328,21 +389,40 @@ class GD_CORE_API ExpressionParser2 {
       return std::move(child);
     }
 
-    return std::move(gd::make_unique<VariableAccessorOrVariableBracketAccessorNode>());
+    return std::move(
+        std::unique_ptr<VariableAccessorOrVariableBracketAccessorNode>());
   }
 
   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
 
+    const gd::ExpressionMetadata &metadata =
+        MetadataProvider::GetAnyExpressionMetadata(platform, functionFullName);
+
+    // In case we can't find a valid expression, ensure the node has the type
+    // that is requested by the parent, so we avoid putting "unknown" (which
+    // would be also correct, but less precise and would prevent completions to
+    // be shown to the user)
+    const gd::String returnType =
+        gd::MetadataProvider::IsBadExpressionMetadata(metadata) == true
+            ? type
+            : metadata.GetReturnType();
+
+    auto parametersNode = Parameters(metadata.parameters);
     auto function =
-        gd::make_unique<FunctionCallNode>(functionFullName);
-    auto parametersNode = Parameters(function.get());
-    function->parameters = std::move(parametersNode.parameters);
+        gd::make_unique<FunctionCallNode>(returnType,
+                                          std::move(parametersNode.parameters),
+                                          metadata,
+                                          functionFullName);
     function->diagnostic = std::move(parametersNode.diagnostic);
+    if (!function->diagnostic)  // TODO: reverse the order of diagnostic?
+      function->diagnostic = ValidateFunction(
+          type, *function, identifierLocation.GetStartPosition());
 
     function->location = ExpressionParserLocation(
         identifierLocation.GetStartPosition(), GetCurrentPosition());
@@ -354,15 +434,16 @@ class GD_CORE_API ExpressionParser2 {
     return std::move(function);
   }
 
-  std::unique_ptr<IdentifierOrFunctionCallOrObjectFunctionNameOrEmptyNode>
+  std::unique_ptr<FunctionCallOrObjectFunctionNameOrEmptyNode>
   ObjectFunctionOrBehaviorFunction(
-      const gd::String &parentIdentifier,
-      const ExpressionParserLocation &parentIdentifierLocation,
-      const ExpressionParserLocation &parentIdentifierDotLocation) {
-    auto childIdentifierAndLocation = ReadIdentifierName();
-    const gd::String &childIdentifierName = childIdentifierAndLocation.name;
-    const auto &childIdentifierNameLocation =
-        childIdentifierAndLocation.location;
+      const gd::String &type,
+      const gd::String &objectName,
+      const ExpressionParserLocation &objectNameLocation,
+      const ExpressionParserLocation &objectNameDotLocation) {
+    auto identifierAndLocation = ReadIdentifierName();
+    const gd::String &objectFunctionOrBehaviorName = identifierAndLocation.name;
+    const auto &objectFunctionOrBehaviorNameLocation =
+        identifierAndLocation.location;
 
     SkipAllWhitespaces();
 
@@ -370,68 +451,87 @@ class GD_CORE_API ExpressionParser2 {
       ExpressionParserLocation namespaceSeparatorLocation =
           SkipNamespaceSeparator();
       SkipAllWhitespaces();
-      return BehaviorFunction(parentIdentifier,
-                              childIdentifierName,
-                              parentIdentifierLocation,
-                              parentIdentifierDotLocation,
-                              childIdentifierNameLocation,
+      return BehaviorFunction(type,
+                              objectName,
+                              objectFunctionOrBehaviorName,
+                              objectNameLocation,
+                              objectNameDotLocation,
+                              objectFunctionOrBehaviorNameLocation,
                               namespaceSeparatorLocation);
     } else if (CheckIfChar(IsOpeningParenthesis)) {
       ExpressionParserLocation openingParenthesisLocation = SkipChar();
 
+      gd::String objectType =
+          GetTypeOfObject(globalObjectsContainer, objectsContainer, objectName);
+
+      const gd::ExpressionMetadata &metadata =
+          MetadataProvider::GetObjectAnyExpressionMetadata(
+              platform, objectType, objectFunctionOrBehaviorName);
+
+      // In case we can't find a valid expression, ensure the node has the type
+      // that is requested by the parent, so we avoid putting "unknown" (which
+      // would be also correct, but less precise and would prevent completions
+      // to be shown to the user)
+      const gd::String returnType =
+          gd::MetadataProvider::IsBadExpressionMetadata(metadata) == true
+              ? type
+              : metadata.GetReturnType();
+
+      auto parametersNode = Parameters(metadata.parameters, objectName);
       auto function = gd::make_unique<FunctionCallNode>(
-          parentIdentifier,
-          childIdentifierName);
-      auto parametersNode = Parameters(function.get(), parentIdentifier);
-      function->parameters = std::move(parametersNode.parameters),
+          returnType,
+          objectName,
+          std::move(parametersNode.parameters),
+          metadata,
+          objectFunctionOrBehaviorName);
       function->diagnostic = std::move(parametersNode.diagnostic);
 
+      if (!function->diagnostic)  // TODO: reverse the order of diagnostic?
+        function->diagnostic = ValidateFunction(
+            type, *function, objectNameLocation.GetStartPosition());
+
+      // If the function needs a capability on the object that may not be covered
+      // by all objects, check it now.
+      if (!metadata.GetRequiredBaseObjectCapability().empty()) {
+        const gd::ObjectMetadata &objectMetadata =
+            MetadataProvider::GetObjectMetadata(platform, objectType);
+
+        if (objectMetadata.IsUnsupportedBaseObjectCapability(
+                metadata.GetRequiredBaseObjectCapability())) {
+          function->diagnostic = RaiseTypeError(
+              _("This expression exists, but it can't be used on this object."),
+              objectNameLocation.GetStartPosition());
+        }
+      }
+
       function->location = ExpressionParserLocation(
-          parentIdentifierLocation.GetStartPosition(), GetCurrentPosition());
-      function->objectNameLocation = parentIdentifierLocation;
-      function->objectNameDotLocation = parentIdentifierDotLocation;
-      function->functionNameLocation = childIdentifierNameLocation;
+          objectNameLocation.GetStartPosition(), GetCurrentPosition());
+      function->objectNameLocation = objectNameLocation;
+      function->objectNameDotLocation = objectNameDotLocation;
+      function->functionNameLocation = objectFunctionOrBehaviorNameLocation;
       function->openingParenthesisLocation = openingParenthesisLocation;
       function->closingParenthesisLocation =
           parametersNode.closingParenthesisLocation;
       return std::move(function);
-    } else if (CheckIfChar(IsDot) || CheckIfChar(IsOpeningSquareBracket)) {
-      auto variable = gd::make_unique<VariableNode>(parentIdentifier);
-      auto child =
-          gd::make_unique<VariableAccessorNode>(childIdentifierName);
-      child->child = VariableAccessorOrVariableBracketAccessor();
-      child->child->parent = child.get();
-      child->nameLocation = childIdentifierNameLocation;
-      child->dotLocation = parentIdentifierDotLocation;
-      child->location = ExpressionParserLocation(
-          parentIdentifierDotLocation.GetStartPosition(), GetCurrentPosition());
-      variable->child = std::move(child);
-      variable->child->parent = variable.get();
-
-      variable->location = ExpressionParserLocation(
-          parentIdentifierLocation.GetStartPosition(), GetCurrentPosition());
-      variable->nameLocation = parentIdentifierLocation;
-
-      return std::move(variable);
     }
 
-    auto node = gd::make_unique<IdentifierNode>(
-        parentIdentifier, childIdentifierName);
-    if (!CheckIfChar(IsParameterSeparator) && !CheckIfChar(IsClosingParenthesis) && !IsEndReached()) {
-      node->diagnostic = RaiseSyntaxError(
-          _("An opening parenthesis (for an object expression), a double colon "
-            "(:: for a behavior expression), a dot or an opening bracket (for "
-            "a child variable) where expected."));
-    }
+    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(
-        parentIdentifierLocation.GetStartPosition(), GetCurrentPosition());
-    node->identifierNameLocation = parentIdentifierLocation;
-    node->identifierNameDotLocation = parentIdentifierDotLocation;
-    node->childIdentifierNameLocation = childIdentifierNameLocation;
+        objectNameLocation.GetStartPosition(), GetCurrentPosition());
+    node->objectNameLocation = objectNameLocation;
+    node->objectNameDotLocation = objectNameDotLocation;
+    node->objectFunctionOrBehaviorNameLocation =
+        objectFunctionOrBehaviorNameLocation;
     return std::move(node);
   }
 
   std::unique_ptr<FunctionCallOrObjectFunctionNameOrEmptyNode> BehaviorFunction(
+      const gd::String &type,
       const gd::String &objectName,
       const gd::String &behaviorName,
       const ExpressionParserLocation &objectNameLocation,
@@ -447,14 +547,35 @@ class GD_CORE_API ExpressionParser2 {
     if (CheckIfChar(IsOpeningParenthesis)) {
       ExpressionParserLocation openingParenthesisLocation = SkipChar();
 
+      gd::String behaviorType = GetTypeOfBehavior(
+          globalObjectsContainer, objectsContainer, behaviorName);
+
+      const gd::ExpressionMetadata &metadata =
+          MetadataProvider::GetBehaviorAnyExpressionMetadata(
+              platform, behaviorType, functionName);
+
+      // In case we can't find a valid expression, ensure the node has the type
+      // that is requested by the parent, so we avoid putting "unknown" (which
+      // would be also correct, but less precise and would prevent completions
+      // to be shown to the user)
+      const gd::String returnType =
+          gd::MetadataProvider::IsBadExpressionMetadata(metadata) == true
+              ? type
+              : metadata.GetReturnType();
+
+      auto parametersNode =
+          Parameters(metadata.parameters, objectName, behaviorName);
       auto function = gd::make_unique<FunctionCallNode>(
+          returnType,
           objectName,
           behaviorName,
+          std::move(parametersNode.parameters),
+          metadata,
           functionName);
-      auto parametersNode =
-          Parameters(function.get(), objectName, behaviorName);
-      function->parameters = std::move(parametersNode.parameters);
       function->diagnostic = std::move(parametersNode.diagnostic);
+      if (!function->diagnostic)  // TODO: reverse the order of diagnostic?
+        function->diagnostic = ValidateFunction(
+            type, *function, objectNameLocation.GetStartPosition());
 
       function->location = ExpressionParserLocation(
           objectNameLocation.GetStartPosition(), GetCurrentPosition());
@@ -470,7 +591,7 @@ class GD_CORE_API ExpressionParser2 {
       return std::move(function);
     } else {
       auto node = gd::make_unique<ObjectFunctionNameNode>(
-          objectName, behaviorName, functionName);
+          type, objectName, behaviorName, functionName);
       node->diagnostic = RaiseSyntaxError(
           _("An opening parenthesis was expected here to call a function."));
 
@@ -494,7 +615,7 @@ class GD_CORE_API ExpressionParser2 {
   };
 
   ParametersNode Parameters(
-      FunctionCallNode *functionCallNode,
+      std::vector<gd::ParameterMetadata> parameterMetadata,
       const gd::String &objectName = "",
       const gd::String &behaviorName = "") {
     std::vector<std::unique_ptr<ExpressionNode>> parameters;
@@ -505,25 +626,77 @@ class GD_CORE_API ExpressionParser2 {
     size_t parameterIndex =
         WrittenParametersFirstIndex(objectName, behaviorName);
 
-    bool previousCharacterIsParameterSeparator = false;
     while (!IsEndReached()) {
       SkipAllWhitespaces();
 
-      if (CheckIfChar(IsClosingParenthesis) && !previousCharacterIsParameterSeparator) {
+      if (CheckIfChar(IsClosingParenthesis)) {
         auto closingParenthesisLocation = SkipChar();
         return ParametersNode{
             std::move(parameters), nullptr, closingParenthesisLocation};
-      }
-      bool isEmptyParameter = CheckIfChar(IsParameterSeparator)
-          || (CheckIfChar(IsClosingParenthesis) && previousCharacterIsParameterSeparator);
-      auto parameter = isEmptyParameter ? gd::make_unique<EmptyNode>() : Expression();
-      parameter->parent = functionCallNode;
-      parameters.push_back(std::move(parameter));
+      } else {
+        if (parameterIndex < parameterMetadata.size()) {
+          const gd::String &type = parameterMetadata[parameterIndex].GetType();
+          if (parameterMetadata[parameterIndex].IsCodeOnly()) {
+            // Do nothing, code only parameters are not written in expressions.
+          } else if (gd::ParameterMetadata::IsExpression("number", type)) {
+            parameters.push_back(Expression("number"));
+          } else if (gd::ParameterMetadata::IsExpression("string", type)) {
+            parameters.push_back(Expression("string"));
+          } else if (gd::ParameterMetadata::IsExpression("variable", type)) {
+            parameters.push_back(Expression(
+                type, lastObjectName.empty() ? objectName : lastObjectName));
+          } else if (gd::ParameterMetadata::IsObject(type)) {
+            size_t parameterStartPosition = GetCurrentPosition();
+            std::unique_ptr<ExpressionNode> objectExpression = Expression(type);
 
-      SkipAllWhitespaces();
-      previousCharacterIsParameterSeparator = CheckIfChar(IsParameterSeparator);
-      SkipIfChar(IsParameterSeparator);
-      parameterIndex++;
+            // 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"));
+            parameters.back()->diagnostic =
+                gd::make_unique<ExpressionParserError>(
+                    "unknown_parameter_type",
+                    _("This function is improperly set up. Reach out to the "
+                      "extension developer or a GDevelop maintainer to fix "
+                      "this issue"),
+                    parameterStartPosition,
+                    GetCurrentPosition());
+          }
+        } else {
+          size_t parameterStartPosition = GetCurrentPosition();
+          parameters.push_back(Expression("unknown"));
+          parameters.back()
+              ->diagnostic = gd::make_unique<ExpressionParserError>(
+              "extra_parameter",
+              _("This parameter was not expected by this expression. Remove it "
+                "or verify that you've entered the proper expression name."),
+              parameterStartPosition,
+              GetCurrentPosition());
+        }
+
+        SkipAllWhitespaces();
+        SkipIfChar(IsParameterSeparator);
+        parameterIndex++;
+      }
     }
 
     ExpressionParserLocation invalidClosingParenthesisLocation;
@@ -535,32 +708,92 @@ class GD_CORE_API ExpressionParser2 {
   }
   ///@}
 
+  /** \name Validators
+   * Return a diagnostic if any error is found
+   */
+  ///@{
+  std::unique_ptr<ExpressionParserDiagnostic> ValidateFunction(
+      const gd::String &type,
+      const gd::FunctionCallNode &function,
+      size_t functionStartPosition);
+
   std::unique_ptr<ExpressionParserDiagnostic> ValidateOperator(
-      gd::String::value_type operatorChar) {
-    if (operatorChar == '+' || operatorChar == '-' || operatorChar == '/' ||
-        operatorChar == '*') {
-      return gd::make_unique<ExpressionParserDiagnostic>();
+      const gd::String &type, gd::String::value_type operatorChar) {
+    if (type == "number") {
+      if (operatorChar == '+' || operatorChar == '-' || operatorChar == '/' ||
+          operatorChar == '*') {
+        return gd::make_unique<ExpressionParserDiagnostic>();
+      }
+
+      return gd::make_unique<ExpressionParserError>(
+          "invalid_operator",
+          _("You've used an operator that is not supported. Operator should be "
+            "either +, -, / or *."),
+          GetCurrentPosition());
+    } else if (type == "string") {
+      if (operatorChar == '+') {
+        return gd::make_unique<ExpressionParserDiagnostic>();
+      }
+
+      return gd::make_unique<ExpressionParserError>(
+          "invalid_operator",
+          _("You've used an operator that is not supported. Only + can be used "
+            "to concatenate texts."),
+          GetCurrentPosition());
+    } 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."),
+          GetCurrentPosition());
+    } else if (gd::ParameterMetadata::IsExpression("variable", type)) {
+      return gd::make_unique<ExpressionParserError>(
+          "invalid_operator",
+          _("Operators (+, -, /, *) can't be used in variable names. Remove "
+            "the operator from the variable name."),
+          GetCurrentPosition());
     }
-    return gd::make_unique<ExpressionParserError>(
-        "invalid_operator",
-        _("You've used an operator that is not supported. Operator should be "
-          "either +, -, / or *."),
-        GetCurrentPosition());
+
+    return gd::make_unique<ExpressionParserDiagnostic>();
   }
 
   std::unique_ptr<ExpressionParserDiagnostic> ValidateUnaryOperator(
+      const gd::String &type,
       gd::String::value_type operatorChar,
       size_t position) {
-    if (operatorChar == '+' || operatorChar == '-') {
-      return gd::make_unique<ExpressionParserDiagnostic>();
+    if (type == "number") {
+      if (operatorChar == '+' || operatorChar == '-') {
+        return gd::make_unique<ExpressionParserDiagnostic>();
+      }
+
+      return gd::make_unique<ExpressionParserError>(
+          "invalid_operator",
+          _("You've used an \"unary\" operator that is not supported. Operator "
+            "should be "
+            "either + or -."),
+          position);
+    } else if (type == "string") {
+      return gd::make_unique<ExpressionParserError>(
+          "invalid_operator",
+          _("You've used an operator that is not supported. Only + can be used "
+            "to concatenate texts, and must be placed between two texts (or "
+            "expressions)."),
+          position);
+    } 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."),
+          position);
+    } else if (gd::ParameterMetadata::IsExpression("variable", type)) {
+      return gd::make_unique<ExpressionParserError>(
+          "invalid_operator",
+          _("Operators (+, -) can't be used in variable names. Remove "
+            "the operator from the variable name."),
+          position);
     }
 
-    return gd::make_unique<ExpressionParserError>(
-        "invalid_operator",
-        _("You've used an \"unary\" operator that is not supported. Operator "
-          "should be "
-          "either + or -."),
-        position);
+    return gd::make_unique<ExpressionParserDiagnostic>();
   }
   ///@}
 
@@ -748,7 +981,7 @@ class GD_CORE_API ExpressionParser2 {
 
   std::unique_ptr<NumberNode> ReadNumber();
 
-  std::unique_ptr<EmptyNode> ReadUntilWhitespace() {
+  std::unique_ptr<EmptyNode> ReadUntilWhitespace(gd::String type) {
     size_t startPosition = GetCurrentPosition();
     gd::String text;
     while (currentPosition < expression.size() &&
@@ -757,13 +990,13 @@ class GD_CORE_API ExpressionParser2 {
       currentPosition++;
     }
 
-    auto node = gd::make_unique<EmptyNode>(text);
+    auto node = gd::make_unique<EmptyNode>(type, text);
     node->location =
         ExpressionParserLocation(startPosition, GetCurrentPosition());
     return node;
   }
 
-  std::unique_ptr<EmptyNode> ReadUntilEnd() {
+  std::unique_ptr<EmptyNode> ReadUntilEnd(gd::String type) {
     size_t startPosition = GetCurrentPosition();
     gd::String text;
     while (currentPosition < expression.size()) {
@@ -771,7 +1004,7 @@ class GD_CORE_API ExpressionParser2 {
       currentPosition++;
     }
 
-    auto node = gd::make_unique<EmptyNode>(text);
+    auto node = gd::make_unique<EmptyNode>(type, text);
     node->location =
         ExpressionParserLocation(startPosition, GetCurrentPosition());
     return node;
@@ -804,11 +1037,34 @@ class GD_CORE_API ExpressionParser2 {
     return std::move(gd::make_unique<ExpressionParserError>(
         "type_error", message, beginningPosition, GetCurrentPosition()));
   }
+
+  std::unique_ptr<ExpressionParserError> RaiseEmptyError(
+      const gd::String &type, size_t beginningPosition) {
+    gd::String message;
+    if (type == "number") {
+      message = _("You must enter a number or a valid expression call.");
+    } else if (type == "string") {
+      message = _(
+          "You must enter a text (between quotes) or a valid expression call.");
+    } else if (gd::ParameterMetadata::IsExpression("variable", type)) {
+      message = _("You must enter a variable name.");
+    } else if (gd::ParameterMetadata::IsObject(type)) {
+      message = _("You must enter a valid object name.");
+    } else {
+      message = _("You must enter a valid expression.");
+    }
+
+    return std::move(RaiseTypeError(message, beginningPosition));
+  }
   ///@}
 
   gd::String expression;
   std::size_t currentPosition;
 
+  const gd::Platform &platform;
+  const gd::ObjectsContainer &globalObjectsContainer;
+  const gd::ObjectsContainer &objectsContainer;
+
   static gd::String NAMESPACE_SEPARATOR;
 };
 

Core/GDCore/Events/Parsers/ExpressionParser2Node.h

@@ -17,7 +17,6 @@ class ObjectsContainer;
 class Platform;
 class ParameterMetadata;
 class ExpressionMetadata;
-struct FunctionCallNode;
 }  // namespace gd
 
 namespace gd {
@@ -58,10 +57,6 @@ struct GD_CORE_API ExpressionParserDiagnostic {
  * \brief An error that can be attached to a gd::ExpressionNode.
  */
 struct GD_CORE_API ExpressionParserError : public ExpressionParserDiagnostic {
-  ExpressionParserError(const gd::String &type_,
-                        const gd::String &message_,
-                        const ExpressionParserLocation &location_)
-      : type(type_), message(message_), location(location_){};
   ExpressionParserError(const gd::String &type_,
                         const gd::String &message_,
                         size_t position_)
@@ -91,7 +86,7 @@ struct GD_CORE_API ExpressionParserError : public ExpressionParserDiagnostic {
  * an expression inherits from.
  */
 struct GD_CORE_API ExpressionNode {
-  ExpressionNode() : parent(nullptr) {};
+  ExpressionNode(const gd::String &type_) : type(type_){};
   virtual ~ExpressionNode(){};
   virtual void Visit(ExpressionParser2NodeWorker &worker){};
 
@@ -102,12 +97,17 @@ struct GD_CORE_API ExpressionNode {
                                       /// function can store the position of the
                                       /// object name, the dot, the function
                                       /// name, etc...
-  ExpressionNode *parent;
+
+  gd::String type;  // Actual type of the node.
+                    // "string", "number", type supported by
+                    // gd::ParameterMetadata::IsObject, types supported by
+                    // gd::ParameterMetadata::IsExpression or "unknown".
 };
 
 struct GD_CORE_API SubExpressionNode : public ExpressionNode {
-  SubExpressionNode(std::unique_ptr<ExpressionNode> expression_)
-      : ExpressionNode(), expression(std::move(expression_)){};
+  SubExpressionNode(const gd::String &type_,
+                    std::unique_ptr<ExpressionNode> expression_)
+      : ExpressionNode(type_), expression(std::move(expression_)){};
   virtual ~SubExpressionNode(){};
   virtual void Visit(ExpressionParser2NodeWorker &worker) {
     worker.OnVisitSubExpressionNode(*this);
@@ -120,8 +120,8 @@ struct GD_CORE_API SubExpressionNode : public ExpressionNode {
  * \brief An operator node. For example: "lhs + rhs".
  */
 struct GD_CORE_API OperatorNode : public ExpressionNode {
-  OperatorNode(gd::String::value_type op_)
-      : ExpressionNode(), op(op_){};
+  OperatorNode(const gd::String &type_, gd::String::value_type op_)
+      : ExpressionNode(type_), op(op_){};
   virtual ~OperatorNode(){};
   virtual void Visit(ExpressionParser2NodeWorker &worker) {
     worker.OnVisitOperatorNode(*this);
@@ -136,8 +136,8 @@ struct GD_CORE_API OperatorNode : public ExpressionNode {
  * \brief A unary operator node. For example: "-2".
  */
 struct GD_CORE_API UnaryOperatorNode : public ExpressionNode {
-  UnaryOperatorNode(gd::String::value_type op_)
-      : ExpressionNode(), op(op_){};
+  UnaryOperatorNode(const gd::String &type_, gd::String::value_type op_)
+      : ExpressionNode(type_), op(op_){};
   virtual ~UnaryOperatorNode(){};
   virtual void Visit(ExpressionParser2NodeWorker &worker) {
     worker.OnVisitUnaryOperatorNode(*this);
@@ -153,7 +153,7 @@ struct GD_CORE_API UnaryOperatorNode : public ExpressionNode {
  */
 struct GD_CORE_API NumberNode : public ExpressionNode {
   NumberNode(const gd::String &number_)
-      : ExpressionNode(), number(number_){};
+      : ExpressionNode("number"), number(number_){};
   virtual ~NumberNode(){};
   virtual void Visit(ExpressionParser2NodeWorker &worker) {
     worker.OnVisitNumberNode(*this);
@@ -168,7 +168,7 @@ struct GD_CORE_API NumberNode : public ExpressionNode {
  * Its `type` is always "string".
  */
 struct GD_CORE_API TextNode : public ExpressionNode {
-  TextNode(const gd::String &text_) : ExpressionNode(), text(text_){};
+  TextNode(const gd::String &text_) : ExpressionNode("string"), text(text_){};
   virtual ~TextNode(){};
   virtual void Visit(ExpressionParser2NodeWorker &worker) {
     worker.OnVisitTextNode(*this);
@@ -177,88 +177,32 @@ struct GD_CORE_API TextNode : public ExpressionNode {
   gd::String text;
 };
 
-struct GD_CORE_API IdentifierOrFunctionCallOrObjectFunctionNameOrEmptyNode
-    : public ExpressionNode {
-  IdentifierOrFunctionCallOrObjectFunctionNameOrEmptyNode()
-      : ExpressionNode(){};
-};
-
-/**
- * \brief An identifier node, usually representing an object or a variable
- * with an optional function name or child variable name respectively.
- *
- * The name of a function to call on an object or the behavior,
- * for example: "MyObject.Function" or "MyObject.Physics".
- * 
- * A variable, potentially with accessor to its child,
- * for example: MyVariable or MyVariable.MyChild
- */
-struct GD_CORE_API IdentifierNode
-    : public IdentifierOrFunctionCallOrObjectFunctionNameOrEmptyNode {
-  IdentifierNode(
-  const gd::String &identifierName_)
-      : IdentifierOrFunctionCallOrObjectFunctionNameOrEmptyNode(),
-        identifierName(identifierName_),
-        childIdentifierName(""){};
-  IdentifierNode(
-  const gd::String &identifierName_,
-  const gd::String &childIdentifierName_)
-      : IdentifierOrFunctionCallOrObjectFunctionNameOrEmptyNode(),
-        identifierName(identifierName_),
-        childIdentifierName(childIdentifierName_){};
-  virtual ~IdentifierNode(){};
-  virtual void Visit(ExpressionParser2NodeWorker &worker) {
-    worker.OnVisitIdentifierNode(*this);
-  };
-
-  gd::String identifierName;  ///< The object or variable name.
-  gd::String childIdentifierName;  ///< The object function or variable child name.
-
-
-  ExpressionParserLocation
-      identifierNameLocation;  ///< Location of the object or variable name.
-  ExpressionParserLocation
-      identifierNameDotLocation;  ///< Location of the "." after the object or variable name.
-  ExpressionParserLocation childIdentifierNameLocation;  ///< Location of object
-                                                         /// function, behavior or
-                                                         /// child variable name.
-};
-
-struct GD_CORE_API FunctionCallOrObjectFunctionNameOrEmptyNode
-    : public IdentifierOrFunctionCallOrObjectFunctionNameOrEmptyNode {
-  FunctionCallOrObjectFunctionNameOrEmptyNode()
-      : IdentifierOrFunctionCallOrObjectFunctionNameOrEmptyNode(){};
-  virtual ~FunctionCallOrObjectFunctionNameOrEmptyNode(){};
-  void Visit(ExpressionParser2NodeWorker &worker) override{};
-};
-
 struct GD_CORE_API VariableAccessorOrVariableBracketAccessorNode : public ExpressionNode {
-  VariableAccessorOrVariableBracketAccessorNode() : ExpressionNode(){};
+  VariableAccessorOrVariableBracketAccessorNode() : ExpressionNode(""){};
 
   std::unique_ptr<VariableAccessorOrVariableBracketAccessorNode> child;
 };
 
 /**
- * \brief A variable with bracket accessor or at least 2 "dot" accessors.
+ * \brief A variable, potentially with accessor to its children.
+ *
+ * Example: MyVariable or MyVariable.MyChildren
  *
- * Example: MyVariable[MyChildren] or MyVariable.MyChildren.MyGranChildren.
- * 
- * Other cases like "MyVariable" or "MyVariable.MyChildren" are IdentifierNode
- * to allow handling ambiguities.
- * 
- * \see gd::IdentifierNode
  * \see gd::VariableAccessorNode
  * \see gd::VariableBracketAccessorNode
  */
-struct GD_CORE_API VariableNode : public FunctionCallOrObjectFunctionNameOrEmptyNode {
-  VariableNode(const gd::String &name_)
-      : FunctionCallOrObjectFunctionNameOrEmptyNode(), name(name_){};
+struct GD_CORE_API VariableNode : public ExpressionNode {
+  VariableNode(const gd::String &type_,
+               const gd::String &name_,
+               const gd::String &objectName_)
+      : ExpressionNode(type_), name(name_), objectName(objectName_){};
   virtual ~VariableNode(){};
   virtual void Visit(ExpressionParser2NodeWorker &worker) {
     worker.OnVisitVariableNode(*this);
   };
 
   gd::String name;
+  gd::String objectName;
 
   std::unique_ptr<VariableAccessorOrVariableBracketAccessorNode>
       child;  // Can be nullptr if no accessor
@@ -272,8 +216,7 @@ struct GD_CORE_API VariableNode : public FunctionCallOrObjectFunctionNameOrEmpty
  */
 struct GD_CORE_API VariableAccessorNode
     : public VariableAccessorOrVariableBracketAccessorNode {
-  VariableAccessorNode(const gd::String &name_)
-      : VariableAccessorOrVariableBracketAccessorNode(), name(name_){};
+  VariableAccessorNode(const gd::String &name_) : name(name_){};
   virtual ~VariableAccessorNode(){};
   virtual void Visit(ExpressionParser2NodeWorker &worker) {
     worker.OnVisitVariableAccessorNode(*this);
@@ -291,7 +234,7 @@ struct GD_CORE_API VariableAccessorNode
 struct GD_CORE_API VariableBracketAccessorNode
     : public VariableAccessorOrVariableBracketAccessorNode {
   VariableBracketAccessorNode(std::unique_ptr<ExpressionNode> expression_)
-      : VariableAccessorOrVariableBracketAccessorNode(), expression(std::move(expression_)){};
+      : expression(std::move(expression_)){};
   virtual ~VariableBracketAccessorNode(){};
   virtual void Visit(ExpressionParser2NodeWorker &worker) {
     worker.OnVisitVariableBracketAccessorNode(*this);
@@ -300,26 +243,55 @@ struct GD_CORE_API VariableBracketAccessorNode
   std::unique_ptr<ExpressionNode> expression;
 };
 
+struct GD_CORE_API IdentifierOrFunctionCallOrObjectFunctionNameOrEmptyNode
+    : public ExpressionNode {
+  IdentifierOrFunctionCallOrObjectFunctionNameOrEmptyNode(
+      const gd::String &type)
+      : ExpressionNode(type){};
+};
+
+/**
+ * \brief An identifier node, usually representing an object or a function name.
+ */
+struct GD_CORE_API IdentifierNode
+    : public IdentifierOrFunctionCallOrObjectFunctionNameOrEmptyNode {
+  IdentifierNode(const gd::String &identifierName_, const gd::String &type_)
+      : IdentifierOrFunctionCallOrObjectFunctionNameOrEmptyNode(type_),
+        identifierName(identifierName_){};
+  virtual ~IdentifierNode(){};
+  virtual void Visit(ExpressionParser2NodeWorker &worker) {
+    worker.OnVisitIdentifierNode(*this);
+  };
+
+  gd::String identifierName;
+};
+
+struct GD_CORE_API FunctionCallOrObjectFunctionNameOrEmptyNode
+    : public IdentifierOrFunctionCallOrObjectFunctionNameOrEmptyNode {
+  FunctionCallOrObjectFunctionNameOrEmptyNode(const gd::String &type)
+      : IdentifierOrFunctionCallOrObjectFunctionNameOrEmptyNode(type){};
+  virtual ~FunctionCallOrObjectFunctionNameOrEmptyNode(){};
+  void Visit(ExpressionParser2NodeWorker &worker) override{};
+};
+
 /**
  * \brief The name of a function to call on an object or the behavior
- * For example: "MyObject.Physics::LinearVelocity".
- * 
- * Other cases like "MyObject.Function" or "MyObject.Physics" are IdentifierNode
- * to allow handling ambiguities.
- * 
- * \see gd::IdentifierNode
+ * For example: "MyObject.Function" or "MyObject.Physics" or
+ * "MyObject.Physics::LinearVelocity".
  */
 struct GD_CORE_API ObjectFunctionNameNode
     : public FunctionCallOrObjectFunctionNameOrEmptyNode {
-  ObjectFunctionNameNode(const gd::String &objectName_,
+  ObjectFunctionNameNode(const gd::String &type_,
+                         const gd::String &objectName_,
                          const gd::String &objectFunctionOrBehaviorName_)
-      : FunctionCallOrObjectFunctionNameOrEmptyNode(),
+      : FunctionCallOrObjectFunctionNameOrEmptyNode(type_),
         objectName(objectName_),
         objectFunctionOrBehaviorName(objectFunctionOrBehaviorName_) {}
-  ObjectFunctionNameNode(const gd::String &objectName_,
+  ObjectFunctionNameNode(const gd::String &type_,
+                         const gd::String &objectName_,
                          const gd::String &behaviorName_,
                          const gd::String &behaviorFunctionName_)
-      : FunctionCallOrObjectFunctionNameOrEmptyNode(),
+      : FunctionCallOrObjectFunctionNameOrEmptyNode(type_),
         objectName(objectName_),
         objectFunctionOrBehaviorName(behaviorName_),
         behaviorFunctionName(behaviorFunctionName_) {}
@@ -362,24 +334,39 @@ struct GD_CORE_API ObjectFunctionNameNode
  */
 struct GD_CORE_API FunctionCallNode : public FunctionCallOrObjectFunctionNameOrEmptyNode {
   /** \brief Construct a free function call node. */
-  FunctionCallNode(const gd::String &functionName_)
-      : FunctionCallOrObjectFunctionNameOrEmptyNode(),
+  FunctionCallNode(const gd::String &type_,
+                   std::vector<std::unique_ptr<ExpressionNode>> parameters_,
+                   const ExpressionMetadata &expressionMetadata_,
+                   const gd::String &functionName_)
+      : FunctionCallOrObjectFunctionNameOrEmptyNode(type_),
+        parameters(std::move(parameters_)),
+        expressionMetadata(expressionMetadata_),
         functionName(functionName_){};
 
   /** \brief Construct an object function call node. */
-  FunctionCallNode(const gd::String &objectName_,
+  FunctionCallNode(const gd::String &type_,
+                   const gd::String &objectName_,
+                   std::vector<std::unique_ptr<ExpressionNode>> parameters_,
+                   const ExpressionMetadata &expressionMetadata_,
                    const gd::String &functionName_)
-      : FunctionCallOrObjectFunctionNameOrEmptyNode(),
+      : FunctionCallOrObjectFunctionNameOrEmptyNode(type_),
         objectName(objectName_),
+        parameters(std::move(parameters_)),
+        expressionMetadata(expressionMetadata_),
         functionName(functionName_){};
 
   /** \brief Construct a behavior function call node. */
-  FunctionCallNode(const gd::String &objectName_,
+  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_)
-      : FunctionCallOrObjectFunctionNameOrEmptyNode(),
+      : FunctionCallOrObjectFunctionNameOrEmptyNode(type_),
         objectName(objectName_),
         behaviorName(behaviorName_),
+        parameters(std::move(parameters_)),
+        expressionMetadata(expressionMetadata_),
         functionName(functionName_){};
   virtual ~FunctionCallNode(){};
   virtual void Visit(ExpressionParser2NodeWorker &worker) {
@@ -389,6 +376,7 @@ struct GD_CORE_API FunctionCallNode : public FunctionCallOrObjectFunctionNameOrE
   gd::String objectName;
   gd::String behaviorName;
   std::vector<std::unique_ptr<ExpressionNode>> parameters;
+  const ExpressionMetadata &expressionMetadata;
   gd::String functionName;
 
   ExpressionParserLocation
@@ -413,8 +401,8 @@ struct GD_CORE_API FunctionCallNode : public FunctionCallOrObjectFunctionNameOrE
  * encountered and any other node could not make sense.
  */
 struct GD_CORE_API EmptyNode : public FunctionCallOrObjectFunctionNameOrEmptyNode {
-  EmptyNode(const gd::String &text_ = "")
-      : FunctionCallOrObjectFunctionNameOrEmptyNode(), text(text_){};
+  EmptyNode(const gd::String &type_, const gd::String &text_ = "")
+      : FunctionCallOrObjectFunctionNameOrEmptyNode(type_), text(text_){};
   virtual ~EmptyNode(){};
   virtual void Visit(ExpressionParser2NodeWorker &worker) {
     worker.OnVisitEmptyNode(*this);

Core/GDCore/Events/Parsers/ExpressionParser2NodePrinter.h

@@ -91,9 +91,6 @@ class GD_CORE_API ExpressionParser2NodePrinter
   }
   void OnVisitIdentifierNode(IdentifierNode& node) override {
     output += node.identifierName;
-    if (!node.childIdentifierName.empty()) {
-      output += "." + node.childIdentifierName;
-    }
   }
   void OnVisitObjectFunctionNameNode(ObjectFunctionNameNode& node) override {
     if (!node.behaviorFunctionName.empty()) {

Core/GDCore/Events/Serialization.cpp

@@ -4,7 +4,6 @@
  * reserved. This project is released under the MIT License.
  */
 #include "GDCore/Events/Serialization.h"
-
 #include "GDCore/CommonTools.h"
 #include "GDCore/Events/Event.h"
 #include "GDCore/Events/EventsList.h"
@@ -219,8 +218,8 @@ void EventsListSerialization::UnserializeEventsFrom(
       event = std::make_shared<EmptyEvent>();
     }
 
-    event->SetDisabled(eventElem.GetBoolAttribute("disabled", false));
-    event->SetFolded(eventElem.GetBoolAttribute("folded", false));
+    event->SetDisabled(eventElem.GetBoolAttribute("disabled"));
+    event->SetFolded(eventElem.GetBoolAttribute("folded"));
 
     list.InsertEvent(event, list.GetEventsCount());
   }
@@ -233,9 +232,8 @@ void EventsListSerialization::SerializeEventsTo(const EventsList& list,
     const gd::BaseEvent& event = list.GetEvent(j);
     SerializerElement& eventElem = events.AddChild("event");
 
-    if (event.IsDisabled())
-      eventElem.SetAttribute("disabled", event.IsDisabled());
-    if (event.IsFolded()) eventElem.SetAttribute("folded", event.IsFolded());
+    eventElem.SetAttribute("disabled", event.IsDisabled());
+    eventElem.SetAttribute("folded", event.IsFolded());
     eventElem.AddChild("type").SetValue(event.GetType());
 
     event.SerializeTo(eventElem);
@@ -342,10 +340,9 @@ void gd::EventsListSerialization::SerializeInstructionsTo(
   instructions.ConsiderAsArrayOf("instruction");
   for (std::size_t k = 0; k < list.size(); k++) {
     SerializerElement& instruction = instructions.AddChild("instruction");
-    instruction.AddChild("type").SetAttribute("value", list[k].GetType());
-
-    if (list[k].IsInverted())
-      instruction.GetChild("type").SetAttribute("inverted", true);
+    instruction.AddChild("type")
+        .SetAttribute("value", list[k].GetType())
+        .SetAttribute("inverted", list[k].IsInverted());
 
     // Parameters
     SerializerElement& parameters = instruction.AddChild("parameters");
@@ -355,10 +352,9 @@ void gd::EventsListSerialization::SerializeInstructionsTo(
           .SetValue(list[k].GetParameter(l).GetPlainString());
 
     // Sub instructions
-    if (!list[k].GetSubInstructions().empty()) {
-      SerializeInstructionsTo(list[k].GetSubInstructions(),
-                              instruction.AddChild("subInstructions"));
-    }
+    SerializerElement& subInstructions =
+        instruction.AddChild("subInstructions");
+    SerializeInstructionsTo(list[k].GetSubInstructions(), subInstructions);
   }
 }
 

Core/GDCore/Extensions/Builtin/AllBuiltinExtensions.h

@@ -42,7 +42,6 @@ class GD_CORE_API BuiltinExtensionsImplementer {
   static void ImplementsTimeExtension(gd::PlatformExtension& extension);
   static void ImplementsVariablesExtension(gd::PlatformExtension& extension);
   static void ImplementsWindowExtension(gd::PlatformExtension& extension);
-  static void ImplementsAsyncExtension(gd::PlatformExtension& extension);
 };
 
 }  // namespace gd

Core/GDCore/Extensions/Builtin/AsyncExtension.cpp

@@ -1,32 +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 "AllBuiltinExtensions.h"
-#include "GDCore/Events/Builtin/AsyncEvent.h"
-#include "GDCore/Tools/Localization.h"
-
-using namespace std;
-namespace gd {
-
-void GD_CORE_API BuiltinExtensionsImplementer::ImplementsAsyncExtension(
-    gd::PlatformExtension &extension) {
-  extension
-      .SetExtensionInformation(
-          "BuiltinAsync",
-          _("Async functions"),
-          _("Functions that defer the execution of the events after it."),
-          "Arthur Pacaud (arthuro555)",
-          "Open source (MIT License)")
-      .SetCategory("Advanced");
-
-  extension.AddEvent("Async",
-                     _("Async event"),
-                     _("Internal event for asynchronous actions"),
-                     "",
-                     "res/eventaddicon.png",
-                     std::make_shared<gd::AsyncEvent>());
-}
-
-}  // namespace gd

Core/GDCore/Extensions/Builtin/AudioExtension.cpp

@@ -343,34 +343,6 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsAudioExtension(
           "res/actions/music.png")
       .AddCodeOnlyParameter("currentScene", "")
       .MarkAsComplex();
-  extension
-      .AddAction(
-          "FadeSoundVolume",
-          _("Fade the volume of a sound played on a channel."),
-          _("Fade the volume of a sound played on a channel to the specified volume within the specified duration."),
-          _("Fade the sound on channel _PARAM1_ to volume _PARAM2_ within _PARAM3_ seconds"),
-          _("Sounds on channels"),
-          "res/actions/son24.png",
-          "res/actions/son.png")
-      .AddCodeOnlyParameter("currentScene", "")
-      .AddParameter("expression", _("Channel identifier"))
-      .AddParameter("expression", _("Final volume (0-100)"))
-      .AddParameter("expression", _("Fading time in seconds"))
-      .MarkAsAdvanced();
-  extension
-      .AddAction(
-          "FadeMusicVolume",
-          _("Fade the volume of a music played on a channel."),
-          _("Fade the volume of a music played on a channel to the specified volume within the specified duration."),
-          _("Fade the music on channel _PARAM1_ to volume _PARAM2_ within _PARAM3_ seconds"),
-          _("Music on channels"),
-          "res/actions/music24.png",
-          "res/actions/music.png")
-      .AddCodeOnlyParameter("currentScene", "")
-      .AddParameter("expression", _("Channel identifier"))
-      .AddParameter("expression", _("Final volume (0-100)"))
-      .AddParameter("expression", _("Fading time in seconds"))
-      .MarkAsAdvanced();
 
   extension
       .AddCondition("MusicPlaying",

Core/GDCore/Extensions/Builtin/BaseObjectExtension.cpp

@@ -1252,7 +1252,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
                  "res/actions/create24.png",
                  "res/actions/create24.png")
       .AddCodeOnlyParameter("objectsContext", "")
-      .AddParameter("objectListOrEmptyIfJustDeclared", _("Object to create"))
+      .AddParameter("objectListWithoutPicking", _("Object to create"))
       .AddParameter("expression", _("X position"))
       .AddParameter("expression", _("Y position"))
       .AddParameter("layer", _("Layer (base layer if empty)"), "", true)
@@ -1270,7 +1270,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
                  "res/actions/create24.png",
                  "res/actions/create24.png")
       .AddCodeOnlyParameter("objectsContext", "")
-      .AddParameter("objectListOrEmptyIfJustDeclared", _("Group of potential objects"))
+      .AddParameter("objectListWithoutPicking", _("Group of potential objects"))
       .SetParameterLongDescription(
           _("Group containing objects that can be created by the action."))
       .AddParameter("string", _("Name of the object to create"))
@@ -1418,33 +1418,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
           "res/conditions/nbObjet.png")
       .AddParameter("objectList", _("Object"))
       .UseStandardRelationalOperatorParameters("number")
-      .MarkAsSimple()
-      .SetHidden();
-
-  extension.AddExpressionAndCondition(
-      "number",
-      "SceneInstancesCount",
-      _("Number of object instances on the scene"),
-      _("the number of instances of the specified objects living on the scene"),
-      _("the number of _PARAM1_ living on the scene"),
-      _("Objects"),
-      "res/conditions/nbObjet24.png")
-    .AddCodeOnlyParameter("objectsContext", "")
-    .AddParameter("objectListOrEmptyWithoutPicking", _("Object"))
-    .UseStandardParameters("number")
-    .MarkAsSimple();
-
-  extension.AddExpressionAndCondition(
-      "number",
-      "PickedInstancesCount",
-      _("Number of object instances currently picked"),
-      _("the number of instances picked by the previous conditions (or actions)"),
-      _("the number of _PARAM0_ currently picked"),
-      _("Objects"),
-      "res/conditions/nbObjet24.png")
-    .AddParameter("objectListOrEmptyWithoutPicking", _("Object"))
-    .UseStandardParameters("number")
-    .MarkAsSimple();
+      .MarkAsSimple();
 
   extension
       .AddCondition(
@@ -1552,8 +1526,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
                        "currently picked in the event"),
                      "",
                      "res/conditions/nbObjet.png")
-      .AddParameter("objectList", _("Object"))
-      .SetHidden(); // Deprecated
+      .AddParameter("objectList", _("Object"));
 
   obj.AddStrExpression("ObjectName",
                        _("Object name"),

Core/GDCore/Extensions/Builtin/CameraExtension.cpp

@@ -29,7 +29,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsCameraExtension(
   extension
       .AddExpressionAndConditionAndAction(
           "number",
-          "CameraCenterX",
+          "CameraX",
           _("Camera center X position"),
           _("the X position of the center of a camera"),
           _("the X position of camera _PARAM4_ (layer: _PARAM3_)"),
@@ -43,25 +43,15 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsCameraExtension(
       .SetDefaultValue("0")
       .MarkAsAdvanced();
 
-  // Compatibility with GD <= 5.0.135
-  extension.AddDuplicatedCondition("CameraX", "CameraCenterX")
-      .SetHidden();  // Deprecated
-  extension.AddDuplicatedExpression("CameraX", "CameraCenterX")
-      .SetHidden();  // Deprecated
-  extension.AddDuplicatedAction("SetCameraX", "SetCameraCenterX")
-      .SetHidden();  // Deprecated
-
   extension.AddDuplicatedAction("CameraX", "SetCameraX")
       .SetHidden();  // Deprecated
-
   extension.AddDuplicatedExpression("VueX", "CameraX")
       .SetHidden();  // Deprecated
-  // end of compatibility code
 
   extension
       .AddExpressionAndConditionAndAction(
           "number",
-          "CameraCenterY",
+          "CameraY",
           _("Camera center Y position"),
           _("the Y position of the center of a camera"),
           _("the Y position of camera _PARAM4_ (layer: _PARAM3_)"),
@@ -75,20 +65,10 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsCameraExtension(
       .SetDefaultValue("0")
       .MarkAsAdvanced();
 
-  // Compatibility with GD <= 5.0.135
-  extension.AddDuplicatedCondition("CameraY", "CameraCenterY")
-      .SetHidden();  // Deprecated
-  extension.AddDuplicatedExpression("CameraY", "CameraCenterY")
-      .SetHidden();  // Deprecated
-  extension.AddDuplicatedAction("SetCameraY", "SetCameraCenterY")
-      .SetHidden();  // Deprecated
-
   extension.AddDuplicatedAction("CameraY", "SetCameraY")
       .SetHidden();  // Deprecated
-
   extension.AddDuplicatedExpression("VueY", "CameraY")
       .SetHidden();  // Deprecated
-  // end of compatibility code
 
   extension
       .AddExpressionAndCondition(
@@ -100,9 +80,9 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsCameraExtension(
           "",
           "res/conditions/camera24.png")
       .AddCodeOnlyParameter("currentScene", "")
-      .AddParameter("layer", _("Layer (base layer if empty)"), "", true)
+      .AddParameter("layer", _("Layer (base layer if empty)"))
       .SetDefaultValue("\"\"")
-      .AddParameter("expression", _("Camera number"), "", true)
+      .AddParameter("expression", _("Camera number"))
       .UseStandardParameters("number")
       .MarkAsAdvanced();
 
@@ -116,77 +96,9 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsCameraExtension(
           "",
           "res/conditions/camera24.png")
       .AddCodeOnlyParameter("currentScene", "")
-      .AddParameter("layer", _("Layer (base layer if empty)"), "", true)
+      .AddParameter("layer", _("Layer (base layer if empty)"))
       .SetDefaultValue("\"\"")
-      .AddParameter("expression", _("Camera number"), "", true)
-      .UseStandardParameters("number")
-      .MarkAsAdvanced();
-
-  extension
-      .AddExpressionAndCondition(
-          "number",
-          "CameraBorderLeft",
-          _("Camera left border position"),
-          _("the position of the left border of a camera"),
-          _("the position of the left border of camera _PARAM2_ of layer "
-            "_PARAM1_"),
-          "",
-          "res/conditions/camera24.png")
-      .AddCodeOnlyParameter("currentScene", "")
-      .AddParameter("layer", _("Layer (base layer if empty)"), "", true)
-      .SetDefaultValue("\"\"")
-      .AddParameter("expression", _("Camera number"), "", true)
-      .UseStandardParameters("number")
-      .MarkAsAdvanced();
-
-  extension
-      .AddExpressionAndCondition(
-          "number",
-          "CameraBorderRight",
-          _("Camera right border position"),
-          _("the position of the right border of a camera"),
-          _("the position of the right border of camera _PARAM2_ of layer "
-            "_PARAM1_"),
-          "",
-          "res/conditions/camera24.png")
-      .AddCodeOnlyParameter("currentScene", "")
-      .AddParameter("layer", _("Layer (base layer if empty)"), "", true)
-      .SetDefaultValue("\"\"")
-      .AddParameter("expression", _("Camera number"), "", true)
-      .UseStandardParameters("number")
-      .MarkAsAdvanced();
-
-  extension
-      .AddExpressionAndCondition(
-          "number",
-          "CameraBorderTop",
-          _("Camera top border position"),
-          _("the position of the top border of a camera"),
-          _("the position of the top border of camera _PARAM2_ of layer "
-            "_PARAM1_"),
-          "",
-          "res/conditions/camera24.png")
-      .AddCodeOnlyParameter("currentScene", "")
-      .AddParameter("layer", _("Layer (base layer if empty)"), "", true)
-      .SetDefaultValue("\"\"")
-      .AddParameter("expression", _("Camera number"), "", true)
-      .UseStandardParameters("number")
-      .MarkAsAdvanced();
-
-  extension
-      .AddExpressionAndCondition(
-          "number",
-          "CameraBorderBottom",
-          _("Camera bottom border position"),
-          _("the position of the bottom border of a camera"),
-          _("the position of the bottom border of camera _PARAM2_ of layer "
-            "_PARAM1_"),
-          "",
-          "res/conditions/camera24.png")
-      .AddCodeOnlyParameter("currentScene", "")
-      .AddParameter("layer", _("Layer (base layer if empty)"), "", true)
-      .SetDefaultValue("\"\"")
-      .AddParameter("expression", _("Camera number"), "", true)
+      .AddParameter("expression", _("Camera number"))
       .UseStandardParameters("number")
       .MarkAsAdvanced();
 

Core/GDCore/Extensions/Builtin/MathematicalToolsExtension.cpp

@@ -229,15 +229,6 @@ BuiltinExtensionsImplementer::ImplementsMathematicalToolsExtension(
                      "res/mathfunction.png")
       .AddParameter("expression", _("Expression"));
 
-  extension
-      .AddExpression("ceilTo",
-                     _("Ceil (round up) to a decimal point"),
-                     _("Round number up to the Nth decimal place"),
-                     "",
-                     "res/mathfunction.png")
-      .AddParameter("expression", _("Expression"))
-      .AddParameter("expression", _("Expression"), "", true);
-
   extension
       .AddExpression("floor",
                      _("Floor (round down)"),
@@ -246,15 +237,6 @@ BuiltinExtensionsImplementer::ImplementsMathematicalToolsExtension(
                      "res/mathfunction.png")
       .AddParameter("expression", _("Expression"));
 
-  extension
-      .AddExpression("floorTo",
-                     _("Floor (round down) to a decimal point"),
-                     _("Round number down to the Nth decimal place"),
-                     "",
-                     "res/mathfunction.png")
-      .AddParameter("expression", _("Expression"))
-      .AddParameter("expression", _("Expression"), "", true);
-
   extension
       .AddExpression("cos",
                      _("Cosine"),
@@ -313,15 +295,6 @@ BuiltinExtensionsImplementer::ImplementsMathematicalToolsExtension(
                      "res/mathfunction.png")
       .AddParameter("expression", _("Expression"));
 
-  extension
-      .AddExpression("roundTo",
-                     _("Round to a decimal point"),
-                     _("Round a number to the Nth decimal place"),
-                     "",
-                     "res/mathfunction.png")
-      .AddParameter("expression", _("Expression"))
-      .AddParameter("expression", _("Expression"), "", true);
-
   extension
       .AddExpression("exp",
                      _("Exponential"),

Core/GDCore/Extensions/Builtin/MouseExtension.cpp

@@ -311,8 +311,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsMouseExtension(
           _("Multitouch"),
           "res/conditions/touch24.png",
           "res/conditions/touch.png")
-      .AddCodeOnlyParameter("currentScene", "")
-      .SetHidden();
+      .AddCodeOnlyParameter("currentScene", "");
 
   extension
       .AddCondition(
@@ -327,54 +326,8 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsMouseExtension(
           _("Multitouch"),
           "res/conditions/touch24.png",
           "res/conditions/touch.png")
-      .AddCodeOnlyParameter("currentScene", "")
-      .SetHidden();
-
-  extension
-      .AddCondition(
-          "HasAnyTouchStarted",
-          _("A new touch has started"),
-          _("Check if a touch has just started on this frame. The touch identifiers can be "
-            "accessed using StartedTouchId() and StartedTouchCount()."),
-          _("A new touch has started"),
-          _("Multitouch"),
-          "res/conditions/touch24.png",
-          "res/conditions/touch.png")
       .AddCodeOnlyParameter("currentScene", "");
 
-  extension
-      .AddExpression(
-          "StartedTouchCount",
-          _("Started touch count"),
-          _("The number of touches that have just started on this frame. The touch identifiers can be "
-            "accessed using StartedTouchId()."),
-          _("Multitouch"),
-          "res/conditions/touch.png")
-      .AddCodeOnlyParameter("currentScene", "");
-
-  extension
-      .AddExpression(
-          "StartedTouchId",
-          _("Started touch identifier"),
-          _("The identifier of the touch that has just started on this frame. The touch number of touches can be "
-            "accessed using StartedTouchCount()."),
-          _("Multitouch"),
-          "res/conditions/touch.png")
-      .AddCodeOnlyParameter("currentScene", "")
-      .AddParameter("expression", _("Touch index"));
-
-  extension
-      .AddCondition(
-          "HasTouchEnded",
-          _("A touch has ended"),
-          _("Check if a touch has ended."),
-          _("The touch with identifier _PARAM1_ has ended"),
-          _("Multitouch"),
-          "res/conditions/touch24.png",
-          "res/conditions/touch.png")
-      .AddCodeOnlyParameter("currentScene", "")
-      .AddParameter("expression", _("Touch identifier"));
-
   extension
       .AddExpression("MouseWheelDelta",
                      _("Mouse wheel: Displacement"),
@@ -389,8 +342,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsMouseExtension(
                      _("Identifier of the last touch"),
                      _("Multitouch"),
                      "res/conditions/touch.png")
-      .AddCodeOnlyParameter("currentScene", "")
-      .SetHidden();
+      .AddCodeOnlyParameter("currentScene", "");
 
   extension
       .AddExpression("LastEndedTouchId",
@@ -398,8 +350,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsMouseExtension(
                      _("Identifier of the last ended touch"),
                      _("Multitouch"),
                      "res/conditions/touch.png")
-      .AddCodeOnlyParameter("currentScene", "")
-      .SetHidden();
+      .AddCodeOnlyParameter("currentScene", "");
 }
 
 }  // namespace gd

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

@@ -4,10 +4,8 @@
  * reserved. This project is released under the MIT License.
  */
 #include "GDCore/Extensions/Builtin/SpriteExtension/Direction.h"
-
 #include <iostream>
 #include <vector>
-
 #include "GDCore/CommonTools.h"
 #include "GDCore/Extensions/Builtin/SpriteExtension/Sprite.h"
 #include "GDCore/Serialization/SerializerElement.h"
@@ -31,15 +29,6 @@ const Sprite& Direction::GetSprite(std::size_t nb) const { return sprites[nb]; }
 
 Sprite& Direction::GetSprite(std::size_t nb) { return sprites[nb]; }
 
-const std::vector<gd::String>& Direction::GetSpriteNames() const {
-  static std::vector<gd::String> spriteNames;
-  spriteNames.clear();
-  for (std::size_t i = 0; i < sprites.size(); ++i) {
-    spriteNames.push_back(sprites[i].GetImageName());
-  }
-  return spriteNames;
-}
-
 void Direction::RemoveSprite(std::size_t index) {
   if (index < sprites.size()) sprites.erase(sprites.begin() + index);
 }
@@ -132,7 +121,7 @@ void Direction::UnserializeFrom(const gd::SerializerElement& element) {
             polygonElement.GetChild(k);
 
         polygon.vertices.push_back(
-            gd::Vector2f(verticeElement.GetDoubleAttribute("x"),
+            sf::Vector2f(verticeElement.GetDoubleAttribute("x"),
                          verticeElement.GetDoubleAttribute("y")));
       }
 

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

@@ -72,13 +72,6 @@ class GD_CORE_API Direction {
    */
   Sprite& GetSprite(std::size_t nb);
 
-  /**
-   * \brief Return a vector of references to sprite names.
-   *
-   * \return A vector of all sprite names references.
-   */
-  const std::vector<gd::String>& GetSpriteNames() const;
-
   /**
    * \brief Check if the direction contains sprites.
    *

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

@@ -4,7 +4,7 @@
  * reserved. This project is released under the MIT License.
  */
 #include "Polygon2d.h"
-#include "GDCore/Vector2.h"
+#include <SFML/System/Vector2.hpp>
 #include <cmath>
 #include <iostream>
 
@@ -28,7 +28,7 @@ void Polygon2d::Move(float x, float y) {
 }
 
 void Polygon2d::ComputeEdges() const {
-  gd::Vector2f v1, v2;
+  sf::Vector2f v1, v2;
   edges.clear();
 
   for (std::size_t i = 0; i < vertices.size(); i++) {
@@ -62,8 +62,8 @@ bool Polygon2d::IsConvex() const {
   return true;
 }
 
-gd::Vector2f Polygon2d::ComputeCenter() const {
-  gd::Vector2f center;
+sf::Vector2f Polygon2d::ComputeCenter() const {
+  sf::Vector2f center;
 
   for (std::size_t i = 0; i < vertices.size(); i++) {
     center.x += vertices[i].x;
@@ -77,10 +77,10 @@ gd::Vector2f Polygon2d::ComputeCenter() const {
 
 Polygon2d Polygon2d::CreateRectangle(float width, float height) {
   Polygon2d rect;
-  rect.vertices.push_back(gd::Vector2f(-width / 2.0f, -height / 2.0f));
-  rect.vertices.push_back(gd::Vector2f(+width / 2.0f, -height / 2.0f));
-  rect.vertices.push_back(gd::Vector2f(+width / 2.0f, +height / 2.0f));
-  rect.vertices.push_back(gd::Vector2f(-width / 2.0f, +height / 2.0f));
+  rect.vertices.push_back(sf::Vector2f(-width / 2.0f, -height / 2.0f));
+  rect.vertices.push_back(sf::Vector2f(+width / 2.0f, -height / 2.0f));
+  rect.vertices.push_back(sf::Vector2f(+width / 2.0f, +height / 2.0f));
+  rect.vertices.push_back(sf::Vector2f(-width / 2.0f, +height / 2.0f));
 
   return rect;
 }

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

@@ -5,7 +5,7 @@
  */
 #ifndef GDCORE_POLYGON_H
 #define GDCORE_POLYGON_H
-#include "GDCore/Vector2.h"
+#include <SFML/System/Vector2.hpp>
 #include <vector>
 
 /**
@@ -22,19 +22,19 @@ class GD_CORE_API Polygon2d {
   Polygon2d(){};
   virtual ~Polygon2d(){};
 
-  std::vector<gd::Vector2f> vertices;  ///< The vertices composing the polygon
-  mutable std::vector<gd::Vector2f>
+  std::vector<sf::Vector2f> vertices;  ///< The vertices composing the polygon
+  mutable std::vector<sf::Vector2f>
       edges;  ///< Edges. Can be computed from vertices using ComputeEdges()
 
   /**
    * \brief Get the vertices composing the polygon.
    */
-  std::vector<gd::Vector2f>& GetVertices() { return vertices; }
+  std::vector<sf::Vector2f>& GetVertices() { return vertices; }
 
   /**
    * \brief Get the vertices composing the polygon.
    */
-  const std::vector<gd::Vector2f>& GetVertices() const { return vertices; }
+  const std::vector<sf::Vector2f>& GetVertices() const { return vertices; }
 
   /**
    * \brief Moves each vertices from the given amount.
@@ -68,7 +68,7 @@ class GD_CORE_API Polygon2d {
   /**
    * \brief Return the position of the center of the polygon
    */
-  gd::Vector2f ComputeCenter() const;
+  sf::Vector2f ComputeCenter() const;
 
   /** \name Tools
    * Tool functions

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

@@ -4,6 +4,7 @@
  * reserved. This project is released under the MIT License.
  */
 #include "GDCore/Extensions/Builtin/SpriteExtension/Sprite.h"
+#include <SFML/Graphics/Sprite.hpp>
 #include <iostream>
 #include "GDCore/Extensions/Builtin/SpriteExtension/Polygon2d.h"
 

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

@@ -6,6 +6,7 @@
 
 #ifndef SPRITE_H
 #define SPRITE_H
+#include <SFML/Graphics/Sprite.hpp>
 #include <memory>
 #include "GDCore/Extensions/Builtin/SpriteExtension/Point.h"
 #include "GDCore/Extensions/Builtin/SpriteExtension/Polygon2d.h"

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

@@ -6,6 +6,7 @@
 
 #include "GDCore/Extensions/Builtin/SpriteExtension/SpriteObject.h"
 
+#include <SFML/Graphics.hpp>
 #include <algorithm>
 
 #include "GDCore/CommonTools.h"

Core/GDCore/Extensions/Builtin/TimeExtension.cpp

@@ -20,7 +20,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsTimeExtension(
           "for slow motion effects).",
           "Florian Rival",
           "Open source (MIT License)")
-      .SetExtensionHelpPath("/all-features/timers-and-time");
+      .SetExtensionHelpPath("/all-features/timers");
   extension.AddInstructionOrExpressionGroupMetadata(
       _("Timers and time")
   )
@@ -141,6 +141,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsTimeExtension(
                  _("Change time scale"),
                  _("Change the time scale of the scene."),
                  _("Set the time scale of the scene to _PARAM1_"),
+
                  "",
                  "res/actions/time24.png",
                  "res/actions/time.png")
@@ -148,19 +149,6 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsTimeExtension(
       .AddParameter("expression",
                     _("Scale (1: Default, 2: 2x faster, 0.5: 2x slower...)"));
 
-  extension
-      .AddAction("Wait",
-                 _("Wait X seconds (experimental)"),
-                 _("Waits a number of seconds before running "
-                   "the next actions (and sub-events)."),
-                 _("Wait _PARAM0_ seconds"),
-                 "",
-                 "res/timer.svg",
-                 "res/timer.svg")
-      .AddParameter("expression", "Time to wait in seconds")
-      .SetHelpPath("/all-features/timers-and-time/wait-action")
-      .SetAsync();
-
   extension
       .AddExpression("TimeDelta",
                      _("Time elapsed since the last frame"),

Core/GDCore/Extensions/Metadata/EffectMetadata.h

@@ -8,7 +8,6 @@
 #include <functional>
 #include <map>
 #include <memory>
-#include <algorithm>
 
 #include "GDCore/Project/PropertyDescriptor.h"
 #include "GDCore/String.h"

Core/GDCore/Extensions/Metadata/InstructionMetadata.cpp

@@ -22,7 +22,6 @@ InstructionMetadata::InstructionMetadata()
       canHaveSubInstructions(false),
       hidden(true),
       usageComplexity(5),
-      isAsync(false),
       isPrivate(false),
       isObjectInstruction(false),
       isBehaviorInstruction(false) {}
@@ -46,7 +45,6 @@ InstructionMetadata::InstructionMetadata(const gd::String& extensionNamespace_,
       extensionNamespace(extensionNamespace_),
       hidden(false),
       usageComplexity(5),
-      isAsync(false),
       isPrivate(false),
       isObjectInstruction(false),
       isBehaviorInstruction(false) {}

Core/GDCore/Extensions/Metadata/InstructionMetadata.h

@@ -9,7 +9,6 @@
 #include <functional>
 #include <map>
 #include <memory>
-#include <algorithm>
 
 #include "GDCore/Events/Instruction.h"
 #include "GDCore/String.h"
@@ -99,23 +98,6 @@ class GD_CORE_API InstructionMetadata {
     return *this;
   }
 
-  /**
-   * Check if the instruction is asynchronous - it will be running in the
-   * background, executing the instructions following it before the frame after
-   * it resolved.
-   */
-  bool IsAsync() const { return isAsync; }
-
-  /**
-   * Set that the instruction is asynchronous - it will be running in the
-   * background, executing the instructions following it before the frame after
-   * it resolved.
-   */
-  InstructionMetadata &SetAsync() {
-    isAsync = true;
-    return *this;
-  }
-
   /**
    * Notify that the instruction can have sub instructions.
    */
@@ -479,7 +461,6 @@ class GD_CORE_API InstructionMetadata {
   int usageComplexity;  ///< Evaluate the instruction from 0 (simple&easy to
                         ///< use) to 10 (complex to understand)
   bool isPrivate;
-  bool isAsync;
   bool isObjectInstruction;
   bool isBehaviorInstruction;
   gd::String requiredBaseObjectCapability;

Core/GDCore/Extensions/Metadata/MetadataProvider.cpp

@@ -13,9 +13,7 @@
 #include "GDCore/Extensions/Metadata/ObjectMetadata.h"
 #include "GDCore/Extensions/Platform.h"
 #include "GDCore/Extensions/PlatformExtension.h"
-#include "GDCore/Project/Layout.h"  // For GetTypeOfObject and GetTypeOfBehavior
 #include "GDCore/String.h"
-#include "GDCore/Events/Parsers/ExpressionParser2.h"
 
 using namespace std;
 
@@ -32,9 +30,12 @@ ExtensionAndMetadata<BehaviorMetadata>
 MetadataProvider::GetExtensionAndBehaviorMetadata(const gd::Platform& platform,
                                                   gd::String behaviorType) {
   for (auto& extension : platform.GetAllPlatformExtensions()) {
-    if (extension->HasBehavior(behaviorType))
-      return ExtensionAndMetadata<BehaviorMetadata>(
-          *extension, extension->GetBehaviorMetadata(behaviorType));
+    auto behaviorTypes = extension->GetBehaviorsTypes();
+    for (std::size_t j = 0; j < behaviorTypes.size(); ++j) {
+      if (behaviorTypes[j] == behaviorType)
+        return ExtensionAndMetadata<BehaviorMetadata>(
+            *extension, extension->GetBehaviorMetadata(behaviorType));
+    }
   }
 
   return ExtensionAndMetadata<BehaviorMetadata>(badExtension, badBehaviorMetadata);
@@ -201,7 +202,8 @@ MetadataProvider::GetExtensionAndBehaviorExpressionMetadata(
     const gd::Platform& platform, gd::String autoType, gd::String exprType) {
   auto& extensions = platform.GetAllPlatformExtensions();
   for (auto& extension : extensions) {
-    if (extension->HasBehavior(autoType)) {
+    const auto& autos = extension->GetBehaviorsTypes();
+    if (find(autos.begin(), autos.end(), autoType) != autos.end()) {
       const auto& allAutoExpressions =
           extension->GetAllExpressionsForBehavior(autoType);
       if (allAutoExpressions.find(exprType) != allAutoExpressions.end())
@@ -290,7 +292,8 @@ MetadataProvider::GetExtensionAndBehaviorStrExpressionMetadata(
     const gd::Platform& platform, gd::String autoType, gd::String exprType) {
   auto& extensions = platform.GetAllPlatformExtensions();
   for (auto& extension : extensions) {
-    if (extension->HasBehavior(autoType)) {
+    const auto& autos = extension->GetBehaviorsTypes();
+    if (find(autos.begin(), autos.end(), autoType) != autos.end()) {
       const auto& allBehaviorStrExpressions =
           extension->GetAllStrExpressionsForBehavior(autoType);
       if (allBehaviorStrExpressions.find(exprType) !=
@@ -347,30 +350,28 @@ const gd::ExpressionMetadata& MetadataProvider::GetAnyExpressionMetadata(
     const gd::Platform& platform, gd::String exprType) {
   const auto& numberExpressionMetadata =
       GetExpressionMetadata(platform, exprType);
-  if (&numberExpressionMetadata != &badExpressionMetadata) {
-    return numberExpressionMetadata;
-  }
   const auto& stringExpressionMetadata =
       GetStrExpressionMetadata(platform, exprType);
-  if (&stringExpressionMetadata != &badExpressionMetadata) {
-    return stringExpressionMetadata;
-  }
-  return badExpressionMetadata;
+
+  return &numberExpressionMetadata != &badExpressionMetadata
+             ? numberExpressionMetadata
+             : &stringExpressionMetadata != &badExpressionMetadata
+                   ? stringExpressionMetadata
+                   : badExpressionMetadata;
 }
 
 const gd::ExpressionMetadata& MetadataProvider::GetObjectAnyExpressionMetadata(
     const gd::Platform& platform, gd::String objectType, gd::String exprType) {
   const auto& numberExpressionMetadata =
       GetObjectExpressionMetadata(platform, objectType, exprType);
-  if (&numberExpressionMetadata != &badExpressionMetadata) {
-    return numberExpressionMetadata;
-  }
   const auto& stringExpressionMetadata =
       GetObjectStrExpressionMetadata(platform, objectType, exprType);
-  if (&stringExpressionMetadata != &badExpressionMetadata) {
-    return stringExpressionMetadata;
-  }
-  return badExpressionMetadata;
+
+  return &numberExpressionMetadata != &badExpressionMetadata
+             ? numberExpressionMetadata
+             : &stringExpressionMetadata != &badExpressionMetadata
+                   ? stringExpressionMetadata
+                   : badExpressionMetadata;
 }
 
 const gd::ExpressionMetadata&
@@ -379,98 +380,14 @@ MetadataProvider::GetBehaviorAnyExpressionMetadata(const gd::Platform& platform,
                                                    gd::String exprType) {
   const auto& numberExpressionMetadata =
       GetBehaviorExpressionMetadata(platform, autoType, exprType);
-  if (&numberExpressionMetadata != &badExpressionMetadata) {
-    return numberExpressionMetadata;
-  }
   const auto& stringExpressionMetadata =
       GetBehaviorStrExpressionMetadata(platform, autoType, exprType);
-  if (&stringExpressionMetadata != &badExpressionMetadata) {
-    return stringExpressionMetadata;
-  }
-  return badExpressionMetadata;
-}
 
-const gd::ExpressionMetadata& MetadataProvider::GetFunctionCallMetadata(
-    const gd::Platform& platform, 
-    const gd::ObjectsContainer &globalObjectsContainer,
-    const gd::ObjectsContainer &objectsContainer,
-    FunctionCallNode& node) {
-
-  if (!node.behaviorName.empty()) {
-    gd::String behaviorType = 
-        GetTypeOfBehavior(globalObjectsContainer, objectsContainer, node.behaviorName);
-    return MetadataProvider::GetBehaviorAnyExpressionMetadata(
-            platform, behaviorType, node.functionName);
-  }
-  else if (!node.objectName.empty()) {
-    gd::String objectType = 
-        GetTypeOfObject(globalObjectsContainer, objectsContainer, node.objectName);
-    return MetadataProvider::GetObjectAnyExpressionMetadata(
-                  platform, objectType, node.functionName);
-  }
-
-  return MetadataProvider::GetAnyExpressionMetadata(platform, node.functionName);
-}
-
-  const gd::ParameterMetadata* MetadataProvider::GetFunctionCallParameterMetadata(
-    const gd::Platform& platform, 
-    const gd::ObjectsContainer &globalObjectsContainer,
-    const gd::ObjectsContainer &objectsContainer,
-    FunctionCallNode& functionCall,
-    ExpressionNode& parameter) {
-      int parameterIndex = -1;
-      for (int i = 0; i < functionCall.parameters.size(); i++) {
-        if (functionCall.parameters.at(i).get() == &parameter) {
-          parameterIndex = i;
-          break;
-        }
-      }
-      if (parameterIndex < 0) {
-        return nullptr;
-      }
-      return MetadataProvider::GetFunctionCallParameterMetadata(
-          platform, 
-          globalObjectsContainer,
-          objectsContainer,
-          functionCall,
-          parameterIndex);
-}
-
-  const gd::ParameterMetadata* MetadataProvider::GetFunctionCallParameterMetadata(
-    const gd::Platform& platform, 
-    const gd::ObjectsContainer &globalObjectsContainer,
-    const gd::ObjectsContainer &objectsContainer,
-    FunctionCallNode& functionCall,
-    int parameterIndex) {
-      // Search the parameter metadata index skipping invisible ones.
-      size_t visibleParameterIndex = 0;
-      size_t metadataParameterIndex =
-          ExpressionParser2::WrittenParametersFirstIndex(
-              functionCall.objectName, functionCall.behaviorName);
-      const gd::ExpressionMetadata &metadata = MetadataProvider::GetFunctionCallMetadata(
-          platform, globalObjectsContainer, objectsContainer, functionCall);
-
-      if (IsBadExpressionMetadata(metadata)) {
-        return nullptr;
-      }
-
-      // TODO use a badMetadata instead of a nullptr?
-      const gd::ParameterMetadata* parameterMetadata = nullptr;
-      while (metadataParameterIndex <
-             metadata.parameters.size()) {
-        if (!metadata.parameters[metadataParameterIndex]
-                 .IsCodeOnly()) {
-          if (visibleParameterIndex == parameterIndex) {
-            parameterMetadata = &metadata.parameters[metadataParameterIndex];
-          }
-          visibleParameterIndex++;
-        }
-        metadataParameterIndex++;
-      }
-      const int visibleParameterCount = visibleParameterIndex;
-      // It can be null if there are too many parameters in the expression, this text node is
-      // not actually linked to a parameter expected by the function call.
-      return parameterMetadata;
+  return &numberExpressionMetadata != &badExpressionMetadata
+             ? numberExpressionMetadata
+             : &stringExpressionMetadata != &badExpressionMetadata
+                   ? stringExpressionMetadata
+                   : badExpressionMetadata;
 }
 
 MetadataProvider::~MetadataProvider() {}

Core/GDCore/Extensions/Metadata/MetadataProvider.h

@@ -15,8 +15,6 @@ class ExpressionMetadata;
 class ExpressionMetadata;
 class Platform;
 class PlatformExtension;
-struct FunctionCallNode;
-struct ExpressionNode;
 }  // namespace gd
 
 namespace gd {
@@ -236,26 +234,6 @@ class GD_CORE_API MetadataProvider {
   static const gd::ExpressionMetadata& GetObjectAnyExpressionMetadata(
       const gd::Platform& platform, gd::String objectType, gd::String exprType);
 
-  static const gd::ExpressionMetadata& GetFunctionCallMetadata(
-    const gd::Platform& platform, 
-    const gd::ObjectsContainer &globalObjectsContainer,
-    const gd::ObjectsContainer &objectsContainer,
-    FunctionCallNode& node);
-
-  static const gd::ParameterMetadata* GetFunctionCallParameterMetadata(
-    const gd::Platform& platform, 
-    const gd::ObjectsContainer &globalObjectsContainer,
-    const gd::ObjectsContainer &objectsContainer,
-    FunctionCallNode& functionCall,
-    ExpressionNode& parameter);
-
-  static const gd::ParameterMetadata* GetFunctionCallParameterMetadata(
-    const gd::Platform& platform, 
-    const gd::ObjectsContainer &globalObjectsContainer,
-    const gd::ObjectsContainer &objectsContainer,
-    FunctionCallNode& functionCall,
-    int parameterIndex);
-
   /**
    * Get information about an expression from its type.
    * Works for behavior expressions.

Core/GDCore/Extensions/Metadata/ParameterMetadata.cpp

@@ -35,18 +35,4 @@ void ParameterMetadata::UnserializeFrom(const SerializerElement& element) {
   name = element.GetStringAttribute("name");
 }
 
-  // TODO factorize in a file with an enum and helpers?
-  const gd::String ParameterMetadata::numberType = "number";
-  const gd::String ParameterMetadata::stringType = "string";
-
-  const gd::String &ParameterMetadata::GetExpressionValueType(const gd::String &parameterType) {
-    if (parameterType == "number" || gd::ParameterMetadata::IsExpression("number", parameterType)) {
-      return ParameterMetadata::numberType;
-    }
-    if (parameterType == "string" || gd::ParameterMetadata::IsExpression("string", parameterType)) {
-      return ParameterMetadata::stringType;
-    }
-    return parameterType;
-  }
-
 }  // namespace gd

Core/GDCore/Extensions/Metadata/ParameterMetadata.h

@@ -152,16 +152,15 @@ class GD_CORE_API ParameterMetadata {
   }
 
   /**
-   * \brief Return true if the type of the parameter is representing one object
-   * (or more, i.e: an object group).
+   * \brief Return true if the type of the parameter is "object", "objectPtr" or
+   * "objectList".
    *
    * \see gd::ParameterMetadata::GetType
    */
   static bool IsObject(const gd::String &parameterType) {
     return parameterType == "object" || parameterType == "objectPtr" ||
            parameterType == "objectList" ||
-           parameterType == "objectListOrEmptyIfJustDeclared" ||
-           parameterType == "objectListOrEmptyWithoutPicking";
+           parameterType == "objectListWithoutPicking";
   }
 
   /**
@@ -207,15 +206,6 @@ class GD_CORE_API ParameterMetadata {
     return false;
   }
 
-  /**
-   * \brief Return the expression type from the parameter type.
-   * Declinations of "number" and "string" types (like "forceMultiplier" or
-   * "sceneName") are replaced by "number" and "string".
-   */
-  static const gd::String &GetExpressionValueType(const gd::String &parameterType);
-  static const gd::String numberType;
-  static const gd::String stringType;
-
   /** \name Serialization
    */
   ///@{

Core/GDCore/Extensions/Metadata/ParameterMetadataTools.cpp

@@ -14,7 +14,7 @@
 
 namespace gd {
 void ParameterMetadataTools::ParametersToObjectsContainer(
-    const gd::Project& project,
+    gd::Project& project,
     const std::vector<gd::ParameterMetadata>& parameters,
     gd::ObjectsContainer& outputObjectsContainer) {
   outputObjectsContainer.GetObjects().clear();
@@ -59,13 +59,13 @@ void ParameterMetadataTools::IterateOverParameters(
     const std::vector<gd::Expression>& parameters,
     const std::vector<gd::ParameterMetadata>& parametersMetadata,
     std::function<void(const gd::ParameterMetadata& parameterMetadata,
-                       const gd::Expression& parameterValue,
+                       const gd::String& parameterValue,
                        const gd::String& lastObjectName)> fn) {
   IterateOverParametersWithIndex(
       parameters,
       parametersMetadata,
       [&fn](const gd::ParameterMetadata& parameterMetadata,
-            const gd::Expression& parameterValue,
+            const gd::String& parameterValue,
             size_t parameterIndex,
             const gd::String& lastObjectName) {
         fn(parameterMetadata, parameterValue, lastObjectName);
@@ -76,17 +76,17 @@ void ParameterMetadataTools::IterateOverParametersWithIndex(
     const std::vector<gd::Expression>& parameters,
     const std::vector<gd::ParameterMetadata>& parametersMetadata,
     std::function<void(const gd::ParameterMetadata& parameterMetadata,
-                       const gd::Expression& parameterValue,
+                       const gd::String& parameterValue,
                        size_t parameterIndex,
                        const gd::String& lastObjectName)> fn) {
   gd::String lastObjectName = "";
   for (std::size_t pNb = 0; pNb < parametersMetadata.size(); ++pNb) {
     const gd::ParameterMetadata& parameterMetadata = parametersMetadata[pNb];
-    const gd::Expression& parameterValue =
+    const gd::String& parameterValue =
         pNb < parameters.size() ? parameters[pNb].GetPlainString() : "";
-    const gd::Expression& parameterValueOrDefault =
-        parameterValue.GetPlainString().empty() && parameterMetadata.optional
-            ? Expression(parameterMetadata.GetDefaultValue())
+    const gd::String& parameterValueOrDefault =
+        parameterValue.empty() && parameterMetadata.optional
+            ? parameterMetadata.GetDefaultValue()
             : parameterValue;
 
     fn(parameterMetadata, parameterValueOrDefault, pNb, lastObjectName);
@@ -97,7 +97,7 @@ void ParameterMetadataTools::IterateOverParametersWithIndex(
     // Search "lastObjectName" in the codebase for other place where this
     // convention is enforced.
     if (gd::ParameterMetadata::IsObject(parameterMetadata.GetType()))
-      lastObjectName = parameterValueOrDefault.GetPlainString();
+      lastObjectName = parameterValueOrDefault;
   }
 }
 

Core/GDCore/Extensions/Metadata/ParameterMetadataTools.h

@@ -19,7 +19,7 @@ namespace gd {
 class GD_CORE_API ParameterMetadataTools {
  public:
   static void ParametersToObjectsContainer(
-      const gd::Project& project,
+      gd::Project& project,
       const std::vector<gd::ParameterMetadata>& parameters,
       gd::ObjectsContainer& outputObjectsContainer);
 
@@ -32,7 +32,7 @@ class GD_CORE_API ParameterMetadataTools {
       const std::vector<gd::Expression>& parameters,
       const std::vector<gd::ParameterMetadata>& parametersMetadata,
       std::function<void(const gd::ParameterMetadata& parameterMetadata,
-                         const gd::Expression& parameterValue,
+                         const gd::String& parameterValue,
                          const gd::String& lastObjectName)> fn);
 
   /**
@@ -44,7 +44,7 @@ class GD_CORE_API ParameterMetadataTools {
       const std::vector<gd::Expression>& parameters,
       const std::vector<gd::ParameterMetadata>& parametersMetadata,
       std::function<void(const gd::ParameterMetadata& parameterMetadata,
-                         const gd::Expression& parameterValue,
+                         const gd::String& parameterValue,
                          size_t parameterIndex,
                          const gd::String& lastObjectName)> fn);
 

Core/GDCore/Extensions/PlatformExtension.cpp

@@ -346,11 +346,6 @@ gd::BehaviorMetadata& PlatformExtension::GetBehaviorMetadata(
   return badBehaviorMetadata;
 }
 
-bool PlatformExtension::HasBehavior(
-    const gd::String& behaviorType) const {
-  return behaviorsInfo.find(behaviorType) != behaviorsInfo.end();
-}
-
 gd::EffectMetadata& PlatformExtension::GetEffectMetadata(
     const gd::String& effectName) {
   if (effectsMetadata.find(effectName) != effectsMetadata.end())
@@ -380,7 +375,7 @@ gd::InstructionMetadata& PlatformExtension::AddDuplicatedAction(
 
   auto copiedAction = actionsInfos.find(copiedNameWithNamespace);
   if (copiedAction == actionsInfos.end()) {
-    gd::LogError("Could not find an action with name " +
+    gd::LogWarning("Could not find an action with name " +
                    copiedNameWithNamespace + " to copy.");
   } else {
     actionsInfos[newNameWithNamespace] = copiedAction->second;
@@ -400,7 +395,7 @@ gd::InstructionMetadata& PlatformExtension::AddDuplicatedCondition(
 
   auto copiedCondition = conditionsInfos.find(copiedNameWithNamespace);
   if (copiedCondition == conditionsInfos.end()) {
-    gd::LogError("Could not find a condition with name " +
+    gd::LogWarning("Could not find a condition with name " +
                    copiedNameWithNamespace + " to copy.");
   } else {
     conditionsInfos[newNameWithNamespace] = copiedCondition->second;
@@ -417,7 +412,7 @@ gd::ExpressionMetadata& PlatformExtension::AddDuplicatedExpression(
 
   auto copiedExpression = expressionsInfos.find(copiedNameWithNamespace);
   if (copiedExpression == expressionsInfos.end()) {
-    gd::LogError("Could not find an expression with name " +
+    gd::LogWarning("Could not find an expression with name " +
                    copiedNameWithNamespace + " to copy.");
   } else {
     expressionsInfos[newNameWithNamespace] = copiedExpression->second;
@@ -434,7 +429,7 @@ gd::ExpressionMetadata& PlatformExtension::AddDuplicatedStrExpression(
 
   auto copiedExpression = strExpressionsInfos.find(copiedNameWithNamespace);
   if (copiedExpression == strExpressionsInfos.end()) {
-    gd::LogError("Could not find a string expression with name " +
+    gd::LogWarning("Could not find a string expression with name " +
                    copiedNameWithNamespace + " to copy.");
   } else {
     strExpressionsInfos[newNameWithNamespace] = copiedExpression->second;

Core/GDCore/Extensions/PlatformExtension.h

@@ -467,12 +467,6 @@ class GD_CORE_API PlatformExtension {
    */
   BehaviorMetadata& GetBehaviorMetadata(const gd::String& behaviorType);
 
-  /**
-   * \brief Return true if the extension contains a behavior associated to \a
-   * behaviorType
-   */
-  bool HasBehavior(const gd::String& behaviorType) const;
-
   /**
    * \brief Return the metadata for the effect with the given name.
    */

Core/GDCore/IDE/Events/EventsBehaviorRenamer.cpp

@@ -11,6 +11,7 @@
 
 #include "GDCore/Events/Event.h"
 #include "GDCore/Events/EventsList.h"
+#include "GDCore/Events/Parsers/ExpressionParser2.h"
 #include "GDCore/Events/Parsers/ExpressionParser2NodePrinter.h"
 #include "GDCore/Events/Parsers/ExpressionParser2NodeWorker.h"
 #include "GDCore/Extensions/Metadata/MetadataProvider.h"
@@ -117,20 +118,27 @@ bool EventsBehaviorRenamer::DoVisitInstruction(gd::Instruction& instruction,
       instruction.GetParameters(),
       metadata.GetParameters(),
       [&](const gd::ParameterMetadata& parameterMetadata,
-          const gd::Expression& parameterValue,
+          const gd::String& parameterValue,
           size_t parameterIndex,
           const gd::String& lastObjectName) {
         const gd::String& type = parameterMetadata.type;
 
         if (gd::ParameterMetadata::IsBehavior(type)) {
           if (lastObjectName == objectName) {
-            if (parameterValue.GetPlainString() == oldBehaviorName) {
+            if (parameterValue == oldBehaviorName) {
               instruction.SetParameter(parameterIndex,
                                        gd::Expression(newBehaviorName));
             }
           }
         } else {
-          auto node = parameterValue.GetRootNode();
+          gd::ExpressionParser2 parser(
+              platform, GetGlobalObjectsContainer(), GetObjectsContainer());
+          auto node =
+              gd::ParameterMetadata::IsExpression("number", type)
+                  ? parser.ParseExpression("number", parameterValue)
+                  : (gd::ParameterMetadata::IsExpression("string", type)
+                         ? parser.ParseExpression("string", parameterValue)
+                         : std::unique_ptr<gd::ExpressionNode>());
           if (node) {
             ExpressionBehaviorRenamer renamer(GetGlobalObjectsContainer(),
                                               GetObjectsContainer(),

Core/GDCore/IDE/Events/EventsContextAnalyzer.cpp

@@ -9,6 +9,7 @@
 #include <vector>
 #include "GDCore/Events/Event.h"
 #include "GDCore/Events/EventsList.h"
+#include "GDCore/Events/Parsers/ExpressionParser2.h"
 #include "GDCore/Events/Parsers/ExpressionParser2NodePrinter.h"
 #include "GDCore/Events/Parsers/ExpressionParser2NodeWorker.h"
 #include "GDCore/Extensions/Metadata/ExpressionMetadata.h"
@@ -16,7 +17,6 @@
 #include "GDCore/Extensions/Metadata/MetadataProvider.h"
 #include "GDCore/Extensions/Metadata/ParameterMetadataTools.h"
 #include "GDCore/IDE/Events/ExpressionValidator.h"
-#include "GDCore/IDE/Events/ExpressionTypeFinder.h"
 #include "GDCore/Project/Layout.h"
 #include "GDCore/Project/Project.h"
 #include "GDCore/String.h"
@@ -31,17 +31,7 @@ namespace gd {
 class GD_CORE_API ExpressionObjectsAnalyzer
     : public ExpressionParser2NodeWorker {
  public:
-  ExpressionObjectsAnalyzer(
-        const gd::Platform &platform_,
-        const gd::ObjectsContainer &globalObjectsContainer_,
-        const gd::ObjectsContainer &objectsContainer_,
-        const gd::String &rootType_,
-        EventsContext& context_) :
-        platform(platform_),
-        globalObjectsContainer(globalObjectsContainer_),
-        objectsContainer(objectsContainer_),
-        rootType(rootType_),
-        context(context_){};
+  ExpressionObjectsAnalyzer(EventsContext& context_) : context(context_){};
   virtual ~ExpressionObjectsAnalyzer(){};
 
  protected:
@@ -69,8 +59,7 @@ class GD_CORE_API ExpressionObjectsAnalyzer
     if (node.child) node.child->Visit(*this);
   }
   void OnVisitIdentifierNode(IdentifierNode& node) override {
-    auto type = gd::ExpressionTypeFinder::GetType(platform, globalObjectsContainer, objectsContainer, rootType, node);
-    if (gd::ParameterMetadata::IsObject(type)) {
+    if (gd::ParameterMetadata::IsObject(node.type)) {
       context.AddObjectName(node.identifierName);
     }
   }
@@ -98,11 +87,6 @@ class GD_CORE_API ExpressionObjectsAnalyzer
   void OnVisitEmptyNode(EmptyNode& node) override {}
 
  private:
-  const gd::Platform &platform;
-  const gd::ObjectsContainer &globalObjectsContainer;
-  const gd::ObjectsContainer &objectsContainer;
-  const gd::String rootType;
-
   EventsContext& context;
 };
 
@@ -118,7 +102,7 @@ bool EventsContextAnalyzer::DoVisitInstruction(gd::Instruction& instruction,
       instruction.GetParameters(),
       instrInfo.parameters,
       [this](const gd::ParameterMetadata& parameterMetadata,
-             const gd::Expression& parameterValue,
+             const gd::String& parameterValue,
              const gd::String& lastObjectName) {
         AnalyzeParameter(platform,
                          project,
@@ -145,14 +129,16 @@ void EventsContextAnalyzer::AnalyzeParameter(
   if (ParameterMetadata::IsObject(type)) {
     context.AddObjectName(value);
   } else if (ParameterMetadata::IsExpression("number", type)) {
-    auto node = parameter.GetRootNode();
+    gd::ExpressionParser2 parser(platform, project, layout);
+    auto node = parser.ParseExpression("number", value);
 
-    ExpressionObjectsAnalyzer analyzer(platform, project, layout, "number", context);
+    ExpressionObjectsAnalyzer analyzer(context);
     node->Visit(analyzer);
   } else if (ParameterMetadata::IsExpression("string", type)) {
-    auto node = parameter.GetRootNode();
+    gd::ExpressionParser2 parser(platform, project, layout);
+    auto node = parser.ParseExpression("string", value);
 
-    ExpressionObjectsAnalyzer analyzer(platform, project, layout, "string", context);
+    ExpressionObjectsAnalyzer analyzer(context);
     node->Visit(analyzer);
   } else if (ParameterMetadata::IsBehavior(type)) {
     context.AddBehaviorName(lastObjectName, value);

Core/GDCore/IDE/Events/EventsRefactorer.cpp

@@ -11,15 +11,15 @@
 #include "GDCore/CommonTools.h"
 #include "GDCore/Events/Event.h"
 #include "GDCore/Events/EventsList.h"
+#include "GDCore/Events/Parsers/ExpressionParser2.h"
 #include "GDCore/Events/Parsers/ExpressionParser2NodePrinter.h"
 #include "GDCore/Events/Parsers/ExpressionParser2NodeWorker.h"
 #include "GDCore/Extensions/Metadata/ExpressionMetadata.h"
 #include "GDCore/Extensions/Metadata/MetadataProvider.h"
 #include "GDCore/Extensions/Platform.h"
 #include "GDCore/IDE/Events/ExpressionValidator.h"
-#include "GDCore/IDE/Events/InstructionSentenceFormatter.h"
 #include "GDCore/Project/ObjectsContainer.h"
-#include "GDCore/IDE/Events/ExpressionTypeFinder.h"
+#include "GDCore/IDE/Events/InstructionSentenceFormatter.h"
 
 using namespace std;
 
@@ -34,30 +34,18 @@ const gd::String EventsRefactorer::searchIgnoredCharacters = ";:,#()";
  */
 class GD_CORE_API ExpressionObjectRenamer : public ExpressionParser2NodeWorker {
  public:
-  ExpressionObjectRenamer(const gd::Platform &platform_,
-                          const gd::ObjectsContainer &globalObjectsContainer_,
-                          const gd::ObjectsContainer &objectsContainer_,
-                          const gd::String &rootType_,
-                          const gd::String& objectName_,
+  ExpressionObjectRenamer(const gd::String& objectName_,
                           const gd::String& objectNewName_)
-      : platform(platform_),
-        globalObjectsContainer(globalObjectsContainer_),
-        objectsContainer(objectsContainer_),
-        rootType(rootType_),
-        hasDoneRenaming(false),
+      : hasDoneRenaming(false),
         objectName(objectName_),
         objectNewName(objectNewName_){};
   virtual ~ExpressionObjectRenamer(){};
 
-  static bool Rename(const gd::Platform &platform,
-                     const gd::ObjectsContainer &globalObjectsContainer,
-                     const gd::ObjectsContainer &objectsContainer,
-                     const gd::String &rootType,
-                     gd::ExpressionNode& node,
+  static bool Rename(gd::ExpressionNode& node,
                      const gd::String& objectName,
                      const gd::String& objectNewName) {
-    if (gd::ExpressionValidator::HasNoErrors(platform, globalObjectsContainer, objectsContainer, rootType, node)) {
-      ExpressionObjectRenamer renamer(platform, globalObjectsContainer, objectsContainer, rootType, objectName, objectNewName);
+    if (ExpressionValidator::HasNoErrors(node)) {
+      ExpressionObjectRenamer renamer(objectName, objectNewName);
       node.Visit(renamer);
 
       return renamer.HasDoneRenaming();
@@ -93,8 +81,7 @@ class GD_CORE_API ExpressionObjectRenamer : public ExpressionParser2NodeWorker {
     if (node.child) node.child->Visit(*this);
   }
   void OnVisitIdentifierNode(IdentifierNode& node) override {
-    auto type = gd::ExpressionTypeFinder::GetType(platform, globalObjectsContainer, objectsContainer, rootType, node);
-    if (gd::ParameterMetadata::IsObject(type) &&
+    if (gd::ParameterMetadata::IsObject(node.type) &&
         node.identifierName == objectName) {
       hasDoneRenaming = true;
       node.identifierName = objectNewName;
@@ -121,11 +108,6 @@ class GD_CORE_API ExpressionObjectRenamer : public ExpressionParser2NodeWorker {
   bool hasDoneRenaming;
   const gd::String& objectName;
   const gd::String& objectNewName;
-  
-  const gd::Platform &platform;
-  const gd::ObjectsContainer &globalObjectsContainer;
-  const gd::ObjectsContainer &objectsContainer;
-  const gd::String rootType;
 };
 
 /**
@@ -136,27 +118,14 @@ class GD_CORE_API ExpressionObjectRenamer : public ExpressionParser2NodeWorker {
  */
 class GD_CORE_API ExpressionObjectFinder : public ExpressionParser2NodeWorker {
  public:
-  ExpressionObjectFinder(const gd::Platform &platform_,
-                         const gd::ObjectsContainer &globalObjectsContainer_,
-                         const gd::ObjectsContainer &objectsContainer_,
-                         const gd::String &rootType_,
-                         const gd::String& objectName_)
-      : platform(platform_),
-        globalObjectsContainer(globalObjectsContainer_),
-        objectsContainer(objectsContainer_),
-        rootType(rootType_),
-        hasObject(false),
-        objectName(objectName_){};
+  ExpressionObjectFinder(const gd::String& objectName_)
+      : hasObject(false), objectName(objectName_){};
   virtual ~ExpressionObjectFinder(){};
 
-  static bool CheckIfHasObject(const gd::Platform &platform,
-                               const gd::ObjectsContainer &globalObjectsContainer,
-                               const gd::ObjectsContainer &objectsContainer,
-                               const gd::String &rootType,
-                               gd::ExpressionNode& node,
+  static bool CheckIfHasObject(gd::ExpressionNode& node,
                                const gd::String& objectName) {
-    if (gd::ExpressionValidator::HasNoErrors(platform, globalObjectsContainer, objectsContainer, rootType, node)) {
-      ExpressionObjectFinder finder(platform, globalObjectsContainer, objectsContainer, rootType, objectName);
+    if (ExpressionValidator::HasNoErrors(node)) {
+      ExpressionObjectFinder finder(objectName);
       node.Visit(finder);
 
       return finder.HasFoundObject();
@@ -192,8 +161,7 @@ class GD_CORE_API ExpressionObjectFinder : public ExpressionParser2NodeWorker {
     if (node.child) node.child->Visit(*this);
   }
   void OnVisitIdentifierNode(IdentifierNode& node) override {
-    auto type = gd::ExpressionTypeFinder::GetType(platform, globalObjectsContainer, objectsContainer, rootType, node);
-    if (gd::ParameterMetadata::IsObject(type) &&
+    if (gd::ParameterMetadata::IsObject(node.type) &&
         node.identifierName == objectName) {
       hasObject = true;
     }
@@ -216,11 +184,6 @@ class GD_CORE_API ExpressionObjectFinder : public ExpressionParser2NodeWorker {
  private:
   bool hasObject;
   const gd::String& objectName;
-  
-  const gd::Platform &platform;
-  const gd::ObjectsContainer &globalObjectsContainer;
-  const gd::ObjectsContainer &objectsContainer;
-  const gd::String rootType;
 };
 
 bool EventsRefactorer::RenameObjectInActions(const gd::Platform& platform,
@@ -242,9 +205,11 @@ bool EventsRefactorer::RenameObjectInActions(const gd::Platform& platform,
       // Replace object's name in expressions
       else if (ParameterMetadata::IsExpression(
                    "number", instrInfos.parameters[pNb].type)) {
-        auto node = actions[aId].GetParameter(pNb).GetRootNode();
+        gd::ExpressionParser2 parser(platform, project, layout);
+        auto node = parser.ParseExpression(
+            "number", actions[aId].GetParameter(pNb).GetPlainString());
 
-        if (ExpressionObjectRenamer::Rename(platform, project, layout, "number", *node, oldName, newName)) {
+        if (ExpressionObjectRenamer::Rename(*node, oldName, newName)) {
           actions[aId].SetParameter(
               pNb, ExpressionParser2NodePrinter::PrintNode(*node));
         }
@@ -252,9 +217,11 @@ bool EventsRefactorer::RenameObjectInActions(const gd::Platform& platform,
       // Replace object's name in text expressions
       else if (ParameterMetadata::IsExpression(
                    "string", instrInfos.parameters[pNb].type)) {
-        auto node = actions[aId].GetParameter(pNb).GetRootNode();
+        gd::ExpressionParser2 parser(platform, project, layout);
+        auto node = parser.ParseExpression(
+            "string", actions[aId].GetParameter(pNb).GetPlainString());
 
-        if (ExpressionObjectRenamer::Rename(platform, project, layout, "string", *node, oldName, newName)) {
+        if (ExpressionObjectRenamer::Rename(*node, oldName, newName)) {
           actions[aId].SetParameter(
               pNb, ExpressionParser2NodePrinter::PrintNode(*node));
         }
@@ -296,9 +263,11 @@ bool EventsRefactorer::RenameObjectInConditions(
       // Replace object's name in expressions
       else if (ParameterMetadata::IsExpression(
                    "number", instrInfos.parameters[pNb].type)) {
-        auto node = conditions[cId].GetParameter(pNb).GetRootNode();
+        gd::ExpressionParser2 parser(platform, project, layout);
+        auto node = parser.ParseExpression(
+            "number", conditions[cId].GetParameter(pNb).GetPlainString());
 
-        if (ExpressionObjectRenamer::Rename(platform, project, layout, "number", *node, oldName, newName)) {
+        if (ExpressionObjectRenamer::Rename(*node, oldName, newName)) {
           conditions[cId].SetParameter(
               pNb, ExpressionParser2NodePrinter::PrintNode(*node));
         }
@@ -306,9 +275,11 @@ bool EventsRefactorer::RenameObjectInConditions(
       // Replace object's name in text expressions
       else if (ParameterMetadata::IsExpression(
                    "string", instrInfos.parameters[pNb].type)) {
-        auto node = conditions[cId].GetParameter(pNb).GetRootNode();
+        gd::ExpressionParser2 parser(platform, project, layout);
+        auto node = parser.ParseExpression(
+            "string", conditions[cId].GetParameter(pNb).GetPlainString());
 
-        if (ExpressionObjectRenamer::Rename(platform, project, layout, "string", *node, oldName, newName)) {
+        if (ExpressionObjectRenamer::Rename(*node, oldName, newName)) {
           conditions[cId].SetParameter(
               pNb, ExpressionParser2NodePrinter::PrintNode(*node));
         }
@@ -345,18 +316,20 @@ bool EventsRefactorer::RenameObjectInEventParameters(
   // Replace object's name in expressions
   else if (ParameterMetadata::IsExpression("number",
                                            parameterMetadata.GetType())) {
-    auto node = expression.GetRootNode();
+    gd::ExpressionParser2 parser(platform, project, layout);
+    auto node = parser.ParseExpression("number", expression.GetPlainString());
 
-    if (ExpressionObjectRenamer::Rename(platform, project, layout, "number", *node, oldName, newName)) {
+    if (ExpressionObjectRenamer::Rename(*node, oldName, newName)) {
       expression = ExpressionParser2NodePrinter::PrintNode(*node);
     }
   }
   // Replace object's name in text expressions
   else if (ParameterMetadata::IsExpression("string",
                                            parameterMetadata.GetType())) {
-    auto node = expression.GetRootNode();
+    gd::ExpressionParser2 parser(platform, project, layout);
+    auto node = parser.ParseExpression("string", expression.GetPlainString());
 
-    if (ExpressionObjectRenamer::Rename(platform, project, layout, "string", *node, oldName, newName)) {
+    if (ExpressionObjectRenamer::Rename(*node, oldName, newName)) {
       expression = ExpressionParser2NodePrinter::PrintNode(*node);
     }
   }
@@ -432,9 +405,11 @@ bool EventsRefactorer::RemoveObjectInActions(const gd::Platform& platform,
       // Find object's name in expressions
       else if (ParameterMetadata::IsExpression(
                    "number", instrInfos.parameters[pNb].type)) {
-        auto node = actions[aId].GetParameter(pNb).GetRootNode();
+        gd::ExpressionParser2 parser(platform, project, layout);
+        auto node = parser.ParseExpression(
+            "number", actions[aId].GetParameter(pNb).GetPlainString());
 
-        if (ExpressionObjectFinder::CheckIfHasObject(platform, project, layout, "number", *node, name)) {
+        if (ExpressionObjectFinder::CheckIfHasObject(*node, name)) {
           deleteMe = true;
           break;
         }
@@ -442,9 +417,11 @@ bool EventsRefactorer::RemoveObjectInActions(const gd::Platform& platform,
       // Find object's name in text expressions
       else if (ParameterMetadata::IsExpression(
                    "string", instrInfos.parameters[pNb].type)) {
-        auto node = actions[aId].GetParameter(pNb).GetRootNode();
+        gd::ExpressionParser2 parser(platform, project, layout);
+        auto node = parser.ParseExpression(
+            "string", actions[aId].GetParameter(pNb).GetPlainString());
 
-        if (ExpressionObjectFinder::CheckIfHasObject(platform, project, layout, "string", *node, name)) {
+        if (ExpressionObjectFinder::CheckIfHasObject(*node, name)) {
           deleteMe = true;
           break;
         }
@@ -492,9 +469,11 @@ bool EventsRefactorer::RemoveObjectInConditions(
       // Find object's name in expressions
       else if (ParameterMetadata::IsExpression(
                    "number", instrInfos.parameters[pNb].type)) {
-        auto node = conditions[cId].GetParameter(pNb).GetRootNode();
+        gd::ExpressionParser2 parser(platform, project, layout);
+        auto node = parser.ParseExpression(
+            "number", conditions[cId].GetParameter(pNb).GetPlainString());
 
-        if (ExpressionObjectFinder::CheckIfHasObject(platform, project, layout, "number", *node, name)) {
+        if (ExpressionObjectFinder::CheckIfHasObject(*node, name)) {
           deleteMe = true;
           break;
         }
@@ -502,9 +481,11 @@ bool EventsRefactorer::RemoveObjectInConditions(
       // Find object's name in text expressions
       else if (ParameterMetadata::IsExpression(
                    "string", instrInfos.parameters[pNb].type)) {
-        auto node = conditions[cId].GetParameter(pNb).GetRootNode();
+        gd::ExpressionParser2 parser(platform, project, layout);
+        auto node = parser.ParseExpression(
+            "string", conditions[cId].GetParameter(pNb).GetPlainString());
 
-        if (ExpressionObjectFinder::CheckIfHasObject(platform, project, layout, "string", *node, name)) {
+        if (ExpressionObjectFinder::CheckIfHasObject(*node, name)) {
           deleteMe = true;
           break;
         }
@@ -554,19 +535,16 @@ void EventsRefactorer::RemoveObjectInEvents(const gd::Platform& platform,
   }
 }
 
-std::vector<EventsSearchResult> EventsRefactorer::ReplaceStringInEvents(
-    gd::ObjectsContainer& project,
-    gd::ObjectsContainer& layout,
-    gd::EventsList& events,
-    gd::String toReplace,
-    gd::String newString,
-    bool matchCase,
-    bool inConditions,
-    bool inActions,
-    bool inEventStrings) {
-  vector<EventsSearchResult> modifiedEvents;
+void EventsRefactorer::ReplaceStringInEvents(gd::ObjectsContainer& project,
+                                             gd::ObjectsContainer& layout,
+                                             gd::EventsList& events,
+                                             gd::String toReplace,
+                                             gd::String newString,
+                                             bool matchCase,
+                                             bool inConditions,
+                                             bool inActions,
+                                             bool inEventStrings) {
   for (std::size_t i = 0; i < events.size(); ++i) {
-    bool eventModified = false;
     if (inConditions) {
       vector<gd::InstructionsList*> conditionsVectors =
           events[i].GetAllConditionsVectors();
@@ -578,13 +556,6 @@ std::vector<EventsSearchResult> EventsRefactorer::ReplaceStringInEvents(
                                       toReplace,
                                       newString,
                                       matchCase);
-        if (conditionsModified && !eventModified) {
-          modifiedEvents.push_back(EventsSearchResult(
-              std::weak_ptr<gd::BaseEvent>(events.GetEventSmartPtr(i)),
-              &events,
-              i));
-          eventModified = true;
-        }
       }
     }
 
@@ -598,45 +569,25 @@ std::vector<EventsSearchResult> EventsRefactorer::ReplaceStringInEvents(
                                                       toReplace,
                                                       newString,
                                                       matchCase);
-        if (actionsModified && !eventModified) {
-          modifiedEvents.push_back(EventsSearchResult(
-              std::weak_ptr<gd::BaseEvent>(events.GetEventSmartPtr(i)),
-              &events,
-              i));
-          eventModified = true;
-        }
       }
     }
 
     if (inEventStrings) {
       bool eventStringModified = ReplaceStringInEventSearchableStrings(
           project, layout, events[i], toReplace, newString, matchCase);
-      if (eventStringModified && !eventModified) {
-        modifiedEvents.push_back(EventsSearchResult(
-            std::weak_ptr<gd::BaseEvent>(events.GetEventSmartPtr(i)),
-            &events,
-            i));
-        eventModified = true;
-      }
     }
 
-    if (events[i].CanHaveSubEvents()) {
-      std::vector<EventsSearchResult> modifiedSubEvent =
-          ReplaceStringInEvents(project,
-                                layout,
-                                events[i].GetSubEvents(),
-                                toReplace,
-                                newString,
-                                matchCase,
-                                inConditions,
-                                inActions,
-                                inEventStrings);
-      std::copy(modifiedSubEvent.begin(),
-                modifiedSubEvent.end(),
-                std::back_inserter(modifiedEvents));
-    }
+    if (events[i].CanHaveSubEvents())
+      ReplaceStringInEvents(project,
+                            layout,
+                            events[i].GetSubEvents(),
+                            toReplace,
+                            newString,
+                            matchCase,
+                            inConditions,
+                            inActions,
+                            inEventStrings);
   }
-  return modifiedEvents;
 }
 
 gd::String ReplaceAllOccurencesCaseUnsensitive(gd::String context,
@@ -767,16 +718,14 @@ vector<EventsSearchResult> EventsRefactorer::SearchInEvents(
     bool inEventSentences) {
   vector<EventsSearchResult> results;
 
-  const gd::String& ignored_characters =
-      EventsRefactorer::searchIgnoredCharacters;
+  const gd::String& ignored_characters = EventsRefactorer::searchIgnoredCharacters;
 
-  search.replace_if(
-      search.begin(),
-      search.end(),
-      [ignored_characters](const char& c) {
-        return ignored_characters.find(c) != gd::String::npos;
-      },
-      "");
+  search.replace_if(search.begin(),
+                    search.end(),
+                    [ignored_characters](const char &c) {
+                      return ignored_characters.find(c) != gd::String::npos;
+                    },
+                    "");
   search = search.LeftTrim().RightTrim();
   search.RemoveConsecutiveOccurrences(search.begin(), search.end(), ' ');
 
@@ -788,11 +737,8 @@ vector<EventsSearchResult> EventsRefactorer::SearchInEvents(
           events[i].GetAllConditionsVectors();
       for (std::size_t j = 0; j < conditionsVectors.size(); ++j) {
         if (!eventAddedInResults &&
-            SearchStringInConditions(platform,
-                                     *conditionsVectors[j],
-                                     search,
-                                     matchCase,
-                                     inEventSentences)) {
+            SearchStringInConditions(
+                platform, *conditionsVectors[j], search, matchCase, inEventSentences)) {
           results.push_back(EventsSearchResult(
               std::weak_ptr<gd::BaseEvent>(events.GetEventSmartPtr(i)),
               &events,
@@ -805,11 +751,9 @@ vector<EventsSearchResult> EventsRefactorer::SearchInEvents(
       vector<gd::InstructionsList*> actionsVectors =
           events[i].GetAllActionsVectors();
       for (std::size_t j = 0; j < actionsVectors.size(); ++j) {
-        if (!eventAddedInResults && SearchStringInActions(platform,
-                                                          *actionsVectors[j],
-                                                          search,
-                                                          matchCase,
-                                                          inEventSentences)) {
+        if (!eventAddedInResults &&
+            SearchStringInActions(
+                platform, *actionsVectors[j], search, matchCase, inEventSentences)) {
           results.push_back(EventsSearchResult(
               std::weak_ptr<gd::BaseEvent>(events.GetEventSmartPtr(i)),
               &events,
@@ -846,11 +790,12 @@ vector<EventsSearchResult> EventsRefactorer::SearchInEvents(
   return results;
 }
 
-bool EventsRefactorer::SearchStringInActions(const gd::Platform& platform,
-                                             gd::InstructionsList& actions,
-                                             gd::String search,
-                                             bool matchCase,
-                                             bool inSentences) {
+bool EventsRefactorer::SearchStringInActions(
+    const gd::Platform& platform,
+    gd::InstructionsList& actions,
+    gd::String search,
+    bool matchCase,
+    bool inSentences) {
   for (std::size_t aId = 0; aId < actions.size(); ++aId) {
     for (std::size_t pNb = 0; pNb < actions[aId].GetParameters().size();
          ++pNb) {
@@ -881,30 +826,27 @@ bool EventsRefactorer::SearchStringInActions(const gd::Platform& platform,
   return false;
 }
 
-bool EventsRefactorer::SearchStringInFormattedText(const gd::Platform& platform,
-                                                   gd::Instruction& instruction,
-                                                   gd::String search,
-                                                   bool matchCase,
-                                                   bool isCondition) {
+bool EventsRefactorer::SearchStringInFormattedText(
+    const gd::Platform& platform,
+    gd::Instruction& instruction,
+    gd::String search,
+    bool matchCase,
+    bool isCondition) {
   const auto& metadata = isCondition
-                             ? gd::MetadataProvider::GetConditionMetadata(
-                                   platform, instruction.GetType())
-                             : gd::MetadataProvider::GetActionMetadata(
-                                   platform, instruction.GetType());
-  gd::String completeSentence =
-      gd::InstructionSentenceFormatter::Get()->GetFullText(instruction,
-                                                           metadata);
+                            ? gd::MetadataProvider::GetConditionMetadata(
+                                  platform, instruction.GetType())
+                            : gd::MetadataProvider::GetActionMetadata(
+                                  platform, instruction.GetType());
+  gd::String completeSentence = gd::InstructionSentenceFormatter::Get()->GetFullText(instruction, metadata);
 
-  const gd::String& ignored_characters =
-      EventsRefactorer::searchIgnoredCharacters;
+  const gd::String& ignored_characters = EventsRefactorer::searchIgnoredCharacters;
 
-  completeSentence.replace_if(
-      completeSentence.begin(),
-      completeSentence.end(),
-      [ignored_characters](const char& c) {
-        return ignored_characters.find(c) != gd::String::npos;
-      },
-      "");
+  completeSentence.replace_if(completeSentence.begin(),
+                              completeSentence.end(),
+                              [ignored_characters](const char &c) {
+                                return ignored_characters.find(c) != gd::String::npos;
+                              },
+                              "");
 
   completeSentence.RemoveConsecutiveOccurrences(
       completeSentence.begin(), completeSentence.end(), ' ');

Core/GDCore/IDE/Events/EventsRefactorer.h

@@ -7,7 +7,6 @@
 #define GDCORE_EVENTSREFACTORER_H
 #include <memory>
 #include <vector>
-
 #include "GDCore/Events/Instruction.h"
 #include "GDCore/Extensions/Metadata/InstructionMetadata.h"
 #include "GDCore/String.h"
@@ -19,7 +18,7 @@ class ExternalEvents;
 class BaseEvent;
 class Instruction;
 typedef std::shared_ptr<gd::BaseEvent> BaseEventSPtr;
-}  // namespace gd
+}
 
 namespace gd {
 
@@ -44,11 +43,10 @@ class GD_CORE_API EventsSearchResult {
   bool IsEventsListValid() const { return eventsList != nullptr; }
 
   /**
-   * \brief Get the events list containing the event pointed by the
-   * EventsSearchResult. \warning Only call this when IsEventsListValid returns
-   * true.
+   * \brief Get the events list containing the event pointed by the EventsSearchResult.
+   * \warning Only call this when IsEventsListValid returns true.
    */
-  const gd::EventsList& GetEventsList() const { return *eventsList; }
+  const gd::EventsList & GetEventsList() const { return *eventsList; }
 
   std::size_t GetPositionInList() const { return positionInList; }
 
@@ -58,7 +56,7 @@ class GD_CORE_API EventsSearchResult {
    * \brief Get the event pointed by the EventsSearchResult.
    * \warning Only call this when IsEventValid returns true.
    */
-  const gd::BaseEvent& GetEvent() const { return *event.lock(); }
+  const gd::BaseEvent & GetEvent() const { return *event.lock(); }
 };
 
 /**
@@ -100,31 +98,27 @@ class GD_CORE_API EventsRefactorer {
    * \return A vector containing EventsSearchResult objects filled with events
    * containing the string
    */
-  static std::vector<EventsSearchResult> SearchInEvents(
-      const gd::Platform& platform,
-      gd::EventsList& events,
-      gd::String search,
-      bool matchCase,
-      bool inConditions,
-      bool inActions,
-      bool inEventStrings,
-      bool inEventSentences);
+  static std::vector<EventsSearchResult> SearchInEvents(const gd::Platform& platform,
+                                                        gd::EventsList& events,
+                                                        gd::String search,
+                                                        bool matchCase,
+                                                        bool inConditions,
+                                                        bool inActions,
+                                                        bool inEventStrings,
+                                                        bool inEventSentences);
 
   /**
    * Replace all occurrences of a gd::String in events
-   *
-   * \return A vector of all modified events.
    */
-  static std::vector<EventsSearchResult> ReplaceStringInEvents(
-      gd::ObjectsContainer& project,
-      gd::ObjectsContainer& layout,
-      gd::EventsList& events,
-      gd::String toReplace,
-      gd::String newString,
-      bool matchCase,
-      bool inConditions,
-      bool inActions,
-      bool inEventString);
+  static void ReplaceStringInEvents(gd::ObjectsContainer& project,
+                                    gd::ObjectsContainer& layout,
+                                    gd::EventsList& events,
+                                    gd::String toReplace,
+                                    gd::String newString,
+                                    bool matchCase,
+                                    bool inConditions,
+                                    bool inActions,
+                                    bool inEventString);
 
   virtual ~EventsRefactorer(){};
 
@@ -154,21 +148,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);
+  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

Core/GDCore/IDE/Events/EventsVariablesFinder.cpp

@@ -7,6 +7,7 @@
 #include "EventsVariablesFinder.h"
 #include "GDCore/Events/Event.h"
 #include "GDCore/Events/Instruction.h"
+#include "GDCore/Events/Parsers/ExpressionParser2.h"
 #include "GDCore/Events/Parsers/ExpressionParser2NodePrinter.h"
 #include "GDCore/Events/Parsers/ExpressionParser2NodeWorker.h"
 #include "GDCore/Extensions/Metadata/ExpressionMetadata.h"
@@ -31,16 +32,10 @@ namespace gd {
 class GD_CORE_API ExpressionParameterSearcher
     : public ExpressionParser2NodeWorker {
  public:
-  ExpressionParameterSearcher(const gd::Platform &platform_,
-                              const gd::ObjectsContainer &globalObjectsContainer_,
-                              const gd::ObjectsContainer &objectsContainer_,
-                              std::set<gd::String>& results_,
+  ExpressionParameterSearcher(std::set<gd::String>& results_,
                               const gd::String& parameterType_,
                               const gd::String& objectName_ = "")
-      : platform(platform_),
-        globalObjectsContainer(globalObjectsContainer_),
-        objectsContainer(objectsContainer_),
-        results(results_),
+      : results(results_),
         parameterType(parameterType_),
         objectName(objectName_){};
   virtual ~ExpressionParameterSearcher(){};
@@ -73,22 +68,10 @@ class GD_CORE_API ExpressionParameterSearcher
   void OnVisitObjectFunctionNameNode(ObjectFunctionNameNode& node) override {}
   void OnVisitFunctionCallNode(FunctionCallNode& node) override {
     bool considerFunction = objectName.empty() || node.objectName == objectName;
-
-    const gd::ExpressionMetadata &metadata = node.objectName.empty() ?
-          MetadataProvider::GetAnyExpressionMetadata(platform, node.functionName) :
-            MetadataProvider::GetObjectAnyExpressionMetadata(
-                platform,
-                GetTypeOfObject(globalObjectsContainer, objectsContainer, objectName),
-                node.functionName);
-
-    if (gd::MetadataProvider::IsBadExpressionMetadata(metadata)) {
-      return;
-    }
-    
     for (size_t i = 0; i < node.parameters.size() &&
-                       i < metadata.parameters.size();
+                       i < node.expressionMetadata.parameters.size();
          ++i) {
-      auto& parameterMetadata = metadata.parameters[i];
+      auto& parameterMetadata = node.expressionMetadata.parameters[i];
       if (considerFunction && parameterMetadata.GetType() == parameterType) {
         // Store the value of the parameter
         results.insert(
@@ -101,10 +84,6 @@ class GD_CORE_API ExpressionParameterSearcher
   void OnVisitEmptyNode(EmptyNode& node) override {}
 
  private:
-  const gd::Platform &platform;
-  const gd::ObjectsContainer &globalObjectsContainer;
-  const gd::ObjectsContainer &objectsContainer;
-
   std::set<gd::String>& results;  ///< Reference to the std::set where argument
                                   ///< values must be stored.
   gd::String parameterType;  ///< The type of the parameters to be searched for.
@@ -186,18 +165,24 @@ std::set<gd::String> EventsVariablesFinder::FindArgumentsInInstructions(
       }
       // Search in expressions
       else if (ParameterMetadata::IsExpression(
-                   "number", instrInfos.parameters[pNb].type) ||
-               ParameterMetadata::IsExpression(
-                   "string", instrInfos.parameters[pNb].type)) {
-        auto node = instructions[aId].GetParameter(pNb).GetRootNode();
+                   "number", instrInfos.parameters[pNb].type)) {
+        gd::ExpressionParser2 parser(platform, project, layout);
+        auto node = parser.ParseExpression(
+            "number", instructions[aId].GetParameter(pNb).GetPlainString());
 
         ExpressionParameterSearcher searcher(
-            platform,
-            project,
-            layout,
-            results,
-            parameterType,
-            objectName);
+            results, parameterType, objectName);
+        node->Visit(searcher);
+      }
+      // Search in gd::String expressions
+      else if (ParameterMetadata::IsExpression(
+                   "string", instrInfos.parameters[pNb].type)) {
+        gd::ExpressionParser2 parser(platform, project, layout);
+        auto node = parser.ParseExpression(
+            "number", instructions[aId].GetParameter(pNb).GetPlainString());
+
+        ExpressionParameterSearcher searcher(
+            results, parameterType, objectName);
         node->Visit(searcher);
       }
       // Remember the value of the last "object" parameter.

Core/GDCore/IDE/Events/ExpressionCompletionFinder.h

@@ -15,8 +15,6 @@
 #include "GDCore/Extensions/Metadata/ExpressionMetadata.h"
 #include "GDCore/Extensions/Metadata/InstructionMetadata.h"
 #include "GDCore/IDE/Events/ExpressionNodeLocationFinder.h"
-#include "GDCore/IDE/Events/ExpressionTypeFinder.h"
-#include "GDCore/IDE/Events/ExpressionVariableOwnerFinder.h"
 
 namespace gd {
 class Expression;
@@ -292,11 +290,7 @@ class GD_CORE_API ExpressionCompletionFinder
    * and returns completions for it.
    */
   static std::vector<ExpressionCompletionDescription>
-  GetCompletionDescriptionsFor(const gd::Platform &platform,
-                               const gd::ObjectsContainer &globalObjectsContainer,
-                               const gd::ObjectsContainer &objectsContainer,
-                               const gd::String &rootType,
-                               gd::ExpressionNode& node,
+  GetCompletionDescriptionsFor(gd::ExpressionNode& node,
                                size_t searchedPosition) {
     gd::ExpressionNodeLocationFinder finder(searchedPosition);
     node.Visit(finder);
@@ -309,7 +303,6 @@ class GD_CORE_API ExpressionCompletionFinder
 
     gd::ExpressionNode* maybeParentNodeAtLocation = finder.GetParentNode();
     gd::ExpressionCompletionFinder autocompletionProvider(
-        platform, globalObjectsContainer, objectsContainer, rootType,
         searchedPosition, maybeParentNodeAtLocation);
     nodeAtLocation->Visit(autocompletionProvider);
     return autocompletionProvider.GetCompletionDescriptions();
@@ -327,21 +320,19 @@ class GD_CORE_API ExpressionCompletionFinder
 
  protected:
   void OnVisitSubExpressionNode(SubExpressionNode& node) override {
-    auto type = gd::ExpressionTypeFinder::GetType(platform, globalObjectsContainer, objectsContainer, rootType, node);
     completions.push_back(ExpressionCompletionDescription::ForObject(
-        type, "", searchedPosition + 1, searchedPosition + 1));
+        node.type, "", searchedPosition + 1, searchedPosition + 1));
     completions.push_back(ExpressionCompletionDescription::ForExpression(
-        type, "", searchedPosition + 1, searchedPosition + 1));
+        node.type, "", searchedPosition + 1, searchedPosition + 1));
   }
   void OnVisitOperatorNode(OperatorNode& node) override {
     // No completions.
   }
   void OnVisitUnaryOperatorNode(UnaryOperatorNode& node) override {
-    auto type = gd::ExpressionTypeFinder::GetType(platform, globalObjectsContainer, objectsContainer, rootType, node);
     completions.push_back(ExpressionCompletionDescription::ForObject(
-        type, "", searchedPosition + 1, searchedPosition + 1));
+        node.type, "", searchedPosition + 1, searchedPosition + 1));
     completions.push_back(ExpressionCompletionDescription::ForExpression(
-        type, "", searchedPosition + 1, searchedPosition + 1));
+        node.type, "", searchedPosition + 1, searchedPosition + 1));
   }
   void OnVisitNumberNode(NumberNode& node) override {
     // No completions
@@ -353,7 +344,6 @@ class GD_CORE_API ExpressionCompletionFinder
     FunctionCallNode* functionCall =
         dynamic_cast<FunctionCallNode*>(maybeParentNodeAtLocation);
     if (functionCall != nullptr) {
-
       int parameterIndex = -1;
       for (int i = 0; i < functionCall->parameters.size(); i++) {
         if (functionCall->parameters.at(i).get() == &node) {
@@ -369,16 +359,15 @@ class GD_CORE_API ExpressionCompletionFinder
       size_t metadataParameterIndex =
           ExpressionParser2::WrittenParametersFirstIndex(
               functionCall->objectName, functionCall->behaviorName);
-      const gd::ExpressionMetadata &metadata = MetadataProvider::GetFunctionCallMetadata(
-          platform, globalObjectsContainer, objectsContainer, *functionCall);
 
       const gd::ParameterMetadata* parameterMetadata = nullptr;
       while (metadataParameterIndex <
-             metadata.parameters.size()) {
-        if (!metadata.parameters[metadataParameterIndex]
+             functionCall->expressionMetadata.parameters.size()) {
+        if (!functionCall->expressionMetadata.parameters[metadataParameterIndex]
                  .IsCodeOnly()) {
           if (visibleParameterIndex == parameterIndex) {
-            parameterMetadata = &metadata.parameters[metadataParameterIndex];
+            parameterMetadata = &functionCall->expressionMetadata
+                                     .parameters[metadataParameterIndex];
           }
           visibleParameterIndex++;
         }
@@ -409,21 +398,12 @@ class GD_CORE_API ExpressionCompletionFinder
     }
   }
   void OnVisitVariableNode(VariableNode& node) override {
-    auto type = gd::ExpressionTypeFinder::GetType(platform, globalObjectsContainer, objectsContainer, rootType, node);
-    auto objectName = gd::ExpressionVariableOwnerFinder::GetObjectName(
-        platform,
-        globalObjectsContainer,
-        objectsContainer,
-        // Variable fields doesn't use expression completion,
-        // so the object will be found inside the expression itself.
-        "",
-        node);
     completions.push_back(ExpressionCompletionDescription::ForVariable(
-        type,
+        node.type,
         node.name,
         node.location.GetStartPosition(),
         node.location.GetEndPosition(),
-        objectName));
+        node.objectName));
   }
   void OnVisitVariableAccessorNode(VariableAccessorNode& node) override {
     // No completions
@@ -433,69 +413,35 @@ class GD_CORE_API ExpressionCompletionFinder
     // No completions
   }
   void OnVisitIdentifierNode(IdentifierNode& node) override {
-    auto type = gd::ExpressionTypeFinder::GetType(platform, globalObjectsContainer, objectsContainer, rootType, node);
-    if (gd::ParameterMetadata::IsObject(type)) {
+    if (gd::ParameterMetadata::IsObject(node.type)) {
       // Only show completions of objects if an object is required
       completions.push_back(ExpressionCompletionDescription::ForObject(
-          type,
+          node.type,
           node.identifierName,
           node.location.GetStartPosition(),
           node.location.GetEndPosition()));
-    } else if (gd::ParameterMetadata::IsExpression("variable", type)) {
-      auto objectName = gd::ExpressionVariableOwnerFinder::GetObjectName(
-          platform,
-          globalObjectsContainer,
-          objectsContainer,
-          // Variable fields doesn't use expression completion,
-          // so the object will be found inside the expression itself.
-          "",
-          node);
-      completions.push_back(ExpressionCompletionDescription::ForVariable(
-          type,
+    } else {
+      // Show completions for expressions and objects otherwise.
+      completions.push_back(ExpressionCompletionDescription::ForObject(
+          node.type,
           node.identifierName,
           node.location.GetStartPosition(),
-          node.location.GetEndPosition(),
-          objectName));
-    } else {
-      // Object function or behavior name
-      if (IsCaretOn(node.identifierNameLocation)) {
-        completions.push_back(ExpressionCompletionDescription::ForObject(
-            type,
-            node.identifierName,
-            node.identifierNameLocation.GetStartPosition(),
-            node.identifierNameLocation.GetEndPosition()));
-        if (!node.identifierNameDotLocation.IsValid()) {
-          completions.push_back(ExpressionCompletionDescription::ForExpression(
-              type,
-              node.identifierName,
-              node.identifierNameLocation.GetStartPosition(),
-              node.identifierNameLocation.GetEndPosition()));
-        }
-      } else if (IsCaretOn(node.identifierNameDotLocation) ||
-                 IsCaretOn(node.childIdentifierNameLocation)) {
-        completions.push_back(ExpressionCompletionDescription::ForBehavior(
-            node.childIdentifierName,
-            node.childIdentifierNameLocation.GetStartPosition(),
-            node.childIdentifierNameLocation.GetEndPosition(),
-            node.identifierName));
-        completions.push_back(ExpressionCompletionDescription::ForExpression(
-            type,
-            node.childIdentifierName,
-            node.childIdentifierNameLocation.GetStartPosition(),
-            node.childIdentifierNameLocation.GetEndPosition(),
-            node.identifierName));
-      }
+          node.location.GetEndPosition()));
+      completions.push_back(ExpressionCompletionDescription::ForExpression(
+          node.type,
+          node.identifierName,
+          node.location.GetStartPosition(),
+          node.location.GetEndPosition()));
     }
   }
   void OnVisitObjectFunctionNameNode(ObjectFunctionNameNode& node) override {
-    auto type = gd::ExpressionTypeFinder::GetType(platform, globalObjectsContainer, objectsContainer, rootType, node);
     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(
-            type,
+            node.type,
             node.objectName,
             node.objectNameLocation.GetStartPosition(),
             node.objectNameLocation.GetEndPosition()));
@@ -509,7 +455,7 @@ class GD_CORE_API ExpressionCompletionFinder
       } else if (IsCaretOn(node.behaviorNameNamespaceSeparatorLocation) ||
                  IsCaretOn(node.behaviorFunctionNameLocation)) {
         completions.push_back(ExpressionCompletionDescription::ForExpression(
-            type,
+            node.type,
             node.behaviorFunctionName,
             node.behaviorFunctionNameLocation.GetStartPosition(),
             node.behaviorFunctionNameLocation.GetEndPosition(),
@@ -520,7 +466,7 @@ class GD_CORE_API ExpressionCompletionFinder
       // Object function or behavior name
       if (IsCaretOn(node.objectNameLocation)) {
         completions.push_back(ExpressionCompletionDescription::ForObject(
-            type,
+            node.type,
             node.objectName,
             node.objectNameLocation.GetStartPosition(),
             node.objectNameLocation.GetEndPosition()));
@@ -532,7 +478,7 @@ class GD_CORE_API ExpressionCompletionFinder
             node.objectFunctionOrBehaviorNameLocation.GetEndPosition(),
             node.objectName));
         completions.push_back(ExpressionCompletionDescription::ForExpression(
-            type,
+            node.type,
             node.objectFunctionOrBehaviorName,
             node.objectFunctionOrBehaviorNameLocation.GetStartPosition(),
             node.objectFunctionOrBehaviorNameLocation.GetEndPosition(),
@@ -541,7 +487,6 @@ class GD_CORE_API ExpressionCompletionFinder
     }
   }
   void OnVisitFunctionCallNode(FunctionCallNode& node) override {
-    auto type = gd::ExpressionTypeFinder::GetType(platform, globalObjectsContainer, objectsContainer, rootType, node);
     bool isCaretOnParenthesis = IsCaretOn(node.openingParenthesisLocation) ||
                                 IsCaretOn(node.closingParenthesisLocation);
 
@@ -549,7 +494,7 @@ class GD_CORE_API ExpressionCompletionFinder
       // Behavior function
       if (IsCaretOn(node.objectNameLocation)) {
         completions.push_back(ExpressionCompletionDescription::ForObject(
-            type,
+            node.type,
             node.objectName,
             node.objectNameLocation.GetStartPosition(),
             node.objectNameLocation.GetEndPosition()));
@@ -562,7 +507,7 @@ class GD_CORE_API ExpressionCompletionFinder
             node.objectName));
       } else {
         completions.push_back(ExpressionCompletionDescription::ForExpression(
-                                  type,
+                                  node.type,
                                   node.functionName,
                                   node.functionNameLocation.GetStartPosition(),
                                   node.functionNameLocation.GetEndPosition(),
@@ -574,7 +519,7 @@ class GD_CORE_API ExpressionCompletionFinder
       // Object function
       if (IsCaretOn(node.objectNameLocation)) {
         completions.push_back(ExpressionCompletionDescription::ForObject(
-            type,
+            node.type,
             node.objectName,
             node.objectNameLocation.GetStartPosition(),
             node.objectNameLocation.GetEndPosition()));
@@ -593,7 +538,7 @@ class GD_CORE_API ExpressionCompletionFinder
         }
 
         completions.push_back(ExpressionCompletionDescription::ForExpression(
-                                  type,
+                                  node.type,
                                   node.functionName,
                                   node.functionNameLocation.GetStartPosition(),
                                   node.functionNameLocation.GetEndPosition(),
@@ -603,7 +548,7 @@ class GD_CORE_API ExpressionCompletionFinder
     } else {
       // Free function
       completions.push_back(ExpressionCompletionDescription::ForExpression(
-                                type,
+                                node.type,
                                 node.functionName,
                                 node.functionNameLocation.GetStartPosition(),
                                 node.functionNameLocation.GetEndPosition())
@@ -611,14 +556,13 @@ class GD_CORE_API ExpressionCompletionFinder
     }
   }
   void OnVisitEmptyNode(EmptyNode& node) override {
-    auto type = gd::ExpressionTypeFinder::GetType(platform, globalObjectsContainer, objectsContainer, rootType, node);
     completions.push_back(ExpressionCompletionDescription::ForObject(
-        type,
+        node.type,
         node.text,
         node.location.GetStartPosition(),
         node.location.GetEndPosition()));
     completions.push_back(ExpressionCompletionDescription::ForExpression(
-        type,
+        node.type,
         node.text,
         node.location.GetStartPosition(),
         node.location.GetEndPosition()));
@@ -634,27 +578,14 @@ class GD_CORE_API ExpressionCompletionFinder
              (inclusive && searchedPosition <= location.GetEndPosition())));
   }
 
-  ExpressionCompletionFinder(const gd::Platform &platform_,
-                             const gd::ObjectsContainer &globalObjectsContainer_,
-                             const gd::ObjectsContainer &objectsContainer_,
-                             const gd::String &rootType_,
-                             size_t searchedPosition_,
+  ExpressionCompletionFinder(size_t searchedPosition_,
                              gd::ExpressionNode* maybeParentNodeAtLocation_)
-      : platform(platform_),
-        globalObjectsContainer(globalObjectsContainer_),
-        objectsContainer(objectsContainer_),
-        rootType(rootType_),
-        searchedPosition(searchedPosition_),
+      : searchedPosition(searchedPosition_),
         maybeParentNodeAtLocation(maybeParentNodeAtLocation_){};
 
   std::vector<ExpressionCompletionDescription> completions;
   size_t searchedPosition;
   gd::ExpressionNode* maybeParentNodeAtLocation;
-  
-  const gd::Platform &platform;
-  const gd::ObjectsContainer &globalObjectsContainer;
-  const gd::ObjectsContainer &objectsContainer;
-  const gd::String rootType;
 };
 
 }  // namespace gd

Core/GDCore/IDE/Events/ExpressionLeftSideTypeFinder.h

@@ -1,123 +0,0 @@
-/*
- * GDevelop Core
- * Copyright 2008-present Florian Rival (Florian.Rival@gmail.com). All rights
- * reserved. This project is released under the MIT License.
- */
-#ifndef GDCORE_EXPRESSIONLEFTSIDETYPEFINDER_H
-#define GDCORE_EXPRESSIONLEFTSIDETYPEFINDER_H
-
-#include <memory>
-#include <vector>
-#include "GDCore/Events/Parsers/ExpressionParser2Node.h"
-#include "GDCore/Events/Parsers/ExpressionParser2NodeWorker.h"
-#include "GDCore/Extensions/Metadata/ExpressionMetadata.h"
-#include "GDCore/Extensions/Metadata/MetadataProvider.h"
-#include "GDCore/Extensions/Metadata/ObjectMetadata.h"
-#include "GDCore/Extensions/Metadata/ParameterMetadata.h"
-#include "GDCore/Project/Layout.h"  // For GetTypeOfObject and GetTypeOfBehavior
-#include "GDCore/Tools/Localization.h"
-
-namespace gd {
-class Expression;
-class ObjectsContainer;
-class Platform;
-class ParameterMetadata;
-class ExpressionMetadata;
-}  // namespace gd
-
-namespace gd {
-
-/**
- * \brief Find the type of the node at the left side of operations.
- *
- * \see gd::ExpressionTypeFinder
- */
-class GD_CORE_API ExpressionLeftSideTypeFinder : public ExpressionParser2NodeWorker {
- public:
-
-  /**
-   * \brief Helper function to find the type of the node at the left side of
-   * operations.
-   */
-  static const gd::String GetType(const gd::Platform &platform,
-                      const gd::ObjectsContainer &globalObjectsContainer,
-                      const gd::ObjectsContainer &objectsContainer,
-                      gd::ExpressionNode& node) {
-    gd::ExpressionLeftSideTypeFinder typeFinder(
-        platform, globalObjectsContainer, objectsContainer);
-    node.Visit(typeFinder);
-    return typeFinder.GetType();
-  }
-
-  virtual ~ExpressionLeftSideTypeFinder(){};
-
- protected:
-  ExpressionLeftSideTypeFinder(const gd::Platform &platform_,
-                       const gd::ObjectsContainer &globalObjectsContainer_,
-                       const gd::ObjectsContainer &objectsContainer_)
-      : platform(platform_),
-        globalObjectsContainer(globalObjectsContainer_),
-        objectsContainer(objectsContainer_),
-        type("unknown") {};
-
-  const gd::String &GetType() {
-    return type;
-  };
-
-  void OnVisitSubExpressionNode(SubExpressionNode& node) override {
-    node.expression->Visit(*this);
-  }
-  void OnVisitOperatorNode(OperatorNode& node) override {
-    node.leftHandSide->Visit(*this);
-  }
-  void OnVisitUnaryOperatorNode(UnaryOperatorNode& node) override {
-    node.factor->Visit(*this);
-  }
-  void OnVisitVariableBracketAccessorNode(
-      VariableBracketAccessorNode& node) override {
-    node.expression->Visit(*this);
-  }
-  void OnVisitNumberNode(NumberNode& node) override {
-    type = "number";
-  }
-  void OnVisitTextNode(TextNode& node) override {
-    type = "string";
-  }
-  void OnVisitFunctionCallNode(FunctionCallNode& node) override {
-    const gd::ExpressionMetadata &metadata = MetadataProvider::GetFunctionCallMetadata(
-        platform, globalObjectsContainer, objectsContainer, node);
-    if (gd::MetadataProvider::IsBadExpressionMetadata(metadata)) {
-      type = "unknown";
-    }
-    else {
-      type = metadata.GetReturnType();
-    }
-  }
-  void OnVisitVariableNode(VariableNode& node) override {
-    type = "unknown";
-  }
-  void OnVisitVariableAccessorNode(VariableAccessorNode& node) override {
-    type = "unknown";
-  }
-  void OnVisitIdentifierNode(IdentifierNode& node) override {
-    type = "unknown";
-  }
-  void OnVisitEmptyNode(EmptyNode& node) override {
-    type = "unknown";
-  }
-  void OnVisitObjectFunctionNameNode(ObjectFunctionNameNode& node) override {
-    type = "unknown";
-  }
-
- private:
-  gd::String type;
-
-  const gd::Platform &platform;
-  const gd::ObjectsContainer &globalObjectsContainer;
-  const gd::ObjectsContainer &objectsContainer;
-  const gd::String rootType;
-};
-
-}  // namespace gd
-
-#endif  // GDCORE_EXPRESSIONLEFTSIDETYPEFINDER_H

Core/GDCore/IDE/Events/ExpressionTypeFinder.cpp

@@ -1,35 +0,0 @@
-/*
- * GDevelop Core
- * Copyright 2008-present Florian Rival (Florian.Rival@gmail.com). All rights
- * reserved. This project is released under the MIT License.
- */
-#include "GDCore/IDE/Events/ExpressionTypeFinder.h"
-
-#include <algorithm>
-#include <memory>
-#include <vector>
-
-#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/Metadata/ObjectMetadata.h"
-#include "GDCore/Extensions/Platform.h"
-#include "GDCore/Project/Layout.h"
-#include "GDCore/Project/Project.h"
-#include "GDCore/Tools/Localization.h"
-#include "GDCore/Tools/MakeUnique.h"
-#include "GDCore/Events/Parsers/ExpressionParser2.h"
-
-using namespace std;
-
-namespace gd {
-
-  // TODO factorize in a file with an enum and helpers?
-  const gd::String ExpressionTypeFinder::unknownType = "unknown";
-  const gd::String ExpressionTypeFinder::numberType = "number";
-  const gd::String ExpressionTypeFinder::stringType = "string";
-  const gd::String ExpressionTypeFinder::numberOrStringType = "number|string";
-
-}  // namespace gd

Core/GDCore/IDE/Events/ExpressionTypeFinder.h

@@ -1,198 +0,0 @@
-/*
- * GDevelop Core
- * Copyright 2008-present Florian Rival (Florian.Rival@gmail.com). All rights
- * reserved. This project is released under the MIT License.
- */
-#ifndef GDCORE_EXPRESSIONTYPEFINDER_H
-#define GDCORE_EXPRESSIONTYPEFINDER_H
-
-#include <memory>
-#include <vector>
-#include "GDCore/Events/Parsers/ExpressionParser2Node.h"
-#include "GDCore/Events/Parsers/ExpressionParser2NodeWorker.h"
-#include "GDCore/IDE/Events/ExpressionLeftSideTypeFinder.h"
-#include "GDCore/Extensions/Metadata/ExpressionMetadata.h"
-#include "GDCore/Extensions/Metadata/MetadataProvider.h"
-#include "GDCore/Extensions/Metadata/ObjectMetadata.h"
-#include "GDCore/Extensions/Metadata/ParameterMetadata.h"
-#include "GDCore/Project/Layout.h" // For GetTypeOfObject and GetTypeOfBehavior
-#include "GDCore/Tools/Localization.h"
-
-namespace gd {
-class Expression;
-class ObjectsContainer;
-class Platform;
-class ParameterMetadata;
-class ExpressionMetadata;
-}  // namespace gd
-
-namespace gd {
-
-/**
- * \brief Find the type of the expression or sub-expression that a given node
- * represents.
- * 
- * The type returned by this worker is a mix of:
- * - an expected type looking up like a parameter declaration
- * - an actual type looking down, but only looking at the most left branch
- *   (using ExpressionLeftSideTypeFinder)
- *
- * This logic was built with the constraint of following a parser that can't
- * know the right side. Now that it is extracted, it could be enhanced if needed.
- *
- * \see gd::ExpressionParser2
- */
-class GD_CORE_API ExpressionTypeFinder : public ExpressionParser2NodeWorker {
- public:
-
-  /**
-   * \brief Helper function to find the type of the expression or
-   * sub-expression that a given node represents.
-   */
-  static const gd::String GetType(const gd::Platform &platform,
-                      const gd::ObjectsContainer &globalObjectsContainer,
-                      const gd::ObjectsContainer &objectsContainer,
-                      const gd::String &rootType,
-                      gd::ExpressionNode& node) {
-    gd::ExpressionTypeFinder typeFinder(
-        platform, globalObjectsContainer, objectsContainer, rootType);
-    node.Visit(typeFinder);
-    return typeFinder.GetType();
-  }
-
-  virtual ~ExpressionTypeFinder(){};
-
- protected:
-  ExpressionTypeFinder(const gd::Platform &platform_,
-                       const gd::ObjectsContainer &globalObjectsContainer_,
-                       const gd::ObjectsContainer &objectsContainer_,
-                       const gd::String &rootType_)
-      : platform(platform_),
-        globalObjectsContainer(globalObjectsContainer_),
-        objectsContainer(objectsContainer_),
-        rootType(rootType_),
-        type(ExpressionTypeFinder::unknownType),
-        child(nullptr) {};
-
-  const gd::String &GetType() {
-    return gd::ParameterMetadata::GetExpressionValueType(type);
-  };
-
-  void OnVisitSubExpressionNode(SubExpressionNode& node) override {
-    VisitParent(node);
-  }
-  void OnVisitOperatorNode(OperatorNode& node) override {
-    VisitParent(node);
-  }
-  void OnVisitUnaryOperatorNode(UnaryOperatorNode& node) override {
-    VisitParent(node);
-  }
-  void OnVisitNumberNode(NumberNode& node) override {
-    type = ExpressionTypeFinder::numberType;
-  }
-  void OnVisitTextNode(TextNode& node) override {
-    type = ExpressionTypeFinder::stringType;
-  }
-  void OnVisitVariableNode(VariableNode& node) override {
-    VisitParent(node);
-  }
-  void OnVisitVariableAccessorNode(VariableAccessorNode& node) override {
-    VisitParent(node);
-  }
-  void OnVisitIdentifierNode(IdentifierNode& node) override {
-    VisitParent(node);
-  }
-  void OnVisitEmptyNode(EmptyNode& node) override {
-    VisitParent(node);
-  }
-  void OnVisitObjectFunctionNameNode(ObjectFunctionNameNode& node) override {
-    VisitParent(node);
-  }
-  void OnVisitVariableBracketAccessorNode(
-      VariableBracketAccessorNode& node) override {
-    if (child == nullptr) {
-      type = ExpressionTypeFinder::unknownType;
-    }
-    auto leftSideType = gd::ExpressionLeftSideTypeFinder::GetType(
-        platform, 
-        globalObjectsContainer,
-        objectsContainer,
-        node);
-    if (leftSideType == ExpressionTypeFinder::numberType
-     || leftSideType == ExpressionTypeFinder::stringType) {
-      type = leftSideType;
-    }
-    else {
-      type = ExpressionTypeFinder::numberOrStringType;
-    }
-  }
-  void OnVisitFunctionCallNode(FunctionCallNode& node) override {
-    if (child == nullptr) {
-      const gd::ExpressionMetadata &metadata = MetadataProvider::GetFunctionCallMetadata(
-          platform, globalObjectsContainer, objectsContainer, node);
-      if (gd::MetadataProvider::IsBadExpressionMetadata(metadata)) {
-        VisitParent(node);
-      }
-      else {
-        type = metadata.GetReturnType();
-      }
-    }
-    else {
-      const gd::ParameterMetadata* parameterMetadata =
-          gd::MetadataProvider::GetFunctionCallParameterMetadata(
-              platform,
-              globalObjectsContainer,
-              objectsContainer,
-              node,
-              *child);
-      if (parameterMetadata == nullptr || parameterMetadata->GetType().empty()) {
-        type = ExpressionTypeFinder::unknownType;
-      }
-      else {
-        type = parameterMetadata->GetType();
-      }
-    }
-  }
-
- private:
-  inline void VisitParent(ExpressionNode& node) {
-    child = &node;
-    if (node.parent != nullptr) {
-      node.parent->Visit(*this);
-    }
-    else if (rootType == ExpressionTypeFinder::numberOrStringType) {
-      auto leftSideType = gd::ExpressionLeftSideTypeFinder::GetType(
-          platform, 
-          globalObjectsContainer,
-          objectsContainer,
-          node);
-      if (leftSideType == ExpressionTypeFinder::numberType
-       || leftSideType == ExpressionTypeFinder::stringType) {
-        type = leftSideType;
-      }
-      else {
-        type = rootType;
-      }
-    }
-    else {
-      type = rootType;
-    }
-  }
-
-  static const gd::String unknownType;
-  static const gd::String numberType;
-  static const gd::String stringType;
-  static const gd::String numberOrStringType;
-
-  gd::String type;
-  ExpressionNode *child;
-
-  const gd::Platform &platform;
-  const gd::ObjectsContainer &globalObjectsContainer;
-  const gd::ObjectsContainer &objectsContainer;
-  const gd::String rootType;
-};
-
-}  // namespace gd
-
-#endif  // GDCORE_EXPRESSIONTYPEFINDER_H

Core/GDCore/IDE/Events/ExpressionValidator.cpp

@@ -1,300 +0,0 @@
-/*
- * GDevelop Core
- * Copyright 2008-present Florian Rival (Florian.Rival@gmail.com). All rights
- * reserved. This project is released under the MIT License.
- */
-#include "GDCore/IDE/Events/ExpressionValidator.h"
-
-#include <algorithm>
-#include <memory>
-#include <vector>
-
-#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/Metadata/ObjectMetadata.h"
-#include "GDCore/Extensions/Platform.h"
-#include "GDCore/Project/Layout.h"
-#include "GDCore/Project/Project.h"
-#include "GDCore/Tools/Localization.h"
-#include "GDCore/Tools/MakeUnique.h"
-#include "GDCore/Events/Parsers/ExpressionParser2.h"
-
-using namespace std;
-
-namespace gd {
-
-namespace {
-/**
- * Return the minimum number of parameters, starting from a given parameter
- * (by convention, 1 for object functions and 2 for behavior functions).
- */
-size_t GetMinimumParametersNumber(
-    const std::vector<gd::ParameterMetadata>& parameters,
-    size_t initialParameterIndex) {
-  size_t nb = 0;
-  for (std::size_t i = initialParameterIndex; i < parameters.size(); ++i) {
-    if (!parameters[i].optional && !parameters[i].codeOnly) nb++;
-  }
-
-  return nb;
-}
-
-/**
- * Return the maximum number of parameters, starting from a given parameter
- * (by convention, 1 for object functions and 2 for behavior functions).
- */
-size_t GetMaximumParametersNumber(
-    const std::vector<gd::ParameterMetadata>& parameters,
-    size_t initialParameterIndex) {
-  size_t nb = 0;
-  for (std::size_t i = initialParameterIndex; i < parameters.size(); ++i) {
-    if (!parameters[i].codeOnly) nb++;
-  }
-
-  return nb;
-}
-
-}  // namespace
-
-ExpressionValidator::Type ExpressionValidator::ValidateFunction(const gd::FunctionCallNode& function) {
-
-  ReportAnyError(function);
-  
-  gd::String objectType = function.objectName.empty() ? "" :
-      GetTypeOfObject(globalObjectsContainer, objectsContainer, function.objectName);
-      
-  gd::String behaviorType = function.behaviorName.empty() ? "" :
-      GetTypeOfBehavior(globalObjectsContainer, objectsContainer, function.behaviorName);
-
-  const gd::ExpressionMetadata &metadata = function.behaviorName.empty() ?
-      function.objectName.empty() ?
-          MetadataProvider::GetAnyExpressionMetadata(platform, function.functionName) :
-          MetadataProvider::GetObjectAnyExpressionMetadata(
-              platform, objectType, function.functionName) : 
-      MetadataProvider::GetBehaviorAnyExpressionMetadata(
-            platform, behaviorType, function.functionName);
-
-  if (!function.objectName.empty()) {
-    // If the function needs a capability on the object that may not be covered
-    // by all objects, check it now.
-    if (!metadata.GetRequiredBaseObjectCapability().empty()) {
-      const gd::ObjectMetadata &objectMetadata =
-          MetadataProvider::GetObjectMetadata(platform, objectType);
-
-      if (objectMetadata.IsUnsupportedBaseObjectCapability(
-              metadata.GetRequiredBaseObjectCapability())) {
-        RaiseTypeError(
-            _("This expression exists, but it can't be used on this object."),
-            function.objectNameLocation);
-        return StringToType(metadata.GetReturnType());
-      }
-    }
-  }
-
-  Type returnType = StringToType(metadata.GetReturnType());
-
-  if (gd::MetadataProvider::IsBadExpressionMetadata(metadata)) {
-    RaiseError(
-        "invalid_function_name",
-        _("Cannot find an expression with this name: ") +
-            function.functionName + "\n" +
-            _("Double check that you've not made any typo in the name."),
-        function.location);
-      return returnType;
-  }
-
-  // Validate the type of the function
-  if (returnType == Type::Number) {
-    if (parentType == Type::String) {
-      RaiseTypeError(
-          _("You tried to use an expression that returns a number, but a "
-            "string is expected. Use `ToString` if you need to convert a "
-            "number to a string."),
-          function.location);
-      return returnType;
-    }
-    else if (parentType != Type::Number && parentType != Type::NumberOrString) {
-      RaiseTypeError(_("You tried to use an expression that returns a "
-                              "number, but another type is expected:") +
-                              " " + TypeToString(parentType),
-                            function.location);
-      return returnType;
-    }
-  } else if (returnType == Type::String) {
-    if (parentType == Type::Number) {
-      RaiseTypeError(
-          _("You tried to use an expression that returns a string, but a "
-            "number is expected. Use `ToNumber` if you need to convert a "
-            "string to a number."),
-          function.location);
-      return returnType;
-    }
-    else if (parentType != Type::String && parentType != Type::NumberOrString) {
-      RaiseTypeError(_("You tried to use an expression that returns a "
-                              "string, but another type is expected:") +
-                              " " + TypeToString(parentType),
-                            function.location);
-      return returnType;
-    }
-  } else {
-    if (parentType != returnType) {
-      RaiseTypeError(
-          _("You tried to use an expression with the wrong return type:") + " " +
-            TypeToString(returnType),
-          function.location);
-      return returnType;
-    }
-  }
-
-  // Validate parameters count
-  size_t minParametersCount = GetMinimumParametersNumber(
-      metadata.parameters,
-      ExpressionParser2::WrittenParametersFirstIndex(function.objectName, function.behaviorName));
-  size_t maxParametersCount = GetMaximumParametersNumber(
-      metadata.parameters,
-      ExpressionParser2::WrittenParametersFirstIndex(function.objectName, function.behaviorName));
-  if (function.parameters.size() < minParametersCount ||
-      function.parameters.size() > maxParametersCount) {
-    gd::String expectedCountMessage =
-        minParametersCount == maxParametersCount
-            ? _("The number of parameters must be exactly ") +
-                  gd::String::From(minParametersCount)
-            : _("The number of parameters must be: ") +
-                  gd::String::From(minParametersCount) + "-" +
-                  gd::String::From(maxParametersCount);
-
-    if (function.parameters.size() < minParametersCount) {
-      RaiseError(
-          "too_few_parameters",
-          _("You have not entered enough parameters for the expression.") + " " +
-              expectedCountMessage,
-          function.location);
-    }
-    else {
-      RaiseError(
-          "extra_parameter",
-          _("This parameter was not expected by this expression. Remove it "
-          "or verify that you've entered the proper expression name.") + " " +
-              expectedCountMessage,
-          ExpressionParserLocation(
-              function.parameters[maxParametersCount]->location.GetStartPosition(),
-              function.location.GetEndPosition() - 1));
-    }
-    return returnType;
-  }
-
-  // TODO: reverse the order of diagnostic?
-  size_t writtenParametersFirstIndex =
-      ExpressionParser2::WrittenParametersFirstIndex(
-          function.objectName, function.behaviorName);
-  int metadataIndex = writtenParametersFirstIndex;
-  for (int parameterIndex = 0; parameterIndex < function.parameters.size(); parameterIndex++) {
-    auto& parameter = function.parameters[parameterIndex];
-    while (metadata.GetParameters()[metadataIndex].IsCodeOnly()) {
-      // The sizes are already checked above.
-      metadataIndex++;
-    }
-    auto& parameterMetadata = metadata.GetParameters()[metadataIndex];
-
-    if (!parameterMetadata.IsOptional() || dynamic_cast<EmptyNode*>(parameter.get()) == nullptr) {
-      auto currentParentType = parentType;
-      parentType = StringToType(parameterMetadata.GetType());
-      parameter->Visit(*this);
-      parentType = currentParentType;
-      
-      const gd::String &expectedParameterType = parameterMetadata.GetType();
-      if (gd::ParameterMetadata::IsExpression(
-          ExpressionValidator::variableTypeString, expectedParameterType)) {
-        if (dynamic_cast<IdentifierNode *>(parameter.get()) == nullptr
-         && dynamic_cast<VariableNode *>(parameter.get()) == nullptr) {
-          RaiseError(
-                  "malformed_variable_parameter",
-                  _("A variable name was expected but something else was "
-                    "written. Enter just the name of the variable for this "
-                    "parameter."),
-                parameter->location);
-        }
-      }
-      else if (gd::ParameterMetadata::IsObject(expectedParameterType)) {
-        if (dynamic_cast<IdentifierNode *>(parameter.get()) == nullptr) {
-          RaiseError(
-                  "malformed_object_parameter",
-                  _("An object name was expected but something else was "
-                    "written. Enter just the name of the object for this "
-                    "parameter."),
-                parameter->location);
-        }
-      }
-      // String and number are already checked in children.
-      else if (!gd::ParameterMetadata::IsExpression(
-               ExpressionValidator::numberTypeString, expectedParameterType)
-            && !gd::ParameterMetadata::IsExpression(
-              ExpressionValidator::stringTypeString, expectedParameterType)) {
-        RaiseError(
-                "unknown_parameter_type",
-                _("This function is improperly set up. Reach out to the "
-                  "extension developer or a GDevelop maintainer to fix "
-                  "this issue"),
-                parameter->location);
-      }
-    }
-    metadataIndex++;
-  }
-  return returnType;
-}
-
-  // TODO factorize in a file with an enum and helpers?
-  const gd::String ExpressionValidator::unknownTypeString = "unknown";
-  const gd::String ExpressionValidator::numberTypeString = "number";
-  const gd::String ExpressionValidator::stringTypeString = "string";
-  const gd::String ExpressionValidator::numberOrStringTypeString = "number|string";
-  const gd::String ExpressionValidator::variableTypeString = "variable";
-  const gd::String ExpressionValidator::objectTypeString = "object";
-  const gd::String ExpressionValidator::emptyTypeString = "empty";
-
-  const gd::String &ExpressionValidator::TypeToString(Type type) {
-    switch (type) {
-      case Type::Unknown:
-      return unknownTypeString;
-      case Type::Number:
-      return numberTypeString;
-      case Type::String:
-      return stringTypeString;
-      case Type::NumberOrString:
-      return numberOrStringTypeString;
-      case Type::Variable:
-      return variableTypeString;
-      case Type::Object:
-      return objectTypeString;
-      case Type::Empty:
-      return emptyTypeString;
-    }
-    return unknownTypeString;
-  }
-
-  ExpressionValidator::Type ExpressionValidator::StringToType(const gd::String &type) {
-    if (type == ExpressionValidator::numberTypeString
-     || gd::ParameterMetadata::IsExpression(ExpressionValidator::numberTypeString, type)) {
-      return Type::Number;
-    }
-    if (type == ExpressionValidator::stringTypeString
-     || gd::ParameterMetadata::IsExpression(ExpressionValidator::stringTypeString, type)) {
-      return Type::String;
-    }
-    if (type == ExpressionValidator::numberOrStringTypeString) {
-      return Type::NumberOrString;
-    }
-    if (type == ExpressionValidator::variableTypeString
-     || gd::ParameterMetadata::IsExpression(ExpressionValidator::variableTypeString, type)) {
-      return Type::Variable;
-    }
-    if (type == ExpressionValidator::objectTypeString
-     || gd::ParameterMetadata::IsObject(type)) {
-      return Type::Object;
-    }
-    return Type::Unknown;
-  }
-}  // namespace gd

Core/GDCore/IDE/Events/ExpressionValidator.h

@@ -10,10 +10,6 @@
 #include <vector>
 #include "GDCore/Events/Parsers/ExpressionParser2Node.h"
 #include "GDCore/Events/Parsers/ExpressionParser2NodeWorker.h"
-#include "GDCore/Tools/MakeUnique.h"
-#include "GDCore/Tools/Localization.h"
-#include "GDCore/Extensions/Metadata/ExpressionMetadata.h"
-
 namespace gd {
 class Expression;
 class ObjectsContainer;
@@ -32,27 +28,15 @@ namespace gd {
  */
 class GD_CORE_API ExpressionValidator : public ExpressionParser2NodeWorker {
  public:
-  ExpressionValidator(const gd::Platform &platform_,
-                      const gd::ObjectsContainer &globalObjectsContainer_,
-                      const gd::ObjectsContainer &objectsContainer_,
-                      const gd::String &rootType_)
-      : platform(platform_),
-        globalObjectsContainer(globalObjectsContainer_),
-        objectsContainer(objectsContainer_),
-        parentType(StringToType(gd::ParameterMetadata::GetExpressionValueType(rootType_))),
-        childType(Type::Unknown) {};
+  ExpressionValidator(){};
   virtual ~ExpressionValidator(){};
 
   /**
    * \brief Helper function to check if a given node does not contain
    * any error.
    */
-  static bool HasNoErrors(const gd::Platform &platform,
-                      const gd::ObjectsContainer &globalObjectsContainer,
-                      const gd::ObjectsContainer &objectsContainer,
-                      const gd::String &rootType,
-                      gd::ExpressionNode& node) {
-    gd::ExpressionValidator validator(platform, globalObjectsContainer, objectsContainer, rootType);
+  static bool HasNoErrors(gd::ExpressionNode& node) {
+    gd::ExpressionValidator validator;
     node.Visit(validator);
     return validator.GetErrors().empty();
   }
@@ -72,247 +56,52 @@ class GD_CORE_API ExpressionValidator : public ExpressionParser2NodeWorker {
     node.expression->Visit(*this);
   }
   void OnVisitOperatorNode(OperatorNode& node) override {
-    ReportAnyError(node);
-    
     node.leftHandSide->Visit(*this);
-    const Type leftType = childType;
-
-    if (leftType == Type::Number) {
-      if (node.op == ' ') {
-        RaiseError("syntax_error",
-            "No operator found. Did you forget to enter an operator (like +, -, "
-            "* or /) between numbers or expressions?", node.rightHandSide->location);
-      }
-    }
-    else if (leftType == Type::String) {
-      if (node.op == ' ') {
-        RaiseError("syntax_error",
-            "You must add the operator + between texts or expressions. For "
-            "example: \"Your name: \" + VariableString(PlayerName).", node.rightHandSide->location);
-      }
-      else if (node.op != '+') {
-      RaiseOperatorError(
-          _("You've used an operator that is not supported. Only + can be used "
-            "to concatenate texts."),
-            ExpressionParserLocation(node.leftHandSide->location.GetEndPosition() + 1, node.location.GetEndPosition()));
-      }
-    } else if (leftType == Type::Object) {
-      RaiseOperatorError(
-          _("Operators (+, -, /, *) can't be used with an object name. Remove "
-            "the operator."),
-            node.rightHandSide->location);
-    } else if (leftType == Type::Variable) {
-      RaiseOperatorError(
-          _("Operators (+, -, /, *) can't be used in variable names. Remove "
-            "the operator from the variable name."),
-            node.rightHandSide->location);
-    }
-
-    parentType = leftType;
+    ReportAnyError(node);
     node.rightHandSide->Visit(*this);
-    const Type rightType = childType;
-
-    childType = leftType;
   }
   void OnVisitUnaryOperatorNode(UnaryOperatorNode& node) override {
     ReportAnyError(node);
     node.factor->Visit(*this);
-    const Type rightType = childType;
-
-    if (rightType == Type::Number) {
-      if (node.op != '+' && node.op != '-') {
-        // This is actually a dead code because the parser takes them as
-        // binary operations with an empty left side which makes as much sense.
-        RaiseTypeError(
-          _("You've used an \"unary\" operator that is not supported. Operator "
-            "should be "
-            "either + or -."),
-          node.location);
-      }
-    } else if (rightType == Type::String) {
-      RaiseTypeError(
-          _("You've used an operator that is not supported. Only + can be used "
-            "to concatenate texts, and must be placed between two texts (or "
-            "expressions)."),
-          node.location);
-    } else if (rightType == Type::Object) {
-      RaiseTypeError(
-          _("Operators (+, -) can't be used with an object name. Remove the "
-            "operator."),
-          node.location);
-    } else if (rightType == Type::Variable) {
-      RaiseTypeError(
-          _("Operators (+, -) can't be used in variable names. Remove "
-            "the operator from the variable name."),
-          node.location);
-    }
-  }
-  void OnVisitNumberNode(NumberNode& node) override {
-    ReportAnyError(node);
-    childType = Type::Number;
-    CheckType(parentType, childType, node.location);
-  }
-  void OnVisitTextNode(TextNode& node) override {
-    ReportAnyError(node);
-    childType = Type::String;
-    CheckType(parentType, childType, node.location);
   }
+  void OnVisitNumberNode(NumberNode& node) override { ReportAnyError(node); }
+  void OnVisitTextNode(TextNode& node) override { ReportAnyError(node); }
   void OnVisitVariableNode(VariableNode& node) override {
     ReportAnyError(node);
-    if (node.child) {
-      node.child->Visit(*this);
-    }
-    childType = Type::Variable;
-    CheckType(parentType, childType, node.location);
+    if (node.child) node.child->Visit(*this);
   }
   void OnVisitVariableAccessorNode(VariableAccessorNode& node) override {
     ReportAnyError(node);
-    if (node.child) {
-      node.child->Visit(*this);
-    }
+    if (node.child) node.child->Visit(*this);
   }
   void OnVisitVariableBracketAccessorNode(
       VariableBracketAccessorNode& node) override {
     ReportAnyError(node);
-
-    Type currentParentType = parentType;
-    parentType = Type::NumberOrString;
     node.expression->Visit(*this);
-    parentType = currentParentType;
-
-    if (node.child) {
-      node.child->Visit(*this);
-    }
+    if (node.child) node.child->Visit(*this);
   }
   void OnVisitIdentifierNode(IdentifierNode& node) override {
     ReportAnyError(node);
-    if (parentType == Type::String) {
-      RaiseTypeError(_("You must wrap your text inside double quotes "
-                            "(example: \"Hello world\")."),
-                          node.location);
-    }
-    else if (parentType == Type::Number) {
-      RaiseTypeError(
-          _("You must enter a number."), node.location);
-    }
-    else if (parentType == Type::NumberOrString) {
-      RaiseTypeError(
-          _("You must enter a number or a text, wrapped inside double quotes "
-            "(example: \"Hello world\")."),
-          node.location);
-    }
-    else if (parentType != Type::Object && parentType != Type::Variable) {
-      // It can't happen.
-      RaiseTypeError(
-          _("You've entered a name, but this type was expected:") + " " + TypeToString(parentType),
-          node.location);
-    }
-    childType = parentType;
   }
   void OnVisitObjectFunctionNameNode(ObjectFunctionNameNode& node) override {
     ReportAnyError(node);
   }
   void OnVisitFunctionCallNode(FunctionCallNode& node) override {
-    childType = ValidateFunction(node);
-  }
-  void OnVisitEmptyNode(EmptyNode& node) override {
     ReportAnyError(node);
-    gd::String message;
-    if (parentType == Type::Number) {
-      message = _("You must enter a number or a valid expression call.");
-    } else if (parentType == Type::String) {
-      message = _(
-          "You must enter a text (between quotes) or a valid expression call.");
-    } else if (parentType == Type::Variable) {
-      message = _("You must enter a variable name.");
-    } else if (parentType == Type::Object) {
-      message = _("You must enter a valid object name.");
-    } else {
-      // It can't happen.
-      message = _("You must enter a valid expression.");
+    for (auto& parameter : node.parameters) {
+      parameter->Visit(*this);
     }
-    RaiseTypeError(message, node.location);
-    childType = Type::Empty;
   }
+  void OnVisitEmptyNode(EmptyNode& node) override { ReportAnyError(node); }
 
  private:
-  enum Type {Unknown = 0, Number, String, NumberOrString, Variable, Object, Empty};
-  Type ValidateFunction(const gd::FunctionCallNode& function);
-
-  void ReportAnyError(const ExpressionNode& node) {
+  void ReportAnyError(ExpressionNode& node) {
     if (node.diagnostic && node.diagnostic->IsError()) {
-      // Syntax errors are holden by the AST nodes.
-      // It's fine to give pointers on them as the AST live longer than errors
-      // handling.
       errors.push_back(node.diagnostic.get());
     }
   }
 
-  void RaiseError(const gd::String &type, 
-      const gd::String &message, const ExpressionParserLocation &location) {
-    auto diagnostic = gd::make_unique<ExpressionParserError>(
-        type, message, location);
-    errors.push_back(diagnostic.get());
-    // Errors found by the validator are not holden by the AST nodes.
-    // They must be owned by the validator to keep living while errors are
-    // handled by the caller.
-    supplementalErrors.push_back(std::move(diagnostic));
-  }
-
-  void RaiseTypeError(
-      const gd::String &message, const ExpressionParserLocation &location) {
-    RaiseError("type_error", message, location);
-  }
-
-  void RaiseOperatorError(
-      const gd::String &message, const ExpressionParserLocation &location) {
-    RaiseError("invalid_operator", message, location);
-  }
-
-  void CheckType(Type expect, Type actual, const ExpressionParserLocation &location) {
-    if (actual == Type::String) {
-      if (expect == Type::Number) {
-        RaiseTypeError(_("You entered a text, but a number was expected."),
-                           location);
-      }
-      else if (expect != Type::String && expect != Type::NumberOrString) {
-        RaiseTypeError(
-            _("You entered a text, but this type was expected:") + " " + TypeToString(expect),
-            location);
-      }
-    }
-    else if (actual == Type::Number) {
-      if (expect == Type::String) {
-        RaiseTypeError(
-            _("You entered a number, but a text was expected (in quotes)."),
-            location);
-      }
-      else if (expect != Type::Number && expect != Type::NumberOrString) {
-        RaiseTypeError(
-            _("You entered a number, but this type was expected:") + " " + TypeToString(expect),
-            location);
-      }
-    }
-  }
-
-  static Type StringToType(const gd::String &type);
-  static const gd::String &TypeToString(Type type);
-  static const gd::String unknownTypeString;
-  static const gd::String numberTypeString;
-  static const gd::String stringTypeString;
-  static const gd::String numberOrStringTypeString;
-  static const gd::String variableTypeString;
-  static const gd::String objectTypeString;
-  static const gd::String identifierTypeString;
-  static const gd::String emptyTypeString;
-
   std::vector<ExpressionParserDiagnostic*> errors;
-  std::vector<std::unique_ptr<ExpressionParserDiagnostic>> supplementalErrors;
-  Type childType;
-  Type parentType;
-  const gd::Platform &platform;
-  const gd::ObjectsContainer &globalObjectsContainer;
-  const gd::ObjectsContainer &objectsContainer;
 };
 
 }  // namespace gd

Core/GDCore/IDE/Events/ExpressionVariableOwnerFinder.h

@@ -1,172 +0,0 @@
-/*
- * GDevelop Core
- * Copyright 2008-present Florian Rival (Florian.Rival@gmail.com). All rights
- * reserved. This project is released under the MIT License.
- */
-#ifndef GDCORE_EXPRESSIONVARIABLEOWNERFINDER_H
-#define GDCORE_EXPRESSIONVARIABLEOWNERFINDER_H
-
-#include <memory>
-#include <vector>
-#include "GDCore/Events/Parsers/ExpressionParser2Node.h"
-#include "GDCore/Events/Parsers/ExpressionParser2NodeWorker.h"
-#include "GDCore/Extensions/Metadata/ExpressionMetadata.h"
-#include "GDCore/Extensions/Metadata/MetadataProvider.h"
-#include "GDCore/Extensions/Metadata/ObjectMetadata.h"
-#include "GDCore/Extensions/Metadata/ParameterMetadata.h"
-#include "GDCore/Project/Layout.h"  // For GetTypeOfObject and GetTypeOfBehavior
-#include "GDCore/Tools/Localization.h"
-
-namespace gd {
-class Expression;
-class ObjectsContainer;
-class Platform;
-class ParameterMetadata;
-class ExpressionMetadata;
-}  // namespace gd
-
-namespace gd {
-
-/**
- * \brief Find the object name that should be used as a context of the
- * expression or sub-expression that a given node represents.
- *
- * \see gd::ExpressionParser2
- */
-class GD_CORE_API ExpressionVariableOwnerFinder : public ExpressionParser2NodeWorker {
- public:
-
-  /**
-   * \brief Helper function to find the object name that should be used as a
-   * context of the expression or sub-expression that a given node represents.
-   */
-  static const gd::String GetObjectName(const gd::Platform &platform,
-                      const gd::ObjectsContainer &globalObjectsContainer,
-                      const gd::ObjectsContainer &objectsContainer,
-                      const gd::String& rootObjectName,
-                      gd::ExpressionNode& node) {
-    gd::ExpressionVariableOwnerFinder typeFinder(
-        platform, globalObjectsContainer, objectsContainer, rootObjectName);
-    node.Visit(typeFinder);
-    return typeFinder.GetObjectName();
-  }
-
-  virtual ~ExpressionVariableOwnerFinder(){};
-
- protected:
-  ExpressionVariableOwnerFinder(const gd::Platform &platform_,
-                       const gd::ObjectsContainer &globalObjectsContainer_,
-                       const gd::ObjectsContainer &objectsContainer_,
-                       const gd::String& rootObjectName_)
-      : platform(platform_),
-        globalObjectsContainer(globalObjectsContainer_),
-        objectsContainer(objectsContainer_),
-        rootObjectName(rootObjectName_),
-        objectName(""),
-        variableNode(nullptr) {};
-
-  /**
-   * \brief Get all the errors
-   *
-   * No errors means that the expression is valid.
-   */
-  const gd::String &GetObjectName() {
-    return objectName;
-  };
-
-  void OnVisitSubExpressionNode(SubExpressionNode& node) override {}
-  void OnVisitOperatorNode(OperatorNode& node) override {}
-  void OnVisitUnaryOperatorNode(UnaryOperatorNode& node) override {}
-  void OnVisitNumberNode(NumberNode& node) override {}
-  void OnVisitTextNode(TextNode& node) override {}
-  void OnVisitVariableNode(VariableNode& node) override {
-    if (variableNode != nullptr) {
-      // This is not possible
-      return;
-    }
-    if (node.parent == nullptr) {
-      objectName = rootObjectName;
-      return;
-    }
-    variableNode = &node;
-    node.parent->Visit(*this);
-  }
-  void OnVisitVariableAccessorNode(VariableAccessorNode& node) override {}
-  void OnVisitIdentifierNode(IdentifierNode& node) override {
-    if (variableNode != nullptr) {
-      // This is not possible
-      return;
-    }
-    if (node.parent == nullptr) {
-      objectName = rootObjectName;
-      return;
-    }
-    // This node is not necessarily a variable node.
-    // It will be checked when visiting the FunctionCallNode.
-    variableNode = &node;
-    node.parent->Visit(*this);
-  }
-  void OnVisitEmptyNode(EmptyNode& node) override {}
-  void OnVisitObjectFunctionNameNode(ObjectFunctionNameNode& node) override {}
-  void OnVisitVariableBracketAccessorNode(
-      VariableBracketAccessorNode& node) override {}
-  void OnVisitFunctionCallNode(FunctionCallNode& functionCall) override {
-    if (variableNode == nullptr) {
-      return;
-    }
-    int parameterIndex = -1;
-    for (int i = 0; i < functionCall.parameters.size(); i++) {
-      if (functionCall.parameters.at(i).get() == variableNode) {
-        parameterIndex = i;
-        break;
-      }
-    }
-    if (parameterIndex < 0) {
-      return;
-    }
-    const gd::ParameterMetadata* parameterMetadata =
-        MetadataProvider::GetFunctionCallParameterMetadata(
-            platform, 
-            globalObjectsContainer,
-            objectsContainer,
-            functionCall,
-            parameterIndex);
-    if (parameterMetadata == nullptr
-     || parameterMetadata->GetType() != "objectvar") {
-      return;
-    }
-
-    // The object on which the function is called is returned if no previous
-    // parameters are objects.
-    objectName = functionCall.objectName;
-    for (int previousIndex = parameterIndex - 1; previousIndex >= 0; previousIndex--) {
-      const gd::ParameterMetadata* previousParameterMetadata =
-          MetadataProvider::GetFunctionCallParameterMetadata(
-              platform, 
-              globalObjectsContainer,
-              objectsContainer,
-              functionCall,
-              previousIndex);
-      if (previousParameterMetadata != nullptr
-      && gd::ParameterMetadata::IsObject(previousParameterMetadata->GetType())) {
-        auto previousParameterNode = functionCall.parameters[previousIndex].get();
-        IdentifierNode* objectNode = dynamic_cast<IdentifierNode*>(previousParameterNode);
-        objectName = objectNode->identifierName;
-        return;
-      }
-    }
-  }
-
- private:
-  gd::String objectName;
-  gd::ExpressionNode *variableNode;
-
-  const gd::Platform &platform;
-  const gd::ObjectsContainer &globalObjectsContainer;
-  const gd::ObjectsContainer &objectsContainer;
-  const gd::String &rootObjectName;
-};
-
-}  // namespace gd
-
-#endif  // GDCORE_EXPRESSIONVARIABLEOWNERFINDER_H

Core/GDCore/IDE/Events/ExpressionsParameterMover.cpp

@@ -11,6 +11,7 @@
 
 #include "GDCore/Events/Event.h"
 #include "GDCore/Events/EventsList.h"
+#include "GDCore/Events/Parsers/ExpressionParser2.h"
 #include "GDCore/Events/Parsers/ExpressionParser2NodePrinter.h"
 #include "GDCore/Events/Parsers/ExpressionParser2NodeWorker.h"
 #include "GDCore/Extensions/Metadata/MetadataProvider.h"
@@ -145,9 +146,17 @@ bool ExpressionsParameterMover::DoVisitInstruction(gd::Instruction& instruction,
                             pNb < instruction.GetParametersCount();
        ++pNb) {
     const gd::String& type = metadata.parameters[pNb].type;
-    const gd::Expression& expression = instruction.GetParameter(pNb);
+    const gd::String& expression =
+        instruction.GetParameter(pNb).GetPlainString();
 
-    auto node = expression.GetRootNode();
+    gd::ExpressionParser2 parser(
+        platform, GetGlobalObjectsContainer(), GetObjectsContainer());
+
+    auto node = gd::ParameterMetadata::IsExpression("number", type)
+                    ? parser.ParseExpression("number", expression)
+                    : (gd::ParameterMetadata::IsExpression("string", type)
+                           ? parser.ParseExpression("string", expression)
+                           : std::unique_ptr<gd::ExpressionNode>());
     if (node) {
       ExpressionParameterMover mover(GetGlobalObjectsContainer(),
                                      GetObjectsContainer(),

Core/GDCore/IDE/Events/ExpressionsRenamer.cpp

@@ -11,6 +11,7 @@
 
 #include "GDCore/Events/Event.h"
 #include "GDCore/Events/EventsList.h"
+#include "GDCore/Events/Parsers/ExpressionParser2.h"
 #include "GDCore/Events/Parsers/ExpressionParser2NodePrinter.h"
 #include "GDCore/Events/Parsers/ExpressionParser2NodeWorker.h"
 #include "GDCore/Extensions/Metadata/MetadataProvider.h"
@@ -155,9 +156,18 @@ bool ExpressionsRenamer::DoVisitInstruction(gd::Instruction& instruction,
   for (std::size_t pNb = 0; pNb < metadata.parameters.size() &&
                             pNb < instruction.GetParametersCount();
        ++pNb) {
-    const gd::Expression& expression = instruction.GetParameter(pNb);
+    const gd::String& type = metadata.parameters[pNb].type;
+    const gd::String& expression =
+        instruction.GetParameter(pNb).GetPlainString();
 
-    auto node = expression.GetRootNode();
+    gd::ExpressionParser2 parser(
+        platform, GetGlobalObjectsContainer(), GetObjectsContainer());
+
+    auto node = gd::ParameterMetadata::IsExpression("number", type)
+                    ? parser.ParseExpression("number", expression)
+                    : (gd::ParameterMetadata::IsExpression("string", type)
+                           ? parser.ParseExpression("string", expression)
+                           : std::unique_ptr<gd::ExpressionNode>());
     if (node) {
       ExpressionFunctionRenamer renamer(GetGlobalObjectsContainer(),
                                         GetObjectsContainer(),

Core/GDCore/IDE/Events/UsedExtensionsFinder.cpp

@@ -1,10 +1,10 @@
 #include "UsedExtensionsFinder.h"
 
 #include "GDCore/Events/Instruction.h"
+#include "GDCore/Events/Parsers/ExpressionParser2.h"
 #include "GDCore/Extensions/Metadata/MetadataProvider.h"
 #include "GDCore/Extensions/PlatformExtension.h"
 #include "GDCore/IDE/WholeProjectRefactorer.h"
-#include "GDCore/IDE/Events/ExpressionTypeFinder.h"
 #include "GDCore/Project/BehaviorContent.h"
 #include "GDCore/Project/Object.h"
 #include "GDCore/Project/Project.h"
@@ -54,12 +54,13 @@ bool UsedExtensionsFinder::DoVisitInstruction(gd::Instruction& instruction,
         metadata.GetMetadata().GetParameter(i).GetType();
     i++;
 
-    if (gd::ParameterMetadata::IsExpression("string", parameterType)) {
-      rootType = "string";
-      expression.GetRootNode()->Visit(*this);
-    } else if (gd::ParameterMetadata::IsExpression("number", parameterType)) {
-      rootType = "number";
-      expression.GetRootNode()->Visit(*this);
+    if (gd::ParameterMetadata::IsExpression("string", parameterType) ||
+        gd::ParameterMetadata::IsExpression("number", parameterType)) {
+      gd::ExpressionParser2 parser(project.GetCurrentPlatform(),
+                                   GetGlobalObjectsContainer(),
+                                   GetObjectsContainer());
+      parser.ParseExpression(parameterType, expression.GetPlainString())
+          ->Visit(*this);
     } else if (gd::ParameterMetadata::IsExpression("variable", parameterType))
       usedExtensions.insert("BuiltinVariables");
   }
@@ -112,8 +113,7 @@ void UsedExtensionsFinder::OnVisitVariableBracketAccessorNode(
 
 // Add extensions bound to Objects/Behaviors/Functions
 void UsedExtensionsFinder::OnVisitIdentifierNode(IdentifierNode& node) {
-  auto type = gd::ExpressionTypeFinder::GetType(project.GetCurrentPlatform(), GetGlobalObjectsContainer(), GetObjectsContainer(), rootType, node);
-  if (gd::ParameterMetadata::IsObject(type)) {
+  if (gd::ParameterMetadata::IsObject(node.type)) {
     usedExtensions.insert(gd::MetadataProvider::GetExtensionAndObjectMetadata(
                               project.GetCurrentPlatform(), node.identifierName)
                               .GetExtension()

Core/GDCore/IDE/Events/UsedExtensionsFinder.h

@@ -31,7 +31,6 @@ class GD_CORE_API UsedExtensionsFinder
  private:
   UsedExtensionsFinder(gd::Project& project_) : project(project_){};
   gd::Project& project;
-  gd::String rootType;
   std::set<gd::String> usedExtensions;
 
   // Object Visitor

Core/GDCore/IDE/EventsFunctionTools.cpp

@@ -18,7 +18,7 @@
 namespace gd {
 
 void EventsFunctionTools::FreeEventsFunctionToObjectsContainer(
-    const gd::Project& project,
+    gd::Project& project,
     const gd::EventsFunction& eventsFunction,
     gd::ObjectsContainer& outputGlobalObjectsContainer,
     gd::ObjectsContainer& outputObjectsContainer) {
@@ -36,7 +36,7 @@ void EventsFunctionTools::FreeEventsFunctionToObjectsContainer(
 }
 
 void EventsFunctionTools::BehaviorEventsFunctionToObjectsContainer(
-    const gd::Project& project,
+    gd::Project& project,
     const gd::EventsBasedBehavior& eventsBasedBehavior,
     const gd::EventsFunction& eventsFunction,
     gd::ObjectsContainer& outputGlobalObjectsContainer,

Core/GDCore/IDE/EventsFunctionTools.h

@@ -32,7 +32,7 @@ class GD_CORE_API EventsFunctionTools {
    * generation for example.
    */
   static void FreeEventsFunctionToObjectsContainer(
-      const gd::Project& project,
+      gd::Project& project,
       const gd::EventsFunction& eventsFunction,
       gd::ObjectsContainer& outputGlobalObjectsContainer,
       gd::ObjectsContainer& outputObjectsContainer);
@@ -46,7 +46,7 @@ class GD_CORE_API EventsFunctionTools {
    * generation for example.
    */
   static void BehaviorEventsFunctionToObjectsContainer(
-      const gd::Project& project,
+      gd::Project& project,
       const gd::EventsBasedBehavior& eventsBasedBehavior,
       const gd::EventsFunction& eventsFunction,
       gd::ObjectsContainer& outputGlobalObjectsContainer,

Core/GDCore/IDE/Project/ArbitraryResourceWorker.cpp

@@ -126,10 +126,9 @@ class ResourceWorkerInEventsWorker : public ArbitraryEventsWorker {
         instruction.GetParameters(),
         metadata.GetParameters(),
         [this, &instruction](const gd::ParameterMetadata& parameterMetadata,
-                             const gd::Expression& parameterExpression,
+                             const gd::String& parameterValue,
                              size_t parameterIndex,
                              const gd::String& lastObjectName) {
-          const String& parameterValue = parameterExpression.GetPlainString();
           if (parameterMetadata.GetType() ==
               "police") {  // Should be renamed fontResource
             gd::String updatedParameterValue = parameterValue;

Core/GDCore/Project/EffectsContainer.cpp

@@ -117,16 +117,6 @@ void EffectsContainer::SwapEffects(std::size_t firstEffectIndex,
   effects[secondEffectIndex] = temp;
 }
 
-void EffectsContainer::MoveEffect(std::size_t oldIndex, std::size_t newIndex) {
-  if (oldIndex >= effects.size() || newIndex >= effects.size() ||
-      newIndex == oldIndex)
-    return;
-
-  auto effect = effects[oldIndex];
-  effects.erase(effects.begin() + oldIndex);
-  effects.insert(effects.begin() + newIndex, effect);
-}
-
 void EffectsContainer::SerializeTo(SerializerElement& element) const {
   element.ConsiderAsArrayOf("effect");
   for (std::size_t i = 0; i < GetEffectsCount(); ++i) {

Core/GDCore/Project/EffectsContainer.h

@@ -7,7 +7,6 @@
 #define GDCORE_EFFECTS_CONTAINER_H
 #include <memory>
 #include <vector>
-#include <algorithm>
 
 #include "GDCore/String.h"
 
@@ -90,11 +89,6 @@ class GD_CORE_API EffectsContainer {
    */
   void RemoveEffect(const gd::String& name);
 
-  /**
-   * \brief Move the specified effect at a new position in the list.
-   */
-  void MoveEffect(std::size_t oldIndex, std::size_t newIndex);
-
   /**
    * Swap the position of two effects.
    */

Core/GDCore/Project/Layout.cpp

@@ -54,8 +54,11 @@ Layout::Layout()
       oglFOV(90.0f),
       oglZNear(1.0f),
       oglZFar(500.0f),
-      disableInputWhenNotFocused(true),
+      disableInputWhenNotFocused(true)
+#if defined(GD_IDE_ONLY)
+      ,
       profiler(NULL)
+#endif
 {
   gd::Layer layer;
   layer.SetCameraCount(1);
@@ -329,6 +332,7 @@ void Layout::UnserializeFrom(gd::Project& project,
   disableInputWhenNotFocused =
       element.GetBoolAttribute("disableInputWhenNotFocused");
 
+#if defined(GD_IDE_ONLY)
   editorSettings.UnserializeFrom(
       element.GetChild("uiSettings", 0, "UISettings"));
 
@@ -336,6 +340,7 @@ void Layout::UnserializeFrom(gd::Project& project,
       element.GetChild("objectsGroups", 0, "GroupesObjets"));
   gd::EventsListSerialization::UnserializeEventsFrom(
       project, GetEvents(), element.GetChild("events", 0, "Events"));
+#endif
 
   UnserializeObjectsFrom(project, element.GetChild("objects", 0, "Objets"));
   initialInstances.UnserializeFrom(
@@ -405,11 +410,13 @@ void Layout::Init(const Layout& other) {
         std::unique_ptr<gd::BehaviorContent>(it.second->Clone());
   }
 
+#if defined(GD_IDE_ONLY)
   events = other.events;
   editorSettings = other.editorSettings;
   objectGroups = other.objectGroups;
 
   profiler = other.profiler;
+#endif
 }
 
 std::vector<gd::String> GetHiddenLayers(const Layout& layout) {
@@ -423,6 +430,7 @@ std::vector<gd::String> GetHiddenLayers(const Layout& layout) {
   return hiddenLayers;
 }
 
+#if defined(GD_IDE_ONLY)
 gd::String GD_CORE_API GetTypeOfObject(const gd::ObjectsContainer& project,
                                        const gd::ObjectsContainer& layout,
                                        gd::String name,
@@ -436,7 +444,7 @@ gd::String GD_CORE_API GetTypeOfObject(const gd::ObjectsContainer& project,
     type = project.GetObject(name).GetType();
 
   // Search in groups
-  else if (searchInGroups) {
+  if (searchInGroups) {
     for (std::size_t i = 0; i < layout.GetObjectGroups().size(); ++i) {
       if (layout.GetObjectGroups()[i].GetName() == name) {
         // A group has the name searched
@@ -497,16 +505,18 @@ gd::String GD_CORE_API GetTypeOfBehavior(const gd::ObjectsContainer& project,
                                          gd::String name,
                                          bool searchInGroups) {
   for (std::size_t i = 0; i < layout.GetObjectsCount(); ++i) {
-    const auto &object = layout.GetObject(i);
-    if (object.HasBehaviorNamed(name)) {
-      return object.GetBehavior(name).GetTypeName();
+    vector<gd::String> behaviors = layout.GetObject(i).GetAllBehaviorNames();
+    for (std::size_t j = 0; j < behaviors.size(); ++j) {
+      if (layout.GetObject(i).GetBehavior(behaviors[j]).GetName() == name)
+        return layout.GetObject(i).GetBehavior(behaviors[j]).GetTypeName();
     }
   }
 
   for (std::size_t i = 0; i < project.GetObjectsCount(); ++i) {
-    const auto &object = project.GetObject(i);
-    if (object.HasBehaviorNamed(name)) {
-      return object.GetBehavior(name).GetTypeName();
+    vector<gd::String> behaviors = project.GetObject(i).GetAllBehaviorNames();
+    for (std::size_t j = 0; j < behaviors.size(); ++j) {
+      if (project.GetObject(i).GetBehavior(behaviors[j]).GetName() == name)
+        return project.GetObject(i).GetBehavior(behaviors[j]).GetTypeName();
     }
   }
 
@@ -602,5 +612,6 @@ GetBehaviorsOfObject(const gd::ObjectsContainer& project,
 
   return behaviors;
 }
+#endif
 
 }  // namespace gd

Core/GDCore/Project/Object.cpp

@@ -12,7 +12,9 @@
 #include "GDCore/Project/Layout.h"
 #include "GDCore/Project/Project.h"
 #include "GDCore/Serialization/SerializerElement.h"
+#if defined(GD_IDE_ONLY)
 #include "GDCore/Project/PropertyDescriptor.h"
+#endif
 
 namespace gd {
 
@@ -22,7 +24,6 @@ Object::Object(const gd::String& name_) : name(name_) {}
 
 void Object::Init(const gd::Object& object) {
   name = object.name;
-  assetStoreId = object.assetStoreId;
   type = object.type;
   objectVariables = object.objectVariables;
   tags = object.tags;
@@ -79,12 +80,13 @@ gd::BehaviorContent& Object::AddBehavior(
   return *behaviors[behaviorName];
 }
 
+#if defined(GD_IDE_ONLY)
 std::map<gd::String, gd::PropertyDescriptor> Object::GetProperties() const {
   std::map<gd::String, gd::PropertyDescriptor> nothing;
   return nothing;
 }
 
-gd::BehaviorContent* Object::AddNewBehavior(const gd::Project& project,
+gd::BehaviorContent* Object::AddNewBehavior(gd::Project& project,
                                             const gd::String& type,
                                             const gd::String& name) {
   const gd::BehaviorMetadata& behaviorMetadata =
@@ -107,11 +109,11 @@ Object::GetInitialInstanceProperties(const gd::InitialInstance& instance,
   std::map<gd::String, gd::PropertyDescriptor> nothing;
   return nothing;
 }
+#endif
 
 void Object::UnserializeFrom(gd::Project& project,
                              const SerializerElement& element) {
   type = element.GetStringAttribute("type");
-  assetStoreId = element.GetStringAttribute("assetStoreId");
   name = element.GetStringAttribute("name", name, "nom");
   tags = element.GetStringAttribute("tags");
 
@@ -182,9 +184,9 @@ void Object::UnserializeFrom(gd::Project& project,
   DoUnserializeFrom(project, element);
 }
 
+#if defined(GD_IDE_ONLY)
 void Object::SerializeTo(SerializerElement& element) const {
   element.SetAttribute("name", GetName());
-  element.SetAttribute("assetStoreId", GetAssetStoreId());
   element.SetAttribute("type", GetType());
   element.SetAttribute("tags", GetTags());
   objectVariables.SerializeTo(element.AddChild("variables"));
@@ -207,5 +209,6 @@ void Object::SerializeTo(SerializerElement& element) const {
 
   DoSerializeTo(element);
 }
+#endif
 
 }  // namespace gd

Core/GDCore/Project/Object.h

@@ -5,7 +5,7 @@
  */
 #ifndef GDCORE_OBJECT_H
 #define GDCORE_OBJECT_H
-#include "GDCore/Vector2.h"
+#include <SFML/System/Vector2.hpp>
 #include <map>
 #include <memory>
 #include <vector>
@@ -83,14 +83,6 @@ class GD_CORE_API Object {
    */
   const gd::String& GetName() const { return name; };
 
-  /** \brief Change the asset store id of the object.
-   */
-  void SetAssetStoreId(const gd::String& assetStoreId_) { assetStoreId = assetStoreId_; };
-
-  /** \brief Return the asset store id of the object.
-   */
-  const gd::String& GetAssetStoreId() const { return assetStoreId; };
-
   /** \brief Change the type of the object.
    */
   void SetType(const gd::String& type_) { type = type_; }
@@ -108,6 +100,7 @@ class GD_CORE_API Object {
   const gd::String& GetTags() const { return tags; }
   ///@}
 
+#if defined(GD_IDE_ONLY)
   /** \name Resources management
    * Members functions related to managing resources used by the object
    */
@@ -193,6 +186,7 @@ class GD_CORE_API Object {
     return false;
   };
     ///@}
+#endif
 
   /** \name Behaviors management
    * Members functions related to behaviors management.
@@ -238,6 +232,7 @@ class GD_CORE_API Object {
    */
   gd::BehaviorContent& AddBehavior(const gd::BehaviorContent& behavior);
 
+#if defined(GD_IDE_ONLY)
   /**
    * \brief Add the behavior of the specified \a type with the specified \a
    * name.
@@ -247,9 +242,10 @@ class GD_CORE_API Object {
    * \return A pointer to the newly added behavior content. NULL if the creation
    * failed.
    */
-  gd::BehaviorContent* AddNewBehavior(const gd::Project& project,
+  gd::BehaviorContent* AddNewBehavior(gd::Project& project,
                                       const gd::String& type,
                                       const gd::String& name);
+#endif
 
   /**
    * \brief Get a read-only access to the map containing the behaviors with
@@ -300,11 +296,13 @@ class GD_CORE_API Object {
  * Members functions related to serialization of the object
  */
 ///@{
+#if defined(GD_IDE_ONLY)
   /**
    * \brief Serialize the object.
    * \see DoSerializeTo
    */
   void SerializeTo(SerializerElement& element) const;
+#endif
 
   /**
    * \brief Unserialize the object.
@@ -315,7 +313,6 @@ class GD_CORE_API Object {
 
  protected:
   gd::String name;  ///< The full name of the object
-  gd::String assetStoreId;  ///< The ID of the asset if the object comes from the store.
   gd::String type;  ///< Which type is the object. ( To test if we can do
                     ///< something reserved to some objects with it )
   std::map<gd::String, std::unique_ptr<gd::BehaviorContent>>
@@ -334,10 +331,12 @@ class GD_CORE_API Object {
   virtual void DoUnserializeFrom(gd::Project& project,
                                  const SerializerElement& element){};
 
+#if defined(GD_IDE_ONLY)
   /**
    * \brief Derived objects can redefine this method to save custom attributes.
    */
   virtual void DoSerializeTo(SerializerElement& element) const {};
+#endif
 
   /**
    * Initialize object using another object. Used by copy-ctor and assign-op.

Core/GDCore/Project/ObjectGroupsContainer.h

@@ -7,7 +7,6 @@
 #ifndef GDCORE_OBJECTGROUPSCONTAINER_H
 #define GDCORE_OBJECTGROUPSCONTAINER_H
 #include <vector>
-#include <algorithm>
 #include "GDCore/Project/ObjectGroup.h"
 #include "GDCore/String.h"
 namespace gd {
@@ -78,6 +77,7 @@ class GD_CORE_API ObjectGroupsContainer {
    */
   bool IsEmpty() const { return objectGroups.empty(); };
 
+#if defined(GD_IDE_ONLY)
   /**
    * \brief return the position of the group called "name" in the group list
    */
@@ -107,6 +107,7 @@ class GD_CORE_API ObjectGroupsContainer {
    * \brief Move the specified group at a new position in the list.
    */
   void Move(std::size_t oldIndex, std::size_t newIndex);
+#endif
 
   /**
    * \brief Clear all groups of the container.

Core/GDCore/Project/ObjectsContainer.cpp

@@ -76,7 +76,7 @@ std::size_t ObjectsContainer::GetObjectsCount() const {
   return initialObjects.size();
 }
 #if defined(GD_IDE_ONLY)
-gd::Object& ObjectsContainer::InsertNewObject(const gd::Project& project,
+gd::Object& ObjectsContainer::InsertNewObject(gd::Project& project,
                                               const gd::String& objectType,
                                               const gd::String& name,
                                               std::size_t position) {

Core/GDCore/Project/ObjectsContainer.h

@@ -94,7 +94,7 @@ class GD_CORE_API ObjectsContainer {
    * \note The object is created using the project's current platform.
    * \return A reference to the object in the list.
    */
-  gd::Object& InsertNewObject(const gd::Project& project,
+  gd::Object& InsertNewObject(gd::Project& project,
                               const gd::String& objectType,
                               const gd::String& name,
                               std::size_t position);

Core/GDCore/Project/Project.cpp

@@ -9,6 +9,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 
+#include <SFML/System/Utf.hpp>
 #include <cctype>
 #include <fstream>
 #include <map>
@@ -51,7 +52,6 @@ Project::Project()
     : name(_("Project")),
       version("1.0.0"),
       packageName("com.example.gamename"),
-      templateSlug(""),
       orientation("landscape"),
       folderProject(false),
       windowWidth(800),
@@ -66,9 +66,6 @@ Project::Project()
       projectUuid(""),
       useDeprecatedZeroAsDefaultZOrder(false),
       useExternalSourceFiles(false),
-      isPlayableWithKeyboard(false),
-      isPlayableWithGamepad(false),
-      isPlayableWithMobile(false),
       currentPlatform(NULL),
       gdMajorVersion(gd::VersionWrapper::Major()),
       gdMinorVersion(gd::VersionWrapper::Minor()),
@@ -517,7 +514,6 @@ void Project::UnserializeFrom(const SerializerElement& element) {
   SetProjectUuid(propElement.GetStringAttribute("projectUuid", ""));
   SetAuthor(propElement.GetChild("author", 0, "Auteur").GetValue().GetString());
   SetPackageName(propElement.GetStringAttribute("packageName"));
-  SetTemplateSlug(propElement.GetStringAttribute("templateSlug"));
   SetOrientation(propElement.GetStringAttribute("orientation", "default"));
   SetFolderProject(propElement.GetBoolAttribute("folderProject"));
   SetLastCompilationDirectory(propElement
@@ -749,7 +745,6 @@ void Project::SerializeTo(SerializerElement& element) const {
   propElement.SetAttribute("projectUuid", projectUuid);
   propElement.SetAttribute("folderProject", folderProject);
   propElement.SetAttribute("packageName", packageName);
-  propElement.SetAttribute("templateSlug", templateSlug);
   propElement.SetAttribute("orientation", orientation);
   platformSpecificAssets.SerializeTo(
       propElement.AddChild("platformSpecificAssets"));
@@ -977,7 +972,6 @@ void Project::Init(const gd::Project& game) {
   isPlayableWithGamepad = game.isPlayableWithGamepad;
   isPlayableWithMobile = game.isPlayableWithMobile;
   packageName = game.packageName;
-  templateSlug = game.templateSlug;
   orientation = game.orientation;
   folderProject = game.folderProject;
   latestCompilationDirectory = game.latestCompilationDirectory;

Core/GDCore/Project/Project.h

@@ -162,18 +162,6 @@ class GD_CORE_API Project : public ObjectsContainer {
    */
   const gd::String& GetPackageName() const { return packageName; }
 
-    /**
-   * \brief Change the slug of the template from which the project is created.
-   */
-  void SetTemplateSlug(const gd::String& templateSlug_) {
-    templateSlug = templateSlug_;
-  };
-
-  /**
-   * \brief Get the slug of the template from which the project is created.
-   */
-  const gd::String& GetTemplateSlug() const { return templateSlug; }
-
   /**
    * \brief Change the project orientation (in particular when exported with
    * Cordova). This has no effect on desktop and web browsers. \param
@@ -995,8 +983,6 @@ class GD_CORE_API Project : public ObjectsContainer {
   bool isPlayableWithGamepad;  ///< The project is playable with a gamepad.
   bool isPlayableWithMobile;   ///< The project is playable on a mobile.
   gd::String packageName;  ///< Game package name
-  gd::String templateSlug; ///< The slug of the template from which the game is
-                           ///< created.
   gd::String orientation;  ///< Lock game orientation (on mobile devices).
                            ///< "default", "landscape" or "portrait".
   bool

Core/GDCore/Project/ResourcesManager.h

@@ -60,7 +60,7 @@ class GD_CORE_API Resource {
    * \see gd::Resource::GetFile
    * \see gd::Resource::SetFile
    */
-  virtual bool UseFile() const { return false; }
+  virtual bool UseFile() { return false; }
 
   /**
    * \brief Return, if applicable, the String containing the file used by the
@@ -184,7 +184,7 @@ class GD_CORE_API ImageResource : public Resource {
    */
   virtual void SetFile(const gd::String& newFile) override;
 
-  virtual bool UseFile() const override { return true; }
+  virtual bool UseFile() override { return true; }
 
   std::map<gd::String, gd::PropertyDescriptor> GetProperties() const override;
   bool UpdateProperty(const gd::String& name, const gd::String& value) override;
@@ -234,7 +234,7 @@ class GD_CORE_API AudioResource : public Resource {
   virtual const gd::String& GetFile() const override { return file; };
   virtual void SetFile(const gd::String& newFile) override;
 
-  virtual bool UseFile() const override { return true; }
+  virtual bool UseFile() override { return true; }
 
   std::map<gd::String, gd::PropertyDescriptor> GetProperties() const override;
   bool UpdateProperty(const gd::String& name, const gd::String& value) override;
@@ -286,7 +286,7 @@ class GD_CORE_API FontResource : public Resource {
   virtual const gd::String& GetFile() const override { return file; };
   virtual void SetFile(const gd::String& newFile) override;
 
-  virtual bool UseFile() const override { return true; }
+  virtual bool UseFile() override { return true; }
   void SerializeTo(SerializerElement& element) const override;
 
   void UnserializeFrom(const SerializerElement& element) override;
@@ -312,7 +312,7 @@ class GD_CORE_API VideoResource : public Resource {
   virtual const gd::String& GetFile() const override { return file; };
   virtual void SetFile(const gd::String& newFile) override;
 
-  virtual bool UseFile() const override { return true; }
+  virtual bool UseFile() override { return true; }
   void SerializeTo(SerializerElement& element) const override;
 
   void UnserializeFrom(const SerializerElement& element) override;
@@ -338,7 +338,7 @@ class GD_CORE_API JsonResource : public Resource {
   virtual const gd::String& GetFile() const override { return file; };
   virtual void SetFile(const gd::String& newFile) override;
 
-  virtual bool UseFile() const override { return true; }
+  virtual bool UseFile() override { return true; }
 
   std::map<gd::String, gd::PropertyDescriptor> GetProperties() const override;
   bool UpdateProperty(const gd::String& name, const gd::String& value) override;
@@ -379,7 +379,7 @@ class GD_CORE_API BitmapFontResource : public Resource {
   virtual const gd::String& GetFile() const override { return file; };
   virtual void SetFile(const gd::String& newFile) override;
 
-  virtual bool UseFile() const override { return true; }
+  virtual bool UseFile() override { return true; }
   void SerializeTo(SerializerElement& element) const override;
 
   void UnserializeFrom(const SerializerElement& element) override;

Core/GDCore/Project/Variable.cpp

@@ -92,7 +92,7 @@ double Variable::GetValue() const {
     return value;
   } else if (type == Type::String) {
     double retVal = str.empty() ? 0.0 : str.To<double>();
-    if (std::isnan(retVal)) retVal = 0.0;
+    if(std::isnan(retVal)) retVal = 0.0;
     return retVal;
   } else if (type == Type::Boolean) {
     return boolVal ? 1.0 : 0.0;
@@ -188,15 +188,6 @@ const Variable& Variable::GetAtIndex(const size_t index) const {
   return *childrenArray.at(index);
 };
 
-void Variable::MoveChildInArray(const size_t oldIndex, const size_t newIndex) {
-  if (oldIndex >= childrenArray.size() || newIndex >= childrenArray.size())
-    return;
-
-  std::shared_ptr<gd::Variable> object = std::move(childrenArray[oldIndex]);
-  childrenArray.erase(childrenArray.begin() + oldIndex);
-  childrenArray.insert(childrenArray.begin() + newIndex, std::move(object));
-}
-
 Variable& Variable::PushNew() { return GetAtIndex(GetChildrenCount()); };
 
 void Variable::RemoveAtIndex(const size_t index) {
@@ -204,29 +195,8 @@ void Variable::RemoveAtIndex(const size_t index) {
   childrenArray.erase(childrenArray.begin() + index);
 };
 
-bool Variable::InsertAtIndex(const gd::Variable& variable, const size_t index) {
-  if (type != Type::Array) return false;
-  auto newVariable = std::make_shared<gd::Variable>(variable);
-  if (index < childrenArray.size()) {
-    childrenArray.insert(childrenArray.begin() + index, newVariable);
-  } else {
-    childrenArray.push_back(newVariable);
-  }
-  return true;
-};
-
-bool Variable::InsertChild(const gd::String& name,
-                           const gd::Variable& variable) {
-  if (type != Type::Structure || HasChild(name)) {
-    return false;
-  }
-  children[name] = std::make_shared<gd::Variable>(variable);
-  return true;
-};
-
 void Variable::SerializeTo(SerializerElement& element) const {
   element.SetStringAttribute("type", TypeAsString(GetType()));
-  if (IsFolded()) element.SetBoolAttribute("folded", true);
 
   if (type == Type::String) {
     element.SetStringAttribute("value", GetString());
@@ -264,7 +234,6 @@ void Variable::UnserializeFrom(const SerializerElement& element) {
   if (element.HasChild("children", "Children") && IsPrimitive(type))
     type = Type::Structure;
   // end of compatibility code
-  SetFolded(element.GetBoolAttribute("folded", false));
 
   if (IsPrimitive(type)) {
     if (type == Type::String) {
@@ -336,7 +305,6 @@ void Variable::RemoveRecursively(const gd::Variable& variableToRemove) {
 Variable::Variable(const Variable& other)
     : value(other.value),
       str(other.str),
-      folded(other.folded),
       boolVal(other.boolVal),
       type(other.type) {
   CopyChildren(other);
@@ -346,7 +314,6 @@ Variable& Variable::operator=(const Variable& other) {
   if (this != &other) {
     value = other.value;
     str = other.str;
-    folded = other.folded;
     boolVal = other.boolVal;
     type = other.type;
     CopyChildren(other);

Core/GDCore/Project/Variable.h

@@ -6,10 +6,10 @@
 
 #ifndef GDCORE_VARIABLE_H
 #define GDCORE_VARIABLE_H
-#include <cmath>
 #include <map>
 #include <memory>
 #include <vector>
+#include <cmath>
 
 #include "GDCore/String.h"
 namespace gd {
@@ -98,7 +98,7 @@ class GD_CORE_API Variable {
   void SetValue(double val) {
     value = val;
     // NaN values are not supported by GDevelop nor the serializer.
-    if (std::isnan(value)) value = 0.0;
+    if(std::isnan(value)) value = 0.0;
     type = Type::Number;
   }
 
@@ -185,9 +185,9 @@ class GD_CORE_API Variable {
    * \brief Get the count of children that the variable has.
    */
   size_t GetChildrenCount() const {
-    return type == Type::Structure ? children.size()
-           : type == Type::Array   ? childrenArray.size()
-                                   : 0;
+    return type == Type::Structure
+               ? children.size()
+               : type == Type::Array ? childrenArray.size() : 0;
   };
 
   /** \name Structure
@@ -290,38 +290,12 @@ class GD_CORE_API Variable {
    */
   void RemoveAtIndex(const size_t index);
 
-  /**
-   * \brief Move child in array.
-   */
-  void MoveChildInArray(const size_t oldIndex, const size_t newIndex);
-
-  /**
-   * \brief Insert child in array.
-   */
-  bool InsertAtIndex(const gd::Variable& variable, const size_t index);
-
-  /**
-   * \brief Insert a child in a structure.
-   */
-  bool InsertChild(const gd::String& name, const gd::Variable& variable);
-
   /**
    * \brief Get the vector containing all the children.
    */
   const std::vector<std::shared_ptr<Variable>>& GetAllChildrenArray() const {
     return childrenArray;
   }
-
-  /**
-   * \brief Set if the children must be folded.
-   */
-  void SetFolded(bool fold = true) { folded = fold; }
-
-  /**
-   * \brief True if the children should be folded in the variables editor.
-   */
-  bool IsFolded() const { return folded; }
-
   ///@}
   ///@}
 
@@ -351,7 +325,6 @@ class GD_CORE_API Variable {
    */
   static Type StringAsType(const gd::String& str);
 
-  bool folded;
   mutable Type type;
   mutable gd::String str;
   mutable double value;

Core/GDCore/Project/VariablesContainer.cpp

@@ -4,10 +4,8 @@
  * reserved. This project is released under the MIT License.
  */
 #include "GDCore/Project/VariablesContainer.h"
-
 #include <algorithm>
 #include <iostream>
-
 #include "GDCore/Project/Variable.h"
 #include "GDCore/Serialization/SerializerElement.h"
 #include "GDCore/String.h"
@@ -90,6 +88,7 @@ Variable& VariablesContainer::Insert(const gd::String& name,
   }
 }
 
+#if defined(GD_IDE_ONLY)
 void VariablesContainer::Remove(const gd::String& varName) {
   variables.erase(
       std::remove_if(
@@ -152,14 +151,13 @@ void VariablesContainer::Swap(std::size_t firstVariableIndex,
 }
 
 void VariablesContainer::Move(std::size_t oldIndex, std::size_t newIndex) {
-  if (oldIndex >= variables.size() || newIndex >= variables.size() ||
-      oldIndex == newIndex)
-    return;
+  if (oldIndex >= variables.size() || newIndex >= variables.size()) return;
 
   auto nameAndVariable = variables[oldIndex];
   variables.erase(variables.begin() + oldIndex);
   variables.insert(variables.begin() + newIndex, nameAndVariable);
 }
+#endif
 
 void VariablesContainer::SerializeTo(SerializerElement& element) const {
   element.ConsiderAsArrayOf("variable");

Core/GDCore/Serialization/SerializerElement.cpp

@@ -77,6 +77,8 @@ bool SerializerElement::GetBoolAttribute(const gd::String& name,
     }
   }
 
+  std::cout << "Bool attribute \"" << name << "\" not found, returning "
+            << defaultValue;
   return defaultValue;
 }
 

Core/GDCore/String.cpp

@@ -9,6 +9,7 @@
 #include <algorithm>
 #include <string.h>
 
+#include <SFML/System/String.hpp>
 #include "GDCore/CommonTools.h"
 #include "GDCore/Utf8/utf8proc.h"
 
@@ -27,6 +28,11 @@ String::String(const char *characters) : m_string()
     *this = characters;
 }
 
+String::String(const sf::String &string) : m_string()
+{
+    *this = string;
+}
+
 String::String(const std::u32string &string) : m_string()
 {
     *this = string;
@@ -38,6 +44,26 @@ String& String::operator=(const char *characters)
     return *this;
 }
 
+String& String::operator=(const sf::String &string)
+{
+    m_string.clear();
+
+    //In theory, an UTF8 character can be up to 6 bytes (even if in the current Unicode standard,
+    //the last character is 4 bytes long when encoded in UTF8).
+    //So, reserve the maximum possible size to avoid reallocations.
+    m_string.reserve( string.getSize() * 6 );
+
+    //Push_back all characters inside the string.
+    for( sf::String::ConstIterator it = string.begin(); it != string.end(); ++it )
+    {
+        push_back( *it );
+    }
+
+    m_string.shrink_to_fit();
+
+    return *this;
+}
+
 String& String::operator=(const std::u32string &string)
 {
     m_string.clear();
@@ -86,7 +112,7 @@ String::const_iterator String::end() const
 String String::FromLocale( const std::string &localizedString )
 {
 #if defined(WINDOWS)
-    return FromUTF8(localizedString); //Don't need to use the current locale, on Windows, std::locale is always the C locale
+    return FromSfString(sf::String(localizedString)); //Don't need to use the current locale, on Windows, std::locale is always the C locale
 #elif defined(MACOS)
     return FromUTF8(localizedString); //Assume UTF8 is the current locale
 #elif defined(EMSCRIPTEN)
@@ -98,7 +124,7 @@ String String::FromLocale( const std::string &localizedString )
        std::locale("").name().find("UTF8") != std::string::npos)
         return FromUTF8(localizedString); //UTF8 is already the current locale
     else
-        return FromUTF8(localizedString); //Use the current locale (std::locale("")) for conversion
+        return FromSfString(sf::String(localizedString, std::locale(""))); //Use the current locale (std::locale("")) for conversion
 #endif
 }
 
@@ -110,6 +136,11 @@ String String::FromUTF32( const std::u32string &string )
     return str;
 }
 
+String String::FromSfString( const sf::String &sfString )
+{
+    return String(sfString);
+}
+
 String String::FromUTF8( const std::string &utf8Str )
 {
     String str(utf8Str.c_str());
@@ -133,7 +164,7 @@ String String::FromWide( const std::wstring &wstr )
 std::string String::ToLocale() const
 {
 #if defined(WINDOWS)
-    return m_string;
+    return ToSfString().toAnsiString();
 #elif defined(MACOS)
     return m_string;
 #elif defined(EMSCRIPTEN)
@@ -145,7 +176,7 @@ std::string String::ToLocale() const
        std::locale("").name().find("UTF8") != std::string::npos)
         return m_string; //UTF8 is already the current locale on Linux
     else
-        return m_string; //Use the current locale for conversion
+        return ToSfString().toAnsiString(std::locale("")); //Use the current locale for conversion
 #endif
 }
 
@@ -160,6 +191,20 @@ std::u32string String::ToUTF32() const
     return u32str;
 }
 
+sf::String String::ToSfString() const
+{
+    sf::String str;
+    for(const_iterator it = begin(); it != end(); ++it)
+        str += sf::String(static_cast<sf::Uint32>(*it));
+
+    return str;
+}
+
+String::operator sf::String() const
+{
+    return ToSfString();
+}
+
 std::string String::ToUTF8() const
 {
     return m_string;