solargraph 0.32.5 → 0.33.0

data/lib/solargraph/source_map/node_processor/sym_node.rb

@@ -3,7 +3,10 @@ module Solargraph
     module NodeProcessor
       class SymNode < Base
         def process
-          pins.push Solargraph::Pin::Symbol.new(get_node_location(node), ":#{node.children[0]}")
+          pins.push Solargraph::Pin::Symbol.new(
+            get_node_location(node),
+            ":#{node.children[0]}"
+          )
         end
       end
     end

data/lib/solargraph/source_map/region.rb

@@ -4,8 +4,8 @@ module Solargraph
     # locations in a source.
     #
     class Region
-      # @return [String]
-      attr_reader :namespace
+      # @return [Pin::Closure]
+      attr_reader :closure
 
       # @return [Symbol]
       attr_reader :scope
@@ -20,10 +20,11 @@ module Solargraph
       # @param namespace [String]
       # @param scope [Symbol]
       # @param visibility [Symbol]
-      def initialize source: Solargraph::Source.load_string(''), namespace: '',
-                     scope: :instance, visibility: :public
+      def initialize source: Solargraph::Source.load_string(''), closure: nil,
+                     scope: nil, visibility: :public
         @source = source
-        @namespace = namespace
+        # @closure = closure
+        @closure = closure || Pin::Namespace.new(name: '', location: source.location)
         @scope = scope
         @visibility = visibility
       end
@@ -35,14 +36,14 @@ module Solargraph
 
       # Generate a new Region with the provided attribute changes.
       #
-      # @param namespace [String, nil]
+      # @param closure [Pin::Closure, nil]
       # @param scope [Symbol, nil]
       # @param visibility [Symbol, nil]
       # @return [Region]
-      def update namespace: nil, scope: nil, visibility: nil
+      def update closure: nil, scope: nil, visibility: nil
         Region.new(
           source: source,
-          namespace: namespace || self.namespace,
+          closure: closure || self.closure,
           scope: scope || self.scope,
           visibility: visibility || self.visibility
         )

data/lib/solargraph/type_checker.rb

