Add Casting operators

Author: CodaFi

Sources/LLVM/Constant.swift

@@ -9,12 +9,22 @@ public protocol RealConstantRepresentation: ConstantRepresentation {}
   public enum Signed: IntegralConstantRepresentation {}
   public enum Floating: RealConstantRepresentation {}
 
+// FIXME: When upgrading to Swift 3.1, move this into `Constant`.
 internal enum InternalConstantRepresentation {
   case unsigned
   case signed
   case floating
 }
 
+/// A `Constant` represents a value initialized to a constant.  Constant values
+/// may be manipulated with standard Swift arithmetic operations and used with
+/// standard IR Builder instructions like any other operand.  The difference
+/// being any instructions acting solely on constants and any arithmetic
+/// performed on constants is evaluated at compile-time only.
+///
+/// `Constant`s keep track of the values they represent at the type level to
+/// disallow mixed-type arithmetic.  Use the `cast` family of operations to
+/// safely convert constants to other representations.
 public struct Constant<Repr: ConstantRepresentation>: IRValue {
   internal let llvm: LLVMValueRef
   internal let repr: InternalConstantRepresentation
@@ -39,6 +49,48 @@ public struct Constant<Repr: ConstantRepresentation>: IRValue {
     }
   }
 
+  // MARK: Casting
+
+  public func cast<T: IntegralConstantRepresentation>(to type: IntType) -> Constant<T> {
+    let reprID = ObjectIdentifier(T.self)
+    let val = self.asLLVM()
+    if reprID == ObjectIdentifier(Unsigned.self) {
+      switch self.repr {
+      case .unsigned: fallthrough
+      case .signed:
+        return Constant<T>(llvm: LLVMConstIntCast(val, type.asLLVM(), /*signed:*/ false.llvm))
+      case .floating:
+        return Constant<T>(llvm: LLVMConstFPToUI(val, type.asLLVM()))
+      }
+    } else if reprID == ObjectIdentifier(Signed.self) {
+      switch self.repr {
+      case .unsigned: fallthrough
+      case .signed:
+        return Constant<T>(llvm: LLVMConstIntCast(val, type.asLLVM(), /*signed:*/ true.llvm))
+      case .floating:
+        return Constant<T>(llvm: LLVMConstFPToSI(val, type.asLLVM()))
+      }
+    } else {
+      fatalError("Invalid representation \(type(of: T.self))")
+    }
+  }
+
+  public func cast<T: RealConstantRepresentation>(to type: FloatType) -> Constant<T> {
+    guard ObjectIdentifier(T.self) == ObjectIdentifier(Floating.self) else {
+      fatalError("Invalid representation \(type(of: T.self))")
+    }
+
+    let val = self.asLLVM()
+    switch self.repr {
+    case .unsigned:
+      return Constant<T>(llvm: LLVMConstUIToFP(val, type.asLLVM()))
+    case .signed:
+      return Constant<T>(llvm: LLVMConstSIToFP(val, type.asLLVM()))
+    case .floating:
+      return Constant<T>(llvm: LLVMConstFPCast(val, type.asLLVM()))
+    }
+  }
+
   // MARK: Arithmetic Operations
 
   public static func neg(_ lhs: Constant<Signed>, overflowBehavior: OverflowBehavior = .default) -> Constant<Signed> {