Add orderBy/limit to GetAllExpressionsWithMetadata and validate in UI

- Add orderBy and limit expressions (type "number") to
  ForEachEvent::GetAllExpressionsWithMetadata so refactoring propagates
  to them.
- Expose GetOrderByExpression/GetLimitExpression in C++ header, IDL
  bindings, and JS types for expression validation.
- Show red underlines (instructionInvalidParameter) on invalid orderBy
  and limit expressions in the ForEachEvent renderer, matching the
  RepeatEvent pattern. Empty limit is treated as valid.
- Replace cursor:pointer on inline selects with the "selectable" CSS
  class for consistent styling.

https://claude.ai/code/session_01LXTeNz7ehNS5TqFYSU6aw5

Author: claude

Core/GDCore/Events/Builtin/ForEachEvent.cpp

@@ -39,9 +39,14 @@ vector<pair<gd::Expression*, gd::ParameterMetadata> >
     ForEachEvent::GetAllExpressionsWithMetadata() {
   vector<pair<gd::Expression*, gd::ParameterMetadata> >
       allExpressionsWithMetadata;
-  auto metadata = gd::ParameterMetadata().SetType("object");
+  auto objectMetadata = gd::ParameterMetadata().SetType("object");
   allExpressionsWithMetadata.push_back(
-      std::make_pair(&objectsToPick, metadata));
+      std::make_pair(&objectsToPick, objectMetadata));
+  auto numberMetadata = gd::ParameterMetadata().SetType("number");
+  allExpressionsWithMetadata.push_back(
+      std::make_pair(&orderBy, numberMetadata));
+  allExpressionsWithMetadata.push_back(
+      std::make_pair(&limit, numberMetadata));
 
   return allExpressionsWithMetadata;
 }
@@ -65,9 +70,14 @@ vector<pair<const gd::Expression*, const gd::ParameterMetadata> >
     ForEachEvent::GetAllExpressionsWithMetadata() const {
   vector<pair<const gd::Expression*, const gd::ParameterMetadata> >
       allExpressionsWithMetadata;
-  auto metadata = gd::ParameterMetadata().SetType("object");
+  auto objectMetadata = gd::ParameterMetadata().SetType("object");
+  allExpressionsWithMetadata.push_back(
+      std::make_pair(&objectsToPick, objectMetadata));
+  auto numberMetadata = gd::ParameterMetadata().SetType("number");
+  allExpressionsWithMetadata.push_back(
+      std::make_pair(&orderBy, numberMetadata));
   allExpressionsWithMetadata.push_back(
-      std::make_pair(&objectsToPick, metadata));
+      std::make_pair(&limit, numberMetadata));
 
   return allExpressionsWithMetadata;
 }

Core/GDCore/Events/Builtin/ForEachEvent.h

