Merge branch 'master' of github.com:apple/swift into tensorflow-stage

* 'master' of github.com:apple/swift:
  [Docs] Update the documentation contents and index (swiftlang#34157)
  [SILGen] Don't use assign_by_wrapper for local property wrappers if there is an initial wrapped value.
  [Property Wrappers] Ban non-member property wrappers with observers, just like we do for regular non-member properties.
  [Test] Start to add SILGen tests for local property wrappers.
  [SILGen] Add a new CaptureEmission kind specifically for emitting captured local variables for the assign_by_wrapper setter.
  [Name Lookup] Remove property wrapper name lookup flags and generalize unqualified lookup of auxiliary decl names.
  [Property Wrappers] Generalize a few property wrapper decl context checks to check for type context instead of local context.
  [Property Wrappers] Add a VarDecl helper method for visiting synthesized property wrapper vars.
  [Property Wrappers] Allow property wrappers on local variables.
  [Property Wrappers] Make sure captures are computed for synthesized property wrapper accessors.
  [SILGen] Only use assign_by_wrapper for wrapped instance properties inside an initializer, and for wrapped local variables.
  [SILGen] Teach SIlGen to emit local property wrappers
  [NameLookup] Teach unqualified lookup to resolve backing property wrapper and projected value references
  [Parser] Don't resolve decl references in the parser if the declaration has a custom attribute.

Author: ainu-bot

docs/README.md

@@ -113,7 +113,7 @@ documentation, please create a thread on the Swift forums under the
     Describes how the "Omit Needless Words" algorithm works,
     making imported names more idiomatic.
 - Type-checking and inference:
-  - [TypeChecker.rst](/docs/TypeChecker.rst):
+  - [TypeChecker.md](/docs/TypeChecker.md):
     Provides an overview of how type-checking and inference work.
   - [RequestEvaluator.md](/docs/RequestEvaluator.md):
     Describes the request evaluator architecture, which is used for

docs/contents.rst

@@ -12,7 +12,6 @@ Contents
    Generics
    StoredAndComputedVariables
    SIL
-   TypeChecker
    OptimizationTips
    ABI: TypeMetadata <ABI/TypeMetadata>
    ABI: TypeLayout <ABI/TypeLayout>

include/swift/AST/Decl.h

@@ -4865,6 +4865,14 @@ class VarDecl : public AbstractStorageDecl {
   /// property wrapper with a \c projectedValue .
   VarDecl *getPropertyWrapperProjectionVar() const;
 
+  /// Visit all auxiliary declarations to this VarDecl.
+  ///
+  /// An auxiliary declaration is a declaration synthesized by the compiler to support
+  /// this VarDecl, such as synthesized property wrapper variables.
+  ///
+  /// \note this function only visits auxiliary decls that are not part of the AST.
+  void visitAuxiliaryDecls(llvm::function_ref<void(VarDecl *)>) const;
+
   /// Retrieve the backing storage property for a lazy property.
   VarDecl *getLazyStorageProperty() const;
 

include/swift/AST/DiagnosticsSema.def

@@ -5275,8 +5275,6 @@ ERROR(property_wrapper_mutating_get_composed_to_get_only,none,
       "property wrapper %0 with a mutating getter cannot be composed inside "
       "get-only property wrapper %1", (TypeLoc, TypeLoc))
 
-ERROR(property_wrapper_local,none,
-      "property wrappers are not yet supported on local properties", ())
 ERROR(property_wrapper_top_level,none,
       "property wrappers are not yet supported in top-level code", ())
 ERROR(property_wrapper_let, none,

lib/AST/Decl.cpp

@@ -5888,6 +5888,17 @@ VarDecl *VarDecl::getPropertyWrapperProjectionVar() const {
   return getPropertyWrapperBackingPropertyInfo().projectionVar;
 }
 
+void VarDecl::visitAuxiliaryDecls(llvm::function_ref<void(VarDecl *)> visit) const {
+  if (getDeclContext()->isTypeContext())
+    return;
+
+  if (auto *backingVar = getPropertyWrapperBackingProperty())
+    visit(backingVar);
+
+  if (auto *projectionVar = getPropertyWrapperProjectionVar())
+    visit(projectionVar);
+}
+
 VarDecl *VarDecl::getLazyStorageProperty() const {
   auto &ctx = getASTContext();
   auto mutableThis = const_cast<VarDecl *>(this);

lib/AST/UnqualifiedLookup.cpp

@@ -22,6 +22,7 @@
 #include "swift/AST/ModuleNameLookup.h"
 #include "swift/AST/NameLookup.h"
 #include "swift/AST/NameLookupRequests.h"
+#include "swift/AST/PropertyWrappers.h"
 #include "swift/Basic/Debug.h"
 #include "swift/Basic/STLExtras.h"
 #include "swift/Basic/SourceManager.h"
@@ -564,8 +565,22 @@ bool ASTScopeDeclConsumerForUnqualifiedLookup::consume(
       }
     }
 
-    if (!value->getName().matchesRef(factory.Name.getFullName()))
-      continue;
+    auto fullName = factory.Name.getFullName();
+    if (!value->getName().matchesRef(fullName)) {
+      bool foundMatch = false;
+      if (auto *varDecl = dyn_cast<VarDecl>(value)) {
+        // Check if the name matches any auxiliary decls not in the AST
+        varDecl->visitAuxiliaryDecls([&](VarDecl *auxiliaryVar) {
+          if (auxiliaryVar->ValueDecl::getName().matchesRef(fullName)) {
+            value = auxiliaryVar;
+            foundMatch = true;
+          }
+        });
+      }
+
+      if (!foundMatch)
+        continue;
+    }
 
     // In order to preserve the behavior of the existing context-based lookup,
     // which finds all results for non-local variables at the top level instead

lib/Parse/ParseExpr.cpp

@@ -2228,7 +2228,7 @@ Expr *Parser::parseExprIdentifier() {
   }
 
   Expr *E;
-  if (D == nullptr) {
+  if (D == nullptr || D->getAttrs().hasAttribute<CustomAttr>()) {
     if (name.getBaseName().isEditorPlaceholder()) {
       IDSyntaxContext.setCreateSyntax(SyntaxKind::EditorPlaceholderExpr);
       return parseExprEditorPlaceholder(IdentTok, name.getBaseIdentifier());

lib/SIL/IR/SILDeclRef.cpp

@@ -487,7 +487,8 @@ IsSerialized_t SILDeclRef::isSerialized() const {
 
   // Stored property initializers are inlinable if the type is explicitly
   // marked as @frozen.
-  if (isStoredPropertyInitializer() || isPropertyWrapperBackingInitializer()) {
+  if (isStoredPropertyInitializer() || (isPropertyWrapperBackingInitializer() &&
+                                        d->getDeclContext()->isTypeContext())) {
     auto *nominal = cast<NominalTypeDecl>(d->getDeclContext());
     auto scope =
       nominal->getFormalAccessScope(/*useDC=*/nullptr,

lib/SILGen/SILGenDecl.cpp

@@ -22,6 +22,7 @@
 #include "swift/AST/Module.h"
 #include "swift/AST/NameLookup.h"
 #include "swift/AST/ProtocolConformance.h"
+#include "swift/AST/PropertyWrappers.h"
 #include "swift/Basic/ProfileCounter.h"
 #include "swift/SIL/FormalLinkage.h"
 #include "swift/SIL/PrettyStackTrace.h"
@@ -1171,6 +1172,22 @@ void SILGenFunction::emitPatternBinding(PatternBindingDecl *PBD,
   // the initialization. Otherwise, mark it uninitialized for DI to resolve.
   if (auto *Init = PBD->getExecutableInit(idx)) {
     FullExpr Scope(Cleanups, CleanupLocation(Init));
+
+    auto *var = PBD->getSingleVar();
+    if (var && var->getDeclContext()->isLocalContext()) {
+      if (auto *orig = var->getOriginalWrappedProperty()) {
+        auto wrapperInfo = orig->getPropertyWrapperBackingPropertyInfo();
+        Init = wrapperInfo.wrappedValuePlaceholder->getOriginalWrappedValue();
+
+        auto value = emitRValue(Init);
+        emitApplyOfPropertyWrapperBackingInitializer(SILLocation(PBD), orig,
+                                                     getForwardingSubstitutionMap(),
+                                                     std::move(value))
+          .forwardInto(*this, SILLocation(PBD), initialization.get());
+        return;
+      }
+    }
+
     emitExprInto(Init, initialization.get(), SILLocation(PBD));
   } else {
     initialization->finishUninitialized(*this);
@@ -1189,6 +1206,18 @@ void SILGenFunction::visitPatternBindingDecl(PatternBindingDecl *PBD) {
 void SILGenFunction::visitVarDecl(VarDecl *D) {
   // We handle emitting the variable storage when we see the pattern binding.
 
+  // Emit the property wrapper backing initializer if necessary.
+  auto wrapperInfo = D->getPropertyWrapperBackingPropertyInfo();
+  if (wrapperInfo && wrapperInfo.initializeFromOriginal)
+    SGM.emitPropertyWrapperBackingInitializer(D);
+
+  D->visitAuxiliaryDecls([&](VarDecl *var) {
+    if (auto *patternBinding = var->getParentPatternBinding())
+      visitPatternBindingDecl(patternBinding);
+
+    visit(var);
+  });
+
   // Emit the variable's accessors.
   D->visitEmittedAccessors([&](AccessorDecl *accessor) {
     SGM.emitFunction(accessor);

lib/SILGen/SILGenFunction.cpp

@@ -187,13 +187,18 @@ void SILGenFunction::emitCaptures(SILLocation loc,
   // Partial applications take ownership of the context parameters, so we'll
   // need to pass ownership rather than merely guaranteeing parameters.
   bool canGuarantee;
+  bool captureCanEscape = true;
   switch (purpose) {
   case CaptureEmission::PartialApplication:
     canGuarantee = false;
     break;
   case CaptureEmission::ImmediateApplication:
     canGuarantee = true;
     break;
+  case CaptureEmission::AssignByWrapper:
+    canGuarantee = false;
+    captureCanEscape = false;
+    break;
   }
 
   auto expansion = getTypeExpansionContext();
@@ -381,7 +386,8 @@ void SILGenFunction::emitCaptures(SILLocation loc,
         } else {
           capturedArgs.push_back(emitManagedRetain(loc, Entry.box));
         }
-        escapesToMark.push_back(entryValue);
+        if (captureCanEscape)
+          escapesToMark.push_back(entryValue);
       } else {
         // Address only 'let' values are passed by box.  This isn't great, in
         // that a variable captured by multiple closures will be boxed for each