My clang now doesn't complain about !"foo".

tools/flags/SkCommandLineFlags.h

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SK_COMMAND_LINE_FLAGS_H
 #define SK_COMMAND_LINE_FLAGS_H
 
@@ skipping 286 matching lines @@
      *      --name=FALSE
      */
     bool match(const char* string);
 
     FlagTypes getFlagType() const { return fFlagType; }
 
     void resetStrings() {
         if (kString_FlagType == fFlagType) {
             fStrings->reset();
         } else {
-            SkASSERT(!"Can only call resetStrings on kString_FlagType");
+            SkDEBUGFAIL("Can only call resetStrings on kString_FlagType");
         }
     }
 
     void append(const char* string) {
         if (kString_FlagType == fFlagType) {
             fStrings->append(string);
         } else {
-            SkASSERT(!"Can only append to kString_FlagType");
+            SkDEBUGFAIL("Can only append to kString_FlagType");
         }
     }
 
     void setInt(int32_t value) {
         if (kInt_FlagType == fFlagType) {
             *fIntValue = value;
         } else {
-            SkASSERT(!"Can only call setInt on kInt_FlagType");
+            SkDEBUGFAIL("Can only call setInt on kInt_FlagType");
         }
     }
 
     void setDouble(double value) {
         if (kDouble_FlagType == fFlagType) {
             *fDoubleValue = value;
         } else {
-            SkASSERT(!"Can only call setDouble on kDouble_FlagType");
+            SkDEBUGFAIL("Can only call setDouble on kDouble_FlagType");
         }
     }
 
     void setBool(bool value) {
         if (kBool_FlagType == fFlagType) {
             *fBoolValue = value;
         } else {
-            SkASSERT(!"Can only call setBool on kBool_FlagType");
+            SkDEBUGFAIL("Can only call setBool on kBool_FlagType");
         }
     }
 
     SkFlagInfo* next() { return fNext; }
 
     const SkString& name() const { return fName; }
 
     const SkString& shortName() const { return fShortName; }
 
     const SkString& help() const { return fHelpString; }
 
     SkString defaultValue() const {
         SkString result;
         switch (fFlagType) {
             case SkFlagInfo::kBool_FlagType:
                 result.printf("%s", fDefaultBool ? "true" : "false");
                 break;
             case SkFlagInfo::kString_FlagType:
                 return fDefaultString;
             case SkFlagInfo::kInt_FlagType:
                 result.printf("%i", fDefaultInt);
                 break;
             case SkFlagInfo::kDouble_FlagType:
                 result.printf("%2.2f", fDefaultDouble);
                 break;
             default:
-                SkASSERT(!"Invalid flag type");
+                SkDEBUGFAIL("Invalid flag type");
         }
         return result;
     }
 
     SkString typeAsString() const {
         switch (fFlagType) {
             case SkFlagInfo::kBool_FlagType:
                 return SkString("bool");
             case SkFlagInfo::kString_FlagType:
                 return SkString("string");
             case SkFlagInfo::kInt_FlagType:
                 return SkString("int");
             case SkFlagInfo::kDouble_FlagType:
                 return SkString("double");
             default:
-                SkASSERT(!"Invalid flag type");
+                SkDEBUGFAIL("Invalid flag type");
                 return SkString();
         }
     }
 
 private:
     SkFlagInfo(const char* name, const char* shortName, FlagTypes type, const char* helpString)
         : fName(name)
         , fShortName(shortName)
         , fFlagType(type)
         , fHelpString(helpString)
@@ skipping 31 matching lines @@
     double*              fDoubleValue;
     double               fDefaultDouble;
     SkCommandLineFlags::StringArray* fStrings;
     // Both for the help string and in case fStrings is empty.
     SkString             fDefaultString;
 
     // In order to keep a linked list.
     SkFlagInfo*          fNext;
 };
 #endif // SK_COMMAND_LINE_FLAGS_H