sass 3.4.0 → 3.4.25

data/lib/sass/tree/css_import_node.rb

@@ -15,6 +15,11 @@ module Sass::Tree
     # @return [String]
     attr_accessor :resolved_uri
 
+    # The supports condition for this import.
+    #
+    # @return [Sass::Supports::Condition]
+    attr_accessor :supports_condition
+
     # The media query for this rule, interspersed with
     # {Sass::Script::Tree::Node}s representing `#{}`-interpolation. Any adjacent
     # strings will be merged together.
@@ -30,9 +35,11 @@ module Sass::Tree
 
     # @param uri [String, Sass::Script::Tree::Node] See \{#uri}
     # @param query [Array<String, Sass::Script::Tree::Node>] See \{#query}
-    def initialize(uri, query = [])
+    # @param supports_condition [Sass::Supports::Condition] See \{#supports_condition}
+    def initialize(uri, query = [], supports_condition = nil)
       @uri = uri
       @query = query
+      @supports_condition = supports_condition
       super('')
     end
 
@@ -52,6 +59,7 @@ module Sass::Tree
       @resolved_value ||=
         begin
           str = "@import #{resolved_uri}"
+          str << " supports(#{supports_condition.to_css})" if supports_condition
           str << " #{resolved_query.to_css}" if resolved_query
           str
         end

data/lib/sass/tree/function_node.rb

@@ -20,6 +20,12 @@ module Sass
       # @return [Script::Tree::Node?]
       attr_accessor :splat
 
+      # Strips out any vendor prefixes.
+      # @return [String] The normalized name of the directive.
+      def normalized_name
+        @normalized_name ||= name.gsub(/^(?:-[a-zA-Z0-9]+-)?/, '\1')
+      end
+
       # @param name [String] The function name
       # @param args [Array<(Script::Tree::Node, Script::Tree::Node)>]
       #   The arguments for the function.
@@ -30,9 +36,8 @@ module Sass
         @splat = splat
         super()
 
-        if %w[and or not].include?(name)
-          raise Sass::SyntaxError.new("Invalid function name \"#{name}\".")
-        end
+        return unless %w(and or not).include?(name)
+        raise Sass::SyntaxError.new("Invalid function name \"#{name}\".")
       end
     end
   end

data/lib/sass/tree/import_node.rb

@@ -55,13 +55,14 @@ module Sass
           return f if f
         end
 
-        message = "File to import not found or unreadable: #{@imported_filename}.\n"
+        lines = ["File to import not found or unreadable: #{@imported_filename}."]
+
         if paths.size == 1
-          message << "Load path: #{paths.first}"
-        else
-          message << "Load paths:\n  " << paths.join("\n  ")
+          lines << "Load path: #{paths.first}"
+        elsif !paths.empty?
+          lines << "Load paths:\n  #{paths.join("\n  ")}"
         end
-        raise SyntaxError.new(message)
+        raise SyntaxError.new(lines.join("\n"))
       rescue SyntaxError => e
         raise SyntaxError.new(e.message, :line => line, :filename => @filename)
       end

data/lib/sass/tree/node.rb

@@ -69,7 +69,7 @@ module Sass
 
       # The line of the document on which this node appeared.
       #
-      # @return [Fixnum]
+      # @return [Integer]
       attr_accessor :line
 
       # The source range in the document on which this node appeared.
@@ -83,13 +83,15 @@ module Sass
       attr_writer :filename
 
       # The options hash for the node.
-      # See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
+      # See {file:SASS_REFERENCE.md#Options the Sass options documentation}.
       #
       # @return [{Symbol => Object}]
       attr_reader :options
 
       def initialize
         @children = []
+        @filename = nil
+        @options = nil
       end
 
       # Sets the options hash for the node and all its children.
@@ -149,7 +151,7 @@ module Sass
       # @return [Boolean]
       def invisible?; false; end
 
