---

yaml
---
r: 278491
b: refs/heads/swift-5.1-old-llvm-branch
c: 22bcbe5
h: refs/heads/master
i:
  278489: b422094
  278487: 377111a

Author: swift-ci

[refs]

@@ -1241,7 +1241,7 @@ refs/tags/swift-DEVELOPMENT-SNAPSHOT-2019-01-24-a: b6f62823aa5010b2ae53f15f72a57
 refs/heads/marcrasi-astverifier-disable: 3fac766a23a77ebd0640296bfd7fc116ea60a4e0
 refs/heads/revert-22227-a-tall-white-fountain-played: adfce60b2eaa54903ea189bed8a783bca609fa53
 refs/heads/revert-22300-revert-22227-a-tall-white-fountain-played: 5f92040224df7dd4e618fdfb367349df64d8acad
-refs/heads/swift-5.1-old-llvm-branch: 4acffab1738f6035af2deb3f6d9c3f164a9c96eb
+refs/heads/swift-5.1-old-llvm-branch: 22bcbe510b17fff056ac4bb87b5f89fc3830ff22
 refs/heads/swift-5.1-branch: 8060872acb4105d9655e020fe047e1ebcd77d0fb
 refs/tags/swift-4.2.2-RELEASE: e429d1f1aaf59e69d38207a96e56265c7f6fccec
 refs/tags/swift-5.0-DEVELOPMENT-SNAPSHOT-2019-02-02-a: 3e5a03d32ff3b1e9af90d6c1198c14f938379a6e

branches/swift-5.1-old-llvm-branch/include/swift/AST/DiagnosticsSema.def

