solargraph 0.26.1 → 0.27.0

data/lib/solargraph/pin/proxy_type.rb

@@ -1,7 +1,7 @@
 module Solargraph
   module Pin
     class ProxyType < Base
-      # @param location [Solargraph::Source::Location]
+      # @param location [Solargraph::Location]
       # @param namespace [String]
       # @param name [String]
       # @param return_type [ComplexType]
@@ -10,10 +10,6 @@ module Solargraph
         @return_complex_type = return_type
       end
 
-      def scope
-        return_complex_type.scope
-      end
-
       def path
         @path ||= begin
           result = namespace.to_s
@@ -22,8 +18,8 @@ module Solargraph
         end
       end
 
-      def named_context
-        path
+      def context
+        @return_complex_type
       end
 
       # @param return_type [ComplexType]

data/lib/solargraph/pin/reference.rb

@@ -1,7 +1,7 @@
 module Solargraph
   module Pin
     class Reference
-      # @return [Source::Location]
+      # @return [Location]
       attr_reader :location
 
       # @return [String]
@@ -10,7 +10,7 @@ module Solargraph
       # @return [String]
       attr_reader :name
 
-      # @param location [Source::Location]
+      # @param location [Location]
       # @param namespace [String]
       # @param name [String]
       def initialize location, namespace, name

data/lib/solargraph/pin/symbol.rb

@@ -1,7 +1,7 @@
 module Solargraph
   module Pin
     class Symbol < Base
-      # @param location [Solargraph::Source::Location]
+      # @param location [Solargraph::Location]
       # @param name [String]
       def initialize location, name
         @name = name

data/lib/solargraph/pin/yard_pin/method.rb

@@ -4,9 +4,9 @@ module Solargraph
       class Method < Pin::Method
         include YardMixin
 
-        def initialize code_object, location
+        def initialize code_object, location, name = nil, scope = nil, visibility = nil
           comments = (code_object.docstring ? code_object.docstring.all : nil)
-          super(location, code_object.namespace.to_s, code_object.name.to_s, comments, code_object.scope, code_object.visibility, get_parameters(code_object))
+          super(location, code_object.namespace.to_s, name || code_object.name.to_s, comments, scope || code_object.scope, visibility || code_object.visibility, get_parameters(code_object))
         end
 
         def return_complex_type

data/lib/solargraph/pin/yard_pin/namespace.rb

@@ -6,14 +6,23 @@ module Solargraph
 
         def initialize code_object, location
           superclass = nil
-          superclass = code_object.superclass.to_s if code_object.is_a?(YARD::CodeObjects::ClassObject) and code_object.superclass
+          # @todo This method of superclass detection is a bit of a hack. If
+          #   the superclass is a Proxy, it is assumed to be undefined in its
+          #   yardoc and converted to a fully qualified namespace.
+          if code_object.is_a?(YARD::CodeObjects::ClassObject) && code_object.superclass
+            if code_object.superclass.is_a?(YARD::CodeObjects::Proxy)
+              superclass = "::#{code_object.superclass}"
+            else
+              superclass = code_object.superclass.to_s
+            end
+          end
           super(location, code_object.namespace.to_s, code_object.name.to_s, comments_from(code_object), namespace_type(code_object), code_object.visibility, superclass)
-          # code_object.class_mixins.each do |m|
-          #   extend_references.push Pin::Reference.new(location, path, m.path)
-          # end
-          # code_object.instance_mixins.each do |m|
-          #   include_references.push Pin::Reference.new(location, path, m.path)
-          # end
+          code_object.class_mixins.each do |m|
+            extend_references.push Pin::Reference.new(location, path, m.path)
+          end
+          code_object.instance_mixins.each do |m|
+            include_references.push Pin::Reference.new(location, path, m.path)
+          end
         end
 
         private

data/lib/solargraph/position.rb

