Merge branch 'master' into SR-11295-warning-unecessary-casts

Author: LucianoPAlmeida

CHANGELOG.md

@@ -26,6 +26,29 @@ CHANGELOG
 Swift Next
 ----------
 
+* [SE-0253][]:
+
+  Values of types that declare `func callAsFunction` methods can be called
+  like functions. The call syntax is shorthand for applying
+  `func callAsFunction` methods.
+
+  ```swift
+  struct Adder {
+    var base: Int
+    func callAsFunction(_ x: Int) -> Int {
+      return x + base
+    }
+  }
+  var adder = Adder(base: 3)
+  adder(10) // returns 13, same as `adder.callAsFunction(10)`
+  ```
+
+  * `func callAsFunction` argument labels are required at call sites.
+  * Multiple `func callAsFunction` methods on a single type are supported.
+  * `mutating func callAsFunction` is supported.
+  * `func callAsFunction` works with `throws` and `rethrows`.
+  * `func callAsFunction` works with trailing closures.
+
 * [SR-4206][]:
 
   A method override is no longer allowed to have a generic signature with 
@@ -7711,6 +7734,7 @@ Swift 1.0
 [SE-0244]: <https://github.com/apple/swift-evolution/blob/master/proposals/0244-opaque-result-types.md>
 [SE-0245]: <https://github.com/apple/swift-evolution/blob/master/proposals/0245-array-uninitialized-initializer.md>
 [SE-0252]: <https://github.com/apple/swift-evolution/blob/master/proposals/0252-keypath-dynamic-member-lookup.md>
+[SE-0253]: <https://github.com/apple/swift-evolution/blob/master/proposals/0253-callable.md>
 [SE-0254]: <https://github.com/apple/swift-evolution/blob/master/proposals/0254-static-subscripts.md>
 
 [SR-106]: <https://bugs.swift.org/browse/SR-106>

benchmark/CMakeLists.txt

