cmPolicies: Remove now-unused REQUIRED_IF_USED and REQUIRED_ALWAYS states

Source/cmAddCustomCommandCommand.cxx

@@ -610,8 +610,6 @@ bool cmAddCustomCommandCommand(std::vector<std::string> const& args,
       case cmPolicies::OLD:
         issueMessage = false;
         break;
-      case cmPolicies::REQUIRED_ALWAYS:
-      case cmPolicies::REQUIRED_IF_USED:
       case cmPolicies::NEW:
         messageType = MessageType::FATAL_ERROR;
         break;

Source/cmAddLibraryCommand.cxx

@@ -242,8 +242,6 @@ bool cmAddLibraryCommand(std::vector<std::string> const& args,
         type = cmStateEnums::STATIC_LIBRARY;
         break;
       case cmPolicies::NEW:
-      case cmPolicies::REQUIRED_IF_USED:
-      case cmPolicies::REQUIRED_ALWAYS:
         mf.IssueMessage(
           MessageType::FATAL_ERROR,
           cmStrCat(

Source/cmBreakCommand.cxx

@@ -24,8 +24,6 @@ bool cmBreakCommand(std::vector<std::string> const& args,
       case cmPolicies::OLD:
         issueMessage = false;
         break;
-      case cmPolicies::REQUIRED_ALWAYS:
-      case cmPolicies::REQUIRED_IF_USED:
       case cmPolicies::NEW:
         messageType = MessageType::FATAL_ERROR;
         break;
@@ -54,8 +52,6 @@ bool cmBreakCommand(std::vector<std::string> const& args,
       case cmPolicies::OLD:
         issueMessage = false;
         break;
-      case cmPolicies::REQUIRED_ALWAYS:
-      case cmPolicies::REQUIRED_IF_USED:
       case cmPolicies::NEW:
         messageType = MessageType::FATAL_ERROR;
         break;

Source/cmCMakePolicyCommand.cxx

@@ -4,7 +4,6 @@
 
 #include "cmExecutionStatus.h"
 #include "cmMakefile.h"
-#include "cmMessageType.h"
 #include "cmPolicies.h"
 #include "cmState.h"
 #include "cmStateTypes.h"
@@ -147,19 +146,6 @@ bool HandleGetMode(std::vector<std::string> const& args,
       // Report that the policy is set to NEW.
       status.GetMakefile().AddDefinition(var, "NEW");
       break;
-    case cmPolicies::REQUIRED_IF_USED:
-    case cmPolicies::REQUIRED_ALWAYS:
-      // The policy is required to be set before anything needs it.
-      {
-        status.GetMakefile().IssueMessage(
-          MessageType::FATAL_ERROR,
-          cmStrCat(
-            cmPolicies::GetRequiredPolicyError(pid), "\n",
-            "The call to cmake_policy(GET ", id,
-            " ...) at which this "
-            "error appears requests the policy, and this version of CMake ",
-            "requires that the policy be set to NEW before it is checked."));
-      }
   }
 
   return true;

Source/cmComputeLinkDepends.cxx

@@ -373,40 +373,19 @@ public:
       case cmPolicies::OLD:
         // rely on default initialization of the class
         break;
-      case cmPolicies::REQUIRED_IF_USED:
-      case cmPolicies::REQUIRED_ALWAYS:
-        makefile->GetCMakeInstance()->IssueMessage(
-          MessageType::FATAL_ERROR,
-          cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0156),
-          target->GetBacktrace());
-        CM_FALLTHROUGH;
       case cmPolicies::NEW: {
         // Policy 0179 applies only when policy 0156 is new
-        switch (target->GetPolicyStatusCMP0179()) {
-          case cmPolicies::WARN:
-            if (!makefile->GetCMakeInstance()->GetIsInTryCompile() &&
-                makefile->PolicyOptionalWarningEnabled(
-                  "CMAKE_POLICY_WARNING_CMP0179")) {
-              makefile->GetCMakeInstance()->IssueMessage(
-                MessageType::AUTHOR_WARNING,
-                cmStrCat(cmPolicies::GetPolicyWarning(cmPolicies::CMP0179),
-                         "\nSince the policy is not set, static libraries "
-                         "de-duplication will keep the last occurrence of the "
-                         "static libraries."),
-                target->GetBacktrace());
-            }
-            CM_FALLTHROUGH;
-          case cmPolicies::OLD:
-            break;
-          case cmPolicies::REQUIRED_IF_USED:
-          case cmPolicies::REQUIRED_ALWAYS:
-            makefile->GetCMakeInstance()->IssueMessage(
-              MessageType::FATAL_ERROR,
-              cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0179),
-              target->GetBacktrace());
-            CM_FALLTHROUGH;
-          case cmPolicies::NEW:
-            break;
+        if (target->GetPolicyStatusCMP0179() == cmPolicies::WARN &&
+            !makefile->GetCMakeInstance()->GetIsInTryCompile() &&
+            makefile->PolicyOptionalWarningEnabled(
+              "CMAKE_POLICY_WARNING_CMP0179")) {
+          makefile->GetCMakeInstance()->IssueMessage(
+            MessageType::AUTHOR_WARNING,
+            cmStrCat(cmPolicies::GetPolicyWarning(cmPolicies::CMP0179),
+                     "\nSince the policy is not set, static libraries "
+                     "de-duplication will keep the last occurrence of the "
+                     "static libraries."),
+            target->GetBacktrace());
         }
 
         if (auto libProcessing = makefile->GetDefinition(cmStrCat(

Source/cmComputeLinkInformation.cxx

@@ -1850,8 +1850,6 @@ bool cmComputeLinkInformation::CheckImplicitDirItem(LinkEntry const& entry)
       CM_FALLTHROUGH;
     case cmPolicies::OLD:
       break;
-    case cmPolicies::REQUIRED_ALWAYS:
-    case cmPolicies::REQUIRED_IF_USED:
     case cmPolicies::NEW:
       return false;
   }
@@ -2205,18 +2203,6 @@ void cmComputeLinkInformation::HandleBadFullItem(LinkEntry const& entry,
     case cmPolicies::NEW:
       // NEW behavior will not get here.
       break;
-    case cmPolicies::REQUIRED_IF_USED:
-    case cmPolicies::REQUIRED_ALWAYS: {
-      std::ostringstream e;
-      /* clang-format off */
-      e << cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0008) << "\n"
-             "Target \"" << this->Target->GetName() << "\" links to item\n"
-             "  " << item << "\n"
-             "which is a full-path but not a valid library file name.";
-      /* clang-format on */
-      this->CMakeInstance->IssueMessage(MessageType::FATAL_ERROR, e.str(),
-                                        this->Target->GetBacktrace());
-    } break;
   }
 }
 
@@ -2248,15 +2234,6 @@ bool cmComputeLinkInformation::FinishLinkerSearchDirectories()
     case cmPolicies::NEW:
       // Should never happen due to assignment of OldLinkDirMode
       return true;
-    case cmPolicies::REQUIRED_IF_USED:
-    case cmPolicies::REQUIRED_ALWAYS: {
-      std::ostringstream e;
-      e << cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0003) << '\n';
-      this->PrintLinkPolicyDiagnosis(e);
-      this->CMakeInstance->IssueMessage(MessageType::FATAL_ERROR, e.str(),
-                                        this->Target->GetBacktrace());
-      return false;
-    }
   }
 
   // Add the link directories for full path items.

Source/cmComputeTargetDepends.cxx

@@ -364,8 +364,6 @@ void cmComputeTargetDepends::AddTargetDepend(size_t depender_index,
       case cmPolicies::OLD:
         break;
       case cmPolicies::NEW:
-      case cmPolicies::REQUIRED_IF_USED:
-      case cmPolicies::REQUIRED_ALWAYS:
         issueMessage = true;
         messageType = MessageType::FATAL_ERROR;
         break;

Source/cmConditionEvaluator.cxx

@@ -453,14 +453,6 @@ bool cmConditionEvaluator::GetBooleanValueWithAutoDereference(
         CM_FALLTHROUGH;
       case cmPolicies::OLD:
         return oldResult;
-      case cmPolicies::REQUIRED_IF_USED:
-      case cmPolicies::REQUIRED_ALWAYS: {
-        errorString = "An argument named \"" + newArg.GetValue() +
-          "\" appears in a conditional statement.  " +
-          cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0012);
-        status = MessageType::FATAL_ERROR;
-        break;
-      }
       case cmPolicies::NEW:
         break;
     }

Source/cmCoreTryCompile.cxx

@@ -769,12 +769,6 @@ cm::optional<cmTryCompileResult> cmCoreTryCompile::TryCompileCode(
       case cmPolicies::OLD:
         // OLD behavior is to do nothing.
         break;
-      case cmPolicies::REQUIRED_IF_USED:
-      case cmPolicies::REQUIRED_ALWAYS:
-        this->Makefile->IssueMessage(
-          MessageType::FATAL_ERROR,
-          cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0066));
-        CM_FALLTHROUGH;
       case cmPolicies::NEW: {
         // NEW behavior is to pass config-specific compiler flags.
         std::string const cfg = !tcConfig.empty()
@@ -810,12 +804,6 @@ cm::optional<cmTryCompileResult> cmCoreTryCompile::TryCompileCode(
       case cmPolicies::OLD:
         // OLD behavior is to do nothing.
         break;
-      case cmPolicies::REQUIRED_IF_USED:
-      case cmPolicies::REQUIRED_ALWAYS:
-        this->Makefile->IssueMessage(
-          MessageType::FATAL_ERROR,
-          cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0056));
-        CM_FALLTHROUGH;
       case cmPolicies::NEW:
         // NEW behavior is to pass linker flags.
         {
@@ -998,12 +986,6 @@ cm::optional<cmTryCompileResult> cmCoreTryCompile::TryCompileCode(
           // OLD behavior is to not honor the language standard variables.
           honorStandard = false;
           break;
-        case cmPolicies::REQUIRED_IF_USED:
-        case cmPolicies::REQUIRED_ALWAYS:
-          this->Makefile->IssueMessage(
-            MessageType::FATAL_ERROR,
-            cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0067));
-          break;
         case cmPolicies::NEW:
           // NEW behavior is to honor the language standard variables.
           // We already initialized honorStandard to true.

Source/cmDebuggerVariablesHelper.cxx

@@ -39,8 +39,6 @@ std::shared_ptr<cmDebuggerVariables> cmDebuggerVariablesHelper::Create(
     { cmPolicies::PolicyStatus::OLD, "OLD" },
     { cmPolicies::PolicyStatus::WARN, "WARN" },
     { cmPolicies::PolicyStatus::NEW, "NEW" },
-    { cmPolicies::PolicyStatus::REQUIRED_IF_USED, "REQUIRED_IF_USED" },
-    { cmPolicies::PolicyStatus::REQUIRED_ALWAYS, "REQUIRED_ALWAYS" }
   };
 
   return std::make_shared<cmDebuggerVariables>(

Source/cmExportCommand.cxx

@@ -405,8 +405,6 @@ static bool HandlePackage(std::vector<std::string> const& args,
         return true;
       }
       break;
-    case cmPolicies::REQUIRED_IF_USED:
-    case cmPolicies::REQUIRED_ALWAYS:
     case cmPolicies::NEW:
       // Default is to not export, but can be enabled.
       if (!mf.IsOn("CMAKE_EXPORT_PACKAGE_REGISTRY")) {

Source/cmExportInstallFileGenerator.cxx

@@ -439,8 +439,6 @@ bool cmExportInstallFileGenerator::CheckInterfaceDirs(
             break;
           case cmPolicies::OLD:
             continue;
-          case cmPolicies::REQUIRED_IF_USED:
-          case cmPolicies::REQUIRED_ALWAYS:
           case cmPolicies::NEW:
             hadFatalError = true;
             break; // Issue fatal message.
@@ -492,8 +490,6 @@ bool cmExportInstallFileGenerator::CheckInterfaceDirs(
             case cmPolicies::OLD:
               shouldContinue = true;
               break;
-            case cmPolicies::REQUIRED_ALWAYS:
-            case cmPolicies::REQUIRED_IF_USED:
             case cmPolicies::NEW:
               break;
           }

Source/cmFileCommand.cxx

@@ -409,8 +409,6 @@ bool HandleStringsCommand(std::vector<std::string> const& args,
       }
       have_regex = true;
       switch (status.GetMakefile().GetPolicyStatus(cmPolicies::CMP0159)) {
-        case cmPolicies::REQUIRED_IF_USED:
-        case cmPolicies::REQUIRED_ALWAYS:
         case cmPolicies::NEW:
           // store_regex = true
           break;
@@ -685,8 +683,6 @@ bool HandleGlobImpl(std::vector<std::string> const& args, bool recurse,
     status.GetMakefile().GetPolicyStatus(cmPolicies::CMP0009);
   if (recurse) {
     switch (policyStatus) {
-      case cmPolicies::REQUIRED_IF_USED:
-      case cmPolicies::REQUIRED_ALWAYS:
       case cmPolicies::NEW:
         g.RecurseThroughSymlinksOff();
         break;
@@ -839,8 +835,6 @@ bool HandleGlobImpl(std::vector<std::string> const& args, bool recurse,
   }
 
   switch (policyStatus) {
-    case cmPolicies::REQUIRED_IF_USED:
-    case cmPolicies::REQUIRED_ALWAYS:
     case cmPolicies::NEW:
       // Correct behavior, yay!
       break;
@@ -1389,8 +1383,6 @@ bool HandleRealPathCommand(std::vector<std::string> const& args,
   cmPolicies::PolicyStatus policyStatus =
     status.GetMakefile().GetPolicyStatus(cmPolicies::CMP0152);
   switch (policyStatus) {
-    case cmPolicies::REQUIRED_IF_USED:
-    case cmPolicies::REQUIRED_ALWAYS:
     case cmPolicies::NEW:
       break;
     case cmPolicies::WARN:

Source/cmFindPackageCommand.cxx

@@ -1388,8 +1388,6 @@ bool cmFindPackageCommand::FindModule(bool& found)
           }
           case cmPolicies::OLD:
             break;
-          case cmPolicies::REQUIRED_IF_USED:
-          case cmPolicies::REQUIRED_ALWAYS:
           case cmPolicies::NEW:
             return true;
         }
@@ -1890,12 +1888,6 @@ void cmFindPackageCommand::PushFindPackageRootPathStack()
     case cmPolicies::OLD:
       // OLD behavior is to ignore the <PackageName>_ROOT variables.
       return;
-    case cmPolicies::REQUIRED_IF_USED:
-    case cmPolicies::REQUIRED_ALWAYS:
-      this->Makefile->IssueMessage(
-        MessageType::FATAL_ERROR,
-        cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0074));
-      return;
     case cmPolicies::NEW: {
       // NEW behavior is to honor the <PackageName>_ROOT variables.
     } break;
@@ -1926,12 +1918,6 @@ void cmFindPackageCommand::PushFindPackageRootPathStack()
       rootDEF = nullptr;
       rootENV = cm::nullopt;
       break;
-    case cmPolicies::REQUIRED_IF_USED:
-    case cmPolicies::REQUIRED_ALWAYS:
-      this->Makefile->IssueMessage(
-        MessageType::FATAL_ERROR,
-        cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0144));
-      return;
     case cmPolicies::NEW: {
       // NEW behavior is to honor the <PACKAGENAME>_ROOT variables.
     } break;

Source/cmFindProgramCommand.cxx

@@ -125,8 +125,6 @@ struct cmFindProgramHelper
       case cmPolicies::OLD:
         return cmSystemTools::FileExists(file, true);
       case cmPolicies::NEW:
-      case cmPolicies::REQUIRED_ALWAYS:
-      case cmPolicies::REQUIRED_IF_USED:
         return cmSystemTools::FileIsExecutable(file);
       default:
         break;

Source/cmGeneratorExpressionEvaluationFile.cxx

@@ -253,8 +253,6 @@ std::string cmGeneratorExpressionEvaluationFile::FixRelativePath(
       // which ends up being used relative to the working dir.
       resultPath = relativePath;
       break;
-    case cmPolicies::REQUIRED_IF_USED:
-    case cmPolicies::REQUIRED_ALWAYS:
     case cmPolicies::NEW:
       // NEW behavior is to interpret the relative path with respect
       // to the current source or binary directory.

Source/cmGeneratorExpressionNode.cxx

@@ -333,8 +333,6 @@ static const struct InListNode : public cmGeneratorExpressionNode
           return "0";
         }
         break;
-      case cmPolicies::REQUIRED_IF_USED:
-      case cmPolicies::REQUIRED_ALWAYS:
       case cmPolicies::NEW:
         values.assign(parameters[1], cmList::EmptyElements::Yes);
         break;
@@ -1931,8 +1929,6 @@ struct CompilerIdNode : public cmGeneratorExpressionNode
           case cmPolicies::OLD:
             return "1";
           case cmPolicies::NEW:
-          case cmPolicies::REQUIRED_ALWAYS:
-          case cmPolicies::REQUIRED_IF_USED:
             break;
         }
       }
@@ -3431,8 +3427,6 @@ static const struct TargetPolicyNode : public cmGeneratorExpressionNode
               MessageType::AUTHOR_WARNING,
               cmPolicies::GetPolicyWarning(policyForString(policy)));
             CM_FALLTHROUGH;
-          case cmPolicies::REQUIRED_IF_USED:
-          case cmPolicies::REQUIRED_ALWAYS:
           case cmPolicies::OLD:
             return "0";
           case cmPolicies::NEW:
@@ -3527,8 +3521,6 @@ struct TargetFilesystemArtifactDependencyCMP0112
       case cmPolicies::OLD:
         context->DependTargets.insert(target);
         break;
-      case cmPolicies::REQUIRED_IF_USED:
-      case cmPolicies::REQUIRED_ALWAYS:
       case cmPolicies::NEW:
         break;
     }

Source/cmGeneratorTarget.cxx

@@ -2474,8 +2474,6 @@ void cmGeneratorTarget::AddExplicitLanguageFlags(std::string& flags,
     case cmPolicies::OLD:
       // The OLD behavior is to not add explicit language flags.
       return;
-    case cmPolicies::REQUIRED_ALWAYS:
-    case cmPolicies::REQUIRED_IF_USED:
     case cmPolicies::NEW:
       // The NEW behavior is to add explicit language flags.
       break;
@@ -4760,15 +4758,6 @@ std::string cmGeneratorTarget::CheckCMP0004(std::string const& item) const
         cm->IssueMessage(MessageType::FATAL_ERROR, e.str(),
                          this->GetBacktrace());
       } break;
-      case cmPolicies::REQUIRED_IF_USED:
-      case cmPolicies::REQUIRED_ALWAYS: {
-        std::ostringstream e;
-        e << cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0004) << "\n"
-          << "Target \"" << this->GetName() << "\" links to item \"" << item
-          << "\" which has leading or trailing whitespace.";
-        cm->IssueMessage(MessageType::FATAL_ERROR, e.str(),
-                         this->GetBacktrace());
-      } break;
     }
   }
   return lib;
@@ -5927,8 +5916,6 @@ cmGeneratorTarget::CxxModuleSupport cmGeneratorTarget::NeedCxxDyndep(
       // The OLD behavior is to not scan the source.
       policyAnswer = CxxModuleSupport::Disabled;
       break;
-    case cmPolicies::REQUIRED_ALWAYS:
-    case cmPolicies::REQUIRED_IF_USED:
     case cmPolicies::NEW:
       // The NEW behavior is to scan the source if the compiler supports
       // scanning and the generator supports it.

Source/cmGeneratorTarget_IncludeDirectories.cxx

@@ -164,8 +164,6 @@ void processIncludeDirectories(cmGeneratorTarget const* tgt,
             case cmPolicies::OLD:
               messageType = MessageType::AUTHOR_WARNING;
               break;
-            case cmPolicies::REQUIRED_ALWAYS:
-            case cmPolicies::REQUIRED_IF_USED:
             case cmPolicies::NEW:
               break;
           }
@@ -204,8 +202,6 @@ void processIncludeDirectories(cmGeneratorTarget const* tgt,
             case cmPolicies::OLD:
               noMessage = true;
               break;
-            case cmPolicies::REQUIRED_IF_USED:
-            case cmPolicies::REQUIRED_ALWAYS:
             case cmPolicies::NEW:
               // Issue the fatal message.
               break;

Source/cmGeneratorTarget_Link.cxx

@@ -459,8 +459,6 @@ bool cmGeneratorTarget::VerifyLinkItemColons(LinkItemRole role,
     } break;
     case cmPolicies::OLD:
       return true;
-    case cmPolicies::REQUIRED_IF_USED:
-    case cmPolicies::REQUIRED_ALWAYS:
     case cmPolicies::NEW:
       // Issue the fatal message.
       break;
@@ -1330,8 +1328,6 @@ void cmGeneratorTarget::ComputeLinkImplementationLibraries(
         case cmPolicies::WARN:
         case cmPolicies::OLD:
           break;
-        case cmPolicies::REQUIRED_IF_USED:
-        case cmPolicies::REQUIRED_ALWAYS:
         case cmPolicies::NEW:
           dagChecker.SetTransitivePropertiesOnlyCMP0131();
           break;
@@ -1390,8 +1386,6 @@ void cmGeneratorTarget::ComputeLinkImplementationLibraries(
             case cmPolicies::OLD:
               noMessage = true;
               break;
-            case cmPolicies::REQUIRED_IF_USED:
-            case cmPolicies::REQUIRED_ALWAYS:
             case cmPolicies::NEW:
               // Issue the fatal message.
               break;

Source/cmGeneratorTarget_LinkDirectories.cxx

@@ -60,8 +60,6 @@ void processLinkDirectories(cmGeneratorTarget const* tgt,
             case cmPolicies::OLD:
               noMessage = true;
               break;
-            case cmPolicies::REQUIRED_IF_USED:
-            case cmPolicies::REQUIRED_ALWAYS:
             case cmPolicies::NEW:
               // Issue the fatal message.
               break;

Source/cmGeneratorTarget_Options.cxx

@@ -363,8 +363,6 @@ std::vector<BT<std::string>> cmGeneratorTarget::GetCompileDefinitions(
             this, config, language, &dagChecker, *entry));
         } break;
         case cmPolicies::NEW:
-        case cmPolicies::REQUIRED_ALWAYS:
-        case cmPolicies::REQUIRED_IF_USED:
           break;
       }
     }

Source/cmGetDirectoryPropertyCommand.cxx

@@ -90,8 +90,6 @@ bool cmGetDirectoryPropertyCommand(std::vector<std::string> const& args,
                     status.GetMakefile().GetDefineFlagsCMP0059());
         return true;
       case cmPolicies::NEW:
-      case cmPolicies::REQUIRED_ALWAYS:
-      case cmPolicies::REQUIRED_IF_USED:
         break;
     }
   }

Source/cmGetPropertyCommand.cxx

@@ -380,8 +380,6 @@ bool HandleDirectoryMode(cmExecutionStatus& status, const std::string& name,
         return StoreResult(infoType, status.GetMakefile(), variable,
                            mf->GetDefineFlagsCMP0059());
       case cmPolicies::NEW:
-      case cmPolicies::REQUIRED_ALWAYS:
-      case cmPolicies::REQUIRED_IF_USED:
         break;
     }
   }

Source/cmGetTargetPropertyCommand.cxx

@@ -60,8 +60,6 @@ bool cmGetTargetPropertyCommand(std::vector<std::string> const& args,
         CM_FALLTHROUGH;
       case cmPolicies::OLD:
         break;
-      case cmPolicies::REQUIRED_IF_USED:
-      case cmPolicies::REQUIRED_ALWAYS:
       case cmPolicies::NEW:
         issueMessage = true;
         messageType = MessageType::FATAL_ERROR;

Source/cmGlobalGenerator.cxx

@@ -1057,12 +1057,6 @@ void cmGlobalGenerator::CheckCompilerIdCompatibility(
         // OLD behavior is to convert AppleClang to Clang.
         mf->AddDefinition(compilerIdVar, "Clang");
         break;
-      case cmPolicies::REQUIRED_IF_USED:
-      case cmPolicies::REQUIRED_ALWAYS:
-        mf->IssueMessage(
-          MessageType::FATAL_ERROR,
-          cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0025));
-        break;
       case cmPolicies::NEW:
         // NEW behavior is to keep AppleClang.
         break;
@@ -1093,12 +1087,6 @@ void cmGlobalGenerator::CheckCompilerIdCompatibility(
           mf->AddDefinition("CMAKE_COMPILER_IS_GNUCXX", "1");
         }
         break;
-      case cmPolicies::REQUIRED_IF_USED:
-      case cmPolicies::REQUIRED_ALWAYS:
-        mf->IssueMessage(
-          MessageType::FATAL_ERROR,
-          cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0047));
-        CM_FALLTHROUGH;
       case cmPolicies::NEW:
         // NEW behavior is to keep QCC.
         break;
@@ -1124,12 +1112,6 @@ void cmGlobalGenerator::CheckCompilerIdCompatibility(
         // OLD behavior is to convert XLClang to XL.
         mf->AddDefinition(compilerIdVar, "XL");
         break;
-      case cmPolicies::REQUIRED_IF_USED:
-      case cmPolicies::REQUIRED_ALWAYS:
-        mf->IssueMessage(
-          MessageType::FATAL_ERROR,
-          cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0089));
-        break;
       case cmPolicies::NEW:
         // NEW behavior is to keep AppleClang.
         break;
@@ -1172,12 +1154,6 @@ void cmGlobalGenerator::CheckCompilerIdCompatibility(
           mf->RemoveDefinition(emulated);
         }
         break;
-      case cmPolicies::REQUIRED_IF_USED:
-      case cmPolicies::REQUIRED_ALWAYS:
-        mf->IssueMessage(
-          MessageType::FATAL_ERROR,
-          cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0129));
-        CM_FALLTHROUGH;
       case cmPolicies::NEW:
         // NEW behavior is to keep LCC.
         break;
@@ -2820,8 +2796,6 @@ static bool RaiseCMP0037Message(cmake* cm, cmTarget* tgt,
     case cmPolicies::OLD:
       break;
     case cmPolicies::NEW:
-    case cmPolicies::REQUIRED_IF_USED:
-    case cmPolicies::REQUIRED_ALWAYS:
       issueMessage = true;
       messageType = MessageType::FATAL_ERROR;
       break;
@@ -3028,8 +3002,6 @@ void cmGlobalGenerator::ReserveGlobalTargetCodegen()
     case cmPolicies::OLD:
       break;
     case cmPolicies::NEW:
-    case cmPolicies::REQUIRED_IF_USED:
-    case cmPolicies::REQUIRED_ALWAYS:
       issueMessage = true;
       messageType = MessageType::FATAL_ERROR;
       break;

Source/cmIncludeCommand.cxx

@@ -100,8 +100,6 @@ bool cmIncludeCommand(std::vector<std::string> const& args,
           }
           case cmPolicies::OLD:
             break;
-          case cmPolicies::REQUIRED_IF_USED:
-          case cmPolicies::REQUIRED_ALWAYS:
           case cmPolicies::NEW:
             mfile = "";
             break;
@@ -130,8 +128,6 @@ bool cmIncludeCommand(std::vector<std::string> const& args,
         CM_FALLTHROUGH;
       case cmPolicies::OLD:
         break;
-      case cmPolicies::REQUIRED_IF_USED:
-      case cmPolicies::REQUIRED_ALWAYS:
       case cmPolicies::NEW:
         modal = "may";
         messageType = MessageType::FATAL_ERROR;

Source/cmInstallCommand.cxx

@@ -105,7 +105,7 @@ public:
   bool MakeFilesFullPath(const char* modeName, const std::string& basePath,
                          const std::vector<std::string>& relFiles,
                          std::vector<std::string>& absFiles);
-  bool CheckCMP0006(bool& failure) const;
+  bool CheckCMP0006() const;
 
   std::string GetDestination(const cmInstallCommandArguments* args,
                              const std::string& varName,
@@ -1018,14 +1018,11 @@ bool HandleTargetsMode(std::vector<std::string> const& args,
             bundleGenerator = CreateInstallTargetGenerator(
               target, bundleArgs, false, helper.Makefile->GetBacktrace());
           } else if (!runtimeArgs.GetDestination().empty()) {
-            bool failure = false;
-            if (helper.CheckCMP0006(failure)) {
+            if (helper.CheckCMP0006()) {
               // For CMake 2.4 compatibility fallback to the RUNTIME
               // properties.
               bundleGenerator = CreateInstallTargetGenerator(
                 target, runtimeArgs, false, helper.Makefile->GetBacktrace());
-            } else if (failure) {
-              return false;
             }
           }
           if (!bundleGenerator) {
@@ -1625,8 +1622,6 @@ bool HandleFilesMode(std::vector<std::string> const& args,
           CM_FALLTHROUGH;
         case cmPolicies::OLD:
           break;
-        case cmPolicies::REQUIRED_IF_USED:
-        case cmPolicies::REQUIRED_ALWAYS:
         case cmPolicies::NEW:
           modal = "may";
           messageType = MessageType::FATAL_ERROR;
@@ -1880,13 +1875,6 @@ bool HandleDirectoryMode(std::vector<std::string> const& args,
         case cmPolicies::OLD:
           destination = args[i];
           break;
-        case cmPolicies::REQUIRED_ALWAYS:
-        case cmPolicies::REQUIRED_IF_USED:
-          // We should never get here, only OLD, WARN, and NEW are used
-          status.GetMakefile().IssueMessage(
-            MessageType::FATAL_ERROR,
-            cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0177));
-          return false;
       }
       doing = DoingNone;
     } else if (doing == DoingType) {
@@ -2494,7 +2482,7 @@ bool Helper::MakeFilesFullPath(const char* modeName,
   return true;
 }
 
-bool Helper::CheckCMP0006(bool& failure) const
+bool Helper::CheckCMP0006() const
 {
   switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0006)) {
     case cmPolicies::WARN:
@@ -2508,13 +2496,6 @@ bool Helper::CheckCMP0006(bool& failure) const
     case cmPolicies::NEW:
       // NEW behavior is to disallow compatibility
       break;
-    case cmPolicies::REQUIRED_IF_USED:
-    case cmPolicies::REQUIRED_ALWAYS:
-      failure = true;
-      this->Makefile->IssueMessage(
-        MessageType::FATAL_ERROR,
-        cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0006));
-      break;
   }
   return false;
 }

Source/cmInstallCommandArguments.cxx

@@ -66,12 +66,6 @@ cmInstallCommandArguments::cmInstallCommandArguments(
         return ArgumentParser::Continue::Yes;
       };
       break;
-    case cmPolicies::REQUIRED_ALWAYS:
-    case cmPolicies::REQUIRED_IF_USED:
-      // We should never get here, only OLD, WARN, and NEW are used
-      makefile.IssueMessage(
-        MessageType::FATAL_ERROR,
-        cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0177));
   }
 
   this->Bind("DESTINATION"_s, normalizeDest);

Source/cmInstallScriptGenerator.cxx

@@ -43,8 +43,6 @@ bool cmInstallScriptGenerator::Compute(cmLocalGenerator* lg)
       case cmPolicies::OLD:
         break;
       case cmPolicies::NEW:
-      case cmPolicies::REQUIRED_ALWAYS:
-      case cmPolicies::REQUIRED_IF_USED:
         this->AllowGenex = true;
         break;
     }

Source/cmInstallSubdirectoryGenerator.cxx

@@ -63,9 +63,7 @@ void cmInstallSubdirectoryGenerator::GenerateScript(std::ostream& os)
         // OLD behavior is handled in cmLocalGenerator::GenerateInstallRules()
         break;
 
-      case cmPolicies::NEW:
-      case cmPolicies::REQUIRED_IF_USED:
-      case cmPolicies::REQUIRED_ALWAYS: {
+      case cmPolicies::NEW: {
         Indent indent;
         std::string odir = this->BinaryDirectory;
         cmSystemTools::ConvertToUnixSlashes(odir);

Source/cmLinkDirectoriesCommand.cxx

@@ -67,11 +67,6 @@ static void AddLinkDir(cmMakefile& mf, std::string const& dir,
       case cmPolicies::OLD:
         // OLD behavior does not convert
         break;
-      case cmPolicies::REQUIRED_IF_USED:
-      case cmPolicies::REQUIRED_ALWAYS:
-        e << cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0015);
-        mf.IssueMessage(MessageType::FATAL_ERROR, e.str());
-        CM_FALLTHROUGH;
       case cmPolicies::NEW:
         // NEW behavior converts
         convertToAbsolute = true;

Source/cmListCommand.cxx

@@ -48,13 +48,6 @@ bool GetIndexArg(const std::string& arg, int* idx, cmMakefile& mf)
         break;
       case cmPolicies::NEW:
         return false;
-      case cmPolicies::REQUIRED_IF_USED:
-      case cmPolicies::REQUIRED_ALWAYS:
-        std::string msg =
-          cmStrCat(cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0121),
-                   " Invalid list index \"", arg, "\".");
-        mf.IssueMessage(MessageType::FATAL_ERROR, msg);
-        break;
     }
   }
 
