clang-format: Add option to disable fallback

[ono]

Summary

From command perspective -no-fallback may be used to indicate that file shall
be not re-formatted if no valid style specified by -style was found.

From API perspective added in,out Fallback parameter indicating if fallback is
desired and if it was used when resolving style.

[djasper]

include/clang/Format/Format.h

494

I still disagree. Use two parameters instead (or return an std::pair<FormatStyle, bool>).

Or maybe even better. Add a style option (DontFormat) and return a format style that sets it to true. That way, one can even explicitly set that in the .clang-format file meant to disable formatting (only having an empty file implicitly disable formatting seems a bit counter-intuitive and potentially hard to document/discover).

lib/Format/Format.cpp

1989

This should be upper case according to LLVM naming conventions.

tools/clang-format/ClangFormat.cpp

74

In case you go with the DontFormat suggestion above, do you even need this flag then?

include/clang/Format/Format.h

 /// directory if \c FileName is empty.
 ///
 /// \param[in] StyleName Style name to interpret according to the description
 /// above.
 /// \param[in] FileName Path to start search for .clang-format if \c StyleName
 /// == "file".
 /// \param[in] FallbackStyle The name of a predefined style used to fallback to
 /// in case the style can't be determined from \p StyleName.
+/// \param[in,out] Fallback indicates if fallback style is intended to be used
+/// and if fallback style was returned.
 ///
 /// \returns FormatStyle as specified by \c StyleName. If no style could be
 /// determined, the default is LLVM Style (see getLLVMStyle()).
 FormatStyle getStyle(StringRef StyleName, StringRef FileName,
-                     StringRef FallbackStyle);
+                     StringRef FallbackStyle, bool &Fallback);
 
 } // end namespace format
 } // end namespace clang
 
 #endif // LLVM_CLANG_FORMAT_FORMAT_H

lib/Format/Format.cpp

static FormatStyle::LanguageKind getLanguageByFileName(StringRef FileName) {
   } else if (FileName.endswith_lower(".proto") ||
              FileName.endswith_lower(".protodevel")) {
     return FormatStyle::LK_Proto;
   }
   return FormatStyle::LK_Cpp;
 }
 
 FormatStyle getStyle(StringRef StyleName, StringRef FileName,
-                     StringRef FallbackStyle) {
+                     StringRef FallbackStyle, bool &Fallback) {
   FormatStyle Style = getLLVMStyle();
   Style.Language = getLanguageByFileName(FileName);
   if (!getPredefinedStyle(FallbackStyle, Style.Language, &Style)) {
     llvm::errs() << "Invalid fallback style \"" << FallbackStyle
                  << "\" using LLVM style\n";
+    Fallback = true;
     return Style;
   }
 
   if (StyleName.startswith("{")) {
     // Parse YAML/JSON style from the command line.
-    if (llvm::error_code ec = parseConfiguration(StyleName, &Style)) {
+    llvm::error_code ec = parseConfiguration(StyleName, &Style);
+    if ((Fallback = !!ec)) {
       llvm::errs() << "Error parsing -style: " << ec.message() << ", using "
                    << FallbackStyle << " style\n";
     }
     return Style;
   }
 
   if (!StyleName.equals_lower("file")) {
-    if (!getPredefinedStyle(StyleName, Style.Language, &Style))
+    if ((Fallback = !getPredefinedStyle(StyleName, Style.Language, &Style))) {
       llvm::errs() << "Invalid value for -style, using " << FallbackStyle
                    << " style\n";
+    }
     return Style;
   }
 
   // Look for .clang-format/_clang-format file in the file's parent directories.
   SmallString<128> UnsuitableConfigFiles;
   SmallString<128> Path(FileName);
   llvm::sys::fs::make_absolute(Path);
   for (StringRef Directory = Path; !Directory.empty();
if (IsFile) {
       }
       if (llvm::error_code ec = parseConfiguration(Text->getBuffer(), &Style)) {
         if (ec == llvm::errc::not_supported) {
           if (!UnsuitableConfigFiles.empty())
             UnsuitableConfigFiles.append(", ");
           UnsuitableConfigFiles.append(ConfigFile);
           continue;
         }
+        if (Fallback) {
           llvm::errs() << "Error reading " << ConfigFile << ": " << ec.message()
                        << "\n";
+        }
         break;
       }
       DEBUG(llvm::dbgs() << "Using configuration file " << ConfigFile << "\n");
+      Fallback = false;
       return Style;
     }
   }
+  if (Fallback) {
     llvm::errs() << "Can't find usable .clang-format, using " << FallbackStyle
                  << " style\n";
+  }
+  Fallback = true;
   if (!UnsuitableConfigFiles.empty()) {
     llvm::errs() << "Configuration file(s) do(es) not support "
                  << getLanguageName(Style.Language) << ": "
                  << UnsuitableConfigFiles << "\n";
   }
   return Style;
 }
 
 } // namespace format
 } // namespace clang

