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

Author: Max Moiseev

CHANGELOG.md

@@ -2,6 +2,17 @@
 Swift 3
 -------
 
+* The @noescape attribute has been extended to be a more general type attribute.
+  You can now declare values of @noescape function type, e.g. in manually
+  curried function signatures.  You can now also declare local variables of
+  @noescape type, and use @noescape in typealiases.  For example, this is now
+  valid code:
+
+    func apply<T, U>(@noescape f: T -> U,
+                     @noescape g: (@noescape T -> U) -> U) -> U {
+      return g(f)
+    }
+
 * Curried function syntax has been removed, and now produces a compile-time
   error.
 

benchmark/README.md

@@ -177,7 +177,7 @@ The benchmark driver will measure the time taken for `N = 1` and automatically c
 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
+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.
 

benchmark/scripts/Benchmark_Driver

@@ -106,9 +106,9 @@ def instrument_test(driver_path, test, num_samples):
                                        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]
+                                     key=lambda x: int(x[min_index]))[min_index]
     avg_test_output[max_index] = max(test_outputs,
-                                     key=lambda x: x[max_index])[max_index]
+                                     key=lambda x: int(x[max_index]))[max_index]
     avg_test_output = map(str, avg_test_output)
 
     return avg_test_output

benchmark/single-source/UTF8Decode.swift

@@ -15,7 +15,7 @@ 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.
+  // This test case is the longest as it's the most performance 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 = "Ру́сский язы́к один из восточнославянских языков, национальный язык русского народа."

benchmark/utils/DriverUtils.swift

@@ -29,6 +29,13 @@ struct BenchResults {
     self.mean = mean
     self.sd = sd
     self.median = median
+
+    // Sanity the bounds of our results
+    precondition(self.min <= self.max, "min should always be <= max")
+    precondition(self.min <= self.mean, "min should always be <= mean")
+    precondition(self.min <= self.median, "min should always be <= median")
+    precondition(self.max >= self.mean, "max should always be >= mean")
+    precondition(self.max >= self.median, "max should always be >= median")
   }
 }
 

cmake/modules/AddSwift.cmake

@@ -459,6 +459,14 @@ function(_compile_swift_files dependency_target_out_var_name)
       FILES "${module_file}" "${module_doc_file}"
       DESTINATION "lib${LLVM_LIBDIR_SUFFIX}/swift/${library_subdir}")
 
+  set(line_directive_tool "${SWIFT_SOURCE_DIR}/utils/line-directive")
+  set(swift_compiler_tool "${SWIFT_NATIVE_SWIFT_TOOLS_PATH}/swiftc")
+  set(swift_compiler_tool_dep)
+  if(SWIFT_BUILD_TOOLS)
+    # Depend on the binary itself, in addition to the symlink.
+    set(swift_compiler_tool_dep "swift")
+  endif()
+
   # Generate API notes if requested.
   set(command_create_apinotes)
   set(depends_create_apinotes)
@@ -470,11 +478,10 @@ function(_compile_swift_files dependency_target_out_var_name)
       set(apinote_file "${module_dir}/${apinote_module}.apinotesc")
       set(apinote_input_file
         "${SWIFT_API_NOTES_PATH}/${apinote_module}.apinotes")
-      set(CLANG_APINOTES "${SWIFT_NATIVE_CLANG_TOOLS_PATH}/clang")
 
       list(APPEND command_create_apinotes
         COMMAND
-        "${CLANG_APINOTES}" "-cc1apinotes" "-yaml-to-binary"
+        "${swift_compiler_tool}" "-apinotes" "-yaml-to-binary"
         "-o" "${apinote_file}"
         "-target" "${SWIFT_SDK_${SWIFTFILE_SDK}_ARCH_${SWIFTFILE_ARCHITECTURE}_TRIPLE}"
         "${apinote_input_file}")
