steep 1.0.0 → 1.1.0.pre.1

data/sig/steep/type_inference/method_params.rbs

@@ -0,0 +1,104 @@
+module Steep
+  module TypeInference
+    class MethodParams
+      class BaseParameter
+        attr_reader name: Symbol
+
+        attr_reader type: untyped
+
+        attr_reader node: Parser::AST::Node
+
+        def initialize: (name: Symbol, type: untyped, node: Parser::AST::Node) -> void
+
+        def optional?: () -> bool
+
+        def value: () -> Parser::AST::Node
+
+        def var_type: () -> AST::Types::t
+
+        def untyped?: () -> bool
+
+        def ==: (untyped other) -> untyped
+
+        alias eql? ==
+
+        def hash: () -> Integer
+      end
+
+      class PositionalParameter < BaseParameter
+      end
+
+      class KeywordParameter < BaseParameter
+      end
+
+      class BaseRestParameter
+        attr_reader name: Symbol
+
+        attr_reader type: untyped
+
+        attr_reader node: Parser::AST::Node
+
+        def initialize: (name: Symbol, type: untyped, node: Parser::AST::Node) -> void
+
+        def ==: (untyped other) -> bool
+
+        alias eql? ==
+
+        def hash: () -> Integer
+        
+        def var_type: () -> AST::Types::t
+      end
+
+      class PositionalRestParameter < BaseRestParameter
+        def var_type: () -> AST::Types::t
+      end
+
+      class KeywordRestParameter < BaseRestParameter
+        def var_type: () -> AST::Types::t
+      end
+
+      class BlockParameter
+        attr_reader name: untyped
+
+        attr_reader type: untyped
+
+        attr_reader node: untyped
+
+        def initialize: (name: untyped, type: untyped, node: untyped, optional: untyped) -> void
+
+        def optional?: () -> (true | false)
+
+        def var_type: () -> AST::Types::t
+
+        def ==: (untyped other) -> untyped
+
+        alias eql? ==
+
+        def hash: () -> untyped
+      end
+
+      attr_reader args: untyped
+
+      attr_reader method_type: untyped
+
+      attr_reader params: untyped
+
+      attr_reader errors: untyped
+
+      def initialize: (args: untyped, method_type: untyped) -> void
+
+      def []: (untyped name) -> untyped
+
+      def size: () -> Integer
+
+      def each_param: () { (BaseParameter | BaseRestParameter | BlockParameter) -> void } -> void
+                    | () -> Enumerator[BaseParameter | BaseRestParameter | BlockParameter, void]
+
+      def each: () { (Symbol, BaseRestParameter | BaseRestParameter | BlockParameter) -> void } -> void
+
+      def self.empty: (node: Parser::AST::Node) -> MethodParams
+
+      def self.build: (node: Parser::AST::Node, method_type: untyped) -> MethodParams
+    end
+  end
+end

data/sig/steep/type_inference/multiple_assignment.rbs

