Remove unreachable code

Primarily "break" after a return statement that
might be intended for style reasons.

Author: nschonni

src/ast.cpp

@@ -222,7 +222,6 @@ namespace Sass {
       // heads are not equal
       else return *l_h < *r_h;
     }
-    return true;
   }
 
   bool Complex_Selector::operator== (const Complex_Selector& rhs) const
@@ -326,7 +325,6 @@ namespace Sass {
     if (const Complex_Selector* cs = Cast<Complex_Selector>(&rhs)) return *this < *cs;
     if (const Compound_Selector* ch = Cast<Compound_Selector>(&rhs)) return *this < *ch;
     throw std::runtime_error("invalid selector base classes to compare");
-    return false;
   }
 
   bool Compound_Selector::operator== (const Selector& rhs) const
@@ -366,7 +364,6 @@ namespace Sass {
     if (const Complex_Selector* cs = Cast<Complex_Selector>(&rhs)) return *this < *cs;
     if (const Compound_Selector* ch = Cast<Compound_Selector>(&rhs)) return *this < *ch;
     throw std::runtime_error("invalid selector base classes to compare");
-    return false;
   }
 
   bool Simple_Selector::operator== (const Selector& rhs) const
@@ -452,8 +449,7 @@ namespace Sass {
       // advance
       ++i; ++n;
     }
-    // no mismatch
-    return true;
+    // there is no break?!
   }
 
   bool Selector_List::operator< (const Selector& rhs) const
@@ -861,8 +857,6 @@ namespace Sass {
           if (wrapped->name() == wrapped_r->name()) {
           if (wrapped->is_superselector_of(wrapped_r)) {
              continue;
-             rset.insert(lhs->to_string());
-
           }}
         }
       }
@@ -1010,8 +1004,7 @@ namespace Sass {
       // advance now
       ++i; ++n;
     }
-    // no mismatch
-    return true;
+    // there is no break?!
   }
 
   bool Complex_Selector::is_superselector_of(Compound_Selector_Obj rhs, std::string wrapping)
@@ -1091,12 +1084,7 @@ namespace Sass {
       { return false; }
       return lhs->tail()->is_superselector_of(marker->tail());
     }
-    else
-    {
-      return lhs->tail()->is_superselector_of(marker->tail());
-    }
-    // catch-all
-    return false;
+    return lhs->tail()->is_superselector_of(marker->tail());
   }
 
   size_t Complex_Selector::length() const
@@ -1353,12 +1341,7 @@ namespace Sass {
 
     }
     // has no head
-    else {
-      return this->tails(tails);
-    }
-
-    // unreachable
-    return 0;
+    return this->tails(tails);
   }
 
   Selector_List_Ptr Complex_Selector::tails(Selector_List_Ptr tails)

src/ast.hpp