@@ -118,12 +111,6 @@ cm::optional<cmList> GetList(const std::string& var,
       return list;
     case cmPolicies::NEW:
       return list;
-    case cmPolicies::REQUIRED_IF_USED:
-    case cmPolicies::REQUIRED_ALWAYS:
-      makefile.IssueMessage(
-        MessageType::FATAL_ERROR,
-        cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0007));
-      return {};
   }
   return list;
 }

Source/cmLocalGenerator.cxx

@@ -754,8 +754,6 @@ void cmLocalGenerator::GenerateInstallRules()
       }
     } break;
 
-    case cmPolicies::REQUIRED_IF_USED:
-    case cmPolicies::REQUIRED_ALWAYS:
     case cmPolicies::NEW:
       // NEW behavior is handled in
       // cmInstallSubdirectoryGenerator::GenerateScript()
@@ -1997,12 +1995,6 @@ std::string cmLocalGenerator::GetLinkLibsCMP0065(
         add_shlib_flags =
           !(tgt.IsAIX() && tgt.GetPropertyAsBool("ENABLE_EXPORTS"));
         break;
-      case cmPolicies::REQUIRED_IF_USED:
-      case cmPolicies::REQUIRED_ALWAYS:
-        this->IssueMessage(
-          MessageType::FATAL_ERROR,
-          cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0065));
-        CM_FALLTHROUGH;
       case cmPolicies::NEW:
         // NEW behavior is to only add the flags if ENABLE_EXPORTS is on,
         // except on AIX where we compute symbol exports.
