-Wformat-nonliteral should not trigger for format strings passed to blocks with __attribute__((format))

[fcloutier]

Summary

The checker that implements -Wformat-nonliteral does not understand __attribute__((format)) on blocks in the same way that it understands it on functions. This works just fine (assuming #define __printflike(A, B) __attribute__((format(printf, A, B)))):

void printfblock(const char *fmt, ...) __printflike(1, 2) {
	va_list ap;
	va_start(ap, fmt);
	vprintf(fmt, ap);
	va_end(ap);
}

void foo(void) {
	printfblock("%s %i\n", "hello", 1);
}

However, this incorrectly triggers -Wformat-nonliteral:

void foo(void) {
	void (^printfblock)(const char *fmt, ...) __printflike(1, 2) = ^(const char *fmt, ...) __printflike(1, 2) {
		va_list ap;
		va_start(ap, fmt);
		vprintf(fmt, ap); // warning: format string is not a string literal [-Wformat-nonliteral]
		va_end(ap);
	};
	
	printfblock("%s %i\n", "hello", 1);
}

This patch updates checkFormatStringExpr so that it can look through BlockDecls and find out which parameter is identified as a format string.

rdar://84603673

[NoQ]

clang/lib/Sema/SemaChecking.cpp

7787

This code now says that all block parameters have index 1 because blocks aren't named(?) I don't think this is correct. I also don't see why this cast is necessary in the first place. The only place where ND is used is the cast into MD which might as well be performed on D directly.

[fcloutier]

Thanks Artem for pointing out that I was completely misusing getFunctionScopeIndex. This should be better. I added a test that you can pick a non-1 value for the format parameter in blocks.

[ahatanak]

clang/lib/Sema/SemaChecking.cpp

7792

Isn't changing dyn_cast<NamedDecl to dyn_cast<Decl> enough to avoid the warning? Just wondering why it is also necessary to move the above code out of the for loop. Actually, it's not clear to me why PVIndex had to be incremented in the loop in the first place.

[ahatanak]

LGTM

clang/lib/Sema/SemaChecking.cpp

if (const VarDecl *VD = dyn_cast<VarDecl>(DR->getDecl())) {
       // logmessage(char const *fmt __attribute__ (format (printf, 1, 2)), ...){
       //      va_list ap;
       //      va_start(ap, fmt);
       //      vprintf(fmt, ap);  // Do NOT emit a warning about "fmt".
       //      ...
       // }
       if (HasVAListArg) {
         if (const ParmVarDecl *PV = dyn_cast<ParmVarDecl>(VD)) {
-          if (const NamedDecl *ND = dyn_cast<NamedDecl>(PV->getDeclContext())) {
+          if (const Decl *D = dyn_cast<Decl>(PV->getDeclContext())) {
             int PVIndex = PV->getFunctionScopeIndex() + 1;
-            for (const auto *PVFormat : ND->specific_attrs<FormatAttr>()) {
+            for (const auto *PVFormat : D->specific_attrs<FormatAttr>()) {
               // adjust for implicit parameter
-              if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(ND))
+              if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D))
                 if (MD->isInstance())
                   ++PVIndex;
               // We also check if the formats are compatible.
               // We can't pass a 'scanf' string to a 'printf' function.
               if (PVIndex == PVFormat->getFormatIdx() &&
                   Type == S.GetFormatStringType(PVFormat))
                 return SLCT_UncheckedLiteral;
             }
           }
         }
       }
     }
 

clang/test/Sema/format-strings.c

-// RUN: %clang_cc1 -fsyntax-only -verify -Wformat-nonliteral -isystem %S/Inputs %s
-// RUN: %clang_cc1 -fsyntax-only -verify -Wformat-nonliteral -isystem %S/Inputs -fno-signed-char %s
+// RUN: %clang_cc1 -fblocks -fsyntax-only -verify -Wformat-nonliteral -isystem %S/Inputs %s
+// RUN: %clang_cc1 -fblocks -fsyntax-only -verify -Wformat-nonliteral -isystem %S/Inputs -fno-signed-char %s
 
 #include <stdarg.h>
 #include <stddef.h>
 #define __need_wint_t
 #include <stddef.h> // For wint_t and wchar_t
 
 typedef struct _FILE FILE;
 int fprintf(FILE *, const char *restrict, ...);

 void PR30481() {
   // This caused crashes due to invalid casts.
   printf(1 > 0); // expected-warning{{format string is not a string literal}} expected-warning{{incompatible integer to pointer conversion}} expected-note@format-strings.c:*{{passing argument to parameter here}} expected-note{{to avoid this}}
 }
 
 void test_printf_opaque_ptr(void *op) {
   printf("%s", op); // expected-warning{{format specifies type 'char *' but the argument has type 'void *'}}
 }
+
+void test_block() {
+  void __attribute__((__format__(__printf__, 1, 2))) (^printf_arg1)(
+      const char *, ...) =
+      ^(const char *fmt, ...) __attribute__((__format__(__printf__, 1, 2))) {
+    va_list ap;
+    va_start(ap, fmt);
+    vprintf(fmt, ap);
+    va_end(ap);
+  };
+
+  printf_arg1("%s string %i\n", "aaa", 123);
+  printf_arg1("%s string\n", 123); // expected-warning{{format specifies type 'char *' but the argument has type 'int'}}
+
+  void __attribute__((__format__(__printf__, 2, 3))) (^printf_arg2)(
+      const char *, const char *, ...) =
+      ^(const char *not_fmt, const char *fmt, ...)
+          __attribute__((__format__(__printf__, 2, 3))) {
+    va_list ap;
+    va_start(ap, fmt);
+    vprintf(not_fmt, ap); // expected-warning{{format string is not a string literal}}
+    va_end(ap);
+  };
+
+  printf_arg2("foo", "%s string %i\n", "aaa", 123);
+  printf_arg2("%s string\n", "foo", "bar"); // expected-warning{{data argument not used by format string}}
+}