@@ -1147,22 +1147,22 @@ namespace Sass {
 
   inline static const std::string sass_op_to_name(enum Sass_OP op) {
     switch (op) {
-      case AND: return "and"; break;
-      case OR: return "or"; break;
-      case EQ: return "eq"; break;
-      case NEQ: return "neq"; break;
-      case GT: return "gt"; break;
-      case GTE: return "gte"; break;
-      case LT: return "lt"; break;
-      case LTE: return "lte"; break;
-      case ADD: return "plus"; break;
-      case SUB: return "sub"; break;
-      case MUL: return "times"; break;
-      case DIV: return "div"; break;
-      case MOD: return "mod"; break;
+      case AND: return "and";
+      case OR: return "or";
+      case EQ: return "eq";
+      case NEQ: return "neq";
+      case GT: return "gt";
+      case GTE: return "gte";
+      case LT: return "lt";
+      case LTE: return "lte";
+      case ADD: return "plus";
+      case SUB: return "sub";
+      case MUL: return "times";
+      case DIV: return "div";
+      case MOD: return "mod";
       // this is only used internally!
-      case NUM_OPS: return "[OPS]"; break;
-      default: return "invalid"; break;
+      case NUM_OPS: return "[OPS]";
+      default: return "invalid";
     }
   }
 
@@ -1191,42 +1191,42 @@ namespace Sass {
     { }
     const std::string type_name() {
       switch (optype()) {
-        case AND: return "and"; break;
-        case OR: return "or"; break;
-        case EQ: return "eq"; break;
-        case NEQ: return "neq"; break;
-        case GT: return "gt"; break;
-        case GTE: return "gte"; break;
-        case LT: return "lt"; break;
-        case LTE: return "lte"; break;
-        case ADD: return "add"; break;
-        case SUB: return "sub"; break;
-        case MUL: return "mul"; break;
-        case DIV: return "div"; break;
-        case MOD: return "mod"; break;
+        case AND: return "and";
+        case OR: return "or";
+        case EQ: return "eq";
+        case NEQ: return "neq";
+        case GT: return "gt";
+        case GTE: return "gte";
+        case LT: return "lt";
+        case LTE: return "lte";
+        case ADD: return "add";
+        case SUB: return "sub";
+        case MUL: return "mul";
+        case DIV: return "div";
+        case MOD: return "mod";
         // this is only used internally!
-        case NUM_OPS: return "[OPS]"; break;
-        default: return "invalid"; break;
+        case NUM_OPS: return "[OPS]";
+        default: return "invalid";
       }
     }
     const std::string separator() {
       switch (optype()) {
-        case AND: return "&&"; break;
-        case OR: return "||"; break;
-        case EQ: return "=="; break;
-        case NEQ: return "!="; break;
-        case GT: return ">"; break;
-        case GTE: return ">="; break;
-        case LT: return "<"; break;
-        case LTE: return "<="; break;
-        case ADD: return "+"; break;
-        case SUB: return "-"; break;
-        case MUL: return "*"; break;
-        case DIV: return "/"; break;
-        case MOD: return "%"; break;
+        case AND: return "&&";
+        case OR: return "||";
+        case EQ: return "==";
+        case NEQ: return "!=";
+        case GT: return ">";
+        case GTE: return ">=";
+        case LT: return "<";
+        case LTE: return "<=";
+        case ADD: return "+";
+        case SUB: return "-";
+        case MUL: return "*";
+        case DIV: return "/";
+        case MOD: return "%";
         // this is only used internally!
-        case NUM_OPS: return "[OPS]"; break;
-        default: return "invalid"; break;
+        case NUM_OPS: return "[OPS]";
+        default: return "invalid";
       }
     }
     bool is_left_interpolant(void) const;
@@ -1294,10 +1294,10 @@ namespace Sass {
     { }
     const std::string type_name() {
       switch (optype_) {
-        case PLUS: return "plus"; break;
-        case MINUS: return "minus"; break;
-        case NOT: return "not"; break;
-        default: return "invalid"; break;
+        case PLUS: return "plus";
+        case MINUS: return "minus";
+        case NOT: return "not";
+        default: return "invalid";
       }
     }
     virtual bool operator==(const Expression& rhs) const

src/eval.cpp

@@ -604,11 +604,11 @@ namespace Sass {
     switch (op_type) {
       case Sass_OP::AND: {
         return *lhs ? b->right()->perform(this) : lhs.detach();
-      } break;
+      }
 
       case Sass_OP::OR: {
         return *lhs ? lhs.detach() : b->right()->perform(this);
-      } break;
+      }
 
       default:
         break;
@@ -1517,8 +1517,6 @@ namespace Sass {
       v->value(ops[op](lv, r.value() * r.convert_factor(l)));
       // v->normalize();
       return v.detach();
-
-      v->value(ops[op](lv, tmp.value()));
     }
     v->normalize();
     return v.detach();
@@ -1536,7 +1534,7 @@ namespace Sass {
                                ops[op](lv, r.g()),
                                ops[op](lv, r.b()),
                                r.a());
-      } break;
+      }
       case Sass_OP::SUB:
       case Sass_OP::DIV: {
         std::string sep(op == Sass_OP::SUB ? "-" : "/");
@@ -1546,10 +1544,10 @@ namespace Sass {
                                l.to_string(opt)
                                + sep
                                + color);
-      } break;
+      }
       case Sass_OP::MOD: {
         throw Exception::UndefinedOperation(&l, &r, sass_op_to_name(op));
-      } break;
+      }
       default: break; // caller should ensure that we don't get here
     }
     // unreachable

