sass 3.4.25 → 3.7.4

data/lib/sass/features.rb

@@ -12,6 +12,7 @@ module Sass
       extend-selector-pseudoclass
       units-level-3
       at-error
+      custom-property
     )]
 
     # Check if a feature exists by name. This is used to implement

data/lib/sass/importers/filesystem.rb

@@ -67,7 +67,7 @@ module Sass
       end
 
       def public_url(name, sourcemap_directory)
-        file_pathname = Sass::Util.cleanpath(Sass::Util.absolute_path(name, @root))
+        file_pathname = Sass::Util.cleanpath(File.absolute_path(name, @root))
         return Sass::Util.file_uri_from_path(file_pathname) if sourcemap_directory.nil?
 
         sourcemap_pathname = Sass::Util.cleanpath(sourcemap_directory)
@@ -133,7 +133,7 @@ module Sass
 
       REDUNDANT_DIRECTORY = /#{Regexp.escape(File::SEPARATOR)}\.#{Regexp.escape(File::SEPARATOR)}/
       # Given a base directory and an `@import`ed name,
-      # finds an existant file that matches the name.
+      # finds an existent file that matches the name.
       #
       # @param dir [String] The directory relative to which to search.
       # @param name [String] The filename to search for.
@@ -154,7 +154,9 @@ module Sass
             [Sass::Util.cleanpath(full_path).to_s, s]
           end
         end.flatten(1)
-        return if found.empty?
+        if found.empty? && split(name)[2].nil? && File.directory?("#{dir}/#{name}")
+          return find_real_file("#{dir}/#{name}", "index", options)
+        end
 
         if found.size > 1 && !@same_name_warnings.include?(found.first.first)
           found.each {|(f, _)| @same_name_warnings << f}
@@ -202,7 +204,7 @@ WARNING
 
       def _find(dir, name, options)
         full_filename, syntax = Sass::Util.destructure(find_real_file(dir, name, options))
-        return unless full_filename && File.readable?(full_filename)
+        return unless full_filename && File.file?(full_filename) && File.readable?(full_filename)
 
         # TODO: this preserves historical behavior, but it's possible
         # :filename should be either normalized to the native format

data/lib/sass/logger/base.rb

@@ -22,6 +22,17 @@ class Sass::Logger::Base
     !disabled && self.class.log_level?(level, log_level)
   end
 
+  # Captures all logger messages emitted during a block and returns them as a
+  # string.
+  def capture
+    old_io = io
+    self.io = StringIO.new
+    yield
+    io.string
+  ensure
+    self.io = old_io
+  end
+
   def log(level, message)
     _log(level, message) if logging_level?(level)
   end

data/lib/sass/plugin/compiler.rb

@@ -303,42 +303,30 @@ module Sass::Plugin
       directories += @inferred_directories
       directories = remove_redundant_directories(directories)
 
-      # A Listen version prior to 2.0 will write a test file to a directory to
-      # see if a watcher supports watching that directory. That breaks horribly
-      # on read-only directories, so we filter those out.
-      unless Sass::Util.listen_geq_2?
-        directories = directories.select {|d| File.directory?(d) && File.writable?(d)}
-      end
-
       # TODO: Keep better track of what depends on what
       # so we don't have to run a global update every time anything changes.
       # XXX The :additional_watch_paths option exists for Compass to use until
       # a deprecated feature is removed. It may be removed without warning.
-      listener_args = directories +
-                      Array(options[:additional_watch_paths]) +
-                      [{:relative_paths => false}]
-
-      # The native windows listener is much slower than the polling option, according to
-      # https://github.com/nex3/sass/commit/a3031856b22bc834a5417dedecb038b7be9b9e3e
-      poll = @options[:poll] || Sass::Util.windows?
-      if poll && Sass::Util.listen_geq_2?
-        # In Listen 2.0.0 and on, :force_polling is an option. In earlier
-        # versions, it's a method on the listener (called below).
-        listener_args.last[:force_polling] = true
-      end
+      directories += Array(options[:additional_watch_paths])
+
+      options = {
+        :relative_paths => false,
+        # The native windows listener is much slower than the polling option, according to
+        # https://github.com/nex3/sass/commit/a3031856b22bc834a5417dedecb038b7be9b9e3e
+        :force_polling => @options[:poll] || Sass::Util.windows?
+      }
 
-      listener = create_listener(*listener_args) do |modified, added, removed|
+      listener = create_listener(*directories, options) do |modified, added, removed|
         on_file_changed(individual_files, modified, added, removed)
         yield(modified, added, removed) if block_given?
       end
 