@@ -0,0 +1,282 @@
+module Solargraph
+  # A static analysis tool for validating data types.
+  #
+  class TypeChecker
+    autoload :Problem, 'solargraph/type_checker/problem'
+    autoload :ParamDef, 'solargraph/type_checker/param_def'
+
+    # @return [String]
+    attr_reader :filename
+
+    # @param filename [String]
+    # @param api_map [ApiMap]
+    def initialize filename, api_map: nil
+      @filename = filename
+      # @todo Smarter directory resolution
+      @api_map = api_map || Solargraph::ApiMap.load(File.dirname(filename))
+    end
+
+    # Return type problems indicate that a method does not specify a type in a
+    # `@return` tag or the specified type could not be resolved to a known
+    # type.
+    #
+    # @return [Array<Problem>]
+    def return_type_problems
+      result = []
+      smap = api_map.source_map(filename)
+      pins = smap.pins.select { |pin| pin.is_a?(Solargraph::Pin::BaseMethod) }
+      pins.each { |pin| result.concat check_return_type(pin) }
+      result
+    end
+
+    # Param type problems indicate that a method does not specify a type in a
+    # `@param` tag for one or more of its parameters, a `@param` tag is defined
+    # that does not correlate with the method signature, or the specified type
+    # could not be resolved to a known type.
+    #
+    # @return [Array<Problem>]
+    def param_type_problems
+      result = []
+      smap = api_map.source_map(filename)
+      smap.locals.select { |pin| pin.is_a?(Solargraph::Pin::Parameter) }.each do |par|
+        next unless par.closure.is_a?(Solargraph::Pin::Method)
+        result.concat check_param_tags(par.closure)
+        type = par.typify(api_map)
+        pdefs = ParamDef.from(par.closure)
+        if type.undefined?
+          if par.return_type.undefined? && !pdefs.any? { |pd| pd.name == par.name && [:restarg, :kwrestarg].include?(pd.type) }
+            result.push Problem.new(
+              par.location, "#{par.closure.name} has undefined @param type for #{par.name}")
+          elsif !pdefs.any? { |pd| [:restarg, :kwrestarg].include?(pd.type) }
+            result.push Problem.new(par.location, "#{par.closure.name} has unresolved @param type for #{par.name}")
+          end
+        end
+      end
+      result
+    end
+
+    # Strict type problems indicate that a `@return` type or a `@param` type
+    # does not match the type inferred from code analysis; or that an argument
+    # sent to a method does not match the type specified in the corresponding
+    # `@param` tag.
+    #
+    # @return [Array<Problem>]
+    def strict_type_problems
+      result = []
+      smap = api_map.source_map(filename)
+      smap.pins.select { |pin| pin.is_a?(Pin::BaseMethod) }.each do |pin|
+        result.concat confirm_return_type(pin)
+      end
+      return result if smap.source.node.nil?
+      result.concat check_send_args smap.source.node
+      result
+    end
+
+    private
+
+    # @return [ApiMap]
+    attr_reader :api_map
+
+    # @param pin [Pin::BaseMethod]
+    # @return [Array<Problem>]
+    def check_param_tags pin
+      return [] if ParamDef.from(pin).map(&:type).include?(:kwrestarg)
+      result = []
+      pin.docstring.tags(:param).each do |par|
+        next if pin.parameter_names.include?(par.name)
+        result.push Problem.new(pin.location, "#{pin.name} has unknown @param #{par.name}")
+      end
+      result
+    end
+
+    # @param pin [Pin::BaseMethod]
+    # @return [Array<Problem>]
+    def check_return_type pin
+      tagged = pin.typify(api_map)
+      if tagged.undefined?
+        if pin.return_type.undefined?
+          probed = pin.probe(api_map)
+          return [Problem.new(pin.location, "#{pin.name} has undefined @return type", probed.to_s)]
+        else
+          return [Problem.new(pin.location, "#{pin.name} has unresolved @return type #{pin.return_type}")]
+        end
+      end
+      []
+    end
+
+    # @param pin [Solargraph::Pin::Base]
+    # @return [Array<Problem>]
+    def confirm_return_type pin
+      tagged = pin.typify(api_map)
+      return [] if tagged.void? || tagged.undefined? || pin.is_a?(Pin::Attribute)
+      probed = pin.probe(api_map)
+      return [] if probed.undefined?
+      if tagged.to_s != probed.to_s
+        if probed.name == 'Array' && probed.subtypes.empty?
+          return [] if tagged.name == 'Array'
+        end
+        if probed.name == 'Hash' && probed.value_types.empty?
+          return [] if tagged.name == 'Hash'
+        end
+        all = true
+        probed.each do |pt|
+          tagged.each do |tt|
+            if pt.name == tt.name && !api_map.super_and_sub?(tt.namespace, pt.namespace) && !tagged.map(&:namespace).include?(pt.namespace)
+              all = false
+              break
+            elsif pt.name == tt.name && ['Array', 'Class', 'Module'].include?(pt.name)
+              if !(tt.subtypes.any? { |ttx| pt.subtypes.any? { |ptx| api_map.super_and_sub?(ttx.to_s, ptx.to_s) } })
+                all = false
+                break
+              end
+            elsif pt.name == tt.name && pt.name == 'Hash'
+              if !(tt.key_types.empty? && !pt.key_types.empty?) && !(tt.key_types.any? { |ttx| pt.key_types.any? { |ptx| api_map.super_and_sub?(ttx.to_s, ptx.to_s) } })
+                if !(tt.value_types.empty? && !pt.value_types.empty?) && !(tt.value_types.any? { |ttx| pt.value_types.any? { |ptx| api_map.super_and_sub?(ttx.to_s, ptx.to_s) } })
+                  all = false
+                  break
+                end
+              end
+            elsif pt.name != tt.name && !api_map.super_and_sub?(tt.to_s, pt.to_s) && !tagged.map(&:to_s).include?(pt.to_s)
+              all = false
+              break
+            end
+          end
+        end
+        return [] if all
+        return [Problem.new(pin.location, "@return type `#{tagged.to_s}` does not match inferred type `#{probed.to_s}`", probed.to_s)]
+      end
+      []
+    end
+
+    def check_send_args node, skip_send = false
+      result = []
+      if node.type == :send
+        smap = api_map.source_map(filename)
+        locals = smap.locals_at(Solargraph::Location.new(filename, Solargraph::Range.from_node(node)))
+        block = smap.locate_block_pin(node.loc.line, node.loc.column)
+        chain = Solargraph::Source::NodeChainer.chain(node, filename)
+        pins = chain.define(api_map, block, locals).select { |pin| pin.is_a?(Pin::BaseMethod ) }
+        if pins.empty?
+          if !more_signature?(node)
+            base = chain.base.define(api_map, block, locals).first
+            if base.nil? || report_location?(base.location)
+              result.push Problem.new(Solargraph::Location.new(filename, Solargraph::Range.from_node(node)), "Unresolved method signature #{chain.links.map(&:word).join('.')}")
+            end
+          end
+        else
+          pin = pins.first
+          ptypes = ParamDef.from(pin)
+          params = param_tags_from(pin)
+          cursor = 0
+          curtype = nil
+          node.children[2..-1].each_with_index do |arg, index|
+            curtype = ptypes[cursor] if curtype.nil? || curtype == :arg
+            if curtype.nil?
+              if pin.parameters[index].nil?
+                result.push Problem.new(Solargraph::Location.new(filename, Solargraph::Range.from_node(node)), "Not enough arguments sent to #{pin.path}")
+                break
+              end
+            else
+              # @todo Break here? Not sure about that
+              break if curtype.type == :restarg || curtype.type == :kwrestarg
+              if arg.is_a?(Parser::AST::Node) && arg.type == :hash
+                arg.children.each do |pair|
+                  sym = pair.children[0].children[0].to_s
+                  partype = params[pin.parameter_names[index]]
+                  if partype.nil?
+                    if report_location?(pin.location)
+                      unless ptypes.map(&:type).include?(:kwrestarg)
+                        result.push Problem.new(Solargraph::Location.new(filename, Solargraph::Range.from_node(node)), "No @param type for #{pin.parameter_names[index]} in #{pin.path}")
+                      end
+                    end
+                  else
+                    chain = Solargraph::Source::NodeChainer.chain(pair.children[1], filename)
+                    argtype = chain.infer(api_map, block, locals)
+                    if argtype.tag != partype.tag
+                      result.push Problem.new(Solargraph::Location.new(filename, Solargraph::Range.from_node(node)), "Wrong parameter type for #{pin.path}: #{pin.parameter_names[index]} expected #{partype.tag}, received #{argtype.tag}")
+                    end
+                  end
+                end
+              elsif arg.is_a?(Parser::AST::Node) && arg.type == :splat
+                result.push Problem.new(Solargraph::Location.new(filename, Solargraph::Range.from_node(node)), "Can't handle splat in #{pin.parameter_names[index]} #{pin.path}")
+                break if curtype != :arg && ptypes.map(&:type).include?(:restarg)
+              else
+                partype = params[pin.parameter_names[index]]
+                if partype.nil?
+                  if report_location?(pin.location)
+                    result.push Problem.new(Solargraph::Location.new(filename, Solargraph::Range.from_node(node)), "No @param type for #{pin.parameter_names[index]} in #{pin.path}")
+                  end
+                else
+                  arg = chain.links.last.arguments[index]
+                  if arg.nil?
+                    result.push Problem.new(Solargraph::Location.new(filename, Solargraph::Range.from_node(node)), "Wrong number of arguments to #{pin.path}")
+                  else
+                    argtype = arg.infer(api_map, block, locals)
+                    if argtype.tag != partype.tag
+                      result.push Problem.new(Solargraph::Location.new(filename, Solargraph::Range.from_node(node)), "Wrong parameter type for #{pin.path}: #{pin.parameter_names[index]} expected #{partype.tag}, received #{argtype.tag}")
+                    end
+                  end
+                end
+              end
+            end
+            cursor += 1 if curtype == :arg
+          end
+        end
+      end
+      node.children.each do |child|
+        next unless child.is_a?(Parser::AST::Node)
+        next if child.type == :send && skip_send
+        result.concat check_send_args(child)
+      end
+      result
+    end
+
+    def param_tags_from pin
+      # @todo Look for see references
+      #   and dig through all the pins
+      return {} if pin.nil?
+      tags = pin.docstring.tags(:param)
+      result = {}
+      tags.each do |tag|
+        result[tag.name] = ComplexType::UNDEFINED
+        result[tag.name] = ComplexType.try_parse(*tag.types).qualify(api_map, pin.context.namespace)
+      end
+      result
+    end
+
+    # @param location [Location, nil]
+    def report_location? location
+      return false if location.nil?
+      filename == location.filename || api_map.bundled?(location.filename)
+    end
+
+    def more_signature? node
+      node.children.any? do |child|
+        child.is_a?(Parser::AST::Node) && (
+          child.type == :send || (child.type == :block && more_signature?(child))
+        )
+      end
+    end
+
+    class << self
+      # @param filename [String]
+      # @return [self]
+      def load filename
+        source = Solargraph::Source.load(filename)
+        api_map = Solargraph::ApiMap.new
+        api_map.map(source)
+        new(filename, api_map: api_map)
+      end
+
+      # @param code [String]
+      # @param filename [String, nil]
+      # @return [self]
+      def load_string code, filename = nil
+        source = Solargraph::Source.load_string(code, filename)
+        api_map = Solargraph::ApiMap.new
+        api_map.map(source)
+        new(filename, api_map: api_map)
+      end
+    end
+  end
+end

