solargraph 0.59.0.dev.1 → 0.59.0

data/lib/solargraph/type_checker.rb

@@ -52,26 +52,26 @@ module Solargraph
 
     # @param inferred [ComplexType, ComplexType::UniqueType]
     # @param expected [ComplexType, ComplexType::UniqueType]
-    def return_type_conforms_to?(inferred, expected)
+    def return_type_conforms_to? inferred, expected
       conforms_to?(inferred, expected, :return_type)
     end
 
     # @param inferred [ComplexType, ComplexType::UniqueType]
     # @param expected [ComplexType, ComplexType::UniqueType]
-    def arg_conforms_to?(inferred, expected)
+    def arg_conforms_to? inferred, expected
       conforms_to?(inferred, expected, :method_call)
     end
 
     # @param inferred [ComplexType, ComplexType::UniqueType]
     # @param expected [ComplexType, ComplexType::UniqueType]
-    def assignment_conforms_to?(inferred, expected)
+    def assignment_conforms_to? inferred, expected
       conforms_to?(inferred, expected, :assignment)
     end
 
     # @param inferred [ComplexType, ComplexType::UniqueType]
     # @param expected [ComplexType, ComplexType::UniqueType]
     # @param scenario [Symbol]
-    def conforms_to?(inferred, expected, scenario)
+    def conforms_to? inferred, expected, scenario
       rules_arr = []
       rules_arr << :allow_empty_params unless rules.require_inferred_type_params?
       rules_arr << :allow_any_match unless rules.require_all_unique_types_match_expected?
@@ -86,12 +86,12 @@ module Solargraph
     # @return [Array<Problem>]
     def problems
       @problems ||= begin
-         all = method_tag_problems
-                 .concat(variable_type_tag_problems)
-                 .concat(const_problems)
-                 .concat(call_problems)
-         unignored = without_ignored(all)
-         unignored.concat(unneeded_sgignore_problems)
+        all = method_tag_problems
+              .concat(variable_type_tag_problems)
+              .concat(const_problems)
+              .concat(call_problems)
+        unignored = without_ignored(all)
+        unignored.concat(unneeded_sgignore_problems)
       end
     end
 
@@ -148,7 +148,10 @@ module Solargraph
         if pin.return_type.undefined? && rules.require_type_tags?
           if pin.attribute?
             inferred = pin.probe(api_map).self_to_type(pin.full_context)
-            result.push Problem.new(pin.location, "Missing @return tag for #{pin.path}", pin: pin) unless inferred.defined?
+            unless inferred.defined?
+              result.push Problem.new(pin.location, "Missing @return tag for #{pin.path}",
+                                      pin: pin)
+            end
           else
             result.push Problem.new(pin.location, "Missing @return tag for #{pin.path}", pin: pin)
           end
@@ -167,7 +170,8 @@ module Solargraph
             end
           else
             unless return_type_conforms_to?(inferred, declared)
-              result.push Problem.new(pin.location, "Declared return type #{declared.rooted_tags} does not match inferred type #{inferred.rooted_tags} for #{pin.path}", pin: pin)
+              result.push Problem.new(pin.location,
+                                      "Declared return type #{declared.rooted_tags} does not match inferred type #{inferred.rooted_tags} for #{pin.path}", pin: pin)
             end
           end
         end
@@ -183,7 +187,7 @@ module Solargraph
     def resolved_constant? pin
       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 }
+                             .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)
@@ -205,19 +209,19 @@ module Solargraph
       pin.signatures.each do |sig|
         params = param_details_from_stack(sig, stack)
         if rules.require_type_tags?
-            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_type(pin.full_context)
-                  if inferred.undefined?
-                    result.push Problem.new(pin.location, "Missing @param tag for #{par.name} on #{pin.path}", pin: pin)
-                  end
-                else
+          sig.parameters.each do |par|
+            break if %i[restarg kwrestarg blockarg].include?(par.decl)
+            unless params[par.name]
+              if pin.attribute?
+                inferred = pin.probe(api_map).self_to_type(pin.full_context)
+                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
         # @param name [String]
         # @param data [Hash{Symbol => BasicObject}]
