sassc 1.11.4 → 1.12.0

data/ext/libsass/script/ci-build-libsass

@@ -18,9 +18,14 @@ if [ "x$TRAVIS_OS_NAME" == "x" ]; then export TRAVIS_OS_NAME=`uname -s | perl -n
 
 if [ "x$COVERAGE" == "xyes" ]; then
   COVERAGE_OPT="--enable-coverage"
-  export EXTRA_CFLAGS="--coverage"
-  export EXTRA_CXXFLAGS="--coverage"
-  export EXTRA_LDFLAGS="--coverage"
+  export EXTRA_CFLAGS="-fprofile-arcs -ftest-coverage"
+  export EXTRA_CXXFLAGS="-fprofile-arcs -ftest-coverage"
+  if [ "$TRAVIS_OS_NAME" == "osx" ]; then
+    # osx doesn't seem to know gcov lib?
+    export EXTRA_LDFLAGS="--coverage"
+  else
+    export EXTRA_LDFLAGS="-lgcov --coverage"
+  fi
 else
   COVERAGE_OPT="--disable-coverage"
 fi
@@ -37,7 +42,7 @@ fi
 if [ "$(expr substr $(uname -s) 1 10)" == "MINGW32_NT" ]; then
   MAKE_OPTS="$MAKE_OPTS -j1 V=1"
 else
-  MAKE_OPTS="$MAKE_OPTS -j3 V=1"
+  MAKE_OPTS="$MAKE_OPTS -j5 V=1"
 fi
 
 if [ "x$PREFIX" == "x" ]; then
@@ -109,7 +114,7 @@ then
   then
     echo "Travis rate limit on github exceeded"
     echo "Retrying via 'special purpose proxy'"
-    JSON=$(curl -L -sS http://libsass.ocbnet.ch/libsass-spec-pr.psgi/$TRAVIS_PULL_REQUEST)
+    JSON=$(curl -L -sS https://github-api-reverse-proxy.herokuapp.com/repos/sass/libsass/pulls/$TRAVIS_PULL_REQUEST)
   fi
 
   RE_SPEC_PR="sass\/sass-spec(#|\/pull\/)([0-9]+)"

data/ext/libsass/script/ci-build-plugin

@@ -0,0 +1,62 @@
+#!/bin/bash
+
+PLUGIN=$1
+RUBY_BIN=ruby
+SASS_SPEC_PATH=sass-spec
+SASSC_BIN=sassc/bin/sassc
+SASS_SPEC_SPEC_DIR=plugins/libsass-${PLUGIN}/test
+
+if [ -e ./tester ] ; then
+  SASSC_BIN=./tester
+fi
+
+if [ -d ./build/lib ] ; then
+  cp -a build/lib lib
+fi
+
+if [ "x$1" == "x" ] ; then
+  echo "No plugin name given"
+  exit 1
+fi
+
+if [ "x$COVERAGE" == "0" ] ; then
+  unset COVERAGE
+fi
+
+export EXTRA_CFLAGS=""
+export EXTRA_CXXFLAGS=""
+if [ "$TRAVIS_OS_NAME" == "osx" ]; then
+  # osx doesn't seem to know gcov lib?
+  export EXTRA_LDFLAGS="--coverage"
+else
+  export EXTRA_LDFLAGS="-lgcov --coverage"
+fi
+
+mkdir -p plugins
+if [ ! -d plugins/libsass-${PLUGIN} ] ; then
+  git clone https://github.com/mgreter/libsass-${PLUGIN} plugins/libsass-${PLUGIN}
+fi
+if [ ! -d plugins/libsass-${PLUGIN}/build ] ; then
+  mkdir plugins/libsass-${PLUGIN}/build
+fi
+RETVAL=$?; if [ "$RETVAL" != "0" ]; then exit $RETVAL; fi
+
+cd plugins/libsass-${PLUGIN}/build
+cmake -G "Unix Makefiles" -D LIBSASS_DIR="../../.." ..
+RETVAL=$?; if [ "$RETVAL" != "0" ]; then exit $RETVAL; fi
+make VERBOSE=1 -j2
+RETVAL=$?; if [ "$RETVAL" != "0" ]; then exit $RETVAL; fi
+cd ../../..
+
+# glob only works on paths relative to imports
+if [ "x$PLUGIN" == "xglob" ]; then
+  ${SASSC_BIN} --plugin-path plugins/libsass-${PLUGIN}/build ${SASS_SPEC_SPEC_DIR}/basic/input.scss > ${SASS_SPEC_SPEC_DIR}/basic/result.css
+  ${SASSC_BIN} --plugin-path plugins/libsass-${PLUGIN}/build ${SASS_SPEC_SPEC_DIR}/basic/input.scss --sourcemap > /dev/null
+else
+  cat ${SASS_SPEC_SPEC_DIR}/basic/input.scss | ${SASSC_BIN} --plugin-path plugins/libsass-${PLUGIN}/build -I ${SASS_SPEC_SPEC_DIR}/basic > ${SASS_SPEC_SPEC_DIR}/basic/result.css
+  cat ${SASS_SPEC_SPEC_DIR}/basic/input.scss | ${SASSC_BIN} --plugin-path plugins/libsass-${PLUGIN}/build -I ${SASS_SPEC_SPEC_DIR}/basic --sourcemap > /dev/null
+fi
+RETVAL=$?; if [ "$RETVAL" != "0" ]; then exit $RETVAL; fi
+
+diff ${SASS_SPEC_SPEC_DIR}/basic/expected_output.css ${SASS_SPEC_SPEC_DIR}/basic/result.css
+RETVAL=$?; if [ "$RETVAL" != "0" ]; then exit $RETVAL; fi

data/ext/libsass/script/ci-install-compiler

@@ -3,4 +3,4 @@
 gem install minitest
 gem install minitap
 
-pip install --user 'requests[security]'
+pip2 install --user 'requests[security]'

data/ext/libsass/script/ci-install-deps

@@ -1,7 +1,7 @@
 #!/bin/bash
 if [ "x$COVERAGE" == "xyes" ]; then
-  pip install --user gcovr
-  pip install --user cpp-coveralls
+  pip2 install --user gcovr
+  pip2 install --user cpp-coveralls
 else
   echo "no dependencies to install"
 fi
@@ -15,9 +15,6 @@ if [ "x$AUTOTOOLS" == "xyes" ]; then
     sudo apt-get -qq install automake
   fi
 
-  # https://github.com/sass/libsass/pull/2183
-  if [ "$TRAVIS_OS_NAME" == "osx" ]; then
-    brew uninstall libtool
-    brew install libtool
-  fi
 fi
+
+exit 0

data/ext/libsass/script/ci-report-coverage

@@ -2,6 +2,12 @@
 
 if [ "x$COVERAGE" = "xyes" ]; then
 
+  # find / -name "gcovr"
+  # find / -name "coveralls"
+  # this is only needed for mac os x builds!
+  PATH=$PATH:/Users/travis/Library/Python/2.7/bin/
+
+
   # exclude some directories from profiling (.libs is from autotools)
   export EXCLUDE_COVERAGE="--exclude plugins
                            --exclude sassc/sassc.c
@@ -21,10 +27,14 @@ if [ "x$COVERAGE" = "xyes" ]; then
                            --exclude src/test
                            --exclude src/posix
                            --exclude src/debugger.hpp"
-  # debug via gcovr
-  gcov -v
+  # debug used gcov version
+  # option not available on mac
+  if [ "$TRAVIS_OS_NAME" != "osx" ]; then
+    gcov -v
+  fi
+  # create summarized report
   gcovr -r .
-  # generate and submit report to coveralls.io
+  # submit report to coveralls.io
   coveralls $EXCLUDE_COVERAGE --gcov-options '\-lp'
 
 else

data/ext/libsass/script/tap-driver

@@ -1,4 +1,4 @@
-#! /bin/sh
+#!/usr/bin/env sh
 # Copyright (C) 2011-2013 Free Software Foundation, Inc.
 #
 # This program is free software; you can redistribute it and/or modify

data/ext/libsass/script/tap-runner

@@ -1 +1 @@
-$@ | tapout tap
+$@ $TEST_FLAGS --tap --silent | tapout tap

data/ext/libsass/src/GNUmakefile.am

@@ -34,7 +34,7 @@ include $(top_srcdir)/Makefile.conf
 
 libsass_la_SOURCES = ${CSOURCES} ${SOURCES}
 
-libsass_la_LDFLAGS = $(AM_LDFLAGS) -no-undefined -version-info 0:9:0
+libsass_la_LDFLAGS = $(AM_LDFLAGS) -no-undefined -version-info 1:0:0
 
 if ENABLE_TESTS
 if ENABLE_COVERAGE

data/ext/libsass/src/ast.cpp

@@ -2,6 +2,7 @@
 #include "ast.hpp"
 #include "context.hpp"
 #include "node.hpp"
+#include "eval.hpp"
 #include "extend.hpp"
 #include "emitter.hpp"
 #include "color_maps.hpp"
@@ -18,80 +19,73 @@ namespace Sass {
 
   static Null sass_null(ParserState("null"));
 
-  bool Supports_Operator::needs_parens(Supports_Condition_Obj cond) const {
-    if (Supports_Operator_Obj op = SASS_MEMORY_CAST(Supports_Operator, cond)) {
-      return op->operand() != operand();
+  bool Wrapped_Selector::find ( bool (*f)(AST_Node_Obj) )
+  {
+    // check children first
+    if (selector_) {
+      if (selector_->find(f)) return true;
     }
-    return SASS_MEMORY_CAST(Supports_Negation, cond) != NULL;
-  }
-
-  bool Supports_Negation::needs_parens(Supports_Condition_Obj cond) const {
-    return SASS_MEMORY_CAST(Supports_Negation, cond) ||
-           SASS_MEMORY_CAST(Supports_Operator, cond);
+    // execute last
+    return f(this);
   }
 
-  size_t HashExpression::operator() (Expression_Obj ex) const {
-    return ex ? ex->hash() : 0;
+  bool Selector_List::find ( bool (*f)(AST_Node_Obj) )
+  {
+    // check children first
+    for (Complex_Selector_Obj sel : elements()) {
+      if (sel->find(f)) return true;
+    }
+    // execute last
+    return f(this);
   }
 
-  size_t HashSimpleSelector::operator() (Simple_Selector_Obj ex) const {
-    return ex ? ex->hash() : 0;
+  bool Compound_Selector::find ( bool (*f)(AST_Node_Obj) )
+  {
+    // check children first
+    for (Simple_Selector_Obj sel : elements()) {
+      if (sel->find(f)) return true;
+    }
+    // execute last
+    return f(this);
   }
 
-
-  bool CompareExpression::operator()(const Expression_Obj& lhs, const Expression_Obj& rhs) const {
-    return lhs && rhs && lhs->eq(*rhs);
+  bool Complex_Selector::find ( bool (*f)(AST_Node_Obj) )
+  {
+    // check children first
+    if (head_ && head_->find(f)) return true;
+    if (tail_ && tail_->find(f)) return true;
+    // execute last
+    return f(this);
   }
 
-  bool CompareSimpleSelector::operator()(Simple_Selector_Obj lhs, Simple_Selector_Obj rhs) const {
-    return &lhs && &rhs && *lhs == *rhs;
+  bool Supports_Operator::needs_parens(Supports_Condition_Obj cond) const {
+    if (Supports_Operator_Obj op = Cast<Supports_Operator>(cond)) {
+      return op->operand() != operand();
+    }
+    return Cast<Supports_Negation>(cond) != NULL;
   }
 
-  std::string & str_ltrim(std::string & str)
-  {
-    auto it2 =  std::find_if( str.begin() , str.end() , [](char ch){ return !std::isspace<char>(ch , std::locale::classic() ) ; } );
-    str.erase( str.begin() , it2);
-    return str;
+  bool Supports_Negation::needs_parens(Supports_Condition_Obj cond) const {
+    return Cast<Supports_Negation>(cond) ||
+           Cast<Supports_Operator>(cond);
   }
 
-  std::string & str_rtrim(std::string & str)
+  void str_rtrim(std::string& str, const std::string& delimiters = " \f\n\r\t\v")
   {
-    auto it1 =  std::find_if( str.rbegin() , str.rend() , [](char ch){ return !std::isspace<char>(ch , std::locale::classic() ) ; } );
-    str.erase( it1.base() , str.end() );
-    return str;
+    str.erase( str.find_last_not_of( delimiters ) + 1 );
   }
 
   void String_Constant::rtrim()
   {
-    value_ = str_rtrim(value_);
-  }
-  void String_Constant::ltrim()
-  {
-    value_ = str_ltrim(value_);
-  }
-  void String_Constant::trim()
-  {
-    rtrim();
-    ltrim();
+    str_rtrim(value_);
   }
 
   void String_Schema::rtrim()
   {
     if (!empty()) {
-      if (String_Ptr str = SASS_MEMORY_CAST(String, last())) str->rtrim();
+      if (String_Ptr str = Cast<String>(last())) str->rtrim();
     }
   }
-  void String_Schema::ltrim()
-  {
-    if (!empty()) {
-      if (String_Ptr str = SASS_MEMORY_CAST(String, first())) str->ltrim();
-    }
-  }
-  void String_Schema::trim()
-  {
-    rtrim();
-    ltrim();
-  }
 
   void Argument::set_delayed(bool delayed)
   {
@@ -111,7 +105,7 @@ namespace Sass {
   bool At_Root_Query::exclude(std::string str)
   {
     bool with = feature() && unquote(feature()->to_string()).compare("with") == 0;
-    List_Ptr l = static_cast<List_Ptr>(&value());
+    List_Ptr l = static_cast<List_Ptr>(value().ptr());
     std::string v;
 
     if (with)
@@ -141,21 +135,20 @@ namespace Sass {
     pstate_.offset += pstate - pstate_ + pstate.offset;
   }
 
-  void AST_Node::set_pstate_offset(const Offset& offset)
-  {
-    pstate_.offset = offset;
-  }
-
-  inline bool is_ns_eq(const std::string& l, const std::string& r)
+  bool Simple_Selector::is_ns_eq(const Simple_Selector& r) const
   {
-    if (l.empty() && r.empty()) return true;
-    else if (l.empty() && r == "*") return true;
-    else if (r.empty() && l == "*") return true;
-    else return l == r;
+    // https://github.com/sass/sass/issues/2229
+    if ((has_ns_ == r.has_ns_) ||
+        (has_ns_ && ns_.empty()) ||
+        (r.has_ns_ && r.ns_.empty())
+    ) {
+      if (ns_.empty() && r.ns() == "*") return false;
+      else if (r.ns().empty() && ns() == "*") return false;
+      else return ns() == r.ns();
+    }
+    return false;
   }
 
-
-
   bool Compound_Selector::operator< (const Compound_Selector& rhs) const
   {
     size_t L = std::min(length(), rhs.length());
@@ -173,7 +166,7 @@ namespace Sass {
     return length() < rhs.length();
   }
 
-  bool Compound_Selector::has_parent_ref()
+  bool Compound_Selector::has_parent_ref() const
   {
     for (Simple_Selector_Obj s : *this) {
       if (s && s->has_parent_ref()) return true;
@@ -181,7 +174,7 @@ namespace Sass {
     return false;
   }
 
-  bool Compound_Selector::has_real_parent_ref()
+  bool Compound_Selector::has_real_parent_ref() const
   {
     for (Simple_Selector_Obj s : *this) {
       if (s && s->has_real_parent_ref()) return true;
@@ -189,13 +182,13 @@ namespace Sass {
     return false;
   }
 
-  bool Complex_Selector::has_parent_ref()
+  bool Complex_Selector::has_parent_ref() const
   {
     return (head() && head()->has_parent_ref()) ||
            (tail() && tail()->has_parent_ref());
   }
 
-  bool Complex_Selector::has_real_parent_ref()
+  bool Complex_Selector::has_real_parent_ref() const
   {
     return (head() && head()->has_real_parent_ref()) ||
            (tail() && tail()->has_real_parent_ref());
@@ -206,25 +199,31 @@ namespace Sass {
     // const iterators for tails
     Complex_Selector_Ptr_Const l = this;
     Complex_Selector_Ptr_Const r = &rhs;
-    Compound_Selector_Ptr l_h = l ? &l->head() : 0;
-    Compound_Selector_Ptr r_h = r ? &r->head() : 0;
+    Compound_Selector_Ptr l_h = NULL;
+    Compound_Selector_Ptr r_h = NULL;
+    if (l) l_h = l->head();
+    if (r) r_h = r->head();
     // process all tails
     while (true)
     {
+      #ifdef DEBUG
       // skip empty ancestor first
       if (l && l->is_empty_ancestor())
       {
-        l = &l->tail();
-        l_h = l ? &l->head() : 0;
+        l_h = NULL;
+        l = l->tail();
+        if(l) l_h = l->head();
         continue;
       }
       // skip empty ancestor first
       if (r && r->is_empty_ancestor())
       {
-        r = &r->tail();
-        r_h = r ? &r->head() : 0;
+        r_h = NULL;
+        r = r->tail();
+        if (r) r_h = r->head();
         continue;
       }
+      #endif
       // check for valid selectors
       if (!l) return !!r;
       if (!r) return false;
@@ -235,11 +234,12 @@ namespace Sass {
         if (l->combinator() != r->combinator())
         { return l->combinator() < r->combinator(); }
         // advance to next tails
-        l = &l->tail();
-        r = &r->tail();
+        l = l->tail();
+        r = r->tail();
         // fetch the next headers
-        l_h = l ? &l->head() : 0;
-        r_h = r ? &r->head() : 0;
+        l_h = NULL; r_h = NULL;
+        if (l) l_h = l->head();
+        if (r) r_h = r->head();
       }
       // one side is null
       else if (!r_h) return true;
@@ -251,16 +251,16 @@ namespace Sass {
         if (l->combinator() != r->combinator())
         { return l->combinator() < r->combinator(); }
         // advance to next tails
-        l = &l->tail();
-        r = &r->tail();
+        l = l->tail();
+        r = r->tail();
         // fetch the next headers
-        l_h = l ? &l->head() : 0;
-        r_h = r ? &r->head() : 0;
+        l_h = NULL; r_h = NULL;
+        if (l) l_h = l->head();
+        if (r) r_h = r->head();
       }
       // heads are not equal
       else return *l_h < *r_h;
     }
-    return true;
   }
 
   bool Complex_Selector::operator== (const Complex_Selector& rhs) const
@@ -268,25 +268,31 @@ namespace Sass {
     // const iterators for tails
     Complex_Selector_Ptr_Const l = this;
     Complex_Selector_Ptr_Const r = &rhs;
-    Compound_Selector_Ptr l_h = l ? &l->head() : 0;
-    Compound_Selector_Ptr r_h = r ? &r->head() : 0;
+    Compound_Selector_Ptr l_h = NULL;
+    Compound_Selector_Ptr r_h = NULL;
+    if (l) l_h = l->head();
+    if (r) r_h = r->head();
     // process all tails
     while (true)
     {
+      #ifdef DEBUG
       // skip empty ancestor first
       if (l && l->is_empty_ancestor())
       {
-        l = &l->tail();
-        l_h = l ? &l->head() : 0;
+        l_h = NULL;
+        l = l->tail();
+        if (l) l_h = l->head();
         continue;
       }
       // skip empty ancestor first
       if (r && r->is_empty_ancestor())
       {
-        r = &r->tail();
-        r_h = r ? &r->head() : 0;
+        r_h = NULL;
+        r = r->tail();
+        if (r) r_h = r->head();
         continue;
       }
+      #endif
       // check the pointers
       if (!r) return !l;
       if (!l) return !r;
@@ -297,27 +303,29 @@ namespace Sass {
         if (l->combinator() != r->combinator())
         { return l->combinator() < r->combinator(); }
         // advance to next tails
-        l = &l->tail();
-        r = &r->tail();
+        l = l->tail();
+        r = r->tail();
         // fetch the next heads
-        l_h = l ? &l->head() : 0;
-        r_h = r ? &r->head() : 0;
+        l_h = NULL; r_h = NULL;
+        if (l) l_h = l->head();
+        if (r) r_h = r->head();
       }
       // equals if other head is empty
       else if ((!l_h && !r_h) ||
                (!l_h && r_h->empty()) ||
                (!r_h && l_h->empty()) ||
-               (*l_h == *r_h))
+               (l_h && r_h && *l_h == *r_h))
       {
         // check combinator after heads
         if (l->combinator() != r->combinator())
         { return l->combinator() == r->combinator(); }
         // advance to next tails
-        l = &l->tail();
-        r = &r->tail();
+        l = l->tail();
+        r = r->tail();
         // fetch the next heads
-        l_h = l ? &l->head() : 0;
-        r_h = r ? &r->head() : 0;
+        l_h = NULL; r_h = NULL;
+        if (l) l_h = l->head();
+        if (r) r_h = r->head();
       }
       // abort
       else break;
@@ -326,78 +334,105 @@ namespace Sass {
     return false;
   }
 
-  Compound_Selector_Ptr Compound_Selector::unify_with(Compound_Selector_Ptr rhs, Context& ctx)
+  Compound_Selector_Ptr Compound_Selector::unify_with(Compound_Selector_Ptr rhs)
   {
     if (empty()) return rhs;
     Compound_Selector_Obj unified = SASS_MEMORY_COPY(rhs);
     for (size_t i = 0, L = length(); i < L; ++i)
     {
       if (unified.isNull()) break;
-      unified = at(i)->unify_with(&unified, ctx);
+      unified = at(i)->unify_with(unified);
     }
     return unified.detach();
   }
 
-  bool Selector::operator== (const Selector& rhs) const
+  bool Complex_Selector::operator== (const Selector& rhs) const
   {
-    if (Selector_List_Ptr_Const sl = dynamic_cast<Selector_List_Ptr_Const>(this)) return *sl == rhs;
-    if (Simple_Selector_Ptr_Const sp = dynamic_cast<Simple_Selector_Ptr_Const>(this)) return *sp == rhs;
+    if (const Selector_List* sl = Cast<Selector_List>(&rhs)) return *this == *sl;
+    if (const Simple_Selector* sp = Cast<Simple_Selector>(&rhs)) return *this == *sp;
+    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 Selector::operator< (const Selector& rhs) const
+
+  bool Complex_Selector::operator< (const Selector& rhs) const
   {
-    if (Selector_List_Ptr_Const sl = dynamic_cast<Selector_List_Ptr_Const>(this)) return *sl < rhs;
-    if (Simple_Selector_Ptr_Const sp = dynamic_cast<Simple_Selector_Ptr_Const>(this)) return *sp < rhs;
+    if (const Selector_List* sl = Cast<Selector_List>(&rhs)) return *this < *sl;
+    if (const Simple_Selector* sp = Cast<Simple_Selector>(&rhs)) return *this < *sp;
+    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");
+  }
+
+  bool Compound_Selector::operator== (const Selector& rhs) const
+  {
+    if (const Selector_List* sl = Cast<Selector_List>(&rhs)) return *this == *sl;
+    if (const Simple_Selector* sp = Cast<Simple_Selector>(&rhs)) return *this == *sp;
+    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");
+  }
+
+  bool Compound_Selector::operator< (const Selector& rhs) const
+  {
+    if (const Selector_List* sl = Cast<Selector_List>(&rhs)) return *this < *sl;
+    if (const Simple_Selector* sp = Cast<Simple_Selector>(&rhs)) return *this < *sp;
+    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");
+  }
+
+  bool Selector_Schema::operator== (const Selector& rhs) const
+  {
+    if (const Selector_List* sl = Cast<Selector_List>(&rhs)) return *this == *sl;
+    if (const Simple_Selector* sp = Cast<Simple_Selector>(&rhs)) return *this == *sp;
+    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");
+  }
+
+  bool Selector_Schema::operator< (const Selector& rhs) const
+  {
+    if (const Selector_List* sl = Cast<Selector_List>(&rhs)) return *this < *sl;
+    if (const Simple_Selector* sp = Cast<Simple_Selector>(&rhs)) return *this < *sp;
+    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
   {
-    if (Simple_Selector_Ptr_Const sp = dynamic_cast<Simple_Selector_Ptr_Const>(&rhs)) return *this == *sp;
+    if (Simple_Selector_Ptr_Const sp = Cast<Simple_Selector>(&rhs)) return *this == *sp;
     return false;
   }
 
   bool Simple_Selector::operator< (const Selector& rhs) const
   {
-    if (Simple_Selector_Ptr_Const sp = dynamic_cast<Simple_Selector_Ptr_Const>(&rhs)) return *this < *sp;
+    if (Simple_Selector_Ptr_Const sp = Cast<Simple_Selector>(&rhs)) return *this < *sp;
     return false;
   }
 
   bool Simple_Selector::operator== (const Simple_Selector& rhs) const
   {
-    Simple_Type type = simple_type();
-    // dynamic cast is a bottleneck - use concrete type as types are final
-    if (type == PSEUDO_SEL /* Pseudo_Selector_Ptr_Const lp = dynamic_cast<Pseudo_Selector_Ptr_Const>(this) */) {
-      return *static_cast<Pseudo_Selector_Ptr_Const>(this) == rhs;
-    }
-    else if (type == WRAPPED_SEL /* Wrapped_Selector_Ptr_Const lw = dynamic_cast<Wrapped_Selector_Ptr_Const>(this) */) {
-      return *static_cast<Wrapped_Selector_Ptr_Const>(this) == rhs;
-    }
-    else if (type == ATTR_SEL /* Attribute_Selector_Ptr_Const la = dynamic_cast<Attribute_Selector_Ptr_Const>(this) */) {
-      return *static_cast<Attribute_Selector_Ptr_Const>(this) == rhs;
-    }
+    // solve the double dispatch problem by using RTTI information via dynamic cast
+    if (const Pseudo_Selector* lhs = Cast<Pseudo_Selector>(this)) {return *lhs == rhs; }
+    else if (const Wrapped_Selector* lhs = Cast<Wrapped_Selector>(this)) {return *lhs == rhs; }
+    else if (const Element_Selector* lhs = Cast<Element_Selector>(this)) {return *lhs == rhs; }
+    else if (const Attribute_Selector* lhs = Cast<Attribute_Selector>(this)) {return *lhs == rhs; }
     else if (name_ == rhs.name_)
-    { return is_ns_eq(ns_, rhs.ns_); }
+    { return is_ns_eq(rhs); }
     else return false;
   }
 
   bool Simple_Selector::operator< (const Simple_Selector& rhs) const
   {
-    Simple_Type type = simple_type();
-    // dynamic cast is a bottleneck - use concrete type as types are final
-    if (type == PSEUDO_SEL /* Pseudo_Selector_Ptr_Const lp = dynamic_cast<Pseudo_Selector_Ptr_Const>(this) */) {
-      return *static_cast<Pseudo_Selector_Ptr_Const>(this) < rhs;
-    }
-    else if (type == WRAPPED_SEL /* Wrapped_Selector_Ptr_Const lw = dynamic_cast<Wrapped_Selector_Ptr_Const>(this) */) {
-      return *static_cast<Wrapped_Selector_Ptr_Const>(this) < rhs;
-    }
-    else if (type == ATTR_SEL /* Attribute_Selector_Ptr_Const la = dynamic_cast<Attribute_Selector_Ptr_Const>(this) */) {
-      return *static_cast<Attribute_Selector_Ptr_Const>(this) < rhs;
-    }
-    if (is_ns_eq(ns_, rhs.ns_))
+    // solve the double dispatch problem by using RTTI information via dynamic cast
+    if (const Pseudo_Selector* lhs = Cast<Pseudo_Selector>(this)) {return *lhs < rhs; }
+    else if (const Wrapped_Selector* lhs = Cast<Wrapped_Selector>(this)) {return *lhs < rhs; }
+    else if (const Element_Selector* lhs = Cast<Element_Selector>(this)) {return *lhs < rhs; }
+    else if (const Attribute_Selector* lhs = Cast<Attribute_Selector>(this)) {return *lhs < rhs; }
+    if (is_ns_eq(rhs))
     { return name_ < rhs.name_; }
     return ns_ < rhs.ns_;
   }
@@ -405,19 +440,19 @@ namespace Sass {
   bool Selector_List::operator== (const Selector& rhs) const
   {
     // solve the double dispatch problem by using RTTI information via dynamic cast
-    if (Selector_List_Ptr_Const ls = dynamic_cast<Selector_List_Ptr_Const>(&rhs)) { return *this == *ls; }
-    else if (Complex_Selector_Ptr_Const ls = dynamic_cast<Complex_Selector_Ptr_Const>(&rhs)) { return *this == *ls; }
-    else if (Compound_Selector_Ptr_Const ls = dynamic_cast<Compound_Selector_Ptr_Const>(&rhs)) { return *this == *ls; }
+    if (Selector_List_Ptr_Const sl = Cast<Selector_List>(&rhs)) { return *this == *sl; }
+    else if (Complex_Selector_Ptr_Const cpx = Cast<Complex_Selector>(&rhs)) { return *this == *cpx; }
+    else if (Compound_Selector_Ptr_Const cpd = Cast<Compound_Selector>(&rhs)) { return *this == *cpd; }
     // no compare method
     return this == &rhs;
   }
 
   // Selector lists can be compared to comma lists
-  bool Selector_List::operator==(const Expression& rhs) const
+  bool Selector_List::operator== (const Expression& rhs) const
   {
     // solve the double dispatch problem by using RTTI information via dynamic cast
-    if (List_Ptr_Const ls = dynamic_cast<List_Ptr_Const>(&rhs)) { return *this == *ls; }
-    if (Selector_Ptr_Const ls = dynamic_cast<Selector_Ptr_Const>(&rhs)) { return *this == *ls; }
+    if (List_Ptr_Const ls = Cast<List>(&rhs)) { return *ls == *this; }
+    if (Selector_Ptr_Const ls = Cast<Selector>(&rhs)) { return *this == *ls; }
     // compare invalid (maybe we should error?)
     return false;
   }
@@ -431,8 +466,8 @@ namespace Sass {
     // create temporary vectors and sort them
     std::vector<Complex_Selector_Obj> l_lst = this->elements();
     std::vector<Complex_Selector_Obj> r_lst = rhs.elements();
-    std::sort(l_lst.begin(), l_lst.end(), cmp_complex_selector());
-    std::sort(r_lst.begin(), r_lst.end(), cmp_complex_selector());
+    std::sort(l_lst.begin(), l_lst.end(), OrderNodes());
+    std::sort(r_lst.begin(), r_lst.end(), OrderNodes());
     // process loop
     while (true)
     {
@@ -451,38 +486,38 @@ namespace Sass {
       // advance
       ++i; ++n;
     }
-    // no mismatch
-    return true;
+    // there is no break?!
   }
 
   bool Selector_List::operator< (const Selector& rhs) const
   {
-    if (Selector_List_Ptr_Const sp = dynamic_cast<Selector_List_Ptr_Const>(&rhs)) return *this < *sp;
+    if (Selector_List_Ptr_Const sp = Cast<Selector_List>(&rhs)) return *this < *sp;
     return false;
   }
 
   bool Selector_List::operator< (const Selector_List& rhs) const
   {
-    if (this->length() != rhs.length()) return false;
-    for (size_t i = 0; i < rhs.length(); i ++) {
-      if (!(*at(i) < *rhs.at(i))) return false;
+    size_t l = rhs.length();
+    if (length() < l) l = length();
+    for (size_t i = 0; i < l; i ++) {
+      if (*at(i) < *rhs.at(i)) return true;
     }
-    return true;
+    return false;
   }
 
-  Compound_Selector_Ptr Simple_Selector::unify_with(Compound_Selector_Ptr rhs, Context& ctx)
+  Compound_Selector_Ptr Simple_Selector::unify_with(Compound_Selector_Ptr rhs)
   {
     for (size_t i = 0, L = rhs->length(); i < L; ++i)
-    { if (to_string(ctx.c_options) == rhs->at(i)->to_string(ctx.c_options)) return rhs; }
+    { if (to_string() == rhs->at(i)->to_string()) return rhs; }
 
     // check for pseudo elements because they are always last
     size_t i, L;
     bool found = false;
-    if (typeid(*this) == typeid(Pseudo_Selector) || typeid(*this) == typeid(Wrapped_Selector))
+    if (typeid(*this) == typeid(Pseudo_Selector) || typeid(*this) == typeid(Wrapped_Selector) || typeid(*this) == typeid(Attribute_Selector))
     {
       for (i = 0, L = rhs->length(); i < L; ++i)
       {
-        if ((SASS_MEMORY_CAST(Pseudo_Selector, (*rhs)[i]) || SASS_MEMORY_CAST(Wrapped_Selector, (*rhs)[i])) && (*rhs)[L-1]->is_pseudo_element())
+        if ((Cast<Pseudo_Selector>((*rhs)[i]) || Cast<Wrapped_Selector>((*rhs)[i]) || Cast<Attribute_Selector>((*rhs)[i])) && (*rhs)[L-1]->is_pseudo_element())
         { found = true; break; }
       }
     }
@@ -490,20 +525,20 @@ namespace Sass {
     {
       for (i = 0, L = rhs->length(); i < L; ++i)
       {
-        if (SASS_MEMORY_CAST(Pseudo_Selector, (*rhs)[i]) || SASS_MEMORY_CAST(Wrapped_Selector, (*rhs)[i]))
+        if (Cast<Pseudo_Selector>((*rhs)[i]) || Cast<Wrapped_Selector>((*rhs)[i]) || Cast<Attribute_Selector>((*rhs)[i]))
         { found = true; break; }
       }
     }
     if (!found)
     {
       rhs->append(this);
-      return rhs;
+    } else {
+      rhs->elements().insert(rhs->elements().begin() + i, this);
     }
-    rhs->elements().insert(rhs->elements().begin() + i, this);
     return rhs;
   }
 
-  Simple_Selector_Ptr Element_Selector::unify_with(Simple_Selector_Ptr rhs, Context& ctx)
+  Simple_Selector_Ptr Element_Selector::unify_with(Simple_Selector_Ptr rhs)
   {
     // check if ns can be extended
     // true for no ns or universal
@@ -534,7 +569,7 @@ namespace Sass {
     return this;
   }
 
-  Compound_Selector_Ptr Element_Selector::unify_with(Compound_Selector_Ptr rhs, Context& ctx)
+  Compound_Selector_Ptr Element_Selector::unify_with(Compound_Selector_Ptr rhs)
   {
     // TODO: handle namespaces
 
@@ -544,18 +579,18 @@ namespace Sass {
       return rhs;
     }
 
-    Simple_Selector_Ptr rhs_0 = &rhs->at(0);
+    Simple_Selector_Ptr rhs_0 = rhs->at(0);
     // otherwise, this is a tag name
     if (name() == "*")
     {
       if (typeid(*rhs_0) == typeid(Element_Selector))
       {
         // if rhs is universal, just return this tagname + rhs's qualifiers
-        Element_Selector_Ptr ts = SASS_MEMORY_CAST_PTR(Element_Selector, rhs_0);
-        rhs->at(0) = this->unify_with(ts, ctx);
+        Element_Selector_Ptr ts = Cast<Element_Selector>(rhs_0);
+        rhs->at(0) = this->unify_with(ts);
         return rhs;
       }
-      else if (SASS_MEMORY_CAST_PTR(Class_Selector, rhs_0) || SASS_MEMORY_CAST_PTR(Id_Selector, rhs_0)) {
+      else if (Cast<Class_Selector>(rhs_0) || Cast<Id_Selector>(rhs_0)) {
         // qualifier is `.class`, so we can prefix with `ns|*.class`
         if (has_ns() && !rhs_0->has_ns()) {
           if (ns() != "*") rhs->elements().insert(rhs->begin(), this);
@@ -572,7 +607,7 @@ namespace Sass {
       // if rhs is universal, just return this tagname + rhs's qualifiers
       if (rhs_0->name() != "*" && rhs_0->ns() != "*" && rhs_0->name() != name()) return 0;
       // otherwise create new compound and unify first simple selector
-      rhs->at(0) = this->unify_with(rhs_0, ctx);
+      rhs->at(0) = this->unify_with(rhs_0);
       return rhs;
 
     }
@@ -581,64 +616,61 @@ namespace Sass {
     return rhs;
   }
 
-  Compound_Selector_Ptr Class_Selector::unify_with(Compound_Selector_Ptr rhs, Context& ctx)
+  Compound_Selector_Ptr Class_Selector::unify_with(Compound_Selector_Ptr rhs)
   {
     rhs->has_line_break(has_line_break());
-    return Simple_Selector::unify_with(rhs, ctx);
+    return Simple_Selector::unify_with(rhs);
   }
 
-  Compound_Selector_Ptr Id_Selector::unify_with(Compound_Selector_Ptr rhs, Context& ctx)
+  Compound_Selector_Ptr Id_Selector::unify_with(Compound_Selector_Ptr rhs)
   {
     for (size_t i = 0, L = rhs->length(); i < L; ++i)
     {
-      if (Id_Selector_Ptr sel = SASS_MEMORY_CAST(Id_Selector, rhs->at(i))) {
+      if (Id_Selector_Ptr sel = Cast<Id_Selector>(rhs->at(i))) {
         if (sel->name() != name()) return 0;
       }
     }
     rhs->has_line_break(has_line_break());
-    return Simple_Selector::unify_with(rhs, ctx);
+    return Simple_Selector::unify_with(rhs);
   }
 
-  Compound_Selector_Ptr Pseudo_Selector::unify_with(Compound_Selector_Ptr rhs, Context& ctx)
+  Compound_Selector_Ptr Pseudo_Selector::unify_with(Compound_Selector_Ptr rhs)
   {
     if (is_pseudo_element())
     {
       for (size_t i = 0, L = rhs->length(); i < L; ++i)
       {
-        if (Pseudo_Selector_Ptr sel = SASS_MEMORY_CAST(Pseudo_Selector, rhs->at(i))) {
+        if (Pseudo_Selector_Ptr sel = Cast<Pseudo_Selector>(rhs->at(i))) {
           if (sel->is_pseudo_element() && sel->name() != name()) return 0;
         }
       }
     }
-    return Simple_Selector::unify_with(rhs, ctx);
+    return Simple_Selector::unify_with(rhs);
   }
 
   bool Attribute_Selector::operator< (const Attribute_Selector& rhs) const
   {
-    if (is_ns_eq(ns(), rhs.ns())) {
+    if (is_ns_eq(rhs)) {
       if (name() == rhs.name()) {
         if (matcher() == rhs.matcher()) {
           bool no_lhs_val = value().isNull();
           bool no_rhs_val = rhs.value().isNull();
-          if (no_lhs_val && no_rhs_val) {
-            return true;
-          }
-          if (!no_lhs_val && !no_rhs_val) {
-            return *value() < *rhs.value();
-          }
+          if (no_lhs_val && no_rhs_val) return false; // equal
+          else if (no_lhs_val) return true; // lhs is null
+          else if (no_rhs_val) return false; // rhs is null
+          return *value() < *rhs.value(); // both are given
         } else { return matcher() < rhs.matcher(); }
       } else { return name() < rhs.name(); }
-    }
-    return false;
+    } else { return ns() < rhs.ns(); }
   }
 
   bool Attribute_Selector::operator< (const Simple_Selector& rhs) const
   {
-    if (Attribute_Selector_Ptr_Const w = dynamic_cast<Attribute_Selector_Ptr_Const>(&rhs))
+    if (Attribute_Selector_Ptr_Const w = Cast<Attribute_Selector>(&rhs))
     {
       return *this < *w;
     }
-    if (is_ns_eq(ns(), rhs.ns()))
+    if (is_ns_eq(rhs))
     { return name() < rhs.name(); }
     return ns() < rhs.ns();
   }
@@ -652,13 +684,13 @@ namespace Sass {
     if (no_lhs_val && no_rhs_val) {
       return (name() == rhs.name())
         && (matcher() == rhs.matcher())
-        && (is_ns_eq(ns(), rhs.ns()));
+        && (is_ns_eq(rhs));
     }
     // both are defined, evaluate
     if (no_lhs_val == no_rhs_val) {
       return (name() == rhs.name())
         && (matcher() == rhs.matcher())
-        && (is_ns_eq(ns(), rhs.ns()))
+        && (is_ns_eq(rhs))
         && (*value() == *rhs.value());
     }
     // not equal
@@ -668,97 +700,130 @@ namespace Sass {
 
   bool Attribute_Selector::operator== (const Simple_Selector& rhs) const
   {
-    if (Attribute_Selector_Ptr_Const w = dynamic_cast<Attribute_Selector_Ptr_Const>(&rhs))
+    if (Attribute_Selector_Ptr_Const w = Cast<Attribute_Selector>(&rhs))
     {
-      return *this == *w;
+      return is_ns_eq(rhs) &&
+             name() == rhs.name() &&
+             *this == *w;
+    }
+    return false;
+  }
+
+  bool Element_Selector::operator< (const Element_Selector& rhs) const
+  {
+    if (is_ns_eq(rhs))
+    { return name() < rhs.name(); }
+    return ns() < rhs.ns();
+  }
+
+  bool Element_Selector::operator< (const Simple_Selector& rhs) const
+  {
+    if (Element_Selector_Ptr_Const w = Cast<Element_Selector>(&rhs))
+    {
+      return *this < *w;
+    }
+    if (is_ns_eq(rhs))
+    { return name() < rhs.name(); }
+    return ns() < rhs.ns();
+  }
+
+  bool Element_Selector::operator== (const Element_Selector& rhs) const
+  {
+    return is_ns_eq(rhs) &&
+           name() == rhs.name();
+  }
+
+  bool Element_Selector::operator== (const Simple_Selector& rhs) const
+  {
+    if (Element_Selector_Ptr_Const w = Cast<Element_Selector>(&rhs))
+    {
+      return is_ns_eq(rhs) &&
+             name() == rhs.name() &&
+             *this == *w;
     }
-    if (is_ns_eq(ns(), rhs.ns()))
-    { return name() == rhs.name(); }
-    return ns() == rhs.ns();
+    return false;
   }
 
   bool Pseudo_Selector::operator== (const Pseudo_Selector& rhs) const
   {
-    if (is_ns_eq(ns(), rhs.ns()) && name() == rhs.name())
+    if (is_ns_eq(rhs) && name() == rhs.name())
     {
       String_Obj lhs_ex = expression();
       String_Obj rhs_ex = rhs.expression();
       if (rhs_ex && lhs_ex) return *lhs_ex == *rhs_ex;
-      else return lhs_ex == rhs_ex;
+      else return lhs_ex.ptr() == rhs_ex.ptr();
     }
     else return false;
   }
 
   bool Pseudo_Selector::operator== (const Simple_Selector& rhs) const
   {
-    if (Pseudo_Selector_Ptr_Const w = dynamic_cast<Pseudo_Selector_Ptr_Const>(&rhs))
+    if (Pseudo_Selector_Ptr_Const w = Cast<Pseudo_Selector>(&rhs))
     {
       return *this == *w;
     }
-    if (is_ns_eq(ns(), rhs.ns()))
-    { return name() == rhs.name(); }
-    return ns() == rhs.ns();
+    return is_ns_eq(rhs) &&
+           name() == rhs.name();
   }
 
   bool Pseudo_Selector::operator< (const Pseudo_Selector& rhs) const
   {
-    if (is_ns_eq(ns(), rhs.ns()) && name() == rhs.name())
+    if (is_ns_eq(rhs) && name() == rhs.name())
     {
       String_Obj lhs_ex = expression();
       String_Obj rhs_ex = rhs.expression();
       if (rhs_ex && lhs_ex) return *lhs_ex < *rhs_ex;
-      else return lhs_ex < rhs_ex;
+      else return lhs_ex.ptr() < rhs_ex.ptr();
     }
-    if (is_ns_eq(ns(), rhs.ns()))
+    if (is_ns_eq(rhs))
     { return name() < rhs.name(); }
     return ns() < rhs.ns();
   }
 
   bool Pseudo_Selector::operator< (const Simple_Selector& rhs) const
   {
-    if (Pseudo_Selector_Ptr_Const w = dynamic_cast<Pseudo_Selector_Ptr_Const>(&rhs))
+    if (Pseudo_Selector_Ptr_Const w = Cast<Pseudo_Selector>(&rhs))
     {
       return *this < *w;
     }
-    if (is_ns_eq(ns(), rhs.ns()))
+    if (is_ns_eq(rhs))
     { return name() < rhs.name(); }
     return ns() < rhs.ns();
   }
 
   bool Wrapped_Selector::operator== (const Wrapped_Selector& rhs) const
   {
-    if (is_ns_eq(ns(), rhs.ns()) && name() == rhs.name())
+    if (is_ns_eq(rhs) && name() == rhs.name())
     { return *(selector()) == *(rhs.selector()); }
     else return false;
   }
 
   bool Wrapped_Selector::operator== (const Simple_Selector& rhs) const
   {
-    if (Wrapped_Selector_Ptr_Const w = dynamic_cast<Wrapped_Selector_Ptr_Const>(&rhs))
+    if (Wrapped_Selector_Ptr_Const w = Cast<Wrapped_Selector>(&rhs))
     {
       return *this == *w;
     }
-    if (is_ns_eq(ns(), rhs.ns()))
-    { return name() == rhs.name(); }
-    return ns() == rhs.ns();
+    return is_ns_eq(rhs) &&
+           name() == rhs.name();
   }
 
   bool Wrapped_Selector::operator< (const Wrapped_Selector& rhs) const
   {
-    if (is_ns_eq(ns(), rhs.ns()) && name() == rhs.name())
+    if (is_ns_eq(rhs) && name() == rhs.name())
     { return *(selector()) < *(rhs.selector()); }
-    if (is_ns_eq(ns(), rhs.ns()))
+    if (is_ns_eq(rhs))
     { return name() < rhs.name(); }
     return ns() < rhs.ns();
   }
 
   bool Wrapped_Selector::operator< (const Simple_Selector& rhs) const
   {
-    if (Wrapped_Selector_Ptr_Const w = dynamic_cast<Wrapped_Selector_Ptr_Const>(&rhs))
+    if (Wrapped_Selector_Ptr_Const w = Cast<Wrapped_Selector>(&rhs))
     {
       return *this < *w;
     }
-    if (is_ns_eq(ns(), rhs.ns()))
+    if (is_ns_eq(rhs))
     { return name() < rhs.name(); }
     return ns() < rhs.ns();
   }
@@ -767,28 +832,26 @@ namespace Sass {
   {
     if (this->name() != sub->name()) return false;
     if (this->name() == ":current") return false;
-    if (Selector_List_Obj rhs_list = SASS_MEMORY_CAST(Selector_List, sub->selector())) {
-      if (Selector_List_Obj lhs_list = SASS_MEMORY_CAST(Selector_List, selector())) {
+    if (Selector_List_Obj rhs_list = Cast<Selector_List>(sub->selector())) {
+      if (Selector_List_Obj lhs_list = Cast<Selector_List>(selector())) {
         return lhs_list->is_superselector_of(rhs_list);
       }
-      error("is_superselector expected a Selector_List", sub->pstate());
-    } else {
-      error("is_superselector expected a Selector_List", sub->pstate());
     }
+    coreError("is_superselector expected a Selector_List", sub->pstate());
     return false;
   }
 
   bool Compound_Selector::is_superselector_of(Selector_List_Obj rhs, std::string wrapped)
   {
     for (Complex_Selector_Obj item : rhs->elements()) {
-      if (is_superselector_of(&item, wrapped)) return true;
+      if (is_superselector_of(item, wrapped)) return true;
     }
     return false;
   }
 
   bool Compound_Selector::is_superselector_of(Complex_Selector_Obj rhs, std::string wrapped)
   {
-    if (rhs->head()) return is_superselector_of(&rhs->head(), wrapped);
+    if (rhs->head()) return is_superselector_of(rhs->head(), wrapped);
     return false;
   }
 
@@ -821,6 +884,9 @@ namespace Sass {
       return false;
     }
 
+    // would like to replace this without stringification
+    // https://github.com/sass/sass/issues/2229
+    // SimpleSelectorSet lset, rset;
     std::set<std::string> lset, rset;
 
     if (lbase && rbase)
@@ -837,20 +903,20 @@ namespace Sass {
 
     for (size_t i = 0, iL = length(); i < iL; ++i)
     {
-      Selector_Obj lhs = &(*this)[i];
+      Selector_Obj wlhs = (*this)[i];
       // very special case for wrapped matches selector
-      if (Wrapped_Selector_Obj wrapped = SASS_MEMORY_CAST(Wrapped_Selector, lhs)) {
+      if (Wrapped_Selector_Obj wrapped = Cast<Wrapped_Selector>(wlhs)) {
         if (wrapped->name() == ":not") {
-          if (Selector_List_Obj not_list = SASS_MEMORY_CAST(Selector_List, wrapped->selector())) {
+          if (Selector_List_Obj not_list = Cast<Selector_List>(wrapped->selector())) {
             if (not_list->is_superselector_of(rhs, wrapped->name())) return false;
           } else {
             throw std::runtime_error("wrapped not selector is not a list");
           }
         }
         if (wrapped->name() == ":matches" || wrapped->name() == ":-moz-any") {
-          lhs = wrapped->selector();
-          if (Selector_List_Obj list = SASS_MEMORY_CAST(Selector_List, wrapped->selector())) {
-            if (Compound_Selector_Obj comp = SASS_MEMORY_CAST(Compound_Selector, rhs)) {
+          wlhs = wrapped->selector();
+          if (Selector_List_Obj list = Cast<Selector_List>(wrapped->selector())) {
+            if (Compound_Selector_Obj comp = Cast<Compound_Selector>(rhs)) {
               if (!wrapping.empty() && wrapping != wrapped->name()) return false;
               if (wrapping.empty() || wrapping != wrapped->name()) {;
                 if (list->is_superselector_of(comp, wrapped->name())) return true;
@@ -858,26 +924,25 @@ namespace Sass {
             }
           }
         }
-        Simple_Selector_Ptr rhs_sel = rhs->elements().size() > i ? &(*rhs)[i] : 0;
-        if (Wrapped_Selector_Ptr wrapped_r = dynamic_cast<Wrapped_Selector_Ptr>(rhs_sel)) {
+        Simple_Selector_Ptr rhs_sel = NULL;
+        if (rhs->elements().size() > i) rhs_sel = (*rhs)[i];
+        if (Wrapped_Selector_Ptr wrapped_r = Cast<Wrapped_Selector>(rhs_sel)) {
           if (wrapped->name() == wrapped_r->name()) {
           if (wrapped->is_superselector_of(wrapped_r)) {
              continue;
-             rset.insert(lhs->to_string());
-
           }}
         }
       }
       // match from here on as strings
-      lset.insert(lhs->to_string());
+      lset.insert(wlhs->to_string());
     }
 
     for (size_t n = 0, nL = rhs->length(); n < nL; ++n)
     {
-      Selector_Obj r = &(*rhs)[n];
-      if (Wrapped_Selector_Obj wrapped = SASS_MEMORY_CAST(Wrapped_Selector, r)) {
+      Selector_Obj r = (*rhs)[n];
+      if (Wrapped_Selector_Obj wrapped = Cast<Wrapped_Selector>(r)) {
         if (wrapped->name() == ":not") {
-          if (Selector_List_Obj ls = SASS_MEMORY_CAST(Selector_List, wrapped->selector())) {
+          if (Selector_List_Obj ls = Cast<Selector_List>(wrapped->selector())) {
             ls->remove_parent_selectors();
             if (is_superselector_of(ls, wrapped->name())) return false;
           }
@@ -886,7 +951,7 @@ namespace Sass {
           if (!wrapping.empty()) {
             if (wrapping != wrapped->name()) return false;
           }
-          if (Selector_List_Obj ls = SASS_MEMORY_CAST(Selector_List, wrapped->selector())) {
+          if (Selector_List_Obj ls = Cast<Selector_List>(wrapped->selector())) {
             ls->remove_parent_selectors();
             return (is_superselector_of(ls, wrapped->name()));
           }
@@ -915,7 +980,7 @@ namespace Sass {
                            0);
   }
 
-  Selector_List_Ptr Complex_Selector::unify_with(Complex_Selector_Ptr other, Context& ctx)
+  Selector_List_Ptr Complex_Selector::unify_with(Complex_Selector_Ptr other)
   {
 
     // get last tails (on the right side)
@@ -941,7 +1006,7 @@ namespace Sass {
     SASS_ASSERT(r_last_head, "rhs head is null");
 
     // get the unification of the last compound selectors
-    Compound_Selector_Obj unified = r_last_head->unify_with(&l_last_head, ctx);
+    Compound_Selector_Obj unified = r_last_head->unify_with(l_last_head);
 
     // abort if we could not unify heads
     if (unified == 0) return 0;
@@ -958,28 +1023,28 @@ namespace Sass {
     }
 
     // create nodes from both selectors
-    Node lhsNode = complexSelectorToNode(this, ctx);
-    Node rhsNode = complexSelectorToNode(other, ctx);
+    Node lhsNode = complexSelectorToNode(this);
+    Node rhsNode = complexSelectorToNode(other);
 
     // overwrite universal base
     if (!is_universal)
     {
       // create some temporaries to convert to node
       Complex_Selector_Obj fake = unified->to_complex();
-      Node unified_node = complexSelectorToNode(&fake, ctx);
+      Node unified_node = complexSelectorToNode(fake);
       // add to permutate the list?
       rhsNode.plus(unified_node);
     }
 
     // do some magic we inherit from node and extend
-    Node node = Extend::subweave(lhsNode, rhsNode, ctx);
-    Selector_List_Ptr result = SASS_MEMORY_NEW(Selector_List, pstate());
+    Node node = subweave(lhsNode, rhsNode);
+    Selector_List_Obj result = SASS_MEMORY_NEW(Selector_List, pstate());
     NodeDequePtr col = node.collection(); // move from collection to list
     for (NodeDeque::iterator it = col->begin(), end = col->end(); it != end; it++)
-    { result->append(nodeToComplexSelector(Node::naiveTrim(*it, ctx), ctx)); }
+    { result->append(nodeToComplexSelector(Node::naiveTrim(*it))); }
 
     // only return if list has some entries
-    return result->length() ? result : 0;
+    return result->length() ? result.detach() : 0;
 
   }
 
@@ -992,8 +1057,8 @@ namespace Sass {
     // create temporary vectors and sort them
     std::vector<Simple_Selector_Obj> l_lst = this->elements();
     std::vector<Simple_Selector_Obj> r_lst = rhs.elements();
-    std::sort(l_lst.begin(), l_lst.end(), cmp_simple_selector());
-    std::sort(r_lst.begin(), r_lst.end(), cmp_simple_selector());
+    std::sort(l_lst.begin(), l_lst.end(), OrderNodes());
+    std::sort(r_lst.begin(), r_lst.end(), OrderNodes());
     // process loop
     while (true)
     {
@@ -1012,12 +1077,7 @@ namespace Sass {
       // advance now
       ++i; ++n;
     }
-    // no mismatch
-    return true;
-  }
-
-  bool Complex_Selector_Pointer_Compare::operator() (const Complex_Selector_Obj& pLeft, const Complex_Selector_Obj& pRight) const {
-    return *pLeft < *pRight;
+    // there is no break?!
   }
 
   bool Complex_Selector::is_superselector_of(Compound_Selector_Obj rhs, std::string wrapping)
@@ -1043,7 +1103,7 @@ namespace Sass {
     { return false; }
 
     if (l_len == 1)
-    { return lhs->head()->is_superselector_of(&rhs->last()->head(), wrapping); }
+    { return lhs->head()->is_superselector_of(rhs->last()->head(), wrapping); }
 
     // we have to look one tail deeper, since we cary the
     // combinator around for it (which is important here)
@@ -1054,7 +1114,7 @@ namespace Sass {
       if (lhs_tail->head() && !rhs_tail->head()) return false;
       if (!lhs_tail->head() && rhs_tail->head()) return false;
       if (lhs_tail->head() && rhs_tail->head()) {
-        if (!lhs_tail->head()->is_superselector_of(&rhs_tail->head())) return false;
+        if (!lhs_tail->head()->is_superselector_of(rhs_tail->head())) return false;
       }
     }
 
@@ -1063,7 +1123,7 @@ namespace Sass {
     for (size_t i = 0, L = rhs->length(); i < L; ++i) {
       if (i == L-1)
       { return false; }
-      if (lhs->head() && marker->head() && lhs->head()->is_superselector_of(&marker->head(), wrapping))
+      if (lhs->head() && marker->head() && lhs->head()->is_superselector_of(marker->head(), wrapping))
       { found = true; break; }
       marker = marker->tail();
     }
@@ -1089,20 +1149,15 @@ namespace Sass {
       { return false; }
       if (!(lhs->combinator() == Complex_Selector::PRECEDES ? marker->combinator() != Complex_Selector::PARENT_OF : lhs->combinator() == marker->combinator()))
       { return false; }
-      return lhs->tail()->is_superselector_of(&marker->tail());
+      return lhs->tail()->is_superselector_of(marker->tail());
     }
     else if (marker->combinator() != Complex_Selector::ANCESTOR_OF)
     {
       if (marker->combinator() != Complex_Selector::PARENT_OF)
       { return false; }
-      return lhs->tail()->is_superselector_of(&marker->tail());
+      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
@@ -1112,20 +1167,11 @@ namespace Sass {
     return 1 + tail()->length();
   }
 
-  Complex_Selector_Obj Complex_Selector::context(Context& ctx)
-  {
-    if (!tail()) return 0;
-    if (!head()) return tail()->context(ctx);
-    Complex_Selector_Obj cpy = SASS_MEMORY_NEW(Complex_Selector, pstate(), combinator(), head(), tail()->context(ctx));
-    cpy->media_block(media_block());
-    return cpy;
-  }
-
   // append another complex selector at the end
   // check if we need to append some headers
   // then we need to check for the combinator
   // only then we can safely set the new tail
-  void Complex_Selector::append(Context& ctx, Complex_Selector_Obj ss)
+  void Complex_Selector::append(Complex_Selector_Obj ss, Backtraces& traces)
   {
 
     Complex_Selector_Obj t = ss->tail();
@@ -1139,47 +1185,49 @@ namespace Sass {
     // append old headers
     if (h && h->length()) {
       if (last()->combinator() != ANCESTOR_OF && c != ANCESTOR_OF) {
-        error("Invalid parent selector", pstate_);
+        traces.push_back(Backtrace(pstate()));
+        throw Exception::InvalidParent(this, traces, ss);
       } else if (last()->head_ && last()->head_->length()) {
         Compound_Selector_Obj rh = last()->head();
-        size_t i = 0, L = h->length();
-        if (SASS_MEMORY_CAST(Element_Selector, h->first())) {
-          if (Class_Selector_Ptr sq = SASS_MEMORY_CAST(Class_Selector, rh->last())) {
-            Class_Selector_Ptr sqs = SASS_MEMORY_COPY(sq);
+        size_t i;
+        size_t L = h->length();
+        if (Cast<Element_Selector>(h->first())) {
+          if (Class_Selector_Ptr cs = Cast<Class_Selector>(rh->last())) {
+            Class_Selector_Ptr sqs = SASS_MEMORY_COPY(cs);
             sqs->name(sqs->name() + (*h)[0]->name());
             sqs->pstate((*h)[0]->pstate());
             (*rh)[rh->length()-1] = sqs;
             rh->pstate(h->pstate());
-            for (i = 1; i < L; ++i) rh->append(&(*h)[i]);
-          } else if (Id_Selector_Ptr sq = SASS_MEMORY_CAST(Id_Selector, rh->last())) {
-            Id_Selector_Ptr sqs = SASS_MEMORY_COPY(sq);
+            for (i = 1; i < L; ++i) rh->append((*h)[i]);
+          } else if (Id_Selector_Ptr is = Cast<Id_Selector>(rh->last())) {
+            Id_Selector_Ptr sqs = SASS_MEMORY_COPY(is);
             sqs->name(sqs->name() + (*h)[0]->name());
             sqs->pstate((*h)[0]->pstate());
             (*rh)[rh->length()-1] = sqs;
             rh->pstate(h->pstate());
-            for (i = 1; i < L; ++i) rh->append(&(*h)[i]);
-          } else if (Element_Selector_Ptr ts = SASS_MEMORY_CAST(Element_Selector, rh->last())) {
+            for (i = 1; i < L; ++i) rh->append((*h)[i]);
+          } else if (Element_Selector_Ptr ts = Cast<Element_Selector>(rh->last())) {
             Element_Selector_Ptr tss = SASS_MEMORY_COPY(ts);
             tss->name(tss->name() + (*h)[0]->name());
             tss->pstate((*h)[0]->pstate());
             (*rh)[rh->length()-1] = tss;
             rh->pstate(h->pstate());
-            for (i = 1; i < L; ++i) rh->append(&(*h)[i]);
-          } else if (Placeholder_Selector_Ptr ps = SASS_MEMORY_CAST(Placeholder_Selector, rh->last())) {
+            for (i = 1; i < L; ++i) rh->append((*h)[i]);
+          } else if (Placeholder_Selector_Ptr ps = Cast<Placeholder_Selector>(rh->last())) {
             Placeholder_Selector_Ptr pss = SASS_MEMORY_COPY(ps);
             pss->name(pss->name() + (*h)[0]->name());
             pss->pstate((*h)[0]->pstate());
             (*rh)[rh->length()-1] = pss;
             rh->pstate(h->pstate());
-            for (i = 1; i < L; ++i) rh->append(&(*h)[i]);
+            for (i = 1; i < L; ++i) rh->append((*h)[i]);
           } else {
-            last()->head_->concat(&h);
+            last()->head_->concat(h);
           }
         } else {
-          last()->head_->concat(&h);
+          last()->head_->concat(h);
         }
-      } else {
-        last()->head_->concat(&h);
+      } else if (last()->head_) {
+        last()->head_->concat(h);
       }
     } else {
       // std::cerr << "has no or empty head\n";
@@ -1201,28 +1249,35 @@ namespace Sass {
       }
     }
 
+  }
 
+  Selector_List_Obj Selector_List::eval(Eval& eval)
+  {
+    Selector_List_Obj list = schema() ?
+      eval(schema()) : eval(this);
+    list->schema(schema());
+    return list;
   }
 
-  Selector_List_Ptr Selector_List::resolve_parent_refs(Context& ctx, std::vector<Selector_List_Obj>& pstack, bool implicit_parent)
+  Selector_List_Ptr Selector_List::resolve_parent_refs(std::vector<Selector_List_Obj>& pstack, Backtraces& traces, bool implicit_parent)
   {
     if (!this->has_parent_ref()) return this;
     Selector_List_Ptr ss = SASS_MEMORY_NEW(Selector_List, pstate());
-    Selector_List_Ptr ps = &pstack.back();
+    Selector_List_Ptr ps = pstack.back();
     for (size_t pi = 0, pL = ps->length(); pi < pL; ++pi) {
       for (size_t si = 0, sL = this->length(); si < sL; ++si) {
-        Selector_List_Obj rv = at(si)->resolve_parent_refs(ctx, pstack, implicit_parent);
-        ss->concat(&rv);
+        Selector_List_Obj rv = at(si)->resolve_parent_refs(pstack, traces, implicit_parent);
+        ss->concat(rv);
       }
     }
     return ss;
   }
 
-  Selector_List_Ptr Complex_Selector::resolve_parent_refs(Context& ctx, std::vector<Selector_List_Obj>& pstack, bool implicit_parent)
+  Selector_List_Ptr Complex_Selector::resolve_parent_refs(std::vector<Selector_List_Obj>& pstack, Backtraces& traces, bool implicit_parent)
   {
     Complex_Selector_Obj tail = this->tail();
     Compound_Selector_Obj head = this->head();
-    Selector_List_Ptr parents = &pstack.back();
+    Selector_List_Ptr parents = pstack.back();
 
     if (!this->has_real_parent_ref() && !implicit_parent) {
       Selector_List_Ptr retval = SASS_MEMORY_NEW(Selector_List, pstate());
@@ -1231,14 +1286,14 @@ namespace Sass {
     }
 
     // first resolve_parent_refs the tail (which may return an expanded list)
-    Selector_List_Obj tails = tail ? tail->resolve_parent_refs(ctx, pstack, implicit_parent) : 0;
+    Selector_List_Obj tails = tail ? tail->resolve_parent_refs(pstack, traces, implicit_parent) : 0;
 
     if (head && head->length() > 0) {
 
       Selector_List_Obj retval;
       // we have a parent selector in a simple compound list
       // mix parent complex selector into the compound list
-      if (SASS_MEMORY_CAST(Parent_Selector, (*head)[0])) {
+      if (Cast<Parent_Selector>((*head)[0])) {
         retval = SASS_MEMORY_NEW(Selector_List, pstate());
 
         // it turns out that real parent references reach
@@ -1246,7 +1301,7 @@ namespace Sass {
         if (parents == NULL && head->has_real_parent_ref()) {
           int i = pstack.size() - 1;
           while (!parents && i > -1) {
-            parents = &pstack.at(i--);
+            parents = pstack.at(i--);
           }
         }
 
@@ -1258,22 +1313,26 @@ namespace Sass {
                 Complex_Selector_Obj parent = (*parents)[i];
                 Complex_Selector_Obj s = SASS_MEMORY_CLONE(parent);
                 Complex_Selector_Obj ss = SASS_MEMORY_CLONE(this);
-                ss->tail(t ? SASS_MEMORY_CLONE(t) : 0);
+                ss->tail(t ? SASS_MEMORY_CLONE(t) : NULL);
                 Compound_Selector_Obj h = SASS_MEMORY_COPY(head_);
                 // remove parent selector from sequence
-                if (h->length()) h->erase(h->begin());
-                ss->head(h->length() ? &h : 0);
-                // adjust for parent selector (1 char)
                 if (h->length()) {
-                  ParserState state(h->at(0)->pstate());
-                  state.offset.column += 1;
-                  state.column -= 1;
-                  (*h)[0]->pstate(state);
+                  h->erase(h->begin());
+                  ss->head(h);
+                } else {
+                  ss->head(NULL);
                 }
+                // adjust for parent selector (1 char)
+                // if (h->length()) {
+                //   ParserState state(h->at(0)->pstate());
+                //   state.offset.column += 1;
+                //   state.column -= 1;
+                //   (*h)[0]->pstate(state);
+                // }
                 // keep old parser state
                 s->pstate(pstate());
                 // append new tail
-                s->append(ctx, ss);
+                s->append(ss, traces);
                 retval->append(s);
               }
             }
@@ -1288,26 +1347,31 @@ namespace Sass {
               // this is only if valid if the parent has no trailing op
               // otherwise we cannot append more simple selectors to head
               if (parent->last()->combinator() != ANCESTOR_OF) {
-                throw Exception::InvalidParent(&parent, &ss);
+                traces.push_back(Backtrace(pstate()));
+                throw Exception::InvalidParent(parent, traces, ss);
               }
-              ss->tail(tail ? SASS_MEMORY_CLONE(tail) : 0);
+              ss->tail(tail ? SASS_MEMORY_CLONE(tail) : NULL);
               Compound_Selector_Obj h = SASS_MEMORY_COPY(head_);
               // remove parent selector from sequence
-              if (h->length()) h->erase(h->begin());
-              ss->head(h->length() ? &h : 0);
+              if (h->length()) {
+                h->erase(h->begin());
+                ss->head(h);
+              } else {
+                ss->head(NULL);
+              }
               // \/ IMO ruby sass bug \/
               ss->has_line_feed(false);
               // adjust for parent selector (1 char)
-              if (h->length()) {
-                ParserState state(h->at(0)->pstate());
-                state.offset.column += 1;
-                state.column -= 1;
-                (*h)[0]->pstate(state);
-              }
+              // if (h->length()) {
+              //   ParserState state(h->at(0)->pstate());
+              //   state.offset.column += 1;
+              //   state.column -= 1;
+              //   (*h)[0]->pstate(state);
+              // }
               // keep old parser state
               s->pstate(pstate());
               // append new tail
-              s->append(ctx, &ss);
+              s->append(ss, traces);
               retval->append(s);
             }
           }
@@ -1320,7 +1384,7 @@ namespace Sass {
               cpy->tail(SASS_MEMORY_CLONE(tails->at(n)));
               cpy->head(SASS_MEMORY_NEW(Compound_Selector, head->pstate()));
               for (size_t i = 1, L = this->head()->length(); i < L; ++i)
-                cpy->head()->append(&(*this->head())[i]);
+                cpy->head()->append((*this->head())[i]);
               if (!cpy->head()->length()) cpy->head(0);
               retval->append(cpy->skip_empty_reference());
             }
@@ -1330,7 +1394,7 @@ namespace Sass {
             Complex_Selector_Obj cpy = SASS_MEMORY_CLONE(this);
             cpy->head(SASS_MEMORY_NEW(Compound_Selector, head->pstate()));
             for (size_t i = 1, L = this->head()->length(); i < L; ++i)
-              cpy->head()->append(&(*this->head())[i]);
+              cpy->head()->append((*this->head())[i]);
             if (!cpy->head()->length()) cpy->head(0);
             retval->append(cpy->skip_empty_reference());
           }
@@ -1338,13 +1402,13 @@ namespace Sass {
       }
       // no parent selector in head
       else {
-        retval = this->tails(ctx, &tails);
+        retval = this->tails(tails);
       }
 
       for (Simple_Selector_Obj ss : head->elements()) {
-        if (Wrapped_Selector_Ptr ws = SASS_MEMORY_CAST(Wrapped_Selector, ss)) {
-          if (Selector_List_Ptr sl = SASS_MEMORY_CAST(Selector_List, ws->selector())) {
-            if (parents) ws->selector(sl->resolve_parent_refs(ctx, pstack, implicit_parent));
+        if (Wrapped_Selector_Ptr ws = Cast<Wrapped_Selector>(ss)) {
+          if (Selector_List_Ptr sl = Cast<Selector_List>(ws->selector())) {
+            if (parents) ws->selector(sl->resolve_parent_refs(pstack, traces, implicit_parent));
           }
         }
       }
@@ -1353,15 +1417,10 @@ namespace Sass {
 
     }
     // has no head
-    else {
-      return this->tails(ctx, &tails);
-    }
-
-    // unreachable
-    return 0;
+    return this->tails(tails);
   }
 
-  Selector_List_Ptr Complex_Selector::tails(Context& ctx, Selector_List_Ptr tails)
+  Selector_List_Ptr Complex_Selector::tails(Selector_List_Ptr tails)
   {
     Selector_List_Ptr rv = SASS_MEMORY_NEW(Selector_List, pstate_);
     if (tails && tails->length()) {
@@ -1389,21 +1448,27 @@ namespace Sass {
       // get the head
       head = cur->head_;
       // abort (and return) if it is not a parent selector
-      if (!head || head->length() != 1 || !SASS_MEMORY_CAST(Parent_Selector, (*head)[0])) {
+      if (!head || head->length() != 1 || !Cast<Parent_Selector>((*head)[0])) {
         break;
       }
       // advance to next
       cur = cur->tail_;
     }
     // result
-    return &cur;
+    return cur;
   }
 
   // return the last tail that is defined
   Complex_Selector_Obj Complex_Selector::last()
   {
-    // ToDo: implement with a while loop
-    return tail_? tail_->last() : this;
+    Complex_Selector_Ptr cur = this;
+    Complex_Selector_Ptr nxt = cur;
+    // loop until last
+    while (nxt) {
+      cur = nxt;
+      nxt = cur->tail();
+    }
+    return cur;
   }
 
   Complex_Selector::Combinator Complex_Selector::clear_innermost()
@@ -1474,7 +1539,31 @@ namespace Sass {
     }
   }
 
-  bool Selector_List::has_parent_ref()
+  size_t Wrapped_Selector::hash()
+  {
+    if (hash_ == 0) {
+      hash_combine(hash_, Simple_Selector::hash());
+      if (selector_) hash_combine(hash_, selector_->hash());
+    }
+    return hash_;
+  }
+  bool Wrapped_Selector::has_parent_ref() const {
+    // if (has_reference()) return true;
+    if (!selector()) return false;
+    return selector()->has_parent_ref();
+  }
+  bool Wrapped_Selector::has_real_parent_ref() const {
+    // if (has_reference()) return true;
+    if (!selector()) return false;
+    return selector()->has_real_parent_ref();
+  }
+  unsigned long Wrapped_Selector::specificity() const
+  {
+    return selector_ ? selector_->specificity() : 0;
+  }
+
+
+  bool Selector_List::has_parent_ref() const
   {
     for (Complex_Selector_Obj s : elements()) {
       if (s && s->has_parent_ref()) return true;
@@ -1482,7 +1571,7 @@ namespace Sass {
     return false;
   }
 
-  bool Selector_List::has_real_parent_ref()
+  bool Selector_List::has_real_parent_ref() const
   {
     for (Complex_Selector_Obj s : elements()) {
       if (s && s->has_real_parent_ref()) return true;
@@ -1490,18 +1579,18 @@ namespace Sass {
     return false;
   }
 
-  bool Selector_Schema::has_parent_ref()
+  bool Selector_Schema::has_parent_ref() const
   {
-    if (String_Schema_Obj schema = SASS_MEMORY_CAST(String_Schema, contents())) {
-      return schema->length() > 0 && SASS_MEMORY_CAST(Parent_Selector, schema->at(0)) != NULL;
+    if (String_Schema_Obj schema = Cast<String_Schema>(contents())) {
+      return schema->length() > 0 && Cast<Parent_Selector>(schema->at(0)) != NULL;
     }
     return false;
   }
 
-  bool Selector_Schema::has_real_parent_ref()
+  bool Selector_Schema::has_real_parent_ref() const
   {
-    if (String_Schema_Obj schema = SASS_MEMORY_CAST(String_Schema, contents())) {
-      Parent_Selector_Obj p = SASS_MEMORY_CAST(Parent_Selector, schema->at(0));
+    if (String_Schema_Obj schema = Cast<String_Schema>(contents())) {
+      Parent_Selector_Obj p = Cast<Parent_Selector>(schema->at(0));
       return schema->length() > 0 && p && p->is_real_parent_ref();
     }
     return false;
@@ -1518,7 +1607,7 @@ namespace Sass {
   {
     // Check every rhs selector against left hand list
     for(size_t i = 0, L = sub->length(); i < L; ++i) {
-      if (!is_superselector_of(&(*sub)[i], wrapping)) return false;
+      if (!is_superselector_of((*sub)[i], wrapping)) return false;
     }
     return true;
   }
@@ -1529,7 +1618,7 @@ namespace Sass {
   {
     // Check every rhs selector against left hand list
     for(size_t i = 0, L = sub->length(); i < L; ++i) {
-      if (!is_superselector_of(&(*sub)[i], wrapping)) return false;
+      if (!is_superselector_of((*sub)[i], wrapping)) return false;
     }
     return true;
   }
@@ -1556,18 +1645,18 @@ namespace Sass {
     return false;
   }
 
-  Selector_List_Ptr Selector_List::unify_with(Selector_List_Ptr rhs, Context& ctx) {
+  Selector_List_Ptr Selector_List::unify_with(Selector_List_Ptr rhs) {
     std::vector<Complex_Selector_Obj> unified_complex_selectors;
     // Unify all of children with RHS's children, storing the results in `unified_complex_selectors`
     for (size_t lhs_i = 0, lhs_L = length(); lhs_i < lhs_L; ++lhs_i) {
       Complex_Selector_Obj seq1 = (*this)[lhs_i];
       for(size_t rhs_i = 0, rhs_L = rhs->length(); rhs_i < rhs_L; ++rhs_i) {
-        Complex_Selector_Ptr seq2 = &rhs->at(rhs_i);
+        Complex_Selector_Ptr seq2 = rhs->at(rhs_i);
 
-        Selector_List_Obj result = seq1->unify_with(seq2, ctx);
+        Selector_List_Obj result = seq1->unify_with(seq2);
         if( result ) {
           for(size_t i = 0, L = result->length(); i < L; ++i) {
-            unified_complex_selectors.push_back( &(*result)[i] );
+            unified_complex_selectors.push_back( (*result)[i] );
           }
         }
       }
@@ -1581,7 +1670,7 @@ namespace Sass {
     return final_result;
   }
 
-  void Selector_List::populate_extends(Selector_List_Obj extendee, Context& ctx, Subset_Map& extends)
+  void Selector_List::populate_extends(Selector_List_Obj extendee, Subset_Map& extends)
   {
 
     Selector_List_Ptr extender = this;
@@ -1594,7 +1683,7 @@ namespace Sass {
       Complex_Selector_Obj pIter = complex_sel;
       while (pIter) {
         Compound_Selector_Obj pHead = pIter->head();
-        if (pHead && SASS_MEMORY_CAST(Parent_Selector, pHead->elements()[0]) == NULL) {
+        if (pHead && Cast<Parent_Selector>(pHead->elements()[0]) == NULL) {
           compound_sel = pHead;
           break;
         }
@@ -1603,32 +1692,24 @@ namespace Sass {
       }
 
       if (!pIter->head() || pIter->tail()) {
-        error("nested selectors may not be extended", c->pstate());
+        coreError("nested selectors may not be extended", c->pstate());
       }
 
       compound_sel->is_optional(extendee->is_optional());
 
       for (size_t i = 0, L = extender->length(); i < L; ++i) {
-        extends.put(compound_sel, std::make_pair(&(*extender)[i], &compound_sel));
+        extends.put(compound_sel, std::make_pair((*extender)[i], compound_sel));
       }
     }
   };
 
-  std::vector<std::string> Compound_Selector::to_str_vec()
-  {
-    std::vector<std::string> result(length());
-    for (size_t i = 0, L = length(); i < L; ++i)
-    { result.push_back((*this)[i]->to_string()); }
-    return result;
-  }
-
   void Compound_Selector::append(Simple_Selector_Ptr element)
   {
     Vectorized<Simple_Selector_Obj>::append(element);
     pstate_.offset += element->pstate().offset;
   }
 
-  Compound_Selector_Ptr Compound_Selector::minus(Compound_Selector_Ptr rhs, Context& ctx)
+  Compound_Selector_Ptr Compound_Selector::minus(Compound_Selector_Ptr rhs)
   {
     Compound_Selector_Ptr result = SASS_MEMORY_NEW(Compound_Selector, pstate());
     // result->has_parent_reference(has_parent_reference());
@@ -1637,24 +1718,24 @@ namespace Sass {
     for (size_t i = 0, L = length(); i < L; ++i)
     {
       bool found = false;
-      std::string thisSelector((*this)[i]->to_string(ctx.c_options));
+      std::string thisSelector((*this)[i]->to_string());
       for (size_t j = 0, M = rhs->length(); j < M; ++j)
       {
-        if (thisSelector == (*rhs)[j]->to_string(ctx.c_options))
+        if (thisSelector == (*rhs)[j]->to_string())
         {
           found = true;
           break;
         }
       }
-      if (!found) result->append(&(*this)[i]);
+      if (!found) result->append((*this)[i]);
     }
 
     return result;
   }
 
-  void Compound_Selector::mergeSources(SourcesSet& sources, Context& ctx)
+  void Compound_Selector::mergeSources(ComplexSelectorSet& sources)
   {
-    for (SourcesSet::iterator iterator = sources.begin(), endIterator = sources.end(); iterator != endIterator; ++iterator) {
+    for (ComplexSelectorSet::iterator iterator = sources.begin(), endIterator = sources.end(); iterator != endIterator; ++iterator) {
       this->sources_.insert(SASS_MEMORY_CLONE(*iterator));
     }
   }
@@ -1686,38 +1767,38 @@ namespace Sass {
   void Arguments::adjust_after_pushing(Argument_Obj a)
   {
     if (!a->name().empty()) {
-      if (/* has_rest_argument_ || */ has_keyword_argument_) {
-        error("named arguments must precede variable-length argument", a->pstate());
+      if (has_keyword_argument()) {
+        coreError("named arguments must precede variable-length argument", a->pstate());
       }
-      has_named_arguments_ = true;
+      has_named_arguments(true);
     }
     else if (a->is_rest_argument()) {
-      if (has_rest_argument_) {
-        error("functions and mixins may only be called with one variable-length argument", a->pstate());
+      if (has_rest_argument()) {
+        coreError("functions and mixins may only be called with one variable-length argument", a->pstate());
       }
       if (has_keyword_argument_) {
-        error("only keyword arguments may follow variable arguments", a->pstate());
+        coreError("only keyword arguments may follow variable arguments", a->pstate());
       }
-      has_rest_argument_ = true;
+      has_rest_argument(true);
     }
     else if (a->is_keyword_argument()) {
-      if (has_keyword_argument_) {
-        error("functions and mixins may only be called with one keyword argument", a->pstate());
+      if (has_keyword_argument()) {
+        coreError("functions and mixins may only be called with one keyword argument", a->pstate());
       }
-      has_keyword_argument_ = true;
+      has_keyword_argument(true);
     }
     else {
-      if (has_rest_argument_) {
-        error("ordinal arguments must precede variable-length arguments", a->pstate());
+      if (has_rest_argument()) {
+        coreError("ordinal arguments must precede variable-length arguments", a->pstate());
       }
-      if (has_named_arguments_) {
-        error("ordinal arguments must precede named arguments", a->pstate());
+      if (has_named_arguments()) {
+        coreError("ordinal arguments must precede named arguments", a->pstate());
       }
     }
   }
 
   bool Ruleset::is_invisible() const {
-    if (Selector_List_Ptr sl = SASS_MEMORY_CAST(Selector_List, selector())) {
+    if (Selector_List_Ptr sl = Cast<Selector_List>(selector())) {
       for (size_t i = 0, L = sl->length(); i < L; ++i)
         if (!(*sl)[i]->has_placeholder()) return false;
     }
@@ -1734,367 +1815,52 @@ namespace Sass {
 
   Number::Number(ParserState pstate, double val, std::string u, bool zero)
   : Value(pstate),
+    Units(),
     value_(val),
     zero_(zero),
-    numerator_units_(std::vector<std::string>()),
-    denominator_units_(std::vector<std::string>()),
     hash_(0)
   {
-    size_t l = 0, r = 0;
+    size_t l = 0;
+    size_t r;
     if (!u.empty()) {
       bool nominator = true;
       while (true) {
         r = u.find_first_of("*/", l);
         std::string unit(u.substr(l, r == std::string::npos ? r : r - l));
         if (!unit.empty()) {
-          if (nominator) numerator_units_.push_back(unit);
-          else denominator_units_.push_back(unit);
+          if (nominator) numerators.push_back(unit);
+          else denominators.push_back(unit);
         }
         if (r == std::string::npos) break;
         // ToDo: should error for multiple slashes
         // if (!nominator && u[r] == '/') error(...)
         if (u[r] == '/')
           nominator = false;
+        // strange math parsing?
+        // else if (u[r] == '*')
+        //  nominator = true;
         l = r + 1;
       }
     }
     concrete_type(NUMBER);
   }
 
-  std::string Number::unit() const
-  {
-    std::string u;
-    for (size_t i = 0, S = numerator_units_.size(); i < S; ++i) {
-      if (i) u += '*';
-      u += numerator_units_[i];
-    }
-    if (!denominator_units_.empty()) u += '/';
-    for (size_t i = 0, S = denominator_units_.size(); i < S; ++i) {
-      if (i) u += '*';
-      u += denominator_units_[i];
-    }
-    return u;
-  }
-
-  bool Number::is_valid_css_unit() const
+  // cancel out unnecessary units
+  void Number::reduce()
   {
-    return numerator_units().size() <= 1 &&
-           denominator_units().size() == 0;
+    // apply conversion factor
+    value_ *= this->Units::reduce();
   }
 
-  bool Number::is_unitless() const
-  { return numerator_units_.empty() && denominator_units_.empty(); }
-
-  void Number::normalize(const std::string& prefered, bool strict)
+  void Number::normalize()
   {
-
-    // first make sure same units cancel each other out
-    // it seems that a map table will fit nicely to do this
-    // we basically construct exponents for each unit
-    // has the advantage that they will be pre-sorted
-    std::map<std::string, int> exponents;
-
-    // initialize by summing up occurences in unit vectors
-    for (size_t i = 0, S = numerator_units_.size(); i < S; ++i) ++ exponents[numerator_units_[i]];
-    for (size_t i = 0, S = denominator_units_.size(); i < S; ++i) -- exponents[denominator_units_[i]];
-
-    // the final conversion factor
-    double factor = 1;
-
-    // get the first entry of numerators
-    // forward it when entry is converted
-    std::vector<std::string>::iterator nom_it = numerator_units_.begin();
-    std::vector<std::string>::iterator nom_end = numerator_units_.end();
-    std::vector<std::string>::iterator denom_it = denominator_units_.begin();
-    std::vector<std::string>::iterator denom_end = denominator_units_.end();
-
-    // main normalization loop
-    // should be close to optimal
-    while (denom_it != denom_end)
-    {
-      // get and increment afterwards
-      const std::string denom = *(denom_it ++);
-      // skip already canceled out unit
-      if (exponents[denom] >= 0) continue;
-      // skip all units we don't know how to convert
-      if (string_to_unit(denom) == UNKNOWN) continue;
-      // now search for nominator
-      while (nom_it != nom_end)
-      {
-        // get and increment afterwards
-        const std::string nom = *(nom_it ++);
-        // skip already canceled out unit
-        if (exponents[nom] <= 0) continue;
-        // skip all units we don't know how to convert
-        if (string_to_unit(nom) == UNKNOWN) continue;
-        // we now have two convertable units
-        // add factor for current conversion
-        factor *= conversion_factor(nom, denom, strict);
-        // update nominator/denominator exponent
-        -- exponents[nom]; ++ exponents[denom];
-        // inner loop done
-        break;
-      }
-    }
-
-    // now we can build up the new unit arrays
-    numerator_units_.clear();
-    denominator_units_.clear();
-
-    // build them by iterating over the exponents
-    for (auto exp : exponents)
-    {
-      // maybe there is more effecient way to push
-      // the same item multiple times to a vector?
-      for(size_t i = 0, S = abs(exp.second); i < S; ++i)
-      {
-        // opted to have these switches in the inner loop
-        // makes it more readable and should not cost much
-        if (!exp.first.empty()) {
-          if (exp.second < 0) denominator_units_.push_back(exp.first);
-          else if (exp.second > 0) numerator_units_.push_back(exp.first);
-        }
-      }
-    }
-
-    // apply factor to value_
-    // best precision this way
-    value_ *= factor;
-
-    // maybe convert to other unit
-    // easier implemented on its own
-    try { convert(prefered, strict); }
-    catch (incompatibleUnits& err)
-    { error(err.what(), pstate()); }
-    catch (...) { throw; }
-
-  }
-
-  // this does not cover all cases (multiple prefered units)
-  double Number::convert_factor(const Number& n) const
-  {
-
-    // first make sure same units cancel each other out
-    // it seems that a map table will fit nicely to do this
-    // we basically construct exponents for each unit class
-    // std::map<std::string, int> exponents;
-    // initialize by summing up occurences in unit vectors
-    // for (size_t i = 0, S = numerator_units_.size(); i < S; ++i) ++ exponents[unit_to_class(numerator_units_[i])];
-    // for (size_t i = 0, S = denominator_units_.size(); i < S; ++i) -- exponents[unit_to_class(denominator_units_[i])];
-
-    std::vector<std::string> l_miss_nums(0);
-    std::vector<std::string> l_miss_dens(0);
-    // create copy since we need these for state keeping
-    std::vector<std::string> r_nums(n.numerator_units_);
-    std::vector<std::string> r_dens(n.denominator_units_);
-
-    std::vector<std::string>::const_iterator l_num_it = numerator_units_.begin();
-    std::vector<std::string>::const_iterator l_num_end = numerator_units_.end();
-
-    bool l_unitless = is_unitless();
-    bool r_unitless = n.is_unitless();
-
-    // overall conversion
-    double factor = 1;
-
-    // process all left numerators
-    while (l_num_it != l_num_end)
-    {
-      // get and increment afterwards
-      const std::string l_num = *(l_num_it ++);
-
-      std::vector<std::string>::iterator r_num_it = r_nums.begin();
-      std::vector<std::string>::iterator r_num_end = r_nums.end();
-
-      bool found = false;
-      // search for compatible numerator
-      while (r_num_it != r_num_end)
-      {
-        // get and increment afterwards
-        const std::string r_num = *(r_num_it);
-        // get possible converstion factor for units
-        double conversion = conversion_factor(l_num, r_num, false);
-        // skip incompatible numerator
-        if (conversion == 0) {
-          ++ r_num_it;
-          continue;
-        }
-        // apply to global factor
-        factor *= conversion;
-        // remove item from vector
-        r_nums.erase(r_num_it);
-        // found numerator
-        found = true;
-        break;
-      }
-      // maybe we did not find any
-      // left numerator is leftover
-      if (!found) l_miss_nums.push_back(l_num);
-    }
-
-    std::vector<std::string>::const_iterator l_den_it = denominator_units_.begin();
-    std::vector<std::string>::const_iterator l_den_end = denominator_units_.end();
-
-    // process all left denominators
-    while (l_den_it != l_den_end)
-    {
-      // get and increment afterwards
-      const std::string l_den = *(l_den_it ++);
-
-      std::vector<std::string>::iterator r_den_it = r_dens.begin();
-      std::vector<std::string>::iterator r_den_end = r_dens.end();
-
-      bool found = false;
-      // search for compatible denominator
-      while (r_den_it != r_den_end)
-      {
-        // get and increment afterwards
-        const std::string r_den = *(r_den_it);
-        // get possible converstion factor for units
-        double conversion = conversion_factor(l_den, r_den, false);
-        // skip incompatible denominator
-        if (conversion == 0) {
-          ++ r_den_it;
-          continue;
-        }
-        // apply to global factor
-        factor *= conversion;
-        // remove item from vector
-        r_dens.erase(r_den_it);
-        // found denominator
-        found = true;
-        break;
-      }
-      // maybe we did not find any
-      // left denominator is leftover
-      if (!found) l_miss_dens.push_back(l_den);
-    }
-
-    // check left-overs (ToDo: might cancel out)
-    if (l_miss_nums.size() > 0 && !r_unitless) {
-      throw Exception::IncompatibleUnits(n, *this);
-    }
-    if (l_miss_dens.size() > 0 && !r_unitless) {
-      throw Exception::IncompatibleUnits(n, *this);
-    }
-    if (r_nums.size() > 0 && !l_unitless) {
-      throw Exception::IncompatibleUnits(n, *this);
-    }
-    if (r_dens.size() > 0 && !l_unitless) {
-      throw Exception::IncompatibleUnits(n, *this);
-    }
-
-    return factor;
-  }
-
-  // this does not cover all cases (multiple prefered units)
-  bool Number::convert(const std::string& prefered, bool strict)
-  {
-    // no conversion if unit is empty
-    if (prefered.empty()) return true;
-
-    // first make sure same units cancel each other out
-    // it seems that a map table will fit nicely to do this
-    // we basically construct exponents for each unit
-    // has the advantage that they will be pre-sorted
-    std::map<std::string, int> exponents;
-
-    // initialize by summing up occurences in unit vectors
-    for (size_t i = 0, S = numerator_units_.size(); i < S; ++i) ++ exponents[numerator_units_[i]];
-    for (size_t i = 0, S = denominator_units_.size(); i < S; ++i) -- exponents[denominator_units_[i]];
-
-    // the final conversion factor
-    double factor = 1;
-
-    std::vector<std::string>::iterator denom_it = denominator_units_.begin();
-    std::vector<std::string>::iterator denom_end = denominator_units_.end();
-
-    // main normalization loop
-    // should be close to optimal
-    while (denom_it != denom_end)
-    {
-      // get and increment afterwards
-      const std::string denom = *(denom_it ++);
-      // check if conversion is needed
-      if (denom == prefered) continue;
-      // skip already canceled out unit
-      if (exponents[denom] >= 0) continue;
-      // skip all units we don't know how to convert
-      if (string_to_unit(denom) == UNKNOWN) continue;
-      // we now have two convertable units
-      // add factor for current conversion
-      factor *= conversion_factor(denom, prefered, strict);
-      // update nominator/denominator exponent
-      ++ exponents[denom]; -- exponents[prefered];
-    }
-
-    std::vector<std::string>::iterator nom_it = numerator_units_.begin();
-    std::vector<std::string>::iterator nom_end = numerator_units_.end();
-
-    // now search for nominator
-    while (nom_it != nom_end)
-    {
-      // get and increment afterwards
-      const std::string nom = *(nom_it ++);
-      // check if conversion is needed
-      if (nom == prefered) continue;
-      // skip already canceled out unit
-      if (exponents[nom] <= 0) continue;
-      // skip all units we don't know how to convert
-      if (string_to_unit(nom) == UNKNOWN) continue;
-      // we now have two convertable units
-      // add factor for current conversion
-      factor *= conversion_factor(nom, prefered, strict);
-      // update nominator/denominator exponent
-      -- exponents[nom]; ++ exponents[prefered];
-    }
-
-    // now we can build up the new unit arrays
-    numerator_units_.clear();
-    denominator_units_.clear();
-
-    // build them by iterating over the exponents
-    for (auto exp : exponents)
-    {
-      // maybe there is more effecient way to push
-      // the same item multiple times to a vector?
-      for(size_t i = 0, S = abs(exp.second); i < S; ++i)
-      {
-        // opted to have these switches in the inner loop
-        // makes it more readable and should not cost much
-        if (!exp.first.empty()) {
-          if (exp.second < 0) denominator_units_.push_back(exp.first);
-          else if (exp.second > 0) numerator_units_.push_back(exp.first);
-        }
-      }
-    }
-
-    // apply factor to value_
-    // best precision this way
-    value_ *= factor;
-
-    // success?
-    return true;
-
-  }
-
-  // useful for making one number compatible with another
-  std::string Number::find_convertible_unit() const
-  {
-    for (size_t i = 0, S = numerator_units_.size(); i < S; ++i) {
-      std::string u(numerator_units_[i]);
-      if (string_to_unit(u) != UNKNOWN) return u;
-    }
-    for (size_t i = 0, S = denominator_units_.size(); i < S; ++i) {
-      std::string u(denominator_units_[i]);
-      if (string_to_unit(u) != UNKNOWN) return u;
-    }
-    return std::string();
+    // apply conversion factor
+    value_ *= this->Units::normalize();
   }
 
   bool Custom_Warning::operator== (const Expression& rhs) const
   {
-    if (Custom_Warning_Ptr_Const r = dynamic_cast<Custom_Warning_Ptr_Const>(&rhs)) {
+    if (Custom_Warning_Ptr_Const r = Cast<Custom_Warning>(&rhs)) {
       return message() == r->message();
     }
     return false;
@@ -2102,67 +1868,59 @@ namespace Sass {
 
   bool Custom_Error::operator== (const Expression& rhs) const
   {
-    if (Custom_Error_Ptr_Const r = dynamic_cast<Custom_Error_Ptr_Const>(&rhs)) {
+    if (Custom_Error_Ptr_Const r = Cast<Custom_Error>(&rhs)) {
       return message() == r->message();
     }
     return false;
   }
 
-  bool Number::eq (const Expression& rhs) const
+  bool Number::operator== (const Expression& rhs) const
   {
-    if (Number_Ptr_Const r = dynamic_cast<Number_Ptr_Const>(&rhs)) {
-      size_t lhs_units = numerator_units_.size() + denominator_units_.size();
-      size_t rhs_units = r->numerator_units_.size() + r->denominator_units_.size();
-      if (!lhs_units && !rhs_units) {
-        return std::fabs(value() - r->value()) < NUMBER_EPSILON;
-      }
-      return (numerator_units_ == r->numerator_units_) &&
-             (denominator_units_ == r->denominator_units_) &&
-             std::fabs(value() - r->value()) < NUMBER_EPSILON;
+    if (auto rhsnr = Cast<Number>(&rhs)) {
+      return *this == *rhsnr;
     }
     return false;
   }
 
-  bool Number::operator== (const Expression& rhs) const
+  bool Number::operator== (const Number& rhs) const
   {
-    if (Number_Ptr_Const r = dynamic_cast<Number_Ptr_Const>(&rhs)) {
-      size_t lhs_units = numerator_units_.size() + denominator_units_.size();
-      size_t rhs_units = r->numerator_units_.size() + r->denominator_units_.size();
-      // unitless and only having one unit seems equivalent (will change in future)
-      if (!lhs_units || !rhs_units) {
-        return std::fabs(value() - r->value()) < NUMBER_EPSILON;
-      }
-      return (numerator_units_ == r->numerator_units_) &&
-             (denominator_units_ == r->denominator_units_) &&
-             std::fabs(value() - r->value()) < NUMBER_EPSILON;
+    Number l(*this), r(rhs); l.reduce(); r.reduce();
+    size_t lhs_units = l.numerators.size() + l.denominators.size();
+    size_t rhs_units = r.numerators.size() + r.denominators.size();
+    // unitless and only having one unit seems equivalent (will change in future)
+    if (!lhs_units || !rhs_units) {
+      return NEAR_EQUAL(l.value(), r.value());
     }
-    return false;
+    l.normalize(); r.normalize();
+    Units &lhs_unit = l, &rhs_unit = r;
+    return lhs_unit == rhs_unit &&
+      NEAR_EQUAL(l.value(), r.value());
   }
 
   bool Number::operator< (const Number& rhs) const
   {
-    size_t lhs_units = numerator_units_.size() + denominator_units_.size();
-    size_t rhs_units = rhs.numerator_units_.size() + rhs.denominator_units_.size();
+    Number l(*this), r(rhs); l.reduce(); r.reduce();
+    size_t lhs_units = l.numerators.size() + l.denominators.size();
+    size_t rhs_units = r.numerators.size() + r.denominators.size();
     // unitless and only having one unit seems equivalent (will change in future)
     if (!lhs_units || !rhs_units) {
-      return value() < rhs.value();
+      return l.value() < r.value();
     }
-
-    Number tmp_r(&rhs); // copy
-    tmp_r.normalize(find_convertible_unit());
-    std::string l_unit(unit());
-    std::string r_unit(tmp_r.unit());
-    if (unit() != tmp_r.unit()) {
-      error("cannot compare numbers with incompatible units", pstate());
+    l.normalize(); r.normalize();
+    Units &lhs_unit = l, &rhs_unit = r;
+    if (!(lhs_unit == rhs_unit)) {
+      /* ToDo: do we always get usefull backtraces? */
+      throw Exception::IncompatibleUnits(rhs, *this);
     }
-    return value() < tmp_r.value();
+    return lhs_unit < rhs_unit ||
+           l.value() < r.value();
   }
 
   bool String_Quoted::operator== (const Expression& rhs) const
   {
-    if (String_Quoted_Ptr_Const qstr = dynamic_cast<String_Quoted_Ptr_Const>(&rhs)) {
+    if (String_Quoted_Ptr_Const qstr = Cast<String_Quoted>(&rhs)) {
       return (value() == qstr->value());
-    } else if (String_Constant_Ptr_Const cstr = dynamic_cast<String_Constant_Ptr_Const>(&rhs)) {
+    } else if (String_Constant_Ptr_Const cstr = Cast<String_Constant>(&rhs)) {
       return (value() == cstr->value());
     }
     return false;
@@ -2174,9 +1932,9 @@ namespace Sass {
 
   bool String_Constant::operator== (const Expression& rhs) const
   {
-    if (String_Quoted_Ptr_Const qstr = dynamic_cast<String_Quoted_Ptr_Const>(&rhs)) {
+    if (String_Quoted_Ptr_Const qstr = Cast<String_Quoted>(&rhs)) {
       return (value() == qstr->value());
-    } else if (String_Constant_Ptr_Const cstr = dynamic_cast<String_Constant_Ptr_Const>(&rhs)) {
+    } else if (String_Constant_Ptr_Const cstr = Cast<String_Constant>(&rhs)) {
       return (value() == cstr->value());
     }
     return false;
@@ -2193,7 +1951,7 @@ namespace Sass {
 
   bool String_Schema::operator== (const Expression& rhs) const
   {
-    if (String_Schema_Ptr_Const r = dynamic_cast<String_Schema_Ptr_Const>(&rhs)) {
+    if (String_Schema_Ptr_Const r = Cast<String_Schema>(&rhs)) {
       if (length() != r->length()) return false;
       for (size_t i = 0, L = length(); i < L; ++i) {
         Expression_Obj rv = (*r)[i];
@@ -2208,7 +1966,7 @@ namespace Sass {
 
   bool Boolean::operator== (const Expression& rhs) const
   {
-    if (Boolean_Ptr_Const r = dynamic_cast<Boolean_Ptr_Const>(&rhs)) {
+    if (Boolean_Ptr_Const r = Cast<Boolean>(&rhs)) {
       return (value() == r->value());
     }
     return false;
@@ -2216,7 +1974,7 @@ namespace Sass {
 
   bool Color::operator== (const Expression& rhs) const
   {
-    if (Color_Ptr_Const r = dynamic_cast<Color_Ptr_Const>(&rhs)) {
+    if (Color_Ptr_Const r = Cast<Color>(&rhs)) {
       return r_ == r->r() &&
              g_ == r->g() &&
              b_ == r->b() &&
@@ -2227,9 +1985,10 @@ namespace Sass {
 
   bool List::operator== (const Expression& rhs) const
   {
-    if (List_Ptr_Const r = dynamic_cast<List_Ptr_Const>(&rhs)) {
+    if (List_Ptr_Const r = Cast<List>(&rhs)) {
       if (length() != r->length()) return false;
       if (separator() != r->separator()) return false;
+      if (is_bracketed() != r->is_bracketed()) return false;
       for (size_t i = 0, L = length(); i < L; ++i) {
         Expression_Obj rv = r->at(i);
         Expression_Obj lv = this->at(i);
@@ -2243,7 +2002,7 @@ namespace Sass {
 
   bool Map::operator== (const Expression& rhs) const
   {
-    if (Map_Ptr_Const r = dynamic_cast<Map_Ptr_Const>(&rhs)) {
+    if (Map_Ptr_Const r = Cast<Map>(&rhs)) {
       if (length() != r->length()) return false;
       for (auto key : keys()) {
         Expression_Obj lv = at(key);
@@ -2261,13 +2020,23 @@ namespace Sass {
     return rhs.concrete_type() == NULL_VAL;
   }
 
+  bool Function::operator== (const Expression& rhs) const
+  {
+    if (Function_Ptr_Const r = Cast<Function>(&rhs)) {
+      Definition_Ptr_Const d1 = Cast<Definition>(definition());
+      Definition_Ptr_Const d2 = Cast<Definition>(r->definition());
+      return d1 && d2 && d1 == d2 && is_css() == r->is_css();
+    }
+    return false;
+  }
+
   size_t List::size() const {
     if (!is_arglist_) return length();
     // arglist expects a list of arguments
     // so we need to break before keywords
     for (size_t i = 0, L = length(); i < L; ++i) {
       Expression_Obj obj = this->at(i);
-      if (Argument* arg = dynamic_cast<Argument*>(&obj)) {
+      if (Argument_Ptr arg = Cast<Argument>(obj)) {
         if (!arg->name().empty()) return i;
       }
     }
@@ -2290,7 +2059,7 @@ namespace Sass {
     return is_interpolant() || (right() && right()->is_right_interpolant());
   }
 
-  std::string AST_Node::to_string(Sass_Inspect_Options opt) const
+  const std::string AST_Node::to_string(Sass_Inspect_Options opt) const
   {
     Sass_Output_Options out(opt);
     Emitter emitter(out);
@@ -2301,7 +2070,7 @@ namespace Sass {
     return i.get_buffer();
   }
 
-  std::string AST_Node::to_string() const
+  const std::string AST_Node::to_string() const
   {
     return to_string({ NESTED, 5 });
   }
@@ -2316,33 +2085,40 @@ namespace Sass {
     return quote(value_, '*');
   }
 
+  bool Declaration::is_invisible() const
+  {
+    if (is_custom_property()) return false;
+
+    return !(value_ && value_->concrete_type() != Expression::NULL_VAL);
+  }
+
   //////////////////////////////////////////////////////////////////////////////////////////
   // Additional method on Lists to retrieve values directly or from an encompassed Argument.
   //////////////////////////////////////////////////////////////////////////////////////////
   Expression_Obj List::value_at_index(size_t i) {
     Expression_Obj obj = this->at(i);
     if (is_arglist_) {
-      if (Argument* arg = dynamic_cast<Argument*>(&obj)) {
+      if (Argument_Ptr arg = Cast<Argument>(obj)) {
         return arg->value();
       } else {
-        return &obj;
+        return obj;
       }
     } else {
-      return &obj;
+      return obj;
     }
   }
 
   //////////////////////////////////////////////////////////////////////////////////////////
   // Convert map to (key, value) list.
   //////////////////////////////////////////////////////////////////////////////////////////
-  List_Obj Map::to_list(Context& ctx, ParserState& pstate) {
+  List_Obj Map::to_list(ParserState& pstate) {
     List_Obj ret = SASS_MEMORY_NEW(List, pstate, length(), SASS_COMMA);
 
     for (auto key : keys()) {
       List_Obj l = SASS_MEMORY_NEW(List, pstate, 2);
-      l->append(&key);
+      l->append(key);
       l->append(at(key));
-      ret->append(&l);
+      ret->append(l);
     }
 
     return ret;
@@ -2396,6 +2172,7 @@ namespace Sass {
   IMPLEMENT_AST_OPERATORS(Custom_Error);
   IMPLEMENT_AST_OPERATORS(List);
   IMPLEMENT_AST_OPERATORS(Map);
+  IMPLEMENT_AST_OPERATORS(Function);
   IMPLEMENT_AST_OPERATORS(Number);
   IMPLEMENT_AST_OPERATORS(Binary_Expression);
   IMPLEMENT_AST_OPERATORS(String_Schema);
@@ -2439,7 +2216,6 @@ namespace Sass {
   IMPLEMENT_AST_OPERATORS(Function_Call_Schema);
   IMPLEMENT_AST_OPERATORS(Block);
   IMPLEMENT_AST_OPERATORS(Content);
-  IMPLEMENT_AST_OPERATORS(Textual);
   IMPLEMENT_AST_OPERATORS(Trace);
   IMPLEMENT_AST_OPERATORS(Keyframe_Rule);
   IMPLEMENT_AST_OPERATORS(Bubble);
@@ -2447,5 +2223,4 @@ namespace Sass {
   IMPLEMENT_AST_OPERATORS(Placeholder_Selector);
   IMPLEMENT_AST_OPERATORS(Definition);
   IMPLEMENT_AST_OPERATORS(Declaration);
-
 }