sassc 2.0.0 → 2.4.0

data/ext/libsass/src/context.hpp

@@ -1,93 +1,81 @@
 #ifndef SASS_CONTEXT_H
 #define SASS_CONTEXT_H
 
-#include <string>
-#include <vector>
-#include <map>
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+#include "ast.hpp"
+
 
 #define BUFFERSIZE 255
 #include "b64/encode.h"
 
-#include "ast_fwd_decl.hpp"
-#include "kwd_arg_macros.hpp"
-#include "ast_fwd_decl.hpp"
 #include "sass_context.hpp"
-#include "environment.hpp"
-#include "source_map.hpp"
-#include "subset_map.hpp"
-#include "backtrace.hpp"
-#include "output.hpp"
+#include "stylesheet.hpp"
 #include "plugins.hpp"
-#include "file.hpp"
-
-
-struct Sass_Function;
+#include "output.hpp"
 
 namespace Sass {
 
   class Context {
   public:
-    void import_url (Import_Ptr imp, std::string load_path, const std::string& ctx_path);
-    bool call_headers(const std::string& load_path, const char* ctx_path, ParserState& pstate, Import_Ptr imp)
+    void import_url (Import* imp, sass::string load_path, const sass::string& ctx_path);
+    bool call_headers(const sass::string& load_path, const char* ctx_path, SourceSpan& pstate, Import* imp)
     { return call_loader(load_path, ctx_path, pstate, imp, c_headers, false); };
-    bool call_importers(const std::string& load_path, const char* ctx_path, ParserState& pstate, Import_Ptr imp)
+    bool call_importers(const sass::string& load_path, const char* ctx_path, SourceSpan& pstate, Import* imp)
     { return call_loader(load_path, ctx_path, pstate, imp, c_importers, true); };
 
   private:
-    bool call_loader(const std::string& load_path, const char* ctx_path, ParserState& pstate, Import_Ptr imp, std::vector<Sass_Importer_Entry> importers, bool only_one = true);
+    bool call_loader(const sass::string& load_path, const char* ctx_path, SourceSpan& pstate, Import* imp, sass::vector<Sass_Importer_Entry> importers, bool only_one = true);
 
   public:
-    const std::string CWD;
+    const sass::string CWD;
     struct Sass_Options& c_options;
-    std::string entry_path;
+    sass::string entry_path;
     size_t head_imports;
     Plugins plugins;
     Output emitter;
 
     // generic ast node garbage container
     // used to avoid possible circular refs
-    std::vector<AST_Node_Obj> ast_gc;
+    CallStack ast_gc;
     // resources add under our control
     // these are guaranteed to be freed
-    std::vector<char*> strings;
-    std::vector<Resource> resources;
-    std::map<const std::string, StyleSheet> sheets;
-    Subset_Map subset_map;
-    std::vector<Sass_Import_Entry> import_stack;
-    std::vector<Sass_Callee> callee_stack;
-    std::vector<Backtrace> traces;
+    sass::vector<char*> strings;
+    sass::vector<Resource> resources;
+    std::map<const sass::string, StyleSheet> sheets;
+    ImporterStack import_stack;
+    sass::vector<Sass_Callee> callee_stack;
+    sass::vector<Backtrace> traces;
+    Extender extender;
 
     struct Sass_Compiler* c_compiler;
 
     // absolute paths to includes
-    std::vector<std::string> included_files;
+    sass::vector<sass::string> included_files;
     // relative includes for sourcemap
-    std::vector<std::string> srcmap_links;
+    sass::vector<sass::string> srcmap_links;
     // vectors above have same size
 
-    std::vector<std::string> plugin_paths; // relative paths to load plugins
-    std::vector<std::string> include_paths; // lookup paths for includes
-
-
-
-
+    sass::vector<sass::string> plugin_paths; // relative paths to load plugins
+    sass::vector<sass::string> include_paths; // lookup paths for includes
 
-    void apply_custom_headers(Block_Obj root, const char* path, ParserState pstate);
+    void apply_custom_headers(Block_Obj root, const char* path, SourceSpan pstate);
 
-    std::vector<Sass_Importer_Entry> c_headers;
-    std::vector<Sass_Importer_Entry> c_importers;
-    std::vector<Sass_Function_Entry> c_functions;
+    sass::vector<Sass_Importer_Entry> c_headers;
+    sass::vector<Sass_Importer_Entry> c_importers;
+    sass::vector<Sass_Function_Entry> c_functions;
 
     void add_c_header(Sass_Importer_Entry header);
     void add_c_importer(Sass_Importer_Entry importer);
     void add_c_function(Sass_Function_Entry function);
 
-    const std::string indent; // String to be used for indentation
-    const std::string linefeed; // String to be used for line feeds
-    const std::string input_path; // for relative paths in src-map
-    const std::string output_path; // for relative paths to the output
-    const std::string source_map_file; // path to source map file (enables feature)
-    const std::string source_map_root; // path for sourceRoot property (pass-through)
+    const sass::string indent; // String to be used for indentation
+    const sass::string linefeed; // String to be used for line feeds
+    const sass::string input_path; // for relative paths in src-map
+    const sass::string output_path; // for relative paths to the output
+    const sass::string source_map_file; // path to source map file (enables feature)
+    const sass::string source_map_root; // path for sourceRoot property (pass-through)
 
     virtual ~Context();
     Context(struct Sass_Context&);
@@ -97,29 +85,29 @@ namespace Sass {
     virtual char* render_srcmap();
 
     void register_resource(const Include&, const Resource&);
-    void register_resource(const Include&, const Resource&, ParserState&);
-    std::vector<Include> find_includes(const Importer& import);
-    Include load_import(const Importer&, ParserState pstate);
+    void register_resource(const Include&, const Resource&, SourceSpan&);
+    sass::vector<Include> find_includes(const Importer& import);
+    Include load_import(const Importer&, SourceSpan pstate);
 
     Sass_Output_Style output_style() { return c_options.output_style; };
-    std::vector<std::string> get_included_files(bool skip = false, size_t headers = 0);
+    sass::vector<sass::string> get_included_files(bool skip = false, size_t headers = 0);
 
   private:
     void collect_plugin_paths(const char* paths_str);
     void collect_plugin_paths(string_list* paths_array);
     void collect_include_paths(const char* paths_str);
     void collect_include_paths(string_list* paths_array);
-    std::string format_embedded_source_map();
-    std::string format_source_mapping_url(const std::string& out_path);
+    sass::string format_embedded_source_map();
+    sass::string format_source_mapping_url(const sass::string& out_path);
 
 
     // void register_built_in_functions(Env* env);
     // void register_function(Signature sig, Native_Function f, Env* env);
     // void register_function(Signature sig, Native_Function f, size_t arity, Env* env);
-    // void register_overload_stub(std::string name, Env* env);
+    // void register_overload_stub(sass::string name, Env* env);
 
   public:
-    const std::string& cwd() { return CWD; };
+    const sass::string& cwd() { return CWD; };
   };
 
   class File_Context : public Context {

data/ext/libsass/src/cssize.cpp

@@ -1,4 +1,7 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
+
 #include <iostream>
 #include <typeinfo>
 #include <vector>
@@ -9,18 +12,17 @@
 namespace Sass {
 
   Cssize::Cssize(Context& ctx)
-  : ctx(ctx),
-    traces(ctx.traces),
-    block_stack(std::vector<Block_Ptr>()),
-    p_stack(std::vector<Statement_Ptr>())
+  : traces(ctx.traces),
+    block_stack(BlockStack()),
+    p_stack(sass::vector<Statement*>())
   { }
 
-  Statement_Ptr Cssize::parent()
+  Statement* Cssize::parent()
   {
     return p_stack.size() ? p_stack.back() : block_stack.front();
   }
 
-  Block_Ptr Cssize::operator()(Block_Ptr b)
+  Block* Cssize::operator()(Block* b)
   {
     Block_Obj bb = SASS_MEMORY_NEW(Block, b->pstate(), b->length(), b->is_root());
     // bb->tabs(b->tabs());
@@ -30,7 +32,7 @@ namespace Sass {
     return bb.detach();
   }
 
-  Statement_Ptr Cssize::operator()(Trace_Ptr t)
+  Statement* Cssize::operator()(Trace* t)
   {
     traces.push_back(Backtrace(t->pstate()));
     auto result = t->block()->perform(this);
@@ -38,11 +40,11 @@ namespace Sass {
     return result;
   }
 
-  Statement_Ptr Cssize::operator()(Declaration_Ptr d)
+  Statement* Cssize::operator()(Declaration* d)
   {
     String_Obj property = Cast<String>(d->property());
 
-    if (Declaration_Ptr dd = Cast<Declaration>(parent())) {
+    if (Declaration* dd = Cast<Declaration>(parent())) {
       String_Obj parent_property = Cast<String>(dd->property());
       property = SASS_MEMORY_NEW(String_Constant,
                                  d->property()->pstate(),
@@ -78,17 +80,17 @@ namespace Sass {
     return 0;
   }
 
-  Statement_Ptr Cssize::operator()(Directive_Ptr r)
+  Statement* Cssize::operator()(AtRule* r)
   {
     if (!r->block() || !r->block()->length()) return r;
 
     if (parent()->statement_type() == Statement::RULESET)
     {
-      return (r->is_keyframes()) ? SASS_MEMORY_NEW(Bubble, r->pstate(), r) : bubble(r);
+      return r->is_keyframes() ? SASS_MEMORY_NEW(Bubble, r->pstate(), r) : bubble(r);
     }
 
     p_stack.push_back(r);
-    Directive_Obj rr = SASS_MEMORY_NEW(Directive,
+    AtRuleObj rr = SASS_MEMORY_NEW(AtRule,
                                   r->pstate(),
                                   r->keyword(),
                                   r->selector(),
@@ -105,15 +107,15 @@ namespace Sass {
         Bubble_Obj s_obj = Cast<Bubble>(s);
         s = s_obj->node();
         if (s->statement_type() != Statement::DIRECTIVE) directive_exists = false;
-        else directive_exists = (Cast<Directive>(s)->keyword() == rr->keyword());
+        else directive_exists = (Cast<AtRule>(s)->keyword() == rr->keyword());
       }
 
     }
 
-    Block_Ptr result = SASS_MEMORY_NEW(Block, rr->pstate());
+    Block* result = SASS_MEMORY_NEW(Block, rr->pstate());
     if (!(directive_exists || rr->is_keyframes()))
     {
-      Directive_Ptr empty_node = Cast<Directive>(rr);
+      AtRule* empty_node = Cast<AtRule>(rr);
       empty_node->block(SASS_MEMORY_NEW(Block, rr->block() ? rr->block()->pstate() : rr->pstate()));
       result->append(empty_node);
     }
@@ -128,7 +130,7 @@ namespace Sass {
     return result;
   }
 
-  Statement_Ptr Cssize::operator()(Keyframe_Rule_Ptr r)
+  Statement* Cssize::operator()(Keyframe_Rule* r)
   {
     if (!r->block() || !r->block()->length()) return r;
 
@@ -140,20 +142,20 @@ namespace Sass {
     return debubble(rr->block(), rr);
   }
 
-  Statement_Ptr Cssize::operator()(Ruleset_Ptr r)
+  Statement* Cssize::operator()(StyleRule* r)
   {
     p_stack.push_back(r);
     // this can return a string schema
     // string schema is not a statement!
     // r->block() is already a string schema
-    // and that is comming from propset expand
-    Block_Ptr bb = operator()(r->block());
+    // and that is coming from propset expand
+    Block* bb = operator()(r->block());
     // this should protect us (at least a bit) from our mess
     // fixing this properly is harder that it should be ...
     if (Cast<Statement>(bb) == NULL) {
       error("Illegal nesting: Only properties may be nested beneath properties.", r->block()->pstate(), traces);
     }
-    Ruleset_Obj rr = SASS_MEMORY_NEW(Ruleset,
+    StyleRuleObj rr = SASS_MEMORY_NEW(StyleRule,
                                   r->pstate(),
                                   r->selector(),
                                   bb);
@@ -167,10 +169,10 @@ namespace Sass {
     }
 
     Block_Obj props = SASS_MEMORY_NEW(Block, rr->block()->pstate());
-    Block_Ptr rules = SASS_MEMORY_NEW(Block, rr->block()->pstate());
+    Block* rules = SASS_MEMORY_NEW(Block, rr->block()->pstate());
     for (size_t i = 0, L = rr->block()->length(); i < L; i++)
     {
-      Statement_Ptr s = rr->block()->at(i);
+      Statement* s = rr->block()->at(i);
       if (bubblable(s)) rules->append(s);
       if (!bubblable(s)) props->append(s);
     }
@@ -183,14 +185,14 @@ namespace Sass {
 
       for (size_t i = 0, L = rules->length(); i < L; i++)
       {
-        Statement_Ptr stm = rules->at(i);
+        Statement* stm = rules->at(i);
         stm->tabs(stm->tabs() + 1);
       }
 
       rules->unshift(rr);
     }
 
-    Block_Ptr ptr = rules;
+    Block* ptr = rules;
     rules = debubble(rules);
     void* lp = ptr;
     void* rp = rules;
@@ -207,25 +209,28 @@ namespace Sass {
     return rules;
   }
 
-  Statement_Ptr Cssize::operator()(Null_Ptr m)
+  Statement* Cssize::operator()(Null* m)
   {
     return 0;
   }
 
-  Statement_Ptr Cssize::operator()(Media_Block_Ptr m)
+  Statement* Cssize::operator()(CssMediaRule* m)
   {
     if (parent()->statement_type() == Statement::RULESET)
-    { return bubble(m); }
+    {
+      return bubble(m);
+    }
 
     if (parent()->statement_type() == Statement::MEDIA)
-    { return SASS_MEMORY_NEW(Bubble, m->pstate(), m); }
+    {
+      return SASS_MEMORY_NEW(Bubble, m->pstate(), m);
+    }
 
     p_stack.push_back(m);
 
-    Media_Block_Obj mm = SASS_MEMORY_NEW(Media_Block,
-                                      m->pstate(),
-                                      m->media_queries(),
-                                      operator()(m->block()));
+    CssMediaRuleObj mm = SASS_MEMORY_NEW(CssMediaRule, m->pstate(), m->block());
+    mm->concat(m->elements());
+    mm->block(operator()(m->block()));
     mm->tabs(m->tabs());
 
     p_stack.pop_back();
@@ -233,7 +238,7 @@ namespace Sass {
     return debubble(mm->block(), mm);
   }
 
-  Statement_Ptr Cssize::operator()(Supports_Block_Ptr m)
+  Statement* Cssize::operator()(SupportsRule* m)
   {
     if (!m->block()->length())
     { return m; }
@@ -243,7 +248,7 @@ namespace Sass {
 
     p_stack.push_back(m);
 
-    Supports_Block_Obj mm = SASS_MEMORY_NEW(Supports_Block,
+    SupportsRuleObj mm = SASS_MEMORY_NEW(SupportsRule,
                                        m->pstate(),
                                        m->condition(),
                                        operator()(m->block()));
@@ -254,17 +259,17 @@ namespace Sass {
     return debubble(mm->block(), mm);
   }
 
-  Statement_Ptr Cssize::operator()(At_Root_Block_Ptr m)
+  Statement* Cssize::operator()(AtRootRule* m)
   {
     bool tmp = false;
     for (size_t i = 0, L = p_stack.size(); i < L; ++i) {
-      Statement_Ptr s = p_stack[i];
+      Statement* s = p_stack[i];
       tmp |= m->exclude_node(s);
     }
 
     if (!tmp && m->block())
     {
-      Block_Ptr bb = operator()(m->block());
+      Block* bb = operator()(m->block());
       for (size_t i = 0, L = bb->length(); i < L; ++i) {
         // (bb->elements())[i]->tabs(m->tabs());
         Statement_Obj stm = bb->at(i);
@@ -282,33 +287,33 @@ namespace Sass {
     return bubble(m);
   }
 
-  Statement_Ptr Cssize::bubble(Directive_Ptr m)
+  Statement* Cssize::bubble(AtRule* m)
   {
-    Block_Ptr bb = SASS_MEMORY_NEW(Block, this->parent()->pstate());
-    Has_Block_Obj new_rule = Cast<Has_Block>(SASS_MEMORY_COPY(this->parent()));
+    Block* bb = SASS_MEMORY_NEW(Block, this->parent()->pstate());
+    ParentStatementObj new_rule = Cast<ParentStatement>(SASS_MEMORY_COPY(this->parent()));
     new_rule->block(bb);
     new_rule->tabs(this->parent()->tabs());
     new_rule->block()->concat(m->block());
 
     Block_Obj wrapper_block = SASS_MEMORY_NEW(Block, m->block() ? m->block()->pstate() : m->pstate());
     wrapper_block->append(new_rule);
-    Directive_Obj mm = SASS_MEMORY_NEW(Directive,
+    AtRuleObj mm = SASS_MEMORY_NEW(AtRule,
                                   m->pstate(),
                                   m->keyword(),
                                   m->selector(),
                                   wrapper_block);
     if (m->value()) mm->value(m->value());
 
-    Bubble_Ptr bubble = SASS_MEMORY_NEW(Bubble, mm->pstate(), mm);
+    Bubble* bubble = SASS_MEMORY_NEW(Bubble, mm->pstate(), mm);
     return bubble;
   }
 
-  Statement_Ptr Cssize::bubble(At_Root_Block_Ptr m)
+  Statement* Cssize::bubble(AtRootRule* m)
   {
     if (!m || !m->block()) return NULL;
-    Block_Ptr bb = SASS_MEMORY_NEW(Block, this->parent()->pstate());
-    Has_Block_Obj new_rule = Cast<Has_Block>(SASS_MEMORY_COPY(this->parent()));
-    Block_Ptr wrapper_block = SASS_MEMORY_NEW(Block, m->block()->pstate());
+    Block* bb = SASS_MEMORY_NEW(Block, this->parent()->pstate());
+    ParentStatementObj new_rule = Cast<ParentStatement>(SASS_MEMORY_COPY(this->parent()));
+    Block* wrapper_block = SASS_MEMORY_NEW(Block, m->block()->pstate());
     if (new_rule) {
       new_rule->block(bb);
       new_rule->tabs(this->parent()->tabs());
@@ -316,74 +321,74 @@ namespace Sass {
       wrapper_block->append(new_rule);
     }
 
-    At_Root_Block_Ptr mm = SASS_MEMORY_NEW(At_Root_Block,
+    AtRootRule* mm = SASS_MEMORY_NEW(AtRootRule,
                                         m->pstate(),
                                         wrapper_block,
                                         m->expression());
-    Bubble_Ptr bubble = SASS_MEMORY_NEW(Bubble, mm->pstate(), mm);
+    Bubble* bubble = SASS_MEMORY_NEW(Bubble, mm->pstate(), mm);
     return bubble;
   }
 
-  Statement_Ptr Cssize::bubble(Supports_Block_Ptr m)
+  Statement* Cssize::bubble(SupportsRule* m)
   {
-    Ruleset_Obj parent = Cast<Ruleset>(SASS_MEMORY_COPY(this->parent()));
+    StyleRuleObj parent = Cast<StyleRule>(SASS_MEMORY_COPY(this->parent()));
 
-    Block_Ptr bb = SASS_MEMORY_NEW(Block, parent->block()->pstate());
-    Ruleset_Ptr new_rule = SASS_MEMORY_NEW(Ruleset,
+    Block* bb = SASS_MEMORY_NEW(Block, parent->block()->pstate());
+    StyleRule* new_rule = SASS_MEMORY_NEW(StyleRule,
                                         parent->pstate(),
                                         parent->selector(),
                                         bb);
     new_rule->tabs(parent->tabs());
     new_rule->block()->concat(m->block());
 
-    Block_Ptr wrapper_block = SASS_MEMORY_NEW(Block, m->block()->pstate());
+    Block* wrapper_block = SASS_MEMORY_NEW(Block, m->block()->pstate());
     wrapper_block->append(new_rule);
-    Supports_Block_Ptr mm = SASS_MEMORY_NEW(Supports_Block,
+    SupportsRule* mm = SASS_MEMORY_NEW(SupportsRule,
                                        m->pstate(),
                                        m->condition(),
                                        wrapper_block);
 
     mm->tabs(m->tabs());
 
-    Bubble_Ptr bubble = SASS_MEMORY_NEW(Bubble, mm->pstate(), mm);
+    Bubble* bubble = SASS_MEMORY_NEW(Bubble, mm->pstate(), mm);
     return bubble;
   }
 
-  Statement_Ptr Cssize::bubble(Media_Block_Ptr m)
+  Statement* Cssize::bubble(CssMediaRule* m)
   {
-    Ruleset_Obj parent = Cast<Ruleset>(SASS_MEMORY_COPY(this->parent()));
+    StyleRuleObj parent = Cast<StyleRule>(SASS_MEMORY_COPY(this->parent()));
 
-    Block_Ptr bb = SASS_MEMORY_NEW(Block, parent->block()->pstate());
-    Ruleset_Ptr new_rule = SASS_MEMORY_NEW(Ruleset,
-                                        parent->pstate(),
-                                        parent->selector(),
-                                        bb);
+    Block* bb = SASS_MEMORY_NEW(Block, parent->block()->pstate());
+    StyleRule* new_rule = SASS_MEMORY_NEW(StyleRule,
+      parent->pstate(),
+      parent->selector(),
+      bb);
     new_rule->tabs(parent->tabs());
     new_rule->block()->concat(m->block());
 
-    Block_Ptr wrapper_block = SASS_MEMORY_NEW(Block, m->block()->pstate());
+    Block* wrapper_block = SASS_MEMORY_NEW(Block, m->block()->pstate());
     wrapper_block->append(new_rule);
-    Media_Block_Obj mm = SASS_MEMORY_NEW(Media_Block,
-                                      m->pstate(),
-                                      m->media_queries(),
-                                      wrapper_block);
+    CssMediaRuleObj mm = SASS_MEMORY_NEW(CssMediaRule,
+      m->pstate(),
+      wrapper_block);
+    mm->concat(m->elements());
 
     mm->tabs(m->tabs());
 
     return SASS_MEMORY_NEW(Bubble, mm->pstate(), mm);
   }
 
-  bool Cssize::bubblable(Statement_Ptr s)
+  bool Cssize::bubblable(Statement* s)
   {
-    return Cast<Ruleset>(s) || s->bubbles();
+    return Cast<StyleRule>(s) || (s && s->bubbles());
   }
 
-  Block_Ptr Cssize::flatten(Block_Ptr b)
+  Block* Cssize::flatten(const Block* b)
   {
-    Block_Ptr result = SASS_MEMORY_NEW(Block, b->pstate(), 0, b->is_root());
+    Block* result = SASS_MEMORY_NEW(Block, b->pstate(), 0, b->is_root());
     for (size_t i = 0, L = b->length(); i < L; ++i) {
-      Statement_Ptr ss = b->at(i);
-      if (Block_Ptr bb = Cast<Block>(ss)) {
+      Statement* ss = b->at(i);
+      if (const Block* bb = Cast<Block>(ss)) {
         Block_Obj bs = flatten(bb);
         for (size_t j = 0, K = bs->length(); j < K; ++j) {
           result->append(bs->at(j));
@@ -396,9 +401,9 @@ namespace Sass {
     return result;
   }
 
-  std::vector<std::pair<bool, Block_Obj>> Cssize::slice_by_bubble(Block_Ptr b)
+  sass::vector<std::pair<bool, Block_Obj>> Cssize::slice_by_bubble(Block* b)
   {
-    std::vector<std::pair<bool, Block_Obj>> results;
+    sass::vector<std::pair<bool, Block_Obj>> results;
 
     for (size_t i = 0, L = b->length(); i < L; ++i) {
       Statement_Obj value = b->at(i);
@@ -411,7 +416,7 @@ namespace Sass {
       }
       else
       {
-        Block_Ptr wrapper_block = SASS_MEMORY_NEW(Block, value->pstate());
+        Block* wrapper_block = SASS_MEMORY_NEW(Block, value->pstate());
         wrapper_block->append(value);
         results.push_back(std::make_pair(key, wrapper_block));
       }
@@ -419,10 +424,10 @@ namespace Sass {
     return results;
   }
 
-  Block_Ptr Cssize::debubble(Block_Ptr children, Statement_Ptr parent)
+  Block* Cssize::debubble(Block* children, Statement* parent)
   {
-    Has_Block_Obj previous_parent = 0;
-    std::vector<std::pair<bool, Block_Obj>> baz = slice_by_bubble(children);
+    ParentStatementObj previous_parent;
+    sass::vector<std::pair<bool, Block_Obj>> baz = slice_by_bubble(children);
     Block_Obj result = SASS_MEMORY_NEW(Block, children->pstate());
 
     for (size_t i = 0, L = baz.size(); i < L; ++i) {
@@ -437,7 +442,7 @@ namespace Sass {
           previous_parent->block()->concat(slice);
         }
         else {
-          previous_parent = Cast<Has_Block>(SASS_MEMORY_COPY(parent));
+          previous_parent = SASS_MEMORY_COPY(parent);
           previous_parent->block(slice);
           previous_parent->tabs(parent->tabs());
 
@@ -448,36 +453,24 @@ namespace Sass {
 
       for (size_t j = 0, K = slice->length(); j < K; ++j)
       {
-        Statement_Ptr ss;
+        Statement_Obj ss;
         Statement_Obj stm = slice->at(j);
         // this has to go now here (too bad)
         Bubble_Obj node = Cast<Bubble>(stm);
-        Media_Block_Ptr m1 = NULL;
-        Media_Block_Ptr m2 = NULL;
-        if (parent) m1 = Cast<Media_Block>(parent);
-        if (node) m2 = Cast<Media_Block>(node->node());
-        if (!parent ||
-            parent->statement_type() != Statement::MEDIA ||
-            node->node()->statement_type() != Statement::MEDIA ||
-            (m1 && m2 && *m1->media_queries() == *m2->media_queries())
-          )
-        {
-          ss = node->node();
-        }
-        else
-        {
-          List_Obj mq = merge_media_queries(
-            Cast<Media_Block>(node->node()),
-            Cast<Media_Block>(parent)
-          );
-          if (!mq->length()) continue;
-          if (Media_Block* b = Cast<Media_Block>(node->node())) {
-            b->media_queries(mq);
-          }
+
+        CssMediaRule* rule1 = NULL;
+        CssMediaRule* rule2 = NULL;
+        if (parent) rule1 = Cast<CssMediaRule>(parent);
+        if (node) rule2 = Cast<CssMediaRule>(node->node());
+        if (rule1 || rule2) {
           ss = node->node();
         }
 
-        if (!ss) continue;
+        ss = node->node();
+
+        if (!ss) {
+          continue;
+        }
 
         ss->tabs(ss->tabs() + node->tabs());
         ss->group_end(node->group_end());
@@ -486,18 +479,19 @@ namespace Sass {
                                     children->pstate(),
                                     children->length(),
                                     children->is_root());
-        bb->append(ss->perform(this));
+        auto evaled = ss->perform(this);
+        if (evaled) bb->append(evaled);
 
         Block_Obj wrapper_block = SASS_MEMORY_NEW(Block,
                                               children->pstate(),
                                               children->length(),
                                               children->is_root());
 
-        Block_Ptr wrapper = flatten(bb);
+        Block* wrapper = flatten(bb);
         wrapper_block->append(wrapper);
 
         if (wrapper->length()) {
-          previous_parent = NULL;
+          previous_parent = {};
         }
 
         if (wrapper_block) {
@@ -509,16 +503,11 @@ namespace Sass {
     return flatten(result);
   }
 
-  Statement_Ptr Cssize::fallback_impl(AST_Node_Ptr n)
-  {
-    return static_cast<Statement_Ptr>(n);
-  }
-
-  void Cssize::append_block(Block_Ptr b, Block_Ptr cur)
+  void Cssize::append_block(Block* b, Block* cur)
   {
     for (size_t i = 0, L = b->length(); i < L; ++i) {
       Statement_Obj ith = b->at(i)->perform(this);
-      if (Block_Ptr bb = Cast<Block>(ith)) {
+      if (Block_Obj bb = Cast<Block>(ith)) {
         for (size_t j = 0, K = bb->length(); j < K; ++j) {
           cur->append(bb->at(j));
         }
@@ -529,78 +518,4 @@ namespace Sass {
     }
   }
 
-  List_Ptr Cssize::merge_media_queries(Media_Block_Ptr m1, Media_Block_Ptr m2)
-  {
-    List_Ptr qq = SASS_MEMORY_NEW(List,
-                               m1->media_queries()->pstate(),
-                               m1->media_queries()->length(),
-                               SASS_COMMA);
-
-    for (size_t i = 0, L = m1->media_queries()->length(); i < L; i++) {
-      for (size_t j = 0, K = m2->media_queries()->length(); j < K; j++) {
-        Expression_Obj l1 = m1->media_queries()->at(i);
-        Expression_Obj l2 = m2->media_queries()->at(j);
-        Media_Query_Ptr mq1 = Cast<Media_Query>(l1);
-        Media_Query_Ptr mq2 = Cast<Media_Query>(l2);
-        Media_Query_Ptr mq = merge_media_query(mq1, mq2);
-        if (mq) qq->append(mq);
-      }
-    }
-
-    return qq;
-  }
-
-
-  Media_Query_Ptr Cssize::merge_media_query(Media_Query_Ptr mq1, Media_Query_Ptr mq2)
-  {
-
-    std::string type;
-    std::string mod;
-
-    std::string m1 = std::string(mq1->is_restricted() ? "only" : mq1->is_negated() ? "not" : "");
-    std::string t1 = mq1->media_type() ? mq1->media_type()->to_string(ctx.c_options) : "";
-    std::string m2 = std::string(mq2->is_restricted() ? "only" : mq1->is_negated() ? "not" : "");
-    std::string t2 = mq2->media_type() ? mq2->media_type()->to_string(ctx.c_options) : "";
-
-
-    if (t1.empty()) t1 = t2;
-    if (t2.empty()) t2 = t1;
-
-    if ((m1 == "not") ^ (m2 == "not")) {
-      if (t1 == t2) {
-        return 0;
-      }
-      type = m1 == "not" ? t2 : t1;
-      mod = m1 == "not" ? m2 : m1;
-    }
-    else if (m1 == "not" && m2 == "not") {
-      if (t1 != t2) {
-        return 0;
-      }
-      type = t1;
-      mod = "not";
-    }
-    else if (t1 != t2) {
-      return 0;
-    } else {
-      type = t1;
-      mod = m1.empty() ? m2 : m1;
-    }
-
-    Media_Query_Ptr mm = SASS_MEMORY_NEW(Media_Query,
-                                         mq1->pstate(),
-                                         0,
-                                         mq1->length() + mq2->length(),
-                                         mod == "not",
-                                         mod == "only");
-
-    if (!type.empty()) {
-      mm->media_type(SASS_MEMORY_NEW(String_Quoted, mq1->pstate(), type));
-    }
-
-    mm->concat(mq2);
-    mm->concat(mq1);
-
-    return mm;
-  }
 }