---

yaml
---
r: 343515
b: refs/heads/master-rebranch
c: 3ddfcae
h: refs/heads/master
i:
  343513: 6000b5a
  343511: 49fbcf9

Author: slavapestov

[refs]

@@ -1455,7 +1455,7 @@ refs/tags/swift-DEVELOPMENT-SNAPSHOT-2019-08-02-a: ddd2b2976aa9bfde5f20fe37f6bd2
 refs/tags/swift-DEVELOPMENT-SNAPSHOT-2019-08-03-a: 171cc166f2abeb5ca2a4003700a8a78a108bd300
 refs/heads/benlangmuir-patch-1: baaebaf39d52f3bf36710d4fe40cf212e996b212
 refs/heads/i-do-redeclare: 8c4e6d5de5c1e3f0a2cedccf319df713ea22c48e
-refs/heads/master-rebranch: a09382ce2bae5051d0cded4a987ed2c05d1287bf
+refs/heads/master-rebranch: 3ddfcae24b928d981e6bcd9b037bacf6a505ca0a
 refs/heads/rdar-53901732: 9bd06af3284e18a109cdbf9aa59d833b24eeca7b
 refs/heads/revert-26776-subst-always-returns-a-type: 1b8e18fdd391903a348970a4c848995d4cdd789c
 refs/heads/tensorflow-merge: 8b854f62f80d4476cb383d43c4aac2001dde3cec

branches/master-rebranch/docs/ABI/Mangling.rst

@@ -551,6 +551,11 @@ Types
   type ::= assoc-type-name 'Qz'                      // shortcut for 'Qyz'
   type ::= assoc-type-list 'QY' GENERIC-PARAM-INDEX  // associated type at depth
   type ::= assoc-type-list 'QZ'                      // shortcut for 'QYz'
+  
+  #if SWIFT_RUNTIME_VERSION >= 5.2
+    type ::= type assoc-type-name 'Qx' // associated type relative to base `type`
+    type ::= type assoc-type-list 'QX' // associated type relative to base `type`
+  #endif
 
   protocol-list ::= protocol '_' protocol*
   protocol-list ::= empty-list

branches/master-rebranch/include/swift/AST/Decl.h

