solargraph 0.25.1 → 0.26.0

data/lib/solargraph/source/chain.rb

@@ -0,0 +1,104 @@
+# HACK Fix autoload issue
+require 'solargraph/source/chain/link'
+
+module Solargraph
+  class Source
+    class Chain
+      autoload :Link,             'solargraph/source/chain/link'
+      autoload :Call,             'solargraph/source/chain/call'
+      autoload :Variable,         'solargraph/source/chain/variable'
+      autoload :ClassVariable,    'solargraph/source/chain/class_variable'
+      autoload :Constant,         'solargraph/source/chain/constant'
+      autoload :InstanceVariable, 'solargraph/source/chain/instance_variable'
+      autoload :GlobalVariable,   'solargraph/source/chain/global_variable'
+      autoload :Literal,          'solargraph/source/chain/literal'
+      autoload :Definition,       'solargraph/source/chain/definition'
+      autoload :Head,             'solargraph/source/chain/head'
+
+      UNDEFINED_CALL = Source::Chain::Call.new('<undefined>')
+      UNDEFINED_CONSTANT = Source::Chain::Constant.new('<undefined>')
+
+      # @return [Array<Source::Chain::Link>]
+      attr_reader :links
+
+      # @param filename [String]
+      # @param links [Array<Chain::Link>]
+      def initialize filename, links
+        @filename = filename
+        @links = links
+        @links.push UNDEFINED_CALL if @links.empty?
+      end
+
+      # @return [Array<Source::Chain::Link>]
+      def base
+        # @todo It might make sense for the chain links to always have a root.
+        @base ||= links[0..-2]
+      end
+
+      # @return [Source::Chain::Link]
+      def tail
+        @tail ||= links.last
+      end
+
+      def literal?
+        tail.is_a?(Literal)
+      end
+
+      # @param api_map [ApiMap]
+      # @param context [Pin::Base]
+      # @param locals [Array<Pin::Base>]
+      # @return [Array<Pin::Base>]
+      def define_with api_map, context, locals
+        inner_define_with links, api_map, context, locals
+      end
+
+      def define_base_with api_map, context, locals
+        inner_define_with links[0..-2], api_map, context, locals
+      end
+
+      # @param api_map [ApiMap]
+      # @param context [Pin::Base]
+      # @param locals [Array<Pin::Base>]
+      # @return [ComplexType]
+      def infer_type_with api_map, context, locals
+        # @todo Perform link inference
+        inner_infer_type_with(links, api_map, context, locals)
+      end
+
+      def infer_base_type_with api_map, context, locals
+        inner_infer_type_with(links[0..-2], api_map, context, locals)
+      end
+
+      private
+
+      def inner_infer_type_with array, api_map, context, locals
+        type = ComplexType::UNDEFINED
+        pins = inner_define_with(array, api_map, context, locals)
+        pins.each do |pin|
+          type = pin.infer(api_map)
+          break unless type.undefined?
+        end
+        type
+      end
+
+      def inner_define_with array, api_map, context, locals
+        return [] if array.empty?
+        type = ComplexType::UNDEFINED
+        head = true
+        # @param link [Chain::Link]
+        array[0..-2].each do |link|
+          pins = link.resolve_pins(api_map, context, head ? locals : [])
+          head = false
+          return [] if pins.empty?
+          pins.each do |pin|
+            type = pin.infer(api_map)
+            break unless type.undefined?
+          end
+          return [] if type.undefined?
+          context = Pin::ProxyType.anonymous(type)
+        end
+        array.last.resolve_pins(api_map, context, head ? locals: [])
+      end
+    end
+  end
+end

data/lib/solargraph/source/chain/call.rb

