steep 0.1.0.pre2 → 0.1.0

data/lib/steep/interface/builder.rb

@@ -0,0 +1,470 @@
+module Steep
+  module Interface
+    class Builder
+      class RecursiveDefinitionError < StandardError
+        attr_reader :chain
+
+        def initialize(type_name)
+          @chain = [type_name].compact
+          super "Recursive inheritance/mixin"
+        end
+
+        def to_s
+          super + " #{chain.join(" ~> ")}"
+        end
+      end
+
+      attr_reader :signatures
+      attr_reader :cache
+
+      def initialize(signatures:)
+        @cache = {}
+        @signatures = signatures
+      end
+
+      def absolute_type_name(type_name, current:)
+        if current
+          begin
+            case type_name
+            when TypeName::Instance
+              type_name.map_module_name {|name|
+                signatures.find_class_or_module(name, current_module: current).name
+              }
+            when TypeName::Module
+              type_name.map_module_name {|name|
+                signatures.find_module(name, current_module: current).name
+              }
+            when TypeName::Class
+              type_name.map_module_name {|name|
+                signatures.find_class(name, current_module: current).name
+              }
+            else
+              type_name
+            end
+          rescue => exn
+            STDERR.puts "Cannot find absolute type name: #{exn.inspect}"
+            type_name
+          end
+        else
+          type_name.map_module_name(&:absolute!)
+        end
+      end
+
+      def absolute_type(type, current:)
+        case type
+        when AST::Types::Name
+          AST::Types::Name.new(
+            name: absolute_type_name(type.name, current: current),
+            args: type.args.map {|ty| absolute_type(ty, current: current) },
+            location: type.location
+          )
+        when AST::Types::Union
+          AST::Types::Union.build(
+            types: type.types.map {|ty| absolute_type(ty, current: current) },
+            location: type.location
+          )
+        when AST::Types::Intersection
+          AST::Types::Intersection.build(
+            types: type.types.map {|ty| absolute_type(ty, current: current) },
+            location: type.location
+          )
+        else
+          type
+        end
+      end
+
+      def build(type_name, current: nil, with_initialize: false)
+        type_name = absolute_type_name(type_name, current: current)
+        cache_key = [type_name, with_initialize]
+        cached = cache[cache_key]
+
+        case cached
+        when nil
+          begin
+            cache[cache_key] = type_name
+
+            interface = case type_name
+                        when TypeName::Instance
+                          instance_to_interface(signatures.find_class_or_module(type_name.name), with_initialize: with_initialize)
+                        when TypeName::Module
+                          module_to_interface(signatures.find_module(type_name.name))
+                        when TypeName::Class
+                          class_to_interface(signatures.find_class_or_module(type_name.name),
+                                             constructor: type_name.constructor)
+                        when TypeName::Interface
+                          interface_to_interface(type_name.name,
+                                                 signatures.find_interface(type_name.name))
+                        else
+                          raise "Unexpected type_name: #{type_name.inspect}"
+                        end
+
+            cache[cache_key]= interface
+          rescue RecursiveDefinitionError => exn
+            exn.chain.unshift(type_name)
+            raise
+          end
+        when TypeName::Base
+          raise RecursiveDefinitionError, type_name
+        else
+          cached
+        end
+      end
+
+      def merge_mixin(type_name, args, methods:, ivars:, supers:, current:)
+        mixed = block_given? ? yield : build(type_name, current: current)
+
+        supers.push(*mixed.supers)
+        instantiated = mixed.instantiate(
+          type: AST::Types::Self.new,
+          args: args,
+          instance_type: AST::Types::Instance.new,
+          module_type: AST::Types::Class.new
+        )
+
+        methods.merge!(instantiated.methods) do |_, super_method, new_method|
+          if super_method.include_in_chain?(new_method)
+            super_method
+          else
+            new_method.with_super(super_method)
+          end
+        end
+
+        merge_ivars ivars, instantiated.ivars
+      end
+
+      def add_method(type_name, method, methods:)
+        super_method = methods[method.name]
+        new_method = Method.new(
+          type_name: type_name,
+          name: method.name,
+          types: method.types.map do |method_type|
+            method_type_to_method_type(method_type, current: type_name.name)
+          end,
+          super_method: super_method,
+          attributes: method.attributes
+        )
+
+        methods[method.name] = if super_method&.include_in_chain?(new_method)
+                                 super_method
+                               else
+                                 new_method
+                               end
+      end
+
+      def class_to_interface(sig, constructor:)
+        type_name = TypeName::Class.new(name: sig.name, constructor: constructor)
+
+        supers = []
+        methods = {
+          new: Method.new(
+            type_name: TypeName::Class.new(name: "Builtin", constructor: true),
+            name: :new,
+            types: [
+              MethodType.new(type_params: [],
+                             params: Params.empty,
+                             block: nil,
+                             return_type: AST::Types::Instance.new,
+                             location: nil
+              )
+            ],
+            super_method: nil,
+            attributes: []
+          )
+        }
+
+        klass = build(TypeName::Instance.new(name: ModuleName.parse("::Class")))
+        instantiated = klass.instantiate(
+          type: AST::Types::Self.new,
+          args: [AST::Types::Instance.new],
+          instance_type: AST::Types::Instance.new,
+          module_type: AST::Types::Class.new
+        )
+        methods.merge!(instantiated.methods)
+
+        unless sig.name == ModuleName.parse("::BasicObject")
+          super_class_name = sig.super_class&.name&.absolute! || ModuleName.parse("::Object")
+          merge_mixin(TypeName::Class.new(name: super_class_name, constructor: constructor),
+                      [],
+                      methods: methods,
+                      ivars: {},
+                      supers: supers,
+                      current: sig.name)
+        end
+
+        sig.members.each do |member|
+          case member
+          when AST::Signature::Members::Include
+            merge_mixin(TypeName::Module.new(name: member.name),
+                        [],
+                        methods: methods,
+                        supers: supers,
+                        ivars: {},
+                        current: sig.name)
+          when AST::Signature::Members::Extend
+            merge_mixin(TypeName::Instance.new(name: member.name),
+                        member.args.map {|type| absolute_type(type, current: sig.name) },
+                        methods: methods,
+                        ivars: {},
+                        supers: supers,
+                        current: sig.name)
+          end
+        end
+
+        sig.members.each do |member|
+          case member
+          when AST::Signature::Members::Method
+            case
+            when member.module_method?
+              add_method(type_name, member, methods: methods)
+            when member.instance_method? && member.name == :initialize
+              if constructor
+                methods[:new] = Method.new(
+                  type_name: type_name,
+                  name: :new,
+                  types: member.types.map do |method_type_sig|
+                    method_type = method_type_to_method_type(method_type_sig, current: sig.name).with(return_type: AST::Types::Instance.new)
+                    args = (sig.params&.variables || []) + method_type.type_params
+
+                    method_type.with(
+                      type_params: args,
+                      return_type: AST::Types::Instance.new
+                    )
+                  end,
+                  super_method: nil,
+                  attributes: []
+                )
+              end
+            end
+          end
+        end
+
+        unless constructor
+          methods.delete(:new)
+        end
+
+        Abstract.new(
+          name: type_name,
+          params: [],
+          methods: methods,
+          supers: supers,
+          ivar_chains: {}
+        )
+      end
+
+      def module_to_interface(sig)
+        type_name = TypeName::Module.new(name: sig.name)
+
+        supers = [sig.self_type].compact.map {|type| absolute_type(type, current: nil) }
+        methods = {}
+
+        module_instance = build(TypeName::Instance.new(name: ModuleName.parse("::Module")))
+        instantiated = module_instance.instantiate(
+          type: AST::Types::Self.new,
+          args: [],
+          instance_type: AST::Types::Instance.new,
+          module_type: AST::Types::Class.new
+        )
+        methods.merge!(instantiated.methods)
+
+        sig.members.each do |member|
+          case member
+          when AST::Signature::Members::Include
+            merge_mixin(TypeName::Module.new(name: member.name),
+                        member.args.map {|type| absolute_type(type, current: sig.name) },
+                        methods: methods,
+                        ivars: {},
+                        supers: supers,
+                        current: sig.name)
+          when AST::Signature::Members::Extend
+            merge_mixin(TypeName::Instance.new(name: member.name),
+                        member.args.map {|type| absolute_type(type, current: sig.name) },
+                        methods: methods,
+                        ivars: {},
+                        supers: supers,
+                        current: sig.name)
+          end
+        end
+
+        sig.members.each do |member|
+          case member
+          when AST::Signature::Members::Method
+            if member.module_method?
+              add_method(type_name, member, methods: methods)
+            end
+          end
+        end
+
+        Abstract.new(
+          name: type_name,
+          params: [],
+          methods: methods,
+          supers: supers,
+          ivar_chains: {}
+        )
+      end
+
+      def instance_to_interface(sig, with_initialize:)
+        type_name = TypeName::Instance.new(name: sig.name)
+
+        params = sig.params&.variables || []
+        supers = []
+        methods = {}
+        ivar_chains = {}
+
+        if sig.is_a?(AST::Signature::Class)
+          unless sig.name == ModuleName.parse("::BasicObject")
+            super_class_name = sig.super_class&.name || ModuleName.parse("::Object")
+            super_class_interface = build(TypeName::Instance.new(name: super_class_name), current: nil)
+
+            supers.push(*super_class_interface.supers)
+            instantiated = super_class_interface.instantiate(
+              type: AST::Types::Self.new,
+              args: (sig.super_class&.args || []).map {|type| absolute_type(type, current: nil) },
+              instance_type: AST::Types::Instance.new,
+              module_type: AST::Types::Class.new
+            )
+
+            methods.merge!(instantiated.methods)
+            merge_ivars(ivar_chains, instantiated.ivars)
+          end
+        end
+
+        if sig.is_a?(AST::Signature::Module)
+          if sig.self_type
+            supers << sig.self_type
+          end
+        end
+
+        sig.members.each do |member|
+          case member
+          when AST::Signature::Members::Include
+            merge_mixin(TypeName::Instance.new(name: member.name),
+                        member.args.map {|type| absolute_type(type, current: sig.name) },
+                        methods: methods,
+                        ivars: ivar_chains,
+                        supers: supers,
+                        current: sig.name)
+          end
+        end
+
+        sig.members.each do |member|
+          case member
+          when AST::Signature::Members::Method
+            if member.instance_method?
+              if with_initialize || member.name != :initialize
+                add_method(type_name, member, methods: methods)
+              end
+            end
+          when AST::Signature::Members::Ivar
+            merge_ivars(ivar_chains,
+                        { member.name => absolute_type(member.type, current: sig.name) })
+          end
+        end
+
+        signatures.find_extensions(sig.name).each do |ext|
+          ext.members.each do |member|
+            case member
+            when AST::Signature::Members::Method
+              if member.instance_method?
+                add_method(type_name, member, methods: methods)
+              end
+            end
+          end
+        end
+
+        Abstract.new(
+          name: type_name,
+          params: params,
+          methods: methods,
+          supers: supers,
+          ivar_chains: ivar_chains
+        )
+      end
+
+      def merge_ivars(dest, new_vars)
+        new_vars.each do |name, new_type|
+          dest[name] = IvarChain.new(type: new_type, parent: dest[name])
+        end
+      end
+
+      def interface_to_interface(_, sig)
+        type_name = TypeName::Interface.new(name: sig.name)
+
+        variables = sig.params&.variables || []
+        methods = sig.methods.each.with_object({}) do |method, methods|
+          methods[method.name] = Method.new(
+            type_name: type_name,
+            name: method.name,
+            types: method.types.map do |method_type|
+              method_type_to_method_type(method_type, current: nil)
+            end,
+            super_method: nil,
+            attributes: []
+          )
+        end
+
+        Abstract.new(
+          name: type_name,
+          params: variables,
+          methods: methods,
+          supers: [],
+          ivar_chains: {}
+        )
+      end
+
+      def method_type_to_method_type(method_type, current:)
+        type_params = method_type.type_params&.variables || []
+        params = params_to_params(method_type.params, current: current)
+        block = method_type.block && Block.new(
+          params: params_to_params(method_type.block.params, current: current),
+          return_type: absolute_type(method_type.block.return_type, current: current)
+        )
+
+        MethodType.new(
+          type_params: type_params,
+          return_type: absolute_type(method_type.return_type, current: current),
+          block: block,
+          params: params,
+          location: method_type.location
+        )
+      end
+
+      def params_to_params(params, current:)
+        required = []
+        optional = []
+        rest = nil
+        required_keywords = {}
+        optional_keywords = {}
+        rest_keywords = nil
+
+        while params
+          case params
+          when AST::MethodType::Params::Required
+            required << absolute_type(params.type, current: current)
+          when AST::MethodType::Params::Optional
+            optional << absolute_type(params.type, current: current)
+          when AST::MethodType::Params::Rest
+            rest = absolute_type(params.type, current: current)
+          when AST::MethodType::Params::RequiredKeyword
+            required_keywords[params.name] = absolute_type(params.type, current: current)
+          when AST::MethodType::Params::OptionalKeyword
+            optional_keywords[params.name] = absolute_type(params.type, current: current)
+          when AST::MethodType::Params::RestKeyword
+            rest_keywords = absolute_type(params.type, current: current)
+            break
+          end
+          params = params.next_params
+        end
+
+        Params.new(
+          required: required,
+          optional: optional,
+          rest: rest,
+          required_keywords: required_keywords,
+          optional_keywords: optional_keywords,
+          rest_keywords: rest_keywords
+        )
+      end
+    end
+  end
+end

