fix: support log node expressions in microflow roundtrip

The LOG statement's optional NODE clause only accepted a bare
`STRING_LITERAL` (e.g. `LOG INFO NODE 'MyModule' 'msg'`), but Studio
Pro persists projects where the node is any expression — a constant
reference like `@MyModule.SecurityLogNode`, a variable, or a function
call. Describing those microflows emitted MDL the parser rejected with
`mismatched input '$' expecting STRING_LITERAL`, and
`addLogMessageAction` was wrapping the already-quoted node in an extra
pair of quotes whenever the input was a plain string.

Widen the grammar and AST:

    logStatement
        : LOG logLevel? (NODE expression)? expression logTemplateParams?
        ;

    LogStmt.Node: Expression  // was string

The visitor now collects all child expressions and assigns the first
to `Node` / second to `Message` when `NODE` is present; the builder
formats `s.Node` through `exprToString` and defaults to `'Application'`
when absent. Describer and diff emitter pass the node through the same
expression formatter, and the format casing is lowercased to match the
rest of the MDL output.

`formatAction` for `LogMessageAction` keeps raw template text on the
wire so Mendix-style `{1}` placeholders survive when WITH params are
present; without that, the literal got re-quoted into `'''Order {1}'''`
on every roundtrip.

Regression tests cover:
- `log info node @Module.Constant 'msg'` roundtrip through
  create -> describe -> re-exec
- template LOG statements: `log info node 'App' 'Order {1}' with ...`
- visitor builds `ConstantRefExpr` for `@Module.Constant` node
- `formatAction` multiline escaping matches the new lowercased form

Author: hjotha

mdl/ast/ast_microflow.go

@@ -261,10 +261,10 @@ func (p *TemplateParam) IsDataSourceRef() bool {
 	return p.DataSourceName != ""
 }
 
-// LogStmt represents: LOG LEVEL NODE 'node' 'message' [WITH params]
+// LogStmt represents: LOG LEVEL [NODE expr] message [WITH params]
 type LogStmt struct {
 	Level       LogLevel             // Log level (INFO, WARNING, etc.)
-	Node        string               // Log node name
+	Node        Expression           // Optional log node expression
 	Message     Expression           // Message expression
 	Template    []TemplateParam      // Optional WITH template params
 	Annotations *ActivityAnnotations // Optional @position, @caption, @color, @annotation

mdl/executor/bugfix_regression_test.go

@@ -140,6 +140,82 @@ func TestAddWhileStatement_PreservesAnnotatedPosition(t *testing.T) {
 	}
 }
 
+func TestAddLogMessageAction_PreservesNodeExpression(t *testing.T) {
+	fb := &flowBuilder{
+		posX:     100,
+		posY:     200,
+		spacing:  HorizontalSpacing,
+		measurer: &layoutMeasurer{},
+	}
+
+	stmt := &ast.LogStmt{
+		Level: ast.LogInfo,
+		Node: &ast.ConstantRefExpr{
+			QualifiedName: ast.QualifiedName{Module: "TestModule", Name: "SecurityLogNode"},
+		},
+		Message: &ast.LiteralExpr{Kind: ast.LiteralString, Value: "User added"},
+	}
+
+	id := fb.addLogMessageAction(stmt)
+	if id == "" {
+		t.Fatal("expected log activity ID")
+	}
+
+	activity, ok := fb.objects[len(fb.objects)-1].(*microflows.ActionActivity)
+	if !ok {
+		t.Fatalf("expected ActionActivity, got %T", fb.objects[len(fb.objects)-1])
+	}
+
+	action, ok := activity.Action.(*microflows.LogMessageAction)
+	if !ok {
+		t.Fatalf("expected LogMessageAction, got %T", activity.Action)
+	}
+
+	if action.LogNodeName != "@TestModule.SecurityLogNode" {
+		t.Fatalf("got log node %q, want %q", action.LogNodeName, "@TestModule.SecurityLogNode")
+	}
+}
+
+func TestAddLogMessageAction_TemplateLiteralDoesNotKeepQuotes(t *testing.T) {
+	fb := &flowBuilder{
+		posX:     100,
+		posY:     200,
+		spacing:  HorizontalSpacing,
+		measurer: &layoutMeasurer{},
+	}
+
+	stmt := &ast.LogStmt{
+		Level: ast.LogInfo,
+		Node:  &ast.LiteralExpr{Kind: ast.LiteralString, Value: "App"},
+		Message: &ast.LiteralExpr{
+			Kind:  ast.LiteralString,
+			Value: "Order {1}",
+		},
+		Template: []ast.TemplateParam{
+			{Index: 1, Value: &ast.VariableExpr{Name: "OrderNumber"}},
+		},
+	}
+
+	id := fb.addLogMessageAction(stmt)
+	if id == "" {
+		t.Fatal("expected log activity ID")
+	}
+
+	activity, ok := fb.objects[len(fb.objects)-1].(*microflows.ActionActivity)
+	if !ok {
+		t.Fatalf("expected ActionActivity, got %T", fb.objects[len(fb.objects)-1])
+	}
+
+	action, ok := activity.Action.(*microflows.LogMessageAction)
+	if !ok {
+		t.Fatalf("expected LogMessageAction, got %T", activity.Action)
+	}
+
+	if got := action.MessageTemplate.Translations["en_US"]; got != "Order {1}" {
+		t.Fatalf("got message template %q, want %q", got, "Order {1}")
+	}
+}
+
 // =============================================================================
 // Issue #19: Long type must not be downgraded to Integer
 // =============================================================================

