SnapKit源码导读

Sources/
├── ConstraintView.swift                       # typealias UIView/NSView → ConstraintView
├── ConstraintLayoutGuide.swift                # typealias UILayoutGuide/NSLayoutGuide
├── ConstraintLayoutSupport.swift              # typealias UILayoutSupport
├── Typealiases.swift                          # LayoutRelation / LayoutAttribute / LayoutPriority
├── ConstraintConfig.swift                     # interfaceLayoutDirection 全局开关
│
├── ConstraintView+Extensions.swift            # view.snp 入口（含 snp_ 老别名）
├── ConstraintLayoutGuide+Extensions.swift     # guide.snp 入口
├── UILayoutSupport+Extensions.swift           # topLayoutGuide.snp（iOS 11 前）
├── ConstraintViewDSL.swift                    # makeConstraints / remake / update / remove
├── ConstraintLayoutGuideDSL.swift             # LayoutGuide 版 DSL
├── ConstraintLayoutSupportDSL.swift           # LayoutSupport 版 DSL
├── ConstraintDSL.swift                        # DSL 协议 + 属性定义（left/top/edges/...）
│
├── ConstraintMaker.swift                      # 属性起点（make.left / make.edges / ...）
├── ConstraintMakerExtendable.swift            # 可追加属性（.top.right）
├── ConstraintMakerRelatable.swift             # equalTo / lessThanOrEqual / greaterThanOrEqual
├── ConstraintMakerRelatable+Extensions.swift  # equalToSuperview 闭包版
├── ConstraintMakerEditable.swift              # multipliedBy / dividedBy / offset / inset
├── ConstraintMakerPrioritizable.swift         # priority(...)
├── ConstraintMakerFinalizable.swift           # labeled(...) + .constraint
│
├── ConstraintAttributes.swift                 # OptionSet 属性位图
├── ConstraintRelation.swift                   # equal / lessThanOrEqual / greaterThanOrEqual
├── ConstraintPriority.swift                   # required/high/medium/low
├── ConstraintDescription.swift                # Builder 中间态 + lazy Constraint
├── ConstraintItem.swift                       # (target, attributes) 二元组（弱引用）
├── LayoutConstraintItem.swift                 # UIView/UILayoutGuide 统一协议
├── ConstraintInsets.swift                     # UIEdgeInsets typealias
├── ConstraintDirectionalInsets.swift          # NSDirectionalEdgeInsets（iOS 11+）
│
├── ConstraintRelatableTarget.swift            # 可作为 equalTo 参数的类型标记
├── ConstraintConstantTarget.swift             # constant 目标 + 属性→CGFloat 的派发
├── ConstraintOffsetTarget.swift               # offset 目标
├── ConstraintInsetTarget.swift                # inset 目标（含标量→insets 转换）
├── ConstraintDirectionalInsetTarget.swift     # 方向 insets 目标
├── ConstraintMultiplierTarget.swift           # multiplier 目标
├── ConstraintPriorityTarget.swift             # priority 目标（Int/Float/UILayoutPriority）
│
├── Constraint.swift                           # 真正的约束对象 + activate/deactivate
├── LayoutConstraint.swift                     # NSLayoutConstraint 子类，回指 Constraint
├── Debugging.swift                            # LayoutConstraint.description 美化
└── PrivacyInfo.xcprivacy                      # 隐私清单

public extension ConstraintView {
    // ... 省略一大堆 @available(*, deprecated) 的老 snp_xxx 别名 ...
    var snp: ConstraintViewDSL {
        return ConstraintViewDSL(view: self)
    }
}

#if canImport(UIKit)
    public typealias ConstraintView = UIView
#else
    public typealias ConstraintView = NSView
#endif

public struct ConstraintViewDSL: ConstraintAttributesDSL {
    
    @discardableResult
    public func prepareConstraints(_ closure: (_ make: ConstraintMaker) -> Void) -> [Constraint] {
        return ConstraintMaker.prepareConstraints(item: self.view, closure: closure)
    }
    
    public func makeConstraints(_ closure: (_ make: ConstraintMaker) -> Void) {
        ConstraintMaker.makeConstraints(item: self.view, closure: closure)
    }
    
    public func remakeConstraints(_ closure: (_ make: ConstraintMaker) -> Void) {
        ConstraintMaker.remakeConstraints(item: self.view, closure: closure)
    }
    
