sassc 2.2.1 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a9d02f93975945a28234a652a653c6f948c243e21367ac04fd47fe73c9b2ffb2
-  data.tar.gz: 77e20a198347263cb2a5b94f63a452cbf2e19352a379d47f63861286cd008244
+  metadata.gz: aebf2c0084662833c589a03cd0de02b8b72d3968f4c33a27d1b37c330a692bf2
+  data.tar.gz: b828b00fb88f9ed8414cd7abfd86afdced6458f47e9560789690d8f9a3670c43
 SHA512:
-  metadata.gz: f43ded03b2153ae363b32c0e95542bc2eb9e1e33f27a09e81b9225c6a055a0ac412ba0a8fe474cd58ed39b68c8fc34cbe3cf8dfd171e08a9b831c09b80d1c3e6
-  data.tar.gz: c53a978dc54f799557f19dde249d17cf21346bc751c16fae7eadbd36e67f9ff8955ff764e3de6ab5f8206f6ab35324b2041972f98bc222a69930eb2f8d74aaab
+  metadata.gz: 802546b5350e0b550b8ba01a125e03dbe52ce9541003ae811782b4cf2c197e12b5056520376a5dbf5317a2b033f70808fafd1e62fe40ecd12cf2d56c52881c6e
+  data.tar.gz: 864f16c8f74351159107fb1ccfd3abf837447b41a846a1c990481e7b28732222c4abde988aebe953fb500db2424a0d7d7ce2fc1c351ed2711aa1fa5ea88e37c1

data/.travis.yml

@@ -10,5 +10,6 @@ rvm:
   - 2.4.6
   - 2.5.5
   - 2.6.3
+  - truffleruby
 notifications:
   email: false

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+- **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**

data/Rakefile

@@ -36,9 +36,7 @@ task 'gem:native' do
 
   # 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.
-  #
-  # g++-multilib is installed for 64->32-bit cross-compilation.
-  RakeCompilerDock.sh "sudo apt-get install -y g++-multilib && gem i rake bundler --no-document && bundle && "\
+  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

data/ext/extconf.rb

@@ -19,13 +19,17 @@ if enable_config('static-stdlib', false)
   $LDFLAGS << ' -static-libgcc -static-libstdc++'
 end
 
-# Set to false when building binary gems
-if enable_config('march-tune-native', true)
+if enable_config('march-tune-native', false)
   $CFLAGS << ' -march=native -mtune=native'
   $CXXFLAGS << ' -march=native -mtune=native'
 end
 
-if enable_config('lto', true)
+# 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'
@@ -56,10 +60,14 @@ $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}']
+  $srcs = Dir['libsass/src/**/*.{c,cpp}'].sort
 end
 
-MakeMakefile::LINK_SO << "\nstrip -x $@"
+# 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

data/ext/libsass/VERSION

@@ -1 +1 @@
-3.6.1
+3.6.3

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

@@ -68,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

@@ -134,6 +134,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/ast.cpp

@@ -1,19 +1,8 @@
+// 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 {
 
@@ -69,7 +58,7 @@ namespace Sass {
     pstate_.offset += pstate - pstate_ + pstate.offset;
   }
 