@@ -0,0 +1,76 @@
+module Steep
+  module TypeInference
+    # This class provides an abstraction for multiple assignments.
+    #
+    class MultipleAssignment
+      type node_type_pair = [Parser::AST::Node, AST::Types::t]
+
+      # Encapsulate assignments included in one `masgn` node
+      #
+      # ```ruby
+      #   a, *b, c = rhs
+      # # ^          Leading assignments
+      # #    ^^      Splat assignment
+      # #        ^   Trailing assignments
+      # ```
+      #
+      class Assignments
+        attr_reader rhs_type: AST::Types::t
+
+        attr_reader optional: bool
+
+        # Assignments before `*` assignment
+        attr_reader leading_assignments: Array[node_type_pair]
+
+        # Assignments after `*` assignment
+        #
+        # Empty if there is no splat assignment.
+        #
+        attr_reader trailing_assignments: Array[node_type_pair]
+
+        # Splat assignment if present
+        attr_reader splat_assignment: node_type_pair?
+
+        def initialize: (
+          rhs_type: AST::Types::t,
+          optional: bool,
+          leading_assignments: Array[node_type_pair],
+          trailing_assignments: Array[node_type_pair],
+          splat_assignment: node_type_pair?
+        ) -> void
+
+        def each: () { (node_type_pair) -> void } -> void
+                | () -> Enumerator[node_type_pair, void]
+      end
+
+      def initialize: () -> void
+
+      # Receives multiple assignment left hand side, right hand side type, and `optional` flag, and returns Assignments object
+      #
+      # This implements a case analysis on `rhs_type`:
+      #
+      # 1. If `rhs_type` is tuple, it returns an Assignments object with corresponding assignments
+      # 2. If `rhs_type` is an array, it returns an Assignments object with corresponding assignments
+      # 3. If `rhs_type` is `untyped`, it returns an Assignments with `untyped` type
+      # 4. It returns `nil` otherwise
+      #
+      def expand: (Parser::AST::Node mlhs, AST::Types::t rhs_type, bool optional) -> Assignments?
+
+      # Returns a type hint for multiple assignment right hand side
+      #
+      # It constructs a structure of tuple types, based on the assignment lhs, and variable types.
+      # 
+      def hint_for_mlhs: (Parser::AST::Node mlhs, TypeEnv env) -> AST::Types::t?
+
+      private
+
+      def expand_tuple: (Array[Parser::AST::Node] assignments, AST::Types::t rhs_type, Array[AST::Types::t] types, bool optional) -> Assignments
+
+      def expand_array: (Array[Parser::AST::Node] assignments, AST::Types::Name::Instance rhs_type, bool optional) -> Assignments
+
+      def expand_any: (Array[Parser::AST::Node] assignments, AST::Types::t rhs_type, AST::Types::t element_type, bool optional) -> Assignments
+
+      def expand_else: (Array[Parser::AST::Node] assignments, AST::Types::t rhs_type, bool optional) -> Assignments
+    end
+  end
+end

data/sig/steep/type_inference/type_env.rbs