@@ -0,0 +1,103 @@
+module Solargraph
+
+  class Position
+    # @return [Integer]
+    attr_reader :line
+
+    # @return [Integer]
+    attr_reader :character
+
+    def initialize line, character
+      @line = line
+      @character = character
+    end
+
+    def column
+      character
+    end
+
+    # Get a hash of the position. This representation is suitable for use in
+    # the language server protocol.
+    #
+    # @return [Hash]
+    def to_hash
+      {
+        line: line,
+        character: character
+      }
+    end
+
+    def inspect
+      "<Position #{line}, #{character}>"
+    end
+
+    # Get a numeric offset for the specified text and position.
+    #
+    # @param text [String]
+    # @param position [Position]
+    # @return [Integer]
+    def self.to_offset text, position
+      result = 0
+      feed = 0
+      line = position.line
+      column = position.character
+      text.lines.each do |l|
+        line_length = l.length
+        char_length = l.chomp.length
+        if feed == line
+          result += column
+          break
+        end
+        result += line_length
+        feed += 1
+      end
+      result
+    end
+
+    # Get a numeric offset for the specified text and a position identified
+    # by its line and character.
+    #
+    # @param text [String]
+    # @param line [Integer]
+    # @param character [Integer]
+    # @return [Integer]
+    def self.line_char_to_offset text, line, character
+      to_offset(text, Position.new(line, character))
+    end
+
+    # Get a position for the specified text and offset.
+    #
+    # @param text [String]
+    # @param offset [Integer]
+    # @return [Position]
+    def self.from_offset text, offset
+      cursor = 0
+      line = 0
+      character = nil
+      text.lines.each do |l|
+        line_length = l.length
+        char_length = l.chomp.length
+        if cursor + char_length >= offset
+          character = offset - cursor
+          break
+        end
+        cursor += line_length
+        line += 1
+      end
+      character = 0 if character.nil? and offset == cursor
+      raise InvalidOffsetError if character.nil?
+      Position.new(line, character)
+    end
+
+    def self.normalize object
+      return object if object.is_a?(Position)
+      return Position.new(object[0], object[1]) if object.is_a?(Array)
+      raise ArgumentError, "Unable to convert #{object.class} to Position"
+    end
+
+    def == other
+      return false unless other.is_a?(Position)
+      line == other.line and character == other.character
+    end
+  end
+end

data/lib/solargraph/range.rb

@@ -0,0 +1,70 @@
+module Solargraph
+  class Range
+    # @return [Position]
+    attr_reader :start
+
+    # @return [Position]
+    attr_reader :ending
+
+    # @param start [Position]
+    # @param ending [Position]
+    def initialize start, ending
+      @start = start
+      @ending = ending
+    end
+
+    # Get a hash of the range. This representation is suitable for use in
+    # the language server protocol.
+    #
+    # @return [Hash<Symbol, Position>]
+    def to_hash
+      {
+        start: start.to_hash,
+        end: ending.to_hash
+      }
+    end
+
+    # True if the specified position is inside the range.
+    #
+    # @param position [Solargraph::Position]
+    # @return [Boolean]
+    def contain? position
+      return false if position.line < start.line or position.line > ending.line
+      return false if position.line == start.line and position.character < start.character
+      return false if position.line == ending.line and position.character > ending.character
+      true
+    end
+
+    # True if the range contains the specified position and the position does not precede it.
+    #
+    # @param position [Position]
+    # @return [Boolean]
+    def include? position
+      contain?(position) and !(position.line == start.line and position.character == start.character)
+    end
+
+    # Create a range from a pair of lines and characters.
+    #
+    # @param l1 [Integer] Starting line
+    # @param c1 [Integer] Starting character
+    # @param l2 [Integer] Ending line
+    # @param c2 [Integer] Ending character
+    # @return [Range]
+    def self.from_to l1, c1, l2, c2
+      Range.new(Position.new(l1, c1), Position.new(l2, c2))
+    end
+
+    def self.from_node node
+      from_expr(node.loc.expression)
+    end
+
+    def self.from_expr expr
+      from_to(expr.line, expr.column, expr.last_line, expr.last_column)
+    end
+
+    def == other
+      return false unless other.is_a?(Range)
+      start == other.start and ending == other.ending
+    end
+  end
+end

