solargraph 0.32.5 → 0.33.0

data/lib/solargraph/pin/reference/require.rb

@@ -3,7 +3,8 @@ module Solargraph
     class Reference
       class Require < Reference
         def initialize location, name
-          super(location, '', name)
+          # super(location, '', name)
+          super(location: location, name: name)
         end
 
         def kind

data/lib/solargraph/pin/singleton.rb

@@ -0,0 +1,9 @@
+module Solargraph
+  module Pin
+    class Singleton < Closure
+      def initialize name: '', location: nil, closure: nil
+        super
+      end
+    end
+  end
+end

data/lib/solargraph/pin/symbol.rb

@@ -4,8 +4,9 @@ module Solargraph
       # @param location [Solargraph::Location]
       # @param name [String]
       def initialize location, name
-        @name = name
-        @location = location
+        super(location: location, name: name)
+        # @name = name
+        # @location = location
       end
 
       def namespace
@@ -28,14 +29,18 @@ module Solargraph
         ''
       end
 
-      def return_complex_type
-        @return_complex_type ||= Solargraph::ComplexType::SYMBOL
+      def return_type
+        @return_type ||= Solargraph::ComplexType::SYMBOL
       end
 
       def directives
         []
       end
 
+      def visibility
+        :public
+      end
+
       def deprecated?
         false
       end

data/lib/solargraph/pin/yard_pin/constant.rb

@@ -4,11 +4,20 @@ module Solargraph
       class Constant < Pin::Constant
         include YardMixin
 
-        def initialize code_object, location
-          super(location, code_object.namespace.to_s, code_object.name.to_s, comments_from(code_object), nil, nil, nil, code_object.visibility)
+        def initialize code_object, location, closure = nil
+          @code_object = code_object
+          closure ||= Solargraph::Pin::Namespace.new(
+            name: code_object.namespace.to_s
+          )
+          super(
+            location: location,
+            closure: closure,
+            name: code_object.name.to_s,
+            comments: comments_from(code_object),
+            visibility: code_object.visibility
+          )
         end
       end
     end
   end
 end
-map = Solargraph::ApiMap.new

data/lib/solargraph/pin/yard_pin/method.rb

@@ -4,15 +4,27 @@ module Solargraph
       class Method < Pin::Method
         include YardMixin
 
-        def initialize code_object, location, name = nil, scope = nil, visibility = nil
+        def initialize code_object, location, name = nil, scope = nil, visibility = nil, closure = nil
+          @code_object = code_object
           comments = (code_object.docstring ? code_object.docstring.all : nil)
-          super(location, code_object.namespace.to_s, name || code_object.name.to_s, comments, scope || code_object.scope, visibility || code_object.visibility, get_parameters(code_object), nil)
+          closure ||= Solargraph::Pin::Namespace.new(
+            name: code_object.namespace.to_s
+          )
+          super(
+            location: location,
+            closure: closure,
+            name: name || code_object.name.to_s,
+            comments: comments,
+            scope: scope || code_object.scope,
+            visibility: visibility || code_object.visibility,
+            args: get_parameters(code_object)
+          )
         end
 
-        def return_complex_type
-          @return_complex_type ||= Solargraph::ComplexType.try_parse(Solargraph::CoreFills::CUSTOM_RETURN_TYPES[path]) if Solargraph::CoreFills::CUSTOM_RETURN_TYPES.has_key?(path)
-          super
-        end
+        # def return_type
+        #   @return_type ||= Solargraph::ComplexType.try_parse(Solargraph::CoreFills::CUSTOM_RETURN_TYPES[path]) if Solargraph::CoreFills::CUSTOM_RETURN_TYPES.has_key?(path)
+        #   super
+        # end
 
         private
 

data/lib/solargraph/pin/yard_pin/namespace.rb

@@ -5,7 +5,19 @@ module Solargraph
         include YardMixin
 
         def initialize code_object, location
-          super(location, code_object.namespace.to_s, code_object.name.to_s, comments_from(code_object), namespace_type(code_object), code_object.visibility)
+          @code_object = code_object
+          closure = Solargraph::Pin::Namespace.new(
+            name: code_object.namespace.to_s,
+            closure: Pin::ROOT_PIN
+          )
+          super(
+            location: location,
+            name: code_object.name.to_s,
+            comments: comments_from(code_object),
+            type: namespace_type(code_object),
+            visibility: code_object.visibility,
+            closure: closure
+          )
         end
 
         private