-      # The output style. See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
+      # The output style. See {file:SASS_REFERENCE.md#Options the Sass options documentation}.
       #
       # @return [Symbol]
       def style

data/lib/sass/tree/prop_node.rb

@@ -39,7 +39,7 @@ module Sass::Tree
     # * This is a child property of another property
     # * The parent property has a value, and thus will be rendered
     #
-    # @return [Fixnum]
+    # @return [Integer]
     attr_accessor :tabs
 
     # The source range in which the property name appears.
@@ -119,11 +119,10 @@ module Sass::Tree
     private
 
     def check!
-      if @options[:property_syntax] && @options[:property_syntax] != @prop_syntax
-        raise Sass::SyntaxError.new(
-          "Illegal property syntax: can't use #{@prop_syntax} syntax when " +
-          ":property_syntax => #{@options[:property_syntax].inspect} is set.")
-      end
+      return unless @options[:property_syntax] && @options[:property_syntax] != @prop_syntax
+      raise Sass::SyntaxError.new(
+        "Illegal property syntax: can't use #{@prop_syntax} syntax when " +
+        ":property_syntax => #{@options[:property_syntax].inspect} is set.")
     end
 
     class << self

data/lib/sass/tree/rule_node.rb

@@ -40,7 +40,7 @@ module Sass::Tree
     # * This is a child rule of another rule
     # * The parent rule has properties, and thus will be rendered
     #
-    # @return [Fixnum]
+    # @return [Integer]
     attr_accessor :tabs
 
     # The entire selector source range for this rule.
@@ -132,14 +132,24 @@ module Sass::Tree
     private
 
     def try_to_parse_non_interpolated_rules
-      if @rule.all? {|t| t.kind_of?(String)}
-        # We don't use real filename/line info because we don't have it yet.
-        # When we get it, we'll set it on the parsed rules if possible.
+      @parsed_rules = nil
+      return unless @rule.all? {|t| t.is_a?(String)}
+
+      # We don't use real filename/line info because we don't have it yet.
+      # When we get it, we'll set it on the parsed rules if possible.
+      parser = nil
+      warnings = Sass::Util.silence_warnings do
         parser = Sass::SCSS::StaticParser.new(@rule.join.strip, nil, nil, 1)
         # rubocop:disable RescueModifier
         @parsed_rules = parser.parse_selector rescue nil
         # rubocop:enable RescueModifier
+
+        $stderr.string
       end
+
+      # If parsing produces a warning, throw away the result so we can parse
+      # later with the real filename info.
+      @parsed_rules = nil unless warnings.empty?
     end
   end
 end

data/lib/sass/tree/visitors/check_nesting.rb

@@ -4,6 +4,8 @@ class Sass::Tree::Visitors::CheckNesting < Sass::Tree::Visitors::Base
 
   def initialize
     @parents = []
+    @parent = nil
+    @current_mixin_def = nil
   end
 
   def visit(node)
@@ -90,9 +92,8 @@ class Sass::Tree::Visitors::CheckNesting < Sass::Tree::Visitors::Base
 
   VALID_EXTEND_PARENTS = [Sass::Tree::RuleNode, Sass::Tree::MixinDefNode, Sass::Tree::MixinNode]
   def invalid_extend_parent?(parent, child)
-    unless is_any_of?(parent, VALID_EXTEND_PARENTS)
-      return "Extend directives may only be used within rules."
-    end
+    return if is_any_of?(parent, VALID_EXTEND_PARENTS)
+    "Extend directives may only be used within rules."
   end
 
   INVALID_IMPORT_PARENTS = CONTROL_NODES +
@@ -110,15 +111,13 @@ class Sass::Tree::Visitors::CheckNesting < Sass::Tree::Visitors::Base
   end
 
   def invalid_mixindef_parent?(parent, child)
