steep 0.18.0 → 0.23.0

data/lib/steep/type_construction.rb

@@ -37,7 +37,6 @@ module Steep
     attr_reader :source
     attr_reader :annotations
     attr_reader :typing
-    attr_reader :type_env
 
     attr_reader :context
 
@@ -169,7 +168,7 @@ module Steep
 
       super_method = if definition
                        if (this_method = definition.methods[method_name])
-                         if module_context&.class_name == checker.factory.type_name(this_method.defined_in.name.absolute!)
+                         if module_context&.class_name == checker.factory.type_name(this_method.defined_in)
                            this_method.super_method
                          else
                            this_method
@@ -231,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)
@@ -241,35 +273,14 @@ 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)
-              decl = checker.factory.env.find_class(absolute_name_)
-              AST::Annotation::Implements::Module.new(name: absolute_name,
-                                                      args: decl.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
         module_args = implement_module_name.args.map {|x| AST::Types::Var.new(name: x)}
 
         type_name_ = checker.factory.type_name_1(implement_module_name.name)
-        module_decl = checker.factory.definition_builder.env.find_class(type_name_)
+        module_entry = checker.factory.definition_builder.env.class_decls[type_name_]
         instance_def = checker.factory.definition_builder.build_instance(type_name_)
         module_def = checker.factory.definition_builder.build_singleton(type_name_)
 
@@ -277,9 +288,22 @@ module Steep
           types: [
             AST::Types::Name::Instance.new(name: module_name, args: module_args),
             AST::Builtin::Object.instance_type,
-            module_decl.self_type&.yield_self {|ty|
-              absolute_type = checker.factory.env.absolute_type(ty, namespace: module_decl.name.absolute!.namespace)
-              checker.factory.type(absolute_type)
+            *module_entry.self_types.map {|module_self|
+              type = case
+                     when module_self.name.interface?
+                       RBS::Types::Interface.new(
+                         name: module_self.name,
+                         args: module_self.args,
+                         location: module_self.location
+                       )
+                     when module_self.name.class?
+                       RBS::Types::ClassInstance.new(
+                         name: module_self.name,
+                         args: module_self.args,
+                         location: module_self.location
+                       )
+                     end
+              checker.factory.type(type)
             }
           ].compact
         )
@@ -340,34 +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)
-            decl = checker.factory.env.find_class(absolute_name_)
-            AST::Annotation::Implements::Module.new(name: name,
-                                                    args: decl.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
@@ -436,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)
 
@@ -564,7 +638,9 @@ 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|
                   typing.add_error(Errors::IncompatibleAssignment.new(node: node,
@@ -987,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)
@@ -998,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)
@@ -1009,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)
@@ -1019,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
@@ -1115,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
 
@@ -1992,9 +2093,11 @@ module Steep
                      end
                    end
                  rescue => exn
-                   $stderr.puts exn.inspect
-                   exn.backtrace.each do |t|
-                     $stderr.puts t
+                   case exn
+                   when RBS::NoTypeFoundError, RBS::NoMixinFoundError, RBS::NoSuperclassFoundError, RBS::InvalidTypeApplicationError
+                     # ignore known RBS errors.
+                   else
+                     Steep.log_error(exn, message: "Unexpected error in #type_send: #{exn.message} (#{exn.class})")
                    end
 
                    fallback_to_any node do
@@ -2750,13 +2853,18 @@ module Steep
     end
 
     def validate_method_definitions(node, module_name)
+      module_name_1 = checker.factory.type_name_1(module_name.name)
+      member_decl_count = checker.factory.env.class_decls[module_name_1].decls.count {|d| d.decl.each_member.count > 0 }
+
+      return unless member_decl_count == 1
+
       expected_instance_method_names = (module_context.instance_definition&.methods || {}).each.with_object(Set[]) do |(name, method), set|
-        if method.implemented_in == module_context.instance_definition.declaration
+        if method.implemented_in == module_context.instance_definition.type_name
           set << name
         end
       end
       expected_module_method_names = (module_context.module_definition&.methods || {}).each.with_object(Set[]) do |(name, method), set|
-        if method.implemented_in == module_context.module_definition.declaration
+        if method.implemented_in == module_context.module_definition.type_name
           set << name
         end
       end
@@ -2915,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
@@ -2948,7 +3057,7 @@ module Steep
     def to_instance_type(type, args: nil)
       args = args || case type
                      when AST::Types::Name::Class, AST::Types::Name::Module
-                       checker.factory.env.find_class(checker.factory.type_name_1(type.name)).type_params.each.map { AST::Builtin.any_type }
+                       checker.factory.env.class_decls[checker.factory.type_name_1(type.name)].type_params.each.map { AST::Builtin.any_type }
                      else
                        raise "unexpected type to to_instance_type: #{type}"
                      end

data/lib/steep/type_inference/type_env.rb

@@ -31,8 +31,8 @@ module Steep
           annotations.const_types.each do |name, type|
             env.set(const: name, type: type)
           end
-          signatures.name_to_global.each do |name, global|
-            type = signatures.absolute_type(global.type, namespace: RBS::Namespace.root) {|ty| ty.name.absolute! }
+          signatures.global_decls.each do |name, entry|
+            type = entry.decl.type
             env.set(gvar: name, type: subtyping.factory.type(type))
           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.18.0"
+  VERSION = "0.23.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/smoke/extension/a.rbs

@@ -1,9 +1,10 @@
-extension Object (X)
+
+class Object
   def try: [A] { (instance) -> A } -> A
   def f: -> Object
 end
 
-extension Kernel (X)
+module Kernel
   def new_module_method: () -> void
 end
 

data/smoke/extension/e.rbs

@@ -2,7 +2,6 @@ class NumberLike
   def to_number: -> Integer
 end
 
-extension Integer (NumberLike)
-  def `+`: (NumberLike) -> NumberLike
-         | super
+class Integer
+  overload def `+`: (NumberLike) -> NumberLike
 end