solargraph 0.58.2 → 0.59.0.dev.2

data/lib/solargraph/source_map/clip.rb

@@ -12,7 +12,10 @@ module Solargraph
         @api_map = api_map
         @cursor = cursor
         closure_pin = closure
-        closure_pin.rebind(api_map) if closure_pin.is_a?(Pin::Block) && !Solargraph::Range.from_node(closure_pin.receiver).contain?(cursor.range.start)
+        # @sg-ignore Need to add nil check here
+        if closure_pin.is_a?(Pin::Block) && !Solargraph::Range.from_node(closure_pin.receiver).contain?(cursor.range.start)
+          closure_pin.rebind(api_map)
+        end
       end
 
       # @return [Array<Pin::Base>] Relevant pins for infering the type of the Cursor's position
@@ -20,7 +23,12 @@ module Solargraph
         return [] if cursor.comment? || cursor.chain.literal?
         result = cursor.chain.define(api_map, closure, locals)
         result.concat file_global_methods
-        result.concat((source_map.pins + source_map.locals).select{ |p| p.name == cursor.word && p.location.range.contain?(cursor.position) }) if result.empty?
+        if result.empty?
+          result.concat((source_map.pins + source_map.locals).select do |p|
+            # @sg-ignore Need to add nil check here
+            p.name == cursor.word && p.location.range.contain?(cursor.position)
+          end)
+        end
         result
       end
 
@@ -32,7 +40,9 @@ module Solargraph
       # @return [Completion]
       def complete
         return package_completions([]) if !source_map.source.parsed? || cursor.string?
-        return package_completions(api_map.get_symbols) if cursor.chain.literal? && cursor.chain.links.last.word == '<Symbol>'
+        if cursor.chain.literal? && cursor.chain.links.last.word == '<Symbol>'
+          return package_completions(api_map.get_symbols)
+        end
         return Completion.new([], cursor.range) if cursor.chain.literal?
         if cursor.comment?
           tag_complete
@@ -78,7 +88,7 @@ module Solargraph
       # @param phrase [String]
       # @return [Array<Solargraph::Pin::Base>]
       def translate phrase
-        chain = Parser.chain(Parser.parse(phrase))
+        chain = Parser.chain(Parser.parse(phrase, cursor.filename, cursor.position.line))
         chain.define(api_map, closure, locals)
       end
 
@@ -92,6 +102,7 @@ module Solargraph
 
       # @return [SourceMap]
       def source_map
+        # @sg-ignore Need to add nil check here
         @source_map ||= api_map.source_map(cursor.filename)
       end
 
@@ -125,12 +136,11 @@ module Solargraph
             next unless param.keyword?
             result.push Pin::KeywordParam.new(pin.location, "#{param.name}:")
           end
-          if !pin.parameters.empty? && pin.parameters.last.kwrestarg?
-            pin.docstring.tags(:param).each do |tag|
-              next if done.include?(tag.name)
-              done.push tag.name
-              result.push Pin::KeywordParam.new(pin.location, "#{tag.name}:")
-            end
+          next unless !pin.parameters.empty? && pin.parameters.last.kwrestarg?
+          pin.docstring.tags(:param).each do |tag|
+            next if done.include?(tag.name)
+            done.push tag.name
+            result.push Pin::KeywordParam.new(pin.location, "#{tag.name}:")
           end
         end
         result
@@ -140,27 +150,34 @@ module Solargraph
       # @return [Completion]
       def package_completions result
         frag_start = cursor.start_of_word.to_s.downcase
-        filtered = result.uniq(&:name).select { |s|
+        filtered = result.uniq(&:name).select do |s|
           s.name.downcase.start_with?(frag_start) &&
-            (!s.is_a?(Pin::Method) || s.name.match(/^[a-z0-9_]+(\!|\?|=)?$/i))
-        }
+            (!s.is_a?(Pin::Method) || s.name.match(/^[a-z0-9_]+(!|\?|=)?$/i))
+        end
         Completion.new(filtered, cursor.range)
       end
 
       # @return [Completion]
       def tag_complete
         result = []
