Merge remote-tracking branch 'origin/master' into master-rebranch

Author: swift-ci

CMakeLists.txt

@@ -499,18 +499,6 @@ include(CMakePushCheckState)
 
 print_versions()
 
-include(SwiftSharedCMakeConfig)
-
-# NOTE: We include this before SwiftComponents as it relies on some LLVM CMake
-# functionality.
-# Support building Swift as a standalone project, using LLVM as an
-# external library.
-if(SWIFT_BUILT_STANDALONE)
-  swift_common_standalone_build_config(SWIFT)
-else()
-  swift_common_unified_build_config(SWIFT)
-endif()
-
 include(SwiftComponents)
 include(SwiftHandleGybSources)
 include(SwiftSetIfArchBitness)
@@ -539,6 +527,16 @@ if(NOT CMAKE_CROSSCOMPILING AND CMAKE_SYSTEM_PROCESSOR STREQUAL "i386")
       OUTPUT_STRIP_TRAILING_WHITESPACE)
 endif()
 
+include(SwiftSharedCMakeConfig)
+
+# Support building Swift as a standalone project, using LLVM as an
+# external library.
+if(SWIFT_BUILT_STANDALONE)
+  swift_common_standalone_build_config(SWIFT)
+else()
+  swift_common_unified_build_config(SWIFT)
+endif()
+
 get_filename_component(SWIFT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR} REALPATH)
 set(SWIFT_BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}")
 set(SWIFT_CMAKE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules")
@@ -1053,7 +1051,6 @@ if(SWIFT_NEED_EXPLICIT_LIBDISPATCH)
   else()
     set(SOURCEKIT_RUNTIME_DIR lib)
   endif()
-  add_dependencies(sourcekit-inproc BlocksRuntime dispatch)
   swift_install_in_component(FILES
                                $<TARGET_FILE:dispatch>
                                $<TARGET_FILE:BlocksRuntime>

apinotes/CMakeLists.txt

@@ -26,7 +26,6 @@ add_custom_target("copy_apinotes" ALL
     COMMENT "Copying API notes to ${output_dir}"
     SOURCES "${sources}")
 
-add_dependencies(compiler copy_apinotes)
 swift_install_in_component(DIRECTORY "${output_dir}"
                            DESTINATION "lib/swift/"
                            COMPONENT compiler)

cmake/modules/AddSwift.cmake

@@ -1506,7 +1506,6 @@ function(add_swift_host_library name)
     INSTALL_IN_COMPONENT "dev"
     )
 
-  add_dependencies(dev ${name})
   if(NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
     swift_install_in_component(TARGETS ${name}
       ARCHIVE DESTINATION lib${LLVM_LIBDIR_SUFFIX} COMPONENT dev
@@ -2118,7 +2117,6 @@ function(add_swift_target_library name)
       endif()
 
       if(sdk STREQUAL WINDOWS AND CMAKE_SYSTEM_NAME STREQUAL Windows)
-        add_dependencies(${SWIFTLIB_INSTALL_IN_COMPONENT} ${name}-windows-${SWIFT_PRIMARY_VARIANT_ARCH})
         swift_install_in_component(TARGETS ${name}-windows-${SWIFT_PRIMARY_VARIANT_ARCH}
                                    RUNTIME
                                      DESTINATION "bin"
@@ -2131,9 +2129,6 @@ function(add_swift_target_library name)
                                      COMPONENT "${SWIFTLIB_INSTALL_IN_COMPONENT}"
                                    PERMISSIONS ${file_permissions})
       else()
-        # NOTE: ${UNIVERSAL_LIBRARY_NAME} is the output associated with the target
-        # ${lipo_target}
-        add_dependencies(${SWIFTLIB_INSTALL_IN_COMPONENT} ${lipo_target})
         swift_install_in_component(FILES "${UNIVERSAL_LIBRARY_NAME}"
                                    DESTINATION "lib${LLVM_LIBDIR_SUFFIX}/${resource_dir}/${resource_dir_sdk_subdir}"
                                    COMPONENT "${SWIFTLIB_INSTALL_IN_COMPONENT}"
@@ -2144,7 +2139,6 @@ function(add_swift_target_library name)
         foreach(arch ${SWIFT_SDK_WINDOWS_ARCHITECTURES})
           if(TARGET ${name}-windows-${arch}_IMPLIB)
             get_target_property(import_library ${name}-windows-${arch}_IMPLIB IMPORTED_LOCATION)
-            add_dependencies(${SWIFTLIB_INSTALL_IN_COMPONENT} ${name}-windows-${arch}_IMPLIB)
             swift_install_in_component(FILES ${import_library}
                                        DESTINATION "lib${LLVM_LIBDIR_SUFFIX}/${resource_dir}/${resource_dir_sdk_subdir}/${arch}"
                                        COMPONENT ${SWIFTLIB_INSTALL_IN_COMPONENT}
@@ -2211,7 +2205,6 @@ function(add_swift_target_library name)
                                OUTPUT
                                  "${UNIVERSAL_LIBRARY_NAME}"
                                ${THIN_INPUT_TARGETS_STATIC})
-        add_dependencies(${SWIFTLIB_INSTALL_IN_COMPONENT} ${lipo_target_static})
         swift_install_in_component(FILES "${UNIVERSAL_LIBRARY_NAME}"
                                    DESTINATION "lib${LLVM_LIBDIR_SUFFIX}/${install_subdir}/${resource_dir_sdk_subdir}"
                                    PERMISSIONS
@@ -2413,7 +2406,6 @@ function(add_swift_host_tool executable)
     ARCHITECTURE ${SWIFT_HOST_VARIANT_ARCH}
     ${ASHT_UNPARSED_ARGUMENTS})
 
-  add_dependencies(${ASHT_SWIFT_COMPONENT} ${executable})
   swift_install_in_component(TARGETS ${executable}
                              RUNTIME
                                DESTINATION bin

cmake/modules/SwiftComponents.cmake

@@ -92,23 +92,11 @@ macro(swift_configure_components)
     "A semicolon-separated list of components to install from the set ${_SWIFT_DEFINED_COMPONENTS}")
 
   foreach(component ${_SWIFT_DEFINED_COMPONENTS})
-    add_custom_target(${component})
-    add_llvm_install_targets(install-${component}
-                             DEPENDS ${component}
-                             COMPONENT ${component})
-
     string(TOUPPER "${component}" var_name_piece)
     string(REPLACE "-" "_" var_name_piece "${var_name_piece}")
     set(SWIFT_INSTALL_${var_name_piece} FALSE)
   endforeach()
 
-  # NOTE: never_install is a dummy component to indicate something should not
-  # be installed. We explicitly do not add an install target for this.
-  add_custom_target(never_install)
-
-  add_custom_target(swift-components)
-  add_custom_target(install-swift-components)
-
   foreach(component ${SWIFT_INSTALL_COMPONENTS})
     if(NOT "${component}" IN_LIST _SWIFT_DEFINED_COMPONENTS)
       message(FATAL_ERROR "unknown install component: ${component}")
@@ -118,8 +106,6 @@ macro(swift_configure_components)
     string(REPLACE "-" "_" var_name_piece "${var_name_piece}")
     if(NOT SWIFT_INSTALL_EXCLUDE_${var_name_piece})
       set(SWIFT_INSTALL_${var_name_piece} TRUE)
-      add_dependencies(swift-components ${component})
-      add_dependencies(install-swift-components install-${component})
     endif()
   endforeach()
 endmacro()
@@ -188,6 +174,5 @@ function(swift_install_symlink_component component)
     MESSAGE "LLVMInstallSymlink script must be available.")
 
   install(SCRIPT ${INSTALL_SYMLINK}
-          CODE "install_symlink(${ARG_LINK_NAME} ${ARG_TARGET} ${ARG_DESTINATION})"
-          COMPONENT ${component})
+          CODE "install_symlink(${ARG_LINK_NAME} ${ARG_TARGET} ${ARG_DESTINATION})")
 endfunction()

cmake/modules/SwiftManpage.cmake

@@ -27,7 +27,7 @@ function(manpage)
       "${CMAKE_CURRENT_BINARY_DIR}/${MP_MAN_FILE_BASENAME}.${MP_MAN_SECTION}")
 
   add_custom_command_target(
-      manpage_target
+      unused_var
       COMMAND
         "${POD2MAN}" "--section" "${MP_MAN_SECTION}"
         "--center" "${MP_PAGE_HEADER}" "--release=\"swift ${SWIFT_VERSION}\""
@@ -38,7 +38,6 @@ function(manpage)
       DEPENDS "${MP_SOURCE}"
       ALL)
 
-  add_dependencies(${MP_INSTALL_IN_COMPONENT} ${manpage_target})
   swift_install_in_component(FILES "${output_file_name}"
                              DESTINATION "share/man/man${MP_MAN_SECTION}"
                              COMPONENT "${MP_INSTALL_IN_COMPONENT}")

docs/CMakeLists.txt

@@ -68,7 +68,6 @@ if (DOXYGEN_FOUND)
     add_dependencies(doxygen doxygen-swift)
   endif()
 
-  add_dependencies(dev doxygen-swift)
   swift_install_in_component(DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/doxygen/html"
                              DESTINATION "docs/html"
                              COMPONENT dev)

include/swift/SIL/SILFunction.h

@@ -28,7 +28,6 @@
 #include "llvm/ADT/StringMap.h"
 
 /// The symbol name used for the program entry point function.
-/// FIXME: Hardcoding this is lame.
 #define SWIFT_ENTRY_POINT_FUNCTION "main"
 
 namespace swift {
@@ -57,6 +56,10 @@ enum IsDynamicallyReplaceable_t {
   IsNotDynamic,
   IsDynamic
 };
+enum IsExactSelfClass_t {
+  IsNotExactSelfClass,
+  IsExactSelfClass,
+};
 
 class SILSpecializeAttr final {
   friend SILFunction;
@@ -200,6 +203,10 @@ class SILFunction
 
   /// Whether the implementation can be dynamically replaced.
   unsigned IsDynamicReplaceable : 1;
+    
+  /// If true, this indicates that a class method implementation will always be
+  /// invoked with a `self` argument of the exact base class type.
+  unsigned ExactSelfClass : 1;
 
   /// If != OptimizationMode::NotSet, the optimization mode specified with an
   /// function attribute.
@@ -294,14 +301,16 @@ class SILFunction
               SubclassScope classSubclassScope, Inline_t inlineStrategy,
               EffectsKind E, SILFunction *insertBefore,
               const SILDebugScope *debugScope,
-              IsDynamicallyReplaceable_t isDynamic);
+              IsDynamicallyReplaceable_t isDynamic,
+              IsExactSelfClass_t isExactSelfClass);
 
   static SILFunction *
   create(SILModule &M, SILLinkage linkage, StringRef name,
          CanSILFunctionType loweredType, GenericEnvironment *genericEnv,
          Optional<SILLocation> loc, IsBare_t isBareSILFunction,
          IsTransparent_t isTrans, IsSerialized_t isSerialized,
          ProfileCounter entryCount, IsDynamicallyReplaceable_t isDynamic,
+         IsExactSelfClass_t isExactSelfClass,
          IsThunk_t isThunk = IsNotThunk,
          SubclassScope classSubclassScope = SubclassScope::NotApplicable,
          Inline_t inlineStrategy = InlineDefault,
@@ -587,14 +596,21 @@ class SILFunction
     IsWeakLinked = value;
   }
 
-  /// Returs whether this function implementation can be dynamically replaced.
+  /// Returns whether this function implementation can be dynamically replaced.
   IsDynamicallyReplaceable_t isDynamicallyReplaceable() const {
     return IsDynamicallyReplaceable_t(IsDynamicReplaceable);
   }
   void setIsDynamic(IsDynamicallyReplaceable_t value = IsDynamic) {
     IsDynamicReplaceable = value;
     assert(!Transparent || !IsDynamicReplaceable);
   }
+    
+  IsExactSelfClass_t isExactSelfClass() const {
+    return IsExactSelfClass_t(ExactSelfClass);
+  }
+  void setIsExactSelfClass(IsExactSelfClass_t t) {
+    ExactSelfClass = t;
+  }
 
   /// Get the DeclContext of this function. (Debug info only).
   DeclContext *getDeclContext() const {

include/swift/Serialization/ModuleFormat.h

@@ -52,7 +52,7 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0;
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t SWIFTMODULE_VERSION_MINOR = 506; // transparent accessor bit
+const uint16_t SWIFTMODULE_VERSION_MINOR = 507; // exact_self_class sil attr
 
 using DeclIDField = BCFixed<31>;
 

lib/Driver/CMakeLists.txt

@@ -62,5 +62,4 @@ if(SWIFT_BUILD_STATIC_STDLIB)
     endif()
   endforeach()
   add_custom_target(swift_static_lnk_args ALL DEPENDS ${static_stdlib_lnk_file_list})
-  add_dependencies(stdlib swift_static_lnk_args)
 endif()

lib/IRGen/GenHeap.cpp

@@ -1718,7 +1718,7 @@ llvm::Value *IRGenFunction::getLocalSelfMetadata() {
     break;
   case ObjectReference:
     LocalSelf = emitDynamicTypeOfOpaqueHeapObject(*this, LocalSelf,
-                                             MetatypeRepresentation::Thick);
+                                                 MetatypeRepresentation::Thick);
     SelfKind = SwiftMetatype;
     break;
   }

lib/IRGen/GenType.cpp

@@ -2255,10 +2255,14 @@ unsigned IRGenModule::getBuiltinIntegerWidth(BuiltinIntegerWidth w) {
   llvm_unreachable("impossible width value");
 }
 
-void IRGenFunction::setLocalSelfMetadata(llvm::Value *value,
+void IRGenFunction::setLocalSelfMetadata(CanType exactSelfClass,
+                                         llvm::Value *value,
                                          IRGenFunction::LocalSelfKind kind) {
   assert(!LocalSelf && "already have local self metadata");
   LocalSelf = value;
+  assert((!exactSelfClass || exactSelfClass->getClassOrBoundGenericClass())
+         && "self type not a class?");
+  ExactSelfType = exactSelfClass;
   SelfKind = kind;
 }
 

lib/IRGen/IRGenFunction.h

@@ -644,7 +644,8 @@ class IRGenFunction {
   };
 
   llvm::Value *getLocalSelfMetadata();
-  void setLocalSelfMetadata(llvm::Value *value, LocalSelfKind kind);
+  void setLocalSelfMetadata(CanType selfBaseTy,
+                            llvm::Value *value, LocalSelfKind kind);
 
 private:
   LocalTypeDataCache &getOrCreateLocalTypeData();
@@ -660,7 +661,8 @@ class IRGenFunction {
 
   /// The value that satisfies metadata lookups for dynamic Self.
   llvm::Value *LocalSelf = nullptr;
-  
+  /// If set, the dynamic Self type is assumed to be equivalent to this exact class.
+  CanType ExactSelfType;
   LocalSelfKind SelfKind;
 };
 

lib/IRGen/IRGenSIL.cpp

@@ -1584,23 +1584,38 @@ static void emitLocalSelfMetadata(IRGenSILFunction &IGF) {
     return;
 
   const SILArgument *selfArg = IGF.CurSILFn->getSelfMetadataArgument();
+  auto selfTy = selfArg->getType().getASTType();
   CanMetatypeType metaTy =
-    dyn_cast<MetatypeType>(selfArg->getType().getASTType());
+    dyn_cast<MetatypeType>(selfTy);
   IRGenFunction::LocalSelfKind selfKind;
   if (!metaTy)
     selfKind = IRGenFunction::ObjectReference;
-  else switch (metaTy->getRepresentation()) {
-  case MetatypeRepresentation::Thin:
-    llvm_unreachable("class metatypes are never thin");
-  case MetatypeRepresentation::Thick:
-    selfKind = IRGenFunction::SwiftMetatype;
-    break;
-  case MetatypeRepresentation::ObjC:
-    selfKind = IRGenFunction::ObjCMetatype;
-    break;
+  else {
+    selfTy = metaTy.getInstanceType();
+    switch (metaTy->getRepresentation()) {
+    case MetatypeRepresentation::Thin:
+      llvm_unreachable("class metatypes are never thin");
+    case MetatypeRepresentation::Thick:
+      selfKind = IRGenFunction::SwiftMetatype;
+      break;
+    case MetatypeRepresentation::ObjC:
+      selfKind = IRGenFunction::ObjCMetatype;
+      break;
+    }
   }
   llvm::Value *value = IGF.getLoweredExplosion(selfArg).claimNext();
-  IGF.setLocalSelfMetadata(value, selfKind);
+  if (auto dynSelfTy = dyn_cast<DynamicSelfType>(selfTy))
+    selfTy = dynSelfTy.getSelfType();
+
+  // Specify the exact Self type if we know it, either because the class
+  // is final, or because the function we're emitting is a method with the
+  // [exact_self_class] attribute set on it during the SIL pipeline.
+  CanType exactSelfTy;
+  if (selfTy->getClassOrBoundGenericClass()->isFinal()
+      || IGF.CurSILFn->isExactSelfClass())
+    exactSelfTy = selfTy;
+
+  IGF.setLocalSelfMetadata(exactSelfTy, value, selfKind);
 }
 
 /// Emit the definition for the given SIL constant.

lib/IRGen/MetadataRequest.cpp

@@ -2378,6 +2378,12 @@ IRGenFunction::emitTypeMetadataRef(CanType type,
   // Look through any opaque types we're allowed to.
   type = IGM.substOpaqueTypesWithUnderlyingTypes(type);
 
+  // If we're asking for the metadata of the type that dynamic Self is known
+  // to be equal to, we can just use the self metadata.
+  if (ExactSelfType == type) {
+    return MetadataResponse::forComplete(getLocalSelfMetadata());
+  }
+  
   if (type->hasArchetype() ||
       isTypeMetadataAccessTrivial(IGM, type)) {
     // FIXME: propagate metadata request!