-  const std::string AST_Node::to_string(Sass_Inspect_Options opt) const
+  std::string AST_Node::to_string(Sass_Inspect_Options opt) const
   {
     Sass_Output_Options out(opt);
     Emitter emitter(out);
@@ -80,19 +69,21 @@ namespace Sass {
     return i.get_buffer();
   }
 
-  const std::string AST_Node::to_string() const
+  std::string AST_Node::to_css(Sass_Inspect_Options opt) const
   {
-    return to_string({ NESTED, 5 });
+    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();
   }
 
-  /////////////////////////////////////////////////////////////////////////
-  /////////////////////////////////////////////////////////////////////////
-
-  Expression_Obj Hashed::at(Expression_Obj k) const
+  std::string AST_Node::to_string() const
   {
-    if (elements_.count(k))
-    { return elements_.at(k); }
-    else { return {}; }
+    return to_string({ NESTED, 5 });
   }
 
   /////////////////////////////////////////////////////////////////////////
@@ -137,6 +128,14 @@ namespace Sass {
     is_root_(ptr->is_root_)
   { }
 
+  bool Block::isInvisible() const
+  {
+    for (auto& item : elements()) {
+      if (!item->is_invisible()) return false;
+    }
+    return true;
+  }
+
   bool Block::has_content()
   {
     for (size_t i = 0, L = elements().size(); i < L; ++i) {
@@ -163,19 +162,20 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Ruleset::Ruleset(ParserState pstate, Selector_List_Obj s, Block_Obj b)
-  : Has_Block(pstate, b), selector_(s), is_root_(false)
+  Ruleset::Ruleset(ParserState pstate, SelectorListObj s, Block_Obj b)
+  : Has_Block(pstate, b), selector_(s), schema_(), is_root_(false)
   { statement_type(RULESET); }
   Ruleset::Ruleset(const Ruleset* ptr)
   : Has_Block(ptr),
     selector_(ptr->selector_),
+    schema_(ptr->schema_),
     is_root_(ptr->is_root_)
   { statement_type(RULESET); }
 
   bool Ruleset::is_invisible() const {
-    if (Selector_List* sl = Cast<Selector_List>(selector())) {
-      for (size_t i = 0, L = sl->length(); i < L; ++i)
-        if (!(*sl)[i]->has_placeholder()) return false;
+    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;
   }
@@ -212,30 +212,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Media_Block::Media_Block(ParserState pstate, List_Obj mqs, Block_Obj b)
-  : Has_Block(pstate, b), media_queries_(mqs)
-  { statement_type(MEDIA); }
-  Media_Block::Media_Block(const Media_Block* ptr)
-  : Has_Block(ptr), media_queries_(ptr->media_queries_)
-  { statement_type(MEDIA); }
-
-  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;
-  }
-
-  bool Media_Block::bubbles()
-  {
-    return true;
-  }
-
-  /////////////////////////////////////////////////////////////////////////
-  /////////////////////////////////////////////////////////////////////////
-
-  Directive::Directive(ParserState pstate, std::string kwd, Selector_List_Obj sel, Block_Obj b, Expression_Obj val)
+  Directive::Directive(ParserState pstate, std::string kwd, SelectorListObj sel, Block_Obj b, Expression_Obj val)
   : Has_Block(pstate, b), keyword_(kwd), selector_(sel), value_(val) // set value manually if needed
   { statement_type(DIRECTIVE); }
   Directive::Directive(const Directive* ptr)
@@ -450,11 +427,19 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Extension::Extension(ParserState pstate, Selector_List_Obj s)
-  : Statement(pstate), selector_(s)
+    ExtendRule::ExtendRule(ParserState pstate, SelectorListObj s)
+  : Statement(pstate), isOptional_(false), selector_(s), schema_()
   { statement_type(EXTEND); }
-  Extension::Extension(const Extension* ptr)
-  : Statement(ptr), selector_(ptr->selector_)
+  ExtendRule::ExtendRule(ParserState 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); }
 
   /////////////////////////////////////////////////////////////////////////
@@ -923,8 +908,13 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
+  // If you forget to add a class here you will get
+  // undefined reference to `vtable for Sass::Class'
+
   IMPLEMENT_AST_OPERATORS(Ruleset);
-  IMPLEMENT_AST_OPERATORS(Media_Block);
+  IMPLEMENT_AST_OPERATORS(MediaRule);
+  IMPLEMENT_AST_OPERATORS(CssMediaRule);
+  IMPLEMENT_AST_OPERATORS(CssMediaQuery);
   IMPLEMENT_AST_OPERATORS(Import);
   IMPLEMENT_AST_OPERATORS(Import_Stub);
   IMPLEMENT_AST_OPERATORS(Directive);
@@ -934,7 +924,7 @@ namespace Sass {
   IMPLEMENT_AST_OPERATORS(For);
   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);

data/ext/libsass/src/ast.hpp

@@ -5,47 +5,22 @@
 // __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
 
-#include <set>
-#include <deque>
-#include <vector>
-#include <string>
-#include <sstream>
-#include <iostream>
 #include <typeinfo>
-#include <algorithm>
+#include <unordered_map>
+
 #include "sass/base.h"
+#include "ast_helpers.hpp"
 #include "ast_fwd_decl.hpp"
+#include "ast_def_macros.hpp"
 
-#include "util.hpp"
-#include "units.hpp"
-#include "context.hpp"
+#include "file.hpp"
 #include "position.hpp"
-#include "constants.hpp"
 #include "operation.hpp"
-#include "position.hpp"
-#include "inspect.hpp"
-#include "source_map.hpp"
 #include "environment.hpp"
-#include "error_handling.hpp"
-#include "ast_def_macros.hpp"
-#include "ast_fwd_decl.hpp"
-#include "source_map.hpp"
 #include "fn_utils.hpp"
 
-#include "sass.h"
-
 namespace Sass {
 
-  // easier to search with name
-  const bool DELAYED = true;
-
-  // ToDo: should this really be hardcoded
-  // Note: most methods follow precision option
-  const double NUMBER_EPSILON = 1e-12;
-
-  // macro to test if numbers are equal within a small error margin
-  #define NEAR_EQUAL(lhs, rhs) std::fabs(lhs - rhs) < NUMBER_EPSILON
-
   // ToDo: where does this fit best?
   // We don't share this with C-API?
   class Operand {
@@ -101,8 +76,9 @@ namespace Sass {
     virtual size_t hash() const { return 0; }
     virtual std::string inspect() const { return to_string({ INSPECT, 5 }); }
     virtual std::string to_sass() const { return to_string({ TO_SASS, 5 }); }
-    virtual const std::string to_string(Sass_Inspect_Options opt) const;
-    virtual const std::string to_string() const;
+    virtual std::string to_string(Sass_Inspect_Options opt) const;
+    virtual std::string to_css(Sass_Inspect_Options opt) const;
+    virtual std::string to_string() const;
     virtual void cloneChildren() {};
     // generic find function (not fully implemented yet)
     // ToDo: add specific implementions to all children
@@ -110,6 +86,20 @@ namespace Sass {
     void update_pstate(const ParserState& pstate);
     Offset off() { return pstate(); }
     Position pos() { return pstate(); }
+
+    // Some obects are not meant to be compared
+    // ToDo: maybe fallback to pointer comparison?
+    virtual bool operator== (const AST_Node& rhs) const {
+      throw std::runtime_error("operator== not implemented");
+    }
+
+    // We can give some reasonable implementations by using
+    // inverst operators on the specialized implementations
+    virtual bool operator!= (const AST_Node& rhs) const {
+      // Unequal if not equal
+      return !(*this == rhs);
+    }
+
     ATTACH_ABSTRACT_AST_OPERATIONS(AST_Node);
     ATTACH_ABSTRACT_CRTP_PERFORM_METHODS()
   };
@@ -228,37 +218,112 @@ namespace Sass {
   public:
     Vectorized(size_t s = 0) : hash_(0)
     { elements_.reserve(s); }
+    Vectorized(std::vector<T> vec) :
+      elements_(std::move(vec)),
+      hash_(0)
+    {}
     virtual ~Vectorized() = 0;
     size_t length() const   { return elements_.size(); }
     bool empty() const      { return elements_.empty(); }
     void clear()            { return elements_.clear(); }
-    T last() const          { return elements_.back(); }
-    T first() const         { return elements_.front(); }
+    T& last()               { return elements_.back(); }
+    T& first()              { return elements_.front(); }
+    const T& last() const   { return elements_.back(); }
+    const T& first() const  { return elements_.front(); }
+
+    bool operator== (const Vectorized<T>& rhs) const {
+      // Abort early if sizes do not match
+      if (length() != rhs.length()) return false;
+      // Otherwise test each node for object equalicy in order
+      return std::equal(begin(), end(), rhs.begin(), ObjEqualityFn<T>);
+    }
+
+    bool operator!= (const Vectorized<T>& rhs) const {
+      return !(*this == rhs);
+    }
+
     T& operator[](size_t i) { return elements_[i]; }
     virtual const T& at(size_t i) const { return elements_.at(i); }
     virtual T& at(size_t i) { return elements_.at(i); }
     const T& get(size_t i) const { return elements_[i]; }
     const T& operator[](size_t i) const { return elements_[i]; }
-    virtual void append(T element)
+
+    // Implicitly get the std::vector from our object
+    // Makes the Vector directly assignable to std::vector
+    // You are responsible to make a copy if needed
+    // Note: since this returns the real object, we can't
+    // Note: guarantee that the hash will not get out of sync
+    operator std::vector<T>&() { return elements_; }
+    operator const std::vector<T>&() const { return elements_; }
+
+    // Explicitly request all elements as a real std::vector
+    // You are responsible to make a copy if needed
+    // Note: since this returns the real object, we can't
+    // Note: guarantee that the hash will not get out of sync
+    std::vector<T>& elements() { return elements_; }
+    const std::vector<T>& elements() const { return elements_; }
+
+    // Insert all items from compatible vector
+    void concat(const std::vector<T>& v)
+    {
+      if (!v.empty()) reset_hash();
+      elements().insert(end(), v.begin(), v.end());
+    }
+
+    // Syntatic sugar for pointers
+    void concat(const Vectorized<T>* v)
     {
-      if (element) {
-        reset_hash();
-        elements_.push_back(element);
-        adjust_after_pushing(element);
+      if (v != nullptr) {
+        return concat(*v);
       }
     }
-    virtual void concat(Vectorized* v)
+
+    // Insert one item on the front
+    void unshift(T element)
     {
-      for (size_t i = 0, L = v->length(); i < L; ++i) this->append((*v)[i]);
+      reset_hash();
+      elements_.insert(begin(), element);
     }
-    Vectorized& unshift(T element)
+
+    // Remove and return item on the front
+    // ToDo: handle empty vectors
+    T shift() {
+      reset_hash();
+      T first = get(0);
+      elements_.erase(begin());
+      return first;
+    }
+
+    // Insert one item on the back
+    // ToDo: rename this to push
+    void append(T element)
     {
-      elements_.insert(elements_.begin(), element);
-      return *this;
+      reset_hash();
+      elements_.insert(end(), element);
+      // ToDo: Mostly used by parameters and arguments
+      // ToDo: Find a more elegant way to support this
+      adjust_after_pushing(element);
+    }
+
+    // Check if an item already exists
+    // Uses underlying object `operator==`
+    // E.g. compares the actual objects
+    bool contains(const T& el) const {
+      for (const T& rhs : elements_) {
+        // Test the underlying objects for equality
+        // A std::find checks for pointer equality
+        if (ObjEqualityFn(el, rhs)) {
+          return true;
+        }
+      }
+      return false;
+    }
+
+    // This might be better implemented as `operator=`?
+    void elements(std::vector<T> e) {
+      reset_hash();
+      elements_ = std::move(e);
     }
-    std::vector<T>& elements() { return elements_; }
-    const std::vector<T>& elements() const { return elements_; }
-    std::vector<T>& elements(std::vector<T>& e) { elements_ = e; return elements_; }
 
     virtual size_t hash() const
     {
@@ -280,8 +345,8 @@ namespace Sass {
     typename std::vector<T>::iterator begin() { return elements_.begin(); }
     typename std::vector<T>::const_iterator end() const { return elements_.end(); }
     typename std::vector<T>::const_iterator begin() const { return elements_.begin(); }
-    typename std::vector<T>::iterator erase(typename std::vector<T>::iterator el) { return elements_.erase(el); }
-    typename std::vector<T>::const_iterator erase(typename std::vector<T>::const_iterator el) { return elements_.erase(el); }
+    typename std::vector<T>::iterator erase(typename std::vector<T>::iterator el) { reset_hash(); return elements_.erase(el); }
+    typename std::vector<T>::const_iterator erase(typename std::vector<T>::const_iterator el) { reset_hash(); return elements_.erase(el); }
 
   };
   template <typename T>
@@ -291,36 +356,61 @@ namespace Sass {
   // Mixin class for AST nodes that should behave like a hash table. Uses an
   // extra <std::vector> internally to maintain insertion order for interation.
   /////////////////////////////////////////////////////////////////////////////
+  template <typename K, typename T, typename U>
   class Hashed {
   private:
-    ExpressionMap elements_;
-    std::vector<Expression_Obj> list_;
+    std::unordered_map<
+      K, T, ObjHash, ObjEquality
+    > elements_;
+
+    std::vector<K> _keys;
+    std::vector<T> _values;
   protected:
     mutable size_t hash_;
-    Expression_Obj duplicate_key_;
+    K duplicate_key_;
     void reset_hash() { hash_ = 0; }
     void reset_duplicate_key() { duplicate_key_ = {}; }
-    virtual void adjust_after_pushing(std::pair<Expression_Obj, Expression_Obj> p) { }
+    virtual void adjust_after_pushing(std::pair<K, T> p) { }
   public:
     Hashed(size_t s = 0)
-    : elements_(ExpressionMap(s)),
-      list_(std::vector<Expression_Obj>()),
+    : elements_(),
+      _keys(),
+      _values(),
       hash_(0), duplicate_key_({})
-    { elements_.reserve(s); list_.reserve(s); }
+    {
+      _keys.reserve(s);
+      _values.reserve(s);
+      elements_.reserve(s);
+    }
     virtual ~Hashed();
-    size_t length() const                  { return list_.size(); }
-    bool empty() const                     { return list_.empty(); }
-    bool has(Expression_Obj k) const          { return elements_.count(k) == 1; }
-    Expression_Obj at(Expression_Obj k) const;
+    size_t length() const                  { return _keys.size(); }
+    bool empty() const                     { return _keys.empty(); }
+    bool has(K k) const          {
+      return elements_.find(k) != elements_.end();
+    }
+    T at(K k) const {
+      if (elements_.count(k))
+      {
+        return elements_.at(k);
+      }
+      else { return {}; }
+    }
     bool has_duplicate_key() const         { return duplicate_key_ != nullptr; }
-    Expression_Obj get_duplicate_key() const  { return duplicate_key_; }
-    const ExpressionMap elements() { return elements_; }
-    Hashed& operator<<(std::pair<Expression_Obj, Expression_Obj> p)
+    K get_duplicate_key() const  { return duplicate_key_; }
+    const std::unordered_map<
+      K, T, ObjHash, ObjEquality
+    >& elements() { return elements_; }
+    Hashed& operator<<(std::pair<K, T> p)
     {
       reset_hash();
 
-      if (!has(p.first)) list_.push_back(p.first);
-      else if (!duplicate_key_) duplicate_key_ = p.first;
+      if (!has(p.first)) {
+        _keys.push_back(p.first);
+        _values.push_back(p.second);
+      }
+      else if (!duplicate_key_) {
+        duplicate_key_ = p.first;
+      }
 
       elements_[p.first] = p.second;
 
@@ -331,7 +421,8 @@ namespace Sass {
     {
       if (length() == 0) {
         this->elements_ = h->elements_;
-        this->list_ = h->list_;
+        this->_values = h->_values;
+        this->_keys = h->_keys;
         return *this;
       }
 
@@ -342,8 +433,12 @@ namespace Sass {
       reset_duplicate_key();
       return *this;
     }
-    const ExpressionMap& pairs() const { return elements_; }
-    const std::vector<Expression_Obj>& keys() const { return list_; }
+    const std::unordered_map<
+      K, T, ObjHash, ObjEquality
+    >& pairs() const { return elements_; }
+
+    const std::vector<K>& keys() const { return _keys; }
+    const std::vector<T>& values() const { return _values; }
 
 //    std::unordered_map<Expression_Obj, Expression_Obj>::iterator end() { return elements_.end(); }
 //    std::unordered_map<Expression_Obj, Expression_Obj>::iterator begin() { return elements_.begin(); }
@@ -351,8 +446,8 @@ namespace Sass {
 //    std::unordered_map<Expression_Obj, Expression_Obj>::const_iterator begin() const { return elements_.begin(); }
 
   };
-  inline Hashed::~Hashed() { }
-
+  template <typename K, typename T, typename U>
+  inline Hashed<K, T, U>::~Hashed() { }
 
   /////////////////////////////////////////////////////////////////////////
   // Abstract base class for statements. This side of the AST hierarchy
@@ -411,6 +506,7 @@ namespace Sass {
     void adjust_after_pushing(Statement_Obj s) override {}
   public:
     Block(ParserState pstate, size_t s = 0, bool r = false);
+    bool isInvisible() const;
     bool has_content() override;
     ATTACH_AST_OPERATIONS(Block)
     ATTACH_CRTP_PERFORM_METHODS()
@@ -434,10 +530,11 @@ namespace Sass {
   // of style declarations.
   /////////////////////////////////////////////////////////////////////////////
   class Ruleset final : public Has_Block {
-    ADD_PROPERTY(Selector_List_Obj, selector)
+    ADD_PROPERTY(SelectorListObj, selector)
+    ADD_PROPERTY(Selector_Schema_Obj, schema)
     ADD_PROPERTY(bool, is_root);
   public:
-    Ruleset(ParserState pstate, Selector_List_Obj s = {}, Block_Obj b = {});
+    Ruleset(ParserState pstate, SelectorListObj s = {}, Block_Obj b = {});
     bool is_invisible() const override;
     ATTACH_AST_OPERATIONS(Ruleset)
     ATTACH_CRTP_PERFORM_METHODS()
@@ -468,29 +565,16 @@ namespace Sass {
     ATTACH_CRTP_PERFORM_METHODS()
   };
 
-  /////////////////
-  // Media queries.
-  /////////////////
-  class Media_Block final : public Has_Block {
-    ADD_PROPERTY(List_Obj, media_queries)
-  public:
-    Media_Block(ParserState pstate, List_Obj mqs, Block_Obj b);
-    bool bubbles() override;
-    bool is_invisible() const override;
-    ATTACH_AST_OPERATIONS(Media_Block)
-    ATTACH_CRTP_PERFORM_METHODS()
-  };
-
   ///////////////////////////////////////////////////////////////////////
   // At-rules -- arbitrary directives beginning with "@" that may have an
   // optional statement block.
   ///////////////////////////////////////////////////////////////////////
   class Directive final : public Has_Block {
     ADD_CONSTREF(std::string, keyword)
-    ADD_PROPERTY(Selector_List_Obj, selector)
+    ADD_PROPERTY(SelectorListObj, selector)
     ADD_PROPERTY(Expression_Obj, value)
   public:
-    Directive(ParserState pstate, std::string kwd, Selector_List_Obj sel = {}, Block_Obj b = {}, Expression_Obj val = {});
+    Directive(ParserState pstate, std::string kwd, SelectorListObj sel = {}, Block_Obj b = {}, Expression_Obj val = {});
     bool bubbles() override;
     bool is_media();
     bool is_keyframes();
@@ -504,7 +588,7 @@ namespace Sass {
   class Keyframe_Rule final : public Has_Block {
     // according to css spec, this should be <keyframes-name>
     // <keyframes-name> = <custom-ident> | <string>
-    ADD_PROPERTY(Selector_List_Obj, name)
+    ADD_PROPERTY(SelectorListObj, name)
   public:
     Keyframe_Rule(ParserState pstate, Block_Obj b);
     ATTACH_AST_OPERATIONS(Keyframe_Rule)
@@ -677,17 +761,6 @@ namespace Sass {
     ATTACH_CRTP_PERFORM_METHODS()
   };
 
-  ////////////////////////////////
-  // The Sass `@extend` directive.
-  ////////////////////////////////
-  class Extension final : public Statement {
-    ADD_PROPERTY(Selector_List_Obj, selector)
-  public:
-    Extension(ParserState pstate, Selector_List_Obj s);
-    ATTACH_AST_OPERATIONS(Extension)
-    ATTACH_CRTP_PERFORM_METHODS()
-  };
-
   /////////////////////////////////////////////////////////////////////////////
   // Definitions for both mixins and functions. The two cases are distinguished
   // by a type tag.
@@ -806,9 +879,96 @@ namespace Sass {
     ATTACH_CRTP_PERFORM_METHODS()
   };
 
-  /////////////////
-  // Media queries.
-  /////////////////
+
+  // A Media Ruleset before it has been evaluated
+  // Could be already final or an interpolation
+  class MediaRule final : public Has_Block {
+    ADD_PROPERTY(List_Obj, schema)
+  public:
+    MediaRule(ParserState pstate, Block_Obj block = {});
+
+    bool bubbles() override { return true; };
+    bool is_invisible() const override { return false; };
+    ATTACH_AST_OPERATIONS(MediaRule)
+    ATTACH_CRTP_PERFORM_METHODS()
+  };
+
+  // A Media Ruleset after it has been evaluated
+  // Representing the static or resulting css
+  class CssMediaRule final : public Has_Block,
+    public Vectorized<CssMediaQuery_Obj> {
+  public:
+    CssMediaRule(ParserState pstate, Block_Obj b);
+    bool bubbles() override { return true; };
+    bool isInvisible() const { return empty(); }
+    bool is_invisible() const override { return false; };
+
+  public:
+    // Hash and equality implemtation from vector
+    size_t hash() const override { return Vectorized::hash(); }
+    // Check if two instances are considered equal
+    bool operator== (const CssMediaRule& rhs) const {
+      return Vectorized::operator== (rhs);
+    }
+    bool operator!=(const CssMediaRule& rhs) const {
+      // Invert from equality
+      return !(*this == rhs);
+    }
+
+    ATTACH_AST_OPERATIONS(CssMediaRule)
+    ATTACH_CRTP_PERFORM_METHODS()
+  };
+
+  // Media Queries after they have been evaluated
+  // Representing the static or resulting css
+  class CssMediaQuery final : public AST_Node {
+
+    // The modifier, probably either "not" or "only".
+    // This may be `null` if no modifier is in use.
+    ADD_PROPERTY(std::string, modifier);
+
+    // The media type, for example "screen" or "print".
+    // This may be `null`. If so, [features] will not be empty.
+    ADD_PROPERTY(std::string, type);
+
+    // Feature queries, including parentheses.
+    ADD_PROPERTY(std::vector<std::string>, features);
+
+  public:
+    CssMediaQuery(ParserState pstate);
+
+    // Check if two instances are considered equal
+    bool operator== (const CssMediaQuery& rhs) const;
+    bool operator!=(const CssMediaQuery& rhs) const {
+      // Invert from equality
+      return !(*this == rhs);
+    }
+
+    // Returns true if this query is empty
+    // Meaning it has no type and features
+    bool empty() const {
+      return type_.empty()
+        && modifier_.empty()
+        && features_.empty();
+    }
+
+    // Whether this media query matches all media types.
+    bool matchesAllTypes() const {
+      return type_.empty() || Util::equalsLiteral("all", type_);
+    }
+
+    // Merges this with [other] and adds a query that matches the intersection
+    // of both inputs to [result]. Returns false if the result is unrepresentable
+    CssMediaQuery_Obj merge(CssMediaQuery_Obj& other);
+
+    ATTACH_AST_OPERATIONS(CssMediaQuery)
+    ATTACH_CRTP_PERFORM_METHODS()
+  };
+
+  ////////////////////////////////////////////////////
+  // Media queries (replaced by MediaRule at al).
+  // ToDo: only used for interpolation case
+  ////////////////////////////////////////////////////
   class Media_Query final : public Expression,
                             public Vectorized<Media_Query_Expression_Obj> {
     ADD_PROPERTY(String_Obj, media_type)
@@ -822,6 +982,7 @@ namespace Sass {
 
   ////////////////////////////////////////////////////
   // Media expressions (for use inside media queries).
+  // ToDo: only used for interpolation case
   ////////////////////////////////////////////////////
   class Media_Query_Expression final : public Expression {
     ADD_PROPERTY(Expression_Obj, feature)