sassc 2.0.0 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 728b06267e365e493048b5367d344608392997c5beee20e7606d763b655514e7
-  data.tar.gz: c418fc06a5d8badec39fe2abf134c8297fa7d96679fa3af145f9718004b3e35b
+  metadata.gz: 75155de90eb3449ed2a1214ca6ab2b82ffe69b144c2a8eaf8a6a4fd522b58ea4
+  data.tar.gz: 8575ebe24a2d56a9bea0e4574ebd23753e283d3b34bf571489f318a357bce2b9
 SHA512:
-  metadata.gz: 37937f49272650f5efc95eda412f8487050171a6fe31eae775cdf6ff03aa293458388a22a352a5dd59f3f4141d83a7f32f91b571513cdb14468a11f6176b69ea
-  data.tar.gz: e25e7d5a7b9049802c35e456cb35e22c801028ca93c5efceaea1e7cf80c14ba84ec3ceb7660d6323146cc5b09a9fb8e1843aa678bc3076d2231cf48d84bae197
+  metadata.gz: ae3eb9431fb5d9de9e1c1759844e1144aba73f59b7de40e1b06d77ba5567bc894a2f0a4ef2d3b6dcce9226044d52de5eeacb7759e715f3eb1bd4818b56b9876c
+  data.tar.gz: e4a07f5789ec2d9f4dbf04bfaf13b5d12224cf4ffd9f72721fac8edfd10eb2b7085af53d70248ce78112ee7af0ea06fb5e452388997eab810d07bd5a7de08a5c

data/.gitignore

@@ -12,5 +12,7 @@
 *.so
 *.o
 *.a
+*.gem
 mkmf.log
 vendor/bundle
+/ext/Makefile

data/.gitmodules

@@ -1,3 +1,3 @@
 [submodule "ext/libsass"]
 	path = ext/libsass
-  url = git://github.com/sass/libsass.git
+	url = https://github.com/sass/libsass.git

data/.travis.yml

@@ -3,8 +3,14 @@ language: ruby
 bundler_args: "--binstubs --standalone --without documentation --path ../bundle"
 script: "bundle exec rake test"
 rvm:
-  - 2.3.7
-  - 2.4.4
-  - 2.5.1
+  - 2.0.0
+  - 2.1.10
+  - 2.2.10
+  - 2.3.8
+  - 2.4.6
+  - 2.5.5
+  - 2.6.3
+  - 2.7.0
+  - truffleruby
 notifications:
   email: false

data/CHANGELOG.md

