Adopt hashing API of Swift 4.2.

Author: objecthub

README.md

@@ -193,9 +193,9 @@ The following technologies are needed to build the components of the LispKit fra
 command-line tool, Xcode and Carthage are not strictly needed. Just for compiling the framework and trying
 the command-line tool in Xcode, the Swift Package Manager is not needed.
 
-- [Xcode 9.4](https://developer.apple.com/xcode/)
+- [Xcode 10.0](https://developer.apple.com/xcode/)
 - [Carthage](https://github.com/Carthage/Carthage)
 - [Swift Package Manager](https://swift.org/package-manager/)
-- [Swift 4.1](https://developer.apple.com/swift/)
+- [Swift 4.2](https://developer.apple.com/swift/)
 - [NumberKit](http://github.com/objecthub/swift-numberkit)
 - [CommandLineKit](http://github.com/objecthub/swift-commandlinekit)

Sources/LispKit/Base/Owners.swift

@@ -27,14 +27,18 @@ import Foundation
 public struct Owners<T: Reference>: Sequence {
 
   fileprivate struct Entry: Hashable {
-    let hashValue: Int
+    let hash: Int
     weak var owner: T?
 
     init(_ owner: T) {
-      self.hashValue = Int(bitPattern: owner.identity)
+      self.hash = Int(bitPattern: owner.identity)
       self.owner = owner
     }
 
+    func hash(into hasher: inout Hasher) {
+      hasher.combine(self.hash)
+    }
+    
     static func ==(lhs: Owners<T>.Entry, rhs: Owners<T>.Entry) -> Bool {
       return lhs.owner === rhs.owner && lhs.hashValue == rhs.hashValue
     }

Sources/LispKit/Base/Reference.swift

@@ -32,8 +32,8 @@ open class Reference: Hashable {
     return String(self.identity, radix: 16)
   }
 
-  public final var hashValue: Int {
-    return ObjectIdentifier(self).hashValue
+  public final func hash(into hasher: inout Hasher) {
+    hasher.combine(ObjectIdentifier(self))
   }
 
   open var typeDescription: String {

Sources/LispKit/Compiler/Checkpointer.swift

@@ -110,18 +110,21 @@ public enum CheckpointData: Hashable, CustomStringConvertible {
   case valueBinding(Symbol)
   case expansion(Expr)
 
-  public var hashValue: Int {
+  public func hash(into hasher: inout Hasher) {
     switch self {
       case .systemDefined:
-        return 1
+        hasher.combine(1)
       case .imported:
-        return 2
+        hasher.combine(2)
       case .fromGlobalEnv(let expr):
-        return expr.hashValue &* 31 &+ 3
+        hasher.combine(3)
+        hasher.combine(expr)
       case .valueBinding(let sym):
-        return sym.hashValue &* 31 &+ 4
+        hasher.combine(4)
+        hasher.combine(sym)
       case .expansion(let expr):
-        return expr.hashValue &* 31 &+ 5
+        hasher.combine(5)
+        hasher.combine(expr)
     }
   }
 

Sources/LispKit/Compiler/Env.swift

@@ -220,16 +220,15 @@ public enum WeakEnv: Hashable {
   }
 
   /// Hash value of this weak environment
-  public var hashValue: Int {
+  public func hash(into hasher: inout Hasher) {
     switch self {
       case .global(let box):
-        return ObjectIdentifier(box).hashValue
+        return hasher.combine(ObjectIdentifier(box))
       case .local(let box):
-        return ObjectIdentifier(box).hashValue
+        return hasher.combine(ObjectIdentifier(box))
     }
   }
 
-  
   /// Compares two weak environments. Two weak environments are the same if they have the same
   /// type (i.e. same enumeration case) and for local environments, the bindings groups are
   /// identical (same object).

Sources/LispKit/Compiler/RuntimeError.swift

@@ -149,13 +149,12 @@ public class RuntimeError: Error, Hashable, CustomStringConvertible {
     }
   }
 
-  public var hashValue: Int {
-    var res = 0
+  public func hash(into hasher: inout Hasher) {
     for irritant in self.irritants {
-      res = res &* 31 &+ irritant.hashValue
+      hasher.combine(irritant)
     }
-    res = res &* 31 &+ self.descriptor.hashValue
-    return res &* 31 &+ self.pos.hashValue
+    hasher.combine(self.descriptor)
+    hasher.combine(self.pos)
   }
 
   public var message: String {
@@ -554,37 +553,40 @@ public enum ErrorDescriptor: Hashable {
     }
   }
 
-  public var hashValue: Int {
+  public func hash(into hasher: inout Hasher) {
     switch self {
       case .lexical(let error):
-        return error.hashValue &* 31
+        hasher.combine(error)
       case .syntax(let error):
-        return error.hashValue &* 31 &+ 1
+        hasher.combine(1)
+        hasher.combine(error)
       case .type(let found, let expected):
-        return (found.hashValue &* 31 &+ expected.hashValue) &* 31 &+ 2
+        hasher.combine(2)
+        hasher.combine(found)
+        hasher.combine(expected)
       case .range(let fun, let argn, let low, let high):
-        var res = (low.hashValue &* 31 &+ high.hashValue) &* 31
-        if let fun = fun {
-          res = (res + fun.hashValue) &* 31
-        }
-        if let argn = argn {
-          res = (res + argn.hashValue) &* 31
-        }
-        return res &+ 3
+        hasher.combine(3)
+        hasher.combine(fun)
+        hasher.combine(argn)
+        hasher.combine(low)
+        hasher.combine(high)
       case .argumentCount(let fun, let min, let max):
-        var res = (min.hashValue &* 31 &+ max.hashValue) &* 31
-        if let fun = fun {
-          res = (res + fun.hashValue) &* 31
-        }
-        return res &+ 4
+        hasher.combine(4)
+        hasher.combine(fun)
+        hasher.combine(min)
+        hasher.combine(max)
       case .eval(let error):
-        return error.hashValue &* 31 &+ 5
+        hasher.combine(5)
+        hasher.combine(error)
       case .os(let error):
-        return error.hashValue &* 31 &+ 6
+        hasher.combine(6)
+        hasher.combine(error)
       case .abortion:
-        return 7
+        hasher.combine(7)
       case .custom(let kind, let message):
-        return (kind.hashValue &* 31 &+ message.hashValue) &* 31 &+ 8
+        hasher.combine(8)
+        hasher.combine(kind)
+        hasher.combine(message)
     }
   }
 

Sources/LispKit/Compiler/SourcePosition.swift

@@ -53,8 +53,10 @@ public struct SourcePosition: Equatable, Hashable, CustomStringConvertible {
               pos.col > UInt16.max ? SourcePosition.unknownColumn : UInt16(pos.col))
   }
 
-  public var hashValue: Int {
-    return ((self.sourceId.hashValue &* 31) &+ self.line.hashValue) &* 31 &+ self.column.hashValue
+  public func hash(into hasher: inout Hasher) {
+    hasher.combine(self.sourceId)
+    hasher.combine(self.line)
+    hasher.combine(self.column)
   }
 
   public var isUnknown: Bool {

Sources/LispKit/Data/Equality.swift

@@ -33,8 +33,8 @@ struct Equality: Hashable {
     self.ref2 = ref2
   }
 
-  var hashValue: Int {
-    return ref1.hashValue &+ ref2.hashValue
+  func hash(into hasher: inout Hasher) {
+    hasher.combine(ref1.hashValue &+ ref2.hashValue)
   }
 
   static func ==(lhs: Equality, rhs: Equality) -> Bool {

Sources/LispKit/Data/Expr.swift

@@ -363,8 +363,8 @@ public enum Expr: Trackable, Hashable {
     }
   }
 
-  public var hashValue: Int {
-    return equalHash(self)
+  public func hash(into hasher: inout Hasher) {
+    equalHash(self, into: &hasher)
   }
 }