Implementation of ElementaryFunctions / Real protocols.

This commit implements SE-0246, by adding conformance to Real to the Float, CGFloat, Double, and Float80 types, implemented either in terms of the system's C math library, existing standard library functionality, or LLVM intrinsics. It includes basic test coverage for these new functions, and deprecates and obsoletes *some* existing functionality in the Platform overlay. We still need to make a decision about how to handle the remaining "tgmath" functions, because obsoleting them is technically a source-breaking change (if users have unqualified names like "exp(1)", it's fine, but it would break users who have used qualified names like "Darwin.exp(1)".)

Author: stephentyrone

cmake/modules/ClangClCompileRules.cmake

@@ -1,8 +1,10 @@
 
 # clang-cl interprets paths starting with /U as macro undefines, so we need to
 # put a -- before the input file path to force it to be treated as a path.
-string(REPLACE "-c <SOURCE>" "-c -- <SOURCE>" CMAKE_C_COMPILE_OBJECT "${CMAKE_C_COMPILE_OBJECT}")
-string(REPLACE "-c <SOURCE>" "-c -- <SOURCE>" CMAKE_CXX_COMPILE_OBJECT "${CMAKE_CXX_COMPILE_OBJECT}")
+if(NOT MSVC AND "${CMAKE_SIMULATE_ID}" STREQUAL "MSVC")
+  string(REPLACE "-c <SOURCE>" "-c -- <SOURCE>" CMAKE_C_COMPILE_OBJECT "${CMAKE_C_COMPILE_OBJECT}")
+  string(REPLACE "-c <SOURCE>" "-c -- <SOURCE>" CMAKE_CXX_COMPILE_OBJECT "${CMAKE_CXX_COMPILE_OBJECT}")
+endif()
 
 # NOTE(compnerd) incremental linking is known to cause corruption in the
 # protocol conformance tables.  Avoid using incremental links with Visual

cmake/modules/SwiftSharedCMakeConfig.cmake

@@ -258,7 +258,11 @@ endmacro()
 macro(swift_common_cxx_warnings)
   # Make unhandled switch cases be an error in assert builds
   if(DEFINED LLVM_ENABLE_ASSERTIONS)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror=switch")
+    check_cxx_compiler_flag("-Werror=switch" CXX_SUPPORTS_WERROR_SWITCH_FLAG)
+    append_if(CXX_SUPPORTS_WERROR_SWITCH_FLAG "-Werror=switch" CMAKE_CXX_FLAGS)
+
+    check_cxx_compiler_flag("/we4062" CXX_SUPPORTS_WE4062)
+    append_if(CXX_SUPPORTS_WE4062 "/we4062" CMAKE_CXX_FLAGS)
   endif()
 
   check_cxx_compiler_flag("-Werror -Wdocumentation" CXX_SUPPORTS_DOCUMENTATION_FLAG)

stdlib/public/CMakeLists.txt

@@ -61,7 +61,6 @@ if(SWIFT_BUILD_STDLIB)
   add_subdirectory(stubs)
   add_subdirectory(core)
   add_subdirectory(SwiftOnoneSupport)
-  add_subdirectory(Maths)
 endif()
 
 if(SWIFT_BUILD_STDLIB OR SWIFT_BUILD_REMOTE_MIRROR)

stdlib/public/Darwin/CoreGraphics/CGFloat.swift.gyb