@@ -225,7 +229,8 @@ module Solargraph
           # @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)
+            result.push Problem.new(pin.location, "Unresolved type #{data[:tagged]} for #{name} param on #{pin.path}",
+                                    pin: pin)
           end
         end
       end
@@ -257,20 +262,20 @@ module Solargraph
                 end
               else
                 unless assignment_conforms_to?(inferred, declared)
-                  result.push Problem.new(pin.location, "Declared type #{declared} does not match inferred type #{inferred} for variable #{pin.name}", pin: pin)
+                  result.push Problem.new(pin.location,
+                                          "Declared type #{declared} does not match inferred type #{inferred} for variable #{pin.name}", pin: pin)
                 end
               end
             elsif declared_externally?(pin)
               ignored_pins.push pin
             end
           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)
+            result.push Problem.new(pin.location, "Unresolved type #{pin.return_type} for variable #{pin.name}",
+                                    pin: pin)
           end
         elsif pin.assignment
           inferred = pin.probe(api_map)
-          if inferred.undefined? && declared_externally?(pin)
-            ignored_pins.push pin
-          end
+          ignored_pins.push pin if inferred.undefined? && declared_externally?(pin)
         end
       end
       result
@@ -313,7 +318,6 @@ module Solargraph
         chain = Solargraph::Parser.chain(call, filename)
         # @sg-ignore Need to add nil check here
         closure_pin = source_map.locate_closure_pin(rng.start.line, rng.start.column)
-        namespace_pin = closure_pin
         if call.type == :block
           # blocks in the AST include the method call as well, so the
           # node returned by #call_nodes_from needs to be backed out
@@ -336,7 +340,6 @@ module Solargraph
           found = nil
           # @type [Array<Solargraph::Pin::Base>]
           all_found = []
-          closest = ComplexType::UNDEFINED
           until base.links.first.undefined?
             # @sg-ignore Need to add nil check here
             all_found = base.define(api_map, closure_pin, locals)
@@ -348,16 +351,13 @@ module Solargraph
           all_closest = all_found.map { |pin| pin.typify(api_map) }
           closest = ComplexType.new(all_closest.flat_map(&:items).uniq)
           # @todo remove the internal_or_core? check at a higher-than-strict level
-          if !found || found.is_a?(Pin::BaseVariable) || (closest.defined? && internal_or_core?(found))
-            # @sg-ignore Need to add nil check here
-            unless closest.generic? || ignored_pins.include?(found)
-              if closest.defined?
-                result.push Problem.new(location, "Unresolved call to #{missing.links.last.word} on #{closest}")
-              else
-                result.push Problem.new(location, "Unresolved call to #{missing.links.last.word}")
-              end
-              @marked_ranges.push rng
+          if (!found || found.is_a?(Pin::BaseVariable) || (closest.defined? && internal_or_core?(found))) && !(closest.generic? || ignored_pins.include?(found))
+            if closest.defined?
+              result.push Problem.new(location, "Unresolved call to #{missing.links.last.word} on #{closest}")
+            else
+              result.push Problem.new(location, "Unresolved call to #{missing.links.last.word}")
             end
+            @marked_ranges.push rng
           end
         end
         # @sg-ignore Need to add nil check here
@@ -407,7 +407,7 @@ module Solargraph
         return [] if !rules.validate_calls? || base.links.first.is_a?(Solargraph::Source::Chain::ZSuper)
 
         all_errors = []
-        pin.signatures.sort { |sig| sig.parameters.length }.each do |sig|
+        pin.signatures.sort_by { |sig| sig.parameters.length }.each do |sig|
           params = param_details_from_stack(sig, pins)
 
           signature_errors = signature_argument_problems_for location, locals, closure_pin, params, arguments, sig, pin
@@ -431,7 +431,6 @@ module Solargraph
     # @param arguments [Array<Source::Chain>]
     # @param sig [Pin::Signature]
     # @param pin [Pin::Method]
