solargraph 0.47.2 → 0.53.3

data/lib/solargraph/type_checker.rb

@@ -22,7 +22,7 @@ module Solargraph
     attr_reader :api_map
 
     # @param filename [String]
-    # @param api_map [ApiMap]
+    # @param api_map [ApiMap, nil]
     # @param level [Symbol]
     def initialize filename, api_map: nil, level: :normal
       @filename = filename
@@ -51,6 +51,7 @@ module Solargraph
 
     class << self
       # @param filename [String]
+      # @param level [Symbol]
       # @return [self]
       def load filename, level = :normal
         source = Solargraph::Source.load(filename)
@@ -61,6 +62,7 @@ module Solargraph
 
       # @param code [String]
       # @param filename [String, nil]
+      # @param level [Symbol]
       # @return [self]
       def load_string code, filename = nil, level = :normal
         source = Solargraph::Source.load_string(code, filename)
@@ -91,7 +93,12 @@ module Solargraph
       declared = pin.typify(api_map).self_to(pin.full_context.namespace)
       if declared.undefined?
         if pin.return_type.undefined? && rules.require_type_tags?
-          result.push Problem.new(pin.location, "Missing @return tag for #{pin.path}", pin: pin)
+          if pin.attribute?
+            inferred = pin.probe(api_map).self_to(pin.full_context.namespace)
+            result.push Problem.new(pin.location, "Missing @return tag for #{pin.path}", pin: pin) unless inferred.defined?
+          else
+            result.push Problem.new(pin.location, "Missing @return tag for #{pin.path}", pin: pin)
+          end
         elsif pin.return_type.defined? && !resolved_constant?(pin)
           result.push Problem.new(pin.location, "Unresolved return type #{pin.return_type} for #{pin.path}", pin: pin)
         elsif rules.must_tag_or_infer? && pin.probe(api_map).undefined?
@@ -120,14 +127,17 @@ module Solargraph
     # @param pin [Pin::Base]
     # @return [Boolean]
     def resolved_constant? pin
-      api_map.get_constants('', pin.binder.tag)
-        .select { |p| p.name == pin.return_type.namespace }
-        .any? do |p|
-          inferred = p.infer(api_map)
-          ['Class', 'Module'].include?(inferred.name)
-        end
+      return true if pin.typify(api_map).defined?
+      constant_pins = api_map.get_constants('', *pin.closure.gates)
+               .select { |p| p.name == pin.return_type.namespace }
+      return true if constant_pins.find { |p| p.typify(api_map).defined? }
+      # will need to probe when a constant name is assigned to a
+      # class/module (alias)
+      return true if constant_pins.find { |p| p.probe(api_map).defined? }
+      false
     end
 
+    # @param pin [Pin::Base]
     def virtual_pin? pin
       pin.location && source_map.source.comment_at?(pin.location.range.ending)
     end
@@ -139,14 +149,27 @@ module Solargraph
       params = first_param_hash(stack)
       result = []
       if rules.require_type_tags?
-        pin.parameters.each do |par|
-          break if par.decl == :restarg || par.decl == :kwrestarg || par.decl == :blockarg
-          unless params[par.name]
-            result.push Problem.new(pin.location, "Missing @param tag for #{par.name} on #{pin.path}", pin: pin)
+        pin.signatures.each do |sig|
+          sig.parameters.each do |par|
+            break if par.decl == :restarg || par.decl == :kwrestarg || par.decl == :blockarg
+            unless params[par.name]
+              if pin.attribute?
+                inferred = pin.probe(api_map).self_to(pin.full_context.namespace)
+                if inferred.undefined?
+                  result.push Problem.new(pin.location, "Missing @param tag for #{par.name} on #{pin.path}", pin: pin)
+                end
+              else
+                result.push Problem.new(pin.location, "Missing @param tag for #{par.name} on #{pin.path}", pin: pin)
+              end
+            end
           end
         end
       end
+      # @todo Should be able to probe type of name and data here
+      # @param name [String]
+      # @param data [Hash{Symbol => BasicObject}]
       params.each_pair do |name, data|
+        # @type [ComplexType]
         type = data[:qualified]
         if type.undefined?
           result.push Problem.new(pin.location, "Unresolved type #{data[:tagged]} for #{name} param on #{pin.path}", pin: pin)
@@ -155,6 +178,7 @@ module Solargraph
       result
     end
 
+    # @return [Array<Pin::Base>]
     def ignored_pins
       @ignored_pins ||= []
     end