@@ -1,3 +1,39 @@
+- **2.4.0**
+  - [Update libsass to 3.6.4](https://github.com/sass/sassc-ruby/pull/199)
+  - [Use FFI::MemoryPointer instead of libc's malloc()](https://github.com/sass/sassc-ruby/pull/205)
+  - [Test against Ruby 2.7.0](https://github.com/sass/sassc-ruby/pull/193)
+
+- **2.3.0**
+  - [Fix rake gem:native task](https://github.com/sass/sassc-ruby/pull/196)
+  - [disable lto flag for darwin + nix](https://github.com/sass/sassc-ruby/pull/166)
+  - [Sort input file list](https://github.com/sass/sassc-ruby/pull/178)
+  - [Set appropriate encoding for source_map](https://github.com/sass/sassc-ruby/pull/152)
+  - [allow passing functions directly](https://github.com/sass/sassc-ruby/pull/162)
+  - [always dispose data context](https://github.com/sass/sassc-ruby/pull/161)
+  - [Update libsass to 3.6.3](https://github.com/sass/sassc-ruby/pull/164)
+  - [Restore strip symbols](https://github.com/sass/sassc-ruby/pull/184)
+  - [Default --march-tune-native to false](https://github.com/sass/sassc-ruby/pull/158)
+  - [Fix compile issue on Mac OS X](https://github.com/sass/sassc-ruby/pull/174)
+  - [Test on TruffleRuby in TravisCI](https://github.com/sass/sassc-ruby/pull/171)
+  - [Use RbConfig::MAKEFILE_CONFIG['DLEXT'] instead of hardcoding extensions](https://github.com/sass/sassc-ruby/pull/173)
+- **2.2.1**
+  - [Fix LoadError on some non-rvm environments](https://github.com/sass/sassc-ruby/pull/156)
+- **2.2.0**
+  - [Do not build precompiled gems for Linux](https://github.com/sass/sassc-ruby/pull/145)
+- **2.1.0**
+  - Equivalent to 2.1.0.pre3
+- **2.1.0.pre3**
+  - [extconf.rb: Always write VERSION if we have .git](https://github.com/sass/sassc-ruby/pull/131)
+  - [Update libsass to 3.6.1](https://github.com/sass/sassc-ruby/pull/130)
+- **2.1.0.pre2**
+  - [Reduce Ruby warnings](https://github.com/sass/sassc-ruby/pull/124)
+  - [prefer equal? to determine object identity](https://github.com/sass/sassc-ruby/pull/122)
+  - [Link C/C++ stdlib statically for binary gems](https://github.com/sass/sassc-ruby/pull/127)
+- **2.1.0.pre1**
+  - [Update Libsass to 3.6.0](https://github.com/sass/sassc-ruby/pull/96/files)
+  - [Support old Ruby versions](https://github.com/sass/sassc-ruby/pull/117/files)
+- **2.0.1**
+  - [Relax FFI dependency](https://github.com/sass/sassc-ruby/pull/102)
 - **2.0.0**
   - [Remove dependency on Ruby Sass](https://github.com/sass/sassc-ruby/pull/85)
   - [frozen_string_literal all files](https://github.com/sass/sassc-ruby/pull/85)

data/CODE_OF_CONDUCT.md

@@ -7,4 +7,4 @@ fair place to play.
 
 [The full community guidelines can be found on the Sass website.][link]
 
-[link]: http://sass-lang.com/community-guidelines
+[link]: https://sass-lang.com/community-guidelines

data/README.md

@@ -6,7 +6,7 @@ This gem combines the speed of `libsass`, the [Sass C implementation](https://gi
 
 ### libsass Version
 
-[3.5.2](https://github.com/sass/libsass/releases/tag/3.5.2)
+[3.6.1](https://github.com/sass/libsass/releases/3.6.1)
 
 ## Installation
 

data/Rakefile

@@ -1,15 +1,51 @@
-begin
-  require 'bundler/gem_tasks'
-rescue LoadError
-  puts 'Cannot load bundler/gem_tasks'
+require 'bundler/gem_tasks'
+
+task default: :test
+
+require 'rake/extensiontask'
+gem_spec = Gem::Specification.load("sassc.gemspec")
+
+# HACK: Prevent rake-compiler from overriding required_ruby_version,
+# because the shared library here is Ruby-agnostic.
+# See https://github.com/rake-compiler/rake-compiler/issues/153
+module FixRequiredRubyVersion
+  def required_ruby_version=(*); end
 end
+Gem::Specification.send(:prepend, FixRequiredRubyVersion)
 
-require 'tasks/libsass'
+Rake::ExtensionTask.new('libsass', gem_spec) do |ext|
+  ext.name = 'libsass'
+  ext.ext_dir = 'ext'
+  ext.lib_dir = 'lib/sassc'
+  ext.cross_compile = true
+  ext.cross_platform = %w[x86-mingw32 x64-mingw32]
 
-task default: :test
+  # Link C++ stdlib statically when building binary gems.
+  ext.cross_config_options << '--enable-static-stdlib'
+
+  ext.cross_config_options << '--disable-march-tune-native'
+
+  ext.cross_compiling do |spec|
+    spec.files.reject! { |path| File.fnmatch?('ext/*', path) }
+  end
+end
+
+desc 'Compile all native gems via rake-compiler-dock (Docker)'
+task 'gem:native' do
+  require 'rake_compiler_dock'
+
+  # The RUBY_CC_VERSION here doesn't matter for the final package.
+  # Only one version should be specified, as the shared library is Ruby-agnostic.
+  RakeCompilerDock.sh "gem i rake bundler --no-document && bundle && "\
+                      "rake clean && rake cross native gem MAKE='nice make -j`nproc`' "\
+                      "RUBY_CC_VERSION=2.6.0 CLEAN=1"
+end
+
+CLEAN.include 'tmp', 'pkg', 'lib/sassc/libsass.{so,bundle}', 'ext/libsass/VERSION',
+              'ext/*.{o,so,bundle}', 'ext/Makefile'
 
 desc "Run all tests"
-task test: 'libsass:compile' do
+task test: 'compile:libsass' do
   $LOAD_PATH.unshift('lib', 'test')
   Dir.glob('./test/**/*_test.rb') { |f| require f }
 end

data/ext/depend

@@ -0,0 +1,4 @@
+# Replaces default mkmf dependencies. Default mkmf dependencies include all libruby headers.
+# We don't need libruby and some of these headers are missing on JRuby (breaking compilation there).
+$(OBJS): $(HDRS)
+

data/ext/extconf.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+gem_root = File.expand_path('..', __dir__)
+libsass_dir = File.join(gem_root, 'ext', 'libsass')
+
+if !File.directory?(libsass_dir) ||
+   # '.', '..', and possibly '.git' from a failed checkout:
+   Dir.entries(libsass_dir).size <= 3
+  Dir.chdir(gem_root) { system('git submodule update --init') } or
+    fail 'Could not fetch libsass'
+end
+
+require 'mkmf'
+
+$CXXFLAGS << ' -std=c++11'
+
+# Set to true when building binary gems
+if enable_config('static-stdlib', false)
+  $LDFLAGS << ' -static-libgcc -static-libstdc++'
+end
+
+if enable_config('march-tune-native', false)
+  $CFLAGS << ' -march=native -mtune=native'
+  $CXXFLAGS << ' -march=native -mtune=native'
+end
+
+# darwin nix clang doesn't support lto
+# disable -lto flag for darwin + nix
+# see: https://github.com/sass/sassc-ruby/issues/148
+enable_lto_by_default = (Gem::Platform.local.os == "darwin" && !ENV['NIX_CC'].nil?)
+
+if enable_config('lto', enable_lto_by_default)
+  $CFLAGS << ' -flto'
+  $CXXFLAGS << ' -flto'
+  $LDFLAGS << ' -flto'
+end
+
+# Disable noisy compilation warnings.
+$warnflags = ''
+$CFLAGS.gsub!(/[\s+](-ansi|-std=[^\s]+)/, '')
+
+dir_config 'libsass'
+
+libsass_version = Dir.chdir(libsass_dir) do
+  if File.exist?('.git')
+    ver = %x[git describe --abbrev=4 --dirty --always --tags].chomp
+    File.write('VERSION', ver)
+    ver
+  end
+  File.read('VERSION').chomp if File.exist?('VERSION')
+end
+
+if libsass_version
+  libsass_version_def = %Q{ -DLIBSASS_VERSION='"#{libsass_version}"'}
+  $CFLAGS << libsass_version_def
+  $CXXFLAGS << libsass_version_def
+end
+
+$INCFLAGS << " -I$(srcdir)/libsass/include"
+$VPATH << "$(srcdir)/libsass/src"
+Dir.chdir(__dir__) do
+  $VPATH += Dir['libsass/src/*/'].map { |p| "$(srcdir)/#{p}" }
+  $srcs = Dir['libsass/src/**/*.{c,cpp}'].sort
+end
+
+# libsass.bundle malformed object (unknown load command 7) on Mac OS X
+# See https://github.com/sass/sassc-ruby/pull/174
+if enable_config('strip', RbConfig::CONFIG['host_os'].downcase !~ /darwin/)
+  MakeMakefile::LINK_SO << "\nstrip -x $@"
+end
+
+# Don't link libruby.
+$LIBRUBYARG = nil
+
+# Disable .def file generation for mingw, as it defines an
+# `Init_libsass` export which we don't have.
+MakeMakefile.send(:remove_const, :EXPORT_PREFIX)
+MakeMakefile::EXPORT_PREFIX = nil
+
+if RUBY_ENGINE == 'jruby' &&
+   Gem::Version.new(RUBY_ENGINE_VERSION) < Gem::Version.new('9.2.8.0')
+  # COUTFLAG is not set correctly on jruby<9.2.8.0
+  # See https://github.com/jruby/jruby/issues/5749
+  MakeMakefile.send(:remove_const, :COUTFLAG)
+  MakeMakefile::COUTFLAG = '-o $(empty)'
+
+  # CCDLFLAGS is not set correctly on jruby<9.2.8.0
+  # See https://github.com/jruby/jruby/issues/5751
+  $CXXFLAGS << ' -fPIC'
+end
+
+create_makefile 'sassc/libsass'

data/ext/libsass/VERSION

@@ -0,0 +1 @@
+3.6.4

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

@@ -1,6 +1,7 @@
 #ifndef SASS_BASE_H
 #define SASS_BASE_H
 
+// #define DEBUG
 // #define DEBUG_SHARED_PTR
 
 #ifdef _MSC_VER
@@ -16,6 +17,12 @@
   #endif
 #endif
 
+// Work around lack of `noexcept` keyword support in VS2013
+#if defined(_MSC_VER) && (_MSC_VER <= 1800) && !defined(_ALLOW_KEYWORD_MACROS)
+#define _ALLOW_KEYWORD_MACROS 1
+#define noexcept throw( )
+#endif
+
 #include <stddef.h>
 #include <stdbool.h>
 
@@ -61,7 +68,8 @@ enum Sass_Output_Style {
   SASS_STYLE_COMPRESSED,
   // only used internaly
   SASS_STYLE_INSPECT,
-  SASS_STYLE_TO_SASS
+  SASS_STYLE_TO_SASS,
+  SASS_STYLE_TO_CSS
 };
 
 // to allocate buffer to be filled

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

@@ -43,7 +43,7 @@ ADDAPI struct Sass_Compiler* ADDCALL sass_make_file_compiler (struct Sass_File_C
 ADDAPI struct Sass_Compiler* ADDCALL sass_make_data_compiler (struct Sass_Data_Context* data_ctx);
 
 // Execute the different compilation steps individually
-// Usefull if you only want to query the included files
+// Useful if you only want to query the included files
 ADDAPI int ADDCALL sass_compiler_parse(struct Sass_Compiler* compiler);
 ADDAPI int ADDCALL sass_compiler_execute(struct Sass_Compiler* compiler);
 
@@ -125,6 +125,9 @@ ADDAPI char** ADDCALL sass_context_get_included_files (struct Sass_Context* ctx)
 // Getters for options include path array
 ADDAPI size_t ADDCALL sass_option_get_include_path_size(struct Sass_Options* options);
 ADDAPI const char* ADDCALL sass_option_get_include_path(struct Sass_Options* options, size_t i);
+// Plugin paths to load dynamic libraries work the same
+ADDAPI size_t ADDCALL sass_option_get_plugin_path_size(struct Sass_Options* options);
+ADDAPI const char* ADDCALL sass_option_get_plugin_path(struct Sass_Options* options, size_t i);
 
 // Calculate the size of the stored null terminated array
 ADDAPI size_t ADDCALL sass_context_get_included_files_size (struct Sass_Context* ctx);
@@ -134,6 +137,7 @@ ADDAPI char* ADDCALL sass_context_take_error_json (struct Sass_Context* ctx);
 ADDAPI char* ADDCALL sass_context_take_error_text (struct Sass_Context* ctx);
 ADDAPI char* ADDCALL sass_context_take_error_message (struct Sass_Context* ctx);
 ADDAPI char* ADDCALL sass_context_take_error_file (struct Sass_Context* ctx);
+ADDAPI char* ADDCALL sass_context_take_error_src (struct Sass_Context* ctx);
 ADDAPI char* ADDCALL sass_context_take_output_string (struct Sass_Context* ctx);
 ADDAPI char* ADDCALL sass_context_take_source_map_string (struct Sass_Context* ctx);
 ADDAPI char** ADDCALL sass_context_take_included_files (struct Sass_Context* ctx);

data/ext/libsass/src/MurmurHash2.hpp

@@ -0,0 +1,91 @@
+//-----------------------------------------------------------------------------
+// MurmurHash2 was written by Austin Appleby, and is placed in the public
+// domain. The author hereby disclaims copyright to this source code.
+//-----------------------------------------------------------------------------
+// LibSass only needs MurmurHash2, so we made this header only
+//-----------------------------------------------------------------------------
+
+#ifndef _MURMURHASH2_H_
+#define _MURMURHASH2_H_
+
+//-----------------------------------------------------------------------------
+// Platform-specific functions and macros
+
+// Microsoft Visual Studio
+
+#if defined(_MSC_VER) && (_MSC_VER < 1600)
+
+typedef unsigned char uint8_t;
+typedef unsigned int uint32_t;
+typedef unsigned __int64 uint64_t;
+
+// Other compilers
+
+#else	// defined(_MSC_VER)
+
+#include <stdint.h>
+
+#endif // !defined(_MSC_VER)
+
+//-----------------------------------------------------------------------------
+
+inline uint32_t MurmurHash2 ( const void * key, int len, uint32_t seed )
+{
+  // 'm' and 'r' are mixing constants generated offline.
+  // They're not really 'magic', they just happen to work well.
+
+  const uint32_t m = 0x5bd1e995;
+  const int r = 24;
+
+  // Initialize the hash to a 'random' value
+
+  uint32_t h = seed ^ len;
+
+  // Mix 4 bytes at a time into the hash
+
+  const unsigned char * data = (const unsigned char *)key;
+
+  while(len >= 4)
+  {
+    uint32_t k = *(uint32_t*)data;
+
+    k *= m;
+    k ^= k >> r;
+    k *= m;
+
+    h *= m;
+    h ^= k;
+
+    data += 4;
+    len -= 4;
+  }
+
+  // Handle the last few bytes of the input array
+
+  switch(len)
+  {
+  case 3:
+    h ^= data[2] << 16;
+    /* fall through */
+  case 2:
+    h ^= data[1] << 8;
+    /* fall through */
+  case 1:
+    h ^= data[0];
+    h *= m;
+  };
+
+  // Do a few final mixes of the hash to ensure the last few
+  // bytes are well-incorporated.
+
+  h ^= h >> 13;
+  h *= m;
+  h ^= h >> 15;
+
+  return h;
+} 
+
+//-----------------------------------------------------------------------------
+
+#endif // _MURMURHASH2_H_
+

data/ext/libsass/src/ast.cpp

@@ -1,1743 +1,681 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
-#include "ast.hpp"
-#include "context.hpp"
-#include "node.hpp"
-#include "eval.hpp"
-#include "extend.hpp"
-#include "emitter.hpp"
-#include "color_maps.hpp"
-#include "ast_fwd_decl.hpp"
-#include <set>
-#include <iomanip>
-#include <iostream>
-#include <algorithm>
-#include <functional>
-#include <cctype>
-#include <locale>
-
-namespace Sass {
-
-  static Null sass_null(ParserState("null"));
-
-  bool Wrapped_Selector::find ( bool (*f)(AST_Node_Obj) )
-  {
-    // check children first
-    if (selector_) {
-      if (selector_->find(f)) return true;
-    }
-    // execute last
-    return f(this);
-  }
-
-  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);
-  }
-
-  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 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 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;
-  }
-
-  bool Supports_Negation::needs_parens(Supports_Condition_Obj cond) const {
-    return Cast<Supports_Negation>(cond) ||
-           Cast<Supports_Operator>(cond);
-  }
-
-  void str_rtrim(std::string& str, const std::string& delimiters = " \f\n\r\t\v")
-  {
-    str.erase( str.find_last_not_of( delimiters ) + 1 );
-  }
-
-  void String_Constant::rtrim()
-  {
-    str_rtrim(value_);
-  }
-
-  void String_Schema::rtrim()
-  {
-    if (!empty()) {
-      if (String_Ptr str = Cast<String>(last())) str->rtrim();
-    }
-  }
-
-  void Argument::set_delayed(bool delayed)
-  {
-    if (value_) value_->set_delayed(delayed);
-    is_delayed(delayed);
-  }
-
-  void Arguments::set_delayed(bool delayed)
-  {
-    for (Argument_Obj 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;
-    List_Ptr l = static_cast<List_Ptr>(value().ptr());
-    std::string v;
-
-    if (with)
-    {
-      if (!l || l->length() == 0) return str.compare("rule") != 0;
-      for (size_t i = 0, L = l->length(); i < L; ++i)
-      {
-        v = unquote((*l)[i]->to_string());
-        if (v.compare("all") == 0 || v == str) return false;
-      }
-      return true;
-    }
-    else
-    {
-      if (!l || !l->length()) return str.compare("rule") == 0;
-      for (size_t i = 0, L = l->length(); i < L; ++i)
-      {
-        v = unquote((*l)[i]->to_string());
-        if (v.compare("all") == 0 || v == str) return true;
-      }
-      return false;
-    }
-  }
-
-  void AST_Node::update_pstate(const ParserState& pstate)
-  {
-    pstate_.offset += pstate - pstate_ + pstate.offset;
-  }
-
-  bool Simple_Selector::is_ns_eq(const Simple_Selector& r) const
-  {
-    // 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());
-    for (size_t i = 0; i < L; ++i)
-    {
-      Simple_Selector_Obj l = (*this)[i];
-      Simple_Selector_Obj r = rhs[i];
-      if (!l && !r) return false;
-      else if (!r) return false;
-      else if (!l) return true;
-      else if (*l != *r)
-      { return *l < *r; }
-    }
-    // just compare the length now
-    return length() < rhs.length();
-  }
-
-  bool Compound_Selector::has_parent_ref() const
-  {
-    for (Simple_Selector_Obj s : *this) {
-      if (s && s->has_parent_ref()) return true;
-    }
-    return false;
-  }
-
-  bool Compound_Selector::has_real_parent_ref() const
-  {
-    for (Simple_Selector_Obj s : *this) {
-      if (s && s->has_real_parent_ref()) return true;
-    }
-    return false;
-  }
-
-  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() const
-  {
-    return (head() && head()->has_real_parent_ref()) ||
-           (tail() && tail()->has_real_parent_ref());
-  }
-
-  bool Complex_Selector::operator< (const Complex_Selector& rhs) const
-  {
-    // const iterators for tails
-    Complex_Selector_Ptr_Const l = this;
-    Complex_Selector_Ptr_Const r = &rhs;
-    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_h = NULL;
-        l = l->tail();
-        if(l) l_h = l->head();
-        continue;
-      }
-      // skip empty ancestor first
-      if (r && r->is_empty_ancestor())
-      {
-        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;
-      // both are null
-      else if (!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();
-        // fetch the next headers
-        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;
-      else if (!l_h) return false;
-      // heads ok and equal
-      else if (*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();
-        // fetch the next headers
-        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;
-    }
-  }
-
-  bool Complex_Selector::operator== (const Complex_Selector& rhs) const
-  {
-    // const iterators for tails
-    Complex_Selector_Ptr_Const l = this;
-    Complex_Selector_Ptr_Const r = &rhs;
-    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_h = NULL;
-        l = l->tail();
-        if (l) l_h = l->head();
-        continue;
-      }
-      // skip empty ancestor first
-      if (r && r->is_empty_ancestor())
-      {
-        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;
-      // both are null
-      if (!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();
-        // fetch the next heads
-        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))
-      {
-        // check combinator after heads
-        if (l->combinator() != r->combinator())
-        { return l->combinator() == r->combinator(); }
-        // advance to next tails
-        l = l->tail();
-        r = r->tail();
-        // fetch the next heads
-        l_h = NULL; r_h = NULL;
-        if (l) l_h = l->head();
-        if (r) r_h = r->head();
-      }
-      // abort
-      else break;
-    }
-    // unreachable
-    return false;
-  }
-
-  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);
-    }
-    return unified.detach();
-  }
-
-  bool Complex_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 Complex_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 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");
-  }
-
-  bool Simple_Selector::operator== (const Selector& rhs) const
-  {
-    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 = Cast<Simple_Selector>(&rhs)) return *this < *sp;
-    return false;
-  }
-
-  bool Simple_Selector::operator== (const Simple_Selector& rhs) const
-  {
-    // 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(rhs); }
-    else return false;
-  }
-
-  bool Simple_Selector::operator< (const Simple_Selector& rhs) const
-  {
-    // 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_;
-  }
-
-  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 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
-  {
-    // solve the double dispatch problem by using RTTI information via dynamic cast
-    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;
-  }
-
-  bool Selector_List::operator== (const Selector_List& 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_Obj> l_lst = this->elements();
-    std::vector<Complex_Selector_Obj> r_lst = rhs.elements();
-    std::sort(l_lst.begin(), l_lst.end(), OrderNodes());
-    std::sort(r_lst.begin(), r_lst.end(), OrderNodes());
-    // process loop
-    while (true)
-    {
-      // first check for valid index
-      if (i == iL) return iL == nL;
-      else if (n == nL) return iL == nL;
-      // the access the vector items
-      Complex_Selector_Obj l = l_lst[i];
-      Complex_Selector_Obj r = r_lst[n];
-      // skip nulls
-      if (!l) ++i;
-      else if (!r) ++n;
-      // do the check
-      else if (*l != *r)
-      { return false; }
-      // advance
-      ++i; ++n;
-    }
-    // there is no break?!
-  }
-
-  bool Selector_List::operator< (const Selector& rhs) const
-  {
-    if (Selector_List_Ptr_Const sp = Cast<Selector_List>(&rhs)) return *this < *sp;
-    return false;
-  }
-
-  bool Selector_List::operator< (const Selector_List& rhs) const
-  {
-    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 false;
-  }
-
-  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() == 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) || typeid(*this) == typeid(Attribute_Selector))
-    {
-      for (i = 0, L = rhs->length(); i < L; ++i)
-      {
-        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; }
-      }
-    }
-    else
-    {
-      for (i = 0, L = rhs->length(); i < L; ++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);
-    } else {
-      rhs->elements().insert(rhs->elements().begin() + i, this);
-    }
-    return rhs;
-  }
-
-  Simple_Selector_Ptr Element_Selector::unify_with(Simple_Selector_Ptr rhs)
-  {
-    // check if ns can be extended
-    // true for no ns or universal
-    if (has_universal_ns())
-    {
-      // but dont extend with universal
-      // true for valid ns and universal
-      if (!rhs->is_universal_ns())
-      {
-        // overwrite the name if star is given as name
-        if (this->name() == "*") { this->name(rhs->name()); }
-        // now overwrite the namespace name and flag
-        this->ns(rhs->ns()); this->has_ns(rhs->has_ns());
-        // return copy
-        return this;
-      }
-    }
-    // namespace may changed, check the name now
-    // overwrite star (but not with another star)
-    if (name() == "*" && rhs->name() != "*")
-    {
-      // simply set the new name
-      this->name(rhs->name());
-      // return copy
-      return this;
-    }
-    // return original
-    return this;
-  }
-
-  Compound_Selector_Ptr Element_Selector::unify_with(Compound_Selector_Ptr rhs)
-  {
-    // TODO: handle namespaces
-
-    // if the rhs is empty, just return a copy of this
-    if (rhs->length() == 0) {
-      rhs->append(this);
-      return rhs;
-    }
-
-    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 = Cast<Element_Selector>(rhs_0);
-        rhs->at(0) = this->unify_with(ts);
-        return rhs;
-      }
-      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);
-        }
-        return rhs;
-      }
-
-
-      return rhs;
-    }
-
-    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
-      rhs->at(0) = this->unify_with(rhs_0);
-      return rhs;
-
-    }
-    // else it's a tag name and a bunch of qualifiers -- just append them
-    if (name() != "*") rhs->elements().insert(rhs->begin(), this);
-    return rhs;
-  }
-
-  Compound_Selector_Ptr Class_Selector::unify_with(Compound_Selector_Ptr rhs)
-  {
-    rhs->has_line_break(has_line_break());
-    return Simple_Selector::unify_with(rhs);
-  }
-
-  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 = 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);
-  }
 
-  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 = Cast<Pseudo_Selector>(rhs->at(i))) {
-          if (sel->is_pseudo_element() && sel->name() != name()) return 0;
-        }
-      }
-    }
-    return Simple_Selector::unify_with(rhs);
-  }
-
-  bool Attribute_Selector::operator< (const Attribute_Selector& rhs) const
-  {
-    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 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(); }
-    } else { return ns() < rhs.ns(); }
-  }
-
-  bool Attribute_Selector::operator< (const Simple_Selector& rhs) const
-  {
-    if (Attribute_Selector_Ptr_Const w = Cast<Attribute_Selector>(&rhs))
-    {
-      return *this < *w;
-    }
-    if (is_ns_eq(rhs))
-    { return name() < rhs.name(); }
-    return ns() < rhs.ns();
-  }
-
-  bool Attribute_Selector::operator== (const Attribute_Selector& rhs) const
-  {
-    // get optional value state
-    bool no_lhs_val = value().isNull();
-    bool no_rhs_val = rhs.value().isNull();
-    // both are null, therefore equal
-    if (no_lhs_val && no_rhs_val) {
-      return (name() == rhs.name())
-        && (matcher() == rhs.matcher())
-        && (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(rhs))
-        && (*value() == *rhs.value());
-    }
-    // not equal
-    return false;
-
-  }
-
-  bool Attribute_Selector::operator== (const Simple_Selector& rhs) const
-  {
-    if (Attribute_Selector_Ptr_Const w = Cast<Attribute_Selector>(&rhs))
-    {
-      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;
-    }
-    return false;
-  }
-
-  bool Pseudo_Selector::operator== (const Pseudo_Selector& rhs) const
-  {
-    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.ptr() == rhs_ex.ptr();
-    }
-    else return false;
-  }
-
-  bool Pseudo_Selector::operator== (const Simple_Selector& rhs) const
-  {
-    if (Pseudo_Selector_Ptr_Const w = Cast<Pseudo_Selector>(&rhs))
-    {
-      return *this == *w;
-    }
-    return is_ns_eq(rhs) &&
-           name() == rhs.name();
-  }
-
-  bool Pseudo_Selector::operator< (const Pseudo_Selector& rhs) const
-  {
-    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.ptr() < rhs_ex.ptr();
-    }
-    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 = Cast<Pseudo_Selector>(&rhs))
-    {
-      return *this < *w;
-    }
-    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(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 = Cast<Wrapped_Selector>(&rhs))
-    {
-      return *this == *w;
-    }
-    return is_ns_eq(rhs) &&
-           name() == rhs.name();
-  }
-
-  bool Wrapped_Selector::operator< (const Wrapped_Selector& rhs) const
-  {
-    if (is_ns_eq(rhs) && name() == rhs.name())
-    { return *(selector()) < *(rhs.selector()); }
-    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 = Cast<Wrapped_Selector>(&rhs))
-    {
-      return *this < *w;
-    }
-    if (is_ns_eq(rhs))
-    { return name() < rhs.name(); }
-    return ns() < rhs.ns();
-  }
-
-  bool Wrapped_Selector::is_superselector_of(Wrapped_Selector_Obj sub)
-  {
-    if (this->name() != sub->name()) return false;
-    if (this->name() == ":current") return false;
-    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);
-      }
-    }
-    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;
-    }
-    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);
-    return false;
-  }
-
-  bool Compound_Selector::is_superselector_of(Compound_Selector_Obj rhs, std::string wrapping)
-  {
-    Compound_Selector_Ptr lhs = this;
-    Simple_Selector_Ptr lbase = lhs->base();
-    Simple_Selector_Ptr rbase = rhs->base();
-
-    // Check if pseudo-elements are the same between the selectors
-
-    std::set<std::string> lpsuedoset, rpsuedoset;
-    for (size_t i = 0, L = length(); i < L; ++i)
-    {
-      if ((*this)[i]->is_pseudo_element()) {
-        std::string pseudo((*this)[i]->to_string());
-        pseudo = pseudo.substr(pseudo.find_first_not_of(":")); // strip off colons to ensure :after matches ::after since ruby sass is forgiving
-        lpsuedoset.insert(pseudo);
-      }
-    }
-    for (size_t i = 0, L = rhs->length(); i < L; ++i)
-    {
-      if ((*rhs)[i]->is_pseudo_element()) {
-        std::string pseudo((*rhs)[i]->to_string());
-        pseudo = pseudo.substr(pseudo.find_first_not_of(":")); // strip off colons to ensure :after matches ::after since ruby sass is forgiving
-        rpsuedoset.insert(pseudo);
-      }
-    }
-    if (lpsuedoset != rpsuedoset) {
-      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)
-    {
-      if (lbase->to_string() == rbase->to_string()) {
-        for (size_t i = 1, L = length(); i < L; ++i)
-        { lset.insert((*this)[i]->to_string()); }
-        for (size_t i = 1, L = rhs->length(); i < L; ++i)
-        { rset.insert((*rhs)[i]->to_string()); }
-        return includes(rset.begin(), rset.end(), lset.begin(), lset.end());
-      }
-      return false;
-    }
-
-    for (size_t i = 0, iL = length(); i < iL; ++i)
-    {
-      Selector_Obj wlhs = (*this)[i];
-      // very special case for wrapped matches selector
-      if (Wrapped_Selector_Obj wrapped = Cast<Wrapped_Selector>(wlhs)) {
-        if (wrapped->name() == ":not") {
-          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") {
-          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;
-              }
-            }
-          }
-        }
-        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;
-          }}
-        }
-      }
-      // match from here on as strings
-      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 = Cast<Wrapped_Selector>(r)) {
-        if (wrapped->name() == ":not") {
-          if (Selector_List_Obj ls = Cast<Selector_List>(wrapped->selector())) {
-            ls->remove_parent_selectors();
-            if (is_superselector_of(ls, wrapped->name())) return false;
-          }
-        }
-        if (wrapped->name() == ":matches" || wrapped->name() == ":-moz-any") {
-          if (!wrapping.empty()) {
-            if (wrapping != wrapped->name()) return false;
-          }
-          if (Selector_List_Obj ls = Cast<Selector_List>(wrapped->selector())) {
-            ls->remove_parent_selectors();
-            return (is_superselector_of(ls, wrapped->name()));
-          }
-        }
-      }
-      rset.insert(r->to_string());
-    }
-
-    //for (auto l : lset) { cerr << "l: " << l << endl; }
-    //for (auto r : rset) { cerr << "r: " << r << endl; }
-
-    if (lset.empty()) return true;
-    // return true if rset contains all the elements of lset
-    return includes(rset.begin(), rset.end(), lset.begin(), lset.end());
-
-  }
-
-  // create complex selector (ancestor of) from compound selector
-  Complex_Selector_Obj Compound_Selector::to_complex()
-  {
-    // create an intermediate complex selector
-    return SASS_MEMORY_NEW(Complex_Selector,
-                           pstate(),
-                           Complex_Selector::ANCESTOR_OF,
-                           this,
-                           0);
-  }
-
-  Selector_List_Ptr Complex_Selector::unify_with(Complex_Selector_Ptr other)
-  {
-
-    // get last tails (on the right side)
-    Complex_Selector_Obj l_last = this->last();
-    Complex_Selector_Obj r_last = other->last();
-
-    // check valid pointers (assertion)
-    SASS_ASSERT(l_last, "lhs is null");
-    SASS_ASSERT(r_last, "rhs is null");
-
-    // Not sure about this check, but closest way I could check
-    // was to see if this is a ruby 'SimpleSequence' equivalent.
-    // It seems to do the job correctly as some specs react to this
-    if (l_last->combinator() != Combinator::ANCESTOR_OF) return 0;
-    if (r_last->combinator() != Combinator::ANCESTOR_OF ) return 0;
-
-    // get the headers for the last tails
-    Compound_Selector_Obj l_last_head = l_last->head();
-    Compound_Selector_Obj 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_Obj unified = r_last_head->unify_with(l_last_head);
-
-    // abort if we could not unify heads
-    if (unified == 0) return 0;
-
-    // check for universal (star: `*`) selector
-    bool is_universal = l_last_head->is_universal() ||
-                        r_last_head->is_universal();
-
-    if (is_universal)
-    {
-      // move the head
-      l_last->head(0);
-      r_last->head(unified);
-    }
-
-    // create nodes from both selectors
-    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);
-      // add to permutate the list?
-      rhsNode.plus(unified_node);
-    }
-
-    // do some magic we inherit from node and extend
-    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))); }
-
-    // only return if list has some entries
-    return result->length() ? result.detach() : 0;
-
-  }
-
-  bool Compound_Selector::operator== (const Compound_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<Simple_Selector_Obj> l_lst = this->elements();
-    std::vector<Simple_Selector_Obj> r_lst = rhs.elements();
-    std::sort(l_lst.begin(), l_lst.end(), OrderNodes());
-    std::sort(r_lst.begin(), r_lst.end(), OrderNodes());
-    // process loop
-    while (true)
-    {
-      // first check for valid index
-      if (i == iL) return iL == nL;
-      else if (n == nL) return iL == nL;
-      // the access the vector items
-      Simple_Selector_Obj l = l_lst[i];
-      Simple_Selector_Obj r = r_lst[n];
-      // skip nulls
-      if (!l) ++i;
-      if (!r) ++n;
-      // do the check now
-      else if (*l != *r)
-      { return false; }
-      // advance now
-      ++i; ++n;
-    }
-    // there is no break?!
-  }
-
-  bool Complex_Selector::is_superselector_of(Compound_Selector_Obj rhs, std::string wrapping)
-  {
-    return last()->head() && last()->head()->is_superselector_of(rhs, wrapping);
-  }
-
-  bool Complex_Selector::is_superselector_of(Complex_Selector_Obj rhs, std::string wrapping)
-  {
-    Complex_Selector_Ptr lhs = this;
-    // check for selectors with leading or trailing combinators
-    if (!lhs->head() || !rhs->head())
-    { return false; }
-    Complex_Selector_Obj l_innermost = lhs->innermost();
-    if (l_innermost->combinator() != Complex_Selector::ANCESTOR_OF)
-    { return false; }
-    Complex_Selector_Obj r_innermost = rhs->innermost();
-    if (r_innermost->combinator() != Complex_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();
-    if (l_len > r_len)
-    { return false; }
-
-    if (l_len == 1)
-    { 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)
-    if (rhs->tail() && lhs->tail() && combinator() != Complex_Selector::ANCESTOR_OF) {
-      Complex_Selector_Obj lhs_tail = lhs->tail();
-      Complex_Selector_Obj 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;
-      if (lhs_tail->head() && rhs_tail->head()) {
-        if (!lhs_tail->head()->is_superselector_of(rhs_tail->head())) return false;
-      }
-    }
-
-    bool found = false;
-    Complex_Selector_Obj marker = rhs;
-    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))
-      { found = true; break; }
-      marker = marker->tail();
-    }
-    if (!found)
-    { return false; }
-
-    /*
-      Hmm, I hope I have the logic right:
-
-      if lhs has a combinator:
-        if !(marker has a combinator) return false
-        if !(lhs.combinator == '~' ? marker.combinator != '>' : lhs.combinator == marker.combinator) return false
-        return lhs.tail-without-innermost.is_superselector_of(marker.tail-without-innermost)
-      else if marker has a combinator:
-        if !(marker.combinator == ">") return false
-        return lhs.tail.is_superselector_of(marker.tail)
-      else
-        return lhs.tail.is_superselector_of(marker.tail)
-    */
-    if (lhs->combinator() != Complex_Selector::ANCESTOR_OF)
-    {
-      if (marker->combinator() == Complex_Selector::ANCESTOR_OF)
-      { 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());
-    }
-    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());
-  }
-
-  size_t Complex_Selector::length() const
-  {
-    // TODO: make this iterative
-    if (!tail()) return 1;
-    return 1 + tail()->length();
-  }
-
-  // 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(Complex_Selector_Obj ss, Backtraces& traces)
-  {
-
-    Complex_Selector_Obj t = ss->tail();
-    Combinator c = ss->combinator();
-    String_Obj r = ss->reference();
-    Compound_Selector_Obj h = ss->head();
-
-    if (ss->has_line_feed()) has_line_feed(true);
-    if (ss->has_line_break()) has_line_break(true);
-
-    // append old headers
-    if (h && h->length()) {
-      if (last()->combinator() != ANCESTOR_OF && c != ANCESTOR_OF) {
-        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;
-        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 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 = 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 = 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]);
-          } else {
-            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";
-    }
-
-    if (last()) {
-      if (last()->combinator() != ANCESTOR_OF && c != ANCESTOR_OF) {
-        Complex_Selector_Ptr inter = SASS_MEMORY_NEW(Complex_Selector, pstate());
-        inter->reference(r);
-        inter->combinator(c);
-        inter->tail(t);
-        last()->tail(inter);
-      } else {
-        if (last()->combinator() == ANCESTOR_OF) {
-          last()->combinator(c);
-          last()->reference(r);
-        }
-        last()->tail(t);
-      }
-    }
-
-  }
-
-  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(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();
-    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(pstack, traces, implicit_parent);
-        ss->concat(rv);
-      }
-    }
-    return ss;
-  }
-
-  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();
-
-    if (!this->has_real_parent_ref() && !implicit_parent) {
-      Selector_List_Ptr retval = SASS_MEMORY_NEW(Selector_List, pstate());
-      retval->append(this);
-      return retval;
-    }
-
-    // first resolve_parent_refs the tail (which may return an expanded list)
-    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 (Cast<Parent_Selector>((*head)[0])) {
-        retval = SASS_MEMORY_NEW(Selector_List, pstate());
-
-        // it turns out that real parent references reach
-        // across @at-root rules, which comes unexpected
-        if (parents == NULL && head->has_real_parent_ref()) {
-          int i = pstack.size() - 1;
-          while (!parents && i > -1) {
-            parents = pstack.at(i--);
-          }
-        }
-
-        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_Obj t = (*tails)[n];
-                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) : NULL);
-                Compound_Selector_Obj h = SASS_MEMORY_COPY(head_);
-                // remove parent selector from sequence
-                if (h->length()) {
-                  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(ss, traces);
-                retval->append(s);
-              }
-            }
-          }
-          // have no tails but parents
-          // loop above is inside out
-          else {
-            for (size_t i = 0, iL = parents->length(); i < iL; ++i) {
-              Complex_Selector_Obj parent = (*parents)[i];
-              Complex_Selector_Obj s = SASS_MEMORY_CLONE(parent);
-              Complex_Selector_Obj ss = SASS_MEMORY_CLONE(this);
-              // 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) {
-                traces.push_back(Backtrace(pstate()));
-                throw Exception::InvalidParent(parent, traces, ss);
-              }
-              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);
-              } 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);
-              // }
-              // keep old parser state
-              s->pstate(pstate());
-              // append new tail
-              s->append(ss, traces);
-              retval->append(s);
-            }
-          }
-        }
-        // have no parent but some tails
-        else {
-          if (tails && tails->length() > 0) {
-            for (size_t n = 0, nL = tails->length(); n < nL; ++n) {
-              Complex_Selector_Obj cpy = SASS_MEMORY_CLONE(this);
-              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]);
-              if (!cpy->head()->length()) cpy->head(0);
-              retval->append(cpy->skip_empty_reference());
-            }
-          }
-          // have no parent nor tails
-          else {
-            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]);
-            if (!cpy->head()->length()) cpy->head(0);
-            retval->append(cpy->skip_empty_reference());
-          }
-        }
-      }
-      // no parent selector in head
-      else {
-        retval = this->tails(tails);
-      }
+#include "ast.hpp"
 
