[NoncopyablePartialConsumption] Ungate feature.

Remove all checks for the feature flag.  It's on all the time.

Author: nate-chandler

lib/SILGen/SILGenDestructor.cpp

@@ -264,14 +264,11 @@ void SILGenFunction::emitDeallocatingMoveOnlyDestructor(DestructorDecl *dd) {
                                 dd->getDeclContext()->getSelfNominalTypeDecl(),
                                 cleanupLoc);
 
-  if (getASTContext().LangOpts.hasFeature(
-          Feature::MoveOnlyPartialConsumption)) {
-    if (auto *ddi = dyn_cast<DropDeinitInst>(selfValue)) {
-      if (auto *mu =
-              dyn_cast<MarkUnresolvedNonCopyableValueInst>(ddi->getOperand())) {
-        if (auto *asi = dyn_cast<AllocStackInst>(mu->getOperand())) {
-          B.createDeallocStack(loc, asi);
-        }
+  if (auto *ddi = dyn_cast<DropDeinitInst>(selfValue)) {
+    if (auto *mu =
+            dyn_cast<MarkUnresolvedNonCopyableValueInst>(ddi->getOperand())) {
+      if (auto *asi = dyn_cast<AllocStackInst>(mu->getOperand())) {
+        B.createDeallocStack(loc, asi);
       }
     }
   }

lib/SILGen/SILGenProlog.cpp

@@ -59,30 +59,19 @@ SILValue SILGenFunction::emitSelfDeclForDestructor(VarDecl *selfDecl) {
   // owned, lets mark them as needing to be no implicit copy checked so they
   // cannot escape.
   if (selfType.isMoveOnly() && !selfType.isAnyClassReferenceType()) {
-    if (getASTContext().LangOpts.hasFeature(
-            Feature::MoveOnlyPartialConsumption)) {
-      SILValue addr = B.createAllocStack(selfDecl, selfValue->getType(), dv);
-      addr = B.createMarkUnresolvedNonCopyableValueInst(
-          selfDecl, addr,
-          MarkUnresolvedNonCopyableValueInst::CheckKind::
-              ConsumableAndAssignable);
-      if (selfValue->getType().isObject()) {
-        B.createStore(selfDecl, selfValue, addr, StoreOwnershipQualifier::Init);
-      } else {
-        B.createCopyAddr(selfDecl, selfValue, addr, IsTake, IsInitialization);
-      }
-      // drop_deinit invalidates any user-defined struct/enum deinit
-      // before the individual members are destroyed.
-      addr = B.createDropDeinit(selfDecl, addr);
-      selfValue = addr;
+    SILValue addr = B.createAllocStack(selfDecl, selfValue->getType(), dv);
+    addr = B.createMarkUnresolvedNonCopyableValueInst(
+        selfDecl, addr,
+        MarkUnresolvedNonCopyableValueInst::CheckKind::ConsumableAndAssignable);
+    if (selfValue->getType().isObject()) {
+      B.createStore(selfDecl, selfValue, addr, StoreOwnershipQualifier::Init);
     } else {
-      if (selfValue->getOwnershipKind() == OwnershipKind::Owned) {
-        selfValue = B.createMarkUnresolvedNonCopyableValueInst(
-            selfDecl, selfValue,
-            MarkUnresolvedNonCopyableValueInst::CheckKind::
-                ConsumableAndAssignable);
-      }
+      B.createCopyAddr(selfDecl, selfValue, addr, IsTake, IsInitialization);
     }
+    // drop_deinit invalidates any user-defined struct/enum deinit
+    // before the individual members are destroyed.
+    addr = B.createDropDeinit(selfDecl, addr);
+    selfValue = addr;
   }
 
   VarLocs[selfDecl] = VarLoc::get(selfValue);

lib/SILOptimizer/Mandatory/MoveOnlyAddressCheckerUtils.cpp

@@ -1791,10 +1791,11 @@ shouldEmitPartialMutationError(UseState &useState, PartialMutation::Kind kind,
   }
 
   auto feature = partialMutationFeature(kind);
-  if (!fn->getModule().getASTContext().LangOpts.hasFeature(feature) &&
+  if (feature &&
+      !fn->getModule().getASTContext().LangOpts.hasFeature(*feature) &&
       !isa<DropDeinitInst>(user)) {
     LLVM_DEBUG(llvm::dbgs()
-               << "    " << getFeatureName(feature) << " disabled!\n");
+               << "    " << getFeatureName(*feature) << " disabled!\n");
     // If the types equal, just bail early.
     // Emit the error.
     return {PartialMutationError::featureDisabled(iterType, kind)};

lib/SILOptimizer/Mandatory/MoveOnlyDiagnostics.cpp

@@ -807,8 +807,9 @@ void DiagnosticEmitter::emitCannotPartiallyMutateError(
 
   switch (error) {
   case PartialMutationError::Kind::FeatureDisabled: {
-    assert(!astContext.LangOpts.hasFeature(
-        partialMutationFeature(error.getKind())));
+    auto feature = partialMutationFeature(error.getKind());
+    assert(feature);
+    assert(!astContext.LangOpts.hasFeature(*feature));
 
     switch (kind) {
     case PartialMutation::Kind::Consume:

lib/SILOptimizer/Mandatory/MoveOnlyTypeUtils.h

@@ -128,12 +128,13 @@ class PartialMutation {
   }
 };
 
-inline Feature partialMutationFeature(PartialMutation::Kind kind) {
+inline std::optional<Feature>
+partialMutationFeature(PartialMutation::Kind kind) {
   switch (kind) {
   case PartialMutation::Kind::Consume:
-    return Feature::MoveOnlyPartialConsumption;
+    return std::nullopt;
   case PartialMutation::Kind::Reinit:
-    return Feature::MoveOnlyPartialReinitialization;
+    return {Feature::MoveOnlyPartialReinitialization};
   }
 }
 
@@ -184,7 +185,7 @@ class PartialMutationError {
   enum class Kind : uint8_t {
     /// The partial consumption feature is disabled.
     ///
-    /// See -enable-experimental-feature MoveOnlyPartialConsumption.
+    /// See -enable-experimental-feature MoveOnlyPartialReinitialization.
     FeatureDisabled,
     /// A partially consumed/reinitialized aggregate has a deinit.
     ///

lib/Sema/MiscDiagnostics.cpp

@@ -422,8 +422,6 @@ static void diagSyntacticUseRestrictions(const Expr *E, const DeclContext *DC,
     }
 
     void checkConsumeExpr(ConsumeExpr *consumeExpr) {
-      auto partialConsumptionEnabled =
-          Ctx.LangOpts.hasFeature(Feature::MoveOnlyPartialConsumption);
       auto *subExpr = consumeExpr->getSubExpr();
       bool noncopyable =
           subExpr->getType()->getCanonicalType()->isNoncopyable();
@@ -447,7 +445,7 @@ static void diagSyntacticUseRestrictions(const Expr *E, const DeclContext *DC,
           continue;
         }
         auto *mre = dyn_cast<MemberRefExpr>(current);
-        if (mre && partialConsumptionEnabled) {
+        if (mre) {
           auto *vd = dyn_cast<VarDecl>(mre->getMember().getDecl());
           if (!vd) {
             Ctx.Diags.diagnose(consumeExpr->getLoc(),
@@ -475,7 +473,7 @@ static void diagSyntacticUseRestrictions(const Expr *E, const DeclContext *DC,
           continue;
         }
         auto *ce = dyn_cast<CallExpr>(current);
-        if (ce && partialConsumptionEnabled) {
+        if (ce) {
           if (noncopyable) {
             Ctx.Diags.diagnose(consumeExpr->getLoc(),
                                diag::consume_expression_non_storage);
@@ -488,7 +486,7 @@ static void diagSyntacticUseRestrictions(const Expr *E, const DeclContext *DC,
           return;
         }
         auto *se = dyn_cast<SubscriptExpr>(current);
-        if (se && partialConsumptionEnabled) {
+        if (se) {
           if (noncopyable) {
             Ctx.Diags.diagnose(consumeExpr->getLoc(),
                                diag::consume_expression_non_storage);