data/lib/steep/interface/instantiated.rb

@@ -0,0 +1,126 @@
+module Steep
+  module Interface
+    class Instantiated
+      attr_reader :type
+      attr_reader :methods
+      attr_reader :ivar_chains
+
+      def initialize(type:, methods:, ivar_chains:)
+        @type = type
+        @methods = methods
+        @ivar_chains = ivar_chains
+      end
+
+      def ivars
+        @ivars ||= ivar_chains.transform_values(&:type)
+      end
+
+      def ==(other)
+        other.is_a?(self.class) && other.type == type && other.params == params && other.methods == methods && other.ivars == ivars
+      end
+
+      class InvalidMethodOverrideError < StandardError
+        attr_reader :type
+        attr_reader :current_method
+        attr_reader :super_method
+        attr_reader :result
+
+        def initialize(type:, current_method:, super_method:, result:)
+          @type = type
+          @current_method = current_method
+          @super_method = super_method
+          @result = result
+
+          super "Invalid override of `#{current_method.name}` in #{type}: definition in #{current_method.type_name} is not compatible with its super (#{super_method.type_name})"
+        end
+      end
+
+      class InvalidIvarOverrideError < StandardError
+        attr_reader :type
+        attr_reader :ivar_name
+        attr_reader :current_ivar_type
+        attr_reader :super_ivar_type
+
+        def initialize(type:, ivar_name:, current_ivar_type:, super_ivar_type:)
+          @type = type
+          @ivar_name = ivar_name
+          @current_ivar_type = current_ivar_type
+          @super_ivar_type = super_ivar_type
+
+          super "Invalid override of `#{ivar_name}` in #{type}: #{current_ivar_type} is not compatible with #{super_ivar_type}"
+        end
+      end
+
+      def validate(check)
+        methods.each do |_, method|
+          validate_method(check, method)
+        end
+
+        ivar_chains.each do |name, chain|
+          validate_chain(check, name, chain)
+        end
+      end
+
+      def validate_chain(check, name, chain)
+        return unless chain.parent
+
+        this_type = chain.type
+        super_type = chain.parent.type
+
+        case
+        when this_type.is_a?(AST::Types::Any) && super_type.is_a?(AST::Types::Any)
+          # ok
+        else
+          relation = Subtyping::Relation.new(sub_type: this_type, super_type: super_type)
+
+          result1 = check.check(relation, constraints: Subtyping::Constraints.empty)
+          result2 = check.check(relation.flip, constraints: Subtyping::Constraints.empty)
+
+          if result1.failure? || result2.failure? || this_type.is_a?(AST::Types::Any) || super_type.is_a?(AST::Types::Any)
+            raise InvalidIvarOverrideError.new(type: self.type, ivar_name: name, current_ivar_type: this_type, super_ivar_type: super_type)
+          end
+        end
+
+        validate_chain(check, name, chain.parent)
+      end
+
+      def validate_method(check, method)
+        if method.super_method
+          result = check.check_method(method.name,
+                                      method,
+                                      method.super_method,
+                                      assumption: Set.new,
+                                      trace: Subtyping::Trace.new,
+                                      constraints: Subtyping::Constraints.empty)
+
+          if result.success?
+            validate_method(check, method.super_method)
+          else
+            raise InvalidMethodOverrideError.new(type: type,
+                                                 current_method: method,
+                                                 super_method: method.super_method,
+                                                 result: result)
+          end
+        end
+      end
+
+      def select_method_type(&block)
+        self.class.new(
+          type: type,
+          methods: methods.each.with_object({}) do |(name, method), methods|
+            methods[name] = Method.new(
+              type_name: method.type_name,
+              name: method.name,
+              types: method.types.select(&block),
+              super_method: method.super_method,
+              attributes: method.attributes,
+            )
+          end.reject do |_, method|
+            method.types.empty?
+          end,
+          ivar_chains: ivar_chains
+        )
+      end
+    end
+  end
+end

