protected LexerATNConfig getEpsilonTarget(CharStream input,
										   LexerATNConfig config,
										   Transition t,
										   ATNConfigSet configs,
										   boolean speculative,
										   boolean treatEofAsEpsilon)
	{
		LexerATNConfig c = null;
		switch (t.getSerializationType()) {
			case Transition.RULE:
				RuleTransition ruleTransition = (RuleTransition)t;
				PredictionContext newContext =
					SingletonPredictionContext.create(config.context, ruleTransition.followState.stateNumber);
				c = new LexerATNConfig(config, t.target, newContext);
				break;

			case Transition.PRECEDENCE:
				throw new UnsupportedOperationException("Precedence predicates are not supported in lexers.");

			case Transition.PREDICATE:
				/*  Track traversing semantic predicates. If we traverse,
				 we cannot add a DFA state for this "reach" computation
				 because the DFA would not test the predicate again in the
				 future. Rather than creating collections of semantic predicates
				 like v3 and testing them on prediction, v4 will test them on the
				 fly all the time using the ATN not the DFA. This is slower but
				 semantically it's not used that often. One of the key elements to
				 this predicate mechanism is not adding DFA states that see
				 predicates immediately afterwards in the ATN. For example,

				 a : ID {p1}? | ID {p2}? ;

				 should create the start state for rule 'a' (to save start state
				 competition), but should not create target of ID state. The
				 collection of ATN states the following ID references includes
				 states reached by traversing predicates. Since this is when we
				 test them, we cannot cash the DFA state target of ID.
			 */
				PredicateTransition pt = (PredicateTransition)t;
				if ( debug ) {
					System.out.println("EVAL rule "+pt.ruleIndex+":"+pt.predIndex);
				}
				configs.hasSemanticContext = true;
				if (evaluatePredicate(input, pt.ruleIndex, pt.predIndex, speculative)) {
					c = new LexerATNConfig(config, t.target);
				}
				break;

			case Transition.ACTION:
				if (config.context == null || config.context.hasEmptyPath()) {
					// execute actions anywhere in the start rule for a token.
					//
					// TODO: if the entry rule is invoked recursively, some
					// actions may be executed during the recursive call. The
					// problem can appear when hasEmptyPath() is true but
					// isEmpty() is false. In this case, the config needs to be
					// split into two contexts - one with just the empty path
					// and another with everything but the empty path.
					// Unfortunately, the current algorithm does not allow
					// getEpsilonTarget to return two configurations, so
					// additional modifications are needed before we can support
					// the split operation.
					LexerActionExecutor lexerActionExecutor = LexerActionExecutor.append(config.getLexerActionExecutor(), atn.lexerActions[((ActionTransition)t).actionIndex]);
					c = new LexerATNConfig(config, t.target, lexerActionExecutor);
					break;
				}
				else {
					// ignore actions in referenced rules
					c = new LexerATNConfig(config, t.target);
					break;
				}

			case Transition.EPSILON:
				c = new LexerATNConfig(config, t.target);
				break;

			case Transition.ATOM:
			case Transition.RANGE:
			case Transition.SET:
				if (treatEofAsEpsilon) {
					if (t.matches(CharStream.EOF, Lexer.MIN_CHAR_VALUE, Lexer.MAX_CHAR_VALUE)) {
						c = new LexerATNConfig(config, t.target);
						break;
					}
				}

				break;
		}

		return c;
	}
Since the alternatives within any lexer decision are ordered by
preference, this method stops pursuing the closure as soon as an accept
state is reached. After the first accept state is reached by depth-first
search from {@code config}, all other (potentially reachable) states for
this rule would have a lower priority.

@return {@code true} if an accept state is reached, otherwise
{@code false}.
runtime/Java/src/org/antlr/v4/runtime/atn/LexerATNSimulator.java