Merge apple/swift:master into tensorflow-stage (using imerge)

Author: Dave Abrahams

CHANGELOG.md

@@ -28,6 +28,20 @@ CHANGELOG
 Swift Next
 ----------
 
+* [SE-0284][]:
+
+  Functions, subscripts, and initializers may now have more than one variadic parameter, as long as all parameters which follow variadic parameters are labeled. This makes declarations like the following valid:
+
+  ```swift
+  func foo(_ a: Int..., b: Double...) { }
+
+  struct Bar {
+    subscript(a: Int..., b b: Int...) -> [Int] { a + b }
+
+    init(a: String..., b: Float...) { }
+  }
+  ```
+
 * [SE-0287][]:
 
   Implicit member expressions now support chains of member accesses, making the following valid:
@@ -8143,6 +8157,7 @@ Swift 1.0
 [SE-0276]: <https://github.com/apple/swift-evolution/blob/master/proposals/0276-multi-pattern-catch-clauses.md>
 [SE-0279]: <https://github.com/apple/swift-evolution/blob/master/proposals/0279-multiple-trailing-closures.md>
 [SE-0280]: <https://github.com/apple/swift-evolution/blob/master/proposals/0280-enum-cases-as-protocol-witnesses.md>
+[SE-0284]: <https://github.com/apple/swift-evolution/blob/master/proposals/0284-multiple-variadic-parameters.md>
 [SE-0286]: <https://github.com/apple/swift-evolution/blob/master/proposals/0286-forward-scan-trailing-closures.md>
 [SE-0287]: <https://github.com/apple/swift-evolution/blob/master/proposals/0287-implicit-member-chains.md>
 

CMakeLists.txt

@@ -648,22 +648,6 @@ if("${CMAKE_C_COMPILER_ID}" STREQUAL "MSVC" OR "${CMAKE_CXX_SIMULATE_ID}" STREQU
   set(SWIFT_COMPILER_IS_MSVC_LIKE TRUE)
 endif()
 
-if(NOT SWIFT_COMPILER_IS_MSVC_LIKE)
-  # CMake's default for CMAKE_CXX_FLAGS_RELEASE is "-O3 -DNDEBUG". Let's avoid "-O3" for consistency
-  # between Release and RelWithDebInfo. Dropping -DNDEBUG from this setting is blocked by triggering
-  # a test failure of Swift-Unit :: Syntax/./SwiftSyntaxTests/TypeSyntaxTests.MetatypeTypeWithAPIs
-  # because unit tests don't currently explicitly set -DNDEBUG/-UNDEBUG.
-  set(CMAKE_CXX_FLAGS_RELEASE "-O2 -DNDEBUG")
-
-  _compute_lto_flag("${SWIFT_TOOLS_ENABLE_LTO}" _lto_flag_out)
-  if(_lto_flag_out)
-    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_RELEASE} -gline-tables-only")
-    set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -gline-tables-only")
-  endif()
-else()
-  
-endif()
-
 #
 # Configure SDKs.
 #

README.md

@@ -32,9 +32,9 @@
 
 | **OS** | **Architecture** | **Build** |
 |---|:---:|:---:|
