solargraph 0.58.2 → 0.59.0.dev.1

data/lib/solargraph/complex_type/unique_type.rb

@@ -11,7 +11,6 @@ module Solargraph
 
       attr_reader :all_params, :subtypes, :key_types
 
-      # @sg-ignore Fix "Not enough arguments to Module#protected"
       protected def equality_fields
         [@name, @all_params, @subtypes, @key_types]
       end
@@ -46,6 +45,7 @@ module Solargraph
         parameters_type = nil
         unless substring.empty?
           subs = ComplexType.parse(substring[1..-2], partial: true)
+          # @sg-ignore Need to add nil check here
           parameters_type = PARAMETERS_TYPE_BY_STARTING_TAG.fetch(substring[0])
           if parameters_type == :hash
             raise ComplexTypeError, "Bad hash type: name=#{name}, substring=#{substring}" unless !subs.is_a?(ComplexType) and subs.length == 2 and !subs[0].is_a?(UniqueType) and !subs[1].is_a?(UniqueType)
@@ -62,6 +62,7 @@ module Solargraph
             subtypes.concat subs
           end
         end
+        # @sg-ignore Need to add nil check here
         new(name, key_types, subtypes, rooted: rooted, parameters_type: parameters_type)
       end
 
@@ -109,6 +110,44 @@ module Solargraph
         end
       end
 
+      # @param exclude_types [ComplexType, nil]
+      # @param api_map [ApiMap]
+      # @return [ComplexType, self]
+      def exclude exclude_types, api_map
+        return self if exclude_types.nil?
+
+        types = items - exclude_types.items
+        types = [ComplexType::UniqueType::UNDEFINED] if types.empty?
+        ComplexType.new(types)
+      end
+
+      # @see https://en.wikipedia.org/wiki/Intersection_type
+      #
+      # @param intersection_type [ComplexType, ComplexType::UniqueType, nil]
+      # @param api_map [ApiMap]
+      # @return [self, ComplexType]
+      def intersect_with intersection_type, api_map
+        return self if intersection_type.nil?
+        return intersection_type if undefined?
+        types = []
+        # try to find common types via conformance
+        items.each do |ut|
+          intersection_type.each do |int_type|
+            if ut.conforms_to?(api_map, int_type, :assignment)
+              types << ut
+            elsif int_type.conforms_to?(api_map, ut, :assignment)
+              types << int_type
+            end
+          end
+        end
+        types = [ComplexType::UniqueType::UNDEFINED] if types.empty?
+        ComplexType.new(types)
+      end
+
+      def simplifyable_literal?
+        literal? && name != 'nil'
+      end
+
       def literal?
         non_literal_name != name
       end
@@ -118,6 +157,13 @@ module Solargraph
         @non_literal_name ||= determine_non_literal_name
       end
 
+      # @return [self]
+      def without_nil
+        return UniqueType::UNDEFINED if nil_type?
+
+        self
+      end
+
       # @return [String]
       def determine_non_literal_name
         # https://github.com/ruby/rbs/blob/master/docs/syntax.md
@@ -131,6 +177,7 @@ module Solargraph
         return 'NilClass' if name == 'nil'
         return 'Boolean' if ['true', 'false'].include?(name)
         return 'Symbol' if name[0] == ':'
+        # @sg-ignore Need to add nil check here
         return 'String' if ['"', "'"].include?(name[0])
         return 'Integer' if name.match?(/^-?\d+$/)
         name
@@ -138,17 +185,17 @@ module Solargraph
 
       def eql?(other)
         self.class == other.class &&
-          # @sg-ignore https://github.com/castwide/solargraph/pull/1114
+          # @sg-ignore flow sensitive typing should support .class == .class
           @name == other.name &&
-          # @sg-ignore https://github.com/castwide/solargraph/pull/1114
+          # @sg-ignore flow sensitive typing should support .class == .class
           @key_types == other.key_types &&
