Revert "Merge pull request #2279 from xzyfer/bracked-lists"

This reverts commit 46f5244, reversing
changes made to f5c8d35.

Author: xzyfer

include/sass/values.h

@@ -35,13 +35,6 @@ enum Sass_Separator {
   SASS_HASH
 };
 
-  // Tags for denoting Sass list delimiters
-enum Sass_List_Delimiter {
-  SASS_NO_DELIMITER,
-  SASS_PARENTHESIS,
-  SASS_BRACKETS
-};
-
 // Value Operators
 enum Sass_OP {
   AND, OR,                   // logical connectives

src/ast.hpp

@@ -1061,25 +1061,21 @@ namespace Sass {
   private:
     ADD_PROPERTY(enum Sass_Separator, separator)
     ADD_PROPERTY(bool, is_arglist)
-    ADD_PROPERTY(enum Sass_List_Delimiter, delimiter)
     ADD_PROPERTY(bool, from_selector)
   public:
     List(ParserState pstate,
-         size_t size = 0, enum Sass_Separator sep = SASS_SPACE, bool argl = false,
-         enum Sass_List_Delimiter delimiter = SASS_NO_DELIMITER)
+         size_t size = 0, enum Sass_Separator sep = SASS_SPACE, bool argl = false)
     : Value(pstate),
       Vectorized<Expression_Obj>(size),
       separator_(sep),
       is_arglist_(argl),
-      delimiter_(delimiter),
       from_selector_(false)
     { concrete_type(LIST); }
     List(const List* ptr)
     : Value(ptr),
       Vectorized<Expression_Obj>(*ptr),
       separator_(ptr->separator_),
       is_arglist_(ptr->is_arglist_),
-      delimiter_(ptr->delimiter_),
       from_selector_(ptr->from_selector_)
     { concrete_type(LIST); }
     std::string type() const { return is_arglist_ ? "arglist" : "list"; }
@@ -1088,8 +1084,7 @@ namespace Sass {
       return separator() == SASS_SPACE ?
         " " : (compressed ? "," : ", ");
     }
-    bool is_bracketed() const { return delimiter() == SASS_BRACKETS; }
-    bool is_invisible() const { return empty() && !is_bracketed(); }
+    bool is_invisible() const { return empty(); }
     Expression_Obj value_at_index(size_t i);
 
     virtual size_t size() const;

src/context.cpp

@@ -811,7 +811,6 @@ namespace Sass {
     register_function(ctx, append_sig, append, env);
     register_function(ctx, zip_sig, zip, env);
     register_function(ctx, list_separator_sig, list_separator, env);
-    register_function(ctx, is_bracketed_sig, is_bracketed, env);
     // Map Functions
     register_function(ctx, map_get_sig, map_get, env);
     register_function(ctx, map_merge_sig, map_merge, env);

src/debugger.hpp

@@ -584,13 +584,11 @@ inline void debug_ast(AST_Node_Ptr node, std::string ind, Env* env)
     std::cerr << ind << "List " << expression;
     std::cerr << " (" << pstate_source_position(node) << ")";
     std::cerr << " (" << expression->length() << ") " <<
-      (expression->separator() == SASS_COMMA ? "Comma " : expression->separator() == SASS_HASH ? "Map " : "Space ") <<
-      (expression->delimiter() == SASS_PARENTHESIS ? "Parenthesis " : expression->delimiter() == SASS_BRACKETS ? "Bracket " : "None ") <<
+      (expression->separator() == SASS_COMMA ? "Comma " : expression->separator() == SASS_HASH ? "Map" : "Space ") <<
       " [delayed: " << expression->is_delayed() << "] " <<
       " [interpolant: " << expression->is_interpolant() << "] " <<
       " [listized: " << expression->from_selector() << "] " <<
       " [arglist: " << expression->is_arglist() << "] " <<
-      " [expanded: " << expression->is_expanded() << "] " <<
       " [hash: " << expression->hash() << "] " <<
       std::endl;
     for(const auto& i : expression->elements()) { debug_ast(i, ind + " ", env); }

src/eval.cpp

@@ -496,8 +496,7 @@ namespace Sass {
                                l->pstate(),
                                l->length(),
                                l->separator(),
-                               l->is_arglist(),
-                               l->delimiter());
+                               l->is_arglist());
     for (size_t i = 0, L = l->length(); i < L; ++i) {
       ll->append((*l)[i]->perform(this));
     }

src/functions.cpp

@@ -1309,7 +1309,7 @@ namespace Sass {
       if (l->empty()) error("argument `$list` of `" + std::string(sig) + "` must not be empty", pstate);
       double index = std::floor(n->value() < 0 ? l->length() + n->value() : n->value() - 1);
       if (index < 0 || index > l->length() - 1) error("index out of bounds for `" + std::string(sig) + "`", pstate);
-      List_Ptr result = SASS_MEMORY_NEW(List, pstate, l->length(), l->separator(), false, l->delimiter());
+      List_Ptr result = SASS_MEMORY_NEW(List, pstate, l->length(), l->separator());
       for (size_t i = 0, L = l->length(); i < L; ++i) {
         result->append(((i == index) ? v : (*l)[i]));
       }
@@ -1335,7 +1335,7 @@ namespace Sass {
       return SASS_MEMORY_NEW(Null, pstate);
     }
 
-    Signature join_sig = "join($list1, $list2, $separator: auto, $bracketed: auto)";
+    Signature join_sig = "join($list1, $list2, $separator: auto)";
     BUILT_IN(join)
     {
       Map_Obj m1 = Cast<Map>(env["$list1"]);
@@ -1344,13 +1344,10 @@ namespace Sass {
       List_Obj l2 = Cast<List>(env["$list2"]);
       String_Constant_Obj sep = ARG("$separator", String_Constant);
       enum Sass_Separator sep_val = (l1 ? l1->separator() : SASS_SPACE);
-      Value* bracketed = ARG("$bracketed", Value);
-      enum Sass_List_Delimiter delimiter = (l1 ? l1->delimiter() : SASS_NO_DELIMITER);
       if (!l1) {
         l1 = SASS_MEMORY_NEW(List, pstate, 1);
         l1->append(ARG("$list1", Expression));
         sep_val = (l2 ? l2->separator() : SASS_SPACE);
-        delimiter = (l2 ? l2->delimiter() : SASS_NO_DELIMITER);
       }
       if (!l2) {
         l2 = SASS_MEMORY_NEW(List, pstate, 1);
@@ -1368,12 +1365,7 @@ namespace Sass {
       if (sep_str == "space") sep_val = SASS_SPACE;
       else if (sep_str == "comma") sep_val = SASS_COMMA;
       else if (sep_str != "auto") error("argument `$separator` of `" + std::string(sig) + "` must be `space`, `comma`, or `auto`", pstate);
-      String_Constant_Obj bracketed_as_str = Cast<String_Constant>(bracketed);
-      bool bracketed_is_auto = bracketed_as_str && unquote(bracketed_as_str->value()) == "auto";
-      if (!bracketed_is_auto) {
-        delimiter = bracketed->is_false() ? SASS_NO_DELIMITER : SASS_BRACKETS;
-      }
-      List_Obj result = SASS_MEMORY_NEW(List, pstate, len, sep_val, false, delimiter);
+      List_Obj result = SASS_MEMORY_NEW(List, pstate, len, sep_val);
       result->concat(l1);
       result->concat(l2);
       return result.detach();
@@ -1993,12 +1985,15 @@ namespace Sass {
       return SASS_MEMORY_NEW(String_Quoted, pstate, ss.str());
     }
 
+<<<<<<< HEAD
     Signature is_bracketed_sig = "is-bracketed($list)";
     BUILT_IN(is_bracketed)
     {
       Value_Obj value = ARG("$list", Value);
       List_Obj list = Cast<List>(value);
       return SASS_MEMORY_NEW(Boolean, pstate, list && list->is_bracketed());
     }
+=======
+>>>>>>> parent of 46f5244... Merge pull request #2279 from xzyfer/bracked-lists
   }
 }

src/functions.hpp

@@ -105,7 +105,6 @@ namespace Sass {
     extern Signature is_superselector_sig;
     extern Signature simple_selectors_sig;
     extern Signature selector_parse_sig;
-    extern Signature is_bracketed_sig;
 
     BUILT_IN(rgb);
     BUILT_IN(rgba_4);
@@ -187,7 +186,6 @@ namespace Sass {
     BUILT_IN(is_superselector);
     BUILT_IN(simple_selectors);
     BUILT_IN(selector_parse);
-    BUILT_IN(is_bracketed);
   }
 }
 

src/inspect.cpp

@@ -362,19 +362,10 @@ namespace Sass {
     append_string(")");
   }
 
-  std::string Inspect::lbracket(List_Ptr list) {
-    return list->is_bracketed() ? "[" : "(";
-  }
-
-  std::string Inspect::rbracket(List_Ptr list) {
-    return list->is_bracketed() ? "]" : ")";
-  }
-
   void Inspect::operator()(List_Ptr list)
   {
-    if (list->empty() && (output_style() == TO_SASS || list->is_bracketed())) {
-      append_string(lbracket(list));
-      append_string(rbracket(list));
+    if (output_style() == TO_SASS && list->empty()) {
+      append_string("()");
       return;
     }
     std::string sep(list->separator() == SASS_SPACE ? " " : ",");
@@ -385,24 +376,20 @@ namespace Sass {
 
     bool was_space_array = in_space_array;
     bool was_comma_array = in_comma_array;
-    // if the list is bracketed, always include the left bracket
-    if (list->is_bracketed()) {
-      append_string(lbracket(list));
-    }
     // probably ruby sass eqivalent of element_needs_parens
-    else if (output_style() == TO_SASS &&
+    if (output_style() == TO_SASS &&
         list->length() == 1 &&
         !list->from_selector() &&
         !Cast<List>(list->at(0)) &&
         !Cast<Selector_List>(list->at(0))
     ) {
-      append_string(lbracket(list));
+      append_string("(");
     }
     else if (!in_declaration && (list->separator() == SASS_HASH ||
         (list->separator() == SASS_SPACE && in_space_array) ||
         (list->separator() == SASS_COMMA && in_comma_array)
     )) {
-      append_string(lbracket(list));
+      append_string("(");
     }
 
     if (list->separator() == SASS_SPACE) in_space_array = true;
@@ -431,29 +418,20 @@ namespace Sass {
 
     in_comma_array = was_comma_array;
     in_space_array = was_space_array;
-
-    // if the list is bracketed, always include the right bracket
-    if (list->is_bracketed()) {
-      if (list->separator() == SASS_COMMA && list->size() == 1) {
-        append_string(",");
-      }
-      append_string(rbracket(list));
-    }
     // probably ruby sass eqivalent of element_needs_parens
-    else if (output_style() == TO_SASS &&
+    if (output_style() == TO_SASS &&
         list->length() == 1 &&
         !list->from_selector() &&
         !Cast<List>(list->at(0)) &&
         !Cast<Selector_List>(list->at(0))
     ) {
-      append_string(",");
-      append_string(rbracket(list));
+      append_string(",)");
     }
     else if (!in_declaration && (list->separator() == SASS_HASH ||
         (list->separator() == SASS_SPACE && in_space_array) ||
         (list->separator() == SASS_COMMA && in_comma_array)
     )) {
-      append_string(rbracket(list));
+      append_string(")");
     }
 
   }

src/inspect.hpp

@@ -91,9 +91,6 @@ namespace Sass {
     virtual void operator()(Complex_Selector_Ptr);
     virtual void operator()(Selector_List_Ptr);
 
-    virtual std::string lbracket(List_Ptr);
-    virtual std::string rbracket(List_Ptr);
-
     // template <typename U>
     // void fallback(U x) { fallback_impl(reinterpret_cast<AST_Node_Ptr>(x)); }
   };

src/output.cpp

@@ -155,7 +155,7 @@ namespace Sass {
             Expression_Ptr item = list->at(list_i);
             if (!item->is_invisible()) all_invisible = false;
           }
-          if (all_invisible && !list->is_bracketed()) bPrintExpression = false;
+          if (all_invisible) bPrintExpression = false;
         }
       }
       // Print if OK