data/lib/solargraph/position.rb

@@ -29,7 +29,7 @@ module Solargraph
     end
 
     def inspect
-      "<Position #{line}, #{character}>"
+      "#<#{self.class} #{line}, #{character}>"
     end
 
     # Get a numeric offset for the specified text and position.

data/lib/solargraph/range.rb

@@ -79,5 +79,9 @@ module Solargraph
       return false unless other.is_a?(Range)
       start == other.start && ending == other.ending
     end
+
+    def inspect
+      "#<#{self.class} #{start.inspect} to #{ending.inspect}>"
+    end
   end
 end

data/lib/solargraph/shell.rb

@@ -1,9 +1,6 @@
 require 'thor'
-require 'json'
-require 'fileutils'
-require 'rubygems/package'
-require 'zlib'
 require 'backport'
+require 'benchmark'
 
 module Solargraph
   class Shell < Thor
@@ -77,6 +74,10 @@ module Solargraph
       ver = version || Solargraph::YardMap::CoreDocs.best_download
       puts "Downloading docs for #{ver}..."
       Solargraph::YardMap::CoreDocs.download ver
+    rescue ArgumentError => e
+      STDERR.puts "ERROR: #{e.message}"
+      STDERR.puts "Run `solargraph available-cores` for a list."
+      exit 1
     end
 
     desc 'list-cores', 'List the local documentation versions'
@@ -98,5 +99,83 @@ module Solargraph
     def reporters
       puts Solargraph::Diagnostics.reporters
     end
+
+    desc 'typecheck [FILE]', 'Run the type checker'
+    long_desc %(
+      Perform type checking on one or more files is a workspace.
+      A normal check reports problems with type definitions in method
+      parameters and return values. A strict check performs static analysis of
+      code to validate return types and arguments in method calls.
+    )
+    option :strict, type: :boolean, aliases: :s, desc: 'Use strict typing', default: false
+    option :directory, type: :string, aliases: :d, desc: 'The workspace directory', default: '.'
+    def typecheck *files
+      directory = File.realpath(options[:directory])
+      api_map = Solargraph::ApiMap.load(directory)
+      if files.empty?
+        files = api_map.source_maps.map(&:filename)
+      else
+        files.map! { |file| File.realpath(file) }
+      end
+      probcount = 0
+      filecount = 0
+      files.each do |file|
+        checker = TypeChecker.new(file, api_map: api_map)
+        problems = checker.param_type_problems + checker.return_type_problems
+        problems.concat checker.strict_type_problems if options[:strict]
+        next if problems.empty?
+        problems.sort! { |a, b| a.location.range.start.line <=> b.location.range.start.line }
+        puts problems.map { |prob| "#{prob.location.filename}:#{prob.location.range.start.line + 1} - #{prob.message}" }.join("\n")
+        filecount += 1
+        probcount += problems.length
+      end
+      puts "#{probcount} problem#{probcount != 1 ? 's' : ''} found#{files.length != 1 ? " in #{filecount} of #{files.length} files" : ''}."
+    end
+
+    desc 'scan', 'Test the workspace for problems'
+    long_desc %(
+      A scan loads the entire workspace to make sure that the ASTs and
+      maps do not raise errors during analysis. It does not perform any type
+      checking or validation; it only confirms that the analysis itself is
+      error-free.
+    )
+    option :directory, type: :string, aliases: :d, desc: 'The workspace directory', default: '.'
+    option :verbose, type: :boolean, aliases: :v, desc: 'Verbose output', default: false
+    def scan
+      directory = File.realpath(options[:directory])
+      api_map = nil
+      time = Benchmark.measure {
+        api_map = Solargraph::ApiMap.load(directory)
+        api_map.pins.each do |pin|
+          begin
+            puts pin_description(pin) if options[:verbose]
+            pin.typify api_map
+            pin.probe api_map
+          rescue Exception => e
+            STDERR.puts "Error testing #{pin_description(pin)} #{pin.location ? "at #{pin.location.filename}:#{pin.location.range.start.line + 1}" : ''}"
+            STDERR.puts "[#{e.class}]: #{e.message}"
+            STDERR.puts e.backtrace.join("\n")
+            exit 1
+          end
+        end
+      }
+      puts "Scanned #{directory} (#{api_map.pins.length} pins) in #{time.real} seconds."
+    end
+
+    private
+
+    # @param pin [Solargraph::Pin::Base]
+    # @return [String]
+    def pin_description pin
+      if pin.path.nil? || pin.path.empty?
+        if pin.closure
+          "#{pin.closure.path} | #{pin.name}"
+        else
+          "#{pin.context.namespace} | #{pin.name}"
+        end
+      else
+        pin.path
+      end
+    end
   end
 end

