Declarations2: add rule DCL40-C

knewbury01 · knewbury01 · commit dda49f716773 · 2022-09-20T17:01:02.000-04:00
diff --git a/c/cert/src/rules/DCL40-C/ExcessLengthNamesIdentifiersNotDistinct.md b/c/cert/src/rules/DCL40-C/ExcessLengthNamesIdentifiersNotDistinct.md
@@ -0,0 +1,18 @@
+# DCL40-C: External identifiers shall be distinct
+
+This query implements the CERT-C rule DCL40-C:
+
+> Do not create incompatible declarations of the same function or object
+
+
+## CERT
+
+** REPLACE THIS BY RUNNING THE SCRIPT `scripts/help/cert-help-extraction.py` **
+
+## Implementation notes
+
+This query considers the first 31 characters of identifiers as significant, as per C99 and reports the case when names are longer than 31 characters and differ in those characters past the 31 first only. This query does not consider universal or extended source characters.
+
+## References
+
+* CERT-C: [DCL40-C: Do not create incompatible declarations of the same function or object](https://wiki.sei.cmu.edu/confluence/display/c)
diff --git a/c/cert/src/rules/DCL40-C/ExcessLengthNamesIdentifiersNotDistinct.ql b/c/cert/src/rules/DCL40-C/ExcessLengthNamesIdentifiersNotDistinct.ql
@@ -0,0 +1,23 @@
+/**
+ * @id c/cert/excess-length-names-identifiers-not-distinct
+ * @name DCL40-C: External identifiers shall be distinct
+ * @description Using nondistinct external identifiers results in undefined behaviour.
+ * @kind problem
+ * @precision very-high
+ * @problem.severity warning
+ * @tags external/cert/id/dcl40-c
+ *       correctness
+ *       maintainability
+ *       readability
+ *       external/cert/obligation/rule
+ */
+
+import cpp
+import codingstandards.c.cert
+import codingstandards.cpp.rules.notdistinctidentifier.NotDistinctIdentifier
+
+class ExcessLengthNamesIdentifiersNotDistinctQuery extends NotDistinctIdentifierSharedQuery {
+  ExcessLengthNamesIdentifiersNotDistinctQuery() {
+    this = Declarations2Package::excessLengthNamesIdentifiersNotDistinctQuery()
+  }
+}
diff --git a/c/cert/src/rules/DCL40-C/ExternalIdentifiers.qll b/c/cert/src/rules/DCL40-C/ExternalIdentifiers.qll
@@ -0,0 +1,15 @@
+import cpp
+import codingstandards.cpp.Linkage
+
+class ExternalIdentifiers extends Declaration {
+  ExternalIdentifiers() {
+    hasExternalLinkage(this) and
+    getNamespace() instanceof GlobalNamespace and
+    not this.isFromTemplateInstantiation(_) and
+    not this.isFromUninstantiatedTemplate(_) and
+    not this.hasDeclaringType() and
+    not this instanceof UserType and
+    not this instanceof Operator and
+    not this.hasName("main")
+  }
+}
diff --git a/c/cert/src/rules/DCL40-C/IncompatibleFunctionDeclarations.md b/c/cert/src/rules/DCL40-C/IncompatibleFunctionDeclarations.md
@@ -0,0 +1,16 @@
+# DCL40-C: Do not create incompatible declarations of the same function or object
+
+This query implements the CERT-C rule DCL40-C:
+
+> Do not create incompatible declarations of the same function or object
+## CERT
+
+** REPLACE THIS BY RUNNING THE SCRIPT `scripts/help/cert-help-extraction.py` **
+
+## Implementation notes
+
+None
+
+## References
+
+* CERT-C: [DCL40-C: Do not create incompatible declarations of the same function or object](https://wiki.sei.cmu.edu/confluence/display/c)
diff --git a/c/cert/src/rules/DCL40-C/IncompatibleFunctionDeclarations.ql b/c/cert/src/rules/DCL40-C/IncompatibleFunctionDeclarations.ql
@@ -0,0 +1,45 @@
+/**
+ * @id c/cert/incompatible-function-declarations
+ * @name DCL40-C: Do not create incompatible declarations of the same function or object
+ * @description Declaring incompatible functions, in other words same named function of different
+ *              return types or with different numbers of parameters or parameter types, then
+ *              accessing those functions can lead to undefined behaviour.
+ * @kind problem
+ * @precision high
+ * @problem.severity error
+ * @tags external/cert/id/dcl40-c
+ *       correctness
+ *       maintainability
+ *       readability
+ *       external/cert/obligation/rule
+ */
+
+import cpp
+import codingstandards.c.cert
+import ExternalIdentifiers
+
+//checks if they are incompatible based on return type, number of parameters and parameter types
+predicate checkMatchingFunction(FunctionDeclarationEntry d, FunctionDeclarationEntry d2) {
+  not d.getType() = d2.getType()
+  or
+  not d.getNumberOfParameters() = d2.getNumberOfParameters()
+  or
+  exists(ParameterDeclarationEntry p, ParameterDeclarationEntry p2, int i |
+    d.getParameterDeclarationEntry(i) = p and
+    d2.getParameterDeclarationEntry(i) = p2 and
+    not p.getType() = p2.getType()
+  )
+}
+
+from ExternalIdentifiers d, FunctionDeclarationEntry f1, FunctionDeclarationEntry f2
+where
+  not isExcluded(f1, Declarations2Package::incompatibleFunctionDeclarationsQuery()) and
+  not isExcluded(f2, Declarations2Package::incompatibleFunctionDeclarationsQuery()) and
+  f1 = d.getADeclarationEntry() and
+  f2 = d.getADeclarationEntry() and
+  not f1 = f2 and
+  f1.getLocation().getStartLine() >= f2.getLocation().getStartLine() and
+  f1.getName() = f2.getName() and
+  checkMatchingFunction(f1, f2)
+select f1, "The object $@ is not compatible with re-declaration $@", f1, f1.getName(), f2,
+  f2.getName()
diff --git a/c/cert/src/rules/DCL40-C/IncompatibleObjectDeclarations.md b/c/cert/src/rules/DCL40-C/IncompatibleObjectDeclarations.md
@@ -0,0 +1,18 @@
+# DCL40-C: Do not create incompatible declarations of the same function or object
+
+This query implements the CERT-C rule DCL40-C:
+
+> Do not create incompatible declarations of the same function or object
+
+
+## CERT
+
+** REPLACE THIS BY RUNNING THE SCRIPT `scripts/help/cert-help-extraction.py` **
+
+## Implementation notes
+
+None
+
+## References
+
+* CERT-C: [DCL40-C: Do not create incompatible declarations of the same function or object](https://wiki.sei.cmu.edu/confluence/display/c)
diff --git a/c/cert/src/rules/DCL40-C/IncompatibleObjectDeclarations.ql b/c/cert/src/rules/DCL40-C/IncompatibleObjectDeclarations.ql
@@ -0,0 +1,30 @@
+/**
+ * @id c/cert/incompatible-object-declarations
+ * @name DCL40-C: Do not create incompatible declarations of the same function or object
+ * @description Declaring incompatible objects, in other words same named objects of different
+ *              types, then accessing those objects can lead to undefined behaviour.
+ * @kind problem
+ * @precision high
+ * @problem.severity error
+ * @tags external/cert/id/dcl40-c
+ *       correctness
+ *       maintainability
+ *       readability
+ *       external/cert/obligation/rule
+ */
+
+import cpp
+import codingstandards.c.cert
+import ExternalIdentifiers
+
+from VariableDeclarationEntry decl1, VariableDeclarationEntry decl2
+where
+  not isExcluded(decl1, Declarations2Package::incompatibleObjectDeclarationsQuery()) and
+  not isExcluded(decl2, Declarations2Package::incompatibleObjectDeclarationsQuery()) and
+  not decl1.getUnspecifiedType() = decl2.getUnspecifiedType() and
+  decl1.getDeclaration() instanceof ExternalIdentifiers and
+  decl2.getDeclaration() instanceof ExternalIdentifiers and
+  decl1.getLocation().getStartLine() >= decl2.getLocation().getStartLine() and
+  decl1.getVariable().getName() = decl2.getVariable().getName()
+select decl1, "The object $@ is not compatible with re-declaration $@", decl1, decl1.getName(),
+  decl2, decl2.getName()
diff --git a/c/cert/test/rules/DCL40-C/ExcessLengthNamesIdentifiersNotDistinct.testref b/c/cert/test/rules/DCL40-C/ExcessLengthNamesIdentifiersNotDistinct.testref
@@ -0,0 +1 @@
+c/common/test/rules/notdistinctidentifier/NotDistinctIdentifier.ql
diff --git a/c/cert/test/rules/DCL40-C/IncompatibleFunctionDeclarations.expected b/c/cert/test/rules/DCL40-C/IncompatibleFunctionDeclarations.expected
@@ -0,0 +1,4 @@
+| test1.c:4:12:4:12 | declaration of f | The object $@ is not compatible with re-declaration $@ | test1.c:4:12:4:12 | declaration of f | f | test.c:4:6:4:6 | definition of f | f |
+| test.c:4:6:4:6 | definition of f | The object $@ is not compatible with re-declaration $@ | test.c:4:6:4:6 | definition of f | f | test1.c:4:12:4:12 | declaration of f | f |
+| test.c:8:6:8:7 | declaration of f1 | The object $@ is not compatible with re-declaration $@ | test.c:8:6:8:7 | declaration of f1 | f1 | test1.c:5:13:5:14 | declaration of f1 | f1 |
+| test.c:9:6:9:7 | definition of f2 | The object $@ is not compatible with re-declaration $@ | test.c:9:6:9:7 | definition of f2 | f2 | test1.c:6:6:6:7 | definition of f2 | f2 |
diff --git a/c/cert/test/rules/DCL40-C/IncompatibleFunctionDeclarations.qlref b/c/cert/test/rules/DCL40-C/IncompatibleFunctionDeclarations.qlref
@@ -0,0 +1 @@
+rules/DCL40-C/IncompatibleFunctionDeclarations.ql
diff --git a/c/cert/test/rules/DCL40-C/IncompatibleObjectDeclarations.expected b/c/cert/test/rules/DCL40-C/IncompatibleObjectDeclarations.expected
@@ -0,0 +1,2 @@
+| test1.c:2:12:2:12 | declaration of i | The object $@ is not compatible with re-declaration $@ | test1.c:2:12:2:12 | declaration of i | i | test.c:1:7:1:7 | definition of i | i |
+| test.c:2:5:2:5 | definition of a | The object $@ is not compatible with re-declaration $@ | test.c:2:5:2:5 | definition of a | a | test1.c:1:13:1:13 | declaration of a | a |
diff --git a/c/cert/test/rules/DCL40-C/IncompatibleObjectDeclarations.qlref b/c/cert/test/rules/DCL40-C/IncompatibleObjectDeclarations.qlref
@@ -0,0 +1 @@
+rules/DCL40-C/IncompatibleObjectDeclarations.ql
diff --git a/c/cert/test/rules/DCL40-C/test.c b/c/cert/test/rules/DCL40-C/test.c
@@ -0,0 +1,10 @@
+short i;                // NON_COMPLIANT
+int a[] = {1, 2, 3, 4}; // NON_COMPLIANT
+
+long f(int a) { // NON_COMPLIANT
+  return a * 2;
+}
+
+void f1(long a); // NON_COMPLIANT
+void f2() {}     // NON_COMPLIANT
+int f3();        // COMPLIANT
diff --git a/c/cert/test/rules/DCL40-C/test1.c b/c/cert/test/rules/DCL40-C/test1.c
@@ -0,0 +1,7 @@
+extern int *a; // NON_COMPLIANT
+extern int i;  // NON_COMPLIANT
+
+extern int f(int a);   // NON_COMPLIANT
+extern void f1(int a); // NON_COMPLIANT
+void f2(int a, ...) {} // NON_COMPLIANT
+int f3();              // COMPLIANT
diff --git a/c/common/test/rules/notdistinctidentifier/NotDistinctIdentifier.expected b/c/common/test/rules/notdistinctidentifier/NotDistinctIdentifier.expected
diff --git a/c/common/test/rules/notdistinctidentifier/NotDistinctIdentifier.ql b/c/common/test/rules/notdistinctidentifier/NotDistinctIdentifier.ql
@@ -0,0 +1,2 @@
+// GENERATED FILE - DO NOT MODIFY
+import codingstandards.cpp.rules.notdistinctidentifier.NotDistinctIdentifier
diff --git a/c/common/test/rules/notdistinctidentifier/test.c b/c/common/test/rules/notdistinctidentifier/test.c
diff --git a/c/misra/test/rules/RULE-5-1/ExternalIdentifiersNotDistinct.qlref b/c/misra/test/rules/RULE-5-1/ExternalIdentifiersNotDistinct.qlref
diff --git a/c/misra/test/rules/RULE-5-1/ExternalIdentifiersNotDistinct.testref b/c/misra/test/rules/RULE-5-1/ExternalIdentifiersNotDistinct.testref
@@ -0,0 +1 @@
+c/common/test/rules/notdistinctidentifier/NotDistinctIdentifier.ql
diff --git a/cpp/common/src/codingstandards/cpp/exclusions/c/Declarations2.qll b/cpp/common/src/codingstandards/cpp/exclusions/c/Declarations2.qll
@@ -5,6 +5,9 @@ import codingstandards.cpp.exclusions.RuleMetadata
 
 newtype Declarations2Query =
   TDeclaringAFlexibleArrayMemberQuery() or
+  TExcessLengthNamesIdentifiersNotDistinctQuery() or
+  TIncompatibleObjectDeclarationsQuery() or
+  TIncompatibleFunctionDeclarationsQuery() or
   TVariablesInsideSwitchStatementQuery()
 
 predicate isDeclarations2QueryMetadata(Query query, string queryId, string ruleId) {
@@ -16,6 +19,30 @@ predicate isDeclarations2QueryMetadata(Query query, string queryId, string ruleI
     "c/cert/declaring-a-flexible-array-member" and
   ruleId = "DCL38-C"
   or
+  query =
+    // `Query` instance for the `excessLengthNamesIdentifiersNotDistinct` query
+    Declarations2Package::excessLengthNamesIdentifiersNotDistinctQuery() and
+  queryId =
+    // `@id` for the `excessLengthNamesIdentifiersNotDistinct` query
+    "c/cert/excess-length-names-identifiers-not-distinct" and
+  ruleId = "DCL40-C"
+  or
+  query =
+    // `Query` instance for the `incompatibleObjectDeclarations` query
+    Declarations2Package::incompatibleObjectDeclarationsQuery() and
+  queryId =
+    // `@id` for the `incompatibleObjectDeclarations` query
+    "c/cert/incompatible-object-declarations" and
+  ruleId = "DCL40-C"
+  or
+  query =
+    // `Query` instance for the `incompatibleFunctionDeclarations` query
+    Declarations2Package::incompatibleFunctionDeclarationsQuery() and
+  queryId =
+    // `@id` for the `incompatibleFunctionDeclarations` query
+    "c/cert/incompatible-function-declarations" and
+  ruleId = "DCL40-C"
+  or
   query =
     // `Query` instance for the `variablesInsideSwitchStatement` query
     Declarations2Package::variablesInsideSwitchStatementQuery() and
@@ -33,6 +60,27 @@ module Declarations2Package {
       TQueryC(TDeclarations2PackageQuery(TDeclaringAFlexibleArrayMemberQuery()))
   }
 
+  Query excessLengthNamesIdentifiersNotDistinctQuery() {
+    //autogenerate `Query` type
+    result =
+      // `Query` type for `excessLengthNamesIdentifiersNotDistinct` query
+      TQueryC(TDeclarations2PackageQuery(TExcessLengthNamesIdentifiersNotDistinctQuery()))
+  }
+
+  Query incompatibleObjectDeclarationsQuery() {
+    //autogenerate `Query` type
+    result =
+      // `Query` type for `incompatibleObjectDeclarations` query
+      TQueryC(TDeclarations2PackageQuery(TIncompatibleObjectDeclarationsQuery()))
+  }
+
+  Query incompatibleFunctionDeclarationsQuery() {
+    //autogenerate `Query` type
+    result =
+      // `Query` type for `incompatibleFunctionDeclarations` query
+      TQueryC(TDeclarations2PackageQuery(TIncompatibleFunctionDeclarationsQuery()))
+  }
+
   Query variablesInsideSwitchStatementQuery() {
     //autogenerate `Query` type
     result =
diff --git a/cpp/common/src/codingstandards/cpp/rules/notdistinctidentifier/NotDistinctIdentifier.qll b/cpp/common/src/codingstandards/cpp/rules/notdistinctidentifier/NotDistinctIdentifier.qll
@@ -0,0 +1,15 @@
+/**
+ * Provides a library which includes a `problems` predicate for reporting....
+ */
+
+import cpp
+import codingstandards.cpp.Customizations
+import codingstandards.cpp.Exclusions
+
+abstract class NotDistinctIdentifierSharedQuery extends Query { }
+
+Query getQuery() { result instanceof NotDistinctIdentifierSharedQuery }
+
+query predicate problems(Element e, string message) {
+not isExcluded(e, getQuery()) and message = "<replace with problem alert message for >"
+}
diff --git a/rule_packages/c/Declarations1.json b/rule_packages/c/Declarations1.json
@@ -86,6 +86,7 @@
           "precision": "very-high",
           "severity": "warning",
           "short_name": "ExternalIdentifiersNotDistinct",
+          "shared_implementation_short_name": "NotDistinctIdentifier",
           "tags": [
             "correctness",
             "maintainability",
diff --git a/rule_packages/c/Declarations2.json b/rule_packages/c/Declarations2.json
diff --git a/rules.csv b/rules.csv

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	`+c/common/test/rules/notdistinctidentifier/NotDistinctIdentifier.ql`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	`+rules/DCL40-C/IncompatibleFunctionDeclarations.ql`