data/lib/steep/interface/ivar_chain.rb

@@ -0,0 +1,26 @@
+module Steep
+  module Interface
+    class IvarChain
+      attr_reader :type
+      attr_reader :parent
+
+      def initialize(type:, parent: nil)
+        @type = type
+        @parent = parent
+      end
+
+      def ==(other)
+        other.is_a?(IvarChain) &&
+          type == type &&
+          parent == parent
+      end
+
+      def subst(s)
+        self.class.new(
+          type: type.subst(s),
+          parent: parent&.subst(s)
+        )
+      end
+    end
+  end
+end

data/lib/steep/interface/method.rb

@@ -0,0 +1,60 @@
+module Steep
+  module Interface
+    class Method
+      attr_reader :type_name
+      attr_reader :name
+      attr_reader :super_method
+      attr_reader :types
+      attr_reader :attributes
+
+      def initialize(type_name:, name:, types:, super_method:, attributes:)
+        @type_name = type_name
+        @name = name
+        @types = types
+        @super_method = super_method
+        @attributes = attributes
+      end
+
+      def ==(other)
+        other.is_a?(Method) &&
+          other.type_name == type_name &&
+          other.name == name &&
+          other.types == types &&
+          other.super_method == super_method &&
+          other.attributes == attributes
+      end
+
+      def closed?
+        types.all?(&:closed?)
+      end
+
+      def subst(s)
+        self.class.new(
+          type_name: type_name,
+          name: name,
+          types: types.map {|type| type.subst(s) },
+          super_method: super_method&.subst(s),
+          attributes: attributes
+        )
+      end
+
+      def with_super(super_method)
+        self.class.new(
+          type_name: type_name,
+          name: name,
+          types: types,
+          super_method: super_method,
+          attributes: attributes
+        )
+      end
+
+      def include_in_chain?(method)
+        (method.type_name == type_name &&
+          method.name == name &&
+          method.types == types &&
+          method.attributes == attributes) ||
+          super_method&.include_in_chain?(method)
+      end
+    end
+  end
+end