Merge branch 'main' of github.com:apple/swift into maxd/main-merge

Author: MaxDesiatov

SwiftCompilerSources/Sources/AST/DiagnosticEngine.swift

@@ -93,15 +93,17 @@ public struct DiagnosticEngine {
         }
       }
     }
-    for arg in args {
+    // 'reversed()' because the closure should be wrapped in that order.
+    for arg in args.reversed() {
       closure = { [closure, arg] in
         arg._withBridgedDiagnosticArgument { bridgedArg in
           bridgedArgs.append(bridgedArg)
           closure()
         }
       }
     }
-    for fixIt in fixIts {
+    // 'reversed()' because the closure should be wrapped in that order.
+    for fixIt in fixIts.reversed() {
       closure = { [closure, fixIt] in
         fixIt.withBridgedDiagnosticFixIt { bridgedFixIt in
           bridgedFixIts.append(bridgedFixIt)

docs/CppInteroperabilityManifesto.md renamed to docs/CppInteropability/CppInteroperabilityManifesto.md

@@ -0,0 +1,209 @@
+#  Getting started with C++ Interoperability
+
+This document is desgined to get you started with bidirectional API-level interoperability between Swift and C++.
+
+## Table of Contents
+
+- [Creating a Module to contain your C++ source code](#creating-a-module-to-contain-your-c-source-code)
+- [Adding C++ to an Xcode project](#adding-c-to-an-xcode-project)
+- [Creating a Swift Package](#Creating-a-Swift-Package)
+- [Building with CMake](#building-with-cmake)
+
+## 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.
+- 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 containts your method implementations
+    header "Cxx.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">
+
+## 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
+
+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`-Xfrontend -enable-cxx-interop`
+- Under `Search Paths` -> `Import Paths` add your search path to the C++ module (i.e, `./ProjectName/Cxx`).
+
+```
+//Add to Other Swift Flags and Import Paths respectively
+-Xfrontend -enable-cxx-interop 
+-I./ProjectName/Cxx
+```
+
+- This should now allow your to import your C++ Module into any `.swift` file.
+
+```
+//In ViewController.swift
+import UIKit
+import Cxx
+
+class ViewController: UIViewController {
+    override func viewDidLoad() {
+        super.viewDidLoad()
+        let result = cxxFunction(7)
+        print(result)
+    }
+}
+```
+
+```
+//In Cxx.cpp
+
+#include "Cxx.hpp"
+int cxxFunction(int n) {
+    return n;
+}
+
+```
+
+```
+//In Cxx.hpp
+
+#ifndef Cxx_hpp
+#define Cxx_hpp
+
+int cxxFunction(int n);
+
+#endif
+
+```
+
+
+## Creating a Swift Package
+After creating your Swift package project, follow the steps [Creating a Module to contain your C++ source code](#creating-a-module-to-contain-your-c-source-code) in your `Source` directory
+
+- In your Package Manifest, you need to configure the Swift target's dependencies and compiler flags
+- In this example the name of the package is `Cxx_Interop`
+- Swift code will be in `Sources/Cxx_Interop` called `main.swift`
+- C++ source code follows the example shown in [Creating a Module to contain your C++ source code](#creating-a-module-to-contain-your-c-source-code)
+- Under targets, add the name of your C++ module and the directory containing the Swift code as a target.
+- In the target defining your Swift target, add a`dependencies` to the C++ Module, the `path`, `source`, and `swiftSettings` with `unsafeFlags` with the source to the C++ Module, and enable `-enable-cxx-interop`
+
+```
+//In Package Manifest
+
+import PackageDescription
+
+let package = Package(
+    name: "Cxx_Interop",
+    platforms: [.macOS(.v12)],
+    products: [
+        .library(
+            name: "Cxx",
+            targets: ["Cxx"]),
+        .library(
+            name: "Cxx_Interop",
+            targets: ["Cxx_Interop"]),
+    ],
+    targets: [
+        .target(
+            name: "Cxx",
+            dependencies: []
+        ),
+        .executableTarget(
+            name: "Cxx_Interop",
+            dependencies: ["Cxx"],
+            path: "./Sources/Cxx_Interop",
+            sources: [ "main.swift" ],
+            swiftSettings: [.unsafeFlags([
+                "-I", "Sources/Cxx",
+                "-Xfrontend", "-enable-cxx-interop",
+            ])]
+        ),
+    ]
+)
+
+```
+
+- We are now able to import our C++ Module into our swift code, and import the package into existing projects
+
+```
+//In main.swift
+
+import Cxx
+
+public struct Cxx_Interop {
+    
+    public func callCxxFunction(n: Int32) -> Int32 {
+        return cxxFunction(n: n)
+    }
+}
+
+print(Cxx_Interop().callCxxFunction(n: 7))
+//outputs: 7
+
+```
+
+## Building with CMake
+After creating your project follow the steps [Creating a Module to contain your C++ source code](#creating-a-module-to-contain-your-c-source-code)
+
+- 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 `add_executable` to the specific files/directory you would like to generate source, with`SHELL:-Xfrontend -enable-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
+
+cmake_minimum_required(VERSION 3.18)
+
+project(Cxx_Interop LANGUAGES CXX Swift)
+
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD_REQUIRED YES)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+add_library(cxx-support ./Sources/Cxx/Cxx.cpp)
+target_compile_options(cxx-support PRIVATE
+  -I${SWIFT_CXX_TOOLCHAIN}/usr/include/c++/v1
+  -fno-exceptions
+  -fignore-exceptions
+  -nostdinc++)
+target_include_directories(cxx-support PUBLIC
+  ${CMAKE_SOURCE_DIR}/Sources/Cxx)
+
+add_executable(Cxx_Interop ./Sources/Cxx_Interop/main.swift)
+target_compile_options(Cxx_Interop PRIVATE
+  "SHELL:-Xfrontend -enable-cxx-interop"
+target_link_libraries(Cxx_Interop PRIVATE cxx-support)
+
+```
+
+```
+//In main.swift
+
+import Cxx
+
+public struct Cxx_Interop {
+    public static func main() {
+        let result = cxxFunction(7)
+        print(result)
+    }
+}
+
+Cxx_Interop.main()
+
+```
+
+- In your projects direcetoy, run `cmake` to generate the systems build files
+
+- To generate an Xcode project run `cmake -GXcode` 
+- To generate with Ninja run `cmake -GNinja`
+
+- For more information on `cmake` see the  'GettingStarted' documentation: (https://github.com/apple/swift/blob/main/docs/HowToGuides/GettingStarted.md)
+
+

docs/CppInteropability/GettingStartedWithC++Interop.md

@@ -424,7 +424,7 @@ ERROR(initializer_has_name,PointsToFirstBadToken,
 
 // Destructor
 ERROR(destructor_decl_outside_class,none,
-      "deinitializers may only be declared within a class", ())
+      "deinitializers may only be declared within a class or actor", ())
 ERROR(expected_lbrace_destructor,PointsToFirstBadToken,
       "expected '{' for deinitializer", ())
 ERROR(destructor_has_name,PointsToFirstBadToken,

include/swift/AST/DiagnosticsParse.def

@@ -0,0 +1,149 @@
+#ifndef SWIFT_CXXMETHODBRIDGING_H
+#define SWIFT_CXXMETHODBRIDGING_H
+
+#include "swift/AST/Decl.h"
+#include "clang/AST/DeclCXX.h"
+#include "llvm/ADT/StringRef.h"
+
+#include <string>
+namespace swift {
+struct CXXMethodBridging {
+  enum class Kind { unkown, getter, setter, subscript };
+
+  enum class NameKind { unkown, snake, lower, camel, title };
+
+  CXXMethodBridging(const clang::CXXMethodDecl *method) : method(method) {}
+
+  Kind classify() {
+    if (nameIsBlacklist())
+      return Kind::unkown;
+
+    // this should be handled as snake case. See: rdar://89453010
+    // case. In the future we could
+    //  import these too, though.
+    auto nameKind = classifyNameKind();
+    if (nameKind != NameKind::title && nameKind != NameKind::camel &&
+        nameKind != NameKind::lower)
+      return Kind::unkown;
+
+    if (getClangName().startswith_insensitive("set")) {
+      // Setters only have one parameter.
+      if (method->getNumParams() != 1)
+        return Kind::unkown;
+
+      // rdar://89453106 (We need to handle imported properties that return a
+      // reference)
+      if (method->getParamDecl(0)->getType()->isReferenceType())
+        return Kind::unkown;
+
+      return Kind::setter;
+    }
+
+    // Getters and subscripts cannot return void.
+    if (method->getReturnType()->isVoidType())
+      return Kind::unkown;
+
+    if (getClangName().startswith_insensitive("get")) {
+      // Getters cannot take arguments.
+      if (method->getNumParams() != 0)
+        return Kind::unkown;
+
+      // rdar://89453106 (We need to handle imported properties that return a
+      // reference)
+      if (method->getReturnType()->isReferenceType())
+        return Kind::unkown;
+
+      return Kind::getter;
+    }
+
+    // rdar://89453187 (Add subscripts clarification to CXXMethod Bridging to
+    // clean up importDecl)
+    return Kind::unkown;
+  }
+
+  NameKind classifyNameKind() {
+    bool allLower = llvm::all_of(getClangName(), islower);
+
+    if (getClangName().empty())
+      return NameKind::unkown;
+
+    if (getClangName().contains('_'))
+      return allLower ? NameKind::snake : NameKind::unkown;
+
+    if (allLower)
+      return NameKind::lower;
+
+    return islower(getClangName().front()) ? NameKind::camel : NameKind::title;
+  }
+
+  llvm::StringRef getClangName() {
+    if (!method->getDeclName().isIdentifier())
+      return "";
+
+    return method->getName();
+  }
+
+  // this should be handled as snake case. See: rdar://89453010
+  std::string importNameAsCamelCaseName() {
+    std::string output;
+    auto kind = classify();
+    if (kind == Kind::getter || kind == Kind::setter) {
+      output = getClangName().drop_front(3).str();
+    } else {
+      output = getClangName().str();
+    }
+
+    if (output.empty())
+      return output;
+
+    // No work to do.
+    if (classifyNameKind() == NameKind::lower)
+      return output;
+
+    // The first character is always lowercase.
+    output.front() = std::tolower(output.front());
+
+    // We already lowercased the first element, so start at one. Look at the
+    // current element and the next one. To handle cases like UTF8String, start
+    // making all the uppercase characters lower, until we see an upper case
+    // character followed by a lower case character (i.e., "St").
+    for (size_t i = 1; i < output.size(); i++) {
+      size_t next = i + 1;
+
+      // If we see two upper case characters (or an upper case character and a
+      // number) make the current character lower case.
+      if (std::isupper(output[i]) &&
+          (std::isupper(output[next]) || std::isdigit(output[next]))) {
+        output[i] = std::tolower(output[i]);
+        // If we found an upper case character followed by a lower case
+        // character, we went far enough. We're done.
+      } else if (std::isupper(output[i]) && std::islower(output[next])) {
+        break;
+        // If we got to the end of the string, we're done.
+      } else if (std::isupper(output[i]) && next + 1 > output.size()) {
+        output[i] = std::tolower(output[i]);
+        break;
+      }
+    }
+
+    return output;
+  }
+
+  std::string importNameAsTitleCaseName() {
+    auto output = importNameAsCamelCaseName();
+    output.front() = std::toupper(output.front());
+    return output;
+  }
+
+private:
+  const clang::CXXMethodDecl *method = nullptr;
+
+  bool nameIsBlacklist() {
+    auto loweredName = getClangName().lower();
+    // Names that start with "get" or "set" but aren't getters or setters.
+    return loweredName == "getter" || loweredName == "setter" ||
+           loweredName == "get" || loweredName == "set";
+  }
+};
+} // namespace swift
+#endif // SWIFT_CXXMETHODBRIDGING_H