sass 3.2.7 → 3.3.0.rc.1

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

@@ -1,103 +1,156 @@
 # A visitor for converting a dynamic Sass tree into a static Sass tree.
 class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
-  # @param root [Tree::Node] The root node of the tree to visit.
-  # @param environment [Sass::Environment] The lexical environment.
-  # @return [Tree::Node] The resulting tree of static nodes.
-  def self.visit(root, environment = Sass::Environment.new)
-    new(environment).send(:visit, root)
-  end
+  class << self
+    # @param root [Tree::Node] The root node of the tree to visit.
+    # @param environment [Sass::Environment] The lexical environment.
+    # @return [Tree::Node] The resulting tree of static nodes.
+    def visit(root, environment = nil)
+      new(environment).send(:visit, root)
+    end
+
+    # @api private
+    # @comment
+    #   rubocop:disable MethodLength
+    def perform_arguments(callable, args, splat)
+      desc = "#{callable.type.capitalize} #{callable.name}"
+      downcase_desc = "#{callable.type} #{callable.name}"
+
+      # All keywords are contained in splat.keywords for consistency,
+      # even if there were no splats passed in.
+      old_keywords_accessed = splat.keywords_accessed
+      keywords = splat.keywords
+      splat.keywords_accessed = old_keywords_accessed
+
+      begin
+        unless keywords.empty?
+          unknown_args = Sass::Util.array_minus(keywords.keys,
+            callable.args.map {|var| var.first.underscored_name})
+          if callable.splat && unknown_args.include?(callable.splat.underscored_name)
+            raise Sass::SyntaxError.new("Argument $#{callable.splat.name} of #{downcase_desc} " +
+                                        "cannot be used as a named argument.")
+          elsif unknown_args.any?
+            description = unknown_args.length > 1 ? 'the following arguments:' : 'an argument named'
+            raise Sass::SyntaxError.new("#{desc} doesn't have #{description} " +
+                                        "#{unknown_args.map {|name| "$#{name}"}.join ', '}.")
+          end
+        end
+      rescue Sass::SyntaxError => keyword_exception
+      end
 
-  # @api private
-  def self.perform_arguments(callable, args, keywords, splat)
-    desc = "#{callable.type.capitalize} #{callable.name}"
-    downcase_desc = "#{callable.type} #{callable.name}"
+      # If there's no splat, raise the keyword exception immediately. The actual
+      # raising happens in the ensure clause at the end of this function.
+      return if keyword_exception && !callable.splat
 
-    begin
-      unless keywords.empty?
-        unknown_args = Sass::Util.array_minus(keywords.keys,
-          callable.args.map {|var| var.first.underscored_name})
-        if callable.splat && unknown_args.include?(callable.splat.underscored_name)
-          raise Sass::SyntaxError.new("Argument $#{callable.splat.name} of #{downcase_desc} cannot be used as a named argument.")
-        elsif unknown_args.any?
-          description = unknown_args.length > 1 ? 'the following arguments:' : 'an argument named'
-          raise Sass::SyntaxError.new("#{desc} doesn't have #{description} #{unknown_args.map {|name| "$#{name}"}.join ', '}.")
+      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
+
+      keywords = keywords.dup
+      env = Sass::Environment.new(callable.environment)
+      callable.args.zip(args[0...callable.args.length]) do |(var, default), value|
+        if value && keywords.include?(var.underscored_name)
+          raise Sass::SyntaxError.new("#{desc} was passed argument $#{var.name} " +
+                                      "both by position and by name.")
         end
+
+        value ||= keywords.delete(var.underscored_name)
+        value ||= default && default.perform(env)
+        raise Sass::SyntaxError.new("#{desc} is missing argument #{var.inspect}.") unless value
+        env.set_local_var(var.name, value)
       end
-    rescue Sass::SyntaxError => keyword_exception
-    end
 
-    # If there's no splat, raise the keyword exception immediately. The actual
-    # raising happens in the ensure clause at the end of this function.
-    return if keyword_exception && !callable.splat
+      if callable.splat
+        rest = args[callable.args.length..-1] || []
+        arg_list = Sass::Script::Value::ArgList.new(rest, keywords.dup, splat_sep)
+        arg_list.options = env.options
+        env.set_local_var(callable.splat.name, arg_list)
+      end
 
-    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.")
+      yield env
+    rescue StandardError => e
+    ensure
+      # If there's a keyword exception, we don't want to throw it immediately,
+      # because the invalid keywords may be part of a glob argument that should be
+      # passed on to another function. So we only raise it if we reach the end of
+      # this function *and* the keywords attached to the argument list glob object
+      # haven't been accessed.
+      #
+      # The keyword exception takes precedence over any Sass errors, but not over
+      # non-Sass exceptions.
+      if keyword_exception &&
+          !(arg_list && arg_list.keywords_accessed) &&
+          (e.nil? || e.is_a?(Sass::SyntaxError))
+        raise keyword_exception
+      elsif e
+        raise e
+      end
     end
 
-    splat_sep = :comma
-    if splat
-      args += splat.to_a
-      splat_sep = splat.separator if splat.is_a?(Sass::Script::List)
-      # If the splat argument exists, there won't be any keywords passed in
-      # manually, so we can safely overwrite rather than merge here.
-      keywords = splat.keywords if splat.is_a?(Sass::Script::ArgList)
-    end
+    # @api private
+    # @return [Sass::Script::Value::ArgList]
+    def perform_splat(splat, performed_keywords, kwarg_splat, environment)
+      args, kwargs, separator = [], Sass::Util.ordered_hash, :comma
+
+      if splat
+        splat = splat.perform(environment)
+        separator = splat.separator || separator
+        if splat.is_a?(Sass::Script::Value::ArgList)
+          args = splat.to_a
+          kwargs = splat.keywords
+        elsif splat.is_a?(Sass::Script::Value::Map)
+          kwargs = arg_hash(splat)
+        else
+          args = splat.to_a
+        end
+      end
 
-    keywords = keywords.dup
-    env = Sass::Environment.new(callable.environment)
-    callable.args.zip(args[0...callable.args.length]) do |(var, default), value|
-      if value && keywords.include?(var.underscored_name)
-        raise Sass::SyntaxError.new("#{desc} was passed argument $#{var.name} both by position and by name.")
+      kwargs = kwargs.merge(performed_keywords)
+
+      if kwarg_splat
+        kwarg_splat = kwarg_splat.perform(environment)
+        unless kwarg_splat.is_a?(Sass::Script::Value::Map)
+          raise Sass::SyntaxError.new("Variable keyword arguments must be a map " +
+                                      "(was #{kwarg_splat.inspect}).")
+        end
+        kwargs = kwargs.merge(arg_hash(kwarg_splat))
       end
 
-      value ||= keywords.delete(var.underscored_name)
-      value ||= default && default.perform(env)
-      raise Sass::SyntaxError.new("#{desc} is missing argument #{var.inspect}.") unless value
-      env.set_local_var(var.name, value)
+      Sass::Script::Value::ArgList.new(args, kwargs, separator)
     end
 
-    if callable.splat
-      rest = args[callable.args.length..-1]
-      arg_list = Sass::Script::ArgList.new(rest, keywords.dup, splat_sep)
-      arg_list.options = env.options
-      env.set_local_var(callable.splat.name, arg_list)
-    end
+    private
 
-    yield env
-  rescue Exception => e
-  ensure
-    # If there's a keyword exception, we don't want to throw it immediately,
-    # because the invalid keywords may be part of a glob argument that should be
-    # passed on to another function. So we only raise it if we reach the end of
-    # this function *and* the keywords attached to the argument list glob object
-    # haven't been accessed.
-    #
-    # The keyword exception takes precedence over any Sass errors, but not over
-    # non-Sass exceptions.
-    if keyword_exception &&
-        !(arg_list && arg_list.keywords_accessed) &&
-        (e.nil? || e.is_a?(Sass::SyntaxError))
-      raise keyword_exception
-    elsif e
-      raise e
+    def arg_hash(map)
+      Sass::Util.map_keys(map.to_h) do |key|
+        next key.value if key.is_a?(Sass::Script::Value::String)
+        raise Sass::SyntaxError.new("Variable keyword argument map must have string keys.\n" +
+          "#{key.inspect} is not a string in #{map.inspect}.")
+      end
     end
   end
+  # @comment
+  #   rubocop:enable MethodLength
 
   protected
 
   def initialize(env)
     @environment = env
-    # Stack trace information, including mixin includes and imports.
-    @stack = []
   end
 
   # If an exception is raised, this adds proper metadata to the backtrace.
   def visit(node)
-    super(node.dup)
+    return super(node.dup) unless @environment
+    @environment.stack.with_base(node.filename, node.line) {super(node.dup)}
   rescue Sass::SyntaxError => e
     e.modify_backtrace(:filename => node.filename, :line => node.line)
     raise e
@@ -142,11 +195,11 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
   # Prints the expression to STDERR.
   def visit_debug(node)
     res = node.expr.perform(@environment)
-    res = res.value if res.is_a?(Sass::Script::String)
+    res = res.value if res.is_a?(Sass::Script::Value::String)
     if node.filename
-      $stderr.puts "#{node.filename}:#{node.line} DEBUG: #{res}"
+      Sass::Util.sass_warn "#{node.filename}:#{node.line} DEBUG: #{res}"
     else
-      $stderr.puts "Line #{node.line} DEBUG: #{res}"
+      Sass::Util.sass_warn "Line #{node.line} DEBUG: #{res}"
     end
     []
   end
@@ -156,8 +209,14 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
     list = node.list.perform(@environment)
 
     with_environment Sass::Environment.new(@environment) do
-      list.to_a.map do |v|
-        @environment.set_local_var(node.var, v)
+      list.to_a.map do |value|
+        if node.vars.length == 1
+          @environment.set_local_var(node.vars.first, value)
+        else
+          node.vars.zip(value.to_a) do |(var, sub_value)|
+            @environment.set_local_var(var, sub_value || Sass::Script::Value::Null.new)
+          end
+        end
         node.children.map {|c| visit(c)}
       end.flatten
     end
@@ -166,7 +225,8 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
   # Runs SassScript interpolation in the selector,
   # and then parses the result into a {Sass::Selector::CommaSequence}.
   def visit_extend(node)
-    parser = Sass::SCSS::StaticParser.new(run_interp(node.selector), node.filename, node.line)
+    parser = Sass::SCSS::StaticParser.new(run_interp(node.selector),
+      node.filename, node.options[:importer], node.line)
     node.resolved_selector = parser.parse_selector
     node
   end
@@ -184,7 +244,7 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
     with_environment Sass::Environment.new(@environment) do
       range.map do |i|
         @environment.set_local_var(node.var,
-          Sass::Script::Number.new(i, from.numerator_units, from.denominator_units))
+          Sass::Script::Value::Number.new(i, from.numerator_units, from.denominator_units))
         node.children.map {|c| visit(c)}
       end.flatten
     end
@@ -194,7 +254,8 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
   def visit_function(node)
     env = Sass::Environment.new(@environment, node.options)
     @environment.set_local_function(node.name,
-      Sass::Callable.new(node.name, node.args, node.splat, env, node.children, !:has_content, "function"))
+      Sass::Callable.new(node.name, node.args, node.splat, env,
+                         node.children, !:has_content, "function"))
     []
   end
 
