Modules: Rename ModuleBuildFailed => DisableGeneratingGlobalModuleIndex, NFC

[dexonsmith]

Summary

Rename CompilerInstance's ModuleBuildFailed field to
DisableGeneratingGlobalModuleIndex, which more precisely describes its
role. Otherwise, it's hard to suss out how it's different from
ModuleLoader::HadFatalFailure, and what sort of code simplifications are
safe.

[jansvoboda11]

LGTM.

clang/include/clang/Frontend/CompilerInstance.h

class CompilerInstance : public ModuleLoader {
   /// Whether we should (re)build the global module index once we
   /// have finished with this translation unit.
   bool BuildGlobalModuleIndex = false;
 
   /// We have a full global module index, with all modules.
   bool HaveFullGlobalModuleIndex = false;
 
   /// One or more modules failed to build.
-  bool ModuleBuildFailed = false;
+  bool DisableGeneratingGlobalModuleIndex = false;
 
   /// The stream for verbose output if owned, otherwise nullptr.
   std::unique_ptr<raw_ostream> OwnedVerboseOutputStream;
 
   /// The stream for verbose output.
   raw_ostream *VerboseOutputStream = &llvm::errs();
 
   /// Holds information about the output file.

clang/lib/Frontend/CompilerInstance.cpp

void CompilerInstance::setInvocation(
     std::shared_ptr<CompilerInvocation> Value) {
   Invocation = std::move(Value);
 }
 
 bool CompilerInstance::shouldBuildGlobalModuleIndex() const {
   return (BuildGlobalModuleIndex ||
           (TheASTReader && TheASTReader->isGlobalIndexUnavailable() &&
            getFrontendOpts().GenerateGlobalModuleIndex)) &&
-         !ModuleBuildFailed;
+         !DisableGeneratingGlobalModuleIndex;
 }
 
 void CompilerInstance::setDiagnostics(DiagnosticsEngine *Value) {
   Diagnostics = Value;
 }
 
 void CompilerInstance::setVerboseOutputStream(raw_ostream &Value) {
   OwnedVerboseOutputStream.reset();
ModuleLoadResult CompilerInstance::findOrCompileModuleAndReadAST(
   // Select the source and filename for loading the named module.
   std::string ModuleFilename;
   ModuleSource Source =
       selectModuleSource(M, ModuleName, ModuleFilename, BuiltModules, HS);
   if (Source == MS_ModuleNotFound) {
     // We can't find a module, error out here.
     getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found)
         << ModuleName << SourceRange(ImportLoc, ModuleNameLoc);
-    ModuleBuildFailed = true;
+    DisableGeneratingGlobalModuleIndex = true;
     return nullptr;
   }
   if (ModuleFilename.empty()) {
     if (M && M->HasIncompatibleModuleFile) {
       // We tried and failed to load a module file for this module. Fall
       // back to textual inclusion for its headers.
       return ModuleLoadResult::ConfigMismatch;
     }
 
     getDiagnostics().Report(ModuleNameLoc, diag::err_module_build_disabled)
         << ModuleName;
-    ModuleBuildFailed = true;
+    DisableGeneratingGlobalModuleIndex = true;
     return nullptr;
   }
 
   // Create an ASTReader on demand.
   if (!getASTReader())
     createASTReader();
 
   // Time how long it takes to load the module.
case ASTReader::Success: {
     M = HS.lookupModule(ModuleName, true, !IsInclusionDirective);
 
     // Check whether M refers to the file in the prebuilt module path.
     if (M && M->getASTFile())
       if (auto ModuleFile = FileMgr->getFile(ModuleFilename))
         if (*ModuleFile == M->getASTFile())
           return M;
 
-    ModuleBuildFailed = true;
+    DisableGeneratingGlobalModuleIndex = true;
     getDiagnostics().Report(ModuleNameLoc, diag::err_module_prebuilt)
         << ModuleName;
     return ModuleLoadResult();
   }
 
   case ASTReader::OutOfDate:
   case ASTReader::Missing:
     // The most interesting case.
     break;
 
   case ASTReader::ConfigurationMismatch:
     if (Source == MS_PrebuiltModulePath)
       // FIXME: We shouldn't be setting HadFatalFailure below if we only
       // produce a warning here!
       getDiagnostics().Report(SourceLocation(),
                               diag::warn_module_config_mismatch)
           << ModuleFilename;
     // Fall through to error out.
     LLVM_FALLTHROUGH;
   case ASTReader::VersionMismatch:
   case ASTReader::HadErrors:
-    // FIXME: Should this set ModuleBuildFailed = true?
+    // FIXME: Should this set DisableGeneratingGlobalModuleIndex = true?
     ModuleLoader::HadFatalFailure = true;
     // FIXME: The ASTReader will already have complained, but can we shoehorn
     // that diagnostic information into a more useful form?
     return ModuleLoadResult();
 
   case ASTReader::Failure:
-    // FIXME: Should this set ModuleBuildFailed = true?
+    // FIXME: Should this set DisableGeneratingGlobalModuleIndex = true?
     ModuleLoader::HadFatalFailure = true;
     return ModuleLoadResult();
   }
 
