solargraph 0.57.0 → 0.58.0

data/lib/solargraph/source_map.rb

@@ -41,11 +41,13 @@ module Solargraph
       # solargraph-rails is known to use this method to get the document symbols. It should probably be removed.
       @document_symbols = nil
       self.convention_pins = conventions_environ.pins
+      # @type [Hash{Class<Pin::Base> => Array<Pin::Base>}]
       @pin_select_cache = {}
     end
 
     # @generic T
     # @param klass [Class<generic<T>>]
+    #
     # @return [Array<generic<T>>]
     def pins_by_class klass
       @pin_select_cache[klass] ||= pin_class_hash.select { |key, _| key <= klass }.values.flatten
@@ -124,10 +126,13 @@ module Solargraph
     # @param line [Integer]
     # @param character [Integer]
     # @return [Pin::Namespace,Pin::Method,Pin::Block]
-    def locate_block_pin line, character
-      _locate_pin line, character, Pin::Namespace, Pin::Method, Pin::Block
+    def locate_closure_pin line, character
+      _locate_pin line, character, Pin::Closure
     end
 
+    # @deprecated Please use locate_closure_pin instead
+    alias locate_block_pin locate_closure_pin
+
     # @param name [String]
     # @return [Array<Location>]
     def references name
@@ -168,10 +173,10 @@ module Solargraph
 
     private
 
-    # @return [Hash{Class => Array<Pin::Base>}]
     # @return [Array<Pin::Base>]
     attr_writer :convention_pins
 
+    # @return [Hash{Class<Pin::Base> => Array<Pin::Base>}]
     def pin_class_hash
       @pin_class_hash ||= pins.to_set.classify(&:class).transform_values(&:to_a)
     end

data/lib/solargraph/type_checker/rules.rb

@@ -20,7 +20,8 @@ module Solargraph
       attr_reader :rank
 
       # @param level [Symbol]
-      def initialize level
+      # @param overrides [Hash{Symbol => Symbol}]
+      def initialize level, overrides
         @rank = if LEVELS.key?(level)
           LEVELS[level]
         else
@@ -28,34 +29,39 @@ module Solargraph
           0
         end
         @level = LEVELS[LEVELS.values.index(@rank)]
+        @overrides = overrides
       end
 
       def ignore_all_undefined?
-        rank < LEVELS[:strict]
+        !report_undefined?
+      end
+
+      def report_undefined?
+        report?(:report_undefined, :strict)
       end
 
       def validate_consts?
-        rank >= LEVELS[:strict]
+        report?(:validate_consts, :strict)
       end
 
       def validate_calls?
-        rank >= LEVELS[:strict]
+        report?(:validate_calls, :strict)
       end
 
       def require_type_tags?
-        rank >= LEVELS[:strong]
+        report?(:validate_type_tags, :strong)
       end
 
       def must_tag_or_infer?
-        rank > LEVELS[:typed]
+        report?(:must_tag_or_infer, :strict)
       end
 
       def validate_tags?
-        rank > LEVELS[:normal]
+        report?(:validate_tags, :typed)
       end
 
       def require_all_return_types_match_inferred?
-        rank >= LEVELS[:alpha]
+        report?(:require_all_return_types_match_inferred, :alpha)
       end
 
       # We keep this at strong because if you added an @ sg-ignore to
@@ -63,7 +69,15 @@ module Solargraph
       # get a false positive - we don't run stronger level checks than
       # requested for performance reasons
       def validate_sg_ignores?
-        rank >= LEVELS[:strong]
+        report?(:validate_sg_ignores, :strong)
+      end
+
+      private
+
+      # @param type [Symbol]
+      # @param level [Symbol]
+      def report?(type, level)
+        rank >= LEVELS[@overrides.fetch(type, level)]
       end
     end
   end

data/lib/solargraph/type_checker.rb

@@ -21,14 +21,23 @@ module Solargraph
     # @return [ApiMap]
     attr_reader :api_map
 
-    # @param filename [String]
+    # @param filename [String, nil]
     # @param api_map [ApiMap, nil]
-    # @param level [Symbol]
-    def initialize filename, api_map: nil, level: :normal
+    # @param level [Symbol] Don't complain about anything above this level
+    # @param workspace [Workspace, nil] Workspace to use for loading
+    #   type checker rules modified by user config
+    # @param type_checker_rules [Hash{Symbol => Symbol}] Overrides for
+    #   type checker rules - e.g., :report_undefined => :strong
+    # @param rules [Rules] Type checker rules object
+    def initialize filename,
+                   api_map: nil,
+                   level: :normal,
+                   workspace: filename ? Workspace.new(File.dirname(filename)) : nil,
+                   rules: workspace ? workspace.rules(level) : Rules.new(level, {})
       @filename = filename
       # @todo Smarter directory resolution
       @api_map = api_map || Solargraph::ApiMap.load(File.dirname(filename))