    public func updateConstraints(_ closure: (_ make: ConstraintMaker) -> Void) {
        ConstraintMaker.updateConstraints(item: self.view, closure: closure)
    }
    
    public func removeConstraints() {
        ConstraintMaker.removeConstraints(item: self.view)
    }
    // ...
}

public var contentHuggingHorizontalPriority: Float {
    get { return self.view.contentHuggingPriority(for: .horizontal).rawValue }
    nonmutating set {
        self.view.setContentHuggingPriority(LayoutPriority(rawValue: newValue), for: .horizontal)
    }
}
// ... contentHuggingVerticalPriority / contentCompressionResistanceHorizontalPriority ...

public protocol ConstraintDSL {
    var target: AnyObject? { get }
    func setLabel(_ value: String?)
    func label() -> String?
}
extension ConstraintDSL {
    public func setLabel(_ value: String?) {
        objc_setAssociatedObject(self.target as Any, &labelKey, value, .OBJC_ASSOCIATION_COPY_NONATOMIC)
    }
    public func label() -> String? {
        return objc_getAssociatedObject(self.target as Any, &labelKey) as? String
    }
}
private var labelKey: UInt8 = 0

public protocol ConstraintBasicAttributesDSL : ConstraintDSL {}
extension ConstraintBasicAttributesDSL {
    public var left: ConstraintItem {
        return ConstraintItem(target: self.target, attributes: ConstraintAttributes.left)
    }
    // ... top / right / bottom / leading / trailing / width / height / centerX / centerY / edges / size / center ...
}

public protocol ConstraintAttributesDSL : ConstraintBasicAttributesDSL {}
extension ConstraintAttributesDSL {
    // baseline / firstBaseline / lastBaseline
    // leftMargin / rightMargin / topMargin / bottomMargin
    // margins / directionalMargins / centerWithinMargins ...
}

public let item: LayoutConstraintItem
private var descriptions = [ConstraintDescription]()

internal init(item: LayoutConstraintItem) {
    self.item = item
    self.item.prepare()            // ← 关键：设置 translatesAutoresizingMaskIntoConstraints = false
}

internal func makeExtendableWithAttributes(_ attributes: ConstraintAttributes) -> ConstraintMakerExtendable {
    let description = ConstraintDescription(item: self.item, attributes: attributes)
    self.descriptions.append(description)
    return ConstraintMakerExtendable(description)
}

internal static func makeConstraints(item: LayoutConstraintItem, closure: (_ make: ConstraintMaker) -> Void) {
    let constraints = prepareConstraints(item: item, closure: closure)
    for constraint in constraints {
        constraint.activateIfNeeded(updatingExisting: false)
    }
}

extension LayoutConstraintItem {
    internal func prepare() {
        if let view = self as? ConstraintView {
            view.translatesAutoresizingMaskIntoConstraints = false
        }
    }
    // ...
}

public var left: ConstraintMakerExtendable {
    return self.makeExtendableWithAttributes(.left)
}
public var edges: ConstraintMakerExtendable {
    return self.makeExtendableWithAttributes(.edges)
}
public var directionalEdges: ConstraintMakerExtendable {
    return self.makeExtendableWithAttributes(.directionalEdges)
}
public var horizontalEdges: ConstraintMakerExtendable {       // v5.6 新增
    return self.makeExtendableWithAttributes(.horizontalEdges)
}
public var verticalEdges: ConstraintMakerExtendable {         // v5.6 新增
    return self.makeExtendableWithAttributes(.verticalEdges)
}
// ... 一共 20+ 个属性

internal static func prepareConstraints(item: LayoutConstraintItem, closure: (_ make: ConstraintMaker) -> Void) -> [Constraint] {
    let maker = ConstraintMaker(item: item)
    closure(maker)
    var constraints: [Constraint] = []
    for description in maker.descriptions {
        guard let constraint = description.constraint else {
            continue
        }
        constraints.append(constraint)
    }
    return constraints
}

internal static func makeConstraints(item: LayoutConstraintItem, closure: (_ make: ConstraintMaker) -> Void) {
    let constraints = prepareConstraints(item: item, closure: closure)
    for constraint in constraints {
        constraint.activateIfNeeded(updatingExisting: false)
    }
}

