Most cases implemented

Author: MichaelRFairhurst

cpp/common/src/codingstandards/cpp/standardlibrary/Memory.qll

@@ -4,6 +4,10 @@
 
 import cpp
 
+class DefaultAllocator extends TemplateClass {
+  DefaultAllocator() { this.hasQualifiedName("std", "allocator") }
+}
+
 abstract class UninitializedMemoryManagementFunction extends Function {
   UninitializedMemoryManagementFunction() {
     this.getADeclarationLocation().getFile().getShortName() = "memory"

cpp/common/src/codingstandards/cpp/types/ImplicitSpecialMemberFunctions.qll

@@ -0,0 +1,147 @@
+import cpp
+
+predicate mustBeImplicitlyDefined(Function mf) {
+  // If it exists and its defaulted, it must be implicitly defined
+  mf.isCompilerGenerated() or mf.isDefaulted()
+}
+
+predicate mustNotBeImplicitlyDefined(Function mf) {
+  // Sanity check: exclude member functions that are definitely user defined!
+  not mustBeImplicitlyDefined(mf) and
+  (
+    // If the user wrote a body, it's not implicitly defined
+    not mf.isCompilerGenerated()
+    or
+    // Deleted functions have no definition at all
+    mf.isDeleted()
+  )
+}
+
+predicate mustBeUserDeclared(Function mf) {
+  exists(FunctionDeclarationEntry fde | fde.getFunction() = mf and not fde.isImplicit())
+}
+
+predicate mustNotBeUserDeclared(Function mf) {
+  // use forex: at least one declaration must exist, and all declarations must be implicit
+  forex(FunctionDeclarationEntry fde | fde.getFunction() = mf | fde.isImplicit())
+}
+
+private signature class SpecialMember extends Function;
+
+private signature predicate constraint(Function mf);
+
+/**
+ * Implicitly defined copy constructors are deprecated if the class has a user-declared copy
+ * assignment operator or a user-declared destructor. The same is true for the reverse case
+ * (implicit copy assignment operators check for copy constructors).
+ *
+ * Unfortunately, trivial copy constructors, assignment operators, and destructors are often missing
+ * from the database, so we can only approximate.
+ *
+ * To manage all of the negatives, double negatives, musts, mays, and may nots, the problem is
+ * broken down into sets as defined below.
+ *
+ * Firstly:
+ * - CC=copy constructor, CA=copy assignment operator, D=destructor
+ * - IDEF = implicitly defined, UDEC = user declared
+ *
+ * and:
+ * - C_has{X} = set of all classes T for which "class T has a {X}"
+ * - C_mustHave{X} = set of all classes T for which "class T must have a {X}"
+ * - C_cannotHave{X} = set of all classes T for which "class T cannot have a {X}"
+ * - C_mayHave{X} = not C_cannotHave{X}
+ *
+ * then we can find all cases we know to be deprecated via:
+ * - Step 1: find C_mustHave{IDEF CC}, C_mustHave{IDEF CA}
+ * - Step 2: find C_mustHave{UDEC CC}, C_mustHave{UDEC CA}, C_mustHave{UDEC D}
+ * - Step 3: All C' are deprecated where C' in C_mustHave{IDEF CC} and (C' in C_mustHave{UDEC CA} or C' in C_mustHave{UDEC D})
+ * - Step 4: All C' are deprecated where C' in C_mustHave{IDEF CA} and (C' in C_mustHave{UDEC CC} or C' in C_mustHave{UDEC D})
+ *
+ * And all cases we may consider deprecated via:
+ * - Step 5: find C_cannotHave{IDEF CC}, C_cannotHave{IDEF CA}
+ * - Step 6: find C_mayHave{IDEF CC}, C_mayHave{IDEF CA} (by negating the cannot sets)
+ * - Step 7: find C_cannotHave{UDEC CC}, C_cannotHave{UDEC CA}, C_cannotHave{UDEC D}
+ * - Step 8: find C_mayHave{UDEC CC}, C_mayHave{UDEC CA}, C_mayHave{UDEC D} (by negating the cannot sets)
+ * - Step 9: All C' may be deprecated where C' in C_mayHave{IDEF CC} and (C' in C_mayHave{UDEC CA} or C' in C_mayHave{UDEC D})
+ * - Step 10: All C' may be deprecated where C' in C_mayHave{IDEF CA} and (C' in C_mayHave{UDEC CC} or C' in C_mayHave{UDEC D})
+ *
+ * This is performed through the various instantiations of this module.
+ */
+private module ClassesWhere<constraint/1 pred, SpecialMember Member> {
+  final class FinalClass = Class;
+
+  class Matching extends FinalClass {
+    Matching() { exists(Member member | member.getDeclaringType() = this and pred(member)) }
+  }
+
+  class NotMatching extends FinalClass {
+    NotMatching() { not this instanceof Matching }
+  }
+}
+
+/* Step 1: find C_mustHave{IDEF CC}, C_mustHave{IDEF CA} */
+private class CMustHaveIdefCC = ClassesWhere<mustBeImplicitlyDefined/1, CopyConstructor>::Matching;
+
+private class CMustHaveIdefCA =
+  ClassesWhere<mustBeImplicitlyDefined/1, CopyAssignmentOperator>::Matching;
+
+/* Step 2: find C_mustHave{UDEC CC}, C_mustHave{UDEC CA}, C_mustHave{UDEC D} */
+private class CMustHaveUdecCC = ClassesWhere<mustBeUserDeclared/1, CopyConstructor>::Matching;
+
+private class CMustHaveUdecCA =
+  ClassesWhere<mustBeUserDeclared/1, CopyAssignmentOperator>::Matching;
+
+private class CMustHaveUdecD = ClassesWhere<mustBeUserDeclared/1, Destructor>::Matching;
+
+/* - Step 3: All C' are deprecated where C' in C_mustHave{IDEF CC} and (C' in C_mustHave{UDEC CA} or C' in C_mustHave{UDEC D}) */
+class MustHaveDeprecatedCopyConstructor extends CMustHaveIdefCC {
+  MustHaveDeprecatedCopyConstructor() {
+    this instanceof CMustHaveUdecCA or this instanceof CMustHaveUdecD
+  }
+}
+
+/* - Step 4: All C' are deprecated where C' in C_mustHave{IDEF CA} and (C' in C_mustHave{UDEC CC} or C' in C_mustHave{UDEC D}) */
+class MustHaveDeprecatedCopyAssignmentOperator extends CMustHaveIdefCA {
+  MustHaveDeprecatedCopyAssignmentOperator() {
+    this instanceof CMustHaveUdecCC or this instanceof CMustHaveUdecD
+  }
+}
+
+/**
+ * Step 5: find C_cannotHave{IDEF CC}, C_cannotHave{IDEF CA}
+ * Step 6: find C_mayHave{IDEF CC}, C_mayHave{IDEF CA} (by negating the cannot sets)
+ *
+ * In our case, `ClassesWhere<...>` performs steps 5 and 6 together via `NotMatching`.
+ */
+private class CMayHaveIdefCC =
+  ClassesWhere<mustNotBeImplicitlyDefined/1, CopyConstructor>::NotMatching;
+
+private class CMayHaveIdefCA =
+  ClassesWhere<mustNotBeImplicitlyDefined/1, CopyAssignmentOperator>::NotMatching;
+
+/**
+ * Step 7: find C_cannotHave{UDEC CC}, C_cannotHave{UDEC CA}, C_cannotHave{UDEC D}
+ * Step 8: find C_mayHave{UDEC CC}, C_mayHave{UDEC CA}, C_mayHave{UDEC D} (by negating the cannot sets)
+ *
+ * In our case, `ClassesWhere<...>` performs steps 7 and 8 together via `NotMatching`.
+ */
+private class CMayHaveUdecCC = ClassesWhere<mustNotBeUserDeclared/1, CopyConstructor>::NotMatching;
+
+private class CMayHaveUdecCA =
+  ClassesWhere<mustNotBeUserDeclared/1, CopyAssignmentOperator>::NotMatching;
+
+private class CMayHaveUdecD = ClassesWhere<mustNotBeUserDeclared/1, Destructor>::NotMatching;
+
+/* - Step 9: All C' may be deprecated where C' in C_mayHave{IDEF CC} and (C' in C_mayHave{UDEC CA} or C' in C_mayHave{UDEC D}) */
+class MayHaveDeprecatedCopyConstructor extends CMayHaveIdefCC {
+  MayHaveDeprecatedCopyConstructor() {
+    this instanceof CMayHaveUdecCA or this instanceof CMayHaveUdecD
+  }
+}
+
+/* - Step 10: All C' may be deprecated where C' in C_mayHave{IDEF CA} and (C' in C_mayHave{UDEC CC} or C' in C_mayHave{UDEC D}) */
+class MayHaveDeprecatedCopyAssignmentOperator extends CMayHaveIdefCA {
+  MayHaveDeprecatedCopyAssignmentOperator() {
+    this instanceof CMayHaveUdecCC or this instanceof CMayHaveUdecD
+  }
+}

cpp/common/test/includes/standard-library/ccomplex

@@ -15,6 +15,7 @@ extern const __ph<2> _2;
 } // namespace placeholders
 template <class Fn, class... Args> class binder {
 public:
+  using result_type = int; // deprecated in C++17
   template <class TFn, class... TArgs>
   constexpr binder(TFn &&f, TArgs &&...args) noexcept {}
 
@@ -57,7 +58,18 @@ template <class T> reference_wrapper<T> ref(T &t) noexcept;
 template <class T> void ref(const T &&t) = delete;
 template <class T> reference_wrapper<T> ref(reference_wrapper<T> t) noexcept;
 
-template <class Ty> struct hash { size_t operator()(Ty val) const; };
+template <class Ty> struct hash {
+  using result_type = size_t;  // deprecated in C++17
+  using argument_type = Ty;    // deprecated in C++17
+  size_t operator()(Ty val) const;
+};
+
+template <class F> class mem_fn_result {
+public:
+  using result_type = int; // deprecated in C++17
+};
+
+template <class F> mem_fn_result<F> mem_fn(F f);
 
 template <class Arg, class Result>
 class pointer_to_unary_function : public unary_function<Arg, Result> {
@@ -103,9 +115,24 @@ template <class Predicate> class binary_negate {
 template <class> class function;
 template <class R, class... Args> class function<R(Args...)> {
 public:
+  using result_type = R; // deprecated in C++17
   function();
   template <class F> function(F&& f);
   template <class F> function &operator=(F &&);
 };
+
+template <class T = void> struct plus {
+  using result_type = T;           // deprecated in C++17
+  using first_argument_type = T;   // deprecated in C++17
+  using second_argument_type = T;  // deprecated in C++17
+  T operator()(const T &x, const T &y) const;
+};
+
+template <class T = void> struct negate {
+  using result_type = T;      // deprecated in C++17
+  using argument_type = T;    // deprecated in C++17
+  T operator()(const T &x) const;
+};
+
 } // namespace std
 #endif

cpp/common/test/includes/standard-library/complex

@@ -1,6 +1,7 @@
 #ifndef _GHLIBCPP_MEMORY
 #define _GHLIBCPP_MEMORY
 #include "exception.h"
+#include "iterator.h"
 #include "stddef.h"
 #include "utility.h"
 
@@ -135,6 +136,14 @@ template <typename T1> struct allocator {
   using value_type = T1;
   using size_type = std::size_t;
   using difference_type = std::ptrdiff_t;
+  // deprecated in C++17:
+  using pointer = T1 *;
+  using const_pointer = const T1 *;
+  using reference = T1 &;
+  using const_reference = const T1 &;
+  template <class T2> struct rebind {
+    using other = allocator<T2>;
+  };
 
   constexpr allocator() noexcept = default;
   constexpr allocator(const allocator &) noexcept = default;
@@ -144,7 +153,14 @@ template <typename T1> struct allocator {
   ~allocator() = default;
 
   T1 *allocate(std::size_t);
+  T1 *allocate(std::size_t, const void *);
   void deallocate(T1 *, std::size_t);
+  // deprecated in C++17:
+  pointer address(reference r) const noexcept;
+  const_pointer address(const_reference r) const noexcept;
+  size_type max_size() const noexcept;
+  template <class U, class... Args> void construct(U *p, Args &&...args);
+  template <class U> void destroy(U *p);
 };
 
 template <> struct allocator<void> {
@@ -260,6 +276,31 @@ T2 destroy_n(T1&&, T2, T3);
 template <class T1>
 constexpr T1* launder(T1*) noexcept;
 
+// get_temporary_buffer / return_temporary_buffer (deprecated in C++17)
+template <class T>
+pair<T *, ptrdiff_t> get_temporary_buffer(ptrdiff_t n) noexcept;
+
+template <class T>
+void return_temporary_buffer(T *p);
+
+// raw_storage_iterator (deprecated in C++17)
+template <class OutputIterator, class T>
+class raw_storage_iterator {
+public:
+  using iterator_category = output_iterator_tag;
+  using value_type = void;
+  using difference_type = void;
+  using pointer = void;
+  using reference = void;
+  explicit raw_storage_iterator(OutputIterator x);
+  raw_storage_iterator &operator*();
+  raw_storage_iterator &operator=(const T &element);
+  raw_storage_iterator &operator=(T &&element);
+  raw_storage_iterator &operator++();
+  raw_storage_iterator operator++(int);
+  OutputIterator base() const;
+};
+
 } // namespace std
 
 #endif // _GHLIBCPP_MEMORY

cpp/common/test/includes/standard-library/cstdalign

@@ -4,6 +4,8 @@
 #include <streambuf>
 
 namespace std {
+typedef basic_iostream<char> iostream;
+
 class strstreambuf : public basic_streambuf<char> {};
 
 class istrstream : public istream {
@@ -18,4 +20,9 @@ class ostrstream : public ostream {
 public:
   ostrstream();
 };
+
+class strstream : public iostream {
+public:
+  strstream();
+};
 } // namespace std