@@ -214,59 +275,67 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
   # Returns a static DirectiveNode if this is importing a CSS file,
   # or parses and includes the imported Sass file.
   def visit_import(node)
-    if path = node.css_import?
-      return Sass::Tree::CssImportNode.resolved("url(#{path})")
+    if (path = node.css_import?)
+      resolved_node = Sass::Tree::CssImportNode.resolved("url(#{path})")
+      resolved_node.source_range = node.source_range
+      return resolved_node
     end
     file = node.imported_file
-    handle_import_loop!(node) if @stack.any? {|e| e[:filename] == file.options[:filename]}
+    if @environment.stack.frames.any? {|f| f.is_import? && f.filename == file.options[:filename]}
+      handle_import_loop!(node)
+    end
 
     begin
-      @stack.push(:filename => node.filename, :line => node.line)
-      root = file.to_tree
-      Sass::Tree::Visitors::CheckNesting.visit(root)
-      node.children = root.children.map {|c| visit(c)}.flatten
-      node
+      @environment.stack.with_import(node.filename, node.line) do
+        root = file.to_tree
+        Sass::Tree::Visitors::CheckNesting.visit(root)
+        node.children = root.children.map {|c| visit(c)}.flatten
+        node
+      end
     rescue Sass::SyntaxError => e
       e.modify_backtrace(:filename => node.imported_file.options[:filename])
       e.add_backtrace(:filename => node.filename, :line => node.line)
       raise e
     end