@@ -487,14 +494,6 @@ function(_compile_swift_files dependency_target_out_var_name)
     endforeach()
   endif()
 
-  set(line_directive_tool "${SWIFT_SOURCE_DIR}/utils/line-directive")
-  set(swift_compiler_tool "${SWIFT_NATIVE_SWIFT_TOOLS_PATH}/swiftc")
-  set(swift_compiler_tool_dep)
-  if(SWIFT_BUILD_TOOLS)
-    # Depend on the binary itself, in addition to the symlink.
-    set(swift_compiler_tool_dep "swift")
-  endif()
-
   # If there are more than one output files, we assume that they are specified
   # otherwise e.g. with an output file map.
   set(output_option)

docs/StdlibRationales.rst

@@ -159,12 +159,17 @@ functions don't return lazy collection wrappers that refer to users' closures.
 The consequence is that all users' closures are ``@noescape``, except in an
 explicitly lazy context.
 
-Based on this rule, we conclude that ``enumerate(), ``zip()`` and
+Based on this rule, we conclude that ``enumerate()``, ``zip()`` and
 ``reverse()`` return lazy wrappers, but ``filter()`` and ``map()`` don't.  For
 the first three functions being lazy is the right default, since usually the
 result is immediately consumed by for-in, so we don't want to allocate memory
 for it.
 
+Note that neither of the two ``sorted()`` methods (neither one that accepts a
+custom comparator closure, nor one that uses the ``Comparable`` conformance)
+can't be lazy, because the lazy version would be less efficient than the eager
+one.
+
 A different design that was rejected is to preserve consistency with other
 strict functions by making these methods strict, but then client code needs to
 call an API with a different name, say ``lazyEnumerate()`` to opt into

include/swift/ABI/MetadataValues.h

@@ -448,8 +448,9 @@ enum class FunctionMetadataConvention: uint8_t {
 };
 
 /// Flags in a function type metadata record.
