Merge remote-tracking branch 'origin/master' into swift-3-api-guidelines

Author: Max Moiseev

CHANGELOG.md

@@ -17,6 +17,18 @@ Swift 3
   A new argument to swiftc is provided to select the linker used, and the gold linker
   is set as the default for arm-based platforms.
 
+* Catch blocks in `rethrows` functions may now `throw` errors. For example:
+
+    ```swift
+    func process(f: () throws -> Int) rethrows -> Int {
+        do {
+            return try f()
+        } catch is SomeError {
+            throw OtherError()
+        }
+    }
+    ```
+
 Swift 2.2
 ---------
 

CMakeLists.txt

@@ -125,6 +125,10 @@ set(SWIFT_NATIVE_SWIFT_TOOLS_PATH "" CACHE STRING
 option(SWIFT_ENABLE_LTO
   "If set to true, build the swift compiler with link time optimization enabled" FALSE)
 
+# The following only works with the Ninja generator in CMake >= 3.0.
+set(SWIFT_PARALLEL_LINK_JOBS "" CACHE STRING
+  "Define the maximum number of linker jobs for swift.")
+
 #
 # User-configurable Darwin-specific options.
 #
@@ -623,9 +627,19 @@ foreach(sdk ${SWIFT_SDKS})
   unset(UNIVERSAL_LIBRARY_NAMES_${SWIFT_SDK_${sdk}_LIB_SUBDIR} CACHE)
 endforeach()
 
+if(SWIFT_PARALLEL_LINK_JOBS)
+  if(CMAKE_VERSION VERSION_LESS 3.0 OR NOT CMAKE_MAKE_PROGRAM MATCHES "ninja")
+    message(WARNING "Job pooling is only available with Ninja generators and CMake 3.0 and later.")
+  else()
+    set_property(GLOBAL APPEND PROPERTY JOB_POOLS swift_link_job_pool=${SWIFT_PARALLEL_LINK_JOBS})
+    set(CMAKE_JOB_POOL_LINK swift_link_job_pool)
+  endif()
+endif()
+
 message(STATUS "Building host Swift tools for ${SWIFT_HOST_VARIANT_SDK} ${SWIFT_HOST_VARIANT_ARCH}")
 message(STATUS "  Build type: ${CMAKE_BUILD_TYPE}")
 message(STATUS "  Assertions: ${LLVM_ENABLE_ASSERTIONS}")
+message(STATUS "  LTO:        ${SWIFT_ENABLE_LTO}")
 message(STATUS "")
 
 message(STATUS "Building Swift standard library and SDK overlays for SDKs: ${SWIFT_SDKS}")

benchmark/CMakeLists.txt

@@ -85,6 +85,7 @@ set(SWIFT_BENCH_MODULES
     single-source/SuperChars
     single-source/TwoSum
     single-source/TypeFlood
+    single-source/UTF8Decode
     single-source/Walsh
     single-source/XorLoop
 )

benchmark/README.md

@@ -173,10 +173,14 @@ To add a new multiple file test:
 The generator script looks for functions prefixed with `run_` in order to
 populate `utils/main.swift`.
 
-Each iteration of work performed in the for-loop below should run in under a
-few milliseconds. The benchmark driver will automatically calculate the
-necessary number of iterations to run each benchmark in approximately one
-second.
+The benchmark driver will measure the time taken for `N = 1` and automatically calculate
+the necessary number of iterations `N` to run each benchmark in approximately one second,
+so the test should ideally run in a few milliseconds for `N = 1`. If the test contains
+any setup code before the loop, ensure the time spent on setup is insignificant compared to
+the time spent inside the loop (for `N = 1`) – otherwise the automatic calculation of `N` might be
+significantly off and any performance gains/regressions will be masked by the fixed setup time.
+If needed you can multiply N by a fixed amount (e.g. `1...100*N`) to achieve this.
+
 
 **Performance Test Template**
 

benchmark/scripts/Benchmark_Driver

@@ -30,31 +30,31 @@ DRIVER_DIR = os.path.dirname(os.path.realpath(__file__))
 def parse_results(res, optset):
     # Parse lines like this
     # #,TEST,SAMPLES,MIN(μs),MAX(μs),MEAN(μs),SD(μs),MEDIAN(μs),PEAK_MEMORY(B)
-    SCORERE = re.compile(r"(\d+),[ \t]*(\w+)," +
-                         ",".join([r"[ \t]*([\d.]+)"] * 7))
+    score_re = re.compile(r"(\d+),[ \t]*(\w+)," +
+                          ",".join([r"[ \t]*([\d.]+)"] * 7))
     # The Totals line would be parsed like this.
-    TOTALRE = re.compile(r"()(Totals)," +
-                         ",".join([r"[ \t]*([\d.]+)"] * 7))
-    KEYGROUP = 2
-    VALGROUP = 4
-    MEMGROUP = 9
+    total_re = re.compile(r"()(Totals)," +
+                          ",".join([r"[ \t]*([\d.]+)"] * 7))
+    key_group = 2
+    val_group = 4
+    mem_group = 9
 
     tests = []
     for line in res.split():
-        m = SCORERE.match(line)
+        m = score_re.match(line)
         if not m:
-            m = TOTALRE.match(line)
+            m = total_re.match(line)
             if not m:
                 continue
-        testresult = int(m.group(VALGROUP))
-        testname = m.group(KEYGROUP)
+        testresult = int(m.group(val_group))
+        testname = m.group(key_group)
         test = {}
         test['Data'] = [testresult]
         test['Info'] = {}
         test['Name'] = "nts.swift/" + optset + "." + testname + ".exec"
         tests.append(test)
         if testname != 'Totals':
-            mem_testresult = int(m.group(MEMGROUP))
+            mem_testresult = int(m.group(mem_group))
             mem_test = {}
             mem_test['Data'] = [mem_testresult]
             mem_test['Info'] = {}
@@ -89,26 +89,26 @@ def instrument_test(driver_path, test, num_samples):
                             [peak_memory])
 
     # Average sample results
