sassc 1.11.1 → 1.11.2

data/ext/libsass/src/ast_def_macros.hpp

@@ -28,13 +28,13 @@ class LocalOption {
 
 #define ATTACH_OPERATIONS()\
 virtual void perform(Operation<void>* op) { (*op)(this); }\
-virtual AST_Node* perform(Operation<AST_Node*>* op) { return (*op)(this); }\
-virtual Statement* perform(Operation<Statement*>* op) { return (*op)(this); }\
-virtual Expression* perform(Operation<Expression*>* op) { return (*op)(this); }\
-virtual Selector* perform(Operation<Selector*>* op) { return (*op)(this); }\
+virtual AST_Node_Ptr perform(Operation<AST_Node_Ptr>* op) { return (*op)(this); }\
+virtual Statement_Ptr perform(Operation<Statement_Ptr>* op) { return (*op)(this); }\
+virtual Expression_Ptr perform(Operation<Expression_Ptr>* op) { return (*op)(this); }\
+virtual Selector_Ptr perform(Operation<Selector_Ptr>* op) { return (*op)(this); }\
 virtual std::string perform(Operation<std::string>* op) { return (*op)(this); }\
 virtual union Sass_Value* perform(Operation<union Sass_Value*>* op) { return (*op)(this); }\
-virtual Value* perform(Operation<Value*>* op) { return (*op)(this); }
+virtual Value_Ptr perform(Operation<Value_Ptr>* op) { return (*op)(this); }
 
 #define ADD_PROPERTY(type, name)\
 protected:\

data/ext/libsass/src/ast_fwd_decl.hpp

@@ -1,91 +1,389 @@
 #ifndef SASS_AST_FWD_DECL_H
 #define SASS_AST_FWD_DECL_H
 
+#include <vector>
+#include <iostream>
+#include <algorithm>
+#include <unordered_map>
+#include <unordered_set>
+#include "memory/SharedPtr.hpp"
+
 /////////////////////////////////////////////
 // Forward declarations for the AST visitors.
 /////////////////////////////////////////////
 namespace Sass {
 
   class AST_Node;
-  // statements
-  class Statement;
+  typedef AST_Node* AST_Node_Ptr;
+  typedef AST_Node const* AST_Node_Ptr_Const;
+
+  class Has_Block;
+  typedef Has_Block* Has_Block_Ptr;
+  typedef Has_Block const* Has_Block_Ptr_Const;
+
+  class Simple_Selector;
+  typedef Simple_Selector* Simple_Selector_Ptr;
+  typedef Simple_Selector const* Simple_Selector_Ptr_Const;
+
+  class PreValue;
+  typedef PreValue* PreValue_Ptr;
+  typedef PreValue const* PreValue_Ptr_Const;
+  class Thunk;
+  typedef Thunk* Thunk_Ptr;
+  typedef Thunk const* Thunk_Ptr_Const;
   class Block;
+  typedef Block* Block_Ptr;
+  typedef Block const* Block_Ptr_Const;
+  class Expression;
+  typedef Expression* Expression_Ptr;
+  typedef Expression const* Expression_Ptr_Const;
+  class Statement;
+  typedef Statement* Statement_Ptr;
+  typedef Statement const* Statement_Ptr_Const;
+  class Value;
+  typedef Value* Value_Ptr;
+  typedef Value const* Value_Ptr_Const;
+  class Declaration;
+  typedef Declaration* Declaration_Ptr;
+  typedef Declaration const* Declaration_Ptr_Const;
   class Ruleset;
+  typedef Ruleset* Ruleset_Ptr;
+  typedef Ruleset const* Ruleset_Ptr_Const;
   class Bubble;
+  typedef Bubble* Bubble_Ptr;
+  typedef Bubble const* Bubble_Ptr_Const;
   class Trace;
+  typedef Trace* Trace_Ptr;
+  typedef Trace const* Trace_Ptr_Const;
+
   class Media_Block;
+  typedef Media_Block* Media_Block_Ptr;
+  typedef Media_Block const* Media_Block_Ptr_Const;
   class Supports_Block;
+  typedef Supports_Block* Supports_Block_Ptr;
+  typedef Supports_Block const* Supports_Block_Ptr_Const;
   class Directive;
+  typedef Directive* Directive_Ptr;
+  typedef Directive const* Directive_Ptr_Const;
+
+
   class Keyframe_Rule;
+  typedef Keyframe_Rule* Keyframe_Rule_Ptr;
+  typedef Keyframe_Rule const* Keyframe_Rule_Ptr_Const;
   class At_Root_Block;
-  class Declaration;
+  typedef At_Root_Block* At_Root_Block_Ptr;
+  typedef At_Root_Block const* At_Root_Block_Ptr_Const;
   class Assignment;
+  typedef Assignment* Assignment_Ptr;
+  typedef Assignment const* Assignment_Ptr_Const;
+
   class Import;
+  typedef Import* Import_Ptr;
+  typedef Import const* Import_Ptr_Const;
   class Import_Stub;
+  typedef Import_Stub* Import_Stub_Ptr;
+  typedef Import_Stub const* Import_Stub_Ptr_Const;
   class Warning;
+  typedef Warning* Warning_Ptr;
+  typedef Warning const* Warning_Ptr_Const;
+
   class Error;
+  typedef Error* Error_Ptr;
+  typedef Error const* Error_Ptr_Const;
   class Debug;
+  typedef Debug* Debug_Ptr;
+  typedef Debug const* Debug_Ptr_Const;
   class Comment;
+  typedef Comment* Comment_Ptr;
+  typedef Comment const* Comment_Ptr_Const;
+
   class If;
+  typedef If* If_Ptr;
+  typedef If const* If_Ptr_Const;
   class For;
+  typedef For* For_Ptr;
+  typedef For const* For_Ptr_Const;
   class Each;
+  typedef Each* Each_Ptr;
+  typedef Each const* Each_Ptr_Const;
   class While;
+  typedef While* While_Ptr;
+  typedef While const* While_Ptr_Const;
   class Return;
+  typedef Return* Return_Ptr;
+  typedef Return const* Return_Ptr_Const;
   class Content;
+  typedef Content* Content_Ptr;
+  typedef Content const* Content_Ptr_Const;
   class Extension;
+  typedef Extension* Extension_Ptr;
+  typedef Extension const* Extension_Ptr_Const;
   class Definition;
-  class Mixin_Call;
-  // expressions
-  class Value;
-  class Expression;
+  typedef Definition* Definition_Ptr;
+  typedef Definition const* Definition_Ptr_Const;
+
   class List;
+  typedef List* List_Ptr;
+  typedef List const* List_Ptr_Const;
   class Map;
+  typedef Map* Map_Ptr;
+  typedef Map const* Map_Ptr_Const;
+
+  class Mixin_Call;
+  typedef Mixin_Call* Mixin_Call_Ptr;
+  typedef Mixin_Call const* Mixin_Call_Ptr_Const;
   class Binary_Expression;
+  typedef Binary_Expression* Binary_Expression_Ptr;
+  typedef Binary_Expression const* Binary_Expression_Ptr_Const;
   class Unary_Expression;
+  typedef Unary_Expression* Unary_Expression_Ptr;
+  typedef Unary_Expression const* Unary_Expression_Ptr_Const;
   class Function_Call;
+  typedef Function_Call* Function_Call_Ptr;
+  typedef Function_Call const* Function_Call_Ptr_Const;
   class Function_Call_Schema;
+  typedef Function_Call_Schema* Function_Call_Schema_Ptr;
+  typedef Function_Call_Schema const* Function_Call_Schema_Ptr_Const;
   class Custom_Warning;
+  typedef Custom_Warning* Custom_Warning_Ptr;
+  typedef Custom_Warning const* Custom_Warning_Ptr_Const;
   class Custom_Error;
+  typedef Custom_Error* Custom_Error_Ptr;
+  typedef Custom_Error const* Custom_Error_Ptr_Const;
+
   class Variable;
+  typedef Variable* Variable_Ptr;
+  typedef Variable const* Variable_Ptr_Const;
   class Textual;
+  typedef Textual* Textual_Ptr;
+  typedef Textual const* Textual_Ptr_Const;
   class Number;
+  typedef Number* Number_Ptr;
+  typedef Number const* Number_Ptr_Const;
   class Color;
+  typedef Color* Color_Ptr;
+  typedef Color const* Color_Ptr_Const;
   class Boolean;
-  class String_Schema;
+  typedef Boolean* Boolean_Ptr;
+  typedef Boolean const* Boolean_Ptr_Const;
   class String;
+  typedef String* String_Ptr;
+  typedef String const* String_Ptr_Const;
+
+  class String_Schema;
+  typedef String_Schema* String_Schema_Ptr;
+  typedef String_Schema const* String_Schema_Ptr_Const;
   class String_Constant;
+  typedef String_Constant* String_Constant_Ptr;
+  typedef String_Constant const* String_Constant_Ptr_Const;
   class String_Quoted;
+  typedef String_Quoted* String_Quoted_Ptr;
+  typedef String_Quoted const* String_Quoted_Ptr_Const;
+
   class Media_Query;
+  typedef Media_Query* Media_Query_Ptr;
+  typedef Media_Query const* Media_Query_Ptr_Const;
   class Media_Query_Expression;
+  typedef Media_Query_Expression* Media_Query_Expression_Ptr;
+  typedef Media_Query_Expression const* Media_Query_Expression_Ptr_Const;
   class Supports_Condition;
+  typedef Supports_Condition* Supports_Condition_Ptr;
+  typedef Supports_Condition const* Supports_Condition_Ptr_Const;
   class Supports_Operator;
+  typedef Supports_Operator* Supports_Operator_Ptr;
+  typedef Supports_Operator const* Supports_Operator_Ptr_Const;
   class Supports_Negation;
+  typedef Supports_Negation* Supports_Negation_Ptr;
+  typedef Supports_Negation const* Supports_Negation_Ptr_Const;
   class Supports_Declaration;
+  typedef Supports_Declaration* Supports_Declaration_Ptr;
+  typedef Supports_Declaration const* Supports_Declaration_Ptr_Const;
   class Supports_Interpolation;
-  class At_Root_Query;
+  typedef Supports_Interpolation* Supports_Interpolation_Ptr;
+  typedef Supports_Interpolation const* Supports_Interpolation_Ptr_Const;
+
+
   class Null;
+  typedef Null* Null_Ptr;
+  typedef Null const* Null_Ptr_Const;
+
+  class At_Root_Query;
+  typedef At_Root_Query* At_Root_Query_Ptr;
+  typedef At_Root_Query const* At_Root_Query_Ptr_Const;
   class Parent_Selector;
-  // parameters and arguments
+  typedef Parent_Selector* Parent_Selector_Ptr;
+  typedef Parent_Selector const* Parent_Selector_Ptr_Const;
   class Parameter;
+  typedef Parameter* Parameter_Ptr;
+  typedef Parameter const* Parameter_Ptr_Const;
   class Parameters;
+  typedef Parameters* Parameters_Ptr;
+  typedef Parameters const* Parameters_Ptr_Const;
   class Argument;
+  typedef Argument* Argument_Ptr;
+  typedef Argument const* Argument_Ptr_Const;
   class Arguments;
-  // selectors
+  typedef Arguments* Arguments_Ptr;
+  typedef Arguments const* Arguments_Ptr_Const;
   class Selector;
+  typedef Selector* Selector_Ptr;
+  typedef Selector const* Selector_Ptr_Const;
+
+
   class Selector_Schema;
+  typedef Selector_Schema* Selector_Schema_Ptr;
+  typedef Selector_Schema const* Selector_Schema_Ptr_Const;
   class Placeholder_Selector;
+  typedef Placeholder_Selector* Placeholder_Selector_Ptr;
+  typedef Placeholder_Selector const* Placeholder_Selector_Ptr_Const;
   class Element_Selector;
+  typedef Element_Selector* Element_Selector_Ptr;
+  typedef Element_Selector const* Element_Selector_Ptr_Const;
   class Class_Selector;
+  typedef Class_Selector* Class_Selector_Ptr;
+  typedef Class_Selector const* Class_Selector_Ptr_Const;
   class Id_Selector;
+  typedef Id_Selector* Id_Selector_Ptr;
+  typedef Id_Selector const* Id_Selector_Ptr_Const;
   class Attribute_Selector;
+  typedef Attribute_Selector* Attribute_Selector_Ptr;
+  typedef Attribute_Selector const* Attribute_Selector_Ptr_Const;
+
   class Pseudo_Selector;
+  typedef Pseudo_Selector* Pseudo_Selector_Ptr;
+  typedef Pseudo_Selector const * Pseudo_Selector_Ptr_Const;
   class Wrapped_Selector;
-  class SimpleSequence_Selector;
-  class Sequence_Selector;
-  class CommaSequence_Selector;
+  typedef Wrapped_Selector* Wrapped_Selector_Ptr;
+  typedef Wrapped_Selector const * Wrapped_Selector_Ptr_Const;
+  class Compound_Selector;
+  typedef Compound_Selector* Compound_Selector_Ptr;
+  typedef Compound_Selector const * Compound_Selector_Ptr_Const;
+  class Complex_Selector;
+  typedef Complex_Selector* Complex_Selector_Ptr;
+  typedef Complex_Selector const * Complex_Selector_Ptr_Const;
+  class Selector_List;
+  typedef Selector_List* Selector_List_Ptr;
+  typedef Selector_List const * Selector_List_Ptr_Const;
+
 
   // common classes
   class Context;
+  class Expand;
+  class Eval;
+
+  // declare classes that are instances of memory nodes
+  // #define IMPL_MEM_OBJ(type) using type##_Obj = SharedImpl<type>
+  #define IMPL_MEM_OBJ(type) typedef SharedImpl<type> type##_Obj
+
+  IMPL_MEM_OBJ(AST_Node);
+  IMPL_MEM_OBJ(Statement);
+  IMPL_MEM_OBJ(Block);
+  IMPL_MEM_OBJ(Ruleset);
+  IMPL_MEM_OBJ(Bubble);
+  IMPL_MEM_OBJ(Trace);
+  IMPL_MEM_OBJ(Media_Block);
+  IMPL_MEM_OBJ(Supports_Block);
+  IMPL_MEM_OBJ(Directive);
+  IMPL_MEM_OBJ(Keyframe_Rule);
+  IMPL_MEM_OBJ(At_Root_Block);
+  IMPL_MEM_OBJ(Declaration);
+  IMPL_MEM_OBJ(Assignment);
+  IMPL_MEM_OBJ(Import);
+  IMPL_MEM_OBJ(Import_Stub);
+  IMPL_MEM_OBJ(Warning);
+  IMPL_MEM_OBJ(Error);
+  IMPL_MEM_OBJ(Debug);
+  IMPL_MEM_OBJ(Comment);
+  IMPL_MEM_OBJ(PreValue);
+  IMPL_MEM_OBJ(Has_Block);
+  IMPL_MEM_OBJ(Thunk);
+  IMPL_MEM_OBJ(If);
+  IMPL_MEM_OBJ(For);
+  IMPL_MEM_OBJ(Each);
+  IMPL_MEM_OBJ(While);
+  IMPL_MEM_OBJ(Return);
+  IMPL_MEM_OBJ(Content);
+  IMPL_MEM_OBJ(Extension);
+  IMPL_MEM_OBJ(Definition);
+  IMPL_MEM_OBJ(Mixin_Call);
+  IMPL_MEM_OBJ(Value);
+  IMPL_MEM_OBJ(Expression);
+  IMPL_MEM_OBJ(List);
+  IMPL_MEM_OBJ(Map);
+  IMPL_MEM_OBJ(Binary_Expression);
+  IMPL_MEM_OBJ(Unary_Expression);
+  IMPL_MEM_OBJ(Function_Call);
+  IMPL_MEM_OBJ(Function_Call_Schema);
+  IMPL_MEM_OBJ(Custom_Warning);
+  IMPL_MEM_OBJ(Custom_Error);
+  IMPL_MEM_OBJ(Variable);
+  IMPL_MEM_OBJ(Textual);
+  IMPL_MEM_OBJ(Number);
+  IMPL_MEM_OBJ(Color);
+  IMPL_MEM_OBJ(Boolean);
+  IMPL_MEM_OBJ(String_Schema);
+  IMPL_MEM_OBJ(String);
+  IMPL_MEM_OBJ(String_Constant);
+  IMPL_MEM_OBJ(String_Quoted);
+  IMPL_MEM_OBJ(Media_Query);
+  IMPL_MEM_OBJ(Media_Query_Expression);
+  IMPL_MEM_OBJ(Supports_Condition);
+  IMPL_MEM_OBJ(Supports_Operator);
+  IMPL_MEM_OBJ(Supports_Negation);
+  IMPL_MEM_OBJ(Supports_Declaration);
+  IMPL_MEM_OBJ(Supports_Interpolation);
+  IMPL_MEM_OBJ(At_Root_Query);
+  IMPL_MEM_OBJ(Null);
+  IMPL_MEM_OBJ(Parent_Selector);
+  IMPL_MEM_OBJ(Parameter);
+  IMPL_MEM_OBJ(Parameters);
+  IMPL_MEM_OBJ(Argument);
+  IMPL_MEM_OBJ(Arguments);
+  IMPL_MEM_OBJ(Selector);
+  IMPL_MEM_OBJ(Selector_Schema);
+  IMPL_MEM_OBJ(Simple_Selector);
+  IMPL_MEM_OBJ(Placeholder_Selector);
+  IMPL_MEM_OBJ(Element_Selector);
+  IMPL_MEM_OBJ(Class_Selector);
+  IMPL_MEM_OBJ(Id_Selector);
+  IMPL_MEM_OBJ(Attribute_Selector);
+  IMPL_MEM_OBJ(Pseudo_Selector);
+  IMPL_MEM_OBJ(Wrapped_Selector);
+  IMPL_MEM_OBJ(Compound_Selector);
+  IMPL_MEM_OBJ(Complex_Selector);
+  IMPL_MEM_OBJ(Selector_List);
+
+
+  struct HashExpression {
+    size_t operator() (Expression_Obj ex) const;
+  };
+  struct CompareExpression {
+    bool operator()(const Expression_Obj& lhs, const Expression_Obj& rhs) const;
+  };
+
+  struct HashSimpleSelector {
+    size_t operator() (Simple_Selector_Obj ex) const;
+  };
+
+  struct CompareSimpleSelector {
+    bool operator()(Simple_Selector_Obj lhs, Simple_Selector_Obj rhs) const;
+  };
+
+  typedef std::unordered_map<
+    Expression_Obj, // key
+    Expression_Obj, // value
+    HashExpression, // hasher
+    CompareExpression // compare
+  > ExpressionMap;
+  typedef std::unordered_set<
+    Expression_Obj, // value
+    HashExpression, // hasher
+    CompareExpression // compare
+  > ExpressionSet;
+
+  typedef std::string Subset_Map_Key;
+  typedef std::vector<size_t> Subset_Map_Arr;
+  typedef std::pair<Complex_Selector_Obj, Compound_Selector_Obj> Subset_Map_Val;
 
 }
 

data/ext/libsass/src/bind.cpp

@@ -9,14 +9,14 @@
 
 namespace Sass {
 
-  void bind(std::string type, std::string name, Parameters* ps, Arguments* as, Context* ctx, Env* env, Eval* eval)
+  void bind(std::string type, std::string name, Parameters_Obj ps, Arguments_Obj as, Context* ctx, Env* env, Eval* eval)
   {
     std::string callee(type + " " + name);
 
-    std::map<std::string, Parameter*> param_map;
+    std::map<std::string, Parameter_Obj> param_map;
 
     for (size_t i = 0, L = as->length(); i < L; ++i) {
-      if (auto str = dynamic_cast<String_Quoted*>((*as)[i]->value())) {
+      if (auto str = SASS_MEMORY_CAST(String_Quoted, (*as)[i]->value())) {
         // force optional quotes (only if needed)
         if (str->quote_mark()) {
           str->quote_mark('*');
@@ -27,7 +27,7 @@ namespace Sass {
     // Set up a map to ensure named arguments refer to actual parameters. Also
     // eval each default value left-to-right, wrt env, populating env as we go.
     for (size_t i = 0, L = ps->length(); i < L; ++i) {
-      Parameter*  p = (*ps)[i];
+      Parameter_Obj  p = ps->at(i);
       param_map[p->name()] = p;
       // if (p->default_value()) {
       //   env->local_frame()[p->name()] = p->default_value()->perform(eval->with(env));
@@ -38,11 +38,11 @@ namespace Sass {
     size_t ip = 0, LP = ps->length();
     size_t ia = 0, LA = as->length();
     while (ia < LA) {
-      Argument* a = (*as)[ia];
+      Argument_Obj a = as->at(ia);
       if (ip >= LP) {
         // skip empty rest arguments
         if (a->is_rest_argument()) {
-          if (List* l = dynamic_cast<List*>(a->value())) {
+          if (List_Obj l = SASS_MEMORY_CAST(List, a->value())) {
             if (l->length() == 0) {
               ++ ia; continue;
             }
@@ -53,7 +53,7 @@ namespace Sass {
         msg << " for `" << name << "'";
         return error(msg.str(), as->pstate());
       }
-      Parameter* p = (*ps)[ip];
+      Parameter_Obj p = ps->at(ip);
 
       // If the current parameter is the rest parameter, process and break the loop
       if (p->is_rest_parameter()) {
@@ -61,24 +61,24 @@ namespace Sass {
         if (a->is_rest_argument()) {
 
           // We should always get a list for rest arguments
-          if (List* rest = dynamic_cast<List*>(a->value())) {
+          if (List_Obj rest = SASS_MEMORY_CAST(List, a->value())) {
               // create a new list object for wrapped items
-              List* arglist = SASS_MEMORY_NEW(ctx->mem, List,
+              List_Ptr arglist = SASS_MEMORY_NEW(List,
                                               p->pstate(),
                                               0,
                                               rest->separator(),
                                               true);
               // wrap each item from list as an argument
-              for (Expression* item : rest->elements()) {
-                if (Argument* arg = dynamic_cast<Argument*>(item)) {
-                  (*arglist) << SASS_MEMORY_NEW(ctx->mem, Argument, *arg);
+              for (Expression_Obj item : rest->elements()) {
+                if (Argument_Obj arg = SASS_MEMORY_CAST(Argument, item)) {
+                  arglist->append(SASS_MEMORY_COPY(arg)); // copy
                 } else {
-                  (*arglist) << SASS_MEMORY_NEW(ctx->mem, Argument,
-                                                item->pstate(),
-                                                item,
-                                                "",
-                                                false,
-                                                false);
+                  arglist->append(SASS_MEMORY_NEW(Argument,
+                                                  item->pstate(),
+                                                  &item,
+                                                  "",
+                                                  false,
+                                                  false));
                 }
               }
               // assign new arglist to environment
@@ -91,23 +91,23 @@ namespace Sass {
         } else if (a->is_keyword_argument()) {
 
           // expand keyword arguments into their parameters
-          List* arglist = SASS_MEMORY_NEW(ctx->mem, List, p->pstate(), 0, SASS_COMMA, true);
+          List_Ptr arglist = SASS_MEMORY_NEW(List, p->pstate(), 0, SASS_COMMA, true);
           env->local_frame()[p->name()] = arglist;
-          Map* argmap = static_cast<Map*>(a->value());
+          Map_Obj argmap = SASS_MEMORY_CAST(Map, a->value());
           for (auto key : argmap->keys()) {
-            std::string name = unquote(static_cast<String_Constant*>(key)->value());
-            (*arglist) << SASS_MEMORY_NEW(ctx->mem, Argument,
-                                          key->pstate(),
-                                          argmap->at(key),
-                                          "$" + name,
-                                          false,
-                                          false);
+            std::string name = unquote(SASS_MEMORY_CAST(String_Constant, key)->value());
+            arglist->append(SASS_MEMORY_NEW(Argument,
+                                            key->pstate(),
+                                            argmap->at(key),
+                                            "$" + name,
+                                            false,
+                                            false));
           }
 
         } else {
 
           // create a new list object for wrapped items
-          List* arglist = SASS_MEMORY_NEW(ctx->mem, List,
+          List_Obj arglist = SASS_MEMORY_NEW(List,
                                           p->pstate(),
                                           0,
                                           SASS_COMMA,
@@ -117,26 +117,28 @@ namespace Sass {
             // get and post inc
             a = (*as)[ia++];
             // maybe we have another list as argument
-            List* ls = dynamic_cast<List*>(a->value());
+            List_Obj ls = SASS_MEMORY_CAST(List, a->value());
             // skip any list completely if empty
             if (ls && ls->empty() && a->is_rest_argument()) continue;
 
-            if (Argument* arg = dynamic_cast<Argument*>(a->value())) {
-              (*arglist) << SASS_MEMORY_NEW(ctx->mem, Argument, *arg);
+            Expression_Obj value = a->value();
+            if (Argument_Obj arg = SASS_MEMORY_CAST(Argument, value)) {
+              arglist->append(&arg);
             }
             // check if we have rest argument
             else if (a->is_rest_argument()) {
               // preserve the list separator from rest args
-              if (List* rest = dynamic_cast<List*>(a->value())) {
+              if (List_Obj rest = SASS_MEMORY_CAST(List, a->value())) {
                 arglist->separator(rest->separator());
 
                 for (size_t i = 0, L = rest->size(); i < L; ++i) {
-                  (*arglist) << SASS_MEMORY_NEW(ctx->mem, Argument,
-                                                (*rest)[i]->pstate(),
-                                                (*rest)[i],
+                  Expression_Obj obj = rest->at(i);
+                  arglist->append(SASS_MEMORY_NEW(Argument,
+                                                obj->pstate(),
+                                                &obj,
                                                 "",
                                                 false,
-                                                false);
+                                                false));
                 }
               }
               // no more arguments
@@ -144,16 +146,16 @@ namespace Sass {
             }
             // wrap all other value types into Argument
             else {
-              (*arglist) << SASS_MEMORY_NEW(ctx->mem, Argument,
+              arglist->append(SASS_MEMORY_NEW(Argument,
                                             a->pstate(),
                                             a->value(),
                                             a->name(),
                                             false,
-                                            false);
+                                            false));
             }
           }
           // assign new arglist to environment
-          env->local_frame()[p->name()] = arglist;
+          env->local_frame()[p->name()] = &arglist;
         }
         // consumed parameter
         ++ip;
@@ -164,7 +166,7 @@ namespace Sass {
       // If the current argument is the rest argument, extract a value for processing
       else if (a->is_rest_argument()) {
         // normal param and rest arg
-        List* arglist = static_cast<List*>(a->value());
+        List_Obj arglist = SASS_MEMORY_CAST(List, a->value());
         // empty rest arg - treat all args as default values
         if (!arglist->length()) {
           break;
@@ -184,9 +186,10 @@ namespace Sass {
           }
         }
         // otherwise move one of the rest args into the param, converting to argument if necessary
-        if (!(a = dynamic_cast<Argument*>((*arglist)[0]))) {
-          Expression* a_to_convert = (*arglist)[0];
-          a = SASS_MEMORY_NEW(ctx->mem, Argument,
+        Expression_Obj obj = arglist->at(0);
+        if (!(a = SASS_MEMORY_CAST(Argument, obj))) {
+          Expression_Ptr a_to_convert = &obj;
+          a = SASS_MEMORY_NEW(Argument,
                               a_to_convert->pstate(),
                               a_to_convert,
                               "",
@@ -199,17 +202,17 @@ namespace Sass {
         }
 
       } else if (a->is_keyword_argument()) {
-        Map* argmap = static_cast<Map*>(a->value());
+        Map_Obj argmap = SASS_MEMORY_CAST(Map, a->value());
 
         for (auto key : argmap->keys()) {
-          std::string name = "$" + unquote(static_cast<String_Constant*>(key)->value());
+          std::string name = "$" + unquote(SASS_MEMORY_CAST(String_Constant, key)->value());
 
           if (!param_map.count(name)) {
             std::stringstream msg;
             msg << callee << " has no parameter named " << name;
             error(msg.str(), a->pstate());
           }
-          env->local_frame()[name] = argmap->at(key);
+          env->local_frame()[name] = &argmap->at(&key);
         }
         ++ia;
         continue;
@@ -225,7 +228,7 @@ namespace Sass {
           error(msg.str(), a->pstate());
         }
         // ordinal arg -- bind it to the next param
-        env->local_frame()[p->name()] = a->value();
+        env->local_frame()[p->name()] = &a->value();
         ++ip;
       }
       else {
@@ -247,7 +250,7 @@ namespace Sass {
               << "provided more than once in call to " << callee;
           error(msg.str(), a->pstate());
         }
-        env->local_frame()[a->name()] = a->value();
+        env->local_frame()[a->name()] = &a->value();
       }
     }
     // EO while ia
@@ -256,20 +259,20 @@ namespace Sass {
     // That's only okay if they have default values, or were already bound by
     // named arguments, or if it's a single rest-param.
     for (size_t i = ip; i < LP; ++i) {
-      Parameter* leftover = (*ps)[i];
+      Parameter_Obj leftover = ps->at(i);
       // cerr << "env for default params:" << endl;
       // env->print();
       // cerr << "********" << endl;
       if (!env->has_local(leftover->name())) {
         if (leftover->is_rest_parameter()) {
-          env->local_frame()[leftover->name()] = SASS_MEMORY_NEW(ctx->mem, List,
+          env->local_frame()[leftover->name()] = SASS_MEMORY_NEW(List,
                                                                    leftover->pstate(),
                                                                    0,
                                                                    SASS_COMMA,
                                                                    true);
         }
         else if (leftover->default_value()) {
-          Expression* dv = leftover->default_value()->perform(eval);
+          Expression_Ptr dv = leftover->default_value()->perform(eval);
           env->local_frame()[leftover->name()] = dv;
         }
         else {