@@ -184,7 +208,7 @@ module Solargraph
             elsif declared_externally?(pin)
               ignored_pins.push pin
             end
-          elsif !pin.is_a?(Pin::Parameter)
+          elsif !pin.is_a?(Pin::Parameter) && !resolved_constant?(pin)
             result.push Problem.new(pin.location, "Unresolved type #{pin.return_type} for variable #{pin.name}", pin: pin)
           end
         else
@@ -202,6 +226,7 @@ module Solargraph
       source_map.pins_by_class(Pin::BaseVariable) + source_map.locals.select { |pin| pin.is_a?(Pin::LocalVariable) }
     end
 
+    # @return [Array<Problem>]
     def const_problems
       return [] unless rules.validate_consts?
       result = []
@@ -220,6 +245,7 @@ module Solargraph
       result
     end
 
+    # @return [Array<Problem>]
     def call_problems
       result = []
       Solargraph::Parser::NodeMethods.call_nodes_from(source_map.source.node).each do |call|
@@ -243,7 +269,7 @@ module Solargraph
           end
           closest = found.typify(api_map) if found
           if !found || found.is_a?(Pin::BaseVariable) || (closest.defined? && internal_or_core?(found))
-            unless ignored_pins.include?(found)
+            unless closest.generic? || ignored_pins.include?(found)
               result.push Problem.new(location, "Unresolved call to #{missing.links.last.word}")
               @marked_ranges.push rng
             end
@@ -254,16 +280,33 @@ module Solargraph
       result
     end
 
+    # @param chain [Solargraph::Source::Chain]
+    # @param api_map [Solargraph::ApiMap]
+    # @param block_pin [Solargraph::Pin::Base]
+    # @param locals [Array<Solargraph::Pin::Base>]
+    # @param location [Solargraph::Location]
+    # @return [Array<Problem>]
     def argument_problems_for chain, api_map, block_pin, locals, location
       result = []
       base = chain
       until base.links.length == 1 && base.undefined?
         pins = base.define(api_map, block_pin, locals)
-        if pins.first.is_a?(Pin::Method)
+
+        if pins.first.is_a?(Pin::DelegatedMethod) && !pins.first.resolvable?(api_map)
+          # Do nothing, as we can't find the actual method implementation
+        elsif pins.first.is_a?(Pin::Method)
           # @type [Pin::Method]
           pin = pins.first
           ap = if base.links.last.is_a?(Solargraph::Source::Chain::ZSuper)
             arity_problems_for(pin, fake_args_for(block_pin), location)
+          elsif pin.path == 'Class#new'
+            fqns = if base.links.one?
+              block_pin.namespace
+            else
+              base.base.infer(api_map, block_pin, locals).namespace
+            end
+            init = api_map.get_method_stack(fqns, 'initialize').first
+            init ? arity_problems_for(init, base.links.last.arguments, location) : []
           else
             arity_problems_for(pin, base.links.last.arguments, location)
           end
@@ -271,71 +314,119 @@ module Solargraph
             result.concat ap
             break
           end
-          break unless rules.validate_calls?
+          break if !rules.validate_calls? || base.links.first.is_a?(Solargraph::Source::Chain::ZSuper)
+
           params = first_param_hash(pins)
-          pin.parameters.each_with_index do |par, idx|
-            argchain = base.links.last.arguments[idx]
-            if argchain.nil? && par.decl == :arg
-              result.push Problem.new(location, "Not enough arguments to #{pin.path}")
-              break
-            end
-            if argchain
-              if par.decl != :arg
-                result.concat kwarg_problems_for argchain, api_map, block_pin, locals, location, pin, params, idx
-                break
-              else
-                ptype = params.key?(par.name) ? params[par.name][:qualified] : ComplexType::UNDEFINED
-                if ptype.nil?
-                  # @todo Some level (strong, I guess) should require the param here
+
+          all_errors = []
+          pin.signatures.sort { |sig| sig.parameters.length }.each do |sig|
+            errors = []
+            # @todo these should be able to be probed
+            # @param par [Parameter]
+            # @param idx [Integer]
+            sig.parameters.each_with_index do |par, idx|
+              argchain = base.links.last.arguments[idx]
+              if argchain.nil?
+                if par.decl == :arg
+                  last = base.links.last.arguments.last
+                  if last && last.node.type == :splat
+                    argchain = last
+                    next # don't try to apply the type of the splat - unlikely to be specific enough
+                  else
+                    errors.push Problem.new(location, "Not enough arguments to #{pin.path}")
+                    next
+                  end
+                else
+                  last = base.links.last.arguments.last
+                  argchain = last if last && [:kwsplat, :hash].include?(last.node.type)
+                end
+              end
+              if argchain
+                if par.decl != :arg
+                  errors.concat kwarg_problems_for sig, argchain, api_map, block_pin, locals, location, pin, params, idx
+                  next
                 else