-      for (Simple_Selector_Obj ss : head->elements()) {
-        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));
-          }
-        }
-      }
+namespace Sass {
 
-      return retval.detach();
+  static Null sass_null(SourceSpan("null"));
 
+  const char* sass_op_to_name(enum Sass_OP op) {
+    switch (op) {
+      case AND: return "and";
+      case OR: return "or";
+      case EQ: return "eq";
+      case NEQ: return "neq";
+      case GT: return "gt";
+      case GTE: return "gte";
+      case LT: return "lt";
+      case LTE: return "lte";
+      case ADD: return "plus";
+      case SUB: return "minus";
+      case MUL: return "times";
+      case DIV: return "div";
+      case MOD: return "mod";
+      // this is only used internally!
+      case NUM_OPS: return "[OPS]";
+      default: return "invalid";
     }
-    // has no head
-    return this->tails(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()) {
-      for (size_t i = 0, iL = tails->length(); i < iL; ++i) {
-        Complex_Selector_Obj pr = SASS_MEMORY_CLONE(this);
-        pr->tail(tails->at(i));
-        rv->append(pr);
-      }
-    }
-    else {
-      rv->append(this);
+  const char* sass_op_separator(enum Sass_OP op) {
+    switch (op) {
+      case AND: return "&&";
+      case OR: return "||";
+      case EQ: return "==";
+      case NEQ: return "!=";
+      case GT: return ">";
+      case GTE: return ">=";
+      case LT: return "<";
+      case LTE: return "<=";
+      case ADD: return "+";
+      case SUB: return "-";
+      case MUL: return "*";
+      case DIV: return "/";
+      case MOD: return "%";
+      // this is only used internally!
+      case NUM_OPS: return "[OPS]";
+      default: return "invalid";
     }
-    return rv;
   }
 
-  // return the last tail that is defined
-  Complex_Selector_Obj Complex_Selector::first()
-  {
-    // declare variables used in loop
-    Complex_Selector_Obj cur = this;
-    Compound_Selector_Obj head;
-    // processing loop
-    while (cur)
-    {
-      // get the head
-      head = cur->head_;
-      // abort (and return) if it is not a parent selector
-      if (!head || head->length() != 1 || !Cast<Parent_Selector>((*head)[0])) {
-        break;
-      }
-      // advance to next
-      cur = cur->tail_;
-    }
-    // result
-    return cur;
-  }
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
 
-  // return the last tail that is defined
-  Complex_Selector_Obj Complex_Selector::last()
+  void AST_Node::update_pstate(const SourceSpan& pstate)
   {
-    Complex_Selector_Ptr cur = this;
-    Complex_Selector_Ptr nxt = cur;
-    // loop until last
-    while (nxt) {
-      cur = nxt;
-      nxt = cur->tail();
-    }
-    return cur;
+    pstate_.offset += pstate.position - pstate_.position + pstate.offset;
   }
 
-  Complex_Selector::Combinator Complex_Selector::clear_innermost()
+  sass::string AST_Node::to_string(Sass_Inspect_Options opt) const
   {
-    Combinator c;
-    if (!tail() || tail()->tail() == 0)
-    { c = combinator(); combinator(ANCESTOR_OF); tail(0); }
-    else
-    { c = tail()->clear_innermost(); }
-    return c;
+    Sass_Output_Options out(opt);
+    Emitter emitter(out);
+    Inspect i(emitter);
+    i.in_declaration = true;
+    // ToDo: inspect should be const
+    const_cast<AST_Node*>(this)->perform(&i);
+    return i.get_buffer();
   }
 
-  void Complex_Selector::set_innermost(Complex_Selector_Obj val, Combinator c)
+  sass::string AST_Node::to_css(Sass_Inspect_Options opt) const
   {
-    if (!tail())
-    { tail(val); combinator(c); }
-    else
-    { tail()->set_innermost(val, c); }
+    opt.output_style = TO_CSS;
+    Sass_Output_Options out(opt);
+    Emitter emitter(out);
+    Inspect i(emitter);
+    i.in_declaration = true;
+    // ToDo: inspect should be const
+    const_cast<AST_Node*>(this)->perform(&i);
+    return i.get_buffer();
   }
 
-  void Complex_Selector::cloneChildren()
+  sass::string AST_Node::to_string() const
   {
-    if (head()) head(SASS_MEMORY_CLONE(head()));
-    if (tail()) tail(SASS_MEMORY_CLONE(tail()));
+    return to_string({ NESTED, 5 });
   }
 
-  void Compound_Selector::cloneChildren()
-  {
-    for (size_t i = 0, l = length(); i < l; i++) {
-      at(i) = SASS_MEMORY_CLONE(at(i));
-    }
-  }
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
 
-  void Selector_List::cloneChildren()
-  {
-    for (size_t i = 0, l = length(); i < l; i++) {
-      at(i) = SASS_MEMORY_CLONE(at(i));
-    }
-  }
+  Statement::Statement(SourceSpan pstate, Type st, size_t t)
+  : AST_Node(pstate), statement_type_(st), tabs_(t), group_end_(false)
+  { }
+  Statement::Statement(const Statement* ptr)
+  : AST_Node(ptr),
+    statement_type_(ptr->statement_type_),
+    tabs_(ptr->tabs_),
+    group_end_(ptr->group_end_)
+  { }
 
-  void Wrapped_Selector::cloneChildren()
+  bool Statement::bubbles()
   {
-    selector(SASS_MEMORY_CLONE(selector()));
+    return false;
   }
 
-  // remove parent selector references
-  // basically unwraps parsed selectors
-  void Selector_List::remove_parent_selectors()
+  bool Statement::has_content()
   {
-    // 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]->tail()) {
-            if ((*this)[i]->has_line_feed()) {
-              (*this)[i]->tail()->has_line_feed(true);
-            }
-            (*this)[i] = (*this)[i]->tail();
-          }
-        }
-        // otherwise remove the first item from head
-        else {
-          (*this)[i]->head()->erase((*this)[i]->head()->begin());
-        }
-      }
-    }
+    return statement_type_ == CONTENT;
   }
 
