sassc 1.10.1 → 1.11.0

data/ext/libsass/docs/implementations.md

@@ -3,6 +3,9 @@ There are several implementations of `libsass` for a variety of languages. Here
 ### C
 * [sassc](https://github.com/hcatlin/sassc)
 
+### Elixir
+* [sass.ex](https://github.com/scottdavis/sass.ex)
+
 ### Go
 * [go-libsass](https://github.com/wellington/go-libsass)
 * [go_sass](https://github.com/suapapa/go_sass)
@@ -32,6 +35,7 @@ There are several implementations of `libsass` for a variety of languages. Here
 
 ### PHP
 * [sassphp](https://github.com/sensational/sassphp)
+* [php-sass](https://github.com/lesstif/php-sass)
 
 ### Python
 * [libsass-python](https://github.com/dahlia/libsass-python)

data/ext/libsass/include/sass/base.h

@@ -63,11 +63,11 @@ enum Sass_Output_Style {
 };
 
 // to allocate buffer to be filled
-void* sass_alloc_memory(size_t size);
+ADDAPI void* ADDCALL sass_alloc_memory(size_t size);
 // to allocate a buffer from existing string
-char* sass_copy_c_string(const char* str);
+ADDAPI char* ADDCALL sass_copy_c_string(const char* str);
 // to free overtaken memory when done
-void sass_free_memory(void* ptr);
+ADDAPI void ADDCALL sass_free_memory(void* ptr);
 
 // Some convenient string helper function
 ADDAPI char* ADDCALL sass_string_quote (const char* str, const char quote_mark);
@@ -76,7 +76,8 @@ ADDAPI char* ADDCALL sass_string_unquote (const char* str);
 // Resolve a file via the given include paths in the include char* array
 ADDAPI char* ADDCALL sass_resolve_file (const char* path, const char* incs[]);
 
-// Get compiled libsass version
+// Implemented sass language version
+// Hardcoded version 3.4 for time being
 ADDAPI const char* ADDCALL libsass_version(void);
 
 // Get compiled libsass language

data/ext/libsass/include/sass/context.h

@@ -50,6 +50,7 @@ ADDAPI int ADDCALL sass_compiler_execute(struct Sass_Compiler* compiler);
 // Release all memory allocated with the compiler
 // This does _not_ include any contexts or options
 ADDAPI void ADDCALL sass_delete_compiler(struct Sass_Compiler* compiler);
+ADDAPI void ADDCALL sass_delete_options(struct Sass_Options* options);
 
 // Release all memory allocated and also ourself
 ADDAPI void ADDCALL sass_delete_file_context (struct Sass_File_Context* ctx);
@@ -73,6 +74,7 @@ ADDAPI enum Sass_Output_Style ADDCALL sass_option_get_output_style (struct Sass_
 ADDAPI bool ADDCALL sass_option_get_source_comments (struct Sass_Options* options);
 ADDAPI bool ADDCALL sass_option_get_source_map_embed (struct Sass_Options* options);
 ADDAPI bool ADDCALL sass_option_get_source_map_contents (struct Sass_Options* options);
+ADDAPI bool ADDCALL sass_option_get_source_map_file_urls (struct Sass_Options* options);
 ADDAPI bool ADDCALL sass_option_get_omit_source_map_url (struct Sass_Options* options);
 ADDAPI bool ADDCALL sass_option_get_is_indented_syntax_src (struct Sass_Options* options);
 ADDAPI const char* ADDCALL sass_option_get_indent (struct Sass_Options* options);
@@ -93,6 +95,7 @@ ADDAPI void ADDCALL sass_option_set_output_style (struct Sass_Options* options,
 ADDAPI void ADDCALL sass_option_set_source_comments (struct Sass_Options* options, bool source_comments);
 ADDAPI void ADDCALL sass_option_set_source_map_embed (struct Sass_Options* options, bool source_map_embed);
 ADDAPI void ADDCALL sass_option_set_source_map_contents (struct Sass_Options* options, bool source_map_contents);
+ADDAPI void ADDCALL sass_option_set_source_map_file_urls (struct Sass_Options* options, bool source_map_file_urls);
 ADDAPI void ADDCALL sass_option_set_omit_source_map_url (struct Sass_Options* options, bool omit_source_map_url);
 ADDAPI void ADDCALL sass_option_set_is_indented_syntax_src (struct Sass_Options* options, bool is_indented_syntax_src);
 ADDAPI void ADDCALL sass_option_set_indent (struct Sass_Options* options, const char* indent);

data/ext/libsass/include/sass/values.h

@@ -30,6 +30,8 @@ enum Sass_Tag {
 enum Sass_Separator {
   SASS_COMMA,
   SASS_SPACE,
+  // only used internally to represent a hash map before evaluation
+  // otherwise we would be too early to check for duplicate keys
   SASS_HASH
 };
 
@@ -41,6 +43,32 @@ enum Sass_OP {
   NUM_OPS                    // so we know how big to make the op table
 };
 
+// Creator functions for all value types
+ADDAPI union Sass_Value* ADDCALL sass_make_null    (void);
+ADDAPI union Sass_Value* ADDCALL sass_make_boolean (bool val);
+ADDAPI union Sass_Value* ADDCALL sass_make_string  (const char* val);
+ADDAPI union Sass_Value* ADDCALL sass_make_qstring (const char* val);
+ADDAPI union Sass_Value* ADDCALL sass_make_number  (double val, const char* unit);
+ADDAPI union Sass_Value* ADDCALL sass_make_color   (double r, double g, double b, double a);
+ADDAPI union Sass_Value* ADDCALL sass_make_list    (size_t len, enum Sass_Separator sep);
+ADDAPI union Sass_Value* ADDCALL sass_make_map     (size_t len);
+ADDAPI union Sass_Value* ADDCALL sass_make_error   (const char* msg);
+ADDAPI union Sass_Value* ADDCALL sass_make_warning (const char* msg);
+
+// Generic destructor function for all types
+// Will release memory of all associated Sass_Values
+// Means we will delete recursively for lists and maps
+ADDAPI void ADDCALL sass_delete_value (union Sass_Value* val);
+
+// Make a deep cloned copy of the given sass value
+ADDAPI union Sass_Value* ADDCALL sass_clone_value (const union Sass_Value* val);
+
+// Execute an operation for two Sass_Values and return the result as a Sass_Value too
+ADDAPI union Sass_Value* ADDCALL sass_value_op (enum Sass_OP op, const union Sass_Value* a, const union Sass_Value* b);
+
+// Stringify a Sass_Values and also return the result as a Sass_Value (of type STRING)
+ADDAPI union Sass_Value* ADDCALL sass_value_stringify (const union Sass_Value* a, bool compressed, int precision);
+
 // Return the sass tag for a generic sass value
 // Check is needed before accessing specific values!
 ADDAPI enum Sass_Tag ADDCALL sass_value_get_tag (const union Sass_Value* v);
@@ -108,33 +136,6 @@ ADDAPI void ADDCALL sass_error_set_message (union Sass_Value* v, char* msg);
 ADDAPI char* ADDCALL sass_warning_get_message (const union Sass_Value* v);
 ADDAPI void ADDCALL sass_warning_set_message (union Sass_Value* v, char* msg);
 
-// Creator functions for all value types
-ADDAPI union Sass_Value* ADDCALL sass_make_null    (void);
-ADDAPI union Sass_Value* ADDCALL sass_make_boolean (bool val);
-ADDAPI union Sass_Value* ADDCALL sass_make_string  (const char* val);
-ADDAPI union Sass_Value* ADDCALL sass_make_qstring (const char* val);
-ADDAPI union Sass_Value* ADDCALL sass_make_number  (double val, const char* unit);
-ADDAPI union Sass_Value* ADDCALL sass_make_color   (double r, double g, double b, double a);
-ADDAPI union Sass_Value* ADDCALL sass_make_list    (size_t len, enum Sass_Separator sep);
-ADDAPI union Sass_Value* ADDCALL sass_make_map     (size_t len);
-ADDAPI union Sass_Value* ADDCALL sass_make_error   (const char* msg);
-ADDAPI union Sass_Value* ADDCALL sass_make_warning (const char* msg);
-
-// Generic destructor function for all types
-// Will release memory of all associated Sass_Values
-// Means we will delete recursively for lists and maps
-ADDAPI void ADDCALL sass_delete_value (union Sass_Value* val);
-
-// Make a deep cloned copy of the given sass value
-ADDAPI union Sass_Value* ADDCALL sass_clone_value (const union Sass_Value* val);
-
-// Stringify a Sass_Values and also return the result as a Sass_Value (of type STRING)
-ADDAPI union Sass_Value* ADDCALL sass_value_stringify (const union Sass_Value* a, bool compressed, int precision);
-
-// Execute an operation for two Sass_Values and return the result as a Sass_Value too
-ADDAPI union Sass_Value* ADDCALL sass_value_op (enum Sass_OP op, const union Sass_Value* a, const union Sass_Value* b);
-
-
 #ifdef __cplusplus
 } // __cplusplus defined.
 #endif

data/ext/libsass/include/sass/version.h

@@ -6,7 +6,7 @@
 #endif
 
 #ifndef LIBSASS_LANGUAGE_VERSION
-#define LIBSASS_LANGUAGE_VERSION "[NA]"
+#define LIBSASS_LANGUAGE_VERSION "3.4"
 #endif
 
 #endif

data/ext/libsass/include/sass2scss.h

@@ -37,7 +37,7 @@
 #ifndef SASS2SCSS_VERSION
 // Hardcode once the file is copied from
 // https://github.com/mgreter/sass2scss
-#define SASS2SCSS_VERSION "1.0.6"
+#define SASS2SCSS_VERSION "1.1.0"
 #endif
 
 // add namespace for c++

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

@@ -120,10 +120,10 @@ then
     echo "Fetching Sass Spec PR $SPEC_PR"
     git -C sass-spec fetch -u origin pull/$SPEC_PR/head:ci-spec-pr-$SPEC_PR
     git -C sass-spec checkout --force ci-spec-pr-$SPEC_PR
-    LD_LIBRARY_PATH="$PREFIX/lib/" make $MAKE_OPTS test_probe
+    LD_LIBRARY_PATH="$PREFIX/lib/" make $MAKE_OPTS test_build
   else
-    LD_LIBRARY_PATH="$PREFIX/lib/" make $MAKE_OPTS test_probe
+    LD_LIBRARY_PATH="$PREFIX/lib/" make $MAKE_OPTS test_build
   fi
 else
-  LD_LIBRARY_PATH="$PREFIX/lib/" make $MAKE_OPTS test_probe
+  LD_LIBRARY_PATH="$PREFIX/lib/" make $MAKE_OPTS test_build
 fi

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

@@ -7,8 +7,17 @@ else
 fi
 
 if [ "x$AUTOTOOLS" == "xyes" ]; then
-  sudo add-apt-repository -y ppa:rbose-debianizer/automake &> /dev/null
-  sudo apt-get -qq update
-  sudo apt-get -qq install automake
   AUTOTOOLS=yes
+
+  if [ "$TRAVIS_OS_NAME" == "linux" ]; then
+    sudo add-apt-repository -y ppa:rbose-debianizer/automake &> /dev/null
+    sudo apt-get -qq update
+    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

data/ext/libsass/src/ast.cpp

@@ -74,6 +74,21 @@ namespace Sass {
     ltrim();
   }
 
+  void Argument::set_delayed(bool delayed)
+  {
+    if (value_) value_->set_delayed(delayed);
+    is_delayed(delayed);
+  }
+
+  void Arguments::set_delayed(bool delayed)
+  {
+    for (Argument* arg : elements()) {
+      if (arg) arg->set_delayed(delayed);
+    }
+    is_delayed(delayed);
+  }
+
+
   bool At_Root_Query::exclude(std::string str)
   {
     bool with = feature() && unquote(feature()->to_string()).compare("with") == 0;
@@ -107,6 +122,11 @@ 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)
   {
     if (l.empty() && r.empty()) return true;
@@ -117,7 +137,7 @@ namespace Sass {
 
 
 
-  bool Compound_Selector::operator< (const Compound_Selector& rhs) const
+  bool SimpleSequence_Selector::operator< (const SimpleSequence_Selector& rhs) const
   {
     size_t L = std::min(length(), rhs.length());
     for (size_t i = 0; i < L; ++i)
@@ -134,7 +154,7 @@ namespace Sass {
     return length() < rhs.length();
   }
 
-  bool Compound_Selector::has_parent_ref()
+  bool SimpleSequence_Selector::has_parent_ref()
   {
     for (Simple_Selector* s : *this) {
       if (s && s->has_parent_ref()) return true;
@@ -142,19 +162,33 @@ namespace Sass {
     return false;
   }
 
-  bool Complex_Selector::has_parent_ref()
+  bool SimpleSequence_Selector::has_real_parent_ref()
+  {
+    for (Simple_Selector* s : *this) {
+      if (s && s->has_real_parent_ref()) return true;
+    }
+    return false;
+  }
+
+  bool Sequence_Selector::has_parent_ref()
   {
     return (head() && head()->has_parent_ref()) ||
            (tail() && tail()->has_parent_ref());
   }
 
-  bool Complex_Selector::operator< (const Complex_Selector& rhs) const
+  bool Sequence_Selector::has_real_parent_ref()
+  {
+    return (head() && head()->has_real_parent_ref()) ||
+           (tail() && tail()->has_real_parent_ref());
+  }
+
+  bool Sequence_Selector::operator< (const Sequence_Selector& rhs) const
   {
     // const iterators for tails
-    const Complex_Selector* l = this;
-    const Complex_Selector* r = &rhs;
-    Compound_Selector* l_h = l ? l->head() : 0;
-    Compound_Selector* r_h = r ? r->head() : 0;
+    const Sequence_Selector* l = this;
+    const Sequence_Selector* r = &rhs;
+    SimpleSequence_Selector* l_h = l ? l->head() : 0;
+    SimpleSequence_Selector* r_h = r ? r->head() : 0;
     // process all tails
     while (true)
     {
@@ -210,13 +244,13 @@ namespace Sass {
     return true;
   }
 
-  bool Complex_Selector::operator== (const Complex_Selector& rhs) const
+  bool Sequence_Selector::operator== (const Sequence_Selector& rhs) const
   {
     // const iterators for tails
-    const Complex_Selector* l = this;
-    const Complex_Selector* r = &rhs;
-    Compound_Selector* l_h = l ? l->head() : 0;
-    Compound_Selector* r_h = r ? r->head() : 0;
+    const Sequence_Selector* l = this;
+    const Sequence_Selector* r = &rhs;
+    SimpleSequence_Selector* l_h = l ? l->head() : 0;
+    SimpleSequence_Selector* r_h = r ? r->head() : 0;
     // process all tails
     while (true)
     {
@@ -273,9 +307,9 @@ namespace Sass {
     return false;
   }
 
-  Compound_Selector* Compound_Selector::unify_with(Compound_Selector* rhs, Context& ctx)
+  SimpleSequence_Selector* SimpleSequence_Selector::unify_with(SimpleSequence_Selector* rhs, Context& ctx)
   {
-    Compound_Selector* unified = rhs;
+    SimpleSequence_Selector* unified = rhs;
     for (size_t i = 0, L = length(); i < L; ++i)
     {
       if (!unified) break;
@@ -304,18 +338,18 @@ namespace Sass {
     return ns() < rhs.ns();
   }
 
-  bool Selector_List::operator== (const Selector& rhs) const
+  bool CommaSequence_Selector::operator== (const Selector& rhs) const
   {
     // solve the double dispatch problem by using RTTI information via dynamic cast
-    if (const Selector_List* ls = dynamic_cast<const Selector_List*>(&rhs)) { return *this == *ls; }
-    else if (const Complex_Selector* ls = dynamic_cast<const Complex_Selector*>(&rhs)) { return *this == *ls; }
-    else if (const Compound_Selector* ls = dynamic_cast<const Compound_Selector*>(&rhs)) { return *this == *ls; }
+    if (const CommaSequence_Selector* ls = dynamic_cast<const CommaSequence_Selector*>(&rhs)) { return *this == *ls; }
+    else if (const Sequence_Selector* ls = dynamic_cast<const Sequence_Selector*>(&rhs)) { return *this == *ls; }
+    else if (const SimpleSequence_Selector* ls = dynamic_cast<const SimpleSequence_Selector*>(&rhs)) { return *this == *ls; }
     // no compare method
     return this == &rhs;
   }
 
   // Selector lists can be compared to comma lists
-  bool Selector_List::operator==(const Expression& rhs) const
+  bool CommaSequence_Selector::operator==(const Expression& rhs) const
   {
     // solve the double dispatch problem by using RTTI information via dynamic cast
     if (const List* ls = dynamic_cast<const List*>(&rhs)) { return *this == *ls; }
@@ -324,15 +358,15 @@ namespace Sass {
     return false;
   }
 
-  bool Selector_List::operator== (const Selector_List& rhs) const
+  bool CommaSequence_Selector::operator== (const CommaSequence_Selector& rhs) const
   {
     // for array access
     size_t i = 0, n = 0;
     size_t iL = length();
     size_t nL = rhs.length();
     // create temporary vectors and sort them
-    std::vector<Complex_Selector*> l_lst = this->elements();
-    std::vector<Complex_Selector*> r_lst = rhs.elements();
+    std::vector<Sequence_Selector*> l_lst = this->elements();
+    std::vector<Sequence_Selector*> 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());
     // process loop
@@ -342,8 +376,8 @@ namespace Sass {
       if (i == iL) return iL == nL;
       else if (n == nL) return iL == nL;
       // the access the vector items
-      Complex_Selector* l = l_lst[i];
-      Complex_Selector* r = r_lst[n];
+      Sequence_Selector* l = l_lst[i];
+      Sequence_Selector* r = r_lst[n];
       // skip nulls
       if (!l) ++i;
       else if (!r) ++n;
@@ -357,7 +391,7 @@ namespace Sass {
     return true;
   }
 
-  Compound_Selector* Simple_Selector::unify_with(Compound_Selector* rhs, Context& ctx)
+  SimpleSequence_Selector* Simple_Selector::unify_with(SimpleSequence_Selector* rhs, Context& ctx)
   {
     for (size_t i = 0, L = rhs->length(); i < L; ++i)
     { if (to_string(ctx.c_options) == (*rhs)[i]->to_string(ctx.c_options)) return rhs; }
@@ -383,11 +417,11 @@ namespace Sass {
     }
     if (!found)
     {
-      Compound_Selector* cpy = SASS_MEMORY_NEW(ctx.mem, Compound_Selector, *rhs);
+      SimpleSequence_Selector* cpy = SASS_MEMORY_NEW(ctx.mem, SimpleSequence_Selector, *rhs);
       (*cpy) << this;
       return cpy;
     }
-    Compound_Selector* cpy = SASS_MEMORY_NEW(ctx.mem, Compound_Selector, rhs->pstate());
+    SimpleSequence_Selector* cpy = SASS_MEMORY_NEW(ctx.mem, SimpleSequence_Selector, rhs->pstate());
     for (size_t j = 0; j < i; ++j)
     { (*cpy) << (*rhs)[j]; }
     (*cpy) << this;
@@ -396,7 +430,7 @@ namespace Sass {
     return cpy;
   }
 
-  Simple_Selector* Type_Selector::unify_with(Simple_Selector* rhs, Context& ctx)
+  Simple_Selector* Element_Selector::unify_with(Simple_Selector* rhs, Context& ctx)
   {
     // check if ns can be extended
     // true for no ns or universal
@@ -407,7 +441,7 @@ namespace Sass {
       if (!rhs->is_universal_ns())
       {
         // creaty the copy inside (avoid unnecessary copies)
-        Type_Selector* ts = SASS_MEMORY_NEW(ctx.mem, Type_Selector, *this);
+        Element_Selector* ts = SASS_MEMORY_NEW(ctx.mem, Element_Selector, *this);
         // overwrite the name if star is given as name
         if (ts->name() == "*") { ts->name(rhs->name()); }
         // now overwrite the namespace name and flag
@@ -421,7 +455,7 @@ namespace Sass {
     if (name() == "*" && rhs->name() != "*")
     {
       // creaty the copy inside (avoid unnecessary copies)
-      Type_Selector* ts = SASS_MEMORY_NEW(ctx.mem, Type_Selector, *this);
+      Element_Selector* ts = SASS_MEMORY_NEW(ctx.mem, Element_Selector, *this);
       // simply set the new name
       ts->name(rhs->name());
       // return copy
@@ -431,13 +465,13 @@ namespace Sass {
     return this;
   }
 
-  Compound_Selector* Type_Selector::unify_with(Compound_Selector* rhs, Context& ctx)
+  SimpleSequence_Selector* Element_Selector::unify_with(SimpleSequence_Selector* rhs, Context& ctx)
   {
     // TODO: handle namespaces
 
     // if the rhs is empty, just return a copy of this
     if (rhs->length() == 0) {
-      Compound_Selector* cpy = SASS_MEMORY_NEW(ctx.mem, Compound_Selector, rhs->pstate());
+      SimpleSequence_Selector* cpy = SASS_MEMORY_NEW(ctx.mem, SimpleSequence_Selector, rhs->pstate());
       (*cpy) << this;
       return cpy;
     }
@@ -446,17 +480,17 @@ namespace Sass {
     // otherwise, this is a tag name
     if (name() == "*")
     {
-      if (typeid(*rhs_0) == typeid(Type_Selector))
+      if (typeid(*rhs_0) == typeid(Element_Selector))
       {
         // if rhs is universal, just return this tagname + rhs's qualifiers
-        Compound_Selector* cpy = SASS_MEMORY_NEW(ctx.mem, Compound_Selector, *rhs);
-        Type_Selector* ts = static_cast<Type_Selector*>(rhs_0);
+        SimpleSequence_Selector* cpy = SASS_MEMORY_NEW(ctx.mem, SimpleSequence_Selector, *rhs);
+        Element_Selector* ts = static_cast<Element_Selector*>(rhs_0);
         (*cpy)[0] = this->unify_with(ts, ctx);
         return cpy;
       }
-      else if (dynamic_cast<Selector_Qualifier*>(rhs_0)) {
+      else if (dynamic_cast<Class_Selector*>(rhs_0) || dynamic_cast<Id_Selector*>(rhs_0)) {
         // qualifier is `.class`, so we can prefix with `ns|*.class`
-        Compound_Selector* cpy = SASS_MEMORY_NEW(ctx.mem, Compound_Selector, rhs->pstate());
+        SimpleSequence_Selector* cpy = SASS_MEMORY_NEW(ctx.mem, SimpleSequence_Selector, rhs->pstate());
         if (has_ns() && !rhs_0->has_ns()) {
           if (ns() != "*") (*cpy) << this;
         }
@@ -469,41 +503,43 @@ namespace Sass {
       return rhs;
     }
 
-    if (typeid(*rhs_0) == typeid(Type_Selector))
+    if (typeid(*rhs_0) == typeid(Element_Selector))
     {
       // 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
-      Compound_Selector* copy = SASS_MEMORY_NEW(ctx.mem, Compound_Selector, *rhs);
+      SimpleSequence_Selector* copy = SASS_MEMORY_NEW(ctx.mem, SimpleSequence_Selector, *rhs);
       (*copy)[0] = this->unify_with(rhs_0, ctx);
       return copy;
 
     }
     // else it's a tag name and a bunch of qualifiers -- just append them
-    Compound_Selector* cpy = SASS_MEMORY_NEW(ctx.mem, Compound_Selector, rhs->pstate());
+    SimpleSequence_Selector* cpy = SASS_MEMORY_NEW(ctx.mem, SimpleSequence_Selector, rhs->pstate());
     if (name() != "*") (*cpy) << this;
     (*cpy) += rhs;
     return cpy;
   }
 
-  Compound_Selector* Selector_Qualifier::unify_with(Compound_Selector* rhs, Context& ctx)
+  SimpleSequence_Selector* Class_Selector::unify_with(SimpleSequence_Selector* rhs, Context& ctx)
   {
-    if (name()[0] == '#')
+    rhs->has_line_break(has_line_break());
+    return Simple_Selector::unify_with(rhs, ctx);
+  }
+
+  SimpleSequence_Selector* Id_Selector::unify_with(SimpleSequence_Selector* rhs, Context& ctx)
+  {
+    for (size_t i = 0, L = rhs->length(); i < L; ++i)
     {
-      for (size_t i = 0, L = rhs->length(); i < L; ++i)
-      {
-        Simple_Selector* rhs_i = (*rhs)[i];
-        if (typeid(*rhs_i) == typeid(Selector_Qualifier) &&
-            static_cast<Selector_Qualifier*>(rhs_i)->name()[0] == '#' &&
-            static_cast<Selector_Qualifier*>(rhs_i)->name() != name())
-          return 0;
+      Simple_Selector* rhs_i = (*rhs)[i];
+      if (typeid(*rhs_i) == typeid(Id_Selector) && static_cast<Id_Selector*>(rhs_i)->name() != name()) {
+        return 0;
       }
     }
     rhs->has_line_break(has_line_break());
     return Simple_Selector::unify_with(rhs, ctx);
   }
 
-  Compound_Selector* Pseudo_Selector::unify_with(Compound_Selector* rhs, Context& ctx)
+  SimpleSequence_Selector* Pseudo_Selector::unify_with(SimpleSequence_Selector* rhs, Context& ctx)
   {
     if (is_pseudo_element())
     {
@@ -645,34 +681,34 @@ namespace Sass {
   {
     if (this->name() != sub->name()) return false;
     if (this->name() == ":current") return false;
-    if (Selector_List* rhs_list = dynamic_cast<Selector_List*>(sub->selector())) {
-      if (Selector_List* lhs_list = dynamic_cast<Selector_List*>(selector())) {
+    if (CommaSequence_Selector* rhs_list = dynamic_cast<CommaSequence_Selector*>(sub->selector())) {
+      if (CommaSequence_Selector* lhs_list = dynamic_cast<CommaSequence_Selector*>(selector())) {
         return lhs_list->is_superselector_of(rhs_list);
       }
-      error("is_superselector expected a Selector_List", sub->pstate());
+      error("is_superselector expected a CommaSequence_Selector", sub->pstate());
     } else {
-      error("is_superselector expected a Selector_List", sub->pstate());
+      error("is_superselector expected a CommaSequence_Selector", sub->pstate());
     }
     return false;
   }
 
-  bool Compound_Selector::is_superselector_of(Selector_List* rhs, std::string wrapped)
+  bool SimpleSequence_Selector::is_superselector_of(CommaSequence_Selector* rhs, std::string wrapped)
   {
-    for (Complex_Selector* item : rhs->elements()) {
+    for (Sequence_Selector* item : rhs->elements()) {
       if (is_superselector_of(item, wrapped)) return true;
     }
     return false;
   }
 
-  bool Compound_Selector::is_superselector_of(Complex_Selector* rhs, std::string wrapped)
+  bool SimpleSequence_Selector::is_superselector_of(Sequence_Selector* rhs, std::string wrapped)
   {
     if (rhs->head()) return is_superselector_of(rhs->head(), wrapped);
     return false;
   }
 
-  bool Compound_Selector::is_superselector_of(Compound_Selector* rhs, std::string wrapping)
+  bool SimpleSequence_Selector::is_superselector_of(SimpleSequence_Selector* rhs, std::string wrapping)
   {
-    Compound_Selector* lhs = this;
+    SimpleSequence_Selector* lhs = this;
     Simple_Selector* lbase = lhs->base();
     Simple_Selector* rbase = rhs->base();
 
@@ -719,7 +755,7 @@ namespace Sass {
       // very special case for wrapped matches selector
       if (Wrapped_Selector* wrapped = dynamic_cast<Wrapped_Selector*>(lhs)) {
         if (wrapped->name() == ":not") {
-          if (Selector_List* not_list = dynamic_cast<Selector_List*>(wrapped->selector())) {
+          if (CommaSequence_Selector* not_list = dynamic_cast<CommaSequence_Selector*>(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");
@@ -727,8 +763,8 @@ namespace Sass {
         }
         if (wrapped->name() == ":matches" || wrapped->name() == ":-moz-any") {
           lhs = wrapped->selector();
-          if (Selector_List* list = dynamic_cast<Selector_List*>(wrapped->selector())) {
-            if (Compound_Selector* comp = dynamic_cast<Compound_Selector*>(rhs)) {
+          if (CommaSequence_Selector* list = dynamic_cast<CommaSequence_Selector*>(wrapped->selector())) {
+            if (SimpleSequence_Selector* comp = dynamic_cast<SimpleSequence_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;
@@ -755,7 +791,7 @@ namespace Sass {
       auto r = (*rhs)[n];
       if (Wrapped_Selector* wrapped = dynamic_cast<Wrapped_Selector*>(r)) {
         if (wrapped->name() == ":not") {
-          if (Selector_List* ls = dynamic_cast<Selector_List*>(wrapped->selector())) {
+          if (CommaSequence_Selector* ls = dynamic_cast<CommaSequence_Selector*>(wrapped->selector())) {
             ls->remove_parent_selectors();
             if (is_superselector_of(ls, wrapped->name())) return false;
           }
@@ -764,7 +800,7 @@ namespace Sass {
           if (!wrapping.empty()) {
             if (wrapping != wrapped->name()) return false;
           }
-          if (Selector_List* ls = dynamic_cast<Selector_List*>(wrapped->selector())) {
+          if (CommaSequence_Selector* ls = dynamic_cast<CommaSequence_Selector*>(wrapped->selector())) {
             ls->remove_parent_selectors();
             return (is_superselector_of(ls, wrapped->name()));
           }
@@ -783,22 +819,22 @@ namespace Sass {
   }
 
   // create complex selector (ancestor of) from compound selector
-  Complex_Selector* Compound_Selector::to_complex(Memory_Manager& mem)
+  Sequence_Selector* SimpleSequence_Selector::to_complex(Memory_Manager& mem)
   {
     // create an intermediate complex selector
-    return SASS_MEMORY_NEW(mem, Complex_Selector,
+    return SASS_MEMORY_NEW(mem, Sequence_Selector,
                            pstate(),
-                           Complex_Selector::ANCESTOR_OF,
+                           Sequence_Selector::ANCESTOR_OF,
                            this,
                            0);
   }
 
-  Selector_List* Complex_Selector::unify_with(Complex_Selector* other, Context& ctx)
+  CommaSequence_Selector* Sequence_Selector::unify_with(Sequence_Selector* other, Context& ctx)
   {
 
     // get last tails (on the right side)
-    Complex_Selector* l_last = this->last();
-    Complex_Selector* r_last = other->last();
+    Sequence_Selector* l_last = this->last();
+    Sequence_Selector* r_last = other->last();
 
     // check valid pointers (assertion)
     SASS_ASSERT(l_last, "lhs is null");
@@ -811,15 +847,15 @@ namespace Sass {
     if (r_last->combinator() != Combinator::ANCESTOR_OF ) return 0;
 
     // get the headers for the last tails
-    Compound_Selector* l_last_head = l_last->head();
-    Compound_Selector* r_last_head = r_last->head();
+    SimpleSequence_Selector* l_last_head = l_last->head();
+    SimpleSequence_Selector* r_last_head = r_last->head();
 
     // check valid head pointers (assertion)
     SASS_ASSERT(l_last_head, "lhs head is null");
     SASS_ASSERT(r_last_head, "rhs head is null");
 
     // get the unification of the last compound selectors
-    Compound_Selector* unified = r_last_head->unify_with(l_last_head, ctx);
+    SimpleSequence_Selector* unified = r_last_head->unify_with(l_last_head, ctx);
 
     // abort if we could not unify heads
     if (unified == 0) return 0;
@@ -843,7 +879,7 @@ namespace Sass {
     if (!is_universal)
     {
       // create some temporaries to convert to node
-      Complex_Selector* fake = unified->to_complex(ctx.mem);
+      Sequence_Selector* fake = unified->to_complex(ctx.mem);
       Node unified_node = complexSelectorToNode(fake, ctx);
       // add to permutate the list?
       rhsNode.plus(unified_node);
@@ -851,7 +887,7 @@ namespace Sass {
 
     // do some magic we inherit from node and extend
     Node node = Extend::subweave(lhsNode, rhsNode, ctx);
-    Selector_List* result = SASS_MEMORY_NEW(ctx.mem, Selector_List, pstate());
+    CommaSequence_Selector* result = SASS_MEMORY_NEW(ctx.mem, CommaSequence_Selector, pstate());
     NodeDequePtr col = node.collection(); // move from collection to list
     for (NodeDeque::iterator it = col->begin(), end = col->end(); it != end; it++)
     { (*result) << nodeToComplexSelector(Node::naiveTrim(*it, ctx), ctx); }
@@ -861,7 +897,7 @@ namespace Sass {
 
   }
 
-  bool Compound_Selector::operator== (const Compound_Selector& rhs) const
+  bool SimpleSequence_Selector::operator== (const SimpleSequence_Selector& rhs) const
   {
     // for array access
     size_t i = 0, n = 0;
@@ -894,26 +930,26 @@ namespace Sass {
     return true;
   }
 
-  bool Complex_Selector_Pointer_Compare::operator() (const Complex_Selector* const pLeft, const Complex_Selector* const pRight) const {
+  bool Sequence_Selector_Pointer_Compare::operator() (const Sequence_Selector* const pLeft, const Sequence_Selector* const pRight) const {
     return *pLeft < *pRight;
   }
 
-  bool Complex_Selector::is_superselector_of(Compound_Selector* rhs, std::string wrapping)
+  bool Sequence_Selector::is_superselector_of(SimpleSequence_Selector* rhs, std::string wrapping)
   {
     return last()->head() && last()->head()->is_superselector_of(rhs, wrapping);
   }
 
-  bool Complex_Selector::is_superselector_of(Complex_Selector* rhs, std::string wrapping)
+  bool Sequence_Selector::is_superselector_of(Sequence_Selector* rhs, std::string wrapping)
   {
-    Complex_Selector* lhs = this;
+    Sequence_Selector* lhs = this;
     // check for selectors with leading or trailing combinators
     if (!lhs->head() || !rhs->head())
     { return false; }
-    const Complex_Selector* l_innermost = lhs->innermost();
-    if (l_innermost->combinator() != Complex_Selector::ANCESTOR_OF)
+    const Sequence_Selector* l_innermost = lhs->innermost();
+    if (l_innermost->combinator() != Sequence_Selector::ANCESTOR_OF)
     { return false; }
-    const Complex_Selector* r_innermost = rhs->innermost();
-    if (r_innermost->combinator() != Complex_Selector::ANCESTOR_OF)
+    const Sequence_Selector* r_innermost = rhs->innermost();
+    if (r_innermost->combinator() != Sequence_Selector::ANCESTOR_OF)
     { return false; }
     // more complex (i.e., longer) selectors are always more specific
     size_t l_len = lhs->length(), r_len = rhs->length();
@@ -925,9 +961,9 @@ namespace Sass {
 
     // we have to look one tail deeper, since we cary the
     // combinator around for it (which is important here)
-    if (rhs->tail() && lhs->tail() && combinator() != Complex_Selector::ANCESTOR_OF) {
-      Complex_Selector* lhs_tail = lhs->tail();
-      Complex_Selector* rhs_tail = rhs->tail();
+    if (rhs->tail() && lhs->tail() && combinator() != Sequence_Selector::ANCESTOR_OF) {
+      Sequence_Selector* lhs_tail = lhs->tail();
+      Sequence_Selector* rhs_tail = rhs->tail();
       if (lhs_tail->combinator() != rhs_tail->combinator()) return false;
       if (lhs_tail->head() && !rhs_tail->head()) return false;
       if (!lhs_tail->head() && rhs_tail->head()) return false;
@@ -937,7 +973,7 @@ namespace Sass {
     }
 
     bool found = false;
-    Complex_Selector* marker = rhs;
+    Sequence_Selector* marker = rhs;
     for (size_t i = 0, L = rhs->length(); i < L; ++i) {
       if (i == L-1)
       { return false; }
@@ -961,17 +997,17 @@ namespace Sass {
       else
         return lhs.tail.is_superselector_of(marker.tail)
     */
-    if (lhs->combinator() != Complex_Selector::ANCESTOR_OF)
+    if (lhs->combinator() != Sequence_Selector::ANCESTOR_OF)
     {
-      if (marker->combinator() == Complex_Selector::ANCESTOR_OF)
+      if (marker->combinator() == Sequence_Selector::ANCESTOR_OF)
       { return false; }
-      if (!(lhs->combinator() == Complex_Selector::PRECEDES ? marker->combinator() != Complex_Selector::PARENT_OF : lhs->combinator() == marker->combinator()))
+      if (!(lhs->combinator() == Sequence_Selector::PRECEDES ? marker->combinator() != Sequence_Selector::PARENT_OF : lhs->combinator() == marker->combinator()))
       { return false; }
       return lhs->tail()->is_superselector_of(marker->tail());
     }
-    else if (marker->combinator() != Complex_Selector::ANCESTOR_OF)
+    else if (marker->combinator() != Sequence_Selector::ANCESTOR_OF)
     {
-      if (marker->combinator() != Complex_Selector::PARENT_OF)
+      if (marker->combinator() != Sequence_Selector::PARENT_OF)
       { return false; }
       return lhs->tail()->is_superselector_of(marker->tail());
     }
@@ -983,18 +1019,18 @@ namespace Sass {
     return false;
   }
 
-  size_t Complex_Selector::length() const
+  size_t Sequence_Selector::length() const
   {
     // TODO: make this iterative
     if (!tail()) return 1;
     return 1 + tail()->length();
   }
 
-  Complex_Selector* Complex_Selector::context(Context& ctx)
+  Sequence_Selector* Sequence_Selector::context(Context& ctx)
   {
     if (!tail()) return 0;
     if (!head()) return tail()->context(ctx);
-    Complex_Selector* cpy = SASS_MEMORY_NEW(ctx.mem, Complex_Selector, pstate(), combinator(), head(), tail()->context(ctx));
+    Sequence_Selector* cpy = SASS_MEMORY_NEW(ctx.mem, Sequence_Selector, pstate(), combinator(), head(), tail()->context(ctx));
     cpy->media_block(media_block());
     return cpy;
   }
@@ -1003,13 +1039,13 @@ namespace Sass {
   // 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* ss)
+  void Sequence_Selector::append(Context& ctx, Sequence_Selector* ss)
   {
 
-    Complex_Selector* t = ss->tail();
+    Sequence_Selector* t = ss->tail();
     Combinator c = ss->combinator();
     String* r = ss->reference();
-    Compound_Selector* h = ss->head();
+    SimpleSequence_Selector* h = ss->head();
 
     if (ss->has_line_feed()) has_line_feed(true);
     if (ss->has_line_break()) has_line_break(true);
@@ -1019,23 +1055,36 @@ namespace Sass {
       if (last()->combinator() != ANCESTOR_OF && c != ANCESTOR_OF) {
         error("Invalid parent selector", pstate_);
       } else if (last()->head_ && last()->head_->length()) {
-        Compound_Selector* rh = last()->head();
+        SimpleSequence_Selector* rh = last()->head();
         size_t i = 0, L = h->length();
-        if (dynamic_cast<Type_Selector*>(h->first())) {
-          if (Selector_Qualifier* sq = dynamic_cast<Selector_Qualifier*>(rh->last())) {
-            Selector_Qualifier* sqs = new Selector_Qualifier(*sq);
+        if (dynamic_cast<Element_Selector*>(h->first())) {
+          if (Class_Selector* sq = dynamic_cast<Class_Selector*>(rh->last())) {
+            Class_Selector* sqs = SASS_MEMORY_NEW(ctx.mem, Class_Selector, *sq);
             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 << (*h)[i];
-          } else if (Type_Selector* ts = dynamic_cast<Type_Selector*>(rh->last())) {
-            Type_Selector* tss = new Type_Selector(*ts);
+          } else if (Id_Selector* sq = dynamic_cast<Id_Selector*>(rh->last())) {
+            Id_Selector* sqs = SASS_MEMORY_NEW(ctx.mem, Id_Selector, *sq);
+            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 << (*h)[i];
+          } else if (Element_Selector* ts = dynamic_cast<Element_Selector*>(rh->last())) {
+            Element_Selector* tss = SASS_MEMORY_NEW(ctx.mem, Element_Selector, *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 << (*h)[i];
-          } else if (Selector_Placeholder* ps = dynamic_cast<Selector_Placeholder*>(rh->last())) {
-            Selector_Placeholder* pss = new Selector_Placeholder(*ps);
+          } else if (Placeholder_Selector* ps = dynamic_cast<Placeholder_Selector*>(rh->last())) {
+            Placeholder_Selector* pss = SASS_MEMORY_NEW(ctx.mem, Placeholder_Selector, *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 << (*h)[i];
           } else {
             *last()->head_ += h;
@@ -1052,7 +1101,7 @@ namespace Sass {
 
     if (last()) {
       if (last()->combinator() != ANCESTOR_OF && c != ANCESTOR_OF) {
-        Complex_Selector* inter = SASS_MEMORY_NEW(ctx.mem, Complex_Selector, pstate());
+        Sequence_Selector* inter = SASS_MEMORY_NEW(ctx.mem, Sequence_Selector, pstate());
         inter->reference(r);
         inter->combinator(c);
         inter->tail(t);
@@ -1069,48 +1118,64 @@ namespace Sass {
 
   }
 
-  Selector_List* Selector_List::parentize(Selector_List* ps, Context& ctx)
+  CommaSequence_Selector* CommaSequence_Selector::resolve_parent_refs(Context& ctx, CommaSequence_Selector* ps, bool implicit_parent)
   {
-    if (!this->has_parent_ref()) return this;
-    Selector_List* ss = SASS_MEMORY_NEW(ctx.mem, Selector_List, pstate());
+    if (!this->has_parent_ref()/* && !implicit_parent*/) return this;
+    CommaSequence_Selector* ss = SASS_MEMORY_NEW(ctx.mem, CommaSequence_Selector, pstate());
     for (size_t pi = 0, pL = ps->length(); pi < pL; ++pi) {
-      Selector_List* list = SASS_MEMORY_NEW(ctx.mem, Selector_List, pstate());
+      CommaSequence_Selector* list = SASS_MEMORY_NEW(ctx.mem, CommaSequence_Selector, pstate());
       *list << (*ps)[pi];
       for (size_t si = 0, sL = this->length(); si < sL; ++si) {
-        *ss += (*this)[si]->parentize(list, ctx);
+        *ss += (*this)[si]->resolve_parent_refs(ctx, list, implicit_parent);
       }
     }
     return ss;
   }
 
-  Selector_List* Complex_Selector::parentize(Selector_List* parents, Context& ctx)
+  CommaSequence_Selector* Sequence_Selector::resolve_parent_refs(Context& ctx, CommaSequence_Selector* parents, bool implicit_parent)
   {
+    Sequence_Selector* tail = this->tail();
+    SimpleSequence_Selector* head = this->head();
 
-    Complex_Selector* tail = this->tail();
-    Compound_Selector* head = this->head();
+    if (!this->has_real_parent_ref() && !implicit_parent) {
+      CommaSequence_Selector* retval = SASS_MEMORY_NEW(ctx.mem, CommaSequence_Selector, pstate());
+      *retval << this;
+      return retval;
+    }
 
-    // first parentize the tail (which may return an expanded list)
-    Selector_List* tails = tail ? tail->parentize(parents, ctx) : 0;
+    // first resolve_parent_refs the tail (which may return an expanded list)
+    CommaSequence_Selector* tails = tail ? tail->resolve_parent_refs(ctx, parents, implicit_parent) : 0;
 
     if (head && head->length() > 0) {
 
-      Selector_List* retval = 0;
+      CommaSequence_Selector* retval = 0;
       // we have a parent selector in a simple compound list
       // mix parent complex selector into the compound list
       if (dynamic_cast<Parent_Selector*>((*head)[0])) {
-        retval = SASS_MEMORY_NEW(ctx.mem, Selector_List, pstate());
+        retval = SASS_MEMORY_NEW(ctx.mem, CommaSequence_Selector, pstate());
         if (parents && parents->length()) {
           if (tails && tails->length() > 0) {
             for (size_t n = 0, nL = tails->length(); n < nL; ++n) {
               for (size_t i = 0, iL = parents->length(); i < iL; ++i) {
-                Complex_Selector* t = (*tails)[n];
-                Complex_Selector* parent = (*parents)[i];
-                Complex_Selector* s = parent->cloneFully(ctx);
-                Complex_Selector* ss = this->clone(ctx);
+                Sequence_Selector* t = (*tails)[n];
+                Sequence_Selector* parent = (*parents)[i];
+                Sequence_Selector* s = parent->cloneFully(ctx);
+                Sequence_Selector* ss = this->clone(ctx);
                 ss->tail(t ? t->clone(ctx) : 0);
-                Compound_Selector* h = head_->clone(ctx);
+                SimpleSequence_Selector* h = head_->clone(ctx);
+                // 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)[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);
                 *retval << s;
               }
@@ -1120,20 +1185,31 @@ namespace Sass {
           // loop above is inside out
           else {
             for (size_t i = 0, iL = parents->length(); i < iL; ++i) {
-              Complex_Selector* parent = (*parents)[i];
-              Complex_Selector* s = parent->cloneFully(ctx);
-              Complex_Selector* ss = this->clone(ctx);
+              Sequence_Selector* parent = (*parents)[i];
+              Sequence_Selector* s = parent->cloneFully(ctx);
+              Sequence_Selector* ss = this->clone(ctx);
               // 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);
               }
               ss->tail(tail ? tail->clone(ctx) : 0);
-              Compound_Selector* h = head_->clone(ctx);
+              SimpleSequence_Selector* h = head_->clone(ctx);
+              // remove parent selector from sequence
               if (h->length()) h->erase(h->begin());
               ss->head(h->length() ? h : 0);
               // \/ IMO ruby sass bug \/
               ss->has_line_feed(false);
+              // adjust for parent selector (1 char)
+              if (h->length()) {
+                ParserState state((*h)[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);
               *retval << s;
             }
@@ -1143,9 +1219,9 @@ namespace Sass {
         else {
           if (tails && tails->length() > 0) {
             for (size_t n = 0, nL = tails->length(); n < nL; ++n) {
-              Complex_Selector* cpy = this->clone(ctx);
+              Sequence_Selector* cpy = this->clone(ctx);
               cpy->tail((*tails)[n]->cloneFully(ctx));
-              cpy->head(SASS_MEMORY_NEW(ctx.mem, Compound_Selector, head->pstate()));
+              cpy->head(SASS_MEMORY_NEW(ctx.mem, SimpleSequence_Selector, head->pstate()));
               for (size_t i = 1, L = this->head()->length(); i < L; ++i)
                 *cpy->head() << (*this->head())[i];
               if (!cpy->head()->length()) cpy->head(0);
@@ -1154,8 +1230,8 @@ namespace Sass {
           }
           // have no parent nor tails
           else {
-            Complex_Selector* cpy = this->clone(ctx);
-            cpy->head(SASS_MEMORY_NEW(ctx.mem, Compound_Selector, head->pstate()));
+            Sequence_Selector* cpy = this->clone(ctx);
+            cpy->head(SASS_MEMORY_NEW(ctx.mem, SimpleSequence_Selector, head->pstate()));
             for (size_t i = 1, L = this->head()->length(); i < L; ++i)
               *cpy->head() << (*this->head())[i];
             if (!cpy->head()->length()) cpy->head(0);
@@ -1170,8 +1246,8 @@ namespace Sass {
 
       for (Simple_Selector* ss : *head) {
         if (Wrapped_Selector* ws = dynamic_cast<Wrapped_Selector*>(ss)) {
-          if (Selector_List* sl = dynamic_cast<Selector_List*>(ws->selector())) {
-            if (parents) ws->selector(sl->parentize(parents, ctx));
+          if (CommaSequence_Selector* sl = dynamic_cast<CommaSequence_Selector*>(ws->selector())) {
+            if (parents) ws->selector(sl->resolve_parent_refs(ctx, parents, implicit_parent));
           }
         }
       }
@@ -1188,12 +1264,12 @@ namespace Sass {
     return 0;
   }
 
-  Selector_List* Complex_Selector::tails(Context& ctx, Selector_List* tails)
+  CommaSequence_Selector* Sequence_Selector::tails(Context& ctx, CommaSequence_Selector* tails)
   {
-    Selector_List* rv = SASS_MEMORY_NEW(ctx.mem, Selector_List, pstate_);
+    CommaSequence_Selector* rv = SASS_MEMORY_NEW(ctx.mem, CommaSequence_Selector, pstate_);
     if (tails && tails->length()) {
       for (size_t i = 0, iL = tails->length(); i < iL; ++i) {
-        Complex_Selector* pr = this->clone(ctx);
+        Sequence_Selector* pr = this->clone(ctx);
         pr->tail((*tails)[i]);
         *rv << pr;
       }
@@ -1205,11 +1281,11 @@ namespace Sass {
   }
 
   // return the last tail that is defined
-  Complex_Selector* Complex_Selector::first()
+  Sequence_Selector* Sequence_Selector::first()
   {
     // declare variables used in loop
-    Complex_Selector* cur = this;
-    const Compound_Selector* head;
+    Sequence_Selector* cur = this;
+    const SimpleSequence_Selector* head;
     // processing loop
     while (cur)
     {
@@ -1227,11 +1303,11 @@ namespace Sass {
   }
 
   // return the last tail that is defined
-  const Complex_Selector* Complex_Selector::first() const
+  const Sequence_Selector* Sequence_Selector::first() const
   {
     // declare variables used in loop
-    const Complex_Selector* cur = this->tail_;
-    const Compound_Selector* head = head_;
+    const Sequence_Selector* cur = this->tail_;
+    const SimpleSequence_Selector* head = head_;
     // processing loop
     while (cur)
     {
@@ -1251,21 +1327,21 @@ namespace Sass {
   }
 
   // return the last tail that is defined
-  Complex_Selector* Complex_Selector::last()
+  Sequence_Selector* Sequence_Selector::last()
   {
     // ToDo: implement with a while loop
     return tail_? tail_->last() : this;
   }
 
   // return the last tail that is defined
-  const Complex_Selector* Complex_Selector::last() const
+  const Sequence_Selector* Sequence_Selector::last() const
   {
     // ToDo: implement with a while loop
     return tail_? tail_->last() : this;
   }
 
 
-  Complex_Selector::Combinator Complex_Selector::clear_innermost()
+  Sequence_Selector::Combinator Sequence_Selector::clear_innermost()
   {
     Combinator c;
     if (!tail() || tail()->tail() == 0)
@@ -1275,7 +1351,7 @@ namespace Sass {
     return c;
   }
 
-  void Complex_Selector::set_innermost(Complex_Selector* val, Combinator c)
+  void Sequence_Selector::set_innermost(Sequence_Selector* val, Combinator c)
   {
     if (!tail())
     { tail(val); combinator(c); }
@@ -1283,18 +1359,18 @@ namespace Sass {
     { tail()->set_innermost(val, c); }
   }
 
-  Complex_Selector* Complex_Selector::clone(Context& ctx) const
+  Sequence_Selector* Sequence_Selector::clone(Context& ctx) const
   {
-    Complex_Selector* cpy = SASS_MEMORY_NEW(ctx.mem, Complex_Selector, *this);
+    Sequence_Selector* cpy = SASS_MEMORY_NEW(ctx.mem, Sequence_Selector, *this);
     cpy->is_optional(this->is_optional());
     cpy->media_block(this->media_block());
     if (tail()) cpy->tail(tail()->clone(ctx));
     return cpy;
   }
 
-  Complex_Selector* Complex_Selector::cloneFully(Context& ctx) const
+  Sequence_Selector* Sequence_Selector::cloneFully(Context& ctx) const
   {
-    Complex_Selector* cpy = SASS_MEMORY_NEW(ctx.mem, Complex_Selector, *this);
+    Sequence_Selector* cpy = SASS_MEMORY_NEW(ctx.mem, Sequence_Selector, *this);
     cpy->is_optional(this->is_optional());
     cpy->media_block(this->media_block());
     if (head()) {
@@ -1308,26 +1384,26 @@ namespace Sass {
     return cpy;
   }
 
-  Compound_Selector* Compound_Selector::clone(Context& ctx) const
+  SimpleSequence_Selector* SimpleSequence_Selector::clone(Context& ctx) const
   {
-    Compound_Selector* cpy = SASS_MEMORY_NEW(ctx.mem, Compound_Selector, *this);
+    SimpleSequence_Selector* cpy = SASS_MEMORY_NEW(ctx.mem, SimpleSequence_Selector, *this);
     cpy->is_optional(this->is_optional());
     cpy->media_block(this->media_block());
     cpy->extended(this->extended());
     return cpy;
   }
 
-  Selector_List* Selector_List::clone(Context& ctx) const
+  CommaSequence_Selector* CommaSequence_Selector::clone(Context& ctx) const
   {
-    Selector_List* cpy = SASS_MEMORY_NEW(ctx.mem, Selector_List, *this);
+    CommaSequence_Selector* cpy = SASS_MEMORY_NEW(ctx.mem, CommaSequence_Selector, *this);
     cpy->is_optional(this->is_optional());
     cpy->media_block(this->media_block());
     return cpy;
   }
 
-  Selector_List* Selector_List::cloneFully(Context& ctx) const
+  CommaSequence_Selector* CommaSequence_Selector::cloneFully(Context& ctx) const
   {
-    Selector_List* cpy = SASS_MEMORY_NEW(ctx.mem, Selector_List, pstate());
+    CommaSequence_Selector* cpy = SASS_MEMORY_NEW(ctx.mem, CommaSequence_Selector, pstate());
     cpy->is_optional(this->is_optional());
     cpy->media_block(this->media_block());
     for (size_t i = 0, L = length(); i < L; ++i) {
@@ -1337,21 +1413,21 @@ namespace Sass {
   }
 
   /* not used anymore - remove?
-  Selector_Placeholder* Selector::find_placeholder()
+  Placeholder_Selector* Selector::find_placeholder()
   {
     return 0;
   }*/
 
   // remove parent selector references
   // basically unwraps parsed selectors
-  void Selector_List::remove_parent_selectors()
+  void CommaSequence_Selector::remove_parent_selectors()
   {
     // Check every rhs selector against left hand list
     for(size_t i = 0, L = length(); i < L; ++i) {
       if (!(*this)[i]->head()) continue;
       if ((*this)[i]->head()->is_empty_reference()) {
         // simply move to the next tail if we have "no" combinator
-        if ((*this)[i]->combinator() == Complex_Selector::ANCESTOR_OF) {
+        if ((*this)[i]->combinator() == Sequence_Selector::ANCESTOR_OF) {
           if ((*this)[i]->tail() != NULL) {
             if ((*this)[i]->has_line_feed()) {
               (*this)[i]->tail()->has_line_feed(true);
@@ -1367,14 +1443,22 @@ namespace Sass {
     }
   }
 
-  bool Selector_List::has_parent_ref()
+  bool CommaSequence_Selector::has_parent_ref()
   {
-    for (Complex_Selector* s : *this) {
+    for (Sequence_Selector* s : *this) {
       if (s && s->has_parent_ref()) return true;
     }
     return false;
   }
 
+  bool CommaSequence_Selector::has_real_parent_ref()
+  {
+    for (Sequence_Selector* s : *this) {
+      if (s && s->has_real_parent_ref()) return true;
+    }
+    return false;
+  }
+
   bool Selector_Schema::has_parent_ref()
   {
     if (String_Schema* schema = dynamic_cast<String_Schema*>(contents())) {
@@ -1383,14 +1467,23 @@ namespace Sass {
     return false;
   }
 
-  void Selector_List::adjust_after_pushing(Complex_Selector* c)
+  bool Selector_Schema::has_real_parent_ref()
+  {
+    if (String_Schema* schema = dynamic_cast<String_Schema*>(contents())) {
+      Parent_Selector* p = dynamic_cast<Parent_Selector*>(schema->at(0));
+      return schema->length() > 0 && p != NULL && p->is_real_parent_ref();
+    }
+    return false;
+  }
+
+  void CommaSequence_Selector::adjust_after_pushing(Sequence_Selector* c)
   {
     // if (c->has_reference())   has_reference(true);
   }
 
   // it's a superselector if every selector of the right side
   // list is a superselector of the given left side selector
-  bool Complex_Selector::is_superselector_of(Selector_List *sub, std::string wrapping)
+  bool Sequence_Selector::is_superselector_of(CommaSequence_Selector *sub, std::string wrapping)
   {
     // Check every rhs selector against left hand list
     for(size_t i = 0, L = sub->length(); i < L; ++i) {
@@ -1401,7 +1494,7 @@ namespace Sass {
 
   // it's a superselector if every selector of the right side
   // list is a superselector of the given left side selector
-  bool Selector_List::is_superselector_of(Selector_List *sub, std::string wrapping)
+  bool CommaSequence_Selector::is_superselector_of(CommaSequence_Selector *sub, std::string wrapping)
   {
     // Check every rhs selector against left hand list
     for(size_t i = 0, L = sub->length(); i < L; ++i) {
@@ -1412,7 +1505,7 @@ namespace Sass {
 
   // it's a superselector if every selector on the right side
   // is a superselector of any one of the left side selectors
-  bool Selector_List::is_superselector_of(Compound_Selector *sub, std::string wrapping)
+  bool CommaSequence_Selector::is_superselector_of(SimpleSequence_Selector *sub, std::string wrapping)
   {
     // Check every lhs selector against right hand
     for(size_t i = 0, L = length(); i < L; ++i) {
@@ -1423,7 +1516,7 @@ namespace Sass {
 
   // it's a superselector if every selector on the right side
   // is a superselector of any one of the left side selectors
-  bool Selector_List::is_superselector_of(Complex_Selector *sub, std::string wrapping)
+  bool CommaSequence_Selector::is_superselector_of(Sequence_Selector *sub, std::string wrapping)
   {
     // Check every lhs selector against right hand
     for(size_t i = 0, L = length(); i < L; ++i) {
@@ -1432,15 +1525,15 @@ namespace Sass {
     return false;
   }
 
-  Selector_List* Selector_List::unify_with(Selector_List* rhs, Context& ctx) {
-    std::vector<Complex_Selector*> unified_complex_selectors;
+  CommaSequence_Selector* CommaSequence_Selector::unify_with(CommaSequence_Selector* rhs, Context& ctx) {
+    std::vector<Sequence_Selector*> 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* seq1 = (*this)[lhs_i];
+      Sequence_Selector* seq1 = (*this)[lhs_i];
       for(size_t rhs_i = 0, rhs_L = rhs->length(); rhs_i < rhs_L; ++rhs_i) {
-        Complex_Selector* seq2 = (*rhs)[rhs_i];
+        Sequence_Selector* seq2 = (*rhs)[rhs_i];
 
-        Selector_List* result = seq1->unify_with(seq2, ctx);
+        CommaSequence_Selector* result = seq1->unify_with(seq2, ctx);
         if( result ) {
           for(size_t i = 0, L = result->length(); i < L; ++i) {
             unified_complex_selectors.push_back( (*result)[i] );
@@ -1449,27 +1542,27 @@ namespace Sass {
       }
     }
 
-    // Creates the final Selector_List by combining all the complex selectors
-    Selector_List* final_result = SASS_MEMORY_NEW(ctx.mem, Selector_List, pstate());
+    // Creates the final CommaSequence_Selector by combining all the complex selectors
+    CommaSequence_Selector* final_result = SASS_MEMORY_NEW(ctx.mem, CommaSequence_Selector, pstate());
     for (auto itr = unified_complex_selectors.begin(); itr != unified_complex_selectors.end(); ++itr) {
       *final_result << *itr;
     }
     return final_result;
   }
 
-  void Selector_List::populate_extends(Selector_List* extendee, Context& ctx, ExtensionSubsetMap& extends)
+  void CommaSequence_Selector::populate_extends(CommaSequence_Selector* extendee, Context& ctx, ExtensionSubsetMap& extends)
   {
 
-    Selector_List* extender = this;
+    CommaSequence_Selector* extender = this;
     for (auto complex_sel : extendee->elements()) {
-      Complex_Selector* c = complex_sel;
+      Sequence_Selector* c = complex_sel;
 
 
       // Ignore any parent selectors, until we find the first non Selector_Reference head
-      Compound_Selector* compound_sel = c->head();
-      Complex_Selector* pIter = complex_sel;
+      SimpleSequence_Selector* compound_sel = c->head();
+      Sequence_Selector* pIter = complex_sel;
       while (pIter) {
-        Compound_Selector* pHead = pIter->head();
+        SimpleSequence_Selector* pHead = pIter->head();
         if (pHead && dynamic_cast<Parent_Selector*>(pHead->elements()[0]) == NULL) {
           compound_sel = pHead;
           break;
@@ -1490,7 +1583,7 @@ namespace Sass {
     }
   };
 
-  std::vector<std::string> Compound_Selector::to_str_vec()
+  std::vector<std::string> SimpleSequence_Selector::to_str_vec()
   {
     std::vector<std::string> result;
     result.reserve(length());
@@ -1499,9 +1592,16 @@ namespace Sass {
     return result;
   }
 
-  Compound_Selector* Compound_Selector::minus(Compound_Selector* rhs, Context& ctx)
+  SimpleSequence_Selector& SimpleSequence_Selector::operator<<(Simple_Selector* element)
+  {
+    Vectorized<Simple_Selector*>::operator<<(element);
+    pstate_.offset += element->pstate().offset;
+    return *this;
+  }
+
+  SimpleSequence_Selector* SimpleSequence_Selector::minus(SimpleSequence_Selector* rhs, Context& ctx)
   {
-    Compound_Selector* result = SASS_MEMORY_NEW(ctx.mem, Compound_Selector, pstate());
+    SimpleSequence_Selector* result = SASS_MEMORY_NEW(ctx.mem, SimpleSequence_Selector, pstate());
     // result->has_parent_reference(has_parent_reference());
 
     // not very efficient because it needs to preserve order
@@ -1523,7 +1623,7 @@ namespace Sass {
     return result;
   }
 
-  void Compound_Selector::mergeSources(SourcesSet& sources, Context& ctx)
+  void SimpleSequence_Selector::mergeSources(SourcesSet& sources, Context& ctx)
   {
     for (SourcesSet::iterator iterator = sources.begin(), endIterator = sources.end(); iterator != endIterator; ++iterator) {
       this->sources_.insert((*iterator)->clone(ctx));
@@ -1594,9 +1694,10 @@ namespace Sass {
   }
 
   bool Ruleset::is_invisible() const {
-    Selector_List* sl = static_cast<Selector_List*>(selector());
-    for (size_t i = 0, L = sl->length(); i < L; ++i)
-      if (!(*sl)[i]->has_placeholder()) return false;
+    if (CommaSequence_Selector* sl = dynamic_cast<CommaSequence_Selector*>(selector())) {
+      for (size_t i = 0, L = sl->length(); i < L; ++i)
+        if (!(*sl)[i]->has_placeholder()) return false;
+    }
     return true;
   }
 
@@ -1983,6 +2084,21 @@ namespace Sass {
     return false;
   }
 
+  bool Number::eq (const Expression& rhs) const
+  {
+    if (const Number* r = dynamic_cast<const Number*>(&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;
+    }
+    return false;
+  }
+
   bool Number::operator== (const Expression& rhs) const
   {
     if (const Number* r = dynamic_cast<const Number*>(&rhs)) {
@@ -2149,29 +2265,6 @@ namespace Sass {
     return is_interpolant() || (right() && right()->is_right_interpolant());
   }
 
-  // delay binary expressions in function arguments
-  // https://github.com/sass/libsass/issues/1417
-  bool Binary_Expression::can_delay(void) const
-  {
-    bool l_delay = false;
-    bool r_delay = false;
-    if (op().operand == Sass_OP::DIV) {
-      if (Textual* tl = dynamic_cast<Textual*>(left())) {
-        l_delay = tl->type() == Textual::NUMBER ||
-                  tl->type() == Textual::DIMENSION;
-      } else {
-        l_delay = dynamic_cast<Number*>(left()) != NULL;
-      }
-      if (Textual* tr = dynamic_cast<Textual*>(right())) {
-        r_delay = tr->type() == Textual::NUMBER ||
-                  tr->type() == Textual::DIMENSION;
-      } else {
-        r_delay = dynamic_cast<Number*>(right()) != NULL;
-      }
-    }
-    return l_delay && r_delay;
-  }
-
   std::string AST_Node::to_string(Sass_Inspect_Options opt) const
   {
     Sass_Output_Options out(opt);
@@ -2213,4 +2306,20 @@ namespace Sass {
     }
   }
 
+  //////////////////////////////////////////////////////////////////////////////////////////
+  // Convert map to (key, value) list.
+  //////////////////////////////////////////////////////////////////////////////////////////
+  List* Map::to_list(Context& ctx, ParserState& pstate) {
+    List* ret = SASS_MEMORY_NEW(ctx.mem, List, pstate, length(), SASS_COMMA);
+
+    for (auto key : keys()) {
+      List* l = SASS_MEMORY_NEW(ctx.mem, List, pstate, 2);
+      *l << key;
+      *l << at(key);
+      *ret << l;
+    }
+
+    return ret;
+  }
+
 }