-                  argtype = argchain.infer(api_map, block_pin, locals)
-                  if argtype.defined? && ptype.defined? && !any_types_match?(api_map, ptype, argtype)
-                    result.push Problem.new(location, "Wrong argument type for #{pin.path}: #{par.name} expected #{ptype}, received #{argtype}")
+                  last = base.links.last.arguments.last
+                  if last && last.node.type == :splat
+                    next # don't try to apply the type of the splat - unlikely to be specific enough
+                  end
+                  ptype = params.key?(par.name) ? params[par.name][:qualified] : ComplexType::UNDEFINED
+                  ptype = ptype.self_to(par.context.namespace)
+                  if ptype.nil?
+                    # @todo Some level (strong, I guess) should require the param here
+                  else
+                    argtype = argchain.infer(api_map, block_pin, locals)
+                    if argtype.defined? && ptype.defined? && !any_types_match?(api_map, ptype, argtype)
+                      errors.push Problem.new(location, "Wrong argument type for #{pin.path}: #{par.name} expected #{ptype}, received #{argtype}")
+                      next
+                    end
                   end
                 end
+              elsif par.decl == :kwarg
+                errors.push Problem.new(location, "Call to #{pin.path} is missing keyword argument #{par.name}")
+                next
               end
-            elsif par.rest?
-              next
-            elsif par.decl == :kwarg
-              result.push Problem.new(location, "Call to #{pin.path} is missing keyword argument #{par.name}")
+            end
+            if errors.empty?
+              all_errors.clear
               break
             end
+            all_errors.concat errors
           end
+          result.concat all_errors
         end
         base = base.base
       end
       result
     end
 
-    def kwarg_problems_for argchain, api_map, block_pin, locals, location, pin, params, first
+    # @param sig [Pin::Signature]
+    # @param argchain [Source::Chain]
+    # @param api_map [ApiMap]
+    # @param block_pin [Pin::Block]
+    # @param locals [Array<Pin::LocalVariable>]
+    # @param location [Location]
+    # @param pin [Pin::Method]
+    # @param params [Hash{String => [nil, Hash]}]
+    # @param idx [Integer]
+    #
+    # @return [Array<Problem>]
+    def kwarg_problems_for sig, argchain, api_map, block_pin, locals, location, pin, params, idx
       result = []
       kwargs = convert_hash(argchain.node)
-      pin.parameters[first..-1].each_with_index do |par, cur|
-        idx = first + cur
-        argchain = kwargs[par.name.to_sym]
-        if par.decl == :kwrestarg || (par.decl == :optarg && idx == pin.parameters.length - 1 && par.asgn_code == '{}')
-          result.concat kwrestarg_problems_for(api_map, block_pin, locals, location, pin, params, kwargs)
-        else
-          if argchain
-            data = params[par.name]
-            if data.nil?
-              # @todo Some level (strong, I guess) should require the param here
-            else
-              ptype = data[:qualified]
-              next if ptype.undefined?
+      par = sig.parameters[idx]
+      argchain = kwargs[par.name.to_sym]
+      if par.decl == :kwrestarg || (par.decl == :optarg && idx == pin.parameters.length - 1 && par.asgn_code == '{}')
+        result.concat kwrestarg_problems_for(api_map, block_pin, locals, location, pin, params, kwargs)
+      else
+        if argchain
+          data = params[par.name]
+          if data.nil?
+            # @todo Some level (strong, I guess) should require the param here
+          else
+            ptype = data[:qualified]
+            unless ptype.undefined?
               argtype = argchain.infer(api_map, block_pin, locals)
               if argtype.defined? && ptype && !any_types_match?(api_map, ptype, argtype)
                 result.push Problem.new(location, "Wrong argument type for #{pin.path}: #{par.name} expected #{ptype}, received #{argtype}")
               end
             end
-          elsif par.decl == :kwarg
-            result.push Problem.new(location, "Call to #{pin.path} is missing keyword argument #{par.name}")
           end