data/lib/solargraph/source.rb

@@ -1,25 +1,22 @@
 require 'parser/current'
-require 'time'
-require 'yard'
 
 module Solargraph
+  # A Ruby file that has been parsed into an AST.
+  #
   class Source
     autoload :FlawedBuilder, 'solargraph/source/flawed_builder'
-    autoload :Fragment,      'solargraph/source/fragment'
-    autoload :Position,      'solargraph/source/position'
-    autoload :Range,         'solargraph/source/range'
-    autoload :Location,      'solargraph/source/location'
     autoload :Updater,       'solargraph/source/updater'
     autoload :Change,        'solargraph/source/change'
     autoload :Mapper,        'solargraph/source/mapper'
     autoload :NodeMethods,   'solargraph/source/node_methods'
-    autoload :Chain,         'solargraph/source/chain'
     autoload :EncodingFixes, 'solargraph/source/encoding_fixes'
-    autoload :CallChainer,   'solargraph/source/call_chainer'
+    autoload :Cursor,        'solargraph/source/cursor'
+    autoload :Chain,         'solargraph/source/chain'
+    autoload :SourceChainer, 'solargraph/source/source_chainer'
     autoload :NodeChainer,   'solargraph/source/node_chainer'
-    autoload :Completion,    'solargraph/source/completion'
 
     include EncodingFixes
+    include NodeMethods
 
     # @return [String]
     attr_reader :code
@@ -27,173 +24,50 @@ module Solargraph
     # @return [Parser::AST::Node]
     attr_reader :node
 
-    # @return [Array]
     attr_reader :comments
 
     # @return [String]
     attr_reader :filename
 
-    # Get the file's modification time.
-    #
-    # @return [Time]
-    attr_reader :mtime
-
-    attr_reader :directives
-
-    attr_reader :path_macros
-
+    # @todo Deprecate?
     # @return [Integer]
-    attr_accessor :version
-
-    # Get the time of the last synchronization.
-    #
-    # @return [Time]
-    attr_reader :stime
-
-    # @return [Array<Solargraph::Pin::Base>]
-    attr_reader :pins
-
-    # @return [Array<Solargraph::Pin::Reference>]
-    attr_reader :requires
-
-    attr_reader :domains
-
-    # @return [Array<Solargraph::Pin::Base>]
-    attr_reader :locals
-
-    include NodeMethods
+    attr_reader :version
 
     # @param code [String]
     # @param filename [String]
-    def initialize code, filename = nil
+    # @param version [Integer]
+    def initialize code, filename = nil, version = 0
+      @code = normalize(code)
+      @repaired = code
+      @filename = filename
+      @version = version
+      @domains = []
       begin
-        @code = normalize(code)
-        @fixed = @code
-        @filename = filename
-        @version = 0
-        @domains = []
-        parse
+        @node, @comments = Source.parse_with_comments(@code, filename)
+        @parsed = true
       rescue Parser::SyntaxError, EncodingError => e
-        hard_fix_node
+        @node, @comments = Source.parse_with_comments(@code.gsub(/[^s]/, ' '), filename)
+        @parsed = false
       rescue Exception => e
         STDERR.puts e.message
         STDERR.puts e.backtrace
         raise "Error parsing #{filename || '(source)'}: [#{e.class}] #{e.message}"
+      ensure
+        @code.freeze
       end
     end
 
-    # @param range [Solargraph::Source::Range]
+    # @param range [Solargraph::Range]
     def at range
       from_to range.start.line, range.start.character, range.ending.line, range.ending.character
     end
 
     def from_to l1, c1, l2, c2
-      b = Solargraph::Source::Position.line_char_to_offset(@code, l1, c1)
-      e = Solargraph::Source::Position.line_char_to_offset(@code, l2, c2)
+      b = Solargraph::Position.line_char_to_offset(@code, l1, c1)
+      e = Solargraph::Position.line_char_to_offset(@code, l2, c2)
       @code[b..e-1]
     end
 