-      if poll && !Sass::Util.listen_geq_2?
-        # In Listen 2.0.0 and on, :force_polling is an option (set above). In
-        # earlier versions, it's a method on the listener.
-        listener.force_polling(true)
+      begin
+        listener.start
+        sleep
+      rescue Interrupt
+        # Squelch Interrupt for clean exit from Listen::Listener
       end
-
-      listen_to(listener)
     end
 
     # Non-destructively modifies \{#options} so that default values are properly set,
@@ -387,28 +375,10 @@ module Sass::Plugin
 
     private
 
+    # This is mocked out in compiler_test.rb.
     def create_listener(*args, &block)
-      Sass::Util.load_listen!
-      if Sass::Util.listen_geq_2?
-        # Work around guard/listen#243.
-        options = args.pop if args.last.is_a?(Hash)
-        args.map do |dir|
-          Listen.to(dir, options, &block)
-        end
-      else
-        Listen::Listener.new(*args, &block)
-      end
-    end
-
-    def listen_to(listener)
-      if Sass::Util.listen_geq_2?
-        listener.map {|l| l.start}
-        sleep
-      else
-        listener.start!
-      end
-    rescue Interrupt
-      # Squelch Interrupt for clean exit from Listen::Listener
+      require 'sass-listen'
+      SassListen.to(*args, &block)
     end
 
     def remove_redundant_directories(directories)
@@ -494,7 +464,7 @@ module Sass::Plugin
           rendered = engine.render
         end
       rescue StandardError => e
-        compilation_error_occured = true
+        compilation_error_occurred = true
         run_compilation_error e, filename, css, sourcemap
         raise e unless options[:full_exception]
         rendered = Sass::SyntaxError.exception_to_css(e, options[:line] || 1)
@@ -507,14 +477,14 @@ module Sass::Plugin
           mapping.to_json(
             :css_path => css, :sourcemap_path => sourcemap, :type => options[:sourcemap]))
       end
-      run_updated_stylesheet(filename, css, sourcemap) unless compilation_error_occured
+      run_updated_stylesheet(filename, css, sourcemap) unless compilation_error_occurred
     end
 
     def write_file(fileName, content)
       flag = 'w'
       flag = 'wb' if Sass::Util.windows? && options[:unix_newlines]
       File.open(fileName, flag) do |file|
-        file.set_encoding(content.encoding) unless Sass::Util.ruby1_8?
+        file.set_encoding(content.encoding)
         file.print(content)
       end
     end

data/lib/sass/plugin/configuration.rb

@@ -26,8 +26,8 @@ module Sass
         clear_callbacks!
       end
 
-      # An options hash.
-      # See {file:SASS_REFERENCE.md#Options the Sass options documentation}.
+      # An options hash. See {file:SASS_REFERENCE.md#Options the Sass options
+      # documentation}.
       #
       # @return [{Symbol => Object}]
       def options

data/lib/sass/railtie.rb

@@ -1,5 +1,5 @@
 # Rails 3.0.0.beta.2+, < 3.1
-if defined?(ActiveSupport) && Sass::Util.has?(:public_method, ActiveSupport, :on_load) &&
+if defined?(ActiveSupport) && ActiveSupport.public_methods.include?(:on_load) &&
     !Sass::Util.ap_geq?('3.1.0.beta')
   require 'sass/plugin/configuration'
   ActiveSupport.on_load(:before_configuration) do

data/lib/sass/script/css_parser.rb

@@ -24,7 +24,10 @@ module Sass
       end
 
       # Short-circuit all the SassScript-only productions
-      alias_method :interpolation, :space
+      def interpolation(first: nil, inner: :space)
+        first || send(inner)
+      end
+
       alias_method :or_expr, :div
       alias_method :unary_div, :ident
       alias_method :paren, :string

data/lib/sass/script/functions.rb

@@ -1,9 +1,7 @@
 require 'sass/script/value/helpers'
 
 module Sass::Script
-  # @comment
   #   YARD can't handle some multiline tags, and we need really long tags for function declarations.
-  #   rubocop:disable LineLength
   # Methods in this module are accessible from the SassScript context.
   # For example, you can write
   #
@@ -77,7 +75,7 @@ module Sass::Script
   # \{#complement complement($color)}
   # : Returns the complement of a color.
   #
-  # \{#invert invert($color)}
+  # \{#invert invert($color, \[$weight\])}
   # : Returns the inverse of a color.
   #
   # ## Opacity Functions