data/lib/solargraph/source.rb

@@ -56,8 +56,8 @@ module Solargraph
         @comments = []
         @parsed = false
       rescue Exception => e
-        STDERR.puts e.message
-        STDERR.puts e.backtrace
+        Solargraph.logger.warn "[#{e.class}] #{e.message}"
+        Solargraph.logger.warn e.backtrace.join("\n")
         raise "Error parsing #{filename || '(source)'}: [#{e.class}] #{e.message}"
       ensure
         @code.freeze
@@ -191,8 +191,22 @@ module Solargraph
     # @param position [Position]
     # @return [Boolean]
     def string_at? position
-      string_ranges.each do |range|
-        return true if range.include?(position)
+      return false if Position.to_offset(code, position) >= code.length
+      string_nodes.each do |node|
+        range = Range.from_node(node)
+        next if range.ending.line < position.line
+        break if range.ending.line > position.line
+        return true if node.type == :str && range.include?(position) && range.start != position
+        if node.type == :dstr
+          inner = node_at(position.line, position.column)
+          next if inner.nil?
+          inner_range = Range.from_node(inner)
+          next unless range.include?(inner_range.ending)
+          return true if inner.type == :str
+          inner_code = at(Solargraph::Range.new(inner_range.start, position))
+          return true if (inner.type == :dstr && inner_range.ending.character <= position.character) && !inner_code.end_with?('}') ||
+            (inner.type != :dstr && inner_range.ending.line == position.line && position.character <= inner_range.ending.character && inner_code.end_with?('}'))
+        end
         break if range.ending.line > position.line
       end
       false
@@ -290,7 +304,7 @@ module Solargraph
       @associated_comments ||= begin
         result = {}
         Parser::Source::Comment.associate_locations(node, comments).each_pair do |loc, all|
-          block = all #.select{ |l| l.document? || code.lines[l.loc.line].strip.start_with?('#')}
+          block = all.select { |l| l.loc.line < loc.line }
           next if block.empty?
           result[loc.line] ||= []
           result[loc.line].concat block
@@ -351,9 +365,9 @@ module Solargraph
       @stringified_comments ||= {}
     end
 
-    # @return [Array<Range>]
-    def string_ranges
-      @string_ranges ||= string_ranges_in(@node)
+    # @return [Array<Parser::AST::Node>]
+    def string_nodes
+      @string_nodes ||= string_nodes_in(@node)
     end
 
     # @return [Array<Range>]
@@ -393,18 +407,24 @@ module Solargraph
       result
     end
 
-    def string_ranges_in n
+    # @param n [Parser::AST::Node]
+    # @return [Array<Parser::AST::Node>]
+    def string_nodes_in n
       result = []
       if n.is_a?(Parser::AST::Node)
-        if n.type == :str
-          result.push Range.from_node(n)
+        if n.type == :str || n.type == :dstr
+          result.push n
         else
-          n.children.each{ |c| result.concat string_ranges_in(c) }
+          n.children.each{ |c| result.concat string_nodes_in(c) }
         end
       end
       result
     end
 
+    # @param node [Parser::AST::Node]
+    # @param position [Position]
+    # @param stack [Array<Parser::AST::Node>]
+    # @return [void]
     def inner_tree_at node, position, stack
       return if node.nil?
       here = Range.from_to(node.loc.expression.line, node.loc.expression.column, node.loc.expression.last_line, node.loc.expression.last_column)

data/lib/solargraph/source/chain.rb

@@ -17,9 +17,7 @@ module Solargraph
       autoload :Literal,          'solargraph/source/chain/literal'
       autoload :Head,             'solargraph/source/chain/head'
 
-      # Chain#infer uses the inference stack to avoid recursing into itself.
-      # See Chain#active_signature for more information.
-      @@inference_stack = []
+      @@inference_depth = 0
 
       UNDEFINED_CALL = Chain::Call.new('<undefined>')
       UNDEFINED_CONSTANT = Chain::Constant.new('<undefined>')
