   /// to find an absolute value. In addition, because `abs(_:)` always returns
   /// a value of the same type, even in a generic context, using the function
   /// instead of the `magnitude` property is encouraged.
-  @_transparent
-  public var magnitude: Self { return self }
+  public var magnitude: Self {
+    @inline(__always)
+    get { return self }
+  }
 
   /// A Boolean value indicating whether this type is a signed integer type.
   ///
   /// This property is always `false` for unsigned integer types.
-  @_transparent
-  public static var isSigned: Bool { return false }
+  public static var isSigned: Bool {
+    @inline(__always)
+    get { return false }
+  }
 }
 
 extension UnsignedInteger where Self : FixedWidthInteger {

//===----------------------------------------------------------------------===//

extension BinaryInteger {
  // FIXME(ABI): using Int as the return type is wrong.
  /// Returns the distance from this value to the given value, expressed as a
  /// stride.
  ///

  @inlinable
  public var bitWidth: Int { return Self.bitWidth }

  @inlinable
  public func _binaryLogarithm() -> Int {
    _precondition(self > (0 as Self))
    return Self.bitWidth &- (leadingZeroBitCount &+ 1)
