sass 3.2.7 → 3.3.0.rc.1

data/lib/sass/scss/rx.rb

@@ -22,7 +22,7 @@ module Sass
           out << escape_char(value.slice!(0...1))
         end
         out << value.gsub(/[^a-zA-Z0-9_-]/) {|c| escape_char c}
-        return out
+        out
       end
 
       # Escapes a single character for a CSS identifier.
@@ -32,7 +32,7 @@ module Sass
       # @private
       def self.escape_char(c)
         return "\\%06x" % Sass::Util.ord(c) unless c =~ /[ -\/:-~]/
-        return "\\#{c}"
+        "\\#{c}"
       end
 
       # Creates a Regexp from a plain text string,
@@ -80,8 +80,8 @@ module Sass
 
       S = /[ \t\r\n\f]+/
 
-      COMMENT = /\/\*[^*]*\*+(?:[^\/][^*]*\*+)*\//
-      SINGLE_LINE_COMMENT = /\/\/.*(\n[ \t]*\/\/.*)*/
+      COMMENT = %r{/\*[^*]*\*+(?:[^/][^*]*\*+)*/}
+      SINGLE_LINE_COMMENT = %r{//.*(\n[ \t]*//.*)*}
 
       CDO            = quote("<!--")
       CDC            = quote("-->")
@@ -94,7 +94,6 @@ module Sass
       HASH = /##{NAME}/
 
       IMPORTANT = /!#{W}important/i
-      DEFAULT = /!#{W}default/i
 
       NUMBER = /#{NUM}(?:#{IDENT}|%)?/
 
@@ -127,7 +126,7 @@ module Sass
 
       STATIC_COMPONENT = /#{IDENT}|#{STRING_NOINTERP}|#{HEXCOLOR}|[+-]?#{NUMBER}|\!important/i
       STATIC_VALUE = /#{STATIC_COMPONENT}(\s*[\s,\/]\s*#{STATIC_COMPONENT})*([;}])/i
-      STATIC_SELECTOR = /(#{NMCHAR}|[ \t]|[,>+*]|[:#.]#{NMSTART}){0,50}([{])/i
+      STATIC_SELECTOR = /(#{NMCHAR}|[ \t]|[,>+*]|[:#.]#{NMSTART}){1,50}([{])/i
     end
   end
 end

data/lib/sass/scss/script_lexer.rb

@@ -4,6 +4,7 @@ module Sass
     # that makes them usable by {SCSS::Parser} to parse SassScript.
     # In particular, the lexer doesn't support `!` for a variable prefix.
     module ScriptLexer
+
       private
 
       def variable

data/lib/sass/scss/script_parser.rb

@@ -6,6 +6,7 @@ module Sass
     # when there's more content in the lexer once lexing is done.
     # In addition, the parser doesn't support `!` for a variable prefix.
     module ScriptParser
+
       private
 
       # @private

data/lib/sass/scss/static_parser.rb

@@ -24,11 +24,28 @@ module Sass
         seq
       end
 
+      # Parses a static at-root query.
+      #
+      # @return [(Symbol, Array<String>)] The type of the query
+      #   (`:with` or `:without`) and the values that are being filtered.
+      # @raise [Sass::SyntaxError] if there's a syntax error in the query,
+      #   or if it doesn't take up the entire input string.
+      def parse_static_at_root_query
+        init_scanner!
+        tok!(/\(/); ss
+        type = tok!(/\b(without|with)\b/).to_sym; ss
+        tok!(/:/); ss
+        directives = expr!(:at_root_directive_list); ss
+        tok!(/\)/)
+        expected("@at-root query list") unless @scanner.eos?
+        return type, directives
+      end
+
       private
 
       def moz_document_function
-        return unless val = tok(URI) || tok(URL_PREFIX) || tok(DOMAIN) ||
-          function(!:allow_var)
+        val = tok(URI) || tok(URL_PREFIX) || tok(DOMAIN) || function(!:allow_var)
+        return unless val
         ss
         [val]
       end
@@ -37,12 +54,12 @@ module Sass
       def script_value; nil; end
       def interpolation; nil; end
       def var_expr; nil; end
-      def interp_string; s = tok(STRING) and [s]; end
-      def interp_uri; s = tok(URI) and [s]; end
-      def interp_ident(ident = IDENT); s = tok(ident) and [s]; end
+      def interp_string; (s = tok(STRING)) && [s]; end
+      def interp_uri; (s = tok(URI)) && [s]; end
+      def interp_ident(ident = IDENT); (s = tok(ident)) && [s]; end
       def use_css_import?; true; end
 
-      def special_directive(name)
+      def special_directive(name, start_pos)
         return unless %w[media import charset -moz-document].include?(name)
         super
       end

data/lib/sass/selector/abstract_sequence.rb

@@ -55,7 +55,7 @@ module Sass
       # @param other [Object] The object to test equality against
       # @return [Boolean] Whether or not this is equal to `other`
       def eql?(other)
-        other.class == self.class && other.hash == self.hash && _eql?(other)
+        other.class == self.class && other.hash == hash && _eql?(other)
       end
       alias_method :==, :eql?
 
@@ -71,7 +71,7 @@ module Sass
       #
       # @return [String]
       def to_s
-        to_a.map {|e| e.is_a?(Sass::Script::Node) ? "\#{#{e.to_sass}}" : e}.join
+        to_a.map {|e| e.is_a?(Sass::Script::Tree::Node) ? "\#{#{e.to_sass}}" : e}.join
       end
 
       # Returns the specificity of the selector as an integer. The base is given

data/lib/sass/selector/comma_sequence.rb

@@ -18,23 +18,28 @@ module Sass
       # handling commas appropriately.
       #
       # @param super_cseq [CommaSequence] The parent selector
+      # @param implicit_parent [Boolean] Whether the the parent
+      #   selector should automatically be prepended to the resolved
+      #   selector if it contains no parent refs.
       # @return [CommaSequence] This selector, with parent references resolved
       # @raise [Sass::SyntaxError] If a parent selector is invalid
-      def resolve_parent_refs(super_cseq)
+      def resolve_parent_refs(super_cseq, implicit_parent = true)
         if super_cseq.nil?
           if @members.any? do |sel|
-              sel.members.any? do |sel_or_op|
-                sel_or_op.is_a?(SimpleSequence) && sel_or_op.members.any? {|ssel| ssel.is_a?(Parent)}
-              end
-            end
-            raise Sass::SyntaxError.new("Base-level rules cannot contain the parent-selector-referencing character '&'.")
+               sel.members.any? do |sel_or_op|
+                 sel_or_op.is_a?(SimpleSequence) &&
+                   sel_or_op.members.any? {|ssel| ssel.is_a?(Parent)}
+               end
+             end
+            raise Sass::SyntaxError.new(
+              "Base-level rules cannot contain the parent-selector-referencing character '&'.")
           end
           return self
         end
 
         CommaSequence.new(
           super_cseq.members.map do |super_seq|
-            @members.map {|seq| seq.resolve_parent_refs(super_seq)}
+            @members.map {|seq| seq.resolve_parent_refs(super_seq, implicit_parent)}
           end.flatten)
       end
 
@@ -53,14 +58,14 @@ module Sass
       #   with extensions made according to `extends`
       def do_extend(extends, parent_directives)
         CommaSequence.new(members.map do |seq|
-            extended = seq.do_extend(extends, parent_directives)
-            # First Law of Extend: the result of extending a selector should
-            # always contain the base selector.
-            #
-            # See https://github.com/nex3/sass/issues/324.
-            extended.unshift seq unless seq.has_placeholder? || extended.include?(seq)
-            extended
-          end.flatten)
+          extended = seq.do_extend(extends, parent_directives)
+          # First Law of Extend: the result of extending a selector should
+          # always contain the base selector.
+          #
+          # See https://github.com/nex3/sass/issues/324.
+          extended.unshift seq unless seq.has_placeholder? || extended.include?(seq)
+          extended
+        end.flatten)
       end
 
       # Returns a string representation of the sequence.
@@ -85,7 +90,7 @@ module Sass
       end
 
       def _eql?(other)
-        other.class == self.class && other.members.eql?(self.members)
+        other.class == self.class && other.members.eql?(members)
       end
     end
   end

data/lib/sass/selector/sequence.rb

@@ -33,7 +33,8 @@ module Sass
       # @return [Array<SimpleSequence, String|Array<Sass::Tree::Node, String>>]
       attr_reader :members
 
-      # @param seqs_and_ops [Array<SimpleSequence, String|Array<Sass::Tree::Node, String>>] See \{#members}
+      # @param seqs_and_ops [Array<SimpleSequence, String|Array<Sass::Tree::Node, String>>]
+      #   See \{#members}
       def initialize(seqs_and_ops)
         @members = seqs_and_ops
       end
@@ -43,14 +44,20 @@ module Sass
       # handling commas appropriately.
       #
       # @param super_seq [Sequence] The parent selector sequence
+      # @param implicit_parent [Boolean] Whether the the parent
+      #   selector should automatically be prepended to the resolved
+      #   selector if it contains no parent refs.
       # @return [Sequence] This selector, with parent references resolved
       # @raise [Sass::SyntaxError] If a parent selector is invalid
-      def resolve_parent_refs(super_seq)
+      def resolve_parent_refs(super_seq, implicit_parent)
         members = @members.dup
         nl = (members.first == "\n" && members.shift)
-        unless members.any? do |seq_or_op|
-            seq_or_op.is_a?(SimpleSequence) && seq_or_op.members.first.is_a?(Parent)
-          end
+        contains_parent_ref = members.any? do |seq_or_op|
+          seq_or_op.is_a?(SimpleSequence) && seq_or_op.members.first.is_a?(Parent)
+        end
+        return self if !implicit_parent && !contains_parent_ref
+
+        unless contains_parent_ref
           old_members, members = members, []
           members << nl if nl
           members << SimpleSequence.new([Parent.new], false)
@@ -105,7 +112,9 @@ module Sass
 
       # @see Simple#to_a
       def to_a
-        ary = @members.map {|seq_or_op| seq_or_op.is_a?(SimpleSequence) ? seq_or_op.to_a : seq_or_op}
+        ary = @members.map do |seq_or_op|
+          seq_or_op.is_a?(SimpleSequence) ? seq_or_op.to_a : seq_or_op
+        end
         Sass::Util.intersperse(ary, " ").flatten.compact
       end
 
@@ -133,7 +142,8 @@ module Sass
       # this conceptually expands into `.D .C, .D (.A .B)`,
       # and this function translates `.D (.A .B)` into `.D .A .B, .A.D .B, .D .A .B`.
       #
-      # @param path [Array<Array<SimpleSequence or String>>] A list of parenthesized selector groups.
+      # @param path [Array<Array<SimpleSequence or String>>]
+      #   A list of parenthesized selector groups.
       # @return [Array<Array<SimpleSequence or String>>] A list of fully-expanded selectors.
       def weave(path)
         # This function works by moving through the selector path left-to-right,
@@ -145,12 +155,14 @@ module Sass
         until afters.empty?
           current = afters.shift.dup
           last_current = [current.pop]
-          befores = Sass::Util.flatten(befores.map do |before|
-              next [] unless sub = subweave(before, current)
-              sub.map {|seqs| seqs + last_current}
-            end, 1)
+          befores.map! do |before|
+            sub = subweave(before, current)
+            next [] unless sub
+            sub.map {|seqs| seqs + last_current}
+          end
+          befores = Sass::Util.flatten(befores, 1)
         end
-        return befores
+        befores
       end
 
       # This interweaves two lists of selectors,
@@ -176,8 +188,10 @@ module Sass
         return [seq1] if seq2.empty?
 
         seq1, seq2 = seq1.dup, seq2.dup
-        return unless init = merge_initial_ops(seq1, seq2)
-        return unless fin = merge_final_ops(seq1, seq2)
+        init = merge_initial_ops(seq1, seq2)
+        return unless init
+        fin = merge_final_ops(seq1, seq2)
+        return unless fin
         seq1 = group_selectors(seq1)
         seq2 = group_selectors(seq2)
         lcs = Sass::Util.lcs(seq2, seq1) do |s1, s2|
@@ -222,7 +236,7 @@ module Sass
         # merged successfully
         lcs = Sass::Util.lcs(ops1, ops2)
         return unless lcs == ops1 || lcs == ops2
-        return (newline ? ["\n"] : []) + (ops1.size > ops2.size ? ops1 : ops2)
+        (newline ? ["\n"] : []) + (ops1.size > ops2.size ? ops1 : ops2)
       end
 
       # Extracts final selector combinators (`"+"`, `">"`, `"~"`) and the
@@ -238,6 +252,8 @@ module Sass
       #   be nil. Otherwise, this will contained the merged selector. Array
       #   elements are [Sass::Util#paths]-style options; conceptually, an "or"
       #   of multiple selectors.
+      # @comment
+      #   rubocop:disable MethodLength
       def merge_final_ops(seq1, seq2, res = [])
         ops1, ops2 = [], []
         ops1 << seq1.pop while seq1.last.is_a?(String)
@@ -255,7 +271,7 @@ module Sass
           # is a supersequence of the other, use that, otherwise give up.
           lcs = Sass::Util.lcs(ops1, ops2)
           return unless lcs == ops1 || lcs == ops2
-          res.unshift *(ops1.size > ops2.size ? ops1 : ops2).reverse
+          res.unshift(*(ops1.size > ops2.size ? ops1 : ops2).reverse)
           return res
         end
 
@@ -301,7 +317,8 @@ module Sass
             res.unshift sel1, op1
             seq2.push sel2, op2
           elsif op1 == op2
-            return unless merged = sel1.unify(sel2.members, sel2.subject?)
+            merged = sel1.unify(sel2.members, sel2.subject?)
+            return unless merged
             res.unshift merged, op1
           else
             # Unknown selector combinators can't be unified
@@ -318,6 +335,8 @@ module Sass
           return merge_final_ops(seq1, seq2, res)
         end
       end
+      # @comment
+      #   rubocop:enable MethodLength
 
       # Takes initial subsequences of `seq1` and `seq2` and returns all
       # orderings of those subsequences. The initial subsequences are determined
@@ -369,7 +388,7 @@ module Sass
           end while !tail.empty? && head.last.is_a?(String) || tail.first.is_a?(String)
           newseq << head
         end
-        return newseq
+        newseq
       end
 
       # Given two selector sequences, returns whether `seq1` is a
@@ -398,15 +417,15 @@ module Sass
         return unless si
 
         if seq1[1].is_a?(String)
-          return unless seq2[si+1].is_a?(String)
+          return unless seq2[si + 1].is_a?(String)
           # .foo ~ .bar is a superselector of .foo + .bar
-          return unless seq1[1] == "~" ? seq2[si+1] != ">" : seq1[1] == seq2[si+1]
-          return _superselector?(seq1[2..-1], seq2[si+2..-1])
-        elsif seq2[si+1].is_a?(String)
-          return unless seq2[si+1] == ">"
-          return _superselector?(seq1[1..-1], seq2[si+2..-1])
+          return unless seq1[1] == "~" ? seq2[si + 1] != ">" : seq1[1] == seq2[si + 1]
+          return _superselector?(seq1[2..-1], seq2[si + 2..-1])
+        elsif seq2[si + 1].is_a?(String)
+          return unless seq2[si + 1] == ">"
+          return _superselector?(seq1[1..-1], seq2[si + 2..-1])
         else
-          return _superselector?(seq1[1..-1], seq2[si+1..-1])
+          return _superselector?(seq1[1..-1], seq2[si + 1..-1])
         end
       end
 
@@ -421,7 +440,8 @@ module Sass
       # @param seq2 [Array<SimpleSequence or String>]
       # @return [Boolean]
       def parent_superselector?(seq1, seq2)
-        base = Sass::Selector::SimpleSequence.new([Sass::Selector::Placeholder.new('<temp>')], false)
+        base = Sass::Selector::SimpleSequence.new([Sass::Selector::Placeholder.new('<temp>')],
+                                                  false)
         _superselector?(seq1 + [base], seq2 + [base])
       end
 
@@ -437,26 +457,32 @@ module Sass
       # @param seqses [Array<Array<Array<SimpleSequence or String>>>]
       # @return [Array<Array<Array<SimpleSequence or String>>>]
       def trim(seqses)
-        # Avoid truly horrific quadratic behavior. TOOD: I think there
+        # Avoid truly horrific quadratic behavior. TODO: I think there
         # may be a way to get perfect trimming without going quadratic.
         return seqses if seqses.size > 100
+
+        # Keep the results in a separate array so we can be sure we aren't
+        # comparing against an already-trimmed selector. This ensures that two
+        # identical selectors don't mutually trim one another.
+        result = seqses.dup
+
         # This is n^2 on the sequences, but only comparing between
         # separate sequences should limit the quadratic behavior.
-        seqses.map do |seqs1|
-          seqs1.reject do |seq1|
-            min_spec = 0
-            _sources(seq1).map {|seq| min_spec += seq.specificity}
-            seqses.any? do |seqs2|
+        seqses.each_with_index do |seqs1, i|
+          result[i] = seqs1.reject do |seq1|
+            max_spec = _sources(seq1).map {|seq| seq.specificity}.max || 0
+            result.any? do |seqs2|
               next if seqs1.equal?(seqs2)
               # Second Law of Extend: the specificity of a generated selector
               # should never be less than the specificity of the extending
               # selector.
               #
               # See https://github.com/nex3/sass/issues/324.
-              seqs2.any? {|seq2| _specificity(seq2) >= min_spec && _superselector?(seq2, seq1)}
+              seqs2.any? {|seq2| _specificity(seq2) >= max_spec && _superselector?(seq2, seq1)}
             end
           end
         end
+        result
       end
 
       def _hash
@@ -464,7 +490,7 @@ module Sass
       end
 
       def _eql?(other)
-        other.members.reject {|m| m == "\n"}.eql?(self.members.reject {|m| m == "\n"})
+        other.members.reject {|m| m == "\n"}.eql?(members.reject {|m| m == "\n"})
       end
 
       private

data/lib/sass/selector/simple.rb

@@ -14,13 +14,12 @@ module Sass
       # @return [String, nil]
       attr_accessor :filename
 
-      # Returns a representation of the node
-      # as an array of strings and potentially {Sass::Script::Node}s
-      # (if there's interpolation in the selector).
-      # When the interpolation is resolved and the strings are joined together,
-      # this will be the string representation of this node.
+      # Returns a representation of the node as an array of strings and
+      # potentially {Sass::Script::Tree::Node}s (if there's interpolation in the
+      # selector). When the interpolation is resolved and the strings are joined
+      # together, this will be the string representation of this node.
       #
-      # @return [Array<String, Sass::Script::Node>]
+      # @return [Array<String, Sass::Script::Tree::Node>]
       def to_a
         Sass::Util.abstract(self)
       end
@@ -30,7 +29,7 @@ module Sass
       #
       # @return [String]
       def inspect
-        to_a.map {|e| e.is_a?(Sass::Script::Node) ? "\#{#{e.to_sass}}" : e}.join
+        to_a.map {|e| e.is_a?(Sass::Script::Tree::Node) ? "\#{#{e.to_sass}}" : e}.join
       end
 
       # @see \{#inspect}
@@ -59,7 +58,7 @@ module Sass
       # @param other [Object] The object to test equality against
       # @return [Boolean] Whether or not this is equal to `other`
       def eql?(other)
-        other.class == self.class && other.hash == self.hash && other.to_a.eql?(to_a)
+        other.class == self.class && other.hash == hash && other.to_a.eql?(to_a)
       end
       alias_method :==, :eql?
 
@@ -84,13 +83,13 @@ module Sass
         return sels if sels.any? {|sel2| eql?(sel2)}
         sels_with_ix = Sass::Util.enum_with_index(sels)
         _, i =
-          if self.is_a?(Pseudo) || self.is_a?(SelectorPseudoClass)
-            sels_with_ix.find {|sel, _| sel.is_a?(Pseudo) && (sels.last.final? || sels.last.type == :element)}
+          if is_a?(Pseudo) || is_a?(SelectorPseudoClass)
+            sels_with_ix.find {|sel, _| sel.is_a?(Pseudo) && (sels.last.type == :element)}
           else
             sels_with_ix.find {|sel, _| sel.is_a?(Pseudo) || sel.is_a?(SelectorPseudoClass)}
           end
         return sels + [self] unless i
-        return sels[0...i] + [self] + sels[i..-1]
+        sels[0...i] + [self] + sels[i..-1]
       end
 
       protected
@@ -112,7 +111,7 @@ module Sass
         return nil, false unless ns1 == ns2 || ns1.nil? || ns1 == ['*'] || ns2.nil? || ns2 == ['*']
         return ns2, true if ns1 == ['*']
         return ns1, true if ns2 == ['*']
-        return ns1 || ns2, true
+        [ns1 || ns2, true]
       end
     end
   end

data/lib/sass/selector/simple_sequence.rb

@@ -21,11 +21,16 @@ module Sass
       # and the generated selector `c.foo.bar.baz` has `{b.bar, c.baz}` as its
       # `sources` set.
       #
-      # This is populated during the {#do_extend} process.
+      # This is populated during the {Sequence#do_extend} process.
       #
       # @return {Set<Sequence>}
       attr_accessor :sources
 
+      # This sequence source range.
+      #
+      # @return [Sass::Source::Range]
+      attr_accessor :source_range
+
       # @see \{#subject?}
       attr_writer :subject
 
@@ -37,11 +42,16 @@ module Sass
         @base ||= (members.first if members.first.is_a?(Element) || members.first.is_a?(Universal))
       end
 
-      # Returns the non-base selectors in this sequence.
+      def pseudo_elements
+        @pseudo_elements ||= (members - [base]).
+          select {|sel| sel.is_a?(Pseudo) && sel.type == :element}
+      end
+
+      # Returns the non-base, non-pseudo-class selectors in this sequence.
       #
       # @return [Set<Simple>]
       def rest
-        @rest ||= Set.new(base ? members[1..-1] : members)
+        @rest ||= Set.new(members - [base] - pseudo_elements)
       end
 
       # Whether or not this compound selector is the subject of the parent
@@ -55,11 +65,12 @@ module Sass
 
       # @param selectors [Array<Simple>] See \{#members}
       # @param subject [Boolean] See \{#subject?}
-      # @param sources [Set<Sequence>]
-      def initialize(selectors, subject, sources = Set.new)
+      # @param source_range [Sass::Source::Range]
+      def initialize(selectors, subject, source_range = nil)
         @members = selectors
         @subject = subject
-        @sources = sources
+        @sources = Set.new
+        @source_range = source_range
       end
 
       # Resolves the {Parent} selectors within this selector
@@ -96,30 +107,37 @@ module Sass
       #   by extending this selector with `extends`.
       # @see CommaSequence#do_extend
       def do_extend(extends, parent_directives, seen = Set.new)
-        Sass::Util.group_by_to_a(extends.get(members.to_set)) {|ex, _| ex.extender}.map do |seq, group|
+        groups = Sass::Util.group_by_to_a(extends.get(members.to_set)) {|ex, _| ex.extender}
+        groups.map! do |seq, group|
           sels = group.map {|_, s| s}.flatten
           # If A {@extend B} and C {...},
           # seq is A, sels is B, and self is C
 
-          self_without_sel = Sass::Util.array_minus(self.members, sels)
+          self_without_sel = Sass::Util.array_minus(members, sels)
           group.each {|e, _| e.result = :failed_to_unify unless e.result == :succeeded}
-          next unless unified = seq.members.last.unify(self_without_sel, subject?)
+          unified = seq.members.last.unify(self_without_sel, subject?)
+          next unless unified
           group.each {|e, _| e.result = :succeeded}
-          next if group.map {|e, _| check_directives_match!(e, parent_directives)}.none?
+          group.each {|e, _| check_directives_match!(e, parent_directives)}
           new_seq = Sequence.new(seq.members[0...-1] + [unified])
           new_seq.add_sources!(sources + [seq])
           [sels, new_seq]
-        end.compact.map do |sels, seq|
+        end
+        groups.compact!
+        groups.map! do |sels, seq|
           seen.include?(sels) ? [] : seq.do_extend(extends, parent_directives, seen + [sels])
-        end.flatten.uniq
+        end
+        groups.flatten!
+        groups.uniq!
+        groups
       end
 
-      # Unifies this selector with another {SimpleSequence}'s {SimpleSequence#members members array},
-      # returning another `SimpleSequence`
+      # Unifies this selector with another {SimpleSequence}'s
+      # {SimpleSequence#members members array}, returning another `SimpleSequence`
       # that matches both this selector and the input selector.
       #
       # @param sels [Array<Simple>] A {SimpleSequence}'s {SimpleSequence#members members array}
-      # @param subject [Boolean] Whether the {SimpleSequence} being merged is a subject.
+      # @param other_subject [Boolean] Whether the other {SimpleSequence} being merged is a subject.
       # @return [SimpleSequence, nil] A {SimpleSequence} matching both `sels` and this selector,
       #   or `nil` if this is impossible (e.g. unifying `#foo` and `#bar`)
       # @raise [Sass::SyntaxError] If this selector cannot be unified.
@@ -129,10 +147,11 @@ module Sass
       #   by the time extension and unification happen,
       #   this exception will only ever be raised as a result of programmer error
       def unify(sels, other_subject)
-        return unless sseq = members.inject(sels) do |sseq, sel|
-          return unless sseq
-          sel.unify(sseq)
+        sseq = members.inject(sels) do |member, sel|
+          return unless member
+          sel.unify(member)
         end
+        return unless sseq
         SimpleSequence.new(sseq, other_subject || subject?)
       end
 
@@ -145,7 +164,9 @@ module Sass
       # @param sseq [SimpleSequence]
       # @return [Boolean]
       def superselector?(sseq)
-        (base.nil? || base.eql?(sseq.base)) && rest.subset?(sseq.rest)
+        (base.nil? || base.eql?(sseq.base)) &&
+          pseudo_elements.eql?(sseq.pseudo_elements) &&
+          rest.subset?(sseq.rest)
       end
 
       # @see Simple#to_a
@@ -164,14 +185,14 @@ module Sass
       end
 
       # Return a copy of this simple sequence with `sources` merged into the
-      # {#sources} set.
+      # {SimpleSequence#sources} set.
       #
       # @param sources [Set<Sequence>]
       # @return [SimpleSequence]
       def with_more_sources(sources)
         sseq = dup
         sseq.members = members.dup
-        sseq.sources.merge sources
+        sseq.sources = self.sources | sources
         sseq
       end
 
@@ -180,16 +201,17 @@ module Sass
       def check_directives_match!(extend, parent_directives)
         dirs1 = extend.directives.map {|d| d.resolved_value}
         dirs2 = parent_directives.map {|d| d.resolved_value}
-        return true if Sass::Util.subsequence?(dirs1, dirs2)
-
-        Sass::Util.sass_warn <<WARNING
-DEPRECATION WARNING on line #{extend.node.line}#{" of #{extend.node.filename}" if extend.node.filename}:
-  @extending an outer selector from within #{extend.directives.last.name} is deprecated.
-  You may only @extend selectors within the same directive.
-  This will be an error in Sass 3.3.
-  It can only work once @extend is supported natively in the browser.
-WARNING
-        return false
+        return if Sass::Util.subsequence?(dirs1, dirs2)
+        line = extend.node.line
+        filename = extend.node.filename
+
+        # TODO(nweiz): this should use the Sass stack trace of the extend node,
+        # not the selector.
+        raise Sass::SyntaxError.new(<<MESSAGE)
+You may not @extend an outer selector from within #{extend.directives.last.name}.
+You may only @extend selectors within the same directive.
+From "@extend #{extend.target.join(', ')}" on line #{line}#{" of #{filename}" if filename}.
+MESSAGE
       end
 
       def _hash
@@ -197,8 +219,8 @@ WARNING
       end
 
       def _eql?(other)
-        other.base.eql?(self.base) && Sass::Util.set_eql?(other.rest, self.rest) &&
-          other.subject? == self.subject?
+        other.base.eql?(base) && other.pseudo_elements == pseudo_elements &&
+          Sass::Util.set_eql?(other.rest, rest) && other.subject? == subject?
       end
     end
   end