@@ -43,16 +41,18 @@ module Solargraph
       # @param locals [Array<Pin::Base>]
       # @return [Array<Pin::Base>]
       def define api_map, name_pin, locals
+        rebind_block name_pin, api_map, locals
         return [] if undefined?
         working_pin = name_pin
         links[0..-2].each do |link|
           pins = link.resolve(api_map, working_pin, locals)
           # Locals are only used when resolving the first link
           locals = []
-          type = infer_first_defined(pins, api_map)
+          type = infer_first_defined(pins, working_pin, api_map)
           return [] if type.undefined?
           working_pin = Pin::ProxyType.anonymous(type)
         end
+        links.last.last_context = working_pin
         links.last.resolve(api_map, working_pin, locals)
       end
 
@@ -61,16 +61,10 @@ module Solargraph
       # @param locals [Array<Pin::Base>]
       # @return [ComplexType]
       def infer api_map, name_pin, locals
-        return ComplexType::UNDEFINED if undefined? || @@inference_stack.include?(active_signature(name_pin))
-        @@inference_stack.push active_signature(name_pin)
+        rebind_block name_pin, api_map, locals
         type = ComplexType::UNDEFINED
         pins = define(api_map, name_pin, locals)
-        pins.each do |pin|
-          type = pin.typify(api_map)
-          break unless type.undefined?
-        end
-        type = pins.first.probe(api_map) unless type.defined? || pins.empty?
-        @@inference_stack.pop
+        type = infer_first_defined(pins, links.last.last_context, api_map)
         type
       end
 
@@ -91,29 +85,55 @@ module Solargraph
 
       private
 
-      # Get a signature for this chain that includes the current context
-      # where it's being analyzed. Chain#infer uses this value to detect
-      # recursive inference into the same chain, e.g., when two variables
-      # reference each other in their assignments.
-      #
-      # @param pin [Pin::Base] The named pin context
-      # @return [String]
-      def active_signature(pin)
-        "#{pin.path}|#{links.map(&:word).join('.')}"
-      end
-
       # @param pins [Array<Pin::Base>]
       # @param api_map [ApiMap]
       # @return [ComplexType]
-      def infer_first_defined pins, api_map
+      def infer_first_defined pins, context, api_map
         type = ComplexType::UNDEFINED
+        return type if @@inference_depth >= 3
+        @@inference_depth += 1
         pins.each do |pin|
-          # type = pin.infer(api_map)
           type = pin.typify(api_map)
-          break unless type.undefined?
+          break if type.defined?
+        end
+        if type.undefined?
+          pins.each do |pin|
+            type = pin.probe(api_map)
+            break if type.defined?
+          end
+        end
+        @@inference_depth -= 1
+        return type if context.nil? || context.return_type.undefined?
+        type.self_to(context.return_type.namespace)
+      end
+
+      def skippable_block_receivers api_map
+        @@skippable_block_receivers ||= (
+          api_map.get_methods('Array', deep: false).map(&:name) +
+          api_map.get_methods('Enumerable', deep: false).map(&:name) +
+          api_map.get_methods('Hash', deep: false).map(&:name) +
+          ['new']
+        ).to_set
+      end
+
+      def rebind_block pin, api_map, locals
+        return unless pin.is_a?(Pin::Block) && pin.receiver && !pin.rebound?
+        # This first rebind just sets the block pin's rebound state
+        pin.rebind ComplexType::UNDEFINED
+        chain = Solargraph::Source::NodeChainer.chain(pin.receiver, pin.location.filename)
+        return if skippable_block_receivers(api_map).include?(chain.links.last.word)
+        if ['instance_eval', 'instance_exec', 'class_eval', 'class_exec', 'module_eval', 'module_exec'].include?(chain.links.last.word)
+          type = chain.base.infer(api_map, pin, locals)
+          pin.rebind type
+        else
+          receiver_pin = chain.define(api_map, pin, locals).first
+          return if receiver_pin.nil? || receiver_pin.docstring.nil?
+          ys = receiver_pin.docstring.tag(:yieldself)
+          unless ys.nil? || ys.types.nil? || ys.types.empty?
+            ysct = ComplexType.try_parse(*ys.types).qualify(api_map, receiver_pin.context.namespace)
+            pin.rebind ysct
+          end
         end
-        type = pins.first.probe(api_map) unless type.defined? || pins.empty?
-        type
       end
     end
   end