C++: Add IR support for ConditionalDeclExpr

Also fixes several places in the library that weren't handling `ConditionalDeclExpr`  correctly.

Author: dave-bartolomeo

cpp/ql/src/semmle/code/cpp/Variable.qll

@@ -291,7 +291,8 @@ class LocalVariable extends LocalScopeVariable, @localvariable {
   override Type getType() { localvariables(underlyingElement(this),unresolveElement(result),_) }
 
   override Function getFunction() {
-    exists(DeclStmt s | s.getADeclaration() = this and s.getEnclosingFunction() = result)
+    exists(DeclStmt s | s.getADeclaration() = this and s.getEnclosingFunction() = result) or
+    exists(ConditionDeclExpr e | e.getVariable() = this and e.getEnclosingFunction() = result)
   }
 }
 

cpp/ql/src/semmle/code/cpp/exprs/Expr.qll

@@ -28,7 +28,8 @@ class Expr extends StmtParent, @expr {
       result = this.getParent().(Expr).getEnclosingStmt() or
       result = this.getParent().(Stmt) or
       exists(Expr other | result = other.getEnclosingStmt() and other.getConversion() = this) or
-      exists(DeclStmt d, LocalVariable v | d.getADeclaration() = v and v.getInitializer().getExpr() = this and result = d)
+      exists(DeclStmt d, LocalVariable v | d.getADeclaration() = v and v.getInitializer().getExpr() = this and result = d) or
+      exists(ConditionDeclExpr cde, LocalVariable v | cde.getVariable() = v and v.getInitializer().getExpr() = this and result = cde.getEnclosingStmt())
   }
 
   /** Gets the enclosing variable of this expression, if any. */

cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/TranslatedDeclarationEntry.qll

@@ -186,3 +186,39 @@ class TranslatedVariableDeclarationEntry extends TranslatedVariableDeclaration,
     result = var
   }
 }
+
+TranslatedConditionDecl getTranslatedConditionDecl(ConditionDeclExpr expr) {
+  result.getAST() = expr
+}
+
+/**
+ * Represents the IR translation of the declaration portion of a `ConditionDeclExpr`, which
+ * represents the variable declared in code such as:
+ * ```
+ * if (int* p = &x) {
+ * }
+ * ```
+ */
+class TranslatedConditionDecl extends TranslatedVariableDeclaration, TTranslatedConditionDecl {
+  ConditionDeclExpr conditionDeclExpr;
+
+  TranslatedConditionDecl() {
+    this = TTranslatedConditionDecl(conditionDeclExpr)
+  }
+
+  override string toString() {
+    result = "decl: " + conditionDeclExpr.toString()
+  }
+
+  override Locatable getAST() {
+    result = conditionDeclExpr
+  }
+
+  override Function getFunction() {
+    result = conditionDeclExpr.getEnclosingFunction()
+  }
+
+  override LocalVariable getVariable() {
+    result = conditionDeclExpr.getVariable()
+  }
+}

cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/TranslatedElement.qll

@@ -319,6 +319,10 @@ newtype TTranslatedElement =
   // An allocation size for a `new` or `new[]` expression
   TTranslatedAllocationSize(NewOrNewArrayExpr newExpr) {
     not ignoreExpr(newExpr)
+  } or
+  // The declaration/initialization part of a `ConditionDeclExpr`
+  TTranslatedConditionDecl(ConditionDeclExpr expr) {
+    not ignoreExpr(expr)
   }
 
 /**

cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/TranslatedExpr.qll

@@ -4,6 +4,7 @@ private import semmle.code.cpp.ir.internal.OperandTag
 private import semmle.code.cpp.ir.internal.TempVariableTag
 private import InstructionTag
 private import TranslatedCondition
+private import TranslatedDeclarationEntry
 private import TranslatedElement
 private import TranslatedFunction
 private import TranslatedInitialization
@@ -2914,3 +2915,57 @@ class TranslatedNewArrayExpr extends TranslatedNewOrNewArrayExpr {
     none()
   }
 }
+
+/**
+ * The IR translation of a `ConditionDeclExpr`, which represents the value of the declared variable
+ * after conversion to `bool` in code such as:
+ * ```
+ * if (int* p = &x) {
+ * }
+ * ```
+ */
+class TranslatedConditionDeclExpr extends TranslatedNonConstantExpr {
+  ConditionDeclExpr condDeclExpr;
+
+  TranslatedConditionDeclExpr() {
+    condDeclExpr = expr
+  }
+
+  override final Instruction getFirstInstruction() {
+    result = getDecl().getFirstInstruction()
+  }
+
+  override final TranslatedElement getChild(int id) {
+    id = 0 and result = getDecl() or
+    id = 1 and result = getConditionExpr()
+  }
+
+  override Instruction getResult() {
+    result = getConditionExpr().getResult()
+  }
+
+  override Instruction getInstructionSuccessor(InstructionTag tag, EdgeKind kind) {
+    none()
+  }
+
+  override Instruction getChildSuccessor(TranslatedElement child) {
+    (
+      child = getDecl() and
+      result = getConditionExpr().getFirstInstruction()
+    ) or
+    child = getConditionExpr() and result = getParent().getChildSuccessor(this)
+  }
+
+  override predicate hasInstruction(Opcode opcode, InstructionTag tag, Type resultType,
+      boolean isGLValue) {
+    none()
+  }
+
+  private TranslatedConditionDecl getDecl() {
+    result = getTranslatedConditionDecl(condDeclExpr)
+  }
+
+  private TranslatedExpr getConditionExpr() {
+    result = getTranslatedExpr(condDeclExpr.getExpr().getFullyConverted())
+  }
+}

