sass 3.7.4 → 4.0.0.alpha.1

data/lib/sass/script/lexer.rb

@@ -19,13 +19,13 @@ module Sass
       # `source_range`: \[`Sass::Source::Range`\]
       # : The range in the source file in which the token appeared.
       #
-      # `pos`: \[`Integer`\]
+      # `pos`: \[`Fixnum`\]
       # : The scanner position at which the SassScript token appeared.
       Token = Struct.new(:type, :value, :source_range, :pos)
 
       # The line number of the lexer's current position.
       #
-      # @return [Integer]
+      # @return [Fixnum]
       def line
         return @line unless @tok
         @tok.source_range.start_pos.line
@@ -34,7 +34,7 @@ module Sass
       # The number of bytes into the current line
       # of the lexer's current position (1-based).
       #
-      # @return [Integer]
+      # @return [Fixnum]
       def offset
         return @offset unless @tok
         @tok.source_range.start_pos.offset
@@ -51,8 +51,6 @@ module Sass
         ':' => :colon,
         '(' => :lparen,
         ')' => :rparen,
-        '[' => :lsquare,
-        ']' => :rsquare,
         ',' => :comma,
         'and' => :and,
         'or' => :or,
@@ -73,8 +71,9 @@ module Sass
       OPERATORS_REVERSE = Sass::Util.map_hash(OPERATORS) {|k, v| [v, k]}
 
       TOKEN_NAMES = Sass::Util.map_hash(OPERATORS_REVERSE) {|k, v| [k, v.inspect]}.merge(
-        :const => "variable (e.g. $foo)",
-        :ident => "identifier (e.g. middle)")
+          :const => "variable (e.g. $foo)",
+          :ident => "identifier (e.g. middle)",
+          :special_fun => '")"')
 
       # A list of operator strings ordered with longer names first
       # so that `>` and `<` don't clobber `>=` and `<=`.
@@ -82,7 +81,7 @@ module Sass
 
       # A sub-list of {OP_NAMES} that only includes operators
       # with identifier names.
-      IDENT_OP_NAMES = OP_NAMES.select {|k, _v| k =~ /^\w+/}
+      IDENT_OP_NAMES = OP_NAMES.select {|k, v| k =~ /^\w+/}
 
       PARSEABLE_NUMBER = /(?:(\d*\.\d+)|(\d+))(?:[eE]([+-]?\d+))?(#{UNIT})?/
 
@@ -144,12 +143,12 @@ module Sass
       }
 
       # @param str [String, StringScanner] The source text to lex
-      # @param line [Integer] The 1-based line on which the SassScript appears.
+      # @param line [Fixnum] The 1-based line on which the SassScript appears.
       #   Used for error reporting and sourcemap building
-      # @param offset [Integer] The 1-based character (not byte) offset in the line in the source.
+      # @param offset [Fixnum] The 1-based character (not byte) offset in the line in the source.
       #   Used for error reporting and sourcemap building
       # @param options [{Symbol => Object}] An options hash;
-      #   see {file:SASS_REFERENCE.md#Options the Sass options documentation}
+      #   see {file:SASS_REFERENCE.md#options the Sass options documentation}
       def initialize(str, line, offset, options)
         @scanner = str.is_a?(StringScanner) ? str : Sass::Util::MultibyteStringScanner.new(str)
         @line = line
@@ -157,8 +156,13 @@ module Sass
         @options = options
         @interpolation_stack = []
         @prev = nil
-        @tok = nil
-        @next_tok = nil
+      end
+
+      # Returns whether or not there's whitespace before the given token.
+      #
+      # @return [Boolean]
+      def whitespace_before?(tok)
+        @scanner.string[0...tok.pos] =~ /\s\Z/
       end
 
       # Moves the lexer forward one token.
@@ -171,33 +175,6 @@ module Sass
         tok
       end
 
