fix: preserve validation feedback targets

Validation feedback actions can target an object or an association path, but the MDL grammar only accepted attribute paths and the formatter only emitted attribute targets. Round-tripping those actions either failed to parse object-only targets or dropped the association name.

The parser now accepts object-only validation feedback targets and treats each path segment as a qualified name so Module.Association stays a single association segment. The formatter emits AssociationName when AttributeName is absent, preserving association targets from existing models.

Tests cover object-only and association formatter output, parser coverage for both target shapes, and the full build/lint/test validation passed locally.

Author: hjothamendix

mdl/executor/cmd_microflows_format_action.go

@@ -587,6 +587,8 @@ func formatAction(
 			if len(parts) >= 3 {
 				attrPath = varName + "/" + parts[len(parts)-1]
 			}
+		} else if a.AssociationName != "" {
+			attrPath = varName + "/" + a.AssociationName
 		}
 		return fmt.Sprintf("validation feedback %s message %s;", attrPath, msgText)
 

mdl/executor/cmd_microflows_format_action_test.go

@@ -507,6 +507,37 @@ func TestFormatAction_ValidationFeedback(t *testing.T) {
 	}
 }
 
+func TestFormatAction_ValidationFeedback_ObjectOnlyTarget(t *testing.T) {
+	e := newTestExecutor()
+	action := &microflows.ValidationFeedbackAction{
+		ObjectVariable: "Customer",
+		Template: &model.Text{
+			Translations: map[string]string{"en_US": "Select a customer"},
+		},
+	}
+	got := e.formatAction(action, nil, nil)
+	want := "validation feedback $Customer message 'Select a customer';"
+	if got != want {
+		t.Errorf("got %q, want %q", got, want)
+	}
+}
+
+func TestFormatAction_ValidationFeedback_AssociationTarget(t *testing.T) {
+	e := newTestExecutor()
+	action := &microflows.ValidationFeedbackAction{
+		ObjectVariable:  "OrderForm",
+		AssociationName: "Sales.OrderForm_Customer",
+		Template: &model.Text{
+			Translations: map[string]string{"en_US": "Select a customer"},
+		},
+	}
+	got := e.formatAction(action, nil, nil)
+	want := "validation feedback $OrderForm/Sales.OrderForm_Customer message 'Select a customer';"
+	if got != want {
+		t.Errorf("got %q, want %q", got, want)
+	}
+}
+
 func TestFormatAction_LogMessage(t *testing.T) {
 	e := newTestExecutor()
 	action := &microflows.LogMessageAction{

mdl/grammar/MDLParser.g4

@@ -1321,7 +1321,7 @@ changeObjectStatement
     ;
 
 attributePath
-    : VARIABLE ((SLASH | DOT) (IDENTIFIER | qualifiedName))+
+    : VARIABLE ((SLASH | DOT) qualifiedName)+
     ;
 
 // COMMIT $Product; or COMMIT $Product WITH EVENTS; or COMMIT $Product REFRESH;
@@ -1565,7 +1565,7 @@ throwStatement
 // VALIDATION FEEDBACK $Product/Code MESSAGE 'Product code cannot be empty';
 // VALIDATION FEEDBACK $Product/Code MESSAGE '{1}' OBJECTS [$Var1, $Var2];
 validationFeedbackStatement
-    : VALIDATION FEEDBACK attributePath MESSAGE expression (OBJECTS LBRACKET expressionList RBRACKET)?
+    : VALIDATION FEEDBACK (attributePath | VARIABLE) MESSAGE expression (OBJECTS LBRACKET expressionList RBRACKET)?
     ;
 
 // =============================================================================

mdl/grammar/parser/MDLParser.interp

@@ -826,6 +826,10 @@ func buildValidationFeedbackStatement(ctx parser.IValidationFeedbackStatementCon
 	// Build attribute path
 	if attrPath := vfCtx.AttributePath(); attrPath != nil {
 		stmt.AttributePath = buildAttributePathFromContext(attrPath)
+	} else if variable := vfCtx.VARIABLE(); variable != nil {
+		stmt.AttributePath = &ast.AttributePathExpr{
+			Variable: strings.TrimPrefix(variable.GetText(), "$"),
+		}
 	}
 
 	// Build message expression

mdl/grammar/parser/mdl_lexer.go

@@ -605,6 +605,63 @@ END;`
 	t.Log("VALIDATION FEEDBACK inside IF block parsed correctly")
 }
 
+func TestValidationFeedbackObjectAndAssociationTargets(t *testing.T) {
+	input := `CREATE MICROFLOW Sales.ValidateOrder ($OrderForm: Sales.OrderForm)
+RETURNS Boolean
+BEGIN
+  VALIDATION FEEDBACK $OrderForm MESSAGE 'Select a value';
+  VALIDATION FEEDBACK $OrderForm/Sales.OrderForm_Customer MESSAGE 'Select a customer';
+  RETURN false;
+END;`
+
+	prog, errs := Build(input)
+	if len(errs) > 0 {
+		for _, err := range errs {
+			t.Errorf("Parse error: %v", err)
+		}
+		return
+	}
+
+	stmt := prog.Statements[0].(*ast.CreateMicroflowStmt)
+	if len(stmt.Body) < 2 {
+		t.Fatalf("Expected at least two body statements, got %d", len(stmt.Body))
+	}
+
+	objectFeedback, ok := stmt.Body[0].(*ast.ValidationFeedbackStmt)
+	if !ok {
+		t.Fatalf("Expected object-only validation feedback, got %T", stmt.Body[0])
+	}
+	if objectFeedback.AttributePath == nil {
+		t.Fatal("Expected object-only AttributePath to be set")
+	}
+	if objectFeedback.AttributePath.Variable != "OrderForm" {
+		t.Errorf("Expected object-only variable 'OrderForm', got %q", objectFeedback.AttributePath.Variable)
+	}
+	if len(objectFeedback.AttributePath.Path) != 0 || len(objectFeedback.AttributePath.Segments) != 0 {
+		t.Errorf("Expected object-only validation feedback to have no path, got path=%v segments=%v",
+			objectFeedback.AttributePath.Path, objectFeedback.AttributePath.Segments)
+	}
+
+	associationFeedback, ok := stmt.Body[1].(*ast.ValidationFeedbackStmt)
+	if !ok {
+		t.Fatalf("Expected association validation feedback, got %T", stmt.Body[1])
+	}
+	if associationFeedback.AttributePath == nil {
+		t.Fatal("Expected association AttributePath to be set")
+	}
+	if associationFeedback.AttributePath.Variable != "OrderForm" {
+		t.Errorf("Expected association variable 'OrderForm', got %q", associationFeedback.AttributePath.Variable)
+	}
+	if len(associationFeedback.AttributePath.Path) != 1 || associationFeedback.AttributePath.Path[0] != "Sales.OrderForm_Customer" {
+		t.Errorf("Expected association path Sales.OrderForm_Customer, got %v", associationFeedback.AttributePath.Path)
+	}
+	if len(associationFeedback.AttributePath.Segments) != 1 ||
+		associationFeedback.AttributePath.Segments[0].Separator != "/" ||
+		associationFeedback.AttributePath.Segments[0].Name != "Sales.OrderForm_Customer" {
+		t.Errorf("Expected slash-qualified association segment, got %v", associationFeedback.AttributePath.Segments)
+	}
+}
+
 // TestRollbackStatement verifies the ROLLBACK statement parses correctly.
 func TestRollbackStatement(t *testing.T) {
 	input := `CREATE MICROFLOW Test.TestRollback ($Order: Test.Order)