Merge remote-tracking branch 'apple/master'

Author: rockbruno

CMakeLists.txt

@@ -354,7 +354,7 @@ endfunction()
 # Print out path and version of any installed commands.
 # We migth be using the wrong version of a command, so record them all.
 function(print_versions)
-  find_version("cmake" "--version" TRUE)
+  find_version("${CMAKE_COMMAND}" "--version" TRUE)
 
   message(STATUS "Finding version for: ${CMAKE_COMMAND}")
   message(STATUS "Found version: ${CMAKE_VERSION}")
@@ -726,7 +726,7 @@ elseif("${SWIFT_HOST_VARIANT_SDK}" MATCHES "(OSX|IOS*|TVOS*|WATCHOS*)")
     COMMAND "xcodebuild" "-version"
     OUTPUT_VARIABLE xcode_version
     OUTPUT_STRIP_TRAILING_WHITESPACE)
-  string(REPLACE "\n" ", " xcode_version ${xcode_version})
+  string(REPLACE "\n" ", " xcode_version "${xcode_version}")
   message(STATUS "${xcode_version}")
   message(STATUS "")
 
@@ -866,11 +866,13 @@ endfunction()
 # package lookup.  Otherwise, rely on the paths specified by the user.  These
 # need to be defined when cross-compiling.
 if(NOT CMAKE_SYSTEM_NAME STREQUAL "Darwin")
-  swift_icu_variables_set("${SWIFT_HOST_VARIANT_SDK_default}"
-                          "${SWIFT_HOST_VARIANT_ARCH_default}"
-                          ICU_CONFIGURED)
-  if("${SWIFT_PATH_TO_LIBICU_BUILD}" STREQUAL "" AND NOT ${ICU_CONFIGURED})
-    find_package(ICU REQUIRED COMPONENTS uc i18n)
+  if(SWIFT_BUILD_STDLIB OR SWIFT_BUILD_SDK_OVERLAY)
+    swift_icu_variables_set("${SWIFT_HOST_VARIANT_SDK_default}"
+                            "${SWIFT_HOST_VARIANT_ARCH_default}"
+                            ICU_CONFIGURED)
+    if("${SWIFT_PATH_TO_LIBICU_BUILD}" STREQUAL "" AND NOT ${ICU_CONFIGURED})
+      find_package(ICU REQUIRED COMPONENTS uc i18n)
+    endif()
   endif()
 endif()
 

README.md

