Revert "Merge pull request #2284 from xzyfer/remove-list-delimiter"

This reverts commit 9ab7daa, reversing
changes made to 46f5244.

Author: xzyfer

include/sass/values.h

@@ -35,6 +35,13 @@ 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,24 +1061,25 @@ namespace Sass {
   private:
     ADD_PROPERTY(enum Sass_Separator, separator)
     ADD_PROPERTY(bool, is_arglist)
-    ADD_PROPERTY(bool, is_bracketed)
+    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, bool bracket = false)
+         size_t size = 0, enum Sass_Separator sep = SASS_SPACE, bool argl = false,
+         enum Sass_List_Delimiter delimiter = SASS_NO_DELIMITER)
     : Value(pstate),
       Vectorized<Expression_Obj>(size),
       separator_(sep),
       is_arglist_(argl),
-      is_bracketed_(bracket),
+      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_),
-      is_bracketed_(ptr->is_bracketed_),
+      delimiter_(ptr->delimiter_),
       from_selector_(ptr->from_selector_)
     { concrete_type(LIST); }
     std::string type() const { return is_arglist_ ? "arglist" : "list"; }
@@ -1087,6 +1088,7 @@ namespace Sass {
       return separator() == SASS_SPACE ?
         " " : (compressed ? "," : ", ");
     }
+    bool is_bracketed() const { return delimiter() == SASS_BRACKETS; }
     bool is_invisible() const { return empty() && !is_bracketed(); }
     Expression_Obj value_at_index(size_t i);
 

src/debugger.hpp

@@ -585,11 +585,11 @@ inline void debug_ast(AST_Node_Ptr node, std::string ind, Env* env)
     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 ") <<
       " [delayed: " << expression->is_delayed() << "] " <<
       " [interpolant: " << expression->is_interpolant() << "] " <<
       " [listized: " << expression->from_selector() << "] " <<
       " [arglist: " << expression->is_arglist() << "] " <<
-      " [bracketed: " << expression->is_bracketed() << "] " <<
       " [expanded: " << expression->is_expanded() << "] " <<
       " [hash: " << expression->hash() << "] " <<
       std::endl;

src/eval.cpp

@@ -497,7 +497,7 @@ namespace Sass {
                                l->length(),
                                l->separator(),
                                l->is_arglist(),
-                               l->is_bracketed());
+                               l->delimiter());
     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->is_bracketed());
+      List_Ptr result = SASS_MEMORY_NEW(List, pstate, l->length(), l->separator(), false, l->delimiter());
       for (size_t i = 0, L = l->length(); i < L; ++i) {
         result->append(((i == index) ? v : (*l)[i]));
       }
