clang/test/Analysis/llvm-conventions.cpp

   1 // RUN: %clang_analyze_cc1 -analyzer-checker=core,alpha.llvm.Conventions \
   2 // RUN:   -std=c++14 -verify  %s
   3
   4 #include "Inputs/system-header-simulator-cxx.h"
   5
   6 //===----------------------------------------------------------------------===//
   7 // Forward declarations for StringRef tests.
   8 //===----------------------------------------------------------------------===//
   9
  10 using size_type = size_t;
  11
  12 namespace std {
  13
  14 template <class T>
  15 struct numeric_limits { const static bool is_signed; };
  16
  17 } // end of namespace std
  18
  19 namespace llvm {
  20
  21 template <class T>
  22 struct iterator_range;
  23
  24 template <class Func>
  25 struct function_ref;
  26
  27 struct hash_code;
  28
  29 template <class T>
  30 struct SmallVectorImpl;
  31
  32 struct APInt;
  33
  34 class StringRef {
  35 public:
  36   static const size_t npos = ~size_t(0);
  37   using iterator = const char *;
  38   using const_iterator = const char *;
  39   using size_type = size_t;
  40
  41   /*implicit*/ StringRef() = default;
  42   StringRef(std::nullptr_t) = delete;
  43   /*implicit*/ StringRef(const char *Str);
  44   /*implicit*/ constexpr StringRef(const char *data, size_t length);
  45   /*implicit*/ StringRef(const std::string &Str);
  46
  47   static StringRef withNullAsEmpty(const char *data);
  48   iterator begin() const;
  49   iterator end() const;
  50   const unsigned char *bytes_begin() const;
  51   const unsigned char *bytes_end() const;
  52   iterator_range<const unsigned char *> bytes() const;
  53   const char *data() const;
  54   bool empty() const;
  55   size_t size() const;
  56   char front() const;
  57   char back() const;
  58   template <typename Allocator>
  59   StringRef copy(Allocator &A) const;
  60   bool equals(StringRef RHS) const;
  61   bool equals_lower(StringRef RHS) const;
  62   int compare(StringRef RHS) const;
  63   int compare_lower(StringRef RHS) const;
  64   int compare_numeric(StringRef RHS) const;
  65   unsigned edit_distance(StringRef Other, bool AllowReplacements = true,
  66                          unsigned MaxEditDistance = 0) const;
  67   std::string str() const;
  68   char operator[](size_t Index) const;
  69   template <typename T>
  70   typename std::enable_if<std::is_same<T, std::string>::value,
  71                           StringRef>::type &
  72   operator=(T &&Str) = delete;
  73   operator std::string() const;
  74   bool startswith(StringRef Prefix) const;
  75   bool startswith_lower(StringRef Prefix) const;
  76   bool endswith(StringRef Suffix) const;
  77   bool endswith_lower(StringRef Suffix) const;
  78   size_t find(char C, size_t From = 0) const;
  79   size_t find_lower(char C, size_t From = 0) const;
  80   size_t find_if(function_ref<bool(char)> F, size_t From = 0) const;
  81   size_t find_if_not(function_ref<bool(char)> F, size_t From = 0) const;
  82   size_t find(StringRef Str, size_t From = 0) const;
  83   size_t find_lower(StringRef Str, size_t From = 0) const;
  84   size_t rfind(char C, size_t From = npos) const;
  85   size_t rfind_lower(char C, size_t From = npos) const;
  86   size_t rfind(StringRef Str) const;
  87   size_t rfind_lower(StringRef Str) const;
  88   size_t find_first_of(char C, size_t From = 0) const;
  89   size_t find_first_of(StringRef Chars, size_t From = 0) const;
  90   size_t find_first_not_of(char C, size_t From = 0) const;
  91   size_t find_first_not_of(StringRef Chars, size_t From = 0) const;
  92   size_t find_last_of(char C, size_t From = npos) const;
  93   size_t find_last_of(StringRef Chars, size_t From = npos) const;
  94   size_t find_last_not_of(char C, size_t From = npos) const;
  95   size_t find_last_not_of(StringRef Chars, size_t From = npos) const;
  96   bool contains(StringRef Other) const;
  97   bool contains(char C) const;
  98   bool contains_lower(StringRef Other) const;
  99   bool contains_lower(char C) const;
 100   size_t count(char C) const;
 101   size_t count(StringRef Str) const;
 102   template <typename T>
 103   typename std::enable_if<std::numeric_limits<T>::is_signed, bool>::type
 104   getAsInteger(unsigned Radix, T &Result) const;
 105   template <typename T>
 106   typename std::enable_if<!std::numeric_limits<T>::is_signed, bool>::type
 107   getAsInteger(unsigned Radix, T &Result) const;
 108   template <typename T>
 109   typename std::enable_if<std::numeric_limits<T>::is_signed, bool>::type
 110   consumeInteger(unsigned Radix, T &Result);
 111   template <typename T>
 112   typename std::enable_if<!std::numeric_limits<T>::is_signed, bool>::type
 113   consumeInteger(unsigned Radix, T &Result);
 114   bool getAsInteger(unsigned Radix, APInt &Result) const;
 115   bool getAsDouble(double &Result, bool AllowInexact = true) const;
 116   std::string lower() const;
 117   std::string upper() const;
 118   StringRef substr(size_t Start, size_t N = npos) const;
 119   StringRef take_front(size_t N = 1) const;
 120   StringRef take_back(size_t N = 1) const;
 121   StringRef take_while(function_ref<bool(char)> F) const;
 122   StringRef take_until(function_ref<bool(char)> F) const;
 123   StringRef drop_front(size_t N = 1) const;
 124   StringRef drop_back(size_t N = 1) const;
 125   StringRef drop_while(function_ref<bool(char)> F) const;
 126   StringRef drop_until(function_ref<bool(char)> F) const;
 127   bool consume_front(StringRef Prefix);
 128   bool consume_back(StringRef Suffix);
 129   StringRef slice(size_t Start, size_t End) const;
 130   std::pair<StringRef, StringRef> split(char Separator) const;
 131   std::pair<StringRef, StringRef> split(StringRef Separator) const;
 132   std::pair<StringRef, StringRef> rsplit(StringRef Separator) const;
 133   void split(SmallVectorImpl<StringRef> &A,
 134              StringRef Separator, int MaxSplit = -1,
 135              bool KeepEmpty = true) const;
 136   void split(SmallVectorImpl<StringRef> &A, char Separator, int MaxSplit = -1,
 137              bool KeepEmpty = true) const;
 138   std::pair<StringRef, StringRef> rsplit(char Separator) const;
 139   StringRef ltrim(char Char) const;
 140   StringRef ltrim(StringRef Chars = " \t\n\v\f\r") const;
 141   StringRef rtrim(char Char) const;
 142   StringRef rtrim(StringRef Chars = " \t\n\v\f\r") const;
 143   StringRef trim(char Char) const;
 144   StringRef trim(StringRef Chars = " \t\n\v\f\r") const;
 145 };
 146
 147 inline bool operator==(StringRef LHS, StringRef RHS);
 148 inline bool operator!=(StringRef LHS, StringRef RHS);
 149 inline bool operator<(StringRef LHS, StringRef RHS);
 150 inline bool operator<=(StringRef LHS, StringRef RHS);
 151 inline bool operator>(StringRef LHS, StringRef RHS);
 152 inline bool operator>=(StringRef LHS, StringRef RHS);
 153 inline std::string &operator+=(std::string &buffer, StringRef string);
 154 hash_code hash_value(StringRef S);
 155
 156 } // end of namespace llvm
 157
 158 //===----------------------------------------------------------------------===//
 159 // Tests for StringRef.
 160 //===----------------------------------------------------------------------===//
 161
 162 void temporarayStringToStringRefAssignmentTest() {
 163   // TODO: Emit a warning.
 164   llvm::StringRef Ref = std::string("Yimmy yummy test.");
 165 }
 166
 167 void assigningStringToStringRefWithLongerLifetimeTest() {
 168   llvm::StringRef Ref;
 169   {
 170     // TODO: Emit a warning.
 171     std::string TmpStr("This is a fine string.");
 172     Ref = TmpStr;
 173   }
 174 }
 175
 176 std::string getTemporaryString() {
 177   return "One two three.";
 178 }
 179
 180 void assigningTempStringFromFunctionToStringRefTest() {
 181   // TODO: Emit a warning.
 182   llvm::StringRef Ref = getTemporaryString();
 183 }
 184
 185 //===----------------------------------------------------------------------===//
 186 // Forward declaration for Clang AST nodes.
 187 //===----------------------------------------------------------------------===//
 188
 189 namespace llvm {
 190
 191 template <class T, int Size>
 192 struct SmallVector {};
 193
 194 } // end of namespace llvm
 195
 196 namespace clang {
 197
 198 struct Type;
 199 struct Decl;
 200 struct Stmt;
 201 struct Attr;
 202
 203 } // end of namespace clang
 204
 205 //===----------------------------------------------------------------------===//
 206 // Tests for Clang AST nodes.
 207 //===----------------------------------------------------------------------===//
 208
 209 namespace clang {
 210
 211 struct Type {
 212   std::string str; // expected-warning{{AST class 'Type' has a field 'str' that allocates heap memory (type std::string)}}
 213 };
 214
 215 } // end of namespace clang
 216
 217 namespace clang {
 218
 219 struct Decl {
 220   llvm::SmallVector<int, 5> Vec; // expected-warning{{AST class 'Decl' has a field 'Vec' that allocates heap memory (type llvm::SmallVector<int, 5>)}}
 221 };
 222
 223 } // end of namespace clang