sassc 1.8.3 → 1.8.4

data/ext/libsass/src/eval.hpp

@@ -1,15 +1,15 @@
 #ifndef SASS_EVAL_H
 #define SASS_EVAL_H
 
+#include "ast.hpp"
 #include "context.hpp"
-#include "listize.hpp"
 #include "operation.hpp"
+#include "environment.hpp"
 
 namespace Sass {
 
   class Expand;
   class Context;
-  class Listize;
 
   class Eval : public Operation_CRTP<Expression*, Eval> {
 
@@ -19,17 +19,16 @@ namespace Sass {
    public:
     Expand&  exp;
     Context& ctx;
-    Listize  listize;
     Eval(Expand& exp);
-    virtual ~Eval();
+    ~Eval();
+
+    bool is_in_comment;
 
     Env* environment();
     Context& context();
     Selector_List* selector();
     Backtrace* backtrace();
 
-    using Operation<Expression*>::operator();
-
     // for evaluating function bodies
     Expression* operator()(Block*);
     Expression* operator()(Assignment*);
@@ -87,16 +86,16 @@ namespace Sass {
 
     // -- only need to define two comparisons, and the rest can be implemented in terms of them
     static bool eq(Expression*, Expression*);
-    static bool lt(Expression*, Expression*);
+    static bool lt(Expression*, Expression*, std::string op);
     // -- arithmetic on the combinations that matter
-    static Value* op_numbers(Memory_Manager&, enum Sass_OP, const Number&, const Number&, bool compressed = false, int precision = 5, ParserState* pstate = 0);
-    static Value* op_number_color(Memory_Manager&, enum Sass_OP, const Number&, const Color&, bool compressed = false, int precision = 5, ParserState* pstate = 0);
-    static Value* op_color_number(Memory_Manager&, enum Sass_OP, const Color&, const Number&, bool compressed = false, int precision = 5, ParserState* pstate = 0);
-    static Value* op_colors(Memory_Manager&, enum Sass_OP, const Color&, const Color&, bool compressed = false, int precision = 5, ParserState* pstate = 0);
-    static Value* op_strings(Memory_Manager&, enum Sass_OP, Value&, Value&, bool compressed = false, int precision = 5, ParserState* pstate = 0);
+    static Value* op_numbers(Memory_Manager&, enum Sass_OP, const Number&, const Number&, struct Sass_Inspect_Options opt, ParserState* pstate = 0);
+    static Value* op_number_color(Memory_Manager&, enum Sass_OP, const Number&, const Color&, struct Sass_Inspect_Options opt, ParserState* pstate = 0);
+    static Value* op_color_number(Memory_Manager&, enum Sass_OP, const Color&, const Number&, struct Sass_Inspect_Options opt, ParserState* pstate = 0);
+    static Value* op_colors(Memory_Manager&, enum Sass_OP, const Color&, const Color&, struct Sass_Inspect_Options opt, ParserState* pstate = 0);
+    static Value* op_strings(Memory_Manager&, Sass::Operand, Value&, Value&, struct Sass_Inspect_Options opt, ParserState* pstate = 0, bool interpolant = false);
 
   private:
-    std::string interpolation(Expression* s, bool into_quotes = false);
+    void interpolation(Context& ctx, std::string& res, Expression* ex, bool into_quotes, bool was_itpl = false);
 
   };
 

data/ext/libsass/src/expand.cpp

@@ -1,14 +1,10 @@
-#ifdef _MSC_VER
-#pragma warning(disable : 4503)
-#endif
-
+#include "sass.hpp"
 #include <iostream>
 #include <typeinfo>
 
 #include "expand.hpp"
 #include "bind.hpp"
 #include "eval.hpp"
-#include "to_string.hpp"
 #include "backtrace.hpp"
 #include "context.hpp"
 #include "parser.hpp"
@@ -20,6 +16,7 @@ namespace Sass {
     eval(Eval(*this)),
     env_stack(std::vector<Env*>()),
     block_stack(std::vector<Block*>()),
+    call_stack(std::vector<AST_Node*>()),
     property_stack(std::vector<String*>()),
     selector_stack(std::vector<Selector_List*>()),
     backtrace_stack(std::vector<Backtrace*>()),
@@ -28,6 +25,7 @@ namespace Sass {
     env_stack.push_back(0);
     env_stack.push_back(env);
     block_stack.push_back(0);
+    call_stack.push_back(0);
     // import_stack.push_back(0);
     property_stack.push_back(0);
     selector_stack.push_back(0);
@@ -106,7 +104,7 @@ namespace Sass {
           while (tail) {
             if (tail->head()) for (Simple_Selector* header : tail->head()->elements()) {
               if (dynamic_cast<Parent_Selector*>(header) == NULL) continue; // skip all others
-              To_String to_string(&ctx); std::string sel_str(complex_selector->perform(&to_string));
+              std::string sel_str(complex_selector->to_string(ctx.c_options));
               error("Base-level rules cannot contain the parent-selector-referencing character '&'.", header->pstate(), backtrace());
             }
             tail = tail->tail();
@@ -120,12 +118,21 @@ namespace Sass {
     if (sel == 0) throw std::runtime_error("Expanded null selector");
 
     selector_stack.push_back(sel);
+    Env* env = 0;
+    if (block_stack.back()->is_root()) {
+      env = new Env(environment());
+      env_stack.push_back(env);
+    }
     Block* blk = r->block()->perform(this)->block();
     Ruleset* rr = SASS_MEMORY_NEW(ctx.mem, Ruleset,
                                   r->pstate(),
                                   sel,
                                   blk);
     selector_stack.pop_back();
+    if (block_stack.back()->is_root()) {
+      env_stack.pop_back();
+      delete env;
+    }
     rr->tabs(r->tabs());
 
     return rr;
@@ -177,12 +184,15 @@ namespace Sass {
 
   Statement* Expand::operator()(Media_Block* m)
   {
-    To_String to_string(&ctx);
     Expression* mq = m->media_queries()->perform(&eval);
-    mq = Parser::from_c_str(mq->perform(&to_string).c_str(), ctx, mq->pstate()).parse_media_queries();
+    std::string str_mq(mq->to_string(ctx.c_options));
+    char* str = sass_strdup(str_mq.c_str());
+    ctx.strings.push_back(str);
+    Parser p(Parser::from_c_str(str, ctx, mq->pstate()));
+    mq = p.parse_media_queries();
     Media_Block* mm = SASS_MEMORY_NEW(ctx.mem, Media_Block,
                                       m->pstate(),
-                                      static_cast<List*>(mq),
+                                      static_cast<List*>(mq->perform(&eval)),
                                       m->block()->perform(this)->block(),
                                       0);
     mm->tabs(m->tabs());
@@ -318,6 +328,11 @@ namespace Sass {
 
   Statement* Expand::operator()(Import_Stub* i)
   {
+    // get parent node from call stack
+    AST_Node* parent = call_stack.back();
+    if (parent && dynamic_cast<Block*>(parent) == NULL) {
+      error("Import directives may not be used within control directives or mixins.", i->pstate());
+    }
     // we don't seem to need that actually afterall
     Sass_Import_Entry import = sass_make_import(
       i->imp_path().c_str(),
@@ -355,12 +370,18 @@ namespace Sass {
 
   Statement* Expand::operator()(Comment* c)
   {
+    eval.is_in_comment = true;
+    auto rv = SASS_MEMORY_NEW(ctx.mem, Comment, c->pstate(), static_cast<String*>(c->text()->perform(&eval)), c->is_important());
+    eval.is_in_comment = false;
     // TODO: eval the text, once we're parsing/storing it as a String_Schema
-    return SASS_MEMORY_NEW(ctx.mem, Comment, c->pstate(), static_cast<String*>(c->text()->perform(&eval)), c->is_important());
+    return rv;
   }
 
   Statement* Expand::operator()(If* i)
   {
+    Env env(environment(), true);
+    env_stack.push_back(&env);
+    call_stack.push_back(i);
     if (*i->predicate()->perform(&eval)) {
       append_block(i->block());
     }
@@ -368,6 +389,8 @@ namespace Sass {
       Block* alt = i->alternative();
       if (alt) append_block(alt);
     }
+    call_stack.pop_back();
+    env_stack.pop_back();
     return 0;
   }
 
@@ -378,11 +401,11 @@ namespace Sass {
     std::string variable(f->variable());
     Expression* low = f->lower_bound()->perform(&eval);
     if (low->concrete_type() != Expression::NUMBER) {
-      error("lower bound of `@for` directive must be numeric", low->pstate(), backtrace());
+      throw Exception::TypeMismatch(*low, "integer");
     }
     Expression* high = f->upper_bound()->perform(&eval);
     if (high->concrete_type() != Expression::NUMBER) {
-      error("upper bound of `@for` directive must be numeric", high->pstate(), backtrace());
+      throw Exception::TypeMismatch(*high, "integer");
     }
     Number* sass_start = static_cast<Number*>(low);
     Number* sass_end = static_cast<Number*>(high);
@@ -396,10 +419,11 @@ namespace Sass {
     double start = sass_start->value();
     double end = sass_end->value();
     // only create iterator once in this environment
-    Env* env = environment();
-    Number* it = SASS_MEMORY_NEW(env->mem, Number, low->pstate(), start, sass_end->unit());
-    AST_Node* old_var = env->has_local(variable) ? env->get_local(variable) : 0;
-    env->set_local(variable, it);
+    Env env(environment(), true);
+    env_stack.push_back(&env);
+    call_stack.push_back(f);
+    Number* it = SASS_MEMORY_NEW(env.mem, Number, low->pstate(), start, sass_end->unit());
+    env.set_local(variable, it);
     Block* body = f->block();
     if (start < end) {
       if (f->is_inclusive()) ++end;
@@ -407,7 +431,7 @@ namespace Sass {
            i < end;
            ++i) {
         it->value(i);
-        env->set_local(variable, it);
+        env.set_local(variable, it);
         append_block(body);
       }
     } else {
@@ -416,13 +440,12 @@ namespace Sass {
            i > end;
            --i) {
         it->value(i);
-        env->set_local(variable, it);
+        env.set_local(variable, it);
         append_block(body);
       }
     }
-    // restore original environment
-    if (!old_var) env->del_local(variable);
-    else env->set_local(variable, old_var);
+    call_stack.pop_back();
+    env_stack.pop_back();
     return 0;
   }
 
@@ -432,11 +455,15 @@ namespace Sass {
   {
     std::vector<std::string> variables(e->variables());
     Expression* expr = e->list()->perform(&eval);
-    List* list = 0;
+    Vectorized<Expression*>* list = 0;
     Map* map = 0;
     if (expr->concrete_type() == Expression::MAP) {
       map = static_cast<Map*>(expr);
     }
+    else if (Selector_List* ls = dynamic_cast<Selector_List*>(expr)) {
+      Listize listize(ctx.mem);
+      list = dynamic_cast<List*>(ls->perform(&listize));
+    }
     else if (expr->concrete_type() != Expression::LIST) {
       list = SASS_MEMORY_NEW(ctx.mem, List, expr->pstate(), 1, SASS_COMMA);
       *list << expr;
@@ -445,12 +472,9 @@ namespace Sass {
       list = static_cast<List*>(expr);
     }
     // remember variables and then reset them
-    Env* env = environment();
-    std::vector<AST_Node*> old_vars(variables.size());
-    for (size_t i = 0, L = variables.size(); i < L; ++i) {
-      old_vars[i] = env->has_local(variables[i]) ? env->get_local(variables[i]) : 0;
-      env->set_local(variables[i], 0);
-    }
+    Env env(environment(), true);
+    env_stack.push_back(&env);
+    call_stack.push_back(e);
     Block* body = e->block();
 
     if (map) {
@@ -462,16 +486,19 @@ namespace Sass {
           List* variable = SASS_MEMORY_NEW(ctx.mem, List, map->pstate(), 2, SASS_SPACE);
           *variable << k;
           *variable << v;
-          env->set_local(variables[0], variable);
+          env.set_local(variables[0], variable);
         } else {
-          env->set_local(variables[0], k);
-          env->set_local(variables[1], v);
+          env.set_local(variables[0], k);
+          env.set_local(variables[1], v);
         }
         append_block(body);
       }
     }
     else {
-      bool arglist = list->is_arglist();
+      // bool arglist = list->is_arglist();
+      if (list->length() == 1 && dynamic_cast<Selector_List*>(list)) {
+        list = dynamic_cast<Vectorized<Expression*>*>(list);
+      }
       for (size_t i = 0, L = list->length(); i < L; ++i) {
         Expression* e = (*list)[i];
         // unwrap value if the expression is an argument
@@ -480,33 +507,30 @@ namespace Sass {
         if (List* scalars = dynamic_cast<List*>(e)) {
           if (variables.size() == 1) {
             Expression* var = scalars;
-            if (arglist) var = (*scalars)[0];
-            env->set_local(variables[0], var);
+            // if (arglist) var = (*scalars)[0];
+            env.set_local(variables[0], var);
           } else {
             for (size_t j = 0, K = variables.size(); j < K; ++j) {
               Expression* res = j >= scalars->length()
                 ? SASS_MEMORY_NEW(ctx.mem, Null, expr->pstate())
                 : (*scalars)[j]->perform(&eval);
-              env->set_local(variables[j], res);
+              env.set_local(variables[j], res);
             }
           }
         } else {
           if (variables.size() > 0) {
-            env->set_local(variables[0], e);
+            env.set_local(variables[0], e);
             for (size_t j = 1, K = variables.size(); j < K; ++j) {
               Expression* res = SASS_MEMORY_NEW(ctx.mem, Null, expr->pstate());
-              env->set_local(variables[j], res);
+              env.set_local(variables[j], res);
             }
           }
         }
         append_block(body);
       }
     }
-    // restore original environment
-    for (size_t j = 0, K = variables.size(); j < K; ++j) {
-      if(!old_vars[j]) env->del_local(variables[j]);
-      else env->set_local(variables[j], old_vars[j]);
-    }
+    call_stack.pop_back();
+    env_stack.pop_back();
     return 0;
   }
 
@@ -514,9 +538,14 @@ namespace Sass {
   {
     Expression* pred = w->predicate();
     Block* body = w->block();
+    Env env(environment(), true);
+    env_stack.push_back(&env);
+    call_stack.push_back(w);
     while (*pred->perform(&eval)) {
       append_block(body);
     }
+    call_stack.pop_back();
+    env_stack.pop_back();
     return 0;
   }
 
@@ -526,20 +555,16 @@ namespace Sass {
     return 0;
   }
 
-  Statement* Expand::operator()(Extension* e)
-  {
-    To_String to_string(&ctx);
-    Selector_List* extender = dynamic_cast<Selector_List*>(selector());
-    if (!extender) return 0;
-    selector_stack.push_back(0);
 
-    if (Selector_List* selector_list = dynamic_cast<Selector_List*>(e->selector())) {
-      for (Complex_Selector* complex_selector : selector_list->elements()) {
+  void Expand::expand_selector_list(Selector* s, Selector_List* extender) {
+
+    if (Selector_List* sl = dynamic_cast<Selector_List*>(s)) {
+      for (Complex_Selector* complex_selector : sl->elements()) {
         Complex_Selector* tail = complex_selector;
         while (tail) {
           if (tail->head()) for (Simple_Selector* header : tail->head()->elements()) {
             if (dynamic_cast<Parent_Selector*>(header) == NULL) continue; // skip all others
-            To_String to_string(&ctx); std::string sel_str(complex_selector->perform(&to_string));
+            std::string sel_str(complex_selector->to_string(ctx.c_options));
             error("Can't extend " + sel_str + ": can't extend parent selectors", header->pstate(), backtrace());
           }
           tail = tail->tail();
@@ -547,16 +572,17 @@ namespace Sass {
       }
     }
 
-    Selector_List* contextualized = dynamic_cast<Selector_List*>(e->selector()->perform(&eval));
-    if (contextualized == NULL) return 0;
+
+    Selector_List* contextualized = dynamic_cast<Selector_List*>(s->perform(&eval));
+    if (contextualized == NULL) return;
     for (auto complex_sel : contextualized->elements()) {
       Complex_Selector* c = complex_sel;
       if (!c->head() || c->tail()) {
-        To_String to_string(&ctx); std::string sel_str(contextualized->perform(&to_string));
+        std::string sel_str(contextualized->to_string(ctx.c_options));
         error("Can't extend " + sel_str + ": can't extend nested selectors", c->pstate(), backtrace());
       }
       Compound_Selector* placeholder = c->head();
-      placeholder->is_optional(e->selector()->is_optional());
+      placeholder->is_optional(s->is_optional());
       for (size_t i = 0, L = extender->length(); i < L; ++i) {
         Complex_Selector* sel = (*extender)[i];
         if (!(sel->head() && sel->head()->length() > 0 &&
@@ -579,8 +605,16 @@ namespace Sass {
       }
     }
 
-    selector_stack.pop_back();
+  }
 
+  Statement* Expand::operator()(Extension* e)
+  {
+    if (Selector_List* extender = dynamic_cast<Selector_List*>(selector())) {
+      selector_stack.push_back(0);
+      Selector* s = e->selector();
+      expand_selector_list(s, extender);
+      selector_stack.pop_back();
+    }
     return 0;
   }
 
@@ -680,10 +714,12 @@ namespace Sass {
   // process and add to last block on stack
   inline void Expand::append_block(Block* b)
   {
+    if (b->is_root()) call_stack.push_back(b);
     for (size_t i = 0, L = b->length(); i < L; ++i) {
       Statement* ith = (*b)[i]->perform(this);
       if (ith) *block_stack.back() << ith;
     }
+    if (b->is_root()) call_stack.pop_back();
   }
 
 }

data/ext/libsass/src/expand.hpp

@@ -30,6 +30,7 @@ namespace Sass {
     // it's easier to work with vectors
     std::vector<Env*>      env_stack;
     std::vector<Block*>    block_stack;
+    std::vector<AST_Node*> call_stack;
     std::vector<String*>   property_stack;
     std::vector<Selector_List*> selector_stack;
     std::vector<Backtrace*>backtrace_stack;
@@ -37,11 +38,12 @@ namespace Sass {
 
     Statement* fallback_impl(AST_Node* n);
 
+  private:
+    void expand_selector_list(Selector*, Selector_List* extender);
+
   public:
     Expand(Context&, Env*, Backtrace*);
-    virtual ~Expand() { }
-
-    using Operation<Statement*>::operator();
+    ~Expand() { }
 
     Statement* operator()(Block*);
     Statement* operator()(Ruleset*);

data/ext/libsass/src/extend.cpp

@@ -1,10 +1,6 @@
-#ifdef _MSC_VER
-#pragma warning(disable : 4503)
-#endif
-
+#include "sass.hpp"
 #include "extend.hpp"
 #include "context.hpp"
-#include "to_string.hpp"
 #include "backtrace.hpp"
 #include "paths.hpp"
 #include "parser.hpp"
@@ -85,23 +81,20 @@ namespace Sass {
 
 
   std::ostream& operator<<(std::ostream& os, Compound_Selector& compoundSelector) {
-    To_String to_string;
     for (size_t i = 0, L = compoundSelector.length(); i < L; ++i) {
       if (i > 0) os << ", ";
-      os << compoundSelector[i]->perform(&to_string);
+      os << compoundSelector[i]->to_string();
     }
     return os;
   }
 
   std::ostream& operator<<(std::ostream& os, Simple_Selector& simpleSelector) {
-    To_String to_string;
-    os << simpleSelector.perform(&to_string);
+    os << simpleSelector.to_string();
     return os;
   }
 
   // Print a string representation of a Compound_Selector
   static void printSimpleSelector(Simple_Selector* pSimpleSelector, const char* message=NULL, bool newline=true) {
-    To_String to_string;
 
     if (message) {
       std::cerr << message;
@@ -125,7 +118,6 @@ namespace Sass {
 
   // Print a string representation of a Compound_Selector
   static void printCompoundSelector(Compound_Selector* pCompoundSelector, const char* message=NULL, bool newline=true) {
-    To_String to_string;
 
     if (message) {
       std::cerr << message;
@@ -144,7 +136,6 @@ namespace Sass {
 
 
   std::ostream& operator<<(std::ostream& os, Complex_Selector& complexSelector) {
-    To_String to_string;
 
     os << "[";
     Complex_Selector* pIter = &complexSelector;
@@ -164,7 +155,7 @@ namespace Sass {
       first = false;
 
       if (pIter->head()) {
-        os << pIter->head()->perform(&to_string);
+        os << pIter->head()->to_string();
       } else {
         os << "NULL_HEAD";
       }
@@ -179,7 +170,6 @@ namespace Sass {
 
   // Print a string representation of a Complex_Selector
   static void printComplexSelector(Complex_Selector* pComplexSelector, const char* message=NULL, bool newline=true) {
-    To_String to_string;
 
     if (message) {
       std::cerr << message;
@@ -197,7 +187,6 @@ namespace Sass {
   }
 
   static void printSelsNewSeqPairCollection(SelsNewSeqPairCollection& collection, const char* message=NULL, bool newline=true) {
-    To_String to_string;
 
     if (message) {
       std::cerr << message;
@@ -225,7 +214,6 @@ namespace Sass {
 
   // Print a string representation of a SourcesSet
   static void printSourcesSet(SourcesSet& sources, Context& ctx, const char* message=NULL, bool newline=true) {
-    To_String to_string;
 
     if (message) {
       std::cerr << message;
@@ -1558,8 +1546,6 @@ namespace Sass {
     Node extendedSelectors = Node::createCollection();
     // extendedSelectors.got_line_feed = true;
 
-    To_String to_string;
-
     SubsetMapEntries entries = subset_map.get_v(pSelector->to_str_vec());
 
     typedef std::vector<std::pair<Complex_Selector, std::vector<ExtensionPair> > > GroupedByToAResult;
@@ -1591,6 +1577,7 @@ namespace Sass {
         for (size_t index = 0; index < pCompound->length(); index++) {
           Simple_Selector* pSimpleSelector = (*pCompound)[index];
           (*pSels) << pSimpleSelector;
+          pCompound->extended(true);
         }
       }
 
@@ -1732,18 +1719,32 @@ namespace Sass {
       Compound_Selector* pHead = pIter->head();
 
       if (pHead) {
+        for (Simple_Selector* pSimple : *pHead) {
+          if (Wrapped_Selector* ws = dynamic_cast<Wrapped_Selector*>(pSimple)) {
+            if (Selector_List* sl = dynamic_cast<Selector_List*>(ws->selector())) {
+              for (Complex_Selector* cs : sl->elements()) {
+                while (cs) {
+                  if (complexSelectorHasExtension(cs, ctx, subset_map)) {
+                    hasExtension = true;
+                    break;
+                  }
+                  cs = cs->tail();
+                }
+              }
+            }
+          }
+        }
         SubsetMapEntries entries = subset_map.get_v(pHead->to_str_vec());
         for (ExtensionPair ext : entries) {
           // check if both selectors have the same media block parent
           if (ext.first->media_block() == pComplexSelector->media_block()) continue;
-          To_String to_string(&ctx);
           if (ext.second->media_block() == 0) continue;
           if (pComplexSelector->media_block() &&
               ext.second->media_block()->media_queries() &&
               pComplexSelector->media_block()->media_queries()
           ) {
-            std::string query_left(ext.second->media_block()->media_queries()->perform(&to_string));
-            std::string query_right(pComplexSelector->media_block()->media_queries()->perform(&to_string));
+            std::string query_left(ext.second->media_block()->media_queries()->to_string(ctx.c_options));
+            std::string query_right(pComplexSelector->media_block()->media_queries()->to_string(ctx.c_options));
             if (query_left == query_right) continue;
           }
 
@@ -1754,7 +1755,7 @@ namespace Sass {
           std::string rel_path(Sass::File::abs2rel(pstate.path, cwd, cwd));
           err << "You may not @extend an outer selector from within @media.\n";
           err << "You may only @extend selectors within the same directive.\n";
-          err << "From \"@extend " << ext.second->perform(&to_string) << "\"";
+          err << "From \"@extend " << ext.second->to_string(ctx.c_options) << "\"";
           err << " on line " << pstate.line+1 << " of " << rel_path << "\n";
           error(err.str(), pComplexSelector->pstate());
         }
@@ -1764,29 +1765,6 @@ namespace Sass {
       pIter = pIter->tail();
     }
 
-    if (!hasExtension) {
-      /* ToDo: don't break stuff
-      std::stringstream err;
-      To_String to_string(&ctx);
-      std::string cwd(Sass::File::get_cwd());
-      std::string sel1(pComplexSelector->perform(&to_string));
-      Compound_Selector* pExtendSelector = 0;
-      for (auto i : subset_map.values()) {
-        if (i.first == pComplexSelector) {
-          pExtendSelector = i.second;
-          break;
-        }
-      }
-      if (!pExtendSelector || !pExtendSelector->is_optional()) {
-        std::string sel2(pExtendSelector ? pExtendSelector->perform(&to_string) : "[unknown]");
-        err << "\"" << sel1 << "\" failed to @extend \"" << sel2 << "\"\n";
-        err << "The selector \"" << sel2 << "\" was not found.\n";
-        err << "Use \"@extend " << sel2 << " !optional\" if the extend should be able to fail.";
-        error(err.str(), pExtendSelector ? pExtendSelector->pstate() : pComplexSelector->pstate());
-      }
-      */
-    }
-
     return hasExtension;
   }
 
@@ -1928,8 +1906,6 @@ namespace Sass {
   */
   Selector_List* Extend::extendSelectorList(Selector_List* pSelectorList, Context& ctx, ExtensionSubsetMap& subset_map, bool isReplace, bool& extendedSomething) {
 
-    To_String to_string(&ctx);
-
     Selector_List* pNewSelectors = SASS_MEMORY_NEW(ctx.mem, Selector_List, pSelectorList->pstate(), pSelectorList->length());
 
     extendedSomething = false;
@@ -1967,6 +1943,21 @@ namespace Sass {
       }
     }
 
+    for (Complex_Selector* cs : *pNewSelectors) {
+      while (cs) {
+        if (cs->head()) {
+        for (Simple_Selector* ss : *cs->head()) {
+          if (Wrapped_Selector* ws = dynamic_cast<Wrapped_Selector*>(ss)) {
+            if (Selector_List* sl = dynamic_cast<Selector_List*>(ws->selector())) {
+              bool extended = false;
+              ws->selector(extendSelectorList(sl, ctx, subset_map, false, extended));
+            }
+          }
+        }
+        }
+        cs = cs->tail();
+      }
+    }
     return pNewSelectors;
 
   }
@@ -2006,9 +1997,8 @@ namespace Sass {
   // Extend a ruleset by extending the selectors and updating them on the ruleset. The block's rules don't need to change.
   template <typename ObjectType>
   static void extendObjectWithSelectorAndBlock(ObjectType* pObject, Context& ctx, ExtensionSubsetMap& subset_map) {
-    To_String to_string(&ctx);
 
-    DEBUG_PRINTLN(EXTEND_OBJECT, "FOUND SELECTOR: " << static_cast<Selector_List*>(pObject->selector())->perform(&to_string))
+    DEBUG_PRINTLN(EXTEND_OBJECT, "FOUND SELECTOR: " << static_cast<Selector_List*>(pObject->selector())->to_string(ctx.c_options))
 
     // Ruby sass seems to filter nodes that don't have any content well before we get here. I'm not sure the repercussions
     // of doing so, so for now, let's just not extend things that won't be output later.
@@ -2021,8 +2011,8 @@ namespace Sass {
     Selector_List* pNewSelectorList = Extend::extendSelectorList(static_cast<Selector_List*>(pObject->selector()), ctx, subset_map, false, extendedSomething);
 
     if (extendedSomething && pNewSelectorList) {
-      DEBUG_PRINTLN(EXTEND_OBJECT, "EXTEND ORIGINAL SELECTORS: " << static_cast<Selector_List*>(pObject->selector())->perform(&to_string))
-      DEBUG_PRINTLN(EXTEND_OBJECT, "EXTEND SETTING NEW SELECTORS: " << pNewSelectorList->perform(&to_string))
+      DEBUG_PRINTLN(EXTEND_OBJECT, "EXTEND ORIGINAL SELECTORS: " << static_cast<Selector_List*>(pObject->selector())->to_string(ctx.c_options))
+      DEBUG_PRINTLN(EXTEND_OBJECT, "EXTEND SETTING NEW SELECTORS: " << pNewSelectorList->to_string(ctx.c_options))
       pNewSelectorList->remove_parent_selectors();
       pObject->selector(pNewSelectorList);
     } else {
@@ -2041,6 +2031,25 @@ namespace Sass {
     for (size_t i = 0, L = b->length(); i < L; ++i) {
       (*b)[i]->perform(this);
     }
+    // do final check if everything was extended
+    // we set `extended` flag on extended selectors
+    if (b->is_root()) {
+      // debug_subset_map(subset_map);
+      for(auto const &it : subset_map.values()) {
+        Complex_Selector* sel = it.first ? it.first->first() : NULL;
+        Compound_Selector* ext = it.second ? it.second : NULL;
+        if (ext && (ext->extended() || ext->is_optional())) continue;
+        std::string str_sel(sel->to_string({ NESTED, 5 }));
+        std::string str_ext(ext->to_string({ NESTED, 5 }));
+        // debug_ast(sel, "sel: ");
+        // debug_ast(ext, "ext: ");
+        error("\"" + str_sel + "\" failed to @extend \"" + str_ext + "\".\n"
+              "The selector \"" + str_ext + "\" was not found.\n"
+              "Use \"@extend " + str_ext + " !optional\" if the"
+                " extend should be able to fail.", ext->pstate());
+      }
+    }
+
   }
 
   void Extend::operator()(Ruleset* pRuleset)