-  ensure
-    @stack.pop unless path
   end
 
   # Loads a mixin into the environment.
   def visit_mixindef(node)
     env = Sass::Environment.new(@environment, node.options)
     @environment.set_local_mixin(node.name,
-      Sass::Callable.new(node.name, node.args, node.splat, env, node.children, node.has_content, "mixin"))
+      Sass::Callable.new(node.name, node.args, node.splat, env,
+                         node.children, node.has_content, "mixin"))
     []
   end
 
   # Runs a mixin.
   def visit_mixin(node)
     include_loop = true
-    handle_include_loop!(node) if @stack.any? {|e| e[:name] == node.name}
+    if @environment.stack.frames.any? {|f| f.is_mixin? && f.name == node.name}
+      handle_include_loop!(node)
+    end
     include_loop = false
 
-    @stack.push(:filename => node.filename, :line => node.line, :name => node.name)
-    raise Sass::SyntaxError.new("Undefined mixin '#{node.name}'.") unless mixin = @environment.mixin(node.name)
+    @environment.stack.with_mixin(node.filename, node.line, node.name) do
+      mixin = @environment.mixin(node.name)
+      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.})
-    end
+      if node.children.any? && !mixin.has_content
+        raise Sass::SyntaxError.new(%Q{Mixin "#{node.name}" does not accept a content block.})
+      end
 