-      # Returns whether or not there's whitespace before the next token.
-      #
-      # @return [Boolean]
-      def whitespace?(tok = @tok)
-        if tok
-          @scanner.string[0...tok.pos] =~ /\s\Z/
-        else
-          @scanner.string[@scanner.pos, 1] =~ /^\s/ ||
-            @scanner.string[@scanner.pos - 1, 1] =~ /\s\Z/
-        end
-      end
-
-      # Returns the given character.
-      #
-      # @return [String]
-      def char(pos = @scanner.pos)
-        @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
@@ -208,11 +185,11 @@ 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
-        @offset = @tok.source_range.start_pos.offset
+        if @tok
+          @scanner.pos = @tok.pos
+          @line = @tok.source_range.start_pos.line
+          @offset = @tok.source_range.start_pos.offset
+        end
       end
 
       # @return [Boolean] Whether or not there's more source text to lex.
@@ -222,11 +199,6 @@ module Sass
         @scanner.eos? && @tok.nil?
       end
 
-      # @return [Boolean] Whether or not the last token lexed was `:end_interpolation`.
-      def after_interpolation?
-        @prev && @prev.type == :end_interpolation
-      end
-
       # Raise an error to the effect that `name` was expected in the input stream
       # and wasn't found.
       #
@@ -252,32 +224,13 @@ 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
+      private
 
-        @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
+      # @return [Boolean] Whether or not the last token lexed was `:end_interpolation`.
+      def after_interpolation?
+        @prev && @prev.type == :end_interpolation
       end
 
-      private
-
       def read_token
         if (tok = @next_tok)
           @next_tok = nil
@@ -299,14 +252,10 @@ module Sass
       end
 
       def token
-        if after_interpolation?
-          interp_type, interp_value = @interpolation_stack.pop
+        if after_interpolation? && (interp = @interpolation_stack.pop)
+          interp_type, interp_value = interp
           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)
@@ -324,12 +273,13 @@ module Sass
 
       def _variable(rx)
         return unless scan(rx)
-        [:const, Sass::Util.normalize_ident_escapes(@scanner[2])]
+
+        [:const, @scanner[2]]
       end
 
       def ident
         return unless scan(REGULAR_EXPRESSIONS[:ident])
-        [@scanner[2] ? :funcall : :ident, Sass::Util.normalize_ident_escapes(@scanner[1])]
+        [@scanner[2] ? :funcall : :ident, @scanner[1]]
       end
 
       def string(re, open)
@@ -385,9 +335,7 @@ MESSAGE
 
         value = (@scanner[1] ? @scanner[1].to_f : @scanner[2].to_i) * (minus ? -1 : 1)
         value *= 10**@scanner[3].to_i if @scanner[3]
-        units = @scanner[4]
-        units = Sass::Util::normalize_ident_escapes(units) if units
-        script_number = Script::Value::Number.new(value, Array(units))
+        script_number = Script::Value::Number.new(value, Array(@scanner[4]))
         [:number, script_number]
       end
 
@@ -406,20 +354,15 @@ 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 == 5 ||
-           @scanner[0].length == 7 || @scanner[0].length == 9)
+        if @scanner[0] =~ /^\#[0-9a-fA-F]+$/ && (@scanner[0].length == 4 || @scanner[0].length == 7)
           return [:color, Script::Value::Color.from_hex(@scanner[0])]
         end
-        [:ident, Sass::Util.normalize_ident_escapes(@scanner[0])]
+        [:ident, @scanner[0]]
       end
 
       def color
         return unless @scanner.match?(REGULAR_EXPRESSIONS[:color])
-        unless @scanner[0].length == 4 || @scanner[0].length == 5 ||
-               @scanner[0].length == 7 || @scanner[0].length == 9
-          return
-        end
+        return unless @scanner[0].length == 4 || @scanner[0].length == 7
         script_color = Script::Value::Color.from_hex(scan(REGULAR_EXPRESSIONS[:color]))
         [:color, script_color]
       end
@@ -427,15 +370,6 @@ 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]
@@ -473,7 +407,7 @@ MESSAGE
       end
 
       def special_val