-  size_t Wrapped_Selector::hash()
+  bool Statement::is_invisible() const
   {
-    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;
+    return false;
   }
 
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
 
-  bool Selector_List::has_parent_ref() const
-  {
-    for (Complex_Selector_Obj s : elements()) {
-      if (s && s->has_parent_ref()) return true;
-    }
-    return false;
-  }
+  Block::Block(SourceSpan pstate, size_t s, bool r)
+  : Statement(pstate),
+    Vectorized<Statement_Obj>(s),
+    is_root_(r)
+  { }
+  Block::Block(const Block* ptr)
+  : Statement(ptr),
+    Vectorized<Statement_Obj>(*ptr),
+    is_root_(ptr->is_root_)
+  { }
 
-  bool Selector_List::has_real_parent_ref() const
+  bool Block::isInvisible() const
   {
-    for (Complex_Selector_Obj s : elements()) {
-      if (s && s->has_real_parent_ref()) return true;
+    for (auto& item : elements()) {
+      if (!item->is_invisible()) return false;
     }
-    return false;
+    return true;
   }
 
-  bool Selector_Schema::has_parent_ref() const
+  bool Block::has_content()
   {
-    if (String_Schema_Obj schema = Cast<String_Schema>(contents())) {
-      return schema->length() > 0 && Cast<Parent_Selector>(schema->at(0)) != NULL;
+    for (size_t i = 0, L = elements().size(); i < L; ++i) {
+      if (elements()[i]->has_content()) return true;
     }
-    return false;
+    return Statement::has_content();
   }
 
-  bool Selector_Schema::has_real_parent_ref() const
-  {
-    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;
-  }
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
+
+  ParentStatement::ParentStatement(SourceSpan pstate, Block_Obj b)
+  : Statement(pstate), block_(b)
+  { }
+  ParentStatement::ParentStatement(const ParentStatement* ptr)
+  : Statement(ptr), block_(ptr->block_)
+  { }
 
-  void Selector_List::adjust_after_pushing(Complex_Selector_Obj c)
+  bool ParentStatement::has_content()
   {
-    // if (c->has_reference())   has_reference(true);
+    return (block_ && block_->has_content()) || Statement::has_content();
   }
 
-  // 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_Obj sub, std::string wrapping)
-  {
-    // 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;
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
+
+  StyleRule::StyleRule(SourceSpan pstate, SelectorListObj s, Block_Obj b)
+  : ParentStatement(pstate, b), selector_(s), schema_(), is_root_(false)
+  { statement_type(RULESET); }
+  StyleRule::StyleRule(const StyleRule* ptr)
+  : ParentStatement(ptr),
+    selector_(ptr->selector_),
+    schema_(ptr->schema_),
+    is_root_(ptr->is_root_)
+  { statement_type(RULESET); }
+
+  bool StyleRule::is_invisible() const {
+    if (const SelectorList * sl = Cast<SelectorList>(selector())) {
+      for (size_t i = 0, L = sl->length(); i < L; i += 1)
+        if (!(*sl)[i]->isInvisible()) return false;
     }
     return true;
   }
 
-  // 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_Obj sub, std::string wrapping)
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
+
+  Bubble::Bubble(SourceSpan pstate, Statement_Obj n, Statement_Obj g, size_t t)
+  : Statement(pstate, Statement::BUBBLE, t), node_(n), group_end_(g == nullptr)
+  { }
+  Bubble::Bubble(const Bubble* ptr)
+  : Statement(ptr),
+    node_(ptr->node_),
+    group_end_(ptr->group_end_)
+  { }
+
+  bool Bubble::bubbles()
   {
-    // 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;
-    }
     return true;
   }
 
-  // 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_Obj sub, std::string wrapping)
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
+
+  Trace::Trace(SourceSpan pstate, sass::string n, Block_Obj b, char type)
+  : ParentStatement(pstate, b), type_(type), name_(n)
+  { }
+  Trace::Trace(const Trace* ptr)
+  : ParentStatement(ptr),
+    type_(ptr->type_),
+    name_(ptr->name_)
+  { }
+
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
+
+  AtRule::AtRule(SourceSpan pstate, sass::string kwd, SelectorListObj sel, Block_Obj b, ExpressionObj val)
+  : ParentStatement(pstate, b), keyword_(kwd), selector_(sel), value_(val) // set value manually if needed
+  { statement_type(DIRECTIVE); }
+  AtRule::AtRule(const AtRule* ptr)
+  : ParentStatement(ptr),
+    keyword_(ptr->keyword_),
+    selector_(ptr->selector_),
+    value_(ptr->value_) // set value manually if needed
+  { statement_type(DIRECTIVE); }
+
+  bool AtRule::bubbles() { return is_keyframes() || is_media(); }
+
+  bool AtRule::is_media() {
+    return keyword_.compare("@-webkit-media") == 0 ||
+            keyword_.compare("@-moz-media") == 0 ||
+            keyword_.compare("@-o-media") == 0 ||
+            keyword_.compare("@media") == 0;
+  }
+  bool AtRule::is_keyframes() {
+    return keyword_.compare("@-webkit-keyframes") == 0 ||
+            keyword_.compare("@-moz-keyframes") == 0 ||
+            keyword_.compare("@-o-keyframes") == 0 ||
+            keyword_.compare("@keyframes") == 0;
+  }
+
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
+
+  Keyframe_Rule::Keyframe_Rule(SourceSpan pstate, Block_Obj b)
+  : ParentStatement(pstate, b), name_()
+  { statement_type(KEYFRAMERULE); }
+  Keyframe_Rule::Keyframe_Rule(const Keyframe_Rule* ptr)
+  : ParentStatement(ptr), name_(ptr->name_)
+  { statement_type(KEYFRAMERULE); }
+
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
+
+  Declaration::Declaration(SourceSpan pstate, String_Obj prop, ExpressionObj val, bool i, bool c, Block_Obj b)
+  : ParentStatement(pstate, b), property_(prop), value_(val), is_important_(i), is_custom_property_(c), is_indented_(false)
+  { statement_type(DECLARATION); }
+  Declaration::Declaration(const Declaration* ptr)
+  : ParentStatement(ptr),
+    property_(ptr->property_),
+    value_(ptr->value_),
+    is_important_(ptr->is_important_),
+    is_custom_property_(ptr->is_custom_property_),
+    is_indented_(ptr->is_indented_)
+  { statement_type(DECLARATION); }
+
+  bool Declaration::is_invisible() const
   {
-    // Check every lhs selector against right hand
-    for(size_t i = 0, L = length(); i < L; ++i) {
-      if ((*this)[i]->is_superselector_of(sub, wrapping)) return true;
+    if (is_custom_property()) return false;
+    return !(value_ && !Cast<Null>(value_));
+  }
+
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
+
+  Assignment::Assignment(SourceSpan pstate, sass::string var, ExpressionObj val, bool is_default, bool is_global)
+  : Statement(pstate), variable_(var), value_(val), is_default_(is_default), is_global_(is_global)
+  { statement_type(ASSIGNMENT); }
+  Assignment::Assignment(const Assignment* ptr)
+  : Statement(ptr),
+    variable_(ptr->variable_),
+    value_(ptr->value_),
+    is_default_(ptr->is_default_),
+    is_global_(ptr->is_global_)
+  { statement_type(ASSIGNMENT); }
+
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
+
+  Import::Import(SourceSpan pstate)
+  : Statement(pstate),
+    urls_(sass::vector<ExpressionObj>()),
+    incs_(sass::vector<Include>()),
+    import_queries_()
+  { statement_type(IMPORT); }
+  Import::Import(const Import* ptr)
+  : Statement(ptr),
+    urls_(ptr->urls_),
+    incs_(ptr->incs_),
+    import_queries_(ptr->import_queries_)
+  { statement_type(IMPORT); }
+
+  sass::vector<Include>& Import::incs() { return incs_; }
+  sass::vector<ExpressionObj>& Import::urls() { return urls_; }
+
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
+
+  Import_Stub::Import_Stub(SourceSpan pstate, Include res)
+  : Statement(pstate), resource_(res)
+  { statement_type(IMPORT_STUB); }
+  Import_Stub::Import_Stub(const Import_Stub* ptr)
+  : Statement(ptr), resource_(ptr->resource_)
+  { statement_type(IMPORT_STUB); }
+  Include Import_Stub::resource() { return resource_; };
+  sass::string Import_Stub::imp_path() { return resource_.imp_path; };
+  sass::string Import_Stub::abs_path() { return resource_.abs_path; };
+
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
+
+  WarningRule::WarningRule(SourceSpan pstate, ExpressionObj msg)
+  : Statement(pstate), message_(msg)
+  { statement_type(WARNING); }
+  WarningRule::WarningRule(const WarningRule* ptr)
+  : Statement(ptr), message_(ptr->message_)
+  { statement_type(WARNING); }
+
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
+
+  ErrorRule::ErrorRule(SourceSpan pstate, ExpressionObj msg)
+  : Statement(pstate), message_(msg)
+  { statement_type(ERROR); }
+  ErrorRule::ErrorRule(const ErrorRule* ptr)
+  : Statement(ptr), message_(ptr->message_)
+  { statement_type(ERROR); }
+
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
+
+  DebugRule::DebugRule(SourceSpan pstate, ExpressionObj val)
+  : Statement(pstate), value_(val)
+  { statement_type(DEBUGSTMT); }
+  DebugRule::DebugRule(const DebugRule* ptr)
+  : Statement(ptr), value_(ptr->value_)
+  { statement_type(DEBUGSTMT); }
+
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
+
+  Comment::Comment(SourceSpan pstate, String_Obj txt, bool is_important)
+  : Statement(pstate), text_(txt), is_important_(is_important)
+  { statement_type(COMMENT); }
+  Comment::Comment(const Comment* ptr)
+  : Statement(ptr),
+    text_(ptr->text_),
+    is_important_(ptr->is_important_)
+  { statement_type(COMMENT); }
+
+  bool Comment::is_invisible() const
+  {
+    return false;
+  }
+
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
+
+  If::If(SourceSpan pstate, ExpressionObj pred, Block_Obj con, Block_Obj alt)
+  : ParentStatement(pstate, con), predicate_(pred), alternative_(alt)
+  { statement_type(IF); }
+  If::If(const If* ptr)
+  : ParentStatement(ptr),
+    predicate_(ptr->predicate_),
+    alternative_(ptr->alternative_)
+  { statement_type(IF); }
+
+  bool If::has_content()
+  {
+    return ParentStatement::has_content() || (alternative_ && alternative_->has_content());
+  }
+
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
+
+  ForRule::ForRule(SourceSpan pstate,
+      sass::string var, ExpressionObj lo, ExpressionObj hi, Block_Obj b, bool inc)
+  : ParentStatement(pstate, b),
+    variable_(var), lower_bound_(lo), upper_bound_(hi), is_inclusive_(inc)
+  { statement_type(FOR); }
+  ForRule::ForRule(const ForRule* ptr)
+  : ParentStatement(ptr),
+    variable_(ptr->variable_),
+    lower_bound_(ptr->lower_bound_),
+    upper_bound_(ptr->upper_bound_),
+    is_inclusive_(ptr->is_inclusive_)
+  { statement_type(FOR); }
+
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
+
+  EachRule::EachRule(SourceSpan pstate, sass::vector<sass::string> vars, ExpressionObj lst, Block_Obj b)
+  : ParentStatement(pstate, b), variables_(vars), list_(lst)
+  { statement_type(EACH); }
+  EachRule::EachRule(const EachRule* ptr)
+  : ParentStatement(ptr), variables_(ptr->variables_), list_(ptr->list_)
+  { statement_type(EACH); }
+
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
+
+  WhileRule::WhileRule(SourceSpan pstate, ExpressionObj pred, Block_Obj b)
+  : ParentStatement(pstate, b), predicate_(pred)
+  { statement_type(WHILE); }
+  WhileRule::WhileRule(const WhileRule* ptr)
+  : ParentStatement(ptr), predicate_(ptr->predicate_)
+  { statement_type(WHILE); }
+
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
+
+  Return::Return(SourceSpan pstate, ExpressionObj val)
+  : Statement(pstate), value_(val)
+  { statement_type(RETURN); }
+  Return::Return(const Return* ptr)
+  : Statement(ptr), value_(ptr->value_)
+  { statement_type(RETURN); }
+
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
+
+    ExtendRule::ExtendRule(SourceSpan pstate, SelectorListObj s)
+  : Statement(pstate), isOptional_(false), selector_(s), schema_()
+  { statement_type(EXTEND); }
+  ExtendRule::ExtendRule(SourceSpan pstate, Selector_Schema_Obj s)
+    : Statement(pstate), isOptional_(false), selector_(), schema_(s)
+  {
+    statement_type(EXTEND);
+  }
+  ExtendRule::ExtendRule(const ExtendRule* ptr)
+  : Statement(ptr),
+    isOptional_(ptr->isOptional_),
+    selector_(ptr->selector_),
+    schema_(ptr->schema_)
+  { statement_type(EXTEND); }
+
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
+
+  Definition::Definition(const Definition* ptr)
+  : ParentStatement(ptr),
+    name_(ptr->name_),
+    parameters_(ptr->parameters_),
+    environment_(ptr->environment_),
+    type_(ptr->type_),
+    native_function_(ptr->native_function_),
+    c_function_(ptr->c_function_),
+    cookie_(ptr->cookie_),
+    is_overload_stub_(ptr->is_overload_stub_),
+    signature_(ptr->signature_)
+  { }
+
+  Definition::Definition(SourceSpan pstate,
+              sass::string n,
+              Parameters_Obj params,
+              Block_Obj b,
+              Type t)
+  : ParentStatement(pstate, b),
+    name_(n),
+    parameters_(params),
+    environment_(0),
+    type_(t),
+    native_function_(0),
+    c_function_(0),
+    cookie_(0),
+    is_overload_stub_(false),
+    signature_(0)
+  { }
+
+  Definition::Definition(SourceSpan pstate,
+              Signature sig,
+              sass::string n,
+              Parameters_Obj params,
+              Native_Function func_ptr,
+              bool overload_stub)
+  : ParentStatement(pstate, {}),
+    name_(n),
+    parameters_(params),
+    environment_(0),
+    type_(FUNCTION),
+    native_function_(func_ptr),
+    c_function_(0),
+    cookie_(0),
+    is_overload_stub_(overload_stub),
+    signature_(sig)
+  { }
+
+  Definition::Definition(SourceSpan pstate,
+              Signature sig,
+              sass::string n,
+              Parameters_Obj params,
+              Sass_Function_Entry c_func)
+  : ParentStatement(pstate, {}),
+    name_(n),
+    parameters_(params),
+    environment_(0),
+    type_(FUNCTION),
+    native_function_(0),
+    c_function_(c_func),
+    cookie_(sass_function_get_cookie(c_func)),
+    is_overload_stub_(false),
+    signature_(sig)
+  { }
+
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
+
+  Mixin_Call::Mixin_Call(SourceSpan pstate, sass::string n, Arguments_Obj args, Parameters_Obj b_params, Block_Obj b)
+  : ParentStatement(pstate, b), name_(n), arguments_(args), block_parameters_(b_params)
+  { }
+  Mixin_Call::Mixin_Call(const Mixin_Call* ptr)
+  : ParentStatement(ptr),
+    name_(ptr->name_),
+    arguments_(ptr->arguments_),
+    block_parameters_(ptr->block_parameters_)
+  { }
+
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
+
+  Content::Content(SourceSpan pstate, Arguments_Obj args)
+  : Statement(pstate),
+    arguments_(args)
+  { statement_type(CONTENT); }
+  Content::Content(const Content* ptr)
+  : Statement(ptr),
+    arguments_(ptr->arguments_)
+  { statement_type(CONTENT); }
+
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
+
+  Expression::Expression(SourceSpan pstate, bool d, bool e, bool i, Type ct)
+  : AST_Node(pstate),
+    is_delayed_(d),
+    is_expanded_(e),
+    is_interpolant_(i),
+    concrete_type_(ct)
+  { }
+
+  Expression::Expression(const Expression* ptr)
+  : AST_Node(ptr),
+    is_delayed_(ptr->is_delayed_),
+    is_expanded_(ptr->is_expanded_),
+    is_interpolant_(ptr->is_interpolant_),
+    concrete_type_(ptr->concrete_type_)
+  { }
+
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
+
+  Unary_Expression::Unary_Expression(SourceSpan pstate, Type t, ExpressionObj o)
+  : Expression(pstate), optype_(t), operand_(o), hash_(0)
+  { }
+  Unary_Expression::Unary_Expression(const Unary_Expression* ptr)
+  : Expression(ptr),
+    optype_(ptr->optype_),
+    operand_(ptr->operand_),
+    hash_(ptr->hash_)
+  { }
+  const sass::string Unary_Expression::type_name() {
+    switch (optype_) {
+      case PLUS: return "plus";
+      case MINUS: return "minus";
+      case SLASH: return "slash";
+      case NOT: return "not";
+      default: return "invalid";
+    }
+  }
+  bool Unary_Expression::operator==(const Expression& rhs) const
+  {
+    try
+    {
+      const Unary_Expression* m = Cast<Unary_Expression>(&rhs);
+      if (m == 0) return false;
+      return type() == m->type() &&
+              *operand() == *m->operand();
+    }
+    catch (std::bad_cast&)
+    {
+      return false;
     }
-    return false;
+    catch (...) { throw; }
   }
-
-  // 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_Obj sub, std::string wrapping)
+  size_t Unary_Expression::hash() const
   {
-    // Check every lhs selector against right hand
-    for(size_t i = 0, L = length(); i < L; ++i) {
-      if ((*this)[i]->is_superselector_of(sub)) return true;
-    }
-    return false;
+    if (hash_ == 0) {
+      hash_ = std::hash<size_t>()(optype_);
+      hash_combine(hash_, operand()->hash());
+    };
+    return hash_;
   }
 
-  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);
-
-        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] );
-          }
-        }
-      }
-    }
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
 
