@Nullable
public static DataIndexer<TodoIndexEntry, Integer, FileContent> getTodoIndexer(
FileType fileType, final VirtualFile virtualFile) {
final DataIndexer<TodoIndexEntry, Integer, FileContent> extIndexer;
if (fileType instanceof SubstitutedFileType
&& !((SubstitutedFileType) fileType).isSameFileType()) {
SubstitutedFileType sft = (SubstitutedFileType) fileType;
extIndexer =
new CompositeTodoIndexer(
getTodoIndexer(sft.getOriginalFileType(), virtualFile),
getTodoIndexer(sft.getFileType(), virtualFile));
} else {
extIndexer = TodoIndexers.INSTANCE.forFileType(fileType);
}
if (extIndexer != null) {
return extIndexer;
}
if (fileType instanceof LanguageFileType) {
final Language lang = ((LanguageFileType) fileType).getLanguage();
final ParserDefinition parserDef = LanguageParserDefinitions.INSTANCE.forLanguage(lang);
final TokenSet commentTokens = parserDef != null ? parserDef.getCommentTokens() : null;
if (commentTokens != null) {
return new TokenSetTodoIndexer(commentTokens, virtualFile);
}
}
if (fileType instanceof CustomSyntaxTableFileType) {
return new TokenSetTodoIndexer(ABSTRACT_FILE_COMMENT_TOKENS, virtualFile);
}
return null;
}
/**
* Tries to calculate given line's indent column assuming that there might be a comment at the
* given indent offset (see {@link #getCommentPrefix(IElementType)}).
*
* @param line target line
* @param indentOffset start indent offset to use for the given line
* @param lineEndOffset given line's end offset
* @param fallbackColumn column to return if it's not possible to apply comment-specific indent
* calculation rules
* @return given line's indent column to use
*/
private int calcIndent(int line, int indentOffset, int lineEndOffset, int fallbackColumn) {
final HighlighterIterator it = myEditor.getHighlighter().createIterator(indentOffset);
IElementType tokenType = it.getTokenType();
Language language = tokenType.getLanguage();
TokenSet comments = myComments.get(language);
if (comments == null) {
ParserDefinition definition = LanguageParserDefinitions.INSTANCE.forLanguage(language);
if (definition != null) {
comments = definition.getCommentTokens();
}
if (comments == null) {
return fallbackColumn;
} else {
myComments.put(language, comments);
}
}
if (comments.contains(tokenType) && indentOffset == it.getStart()) {
String prefix = COMMENT_PREFIXES.get(tokenType);
if (prefix == null) {
prefix = getCommentPrefix(tokenType);
}
if (!NO_COMMENT_INFO_MARKER.equals(prefix)) {
final int indentInsideCommentOffset =
CharArrayUtil.shiftForward(
myChars, indentOffset + prefix.length(), lineEndOffset, " \t");
if (indentInsideCommentOffset < lineEndOffset) {
int indent = myEditor.calcColumnNumber(indentInsideCommentOffset, line);
indentAfterUncomment.put(line, indent - prefix.length());
return indent;
}
}
}
return fallbackColumn;
}
public double isBashFile(File file, String data, Project project) {
ParserDefinition definition =
LanguageParserDefinitions.INSTANCE.forLanguage(BashFileType.BASH_LANGUAGE);
Lexer lexer = definition.createLexer(project);
lexer.start(data);
int tokenCount = 0;
Set<IElementType> tokenSet = Sets.newHashSet();
Set<Integer> modeSet = Sets.newHashSet();
while (lexer.getTokenType() != BashTokenTypes.BAD_CHARACTER && lexer.getTokenType() != null) {
tokenSet.add(lexer.getTokenType());
modeSet.add(lexer.getState());
lexer.advance();
tokenCount++;
}
double score = 0;
if (lexer.getTokenType() == BashTokenTypes.BAD_CHARACTER) {
score -= badCharacterWeight;
}
if (tokenCount > 4) {
score += tokenLimitWeight;
}
score += Math.min(0.45, (double) tokenSet.size() * tokenWeight);
score += Math.min(0.45, (double) modeSet.size() * modeWeight);
return score;
}
@Nullable
protected PsiFile createFile(Language lang) {
if (lang != getBaseLanguage()) return null;
final ParserDefinition parserDefinition = LanguageParserDefinitions.INSTANCE.forLanguage(lang);
if (parserDefinition != null) {
return parserDefinition.createFile(this);
}
return null;
}
private static void initState(IElementType root, PsiBuilder builder, ErrorState state) {
PsiFile file = builder.getUserDataUnprotected(FileContextUtil.CONTAINING_FILE_KEY);
state.completionState = file == null ? null : file.getUserData(COMPLETION_STATE_KEY);
Language language = file == null ? root.getLanguage() : file.getLanguage();
state.caseSensitive = language.isCaseSensitive();
ParserDefinition parserDefinition = LanguageParserDefinitions.INSTANCE.forLanguage(language);
if (parserDefinition != null) {
state.commentTokens = parserDefinition.getCommentTokens();
state.whitespaceTokens = parserDefinition.getWhitespaceTokens();
}
PairedBraceMatcher matcher = LanguageBraceMatching.INSTANCE.forLanguage(language);
state.braces = matcher == null ? null : matcher.getPairs();
if (state.braces != null && state.braces.length == 0) state.braces = null;
}
private static boolean isLiteral(PsiElement element) {
if (element == null) return false;
final ASTNode astNode = element.getNode();
if (astNode == null) {
return false;
}
final IElementType elementType = astNode.getElementType();
final ParserDefinition parserDefinition =
LanguageParserDefinitions.INSTANCE.forLanguage(element.getLanguage());
if (parserDefinition != null) {
final TokenSet literals = parserDefinition.getStringLiteralElements();
return literals.contains(elementType);
}
return false;
}
public static boolean canHaveStub(@NotNull VirtualFile file) {
final FileType fileType = file.getFileType();
if (fileType instanceof LanguageFileType) {
Language l = ((LanguageFileType) fileType).getLanguage();
ParserDefinition parserDefinition = LanguageParserDefinitions.INSTANCE.forLanguage(l);
if (parserDefinition == null) return false;
final IFileElementType elementType = parserDefinition.getFileNodeType();
return elementType instanceof IStubFileElementType
&& (((IStubFileElementType) elementType).shouldBuildStubFor(file)
|| IndexingStamp.isFileIndexed(
file, INDEX_ID, IndexInfrastructure.getIndexCreationStamp(INDEX_ID)));
}
if (fileType.isBinary()) {
final BinaryFileStubBuilder builder = BinaryFileStubBuilders.INSTANCE.forFileType(fileType);
return builder != null && builder.acceptsFile(file);
}
return false;
}
public static boolean isCommentToken(
@NotNull IElementType tokenType, @NotNull LanguageVersion languageVersion) {
final Language language = tokenType.getLanguage();
if (language != languageVersion.getLanguage()) {
return false;
}
boolean inComments = false;
final ParserDefinition parserDefinition =
LanguageParserDefinitions.INSTANCE.forLanguage(language);
if (parserDefinition != null) {
final TokenSet commentTokens = parserDefinition.getCommentTokens(languageVersion);
if (commentTokens.contains(tokenType)) {
inComments = true;
}
}
return inComments;
}
@Override
public boolean acceptInput(final VirtualFile file) {
if (!(file.getFileSystem() instanceof LocalFileSystem)) {
return false; // do not index TODOs in library sources
}
final FileType fileType = file.getFileType();
if (ProjectUtil.isProjectOrWorkspaceFile(file, fileType)) {
return false;
}
if (fileType instanceof LanguageFileType) {
final Language lang = ((LanguageFileType) fileType).getLanguage();
final ParserDefinition parserDef = LanguageParserDefinitions.INSTANCE.forLanguage(lang);
final TokenSet commentTokens = parserDef != null ? parserDef.getCommentTokens() : null;
return commentTokens != null;
}
return IdTableBuilding.isTodoIndexerRegistered(fileType)
|| fileType instanceof AbstractFileType;
}
private static int getCumulativeVersion() {
int version = VERSION;
for (final FileType fileType : FileTypeManager.getInstance().getRegisteredFileTypes()) {
if (fileType instanceof LanguageFileType) {
Language l = ((LanguageFileType) fileType).getLanguage();
ParserDefinition parserDefinition = LanguageParserDefinitions.INSTANCE.forLanguage(l);
if (parserDefinition != null) {
final IFileElementType type = parserDefinition.getFileNodeType();
if (type instanceof IStubFileElementType) {
version += ((IStubFileElementType) type).getStubVersion();
}
}
} else if (fileType.isBinary()) {
final BinaryFileStubBuilder builder = BinaryFileStubBuilders.INSTANCE.forFileType(fileType);
if (builder != null) {
version += builder.getStubVersion();
}
}
}
return version;
}
@NotNull
@Override
public PsiElement createDummyHolder(
@NotNull final String text,
@NotNull final IElementType type,
@Nullable final PsiElement context) {
final DummyHolder result = DummyHolderFactory.createHolder(myManager, context);
final FileElement holder = result.getTreeElement();
final Language language = type.getLanguage();
final ParserDefinition parserDefinition =
LanguageParserDefinitions.INSTANCE.forLanguage(language);
assert parserDefinition != null : "No parser definition for language " + language;
final Project project = myManager.getProject();
final Lexer lexer = parserDefinition.createLexer(project);
final PsiBuilder builder =
PsiBuilderFactory.getInstance().createBuilder(project, holder, lexer, language, text);
final ASTNode node = parserDefinition.createParser(project).parse(type, builder);
holder.rawAddChildren((TreeElement) node);
final PsiElement psi = node.getPsi();
assert psi != null : text;
return psi;
}
private static boolean isCommentComplete(
PsiComment comment, CodeDocumentationAwareCommenter commenter, Editor editor) {
for (CommentCompleteHandler handler :
Extensions.getExtensions(CommentCompleteHandler.EP_NAME)) {
if (handler.isApplicable(comment, commenter)) {
return handler.isCommentComplete(comment, commenter, editor);
}
}
String commentText = comment.getText();
final boolean docComment = isDocComment(comment, commenter);
final String expectedCommentEnd =
docComment ? commenter.getDocumentationCommentSuffix() : commenter.getBlockCommentSuffix();
if (!commentText.endsWith(expectedCommentEnd)) return false;
final PsiFile containingFile = comment.getContainingFile();
final Language language = containingFile.getLanguage();
ParserDefinition parserDefinition = LanguageParserDefinitions.INSTANCE.forLanguage(language);
if (parserDefinition == null) {
return true;
}
Lexer lexer = parserDefinition.createLexer(containingFile.getProject());
final String commentPrefix =
docComment ? commenter.getDocumentationCommentPrefix() : commenter.getBlockCommentPrefix();
lexer.start(
commentText, commentPrefix == null ? 0 : commentPrefix.length(), commentText.length());
QuoteHandler fileTypeHandler = TypedHandler.getQuoteHandler(containingFile, editor);
JavaLikeQuoteHandler javaLikeQuoteHandler =
fileTypeHandler instanceof JavaLikeQuoteHandler
? (JavaLikeQuoteHandler) fileTypeHandler
: null;
while (true) {
IElementType tokenType = lexer.getTokenType();
if (tokenType == null) {
return false;
}
if (javaLikeQuoteHandler != null
&& javaLikeQuoteHandler.getStringTokenTypes() != null
&& javaLikeQuoteHandler.getStringTokenTypes().contains(tokenType)) {
String text = commentText.substring(lexer.getTokenStart(), lexer.getTokenEnd());
int endOffset = comment.getTextRange().getEndOffset();
if (text.endsWith(expectedCommentEnd)
&& endOffset < containingFile.getTextLength()
&& containingFile.getText().charAt(endOffset) == '\n') {
return true;
}
}
if (tokenType == commenter.getDocumentationCommentTokenType()
|| tokenType == commenter.getBlockCommentTokenType()) {
return false;
}
if (tokenType == commenter.getLineCommentTokenType()
&& lexer.getTokenText().contains(commentPrefix)) {
return false;
}
if (lexer.getTokenEnd() == commentText.length()) {
if (tokenType == commenter.getLineCommentTokenType()) {
String prefix = commenter.getLineCommentPrefix();
lexer.start(
commentText,
lexer.getTokenStart() + (prefix == null ? 0 : prefix.length()),
commentText.length());
lexer.advance();
continue;
} else if (isInvalidPsi(comment)) {
return false;
}
return true;
}
lexer.advance();
}
}
private static boolean isStringLiteral(PsiElement element, ParserDefinition definition) {
return PlatformPatterns.psiElement()
.withElementType(definition.getStringLiteralElements())
.accepts(element);
}