diff --git a/monticore-generator/src/main/java/de/monticore/codegen/parser/ParserGeneratorHelper.java b/monticore-generator/src/main/java/de/monticore/codegen/parser/ParserGeneratorHelper.java
index e5eae2a8a..a5c3018bb 100644
--- a/monticore-generator/src/main/java/de/monticore/codegen/parser/ParserGeneratorHelper.java
+++ b/monticore-generator/src/main/java/de/monticore/codegen/parser/ParserGeneratorHelper.java
@@ -146,7 +146,7 @@ public String getParserPackage() {
   /**
    * @return the name for a lexsymbol that should be used in an Antlr-File
    */
-  public String getLexSymbolName(String constName) {
+  public String getOrComputeLexSymbolName(String constName) {
     Log.errorIfNull(constName);
     if (grammarInfo.getSplitRules().containsKey(constName)) {
       return grammarInfo.getSplitRules().get(constName);
@@ -155,6 +155,24 @@ public String getLexSymbolName(String constName) {
     }
   }
 
+  /**
+   * Side effect free.
+   * @return the name for a lexsymbol that was used in an Antlr-File
+   */
+  public Optional<String> getCachedLexSymbolName(String constName) {
+    Log.errorIfNull(constName);
+    if (grammarInfo.getSplitRules().containsKey(constName)) {
+      return Optional.of(grammarInfo.getSplitRules().get(constName));
+    } else {
+      // Optimally we would call Map#get directly on the LexNamer
+      // (which is only available with the next release)
+      if (grammarInfo.getLexNamer().getLexnames().contains(constName)) {
+        return Optional.of(grammarInfo.getLexNamer().getLexName(grammarSymbol, constName));
+      }
+      return Optional.empty();
+    }
+  }
+
   /**
    * @return the name for a rule replacing a keyword
    */
diff --git a/monticore-generator/src/main/java/de/monticore/codegen/parser/antlr/Grammar2Antlr.java b/monticore-generator/src/main/java/de/monticore/codegen/parser/antlr/Grammar2Antlr.java
index 8d990df69..829b0c60f 100644
--- a/monticore-generator/src/main/java/de/monticore/codegen/parser/antlr/Grammar2Antlr.java
+++ b/monticore-generator/src/main/java/de/monticore/codegen/parser/antlr/Grammar2Antlr.java
@@ -268,7 +268,7 @@ public void handle(ASTEnumProd ast) {
     int index = 0;
     for (ASTConstant c : ast.getConstantList()) {
       addToCodeSection(sep);
-      addToCodeSection("\n", "e_" + index++ + "=" + parserHelper.getLexSymbolName(c.getName()));
+      addToCodeSection("\n", "e_" + index++ + "=" + parserHelper.getOrComputeLexSymbolName(c.getName()));
 
       if (embeddedJavaCode) {
         String temp1 = "";
@@ -319,11 +319,11 @@ public void handle(ASTConstantGroup ast) {
       if (x.isPresentKeyConstant()) {
         addToCodeSection(createKeyPredicate(x.getKeyConstant().getStringList(), tmpName + label));
       } else if (!grammarInfo.isKeyword(x.getName(), grammarEntry)) {
-        addToCodeSection(tmpName + label + parserHelper.getLexSymbolName(x.getName()));
+        addToCodeSection(tmpName + label + parserHelper.getOrComputeLexSymbolName(x.getName()));
       } else if (grammarInfo.getKeywordRules().contains(x.getName())) {
         addToCodeSection(tmpName + label + parserHelper.getKeyRuleName(x.getName()));
       } else {
-        addToCodeSection(tmpName + label + parserHelper.getLexSymbolName(x.getName()));
+        addToCodeSection(tmpName + label + parserHelper.getOrComputeLexSymbolName(x.getName()));
       }
 
       del = "|\n";
@@ -464,7 +464,7 @@ public void visit(ASTTerminal ast) {
     } else if (grammarInfo.isKeyword(ast.getName(), grammarEntry) && grammarInfo.getKeywordRules().contains(ast.getName())) {
       rulename = parserHelper.getKeyRuleName(ast.getName());
     } else {
-      rulename = parserHelper.getLexSymbolName(ast.getName().intern());
+      rulename = parserHelper.getOrComputeLexSymbolName(ast.getName().intern());
     }
 
     // No actions in predicates
@@ -487,7 +487,7 @@ public void visit(ASTTerminal ast) {
         if (grammarInfo.getKeywordRules().contains(replaceString)) {
           addToCodeSection(parserHelper.getKeyRuleName(replaceString));
         } else {
-          addToCodeSection(parserHelper.getLexSymbolName(replaceString));
+          addToCodeSection(parserHelper.getOrComputeLexSymbolName(replaceString));
         }
         seperator = " | ";
       }
@@ -568,7 +568,7 @@ void handleTerminal(String labelAssignment, String tmpVarName, Map<String, Colle
       if (grammarInfo.getKeywordRules().contains(replaceString)) {
         addToCodeSection(parserHelper.getKeyRuleName(replaceString));
       } else {
-        addToCodeSection(parserHelper.getLexSymbolName(replaceString));
+        addToCodeSection(parserHelper.getOrComputeLexSymbolName(replaceString));
       }
       seperator = " | ";
     }
@@ -586,7 +586,7 @@ public void visit(ASTTokenTerminal ast) {
     if (replacedAdditionalKeywords.containsKey(ast.getName())) {
       handleTerminal(labelAssignment, tmpVarName, replacedAdditionalKeywords, ast.getName());
     } else {
-      addToCodeSection(tmpVarName + labelAssignment + parserHelper.getLexSymbolName(ast.getTokenConstant().getString()));
+      addToCodeSection(tmpVarName + labelAssignment + parserHelper.getOrComputeLexSymbolName(ast.getTokenConstant().getString()));
     }
 
     addActionToCodeSection();
@@ -1056,7 +1056,7 @@ protected void addActionForKeyword(ASTTerminal keyword, ProdSymbol rule, boolean
     addToCodeSection("(");
     String rulename = "";
     if (grammarInfo.isKeyword(keyword.getName(), grammarEntry)) {
-      rulename = parserHelper.getLexSymbolName(keyword.getName());
+      rulename = parserHelper.getOrComputeLexSymbolName(keyword.getName());
     }
 
     // No actions in predicates
diff --git a/monticore-generator/src/main/java/de/monticore/codegen/parser/antlr/Grammar2ParseVisitor.java b/monticore-generator/src/main/java/de/monticore/codegen/parser/antlr/Grammar2ParseVisitor.java
index 948f4d5c9..3da1d41fe 100644
--- a/monticore-generator/src/main/java/de/monticore/codegen/parser/antlr/Grammar2ParseVisitor.java
+++ b/monticore-generator/src/main/java/de/monticore/codegen/parser/antlr/Grammar2ParseVisitor.java
@@ -639,7 +639,7 @@ protected String getRuleName(String name) {
     } else if (grammarInfo.isKeyword(name, parserGeneratorHelper.getGrammarSymbol()) && grammarInfo.getKeywordRules().contains(name)) {
       return parserGeneratorHelper.getKeyRuleName(name);
     } else {
-      return parserGeneratorHelper.getLexSymbolName(name.intern());
+      return parserGeneratorHelper.getCachedLexSymbolName(name.intern()).orElse("##no-usagename-for-rulename");
     }
   }
 
@@ -779,13 +779,16 @@ protected String getRuleName(ASTConstant constant) {
       }
       return parserGeneratorHelper.getKeyRuleName(constant.getKeyConstant().getString(0));
     } else if (constant.isPresentTokenConstant()) {
-      return parserGeneratorHelper.getLexSymbolName(constant.getTokenConstant().getString());
+      return parserGeneratorHelper.getCachedLexSymbolName(constant.getTokenConstant().getString())
+              .orElse("##no-usagename-rulename-tc");
     } else if (!grammarInfo.isKeyword(constant.getName(), parserGeneratorHelper.getGrammarSymbol())) {
-      return parserGeneratorHelper.getLexSymbolName(constant.getName());
+      return parserGeneratorHelper.getCachedLexSymbolName(constant.getName())
+              .orElse("##no-usagename-rulename-k");
     } else if (grammarInfo.getKeywordRules().contains(constant.getName())) {
       return parserGeneratorHelper.getKeyRuleName(constant.getName());
     } else {
-      return parserGeneratorHelper.getLexSymbolName(constant.getName());
+      return parserGeneratorHelper.getCachedLexSymbolName(constant.getName())
+              .orElse("##no-usagename-rulename");
     }
   }
 
diff --git a/monticore-generator/src/main/resources/parser/Lexer.ftl b/monticore-generator/src/main/resources/parser/Lexer.ftl
index ae5fe198d..108075bd0 100644
--- a/monticore-generator/src/main/resources/parser/Lexer.ftl
+++ b/monticore-generator/src/main/resources/parser/Lexer.ftl
@@ -13,7 +13,7 @@ ${tc.includeArgs("parser.LexerMember", [antlrGenerator, parserHelper.getGrammarS
 
 // Implicit token
 <#list genHelper.getLexSymbolsWithInherited() as lexSymbol>
-  ${genHelper.getLexSymbolName(lexSymbol)} : '${lexSymbol}';
+  ${genHelper.getOrComputeLexSymbolName(lexSymbol)} : '${lexSymbol}';
 </#list>
 
 // Explicit token
diff --git a/monticore-grammar/src/main/java/de/monticore/grammar/LexNamer.java b/monticore-grammar/src/main/java/de/monticore/grammar/LexNamer.java
index 5cb5293f2..69f4c6a5d 100644
--- a/monticore-grammar/src/main/java/de/monticore/grammar/LexNamer.java
+++ b/monticore-grammar/src/main/java/de/monticore/grammar/LexNamer.java
@@ -4,6 +4,7 @@
 
 import java.util.HashMap;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
 
 import de.monticore.grammar.grammar._symboltable.MCGrammarSymbol;
@@ -119,14 +120,30 @@ public static String createSimpleGoodName(String x) {
 
   }
 
+  /**
+   * Computes a new name for the lexical production or returns the previously
+   * computed one.
+   *
+   * @deprecated Use {@link LexNamer#getComputedLexName(String)}
+   * or {@link LexNamer#getOrComputeLexName(MCGrammarSymbol, String)} instead
+   */
+  @Deprecated
+  public String getLexName(MCGrammarSymbol grammarSymbol, String sym) {
+    return this.getOrComputeLexName(grammarSymbol, sym);
+  }
+
+  public Optional<String> getComputedLexName(String sym) {
+    return Optional.ofNullable(this.usedLex.get(sym));
+  }
+
   /**
    * Returns Human-Readable, antlr conformed name for a lexsymbols nice names for common tokens
    * (change constructor to add tokenes) LEXi where i is number for unknown ones
-   * 
+   *
    * @param sym lexer symbol
    * @return Human-Readable, antlr conformed name for a lexsymbols
    */
-  public String getLexName(MCGrammarSymbol grammarSymbol, String sym) {
+  public String getOrComputeLexName(MCGrammarSymbol grammarSymbol, String sym) {
     if (usedLex.containsKey(sym)) {
       return usedLex.get(sym);
     }
@@ -139,8 +156,17 @@ public String getLexName(MCGrammarSymbol grammarSymbol, String sym) {
     Log.debug("Using lexer symbol " + goodName + " for symbol '" + sym + "'", "LexNamer");
     return goodName;
   }
-  
+
+  @Deprecated
   public String getConstantName(String sym) {
+    return this.getOrComputeConstantName(sym);
+  }
+
+  public Optional<String> getComputedConstantName(String sym) {
+    return Optional.ofNullable(this.usedConstants.get(sym));
+  }
+
+  public String getOrComputeConstantName(String sym) {
     String s = sym.intern();
     
     if (!usedConstants.containsKey(s)) {
@@ -165,8 +191,11 @@ protected String convertKeyword(String key)  {
     return key;
   }
 
-
   public Set<String> getLexnames() {
-    return usedLex.keySet();
+    return this.usedLex.keySet();
+  }
+
+  public Set<String> getUsedConstants() {
+    return this.usedConstants.keySet();
   }
 }