int lang_struct_rc_1(int i){
    if (i > 0){                                // ok: i>0 can be either true or false
        if (i+1 > 1){           // 'Redundant Condition' warning issued here: 
                                //  if execution reaches this point, i+1>0 is true
      return i;
    }
  }
  return 0;
}

enum color { BLUE, RED, YELLOW };

bool process_bools(bool x, bool y){
  return x && y;
}

bool lang_struct_rc_2(bool doNegate, bool andArg){
    color colA = BLUE;
    color colB = RED;
    if (doNegate){                             // ok: doNegate can be either true or false
        return (bool)colA;              // 'Redundant Condition' warning issued here: 
                                        //     return (bool)colA; 
                                        // is normalized to the form
                                        //     if (colA != 0)
                                        //         TMP=true;
                                        //     else
                                        //         TMP=false;
                                        //     return TMP;
                                        // and (colA != 0) is always true
                                        // 
                                        // While the IF statement cited in the resulting warning report is not explicitly present
                                        // in the code, the warning does signal the presence of redundancy:
                                        //     (bool)colA
                                        // is functionally equivalent to 
                                        //     false
                                        // so neither the cast operation nor the colA variable is actually required.
    }
    return process_bools(colB, andArg); // 'Redundant Condition' warning issued here: 
                                        // negate(colB) coerces colB to bool, and this coercion is similarly
                                        // normalized to an IF expression whose condition is (colB != 0)
                                        // 
                                        // While the IF statement cited in the resulting warning report is not explicitly present
                                        // in the code, the warning does signal the presence of redundancy:
                                        //     process_bools(colB, andArg)
                                        // is functionally equivalent to 
                                        //     process_bools(true, andArg)
                                        // so the colB variable isn't required either.
}