First implementation

Author: MichaelRFairhurst

cpp/misra/src/rules/RULE-15-0-1/AnalyzableClass.qll

@@ -0,0 +1,68 @@
+import cpp
+
+private predicate isUsable(MemberFunction f) {
+  not f.isDeleted() and
+  f.isPublic()
+}
+
+private predicate isMemberCustomized(MemberFunction f) {
+  exists(f.getDefinition()) and
+  not f.isDefaulted()
+}
+
+newtype TSpecialMember =
+  TMoveConstructor() or
+  TMoveAssignmentOperator() or
+  TCopyConstructor() or
+  TCopyAssignmentOperator() or
+  TDestructor()
+
+class AnalyzableClass extends Class {
+  MoveConstructor moveCtor;
+  MoveAssignmentOperator moveAssign;
+  CopyConstructor copyCtor;
+  CopyAssignmentOperator copyAssign;
+  Destructor dtor;
+
+  AnalyzableClass() {
+    moveCtor = this.getAConstructor() and
+    copyCtor = this.getAConstructor() and
+    moveAssign = this.getAMemberFunction() and
+    copyAssign = this.getAMemberFunction() and
+    dtor = this.getDestructor()
+  }
+
+  predicate exposes(TSpecialMember m) {
+    m instanceof TMoveConstructor and moveConstructible()
+    or
+    m instanceof TMoveAssignmentOperator and moveAssignable()
+    or
+    m instanceof TCopyConstructor and copyConstructible()
+    or
+    m instanceof TCopyAssignmentOperator and copyAssignable()
+    or
+    m instanceof TDestructor and destructible()
+  }
+
+  predicate moveConstructible() { isUsable(moveCtor) }
+
+  predicate copyConstructible() { isUsable(copyCtor) }
+
+  predicate moveAssignable() { isUsable(moveAssign) }
+
+  predicate copyAssignable() { isUsable(copyAssign) }
+
+  predicate destructible() { isUsable(dtor) }
+
+  predicate isCustomized(TSpecialMember s) {
+    s instanceof TMoveConstructor and isMemberCustomized(moveCtor)
+    or
+    s instanceof TMoveAssignmentOperator and isMemberCustomized(moveAssign)
+    or
+    s instanceof TCopyConstructor and isMemberCustomized(copyCtor)
+    or
+    s instanceof TCopyAssignmentOperator and isMemberCustomized(copyAssign)
+    or
+    s instanceof TDestructor and isMemberCustomized(dtor)
+  }
+}

cpp/misra/src/rules/RULE-15-0-1/ImproperlyProvidedSpecialMemberFunctions.ql

@@ -16,8 +16,91 @@
 
 import cpp
 import codingstandards.cpp.misra
+import AnalyzableClass
 
-from
+predicate isCopyEnabled(AnalyzableClass c) {
+  c.moveConstructible() and
+  not c.moveAssignable() and
+  c.copyConstructible() and
+  not c.copyAssignable()
+  or
+  c.moveConstructible() and
+  c.moveAssignable() and
+  c.copyConstructible() and
+  c.copyAssignable()
+}
+
+predicate isMoveOnly(AnalyzableClass c) {
+  c.moveConstructible() and
+  not c.moveAssignable() and
+  not c.copyConstructible() and
+  not c.copyAssignable()
+  or
+  c.moveConstructible() and
+  c.moveAssignable() and
+  not c.copyConstructible() and
+  not c.copyAssignable()
+}
+
+predicate unmovable(AnalyzableClass c) {
+  not c.moveConstructible() and
+  not c.moveAssignable() and
+  not c.copyConstructible() and
+  not c.copyAssignable()
+}
+
+predicate isValidCategory(AnalyzableClass c) {
+  isCopyEnabled(c) or
+  isMoveOnly(c) or
+  unmovable(c)
+}
+
+predicate violatesCustomizedDestructorRequirements(AnalyzableClass c, string reason) {
+  c.isCustomized(TDestructor()) and
+  (
+    c.moveConstructible() and
+    not c.isCustomized(TMoveConstructor()) and
+    reason = "Move constructor is not customized"
+    or
+    c.moveAssignable() and
+    not c.isCustomized(TMoveAssignmentOperator()) and
+    reason = "Move assignment operator is not customized"
+    or
+    c.copyConstructible() and
+    not c.isCustomized(TCopyConstructor()) and
+    reason = "Copy constructor is not customized"
+    or
+    c.copyAssignable() and
+    not c.isCustomized(TCopyAssignmentOperator()) and
+    reason = "Copy assignment operator is not customized"
+  )
+}
+
+predicate violatesInheritanceRequirements(AnalyzableClass c) {
+  exists(ClassDerivation d |
+    d.getBaseClass() = c and
+    d.hasSpecifier("public")
+  ) and
+  (
+    isMoveOnly(c) and
+    c.getDestructor().isPublic() and
+    c.getDestructor().isVirtual()
+    or
+    c.getDestructor().isProtected() and
+    not c.getDestructor().isVirtual()
+  )
+}
+
+from AnalyzableClass c, string message
 where