@@ -2605,8 +2597,6 @@ bool cmLocalGenerator::GetShouldUseOldFlags(bool shared,
         }
         case cmPolicies::OLD:
           return true;
-        case cmPolicies::REQUIRED_IF_USED:
-        case cmPolicies::REQUIRED_ALWAYS:
         case cmPolicies::NEW:
           return false;
       }
@@ -2740,13 +2730,6 @@ void cmLocalGenerator::AppendFlags(std::string& flags,
     case cmPolicies::OLD:
       this->AppendFlags(flags, newFlags);
       break;
-    case cmPolicies::REQUIRED_IF_USED:
-    case cmPolicies::REQUIRED_ALWAYS:
-      this->Makefile->GetCMakeInstance()->IssueMessage(
-        MessageType::FATAL_ERROR,
-        cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0181),
-        target->GetBacktrace());
-      CM_FALLTHROUGH;
     case cmPolicies::NEW:
       if (compileOrLink == cmBuildStep::Link) {
         std::vector<std::string> options;
@@ -4422,12 +4405,6 @@ bool cmLocalGenerator::NeedBackwardsCompatibility_2_4()
       break;
     case cmPolicies::NEW:
       // New behavior is to ignore the variable.
-    case cmPolicies::REQUIRED_IF_USED:
-    case cmPolicies::REQUIRED_ALWAYS:
-      // This will never be the case because the only way to require
-      // the setting is to require the user to specify version policy
-      // 2.6 or higher.  Once we add that requirement then this whole
-      // method can be removed anyway.
       return false;
   }
 