-    def macro path
-      @path_macros[path]
-    end
-
-    # @todo Temporary blank
-    def path_macros
-      @path_macros ||= {}
-    end
-
-    # @todo Name problem
-    # @return [Array<Solargraph::Pin::Reference>]
-    def required
-      requires
-    end
-
-    # @return [Array<String>]
-    def namespaces
-      @namespaces ||= pins.select{|pin| pin.kind == Pin::NAMESPACE}.map(&:path)
-    end
-
-    # @param fqns [String] The namespace (nil for all)
-    # @return [Array<Solargraph::Pin::Namespace>]
-    def namespace_pins fqns = nil
-      pins.select{|pin| pin.kind == Pin::NAMESPACE}
-    end
-
-    # @param fqns [String] The namespace (nil for all)
-    # @return [Array<Solargraph::Pin::Method>]
-    def method_pins fqns = nil
-      pins.select{|pin| pin.kind == Solargraph::Pin::METHOD or pin.kind == Solargraph::Pin::ATTRIBUTE}
-    end
-
-    # @return [Array<Solargraph::Pin::Attribute>]
-    def attribute_pins
-      pins.select{|pin| pin.kind == Pin::ATTRIBUTE}
-    end
-
-    # @return [Array<Solargraph::Pin::InstanceVariable>]
-    def instance_variable_pins
-      pins.select{|pin| pin.kind == Pin::INSTANCE_VARIABLE}
-    end
-
-    # @return [Array<Solargraph::Pin::ClassVariable>]
-    def class_variable_pins
-      pins.select{|pin| pin.kind == Pin::CLASS_VARIABLE}
-    end
-
-    # @return [Array<Solargraph::Pin::GlobalVariable>]
-    def global_variable_pins
-      pins.select{|pin| pin.kind == Pin::GLOBAL_VARIABLE}
-    end
-
-    # @return [Array<Solargraph::Pin::Constant>]
-    def constant_pins
-      pins.select{|pin| pin.kind == Pin::CONSTANT}
-    end
-
-    # @return [Array<Solargraph::Pin::Symbol>]
-    def symbol_pins
-      @symbols
-    end
-
-    # @return [Array<Solargraph::Pin::Symbol>]
-    def symbols
-      symbol_pins
-    end
-
-    # @param name [String]
-    # @return [Array<Source::Location>]
-    def references name
-      inner_node_references(name, node).map do |n|
-        offset = Position.to_offset(code, get_node_start_position(n))
-        soff = code.index(name, offset)
-        eoff = soff + name.length
-        Location.new(
-          filename,
-          Solargraph::Source::Range.new(
-            Position.from_offset(code, soff),
-            Position.from_offset(code, eoff)
-          )
-        )
-      end
-    end
-
-    def locate_named_path_pin line, character
-      _locate_pin line, character, Pin::NAMESPACE, Pin::METHOD
-    end
-
-    # Locate the namespace pin at the specified line and character.
-    #
-    # @param line [line]
-    # @param character [character]
-    # @return [Pin::Namespace]
-    def locate_namespace_pin line, character
-      _locate_pin line, character, Pin::NAMESPACE
-    end
-
-    def locate_block_pin line, character
-      _locate_pin line, character, Pin::NAMESPACE, Pin::METHOD, Pin::BLOCK
-    end
-
     # Get the nearest node that contains the specified index.
     #
     # @param line [Integer]
@@ -203,38 +77,6 @@ module Solargraph
       tree_at(line, column).first
     end
 
-    # True if the specified location is inside a string.
-    #
-    # @param line [Integer]
-    # @param column [Integer]
-    # @return [Boolean]
-    def string_at?(line, column)
-      # node = node_at(line, column)
-      # # @todo raise InvalidOffset or InvalidRange or something?
-      # return false if node.nil?
-      # node.type == :str or node.type == :dstr
-      pos = Source::Position.new(line, column)
-      @strings.each do |str|
-        return true if str.contain?(pos)
-        break if str.start.line > pos.line
-      end
-      false
-    end
-
-    # True if the specified location is inside a comment.
-    #
-    # @param line [Integer]
-    # @param column [Integer]
-    # @return [Boolean]
-    def comment_at?(line, column)
-      pos = Source::Position.new(line, column)
-      @comment_ranges.each do |cmnt|
-        return true if cmnt.include?(pos)
-        break if cmnt.start.line > pos.line
-      end
-      false
-    end
-
     # Get an array of nodes containing the specified index, starting with the
     # nearest node and ending with the root.
     #
