[debug-info] Define DebugVarCarryingInst, a light abstraction on top of instructions that carry information about a specific debug variable.

This allows one to write high level code over the set of such instructions with
greater correctness by using exhaustive switches, methods, and keeping it light
weight by using *, -> operators to access functionality from the underlying
instruction when needed.

Author: gottesmm

include/swift/SIL/DebugUtils.h

@@ -218,6 +218,96 @@ inline SILBasicBlock::iterator eraseFromParentWithDebugInsts(
 bool hasNonTrivialNonDebugTransitiveUsers(
     PointerUnion<SILInstruction *, SILArgument *> V);
 
+/// A light weight abstraction on top of an instruction that carries within it
+/// information about a debug variable. This allows one to write high level code
+/// over the set of such instructions with greater correctness by using
+/// exhaustive switches, methods, and keeping it light weight by using *, ->
+/// operators to access functionality from the underlying instruction when
+/// needed.
+struct DebugVarCarryingInst {
+  enum class Kind {
+    Invalid = 0,
+    DebugValue,
+    DebugValueAddr,
+    AllocStack,
+    AllocBox,
+  };
+
+  Kind kind;
+  SILInstruction *inst;
+
+  DebugVarCarryingInst() : kind(Kind::Invalid), inst(nullptr) {}
+  DebugVarCarryingInst(DebugValueInst *dvi)
+      : kind(Kind::DebugValue), inst(dvi) {}
+  DebugVarCarryingInst(DebugValueAddrInst *dvai)
+      : kind(Kind::DebugValueAddr), inst(dvai) {}
+  DebugVarCarryingInst(AllocStackInst *asi)
+      : kind(Kind::AllocStack), inst(asi) {}
+  DebugVarCarryingInst(AllocBoxInst *abi) : kind(Kind::AllocBox), inst(abi) {}
+  DebugVarCarryingInst(SILInstruction *newInst)
+      : kind(Kind::Invalid), inst(nullptr) {
+    switch (newInst->getKind()) {
+    default:
+      return;
+    case SILInstructionKind::DebugValueInst:
+      kind = Kind::DebugValue;
+      break;
+    case SILInstructionKind::DebugValueAddrInst:
+      kind = Kind::DebugValueAddr;
+      break;
+    case SILInstructionKind::AllocStackInst:
+      kind = Kind::AllocStack;
+      break;
+    case SILInstructionKind::AllocBoxInst:
+      kind = Kind::AllocBox;
+      break;
+    }
+    inst = newInst;
+  }
+
+  /// Enable the composition struct to be used as an instruction easily. We use
+  /// a '*' so that in the source it is easily visible to the eye that something
+  /// is happening here.
+  SILInstruction *operator*() const { return inst; }
+
+  /// Enable one to access the methods of the wrapped instruction using
+  /// '->'. This keeps the wrapper light weight.
+  SILInstruction *operator->() const { return inst; }
+
+  /// Add support for this struct in `if` statement.
+  explicit operator bool() const { return bool(kind); }
+
+  VarDecl *getDecl() const {
+    switch (kind) {
+    case Kind::Invalid:
+      llvm_unreachable("Invalid?!");
+    case Kind::DebugValue:
+      return cast<DebugValueInst>(inst)->getDecl();
+    case Kind::DebugValueAddr:
+      return cast<DebugValueAddrInst>(inst)->getDecl();
+    case Kind::AllocStack:
+      return cast<AllocStackInst>(inst)->getDecl();
+    case Kind::AllocBox:
+      return cast<AllocBoxInst>(inst)->getDecl();
+    }
+  }
+
+  Optional<SILDebugVariable> getVarInfo() const {
+    switch (kind) {
+    case Kind::Invalid:
+      llvm_unreachable("Invalid?!");
+    case Kind::DebugValue:
+      return cast<DebugValueInst>(inst)->getVarInfo();
+    case Kind::DebugValueAddr:
+      return cast<DebugValueAddrInst>(inst)->getVarInfo();
+    case Kind::AllocStack:
+      return cast<AllocStackInst>(inst)->getVarInfo();
+    case Kind::AllocBox:
+      return cast<AllocBoxInst>(inst)->getVarInfo();
+    }
+  }
+};
+
 } // end namespace swift
 
 #endif // SWIFT_SIL_DEBUGUTILS_H