Merge pull request swiftlang#74631 from slavapestov/rqm-assertions

RequirementMachine: Convert to new assertions

Author: slavapestov

include/swift/Basic/Assertions.h

@@ -41,13 +41,27 @@
 // that are more expensive than you think.  You can switch those to
 // `CONDITIONAL_ASSERT` or `DEBUG_ASSERT` as needed.
 
+// Visual Studio doesn't have __FILE_NAME__
+#ifdef __FILE_NAME__
+
 #define ASSERT(expr) \
   do { \
-    if (ASSERT_UNLIKELY(!expr)) {			   \
+    if (ASSERT_UNLIKELY(!(expr))) {			   \
       ASSERT_failure(#expr, __FILE_NAME__, __LINE__, __func__); \
     } \
   } while (0)
 
+#else
+
+#define ASSERT(expr) \
+  do { \
+    if (ASSERT_UNLIKELY(!(expr))) {			   \
+      ASSERT_failure(#expr, __FILE__, __LINE__, __func__); \
+    } \
+  } while (0)
+
+#endif
+
 // Function that reports the actual failure when it occurs.
 void ASSERT_failure(const char *expr, const char *file, int line, const char *func);
 

lib/AST/RequirementMachine/ConcreteContraction.cpp

@@ -346,7 +346,7 @@ ConcreteContraction::substTypeParameterRec(Type type, Position position) const {
 /// it is the subject of a conformance requirement.
 Type ConcreteContraction::substTypeParameter(
     Type type, Position position) const {
-  assert(type->isTypeParameter());
+  ASSERT(type->isTypeParameter());
 
   auto result = substTypeParameterRec(type, position);
   if (!result)
@@ -552,13 +552,13 @@ bool ConcreteContraction::performConcreteContraction(
   // subject type is a generic parameter.
   for (auto req : requirements) {
     auto subjectType = req.req.getFirstType();
-    assert(subjectType->isTypeParameter() &&
-           "You forgot to call desugarRequirement()");
+    ASSERT(subjectType->isTypeParameter() &&
+           "Forgot to call desugarRequirement()");
 
     auto kind = req.req.getKind();
     switch (kind) {
     case RequirementKind::SameShape:
-      assert(req.req.getSecondType()->isTypeParameter());
+      ASSERT(req.req.getSecondType()->isTypeParameter());
       continue;
 
     case RequirementKind::SameType: {
@@ -584,8 +584,8 @@ bool ConcreteContraction::performConcreteContraction(
     }
     case RequirementKind::Superclass: {
       auto constraintType = req.req.getSecondType();
-      assert(!constraintType->isTypeParameter() &&
-             "You forgot to call desugarRequirement()");
+      ASSERT(!constraintType->isTypeParameter() &&
+             "Forgot to call desugarRequirement()");
 
       subjectType = stripBoundDependentMemberTypes(subjectType);
       if (typeOccursIn(subjectType,

lib/AST/RequirementMachine/ConcreteTypeWitness.cpp

@@ -124,9 +124,9 @@ void PropertyMap::concretizeNestedTypesFromConcreteParent(
     ArrayRef<Term> substitutions,
     ArrayRef<unsigned> conformsToRules,
     ArrayRef<const ProtocolDecl *> conformsTo) {
-  assert(requirementKind == RequirementKind::SameType ||
+  ASSERT(requirementKind == RequirementKind::SameType ||
          requirementKind == RequirementKind::Superclass);
-  assert(conformsTo.size() == conformsToRules.size());
+  ASSERT(conformsTo.size() == conformsToRules.size());
 
   for (unsigned i : indices(conformsTo)) {
     auto *proto = conformsTo[i];
@@ -227,7 +227,7 @@ void PropertyMap::concretizeTypeWitnessInConformance(
   auto substitutions = concreteConformanceSymbol.getSubstitutions();
 
   auto *proto = assocType->getProtocol();
-  assert(proto == concreteConformanceSymbol.getProtocol());
+  ASSERT(proto == concreteConformanceSymbol.getProtocol());
 
   if (Debug.contains(DebugFlags::ConcretizeNestedTypes)) {
     llvm::dbgs() << "^^ " << "Looking up type witness for "
@@ -284,7 +284,7 @@ void PropertyMap::concretizeTypeWitnessInConformance(
       key, requirementKind, concreteType, typeWitness, subjectType,
       substitutions, path);
 
-  assert(!path.empty());
+  ASSERT(!path.empty());
   (void) System.addRule(constraintType, subjectType, &path);
   if (Debug.contains(DebugFlags::ConcretizeNestedTypes)) {
     llvm::dbgs() << "^^ Induced rule " << constraintType
@@ -411,7 +411,7 @@ MutableTerm PropertyMap::computeConstraintTermForTypeWitness(
       &substPath);
   if (differenceID) {
     const auto &difference = System.getTypeDifference(*differenceID);
-    assert(difference.LHS == typeWitnessSymbol);
+    ASSERT(difference.LHS == typeWitnessSymbol);
     typeWitnessSymbol = difference.RHS;
     substPath.invert();
   }
@@ -599,7 +599,7 @@ void PropertyMap::inferConditionalRequirements(
   builder.initWithConditionalRequirements(desugaredRequirements,
                                           substitutions);
 
-  assert(builder.PermanentRules.empty());
+  ASSERT(builder.PermanentRules.empty());
 
   System.addRules(std::move(builder.ImportedRules),
                   std::move(builder.PermanentRules),

lib/AST/RequirementMachine/Diagnostics.cpp

@@ -203,7 +203,7 @@ bool swift::rewriting::diagnoseRequirementErrors(
       if (requirement.hasError())
         break;
 
-      assert(requirement.getKind() == RequirementKind::SameType ||
+      ASSERT(requirement.getKind() == RequirementKind::SameType ||
              requirement.getKind() == RequirementKind::Superclass);
 
       ctx.Diags.diagnose(loc,
@@ -273,7 +273,7 @@ void RewriteSystem::computeConflictingRequirementDiagnostics(
     const auto &firstRule = getRule(pair.first);
     const auto &secondRule = getRule(pair.second);
 
-    assert(firstRule.isPropertyRule() && secondRule.isPropertyRule());
+    ASSERT(firstRule.isPropertyRule() && secondRule.isPropertyRule());
 
     if (firstRule.isSubstitutionSimplified() ||
         secondRule.isSubstitutionSimplified())
@@ -309,7 +309,7 @@ void RewriteSystem::computeRecursiveRequirementDiagnostics(
   for (unsigned ruleID : RecursiveRules) {
     const auto &rule = getRule(ruleID);
 
-    assert(isInMinimizationDomain(rule.getRHS()[0].getRootProtocol()));
+    ASSERT(isInMinimizationDomain(rule.getRHS()[0].getRootProtocol()));
 
     Type subjectType = propertyMap.getTypeForTerm(rule.getRHS(), genericParams);
     errors.push_back(RequirementError::forRecursiveRequirement(

lib/AST/RequirementMachine/Diagnostics.h

@@ -16,6 +16,7 @@
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/Requirement.h"
 #include "swift/AST/Type.h"
+#include "swift/Basic/Assertions.h"
 
 namespace swift {
 
@@ -84,14 +85,14 @@ struct RequirementError {
 
 public:
   Requirement getRequirement() const {
-    assert(kind != Kind::InvalidInverseOuterSubject &&
+    ASSERT(kind != Kind::InvalidInverseOuterSubject &&
            kind != Kind::InvalidInverseSubject &&
            kind != Kind::ConflictingInverseRequirement);
     return requirement;
   }
 
   InverseRequirement getInverse() const {
-    assert(kind == Kind::InvalidInverseOuterSubject ||
+    ASSERT(kind == Kind::InvalidInverseOuterSubject ||
            kind == Kind::InvalidInverseSubject ||
            kind == Kind::ConflictingInverseRequirement);
     return inverse;

lib/AST/RequirementMachine/GenericSignatureQueries.cpp

@@ -243,12 +243,12 @@ RequirementMachine::getLongestValidPrefix(const MutableTerm &term) const {
       return prefix;
 
     case Symbol::Kind::Protocol:
-      assert(prefix.empty() &&
+      ASSERT(prefix.empty() &&
              "Protocol symbol can only appear at the start of a type term");
       break;
 
     case Symbol::Kind::GenericParam: {
-      assert(prefix.empty() &&
+      ASSERT(prefix.empty() &&
              "Generic parameter symbol can only appear at the start of a type term");
 
       if (std::find_if(Params.begin(), Params.end(),
@@ -500,8 +500,6 @@ Type RequirementMachine::getReducedType(
 /// Determine if the given type parameter is valid with respect to this
 /// requirement machine's generic signature.
 bool RequirementMachine::isValidTypeParameter(Type type) const {
-  assert(type->isTypeParameter());
-
   auto term = Context.getMutableTermForType(type->getCanonicalType(),
                                             /*proto=*/nullptr);
   System.simplify(term);
@@ -525,23 +523,21 @@ bool RequirementMachine::isValidTypeParameter(Type type) const {
 ConformancePath
 RequirementMachine::getConformancePath(Type type,
                                        ProtocolDecl *protocol) {
-  assert(type->isTypeParameter());
-
   auto mutTerm = Context.getMutableTermForType(type->getCanonicalType(),
                                                /*proto=*/nullptr);
   System.simplify(mutTerm);
   verify(mutTerm);
 
-#ifndef NDEBUG
-  auto *props = Map.lookUpProperties(mutTerm);
-  assert(props &&
-         "Subject type of conformance access path should be known");
-  assert(!props->isConcreteType() &&
-         "Concrete types do not have conformance access paths");
-  auto conformsTo = props->getConformsTo();
-  assert(std::find(conformsTo.begin(), conformsTo.end(), protocol) &&
-         "Subject type of conformance access path must conform to protocol");
-#endif
+  if (CONDITIONAL_ASSERT_enabled()) {
+    auto *props = Map.lookUpProperties(mutTerm);
+    ASSERT(props &&
+           "Subject type of conformance access path should be known");
+    ASSERT(!props->isConcreteType() &&
+           "Concrete types do not have conformance access paths");
+    auto conformsTo = props->getConformsTo();
+    ASSERT(std::find(conformsTo.begin(), conformsTo.end(), protocol) &&
+          "Subject type of conformance access path must conform to protocol");
+  }
 
   auto term = Term::get(mutTerm, Context);
 
@@ -565,8 +561,7 @@ RequirementMachine::getConformancePath(Type type,
     auto key = std::make_pair(term, proto);
     auto inserted = ConformancePaths.insert(
         std::make_pair(key, path));
-    assert(inserted.second);
-    (void) inserted;
+    ASSERT(inserted.second);
 
     if (Stats)
       ++Stats->getFrontendCounters().NumConformancePathsRecorded;
@@ -724,7 +719,7 @@ RequirementMachine::lookupNestedType(Type depType, Identifier name) const {
   }
 
   if (bestAssocType) {
-    assert(bestAssocType->getOverriddenDecls().empty() &&
+    ASSERT(bestAssocType->getOverriddenDecls().empty() &&
            "Lookup should never keep a non-anchor associated type");
     return bestAssocType;
 
@@ -738,7 +733,7 @@ RequirementMachine::lookupNestedType(Type depType, Identifier name) const {
 
 MutableTerm
 RequirementMachine::getReducedShapeTerm(Type type) const {
-  assert(type->isParameterPack());
+  ASSERT(type->isParameterPack());
 
   auto term = Context.getMutableTermForType(type->getCanonicalType(),
                                             /*proto=*/nullptr);
@@ -780,7 +775,9 @@ bool RequirementMachine::haveSameShape(Type type1, Type type2) const {
 }
 
 void RequirementMachine::verify(const MutableTerm &term) const {
-#ifndef NDEBUG
+  if (!CONDITIONAL_ASSERT_enabled())
+    return;
+
   // If the term is in the generic parameter domain, ensure we have a valid
   // generic parameter.
   if (term.begin()->getKind() == Symbol::Kind::GenericParam) {
@@ -828,7 +825,7 @@ void RequirementMachine::verify(const MutableTerm &term) const {
 
     switch (symbol.getKind()) {
     case Symbol::Kind::Name:
-      assert(!erased.empty());
+      ASSERT(!erased.empty());
       erased.add(symbol);
       break;
 
@@ -865,5 +862,4 @@ void RequirementMachine::verify(const MutableTerm &term) const {
     dump(llvm::errs());
     abort();
   }
-#endif
 }

lib/AST/RequirementMachine/Histogram.h

@@ -15,6 +15,7 @@
 #ifndef SWIFT_HISTOGRAM_H
 #define SWIFT_HISTOGRAM_H
 
+#include "swift/Basic/Assertions.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/raw_ostream.h"
@@ -68,7 +69,7 @@ class Histogram {
   /// Start. The value is allowed to be greater than or equal to Start + Size,
   /// in which case it's counted in the OverflowBucket.
   void add(unsigned value) {
-    assert(value >= Start);
+    ASSERT(value >= Start);
     value -= Start;
     if (value >= Size)
       ++OverflowBucket;

lib/AST/RequirementMachine/HomotopyReduction.cpp

@@ -212,7 +212,7 @@ RewriteSystem::findRuleToDelete(EliminationPredicate isRedundantRuleFn) {
     // We should not find a rule that has already been marked redundant
     // here; it should have already been replaced with a rewrite path
     // in all homotopy generators.
-    assert(!rule.isRedundant());
+    ASSERT(!rule.isRedundant());
 
     // Associated type introduction rules are 'permanent'. They're
     // not worth eliminating since they are re-added every time; it
@@ -436,9 +436,9 @@ void RewriteSystem::minimizeRewriteSystem(const PropertyMap &map) {
     llvm::dbgs() << "-----------------------------\n";
   }
 
-  assert(Complete);
-  assert(!Minimized);
-  assert(!Frozen);
+  ASSERT(Complete);
+  ASSERT(!Minimized);
+  ASSERT(!Frozen);
   Minimized = 1;
 
   propagateExplicitBits();
@@ -591,8 +591,8 @@ void RewriteSystem::minimizeRewriteSystem(const PropertyMap &map) {
 /// after minimization. Instead, we will rebuild a new rewrite system
 /// from the minimized requirements.
 GenericSignatureErrors RewriteSystem::getErrors() const {
-  assert(Complete);
-  assert(Minimized);
+  ASSERT(Complete);
+  ASSERT(Minimized);
 
   GenericSignatureErrors result;
 
@@ -644,8 +644,8 @@ GenericSignatureErrors RewriteSystem::getErrors() const {
 /// These rules form the requirement signatures of these protocols.
 llvm::DenseMap<const ProtocolDecl *, RewriteSystem::MinimizedProtocolRules>
 RewriteSystem::getMinimizedProtocolRules() const {
-  assert(Minimized);
-  assert(!Protos.empty());
+  ASSERT(Minimized);
+  ASSERT(!Protos.empty());
 
   llvm::DenseMap<const ProtocolDecl *, MinimizedProtocolRules> rules;
   for (unsigned ruleID = FirstLocalRule, e = Rules.size();
@@ -676,8 +676,8 @@ RewriteSystem::getMinimizedProtocolRules() const {
 /// These rules form the top-level generic signature for this rewrite system.
 std::vector<unsigned>
 RewriteSystem::getMinimizedGenericSignatureRules() const {
-  assert(Minimized);
-  assert(Protos.empty());
+  ASSERT(Minimized);
+  ASSERT(Protos.empty());
 
   std::vector<unsigned> rules;
   for (unsigned ruleID = FirstLocalRule, e = Rules.size();
@@ -713,11 +713,11 @@ void RewriteSystem::verifyRedundantConformances(
     const llvm::DenseSet<unsigned> &redundantConformances) const {
   for (unsigned ruleID : redundantConformances) {
     const auto &rule = getRule(ruleID);
-    assert(!rule.isPermanent() &&
+    ASSERT(!rule.isPermanent() &&
            "Permanent rule cannot be redundant");
-    assert(!rule.isIdentityConformanceRule() &&
+    ASSERT(!rule.isIdentityConformanceRule() &&
            "Identity conformance cannot be redundant");
-    assert(rule.isAnyConformanceRule() &&
+    ASSERT(rule.isAnyConformanceRule() &&
            "Redundant conformance is not a conformance rule?");
 
     if (!rule.isRedundant()) {