rigortype 0.3.9 → 0.4.0

data/lib/rigor/inference/match_rebinding/frame.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../../source/node_children"
+
+module Rigor
+  module Inference
+    module MatchRebinding
+      # The frame a body runs in, stamped on its entry scope ({Scope#with_match_frame}) and shared by every scope
+      # derived from it, blocks included, since they run in the same frame. Each answer is computed on the first
+      # ask — only code run while a match global is narrowed asks — and kept for the rest of the body: whether the
+      # body makes a matching closure, whether its implicit-self calls keep the reset ({#self_call_fallback?}), the
+      # method's forwarded `&block` name, and {MatchRebinding.may_match?} per node ({#memo}). The same slot holds
+      # `$_` (issue #1359), whose frame-wide answers ({#last_line_closure?}, {#last_line_fallback?}) are kept here
+      # too, asked only while `$_` is narrowed.
+      class Frame
+        # The nodes that bind a local in a body: the writes, and a block's, lambda's, `rescue`'s or pattern's own
+        # parameters and targets.
+        LOCAL_BINDINGS = Set[
+          Prism::LocalVariableWriteNode, Prism::LocalVariableOperatorWriteNode, Prism::LocalVariableOrWriteNode,
+          Prism::LocalVariableAndWriteNode, Prism::LocalVariableTargetNode, Prism::RequiredParameterNode,
+          Prism::OptionalParameterNode, Prism::RestParameterNode, Prism::RequiredKeywordParameterNode,
+          Prism::OptionalKeywordParameterNode, Prism::KeywordRestParameterNode, Prism::BlockParameterNode,
+          Prism::BlockLocalVariableNode
+        ].freeze
+        private_constant :LOCAL_BINDINGS
+
+        # @param parameters — a method's parameters, whose default expressions run in its frame; nil for a class,
+        #   module or file body.
+        def initialize(body, parameters = nil)
+          @body = body
+          @parameters = parameters
+          @matching_closure = nil
+          @self_call_fallback = nil
+          @forwarded_block = nil
+          @scans = nil
+          @last_line_closure = nil
+          @last_line_fallback = nil
+        end
+
+        def matching_closure?(scope = nil)
+          if @matching_closure.nil?
+            @matching_closure = MatchRebinding.matching_closure?(@body, scope) ||
+                                MatchRebinding.matching_closure?(@parameters, scope)
+          end
+          @matching_closure
+        end
+
+        # True when an implicit-self call in this frame forgets the match globals as it did before issue #1364,
+        # because the body or a parameter default hands the frame's slot to code the analyzer does not trace
+        # ({MatchRebinding.self_call_fallback?}). Kept as {#memo} keeps a scan: the broad reading resolves constants
+        # and the variables a lookup argument names through `scope`.
+        def self_call_fallback?(scope = nil)
+          return fallback_in_frame?(scope) if scope.nil?
+
+          kept = @self_call_fallback
+          return kept[2] if kept && kept[0].equal?(scope.locals) && kept[1].equal?(scope.ivars)
+
+          result = fallback_in_frame?(scope)
+          @self_call_fallback = [scope.locals, scope.ivars, result]
+          result
+        end
+
+        # {#matching_closure?} for `$_` ({LastLine.closure?}).
+        def last_line_closure?(scope = nil)
+          if @last_line_closure.nil?
+            @last_line_closure = LastLine.closure?(@body, scope) || LastLine.closure?(@parameters, scope)
+          end
+          @last_line_closure
+        end
+
+        # {#self_call_fallback?} for `$_` ({LastLine.fallback?}). Its reading is by name alone, so it is kept once.
+        def last_line_fallback?(scope = nil)
+          if @last_line_fallback.nil?
+            block_name = block_parameter_name
+            @last_line_fallback = LastLine.fallback?(@body, block_name, scope) ||
+                                  LastLine.fallback?(@parameters, block_name, scope)
+          end
+          @last_line_fallback
+        end
+
+        # True when `name` is the method's own `&block` parameter and the body never binds that name — no write, no
+        # block or lambda parameter shadowing it — so every read of it in the frame is the block the caller passed,
+        # which the caller made in its own frame.
+        def forwarded_block?(name)
+          @forwarded_block = forwarded_block_name || false if @forwarded_block.nil?
+          @forwarded_block == name
+        end
+
+        # The scan of `node` under `scope`, kept while `scope`'s local and instance-variable tables are the same
+        # objects: a lookup argument's answer reads them ({MatchRebinding.may_match?}), and a rebuild that leaves
+        # them alone passes the same tables on. `kind` keeps another reading of the same node apart (issue #1365:
+        # {MatchRebinding.operands_may_rebind?}, and the code an eval runs), which the statement pass and each
+        # typing pass over the call ask again.
+        def memo(node, scope, kind = nil)
+          scans = kind.nil? ? (@scans ||= {}.compare_by_identity) : kind_scans(kind)
+          locals = scope.locals
+          ivars = scope.ivars
+          kept = scans[node]
+          return kept[2] if kept && kept[0].equal?(locals) && kept[1].equal?(ivars)
+
+          result = yield
+          scans[node] = [locals, ivars, result]
+          result
+        end
+
+        private
+
+        def kind_scans(kind)
+          tables = (@kind_scans ||= {})
+          tables[kind] ||= {}.compare_by_identity
+        end
+
+        def fallback_in_frame?(scope)
+          block_name = block_parameter_name
+          MatchRebinding.self_call_fallback?(@body, block_name, scope) ||
+            MatchRebinding.self_call_fallback?(@parameters, block_name, scope)
+        end
+
+        def forwarded_block_name
+          name = block_parameter_name
+          return nil if name.nil? || binds_local?(@body, name)
+
+          name
+        end
+
+        # The method's own `&block` parameter's name, or nil.
+        def block_parameter_name
+          parameters = @parameters
+          block = parameters.is_a?(Prism::ParametersNode) ? parameters.block : nil
+          block&.name
+        end
+
+        # `node` is a body or one of its descendants; a method with an empty body passes nil.
+        def binds_local?(node, name)
+          return false if node.nil?
+          return true if LOCAL_BINDINGS.include?(node.class) && node.name == name
+          return false if OWN_FRAME_NODES.include?(node.class)
+
+          found = false
+          node.rigor_each_child { |child| found ||= binds_local?(child, name) }
+          found
+        end
+      end
+    end
+  end
+end