-    args = node.args.map {|a| a.perform(@environment)}
-    keywords = Sass::Util.map_hash(node.keywords) {|k, v| [k, v.perform(@environment)]}
-    splat = node.splat.perform(@environment) if node.splat
+      args = node.args.map {|a| a.perform(@environment)}
+      keywords = Sass::Util.map_hash(node.keywords) {|k, v| [k, v.perform(@environment)]}
+      splat = self.class.perform_splat(node.splat, keywords, node.kwarg_splat, @environment)
 
-    self.class.perform_arguments(mixin, args, keywords, splat) do |env|
-      env.caller = Sass::Environment.new(@environment)
-      env.content = node.children if node.has_children
+      self.class.perform_arguments(mixin, args, splat) do |env|
+        env.caller = Sass::Environment.new(@environment)
+        env.content = [node.children, @environment] if node.has_children
 
-      trace_node = Sass::Tree::TraceNode.from_node(node.name, node)
-      with_environment(env) {trace_node.children = mixin.tree.map {|c| visit(c)}.flatten}
-      trace_node
+        trace_node = Sass::Tree::TraceNode.from_node(node.name, node)
+        with_environment(env) {trace_node.children = mixin.tree.map {|c| visit(c)}.flatten}
+        trace_node
+      end
     end
   rescue Sass::SyntaxError => e
     unless include_loop
@@ -274,22 +343,24 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
       e.add_backtrace(:line => node.line)
     end
     raise e
-  ensure
-    @stack.pop unless include_loop
   end
 
   def visit_content(node)
-    return [] unless content = @environment.content
-    @stack.push(:filename => node.filename, :line => node.line, :name => '@content')
-    trace_node = Sass::Tree::TraceNode.from_node('@content', node)
-    with_environment(@environment.caller) {trace_node.children = content.map {|c| visit(c.dup)}.flatten}
-    trace_node
+    content, content_env = @environment.content
+    return [] unless content
+    @environment.stack.with_mixin(node.filename, node.line, '@content') do
+      trace_node = Sass::Tree::TraceNode.from_node('@content', node)
+      content_env = Sass::Environment.new(content_env)
+      content_env.caller = Sass::Environment.new(@environment)
+      with_environment(content_env) do
+        trace_node.children = content.map {|c| visit(c.dup)}.flatten
+      end
+      trace_node
+    end
   rescue Sass::SyntaxError => e
     e.modify_backtrace(:mixin => '@content', :line => node.line)
     e.add_backtrace(:line => node.line)
     raise e
-  ensure
-    @stack.pop if content
   end
 
   # Runs any SassScript that may be embedded in a property.
@@ -297,6 +368,7 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
     node.resolved_name = run_interp(node.name)
     val = node.value.perform(@environment)
     node.resolved_value = val.to_s
+    node.value_source_range = val.source_range if val.source_range
     yield
   end
 
@@ -308,38 +380,78 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
   # Runs SassScript interpolation in the selector,
   # and then parses the result into a {Sass::Selector::CommaSequence}.
   def visit_rule(node)
