solargraph 0.54.4 → 0.58.3

data/lib/solargraph/type_checker/checks.rb

@@ -1,120 +1,124 @@
-# 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
-        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
-        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
+# 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,35 +1,37 @@
-# 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
-
-      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
+# 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/type_checker/problem.rb

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

data/lib/solargraph/type_checker/rules.rb

@@ -1,62 +1,84 @@
-# frozen_string_literal: true
-
-module Solargraph
-  class TypeChecker
-    # Definitions of type checking rules to be performed at various levels
-    #
-    class Rules
-      LEVELS = {
-        normal: 0,
-        typed: 1,
-        strict: 2,
-        strong: 3,
-        alpha: 4
-      }.freeze
-
-      # @return [Symbol]
-      attr_reader :level
-
-      # @return [Integer]
-      attr_reader :rank
-
-      # @param level [Symbol]
-      def initialize level
-        @rank = if LEVELS.key?(level)
-          LEVELS[level]
-        else
-          Solargraph.logger.warn "Unrecognized TypeChecker level #{level}, assuming normal"
-          0
-        end
-        @level = LEVELS[LEVELS.values.index(@rank)]
-      end
-
-      def ignore_all_undefined?
-        rank < LEVELS[:strict]
-      end
-
-      def validate_consts?
-        rank >= LEVELS[:strict]
-      end
-
-      def validate_calls?
-        rank >= LEVELS[:strict]
-      end
-
-      def require_type_tags?
-        rank >= LEVELS[:strong]
-      end
-
-      def must_tag_or_infer?
-        rank > LEVELS[:typed]
-      end
-
-      def validate_tags?
-        rank > LEVELS[:normal]
-      end
-
-      def require_all_return_types_match_inferred?
-        rank >= LEVELS[:alpha]
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  class TypeChecker
+    # Definitions of type checking rules to be performed at various levels
+    #
+    class Rules
+      LEVELS = {
+        normal: 0,
+        typed: 1,
+        strict: 2,
+        strong: 3,
+        alpha: 4
+      }.freeze
+
+      # @return [Symbol]
+      attr_reader :level
+
+      # @return [Integer]
+      attr_reader :rank
+
+      # @param level [Symbol]
+      # @param overrides [Hash{Symbol => Symbol}]
+      def initialize level, overrides
+        @rank = if LEVELS.key?(level)
+          LEVELS[level]
+        else
+          Solargraph.logger.warn "Unrecognized TypeChecker level #{level}, assuming normal"
+          0
+        end
+        @level = LEVELS[LEVELS.values.index(@rank)]
+        @overrides = overrides
+      end
+
+      def ignore_all_undefined?
+        !report_undefined?
+      end
+
+      def report_undefined?
+        report?(:report_undefined, :strict)
+      end
+
+      def validate_consts?
+        report?(:validate_consts, :strict)
+      end
+
+      def validate_calls?
+        report?(:validate_calls, :strict)
+      end
+
+      def require_type_tags?
+        report?(:validate_type_tags, :strong)
+      end
+
+      def must_tag_or_infer?
+        report?(:must_tag_or_infer, :strict)
+      end
+
+      def validate_tags?
+        report?(:validate_tags, :typed)
+      end
+
+      def require_all_return_types_match_inferred?
+        report?(:require_all_return_types_match_inferred, :alpha)
+      end
+
+      # We keep this at strong because if you added an @ sg-ignore to
+      # address a strong-level issue, then ran at a lower level, you'd
+      # get a false positive - we don't run stronger level checks than
+      # requested for performance reasons
+      def validate_sg_ignores?
+        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
+end