-          # @sg-ignore https://github.com/castwide/solargraph/pull/1114
+          # @sg-ignore flow sensitive typing should support .class == .class
           @subtypes == other.subtypes &&
-          # @sg-ignore https://github.com/castwide/solargraph/pull/1114
+          # @sg-ignore flow sensitive typing should support .class == .class
           @rooted == other.rooted? &&
-          # @sg-ignore https://github.com/castwide/solargraph/pull/1114
+          # @sg-ignore flow sensitive typing should support .class == .class
           @all_params == other.all_params &&
-          # @sg-ignore https://github.com/castwide/solargraph/pull/1114
+          # @sg-ignore flow sensitive typing should support .class == .class
           @parameters_type == other.parameters_type
       end
 
@@ -156,10 +203,86 @@ module Solargraph
         eql?(other)
       end
 
+      # https://www.playfulpython.com/type-hinting-covariance-contra-variance/
+
+      # "[Expected] type variables that are COVARIANT can be substituted with
+      #  a more specific [inferred] type without causing errors"
+      #
+      # "[Expected] type variables that are CONTRAVARIANT can be substituted
+      #   with a more general [inferred] type without causing errors"
+      #
+      # "[Expected] types where neither is possible are INVARIANT"
+      #
+      # @param _situation [:method_call, :return_type]
+      # @param default [Symbol] The default variance to return if the type is not one of the special cases
+      #
+      # @return [:invariant, :covariant, :contravariant]
+      def parameter_variance _situation, default = :covariant
+        # @todo RBS can specify variance - maybe we can use that info
+        #   and also let folks specify?
+        #
+        # Array/Set: ideally invariant, since we don't know if user is
+        #   going to add new stuff into it or read it.  But we don't
+        #   have a way to specify, so we use covariant
+        # Enumerable: covariant:  can't be changed, so we can pass
+        #   in more specific subtypes
+        # Hash: read-only would be covariant, read-write would be
+        #   invariant if we could distinguish that - should default to
+        #   covariant
+        # contravariant?: Proc - can be changed, so we can pass
+        #   in less specific super types
+        if ['Hash', 'Tuple', 'Array', 'Set', 'Enumerable'].include?(name) && fixed_parameters?
+          :covariant
+        else
+          default
+        end
+      end
+
+      # Whether this is an RBS interface like _ToAry or _Each.
+      def interface?
+        name.start_with?('_')
+      end
+
+      # @param other [UniqueType]
+      def erased_version_of?(other)
+        name == other.name && (all_params.empty? || all_params.all?(&:undefined?))
+      end
+
+      # @param api_map [ApiMap]
+      # @param expected [ComplexType::UniqueType, ComplexType]
+      # @param situation [:method_call, :assignment, :return_type]
+      # @param rules [Array<:allow_subtype_skew, :allow_empty_params, :allow_reverse_match, :allow_any_match, :allow_undefined, :allow_unresolved_generic>]
+      # @param variance [:invariant, :covariant, :contravariant]
+      def conforms_to?(api_map, expected, situation, rules = [],
+                       variance: erased_variance(situation))
+        return true if undefined? && rules.include?(:allow_undefined)
+
+        # @todo teach this to validate duck types as inferred type
+        return true if duck_type?
+
+        # complex types as expectations are unions - we only need to
+        # match one of their unique types
+        expected.any? do |expected_unique_type|
+          # :nocov:
+          unless expected_unique_type.instance_of?(UniqueType)
+            raise "Expected type must be a UniqueType, got #{expected_unique_type.class} in #{expected.inspect}"
+          end
+          # :nocov:
+          conformance = Conformance.new(api_map, self, expected_unique_type, situation,
+                                        rules, variance: variance)
+          conformance.conforms_to_unique_type?
+        end
+      end
+
       def hash
         [self.class, @name, @key_types, @sub_types, @rooted, @all_params, @parameters_type].hash
       end
 
