---

yaml
---
r: 343518
b: refs/heads/master-rebranch
c: 99c6521
h: refs/heads/master

Author: rintaro

[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: 9612f447c1ad09783cf9dcc8ba325ae7858e8ecb
+refs/heads/master-rebranch: 99c65211e6452692790779210759a5da29a83229
 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/ASTContext.h

@@ -17,7 +17,6 @@
 #ifndef SWIFT_AST_ASTCONTEXT_H
 #define SWIFT_AST_ASTCONTEXT_H
 
-#include "swift/AST/ClangModuleLoader.h"
 #include "swift/AST/Evaluator.h"
 #include "swift/AST/GenericSignature.h"
 #include "swift/AST/Identifier.h"
@@ -32,6 +31,7 @@
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/SetVector.h"
+#include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/TinyPtrVector.h"
 #include "llvm/Support/Allocator.h"
@@ -49,10 +49,12 @@ namespace clang {
 }
 
 namespace swift {
+  class AbstractFunctionDecl;
   class ASTContext;
   enum class Associativity : unsigned char;
   class AvailabilityContext;
   class BoundGenericType;
+  class ClangModuleLoader;
   class ClangNode;
   class ConcreteDeclRef;
   class ConstructorDecl;

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

@@ -543,7 +543,7 @@ class alignas(1 << DeclAlignInBits) Decl {
     NumRequirementsInSignature : 16
   );
 
-  SWIFT_INLINE_BITFIELD(ClassDecl, NominalTypeDecl, 2+1+2+1+7+1+1+1+1,
+  SWIFT_INLINE_BITFIELD(ClassDecl, NominalTypeDecl, 2+1+2+1+7+1+1+1+1+1+1,
     /// The stage of the inheritance circularity check for this class.
     Circularity : 2,
 
@@ -557,7 +557,10 @@ class alignas(1 << DeclAlignInBits) Decl {
     HasForcedEmittedMembers : 1,     
 
     HasMissingDesignatedInitializers : 1,
+    ComputedHasMissingDesignatedInitializers : 1,
+
     HasMissingVTableEntries : 1,
+    ComputedHasMissingVTableEntries : 1,
 
     /// Whether instances of this class are incompatible
     /// with weak and unowned references.
@@ -3272,7 +3275,7 @@ class NominalTypeDecl : public GenericTypeDecl, public IterableDeclContext {
   llvm::PointerIntPair<MemberLookupTable *, 1, bool> LookupTable;
 
   /// Prepare the lookup table to make it ready for lookups.
-  void prepareLookupTable(bool ignoreNewExtensions);
+  void prepareLookupTable();
 
   /// True if the entries in \c LookupTable are complete--that is, if a
   /// name is present, it contains all members with that name.
@@ -3378,24 +3381,11 @@ class NominalTypeDecl : public GenericTypeDecl, public IterableDeclContext {
   /// Retrieve the set of extensions of this type.
   ExtensionRange getExtensions();
 
-  /// Make a member of this nominal type, or one of its extensions,
-  /// immediately visible in the lookup table.
-  ///
-  /// A member of a nominal type or extension thereof will become
-  /// visible to name lookup as soon as it is added. However, if the
-  /// addition of a member is delayed---for example, because it's
-  /// being introduced in response to name lookup---this method can be
-  /// called to make it immediately visible.
-  void makeMemberVisible(ValueDecl *member);
-
   /// Special-behaviour flags passed to lookupDirect()
   enum class LookupDirectFlags {
-    /// Whether to avoid loading any new extension.
-    /// Used by the module loader to break recursion.
-    IgnoreNewExtensions = 1 << 0,
     /// Whether to include @_implements members.
     /// Used by conformance-checking to find special @_implements members.
-    IncludeAttrImplements = 1 << 1,
+    IncludeAttrImplements = 1 << 0,
   };
 
   /// Find all of the declarations with the given name within this nominal type
@@ -3879,6 +3869,7 @@ class ClassDecl final : public NominalTypeDecl {
   bool hasMissingDesignatedInitializers() const;
 
   void setHasMissingDesignatedInitializers(bool newValue = true) {
+    Bits.ClassDecl.ComputedHasMissingDesignatedInitializers = 1;
     Bits.ClassDecl.HasMissingDesignatedInitializers = newValue;
   }
 
@@ -3889,6 +3880,7 @@ class ClassDecl final : public NominalTypeDecl {
   bool hasMissingVTableEntries() const;
 
   void setHasMissingVTableEntries(bool newValue = true) {
+    Bits.ClassDecl.ComputedHasMissingVTableEntries = 1;
     Bits.ClassDecl.HasMissingVTableEntries = newValue;
   }
 
@@ -4195,6 +4187,14 @@ class ProtocolDecl final : public NominalTypeDecl {
   /// a protocol having nested types (ObjC protocols).
   llvm::TinyPtrVector<AssociatedTypeDecl *> getAssociatedTypeMembers() const;
 
+  /// Returns a protocol requirement with the given name, or nullptr if the
+  /// name has multiple overloads, or no overloads at all.
+  ValueDecl *getSingleRequirement(DeclName name) const;
+
+  /// Returns an associated type with the given name, or nullptr if one does
+  /// not exist.
+  AssociatedTypeDecl *getAssociatedType(Identifier name) const;
+
   /// Walk this protocol and all of the protocols inherited by this protocol,
   /// transitively, invoking the callback function for each protocol.
   ///
@@ -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/ClangImporter/ClangImporter.h

@@ -51,11 +51,13 @@ class ClangModuleUnit;
 class ClangNode;
 class Decl;
 class DeclContext;
+class EnumDecl;
 class ImportDecl;
 class IRGenOptions;
 class LazyResolver;
 class ModuleDecl;
 class NominalTypeDecl;
+class StructDecl;
 class TypeDecl;
 class VisibleDeclConsumer;
 enum class SelectorSplitKind;
@@ -213,6 +215,9 @@ class ClangImporter final : public ClangModuleLoader {
                       StringRef relatedEntityKind,
                       llvm::function_ref<void(TypeDecl *)> receiver) override;
 
+  /// Look up the nested 'Code' enum for an error wrapper struct.
+  EnumDecl *lookupErrorCodeEnum(const StructDecl *errorWrapper) const;
+
   /// Look for textually included declarations from the bridging header.
   ///
   /// \param filter returns true if the given clang decl/macro should be

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/lib/AST/ASTContext.cpp

@@ -17,6 +17,7 @@
 #include "swift/AST/ASTContext.h"
 #include "ForeignRepresentationInfo.h"
 #include "SubstitutionMapStorage.h"
+#include "swift/AST/ClangModuleLoader.h"
 #include "swift/AST/ConcreteDeclRef.h"
 #include "swift/AST/DiagnosticEngine.h"
 #include "swift/AST/DiagnosticsSema.h"

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

@@ -84,11 +84,7 @@ TypeDecl *ASTBuilder::createTypeDecl(NodePointer node) {
       return nullptr;
 
     auto name = Ctx.getIdentifier(node->getChild(1)->getText());
-    auto results = proto->lookupDirect(name);
-    if (results.size() != 1)
-      return nullptr;
-
-    return dyn_cast<AssociatedTypeDecl>(results[0]);
+    return proto->getAssociatedType(name);
   }
 
   auto *DC = findDeclContext(node);
@@ -585,13 +581,8 @@ Type ASTBuilder::createDependentMemberType(StringRef member,
   if (!base->isTypeParameter())
     return Type();
 
-  auto flags = OptionSet<NominalTypeDecl::LookupDirectFlags>();
-  flags |= NominalTypeDecl::LookupDirectFlags::IgnoreNewExtensions;
-  for (auto member : protocol->lookupDirect(Ctx.getIdentifier(member),
-                                            flags)) {
-    if (auto assocType = dyn_cast<AssociatedTypeDecl>(member))
-      return DependentMemberType::get(base, assocType);
-  }
+  if (auto assocType = protocol->getAssociatedType(Ctx.getIdentifier(member)))
+    return DependentMemberType::get(base, assocType);
 
   return Type();
 }

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

@@ -1005,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");