More arithmetic

# Conflicts:
#	Sources/LLVM/IntType.swift

Author: CodaFi

Sources/LLVM/Constant.swift

@@ -3,19 +3,21 @@ import cllvm
 #endif
 
 public protocol ConstantRepresentation {}
-  public enum Unsigned: ConstantRepresentation {}
-  public enum Signed: ConstantRepresentation {}
-  public enum Floating: ConstantRepresentation {}
+public protocol IntegralConstantRepresentation: ConstantRepresentation {}
+public protocol RealConstantRepresentation: ConstantRepresentation {}
+  public enum Unsigned: IntegralConstantRepresentation {}
+  public enum Signed: IntegralConstantRepresentation {}
+  public enum Floating: RealConstantRepresentation {}
+
+internal enum InternalConstantRepresentation {
+  case unsigned
+  case signed
+  case floating
+}
 
 public struct Constant<Repr: ConstantRepresentation>: IRValue {
-  internal enum Representation {
-    case unsigned
-    case signed
-    case floating
-  }
-
   internal let llvm: LLVMValueRef
-  internal let repr: Representation
+  internal let repr: InternalConstantRepresentation
 
   /// Retrieves the underlying LLVM constant object.
   public func asLLVM() -> LLVMValueRef {
@@ -25,17 +27,28 @@ public struct Constant<Repr: ConstantRepresentation>: IRValue {
   public init(llvm: LLVMValueRef!) {
     self.llvm = llvm
 
-    if ObjectIdentifier(Repr.self) == ObjectIdentifier(Unsigned.self) {
+    let reprID = ObjectIdentifier(Repr.self)
+    if reprID == ObjectIdentifier(Unsigned.self) {
       self.repr = .unsigned
-    } else if ObjectIdentifier(Repr.self) == ObjectIdentifier(Signed.self) {
+    } else if reprID == ObjectIdentifier(Signed.self) {
       self.repr = .signed
-    } else if ObjectIdentifier(Repr.self) == ObjectIdentifier(Floating.self) {
+    } else if reprID == ObjectIdentifier(Floating.self) {
       self.repr = .floating
     } else {
       fatalError("Invalid representation \(type(of: Repr.self))")
     }
   }
 
+  public static prefix func -(lhs: Constant<Signed>) -> Constant<Signed> {
+    precondition(lhs.repr == .signed, "Invalid representation")
+    return Constant<Signed>(llvm: LLVMConstNeg(lhs.llvm))
+  }
+
+  public static prefix func -(lhs: Constant<Floating>) -> Constant<Floating> {
+    precondition(lhs.repr == .floating, "Invalid representation")
+    return Constant<Floating>(llvm: LLVMConstFNeg(lhs.llvm))
+  }
+
   public static func +(lhs: Constant, rhs: Constant) -> Constant {
     precondition(lhs.repr == rhs.repr, "Mixed-representation constant operations are disallowed")
 
@@ -85,6 +98,19 @@ public struct Constant<Repr: ConstantRepresentation>: IRValue {
     }
   }
 
+  public static func %(lhs: Constant, rhs: Constant) -> Constant {
+    precondition(lhs.repr == rhs.repr, "Mixed-representation constant operations are disallowed")
+
+    switch lhs.repr {
+    case .signed:
+      return Constant(llvm: LLVMConstSRem(lhs.llvm, rhs.llvm))
+    case .unsigned:
+      return Constant(llvm: LLVMConstURem(lhs.llvm, rhs.llvm))
+    case .floating:
+      return Constant(llvm: LLVMConstFRem(lhs.llvm, rhs.llvm))
+    }
+  }
+
   public static func ==(lhs: Constant, rhs: Constant) -> Constant {
     precondition(lhs.repr == rhs.repr, "Mixed-representation constant operations are disallowed")
 
@@ -142,4 +168,45 @@ public struct Constant<Repr: ConstantRepresentation>: IRValue {
       return Constant(llvm: LLVMConstFCmp(RealPredicate.oge.llvm, lhs.llvm, rhs.llvm))
     }
   }
+
+  public static prefix func ! <T: IntegralConstantRepresentation>(lhs: Constant<T>) -> Constant<T> {
+    precondition(lhs.repr == .signed || lhs.repr == .unsigned, "Invalid representation")
+    return Constant<T>(llvm: LLVMConstNeg(lhs.llvm))
+  }
+
+  public static func &&(lhs: Constant, rhs: Constant) -> Constant {
+    precondition(lhs.repr == rhs.repr, "Mixed-representation constant operations are disallowed")
+
+    return Constant(llvm: LLVMConstAnd(lhs.llvm, rhs.llvm))
+  }
+
+  public static func ||(lhs: Constant, rhs: Constant) -> Constant {
+    precondition(lhs.repr == rhs.repr, "Mixed-representation constant operations are disallowed")
+
+    return Constant(llvm: LLVMConstOr(lhs.llvm, rhs.llvm))
+  }
+
+  public static func ^(lhs: Constant, rhs: Constant) -> Constant {
+    precondition(lhs.repr == rhs.repr, "Mixed-representation constant operations are disallowed")
+
+    return Constant(llvm: LLVMConstXor(lhs.llvm, rhs.llvm))
+  }
+
+  public static func >> <T: IntegralConstantRepresentation, U: IntegralConstantRepresentation>(lhs: Constant<T>, rhs: Constant<U>) -> Constant<T> {
+    precondition(lhs.repr == rhs.repr, "Mixed-representation constant operations are disallowed")
+
+    return Constant<T>(llvm: LLVMConstAShr(lhs.llvm, rhs.llvm))
+  }
+
+//  public static func >>> <T: IntegralConstantRepresentation, U: IntegralConstantRepresentation>(lhs: Constant<T>, rhs: Constant<U>) -> Constant<T> {
+//    precondition(lhs.repr == rhs.repr, "Mixed-representation constant operations are disallowed")
+//
+//    return Constant<T>(llvm: LLVMConstLShr(lhs.llvm, rhs.llvm))
+//  }
+
+  public static func << <T: IntegralConstantRepresentation, U: IntegralConstantRepresentation>(lhs: Constant<T>, rhs: Constant<U>) -> Constant<T> {
+    precondition(lhs.repr == rhs.repr, "Mixed-representation constant operations are disallowed")
+
+    return Constant<T>(llvm: LLVMConstShl(lhs.llvm, rhs.llvm))
+  }
 }