A8-4-13: Fix compiler compatibility FPs

Fix false positives identified by compiler compatibility testing on gcc/clang,
which identified that shared_ptr used a hidden base class in real compilers
causing our detection of modifying function calls to fail. This has been
addressed, with a bonus modification to more accurately represent which
pointer/reference types are captured.

Author: lcartey

change_notes/2023-08-02-a8-4-13-false-positives.md

@@ -0,0 +1 @@
+ - `A8-4-13` - reduce false positives when using gcc/clang where a modifying operation was used on a shared_ptr.

cpp/autosar/src/rules/A8-4-13/SharedPtrPassedToFunctionWithImproperSemantics.ql

@@ -19,13 +19,19 @@ import cpp
 import codingstandards.cpp.autosar
 import codingstandards.cpp.SmartPointers
 
+class AutosarSharedPointerOrDerived extends Type {
+  AutosarSharedPointerOrDerived() {
+    this.getUnspecifiedType() instanceof AutosarSharedPointer or
+    this.getUnspecifiedType().(DerivedType).getBaseType() instanceof AutosarSharedPointer
+  }
+}
+
 Expr underlyingObjectAffectingSharedPointerExpr(Function f) {
   result =
     any(VariableAccess va, FunctionCall fc |
       va.getEnclosingFunction() = f and
-      // strip the type so as to include reference parameter types
-      va.getType().stripType() instanceof AutosarSharedPointer and
-      fc.getTarget().getDeclaringType().stripType() instanceof AutosarSharedPointer and
+      // The type of the variable is either a shared_ptr, or a reference or pointer to a shared_ptr
+      va.getType() instanceof AutosarSharedPointerOrDerived and
       fc.getQualifier() = va and
       // include only calls to methods which modify the underlying object
       fc.getTarget().hasName(["operator=", "reset", "swap"])
@@ -36,7 +42,7 @@ Expr underlyingObjectAffectingSharedPointerExpr(Function f) {
 
 predicate flowsToUnderlyingObjectAffectingExpr(Parameter p) {
   // check if a parameter flows locally to an expression which affects smart pointer lifetime
-  p.getType().stripType() instanceof AutosarSharedPointer and
+  p.getType() instanceof AutosarSharedPointerOrDerived and
   localExprFlow(p.getAnAccess(), underlyingObjectAffectingSharedPointerExpr(p.getFunction()))
   or
   // else handle nested cases, such as passing smart pointers as reference arguments
@@ -54,7 +60,7 @@ predicate flowsToUnderlyingObjectAffectingExpr(Parameter p) {
 from DefinedSmartPointerParameter p, string problem
 where
   not isExcluded(p, SmartPointers1Package::smartPointerAsParameterWithoutLifetimeSemanticsQuery()) and
-  p.getType().stripType() instanceof AutosarSharedPointer and
+  p.getType() instanceof AutosarSharedPointerOrDerived and
   (
     // handle the parameter depending on its derived type
     p.getType() instanceof RValueReferenceType and

cpp/common/test/includes/standard-library/memory.h

@@ -1,7 +1,7 @@
 #ifndef _GHLIBCPP_MEMORY
 #define _GHLIBCPP_MEMORY
-#include "stddef.h"
 #include "exception.h"
+#include "stddef.h"
 
 namespace std {
 
@@ -18,6 +18,7 @@ template <typename T> struct default_delete<T[]> {
 template <typename T, typename Deleter = std::default_delete<T>>
 class unique_ptr {
 public:
+  typedef T *pointer;
   unique_ptr() {}
   unique_ptr(T *ptr) {}
   unique_ptr(const unique_ptr<T> &t) = delete;
@@ -27,9 +28,7 @@ class unique_ptr {
   T *operator->() const noexcept { return ptr; }
   T *get() const noexcept { return ptr; }
   T *release() { return ptr; }
-  void reset() {}
-  void reset(T *ptr) {}
-  void reset(T ptr) {}
+  void reset(pointer __p = pointer()) {}
   T *get() { return ptr; }
   unique_ptr<T> &operator=(const unique_ptr &) = delete;
   unique_ptr<T> &operator=(unique_ptr &&) { return *this; }
@@ -70,23 +69,29 @@ template <class T, class D> class unique_ptr<T[], D> {
 template <class T, class... Args> unique_ptr<T> make_unique(Args &&...args);
 template <class T> unique_ptr<T> make_unique(size_t n);
 
-template <typename T> class shared_ptr {
+template <typename T> class __shared_ptr {
+public:
+  void reset() noexcept;
+  template <class Y> void reset(Y *p);
+  template <class Y, class D> void reset(Y *p, D d);
+  template <class Y, class D, class A> void reset(Y *p, D d, A a);
+};
+
+template <typename T> class shared_ptr : public __shared_ptr<T> {
 public:
-  shared_ptr() {}
-  shared_ptr(T *ptr) {}
+  shared_ptr();
+  shared_ptr(T *ptr);
   shared_ptr(const shared_ptr<T> &r) noexcept;
   template <class Y> shared_ptr(const shared_ptr<Y> &r) noexcept;
   shared_ptr(shared_ptr<T> &&r) noexcept;
   template <class Y> shared_ptr(shared_ptr<Y> &&r) noexcept;
   shared_ptr(unique_ptr<T> &&t) {}
   ~shared_ptr() {}
-  T &operator*() const { return *ptr; }
-  T *operator->() const noexcept { return ptr; }
-  void reset() {}
-  void reset(T *pt) {}
-  void reset(T pt) {}
+  T &operator*() const noexcept;
+  T *operator->() const noexcept;
+
   long use_count() const noexcept { return 0; }
-  T *get() { return ptr; }
+  T *get() const noexcept { return ptr; }
   shared_ptr<T> &operator=(const shared_ptr &) {}
   shared_ptr<T> &operator=(shared_ptr &&) { return *this; }
   template <typename S> shared_ptr &operator=(shared_ptr<T> &&) {