@@ -1345,12 +1345,12 @@ namespace Sass {
       String_Constant_Obj sep = ARG("$separator", String_Constant);
       enum Sass_Separator sep_val = (l1 ? l1->separator() : SASS_SPACE);
       Value* bracketed = ARG("$bracketed", Value);
-      bool is_bracketed = (l1 ? l1->is_bracketed() : false);
+      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);
-        is_bracketed = (l2 ? l2->is_bracketed() : false);
+        delimiter = (l2 ? l2->delimiter() : SASS_NO_DELIMITER);
       }
       if (!l2) {
         l2 = SASS_MEMORY_NEW(List, pstate, 1);
@@ -1371,9 +1371,9 @@ namespace Sass {
       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) {
-        is_bracketed = !bracketed->is_false();
+        delimiter = bracketed->is_false() ? SASS_NO_DELIMITER : SASS_BRACKETS;
       }
-      List_Obj result = SASS_MEMORY_NEW(List, pstate, len, sep_val, false, is_bracketed);
+      List_Obj result = SASS_MEMORY_NEW(List, pstate, len, sep_val, false, delimiter);
       result->concat(l1);
       result->concat(l2);
       return result.detach();

src/parser.cpp

@@ -1048,8 +1048,13 @@ namespace Sass {
     List_Obj map = SASS_MEMORY_NEW(List, pstate, 0, SASS_HASH);
 
     // it's not a map so return the lexed value as a list value
-    if (!lex_css< exactly<':'> >())
-    { return key; }
+    if (!lex_css< exactly<':'> >()) {
+      List_Obj list = SASS_MEMORY_CAST(List, key);
+      if (list && list->delimiter() == SASS_NO_DELIMITER) {
+        list->delimiter(SASS_PARENTHESIS);
+      }
+      return key;
+    }
 
     Expression_Obj value = parse_space_list();
 
@@ -1080,49 +1085,6 @@ namespace Sass {
     return map;
   }
 
-  Expression_Obj Parser::parse_bracket_list()
-  {
-    // check if we have an empty list
-    // return the empty list as such
-    if (peek_css< list_terminator >(position))
-    {
-      // return an empty list (nothing to delay)
-      return SASS_MEMORY_NEW(List, pstate, 0, SASS_SPACE, false, true);
-    }
-
-    bool has_paren = peek_css< exactly<'('> >() != NULL;
-
-    // now try to parse a space list
-    Expression_Obj list = parse_space_list();
-    // if it's a singleton, return it (don't wrap it)
-    if (!peek_css< exactly<','> >(position)) {
-      List_Obj l = Cast<List>(list);
-      if (!l || l->is_bracketed() || has_paren) {
-        List_Obj bracketed_list = SASS_MEMORY_NEW(List, pstate, 1, SASS_SPACE, false, true);
-        bracketed_list->append(list);
-        return bracketed_list;
-      }
-      l->is_bracketed(true);
-      return l;
-    }
-
-    // if we got so far, we actually do have a comma list
-    List_Obj bracketed_list = SASS_MEMORY_NEW(List, pstate, 2, SASS_COMMA, false, true);
-    // wrap the first expression
-    bracketed_list->append(list);
-
-    while (lex_css< exactly<','> >())
-    {
-      // check for abort condition
-      if (peek_css< list_terminator >(position)
-      ) { break; }
-      // otherwise add another expression
-      bracketed_list->append(parse_space_list());
-    }
-    // return the list
-    return bracketed_list;
-  }
-
   // parse list returns either a space separated list,
   // a comma separated list or any bare expression found.
   // so to speak: we unwrap items from lists if possible here!
@@ -1136,7 +1098,19 @@ namespace Sass {
   {
     // check if we have an empty list
     // return the empty list as such
-    if (peek_css< list_terminator >(position))
+    if (peek_css< alternatives <
+          // exactly<'!'>,
+          exactly<';'>,
+          exactly<'}'>,
+          exactly<'{'>,
+          exactly<')'>,
+          exactly<']'>,
+          exactly<':'>,
+          end_of_file,
+          exactly<ellipsis>,
+          default_flag,
+          global_flag
+        > >(position))
     {
       // return an empty list (nothing to delay)
       return SASS_MEMORY_NEW(List, pstate, 0);
@@ -1160,7 +1134,18 @@ namespace Sass {
     while (lex_css< exactly<','> >())
     {
       // check for abort condition
-      if (peek_css< list_terminator >(position)
+      if (peek_css< alternatives <
+            exactly<';'>,
+            exactly<'}'>,
+            exactly<'{'>,
+            exactly<')'>,
+            exactly<']'>,
+            exactly<':'>,
+            end_of_file,
+            exactly<ellipsis>,
+            default_flag,
+            global_flag
+          > >(position)
       ) { break; }
       // otherwise add another expression
       comma_list->append(parse_space_list());
@@ -1175,16 +1160,39 @@ namespace Sass {
   {
     Expression_Obj disj1 = parse_disjunction();
     // if it's a singleton, return it (don't wrap it)
-    if (peek_css< space_list_terminator >(position)
-    ) {
-      return disj1; }
+    if (peek_css< alternatives <
+          // exactly<'!'>,
+          exactly<';'>,
+          exactly<'}'>,
+          exactly<'{'>,
+          exactly<')'>,
+          exactly<']'>,
+          exactly<','>,
+          exactly<':'>,
+          end_of_file,
+          exactly<ellipsis>,
+          default_flag,
+          global_flag
+        > >(position)
+    ) { return disj1; }
 
     List_Obj space_list = SASS_MEMORY_NEW(List, pstate, 2, SASS_SPACE);
     space_list->append(disj1);
 
-    while (
-      !(peek_css< space_list_terminator >(position)) &&
-      peek_css< optional_css_whitespace >() != end
+    while (!(peek_css< alternatives <
+               // exactly<'!'>,
+               exactly<';'>,
+               exactly<'}'>,
+               exactly<'{'>,
+               exactly<')'>,
+               exactly<']'>,
+               exactly<','>,
+               exactly<':'>,
+               end_of_file,
+               exactly<ellipsis>,
+               default_flag,
+               global_flag
+           > >(position)) && peek_css< optional_css_whitespace >() != end
     ) {
       // the space is parsed implicitly?
       space_list->append(parse_disjunction());
@@ -1378,9 +1386,20 @@ namespace Sass {
     }
     else if (lex_css< exactly<'['> >()) {
       // explicit bracketed
-      Expression_Obj value = parse_bracket_list();
+      Expression_Obj value = parse_list();
       // lex the expected closing square bracket
       if (!lex_css< exactly<']'> >()) error("unclosed squared bracket", pstate);
+<<<<<<< HEAD
+=======
+      // fix delimiter
+      List_Obj list = SASS_MEMORY_CAST(List, value);
+      if (!list || list->delimiter() != SASS_NO_DELIMITER) {
+        List_Ptr outer_list = SASS_MEMORY_NEW(List, pstate, 1, SASS_SPACE, false, SASS_BRACKETS);
+        outer_list->append(&value);
+        return outer_list;
+      }
+      list->delimiter(SASS_BRACKETS);
+>>>>>>> parent of 9ab7daa... Merge pull request #2284 from xzyfer/remove-list-delimiter
       return value;
     }
     // string may be interpolated

src/parser.hpp

@@ -256,7 +256,6 @@ namespace Sass {
     bool parse_number_prefix();
     Declaration_Obj parse_declaration();
     Expression_Obj parse_map();
-    Expression_Obj parse_bracket_list();
     Expression_Obj parse_list(bool delayed = false);
     Expression_Obj parse_comma_list(bool delayed = false);
     Expression_Obj parse_space_list();

src/prelexer.cpp

@@ -1419,28 +1419,6 @@ namespace Sass {
       >(src);
     }
 
-    const char* list_terminator(const char* src) {
-      return alternatives <
-        exactly<';'>,
-        exactly<'}'>,
-        exactly<'{'>,
-        exactly<')'>,
-        exactly<']'>,
-        exactly<':'>,
-        end_of_file,
-        exactly<ellipsis>,
-        default_flag,
-        global_flag
-      >(src);
-    };
-
-    const char* space_list_terminator(const char* src) {
-      return alternatives <
-        exactly<','>,
-        list_terminator
-      >(src);
-    };
-
 
     // const char* real_uri_prefix(const char* src) {
     //   return alternatives<

src/prelexer.hpp

@@ -355,10 +355,6 @@ namespace Sass {
     const char* ie_keyword_arg_value(const char* src);
     const char* ie_keyword_arg_property(const char* src);
 
-    // characters that terminate parsing of a list
-    const char* list_terminator(const char* src);
-    const char* space_list_terminator(const char* src);
-
     // match url()
     const char* H(const char* src);
     const char* W(const char* src);