steep 0.17.0 → 0.21.0

data/lib/steep/signature/validator.rb

@@ -35,6 +35,14 @@ module Steep
         checker.factory.definition_builder
       end
 
+      def type_name_resolver
+        @type_name_resolver ||= RBS::TypeNameResolver.from_env(env)
+      end
+
+      def validator
+        @validator ||= RBS::Validator.new(env: env, resolver: type_name_resolver)
+      end
+
       def factory
         checker.factory
       end
@@ -47,57 +55,69 @@ module Steep
         validate_global
       end
 
-      def validate_one_decl(name, decl)
-        case decl
-        when Declarations::Class
-          rescue_validation_errors do
-            Steep.logger.debug "#{Location.to_string decl.location}:\tValidating class definition `#{name}`..."
-            builder.build_instance(decl.name.absolute!).each_type do |type|
-              env.validate type, namespace: RBS::Namespace.root
+      def validate_type(type)
+        Steep.logger.debug "#{Location.to_string type.location}: Validating #{type}..."
+        validator.validate_type type, context: [RBS::Namespace.root]
+      end
+
+      def validate_one_class(name)
+        rescue_validation_errors do
+          Steep.logger.debug "Validating class definition `#{name}`..."
+          Steep.logger.tagged "#{name}" do
+            builder.build_instance(name).each_type do |type|
+              validate_type type
             end
-            builder.build_singleton(decl.name.absolute!).each_type do |type|
-              env.validate type, namespace: RBS::Namespace.root
+            builder.build_singleton(name).each_type do |type|
+              validate_type type
             end
           end
-        when Declarations::Interface
-          rescue_validation_errors do
-            Steep.logger.debug "#{Location.to_string decl.location}:\tValidating interface `#{name}`..."
-            builder.build_interface(decl.name.absolute!, decl).each_type do |type|
-              env.validate type, namespace: RBS::Namespace.root
+        end
+      end
+
+      def validate_one_interface(name)
+        rescue_validation_errors do
+          Steep.logger.debug "Validating interface `#{name}`..."
+          Steep.logger.tagged "#{name}" do
+            builder.build_interface(name).each_type do |type|
+              validate_type type
             end
           end
         end
       end
 
       def validate_decl
-        env.each_decl do |name, decl|
-          validate_one_decl name, decl
+        env.class_decls.each_key do |name|
+          validate_one_class(name)
+        end
+
+        env.interface_decls.each_key do |name|
+          validate_one_interface(name)
         end
       end
 
       def validate_const
-        env.each_constant do |name, decl|
+        env.constant_decls.each do |name, entry|
           rescue_validation_errors do
-            Steep.logger.debug "#{Location.to_string decl.location}:\tValidating constant `#{name}`..."
-            env.validate(decl.type, namespace: name.namespace)
+            Steep.logger.debug "Validating constant `#{name}`..."
+            validate_type entry.decl.type
           end
         end
       end
 
       def validate_global
-        env.each_global do |name, decl|
+        env.global_decls.each do |name, entry|
           rescue_validation_errors do
-            Steep.logger.debug "#{Location.to_string decl.location}:\tValidating global `#{name}`..."
-            env.validate(decl.type, namespace: RBS::Namespace.root)
+            Steep.logger.debug "Validating global `#{name}`..."
+            validate_type entry.decl.type
           end
         end
       end
 
       def validate_alias
-        env.each_alias do |name, decl|
+        env.alias_decls.each do |name, entry|
           rescue_validation_errors do
-            Steep.logger.debug "#{Location.to_string decl.location}:\tValidating alias `#{name}`..."
-            env.validate(decl.type, namespace: name.namespace)
+            Steep.logger.debug "Validating alias `#{name}`..."
+            validate_type(entry.decl.type)
           end
         end
       end
@@ -108,10 +128,10 @@ module Steep
         @errors << Errors::InvalidTypeApplicationError.new(
           name: factory.type_name(exn.type_name),
           args: exn.args.map {|ty| factory.type(ty) },
-          params: exn.params.each.map(&:name),
+          params: exn.params,
           location: exn.location
         )
-      rescue RBS::NoTypeFoundError => exn
+      rescue RBS::NoTypeFoundError, RBS::NoSuperclassFoundError, RBS::NoMixinFoundError => exn
         @errors << Errors::UnknownTypeNameError.new(
           name: factory.type_name(exn.type_name),
           location: exn.location

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
@@ -175,30 +253,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)
@@ -283,6 +376,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 +483,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

@@ -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)
 
@@ -565,6 +639,7 @@ module Steep
               add_typing(node, type: AST::Builtin.any_type)
             else
               rhs_result = synthesize(rhs, hint: hint || context.lvar_env.declared_types[name]&.type)
+
               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,
@@ -1115,6 +1190,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 +2086,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 +2846,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
@@ -2948,7 +3049,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