@@ -176,7 +174,7 @@ module Sass::Script
   # \{#set-nth set-nth($list, $n, $value)}
   # : Replaces the nth item in a list.
   #
-  # \{#join join($list1, $list2, \[$separator\])}
+  # \{#join join($list1, $list2, \[$separator, $bracketed\])}
   # : Joins together two lists into one.
   #
   # \{#append append($list1, $val, \[$separator\])}
@@ -191,6 +189,9 @@ module Sass::Script
   # \{#list_separator list-separator($list)}
   # : Returns the separator of a list.
   #
+  # \{#is_bracketed is-bracketed($list)}
+  # : Returns whether a list has square brackets.
+  #
   # ## Map Functions {#map-functions}
   #
   # Maps in Sass are immutable; all map functions return a new map rather than
@@ -276,6 +277,9 @@ module Sass::Script
   # \{#mixin_exists mixin-exists($name)}
   # : Returns whether a mixin with the given name exists.
   #
+  # \{#content_exists content-exists()}
+  # : Returns whether the current mixin was passed a content block.
+  #
   # \{#inspect inspect($value)}
   # : Returns the string representation of a value as it would be represented in Sass.
   #
@@ -291,8 +295,12 @@ module Sass::Script
   # \{#comparable comparable($number1, $number2)}
   # : Returns whether two numbers can be added, subtracted, or compared.
   #
-  # \{#call call($name, $args...)}
-  # : Dynamically calls a Sass function.
+  # \{#call call($function, $args...)}
+  # : Dynamically calls a Sass function reference returned by `get-function`.
+  #
+  # \{#get_function get-function($name, $css: false)}
+  # : Looks up a function with the given name in the current lexical scope
+  #   and returns a reference to it.
   #
   # ## Miscellaneous Functions
   #
@@ -354,9 +362,6 @@ module Sass::Script
   # representation) on those objects without first setting {Tree::Node#options=
   # the #options attribute}.
   #
-  # @comment
-  #   rubocop:enable LineLength
-  #   rubocop:disable ModuleLength
   module Functions
     @signatures = {}
 
@@ -471,14 +476,14 @@ module Sass::Script
     # @param seed [Integer]
     # @return [Integer] The same seed.
     def self.random_seed=(seed)
-      @random_number_generator = Sass::Util::CrossPlatformRandom.new(seed)
+      @random_number_generator = Random.new(seed)
     end
 
     # Get Sass's internal random number generator.
     #
     # @return [Random]
     def self.random_number_generator
-      @random_number_generator ||= Sass::Util::CrossPlatformRandom.new
+      @random_number_generator ||= Random.new
     end
 
     # The context in which methods in {Script::Functions} are evaluated.
@@ -522,18 +527,27 @@ module Sass::Script
       #   assert_type value, :String
       #   assert_type value, :Number
       # @param value [Sass::Script::Value::Base] A SassScript value
-      # @param type [Symbol] The name of the type the value is expected to be
+      # @param type [Symbol, Array<Symbol>] The name(s) of the type the value is expected to be
       # @param name [String, Symbol, nil] The name of the argument.
       # @raise [ArgumentError] if value is not of the correct type.
       def assert_type(value, type, name = nil)
-        klass = Sass::Script::Value.const_get(type)
-        if value.is_a?(klass)
-          value.check_deprecated_interp if type == :String
+        valid_types = Array(type)
+        found_type = valid_types.find do |t|
+          value.is_a?(Sass::Script::Value.const_get(t)) ||
+            t == :Map && value.is_a?(Sass::Script::Value::List) && value.value.empty?
+        end
+
+        if found_type
+          value.check_deprecated_interp if found_type == :String
           return
         end
 
-        return if value.is_a?(Sass::Script::Value::List) && type == :Map && value.value.empty?
-        err = "#{value.inspect} is not a #{TYPE_NAMES[type] || type.to_s.downcase}"
+        err = if valid_types.size == 1
+                "#{value.inspect} is not a #{TYPE_NAMES[type] || type.to_s.downcase}"
+              else
+                type_names = valid_types.map {|t| TYPE_NAMES[t] || t.to_s.downcase}
+                "#{value.inspect} is not any of #{type_names.join(', ')}"
+              end
         err = "$#{name.to_s.tr('_', '-')}: " + err if name
         raise ArgumentError.new(err)
       end
@@ -634,23 +648,27 @@ module Sass::Script
     #     inclusive
     # @return [Sass::Script::Value::Color]
     # @raise [ArgumentError] if any parameter is the wrong type or out of bounds
