sassc 1.11.1 → 1.11.2

data/ext/libsass/src/ast.hpp

@@ -9,8 +9,30 @@
 #include <iostream>
 #include <typeinfo>
 #include <algorithm>
-#include <unordered_map>
 #include "sass/base.h"
+#include "ast_fwd_decl.hpp"
+
+#ifdef DEBUG_SHARED_PTR
+
+#define ATTACH_VIRTUAL_AST_OPERATIONS(klass) \
+  virtual klass##_Ptr copy(std::string, size_t) const = 0; \
+  virtual klass##_Ptr clone(std::string, size_t) const = 0; \
+
+#define ATTACH_AST_OPERATIONS(klass) \
+  virtual klass##_Ptr copy(std::string, size_t) const; \
+  virtual klass##_Ptr clone(std::string, size_t) const; \
+
+#else
+
+#define ATTACH_VIRTUAL_AST_OPERATIONS(klass) \
+  virtual klass##_Ptr copy() const = 0; \
+  virtual klass##_Ptr clone() const = 0; \
+
+#define ATTACH_AST_OPERATIONS(klass) \
+  virtual klass##_Ptr copy() const; \
+  virtual klass##_Ptr clone() const; \
+
+#endif
 
 #ifdef __clang__
 
@@ -20,12 +42,7 @@
  *
  * Type type() which hides string type() from Expression
  *
- * and
- *
- * Block* block() which hides virtual Block* block() from Statement
- *
  */
-
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Woverloaded-virtual"
 
