steep 1.0.2 → 1.1.0.pre.1

data/lib/steep/type_inference/type_env_builder.rb

@@ -0,0 +1,138 @@
+module Steep
+  module TypeInference
+    class TypeEnvBuilder
+      module Command
+        class AnnotationsBase
+          attr_reader :annotations
+
+          def initialize(annotations)
+            @annotations = annotations
+          end
+        end
+
+        class RBSBase
+          attr_reader :factory
+
+          attr_reader :environment
+
+          def initialize(factory)
+            @factory = factory
+            @environment = factory.env
+          end
+        end
+
+        class ImportLocalVariableAnnotations < AnnotationsBase
+          attr_reader :on_duplicate
+
+          def initialize(annotations)
+            super
+            @merge = false
+            @on_duplicate = nil
+          end
+
+          def merge!(merge = true)
+            @merge = merge
+            self
+          end
+
+          def on_duplicate!(&block)
+            @on_duplicate = block
+            self
+          end
+
+          def call(env)
+            local_variable_types = annotations.var_type_annotations.each.with_object({}) do |pair, hash|
+              name, annotation = pair
+              annotation_type = annotations.absolute_type(annotation.type) || annotation.type
+
+              if current_type = env[name]
+                on_duplicate&.call(name, current_type, annotation_type)
+                hash[name] = [annotation_type, annotation_type]
+              else
+                hash[name] = [annotation_type, annotation_type]
+              end
+            end
+
+            if @merge
+              env.merge(local_variable_types: local_variable_types)
+            else
+              env.update(local_variable_types: local_variable_types)
+            end
+          end
+        end
+
+        class ImportInstanceVariableAnnotations < AnnotationsBase
+          def call(env)
+            ivar_types = annotations.ivar_type_annotations.transform_values do |annotation|
+              annotations.absolute_type(annotation.type) || annotation.type
+            end
+
+            if @merge
+              env.merge(instance_variable_types: ivar_types)
+            else
+              env.update(instance_variable_types: ivar_types)
+            end
+          end
+
+          def merge!(merge = true)
+            @merge = merge
+            self
+          end
+        end
+
+        class ImportGlobalDeclarations < RBSBase
+          def call(env)
+            global_types = environment.global_decls.transform_values do |decl|
+              factory.type(decl.decl.type)
+            end
+
+            env.update(global_types: global_types)
+          end
+        end
+
+        class ImportInstanceVariableDefinition
+          attr_reader :definition
+
+          attr_reader :factory
+
+          def initialize(definition, factory)
+            @definition = definition
+            @factory = factory
+          end
+
+          def call(env)
+            return env unless definition
+
+            instance_variable_types = definition.instance_variables.transform_values do |ivar|
+              factory.type(ivar.type)
+            end
+
+            env.update(instance_variable_types: instance_variable_types)
+          end
+        end
+
+        class ImportConstantAnnotations < AnnotationsBase
+          def call(env)
+            constant_types = annotations.const_type_annotations.transform_values do |const|
+              annotations.absolute_type(const.type) || const.type
+            end
+
+            env.update(constant_types: constant_types)
+          end
+        end
+      end
+
+      attr_reader :commands
+
+      def initialize(*commands)
+        @commands = commands
+      end
+
+      def build(type_env)
+        commands.inject(type_env) do |env, command|
+          command.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/steep/typing.rb

@@ -67,6 +67,8 @@ module Steep
     end
 
     def type_of(node:)
+      raise "`nil` given to `Typing#type_of(node:)`" unless node
+
       type = typing[node]
 
       if type

data/lib/steep/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "1.0.2"
+  VERSION = "1.1.0.pre.1"
 end

data/lib/steep.rb

@@ -24,9 +24,11 @@ require "rbs"
 require "steep/path_helper"
 
 require "steep/shims/filter_map"
+require "steep/shims/symbol_start_with"
 
 require "steep/equatable"
 require "steep/method_name"