@@ -0,0 +1,158 @@
+module Steep
+  module TypeInference
+    # TypeEnv is the one-stop class to manage type of variables.
+    #
+    # ### Local variables primitive operations
+    #
+    # * Assigning to a local variable
+    # * Adding local variable type enforcement
+    # * Refine local variable types
+    # * Resetting refinements
+    #
+    # ### Pure calls primitive operations
+    #
+    # * Adding pure calls
+    # * Removing pure calls
+    # * Refine pure call types
+    # * Resetting pure call refinements
+    #
+    # ### Branch operations
+    #
+    # * Start branching with refinements
+    # * Merge branches
+    #
+    #
+    class TypeEnv
+      include NodeHelper
+
+      type local_variable_entry = [AST::Types::t, AST::Types::t?]
+
+      attr_reader local_variable_types: Hash[Symbol, local_variable_entry]
+
+      attr_reader pure_method_calls: Hash[Parser::AST::Node, [MethodCall::Typed, AST::Types::t?]]
+
+      attr_reader instance_variable_types: Hash[Symbol, AST::Types::t]
+
+      attr_reader global_types: Hash[Symbol, AST::Types::t]
+
+      attr_reader constant_types: Hash[RBS::TypeName, AST::Types::t]
+
+      attr_reader constant_env: ConstantEnv
+
+      @pure_node_descendants: Hash[Parser::AST::Node, Set[Parser::AST::Node]]
+
+      def initialize: (
+          ConstantEnv,
+          ?local_variable_types: Hash[Symbol, local_variable_entry],
+          ?instance_variable_types: Hash[Symbol, AST::Types::t],
+          ?global_types: Hash[Symbol, AST::Types::t],
+          ?constant_types: Hash[RBS::TypeName, AST::Types::t],
+          ?pure_method_calls: Hash[Parser::AST::Node, [MethodCall::Typed, AST::Types::t?]]
+        ) -> void
+
+      def update: (
+          ?local_variable_types: Hash[Symbol, local_variable_entry],
+          ?instance_variable_types: Hash[Symbol, AST::Types::t],
+          ?global_types: Hash[Symbol, AST::Types::t],
+          ?constant_types: Hash[RBS::TypeName, AST::Types::t],
+          ?pure_method_calls: Hash[Parser::AST::Node, [MethodCall::Typed, AST::Types::t?]]
+        ) -> TypeEnv
+
+      def merge: (
+          ?local_variable_types: Hash[Symbol, local_variable_entry],
+          ?instance_variable_types: Hash[Symbol, AST::Types::t],
+          ?global_types: Hash[Symbol, AST::Types::t],
+          ?constant_types: Hash[RBS::TypeName, AST::Types::t],
+          ?pure_method_calls: Hash[Parser::AST::Node, [MethodCall::Typed, AST::Types::t?]]
+        ) -> TypeEnv
+
+      # Returns type of `name`.
+      #
+      def []: (Symbol name) -> AST::Types::t?
+            | (Parser::AST::Node node) -> AST::Types::t?
+
+      # Tells the environment that local variables are updated.
+      # Keeps their enforced types and invalidates related nodes.
+      #
+      def assign_local_variables: (Hash[Symbol, AST::Types::t]) -> TypeEnv
+
+      # Tells the environment that the local variable is updated with it's enforced type.
+      #
+      # Invalidates related nodes.
+      #
+      def assign_local_variable: (Symbol name, AST::Types::t type, AST::Types::t? enforced_type) -> TypeEnv
+
+      # Refines types of local variables and pure calls.
+      #
+      # * Receives types of updated local variables and pure calls.
+      # * The local variable types will be
+      #
+      def refine_types: (?local_variable_types: Hash[Symbol, AST::Types::t], ?pure_call_types: Hash[Parser::AST::Node, AST::Types::t]) -> TypeEnv
+
+      def enforced_type: (Symbol name) -> AST::Types::t?
+
+      # Returns type of constant of `const_name`, or `const_name` under `mod_name`.
+      #
+      # Returns `nil` if no such constant found.
+      #
+      def constant: (Symbol const_name, bool toplevel) -> ConstantEnv::constant_tuple?
+                  | (RBS::TypeName mod_name, Symbol const_name) -> ConstantEnv::constant_tuple?
+
+      def annotated_constant: (RBS::TypeName) -> AST::Types::t?
+
+      # _Pin_ the local variables if array is given.
+      # When `nil` is given, all local variables are _pinned_.
+      #
+      def pin_local_variables: (Array[Symbol]? names) -> Hash[Symbol, local_variable_entry]
+
+      # _Unpin_ the local variables if array is given.
+      # When `nil` is given, all local variables are _unpinned_.
+      #
+      def unpin_local_variables: (Array[Symbol]? names) -> TypeEnv
+
+      def to_s: () -> String
+
+      # Apply the substitution to the type of local variables.
+      #
+      def subst: (Interface::Substitution) -> TypeEnv
+
+      # Returns a `TypeEnv` such that:
+      #
+      # * All of the given environments are result of the type checking of branches from `self`,
+      # * All of the branches meet at one point, with the returned `TypeEnv`
+      #
+      # See the example below:
+      #
+      # ```ruby
+      # if foo()         # The original environment `self` is for after the evaluation of `foo()`
+      #   a = bar()      # One environment `env1` can be given from after the evaluation of `bar()`
+      # else
+      #   b = baz()      # Another environment `env2` is from after the evaluation of `baz`
+      # end
+      #
+      # ???              # How is the environment for here is `self.merge(env1, env2)`
+      #                  # The environment has both optional types of `a` and `b`
+      # ```
+      #
+      def join: (*TypeEnv) -> TypeEnv
+
+      def add_pure_call: (Parser::AST::Node, MethodCall::Typed, AST::Types::t?) -> TypeEnv
+
+      def replace_pure_call_type: (Parser::AST::Node, AST::Types::t) -> TypeEnv
+
+      def invalidate_pure_node: (Parser::AST::Node) -> TypeEnv
+
+      private
+
+      def pure_node_invalidation: (Enumerable[Parser::AST::Node] invalidated_nodes) -> Hash[Parser::AST::Node, [MethodCall::Typed, AST::Types::t?]]
+
+      def invalidated_pure_nodes: (Parser::AST::Node) -> Set[Parser::AST::Node]
+
+      def local_variable_name?: (Symbol) -> bool
+
+      def instance_variable_name?: (Symbol) -> bool
+
+      def global_name?: (Symbol) -> bool
+    end
+  end
+end