-class FunctionTypeFlags {
-  typedef size_t int_type;
+template <typename Runtime>
+class TargetFunctionTypeFlags {
+  using int_type = typename Runtime::StoredSize;
   enum : int_type {
     NumArgumentsMask = 0x00FFFFFFU,
     ConventionMask   = 0x0F000000U,
@@ -458,22 +459,24 @@ class FunctionTypeFlags {
   };
   int_type Data;
 
-  constexpr FunctionTypeFlags(int_type Data) : Data(Data) {}
+  constexpr TargetFunctionTypeFlags(int_type Data) : Data(Data) {}
 public:
-  constexpr FunctionTypeFlags() : Data(0) {}
+  constexpr TargetFunctionTypeFlags() : Data(0) {}
 
-  constexpr FunctionTypeFlags withNumArguments(unsigned numArguments) const {
-    return FunctionTypeFlags((Data & ~NumArgumentsMask) | numArguments);
+  constexpr TargetFunctionTypeFlags withNumArguments(unsigned numArguments) const {
+    return TargetFunctionTypeFlags((Data & ~NumArgumentsMask) | numArguments);
   }
 
-  constexpr FunctionTypeFlags withConvention(FunctionMetadataConvention c) const {
-    return FunctionTypeFlags((Data & ~ConventionMask)
+  constexpr TargetFunctionTypeFlags<Runtime>
+  withConvention(FunctionMetadataConvention c) const {
+    return TargetFunctionTypeFlags((Data & ~ConventionMask)
                              | (int_type(c) << ConventionShift));
   }
 
-  constexpr FunctionTypeFlags withThrows(bool throws) const {
-    return FunctionTypeFlags((Data & ~ThrowsMask)
-                             | (throws ? ThrowsMask : 0));
+  constexpr TargetFunctionTypeFlags<Runtime>
+  withThrows(bool throws) const {
+    return TargetFunctionTypeFlags<Runtime>((Data & ~ThrowsMask) |
+                                            (throws ? ThrowsMask : 0));
   }
 
   unsigned getNumArguments() const {
@@ -492,17 +495,18 @@ class FunctionTypeFlags {
     return Data;
   }
 
-  static FunctionTypeFlags fromIntValue(int_type Data) {
-    return FunctionTypeFlags(Data);
+  static TargetFunctionTypeFlags<Runtime> fromIntValue(int_type Data) {
+    return TargetFunctionTypeFlags(Data);
   }
 
-  bool operator==(FunctionTypeFlags other) const {
+  bool operator==(TargetFunctionTypeFlags<Runtime> other) const {
     return Data == other.Data;
   }
-  bool operator!=(FunctionTypeFlags other) const {
+  bool operator!=(TargetFunctionTypeFlags<Runtime> other) const {
     return Data != other.Data;
   }
 };
+using FunctionTypeFlags = TargetFunctionTypeFlags<InProcess>;
 
 /// Field types and flags as represented in a nominal type's field/case type
 /// vector.

include/swift/AST/ASTPrinter.h

@@ -43,26 +43,35 @@ enum class PrintNameContext {
   /// not escaped.
   FunctionParameterExternal,
   FunctionParameterLocal,
+  /// Tuple element context, similar to \c FunctionParameterExternal.
+  TupleElement,
+  /// Attributes, which are escaped as 'Normal', but differentiated for
+  /// the purposes of printName* callbacks.
+  Attribute,
 };
 
-/// Describes the kind of parameter-like entity being printed.
+/// Describes the kind of structured entity being printed.
+///
+/// This includes printables with sub-structure that cannot be completely
+/// handled by the printDeclPre/printDeclPost callbacks.
 /// E.g.
 /// \code
 ///   func foo(<FunctionParameter>x: Int = 2</FunctionParameter>, ...)
 /// \endcode
-enum class PrintParameterKind {
+enum class PrintStructureKind {
+  GenericParameter,
+  GenericRequirement,
   FunctionParameter,
+  FunctionType,
+  FunctionReturnType,
+  BuiltinAttribute,
+  TupleElement,
 };
 
 /// An abstract class used to print an AST.
 class ASTPrinter {
   unsigned CurrentIndentation = 0;
   unsigned PendingNewlines = 0;
-  /// The queue of pending printDeclPre callbacks that will be run when we print
-  /// a non-whitespace character.
-  SmallVector<const Decl *, 4> PendingDeclPreCallbacks;
-  const Decl *PendingDeclLocCallback = nullptr;
-  Optional<PrintNameContext> PendingNamePreCallback;
   const NominalTypeDecl *SynthesizeTarget = nullptr;
 
   void printTextImpl(StringRef Text);
@@ -117,10 +126,14 @@ 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 structured entity.
+  ///
+  /// Callers should use callPrintStructurePre().
+  virtual void printStructurePre(PrintStructureKind Kind,
+                                 const Decl *D = nullptr) {}
+  /// Called after printing a structured entity.
+  virtual void printStructurePost(PrintStructureKind Kind,
+                                  const Decl *D = nullptr) {}
 
   /// Called before printing a name in the given context.
   virtual void printNamePre(PrintNameContext Context) {}
@@ -153,6 +166,14 @@ class ASTPrinter {
     printNamePost(PrintNameContext::Keyword);
   }
 
+  void printAttrName(StringRef Name, bool needAt = false) {
+    callPrintNamePre(PrintNameContext::Attribute);
+    if (needAt)
+      *this << "@";
+    *this << Name;
+    printNamePost(PrintNameContext::Attribute);
+  }
+
   void printName(Identifier Name,
                  PrintNameContext Context = PrintNameContext::Normal);
 
@@ -171,51 +192,52 @@ class ASTPrinter {
     PendingNewlines++;
   }
 
+  void forceNewlines() {
+    if (PendingNewlines > 0) {
+      llvm::SmallString<16> Str;
+      for (unsigned i = 0; i != PendingNewlines; ++i)
+        Str += '\n';
+      PendingNewlines = 0;
+      printText(Str);
+      printIndent();
+    }
+  }
+
   virtual void printIndent();
 
   // MARK: Callback interface wrappers that perform ASTPrinter bookkeeping.
 
-  /// Schedule a \c printDeclPre callback to be called as soon as a
-  /// non-whitespace character is printed.
-  void callPrintDeclPre(const Decl *D) {
-    PendingDeclPreCallbacks.emplace_back(D);
-  }
+   /// Make a callback to printDeclPre(), performing any necessary bookeeping.
+  void callPrintDeclPre(const Decl *D);
 
   /// Make a callback to printDeclPost(), performing any necessary bookeeping.
   void callPrintDeclPost(const Decl *D) {
-    if (!PendingDeclPreCallbacks.empty() &&
-        PendingDeclPreCallbacks.back() == D) {
-      // Nothing printed for D; skip both pre and post callbacks.
-      // Ideally we wouldn't get as far as setting up the callback if we aren't
-      // going to print anything, but currently that would mean walking the
-      // children of top-level code decls to determine.
-      PendingDeclPreCallbacks.pop_back();
-      return;
-    }
     printDeclPost(D);
   }
 
   /// Make a callback to avoidPrintDeclPost(), performing any necessary
   /// bookkeeping.
   void callAvoidPrintDeclPost(const Decl *D) {
-    assert((PendingDeclPreCallbacks.empty() ||
-            PendingDeclPreCallbacks.back() != D) &&
-           "printDeclPre should not be called on avoided decl");
     avoidPrintDeclPost(D);
   }
 
-  /// Schedule a \c printDeclLoc callback to be called as soon as a
-  /// non-whitespace character is printed.
+   /// Make a callback to printDeclLoc(), performing any necessary bookeeping.
   void callPrintDeclLoc(const Decl *D) {
-    assert(!PendingDeclLocCallback && "unexpected nested callPrintDeclLoc");
-    PendingDeclLocCallback = D;
+    forceNewlines();
+    printDeclLoc(D);
   }
 
-  /// Schedule a \c printNamePre callback to be called as soon as a
-  /// non-whitespace character is printed.
+   /// Make a callback to printNamePre(), performing any necessary bookeeping.
   void callPrintNamePre(PrintNameContext Context) {
-    assert(!PendingNamePreCallback && "unexpected nested callPrintNamePre");
-    PendingNamePreCallback = Context;
+    forceNewlines();
+    printNamePre(Context);
+  }
+
+  /// Make a callback to printStructurePre(), performing any necessary
+  /// bookkeeping.
+  void callPrintStructurePre(PrintStructureKind Kind, const Decl *D = nullptr) {
+    forceNewlines();
+    printStructurePre(Kind, D);
   }
 
   /// To sanitize a malformed utf8 string to a well-formed one.

include/swift/AST/Attr.def

@@ -46,7 +46,7 @@ TYPE_ATTR(in)
 TYPE_ATTR(inout)
 TYPE_ATTR(inout_aliasable)
 TYPE_ATTR(in_guaranteed)
-TYPE_ATTR(noescape)  // Only valid in sil mode.
+TYPE_ATTR(noescape)
 TYPE_ATTR(owned)
 TYPE_ATTR(unowned_inner_pointer)
 TYPE_ATTR(guaranteed)

include/swift/AST/Attr.h

@@ -361,6 +361,10 @@ class DeclAttribute : public AttributeBase {
     return getOptions(getKind());
   }
 
+  /// Prints this attribute (if applicable), returning `true` if anything was
+  /// printed.
+  bool printImpl(ASTPrinter &Printer, const PrintOptions &Options) const;
+
 public:
   DeclAttrKind getKind() const {
     return static_cast<DeclAttrKind>(DeclAttrBits.Kind);