+      # @return [self]
+      def erase_parameters
+        UniqueType.new(name, rooted: rooted?, parameters_type: parameters_type)
+      end
+
       # @return [Array<UniqueType>]
       def items
         [self]
@@ -181,6 +304,7 @@ module Solargraph
         rooted_tags
       end
 
+      # @sg-ignore Need better if/elseanalysis
       # @return [String]
       def to_rbs
         if duck_type?
@@ -190,7 +314,7 @@ module Solargraph
         elsif name.downcase == 'nil'
           'nil'
         elsif name == GENERIC_TAG_NAME
-          all_params.first.name
+          all_params.first&.name
         elsif ['Class', 'Module'].include?(name)
           rbs_name
         elsif ['Tuple', 'Array'].include?(name) && fixed_parameters?
@@ -242,16 +366,13 @@ module Solargraph
         name == GENERIC_TAG_NAME || all_params.any?(&:generic?)
       end
 
-      # @param api_map [ApiMap] The ApiMap that performs qualification
-      # @param atype [ComplexType] type which may be assigned to this type
-      def can_assign?(api_map, atype)
-        logger.debug { "UniqueType#can_assign?(self=#{rooted_tags.inspect}, atype=#{atype.rooted_tags.inspect})" }
-        downcasted_atype = atype.downcast_to_literal_if_possible
-        out = downcasted_atype.all? do |autype|
-          autype.name == name || api_map.super_and_sub?(name, autype.name)
-        end
-        logger.debug { "UniqueType#can_assign?(self=#{rooted_tags.inspect}, atype=#{atype.rooted_tags.inspect}) => #{out}" }
-        out
+      def nullable?
+        nil_type?
+      end
+
+      # @yieldreturn [Boolean]
+      def all? &block
+        block.yield self
       end
 
       # @return [UniqueType]
@@ -260,15 +381,18 @@ module Solargraph
       end
 
       # @param generics_to_resolve [Enumerable<String>]
-      # @param context_type [UniqueType, nil]
+      # @param context_type [ComplexType, UniqueType, nil]
       # @param resolved_generic_values [Hash{String => ComplexType, ComplexType::UniqueType}] Added to as types are encountered or resolved
       # @return [UniqueType, ComplexType]
       def resolve_generics_from_context generics_to_resolve, context_type, resolved_generic_values: {}
         if name == ComplexType::GENERIC_TAG_NAME
           type_param = subtypes.first&.name
+          # @sg-ignore flow sensitive typing needs to eliminate literal from union with [:bar].include?(foo)
           return self unless generics_to_resolve.include? type_param
+          # @sg-ignore flow sensitive typing needs to eliminate literal from union with [:bar].include?(foo)
           unless context_type.nil? || !resolved_generic_values[type_param].nil?
             new_binding = true
+            # @sg-ignore flow sensitive typing needs to eliminate literal from union with [:bar].include?(foo)
             resolved_generic_values[type_param] = context_type
           end
           if new_binding
@@ -276,6 +400,7 @@ module Solargraph
               complex_type.resolve_generics_from_context(generics_to_resolve, nil, resolved_generic_values: resolved_generic_values)
             end
           end
+          # @sg-ignore flow sensitive typing needs to eliminate literal from union with [:bar].include?(foo)
           return resolved_generic_values[type_param] || self
         end
 
@@ -286,7 +411,7 @@ module Solargraph
       end
 
       # @param generics_to_resolve [Enumerable<String>]
-      # @param context_type [UniqueType, nil]
+      # @param context_type [UniqueType, ComplexType, nil]
       # @param resolved_generic_values [Hash{String => ComplexType}]
       # @yieldreturn [Array<ComplexType>]
       # @return [Array<ComplexType>]
@@ -337,6 +462,7 @@ module Solargraph
                 ComplexType::UNDEFINED
               end
             else
+              # @sg-ignore Need to add nil check here
               context_type.all_params[idx] || definitions.generic_defaults[generic_name] || ComplexType::UNDEFINED
             end
           else