data/sig/steep/type_inference/type_env_builder.rbs

@@ -0,0 +1,77 @@
+module Steep
+  module TypeInference
+    class TypeEnvBuilder
+      module Command
+        interface _Base
+          def call: (TypeEnv) -> TypeEnv
+        end
+
+        class RBSBase
+          attr_reader environment: RBS::Environment
+
+          attr_reader factory: AST::Types::Factory
+
+          def initialize: (AST::Types::Factory) -> void
+        end
+
+        class AnnotationsBase
+          attr_reader annotations: AST::Annotation::Collection
+
+          def initialize: (AST::Annotation::Collection) -> void
+        end
+
+        # Insert local variable annotations.
+        #
+        # * When _merge mode_ is on, adds and overwrite local variables.
+        # * When _merge mode_ is off, it wipes all existing local variables and adds from annotations.
+        #
+        class ImportLocalVariableAnnotations < AnnotationsBase
+          include _Base
+
+          attr_reader on_duplicate: (^(Symbol, AST::Types::t, AST::Types::t) -> void)?
+
+          @merge: bool
+
+          # Set _merge mode_ `on`.
+          def merge!: (?bool) -> self
+
+          def on_duplicate!: () { (Symbol name, AST::Types::t original, AST::Types::t annotation) -> void } -> self
+        end
+
+        # Insert global variable types into type environment from `RBS::Environment`.
+        #
+        class ImportGlobalDeclarations < RBSBase
+          def merge!: (?bool) -> self
+
+          @merge: bool
+
+          include _Base
+        end
+
+        class ImportInstanceVariableAnnotations < AnnotationsBase
+          include _Base
+        end
+
+        class ImportInstanceVariableDefinition
+          attr_reader definition: RBS::Definition?
+
+          attr_reader factory: AST::Types::Factory
+
+          def initialize: (RBS::Definition?, AST::Types::Factory) -> void
+
+          include _Base
+        end
+
+        class ImportConstantAnnotations < AnnotationsBase
+          include _Base
+        end
+      end
+
+      attr_reader commands: Array[Command::_Base]
+
+      def initialize: (*Command::_Base) -> void
+
+      def build: (TypeEnv) -> TypeEnv
+    end
+  end
+end

data/sig/steep/typing.rbs

@@ -0,0 +1,68 @@
+module Steep
+  class Typing
+    class UnknownNodeError < StandardError
+      attr_reader op: untyped
+
+      attr_reader node: untyped
+
+      def initialize: (untyped op, node: untyped) -> void
+    end
+
+    attr_reader source: Source
+
+    attr_reader errors: untyped
+
+    attr_reader typing: untyped
+
+    attr_reader parent: untyped
+
+    attr_reader parent_last_update: untyped
+
+    attr_reader last_update: untyped
+
+    attr_reader should_update: untyped
+
+    attr_reader contexts: untyped
+
+    attr_reader root_context: untyped
+
+    attr_reader method_calls: untyped
+
+    attr_reader source_index: untyped
+
+    def initialize: (source: untyped, root_context: untyped, ?parent: untyped?, ?parent_last_update: untyped, ?contexts: untyped?, ?source_index: untyped?) -> void
+
+    def add_error: (untyped error) -> untyped
+
+    def add_typing: (Parser::AST::Node node, AST::Types::t `type`, TypeInference::Context _context) -> untyped
+
+    def add_call: (untyped node, untyped call) -> untyped
+
+    def add_context: (Range[Integer] range, context: TypeInference::Context) -> void
+
+    def has_type?: (untyped node) -> untyped
+
+    def type_of: (node: Parser::AST::Node) -> AST::Types::t
+
+    def call_of: (node: untyped) -> untyped
+
+    def add_context_for_node: (untyped node, context: untyped) -> untyped
+
+    def block_range: (untyped node) -> ::Range[untyped]
+
+    def add_context_for_body: (untyped node, context: untyped) -> untyped
+
+    def context_at: (line: Integer, column: Integer) -> TypeInference::Context
+
+    def dump: (untyped io) -> untyped
+
+    def self.summary: (untyped node) -> ::String
+
+    def new_child: [A] (Range[Integer] range) { (Typing) -> A } -> A
+                 | (Range[Integer]) -> Typing
+
+    def each_typing: () { () -> untyped } -> untyped
+
+    def save!: () -> void
+  end
+end