-    unless (@parents.map {|p| p.class} & INVALID_IMPORT_PARENTS).empty?
-      return "Mixins may not be defined within control directives or other mixins."
-    end
+    return if (@parents.map {|p| p.class} & INVALID_IMPORT_PARENTS).empty?
+    "Mixins may not be defined within control directives or other mixins."
   end
 
   def invalid_function_parent?(parent, child)
-    unless (@parents.map {|p| p.class} & INVALID_IMPORT_PARENTS).empty?
-      return "Functions may not be defined within control directives or other mixins."
-    end
+    return if (@parents.map {|p| p.class} & INVALID_IMPORT_PARENTS).empty?
+    "Functions may not be defined within control directives or other mixins."
   end
 
   VALID_FUNCTION_CHILDREN = [
@@ -126,27 +125,24 @@ class Sass::Tree::Visitors::CheckNesting < Sass::Tree::Visitors::Base
     Sass::Tree::VariableNode, Sass::Tree::WarnNode, Sass::Tree::ErrorNode
   ] + CONTROL_NODES
   def invalid_function_child?(parent, child)
-    unless is_any_of?(child, VALID_FUNCTION_CHILDREN)
-      "Functions can only contain variable declarations and control directives."
-    end
+    return if is_any_of?(child, VALID_FUNCTION_CHILDREN)
+    "Functions can only contain variable declarations and control directives."
   end
 
-  VALID_PROP_CHILDREN =  CONTROL_NODES + [Sass::Tree::CommentNode,
-                                          Sass::Tree::PropNode,
-                                          Sass::Tree::MixinNode]
+  VALID_PROP_CHILDREN = CONTROL_NODES + [Sass::Tree::CommentNode,
+                                         Sass::Tree::PropNode,
+                                         Sass::Tree::MixinNode]
   def invalid_prop_child?(parent, child)
-    unless is_any_of?(child, VALID_PROP_CHILDREN)
-      "Illegal nesting: Only properties may be nested beneath properties."
-    end
+    return if is_any_of?(child, VALID_PROP_CHILDREN)
+    "Illegal nesting: Only properties may be nested beneath properties."
   end
 
   VALID_PROP_PARENTS = [Sass::Tree::RuleNode, Sass::Tree::KeyframeRuleNode, Sass::Tree::PropNode,
                         Sass::Tree::MixinDefNode, Sass::Tree::DirectiveNode, Sass::Tree::MixinNode]
   def invalid_prop_parent?(parent, child)
-    unless is_any_of?(parent, VALID_PROP_PARENTS)
-      "Properties are only allowed within rules, directives, mixin includes, or other properties." +
-        child.pseudo_class_selector_message
-    end
+    return if is_any_of?(parent, VALID_PROP_PARENTS)
+    "Properties are only allowed within rules, directives, mixin includes, or other properties." +
+      child.pseudo_class_selector_message
   end
 
   def invalid_return_parent?(parent, child)

data/lib/sass/tree/visitors/convert.rb

@@ -18,15 +18,19 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
     @tabs = 0
     # 2 spaces by default
     @tab_chars = @options[:indent] || "  "
+    @is_else = false
   end
 
   def visit_children(parent)
     @tabs += 1
     return @format == :sass ? "\n" : " {}\n" if parent.children.empty?
+
+    res = visit_rule_level(parent.children)
+
     if @format == :sass
-      "\n"  + super.join.rstrip + "\n"
+      "\n" + res.rstrip + "\n"
     else
-      " {\n" + super.join.rstrip + "\n#{ @tab_chars * (@tabs - 1)}}\n"
+      " {\n" + res.rstrip + "\n#{@tab_chars * (@tabs - 1)}}\n"
     end
   ensure
     @tabs -= 1
@@ -34,20 +38,7 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
 
   # Ensures proper spacing between top-level nodes.
   def visit_root(node)
