[Diagnostics] Remove the MacroMissingArguments constraint fix and its

associated failure diagnostic.

This constraint fix is unused now that MacroExpansionExpr always has an
argument list, and goes through the AddMissingArguments constraint fix for
this error.

Author: hborla

include/swift/Sema/CSFix.h

@@ -419,9 +419,6 @@ enum class FixKind : uint8_t {
   /// Macro without leading #.
   MacroMissingPound,
 
-  /// Macro that has parameters but was not provided with any arguments.
-  MacroMissingArguments,
-
   /// Allow function type actor mismatch e.g. `@MainActor () -> Void`
   /// vs.`@OtherActor () -> Void`
   AllowGlobalActorMismatch,
@@ -3268,32 +3265,6 @@ class MacroMissingPound final : public ConstraintFix {
   }
 };
 
-class MacroMissingArguments final : public ConstraintFix {
-  MacroDecl *macro;
-
-  MacroMissingArguments(ConstraintSystem &cs, MacroDecl *macro,
-                        ConstraintLocator *locator)
-      : ConstraintFix(cs, FixKind::MacroMissingArguments, locator),
-        macro(macro) { }
-
-public:
-  std::string getName() const override { return "macro missing arguments"; }
-
-  bool diagnose(const Solution &solution, bool asNote = false) const override;
-
-  bool diagnoseForAmbiguity(CommonFixesArray commonFixes) const override {
-    return diagnose(*commonFixes.front().first);
-  }
-
-  static MacroMissingArguments *
-  create(ConstraintSystem &cs, MacroDecl *macro,
-         ConstraintLocator *locator);
-
-  static bool classof(ConstraintFix *fix) {
-    return fix->getKind() == FixKind::MacroMissingArguments;
-  }
-};
-
 /// Allow mismatch between function types global actors.
 /// e.g.  `@MainActor () -> Void` vs.`@OtherActor () -> Void`
 class AllowGlobalActorMismatch final : public ContextualMismatch {

lib/Sema/CSDiagnostics.cpp

@@ -8530,35 +8530,6 @@ bool AddMissingMacroPound::diagnoseAsError() {
   return true;
 }
 
-bool AddMissingMacroArguments::diagnoseAsError() {
-  std::string argumentString;
-  {
-    llvm::raw_string_ostream out(argumentString);
-    out << "(";
-    llvm::interleave(
-        macro->parameterList->begin(), macro->parameterList->end(),
-        [&](ParamDecl *param) {
-          if (!param->getArgumentName().empty()) {
-            out << param->getArgumentName() << ": ";
-          }
-
-          out << "<#" << param->getInterfaceType().getString() << "#" << ">";
-        },
-        [&] {
-          out << ", ";
-        });
-    out << ")";
-  }
-
-  auto insertLoc = getRawAnchor().getEndLoc();
-  emitDiagnostic(diag::macro_expansion_missing_arguments, macro->getName())
-    .fixItInsertAfter(insertLoc, argumentString);
-  macro->diagnose(
-      diag::kind_declname_declared_here, macro->getDescriptiveKind(),
-      macro->getName());
-  return true;
-}
-
 bool GlobalActorFunctionMismatchFailure::diagnoseTupleElement() {
   auto *locator = getLocator();
   auto path = locator->getPath();

lib/Sema/CSDiagnostics.h

@@ -2877,29 +2877,6 @@ class AddMissingMacroPound final : public FailureDiagnostic {
   bool diagnoseAsError() override;
 };
 
-/// Diagnose situations where we end up type checking a reference to a macro
-/// that has parameters, but was not provided any arguments.
-///
-/// \code
-/// func print(_ value: Any)
-/// @expression macro print<Value...>(_ value: Value...)
-///
-/// func test(e: E) {
-///   #print
-/// }
-/// \endcode
-class AddMissingMacroArguments final : public FailureDiagnostic {
-  MacroDecl *macro;
-
-public:
-  AddMissingMacroArguments(const Solution &solution, MacroDecl *macro,
-                       ConstraintLocator *locator)
-    : FailureDiagnostic(solution, locator),
-      macro(macro) { }
-
-  bool diagnoseAsError() override;
-};
-
 /// Diagnose function types global actor mismatches
 /// e.g.  `@MainActor () -> Void` vs.`@OtherActor () -> Void`
 class GlobalActorFunctionMismatchFailure final : public ContextualFailure {

lib/Sema/CSFix.cpp

@@ -2614,18 +2614,6 @@ MacroMissingPound::create(ConstraintSystem &cs, MacroDecl *macro,
   return new (cs.getAllocator()) MacroMissingPound(cs, macro, locator);
 }
 
-bool MacroMissingArguments::diagnose(const Solution &solution,
-                                     bool asNote) const {
-  AddMissingMacroArguments failure(solution, macro, getLocator());
-  return failure.diagnose(asNote);
-}
-
-MacroMissingArguments *
-MacroMissingArguments::create(ConstraintSystem &cs, MacroDecl *macro,
-                              ConstraintLocator *locator) {
-  return new (cs.getAllocator()) MacroMissingArguments(cs, macro, locator);
-}
-
 bool AllowGlobalActorMismatch::diagnose(const Solution &solution,
                                         bool asNote) const {
   GlobalActorFunctionMismatchFailure failure(solution, getFromType(),

lib/Sema/CSSimplify.cpp

@@ -13944,7 +13944,6 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyFixConstraint(
   case FixKind::NotCompileTimeConst:
   case FixKind::RenameConflictingPatternVariables:
   case FixKind::MacroMissingPound:
-  case FixKind::MacroMissingArguments:
   case FixKind::AllowGlobalActorMismatch: {
     return recordFix(fix) ? SolutionKind::Error : SolutionKind::Solved;
   }

lib/Sema/ConstraintSystem.cpp

@@ -3594,26 +3594,6 @@ void ConstraintSystem::resolveOverload(ConstraintLocator *locator,
         // Record a fix here
         (void)recordFix(MacroMissingPound::create(*this, macro, locator));
       }
-
-      // If the macro has parameters but wasn't provided with any arguments,
-      // introduce a fix to add the arguments.
-      bool isCall;
-      switch (choice.getFunctionRefKind()) {
-      case FunctionRefKind::SingleApply:
-      case FunctionRefKind::DoubleApply:
-        isCall = true;
-        break;
-
-      case FunctionRefKind::Unapplied:
-      case FunctionRefKind::Compound:
-        // Note: macros don't have compound name references.
-        isCall = false;
-        break;
-      }
-      if (macro->parameterList && !isCall) {
-        // Record a fix here
-        (void)recordFix(MacroMissingArguments::create(*this, macro, locator));
-      }
     }
   }