@@ -251,82 +93,111 @@ module Solargraph
 
     # @param updater [Source::Updater]
     # @param reparse [Boolean]
-    # @return [void]
-    def synchronize updater, reparse = true
+    # @return [Source]
+    def synchronize updater
       raise 'Invalid synchronization' unless updater.filename == filename
-      original_code = @code
-      original_fixed = @fixed
-      @code = updater.write(original_code)
-      @fixed = updater.write(original_code, true)
-      @version = updater.version
-      return if @code == original_code or !reparse
-      begin
-        parse
-        @fixed = @code
-      rescue Parser::SyntaxError, EncodingError => e
-        @fixed = updater.repair(original_fixed)
-        begin
-          parse
-        rescue Parser::SyntaxError, EncodingError => e
-          hard_fix_node
+      real_code = updater.write(@code)
+      incr_code = updater.write(@code, true)
+      if real_code == @code
+        @version = updater.version
+        return self
+      end
+      synced = Source.new(incr_code, filename)
+      if synced.parsed?
+        synced.code = real_code
+        if synced.repaired?
+          synced.error_ranges.concat combine_errors(error_ranges + updater.changes.map(&:range))
         end
+      else
+        new_repair = updater.repair(@repaired)
+        synced = Source.new(new_repair, filename)
+        synced.error_ranges.concat combine_errors(error_ranges + updater.changes.map(&:range))
+        synced.parsed = false
+        synced.code = real_code
       end
+      synced.version = updater.version
+      synced
     end
 
-    # @param query [String]
-    # @return [Array<Solargraph::Pin::Base>]
-    def query_symbols query
-      return [] if query.empty?
-      down = query.downcase
-      all_symbols.select{|p| p.path.downcase.include?(down)}
+    # @param position [Position]
+    # @return [Source::Cursor]
+    def cursor_at position
+      Cursor.new(self, position)
     end
 
-    # @return [Array<Solargraph::Pin::Base>]
-    def all_symbols
-      @all_symbols ||= pins.select{ |pin|
-        [Pin::ATTRIBUTE, Pin::CONSTANT, Pin::METHOD, Pin::NAMESPACE].include?(pin.kind) and !pin.name.empty?
-      }
+    # @return [Boolean]
+    def parsed?
+      @parsed
     end
 
-    # @param location [Solargraph::Source::Location]
-    # @return [Solargraph::Pin::Base]
-    def locate_pin location
-      # return nil unless location.start_with?("#{filename}:")
-      pins.select{|pin| pin.location == location}
+    def repaired?
+      @is_repaired ||= (@code != @repaired)
     end
 
-    # @param line [Integer] A zero-based line number
-    # @param column [Integer] A zero-based column number
-    # @return [Solargraph::Source::Fragment]
-    def fragment_at line, column
-      Fragment.new(self, line, column)
+    # @param position [Position]
+    # @return [Boolean]
+    def string_at? position
+      string_ranges.each do |range|
+        return true if range.include?(position)
+        break if range.ending.line > position.line
+      end
+      false
     end
 
+    # @param position [Position]
     # @return [Boolean]
-    def parsed?
-      @parsed
+    def comment_at? position
+      comment_ranges.each do |range|
+        return true if range.include?(position)
+        break if range.ending.line > position.line
+      end
+      false
+    end
+
+    # @param name [String]
+    # @return [Array<Location>]
+    def references name
+      inner_node_references(name, node).map do |n|
+        offset = Position.to_offset(code, get_node_start_position(n))
+        soff = code.index(name, offset)
+        eoff = soff + name.length
+        Location.new(
+          filename,
+          Range.new(
+            Position.from_offset(code, soff),
+            Position.from_offset(code, eoff)
+          )
+        )
+      end
+    end
+
+    # @return [Array<Range>]
+    def error_ranges
+      @error_ranges ||= []
     end
 
     private
 