@@ -0,0 +1,72 @@
+module Solargraph
+  class Source
+    class Chain
+      class Call < Link
+        # @return [String]
+        attr_reader :word
+
+        # @return [Array<Chain>]
+        attr_reader :arguments
+
+        def initialize word, arguments = []
+          @word = word
+          @arguments = arguments
+        end
+
+        def resolve_pins api_map, context, locals
+          found = locals.select{|p| p.name == word}
+          return inferred_pins(found, api_map, context) unless found.empty?
+          pins = api_map.get_method_stack(namespace_from_context(context), word, scope: context.scope)
+          return [] if pins.empty?
+          pins[0] = virtual_new_pin(pins.first, context) if pins.first.path == 'Class#new'
+          inferred_pins(pins, api_map, context)
+        end
+
+        private
+
+        # @param pin [Pin::Base]
+        # @return [String]
+        def namespace_from_context pin
+          return pin.namespace if pin.kind == Pin::ATTRIBUTE or pin.kind == Pin::METHOD
+          pin.return_complex_type.namespace
+        end
+
+        # Create a `new` pin to facilitate type inference. This is necessary for
+        # classes from YARD and classes in the namespace that do not have an
+        # `initialize` method.
+        #
+        # @param new_pin [Solargraph::Pin::Base]
+        # @param context_pin [Solargraph::Pin::Base]
+        # @return [Pin::Method]
+        def virtual_new_pin new_pin, context_pin
+          pin = Pin::Method.new(new_pin.location, context_pin.path, new_pin.name, '', :class, new_pin.visibility, new_pin.parameters)
+          # @todo Smelly instance variable access.
+          pin.instance_variable_set(:@return_complex_type, ComplexType.parse(context_pin.path))
+          pin
+        end
+
+        def self_pin(api_map, context)
+          return Pin::ProxyType.anonymous(ComplexType.parse(context.namespace)) if context.scope == :instance
+          # return api_map.get_path_suggestions(context.namespace)
+          context
+        end
+
+        def inferred_pins pins, api_map, context_pin
+          result = pins.uniq(&:location).map do |p|
+            if CoreFills::METHODS_RETURNING_SELF.include?(p.path)
+              next Solargraph::Pin::Method.new(p.location, p.namespace, p.name, "@return [#{context_pin.return_complex_type.tag}]", p.scope, p.visibility, p.parameters)
+            end
+            if CoreFills::METHODS_RETURNING_SUBTYPES.include?(p.path) and !context_pin.return_complex_type.subtypes.empty?
+              next Solargraph::Pin::Method.new(p.location, p.namespace, p.name, "@return [#{context_pin.return_complex_type.subtypes.first.tag}]", p.scope, p.visibility, p.parameters)
+            end
+            next p if p.kind == Pin::METHOD or p.kind == Pin::ATTRIBUTE or p.kind == Pin::NAMESPACE
+            type = p.infer(api_map)
+            next p if p.return_complex_type == type
+            Pin::ProxyType.new(p.location, nil, p.name, type)
+          end
+          result
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source/chain/class_variable.rb

@@ -0,0 +1,11 @@
+module Solargraph
+  class Source
+    class Chain
+      class ClassVariable < Link
+        def resolve_pins api_map, context, locals
+          api_map.get_class_variable_pins(context.namespace).select{|p| p.name == word}
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source/chain/constant.rb

@@ -0,0 +1,17 @@
+module Solargraph
+  class Source
+    class Chain
+      class Constant < Link
+        def initialize word
+          @word = word
+        end
+
+        def resolve_pins api_map, context, locals
+          ns = api_map.qualify(word, context.named_context)
+          return [] if ns.nil?
+          api_map.get_path_suggestions(ns)
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source/chain/definition.rb

@@ -0,0 +1,16 @@
+module Solargraph
+  class Source
+    class Chain
+      class Definition < Link
+        # @param location [Solargraph::Source::Location]
+        def initialize location
+          @location = location
+        end
+
+        def resolve_pins api_map, context, locals
+          api_map.locate_pin(@location)
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source/chain/global_variable.rb

@@ -0,0 +1,11 @@
+module Solargraph
+  class Source
+    class Chain
+      class GlobalVariable < Link
+        def resolve_pins api_map, context, locals
+          api_map.get_global_variable_pins.select{|p| p.name == word}
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source/chain/head.rb

