solargraph 0.58.2 → 0.59.0.dev.2

data/lib/solargraph/type_checker/checks.rb

@@ -1,124 +0,0 @@
-# frozen_string_literal: true
-
-module Solargraph
-  class TypeChecker
-    # Helper methods for performing type checks
-    #
-    module Checks
-      module_function
-
-      # Compare an expected type with an inferred type. Common usage is to
-      # check if the type declared in a method's @return tag matches the type
-      # inferred from static analysis of the code.
-      #
-      # @param api_map [ApiMap]
-      # @param expected [ComplexType]
-      # @param inferred [ComplexType]
-      # @return [Boolean]
-      def types_match? api_map, expected, inferred
-        return true if expected.to_s == inferred.to_s
-        matches = []
-        expected.each do |exp|
-          found = false
-          inferred.each do |inf|
-            # if api_map.super_and_sub?(fuzz(inf), fuzz(exp))
-            if either_way?(api_map, inf, exp)
-              found = true
-              matches.push inf
-              break
-            end
-          end
-          return false unless found
-        end
-        inferred.each do |inf|
-          next if matches.include?(inf)
-          found = false
-          expected.each do |exp|
-            # if api_map.super_and_sub?(fuzz(inf), fuzz(exp))
-            if either_way?(api_map, inf, exp)
-              found = true
-              break
-            end
-          end
-          return false unless found
-        end
-        true
-      end
-
-      # @param api_map [ApiMap]
-      # @param expected [ComplexType]
-      # @param inferred [ComplexType]
-      # @return [Boolean]
-      def any_types_match? api_map, expected, inferred
-        expected = expected.downcast_to_literal_if_possible
-        inferred = inferred.downcast_to_literal_if_possible
-        return duck_types_match?(api_map, expected, inferred) if expected.duck_type?
-        # walk through the union expected type and see if any members
-        # of the union match the inferred type
-        expected.each do |exp|
-          next if exp.duck_type?
-          # @todo: there should be a level of typechecking where all
-          #   unique types in the inferred must match one of the
-          #   expected unique types
-          inferred.each do |inf|
-            # return true if exp == inf || api_map.super_and_sub?(fuzz(inf), fuzz(exp))
-            return true if exp == inf || either_way?(api_map, inf, exp)
-          end
-        end
-        false
-      end
-
-      # @param api_map [ApiMap]
-      # @param inferred [ComplexType]
-      # @param expected [ComplexType]
-      # @return [Boolean]
-      def all_types_match? api_map, inferred, expected
-        expected = expected.downcast_to_literal_if_possible
-        inferred = inferred.downcast_to_literal_if_possible
-        return duck_types_match?(api_map, expected, inferred) if expected.duck_type?
-        inferred.each do |inf|
-          next if inf.duck_type?
-          return false unless expected.any? { |exp| exp == inf || either_way?(api_map, inf, exp) }
-        end
-        true
-      end
-
-      # @param api_map [ApiMap]
-      # @param expected [ComplexType]
-      # @param inferred [ComplexType]
-      # @return [Boolean]
-      def duck_types_match? api_map, expected, inferred
-        raise ArgumentError, 'Expected type must be duck type' unless expected.duck_type?
-        expected.each do |exp|
-          next unless exp.duck_type?
-          quack = exp.to_s[1..-1]
-          return false if api_map.get_method_stack(inferred.namespace, quack, scope: inferred.scope).empty?
-        end
-        true
-      end
-
-      # @param type [ComplexType::UniqueType]
-      # @return [String]
-      def fuzz type
-        if type.parameters?
-          type.name
-        else
-          type.tag
-        end
-      end
-
-      # @param api_map [ApiMap]
-      # @param cls1 [ComplexType::UniqueType]
-      # @param cls2 [ComplexType::UniqueType]
-      # @return [Boolean]
-      def either_way?(api_map, cls1, cls2)
-        # @todo there should be a level of typechecking which uses the
-        #   full tag with parameters to determine compatibility
-        f1 = cls1.name
-        f2 = cls2.name
-        api_map.type_include?(f1, f2) || api_map.super_and_sub?(f1, f2) || api_map.super_and_sub?(f2, f1)
-        # api_map.type_include?(f1, f2) || api_map.super_and_sub?(f1, f2) || api_map.super_and_sub?(f2, f1)
-      end
-    end
-  end
-end

