Merge pull request #1347 from mgreter/feature/code-cleanup

Some more code cleanups I have missed

Author: xzyfer

eval.cpp

@@ -497,12 +497,12 @@ namespace Sass {
 
     // see if it's a relational expression
     switch(op_type) {
-      case Sass_OP::EQ:  return new (ctx.mem) Boolean(b->pstate(), eq(lhs, rhs, ctx));
-      case Sass_OP::NEQ: return new (ctx.mem) Boolean(b->pstate(), !eq(lhs, rhs, ctx));
-      case Sass_OP::GT:  return new (ctx.mem) Boolean(b->pstate(), !lt(lhs, rhs, ctx) && !eq(lhs, rhs, ctx));
-      case Sass_OP::GTE: return new (ctx.mem) Boolean(b->pstate(), !lt(lhs, rhs, ctx));
-      case Sass_OP::LT:  return new (ctx.mem) Boolean(b->pstate(), lt(lhs, rhs, ctx));
-      case Sass_OP::LTE: return new (ctx.mem) Boolean(b->pstate(), lt(lhs, rhs, ctx) || eq(lhs, rhs, ctx));
+      case Sass_OP::EQ:  return new (ctx.mem) Boolean(b->pstate(), eq(lhs, rhs));
+      case Sass_OP::NEQ: return new (ctx.mem) Boolean(b->pstate(), !eq(lhs, rhs));
+      case Sass_OP::GT:  return new (ctx.mem) Boolean(b->pstate(), !lt(lhs, rhs) && !eq(lhs, rhs));
+      case Sass_OP::GTE: return new (ctx.mem) Boolean(b->pstate(), !lt(lhs, rhs));
+      case Sass_OP::LT:  return new (ctx.mem) Boolean(b->pstate(), lt(lhs, rhs));
+      case Sass_OP::LTE: return new (ctx.mem) Boolean(b->pstate(), lt(lhs, rhs) || eq(lhs, rhs));
 
       default:                     break;
     }
@@ -1065,7 +1065,7 @@ namespace Sass {
 
   // All the binary helpers.
 
-  bool Eval::eq(Expression* lhs, Expression* rhs, Context& ctx)
+  bool Eval::eq(Expression* lhs, Expression* rhs)
   {
     Expression::Concrete_Type ltype = lhs->concrete_type();
     Expression::Concrete_Type rtype = rhs->concrete_type();
@@ -1107,7 +1107,7 @@ namespace Sass {
         if (l->length() != r->length()) return false;
         if (l->separator() != r->separator()) return false;
         for (size_t i = 0, L = l->length(); i < L; ++i) {
-          if (!eq((*l)[i], (*r)[i], ctx)) return false;
+          if (!eq((*l)[i], (*r)[i])) return false;
         }
         return true;
       } break;
@@ -1117,7 +1117,7 @@ namespace Sass {
         Map* r = static_cast<Map*>(rhs);
         if (l->length() != r->length()) return false;
         for (auto key : l->keys())
-          if (!eq(l->at(key), r->at(key), ctx)) return false;
+          if (!eq(l->at(key), r->at(key))) return false;
         return true;
       } break;
       case Expression::NULL_VAL: {
@@ -1129,7 +1129,7 @@ namespace Sass {
     return false;
   }
 
-  bool Eval::lt(Expression* lhs, Expression* rhs, Context& ctx)
+  bool Eval::lt(Expression* lhs, Expression* rhs)
   {
     if (lhs->concrete_type() != Expression::NUMBER ||
         rhs->concrete_type() != Expression::NUMBER)

eval.hpp

@@ -86,8 +86,8 @@ namespace Sass {
     Expression* fallback(U x) { return fallback_impl(x); }
 
     // -- only need to define two comparisons, and the rest can be implemented in terms of them
-    static bool eq(Expression*, Expression*, Context&);
-    static bool lt(Expression*, Expression*, Context&);
+    static bool eq(Expression*, Expression*);
+    static bool lt(Expression*, Expression*);
     // -- arithmetic on the combinations that matter
     static Expression* op_numbers(Context&, enum Sass_OP, Number*, Number*);
     static Expression* op_number_color(Context&, enum Sass_OP, Number*, Color*);

functions.cpp

@@ -1077,7 +1077,7 @@ namespace Sass {
         Number* xi = dynamic_cast<Number*>(arglist->value_at_index(i));
         if (!xi) error("`" + string(sig) + "` only takes numeric arguments", pstate);
         if (least) {
-          if (Eval::lt(xi, least, ctx)) least = xi;
+          if (Eval::lt(xi, least)) least = xi;
         } else least = xi;
       }
       return least;
@@ -1092,7 +1092,7 @@ namespace Sass {
         Number* xi = dynamic_cast<Number*>(arglist->value_at_index(i));
         if (!xi) error("`" + string(sig) + "` only takes numeric arguments", pstate);
         if (greatest) {
-          if (Eval::lt(greatest, xi, ctx)) greatest = xi;
+          if (Eval::lt(greatest, xi)) greatest = xi;
         } else greatest = xi;
       }
       return greatest;
@@ -1202,7 +1202,7 @@ namespace Sass {
         *l << ARG("$list", Expression);
       }
       for (size_t i = 0, L = l->length(); i < L; ++i) {
-        if (Eval::eq(l->value_at_index(i), v, ctx)) return new (ctx.mem) Number(pstate, i+1);
+        if (Eval::eq(l->value_at_index(i), v)) return new (ctx.mem) Number(pstate, i+1);
       }
       return new (ctx.mem) Null(pstate);
     }
@@ -1377,7 +1377,7 @@ namespace Sass {
       for (auto key : m->keys()) {
         remove = false;
         for (size_t j = 0, K = arglist->length(); j < K && !remove; ++j) {
-          remove = Eval::eq(key, arglist->value_at_index(j), ctx);
+          remove = Eval::eq(key, arglist->value_at_index(j));
         }
         if (!remove) *result << make_pair(key, m->at(key));
       }

listize.cpp

@@ -78,13 +78,9 @@ namespace Sass {
     return l;
   }
 
-  Expression* Listize::operator()(Parent_Selector* sel)
-  {
-    return 0;
-  }
-
   Expression* Listize::fallback_impl(AST_Node* n)
   {
-    return static_cast<Expression*>(n);
+    return dynamic_cast<Expression*>(n);
   }
+
 }

listize.hpp

@@ -30,7 +30,6 @@ namespace Sass {
     Expression* operator()(Selector_List*);
     Expression* operator()(Complex_Selector*);
     Expression* operator()(Compound_Selector*);
-    Expression* operator()(Parent_Selector*);
 
     template <typename U>
     Expression* fallback(U x) { return fallback_impl(x); }