@@ -586,8 +586,8 @@ ERROR(cannot_return_value_from_void_func,none,
 
 ERROR(sema_no_import,Fatal,
       "no such module '%0'", (StringRef))
-ERROR(sema_no_import_arch,Fatal,
-      "could not find module '%0' for architecture '%1'; "
+ERROR(sema_no_import_target,Fatal,
+      "could not find module '%0' for target '%1'; "
       "found: %2", (StringRef, StringRef, StringRef))
 ERROR(sema_no_import_repl,none,
       "no such module '%0'", (StringRef))

branches/swift-5.1-old-llvm-branch/include/swift/AST/NameLookup.h

@@ -118,20 +118,25 @@ class UnqualifiedLookup {
   /// That is, \c makeArrayRef(Results).take_front(IndexOfFirstOuterResults)
   /// will be Results from the innermost scope that had results, and the
   /// remaining elements of Results will be from parent scopes of this one.
+  ///
+  /// Allows unqualified name lookup to return results from outer scopes.
+  /// This is necessary for disambiguating calls to functions like `min` and
+  /// `max`.
   size_t IndexOfFirstOuterResult;
 
   /// Return true if anything was found by the name lookup.
   bool isSuccess() const { return !Results.empty(); }
 
   /// Get the result as a single type, or a null type if that fails.
-  TypeDecl *getSingleTypeResult();
+  TypeDecl *getSingleTypeResult() const;
 };
 
 inline UnqualifiedLookup::Options operator|(UnqualifiedLookup::Flags flag1,
                                             UnqualifiedLookup::Flags flag2) {
   return UnqualifiedLookup::Options(flag1) | flag2;
 }
 
+
 /// Describes the reason why a certain declaration is visible.
 enum class DeclVisibilityKind {
   /// Declaration is a local variable or type.
@@ -352,6 +357,29 @@ void lookupInModule(ModuleDecl *module, ModuleDecl::AccessPathTy accessPath,
                     const DeclContext *moduleScopeContext,
                     ArrayRef<ModuleDecl::ImportedModule> extraImports = {});
 
+template <typename Fn>
+void forAllVisibleModules(const DeclContext *DC, const Fn &fn) {
+  DeclContext *moduleScope = DC->getModuleScopeContext();
+  if (auto file = dyn_cast<FileUnit>(moduleScope))
+    file->forAllVisibleModules(fn);
+  else
+    cast<ModuleDecl>(moduleScope)
+        ->forAllVisibleModules(ModuleDecl::AccessPathTy(), fn);
+}
+
+/// Only name lookup has gathered a set of results, perform any necessary
+/// steps to prune the result set before returning it to the caller.
+bool finishLookup(const DeclContext *dc, NLOptions options,
+                  SmallVectorImpl<ValueDecl *> &decls);
+
+/// Do nothing if debugClient is null.
+template <typename Result>
+void filterForDiscriminator(SmallVectorImpl<Result> &results,
+                            DebuggerClient *debugClient);
+
+void recordLookupOfTopLevelName(DeclContext *topLevelContext, DeclName name,
+                                bool isCascading);
+
 } // end namespace namelookup
 
 /// Retrieve the set of nominal type declarations that are directly

branches/swift-5.1-old-llvm-branch/include/swift/Basic/Platform.h

@@ -74,6 +74,17 @@ namespace swift {
   ///
   /// This is a stop-gap until full Triple support (ala Clang) exists within swiftc.
   StringRef getMajorArchitectureName(const llvm::Triple &triple);
+
+  /// Computes the normalized target triple used as the most preferred name for
+  /// module loading.
+  ///
+  /// For platforms with fat binaries, this canonicalizes architecture,
+  /// vendor, and OS names, strips OS versions, and makes inferred environments
+  /// explicit. For other platforms, it returns the unmodified triple.
+  ///
+  /// The input triple should already be "normalized" in the sense that
+  /// llvm::Triple::normalize() would not affect it.
+  llvm::Triple getTargetSpecificModuleTriple(const llvm::Triple &triple);
 } // end namespace swift
 
 #endif // SWIFT_BASIC_PLATFORM_H

branches/swift-5.1-old-llvm-branch/include/swift/Demangling/Demangle.h

@@ -2,7 +2,7 @@
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Copyright (c) 2014 - 2019 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
@@ -35,6 +35,11 @@ namespace Demangle {
 
 enum class SymbolicReferenceKind : uint8_t;
 
+/// A simple default implementation that assigns letters to archetypes in
+/// alphabetic order.
+std::string archetypeName(uint64_t index, uint64_t depth);
+
+/// Display style options for the demangler.
 struct DemangleOptions {
   bool SynthesizeSugarOnTypes = false;
   bool DisplayDebuggerGeneratedModule = true;
@@ -52,6 +57,7 @@ struct DemangleOptions {
   bool ShortenArchetype = false;
   bool ShowPrivateDiscriminators = true;
   bool ShowFunctionArgumentTypes = true;
+  std::function<std::string(uint64_t, uint64_t)> ArchetypeName = archetypeName;
 
   DemangleOptions() {}
 
@@ -346,17 +352,19 @@ class Context {
   /// prefix: _T, _T0, $S, _$S.
   ///
   /// \returns The demangled string.
-  std::string demangleSymbolAsString(llvm::StringRef MangledName,
-                            const DemangleOptions &Options = DemangleOptions());
+  std::string demangleSymbolAsString(
+      llvm::StringRef MangledName,
+      const DemangleOptions &Options = DemangleOptions());
 
   /// Demangle the given type and return the readable name.
   ///
   /// \param MangledName The mangled type string, which does _not_ start with
   /// a mangling prefix.
   ///
   /// \returns The demangled string.
-  std::string demangleTypeAsString(llvm::StringRef MangledName,
-                            const DemangleOptions &Options = DemangleOptions());
+  std::string
+  demangleTypeAsString(llvm::StringRef MangledName,
+                       const DemangleOptions &Options = DemangleOptions());
 
   /// Returns true if the mangledName refers to a thunk function.
   ///
@@ -584,7 +592,6 @@ bool nodeConsumesGenericArgs(Node *node);
 bool isSpecialized(Node *node);
 
 NodePointer getUnspecialized(Node *node, NodeFactory &Factory);
-std::string archetypeName(Node::IndexType index, Node::IndexType depth);
 
 /// Returns true if the node \p kind refers to a context node, e.g. a nominal
 /// type or a function.

branches/swift-5.1-old-llvm-branch/include/swift/Remote/MetadataReader.h

@@ -410,11 +410,15 @@ class MetadataReader {
     StoredPointer InstanceAddress =
         InstanceMetadataAddressAddress + 2 * sizeof(StoredPointer);
 
+    // When built with Objective-C interop, the runtime also stores a conformance
+    // to Hashable and the base type introducing the Hashable conformance.
+    if (isObjC)
+      InstanceAddress += 2 * sizeof(StoredPointer);
+
     // Round up to alignment, and we have the start address of the
     // instance payload.
     auto AlignmentMask = VWT->getAlignmentMask();
-    auto Offset = (sizeof(HeapObject) + AlignmentMask) & ~AlignmentMask;
-    InstanceAddress += Offset;
+    InstanceAddress = (InstanceAddress + AlignmentMask) & ~AlignmentMask;
 
     return RemoteExistential(
         RemoteAddress(*InstanceMetadataAddress),
@@ -2447,6 +2451,12 @@ class MetadataReader {
       tryFindSymbol(_address, symbolName);                   \
       tryReadSymbol(_address, dest);                         \
     } while (0)
+#   define tryFindAndReadSymbolWithDefault(dest, symbolName, default) do { \
+      dest = default;                                                      \
+      auto _address = Reader->getSymbolAddress(symbolName);                \
+      if (_address)                                                        \
+        tryReadSymbol(_address, dest);                                     \
+    } while (0)
 
     tryFindAndReadSymbol(TaggedPointerMask,
                          "objc_debug_taggedpointer_mask");
@@ -2459,30 +2469,34 @@ class MetadataReader {
     if (!TaggedPointerClassesAddr)
       finish(TaggedPointerEncodingKind::Error);
     TaggedPointerClasses = TaggedPointerClassesAddr.getAddressData();
-    tryFindAndReadSymbol(TaggedPointerExtendedMask,
-                         "objc_debug_taggedpointer_ext_mask");
-    tryFindAndReadSymbol(TaggedPointerExtendedSlotShift,
-                         "objc_debug_taggedpointer_ext_slot_shift");
-    tryFindAndReadSymbol(TaggedPointerExtendedSlotMask,
-                         "objc_debug_taggedpointer_ext_slot_mask");
-    tryFindSymbol(TaggedPointerExtendedClassesAddr,
-                  "objc_debug_taggedpointer_ext_classes");
-    if (!TaggedPointerExtendedClassesAddr)
-      finish(TaggedPointerEncodingKind::Error);
-    TaggedPointerExtendedClasses =
-        TaggedPointerExtendedClassesAddr.getAddressData();
+    
+    // Extended tagged pointers don't exist on older OSes. Handle those
+    // by setting the variables to zero.
+    tryFindAndReadSymbolWithDefault(TaggedPointerExtendedMask,
+                                    "objc_debug_taggedpointer_ext_mask",
+                                    0);
+    tryFindAndReadSymbolWithDefault(TaggedPointerExtendedSlotShift,
+                                    "objc_debug_taggedpointer_ext_slot_shift",
+                                    0);
+    tryFindAndReadSymbolWithDefault(TaggedPointerExtendedSlotMask,
+                                    "objc_debug_taggedpointer_ext_slot_mask",
+                                    0);
+    auto TaggedPointerExtendedClassesAddr =
+      Reader->getSymbolAddress("objc_debug_taggedpointer_ext_classes");
+    if (TaggedPointerExtendedClassesAddr)
+      TaggedPointerExtendedClasses =
+          TaggedPointerExtendedClassesAddr.getAddressData();
 
     // The tagged pointer obfuscator is not present on older OSes, in
     // which case we can treat it as zero.
-    TaggedPointerObfuscator = 0;
-    auto TaggedPointerObfuscatorAddr = Reader->getSymbolAddress(
-      "objc_debug_taggedpointer_obfuscator");
-    if (TaggedPointerObfuscatorAddr)
-      tryReadSymbol(TaggedPointerObfuscatorAddr, TaggedPointerObfuscator);
-
+    tryFindAndReadSymbolWithDefault(TaggedPointerObfuscator,
+                                    "objc_debug_taggedpointer_obfuscator",
+                                    0);
+    
 #   undef tryFindSymbol
 #   undef tryReadSymbol
 #   undef tryFindAndReadSymbol
+#   undef tryFindAndReadSymbolWithDefault
 
     return finish(TaggedPointerEncodingKind::Extended);
   }

branches/swift-5.1-old-llvm-branch/include/swift/Serialization/SerializedModuleLoader.h

@@ -68,10 +68,10 @@ class SerializedModuleLoaderBase : public ModuleLoader {
   /// to list the architectures that \e are present.
   ///
   /// \returns true if an error diagnostic was emitted
-  virtual bool maybeDiagnoseArchitectureMismatch(SourceLoc sourceLocation,
-                                                 StringRef moduleName,
-                                                 StringRef archName,
-                                                 StringRef directoryPath) {
+  virtual bool maybeDiagnoseTargetMismatch(SourceLoc sourceLocation,
+                                           StringRef moduleName,
+                                           StringRef archName,
+                                           StringRef directoryPath) {
     return false;
   }
 
@@ -139,10 +139,10 @@ class SerializedModuleLoader : public SerializedModuleLoaderBase {
       std::unique_ptr<llvm::MemoryBuffer> *ModuleBuffer,
       std::unique_ptr<llvm::MemoryBuffer> *ModuleDocBuffer) override;
 
-  bool maybeDiagnoseArchitectureMismatch(SourceLoc sourceLocation,
-                                         StringRef moduleName,
-                                         StringRef archName,
-                                         StringRef directoryPath) override;
+  bool maybeDiagnoseTargetMismatch(SourceLoc sourceLocation,
+                                   StringRef moduleName,
+                                   StringRef archName,
+                                   StringRef directoryPath) override;
 
 public:
   virtual ~SerializedModuleLoader();

branches/swift-5.1-old-llvm-branch/lib/AST/CMakeLists.txt

@@ -95,6 +95,7 @@ add_swift_host_library(swiftAST STATIC
   TypeRefinementContext.cpp
   TypeRepr.cpp
   TypeWalker.cpp
+  UnqualifiedLookup.cpp
   USRGeneration.cpp
 
   INTERFACE_LINK_LIBRARIES