sass 3.3.0.alpha.16 → 3.3.0.alpha.50

data/lib/sass/script/lexer.rb

@@ -17,10 +17,10 @@ module Sass
       # : The Ruby object corresponding to the value of the token.
       #
       # `line`: \[`Fixnum`\]
-      # : The line of the source file on which the token appears.
+      # : The line of the source file on which the token appears (1-based).
       #
       # `offset`: \[`Fixnum`\]
-      # : The number of bytes into the line the SassScript token appeared.
+      # : The number of characters into the line the SassScript token appeared (1-based).
       #
       # `pos`: \[`Fixnum`\]
       # : The scanner position at which the SassScript token appeared.
@@ -32,7 +32,7 @@ module Sass
       attr_reader :line
 
       # The number of bytes into the current line
-      # of the lexer's current position.
+      # of the lexer's current position (1-based).
       #
       # @return [Fixnum]
       attr_reader :offset
@@ -125,10 +125,10 @@ module Sass
       }
 
       # @param str [String, StringScanner] The source text to lex
-      # @param line [Fixnum] The line on which the SassScript appears.
-      #   Used for error reporting
-      # @param offset [Fixnum] The number of characters in on which the SassScript appears.
-      #   Used for error reporting
+      # @param line [Fixnum] The 1-based line on which the SassScript appears.
+      #   Used for error reporting and sourcemap building
+      # @param offset [Fixnum] The 1-based character (not byte) offset in the line on which the SassScript appears.
+      #   Used for error reporting and sourcemap building
       # @param options [{Symbol => Object}] An options hash;
       #   see {file:SASS_REFERENCE.md#sass_options the Sass options documentation}
       def initialize(str, line, offset, options)
@@ -172,7 +172,11 @@ module Sass
       # Rewinds the underlying StringScanner
       # to before the token returned by \{#peek}.
       def unpeek!
-        @scanner.pos = @tok.pos if @tok
+        if @tok
+          @scanner.pos = @tok.pos
+          @line = @tok.line
+          @offset = @tok.offset
+        end
       end
 
       # @return [Boolean] Whether or not there's more source text to lex.
@@ -220,8 +224,7 @@ module Sass
         size ||= @scanner.matched_size
 
         val.line = @line if val.is_a?(Script::Node)
-        Token.new(type, val, @line,
-          current_position - size, @scanner.pos - size)
+        Token.new(type, val, @line, @offset - size, @scanner.pos - size)
       end
 
       def whitespace
@@ -258,9 +261,11 @@ module Sass
       end
 
       def string(re, open)
+        start_pos = source_position
         return unless scan(STRING_REGULAR_EXPRESSIONS[[re, open]])
         if @scanner[2] == '#{' #'
           @scanner.pos -= 2 # Don't actually consume the #{
+          @offset -= 2
           @interpolation_stack << re
         end
         str =