ConstraintMakerFinalizable
    └── ConstraintMakerPrioritizable
        └── ConstraintMakerEditable
            └── ConstraintMakerRelatable
                └── ConstraintMakerExtendable  (注意：这条线反过来)

public class ConstraintMakerExtendable: ConstraintMakerRelatable {
    
    public var left: ConstraintMakerExtendable {
        self.description.attributes += .left       // ← OptionSet 位或
        return self
    }
    
    public var top: ConstraintMakerExtendable {
        self.description.attributes += .top
        return self
    }
    
    public var edges: ConstraintMakerExtendable {
        self.description.attributes += .edges
        return self
    }
    // ... 所有属性都一样
}

internal func +=(left: inout ConstraintAttributes, right: ConstraintAttributes) {
    left.formUnion(right)
}

public class ConstraintMakerRelatable {
    internal let description: ConstraintDescription
    
    internal func relatedTo(_ other: ConstraintRelatableTarget, relation: ConstraintRelation, file: String, line: UInt) -> ConstraintMakerEditable {
        let related: ConstraintItem
        let constant: ConstraintConstantTarget
        
        if let other = other as? ConstraintItem {
            guard other.attributes == ConstraintAttributes.none ||
                  other.attributes.layoutAttributes.count <= 1 ||
                  other.attributes.layoutAttributes == self.description.attributes.layoutAttributes ||
                  other.attributes == .edges && self.description.attributes == .margins ||
                  /* ... 一堆合法的属性组合 ... */ else {
                fatalError("Cannot constraint to multiple non identical attributes. (\(file), \(line))");
            }
            related = other
            constant = 0.0
        } else if let other = other as? ConstraintView {
            related = ConstraintItem(target: other, attributes: ConstraintAttributes.none)
            constant = 0.0
        } else if let other = other as? ConstraintConstantTarget {
            related = ConstraintItem(target: nil, attributes: ConstraintAttributes.none)
            constant = other
        } else if #available(iOS 9.0, OSX 10.11, *), let other = other as? ConstraintLayoutGuide {
            related = ConstraintItem(target: other, attributes: ConstraintAttributes.none)
            constant = 0.0
        } else {
            fatalError("Invalid constraint. (\(file), \(line))")
        }
        
        let editable = ConstraintMakerEditable(self.description)
        editable.description.sourceLocation = (file, line)
        editable.description.relation = relation
        editable.description.related = related
        editable.description.constant = constant
        return editable
    }
    
    @discardableResult
    public func equalTo(_ other: ConstraintRelatableTarget, _ file: String = #fileID, _ line: UInt = #line) -> ConstraintMakerEditable {
        return self.relatedTo(other, relation: .equal, file: file, line: line)
    }
    // ... lessThanOrEqualTo / greaterThanOrEqualTo / equalToSuperview ...
}

public class ConstraintMakerEditable: ConstraintMakerPrioritizable {

    @discardableResult
    public func multipliedBy(_ amount: ConstraintMultiplierTarget) -> ConstraintMakerEditable {
        self.description.multiplier = amount
        return self
    }
    
    @discardableResult
    public func dividedBy(_ amount: ConstraintMultiplierTarget) -> ConstraintMakerEditable {
        return self.multipliedBy(1.0 / amount.constraintMultiplierTargetValue)
    }
    
    @discardableResult
    public func offset(_ amount: ConstraintOffsetTarget) -> ConstraintMakerEditable {
        self.description.constant = amount.constraintOffsetTargetValue
        return self
    }
    
    @discardableResult
    public func inset(_ amount: ConstraintInsetTarget) -> ConstraintMakerEditable {
        self.description.constant = amount.constraintInsetTargetValue
        return self
    }
    
    #if canImport(UIKit)
    @discardableResult
    @available(iOS 11.0, tvOS 11.0, *)
    public func inset(_ amount: ConstraintDirectionalInsetTarget) -> ConstraintMakerEditable {
        self.description.constant = amount.constraintDirectionalInsetTargetValue
        return self
    }
    #endif
}

public class ConstraintMakerPrioritizable: ConstraintMakerFinalizable {
    
    @discardableResult
    public func priority(_ amount: ConstraintPriority) -> ConstraintMakerFinalizable {
        self.description.priority = amount.value
        return self
    }
    