-        return unless scan(/!#{W}important/i)
+        return unless scan(/!important/i)
         [:string, Script::Value::String.new("!important")]
       end
 

data/lib/sass/script/parser.rb

@@ -7,33 +7,28 @@ module Sass
     class Parser
       # The line number of the parser's current position.
       #
-      # @return [Integer]
+      # @return [Fixnum]
       def line
         @lexer.line
       end
 
       # The column number of the parser's current position.
       #
-      # @return [Integer]
+      # @return [Fixnum]
       def offset
         @lexer.offset
       end
 
       # @param str [String, StringScanner] The source text to parse
-      # @param line [Integer] The line on which the SassScript appears.
+      # @param line [Fixnum] The line on which the SassScript appears.
       #   Used for error reporting and sourcemap building
-      # @param offset [Integer] The character (not byte) offset where the script starts in the line.
+      # @param offset [Fixnum] The character (not byte) offset where the script starts in the line.
       #   Used for error reporting and sourcemap building
-      # @param options [{Symbol => Object}] An options hash; see
-      #   {file:SASS_REFERENCE.md#Options the Sass options documentation}.
-      #   This supports an additional `:allow_extra_text` option that controls
-      #   whether the parser throws an error when extra text is encountered
-      #   after the parsed construct.
+      # @param options [{Symbol => Object}] An options hash;
+      #   see {file:SASS_REFERENCE.md#options the Sass options documentation}
       def initialize(str, line, offset, options = {})
         @options = options
-        @allow_extra_text = options.delete(:allow_extra_text)
         @lexer = lexer_class.new(str, line, offset, options)
-        @stop_at = nil
       end
 
       # Parses a SassScript expression within an interpolated segment (`#{}`).
@@ -50,9 +45,7 @@ module Sass
         start_pos = Sass::Source::Position.new(line, offset - 2)
         expr = assert_expr :expr
         assert_tok :end_interpolation
-        expr = Sass::Script::Tree::Interpolation.new(
-          nil, expr, nil, false, false, :warn_for_color => warn_for_color)
-        check_for_interpolation expr
+        expr = Sass::Script::Tree::Interpolation.new(expr, warn_for_color)
         expr.options = @options
         node(expr, start_pos)
       rescue Sass::SyntaxError => e
@@ -68,7 +61,6 @@ module Sass
         expr = assert_expr :expr
         assert_done
         expr.options = @options
-        check_for_interpolation expr
         expr
       rescue Sass::SyntaxError => e
         e.modify_backtrace :line => @lexer.line, :filename => @options[:filename]
@@ -78,7 +70,7 @@ module Sass
       # Parses a SassScript expression,
       # ending it when it encounters one of the given identifier tokens.
       #
-      # @param tokens [#include?(String | Symbol)] A set of strings or symbols that delimit the expression.
+      # @param tokens [#include?(String)] A set of strings 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)
@@ -86,7 +78,6 @@ module Sass
         expr = assert_expr :expr
         assert_done
         expr.options = @options
-        check_for_interpolation expr
         expr
       rescue Sass::SyntaxError => e
         e.modify_backtrace :line => @lexer.line, :filename => @options[:filename]
@@ -110,26 +101,10 @@ module Sass
         end
         assert_done
 
-        args.each do |a|
-          check_for_interpolation a
-          a.options = @options
-        end
-
-        keywords.each do |_, v|
-          check_for_interpolation v
-          v.options = @options
-        end
-
-        if splat
-          check_for_interpolation splat
-          splat.options = @options
-        end
-
-        if kwarg_splat
-          check_for_interpolation kwarg_splat
-          kwarg_splat.options = @options
-        end
-
+        args.each {|a| a.options = @options}
+        keywords.each {|k, v| v.options = @options}
+        splat.options = @options if splat
+        kwarg_splat.options = @options if kwarg_splat
         return args, keywords, splat, kwarg_splat
       rescue Sass::SyntaxError => e
         e.modify_backtrace :line => @lexer.line, :filename => @options[:filename]
@@ -146,20 +121,10 @@ module Sass
         assert_done
 
         args.each do |k, v|
-          check_for_interpolation k
           k.options = @options
-
-          if v
-            check_for_interpolation v
-            v.options = @options
-          end
-        end
-
-        if splat
-          check_for_interpolation splat
-          splat.options = @options
+          v.options = @options if v
         end
-
+        splat.options = @options if splat
         return args, splat
       rescue Sass::SyntaxError => e
         e.modify_backtrace :line => @lexer.line, :filename => @options[:filename]
@@ -176,20 +141,10 @@ module Sass
         assert_done
 
         args.each do |k, v|
-          check_for_interpolation k
           k.options = @options
-
-          if v
-            check_for_interpolation v
-            v.options = @options
-          end
-        end
-
-        if splat
-          check_for_interpolation splat
-          splat.options = @options
+          v.options = @options if v
         end
-
+        splat.options = @options if splat
         return args, splat
       rescue Sass::SyntaxError => e
         e.modify_backtrace :line => @lexer.line, :filename => @options[:filename]
@@ -209,7 +164,6 @@ module Sass
         end
 
         expr = assert_expr :funcall
-        check_for_interpolation expr
         expr.options = @options
         @lexer.unpeek!
         expr
@@ -267,20 +221,8 @@ module Sass
         def production(name, sub, *ops)
           class_eval <<RUBY, __FILE__, __LINE__ + 1
             def #{name}
-              interp = try_ops_after_interp(#{ops.inspect}, #{name.inspect})
-              return interp if interp
               return unless e = #{sub}
-
-              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
-
+              while tok = try_toks(#{ops.map {|o| o.inspect}.join(', ')})
                 e = node(Tree::Operation.new(e, assert_expr(#{sub.inspect}), tok.type),
                          e.source_range.start_pos)
               end
@@ -293,8 +235,6 @@ RUBY
           class_eval <<RUBY, __FILE__, __LINE__ + 1
             def unary_#{op}
               return #{sub} unless tok = try_tok(:#{op})
-              interp = try_op_before_interp(tok)
-              return interp if interp
               start_pos = source_position
               node(Tree::UnaryOperation.new(assert_expr(:unary_#{op}), :#{op}), start_pos)
             end
@@ -317,7 +257,7 @@ RUBY
 
       def map
         start_pos = source_position
-        e = interpolation
+        e = space
         return unless e
         return list e, start_pos unless @lexer.peek && @lexer.peek.type == :colon
 
@@ -327,20 +267,19 @@ RUBY
           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
 
       def map_pair(key = nil)
-        return unless key ||= interpolation
+        return unless key ||= space
         assert_tok :colon
-        return key, assert_expr(:interpolation)
+        return key, assert_expr(:space)
       end
 
       def expr
         start_pos = source_position
-        e = interpolation
+        e = space
         return unless e
         list e, start_pos
       end
@@ -348,133 +287,16 @@ RUBY
       def list(first, start_pos)
         return first unless @lexer.peek && @lexer.peek.type == :comma
 
-        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))
-            other_interp = try_ops_after_interp([:comma], :expr, interp)
-            return interp unless other_interp
-            return other_interp
-          end
-          return list unless (e = interpolation)
+        list = node(Sass::Script::Tree::ListLiteral.new([first], :comma), start_pos)
+        while try_tok(:comma)
+          return list unless (e = space)
           list.elements << e
           list.source_range.end_pos = list.elements.last.source_range.end_pos
         end
         list
       end
 
-      production :equals, :interpolation, :single_eq
-
-      def try_op_before_interp(op, prev = nil, after_interp = false)
-        return unless @lexer.peek && @lexer.peek.type == :begin_interpolation
-        unary = !prev && !after_interp
-        wb = @lexer.whitespace?(op)
-        str = literal_node(Script::Value::String.new(Lexer::OPERATORS_REVERSE[op.type]),
-                           op.source_range)
-
-        deprecation =
-          case op.type
-          when :comma; :potential
-          when :div, :single_eq; :none
-          when :plus; unary ? :none : :immediate
-          when :minus; @lexer.whitespace?(@lexer.peek) ? :immediate : :none
-          else; :immediate
-          end
-
-        interp = node(
-          Script::Tree::Interpolation.new(
-            prev, str, nil, wb, false, :originally_text => true, :deprecation => deprecation),
-          (prev || str).source_range.start_pos)
-        interpolation(first: interp)
-      end
-
-      def try_ops_after_interp(ops, name, prev = nil)
-        return unless @lexer.after_interpolation?
-        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
-
-        wa = @lexer.whitespace?
-        str = literal_node(Script::Value::String.new(Lexer::OPERATORS_REVERSE[op.type]),
-                           op.source_range)
-        str.line = @lexer.line
-
-        deprecation =
-          case op.type
-          when :comma; :potential
-          when :div, :single_eq; :none
-          when :minus; @lexer.whitespace?(op) ? :immediate : :none
-          else; :immediate
-          end
-        interp = node(
-          Script::Tree::Interpolation.new(
-            prev, str, assert_expr(name), false, wa,
-            :originally_text => true, :deprecation => deprecation),
-          (prev || str).source_range.start_pos)
-        interp
-      end
-
-      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_stop_at {assert_expr :expr}
-          assert_tok :end_interpolation
-          wa = @lexer.whitespace?
-          char_after = @lexer.char
-
-          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
-
-          deprecation =
-            if before_deprecation == :immediate || after_deprecation == :immediate ||
-               # Warn for #{foo}$var and #{foo}(1) but not #{$foo}1.
-               (after && !wa && char_after =~ /[$(]/) ||
-               # Warn for $var#{foo} and (a)#{foo} but not a#{foo}.
-               (e && !wb && is_unsafe_before?(e, char_before))
-              :immediate
-            else
-              :potential
-            end
-
-          e = node(
-            Script::Tree::Interpolation.new(e, mid, after, wb, wa, :deprecation => deprecation),
-            (e || interp).source_range.start_pos)
-        end
-        e
-      end
-
-      # Returns whether `expr` is unsafe to include before an interpolation.
-      #
-      # @param expr [Node] The expression to check.
-      # @param char_before [String] The character immediately before the
-      #   interpolation being checked (and presumably the last character of
-      #   `expr`).
-      # @return [Boolean]
-      def is_unsafe_before?(expr, char_before)
-        return char_before == ')' if is_safe_value?(expr)
-
-        # Otherwise, it's only safe if it was another interpolation.
-        !expr.is_a?(Script::Tree::Interpolation)
-      end
-
-      # Returns whether `expr` is safe as the value immediately before an
-      # interpolation.
-      #
-      # It's safe as long as the previous expression is an identifier or number,
-      # or a list whose last element is also safe.
-      def is_safe_value?(expr)
-        return is_safe_value?(expr.elements.last) if expr.is_a?(Script::Tree::ListLiteral)
-        return false unless expr.is_a?(Script::Tree::Literal)
-        expr.value.is_a?(Script::Value::Number) ||
-          (expr.value.is_a?(Script::Value::String) && expr.value.type == :identifier)
-      end
+      production :equals, :space, :single_eq
 
       def space
         start_pos = source_position
@@ -487,7 +309,7 @@ RUBY
         if arr.size == 1
           arr.first
         else
-          node(Sass::Script::Tree::ListLiteral.new(arr, separator: :space), start_pos)
+          node(Sass::Script::Tree::ListLiteral.new(arr, :space), start_pos)
         end
       end
 
@@ -504,136 +326,51 @@ RUBY
       unary :not, :ident
 
       def 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
-        if (color = Sass::Script::Value::Color::COLOR_NAMES[name.value.downcase])
-          literal_node(Sass::Script::Value::Color.new(color, name.value), name.source_range)
-        elsif name.value == "true"
-          literal_node(Sass::Script::Value::Bool.new(true), name.source_range)
-        elsif name.value == "false"
-          literal_node(Sass::Script::Value::Bool.new(false), name.source_range)
-        elsif name.value == "null"
-          literal_node(Sass::Script::Value::Null.new, name.source_range)
+        return funcall unless (first = @lexer.peek)
+
+        contents = []
+        if first.type == :ident
+          return if @stop_at && @stop_at.include?(first.value)
+          contents << @lexer.next.value
+        elsif first.type == :begin_interpolation
+          @lexer.next # Move through :begin_interpolation
+          contents << assert_expr(:expr)
+          assert_tok(:end_interpolation)
         else
-          literal_node(Sass::Script::Value::String.new(name.value, :identifier), name.source_range)
+          return funcall
         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
+        while (tok = @lexer.peek)
+          break if @lexer.whitespace_before?(tok)
 
-      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
+          if tok.type == :ident
+            contents << @lexer.next.value
+            next
           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
+          break unless try_tok(:begin_interpolation)
+          contents << assert_expr(:expr)
+          assert_tok(:end_interpolation)
         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
+        if contents.length > 1 || contents.first.is_a?(Sass::Script::Tree::Node)
+          return node(
+            Sass::Script::Tree::StringInterpolation.new(contents, :identifier),
+            first.source_range.start_pos)
         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
+        if (color = Sass::Script::Value::Color::COLOR_NAMES[first.value.downcase])
+          literal_node(Sass::Script::Value::Color.new(color, first.value), first.source_range)
+        elsif first.value == "true"
+          literal_node(Sass::Script::Value::Bool.new(true), first.source_range)
+        elsif first.value == "false"
+          literal_node(Sass::Script::Value::Bool.new(false), first.source_range)
+        elsif first.value == "null"
+          literal_node(Sass::Script::Value::Null.new, first.source_range)
+        else
+          literal_node(
+            Sass::Script::Value::String.new(first.value, :identifier),
+            first.source_range)
         end
       end
 
@@ -652,31 +389,29 @@ RUBY
         else
           return [], nil unless try_tok(:lparen)
         end
+        return [], nil if try_tok(:rparen)
 
-        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)
+        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.")
           end
-          assert_tok(:rparen)
-          return res, splat
+          res << [var, val]
+          break unless try_tok(:comma)
         end
+        assert_tok(:rparen)
+        return res, splat
       end
 
       def fn_arglist
@@ -684,41 +419,44 @@ RUBY
       end
 
       def mixin_arglist
-        arglist(:interpolation, "mixin argument")
+        arglist(:space, "mixin argument")
       end
 
       def arglist(subexpr, description)
-        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
+        args = []
+        keywords = Sass::Util::NormalizedMap.new
+        e = send(subexpr)
 
-              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
+        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
+
+            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
 
-            return args, keywords, splat unless try_tok(:comma)
+            args << e if e
           end
-          return args, keywords
+
+          return args, keywords, splat unless try_tok(:comma)
+          e = assert_expr(subexpr, description)
         end
       end
 
@@ -730,73 +468,32 @@ RUBY
 
       def special_fun
         first = try_tok(:special_fun)
-        return square_list unless first
-        str = literal_node(first.value, first.source_range)
-        return str unless try_tok(:string_interpolation)
-        mid = without_stop_at {assert_expr :expr}
-        assert_tok :end_interpolation
-        last = assert_expr(:special_fun)
-        node(
-          Tree::Interpolation.new(str, mid, last, false, false),
-          first.source_range.start_pos)
-      end
-
-      def square_list
-        start_pos = source_position
-        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
+        return paren unless first
 
-            # 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
+        unless try_tok(:string_interpolation)
+          return literal_node(first.value, first.source_range)
+        end
 
-          assert_tok(:rsquare)
-          end_pos = source_position
+        contents = [first.value.value]
+        begin
+          contents << assert_expr(:expr)
+          assert_tok :end_interpolation
+          contents << assert_tok(:special_fun).value.value
+        end while try_tok(:string_interpolation)
 
-          node(Sass::Script::Tree::ListLiteral.new(elements, separator: separator, bracketed: true),
-               start_pos, end_pos)
-        end
+        node(
+          Tree::StringInterpolation.new(contents, :identifier),
+          first.source_range.start_pos)
       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
+        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([], nil), start_pos, end_pos)
       end
 
       def variable
@@ -809,12 +506,21 @@ RUBY
       def string
         first = try_tok(:string)
         return number unless first
-        str = literal_node(first.value, first.source_range)
-        return str unless try_tok(:string_interpolation)
-        mid = assert_expr :expr
-        assert_tok :end_interpolation
-        last = without_stop_at {assert_expr(:string)}
-        node(Tree::StringInterpolation.new(str, mid, last), first.source_range.start_pos)
+
+        unless try_tok(:string_interpolation)
+          return literal_node(first.value, first.source_range)
+        end
+
+        contents = [first.value.value]
+        begin
+          contents << assert_expr(:expr)
+          assert_tok :end_interpolation
+          contents << assert_tok(:string).value.value
+        end while try_tok(:string_interpolation)
+
+        node(
+          Tree::StringInterpolation.new(contents, first.value.type),
+          first.source_range.start_pos)
       end
 
       def number
@@ -845,8 +551,7 @@ RUBY
         :default => "expression (e.g. 1px, bold)",
         :mixin_arglist => "mixin argument",
         :fn_arglist => "function argument",
-        :splat => "...",
-        :special_fun => '")"',
+        :splat => "..."
       }
 
       def assert_expr(name, expected = nil)
@@ -868,42 +573,20 @@ RUBY
         @lexer.expected!(names.map {|tok| Lexer::TOKEN_NAMES[tok] || tok}.join(" or "))
       end
 
-      def peek_tok(name)
+      def try_tok(name)
         # Avoids an array allocation caused by argument globbing in the try_toks method.
         peeked = @lexer.peek
-        peeked && name == peeked.type && peeked
-      end
-
-      def peek_toks(*names)
-        peeked = @lexer.peek
-        peeked && names.include?(peeked.type) && peeked
-      end
-
-      def try_tok(name)
-        peek_tok(name) && @lexer.next
+        peeked && name == peeked.type && @lexer.next
       end
 
       def try_toks(*names)
-        peek_toks(*names) && @lexer.next
+        peeked = @lexer.peek
+        peeked && names.include?(peeked.type) && @lexer.next
       end
 
       def assert_done
-        if @allow_extra_text
-          # If extra text is allowed, just rewind the lexer so that the
-          # StringScanner is pointing to the end of the parsed text.
-          @lexer.unpeek!
-        else
-          return if @lexer.done?
-          @lexer.expected!(EXPR_NAMES[:default])
-        end
-      end
-
-      def without_stop_at
-        old_stop_at = @stop_at
-        @stop_at = nil
-        yield
-      ensure
-        @stop_at = old_stop_at
+        return if @lexer.done?
+        @lexer.expected!(EXPR_NAMES[:default])
       end
 
       # @overload node(value, source_range)
@@ -937,65 +620,6 @@ RUBY
         node.filename = @options[:filename]
         node
       end
-
-      # Converts an array of strings and expressions to a string interoplation
-      # object.
-      #
-      # @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
-      # emits warnings for them.
-      #
-      # @param node [Sass::Script::Tree::Node]
-      def check_for_interpolation(node)
-        nodes = [node]
-        until nodes.empty?
-          node = nodes.pop
-          unless node.is_a?(Sass::Script::Tree::Interpolation) &&
-                 node.deprecation == :immediate
-            nodes.concat node.children
-            next
-          end
-
-          interpolation_deprecation(node)
-        end
-      end
-
-      # Emits a deprecation warning for an interpolation node.
-      #
-      # @param node [Sass::Script::Tree::Node]
-      def interpolation_deprecation(interpolation)
-        return if @options[:_convert]
-        location = "on line #{interpolation.line}"
-        location << " of #{interpolation.filename}" if interpolation.filename
-        Sass::Util.sass_warn <<WARNING
-DEPRECATION WARNING #{location}:
-\#{} interpolation near operators will be simplified in a future version of Sass.
-To preserve the current behavior, use quotes:
-
-  #{interpolation.to_quoted_equivalent.to_sass}
-
-You can use the sass-convert command to automatically fix most cases.
-WARNING
-      end
     end
   end
 end