[Macros] Diagnose when we forget to provide macro arguments.

Unlike functions, you can't curry macros; diagnose when one omits the
arguments in a macro expansion of a macro that has a parameter list.

Author: DougGregor

include/swift/AST/DiagnosticsSema.def

@@ -6796,6 +6796,8 @@ ERROR(macro_without_context,none,
        (DeclName))
 ERROR(macro_expansion_missing_pound,none,
       "expansion of macro %0 requires leading '#'", (DeclName))
+ERROR(macro_expansion_missing_arguments,none,
+      "expansion of macro %0 requires arguments", (DeclName))
 
 //------------------------------------------------------------------------------
 // MARK: Move Only Errors

include/swift/Sema/CSFix.h

@@ -418,6 +418,9 @@ enum class FixKind : uint8_t {
 
   /// Macro without leading #.
   MacroMissingPound,
+
+  /// Macro that has parameters but was not provided with any arguments.
+  MacroMissingArguments,
 };
 
 class ConstraintFix {
@@ -3257,6 +3260,32 @@ 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;
+  }
+};
+
 } // end namespace constraints
 } // end namespace swift
 

lib/Sema/CSDiagnostics.cpp

@@ -8502,3 +8502,32 @@ bool AddMissingMacroPound::diagnoseAsError() {
     .fixItInsert(getLoc(), "#");
   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;
+}

lib/Sema/CSDiagnostics.h

@@ -2877,6 +2877,29 @@ 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;
+};
+
 } // end namespace constraints
 } // end namespace swift
 

lib/Sema/CSFix.cpp

@@ -2613,3 +2613,15 @@ MacroMissingPound::create(ConstraintSystem &cs, MacroDecl *macro,
                           ConstraintLocator *locator) {
   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);
+}

lib/Sema/CSGen.cpp

@@ -3782,9 +3782,16 @@ namespace {
 #if SWIFT_SWIFT_PARSER
       auto &ctx = CS.getASTContext();
       if (ctx.LangOpts.hasFeature(Feature::Macros)) {
+        auto locator = CS.getConstraintLocator(expr);
+
+        // For calls, set up the argument list.
+        bool isCall = expr->getArgs() != nullptr;
+        if (isCall) {
+          CS.associateArgumentList(locator, expr->getArgs());
+        }
+
         // Look up the macros with this name.
         auto macroIdent = expr->getMacroName().getBaseIdentifier();
-        bool isCall = expr->getArgs() != nullptr;
         FunctionRefKind functionRefKind = isCall ? FunctionRefKind::SingleApply
                                                  : FunctionRefKind::Unapplied;
         auto macros = lookupMacros(
@@ -3798,7 +3805,6 @@ namespace {
         }
 
         // Introduce an overload set for the macro reference.
-        auto locator = CS.getConstraintLocator(expr);
         auto macroRefType = Type(CS.createTypeVariable(locator, 0));
         CS.addOverloadSet(macroRefType, macros, CurDC, locator);
 
@@ -3814,10 +3820,8 @@ namespace {
         if (!isCall)
           return macroRefType;
 
-        // For calls, set up the argument list and form the applicable-function
-        // constraint. The result type is the result of that call.
-        CS.associateArgumentList(locator, expr->getArgs());
-
+        // For calls, form the applicable-function constraint. The result type
+        // is the result of that call.
         SmallVector<AnyFunctionType::Param, 8> params;
         getMatchingParams(expr->getArgs(), params);
 

lib/Sema/CSSimplify.cpp

@@ -13810,7 +13810,8 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyFixConstraint(
   case FixKind::IgnoreKeyPathContextualMismatch:
   case FixKind::NotCompileTimeConst:
   case FixKind::RenameConflictingPatternVariables:
-  case FixKind::MacroMissingPound: {
+  case FixKind::MacroMissingPound:
+  case FixKind::MacroMissingArguments: {
     return recordFix(fix) ? SolutionKind::Error : SolutionKind::Solved;
   }
   case FixKind::IgnoreInvalidASTNode: {

lib/Sema/ConstraintSystem.cpp

@@ -3569,12 +3569,34 @@ void ConstraintSystem::resolveOverload(ConstraintLocator *locator,
       }
     }
 
-    // If we have a macro, it can only be used in an expansion.
+    // If we have a macro, check for correct usage.
     if (auto macro = dyn_cast<MacroDecl>(decl)) {
+      // Macro can only be used in an expansion. If we end up here, it's
+      // because we found a macro but are missing the leading '#'.
       if (!locator->isForMacroExpansion()) {
         // 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));
+      }
     }
   }
 

test/Macros/macros_diagnostics.swift

@@ -47,6 +47,9 @@ func overloaded1(_ p: Any) { }
 @expression macro notOverloaded1(_ p: P) = MissingModule.MissingType // expected-note{{'notOverloaded1' previously declared here}}
 @expression macro notOverloaded1(_ p: P) = MissingModule.MissingOtherType // expected-error{{invalid redeclaration of 'notOverloaded1'}}
 
+@expression macro intIdentity(value: Int, _: Float) -> Int = MissingModule.MissingType
+// expected-note@-1{{macro 'intIdentity(value:_:)' declared here}}
+
 func testDiags(a: Int, b: Int) {
   // FIXME: Bad diagnostic.
   let s = #stringify<Int, Int>(a + b) // expected-error{{type of expression is ambiguous without more context}}
@@ -66,6 +69,8 @@ func testDiags(a: Int, b: Int) {
   _ = stringify(a + b)
   // expected-error@-1{{expansion of macro 'stringify' requires leading '#'}}{{7-7=#}}
 
+  _ = #intIdentity // expected-error{{expansion of macro 'intIdentity(value:_:)' requires arguments}}{{19-19=(value: <#Int#>, <#Float#>)}}
+
   overloaded1(a) // okay, calls the function
   #overloaded1(a) // expected-error{{argument type 'Int' does not conform to expected type 'P'}}
 }