mdl/executor/cmd_diff_mdl.go

@@ -345,9 +345,9 @@ func microflowStatementToMDL(ctx *ExecContext, stmt ast.MicroflowStatement, inde
 		lines = append(lines, indentStr+"end loop;")
 
 	case *ast.LogStmt:
-		nodeStr := s.Node
-		if !strings.HasPrefix(nodeStr, "'") {
-			nodeStr = "'" + nodeStr + "'"
+		nodeStr := "'Application'"
+		if s.Node != nil {
+			nodeStr = diffExpressionToString(ctx, s.Node)
 		}
 		msgStr := diffExpressionToString(ctx, s.Message)
 		stmt := fmt.Sprintf("%slog %s node %s %s", indentStr, strings.ToLower(s.Level.String()), nodeStr, msgStr)

mdl/executor/cmd_microflows_builder_calls.go

@@ -38,7 +38,11 @@ func (fb *flowBuilder) addLogMessageAction(s *ast.LogStmt) model.ID {
 
 	if len(s.Template) > 0 {
 		// Use provided template parameters
-		templateText = fb.exprToString(s.Message)
+		if lit, ok := s.Message.(*ast.LiteralExpr); ok && lit.Kind == ast.LiteralString {
+			templateText = fmt.Sprintf("%v", lit.Value)
+		} else {
+			templateText = fb.exprToString(s.Message)
+		}
 		// Sort parameters by index to ensure correct order
 		maxIndex := 0
 		for _, p := range s.Template {
@@ -61,10 +65,15 @@ func (fb *flowBuilder) addLogMessageAction(s *ast.LogStmt) model.ID {
 		templateParams = []string{fb.exprToString(s.Message)}
 	}
 
+	logNodeName := "'Application'"
+	if s.Node != nil {
+		logNodeName = fb.exprToString(s.Node)
+	}
+
 	action := &microflows.LogMessageAction{
 		BaseElement: model.BaseElement{ID: model.ID(types.GenerateID())},
 		LogLevel:    logLevel,
-		LogNodeName: "'" + s.Node + "'", // Store as expression (e.g., 'TEST')
+		LogNodeName: logNodeName,
 		MessageTemplate: &model.Text{
 			BaseElement: model.BaseElement{ID: model.ID(types.GenerateID())},
 			Translations: map[string]string{

mdl/executor/cmd_microflows_format_action_test.go

@@ -535,7 +535,23 @@ func TestFormatAction_LogMessage_EscapesMultiline(t *testing.T) {
 		},
 	}
 	got := e.formatAction(action, nil, nil)
-	want := "LOG INFO NODE 'App' 'Line 1\\nLine 2';"
+	want := "log info node 'App' 'Line 1\\nLine 2';"
+	if got != want {
+		t.Errorf("got %q, want %q", got, want)
+	}
+}
+
+func TestFormatAction_LogMessage_NodeExpression(t *testing.T) {
+	e := newTestExecutor()
+	action := &microflows.LogMessageAction{
+		LogLevel:    microflows.LogLevelInfo,
+		LogNodeName: "@MyModule.SecurityLogNode",
+		MessageTemplate: &model.Text{
+			Translations: map[string]string{"en_US": "User added"},
+		},
+	}
+	got := e.formatAction(action, nil, nil)
+	want := "log info node @MyModule.SecurityLogNode 'User added';"
 	if got != want {
 		t.Errorf("got %q, want %q", got, want)
 	}

mdl/executor/roundtrip_microflow_test.go

@@ -107,9 +107,56 @@ func TestRoundtripMicroflow_LogWithTemplate(t *testing.T) {
 		t.Error("Expected $CustomerName parameter in output")
 	}
 
+	if err := env.executeMDL(output); err != nil {
+		t.Fatalf("Describe output should execute without syntax errors: %v\n%s", err, output)
+	}
+
+	output2, err := env.describeMDL(`DESCRIBE MICROFLOW ` + microflowName + `;`)
+	if err != nil {
+		t.Fatalf("Failed to describe microflow after re-exec: %v", err)
+	}
+	if strings.Contains(output2, "'''Processing order") {
+		t.Fatalf("Roundtrip should not double-quote log template text:\n%s", output2)
+	}
+
 	t.Logf("log with template roundtrip successful:\n%s", output)
 }
 
+func TestRoundtripMicroflow_LogWithNodeExpression(t *testing.T) {
+	env := setupTestEnv(t)
+	defer env.teardown()
+
+	if err := env.executeMDL(`CREATE CONSTANT ` + testModule + `.SecurityLogNode TYPE String DEFAULT 'Security';`); err != nil {
+		t.Fatalf("Failed to create constant for log node: %v", err)
+	}
+
+	microflowName := testModule + ".TestLogNodeExpression"
+	env.registerCleanup("microflow", microflowName)
+
+	createMDL := `CREATE MICROFLOW ` + microflowName + ` () RETURNS Boolean
+	BEGIN
+		LOG INFO NODE @` + testModule + `.SecurityLogNode 'User added';
+		RETURN true;
+	END;`
+
+	if err := env.executeMDL(createMDL); err != nil {
+		t.Fatalf("Failed to create microflow with node expression: %v", err)
+	}
+
+	output, err := env.describeMDL(`DESCRIBE MICROFLOW ` + microflowName + `;`)
+	if err != nil {
+		t.Fatalf("Failed to describe microflow: %v", err)
+	}
+
+	if !containsProperty(output, "LOG INFO NODE @"+testModule+".SecurityLogNode") {
+		t.Fatalf("Expected constant node expression in output, got:\n%s", output)
+	}
+
+	if err := env.executeMDL(output); err != nil {
+		t.Fatalf("Describe output should execute without syntax errors: %v\n%s", err, output)
+	}
+}
+
 // --- DESCRIBE MICROFLOW Roundtrip Tests ---
 // These tests verify that DESCRIBE MICROFLOW produces correct output for various
 // microflow patterns. They serve as regression guards for bugs in findBranchFlows

mdl/executor/validate_microflow.go

@@ -400,6 +400,7 @@ func referencedVars(stmt ast.MicroflowStatement) []string {
 	case *ast.RemoveFromListStmt:
 		refs = append(refs, s.Item, s.List)
 	case *ast.LogStmt:
+		refs = append(refs, exprVarRefs(s.Node)...)
 		refs = append(refs, exprVarRefs(s.Message)...)
 	}
 	return refs

mdl/grammar/MDLParser.g4

@@ -1400,7 +1400,7 @@ raiseErrorStatement
 
 // LOG INFO NODE 'TEST' 'Message'; or LOG INFO 'Message'; or LOG WARNING 'Message' WITH ({1} = $var);
 logStatement
-    : LOG logLevel? (NODE STRING_LITERAL)? expression logTemplateParams?
+    : LOG logLevel? (NODE expression)? expression logTemplateParams?
     ;
 
 logLevel