Merge pull request #64302 from DougGregor/external-macro-without-decl

[Macros] Don't require a declaration of `#externalMacro`.

Author: swift-ci

lib/Sema/TypeCheckMacros.cpp

@@ -230,6 +230,24 @@ Optional<Identifier> getIdentifierFromStringLiteralArgument(
   return ctx.getIdentifier(contents);
 }
 
+/// For a macro expansion expression that is known to be #externalMacro,
+/// handle the definition.
+static MacroDefinition handleExternalMacroDefinition(
+    ASTContext &ctx, MacroExpansionExpr *expansion) {
+  // Dig out the module and type name.
+  auto moduleName = getIdentifierFromStringLiteralArgument(ctx, expansion, 0);
+  if (!moduleName) {
+    return MacroDefinition::forInvalid();
+  }
+
+  auto typeName = getIdentifierFromStringLiteralArgument(ctx, expansion, 1);
+  if (!typeName) {
+    return MacroDefinition::forInvalid();
+  }
+
+  return MacroDefinition::forExternal(*moduleName, *typeName);
+}
+
 MacroDefinition MacroDefinitionRequest::evaluate(
     Evaluator &evaluator, MacroDecl *macro
 ) const {
@@ -258,6 +276,14 @@ MacroDefinition MacroDefinitionRequest::evaluate(
     return MacroDefinition::forInvalid();
   }
 
+  // Handle #externalMacro without requiring a declaration at all.
+  // Note: this is a workaround to allow newer compilers to work with
+  // older standard libraries.
+  if (expansion->getMacroName().getBaseName().userFacingName() ==
+          "externalMacro") {
+    return handleExternalMacroDefinition(ctx, expansion);
+  }
+
   // Type-check the macro expansion.
   Type resultType = macro->mapTypeIntoContext(macro->getResultInterfaceType());
 
@@ -290,18 +316,7 @@ MacroDefinition MacroDefinitionRequest::evaluate(
     return MacroDefinition::forInvalid();
   }
 
-  // Dig out the module and type name.
-  auto moduleName = getIdentifierFromStringLiteralArgument(ctx, expansion, 0);
-  if (!moduleName) {
-    return MacroDefinition::forInvalid();
-  }
-
-  auto typeName = getIdentifierFromStringLiteralArgument(ctx, expansion, 1);
-  if (!typeName) {
-    return MacroDefinition::forInvalid();
-  }
-
-  return MacroDefinition::forExternal(*moduleName, *typeName);
+  return handleExternalMacroDefinition(ctx, expansion);
 }
 
 /// Load a plugin library based on a module name.

test/Macros/external-macro-without-decl.swift

@@ -0,0 +1,68 @@
+// RUN: %target-typecheck-verify-swift -swift-version 5 -module-name Swift -parse-stdlib
+
+// expected-warning@+2{{@expression has been removed in favor of @freestanding(expression)}}
+// expected-warning@+1{{external macro implementation type 'A.B' could not be found for macro 'myMacro()'; the type must be public and provided via '-load-plugin-library'}}
+@expression macro myMacro() = #externalMacro(module: "A", type: "B")
+
+// Protocols needed for string literals to work
+public protocol ExpressibleByUnicodeScalarLiteral {
+  associatedtype UnicodeScalarLiteralType: _ExpressibleByBuiltinUnicodeScalarLiteral
+
+  init(unicodeScalarLiteral value: UnicodeScalarLiteralType)
+}
+
+public protocol _ExpressibleByBuiltinExtendedGraphemeClusterLiteral
+  : _ExpressibleByBuiltinUnicodeScalarLiteral {
+
+  init(
+    _builtinExtendedGraphemeClusterLiteral start: Builtin.RawPointer,
+    utf8CodeUnitCount: Builtin.Word,
+    isASCII: Builtin.Int1)
+}
+
+public protocol ExpressibleByExtendedGraphemeClusterLiteral
+  : ExpressibleByUnicodeScalarLiteral {
+
+  associatedtype ExtendedGraphemeClusterLiteralType
+    : _ExpressibleByBuiltinExtendedGraphemeClusterLiteral
+
+  init(extendedGraphemeClusterLiteral value: ExtendedGraphemeClusterLiteralType)
+}
+
+extension ExpressibleByExtendedGraphemeClusterLiteral
+  where ExtendedGraphemeClusterLiteralType == UnicodeScalarLiteralType {
+
+  @_transparent
+  public init(unicodeScalarLiteral value: ExtendedGraphemeClusterLiteralType) {
+    self.init(extendedGraphemeClusterLiteral: value)
+  }
+}
+
+public protocol _ExpressibleByBuiltinStringLiteral
+  : _ExpressibleByBuiltinExtendedGraphemeClusterLiteral {
+
+  init(
+    _builtinStringLiteral start: Builtin.RawPointer,
+    utf8CodeUnitCount: Builtin.Word,
+    isASCII: Builtin.Int1)
+}
+
+public protocol ExpressibleByStringLiteral
+  : ExpressibleByExtendedGraphemeClusterLiteral {
+  associatedtype StringLiteralType: _ExpressibleByBuiltinStringLiteral
+
+  init(stringLiteral value: StringLiteralType)
+}
+
+extension ExpressibleByStringLiteral
+  where StringLiteralType == ExtendedGraphemeClusterLiteralType {
+
+  @_transparent
+  public init(extendedGraphemeClusterLiteral value: StringLiteralType) {
+    self.init(stringLiteral: value)
+  }
+}
+
+public protocol _ExpressibleByBuiltinUnicodeScalarLiteral {
+  init(_builtinUnicodeScalarLiteral value: Builtin.Int32)
+}

test/Macros/macros_diagnostics.swift

@@ -14,7 +14,7 @@ protocol P { }
 
 @freestanding(expression) macro tryToHide<T: P>(_: T) -> some P = #externalMacro(module: "BuiltinMacros", type: "Blah")
 // expected-error@-1{{some' types are only permitted in properties, subscripts, and functions}}
-// expected-error@-2{{generic parameter 'T' could not be inferred}}
+// expected-warning@-2{{external macro implementation type}}
 
 internal struct X { } // expected-note{{type declared here}}