@@ -0,0 +1,20 @@
+module Solargraph
+  class Source
+    class Chain
+      # Chain::Head is a link for ambiguous words, e.g.; `String` can refer to
+      # either a class (`String`) or a function (`Kernel#String`).
+      #
+      class Head < Call
+        def resolve_pins api_map, context, locals
+          return [self_pin(api_map, context)] if word == 'self'
+          base = super
+          return base if locals.map(&:name).include?(word)
+          here = []
+          ns = api_map.qualify(word, context.named_context)
+          here.concat api_map.get_path_suggestions(ns) unless ns.nil?
+          here + base
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source/chain/instance_variable.rb

@@ -0,0 +1,11 @@
+module Solargraph
+  class Source
+    class Chain
+      class InstanceVariable < Link
+        def resolve_pins api_map, context, locals
+          api_map.get_instance_variable_pins(context.namespace, context.scope).select{|p| p.name == word}
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source/chain/link.rb

@@ -0,0 +1,33 @@
+module Solargraph
+  class Source
+    class Chain
+      class Link
+        attr_reader :word
+
+        def initialize word = '<undefined>'
+          @word = word
+        end
+
+        def undefined?
+          word == '<undefined>'
+        end
+
+        def constant?
+          is_a?(Chain::Constant)
+        end
+
+        # @param api_map [ApiMap]
+        # @param context [ComplexType]
+        # @param locals [Array<Solargraph::Pin::Base>]
+        # @return [Array<Solargraph::Pin::Base>]
+        def resolve_pins api_map, context, locals
+          []
+        end
+
+        def == other
+          self.class == other.class and word == other.word
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source/chain/literal.rb

@@ -0,0 +1,21 @@
+module Solargraph
+  class Source
+    class Chain
+      class Literal < Link
+        def word
+          @word ||= "<#{@type}>"
+        end
+
+        # @param type [String]
+        def initialize type
+          @type = type
+          @complex_type = ComplexType.parse(type).first
+        end
+
+        def resolve_pins api_map, context, locals
+          [Pin::ProxyType.anonymous(@complex_type)]
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source/chain/variable.rb

@@ -0,0 +1,11 @@
+module Solargraph
+  class Source
+    class Chain
+      class Variable < Link
+        def resolve_pins api_map, context, locals
+          api_map.get_instance_variable_pins(context.namespace, context.scope).select{|p| p.name == word}
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source/change.rb

@@ -3,6 +3,8 @@ module Solargraph
     # A change to be applied to text.
     #
     class Change
+      include EncodingFixes
+
       # @return [Range]
       attr_reader :range
 
@@ -68,7 +70,7 @@ module Solargraph
       def commit text, insert
         start_offset = Position.to_offset(text, range.start)
         end_offset = Position.to_offset(text, range.ending)
-        (start_offset == 0 ? '' : text[0..start_offset-1].to_s) + insert.force_encoding('utf-8') + text[end_offset..-1].to_s
+        (start_offset == 0 ? '' : text[0..start_offset-1].to_s) + normalize(insert) + text[end_offset..-1].to_s
       end
     end
   end

data/lib/solargraph/{api_map → source}/completion.rb

@@ -1,5 +1,5 @@
 module Solargraph
-  class ApiMap
+  class Source
     # The result of a completion request containing the pins that describe
     # completion options and the range to be replaced.
     #
@@ -10,6 +10,8 @@ module Solargraph
       # @return [Solargraph::Source::Range]
       attr_reader :range
 
+      # @param pins [Array<Solargraph::Pin::Base>]
+      # @param range [Solargraph::Source::Range]
       def initialize pins, range
         @pins = pins
         @range = range

data/lib/solargraph/source/encoding_fixes.rb

@@ -0,0 +1,21 @@
+module Solargraph
+  class Source
+    module EncodingFixes
+      module_function
+
+      # Convert strings to normalized UTF-8.
+      #
+      # @param string [String]
+      # @return [String]
+      def normalize string
+        begin
+          string.force_encoding('UTF-8')
+        rescue ::Encoding::CompatibilityError, ::Encoding::UndefinedConversionError, ::Encoding::InvalidByteSequenceError => e
+          # @todo Improve error handling
+          STDERR.puts "Normalize error: #{e.message}"
+          string
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source/fragment.rb

@@ -79,114 +79,63 @@ module Solargraph
         @scope
       end
 