-    # @param pins [Array<Pin::Method>]
     #
     # @return [Array<Problem>]
     def signature_argument_problems_for location, locals, closure_pin, params, arguments, sig, pin
@@ -441,31 +440,25 @@ module Solargraph
       #   when possible, and when not, ensure provably
       #   incorrect situations are detected.
       sig.parameters.each_with_index do |par, idx|
-        return errors if par.decl == :restarg  # bail out and assume the rest is valid pending better arg processing
+        return errors if par.decl == :restarg # bail out and assume the rest is valid pending better arg processing
         argchain = arguments[idx]
         if argchain.nil?
+          final_arg = arguments.last
           if par.decl == :arg
-            final_arg = arguments.last
             if final_arg && final_arg.node.type == :splat
               argchain = final_arg
               return errors
             else
               errors.push Problem.new(location, "Not enough arguments to #{pin.path}")
             end
-          else
-            final_arg = arguments.last
-            argchain = final_arg if final_arg && [:kwsplat, :hash].include?(final_arg.node.type)
+          elsif final_arg && %i[kwsplat hash].include?(final_arg.node.type)
+            argchain = final_arg
           end
         end
         if argchain
-          if par.decl != :arg
-            errors.concat kwarg_problems_for sig, argchain, api_map, closure_pin, locals, location, pin, params, idx
-            next
-          else
-            if argchain.node.type == :splat && argchain == arguments.last
-              final_arg = argchain
-            end
-            if (final_arg && final_arg.node.type == :splat)
+          if par.decl == :arg
+            final_arg = argchain if argchain.node.type == :splat && argchain == arguments.last
+            if final_arg && final_arg.node.type == :splat
               # The final argument given has been seen and was a
               # splat, which doesn't give us useful types or
               # arities against positional parameters, so let's
@@ -485,15 +478,19 @@ module Solargraph
             ptype = params.key?(par.name) ? params[par.name][:qualified] : ComplexType::UNDEFINED
             ptype = ptype.self_to_type(par.context)
             if ptype.nil?
-            # @todo Some level (strong, I guess) should require the param here
+              # @todo Some level (strong, I guess) should require the param here
             else
               argtype = argchain.infer(api_map, closure_pin, locals)
               argtype = argtype.self_to_type(closure_pin.context)
               if argtype.defined? && ptype.defined? && !arg_conforms_to?(argtype, ptype)
-                errors.push Problem.new(location, "Wrong argument type for #{pin.path}: #{par.name} expected #{ptype}, received #{argtype}")
+                errors.push Problem.new(location,
+                                        "Wrong argument type for #{pin.path}: #{par.name} expected #{ptype}, received #{argtype}")
                 return errors
               end
             end
+          else
+            errors.concat kwarg_problems_for sig, argchain, api_map, closure_pin, locals, location, pin, params, idx
+            next
           end
         elsif par.decl == :kwarg
           errors.push Problem.new(location, "Call to #{pin.path} is missing keyword argument #{par.name}")
@@ -522,27 +519,26 @@ module Solargraph
       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, closure_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
-            # @type [ComplexType, ComplexType::UniqueType]
-            ptype = data[:qualified]
-            ptype = ptype.self_to_type(pin.context)
-            unless ptype.undefined?
-              # @type [ComplexType]
-              argtype = argchain.infer(api_map, closure_pin, locals).self_to_type(closure_pin.context)
-              # @todo Unresolved call to defined?
-              if argtype.defined? && ptype && !arg_conforms_to?(argtype, ptype)
-                result.push Problem.new(location, "Wrong argument type for #{pin.path}: #{par.name} expected #{ptype}, received #{argtype}")
-              end
+      elsif argchain
+        data = params[par.name]
+        if data.nil?
+          # @todo Some level (strong, I guess) should require the param here
+        else
+          # @type [ComplexType, ComplexType::UniqueType]
+          ptype = data[:qualified]
+          ptype = ptype.self_to_type(pin.context)
+          unless ptype.undefined?
+            # @type [ComplexType]
+            argtype = argchain.infer(api_map, closure_pin, locals).self_to_type(closure_pin.context)
+            # @todo Unresolved call to defined?
+            if argtype.defined? && ptype && !arg_conforms_to?(argtype, ptype)
+              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
       result
     end
