sassc 1.11.1 → 1.11.2

data/ext/libsass/src/eval.hpp

@@ -12,10 +12,10 @@ namespace Sass {
   class Expand;
   class Context;
 
-  class Eval : public Operation_CRTP<Expression*, Eval> {
+  class Eval : public Operation_CRTP<Expression_Ptr, Eval> {
 
    private:
-    Expression* fallback_impl(AST_Node* n);
+    Expression_Ptr fallback_impl(AST_Node_Ptr n);
 
    public:
     Expand&  exp;
@@ -27,83 +27,82 @@ namespace Sass {
     bool is_in_comment;
 
     Env* environment();
-    Context& context();
-    CommaSequence_Selector* selector();
     Backtrace* backtrace();
+    Selector_List_Obj selector();
 
     // for evaluating function bodies
-    Expression* operator()(Block*);
-    Expression* operator()(Assignment*);
-    Expression* operator()(If*);
-    Expression* operator()(For*);
-    Expression* operator()(Each*);
-    Expression* operator()(While*);
-    Expression* operator()(Return*);
-    Expression* operator()(Warning*);
-    Expression* operator()(Error*);
-    Expression* operator()(Debug*);
-
-    Expression* operator()(List*);
-    Expression* operator()(Map*);
-    Expression* operator()(Binary_Expression*);
-    Expression* operator()(Unary_Expression*);
-    Expression* operator()(Function_Call*);
-    Expression* operator()(Function_Call_Schema*);
-    Expression* operator()(Variable*);
-    Expression* operator()(Textual*);
-    Expression* operator()(Number*);
-    Expression* operator()(Color*);
-    Expression* operator()(Boolean*);
-    Expression* operator()(String_Schema*);
-    Expression* operator()(String_Quoted*);
-    Expression* operator()(String_Constant*);
-    // Expression* operator()(CommaSequence_Selector*);
-    Expression* operator()(Media_Query*);
-    Expression* operator()(Media_Query_Expression*);
-    Expression* operator()(At_Root_Query*);
-    Expression* operator()(Supports_Operator*);
-    Expression* operator()(Supports_Negation*);
-    Expression* operator()(Supports_Declaration*);
-    Expression* operator()(Supports_Interpolation*);
-    Expression* operator()(Null*);
-    Expression* operator()(Argument*);
-    Expression* operator()(Arguments*);
-    Expression* operator()(Comment*);
+    Expression_Ptr operator()(Block_Ptr);
+    Expression_Ptr operator()(Assignment_Ptr);
+    Expression_Ptr operator()(If_Ptr);
+    Expression_Ptr operator()(For_Ptr);
+    Expression_Ptr operator()(Each_Ptr);
+    Expression_Ptr operator()(While_Ptr);
+    Expression_Ptr operator()(Return_Ptr);
+    Expression_Ptr operator()(Warning_Ptr);
+    Expression_Ptr operator()(Error_Ptr);
+    Expression_Ptr operator()(Debug_Ptr);
+
+    Expression_Ptr operator()(List_Ptr);
+    Expression_Ptr operator()(Map_Ptr);
+    Expression_Ptr operator()(Binary_Expression_Ptr);
+    Expression_Ptr operator()(Unary_Expression_Ptr);
+    Expression_Ptr operator()(Function_Call_Ptr);
+    Expression_Ptr operator()(Function_Call_Schema_Ptr);
+    Expression_Ptr operator()(Variable_Ptr);
+    Expression_Ptr operator()(Textual_Ptr);
+    Expression_Ptr operator()(Number_Ptr);
+    Expression_Ptr operator()(Color_Ptr);
+    Expression_Ptr operator()(Boolean_Ptr);
+    Expression_Ptr operator()(String_Schema_Ptr);
+    Expression_Ptr operator()(String_Quoted_Ptr);
+    Expression_Ptr operator()(String_Constant_Ptr);
+    // Expression_Ptr operator()(Selector_List_Ptr);
+    Expression_Ptr operator()(Media_Query_Ptr);
+    Expression_Ptr operator()(Media_Query_Expression_Ptr);
+    Expression_Ptr operator()(At_Root_Query_Ptr);
+    Expression_Ptr operator()(Supports_Operator_Ptr);
+    Expression_Ptr operator()(Supports_Negation_Ptr);
+    Expression_Ptr operator()(Supports_Declaration_Ptr);
+    Expression_Ptr operator()(Supports_Interpolation_Ptr);
+    Expression_Ptr operator()(Null_Ptr);
+    Expression_Ptr operator()(Argument_Ptr);
+    Expression_Ptr operator()(Arguments_Ptr);
+    Expression_Ptr operator()(Comment_Ptr);
 
     // these will return selectors
-    CommaSequence_Selector* operator()(CommaSequence_Selector*);
-    CommaSequence_Selector* operator()(Sequence_Selector*);
-    Attribute_Selector* operator()(Attribute_Selector*);
+    Selector_List_Ptr operator()(Selector_List_Ptr);
+    Selector_List_Ptr operator()(Complex_Selector_Ptr);
+    Attribute_Selector_Ptr operator()(Attribute_Selector_Ptr);
     // they don't have any specific implementatio (yet)
-    Element_Selector* operator()(Element_Selector* s) { return s; };
-    Pseudo_Selector* operator()(Pseudo_Selector* s) { return s; };
-    Wrapped_Selector* operator()(Wrapped_Selector* s) { return s; };
-    Class_Selector* operator()(Class_Selector* s) { return s; };
-    Id_Selector* operator()(Id_Selector* s) { return s; };
-    Placeholder_Selector* operator()(Placeholder_Selector* s) { return s; };
+    Element_Selector_Ptr operator()(Element_Selector_Ptr s) { return s; };
+    Pseudo_Selector_Ptr operator()(Pseudo_Selector_Ptr s) { return s; };
+    Wrapped_Selector_Ptr operator()(Wrapped_Selector_Ptr s) { return s; };
+    Class_Selector_Ptr operator()(Class_Selector_Ptr s) { return s; };
+    Id_Selector_Ptr operator()(Id_Selector_Ptr s) { return s; };
+    Placeholder_Selector_Ptr operator()(Placeholder_Selector_Ptr s) { return s; };
     // actual evaluated selectors
-    CommaSequence_Selector* operator()(Selector_Schema*);
-    Expression* operator()(Parent_Selector*);
+    Selector_List_Ptr operator()(Selector_Schema_Ptr);
+    Expression_Ptr operator()(Parent_Selector_Ptr);
 
     template <typename U>
-    Expression* fallback(U x) { return fallback_impl(x); }
+    Expression_Ptr fallback(U x) { return fallback_impl(x); }
 
     // -- only need to define two comparisons, and the rest can be implemented in terms of them
-    static bool eq(Expression*, Expression*);
-    static bool lt(Expression*, Expression*, std::string op);
+    static bool eq(Expression_Obj, Expression_Obj);
+    static bool lt(Expression_Obj, Expression_Obj, std::string op);
     // -- arithmetic on the combinations that matter
-    static Value* op_numbers(Memory_Manager&, enum Sass_OP, const Number&, const Number&, struct Sass_Inspect_Options opt, ParserState* pstate = 0);
-    static Value* op_number_color(Memory_Manager&, enum Sass_OP, const Number&, const Color&, struct Sass_Inspect_Options opt, ParserState* pstate = 0);
-    static Value* op_color_number(Memory_Manager&, enum Sass_OP, const Color&, const Number&, struct Sass_Inspect_Options opt, ParserState* pstate = 0);
-    static Value* op_colors(Memory_Manager&, enum Sass_OP, const Color&, const Color&, struct Sass_Inspect_Options opt, ParserState* pstate = 0);
-    static Value* op_strings(Memory_Manager&, Sass::Operand, Value&, Value&, struct Sass_Inspect_Options opt, ParserState* pstate = 0, bool interpolant = false);
+    static Value_Ptr op_numbers(enum Sass_OP, const Number&, const Number&, struct Sass_Inspect_Options opt, ParserState* pstate = 0);
+    static Value_Ptr op_number_color(enum Sass_OP, const Number&, const Color&, struct Sass_Inspect_Options opt, ParserState* pstate = 0);
+    static Value_Ptr op_color_number(enum Sass_OP, const Color&, const Number&, struct Sass_Inspect_Options opt, ParserState* pstate = 0);
+    static Value_Ptr op_colors(enum Sass_OP, const Color&, const Color&, struct Sass_Inspect_Options opt, ParserState* pstate = 0);
+    static Value_Ptr op_strings(Sass::Operand, Value&, Value&, struct Sass_Inspect_Options opt, ParserState* pstate = 0, bool interpolant = false);
 
   private:
-    void interpolation(Context& ctx, std::string& res, Expression* ex, bool into_quotes, bool was_itpl = false);
+    void interpolation(Context& ctx, std::string& res, Expression_Obj ex, bool into_quotes, bool was_itpl = false);
 
   };
 
-  Expression* cval_to_astnode(Memory_Manager& mem, union Sass_Value* v, Context& ctx, Backtrace* backtrace, ParserState pstate = ParserState("[AST]"));
+  Expression_Ptr cval_to_astnode(union Sass_Value* v, Backtrace* backtrace, ParserState pstate = ParserState("[AST]"));
 
 }
 

data/ext/libsass/src/expand.cpp

@@ -2,6 +2,7 @@
 #include <iostream>
 #include <typeinfo>
 
+#include "ast.hpp"
 #include "expand.hpp"
 #include "bind.hpp"
 #include "eval.hpp"
@@ -12,29 +13,26 @@
 namespace Sass {
 
   // simple endless recursion protection
-  const unsigned int maxRecursion = 500;
-  static unsigned int recursions = 0;
+  const size_t maxRecursion = 500;
 
-  Expand::Expand(Context& ctx, Env* env, Backtrace* bt, std::vector<CommaSequence_Selector*>* stack)
+  Expand::Expand(Context& ctx, Env* env, Backtrace* bt, std::vector<Selector_List_Obj>* stack)
   : ctx(ctx),
     eval(Eval(*this)),
-    env_stack(std::vector<Env*>()),
-    block_stack(std::vector<Block*>()),
-    call_stack(std::vector<AST_Node*>()),
-    property_stack(std::vector<String*>()),
-    selector_stack(std::vector<CommaSequence_Selector*>()),
-    media_block_stack(std::vector<Media_Block*>()),
-    backtrace_stack(std::vector<Backtrace*>()),
+    recursions(0),
     in_keyframes(false),
     at_root_without_rule(false),
-    old_at_root_without_rule(false)
+    old_at_root_without_rule(false),
+    env_stack(std::vector<Env*>()),
+    block_stack(std::vector<Block_Ptr>()),
+    call_stack(std::vector<AST_Node_Obj>()),
+    selector_stack(std::vector<Selector_List_Obj>()),
+    media_block_stack(std::vector<Media_Block_Ptr>()),
+    backtrace_stack(std::vector<Backtrace*>())
   {
     env_stack.push_back(0);
     env_stack.push_back(env);
     block_stack.push_back(0);
     call_stack.push_back(0);
-    // import_stack.push_back(0);
-    property_stack.push_back(0);
     if (stack == NULL) { selector_stack.push_back(0); }
     else { selector_stack.insert(selector_stack.end(), stack->begin(), stack->end()); }
     media_block_stack.push_back(0);
@@ -54,7 +52,7 @@ namespace Sass {
     return 0;
   }
 
-  CommaSequence_Selector* Expand::selector()
+  Selector_List_Obj Expand::selector()
   {
     if (selector_stack.size() > 0)
       return selector_stack.back();
@@ -69,40 +67,42 @@ namespace Sass {
   }
 
   // blocks create new variable scopes
-  Statement* Expand::operator()(Block* b)
+  Block_Ptr Expand::operator()(Block_Ptr b)
   {
     // create new local environment
     // set the current env as parent
     Env env(environment());
     // copy the block object (add items later)
-    Block* bb = SASS_MEMORY_NEW(ctx.mem, Block,
+    Block_Obj bb = SASS_MEMORY_NEW(Block,
                                 b->pstate(),
                                 b->length(),
                                 b->is_root());
     // setup block and env stack
-    this->block_stack.push_back(bb);
+    this->block_stack.push_back(&bb);
     this->env_stack.push_back(&env);
     // operate on block
+    // this may throw up!
     this->append_block(b);
     // revert block and env stack
     this->block_stack.pop_back();
     this->env_stack.pop_back();
     // return copy
-    return bb;
+    return bb.detach();
   }
 
-  Statement* Expand::operator()(Ruleset* r)
+  Statement_Ptr Expand::operator()(Ruleset_Ptr r)
   {
     LOCAL_FLAG(old_at_root_without_rule, at_root_without_rule);
 
     if (in_keyframes) {
-      Keyframe_Rule* k = SASS_MEMORY_NEW(ctx.mem, Keyframe_Rule, r->pstate(), r->block()->perform(this)->block());
+      Block_Ptr bb = operator()(&r->block());
+      Keyframe_Rule_Obj k = SASS_MEMORY_NEW(Keyframe_Rule, r->pstate(), bb);
       if (r->selector()) {
         selector_stack.push_back(0);
-        k->selector(static_cast<CommaSequence_Selector*>(r->selector()->perform(&eval)));
+        k->name(SASS_MEMORY_CAST_PTR(Selector_List, r->selector()->perform(&eval)));
         selector_stack.pop_back();
       }
-      return k;
+      return k.detach();
     }
 
     // reset when leaving scope
@@ -110,46 +110,48 @@ namespace Sass {
 
     // do some special checks for the base level rules
     if (r->is_root()) {
-      if (CommaSequence_Selector* selector_list = dynamic_cast<CommaSequence_Selector*>(r->selector())) {
-        for (Sequence_Selector* complex_selector : selector_list->elements()) {
-          Sequence_Selector* tail = complex_selector;
+      if (Selector_List_Ptr selector_list = SASS_MEMORY_CAST(Selector_List, r->selector())) {
+        for (Complex_Selector_Obj complex_selector : selector_list->elements()) {
+          Complex_Selector_Ptr tail = &complex_selector;
           while (tail) {
-            if (tail->head()) for (Simple_Selector* header : tail->head()->elements()) {
-              if (dynamic_cast<Parent_Selector*>(header) == NULL) continue; // skip all others
+            if (tail->head()) for (Simple_Selector_Obj header : tail->head()->elements()) {
+              if (SASS_MEMORY_CAST(Parent_Selector, header) == NULL) continue; // skip all others
               std::string sel_str(complex_selector->to_string(ctx.c_options));
               error("Base-level rules cannot contain the parent-selector-referencing character '&'.", header->pstate(), backtrace());
             }
-            tail = tail->tail();
+            tail = &tail->tail();
           }
         }
       }
     }
 
-    Expression* ex = r->selector()->perform(&eval);
-    CommaSequence_Selector* sel = dynamic_cast<CommaSequence_Selector*>(ex);
+    Expression_Obj ex = 0;
+    if (r->selector()) ex = r->selector()->perform(&eval);
+    Selector_List_Obj sel = SASS_MEMORY_CAST(Selector_List, ex);
     if (sel == 0) throw std::runtime_error("Expanded null selector");
 
     if (sel->length() == 0 || sel->has_parent_ref()) {
       bool has_parent_selector = false;
       for (size_t i = 0, L = selector_stack.size(); i < L && !has_parent_selector; i++) {
-        CommaSequence_Selector* ll = selector_stack.at(i);
+        Selector_List_Obj ll = selector_stack.at(i);
         has_parent_selector = ll != 0 && ll->length() > 0;
       }
-      if (!has_parent_selector) {
+      if (sel->has_real_parent_ref() && !has_parent_selector) {
         error("Base-level rules cannot contain the parent-selector-referencing character '&'.", sel->pstate(), backtrace());
       }
     }
 
-    selector_stack.push_back(sel);
+    selector_stack.push_back(&sel);
     Env env(environment());
     if (block_stack.back()->is_root()) {
       env_stack.push_back(&env);
     }
     sel->set_media_block(media_block_stack.back());
-    Block* blk = r->block()->perform(this)->block();
-    Ruleset* rr = SASS_MEMORY_NEW(ctx.mem, Ruleset,
+    Block_Obj blk = 0;
+    if (r->block()) blk = operator()(&r->block());
+    Ruleset_Ptr rr = SASS_MEMORY_NEW(Ruleset,
                                   r->pstate(),
-                                  sel,
+                                  &sel,
                                   blk);
     selector_stack.pop_back();
     if (block_stack.back()->is_root()) {
@@ -162,66 +164,70 @@ namespace Sass {
     return rr;
   }
 
-  Statement* Expand::operator()(Supports_Block* f)
+  Statement_Ptr Expand::operator()(Supports_Block_Ptr f)
   {
-    Expression* condition = f->condition()->perform(&eval);
-    Supports_Block* ff = SASS_MEMORY_NEW(ctx.mem, Supports_Block,
+    Expression_Obj condition = f->condition()->perform(&eval);
+    Supports_Block_Obj ff = SASS_MEMORY_NEW(Supports_Block,
                                        f->pstate(),
-                                       static_cast<Supports_Condition*>(condition),
-                                       f->block()->perform(this)->block());
-    return ff;
+                                       SASS_MEMORY_CAST(Supports_Condition, condition),
+                                       operator()(&f->block()));
+    return ff.detach();
   }
 
-  Statement* Expand::operator()(Media_Block* m)
+  Statement_Ptr Expand::operator()(Media_Block_Ptr m)
   {
     media_block_stack.push_back(m);
-    Expression* mq = m->media_queries()->perform(&eval);
+    Expression_Obj mq = m->media_queries()->perform(&eval);
     std::string str_mq(mq->to_string(ctx.c_options));
     char* str = sass_copy_c_string(str_mq.c_str());
     ctx.strings.push_back(str);
     Parser p(Parser::from_c_str(str, ctx, mq->pstate()));
-    mq = p.parse_media_queries();
-    Media_Block* mm = SASS_MEMORY_NEW(ctx.mem, Media_Block,
+    mq = &p.parse_media_queries(); // re-assign now
+    List_Obj ls = SASS_MEMORY_CAST_PTR(List, mq->perform(&eval));
+    Block_Obj blk = operator()(&m->block());
+    Media_Block_Ptr mm = SASS_MEMORY_NEW(Media_Block,
                                       m->pstate(),
-                                      static_cast<List*>(mq->perform(&eval)),
-                                      m->block()->perform(this)->block(),
+                                      ls,
+                                      blk,
                                       0);
     media_block_stack.pop_back();
     mm->tabs(m->tabs());
     return mm;
   }
 
-  Statement* Expand::operator()(At_Root_Block* a)
+  Statement_Ptr Expand::operator()(At_Root_Block_Ptr a)
   {
-    Block* ab = a->block();
-    Expression* ae = a->expression();
+    Block_Obj ab = a->block();
+    Expression_Obj ae = &a->expression();
 
     if (ae) ae = ae->perform(&eval);
-    else ae = SASS_MEMORY_NEW(ctx.mem, At_Root_Query, a->pstate());
+    else ae = SASS_MEMORY_NEW(At_Root_Query, a->pstate());
 
     LOCAL_FLAG(at_root_without_rule, true);
     LOCAL_FLAG(in_keyframes, false);
 
-    Block* bb = ab ? ab->perform(this)->block() : 0;
-    At_Root_Block* aa = SASS_MEMORY_NEW(ctx.mem, At_Root_Block,
+                                       ;
+
+    Block_Obj bb = ab ? operator()(&ab) : NULL;
+    At_Root_Block_Obj aa = SASS_MEMORY_NEW(At_Root_Block,
                                         a->pstate(),
                                         bb,
-                                        static_cast<At_Root_Query*>(ae));
-    return aa;
+                                        SASS_MEMORY_CAST(At_Root_Query, ae));
+    return aa.detach();
   }
 
-  Statement* Expand::operator()(Directive* a)
+  Statement_Ptr Expand::operator()(Directive_Ptr a)
   {
     LOCAL_FLAG(in_keyframes, a->is_keyframes());
-    Block* ab = a->block();
-    Selector* as = a->selector();
-    Expression* av = a->value();
+    Block_Ptr ab = &a->block();
+    Selector_Ptr as = &a->selector();
+    Expression_Ptr av = &a->value();
     selector_stack.push_back(0);
     if (av) av = av->perform(&eval);
-    if (as) as = dynamic_cast<Selector*>(as->perform(&eval));
+    if (as) as = SASS_MEMORY_CAST_PTR(Selector, as->perform(&eval));
     selector_stack.pop_back();
-    Block* bb = ab ? ab->perform(this)->block() : 0;
-    Directive* aa = SASS_MEMORY_NEW(ctx.mem, Directive,
+    Block_Ptr bb = ab ? operator()(ab) : NULL;
+    Directive_Ptr aa = SASS_MEMORY_NEW(Directive,
                                   a->pstate(),
                                   a->keyword(),
                                   as,
@@ -230,17 +236,23 @@ namespace Sass {
     return aa;
   }
 
-  Statement* Expand::operator()(Declaration* d)
+  Statement_Ptr Expand::operator()(Declaration_Ptr d)
   {
-    Block* ab = d->block();
-    String* old_p = d->property();
-    String* new_p = static_cast<String*>(old_p->perform(&eval));
-    Expression* value = d->value()->perform(&eval);
-    Block* bb = ab ? ab->perform(this)->block() : 0;
+    Block_Obj ab = d->block();
+    String_Obj old_p = d->property();
+    Expression_Obj prop = old_p->perform(&eval);
+    String_Obj new_p = SASS_MEMORY_CAST(String, prop);
+    // we might get a color back
+    if (!new_p) {
+      std::string str(prop->to_string(ctx.c_options));
+      new_p = SASS_MEMORY_NEW(String_Constant, old_p->pstate(), str);
+    }
+    Expression_Obj value = d->value()->perform(&eval);
+    Block_Obj bb = ab ? operator()(&ab) : NULL;
     if (!bb) {
       if (!value || (value->is_invisible() && !d->is_important())) return 0;
     }
-    Declaration* decl = SASS_MEMORY_NEW(ctx.mem, Declaration,
+    Declaration_Ptr decl = SASS_MEMORY_NEW(Declaration,
                                         d->pstate(),
                                         new_p,
                                         value,
@@ -250,14 +262,14 @@ namespace Sass {
     return decl;
   }
 
-  Statement* Expand::operator()(Assignment* a)
+  Statement_Ptr Expand::operator()(Assignment_Ptr a)
   {
     Env* env = environment();
     std::string var(a->variable());
     if (a->is_global()) {
       if (a->is_default()) {
         if (env->has_global(var)) {
-          Expression* e = dynamic_cast<Expression*>(env->get_global(var));
+          Expression_Obj e = SASS_MEMORY_CAST(Expression, env->get_global(var));
           if (!e || e->concrete_type() == Expression::NULL_VAL) {
             env->set_global(var, a->value()->perform(&eval));
           }
@@ -275,8 +287,8 @@ namespace Sass {
         auto cur = env;
         while (cur && cur->is_lexical()) {
           if (cur->has_local(var)) {
-            if (AST_Node* node = cur->get_local(var)) {
-              Expression* e = dynamic_cast<Expression*>(node);
+            if (AST_Node_Obj node = cur->get_local(var)) {
+              Expression_Obj e = SASS_MEMORY_CAST(Expression, node);
               if (!e || e->concrete_type() == Expression::NULL_VAL) {
                 cur->set_local(var, a->value()->perform(&eval));
               }
@@ -291,8 +303,8 @@ namespace Sass {
         throw std::runtime_error("Env not in sync");
       }
       else if (env->has_global(var)) {
-        if (AST_Node* node = env->get_global(var)) {
-          Expression* e = dynamic_cast<Expression*>(node);
+        if (AST_Node_Obj node = env->get_global(var)) {
+          Expression_Obj e = SASS_MEMORY_CAST(Expression, node);
           if (!e || e->concrete_type() == Expression::NULL_VAL) {
             env->set_global(var, a->value()->perform(&eval));
           }
@@ -311,26 +323,26 @@ namespace Sass {
     return 0;
   }
 
-  Statement* Expand::operator()(Import* imp)
+  Statement_Ptr Expand::operator()(Import_Ptr imp)
   {
-    Import* result = SASS_MEMORY_NEW(ctx.mem, Import, imp->pstate());
-    if (imp->media_queries() && imp->media_queries()->size()) {
-      Expression* ex = imp->media_queries()->perform(&eval);
-      result->media_queries(dynamic_cast<List*>(ex));
+    Import_Obj result = SASS_MEMORY_NEW(Import, imp->pstate());
+    if (imp->import_queries() && imp->import_queries()->size()) {
+      Expression_Obj ex = imp->import_queries()->perform(&eval);
+      result->import_queries(SASS_MEMORY_CAST(List, ex));
     }
     for ( size_t i = 0, S = imp->urls().size(); i < S; ++i) {
       result->urls().push_back(imp->urls()[i]->perform(&eval));
     }
     // all resources have been dropped for Input_Stubs
     // for ( size_t i = 0, S = imp->incs().size(); i < S; ++i) {}
-    return result;
+    return result.detach();
   }
 
-  Statement* Expand::operator()(Import_Stub* i)
+  Statement_Ptr Expand::operator()(Import_Stub_Ptr i)
   {
     // get parent node from call stack
-    AST_Node* parent = call_stack.back();
-    if (parent && dynamic_cast<Block*>(parent) == NULL) {
+    AST_Node_Obj parent = call_stack.back();
+    if (SASS_MEMORY_CAST(Block, parent) == NULL) {
       error("Import directives may not be used within control directives or mixins.", i->pstate());
     }
     // we don't seem to need that actually afterall
@@ -341,52 +353,53 @@ namespace Sass {
     );
     ctx.import_stack.push_back(import);
     const std::string& abs_path(i->resource().abs_path);
-    append_block(ctx.sheets.at(abs_path).root);
+    append_block(&ctx.sheets.at(abs_path).root);
     sass_delete_import(ctx.import_stack.back());
     ctx.import_stack.pop_back();
     return 0;
   }
 
-  Statement* Expand::operator()(Warning* w)
+  Statement_Ptr Expand::operator()(Warning_Ptr w)
   {
     // eval handles this too, because warnings may occur in functions
     w->perform(&eval);
     return 0;
   }
 
-  Statement* Expand::operator()(Error* e)
+  Statement_Ptr Expand::operator()(Error_Ptr e)
   {
     // eval handles this too, because errors may occur in functions
     e->perform(&eval);
     return 0;
   }
 
-  Statement* Expand::operator()(Debug* d)
+  Statement_Ptr Expand::operator()(Debug_Ptr d)
   {
     // eval handles this too, because warnings may occur in functions
     d->perform(&eval);
     return 0;
   }
 
-  Statement* Expand::operator()(Comment* c)
+  Statement_Ptr Expand::operator()(Comment_Ptr c)
   {
     eval.is_in_comment = true;
-    auto rv = SASS_MEMORY_NEW(ctx.mem, Comment, c->pstate(), static_cast<String*>(c->text()->perform(&eval)), c->is_important());
+    Comment_Ptr rv = SASS_MEMORY_NEW(Comment, c->pstate(), SASS_MEMORY_CAST_PTR(String, c->text()->perform(&eval)), c->is_important());
     eval.is_in_comment = false;
     // TODO: eval the text, once we're parsing/storing it as a String_Schema
     return rv;
   }
 
-  Statement* Expand::operator()(If* i)
+  Statement_Ptr Expand::operator()(If_Ptr i)
   {
     Env env(environment(), true);
     env_stack.push_back(&env);
     call_stack.push_back(i);
-    if (*i->predicate()->perform(&eval)) {
-      append_block(i->block());
+    Expression_Obj rv = i->predicate()->perform(&eval);
+    if (*rv) {
+      append_block(&i->block());
     }
     else {
-      Block* alt = i->alternative();
+      Block_Ptr alt = &i->alternative();
       if (alt) append_block(alt);
     }
     call_stack.pop_back();
@@ -396,19 +409,19 @@ namespace Sass {
 
   // For does not create a new env scope
   // But iteration vars are reset afterwards
-  Statement* Expand::operator()(For* f)
+  Statement_Ptr Expand::operator()(For_Ptr f)
   {
     std::string variable(f->variable());
-    Expression* low = f->lower_bound()->perform(&eval);
+    Expression_Obj low = f->lower_bound()->perform(&eval);
     if (low->concrete_type() != Expression::NUMBER) {
       throw Exception::TypeMismatch(*low, "integer");
     }
-    Expression* high = f->upper_bound()->perform(&eval);
+    Expression_Obj high = f->upper_bound()->perform(&eval);
     if (high->concrete_type() != Expression::NUMBER) {
       throw Exception::TypeMismatch(*high, "integer");
     }
-    Number* sass_start = static_cast<Number*>(low);
-    Number* sass_end = static_cast<Number*>(high);
+    Number_Obj sass_start = SASS_MEMORY_CAST(Number, low);
+    Number_Obj sass_end = SASS_MEMORY_CAST(Number, high);
     // check if units are valid for sequence
     if (sass_start->unit() != sass_end->unit()) {
       std::stringstream msg; msg << "Incompatible units: '"
@@ -422,16 +435,17 @@ namespace Sass {
     Env env(environment(), true);
     env_stack.push_back(&env);
     call_stack.push_back(f);
-    Number* it = SASS_MEMORY_NEW(env.mem, Number, low->pstate(), start, sass_end->unit());
-    env.set_local(variable, it);
-    Block* body = f->block();
+    Number_Obj it = SASS_MEMORY_NEW(Number, low->pstate(), start, sass_end->unit());
+    env.set_local(variable, &it);
+    Block_Ptr body = &f->block();
     if (start < end) {
       if (f->is_inclusive()) ++end;
       for (double i = start;
            i < end;
            ++i) {
+        it = SASS_MEMORY_COPY(it);
         it->value(i);
-        env.set_local(variable, it);
+        env.set_local(variable, &it);
         append_block(body);
       }
     } else {
@@ -439,8 +453,9 @@ namespace Sass {
       for (double i = start;
            i > end;
            --i) {
+        it = SASS_MEMORY_COPY(it);
         it->value(i);
-        env.set_local(variable, it);
+        env.set_local(variable, &it);
         append_block(body);
       }
     }
@@ -451,78 +466,79 @@ namespace Sass {
 
   // Eval does not create a new env scope
   // But iteration vars are reset afterwards
-  Statement* Expand::operator()(Each* e)
+  Statement_Ptr Expand::operator()(Each_Ptr e)
   {
     std::vector<std::string> variables(e->variables());
-    Expression* expr = e->list()->perform(&eval);
-    Vectorized<Expression*>* list = 0;
-    Map* map = 0;
+    Expression_Obj expr = e->list()->perform(&eval);
+    List_Obj list = 0;
+    Map_Obj map;
     if (expr->concrete_type() == Expression::MAP) {
-      map = static_cast<Map*>(expr);
+      map = SASS_MEMORY_CAST(Map, expr);
     }
-    else if (CommaSequence_Selector* ls = dynamic_cast<CommaSequence_Selector*>(expr)) {
-      Listize listize(ctx.mem);
-      list = dynamic_cast<List*>(ls->perform(&listize));
+    else if (Selector_List_Ptr ls = SASS_MEMORY_CAST(Selector_List, expr)) {
+      Listize listize;
+      Expression_Obj rv = ls->perform(&listize);
+      list = SASS_MEMORY_CAST(List, rv);
     }
     else if (expr->concrete_type() != Expression::LIST) {
-      list = SASS_MEMORY_NEW(ctx.mem, List, expr->pstate(), 1, SASS_COMMA);
-      *list << expr;
+      list = SASS_MEMORY_NEW(List, expr->pstate(), 1, SASS_COMMA);
+      list->append(expr);
     }
     else {
-      list = static_cast<List*>(expr);
+      list = SASS_MEMORY_CAST(List, expr);
     }
     // remember variables and then reset them
     Env env(environment(), true);
     env_stack.push_back(&env);
     call_stack.push_back(e);
-    Block* body = e->block();
+    Block_Ptr body = &e->block();
 
     if (map) {
       for (auto key : map->keys()) {
-        Expression* k = key->perform(&eval);
-        Expression* v = map->at(key)->perform(&eval);
+        Expression_Obj k = key->perform(&eval);
+        Expression_Obj v = map->at(key)->perform(&eval);
 
         if (variables.size() == 1) {
-          List* variable = SASS_MEMORY_NEW(ctx.mem, List, map->pstate(), 2, SASS_SPACE);
-          *variable << k;
-          *variable << v;
-          env.set_local(variables[0], variable);
+          List_Obj variable = SASS_MEMORY_NEW(List, map->pstate(), 2, SASS_SPACE);
+          variable->append(k);
+          variable->append(v);
+          env.set_local(variables[0], &variable);
         } else {
-          env.set_local(variables[0], k);
-          env.set_local(variables[1], v);
+          env.set_local(variables[0], &k);
+          env.set_local(variables[1], &v);
         }
         append_block(body);
       }
     }
     else {
       // bool arglist = list->is_arglist();
-      if (list->length() == 1 && dynamic_cast<CommaSequence_Selector*>(list)) {
-        list = dynamic_cast<Vectorized<Expression*>*>(list);
+      if (list->length() == 1 && SASS_MEMORY_CAST(Selector_List, list)) {
+        list = SASS_MEMORY_CAST(List, list);
       }
       for (size_t i = 0, L = list->length(); i < L; ++i) {
-        Expression* e = (*list)[i];
+        Expression_Obj e = list->at(i);
         // unwrap value if the expression is an argument
-        if (Argument* arg = dynamic_cast<Argument*>(e)) e = arg->value();
+        if (Argument_Obj arg = SASS_MEMORY_CAST(Argument, e)) e = arg->value();
         // check if we got passed a list of args (investigate)
-        if (List* scalars = dynamic_cast<List*>(e)) {
+        if (List_Obj scalars = SASS_MEMORY_CAST(List, e)) {
           if (variables.size() == 1) {
-            Expression* var = scalars;
+            List_Obj var = scalars;
             // if (arglist) var = (*scalars)[0];
-            env.set_local(variables[0], var);
+            env.set_local(variables[0], &var);
           } else {
             for (size_t j = 0, K = variables.size(); j < K; ++j) {
-              Expression* res = j >= scalars->length()
-                ? SASS_MEMORY_NEW(ctx.mem, Null, expr->pstate())
+              Expression_Obj res = j >= scalars->length()
+                ? SASS_MEMORY_NEW(Null, expr->pstate())
                 : (*scalars)[j]->perform(&eval);
-              env.set_local(variables[j], res);
+              env.set_local(variables[j], &res);
             }
           }
         } else {
           if (variables.size() > 0) {
-            env.set_local(variables[0], e);
+            env.set_local(variables.at(0), &e);
             for (size_t j = 1, K = variables.size(); j < K; ++j) {
-              Expression* res = SASS_MEMORY_NEW(ctx.mem, Null, expr->pstate());
-              env.set_local(variables[j], res);
+              Expression_Obj res = SASS_MEMORY_NEW(Null, expr->pstate());
+              env.set_local(variables[j], &res);
             }
           }
         }
@@ -534,36 +550,38 @@ namespace Sass {
     return 0;
   }
 
-  Statement* Expand::operator()(While* w)
+  Statement_Ptr Expand::operator()(While_Ptr w)
   {
-    Expression* pred = w->predicate();
-    Block* body = w->block();
+    Expression_Obj pred = w->predicate();
+    Block_Ptr body = &w->block();
     Env env(environment(), true);
     env_stack.push_back(&env);
     call_stack.push_back(w);
-    while (*pred->perform(&eval)) {
+    Expression_Obj cond = pred->perform(&eval);
+    while (*&cond) {
       append_block(body);
+      cond = pred->perform(&eval);
     }
     call_stack.pop_back();
     env_stack.pop_back();
     return 0;
   }
 
-  Statement* Expand::operator()(Return* r)
+  Statement_Ptr Expand::operator()(Return_Ptr r)
   {
     error("@return may only be used within a function", r->pstate(), backtrace());
     return 0;
   }
 
 
-  void Expand::expand_selector_list(Selector* s, CommaSequence_Selector* extender) {
+  void Expand::expand_selector_list(Selector_Obj s, Selector_List_Obj extender) {
 
-    if (CommaSequence_Selector* sl = dynamic_cast<CommaSequence_Selector*>(s)) {
-      for (Sequence_Selector* complex_selector : sl->elements()) {
-        Sequence_Selector* tail = complex_selector;
+    if (Selector_List_Obj sl = SASS_MEMORY_CAST(Selector_List, s)) {
+      for (Complex_Selector_Obj complex_selector : sl->elements()) {
+        Complex_Selector_Obj tail = complex_selector;
         while (tail) {
-          if (tail->head()) for (Simple_Selector* header : tail->head()->elements()) {
-            if (dynamic_cast<Parent_Selector*>(header) == NULL) continue; // skip all others
+          if (tail->head()) for (Simple_Selector_Obj header : tail->head()->elements()) {
+            if (SASS_MEMORY_CAST(Parent_Selector, header) == NULL) continue; // skip all others
             std::string sel_str(complex_selector->to_string(ctx.c_options));
             error("Can't extend " + sel_str + ": can't extend parent selectors", header->pstate(), backtrace());
           }
@@ -573,78 +591,78 @@ namespace Sass {
     }
 
 
-    CommaSequence_Selector* contextualized = dynamic_cast<CommaSequence_Selector*>(s->perform(&eval));
-    if (contextualized == NULL) return;
+    Selector_List_Obj contextualized = SASS_MEMORY_CAST_PTR(Selector_List, s->perform(&eval));
+    if (contextualized == false) return;
     for (auto complex_sel : contextualized->elements()) {
-      Sequence_Selector* c = complex_sel;
+      Complex_Selector_Obj c = complex_sel;
       if (!c->head() || c->tail()) {
         std::string sel_str(contextualized->to_string(ctx.c_options));
         error("Can't extend " + sel_str + ": can't extend nested selectors", c->pstate(), backtrace());
       }
-      SimpleSequence_Selector* placeholder = c->head();
+      Compound_Selector_Obj placeholder = c->head();
       if (contextualized->is_optional()) placeholder->is_optional(true);
       for (size_t i = 0, L = extender->length(); i < L; ++i) {
-        Sequence_Selector* sel = (*extender)[i];
+        Complex_Selector_Obj sel = (*extender)[i];
         if (!(sel->head() && sel->head()->length() > 0 &&
-            dynamic_cast<Parent_Selector*>((*sel->head())[0])))
+            SASS_MEMORY_CAST(Parent_Selector, (*sel->head())[0])))
         {
-          SimpleSequence_Selector* hh = SASS_MEMORY_NEW(ctx.mem, SimpleSequence_Selector, (*extender)[i]->pstate());
+          Compound_Selector_Obj hh = SASS_MEMORY_NEW(Compound_Selector, (*extender)[i]->pstate());
           hh->media_block((*extender)[i]->media_block());
-          Sequence_Selector* ssel = SASS_MEMORY_NEW(ctx.mem, Sequence_Selector, (*extender)[i]->pstate());
+          Complex_Selector_Obj ssel = SASS_MEMORY_NEW(Complex_Selector, (*extender)[i]->pstate());
           ssel->media_block((*extender)[i]->media_block());
           if (sel->has_line_feed()) ssel->has_line_feed(true);
-          Parent_Selector* ps = SASS_MEMORY_NEW(ctx.mem, Parent_Selector, (*extender)[i]->pstate());
+          Parent_Selector_Obj ps = SASS_MEMORY_NEW(Parent_Selector, (*extender)[i]->pstate());
           ps->media_block((*extender)[i]->media_block());
-          *hh << ps;
+          hh->append(&ps);
           ssel->tail(sel);
           ssel->head(hh);
           sel = ssel;
         }
         // if (c->has_line_feed()) sel->has_line_feed(true);
-        ctx.subset_map.put(placeholder->to_str_vec(), std::make_pair(sel, placeholder));
+        ctx.subset_map.put(placeholder, std::make_pair(sel, placeholder));
       }
     }
 
   }
 
-  Statement* Expand::operator()(Extension* e)
+  Statement* Expand::operator()(Extension_Ptr e)
   {
-    if (CommaSequence_Selector* extender = dynamic_cast<CommaSequence_Selector*>(selector())) {
-      Selector* s = e->selector();
-      CommaSequence_Selector* sl = NULL;
+    if (Selector_List_Obj extender = SASS_MEMORY_CAST(Selector_List, selector())) {
+      Selector_Obj s = e->selector();
+      Selector_List_Obj sl = NULL;
       // check if we already have a valid selector list
-      if ((sl = dynamic_cast<CommaSequence_Selector*>(s))) {}
+      if ((sl = SASS_MEMORY_CAST(Selector_List, s))) {}
       // convert selector schema to a selector list
-      else if (Selector_Schema* schema = dynamic_cast<Selector_Schema*>(s)) {
+      else if (Selector_Schema_Obj schema = SASS_MEMORY_CAST(Selector_Schema, s)) {
         if (schema->has_real_parent_ref()) {
-          sl = eval(schema);
+          sl = eval(&schema);
         } else {
           selector_stack.push_back(0);
-          sl = eval(schema);
+          sl = eval(&schema);
           sl->remove_parent_selectors();
           selector_stack.pop_back();
         }
       }
       // abort on invalid selector
-      if (sl == NULL) return NULL;
-      for (Sequence_Selector* cs : *sl) {
-        if (cs != NULL && cs->head() != NULL) {
+      if (sl.isNull()) return NULL;
+      for (Complex_Selector_Obj cs : sl->elements()) {
+        if (!cs.isNull() && !cs->head().isNull()) {
           cs->head()->media_block(media_block_stack.back());
         }
       }
       selector_stack.push_back(0);
-      expand_selector_list(sl, extender);
+      expand_selector_list(&sl, extender);
       selector_stack.pop_back();
     }
     return 0;
   }
 
-  Statement* Expand::operator()(Definition* d)
+  Statement_Ptr Expand::operator()(Definition_Ptr d)
   {
     Env* env = environment();
-    Definition* dd = SASS_MEMORY_NEW(ctx.mem, Definition, *d);
+    Definition_Obj dd = SASS_MEMORY_COPY(d);
     env->local_frame()[d->name() +
-                        (d->type() == Definition::MIXIN ? "[m]" : "[f]")] = dd;
+                        (d->type() == Definition::MIXIN ? "[m]" : "[f]")] = &dd;
 
     if (d->type() == Definition::FUNCTION && (
       Prelexer::calc_fn_call(d->name().c_str()) ||
@@ -659,60 +677,60 @@ namespace Sass {
       );
     }
 
-
     // set the static link so we can have lexical scoping
     dd->environment(env);
     return 0;
   }
 
-  Statement* Expand::operator()(Mixin_Call* c)
+  Statement_Ptr Expand::operator()(Mixin_Call_Ptr c)
   {
-    recursions ++;
 
     if (recursions > maxRecursion) {
       throw Exception::StackError(*c);
     }
 
+    recursions ++;
+
     Env* env = environment();
     std::string full_name(c->name() + "[m]");
     if (!env->has(full_name)) {
       error("no mixin named " + c->name(), c->pstate(), backtrace());
     }
-    Definition* def = static_cast<Definition*>((*env)[full_name]);
-    Block* body = def->block();
-    Parameters* params = def->parameters();
+    Definition_Obj def = SASS_MEMORY_CAST(Definition, (*env)[full_name]);
+    Block_Obj body = def->block();
+    Parameters_Obj params = def->parameters();
 
     if (c->block() && c->name() != "@content" && !body->has_content()) {
       error("Mixin \"" + c->name() + "\" does not accept a content block.", c->pstate(), backtrace());
     }
-    Arguments* args = static_cast<Arguments*>(c->arguments()
-                                               ->perform(&eval));
+    Expression_Obj rv = c->arguments()->perform(&eval);
+    Arguments_Obj args = SASS_MEMORY_CAST(Arguments, rv);
     Backtrace new_bt(backtrace(), c->pstate(), ", in mixin `" + c->name() + "`");
     backtrace_stack.push_back(&new_bt);
     Env new_env(def->environment());
     env_stack.push_back(&new_env);
     if (c->block()) {
       // represent mixin content blocks as thunks/closures
-      Definition* thunk = SASS_MEMORY_NEW(ctx.mem, Definition,
+      Definition_Obj thunk = SASS_MEMORY_NEW(Definition,
                                           c->pstate(),
                                           "@content",
-                                          SASS_MEMORY_NEW(ctx.mem, Parameters, c->pstate()),
+                                          SASS_MEMORY_NEW(Parameters, c->pstate()),
                                           c->block(),
                                           Definition::MIXIN);
       thunk->environment(env);
-      new_env.local_frame()["@content[m]"] = thunk;
+      new_env.local_frame()["@content[m]"] = &thunk;
     }
 
     bind(std::string("Mixin"), c->name(), params, args, &ctx, &new_env, &eval);
 
-    Block* trace_block = SASS_MEMORY_NEW(ctx.mem, Block, c->pstate());
-    Trace* trace = SASS_MEMORY_NEW(ctx.mem, Trace, c->pstate(), c->name(), trace_block);
+    Block_Obj trace_block = SASS_MEMORY_NEW(Block, c->pstate());
+    Trace_Obj trace = SASS_MEMORY_NEW(Trace, c->pstate(), c->name(), trace_block);
 
 
-    block_stack.push_back(trace_block);
-    for (auto bb : *body) {
-      Statement* ith = bb->perform(this);
-      if (ith) *trace->block() << ith;
+    block_stack.push_back(&trace_block);
+    for (auto bb : body->elements()) {
+      Statement_Obj ith = bb->perform(this);
+      if (ith) trace->block()->append(ith);
     }
     block_stack.pop_back();
 
@@ -720,10 +738,10 @@ namespace Sass {
     backtrace_stack.pop_back();
 
     recursions --;
-    return trace;
+    return trace.detach();
   }
 
-  Statement* Expand::operator()(Content* c)
+  Statement_Ptr Expand::operator()(Content_Ptr c)
   {
     Env* env = environment();
     // convert @content directives into mixin calls to the underlying thunk
@@ -733,36 +751,37 @@ namespace Sass {
       selector_stack.push_back(0);
     }
 
-    Mixin_Call* call = SASS_MEMORY_NEW(ctx.mem, Mixin_Call,
+    Mixin_Call_Obj call = SASS_MEMORY_NEW(Mixin_Call,
                                        c->pstate(),
                                        "@content",
-                                       SASS_MEMORY_NEW(ctx.mem, Arguments, c->pstate()));
+                                       SASS_MEMORY_NEW(Arguments, c->pstate()));
 
-    Trace* trace = dynamic_cast<Trace*>(call->perform(this));
+    Trace_Obj trace = SASS_MEMORY_CAST_PTR(Trace, call->perform(this));
 
     if (block_stack.back()->is_root()) {
       selector_stack.pop_back();
     }
 
-    return trace;
+    return trace.detach();
   }
 
   // produce an error if something is not implemented
-  inline Statement* Expand::fallback_impl(AST_Node* n)
+  inline Statement_Ptr Expand::fallback_impl(AST_Node_Ptr n)
   {
     std::string err =std:: string("`Expand` doesn't handle ") + typeid(*n).name();
-    String_Quoted* msg = SASS_MEMORY_NEW(ctx.mem, String_Quoted, ParserState("[WARN]"), err);
+    String_Quoted_Obj msg = SASS_MEMORY_NEW(String_Quoted, ParserState("[WARN]"), err);
     error("unknown internal error; please contact the LibSass maintainers", n->pstate(), backtrace());
-    return SASS_MEMORY_NEW(ctx.mem, Warning, ParserState("[WARN]"), msg);
+    return SASS_MEMORY_NEW(Warning, ParserState("[WARN]"), &msg);
   }
 
   // process and add to last block on stack
-  inline void Expand::append_block(Block* b)
+  inline void Expand::append_block(Block_Ptr b)
   {
     if (b->is_root()) call_stack.push_back(b);
     for (size_t i = 0, L = b->length(); i < L; ++i) {
-      Statement* ith = (*b)[i]->perform(this);
-      if (ith) *block_stack.back() << ith;
+      Statement_Ptr stm = &b->at(i);
+      Statement_Obj ith = stm->perform(this);
+      if (ith) block_stack.back()->append(ith);
     }
     if (b->is_root()) call_stack.pop_back();
   }