solargraph 0.59.1 → 0.59.2

data/lib/solargraph/source/chain/head.rb

@@ -1,19 +1,19 @@
-# frozen_string_literal: true
-
-module Solargraph
-  class Source
-    class Chain
-      # Chain::Head is a link for ambiguous words, e.g.; `String` can refer to
-      # either a class (`String`) or a function (`Kernel#String`).
-      #
-      # @note Chain::Head is only intended to handle `self` and `super`.
-      class Head < Link
-        def resolve api_map, name_pin, locals
-          return [Pin::ProxyType.anonymous(name_pin.binder, source: :chain)] if word == 'self'
-          # return super_pins(api_map, name_pin) if word == 'super'
-          []
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    class Chain
+      # Chain::Head is a link for ambiguous words, e.g.; `String` can refer to
+      # either a class (`String`) or a function (`Kernel#String`).
+      #
+      # @note Chain::Head is only intended to handle `self` and `super`.
+      class Head < Link
+        def resolve api_map, name_pin, locals
+          return [Pin::ProxyType.anonymous(name_pin.binder, source: :chain)] if word == 'self'
+          # return super_pins(api_map, name_pin) if word == 'super'
+          []
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source/chain/literal.rb

@@ -13,21 +13,25 @@ module Solargraph
         def initialize type, node
           super("<#{type}>")
 
-          if node.is_a?(::Parser::AST::Node)
-            # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
-            if node.type == :true
-              @value = true
-            # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
-            elsif node.type == :false
-              @value = false
-            # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
-            elsif %i[int sym].include?(node.type)
-              # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
-              @value = node.children.first
-            end
-          end
+          # @todo We might be able to do some light inference from literals and
+          #   tuples as long as literal values are intransitive.
+
+          # if node.is_a?(::Parser::AST::Node)
+          #   # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
+          #   if node.type == :true
+          #     @value = true
+          #   # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
+          #   elsif node.type == :false
+          #     @value = false
+          #   # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
+          #   elsif %i[int sym].include?(node.type)
+          #     # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
+          #     @value = node.children.first
+          #   end
+          # end
           @type = type
-          @literal_type = ComplexType.try_parse(@value.inspect)
+          # @literal_type = ComplexType.try_parse(@value.inspect)
+          @literal_type = ComplexType::UNDEFINED
           @complex_type = ComplexType.try_parse(type)
         end
 

data/lib/solargraph/source/source_chainer.rb

@@ -32,10 +32,10 @@ module Solargraph
       # @return [Source::Chain]
       def chain
         # Special handling for files that end with an integer and a period