    @discardableResult
    public func priority(_ amount: ConstraintPriorityTarget) -> ConstraintMakerFinalizable {
        self.description.priority = amount
        return self
    }
    // ... 废弃的 priorityRequired/High/Medium/Low ...
}

public class ConstraintMakerFinalizable {
    
    internal let description: ConstraintDescription
    
    internal init(_ description: ConstraintDescription) {
        self.description = description
    }
    
    @discardableResult
    public func labeled(_ label: String) -> ConstraintMakerFinalizable {
        self.description.label = label
        return self
    }
    
    public var constraint: Constraint {
        return self.description.constraint!
    }
}

public class ConstraintDescription {
    
    internal let item: LayoutConstraintItem
    internal var attributes: ConstraintAttributes
    internal var relation: ConstraintRelation? = nil
    internal var sourceLocation: (String, UInt)? = nil
    internal var label: String? = nil
    internal var related: ConstraintItem? = nil
    internal var multiplier: ConstraintMultiplierTarget = 1.0
    internal var constant: ConstraintConstantTarget = 0.0
    internal var priority: ConstraintPriorityTarget = 1000.0
    internal lazy var constraint: Constraint? = {
        guard let relation = self.relation,
              let related = self.related,
              let sourceLocation = self.sourceLocation else {
            return nil
        }
        let from = ConstraintItem(target: self.item, attributes: self.attributes)
        
        return Constraint(
            from: from,
            to: related,
            relation: relation,
            sourceLocation: sourceLocation,
            label: self.label,
            multiplier: self.multiplier,
            constant: self.constant,
            priority: self.priority
        )
    }()
    
    internal init(item: LayoutConstraintItem, attributes: ConstraintAttributes) {
        self.item = item
        self.attributes = attributes
    }
}

public protocol ConstraintRelatableTarget {}

extension Int: ConstraintRelatableTarget {}
extension UInt: ConstraintRelatableTarget {}
extension Float: ConstraintRelatableTarget {}
extension Double: ConstraintRelatableTarget {}
extension CGFloat: ConstraintRelatableTarget {}
extension CGSize: ConstraintRelatableTarget {}
extension CGPoint: ConstraintRelatableTarget {}
extension ConstraintInsets: ConstraintRelatableTarget {}
#if canImport(UIKit)
@available(iOS 11.0, tvOS 11.0, *)
extension ConstraintDirectionalInsets: ConstraintRelatableTarget {}
#endif
extension ConstraintItem: ConstraintRelatableTarget {}
extension ConstraintView: ConstraintRelatableTarget {}
@available(iOS 9.0, OSX 10.11, *)
extension ConstraintLayoutGuide: ConstraintRelatableTarget {}

extension ConstraintConstantTarget {
    internal func constraintConstantTargetValueFor(layoutAttribute: LayoutAttribute) -> CGFloat {
        if let value = self as? CGFloat { return value }
        if let value = self as? Float { return CGFloat(value) }
        // ... Double/Int/UInt 转 CGFloat ...
        
        if let value = self as? CGSize {
            if layoutAttribute == .width { return value.width }
            else if layoutAttribute == .height { return value.height }
            else { return 0.0 }
        }
        
        if let value = self as? CGPoint {
            switch layoutAttribute {
            case .left, .right, .leading, .trailing, .centerX, .leftMargin, ...:
                return value.x
            case .top, .bottom, .centerY, .topMargin, ..., .lastBaseline, .firstBaseline:
                return value.y
            // ...
            }
        }
        
        if let value = self as? ConstraintInsets {
            switch layoutAttribute {
            case .left, .leftMargin:            return value.left
            case .top, .topMargin, .firstBaseline:
                                                return value.top
            case .right, .rightMargin:          return -value.right     // ← 符号翻转
            case .bottom, .bottomMargin, .lastBaseline:
                                                return -value.bottom    // ← 符号翻转
            case .leading, .leadingMargin:
                return (ConstraintConfig.interfaceLayoutDirection == .leftToRight) ? value.left : value.right
            case .trailing, .trailingMargin:
                return (ConstraintConfig.interfaceLayoutDirection == .leftToRight) ? -value.right : -value.left
            case .centerX, .centerXWithinMargins:
                                                return (value.left - value.right) / 2
            case .centerY, .centerYWithinMargins:
                                                return (value.top - value.bottom) / 2
            case .width:                        return -(value.left + value.right)
            case .height:                       return -(value.top + value.bottom)
            // ...
            }
        }
        
        // ConstraintDirectionalInsets ... 与 ConstraintInsets 类似但 leading/trailing 不看 interfaceLayoutDirection
        return 0.0
    }
}

