steep 0.19.0 → 0.24.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a2c1abcf64958fd547dbb336a0489d9e310e71bc66d208a67c6328c1ac09e62b
-  data.tar.gz: eecd4d437442a85356525c31d10697d73f06fd319930371a7f2710b77f3e86a3
+  metadata.gz: 3fc0de639f659b9b59f83ca0f8968550e7230ee1dbb6ae8e0d005325267ab46e
+  data.tar.gz: a1f73b521a222fa1313c2f58b1e0d3fb2a07149aba42c17e91c8df495e3319de
 SHA512:
-  metadata.gz: 57957103491d678aa843f9155a757d9f903968d272e2d117b659bcb46659ada397cf82db1bf4e54e25f77a5548db32b6ea2da7be0fba6920d033340c44448c19
-  data.tar.gz: 94eeb79af2e1fdab28b5f2c6237e343d9f174d7ff5a65c9d25d3860e042820027c1f4fab8c6571492967c74b37161572b8ab1dea91d8d60d0e7f2c1cbf4c31fe
+  metadata.gz: bcedd630c3b51bc4d3a24549c6bcde88156af410be2b64ec51d813c238f3cb5d5f9f85b980302cae3cacd007e478ae51f99019ed10f3b6a31df84723bd43f35b
+  data.tar.gz: da09a3c3e7f762ec48b378533b6c624c1b9590a0cfd58ffc7aed87212fde2c67897bc1aa745eaa8f4baeaa19b1e6c7b0a4826e7fb6e582a6ef6798ee3b4a47a4

data/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 ## master
 
