`enter_XXX` for alternative labels are not invoked

[3c1u]

enter_XXX for alternative labels are not invoked, while enter_every_rule and enter_XXX for rules are called.

Given the grammar:

grammar Test;

prog
    : ident EOF
    ;

ident
    : 'tohka'   # Tohka
    ;

and the input tohka, the following program

#![feature(try_blocks)]
#![feature(exclusive_range_pattern)]

#[macro_use]
extern crate lazy_static;

#[allow(warnings)]
pub mod testlexer;
#[allow(warnings)]
pub mod testlistener;
#[allow(warnings)]
pub mod testparser;

use testlexer::*;
use testlistener::*;
use testparser::*;

use antlr_rust::common_token_stream::CommonTokenStream;
use antlr_rust::input_stream::InputStream;
use antlr_rust::tree::ParseTreeListener;

struct Listener;

impl ParseTreeListener for Listener {}

impl TestListener for Listener {
    fn enter_prog(&mut self, _ctx: &ProgContext) {
        println!("enter prog");
    }

    fn exit_prog(&mut self, _ctx: &ProgContext) {
        println!("exit prog");
    }

    fn enter_Tohka(&mut self, _ctx: &TohkaContext) {
        println!("enter Tohka");
    }

    fn exit_Tohka(&mut self, _ctx: &TohkaContext) {
        println!("exit Tohka");
    }
}

fn main() {
    let lexer = TestLexer::new(Box::new(InputStream::new("tohka".into())));
    let token_source = CommonTokenStream::new(lexer);
    let mut parser = TestParser::new(Box::new(token_source));
    let listener = Listener;

    let id = parser.add_parse_listener(Box::new(listener));
    parser.prog().expect("failed to parse");

    let _ = parser.remove_parse_listener(id);
}

prints

enter prog
exit Tohka
exit prog

which should be like the following:

enter prog
enter Tohka
exit Tohka
exit prog