[NameLookup] Prefer property wrapper over attached macro on local var

We don't properly support peer declarations in local contexts, as such
if we have both a property wrapper and macro with a given name on a
local var, let's prefer the property wrapper.

rdar://148782639

Author: hamishknight

lib/AST/NameLookup.cpp

@@ -3971,20 +3971,34 @@ GenericParamListRequest::evaluate(Evaluator &evaluator, GenericContext *value) c
       parsedGenericParams->getRAngleLoc());
 }
 
+static bool shouldPreferPropertyWrapperOverMacro(CustomAttrOwner owner) {
+  // If we have a VarDecl in a local context, prefer to use a property wrapper
+  // if one exists. This is necessary since we don't properly support peer
+  // declarations in local contexts, so want to use a property wrapper if one
+  // exists.
+  if (auto *D = dyn_cast_or_null<VarDecl>(owner.getAsDecl())) {
+    if (D->getDeclContext()->isLocalContext())
+      return true;
+  }
+  return false;
+}
+
 NominalTypeDecl *CustomAttrNominalRequest::evaluate(Evaluator &evaluator,
                                                     CustomAttr *attr) const {
   auto owner = attr->getOwner();
   auto *dc = owner.getDeclContext();
 
   // Look for names at module scope, so we don't trigger name lookup for
   // nested scopes. At this point, we're looking to see whether there are
-  // any suitable macros.
+  // any suitable macros. If we're preferring property wrappers we wait to see
+  // if any property wrappers are in scope before returning.
   auto [module, macro] = attr->destructureMacroRef();
   auto moduleName = (module) ? module->getNameRef() : DeclNameRef();
   auto macroName = (macro) ? macro->getNameRef() : DeclNameRef();
   auto macros = namelookup::lookupMacros(dc, moduleName, macroName,
                                          getAttachedMacroRoles());
-  if (!macros.empty())
+  auto shouldPreferPropWrapper = shouldPreferPropertyWrapperOverMacro(owner);
+  if (!macros.empty() && !shouldPreferPropWrapper)
     return nullptr;
 
   // Find the types referenced by the custom attribute.
@@ -4004,6 +4018,15 @@ NominalTypeDecl *CustomAttrNominalRequest::evaluate(Evaluator &evaluator,
   auto nominals = resolveTypeDeclsToNominal(evaluator, ctx, decls.first,
                                             ResolveToNominalOptions(),
                                             modulesFound, anyObject);
+  // If we're preferring property wrappers and found a suitable match, continue.
+  // Otherwise we can bail and resolve as a macro.
+  if (shouldPreferPropWrapper) {
+    auto hasPropWrapper = llvm::any_of(nominals, [](NominalTypeDecl *NTD) {
+      return NTD->getAttrs().hasAttribute<PropertyWrapperAttr>();
+    });
+    if (!macros.empty() && !hasPropWrapper)
+      return nullptr;
+  }
   if (nominals.size() == 1 && !isa<ProtocolDecl>(nominals.front()))
     return nominals.front();
 

lib/Sema/TypeCheckMacros.cpp

@@ -2241,7 +2241,12 @@ ConcreteDeclRef ResolveMacroRequest::evaluate(Evaluator &evaluator,
 
   // When a macro is not found for a custom attribute, it may be a non-macro.
   // So bail out to prevent diagnostics from the contraint system.
-  if (macroRef.getAttr()) {
+  if (auto *attr = macroRef.getAttr()) {
+    // If we already resolved this CustomAttr to a nominal, this isn't for a
+    // macro.
+    if (attr->getNominalDecl())
+      return ConcreteDeclRef();
+
     auto foundMacros = namelookup::lookupMacros(dc, macroRef.getModuleName(),
                                                 macroRef.getMacroName(), roles);
     if (foundMacros.empty())

test/NameLookup/property_wrapper_and_macro.swift

@@ -0,0 +1,89 @@
+// RUN: %empty-directory(%t)
+// RUN: split-file %s %t
+// RUN: %target-swift-frontend -emit-ir -primary-file %t/valid.swift %t/definitions.swift
+// RUN: %target-swift-frontend -typecheck -verify -verify-additional-prefix main- -primary-file %t/main.swift %t/definitions.swift
+// RUN: %target-swift-frontend -typecheck -verify -verify-additional-prefix other- -parse-as-library -primary-file %t/other.swift %t/definitions.swift
+
+//--- definitions.swift
+@attached(peer)
+macro SomeAttr() = #externalMacro(module: "", type: "") // expected-note {{declared here}}
+// expected-main-note@-1 2{{declared here}}
+
+@propertyWrapper
+struct SomeAttr<T> {
+  var wrappedValue: T
+  init(wrappedValue: T) { self.wrappedValue = wrappedValue }
+  init(projectedValue: Self) { self = projectedValue}
+  var projectedValue: Self { self }
+}
+
+struct Err: Error {}
+
+//--- valid.swift
+func foo() throws {
+  // Make sure we prefer the property wrapper over the macro here.
+  @SomeAttr var x = 0
+  let _: Int = x
+  let _: SomeAttr<Int> = _x
+  let _: SomeAttr<Int> = $x
+
+  _ = {
+    @SomeAttr var y = 0
+    let _: Int = y
+    let _: SomeAttr<Int> = _y
+    let _: SomeAttr<Int> = $y
+  }
+
+  func bar(@SomeAttr x: Int) {
+    let _: Int = x
+    let _: SomeAttr<Int> = _x
+    let _: SomeAttr<Int> = $x
+  }
+
+  bar($x: SomeAttr(wrappedValue: 0))
+
+  func baz(_ fn: (SomeAttr<Int>) -> Void) {}
+  baz { x in }
+  baz { $x in }
+
+  _ = if .random() {
+    @SomeAttr var z = 0
+    let _: SomeAttr<Int> = _z
+    let _: SomeAttr<Int> = $z
+    throw Err()
+  } else {
+    0
+  }
+}
+
+//--- main.swift
+struct S1 {
+  var x = if .random() {
+    @SomeAttr var y = 0
+    let _: SomeAttr<Int> = _y
+    let _: SomeAttr<Int> = $y
+    throw Err() // expected-error {{errors cannot be thrown out of a property initializer}}
+  } else {
+    0
+  }
+}
+
+// Here we prefer the macro.
+struct S2 {
+  @SomeAttr var x = 0 // expected-error {{could not be found for macro}}
+}
+
+func bar() {
+  @SomeAttr func baz() {} // expected-error {{could not be found for macro}}
+}
+
+@SomeAttr var x = 0 // expected-error {{could not be found for macro}}
+
+_ = { @SomeAttr<Int> in }
+// expected-error@-1 {{attribute @SomeAttr<Int> is not supported on a closure}}
+// expected-warning@-2 {{cannot specialize a non-generic external macro 'SomeAttr()'}}
+
+//--- other.swift
+
+// Also check for a library file
+@SomeAttr var x = 0 // expected-error {{could not be found for macro}}