-  not isExcluded(x, Classes3Package::improperlyProvidedSpecialMemberFunctionsQuery()) and
-select
+  not isExcluded(c, Classes3Package::improperlyProvidedSpecialMemberFunctionsQuery()) and
+  (
+    not isValidCategory(c) and
+    message = "Class does not fall into a valid category (unmovable, move-only, or copy-enabled)."
+    or
+    violatesCustomizedDestructorRequirements(c, message)
+    or
+    violatesInheritanceRequirements(c) and
+    message = "Class violates inheritance requirements for special member functions."
+  )
+select c, message

cpp/misra/test/rules/RULE-15-0-1/test.cpp

@@ -152,94 +152,112 @@ class PrivateMoveAssign { // NON_COMPLIANT
 namespace additional_requirements {
 
 class CustomizedCopyCtorCompliant { // COMPLIANT
+public:
   DEFINE_ALL_SPECIAL_MEMBERS(CustomizedCopyCtorCompliant, CUSTOMIZED, DEFAULTED,
                              DEFAULTED, DEFAULTED, CUSTOMIZED)
 };
 
 class CustomizedMoveCtorCompliant { // COMPLIANT
+public:
   DEFINE_ALL_SPECIAL_MEMBERS(CustomizedMoveCtorCompliant, DEFAULTED, CUSTOMIZED,
                              DEFAULTED, DEFAULTED, CUSTOMIZED)
 };
 
 class CustomizedCopyAssignCompliant { // COMPLIANT
+public:
   DEFINE_ALL_SPECIAL_MEMBERS(CustomizedCopyAssignCompliant, DEFAULTED,
                              DEFAULTED, CUSTOMIZED, DEFAULTED, CUSTOMIZED)
 };
 
 class CustomizedMoveAssignCompliant { // COMPLIANT
+public:
   DEFINE_ALL_SPECIAL_MEMBERS(CustomizedMoveAssignCompliant, DEFAULTED,
                              DEFAULTED, DEFAULTED, CUSTOMIZED, CUSTOMIZED)
 };
 
 class CustomizedCopyCtorDefaultDtor { // NON_COMPLIANT
+public:
   DEFINE_ALL_SPECIAL_MEMBERS(CustomizedCopyCtorDefaultDtor, CUSTOMIZED,
                              DEFAULTED, DEFAULTED, DEFAULTED, DEFAULTED)
 };
 
 class CustomizedCopyCtorDeletedDtor { // NON_COMPLIANT
+public:
   DEFINE_ALL_SPECIAL_MEMBERS(CustomizedCopyCtorDeletedDtor, CUSTOMIZED,
                              DEFAULTED, DEFAULTED, DEFAULTED, DELETED)
 };
 
 class CustomizedMoveCtorNonCompliant { // NON_COMPLIANT
+public:
   DEFINE_ALL_SPECIAL_MEMBERS(CustomizedMoveCtorNonCompliant, CUSTOMIZED,
                              DEFAULTED, DEFAULTED, DEFAULTED, DEFAULTED)
 };
 
 class CustomizedCopyAssignNonCompliant { // NON_COMPLIANT
+public:
   DEFINE_ALL_SPECIAL_MEMBERS(CustomizedCopyAssignNonCompliant, DEFAULTED,
                              DEFAULTED, CUSTOMIZED, DEFAULTED, DEFAULTED)
 };
 
 class CustomizedMoveAssignNonCompliant { // NON_COMPLIANT
+public:
   DEFINE_ALL_SPECIAL_MEMBERS(CustomizedMoveAssignNonCompliant, DEFAULTED,
                              DEFAULTED, DEFAULTED, CUSTOMIZED, DEFAULTED)
 };
 
 // Move-only with a customized dtor requires customized move operations.
 class MoveOnlyNotCustomizedNonCompliant { // NON_COMPLIANT
+public:
   DEFINE_ALL_SPECIAL_MEMBERS(MoveOnlyNotCustomizedNonCompliant, DELETED,
                              DEFAULTED, DELETED, DELETED, CUSTOMIZED)
 };
 
 // Move-only with a customized dtor requires customized move operations.
 class MoveOnlyAssignableNotCustomizedNonCompliant { // NON_COMPLIANT
+public:
   DEFINE_ALL_SPECIAL_MEMBERS(MoveOnlyAssignableNotCustomizedNonCompliant,
                              DELETED, DEFAULTED, DELETED, DEFAULTED, CUSTOMIZED)
 };
 
 class MoveOnlyCustomizedCompliant { // COMPLIANT -- customized move
+public:
   DEFINE_ALL_SPECIAL_MEMBERS(MoveOnlyCustomizedCompliant, DELETED, CUSTOMIZED,
                              DELETED, DELETED, CUSTOMIZED)
 };
 
 class MoveOnlyAssignableCustomizedCompliant { // COMPLIANT -- customized move
+public:
   DEFINE_ALL_SPECIAL_MEMBERS(MoveOnlyAssignableCustomizedCompliant, DELETED,
                              CUSTOMIZED, DELETED, CUSTOMIZED, CUSTOMIZED)
 };
 
 class MoveOnlyNotCustomizedCompliant { // COMPLIANT -- default dtor
+public:
   DEFINE_ALL_SPECIAL_MEMBERS(MoveOnlyNotCustomizedCompliant, DELETED, DEFAULTED,
                              DELETED, DELETED, DEFAULTED)
 };
 
 class MoveOnlyAssignableNotCustomizedCompliant { // COMPLIANT -- default dtor
+public:
   DEFINE_ALL_SPECIAL_MEMBERS(MoveOnlyAssignableNotCustomizedCompliant, DELETED,
                              DEFAULTED, DELETED, DEFAULTED, DEFAULTED)
 };
 
 // Copy-enabled with customized dtor requires customized copy and move
 class CopyEnabledCustomizedDtorNonCompliant { // NON_COMPLIANT
+public:
   DEFINE_ALL_SPECIAL_MEMBERS(CopyEnabledCustomizedDtorNonCompliant, DEFAULTED,
                              DEFAULTED, DEFAULTED, DEFAULTED, CUSTOMIZED)
 };
 
 class CopyEnabledNonCustomizedDtorCompliant { // COMPLIANT
+public:
   DEFINE_ALL_SPECIAL_MEMBERS(CopyEnabledNonCustomizedDtorCompliant, DEFAULTED,
                              DEFAULTED, DEFAULTED, DEFAULTED, DEFAULTED)
 };
 
 class CopyEnabledCustomizedDtorCompliant { // COMPLIANT
+public:
   DEFINE_ALL_SPECIAL_MEMBERS(CopyEnabledCustomizedDtorCompliant, CUSTOMIZED,
                              CUSTOMIZED, CUSTOMIZED, CUSTOMIZED, CUSTOMIZED)
 };