@@ -352,6 +478,13 @@ module Solargraph
         [block.yield(self)]
       end
 
+      # @yieldparam t [self]
+      # @yieldreturn [self]
+      # @return [Enumerable<self>]
+      def each &block
+        [self].each &block
+      end
+
       # @return [Array<UniqueType>]
       def to_a
         [self]
@@ -370,6 +503,7 @@ module Solargraph
         new_key_types ||= @key_types
         new_subtypes ||= @subtypes
         make_rooted = @rooted if make_rooted.nil?
+        # @sg-ignore flow sensitive typing needs better handling of ||= on lvars
         UniqueType.new(new_name, new_key_types, new_subtypes, rooted: make_rooted, parameters_type: parameters_type)
       end
 
@@ -443,6 +577,22 @@ module Solargraph
         end
       end
 
+      # @yieldreturn [Boolean]
+      def any? &block
+        block.yield self
+      end
+
+      # @return [ComplexType]
+      def reduce_class_type
+        new_items = items.flat_map do |type|
+          next type unless ['Module', 'Class'].include?(type.name)
+          next type if type.all_params.empty?
+
+          type.all_params
+        end
+        ComplexType.new(new_items)
+      end
+
       def all_rooted?
         return true if name == GENERIC_TAG_NAME
         rooted? && all_params.all?(&:rooted?)

data/lib/solargraph/complex_type.rb

@@ -9,6 +9,7 @@ module Solargraph
     #   include TypeMethods
     include Equality
 
+    autoload :Conformance, 'solargraph/complex_type/conformance'
     autoload :TypeMethods, 'solargraph/complex_type/type_methods'
     autoload :UniqueType,  'solargraph/complex_type/unique_type'
 
@@ -19,13 +20,15 @@ module Solargraph
       items = types.flat_map(&:items).uniq(&:to_s)
       if items.any? { |i| i.name == 'false' } && items.any? { |i| i.name == 'true' }
         items.delete_if { |i| i.name == 'false' || i.name == 'true' }
-        items.unshift(ComplexType::BOOLEAN)
+        items.unshift(UniqueType::BOOLEAN)
       end
+      # @type [Array<UniqueType>]
       items = [UniqueType::UNDEFINED] if items.any?(&:undefined?)
+      # @todo shouldn't need this cast - if statement above adds an 'Array' type
+      # @type [Array<UniqueType>]
       @items = items
     end
 
-    # @sg-ignore Fix "Not enough arguments to Module#protected"
     protected def equality_fields
       [self.class, items]
     end
@@ -44,7 +47,7 @@ module Solargraph
     end
 
     # @param generics_to_resolve [Enumerable<String>]]
-    # @param context_type [UniqueType, nil]
+    # @param context_type [ComplexType, ComplexType::UniqueType, nil]
     # @param resolved_generic_values [Hash{String => ComplexType}] Added to as types are encountered or resolved
     # @return [self]
     def resolve_generics_from_context generics_to_resolve, context_type, resolved_generic_values: {}
@@ -65,7 +68,7 @@ module Solargraph
        (@items.length > 1 ? ')' : ''))
     end
 
-    # @param dst [ComplexType]
+    # @param dst [ComplexType, ComplexType::UniqueType]
     # @return [ComplexType]
     def self_to_type dst
       object_type_dst = dst.reduce_class_type
@@ -76,9 +79,13 @@ module Solargraph
     end
 
     # @yieldparam [UniqueType]
+    # @yieldreturn [UniqueType]
     # @return [Array<UniqueType>]
-    def map &block
-      @items.map &block
+    # @sg-ignore Declared return type
+    #   ::Array<::Solargraph::ComplexType::UniqueType> does not match
+    #   inferred type ::Array<::Proc> for Solargraph::ComplexType#map
+    def map(&block)
+      @items.map(&block)
     end
 
     # @yieldparam [UniqueType]
