title: C# ANTLR parser does not implement inherited abstract member TokenNames.get
body: <p>I'm trying to use an ANTLR 4.5.3 parser in C# on Mono (running from Xamarin Studio 6.1.2 on macOS 10.11.3), but the code generated by the <code>antlr4</code> Java command-line tool has one error which prevents compilation.</p>
  
  <p>My grammar is as follows:</p>
  
  <pre><code>grammar Hello;
  
  HELLO: 'hello';
  WORD: [a-z]+;
  
  greeting: HELLO WORD;
  
  WS: [ \n\t\r]+ -&gt; skip;
  </code></pre>
  
  <p>When the grammar is passed through <code>antlr4</code> there are no errors or warnings, but in Xamarin Studio compilation of the resulting <code>HelloParser</code> class fails with: </p>
  
  <blockquote>
    <p>Error CS0534: <code>HelloParser</code> does not implement inherited abstract member <code>Antlr4.Runtime.Recognizer&lt;Antlr4.Runtime.IToken,Antlr4.Runtime.Atn.ParserATNSimulator&gt;.TokenNames.get</code> (CS0534)</p>
  </blockquote>
  
  <p>I've got the corresponding ANTLR 4.5.3 NuGet package, and there are no other errors. The rest of the resulting parser class appears to be OK. (A <code>GreetingContext</code> class and a <code>HelloParser.greeting</code> method are generated.)</p>
  
  <p><strong>Why is ANTLR not generating this method, and how can I fix this error?</strong></p>
  
  <p>If needed, here is the entire of the <code>HelloParser.cs</code> file:</p>
  
  <pre><code>//------------------------------------------------------------------------------
  // &lt;auto-generated&gt;
  //     This code was generated by a tool.
  //     ANTLR Version: 4.5.3
  //
  //     Changes to this file may cause incorrect behavior and will be lost if
  //     the code is regenerated.
  // &lt;/auto-generated&gt;
  //------------------------------------------------------------------------------
  
  // Generated from Hello.g4 by ANTLR 4.5.3
  
  // Unreachable code detected
  #pragma warning disable 0162
  // The variable '...' is assigned but its value is never used
  #pragma warning disable 0219
  // Missing XML comment for publicly visible type or member '...'
  #pragma warning disable 1591
  // Ambiguous reference in cref attribute
  #pragma warning disable 419
  
  using System;
  using System.Text;
  using System.Diagnostics;
  using System.Collections.Generic;
  using Antlr4.Runtime;
  using Antlr4.Runtime.Atn;
  using Antlr4.Runtime.Misc;
  using Antlr4.Runtime.Tree;
  using DFA = Antlr4.Runtime.Dfa.DFA;
  
  [System.CodeDom.Compiler.GeneratedCode("ANTLR", "4.5.3")]
  [System.CLSCompliant(false)]
  public partial class HelloParser : Parser {
      public const int
          HELLO=1, WORD=2, WS=3;
      public const int
          RULE_greeting = 0;
      public static readonly string[] ruleNames = {
          "greeting"
      };
  
      private static readonly string[] _LiteralNames = {
          null, "'hello'"
      };
      private static readonly string[] _SymbolicNames = {
          null, "HELLO", "WORD", "WS"
      };
      public static readonly IVocabulary DefaultVocabulary = new Vocabulary(_LiteralNames, _SymbolicNames);
  
      [NotNull]
      public override IVocabulary Vocabulary
      {
          get
          {
              return DefaultVocabulary;
          }
      }
  
      public override string GrammarFileName { get { return "Hello.g4"; } }
  
      public override string[] RuleNames { get { return ruleNames; } }
  
      public override string SerializedAtn { get { return _serializedATN; } }
  
      public HelloParser(ITokenStream input)
          : base(input)
      {
          Interpreter = new ParserATNSimulator(this,_ATN);
      }
      public partial class GreetingContext : ParserRuleContext {
          public ITerminalNode HELLO() { return GetToken(HelloParser.HELLO, 0); }
          public ITerminalNode WORD() { return GetToken(HelloParser.WORD, 0); }
          public GreetingContext(ParserRuleContext parent, int invokingState)
              : base(parent, invokingState)
          {
          }
          public override int RuleIndex { get { return RULE_greeting; } }
          public override void EnterRule(IParseTreeListener listener) {
              IHelloListener typedListener = listener as IHelloListener;
              if (typedListener != null) typedListener.EnterGreeting(this);
          }
          public override void ExitRule(IParseTreeListener listener) {
              IHelloListener typedListener = listener as IHelloListener;
              if (typedListener != null) typedListener.ExitGreeting(this);
          }
      }
  
      [RuleVersion(0)]
      public GreetingContext greeting() {
          GreetingContext _localctx = new GreetingContext(Context, State);
          EnterRule(_localctx, 0, RULE_greeting);
          try {
              EnterOuterAlt(_localctx, 1);
              {
              State = 2; Match(HELLO);
              State = 3; Match(WORD);
              }
          }
          catch (RecognitionException re) {
              _localctx.exception = re;
              ErrorHandler.ReportError(this, re);
              ErrorHandler.Recover(this, re);
          }
          finally {
              ExitRule();
          }
          return _localctx;
      }
  
      private static string _serializedATN = _serializeATN();
      private static string _serializeATN()
      {
          StringBuilder sb = new StringBuilder();
          sb.Append("\x3\x430\xD6D1\x8206\xAD2D\x4417\xAEF1\x8D80\xAADD\x3\x5");
          sb.Append("\b\x4\x2\t\x2\x3\x2\x3\x2\x3\x2\x3\x2\x2\x2\x3\x2\x2\x2\x6\x2");
          sb.Append("\x4\x3\x2\x2\x2\x4\x5\a\x3\x2\x2\x5\x6\a\x4\x2\x2\x6\x3\x3\x2");
          sb.Append("\x2\x2\x2");
          return sb.ToString();
      }
  
      public static readonly ATN _ATN =
          new ATNDeserializer().Deserialize(_serializedATN.ToCharArray());
  }
  </code></pre>
  
  <p>Comment if you need any of the other generated files in case the error isn't reproducible with your own ANTLR.</p>