---

yaml
---
r: 349115
b: refs/heads/master
c: ca19a9d
h: refs/heads/master
i:
  349113: 0c45e7e
  349111: 549117a

Author: CodaFi

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: f15544de0b1cbb9cbcdbb1b5b83fd6fac008db79
+refs/heads/master: ca19a9d12fe3e819cdc1c61f008f3a07daae0008
 refs/heads/master-next: 203b3026584ecad859eb328b2e12490099409cd5
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea

trunk/CMakeLists.txt

@@ -377,6 +377,10 @@ option(SWIFT_ENABLE_STDLIBCORE_EXCLUSIVITY_CHECKING
   "Build stdlibCore with exclusivity checking enabled"
   FALSE)
 
+option(SWIFT_ENABLE_EXPERIMENTAL_DIFFERENTIABLE_PROGRAMMING
+  "Enable experimental Swift differentiable programming features"
+  FALSE)
+
 #
 # End of user-configurable options.
 #

trunk/benchmark/single-source/UTF8Decode.swift

@@ -42,6 +42,18 @@ public let UTF8Decode = [
       name: "UTF8Decode_InitFromBytes_ascii",
       runFunction: run_UTF8Decode_InitFromBytes_ascii,
       tags: [.validation, .api, .String]),
+    BenchmarkInfo(
+      name: "UTF8Decode_InitFromData_ascii_as_ascii",
+      runFunction: run_UTF8Decode_InitFromData_ascii_as_ascii,
+      tags: [.validation, .api, .String]),
+    BenchmarkInfo(
+      name: "UTF8Decode_InitDecoding_ascii_as_ascii",
+      runFunction: run_UTF8Decode_InitDecoding_ascii_as_ascii,
+      tags: [.validation, .api, .String]),
+    BenchmarkInfo(
+      name: "UTF8Decode_InitFromBytes_ascii_as_ascii",
+      runFunction: run_UTF8Decode_InitFromBytes_ascii_as_ascii,
+      tags: [.validation, .api, .String]),
 ]
 
 // 1-byte sequences
@@ -129,4 +141,26 @@ public func run_UTF8Decode_InitFromBytes_ascii(_ N: Int) {
   }
 }
 
+@inline(never)
+public func run_UTF8Decode_InitFromData_ascii_as_ascii(_ N: Int) {
+  let input = asciiData
+  for _ in 0..<1_000*N {
+    blackHole(String(data: input, encoding: .ascii))
+  }
+}
+@inline(never)
+public func run_UTF8Decode_InitDecoding_ascii_as_ascii(_ N: Int) {
+  let input = asciiBytes
+  for _ in 0..<1_000*N {
+    blackHole(String(decoding: input, as: Unicode.ASCII.self))
+  }
+}
+@inline(never)
+public func run_UTF8Decode_InitFromBytes_ascii_as_ascii(_ N: Int) {
+  let input = asciiBytes
+  for _ in 0..<1_000*N {
+    blackHole(String(bytes: input, encoding: .ascii))
+  }
+}
+
 

trunk/cmake/modules/AddSwift.cmake

@@ -422,6 +422,10 @@ function(_add_variant_swift_compile_flags
     list(APPEND result "-D" "SWIFT_ENABLE_RUNTIME_FUNCTION_COUNTERS")
   endif()
 
+  if(SWIFT_ENABLE_EXPERIMENTAL_DIFFERENTIABLE_PROGRAMMING)
+    list(APPEND result "-D" "SWIFT_ENABLE_EXPERIMENTAL_DIFFERENTIABLE_PROGRAMMING")
+  endif()
+
   set("${result_var_name}" "${result}" PARENT_SCOPE)
 endfunction()
 

trunk/include/swift/AST/AnyFunctionRef.h

@@ -52,13 +52,13 @@ class AnyFunctionRef {
     }
   }
 