@@ -552,20 +548,22 @@ module Solargraph
     # @param locals [Array<Pin::LocalVariable>]
     # @param location [Location]
     # @param pin [Pin::Method]
-    # @param params [Hash{String => [nil, Hash]}]
+    # @param params [Hash{String => nil, Hash}]
     # @param kwargs [Hash{Symbol => Source::Chain}]
     # @return [Array<Problem>]
-    def kwrestarg_problems_for(api_map, closure_pin, locals, location, pin, params, kwargs)
+    def kwrestarg_problems_for api_map, closure_pin, locals, location, pin, params, kwargs
       result = []
       kwargs.each_pair do |pname, argchain|
         next unless params.key?(pname.to_s)
+        # @sg-ignore
         # @type [ComplexType]
-        ptype = params[pname.to_s][:qualified]
-        ptype = ptype.self_to_type(pin.context)
+        raw_ptype = params[pname.to_s][:qualified]
+        ptype = raw_ptype.self_to_type(pin.context)
         argtype = argchain.infer(api_map, closure_pin, locals)
         argtype = argtype.self_to_type(closure_pin.context)
         if argtype.defined? && ptype && !arg_conforms_to?(argtype, ptype)
-          result.push Problem.new(location, "Wrong argument type for #{pin.path}: #{pname} expected #{ptype}, received #{argtype}")
+          result.push Problem.new(location,
+                                  "Wrong argument type for #{pin.path}: #{pname} expected #{ptype}, received #{argtype}")
         end
       end
       result
@@ -575,7 +573,7 @@ module Solargraph
     # @param pin [Pin::Method, Pin::Signature]
     # @param relevant_pin [Pin::Method, Pin::Signature] the pin which is under inspection
     # @return [void]
-    def add_restkwarg_param_tag_details(param_details, pin, relevant_pin)
+    def add_restkwarg_param_tag_details param_details, pin, relevant_pin
       # see if we have additional tags to pay attention to from YARD -
       # e.g., kwargs in a **restkwargs splat
       tags = pin.docstring.tags(:param)
@@ -596,7 +594,7 @@ module Solargraph
 
     # @param pin [Pin::Signature]
     # @return [Hash{String => Hash{Symbol => String, ComplexType}}]
-    def signature_param_details(pin)
+    def signature_param_details pin
       # @type [Hash{String => Hash{Symbol => String, ComplexType}}]
       result = {}
       pin.parameters.each do |param|
@@ -630,7 +628,7 @@ module Solargraph
     # @param new_param_details [Hash{String => Hash{Symbol => String, ComplexType}}]
     #
     # @return [void]
-    def add_to_param_details(param_details, param_names, new_param_details)
+    def add_to_param_details param_details, param_names, new_param_details
       new_param_details.each do |param_name, details|
         next unless param_names.include?(param_name)
 
@@ -643,7 +641,7 @@ module Solargraph
     # @param signature [Pin::Signature]
     # @param method_pin_stack [Array<Pin::Method>]
     # @return [Hash{String => Hash{Symbol => String, ComplexType}}]
-    def param_details_from_stack(signature, method_pin_stack)
+    def param_details_from_stack signature, method_pin_stack
       signature_type = signature.typify(api_map)
       signature = signature.proxy signature_type
       param_details = signature_param_details(signature)
@@ -683,7 +681,7 @@ module Solargraph
 
     # @param pin [Pin::BaseVariable]
     def declared_externally? pin
-      raise "No assignment found" if pin.assignment.nil?
+      raise 'No assignment found' if pin.assignment.nil?
 
       chain = Solargraph::Parser.chain(pin.assignment, filename)
       # @sg-ignore flow sensitive typing needs to handle attrs
@@ -696,24 +694,19 @@ module Solargraph
       type = chain.infer(api_map, closure_pin, locals)
       if type.undefined? && !rules.ignore_all_undefined?
         base = chain