-    def rgb(red, green, blue)
-      if calc?(red) || calc?(green) || calc?(blue)
+    def rgb(red, green = nil, blue = nil)
+      if green.nil?
+        return unquoted_string("rgb(#{red})") if var?(red)
+        raise ArgumentError.new("wrong number of arguments (1 for 3)")
+      elsif blue.nil?
+        return unquoted_string("rgb(#{red}, #{green})") if var?(red) || var?(green)
+        raise ArgumentError.new("wrong number of arguments (2 for 3)")
+      end
+
+      if special_number?(red) || special_number?(green) || special_number?(blue)
         return unquoted_string("rgb(#{red}, #{green}, #{blue})")
       end
       assert_type red, :Number, :red
       assert_type green, :Number, :green
       assert_type blue, :Number, :blue
 
-      color_attrs = [red, green, blue].map do |c|
-        if c.is_unit?("%")
-          c.value * 255 / 100.0
-        elsif c.unitless?
-          c.value
-        else
-          raise ArgumentError.new("Expected #{c} to be unitless or have a unit of % but got #{c}")
-        end
-      end
+      color_attrs = [
+        percentage_or_unitless(red, 255, "red"),
+        percentage_or_unitless(green, 255, "green"),
+        percentage_or_unitless(blue, 255, "blue")
+      ]
 
       # Don't store the string representation for function-created colors, both
       # because it's not very useful and because some functions aren't supported
@@ -658,6 +676,8 @@ module Sass::Script
       Sass::Script::Value::Color.new(color_attrs)
     end
     declare :rgb, [:red, :green, :blue]
+    declare :rgb, [:red, :green]
+    declare :rgb, [:red]
 
     # Creates a {Sass::Script::Value::Color Color} from red, green, blue, and
     # alpha values.
@@ -692,20 +712,39 @@ module Sass::Script
     #     is the wrong type
     def rgba(*args)
       case args.size
+      when 1
+        return unquoted_string("rgba(#{args.first})") if var?(args.first)
+        raise ArgumentError.new("wrong number of arguments (1 for 4)")
       when 2
         color, alpha = args
 
+        if var?(color)
+          return unquoted_string("rgba(#{color}, #{alpha})")
+        elsif var?(alpha)
+          if color.is_a?(Sass::Script::Value::Color)
+            return unquoted_string("rgba(#{color.red}, #{color.green}, #{color.blue}, #{alpha})")
+          else
+            return unquoted_string("rgba(#{color}, #{alpha})")
+          end
+        end
+
         assert_type color, :Color, :color
-        if calc?(alpha)
+        if special_number?(alpha)
           unquoted_string("rgba(#{color.red}, #{color.green}, #{color.blue}, #{alpha})")
         else
           assert_type alpha, :Number, :alpha
-          check_alpha_unit alpha, 'rgba'
-          color.with(:alpha => alpha.value)
+          color.with(:alpha => percentage_or_unitless(alpha, 1, "alpha"))
+        end
+      when 3
+        if var?(args[0]) || var?(args[1]) || var?(args[2])
+          unquoted_string("rgba(#{args.join(', ')})")
+        else
+          raise ArgumentError.new("wrong number of arguments (3 for 4)")
         end
       when 4
         red, green, blue, alpha = args
-        if calc?(red) || calc?(green) || calc?(blue) || calc?(alpha)
+        if special_number?(red) || special_number?(green) ||
+           special_number?(blue) || special_number?(alpha)
           unquoted_string("rgba(#{red}, #{green}, #{blue}, #{alpha})")
         else
           rgba(rgb(red, green, blue), alpha)
@@ -715,7 +754,9 @@ module Sass::Script
       end
     end
     declare :rgba, [:red, :green, :blue, :alpha]
+    declare :rgba, [:red, :green, :blue]
     declare :rgba, [:color, :alpha]
+    declare :rgba, [:red]
 
     # Creates a {Sass::Script::Value::Color Color} from hue, saturation, and
     # lightness values. Uses the algorithm from the [CSS3 spec][].
@@ -733,14 +774,24 @@ module Sass::Script
     # @return [Sass::Script::Value::Color]
     # @raise [ArgumentError] if `$saturation` or `$lightness` are out of bounds
     #   or any parameter is the wrong type