-        if phrase =~ /^[0-9]+\.$/
-          return Chain.new([Chain::Literal.new('Integer', Integer(phrase[0..-2])),
-                            Chain::UNDEFINED_CALL])
-        end
+        # if phrase =~ /^[0-9]+\.$/
+        #   return Chain.new([Chain::Literal.new('Integer', Integer(phrase[0..-2])),
+        #                     Chain::UNDEFINED_CALL])
+        # end
         if phrase.start_with?(':') && !phrase.start_with?('::')
           return Chain.new([Chain::Literal.new('Symbol',
                                                # @sg-ignore Need to add nil check here

data/lib/solargraph/version.rb

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

data/lib/solargraph/yard_map/cache.rb

@@ -1,25 +1,25 @@
-# frozen_string_literal: true
-
-module Solargraph
-  class YardMap
-    class Cache
-      def initialize
-        # @type [Hash{String => Array<Solargraph::Pin::Base>}]
-        @path_pins = {}
-      end
-
-      # @param path [String]
-      # @param pins [Array<Solargraph::Pin::Base>]
-      # @return [Array<Solargraph::Pin::Base>]
-      def set_path_pins path, pins
-        @path_pins[path] = pins
-      end
-
-      # @param path [String]
-      # @return [Array<Solargraph::Pin::Base>]
-      def get_path_pins path
-        @path_pins[path]
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  class YardMap
+    class Cache
+      def initialize
+        # @type [Hash{String => Array<Solargraph::Pin::Base>}]
+        @path_pins = {}
+      end
+
+      # @param path [String]
+      # @param pins [Array<Solargraph::Pin::Base>]
+      # @return [Array<Solargraph::Pin::Base>]
+      def set_path_pins path, pins
+        @path_pins[path] = pins
+      end
+
+      # @param path [String]
+      # @return [Array<Solargraph::Pin::Base>]
+      def get_path_pins path
+        @path_pins[path]
+      end
+    end
+  end
+end

data/lib/solargraph/yard_map/mapper/to_constant.rb

@@ -1,28 +1,28 @@
-# frozen_string_literal: true
-
-module Solargraph
-  class YardMap
-    class Mapper
-      module ToConstant
-        extend YardMap::Helpers
-
-        # @param code_object [YARD::CodeObjects::Base]
-        # @param closure [Pin::Closure, nil]
-        # @param spec [Gem::Specification, nil]
-        # @return [Pin::Constant]
-        def self.make code_object, closure = nil, spec = nil
-          closure ||= create_closure_namespace_for(code_object, spec)
-
-          Pin::Constant.new(
-            location: object_location(code_object, spec),
-            closure: closure,
-            name: code_object.name.to_s,
-            comments: code_object.docstring ? code_object.docstring.all.to_s : '',
-            visibility: code_object.visibility,
-            source: :yardoc
-          )
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  class YardMap
+    class Mapper
+      module ToConstant
+        extend YardMap::Helpers
+
+        # @param code_object [YARD::CodeObjects::Base]
+        # @param closure [Pin::Closure, nil]
+        # @param spec [Gem::Specification, nil]
+        # @return [Pin::Constant]
+        def self.make code_object, closure = nil, spec = nil
+          closure ||= create_closure_namespace_for(code_object, spec)
+
+          Pin::Constant.new(
+            location: object_location(code_object, spec),
+            closure: closure,
+            name: code_object.name.to_s,
+            comments: code_object.docstring ? code_object.docstring.all.to_s : '',
+            visibility: code_object.visibility,
+            source: :yardoc
+          )
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: solargraph
 version: !ruby/object:Gem::Version
-  version: 0.59.1
+  version: 0.59.2
 platform: ruby
 authors:
 - Fred Snyder
@@ -804,7 +804,6 @@ files:
 - rbs/fills/rubygems/0/errors.rbs
 - rbs/fills/rubygems/0/spec_fetcher.rbs
 - rbs/fills/rubygems/0/specification.rbs
-- rbs/fills/tuple/tuple.rbs
 - rbs/shims/ast/0/node.rbs
 - rbs/shims/ast/2.4/.rbs_meta.yaml
 - rbs/shims/ast/2.4/ast.rbs

data/rbs/fills/tuple/tuple.rbs

@@ -1,177 +0,0 @@
-# <-- liberally borrowed from
-#     https://github.com/ruby/rbs/blob/master/core/array.rbs, which
-#     was generated from
-#     https://github.com/ruby/ruby/blob/master/array.c
-#     -->
-module Solargraph
-  module Fills
-    class Tuple[unchecked out A,
-                unchecked out B = A,
-                unchecked out C = A | B,
-                unchecked out D = A | B | C,
-                unchecked out E = A | B | C | D,
-                unchecked out F = A | B | C | D | E,
-                unchecked out G = A | B | C | D | E | F,
-                unchecked out H = A | B | C | D | E | F | G,
-                unchecked out I = A | B | C | D | E | F | G | H,
-                unchecked out J = A | B | C | D | E | F | G | H | I] < Array[A | B | C | D | E | F | G | H | I | J]
-      # <!--
-      #   rdoc-file=array.c
-      #   - self[index] -> object or nil
-      # -->
-      # Returns elements from `self`; does not modify `self`.
-      #
-      # In brief:
-      #
-      #     a = [:foo, 'bar', 2]
-      #
-      #     # Single argument index: returns one element.
-      #     a[0]     # => :foo          # Zero-based index.
-      #
-      # When a single integer argument `index` is given, returns the element at offset
-      # `index`:
-      #
-      #     a = [:foo, 'bar', 2]
-      #     a[0] # => :foo
-      #     a[2] # => 2
-      #     a # => [:foo, "bar", 2]
-      def []: (0 index) -> A
-            | (1 index) -> B
-            | (2 index) -> C
-            | (3 index) -> D
-            | (4 index) -> E
-            | (5 index) -> F
-            | (6 index) -> G
-            | (7 index) -> H
-            | (8 index) -> I
-            | (9 index) -> J
-            | (int index) -> nil
-
-      # <!--
-      #   rdoc-file=array.c
-      #   - at(index) -> object or nil
-      # -->
-      # Returns the element of `self` specified by the given `index` or `nil` if there
-      # is no such element; `index` must be an [integer-convertible
-      # object](rdoc-ref:implicit_conversion.rdoc@Integer-Convertible+Objects).
-      #
-      # For non-negative `index`, returns the element of `self` at offset `index`:
-      #
-      #     a = [:foo, 'bar', 2]
-      #     a.at(0)   # => :foo
-      #     a.at(2)   # => 2
-      #     a.at(2.0) # => 2
-      #
-      # Related: Array#[]; see also [Methods for
-      # Fetching](rdoc-ref:Array@Methods+for+Fetching).
-      #
-      def at: (0 index) -> A
-            | (1 index) -> B
-            | (2 index) -> C
-            | (3 index) -> D
-            | (4 index) -> E
-            | (5 index) -> F
-            | (6 index) -> G
-            | (7 index) -> H
-            | (8 index) -> I
-            | (9 index) -> J
-            | (int index) -> nil
-
-      # <!--
-      #   rdoc-file=array.c
-      #   - fetch(index) -> element
-      #   - fetch(index, default_value) -> element or default_value
-      #   - fetch(index) {|index| ... } -> element or block_return_value
-      # -->
-      # Returns the element of `self` at offset `index` if `index` is in range;
-      # `index` must be an [integer-convertible
-      # object](rdoc-ref:implicit_conversion.rdoc@Integer-Convertible+Objects).
-      #
-      # With the single argument `index` and no block, returns the element at offset
-      # `index`:
-      #
-      #     a = [:foo, 'bar', 2]
-      #     a.fetch(1)   # => "bar"
-      #     a.fetch(1.1) # => "bar"
-      #
-      # With arguments `index` and `default_value` (which may be any object) and no
-      # block, returns `default_value` if `index` is out-of-range:
-      #
-      #     a = [:foo, 'bar', 2]
-      #     a.fetch(1, nil)  # => "bar"
-      #     a.fetch(3, :foo) # => :foo
-      #
-      # With argument `index` and a block, returns the element at offset `index` if
-      # index is in range (and the block is not called); otherwise calls the block
-      # with index and returns its return value:
-      #
-      #     a = [:foo, 'bar', 2]
-      #     a.fetch(1) {|index| raise 'Cannot happen' } # => "bar"
-      #     a.fetch(50) {|index| "Value for #{index}" } # => "Value for 50"
-      #
-      # Related: see [Methods for Fetching](rdoc-ref:Array@Methods+for+Fetching).
-      #
-      def fetch: (0 index) -> A
-               | (1 index) -> B
-               | (2 index) -> C
-               | (3 index) -> D
-               | (4 index) -> E
-               | (5 index) -> F
-               | (6 index) -> G
-               | (7 index) -> H
-               | (8 index) -> I
-               | (9 index) -> J
-               | (int index) -> void
-               | [T] (0 index, T default) -> (A | T)
-               | [T] (1 index, T default) -> (B | T)
-               | [T] (2 index, T default) -> (C | T)
-               | [T] (3 index, T default) -> (D | T)
-               | [T] (4 index, T default) -> (E | T)
-               | [T] (5 index, T default) -> (F | T)
-               | [T] (6 index, T default) -> (G | T)
-               | [T] (7 index, T default) -> (H | T)
-               | [T] (8 index, T default) -> (I | T)
-               | [T] (9 index, T default) -> (J | T)
-               | [T] (int index, T default) -> (A | B | C | D | E | F | G | H | I | J | T)
-               | [T] (0 index) { (int index) -> T } -> (A | T)
-               | [T] (1 index) { (int index) -> T } -> (B | T)
-               | [T] (2 index) { (int index) -> T } -> (C | T)
-               | [T] (3 index) { (int index) -> T } -> (D | T)
-               | [T] (4 index) { (int index) -> T } -> (E | T)
-               | [T] (5 index) { (int index) -> T } -> (F | T)
-               | [T] (6 index) { (int index) -> T } -> (G | T)
-               | [T] (7 index) { (int index) -> T } -> (H | T)
-               | [T] (8 index) { (int index) -> T } -> (I | T)
-               | [T] (9 index) { (int index) -> T } -> (J | T)
-               | [T] (int index) { (int index) -> T } -> (A | B | C | D | E | F | G | H | I | J | T)
-
-      # <!--
-      #   rdoc-file=array.rb
-      #   - first -> object or nil
-      #   - first(count) -> new_array
-      # -->
-      # Returns elements from `self`, or `nil`; does not modify `self`.
-      #
-      # With no argument given, returns the first element (if available):
-      #
-      #     a = [:foo, 'bar', 2]
-      #     a.first # => :foo
-      #     a # => [:foo, "bar", 2]
-      #
-      # If `self` is empty, returns `nil`.
-      #
-      #     [].first # => nil
-      #
-      # With a non-negative integer argument `count` given, returns the first `count`
-      # elements (as available) in a new array:
-      #
-      #     a.first(0)  # => []
-      #     a.first(2)  # => [:foo, "bar"]
-      #     a.first(50) # => [:foo, "bar", 2]
-      #
-      # Related: see [Methods for Querying](rdoc-ref:Array@Methods+for+Querying).
-      #
-      def first: %a{implicitly-returns-nil} () -> A
-    end
-  end
-end