Merge remote-tracking branch 'origin/main' into katei/merge-main-2022-10-01

Author: kateinoigakukun

CHANGELOG.md

@@ -3,6 +3,48 @@ CHANGELOG
 
 _**Note:** This is in reverse chronological order, so newer entries are added to the top._
 
+## Swift 6.0
+
+* [SE-0365][]:
+ 
+  Implicit `self` is now permitted for `weak self` captures, after `self` is unwrapped.
+
+  For example, the usage of implicit `self` below is now permitted:
+
+  ```swift
+  class ViewController {
+    let button: Button
+
+    func setup() {
+        button.tapHandler = { [weak self] in
+            guard let self else { return }
+            dismiss() // refers to `self.dismiss()`
+        }
+    }
+
+    func dismiss() { ... }
+  }
+  ```
+
+  In Swift 5 language modes, implicit `self` is permitted for `weak self` captures in _non-escaping_ closures even before `self` is unwrapped. For example, this code compiles successfully in Swift 5 language mode:
+
+  ```swift
+  class ExampleClass {
+    func makeArray() -> [String] {
+      // `Array.map` takes a non-escaping closure:
+      ["foo", "bar", "baaz"].map { [weak self] string in
+        double(string) // implicitly refers to `self!.double(string)`
+      }
+    } 
+
+    func double(_ string: String) -> String {
+      string + string
+    }
+  }
+  ```
+
+  In Swift 6, the above code will no longer compile. `weak self` captures in non-escaping closures now have the same behavior as captures in escaping closures (as described in [SE-0365][]). Code relying on the previous behavior will need to be updated to either unwrap `self` (e.g. by adding a `guard let self else return` statement), or to use a different capture method (e.g. using `[self]` or `[unowned self]` instead of `[weak self]`).
+
 ## Swift 5.8
 
 * [SE-0362][]:
@@ -9559,6 +9601,7 @@ Swift 1.0
 [SE-0357]: <https://github.com/apple/swift-evolution/blob/main/proposals/0357-regex-string-processing-algorithms.md>
 [SE-0358]: <https://github.com/apple/swift-evolution/blob/main/proposals/0358-primary-associated-types-in-stdlib.md>
 [SE-0362]: <https://github.com/apple/swift-evolution/blob/main/proposals/0362-piecemeal-future-features.md>
+[SE-0365]: <https://github.com/apple/swift-evolution/blob/main/proposals/0365-implicit-self-weak-capture.md>
 
 [SR-75]: <https://bugs.swift.org/browse/SR-75>
 [SR-106]: <https://bugs.swift.org/browse/SR-106>

docs/CppInteroperability/GettingStartedWithC++Interop.md

@@ -11,22 +11,20 @@ This document is designed to get you started with bidirectional API-level intero
 
 ## Creating a Module to contain your C++ source code
 
-- Create a new C++ implementation and header file
-- For this example we will call the files Cxx, so we should have a Cxx.cpp and Cxx.hpp.
+- Create a new target in Xcode via _File_ | _New_ | _Target_, select _Library_.
+- Within the directory of the newly created target, create a new C++ implementation and header file
+- For this example we will call the files CxxTest, so we should have a CxxTest.cpp and CxxTest.hpp.
 - Next create an empty file and call it `module.modulemap`, in this file create the module for your source code, and define your C++ header (`requires cplusplus` isn't required but it's convention for C++ modules, especially if they use C++ features).
 
 ```
-//In module.modulemap
-module Cxx {
-    //note that your header should be the file that contains your method implementations
-    header "Cxx.hpp"
+// In module.modulemap
+module CxxTest {
+    header "CxxTest.hpp"
     requires cplusplus
 }
 ```
 