-      # Get the signature up to the current offset. Given the text `foo.bar`,
-      # the signature at offset 5 is `foo.b`.
-      #
-      # @return [String]
-      def signature
-        @signature ||= signature_data[1].to_s
-      end
-
-      def valid?
-        @source.parsed?
-      end
-
-      def broken?
-        !valid?
-      end
-
       # Get the signature before the current word. Given the signature
       # `String.new.split`, the base is `String.new`.
       #
       # @return [String]
       def base
-        if @base.nil?
-          if signature.include?('.')
-            if signature.end_with?('.')
-              @base = signature[0..-2]
-            else
-              @base = signature.split('.')[0..-2].join('.')
-            end
-          elsif signature.include?('::')
-            if signature.end_with?('::')
-              @base = signature[0..-3]
-            else
-              @base = signature.split('::')[0..-2].join('::')
-            end
-          else
-            # @base = signature
-            @base = ''
-          end
-        end
-        @base
-      end
-
-      # @return [String]
-      def root
-        @root ||= signature.split('.').first
+        chain.links[0..-2].map(&:word).join('.')
       end
 
-      # @return [String]
+      # @return [Source::Chain]
       def chain
-        @chain ||= ( signature.empty? ? '' : signature.split('.')[1..-1].join('.') )
-      end
-
-      # @return [String]
-      def base_chain
-        @base_chain ||= signature.split('.')[1..-2].join('.')
+        @chain ||= generate_chain
       end
 
+      # Get the whole signature at the current offset, including the final
+      # word and its remainder.
+      #
       # @return [String]
-      def whole_chain
-        @whole_chain ||= whole_signature.split('.')[1..-1].join('.')
+      def whole_signature
+        chain.links.reject{|l| l.word == '<undefined>'}.map(&:word).join('.')
       end
 
-      # Get the remainder of the word after the current offset. Given the text
-      # `foobar` with an offset of 3, the remainder is `bar`.
+      # Get the word before the current offset. Given the text `foo.bar`, the
+      # word at offset 6 is `ba`.
       #
       # @return [String]
-      def remainder
-        @remainder ||= remainder_at(offset)
+      def start_of_word
+        @start_of_word ||= begin
+          match = @code[0..offset-1].to_s.match(start_word_pattern)
+          result = (match ? match[0] : '')
+          result = ":#{result}" if @code[0..offset-result.length].end_with?('::') and !@code[0..offset-result.length].end_with?('::')
+          result
+        end
       end
 
-      # Get the whole word at the current offset, including the remainder.
-      # Given the text `foobar.baz`, the whole word at any offset from 0 to 6
-      # is `foobar`.
-      #
-      # @return [String]
-      def whole_word
-        @whole_word ||= word + remainder
+      def word
+        start_of_word
       end
 
-      # Get the whole signature at the current offset, including the final
-      # word and its remainder.
-      #
-      # @return [String]
-      def whole_signature
-        @whole_signature ||= signature + remainder
+      def end_of_word
+        @end_of_word ||= begin
+          match = @code[offset..-1].to_s.match(end_word_pattern)
+          match ? match[0] : ''
+        end
       end
 
-      # Get the entire phrase up to the current offset. Given the text
-      # `foo[bar].baz()`, the phrase at offset 10 is `foo[bar].b`.
-      #
-      # @return [String]
-      def phrase
-        @phrase ||= @code[signature_data[0]..offset]
+      def remainder
+        end_of_word
       end
 
-      # Get the word before the current offset. Given the text `foo.bar`, the
-      # word at offset 6 is `ba`.
-      #
-      # @return [String]
-      def word
-        @word ||= word_at(offset)
+      def whole_word
+        start_of_word + end_of_word
       end
 
       # True if the current offset is inside a string.
       #
       # @return [Boolean]
       def string?
-        # @string ||= (node.type == :str or node.type == :dstr)
         @string ||= @source.string_at?(line, character)
       end
 
@@ -194,22 +143,15 @@ module Solargraph
       #
       # @return [Boolean]
       def comment?