@@ -8,7 +8,6 @@
 | **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 16.10** | x86_64 | [![Build Status](https://ci.swift.org/job/oss-swift-incremental-RA-linux-ubuntu-16_10/lastCompletedBuild/badge/icon)](https://ci.swift.org/job/oss-swift-incremental-RA-linux-ubuntu-16_10)|[![Build Status](https://ci.swift.org/job/oss-swift-package-linux-ubuntu-16_10/lastCompletedBuild/badge/icon)](https://ci.swift.org/job/oss-swift-package-linux-ubuntu-16_10)|
 | **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)|
 
 **Swift Community-Hosted CI Platforms**

benchmark/single-source/BinaryFloatingPointConversionFromBinaryInteger.swift

@@ -110,6 +110,10 @@ extension MockBinaryInteger : BinaryInteger {
   var trailingZeroBitCount: Int {
     return _value.trailingZeroBitCount
   }
+  
+  func isMultiple(of other: MockBinaryInteger<T>) -> Bool {
+    return _value.isMultiple(of: other._value)
+  }
 
   static func + (
     lhs: MockBinaryInteger<T>, rhs: MockBinaryInteger<T>

cmake/modules/AddSwift.cmake

@@ -246,7 +246,9 @@ function(_add_variant_c_compile_flags)
     list(APPEND result "-DLLVM_ON_WIN32")
     list(APPEND result "-D_CRT_SECURE_NO_WARNINGS")
     list(APPEND result "-D_CRT_NONSTDC_NO_WARNINGS")
-    list(APPEND result "-D_CRT_USE_BUILTIN_OFFSETOF")
+    if(NOT "${CMAKE_C_COMPILER_ID}" STREQUAL "MSVC")
+      list(APPEND result "-D_CRT_USE_BUILTIN_OFFSETOF")
+    endif()
     # TODO(compnerd) permit building for different families
     list(APPEND result "-D_CRT_USE_WINAPI_FAMILY_DESKTOP_APP")
     if("${CFLAGS_ARCH}" MATCHES arm)
@@ -800,11 +802,13 @@ function(_add_swift_library_single target name)
 
   if("${SWIFTLIB_SINGLE_SDK}" STREQUAL "WINDOWS")
     swift_windows_include_for_arch(${SWIFTLIB_SINGLE_ARCHITECTURE} SWIFTLIB_INCLUDE)
-    swift_windows_generate_sdk_vfs_overlay(SWIFTLIB_SINGLE_VFS_OVERLAY_FLAGS)
-    foreach(flag ${SWIFTLIB_SINGLE_VFS_OVERLAY_FLAGS})
-      list(APPEND SWIFTLIB_SINGLE_SWIFT_COMPILE_FLAGS -Xcc;${flag})
-      list(APPEND SWIFTLIB_SINGLE_C_COMPILE_FLAGS ${flag})
-    endforeach()
+    if(NOT "${CMAKE_C_COMPILER_ID}" STREQUAL "MSVC")
+      swift_windows_generate_sdk_vfs_overlay(SWIFTLIB_SINGLE_VFS_OVERLAY_FLAGS)
+      foreach(flag ${SWIFTLIB_SINGLE_VFS_OVERLAY_FLAGS})
+        list(APPEND SWIFTLIB_SINGLE_SWIFT_COMPILE_FLAGS -Xcc;${flag})
+        list(APPEND SWIFTLIB_SINGLE_C_COMPILE_FLAGS ${flag})
+      endforeach()
+    endif()
     foreach(directory ${SWIFTLIB_INCLUDE})
       list(APPEND SWIFTLIB_SINGLE_SWIFT_COMPILE_FLAGS -Xfrontend;-I${directory})
     endforeach()
@@ -1572,6 +1576,13 @@ function(add_swift_library name)
   endif()
 
   if(SWIFTLIB_TARGET_LIBRARY)
+    # In the standard library and overlays, warn about implicit overrides
+    # as a reminder to consider when inherited protocols need different
+    # behavior for their requirements.
+    if (SWIFTLIB_IS_STDLIB)
+      list(APPEND SWIFTLIB_SWIFT_COMPILE_FLAGS "-warn-implicit-overrides")
+    endif()
+
     if(NOT SWIFT_BUILD_RUNTIME_WITH_HOST_COMPILER AND NOT BUILD_STANDALONE)
       list(APPEND SWIFTLIB_DEPENDS clang)
     endif()

cmake/modules/SwiftSharedCMakeConfig.cmake

@@ -24,7 +24,7 @@ macro(swift_common_standalone_build_config_llvm product is_cross_compiling)
   # Then we import LLVMConfig. This is going to override whatever cached value
   # we have for LLVM_ENABLE_ASSERTIONS.
   find_package(LLVM REQUIRED CONFIG
-    HINTS "${PATH_TO_LLVM_BUILD}" NO_DEFAULT_PATH)
+    HINTS "${PATH_TO_LLVM_BUILD}" NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
 
   # If we did not have a cached value for LLVM_ENABLE_ASSERTIONS, set
   # LLVM_ENABLE_ASSERTIONS_saved to be the ENABLE_ASSERTIONS value from LLVM so
@@ -69,7 +69,7 @@ macro(swift_common_standalone_build_config_llvm product is_cross_compiling)
   endif()
 
   find_program(LLVM_TABLEGEN_EXE "llvm-tblgen" "${${product}_NATIVE_LLVM_TOOLS_PATH}"
-    NO_DEFAULT_PATH)
+    NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
   if ("${LLVM_TABLEGEN_EXE}" STREQUAL "LLVM_TABLEGEN_EXE-NOTFOUND")
     message(FATAL_ERROR "Failed to find tablegen in ${${product}_NATIVE_LLVM_TOOLS_PATH}")
   endif()
@@ -149,7 +149,7 @@ macro(swift_common_standalone_build_config_clang product is_cross_compiling)
 
   # Then include Clang.
   find_package(Clang REQUIRED CONFIG
-    HINTS "${PATH_TO_CLANG_BUILD}" NO_DEFAULT_PATH)
+    HINTS "${PATH_TO_CLANG_BUILD}" NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
 
   if(NOT EXISTS "${PATH_TO_CLANG_SOURCE}/include/clang/AST/Decl.h")
     message(FATAL_ERROR "Please set ${product}_PATH_TO_CLANG_SOURCE to the root directory of Clang's source code.")

docs/ABI/Mangling.rst

@@ -59,6 +59,7 @@ Globals
   global ::= nominal-type 'Ml'           // in-place type initialization cache
   global ::= nominal-type 'Mm'           // class metaclass
   global ::= nominal-type 'Mn'           // nominal type descriptor
+  global ::= nominal-type 'Mu'           // class method lookup function
   global ::= module 'MXM'                // module descriptor
   global ::= context 'MXE'               // extension descriptor
   global ::= context 'MXX'               // anonymous context descriptor

docs/Lexicon.rst

@@ -26,7 +26,7 @@ source code, tests, and commit messages. See also the `LLVM lexicon`_.
       struct Foo<T> {
         var value: T
         // Foo.value has abstraction pattern <T> T
-    
+      }
       struct Bar<T, U> {
         var value: (T) -> U
         // Bar.value has abstraction pattern <T, U> (T) -> U

docs/RequestEvaluator.md

@@ -61,7 +61,6 @@ The request-evaluator is relatively new to the Swift compiler, having been intro
 * Add API to the evaluator to add a specific (request, result) pair to the cache, and make it "stick" even if the cache is cleared. This API should be usable from places in the compiler that inject specific known state, such as when the Clang importer synthesizes ASTs.
 * Explore how best to cache data structures in the evaluator. For example, caching `std::vector<T>` or `std::string` implies that we'll make copies of the underlying data structure each time we access the data. Could we automatically intern the data into an allocation arena owned by the evaluator, and vend `ArrayRef<T>` and `StringRef` to clients instead?
 * Sometimes the compiler crashes or otherwise fails due to a cycle detected by the evaluator but (currently) not diagnosed. Add some logic to record cycles encountered during compilation, and if the compiler crashes (or otherwise fails), dump the cycles at the end of execution to help with debugging.
-* Automatically create appropriate [`FrontendStatsTracer`](https://github.com/apple/swift/blob/master/include/swift/Basic/Statistic.h) instances when evaluating requests that embed AST references to anything the stats-tracing logic can handle (`Decl*`, `ProtocolConformance*`, etc.). Try to do this automatically for `SimpleRequest` so specific requests don't need to opt in for it to work. 
 * Cycle diagnostics are far too complicated and produce very poor results. Consider replacing the current `diagnoseCycle`/`noteCycleStep` scheme with a single method that produces summary information (e.g., a short summary string + source location information) and provides richer diagnostics from that string.
 * The `isCached()` check to determine whether a specific instance of a request is worth caching may be at the wrong level, because one generally has to duplicate effort (or worse, code!) to make the decision in `isCached()`. Consider whether the `evaluator()` function could return something special to say "produce this value without caching" vs. the normal "produce this value with caching".
 * Try to eliminate more boilerplate from subclasses of [`SimpleRequest`](https://github.com/apple/swift/blob/master/include/swift/AST/SimpleRequest.h). We are going to have a *lot* of requests.

include/swift/ABI/Metadata.h

@@ -770,17 +770,25 @@ struct TargetHeapMetadata : TargetMetadata<Runtime> {
 };
 using HeapMetadata = TargetHeapMetadata<InProcess>;
 
+/// An opaque descriptor describing a class or protocol method. References to
+/// these descriptors appear in the method override table of a class context
+/// descriptor, or a resilient witness table pattern, respectively.
+///
+/// Clients should not assume anything about the contents of this descriptor
+/// other than it having 4 byte alignment.
 template <typename Runtime>
 struct TargetMethodDescriptor {
-  /// The method implementation.
-  TargetRelativeDirectPointer<Runtime, void> Impl;
-
   /// Flags describing the method.
   MethodDescriptorFlags Flags;
 
+  /// The method implementation.
+  TargetRelativeDirectPointer<Runtime, void> Impl;
+
   // TODO: add method types or anything else needed for reflection.
 };
 
+using MethodDescriptor = TargetMethodDescriptor<InProcess>;
+
 /// Header for a class vtable descriptor. This is a variable-sized
 /// structure that describes how to find and parse a vtable
 /// within the type metadata for a class.
@@ -804,14 +812,41 @@ struct TargetVTableDescriptorHeader {
   /// entries occupy in instantiated class metadata.
   uint32_t VTableSize;
 
-  uint32_t getVTableOffset(const TargetClassMetadata<Runtime> *metadata) const {
-    const auto *description = metadata->getDescription();
-    if (description->hasResilientSuperclass())
-      return metadata->Superclass->getSizeInWords() + VTableOffset;
+  uint32_t getVTableOffset(const TargetClassDescriptor<Runtime> *description) const {
+    if (description->hasResilientSuperclass()) {
+      auto bounds = description->getMetadataBounds();
+      return (bounds.ImmediateMembersOffset / sizeof(StoredPointer)
+              + VTableOffset);
+    }
+
     return VTableOffset;
   }
 };
 
+/// An entry in the method override table, referencing a method from one of our
+/// ancestor classes, together with an implementation.
+template <typename Runtime>
+struct TargetMethodOverrideDescriptor {
+  /// The class containing the base method.
+  TargetRelativeIndirectablePointer<Runtime, TargetClassDescriptor<Runtime>> Class;
+
+  /// The base method.
+  TargetRelativeIndirectablePointer<Runtime, TargetMethodDescriptor<Runtime>> Method;
+
+  /// The implementation of the override.
+  TargetRelativeDirectPointer<Runtime, void, /*Nullable=*/true> Impl;
+};
+
+/// Header for a class vtable override descriptor. This is a variable-sized
+/// structure that provides implementations for overrides of methods defined
+/// in superclasses.
+template <typename Runtime>
+struct TargetOverrideTableHeader {
+  /// The number of MethodOverrideDescriptor records following the vtable
+  /// override header in the class's nominal type descriptor.
+  uint32_t NumEntries;
+};
+
 /// The bounds of a class metadata object.
 ///
 /// This type is a currency type and is not part of the ABI.
@@ -1107,7 +1142,7 @@ struct TargetClassMetadata : public TargetAnyClassMetadata<Runtime> {
   /// Get a pointer to the field offset vector, if present, or null.
   const StoredPointer *getFieldOffsets() const {
     assert(isTypeMetadata());
-    auto offset = getDescription()->getFieldOffsetVectorOffset(this);
+    auto offset = getDescription()->getFieldOffsetVectorOffset();
     if (offset == 0)
       return nullptr;
     auto asWords = reinterpret_cast<const void * const*>(this);
@@ -3580,15 +3615,19 @@ class TargetClassDescriptor final
                               TargetForeignMetadataInitialization<Runtime>,
                               TargetSingletonMetadataInitialization<Runtime>,
                               TargetVTableDescriptorHeader<Runtime>,
-                              TargetMethodDescriptor<Runtime>> {
+                              TargetMethodDescriptor<Runtime>,
+                              TargetOverrideTableHeader<Runtime>,
+                              TargetMethodOverrideDescriptor<Runtime>> {
 private:
   using TrailingGenericContextObjects =
     TrailingGenericContextObjects<TargetClassDescriptor<Runtime>,
                                   TargetTypeGenericContextDescriptorHeader,
                                   TargetForeignMetadataInitialization<Runtime>,
                                   TargetSingletonMetadataInitialization<Runtime>,
                                   TargetVTableDescriptorHeader<Runtime>,
-                                  TargetMethodDescriptor<Runtime>>;
+                                  TargetMethodDescriptor<Runtime>,
+                                  TargetOverrideTableHeader<Runtime>,
+                                  TargetMethodOverrideDescriptor<Runtime>>;
 
   using TrailingObjects =
     typename TrailingGenericContextObjects::TrailingObjects;
@@ -3597,6 +3636,8 @@ class TargetClassDescriptor final
 public:
   using MethodDescriptor = TargetMethodDescriptor<Runtime>;
   using VTableDescriptorHeader = TargetVTableDescriptorHeader<Runtime>;
+  using OverrideTableHeader = TargetOverrideTableHeader<Runtime>;
+  using MethodOverrideDescriptor = TargetMethodOverrideDescriptor<Runtime>;
   using ForeignMetadataInitialization =
     TargetForeignMetadataInitialization<Runtime>;
   using SingletonMetadataInitialization =
@@ -3707,6 +3748,17 @@ class TargetClassDescriptor final
     return getVTableDescriptor()->VTableSize;
   }
 
+  size_t numTrailingObjects(OverloadToken<OverrideTableHeader>) const {
+    return hasOverrideTable() ? 1 : 0;
+  }
+
+  size_t numTrailingObjects(OverloadToken<MethodOverrideDescriptor>) const {
+    if (!hasOverrideTable())
+      return 0;
+
+    return getOverrideTable()->NumEntries;
+  }
+
 public:
   const ForeignMetadataInitialization &getForeignMetadataInitialization() const{
     assert(this->hasForeignMetadataInitialization());
@@ -3722,11 +3774,12 @@ class TargetClassDescriptor final
   /// its stored properties.
   bool hasFieldOffsetVector() const { return FieldOffsetVectorOffset != 0; }
 
-  unsigned getFieldOffsetVectorOffset(const ClassMetadata *metadata) const {
-    const auto *description = metadata->getDescription();
-
-    if (description->hasResilientSuperclass())
-      return metadata->Superclass->getSizeInWords() + FieldOffsetVectorOffset;
+  unsigned getFieldOffsetVectorOffset() const {
+    if (hasResilientSuperclass()) {
+      auto bounds = getMetadataBounds();
+      return (bounds.ImmediateMembersOffset / sizeof(StoredPointer)
+              + FieldOffsetVectorOffset);
+    }
 
     return FieldOffsetVectorOffset;
   }
@@ -3735,6 +3788,10 @@ class TargetClassDescriptor final
     return this->getTypeContextDescriptorFlags().class_hasVTable();
   }
 
+  bool hasOverrideTable() const {
+    return this->getTypeContextDescriptorFlags().class_hasOverrideTable();
+  }
+
   bool hasResilientSuperclass() const {
     return this->getTypeContextDescriptorFlags().class_hasResilientSuperclass();
   }
@@ -3744,14 +3801,27 @@ class TargetClassDescriptor final
       return nullptr;
     return this->template getTrailingObjects<VTableDescriptorHeader>();
   }
-  
+
   llvm::ArrayRef<MethodDescriptor> getMethodDescriptors() const {
     if (!hasVTable())
       return {};
     return {this->template getTrailingObjects<MethodDescriptor>(),
             numTrailingObjects(OverloadToken<MethodDescriptor>{})};
   }
 
+  const OverrideTableHeader *getOverrideTable() const {
+    if (!hasOverrideTable())
+      return nullptr;
+    return this->template getTrailingObjects<OverrideTableHeader>();
+  }
+
+  llvm::ArrayRef<MethodOverrideDescriptor> getMethodOverrideDescriptors() const {
+    if (!hasOverrideTable())
+      return {};
+    return {this->template getTrailingObjects<MethodOverrideDescriptor>(),
+            numTrailingObjects(OverloadToken<MethodOverrideDescriptor>{})};
+  }
+
   /// Return the bounds of this class's metadata.
   TargetClassMetadataBounds<Runtime> getMetadataBounds() const {
     if (!hasResilientSuperclass())