//===--- ComparisonInTempFailureRetryCheck.cpp - clang-tidy----------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "../utils/Matchers.h"
#include "ComparisonInTempFailureRetryCheck.h"
#include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h"

using namespace clang::ast_matchers;

namespace clang {
namespace tidy {
namespace android {

ComparisonInTempFailureRetryCheck::ComparisonInTempFailureRetryCheck(
    StringRef Name, ClangTidyContext *Context)
    : ClangTidyCheck(Name, Context),
      RawRetryList(Options.get("RetryMacros", "TEMP_FAILURE_RETRY")) {
  StringRef(RawRetryList).split(RetryMacros, ",", -1, false);
}

void ComparisonInTempFailureRetryCheck::storeOptions(
    ClangTidyOptions::OptionMap &Opts) {
  Options.store(Opts, "RetryMacros", RawRetryList);
}

void ComparisonInTempFailureRetryCheck::registerMatchers(MatchFinder *Finder) {
  // Both glibc's and Bionic's TEMP_FAILURE_RETRY macros structurally look like:
  //
  // #define TEMP_FAILURE_RETRY(x) ({ \
  //    typeof(x) y; \
  //    do y = (x); \
  //    while (y == -1 && errno == EINTR); \
  //    y; \
  // })
  //
  // (glibc uses `long int` instead of `typeof(x)` for the type of y).
  //
  // It's unclear how to walk up the AST from inside the expansion of `x`, and
  // we need to not complain about things like TEMP_FAILURE_RETRY(foo(x == 1)),
  // so we just match the assignment of `y = (x)` and inspect `x` from there.
  Finder->addMatcher(
      binaryOperator(hasOperatorName("="),
                     hasRHS(ignoringParenCasts(
                         binaryOperator(isComparisonOperator()).bind("inner"))))
          .bind("outer"),
      this);
}

void ComparisonInTempFailureRetryCheck::check(
    const MatchFinder::MatchResult &Result) {
  StringRef RetryMacroName;
  const auto &Node = *Result.Nodes.getNodeAs<BinaryOperator>("outer");
  if (!Node.getBeginLoc().isMacroID())
    return;

  const SourceManager &SM = *Result.SourceManager;
  if (!SM.isMacroArgExpansion(Node.getRHS()->IgnoreParenCasts()->getBeginLoc()))
    return;

  const LangOptions &Opts = Result.Context->getLangOpts();
  SourceLocation LocStart = Node.getBeginLoc();
  while (LocStart.isMacroID()) {
    SourceLocation Invocation = SM.getImmediateMacroCallerLoc(LocStart);
    Token Tok;
    if (!Lexer::getRawToken(SM.getSpellingLoc(Invocation), Tok, SM, Opts,
                            /*IgnoreWhiteSpace=*/true)) {
      if (Tok.getKind() == tok::raw_identifier &&
          llvm::is_contained(RetryMacros, Tok.getRawIdentifier())) {
        RetryMacroName = Tok.getRawIdentifier();
        break;
      }
    }

    LocStart = Invocation;
  }
  if (RetryMacroName.empty())
    return;

  const auto &Inner = *Result.Nodes.getNodeAs<BinaryOperator>("inner");
  diag(Inner.getOperatorLoc(), "top-level comparison in %0") << RetryMacroName;

  // FIXME: FixIts would be nice, but potentially nontrivial when nested macros
  // happen, e.g. `TEMP_FAILURE_RETRY(IS_ZERO(foo()))`
}

} // namespace android
} // namespace tidy
} // namespace clang