tools/clang-format/ClangFormat.cpp

 static cl::opt<std::string>
 FallbackStyle("fallback-style",
               cl::desc("The name of the predefined style used as a\n"
                        "fallback in case clang-format is invoked with\n"
                        "-style=file, but can not find the .clang-format\n"
                        "file to use."),
               cl::init("LLVM"), cl::cat(ClangFormatCategory));
 
+static cl::opt<bool>
+NoFallback("no-fallback",
+           cl::desc("Skip formatting when style specified with -style\n"
+                    "is not found or is invalid. Empty .clang-format\n"
+                    "file in conjunction with -style=file effectively\n"
+                    "disables formatting inside specific folder."),
+           cl::cat(ClangFormatCategory));
+
 static cl::opt<std::string>
 AssumeFilename("assume-filename",
                cl::desc("When reading from stdin, clang-format assumes this\n"
                         "filename to look for a style config file (with\n"
                         "-style=file)."),
                cl::cat(ClangFormatCategory));
 
 static cl::opt<bool> Inplace("i",
static bool format(StringRef FileName) {
   }
   if (Code->getBufferSize() == 0)
     return false; // Empty files are formatted correctly.
   FileID ID = createInMemoryFile(FileName, Code.get(), Sources, Files);
   std::vector<CharSourceRange> Ranges;
   if (fillRanges(Sources, ID, Code.get(), Ranges))
     return true;
 
-  FormatStyle FormatStyle = getStyle(
-      Style, (FileName == "-") ? AssumeFilename : FileName, FallbackStyle);
+  bool Fallback = !NoFallback;
+  FormatStyle FormatStyle =
+      getStyle(Style, (FileName == "-") ? AssumeFilename : FileName,
+               FallbackStyle, Fallback);
   Lexer Lex(ID, Sources.getBuffer(ID), Sources,
             getFormattingLangOpts(FormatStyle.Standard));
-  tooling::Replacements Replaces = reformat(FormatStyle, Lex, Sources, Ranges);
+  tooling::Replacements Replaces;
+  if (!Fallback || !NoFallback) {
+    Replaces = reformat(FormatStyle, Lex, Sources, Ranges);
+  }
   if (OutputXML) {
     llvm::outs()
         << "<?xml version='1.0'?>\n<replacements xml:space='preserve'>\n";
     for (tooling::Replacements::const_iterator I = Replaces.begin(),
                                                E = Replaces.end();
          I != E; ++I) {
       llvm::outs() << "<replacement "
                    << "offset='" << I->getOffset() << "' "
cl::ParseCommandLineOptions(
       "If <file>s are given, it reformats the files. If -i is specified\n"
       "together with <file>s, the files are edited in-place. Otherwise, the\n"
       "result is written to the standard output.\n");
 
   if (Help)
     cl::PrintHelpMessage();
 
   if (DumpConfig) {
+    bool Fallback = !NoFallback;
     std::string Config =
         clang::format::configurationAsText(clang::format::getStyle(
             Style, FileNames.empty() ? AssumeFilename : FileNames[0],
-            FallbackStyle));
+            FallbackStyle, Fallback));
     llvm::outs() << Config << "\n";
     return 0;
   }
 
   bool Error = false;
   switch (FileNames.size()) {
   case 0:
     Error = clang::format::format("-");