+## 0.24.0 (2020-08-11)
+
+* Update RBS to 0.10 ([#180](https://github.com/soutaro/steep/pull/180))
+
+## 0.23.0 (2020-08-06)
+
+* Fix literal typing with hint ([#179](https://github.com/soutaro/steep/pull/179))
+* Fix literal type subtyping ([#178](https://github.com/soutaro/steep/pull/178))
+
+## 0.22.0 (2020-08-03)
+
+* Improve signature validation ([#175](https://github.com/soutaro/steep/pull/175), [#177](https://github.com/soutaro/steep/pull/177))
+* Fix boolean literal typing ([#172](https://github.com/soutaro/steep/pull/172))
+* Make exit code success when Steep has unreported type errors ([#171](https://github.com/soutaro/steep/pull/171))
+* Allow `./` prefix for signature pattern ([#170](https://github.com/soutaro/steep/pull/170))
+
+## 0.21.0 (2020-07-20)
+
+* Fix LSP hover ([#168](https://github.com/soutaro/steep/pull/168))
+* Nominal subtyping ([#167](https://github.com/soutaro/steep/pull/167))
+
+## 0.20.0 (2020-07-17)
+
+* Support singleton class definitions ([#166](https://github.com/soutaro/steep/pull/166))
+
 ## 0.19.0 (2020-07-12)
 
 * Update RBS. ([#157](https://github.com/soutaro/steep/pull/157))
@@ -35,7 +60,7 @@
 
 * Fix constant resolution ([#143](https://github.com/soutaro/steep/pull/143))
 * Fix RBS diagnostics line number in LSP ([#142](https://github.com/soutaro/steep/pull/142))
-* Fix crash caused by hover on `def` in LSP ([#140](https://github.com/soutaro/steep/pull/140)) 
+* Fix crash caused by hover on `def` in LSP ([#140](https://github.com/soutaro/steep/pull/140))
 
 ## 0.16.0 (2020-05-19)
 

data/Gemfile

@@ -5,3 +5,10 @@ gemspec
 
 gem "with_steep_types", path: "test/gems/with_steep_types"
 gem "without_steep_types", path: "test/gems/without_steep_types"
+
+gem "rake"
+gem "minitest", "~> 5.0"
+gem "racc", "~> 1.4"
+gem "minitest-reporters"
+gem "minitest-hooks"
+gem "stackprof"

data/bin/steep-prof

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+require "stackprof"
+
+mode = (ENV["STEEP_STACKPROF_MODE"] || :wall).to_sym
+out = ENV["STEEP_STACKPROF_OUT"] || "tmp/stackprof-#{mode}-steep.dump"
+
+def exit(*)
+
+end
+
+
+STDERR.puts "Running profiler: mode=#{mode}, out=#{out}"
+StackProf.run(mode: mode, out: out) do
+  load File.join(__dir__, "../exe/steep")
+end

data/lib/steep/ast/types/factory.rb

@@ -288,7 +288,7 @@ module Steep
         def expand_alias(type)
           unfolded = case type
                      when AST::Types::Name::Alias
-                       unfolded = unfold(type.name)
+                       unfold(type.name)
                      else
                        type
                      end

data/lib/steep/ast/types/literal.rb

@@ -49,6 +49,10 @@ module Steep
                     Builtin::String
                   when Symbol
                     Builtin::Symbol
+                  when true
+                    Builtin::TrueClass
+                  when false
+                    Builtin::FalseClass
                   else
                     raise "Unexpected literal type: #{value.inspect}"
                   end

data/lib/steep/project/target.rb

@@ -79,6 +79,7 @@ module Steep
       def self.test_pattern(patterns, path, ext:)
         patterns.any? do |pattern|
           p = pattern.end_with?(File::Separator) ? pattern : pattern + File::Separator
+          p.delete_prefix!('./')
           (path.to_s.start_with?(p) && path.extname == ext) || File.fnmatch(pattern, path.to_s)
         end
       end
@@ -160,6 +161,16 @@ module Steep
               else
                 yield env, check, Time.now
               end
+            rescue RBS::DuplicatedDeclarationError => exn
+              @status = SignatureValidationErrorStatus.new(
+                errors: [
+                  Signature::Errors::DuplicatedDefinitionError.new(
+                    name: exn.name,
+                    location: exn.decls[0].location
+                  )
+                ],
+                timestamp: Time.now
+              )
             rescue => exn
               @status = SignatureOtherErrorStatus.new(error: exn, timestamp: Time.now)
             end
@@ -205,7 +216,7 @@ module Steep
       def errors
         case status
         when TypeCheckStatus
-          source_files.each_value.flat_map(&:errors)
+          source_files.each_value.flat_map(&:errors).select { |error | options.error_to_report?(error) }
         else
           []
         end

data/lib/steep/server/interaction_worker.rb

@@ -95,8 +95,8 @@ module Steep
 ```
 HOVER
             if content.definition
-              if content.definition.comment
-                string << "\n----\n\n#{content.definition.comment.string}"
+              if content.definition.comments
+                string << "\n----\n\n#{content.definition.comments.map(&:string).join("\n\n")}"
               end
 
               string << "\n----\n\n#{content.definition.method_types.map {|x| "- `#{x}`\n" }.join()}"
@@ -111,7 +111,7 @@ def #{content.method_name}: #{content.method_type}
 ```
 HOVER
           if (comment = content.comment_string)
-            string << "\n----\n\n#{comment.string}\n"
+            string << "\n----\n\n#{comment}\n"
           end
 
           if content.definition.method_types.size > 1

data/lib/steep/server/signature_worker.rb

@@ -112,6 +112,9 @@ module Steep
                         target.signature_files.each_key.with_object({}) do |path, hash|
                           hash[path] = []
                         end
+                      when Project::Target::SignatureOtherErrorStatus
+                        Steep.log_error status.error
+                        {}
                       else
                         Steep.logger.info "Unexpected target status: #{status.class}"
                         {}

data/lib/steep/signature/errors.rb

@@ -19,6 +19,19 @@ module Steep
         end
       end
 
+      class DuplicatedDefinitionError < Base
+        attr_reader :name
+
+        def initialize(name:, location:)
+          @name = name
+          @location = location
+        end
+
+        def puts(io)
+          io.puts "#{loc_to_s}\sDuplicatedDefinitionError: name=#{name}"
+        end
+      end
+
       class UnknownTypeNameError < Base
         attr_reader :name
 
@@ -48,6 +61,21 @@ module Steep
           io.puts "#{loc_to_s}\tInvalidTypeApplicationError: name=#{name}, expected=[#{params.join(", ")}], actual=[#{args.join(", ")}]"
         end
       end
+
+      class InvalidMethodOverloadError < Base
+        attr_reader :class_name
+        attr_reader :method_name
+
+        def initialize(class_name:, method_name:, location:)
+          @class_name = class_name
+          @method_name = method_name
+          @location = location
+        end
+
+        def puts(io)
+          io.puts "#{loc_to_s}\tInvalidMethodOverloadError: class_name=#{class_name}, method_name=#{method_name}"
+        end
+      end
     end
   end
 end

data/lib/steep/signature/validator.rb

@@ -53,6 +53,7 @@ module Steep
         validate_decl
         validate_const
         validate_global
+        validate_alias
       end
 
       def validate_type(type)
@@ -99,6 +100,7 @@ module Steep
         env.constant_decls.each do |name, entry|
           rescue_validation_errors do
             Steep.logger.debug "Validating constant `#{name}`..."
+            builder.ensure_namespace!(name.namespace, location: entry.decl.location)
             validate_type entry.decl.type
           end
         end
@@ -117,7 +119,9 @@ module Steep
         env.alias_decls.each do |name, entry|
           rescue_validation_errors do
             Steep.logger.debug "Validating alias `#{name}`..."
-            validate_type(entry.decl.type)
+            builder.expand_alias(name).tap do |type|
+              validate_type(type)
+            end
           end
         end
       end
@@ -136,6 +140,12 @@ module Steep
           name: factory.type_name(exn.type_name),
           location: exn.location
         )
+      rescue RBS::InvalidOverloadMethodError => exn
+        @errors << Errors::InvalidMethodOverloadError.new(
+          class_name: factory.type_name(exn.type_name),
+          method_name: exn.method_name,
+          location: exn.members[0].location
+        )
       end
     end
   end

data/lib/steep/subtyping/check.rb

@@ -9,6 +9,84 @@ module Steep
         @cache = {}
       end
 
+      def instance_super_types(type_name, args:)
+        type_name_1 = factory.type_name_1(type_name)
+        ancestors = factory.definition_builder.one_instance_ancestors(type_name_1)
+
+        subst = unless args.empty?
+                  args_ = args.map {|type| factory.type_1(type) }
+                  RBS::Substitution.build(ancestors.params, args_)
+                end
+
+        ancestors.each_ancestor.map do |ancestor|
+          name = factory.type_name(ancestor.name)
+
+          case ancestor
+          when RBS::Definition::Ancestor::Instance
+            args = ancestor.args.map do |type|
+              type = type.sub(subst) if subst
+              factory.type(type)
+            end
+
+            if ancestor.name.class?
+              AST::Types::Name::Instance.new(
+                name: name,
+                args: args,
+                location: nil
+              )
+            else
+              AST::Types::Name::Interface.new(
+                name: name,
+                args: args,
+                location: nil
+              )
+            end
+          when RBS::Definition::Ancestor::Singleton
+            AST::Types::Name::Class.new(
+              name: name,
+              constructor: nil,
+              location: nil
+            )
+          end
+        end
+      end
+
+      def singleton_super_types(type_name)
+        type_name_1 = factory.type_name_1(type_name)
+        ancestors = factory.definition_builder.one_singleton_ancestors(type_name_1)
+
+        ancestors.each_ancestor.map do |ancestor|
+          name = factory.type_name(ancestor.name)
+
+          case ancestor
+          when RBS::Definition::Ancestor::Instance
+            args = ancestor.args.map do |type|
+              factory.type(type)
+            end
+
+            if ancestor.name.class?
+              AST::Types::Name::Instance.new(
+                name: name,
+                args: args,
+                location: nil
+              )
+            else
+              AST::Types::Name::Interface.new(
+                name: name,
+                args: args,
+                location: nil
+              )
+            end
+          when RBS::Definition::Ancestor::Singleton
+            AST::Types::Name::Class.new(
+              name: name,
+              constructor: nil,
+              location: nil
+            )
+          end
+        end
+      end
+
       def check(relation, constraints:, self_type:, assumption: Set.new, trace: Trace.new)
         Steep.logger.tagged "#{relation.sub_type} <: #{relation.super_type}" do
           prefix = trace.size
@@ -102,15 +180,6 @@ module Steep
               constraints: constraints
             )
 
-          when relation.sub_type.is_a?(AST::Types::Literal)
-            check(
-              Relation.new(sub_type: relation.sub_type.back_type, super_type: relation.super_type),
-              self_type: self_type,
-              assumption: assumption,
-              trace: trace,
-              constraints: constraints
-            )
-
           when relation.sub_type.is_a?(AST::Types::Union)
             results = relation.sub_type.types.map do |sub_type|
               check(Relation.new(sub_type: sub_type, super_type: relation.super_type),
@@ -175,30 +244,45 @@ module Steep
             failure(error: Result::Failure::UnknownPairError.new(relation: relation),
                     trace: trace)
 
-          when relation.sub_type.is_a?(AST::Types::Name::Base) && relation.super_type.is_a?(AST::Types::Name::Base)
-            if (pairs = extract_nominal_pairs(relation))
-              results = pairs.flat_map do |(sub, sup)|
-                Relation.new(sub_type: sub, super_type: sup).yield_self do |rel|
-                  [rel, rel.flip]
-                end
-              end.map do |relation|
-                check(relation,
-                       self_type: self_type,
-                       assumption: assumption,
-                       trace: trace,
-                       constraints: constraints)
-              end
+          when relation.super_type.is_a?(AST::Types::Name::Interface)
+            sub_interface = factory.interface(relation.sub_type, private: false)
+            super_interface = factory.interface(relation.super_type, private: false)
 
-              if results.all?(&:success?)
-                results.first
+            check_interface(sub_interface,
+                            super_interface,
+                            self_type: self_type,
+                            assumption: assumption,
+                            trace: trace,
+                            constraints: constraints)
+
+          when relation.sub_type.is_a?(AST::Types::Name::Base) && relation.super_type.is_a?(AST::Types::Name::Base)
+            if relation.sub_type.name == relation.super_type.name && relation.sub_type.class == relation.super_type.class
+              if arg_type?(relation.sub_type) && arg_type?(relation.super_type)
+                check_type_arg(relation, self_type: self_type, assumption: assumption, trace: trace, constraints: constraints)
               else
-                results.find(&:failure?)
+                success(constraints: constraints)
               end
             else
-              sub_interface = factory.interface(relation.sub_type, private: false)
-              super_interface = factory.interface(relation.super_type, private: false)
-
-              check_interface(sub_interface, super_interface, self_type: self_type, assumption: assumption, trace: trace, constraints: constraints)
+              possible_sub_types = case relation.sub_type
+                                   when AST::Types::Name::Instance
+                                     instance_super_types(relation.sub_type.name, args: relation.sub_type.args)
+                                   when AST::Types::Name::Class
+                                     singleton_super_types(relation.sub_type.name)
+                                   else
+                                     []
+                                   end
+
+              unless possible_sub_types.empty?
+                success_any?(possible_sub_types) do |sub_type|
+                  check(Relation.new(sub_type: sub_type, super_type: relation.super_type),
+                        self_type: self_type,
+                        assumption: assumption,
+                        trace: trace,
+                        constraints: constraints)
+                end
+              else
+                failure(error: Result::Failure::UnknownPairError.new(relation: relation), trace: trace)
+              end
             end
 
           when relation.sub_type.is_a?(AST::Types::Proc) && relation.super_type.is_a?(AST::Types::Proc)
@@ -276,6 +360,32 @@ module Steep
                             trace: trace,
                             constraints: constraints)
 
+          when relation.super_type.is_a?(AST::Types::Literal)
+            case
+            when relation.super_type.value == true && AST::Builtin::TrueClass.instance_type?(relation.sub_type)
+              success(constraints: constraints)
+            when relation.super_type.value == false && AST::Builtin::FalseClass.instance_type?(relation.sub_type)
+              success(constraints: constraints)
+            else
+              failure(error: Result::Failure::UnknownPairError.new(relation: relation),
+                      trace: trace)
+            end
+
+          when relation.super_type.is_a?(AST::Types::Nil) && AST::Builtin::NilClass.instance_type?(relation.sub_type)
+            success(constraints: constraints)
+
+          when relation.sub_type.is_a?(AST::Types::Nil) && AST::Builtin::NilClass.instance_type?(relation.super_type)
+            success(constraints: constraints)
+
+          when relation.sub_type.is_a?(AST::Types::Literal)
+            check(
+              Relation.new(sub_type: relation.sub_type.back_type, super_type: relation.super_type),
+              self_type: self_type,
+              assumption: assumption,
+              trace: trace,
+              constraints: constraints
+            )
+
           else
             failure(error: Result::Failure::UnknownPairError.new(relation: relation),
                     trace: trace)
@@ -283,6 +393,80 @@ module Steep
         end
       end
 
+      def definition_for_type(type)
+        type_name = factory.type_name_1(type.name)
+
+        case type
+        when AST::Types::Name::Instance
+          factory.definition_builder.build_instance(type_name)
+        when AST::Types::Name::Class
+          factory.definition_builder.build_singleton(type_name)
+        when AST::Types::Name::Interface
+          factory.definition_builder.build_interface(type_name)
+        else
+          raise
+        end
+      end
+
+      def arg_type?(type)
+        case type
+        when AST::Types::Name::Instance, AST::Types::Name::Interface
+          type.args.size > 0
+        else
+          false
+        end
+      end
+
+      def check_type_arg(relation, self_type:, assumption:, trace:, constraints:)
+        sub_args = relation.sub_type.args
+        sup_args = relation.super_type.args
+
+        sup_def = definition_for_type(relation.super_type)
+        sup_params = sup_def.type_params_decl
+
+        success_all?(sub_args.zip(sup_args, sup_params.each)) do |sub_arg, sup_arg, sup_param|
+          case sup_param.variance
+          when :covariant
+            check(Relation.new(sub_type: sub_arg, super_type: sup_arg), self_type: self_type, assumption: assumption, trace: trace, constraints: constraints)
+          when :contravariant
+            check(Relation.new(sub_type: sup_arg, super_type: sub_arg), self_type: self_type, assumption: assumption, trace: trace, constraints: constraints)
+          when :invariant
+            rel = Relation.new(sub_type: sub_arg, super_type: sup_arg)
+            success_all?([rel, rel.flip]) do |r|
+              check(r, self_type: self_type, assumption: assumption, trace: trace, constraints: constraints)
+            end
+          end
+        end
+      end
+
+      def success_all?(collection, &block)
+        results = collection.map do |obj|
+          result = yield(obj)
+
+          if result.failure?
+            return result
+          end
+
+          result
+        end
+
+        results[0]
+      end
+
+      def success_any?(collection, &block)
+        results = collection.map do |obj|
+          result = yield(obj)
+
+          if result.success?
+            return result
+          end
+
+          result
+        end
+
+        results[0]
+      end
+
       def extract_nominal_pairs(relation)
         sub_type = relation.sub_type
         super_type = relation.super_type
@@ -316,20 +500,7 @@ module Steep
           return true
         end
 
-        case
-        when relation.sub_type == relation.super_type
-          true
-        when relation.sub_type.is_a?(AST::Types::Name::Base) && relation.super_type.is_a?(AST::Types::Name::Base)
-          if (pairs = extract_nominal_pairs(relation))
-            pairs.all? do |(s, t)|
-              same_type?(Relation.new(sub_type: s, super_type: t), assumption: assumption)
-            end
-          else
-            false
-          end
-        else
-          false
-        end
+        relation.sub_type == relation.super_type
       end
 
       def check_interface(sub_interface, super_interface, self_type:, assumption:, trace:, constraints:)

data/lib/steep/type_construction.rb

@@ -230,6 +230,39 @@ module Steep
       )
     end
 
+    def implement_module(module_name:, super_name: nil, annotations:)
+      if (annotation = annotations.implement_module_annotation)
+        absolute_name(annotation.name.name).yield_self do |absolute_name|
+          if checker.factory.class_name?(absolute_name) || checker.factory.module_name?(absolute_name)
+            AST::Annotation::Implements::Module.new(
+              name: absolute_name,
+              args: annotation.name.args
+            )
+          else
+            Steep.logger.error "Unknown class name given to @implements: #{annotation.name.name}"
+            nil
+          end
+        end
+      else
+        name = nil
+        name ||= absolute_name(module_name).yield_self do |absolute_name|
+          absolute_name if checker.factory.class_name?(absolute_name) || checker.factory.module_name?(absolute_name)
+        end
+        name ||= super_name && absolute_name(super_name).yield_self do |absolute_name|
+          absolute_name if checker.factory.class_name?(absolute_name) || checker.factory.module_name?(absolute_name)
+        end
+
+        if name
+          absolute_name_ = checker.factory.type_name_1(name)
+          entry = checker.factory.env.class_decls[absolute_name_]
+          AST::Annotation::Implements::Module.new(
+            name: name,
+            args: entry.type_params.each.map(&:name)
+          )
+        end
+      end
+    end
+
     def for_module(node)
       new_module_name = Names::Module.from_node(node.children.first) or raise "Unexpected module name: #{node.children.first}"
       new_namespace = nested_namespace_for_module(new_module_name)
@@ -240,28 +273,7 @@ module Steep
       annots = source.annotations(block: node, factory: checker.factory, current_module: new_namespace)
       module_type = AST::Builtin::Module.instance_type
 
-      implement_module_name = yield_self do
-        if (annotation = annots.implement_module_annotation)
-          absolute_name(annotation.name.name).yield_self do |absolute_name|
-            if checker.factory.module_name?(absolute_name)
-              AST::Annotation::Implements::Module.new(name: absolute_name,
-                                                      args: annotation.name.args)
-            else
-              Steep.logger.error "Unknown module name given to @implements: #{annotation.name.name}"
-              nil
-            end
-          end
-        else
-          absolute_name(new_module_name).yield_self do |absolute_name|
-            if checker.factory.module_name?(absolute_name)
-              absolute_name_ = checker.factory.type_name_1(absolute_name)
-              entry = checker.factory.env.class_decls[absolute_name_]
-              AST::Annotation::Implements::Module.new(name: absolute_name,
-                                                      args: entry.type_params.each.map(&:name))
-            end
-          end
-        end
-      end
+      implement_module_name = implement_module(module_name: new_module_name, annotations: annots)
 
       if implement_module_name
         module_name = implement_module_name.name
@@ -352,36 +364,7 @@ module Steep
 
       annots = source.annotations(block: node, factory: checker.factory, current_module: new_namespace)
 
-      implement_module_name = yield_self do
-        if (annotation = annots.implement_module_annotation)
-          absolute_name(annotation.name.name).yield_self do |absolute_name|
-            if checker.factory.class_name?(absolute_name)
-              AST::Annotation::Implements::Module.new(name: absolute_name,
-                                                      args: annotation.name.args)
-            else
-              Steep.logger.error "Unknown class name given to @implements: #{annotation.name.name}"
-              nil
-            end
-          end
-        else
-          name = nil
-          name ||= absolute_name(new_class_name).yield_self do |absolute_name|
-            absolute_name if checker.factory.class_name?(absolute_name)
-          end
-          name ||= super_class_name && absolute_name(super_class_name).yield_self do |absolute_name|
-            absolute_name if checker.factory.class_name?(absolute_name)
-          end
-
-          if name
-            absolute_name_ = checker.factory.type_name_1(name)
-            entry = checker.factory.env.class_decls[absolute_name_]
-            AST::Annotation::Implements::Module.new(
-              name: name,
-              args: entry.type_params.each.map(&:name)
-            )
-          end
-        end
-      end
+      implement_module_name = implement_module(module_name: new_class_name, super_name: super_class_name, annotations: annots)
 
       if annots.implement_module_annotation
         new_class_name = implement_module_name.name
@@ -450,6 +433,83 @@ module Steep
       )
     end
 
+    def for_sclass(node, type)
+      annots = source.annotations(block: node, factory: checker.factory, current_module: current_namespace)
+
+      instance_type = if type.is_a?(AST::Types::Self)
+                        context.self_type
+                      else
+                        type
+                      end
+
+      module_type = case instance_type
+                    when AST::Types::Name::Class
+                      AST::Builtin::Class.instance_type
+                    when AST::Types::Name::Module
+                      AST::Builtin::Module.instance_type
+                    when AST::Types::Name::Instance
+                      instance_type.to_class(constructor: nil)
+                    else
+                      raise "Unexpected type for sclass node: #{type}"
+                    end
+
+      instance_definition = case instance_type
+                            when AST::Types::Name::Class, AST::Types::Name::Module
+                              type_name = checker.factory.type_name_1(instance_type.name)
+                              checker.factory.definition_builder.build_singleton(type_name)
+                            when AST::Types::Name::Instance
+                              type_name = checker.factory.type_name_1(instance_type.name)
+                              checker.factory.definition_builder.build_instance(type_name)
+                            end
+
+      module_definition = case module_type
+                          when AST::Types::Name::Class, AST::Types::Name::Module
+                            type_name = checker.factory.type_name_1(instance_type.name)
+                            checker.factory.definition_builder.build_singleton(type_name)
+                          else
+                            nil
+                          end
+
+      module_context = TypeInference::Context::ModuleContext.new(
+        instance_type: annots.instance_type || instance_type,
+        module_type: annots.self_type || annots.module_type || module_type,
+        implement_name: nil,
+        current_namespace: current_namespace,
+        const_env: self.module_context.const_env,
+        class_name: self.module_context.class_name,
+        module_definition: module_definition,
+        instance_definition: instance_definition
+      )
+
+      type_env = TypeInference::TypeEnv.build(annotations: annots,
+                                              subtyping: checker,
+                                              const_env: self.module_context.const_env,
+                                              signatures: checker.factory.env)
+
+      lvar_env = TypeInference::LocalVariableTypeEnv.empty(
+        subtyping: checker,
+        self_type: module_context.module_type
+      ).annotate(annots)
+
+      body_context = TypeInference::Context.new(
+        method_context: nil,
+        block_context: nil,
+        module_context: module_context,
+        break_context: nil,
+        self_type: module_context.module_type,
+        type_env: type_env,
+        lvar_env: lvar_env
+      )
+
+      self.class.new(
+        checker: checker,
+        source: source,
+        annotations: annots,
+        typing: typing,
+        context: body_context
+      )
+    end
+
     def for_branch(node, truthy_vars: Set.new, type_case_override: nil, break_context: context.break_context)
       annots = source.annotations(block: node, factory: checker.factory, current_module: current_namespace)
 
@@ -578,7 +638,8 @@ module Steep
             when :__skip__
               add_typing(node, type: AST::Builtin.any_type)
             else
-              rhs_result = synthesize(rhs, hint: hint || context.lvar_env.declared_types[name]&.type)
+              hint ||= context.lvar_env.declared_types[name]&.type
+              rhs_result = synthesize(rhs, hint: hint)
 
               constr = rhs_result.constr.update_lvar_env do |lvar_env|
                 lvar_env.assign(name, node: node, type: rhs_result.type) do |declared_type, actual_type, result|
@@ -1002,7 +1063,7 @@ module Steep
 
         when :int
           yield_self do
-            literal_type = expand_alias(hint) {|hint_| test_literal_type(node.children[0], hint_) }
+            literal_type = test_literal_type(node.children[0], hint)
 
             if literal_type
               add_typing(node, type: literal_type)
@@ -1013,7 +1074,7 @@ module Steep
 
         when :sym
           yield_self do
-            literal_type = expand_alias(hint) {|hint| test_literal_type(node.children[0], hint) }
+            literal_type = test_literal_type(node.children[0], hint)
 
             if literal_type
               add_typing(node, type: literal_type)
@@ -1024,7 +1085,7 @@ module Steep
 
         when :str
           yield_self do
-            literal_type = expand_alias(hint) {|hint_| test_literal_type(node.children[0], hint_)}
+            literal_type = test_literal_type(node.children[0], hint)
 
             if literal_type
               add_typing(node, type: literal_type)
@@ -1034,7 +1095,13 @@ module Steep
           end
 
         when :true, :false
-          add_typing(node, type: AST::Types::Boolean.new)
+          ty = node.type == :true ? AST::Types::Literal.new(value: true) : AST::Types::Literal.new(value: false)
+
+          if hint && check_relation(sub_type: ty, super_type: hint).success?
+            add_typing(node, type: hint)
+          else
+            add_typing(node, type: AST::Types::Boolean.new)
+          end
 
         when :hash
           yield_self do
@@ -1130,6 +1197,25 @@ module Steep
             add_typing(node, type: AST::Builtin.nil_type)
           end
 
+        when :sclass
+          yield_self do
+            type, constr = synthesize(node.children[0])
+            constructor = constr.for_sclass(node, type)
+
+            constructor.typing.add_context_for_node(node, context: constructor.context)
+            constructor.typing.add_context_for_body(node, context: constructor.context)
+
+            constructor.synthesize(node.children[1]) if node.children[1]
+
+            if constructor.module_context.instance_definition && module_context.module_definition
+              if constructor.module_context.instance_definition.type_name == module_context.module_definition.type_name
+                module_context.defined_module_methods.merge(constructor.module_context.defined_instance_methods)
+              end
+            end
+
+            add_typing(node, type: AST::Builtin.nil_type)
+          end
+
         when :self
           add_typing node, type: AST::Types::Self.new
 
@@ -2937,14 +3023,15 @@ module Steep
     end
 
     def test_literal_type(literal, hint)
-      case hint
-      when AST::Types::Literal
-        if hint.value == literal
-          hint
-        end
-      when AST::Types::Union
-        if hint.types.any? {|ty| ty.is_a?(AST::Types::Literal) && ty.value == literal}
-          hint
+      if hint
+        case hint
+        when AST::Types::Any
+          nil
+        else
+          literal_type = AST::Types::Literal.new(value: literal, location: nil)
+          if check_relation(sub_type: literal_type, super_type: hint).success?
+            hint
+          end
         end
       end
     end

data/lib/steep/typing.rb

@@ -95,6 +95,12 @@ module Steep
         end_pos = node.loc.end.begin_pos
         add_context(begin_pos..end_pos, context: context)
 
+      when :sclass
+        name_node = node.children[0]
+        begin_pos = name_node.loc.expression.end_pos
+        end_pos = node.loc.end.begin_pos
+        add_context(begin_pos..end_pos, context: context)
+
       when :def, :defs
         args_node = case node.type
                     when :def

data/lib/steep/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "0.19.0"
+  VERSION = "0.24.0"
 end

data/smoke/class/a.rbs

@@ -18,7 +18,6 @@ class D
   def foo: -> untyped
 end
 
-class E
-  def initialize: () -> untyped
+interface _E
   def foo: -> untyped
 end

data/smoke/class/f.rb

@@ -1,8 +1,10 @@
-# @type var e: E
+# @type var e: _E
 # @type var d: D
 
 e = (_ = nil)
 d = (_ = nil)
 
 e = d
+
+# !expects IncompatibleAssignment: lhs_type=::D, rhs_type=::_E
 d = e

data/steep.gemspec

@@ -28,18 +28,11 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = '>= 2.6.0'
 
-  spec.add_development_dependency "bundler", ">= 1.13"
-  spec.add_development_dependency "rake", "~> 13.0"
-  spec.add_development_dependency "minitest", "~> 5.0"
-  spec.add_development_dependency "racc", "~> 1.4"
-  spec.add_development_dependency "minitest-reporters", "~> 1.4.2"
-  spec.add_development_dependency "minitest-hooks", "~> 1.5.0"
-
   spec.add_runtime_dependency "parser", "~> 2.7.0"
   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.6.0", '< 0.7.0'
+  spec.add_runtime_dependency "rbs", "~> 0.10.0"
 end

metadata

@@ -1,99 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: steep
 version: !ruby/object:Gem::Version
-  version: 0.19.0
+  version: 0.24.0
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-07-12 00:00:00.000000000 Z
+date: 2020-08-10 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.13'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.13'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
-- !ruby/object:Gem::Dependency
-  name: minitest
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.0'
-- !ruby/object:Gem::Dependency
-  name: racc
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.4'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.4'
-- !ruby/object:Gem::Dependency
-  name: minitest-reporters
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.4.2
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.4.2
-- !ruby/object:Gem::Dependency
-  name: minitest-hooks
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.5.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.5.0
 - !ruby/object:Gem::Dependency
   name: parser
   requirement: !ruby/object:Gem::Requirement
@@ -188,22 +104,16 @@ dependencies:
   name: rbs
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.6.0
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.7.0
+        version: 0.10.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.6.0
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.7.0
+        version: 0.10.0
 description: Gradual Typing for Ruby
 email:
 - matsumoto@soutaro.com
@@ -224,6 +134,7 @@ files:
 - bin/console
 - bin/setup
 - bin/smoke_runner.rb
+- bin/steep-prof
 - exe/steep
 - lib/steep.rb
 - lib/steep/annotation_parser.rb