-        @comment ||= check_comment(line, column)
-      end
-
-      # Get the range of the word up to the current offset.
-      #
-      # @return [Range]
-      def word_range
-        @word_range ||= word_range_at(offset, false)
+        @comment ||= @source.comment_at?(line, column)
       end
 
       # Get the range of the whole word at the current offset, including its
       # remainder.
       #
       # @return [Range]
-      def whole_word_range
-        @whole_word_range ||= word_range_at(offset, true)
+      def word_range
+        @word_range ||= word_range_at(offset - start_of_word.length, offset + end_of_word.length)
       end
 
       # @return [Solargraph::Pin::Base]
@@ -222,30 +164,13 @@ module Solargraph
         @named_path ||= @source.locate_named_path_pin(line, character)
       end
 
+      # Get an array of all the locals that are visible from the fragment's
+      # position. Locals can be local variables, method parameters, or block
+      # parameters. The array starts with the nearest local pin.
+      #
       # @return [Array<Solargraph::Pin::Base>]
       def locals
-        @locals ||= @source.locals.select{|pin| pin.visible_from?(block, position)}
-      end
-
-      # True if the fragment is a signature that stems from a literal value.
-      #
-      # @return [Boolean]
-      def base_literal?
-        !base_literal.nil?
-      end
-
-      # The type of literal value at the root of the signature (or nil).
-      #
-      # @return [String]
-      def base_literal
-        if @base_literal.nil? and !@calculated_literal
-          @calculated_literal = true
-          if signature.start_with?('.')
-            pn = @source.node_at(line, column - 2)
-            @base_literal = infer_literal_node_type(pn) unless pn.nil?
-          end
-        end
-        @base_literal
+        @locals ||= @source.locals.select{|pin| pin.visible_from?(block, position)}.reverse
       end
 
       # True if the fragment is inside a literal value.
@@ -267,6 +192,70 @@ module Solargraph
         end
       end
 
+      # Get a set of available completions for the specified fragment. The
+      # resulting Completion object contains an array of pins and the range of
+      # text to replace in the source.
+      #
+      # @param api_map [ApiMap]
+      # @return [Completion]
+      def complete api_map
+        return Completion.new([], word_range) if chain.literal? or comment?
+        result = []
+        type = infer_base_type(api_map)
+        if chain.tail.constant?
+          result.concat api_map.get_constants(type.namespace, namespace)
+        else
+          result.concat api_map.get_complex_type_methods(type, namespace, chain.links.length == 1)
+          if chain.links.length == 1
+            if word.start_with?('@@')
+              return package_completions(api_map.get_class_variable_pins(namespace))
+            elsif word.start_with?('@')
+              return package_completions(api_map.get_instance_variable_pins(namespace, scope))
+            elsif word.start_with?('$')
+              return package_completions(api_map.get_global_variable_pins)
+            elsif word.start_with?(':') and !word.start_with?('::')
+              return package_completions(api_map.get_symbols)
+            end
+            result.concat api_map.get_constants('', namespace)
+            result.concat prefer_non_nil_variables(locals)
+            result.concat api_map.get_methods(namespace, scope: scope, visibility: [:public, :private, :protected])
+            result.concat api_map.get_methods('Kernel')
+            result.concat ApiMap.keywords
+          end
+        end
+        package_completions(result)
+      end
+
+      def define api_map
+        return [] if chain.literal?
+        return [] if string? or comment? or literal?
+        # HACK: Checking for self first because it's also a keyword
+        return [] if ApiMap::KEYWORDS.include?(chain.links.first.word) and chain.links.first.word != 'self'
+        chain.define_with(api_map, named_path, locals)
+      end
+
+      # Get an array of pins that describe the method being called by the
+      # argument list where the fragment is located. This is useful for queries
+      # that need to know what parameters the current method expects to receive.
+      #
+      # If the fragment is not inside an argument list, return an empty array.
+      #
+      # @param api_map [Solargraph::Source::Fragment]
+      # @return [Array<Solargraph::Pin::Base>]
+      def signify api_map
+        return [] unless argument?
+        return [] if recipient.whole_signature.nil? or recipient.whole_signature.empty?
+        result = []
+        result.concat recipient.define(api_map)
+        result.select{ |pin| pin.kind == Pin::METHOD }
+      end
+
+      # @param api_map [ApiMap]
+      # @return [ComplexType]
+      def infer_base_type api_map
+        chain.infer_base_type_with(api_map, named_path, locals)
+      end
+
       private
 
       # @return [Integer]
