How to use com.intellij.lexer

public int getBufferEnd() {
  // since {@link #getBufferSequence} uses `eexLexer`, so does this.
  return eexLexer.getBufferEnd();
}

Position(final EmbeddedElixir lexer) {
  this.eexPosition = lexer.eexLexer.getCurrentPosition();
  if (lexer.eexLexer.getTokenType() == ELIXIR) {
    this.elixirPosition = lexer.elixirLexer.getCurrentPosition();
  } else {
    this.elixirPosition = null;
  }
}

  @Override
  public IElementType merge(final IElementType type, final Lexer originalLexer) {
    IElementType mergedTokenType;
    if (type != DATA) {
      while (true) {
        IElementType originalTokenType = originalLexer.getTokenType();
        if (originalTokenType != null && originalTokenType != DATA) {
          originalLexer.advance();
        } else {
          break;
        }
      }
      mergedTokenType = EEX;
    } else {
      mergedTokenType = type;
    }
    return mergedTokenType;
  }
}

public void advance() {
  if (eexLexer.getTokenType() == ELIXIR) {
    elixirLexer.advance();
    if (elixirLexer.getTokenType() == null) {
      eexLexer.advance();
    }
  } else {
    eexLexer.advance();
    if (eexLexer.getTokenType() == ELIXIR) {
      // start automatically does equivalent of `advance` since `elixirLexer` is also a look-ahead lexer
      elixirLexer.start(getBufferSequence(), eexLexer.getTokenStart(), eexLexer.getTokenEnd());
    }
  }
}

private void restoreElixirPosition(@Nullable LexerPosition elixirPosition) {
  if (elixirPosition != null) {
    elixirLexer.start(getBufferSequence(), eexLexer.getTokenStart(), eexLexer.getTokenEnd());
    elixirLexer.restore(elixirPosition);
  }
}

 private void lexToken(Lexer lexer) {
  myTokenType = lexer.getTokenType();
  if (myTokenType == LEFT_BRACE_CODE_START) {
   myTokenType = LEFT_BRACE;
  }
  myTokenStart = lexer.getTokenStart();
  myState = lexer.getState();
  myTokenEnd = lexer.getTokenEnd();
  lexer.advance();
 }
}

@Override
public void start(@NotNull CharSequence buffer, int startOffset, int endOffset, int initialState) {
  eexLexer.start(buffer, startOffset, endOffset, initialState & 0xFFFF);
  if (eexLexer.getTokenType() == ELIXIR) {
    elixirLexer.start(buffer, startOffset, endOffset);
  } else {
    elixirLexer.start(buffer, startOffset, endOffset);
  }
}

 public GoLexer() {
  super(new FlexAdapter(new _GoLexer()), TokenSet.orSet(GoParserDefinition.COMMENTS, GoParserDefinition.WHITESPACES));
 }
}

public int getTokenStart() {
  return lexer().getTokenStart();
}

protected void start(@NotNull CharSequence charSequence) {
  lexer.start(charSequence);
}

@Contract(pure = true)
@Nullable
private static <T> T forLanguage(@NotNull Lexer eexLexer, @NotNull T forEEx, @Nullable T forElixir) {
  return forLanguage(eexLexer.getTokenType(), forEEx, forElixir);
}

public int getTokenEnd() {
  return lexer().getTokenEnd();
}

@NotNull
public CharSequence getBufferSequence() {
  // elixirLexer only has a subsequence that is `eexLexer`'s
  return eexLexer.getBufferSequence();
}

private void restoreEExPosition(@NotNull LexerPosition eexPosition) {
  eexLexer.restore(eexPosition);
}

  public int getState() {
    return position().getState();
  }
}

public int getOffset() {
  return position().getOffset();
}

public int getState() {
  return lexer().getState() | (lexerLanguageFlag() << 16);
}

  public LookAhead() {
    super(
        new MergingLexerAdapter(
            new Adapter(),
            MERGABLE_TOKEN_SET
        )
    );
  }
}

@Override
public int getBufferEnd() {
 return myMainLexer.getBufferEnd();
}

@Nullable
public IElementType getTokenType() {
  IElementType tokenType = lexer().getTokenType();
  if (tokenType != null && tokenType.getLanguage() != ElixirLanguage.INSTANCE) {
    IElementType elixirTokenType = EEX_TOKEN_TYPE_TO_ELIXIR_TOKEN_TYPE.get(tokenType);
    assert elixirTokenType != null : "EEx TokenType " + tokenType + " is not mapped to an Elixir TokenType";
    tokenType = elixirTokenType;
  }
  return tokenType;
}