data/sig/steep.rbs

@@ -0,0 +1,31 @@
+module Steep
+  def self.logger: () -> Logger
+
+  def self.new_logger: (untyped output, untyped prev_level) -> untyped
+
+  def self.log_output: () -> untyped
+
+  def self.log_output=: (untyped output) -> untyped
+
+  def self.measure: (untyped message, ?level: ::Symbol) { () -> untyped } -> untyped
+
+  def self.log_error: (untyped exn, ?message: ::String) -> untyped
+
+  class Sampler
+    def initialize: () -> void
+
+    def sample: (untyped message) { () -> untyped } -> untyped
+
+    def count: () -> untyped
+
+    def total: () -> untyped
+
+    def slowests: (untyped num) -> untyped
+
+    def average: () -> (untyped | 0)
+
+    def percentile: (untyped p) -> untyped
+  end
+
+  def self.measure2: (untyped message, ?level: ::Symbol) { (untyped) -> untyped } -> untyped
+end

data/smoke/class/f.rb

@@ -6,4 +6,5 @@ d = (_ = nil)
 
 e = d
 
+e = _ = nil
 d = e

data/smoke/class/test_expectations.yml

@@ -56,10 +56,10 @@
   diagnostics:
   - range:
       start:
-        line: 9
+        line: 10
         character: 0
       end:
-        line: 9
+        line: 10
         character: 5
     severity: ERROR
     message: |-

data/smoke/diagnostics/test_expectations.yml

@@ -489,8 +489,10 @@
         line: 2
         character: 10
     severity: ERROR
-    message: The value given to break will be ignored
-    code: Ruby::UnexpectedJumpValue
+    message: |-
+      Cannot break with a value of type `::Integer` because type `nil` is assumed
+        ::Integer <: nil
+    code: Ruby::BreakTypeMismatch
 - file: unexpected_keyword.rb
   diagnostics:
   - range:

data/smoke/regression/lambda.rb

@@ -0,0 +1,3 @@
+module Mod
+  ->(){}
+end

data/smoke/regression/test_expectations.yml

@@ -40,6 +40,18 @@
              | (::Numeric) -> ::Time
              | (::Time) -> ::Float
     code: Ruby::UnresolvedOverloading
+- file: lambda.rb
+  diagnostics:
+  - range:
+      start:
+        line: 1
+        character: 7
+      end:
+        line: 1
+        character: 10
+    severity: ERROR
+    message: 'Cannot find the declaration of module: `Mod`'
+    code: Ruby::UnknownConstant
 - file: set_divide.rb
   diagnostics:
   - range:

data/steep.gemspec

@@ -28,7 +28,7 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = '>= 2.6.0'
 
-  spec.add_runtime_dependency "parser", ">= 3.0"
+  spec.add_runtime_dependency "parser", ">= 3.1"
   spec.add_runtime_dependency "activesupport", ">= 5.1"
   spec.add_runtime_dependency "rainbow", ">= 2.2.2", "< 4.0"
   spec.add_runtime_dependency "listen", "~> 3.0"