sassc 2.2.1 → 2.4.0

data/ext/libsass/src/ast_sel_unify.cpp

@@ -1,280 +1,275 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
-#include "ast.hpp"
-#include "context.hpp"
-#include "node.hpp"
-#include "eval.hpp"
-#include "extend.hpp"
-#include "emitter.hpp"
-#include "color_maps.hpp"
-#include "ast_fwd_decl.hpp"
-#include <set>
-#include <iomanip>
-#include <iostream>
-#include <algorithm>
-#include <functional>
-#include <cctype>
-#include <locale>
-
-#include "ast_selectors.hpp"
 
-// #define DEBUG_UNIFY
+#include "ast.hpp"
 
 namespace Sass {
 
-  Compound_Selector* Compound_Selector::unify_with(Compound_Selector* rhs)
+  // ##########################################################################
+  // Returns the contents of a [SelectorList] that matches only 
+  // elements that are matched by both [complex1] and [complex2].
+  // If no such list can be produced, returns `null`.
+  // ##########################################################################
+  // ToDo: fine-tune API to avoid unnecessary wrapper allocations
+  // ##########################################################################
+  sass::vector<sass::vector<SelectorComponentObj>> unifyComplex(
+    const sass::vector<sass::vector<SelectorComponentObj>>& complexes)
   {
-    #ifdef DEBUG_UNIFY
-    const std::string debug_call = "unify(Compound[" + this->to_string() + "], Compound[" + rhs->to_string() + "])";
-    std::cerr << debug_call << std::endl;
-    #endif
 
+    SASS_ASSERT(!complexes.empty(), "Can't unify empty list");
+    if (complexes.size() == 1) return complexes;
+
+    CompoundSelectorObj unifiedBase = SASS_MEMORY_NEW(CompoundSelector, SourceSpan("[phony]"));
+    for (auto complex : complexes) {
+      SelectorComponentObj base = complex.back();
+      if (CompoundSelector * comp = base->getCompound()) {
+        if (unifiedBase->empty()) {
+          unifiedBase->concat(comp);
+        }
+        else {
+          for (SimpleSelectorObj simple : comp->elements()) {
+            unifiedBase = simple->unifyWith(unifiedBase);
+            if (unifiedBase.isNull()) return {};
+          }
+        }
+      }
+      else {
+        return {};
+      }
+    }
+
+    sass::vector<sass::vector<SelectorComponentObj>> complexesWithoutBases;
+    for (size_t i = 0; i < complexes.size(); i += 1) {
+      sass::vector<SelectorComponentObj> sel = complexes[i];
+      sel.pop_back(); // remove last item (base) from the list
+      complexesWithoutBases.push_back(std::move(sel));
+    }
+
+    complexesWithoutBases.back().push_back(unifiedBase);
+
+    return weave(complexesWithoutBases);
+
+  }
+  // EO unifyComplex
+
+  // ##########################################################################
+  // Returns a [CompoundSelector] that matches only elements
+  // that are matched by both [compound1] and [compound2].
+  // If no such selector can be produced, returns `null`.
+  // ##########################################################################
+  CompoundSelector* CompoundSelector::unifyWith(CompoundSelector* rhs)
+  {
     if (empty()) return rhs;
-    Compound_Selector_Obj unified = SASS_MEMORY_COPY(rhs);
-    for (const Simple_Selector_Obj& sel : elements()) {
-      unified = sel->unify_with(unified);
+    CompoundSelectorObj unified = SASS_MEMORY_COPY(rhs);
+    for (const SimpleSelectorObj& sel : elements()) {
+      unified = sel->unifyWith(unified);
       if (unified.isNull()) break;
     }
-
-    #ifdef DEBUG_UNIFY
-    std::cerr << "> " << debug_call << " = Compound[" << unified->to_string() << "]" << std::endl;
-    #endif
     return unified.detach();
   }
-
-  Compound_Selector* Simple_Selector::unify_with(Compound_Selector* rhs)
+  // EO CompoundSelector::unifyWith(CompoundSelector*)
+
+  // ##########################################################################
+  // Returns the compoments of a [CompoundSelector] that matches only elements
+  // matched by both this and [compound]. By default, this just returns a copy
+  // of [compound] with this selector added to the end, or returns the original
+  // array if this selector already exists in it. Returns `null` if unification
+  // is impossible—for example, if there are multiple ID selectors.
+  // ##########################################################################
+  // This is implemented in `selector/simple.dart` as `SimpleSelector::unify`
+  // ##########################################################################
+  CompoundSelector* SimpleSelector::unifyWith(CompoundSelector* rhs)
   {
-    #ifdef DEBUG_UNIFY
-    const std::string debug_call = "unify(Simple[" + this->to_string() + "], Compound[" + rhs->to_string() + "])";
-    std::cerr << debug_call << std::endl;
-    #endif
 
     if (rhs->length() == 1) {
-      if (rhs->at(0)->is_universal()) {
-        Compound_Selector* this_compound = SASS_MEMORY_NEW(Compound_Selector, pstate(), 1);
+      if (rhs->get(0)->is_universal()) {
+        CompoundSelector* this_compound = SASS_MEMORY_NEW(CompoundSelector, pstate());
         this_compound->append(SASS_MEMORY_COPY(this));
-        Compound_Selector* unified = rhs->at(0)->unify_with(this_compound);
+        CompoundSelector* unified = rhs->get(0)->unifyWith(this_compound);
         if (unified == nullptr || unified != this_compound) delete this_compound;
-
-        #ifdef DEBUG_UNIFY
-        std::cerr << "> " << debug_call << " = " << "Compound[" << unified->to_string() << "]" << std::endl;
-        #endif
         return unified;
       }
     }
-    for (const Simple_Selector_Obj& sel : rhs->elements()) {
+    for (const SimpleSelectorObj& sel : rhs->elements()) {
       if (*this == *sel) {
-        #ifdef DEBUG_UNIFY
-        std::cerr << "> " << debug_call << " = " << "Compound[" << rhs->to_string() << "]" << std::endl;
-        #endif
         return rhs;
       }
     }
-    const int lhs_order = this->unification_order();
-    size_t i = rhs->length();
-    while (i > 0 && lhs_order < rhs->at(i - 1)->unification_order()) --i;
-    rhs->insert(rhs->begin() + i, this);
-    #ifdef DEBUG_UNIFY
-    std::cerr << "> " << debug_call << " = " << "Compound[" << rhs->to_string() << "]" << std::endl;
-    #endif
-    return rhs;
-  }
 
-  Simple_Selector* Type_Selector::unify_with(Simple_Selector* rhs)
-  {
-    #ifdef DEBUG_UNIFY
-    const std::string debug_call = "unify(Type[" + this->to_string() + "], Simple[" + rhs->to_string() + "])";
-    std::cerr << debug_call << std::endl;
-    #endif
+    CompoundSelectorObj result = SASS_MEMORY_NEW(CompoundSelector, rhs->pstate());
 
-    bool rhs_ns = false;
-    if (!(is_ns_eq(*rhs) || rhs->is_universal_ns())) {
-      if (!is_universal_ns()) {
-        #ifdef DEBUG_UNIFY
-        std::cerr << "> " << debug_call << " = nullptr" << std::endl;
-        #endif
-        return nullptr;
-      }
-      rhs_ns = true;
-    }
-    bool rhs_name = false;
-    if (!(name_ == rhs->name() || rhs->is_universal())) {
-      if (!(is_universal())) {
-        #ifdef DEBUG_UNIFY
-        std::cerr << "> " << debug_call << " = nullptr" << std::endl;
-        #endif
-        return nullptr;
+    bool addedThis = false;
+    for (auto simple : rhs->elements()) {
+      // Make sure pseudo selectors always come last.
+      if (!addedThis && simple->getPseudoSelector()) {
+        result->append(this);
+        addedThis = true;
       }
-      rhs_name = true;
+      result->append(simple);
     }
-    if (rhs_ns) {
-      ns(rhs->ns());
-      has_ns(rhs->has_ns());
+
+    if (!addedThis) {
+      result->append(this);
     }
-    if (rhs_name) name(rhs->name());
-    #ifdef DEBUG_UNIFY
-    std::cerr << "> " << debug_call << " = Simple[" << this->to_string() << "]" << std::endl;
-    #endif
-    return this;
+    return result.detach();
+
   }
+  // EO SimpleSelector::unifyWith(CompoundSelector*)
 
-  Compound_Selector* Type_Selector::unify_with(Compound_Selector* rhs)
+  // ##########################################################################
+  // This is implemented in `selector/type.dart` as `PseudoSelector::unify`
+  // ##########################################################################
+  CompoundSelector* TypeSelector::unifyWith(CompoundSelector* rhs)
   {
-    #ifdef DEBUG_UNIFY
-    const std::string debug_call = "unify(Type[" + this->to_string() + "], Compound[" + rhs->to_string() + "])";
-    std::cerr << debug_call << std::endl;
-    #endif
-
     if (rhs->empty()) {
       rhs->append(this);
-      #ifdef DEBUG_UNIFY
-      std::cerr << "> " << debug_call << " = Compound[" << rhs->to_string() << "]" << std::endl;
-      #endif
       return rhs;
     }
-    Type_Selector* rhs_0 = Cast<Type_Selector>(rhs->at(0));
-    if (rhs_0 != nullptr) {
-      Simple_Selector* unified = unify_with(rhs_0);
+    TypeSelector* type = Cast<TypeSelector>(rhs->at(0));
+    if (type != nullptr) {
+      SimpleSelector* unified = unifyWith(type);
       if (unified == nullptr) {
-        #ifdef DEBUG_UNIFY
-        std::cerr << "> " << debug_call << " = nullptr" << std::endl;
-        #endif
         return nullptr;
       }
       rhs->elements()[0] = unified;
-    } else if (!is_universal() || (has_ns_ && ns_ != "*")) {
+    }
+    else if (!is_universal() || (has_ns_ && ns_ != "*")) {
       rhs->insert(rhs->begin(), this);
     }
-    #ifdef DEBUG_UNIFY
-    std::cerr << "> " << debug_call << " = Compound[" << rhs->to_string() << "]" << std::endl;
-    #endif
     return rhs;
   }
 
-  Compound_Selector* Class_Selector::unify_with(Compound_Selector* rhs)
-  {
-    rhs->has_line_break(has_line_break());
-    return Simple_Selector::unify_with(rhs);
-  }
-
-  Compound_Selector* Id_Selector::unify_with(Compound_Selector* rhs)
+  // ##########################################################################
+  // This is implemented in `selector/id.dart` as `PseudoSelector::unify`
+  // ##########################################################################
+  CompoundSelector* IDSelector::unifyWith(CompoundSelector* rhs)
   {
-    for (const Simple_Selector_Obj& sel : rhs->elements()) {
-      if (Id_Selector* id_sel = Cast<Id_Selector>(sel)) {
+    for (const SimpleSelector* sel : rhs->elements()) {
+      if (const IDSelector* id_sel = Cast<IDSelector>(sel)) {
         if (id_sel->name() != name()) return nullptr;
       }
     }
-    rhs->has_line_break(has_line_break());
-    return Simple_Selector::unify_with(rhs);
-  }
-
-  Compound_Selector* Pseudo_Selector::unify_with(Compound_Selector* rhs)
-  {
-    if (is_pseudo_element()) {
-      for (const Simple_Selector_Obj& sel : rhs->elements()) {
-        if (Pseudo_Selector* pseudo_sel = Cast<Pseudo_Selector>(sel)) {
-          if (pseudo_sel->is_pseudo_element() && pseudo_sel->name() != name()) return nullptr;
-        }
-      }
-    }
-    return Simple_Selector::unify_with(rhs);
+    return SimpleSelector::unifyWith(rhs);
   }
 
-  Selector_List* Complex_Selector::unify_with(Complex_Selector* rhs)
+  // ##########################################################################
+  // This is implemented in `selector/pseudo.dart` as `PseudoSelector::unify`
+  // ##########################################################################
+  CompoundSelector* PseudoSelector::unifyWith(CompoundSelector* compound)
   {
-    #ifdef DEBUG_UNIFY
-    const std::string debug_call = "unify(Complex[" + this->to_string() + "], Complex[" + rhs->to_string() + "])";
-    std::cerr << debug_call << std::endl;
-    #endif
-
-    // get last tails (on the right side)
-    Complex_Selector* l_last = this->mutable_last();
-    Complex_Selector* r_last = rhs->mutable_last();
-
-    // check valid pointers (assertion)
-    SASS_ASSERT(l_last, "lhs is null");
-    SASS_ASSERT(r_last, "rhs is null");
-
-    // Not sure about this check, but closest way I could check
-    // was to see if this is a ruby 'SimpleSequence' equivalent.
-    // It seems to do the job correctly as some specs react to this
-    if (l_last->combinator() != Combinator::ANCESTOR_OF) return nullptr;
-    if (r_last->combinator() != Combinator::ANCESTOR_OF) return nullptr;
-
-    // get the headers for the last tails
-    Compound_Selector* l_last_head = l_last->head();
-    Compound_Selector* r_last_head = r_last->head();
-
-    // check valid head pointers (assertion)
-    SASS_ASSERT(l_last_head, "lhs head is null");
-    SASS_ASSERT(r_last_head, "rhs head is null");
-
-    // get the unification of the last compound selectors
-    Compound_Selector_Obj unified = r_last_head->unify_with(l_last_head);
-
-    // abort if we could not unify heads
-    if (unified == nullptr) return nullptr;
-
-    // move the head
-    if (l_last_head->is_universal()) l_last->head({});
-    r_last->head(unified);
 
-    #ifdef DEBUG_UNIFY
-    std::cerr << "> " << debug_call << " before weave: lhs=" << this->to_string() << " rhs=" << rhs->to_string() << std::endl;
-    #endif
+    if (compound->length() == 1 && compound->first()->is_universal()) {
+      // std::cerr << "implement universal pseudo\n";
+    }
 
-    // create nodes from both selectors
-    Node lhsNode = complexSelectorToNode(this);
-    Node rhsNode = complexSelectorToNode(rhs);
+    for (const SimpleSelectorObj& sel : compound->elements()) {
+      if (*this == *sel) {
+        return compound;
+      }
+    }
 
-    // Complex_Selector_Obj fake = unified->to_complex();
-    // Node unified_node = complexSelectorToNode(fake);
-    // // add to permutate the list?
-    // rhsNode.plus(unified_node);
+    CompoundSelectorObj result = SASS_MEMORY_NEW(CompoundSelector, compound->pstate());
+
+    bool addedThis = false;
+    for (auto simple : compound->elements()) {
+      // Make sure pseudo selectors always come last.
+      if (PseudoSelectorObj pseudo = simple->getPseudoSelector()) {
+        if (pseudo->isElement()) {
+          // A given compound selector may only contain one pseudo element. If
+          // [compound] has a different one than [this], unification fails.
+          if (isElement()) {
+            return {};
+          }
+          // Otherwise, this is a pseudo selector and
+          // should come before pseduo elements.
+          result->append(this);
+          addedThis = true;
+        }
+      }
+      result->append(simple);
+    }
 
-    // do some magic we inherit from node and extend
-    Node node = subweave(lhsNode, rhsNode);
-    Selector_List_Obj result = SASS_MEMORY_NEW(Selector_List, pstate(), node.collection()->size());
-    for (auto &item : *node.collection()) {
-      result->append(nodeToComplexSelector(Node::naiveTrim(item)));
+    if (!addedThis) {
+      result->append(this);
     }
 
-    #ifdef DEBUG_UNIFY
-    std::cerr << "> " << debug_call << " = " << result->to_string() << std::endl;
-    #endif
+    return result.detach();
 
-    // only return if list has some entries
-    return result->length() ? result.detach() : nullptr;
   }
+  // EO PseudoSelector::unifyWith(CompoundSelector*
+
+  // ##########################################################################
+  // This is implemented in `extend/functions.dart` as `unifyUniversalAndElement`
+  // Returns a [SimpleSelector] that matches only elements that are matched by
+  // both [selector1] and [selector2], which must both be either [UniversalSelector]s
+  // or [TypeSelector]s. If no such selector can be produced, returns `null`.
+  // Note: libsass handles universal selector directly within the type selector
+  // ##########################################################################
+  SimpleSelector* TypeSelector::unifyWith(const SimpleSelector* rhs)
+  {
+    bool rhs_ns = false;
+    if (!(is_ns_eq(*rhs) || rhs->is_universal_ns())) {
+      if (!is_universal_ns()) {
+        return nullptr;
+      }
+      rhs_ns = true;
+    }
+    bool rhs_name = false;
+    if (!(name_ == rhs->name() || rhs->is_universal())) {
+      if (!(is_universal())) {
+        return nullptr;
+      }
+      rhs_name = true;
+    }
+    if (rhs_ns) {
+      ns(rhs->ns());
+      has_ns(rhs->has_ns());
+    }
+    if (rhs_name) name(rhs->name());
+    return this;
+  }
+  // EO TypeSelector::unifyWith(const SimpleSelector*)
 
-  Selector_List* Selector_List::unify_with(Selector_List* rhs) {
-    #ifdef DEBUG_UNIFY
-    const std::string debug_call = "unify(List[" + this->to_string() + "], List[" + rhs->to_string() + "])";
-    std::cerr << debug_call << std::endl;
-    #endif
+  // ##########################################################################
+  // Unify two complex selectors. Internally calls `unifyComplex`
+  // and then wraps the result in newly create ComplexSelectors.
+  // ##########################################################################
+  SelectorList* ComplexSelector::unifyWith(ComplexSelector* rhs)
+  {
+    SelectorListObj list = SASS_MEMORY_NEW(SelectorList, pstate());
+    sass::vector<sass::vector<SelectorComponentObj>> rv =
+       unifyComplex({ elements(), rhs->elements() });
+    for (sass::vector<SelectorComponentObj> items : rv) {
+      ComplexSelectorObj sel = SASS_MEMORY_NEW(ComplexSelector, pstate());
+      sel->elements() = std::move(items);
+      list->append(sel);
+    }
+    return list.detach();
+  }
+  // EO ComplexSelector::unifyWith(ComplexSelector*)
 
-    std::vector<Complex_Selector_Obj> result;
-    // Unify all of children with RHS's children, storing the results in `unified_complex_selectors`
-    for (Complex_Selector_Obj& seq1 : elements()) {
-      for (Complex_Selector_Obj& seq2 : rhs->elements()) {
-        Complex_Selector_Obj seq1_copy = SASS_MEMORY_CLONE(seq1);
-        Complex_Selector_Obj seq2_copy = SASS_MEMORY_CLONE(seq2);
-        Selector_List_Obj unified = seq1_copy->unify_with(seq2_copy);
-        if (unified) {
-          result.reserve(result.size() + unified->length());
-          std::copy(unified->begin(), unified->end(), std::back_inserter(result));
+  // ##########################################################################
+  // only called from the sass function `selector-unify`
+  // ##########################################################################
+  SelectorList* SelectorList::unifyWith(SelectorList* rhs)
+  {
+    SelectorList* slist = SASS_MEMORY_NEW(SelectorList, pstate());
+    // Unify all of children with RHS's children,
+    // storing the results in `unified_complex_selectors`
+    for (ComplexSelectorObj& seq1 : elements()) {
+      for (ComplexSelectorObj& seq2 : rhs->elements()) {
+        if (SelectorListObj unified = seq1->unifyWith(seq2)) {
+          std::move(unified->begin(), unified->end(),
+            std::inserter(slist->elements(), slist->end()));
         }
       }
     }
-
-    // Creates the final Selector_List by combining all the complex selectors
-    Selector_List* final_result = SASS_MEMORY_NEW(Selector_List, pstate(), result.size());
-    for (Complex_Selector_Obj& sel : result) {
-      final_result->append(sel);
-    }
-    #ifdef DEBUG_UNIFY
-    std::cerr << "> " << debug_call << " = " << final_result->to_string() << std::endl;
-    #endif
-    return final_result;
+    return slist;
   }
+  // EO SelectorList::unifyWith(SelectorList*)
+
+  // ##########################################################################
+  // ##########################################################################
 
 }