data/lib/solargraph/type_checker/param_def.rb

@@ -0,0 +1,47 @@
+module Solargraph
+  class TypeChecker
+    # Data about a method parameter definition. This is the information from
+    # the args list in the def call, not the `@param` tags.
+    #
+    class ParamDef
+      # @return [String]
+      attr_reader :name
+
+      # @return [Symbol]
+      attr_reader :type
+
+      def initialize name, type
+        @name = name
+        @type = type
+      end
+
+      class << self
+        # Get an array of ParamDefs from a method pin.
+        #
+        # @param pin [Solargraph::Pin::BaseMethod]
+        # @return [Array<ParamDef>]
+        def from pin
+          result = []
+          pin.parameters.each_with_index do |full, index|
+            result.push ParamDef.new(pin.parameter_names[index], arg_type(full))
+          end
+          result
+        end
+
+        private
+
+        # @param string [String]
+        # @return [Symbol]
+        def arg_type string
+          return :kwrestarg if string.start_with?('**')
+          return :restarg if string.start_with?('*')
+          return :optarg if string.include?('=')
+          return :kwoptarg if string.end_with?(':')
+          return :kwarg if string =~ /^[a-z0-9_]*?:/
+          :arg
+        end
+      end
+
+    end
+  end
+end

data/lib/solargraph/type_checker/problem.rb