+require "steep/node_helper"
 require "steep/ast/types/helper"
 require "steep/ast/types/any"
 require "steep/ast/types/instance"
@@ -46,7 +48,6 @@ require "steep/ast/types/tuple"
 require "steep/ast/types/proc"
 require "steep/ast/types/record"
 require "steep/ast/types/logic"
-require "steep/ast/type_params"
 require "steep/ast/annotation"
 require "steep/ast/annotation/collection"
 require "steep/ast/builtin"
@@ -85,9 +86,9 @@ require "steep/type_inference/block_params"
 require "steep/type_inference/method_params"
 require "steep/type_inference/constant_env"
 require "steep/type_inference/type_env"
-require "steep/type_inference/local_variable_type_env"
-require "steep/type_inference/logic"
+require "steep/type_inference/type_env_builder"
 require "steep/type_inference/logic_type_interpreter"
+require "steep/type_inference/multiple_assignment"
 require "steep/type_inference/method_call"
 require "steep/ast/types"
 

data/rbs_collection.steep.lock.yaml

@@ -0,0 +1,112 @@
+---
+sources:
+- name: ruby/gem_rbs_collection
+  remote: https://github.com/ruby/gem_rbs_collection.git
+  revision: main
+  repo_dir: gems
+path: ".gem_rbs_collection"
+gems:
+- name: set
+  version: '0'
+  source:
+    type: stdlib
+- name: rbs
+  version: 2.6.0
+  source:
+    type: rubygems
+- name: activesupport
+  version: '6.0'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: cd6db41310b911e1df3476246257510673f01b8a
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: ast
+  version: '2.4'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: cd6db41310b911e1df3476246257510673f01b8a
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: i18n
+  version: '1.10'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: cd6db41310b911e1df3476246257510673f01b8a
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: listen
+  version: '3.2'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: cd6db41310b911e1df3476246257510673f01b8a
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: minitest
+  version: '0'
+  source:
+    type: stdlib
+- name: parallel
+  version: '1.20'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: cd6db41310b911e1df3476246257510673f01b8a
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: rainbow
+  version: '3.0'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: cd6db41310b911e1df3476246257510673f01b8a
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: logger
+  version: '0'
+  source:
+    type: stdlib
+- name: pathname
+  version: '0'
+  source:
+    type: stdlib
+- name: json
+  version: '0'
+  source:
+    type: stdlib
+- name: optparse
+  version: '0'
+  source:
+    type: stdlib
+- name: rubygems
+  version: '0'
+  source:
+    type: stdlib
+- name: tsort
+  version: '0'
+  source:
+    type: stdlib
+- name: monitor
+  version: '0'
+  source:
+    type: stdlib
+- name: date
+  version: '0'
+  source:
+    type: stdlib
+- name: singleton
+  version: '0'
+  source:
+    type: stdlib
+- name: mutex_m
+  version: '0'
+  source:
+    type: stdlib
+- name: time
+  version: '0'
+  source:
+    type: stdlib

data/rbs_collection.steep.yaml

@@ -0,0 +1,19 @@
+# Download sources
+sources:
+  - name: ruby/gem_rbs_collection
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    revision: main
+    repo_dir: gems
+
+# A directory to install the downloaded RBSs
+path: .gem_rbs_collection
+
+gems:
+  # Skip loading rbs gem's RBS.
+  # It's unnecessary if you don't use rbs as a library.
+  - name: steep
+    ignore: true
+  - name: set
+  - name: rbs
+  - name: with_steep_types
+    ignore: true

data/sample/sig/conference.rbs

@@ -4,3 +4,11 @@ class Conference
 
   def initialize: (title: String, year: Integer) -> void
 end
+
+class NilClass
+  def must: () -> bot
+end
+
+class Object
+  def must: () -> self
+end

data/sig/shims/parser/source/map.rbs