-    NUM_SAMPLES_INDEX = 2
-    MIN_INDEX = 3
-    MAX_INDEX = 4
-    AVG_START_INDEX = 5
+    num_samples_index = 2
+    min_index = 3
+    max_index = 4
+    avg_start_index = 5
 
     # TODO: Correctly take stdev
     avg_test_output = test_outputs[0]
-    avg_test_output[AVG_START_INDEX:] = map(int,
-                                            avg_test_output[AVG_START_INDEX:])
+    avg_test_output[avg_start_index:] = map(int,
+                                            avg_test_output[avg_start_index:])
     for test_output in test_outputs[1:]:
-        for i in range(AVG_START_INDEX, len(test_output)):
+        for i in range(avg_start_index, len(test_output)):
             avg_test_output[i] += int(test_output[i])
-    for i in range(AVG_START_INDEX, len(avg_test_output)):
+    for i in range(avg_start_index, len(avg_test_output)):
         avg_test_output[i] = int(round(avg_test_output[i] /
                                        float(len(test_outputs))))
-    avg_test_output[NUM_SAMPLES_INDEX] = num_samples
-    avg_test_output[MIN_INDEX] = min(test_outputs,
-                                     key=lambda x: x[MIN_INDEX])[MIN_INDEX]
-    avg_test_output[MAX_INDEX] = max(test_outputs,
-                                     key=lambda x: x[MAX_INDEX])[MAX_INDEX]
+    avg_test_output[num_samples_index] = num_samples
+    avg_test_output[min_index] = min(test_outputs,
+                                     key=lambda x: x[min_index])[min_index]
+    avg_test_output[max_index] = max(test_outputs,
+                                     key=lambda x: x[max_index])[max_index]
     avg_test_output = map(str, avg_test_output)
 
     return avg_test_output

benchmark/single-source/UTF8Decode.swift