@@ -4338,7 +4338,7 @@ class ProtocolDecl final : public NominalTypeDecl {
   /// with the Objective-C runtime.
   StringRef getObjCRuntimeName(llvm::SmallVectorImpl<char> &buffer) const;
 
-  /// Create the generic parameters of this protocol if the haven't been
+  /// Create the generic parameters of this protocol if they haven't been
   /// created yet.
   void createGenericParamsIfMissing();
 

branches/master-rebranch/include/swift/Frontend/ParseableInterfaceModuleLoader.h

@@ -134,14 +134,16 @@ class ParseableInterfaceModuleLoader : public SerializedModuleLoaderBase {
       DependencyTracker *tracker, ModuleLoadingMode loadMode,
       ArrayRef<std::string> PreferInterfaceForModules,
       bool RemarkOnRebuildFromInterface)
-  : SerializedModuleLoaderBase(ctx, tracker, loadMode, PreferInterfaceForModules),
+  : SerializedModuleLoaderBase(ctx, tracker, loadMode),
   CacheDir(cacheDir), PrebuiltCacheDir(prebuiltCacheDir),
-  RemarkOnRebuildFromInterface(RemarkOnRebuildFromInterface)
+  RemarkOnRebuildFromInterface(RemarkOnRebuildFromInterface),
+  PreferInterfaceForModules(PreferInterfaceForModules)
   {}
 
   std::string CacheDir;
   std::string PrebuiltCacheDir;
   bool RemarkOnRebuildFromInterface;
+  ArrayRef<std::string> PreferInterfaceForModules;
 
   std::error_code findModuleFilesInDirectory(
     AccessPathElem ModuleID, StringRef DirPath, StringRef ModuleFilename,

branches/master-rebranch/include/swift/SIL/SILInstructionWorklist.h

@@ -0,0 +1,115 @@
+//===--- SILInstructionWorklist.h -------------------------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+///
+/// When visiting the instructions in a function/basic block, one often modifies
+/// the list of instructions to be visited.  That fact introduces complexity in
+/// the form of ensuring that no effort is wasted moving items down in the list
+/// when an item is removed from it and also in the form of ensuring that no
+/// instructions which have been modified/deleted are visited.
+///
+/// The SILInstructionWorklist manages that complexity.  It is responsible for
+/// ensuring that removing an instruction is not unnecessarily expensive and
+/// that only valid instructions are removed from the list.
+///
+//===----------------------------------------------------------------------===//
+
+#include "swift/SIL/SILInstruction.h"
+#include "swift/SIL/SILValue.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/SmallVector.h"
+
+namespace swift {
+
+/// Manages a list of instructions awaiting visitation.
+class SILInstructionWorklist final {
+  llvm::SmallVector<SILInstruction *, 256> worklist;
+  llvm::DenseMap<SILInstruction *, unsigned> worklistMap;
+  StringRef loggingName;
+
+  void operator=(const SILInstructionWorklist &rhs) = delete;
+  SILInstructionWorklist(const SILInstructionWorklist &worklist) = delete;
+
+public:
+  SILInstructionWorklist(const char *loggingName = "InstructionWorklist")
+      : loggingName(loggingName) {}
+
+  /// Returns true if the worklist is empty.
+  bool isEmpty() const { return worklist.empty(); }
+
+  /// Add the specified instruction to the worklist if it isn't already in it.
+  void add(SILInstruction *instruction);
+
+  /// If the given ValueBase is a SILInstruction add it to the worklist.
+  void addValue(ValueBase *value) {
+    if (auto *instruction = value->getDefiningInstruction())
+      add(instruction);
+  }
+
+  /// Add the given list of instructions in reverse order to the worklist. This
+  /// routine assumes that the worklist is empty and the given list has no
+  /// duplicates.
+  void addInitialGroup(ArrayRef<SILInstruction *> list);
+
+  // If instruction is in the worklist, remove it.
+  void remove(SILInstruction *instruction) {
+    auto iterator = worklistMap.find(instruction);
+    if (iterator == worklistMap.end())
+      return; // Not in worklist.
+
+    // Don't bother moving everything down, just null out the slot. We will
+    // check before we process any instruction if it is null.
+    worklist[iterator->second] = nullptr;
+    worklistMap.erase(iterator);
+  }
+
+  /// Remove the top element from the worklist.
+  SILInstruction *removeOne() {
+    SILInstruction *instruction = worklist.pop_back_val();
+    worklistMap.erase(instruction);
+    return instruction;
+  }
+
+  /// When an instruction has been simplified, add all of its users to the
+  /// worklist, since additional simplifications of its users may have been
+  /// exposed.
+  void addUsersToWorklist(ValueBase *instruction) {
+    for (auto *use : instruction->getUses())
+      add(use->getUser());
+  }
+
+  void addUsersToWorklist(SILValue value) {
+    for (auto *use : value->getUses())
+      add(use->getUser());
+  }
+
+  /// When an instruction has been simplified, add all of its users to the
+  /// worklist, since additional simplifications of its users may have been
+  /// exposed.
+  void addUsersOfAllResultsToWorklist(SILInstruction *instruction) {
+    for (auto result : instruction->getResults()) {
+      addUsersToWorklist(result);
+    }
+  }
+
+  /// Check that the worklist is empty and nuke the backing store for the map if
+  /// it is large.
+  void zap() {
+    assert(worklistMap.empty() && "Worklist empty, but the map is not?");
+
+    // Do an explicit clear, this shrinks the map if needed.
+    worklistMap.clear();
+  }
+};
+
+} // end namespace swift

branches/master-rebranch/include/swift/Serialization/SerializedModuleLoader.h

@@ -42,10 +42,8 @@ class SerializedModuleLoaderBase : public ModuleLoader {
 protected:
   ASTContext &Ctx;
   ModuleLoadingMode LoadMode;
-  ArrayRef<std::string> PreferInterfaceForModules;
   SerializedModuleLoaderBase(ASTContext &ctx, DependencyTracker *tracker,
-                             ModuleLoadingMode LoadMode,
-                             ArrayRef<std::string> PreferInterfaceForModules = {});
+                             ModuleLoadingMode LoadMode);
 
   void collectVisibleTopLevelModuleNamesImpl(SmallVectorImpl<Identifier> &names,
                                              StringRef extension) const;

branches/master-rebranch/lib/AST/ASTMangler.cpp

@@ -736,7 +736,9 @@ void ASTMangler::appendOpaqueDeclName(const OpaqueTypeDecl *opaqueDecl) {
   if (canSymbolicReference(opaqueDecl)) {
     appendSymbolicReference(opaqueDecl);
   } else if (auto namingDecl = opaqueDecl->getNamingDecl()) {
+    CanGenericSignature savedSignature = CurGenericSignature;
     appendEntity(namingDecl);
+    CurGenericSignature = savedSignature;
     appendOperator("QO");
   } else {
     llvm_unreachable("todo: independent opaque type decls");
@@ -1003,6 +1005,22 @@ void ASTMangler::appendType(Type type, const ValueDecl *forDecl) {
 
     case TypeKind::NestedArchetype: {
       auto nestedType = cast<NestedArchetypeType>(tybase);
+      
+      // Mangle associated types of opaque archetypes like dependent member
+      // types, so that they can be accurately demangled at runtime.
+      if (auto opaque =
+            dyn_cast<OpaqueTypeArchetypeType>(nestedType->getRoot())) {
+        if (tryMangleTypeSubstitution(nestedType))
+          return;
+        
+        appendType(opaque);
+        bool isAssocTypeAtDepth = false;
+        appendAssocType(nestedType->getInterfaceType(), isAssocTypeAtDepth);
+        appendOperator(isAssocTypeAtDepth ? "QX" : "Qx");
+        addTypeSubstitution(nestedType);
+        return;
+      }
+      
       appendType(nestedType->getParent());
       appendIdentifier(nestedType->getName().str());
       appendOperator("Qa");

branches/master-rebranch/lib/AST/ModuleNameLookup.cpp

@@ -154,9 +154,8 @@ void ModuleNameLookup<LookupStrategy>::lookupInModule(
       resolutionKind == ResolutionKind::Overloadable) {
     // If we only found top-level functions, keep looking, since we may
     // find additional overloads.
-    if (std::find_if(decls.begin() + initialCount, decls.end(),
-                     [](ValueDecl *VD) { return !isa<FuncDecl>(VD); })
-        == decls.end())
+    if (std::all_of(decls.begin() + initialCount, decls.end(),
+                    [](ValueDecl *VD) { return isa<FuncDecl>(VD); }))
       canReturnEarly = false;
   }
 

branches/master-rebranch/lib/Basic/Platform.cpp

@@ -351,6 +351,8 @@ swift::getSwiftRuntimeCompatibilityVersionForTarget(const llvm::Triple &Triple){
     if (Major == 10) {
       if (Minor <= 14) {
         return llvm::VersionTuple(5, 0);
+      } else if (Minor <= 15) {
+        return llvm::VersionTuple(5, 1);
       } else {
         return None;
       }
@@ -361,13 +363,17 @@ swift::getSwiftRuntimeCompatibilityVersionForTarget(const llvm::Triple &Triple){
     Triple.getiOSVersion(Major, Minor, Micro);
     if (Major <= 12) {
       return llvm::VersionTuple(5, 0);
+    } else if (Major <= 13) {
+      return llvm::VersionTuple(5, 1);
     } else {
       return None;
     }
   } else if (Triple.isWatchOS()) {
     Triple.getWatchOSVersion(Major, Minor, Micro);
     if (Major <= 5) {
       return llvm::VersionTuple(5, 0);
+    } else if (Major <= 6) {
+      return llvm::VersionTuple(5, 1);
     } else {
       return None;
     }