-    def hsl(hue, saturation, lightness)
-      if calc?(hue) || calc?(saturation) || calc?(lightness)
+    def hsl(hue, saturation = nil, lightness = nil)
+      if saturation.nil?
+        return unquoted_string("hsl(#{hue})") if var?(hue)
+        raise ArgumentError.new("wrong number of arguments (1 for 3)")
+      elsif lightness.nil?
+        return unquoted_string("hsl(#{hue}, #{saturation})") if var?(hue) || var?(saturation)
+        raise ArgumentError.new("wrong number of arguments (2 for 3)")
+      end
+
+      if special_number?(hue) || special_number?(saturation) || special_number?(lightness)
         unquoted_string("hsl(#{hue}, #{saturation}, #{lightness})")
       else
         hsla(hue, saturation, lightness, number(1))
       end
     end
     declare :hsl, [:hue, :saturation, :lightness]
+    declare :hsl, [:hue, :saturation]
+    declare :hsl, [:hue]
 
     # Creates a {Sass::Script::Value::Color Color} from hue,
     # saturation, lightness, and alpha values. Uses the algorithm from
@@ -761,15 +812,29 @@ module Sass::Script
     # @return [Sass::Script::Value::Color]
     # @raise [ArgumentError] if `$saturation`, `$lightness`, or `$alpha` are out
     #   of bounds or any parameter is the wrong type
-    def hsla(hue, saturation, lightness, alpha)
-      if calc?(hue) || calc?(saturation) || calc?(lightness) || calc?(alpha)
+    def hsla(hue, saturation = nil, lightness = nil, alpha = nil)
+      if saturation.nil?
+        return unquoted_string("hsla(#{hue})") if var?(hue)
+        raise ArgumentError.new("wrong number of arguments (1 for 4)")
+      elsif lightness.nil?
+        return unquoted_string("hsla(#{hue}, #{saturation})") if var?(hue) || var?(saturation)
+        raise ArgumentError.new("wrong number of arguments (2 for 4)")
+      elsif alpha.nil?
+        if var?(hue) || var?(saturation) || var?(lightness)
+          return unquoted_string("hsla(#{hue}, #{saturation}, #{lightness})")
+        else
+          raise ArgumentError.new("wrong number of arguments (2 for 4)")
+        end
+      end
+
+      if special_number?(hue) || special_number?(saturation) ||
+         special_number?(lightness) || special_number?(alpha)
         return unquoted_string("hsla(#{hue}, #{saturation}, #{lightness}, #{alpha})")
       end
       assert_type hue, :Number, :hue
       assert_type saturation, :Number, :saturation
       assert_type lightness, :Number, :lightness
       assert_type alpha, :Number, :alpha
-      check_alpha_unit alpha, 'hsla'
 
       h = hue.value
       s = saturation.value
@@ -779,9 +844,13 @@ module Sass::Script
       # because it's not very useful and because some functions aren't supported
       # on older browsers.
       Sass::Script::Value::Color.new(
-        :hue => h, :saturation => s, :lightness => l, :alpha => alpha.value)
+        :hue => h, :saturation => s, :lightness => l,
+        :alpha => percentage_or_unitless(alpha, 1, "alpha"))
     end
     declare :hsla, [:hue, :saturation, :lightness, :alpha]
+    declare :hsla, [:hue, :saturation, :lightness]
+    declare :hsla, [:hue, :saturation]
+    declare :hsla, [:hue]
 
     # Gets the red component of a color. Calculated from HSL where necessary via
     # [this algorithm][hsl-to-rgb].
@@ -1384,20 +1453,28 @@ module Sass::Script
     #
     # @overload invert($color)
     #   @param $color [Sass::Script::Value::Color]
+    # @overload invert($color, $weight: 100%)
+    #   @param $color [Sass::Script::Value::Color]
+    #   @param $weight [Sass::Script::Value::Number] The relative weight of the
+    #     color color's inverse
     # @return [Sass::Script::Value::Color]
-    # @raise [ArgumentError] if `$color` isn't a color
-    def invert(color)
+    # @raise [ArgumentError] if `$color` isn't a color or `$weight`
+    #   isn't a percentage between 0% and 100%
+    def invert(color, weight = number(100))
       if color.is_a?(Sass::Script::Value::Number)
         return identifier("invert(#{color})")
       end
 
       assert_type color, :Color, :color