extension ConstraintInsetTarget {
    internal var constraintInsetTargetValue: ConstraintInsets {
        if let amount = self as? ConstraintInsets {
            return amount
        } else if let amount = self as? Float {
            return ConstraintInsets(top: CGFloat(amount), left: CGFloat(amount), bottom: CGFloat(amount), right: CGFloat(amount))
        } else if let amount = self as? Double {
            return ConstraintInsets(top: CGFloat(amount), left: CGFloat(amount), bottom: CGFloat(amount), right: CGFloat(amount))
        } else if let amount = self as? CGFloat {
            return ConstraintInsets(top: amount, left: amount, bottom: amount, right: amount)
        }
        // ...
    }
}

internal struct ConstraintAttributes : OptionSet, ExpressibleByIntegerLiteral {
    
    internal private(set) var rawValue: UInt
    
    // normal
    internal static let none: ConstraintAttributes = 0
    internal static let left: ConstraintAttributes = ConstraintAttributes(UInt(1) << 0)
    internal static let top: ConstraintAttributes = ConstraintAttributes(UInt(1) << 1)
    internal static let right: ConstraintAttributes = ConstraintAttributes(UInt(1) << 2)
    internal static let bottom: ConstraintAttributes = ConstraintAttributes(UInt(1) << 3)
    internal static let leading: ConstraintAttributes = ConstraintAttributes(UInt(1) << 4)
    internal static let trailing: ConstraintAttributes = ConstraintAttributes(UInt(1) << 5)
    internal static let width: ConstraintAttributes = ConstraintAttributes(UInt(1) << 6)
    internal static let height: ConstraintAttributes = ConstraintAttributes(UInt(1) << 7)
    internal static let centerX: ConstraintAttributes = ConstraintAttributes(UInt(1) << 8)
    internal static let centerY: ConstraintAttributes = ConstraintAttributes(UInt(1) << 9)
    internal static let lastBaseline: ConstraintAttributes = ConstraintAttributes(UInt(1) << 10)
    @available(iOS 8.0, OSX 10.11, *)
    internal static let firstBaseline: ConstraintAttributes = ConstraintAttributes(UInt(1) << 11)
    // leftMargin(1<<12), rightMargin(1<<13), ...
    
    // aggregates
    internal static let edges: ConstraintAttributes = [.horizontalEdges, .verticalEdges]
    internal static let horizontalEdges: ConstraintAttributes = [.left, .right]
    internal static let verticalEdges: ConstraintAttributes = [.top, .bottom]
    internal static let directionalEdges: ConstraintAttributes = [.directionalHorizontalEdges, .directionalVerticalEdges]
    internal static let directionalHorizontalEdges: ConstraintAttributes = [.leading, .trailing]
    internal static let directionalVerticalEdges: ConstraintAttributes = [.top, .bottom]
    internal static let size: ConstraintAttributes = [.width, .height]
    internal static let center: ConstraintAttributes = [.centerX, .centerY]
    @available(iOS 8.0, *)
    internal static let margins: ConstraintAttributes = [.leftMargin, .topMargin, .rightMargin, .bottomMargin]
    @available(iOS 8.0, *)
    internal static let directionalMargins: ConstraintAttributes = [.leadingMargin, .topMargin, .trailingMargin, .bottomMargin]
    @available(iOS 8.0, *)
    internal static let centerWithinMargins: ConstraintAttributes = [.centerXWithinMargins, .centerYWithinMargins]
    
    internal var layoutAttributes:[LayoutAttribute] {
        var attrs = [LayoutAttribute]()
        if (self.contains(ConstraintAttributes.left))  { attrs.append(.left) }
        if (self.contains(ConstraintAttributes.top))   { attrs.append(.top) }
        // ... 十几个 if
        return attrs
    }
}

public final class Constraint {

