| //===--- SourceLocationUtilities.cpp - Source location helper functions ---===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "SourceLocationUtilities.h" |
| #include "clang/AST/Stmt.h" |
| #include "clang/Lex/Lexer.h" |
| #include <limits> |
| |
| namespace clang { |
| namespace tooling { |
| |
| SourceLocation findLastLocationOfSourceConstruct(SourceLocation HeaderEnd, |
| const Stmt *Body, |
| const SourceManager &SM) { |
| SourceLocation BodyStart = SM.getSpellingLoc(Body->getLocStart()); |
| unsigned BodyLine = SM.getSpellingLineNumber(BodyStart); |
| unsigned HeaderLine = SM.getSpellingLineNumber(HeaderEnd); |
| |
| if (BodyLine > HeaderLine) { |
| // The Last location on the previous line if the body is not on the same |
| // line as the last known location. |
| SourceLocation LineLocThatPrecedesBody = |
| SM.translateLineCol(SM.getFileID(BodyStart), BodyLine - 1, |
| std::numeric_limits<unsigned>::max()); |
| if (LineLocThatPrecedesBody.isValid()) |
| return LineLocThatPrecedesBody; |
| } |
| // We want to include the location of the '{'. |
| return isa<CompoundStmt>(Body) ? BodyStart : BodyStart.getLocWithOffset(-1); |
| } |
| |
| SourceLocation findFirstLocationOfSourceConstruct(SourceLocation HeaderStart, |
| const Stmt *PreviousBody, |
| const SourceManager &SM) { |
| if (!isa<CompoundStmt>(PreviousBody)) |
| return HeaderStart; |
| SourceLocation BodyEnd = SM.getSpellingLoc(PreviousBody->getLocEnd()); |
| unsigned BodyLine = SM.getSpellingLineNumber(BodyEnd); |
| unsigned HeaderLine = SM.getSpellingLineNumber(HeaderStart); |
| if (BodyLine >= HeaderLine) |
| return BodyEnd; |
| return HeaderStart; |
| } |
| |
| bool isLocationInAnyRange(SourceLocation Location, ArrayRef<SourceRange> Ranges, |
| const SourceManager &SM) { |
| for (const SourceRange &Range : Ranges) { |
| if (!isPointWithin(Location, Range.getBegin(), Range.getEnd(), SM)) |
| continue; |
| return true; |
| } |
| return false; |
| } |
| |
| SourceLocation getPreciseTokenLocEnd(SourceLocation Loc, |
| const SourceManager &SM, |
| const LangOptions &LangOpts) { |
| return Lexer::getLocForEndOfToken(Loc, 0, SM, LangOpts); |
| } |
| |
| SourceLocation findClosingParenLocEnd(SourceLocation LastKnownLoc, |
| const SourceManager &SM, |
| const LangOptions &LangOpts) { |
| return Lexer::findLocationAfterToken( |
| LastKnownLoc, tok::r_paren, SM, LangOpts, |
| /*SkipTrailingWhitespaceAndNewLine=*/false); |
| } |
| |
| SourceRange getRangeOfNextToken(SourceLocation Loc, tok::TokenKind Kind, |
| const SourceManager &SM, |
| const LangOptions &LangOpts) { |
| SourceLocation NextLoc = |
| Lexer::findLocationAfterToken(Loc, Kind, SM, LangOpts, |
| /*SkipTrailingWhitespaceAndNewLine=*/false); |
| if (NextLoc.isInvalid()) |
| return SourceRange(); |
| return SourceRange( |
| Lexer::GetBeginningOfToken(NextLoc.getLocWithOffset(-1), SM, LangOpts), |
| NextLoc); |
| } |
| |
| SourceLocation findLastNonCompoundLocation(const Stmt *S) { |
| const auto *CS = dyn_cast<CompoundStmt>(S); |
| if (!CS) |
| return S->getLocEnd(); |
| return CS->body_back() ? CS->body_back()->getLocEnd() : SourceLocation(); |
| } |
| |
| bool areOnSameLine(SourceLocation Loc1, SourceLocation Loc2, |
| const SourceManager &SM) { |
| return !Loc1.isMacroID() && !Loc2.isMacroID() && |
| SM.getSpellingLineNumber(Loc1) == SM.getSpellingLineNumber(Loc2); |
| } |
| |
| SourceLocation |
| getLastLineLocationUnlessItHasOtherTokens(SourceLocation SpellingLoc, |
| const SourceManager &SM, |
| const LangOptions &LangOpts) { |
| assert(!SpellingLoc.isMacroID() && "Expecting a spelling location"); |
| SourceLocation NextTokenLoc = |
| Lexer::findNextTokenLocationAfterTokenAt(SpellingLoc, SM, LangOpts); |
| if (NextTokenLoc.isValid()) { |
| bool IsSameLine = areOnSameLine(SpellingLoc, NextTokenLoc, SM); |
| if (IsSameLine) { |
| // Could be a ';' on the same line, so try looking after the ';' |
| if (isSemicolonAtLocation(NextTokenLoc, SM, LangOpts)) |
| return getLastLineLocationUnlessItHasOtherTokens(NextTokenLoc, SM, |
| LangOpts); |
| } else { |
| SourceLocation LastLoc = SM.translateLineCol( |
| SM.getFileID(SpellingLoc), SM.getSpellingLineNumber(SpellingLoc), |
| std::numeric_limits<unsigned>::max()); |
| if (LastLoc.isValid()) |
| return LastLoc; |
| } |
| } |
| return getPreciseTokenLocEnd(SpellingLoc, SM, LangOpts); |
| } |
| |
| bool isSemicolonAtLocation(SourceLocation TokenLoc, const SourceManager &SM, |
| const LangOptions &LangOpts) { |
| return Lexer::getSourceText( |
| CharSourceRange::getTokenRange(TokenLoc, TokenLoc), SM, |
| LangOpts) == ";"; |
| } |
| |
| SourceRange trimSelectionRange(SourceRange Range, const SourceManager &SM, |
| const LangOptions &LangOpts) { |
| bool IsInvalid = false; |
| StringRef Text = Lexer::getSourceText(CharSourceRange::getCharRange(Range), |
| SM, LangOpts, &IsInvalid); |
| if (IsInvalid || Text.empty()) |
| return Range; |
| assert(Range.getBegin().isFileID() && "Not a file range!"); |
| |
| std::string Source = Text.str(); |
| Lexer Lex(Range.getBegin(), LangOpts, Source.c_str(), Source.c_str(), |
| Source.c_str() + Source.size()); |
| // Get comment tokens as well. |
| Lex.SetCommentRetentionState(true); |
| SourceLocation StartLoc, EndLoc; |
| while (true) { |
| Token Tok; |
| Lex.LexFromRawLexer(Tok); |
| if (Tok.getKind() == tok::eof) |
| break; |
| if (StartLoc.isInvalid()) |
| StartLoc = Tok.getLocation(); |
| if (Tok.getKind() != tok::semi) |
| EndLoc = Tok.getEndLoc(); |
| } |
| return StartLoc.isValid() && EndLoc.isValid() ? SourceRange(StartLoc, EndLoc) |
| : SourceRange(); |
| } |
| |
| /// Tokenize the given file and check if it contains a comment that ends at the |
| /// given location. |
| static SourceLocation findCommentThatEndsAt(FileID FID, |
| SourceLocation StartOfFile, |
| const SourceManager &SM, |
| const LangOptions &LangOpts, |
| SourceLocation ExpectedEndLoc) { |
| // Try to load the file buffer. |
| bool InvalidTemp = false; |
| StringRef File = SM.getBufferData(FID, &InvalidTemp); |
| if (InvalidTemp) |
| return SourceLocation(); |
| |
| // Search for the comment that ends at the given location. |
| Lexer Lex(StartOfFile, LangOpts, File.begin(), File.begin(), File.end()); |
| Lex.SetCommentRetentionState(true); |
| Token Tok; |
| while (!Lex.LexFromRawLexer(Tok)) { |
| if (Tok.is(tok::comment) && Tok.getEndLoc() == ExpectedEndLoc) |
| return Tok.getLocation(); |
| } |
| // Find the token. |
| return SourceLocation(); |
| } |
| |
| SourceLocation getLocationOfPrecedingComment(SourceLocation Location, |
| const SourceManager &SM, |
| const LangOptions &LangOpts) { |
| SourceLocation PrevResult = Location; |
| SourceLocation Result = Location; |
| if (Result.isMacroID()) |
| Result = SM.getExpansionLoc(Result); |
| FileID FID = SM.getFileID(Result); |
| SourceLocation StartOfFile = SM.getLocForStartOfFile(FID); |
| Token Tok; |
| Tok.setKind(tok::unknown); |
| SourceLocation TokenLoc = Result; |
| auto GetPreviousToken = [&]() -> bool { |
| TokenLoc = |
| Lexer::GetBeginningOfToken(TokenLoc.getLocWithOffset(-1), SM, LangOpts); |
| return !Lexer::getRawToken(TokenLoc, Tok, SM, LangOpts); |
| }; |
| // Look for a comment token. |
| while (TokenLoc != StartOfFile) { |
| bool LocHasToken = GetPreviousToken(); |
| if (LocHasToken && Tok.is(tok::slash)) { |
| // Check if this the end of a multiline '/*' comment before returning. |
| SourceLocation CommentLoc = findCommentThatEndsAt( |
| FID, StartOfFile, SM, LangOpts, Tok.getEndLoc()); |
| return CommentLoc.isInvalid() ? Result : CommentLoc; |
| } |
| if (LocHasToken && Tok.isNot(tok::comment)) |
| break; |
| if (!LocHasToken) |
| continue; |
| // We found a preceding comment. Check if there are other preceding |
| // comments. |
| PrevResult = Result; |
| Result = Tok.getLocation(); |
| while (TokenLoc != StartOfFile) { |
| bool LocHasToken = GetPreviousToken(); |
| if (LocHasToken && Tok.isNot(tok::comment)) { |
| // Reset the result to the previous location if this comment trails |
| // another token on the same line. |
| if (SM.getSpellingLineNumber(Tok.getEndLoc()) == |
| SM.getSpellingLineNumber(Result)) |
| Result = PrevResult; |
| break; |
| } |
| if (!LocHasToken) |
| continue; |
| // The location of this comment is accepted only when the next comment |
| // is located immediately after this comment. |
| if (SM.getSpellingLineNumber(Tok.getEndLoc()) != |
| SM.getSpellingLineNumber(Result) - 1) |
| break; |
| PrevResult = Result; |
| Result = Tok.getLocation(); |
| } |
| break; |
| } |
| return Result; |
| } |
| |
| SourceLocation getLocationOfPrecedingToken(SourceLocation Loc, |
| const SourceManager &SM, |
| const LangOptions &LangOpts) { |
| SourceLocation Result = Loc; |
| if (Result.isMacroID()) |
| Result = SM.getExpansionLoc(Result); |
| FileID FID = SM.getFileID(Result); |
| SourceLocation StartOfFile = SM.getLocForStartOfFile(FID); |
| if (Loc == StartOfFile) |
| return SourceLocation(); |
| return Lexer::GetBeginningOfToken(Result.getLocWithOffset(-1), SM, LangOpts); |
| } |
| |
| } // end namespace tooling |
| } // end namespace clang |