-        missing = chain
         # @type [Solargraph::Pin::Base, nil]
         found = nil
         # @type [Array<Solargraph::Pin::Base>]
         all_found = []
-        closest = ComplexType::UNDEFINED
         until base.links.first.undefined?
           all_found = base.define(api_map, closure_pin, locals)
           found = all_found.first
           break if found
-          missing = base
           base = base.base
         end
         all_closest = all_found.map { |pin| pin.typify(api_map) }
         closest = ComplexType.new(all_closest.flat_map(&:items).uniq)
-        if !found || closest.defined? || internal?(found)
-          return false
-        end
+        return false if !found || closest.defined? || internal?(found)
       end
       true
     end
@@ -736,7 +729,7 @@ module Solargraph
     # @param arguments [Array<Source::Chain>]
     # @param location [Location]
     # @return [Array<Problem>]
-    def parameterized_arity_problems_for(pin, parameters, arguments, location)
+    def parameterized_arity_problems_for pin, parameters, arguments, location
       return [] unless pin.explicit?
       return [] if parameters.empty? && arguments.empty?
       return [] if pin.anon_splat?
@@ -751,7 +744,7 @@ module Solargraph
           settled_kwargs = parameters.count(&:keyword?)
         else
           kwargs = convert_hash(unchecked.last.node)
-          if parameters.any? { |param| [:kwarg, :kwoptarg].include?(param.decl) || param.kwrestarg? }
+          if parameters.any? { |param| %i[kwarg kwoptarg].include?(param.decl) || param.kwrestarg? }
             if kwargs.empty?
               add_params += 1
             else
@@ -780,10 +773,12 @@ module Solargraph
         return [] if parameters.any?(&:rest?)
         opt = optional_param_count(parameters)
         return [] if unchecked.length <= req + opt
-        if req + add_params + 1 == unchecked.length && any_splatted_call?(unchecked.map(&:node)) && (parameters.map(&:decl) & [:kwarg, :kwoptarg, :kwrestarg]).any?
+        if req + add_params + 1 == unchecked.length && any_splatted_call?(unchecked.map(&:node)) && (parameters.map(&:decl) & %i[
+          kwarg kwoptarg kwrestarg
+        ]).any?
           return []
         end
-        return [] if arguments.length - req == parameters.select { |p| [:optarg, :kwoptarg].include?(p.decl) }.length
+        return [] if arguments.length - req == parameters.select { |p| %i[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.
@@ -799,35 +794,33 @@ module Solargraph
     # @todo need to use generic types in method to choose correct
     #   signature and generate Integer as return type
     # @return [Integer]
-    def required_param_count(parameters)
+    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]
+    #
     # @return [Integer]
-    def optional_param_count(parameters)
+    def optional_param_count parameters
       parameters.select { |p| p.decl == :optarg }.length
     end
 
     # @param pin [Pin::Method]
-    # @sg-ignore need boolish support for ? methods
     def abstract? pin
       pin.docstring.has_tag?('abstract') ||
-        # @sg-ignore of low sensitive typing needs to handle ivars
-        (pin.closure && pin.closure.docstring.has_tag?('abstract'))
+        pin.closure&.docstring&.has_tag?('abstract')
     end
 
     # @param pin [Pin::Method]
     # @return [Array<Source::Chain>]
-    def fake_args_for(pin)
+    def fake_args_for pin
       args = []
       with_opts = false
       with_block = false
       # @param pin [Pin::Parameter]
       pin.parameters.each do |pin|
         # @sg-ignore flow sensitive typing should be able to handle redefinition
-        if [:kwarg, :kwoptarg, :kwrestarg].include?(pin.decl)
+        if %i[kwarg kwoptarg kwrestarg].include?(pin.decl)
           with_opts = true
         # @sg-ignore flow sensitive typing should be able to handle redefinition
         elsif pin.decl == :block

data/lib/solargraph/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Solargraph
-  VERSION = ENV.fetch('SOLARGRAPH_FORCE_VERSION', '0.59.0.dev.1')
+  VERSION = ENV.fetch('SOLARGRAPH_FORCE_VERSION', '0.59.0')
 end

data/lib/solargraph/workspace/config.rb

@@ -54,7 +54,9 @@ module Solargraph
       #
       # @return [Array<String>]
       def calculated
-        Solargraph.logger.info "Indexing workspace files in #{directory}" unless @calculated || directory.empty? || directory == '*'
+        unless @calculated || directory.empty? || directory == '*'
+          Solargraph.logger.info "Indexing workspace files in #{directory}"
+        end
         @calculated ||= included - excluded
       end
 
@@ -146,7 +148,7 @@ module Solargraph
         global_config = read_config(global_config_path)
 
         defaults = default_config
-        defaults.merge({'exclude' => []}) unless workspace_config.nil?
+        defaults.merge({ 'exclude' => [] }) unless workspace_config.nil?
 
         defaults
           .merge(global_config || {})
@@ -160,13 +162,13 @@ module Solargraph
       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))
