---

yaml
---
r: 349118
b: refs/heads/master
c: dd82b63
h: refs/heads/master

Author: CodaFi

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 443d6f7c300d0bfa1a215669e41bc5411f935c42
+refs/heads/master: dd82b63f6cc062b759b26dd714537b757e25e7cc
 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,10 +377,6 @@ 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,18 +42,6 @@ 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
@@ -141,26 +129,4 @@ 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,10 +422,6 @@ 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/Decl.h

@@ -4786,8 +4786,6 @@ class VarDecl : public AbstractStorageDecl {
           bool issCaptureList, SourceLoc nameLoc, Identifier name,
           DeclContext *dc, StorageIsMutable_t supportsMutation);
 
-  TypeRepr *ParentRepr = nullptr;
-
   Type typeInContext;
 
 public:
@@ -4806,11 +4804,6 @@ class VarDecl : public AbstractStorageDecl {
     return hasName() ? getBaseName().getIdentifier().str() : "_";
   }
 
-  /// Retrieve the TypeRepr corresponding to the parsed type of the parent
-  /// pattern, if it exists.
-  TypeRepr *getTypeRepr() const { return ParentRepr; }
-  void setTypeRepr(TypeRepr *repr) { ParentRepr = repr; }
-
   bool hasType() const {
     // We have a type if either the type has been computed already or if
     // this is a deserialized declaration with an interface type.
@@ -4864,6 +4857,14 @@ class VarDecl : public AbstractStorageDecl {
   ///
   Pattern *getParentPattern() const;
 
+  /// Returns the parsed type of this variable declaration.  For parameters, this
+  /// is the parsed type the user explicitly wrote.  For variables, this is the
+  /// type the user wrote in the typed pattern that binds this variable.
+  ///
+  /// Note that there are many cases where the user may elide types.  This will
+  /// return null in those cases.
+  TypeRepr *getTypeReprOrParentPatternTypeRepr() const;
+
   /// Return the statement that owns the pattern associated with this VarDecl,
   /// if one exists.
   ///
@@ -5158,6 +5159,8 @@ class ParamDecl : public VarDecl {
   SourceLoc ArgumentNameLoc;
   SourceLoc SpecifierLoc;
 
+  TypeRepr *TyRepr = nullptr;
+
   struct StoredDefaultArgument {
     PointerUnion<Expr *, VarDecl *> DefaultArg;
     Initializer *InitContext = nullptr;
@@ -5203,6 +5206,10 @@ class ParamDecl : public VarDecl {
 
   SourceLoc getSpecifierLoc() const { return SpecifierLoc; }
 
+  /// Retrieve the TypeRepr corresponding to the parsed type of the parameter, if it exists.
+  TypeRepr *getTypeRepr() const { return TyRepr; }
+  void setTypeRepr(TypeRepr *repr) { TyRepr = repr; }
+
   DefaultArgumentKind getDefaultArgumentKind() const {
     return static_cast<DefaultArgumentKind>(Bits.ParamDecl.defaultArgumentKind);
   }

trunk/include/swift/SIL/SILConstants.h

@@ -33,7 +33,6 @@ struct DerivedAddressValue;
 struct EnumWithPayloadSymbolicValue;
 struct SymbolicValueMemoryObject;
 struct UnknownSymbolicValue;
-struct SymbolicClosure;
 
 extern llvm::cl::opt<unsigned> ConstExprLimit;
 
@@ -262,9 +261,6 @@ class SymbolicValue {
 
     /// This represents an array.
     RK_Array,
-
-    /// This represents a closure.
-    RK_Closure,
   };
 
   union {
@@ -309,7 +305,7 @@ class SymbolicValue {
     /// information about the memory object and access path of the access.
     DerivedAddressValue *derivedAddress;
 
-    // The following two fields are for representing an Array.
+    // The following 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
@@ -333,10 +329,6 @@ 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;
@@ -392,9 +384,6 @@ 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
@@ -544,22 +533,6 @@ 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
 
@@ -634,57 +607,6 @@ 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/lib/AST/ASTPrinter.cpp

@@ -2524,7 +2524,7 @@ void PrintAST::visitVarDecl(VarDecl *decl) {
   if (decl->hasInterfaceType()) {
     Printer << ": ";
     TypeLoc tyLoc;
-    if (auto *repr = decl->getTypeRepr())
+    if (auto *repr = decl->getTypeReprOrParentPatternTypeRepr())
       tyLoc = TypeLoc(repr, decl->getInterfaceType());
     else
       tyLoc = TypeLoc::withoutLoc(decl->getInterfaceType());

trunk/lib/AST/Decl.cpp

@@ -2595,7 +2595,7 @@ OpaqueReturnTypeRepr *ValueDecl::getOpaqueResultTypeRepr() const {
         }
       }
     } else {
-      returnRepr = VD->getTypeRepr();
+      returnRepr = VD->getTypeReprOrParentPatternTypeRepr();
     }
   } else if (auto *FD = dyn_cast<FuncDecl>(this)) {
     returnRepr = FD->getBodyResultTypeLoc().getTypeRepr();
@@ -5285,6 +5285,16 @@ Pattern *VarDecl::getParentPattern() const {
   return nullptr;
 }
 
+TypeRepr *VarDecl::getTypeReprOrParentPatternTypeRepr() const {
+  if (auto *param = dyn_cast<ParamDecl>(this))
+    return param->getTypeRepr();
+
+  if (auto *parentPattern = dyn_cast_or_null<TypedPattern>(getParentPattern()))
+      return parentPattern->getTypeLoc().getTypeRepr();
+
+  return nullptr;
+}
+
 NullablePtr<VarDecl>
 VarDecl::getCorrespondingFirstCaseLabelItemVarDecl() const {
   if (!hasName())
@@ -5643,16 +5653,11 @@ void VarDecl::emitLetToVarNoteIfSimple(DeclContext *UseDC) const {
         if (AD->isGetter() && !AD->getAccessorKeywordLoc().isValid())
           return;
       }
-
+                   
       auto &d = getASTContext().Diags;
-      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 ");
-      }
+      d.diagnose(FD->getFuncLoc(), diag::change_to_mutating,
+                 isa<AccessorDecl>(FD))
+       .fixItInsert(FD->getFuncLoc(), "mutating ");
       return;
     }
   }

trunk/lib/IRGen/GenEnum.cpp

@@ -1127,12 +1127,10 @@ namespace {
   protected:
     int64_t getDiscriminatorIndex(EnumElementDecl *target) const override {
       // The elements are assigned discriminators ABI-compatible with their
-      // raw values from C. An invalid raw value is assigned the error index -1.
-      auto intExpr =
-          dyn_cast_or_null<IntegerLiteralExpr>(target->getRawValueExpr());
-      if (!intExpr) {
-        return -1;
-      }
+      // raw values from C.
+      assert(target->getRawValueExpr()
+             && "c-compatible enum elt has no raw value?!");
+      auto intExpr = cast<IntegerLiteralExpr>(target->getRawValueExpr());
       auto intType = getDiscriminatorType();
 
       APInt intValue =