Source/cmLocalNinjaGenerator.cxx

@@ -730,8 +730,6 @@ void cmLocalNinjaGenerator::WriteCustomCommandBuildStatement(
             CM_FALLTHROUGH;
           case cmPolicies::OLD:
             break;
-          case cmPolicies::REQUIRED_IF_USED:
-          case cmPolicies::REQUIRED_ALWAYS:
           case cmPolicies::NEW:
             depfile = ccg.GetInternalDepfile();
             break;
@@ -833,8 +831,6 @@ cmLocalNinjaGenerator::MakeCustomCommandGenerators(
       CM_FALLTHROUGH;
     case cmPolicies::OLD:
       break;
-    case cmPolicies::REQUIRED_IF_USED:
-    case cmPolicies::REQUIRED_ALWAYS:
     case cmPolicies::NEW:
       transformDepfile = true;
       break;

Source/cmMakefile.cxx

@@ -211,8 +211,6 @@ bool cmMakefile::CheckCMP0037(std::string const& targetName,
     case cmPolicies::OLD:
       break;
     case cmPolicies::NEW:
-    case cmPolicies::REQUIRED_IF_USED:
-    case cmPolicies::REQUIRED_ALWAYS:
       issueMessage = true;
       messageType = MessageType::FATAL_ERROR;
       break;
@@ -601,12 +599,6 @@ cmMakefile::IncludeScope::IncludeScope(cmMakefile* mf,
         // OLD behavior is to not push a scope at all.
         this->NoPolicyScope = true;
         break;
-      case cmPolicies::REQUIRED_IF_USED:
-      case cmPolicies::REQUIRED_ALWAYS:
-        // We should never make this policy required, but we handle it
-        // here just in case.
-        this->CheckCMP0011 = true;
-        CM_FALLTHROUGH;
       case cmPolicies::NEW:
         // NEW behavior is to push a (strong) scope.
         this->Makefile->PushPolicy();
@@ -664,17 +656,6 @@ void cmMakefile::IncludeScope::EnforceCMP0011()
         this->Makefile->IssueMessage(MessageType::AUTHOR_WARNING, e);
       }
       break;
-    case cmPolicies::REQUIRED_IF_USED:
-    case cmPolicies::REQUIRED_ALWAYS: {
-      auto e = cmStrCat(
-        cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0011),
-        "\n"
-        "The included script\n  ",
-        this->Makefile->GetBacktrace().Top().FilePath,
-        "\n"
-        "affects policy settings, so it requires this policy to be set.");
-      this->Makefile->IssueMessage(MessageType::FATAL_ERROR, e);
-    } break;
     case cmPolicies::OLD:
     case cmPolicies::NEW:
       // The script set this policy.  We assume the purpose of the
@@ -980,8 +961,6 @@ void cmMakefile::EnforceDirectoryLevelRules() const
         // OLD behavior is to use policy version 2.4 set in
         // cmListFileCache.
         break;
-      case cmPolicies::REQUIRED_IF_USED:
-      case cmPolicies::REQUIRED_ALWAYS:
       case cmPolicies::NEW:
         // NEW behavior is to issue an error.
         this->GetCMakeInstance()->IssueMessage(MessageType::FATAL_ERROR, e,
@@ -1183,8 +1162,6 @@ cmTarget* cmMakefile::GetCustomCommandTarget(
       case cmPolicies::OLD:
         break;
       case cmPolicies::NEW:
-      case cmPolicies::REQUIRED_IF_USED:
-      case cmPolicies::REQUIRED_ALWAYS:
         issueMessage = true;
         messageType = MessageType::FATAL_ERROR;
         break;
@@ -1539,12 +1516,6 @@ bool cmMakefile::ParseDefineFlag(std::string const& def, bool remove)
         // OLD behavior is to not escape the value.  We should not
         // convert the definition to use the property.
         return false;
-      case cmPolicies::REQUIRED_IF_USED:
-      case cmPolicies::REQUIRED_ALWAYS:
-        this->IssueMessage(
-          MessageType::FATAL_ERROR,
-          cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0005));
-        return false;
       case cmPolicies::NEW:
         // NEW behavior is to escape the value.  Proceed to convert it
         // to an entry in the property.
@@ -1923,11 +1894,6 @@ void cmMakefile::ConfigureSubDirectory(cmMakefile* mf)
       case cmPolicies::OLD:
         // OLD behavior does not warn.
         break;
-      case cmPolicies::REQUIRED_IF_USED:
-      case cmPolicies::REQUIRED_ALWAYS:
-        e += cmStrCat('\n',
-                      cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0014));
-        CM_FALLTHROUGH;
       case cmPolicies::NEW:
         // NEW behavior prints the error.
         this->IssueMessage(MessageType::FATAL_ERROR, e);
@@ -2116,8 +2082,6 @@ void cmMakefile::AddCacheDefinition(const std::string& name, cmValue value,
       this->StateSnapshot.RemoveDefinition(name);
       break;
     case cmPolicies::NEW:
-    case cmPolicies::REQUIRED_IF_USED:
-    case cmPolicies::REQUIRED_ALWAYS:
       break;
   }
 }
@@ -2790,8 +2754,6 @@ const std::string& cmMakefile::ExpandVariablesInString(
                                                noEscapes, atOnly, filename,
                                                line, removeEmpty, true);
       break;
-    case cmPolicies::REQUIRED_IF_USED:
-    case cmPolicies::REQUIRED_ALWAYS:
     // Messaging here would be *very* verbose.
     case cmPolicies::NEW:
       mtype = this->ExpandVariablesInStringNew(errorstr, source, escapeQuotes,
@@ -2937,11 +2899,6 @@ MessageType cmMakefile::ExpandVariablesInStringOld(
           // OLD behavior is to just warn and continue.
           mtype = MessageType::AUTHOR_WARNING;
           break;
-        case cmPolicies::REQUIRED_IF_USED:
-        case cmPolicies::REQUIRED_ALWAYS:
-          error += cmStrCat(
-            '\n', cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0010));
-          break;
         case cmPolicies::NEW:
           // NEW behavior is to report the error.
           break;
@@ -3962,8 +3919,6 @@ std::string cmMakefile::GetModulesFile(cm::string_view filename, bool& system,
           system = false;
           result = moduleInCMakeModulePath;
           break;
-        case cmPolicies::REQUIRED_IF_USED:
-        case cmPolicies::REQUIRED_ALWAYS:
         case cmPolicies::NEW:
           system = true;
           result = moduleInCMakeRoot;
@@ -4428,12 +4383,6 @@ bool cmMakefile::EnforceUniqueName(std::string const& name, std::string& msg,
         CM_FALLTHROUGH;
       case cmPolicies::OLD:
         return true;
-      case cmPolicies::REQUIRED_IF_USED:
-      case cmPolicies::REQUIRED_ALWAYS:
-        this->IssueMessage(
-          MessageType::FATAL_ERROR,
-          cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0002));
-        return true;
       case cmPolicies::NEW:
         break;
     }
@@ -4518,11 +4467,6 @@ bool cmMakefile::EnforceUniqueDir(const std::string& srcPath,
     case cmPolicies::OLD:
       // OLD behavior does not warn.
       return true;
-    case cmPolicies::REQUIRED_IF_USED:
-    case cmPolicies::REQUIRED_ALWAYS:
-      e = cmStrCat(cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0013),
-                   '\n');
-      CM_FALLTHROUGH;
     case cmPolicies::NEW:
       // NEW behavior prints the error.
       e += cmStrCat("The binary directory\n"
@@ -4742,8 +4686,6 @@ bool cmMakefile::IgnoreErrorsCMP0061() const
       CM_FALLTHROUGH;
     case cmPolicies::OLD:
       break;
-    case cmPolicies::REQUIRED_IF_USED:
-    case cmPolicies::REQUIRED_ALWAYS:
     case cmPolicies::NEW:
       ignoreErrors = false;
       break;

Source/cmMakefileTargetGenerator.cxx

@@ -75,8 +75,6 @@ cmMakefileTargetGenerator::cmMakefileTargetGenerator(cmGeneratorTarget* target)
       this->CMP0113New = false;
       break;
     case cmPolicies::NEW:
-    case cmPolicies::REQUIRED_IF_USED:
-    case cmPolicies::REQUIRED_ALWAYS:
       this->CMP0113New = true;
       break;
   }

Source/cmMarkAsAdvancedCommand.cxx

@@ -54,8 +54,6 @@ bool cmMarkAsAdvancedCommand(std::vector<std::string> const& args,
         oldBehavior = true;
         break;
       case cmPolicies::NEW:
-      case cmPolicies::REQUIRED_IF_USED:
-      case cmPolicies::REQUIRED_ALWAYS:
         if (!state->GetCacheEntryValue(variable)) {
           ignoreVariable = true;
         }

Source/cmNinjaTargetGenerator.cxx

@@ -1060,8 +1060,6 @@ void cmNinjaTargetGenerator::WriteObjectBuildStatements(
         case cmPolicies::WARN:
         case cmPolicies::OLD:
           break;
-        case cmPolicies::REQUIRED_ALWAYS:
-        case cmPolicies::REQUIRED_IF_USED:
         case cmPolicies::NEW:
           usePrivateGeneratedSources = true;
           break;

Source/cmOptionCommand.cxx

@@ -38,8 +38,6 @@ bool cmOptionCommand(std::vector<std::string> const& args,
       case cmPolicies::OLD:
         // OLD behavior does not warn.
         break;
-      case cmPolicies::REQUIRED_ALWAYS:
-      case cmPolicies::REQUIRED_IF_USED:
       case cmPolicies::NEW: {
         // See if a local variable with this name already exists.
         // If so we ignore the option command.

Source/cmPolicies.h

@@ -614,10 +614,6 @@ public:
     OLD,  ///< Use old behavior
     WARN, ///< Use old behavior but issue a warning
     NEW,  ///< Use new behavior
-    /// Issue an error if user doesn't set policy status to NEW and hits the
-    /// check
-    REQUIRED_IF_USED,
-    REQUIRED_ALWAYS ///< Issue an error unless user sets policy status to NEW.
   };
 
   /// Policy identifiers

Source/cmQtAutoGenInitializer.cxx

@@ -433,8 +433,6 @@ bool cmQtAutoGenInitializer::InitCustomTargets()
     case cmPolicies::OLD:
       // Ignore GENERATED files
       break;
-    case cmPolicies::REQUIRED_IF_USED:
-    case cmPolicies::REQUIRED_ALWAYS:
     case cmPolicies::NEW:
       // Process GENERATED files
       this->CMP0071Accept = true;
@@ -450,8 +448,6 @@ bool cmQtAutoGenInitializer::InitCustomTargets()
     case cmPolicies::OLD:
       // Ignore .hh files
       break;
-    case cmPolicies::REQUIRED_IF_USED:
-    case cmPolicies::REQUIRED_ALWAYS:
     case cmPolicies::NEW:
       // Process .hh file
       this->CMP0100Accept = true;
@@ -669,8 +665,6 @@ bool cmQtAutoGenInitializer::InitCustomTargets()
         case cmPolicies::OLD:
           addBefore = true;
           break;
-        case cmPolicies::REQUIRED_IF_USED:
-        case cmPolicies::REQUIRED_ALWAYS:
         case cmPolicies::NEW:
           this->GenTarget->AddSystemIncludeDirectory(this->Dir.IncludeGenExp,
                                                      "CXX");

Source/cmReturnCommand.cxx

@@ -29,13 +29,6 @@ bool cmReturnCommand(std::vector<std::string> const& args,
         CM_FALLTHROUGH;
       case cmPolicies::OLD:
         return true;
-      case cmPolicies::REQUIRED_IF_USED:
-      case cmPolicies::REQUIRED_ALWAYS:
-        status.GetMakefile().IssueMessage(
-          MessageType::FATAL_ERROR,
-          cmStrCat('\n', cmPolicies::GetPolicyWarning(cmPolicies::CMP0140)));
-        cmSystemTools::SetFatalErrorOccurred();
-        return false;
       default:
         break;
     }

Source/cmSourceFile.cxx

@@ -226,8 +226,6 @@ bool cmSourceFile::FindFullPath(std::string* error,
         err = cmStrCat(err, " .", ext);
       }
       break;
-    case cmPolicies::REQUIRED_IF_USED:
-    case cmPolicies::REQUIRED_ALWAYS:
     case cmPolicies::NEW:
       break;
   }

Source/cmState.cxx

@@ -464,8 +464,6 @@ void cmState::AddDisallowedCommand(std::string const& name,
           CM_FALLTHROUGH;
         case cmPolicies::OLD:
           break;
-        case cmPolicies::REQUIRED_IF_USED:
-        case cmPolicies::REQUIRED_ALWAYS:
         case cmPolicies::NEW:
           mf.IssueMessage(MessageType::FATAL_ERROR, message);
           return true;

Source/cmTarget.cxx

@@ -120,8 +120,6 @@ cmValue cmTargetPropertyComputer::GetSources<cmTarget>(cmTarget const* tgt,
             CM_FALLTHROUGH;
           case cmPolicies::OLD:
             break;
-          case cmPolicies::REQUIRED_ALWAYS:
-          case cmPolicies::REQUIRED_IF_USED:
           case cmPolicies::NEW:
             addContent = true;
             break;
@@ -1416,8 +1414,6 @@ std::string cmTargetInternals::ProcessSourceItemCMP0049(
       case cmPolicies::OLD:
         noMessage = true;
         break;
-      case cmPolicies::REQUIRED_ALWAYS:
-      case cmPolicies::REQUIRED_IF_USED:
       case cmPolicies::NEW:
         messageType = MessageType::FATAL_ERROR;
     }
@@ -2106,8 +2102,6 @@ struct ReadOnlyProperty
         case cmPolicies::OLD:
           readOnly = false;
           break;
-        case cmPolicies::REQUIRED_ALWAYS:
-        case cmPolicies::REQUIRED_IF_USED:
         case cmPolicies::NEW:
           context->IssueMessage(MessageType::FATAL_ERROR,
                                 this->message(prop, target));

Source/cmTargetLinkLibrariesCommand.cxx

@@ -115,10 +115,6 @@ bool cmTargetLinkLibrariesCommand(std::vector<std::string> const& args,
         case cmPolicies::OLD: // OLD behavior does not warn.
           t = MessageType::MESSAGE;
           break;
-        case cmPolicies::REQUIRED_IF_USED:
-        case cmPolicies::REQUIRED_ALWAYS:
-          e << '\n' << cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0016);
-          break;
         case cmPolicies::NEW: // NEW behavior prints the error.
           break;
       }
@@ -150,8 +146,6 @@ bool cmTargetLinkLibrariesCommand(std::vector<std::string> const& args,
         CM_FALLTHROUGH;
       case cmPolicies::OLD:
         break;
-      case cmPolicies::REQUIRED_ALWAYS:
-      case cmPolicies::REQUIRED_IF_USED:
       case cmPolicies::NEW:
         modal = "must";
         messageType = MessageType::FATAL_ERROR;
@@ -408,8 +402,6 @@ TLL::TLL(cmMakefile& mf, cmTarget* target)
       case cmPolicies::OLD:
         this->RejectRemoteLinking = true;
         break;
-      case cmPolicies::REQUIRED_ALWAYS:
-      case cmPolicies::REQUIRED_IF_USED:
       case cmPolicies::NEW:
         this->EncodeRemoteReference = true;
         break;
@@ -461,8 +453,6 @@ bool TLL::HandleLibrary(ProcessingState currentProcessingState,
         CM_FALLTHROUGH;
       case cmPolicies::OLD:
         break;
-      case cmPolicies::REQUIRED_ALWAYS:
-      case cmPolicies::REQUIRED_IF_USED:
       case cmPolicies::NEW:
         modal = "must";
         messageType = MessageType::FATAL_ERROR;

Source/cmTargetPropertyComputer.cxx

@@ -22,8 +22,6 @@ bool cmTargetPropertyComputer::HandleLocationPropertyPolicy(
       CM_FALLTHROUGH;
     case cmPolicies::OLD:
       break;
-    case cmPolicies::REQUIRED_ALWAYS:
-    case cmPolicies::REQUIRED_IF_USED:
     case cmPolicies::NEW:
       modal = "may";
       messageType = MessageType::FATAL_ERROR;

Source/cmTargetSourcesCommand.cxx

@@ -165,12 +165,6 @@ std::vector<std::string> TargetSourcesImpl::ConvertToAbsoluteContent(
       case cmPolicies::OLD:
         issueMessage = false;
         break;
-      case cmPolicies::REQUIRED_ALWAYS:
-      case cmPolicies::REQUIRED_IF_USED:
-        this->Makefile->IssueMessage(
-          MessageType::FATAL_ERROR,
-          cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0076));
-        break;
       case cmPolicies::NEW: {
         issueMessage = false;
         useAbsoluteContent = true;

Source/cmTestGenerator.cxx

@@ -49,8 +49,6 @@ bool needToQuoteTestName(const cmMakefile& mf, const std::string& name)
     case cmPolicies::OLD:
       // OLD behavior is to not quote the test's name.
       return false;
-    case cmPolicies::REQUIRED_IF_USED:
-    case cmPolicies::REQUIRED_ALWAYS:
     case cmPolicies::NEW:
     default:
       // NEW behavior is to quote the test's name.

Source/cmWhileCommand.cxx

@@ -126,8 +126,6 @@ bool cmWhileFunctionBlocker::Replay(std::vector<cmListFileFunction> functions,
       case cmPolicies::OLD:
         // OLD behavior is to silently ignore the error.
         break;
-      case cmPolicies::REQUIRED_ALWAYS:
-      case cmPolicies::REQUIRED_IF_USED:
       case cmPolicies::NEW:
         // NEW behavior is to enforce the error.
         enforceError = true;