[Macros] Start threading argument labels through macros.

Author: DougGregor

lib/Parse/ParseType.cpp

@@ -18,6 +18,7 @@
 #include "swift/AST/ASTWalker.h"
 #include "swift/AST/Attr.h"
 #include "swift/AST/GenericParamList.h"
+#include "swift/AST/SourceFile.h" // only for isMacroSignatureFile
 #include "swift/AST/TypeRepr.h"
 #include "swift/Parse/Lexer.h"
 #include "swift/Parse/CodeCompletionCallbacks.h"
@@ -1067,6 +1068,11 @@ ParserResult<TypeRepr> Parser::parseOldStyleProtocolComposition() {
   return makeParserResult(Status, composition);
 }
 
+/// FIXME: This is an egregious hack.
+static bool isMacroSignatureFile(SourceFile &sf) {
+  return sf.getFilename().startswith("Macro signature of");
+}
+
 /// parseTypeTupleBody
 ///   type-tuple:
 ///     '(' type-tuple-body? ')'
@@ -1209,7 +1215,8 @@ ParserResult<TypeRepr> Parser::parseTypeTupleBody() {
 
     // If there was a first name, complain; arguments in function types are
     // always unlabeled.
-    if (element.NameLoc.isValid() && !element.Name.empty()) {
+    if (element.NameLoc.isValid() && !element.Name.empty() &&
+        /*FIXME: Gross hack*/!isMacroSignatureFile(SF)) {
       auto diag = diagnose(element.NameLoc, diag::function_type_argument_label,
                            element.Name);
       if (element.SecondNameLoc.isInvalid())

lib/Sema/CSApply.cpp

@@ -2982,9 +2982,6 @@ namespace {
         auto overload = solution.getOverloadChoice(locator);
 
         auto macro = cast<MacroDecl>(overload.choice.getDecl());
-        // FIXME: use the macro for expansion!
-        // FIXME: form a proper ConcreteDeclRef for the macro expansion!
-
         ConcreteDeclRef macroRef = resolveConcreteDeclRef(macro, locator);
         if (auto newExpr = expandMacroExpr(dc, expr, macroRef, expandedType)) {
           auto expansion = new (ctx) MacroExpansionExpr(

lib/Sema/CSSimplify.cpp

@@ -178,6 +178,8 @@ static bool areConservativelyCompatibleArgumentLabels(
     if (!varTy->mayBeCallable(cs.DC))
       return false;
     fnType = varTy->getAs<AnyFunctionType>();
+  } else if (auto *MD = dyn_cast<MacroDecl>(decl)) {
+    fnType = MD->getInterfaceType()->getAs<AnyFunctionType>();
   }
 
   // Given we want to be conservative with this checking, if there's any case

lib/Sema/ConstraintSystem.cpp

@@ -1610,10 +1610,6 @@ ConstraintSystem::getTypeOfReference(ValueDecl *value,
   if (auto macro = dyn_cast<MacroDecl>(value)) {
     Type macroType = macro->getInterfaceType();
 
-    // Remove argument labels when we have a function-like macro.
-    if (isa<AnyFunctionType>(macroType.getPointer()))
-      macroType = macroType->removeArgumentLabels(1);
-
     // Open any the generic types.
     OpenedTypeMap replacements;
     openGeneric(macro->getParentModule(), macro->getGenericSignature(),

lib/Sema/TypeCheckType.cpp

@@ -3235,11 +3235,19 @@ TypeResolver::resolveASTFunctionTypeParams(TupleTypeRepr *inputRepr,
       }
     }
 
+    Identifier argumentLabel;
+    Identifier parameterName;
+    if (inputRepr->getElement(i).SecondNameLoc.isValid()) {
+      argumentLabel = inputRepr->getElement(i).Name;
+      parameterName = inputRepr->getElement(i).SecondName;
+    } else {
+      parameterName = inputRepr->getElementName(i);
+    }
+
     auto paramFlags = ParameterTypeFlags::fromParameterType(
         ty, variadic, autoclosure, /*isNonEphemeral*/ false, ownership,
         isolated, noDerivative, compileTimeConst);
-    elements.emplace_back(ty, Identifier(), paramFlags,
-                          inputRepr->getElementName(i));
+    elements.emplace_back(ty, argumentLabel, paramFlags, parameterName);
   }
 
   return elements;

test/Macros/Inputs/macro_definition.swift

@@ -96,6 +96,94 @@ struct StringifyMacro: _CompilerPlugin {
   }
 }
 
+struct ColorLiteralMacro: _CompilerPlugin {
+  static func _name() -> (UnsafePointer<UInt8>, count: Int) {
+    var name = "customColorLiteral"
+    return name.withUTF8 { buffer in
+      let result = UnsafeMutablePointer<UInt8>.allocate(capacity: buffer.count)
+      result.initialize(from: buffer.baseAddress!, count: buffer.count)
+      return (UnsafePointer(result), count: buffer.count)
+    }
+  }
+
+  static func _genericSignature() -> (UnsafePointer<UInt8>?, count: Int) {
+    var genSig = "<T: _ExpressibleByColorLiteral>"
+    return genSig.withUTF8 { buffer in
+      let result = UnsafeMutablePointer<UInt8>.allocate(capacity: buffer.count)
+      result.initialize(from: buffer.baseAddress!, count: buffer.count)
+      return (UnsafePointer(result), count: buffer.count)
+    }
+  }
+
+  static func _typeSignature() -> (UnsafePointer<UInt8>, count: Int) {
+    var typeSig =
+      """
+      (
+       red red: Float, green green: Float, blue blue: Float, alpha alpha: Float
+      ) -> T
+      """
+    return typeSig.withUTF8 { buffer in
+      let result = UnsafeMutablePointer<UInt8>.allocate(capacity: buffer.count)
+      result.initialize(from: buffer.baseAddress!, count: buffer.count)
+      return (UnsafePointer(result), count: buffer.count)
+    }
+  }
+
+  static func _owningModule() -> (UnsafePointer<UInt8>, count: Int) {
+    var swiftModule = "Swift"
+    return swiftModule.withUTF8 { buffer in
+      let result = UnsafeMutablePointer<UInt8>.allocate(capacity: buffer.count)
+      result.initialize(from: buffer.baseAddress!, count: buffer.count)
+      return (UnsafePointer(result), count: buffer.count)
+    }
+  }
+
+  static func _supplementalSignatureModules() -> (UnsafePointer<UInt8>, count: Int) {
+    var nothing = ""
+    return nothing.withUTF8 { buffer in
+      let result = UnsafeMutablePointer<UInt8>.allocate(capacity: buffer.count)
+      result.initialize(from: buffer.baseAddress!, count: buffer.count)
+      return (UnsafePointer(result), count: buffer.count)
+    }
+  }
+
+  static func _kind() -> _CompilerPluginKind {
+    .expressionMacro
+  }
+
+  static func _rewrite(
+    targetModuleName: UnsafePointer<UInt8>,
+    targetModuleNameCount: Int,
+    filePath: UnsafePointer<UInt8>,
+    filePathCount: Int,
+    sourceFileText: UnsafePointer<UInt8>,
+    sourceFileTextCount: Int,
+    localSourceText: UnsafePointer<UInt8>,
+    localSourceTextCount: Int
+  ) -> (UnsafePointer<UInt8>?, count: Int) {
+    let meeTextBuffer = UnsafeBufferPointer(
+      start: localSourceText, count: localSourceTextCount)
+    let meeText = String(decoding: meeTextBuffer, as: UTF8.self)
+    let prefix = "#customColorLiteral(red:"
+    guard meeText.starts(with: prefix), meeText.last == ")" else {
+      return (nil, 0)
+    }
+    let expr = meeText.dropFirst(prefix.count).dropLast()
+    var resultString = ".init(_colorLiteralRed:\(expr))"
+    return resultString.withUTF8 { buffer in
+      let result = UnsafeMutableBufferPointer<UInt8>.allocate(
+          capacity: buffer.count + 1)
+      _ = result.initialize(from: buffer)
+      result[buffer.count] = 0
+      return (UnsafePointer(result.baseAddress), buffer.count)
+    }
+  }
+}
+
+
 public var allMacros: [Any.Type] {
-  [StringifyMacro.self]
+  [
+    StringifyMacro.self,
+    ColorLiteralMacro.self
+  ]
 }

test/Macros/macro_plugin.swift

@@ -34,3 +34,10 @@ let _ = #customStringify(["a", "b", "c"] + ["d", "e", "f"])
 // CHECK:   (tuple_expr type='([String], String)'
 // CHECK:     (binary_expr type='[String]'
 // CHECK:     (string_literal_expr type='String'
+
+struct MyColor: _ExpressibleByColorLiteral {
+  init(_colorLiteralRed red: Float, green: Float, blue: Float, alpha: Float) { }
+}
+
+let _: MyColor = #customColorLiteral(red: 0.5, green: 0.5, blue: 0.2, alpha: 0.9)
+