---

yaml
---
r: 349125
b: refs/heads/master
c: e01ce6c
h: refs/heads/master
i:
  349123: fae0186

Author: beccadax

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: e85a715a62e7c5a446551dcc2d1a045c55f27982
+refs/heads/master: e01ce6ccec49504ae923778896716367e443c018
 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

@@ -71,7 +71,6 @@ namespace swift {
   class GenericTypeParamDecl;
   class GenericTypeParamType;
   class ModuleDecl;
-  class NamedPattern;
   class EnumCaseDecl;
   class EnumElementDecl;
   class ParameterList;
@@ -4774,8 +4773,6 @@ enum class PropertyWrapperSynthesizedPropertyKind {
 
 /// VarDecl - 'var' and 'let' declarations.
 class VarDecl : public AbstractStorageDecl {
-  NamedPattern *NamingPattern = nullptr;
-
 public:
   enum class Introducer : uint8_t {
     Let = 0,
@@ -4789,6 +4786,10 @@ 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)
@@ -4805,10 +4806,26 @@ 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.
   ///
@@ -4847,14 +4864,6 @@ 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.
   ///
@@ -4895,9 +4904,6 @@ 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
@@ -5152,8 +5158,6 @@ class ParamDecl : public VarDecl {
   SourceLoc ArgumentNameLoc;
   SourceLoc SpecifierLoc;
 
-  TypeRepr *TyRepr = nullptr;
-
   struct StoredDefaultArgument {
     PointerUnion<Expr *, VarDecl *> DefaultArg;
     Initializer *InitContext = nullptr;
@@ -5199,10 +5203,6 @@ 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,9 +1509,6 @@ 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/include/swift/SIL/SILDeclRef.h

@@ -249,6 +249,11 @@ struct SILDeclRef {
   bool isStoredPropertyInitializer() const {
     return kind == Kind::StoredPropertyInitializer;
   }
+  /// True if the SILDeclRef references the initializer for the backing storage
+  /// of a property wrapper.
+  bool isPropertyWrapperBackingInitializer() const {
+    return kind == Kind::PropertyWrapperBackingInitializer;
+  }
 
   /// True if the SILDeclRef references the ivar initializer or deinitializer of
   /// a class.

trunk/lib/AST/ASTDumper.cpp

@@ -725,7 +725,7 @@ namespace {
 
       if (auto *var = dyn_cast<VarDecl>(VD)) {
         PrintWithColorRAII(OS, TypeColor) << " type='";
-        if (auto varTy = var->hasInterfaceType())
+        if (var->hasType())
           var->getType().print(PrintWithColorRAII(OS, TypeColor).getOS());
         else
           PrintWithColorRAII(OS, TypeColor) << "<null type>";
@@ -954,11 +954,13 @@ namespace {
         PrintWithColorRAII(OS, IdentifierColor)
           << " apiName=" << P->getArgumentName();
 
-      if (P->hasInterfaceType()) {
+      if (P->hasType()) {
         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->getTypeReprOrParentPatternTypeRepr())
+    if (auto *repr = decl->getTypeRepr())
       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->getTypeReprOrParentPatternTypeRepr();
+      returnRepr = VD->getTypeRepr();
     }
   } else if (auto *FD = dyn_cast<FuncDecl>(this)) {
     returnRepr = FD->getBodyResultTypeLoc().getTypeRepr();
@@ -5007,7 +5007,24 @@ VarDecl::VarDecl(DeclKind kind, bool isStatic, VarDecl::Introducer introducer,
 }
 
 Type VarDecl::getType() const {
-  return getDeclContext()->mapTypeIntoContext(getInterfaceType());
+  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));
 }
 
 /// Returns whether the var is settable in the specified context: this
@@ -5252,6 +5269,9 @@ 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
@@ -5265,16 +5285,6 @@ 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,6 +2110,7 @@ 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;
@@ -2118,6 +2119,7 @@ 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,23 +318,6 @@ 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 =
@@ -371,6 +354,10 @@ 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.
@@ -393,12 +380,7 @@ 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,7 +764,6 @@ 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,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 =