steep 1.0.0 → 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.0"
+  VERSION = "1.1.0.pre.1"
 end

data/lib/steep.rb

@@ -1,7 +1,7 @@
 require "steep/version"
 
 require "pathname"
-require "parser/ruby30"
+require "parser/ruby31"
 require "active_support"
 require "active_support/core_ext/object/try"
 require "active_support/core_ext/string/inflections"
@@ -21,10 +21,14 @@ require "terminal-table"
 
 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"
@@ -44,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"
@@ -65,7 +68,6 @@ require "steep/subtyping/cache"
 require "steep/subtyping/relation"
 require "steep/subtyping/constraints"
 require "steep/subtyping/variable_variance"
-require "steep/subtyping/variable_occurrence"
 
 require "steep/diagnostic/helper"
 require "steep/diagnostic/ruby"
@@ -84,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