data/lib/rigor/inference/match_rebinding/operands.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../../source/node_children"
+require_relative "../../type"
+
+module Rigor
+  module Inference
+    module MatchRebinding
+      # Whether an operand of a call, a `when` condition or a pattern is a Regexp — the one question that decides
+      # whether `===`, `case` and the lookup names run a match. Two readings, because the constructs differ in
+      # what they usually hold:
+      #
+      # - a `when` condition, a pattern value and a `===` receiver are patterns far more often than not, so
+      #   anything but a value known not to be a Regexp counts ({.pattern_value?}, {.pattern_matches?});
+      # - a `[]` / `split` / `index` argument is a lookup key far more often than not, so only a value known to be
+      #   a Regexp counts ({.regexp_argument?}).
+      #
+      # A constant resolves through the scope. One that does not resolve is read as a class, the usual CamelCase
+      # referent, so it does not count either way — except under the `broad` reading, where it may be a Regexp
+      # defined in another file (#1373) and counts ({MatchRebinding.broad_may_match?}).
+      #
+      # Outside a block, a statement's operands are read on two further terms (issue #1365), because the flow scope
+      # types them but its types can be stale (#1380): a call the name table forgot on before keeps the narrowing only
+      # on a non-Regexp literal ({.keep_literal?}), and a call in a position that never forgot forgets only on an
+      # operand known to be a Regexp ({.known_regexp_operand?}).
+      module Operands
+        REGEX_LITERALS = Set[Prism::RegularExpressionNode, Prism::InterpolatedRegularExpressionNode].freeze
+        # Values whose `===` cannot run a match. An interpolated String or Symbol is still a String or Symbol; the
+        # code it embeds is scanned like any other.
+        NON_REGEXP_LITERALS = Set[
+          Prism::SymbolNode, Prism::InterpolatedSymbolNode, Prism::StringNode, Prism::InterpolatedStringNode,
+          Prism::IntegerNode, Prism::FloatNode, Prism::RationalNode, Prism::ImaginaryNode,
+          Prism::NilNode, Prism::TrueNode, Prism::FalseNode
+        ].freeze
+        # The literals {.keep_literal?} accepts: each is never a Regexp, whatever a flow type says.
+        KEEP_LITERALS = Set[
+          Prism::SymbolNode, Prism::StringNode, Prism::IntegerNode, Prism::FloatNode, Prism::RationalNode,
+          Prism::ImaginaryNode, Prism::NilNode, Prism::TrueNode, Prism::FalseNode
+        ].freeze
+        CONSTANT_NODES = Set[Prism::ConstantReadNode, Prism::ConstantPathNode].freeze
+        PINNED_NODES = Set[Prism::PinnedVariableNode, Prism::PinnedExpressionNode].freeze
+        REGEXP_CONSTRUCTORS = Set[:new, :union, :compile].freeze
+        # The classes a Regexp is an instance of, so a value of one of these types may be a Regexp.
+        REGEXP_ANCESTORS = Set["Regexp", "Object", "BasicObject", "Kernel"].freeze
+        # How a class relates to `Regexp` when every instance of it is one.
+        REGEXP_CLASS_ORDERINGS = Set[:subclass, :equal].freeze
+        private_constant :REGEX_LITERALS, :NON_REGEXP_LITERALS, :KEEP_LITERALS, :CONSTANT_NODES, :PINNED_NODES,
+                         :REGEXP_CONSTRUCTORS, :REGEXP_ANCESTORS, :REGEXP_CLASS_ORDERINGS
+
+        module_function
+
+        # True when a statement's operand is never a Regexp by its syntax alone: a Symbol, a String without
+        # interpolation, a number, `nil`, `true`, `false`, or a range of those. A call the name table forgot on before
+        # issue #1365 (`row[:name]`, `csv.split(",")`, `list.index(3)`) keeps the narrowing only when every argument is
+        # one, because a flow type that says "String" can be stale while the value is a Regexp (#1380).
+        def keep_literal?(node)
+          return true if KEEP_LITERALS.include?(node.class)
+          return false unless node.is_a?(Prism::RangeNode)
+
+          [node.left, node.right].all? { |bound| bound.nil? || KEEP_LITERALS.include?(bound.class) }
+        end
+
+        # True when `node` is a constant naming a class or module (`String === s`), whose `===` is `Module#===`.
+        def class_constant?(node, scope)
+          CONSTANT_NODES.include?(node.class) && node_type(node, scope).is_a?(Type::Singleton)
+        end
+
+        # True when a statement's operand is known to be a Regexp: a regex literal, a splat whose elements are known
+        # to be ones, or a value whose type in the flow scope is one ({.regexp_type?}; `Regexp.new(src)` types as
+        # one). `Dynamic[top]`, `Object` and any other type are not: a position that never forgot before issue #1365
+        # forgets only on evidence, so an argument that is a Regexp without the analyzer knowing it is a gap there,
+        # as it was before.
+        def known_regexp_operand?(node, scope)
+          return true if REGEX_LITERALS.include?(node.class)
+          return splat_known_regexp?(node.expression, scope) if node.is_a?(Prism::SplatNode)
+          return false if NON_REGEXP_LITERALS.include?(node.class)
+
+          regexp_type?(node_type(node, scope), scope)
+        end
+
+        # `*args` passes each element; an anonymous `*` forwards elements nothing is known about.
+        def splat_known_regexp?(expression, scope)
+          return false if expression.nil?
+
+          type = node_type(expression, scope)
+          case type
+          when Type::Tuple then type.elements.any? { |element| regexp_type?(element, scope) }
+          when Type::Nominal
+            type.class_name == "Array" ? type.type_args.any? { |element| regexp_type?(element, scope) } : false
+          else false
+          end
+        end
+        private_class_method :splat_known_regexp?
+
+        # True when a value of `type` may be a Regexp on the analyzer's evidence: a Regexp constant, `Regexp` or a
+        # class the environment places below it, a union or intersection with such a member, a refinement or
+        # difference over one, or a `Dynamic` whose static facet is one.
+        def regexp_type?(type, scope)
+          case type
+          when Type::Constant then type.value.is_a?(Regexp)
+          when Type::Nominal then regexp_class?(type.class_name, scope)
+          when Type::Union, Type::Intersection then type.members.any? { |member| regexp_type?(member, scope) }
+          when Type::Dynamic then regexp_type?(type.static_facet, scope)
+          when Type::Difference, Type::Refined then regexp_type?(type.base, scope)
+          else false
+          end
+        end
+
+        def regexp_class?(class_name, scope)
+          return true if class_name == "Regexp"
+
+          environment = scope&.environment
+          !environment.nil? && REGEXP_CLASS_ORDERINGS.include?(environment.class_ordering(class_name, "Regexp"))
+        end
+        private_class_method :regexp_class?
+
+        def regexp_constructor?(node)
+          node.is_a?(Prism::CallNode) && REGEXP_CONSTRUCTORS.include?(node.name) &&
+            node.receiver.is_a?(Prism::ConstantReadNode) && node.receiver.name == :Regexp
+        end
+        private_class_method :regexp_constructor?
+
+        def node_type(node, scope)
+          scope&.type_of(node)
+        rescue StandardError
+          nil
+        end
+        private_class_method :node_type
+
+        # True when a `===` receiver or a `when` condition may be a Regexp: a regex literal, a constant bound to
+        # one, a splat of a constant holding one, or any other expression (`when re`), but not a literal that is
+        # not one. `broad` counts an unresolved constant too.
+        def pattern_value?(node, scope, broad: false)
+          klass = node.class
+          return true if REGEX_LITERALS.include?(klass)
+          return false if non_regexp_literal?(node)
+          return constant_may_be_regexp?(node_type(node, scope), broad) if CONSTANT_NODES.include?(klass)
+          return splat_regexp?(node, scope, broad) if node.is_a?(Prism::SplatNode)
+
+          true
+        end
+
+        # True when an `in` / `=>` pattern holds a value that may be a Regexp: a regex literal, a pinned variable
+        # or expression, or a constant bound to one. Its structure, captures and other literals run no match, and
+        # an `if` / `unless` guard is ordinary code, scanned with the rest of the body. `broad` counts an unresolved
+        # constant too.
+        def pattern_matches?(node, scope, broad: false)
+          return false if node.nil?
+
+          klass = node.class
+          return true if REGEX_LITERALS.include?(klass) || PINNED_NODES.include?(klass)
+          return constant_may_be_regexp?(node_type(node, scope), broad) if CONSTANT_NODES.include?(klass)
+          if node.is_a?(Prism::IfNode) || node.is_a?(Prism::UnlessNode)
+            return pattern_matches?(node.statements, scope, broad: broad)
+          end
+
+          found = false
+          node.rigor_each_child { |child| found ||= pattern_matches?(child, scope, broad: broad) }
+          found
+        end
+
+        # True when an argument is known to be a Regexp: a regex literal, a constant bound to one, a local or
+        # instance variable bound to one where the block is written, or `Regexp.new` / `.union` / `.compile`. A
+        # block parameter is bound only inside the block, so `row[f]` does not count.
+        def regexp_argument?(node, scope)
+          case node
+          when Prism::RegularExpressionNode, Prism::InterpolatedRegularExpressionNode then true
+          when Prism::ConstantReadNode, Prism::ConstantPathNode then regexp_type?(node_type(node, scope), scope)
+          when Prism::LocalVariableReadNode then regexp_type?(scope&.local(node.name), scope)
+          when Prism::InstanceVariableReadNode then regexp_type?(scope&.ivar(node.name), scope)
+          when Prism::CallNode then regexp_constructor?(node)
+          else false
+          end
+        end
+
+        # `when *KEYS` runs `===` on each element of `KEYS`; a splat of anything but a constant counts.
+        def splat_regexp?(splat, scope, broad)
+          expression = splat.expression
+          return true unless CONSTANT_NODES.include?(expression.class)
+
+          type = node_type(expression, scope)
+          (broad && unresolved?(type)) || elements_regexp?(type)
+        end
+        private_class_method :splat_regexp?
+
+        def elements_regexp?(type)
+          case type
+          when Type::Tuple then type.elements.any? { |element| constant_regexp?(element) }
+          when Type::Nominal then type.type_args.any? { |argument| constant_regexp?(argument) }
+          when Type::Constant then type.value.is_a?(Array) && type.value.any?(Regexp)
+          when Type::Union then type.members.any? { |member| elements_regexp?(member) }
+          else false
+          end
+        end
+        private_class_method :elements_regexp?
+
+        def non_regexp_literal?(node)
+          return true if NON_REGEXP_LITERALS.include?(node.class)
+          return false unless node.is_a?(Prism::RangeNode)
+
+          [node.left, node.right].all? { |bound| bound.nil? || non_regexp_literal?(bound) }
+        end
+        private_class_method :non_regexp_literal?
+
+        def constant_may_be_regexp?(type, broad)
+          constant_regexp?(type) || (broad && unresolved?(type))
+        end
+        private_class_method :constant_may_be_regexp?
+
+        # A constant that does not resolve reads as `Dynamic`, or as nil without a scope.
+        def unresolved?(type)
+          case type
+          when nil, Type::Dynamic then true
+          when Type::Union then type.members.any? { |member| unresolved?(member) }
+          else false
+          end
+        end
+        private_class_method :unresolved?
+
+        # True when a constant's type may be a Regexp. A class or module, a Tuple or HashShape, any other value,
+        # and a constant that does not resolve do not.
+        def constant_regexp?(type)
+          case type
+          when Type::Constant then type.value.is_a?(Regexp)
+          when Type::Nominal then REGEXP_ANCESTORS.include?(type.class_name)
+          when Type::Union then type.members.any? { |member| constant_regexp?(member) }
+          else false
+          end
+        end
+        private_class_method :constant_regexp?
+      end
+    end
+  end
+end