cpp/ql/test/library-tests/ir/ir/PrintAST.expected

@@ -6335,3 +6335,119 @@ ir.cpp:
 #  963|             Type = int
 #  963|             Value = 900
 #  963|             ValueCategory = prvalue
+#  966| IfStmtWithDeclaration(int, int) -> void
+#  966|   params: 
+#  966|     0: x
+#  966|         Type = int
+#  966|     1: y
+#  966|         Type = int
+#  966|   body: { ... }
+#  967|     0: if (...) ... 
+#  967|       0: (condition decl)
+#  967|           Type = bool
+#  967|           ValueCategory = prvalue
+#  967|         0: b
+#  967|             Type = bool
+#  967|             ValueCategory = prvalue(load)
+#  967|       1: { ... }
+#  968|         0: ExprStmt
+#  968|           0: ... = ...
+#  968|               Type = int
+#  968|               ValueCategory = lvalue
+#  968|             0: x
+#  968|                 Type = int
+#  968|                 ValueCategory = lvalue
+#  968|             1: 5
+#  968|                 Type = int
+#  968|                 Value = 5
+#  968|                 ValueCategory = prvalue
+#  970|       2: if (...) ... 
+#  970|         0: (condition decl)
+#  970|             Type = bool
+#  970|             ValueCategory = prvalue
+#  970|           0: (bool)...
+#  970|               Conversion = conversion to bool
+#  970|               Type = bool
+#  970|               ValueCategory = prvalue
+#  970|             expr: z
+#  970|                 Type = int
+#  970|                 ValueCategory = prvalue(load)
+#  970|         1: { ... }
+#  971|           0: ExprStmt
+#  971|             0: ... = ...
+#  971|                 Type = int
+#  971|                 ValueCategory = lvalue
+#  971|               0: y
+#  971|                   Type = int
+#  971|                   ValueCategory = lvalue
+#  971|               1: 7
+#  971|                   Type = int
+#  971|                   Value = 7
+#  971|                   ValueCategory = prvalue
+#  973|         2: if (...) ... 
+#  973|           0: (condition decl)
+#  973|               Type = bool
+#  973|               ValueCategory = prvalue
+#  973|             0: (bool)...
+#  973|                 Conversion = conversion to bool
+#  973|                 Type = bool
+#  973|                 ValueCategory = prvalue
+#  973|               expr: p
+#  973|                   Type = int *
+#  973|                   ValueCategory = prvalue(load)
+#  973|           1: { ... }
+#  974|             0: ExprStmt
+#  974|               0: ... = ...
+#  974|                   Type = int
+#  974|                   ValueCategory = lvalue
+#  974|                 0: * ...
+#  974|                     Type = int
+#  974|                     ValueCategory = lvalue
+#  974|                   0: p
+#  974|                       Type = int *
+#  974|                       ValueCategory = prvalue(load)
+#  974|                 1: 2
+#  974|                     Type = int
+#  974|                     Value = 2
+#  974|                     ValueCategory = prvalue
+#  976|     1: return ...
+#  978| WhileStmtWithDeclaration(int, int) -> void
+#  978|   params: 
+#  978|     0: x
+#  978|         Type = int
+#  978|     1: y
+#  978|         Type = int
+#  978|   body: { ... }
+#  979|     0: while (...) ...
+#  979|       0: (condition decl)
+#  979|           Type = bool
+#  979|           ValueCategory = prvalue
+#  979|         0: b
+#  979|             Type = bool
+#  979|             ValueCategory = prvalue(load)
+#  979|       1: { ... }
+#  981|     1: while (...) ...
+#  981|       0: (condition decl)
+#  981|           Type = bool
+#  981|           ValueCategory = prvalue
+#  981|         0: (bool)...
+#  981|             Conversion = conversion to bool
+#  981|             Type = bool
+#  981|             ValueCategory = prvalue
+#  981|           expr: z
+#  981|               Type = int
+#  981|               ValueCategory = prvalue(load)
+#  981|       1: { ... }
+#  983|     2: while (...) ...
+#  983|       0: (condition decl)
+#  983|           Type = bool
+#  983|           ValueCategory = prvalue
+#  983|         0: (bool)...
+#  983|             Conversion = conversion to bool
+#  983|             Type = bool
+#  983|             ValueCategory = prvalue
+#  983|           expr: p
+#  983|               Type = int *
+#  983|               ValueCategory = prvalue(load)
+#  983|       1: { ... }
+#  985|     3: return ...