---

yaml
---
r: 348839
b: refs/heads/master
c: 70b1d91
h: refs/heads/master
i:
  348837: e40957c
  348835: 24d3917
  348831: 192c5a0

Author: drodriguez

[refs]

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

trunk/CMakeLists.txt

@@ -125,7 +125,7 @@ set(SWIFT_ANALYZE_CODE_COVERAGE FALSE CACHE STRING
 # SWIFT_VERSION is deliberately /not/ cached so that an existing build directory
 # can be reused when a new version of Swift comes out (assuming the user hasn't
 # manually set it as part of their own CMake configuration).
-set(SWIFT_VERSION "5.1.1")
+set(SWIFT_VERSION "5.1")
 
 set(SWIFT_VENDOR "" CACHE STRING
     "The vendor name of the Swift compiler")

trunk/README.md

@@ -6,6 +6,7 @@
 | | **Architecture** | **Master** | **Package** |
 |---|:---:|:---:|:---:|
 | **macOS**        | x86_64 |[![Build Status](https://ci.swift.org/job/oss-swift-incremental-RA-osx/lastCompletedBuild/badge/icon)](https://ci.swift.org/job/oss-swift-incremental-RA-osx)|[![Build Status](https://ci.swift.org/job/oss-swift-package-osx/lastCompletedBuild/badge/icon)](https://ci.swift.org/job/oss-swift-package-osx)|
+| **Ubuntu 14.04** | x86_64 | [![Build Status](https://ci.swift.org/job/oss-swift-incremental-RA-linux-ubuntu-14_04/lastCompletedBuild/badge/icon)](https://ci.swift.org/job/oss-swift-incremental-RA-linux-ubuntu-14_04)|[![Build Status](https://ci.swift.org/job/oss-swift-package-linux-ubuntu-14_04/lastCompletedBuild/badge/icon)](https://ci.swift.org/job/oss-swift-package-linux-ubuntu-14_04)|
 | **Ubuntu 16.04** | x86_64 | [![Build Status](https://ci.swift.org/job/oss-swift-incremental-RA-linux-ubuntu-16_04/lastCompletedBuild/badge/icon)](https://ci.swift.org/job/oss-swift-incremental-RA-linux-ubuntu-16_04)|[![Build Status](https://ci.swift.org/job/oss-swift-package-linux-ubuntu-16_04/lastCompletedBuild/badge/icon)](https://ci.swift.org/job/oss-swift-package-linux-ubuntu-16_04)|
 | **Ubuntu 18.04** | x86_64 | [![Build Status](https://ci.swift.org/job/oss-swift-incremental-RA-linux-ubuntu-18_04/lastCompletedBuild/badge/icon)](https://ci.swift.org/job/oss-swift-incremental-RA-linux-ubuntu-18_04)|[![Build Status](https://ci.swift.org/job/oss-swift-package-linux-ubuntu-18_04/lastCompletedBuild/badge/icon)](https://ci.swift.org/job/oss-swift-package-linux-ubuntu-18_04)|
 

trunk/include/swift/ABI/Metadata.h

@@ -998,6 +998,8 @@ struct TargetClassMetadata : public TargetAnyClassMetadata<Runtime> {
   using StoredPointer = typename Runtime::StoredPointer;
   using StoredSize = typename Runtime::StoredSize;
 
+  friend class ReflectionContext;
+
   TargetClassMetadata() = default;
   constexpr TargetClassMetadata(const TargetAnyClassMetadata<Runtime> &base,
              ClassFlags flags,

trunk/include/swift/AST/AnyRequest.h

@@ -54,7 +54,7 @@ class AnyRequest {
   friend llvm::DenseMapInfo<swift::AnyRequest>;
 
   static hash_code hashForHolder(uint64_t typeID, hash_code requestHash) {
-    return hash_combine(typeID, requestHash);
+    return hash_combine(hash_value(typeID), requestHash);
   }
 
   /// Abstract base class used to hold the specific request kind.

trunk/include/swift/AST/Decl.h

@@ -340,7 +340,12 @@ class alignas(1 << DeclAlignInBits) Decl {
     IsUserAccessible : 1
   );
 
-  SWIFT_INLINE_BITFIELD(AbstractStorageDecl, ValueDecl, 1,
+  SWIFT_INLINE_BITFIELD(AbstractStorageDecl, ValueDecl, 1+1+1,
+    /// Whether a keypath component can directly reference this storage,
+    /// or if it must use the overridden declaration instead.
+    HasComputedValidKeyPathComponent : 1,
+    ValidKeyPathComponent : 1,
+    
     /// Whether this property is a type property (currently unfortunately
     /// called 'static').
     IsStatic : 1
@@ -4530,6 +4535,8 @@ class AbstractStorageDecl : public ValueDecl {
     Bits.AbstractStorageDecl.IsStatic = IsStatic;
   }
 
+  void computeIsValidKeyPathComponent();
+  
   OpaqueTypeDecl *OpaqueReturn = nullptr;
 
 public:
@@ -4772,9 +4779,18 @@ class AbstractStorageDecl : public ValueDecl {
   /// property from the given module?
   bool isResilient(ModuleDecl *M, ResilienceExpansion expansion) const;
 
+  void setIsValidKeyPathComponent(bool value) {
+    Bits.AbstractStorageDecl.HasComputedValidKeyPathComponent = true;
+    Bits.AbstractStorageDecl.ValidKeyPathComponent = value;
+  }
+
   /// True if the storage can be referenced by a keypath directly.
   /// Otherwise, its override must be referenced.
-  bool isValidKeyPathComponent() const;
+  bool isValidKeyPathComponent() const {
+    if (!Bits.AbstractStorageDecl.HasComputedValidKeyPathComponent)
+      const_cast<AbstractStorageDecl *>(this)->computeIsValidKeyPathComponent();
+    return Bits.AbstractStorageDecl.ValidKeyPathComponent;
+  }
 
   /// True if the storage exports a property descriptor for key paths in
   /// other modules.

trunk/include/swift/AST/SearchPathOptions.h

@@ -13,7 +13,6 @@
 #ifndef SWIFT_AST_SEARCHPATHOPTIONS_H
 #define SWIFT_AST_SEARCHPATHOPTIONS_H
 
-#include "swift/Basic/ArrayRefView.h"
 #include "llvm/ADT/Hashing.h"
 
 #include <string>
@@ -82,38 +81,30 @@ class SearchPathOptions {
   /// would for a non-system header.
   bool DisableModulesValidateSystemDependencies = false;
 
-private:
-  static StringRef
-  pathStringFromFrameworkSearchPath(const FrameworkSearchPath &next) {
-    return next.Path;
-  };
-
-public:
   /// Return a hash code of any components from these options that should
   /// contribute to a Swift Bridging PCH hash.
   llvm::hash_code getPCHHashComponents() const {
+    using llvm::hash_value;
     using llvm::hash_combine;
-    using llvm::hash_combine_range;
-
-    using FrameworkPathView = ArrayRefView<FrameworkSearchPath, StringRef,
-                                           pathStringFromFrameworkSearchPath>;
-    FrameworkPathView frameworkPathsOnly{FrameworkSearchPaths};
-
-    return hash_combine(SDKPath,
-                        hash_combine_range(ImportSearchPaths.begin(),
-                                           ImportSearchPaths.end()),
-                        hash_combine_range(VFSOverlayFiles.begin(),
-                                           VFSOverlayFiles.end()),
-                        // FIXME: Should we include the system-ness of framework
-                        // search paths too?
-                        hash_combine_range(frameworkPathsOnly.begin(),
-                                           frameworkPathsOnly.end()),
-                        hash_combine_range(LibrarySearchPaths.begin(),
-                                           LibrarySearchPaths.end()),
-                        RuntimeResourcePath,
-                        hash_combine_range(RuntimeLibraryImportPaths.begin(),
-                                           RuntimeLibraryImportPaths.end()),
-                        DisableModulesValidateSystemDependencies);
+    auto Code = hash_value(SDKPath);
+    for (auto Import : ImportSearchPaths) {
+      Code = hash_combine(Code, Import);
+    }
+    for (auto VFSFile : VFSOverlayFiles) {
+      Code = hash_combine(Code, VFSFile);
+    }
+    for (const auto &FrameworkPath : FrameworkSearchPaths) {
+      Code = hash_combine(Code, FrameworkPath.Path);
+    }
+    for (auto LibraryPath : LibrarySearchPaths) {
+      Code = hash_combine(Code, LibraryPath);
+    }
+    Code = hash_combine(Code, RuntimeResourcePath);
+    for (auto RuntimeLibraryImportPath : RuntimeLibraryImportPaths) {
+      Code = hash_combine(Code, RuntimeLibraryImportPath);
+    }
+    Code = hash_combine(Code, DisableModulesValidateSystemDependencies);
+    return Code;
   }
 };
 

trunk/include/swift/AST/TypeCheckRequests.h

@@ -380,7 +380,8 @@ struct WhereClauseOwner {
   SourceLoc getLoc() const;
 
   friend hash_code hash_value(const WhereClauseOwner &owner) {
-    return llvm::hash_combine(owner.dc, owner.source.getOpaqueValue());
+    return hash_combine(hash_value(owner.dc),
+                        hash_value(owner.source.getOpaqueValue()));
   }
 
   friend bool operator==(const WhereClauseOwner &lhs,
@@ -1208,7 +1209,6 @@ class UnderlyingTypeRequest :
   bool isCached() const { return true; }
   Optional<Type> getCachedResult() const;
   void cacheResult(Type value) const;
-  void diagnoseCycle(DiagnosticEngine &diags) const;
 };
 
 class OperatorPrecedenceGroupRequest
@@ -1255,23 +1255,6 @@ class EnumRawValuesRequest :
   void cacheResult(bool value) const;
 };
 
-class IsABICompatibleOverrideRequest
-    : public SimpleRequest<IsABICompatibleOverrideRequest, bool(ValueDecl *),
-                           CacheKind::Cached> {
-public:
-  using SimpleRequest::SimpleRequest;
-
-private:
-  friend SimpleRequest;
-
-  // Evaluation.
-  llvm::Expected<bool> evaluate(Evaluator &evaluator, ValueDecl *decl) const;
-
-public:
-  // Caching.
-  bool isCached() const { return true; }
-};
-
 // Allow AnyValue to compare two Type values, even though Type doesn't
 // support ==.
 template<>

trunk/include/swift/AST/TypeCheckerTypeIDZone.def

@@ -142,5 +142,3 @@ SWIFT_REQUEST(TypeChecker, UnderlyingTypeRequest, Type(TypeAliasDecl *),
               SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, USRGenerationRequest, std::string(const ValueDecl *),
               Cached, NoLocationInfo)
-SWIFT_REQUEST(TypeChecker, IsABICompatibleOverrideRequest,
-              bool(ValueDecl *), Cached, NoLocationInfo)

trunk/include/swift/AST/TypeLoc.h

@@ -68,7 +68,8 @@ struct TypeLoc {
   TypeLoc clone(ASTContext &ctx) const;
 
   friend llvm::hash_code hash_value(const TypeLoc &owner) {
-    return llvm::hash_combine(owner.Ty.getPointer(), owner.TyR);
+    return hash_combine(llvm::hash_value(owner.Ty.getPointer()),
+                        llvm::hash_value(owner.TyR));
   }
 
   friend bool operator==(const TypeLoc &lhs,

trunk/include/swift/Basic/LangOptions.h

@@ -325,10 +325,6 @@ namespace swift {
     /// set to true.
     bool ExperimentalDependenciesIncludeIntrafileOnes = false;
 
-    /// Whether to enable experimental differentiable programming features:
-    /// `@differentiable` declaration attribute, etc.
-    bool EnableExperimentalDifferentiableProgramming = false;
-
     /// Sets the target we are building for and updates platform conditions
     /// to match.
     ///
@@ -445,10 +441,12 @@ namespace swift {
     /// Return a hash code of any components from these options that should
     /// contribute to a Swift Bridging PCH hash.
     llvm::hash_code getPCHHashComponents() const {
+      auto code = llvm::hash_value(Target.str());
       SmallString<16> Scratch;
       llvm::raw_svector_ostream OS(Scratch);
       OS << EffectiveLanguageVersion;
-      return llvm::hash_combine(Target.str(), OS.str());
+      code = llvm::hash_combine(code, OS.str());
+      return code;
     }
 
   private:

trunk/include/swift/Basic/SourceLoc.h

@@ -265,8 +265,10 @@ template <> struct DenseMapInfo<swift::SourceRange> {
   }
 
   static unsigned getHashValue(const swift::SourceRange &Val) {
-    return hash_combine(Val.Start.getOpaquePointerValue(),
-                        Val.End.getOpaquePointerValue());
+    return hash_combine(DenseMapInfo<const void *>::getHashValue(
+                            Val.Start.getOpaquePointerValue()),
+                        DenseMapInfo<const void *>::getHashValue(
+                            Val.End.getOpaquePointerValue()));
   }
 
   static bool isEqual(const swift::SourceRange &LHS,

trunk/include/swift/ClangImporter/ClangImporterOptions.h

@@ -99,21 +99,23 @@ class ClangImporterOptions {
   /// Return a hash code of any components from these options that should
   /// contribute to a Swift Bridging PCH hash.
   llvm::hash_code getPCHHashComponents() const {
+    using llvm::hash_value;
     using llvm::hash_combine;
-    using llvm::hash_combine_range;
-
-    return hash_combine(ModuleCachePath,
-                        hash_combine_range(ExtraArgs.begin(), ExtraArgs.end()),
-                        OverrideResourceDir,
-                        TargetCPU,
-                        BridgingHeader,
-                        PrecompiledHeaderOutputDir,
-                        static_cast<uint8_t>(Mode),
-                        DetailedPreprocessingRecord,
-                        ImportForwardDeclarations,
-                        InferImportAsMember,
-                        DisableSwiftBridgeAttr,
-                        DisableOverlayModules);
+
+    auto Code = hash_value(ModuleCachePath);
+    Code = hash_combine(Code, llvm::hash_combine_range(ExtraArgs.begin(),
+                                                       ExtraArgs.end()));
+    Code = hash_combine(Code, OverrideResourceDir);
+    Code = hash_combine(Code, TargetCPU);
+    Code = hash_combine(Code, BridgingHeader);
+    Code = hash_combine(Code, PrecompiledHeaderOutputDir);
+    Code = hash_combine(Code, static_cast<uint8_t>(Mode));
+    Code = hash_combine(Code, DetailedPreprocessingRecord);
+    Code = hash_combine(Code, ImportForwardDeclarations);
+    Code = hash_combine(Code, InferImportAsMember);
+    Code = hash_combine(Code, DisableSwiftBridgeAttr);
+    Code = hash_combine(Code, DisableOverlayModules);
+    return Code;
   }
 };
 

trunk/include/swift/IDE/IDERequests.h

@@ -38,7 +38,8 @@ struct CursorInfoOwner {
   CursorInfoOwner(SourceFile *File, SourceLoc Loc): File(File), Loc(Loc) { }
 
   friend llvm::hash_code hash_value(const CursorInfoOwner &CI) {
-    return llvm::hash_combine(CI.File, CI.Loc.getOpaquePointerValue());
+    return hash_combine(hash_value(CI.File),
+      hash_value(CI.Loc.getOpaquePointerValue()));
   }
 
   friend bool operator==(const CursorInfoOwner &lhs, const CursorInfoOwner &rhs) {
@@ -96,9 +97,9 @@ struct RangeInfoOwner {
   RangeInfoOwner(SourceFile *File, unsigned Offset, unsigned Length);
 
   friend llvm::hash_code hash_value(const RangeInfoOwner &CI) {
-    return llvm::hash_combine(CI.File,
-                              CI.StartLoc.getOpaquePointerValue(),
-                              CI.EndLoc.getOpaquePointerValue());
+    return hash_combine(hash_value(CI.File),
+                        hash_value(CI.StartLoc.getOpaquePointerValue()),
+                        hash_value(CI.EndLoc.getOpaquePointerValue()));
   }
 
   friend bool operator==(const RangeInfoOwner &lhs, const RangeInfoOwner &rhs) {
@@ -182,9 +183,9 @@ struct OverridenDeclsOwner {
       Transitive(Transitive) {}
 
   friend llvm::hash_code hash_value(const OverridenDeclsOwner &CI) {
-    return llvm::hash_combine(CI.VD,
-                              CI.IncludeProtocolRequirements,
-                              CI.Transitive);
+    return hash_combine(hash_value(CI.VD),
+                        hash_value(CI.IncludeProtocolRequirements),
+                        hash_value(CI.Transitive));
   }
 
   friend bool operator==(const OverridenDeclsOwner &lhs,

trunk/include/swift/Option/Options.td

@@ -424,11 +424,6 @@ def disable_bridging_pch : Flag<["-"], "disable-bridging-pch">,
   Flags<[HelpHidden]>,
   HelpText<"Disable automatic generation of bridging PCH files">;
 
-// Experimental feature options
-def enable_experimental_differentiable_programming : Flag<["-"], "enable-experimental-differentiable-programming">,
-  Flags<[FrontendOption]>,
-  HelpText<"Enable experimental differentiable programming features">;
-
 // Diagnostic control options
 def suppress_warnings : Flag<["-"], "suppress-warnings">,
   Flags<[FrontendOption]>,

trunk/include/swift/Parse/ASTGen.h

@@ -67,8 +67,10 @@ class ASTGen {
 
 private:
   DeclAttributes
-  generateDeclAttributes(const syntax::Syntax &D, SourceLoc Loc,
-                         bool includeComments);
+  generateDeclAttributes(const syntax::DeclSyntax &D,
+                         const Optional<syntax::AttributeListSyntax> &attrs,
+                         const Optional<syntax::ModifierListSyntax> &modifiers,
+                         SourceLoc Loc, bool includeComments);
 
   void generateFreeStandingGenericWhereClause(
                                 const syntax::GenericWhereClauseSyntax &syntax,

trunk/include/swift/Parse/Parser.h

@@ -895,9 +895,9 @@ class Parser {
   bool parseMatchingToken(tok K, SourceLoc &TokLoc, Diag<> ErrorDiag,
                           SourceLoc OtherLoc);
 
-  ParsedSyntaxResult<ParsedTokenSyntax>
-  parseMatchingTokenSyntax(tok K, Diag<> ErrorDiag, SourceLoc OtherLoc,
-                           bool silenceDiag = false);
+  llvm::Optional<ParsedTokenSyntax>
+  parseMatchingTokenSyntax(tok K, SourceLoc &TokLoc, Diag<> ErrorDiag,
+                           SourceLoc OtherLoc);
 
   /// Returns the proper location for a missing right brace, parenthesis, etc.
   SourceLoc getLocForMissingMatchingToken() const;
@@ -919,6 +919,7 @@ class Parser {
                          llvm::function_ref<ParserStatus()> callback);
   ParserStatus parseListSyntax(tok RightK, SourceLoc LeftLoc,
                                llvm::Optional<ParsedTokenSyntax> &LastComma,
+                               SourceLoc &RightLoc,
                                llvm::Optional<ParsedTokenSyntax> &Right,
                                llvm::SmallVectorImpl<ParsedSyntax>& Junk,
                                bool AllowSepAfterLast, Diag<> ErrorDiag,

trunk/include/swift/Sema/IDETypeCheckingRequests.h

@@ -38,7 +38,8 @@ struct DeclApplicabilityOwner {
     DC(DC), Ty(Ty), ExtensionOrMember(VD) {}
 
   friend llvm::hash_code hash_value(const DeclApplicabilityOwner &CI) {
-    return llvm::hash_combine(CI.Ty.getPointer(), CI.ExtensionOrMember);
+    return hash_combine(hash_value(CI.Ty.getPointer()),
+                        hash_value(CI.ExtensionOrMember));
   }
 
   friend bool operator==(const DeclApplicabilityOwner &lhs,
@@ -95,8 +96,8 @@ struct TypePair {
   TypePair(Type FirstTy, Type SecondTy): FirstTy(FirstTy), SecondTy(SecondTy) {}
   TypePair(): TypePair(Type(), Type()) {}
   friend llvm::hash_code hash_value(const TypePair &TI) {
-    return llvm::hash_combine(TI.FirstTy.getPointer(),
-                              TI.SecondTy.getPointer());
+    return hash_combine(hash_value(TI.FirstTy.getPointer()),
+                        hash_value(TI.SecondTy.getPointer()));
   }
 
   friend bool operator==(const TypePair &lhs,
@@ -132,7 +133,9 @@ struct TypeRelationCheckInput {
     OpenArchetypes(OpenArchetypes) {}
 
   friend llvm::hash_code hash_value(const TypeRelationCheckInput &TI) {
-    return llvm::hash_combine(TI.Pair, TI.Relation, TI.OpenArchetypes);
+    return hash_combine(hash_value(TI.Pair),
+                        hash_value(TI.Relation),
+                        hash_value(TI.OpenArchetypes));
   }
 
   friend bool operator==(const TypeRelationCheckInput &lhs,