-  const CaptureInfo &getCaptureInfo() const {
+  CaptureInfo getCaptureInfo() const {
     if (auto *AFD = TheFunction.dyn_cast<AbstractFunctionDecl *>())
       return AFD->getCaptureInfo();
     return TheFunction.get<AbstractClosureExpr *>()->getCaptureInfo();
   }
 
-  void setCaptureInfo(const CaptureInfo &captures) const {
+  void setCaptureInfo(CaptureInfo captures) const {
     if (auto *AFD = TheFunction.dyn_cast<AbstractFunctionDecl *>()) {
       AFD->setCaptureInfo(captures);
       return;

trunk/include/swift/AST/Decl.h

@@ -2021,8 +2021,8 @@ class PatternBindingEntry {
   /// from the source range.
   SourceRange getSourceRange(bool omitAccessors = false) const;
 
-  const CaptureInfo &getCaptureInfo() const { return Captures; }
-  void setCaptureInfo(const CaptureInfo &captures) { Captures = captures; }
+  CaptureInfo getCaptureInfo() const { return Captures; }
+  void setCaptureInfo(CaptureInfo captures) { Captures = captures; }
 
 private:
   SourceLoc getLastAccessorEndLoc() const;
@@ -2126,11 +2126,11 @@ class PatternBindingDecl final : public Decl,
     return getPatternList()[i].getInitContext();
   }
 
-  const CaptureInfo &getCaptureInfo(unsigned i) const {
+  CaptureInfo getCaptureInfo(unsigned i) const {
     return getPatternList()[i].getCaptureInfo();
   }
 
-  void setCaptureInfo(unsigned i, const CaptureInfo &captures) {
+  void setCaptureInfo(unsigned i, CaptureInfo captures) {
     getMutablePatternList()[i].setCaptureInfo(captures);
   }
 
@@ -5237,12 +5237,12 @@ class ParamDecl : public VarDecl {
 
   void setDefaultArgumentInitContext(Initializer *initContext);
 
-  const CaptureInfo &getDefaultArgumentCaptureInfo() const {
+  CaptureInfo getDefaultArgumentCaptureInfo() const {
     assert(DefaultValueAndFlags.getPointer());
     return DefaultValueAndFlags.getPointer()->Captures;
   }
 
-  void setDefaultArgumentCaptureInfo(const CaptureInfo &captures);
+  void setDefaultArgumentCaptureInfo(CaptureInfo captures);
 
   /// Extracts the text of the default argument attached to the provided
   /// ParamDecl, removing all inactive #if clauses and providing only the
@@ -5814,8 +5814,8 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   /// Retrieve the source range of the function declaration name + patterns.
   SourceRange getSignatureSourceRange() const;
 
-  const CaptureInfo &getCaptureInfo() const { return Captures; }
-  void setCaptureInfo(const CaptureInfo &captures) { Captures = captures; }
+  CaptureInfo getCaptureInfo() const { return Captures; }
+  void setCaptureInfo(CaptureInfo captures) { Captures = captures; }
 
   /// Retrieve the Objective-C selector that names this method.
   ObjCSelector getObjCSelector(DeclName preferredName = DeclName(),

trunk/include/swift/AST/Expr.h

@@ -3449,7 +3449,7 @@ class AbstractClosureExpr : public DeclContext, public Expr {
     Bits.AbstractClosureExpr.Discriminator = Discriminator;
   }
 
-  const CaptureInfo &getCaptureInfo() const { return Captures; }
+  CaptureInfo getCaptureInfo() const { return Captures; }
   void setCaptureInfo(CaptureInfo captures) { Captures = captures; }
 
   /// Retrieve the parameters of this closure.

trunk/include/swift/AST/Initializer.h

@@ -150,12 +150,6 @@ class SerializedPatternBindingInitializer : public SerializedLocalDeclContext {
 /// A default argument expression.  The parent context is the function
 /// (possibly a closure) for which this is a default argument.
 class DefaultArgumentInitializer : public Initializer {
-  friend class ASTContext; // calls reset on unused contexts
-  void reset(DeclContext *parent, unsigned index) {
-    setParent(parent);
-    SpareBits = index;
-  }
-
 public:
   explicit DefaultArgumentInitializer(DeclContext *parent, unsigned index)
       : Initializer(InitializerKind::DefaultArgument, parent) {

trunk/include/swift/SIL/SILArgumentConvention.h

@@ -17,18 +17,6 @@
 
 namespace swift {
 
-enum class InoutAliasingAssumption {
-  /// Assume that an inout indirect parameter may alias other objects.
-  /// This is the safe assumption an optimization should make if it may break
-  /// memory safety in case the inout aliasing rule is violation.
-  Aliasing,
-
-  /// Assume that an inout indirect parameter cannot alias other objects.
-  /// Optimizations should only use this if they can guarantee that they will
-  /// not break memory safety even if the inout aliasing rule is violated.
-  NotAliasing
-};
-
 /// Conventions for apply operands and function-entry arguments in SIL.
 ///
 /// This is simply a union of ParameterConvention and ResultConvention
@@ -142,19 +130,14 @@ struct SILArgumentConvention {
   }
 
   /// Returns true if \p Value is a not-aliasing indirect parameter.
-  /// The \p isInoutAliasing specifies what to assume about the inout
-  /// convention.
-  /// See InoutAliasingAssumption.
-  bool isNotAliasedIndirectParameter(InoutAliasingAssumption isInoutAliasing) {
+  bool isNotAliasedIndirectParameter() {
     switch (Value) {
     case SILArgumentConvention::Indirect_In:
     case SILArgumentConvention::Indirect_In_Constant:
     case SILArgumentConvention::Indirect_Out:
     case SILArgumentConvention::Indirect_In_Guaranteed:
-      return true;
-
     case SILArgumentConvention::Indirect_Inout:
-      return isInoutAliasing == InoutAliasingAssumption::NotAliasing;
+      return true;
 
     case SILArgumentConvention::Indirect_InoutAliasable:
     case SILArgumentConvention::Direct_Unowned:

trunk/include/swift/SIL/SILConstants.h

@@ -33,6 +33,7 @@ struct DerivedAddressValue;
 struct EnumWithPayloadSymbolicValue;
 struct SymbolicValueMemoryObject;
 struct UnknownSymbolicValue;
+struct SymbolicClosure;
 
 extern llvm::cl::opt<unsigned> ConstExprLimit;
 
@@ -261,6 +262,9 @@ class SymbolicValue {
 
     /// This represents an array.
     RK_Array,
+
+    /// This represents a closure.
+    RK_Closure,
   };
 
   union {
@@ -305,7 +309,7 @@ class SymbolicValue {
     /// information about the memory object and access path of the access.
     DerivedAddressValue *derivedAddress;
 
-    // The following fields are for representing an Array.
+    // The following two fields are for representing an Array.
     //
     // In Swift, an array is a non-trivial struct that stores a reference to an
     // internal storage: _ContiguousArrayStorage. Though arrays have value
@@ -329,6 +333,10 @@ class SymbolicValue {
     /// When this symbolic value is of an "Array" kind, this stores a memory
     /// object that contains a SymbolicArrayStorage value.
     SymbolicValueMemoryObject *array;
+
+    /// When this symbolic value is of "Closure" kind, store a pointer to the
+    /// symbolic representation of the closure.
+    SymbolicClosure *closure;
   } value;
 
   RepresentationKind representationKind : 8;
@@ -384,6 +392,9 @@ class SymbolicValue {
     /// This represents an array value.
     Array,
 
+    /// This represents a closure.
+    Closure,
+
     /// These values are generally only seen internally to the system, external
     /// clients shouldn't have to deal with them.
     UninitMemory
@@ -533,6 +544,22 @@ class SymbolicValue {
   /// Return the type of this array symbolic value.
   Type getArrayType() const;
 
+  /// Create and return a symbolic value that represents a closure.
+  /// \param target SILFunction corresponding the target of the closure.
+  /// \param capturedArguments an array consisting of SILValues of captured
+  /// arguments along with their symbolic values when available.
+  /// \param allocator the allocator to use for storing the contents of this
+  /// symbolic value.
+  static SymbolicValue makeClosure(
+      SILFunction *target,
+      ArrayRef<std::pair<SILValue, Optional<SymbolicValue>>> capturedArguments,
+      SymbolicValueAllocator &allocator);
+
+  SymbolicClosure *getClosure() const {
+    assert(getKind() == Closure);
+    return value.closure;
+  }
+
   //===--------------------------------------------------------------------===//
   // Helpers
 
@@ -607,6 +634,57 @@ struct SymbolicValueMemoryObject {
   SymbolicValueMemoryObject(const SymbolicValueMemoryObject &) = delete;
   void operator=(const SymbolicValueMemoryObject &) = delete;
 };
+
+using SymbolicClosureArgument = std::pair<SILValue, Optional<SymbolicValue>>;
+
+/// Representation of a symbolic closure. A symbolic closure consists of a
+/// SILFunction and an array of SIL values, corresponding to the captured
+/// arguments, and (optional) symbolic values representing the constant values
+/// of the captured arguments. The symbolic values are optional as it is not
+/// necessary for every captured argument to be a constant, which enables
+/// representing closures whose captured arguments are not compile-time
+/// constants.
+struct SymbolicClosure final
+  : private llvm::TrailingObjects<SymbolicClosure, SymbolicClosureArgument> {
+
+  friend class llvm::TrailingObjects<SymbolicClosure, SymbolicClosureArgument>;
+
+private:
+
+  SILFunction *target;
+
+  // The number of SIL values captured by the closure.
+  unsigned numCaptures;
+
+  // True iff there exists captured arguments whose constant value is not known.
+  bool hasNonConstantCaptures = true;
+
+  SymbolicClosure() = delete;
+  SymbolicClosure(const SymbolicClosure &) = delete;
+  SymbolicClosure(SILFunction *callee, unsigned numArguments,
+                  bool nonConstantCaptures)
+      : target(callee), numCaptures(numArguments),
+        hasNonConstantCaptures(nonConstantCaptures) {}
+
+public:
+  static SymbolicClosure *create(SILFunction *callee,
+                                 ArrayRef<SymbolicClosureArgument> args,
+                                 SymbolicValueAllocator &allocator);
+
+  ArrayRef<SymbolicClosureArgument> getCaptures() const {
+    return {getTrailingObjects<SymbolicClosureArgument>(), numCaptures};
+  }
+
+  // This is used by the llvm::TrailingObjects base class.
+  size_t numTrailingObjects(OverloadToken<SymbolicClosureArgument>) const {
+    return numCaptures;
+  }
+
+  SILFunction *getTarget() {
+    return target;
+  }
+};
+
 } // end namespace swift
 
 #endif

trunk/include/swift/SILOptimizer/Analysis/ValueTracking.h

@@ -26,16 +26,14 @@ namespace swift {
 /// any other pointer in the function.
 /// The \p assumeInoutIsNotAliasing specifies in no-aliasing is assumed for
 /// the @inout convention. See swift::isNotAliasedIndirectParameter().
-bool isNotAliasingArgument(SILValue V, InoutAliasingAssumption isInoutAliasing =
-                                         InoutAliasingAssumption::Aliasing);
+bool isNotAliasingArgument(SILValue V);
 
 /// Returns true if \p V is local inside its function. This means its underlying
 /// object either is a non-aliasing function argument or a locally allocated
 /// object.
 /// The \p assumeInoutIsNotAliasing specifies in no-aliasing is assumed for
 /// the @inout convention. See swift::isNotAliasedIndirectParameter().
-bool pointsToLocalObject(SILValue V, InoutAliasingAssumption isInoutAliasing =
-                                         InoutAliasingAssumption::Aliasing);
+bool pointsToLocalObject(SILValue V);
 
 enum class IsZeroKind {
   Zero,

trunk/lib/AST/Decl.cpp

@@ -5643,11 +5643,16 @@ void VarDecl::emitLetToVarNoteIfSimple(DeclContext *UseDC) const {
         if (AD->isGetter() && !AD->getAccessorKeywordLoc().isValid())
           return;
       }
-                   
+
       auto &d = getASTContext().Diags;
-      d.diagnose(FD->getFuncLoc(), diag::change_to_mutating,
-                 isa<AccessorDecl>(FD))
-       .fixItInsert(FD->getFuncLoc(), "mutating ");
+      auto diags = d.diagnose(FD->getFuncLoc(), diag::change_to_mutating,
+                              isa<AccessorDecl>(FD));
+      if (auto nonmutatingAttr =
+              FD->getAttrs().getAttribute<NonMutatingAttr>()) {
+        diags.fixItReplace(nonmutatingAttr->getLocation(), "mutating");
+      } else {
+        diags.fixItInsert(FD->getFuncLoc(), "mutating ");
+      }
       return;
     }
   }
@@ -5850,7 +5855,7 @@ void ParamDecl::setDefaultArgumentInitContext(Initializer *initContext) {
   DefaultValueAndFlags.getPointer()->InitContext = initContext;
 }
 
-void ParamDecl::setDefaultArgumentCaptureInfo(const CaptureInfo &captures) {
+void ParamDecl::setDefaultArgumentCaptureInfo(CaptureInfo captures) {
   assert(DefaultValueAndFlags.getPointer());
   DefaultValueAndFlags.getPointer()->Captures = captures;
 }