-    Sass::Util.enum_cons(node.children + [nil], 2).map do |child, nxt|
-      visit(child) +
-        if nxt &&
-            (child.is_a?(Sass::Tree::CommentNode) &&
-              child.line + child.lines + 1 == nxt.line) ||
-            (child.is_a?(Sass::Tree::ImportNode) && nxt.is_a?(Sass::Tree::ImportNode) &&
-              child.line + 1 == nxt.line) ||
-            (child.is_a?(Sass::Tree::VariableNode) && nxt.is_a?(Sass::Tree::VariableNode) &&
-              child.line + 1 == nxt.line)
-          ""
-        else
-          "\n"
-        end
-    end.join.rstrip + "\n"
+    visit_rule_level(node.children)
   end
 
   def visit_charset(node)
@@ -57,14 +48,14 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
   def visit_comment(node)
     value = interp_to_src(node.value)
     if @format == :sass
-      content = value.gsub(/\*\/$/, '').rstrip
+      content = value.gsub(%r{\*/$}, '').rstrip
       if content =~ /\A[ \t]/
         # Re-indent SCSS comments like this:
         #     /* foo
         #   bar
         #       baz */
         content.gsub!(/^/, '   ')
-        content.sub!(/\A([ \t]*)\/\*/, '/*\1')
+        content.sub!(%r{\A([ \t]*)/\*}, '/*\1')
       end
 
       if content.include?("\n")
@@ -78,13 +69,13 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
         end
       end
 
-      content.gsub!(/\A\/\*/, '//') if node.type == :silent
+      content.gsub!(%r{\A/\*}, '//') if node.type == :silent
       content.gsub!(/^/, tab_str)
       content = content.rstrip + "\n"
     else
       spaces = (@tab_chars * [@tabs - value[/^ */].size, 0].max)
       content = if node.type == :silent
-                  value.gsub(/^[\/ ]\*/, '//').gsub(/ *\*\/$/, '')
+                  value.gsub(%r{^[/ ]\*}, '//').gsub(%r{ *\*/$}, '')
                 else
                   value
                 end.gsub(/^/, spaces) + "\n"