+        elsif par.decl == :kwarg
+          result.push Problem.new(location, "Call to #{pin.path} is missing keyword argument #{par.name}")
         end
       end
       result
     end
 
+    # @param api_map [ApiMap]
+    # @param block_pin [Pin::Block]
+    # @param locals [Array<Pin::LocalVariable>]
+    # @param location [Location]
+    # @param pin [Pin::Method]
+    # @param params [Hash{String => [nil, Hash]}]
+    # @param kwargs [Hash{Symbol => Source::Chain}]
+    # @return [Array<Problem>]
     def kwrestarg_problems_for(api_map, block_pin, locals, location, pin, params, kwargs)
       result = []
       kwargs.each_pair do |pname, argchain|
@@ -349,8 +440,8 @@ module Solargraph
       result
     end
 
-    # @param [Pin::Method]
-    # @return [Hash]
+    # @param pin [Pin::Method]
+    # @return [Hash{String => Hash{Symbol => BaseObject}}]
     def param_hash(pin)
       tags = pin.docstring.tags(:param)
       return {} if tags.empty?
@@ -365,10 +456,12 @@ module Solargraph
       result
     end
 
-    # @param [Array<Pin::Method>]
-    # @return [Hash]
+    # @param pins [Array<Pin::Method>]
+    # @return [Hash{String => Hash{Symbol => BasicObject}}]
     def first_param_hash(pins)
       pins.each do |pin|
+        # @todo this assignment from parametric use of Hash should not lose its generic
+        # @type [Hash{String => Hash{Symbol => BasicObject}]
         result = param_hash(pin)
         return result unless result.empty?
       end
@@ -381,8 +474,11 @@ module Solargraph
       pin.location && api_map.bundled?(pin.location.filename)
     end
 
+    # True if the pin is either internal (part of the workspace) or from the core/stdlib
+    # @param pin [Pin::Base]
     def internal_or_core? pin
-      internal?(pin) || api_map.yard_map.core_pins.include?(pin) || api_map.yard_map.stdlib_pins.include?(pin)
+      # @todo RBS pins are not necessarily core/stdlib pins
+      internal?(pin) || pin.source == :rbs
     end
 
     # @param pin [Pin::Base]
@@ -390,6 +486,7 @@ module Solargraph
       !internal? pin
     end
 
+    # @param pin [Pin::Base]
     def declared_externally? pin
       return true if pin.assignment.nil?
       chain = Solargraph::Parser.chain(pin.assignment, filename)
@@ -418,41 +515,44 @@ module Solargraph
     end
 
     # @param pin [Pin::Method]
-    def arity_problems_for(pin, arguments, location)
-      ([pin] + pin.overloads).map do |p|
-        result = pin_arity_problems_for(p, arguments, location)
-        return [] if result.empty?
-        result
-      end.flatten.uniq(&:message)
+    # @param arguments [Array<Source::Chain>]
+    # @param location [Location]
+    # @return [Array<Problem>]
+    def arity_problems_for pin, arguments, location
+      results = pin.signatures.map do |sig|
+        r = parameterized_arity_problems_for(pin, sig.parameters, arguments, location)
+        return [] if r.empty?
+        r
+      end
+      results.first
     end
 
     # @param pin [Pin::Method]
-    def pin_arity_problems_for(pin, arguments, location)
+    # @param parameters [Array<Pin::Parameter>]
+    # @param arguments [Array<Source::Chain>]
+    # @param location [Location]
+    # @return [Array<Problem>]
+    def parameterized_arity_problems_for(pin, parameters, arguments, location)
       return [] unless pin.explicit?
-      return [] if pin.parameters.empty? && arguments.empty?
-      if pin.parameters.empty?
-        # Functions tagged param_tuple accepts two arguments (e.g., Hash#[]=)
-        return [] if pin.docstring.tag(:param_tuple) && arguments.length == 2
-        return [] if arguments.length == 1 && arguments.last.links.last.is_a?(Source::Chain::BlockVariable)
-        return [Problem.new(location, "Too many arguments to #{pin.path}")]
-      end
+      return [] if parameters.empty? && arguments.empty?
+      return [] if pin.anon_splat?
       unchecked = arguments.clone
       add_params = 0
-      if unchecked.empty? && pin.parameters.any? { |param| param.decl == :kwarg }
+      if unchecked.empty? && parameters.any? { |param| param.decl == :kwarg }
         return [Problem.new(location, "Missing keyword arguments to #{pin.path}")]
       end
       settled_kwargs = 0
       unless unchecked.empty?
         if any_splatted_call?(unchecked.map(&:node))