-    rule = node.rule
-    rule = rule.map {|e| e.is_a?(String) && e != ' ' ? e.strip : e} if node.style == :compressed
-    parser = Sass::SCSS::StaticParser.new(run_interp(node.rule), node.filename, node.line)
+    old_at_root_without_rule, @at_root_without_rule = @at_root_without_rule, false
+    parser = Sass::SCSS::StaticParser.new(run_interp(node.rule),
+      node.filename, node.options[:importer], node.line)
     node.parsed_rules ||= parser.parse_selector
-    if node.options[:trace_selectors]
-      @stack.push(:filename => node.filename, :line => node.line)
-      node.stack_trace = stack_trace
-      @stack.pop
+    node.resolved_rules = node.parsed_rules.resolve_parent_refs(
+      @environment.selector, !old_at_root_without_rule)
+    node.stack_trace = @environment.stack.to_s if node.options[:trace_selectors]
+    with_environment Sass::Environment.new(@environment, node.options) do
+      @environment.selector = node.resolved_rules
+      node.children = node.children.map {|c| visit(c)}.flatten
+    end
+    node
+  ensure
+    @at_root_without_rule = old_at_root_without_rule
+  end
+
+  # Sets a variable that indicates that the first level of rule nodes
+  # shouldn't include the parent selector by default.
+  def visit_atroot(node)
+    if node.query
+      parser = Sass::SCSS::StaticParser.new(run_interp(node.query),
+        node.filename, node.options[:importer], node.line)
+      node.resolved_type, node.resolved_value = parser.parse_static_at_root_query
+    else
+      node.resolved_type, node.resolved_value = :without, ['rule']
     end
+
+    old_at_root_without_rule = @at_root_without_rule
+    @at_root_without_rule = true if node.exclude?('rule')
     yield
+  ensure
+    @at_root_without_rule = old_at_root_without_rule
   end
 
   # Loads the new variable value into the environment.
   def visit_variable(node)
-    var = @environment.var(node.name)
+    env = @environment
+    if node.global
+      env = env.global_env
+    elsif env.parent && env.is_var_global?(node.name)
+      var_expr = "$#{node.name}: #{node.expr.to_sass(env.options)} !global"
+      var_expr << " !default" if node.guarded
+      location = "on line #{node.line}"
+      location << " of #{node.filename}" if node.filename
+      Sass::Util.sass_warn <<WARNING
+DEPRECATION WARNING #{location}:
+Assigning to global variable "$#{node.name}" by default is deprecated.
+In future versions of Sass, this will create a new local variable.
+If you want to assign to the global variable, use "#{var_expr}" instead.
+WARNING
+    end
+
+    var = env.var(node.name)
     return [] if node.guarded && var && !var.null?
     val = node.expr.perform(@environment)
-    @environment.set_var(node.name, val)
+    if node.expr.source_range
+      val.source_range = node.expr.source_range
+    else
+      val.source_range = node.source_range
+    end
+    env.set_var(node.name, val)
     []
   end
 
   # Prints the expression to STDERR with a stylesheet trace.
   def visit_warn(node)
-    @stack.push(:filename => node.filename, :line => node.line)
     res = node.expr.perform(@environment)
-    res = res.value if res.is_a?(Sass::Script::String)
+    res = res.value if res.is_a?(Sass::Script::Value::String)
     msg = "WARNING: #{res}\n         "
-    msg << stack_trace.join("\n         ") << "\n"
+    msg << @environment.stack.to_s.gsub("\n", "\n         ") << "\n"
     Sass::Util.sass_warn msg
     []
-  ensure
-    @stack.pop
   end
 
   # Runs the child nodes until the continuation expression becomes false.
@@ -353,11 +465,15 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
 
   def visit_directive(node)
     node.resolved_value = run_interp(node.value)
-    yield
+    with_environment Sass::Environment.new(@environment) do
+      node.children = node.children.map {|c| visit(c)}.flatten
+      node
+    end
   end
 
   def visit_media(node)
-    parser = Sass::SCSS::StaticParser.new(run_interp(node.query), node.filename, node.line)
+    parser = Sass::SCSS::StaticParser.new(run_interp(node.query),
+      node.filename, node.options[:importer], node.line)
     node.resolved_query ||= parser.parse_media_query_list
     yield
   end
@@ -371,7 +487,8 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
   def visit_cssimport(node)
     node.resolved_uri = run_interp([node.uri])
     if node.query
-      parser = Sass::SCSS::StaticParser.new(run_interp(node.query), node.filename, node.line)
+      parser = Sass::SCSS::StaticParser.new(run_interp(node.query),
+        node.filename, node.options[:importer], node.line)
       node.resolved_query ||= parser.parse_media_query_list
     end
     yield