-      @rules = Rules.new(level)
+      @rules = rules
       # @type [Array<Range>]
       @marked_ranges = []
     end
@@ -96,7 +105,7 @@ module Solargraph
     def method_return_type_problems_for pin
       return [] if pin.is_a?(Pin::MethodAlias)
       result = []
-      declared = pin.typify(api_map).self_to_type(pin.full_context).qualify(api_map, pin.full_context.tag)
+      declared = pin.typify(api_map).self_to_type(pin.full_context).qualify(api_map, *pin.gates)
       if declared.undefined?
         if pin.return_type.undefined? && rules.require_type_tags?
           if pin.attribute?
@@ -152,33 +161,32 @@ module Solargraph
     # @return [Array<Problem>]
     def method_param_type_problems_for pin
       stack = api_map.get_method_stack(pin.namespace, pin.name, scope: pin.scope)
-      params = first_param_hash(stack)
       result = []
-      if rules.require_type_tags?
-        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_type(pin.full_context)
-                if inferred.undefined?
+      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
                   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)
+        # @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)
+          end
         end
       end
       result
@@ -196,7 +204,7 @@ module Solargraph
         if pin.return_type.defined?
           declared = pin.typify(api_map)
           next if declared.duck_type?
-          if declared.defined?
+          if declared.defined? && pin.assignment
             if rules.validate_tags?
               inferred = pin.probe(api_map)
               if inferred.undefined?
@@ -217,7 +225,7 @@ module Solargraph
           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
+        elsif pin.assignment
           inferred = pin.probe(api_map)
           if inferred.undefined? && declared_externally?(pin)
             ignored_pins.push pin
@@ -239,10 +247,11 @@ module Solargraph
       Solargraph::Parser::NodeMethods.const_nodes_from(source.node).each do |const|
         rng = Solargraph::Range.from_node(const)
         chain = Solargraph::Parser.chain(const, filename)
-        block_pin = source_map.locate_block_pin(rng.start.line, rng.start.column)
+        closure_pin = source_map.locate_closure_pin(rng.start.line, rng.start.column)
+        closure_pin.rebind(api_map)
         location = Location.new(filename, rng)
         locals = source_map.locals_at(location)
-        pins = chain.define(api_map, block_pin, locals)
+        pins = chain.define(api_map, closure_pin, locals)
         if pins.empty?
           result.push Problem.new(location, "Unresolved constant #{Solargraph::Parser::NodeMethods.unpack_name(const)}")
           @marked_ranges.push location.range
@@ -258,17 +267,25 @@ module Solargraph
         rng = Solargraph::Range.from_node(call)
         next if @marked_ranges.any? { |d| d.contain?(rng.start) }
         chain = Solargraph::Parser.chain(call, filename)
-        block_pin = source_map.locate_block_pin(rng.start.line, rng.start.column)
+        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
+          # one closure
+          closure_pin = closure_pin.closure
+        end
+        closure_pin.rebind(api_map)
         location = Location.new(filename, rng)
         locals = source_map.locals_at(location)
-        type = chain.infer(api_map, block_pin, locals)
+        type = chain.infer(api_map, closure_pin, locals)
         if type.undefined? && !rules.ignore_all_undefined?
           base = chain
           missing = chain
           found = nil
           closest = ComplexType::UNDEFINED
           until base.links.first.undefined?
-            found = base.define(api_map, block_pin, locals).first
+            found = base.define(api_map, closure_pin, locals).first
             break if found
             missing = base
             base = base.base
@@ -286,7 +303,7 @@ module Solargraph
             end
           end
         end
-        result.concat argument_problems_for(chain, api_map, block_pin, locals, location)
+        result.concat argument_problems_for(chain, api_map, closure_pin, locals, location)
       end
       result
     end
@@ -309,8 +326,9 @@ module Solargraph
       pins = base.define(api_map, closure_pin, locals)
 
       first_pin = pins.first
