fix: unify identifier rules to use full keyword list, add regression tests

Replace commonNameKeyword with keyword in all identifier rules
(attributeName, enumValueName, indexColumnName, imageName, parameterName,
selectAlias) so any lexer token can be used as an identifier. Remove the
now-redundant commonNameKeyword rule.

Add keyword-as-identifier.mdl regression test covering enum values,
entity names, and attribute names that match lexer keywords.
Add keyword_coverage_test.go to verify lexer/keyword sync.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: engalar

mdl-examples/doctype-tests/keyword-as-identifier.mdl

@@ -0,0 +1,117 @@
+-- ============================================================================
+-- Keyword-as-Identifier Regression Tests
+-- ============================================================================
+--
+-- Verifies that lexer keyword tokens can be used as identifiers (entity names,
+-- attribute names, enum values) via the parser's `keyword` rule.
+--
+-- Regression test for PR #186 (168 missing tokens) and PR #174 (OPEN fix).
+-- See: https://github.com/mendixlabs/mxcli/pull/186
+--
+-- Usage:
+--   mxcli check mdl-examples/doctype-tests/keyword-as-identifier.mdl
+--
+-- ============================================================================
+
+CREATE MODULE KeywordTest;
+
+-- MARK: Enum values that are lexer keywords
+
+CREATE ENUMERATION KeywordTest.IssueStatus (
+  Open,
+  Closed,
+  Data,
+  Filter,
+  Match,
+  Empty,
+  Container,
+  Node
+);
+
+CREATE ENUMERATION KeywordTest.HttpMethod (
+  Get,
+  Post,
+  Put,
+  Delete,
+  Patch
+);
+
+CREATE ENUMERATION KeywordTest.ActivityKind (
+  Activity,
+  Condition,
+  Loop,
+  Start,
+  End,
+  Split,
+  Join,
+  Merge
+);
+
+CREATE ENUMERATION KeywordTest.LayoutKind (
+  Layout,
+  Header,
+  Footer,
+  Body,
+  Content,
+  Title,
+  Text,
+  Image
+);
+
+CREATE ENUMERATION KeywordTest.MiscKeywords (
+  Action,
+  Source,
+  Target,
+  Owner,
+  Type,
+  Name,
+  Value,
+  Result,
+  Object,
+  Index,
+  Input,
+  Output,
+  Sort,
+  Order,
+  Commit,
+  Close,
+  Refresh,
+  Rollback
+);
+
+-- MARK: Entity names and attributes that are keywords
+
+CREATE ENTITY KeywordTest.Data (
+  Filter     : String(200),
+  Match      : String(200),
+  Container  : String(200),
+  Source     : String(200),
+  Target     : String(200),
+  Action     : String(200),
+  Value      : String(200),
+  Status     : String(200)
+);
+
+CREATE ENTITY KeywordTest.Activity (
+  Name       : String(200),
+  Type       : String(200),
+  Result     : String(200)
+);
+
+-- MARK: Microflow using keyword-named enum values in CREATE
+
+CREATE OR REPLACE MICROFLOW KeywordTest.TestKeywordEnumValues ()
+RETURNS Nothing
+BEGIN
+  $Issue = CREATE KeywordTest.Data (
+    Filter = 'test',
+    Match  = 'test',
+    Status = 'active'
+  );
+
+  $Activity = CREATE KeywordTest.Activity (
+    Name   = 'test',
+    Type   = 'task',
+    Result = 'ok'
+  );
+END;

mdl/grammar/MDLParser.g4

@@ -575,8 +575,7 @@ attributeDefinition
 attributeName
     : IDENTIFIER
     | QUOTED_IDENTIFIER                     // Escape any reserved word ("Range", `Order`)
-    | commonNameKeyword
-    | ATTRIBUTE                             // Allow 'Attribute' as attribute name
+    | keyword
     ;
 
 attributeConstraint
@@ -680,7 +679,7 @@ indexAttribute
 indexColumnName
     : IDENTIFIER
     | QUOTED_IDENTIFIER                     // Escape any reserved word
-    | commonNameKeyword
+    | keyword
     ;
 
 createAssociationStatement
@@ -790,15 +789,12 @@ enumerationValue
     : docComment? enumValueName (CAPTION? STRING_LITERAL)?
     ;
 
-// Allow reserved keywords as enumeration value names
+// Allow reserved keywords as enumeration value names.
+// Uses the full `keyword` rule so any lexer token can appear as an enum value name.
 enumValueName
     : IDENTIFIER
     | QUOTED_IDENTIFIER                                      // Escape any reserved word
