C++: use more field overrides in IR generation

Author: Robert Marsh

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

@@ -255,64 +255,53 @@ abstract class TranslatedDirectCall extends TranslatedCall {
  */
 abstract class TranslatedCallExpr extends TranslatedNonConstantExpr,
     TranslatedCall {
-  Call call;
-
-  TranslatedCallExpr() {
-    expr = call
-  }
+  override Call expr;
 
   override final Type getCallResultType() {
     result = getResultType()
   }
 
   override final predicate hasArguments() {
-    exists(call.getArgument(0))
+    exists(expr.getArgument(0))
   }
 
   override final TranslatedExpr getQualifier() {
-    result = getTranslatedExpr(call.getQualifier().getFullyConverted())
+    result = getTranslatedExpr(expr.getQualifier().getFullyConverted())
   }
 
   override final TranslatedExpr getArgument(int index) {
-    result = getTranslatedExpr(call.getArgument(index).getFullyConverted())
+    result = getTranslatedExpr(expr.getArgument(index).getFullyConverted())
   }
 }
 
 /**
  * Represents the IR translation of a call through a function pointer.
  */
 class TranslatedExprCall extends TranslatedCallExpr {
-  ExprCall exprCall;
+  override ExprCall expr;
 
-  TranslatedExprCall() {
-    expr = exprCall
-  }
 
   override TranslatedExpr getCallTarget() {
-    result = getTranslatedExpr(exprCall.getExpr().getFullyConverted())
+    result = getTranslatedExpr(expr.getExpr().getFullyConverted())
   }
 }
 
 /**
  * Represents the IR translation of a direct function call.
  */
 class TranslatedFunctionCall extends TranslatedCallExpr, TranslatedDirectCall {
-  FunctionCall funcCall;
-
-  TranslatedFunctionCall() {
-    expr = funcCall
-  }
+  override FunctionCall expr;
 
   override Function getInstructionFunction(InstructionTag tag) {
-    tag = CallTargetTag() and result = funcCall.getTarget()
+    tag = CallTargetTag() and result = expr.getTarget()
   }
 
   override predicate hasReadSideEffect() {
-    not funcCall.getTarget().(SideEffectFunction).neverReadsMemory()
+    not expr.getTarget().(SideEffectFunction).neverReadsMemory()
   }
 
   override predicate hasWriteSideEffect() {
-    not funcCall.getTarget().(SideEffectFunction).neverWritesMemory()
+    not expr.getTarget().(SideEffectFunction).neverWritesMemory()
   }
 }
 
@@ -321,8 +310,8 @@ class TranslatedFunctionCall extends TranslatedCallExpr, TranslatedDirectCall {
  */
 class TranslatedStructorCall extends TranslatedFunctionCall {
   TranslatedStructorCall() {
-    funcCall instanceof ConstructorCall or
-    funcCall instanceof DestructorCall
+    expr instanceof ConstructorCall or
+    expr instanceof DestructorCall
   }
 
   override Instruction getQualifierResult() {

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

@@ -75,11 +75,7 @@ abstract class TranslatedFlexibleCondition extends TranslatedCondition,
 }
 
 class TranslatedParenthesisCondition extends TranslatedFlexibleCondition {
-  ParenthesisExpr paren;
-
-  TranslatedParenthesisCondition() {
-    paren = expr
-  }
+  override ParenthesisExpr expr;
 
   final override Instruction getChildTrueSuccessor(TranslatedCondition child) {
     child = getOperand() and
@@ -92,16 +88,12 @@ class TranslatedParenthesisCondition extends TranslatedFlexibleCondition {
   }
 
   final override TranslatedCondition getOperand() {
-    result = getTranslatedCondition(paren.getExpr())
+    result = getTranslatedCondition(expr.getExpr())
   }
 }
 
 class TranslatedNotCondition extends TranslatedFlexibleCondition {
-  NotExpr notExpr;
-
-  TranslatedNotCondition() {
-    notExpr = expr
-  }
+  override NotExpr expr;
 
   override Instruction getChildTrueSuccessor(TranslatedCondition child) {
     child = getOperand() and
@@ -114,7 +106,7 @@ class TranslatedNotCondition extends TranslatedFlexibleCondition {
   }
 
   override TranslatedCondition getOperand() {
-    result = getTranslatedCondition(notExpr.getOperand().getFullyConverted())
+    result = getTranslatedCondition(expr.getOperand().getFullyConverted())
   }
 }
 
@@ -131,11 +123,7 @@ abstract class TranslatedNativeCondition extends TranslatedCondition,
 
 abstract class TranslatedBinaryLogicalOperation extends
   TranslatedNativeCondition, ConditionContext {
-  BinaryLogicalOperation op;
-
-  TranslatedBinaryLogicalOperation() {
-    op = expr
-  }
+  override BinaryLogicalOperation expr;
 
   override final TranslatedElement getChild(int id) {
     id = 0 and result = getLeftOperand() or
@@ -157,17 +145,17 @@ abstract class TranslatedBinaryLogicalOperation extends
   }
 
   final TranslatedCondition getLeftOperand() {
-    result = getTranslatedCondition(op.getLeftOperand().getFullyConverted())
+    result = getTranslatedCondition(expr.getLeftOperand().getFullyConverted())
   }
 
   final TranslatedCondition getRightOperand() {
-    result = getTranslatedCondition(op.getRightOperand().getFullyConverted())
+    result = getTranslatedCondition(expr.getRightOperand().getFullyConverted())
   }
 }
 
 class TranslatedLogicalAndExpr extends TranslatedBinaryLogicalOperation {
   TranslatedLogicalAndExpr() {
-    op instanceof LogicalAndExpr
+    expr instanceof LogicalAndExpr
   }
 
   override Instruction getChildTrueSuccessor(TranslatedCondition child) {
@@ -188,9 +176,7 @@ class TranslatedLogicalAndExpr extends TranslatedBinaryLogicalOperation {
 }
 
 class TranslatedLogicalOrExpr extends TranslatedBinaryLogicalOperation {
-  TranslatedLogicalOrExpr() {
-    op instanceof LogicalOrExpr
-  }
+  override LogicalOrExpr expr;
 
   override Instruction getChildTrueSuccessor(TranslatedCondition child) {
     (child = getLeftOperand() or child = getRightOperand()) and

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

@@ -120,16 +120,12 @@ abstract class TranslatedListInitialization extends TranslatedInitialization,
 class TranslatedClassListInitialization extends
   TranslatedListInitialization
 {
-  ClassAggregateLiteral initList;
-  
-  TranslatedClassListInitialization() {
-    initList = expr
-  }
+  override ClassAggregateLiteral expr;
 
   override TranslatedElement getChild(int id) {
     exists(TranslatedFieldInitialization fieldInit |
       result = fieldInit and
-      fieldInit = getTranslatedFieldInitialization(initList, _) and
+      fieldInit = getTranslatedFieldInitialization(expr, _) and
       fieldInit.getOrder() = id
     )
   }
@@ -141,16 +137,12 @@ class TranslatedClassListInitialization extends
  */
 class TranslatedArrayListInitialization extends
   TranslatedListInitialization {
-  ArrayAggregateLiteral initList;
-
-  TranslatedArrayListInitialization() {
-    initList = expr
-  }
+  override ArrayAggregateLiteral expr;
 
   override TranslatedElement getChild(int id) {
     // The children are in initialization order
     result = rank[id + 1](TranslatedElementInitialization init |
-      init.getInitList() = initList |
+      init.getInitList() = expr |
       init order by init.getElementIndex()
     )
   }
@@ -231,9 +223,7 @@ class TranslatedSimpleDirectInitialization extends
  */
 class TranslatedStringLiteralInitialization extends
     TranslatedDirectInitialization {
-  TranslatedStringLiteralInitialization() {
-    expr instanceof StringLiteral
-  }
+  override StringLiteral expr;
 
   override predicate hasInstruction(Opcode opcode, InstructionTag tag,
       Type resultType, boolean isGLValue) {
@@ -434,11 +424,7 @@ class TranslatedStringLiteralInitialization extends
 
 class TranslatedConstructorInitialization extends
     TranslatedDirectInitialization, StructorCallContext {
-  ConstructorCall ctorCall;
-
-  TranslatedConstructorInitialization() {
-    ctorCall = expr
-  }
+  override ConstructorCall expr;
 
   override predicate hasInstruction(Opcode opcode, InstructionTag tag,
     Type resultType, boolean isGLValue) {
@@ -1008,9 +994,7 @@ TranslatedConstructorCallFromConstructor getTranslatedConstructorBaseInit(Constr
  * Represents the IR translation of a delegating constructor call from within a constructor.
  */
 class TranslatedConstructorDelegationInit extends TranslatedConstructorCallFromConstructor {
-  TranslatedConstructorDelegationInit() {
-    call instanceof ConstructorDelegationInit
-  }
+  override ConstructorDelegationInit call;
 
   override final string toString() {
     result = "delegation construct: " + call.toString()