-          settled_kwargs = pin.parameters.count(&:keyword?)
+          settled_kwargs = parameters.count(&:keyword?)
         else
           kwargs = convert_hash(unchecked.last.node)
-          if pin.parameters.any? { |param| [:kwarg, :kwoptarg].include?(param.decl) || param.kwrestarg? }
+          if parameters.any? { |param| [:kwarg, :kwoptarg].include?(param.decl) || param.kwrestarg? }
             if kwargs.empty?
               add_params += 1
             else
               unchecked.pop
-              pin.parameters.each do |param|
+              parameters.each do |param|
                 next unless param.keyword?
                 if kwargs.key?(param.name.to_sym)
                   kwargs.delete param.name.to_sym
@@ -462,7 +562,7 @@ module Solargraph
                   return [Problem.new(location, "Missing keyword argument #{param.name} to #{pin.path}")]
                 end
               end
-              kwargs.clear if pin.parameters.any?(&:kwrestarg?)
+              kwargs.clear if parameters.any?(&:kwrestarg?)
               unless kwargs.empty?
                 return [Problem.new(location, "Unrecognized keyword argument #{kwargs.keys.first} to #{pin.path}")]
               end
@@ -470,18 +570,15 @@ module Solargraph
           end
         end
       end
-      req = required_param_count(pin)
+      req = required_param_count(parameters)
       if req + add_params < unchecked.length
-        return [] if pin.parameters.any?(&:rest?)
-        opt = optional_param_count(pin)
+        return [] if parameters.any?(&:rest?)
+        opt = optional_param_count(parameters)
         return [] if unchecked.length <= req + opt
-        if unchecked.length == req + opt + 1 && unchecked.last.links.last.is_a?(Source::Chain::BlockVariable)
-          return []
-        end
-        if req + add_params + 1 == unchecked.length && any_splatted_call?(unchecked.map(&:node)) && (pin.parameters.map(&:decl) & [:kwarg, :kwoptarg, :kwrestarg]).any?
+        if req + add_params + 1 == unchecked.length && any_splatted_call?(unchecked.map(&:node)) && (parameters.map(&:decl) & [:kwarg, :kwoptarg, :kwrestarg]).any?
           return []
         end
-        return [] if arguments.length - req == pin.parameters.select { |p| [:optarg, :kwoptarg].include?(p.decl) }.length
+        return [] if arguments.length - req == parameters.select { |p| [:optarg, :kwoptarg].include?(p.decl) }.length
         return [Problem.new(location, "Too many arguments to #{pin.path}")]
       elsif unchecked.length < req - settled_kwargs && (arguments.empty? || (!arguments.last.splat? && !arguments.last.links.last.is_a?(Solargraph::Source::Chain::Hash)))
         # HACK: Kernel#raise signature is incorrect in Ruby 2.7 core docs.
@@ -493,26 +590,30 @@ module Solargraph
       []
     end
 
-    # @param pin [Pin::Method]
-    def required_param_count(pin)
-      pin.parameters.sum { |param| %i[arg kwarg].include?(param.decl) ? 1 : 0 }
+    # @param parameters [Enumerable<Pin::Parameter>]
+    # @todo need to use generic types in method to choose correct
+    #   signature and generate Integer as return type
+    # @sg-ignore
+    # @return [Integer]
+    def required_param_count(parameters)
+      parameters.sum { |param| %i[arg kwarg].include?(param.decl) ? 1 : 0 }
     end
 
+    # @param parameters [Enumerable<Pin::Parameter>]
     # @param pin [Pin::Method]
-    def optional_param_count(pin)
-      count = 0
-      pin.parameters.each do |param|
-        next unless param.decl == :optarg
-        count += 1
-      end
-      count
+    # @return [Integer]
+    def optional_param_count(parameters)
+      parameters.select { |p| p.decl == :optarg }.length
     end
 
+    # @param pin [Pin::Method]
     def abstract? pin
-      pin.docstring.has_tag?(:abstract) ||
-        (pin.closure && pin.closure.docstring.has_tag?(:abstract))
+      pin.docstring.has_tag?('abstract') ||
+        (pin.closure && pin.closure.docstring.has_tag?('abstract'))
     end
 
+    # @param pin [Pin::Base]
+    # @return [Array<Source::Chain>]
     def fake_args_for(pin)
       args = []
       with_opts = false
@@ -533,10 +634,12 @@ module Solargraph
       args
     end
 
