steep 0.25.0 → 0.31.0

data/lib/steep/type_inference/block_params.rb

@@ -56,6 +56,11 @@ module Steep
 
         node.children.each do |arg|
           var = arg.children.first
+
+          if var.is_a?(::AST::Node)
+            return
+          end
+
           type = annotations.var_type(lvar: var.name)
 
           case arg.type

data/lib/steep/type_inference/constant_env.rb

@@ -6,7 +6,7 @@ module Steep
       attr_reader :factory
       attr_reader :table
 
-      # ConstantEnv receives an Names::Module as a context, not a Namespace, because this is a simulation of Ruby.
+      # ConstantEnv receives an TypeName as a context, not a Namespace, because this is a simulation of Ruby.
       # Any namespace is a module or class.
       def initialize(factory:, context:)
         @cache = {}
@@ -17,10 +17,7 @@ module Steep
 
       def lookup(name)
         cache[name] ||= begin
-          constant = table.resolve_constant_reference(
-            factory.type_name_1(name),
-            context: context.map {|namespace| factory.namespace_1(namespace) }
-          )
+          constant = table.resolve_constant_reference(name, context: context)
 
           if constant
             factory.type(constant.type)

data/lib/steep/type_inference/logic_type_interpreter.rb

@@ -0,0 +1,219 @@
+module Steep
+  module TypeInference
+    class LogicTypeInterpreter
+      attr_reader :subtyping
+      attr_reader :typing
+
+      def initialize(subtyping:, typing:)
+        @subtyping = subtyping
+        @typing = typing
+      end
+
+      def factory
+        subtyping.factory
+      end
+
+      def guess_type_from_method(node)
+        if node.type == :send
+          method = node.children[1]
+          case method
+          when :is_a?, :kind_of?, :instance_of?
+            AST::Types::Logic::ReceiverIsArg.new
+          when :nil?
+            AST::Types::Logic::ReceiverIsNil.new
+          when :!
+            AST::Types::Logic::Not.new
+          when :===
+            AST::Types::Logic::ArgIsReceiver.new
+          end
+        end
+      end
+
+      def eval(env:, type:, node:)
+        value_node, vars = decompose_value(node)
+
+        truthy_env = env
+        falsy_env = env
+
+        if type.is_a?(AST::Types::Any)
+          type = guess_type_from_method(node) || type
+        end
+
+        if type.is_a?(AST::Types::Logic::Base)
+          vars.each do |var_name|
+            truthy_env = truthy_env.assign!(var_name, node: node, type: AST::Builtin.true_type)
+            falsy_env = truthy_env.assign!(var_name, node: node, type: AST::Builtin.false_type)
+          end
+
+          case type
+          when AST::Types::Logic::ReceiverIsNil
+            case value_node.type
+            when :send
+              receiver = value_node.children[0]
+
+              if receiver
+                _, receiver_vars = decompose_value(receiver)
+
+                receiver_vars.each do |receiver_var|
+                  var_type = env[receiver_var]
+                  truthy_type, falsy_type = factory.unwrap_optional(var_type)
+
+                  truthy_env = truthy_env.assign!(receiver_var, node: node, type: falsy_type || AST::Builtin.nil_type)
+                  falsy_env = falsy_env.assign!(receiver_var, node: node, type: truthy_type)
+                end
+              end
+            end
+          when AST::Types::Logic::ReceiverIsArg
+            case value_node.type
+            when :send
+              receiver, _, arg = value_node.children
+
+              if receiver
+                _, receiver_vars = decompose_value(receiver)
+                arg_type = typing.type_of(node: arg)
+
+                if arg_type.is_a?(AST::Types::Name::Singleton)
+                  receiver_vars.each do |var_name|
+                    var_type = env[var_name]
+                    truthy_type, falsy_type = type_case_select(var_type, arg_type.name)
+
+                    truthy_env = truthy_env.assign!(var_name, node: node, type: truthy_type)
+                    falsy_env = falsy_env.assign!(var_name, node: node, type: falsy_type)
+                  end
+                end
+              end
+            end
+          when AST::Types::Logic::ArgIsReceiver
+            case value_node.type
+            when :send
+              receiver, _, arg = value_node.children
+
+              if receiver
+                _, arg_vars = decompose_value(arg)
+                receiver_type = typing.type_of(node: receiver)
+
+                if receiver_type.is_a?(AST::Types::Name::Singleton)
+                  arg_vars.each do |var_name|
+                    var_type = env[var_name]
+                    truthy_type, falsy_type = type_case_select(var_type, receiver_type.name)
+
+                    truthy_env = truthy_env.assign!(var_name, node: node, type: truthy_type)
+                    falsy_env = falsy_env.assign!(var_name, node: node, type: falsy_type)
+                  end
+                end
+              end
+            end
+          when AST::Types::Logic::Not
+            receiver, * = value_node.children
+            receiver_type = typing.type_of(node: receiver)
+            falsy_env, truthy_env = eval(env: env, type: receiver_type, node: receiver)
+          end
+        else
+          _, vars = decompose_value(node)
+
+          vars.each do |var_name|
+            var_type = env[var_name]
+            truthy_type, falsy_type = factory.unwrap_optional(var_type)
+
+            if falsy_type
+              truthy_env = truthy_env.assign!(var_name, node: node, type: truthy_type)
+              falsy_env = falsy_env.assign!(var_name, node: node, type: falsy_type)
+            else
+              truthy_env = truthy_env.assign!(var_name, node: node, type: truthy_type)
+              falsy_env = falsy_env.assign!(var_name, node: node, type: truthy_type)
+            end
+          end
+        end
+
+        [truthy_env, falsy_env]
+      end
+
+      def decompose_value(node)
+        case node.type
+        when :lvar
+          [node, Set[node.children[0].name]]
+        when :masgn
+          lhs, rhs = node.children
+          lhs_vars = lhs.children.select {|m| m.type == :lvasgn }.map {|m| m.children[0].name }
+          val, vars = decompose_value(rhs)
+          [val, vars + lhs_vars]
+        when :lvasgn
+          var, rhs = node.children
+          val, vars = decompose_value(rhs)
+          [val, vars + [var.name]]
+        when :begin
+          decompose_value(node.children.last)
+        when :and
+          left, right = node.children
+          _, left_vars = decompose_value(left)
+          val, right_vars = decompose_value(right)
+          [val, left_vars + right_vars]
+        else
+          [node, Set[]]
+        end
+      end
+
+      def type_case_select(type, klass)
+        truth_types, false_types = type_case_select0(type, klass)
+
+        [
+          AST::Types::Union.build(types: truth_types),
+          AST::Types::Union.build(types: false_types)
+        ]
+      end
+
+      def type_case_select0(type, klass)
+        instance_type = factory.instance_type(klass)
+
+        case type
+        when AST::Types::Union
+          truthy_types = []
+          falsy_types = []
+
+          type.types.each do |ty|
+            truths, falses = type_case_select0(ty, klass)
+
+            if truths.empty?
+              falsy_types.push(ty)
+            else
+              truthy_types.push(*truths)
+              falsy_types.push(*falses)
+            end
+          end
+
+          [truthy_types, falsy_types]
+
+        when AST::Types::Name::Instance
+          relation = Subtyping::Relation.new(sub_type: type, super_type: instance_type)
+          if subtyping.check(relation, constraints: Subtyping::Constraints.empty, self_type: AST::Types::Self.new).success?
+            [
+              [type],
+              []
+            ]
+          else
+            [
+              [],
+              [type]
+            ]
+          end
+
+        when AST::Types::Name::Alias
+          ty = factory.expand_alias(type)
+          type_case_select0(ty, klass)
+
+        when AST::Types::Any, AST::Types::Top
+          [
+            [instance_type],
+            [type]
+          ]
+
+        else
+          [
+            [],
+            [type]
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/steep/type_inference/type_env.rb

@@ -57,7 +57,7 @@ module Steep
         end
       end
 
-      # @type method assert: (const: Names::Module) { () -> void } -> AST::Type
+      # @type method assert: (const: TypeName) { () -> void } -> AST::Type
       #                    | (gvar: Symbol) { () -> void } -> AST::Type
       #                    | (ivar: Symbol) { () -> void } -> AST::Type
       def get(const: nil, gvar: nil, ivar: nil)
@@ -98,7 +98,7 @@ module Steep
         end
       end
 
-      # @type method assign: (const: Names::Module, type: AST::Type) { (Subtyping::Result::Failure | nil) -> void } -> AST::Type
+      # @type method assign: (const: TypeName, type: AST::Type) { (Subtyping::Result::Failure | nil) -> void } -> AST::Type
       #                    | (gvar: Symbol, type: AST::Type) { (Subtyping::Result::Failure | nil) -> void } -> AST::Type
       #                    | (ivar: Symbol, type: AST::Type) { (Subtyping::Result::Failure | nil) -> void } -> AST::Type
       def assign(const: nil, gvar: nil, ivar: nil, type:, self_type:, &block)

data/lib/steep/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "0.25.0"
+  VERSION = "0.31.0"
 end

data/smoke/alias/a.rb

@@ -1,7 +1,7 @@
 # @type var x: foo
 x = ""
 
-# !expects ArgumentTypeMismatch: receiver=(::Integer | ::String), expected=::string, actual=::Integer
+# !expects* UnresolvedOverloading: receiver=(::String | ::Integer), method_name=+,
 x + 123
 
 # @type var y: bar

data/smoke/case/a.rb

@@ -1,6 +1,6 @@
 # @type var a: Integer
 
-# !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=(::Array[::String] | ::Integer | ::String | nil)
+# !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=(::Integer | ::Array[::String] | nil | ::String)
 a = case 1
     when 2
       1

data/smoke/hash/d.rb

@@ -2,5 +2,5 @@
 
 params = { id: 30, name: "Matz" }
 
-# !expects IncompatibleAssignment: lhs_type={ :name => ::String, :id => ::Integer }, rhs_type={ :id => ::String, :name => ::String, :email => ::String }
+# !expects IncompatibleAssignment: lhs_type={ :id => ::Integer, :name => ::String }, rhs_type={ :email => ::String, :id => ::String, :name => ::String }
 params = { id: "30", name: "foo", email: "matsumoto@soutaro.com" }

data/smoke/if/a.rb

@@ -13,7 +13,7 @@ else
   "baz"
 end
 
-# !expects IncompatibleAssignment: lhs_type=::String, rhs_type=(::Integer | ::String)
+# !expects IncompatibleAssignment: lhs_type=::String, rhs_type=(::String | ::Integer)
 a = if z
       "foofoo"
     else

data/smoke/module/a.rb

@@ -13,7 +13,7 @@ module A
     # !expects IncompatibleAssignment: lhs_type=::String, rhs_type=::Integer
     s = n
 
-    # !expects NoMethodError: type=(::A & ::Object & ::_Each2[::Integer, ::A]), method=foo
+    # !expects NoMethodError: type=(::Object & ::_Each2[::Integer, ::A] & ::A), method=foo
     foo()
 
     n

data/smoke/rescue/a.rb

@@ -1,6 +1,6 @@
 # @type var a: Integer
 
-# !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=(::Integer | ::String)
+# !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=(::String | ::Integer)
 a = begin
       'foo'
     rescue
@@ -9,12 +9,12 @@ a = begin
 
 # @type var b: Integer
 
-# !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=(::Integer | ::String)
+# !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=(::String | ::Integer)
 b = 'foo' rescue 1
 
 # @type var c: Integer
 
-# !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=(::Integer | ::String | ::Symbol)
+# !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=(::String | ::Symbol | ::Integer)
 c = begin
       'foo'
     rescue RuntimeError
@@ -23,18 +23,9 @@ c = begin
       1
     end
 
-# @type var d: Integer
-
-# !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=::String
-d = begin
-      1
-    else
-      'foo'
-    end
-
 # @type var e: Integer
 
-# !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=(::Array[::Integer] | ::Integer | ::Symbol)
+# !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=(::Array[::Integer] | ::Symbol | ::Integer)
 e = begin
       'foo'
     rescue RuntimeError

data/smoke/toplevel/Steepfile

@@ -0,0 +1,5 @@
+target :test do
+  typing_options :strict
+  check "*.rb"
+  signature "*.rbs"
+end

data/smoke/toplevel/a.rb

@@ -0,0 +1,4 @@
+# !expects MethodBodyTypeMismatch: method=fizz_buzz, expected=::String, actual=nil
+def fizz_buzz(n)
+  nil
+end

data/smoke/toplevel/a.rbs

@@ -0,0 +1,3 @@
+class Object
+  def fizz_buzz: (Integer) -> String
+end

data/smoke/type_case/a.rb

@@ -26,10 +26,3 @@ when String
   # @type var x: Integer
   x + 1
 end
-
-case x
-when Object
-  # !expects@+2 IncompatibleTypeCase: var_name=x, ::Object <: (::Integer | ::String | ::Symbol)
-  # !expects NoMethodError: type=::Object, method=foobar
-  x.foobar
-end

data/steep.gemspec

@@ -32,7 +32,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "ast_utils", "~> 0.3.0"
   spec.add_runtime_dependency "activesupport", ">= 5.1"
   spec.add_runtime_dependency "rainbow", ">= 2.2.2", "< 4.0"
-  spec.add_runtime_dependency "listen", "~> 3.1"
-  spec.add_runtime_dependency "language_server-protocol", "~> 3.14.0.2"
-  spec.add_runtime_dependency "rbs", "~> 0.10.0"
+  spec.add_runtime_dependency "listen", "~> 3.0"
+  spec.add_runtime_dependency "language_server-protocol", "~> 3.15.0.1"
+  spec.add_runtime_dependency "rbs", "~> 0.12.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: steep
 version: !ruby/object:Gem::Version
-  version: 0.25.0
+  version: 0.31.0
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-08-17 00:00:00.000000000 Z
+date: 2020-10-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -78,42 +78,42 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.14.0.2
+        version: 3.15.0.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.14.0.2
+        version: 3.15.0.1
 - !ruby/object:Gem::Dependency
   name: rbs
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.10.0
+        version: 0.12.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.10.0
+        version: 0.12.0
 description: Gradual Typing for Ruby
 email:
 - matsumoto@soutaro.com
@@ -143,8 +143,6 @@ files:
 - lib/steep/ast/buffer.rb
 - lib/steep/ast/builtin.rb
 - lib/steep/ast/location.rb
-- lib/steep/ast/method_type.rb
-- lib/steep/ast/namespace.rb
 - lib/steep/ast/type_params.rb
 - lib/steep/ast/types.rb
 - lib/steep/ast/types/any.rb
@@ -156,6 +154,7 @@ files:
 - lib/steep/ast/types/instance.rb
 - lib/steep/ast/types/intersection.rb
 - lib/steep/ast/types/literal.rb
+- lib/steep/ast/types/logic.rb
 - lib/steep/ast/types/name.rb
 - lib/steep/ast/types/nil.rb
 - lib/steep/ast/types/proc.rb
@@ -184,14 +183,15 @@ files:
 - lib/steep/interface/method.rb
 - lib/steep/interface/method_type.rb
 - lib/steep/interface/substitution.rb
-- lib/steep/names.rb
+- lib/steep/module_helper.rb
 - lib/steep/project.rb
 - lib/steep/project/completion_provider.rb
 - lib/steep/project/dsl.rb
-- lib/steep/project/file.rb
 - lib/steep/project/file_loader.rb
 - lib/steep/project/hover_content.rb
 - lib/steep/project/options.rb
+- lib/steep/project/signature_file.rb
+- lib/steep/project/source_file.rb
 - lib/steep/project/target.rb
 - lib/steep/server/base_worker.rb
 - lib/steep/server/code_worker.rb
@@ -218,6 +218,7 @@ files:
 - lib/steep/type_inference/context_array.rb
 - lib/steep/type_inference/local_variable_type_env.rb
 - lib/steep/type_inference/logic.rb
+- lib/steep/type_inference/logic_type_interpreter.rb
 - lib/steep/type_inference/send_args.rb
 - lib/steep/type_inference/type_env.rb
 - lib/steep/typing.rb
@@ -347,6 +348,9 @@ files:
 - smoke/super/Steepfile
 - smoke/super/a.rb
 - smoke/super/a.rbs
+- smoke/toplevel/Steepfile
+- smoke/toplevel/a.rb
+- smoke/toplevel/a.rbs
 - smoke/type_case/Steepfile
 - smoke/type_case/a.rb
 - smoke/yield/Steepfile
@@ -374,7 +378,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Gradual Typing for Ruby