src/functions.cpp

@@ -1214,7 +1214,6 @@ namespace Sass {
       } else {
         throw Exception::InvalidArgumentType(pstate, "random", "$limit", "number");
       }
-      return 0;
     }
 
     /////////////////

src/parser.cpp

@@ -1350,7 +1350,7 @@ namespace Sass {
         case '*': operators.push_back({ Sass_OP::MUL, left_ws != 0, right_ws != 0 }); break;
         case '/': operators.push_back({ Sass_OP::DIV, left_ws != 0, right_ws != 0 }); break;
         case '%': operators.push_back({ Sass_OP::MOD, left_ws != 0, right_ws != 0 }); break;
-        default: throw std::runtime_error("unknown static op parsed"); break;
+        default: throw std::runtime_error("unknown static op parsed");
       }
       operands.push_back(parse_factor());
       left_ws = peek < css_comments >();

src/sass_context.cpp

@@ -199,7 +199,6 @@ namespace Sass {
   static int handle_errors(Sass_Context* c_ctx) {
     try { return handle_error(c_ctx); }
     catch (...) { return handle_error(c_ctx); }
-    return c_ctx->error_status;
   }
 
   static Block_Obj sass_parse_block(Sass_Compiler* compiler) throw()

src/sass_values.cpp

@@ -236,40 +236,40 @@ extern "C" {
     switch(val->unknown.tag) {
         case SASS_NULL: {
                 return sass_make_null();
-        }   break;
+        }
         case SASS_BOOLEAN: {
                 return sass_make_boolean(val->boolean.value);
-        }   break;
+        }
         case SASS_NUMBER: {
                 return sass_make_number(val->number.value, val->number.unit);
-        }   break;
+        }
         case SASS_COLOR: {
                 return sass_make_color(val->color.r, val->color.g, val->color.b, val->color.a);
-        }   break;
+        }
         case SASS_STRING: {
                 return sass_string_is_quoted(val) ? sass_make_qstring(val->string.value) : sass_make_string(val->string.value);
-        }   break;
+        }
         case SASS_LIST: {
                 union Sass_Value* list = sass_make_list(val->list.length, val->list.separator, val->list.is_bracketed);
                 for (i = 0; i < list->list.length; i++) {
                     list->list.values[i] = sass_clone_value(val->list.values[i]);
                 }
                 return list;
-        }   break;
+        }
         case SASS_MAP: {
                 union Sass_Value* map = sass_make_map(val->map.length);
                 for (i = 0; i < val->map.length; i++) {
                     map->map.pairs[i].key = sass_clone_value(val->map.pairs[i].key);
                     map->map.pairs[i].value = sass_clone_value(val->map.pairs[i].value);
                 }
                 return map;
-        }   break;
+        }
         case SASS_ERROR: {
                 return sass_make_error(val->error.message);
-        }   break;
+        }
         case SASS_WARNING: {
                 return sass_make_warning(val->warning.message);
-        }   break;
+        }
     }
 
     return 0;
@@ -349,9 +349,6 @@ extern "C" {
     catch (std::string& e) { return sass_make_error(e.c_str()); }
     catch (const char* e) { return sass_make_error(e); }
     catch (...) { return sass_make_error("unknown"); }
-
-    return 0;
-
   }
 
 }

src/to_value.cpp

@@ -9,8 +9,6 @@ namespace Sass {
     // throw a runtime error if this happens
     // we want a well defined set of possible nodes
     throw std::runtime_error("invalid node for to_value");
-    // mute warning
-    return 0;
   }
 
   // Custom_Error is a valid value