@@ -0,0 +1,25 @@
+module Solargraph
+  class TypeChecker
+    # A problem reported by TypeChecker.
+    #
+    class Problem
+      # @return [Solargraph::Location]
+      attr_reader :location
+
+      # @return [String]
+      attr_reader :message
+
+      # @return [String, nil]
+      attr_reader :suggestion
+
+      # @param location [Solargraph::Location]
+      # @param message [String]
+      # @param suggestion [String, nil]
+      def initialize location, message, suggestion = nil
+        @location = location
+        @message = message
+        @suggestion = suggestion
+      end
+    end
+  end
+end

data/lib/solargraph/version.rb

@@ -1,3 +1,3 @@
 module Solargraph
-  VERSION = '0.32.5'
+  VERSION = '0.33.0'
 end

data/lib/solargraph/views/environment.erb

@@ -36,7 +36,7 @@
       Parser Target Version: <%= Solargraph::Source.parser.version %>
     </li>
     <li>
-      Using Bundler: <%= ENV.key?('BUNDLE_GEMFILE') %>
+      Using Bundler: <%= ENV.key?('BUNDLE_BIN_PATH') %>
     </li>
   </ul>
   <h2>

data/lib/solargraph/workspace.rb

@@ -126,7 +126,7 @@ module Solargraph
 
     private
 
-    # @return [Hash<String, Solargraph::Source>]
+    # @return [Hash{String => Solargraph::Source}]
     def source_hash
       @source_hash ||= {}
     end
@@ -152,7 +152,7 @@ module Solargraph
       result = []
       gemspecs.each do |file|
         base = File.dirname(file)
-        # @todo Evaluating gemspec files violates the goal of not running
+        # HACK: Evaluating gemspec files violates the goal of not running
         #   workspace code, but this is how Gem::Specification.load does it
         #   anyway.
         begin

data/lib/solargraph/workspace/config.rb

@@ -34,7 +34,6 @@ module Solargraph
         @raw_data['require'] ||= []
         @raw_data['domains'] ||= []
         @raw_data['reporters'] ||= %w[rubocop require_not_found]
-        @raw_data['plugins'] ||= []
         @raw_data['require_paths'] ||= []
         @raw_data['max_files'] ||= MAX_FILES
         included
@@ -88,13 +87,6 @@ module Solargraph
         raw_data['require_paths'] || []
       end
 
-      # An array of Solargraph plugins to install.
-      #
-      # @return [Array<String>]
-      def plugins
-        raw_data['plugins']
-      end
-
       # An array of reporters to use for diagnostics.
       #
       # @return [Array<String>]