-    // Creates the final Selector_List by combining all the complex selectors
-    Selector_List_Ptr final_result = SASS_MEMORY_NEW(Selector_List, pstate());
-    for (auto itr = unified_complex_selectors.begin(); itr != unified_complex_selectors.end(); ++itr) {
-      final_result->append(*itr);
+  Argument::Argument(SourceSpan pstate, ExpressionObj val, sass::string n, bool rest, bool keyword)
+  : Expression(pstate), value_(val), name_(n), is_rest_argument_(rest), is_keyword_argument_(keyword), hash_(0)
+  {
+    if (!name_.empty() && is_rest_argument_) {
+      coreError("variable-length argument may not be passed by name", pstate_);
     }
-    return final_result;
   }
-
-  void Selector_List::populate_extends(Selector_List_Obj extendee, Subset_Map& extends)
+  Argument::Argument(const Argument* ptr)
+  : Expression(ptr),
+    value_(ptr->value_),
+    name_(ptr->name_),
+    is_rest_argument_(ptr->is_rest_argument_),
+    is_keyword_argument_(ptr->is_keyword_argument_),
+    hash_(ptr->hash_)
   {
-
-    Selector_List_Ptr extender = this;
-    for (auto complex_sel : extendee->elements()) {
-      Complex_Selector_Obj c = complex_sel;
-
-
-      // Ignore any parent selectors, until we find the first non Selectorerence head
-      Compound_Selector_Obj compound_sel = c->head();
-      Complex_Selector_Obj pIter = complex_sel;
-      while (pIter) {
-        Compound_Selector_Obj pHead = pIter->head();
-        if (pHead && Cast<Parent_Selector>(pHead->elements()[0]) == NULL) {
-          compound_sel = pHead;
-          break;
-        }
-
-        pIter = pIter->tail();
-      }
-
-      if (!pIter->head() || pIter->tail()) {
-        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));
-      }
+    if (!name_.empty() && is_rest_argument_) {
+      coreError("variable-length argument may not be passed by name", pstate_);
     }
-  };
+  }
 