    internal let sourceLocation: (String, UInt)
    internal let label: String?
    private let from: ConstraintItem
    private let to: ConstraintItem
    private let relation: ConstraintRelation
    private let multiplier: ConstraintMultiplierTarget
    private var constant: ConstraintConstantTarget {
        didSet { self.updateConstantAndPriorityIfNeeded() }
    }
    private var priority: ConstraintPriorityTarget {
        didSet { self.updateConstantAndPriorityIfNeeded() }
    }
    public var layoutConstraints: [LayoutConstraint]
    
    public var isActive: Bool {
        set { newValue ? activate() : deactivate() }
        get {
            for layoutConstraint in self.layoutConstraints {
                if layoutConstraint.isActive { return true }
            }
            return false
        }
    }

for layoutFromAttribute in layoutFromAttributes {
    let layoutToAttribute: LayoutAttribute
    #if canImport(UIKit)
        if layoutToAttributes.count > 0 {
            if self.from.attributes == .edges && self.to.attributes == .margins {
                switch layoutFromAttribute {
                case .left:   layoutToAttribute = .leftMargin
                case .right:  layoutToAttribute = .rightMargin
                case .top:    layoutToAttribute = .topMargin
                case .bottom: layoutToAttribute = .bottomMargin
                default: fatalError()
                }
            } else if /* margins → edges / directionalEdges → directionalMargins / ... */ {
                // ...
            } else if self.from.attributes == self.to.attributes {
                layoutToAttribute = layoutFromAttribute
            } else {
                layoutToAttribute = layoutToAttributes[0]
            }
        } else {
            if self.to.target == nil && (layoutFromAttribute == .centerX || layoutFromAttribute == .centerY) {
                layoutToAttribute = layoutFromAttribute == .centerX ? .left : .top
            } else {
                layoutToAttribute = layoutFromAttribute
            }
        }
    #else
        // macOS 简化版
    #endif

    let layoutConstant: CGFloat = self.constant.constraintConstantTargetValueFor(layoutAttribute: layoutToAttribute)
    var layoutTo: AnyObject? = self.to.target

    // 没指定对端 View？那就用 superview（除了 width/height 这种不需要参考系的）
    if layoutTo == nil && layoutToAttribute != .width && layoutToAttribute != .height {
        layoutTo = layoutFrom.superview
    }

    let layoutConstraint = LayoutConstraint(
        item: layoutFrom,
        attribute: layoutFromAttribute,
        relatedBy: layoutRelation,
        toItem: layoutTo,
        attribute: layoutToAttribute,
        multiplier: self.multiplier.constraintMultiplierTargetValue,
        constant: layoutConstant
    )
    layoutConstraint.label = self.label
    layoutConstraint.priority = LayoutPriority(rawValue: self.priority.constraintPriorityTargetValue)
    layoutConstraint.constraint = self
    self.layoutConstraints.append(layoutConstraint)
}

internal func activateIfNeeded(updatingExisting: Bool = false) {
    guard let item = self.from.layoutConstraintItem else {
        print("WARNING: SnapKit failed to get from item from constraint. Activate will be a no-op.")
        return
    }
    let layoutConstraints = self.layoutConstraints

    if updatingExisting {
        var existingLayoutConstraints: [LayoutConstraint] = []
        for constraint in item.constraints {
            existingLayoutConstraints += constraint.layoutConstraints
        }
        for layoutConstraint in layoutConstraints {
            let existingLayoutConstraint = existingLayoutConstraints.first { $0 == layoutConstraint }
            guard let updateLayoutConstraint = existingLayoutConstraint else {
                fatalError("Updated constraint could not find existing matching constraint to update: \(layoutConstraint)")
            }
            let updateLayoutAttribute = (updateLayoutConstraint.secondAttribute == .notAnAttribute) ? updateLayoutConstraint.firstAttribute : updateLayoutConstraint.secondAttribute
            updateLayoutConstraint.constant = self.constant.constraintConstantTargetValueFor(layoutAttribute: updateLayoutAttribute)
        }
    } else {
        NSLayoutConstraint.activate(layoutConstraints)
        item.add(constraints: [self])
    }
}

internal func deactivateIfNeeded() {
    guard let item = self.from.layoutConstraintItem else {
        print("WARNING: SnapKit failed to get from item from constraint. Deactivate will be a no-op.")
        return
    }
    let layoutConstraints = self.layoutConstraints
    NSLayoutConstraint.deactivate(layoutConstraints)
    item.remove(constraints: [self])
}

internal static func makeConstraints(item: LayoutConstraintItem, closure: (_ make: ConstraintMaker) -> Void) {
    let constraints = prepareConstraints(item: item, closure: closure)
    for constraint in constraints {
        constraint.activateIfNeeded(updatingExisting: false)
    }
}

internal static func remakeConstraints(item: LayoutConstraintItem, closure: (_ make: ConstraintMaker) -> Void) {
    self.removeConstraints(item: item)
    self.makeConstraints(item: item, closure: closure)
}

internal static func updateConstraints(item: LayoutConstraintItem, closure: (_ make: ConstraintMaker) -> Void) {
    guard item.constraints.count > 0 else {
        self.makeConstraints(item: item, closure: closure)
        return
    }
    let constraints = prepareConstraints(item: item, closure: closure)
    for constraint in constraints {
        constraint.activateIfNeeded(updatingExisting: true)
    }
}

internal static func removeConstraints(item: LayoutConstraintItem) {
    let constraints = item.constraints
    for constraint in constraints {
        constraint.deactivateIfNeeded()
    }
}

extension LayoutConstraintItem {
    