-        match = source_map.code[0..cursor.offset-1].match(/[\[<, ]([a-z0-9_:]*)\z/i)
+        # @sg-ignore Need to add nil check here
+        match = source_map.code[0..(cursor.offset - 1)].match(/[\[<, ]([a-z0-9_:]*)\z/i)
         if match
+          # @sg-ignore Need to add nil check here
           full = match[1]
+          # @sg-ignore Need to add nil check here
           if full.include?('::')
+            # @sg-ignore Need to add nil check here
             if full.end_with?('::')
+              # @sg-ignore Need to add nil check here
               result.concat api_map.get_constants(full[0..-3], *gates)
             else
+              # @sg-ignore Need to add nil check here
               result.concat api_map.get_constants(full.split('::')[0..-2].join('::'), *gates)
             end
           else
-            result.concat api_map.get_constants('', full.end_with?('::') ? '' : context_pin.full_context.namespace, *gates) #.select { |pin| pin.name.start_with?(full) }
+            # @sg-ignore Need to add nil check here
+            result.concat api_map.get_constants('', full.end_with?('::') ? '' : context_pin.full_context.namespace, *gates) # .select { |pin| pin.name.start_with?(full) }
           end
         end
         package_completions(result)
@@ -173,24 +190,24 @@ module Solargraph
         if cursor.chain.constant? || cursor.start_of_constant?
           full = cursor.chain.links.first.word
           type = if cursor.chain.undefined?
-            cursor.chain.base.infer(api_map, context_pin, locals)
-          else
-            if full.include?('::') && cursor.chain.links.length == 1
-              ComplexType.try_parse(full.split('::')[0..-2].join('::'))
-            elsif cursor.chain.links.length > 1
-              ComplexType.try_parse(full)
-            else
-              ComplexType::UNDEFINED
-            end
-          end
+                   cursor.chain.base.infer(api_map, context_pin, locals)
+                 elsif full.include?('::') && cursor.chain.links.length == 1
+                   # @sg-ignore Need to add nil check here
+                   ComplexType.try_parse(full.split('::')[0..-2].join('::'))
+                 elsif cursor.chain.links.length > 1
+                   ComplexType.try_parse(full)
+                 else
+                   ComplexType::UNDEFINED
+                 end
           if type.undefined?
             if full.include?('::')
               result.concat api_map.get_constants(full, *gates)
             else
-              result.concat api_map.get_constants('', cursor.start_of_constant? ? '' : context_pin.full_context.namespace, *gates) #.select { |pin| pin.name.start_with?(full) }
+              result.concat api_map.get_constants('', cursor.start_of_constant? ? '' : context_pin.full_context.namespace, *gates) # .select { |pin| pin.name.start_with?(full) }
             end
           else
-            result.concat api_map.get_constants(type.namespace, cursor.start_of_constant? ? '' : context_pin.full_context.namespace, *gates)
+            result.concat api_map.get_constants(type.namespace,
+                                                cursor.start_of_constant? ? '' : context_pin.full_context.namespace, *gates)
           end
         else
           type = cursor.chain.base.infer(api_map, closure, locals)
@@ -199,14 +216,16 @@ module Solargraph
             if cursor.word.start_with?('@@')
               return package_completions(api_map.get_class_variable_pins(context_pin.full_context.namespace))
             elsif cursor.word.start_with?('@')
-              return package_completions(api_map.get_instance_variable_pins(closure.binder.namespace, closure.binder.scope))
+              return package_completions(api_map.get_instance_variable_pins(closure.full_context.namespace,
+                                                                            closure.context.scope))
             elsif cursor.word.start_with?('$')
               return package_completions(api_map.get_global_variable_pins)
             end
             result.concat locals
             result.concat file_global_methods unless closure.binder.namespace.empty?
             result.concat api_map.get_constants(context_pin.context.namespace, *gates)
-            result.concat api_map.get_methods(closure.binder.namespace, scope: closure.binder.scope, visibility: [:public, :private, :protected])
+            result.concat api_map.get_methods(closure.binder.namespace, scope: closure.binder.scope,
+                                                                        visibility: %i[public private protected])
             result.concat api_map.get_methods('Kernel')
             result.concat api_map.keyword_pins.to_a
           end

data/lib/solargraph/source_map/data.rb

@@ -8,13 +8,16 @@ module Solargraph
         @source = source
       end
 
+      # @sg-ignore Translate to something flow sensitive typing understands
       # @return [Array<Solargraph::Pin::Base>]
+      # @sg-ignore https://github.com/castwide/solargraph/pull/1100
       def pins
         generate
         @pins || []
       end
 
-      # @return [Array<Solargraph::LocalVariable>]
+      # @sg-ignore Translate to something flow sensitive typing understands
+      # @return [Array<Solargraph::Pin::LocalVariable>]
       def locals
         generate
         @locals || []

data/lib/solargraph/source_map/mapper.rb

@@ -12,7 +12,7 @@ module Solargraph
 
       private_class_method :new
 
-      DIRECTIVE_REGEXP = /(@\!method|@\!attribute|@\!visibility|@\!domain|@\!macro|@\!parse|@\!override)/.freeze
+      DIRECTIVE_REGEXP = /(@!method|@!attribute|@!visibility|@!domain|@!macro|@!parse|@!override)/
 
       # Generate the data.
       #
@@ -24,14 +24,15 @@ module Solargraph
         @code = source.code
         @comments = source.comments
         @pins, @locals = Parser.map(source)
+        # @param p [Solargraph::Pin::Base]
         @pins.each { |p| p.source = :code }
         @locals.each { |l| l.source = :code }
         process_comment_directives
         [@pins, @locals]
-      # rescue Exception => e
-      #   Solargraph.logger.warn "Error mapping #{source.filename}: [#{e.class}] #{e.message}"
-      #   Solargraph.logger.warn e.backtrace.join("\n")
-      #   [[], []]
+        # rescue Exception => e
+        #   Solargraph.logger.warn "Error mapping #{source.filename}: [#{e.class}] #{e.message}"
+        #   Solargraph.logger.warn e.backtrace.join("\n")
+        #   [[], []]
       end
 
       # @param filename [String]
@@ -48,6 +49,7 @@ module Solargraph
         # @param source [Source]
         # @return [Array]
         def map source
+          # @sg-ignore Need to add nil check here
           return new.unmap(source.filename, source.code) unless source.parsed?
           new.map source
         end
@@ -61,8 +63,9 @@ module Solargraph
 
       # @param position [Solargraph::Position]
       # @return [Solargraph::Pin::Closure]
-      def closure_at(position)
-        pins.select{|pin| pin.is_a?(Pin::Closure) and pin.location.range.contain?(position)}.last
+      def closure_at position
+        # @sg-ignore Need to add nil check here
+        pins.select { |pin| pin.is_a?(Pin::Closure) and pin.location.range.contain?(position) }.last
       end
 
       # @param source_position [Position]
@@ -90,11 +93,13 @@ module Solargraph
       def find_directive_line_number comment, tag, start
         # Avoid overruning the index
         return start unless start < comment.lines.length
-        num = comment.lines[start..-1].find_index do |line|
+        # @sg-ignore Need to add nil check here
+        num = comment.lines[start..].find_index do |line|
           # Legacy method directives might be `@method` instead of `@!method`
           # @todo Legacy syntax should probably emit a warning
           line.include?("@!#{tag}") || (tag == 'method' && line.include?("@#{tag}"))
         end
+        # @sg-ignore Need to add nil check here
         num.to_i + start
       end
 
@@ -103,35 +108,37 @@ module Solargraph
       # @param directive [YARD::Tags::Directive]
       # @return [void]
       def process_directive source_position, comment_position, directive
+        # @sg-ignore Need to add nil check here
         docstring = Solargraph::Source.parse_docstring(directive.tag.text).to_docstring
         location = Location.new(@filename, Range.new(comment_position, comment_position))
         case directive.tag.tag_name
         when 'method'
           namespace = closure_at(source_position) || @pins.first
-          if namespace.location.range.start.line < comment_position.line
-            namespace = closure_at(comment_position)
-          end
+          # @sg-ignore Need to add nil check here
+          namespace = closure_at(comment_position) if namespace.location.range.start.line < comment_position.line
           begin
             src = Solargraph::Source.load_string("def #{directive.tag.name};end", @source.filename)
             region = Parser::Region.new(source: src, closure: namespace)
+            # @type [Array<Pin::Method>]
             method_gen_pins = Parser.process_node(src.node, region).first.select { |pin| pin.is_a?(Pin::Method) }
             gen_pin = method_gen_pins.last
             return if gen_pin.nil?
             # Move the location to the end of the line so it gets recognized
             # as originating from a comment
-            shifted = Solargraph::Position.new(comment_position.line, @code.lines[comment_position.line].to_s.chomp.length)
+            shifted = Solargraph::Position.new(comment_position.line,
+                                               @code.lines[comment_position.line].to_s.chomp.length)
             # @todo: Smelly instance variable access
             gen_pin.instance_variable_set(:@comments, docstring.all.to_s)
             gen_pin.instance_variable_set(:@location, Solargraph::Location.new(@filename, Range.new(shifted, shifted)))
             gen_pin.instance_variable_set(:@explicit, false)
             @pins.push gen_pin
-          rescue Parser::SyntaxError => e
+          rescue Parser::SyntaxError
             # @todo Handle error in directive
           end
         when 'attribute'
           return if directive.tag.name.nil?
           namespace = closure_at(source_position)
-          t = (directive.tag.types.nil? || directive.tag.types.empty?) ? nil : directive.tag.types.flatten.join('')
+          t = directive.tag.types.nil? || directive.tag.types.empty? ? nil : directive.tag.types.join
           if t.nil? || t.include?('r')
             pins.push Solargraph::Pin::Method.new(
               location: location,
@@ -157,57 +164,68 @@ module Solargraph
               source: :source_map
             )
             pins.push method_pin
-            method_pin.parameters.push Pin::Parameter.new(name: 'value', decl: :arg, closure: pins.last, source: :source_map)
+            method_pin.parameters.push Pin::Parameter.new(name: 'value', decl: :arg, closure: pins.last,
+                                                          source: :source_map)
             if pins.last.return_type.defined?
-              pins.last.docstring.add_tag YARD::Tags::Tag.new(:param, '', pins.last.return_type.to_s.split(', '), 'value')
+              pins.last.docstring.add_tag YARD::Tags::Tag.new(:param, '', pins.last.return_type.to_s.split(', '),
+                                                              'value')
             end
           end
         when 'visibility'
 
-            kind = directive.tag.text&.to_sym
-            return unless [:private, :protected, :public].include?(kind)
+          kind = directive.tag.text&.to_sym
+          # @sg-ignore Need to look at Tuple#include? handling
+          return unless %i[private protected public].include?(kind)
 
-            name = directive.tag.name
-            closure = closure_at(source_position) || @pins.first
-            if closure.location.range.start.line < comment_position.line
-              closure = closure_at(comment_position)
+          name = directive.tag.name
+          closure = closure_at(source_position) || @pins.first
+          # @sg-ignore Need to add nil check here
+          closure = closure_at(comment_position) if closure.location.range.start.line < comment_position.line
+          if closure.is_a?(Pin::Method) && no_empty_lines?(comment_position.line, source_position.line)
+            # @todo Smelly instance variable access
+            closure.instance_variable_set(:@visibility, kind)
+          else
+            matches = pins.select do |pin|
+              pin.is_a?(Pin::Method) && pin.name == name && pin.namespace == namespace && pin.context.scope == namespace.is_a?(Pin::Singleton) ? :class : :instance
             end
-            if closure.is_a?(Pin::Method) && no_empty_lines?(comment_position.line, source_position.line)
+            matches.each do |pin|
               # @todo Smelly instance variable access
-              closure.instance_variable_set(:@visibility, kind)
-            else
-              matches = pins.select{ |pin| pin.is_a?(Pin::Method) && pin.name == name && pin.namespace == namespace && pin.context.scope == namespace.is_a?(Pin::Singleton) ? :class : :instance }
-              matches.each do |pin|
-                # @todo Smelly instance variable access
-                pin.instance_variable_set(:@visibility, kind)
-              end
+              pin.instance_variable_set(:@visibility, kind)
             end
+          end
 
         when 'parse'
           begin
             ns = closure_at(source_position)
+            # @sg-ignore Need to add nil check here
             src = Solargraph::Source.load_string(directive.tag.text, @source.filename)
             region = Parser::Region.new(source: src, closure: ns)
             # @todo These pins may need to be marked not explicit
             index = @pins.length
             loff = if @code.lines[comment_position.line].strip.end_with?('@!parse')
-              comment_position.line + 1
-            else
-              comment_position.line
-            end
-            Parser.process_node(src.node, region, @pins)
-            @pins[index..-1].each do |p|
+                     comment_position.line + 1
+                   else
+                     comment_position.line
+                   end
+            locals = []
+            ivars = []
+            Parser.process_node(src.node, region, @pins, locals, ivars)
+            @pins.concat ivars
+            # @sg-ignore Need to add nil check here
+            @pins[index..].each do |p|
               # @todo Smelly instance variable access
               p.location.range.start.instance_variable_set(:@line, p.location.range.start.line + loff)
               p.location.range.ending.instance_variable_set(:@line, p.location.range.ending.line + loff)
             end
-          rescue Parser::SyntaxError => e
+          rescue Parser::SyntaxError
             # @todo Handle parser errors in !parse directives
           end
         when 'domain'
           namespace = closure_at(source_position) || Pin::ROOT_PIN
+          # @sg-ignore flow sensitive typing should be able to handle redefinition
           namespace.domains.concat directive.tag.types unless directive.tag.types.nil?
         when 'override'
+          # @sg-ignore Need to add nil check here
           pins.push Pin::Reference::Override.new(location, directive.tag.name, docstring.tags,
                                                  source: :source_map)
         when 'macro'
@@ -217,7 +235,9 @@ module Solargraph
 
       # @param line1 [Integer]
       # @param line2 [Integer]
-      def no_empty_lines?(line1, line2)
+      # @sg-ignore Need to add nil check here
+      def no_empty_lines? line1, line2
+        # @sg-ignore Need to add nil check here
         @code.lines[line1..line2].none? { |line| line.strip.empty? }
       end
 
@@ -227,7 +247,7 @@ module Solargraph
         ctxt = ''
         num = nil
         started = false
-        comment.lines.each { |l|
+        comment.lines.each do |l|
           # Trim the comment and minimum leading whitespace
           p = l.encode('UTF-8', invalid: :replace, replace: '?').gsub(/^#+/, '')
           if num.nil? && !p.strip.empty?
@@ -235,10 +255,11 @@ module Solargraph
             started = true
           elsif started && !p.strip.empty?
             cur = p.index(/[^ ]/)
+            # @sg-ignore Need to add nil check here
             num = cur if cur < num
           end
-          ctxt += "#{p[num..-1]}" if started
-        }
+          ctxt += p[num..].to_s if started
+        end
         ctxt
       end
 
@@ -247,7 +268,15 @@ module Solargraph
         return unless @code.encode('UTF-8', invalid: :replace, replace: '?') =~ DIRECTIVE_REGEXP
         code_lines = @code.lines
         @source.associated_comments.each do |line, comments|
-          src_pos = line ? Position.new(line, code_lines[line].to_s.chomp.index(/[^\s]/) || 0) : Position.new(code_lines.length, 0)
+          src_pos = if line
+                      Position.new(line,
+                                   code_lines[line].to_s.chomp.index(/[^\s]/) || 0)
+                    else
+                      Position.new(
+                        code_lines.length, 0
+                      )
+                    end
+          # @sg-ignore Need to add nil check here
           com_pos = Position.new(line + 1 - comments.lines.length, 0)
           process_comment(src_pos, com_pos, comments)
         end

data/lib/solargraph/source_map.rb

@@ -34,6 +34,8 @@ module Solargraph
     # @param source [Source]
     def initialize source
       @source = source
+      # @type [Array<Pin::Base>, nil]
+      @convention_pins = nil
 
       conventions_environ.merge Convention.for_local(self) unless filename.nil?
       # FIXME: unmemoizing the document_symbols in case it was called and memoized from any of conventions above
@@ -60,10 +62,12 @@ module Solargraph
     #
     # @return [Integer]
     def api_hash
-      @api_hash ||= (pins_by_class(Pin::Constant) + pins_by_class(Pin::Namespace).select { |pin| pin.namespace.to_s > '' } + pins_by_class(Pin::Reference) + pins_by_class(Pin::Method).map(&:node) + locals).hash
+      @api_hash ||= (pins_by_class(Pin::Constant) + pins_by_class(Pin::Namespace).select do |pin|
+        pin.namespace.to_s > ''
+      end + pins_by_class(Pin::Reference) + pins_by_class(Pin::Method).map(&:node) + locals).hash
     end
 
-    # @return [String]
+    # @return [String, nil]
     def filename
       source.filename
     end
@@ -84,6 +88,7 @@ module Solargraph
     end
 
     # all pins except Solargraph::Pin::Reference::Reference
+    #
     # @return [Array<Pin::Base>]
     def document_symbols
       @document_symbols ||= (pins + convention_pins).select do |pin|
@@ -97,7 +102,7 @@ module Solargraph
       Pin::Search.new(document_symbols, query).results
     end
 
-    # @param position [Position]
+    # @param position [Position, Array(Integer, Integer)]
     # @return [Source::Cursor]
     def cursor_at position
       Source::Cursor.new(source, position)
@@ -125,7 +130,7 @@ module Solargraph
 
     # @param line [Integer]
     # @param character [Integer]
-    # @return [Pin::Namespace,Pin::Method,Pin::Block]
+    # @return [Pin::Closure]
     def locate_closure_pin line, character
       _locate_pin line, character, Pin::Closure
     end
@@ -141,9 +146,9 @@ module Solargraph
 
     # @param location [Location]
     # @return [Array<Pin::LocalVariable>]
-    def locals_at(location)
+    def locals_at location
       return [] if location.filename != filename
-      closure = locate_named_path_pin(location.range.start.line, location.range.start.character)
+      closure = locate_closure_pin(location.range.start.line, location.range.start.character)
       locals.select { |pin| pin.visible_at?(closure, location) }
     end
 
@@ -178,6 +183,7 @@ module Solargraph
 
     # @return [Hash{Class<Pin::Base> => Array<Pin::Base>}]
     def pin_class_hash
+      # @todo Need to support generic resolution in classify and transform_values
       @pin_class_hash ||= pins.to_set.classify(&:class).transform_values(&:to_a)
     end
 
@@ -191,10 +197,12 @@ module Solargraph
       @convention_pins || []
     end
 
+    # @generic T
     # @param line [Integer]
     # @param character [Integer]
-    # @param klasses [Array<Class>]
-    # @return [Pin::Base, nil]
+    # @param klasses [Array<Class<generic<T>>>]
+    # @return [generic<T>, nil]
+    # @sg-ignore Need better generic inference here
     def _locate_pin line, character, *klasses
       position = Position.new(line, character)
       found = nil
@@ -202,7 +210,11 @@ module Solargraph
         # @todo Attribute pins should not be treated like closures, but
         #   there's probably a better way to handle it
         next if pin.is_a?(Pin::Method) && pin.attribute?
-        found = pin if (klasses.empty? || klasses.any? { |kls| pin.is_a?(kls) } ) && pin.location.range.contain?(position)
+        found = pin if (klasses.empty? || klasses.any? do |kls|
+          pin.is_a?(kls)
+          # @sg-ignore Need to add nil check here
+        end) && pin.location.range.contain?(position)
+        # @sg-ignore Need to add nil check here
         break if pin.location.range.start.line > line
       end
       # Assuming the root pin is always valid

data/lib/solargraph/type_checker/problem.rb

@@ -5,19 +5,21 @@ module Solargraph
     # A problem reported by TypeChecker.
     #
     class Problem
+      # @todo Missed nil violation
       # @return [Solargraph::Location]
       attr_reader :location
 
       # @return [String]
       attr_reader :message
 
+      # @todo Missed nil violation
       # @return [Pin::Base]
       attr_reader :pin
 
       # @return [String, nil]
       attr_reader :suggestion
 
-      # @param location [Solargraph::Location]
+      # @param location [Solargraph::Location, nil]
       # @param message [String]
       # @param pin [Solargraph::Pin::Base, nil]
       # @param suggestion [String, nil]

data/lib/solargraph/type_checker/rules.rb

@@ -23,11 +23,11 @@ module Solargraph
       # @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
+                  LEVELS[level]
+                else
+                  Solargraph.logger.warn "Unrecognized TypeChecker level #{level}, assuming normal"
+                  0
+                end
         @level = LEVELS[LEVELS.values.index(@rank)]
         @overrides = overrides
       end
@@ -60,8 +60,81 @@ module Solargraph
         report?(:validate_tags, :typed)
       end
 
-      def require_all_return_types_match_inferred?
-        report?(:require_all_return_types_match_inferred, :alpha)
+      def require_inferred_type_params?
+        report?(:require_inferred_type_params, :alpha)
+      end
+
+      #
+      # False negatives:
+      #
+      # @todo 4: Missed nil violation
+      #
+      # pending code fixes (277):
+      #
+      # @todo 281: Need to add nil check here
+      # @todo 22: Translate to something flow sensitive typing understands
+      # @todo 3: Need a downcast here
+      #
+      # flow sensitive typing could handle (96):
+      #
+      # @todo 36: flow sensitive typing needs to handle attrs
+      # @todo 29: flow sensitive typing should be able to handle redefinition
+      # @todo 19: flow sensitive typing needs to narrow down type with an if is_a? check
+      # @todo 13: Need to validate config
+      # @todo 8: flow sensitive typing should support .class == .class
+      # @todo 6: need boolish support for ? methods
+      # @todo 6: flow sensitive typing needs better handling of ||= on lvars
+      # @todo 5: literal arrays in this module turn into ::Solargraph::Source::Chain::Array
+      # @todo 5: flow sensitive typing needs to handle 'raise if'
+      # @todo 4: flow sensitive typing needs to eliminate literal from union with [:bar].include?(foo)
+      # @todo 4: nil? support in flow sensitive typing
+      # @todo 3: flow sensitive typing ought to be able to handle 'when ClassName'
+      # @todo 2: downcast output of Enumerable#select
+      # @todo 2: flow sensitive typing should handle return nil if location&.name.nil?
+      # @todo 2: flow sensitive typing should handle is_a? and next
+      # @todo 2: Need to look at Tuple#include? handling
+      # @todo 2: Should better support meaning of '&' in RBS
+      # @todo 2: (*) flow sensitive typing needs to handle "if foo = bar"
+      # @todo 2: flow sensitive typing needs to handle "if foo = bar"
+      # @todo 2: Need to handle duck-typed method calls on union types
+      # @todo 2: Need better handling of #compact
+      # @todo 2: flow sensitive typing should allow shadowing of Kernel#caller
+      # @todo 1: flow sensitive typing not smart enough to handle this case
+      # @todo 1: flow sensitive typing needs to handle if foo = bar
+      # @todo 1: flow sensitive typing needs to handle "if foo.nil?"
+      # @todo 1: flow sensitive typing should support case/when
+      # @todo 1: flow sensitive typing should support ivars
+      # @todo 1: Need to support this in flow sensitive typing
+      # @todo 1: flow sensitive typing needs to handle self.class == other.class
+      # @todo 1: flow sensitive typing needs to remove literal with
+      # @todo 1: flow sensitive typing needs to understand reassignment
+      # @todo 1: flow sensitive typing should be able to identify more blocks that always return
+      # @todo 1: should warn on nil dereference below
+      # @todo 1: flow sensitive typing needs to create separate ranges for postfix if
+      # @todo 1: flow sensitive typing needs to handle constants
+      # @todo 1: flow sensitive typing needs to eliminate literal from union with return if foo == :bar
+      def require_all_unique_types_match_expected?
+        report?(:require_all_unique_types_match_expected, :strong)
+      end
+
+      def require_all_unique_types_support_call?
+        report?(:require_all_unique_types_support_call, :strong)
+      end
+
+      def require_no_undefined_args?
+        report?(:require_no_undefined_args, :alpha)
+      end
+
+      def require_generics_resolved?
+        report?(:require_generics_resolved, :alpha)
+      end
+
+      def require_interfaces_resolved?
+        report?(:require_interfaces_resolved, :alpha)
+      end
+
+      def require_downcasts?
+        report?(:require_downcasts, :alpha)
       end
 
       # We keep this at strong because if you added an @ sg-ignore to
@@ -76,7 +149,7 @@ module Solargraph
 
       # @param type [Symbol]
       # @param level [Symbol]
-      def report?(type, level)
+      def report? type, level
         rank >= LEVELS[@overrides.fetch(type, level)]
       end
     end