@@ -269,34 +274,47 @@ module Sass
           else
             Script::String.new(@scanner[1].gsub(/\\(['"]|\#\{)/, '\1'), :string)
           end
+        str.source_range = range(start_pos)
         [:string, str]
       end
 
       def number
+        start_pos = source_position
         return unless scan(REGULAR_EXPRESSIONS[:number])
         value = @scanner[2] ? @scanner[2].to_f : @scanner[3].to_i
         value = -value if @scanner[1]
-        [:number, Script::Number.new(value, Array(@scanner[4]))]
+        script_number = Script::Number.new(value, Array(@scanner[4]))
+        script_number.source_range = range(start_pos)
+        [:number, script_number]
       end
 
       def color
+        start_pos = source_position
         return unless s = scan(REGULAR_EXPRESSIONS[:color])
         raise Sass::SyntaxError.new(<<MESSAGE.rstrip) unless s.size == 4 || s.size == 7
 Colors must have either three or six digits: '#{s}'
 MESSAGE
         value = s.scan(/^#(..?)(..?)(..?)$/).first.
           map {|num| num.ljust(2, num).to_i(16)}
-        [:color, Script::Color.new(value)]
+        script_color = Script::Color.new(value)
+        script_color.source_range = range(start_pos)
+        [:color, script_color]
       end
 
       def bool
+        start_pos = source_position
         return unless s = scan(REGULAR_EXPRESSIONS[:bool])
-        [:bool, Script::Bool.new(s == 'true')]
+        script_bool = Script::Bool.new(s == 'true')
+        script_bool.source_range = range(start_pos)
+        [:bool, script_bool]
       end
 
       def null
+        start_pos = source_position
         return unless scan(REGULAR_EXPRESSIONS[:null])
-        [:null, Script::Null.new]
+        script_null = Script::Null.new
+        script_null.source_range = range(start_pos)
+        [:null, script_null]
       end
 
       def special_fun
@@ -306,7 +324,7 @@ MESSAGE
         old_line = @line
         old_offset = @offset
         @line += c
-        @offset = (c == 0 ? @offset + str2.size : str2[/\n(.*)/, 1].size)
+        @offset = c == 0 ? @offset + str2.size : str2[/\n([^\n]*)/, 1].size + 1
         [:special_fun,
           Sass::Util.merge_adjacent_strings(
             [str1] + Sass::Engine.parse_interp(str2, old_line, old_offset, @options)),
@@ -338,12 +356,16 @@ MESSAGE
         return unless str = @scanner.scan(re)
         c = str.count("\n")
         @line += c
-        @offset = (c == 0 ? @offset + str.size : str[/\n(.*)/, 1].size)
+        @offset = (c == 0 ? @offset + str.size : str[/\n([^\n]*)/, 1].size + 1)
         str
       end
 
-      def current_position
-        @offset + 1
+      def range(start_pos, end_pos = source_position)
+        Sass::Source::Range.new(start_pos, end_pos, @options[:filename])
+      end
+
+      def source_position
+        Sass::Source::Position.new(@line, @offset)
       end
     end
   end

data/lib/sass/script/node.rb

@@ -13,6 +13,16 @@ module Sass::Script
     # @return [Fixnum]
     attr_accessor :line
 
+    # The source range in the document on which this node appeared.
+    #
+    # @return [Sass::Source::Range]
+    attr_accessor :source_range
+
+    # The file name of the document on which this node appeared.
+    #
+    # @return [String]
+    attr_accessor :filename
+
     # Sets the options hash for this node,
     # as well as for all child nodes.
     # See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.

data/lib/sass/script/parser.rb

@@ -12,11 +12,18 @@ module Sass
         @lexer.line
       end
 
+      # The column number of the parser's current position.
+      #
+      # @return [Fixnum]
+      def offset
+        @lexer.offset
+      end
+
       # @param str [String, StringScanner] The source text to parse
       # @param line [Fixnum] The line on which the SassScript appears.
-      #   Used for error reporting
-      # @param offset [Fixnum] The number of characters in on which the SassScript appears.
-      #   Used for error reporting
+      #   Used for error reporting and sourcemap building
+      # @param offset [Fixnum] The character (not byte) offset in the line on which the SassScript appears.
+      #   Used for error reporting and sourcemap building
       # @param options [{Symbol => Object}] An options hash;
       #   see {file:SASS_REFERENCE.md#sass_options the Sass options documentation}
       def initialize(str, line, offset, options = {})
@@ -32,9 +39,11 @@ module Sass
       # @return [Script::Node] The root node of the parse tree
       # @raise [Sass::SyntaxError] if the expression isn't valid SassScript
       def parse_interpolated
+        start_pos = source_position
         expr = assert_expr :expr
         assert_tok :end_interpolation
         expr.options = @options
+        expr.source_range = range(start_pos)
         expr
       rescue Sass::SyntaxError => e
         e.modify_backtrace :line => @lexer.line, :filename => @options[:filename]
@@ -46,9 +55,11 @@ module Sass
       # @return [Script::Node] The root node of the parse tree
       # @raise [Sass::SyntaxError] if the expression isn't valid SassScript
       def parse
+        start_pos = source_position
         expr = assert_expr :expr
         assert_done
         expr.options = @options
+        expr.source_range = range(start_pos)
         expr
       rescue Sass::SyntaxError => e
         e.modify_backtrace :line => @lexer.line, :filename => @options[:filename]
@@ -213,9 +224,10 @@ module Sass
                   return other_interp
                 end
 
-                line = @lexer.line
+                start_pos = source_position
                 e = Operation.new(e, assert_expr(#{sub.inspect}), tok.type)
-                e.line = line
+                e.line = start_pos.line
+                e.source_range = range(start_pos)
               end
               e
             end
@@ -238,12 +250,24 @@ RUBY
 
       private
 
+      def source_position
+        Sass::Source::Position.new(line, offset)
+      end
+
+      def token_start_position(token)
+        Sass::Source::Position.new(token.line, token.offset)
+      end
+
+      def range(start_pos, end_pos=source_position)
+        Sass::Source::Range.new(start_pos, end_pos, @options[:filename])
+      end
+
       # @private
       def lexer_class; Lexer; end
 
       def expr
         interp = try_ops_after_interp([:comma], :expr) and return interp
-        line = @lexer.line
+        start_pos = source_position
         return unless e = interpolation
         arr = [e]
         while tok = try_tok(:comma)
@@ -253,7 +277,7 @@ RUBY
           end
           arr << assert_expr(:interpolation)
         end
-        arr.size == 1 ? arr.first : node(List.new(arr, :comma), line)
+        arr.size == 1 ? arr.first : node(List.new(arr, :comma), start_pos)
       end
 
       production :equals, :interpolation, :single_eq
@@ -276,8 +300,10 @@ RUBY
         wa = @lexer.whitespace?
         str = Script::String.new(Lexer::OPERATORS_REVERSE[op.type])
         str.line = @lexer.line
+        start_pos = source_position
         interp = Script::Interpolation.new(prev, str, assert_expr(name), !:wb, wa, :originally_text)
         interp.line = @lexer.line
+        interp.source_range = range(start_pos)
         return interp
       end
 
@@ -295,13 +321,13 @@ RUBY
       end
 
       def space
-        line = @lexer.line
+        start_pos = source_position
         return unless e = or_expr
         arr = [e]
         while e = or_expr
           arr << e
         end
-        arr.size == 1 ? arr.first : node(List.new(arr, :space), line)
+        arr.size == 1 ? arr.first : node(List.new(arr, :space), start_pos)
       end
 
       production :or_expr, :and_expr, :or
@@ -322,16 +348,16 @@ RUBY
 
         name = @lexer.next
         if color = Color::COLOR_NAMES[name.value.downcase]
-          return node(Color.new(color))
+          return node(Color.new(color), token_start_position(name), source_position)
         end
-        node(Script::String.new(name.value, :identifier))
+        node(Script::String.new(name.value, :identifier), token_start_position(name), source_position)
       end
 
       def funcall
         return raw unless tok = try_tok(:funcall)
         args, keywords, splat = fn_arglist || [[], {}]
         assert_tok(:rparen)
-        node(Script::Funcall.new(tok.value, args, keywords, splat))
+        node(Script::Funcall.new(tok.value, args, keywords, splat), token_start_position(tok), source_position)
       end
 
       def defn_arglist!(must_have_parens)
@@ -347,9 +373,10 @@ RUBY
         must_have_default = false
         loop do
           line = @lexer.line
-          offset = @lexer.offset + 1
+          offset = @lexer.offset
           c = assert_tok(:const)
           var = Script::Variable.new(c.value)
+          var.source_range = range(c.offset)
           if try_tok(:colon)
             val = assert_expr(:space)
             must_have_default = true
@@ -421,27 +448,30 @@ RUBY
         return variable unless try_tok(:lparen)
         was_in_parens = @in_parens
         @in_parens = true
-        line = @lexer.line
+        start_pos = source_position
         e = expr
         assert_tok(:rparen)
-        return e || node(List.new([], :space), line)
+        return e || node(List.new([], :space), start_pos)
       ensure
         @in_parens = was_in_parens
       end
 
       def variable
+        start_pos = source_position
         return string unless c = try_tok(:const)
-        node(Variable.new(*c.value))
+        node(Variable.new(*c.value), start_pos, source_position)
       end
 
       def string
         return number unless first = try_tok(:string)
         return first.value unless try_tok(:begin_interpolation)
+        start_pos = source_position
         line = @lexer.line
         mid = parse_interpolated
         last = assert_expr(:string)
         interp = StringInterpolation.new(first.value, mid, last)
         interp.line = line
+        interp.source_range = range(start_pos)
         interp
       end
 
@@ -486,8 +516,10 @@ RUBY
         @lexer.expected!(EXPR_NAMES[:default])
       end
 
-      def node(node, line = @lexer.line)
-        node.line = line
+      def node(node, start_pos = source_position, end_pos = nil)
+        node.line = start_pos.line
+        node.filename = @options[:filename]
+        node.source_range = range(start_pos, end_pos) if end_pos
         node
       end
     end

data/lib/sass/scss/parser.rb

@@ -5,16 +5,24 @@ module Sass
     # The parser for SCSS.
     # It parses a string of code into a tree of {Sass::Tree::Node}s.
     class Parser
+
+      # Expose for the SASS parser.
+      attr_accessor :offset
+
       # @param str [String, StringScanner] The source document to parse.
       #   Note that `Parser` *won't* raise a nice error message if this isn't properly parsed;
       #   for that, you should use the higher-level {Sass::Engine} or {Sass::CSS}.
       # @param filename [String] The name of the file being parsed. Used for warnings.
-      # @param line [Fixnum] The line on which the source string appeared,
+      # @param line [Fixnum] The 1-based line on which the source string appeared,
       #   if it's part of another document.
-      def initialize(str, filename, line = 1)
+      # @param offset [Fixnum] The 1-based character (not byte) offset in the line on
+      #   which the source string starts. Used for error reporting and sourcemap
+      #   building.
+      def initialize(str, filename, line = 1, offset = 1)
         @template = str
         @filename = filename
         @line = line
+        @offset = offset
         @strs = []
       end
 
@@ -56,6 +64,14 @@ module Sass
 
       include Sass::SCSS::RX
 
+      def source_position
+        Sass::Source::Position.new(@line, @offset)
+      end
+
+      def range(start_pos, end_pos=source_position)
+        Sass::Source::Range.new(start_pos, end_pos, @filename)
+      end
+
       def init_scanner!
         @scanner =
           if @template.is_a?(StringScanner)
@@ -66,7 +82,7 @@ module Sass
       end
 
       def stylesheet
-        node = node(Sass::Tree::RootNode.new(@scanner.string))
+        node = node(Sass::Tree::RootNode.new(@scanner.string), source_position)
         block_contents(node, :stylesheet) {s(node)}
       end
 
@@ -128,13 +144,14 @@ module Sass
       PREFIXED_DIRECTIVES = Set[:supports]
 
       def directive
+        start_pos = source_position
         return unless tok(/@/)
         name = tok!(IDENT)
         ss
 
-        if dir = special_directive(name)
+        if dir = special_directive(name, start_pos)
           return dir
-        elsif dir = prefixed_directive(name)
+        elsif dir = prefixed_directive(name, start_pos)
           return dir
         end
 
@@ -143,11 +160,11 @@ module Sass
         # Some take no arguments at all.
         val = expr || selector
         val = val ? ["@#{name} "] + Sass::Util.strip_string_array(val) : ["@#{name}"]
-        directive_body(val)
+        directive_body(val, start_pos)
       end
 
-      def directive_body(value)
-        node = node(Sass::Tree::DirectiveNode.new(value))
+      def directive_body(value, start_pos)
+        node = Sass::Tree::DirectiveNode.new(value)
 
         if tok(/\{/)
           node.has_children = true
@@ -155,31 +172,31 @@ module Sass
           tok!(/\}/)
         end
 
-        node
+        node(node, start_pos)
       end
 
-      def special_directive(name)
+      def special_directive(name, start_pos)
         sym = name.gsub('-', '_').to_sym
-        DIRECTIVES.include?(sym) && send("#{sym}_directive")
+        DIRECTIVES.include?(sym) && send("#{sym}_directive", start_pos)
       end
 
-      def prefixed_directive(name)
+      def prefixed_directive(name, start_pos)
         sym = name.gsub(/^-[a-z0-9]+-/i, '').gsub('-', '_').to_sym
-        PREFIXED_DIRECTIVES.include?(sym) && send("#{sym}_directive", name)
+        PREFIXED_DIRECTIVES.include?(sym) && send("#{sym}_directive", name, start_pos)
       end
 
-      def mixin_directive
+      def mixin_directive(start_pos)
         name = tok! IDENT
         args, splat = sass_script(:parse_mixin_definition_arglist)
         ss
-        block(node(Sass::Tree::MixinDefNode.new(name, args, splat)), :directive)
+        block(node(Sass::Tree::MixinDefNode.new(name, args, splat), start_pos), :directive)
       end
 
-      def include_directive
+      def include_directive(start_pos)
         name = tok! IDENT
         args, keywords, splat = sass_script(:parse_mixin_include_arglist)
         ss
-        include_node = node(Sass::Tree::MixinNode.new(name, args, keywords, splat))
+        include_node = node(Sass::Tree::MixinNode.new(name, args, keywords, splat), start_pos)
         if tok?(/\{/)
           include_node.has_children = true
           block(include_node, :directive)
@@ -188,31 +205,31 @@ module Sass
         end
       end
 
-      def content_directive
+      def content_directive(start_pos)
         ss
-        node(Sass::Tree::ContentNode.new)
+        node(Sass::Tree::ContentNode.new, start_pos)
       end
 
-      def function_directive
+      def function_directive(start_pos)
         name = tok! IDENT
         args, splat = sass_script(:parse_function_definition_arglist)
         ss
-        block(node(Sass::Tree::FunctionNode.new(name, args, splat)), :function)
+        block(node(Sass::Tree::FunctionNode.new(name, args, splat), start_pos), :function)
       end
 
-      def return_directive
-        node(Sass::Tree::ReturnNode.new(sass_script(:parse)))
+      def return_directive(start_pos)
+        node(Sass::Tree::ReturnNode.new(sass_script(:parse)), start_pos)
       end
 
-      def debug_directive
-        node(Sass::Tree::DebugNode.new(sass_script(:parse)))
+      def debug_directive(start_pos)
+        node(Sass::Tree::DebugNode.new(sass_script(:parse)), start_pos)
       end
 
-      def warn_directive
-        node(Sass::Tree::WarnNode.new(sass_script(:parse)))
+      def warn_directive(start_pos)
+        node(Sass::Tree::WarnNode.new(sass_script(:parse)), start_pos)
       end
 
-      def for_directive
+      def for_directive(start_pos)
         tok!(/\$/)
         var = tok! IDENT
         ss
@@ -226,10 +243,10 @@ module Sass
         to = sass_script(:parse)
         ss
 
-        block(node(Sass::Tree::ForNode.new(var, from, to, exclusive)), :directive)
+        block(node(Sass::Tree::ForNode.new(var, from, to, exclusive), start_pos), :directive)
       end
 
-      def each_directive
+      def each_directive(start_pos)
         tok!(/\$/)
         var = tok! IDENT
         ss
@@ -238,19 +255,19 @@ module Sass
         list = sass_script(:parse)
         ss
 
-        block(node(Sass::Tree::EachNode.new(var, list)), :directive)
+        block(node(Sass::Tree::EachNode.new(var, list), start_pos), :directive)
       end
 
-      def while_directive
+      def while_directive(start_pos)
         expr = sass_script(:parse)
         ss
-        block(node(Sass::Tree::WhileNode.new(expr)), :directive)
+        block(node(Sass::Tree::WhileNode.new(expr), start_pos), :directive)
       end
 
-      def if_directive
+      def if_directive(start_pos)
         expr = sass_script(:parse)
         ss
-        node = block(node(Sass::Tree::IfNode.new(expr)), :directive)
+        node = block(node(Sass::Tree::IfNode.new(expr), start_pos), :directive)
         pos = @scanner.pos
         line = @line
         ss
@@ -265,10 +282,11 @@ module Sass
       end
 
       def else_block(node)
+        start_pos = source_position
         return unless tok(/@else/)
         ss
         else_node = block(
-          Sass::Tree::IfNode.new((sass_script(:parse) if tok(/if/))),
+          node(Sass::Tree::IfNode.new((sass_script(:parse) if tok(/if/))), start_pos),
           :directive)
         node.add_else(else_node)
         pos = @scanner.pos
@@ -284,18 +302,18 @@ module Sass
           end
       end
 
-      def else_directive
+      def else_directive(start_pos)
         err("Invalid CSS: @else must come after @if")
       end
 
-      def extend_directive
+      def extend_directive(start_pos)
         selector = expr!(:selector_sequence)
         optional = tok(OPTIONAL)
         ss
-        node(Sass::Tree::ExtendNode.new(selector, !!optional))
+        node(Sass::Tree::ExtendNode.new(selector, !!optional), start_pos)
       end
 
-      def import_directive
+      def import_directive(start_pos)
         values = []
 
         loop do
@@ -307,13 +325,13 @@ module Sass
       end
 
       def import_arg
-        line = @line
+        start_pos = source_position
         return unless (str = tok(STRING)) || (uri = tok?(/url\(/i))
         if uri
           str = sass_script(:parse_string)
           media = media_query_list
           ss
-          return node(Tree::CssImportNode.new(str, media.to_a))
+          return node(Tree::CssImportNode.new(str, media.to_a), start_pos)
         end
 
         path = @scanner[1] || @scanner[2]
@@ -321,18 +339,16 @@ module Sass
 
         media = media_query_list
         if path =~ /^(https?:)?\/\// || media || use_css_import?
-          node = Sass::Tree::CssImportNode.new(str, media.to_a)
-        else
-          node = Sass::Tree::ImportNode.new(path.strip)
+          return node(Sass::Tree::CssImportNode.new(str, media.to_a), start_pos)
         end
-        node.line = line
-        node
+
+        node(Sass::Tree::ImportNode.new(path.strip), start_pos)
       end
 
       def use_css_import?; false; end
 
-      def media_directive
-        block(node(Sass::Tree::MediaNode.new(expr!(:media_query_list).to_a)), :directive)
+      def media_directive(start_pos)
+        block(node(Sass::Tree::MediaNode.new(expr!(:media_query_list).to_a), start_pos), :directive)
       end
 
       # http://www.w3.org/TR/css3-mediaqueries/#syntax
@@ -400,11 +416,11 @@ module Sass
         res
       end
 
-      def charset_directive
+      def charset_directive(start_pos)
         tok! STRING
         name = @scanner[1] || @scanner[2]
         ss
-        node(Sass::Tree::CharsetNode.new(name))
+        node(Sass::Tree::CharsetNode.new(name), start_pos)
       end
 
       # The document directive is specified in
@@ -415,14 +431,14 @@ module Sass
       # We could parse all document directives according to Mozilla's syntax,
       # but if someone's using e.g. @-webkit-document we don't want them to
       # think WebKit works sans quotes.
-      def _moz_document_directive
+      def _moz_document_directive(start_pos)
         res = ["@-moz-document "]
         loop do
           res << str{ss} << expr!(:moz_document_function)
           break unless c = tok(/,/)
           res << c
         end
-        directive_body(res.flatten)
+        directive_body(res.flatten, start_pos)
       end
 
       def moz_document_function
@@ -433,16 +449,16 @@ module Sass
       end
 
       # http://www.w3.org/TR/css3-conditional/
-      def supports_directive(name)
+      def supports_directive(name, start_pos)
         condition = expr!(:supports_condition)
-        node = node(Sass::Tree::SupportsNode.new(name, condition))
+        node = Sass::Tree::SupportsNode.new(name, condition)
 
         tok!(/\{/)
         node.has_children = true
         block_contents(node, :directive)
         tok!(/\}/)
 
-        node
+        node(node, start_pos)
       end
 
       def supports_condition
@@ -494,12 +510,14 @@ module Sass
 
       def variable
         return unless tok(/\$/)
+        start_pos = source_position
         name = tok!(IDENT)
         ss; tok!(/:/); ss
 
         expr = sass_script(:parse)
         guarded = tok(DEFAULT)
-        node(Sass::Tree::VariableNode.new(name, expr, guarded))
+        result = Sass::Tree::VariableNode.new(name, expr, guarded)
+        node(result, start_pos)
       end
 
       def operator
@@ -511,8 +529,9 @@ module Sass
       end
 
       def ruleset
+        start_pos = source_position
         return unless rules = selector_sequence
-        block(node(Sass::Tree::RuleNode.new(rules.flatten.compact)), :ruleset)
+        block(node(Sass::Tree::RuleNode.new(rules.flatten.compact), start_pos), :ruleset)
       end
 
       def block(node, context)
@@ -520,6 +539,7 @@ module Sass
         tok!(/\{/)
         block_contents(node, context)
         tok!(/\}/)
+        node.source_range.end_pos = source_position if node.source_range
         node
       end
 
@@ -829,6 +849,7 @@ module Sass
 
       def declaration
         # This allows the "*prop: val", ":prop: val", and ".prop: val" hacks
+        name_start_pos = source_position
         if s = tok(/[:\*\.]|\#(?!\{)/)
           @use_property_exception = s !~ /[\.\#]/
           name = [s, str{ss}, *expr!(:interp_ident)]
@@ -839,14 +860,18 @@ module Sass
         if comment = tok(COMMENT)
           name << comment
         end
+        name_end_pos = source_position
         ss
 
         tok!(/:/)
-        space, value = value!
+        value_start_pos, space, value = value!
+        value_end_pos = source_position
         ss
         require_block = tok?(/\{/)
 
-        node = node(Sass::Tree::PropNode.new(name.flatten.compact, value, :new))
+        node = node(Sass::Tree::PropNode.new(name.flatten.compact, value, :new), name_start_pos, value_end_pos)
+        node.name_source_range = range(name_start_pos, name_end_pos)
+        node.value_source_range = range(value_start_pos, value_end_pos)
 
         return node unless require_block
         nested_properties! node, space
@@ -854,18 +879,19 @@ module Sass
 
       def value!
         space = !str {ss}.empty?
+        value_start_pos = source_position
         @use_property_exception ||= space || !tok?(IDENT)
 
-        return true, Sass::Script::String.new("") if tok?(/\{/)
+        return value_start_pos, true, Sass::Script::String.new("") if tok?(/\{/)
         # This is a bit of a dirty trick:
         # if the value is completely static,
         # we don't parse it at all, and instead return a plain old string
         # containing the value.
         # This results in a dramatic speed increase.
         if val = tok(STATIC_VALUE, true)
-          return space, Sass::Script::String.new(val.strip)
+          return value_start_pos, space, Sass::Script::String.new(val.strip)
         end
-        return space, sass_script(:parse)
+        return value_start_pos, space, sass_script(:parse)
       end
 
       def nested_properties!(node, space)
@@ -982,18 +1008,21 @@ MESSAGE
       def str?
         pos = @scanner.pos
         line = @line
+        offset = @offset
         @strs.push ""
         throw_error {yield} && @strs.last
       rescue Sass::SyntaxError => e
         @scanner.pos = pos
         @line = line
+        @offset = offset
         nil
       ensure
         @strs.pop
       end
 
-      def node(node)
-        node.line = @line
+      def node(node, start_pos, end_pos = source_position)
+        node.line = start_pos.line
+        node.source_range = range(start_pos, end_pos)
         node
       end
 
@@ -1003,8 +1032,7 @@ MESSAGE
       def self.sass_script_parser; @sass_script_parser; end
 
       def sass_script(*args)
-        parser = self.class.sass_script_parser.new(@scanner, @line,
-          @scanner.pos - (@scanner.string[0...@scanner.pos].rindex("\n") || 0))
+        parser = self.class.sass_script_parser.new(@scanner, @line, @offset, :filename => @filename)
         result = parser.send(*args)
         unless @strs.empty?
           # Convert to CSS manually so that comments are ignored.
@@ -1012,6 +1040,7 @@ MESSAGE
           @strs.each {|s| s << src}
         end
         @line = parser.line
+        @offset = parser.offset
         result
       rescue Sass::SyntaxError => e
         throw(:_sass_parser_error, true) if @throw_error
@@ -1086,10 +1115,12 @@ MESSAGE
         old_throw_error, @throw_error = @throw_error, true
         pos = @scanner.pos
         line = @line
+        offset = @offset
         expected = @expected
         if catch(:_sass_parser_error) {yield; false}
           @scanner.pos = pos
           @line = line
+          @offset = offset
           @expected = expected
           {:pos => pos, :line => line, :expected => @expected, :block => block}
         end
@@ -1152,7 +1183,15 @@ MESSAGE
             @scanner.pos -= @scanner[-1].length
             res.slice!(-@scanner[-1].length..-1)
           end
-          @line += res.count(NEWLINE)
+
+          newline_count = res.count(NEWLINE)
+          if newline_count > 0
+            @line += newline_count
+            @offset = res[res.rindex(NEWLINE)..-1].size
+          else
+            @offset += res.size
+          end
+
           @expected = nil
           if !@strs.empty? && rx != COMMENT && rx != SINGLE_LINE_COMMENT
             @strs.each {|s| s << res}