@@ -283,175 +272,11 @@ module Solargraph
         [pos.line, pos.character]
       end
 
-      def signature_data
-        @signature_data ||= get_signature_data_at(offset)
-      end
-
-      def get_signature_data_at index
-        brackets = 0
-        squares = 0
-        parens = 0
-        signature = ''
-        index -=1
-        in_whitespace = false
-        while index >= 0
-          pos = Position.from_offset(@code, index)
-          break if index > 0 and check_comment(pos.line, pos.character)
-          unless !in_whitespace and string?
-            break if brackets > 0 or parens > 0 or squares > 0
-            char = @code[index, 1]
-            break if char.nil? # @todo Is this the right way to handle this?
-            if brackets.zero? and parens.zero? and squares.zero? and [' ', "\r", "\n", "\t"].include?(char)
-              in_whitespace = true
-            else
-              if brackets.zero? and parens.zero? and squares.zero? and in_whitespace
-                unless char == '.' or @code[index+1..-1].strip.start_with?('.')
-                  old = @code[index+1..-1]
-                  nxt = @code[index+1..-1].lstrip
-                  index += (@code[index+1..-1].length - @code[index+1..-1].lstrip.length)
-                  break
-                end
-              end
-              if char == ')'
-                parens -=1
-              elsif char == ']'
-                squares -=1
-              elsif char == '}'
-                brackets -= 1
-              elsif char == '('
-                parens += 1
-              elsif char == '{'
-                brackets += 1
-              elsif char == '['
-                squares += 1
-                signature = ".[]#{signature}" if parens.zero? and brackets.zero? and squares.zero? and @code[index-2] != '%'
-              end
-              if brackets.zero? and parens.zero? and squares.zero?
-                break if ['"', "'", ',', ';', '%'].include?(char)
-                signature = char + signature if char.match(/[a-z0-9:\._@\$\?\!]/i) and @code[index - 1] != '%'
-                break if char == '$'
-                if char == '@'
-                  signature = "@#{signature}" if @code[index-1, 1] == '@'
-                  break
-                end
-              end
-              in_whitespace = false
-            end
-          end
-          index -= 1
-        end
-        # @todo Smelly exceptional case for integer literals
-        match = signature.match(/^[0-9]+/)
-        if match
-          index += match[0].length
-          signature = signature[match[0].length..-1].to_s
-          @base_literal = 'Integer'
-        # @todo Smelly exceptional case for array literals
-        elsif signature.start_with?('.[]')
-          index += 2
-          signature = signature[3..-1].to_s
-          @base_literal = 'Array'
-        elsif signature.start_with?('.')
-          pos = Position.from_offset(source.code, index)
-          node = source.node_at(pos.line, pos.character)
-          lit = infer_literal_node_type(node)
-          unless lit.nil?
-            signature = signature[1..-1].to_s
-            index += 1
-            @base_literal = lit
-          end
-        end
-        [index + 1, signature]
-      end
-
-      # Determine if the specified location is inside a comment.
-      #
-      # @param lin [Integer]
-      # @param col [Integer]
-      # @return [Boolean]
-      def check_comment(lin, col)
-        index = Position.line_char_to_offset(source_from_parser, lin, col)
-        @source.comments.each do |c|
-          return true if index > c.location.expression.begin_pos and index <= c.location.expression.end_pos
-        end
-        false
-      end
-
-      # True if the line and column are inside the specified range.
-      #
-      # @param location [Parser::Source::Range]
-      def compare_range line, column, location
-        return true if line == location.first_line and line == location.last_line and column >= location.column and column < location.last_column
-        return true if line > location.first_line and line < location.last_line
-        return true if line == location.last_line and column >= location.last_column and column < location.last_column
-        false
-      end
-
-      # Select the word that directly precedes the specified index.
-      # A word can only consist of letters, numbers, and underscores.
-      #
-      # @param index [Integer]
-      # @return [String]
-      def word_at index
-        @code[beginning_of_word_at(index)..index - 1].to_s
-      end
-
-      def beginning_of_word_at index
-        cursor = index - 1
-        # Words can end with ? or !
-        if @code[cursor, 1] == '!' or @code[cursor, 1] == '?'
-          cursor -= 1
-        end
-        while cursor > -1
-          char = @code[cursor, 1]
-          break if char.nil? or char.strip.empty?
-          break unless char.match(/[a-z0-9_]/i)
-          cursor -= 1
-        end
-        # Words can begin with @@, @, $, or :
-        if cursor > -1
-          if cursor > 0 and @code[cursor - 1, 2] == '@@'
-            cursor -= 2
-          elsif @code[cursor, 1] == '@' or @code[cursor, 1] == '$'
-            cursor -= 1
-          elsif @code[cursor, 1] == ':' and (cursor == 0 or @code[cursor - 1, 2] != '::')
-            cursor -= 1
-          end
-        end
-        cursor + 1
-      end
-
       # @return Solargraph::Source::Range