@@ -0,0 +1,146 @@
+module Parser
+  module Source
+    #
+    # {Map} relates AST nodes to the source code they were parsed from.
+    # More specifically, a {Map} or its subclass contains a set of ranges:
+    #
+    #  * `expression`: smallest range which includes all source corresponding
+    #    to the node and all `expression` ranges of its children.
+    #  * other ranges (`begin`, `end`, `operator`, ...): node-specific ranges
+    #    pointing to various interesting tokens corresponding to the node.
+    #
+    # Note that the {Map::Heredoc} map is the only one whose `expression` does
+    # not include other ranges. It only covers the heredoc marker (`<<HERE`),
+    # not the here document itself.
+    #
+    # All ranges except `expression` are defined by {Map} subclasses.
+    #
+    # Ranges (except `expression`) can be `nil` if the corresponding token is
+    # not present in source. For example, a hash may not have opening/closing
+    # braces, and so would its source map.
+    #
+    #     p Parser::CurrentRuby.parse('[1 => 2]').children[0].loc
+    #     # => <Parser::Source::Map::Collection:0x007f5492b547d8
+    #     #  @end=nil, @begin=nil,
+    #     #  @expression=#<Source::Range (string) 1...7>>
+    #
+    # The {file:doc/AST_FORMAT.md} document describes how ranges associated to source
+    # code tokens. For example, the entry
+    #
+    #     (array (int 1) (int 2))
+    #
+    #     "[1, 2]"
+    #      ^ begin
+    #           ^ end
+    #      ~~~~~~ expression
+    #
+    # means that if `node` is an {Parser::AST::Node} `(array (int 1) (int 2))`,
+    # then `node.loc` responds to `begin`, `end` and `expression`, and
+    # `node.loc.begin` returns a range pointing at the opening bracket, and so on.
+    #
+    # If you want to write code polymorphic by the source map (i.e. accepting
+    # several subclasses of {Map}), use `respond_to?` instead of `is_a?` to
+    # check whether the map features the range you need. Concrete {Map}
+    # subclasses may not be preserved between versions, but their interfaces
+    # will be kept compatible.
+    #
+    # You can visualize the source maps with `ruby-parse -E` command-line tool.
+    #
+    # @example
+    #  require 'parser/current'
+    #
+    #  p Parser::CurrentRuby.parse('[1, 2]').loc
+    #  # => #<Parser::Source::Map::Collection:0x007f14b80eccd8
+    #  #  @end=#<Source::Range (string) 5...6>,
+    #  #  @begin=#<Source::Range (string) 0...1>,
+    #  #  @expression=#<Source::Range (string) 0...6>>
+    #
+    # @!attribute [r] node
+    #  The node that is described by this map. Nodes and maps have 1:1 correspondence.
+    #  @return [Parser::AST::Node]
+    #
+    # @!attribute [r] expression
+    #  @return [Range]
+    #
+    # @api public
+    #
+    class Map
+      attr_reader node: AST::Node
+
+      attr_reader expression: Range
+
+      #
+      # @param [Range] expression
+      def initialize: (untyped expression) -> void
+
+      #
+      # @api private
+      def initialize_copy: (untyped other) -> untyped
+
+      #
+      # @api private
+      def node=: (untyped node) -> untyped
+
+      #
+      # A shortcut for `self.expression.line`.
+      # @return [Integer]
+      #
+      def line: () -> Integer
+
+      alias first_line line
+
+      #
+      # A shortcut for `self.expression.column`.
+      # @return [Integer]
+      #
+      def column: () -> Integer
+
+      #
+      # A shortcut for `self.expression.last_line`.
+      # @return [Integer]
+      #
+      def last_line: () -> Integer
+
+      #
+      # A shortcut for `self.expression.last_column`.
+      # @return [Integer]
+      #
+      def last_column: () -> Integer
+
+      #
+      # @api private
+      #
+      def with_expression: (untyped expression_l) -> untyped
+
+      #
+      # Compares source maps.
+      # @return [Boolean]
+      #
+      def ==: (untyped other) -> bool
+
+      #
+      # Converts this source map to a hash with keys corresponding to
+      # ranges. For example, if called on an instance of {Collection},
+      # which adds the `begin` and `end` ranges, the resulting hash
+      # will contain keys `:expression`, `:begin` and `:end`.
+      #
+      # @example
+      #  require 'parser/current'
+      #
+      #  p Parser::CurrentRuby.parse('[1, 2]').loc.to_hash
+      #  # => {
+      #  #   :begin => #<Source::Range (string) 0...1>,
+      #  #   :end => #<Source::Range (string) 5...6>,
+      #  #   :expression => #<Source::Range (string) 0...6>
+      #  # }
+      #
+      # @return [Hash<Symbol, Parser::Source::Range>]
+      #
+      def to_hash: () -> Hash[Symbol, Range]
+
+      def with: () ?{ () -> untyped } -> untyped
+
+      def update_expression: (untyped expression_l) -> untyped
+    end
+  end
+end

