sass 3.4.25 → 3.7.4

data/lib/sass/script/lexer.rb

@@ -51,6 +51,8 @@ module Sass
         ':' => :colon,
         '(' => :lparen,
         ')' => :rparen,
+        '[' => :lsquare,
+        ']' => :rsquare,
         ',' => :comma,
         'and' => :and,
         'or' => :or,
@@ -188,6 +190,14 @@ module Sass
         @scanner.string[pos, 1]
       end
 
+      # Consumes and returns single raw character from the input stream.
+      #
+      # @return [String]
+      def next_char
+        unpeek!
+        scan(/./)
+      end
+
       # Returns the next token without moving the lexer forward.
       #
       # @return [Token] The next token
@@ -198,6 +208,7 @@ module Sass
       # Rewinds the underlying StringScanner
       # to before the token returned by \{#peek}.
       def unpeek!
+        raise "[BUG] Can't unpeek before a queued token!" if @next_tok
         return unless @tok
         @scanner.pos = @tok.pos
         @line = @tok.source_range.start_pos.line
@@ -241,6 +252,30 @@ module Sass
         @scanner.string[old_pos...new_pos]
       end
 
+      # Runs a block, and rewinds the state of the lexer to the beginning of the
+      # block if it returns `nil` or `false`.
+      def try
+        old_pos = @scanner.pos
+        old_line = @line
+        old_offset = @offset
+        old_interpolation_stack = @interpolation_stack.dup
+        old_prev = @prev
+        old_tok = @tok
+        old_next_tok = @next_tok
+
+        result = yield
+        return result if result
+
+        @scanner.pos = old_pos
+        @line = old_line
+        @offset = old_offset
+        @interpolation_stack = old_interpolation_stack
+        @prev = old_prev
+        @tok = old_tok
+        @next_tok = old_next_tok
+        nil
+      end
+
       private
 
       def read_token
@@ -264,10 +299,14 @@ module Sass
       end
 
       def token
-        if after_interpolation? && (interp = @interpolation_stack.pop)
-          interp_type, interp_value = interp
+        if after_interpolation?
+          interp_type, interp_value = @interpolation_stack.pop
           if interp_type == :special_fun
             return special_fun_body(interp_value)
+          elsif interp_type.nil?
+            if @scanner.string[@scanner.pos - 1] == '}' && scan(REGULAR_EXPRESSIONS[:ident])
+              return [@scanner[2] ? :funcall : :ident, Sass::Util.normalize_ident_escapes(@scanner[1], start: false)]
+            end
           else
             raise "[BUG]: Unknown interp_type #{interp_type}" unless interp_type == :string
             return string(interp_value, true)
@@ -285,13 +324,12 @@ module Sass
 
       def _variable(rx)
         return unless scan(rx)
-
-        [:const, @scanner[2]]
+        [:const, Sass::Util.normalize_ident_escapes(@scanner[2])]
       end
 
       def ident
         return unless scan(REGULAR_EXPRESSIONS[:ident])
-        [@scanner[2] ? :funcall : :ident, @scanner[1]]
+        [@scanner[2] ? :funcall : :ident, Sass::Util.normalize_ident_escapes(@scanner[1])]
       end
 
       def string(re, open)
@@ -347,7 +385,9 @@ MESSAGE
 
         value = (@scanner[1] ? @scanner[1].to_f : @scanner[2].to_i) * (minus ? -1 : 1)
         value *= 10**@scanner[3].to_i if @scanner[3]
-        script_number = Script::Value::Number.new(value, Array(@scanner[4]))
+        units = @scanner[4]
+        units = Sass::Util::normalize_ident_escapes(units) if units
+        script_number = Script::Value::Number.new(value, Array(units))
         [:number, script_number]
       end
 
@@ -366,15 +406,20 @@ MESSAGE
         # IDs in properties are used in the Basic User Interface Module
         # (http://www.w3.org/TR/css3-ui/).
         return unless scan(REGULAR_EXPRESSIONS[:id])
-        if @scanner[0] =~ /^\#[0-9a-fA-F]+$/ && (@scanner[0].length == 4 || @scanner[0].length == 7)
+        if @scanner[0] =~ /^\#[0-9a-fA-F]+$/ &&
+          (@scanner[0].length == 4 || @scanner[0].length == 5 ||
+           @scanner[0].length == 7 || @scanner[0].length == 9)
           return [:color, Script::Value::Color.from_hex(@scanner[0])]
         end