-      unresolvable = first_pin.is_a?(Pin::DelegatedMethod) && !first_pin.resolvable?(api_map)
-      if !unresolvable && first_pin.is_a?(Pin::Method)
+      if first_pin.is_a?(Pin::DelegatedMethod) && !first_pin.resolvable?(api_map)
+        # Do nothing, as we can't find the actual method implementation
+      elsif first_pin.is_a?(Pin::Method)
         # @type [Pin::Method]
         pin = first_pin
         ap = if base.links.last.is_a?(Solargraph::Source::Chain::ZSuper)
@@ -322,7 +340,6 @@ module Solargraph
                         base.base.infer(api_map, closure_pin, locals).namespace
                       end
                init = api_map.get_method_stack(fqns, 'initialize').first
-
                init ? arity_problems_for(init, arguments, location) : []
              else
                arity_problems_for(pin, arguments, location)
@@ -330,11 +347,12 @@ module Solargraph
         return ap unless ap.empty?
         return [] if !rules.validate_calls? || base.links.first.is_a?(Solargraph::Source::Chain::ZSuper)
 
-        params = first_param_hash(pins)
-
         all_errors = []
         pin.signatures.sort { |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
+
           if signature_errors.empty?
             # we found a signature that works - meaning errors from
             # other signatures don't matter.
@@ -411,6 +429,7 @@ module Solargraph
             # @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? && !any_types_match?(api_map, ptype, argtype)
                 errors.push Problem.new(location, "Wrong argument type for #{pin.path}: #{par.name} expected #{ptype}, received #{argtype}")
                 return errors
@@ -428,7 +447,7 @@ module Solargraph
     # @param sig [Pin::Signature]
     # @param argchain [Source::Chain]
     # @param api_map [ApiMap]
-    # @param block_pin [Pin::Block]
+    # @param closure_pin [Pin::Closure]
     # @param locals [Array<Pin::LocalVariable>]
     # @param location [Location]
     # @param pin [Pin::Method]
@@ -436,13 +455,13 @@ module Solargraph
     # @param idx [Integer]
     #
     # @return [Array<Problem>]
-    def kwarg_problems_for sig, argchain, api_map, block_pin, locals, location, pin, params, idx
+    def kwarg_problems_for sig, argchain, api_map, closure_pin, locals, location, pin, params, idx
       result = []
       kwargs = convert_hash(argchain.node)
       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)
+        result.concat kwrestarg_problems_for(api_map, closure_pin, locals, location, pin, params, kwargs)
       else
         if argchain
           data = params[par.name]
@@ -450,8 +469,11 @@ module Solargraph
             # @todo Some level (strong, I guess) should require the param here
           else
             ptype = data[:qualified]
+            ptype = ptype.self_to_type(pin.context)
             unless ptype.undefined?
-              argtype = argchain.infer(api_map, block_pin, locals)
+              # @sg-ignore https://github.com/castwide/solargraph/pull/1127
+              argtype = argchain.infer(api_map, closure_pin, locals).self_to_type(closure_pin.context)
+              # @sg-ignore Unresolved call to defined?
               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
@@ -465,19 +487,21 @@ module Solargraph
     end
 
     # @param api_map [ApiMap]
-    # @param block_pin [Pin::Block]
+    # @param closure_pin [Pin::Closure]
     # @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)
+    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)
         ptype = params[pname.to_s][:qualified]
-        argtype = argchain.infer(api_map, block_pin, locals)
+        ptype = 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 && !any_types_match?(api_map, ptype, argtype)
           result.push Problem.new(location, "Wrong argument type for #{pin.path}: #{pname} expected #{ptype}, received #{argtype}")
         end
@@ -485,9 +509,32 @@ module Solargraph
       result
     end
 
-    # @param pin [Pin::Method]
+    # @param param_details [Hash{String => Hash{Symbol => String, ComplexType}}]
+    # @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)
+      # see if we have additional tags to pay attention to from YARD -
+      # e.g., kwargs in a **restkwargs splat
+      tags = pin.docstring.tags(:param)
+      tags.each do |tag|
+        next if param_details.key? tag.name.to_s
+        next if tag.types.nil?
+        details = {
+          tagged: tag.types.join(', '),
+          qualified: Solargraph::ComplexType.try_parse(*tag.types).qualify(api_map, pin.full_context.namespace)
+        }
+        # don't complain about a param that didn't come from the pin we're looking at anyway
+        if details[:qualified].defined? ||
+           relevant_pin.parameter_names.include?(tag.name.to_s)
+          param_details[tag.name.to_s] = details
+        end
+      end
+    end
+
+    # @param pin [Pin::Signature]
     # @return [Hash{String => Hash{Symbol => String, ComplexType}}]
