DESCRIBE output emits unquoted reserved-word identifiers that fail mxcli check

[ako]

Problem

MDL treats common English words (Template, Attribute, Column, List, …) as reserved keywords. Marketplace modules (e.g. ExcelImporter) use these as parameter/element names. DESCRIBE MICROFLOW (and other DESCRIBE commands) emit those identifiers unquoted, so copy-pasting the output back into mxcli check fails.

Current behavior

• Quoted identifiers are supported by the lexer: "..." and `...` (mdl/grammar/MDLLexer.g4 QUOTED_IDENTIFIER), and identifierOrKeyword accepts them.
• But DESCRIBE output renders names directly without checking for keyword collisions, and no error message suggests quoting when a bare reserved word is used as an identifier.

Request (either is acceptable)

1. Emit DESCRIBE identifiers auto-quoted when they collide with a reserved keyword, or
2. Have mxcli check produce a targeted error that suggests quoting the offending identifier.

Related

• Reserved words can't be used as SHOW_PAGE parameter names #114 (reserved words can't be used as SHOW_PAGE parameter names) — narrower instance of the same root cause.

---

Source: customer feedback batch (2026-06). Reporter: Miwa. Reporter severity: 4/5.
Filed after codebase investigation at 297e0b0a.

[github-actions]

Issue Triage

Summary:
The issue requests that mxcli check either auto‑quote reserved‑word identifiers in DESCRIBE output or give a clear error suggesting quoting, to avoid failures when Marketplace modules use common English words as names.

Checklist for feature request

Required info	Present?	Notes
Use case – why the feature is needed, what problem it solves	✅	Described: DESCRIBE emits unquoted reserved words causing mxcli check to fail.
Proposed syntax or behavior (if applicable)	✅	Two options given: auto‑quote identifiers in DESCRIBE output, or emit a targeted error suggesting quoting.
Mendix version relevance (if version‑specific)	⚪	Not version‑specific; the problem applies generally, so no version info is required.

Conclusion:
All necessary information for a feature request is provided. Thank you for the clear and detailed report!

---

Automated triage via OpenRouter — workflow source

[github-actions]

Enhancement Implementation Guide

We are given an enhancement request about DESCRIBE output emitting unquoted reserved-word identifiers that fail mxcli check.

The problem:

• MDL treats common English words (like Template, Attribute, Column, List, etc.) as reserved keywords.
• Marketplace modules (e.g., ExcelImporter) use these as parameter/element names.
• DESCRIBE MICROFLOW (and other DESCRIBE commands) emit those identifiers unquoted, so copy-pasting the output back into mxcli check fails.

Current behavior:

• Quoted identifiers are supported by the lexer (both " and backticks) and identifierOrKeyword accepts them.
• But DESCRIBE output renders names directly without checking for keyword collisions, and no error message suggests quoting when a bare reserved word is used as an identifier.

Request (either is acceptable):

1. Emit DESCRIBE identifiers auto-quoted when they collide with a reserved keyword, OR
2. Have mxcli check produce a targeted error that suggests quoting the offending identifier.

We are to provide an implementation guide.

Let's break down the task:

1. Completeness Assessment: The issue is clear. We have a problem with DESCRIBE output not quoting reserved words, causing round-trip failure. We don't need to ask for more details.

2. Overlap Check: We should check if there's already a way to handle this. The issue says that quoted identifiers are supported, so the problem is only in the DESCRIBE output not quoting when necessary. There's no existing feature that automatically quotes in DESCRIBE.

3. Proposed MDL Syntax: We are not changing the MDL syntax per se, but we are changing the output of DESCRIBE. We have two options:
   Option 1: Auto-quote in DESCRIBE when the identifier is a reserved word.
   Option 2: Change the error message in mxcli check to suggest quoting when a reserved word is used as an identifier without quotes.

   However, note that the request says either is acceptable. We should choose the one that is more user-friendly and follows the principle of least surprise.

   Considering the design guidelines for MDL (reads as English, one way to do each thing, etc.), it is better to have DESCRIBE output that is immediately usable (i.e., auto-quoted) so that the user can copy-paste and it just works. This is also the approach taken by many SQL DESCRIBE commands (they quote identifiers when necessary).

   Therefore, we propose to implement Option 1: Emit DESCRIBE identifiers auto-quoted when they collide with a reserved keyword.

   We must note that the DESCRIBE command is used for many document types (microflows, entities, pages, etc.). We need to ensure that whenever we output an identifier (like a module name, element name, parameter name, etc.) in DESCRIBE, we check if it is a reserved word and if so, we quote it.

   Examples of DESCRIBE output that might need quoting:

   • describe microflow MyModule.Template -> should output describe microflow MyModule."Template" (or using backticks) if Template is a reserved word.
   • Similarly, for parameters in a microflow: if a parameter is named List, then in the microflow DESCRIBE we might see a variable declaration like declare $List list of ... and we need to quote List if it's a reserved word.

   However, note that the issue specifically mentions that the problem occurs with parameter/element names in marketplace modules. So we are particularly concerned with identifiers that appear in the DESCRIBE output as names (like in variable declarations, entity names, etc.).

   We must be cautious: we don't want to quote identifiers that are not reserved words because that would change the meaning (though in MDL, quoting an identifier that is not a reserved word is allowed and treated as the same identifier). But to avoid unnecessary quoting, we only quote when the identifier is a reserved word.

   We have two quoting styles in MDL: double quotes and backticks. We can choose one. Looking at the grammar, both are accepted. We can choose double quotes for consistency with SQL, or backticks. However, note that the issue says that quoted identifiers are supported by the lexer with both " and backticks.

   Let's choose double quotes for now, but note that the existing codebase might have a preference. We should check how identifiers are currently quoted in DESCRIBE (if at all). Since the issue says that DESCRIBE currently emits unquoted, we are adding quoting only for reserved words.

   We must also note that the DESCRIBE output must be valid MDL that can be parsed again. So we must quote in a way that the lexer will accept.

   The lexer rule for QUOTED_IDENTIFIER is defined in MDLLexer.g4. We can use either style.

   We'll choose double quotes because they are more common in SQL and the issue example uses double quotes in the lexer comment.

   However, note that in the MDL grammar, we have:

   QUOTED_IDENTIFIER
        :   '"' ( ESC_SEQ | ~('"' | '\\') )* '"'
        |   '`' ( ESC_SEQ | ~('`' | '\\') )* '`'
        ;
   

   So both are acceptable.

   We'll use double quotes for the auto-quoting.

   Examples:

   • Input: describe microflow ExcelImporter.ImportTemplate (if Template is a reserved word) -> Output: describe microflow ExcelImporter."ImportTemplate"
   • But note: the entire qualified name is ExcelImporter.ImportTemplate. We only need to quote the part that is a reserved word? Actually, the issue is about the identifier (the last part) being a reserved word. However, note that the module name might also be a reserved word? But the issue says "parameter/element names", so we are focusing on the element name (the part after the dot).

   However, in MDL, identifiers can be qualified (with dots) or unqualified. In DESCRIBE, we are outputting qualified names? Actually, the DESCRIBE command for a microflow would output the microflow's qualified name. But inside the microflow, we have local names (like variable names, parameter names) that are not qualified.

   We must consider:

   • When DESCRIBE outputs a qualified name (like for an entity, microflow, etc.), we should check each part? Actually, no: the qualified name is made up of identifiers separated by dots. Each identifier must be checked individually.

   Example: if we have a module named List (which is a reserved word) and an entity named Customer, then the qualified name is List.Customer. We must output "List".Customer because List is a reserved word.

   Similarly, if we have a parameter named List in a microflow, then in the variable declaration we output declare $""List"" list of ...? Actually, no: the variable name is $List and we want to output the identifier List (without the dollar) in the declaration? Let's look at the microflow DESCRIBE.

   In the microflow DESCRIBE, we see:

   create microflow MyModule.MyFlow (
       $Param1: String,
       $Param2: Integer
   )
   returns ...
   begin
       ...
   end;
   

   The parameters are shown without the dollar sign. So if a parameter is named List, we would see:

   create microflow MyModule.MyFlow (
       $List: String,
       ...
   )
   

   But note: the dollar sign is not part of the identifier in the MDL syntax for parameters? Actually, in the microflow header, we write $Param but in the DESCRIBE output, we see the dollar sign? Let me check an existing DESCRIBE output.

   Since I don't have a running example, I'll rely on the issue: the problem is that the DESCRIBE output emits the identifier unquoted. So in the example above, if List is a reserved word, then the DESCRIBE output would have $List (without quotes) and that would fail because List is a keyword.

   Therefore, we must quote the identifier part (the List in $List) when it is a reserved word.

   Similarly, in the body of the microflow, we might have:

   declare $List list of String
   

   and if List is a reserved word, then we must output declare $""List"" list of String? But note: the dollar sign is part of the variable syntax. The identifier after the dollar is what we are concerned with.

   So the rule is: whenever we output an identifier (which in MDL can be a simple identifier or a qualified identifier) in a context where it is used as a name (not as a keyword), we must check each simple identifier (the parts separated by dots) and if any part is a reserved word, we quote that part.

   However, note that in MDL, we can also have quoted identifiers in the middle of a qualified name? For example: MyModule."List". So we must be able to output a qualified name where some parts are quoted.

   We already have the infrastructure for parsing quoted identifiers. We just need to make sure that when we generate the DESCRIBE output, we quote any part that is a reserved word.

   Steps for generating an identifier in DESCRIBE:

   • Split the qualified name by dots (if it is qualified) or treat the whole string as one part if unqualified.
   • For each part, check if it is a reserved word (using the list from the lexer).
   • If it is, then output it in double quotes (or backticks). Otherwise, output it bare.
   • Then join the parts with dots.

   But note: what if the identifier is already quoted in the model? We don't want to double quote. However, the DESCRIBE output is generated from the internal representation, which does not store the quoting style. We only store the identifier string. So we are safe: we are generating the output from scratch.

   We must also note that the DESCRIBE output for some things might not be identifiers? For example, in a microflow we output constants, expressions, etc. We are only concerned with the places where we output a name (like a variable name, parameter name, entity name, etc.).

   We must audit the DESCRIBE generators (the format* functions in the executor) to see where they output identifiers and apply the quoting rule.

   However, note that the issue says that the problem occurs with DESCRIBE MICROFLOW and other DESCRIBE commands. So we must fix all DESCRIBE commands.

   Given the scope, we might consider a helper function that takes a string (an identifier part) and returns it quoted if it is a reserved word, otherwise bare.

   We can then use this helper whenever we are about to output an identifier (a simple identifier) in the DESCRIBE output.

   We must be cautious: we don't want to quote in places that are not identifiers (like in strings, or in keywords). But in the DESCRIBE output, we are generating MDL, so we know the context.

   We will implement a function in the executor (or in a utility package) that quotes an identifier if necessary.

   Let's call it quoteIdentifierIfNeeded(s string) string.

   We will need the list of reserved words. We can get it from the lexer? Or we can duplicate the list? Since the lexer grammar is the source of truth, we should avoid duplicating. However, the lexer is in ANTLR and we don't have direct access to the list from Go.

   Alternatively, we can maintain a list of reserved words in Go (maybe in mdl/lexer/ or mdl/grammar/). But note: the project already has a list of reserved words in the lexer grammar. We can extract that list and put it in a Go file? Or we can use the ANTLR-generated lexer to check? That might be heavy.

   Since the list of reserved words is fixed (and not too long), we can duplicate it in a Go file and update it when the grammar changes. We must remember to update both.

   Alternatively, we can generate the list from the grammar during code generation? But that might be overkill.

   Given the project structure, I see that there is a mdl/grammar/ directory. We can create a Go file in mdl/ that contains the list of reserved words, and we update it manually when we change the grammar? Or we can have a script that extracts the reserved words from the grammar and updates the Go file.

   However, for the sake of this task, we can duplicate the list and note that we must keep it in sync.

   We can look at the existing code: is there already a place that checks for reserved words? For example, in the visitor when we are checking if an identifier is a keyword? We see in the grammar that identifierOrKeyword is used. But we don't have a Go function that checks if a string is a keyword.

   We can create a function in mdl/visitor/ or mdl/executor/ that checks against a hardcoded list.

   Let's look at the lexer grammar to see the reserved words. We don't have the exact grammar in the context, but we know from the issue that words like Template, Attribute, Column, List are reserved.

   We can start by creating a set of these words and then expand as we find more.

   However, note that the issue says: "MDL treats common English words (Template, Attribute, Column, List, …) as reserved keywords." So we have a list.

   We can put the list in a new file, say mdl/reservedwords.go, and then use it in the executor.

   Steps for implementation:

   1. Create a helper function in mdl/ (maybe in mdl/utils.go or a new file) that returns whether a string is a reserved word and/or quotes it if necessary.

   2. In the DESCRIBE formatting functions (in mdl/executor/cmd_*_show.go files), whenever we are about to output an identifier (a simple identifier, not a qualified one), we run it through the helper.

   3. For qualified identifiers, we split by dot, process each part, and then join.

   4. We must be careful: we don't want to quote in places that are not meant to be identifiers (like in the middle of a string). But in the DESCRIBE output, we are generating MDL, so we know that we are outputting an identifier in a specific context (like after a keyword entity, or in a variable declaration).

   However, note that the DESCRIBE output might output an identifier in a place where it is not expected to be an identifier? For example, in a comment? We don't output comments in DESCRIBE. So we are safe.

   We must also note that the DESCRIBE output for some things might output a string that is not an identifier? For example, the value of a constant. We don't want to quote that. So we must only apply the helper to places that are known to be identifiers.

   Therefore, we will go through each DESCRIBE formatter and identify the places where we output an identifier (a name) and apply the quoting.

   Examples of places to fix:

   • In formatMicroflowSignature: when we output the parameter names (without the dollar) and the microflow name (which is qualified).
   • In formatVariableDeclaration: when we output the variable name (without the dollar) in a declare statement.
   • In formatEntity: when we output the entity name (qualified) and the attribute names (in the attribute list).
   • And so on.

   This is a bit of a shotgun approach, but it is necessary.

   Alternatively, we can create a function that formats an identifier (possibly qualified) and use it everywhere we output an identifier.

   Let's create a function:

   // FormatIdentifier formats an identifier (which may be qualified) for output in MDL,
   // quoting any part that is a reserved word.
   func FormatIdentifier(id string) string {
        // Split by dot
        parts := strings.Split(id, ".")
        for i, part := range parts {
            if isReservedWord(part) {
                parts[i] = strconv.Quote(part) // This would produce double quotes? But note: strconv.Quote produces double quotes and escapes inside.
                // However, we want to produce `"` + part + `"` without escaping the content? But the part might contain a double quote? 
                // In Mendix, identifiers cannot contain a double quote? They are alphanumeric and underscores? 
                // Actually, the lexer allows escaped characters in quoted identifiers, but we are generating from a clean identifier.
                // We can simply do: `"` + part + `"`
                // But note: if the part contains a double quote, we must escape it? However, Mendix identifiers do not allow double quotes.
                // So we can assume the part does not contain a double quote.
                parts[i] = `"` + part + `"`
            }
        }
        return strings.Join(parts, ".")
   }

   But wait: what if the identifier is already quoted in the model? We don't have that information. We are generating from the internal name, which is without quotes. So we are safe.

   However, note: the internal representation of a qualified name in the model does not store the quoting. We only have the string. So we are generating the output from the string.

   We must also note: the identifier might be empty? Probably not.

   We must also note: the identifier might be a keyword that is not in our list? We are maintaining the list.

   We'll create isReservedWord function that checks against a set.

   We'll put the set in a file, say mdl/reservedwords.go.

   We'll initialize it with the words we know: Template, Attribute, Column, List, and then we can add more as we encounter them.

   We can also extract the list from the lexer grammar? But for now, we'll hardcode.

   We must remember to update the list when the grammar changes.

   Alternatively, we can avoid hardcoding by parsing the lexer

---

Automated guide via OpenRouter — workflow source

[ako]

Investigation findings (empirical, built from main)

I reproduced each case with mxcli check. The headline examples no longer fail — but there's a real, narrower bug underneath, and the proposed "auto-quote DESCRIBE output" fix won't work for it.

What actually happens

Case	Result	Why
entity attr Column/Template, microflow param Template/List, describe Mod.Template	✅ passes	these go through identifierOrKeyword, whose keyword alternative is a 552-entry allowlist covering ~all keywords
attribute/association paths $obj/Column, $o/Mod.A_B/List	✅ passes	same allowlist
variable $Template, page param $Template	✅ passes	VARIABLE: '$' ID_BODY+ — the $ prefix tokenizes the whole name
widget named List/Template (container List { … })	❌ mismatched input 'List' expecting IDENTIFIER	widgetV3 : widgetTypeV3 IDENTIFIER … — strict IDENTIFIER
same widget name, quoted (container "List")	❌ also fails	strict IDENTIFIER accepts neither keywords nor QUOTED_IDENTIFIER

So the cited names (Template/Attribute/Column/List) as element/parameter names already work. The genuine gap is the ~103 strict-IDENTIFIER positions in the grammar — most impactfully widget names: a Studio Pro page can legitimately name a widget List/Column/Template, and DESCRIBE PAGE then emits non-reparseable MDL.

Why option 1 (auto-quote output) is insufficient by itself

The premise "quoted identifiers are supported, so just emit them quoted" holds for identifierOrKeyword positions — but those already work unquoted. The positions that actually break use bare IDENTIFIER and reject "List" too. The grammar must be widened first; only then does quoting help.

Note on the existing partial handling

mdl/visitor/visitor.go already detects ~44 hardcoded reserved words from the ANTLR error string and suggests renaming (Title_, MyTitle). That advice is unhelpful for marketplace-module names you can't rename, and the hardcoded list is a maintenance trap.

Recommended fix (layered)

1. Grammar: widen high-value strict-IDENTIFIER name positions (starting with widgetV3 widget names) to (IDENTIFIER | QUOTED_IDENTIFIER); unquoteIdentifier in the visitor.
2. Output: emit identifiers quoted when a name isn't a legal bare IDENTIFIER (detect by lexing the candidate — no hardcoded list).
3. Check error: suggest quoting (container "List"), not renaming.
4. Subsumes Reserved words can't be used as SHOW_PAGE parameter names #114 (same root cause). Any PR must include a DESCRIBE→parse roundtrip test for a reserved-word widget name.

Starting with the widget-name slice (grammar + visitor + output + roundtrip test).