data/lib/solargraph/type_checker/param_def.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-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
-
-      # @param name [String]
-      # @param type [Symbol] The type of parameter, such as :req, :opt, :rest, etc.
-      def initialize name, type
-        @name = name
-        @type = type
-      end
-
-      class << self
-        # Get an array of ParamDefs from a method pin.
-        #
-        # @param pin [Solargraph::Pin::Method]
-        # @return [Array<ParamDef>]
-        def from pin
-          result = []
-          pin.parameters.each do |par|
-            result.push ParamDef.new(par.name, par.decl)
-          end
-          result
-        end
-      end
-    end
-  end
-end

data/lib/solargraph/yard_map/to_method.rb

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-module Solargraph
-  class YardMap
-    class ToMethod
-      module InnerMethods
-        module_function
-
-        # @param code_object [YARD::CodeObjects::Base]
-        # @param location [Solargraph::Location]
-        # @param comments [String]
-        # @return [Array<Solargraph::Pin::Parameter>]
-        def get_parameters code_object, location, comments
-          return [] unless code_object.is_a?(YARD::CodeObjects::MethodObject)
-          # HACK: Skip `nil` and `self` parameters that are sometimes emitted
-          # for methods defined in C
-          # See https://github.com/castwide/solargraph/issues/345
-          # @sg-ignore https://github.com/castwide/solargraph/pull/1114
-          code_object.parameters.select { |a| a[0] && a[0] != 'self' }.map do |a|
-            Solargraph::Pin::Parameter.new(
-              location: location,
-              closure: self,
-              comments: comments,
-              name: arg_name(a),
-              presence: nil,
-              decl: arg_type(a),
-              asgn_code: a[1],
-              source: :yard_map
-            )
-          end
-        end
-
-        # @param a [Array<String>]
-        # @return [String]
-        def arg_name a
-          a[0].gsub(/[^a-z0-9_]/i, '')
-        end
-
-        # @param a [Array]
-        # @return [::Symbol]
-        def arg_type a
-          if a[0].start_with?('**')
-            :kwrestarg
-          elsif a[0].start_with?('*')
-            :restarg
-          elsif a[0].start_with?('&')
-            :blockarg
-          elsif a[0].end_with?(':')
-            a[1] ? :kwoptarg : :kwarg
-          elsif a[1]
-            :optarg
-          else
-            :arg
-          end
-        end
-      end
-      private_constant :InnerMethods
-
-      include Helpers
-
-      # @param code_object [YARD::CodeObjects::MethodObject]
-      # @param name [String, nil]
-      # @param scope [Symbol, nil]
-      # @param visibility [Symbol, nil]
-      # @param closure [Solargraph::Pin::Base, nil]
-      # @param spec [Solargraph::Pin::Base, nil]
-      # @return [Solargraph::Pin::Method]
-      def make code_object, name = nil, scope = nil, visibility = nil, closure = nil, spec = nil
-        closure ||= Solargraph::Pin::Namespace.new(
-          name: code_object.namespace.to_s,
-          gates: [code_object.namespace.to_s]
-        )
-        location = object_location(code_object, spec)
-        comments = code_object.docstring ? code_object.docstring.all.to_s : ''
-        Pin::Method.new(
-          location: location,
-          closure: closure,
-          name: name || code_object.name.to_s,
-          comments: comments,
-          scope: scope || code_object.scope,
-          visibility: visibility || code_object.visibility,
-          parameters: InnerMethods.get_parameters(code_object, location, comments),
-          explicit: code_object.is_explicit?,
-          source: :yard_map
-        )
-      end
-    end
-  end
-end