-      color.with(
+      inv = color.with(
         :red => (255 - color.red),
         :green => (255 - color.green),
         :blue => (255 - color.blue))
+
+      mix(inv, color, weight)
     end
     declare :invert, [:color]
+    declare :invert, [:color, :weight]
 
     # Removes quotes from a string. If the string is already unquoted, this will
     # return it unmodified.
@@ -1413,13 +1490,11 @@ module Sass::Script
     def unquote(string)
       unless string.is_a?(Sass::Script::Value::String)
         # Don't warn multiple times for the same source line.
-        # rubocop:disable GlobalVars
         $_sass_warned_for_unquote ||= Set.new
         frame = environment.stack.frames.last
         key = [frame.filename, frame.line] if frame
         return string if frame && $_sass_warned_for_unquote.include?(key)
         $_sass_warned_for_unquote << key if frame
-        # rubocop:enable GlobalVars
 
         Sass::Util.sass_warn(<<MESSAGE.strip)
 DEPRECATION WARNING: Passing #{string.to_sass}, a non-string value, to unquote()
@@ -1612,6 +1687,10 @@ MESSAGE
     #   type-of(#fff)   => color
     #   type-of(blue)   => color
     #   type-of(null)   => null
+    #   type-of(a b c)  => list
+    #   type-of((a: 1, b: 2)) => map
+    #   type-of(get-function("foo")) => function
+    #
     # @overload type_of($value)
     #   @param $value [Sass::Script::Value::Base] The value to inspect
     # @return [Sass::Script::Value::String] The unquoted string name of the
@@ -1639,6 +1718,12 @@ MESSAGE
     #
     # * `at-error` indicates that the Sass `@error` directive is supported.
     #
+    # * `custom-property` indicates that the [Custom Properties Level 1][] spec
+    #   is supported. This means that custom properties are parsed statically,
+    #   with only interpolation treated as SassScript.
+    #
+    # [Custom Properties Level 1]: https://www.w3.org/TR/css-variables-1/
+    #
     # @example
     #   feature-exists(some-feature-that-exists) => true
     #   feature-exists(what-is-this-i-dont-know) => false
@@ -1653,6 +1738,55 @@ MESSAGE
     end
     declare :feature_exists, [:feature]
 
+    # Returns a reference to a function for later invocation with the `call()` function.
+    #
+    # If `$css` is `false`, the function reference may refer to a function
+    # defined in your stylesheet or built-in to the host environment. If it's
+    # `true` it will refer to a plain-CSS function.
+    #
+    # @example
+    #   get-function("rgb")
+    #
+    #   @function myfunc { @return "something"; }
+    #   get-function("myfunc")
+    #
+    # @overload get_function($name, $css: false)
+    #   @param name [Sass::Script::Value::String] The name of the function being referenced.
+    #   @param css [Sass::Script::Value::Bool] Whether to get a plain CSS function.
+    #
+    # @return [Sass::Script::Value::Function] A function reference.
+    def get_function(name, kwargs = {})
+      assert_type name, :String, :name
+
+      css = if kwargs.has_key?("css")
+              v = kwargs.delete("css")
+              assert_type v, :Bool, :css
+              v.value
+            else
+              false
+            end
+
+      if kwargs.any?
+        raise ArgumentError.new("Illegal keyword argument '#{kwargs.keys.first}'")
+      end
+
+      if css
+        return Sass::Script::Value::Function.new(
+          Sass::Callable.new(name.value, nil, nil, nil, nil, nil, "function", :css))
+      end
+
+      callable = environment.caller.function(name.value) ||
+        (Sass::Script::Functions.callable?(name.value.tr("-", "_")) &&
+         Sass::Callable.new(name.value, nil, nil, nil, nil, nil, "function", :builtin))
+
+      if callable
+        Sass::Script::Value::Function.new(callable)
+      else
+        raise Sass::SyntaxError.new("Function not found: #{name}")
+      end
+    end
+    declare :get_function, [:name], :var_kwargs => true
+
     # Returns the unit(s) associated with a number. Complex units are sorted in
     # alphabetical order by numerator and denominator.
     #
@@ -1855,7 +1989,7 @@ MESSAGE
       index = n.to_i > 0 ? n.to_i - 1 : n.to_i
       new_list = list.to_a.dup
       new_list[index] = value
-      Sass::Script::Value::List.new(new_list, list.separator)
+      list.with_contents(new_list)
     end
     declare :set_nth, [:list, :n, :value]
 
@@ -1896,6 +2030,9 @@ MESSAGE
     # list. If both lists have fewer than two items, spaces are used for the
     # resulting list.
     #
+    # Unless `$bracketed` is passed, the resulting list is bracketed if the
+    # first parameter is.
+    #
     # Like all list functions, `join()` returns a new list rather than modifying
     # its arguments in place.
     #
@@ -1905,27 +2042,70 @@ MESSAGE
     #   join(10px, 20px) => 10px 20px
     #   join(10px, 20px, comma) => 10px, 20px
     #   join((blue, red), (#abc, #def), space) => blue red #abc #def
-    # @overload join($list1, $list2, $separator: auto)
+    #   join([10px], 20px) => [10px 20px]
+    # @overload join($list1, $list2, $separator: auto, $bracketed: auto)
     #   @param $list1 [Sass::Script::Value::Base]
     #   @param $list2 [Sass::Script::Value::Base]
     #   @param $separator [Sass::Script::Value::String] The list separator to use.
     #     If this is `comma` or `space`, that separator will be used. If this is
     #     `auto` (the default), the separator is determined as explained above.
+    #   @param $bracketed [Sass::Script::Value::Base] Whether the resulting list
+    #     will be bracketed. If this is `auto` (the default), the separator is
+    #     determined as explained above.
     # @return [Sass::Script::Value::List]
-    def join(list1, list2, separator = identifier("auto"))
+    def join(list1, list2,
+             separator = identifier("auto"), bracketed = identifier("auto"),
+             kwargs = nil, *rest)
+      if separator.is_a?(Hash)
+        kwargs = separator
+        separator = identifier("auto")
+      elsif bracketed.is_a?(Hash)
+        kwargs = bracketed
+        bracketed = identifier("auto")
+      elsif rest.last.is_a?(Hash)
+        rest.unshift kwargs
+        kwargs = rest.pop
+      end
+
+      unless rest.empty?
+        # Add 4 to rest.length because we don't want to count the kwargs hash,
+        # which is always passed.
+        raise ArgumentError.new("wrong number of arguments (#{rest.length + 4} for 2..4)")
+      end
+
+      if kwargs
+        separator = kwargs.delete("separator") || separator
+        bracketed = kwargs.delete("bracketed") || bracketed
+
+        unless kwargs.empty?
+          name, val = kwargs.to_a.first
+          raise ArgumentError.new("Unknown argument $#{name} (#{val})")
+        end
+      end
+
       assert_type separator, :String, :separator
       unless %w(auto space comma).include?(separator.value)
         raise ArgumentError.new("Separator name must be space, comma, or auto")
       end
-      sep = if separator.value == 'auto'
-              list1.separator || list2.separator || :space
-            else
-              separator.value.to_sym
-            end
-      list(list1.to_a + list2.to_a, sep)
+
+      list(list1.to_a + list2.to_a,
+        separator:
+          if separator.value == 'auto'
+            list1.separator || list2.separator || :space
+          else
+            separator.value.to_sym
+          end,
+        bracketed:
+          if bracketed.is_a?(Sass::Script::Value::String) && bracketed.value == 'auto'
+            list1.bracketed
+          else
+            bracketed.to_bool
+          end)
     end
-    declare :join, [:list1, :list2]
-    declare :join, [:list1, :list2, :separator]
+    # We don't actually take variable arguments or keyword arguments, but this
+    # is the best way to take either `$separator` or `$bracketed` as keywords
+    # without complaining about the other missing.
+    declare :join, [:list1, :list2], :var_args => true, :var_kwargs => true
 
     # Appends a single value onto the end of a list.
     #
@@ -1953,12 +2133,13 @@ MESSAGE
       unless %w(auto space comma).include?(separator.value)
         raise ArgumentError.new("Separator name must be space, comma, or auto")
       end
-      sep = if separator.value == 'auto'
-              list.separator || :space
-            else
-              separator.value.to_sym
-            end
-      list(list.to_a + [val], sep)
+      list.with_contents(list.to_a + [val],
+        separator:
+          if separator.value == 'auto'
+            list.separator || :space
+          else
+            separator.value.to_sym
+          end)
     end
     declare :append, [:list, :val]
     declare :append, [:list, :val, :separator]
@@ -2028,7 +2209,20 @@ MESSAGE
     def list_separator(list)
       identifier((list.separator || :space).to_s)
     end
-    declare :separator, [:list]
+    declare :list_separator, [:list]
+
+    # Returns whether a list uses square brackets.
+    #
+    # @example
+    #   is-bracketed(1px 2px 3px) => false
+    #   is-bracketed([1px, 2px, 3px]) => true
+    # @overload is_bracketed($list)
+    #   @param $list [Sass::Script::Value::Base]
+    # @return [Sass::Script::Value::Bool]
+    def is_bracketed(list)
+      bool(list.bracketed)
+    end
+    declare :is_bracketed, [:list]
 
     # Returns the value in a map associated with the given key. If the map
     # doesn't have such a key, returns `null`.
@@ -2214,10 +2408,24 @@ MESSAGE
     #   $fn: nth;
     #   call($fn, (a b c), 2) => b
     #
-    # @overload call($name, $args...)
-    #   @param $name [String] The name of the function to call.
+    # @overload call($function, $args...)
+    #   @param $function [Sass::Script::Value::Function] The function to call.
     def call(name, *args)
-      assert_type name, :String, :name
+      unless name.is_a?(Sass::Script::Value::String) ||
+             name.is_a?(Sass::Script::Value::Function)
+        assert_type name, :Function, :function
+      end
+      if name.is_a?(Sass::Script::Value::String)
+        name = if function_exists(name).to_bool
+                 get_function(name)
+               else
+                 get_function(name, "css" => bool(true))
+               end
+        Sass::Util.sass_warn(<<WARNING)
+DEPRECATION WARNING: Passing a string to call() is deprecated and will be illegal
+in Sass 4.0. Use call(#{name.to_sass}) instead.
+WARNING
+      end
       kwargs = args.last.is_a?(Hash) ? args.pop : {}
       funcall = Sass::Script::Tree::Funcall.new(
         name.value,
@@ -2225,6 +2433,8 @@ MESSAGE
         Sass::Util.map_vals(kwargs) {|v| Sass::Script::Tree::Literal.new(v)},
         nil,
         nil)
+      funcall.line = environment.stack.frames.last.line
+      funcall.filename = environment.stack.frames.last.filename
       funcall.options = options
       perform(funcall)
     end
@@ -2313,12 +2523,12 @@ MESSAGE
     #
     # @overload function_exists($name)
     #   @param name [Sass::Script::Value::String] The name of the function to
-    #     check.
+    #     check or a function reference.
     # @return [Sass::Script::Value::Bool] Whether the function is defined.
     def function_exists(name)
       assert_type name, :String, :name
       exists = Sass::Script::Functions.callable?(name.value.tr("-", "_"))
-      exists ||= environment.function(name.value)
+      exists ||= environment.caller.function(name.value)
       bool(exists)
     end
     declare :function_exists, [:name]
@@ -2341,6 +2551,31 @@ MESSAGE
     end
     declare :mixin_exists, [:name]
 
+    # Check whether a mixin was passed a content block.
+    #
+    # Unless `content-exists()` is called directly from a mixin, an error will be raised.
+    #
+    # @example
+    #   @mixin needs-content {
+    #     @if not content-exists() {
+    #       @error "You must pass a content block!"
+    #     }
+    #     @content;
+    #   }
+    #
+    # @overload content_exists()
+    # @return [Sass::Script::Value::Bool] Whether a content block was passed to the mixin.
+    def content_exists
+      # frames.last is the stack frame for this function,
+      # so we use frames[-2] to get the frame before that.
+      mixin_frame = environment.stack.frames[-2]
+      unless mixin_frame && mixin_frame.type == :mixin
+        raise Sass::SyntaxError.new("Cannot call content-exists() except within a mixin.")
+      end
+      bool(!environment.caller.content.nil?)
+    end
+    declare :content_exists, []
+
     # Return a string containing the value as its Sass representation.
     #
     # @overload inspect($value)
@@ -2663,10 +2898,7 @@ MESSAGE
         yield(value.value), value.numerator_units, value.denominator_units)
     end
 
-    # @comment
-    #   rubocop:disable ParameterLists
     def _adjust(color, amount, attr, range, op, units = "")
-      # rubocop:enable ParameterLists
       assert_type color, :Color, :color
       assert_type amount, :Number, :amount
       Sass::Util.check_range('Amount', range, amount, units)
@@ -2674,19 +2906,14 @@ MESSAGE
       color.with(attr => color.send(attr).send(op, amount.value))
     end
 
-    def check_alpha_unit(alpha, function)
-      return if alpha.unitless?
-
-      if alpha.is_unit?("%")
-        Sass::Util.sass_warn(<<WARNING)
-DEPRECATION WARNING: Passing a percentage as the alpha value to #{function}() will be
-interpreted differently in future versions of Sass. For now, use #{alpha.value} instead.
-WARNING
+    def percentage_or_unitless(number, max, name)
+      if number.unitless?
+        number.value
+      elsif number.is_unit?("%")
+        max * number.value / 100.0;
       else
-        Sass::Util.sass_warn(<<WARNING)
-DEPRECATION WARNING: Passing a number with units as the alpha value to #{function}() is
-deprecated and will be an error in future versions of Sass. Use #{alpha.value} instead.
-WARNING
+        raise ArgumentError.new(
+          "$#{name}: Expected #{number} to have no units or \"%\"");
       end
     end
   end