-    | commonNameKeyword
-    | SERVICE | SERVICES                                     // OData/auth keywords used as enum values
-    | GUEST | SESSION | BASIC | CLIENT | CLIENTS
-    | PUBLISH | EXPOSE | EXTERNAL | PAGING | HEADERS
-    | DISPLAY | STRUCTURE                                    // Layout/structure keywords used as enum values
+    | keyword
     ;
 
 enumerationOptions
@@ -837,7 +833,7 @@ imageCollectionItem
 imageName
     : IDENTIFIER
     | QUOTED_IDENTIFIER
-    | commonNameKeyword
+    | keyword
     ;
 
 // =============================================================================
@@ -1094,7 +1090,7 @@ microflowParameter
 parameterName
     : IDENTIFIER
     | QUOTED_IDENTIFIER                            // Escape any reserved word
-    | commonNameKeyword
+    | keyword
     ;
 
 microflowReturnType
@@ -1733,7 +1729,7 @@ memberAttributeName
     : qualifiedName
     | IDENTIFIER
     | QUOTED_IDENTIFIER                     // Escape any reserved word
-    | commonNameKeyword
+    | keyword
     ;
 
 // Legacy changeList for backwards compatibility
@@ -3081,7 +3077,7 @@ selectItem
 // Allow keywords as aliases in SELECT
 selectAlias
     : IDENTIFIER
-    | commonNameKeyword
+    | keyword
     ;
 
 fromClause
@@ -3514,33 +3510,8 @@ annotationValue
     | qualifiedName
     ;
 