-      def word_range_at index, whole
-        cursor = beginning_of_word_at(index)
-        start_offset = cursor
-        start_offset -= 1 if (start_offset > 1 and @code[start_offset - 1] == ':') and (start_offset == 1 or @code[start_offset - 2] != ':')
-        cursor = index
-        if whole
-          while cursor < @code.length
-            char = @code[cursor, 1]
-            break if char.nil? or char == ''
-            break unless char.match(/[a-z0-9_\?\!]/i)
-            cursor += 1
-          end
-        end
-        end_offset = cursor
-        end_offset = start_offset if end_offset < start_offset
-        start_pos = get_position_at(start_offset)
-        end_pos = get_position_at(end_offset)
-        Solargraph::Source::Range.from_to(start_pos[0], start_pos[1], end_pos[0], end_pos[1])
-      end
-
-      # @return [String]
-      def remainder_at index
-        cursor = index
-        while cursor < @code.length
-          char = @code[cursor, 1]
-          break if char.nil? or char == ''
-          break unless char.match(/[a-z0-9_\?\!]/i)
-          cursor += 1
-        end
-        @code[index..cursor-1].to_s
+      def word_range_at first, last
+        s = Position.from_offset(@source.code, first)
+        e = Position.from_offset(@source.code, last)
+        Solargraph::Source::Range.new(s, e)
       end
 
       def signature_position
@@ -475,12 +300,42 @@ module Solargraph
         @signature_position
       end
 
-      # Range tests that depend on positions identified from parsed code, such
-      # as comment ranges, need to normalize EOLs to \n.
+      def generate_chain
+        CallChainer.chain(source, line, column)
+      end
+
+      def start_word_pattern
+        /(@{1,2}|\$)?([a-z0-9_]|[^\u0000-\u007F])*\z/i
+      end
+
+      def end_word_pattern
+        /^([a-z0-9_]|[^\u0000-\u007F])*[\?\!]?/i
+      end
+
+      # @param fragment [Source::Fragment]
+      # @param result [Array<Pin::Base>]
+      # @return [Completion]
+      def package_completions result
+        frag_start = word.to_s.downcase
+        filtered = result.uniq(&:identifier).select{|s| s.name.downcase.start_with?(frag_start) and (s.kind != Pin::METHOD or s.name.match(/^[a-z0-9_]+(\!|\?|=)?$/i))}.sort_by.with_index{ |x, idx| [x.name, idx] }
+        Completion.new(filtered, word_range)
+      end
+
+      # Sort an array of pins to put nil or undefined variables last.
       #
-      # @return [String]
-      def source_from_parser
-        @source_from_parser ||= @source.code.gsub(/\r\n/, "\n")
+      # @param pins [Array<Solargraph::Pin::Base>]
+      # @return [Array<Solargraph::Pin::Base>]
+      def prefer_non_nil_variables pins
+        result = []
+        nil_pins = []
+        pins.each do |pin|
+          if pin.variable? and pin.nil_assignment?
+            nil_pins.push pin
+          else
+            result.push pin
+          end
+        end
+        result + nil_pins
       end
     end
   end