[Diagnostics] Address of a standard library function

[xbolva00]

Summary

"Taking the address of a standard library function is not allowed" - https://usingstdcpp.org/2018/03/18/jacksonville18-iso-cpp-report/

[xbolva00]

Removed extra new line, changed test

[xbolva00]

Ping

include/clang/Basic/DiagnosticGroups.td

 def UnreachableCodeAggressive : DiagGroup<"unreachable-code-aggressive",
                                     [UnreachableCode,
                                      UnreachableCodeBreak,
                                      UnreachableCodeReturn]>;
 
 // Aggregation warning settings.
 
 // Populate -Waddress with warnings from other groups.
-def : DiagGroup<"address", [PointerBoolConversion,
+def Address : DiagGroup<"address", [PointerBoolConversion,
                             StringCompare,
                             TautologicalPointerCompare]>;
 
 // -Widiomatic-parentheses contains warnings about 'idiomatic'
 // missing parentheses;  it is off by default.  We do not include it
 // in -Wparentheses because most users who use -Wparentheses explicitly
 // do not want these warnings.
 def ParenthesesOnEquality : DiagGroup<"parentheses-equality">;

include/clang/Basic/DiagnosticSemaKinds.td

 
 def err_no_typeid_with_fno_rtti : Error<
   "use of typeid requires -frtti">;
 def err_no_dynamic_cast_with_fno_rtti : Error<
   "use of dynamic_cast requires -frtti">;
 
 def err_cannot_form_pointer_to_member_of_reference_type : Error<
   "cannot form a pointer-to-member to member %0 of reference type %1">;
+def warn_taking_address_standard_library_function : Warning<
+  "taking the address of the standard library function '%0' is not allowed">
+  , InGroup<Address>;
 def err_incomplete_object_call : Error<
   "incomplete type in call to object of type %0">;
 
 def warn_condition_is_assignment : Warning<"using the result of an "
   "assignment as a condition without parentheses">,
   InGroup<Parentheses>;
 // Completely identical except off by default.
 def warn_condition_is_idiomatic_assignment : Warning<"using the result "

lib/Sema/SemaExpr.cpp

QualType Sema::CheckAddressOfOperand(ExprResult &OrigOp, SourceLocation OpLoc) {
 
   if (auto *FD = dyn_cast_or_null<FunctionDecl>(dcl))
     if (!checkAddressOfFunctionIsAvailable(FD, /*Complain=*/true,
                                            op->getBeginLoc()))
       return QualType();
 
   Expr::LValueClassification lval = op->ClassifyLValue(Context);
   unsigned AddressOfError = AO_No_Error;
-
   if (lval == Expr::LV_ClassTemporary || lval == Expr::LV_ArrayTemporary) {
     bool sfinae = (bool)isSFINAEContext();
     Diag(OpLoc, isSFINAEContext() ? diag::err_typecheck_addrof_temporary
                                   : diag::ext_typecheck_addrof_temporary)
       << op->getType() << op->getSourceRange();
     if (sfinae)
       return QualType();
     // Materialize the temporary as an lvalue so that we can take its address.
if (const VarDecl *vd = dyn_cast<VarDecl>(dcl)) {
               op->getType(),
               Context.getTypeDeclType(cast<RecordDecl>(Ctx)).getTypePtr());
           // Under the MS ABI, lock down the inheritance model now.
           if (Context.getTargetInfo().getCXXABI().isMicrosoft())
             (void)isCompleteType(OpLoc, MPTy);
           return MPTy;
         }
       }
-    } else if (!isa<FunctionDecl>(dcl) && !isa<NonTypeTemplateParmDecl>(dcl) &&
-               !isa<BindingDecl>(dcl))
+    } else if (isa<FunctionDecl>(dcl)) {
+      StringRef QualName =  cast<FunctionDecl>(dcl)->getQualifiedNameAsString();
+      if (QualName.startswith("std::"))
+        Diag(OpLoc, diag::warn_taking_address_standard_library_function) << QualName;
+    } else if (!isa<NonTypeTemplateParmDecl>(dcl) && !isa<BindingDecl>(dcl))
       llvm_unreachable("Unknown/unexpected decl type");
   }
 
   if (AddressOfError != AO_No_Error) {
     diagnoseAddressOfInvalidType(*this, OpLoc, op, AddressOfError);
     return QualType();
   }
 

test/SemaCXX/warn_address_standard_library_function.cpp

+// RUN: %clang_cc1 -fsyntax-only -verify -Waddress -std=c++14 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -Waddress -std=c++17 %s
+
+namespace std {
+    void foo (void) { }
+}
+
+namespace mystd {
+    void foo (void) { }
+}
+
+auto warn1(void) {
+    return &std::foo; // expected-warning{{taking the address of the standard library function 'std::foo' is not allowed}}
+}
+
+auto warn2(void) {
+    return &(std::foo); // expected-warning{{taking the address of the standard library function 'std::foo' is not allowed}}
+}
+
+auto nowarn1(void) {
+    return &mystd::foo;
+}
+
+auto nowarn2(void) {
+    return &(mystd::foo);
+}