@@ -513,18 +513,111 @@ public func %=(lhs: inout CGFloat, rhs: CGFloat) {
 // tgmath
 //===----------------------------------------------------------------------===//
 
+%from SwiftMathFunctions import *
+extension CGFloat: Real {
+% for func in ElementaryFunctions + RealFunctions:
+
+  @_alwaysEmitIntoClient
+  public static func ${func.decl("CGFloat")} {
+    return CGFloat(NativeType.${func.swiftName}(${func.params("", ".native")}))
+  }
+% end
+
+  @_alwaysEmitIntoClient
+  public static func pow(_ x: CGFloat, _ y: CGFloat) -> CGFloat {
+    return CGFloat(NativeType.pow(x.native, y.native))
+  }
+
+  @_alwaysEmitIntoClient
+  public static func pow(_ x: CGFloat, _ n: Int) -> CGFloat {
+    return CGFloat(NativeType.pow(x.native, n))
+  }
+
+  @_alwaysEmitIntoClient
+  public static func root(_ x: CGFloat, _ n: Int) -> CGFloat {
+    return CGFloat(NativeType.root(x.native, n))
+  }
+
+  @_alwaysEmitIntoClient
+  public static func atan2(y: CGFloat, x: CGFloat) -> CGFloat {
+    return CGFloat(NativeType.atan2(y: y.native, x: x.native))
+  }
+
+#if !os(Windows)
+  @_alwaysEmitIntoClient
+  public static func logGamma(_ x: CGFloat) -> CGFloat {
+    return CGFloat(NativeType.logGamma(x.native))
+  }
+#endif
+}
+
+@available(swift, deprecated: 5.1, message: "Use `root(x, 3)`.")
+@_transparent
+public func cbrt(_ x: CGFloat) -> CGFloat {
+  return CGFloat.root(x, 3)
+}
+
+@available(swift, deprecated: 5.1, message: "Use CGFloat.minimum( ) or Swift.min( )")
+@_transparent
+public func fmin(_ x: CGFloat, _ y: CGFloat) -> CGFloat {
+  return .minimum(x, y)
+}
+
+@available(swift, deprecated: 5.1, message: "Use CGFloat.maximum( ) or Swift.max( )")
+@_transparent
+public func fmax(_ x: CGFloat, _ y: CGFloat) -> CGFloat {
+  return .maximum(x, y)
+}
+
+#if !os(Windows)
+@available(swift, deprecated: 5.1, message: "Use (logGamma(x), signGamma(x)).")
+@_transparent
+public func lgamma(_ x: CGFloat) -> (CGFloat, Int) {
+  return (CGFloat.logGamma(x), CGFloat.signGamma(x) == .plus ? 1 : -1)
+}
+#endif
+
+@available(swift, deprecated: 5.1, message: "Use `x.exponent` or `floor(log2(x))`.")
+@_transparent
+public func logb(_ x: CGFloat) -> CGFloat {
+  return CGFloat.log2(x).rounded(.down)
+}
+
+@available(swift, deprecated: 5.1, message: "Swift does not model dynamic rounding modes, use x.rounded(.toNearestOrEven).")
+@_transparent
+public func nearbyint(_ x: CGFloat) -> CGFloat {
+  return x.rounded(.toNearestOrEven)
+}
+
+@available(swift, deprecated: 5.1, message: "Use the .nextUp or .nextDown property.")
+@_transparent
+public func nextafter(_ x: CGFloat, _ y: CGFloat) -> CGFloat {
+  return y > x ? x.nextUp : (y < x ? x.nextDown : y)
+}
+
+@available(swift, deprecated: 5.1, message: "Swift does not model dynamic rounding modes, use x.rounded(.toNearestOrEven).")
+@_transparent
+public func rint(_ x: CGFloat) -> CGFloat {
+  return x.rounded(.toNearestOrEven)
+}
+
+@available(swift, deprecated: 5.1, message: "Use `gamma(x)`.")
+@_transparent
+public func tgamma(_ x: CGFloat) -> CGFloat {
+  return CGFloat.gamma(x)
+}
+
 %{
 UnaryFunctions = [
   'acos', 'asin', 'atan', 'cos', 'sin', 'tan',
   'acosh', 'asinh', 'atanh', 'cosh', 'sinh', 'tanh',
   'exp', 'exp2', 'expm1',
-  'log', 'log10', 'log1p', 'log2', 'logb',
-  'cbrt', 'erf', 'erfc', 'tgamma',
-  'nearbyint', 'rint'
+  'log', 'log10', 'log1p', 'log2',
+  'erf', 'erfc',
 ]
 
 BinaryFunctions = [
-  'atan2', 'hypot', 'pow', 'copysign', 'nextafter', 'fdim', 'fmax', 'fmin'
+  'atan2', 'hypot', 'pow', 'copysign', 'fdim'
 ]
 }%
 
@@ -571,18 +664,12 @@ public func ldexp(_ x: CGFloat, _ n: Int) -> CGFloat {
   return CGFloat(ldexp(x.native, n))
 }
 
-@available(swift, deprecated: 4.2, message: "use the exponent property.")
+@available(swift, deprecated: 4.2, obsoleted: 5.1, message: "use the exponent property.")
 @_transparent
 public func ilogb(_ x: CGFloat) -> Int {
   return Int(x.exponent)
 }
 
-@_transparent
-public func lgamma(_ x: CGFloat) -> (CGFloat, Int) {
-  let (value, sign) = lgamma(x.native)
-  return (CGFloat(value), sign)
-}
-
 @_transparent
 public func remquo(_ x: CGFloat, _ y: CGFloat) -> (CGFloat, Int) {
   let (rem, quo) = remquo(x.native, y.native)

stdlib/public/Maths/CMakeLists.txt

@@ -18,7 +18,6 @@ add_swift_target_library(swiftDarwin ${SWIFT_STDLIB_LIBRARY_BUILD_TYPES} IS_SDK_
     SWIFT_COMPILE_FLAGS -Xfrontend -disable-objc-attr-requires-foundation-module "${SWIFT_RUNTIME_SWIFT_COMPILE_FLAGS}"
     LINK_FLAGS "${SWIFT_RUNTIME_SWIFT_LINK_FLAGS}"
     TARGET_SDKS ALL_APPLE_PLATFORMS
-    SWIFT_MODULE_DEPENDS Maths
 
     # This is overly conservative, but we have so few API notes files that
     # haven't migrated to the Swift repo that it's probably fine in practice.
@@ -34,7 +33,6 @@ add_swift_target_library(swiftGlibc ${SWIFT_STDLIB_LIBRARY_BUILD_TYPES} IS_SDK_O
     SWIFT_COMPILE_FLAGS "${SWIFT_RUNTIME_SWIFT_COMPILE_FLAGS}"
     LINK_FLAGS "${SWIFT_RUNTIME_SWIFT_LINK_FLAGS}"
     TARGET_SDKS ANDROID CYGWIN FREEBSD LINUX HAIKU
-    SWIFT_MODULE_DEPENDS Maths
     DEPENDS glibc_modulemap)
 
 add_swift_target_library(swiftMSVCRT ${SWIFT_STDLIB_LIBRARY_BUILD_TYPES} IS_SDK_OVERLAY
@@ -46,8 +44,7 @@ add_swift_target_library(swiftMSVCRT ${SWIFT_STDLIB_LIBRARY_BUILD_TYPES} IS_SDK_
 
     SWIFT_COMPILE_FLAGS "${SWIFT_RUNTIME_SWIFT_COMPILE_FLAGS}"
     LINK_FLAGS "${SWIFT_RUNTIME_SWIFT_LINK_FLAGS}"
-    TARGET_SDKS WINDOWS
-    SWIFT_MODULE_DEPENDS Maths)
+    TARGET_SDKS WINDOWS)
 
 set(glibc_modulemap_target_list)
 foreach(sdk ${SWIFT_SDKS})