@@ -0,0 +1,46 @@
+//===--- UTF8Decode.swift -------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import TestsUtils
+
+@inline(never)
+public func run_UTF8Decode(N: Int) {
+  // 1-byte sequences
+  // This test case is the longest as it's the most perfomance sensitive.
+  let ascii = "Swift is a multi-paradigm, compiled programming language created for iOS, OS X, watchOS, tvOS and Linux development by Apple Inc. Swift is designed to work with Apple's Cocoa and Cocoa Touch frameworks and the large body of existing Objective-C code written for Apple products. Swift is intended to be more resilient to erroneous code (\"safer\") than Objective-C and also more concise. It is built with the LLVM compiler framework included in Xcode 6 and later and uses the Objective-C runtime, which allows C, Objective-C, C++ and Swift code to run within a single program."
+  // 2-byte sequences
+  let russian = "Ру́сский язы́к один из восточнославянских языков, национальный язык русского народа."
+  // 3-byte sequences
+  let japanese = "日本語（にほんご、にっぽんご）は、主に日本国内や日本人同士の間で使われている言語である。"
+  // 4-byte sequences
+  // Most commonly emoji, which are usually mixed with other text.
+  let emoji = "Panda 🐼, Dog 🐶, Cat 🐱, Mouse 🐭."
+
+  let strings = [ ascii, russian, japanese, emoji ].map { Array($0.utf8) }
+
+  func isEmpty(result: UnicodeDecodingResult) -> Bool {
+    switch result {
+    case .emptyInput:
+      return true
+    default:
+      return false
+    }
+  }
+
+  for _ in 1...200*N {
+    for string in strings {
+      var it = string.makeIterator()
+      var utf8 = UTF8()
+      while !isEmpty(utf8.decode(&it)) { }
+    }
+  }
+}

benchmark/utils/main.swift

@@ -90,6 +90,7 @@ import StringWalk
 import SuperChars
 import TwoSum
 import TypeFlood
+import UTF8Decode
 import Walsh
 import XorLoop
 
@@ -171,6 +172,7 @@ precommitTests = [
   "SuperChars": run_SuperChars,
   "TwoSum": run_TwoSum,
   "TypeFlood": run_TypeFlood,
+  "UTF8Decode": run_UTF8Decode,
   "Walsh": run_Walsh,
   "XorLoop": run_XorLoop,
 ]

cmake/modules/AddSwift.cmake

@@ -1814,7 +1814,9 @@ function(_add_swift_executable_single name)
       COMPILE_FLAGS " ${c_compile_flags}")
   set_property(TARGET ${name} APPEND_STRING PROPERTY
       LINK_FLAGS " ${link_flags}")
-
+  if (SWIFT_PARALLEL_LINK_JOBS)
+    set_property(TARGET ${name} PROPERTY JOB_POOL_LINK swift_link_job_pool)
+  endif()
   set_output_directory(${name}
       BINARY_DIR ${SWIFT_RUNTIME_OUTPUT_INTDIR}
       LIBRARY_DIR ${SWIFT_LIBRARY_OUTPUT_INTDIR})

include/swift/ABI/MetadataValues.h