@@ -104,7 +95,7 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
     res = "#{tab_str}#{interp_to_src(node.value)}"
     res.gsub!(/^@import \#\{(.*)\}([^}]*)$/, '@import \1\2')
     return res + "#{semi}\n" unless node.has_children
-    res + yield + "\n"
+    res + yield
   end
 
   def visit_each(node)
@@ -113,13 +104,13 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
   end
 
   def visit_extend(node)
-    "#{tab_str}@extend #{selector_to_src(node.selector).lstrip}#{semi}" +
-      "#{" !optional" if node.optional?}\n"
+    "#{tab_str}@extend #{selector_to_src(node.selector).lstrip}" +
+      "#{' !optional' if node.optional?}#{semi}\n"
   end
 
   def visit_for(node)
     "#{tab_str}@for $#{dasherize(node.var)} from #{node.from.to_sass(@options)} " +
-      "#{node.exclusive ? "to" : "through"} #{node.to.to_sass(@options)}#{yield}"
+      "#{node.exclusive ? 'to' : 'through'} #{node.to.to_sass(@options)}#{yield}"
   end
 
   def visit_function(node)
@@ -173,6 +164,7 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
     else
       str = "#{tab_str}@import #{node.uri}"
     end
+    str << " supports(#{node.supports_condition.to_src(@options)})" if node.supports_condition
     str << " #{interp_to_src(node.query)}" unless node.query.empty?
     "#{str}#{semi}\n"
   end
@@ -274,14 +266,39 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
       "#{tab_str}@at-root #{query_interp_to_src(node.query)}#{yield}"
     elsif node.children.length == 1 && node.children.first.is_a?(Sass::Tree::RuleNode)
       rule = node.children.first
-      "#{tab_str}@at-root #{selector_to_src(rule.rule)}#{visit_children(rule)}"
+      "#{tab_str}@at-root #{selector_to_src(rule.rule).lstrip}#{visit_children(rule)}"
     else
       "#{tab_str}@at-root#{yield}"
     end
   end
 
+  def visit_keyframerule(node)
+    "#{tab_str}#{node.resolved_value}#{yield}"
+  end
+
   private
 
+  # Visit rule-level nodes and return their conversion with appropriate
+  # whitespace added.
+  def visit_rule_level(nodes)
+    Sass::Util.enum_cons(nodes + [nil], 2).map do |child, nxt|
+      visit(child) +
+        if nxt &&
+            (child.is_a?(Sass::Tree::CommentNode) && child.line + child.lines + 1 == nxt.line) ||
+            (child.is_a?(Sass::Tree::ImportNode) && nxt.is_a?(Sass::Tree::ImportNode) &&
+              child.line + 1 == nxt.line) ||
+            (child.is_a?(Sass::Tree::VariableNode) && nxt.is_a?(Sass::Tree::VariableNode) &&
+              child.line + 1 == nxt.line) ||
+            (child.is_a?(Sass::Tree::PropNode) && nxt.is_a?(Sass::Tree::PropNode)) ||
+            (child.is_a?(Sass::Tree::MixinNode) && nxt.is_a?(Sass::Tree::MixinNode) &&
+              child.line + 1 == nxt.line)
+          ""
+        else
+          "\n"
+        end
+    end.join.rstrip + "\n"
+  end
+
   def interp_to_src(interp)
     interp.map {|r| r.is_a?(String) ? r : r.to_sass(@options)}.join
   end
@@ -326,7 +343,7 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
 
   def dasherize(s)
     if @options[:dasherize]
-      s.gsub('_', '-')
+      s.tr('_', '-')
     else
       s
     end

data/lib/sass/tree/visitors/cssize.rb

@@ -222,7 +222,11 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
   # Bubbles a directive up through RuleNodes.
   def visit_directive(node)
     return node unless node.has_children
-    return bubble(node) if parent.is_a?(Sass::Tree::RuleNode)
+    if parent.is_a?(Sass::Tree::RuleNode)
+      # @keyframes shouldn't include the rule nodes, so we manually create a
+      # bubble that doesn't have the parent's contents for them.
+      return node.normalized_name == '@keyframes' ? Bubble.new(node) : bubble(node)
+    end
 
     yield
 

data/lib/sass/tree/visitors/deep_copy.rb

@@ -55,7 +55,7 @@ class Sass::Tree::Visitors::DeepCopy < Sass::Tree::Visitors::Base
 
   def visit_mixin(node)
     node.args = node.args.map {|a| a.deep_copy}
-    node.keywords = Hash[node.keywords.map {|k, v| [k, v.deep_copy]}]
+    node.keywords = Sass::Util::NormalizedMap.new(Hash[node.keywords.map {|k, v| [k, v.deep_copy]}])
     yield
   end
 

data/lib/sass/tree/visitors/extend.rb

@@ -44,25 +44,27 @@ class Sass::Tree::Visitors::Extend < Sass::Tree::Visitors::Base
     node.resolved_rules = node.resolved_rules.do_extend(@extends, @parent_directives)
   end
 
-  private
+  class << self
+    private
 
-  def self.check_extends_fired!(extends)
-    extends.each_value do |ex|
-      next if ex.result == :succeeded || ex.node.optional?
-      message = "\"#{ex.extender}\" failed to @extend \"#{ex.target.join}\"."
-      reason =
-        if ex.result == :not_found
-          "The selector \"#{ex.target.join}\" was not found."
-        else
-          "No selectors matching \"#{ex.target.join}\" could be unified with \"#{ex.extender}\"."
-        end
+    def check_extends_fired!(extends)
+      extends.each_value do |ex|
+        next if ex.result == :succeeded || ex.node.optional?
+        message = "\"#{ex.extender}\" failed to @extend \"#{ex.target.join}\"."
+        reason =
+          if ex.result == :not_found
+            "The selector \"#{ex.target.join}\" was not found."
+          else
+            "No selectors matching \"#{ex.target.join}\" could be unified with \"#{ex.extender}\"."
+          end
 
-      # TODO(nweiz): this should use the Sass stack trace of the extend node.
-      raise Sass::SyntaxError.new(<<MESSAGE, :filename => ex.node.filename, :line => ex.node.line)
+        # TODO(nweiz): this should use the Sass stack trace of the extend node.
+        raise Sass::SyntaxError.new(<<MESSAGE, :filename => ex.node.filename, :line => ex.node.line)
 #{message}
 #{reason}
 Use "@extend #{ex.target.join} !optional" if the extend should be able to fail.
 MESSAGE
+      end
     end
   end
 end

data/lib/sass/tree/visitors/perform.rb

@@ -1,5 +1,7 @@
 # A visitor for converting a dynamic Sass tree into a static Sass tree.
 class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
+  @@function_name_deprecation = Sass::Deprecation.new
+
   class << self
     # @param root [Tree::Node] The root node of the tree to visit.
     # @param environment [Sass::Environment] The lexical environment.
@@ -11,7 +13,7 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
     # @api private
     # @comment
     #   rubocop:disable MethodLength
-    def perform_arguments(callable, args, splat)
+    def perform_arguments(callable, args, splat, environment)
       desc = "#{callable.type.capitalize} #{callable.name}"
       downcase_desc = "#{callable.type} #{callable.name}"
 
@@ -41,20 +43,26 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
       # raising happens in the ensure clause at the end of this function.
       return if keyword_exception && !callable.splat
 
-      if args.size > callable.args.size && !callable.splat
-        takes = callable.args.size
-        passed = args.size
-        raise Sass::SyntaxError.new(
-          "#{desc} takes #{takes} argument#{'s' unless takes == 1} " +
-          "but #{passed} #{passed == 1 ? 'was' : 'were'} passed.")
-      end
-
       splat_sep = :comma
       if splat
         args += splat.to_a
         splat_sep = splat.separator
       end
 
+      if args.size > callable.args.size && !callable.splat
+        extra_args_because_of_splat = splat && args.size - splat.to_a.size <= callable.args.size
+
+        takes = callable.args.size
+        passed = args.size
+        message = "#{desc} takes #{takes} argument#{'s' unless takes == 1} " +
+          "but #{passed} #{passed == 1 ? 'was' : 'were'} passed."
+        raise Sass::SyntaxError.new(message) unless extra_args_because_of_splat
+        # TODO: when the deprecation period is over, make this an error.
+        Sass::Util.sass_warn("WARNING: #{message}\n" +
+          environment.stack.to_s.gsub(/^/m, " " * 8) + "\n" +
+          "This will be an error in future versions of Sass.")
+      end
+
       env = Sass::Environment.new(callable.environment)
       callable.args.zip(args[0...callable.args.length]) do |(var, default), value|
         if value && keywords.has_key?(var.name)
@@ -144,6 +152,8 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
 
   def initialize(env)
     @environment = env
+    @in_keyframes = false
+    @at_root_without_rule = false
   end
 
   # If an exception is raised, this adds proper metadata to the backtrace.
@@ -222,7 +232,7 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
   def visit_each(node)
     list = node.list.perform(@environment)
 
-    with_environment Sass::Environment.new(@environment) do
+    with_environment Sass::SemiGlobalEnvironment.new(@environment) do
       list.to_a.map do |value|
         if node.vars.length == 1
           @environment.set_local_var(node.vars.first, value)
@@ -256,7 +266,7 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
     direction = from.to_i > to.to_i ? -1 : 1
     range = Range.new(direction * from.to_i, direction * to.to_i, node.exclusive)
 
-    with_environment Sass::Environment.new(@environment) do
+    with_environment Sass::SemiGlobalEnvironment.new(@environment) do
       range.map do |i|
         @environment.set_local_var(node.var,
           Sass::Script::Value::Number.new(direction * i,
@@ -269,9 +279,18 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
   # Loads the function into the environment.
   def visit_function(node)
     env = Sass::Environment.new(@environment, node.options)
+
+    if node.normalized_name == 'calc' || node.normalized_name == 'element' ||
+        node.name == 'expression' || node.name == 'url'
+      @@function_name_deprecation.warn(node.filename, node.line, <<WARNING)
+Naming a function "#{node.name}" is disallowed and will be an error in future versions of Sass.
+This name conflicts with an existing CSS function with special parse rules.
+WARNING
+    end
+
     @environment.set_local_function(node.name,
       Sass::Callable.new(node.name, node.args, node.splat, env,
-                         node.children, !:has_content, "function"))
+                         node.children, false, "function"))
     []
   end
 
@@ -279,8 +298,9 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
   # otherwise, tries the else nodes.
   def visit_if(node)
     if node.expr.nil? || node.expr.perform(@environment).to_bool
-      yield
-      node.children
+      with_environment Sass::SemiGlobalEnvironment.new(@environment) do
+        node.children.map {|c| visit(c)}
+      end.flatten
     elsif node.else
       visit(node.else)
     else
@@ -293,6 +313,7 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
   def visit_import(node)
     if (path = node.css_import?)
       resolved_node = Sass::Tree::CssImportNode.resolved("url(#{path})")
+      resolved_node.options = node.options
       resolved_node.source_range = node.source_range
       return resolved_node
     end
@@ -331,14 +352,14 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
       raise Sass::SyntaxError.new("Undefined mixin '#{node.name}'.") unless mixin
 
       if node.children.any? && !mixin.has_content
-        raise Sass::SyntaxError.new(%Q{Mixin "#{node.name}" does not accept a content block.})
+        raise Sass::SyntaxError.new(%(Mixin "#{node.name}" does not accept a content block.))
       end
 
       args = node.args.map {|a| a.perform(@environment)}
       keywords = Sass::Util.map_vals(node.keywords) {|v| v.perform(@environment)}
       splat = self.class.perform_splat(node.splat, keywords, node.kwarg_splat, @environment)
 
-      self.class.perform_arguments(mixin, args, splat) do |env|
+      self.class.perform_arguments(mixin, args, splat, @environment) do |env|
         env.caller = Sass::Environment.new(@environment)
         env.content = [node.children, @environment] if node.has_children
 
@@ -397,6 +418,7 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
       keyframe_rule_node.line = node.line
       keyframe_rule_node.filename = node.filename
       keyframe_rule_node.source_range = node.source_range
+      keyframe_rule_node.has_children = node.has_children
       with_environment Sass::Environment.new(@environment, node.options) do
         keyframe_rule_node.children = node.children.map {|c| visit(c)}.flatten
       end
@@ -470,7 +492,7 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
   # Runs the child nodes until the continuation expression becomes false.
   def visit_while(node)
     children = []
-    with_environment Sass::Environment.new(@environment) do
+    with_environment Sass::SemiGlobalEnvironment.new(@environment) do
       children += node.children.map {|c| visit(c)} while node.expr.perform(@environment).to_bool
     end
     children.flatten
@@ -507,6 +529,9 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
         node.filename, node.options[:importer], node.line)
       node.resolved_query ||= parser.parse_media_query_list
     end
+    if node.supports_condition
+      node.supports_condition.perform(@environment)
+    end
     yield
   end
 

data/lib/sass/tree/visitors/set_options.rb

@@ -80,7 +80,7 @@ class Sass::Tree::Visitors::SetOptions < Sass::Tree::Visitors::Base
 
   def visit_mixin(node)
     node.args.each {|a| a.options = @options}
-    node.keywords.each {|k, v| v.options = @options}
+    node.keywords.each {|_k, v| v.options = @options}
     node.splat.options = @options if node.splat
     node.kwarg_splat.options = @options if node.kwarg_splat
     yield