Reduce repeated code in ControllingCExpressionVisitor

Author: ibbem

src/main/java/org/variantsync/diffdetective/feature/cpp/ControllingCExpressionVisitor.java

@@ -102,95 +102,47 @@ public StringBuilder visitUnaryOperator(CExpressionParser.UnaryOperatorContext c
     //    ;
     @Override
     public StringBuilder visitNamespaceExpression(CExpressionParser.NamespaceExpressionContext ctx) {
-        if (ctx.primaryExpression().size() > 1) {
-            // primaryExpression (('*'|'/'|'%') primaryExpression)+
-            // We have to abstract the arithmetic expression if there is more than one operand
-            return ctx.accept(abstractingVisitor);
-        } else {
-            // primaryExpression
-            // There is exactly one child expression
-            return ctx.primaryExpression(0).accept(this);
-        }
+        return recurseOnSingleChild(ctx);
     }
 
     // multiplicativeExpression
     //    :   primaryExpression (('*'|'/'|'%') primaryExpression)*
     //    ;
     @Override
     public StringBuilder visitMultiplicativeExpression(CExpressionParser.MultiplicativeExpressionContext ctx) {
-        if (ctx.namespaceExpression().size() > 1) {
-            // primaryExpression (('*'|'/'|'%') primaryExpression)+
-            // We have to abstract the arithmetic expression if there is more than one operand
-            return ctx.accept(abstractingVisitor);
-        } else {
-            // primaryExpression
-            // There is exactly one child expression
-            return ctx.namespaceExpression(0).accept(this);
-        }
+        return recurseOnSingleChild(ctx);
     }
 
     // additiveExpression
     //    :   multiplicativeExpression (('+'|'-') multiplicativeExpression)*
     //    ;
     @Override
     public StringBuilder visitAdditiveExpression(CExpressionParser.AdditiveExpressionContext ctx) {
-        if (ctx.multiplicativeExpression().size() > 1) {
-            // multiplicativeExpression (('+'|'-') multiplicativeExpression)+
-            // We have to abstract the arithmetic expression if there is more than one operand
-            return ctx.accept(abstractingVisitor);
-        } else {
-            // multiplicativeExpression
-            // There is exactly one child expression
-            return ctx.multiplicativeExpression(0).accept(this);
-        }
+        return recurseOnSingleChild(ctx);
     }
 
     // shiftExpression
     //    :   additiveExpression (('<<'|'>>') additiveExpression)*
     //    ;
     @Override
     public StringBuilder visitShiftExpression(CExpressionParser.ShiftExpressionContext ctx) {
-        if (ctx.additiveExpression().size() > 1) {
-            // additiveExpression (('<<'|'>>') additiveExpression)+
-            // We have to abstract the shift expression if there is more than one operand
-            return ctx.accept(abstractingVisitor);
-        } else {
-            // additiveExpression
-            // There is exactly one child expression
-            return ctx.additiveExpression(0).accept(this);
-        }
+        return recurseOnSingleChild(ctx);
     }
 
     // relationalExpression
     //    :   shiftExpression (('<'|'>'|'<='|'>=') shiftExpression)*
     //    ;
     @Override
     public StringBuilder visitRelationalExpression(CExpressionParser.RelationalExpressionContext ctx) {
-        if (ctx.shiftExpression().size() > 1) {
-            // shiftExpression (('<'|'>'|'<='|'>=') shiftExpression)+
-            // We have to abstract the relational expression if there is more than one operand
-            return ctx.accept(abstractingVisitor);
-        } else {
-            // shiftExpression
-            // There is exactly one child expression
-            return ctx.shiftExpression(0).accept(this);
-        }
+        return recurseOnSingleChild(ctx);
     }
 
     // equalityExpression
     //    :   relationalExpression (('=='| '!=') relationalExpression)*
     //    ;
     @Override
     public StringBuilder visitEqualityExpression(CExpressionParser.EqualityExpressionContext ctx) {
-        if (ctx.relationalExpression().size() > 1) {
-            // relationalExpression (('=='| '!=') relationalExpression)+
-            // We have to abstract the equality expression if there is more than one operand
-            return ctx.accept(abstractingVisitor);
-        } else {
-            // relationalExpression
-            // There is exactly one child expression
-            return ctx.relationalExpression(0).accept(this);
-        }
+        return recurseOnSingleChild(ctx);
     }
 
     // specialOperator
@@ -268,61 +220,31 @@ public StringBuilder visitAssignmentOperator(CExpressionParser.AssignmentOperato
     //    ;
     @Override
     public StringBuilder visitExpression(CExpressionParser.ExpressionContext ctx) {
-        if (ctx.assignmentExpression().size() > 1) {
-            // assignmentExpression (',' assignmentExpression)+
-            return ctx.accept(abstractingVisitor);
-        } else {
-            // assignmentExpression
-            return ctx.assignmentExpression(0).accept(this);
-        }
+        return recurseOnSingleChild(ctx);
     }
 
     // andExpression
     //    :   equalityExpression ( '&' equalityExpression)*
     //    ;
     @Override
     public StringBuilder visitAndExpression(CExpressionParser.AndExpressionContext ctx) {
-        if (ctx.equalityExpression().size() > 1) {
-            // equalityExpression ( '&' equalityExpression)+
-            // We have to abstract the 'and' expression if there is more than one operand
-            return ctx.accept(abstractingVisitor);
-        } else {
-            // equalityExpression
-            // There is exactly one child expression
-            return ctx.equalityExpression(0).accept(this);
-        }
+        return recurseOnSingleChild(ctx);
     }
 
     // exclusiveOrExpression
     //    :   andExpression ('^' andExpression)*
     //    ;
     @Override
     public StringBuilder visitExclusiveOrExpression(CExpressionParser.ExclusiveOrExpressionContext ctx) {
-        if (ctx.andExpression().size() > 1) {
-            // andExpression ('^' andExpression)+
-            // We have to abstract the xor expression if there is more than one operand
-            return ctx.accept(abstractingVisitor);
-        } else {
-            // andExpression
-            // There is exactly one child expression
-            return ctx.andExpression(0).accept(this);
-        }
+        return recurseOnSingleChild(ctx);
     }
 
     // inclusiveOrExpression
     //    :   exclusiveOrExpression ('|' exclusiveOrExpression)*
     //    ;
     @Override
     public StringBuilder visitInclusiveOrExpression(CExpressionParser.InclusiveOrExpressionContext ctx) {
-        if (ctx.exclusiveOrExpression().size() > 1) {
-            // exclusiveOrExpression ('|' exclusiveOrExpression)+
-            // We have to abstract the 'or' expression if there is more than one operand
-            return ctx.accept(abstractingVisitor);
-        } else {
-            // exclusiveOrExpression
-            // There is exactly one child expression
-            return ctx.exclusiveOrExpression(0).accept(this);
-        }
+        return recurseOnSingleChild(ctx);
     }
 
     // logicalAndExpression
@@ -365,4 +287,14 @@ private StringBuilder visitLogicalExpression(ParserRuleContext expressionContext
         }
         return sb;
     }
-}
+
+    private StringBuilder recurseOnSingleChild(ParserRuleContext ctx) {
+        if (ctx.getChildCount() > 1) {
+            // We have to abstract the expression if there is more than one operand
+            return ctx.accept(abstractingVisitor);
+        } else {
+            // There is exactly one child expression so we recurse
+            return ctx.getChild(0).accept(this);
+        }
+    }
+}