// RUN: %check_clang_tidy %s performance-faster-string-find %t
// RUN: %check_clang_tidy -check-suffix=CUSTOM %s performance-faster-string-find %t -- \
// RUN:   -config="{CheckOptions: \
// RUN:             [{key: performance-faster-string-find.StringLikeClasses, \
// RUN:               value: '::llvm::StringRef;'}]}"

namespace std {
template <typename Char>
struct basic_string {
  int find(const Char *, int = 0) const;
  int find(const Char *, int, int) const;
  int rfind(const Char *) const;
  int find_first_of(const Char *) const;
  int find_first_not_of(const Char *) const;
  int find_last_of(const Char *) const;
  int find_last_not_of(const Char *) const;
};

typedef basic_string<char> string;
typedef basic_string<wchar_t> wstring;

template <typename Char>
struct basic_string_view {
  int find(const Char *, int = 0) const;
  int find(const Char *, int, int) const;
  int rfind(const Char *) const;
  int find_first_of(const Char *) const;
  int find_first_not_of(const Char *) const;
  int find_last_of(const Char *) const;
  int find_last_not_of(const Char *) const;
};

typedef basic_string_view<char> string_view;
typedef basic_string_view<wchar_t> wstring_view;
}  // namespace std

namespace llvm {
struct StringRef {
  int find(const char *) const;
};
}  // namespace llvm

struct NotStringRef {
  int find(const char *);
};

void StringFind() {
  std::string Str;

  Str.find("a");
  // CHECK-MESSAGES: [[@LINE-1]]:12: warning: 'find' called with a string literal consisting of a single character; consider using the more effective overload accepting a character [performance-faster-string-find]
  // CHECK-FIXES: Str.find('a');

  // Works with the pos argument.
  Str.find("a", 1);
  // CHECK-MESSAGES: [[@LINE-1]]:12: warning: 'find' called with a string literal
  // CHECK-FIXES: Str.find('a', 1);

  // Doens't work with strings smaller or larger than 1 char.
  Str.find("");
  Str.find("ab");

  // Doesn't do anything with the 3 argument overload.
  Str.find("a", 1, 1);

  // Other methods that can also be replaced
  Str.rfind("a");
  // CHECK-MESSAGES: [[@LINE-1]]:13: warning: 'rfind' called with a string literal
  // CHECK-FIXES: Str.rfind('a');
  Str.find_first_of("a");
  // CHECK-MESSAGES: [[@LINE-1]]:21: warning: 'find_first_of' called with a string
  // CHECK-FIXES: Str.find_first_of('a');
  Str.find_first_not_of("a");
  // CHECK-MESSAGES: [[@LINE-1]]:25: warning: 'find_first_not_of' called with a
  // CHECK-FIXES: Str.find_first_not_of('a');
  Str.find_last_of("a");
  // CHECK-MESSAGES: [[@LINE-1]]:20: warning: 'find_last_of' called with a string
  // CHECK-FIXES: Str.find_last_of('a');
  Str.find_last_not_of("a");
  // CHECK-MESSAGES: [[@LINE-1]]:24: warning: 'find_last_not_of' called with a
  // CHECK-FIXES: Str.find_last_not_of('a');

  // std::wstring should work.
  std::wstring WStr;
  WStr.find(L"n");
  // CHECK-MESSAGES: [[@LINE-1]]:13: warning: 'find' called with a string literal
  // CHECK-FIXES: Str.find(L'n');
  // Even with unicode that fits in one wide char.
  WStr.find(L"\x3A9");
  // CHECK-MESSAGES: [[@LINE-1]]:13: warning: 'find' called with a string literal
  // CHECK-FIXES: Str.find(L'\x3A9');

  // std::string_view and std::wstring_view should work.
  std::string_view StrView;
  StrView.find("n");
  // CHECK-MESSAGES: [[@LINE-1]]:16: warning: 'find' called with a string literal
  // CHECK-FIXES: StrView.find('n');
  std::wstring_view WStrView;

  WStrView.find(L"n");
  // CHECK-MESSAGES: [[@LINE-1]]:17: warning: 'find' called with a string literal
  // CHECK-FIXES: WStrView.find(L'n');
  WStrView.find(L"\x3A9");
  // CHECK-MESSAGES: [[@LINE-1]]:17: warning: 'find' called with a string literal
  // CHECK-FIXES: WStrView.find(L'\x3A9');

  // Also with other types, but only if it was specified in the options.
  llvm::StringRef sr;
  sr.find("x");
  // CHECK-MESSAGES-CUSTOM: [[@LINE-1]]:11: warning: 'find' called with a string literal
  // CHECK-FIXES-CUSTOM: sr.find('x');
  NotStringRef nsr;
  nsr.find("x");
}


template <typename T>
int FindTemplateDependant(T value) {
  return value.find("A");
}
template <typename T>
int FindTemplateNotDependant(T pos) {
  return std::string().find("A", pos);
  // CHECK-MESSAGES: [[@LINE-1]]:29: warning: 'find' called with a string literal
  // CHECK-FIXES: return std::string().find('A', pos);
}

int FindStr() {
  return FindTemplateDependant(std::string()) + FindTemplateNotDependant(1);
}

#define STR_MACRO(str) str.find("A")
#define POS_MACRO(pos) std::string().find("A",pos)

int Macros() {
  return STR_MACRO(std::string()) + POS_MACRO(1);
  // CHECK-MESSAGES: [[@LINE-1]]:10: warning: 'find' called with a string literal
  // CHECK-MESSAGES: [[@LINE-2]]:37: warning: 'find' called with a string literal
}