@@ -99,12 +106,6 @@ module Solargraph
       end
     end
 
-    # @param atype [ComplexType] type which may be assigned to this type
-    # @param api_map [ApiMap] The ApiMap that performs qualification
-    def can_assign?(api_map, atype)
-      any? { |ut| ut.can_assign?(api_map, atype) }
-    end
-
     # @param new_name [String, nil]
     # @param make_rooted [Boolean, nil]
     # @param new_key_types [Array<ComplexType>, nil]
@@ -194,6 +195,60 @@ module Solargraph
       rooted_tags
     end
 
+    # @param api_map [ApiMap]
+    # @param expected [ComplexType, ComplexType::UniqueType]
+    # @param situation [:method_call, :return_type, :assignment]
+    # @param allow_subtype_skew [Boolean] if false, check if any
+    #   subtypes of the expected type match the inferred type
+    # @param allow_reverse_match [Boolean] if true, check if any subtypes
+    #   of the expected type match the inferred type
+    # @param allow_empty_params [Boolean] if true, allow a general
+    #   inferred type without parameters to conform to a more specific
+    #   expected type
+    # @param allow_any_match [Boolean] if true, any unique type
+    #   matched in the inferred qualifies as a match
+    # @param allow_undefined [Boolean] if true, treat undefined as a
+    #   wildcard that matches anything
+    # @param rules [Array<:allow_subtype_skew, :allow_empty_params, :allow_reverse_match, :allow_any_match, :allow_undefined, :allow_unresolved_generic, :allow_unmatched_interface>]
+    # @param variance [:invariant, :covariant, :contravariant]
+    # @return [Boolean]
+    def conforms_to?(api_map, expected,
+                     situation,
+                     rules = [],
+                     variance: erased_variance(situation))
+      expected = expected.downcast_to_literal_if_possible
+      inferred = downcast_to_literal_if_possible
+
+      return duck_types_match?(api_map, expected, inferred) if expected.duck_type?
+
+      if rules.include? :allow_any_match
+        inferred.any? do |inf|
+          inf.conforms_to?(api_map, expected, situation, rules,
+                           variance: variance)
+        end
+      else
+        inferred.all? do |inf|
+          inf.conforms_to?(api_map, expected, situation, rules,
+                           variance: variance)
+        end
+      end
+    end
+
+    # @param api_map [ApiMap]
+    # @param expected [ComplexType, UniqueType]
+    # @param inferred [ComplexType, UniqueType]
+    # @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..]
+        # @sg-ignore Need to add nil check here
+        return false if api_map.get_method_stack(inferred.namespace, quack, scope: inferred.scope).empty?
+      end
+      true
+    end
+
     # @return [String]
     def rooted_tags
       map(&:rooted_tag).join(', ')
@@ -252,6 +307,13 @@ module Solargraph
       @items.any?(&:nil_type?)
     end
 
+    # @return [ComplexType]
+    def without_nil
+      new_items = @items.reject(&:nil_type?)
+      return ComplexType::UNDEFINED if new_items.empty?
+      ComplexType.new(new_items)
+    end
+
     # @return [Array<ComplexType>]
     def all_params
       @items.first.all_params || []
@@ -274,6 +336,13 @@ module Solargraph
       all?(&:all_rooted?)
     end
 
+    # @param other [ComplexType, UniqueType]
+    def erased_version_of?(other)
+      return false if items.length != 1 || other.items.length != 1
+
+      @items.first.erased_version_of?(other.items.first)
+    end
+
     # every top-level type has resolved to be fully qualified; see
     # #all_rooted? to check their subtypes as well
     def rooted?
@@ -286,6 +355,40 @@ module Solargraph
       @items.all?(&:rooted?)
     end
 