-  void Compound_Selector::append(Simple_Selector_Ptr element)
+  void Argument::set_delayed(bool delayed)
   {
-    Vectorized<Simple_Selector_Obj>::append(element);
-    pstate_.offset += element->pstate().offset;
+    if (value_) value_->set_delayed(delayed);
+    is_delayed(delayed);
   }
 
-  Compound_Selector_Ptr Compound_Selector::minus(Compound_Selector_Ptr rhs)
+  bool Argument::operator==(const Expression& rhs) const
   {
-    Compound_Selector_Ptr result = SASS_MEMORY_NEW(Compound_Selector, pstate());
-    // result->has_parent_reference(has_parent_reference());
-
-    // not very efficient because it needs to preserve order
-    for (size_t i = 0, L = length(); i < L; ++i)
+    try
     {
-      bool found = false;
-      std::string thisSelector((*this)[i]->to_string());
-      for (size_t j = 0, M = rhs->length(); j < M; ++j)
-      {
-        if (thisSelector == (*rhs)[j]->to_string())
-        {
-          found = true;
-          break;
-        }
-      }
-      if (!found) result->append((*this)[i]);
+      const Argument* m = Cast<Argument>(&rhs);
+      if (!(m && name() == m->name())) return false;
+      return *value() == *m->value();
+    }
+    catch (std::bad_cast&)
+    {
+      return false;
     }
+    catch (...) { throw; }
+  }
 
