---

yaml
---
r: 349126
b: refs/heads/master
c: 7214b0d
h: refs/heads/master

Author: beccadax

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: e01ce6ccec49504ae923778896716367e443c018
+refs/heads/master: 7214b0da75a56bd603fc593640cbb4934dc417c9
 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/Decl.h

@@ -71,6 +71,7 @@ namespace swift {
   class GenericTypeParamDecl;
   class GenericTypeParamType;
   class ModuleDecl;
+  class NamedPattern;
   class EnumCaseDecl;
   class EnumElementDecl;
   class ParameterList;
@@ -4773,6 +4774,8 @@ enum class PropertyWrapperSynthesizedPropertyKind {
 
 /// VarDecl - 'var' and 'let' declarations.
 class VarDecl : public AbstractStorageDecl {
+  NamedPattern *NamingPattern = nullptr;
+
 public:
   enum class Introducer : uint8_t {
     Let = 0,
@@ -4786,10 +4789,6 @@ class VarDecl : public AbstractStorageDecl {
           bool issCaptureList, SourceLoc nameLoc, Identifier name,
           DeclContext *dc, StorageIsMutable_t supportsMutation);
 
-  TypeRepr *ParentRepr = nullptr;
-
-  Type typeInContext;
-
 public:
   VarDecl(bool isStatic, Introducer introducer, bool isCaptureList,
           SourceLoc nameLoc, Identifier name, DeclContext *dc)
@@ -4806,26 +4805,10 @@ 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.
-    return !typeInContext.isNull();
-  }
-
   /// Get the type of the variable within its context. If the context is generic,
   /// this will use archetypes.
   Type getType() const;
 
-  /// Set the type of the variable within its context.
-  void setType(Type t);
-
-  void markInvalid();
-
   /// Retrieve the source range of the variable type, or an invalid range if the
   /// variable's type is not explicitly written in the source.
   ///
@@ -4864,6 +4847,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.
   ///
@@ -4904,6 +4895,9 @@ class VarDecl : public AbstractStorageDecl {
     Parent = v;
   }
 
+  NamedPattern *getNamingPattern() const { return NamingPattern; }
+  void setNamingPattern(NamedPattern *Pat) { NamingPattern = Pat; }
+
   /// If this is a VarDecl that does not belong to a CaseLabelItem's pattern,
   /// return this. Otherwise, this VarDecl must belong to a CaseStmt's
   /// CaseLabelItem. In that case, return the first case label item of the first
@@ -5158,6 +5152,8 @@ class ParamDecl : public VarDecl {
   SourceLoc ArgumentNameLoc;
   SourceLoc SpecifierLoc;
 
+  TypeRepr *TyRepr = nullptr;
+
   struct StoredDefaultArgument {
     PointerUnion<Expr *, VarDecl *> DefaultArg;
     Initializer *InitContext = nullptr;
@@ -5203,6 +5199,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/AST/DiagnosticsSema.def

@@ -1509,6 +1509,9 @@ ERROR(pattern_binds_no_variables,none,
       "%select{property|global variable}0 declaration does not bind any "
       "variables",
       (unsigned))
+ERROR(variable_bound_by_no_pattern,none,
+      "variable %0 is not bound by any pattern",
+      (DeclName))
 
 WARNING(optional_ambiguous_case_ref,none,
         "assuming you mean '%0.%2'; did you mean '%1.%2' instead?",

trunk/lib/AST/ASTDumper.cpp

@@ -725,7 +725,7 @@ namespace {
 
       if (auto *var = dyn_cast<VarDecl>(VD)) {
         PrintWithColorRAII(OS, TypeColor) << " type='";
-        if (var->hasType())
+        if (auto varTy = var->hasInterfaceType())
           var->getType().print(PrintWithColorRAII(OS, TypeColor).getOS());
         else
           PrintWithColorRAII(OS, TypeColor) << "<null type>";
@@ -954,13 +954,11 @@ namespace {
         PrintWithColorRAII(OS, IdentifierColor)
           << " apiName=" << P->getArgumentName();
 
-      if (P->hasType()) {
+      if (P->hasInterfaceType()) {
         PrintWithColorRAII(OS, TypeColor) << " type='";
         P->getType().print(PrintWithColorRAII(OS, TypeColor).getOS());
         PrintWithColorRAII(OS, TypeColor) << "'";
-      }
 
-      if (P->hasInterfaceType()) {
         PrintWithColorRAII(OS, InterfaceTypeColor) << " interface type='";
         P->getInterfaceType().print(
             PrintWithColorRAII(OS, InterfaceTypeColor).getOS());

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();
@@ -5007,24 +5007,7 @@ VarDecl::VarDecl(DeclKind kind, bool isStatic, VarDecl::Introducer introducer,
 }
 
 Type VarDecl::getType() const {
-  if (!typeInContext) {
-    const_cast<VarDecl *>(this)->typeInContext =
-      getDeclContext()->mapTypeIntoContext(
-        getInterfaceType());
-  }
-
-  return typeInContext;
-}
-
-void VarDecl::setType(Type t) {
-  assert(t.isNull() || !t->is<InOutType>());
-  typeInContext = t;
-}
-
-void VarDecl::markInvalid() {
-  auto &Ctx = getASTContext();
-  setType(ErrorType::get(Ctx));
-  setInterfaceType(ErrorType::get(Ctx));
+  return getDeclContext()->mapTypeIntoContext(getInterfaceType());
 }
 
 /// Returns whether the var is settable in the specified context: this
@@ -5269,9 +5252,6 @@ Pattern *VarDecl::getParentPattern() const {
           if (pat->containsVarDecl(this))
             return pat;
     }
-
-    //stmt->dump();
-    assert(0 && "Unknown parent pattern statement?");
   }
 
   // Otherwise, check if we have to walk our case stmt's var decl list to find
@@ -5285,6 +5265,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->getTypeRepr();
+
+  return nullptr;
+}
+
 NullablePtr<VarDecl>
 VarDecl::getCorrespondingFirstCaseLabelItemVarDecl() const {
   if (!hasName())

trunk/lib/ClangImporter/ImportDecl.cpp

@@ -2110,7 +2110,6 @@ applyPropertyOwnership(VarDecl *prop,
   if (attrs & clang::ObjCPropertyDecl::OBJC_PR_weak) {
     prop->getAttrs().add(new (ctx)
                              ReferenceOwnershipAttr(ReferenceOwnership::Weak));
-    prop->setType(WeakStorageType::get(prop->getType(), ctx));
     prop->setInterfaceType(WeakStorageType::get(
         prop->getInterfaceType(), ctx));
     return;
@@ -2119,7 +2118,6 @@ applyPropertyOwnership(VarDecl *prop,
       (attrs & clang::ObjCPropertyDecl::OBJC_PR_unsafe_unretained)) {
     prop->getAttrs().add(
         new (ctx) ReferenceOwnershipAttr(ReferenceOwnership::Unmanaged));
-    prop->setType(UnmanagedStorageType::get(prop->getType(), ctx));
     prop->setInterfaceType(UnmanagedStorageType::get(
         prop->getInterfaceType(), ctx));
     return;

trunk/lib/Frontend/Frontend.cpp

@@ -318,6 +318,23 @@ void CompilerInstance::setUpDiagnosticOptions() {
   }
 }
 
+// The ordering of ModuleLoaders is important!
+//
+// 1. SourceLoader: This is a hack and only the compiler's tests are using it,
+//    to avoid writing repetitive code involving generating modules/interfaces.
+//    Ideally, we'd get rid of it.
+// 2. MemoryBufferSerializedModuleLoader: This is used by LLDB, because it might
+//    already have the module available in memory.
+// 3. ModuleInterfaceLoader: Tries to find an up-to-date swiftmodule. If it
+//    succeeds, it issues a particular "error" (see
+//    [Note: ModuleInterfaceLoader-defer-to-SerializedModuleLoader]), which
+//    is interpreted by the overarching loader as a command to use the
+//    SerializedModuleLoader. If we failed to find a .swiftmodule, this falls
+//    back to using an interface. Actual errors lead to diagnostics.
+// 4. SerializedModuleLoader: Loads a serialized module if it can.
+// 5. ClangImporter: This must come after all the Swift module loaders because
+//    in the presence of overlays and mixed-source frameworks, we want to prefer
+//    the overlay or framework module over the underlying Clang module.
 bool CompilerInstance::setUpModuleLoaders() {
   if (hasSourceImport()) {
     bool enableLibraryEvolution =
@@ -354,10 +371,6 @@ bool CompilerInstance::setUpModuleLoaders() {
     Context->addModuleLoader(std::move(MemoryBufferLoader));
   }
 
-  std::unique_ptr<SerializedModuleLoader> SML =
-    SerializedModuleLoader::create(*Context, getDependencyTracker(), MLM);
-  this->SML = SML.get();
-
   // Wire up the Clang importer. If the user has specified an SDK, use it.
   // Otherwise, we just keep it around as our interface to Clang's ABI
   // knowledge.
@@ -380,7 +393,12 @@ bool CompilerInstance::setUpModuleLoaders() {
         FEOpts.RemarkOnRebuildFromModuleInterface);
     Context->addModuleLoader(std::move(PIML));
   }
+
+  std::unique_ptr<SerializedModuleLoader> SML =
+    SerializedModuleLoader::create(*Context, getDependencyTracker(), MLM);
+  this->SML = SML.get();
   Context->addModuleLoader(std::move(SML));
+
   Context->addModuleLoader(std::move(clangImporter), /*isClang*/ true);
 
   return false;

trunk/lib/Frontend/ModuleInterfaceLoader.cpp

@@ -764,6 +764,7 @@ class ModuleInterfaceLoaderImpl {
       }
     }
 
+    // [Note: ModuleInterfaceLoader-defer-to-SerializedModuleLoader]
     // Finally, if there's a module adjacent to the .swiftinterface that we can
     // _likely_ load (it validates OK and is up to date), bail early with
     // errc::not_supported, so the next (serialized) loader in the chain will

trunk/lib/IRGen/GenEnum.cpp

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

trunk/lib/Sema/CSApply.cpp

@@ -4455,7 +4455,6 @@ namespace {
           SourceLoc(),
           /*argument label*/ SourceLoc(), Identifier(),
           /*parameter name*/ SourceLoc(), ctx.getIdentifier("$0"), closure);
-      param->setType(baseTy);
       param->setInterfaceType(baseTy->mapTypeOutOfContext());
       param->setSpecifier(ParamSpecifier::Default);
 
@@ -4471,7 +4470,6 @@ namespace {
                               /*argument label*/ SourceLoc(), Identifier(),
                               /*parameter name*/ SourceLoc(),
                               ctx.getIdentifier("$kp$"), outerClosure);
-      outerParam->setType(keyPathTy);
       outerParam->setInterfaceType(keyPathTy->mapTypeOutOfContext());
       outerParam->setSpecifier(ParamSpecifier::Default);
 
@@ -4650,7 +4648,6 @@ namespace {
     Expr *visitTapExpr(TapExpr *E) {
       auto type = simplifyType(cs.getType(E));
 
-      E->getVar()->setType(type);
       E->getVar()->setInterfaceType(type->mapTypeOutOfContext());
 
       cs.setType(E, type);