+    # @param problems [Array<Problem>]
+    # @return [Array<Problem>]
     def without_ignored problems
       problems.reject do |problem|
         node = source_map.source.node_at(problem.location.range.start.line, problem.location.range.start.column)
-        source_map.source.comments_for(node)&.include?('@sg-ignore')
+        node && source_map.source.comments_for(node)&.include?('@sg-ignore')
       end
     end
   end

data/lib/solargraph/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Solargraph
-  VERSION = '0.47.2'
+  VERSION = '0.53.3'
 end

data/lib/solargraph/views/environment.erb

@@ -30,10 +30,10 @@
       Solargraph Version: <%= Solargraph::VERSION %>
     </li>
     <li>
-      Core Documentation Version: <%= Solargraph::YardMap::CoreDocs.best_match %>
+      Core Documentation Version: N/A <%# @todo Fix %>
     </li>
     <li>
-      Core Cache Directory: <%= Solargraph::YardMap::CoreDocs.cache_dir %>
+      Core Cache Directory: N/A <%# @todo Fix %>
     </li>
     <% unless Solargraph::Parser.rubyvm? %>
       <li>

data/lib/solargraph/workspace/config.rb

@@ -14,12 +14,12 @@ module Solargraph
       # @return [String]
       attr_reader :directory
 
-      # @return [Hash]
+      # @return [Hash{String => BasicObject}]
       attr_reader :raw_data
 
       # @param directory [String]
       def initialize directory = ''
-        @directory = directory
+        @directory = File.absolute_path(directory)
         @raw_data = config_data
         included
         excluded
@@ -41,8 +41,10 @@ module Solargraph
         @excluded ||= process_exclusions(@raw_data['exclude'])
       end
 
+      # @param filename [String]
       def allow? filename
-        filename.start_with?(directory) && 
+        filename = File.absolute_path(filename, directory)
+        filename.start_with?(directory) &&
           !excluded.include?(filename) &&
           excluded_directories.none? { |d| filename.start_with?(d) }
       end
@@ -110,7 +112,7 @@ module Solargraph
 
       # @return [String]
       def global_config_path
-        ENV['SOLARGRAPH_GLOBAL_CONFIG'] || 
+        ENV['SOLARGRAPH_GLOBAL_CONFIG'] ||
           File.join(Dir.home, '.config', 'solargraph', 'config.yml')
       end
 
@@ -120,7 +122,7 @@ module Solargraph
         File.join(@directory, '.solargraph.yml')
       end
 
-      # @return [Hash]
+      # @return [Hash{String => Array, Hash, Integer}]
       def config_data
         workspace_config = read_config(workspace_config_path)
         global_config = read_config(global_config_path)
@@ -135,15 +137,15 @@ module Solargraph
 
       # Read a .solargraph yaml config
       #
-      # @param directory [String]
-      # @return [Hash, nil]
+      # @param config_path [String]
+      # @return [Hash{String => Array, Hash, Integer}, nil]
       def read_config config_path = ''
         return nil if config_path.empty?
         return nil unless File.file?(config_path)
         YAML.safe_load(File.read(config_path))
       end
 
-      # @return [Hash]
+      # @return [Hash{String => Array, Hash, Integer}]
       def default_config
         {
           'include' => ['**/*.rb'],
@@ -171,7 +173,7 @@ module Solargraph
       # @return [Array<String>]
       def process_globs globs
         result = globs.flat_map do |glob|
-          Dir[File.join directory, glob]
+          Dir[File.absolute_path(glob, directory)]
             .map{ |f| f.gsub(/\\/, '/') }
             .select { |f| File.file?(f) }
         end
@@ -186,7 +188,7 @@ module Solargraph
       def process_exclusions globs
         remainder = globs.select do |glob|
           if glob_is_directory?(glob)
-            exdir = File.join(directory, glob_to_directory(glob))
+            exdir = File.absolute_path(glob_to_directory(glob), directory)
             included.delete_if { |file| file.start_with?(exdir) }
             false
           else
@@ -221,10 +223,11 @@ module Solargraph
         glob.gsub(/(\/\*|\/\*\*\/\*\*?)$/, '')
       end
 
+      # @return [Array<String>]
       def excluded_directories
         @raw_data['exclude']
           .select { |g| glob_is_directory?(g) }
-          .map { |g| File.join(directory, glob_to_directory(g)) }
+          .map { |g| File.absolute_path(glob_to_directory(g), directory) }
       end
     end
   end