    internal func prepare() {
        if let view = self as? ConstraintView {
            view.translatesAutoresizingMaskIntoConstraints = false
        }
    }
    
    internal var superview: ConstraintView? {
        if let view = self as? ConstraintView { return view.superview }
        if #available(iOS 9.0, OSX 10.11, *), let guide = self as? ConstraintLayoutGuide {
            return guide.owningView
        }
        return nil
    }
    
    internal var constraints: [Constraint] {
        return self.constraintsSet.allObjects as! [Constraint]
    }
    
    internal func add(constraints: [Constraint]) {
        let constraintsSet = self.constraintsSet
        for constraint in constraints {
            constraintsSet.add(constraint)
        }
    }
    
    internal func remove(constraints: [Constraint]) {
        let constraintsSet = self.constraintsSet
        for constraint in constraints {
            constraintsSet.remove(constraint)
        }
    }
    
    private var constraintsSet: NSMutableSet {
        let constraintsSet: NSMutableSet
        if let existing = objc_getAssociatedObject(self, &constraintsKey) as? NSMutableSet {
            constraintsSet = existing
        } else {
            constraintsSet = NSMutableSet()
            objc_setAssociatedObject(self, &constraintsKey, constraintsSet, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
        }
        return constraintsSet
    }
}
private var constraintsKey: UInt8 = 0

public final class ConstraintItem {
    internal weak var target: AnyObject?    // ← weak
    internal let attributes: ConstraintAttributes
    
    internal init(target: AnyObject?, attributes: ConstraintAttributes) {
        self.target = target
        self.attributes = attributes
    }
    
    internal var layoutConstraintItem: LayoutConstraintItem? {
        return self.target as? LayoutConstraintItem
    }
}

public extension LayoutConstraint {
    
    override var description: String {
        var description = "<"
        description += descriptionForObject(self)
        
        if let firstItem = conditionalOptional(from: self.firstItem) {
            description += " \(descriptionForObject(firstItem))"
        }
        if self.firstAttribute != .notAnAttribute {
            description += ".\(descriptionForAttribute(self.firstAttribute))"
        }
        description += " \(descriptionForRelation(self.relation))"
        if let secondItem = self.secondItem {
            description += " \(descriptionForObject(secondItem))"
        }
        if self.secondAttribute != .notAnAttribute {
            description += ".\(descriptionForAttribute(self.secondAttribute))"
        }
        if self.multiplier != 1.0 {
            description += " * \(self.multiplier)"
        }
        if self.secondAttribute == .notAnAttribute {
            description += " \(self.constant)"
        } else {
            if self.constant > 0.0 {
                description += " + \(self.constant)"
            } else if self.constant < 0.0 {
                description += " - \(abs(self.constant))"
            }
        }
        if self.priority.rawValue != 1000.0 {
            description += " ^\(self.priority)"
        }
        description += ">"
        return description
    }
}

<LayoutConstraint:redBox@ViewController.swift#42 UIView:redBox.top == UIView:superview.top + 20>

box.snp.makeConstraints { make in
    make.width.height.equalTo(50)
    make.center.equalToSuperview()
}