Don't add implicit cast constraints to void* arguments (#676)

* avoid adding extra constraint when casting arguments to void

* add test

* more precise test name

Author: kyleheadley

clang/lib/3C/CastPlacement.cpp

@@ -66,6 +66,10 @@ bool CastPlacementVisitor::VisitCallExpr(CallExpr *CE) {
 
       CVarSet ArgConstraints = CR.getExprConstraintVarsSet(ArgExpr);
       for (auto *ArgC : ArgConstraints) {
+        // If the function takes a void *, we already know about the wildness,
+        // so allow the implicit cast.
+        if (TypeVar == nullptr && FV->getExternalParam(PIdx)->isVoidPtr())
+          continue;
         CastNeeded CastKind = needCasting(
             ArgC, ArgC, FV->getInternalParam(PIdx), FV->getExternalParam(PIdx));
         if (CastKind != NO_CAST) {

clang/lib/3C/ConstraintBuilder.cpp

@@ -239,12 +239,11 @@ class FunctionVisitor : public RecursiveASTVisitor<FunctionVisitor> {
           for (const auto &A : E->arguments()) {
             CSetBkeyPair ArgumentConstraints;
             if (I < TargetFV->numParams()) {
-              // Remove casts to void* on polymorphic types that are used
-              // consistently.
-              const int TyIdx =
-                  TargetFV->getExternalParam(I)->getGenericIndex();
-              if (ConsistentTypeParams.find(TyIdx) !=
-                  ConsistentTypeParams.end())
+              // When the function has a void* parameter, Clang will
+              // add an implicit cast to void* here. Generating constraints
+              // will add an extraneous wild constraint to void*. This
+              // unnecessarily complicates results and root causes.
+              if (TargetFV->getExternalParam(I)->isVoidPtr())
                 ArgumentConstraints =
                     CB.getExprConstraintVars(A->IgnoreImpCasts());
               else

clang/test/3C/implicit_casts_root_cause.c

@@ -0,0 +1,26 @@
+// RUN: 3c -base-dir=%S -alltypes -warn-root-cause %s -- -Xclang -verify -Wno-everything
+
+// This test checks that void* casts of arguments are ignored by the root
+// cause code (and handled by the function parameter causes), but other casts
+// are still noted.
+
+void has_void(void* v); // expected-warning {{3 unchecked pointers: Default void* type}}
+void test_no_cause() {
+  int *b, *c;
+  has_void(b); // specifically no warning here, since it shows up above
+  has_void(c);
+}
+
+void has_float(float* v); // expected-warning {{Unchecked pointer in parameter or return of external function has_float}}
+void test_float_cause() {
+  int *b, *c;
+  has_float(b); // expected-warning {{1 unchecked pointer: Cast from int * to float *}}
+  has_float(c); // expected-warning {{1 unchecked pointer: Cast from int * to float *}}
+}
+
+void has_body(float* v){}
+void test_only_args_cause() {
+  int *b, *c;
+  has_body(b); // expected-warning {{1 unchecked pointer: Cast from int * to float *}}
+  has_body(c); // expected-warning {{1 unchecked pointer: Cast from int * to float *}}
+}