+    # @param exclude_types [ComplexType, nil]
+    # @param api_map [ApiMap]
+    # @return [ComplexType, self]
+    def exclude exclude_types, api_map
+      return self if exclude_types.nil?
+
+      types = items - exclude_types.items
+      types = [ComplexType::UniqueType::UNDEFINED] if types.empty?
+      ComplexType.new(types)
+    end
+
+    # @see https://en.wikipedia.org/wiki/Intersection_type
+    #
+    # @param intersection_type [ComplexType, ComplexType::UniqueType, nil]
+    # @param api_map [ApiMap]
+    # @return [self, ComplexType::UniqueType]
+    def intersect_with intersection_type, api_map
+      return self if intersection_type.nil?
+      return intersection_type if undefined?
+      types = []
+      # try to find common types via conformance
+      items.each do |ut|
+        intersection_type.each do |int_type|
+          if int_type.conforms_to?(api_map, ut, :assignment)
+            types << int_type
+          elsif ut.conforms_to?(api_map, int_type, :assignment)
+            types << ut
+          end
+        end
+      end
+      types = [ComplexType::UniqueType::UNDEFINED] if types.empty?
+      ComplexType.new(types)
+    end
+
     protected
 
     # @return [ComplexType]
@@ -320,17 +423,18 @@ module Solargraph
       # #  @todo Need ability to use a literal true as a type below
       # #  @param partial [Boolean] True if the string is part of a another type
       # #  @return [Array<UniqueType>]
-      # @todo To be able to select the right signature above,
+      # @sg-ignore To be able to select the right signature above,
       #   Chain::Call needs to know the decl type (:arg, :optarg,
       #   :kwarg, etc) of the arguments given, instead of just having
       #   an array of Chains as the arguments.
       def parse *strings, partial: false
-        # @type [Hash{Array<String> => ComplexType}]
+        # @type [Hash{Array<String> => ComplexType, Array<ComplexType::UniqueType>}]
         @cache ||= {}
         unless partial
           cached = @cache[strings]
           return cached unless cached.nil?
         end
+        # @types [Array<ComplexType::UniqueType>]
         types = []
         key_types = nil
         strings.each do |type_string|
@@ -351,6 +455,7 @@ module Solargraph
               elsif base.end_with?('=')
                 raise ComplexTypeError, "Invalid hash thing" unless key_types.nil?
                 # types.push ComplexType.new([UniqueType.new(base[0..-2].strip)])
+                # @sg-ignore Need to add nil check here
                 types.push UniqueType.parse(base[0..-2].strip, subtype_string)
                 # @todo this should either expand key_type's type
                 #   automatically or complain about not being

data/lib/solargraph/convention/data_definition/data_definition_node.rb

@@ -66,7 +66,7 @@ module Solargraph
           end.compact
         end
 
-        # @return [Parser::AST::Node]
+        # @return [Parser::AST::Node, nil]
         def body_node
           node.children[2]
         end
@@ -81,8 +81,10 @@ module Solargraph
           node.children[1]
         end
 
+        # @sg-ignore Need to add nil check here
         # @return [Array<Parser::AST::Node>]
         def data_attribute_nodes
+          # @sg-ignore Need to add nil check here
           data_node.children[2..-1]
         end
       end

data/lib/solargraph/convention/data_definition.rb

@@ -17,6 +17,7 @@ module Solargraph
               type: :class,
               location: loc,
               closure: region.closure,
+              # @sg-ignore flow sensitive typing needs to handle attrs
               name: data_definition_node.class_name,
               comments: comments_for(node),
               visibility: :public,
@@ -39,6 +40,7 @@ module Solargraph
             # Solargraph::SourceMap::Clip#complete_keyword_parameters does not seem to currently take into account [Pin::Method#signatures] hence we only one for :kwarg
             pins.push initialize_method_pin
 