-|**[Ubuntu 16.04](https://github.com/apple/swift-community-hosted-continuous-integration/blob/master/nodes/x86_64_ubuntu_16_04_tensorflow.json)** | x86_64 |[![Build Status](https://ci-external.swift.org/job/oss-swift-RA-linux-ubuntu-16.04-tensorflow/lastCompletedBuild/badge/icon)](https://ci-external.swift.org/job/oss-swift-RA-linux-ubuntu-16.04-tensorflow)|
+|**[Ubuntu 18.04](https://github.com/apple/swift-community-hosted-continuous-integration/blob/master/nodes/x86_64_ubuntu_18_04_tensorflow.json)** | x86_64 |[![Build Status](https://ci-external.swift.org/job/oss-swift-RA-linux-ubuntu-18.04-tensorflow/lastCompletedBuild/badge/icon)](https://ci-external.swift.org/job/oss-swift-RA-linux-ubuntu-18.04-tensorflow)|
 |**[macOS 10.13](https://github.com/apple/swift-community-hosted-continuous-integration/blob/master/nodes/x86_64_macos_high_sierra_tensorflow.json)** | x86_64 |[![Build Status](https://ci-external.swift.org/job/oss-swift-RA-macOS-tensorflow/lastCompletedBuild/badge/icon)](https://ci-external.swift.org/job/oss-swift-RA-macOS-tensorflow)|
-|**[Ubuntu 16.04 (GPU)](https://github.com/apple/swift-community-hosted-continuous-integration/blob/master/nodes/x86_64_ubuntu_16_04_tensorflow_gpu.json)** | x86_64 |[![Build Status](https://ci-external.swift.org/job/oss-swift-RA-linux-ubuntu-16.04-tensorflow-gpu/lastCompletedBuild/badge/icon)](https://ci-external.swift.org/job/oss-swift-RA-linux-ubuntu-16.04-tensorflow-gpu)|
+|**[Ubuntu 18.04 (GPU)](https://github.com/apple/swift-community-hosted-continuous-integration/blob/master/nodes/x86_64_ubuntu_18_04_tensorflow_gpu.json)** | x86_64 |[![Build Status](https://ci-external.swift.org/job/oss-swift-RA-linux-ubuntu-18.04-tensorflow-gpu/lastCompletedBuild/badge/icon)](https://ci-external.swift.org/job/oss-swift-RA-linux-ubuntu-18.04-tensorflow-gpu)|
 
 <!-- SWIFT_ENABLE_TENSORFLOW -->
 
@@ -89,6 +89,8 @@ If you are interested in:
   up until the "Building the project" section. After that, follow the
   instructions in the [Swift Toolchains](#swift-toolchains) section below.
 
+We also have an [FAQ](/docs/HowToGuides/FAQ.md) that answers common questions.
+
 [Getting Started guide]: /docs/HowToGuides/GettingStarted.md
 
 ### Swift For TensorFlow Toolchains
@@ -151,14 +153,14 @@ Try the suggestions in
 [Troubleshooting build issues](/docs/HowToGuides/GettingStarted.md#troubleshooting-build-issues).
 
 Make sure you are using the
-[correct release](/docs/HowToGuides/GettingStared.md#installing-dependencies)
+[correct release](/docs/HowToGuides/GettingStarted.md#installing-dependencies)
 of Xcode.
 
 If you have changed Xcode versions but still encounter errors that appear to
 be related to the Xcode version, try passing `--clean` to `build-script`.
 
 When a new version of Xcode is released, you can update your build without
-recompiling the entire project by passing the `--reconfigure` option.
+recompiling the entire project by passing `--reconfigure` to `build-script`.
 
 ## Learning More
 

cmake/modules/AddSwift.cmake

@@ -130,18 +130,17 @@ function(_add_host_variant_c_compile_flags target)
   _add_host_variant_c_compile_link_flags(${target})
 
   is_build_type_optimized("${CMAKE_BUILD_TYPE}" optimized)
-  is_build_type_with_debuginfo("${CMAKE_BUILD_TYPE}" debuginfo)
-
-  # Add -O0/-O2/-O3/-Os/-g/-momit-leaf-frame-pointer/... based on CMAKE_BUILD_TYPE.
-  target_compile_options(${target} PRIVATE "${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE}}")
-
   if(optimized)
+    if("${CMAKE_BUILD_TYPE}" STREQUAL "MinSizeRel")
+      target_compile_options(${target} PRIVATE -Os)
+    else()
+      target_compile_options(${target} PRIVATE -O2)
+    endif()
+
     # Omit leaf frame pointers on x86 production builds (optimized, no debug
     # info, and no asserts).
-    if(NOT debuginfo AND NOT LLVM_ENABLE_ASSERTIONS)
-      # Unfortunately, this cannot be folded into the standard
-      # CMAKE_CXX_FLAGS_... because Apple multi-SDK builds use different
-      # architectures for different SDKs.
+    is_build_type_with_debuginfo("${CMAKE_BUILD_TYPE}" debug)
+    if(NOT debug AND NOT LLVM_ENABLE_ASSERTIONS)
       if(SWIFT_HOST_VARIANT_ARCH MATCHES "i?86")
         if(NOT SWIFT_COMPILER_IS_MSVC_LIKE)
           target_compile_options(${target} PRIVATE -momit-leaf-frame-pointer)
@@ -150,6 +149,27 @@ function(_add_host_variant_c_compile_flags target)
         endif()
       endif()
     endif()
+  else()
+    if(NOT SWIFT_COMPILER_IS_MSVC_LIKE)
+      target_compile_options(${target} PRIVATE -O0)
+    else()
+      target_compile_options(${target} PRIVATE /Od)
+    endif()
+  endif()
+
+  # CMake automatically adds the flags for debug info if we use MSVC/clang-cl.
+  if(NOT SWIFT_COMPILER_IS_MSVC_LIKE)
+    is_build_type_with_debuginfo("${CMAKE_BUILD_TYPE}" debuginfo)
+    if(debuginfo)
+      _compute_lto_flag("${SWIFT_TOOLS_ENABLE_LTO}" _lto_flag_out)
+      if(_lto_flag_out)
+        target_compile_options(${target} PRIVATE -gline-tables-only)
+      else()
+        target_compile_options(${target} PRIVATE -g)
+      endif()
+    else()
+      target_compile_options(${target} PRIVATE -g0)
+    endif()
   endif()
 
   if(SWIFT_HOST_VARIANT_SDK STREQUAL WINDOWS)

docs/CppInteroperabilityManifesto.md

@@ -63,12 +63,12 @@ Assumptions:
     + [Function templates](#function-templates)
     + [Function templates: import as Swift generic functions](#function-templates-import-as-swift-generic-functions)
     + [Function templates: allow to specify template arguments](#function-templates-allow-to-specify-template-arguments)
-    + [Function templates: calls to specific specilalizations](#function-templates-calls-to-specific-specilalizations)
+    + [Function templates: calls to specific specializations](#function-templates-calls-to-specific-specializations)
     + [Function templates: calls with generic type parameters](#function-templates-calls-with-generic-type-parameters)
     + [Function templates: importing as real generic functions](#function-templates-importing-as-real-generic-functions)
     + [Class templates](#class-templates)
     + [Class templates: importing instantiation behind typedef](#class-templates-importing-instantiation-behind-typedef)
-    + [Class templates: importing specific specilalizations](#class-templates-importing-specific-specilalizations)
+    + [Class templates: importing specific specializations](#class-templates-importing-specific-specializations)
     + [Class templates: using with generic type parameters](#class-templates-using-with-generic-type-parameters)
     + [Class templates: using in generic code through a synthesized protocol](#class-templates-using-in-generic-code-through-a-synthesized-protocol)
     + [Class templates: importing as real generic structs](#class-templates-importing-as-real-generic-structs)
@@ -1902,7 +1902,7 @@ struct Employee {
   private func _getName() -> UnsafePointer<std.string>
 
   // void setName(std::string newName);
-  private func _setName(_ newName: std.string)
+  private mutating func _setName(_ newName: std.string)
 
   // Swifty API.
   public var name: std.string {
@@ -2436,7 +2436,7 @@ possible to do so when importing a C++ function template as a C++ generic
 function; "inout"-ness of an argument can't change across instantiations of a
 generic function in Swift.
 
-### Function templates: calls to specific specilalizations
+### Function templates: calls to specific specializations
 
 From an implementation point of view, it is easy to compile Swift code that
 calls C++ function templates if template arguments are concrete types that are
@@ -2615,7 +2615,7 @@ struct MagicNumber {}
 typealias WrappedMagicNumber = __CxxTemplateInst12MagicWrapperI11MagicNumberE
 ```
 
-### Class templates: importing specific specilalizations
+### Class templates: importing specific specializations
 
 Just like with calls to C++ function templates, it is easy to compile a use of a
 C++ class templates if the usage in Swift code unambiguously specifies which

docs/HowToGuides/FAQ.md

@@ -64,8 +64,14 @@ This very depends on what X is, but some broad guidelines are:
 1. Do a case-insensitive recursive string search.
    - Use a specialized tool like [ripgrep](https://github.com/BurntSushi/ripgrep)
      or [ag](https://github.com/ggreer/the_silver_searcher).
+   - Use `git grep --ignore-case "mypattern"`. `git grep` also supports helpful
+     flags which provide more context:
+     - `--show-function`: Tries to print the function name that a match was
+       found in.
+     - `--function-context`: Tries to print the entire surrounding function
+       containing the match.
    - Use 'Find in Workspace' in Xcode (<kbd>⌘</kbd>+<kbd>⇧</kbd>+<kbd>F</kbd>).
-   - Use `grep -i -r "mypattern" .`.
+   - Use `grep --ignore-case --recursive "mypattern" .`.
 2. Go through the [Documentation Index](/docs/README.md).
 
 ### How do I build the documentation as HTML?

docs/HowToGuides/FirstPullRequest.md

@@ -6,7 +6,7 @@ you are an experienced open source contributor who is excited about Swift, or
 maybe you are somewhere in-between. Regardless of your background, we are
 excited to have you contribute and improve the developer experience for Swift
 programmers all over the globe.
-:sparkles::child::student::woman_technologist::technologist::man_technologist::sparkles:
+:sparkles:🧒🏾🧑🏼‍🎓👩🏽‍💻🧑🏻‍💻👨🏿‍💻:sparkles:
 
 This document provides a high-level overview of different parts of the
 contribution process.

docs/HowToGuides/GettingStarted.md

@@ -19,7 +19,7 @@ toolchain as a one-off, there are a couple of differences:
   - [Ubuntu Linux](#ubuntu-linux)
 - [Building the project for the first time](#building-the-project-for-the-first-time)
   - [Spot check dependencies](#spot-check-dependencies)
-  - [Understanding the pieces](#understanding-the-pieces)
+  - [The roles of different tools](#the-roles-of-different-tools)
   - [The actual build](#the-actual-build)
   - [Troubleshooting build issues](#troubleshooting-build-issues)
 - [Editing code](#editing-code)
@@ -373,7 +373,7 @@ The codebase is your oyster!
 
 Now that you have made some changes, you will need to rebuild...
 
-### Incremental rebuilds with Ninja
+### Incremental builds with Ninja
 
 To rebuild the compiler:
 ```sh
@@ -503,7 +503,7 @@ utils/build-script --release-debuginfo --debug-swift # other flags...
 # debug Stdlib + optimized Swiftc + optimized Clang/LLVM
 utils/build-script --release-debuginfo --debug-swift-stdlib # other flags...
 
-# optimized Stdlib + debug Swiftc (expect typechecker) + optimized Clang/LLVM
+# optimized Stdlib + debug Swiftc (except typechecker) + optimized Clang/LLVM
 utils/build-script --release-debuginfo --debug-swift --force-optimized-typechecker
 
 # Last resort option, it is highly unlikely that you will need this

docs/Lexicon.md

@@ -45,6 +45,28 @@ introduces [reabstraction](#reabstraction) conversions when a value is used with
 different abstraction pattern. (This is where the infamous "reabstraction
 thunk helpers" sometimes seen in Swift backtraces come from.)
 
+## access path
+
+Broadly, an "access path" is a list of "accesses" which must be chained together
+to compute some output from an input. For instance, the generics system has a
+type called a `ConformanceAccessPath` which explains how to, for example,
+walk from `T: Collection` to `T: Sequence` to `T.Iterator: IteratorProtocol`.
+There are several different kinds of "access path" in different parts of the compiler,
+but they all follow this basic theme.
+
+In the specific context of imports, an "access path" is the `Bar` portion of a scoped
+import like `import class Foo.Bar`. Theoretically, it could have several identifiers
+to designate a nested type, although the compiler doesn't currently support this. It can
+also be empty, matching all top-level declarations in the module.
+
+Note, however, that there has historically been some confusion about the meaning of
+"access path" with regards to imports. You might see some code use "access path"
+to include the `Foo` part or even to describe a chain of submodule names where a
+declaration is not valid at all. (Strictly, the chain of module names is a "module path"
+and the combination of module path + access path is an "import path".)
+
+See `ImportPath` and the types nested inside it for more on this.
+
 ## archetype
 
 A placeholder for a generic parameter or an associated type within a

include/swift/AST/ASTContext.h

@@ -20,6 +20,7 @@
 #include "swift/AST/Evaluator.h"
 #include "swift/AST/GenericSignature.h"
 #include "swift/AST/Identifier.h"
+#include "swift/AST/Import.h"
 #include "swift/AST/SearchPathOptions.h"
 #include "swift/AST/Type.h"
 #include "swift/AST/Types.h"
@@ -891,12 +892,12 @@ class ASTContext final {
   ///
   /// Note that even if this check succeeds, errors may still occur if the
   /// module is loaded in full.
-  bool canImportModule(Located<Identifier> ModulePath);
+  bool canImportModule(ImportPath::Element ModulePath);
 
   /// \returns a module with a given name that was already loaded.  If the
   /// module was not loaded, returns nullptr.
   ModuleDecl *getLoadedModule(
-      ArrayRef<Located<Identifier>> ModulePath) const;
+      ImportPath::Module ModulePath) const;
 
   ModuleDecl *getLoadedModule(Identifier ModuleName) const;
 
@@ -906,10 +907,12 @@ class ASTContext final {
   /// be returned.
   ///
   /// \returns The requested module, or NULL if the module cannot be found.
-  ModuleDecl *getModule(ArrayRef<Located<Identifier>> ModulePath);
+  ModuleDecl *getModule(ImportPath::Module ModulePath);
 
   ModuleDecl *getModuleByName(StringRef ModuleName);
 
+  ModuleDecl *getModuleByIdentifier(Identifier ModuleID);
+
   /// Returns the standard library module, or null if the library isn't present.
   ///
   /// If \p loadIfAbsent is true, the ASTContext will attempt to load the module

include/swift/AST/AnyFunctionRef.h

@@ -137,9 +137,9 @@ class AnyFunctionRef {
     return cast<AutoClosureExpr>(ACE)->getBody();
   }
 
-  void setBody(BraceStmt *stmt, bool isSingleExpression) {
+  void setTypecheckedBody(BraceStmt *stmt, bool isSingleExpression) {
     if (auto *AFD = TheFunction.dyn_cast<AbstractFunctionDecl *>()) {
-      AFD->setBody(stmt);
+      AFD->setBody(stmt, AbstractFunctionDecl::BodyKind::TypeChecked);
       AFD->setHasSingleExpressionBody(isSingleExpression);
       return;
     }

include/swift/AST/Attr.def

@@ -566,11 +566,17 @@ SIMPLE_DECL_ATTR(asyncHandler, AsyncHandler,
   ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIStableToRemove,
   101)
 
+CONTEXTUAL_SIMPLE_DECL_ATTR(actor, Actor,
+  OnClass | ConcurrencyOnly |
+  ABIBreakingToAdd | ABIBreakingToRemove |
+  APIBreakingToAdd | APIBreakingToRemove,
+  102)
+
 // SWIFT_ENABLE_TENSORFLOW
 SIMPLE_DECL_ATTR(compilerEvaluable, CompilerEvaluable,
   OnAccessor | OnFunc | OnConstructor | OnSubscript |
   ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIStableToRemove |
-  NotSerialized, 102)
+  NotSerialized, 103)
 // SWIFT_ENABLE_TENSORFLOW END
 
 #undef TYPE_ATTR

include/swift/AST/Attr.h

@@ -419,6 +419,9 @@ class DeclAttribute : public AttributeBase {
 
     /// The opposite of ABIBreakingToRemove
     ABIStableToRemove = 1ull << (unsigned(DeclKindIndex::Last_Decl) + 15),
+
+    /// Whether this attribute is only valid when concurrency is enabled.
+    ConcurrencyOnly = 1ull << (unsigned(DeclKindIndex::Last_Decl) + 16),
   };
 
   LLVM_READNONE
@@ -497,6 +500,10 @@ class DeclAttribute : public AttributeBase {
     return getOptions(DK) & SILOnly;
   }
 
+  static bool isConcurrencyOnly(DeclAttrKind DK) {
+    return getOptions(DK) & ConcurrencyOnly;
+  }
+
   static bool isUserInaccessible(DeclAttrKind DK) {
     return getOptions(DK) & UserInaccessible;
   }