How to use

Lexer

in

com.intellij.lexer

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());
    }
  }
}

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

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

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 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);
  }
}

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 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 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);
}

@Override
public void restore(@NotNull final LexerPosition position) {
  final int prefixLength = prefix.length();
  final int newOffset = position.getOffset() - prefixLength;
  if (newOffset == 0) {
    this.afterPrefix = false;
  }
  if (newOffset < myDelegate.getBufferEnd()) {
    this.delegateEOF = false;
    this.afterEOF = false;
  }
  myDelegate.restore(new LexerPosition() {
    @Override
    public int getOffset() {
      return newOffset;
    }
    @Override
    public int getState() {
      return position.getState();
    }
  });
}

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

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

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

@Override
public void advance() {
  if (afterPrefix) {
    myDelegate.advance();
  }
  afterPrefix = true;
  afterEOF |= delegateEOF;
  delegateEOF |= myDelegate.getTokenType() == null;
}

@Override
public int getTokenStart() {
  int tokenStart = myDelegate.getTokenStart();
  if (!afterPrefix && tokenStart == 0) {
    return 0;
  }
  if (afterEOF) {
    return prefix.length() + suffix.length() + tokenStart;
  }
  return prefix.length() + tokenStart;
}

@Override
public void start(@NotNull CharSequence buffer, int startOffset, int endOffset, int initialState) {
 if (initialState == 0 && myTryCatchEnabled) {
  initialState = -1;
 }
 myMainLexer.start(buffer, startOffset, endOffset, initialState);
 myTokenStart = myTokenEnd = startOffset;
 myTokenType = null;
 myIsSublexing = false;
}

@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;
}

@Override
public int getTokenEnd() {
  if (!afterPrefix) {
    return prefix.length();
  }
  int tokenEnd = myDelegate.getTokenEnd();
  if (delegateEOF) {
    return prefix.length() + suffix.length() + tokenEnd;
  }
  return prefix.length() + tokenEnd;
}