replace require with the new ASSERT macro

Author: eeckstein

include/swift/Basic/Require.h

@@ -17,7 +17,7 @@
 #ifndef SWIFT_SIL_SILBITFIELD_H
 #define SWIFT_SIL_SILBITFIELD_H
 
-#include "swift/Basic/Require.h"
+#include "swift/Basic/Assertions.h"
 #include "swift/SIL/SILFunction.h"
 
 namespace swift {
@@ -56,12 +56,12 @@ template <class Impl, class T> class SILBitfield {
       parent(parent),
       function(function) {
     assert(size > 0 && "bit field size must be > 0");
-    require(endBit <= T::numCustomBits,
-            "too many/large bit fields allocated in function");
-    assert((!parent || bitfieldID > parent->bitfieldID) &&
+    ASSERT(endBit <= T::numCustomBits &&
+           "too many/large bit fields allocated in function");
+    ASSERT((!parent || bitfieldID > parent->bitfieldID) &&
            "BasicBlockBitfield indices are not in order");
-    require(function->currentBitfieldID < T::maxBitfieldID,
-            "currentBitfieldID overflow");
+    ASSERT(function->currentBitfieldID < T::maxBitfieldID &&
+           "currentBitfieldID overflow");
     ++function->currentBitfieldID;
   }
 

include/swift/SIL/SILBitfield.h

@@ -60,7 +60,6 @@
 #include "swift/AST/ProtocolConformance.h"
 #include "swift/AST/SubstitutionMap.h"
 #include "swift/Basic/Assertions.h"
-#include "swift/Basic/Require.h"
 #include "swift/ClangImporter/ClangModule.h"
 #include "swift/SIL/FormalLinkage.h"
 #include "swift/Serialization/SerializedSILLoader.h"
@@ -76,20 +75,20 @@ STATISTIC(NumFuncLinked, "Number of SIL functions linked");
 //===----------------------------------------------------------------------===//
 
 void SILLinkerVisitor::deserializeAndPushToWorklist(SILFunction *F) {
-  assert(F->isExternalDeclaration());
+  ASSERT(F->isExternalDeclaration());
 
   LLVM_DEBUG(llvm::dbgs() << "Imported function: "
                           << F->getName() << "\n");
   SILFunction *NewF =
     Mod.getSILLoader()->lookupSILFunction(F, /*onlyUpdateLinkage*/ false);
-  assert(!NewF || NewF == F);
+  ASSERT(!NewF || NewF == F);
   if (!NewF || F->isExternalDeclaration()) {
-    assert((!hasSharedVisibility(F->getLinkage()) || F->hasForeignBody()) &&
+    ASSERT((!hasSharedVisibility(F->getLinkage()) || F->hasForeignBody()) &&
            "cannot deserialize shared function");
     return;
   }
 
-  assert(!F->isAnySerialized() == Mod.isSerialized() &&
+  ASSERT(!F->isAnySerialized() == Mod.isSerialized() &&
          "the de-serializer did set the wrong serialized flag");
 
   F->setBare(IsBare);
@@ -103,9 +102,9 @@ void SILLinkerVisitor::deserializeAndPushToWorklist(SILFunction *F) {
 void SILLinkerVisitor::maybeAddFunctionToWorklist(
     SILFunction *F, SerializedKind_t callerSerializedKind) {
   SILLinkage linkage = F->getLinkage();
-  require(callerSerializedKind == IsNotSerialized ||
+  ASSERT((callerSerializedKind == IsNotSerialized ||
             F->hasValidLinkageForFragileRef(callerSerializedKind) ||
-            hasSharedVisibility(linkage) || F->isExternForwardDeclaration(),
+            hasSharedVisibility(linkage) || F->isExternForwardDeclaration()) &&
          "called function has wrong linkage for serialized function");
   if (!F->isExternalDeclaration()) {
     // The function is already in the module, so no need to de-serialized it.
@@ -175,7 +174,7 @@ void SILLinkerVisitor::linkInVTable(ClassDecl *D) {
   // vtables that might have shared linkage yet, so this is only needed in
   // the performance pipeline to deserialize more functions early, and expose
   // optimization opportunities.
-  assert(isLinkAll());
+  ASSERT(isLinkAll());
 
   // Attempt to lookup the Vtbl from the SILModule.
   SILVTable *Vtbl = Mod.lookUpVTable(D);

lib/SIL/IR/Linker.cpp

@@ -1422,8 +1422,8 @@ FixedSizeSlab *SwiftPassInvocation::freeSlab(FixedSizeSlab *slab) {
 }
 
 BasicBlockSet *SwiftPassInvocation::allocBlockSet() {
-  require(numBlockSetsAllocated < BlockSetCapacity,
-          "too many BasicBlockSets allocated");
+  ASSERT(numBlockSetsAllocated < BlockSetCapacity &&
+         "too many BasicBlockSets allocated");
 
   auto *storage = (BasicBlockSet *)blockSetStorage + numBlockSetsAllocated;
   BasicBlockSet *set = new (storage) BasicBlockSet(function);
@@ -1446,8 +1446,8 @@ void SwiftPassInvocation::freeBlockSet(BasicBlockSet *set) {
 }
 
 NodeSet *SwiftPassInvocation::allocNodeSet() {
-  require(numNodeSetsAllocated < NodeSetCapacity,
-          "too many NodeSets allocated");
+  ASSERT(numNodeSetsAllocated < NodeSetCapacity &&
+         "too many NodeSets allocated");
 
   auto *storage = (NodeSet *)nodeSetStorage + numNodeSetsAllocated;
   NodeSet *set = new (storage) NodeSet(function);
@@ -1470,8 +1470,8 @@ void SwiftPassInvocation::freeNodeSet(NodeSet *set) {
 }
 
 OperandSet *SwiftPassInvocation::allocOperandSet() {
-  require(numOperandSetsAllocated < OperandSetCapacity,
-          "too many OperandSets allocated");
+  ASSERT(numOperandSetsAllocated < OperandSetCapacity &&
+         "too many OperandSets allocated");
 
   auto *storage = (OperandSet *)operandSetStorage + numOperandSetsAllocated;
   OperandSet *set = new (storage) OperandSet(function);

lib/SILOptimizer/PassManager/PassManager.cpp

@@ -15,7 +15,6 @@
 #include "swift/SILOptimizer/Utils/PerformanceInlinerUtils.h"
 #include "swift/AST/Module.h"
 #include "swift/Basic/Assertions.h"
-#include "swift/Basic/Require.h"
 #include "swift/SILOptimizer/Utils/InstOptUtils.h"
 #include "llvm/Support/CommandLine.h"
 
@@ -853,8 +852,8 @@ SILFunction *swift::getEligibleFunction(FullApplySite AI,
         !Callee->hasValidLinkageForFragileRef(Caller->getSerializedKind())) {
       llvm::errs() << "caller: " << Caller->getName() << "\n";
       llvm::errs() << "callee: " << Callee->getName() << "\n";
-      require(false, "Should never be inlining a resilient function into "
-                     "a fragile function");
+      ASSERT(false && "Should never be inlining a resilient function into "
+                      "a fragile function");
     }
     return nullptr;
   }