[PATCH] Disabling warnings on unused parameters if function is deleted/ defaulted (cxx11) [PR19303]

[dinesh.d]

Summary

if a function is defined out-of-line and marked as deleted/ defaulted [cxx11],
it is handled by Parser::ParseFunctionDefinition( Body = 0). This function calls
Actions.ActOnFinishFunctionBody() which in-turn calls DiagnoseUnusedParameters()
and DiagnoseSizeOfParametersAndReturnValue(). After this, the function attributes
are set to deleted/ defaulted.

For deleted/ defaulted function, as they do not have body to diagnosed against,
DiagnoseXXX calls does not make much sense. I have added a patch with this check
before calling DiagnoseXXX functions.

I have tried other options like, first mark functions as deleted/ defaulted and
then call ActOnFinishFunctionBody() and check if function is marked before calling
DiagnoseXXX functions but it has its own side effects.

Please let me know if this patch is ok.

[dinesh.d]

gentle ping

[rnk]

lib/Sema/SemaDecl.cpp

9926–9927

This comment should be higher level, explaining why it's doing this, not how it's doing it. The code itself is fairly obvious. For example:

// Don't diagnose unused parameters of defaulted or deleted functions.

9930–9931

This might apply to a copy constructor for a large class. Consider:

struct A {
  int a[LARGE];
  A(A a);
};
A::A(A a) = default; // expected-warning {{...}}

[dinesh.d]

Updated as per comment.

Thanks for review

[rnk]

Looks good! Do you need someone to commit it?

[dinesh.d]

Yes, I do not have commit access and need help in committing this.

[dinesh.d]

Thanks for committing this patch (r207672)

lib/Sema/SemaDecl.cpp

if (FD->hasImplicitReturnZero() || FD->hasAttr<NakedAttr>())
       WP.disableCheckFallThrough();
 
     // MSVC permits the use of pure specifier (=0) on function definition,
     // defined at class scope, warn about this non-standard construct.
     if (getLangOpts().MicrosoftExt && FD->isPure() && FD->isCanonicalDecl())
       Diag(FD->getLocation(), diag::warn_pure_function_definition);
 
     if (!FD->isInvalidDecl()) {
+      // Don't diagnose unused parameters of defaulted or deleted functions.
+      if (Body)
         DiagnoseUnusedParameters(FD->param_begin(), FD->param_end());
       DiagnoseSizeOfParametersAndReturnValue(FD->param_begin(), FD->param_end(),
                                              FD->getReturnType(), FD);
 
       // If this is a constructor, we need a vtable.
       if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(FD))
         MarkVTableUsed(FD->getLocation(), Constructor->getParent());
       
       // Try to apply the named return value optimization. We have to check
       // if we can do this here because lambdas keep return statements around
       // to deduce an implicit return type.
       if (getLangOpts().CPlusPlus && FD->getReturnType()->isRecordType() &&
           !FD->isDependentContext())
         computeNRVO(Body, getCurFunction());
     }
     

test/SemaCXX/cxx11-unused.cpp

+// RUN: %clang_cc1 -std=c++11 -verify %s -Wunused-parameter
+
+// PR19303 : Make sure we don't get a unused expression warning for deleted and
+// defaulted functions
+
+// expected-no-diagnostics
+
+class A {
+public:
+  int x;
+  A() = default;
+  ~A() = default;
+  A(const A &other) = delete;
+
+  template <typename T>
+  void SetX(T x) {
+    this->x = x;
+  };
+
+  void SetX1(int x);
+};
+
+template <>
+void A::SetX(A x) = delete;
+
+class B {
+public:
+  B() = default;
+  ~B() = default;
+  B(const B &other);
+};
+
+B::B(const B &other) = default;