-    def _locate_pin line, character, *kinds
-      position = Solargraph::Source::Position.new(line, character)
-      found = nil
-      pins.each do |pin|
-        found = pin if (kinds.empty? or kinds.include?(pin.kind)) and pin.location.range.contain?(position)
-        break if pin.location.range.start.line > line
+    # @return [Array<Range>]
+    def string_ranges
+      @string_ranges ||= string_ranges_in(@node)
+    end
+
+    # @return [Array<Range>]
+    def comment_ranges
+      @comment_ranges || @comments.map do |cmnt|
+        Range.from_expr(cmnt.loc.expression)
       end
-      # @todo Assuming the root pin is always valid
-      found || pins.first
     end
 
-    def inner_node_references name, top
+    def string_ranges_in n
       result = []
-      if top.kind_of?(AST::Node)
-        if top.children.any?{|c| c.to_s == name}
-          result.push top
+      if n.is_a?(Parser::AST::Node)
+        if n.type == :str
+          result.push Range.from_node(n)
+        else
+          n.children.each{ |c| result.concat string_ranges_in(c) }
         end
-        top.children.each { |c| result.concat inner_node_references(name, c) }
       end
       result
     end
@@ -344,101 +215,46 @@ module Solargraph
       end
     end
 
-    # @return [void]
-    def parse
-      node, comments = inner_parse(@fixed, filename)
-      @node = node
-      @comments = comments
-      process_parsed node, comments
-      @parsed = true
+    def inner_node_references name, top
+      result = []
+      if top.kind_of?(AST::Node)
+        if top.children.any?{|c| c.to_s == name}
+          result.push top
+        end
+        top.children.each { |c| result.concat inner_node_references(name, c) }
+      end
+      result
     end
 
-    def hard_fix_node
-      @fixed = @code.gsub(/[^\s]/, '_')
-      node, comments = inner_parse(@fixed, filename)
-      process_parsed node, comments
-      @node = node
-      @comments = comments
-      @parsed = false
+    # @param ranges [Array<Range>]
+    # @return [Array<Range>]
+    def combine_errors ranges
+      result = []
+      lines = []
+      ranges.sort{|a, b| a.start.line <=> b.start.line}.each do |rng|
+        next if rng.nil? || lines.include?(rng.start.line)
+        lines.push rng.start.line
+        next if comment_at?(rng.start) || rng.start.line >= code.lines.length
+        fcol = code.lines[rng.start.line].index(/[^\s]/) || 0
+        ecol = code.lines[rng.start.line].length
+        result.push Range.from_to(rng.start.line, fcol, rng.start.line, ecol)
+      end
+      result
     end
 
-    def inner_parse code, filename
-      parser = Parser::CurrentRuby.new(FlawedBuilder.new)
-      parser.diagnostics.all_errors_are_fatal = true
-      parser.diagnostics.ignore_warnings      = true
-      buffer = Parser::Source::Buffer.new(filename, 0)
-      buffer.source = code.encode('UTF-8', 'binary', invalid: :replace, undef: :replace, replace: '_')
-      parser.parse_with_comments(buffer)
-    end
+    protected
 
-    def process_parsed node, comments
-      new_map_data = Mapper.map(filename, code, node, comments)
-      synchronize_mapped *new_map_data
-    end
+    # @return [Integer]
+    attr_writer :version
 
-    def synchronize_mapped new_pins, new_locals, new_requires, new_symbols, new_strings, new_comment_ranges #, new_path_macros, new_domains
-      @strings = new_strings
-      @comment_ranges = new_comment_ranges
-      return if @requires == new_requires and @symbols == new_symbols and try_merge(new_pins, new_locals)
-      @pins = new_pins
-      @locals = new_locals
-      @requires = new_requires
-      @symbols = new_symbols
-      @all_symbols = nil # Reset for future queries
-      @domains = []
-      @path_macros = {}
-      dirpins = []
-      @pins.select(&:maybe_directives?).each do |pin|
-        dirpins.push pin unless pin.directives.empty?
-      end
-      process_directives dirpins
-      @stime = Time.now
-    end
+    # @return [String]
+    attr_writer :code
 