+        YAML.safe_load_file(config_path)
       end
 
       # @return [Hash{String => Array, Hash, Integer}]
       def default_config
         {
-          'include' => ['Rakefile', 'Gemfile', '*.gemspec', '**/*.rb'],
+          'include' => ['Rakefile', 'Gemfile', '*.gemspec', './**/*.rb'],
           'exclude' => ['spec/**/*', 'test/**/*', 'vendor/**/*', '.bundle/**/*'],
           'require' => [],
           'domains' => [],
@@ -176,11 +178,11 @@ module Solargraph
               'cops' => 'safe',
               'except' => [],
               'only' => [],
-              'extra_args' =>[]
+              'extra_args' => []
             }
           },
           'type_checker' => {
-            'rules' => { }
+            'rules' => {}
           },
           'require_paths' => [],
           'plugins' => [],
@@ -193,12 +195,11 @@ module Solargraph
       # @param globs [Array<String>]
       # @return [Array<String>]
       def process_globs globs
-        result = globs.flat_map do |glob|
+        globs.flat_map do |glob|
           Dir[File.absolute_path(glob, directory)]
-            .map{ |f| f.gsub(/\\/, '/') }
+            .map { |f| f.gsub('\\', '/') }
             .select { |f| File.file?(f) }
         end
-        result
       end
 
       # Modify the included files based on excluded directories and get an
@@ -241,7 +242,7 @@ module Solargraph
       # @param glob [String]
       # @return [String]
       def glob_to_directory glob
-        glob.gsub(/(\/\*|\/\*\*\/\*\*?)$/, '')
+        glob.gsub(%r{(/\*|/\*\*/\*\*?)$}, '')
       end
 
       # @return [Array<String>]

data/lib/solargraph/workspace/gemspecs.rb

@@ -117,7 +117,7 @@ module Solargraph
       #
       # @return [Array<Gem::Specification>]
       def fetch_dependencies gemspec, out: $stderr
-        gemspecs = all_gemspecs_from_bundle
+        all_gemspecs_from_bundle
 
         # @type [Hash{String => Gem::Specification}]
         deps_so_far = {}
@@ -190,7 +190,7 @@ module Solargraph
                                                           end
                                                         # @sg-ignore Unresolved constant Gem::StubSpecification
                                                         when Gem::StubSpecification
-                                                          # @sg-ignore flow sensitive typing ought to be able to handle 'when ClassName'
+                                                          # @sg-ignore Unresolved call to to_spec on Gem::Specification, Bundler::LazySpecification, Bundler::StubSpecification
                                                           specish.to_spec
                                                         else
                                                           raise "Unexpected type while resolving gem: #{specish.class}"
@@ -313,7 +313,7 @@ module Solargraph
         end
       end
 
-      # @sg-ignore flow sensitive typing needs better handling of ||= on lvars
+      # @sg-ignore return type could not be inferred
       # @return [Array<Gem::Specification>]
       def all_gemspecs_from_external_bundle
         @all_gemspecs_from_external_bundle ||=