data/sig/shims/parser/source/range.rbs

@@ -0,0 +1,237 @@
+module Parser
+  module Source
+    #
+    # A range of characters in a particular source buffer.
+    #
+    # The range is always exclusive, i.e. a range with `begin_pos` of 3 and
+    # `end_pos` of 5 will contain the following characters:
+    #
+    #     example
+    #        ^^
+    #
+    # @!attribute [r] source_buffer
+    #  @return [Parser::Source::Buffer]
+    #
+    # @!attribute [r] begin_pos
+    #  @return [Integer] index of the first character in the range
+    #
+    # @!attribute [r] end_pos
+    #  @return [Integer] index of the character after the last character in the range
+    #
+    # @api public
+    #
+    class Range
+      include Comparable
+
+      attr_reader source_buffer: untyped
+
+      attr_reader begin_pos: Integer
+
+      attr_reader end_pos: Integer
+
+      #
+      # @param [Buffer]  source_buffer
+      # @param [Integer] begin_pos
+      # @param [Integer] end_pos
+      #
+      def initialize: (untyped source_buffer, untyped begin_pos, untyped end_pos) -> void
+
+      #
+      # @return [Range] a zero-length range located just before the beginning
+      #   of this range.
+      #
+      def begin: () -> Range
+
+      #
+      # @return [Range] a zero-length range located just after the end
+      #   of this range.
+      #
+      def end: () -> Range
+
+      #
+      # @return [Integer] amount of characters included in this range.
+      #
+      def size: () -> Integer
+
+      alias length size
+
+      #
+      # Line number of the beginning of this range. By default, the first line
+      # of a buffer is 1; as such, line numbers are most commonly one-based.
+      #
+      # @see Buffer
+      # @return [Integer] line number of the beginning of this range.
+      #
+      def line: () -> Integer
+
+      alias first_line line
+
+      #
+      # @return [Integer] zero-based column number of the beginning of this range.
+      #
+      def column: () -> Integer
+
+      #
+      # @return [Integer] line number of the end of this range.
+      #
+      def last_line: () -> Integer
+
+      #
+      # @return [Integer] zero-based column number of the end of this range.
+      #
+      def last_column: () -> Integer
+
+      #
+      # @return [::Range] a range of columns spanned by this range.
+      # @raise RangeError
+      #
+      def column_range: () -> ::Range[Integer]
+
+      #
+      # @return [String] a line of source code containing the beginning of this range.
+      #
+      def source_line: () -> String
+
+      #
+      # @return [String] all source code covered by this range.
+      #
+      def source: () -> String
+
+      #
+      # `is?` provides a concise way to compare the source corresponding to this range.
+      # For example, `r.source == '(' || r.source == 'begin'` is equivalent to
+      # `r.is?('(', 'begin')`.
+      #
+      def is?: (*untyped what) -> untyped
+
+      #
+      # @return [Array<Integer>] a set of character indexes contained in this range.
+      #
+      def to_a: () -> Array[Integer]
+
+      #
+      # @return [Range] a Ruby range with the same `begin_pos` and `end_pos`
+      #
+      def to_range: () -> ::Range[Integer]
+
+      #
+      # Composes a GNU/Clang-style string representation of the beginning of this
+      # range.
+      #
+      # For example, for the following range in file `foo.rb`,
+      #
+      #     def foo
+      #         ^^^
+      #
+      # `to_s` will return `foo.rb:1:5`.
+      # Note that the column index is one-based.
+      #
+      # @return [String]
+      #
+      def to_s: () -> String
+
+      #
+      # @param [Hash] Endpoint(s) to change, any combination of :begin_pos or :end_pos
+      # @return [Range] the same range as this range but with the given end point(s) changed
+      # to the given value(s).
+      #
+      def with: (?begin_pos: untyped, ?end_pos: untyped) -> untyped
+
+      #
+      # @param [Hash] Endpoint(s) to change, any combination of :begin_pos or :end_pos
+      # @return [Range] the same range as this range but with the given end point(s) adjusted
+      # by the given amount(s)
+      #
+      def adjust: (?begin_pos: ::Integer, ?end_pos: ::Integer) -> untyped
+
+      #
+      # @param [Integer] new_size
+      # @return [Range] a range beginning at the same point as this range and length `new_size`.
+      #
+      def resize: (untyped new_size) -> untyped
+
+      #
+      # @param [Range] other
+      # @return [Range] smallest possible range spanning both this range and `other`.
+      #
+      def join: (untyped other) -> untyped
+
+      #
+      # @param [Range] other
+      # @return [Range] overlapping region of this range and `other`, or `nil`
+      #   if they do not overlap
+      #
+      def intersect: (untyped other) -> (untyped | nil)
+
+      #
+      # Return `true` iff this range and `other` are disjoint.
+      #
+      # Two ranges must be one and only one of ==, disjoint?, contains?, contained? or crossing?
+      #
+      # @param [Range] other
+      # @return [Boolean]
+      #
+      def disjoint?: (untyped other) -> untyped
+
+      #
+      # Return `true` iff this range is not disjoint from `other`.
+      #
+      # @param [Range] other
+      # @return [Boolean] `true` if this range and `other` overlap
+      #
+      def overlaps?: (untyped other) -> untyped
+
+      #
+      # Returns true iff this range contains (strictly) `other`.
+      #
+      # Two ranges must be one and only one of ==, disjoint?, contains?, contained? or crossing?
+      #
+      # @param [Range] other
+      # @return [Boolean]
+      #
+      def contains?: (untyped other) -> untyped
+
+      #
+      # Return `other.contains?(self)`
+      #
+      # Two ranges must be one and only one of ==, disjoint?, contains?, contained? or crossing?
+      #
+      # @param [Range] other
+      # @return [Boolean]
+      #
+      def contained?: (untyped other) -> untyped
+
+      #
+      # Returns true iff both ranges intersect and also have different elements from one another.
+      #
+      # Two ranges must be one and only one of ==, disjoint?, contains?, contained? or crossing?
+      #
+      # @param [Range] other
+      # @return [Boolean]
+      #
+      def crossing?: (untyped other) -> (false | untyped)
+
+      #
+      # Checks if a range is empty; if it contains no characters
+      # @return [Boolean]
+      def empty?: () -> untyped
+
+      #
+      # Compare ranges, first by begin_pos, then by end_pos.
+      #
+      def <=>: (untyped other) -> (nil | untyped)
+
+      alias eql? ==
+
+      #
+      # Support for Ranges be used in as Hash indices and in Sets.
+      #
+      def hash: () -> untyped
+
+      #
+      # @return [String] a human-readable representation of this range.
+      #
+      def inspect: () -> ::String
+    end
+  end
+end