-    return result;
+  size_t Argument::hash() const
+  {
+    if (hash_ == 0) {
+      hash_ = std::hash<sass::string>()(name());
+      hash_combine(hash_, value()->hash());
+    }
+    return hash_;
   }
 
-  void Compound_Selector::mergeSources(ComplexSelectorSet& sources)
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
+
+  Arguments::Arguments(SourceSpan pstate)
+  : Expression(pstate),
+    Vectorized<Argument_Obj>(),
+    has_named_arguments_(false),
+    has_rest_argument_(false),
+    has_keyword_argument_(false)
+  { }
+  Arguments::Arguments(const Arguments* ptr)
+  : Expression(ptr),
+    Vectorized<Argument_Obj>(*ptr),
+    has_named_arguments_(ptr->has_named_arguments_),
+    has_rest_argument_(ptr->has_rest_argument_),
+    has_keyword_argument_(ptr->has_keyword_argument_)
+  { }
+
+  void Arguments::set_delayed(bool delayed)
   {
-    for (ComplexSelectorSet::iterator iterator = sources.begin(), endIterator = sources.end(); iterator != endIterator; ++iterator) {
-      this->sources_.insert(SASS_MEMORY_CLONE(*iterator));
+    for (Argument_Obj arg : elements()) {
+      if (arg) arg->set_delayed(delayed);
     }
+    is_delayed(delayed);
   }
 
   Argument_Obj Arguments::get_rest_argument()
@@ -1749,7 +687,7 @@ namespace Sass {
         }
       }
     }
-    return NULL;
+    return {};
   }
 
   Argument_Obj Arguments::get_keyword_argument()
@@ -1761,7 +699,7 @@ namespace Sass {
         }
       }
     }
-    return NULL;
+    return {};
   }
 
   void Arguments::adjust_after_pushing(Argument_Obj a)
@@ -1797,430 +735,219 @@ namespace Sass {
     }
   }
 
-  bool Ruleset::is_invisible() const {
-    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;
-    }
-    return true;
-  }
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
 
-  bool Media_Block::is_invisible() const {
-    for (size_t i = 0, L = block()->length(); i < L; ++i) {
-      Statement_Obj stm = block()->at(i);
-      if (!stm->is_invisible()) return false;
-    }
-    return true;
-  }
+  Media_Query::Media_Query(SourceSpan pstate, String_Obj t, size_t s, bool n, bool r)
+  : Expression(pstate), Vectorized<Media_Query_ExpressionObj>(s),
+    media_type_(t), is_negated_(n), is_restricted_(r)
+  { }
+  Media_Query::Media_Query(const Media_Query* ptr)
+  : Expression(ptr),
+    Vectorized<Media_Query_ExpressionObj>(*ptr),
+    media_type_(ptr->media_type_),
+    is_negated_(ptr->is_negated_),
+    is_restricted_(ptr->is_restricted_)
+  { }
 
-  Number::Number(ParserState pstate, double val, std::string u, bool zero)
-  : Value(pstate),
-    Units(),
-    value_(val),
-    zero_(zero),
-    hash_(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) 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);
-  }
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
 
-  // cancel out unnecessary units
-  void Number::reduce()
-  {
-    // apply conversion factor
-    value_ *= this->Units::reduce();
-  }
+  Media_Query_Expression::Media_Query_Expression(SourceSpan pstate,
+                          ExpressionObj f, ExpressionObj v, bool i)
+  : Expression(pstate), feature_(f), value_(v), is_interpolated_(i)
+  { }
+  Media_Query_Expression::Media_Query_Expression(const Media_Query_Expression* ptr)
+  : Expression(ptr),
+    feature_(ptr->feature_),
+    value_(ptr->value_),
+    is_interpolated_(ptr->is_interpolated_)
+  { }
 
-  void Number::normalize()
-  {
-    // apply conversion factor
-    value_ *= this->Units::normalize();
-  }
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
 
-  bool Custom_Warning::operator== (const Expression& rhs) const
-  {
-    if (Custom_Warning_Ptr_Const r = Cast<Custom_Warning>(&rhs)) {
-      return message() == r->message();
-    }
-    return false;
-  }
+  At_Root_Query::At_Root_Query(SourceSpan pstate, ExpressionObj f, ExpressionObj v, bool i)
+  : Expression(pstate), feature_(f), value_(v)
+  { }
+  At_Root_Query::At_Root_Query(const At_Root_Query* ptr)
+  : Expression(ptr),
+    feature_(ptr->feature_),
+    value_(ptr->value_)
+  { }
 
-  bool Custom_Error::operator== (const Expression& rhs) const
+  bool At_Root_Query::exclude(sass::string str)
   {
-    if (Custom_Error_Ptr_Const r = Cast<Custom_Error>(&rhs)) {
-      return message() == r->message();
-    }
-    return false;
-  }
+    bool with = feature() && unquote(feature()->to_string()).compare("with") == 0;
+    List* l = static_cast<List*>(value().ptr());
+    sass::string v;
 
