[AST/Sema] NonCopyableGenerics: Remove all but one direct use of getMarking(...)

Author: xedin

lib/AST/ConformanceLookup.cpp

@@ -415,8 +415,7 @@ getBuiltinInvertibleProtocolConformance(NominalTypeDecl *nominal,
   case InvertibleProtocolKind::Copyable:
     // If move-only classes is enabled, we'll check the markings.
     if (ctx.LangOpts.hasFeature(Feature::MoveOnlyClasses)) {
-      auto marking = nominal->getMarking(*ip);
-      switch (marking.getInverse().getKind()) {
+      switch (nominal->hasInverseMarking(*ip).getKind()) {
       case InverseMarking::Kind::LegacyExplicit:
       case InverseMarking::Kind::Explicit:
         // An inverse ~Copyable prevents conformance.

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -3219,11 +3219,11 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     auto &ctx = decl->getASTContext();
 
     for (auto ip : InvertibleProtocolSet::full()) {
-      auto marking = decl->getMarking(ip);
+      auto inverseMarking = decl->hasInverseMarking(ip);
 
       // Inferred inverses are already ignored for classes.
       // FIXME: we can also diagnose @_moveOnly here if we use `isAnyExplicit`
-      if (!marking.getInverse().is(InverseMarking::Kind::Explicit))
+      if (!inverseMarking.is(InverseMarking::Kind::Explicit))
         continue;
 
       // Allow ~Copyable when MoveOnlyClasses is enabled
@@ -3232,7 +3232,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
         continue;
 
 
-      ctx.Diags.diagnose(marking.getInverse().getLoc(),
+      ctx.Diags.diagnose(inverseMarking.getLoc(),
                          diag::inverse_on_class,
                          getProtocolName(getKnownProtocolKind(ip)));
     }

lib/Sema/TypeCheckInvertible.cpp

@@ -52,25 +52,24 @@ static void addConformanceFixIt(const NominalTypeDecl *nominal,
 // a conformance to KP.
 static void emitAdviceToApplyInverseAfter(InFlightDiagnostic &&diag,
                                           InvertibleProtocolKind ip,
-                                          InverseMarking marking,
+                                          InverseMarking::Mark inverseMarking,
                                           NominalTypeDecl *nominal) {
   auto kp = getKnownProtocolKind(ip);
 
   // Immediately flush, then emit notes, so they're associated.
   diag.flush();
 
-  auto &ctx = nominal->getASTContext();
-  // Not expecting the positive KP constraint to be classified as "Inferred".
-  assert(marking.getPositive().getKind() != InverseMarking::Kind::Inferred);
-
   // Have no advice for situations where the KP conformance is explicit.
+  auto marking = nominal->getMarking(ip);
   if (marking.getPositive().isPresent())
     return;
 
-  switch (marking.getInverse().getKind()) {
+  auto &ctx = nominal->getASTContext();
+
+  switch (inverseMarking.getKind()) {
   case InverseMarking::Kind::Inferred:
     // Note that the enclosing type is conditionally conforming to KP first.
-    ctx.Diags.diagnose(marking.getInverse().getLoc(),
+    ctx.Diags.diagnose(inverseMarking.getLoc(),
                        diag::note_inverse_preventing_conformance_implicit,
                        nominal, getProtocolName(kp));
     LLVM_FALLTHROUGH;
@@ -104,7 +103,7 @@ static void tryEmitContainmentFixits(InFlightDiagnostic &&diag,
   auto kp = getKnownProtocolKind(ip);
 
   // Check the enclosing type's markings to see what to suggest.
-  auto enclosingMarking = enclosingNom->getMarking(ip);
+  auto enclosingMarking = enclosingNom->hasInverseMarking(ip);
 
   // First, the generic advice.
   emitAdviceToApplyInverseAfter(std::move(diag), ip,
@@ -131,7 +130,7 @@ static void tryEmitContainmentFixits(InFlightDiagnostic &&diag,
   // not IP.
   if (auto nominal = nonConformingTy->getAnyNominal()) {
     if (nominal->getLoc(/*SerializedOK=*/false)) {
-      auto inverse = nominal->getMarking(ip).getInverse();
+      auto inverse = nominal->hasInverseMarking(ip);
       auto loc = inverse.getLoc();
 
       switch (inverse.getKind()) {
@@ -176,10 +175,10 @@ static bool checkInvertibleConformanceCommon(ProtocolConformance *conformance,
   //
   // So, if the nominal has `~Copyable` but this conformance is
   // written in an extension, then we do not raise an error.
-  auto marking = nom->getMarking(ip);
-  if (marking.getInverse().isAnyExplicit()) {
+  auto inverseMarking = nom->hasInverseMarking(ip);
+  if (inverseMarking.isAnyExplicit()) {
     if (conformance->getDeclContext() == nom) {
-      ctx.Diags.diagnose(marking.getInverse().getLoc(),
+      ctx.Diags.diagnose(inverseMarking.getLoc(),
                          diag::inverse_but_also_conforms,
                          nom, getProtocolName(kp));
       conforms &= false;
@@ -200,7 +199,7 @@ static bool checkInvertibleConformanceCommon(ProtocolConformance *conformance,
       auto diag = deinit->diagnose(diag::copyable_illegal_deinit, nom);
       emitAdviceToApplyInverseAfter(std::move(diag),
                                     ip,
-                                    nom->getMarking(ip),
+                                    inverseMarking,
                                     nom);
       conforms &= false;
     }
@@ -398,14 +397,9 @@ ProtocolConformance *deriveConformanceForInvertible(Evaluator &evaluator,
     return generateConformance(ext);
   };
 
-  auto marking = nominal->getMarking(*ip);
-
-  // Unexpected to have any positive marking for IP if we're deriving it.
-  assert(!marking.getPositive().isPresent());
-
   // Check what kind of inverse-marking we have to determine whether to generate
   // a conformance for IP.
-  switch (marking.getInverse().getKind()) {
+  switch (nominal->hasInverseMarking(*ip).getKind()) {
   case InverseMarking::Kind::LegacyExplicit:
   case InverseMarking::Kind::Explicit:
     return nullptr; // No positive IP conformance will be inferred.