// nontrivial_loadable_type.swift
import _Differentiation

/// A non-trivial, loadable type.
///
/// Used to test differentiation transform coverage.
struct NontrivialLoadable<T> {
  fileprivate class Box {
    fileprivate var value: T
    init(_ value: T) {
      self.value = value
    }
  }
  private var handle: Box

  init(_ value: T) {
    self.handle = Box(value)
  }

  var value: T {
    get { handle.value }
    set { handle.value = newValue }
  }
}

extension NontrivialLoadable: ExpressibleByFloatLiteral
where T: ExpressibleByFloatLiteral {
  init(floatLiteral value: T.FloatLiteralType) {
    self.handle = Box(T(floatLiteral: value))
  }
}

extension NontrivialLoadable: ExpressibleByIntegerLiteral
where T: ExpressibleByIntegerLiteral {
  init(integerLiteral value: T.IntegerLiteralType) {
    self.handle = Box(T(integerLiteral: value))
  }
}

extension NontrivialLoadable: Equatable where T: Equatable {
  static func == (lhs: NontrivialLoadable, rhs: NontrivialLoadable) -> Bool {
    return lhs.value == rhs.value
  }
}

extension NontrivialLoadable: AdditiveArithmetic where T: AdditiveArithmetic {
  static var zero: NontrivialLoadable { return NontrivialLoadable(T.zero) }
  static func + (lhs: NontrivialLoadable, rhs: NontrivialLoadable)
    -> NontrivialLoadable
  {
    return NontrivialLoadable(lhs.value + rhs.value)
  }
  static func - (lhs: NontrivialLoadable, rhs: NontrivialLoadable)
    -> NontrivialLoadable
  {
    return NontrivialLoadable(lhs.value - rhs.value)
  }
}

extension NontrivialLoadable: Differentiable
where T: Differentiable, T == T.TangentVector {
  typealias TangentVector = NontrivialLoadable<T.TangentVector>
}

// property-wrappers.swift
// RUN: %target-swift-frontend -emit-sil -verify %s %S/Inputs/nontrivial_loadable_type.swift

import DifferentiationUnittest

@propertyWrapper
struct Wrapper<Value> {
  private var value: Value
  var wrappedValue: Value { // computed property
    get { value }
    set { value = newValue }
  }

  init(wrappedValue: Value) {
    self.value = wrappedValue
  }
}

struct GenericStruct<T: Differentiable>: Differentiable {
  @Wrapper var nontrivial: NontrivialLoadable<Float> = 20

  @differentiable
  static func nontrivialSetter(_ s: inout GenericStruct, _ x: NontrivialLoadable<Float>) {
    s.nontrivial = x
  }
}