Replace assert(0) with llvm_unreachable.

[rsmith]

LGTM, post-commit review is fine for changes like this.

[v.g.vassilev]

Ok, thanks! I was hesitant for the changes in libclang, because of the return statements.

[rsmith]

You should remove the code after the assert(0), or you'll trigger "unreachable code" warnings.

[v.g.vassilev]

Sure, I can do this, as long as this semantic change is ok.

[dblaikie]

If possible, please upload patches with full context - makes it easier to check around nearby code when reviewing. (the 'arc' tool for phab helps with this)

include/clang/AST/Redeclarable.h

257–261

Branch-to-unreachable is generally to be avoided.

Looks like this code should actually change to:

if (Current->isFirstDecl()) {
  assert(PassedFirst);

Similar comments on many of the other changes here

include/clang/AST/Redeclarable.h

       // Sanity check to avoid infinite loop on invalid redecl chain.
       if (Current->isFirstDecl()) {
         if (PassedFirst) {
-          assert(0 && "Passed first decl twice, invalid redecl chain!");
+          llvm_unreachable("Passed first decl twice, invalid redecl chain!");
           Current = nullptr;
           return *this;
         }

lib/AST/ExprConstant.cpp

     if (!Source)
       return Error(E);
     if (Source == E) { // sanity checking.
-      assert(0 && "OpaqueValueExpr recursively refers to itself");
+      llvm_unreachable("OpaqueValueExpr recursively refers to itself");
       return Error(E);
     }
     return StmtVisitorTy::Visit(Source);

lib/Basic/SourceManager.cpp

 
 void ContentCache::replaceBuffer(llvm::MemoryBuffer *B, bool DoNotFree) {
   if (B && B == Buffer.getPointer()) {
-    assert(0 && "Replacing with the same buffer");
+    llvm_unreachable("Replacing with the same buffer");
     Buffer.setInt(DoNotFree? DoNotFreeFlag : 0);
     return;
   }

 FileID SourceManager::getFileIDLoaded(unsigned SLocOffset) const {
   // Sanity checking, otherwise a bug may lead to hanging in release build.
   if (SLocOffset < CurrentLoadedOffset) {
-    assert(0 && "Invalid SLocOffset or bad function choice");
+    llvm_unreachable("Invalid SLocOffset or bad function choice");
     return FileID();
   }
 

     if (E.getOffset() > SLocOffset) {
       // Sanity checking, otherwise a bug may lead to hanging in release build.
       if (GreaterIndex == MiddleIndex) {
-        assert(0 && "binary search missed the entry");
+        llvm_unreachable("binary search missed the entry");
         return FileID();
       }
       GreaterIndex = MiddleIndex;

 
     // Sanity checking, otherwise a bug may lead to hanging in release build.
     if (LessIndex == MiddleIndex) {
-      assert(0 && "binary search missed the entry");
+      llvm_unreachable("binary search missed the entry");
       return FileID();
     }
     LessIndex = MiddleIndex;

lib/Lex/PreprocessingRecord.cpp

   int Pos = std::distance(iterator(this, 0), PPEI);
   if (Pos < 0) {
     if (unsigned(-Pos-1) >= LoadedPreprocessedEntities.size()) {
-      assert(0 && "Out-of bounds loaded preprocessed entity");
+      llvm_unreachable("Out-of bounds loaded preprocessed entity");
       return false;
     }
     assert(ExternalSource && "No external source to load from");

   }
 
   if (unsigned(Pos) >= PreprocessedEntities.size()) {
-    assert(0 && "Out-of bounds local preprocessed entity");
+    llvm_unreachable("Out-of bounds local preprocessed entity");
     return false;
   }
   return isPreprocessedEntityIfInFileID(PreprocessedEntities[Pos],

lib/Sema/SemaType.cpp

       break;
       #include "clang/Basic/OpenCLImageTypes.def"
     default:
-      assert(0 && "Unable to find corresponding image type.");
+      llvm_unreachable("Unable to find corresponding image type.");
     }
 
     S.Diag(TypedefTy->getDecl()->getLocStart(),

lib/Serialization/ASTReader.cpp

   unsigned Index = ID - NUM_PREDEF_DECL_IDS;
 
   if (Index >= DeclsLoaded.size()) {
-    assert(0 && "declaration ID out-of-range for AST file");
+    llvm_unreachable("declaration ID out-of-range for AST file");
     Error("declaration ID out-of-range for AST file");
     return nullptr;
   }

   unsigned Index = ID - NUM_PREDEF_DECL_IDS;
 
   if (Index >= DeclsLoaded.size()) {
-    assert(0 && "declaration ID out-of-range for AST file");
+    llvm_unreachable("declaration ID out-of-range for AST file");
     Error("declaration ID out-of-range for AST file");
     return nullptr;
   }

lib/Serialization/ASTWriter.cpp

     MacroID ID = MacroInfosToEmit[I].ID;
 
     if (ID < FirstMacroID) {
-      assert(0 && "Loaded MacroInfo entered MacroInfosToEmit ?");
+      llvm_unreachable("Loaded MacroInfo entered MacroInfosToEmit ?");
       continue;
     }
 

     TypeIdx &Idx = TypeIdxs[T];
     if (Idx.getIndex() == 0) {
       if (DoneWritingDeclsAndTypes) {
-        assert(0 && "New type seen after serializing all the types to emit!");
+        llvm_unreachable("New type seen after serializing all the types to emit!");
         return TypeIdx();
       }
 

   DeclID &ID = DeclIDs[D];
   if (ID == 0) {
     if (DoneWritingDeclsAndTypes) {
-      assert(0 && "New decl seen after serializing all the decls to emit!");
+      llvm_unreachable("New decl seen after serializing all the decls to emit!");
       return 0;
     }
 

tools/c-index-test/c-index-test.c

   case CXIdxEntity_CXXTypeAlias: return "type-alias";
   case CXIdxEntity_CXXInterface: return "c++-__interface";
   }
-  assert(0 && "Garbage entity kind");
+  llvm_unreachable("Garbage entity kind");
   return 0;
 }
 

     return "-template-partial-spec";
   case CXIdxEntity_TemplateSpecialization: return "-template-spec";
   }
-  assert(0 && "Garbage entity kind");
+  llvm_unreachable("Garbage entity kind");
   return 0;
 }
 

   case CXIdxEntityLang_CXX: return "C++";
   case CXIdxEntityLang_Swift: return "Swift";
   }
-  assert(0 && "Garbage language kind");
+  llvm_unreachable("Garbage language kind");
   return 0;
 }
 

tools/libclang/CXCursor.cpp

   TemplateArgument TA;
   if (clang_Cursor_getTemplateArgument(C, I, &TA) !=
       CXGetTemplateArgumentStatus_Success) {
-    assert(0 && "Unable to retrieve TemplateArgument");
+    llvm_unreachable("Unable to retrieve TemplateArgument");
     return 0;
   }
 
   if (TA.getKind() != TemplateArgument::Integral) {
-    assert(0 && "Passed template argument is not Integral");
+    llvm_unreachable("Passed template argument is not Integral");
     return 0;
   }
 

   TemplateArgument TA;
   if (clang_Cursor_getTemplateArgument(C, I, &TA) !=
       CXGetTemplateArgumentStatus_Success) {
-    assert(0 && "Unable to retrieve TemplateArgument");
+    llvm_unreachable("Unable to retrieve TemplateArgument");
     return 0;
   }
 
   if (TA.getKind() != TemplateArgument::Integral) {
-    assert(0 && "Passed template argument is not Integral");
+    llvm_unreachable("Passed template argument is not Integral");
     return 0;
   }