-    # @param new_pins [Array<Solargraph::Pin::Base>]
-    # @param new_locals [Array<Solargraph::Pin::Base>]
-    # @return [Boolean]
-    def try_merge new_pins, new_locals
-      return false if @pins.nil? or @locals.nil? or new_pins.length != @pins.length or new_locals.length != @locals.length
-      new_pins.each_index do |i|
-        return false unless @pins[i].try_merge!(new_pins[i])
-      end
-      new_locals.each_index do |i|
-        return false unless @locals[i].try_merge!(new_locals[i])
-      end
-      true
-    end
+    # @return [String]
+    attr_accessor :repaired
 
-    # @return [void]
-    def process_directives pins
-      pins.each do |pin|
-        pin.directives.each do |d|
-          # ns = namespace_for(k.node)
-          ns = (pin.kind == Pin::NAMESPACE ? pin.path : pin.namespace)
-          docstring = YARD::Docstring.parser.parse(d.tag.text).to_docstring
-          if d.tag.tag_name == 'attribute'
-            t = (d.tag.types.nil? || d.tag.types.empty?) ? nil : d.tag.types.flatten.join('')
-            if t.nil? or t.include?('r')
-              # location, namespace, name, docstring, access
-              @pins.push Solargraph::Pin::Attribute.new(pin.location, pin.path, d.tag.name, docstring.all, :reader, :instance)
-            end
-            if t.nil? or t.include?('w')
-              @pins.push Solargraph::Pin::Attribute.new(pin.location, pin.path, "#{d.tag.name}=", docstring.all, :writer, :instance)
-            end
-          elsif d.tag.tag_name == 'method'
-            gen_src = Source.new("def #{d.tag.name};end", filename)
-            gen_pin = gen_src.pins.last # Method is last pin after root namespace
-            @pins.push Solargraph::Pin::Method.new(pin.location, pin.path, gen_pin.name, docstring.all, :instance, :public, [])
-          elsif d.tag.tag_name == 'macro'
-            @path_macros[pin.path] = d
-          elsif d.tag.tag_name == 'domain'
-            @domains.push d.tag.text
-          else
-            # STDERR.puts "Nothing to do for directive: #{d}"
-          end
-        end
-      end
-    end
+    # @return [Boolean]
+    attr_writer :parsed
 
     class << self
       # @param filename [String]
@@ -453,17 +269,32 @@ module Solargraph
       # @param code [String]
       # @param filename [String]
       # @return [Solargraph::Source]
-      def load_string code, filename = nil
-        Source.new code, filename
+      def load_string code, filename = nil, version = 0
+        Source.new code, filename, version
       end
 
-      def parse_node code, filename
+      def parse_with_comments code, filename = nil
+        buffer = Parser::Source::Buffer.new(filename, 0)
+        buffer.source = code.encode('UTF-8', 'binary', invalid: :replace, undef: :replace, replace: '_')
+        parser.parse_with_comments(buffer)
+      end
+
+      def parse code, filename = nil
+        buffer = Parser::Source::Buffer.new(filename, 0)
+        buffer.source = code.encode('UTF-8', 'binary', invalid: :replace, undef: :replace, replace: '_')
+        parser.parse(buffer)
+      end
+
+      private
+
+      # @return [Parser::Base]
+      def parser
+        # @todo Consider setting an instance variable. We might not need to
+        #   recreate the parser every time we use it.
         parser = Parser::CurrentRuby.new(FlawedBuilder.new)
         parser.diagnostics.all_errors_are_fatal = true
         parser.diagnostics.ignore_warnings      = true
-        buffer = Parser::Source::Buffer.new(nil, 0)
-        buffer.source = code.encode('UTF-8', 'binary', invalid: :replace, undef: :replace, replace: '_')
-        parser.parse(buffer)
+        parser
       end
     end
   end