@@ -379,25 +496,12 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
 
   private
 
-  def stack_trace
-    trace = []
-    stack = @stack.map {|e| e.dup}.reverse
-    stack.each_cons(2) {|(e1, e2)| e1[:caller] = e2[:name]; [e1, e2]}
-    stack.each_with_index do |entry, i|
-      msg = "#{i == 0 ? "on" : "from"} line #{entry[:line]}"
-      msg << " of #{entry[:filename] || "an unknown file"}"
-      msg << ", in `#{entry[:caller]}'" if entry[:caller]
-      trace << msg
-    end
-    trace
-  end
-
   def run_interp_no_strip(text)
     text.map do |r|
       next r if r.is_a?(String)
       val = r.perform(@environment)
       # Interpolated strings should never render with quotes
-      next val.value if val.is_a?(Sass::Script::String)
+      next val.value if val.is_a?(Sass::Script::Value::String)
       val.to_s
     end.join
   end
@@ -409,8 +513,9 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
   def handle_include_loop!(node)
     msg = "An @include loop has been found:"
     content_count = 0
-    mixins = @stack.reverse.map {|s| s[:name]}.compact.select do |s|
-      if s == '@content'
+    mixins = @environment.stack.frames.select {|f| f.is_mixin?}.reverse!.map! {|f| f.name}
+    mixins = mixins.select do |name|
+      if name == '@content'
         content_count += 1
         false
       elsif content_count > 0
@@ -421,7 +526,7 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
       end
     end
 
-    return if mixins.empty?
+    return unless mixins.include?(node.name)
     raise Sass::SyntaxError.new("#{msg} #{node.name} includes itself") if mixins.size == 1
 
     msg << "\n" << Sass::Util.enum_cons(mixins.reverse + [node.name], 2).map do |m1, m2|
@@ -432,7 +537,7 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
 
   def handle_import_loop!(node)
     msg = "An @import loop has been found:"
-    files = @stack.map {|s| s[:filename]}.compact
+    files = @environment.stack.frames.select {|f| f.is_import?}.map {|f| f.filename}.compact
     if node.filename == node.imported_file.options[:filename]
       raise Sass::SyntaxError.new("#{msg} #{node.filename} imports itself")
     end

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

@@ -26,7 +26,7 @@ class Sass::Tree::Visitors::SetOptions < Sass::Tree::Visitors::Base
   end
 
   def visit_extend(node)
-    node.selector.each {|c| c.options = @options if c.is_a?(Sass::Script::Node)}
+    node.selector.each {|c| c.options = @options if c.is_a?(Sass::Script::Tree::Node)}
     yield
   end
 
@@ -73,7 +73,7 @@ class Sass::Tree::Visitors::SetOptions < Sass::Tree::Visitors::Base
   end
 
   def visit_prop(node)
-    node.name.each {|c| c.options = @options if c.is_a?(Sass::Script::Node)}
+    node.name.each {|c| c.options = @options if c.is_a?(Sass::Script::Tree::Node)}
     node.value.options = @options
     yield
   end
@@ -84,7 +84,7 @@ class Sass::Tree::Visitors::SetOptions < Sass::Tree::Visitors::Base
   end
 
   def visit_rule(node)
-    node.rule.each {|c| c.options = @options if c.is_a?(Sass::Script::Node)}
+    node.rule.each {|c| c.options = @options if c.is_a?(Sass::Script::Tree::Node)}
     yield
   end
 
@@ -104,17 +104,17 @@ class Sass::Tree::Visitors::SetOptions < Sass::Tree::Visitors::Base
   end
 
   def visit_directive(node)
-    node.value.each {|c| c.options = @options if c.is_a?(Sass::Script::Node)}
+    node.value.each {|c| c.options = @options if c.is_a?(Sass::Script::Tree::Node)}
     yield
   end
 
   def visit_media(node)
-    node.query.each {|c| c.options = @options if c.is_a?(Sass::Script::Node)}
+    node.query.each {|c| c.options = @options if c.is_a?(Sass::Script::Tree::Node)}
     yield
   end
 
   def visit_cssimport(node)
-    node.query.each {|c| c.options = @options if c.is_a?(Sass::Script::Node)} if node.query
+    node.query.each {|c| c.options = @options if c.is_a?(Sass::Script::Tree::Node)} if node.query
     yield
   end