-        [:ident, @scanner[0]]
+        [:ident, Sass::Util.normalize_ident_escapes(@scanner[0])]
       end
 
       def color
         return unless @scanner.match?(REGULAR_EXPRESSIONS[:color])
-        return unless @scanner[0].length == 4 || @scanner[0].length == 7
+        unless @scanner[0].length == 4 || @scanner[0].length == 5 ||
+               @scanner[0].length == 7 || @scanner[0].length == 9
+          return
+        end
         script_color = Script::Value::Color.from_hex(scan(REGULAR_EXPRESSIONS[:color]))
         [:color, script_color]
       end
@@ -382,6 +427,15 @@ MESSAGE
       def selector
         start_pos = source_position
         return unless scan(REGULAR_EXPRESSIONS[:selector])
+
+        if @scanner.peek(1) == '&'
+          filename = @options[:filename]
+          Sass::Util.sass_warn <<MESSAGE
+WARNING on line #{line}, column #{offset}#{" of #{filename}" if filename}:
+In Sass, "&&" means two copies of the parent selector. You probably want to use "and" instead.
+MESSAGE
+        end
+
         script_selector = Script::Tree::Selector.new
         script_selector.source_range = range(start_pos)
         [:selector, script_selector]

data/lib/sass/script/parser.rb

@@ -1,5 +1,4 @@
 require 'sass/script/lexer'
-require 'sass/script/css_variable_warning'
 
 module Sass
   module Script
@@ -35,7 +34,6 @@ module Sass
         @allow_extra_text = options.delete(:allow_extra_text)
         @lexer = lexer_class.new(str, line, offset, options)
         @stop_at = nil
-        @css_variable_warning = nil
       end
 
       # Parses a SassScript expression within an interpolated segment (`#{}`).
@@ -64,23 +62,13 @@ module Sass
 
       # Parses a SassScript expression.
       #
-      # @param css_variable [Boolean] Whether this is the value of a CSS variable.
       # @return [Script::Tree::Node] The root node of the parse tree
       # @raise [Sass::SyntaxError] if the expression isn't valid SassScript
-      def parse(css_variable = false)
-        if css_variable
-          @css_variable_warning = CssVariableWarning.new
-        end
-
+      def parse
         expr = assert_expr :expr
         assert_done
         expr.options = @options
         check_for_interpolation expr
-
-        if css_variable
-          @css_variable_warning.value = expr
-        end
-
         expr
       rescue Sass::SyntaxError => e
         e.modify_backtrace :line => @lexer.line, :filename => @options[:filename]
@@ -90,7 +78,7 @@ module Sass
       # Parses a SassScript expression,
       # ending it when it encounters one of the given identifier tokens.
       #
-      # @param tokens [#include?(String)] A set of strings that delimit the expression.
+      # @param tokens [#include?(String | Symbol)] A set of strings or symbols that delimit the expression.
       # @return [Script::Tree::Node] The root node of the parse tree
       # @raise [Sass::SyntaxError] if the expression isn't valid SassScript
       def parse_until(tokens)
@@ -127,7 +115,7 @@ module Sass
           a.options = @options
         end
 
-        keywords.each do |_k, v|
+        keywords.each do |_, v|
           check_for_interpolation v
           v.options = @options
         end
@@ -232,12 +220,12 @@ module Sass
 
       # Parses a SassScript expression.
       #
+      # @overload parse(str, line, offset, filename = nil)
       # @return [Script::Tree::Node] The root node of the parse tree
       # @see Parser#initialize
       # @see Parser#parse