@@ -86,19 +103,26 @@ namespace Sass {
   //////////////////////////////////////////////////////////
   // Abstract base class for all abstract syntax tree nodes.
   //////////////////////////////////////////////////////////
-  class AST_Node : public Memory_Object {
+  class AST_Node : public SharedObj {
     ADD_PROPERTY(ParserState, pstate)
   public:
     AST_Node(ParserState pstate)
     : pstate_(pstate)
     { }
+    AST_Node(const AST_Node* ptr)
+    : pstate_(ptr->pstate_)
+    { }
+
+    // AST_Node(AST_Node& ptr) = delete;
+
     virtual ~AST_Node() = 0;
     virtual size_t hash() { return 0; }
+    ATTACH_VIRTUAL_AST_OPERATIONS(AST_Node);
     virtual std::string inspect() const { return to_string({ INSPECT, 5 }); }
     virtual std::string to_sass() const { return to_string({ TO_SASS, 5 }); }
     virtual std::string to_string(Sass_Inspect_Options opt) const;
     virtual std::string to_string() const;
-    // virtual Block* block() { return 0; }
+    virtual void cloneChildren() {};
   public:
     void update_pstate(const ParserState& pstate);
     void set_pstate_offset(const Offset& offset);
@@ -129,8 +153,15 @@ namespace Sass {
       NULL_VAL,
       C_WARNING,
       C_ERROR,
+      FUNCTION,
       NUM_TYPES
     };
+    enum Simple_Type {
+      SIMPLE,
+      ATTR_SEL,
+      PSEUDO_SEL,
+      WRAPPED_SEL,
+    };
   private:
     // expressions in some contexts shouldn't be evaluated
     ADD_PROPERTY(bool, is_delayed)
@@ -146,12 +177,20 @@ namespace Sass {
       is_interpolant_(i),
       concrete_type_(ct)
     { }
+    Expression(const Expression* ptr)
+    : AST_Node(ptr),
+      is_delayed_(ptr->is_delayed_),
+      is_expanded_(ptr->is_expanded_),
+      is_interpolant_(ptr->is_interpolant_),
+      concrete_type_(ptr->concrete_type_)
+    { }
     virtual operator bool() { return true; }
     virtual ~Expression() { }
     virtual std::string type() { return ""; /* TODO: raise an error? */ }
     virtual bool is_invisible() const { return false; }
     static std::string type_name() { return ""; }
     virtual bool is_false() { return false; }
+    // virtual bool is_true() { return !is_false(); }
     virtual bool operator== (const Expression& rhs) const { return false; }
     virtual bool eq(const Expression& rhs) const { return *this == rhs; };
     virtual void set_delayed(bool delayed) { is_delayed(delayed); }
@@ -160,6 +199,7 @@ namespace Sass {
     virtual bool is_right_interpolant() const { return is_interpolant(); }
     virtual std::string inspect() const { return to_string({ INSPECT, 5 }); }
     virtual std::string to_sass() const { return to_string({ TO_SASS, 5 }); }
+    ATTACH_VIRTUAL_AST_OPERATIONS(Expression);
     virtual size_t hash() { return 0; }
   };
 
@@ -172,6 +212,10 @@ namespace Sass {
                bool d = false, bool e = false, bool i = false, Concrete_Type ct = NONE)
     : Expression(pstate, d, e, i, ct)
     { }
+    PreValue(const PreValue* ptr)
+    : Expression(ptr)
+    { }
+    ATTACH_VIRTUAL_AST_OPERATIONS(PreValue);
     virtual ~PreValue() { }
   };
 
@@ -184,6 +228,10 @@ namespace Sass {
           bool d = false, bool e = false, bool i = false, Concrete_Type ct = NONE)
     : Expression(pstate, d, e, i, ct)
     { }
+    Value(const Value* ptr)
+    : Expression(ptr)
+    { }
+    ATTACH_VIRTUAL_AST_OPERATIONS(Value);
     virtual bool operator== (const Expression& rhs) const = 0;
   };
 }
@@ -194,17 +242,17 @@ namespace Sass {
 
 namespace std {
   template<>
-  struct hash<Sass::Expression*>
+  struct hash<Sass::Expression_Obj>
   {
-    size_t operator()(Sass::Expression* s) const
+    size_t operator()(Sass::Expression_Obj s) const
     {
       return s->hash();
     }
   };
   template<>
-  struct equal_to<Sass::Expression*>
+  struct equal_to<Sass::Expression_Obj>
   {
-    bool operator()( Sass::Expression* lhs,  Sass::Expression* rhs) const
+    bool operator()( Sass::Expression_Obj lhs,  Sass::Expression_Obj rhs) const
     {
       return lhs->hash() == rhs->hash();
     }
@@ -231,23 +279,24 @@ namespace Sass {
     virtual ~Vectorized() = 0;
     size_t length() const   { return elements_.size(); }
     bool empty() const      { return elements_.empty(); }
+    void clear()            { return elements_.clear(); }
     T last() const          { return elements_.back(); }
     T first() const         { return elements_.front(); }
     T& operator[](size_t i) { return elements_[i]; }
     virtual const T& at(size_t i) const { return elements_.at(i); }
+    virtual T& at(size_t i) { return elements_.at(i); }
     const T& operator[](size_t i) const { return elements_[i]; }
-    virtual Vectorized& operator<<(T element)
+    virtual void append(T element)
     {
-      if (!element) return *this;
-      reset_hash();
-      elements_.push_back(element);
-      adjust_after_pushing(element);
-      return *this;
+      if (element) {
+        reset_hash();
+        elements_.push_back(element);
+        adjust_after_pushing(element);
+      }
     }
-    Vectorized& operator+=(Vectorized* v)
+    virtual void concat(Vectorized* v)
     {
-      for (size_t i = 0, L = v->length(); i < L; ++i) *this << (*v)[i];
-      return *this;
+      for (size_t i = 0, L = v->length(); i < L; ++i) this->append((*v)[i]);
     }
     Vectorized& unshift(T element)
     {
@@ -284,43 +333,27 @@ namespace Sass {
   // extra <std::vector> internally to maintain insertion order for interation.
   /////////////////////////////////////////////////////////////////////////////
   class Hashed {
-  struct HashExpression {
-    size_t operator() (Expression* ex) const {
-      return ex ? ex->hash() : 0;
-    }
-  };
-  struct CompareExpression {
-    bool operator()(const Expression* lhs, const Expression* rhs) const {
-      return lhs && rhs && lhs->eq(*rhs);
-    }
-  };
-  typedef std::unordered_map<
-    Expression*, // key
-    Expression*, // value
-    HashExpression, // hasher
-    CompareExpression // compare
-  > ExpressionMap;
   private:
     ExpressionMap elements_;
-    std::vector<Expression*> list_;
+    std::vector<Expression_Obj> list_;
   protected:
     size_t hash_;
-    Expression* duplicate_key_;
+    Expression_Obj duplicate_key_;
     void reset_hash() { hash_ = 0; }
     void reset_duplicate_key() { duplicate_key_ = 0; }
-    virtual void adjust_after_pushing(std::pair<Expression*, Expression*> p) { }
+    virtual void adjust_after_pushing(std::pair<Expression_Obj, Expression_Obj> p) { }
   public:
-    Hashed(size_t s = 0) : elements_(ExpressionMap(s)), list_(std::vector<Expression*>())
+    Hashed(size_t s = 0) : elements_(ExpressionMap(s)), list_(std::vector<Expression_Obj>())
     { elements_.reserve(s); list_.reserve(s); reset_duplicate_key(); }
     virtual ~Hashed();
     size_t length() const                  { return list_.size(); }
     bool empty() const                     { return list_.empty(); }
-    bool has(Expression* k) const          { return elements_.count(k) == 1; }
-    Expression* at(Expression* k) const;
+    bool has(Expression_Obj k) const          { return elements_.count(k) == 1; }
+    Expression_Obj at(Expression_Obj k) const;
     bool has_duplicate_key() const         { return duplicate_key_ != 0; }
-    Expression* get_duplicate_key() const  { return duplicate_key_; }
+    Expression_Obj get_duplicate_key() const  { return duplicate_key_; }
     const ExpressionMap elements() { return elements_; }
-    Hashed& operator<<(std::pair<Expression*, Expression*> p)
+    Hashed& operator<<(std::pair<Expression_Obj, Expression_Obj> p)
     {
       reset_hash();
 
@@ -348,12 +381,12 @@ namespace Sass {
       return *this;
     }
     const ExpressionMap& pairs() const { return elements_; }
-    const std::vector<Expression*>& keys() const { return list_; }
+    const std::vector<Expression_Obj>& keys() const { return list_; }
 
-    std::unordered_map<Expression*, Expression*>::iterator end() { return elements_.end(); }
-    std::unordered_map<Expression*, Expression*>::iterator begin() { return elements_.begin(); }
-    std::unordered_map<Expression*, Expression*>::const_iterator end() const { return elements_.end(); }
-    std::unordered_map<Expression*, Expression*>::const_iterator begin() const { return elements_.begin(); }
+//    std::unordered_map<Expression_Obj, Expression_Obj>::iterator end() { return elements_.end(); }
+//    std::unordered_map<Expression_Obj, Expression_Obj>::iterator begin() { return elements_.begin(); }
+//    std::unordered_map<Expression_Obj, Expression_Obj>::const_iterator end() const { return elements_.end(); }
+//    std::unordered_map<Expression_Obj, Expression_Obj>::const_iterator begin() const { return elements_.begin(); }
 
   };
   inline Hashed::~Hashed() { }
@@ -392,19 +425,23 @@ namespace Sass {
       IF
     };
   private:
-    ADD_PROPERTY(Block*, block)
     ADD_PROPERTY(Statement_Type, statement_type)
     ADD_PROPERTY(size_t, tabs)
     ADD_PROPERTY(bool, group_end)
   public:
     Statement(ParserState pstate, Statement_Type st = NONE, size_t t = 0)
-    : AST_Node(pstate), block_(0), statement_type_(st), tabs_(t), group_end_(false)
+    : AST_Node(pstate), statement_type_(st), tabs_(t), group_end_(false)
+     { }
+    Statement(const Statement* ptr)
+    : AST_Node(ptr),
+      statement_type_(ptr->statement_type_),
+      tabs_(ptr->tabs_),
+      group_end_(ptr->group_end_)
      { }
     virtual ~Statement() = 0;
     // needed for rearranging nested rulesets during CSS emission
     virtual bool   is_invisible() const { return false; }
     virtual bool   bubbles() { return false; }
-    virtual Block* block()  { return 0; }
     virtual bool has_content()
     {
       return statement_type_ == CONTENT;
@@ -415,21 +452,27 @@ namespace Sass {
   ////////////////////////
   // Blocks of statements.
   ////////////////////////
-  class Block : public Statement, public Vectorized<Statement*> {
+  class Block : public Statement, public Vectorized<Statement_Obj> {
     ADD_PROPERTY(bool, is_root)
     ADD_PROPERTY(bool, is_at_root);
     // needed for properly formatted CSS emission
   protected:
-    void adjust_after_pushing(Statement* s)
+    void adjust_after_pushing(Statement_Obj s)
     {
     }
   public:
     Block(ParserState pstate, size_t s = 0, bool r = false)
     : Statement(pstate),
-      Vectorized<Statement*>(s),
+      Vectorized<Statement_Obj>(s),
       is_root_(r),
       is_at_root_(false)
     { }
+    Block(const Block* ptr)
+    : Statement(ptr),
+      Vectorized<Statement_Obj>(*ptr),
+      is_root_(ptr->is_root_),
+      is_at_root_(ptr->is_at_root_)
+    { }
     virtual bool has_content()
     {
       for (size_t i = 0, L = elements().size(); i < L; ++i) {
@@ -437,7 +480,7 @@ namespace Sass {
       }
       return Statement::has_content();
     }
-    Block* block() { return this; }
+    ATTACH_AST_OPERATIONS(Block)
     ATTACH_OPERATIONS()
   };
 
@@ -445,11 +488,14 @@ namespace Sass {
   // Abstract base class for statements that contain blocks of statements.
   ////////////////////////////////////////////////////////////////////////
   class Has_Block : public Statement {
-    ADD_PROPERTY(Block*, block)
+    ADD_PROPERTY(Block_Obj, block)
   public:
-    Has_Block(ParserState pstate, Block* b)
+    Has_Block(ParserState pstate, Block_Obj b)
     : Statement(pstate), block_(b)
     { }
+    Has_Block(const Has_Block* ptr)
+    : Statement(ptr), block_(ptr->block_)
+    { }
     virtual bool has_content()
     {
       return (block_ && block_->has_content()) || Statement::has_content();
@@ -463,14 +509,21 @@ namespace Sass {
   // of style declarations.
   /////////////////////////////////////////////////////////////////////////////
   class Ruleset : public Has_Block {
-    ADD_PROPERTY(Selector*, selector)
+    ADD_PROPERTY(Selector_Obj, selector)
     ADD_PROPERTY(bool, at_root);
     ADD_PROPERTY(bool, is_root);
   public:
-    Ruleset(ParserState pstate, Selector* s = 0, Block* b = 0)
+    Ruleset(ParserState pstate, Selector_Obj s = 0, Block_Obj b = 0)
     : Has_Block(pstate, b), selector_(s), at_root_(false), is_root_(false)
     { statement_type(RULESET); }
+    Ruleset(const Ruleset* ptr)
+    : Has_Block(ptr),
+      selector_(ptr->selector_),
+      at_root_(ptr->at_root_),
+      is_root_(ptr->is_root_)
+    { statement_type(RULESET); }
     bool is_invisible() const;
+    ATTACH_AST_OPERATIONS(Ruleset)
     ATTACH_OPERATIONS()
   };
 
@@ -478,13 +531,19 @@ namespace Sass {
   // Bubble.
   /////////////////
   class Bubble : public Statement {
-    ADD_PROPERTY(Statement*, node)
+    ADD_PROPERTY(Statement_Obj, node)
     ADD_PROPERTY(bool, group_end)
   public:
-    Bubble(ParserState pstate, Statement* n, Statement* g = 0, size_t t = 0)
+    Bubble(ParserState pstate, Statement_Obj n, Statement_Obj g = 0, size_t t = 0)
     : Statement(pstate, Statement::BUBBLE, t), node_(n), group_end_(g == 0)
     { }
+    Bubble(const Bubble* ptr)
+    : Statement(ptr),
+      node_(ptr->node_),
+      group_end_(ptr->group_end_)
+    { }
     bool bubbles() { return true; }
+    ATTACH_AST_OPERATIONS(Bubble)
     ATTACH_OPERATIONS()
   };
 
@@ -494,9 +553,14 @@ namespace Sass {
   class Trace : public Has_Block {
     ADD_PROPERTY(std::string, name)
   public:
-    Trace(ParserState pstate, std::string n, Block* b = 0)
+    Trace(ParserState pstate, std::string n, Block_Obj b = 0)
     : Has_Block(pstate, b), name_(n)
     { }
+    Trace(const Trace* ptr)
+    : Has_Block(ptr),
+      name_(ptr->name_)
+    { }
+    ATTACH_AST_OPERATIONS(Trace)
     ATTACH_OPERATIONS()
   };
 
@@ -504,16 +568,20 @@ namespace Sass {
   // Media queries.
   /////////////////
   class Media_Block : public Has_Block {
-    ADD_PROPERTY(List*, media_queries)
+    ADD_PROPERTY(List_Obj, media_queries)
   public:
-    Media_Block(ParserState pstate, List* mqs, Block* b)
+    Media_Block(ParserState pstate, List_Obj mqs, Block_Obj b)
     : Has_Block(pstate, b), media_queries_(mqs)
     { statement_type(MEDIA); }
-    Media_Block(ParserState pstate, List* mqs, Block* b, Selector* s)
+    Media_Block(ParserState pstate, List_Obj mqs, Block_Obj b, Selector_Obj s)
     : Has_Block(pstate, b), media_queries_(mqs)
     { statement_type(MEDIA); }
+    Media_Block(const Media_Block* ptr)
+    : Has_Block(ptr), media_queries_(ptr->media_queries_)
+    { statement_type(MEDIA); }
     bool bubbles() { return true; }
     bool is_invisible() const;
+    ATTACH_AST_OPERATIONS(Media_Block)
     ATTACH_OPERATIONS()
   };
 
@@ -523,12 +591,18 @@ namespace Sass {
   ///////////////////////////////////////////////////////////////////////
   class Directive : public Has_Block {
     ADD_PROPERTY(std::string, keyword)
-    ADD_PROPERTY(Selector*, selector)
-    ADD_PROPERTY(Expression*, value)
+    ADD_PROPERTY(Selector_Obj, selector)
+    ADD_PROPERTY(Expression_Obj, value)
   public:
-    Directive(ParserState pstate, std::string kwd, Selector* sel = 0, Block* b = 0, Expression* val = 0)
+    Directive(ParserState pstate, std::string kwd, Selector_Obj sel = 0, Block_Obj b = 0, Expression_Obj val = 0)
     : Has_Block(pstate, b), keyword_(kwd), selector_(sel), value_(val) // set value manually if needed
     { statement_type(DIRECTIVE); }
+    Directive(const Directive* ptr)
+    : Has_Block(ptr),
+      keyword_(ptr->keyword_),
+      selector_(ptr->selector_),
+      value_(ptr->value_) // set value manually if needed
+    { statement_type(DIRECTIVE); }
     bool bubbles() { return is_keyframes() || is_media(); }
     bool is_media() {
       return keyword_.compare("@-webkit-media") == 0 ||
@@ -542,6 +616,7 @@ namespace Sass {
              keyword_.compare("@-o-keyframes") == 0 ||
              keyword_.compare("@keyframes") == 0;
     }
+    ATTACH_AST_OPERATIONS(Directive)
     ATTACH_OPERATIONS()
   };
 
@@ -549,11 +624,17 @@ namespace Sass {
   // Keyframe-rules -- the child blocks of "@keyframes" nodes.
   ///////////////////////////////////////////////////////////////////////
   class Keyframe_Rule : public Has_Block {
-    ADD_PROPERTY(Selector*, selector)
+    // according to css spec, this should be <keyframes-name>
+    // <keyframes-name> = <custom-ident> | <string>
+    ADD_PROPERTY(Selector_Obj, name)
   public:
-    Keyframe_Rule(ParserState pstate, Block* b)
-    : Has_Block(pstate, b), selector_(0)
+    Keyframe_Rule(ParserState pstate, Block_Obj b)
+    : Has_Block(pstate, b), name_()
+    { statement_type(KEYFRAMERULE); }
+    Keyframe_Rule(const Keyframe_Rule* ptr)
+    : Has_Block(ptr), name_(ptr->name_)
     { statement_type(KEYFRAMERULE); }
+    ATTACH_AST_OPERATIONS(Keyframe_Rule)
     ATTACH_OPERATIONS()
   };
 
@@ -561,15 +642,23 @@ namespace Sass {
   // Declarations -- style rules consisting of a property name and values.
   ////////////////////////////////////////////////////////////////////////
   class Declaration : public Has_Block {
-    ADD_PROPERTY(String*, property)
-    ADD_PROPERTY(Expression*, value)
+    ADD_PROPERTY(String_Obj, property)
+    ADD_PROPERTY(Expression_Obj, value)
     ADD_PROPERTY(bool, is_important)
     ADD_PROPERTY(bool, is_indented)
   public:
     Declaration(ParserState pstate,
-                String* prop, Expression* val, bool i = false, Block* b = 0)
+                String_Obj prop, Expression_Obj val, bool i = false, Block_Obj b = 0)
     : Has_Block(pstate, b), property_(prop), value_(val), is_important_(i), is_indented_(false)
     { statement_type(DECLARATION); }
+    Declaration(const Declaration* ptr)
+    : Has_Block(ptr),
+      property_(ptr->property_),
+      value_(ptr->value_),
+      is_important_(ptr->is_important_),
+      is_indented_(ptr->is_indented_)
+    { statement_type(DECLARATION); }
+    ATTACH_AST_OPERATIONS(Declaration)
     ATTACH_OPERATIONS()
   };
 
@@ -578,16 +667,24 @@ namespace Sass {
   /////////////////////////////////////
   class Assignment : public Statement {
     ADD_PROPERTY(std::string, variable)
-    ADD_PROPERTY(Expression*, value)
+    ADD_PROPERTY(Expression_Obj, value)
     ADD_PROPERTY(bool, is_default)
     ADD_PROPERTY(bool, is_global)
   public:
     Assignment(ParserState pstate,
-               std::string var, Expression* val,
+               std::string var, Expression_Obj val,
                bool is_default = false,
                bool is_global = false)
     : Statement(pstate), variable_(var), value_(val), is_default_(is_default), is_global_(is_global)
     { statement_type(ASSIGNMENT); }
+    Assignment(const Assignment* ptr)
+    : Statement(ptr),
+      variable_(ptr->variable_),
+      value_(ptr->value_),
+      is_default_(ptr->is_default_),
+      is_global_(ptr->is_global_)
+    { statement_type(ASSIGNMENT); }
+    ATTACH_AST_OPERATIONS(Assignment)
     ATTACH_OPERATIONS()
   };
 
@@ -596,18 +693,25 @@ namespace Sass {
   // necessary to store a list of each in an Import node.
   ////////////////////////////////////////////////////////////////////////////
   class Import : public Statement {
-    std::vector<Expression*> urls_;
+    std::vector<Expression_Obj> urls_;
     std::vector<Include>     incs_;
-    ADD_PROPERTY(List*,      media_queries);
+    ADD_PROPERTY(List_Obj,      import_queries);
   public:
     Import(ParserState pstate)
     : Statement(pstate),
-      urls_(std::vector<Expression*>()),
+      urls_(std::vector<Expression_Obj>()),
       incs_(std::vector<Include>()),
-      media_queries_(0)
+      import_queries_()
     { statement_type(IMPORT); }
-    std::vector<Expression*>& urls() { return urls_; }
+    Import(const Import* ptr)
+    : Statement(ptr),
+      urls_(ptr->urls_),
+      incs_(ptr->incs_),
+      import_queries_(ptr->import_queries_)
+    { statement_type(IMPORT); }
+    std::vector<Expression_Obj>& urls() { return urls_; }
     std::vector<Include>& incs() { return incs_; }
+    ATTACH_AST_OPERATIONS(Import)
     ATTACH_OPERATIONS()
   };
 
@@ -623,6 +727,10 @@ namespace Sass {
     Import_Stub(ParserState pstate, Include res)
     : Statement(pstate), resource_(res)
     { statement_type(IMPORT_STUB); }
+    Import_Stub(const Import_Stub* ptr)
+    : Statement(ptr), resource_(ptr->resource_)
+    { statement_type(IMPORT_STUB); }
+    ATTACH_AST_OPERATIONS(Import_Stub)
     ATTACH_OPERATIONS()
   };
 
@@ -630,11 +738,15 @@ namespace Sass {
   // The Sass `@warn` directive.
   //////////////////////////////
   class Warning : public Statement {
-    ADD_PROPERTY(Expression*, message)
+    ADD_PROPERTY(Expression_Obj, message)
   public:
-    Warning(ParserState pstate, Expression* msg)
+    Warning(ParserState pstate, Expression_Obj msg)
     : Statement(pstate), message_(msg)
     { statement_type(WARNING); }
+    Warning(const Warning* ptr)
+    : Statement(ptr), message_(ptr->message_)
+    { statement_type(WARNING); }
+    ATTACH_AST_OPERATIONS(Warning)
     ATTACH_OPERATIONS()
   };
 
@@ -642,11 +754,15 @@ namespace Sass {
   // The Sass `@error` directive.
   ///////////////////////////////
   class Error : public Statement {
-    ADD_PROPERTY(Expression*, message)
+    ADD_PROPERTY(Expression_Obj, message)
   public:
-    Error(ParserState pstate, Expression* msg)
+    Error(ParserState pstate, Expression_Obj msg)
     : Statement(pstate), message_(msg)
     { statement_type(ERROR); }
+    Error(const Error* ptr)
+    : Statement(ptr), message_(ptr->message_)
+    { statement_type(ERROR); }
+    ATTACH_AST_OPERATIONS(Error)
     ATTACH_OPERATIONS()
   };
 
@@ -654,11 +770,15 @@ namespace Sass {
   // The Sass `@debug` directive.
   ///////////////////////////////
   class Debug : public Statement {
-    ADD_PROPERTY(Expression*, value)
+    ADD_PROPERTY(Expression_Obj, value)
   public:
-    Debug(ParserState pstate, Expression* val)
+    Debug(ParserState pstate, Expression_Obj val)
     : Statement(pstate), value_(val)
     { statement_type(DEBUGSTMT); }
+    Debug(const Debug* ptr)
+    : Statement(ptr), value_(ptr->value_)
+    { statement_type(DEBUGSTMT); }
+    ATTACH_AST_OPERATIONS(Debug)
     ATTACH_OPERATIONS()
   };
 
@@ -666,14 +786,20 @@ namespace Sass {
   // CSS comments. These may be interpolated.
   ///////////////////////////////////////////
   class Comment : public Statement {
-    ADD_PROPERTY(String*, text)
+    ADD_PROPERTY(String_Obj, text)
     ADD_PROPERTY(bool, is_important)
   public:
-    Comment(ParserState pstate, String* txt, bool is_important)
+    Comment(ParserState pstate, String_Obj txt, bool is_important)
     : Statement(pstate), text_(txt), is_important_(is_important)
     { statement_type(COMMENT); }
+    Comment(const Comment* ptr)
+    : Statement(ptr),
+      text_(ptr->text_),
+      is_important_(ptr->is_important_)
+    { statement_type(COMMENT); }
     virtual bool is_invisible() const
     { return /* is_important() == */ false; }
+    ATTACH_AST_OPERATIONS(Comment)
     ATTACH_OPERATIONS()
   };
 
@@ -681,16 +807,22 @@ namespace Sass {
   // The Sass `@if` control directive.
   ////////////////////////////////////
   class If : public Has_Block {
-    ADD_PROPERTY(Expression*, predicate)
-    ADD_PROPERTY(Block*, alternative)
+    ADD_PROPERTY(Expression_Obj, predicate)
+    ADD_PROPERTY(Block_Obj, alternative)
   public:
-    If(ParserState pstate, Expression* pred, Block* con, Block* alt = 0)
-    : Has_Block(pstate, con), predicate_(pred), alternative_(alt)
+    If(ParserState pstate, Expression_Obj pred, Block_Obj con, Block_Obj alt = 0)
+    : Has_Block(pstate, &con), predicate_(pred), alternative_(alt)
+    { statement_type(IF); }
+    If(const If* ptr)
+    : Has_Block(ptr),
+      predicate_(ptr->predicate_),
+      alternative_(ptr->alternative_)
     { statement_type(IF); }
     virtual bool has_content()
     {
       return Has_Block::has_content() || (alternative_ && alternative_->has_content());
     }
+    ATTACH_AST_OPERATIONS(If)
     ATTACH_OPERATIONS()
   };
 
@@ -699,15 +831,23 @@ namespace Sass {
   /////////////////////////////////////
   class For : public Has_Block {
     ADD_PROPERTY(std::string, variable)
-    ADD_PROPERTY(Expression*, lower_bound)
-    ADD_PROPERTY(Expression*, upper_bound)
+    ADD_PROPERTY(Expression_Obj, lower_bound)
+    ADD_PROPERTY(Expression_Obj, upper_bound)
     ADD_PROPERTY(bool, is_inclusive)
   public:
     For(ParserState pstate,
-        std::string var, Expression* lo, Expression* hi, Block* b, bool inc)
+        std::string var, Expression_Obj lo, Expression_Obj hi, Block_Obj b, bool inc)
     : Has_Block(pstate, b),
       variable_(var), lower_bound_(lo), upper_bound_(hi), is_inclusive_(inc)
     { statement_type(FOR); }
+    For(const For* ptr)
+    : Has_Block(ptr),
+      variable_(ptr->variable_),
+      lower_bound_(ptr->lower_bound_),
+      upper_bound_(ptr->upper_bound_),
+      is_inclusive_(ptr->is_inclusive_)
+    { statement_type(FOR); }
+    ATTACH_AST_OPERATIONS(For)
     ATTACH_OPERATIONS()
   };
 
@@ -716,11 +856,15 @@ namespace Sass {
   //////////////////////////////////////
   class Each : public Has_Block {
     ADD_PROPERTY(std::vector<std::string>, variables)
-    ADD_PROPERTY(Expression*, list)
+    ADD_PROPERTY(Expression_Obj, list)
   public:
-    Each(ParserState pstate, std::vector<std::string> vars, Expression* lst, Block* b)
+    Each(ParserState pstate, std::vector<std::string> vars, Expression_Obj lst, Block_Obj b)
     : Has_Block(pstate, b), variables_(vars), list_(lst)
     { statement_type(EACH); }
+    Each(const Each* ptr)
+    : Has_Block(ptr), variables_(ptr->variables_), list_(ptr->list_)
+    { statement_type(EACH); }
+    ATTACH_AST_OPERATIONS(Each)
     ATTACH_OPERATIONS()
   };
 
@@ -728,11 +872,15 @@ namespace Sass {
   // The Sass `@while` control directive.
   ///////////////////////////////////////
   class While : public Has_Block {
-    ADD_PROPERTY(Expression*, predicate)
+    ADD_PROPERTY(Expression_Obj, predicate)
   public:
-    While(ParserState pstate, Expression* pred, Block* b)
+    While(ParserState pstate, Expression_Obj pred, Block_Obj b)
     : Has_Block(pstate, b), predicate_(pred)
     { statement_type(WHILE); }
+    While(const While* ptr)
+    : Has_Block(ptr), predicate_(ptr->predicate_)
+    { statement_type(WHILE); }
+    ATTACH_AST_OPERATIONS(While)
     ATTACH_OPERATIONS()
   };
 
@@ -740,11 +888,15 @@ namespace Sass {
   // The @return directive for use inside SassScript functions.
   /////////////////////////////////////////////////////////////
   class Return : public Statement {
-    ADD_PROPERTY(Expression*, value)
+    ADD_PROPERTY(Expression_Obj, value)
   public:
-    Return(ParserState pstate, Expression* val)
+    Return(ParserState pstate, Expression_Obj val)
     : Statement(pstate), value_(val)
     { statement_type(RETURN); }
+    Return(const Return* ptr)
+    : Statement(ptr), value_(ptr->value_)
+    { statement_type(RETURN); }
+    ATTACH_AST_OPERATIONS(Return)
     ATTACH_OPERATIONS()
   };
 
@@ -752,11 +904,15 @@ namespace Sass {
   // The Sass `@extend` directive.
   ////////////////////////////////
   class Extension : public Statement {
-    ADD_PROPERTY(Selector*, selector)
+    ADD_PROPERTY(Selector_Obj, selector)
   public:
-    Extension(ParserState pstate, Selector* s)
+    Extension(ParserState pstate, Selector_Obj s)
     : Statement(pstate), selector_(s)
     { statement_type(EXTEND); }
+    Extension(const Extension* ptr)
+    : Statement(ptr), selector_(ptr->selector_)
+    { statement_type(EXTEND); }
+    ATTACH_AST_OPERATIONS(Extension)
     ATTACH_OPERATIONS()
   };
 
@@ -765,15 +921,14 @@ namespace Sass {
   // by a type tag.
   /////////////////////////////////////////////////////////////////////////////
   struct Backtrace;
-  typedef Environment<AST_Node*> Env;
-  typedef const char* Signature;
-  typedef Expression* (*Native_Function)(Env&, Env&, Context&, Signature, ParserState, Backtrace*, std::vector<CommaSequence_Selector*>);
+  typedef Environment<AST_Node_Obj> Env;
   typedef const char* Signature;
+  typedef Expression_Ptr (*Native_Function)(Env&, Env&, Context&, Signature, ParserState, Backtrace*, std::vector<Selector_List_Obj>);
   class Definition : public Has_Block {
   public:
     enum Type { MIXIN, FUNCTION };
     ADD_PROPERTY(std::string, name)
-    ADD_PROPERTY(Parameters*, parameters)
+    ADD_PROPERTY(Parameters_Obj, parameters)
     ADD_PROPERTY(Env*, environment)
     ADD_PROPERTY(Type, type)
     ADD_PROPERTY(Native_Function, native_function)
@@ -782,10 +937,23 @@ namespace Sass {
     ADD_PROPERTY(bool, is_overload_stub)
     ADD_PROPERTY(Signature, signature)
   public:
+    Definition(const Definition* ptr)
+    : Has_Block(ptr),
+      name_(ptr->name_),
+      parameters_(ptr->parameters_),
+      environment_(ptr->environment_),
+      type_(ptr->type_),
+      native_function_(ptr->native_function_),
+      c_function_(ptr->c_function_),
+      cookie_(ptr->cookie_),
+      is_overload_stub_(ptr->is_overload_stub_),
+      signature_(ptr->signature_)
+    { }
+
     Definition(ParserState pstate,
                std::string n,
-               Parameters* params,
-               Block* b,
+               Parameters_Obj params,
+               Block_Obj b,
                Type t)
     : Has_Block(pstate, b),
       name_(n),
@@ -801,7 +969,7 @@ namespace Sass {
     Definition(ParserState pstate,
                Signature sig,
                std::string n,
-               Parameters* params,
+               Parameters_Obj params,
                Native_Function func_ptr,
                bool overload_stub = false)
     : Has_Block(pstate, 0),
@@ -818,7 +986,7 @@ namespace Sass {
     Definition(ParserState pstate,
                Signature sig,
                std::string n,
-               Parameters* params,
+               Parameters_Obj params,
                Sass_Function_Entry c_func,
                bool whatever,
                bool whatever2)
@@ -833,6 +1001,7 @@ namespace Sass {
       is_overload_stub_(false),
       signature_(sig)
     { }
+    ATTACH_AST_OPERATIONS(Definition)
     ATTACH_OPERATIONS()
   };
 
@@ -841,11 +1010,17 @@ namespace Sass {
   //////////////////////////////////////
   class Mixin_Call : public Has_Block {
     ADD_PROPERTY(std::string, name)
-    ADD_PROPERTY(Arguments*, arguments)
+    ADD_PROPERTY(Arguments_Obj, arguments)
   public:
-    Mixin_Call(ParserState pstate, std::string n, Arguments* args, Block* b = 0)
+    Mixin_Call(ParserState pstate, std::string n, Arguments_Obj args, Block_Obj b = 0)
     : Has_Block(pstate, b), name_(n), arguments_(args)
     { }
+    Mixin_Call(const Mixin_Call* ptr)
+    : Has_Block(ptr),
+      name_(ptr->name_),
+      arguments_(ptr->arguments_)
+    { }
+    ATTACH_AST_OPERATIONS(Mixin_Call)
     ATTACH_OPERATIONS()
   };
 
@@ -853,10 +1028,13 @@ namespace Sass {
   // The @content directive for mixin content blocks.
   ///////////////////////////////////////////////////
   class Content : public Statement {
-    ADD_PROPERTY(Media_Block*, media_block)
+    ADD_PROPERTY(Media_Block_Obj, media_block)
   public:
     Content(ParserState pstate) : Statement(pstate)
     { statement_type(CONTENT); }
+    Content(const Content* ptr) : Statement(ptr)
+    { statement_type(CONTENT); }
+    ATTACH_AST_OPERATIONS(Content)
     ATTACH_OPERATIONS()
   };
 
@@ -864,8 +1042,8 @@ namespace Sass {
   // Lists of values, both comma- and space-separated (distinguished by a
   // type-tag.) Also used to represent variable-length argument lists.
   ///////////////////////////////////////////////////////////////////////
-  class List : public Value, public Vectorized<Expression*> {
-    void adjust_after_pushing(Expression* e) { is_expanded(false); }
+  class List : public Value, public Vectorized<Expression_Obj> {
+    void adjust_after_pushing(Expression_Obj e) { is_expanded(false); }
   private:
     ADD_PROPERTY(enum Sass_Separator, separator)
     ADD_PROPERTY(bool, is_arglist)
@@ -874,11 +1052,18 @@ namespace Sass {
     List(ParserState pstate,
          size_t size = 0, enum Sass_Separator sep = SASS_SPACE, bool argl = false)
     : Value(pstate),
-      Vectorized<Expression*>(size),
+      Vectorized<Expression_Obj>(size),
       separator_(sep),
       is_arglist_(argl),
       from_selector_(false)
     { concrete_type(LIST); }
+    List(const List* ptr)
+    : Value(ptr),
+      Vectorized<Expression_Obj>(*ptr),
+      separator_(ptr->separator_),
+      is_arglist_(ptr->is_arglist_),
+      from_selector_(ptr->from_selector_)
+    { concrete_type(LIST); }
     std::string type() { return is_arglist_ ? "arglist" : "list"; }
     static std::string type_name() { return "list"; }
     const char* sep_string(bool compressed = false) const {
@@ -886,7 +1071,7 @@ namespace Sass {
         " " : (compressed ? "," : ", ");
     }
     bool is_invisible() const { return empty(); }
-    Expression* value_at_index(size_t i);
+    Expression_Obj value_at_index(size_t i);
 
     virtual size_t size() const;
 
@@ -908,6 +1093,7 @@ namespace Sass {
 
     virtual bool operator== (const Expression& rhs) const;
 
+    ATTACH_AST_OPERATIONS(List)
     ATTACH_OPERATIONS()
   };
 
@@ -915,17 +1101,21 @@ namespace Sass {
   // Key value paris.
   ///////////////////////////////////////////////////////////////////////
   class Map : public Value, public Hashed {
-    void adjust_after_pushing(std::pair<Expression*, Expression*> p) { is_expanded(false); }
+    void adjust_after_pushing(std::pair<Expression_Obj, Expression_Obj> p) { is_expanded(false); }
   public:
     Map(ParserState pstate,
          size_t size = 0)
     : Value(pstate),
       Hashed(size)
     { concrete_type(MAP); }
+    Map(const Map* ptr)
+    : Value(ptr),
+      Hashed(*ptr)
+    { concrete_type(MAP); }
     std::string type() { return "map"; }
     static std::string type_name() { return "map"; }
     bool is_invisible() const { return empty(); }
-    List* to_list(Context& ctx, ParserState& pstate);
+    List_Obj to_list(Context& ctx, ParserState& pstate);
 
     virtual size_t hash()
     {
@@ -941,6 +1131,7 @@ namespace Sass {
 
     virtual bool operator== (const Expression& rhs) const;
 
+    ATTACH_AST_OPERATIONS(Map)
     ATTACH_OPERATIONS()
   };
 
@@ -973,14 +1164,21 @@ namespace Sass {
   class Binary_Expression : public PreValue {
   private:
     ADD_HASHED(Operand, op)
-    ADD_HASHED(Expression*, left)
-    ADD_HASHED(Expression*, right)
+    ADD_HASHED(Expression_Obj, left)
+    ADD_HASHED(Expression_Obj, right)
     size_t hash_;
   public:
     Binary_Expression(ParserState pstate,
-                      Operand op, Expression* lhs, Expression* rhs)
+                      Operand op, Expression_Obj lhs, Expression_Obj rhs)
     : PreValue(pstate), op_(op), left_(lhs), right_(rhs), hash_(0)
     { }
+    Binary_Expression(const Binary_Expression* ptr)
+    : PreValue(ptr),
+      op_(ptr->op_),
+      left_(ptr->left_),
+      right_(ptr->right_),
+      hash_(ptr->hash_)
+    { }
     const std::string type_name() {
       switch (type()) {
         case AND: return "and"; break;
@@ -1038,7 +1236,7 @@ namespace Sass {
     {
       try
       {
-        const Binary_Expression* m = dynamic_cast<const Binary_Expression*>(&rhs);
+        Binary_Expression_Ptr_Const m = dynamic_cast<Binary_Expression_Ptr_Const>(&rhs);
         if (m == 0) return false;
         return type() == m->type() &&
                left() == m->left() &&
@@ -1060,6 +1258,7 @@ namespace Sass {
       return hash_;
     }
     enum Sass_OP type() const { return op_.operand; }
+    ATTACH_AST_OPERATIONS(Binary_Expression)
     ATTACH_OPERATIONS()
   };
 
@@ -1071,12 +1270,18 @@ namespace Sass {
     enum Type { PLUS, MINUS, NOT };
   private:
     ADD_HASHED(Type, type)
-    ADD_HASHED(Expression*, operand)
+    ADD_HASHED(Expression_Obj, operand)
     size_t hash_;
   public:
-    Unary_Expression(ParserState pstate, Type t, Expression* o)
+    Unary_Expression(ParserState pstate, Type t, Expression_Obj o)
     : Expression(pstate), type_(t), operand_(o), hash_(0)
     { }
+    Unary_Expression(const Unary_Expression* ptr)
+    : Expression(ptr),
+      type_(ptr->type_),
+      operand_(ptr->operand_),
+      hash_(ptr->hash_)
+    { }
     const std::string type_name() {
       switch (type_) {
         case PLUS: return "plus"; break;
@@ -1089,7 +1294,7 @@ namespace Sass {
     {
       try
       {
-        const Unary_Expression* m = dynamic_cast<const Unary_Expression*>(&rhs);
+        Unary_Expression_Ptr_Const m = dynamic_cast<Unary_Expression_Ptr_Const>(&rhs);
         if (m == 0) return false;
         return type() == m->type() &&
                operand() == m->operand();
@@ -1108,6 +1313,7 @@ namespace Sass {
       };
       return hash_;
     }
+    ATTACH_AST_OPERATIONS(Unary_Expression)
     ATTACH_OPERATIONS()
   };
 
@@ -1115,17 +1321,29 @@ namespace Sass {
   // Individual argument objects for mixin and function calls.
   ////////////////////////////////////////////////////////////
   class Argument : public Expression {
-    ADD_HASHED(Expression*, value)
+    ADD_HASHED(Expression_Obj, value)
     ADD_HASHED(std::string, name)
     ADD_PROPERTY(bool, is_rest_argument)
     ADD_PROPERTY(bool, is_keyword_argument)
     size_t hash_;
   public:
-    Argument(ParserState pstate, Expression* val, std::string n = "", bool rest = false, bool keyword = false)
+    Argument(ParserState pstate, Expression_Obj val, std::string n = "", bool rest = false, bool keyword = false)
     : Expression(pstate), value_(val), name_(n), is_rest_argument_(rest), is_keyword_argument_(keyword), hash_(0)
     {
       if (!name_.empty() && is_rest_argument_) {
-        error("variable-length argument may not be passed by name", pstate);
+        error("variable-length argument may not be passed by name", pstate_);
+      }
+    }
+    Argument(const Argument* ptr)
+    : Expression(ptr),
+      value_(ptr->value_),
+      name_(ptr->name_),
+      is_rest_argument_(ptr->is_rest_argument_),
+      is_keyword_argument_(ptr->is_keyword_argument_),
+      hash_(ptr->hash_)
+    {
+      if (!name_.empty() && is_rest_argument_) {
+        error("variable-length argument may not be passed by name", pstate_);
       }
     }
 
@@ -1134,7 +1352,7 @@ namespace Sass {
     {
       try
       {
-        const Argument* m = dynamic_cast<const Argument*>(&rhs);
+        Argument_Ptr_Const m = dynamic_cast<Argument_Ptr_Const>(&rhs);
         if (!(m && name() == m->name())) return false;
         return *value() == *m->value();
       }
@@ -1154,6 +1372,7 @@ namespace Sass {
       return hash_;
     }
 
+    ATTACH_AST_OPERATIONS(Argument)
     ATTACH_OPERATIONS()
   };
 
@@ -1162,26 +1381,34 @@ namespace Sass {
   // error checking (e.g., ensuring that all ordinal arguments precede all
   // named arguments).
   ////////////////////////////////////////////////////////////////////////
-  class Arguments : public Expression, public Vectorized<Argument*> {
+  class Arguments : public Expression, public Vectorized<Argument_Obj> {
     ADD_PROPERTY(bool, has_named_arguments)
     ADD_PROPERTY(bool, has_rest_argument)
     ADD_PROPERTY(bool, has_keyword_argument)
   protected:
-    void adjust_after_pushing(Argument* a);
+    void adjust_after_pushing(Argument_Obj a);
   public:
     Arguments(ParserState pstate)
     : Expression(pstate),
-      Vectorized<Argument*>(),
+      Vectorized<Argument_Obj>(),
       has_named_arguments_(false),
       has_rest_argument_(false),
       has_keyword_argument_(false)
     { }
+    Arguments(const Arguments* ptr)
+    : Expression(ptr),
+      Vectorized<Argument_Obj>(*ptr),
+      has_named_arguments_(ptr->has_named_arguments_),
+      has_rest_argument_(ptr->has_rest_argument_),
+      has_keyword_argument_(ptr->has_keyword_argument_)
+    { }
 
     virtual void set_delayed(bool delayed);
 
-    Argument* get_rest_argument();
-    Argument* get_keyword_argument();
+    Argument_Obj get_rest_argument();
+    Argument_Obj get_keyword_argument();
 
+    ATTACH_AST_OPERATIONS(Arguments)
     ATTACH_OPERATIONS()
   };
 
@@ -1190,22 +1417,31 @@ namespace Sass {
   //////////////////
   class Function_Call : public PreValue {
     ADD_HASHED(std::string, name)
-    ADD_HASHED(Arguments*, arguments)
+    ADD_HASHED(Arguments_Obj, arguments)
+    ADD_PROPERTY(bool, via_call)
     ADD_PROPERTY(void*, cookie)
     size_t hash_;
   public:
-    Function_Call(ParserState pstate, std::string n, Arguments* args, void* cookie)
-    : PreValue(pstate), name_(n), arguments_(args), cookie_(cookie), hash_(0)
-    { concrete_type(STRING); }
-    Function_Call(ParserState pstate, std::string n, Arguments* args)
-    : PreValue(pstate), name_(n), arguments_(args), cookie_(0), hash_(0)
-    { concrete_type(STRING); }
+    Function_Call(ParserState pstate, std::string n, Arguments_Obj args, void* cookie)
+    : PreValue(pstate), name_(n), arguments_(args), via_call_(false), cookie_(cookie), hash_(0)
+    { concrete_type(FUNCTION); }
+    Function_Call(ParserState pstate, std::string n, Arguments_Obj args)
+    : PreValue(pstate), name_(n), arguments_(args), via_call_(false), cookie_(0), hash_(0)
+    { concrete_type(FUNCTION); }
+    Function_Call(const Function_Call* ptr)
+    : PreValue(ptr),
+      name_(ptr->name_),
+      arguments_(ptr->arguments_),
+      via_call_(ptr->via_call_),
+      cookie_(ptr->cookie_),
+      hash_(ptr->hash_)
+    { concrete_type(FUNCTION); }
 
     virtual bool operator==(const Expression& rhs) const
     {
       try
       {
-        const Function_Call* m = dynamic_cast<const Function_Call*>(&rhs);
+        Function_Call_Ptr_Const m = dynamic_cast<Function_Call_Ptr_Const>(&rhs);
         if (!(m && name() == m->name())) return false;
         if (!(m && arguments()->length() == m->arguments()->length())) return false;
         for (size_t i =0, L = arguments()->length(); i < L; ++i)
@@ -1228,7 +1464,7 @@ namespace Sass {
       }
       return hash_;
     }
-
+    ATTACH_AST_OPERATIONS(Function_Call)
     ATTACH_OPERATIONS()
   };
 
@@ -1236,12 +1472,18 @@ namespace Sass {
   // Function call schemas.
   /////////////////////////
   class Function_Call_Schema : public Expression {
-    ADD_PROPERTY(String*, name)
-    ADD_PROPERTY(Arguments*, arguments)
+    ADD_PROPERTY(String_Obj, name)
+    ADD_PROPERTY(Arguments_Obj, arguments)
   public:
-    Function_Call_Schema(ParserState pstate, String* n, Arguments* args)
+    Function_Call_Schema(ParserState pstate, String_Obj n, Arguments_Obj args)
     : Expression(pstate), name_(n), arguments_(args)
     { concrete_type(STRING); }
+    Function_Call_Schema(const Function_Call_Schema* ptr)
+    : Expression(ptr),
+      name_(ptr->name_),
+      arguments_(ptr->arguments_)
+    { concrete_type(STRING); }
+    ATTACH_AST_OPERATIONS(Function_Call_Schema)
     ATTACH_OPERATIONS()
   };
 
@@ -1254,12 +1496,15 @@ namespace Sass {
     Variable(ParserState pstate, std::string n)
     : PreValue(pstate), name_(n)
     { }
+    Variable(const Variable* ptr)
+    : PreValue(ptr), name_(ptr->name_)
+    { }
 
     virtual bool operator==(const Expression& rhs) const
     {
       try
       {
-        const Variable* e = dynamic_cast<const Variable*>(&rhs);
+        Variable_Ptr_Const e = dynamic_cast<Variable_Ptr_Const>(&rhs);
         return e && name() == e->name();
       }
       catch (std::bad_cast&)
@@ -1274,6 +1519,7 @@ namespace Sass {
       return std::hash<std::string>()(name());
     }
 
+    ATTACH_AST_OPERATIONS(Variable)
     ATTACH_OPERATIONS()
   };
 
@@ -1293,12 +1539,18 @@ namespace Sass {
     : Expression(pstate, DELAYED), type_(t), value_(val),
       hash_(0)
     { }
+    Textual(const Textual* ptr)
+    : Expression(ptr),
+      type_(ptr->type_),
+      value_(ptr->value_),
+      hash_(ptr->hash_)
+    { }
 
     virtual bool operator==(const Expression& rhs) const
     {
       try
       {
-        const Textual* e = dynamic_cast<const Textual*>(&rhs);
+        Textual_Ptr_Const e = dynamic_cast<Textual_Ptr_Const>(&rhs);
         return e && value() == e->value() && type() == e->type();
       }
       catch (std::bad_cast&)
@@ -1317,6 +1569,7 @@ namespace Sass {
       return hash_;
     }
 
+    ATTACH_AST_OPERATIONS(Textual)
     ATTACH_OPERATIONS()
   };
 
@@ -1331,6 +1584,15 @@ namespace Sass {
     size_t hash_;
   public:
     Number(ParserState pstate, double val, std::string u = "", bool zero = true);
+
+    Number(const Number* ptr)
+    : Value(ptr),
+      value_(ptr->value_), zero_(ptr->zero_),
+      numerator_units_(ptr->numerator_units_),
+      denominator_units_(ptr->denominator_units_),
+      hash_(ptr->hash_)
+    { concrete_type(NUMBER); }
+
     bool zero() { return zero_; }
     bool is_valid_css_unit() const;
     std::vector<std::string>& numerator_units()   { return numerator_units_; }
@@ -1363,7 +1625,7 @@ namespace Sass {
     virtual bool operator< (const Number& rhs) const;
     virtual bool operator== (const Expression& rhs) const;
     virtual bool eq(const Expression& rhs) const;
-
+    ATTACH_AST_OPERATIONS(Number)
     ATTACH_OPERATIONS()
   };
 
@@ -1382,6 +1644,15 @@ namespace Sass {
     : Value(pstate), r_(r), g_(g), b_(b), a_(a), disp_(disp),
       hash_(0)
     { concrete_type(COLOR); }
+    Color(const Color* ptr)
+    : Value(ptr),
+      r_(ptr->r_),
+      g_(ptr->g_),
+      b_(ptr->b_),
+      a_(ptr->a_),
+      disp_(ptr->disp_),
+      hash_(ptr->hash_)
+    { concrete_type(COLOR); }
     std::string type() { return "color"; }
     static std::string type_name() { return "color"; }
 
@@ -1398,6 +1669,7 @@ namespace Sass {
 
     virtual bool operator== (const Expression& rhs) const;
 
+    ATTACH_AST_OPERATIONS(Color)
     ATTACH_OPERATIONS()
   };
 
@@ -1410,7 +1682,11 @@ namespace Sass {
     Custom_Error(ParserState pstate, std::string msg)
     : Value(pstate), message_(msg)
     { concrete_type(C_ERROR); }
+    Custom_Error(const Custom_Error* ptr)
+    : Value(ptr), message_(ptr->message_)
+    { concrete_type(C_ERROR); }
     virtual bool operator== (const Expression& rhs) const;
+    ATTACH_AST_OPERATIONS(Custom_Error)
     ATTACH_OPERATIONS()
   };
 
@@ -1423,7 +1699,11 @@ namespace Sass {
     Custom_Warning(ParserState pstate, std::string msg)
     : Value(pstate), message_(msg)
     { concrete_type(C_WARNING); }
+    Custom_Warning(const Custom_Warning* ptr)
+    : Value(ptr), message_(ptr->message_)
+    { concrete_type(C_WARNING); }
     virtual bool operator== (const Expression& rhs) const;
+    ATTACH_AST_OPERATIONS(Custom_Warning)
     ATTACH_OPERATIONS()
   };
 
@@ -1438,6 +1718,11 @@ namespace Sass {
     : Value(pstate), value_(val),
       hash_(0)
     { concrete_type(BOOLEAN); }
+    Boolean(const Boolean* ptr)
+    : Value(ptr),
+      value_(ptr->value_),
+      hash_(ptr->hash_)
+    { concrete_type(BOOLEAN); }
     virtual operator bool() { return value_; }
     std::string type() { return "bool"; }
     static std::string type_name() { return "bool"; }
@@ -1453,6 +1738,7 @@ namespace Sass {
 
     virtual bool operator== (const Expression& rhs) const;
 
+    ATTACH_AST_OPERATIONS(Boolean)
     ATTACH_OPERATIONS()
   };
 
@@ -1465,12 +1751,19 @@ namespace Sass {
     String(ParserState pstate, bool delayed = false)
     : Value(pstate, delayed)
     { concrete_type(STRING); }
+    String(const String* ptr)
+    : Value(ptr)
+    { concrete_type(STRING); }
     static std::string type_name() { return "string"; }
     virtual ~String() = 0;
     virtual void rtrim() = 0;
     virtual void ltrim() = 0;
     virtual void trim() = 0;
     virtual bool operator==(const Expression& rhs) const = 0;
+    virtual bool operator<(const Expression& rhs) const {
+      return this->to_string() < rhs.to_string();
+    };
+    ATTACH_VIRTUAL_AST_OPERATIONS(String);
     ATTACH_OPERATIONS()
   };
   inline String::~String() { };
@@ -1479,13 +1772,19 @@ namespace Sass {
   // Interpolated strings. Meant to be reduced to flat strings during the
   // evaluation phase.
   ///////////////////////////////////////////////////////////////////////
-  class String_Schema : public String, public Vectorized<Expression*> {
+  class String_Schema : public String, public Vectorized<Expression_Obj> {
     // ADD_PROPERTY(bool, has_interpolants)
     size_t hash_;
   public:
     String_Schema(ParserState pstate, size_t size = 0, bool has_interpolants = false)
-    : String(pstate), Vectorized<Expression*>(size), hash_(0)
+    : String(pstate), Vectorized<Expression_Obj>(size), hash_(0)
+    { concrete_type(STRING); }
+    String_Schema(const String_Schema* ptr)
+    : String(ptr),
+      Vectorized<Expression_Obj>(*ptr),
+      hash_(ptr->hash_)
     { concrete_type(STRING); }
+
     std::string type() { return "string"; }
     static std::string type_name() { return "string"; }
 
@@ -1516,7 +1815,7 @@ namespace Sass {
     }
 
     virtual bool operator==(const Expression& rhs) const;
-
+    ATTACH_AST_OPERATIONS(String_Schema)
     ATTACH_OPERATIONS()
   };
 
@@ -1530,6 +1829,13 @@ namespace Sass {
   protected:
     size_t hash_;
   public:
+    String_Constant(const String_Constant* ptr)
+    : String(ptr),
+      quote_mark_(ptr->quote_mark_),
+      can_compress_whitespace_(ptr->can_compress_whitespace_),
+      value_(ptr->value_),
+      hash_(ptr->hash_)
+    { }
     String_Constant(ParserState pstate, std::string val)
     : String(pstate), quote_mark_(0), can_compress_whitespace_(false), value_(read_css_string(val)), hash_(0)
     { }
@@ -1564,6 +1870,7 @@ namespace Sass {
     static char double_quote() { return '"'; }
     static char single_quote() { return '\''; }
 
+    ATTACH_AST_OPERATIONS(String_Constant)
     ATTACH_OPERATIONS()
   };
 
@@ -1573,8 +1880,8 @@ namespace Sass {
   class String_Quoted : public String_Constant {
   public:
     String_Quoted(ParserState pstate, std::string val, char q = 0,
-    	bool keep_utf8_escapes = false, bool skip_unquoting = false,
-    	bool strict_unquoting = true)
+      bool keep_utf8_escapes = false, bool skip_unquoting = false,
+      bool strict_unquoting = true)
     : String_Constant(pstate, val)
     {
       if (skip_unquoting == false) {
@@ -1582,8 +1889,12 @@ namespace Sass {
       }
       if (q && quote_mark_) quote_mark_ = q;
     }
+    String_Quoted(const String_Quoted* ptr)
+    : String_Constant(ptr)
+    { }
     virtual bool operator==(const Expression& rhs) const;
     virtual std::string inspect() const; // quotes are forced on inspection
+    ATTACH_AST_OPERATIONS(String_Quoted)
     ATTACH_OPERATIONS()
   };
 
@@ -1591,16 +1902,24 @@ namespace Sass {
   // Media queries.
   /////////////////
   class Media_Query : public Expression,
-                      public Vectorized<Media_Query_Expression*> {
-    ADD_PROPERTY(String*, media_type)
+                      public Vectorized<Media_Query_Expression_Obj> {
+    ADD_PROPERTY(String_Obj, media_type)
     ADD_PROPERTY(bool, is_negated)
     ADD_PROPERTY(bool, is_restricted)
   public:
     Media_Query(ParserState pstate,
-                String* t = 0, size_t s = 0, bool n = false, bool r = false)
-    : Expression(pstate), Vectorized<Media_Query_Expression*>(s),
+                String_Obj t = 0, size_t s = 0, bool n = false, bool r = false)
+    : Expression(pstate), Vectorized<Media_Query_Expression_Obj>(s),
       media_type_(t), is_negated_(n), is_restricted_(r)
     { }
+    Media_Query(const Media_Query* ptr)
+    : Expression(ptr),
+      Vectorized<Media_Query_Expression_Obj>(*ptr),
+      media_type_(ptr->media_type_),
+      is_negated_(ptr->is_negated_),
+      is_restricted_(ptr->is_restricted_)
+    { }
+    ATTACH_AST_OPERATIONS(Media_Query)
     ATTACH_OPERATIONS()
   };
 
@@ -1608,14 +1927,21 @@ namespace Sass {
   // Media expressions (for use inside media queries).
   ////////////////////////////////////////////////////
   class Media_Query_Expression : public Expression {
-    ADD_PROPERTY(Expression*, feature)
-    ADD_PROPERTY(Expression*, value)
+    ADD_PROPERTY(Expression_Obj, feature)
+    ADD_PROPERTY(Expression_Obj, value)
     ADD_PROPERTY(bool, is_interpolated)
   public:
     Media_Query_Expression(ParserState pstate,
-                           Expression* f, Expression* v, bool i = false)
+                           Expression_Obj f, Expression_Obj v, bool i = false)
     : Expression(pstate), feature_(f), value_(v), is_interpolated_(i)
     { }
+    Media_Query_Expression(const Media_Query_Expression* ptr)
+    : Expression(ptr),
+      feature_(ptr->feature_),
+      value_(ptr->value_),
+      is_interpolated_(ptr->is_interpolated_)
+    { }
+    ATTACH_AST_OPERATIONS(Media_Query_Expression)
     ATTACH_OPERATIONS()
   };
 
@@ -1623,12 +1949,16 @@ namespace Sass {
   // `@supports` rule.
   ////////////////////
   class Supports_Block : public Has_Block {
-    ADD_PROPERTY(Supports_Condition*, condition)
+    ADD_PROPERTY(Supports_Condition_Obj, condition)
   public:
-    Supports_Block(ParserState pstate, Supports_Condition* condition, Block* block = 0)
+    Supports_Block(ParserState pstate, Supports_Condition_Obj condition, Block_Obj block = 0)
     : Has_Block(pstate, block), condition_(condition)
     { statement_type(SUPPORTS); }
+    Supports_Block(const Supports_Block* ptr)
+    : Has_Block(ptr), condition_(ptr->condition_)
+    { statement_type(SUPPORTS); }
     bool bubbles() { return true; }
+    ATTACH_AST_OPERATIONS(Supports_Block)
     ATTACH_OPERATIONS()
   };
 
@@ -1640,7 +1970,11 @@ namespace Sass {
     Supports_Condition(ParserState pstate)
     : Expression(pstate)
     { }
-    virtual bool needs_parens(Supports_Condition* cond) const { return false; }
+    Supports_Condition(const Supports_Condition* ptr)
+    : Expression(ptr)
+    { }
+    virtual bool needs_parens(Supports_Condition_Obj cond) const { return false; }
+    ATTACH_AST_OPERATIONS(Supports_Condition)
     ATTACH_OPERATIONS()
   };
 
@@ -1651,14 +1985,21 @@ namespace Sass {
   public:
     enum Operand { AND, OR };
   private:
-    ADD_PROPERTY(Supports_Condition*, left);
-    ADD_PROPERTY(Supports_Condition*, right);
+    ADD_PROPERTY(Supports_Condition_Obj, left);
+    ADD_PROPERTY(Supports_Condition_Obj, right);
     ADD_PROPERTY(Operand, operand);
   public:
-    Supports_Operator(ParserState pstate, Supports_Condition* l, Supports_Condition* r, Operand o)
+    Supports_Operator(ParserState pstate, Supports_Condition_Obj l, Supports_Condition_Obj r, Operand o)
     : Supports_Condition(pstate), left_(l), right_(r), operand_(o)
     { }
-    virtual bool needs_parens(Supports_Condition* cond) const;
+    Supports_Operator(const Supports_Operator* ptr)
+    : Supports_Condition(ptr),
+      left_(ptr->left_),
+      right_(ptr->right_),
+      operand_(ptr->operand_)
+    { }
+    virtual bool needs_parens(Supports_Condition_Obj cond) const;
+    ATTACH_AST_OPERATIONS(Supports_Operator)
     ATTACH_OPERATIONS()
   };
 
@@ -1667,12 +2008,16 @@ namespace Sass {
   //////////////////////////////////////////
   class Supports_Negation : public Supports_Condition {
   private:
-    ADD_PROPERTY(Supports_Condition*, condition);
+    ADD_PROPERTY(Supports_Condition_Obj, condition);
   public:
-    Supports_Negation(ParserState pstate, Supports_Condition* c)
+    Supports_Negation(ParserState pstate, Supports_Condition_Obj c)
     : Supports_Condition(pstate), condition_(c)
     { }
-    virtual bool needs_parens(Supports_Condition* cond) const;
+    Supports_Negation(const Supports_Negation* ptr)
+    : Supports_Condition(ptr), condition_(ptr->condition_)
+    { }
+    virtual bool needs_parens(Supports_Condition_Obj cond) const;
+    ATTACH_AST_OPERATIONS(Supports_Negation)
     ATTACH_OPERATIONS()
   };
 
@@ -1681,13 +2026,19 @@ namespace Sass {
   /////////////////////////////////////////////////////
   class Supports_Declaration : public Supports_Condition {
   private:
-    ADD_PROPERTY(Expression*, feature);
-    ADD_PROPERTY(Expression*, value);
+    ADD_PROPERTY(Expression_Obj, feature);
+    ADD_PROPERTY(Expression_Obj, value);
   public:
-    Supports_Declaration(ParserState pstate, Expression* f, Expression* v)
+    Supports_Declaration(ParserState pstate, Expression_Obj f, Expression_Obj v)
     : Supports_Condition(pstate), feature_(f), value_(v)
     { }
-    virtual bool needs_parens(Supports_Condition* cond) const { return false; }
+    Supports_Declaration(const Supports_Declaration* ptr)
+    : Supports_Condition(ptr),
+      feature_(ptr->feature_),
+      value_(ptr->value_)
+    { }
+    virtual bool needs_parens(Supports_Condition_Obj cond) const { return false; }
+    ATTACH_AST_OPERATIONS(Supports_Declaration)
     ATTACH_OPERATIONS()
   };
 
@@ -1696,12 +2047,17 @@ namespace Sass {
   ///////////////////////////////////////////////
   class Supports_Interpolation : public Supports_Condition {
   private:
-    ADD_PROPERTY(Expression*, value);
+    ADD_PROPERTY(Expression_Obj, value);
   public:
-    Supports_Interpolation(ParserState pstate, Expression* v)
+    Supports_Interpolation(ParserState pstate, Expression_Obj v)
     : Supports_Condition(pstate), value_(v)
     { }
-    virtual bool needs_parens(Supports_Condition* cond) const { return false; }
+    Supports_Interpolation(const Supports_Interpolation* ptr)
+    : Supports_Condition(ptr),
+      value_(ptr->value_)
+    { }
+    virtual bool needs_parens(Supports_Condition_Obj cond) const { return false; }
+    ATTACH_AST_OPERATIONS(Supports_Interpolation)
     ATTACH_OPERATIONS()
   };
 
@@ -1710,13 +2066,19 @@ namespace Sass {
   /////////////////////////////////////////////////
   class At_Root_Query : public Expression {
   private:
-    ADD_PROPERTY(Expression*, feature)
-    ADD_PROPERTY(Expression*, value)
+    ADD_PROPERTY(Expression_Obj, feature)
+    ADD_PROPERTY(Expression_Obj, value)
   public:
-    At_Root_Query(ParserState pstate, Expression* f = 0, Expression* v = 0, bool i = false)
+    At_Root_Query(ParserState pstate, Expression_Obj f = 0, Expression_Obj v = 0, bool i = false)
     : Expression(pstate), feature_(f), value_(v)
     { }
+    At_Root_Query(const At_Root_Query* ptr)
+    : Expression(ptr),
+      feature_(ptr->feature_),
+      value_(ptr->value_)
+    { }
     bool exclude(std::string str);
+    ATTACH_AST_OPERATIONS(At_Root_Query)
     ATTACH_OPERATIONS()
   };
 
@@ -1724,13 +2086,16 @@ namespace Sass {
   // At-root.
   ///////////
   class At_Root_Block : public Has_Block {
-    ADD_PROPERTY(At_Root_Query*, expression)
+    ADD_PROPERTY(At_Root_Query_Obj, expression)
   public:
-    At_Root_Block(ParserState pstate, Block* b = 0, At_Root_Query* e = 0)
+    At_Root_Block(ParserState pstate, Block_Obj b = 0, At_Root_Query_Obj e = 0)
     : Has_Block(pstate, b), expression_(e)
     { statement_type(ATROOT); }
+    At_Root_Block(const At_Root_Block* ptr)
+    : Has_Block(ptr), expression_(ptr->expression_)
+    { statement_type(ATROOT); }
     bool bubbles() { return true; }
-    bool exclude_node(Statement* s) {
+    bool exclude_node(Statement_Obj s) {
       if (expression() == 0)
       {
         return s->statement_type() == Statement::RULESET;
@@ -1738,7 +2103,7 @@ namespace Sass {
 
       if (s->statement_type() == Statement::DIRECTIVE)
       {
-        if (Directive* dir = dynamic_cast<Directive*>(s))
+        if (Directive_Obj dir = SASS_MEMORY_CAST(Directive, s))
         {
           std::string keyword(dir->keyword());
           if (keyword.length() > 0) keyword.erase(0, 1);
@@ -1757,12 +2122,13 @@ namespace Sass {
       {
         return expression()->exclude("supports");
       }
-      if (Directive* dir = dynamic_cast<Directive*>(s))
+      if (Directive_Obj dir = SASS_MEMORY_CAST(Directive, s))
       {
         if (dir->is_keyframes()) return expression()->exclude("keyframes");
       }
       return false;
     }
+    ATTACH_AST_OPERATIONS(At_Root_Block)
     ATTACH_OPERATIONS()
   };
 
@@ -1772,6 +2138,7 @@ namespace Sass {
   class Null : public Value {
   public:
     Null(ParserState pstate) : Value(pstate) { concrete_type(NULL_VAL); }
+    Null(const Null* ptr) : Value(ptr) { concrete_type(NULL_VAL); }
     std::string type() { return "null"; }
     static std::string type_name() { return "null"; }
     bool is_invisible() const { return true; }
@@ -1785,6 +2152,7 @@ namespace Sass {
 
     virtual bool operator== (const Expression& rhs) const;
 
+    ATTACH_AST_OPERATIONS(Null)
     ATTACH_OPERATIONS()
   };
 
@@ -1792,10 +2160,10 @@ namespace Sass {
   // Thunks for delayed evaluation.
   /////////////////////////////////
   class Thunk : public Expression {
-    ADD_PROPERTY(Expression*, expression)
+    ADD_PROPERTY(Expression_Obj, expression)
     ADD_PROPERTY(Env*, environment)
   public:
-    Thunk(ParserState pstate, Expression* exp, Env* env = 0)
+    Thunk(ParserState pstate, Expression_Obj exp, Env* env = 0)
     : Expression(pstate), expression_(exp), environment_(env)
     { }
   };
@@ -1805,17 +2173,28 @@ namespace Sass {
   /////////////////////////////////////////////////////////
   class Parameter : public AST_Node {
     ADD_PROPERTY(std::string, name)
-    ADD_PROPERTY(Expression*, default_value)
+    ADD_PROPERTY(Expression_Obj, default_value)
     ADD_PROPERTY(bool, is_rest_parameter)
   public:
     Parameter(ParserState pstate,
-              std::string n, Expression* def = 0, bool rest = false)
+              std::string n, Expression_Obj def = 0, bool rest = false)
     : AST_Node(pstate), name_(n), default_value_(def), is_rest_parameter_(rest)
     {
       if (default_value_ && is_rest_parameter_) {
-        error("variable-length parameter may not have a default value", pstate);
+        error("variable-length parameter may not have a default value", pstate_);
       }
     }
+    Parameter(const Parameter* ptr)
+    : AST_Node(ptr),
+      name_(ptr->name_),
+      default_value_(ptr->default_value_),
+      is_rest_parameter_(ptr->is_rest_parameter_)
+    {
+      if (default_value_ && is_rest_parameter_) {
+        error("variable-length parameter may not have a default value", pstate_);
+      }
+    }
+    ATTACH_AST_OPERATIONS(Parameter)
     ATTACH_OPERATIONS()
   };
 
@@ -1824,11 +2203,11 @@ namespace Sass {
   // error checking (e.g., ensuring that all optional parameters follow all
   // required parameters).
   /////////////////////////////////////////////////////////////////////////
-  class Parameters : public AST_Node, public Vectorized<Parameter*> {
+  class Parameters : public AST_Node, public Vectorized<Parameter_Obj> {
     ADD_PROPERTY(bool, has_optional_parameters)
     ADD_PROPERTY(bool, has_rest_parameter)
   protected:
-    void adjust_after_pushing(Parameter* p)
+    void adjust_after_pushing(Parameter_Obj p)
     {
       if (p->default_value()) {
         if (has_rest_parameter_) {
@@ -1854,10 +2233,17 @@ namespace Sass {
   public:
     Parameters(ParserState pstate)
     : AST_Node(pstate),
-      Vectorized<Parameter*>(),
+      Vectorized<Parameter_Obj>(),
       has_optional_parameters_(false),
       has_rest_parameter_(false)
     { }
+    Parameters(const Parameters* ptr)
+    : AST_Node(ptr),
+      Vectorized<Parameter_Obj>(*ptr),
+      has_optional_parameters_(ptr->has_optional_parameters_),
+      has_rest_parameter_(ptr->has_rest_parameter_)
+    { }
+    ATTACH_AST_OPERATIONS(Parameters)
     ATTACH_OPERATIONS()
   };
 
@@ -1873,7 +2259,10 @@ namespace Sass {
     // maybe we have optional flag
     ADD_PROPERTY(bool, is_optional)
     // parent block pointers
-    ADD_PROPERTY(Media_Block*, media_block)
+
+    // must not be a reference counted object
+    // otherwise we create circular references
+    ADD_PROPERTY(Media_Block_Ptr, media_block)
   protected:
     size_t hash_;
   public:
@@ -1886,26 +2275,33 @@ namespace Sass {
       media_block_(0),
       hash_(0)
     { concrete_type(SELECTOR); }
+    Selector(const Selector* ptr)
+    : Expression(ptr),
+      // has_reference_(ptr->has_reference_),
+      has_line_feed_(ptr->has_line_feed_),
+      has_line_break_(ptr->has_line_break_),
+      is_optional_(ptr->is_optional_),
+      media_block_(ptr->media_block_),
+      hash_(ptr->hash_)
+    { concrete_type(SELECTOR); }
     virtual ~Selector() = 0;
     virtual size_t hash() = 0;
     virtual unsigned long specificity() {
       return 0;
     }
-    virtual void set_media_block(Media_Block* mb) {
+    virtual void set_media_block(Media_Block_Ptr mb) {
       media_block(mb);
     }
-    virtual bool has_wrapped_selector() {
-      return false;
-    }
-    virtual bool has_placeholder() {
-      return false;
-    }
     virtual bool has_parent_ref() {
       return false;
     }
     virtual bool has_real_parent_ref() {
       return false;
     }
+    // dispatch to correct handlers
+    virtual bool operator<(const Selector& rhs) const;
+    virtual bool operator==(const Selector& rhs) const;
+    ATTACH_VIRTUAL_AST_OPERATIONS(Selector);
   };
   inline Selector::~Selector() { }
 
@@ -1914,12 +2310,17 @@ namespace Sass {
   // re-parsed into a normal selector class.
   /////////////////////////////////////////////////////////////////////////
   class Selector_Schema : public Selector {
-    ADD_PROPERTY(String*, contents)
+    ADD_PROPERTY(String_Obj, contents)
     ADD_PROPERTY(bool, at_root);
   public:
-    Selector_Schema(ParserState pstate, String* c)
+    Selector_Schema(ParserState pstate, String_Obj c)
     : Selector(pstate), contents_(c), at_root_(false)
     { }
+    Selector_Schema(const Selector_Schema* ptr)
+    : Selector(ptr),
+      contents_(ptr->contents_),
+      at_root_(ptr->at_root_)
+    { }
     virtual bool has_parent_ref();
     virtual bool has_real_parent_ref();
     virtual size_t hash() {
@@ -1928,6 +2329,7 @@ namespace Sass {
       }
       return hash_;
     }
+    ATTACH_AST_OPERATIONS(Selector_Schema)
     ATTACH_OPERATIONS()
   };
 
@@ -1935,13 +2337,15 @@ namespace Sass {
   // Abstract base class for simple selectors.
   ////////////////////////////////////////////
   class Simple_Selector : public Selector {
-    ADD_PROPERTY(std::string, ns);
+    ADD_PROPERTY(std::string, ns)
     ADD_PROPERTY(std::string, name)
+    ADD_PROPERTY(Simple_Type, simple_type)
     ADD_PROPERTY(bool, has_ns)
   public:
     Simple_Selector(ParserState pstate, std::string n = "")
     : Selector(pstate), ns_(""), name_(n), has_ns_(false)
     {
+      simple_type(SIMPLE);
       size_t pos = n.find('|');
       // found some namespace
       if (pos != std::string::npos) {
@@ -1950,6 +2354,12 @@ namespace Sass {
         name_ = n.substr(pos + 1);
       }
     }
+    Simple_Selector(const Simple_Selector* ptr)
+    : Selector(ptr),
+      ns_(ptr->ns_),
+      name_(ptr->name_),
+      has_ns_(ptr->has_ns_)
+    { simple_type(SIMPLE); }
     virtual bool unique() const
     {
       return false;
@@ -1997,20 +2407,27 @@ namespace Sass {
       return name_ == "*";
     }
 
+    virtual bool has_placeholder() {
+      return false;
+    }
+
     virtual ~Simple_Selector() = 0;
-    virtual SimpleSequence_Selector* unify_with(SimpleSequence_Selector*, Context&);
+    virtual Compound_Selector_Ptr unify_with(Compound_Selector_Ptr, Context&);
     virtual bool has_parent_ref() { return false; };
     virtual bool has_real_parent_ref() { return false; };
     virtual bool is_pseudo_element() { return false; }
     virtual bool is_pseudo_class() { return false; }
 
-    virtual bool is_superselector_of(SimpleSequence_Selector* sub) { return false; }
+    virtual bool is_superselector_of(Compound_Selector_Obj sub) { return false; }
 
-    bool operator==(const Simple_Selector& rhs) const;
+    virtual bool operator==(const Selector& rhs) const;
+    virtual bool operator==(const Simple_Selector& rhs) const;
     inline bool operator!=(const Simple_Selector& rhs) const { return !(*this == rhs); }
 
+    bool operator<(const Selector& rhs) const;
     bool operator<(const Simple_Selector& rhs) const;
     // default implementation should work for most of the simple selectors (otherwise overload)
+    ATTACH_VIRTUAL_AST_OPERATIONS(Simple_Selector);
     ATTACH_OPERATIONS();
   };
   inline Simple_Selector::~Simple_Selector() { }
@@ -2020,7 +2437,7 @@ namespace Sass {
   // The Parent Selector Expression.
   //////////////////////////////////
   // parent selectors can occur in selectors but also
-  // inside strings in declarations (SimpleSequence_Selector).
+  // inside strings in declarations (Compound_Selector).
   // only one simple parent selector means the first case.
   class Parent_Selector : public Simple_Selector {
     ADD_PROPERTY(bool, real)
@@ -2028,6 +2445,9 @@ namespace Sass {
     Parent_Selector(ParserState pstate, bool r = true)
     : Simple_Selector(pstate, "&"), real_(r)
     { /* has_reference(true); */ }
+    Parent_Selector(const Parent_Selector* ptr)
+    : Simple_Selector(ptr), real_(ptr->real_)
+    { /* has_reference(true); */ }
     bool is_real_parent_ref() { return real(); };
     virtual bool has_parent_ref() { return true; };
     virtual bool has_real_parent_ref() { return is_real_parent_ref(); };
@@ -2037,6 +2457,7 @@ namespace Sass {
     }
     std::string type() { return "selector"; }
     static std::string type_name() { return "selector"; }
+    ATTACH_AST_OPERATIONS(Parent_Selector)
     ATTACH_OPERATIONS()
   };
 
@@ -2048,6 +2469,9 @@ namespace Sass {
     Placeholder_Selector(ParserState pstate, std::string n)
     : Simple_Selector(pstate, n)
     { }
+    Placeholder_Selector(const Placeholder_Selector* ptr)
+    : Simple_Selector(ptr)
+    { }
     virtual unsigned long specificity()
     {
       return Constants::Specificity_Base;
@@ -2055,8 +2479,8 @@ namespace Sass {
     virtual bool has_placeholder() {
       return true;
     }
-    // virtual Placeholder_Selector* find_placeholder();
     virtual ~Placeholder_Selector() {};
+    ATTACH_AST_OPERATIONS(Placeholder_Selector)
     ATTACH_OPERATIONS()
   };
 
@@ -2068,13 +2492,17 @@ namespace Sass {
     Element_Selector(ParserState pstate, std::string n)
     : Simple_Selector(pstate, n)
     { }
+    Element_Selector(const Element_Selector* ptr)
+    : Simple_Selector(ptr)
+    { }
     virtual unsigned long specificity()
     {
       if (name() == "*") return 0;
       else               return Constants::Specificity_Element;
     }
-    virtual Simple_Selector* unify_with(Simple_Selector*, Context&);
-    virtual SimpleSequence_Selector* unify_with(SimpleSequence_Selector*, Context&);
+    virtual Simple_Selector_Ptr unify_with(Simple_Selector_Ptr, Context&);
+    virtual Compound_Selector_Ptr unify_with(Compound_Selector_Ptr, Context&);
+    ATTACH_AST_OPERATIONS(Element_Selector)
     ATTACH_OPERATIONS()
   };
 
@@ -2086,6 +2514,9 @@ namespace Sass {
     Class_Selector(ParserState pstate, std::string n)
     : Simple_Selector(pstate, n)
     { }
+    Class_Selector(const Class_Selector* ptr)
+    : Simple_Selector(ptr)
+    { }
     virtual bool unique() const
     {
       return false;
@@ -2094,7 +2525,8 @@ namespace Sass {
     {
       return Constants::Specificity_Class;
     }
-    virtual SimpleSequence_Selector* unify_with(SimpleSequence_Selector*, Context&);
+    virtual Compound_Selector_Ptr unify_with(Compound_Selector_Ptr, Context&);
+    ATTACH_AST_OPERATIONS(Class_Selector)
     ATTACH_OPERATIONS()
   };
 
@@ -2106,6 +2538,9 @@ namespace Sass {
     Id_Selector(ParserState pstate, std::string n)
     : Simple_Selector(pstate, n)
     { }
+    Id_Selector(const Id_Selector* ptr)
+    : Simple_Selector(ptr)
+    { }
     virtual bool unique() const
     {
       return true;
@@ -2114,7 +2549,8 @@ namespace Sass {
     {
       return Constants::Specificity_ID;
     }
-    virtual SimpleSequence_Selector* unify_with(SimpleSequence_Selector*, Context&);
+    virtual Compound_Selector_Ptr unify_with(Compound_Selector_Ptr, Context&);
+    ATTACH_AST_OPERATIONS(Id_Selector)
     ATTACH_OPERATIONS()
   };
 
@@ -2123,11 +2559,17 @@ namespace Sass {
   ///////////////////////////////////////////////////
   class Attribute_Selector : public Simple_Selector {
     ADD_PROPERTY(std::string, matcher)
-    ADD_PROPERTY(String*, value) // might be interpolated
+    // this cannot be changed to obj atm!!!!!!????!!!!!!!
+    ADD_PROPERTY(String_Obj, value) // might be interpolated
   public:
-    Attribute_Selector(ParserState pstate, std::string n, std::string m, String* v)
+    Attribute_Selector(ParserState pstate, std::string n, std::string m, String_Obj v)
     : Simple_Selector(pstate, n), matcher_(m), value_(v)
-    { }
+    { simple_type(ATTR_SEL); }
+    Attribute_Selector(const Attribute_Selector* ptr)
+    : Simple_Selector(ptr),
+      matcher_(ptr->matcher_),
+      value_(ptr->value_)
+    { simple_type(ATTR_SEL); }
     virtual size_t hash()
     {
       if (hash_ == 0) {
@@ -2141,10 +2583,11 @@ namespace Sass {
     {
       return Constants::Specificity_Attr;
     }
-    bool operator==(const Simple_Selector& rhs) const;
-    bool operator==(const Attribute_Selector& rhs) const;
-    bool operator<(const Simple_Selector& rhs) const;
-    bool operator<(const Attribute_Selector& rhs) const;
+    virtual bool operator==(const Simple_Selector& rhs) const;
+    virtual bool operator==(const Attribute_Selector& rhs) const;
+    virtual bool operator<(const Simple_Selector& rhs) const;
+    virtual bool operator<(const Attribute_Selector& rhs) const;
+    ATTACH_AST_OPERATIONS(Attribute_Selector)
     ATTACH_OPERATIONS()
   };
 
@@ -2165,11 +2608,14 @@ namespace Sass {
 
   // Pseudo Selector cannot have any namespace?
   class Pseudo_Selector : public Simple_Selector {
-    ADD_PROPERTY(String*, expression)
+    ADD_PROPERTY(String_Obj, expression)
   public:
-    Pseudo_Selector(ParserState pstate, std::string n, String* expr = 0)
+    Pseudo_Selector(ParserState pstate, std::string n, String_Obj expr = 0)
     : Simple_Selector(pstate, n), expression_(expr)
-    { }
+    { simple_type(PSEUDO_SEL); }
+    Pseudo_Selector(const Pseudo_Selector* ptr)
+    : Simple_Selector(ptr), expression_(ptr->expression_)
+    { simple_type(PSEUDO_SEL); }
 
     // A pseudo-class always consists of a "colon" (:) followed by the name
     // of the pseudo-class and optionally by a value between parentheses.
@@ -2206,11 +2652,12 @@ namespace Sass {
         return Constants::Specificity_Element;
       return Constants::Specificity_Pseudo;
     }
-    bool operator==(const Simple_Selector& rhs) const;
-    bool operator==(const Pseudo_Selector& rhs) const;
-    bool operator<(const Simple_Selector& rhs) const;
-    bool operator<(const Pseudo_Selector& rhs) const;
-    virtual SimpleSequence_Selector* unify_with(SimpleSequence_Selector*, Context&);
+    virtual bool operator==(const Simple_Selector& rhs) const;
+    virtual bool operator==(const Pseudo_Selector& rhs) const;
+    virtual bool operator<(const Simple_Selector& rhs) const;
+    virtual bool operator<(const Pseudo_Selector& rhs) const;
+    virtual Compound_Selector_Ptr unify_with(Compound_Selector_Ptr, Context&);
+    ATTACH_AST_OPERATIONS(Pseudo_Selector)
     ATTACH_OPERATIONS()
   };
 
@@ -2218,12 +2665,15 @@ namespace Sass {
   // Wrapped selector -- pseudo selector that takes a list of selectors as argument(s) e.g., :not(:first-of-type), :-moz-any(ol p.blah, ul, menu, dir)
   /////////////////////////////////////////////////
   class Wrapped_Selector : public Simple_Selector {
-    ADD_PROPERTY(Selector*, selector)
+    ADD_PROPERTY(Selector_Obj, selector)
   public:
-    Wrapped_Selector(ParserState pstate, std::string n, Selector* sel)
+    Wrapped_Selector(ParserState pstate, std::string n, Selector_Obj sel)
     : Simple_Selector(pstate, n), selector_(sel)
-    { }
-    virtual bool is_superselector_of(Wrapped_Selector* sub);
+    { simple_type(WRAPPED_SEL); }
+    Wrapped_Selector(const Wrapped_Selector* ptr)
+    : Simple_Selector(ptr), selector_(ptr->selector_)
+    { simple_type(WRAPPED_SEL); }
+    virtual bool is_superselector_of(Wrapped_Selector_Obj sub);
     // Selectors inside the negation pseudo-class are counted like any
     // other, but the negation itself does not count as a pseudo-class.
     virtual size_t hash()
@@ -2244,48 +2694,52 @@ namespace Sass {
       if (!selector()) return false;
       return selector()->has_real_parent_ref();
     }
-    virtual bool has_wrapped_selector()
-    {
-      return true;
-    }
     virtual unsigned long specificity()
     {
       return selector_ ? selector_->specificity() : 0;
     }
-    bool operator==(const Simple_Selector& rhs) const;
-    bool operator==(const Wrapped_Selector& rhs) const;
-    bool operator<(const Simple_Selector& rhs) const;
-    bool operator<(const Wrapped_Selector& rhs) const;
+    virtual bool operator==(const Simple_Selector& rhs) const;
+    virtual bool operator==(const Wrapped_Selector& rhs) const;
+    virtual bool operator<(const Simple_Selector& rhs) const;
+    virtual bool operator<(const Wrapped_Selector& rhs) const;
+    virtual void cloneChildren();
+    ATTACH_AST_OPERATIONS(Wrapped_Selector)
     ATTACH_OPERATIONS()
   };
 
-  struct Sequence_Selector_Pointer_Compare {
-    bool operator() (const Sequence_Selector* const pLeft, const Sequence_Selector* const pRight) const;
+  struct Complex_Selector_Pointer_Compare {
+    bool operator() (const Complex_Selector_Obj& pLeft, const Complex_Selector_Obj& pRight) const;
   };
 
   ////////////////////////////////////////////////////////////////////////////
   // Simple selector sequences. Maintains flags indicating whether it contains
   // any parent references or placeholders, to simplify expansion.
   ////////////////////////////////////////////////////////////////////////////
-  typedef std::set<Sequence_Selector*, Sequence_Selector_Pointer_Compare> SourcesSet;
-  class SimpleSequence_Selector : public Selector, public Vectorized<Simple_Selector*> {
+  typedef std::set<Complex_Selector_Obj, Complex_Selector_Pointer_Compare> SourcesSet;
+  class Compound_Selector : public Selector, public Vectorized<Simple_Selector_Obj> {
   private:
     SourcesSet sources_;
     ADD_PROPERTY(bool, extended);
     ADD_PROPERTY(bool, has_parent_reference);
   protected:
-    void adjust_after_pushing(Simple_Selector* s)
+    void adjust_after_pushing(Simple_Selector_Obj s)
     {
       // if (s->has_reference())   has_reference(true);
       // if (s->has_placeholder()) has_placeholder(true);
     }
   public:
-    SimpleSequence_Selector(ParserState pstate, size_t s = 0)
+    Compound_Selector(ParserState pstate, size_t s = 0)
     : Selector(pstate),
-      Vectorized<Simple_Selector*>(s),
+      Vectorized<Simple_Selector_Obj>(s),
       extended_(false),
       has_parent_reference_(false)
     { }
+    Compound_Selector(const Compound_Selector* ptr)
+    : Selector(ptr),
+      Vectorized<Simple_Selector_Obj>(*ptr),
+      extended_(ptr->extended_),
+      has_parent_reference_(ptr->has_parent_reference_)
+    { }
     bool contains_placeholder() {
       for (size_t i = 0, L = length(); i < L; ++i) {
         if ((*this)[i]->has_placeholder()) return true;
@@ -2293,33 +2747,33 @@ namespace Sass {
       return false;
     };
 
-    SimpleSequence_Selector& operator<<(Simple_Selector* element);
+    void append(Simple_Selector_Ptr element);
 
     bool is_universal() const
     {
       return length() == 1 && (*this)[0]->is_universal();
     }
 
-    Sequence_Selector* to_complex(Memory_Manager& mem);
-    SimpleSequence_Selector* unify_with(SimpleSequence_Selector* rhs, Context& ctx);
-    // virtual Placeholder_Selector* find_placeholder();
+    Complex_Selector_Obj to_complex();
+    Compound_Selector_Ptr unify_with(Compound_Selector_Ptr rhs, Context& ctx);
+    // virtual Placeholder_Selector_Ptr find_placeholder();
     virtual bool has_parent_ref();
     virtual bool has_real_parent_ref();
-    Simple_Selector* base()
+    Simple_Selector_Ptr base()
     {
       // Implement non-const in terms of const. Safe to const_cast since this method is non-const
-      return const_cast<Simple_Selector*>(static_cast<const SimpleSequence_Selector*>(this)->base());
+      return const_cast<Simple_Selector_Ptr>(static_cast<Compound_Selector_Ptr_Const>(this)->base());
     }
-    const Simple_Selector* base() const {
+    Simple_Selector_Ptr_Const base() const {
       if (length() == 0) return 0;
       // ToDo: why is this needed?
-      if (dynamic_cast<Element_Selector*>((*this)[0]))
-        return (*this)[0];
+      if (SASS_MEMORY_CAST(Element_Selector, (*this)[0]))
+        return &(*this)[0];
       return 0;
     }
-    virtual bool is_superselector_of(SimpleSequence_Selector* sub, std::string wrapped = "");
-    virtual bool is_superselector_of(Sequence_Selector* sub, std::string wrapped = "");
-    virtual bool is_superselector_of(CommaSequence_Selector* sub, std::string wrapped = "");
+    virtual bool is_superselector_of(Compound_Selector_Obj sub, std::string wrapped = "");
+    virtual bool is_superselector_of(Complex_Selector_Obj sub, std::string wrapped = "");
+    virtual bool is_superselector_of(Selector_List_Obj sub, std::string wrapped = "");
     virtual size_t hash()
     {
       if (Selector::hash_ == 0) {
@@ -2336,19 +2790,10 @@ namespace Sass {
       return sum;
     }
 
-    virtual bool has_wrapped_selector()
-    {
-      if (length() == 0) return false;
-      if (Simple_Selector* ss = elements().front()) {
-        if (ss->has_wrapped_selector()) return true;
-      }
-      return false;
-    }
-
     virtual bool has_placeholder()
     {
       if (length() == 0) return false;
-      if (Simple_Selector* ss = elements().front()) {
+      if (Simple_Selector_Obj ss = elements().front()) {
         if (ss->has_placeholder()) return true;
       }
       return false;
@@ -2357,22 +2802,21 @@ namespace Sass {
     bool is_empty_reference()
     {
       return length() == 1 &&
-             dynamic_cast<Parent_Selector*>((*this)[0]);
+             SASS_MEMORY_CAST(Parent_Selector, (*this)[0]);
     }
-    std::vector<std::string> to_str_vec(); // sometimes need to convert to a flat "by-value" data structure
+    std::vector<Subset_Map_Key> to_str_vec(); // sometimes need to convert to a flat "by-value" data structure
 
-    bool operator<(const SimpleSequence_Selector& rhs) const;
-
-    bool operator==(const SimpleSequence_Selector& rhs) const;
-    inline bool operator!=(const SimpleSequence_Selector& rhs) const { return !(*this == rhs); }
+    virtual bool operator<(const Compound_Selector& rhs) const;
+    virtual bool operator==(const Compound_Selector& rhs) const;
+    inline bool operator!=(const Compound_Selector& rhs) const { return !(*this == rhs); }
 
     SourcesSet& sources() { return sources_; }
     void clearSources() { sources_.clear(); }
     void mergeSources(SourcesSet& sources, Context& ctx);
 
-    SimpleSequence_Selector* clone(Context&) const; // does not clone the Simple_Selector*s
-
-    SimpleSequence_Selector* minus(SimpleSequence_Selector* rhs, Context& ctx);
+    Compound_Selector_Ptr minus(Compound_Selector_Ptr rhs, Context& ctx);
+    virtual void cloneChildren();
+    ATTACH_AST_OPERATIONS(Compound_Selector)
     ATTACH_OPERATIONS()
   };
 
@@ -2381,37 +2825,40 @@ namespace Sass {
   // CSS selector combinators (">", "+", "~", and whitespace). Essentially a
   // linked list.
   ////////////////////////////////////////////////////////////////////////////
-  class Sequence_Selector : public Selector {
+  class Complex_Selector : public Selector {
   public:
     enum Combinator { ANCESTOR_OF, PARENT_OF, PRECEDES, ADJACENT_TO, REFERENCE };
   private:
     ADD_PROPERTY(Combinator, combinator)
-    ADD_PROPERTY(SimpleSequence_Selector*, head)
-    ADD_PROPERTY(Sequence_Selector*, tail)
-    ADD_PROPERTY(String*, reference);
+    ADD_PROPERTY(Compound_Selector_Obj, head)
+    ADD_PROPERTY(Complex_Selector_Obj, tail)
+    ADD_PROPERTY(String_Obj, reference);
   public:
     bool contains_placeholder() {
       if (head() && head()->contains_placeholder()) return true;
       if (tail() && tail()->contains_placeholder()) return true;
       return false;
     };
-    Sequence_Selector(ParserState pstate,
+    Complex_Selector(ParserState pstate,
                      Combinator c = ANCESTOR_OF,
-                     SimpleSequence_Selector* h = 0,
-                     Sequence_Selector* t = 0,
-                     String* r = 0)
+                     Compound_Selector_Obj h = 0,
+                     Complex_Selector_Obj t = 0,
+                     String_Obj r = 0)
     : Selector(pstate),
       combinator_(c),
       head_(h), tail_(t),
       reference_(r)
-    {
-      // if ((h && h->has_reference())   || (t && t->has_reference()))   has_reference(true);
-      // if ((h && h->has_placeholder()) || (t && t->has_placeholder())) has_placeholder(true);
-    }
+    {}
+    Complex_Selector(const Complex_Selector* ptr)
+    : Selector(ptr),
+      combinator_(ptr->combinator_),
+      head_(ptr->head_), tail_(ptr->tail_),
+      reference_(ptr->reference_)
+    {};
     virtual bool has_parent_ref();
     virtual bool has_real_parent_ref();
 
-    Sequence_Selector* skip_empty_reference()
+    Complex_Selector_Obj skip_empty_reference()
     {
       if ((!head_ || !head_->length() || head_->is_empty_reference()) &&
           combinator() == Combinator::ANCESTOR_OF)
@@ -2431,36 +2878,29 @@ namespace Sass {
              combinator() == Combinator::ANCESTOR_OF;
     }
 
-    Sequence_Selector* context(Context&);
+    Complex_Selector_Obj context(Context&);
 
 
+    Selector_List_Ptr tails(Context& ctx, Selector_List_Ptr tails);
+
     // front returns the first real tail
     // skips over parent and empty ones
-    const Sequence_Selector* first() const;
-
+    Complex_Selector_Obj first();
     // last returns the last real tail
-    const Sequence_Selector* last() const;
-
-    CommaSequence_Selector* tails(Context& ctx, CommaSequence_Selector* tails);
-
-    // unconstant accessors
-    Sequence_Selector* first();
-    Sequence_Selector* last();
+    Complex_Selector_Obj last();
 
     // some shortcuts that should be removed
-    const Sequence_Selector* innermost() const { return last(); };
-    Sequence_Selector* innermost() { return last(); };
+    Complex_Selector_Obj innermost() { return last(); };
 
     size_t length() const;
-    CommaSequence_Selector* resolve_parent_refs(Context& ctx, CommaSequence_Selector* parents, bool implicit_parent = true);
-    virtual bool is_superselector_of(SimpleSequence_Selector* sub, std::string wrapping = "");
-    virtual bool is_superselector_of(Sequence_Selector* sub, std::string wrapping = "");
-    virtual bool is_superselector_of(CommaSequence_Selector* sub, std::string wrapping = "");
-    // virtual Placeholder_Selector* find_placeholder();
-    CommaSequence_Selector* unify_with(Sequence_Selector* rhs, Context& ctx);
+    Selector_List_Ptr resolve_parent_refs(Context& ctx, std::vector<Selector_List_Obj>& pstack, bool implicit_parent = true);
+    virtual bool is_superselector_of(Compound_Selector_Obj sub, std::string wrapping = "");
+    virtual bool is_superselector_of(Complex_Selector_Obj sub, std::string wrapping = "");
+    virtual bool is_superselector_of(Selector_List_Obj sub, std::string wrapping = "");
+    Selector_List_Ptr unify_with(Complex_Selector_Ptr rhs, Context& ctx);
     Combinator clear_innermost();
-    void append(Context&, Sequence_Selector*);
-    void set_innermost(Sequence_Selector*, Combinator);
+    void append(Context&, Complex_Selector_Obj);
+    void set_innermost(Complex_Selector_Obj, Combinator);
     virtual size_t hash()
     {
       if (hash_ == 0) {
@@ -2478,24 +2918,19 @@ namespace Sass {
       if (tail()) sum += tail()->specificity();
       return sum;
     }
-    virtual void set_media_block(Media_Block* mb) {
+    virtual void set_media_block(Media_Block_Ptr mb) {
       media_block(mb);
       if (tail_) tail_->set_media_block(mb);
       if (head_) head_->set_media_block(mb);
     }
-    virtual bool has_wrapped_selector() {
-      if (head_ && head_->has_wrapped_selector()) return true;
-      if (tail_ && tail_->has_wrapped_selector()) return true;
-      return false;
-    }
     virtual bool has_placeholder() {
       if (head_ && head_->has_placeholder()) return true;
       if (tail_ && tail_->has_placeholder()) return true;
       return false;
     }
-    bool operator<(const Sequence_Selector& rhs) const;
-    bool operator==(const Sequence_Selector& rhs) const;
-    inline bool operator!=(const Sequence_Selector& rhs) const { return !(*this == rhs); }
+    virtual bool operator<(const Complex_Selector& rhs) const;
+    virtual bool operator==(const Complex_Selector& rhs) const;
+    inline bool operator!=(const Complex_Selector& rhs) const { return !(*this == rhs); }
     SourcesSet sources()
     {
       //s = Set.new
@@ -2504,8 +2939,8 @@ namespace Sass {
 
       SourcesSet srcs;
 
-      SimpleSequence_Selector* pHead = head();
-      Sequence_Selector*  pTail = tail();
+      Compound_Selector_Obj pHead = head();
+      Complex_Selector_Obj  pTail = tail();
 
       if (pHead) {
         SourcesSet& headSources = pHead->sources();
@@ -2521,48 +2956,52 @@ namespace Sass {
     }
     void addSources(SourcesSet& sources, Context& ctx) {
       // members.map! {|m| m.is_a?(SimpleSequence) ? m.with_more_sources(sources) : m}
-      Sequence_Selector* pIter = this;
+      Complex_Selector_Ptr pIter = this;
       while (pIter) {
-        SimpleSequence_Selector* pHead = pIter->head();
+        Compound_Selector_Ptr pHead = &pIter->head();
 
         if (pHead) {
           pHead->mergeSources(sources, ctx);
         }
 
-        pIter = pIter->tail();
+        pIter = &pIter->tail();
       }
     }
     void clearSources() {
-      Sequence_Selector* pIter = this;
+      Complex_Selector_Ptr pIter = this;
       while (pIter) {
-        SimpleSequence_Selector* pHead = pIter->head();
+        Compound_Selector_Ptr pHead = &pIter->head();
 
         if (pHead) {
           pHead->clearSources();
         }
 
-        pIter = pIter->tail();
+        pIter = &pIter->tail();
       }
     }
-    Sequence_Selector* clone(Context&) const;      // does not clone SimpleSequence_Selector*s
-    Sequence_Selector* cloneFully(Context&) const; // clones SimpleSequence_Selector*s
-    // std::vector<SimpleSequence_Selector*> to_vector();
+
+    virtual void cloneChildren();
+    ATTACH_AST_OPERATIONS(Complex_Selector)
     ATTACH_OPERATIONS()
   };
 
-  typedef std::deque<Sequence_Selector*> ComplexSelectorDeque;
-  typedef Subset_Map<std::string, std::pair<Sequence_Selector*, SimpleSequence_Selector*> > ExtensionSubsetMap;
+  typedef std::deque<Complex_Selector_Obj> ComplexSelectorDeque;
 
   ///////////////////////////////////
   // Comma-separated selector groups.
   ///////////////////////////////////
-  class CommaSequence_Selector : public Selector, public Vectorized<Sequence_Selector*> {
+  class Selector_List : public Selector, public Vectorized<Complex_Selector_Obj> {
     ADD_PROPERTY(std::vector<std::string>, wspace)
   protected:
-    void adjust_after_pushing(Sequence_Selector* c);
+    void adjust_after_pushing(Complex_Selector_Obj c);
   public:
-    CommaSequence_Selector(ParserState pstate, size_t s = 0)
-    : Selector(pstate), Vectorized<Sequence_Selector*>(s), wspace_(0)
+    Selector_List(ParserState pstate, size_t s = 0)
+    : Selector(pstate), Vectorized<Complex_Selector_Obj>(s), wspace_(0)
+    { }
+    Selector_List(const Selector_List* ptr)
+    : Selector(ptr),
+      Vectorized<Complex_Selector_Obj>(*ptr),
+      wspace_(ptr->wspace_)
     { }
     std::string type() { return "list"; }
     // remove parent selector references
@@ -2570,13 +3009,12 @@ namespace Sass {
     virtual bool has_parent_ref();
     virtual bool has_real_parent_ref();
     void remove_parent_selectors();
-    // virtual Placeholder_Selector* find_placeholder();
-    CommaSequence_Selector* resolve_parent_refs(Context& ctx, CommaSequence_Selector* parents, bool implicit_parent = true);
-    virtual bool is_superselector_of(SimpleSequence_Selector* sub, std::string wrapping = "");
-    virtual bool is_superselector_of(Sequence_Selector* sub, std::string wrapping = "");
-    virtual bool is_superselector_of(CommaSequence_Selector* sub, std::string wrapping = "");
-    CommaSequence_Selector* unify_with(CommaSequence_Selector*, Context&);
-    void populate_extends(CommaSequence_Selector*, Context&, ExtensionSubsetMap&);
+    Selector_List_Ptr resolve_parent_refs(Context& ctx, std::vector<Selector_List_Obj>& pstack, bool implicit_parent = true);
+    virtual bool is_superselector_of(Compound_Selector_Obj sub, std::string wrapping = "");
+    virtual bool is_superselector_of(Complex_Selector_Obj sub, std::string wrapping = "");
+    virtual bool is_superselector_of(Selector_List_Obj sub, std::string wrapping = "");
+    Selector_List_Ptr unify_with(Selector_List_Ptr, Context&);
+    void populate_extends(Selector_List_Obj, Context&, Subset_Map&);
     virtual size_t hash()
     {
       if (Selector::hash_ == 0) {
@@ -2596,30 +3034,26 @@ namespace Sass {
       }
       return sum;
     }
-    virtual void set_media_block(Media_Block* mb) {
+    virtual void set_media_block(Media_Block_Ptr mb) {
       media_block(mb);
-      for (Sequence_Selector* cs : elements()) {
+      for (Complex_Selector_Obj cs : elements()) {
         cs->set_media_block(mb);
       }
     }
-    virtual bool has_wrapped_selector() {
-      for (Sequence_Selector* cs : elements()) {
-        if (cs->has_wrapped_selector()) return true;
-      }
-      return false;
-    }
     virtual bool has_placeholder() {
-      for (Sequence_Selector* cs : elements()) {
+      for (Complex_Selector_Obj cs : elements()) {
         if (cs->has_placeholder()) return true;
       }
       return false;
     }
-    CommaSequence_Selector* clone(Context&) const;      // does not clone SimpleSequence_Selector*s
-    CommaSequence_Selector* cloneFully(Context&) const; // clones SimpleSequence_Selector*s
+    virtual bool operator<(const Selector& rhs) const;
     virtual bool operator==(const Selector& rhs) const;
-    virtual bool operator==(const CommaSequence_Selector& rhs) const;
+    virtual bool operator<(const Selector_List& rhs) const;
+    virtual bool operator==(const Selector_List& rhs) const;
     // Selector Lists can be compared to comma lists
     virtual bool operator==(const Expression& rhs) const;
+    virtual void cloneChildren();
+    ATTACH_AST_OPERATIONS(Selector_List)
     ATTACH_OPERATIONS()
   };
 
@@ -2630,10 +3064,10 @@ namespace Sass {
     // is required for proper stl collection ordering) is implemented using string comparision. This gives stable sorting
     // behavior, and can be used to determine if the selectors would have exactly idential output. operator== matches the
     // ruby sass implementations for eql, which sometimes perform order independent comparisions (like set comparisons of the
-    // members of a SimpleSequence (SimpleSequence_Selector)).
+    // members of a SimpleSequence (Compound_Selector)).
     //
     // Due to the reliance on operator== and operater< behavior, this templated method is currently only intended for
-    // use with SimpleSequence_Selector and Sequence_Selector objects.
+    // use with Compound_Selector and Complex_Selector objects.
     if (simpleSelectorOrderDependent) {
       return !(one < two) && !(two < one);
     } else {
@@ -2642,9 +3076,9 @@ namespace Sass {
   }
 
   // compare function for sorting and probably other other uses
-  struct cmp_complex_selector { inline bool operator() (const Sequence_Selector* l, const Sequence_Selector* r) { return (*l < *r); } };
-  struct cmp_compound_selector { inline bool operator() (const SimpleSequence_Selector* l, const SimpleSequence_Selector* r) { return (*l < *r); } };
-  struct cmp_simple_selector { inline bool operator() (const Simple_Selector* l, const Simple_Selector* r) { return (*l < *r); } };
+  struct cmp_complex_selector { inline bool operator() (const Complex_Selector_Obj l, const Complex_Selector_Obj r) { return (*l < *r); } };
+  struct cmp_compound_selector { inline bool operator() (const Compound_Selector_Obj l, const Compound_Selector_Obj r) { return (*l < *r); } };
+  struct cmp_simple_selector { inline bool operator() (const Simple_Selector_Obj l, const Simple_Selector_Obj r) { return (*l < *r); } };
 
 }