   // ReadAST returned Missing or OutOfDate.
   if (Source != MS_ModuleCache) {
     // We don't know the desired configuration for this module and don't
     // necessarily even have a module map. Since ReadAST already produces
     // diagnostics for these two cases, we simply error out here.
-    ModuleBuildFailed = true;
+    DisableGeneratingGlobalModuleIndex = true;
     return ModuleLoadResult();
   }
 
   // The module file is missing or out-of-date. Build it.
   assert(M && "missing module, but trying to compile for cache");
 
   // Check whether there is a cycle in the module graph.
   ModuleBuildStack ModPath = getSourceManager().getModuleBuildStack();
   ModuleBuildStack::iterator Pos = ModPath.begin(), PosEnd = ModPath.end();
   for (; Pos != PosEnd; ++Pos) {
     if (Pos->first == ModuleName)
       break;
   }
 
   if (Pos != PosEnd) {
     SmallString<256> CyclePath;
     for (; Pos != PosEnd; ++Pos) {
       CyclePath += Pos->first;
       CyclePath += " -> ";
     }
     CyclePath += ModuleName;
 
     getDiagnostics().Report(ModuleNameLoc, diag::err_module_cycle)
         << ModuleName << CyclePath;
-    // FIXME: Should this set ModuleBuildFailed = true?
+    // FIXME: Should this set DisableGeneratingGlobalModuleIndex = true?
     return nullptr;
   }
 
   // Check whether we have already attempted to build this module (but
   // failed).
   if (getPreprocessorOpts().FailedModules &&
       getPreprocessorOpts().FailedModules->hasAlreadyFailed(ModuleName)) {
     getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_built)
         << ModuleName << SourceRange(ImportLoc, ModuleNameLoc);
-    ModuleBuildFailed = true;
+    DisableGeneratingGlobalModuleIndex = true;
     return nullptr;
   }
 
   // Try to compile and then read the AST.
   if (!compileModuleAndReadAST(*this, ImportLoc, ModuleNameLoc, M,
                                ModuleFilename)) {
     assert(getDiagnostics().hasErrorOccurred() &&
            "undiagnosed error in compileModuleAndReadAST");
     if (getPreprocessorOpts().FailedModules)
       getPreprocessorOpts().FailedModules->addFailed(ModuleName);
-    ModuleBuildFailed = true;
+    DisableGeneratingGlobalModuleIndex = true;
     return nullptr;
   }
 
   // Okay, we've rebuilt and now loaded the module.
   return M;
 }
 
 ModuleLoadResult
if (auto MaybeModule = MM.getCachedModuleLoad(*Path[0].first)) {
     Module = PP->getHeaderSearchInfo().lookupModule(
         ModuleName, /*AllowSearch*/ true,
         /*AllowExtraModuleMapSearch*/ !IsInclusionDirective);
     /// FIXME: perhaps we should (a) look for a module using the module name
     //  to file map (PrebuiltModuleFiles) and (b) diagnose if still not found?
     //if (Module == nullptr) {
     //  getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found)
     //    << ModuleName;
-    //  ModuleBuildFailed = true;
+    //  DisableGeneratingGlobalModuleIndex = true;
     //  return ModuleLoadResult();
     //}
     MM.cacheModuleLoad(*Path[0].first, Module);
   } else {
     ModuleLoadResult Result = findOrCompileModuleAndReadAST(
         ModuleName, ImportLoc, ModuleNameLoc, IsInclusionDirective);
-    // FIXME: Can we pull 'ModuleBuildFailed = true' out of the return
-    // sequences for findOrCompileModuleAndReadAST and do it here (as long as
-    // the result is not a config mismatch)?  See FIXMEs there.
+    // FIXME: Can we pull 'DisableGeneratingGlobalModuleIndex = true' out of
+    // the return sequences for findOrCompileModuleAndReadAST and do it here
+    // (as long as the result is not a config mismatch)?  See FIXMEs there.
     if (!Result.isNormal())
       return Result;
     Module = Result;
     MM.cacheModuleLoad(*Path[0].first, Module);
   }
 
   // If we never found the module, fail.  Otherwise, verify the module and link
   // it up.