+            # @sg-ignore flow sensitive typing needs to handle attrs
             data_definition_node.attributes.map do |attribute_node, attribute_name|
               initialize_method_pin.parameters.push(
                 Pin::Parameter.new(
@@ -51,6 +53,7 @@ module Solargraph
             end
 
             # define attribute readers and instance variables
+            # @sg-ignore flow sensitive typing needs to handle attrs
             data_definition_node.attributes.each do |attribute_node, attribute_name|
               name = attribute_name.to_s
               method_pin = Pin::Method.new(
@@ -78,7 +81,7 @@ module Solargraph
 
           private
 
-          # @return [DataDefintionNode, nil]
+          # @return [DataDefinition::DataDefintionNode, DataDefinition::DataAssignmentNode, nil]
           def data_definition_node
             @data_definition_node ||= if DataDefintionNode.match?(node)
                                         DataDefintionNode.new(node)

data/lib/solargraph/convention/struct_definition/struct_assignment_node.rb

@@ -22,6 +22,7 @@ module Solargraph
           #     s(:def, :foo,
           #       s(:args),
           #       s(:send, nil, :bar))))
+          #
           # @param node [Parser::AST::Node]
           def match?(node)
             return false unless node&.type == :casgn

data/lib/solargraph/convention/struct_definition/struct_definition_node.rb

@@ -92,6 +92,7 @@ module Solargraph
           node.children[1]
         end
 
+        # @sg-ignore Need to add nil check here
         # @return [Array<Parser::AST::Node>]
         def struct_attribute_nodes
           struct_node.children[2..-1]

data/lib/solargraph/convention/struct_definition.rb

@@ -17,6 +17,7 @@ module Solargraph
               type: :class,
               location: loc,
               closure: region.closure,
+              # @sg-ignore flow sensitive typing needs to handle attrs
               name: struct_definition_node.class_name,
               docstring: docstring,
               visibility: :public,
@@ -39,6 +40,7 @@ module Solargraph
 
             pins.push initialize_method_pin
 
+            # @sg-ignore flow sensitive typing needs to handle attrs
             struct_definition_node.attributes.map do |attribute_node, attribute_name|
               initialize_method_pin.parameters.push(
                 Pin::Parameter.new(
@@ -52,6 +54,7 @@ module Solargraph
             end
 
             # define attribute accessors and instance variables
+            # @sg-ignore flow sensitive typing needs to handle attrs
             struct_definition_node.attributes.each do |attribute_node, attribute_name|
               [attribute_name, "#{attribute_name}="].each do |name|
                 docs = docstring.tags.find { |t| t.tag_name == 'param' && t.name == attribute_name }
@@ -102,7 +105,7 @@ module Solargraph
 
           private
 
-          # @return [StructDefintionNode, StructAssignmentNode, nil]
+          # @return [StructDefinition::StructDefintionNode, StructDefinition::StructAssignmentNode, nil]
           def struct_definition_node
             @struct_definition_node ||= if StructDefintionNode.match?(node)
                                           StructDefintionNode.new(node)
@@ -121,6 +124,7 @@ module Solargraph
           # @return [YARD::Docstring]
           def parse_comments
             struct_comments = comments_for(node) || ''
+            # @sg-ignore Need to add nil check here
             struct_definition_node.attributes.each do |attr_node, attr_name|
               comment = comments_for(attr_node)
               next if comment.nil?

data/lib/solargraph/diagnostics/require_not_found.rb

@@ -10,6 +10,7 @@ module Solargraph
         return [] unless source.parsed? && source.synchronized?
         result = []
         refs = {}
+        # @sg-ignore Need to add nil check here
         map = api_map.source_map(source.filename)
         map.requires.each { |ref| refs[ref.name] = ref }
         api_map.missing_docs.each do |r|

data/lib/solargraph/diagnostics/rubocop.rb

@@ -25,6 +25,7 @@ module Solargraph
       def diagnose source, _api_map
         @source = source
         require_rubocop(rubocop_version)
+        # @sg-ignore Need to add nil check here
         options, paths = generate_options(source.filename, source.code)
         store = RuboCop::ConfigStore.new
         runner = RuboCop::Runner.new(options, store)