data/lib/rigor/inference/match_rebinding/self_calls.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Rigor
+  module Inference
+    module MatchRebinding
+      # Method names that may run a regex match, read by name alone: a Symbol or String literal naming one counts
+      # ({SelfCalls.method_name_literal?}), since the method it is handed to may run it from C (`inject(:=~)`). A call
+      # itself is read with its arguments ({Calls}, issue #1365).
+      MATCH_CAPABLE_METHODS = %i[
+        =~ match match? gsub gsub! sub sub! scan split slice slice!
+        [] partition rpartition index rindex === grep grep_v
+      ].freeze
+
+      # The calls past that table that may rebind the frame they are made from, read by name alone (issue #1364), as
+      # the broad reading of a frame's blocks counts them ({MatchRebinding.broad_may_match?}), and as the calls an
+      # implicit-self call forgot on before issue #1365, which {Calls.base_named?} keeps forgetting on.
+      module SelfCalls
+        # Builtins that set their caller's `$~` and the table misses: `x !~ re`, `~re`, and `start_with?(re)`,
+        # `byteindex(re)`, `byterindex(re)`, `s[re] = v` — the ones a `String` or `Regexp` subclass inherits too.
+        SELF_MATCHING = Set[:!~, :~, :start_with?, :byteindex, :byterindex, :[]=].freeze
+        # Predicates that run `pattern === element` from C when given an argument, even when the class's `each` is
+        # written in Ruby.
+        PATTERN_PREDICATES = Set[:any?, :all?, :none?, :one?].freeze
+        # These run a String of code in the frame that calls them: `eval` always, the other three in their String
+        # form only, since their block form is a block ({MatchRebinding.block_may_match?}).
+        EVALS = Set[:eval].freeze
+        STRING_EVALS = Set[:instance_eval, :class_eval, :module_eval].freeze
+        # These run the method they name, which counts when it is one of {METHOD_NAMES} or not a literal.
+        SENDS = Set[:send, :__send__, :public_send].freeze
+        # Every name above and in the table, as Strings: a literal compares by its bytes, which an invalid one
+        # (`send("\xff")`) cannot turn into a Symbol.
+        METHOD_NAMES = (
+          MATCH_CAPABLE_METHODS.to_set | SELF_MATCHING | PATTERN_PREDICATES | EVALS | STRING_EVALS | SENDS
+        ).to_set(&:to_s).freeze
+        private_constant :SELF_MATCHING, :PATTERN_PREDICATES, :EVALS, :STRING_EVALS, :SENDS, :METHOD_NAMES
+
+        module_function
+
+        # True when `call_node`, on any receiver, is a call past the table that may rebind the frame it is made
+        # from: a {SELF_MATCHING} name; a {PATTERN_PREDICATES} name with an argument; an eval of a String
+        # ({EVALS}, or {STRING_EVALS} with an argument); or a {SENDS} call whose name is not a literal, or names a
+        # method that counts.
+        def named_match?(call_node)
+          name = call_node.name
+          arguments = call_node.arguments&.arguments
+          return true if SELF_MATCHING.include?(name) || EVALS.include?(name)
+          return !arguments.nil? if PATTERN_PREDICATES.include?(name) || STRING_EVALS.include?(name)
+          return sent_name_matches?(arguments&.first) if SENDS.include?(name)
+
+          false
+        end
+
+        # True when a {SENDS} call's name argument is not a Symbol or String literal, or names a method that counts.
+        def sent_name_matches?(name_node)
+          return method_name_literal?(name_node) if literal_name?(name_node)
+
+          true
+        end
+
+        # True when `node` is a Symbol or String literal naming the table's methods or the ones above:
+        # `inject(:=~)` runs `=~` from C in the frame that calls it.
+        def method_name_literal?(node)
+          literal_name?(node) && METHOD_NAMES.include?(node.unescaped)
+        end
+
+        # True for `send(:binding)`, or a {SENDS} call whose name is not a literal and so may be `:binding`.
+        def sends_binding?(call_node)
+          return false unless SENDS.include?(call_node.name)
+
+          name_node = call_node.arguments&.arguments&.first
+          !literal_name?(name_node) || name_node.unescaped == "binding"
+        end
+
+        def literal_name?(node)
+          node.is_a?(Prism::SymbolNode) || node.is_a?(Prism::StringNode)
+        end
+        private_class_method :literal_name?
+      end
+    end
+  end
+end