@@ -65,6 +65,7 @@ class GD_CORE_API ForEachEvent : public gd::BaseEvent {
   void SetOrderBy(gd::String orderBy_) {
     orderBy = gd::Expression(orderBy_);
   };
+  const gd::Expression& GetOrderByExpression() const { return orderBy; };
 
   const gd::String& GetOrder() const { return order; }
   void SetOrder(const gd::String& order_) { order = order_; }
@@ -75,6 +76,7 @@ class GD_CORE_API ForEachEvent : public gd::BaseEvent {
   void SetLimit(gd::String limit_) {
     limit = gd::Expression(limit_);
   };
+  const gd::Expression& GetLimitExpression() const { return limit; };
 
   virtual std::vector<const gd::InstructionsList*> GetAllConditionsVectors()
       const;

GDevelop.js/Bindings/Bindings.idl

@@ -2520,10 +2520,12 @@ interface ForEachEvent {
     void SetLoopIndexVariableName([Const] DOMString name);
     [Const, Ref] DOMString GetOrderBy();
     void SetOrderBy([Const] DOMString orderBy);
+    [Const, Ref] Expression GetOrderByExpression();
     [Const, Ref] DOMString GetOrder();
     void SetOrder([Const] DOMString order);
     [Const, Ref] DOMString GetLimit();
     void SetLimit([Const] DOMString limit);
+    [Const, Ref] Expression GetLimitExpression();
 };
 ForEachEvent implements BaseEvent;
 

GDevelop.js/types.d.ts

@@ -1942,10 +1942,12 @@ export class ForEachEvent extends BaseEvent {
   setLoopIndexVariableName(name: string): void;
   getOrderBy(): string;
   setOrderBy(orderBy: string): void;
+  getOrderByExpression(): Expression;
   getOrder(): string;
   setOrder(order: string): void;
   getLimit(): string;
   setLimit(limit: string): void;
+  getLimitExpression(): Expression;
 }
 
 export class ForEachChildVariableEvent extends BaseEvent {

GDevelop.js/types/gdforeachevent.js

@@ -9,10 +9,12 @@ declare class gdForEachEvent extends gdBaseEvent {
   setLoopIndexVariableName(name: string): void;
   getOrderBy(): string;
   setOrderBy(orderBy: string): void;
+  getOrderByExpression(): gdExpression;
   getOrder(): string;
   setOrder(order: string): void;
   getLimit(): string;
   setLimit(limit: string): void;
+  getLimitExpression(): gdExpression;
   delete(): void;
   ptr: number;
 };

newIDE/app/src/EventsSheet/EventsTree/Renderers/ForEachEvent.js

@@ -53,7 +53,6 @@ const styles = {
     background: 'none',
     border: 'none',
     borderBottom: '1px dashed currentColor',
-    cursor: 'pointer',
     fontSize: 'inherit',
     fontFamily: 'inherit',
     color: 'inherit',
@@ -223,11 +222,39 @@ export default class ForEachEvent extends React.Component<
   render(): any {
     const forEachEvent = gd.asForEachEvent(this.props.event);
     const objectName = forEachEvent.getObjectToPick();
-    const orderBy = forEachEvent.getOrderBy();
+    const orderByExpression = forEachEvent.getOrderByExpression();
+    const orderBy = orderByExpression.getPlainString();
     const order = forEachEvent.getOrder();
-    const limit = forEachEvent.getLimit();
+    const limitExpression = forEachEvent.getLimitExpression();
+    const limit = limitExpression.getPlainString();
     const hasOrderBy = !!orderBy;
 
+    let isOrderByValid = true;
+    if (hasOrderBy) {
+      const orderByValidator = new gd.ExpressionValidator(
+        gd.JsPlatform.get(),
+        this.props.projectScopedContainersAccessor.get(),
+        'number',
+        ''
+      );
+      orderByExpression.getRootNode().visit(orderByValidator);
+      isOrderByValid = orderByValidator.getAllErrors().size() === 0;
+      orderByValidator.delete();
+    }
+
+    let isLimitValid = true;
+    if (limit) {
+      const limitValidator = new gd.ExpressionValidator(
+        gd.JsPlatform.get(),
+        this.props.projectScopedContainersAccessor.get(),
+        'number',
+        ''
+      );
+      limitExpression.getRootNode().visit(limitValidator);
+      isLimitValid = limitValidator.getAllErrors().size() === 0;
+      limitValidator.delete();
+    }
+
     const objectNameIsValid = this.props.projectScopedContainersAccessor
       .get()
       .getObjectsContainersList()
@@ -298,6 +325,7 @@ export default class ForEachEvent extends React.Component<
           </Trans>{' '}
           {/* Inline select for "ordered by" vs "(any order)" */}
           <select
+            className={selectableArea}
             style={styles.inlineSelect}
             value={hasOrderBy ? 'orderBy' : 'any'}
             onChange={e => {
@@ -336,10 +364,21 @@ export default class ForEachEvent extends React.Component<
                 }}
                 tabIndex={0}
               >
-                {orderBy}
+                {isOrderByValid ? (
+                  orderBy
+                ) : (
+                  <span
+                    className={classNames({
+                      [instructionInvalidParameter]: true,
+                    })}
+                  >
+                    {orderBy}
+                  </span>
+                )}
               </span>
               ({/* Inline select for ascending/descending */}
               <select
+                className={selectableArea}
                 style={styles.inlineSelect}
                 value={order}
                 onChange={e => {
@@ -371,7 +410,21 @@ export default class ForEachEvent extends React.Component<
                   }}
                   tabIndex={0}
                 >
-                  {limit || <Trans>no limit</Trans>}
+                  {limit ? (
+                    isLimitValid ? (
+                      limit
+                    ) : (
+                      <span
+                        className={classNames({
+                          [instructionInvalidParameter]: true,
+                        })}
+                      >
+                        {limit}
+                      </span>
+                    )
+                  ) : (
+                    <Trans>no limit</Trans>
+                  )}
                 </span>
               </span>
               )