@@ -87,6 +87,7 @@ set(SWIFT_BENCH_MODULES
     single-source/Exclusivity
     single-source/ExistentialPerformance
     single-source/Fibonacci
+    single-source/FindStringNaive
     single-source/FlattenList
     single-source/FloatingPointParsing
     single-source/FloatingPointPrinting

benchmark/single-source/FindStringNaive.swift

@@ -0,0 +1,185 @@
+//===--- FindStringNaive.swift --------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2019 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import TestsUtils
+
+// Mini benchmark implementing a naive String search algorithm that
+// at the moment shows a lot of ARC traffic.
+let t: [BenchmarkCategory] = [.String, .refcount]
+let N = 100
+
+var longStringFoFoFoFox: String?
+var longArrayFoFoFoFox: [UInt8]?
+
+public let FindStringNaive = [
+  BenchmarkInfo(
+    name: "FindString.Loop1.Substring",
+    runFunction: runBenchLoop1Substring,
+    tags: t,
+    setUpFunction: {
+      longStringFoFoFoFox = String(repeating: "fo", count: 5_000) + "fox <-- needle"
+    }),
+  BenchmarkInfo(
+    name: "FindString.Rec3.String",
+    runFunction: runBenchRecursive3String,
+    tags: t,
+    setUpFunction: {
+      longStringFoFoFoFox = String(repeating: "fo", count: 500) + "fox <-- needle"
+    }),
+  BenchmarkInfo(
+    name: "FindString.Rec3.Substring",
+    runFunction: runBenchRecursive3Substring,
+    tags: t,
+    setUpFunction: {
+      longStringFoFoFoFox = String(repeating: "fo", count: 500) + "fox <-- needle"
+    }),
+  BenchmarkInfo(
+    name: "FindString.Loop1.Array",
+    runFunction: runBenchLoop1Array,
+    tags: t,
+    setUpFunction: {
+      longArrayFoFoFoFox = []
+      longArrayFoFoFoFox!.reserveCapacity(1_100_000)
+      for _ in 0 ..< 500_000 {
+        longArrayFoFoFoFox!.append(contentsOf: "fo".utf8)
+      }
+      longArrayFoFoFoFox!.append(contentsOf: "fox <-- needle".utf8)
+    }),
+  BenchmarkInfo(
+    name: "FindString.Rec3.Array",
+    runFunction: runBenchRecursive3ArrayOfUTF8,
+    tags: t,
+    setUpFunction: {
+      longArrayFoFoFoFox = []
+      longArrayFoFoFoFox!.reserveCapacity(11_000)
+      for _ in 0 ..< 5_000 {
+        longArrayFoFoFoFox!.append(contentsOf: "fo".utf8)
+      }
+      longArrayFoFoFoFox!.append(contentsOf: "fox <-- needle".utf8)
+    }),
+]
+
+func findOne<S: StringProtocol>(
+  _ string: S,
+  needle: Character
+) -> String.Index? {
+  var index = string.startIndex
+  while index < string.endIndex {
+    let nextIndex = string.index(after: index)
+    if string[index] == needle {
+      return index
+    }
+    index = nextIndex
+  }
+  return nil
+}
+
+func findThreeRecursive<S: StringProtocol>(
+  _ string: S,
+  needle1: Character,
+  needle2: Character?,
+  needle3: Character?
+) -> String.Index? {
+  var index = string.startIndex
+  while index < string.endIndex {
+    let nextIndex = string.index(after: index)
+    if string[index] == needle1 {
+      // Check subsequent needles recursively (if applicable)
+      guard let needle2 = needle2 else { return index }
+
+      if findThreeRecursive(
+        string[nextIndex...].prefix(2), needle1: needle2, needle2: needle3, needle3: nil
+      ) == nextIndex {
+        return index
+      }
+    }
+    index = nextIndex
+  }
+  return nil
+}
+
+func findOneOnUTF8Collection<Bytes: Collection>(
+  _ string: Bytes,
+  needle: UInt8
+) -> Bytes.Index? where Bytes.Element == UInt8 {
+  var index = string.startIndex
+  while index < string.endIndex {
+    let nextIndex = string.index(after: index)
+    if string[index] == needle {
+      return index
+    }
+    index = nextIndex
+  }
+  return nil
+}
+
+func findThreeOnUTF8Collection<Bytes: Collection>(
+  _ string: Bytes,
+  needle1: UInt8,
+  needle2: UInt8?,
+  needle3: UInt8?
+) -> Bytes.Index? where Bytes.Element == UInt8 {
+  var index = string.startIndex
+  while index < string.endIndex {
+    let nextIndex = string.index(after: index)
+    if string[index] == needle1 {
+      // Check subsequent needles recursively (if applicable)
+      guard let needle2 = needle2 else { return index }
+
+      if findThreeOnUTF8Collection(
+        string[nextIndex...].prefix(2), needle1: needle2, needle2: needle3, needle3: nil
+      ) == nextIndex {
+        return index
+      }
+    }
+    index = nextIndex
+  }
+  return nil
+}
+
+@inline(never)
+func runBenchLoop1Substring(iterations: Int) {
+  for _ in 0 ..< iterations {
+    precondition(findOne(longStringFoFoFoFox![...], needle: "x") != nil)
+  }
+}
+
+@inline(never)
+func runBenchLoop1Array(iterations: Int) {
+  for _ in 0 ..< iterations {
+    precondition(findOneOnUTF8Collection(longArrayFoFoFoFox!, needle: UInt8(ascii: "x")) != nil)
+  }
+}
+
+@inline(never)
+func runBenchRecursive3Substring(iterations: Int) {
+  for _ in 0 ..< iterations {
+    precondition(findThreeRecursive(longStringFoFoFoFox![...], needle1: "f", needle2: "o", needle3: "x") != nil)
+  }
+}
+
+@inline(never)
+func runBenchRecursive3String(iterations: Int) {
+  for _ in 0 ..< iterations {
+    precondition(findThreeRecursive(longStringFoFoFoFox!, needle1: "f", needle2: "o", needle3: "x") != nil)
+  }
+}
+
+@inline(never)
+func runBenchRecursive3ArrayOfUTF8(iterations: Int) {
+  for _ in 0 ..< iterations {
+    precondition(findThreeOnUTF8Collection(longArrayFoFoFoFox!,
+                                      needle1: UInt8(ascii: "f"),
+                                      needle2: UInt8(ascii: "o"),
+                                      needle3: UInt8(ascii: "x")) != nil)
+  }
+}

benchmark/utils/main.swift

@@ -75,6 +75,7 @@ import ErrorHandling
 import Exclusivity
 import ExistentialPerformance
 import Fibonacci
+import FindStringNaive
 import FlattenList
 import FloatingPointParsing
 import FloatingPointPrinting
@@ -253,6 +254,7 @@ registerBenchmark(ErrorHandling)
 registerBenchmark(Exclusivity)
 registerBenchmark(ExistentialPerformance)
 registerBenchmark(Fibonacci)
+registerBenchmark(FindStringNaive)
 registerBenchmark(FlattenListLoop)
 registerBenchmark(FlattenListFlatMap)
 registerBenchmark(FloatingPointParsing)

cmake/modules/AddSwift.cmake

@@ -2370,7 +2370,7 @@ function(_add_swift_executable_single name)
   # NOTE(compnerd) use the C linker language to invoke `clang` rather than
   # `clang++` as we explicitly link against the C++ runtime.  We were previously
   # actually passing `-nostdlib++` to avoid the C++ runtime linkage.
-  if(SWIFTEXE_SINGLE_SDK STREQUAL ANDROID)
+  if(${SWIFTEXE_SINGLE_SDK} STREQUAL ANDROID)
     set_property(TARGET "${name}" PROPERTY
       LINKER_LANGUAGE "C")
   else()

include/swift/AST/ASTContext.h

@@ -69,7 +69,6 @@ namespace swift {
   class LazyGenericContextData;
   class LazyIterableDeclContextData;
   class LazyMemberLoader;
-  class LazyMemberParser;
   class LazyResolver;
   class PatternBindingDecl;
   class PatternBindingInitializer;
@@ -425,12 +424,6 @@ class ASTContext final {
   void setLazyResolver(LazyResolver *resolver);
 
 public:
-  /// Add a lazy parser for resolving members later.
-  void addLazyParser(LazyMemberParser *parser);
-
-  /// Remove a lazy parser.
-  void removeLazyParser(LazyMemberParser *parser);
-
   /// getIdentifier - Return the uniqued and AST-Context-owned version of the
   /// specified string.
   Identifier getIdentifier(StringRef Str) const;
@@ -822,12 +815,6 @@ class ASTContext final {
   LazyContextData *getOrCreateLazyContextData(const DeclContext *decl,
                                               LazyMemberLoader *lazyLoader);
 
-  /// Use the lazy parsers associated with the context to populate the members
-  /// of the given decl context.
-  ///
-  /// \param IDC The context whose member decls should be lazily parsed.
-  void parseMembers(IterableDeclContext *IDC);
-
   /// Get the lazy function data for the given generic context.
   ///
   /// \param lazyLoader If non-null, the lazy loader to use when creating the

include/swift/AST/ASTTypeIDZone.def

@@ -33,3 +33,4 @@ SWIFT_TYPEID(AncestryFlags)
 SWIFT_TYPEID_NAMED(GenericSignature *, GenericSignature)
 SWIFT_TYPEID_NAMED(GenericTypeParamType *, GenericTypeParamType)
 SWIFT_TYPEID(Requirement)
+SWIFT_TYPEID_NAMED(IterableDeclContext *, IterableDeclContext)

include/swift/AST/ASTTypeIDs.h

@@ -17,19 +17,26 @@
 #ifndef SWIFT_AST_ASTTYPEIDS_H
 #define SWIFT_AST_ASTTYPEIDS_H
 
+#include "swift/Basic/LLVM.h"
 #include "swift/Basic/TypeID.h"
 namespace swift {
 
 class CustomAttr;
+class Decl;
 class GenericSignature;
 class GenericTypeParamType;
+class IterableDeclContext;
 class NominalTypeDecl;
+class OperatorDecl;
 struct PropertyWrapperBackingPropertyInfo;
 struct PropertyWrapperTypeInfo;
 enum class CtorInitializerKind;
 struct PropertyWrapperMutability;
+class ProtocolDecl;
 class Requirement;
+enum class ResilienceExpansion : unsigned;
 class Type;
+class ValueDecl;
 class VarDecl;
 class TypeAliasDecl;
 class Type;

include/swift/AST/Attr.def

@@ -362,8 +362,7 @@ SIMPLE_DECL_ATTR(_weakLinked, WeakLinked,
   OnSubscript | OnConstructor | OnEnumElement | OnExtension | UserInaccessible,
   75)
 SIMPLE_DECL_ATTR(frozen, Frozen,
-  OnEnum | OnStruct |
-  UserInaccessible,
+  OnEnum | OnStruct,
   76)
 DECL_ATTR_ALIAS(_frozen, Frozen)
 SIMPLE_DECL_ATTR(_forbidSerializingReference, ForbidSerializingReference,

include/swift/AST/Builtins.def

@@ -418,6 +418,14 @@ BUILTIN_MISC_OPERATION(Strideof, "strideof", "n", Special)
 /// IsPOD has type T.Type -> Bool
 BUILTIN_MISC_OPERATION(IsPOD, "ispod", "n", Special)
 
+/// IsConcrete has type (T.Type) -> Bool
+///
+/// If the meta type T is concrete, we can always transform this to `true` at
+/// any time in SIL. If it's generic, then we lower it to `false` right before
+/// IRGen in IRGenPrepare. This allows for the optimizer to specialize this at
+/// -O and eliminate conditional code.
+BUILTIN_MISC_OPERATION(IsConcrete, "isConcrete", "n", Special)
+
 /// IsBitwiseTakable has type T.Type -> Bool
 BUILTIN_MISC_OPERATION(IsBitwiseTakable, "isbitwisetakable", "n", Special)
 

include/swift/AST/Decl.h

@@ -5594,6 +5594,8 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
     SourceRange BodyRange;
   };
 
+  friend class ParseAbstractFunctionBodyRequest;
+
   CaptureInfo Captures;
 
   /// Location of the 'throws' token.
@@ -7248,6 +7250,17 @@ void simple_display(llvm::raw_ostream &out, const Decl *decl);
 /// Display ValueDecl subclasses.
 void simple_display(llvm::raw_ostream &out, const ValueDecl *decl);
 
+/// Display ExtensionDecls.
+inline void simple_display(llvm::raw_ostream &out, const ExtensionDecl *decl) {
+  simple_display(out, static_cast<const Decl *>(decl));
+}
+
+/// Display NominalTypeDecls.
+inline void simple_display(llvm::raw_ostream &out,
+                           const NominalTypeDecl *decl) {
+  simple_display(out, static_cast<const Decl *>(decl));
+}
+
 /// Extract the source location from the given declaration.
 SourceLoc extractNearestSourceLoc(const Decl *decl);
 
@@ -7261,6 +7274,11 @@ inline SourceLoc extractNearestSourceLoc(const GenericTypeDecl *type) {
   return extractNearestSourceLoc(static_cast<const Decl *>(type));
 }
 
+/// Extract the source location from the given declaration.
+inline SourceLoc extractNearestSourceLoc(const NominalTypeDecl *type) {
+  return extractNearestSourceLoc(static_cast<const Decl *>(type));
+}
+
 /// Extract the source location from the given declaration.
 inline SourceLoc extractNearestSourceLoc(const AbstractFunctionDecl *func) {
   return extractNearestSourceLoc(static_cast<const Decl *>(func));