-      def self.parse(value, line, offset, options = {})
-        css_variable = options.delete :css_variable
-        new(value, line, offset, options).parse(css_variable)
+      def self.parse(*args)
+        new(*args).parse
       end
 
       PRECEDENCE = [
@@ -250,8 +238,6 @@ module Sass
 
       ASSOCIATIVE = [:plus, :times]
 
-      VALID_CSS_OPS = [:comma, :single_eq, :space, :div]
-
       class << self
         # Returns an integer representing the precedence
         # of the given operator.
@@ -284,17 +270,17 @@ module Sass
               interp = try_ops_after_interp(#{ops.inspect}, #{name.inspect})
               return interp if interp
               return unless e = #{sub}
-              while tok = try_toks(#{ops.map {|o| o.inspect}.join(', ')})
+
+              while tok = peek_toks(#{ops.map {|o| o.inspect}.join(', ')})
+                return e if @stop_at && @stop_at.include?(tok.type)
+                @lexer.next
+
                 if interp = try_op_before_interp(tok, e)
                   other_interp = try_ops_after_interp(#{ops.inspect}, #{name.inspect}, interp)
                   return interp unless other_interp
                   return other_interp
                 end
 
-                if @css_variable_warning && !VALID_CSS_OPS.include?(tok.type)
-                  @css_variable_warning.warn!
-                end
-
                 e = node(Tree::Operation.new(e, assert_expr(#{sub.inspect}), tok.type),
                          e.source_range.start_pos)
               end
@@ -310,8 +296,6 @@ RUBY
               interp = try_op_before_interp(tok)
               return interp if interp
               start_pos = source_position
-
-              @css_variable_warning.warn! if @css_variable_warning
               node(Tree::UnaryOperation.new(assert_expr(:unary_#{op}), :#{op}), start_pos)
             end
 RUBY
@@ -338,12 +322,12 @@ RUBY
         return list e, start_pos unless @lexer.peek && @lexer.peek.type == :colon
 
         pair = map_pair(e)
-        @css_variable_warning.warn! if @css_variable_warning
         map = node(Sass::Script::Tree::MapLiteral.new([pair]), start_pos)
         while try_tok(:comma)
           pair = map_pair
           return map unless pair
           map.pairs << pair
+          map.source_range.end_pos = map.pairs.last.last.source_range.end_pos
         end
         map
       end
@@ -364,7 +348,7 @@ RUBY
       def list(first, start_pos)
         return first unless @lexer.peek && @lexer.peek.type == :comma
 
-        list = node(Sass::Script::Tree::ListLiteral.new([first], :comma), start_pos)
+        list = node(Sass::Script::Tree::ListLiteral.new([first], separator: :comma), start_pos)
         while (tok = try_tok(:comma))
           element_before_interp = list.elements.length == 1 ? list.elements.first : list
           if (interp = try_op_before_interp(tok, element_before_interp))
@@ -401,13 +385,16 @@ RUBY
           Script::Tree::Interpolation.new(
             prev, str, nil, wb, false, :originally_text => true, :deprecation => deprecation),
           (prev || str).source_range.start_pos)
-        interpolation(interp)
+        interpolation(first: interp)
       end
 
       def try_ops_after_interp(ops, name, prev = nil)
         return unless @lexer.after_interpolation?
-        op = try_toks(*ops)
+        op = peek_toks(*ops)
         return unless op
+        return if @stop_at && @stop_at.include?(op.type)
+        @lexer.next
+
         interp = try_op_before_interp(op, prev, :after_interp)
         return interp if interp
 
@@ -431,17 +418,17 @@ RUBY
         interp
       end
 
-      def interpolation(first = space)
-        e = first
+      def interpolation(first: nil, inner: :space)
+        e = first || send(inner)
         while (interp = try_tok(:begin_interpolation))
           wb = @lexer.whitespace?(interp)
           char_before = @lexer.char(interp.pos - 1)
-          mid = without_css_variable_warning {assert_expr :expr}
+          mid = without_stop_at {assert_expr :expr}
           assert_tok :end_interpolation
           wa = @lexer.whitespace?
           char_after = @lexer.char
 
-          after = space
+          after = send(inner)
           before_deprecation = e.is_a?(Script::Tree::Interpolation) ? e.deprecation : :none
           after_deprecation = after.is_a?(Script::Tree::Interpolation) ? after.deprecation : :none
 
@@ -500,7 +487,7 @@ RUBY
         if arr.size == 1
           arr.first
         else
-          node(Sass::Script::Tree::ListLiteral.new(arr, :space), start_pos)
+          node(Sass::Script::Tree::ListLiteral.new(arr, separator: :space), start_pos)
         end
       end
 
@@ -517,7 +504,7 @@ RUBY
       unary :not, :ident
 
       def ident
-        return funcall unless @lexer.peek && @lexer.peek.type == :ident
+        return css_min_max unless @lexer.peek && @lexer.peek.type == :ident
         return if @stop_at && @stop_at.include?(@lexer.peek.value)
 
         name = @lexer.next
@@ -534,6 +521,122 @@ RUBY
         end
       end
 
+      def css_min_max
+        @lexer.try do
+          next unless tok = try_tok(:funcall)
+          next unless %w[min max].include?(tok.value.downcase)
+          next unless contents = min_max_contents
+          node(array_to_interpolation(["#{tok.value}(", *contents]),
+               tok.source_range.start_pos, source_position)
+        end || funcall
+      end
+
+      def min_max_contents(allow_comma: true)
+        result = []
+        loop do
+          if tok = try_tok(:number)
+            result << tok.value.to_s
+          elsif value = min_max_interpolation
+            result << value
+          elsif value = min_max_calc
+            result << value.value
+          elsif value = min_max_function ||
+                        min_max_parens ||
+                        nested_min_max
+            result.concat value
+          else
+            return
+          end
+
+          if try_tok(:rparen)
+            result << ")"
+            return result
+          elsif tok = try_tok(:plus) || try_tok(:minus) || try_tok(:times) || try_tok(:div)
+            result << " #{Lexer::OPERATORS_REVERSE[tok.type]} "
+          elsif allow_comma && try_tok(:comma)
+            result << ", "
+          else
+            return
+          end
+        end
+      end
+
+      def min_max_interpolation
+        without_stop_at do
+          tok = try_tok(:begin_interpolation)
+          return unless tok
+          expr = without_stop_at {assert_expr :expr}
+          assert_tok :end_interpolation
+          expr
+        end
+      end
+
+      def min_max_function
+        return unless tok = peek_tok(:funcall)
+        return unless %w[calc env var].include?(tok.value.downcase)
+        @lexer.next
+        result = [tok.value, '(', *declaration_value, ')']
+        assert_tok :rparen
+        result
+      end
+
+      def min_max_calc
+        return unless tok = peek_tok(:special_fun)
+        return unless tok.value.value.downcase.start_with?("calc(")
+        @lexer.next.value
+      end
+
+      def min_max_parens
+        return unless try_tok :lparen
+        return unless contents = min_max_contents(allow_comma: false)
+        ['(', *contents]
+      end
+
+      def nested_min_max
+        return unless tok = peek_tok(:funcall)
+        return unless %w[min max].include?(tok.value.downcase)
+        @lexer.next
+        return unless contents = min_max_contents
+        [tok.value, '(', *contents]
+      end
+
+      def declaration_value
+        result = []
+        brackets = []
+        loop do
+          result << @lexer.str do
+            until @lexer.done? ||
+                  peek_toks(:begin_interpolation,
+                            :end_interpolation,
+                            :lcurly,
+                            :lparen,
+                            :lsquare,
+                            :rparen,
+                            :rsquare)
+              @lexer.next || @lexer.next_char
+            end
+          end
+
+          if try_tok(:begin_interpolation)
+            result << assert_expr(:expr)
+            assert_tok :end_interpolation
+          elsif tok = try_toks(:lcurly, :lparen, :lsquare)
+            brackets << case tok.type
+                        when :lcurly; :end_interpolation
+                        when :lparen; :rparen
+                        when :lsquare; :rsquare
+                        end
+            result << Lexer::OPERATORS_REVERSE[tok.type]
+          elsif brackets.empty?
+            return result
+          else
+            bracket = brackets.pop
+            assert_tok bracket
+            result << Lexer::OPERATORS_REVERSE[bracket]
+          end
+        end
+      end
+
       def funcall
         tok = try_tok(:funcall)
         return raw unless tok
@@ -549,29 +652,31 @@ RUBY
         else
           return [], nil unless try_tok(:lparen)
         end
-        return [], nil if try_tok(:rparen)
 
-        res = []
-        splat = nil
-        must_have_default = false
-        loop do
-          c = assert_tok(:const)
-          var = node(Script::Tree::Variable.new(c.value), c.source_range)
-          if try_tok(:colon)
-            val = assert_expr(:space)
-            must_have_default = true
-          elsif try_tok(:splat)
-            splat = var
-            break
-          elsif must_have_default
-            raise SyntaxError.new(
-              "Required argument #{var.inspect} must come before any optional arguments.")
+        without_stop_at do
+          res = []
+          splat = nil
+          must_have_default = false
+          loop do
+            break if peek_tok(:rparen)
+            c = assert_tok(:const)
+            var = node(Script::Tree::Variable.new(c.value), c.source_range)
+            if try_tok(:colon)
+              val = assert_expr(:space)
+              must_have_default = true
+            elsif try_tok(:splat)
+              splat = var
+              break
+            elsif must_have_default
+              raise SyntaxError.new(
+                "Required argument #{var.inspect} must come before any optional arguments.")
+            end
+            res << [var, val]
+            break unless try_tok(:comma)
           end
-          res << [var, val]
-          break unless try_tok(:comma)
+          assert_tok(:rparen)
+          return res, splat
         end
-        assert_tok(:rparen)
-        return res, splat
       end
 
       def fn_arglist
@@ -583,40 +688,37 @@ RUBY
       end
 
       def arglist(subexpr, description)
-        args = []
-        keywords = Sass::Util::NormalizedMap.new
-        e = send(subexpr)
-
-        return [args, keywords] unless e
-
-        splat = nil
-        loop do
-          if @lexer.peek && @lexer.peek.type == :colon
-            name = e
-            @lexer.expected!("comma") unless name.is_a?(Tree::Variable)
-            assert_tok(:colon)
-            value = assert_expr(subexpr, description)
-
-            if keywords[name.name]
-              raise SyntaxError.new("Keyword argument \"#{name.to_sass}\" passed more than once")
-            end
+        without_stop_at do
+          args = []
+          keywords = Sass::Util::NormalizedMap.new
+          splat = nil
+          while (e = send(subexpr))
+            if @lexer.peek && @lexer.peek.type == :colon
+              name = e
+              @lexer.expected!("comma") unless name.is_a?(Tree::Variable)
+              assert_tok(:colon)
+              value = assert_expr(subexpr, description)
+
+              if keywords[name.name]
+                raise SyntaxError.new("Keyword argument \"#{name.to_sass}\" passed more than once")
+              end
 
-            keywords[name.name] = value
-          else
-            if try_tok(:splat)
-              return args, keywords, splat, e if splat
-              splat, e = e, nil
-            elsif splat
-              raise SyntaxError.new("Only keyword arguments may follow variable arguments (...).")
-            elsif !keywords.empty?
-              raise SyntaxError.new("Positional arguments must come before keyword arguments.")
+              keywords[name.name] = value
+            else
+              if try_tok(:splat)
+                return args, keywords, splat, e if splat
+                splat, e = e, nil
+              elsif splat
+                raise SyntaxError.new("Only keyword arguments may follow variable arguments (...).")
+              elsif !keywords.empty?
+                raise SyntaxError.new("Positional arguments must come before keyword arguments.")
+              end
+              args << e if e
             end
 
-            args << e if e
+            return args, keywords, splat unless try_tok(:comma)
           end
-
-          return args, keywords, splat unless try_tok(:comma)
-          e = assert_expr(subexpr, description)
+          return args, keywords
         end
       end
 
@@ -628,10 +730,10 @@ RUBY
 
       def special_fun
         first = try_tok(:special_fun)
-        return paren unless first
+        return square_list unless first
         str = literal_node(first.value, first.source_range)
         return str unless try_tok(:string_interpolation)
-        mid = without_css_variable_warning {assert_expr :expr}
+        mid = without_stop_at {assert_expr :expr}
         assert_tok :end_interpolation
         last = assert_expr(:special_fun)
         node(
@@ -639,24 +741,68 @@ RUBY
           first.source_range.start_pos)
       end
 
-      def paren
-        return variable unless try_tok(:lparen)
+      def square_list
         start_pos = source_position
-        e = map
-        e.force_division! if e
-        end_pos = source_position
-        assert_tok(:rparen)
+        return paren unless try_tok(:lsquare)
+
+        without_stop_at do
+          space_start_pos = source_position
+          e = interpolation(inner: :or_expr)
+          separator = nil
+          if e
+            elements = [e]
+            while (e = interpolation(inner: :or_expr))
+              elements << e
+            end
+
+            # If there's a comma after a space-separated list, it's actually a
+            # space-separated list nested in a comma-separated list.
+            if try_tok(:comma)
+              e = if elements.length == 1
+                    elements.first
+                  else
+                    node(
+                      Sass::Script::Tree::ListLiteral.new(elements, separator: :space),
+                      space_start_pos)
+                  end
+              elements = [e]
+
+              while (e = space)
+                elements << e
+                break unless try_tok(:comma)
+              end
+              separator = :comma
+            else
+              separator = :space if elements.length > 1
+            end
+          else
+            elements = []
+          end
+
+          assert_tok(:rsquare)
+          end_pos = source_position
 
-        @css_variable_warning.warn! if @css_variable_warning
-        e || node(Sass::Script::Tree::ListLiteral.new([], nil), start_pos, end_pos)
+          node(Sass::Script::Tree::ListLiteral.new(elements, separator: separator, bracketed: true),
+               start_pos, end_pos)
+        end
+      end
+
+      def paren
+        return variable unless try_tok(:lparen)
+        without_stop_at do
+          start_pos = source_position
+          e = map
+          e.force_division! if e
+          end_pos = source_position
+          assert_tok(:rparen)
+          e || node(Sass::Script::Tree::ListLiteral.new([]), start_pos, end_pos)
+        end
       end
 
       def variable
         start_pos = source_position
         c = try_tok(:const)
         return string unless c
-
-        @css_variable_warning.warn! if @css_variable_warning
         node(Tree::Variable.new(*c.value), start_pos)
       end
 
@@ -665,9 +811,9 @@ RUBY
         return number unless first
         str = literal_node(first.value, first.source_range)
         return str unless try_tok(:string_interpolation)
-        mid = without_css_variable_warning {assert_expr :expr}
+        mid = assert_expr :expr
         assert_tok :end_interpolation
-        last = assert_expr(:string)
+        last = without_stop_at {assert_expr(:string)}
         node(Tree::StringInterpolation.new(str, mid, last), first.source_range.start_pos)
       end
 
@@ -683,7 +829,6 @@ RUBY
       def selector
         tok = try_tok(:selector)
         return literal unless tok
-        @css_variable_warning.warn! if @css_variable_warning
         node(tok.value, tok.source_range.start_pos)
       end
 
@@ -723,15 +868,23 @@ RUBY
         @lexer.expected!(names.map {|tok| Lexer::TOKEN_NAMES[tok] || tok}.join(" or "))
       end
 
-      def try_tok(name)
+      def peek_tok(name)
         # Avoids an array allocation caused by argument globbing in the try_toks method.
         peeked = @lexer.peek
-        peeked && name == peeked.type && @lexer.next
+        peeked && name == peeked.type && peeked
       end
 
-      def try_toks(*names)
+      def peek_toks(*names)
         peeked = @lexer.peek
-        peeked && names.include?(peeked.type) && @lexer.next
+        peeked && names.include?(peeked.type) && peeked
+      end
+
+      def try_tok(name)
+        peek_tok(name) && @lexer.next
+      end
+
+      def try_toks(*names)
+        peek_toks(*names) && @lexer.next
       end
 
       def assert_done
@@ -745,6 +898,14 @@ RUBY
         end
       end
 
+      def without_stop_at
+        old_stop_at = @stop_at
+        @stop_at = nil
+        yield
+      ensure
+        @stop_at = old_stop_at
+      end
+
       # @overload node(value, source_range)
       #   @param value [Sass::Script::Value::Base]
       #   @param source_range [Sass::Source::Range]
@@ -771,25 +932,33 @@ RUBY
             range(source_range_or_start_pos, end_pos)
           end
 
-        node.css_variable_warning = @css_variable_warning
         node.line = source_range.start_pos.line
         node.source_range = source_range
         node.filename = @options[:filename]
         node
       end
 
-      # Runs the given block without CSS variable warnings enabled.
-      #
-      # CSS warnings don't apply within interpolation, so this is used to
-      # disable them.
+      # Converts an array of strings and expressions to a string interoplation
+      # object.
       #
-      # @yield []
-      def without_css_variable_warning
-        old_css_variable_warning = @css_variable_warning
-        @css_variable_warning = nil
-        yield
-      ensure
-        @css_variable_warning = old_css_variable_warning
+      # @param array [Array<Script::Tree:Node | String>]
+      # @return [Script::Tree::StringInterpolation]
+      def array_to_interpolation(array)
+        Sass::Util.merge_adjacent_strings(array).reverse.inject(nil) do |after, value|
+          if value.is_a?(::String)
+            literal = Sass::Script::Tree::Literal.new(
+              Sass::Script::Value::String.new(value))
+            next literal unless after
+            Sass::Script::Tree::StringInterpolation.new(literal, after.mid, after.after)
+          else
+            Sass::Script::Tree::StringInterpolation.new(
+              Sass::Script::Tree::Literal.new(
+                Sass::Script::Value::String.new('')),
+              value,
+              after || Sass::Script::Tree::Literal.new(
+                Sass::Script::Value::String.new('')))
+          end
+        end
       end
 
       # Checks a script node for any immediately-deprecated interpolations, and