-    def param_hash(pin)
+    def signature_param_details(pin)
       # @type [Hash{String => Hash{Symbol => String, ComplexType}}]
       result = {}
       pin.parameters.each do |param|
@@ -506,36 +553,50 @@ module Solargraph
         next if tag.types.nil?
         result[tag.name.to_s] = {
           tagged: tag.types.join(', '),
-          qualified: Solargraph::ComplexType.try_parse(*tag.types).qualify(api_map, pin.full_context.namespace)
+          qualified: Solargraph::ComplexType.try_parse(*tag.types).qualify(api_map, *pin.closure.gates)
         }
       end
       result
     end
 
-    # @param pins [Array<Pin::Method>]
+    # The original signature defines the parameters, but other
+    # signatures and method pins can help by adding type information
+    #
+    # @param param_details [Hash{String => Hash{Symbol => String, ComplexType}}]
+    # @param param_names [Array<String>]
+    # @param new_param_details [Hash{String => Hash{Symbol => String, ComplexType}}]
+    #
+    # @return [void]
+    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)
+
+        param_details[param_name] ||= {}
+        param_details[param_name][:tagged] ||= details[:tagged]
+        param_details[param_name][:qualified] ||= details[:qualified]
+      end
+    end
+
+    # @param signature [Pin::Signature]
+    # @param method_pin_stack [Array<Pin::Method>]
     # @return [Hash{String => Hash{Symbol => String, ComplexType}}]
-    def first_param_hash(pins)
-      return {} if pins.empty?
-      first_pin_type = pins.first.typify(api_map)
-      first_pin = pins.first.proxy first_pin_type
-      param_names = first_pin.parameter_names
-      results = param_hash(first_pin)
-      pins[1..].each do |pin|
-        # @todo this assignment from parametric use of Hash should not lose its generic
-        # @type [Hash{String => Hash{Symbol => BasicObject}}]
+    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)
+      param_names = signature.parameter_names
+
+      method_pin_stack.each do |method_pin|
+        add_restkwarg_param_tag_details(param_details, method_pin, signature)
 
         # documentation of types in superclasses should fail back to
         # subclasses if the subclass hasn't documented something
-        superclass_results = param_hash(pin)
-        superclass_results.each do |param_name, details|
-          next unless param_names.include?(param_name)
-
-          results[param_name] ||= {}
-          results[param_name][:tagged] ||= details[:tagged]
-          results[param_name][:qualified] ||= details[:qualified]
+        method_pin.signatures.each do |sig|
+          add_restkwarg_param_tag_details(param_details, sig, signature)
+          add_to_param_details param_details, param_names, signature_param_details(sig)
         end
       end
-      results
+      param_details
     end
 
     # @param pin [Pin::Base]
@@ -558,20 +619,21 @@ module Solargraph
 
     # @param pin [Pin::BaseVariable]
     def declared_externally? pin
-      return true if pin.assignment.nil?
+      raise "No assignment found" if pin.assignment.nil?
+
       chain = Solargraph::Parser.chain(pin.assignment, filename)
       rng = Solargraph::Range.from_node(pin.assignment)
-      block_pin = source_map.locate_block_pin(rng.start.line, rng.start.column)
+      closure_pin = source_map.locate_closure_pin(rng.start.line, rng.start.column)
       location = Location.new(filename, Range.from_node(pin.assignment))
       locals = source_map.locals_at(location)
-      type = chain.infer(api_map, block_pin, locals)
+      type = chain.infer(api_map, closure_pin, locals)
       if type.undefined? && !rules.ignore_all_undefined?
         base = chain
         missing = chain
         found = nil
         closest = ComplexType::UNDEFINED
         until base.links.first.undefined?
-          found = base.define(api_map, block_pin, locals).first
+          found = base.define(api_map, closure_pin, locals).first
           break if found
           missing = base
           base = base.base

data/lib/solargraph/version.rb

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

data/lib/solargraph/workspace/config.rb

@@ -14,8 +14,8 @@ module Solargraph
       # @return [String]
       attr_reader :directory
 
-      # @todo To make this strongly typed we'll need a record syntax
-      # @return [Hash{String => Array, Hash, Integer, nil}]
+      # @todo To make JSON strongly typed we'll need a record syntax
+      # @return [Hash{String => undefined, nil}]
       attr_reader :raw_data
 
       # @param directory [String]
@@ -63,6 +63,7 @@ module Solargraph
       # namespace. It's typically used to identify available DSLs.
       #
       # @return [Array<String>]
+      # @sg-ignore Need to validate config
       def domains
         raw_data['domains']
       end