@@ -26,19 +26,27 @@
 
 namespace swift {
 
-struct Metadata;
+struct InProcess;
+template <typename Runtime> struct TargetMetadata;
+using Metadata = TargetMetadata<InProcess>;
 
 /// Kinds of Swift metadata records.  Some of these are types, some
 /// aren't.
-enum class MetadataKind : uintptr_t {
+enum class MetadataKind : uint32_t {
 #define METADATAKIND(name, value) name = value,
 #define ABSTRACTMETADATAKIND(name, start, end)                                 \
   name##_Start = start, name##_End = end,
 #include "MetadataKind.def"
 };
 
+template <typename StoredPointer>
+bool metadataKindIsClass(StoredPointer Kind) {
+  return Kind > static_cast<StoredPointer>(MetadataKind::NonIsaMetadata_End) ||
+      Kind < static_cast<StoredPointer>(MetadataKind::NonIsaMetadata_Start);
+}
+
 /// Kinds of Swift nominal type descriptor records.
-enum class NominalTypeKind : uintptr_t {
+enum class NominalTypeKind : uint32_t {
 #define NOMINALTYPEMETADATAKIND(name, value) name = value,
 #include "MetadataKind.def"
 };

include/swift/AST/ASTPrinter.h

@@ -35,6 +35,8 @@ namespace swift {
 enum class PrintNameContext {
   /// Normal context
   Normal,
+  /// Keyword context, where no keywords are escaped.
+  Keyword,
   /// Generic parameter context, where 'Self' is not escaped.
   GenericParameter,
   /// Function parameter context, where keywords other than let/var/inout are
@@ -43,6 +45,15 @@ enum class PrintNameContext {
   FunctionParameterLocal,
 };
 
+/// Describes the kind of parameter-like entity being printed.
+/// E.g.
+/// \code
+///   func foo(<FunctionParameter>x: Int = 2</FunctionParameter>, ...)
+/// \endcode
+enum class PrintParameterKind {
+  FunctionParameter,
+};
+
 /// An abstract class used to print an AST.
 class ASTPrinter {
   unsigned CurrentIndentation = 0;
@@ -106,6 +117,11 @@ class ASTPrinter {
   virtual void printSynthesizedExtensionPost(const ExtensionDecl *ED,
                                              const NominalTypeDecl *NTD) {}
 
+  /// Called before printing a parameter-like entity.
+  virtual void printParameterPre(PrintParameterKind Kind) {}
+  /// Called after printing a parameter-like entity.
+  virtual void printParameterPost(PrintParameterKind Kind) {}
+
   /// Called before printing a name in the given context.
   virtual void printNamePre(PrintNameContext Context) {}
   /// Called after printing a name in the given context.
@@ -131,6 +147,12 @@ class ASTPrinter {
 
   ASTPrinter &operator<<(DeclName name);
 
+  void printKeyword(StringRef Name) {
+    callPrintNamePre(PrintNameContext::Keyword);
+    *this << Name;
+    printNamePost(PrintNameContext::Keyword);
+  }
+
   void printName(Identifier Name,
                  PrintNameContext Context = PrintNameContext::Normal);
 

include/swift/AST/Decl.h

@@ -27,6 +27,7 @@
 #include "swift/AST/TypeAlignments.h"
 #include "swift/Basic/OptionalEnum.h"
 #include "swift/Basic/Range.h"
+#include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/Support/TrailingObjects.h"
@@ -3350,6 +3351,8 @@ class ProtocolDecl : public NominalTypeDecl {
 
   ArrayRef<ProtocolDecl *> InheritedProtocols;
 
+  llvm::DenseMap<ValueDecl *, ConcreteDeclRef> DefaultWitnesses;
+
   /// True if the protocol has requirements that cannot be satisfied (e.g.
   /// because they could not be imported from Objective-C).
   unsigned HasMissingRequirements : 1;
@@ -3494,6 +3497,23 @@ class ProtocolDecl : public NominalTypeDecl {
     HasMissingRequirements = newValue;
   }
 
+  /// Returns the default witness for a requirement, or nullptr if there is
+  /// no default.
+  ConcreteDeclRef getDefaultWitness(ValueDecl *requirement) {
+    auto found = DefaultWitnesses.find(requirement);
+    if (found == DefaultWitnesses.end())
+      return nullptr;
+    return found->second;
+  }
+
+  /// Record the default witness for a requirement.
+  void setDefaultWitness(ValueDecl *requirement, ConcreteDeclRef witness) {
+    assert(witness);
+    auto pair = DefaultWitnesses.insert(std::make_pair(requirement, witness));
+    assert(pair.second && "Already have a default witness!");
+    (void) pair;
+  }
+
   /// Set the list of inherited protocols.
   void setInheritedProtocols(ArrayRef<ProtocolDecl *> protocols) {
     assert(!InheritedProtocolsSet && "protocols already set");

include/swift/AST/DiagnosticsParse.def

@@ -148,6 +148,9 @@ NOTE(note_in_decl_extension,none,
 WARNING(inout_as_attr_deprecated,none,
         "'inout' before a parameter name is deprecated, place it before the parameter type instead",
         ())
+WARNING(line_directive_style_deprecated,none,
+        "#line directive is deprecated, please use #setline instead",
+        ())
 
 ERROR(declaration_same_line_without_semi,none,
       "consecutive declarations on a line must be separated by ';'", ())
@@ -343,6 +346,8 @@ ERROR(subscript_static,none,
       "subscript cannot be marked %0", (StaticSpellingKind))
 
 // initializer
+ERROR(invalid_nested_init,none,
+      "missing '%select{super.|self.}0' at initializer invocation", (bool))
 ERROR(initializer_decl_wrong_scope,none,
       "initializers may only be declared within a type", ())
 ERROR(expected_lparen_initializer,PointsToFirstBadToken,