Consolidate the Declaration and Propset AST nodes

In order to fix #1585 we need to introduce the `Trace` node from
Ruby Sass. This node interacts with propsets in an interesting way.
Have two node to represent the single Ruby `Prop` node caused a
lot of trouble with correct implementing check nesting logic for
`Trace`.

The trouble with implementing `Trace` were exaggerated by us
incorrectly eval propsets into declarations in the expand step.
This PR moves the de-nesting of prop nodes the cssize step to
[better match Ruby Sass][1].

Later we should rename this node `Prop` but it's out of scope of
this PR. This should allow my work on porting the `Trace` node over
from Ruby Sass to fix #1585.

[1]: https://github.com/sass/sass/blob/63586f1e51c0aec47a7afcc8cd17aa03f32f0a29/lib/sass/tree/visitors/cssize.rb#L149-L166

Author: xzyfer

src/ast.hpp

@@ -580,15 +580,15 @@ namespace Sass {
   ////////////////////////////////////////////////////////////////////////
   // Declarations -- style rules consisting of a property name and values.
   ////////////////////////////////////////////////////////////////////////
-  class Declaration : public Statement {
+  class Declaration : public Has_Block {
     ADD_PROPERTY(String*, property)
     ADD_PROPERTY(Expression*, value)
     ADD_PROPERTY(bool, is_important)
     ADD_PROPERTY(bool, is_indented)
   public:
     Declaration(ParserState pstate,
-                String* prop, Expression* val, bool i = false)
-    : Statement(pstate), property_(prop), value_(val), is_important_(i), is_indented_(false)
+                String* prop, Expression* val, bool i = false, Block* b = 0)
+    : Has_Block(pstate, b), property_(prop), value_(val), is_important_(i), is_indented_(false)
     { statement_type(DECLARATION); }
     ATTACH_OPERATIONS()
   };

src/ast_factory.hpp

@@ -19,7 +19,7 @@ namespace Sass {
     At_Root_Block* new_At_Root_Block(std::string p, size_t l, Selector* sel, Block* b);
     Directive* new_At_Rule(std::string p, size_t l, std::string kwd, Selector* sel, Block* b);
     Keyframe_Rule* new_Keyframe_Rule(std::string p, size_t l, Block* b);
-    Declaration* new_Declaration(std::string p, size_t l, String* prop, List* vals);
+    Declaration* new_Declaration(std::string p, size_t l, String* prop, List* vals, Block* b);
     Assignment* new_Assignment(std::string p, size_t l, std::string var, Expression* val, bool guarded = false);
     Import<Function_Call*>* new_CSS_Import(std::string p, size_t l, Function_Call* loc);
     Import<String*>* new_SASS_Import(std::string p, size_t l, String* loc);

src/check_nesting.cpp

@@ -42,15 +42,15 @@ namespace Sass {
     return static_cast<Statement*>(n);
   }
 
-  bool CheckNesting::is_valid_prop_parent(AST_Node* p) 
+  bool CheckNesting::is_valid_prop_parent(AST_Node* p)
   {
     if (Definition* def = dynamic_cast<Definition*>(p)) {
       return def->type() == Definition::MIXIN;
     }
 
     return dynamic_cast<Ruleset*>(p) ||
            dynamic_cast<Keyframe_Rule*>(p) ||
-           dynamic_cast<Propset*>(p) ||
+           dynamic_cast<Declaration*>(p) ||
            dynamic_cast<Directive*>(p) ||
            dynamic_cast<Mixin_Call*>(p);
   }

src/cssize.cpp

@@ -44,6 +44,45 @@ namespace Sass {
     return t->block()->perform(this);
   }
 
+  Statement* Cssize::operator()(Declaration* d)
+  {
+    String* property = dynamic_cast<String*>(d->property());
+
+    if (Declaration* dd = dynamic_cast<Declaration*>(parent())) {
+      String* parent_property = dynamic_cast<String*>(dd->property());
+      property = SASS_MEMORY_NEW(ctx.mem, String_Constant,
+                                 d->property()->pstate(),
+                                 parent_property->to_string() + "-" + property->to_string());
+      if (!dd->value()) {
+        d->tabs(dd->tabs() + 1);
+      }
+    }
+
+    Declaration* dd = SASS_MEMORY_NEW(ctx.mem, Declaration,
+                                      d->pstate(),
+                                      property,
+                                      d->value(),
+                                      d->is_important());
+    dd->is_indented(d->is_indented());
+    dd->tabs(d->tabs());
+
+    p_stack.push_back(dd);
+    Block* bb = d->block() ? d->block()->perform(this)->block() : 0;
+    p_stack.pop_back();
+
+    if (bb && bb->length()) {
+      if (dd->value() && !dd->value()->is_invisible()) {
+        bb->unshift(dd);
+      }
+      return bb;
+    }
+    else if (dd->value() && !dd->value()->is_invisible()) {
+      return dd;
+    }
+
+    return 0;
+  }
+
   Statement* Cssize::operator()(Directive* r)
   {
     if (!r->block() || !r->block()->length()) return r;

src/cssize.hpp

@@ -13,11 +13,11 @@ namespace Sass {
 
   class Cssize : public Operation_CRTP<Statement*, Cssize> {
 
-    Context&                 ctx;
-    std::vector<Block*>      block_stack;
-    std::vector<Statement*>  p_stack;
+    Context&                    ctx;
+    std::vector<Block*>         block_stack;
+    std::vector<Statement*>     p_stack;
     std::vector<Selector_List*> s_stack;
-    Backtrace*               backtrace;
+    Backtrace*                  backtrace;
 
     Statement* fallback_impl(AST_Node* n);
 
@@ -37,7 +37,7 @@ namespace Sass {
     Statement* operator()(Directive*);
     Statement* operator()(Keyframe_Rule*);
     Statement* operator()(Trace*);
-    // Statement* operator()(Declaration*);
+    Statement* operator()(Declaration*);
     // Statement* operator()(Assignment*);
     // Statement* operator()(Import*);
     // Statement* operator()(Import_Stub*);

src/debugger.hpp

@@ -155,6 +155,7 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
     Propset* selector = dynamic_cast<Propset*>(node);
     std::cerr << ind << "Propset " << selector;
     std::cerr << " (" << pstate_source_position(node) << ")";
+    std::cerr << " <" << dynamic_cast<String_Constant*>(selector->property_fragment())->value() << ">";
     std::cerr << " " << selector->tabs() << std::endl;
     if (selector->block()) for(auto i : selector->block()->elements()) { debug_ast(i, ind + " ", env); }
   } else if (dynamic_cast<Wrapped_Selector*>(node)) {
@@ -389,6 +390,7 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
     std::cerr << " " << block->tabs() << std::endl;
     debug_ast(block->property(), ind + " prop: ", env);
     debug_ast(block->value(), ind + " value: ", env);
+    debug_ast(block->block(), ind + " ", env);
   } else if (dynamic_cast<Keyframe_Rule*>(node)) {
     Keyframe_Rule* has_block = dynamic_cast<Keyframe_Rule*>(node);
     std::cerr << ind << "Keyframe_Rule " << has_block;

src/expand.cpp

@@ -157,6 +157,15 @@ namespace Sass {
   // mixes string_schema and statement
   Statement* Expand::operator()(Propset* p)
   {
+    String* fragment = dynamic_cast<String*>(p->property_fragment()->perform(&eval));
+    Propset* prop = SASS_MEMORY_NEW(ctx.mem, Propset,
+                                        p->pstate(),
+                                        fragment,
+                                        p->block()->perform(this)->block());
+    prop->tabs(p->tabs());
+    return prop;
+
+
     property_stack.push_back(p->property_fragment());
     Block* expanded_block = p->block()->perform(this)->block();
     for (size_t i = 0, L = expanded_block->length(); i < L; ++i) {
@@ -258,15 +267,20 @@ namespace Sass {
 
   Statement* Expand::operator()(Declaration* d)
   {
+    Block* ab = d->block();
     String* old_p = d->property();
     String* new_p = static_cast<String*>(old_p->perform(&eval));
     Expression* value = d->value()->perform(&eval);
-    if (!value || (value->is_invisible() && !d->is_important())) return 0;
+    Block* bb = ab ? ab->perform(this)->block() : 0;
+    if (!bb) {
+      if (!value || (value->is_invisible() && !d->is_important())) return 0;
+    }
     Declaration* decl = SASS_MEMORY_NEW(ctx.mem, Declaration,
                                         d->pstate(),
                                         new_p,
                                         value,
-                                        d->is_important());
+                                        d->is_important(),
+                                        bb);
     decl->tabs(d->tabs());
     return decl;
   }

src/output.cpp

@@ -118,7 +118,9 @@ namespace Sass {
       for (size_t i = 0, L = b->length(); i < L; ++i) {
         Statement* stm = (*b)[i];
         if (dynamic_cast<Has_Block*>(stm)) {
-          stm->perform(this);
+          if (typeid(*stm) != typeid(Declaration)) {
+            stm->perform(this);
+          }
         }
       }
       return;

src/parser.cpp

@@ -284,7 +284,7 @@ namespace Sass {
         if (decl->is_indented()) ++ indentation;
         // parse a propset that rides on the declaration's property
         stack.push_back(Scope::Properties);
-        (*block) << SASS_MEMORY_NEW(ctx.mem, Propset, pstate, decl->property(), parse_block());
+        decl->block(parse_block());
         stack.pop_back();
         if (decl->is_indented()) -- indentation;
       }

src/util.cpp

@@ -470,6 +470,8 @@ namespace Sass {
         Statement* stm = (*b)[i];
         if (dynamic_cast<Directive*>(stm)) {
           return true;
+        } else if (Declaration* d = dynamic_cast<Declaration*>(stm)) {
+          return isPrintable(d, style);
         } else if (dynamic_cast<Has_Block*>(stm)) {
           Block* pChildBlock = ((Has_Block*)stm)->block();
           if (isPrintable(pChildBlock, style)) {
@@ -484,8 +486,6 @@ namespace Sass {
           if (c->is_important()) {
             hasDeclarations = c->is_important();
           }
-        } else if (Declaration* d = dynamic_cast<Declaration*>(stm)) {
-          return isPrintable(d, style);
         } else {
           hasDeclarations = true;
         }