@@ -70,6 +71,7 @@ module Solargraph
       # An array of required paths to add to the workspace.
       #
       # @return [Array<String>]
+      # @sg-ignore Need to validate config
       def required
         raw_data['require']
       end
@@ -83,6 +85,7 @@ module Solargraph
 
       # An array of reporters to use for diagnostics.
       #
+      # @sg-ignore Need to validate config
       # @return [Array<String>]
       def reporters
         raw_data['reporters']
@@ -90,6 +93,7 @@ module Solargraph
 
       # A hash of options supported by the formatter
       #
+      # @sg-ignore Need to validate config
       # @return [Hash]
       def formatter
         raw_data['formatter']
@@ -97,6 +101,7 @@ module Solargraph
 
       # An array of plugins to require.
       #
+      # @sg-ignore Need to validate config
       # @return [Array<String>]
       def plugins
         raw_data['plugins']
@@ -104,11 +109,21 @@ module Solargraph
 
       # The maximum number of files to parse from the workspace.
       #
+      # @sg-ignore Need to validate config
       # @return [Integer]
       def max_files
         raw_data['max_files']
       end
 
+      # @return [Hash{Symbol => Symbol}]
+      def type_checker_rules
+        # @type [Hash{String => String}]
+        raw_rules = raw_data.fetch('type_checker', {}).fetch('rules', {})
+        raw_rules.to_h do |k, v|
+          [k.to_sym, v.to_sym]
+        end
+      end
+
       private
 
       # @return [String]
@@ -123,7 +138,7 @@ module Solargraph
         File.join(@directory, '.solargraph.yml')
       end
 
-      # @return [Hash{String => Array<undefined>, Hash{String => undefined}, Integer}]
+      # @return [Hash{String => undefined}]
       def config_data
         workspace_config = read_config(workspace_config_path)
         global_config = read_config(global_config_path)
@@ -162,6 +177,9 @@ module Solargraph
               'extra_args' =>[]
             }
           },
+          'type_checker' => {
+            'rules' => { }
+          },
           'require_paths' => [],
           'plugins' => [],
           'max_files' => MAX_FILES

data/lib/solargraph/workspace/require_paths.rb

@@ -76,7 +76,6 @@ module Solargraph
                "spec = eval(File.read('#{gemspec_file_path}'), TOPLEVEL_BINDING, '#{gemspec_file_path}'); " \
                'return unless Gem::Specification === spec; ' \
                'puts({name: spec.name, paths: spec.require_paths}.to_json)']
-        # @sg-ignore Unresolved call to capture3 on Module<Open3>
         o, e, s = Open3.capture3(*cmd)
         if s.success?
           begin

data/lib/solargraph/workspace.rb

@@ -19,11 +19,17 @@ module Solargraph
     attr_reader :gemnames
     alias source_gems gemnames
 
-    # @param directory [String]
+    # @param directory [String] TODO: Remove '' and '*' special cases
     # @param config [Config, nil]
     # @param server [Hash]
     def initialize directory = '', config = nil, server = {}
-      @directory = directory
+      raise ArgumentError, 'directory must be a String' unless directory.is_a?(String)
+
+      @directory = if ['*', ''].include?(directory)
+                     directory
+                   else
+                     File.absolute_path(directory)
+                   end
       @config = config
       @server = server
       load_sources
@@ -44,6 +50,12 @@ module Solargraph
       @config ||= Solargraph::Workspace::Config.new(directory)
     end
 
+    # @param level [Symbol]
+    # @return [TypeChecker::Rules]
+    def rules(level)
+      @rules ||= TypeChecker::Rules.new(level, config.type_checker_rules)
+    end
+
     # Merge the source. A merge will update the existing source for the file
     # or add it to the sources if the workspace is configured to include it.
     # The source is ignored if the configuration excludes it.
@@ -114,23 +126,6 @@ module Solargraph
       false
     end
 
-    # True if the workspace contains at least one gemspec file.
-    #
-    # @return [Boolean]
-    def gemspec?
-      !gemspecs.empty?
-    end
-
-    # Get an array of all gemspec files in the workspace.
-    #
-    # @return [Array<String>]
-    def gemspecs
-      return [] if directory.empty? || directory == '*'
-      @gemspecs ||= Dir[File.join(directory, '**/*.gemspec')].select do |gs|
-        config.allow? gs
-      end
-    end
-
     # @return [String, nil]
     def rbs_collection_path
       @gem_rbs_collection ||= read_rbs_collection_path