-- Move the newly created files (Cxx.cpp, Cxx.hpp, module.modulemap) into a separate directory (this should remain in your project directory)
-
-<img width="252" alt="Screen Shot 2022-02-26 at 9 14 06 PM" src="https://user-images.githubusercontent.com/62521716/155867937-9d9d6c62-4418-414d-bc4e-5d12c2055022.png">
+<img width="127" alt="cxx-interop-ctest" src="https://user-images.githubusercontent.com/3801618/192995602-f37137f3-ec15-4fdd-bf2c-591728945a68.png">
 
 ## Adding C++ to an Xcode project
 - In your xcode project, follow the steps [Creating a Module to contain your C++ source code](#creating-a-module-to-contain-your-c-source-code) in your project directory
@@ -35,44 +33,44 @@ Add the C++ module to the include path and enable C++ interop:
 - Navigate to your project directory
 - In `Project` navigate to `Build Settings` -> `Swift Compiler`
 - Under `Custom Flags` -> `Other Swift Flags` add`-enable-experimental-cxx-interop`
-- Under `Search Paths` -> `Import Paths` add your search path to the C++ module (i.e, `./ProjectName/Cxx`). Repeat this step in `Other Swift Flags`
+- Under `Search Paths` -> `Import Paths` add your search path to the C++ module (i.e, `./ProjectName/CxxTest`). Repeat this step in `Other Swift Flags`
 
 ```
 //Add to Other Swift Flags and Import Paths respectively
 -enable-experimental-cxx-interop
--I./ProjectName/Cxx
+-I./ProjectName/CxxTest
 ```
 
 - This should now allow your to import your C++ Module into any `.swift` file.
 
 ```
 //In ContentView.swift
 import SwiftUI
-import Cxx
+import CxxTest
 
 struct ContentView: View {
     var body: some View {
-        Text("Cxx function result: \(cxxFunction(7))")
+        Text("CxxTest function result: \(cxxFunction(7))")
             .padding()
     }
 }
 ```
 
 ```
-//In Cxx.hpp
+// In CxxTest.hpp
 
-#ifndef Cxx_hpp
-#define Cxx_hpp
+#ifndef CxxTest_hpp
+#define CxxTest_hpp
 
 int cxxFunction(int n);
 
 #endif
 ```
 
 ```
-//In Cxx.cpp
+// In CxxTest.cpp
 
-#include "Cxx.hpp"
+#include "CxxTest.hpp"
 
 int cxxFunction(int n) {
     return n;
@@ -101,24 +99,24 @@ let package = Package(
     platforms: [.macOS(.v12)],
     products: [
         .library(
-            name: "Cxx",
-            targets: ["Cxx"]),
+            name: "CxxTest",
+            targets: ["CxxTest"]),
         .library(
             name: "CxxInterop",
             targets: ["CxxInterop"]),
     ],
     targets: [
         .target(
-            name: "Cxx",
+            name: "CxxTest",
             dependencies: []
         ),
         .executableTarget(
             name: "CxxInterop",
-            dependencies: ["Cxx"],
+            dependencies: ["CxxTest"],
             path: "./Sources/CxxInterop",
             sources: [ "main.swift" ],
             swiftSettings: [.unsafeFlags([
-                "-I", "Sources/Cxx",
+                "-I", "Sources/CxxTest",
                 "-enable-experimental-cxx-interop",
             ])]
         ),
@@ -132,7 +130,7 @@ let package = Package(
 ```
 //In main.swift
 
-import Cxx
+import CxxTest
 
 public struct CxxInterop {
 
@@ -151,12 +149,12 @@ After creating your project follow the steps [Creating a Module to contain your
 
 - Create a `CMakeLists.txt` file and configure for your project
 - In`add_library` invoke `cxx-support` with the path to the C++ implementation file
-- Add the `target_include_directories` with `cxx-support` and path to the C++ Module `${CMAKE_SOURCE_DIR}/Sources/Cxx`
+- Add the `target_include_directories` with `cxx-support` and path to the C++ Module `${CMAKE_SOURCE_DIR}/Sources/CxxTest`
 - Add the `add_executable` to the specific files/directory you would like to generate source, with`SHELL:-enable-experimental-cxx-interop`.
 - In the example below we will be following the file structure used in [Creating a Swift Package](#Creating-a-Swift-Package)
 
 ```
-//In CMakeLists.txt
+// In CMakeLists.txt
 
 cmake_minimum_required(VERSION 3.18)
 
@@ -166,14 +164,12 @@ set(CMAKE_CXX_STANDARD 11)
 set(CMAKE_CXX_STANDARD_REQUIRED YES)
 set(CMAKE_CXX_EXTENSIONS OFF)
 
-add_library(cxx-support ./Sources/Cxx/Cxx.cpp)
+add_library(cxx-support ./Sources/CxxTest/CxxTest.cpp)
 target_compile_options(cxx-support PRIVATE
-  -I${SWIFT_CXX_TOOLCHAIN}/usr/include/c++/v1
   -fno-exceptions
-  -fignore-exceptions
-  -nostdinc++)
+  -fignore-exceptions)
 target_include_directories(cxx-support PUBLIC
-  ${CMAKE_SOURCE_DIR}/Sources/Cxx)
+  ${CMAKE_SOURCE_DIR}/Sources/CxxTest)
 
 add_executable(CxxInterop ./Sources/CxxInterop/main.swift)
 target_compile_options(CxxInterop PRIVATE
@@ -185,7 +181,7 @@ target_link_libraries(CxxInterop PRIVATE cxx-support)
 ```
 //In main.swift
 
-import Cxx
+import CxxTest
 
 public struct CxxInterop {
     public static func main() {

docs/HowToGuides/GettingStarted.md

@@ -154,6 +154,7 @@ Double-check that running `pwd` prints a path ending with `swift`.
 
 1. The latest Linux dependencies are listed in the respective Dockerfiles:
    * [Ubuntu 20.04](https://github.com/apple/swift-docker/blob/main/swift-ci/master/ubuntu/20.04/Dockerfile)
+   * [Ubuntu 22.04](https://github.com/apple/swift-docker/blob/main/swift-ci/master/ubuntu/22.04/Dockerfile)
    * [CentOS 7](https://github.com/apple/swift-docker/blob/main/swift-ci/master/centos/7/Dockerfile)
    * [Amazon Linux 2](https://github.com/apple/swift-docker/blob/main/swift-ci/master/amazon-linux/2/Dockerfile)
 

include/swift/AST/DiagnosticsSema.def

@@ -1204,6 +1204,12 @@ NOTE(optional_key_path_root_base_chain, none,
 NOTE(optional_key_path_root_base_unwrap, none,
      "unwrap the optional using '!.' to access unwrapped type member %0",
      (DeclNameRef))
+
+ERROR(optional_self_not_unwrapped,none,
+      "explicit use of 'self' is required when 'self' is optional, "
+      "to make control flow explicit", ())
+NOTE(optional_self_chain,none,
+     "reference 'self?.' explicitly", ())
 
 ERROR(missing_unwrap_optional_try,none,
       "value of optional type %0 not unwrapped; did you mean to use 'try!' "
@@ -3939,8 +3945,6 @@ NOTE(note_reference_self_explicitly,none,
 NOTE(note_other_self_capture,none,
       "variable other than 'self' captured here under the name 'self' does not "
       "enable implicit 'self'", ())
-NOTE(note_self_captured_weakly,none,
-      "weak capture of 'self' here does not enable implicit 'self'", ())
 ERROR(implicit_use_of_self_in_closure,none,
       "implicit use of 'self' in closure; use 'self.' to make"
       " capture semantics explicit", ())

include/swift/AST/NameLookup.h

@@ -107,15 +107,20 @@ struct LookupResultEntry {
   /// extension (if it found something at that level).
   DeclContext *BaseDC;
 
+  /// The declaration that defines the base of the call to `Value`.
+  /// This is always available, as long as `BaseDC` is not null.
+  ValueDecl *BaseDecl;
+
   /// The declaration corresponds to the given name; i.e. the decl we are
   /// looking up.
   ValueDecl *Value;
 
 public:
-  LookupResultEntry(ValueDecl *value) : BaseDC(nullptr), Value(value) {}
+  LookupResultEntry(ValueDecl *value)
+      : BaseDC(nullptr), BaseDecl(nullptr), Value(value) {}
 
-  LookupResultEntry(DeclContext *baseDC, ValueDecl *value)
-    : BaseDC(baseDC), Value(value) {}
+  LookupResultEntry(DeclContext *baseDC, ValueDecl *baseDecl, ValueDecl *value)
+      : BaseDC(baseDC), BaseDecl(baseDecl), Value(value) {}
 
   ValueDecl *getValueDecl() const { return Value; }
 

include/swift/AST/Stmt.h

@@ -398,14 +398,15 @@ class alignas(8) PoundAvailableInfo final :
 class PoundHasSymbolInfo final : public ASTAllocated<PoundHasSymbolInfo> {
   Expr *SymbolExpr;
   ConcreteDeclRef ReferencedDecl;
+  bool Invalid;
 
   SourceLoc PoundLoc;
   SourceLoc LParenLoc;
   SourceLoc RParenLoc;
 
   PoundHasSymbolInfo(SourceLoc PoundLoc, SourceLoc LParenLoc, Expr *SymbolExpr,
                      SourceLoc RParenLoc)
-      : SymbolExpr(SymbolExpr), ReferencedDecl(), PoundLoc(PoundLoc),
+      : SymbolExpr(SymbolExpr), ReferencedDecl(), Invalid(), PoundLoc(PoundLoc),
         LParenLoc(LParenLoc), RParenLoc(RParenLoc){};
 
 public:
@@ -419,6 +420,10 @@ class PoundHasSymbolInfo final : public ASTAllocated<PoundHasSymbolInfo> {
   ConcreteDeclRef getReferencedDecl() { return ReferencedDecl; }
   void setReferencedDecl(ConcreteDeclRef CDR) { ReferencedDecl = CDR; }
 
+  /// Returns true if the referenced decl has been diagnosed as invalid.
+  bool isInvalid() const { return Invalid; }
+  void setInvalid() { Invalid = true; }
+
   SourceLoc getLParenLoc() const { return LParenLoc; }
   SourceLoc getRParenLoc() const { return RParenLoc; }
   SourceLoc getStartLoc() const { return PoundLoc; }
@@ -630,7 +635,7 @@ class DoStmt : public LabeledStmt {
 };
 
 /// Either an "if let" case or a simple boolean expression can appear as the
-/// condition of an 'if' or 'while' statement.
+/// condition of an 'if', 'guard', or 'while' statement.
 using StmtCondition = MutableArrayRef<StmtConditionElement>;
 
 /// This is the common base class between statements that can have labels, and

include/swift/SIL/SILDeclRef.h

@@ -483,9 +483,6 @@ struct SILDeclRef {
     return result;
   }
 
-  /// True is the decl ref references any kind of thunk.
-  bool isAnyThunk() const;
-
   /// True if the decl ref references a thunk from a natively foreign
   /// declaration to Swift calling convention.
   bool isForeignToNativeThunk() const;

include/swift/SIL/SILProfiler.h

@@ -31,9 +31,6 @@ class SILCoverageMap;
 class SILFunction;
 class SILModule;
 
-/// Returns whether the given AST node requires profiling instrumentation.
-bool doesASTRequireProfiling(SILModule &M, ASTNode N, SILDeclRef Constant);
-
 /// SILProfiler - Maps AST nodes to profile counters.
 class SILProfiler : public SILAllocated<SILProfiler> {
 private:

include/swift/SILOptimizer/Utils/CanonicalOSSALifetime.h

@@ -249,9 +249,6 @@ class CanonicalizeOSSALifetime {
   /// liveness may be pruned during canonicalization.
   bool pruneDebugMode;
 
-  /// If true, then new destroy_value instructions will be poison.
-  bool poisonRefsMode;
-
   /// If true and we are processing a value of move_only type, emit a diagnostic
   /// when-ever we need to insert a copy_value.
   std::function<void(Operand *)> moveOnlyCopyValueNotification;
@@ -348,12 +345,11 @@ class CanonicalizeOSSALifetime {
   }
 
   CanonicalizeOSSALifetime(
-      bool pruneDebugMode, bool poisonRefsMode,
-      NonLocalAccessBlockAnalysis *accessBlockAnalysis, DominanceInfo *domTree,
-      InstructionDeleter &deleter,
+      bool pruneDebugMode, NonLocalAccessBlockAnalysis *accessBlockAnalysis,
+      DominanceInfo *domTree, InstructionDeleter &deleter,
       std::function<void(Operand *)> moveOnlyCopyValueNotification = nullptr,
       std::function<void(Operand *)> moveOnlyFinalConsumingUse = nullptr)
-      : pruneDebugMode(pruneDebugMode), poisonRefsMode(poisonRefsMode),
+      : pruneDebugMode(pruneDebugMode),
         moveOnlyCopyValueNotification(moveOnlyCopyValueNotification),
         moveOnlyFinalConsumingUse(moveOnlyFinalConsumingUse),
         accessBlockAnalysis(accessBlockAnalysis), domTree(domTree),
@@ -414,11 +410,9 @@ class CanonicalizeOSSALifetime {
   void findOrInsertDestroys();
 
   void findOrInsertDestroyOnCFGEdge(SILBasicBlock *predBB,
-                                    SILBasicBlock *succBB, bool needsPoison);
+                                    SILBasicBlock *succBB);
 
   void rewriteCopies();
-
-  void injectPoison();
 };
 
 } // end namespace swift