-/**
- * Keywords commonly used as attribute, parameter, enum value, and column names.
- * Excludes DDL keywords (CREATE, ALTER, DROP, ENTITY, etc.) and flow control
- * keywords (BEGIN, END, IF, RETURN, etc.) that would cause parser ambiguity
- * when used in entity/microflow body contexts.
- */
-commonNameKeyword
-    : STATUS | TYPE | VALUE | INDEX                          // Common data keywords
-    | USERNAME | PASSWORD                                    // User-related keywords
-    | COUNT | SUM | AVG | MIN | MAX                          // Aggregate function names
-    | ACTION | MESSAGE                                       // Common entity attribute names
-    | OWNER | REFERENCE | CASCADE                            // Association keywords
-    | SUCCESS | ERROR | WARNING | INFO | DEBUG | CRITICAL    // Log/status keywords
-    | DESCRIPTION | ROLE | LEVEL | ACCESS | USER             // Security keywords
-    | CAPTION | CONTENT | LABEL | TITLE | TEXT               // Display/UI keywords
-    | FORMAT | RANGE | SOURCE_KW | CHECK                     // Validation/data keywords
-    | FOLDER | NAVIGATION | HOME | VERSION | PRODUCTION      // Structure/config keywords
-    | SELECTION | EDITABLE | VISIBLE | DATASOURCE            // Widget property keywords
-    | TABLETWIDTH | PHONEWIDTH                               // Responsive width keywords
-    | WIDTH | HEIGHT | STYLE | CLASS                         // Styling keywords
-    | BOTH | SINGLE | MULTIPLE | NONE                        // Cardinality keywords
-    | PROTOTYPE | OFF                                        // Security level keywords
-    | STORAGE | TABLE                                         // Association storage keywords
-    | URL | POSITION | SORT                                    // Common attribute names
-    ;
-
-/** Keywords that can be used as identifiers in certain contexts (module/entity names via qualifiedName).
+/** Keywords that can be used as identifiers in certain contexts (module/entity names via qualifiedName,
+ *  attribute names, enum values, parameter names, etc.).
  *  Every word-type lexer token must appear here so that user-defined names (entity, attribute,
  *  enum value, module) that happen to match a keyword can still be parsed.
  *  Maintain alphabetical order within each group for easy auditing.

mdl/grammar/keyword_coverage_test.go

@@ -0,0 +1,134 @@
+package grammar
+
+import (
+	"bufio"
+	"os"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+// TestKeywordRuleCoverage verifies that every lexer token (except structural
+// ones like operators, punctuation, literals, and identifiers) is listed in
+// the parser's `keyword` rule. This catches the common mistake of adding a
+// new token to MDLLexer.g4 but forgetting to add it to the keyword rule,
+// which would prevent it from being used as an identifier.
+func TestKeywordRuleCoverage(t *testing.T) {
+	allTokens := parseLexerTokens(t, "parser/MDLLexer.tokens")
+	keywordTokens := parseKeywordRule(t, "MDLParser.g4")
+
+	// Structural tokens that should NOT be in the keyword rule.
+	excluded := map[string]bool{
+		// Whitespace & comments
+		"WS": true, "DOC_COMMENT": true, "BLOCK_COMMENT": true, "LINE_COMMENT": true,
+		// Identifiers & variables
+		"IDENTIFIER": true, "HYPHENATED_ID": true, "QUOTED_IDENTIFIER": true, "VARIABLE": true,
+		// Literals
+		"STRING_LITERAL": true, "DOLLAR_STRING": true, "NUMBER_LITERAL": true, "MENDIX_TOKEN": true,
+		// Punctuation
+		"SEMICOLON": true, "COMMA": true, "DOT": true,
+		"LPAREN": true, "RPAREN": true,
+		"LBRACE": true, "RBRACE": true,
+		"LBRACKET": true, "RBRACKET": true,
+		"COLON": true, "AT": true, "PIPE": true,
+		"DOUBLE_COLON": true, "ARROW": true, "QUESTION": true, "HASH": true,
+		// Operators
+		"NOT_EQUALS": true, "LESS_THAN_OR_EQUAL": true, "GREATER_THAN_OR_EQUAL": true,
+		"EQUALS": true, "LESS_THAN": true, "GREATER_THAN": true,
+		"PLUS": true, "MINUS": true, "STAR": true, "SLASH": true, "PERCENT": true,
+		// Version marker (not an identifier)
+		"V3": true,
+	}
+
+	// Tokens missing from keyword rule (in lexer but not in keyword).
+	var missing []string
+	for _, tok := range allTokens {
+		if excluded[tok] {
+			continue
+		}
+		if !keywordTokens[tok] {
+			missing = append(missing, tok)
+		}
+	}
+
+	// Tokens in keyword rule but not in lexer (typos or stale entries).
+	var extra []string
+	allSet := make(map[string]bool, len(allTokens))
+	for _, tok := range allTokens {
+		allSet[tok] = true
+	}
+	for tok := range keywordTokens {
+		if !allSet[tok] {
+			extra = append(extra, tok)
+		}
+	}
+
+	if len(missing) > 0 {
+		t.Errorf("tokens in lexer but missing from keyword rule (%d):\n  %s\n"+
+			"Add them to the keyword rule in MDLParser.g4 or to the excluded set in this test.",
+			len(missing), strings.Join(missing, ", "))
+	}
+	if len(extra) > 0 {
+		t.Errorf("tokens in keyword rule but not in lexer (%d):\n  %s",
+			len(extra), strings.Join(extra, ", "))
+	}
+}
+
+// parseLexerTokens reads MDLLexer.tokens and returns all symbolic token names
+// (skipping literal aliases like '<='=515).
+func parseLexerTokens(t *testing.T, path string) []string {
+	t.Helper()
+	f, err := os.Open(path)
+	if err != nil {
+		t.Fatalf("open %s: %v", path, err)
+	}
+	defer f.Close()
+
+	var tokens []string
+	scanner := bufio.NewScanner(f)
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+		if line == "" || strings.HasPrefix(line, "'") {
+			continue
+		}
+		if idx := strings.IndexByte(line, '='); idx > 0 {
+			tokens = append(tokens, line[:idx])
+		}
+	}
+	if err := scanner.Err(); err != nil {
+		t.Fatalf("scan %s: %v", path, err)
+	}
+	return tokens
+}
+
+// parseKeywordRule reads MDLParser.g4, extracts the `keyword` rule body, and
+// returns the set of token names referenced in it.
+func parseKeywordRule(t *testing.T, path string) map[string]bool {
+	t.Helper()
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatalf("read %s: %v", path, err)
+	}
+	text := string(data)
+
+	// Find the keyword rule: starts with "keyword" at the beginning of a line,
+	// ends with ";".
+	re := regexp.MustCompile(`(?m)^keyword\b([\s\S]*?);`)
+	m := re.FindStringSubmatch(text)
+	if m == nil {
+		t.Fatal("keyword rule not found in MDLParser.g4")
+	}
+
+	// Strip single-line comments (// ...) to avoid matching words in comments.
+	body := regexp.MustCompile(`//[^\n]*`).ReplaceAllString(m[1], "")
+
+	// Extract all UPPERCASE token references (e.g., ADD, ALTER, STRING_TYPE).
+	tokenRe := regexp.MustCompile(`\b([A-Z][A-Z0-9_]*)\b`)
+	matches := tokenRe.FindAllStringSubmatch(body, -1)
+
+	result := make(map[string]bool, len(matches))
+	for _, match := range matches {
+		result[match[1]] = true
+	}
+	return result
+}