-  bool Number::operator== (const Expression& rhs) const
-  {
-    if (auto rhsnr = Cast<Number>(&rhs)) {
-      return *this == *rhsnr;
+    if (with)
+    {
+      if (!l || l->length() == 0) return str.compare("rule") != 0;
+      for (size_t i = 0, L = l->length(); i < L; ++i)
+      {
+        v = unquote((*l)[i]->to_string());
+        if (v.compare("all") == 0 || v == str) return false;
+      }
+      return true;
     }
-    return false;
-  }
-
-  bool Number::operator== (const Number& rhs) const
-  {
-    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());
+    else
+    {
+      if (!l || !l->length()) return str.compare("rule") == 0;
+      for (size_t i = 0, L = l->length(); i < L; ++i)
+      {
+        v = unquote((*l)[i]->to_string());
+        if (v.compare("all") == 0 || v == str) return true;
+      }
+      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
-  {
-    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 l.value() < r.value();
-    }
-    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 lhs_unit < rhs_unit ||
-           l.value() < r.value();
-  }
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
 
-  bool String_Quoted::operator== (const Expression& rhs) const
-  {
-    if (String_Quoted_Ptr_Const qstr = Cast<String_Quoted>(&rhs)) {
-      return (value() == qstr->value());
-    } else if (String_Constant_Ptr_Const cstr = Cast<String_Constant>(&rhs)) {
-      return (value() == cstr->value());
-    }
-    return false;
-  }
+  AtRootRule::AtRootRule(SourceSpan pstate, Block_Obj b, At_Root_Query_Obj e)
+  : ParentStatement(pstate, b), expression_(e)
+  { statement_type(ATROOT); }
+  AtRootRule::AtRootRule(const AtRootRule* ptr)
+  : ParentStatement(ptr), expression_(ptr->expression_)
+  { statement_type(ATROOT); }
 
-  bool String_Constant::is_invisible() const {
-    return value_.empty() && quote_mark_ == 0;
+  bool AtRootRule::bubbles() {
+    return true;
   }
 
-  bool String_Constant::operator== (const Expression& rhs) const
-  {
-    if (String_Quoted_Ptr_Const qstr = Cast<String_Quoted>(&rhs)) {
-      return (value() == qstr->value());
-    } else if (String_Constant_Ptr_Const cstr = Cast<String_Constant>(&rhs)) {
-      return (value() == cstr->value());
+  bool AtRootRule::exclude_node(Statement_Obj s) {
+    if (expression() == nullptr)
+    {
+      return s->statement_type() == Statement::RULESET;
     }
-    return false;
-  }
-
-  bool String_Schema::is_left_interpolant(void) const
-  {
-    return length() && first()->is_left_interpolant();
-  }
-  bool String_Schema::is_right_interpolant(void) const
-  {
-    return length() && last()->is_right_interpolant();
-  }
 
-  bool String_Schema::operator== (const Expression& rhs) const
-  {
-    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];
-        Expression_Obj lv = (*this)[i];
-        if (!lv || !rv) return false;
-        if (!(*lv == *rv)) return false;
+    if (s->statement_type() == Statement::DIRECTIVE)
+    {
+      if (AtRuleObj dir = Cast<AtRule>(s))
+      {
+        sass::string keyword(dir->keyword());
+        if (keyword.length() > 0) keyword.erase(0, 1);
+        return expression()->exclude(keyword);
       }
-      return true;
-    }
-    return false;
-  }
-
-  bool Boolean::operator== (const Expression& rhs) const
-  {
-    if (Boolean_Ptr_Const r = Cast<Boolean>(&rhs)) {
-      return (value() == r->value());
     }
-    return false;
-  }
-
-  bool Color::operator== (const Expression& rhs) const
-  {
-    if (Color_Ptr_Const r = Cast<Color>(&rhs)) {
-      return r_ == r->r() &&
-             g_ == r->g() &&
-             b_ == r->b() &&
-             a_ == r->a();
+    if (s->statement_type() == Statement::MEDIA)
+    {
+      return expression()->exclude("media");
     }
-    return false;
-  }
-
-  bool List::operator== (const Expression& rhs) const
-  {
-    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);
-        if (!lv || !rv) return false;
-        if (!(*lv == *rv)) return false;
-      }
-      return true;
+    if (s->statement_type() == Statement::RULESET)
+    {
+      return expression()->exclude("rule");
     }
-    return false;
-  }
-
-  bool Map::operator== (const Expression& rhs) const
-  {
-    if (Map_Ptr_Const r = Cast<Map>(&rhs)) {
-      if (length() != r->length()) return false;
-      for (auto key : keys()) {
-        Expression_Obj lv = at(key);
-        Expression_Obj rv = r->at(key);
-        if (!rv || !lv) return false;
-        if (!(*lv == *rv)) return false;
-      }
-      return true;
+    if (s->statement_type() == Statement::SUPPORTS)
+    {
+      return expression()->exclude("supports");
     }
-    return false;
-  }
-
-  bool Null::operator== (const Expression& rhs) const
-  {
-    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();
+    if (AtRuleObj dir = Cast<AtRule>(s))
+    {
+      if (dir->is_keyframes()) return expression()->exclude("keyframes");
     }
     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_Ptr arg = Cast<Argument>(obj)) {
-        if (!arg->name().empty()) return i;
-      }
-    }
-    return length();
-  }
-
-  Expression_Obj Hashed::at(Expression_Obj k) const
-  {
-    if (elements_.count(k))
-    { return elements_.at(k); }
-    else { return NULL; }
-  }
-
-  bool Binary_Expression::is_left_interpolant(void) const
-  {
-    return is_interpolant() || (left() && left()->is_left_interpolant());
-  }
-  bool Binary_Expression::is_right_interpolant(void) const
-  {
-    return is_interpolant() || (right() && right()->is_right_interpolant());
-  }
-
-  const std::string AST_Node::to_string(Sass_Inspect_Options opt) const
-  {
-    Sass_Output_Options out(opt);
-    Emitter emitter(out);
-    Inspect i(emitter);
-    i.in_declaration = true;
-    // ToDo: inspect should be const
-    const_cast<AST_Node_Ptr>(this)->perform(&i);
-    return i.get_buffer();
-  }
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
 
-  const std::string AST_Node::to_string() const
-  {
-    return to_string({ NESTED, 5 });
-  }
+  Parameter::Parameter(SourceSpan pstate, sass::string n, ExpressionObj def, bool rest)
+  : AST_Node(pstate), name_(n), default_value_(def), is_rest_parameter_(rest)
+  { }
+  Parameter::Parameter(const Parameter* ptr)
+  : AST_Node(ptr),
+    name_(ptr->name_),
+    default_value_(ptr->default_value_),
+    is_rest_parameter_(ptr->is_rest_parameter_)
+  { }
 
-  std::string String_Quoted::inspect() const
-  {
-    return quote(value_, '*');
-  }
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
 
-  std::string String_Constant::inspect() const
-  {
-    return quote(value_, '*');
-  }
+  Parameters::Parameters(SourceSpan pstate)
+  : AST_Node(pstate),
+    Vectorized<Parameter_Obj>(),
+    has_optional_parameters_(false),
+    has_rest_parameter_(false)
+  { }
+  Parameters::Parameters(const Parameters* ptr)
+  : AST_Node(ptr),
+    Vectorized<Parameter_Obj>(*ptr),
+    has_optional_parameters_(ptr->has_optional_parameters_),
+    has_rest_parameter_(ptr->has_rest_parameter_)
+  { }
 
-  bool Declaration::is_invisible() const
+  void Parameters::adjust_after_pushing(Parameter_Obj p)
   {
-    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_Ptr arg = Cast<Argument>(obj)) {
-        return arg->value();
-      } else {
-        return obj;
+    if (p->default_value()) {
+      if (has_rest_parameter()) {
+        coreError("optional parameters may not be combined with variable-length parameters", p->pstate());
+      }
+      has_optional_parameters(true);
+    }
+    else if (p->is_rest_parameter()) {
+      if (has_rest_parameter()) {
+        coreError("functions and mixins cannot have more than one variable-length parameter", p->pstate());
+      }
+      has_rest_parameter(true);
+    }
+    else {
+      if (has_rest_parameter()) {
+        coreError("required parameters must precede variable-length parameters", p->pstate());
+      }
+      if (has_optional_parameters()) {
+        coreError("required parameters must precede optional parameters", p->pstate());
       }
-    } else {
-      return obj;
     }
   }
 
-  //////////////////////////////////////////////////////////////////////////////////////////
-  // Convert map to (key, value) list.
-  //////////////////////////////////////////////////////////////////////////////////////////
-  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(at(key));
-      ret->append(l);
-    }
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
 
-    return ret;
-  }
+  // If you forget to add a class here you will get
+  // undefined reference to `vtable for Sass::Class'
 
-  //////////////////////////////////////////////////////////////////////////////////////////
-  // Copy implementations
-  //////////////////////////////////////////////////////////////////////////////////////////
-
-  #ifdef DEBUG_SHARED_PTR
-
-  #define IMPLEMENT_AST_OPERATORS(klass) \
-    klass##_Ptr klass::copy(std::string file, size_t line) const { \
-      klass##_Ptr cpy = new klass(this); \
-      cpy->trace(file, line); \
-      return cpy; \
-    } \
-    klass##_Ptr klass::clone(std::string file, size_t line) const { \
-      klass##_Ptr cpy = copy(file, line); \
-      cpy->cloneChildren(); \
-      return cpy; \
-    } \
-
-  #else
-
-  #define IMPLEMENT_AST_OPERATORS(klass) \
-    klass##_Ptr klass::copy() const { \
-      return new klass(this); \
-    } \
-    klass##_Ptr klass::clone() const { \
-      klass##_Ptr cpy = copy(); \
-      cpy->cloneChildren(); \
-      return cpy; \
-    } \
-
-  #endif
-
-  IMPLEMENT_AST_OPERATORS(Supports_Operator);
-  IMPLEMENT_AST_OPERATORS(Supports_Negation);
-  IMPLEMENT_AST_OPERATORS(Compound_Selector);
-  IMPLEMENT_AST_OPERATORS(Complex_Selector);
-  IMPLEMENT_AST_OPERATORS(Element_Selector);
-  IMPLEMENT_AST_OPERATORS(Class_Selector);
-  IMPLEMENT_AST_OPERATORS(Id_Selector);
-  IMPLEMENT_AST_OPERATORS(Pseudo_Selector);
-  IMPLEMENT_AST_OPERATORS(Wrapped_Selector);
-  IMPLEMENT_AST_OPERATORS(Selector_List);
-  IMPLEMENT_AST_OPERATORS(Ruleset);
-  IMPLEMENT_AST_OPERATORS(Media_Block);
-  IMPLEMENT_AST_OPERATORS(Custom_Warning);
-  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);
-  IMPLEMENT_AST_OPERATORS(String_Constant);
-  IMPLEMENT_AST_OPERATORS(String_Quoted);
-  IMPLEMENT_AST_OPERATORS(Boolean);
-  IMPLEMENT_AST_OPERATORS(Color);
-  IMPLEMENT_AST_OPERATORS(Null);
-  IMPLEMENT_AST_OPERATORS(Parent_Selector);
+  IMPLEMENT_AST_OPERATORS(StyleRule);
+  IMPLEMENT_AST_OPERATORS(MediaRule);
+  IMPLEMENT_AST_OPERATORS(CssMediaRule);
+  IMPLEMENT_AST_OPERATORS(CssMediaQuery);
   IMPLEMENT_AST_OPERATORS(Import);
   IMPLEMENT_AST_OPERATORS(Import_Stub);
-  IMPLEMENT_AST_OPERATORS(Function_Call);
-  IMPLEMENT_AST_OPERATORS(Directive);
-  IMPLEMENT_AST_OPERATORS(At_Root_Block);
-  IMPLEMENT_AST_OPERATORS(Supports_Block);
-  IMPLEMENT_AST_OPERATORS(While);
-  IMPLEMENT_AST_OPERATORS(Each);
-  IMPLEMENT_AST_OPERATORS(For);
+  IMPLEMENT_AST_OPERATORS(AtRule);
+  IMPLEMENT_AST_OPERATORS(AtRootRule);
+  IMPLEMENT_AST_OPERATORS(WhileRule);
+  IMPLEMENT_AST_OPERATORS(EachRule);
+  IMPLEMENT_AST_OPERATORS(ForRule);
   IMPLEMENT_AST_OPERATORS(If);
   IMPLEMENT_AST_OPERATORS(Mixin_Call);
-  IMPLEMENT_AST_OPERATORS(Extension);
+  IMPLEMENT_AST_OPERATORS(ExtendRule);
   IMPLEMENT_AST_OPERATORS(Media_Query);
   IMPLEMENT_AST_OPERATORS(Media_Query_Expression);
-  IMPLEMENT_AST_OPERATORS(Debug);
-  IMPLEMENT_AST_OPERATORS(Error);
-  IMPLEMENT_AST_OPERATORS(Warning);
+  IMPLEMENT_AST_OPERATORS(DebugRule);
+  IMPLEMENT_AST_OPERATORS(ErrorRule);
+  IMPLEMENT_AST_OPERATORS(WarningRule);
   IMPLEMENT_AST_OPERATORS(Assignment);
   IMPLEMENT_AST_OPERATORS(Return);
   IMPLEMENT_AST_OPERATORS(At_Root_Query);
-  IMPLEMENT_AST_OPERATORS(Variable);
   IMPLEMENT_AST_OPERATORS(Comment);
-  IMPLEMENT_AST_OPERATORS(Attribute_Selector);
-  IMPLEMENT_AST_OPERATORS(Supports_Interpolation);
-  IMPLEMENT_AST_OPERATORS(Supports_Declaration);
-  IMPLEMENT_AST_OPERATORS(Supports_Condition);
   IMPLEMENT_AST_OPERATORS(Parameters);
   IMPLEMENT_AST_OPERATORS(Parameter);
   IMPLEMENT_AST_OPERATORS(Arguments);
   IMPLEMENT_AST_OPERATORS(Argument);
   IMPLEMENT_AST_OPERATORS(Unary_Expression);
-  IMPLEMENT_AST_OPERATORS(Function_Call_Schema);
   IMPLEMENT_AST_OPERATORS(Block);
   IMPLEMENT_AST_OPERATORS(Content);
   IMPLEMENT_AST_OPERATORS(Trace);
   IMPLEMENT_AST_OPERATORS(Keyframe_Rule);
   IMPLEMENT_AST_OPERATORS(Bubble);
-  IMPLEMENT_AST_OPERATORS(Selector_Schema);
-  IMPLEMENT_AST_OPERATORS(Placeholder_Selector);
   IMPLEMENT_AST_OPERATORS(Definition);
   IMPLEMENT_AST_OPERATORS(Declaration);
+
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
+
 }