steep 0.1.0.pre

data/lib/steep/parser.y

@@ -0,0 +1,311 @@
+class Steep::Parser
+
+rule
+
+target: type_METHOD method_type { result = val[1] }
+      | type_SIGNATURE signatures { result = val[1] }
+      | type_ANNOTATION annotation { result = val[1] }
+
+method_type: type_params params block_opt ARROW return_type
+               { result = Interface::MethodType.new(type_params: val[0], params: val[1], block: val[2], return_type: val[4]) }
+
+return_type: simple_type
+           | LPAREN union_seq RPAREN { result = Types::Union.new(types: val[1]) }
+
+params: { result = Interface::Params.empty }
+      | LPAREN params0 RPAREN { result = val[1] }
+      | type { result = Interface::Params.empty.with(required: [val[0]]) }
+
+params0: required_param { result = Interface::Params.empty.with(required: [val[0]]) }
+       | required_param COMMA params0 { result = val[2].with(required: [val[0]] + val[2].required) }
+       | params1 { result = val[0] }
+
+params1: optional_param { result = Interface::Params.empty.with(optional: [val[0]]) }
+       | optional_param COMMA params1 { result = val[2].with(optional: [val[0]] + val[2].optional) }
+       | params2 { result = val[0] }
+
+params2: rest_param { result = Interface::Params.empty.with(rest: val[0]) }
+       | rest_param COMMA params3 { result = val[2].with(rest: val[0]) }
+       | params3 { result = val[0] }
+
+params3: required_keyword { result = Interface::Params.empty.with(required_keywords: val[0]) }
+       | optional_keyword { result = Interface::Params.empty.with(optional_keywords: val[0]) }
+       | required_keyword COMMA params3 { result = val[2].with(required_keywords: val[2].required_keywords.merge(val[0])) }
+       | optional_keyword COMMA params3 { result = val[2].with(optional_keywords: val[2].optional_keywords.merge(val[0])) }
+       | params4 { result = val[0] }
+
+params4: { result = Interface::Params.empty }
+       | STAR2 type { result = Interface::Params.empty.with(rest_keywords: val[1]) }
+
+required_param: type { result = val[0] }
+optional_param: QUESTION type { result = val[1] }
+rest_param: STAR type { result = val[1] }
+required_keyword: keyword COLON type { result = { val[0] => val[2] } }
+optional_keyword: QUESTION keyword COLON type { result = { val[1] => val[3] } }
+
+block_opt: { result = nil }
+         | LBRACE RBRACE { result = Interface::Block.new(params: Interface::Params.empty.with(rest: Types::Any.new),
+                                                                return_type: Types::Any.new) }
+         | LBRACE block_params ARROW type RBRACE { result = Interface::Block.new(params: val[1], return_type: val[3]) }
+
+block_params: LPAREN block_params0 RPAREN { result = val[1] }
+            | { result = Interface::Params.empty.with(rest: Types::Any.new) }
+
+block_params0: required_param { result = Interface::Params.empty.with(required: [val[0]]) }
+             | required_param COMMA block_params0 { result = val[2].with(required: [val[0]] + val[2].required) }
+             | block_params1 { result = val[0] }
+
+block_params1: optional_param { result = Interface::Params.empty.with(optional: [val[0]]) }
+            | optional_param COMMA block_params1 { result = val[2].with(optional: [val[0]] + val[2].optional) }
+            | block_params2 { result = val[0] }
+
+block_params2: { result = Interface::Params.empty }
+             | rest_param { result = Interface::Params.empty.with(rest: val[0]) }
+
+simple_type: INTERFACE_NAME { result = Types::Name.interface(name: val[0]) }
+    | INTERFACE_NAME LT type_seq GT { result = Types::Name.interface(name: val[0], params: val[2]) }
+    | MODULE_NAME { result = Types::Name.instance(name: val[0])}
+    | MODULE_NAME LT type_seq GT { result = Types::Name.instance(name: val[0], params: val[2]) }
+    | CLASS_IDENT { result = Types::Name.module(name: val[0]) }
+    | ANY { result = Types::Any.new }
+    | TVAR { result = Types::Var.new(name: val[0]) }
+    | CLASS { result = Types::Class.new }
+    | MODULE { result = Types::Class.new }
+    | INSTANCE { result = Types::Instance.new }
+
+type: simple_type
+    | union_seq { result = Types::Union.new(types: val[0]) }
+
+type_seq: type { result = [val[0]] }
+        | type COMMA type_seq { result = [val[0]] + val[2] }
+
+union_seq: simple_type BAR simple_type { result = [val[0], val[2]] }
+         | simple_type BAR union_seq { result = [val[0]] + val[2] }
+
+keyword: IDENT
+       | MODULE_NAME
+       | INTERFACE_NAME
+       | ANY { result = :any }
+       | CLASS { result = :class }
+       | MODULE { result = :module }
+       | INSTANCE { result = :instance }
+
+signatures: { result = [] }
+          | interface signatures { result = [val[0]] + val[1] }
+          | class_decl signatures { result = [val[0]] + val[1] }
+          | module_decl signatures { result = [val[0]] + val[1] }
+          | extension_decl signatures { result = [val[0]] + val[1] }
+
+interface: INTERFACE interface_name type_params method_decls END { result = Signature::Interface.new(name: val[1], params: val[2], methods: val[3]) }
+class_decl: CLASS class_name type_params super_opt class_members END { result = Signature::Class.new(name: val[1], params: val[2], super_class: val[3], members: val[4] )}
+module_decl: MODULE class_name type_params self_type_opt class_members END { result = Signature::Module.new(name: val[1], params: val[2], self_type: val[3], members: val[4]) }
+extension_decl: EXTENSION class_name LPAREN class_name RPAREN class_members END { result = Signature::Extension.new(module_name: val[1], extension_name: val[3], members: val[5]) }
+
+self_type_opt: { result = nil }
+             | COLON type { result = val[1] }
+
+interface_name: INTERFACE_NAME { result = val[0] }
+
+class_name: MODULE_NAME { result = val[0] }
+
+class_members: { result = [] }
+             | class_member class_members { result = [val[0]] + val[1] }
+
+class_member: instance_method_member { result = val[0] }
+            | class_method_member { result = val[0] }
+            | class_instance_method_member { result = val[0] }
+            | include_member { result = val[0] }
+            | extend_member { result = val[0] }
+
+instance_method_member: DEF method_name COLON method_type_union { result = Signature::Members::InstanceMethod.new(name: val[1], types: val[3]) }
+class_method_member: DEF SELF DOT method_name COLON method_type_union { result = Signature::Members::ModuleMethod.new(name: val[3], types: val[5]) }
+class_instance_method_member: DEF SELFQ DOT method_name COLON method_type_union { result = Signature::Members::ModuleInstanceMethod.new(name: val[3], types: val[5]) }
+include_member: INCLUDE type { result = Signature::Members::Include.new(name: val[1]) }
+extend_member: EXTEND type { result = Signature::Members::Extend.new(name: val[1]) }
+
+super_opt: { result = nil }
+         | LTCOLON type { result = val[1] }
+
+type_params: { result = [] }
+          | LT type_param_seq GT { result = val[1] }
+
+type_param_seq: TVAR { result = [val[0]] }
+           | TVAR COMMA type_param_seq { result = [val[0]] + val[2] }
+
+method_decls: { result = {} }
+            | method_decl method_decls { result = val[1].merge(val[0]) }
+
+method_decl: DEF method_name COLON method_type_union { result = { val[1] => val[3] }}
+
+method_type_union: method_type { result = [val[0]] }
+                 | method_type BAR method_type_union { result = [val[0]] + val[2] }
+
+method_name: IDENT
+           | MODULE_NAME
+           | INTERFACE_NAME
+           | ANY { result = :any }
+           | INTERFACE { result = :interface }
+           | END { result = :end }
+           | PLUS { result = :+ }
+           | CLASS { result = :class }
+           | MODULE { result = :module }
+           | INSTANCE { result = :instance }
+           | OPERATOR
+           | METHOD_NAME
+
+annotation: AT_TYPE VAR subject COLON type { result = Annotation::VarType.new(var: val[2], type: val[4]) }
+          | AT_TYPE METHOD subject COLON method_type { result = Annotation::MethodType.new(method: val[2], type: val[4]) }
+          | AT_TYPE RETURN COLON type { result = Annotation::ReturnType.new(type: val[3]) }
+          | AT_TYPE BLOCK COLON type { result = Annotation::BlockType.new(type: val[3]) }
+          | AT_TYPE SELF COLON type { result = Annotation::SelfType.new(type: val[3]) }
+          | AT_TYPE CONST CONST_PATH COLON type { result = Annotation::ConstType.new(name: val[2], type: val[4]) }
+          | AT_TYPE CONST MODULE_NAME COLON type { result = Annotation::ConstType.new(name: val[2], type: val[4]) }
+          | AT_TYPE INSTANCE COLON type { result = Annotation::InstanceType.new(type: val[3]) }
+          | AT_TYPE MODULE COLON type { result = Annotation::ModuleType.new(type: val[3]) }
+          | AT_TYPE IVAR IVAR_NAME COLON type { result = Annotation::IvarType.new(name: val[2], type: val[4]) }
+          | AT_TYPE { raise "Invalid type annotation" }
+          | AT_IMPLEMENTS MODULE_NAME { result = Annotation::Implements.new(module_name: val[1]) }
+          | AT_DYNAMIC method_name { result = Annotation::Dynamic.new(name: val[1]) }
+
+subject: IDENT { result = val[0] }
+
+end
+
+---- inner
+
+require "strscan"
+
+attr_reader :input
+
+def initialize(type, input)
+  super()
+  @type = type
+  @input = StringScanner.new(input)
+end
+
+def self.parse_method(input)
+  new(:METHOD, input).do_parse
+end
+
+def self.parse_signature(input)
+  new(:SIGNATURE, input).do_parse
+end
+
+def self.parse_annotation_opt(input)
+  new(:ANNOTATION, input).do_parse
+rescue
+  nil
+end
+
+def next_token
+  if @type
+    type = @type
+    @type = nil
+    return [:"type_#{type}", nil]
+  end
+
+  case
+  when input.scan(/\s+/)
+    next_token
+  when input.scan(/#.*/)
+    next_token
+  when input.eos?
+    [false, false]
+  when input.scan(/->/)
+    [:ARROW, nil]
+  when input.scan(/\?/)
+    [:QUESTION, nil]
+  when input.scan(/\(/)
+    [:LPAREN, nil]
+  when input.scan(/\)/)
+    [:RPAREN, nil]
+  when input.scan(/{/)
+    [:LBRACE, nil]
+  when input.scan(/}/)
+    [:RBRACE, nil]
+  when input.scan(/,/)
+    [:COMMA, nil]
+  when input.scan(/[A-Z]\w*(::[A-Z]\w*)+/)
+    [:CONST_PATH, input.matched.to_sym]
+  when input.scan(/::[A-Z]\w*(::[A-Z]\w*)*/)
+    [:CONST_PATH, input.matched.to_sym]
+  when input.scan(/:/)
+    [:COLON, nil]
+  when input.scan(/\*\*/)
+    [:STAR2, nil]
+  when input.scan(/\*/)
+    [:STAR, nil]
+  when input.scan(/\+/)
+    [:PLUS, nil]
+  when input.scan(/\./)
+    [:DOT, nil]
+  when input.scan(/<:/)
+    [:LTCOLON, nil]
+  when input.scan(/(\[\]=)|(\[\])|===|==|\^|!=|<<|>>/)
+    [:OPERATOR, input.matched.to_sym]
+  when input.scan(/</)
+    [:LT, nil]
+  when input.scan(/>/)
+    [:GT, nil]
+  when input.scan(/any\b/)
+    [:ANY, nil]
+  when input.scan(/interface\b/)
+    [:INTERFACE, nil]
+  when input.scan(/end\b/)
+    [:END, nil]
+  when input.scan(/\|/)
+    [:BAR, nil]
+  when input.scan(/def\b/)
+    [:DEF, nil]
+  when input.scan(/@type\b/)
+    [:AT_TYPE, nil]
+  when input.scan(/@implements\b/)
+    [:AT_IMPLEMENTS, nil]
+  when input.scan(/@dynamic\b/)
+    [:AT_DYNAMIC, nil]
+  when input.scan(/const\b/)
+    [:CONST, nil]
+  when input.scan(/var\b/)
+    [:VAR, nil]
+  when input.scan(/return\b/)
+    [:RETURN, nil]
+  when input.scan(/block\b/)
+    [:BLOCK, nil]
+  when input.scan(/method\b/)
+    [:METHOD, nil]
+  when input.scan(/self\?/)
+    [:SELFQ, nil]
+  when input.scan(/self\b/)
+    [:SELF, nil]
+  when input.scan(/'\w+/)
+    [:TVAR, input.matched.gsub(/\A'/, '').to_sym]
+  when input.scan(/instance\b/)
+    [:INSTANCE, nil]
+  when input.scan(/class\b/)
+    [:CLASS, nil]
+  when input.scan(/module\b/)
+    [:MODULE, nil]
+  when input.scan(/include\b/)
+    [:INCLUDE, nil]
+  when input.scan(/extend\b/)
+    [:EXTEND, nil]
+  when input.scan(/instance\b/)
+    [:INSTANCE, nil]
+  when input.scan(/ivar\b/)
+    [:IVAR, nil]
+  when input.scan(/extension\b/)
+    [:EXTENSION, nil]
+  when input.scan(/[A-Z]\w*\.(class|module)\b/)
+    [:CLASS_IDENT, input.matched.gsub(/\.(class|module)$/, '').to_sym]
+  when input.scan(/\w+(\!|\?)/)
+    [:METHOD_NAME, input.matched.to_sym]
+  when input.scan(/[A-Z]\w*/)
+    [:MODULE_NAME, input.matched.to_sym]
+  when input.scan(/_\w+/)
+    [:INTERFACE_NAME, input.matched.to_sym]
+  when input.scan(/@[\w_]+/)
+    [:IVAR_NAME, input.matched.to_sym]
+  when input.scan(/\w+/)
+    [:IDENT, input.matched.to_sym]
+  end
+end

data/lib/steep/signature/class.rb

@@ -0,0 +1,358 @@
+module Steep
+  module Signature
+    module Members
+      class InstanceMethod
+        attr_reader :name
+        attr_reader :types
+
+        def initialize(name:, types:)
+          @name = name
+          @types = types
+        end
+
+        def ==(other)
+          other.is_a?(InstanceMethod) && other.name == name && other.types == types
+        end
+      end
+
+      class ModuleMethod
+        attr_reader :name
+        attr_reader :types
+
+        def initialize(name:, types:)
+          @name = name
+          @types = types
+        end
+
+        def ==(other)
+          other.is_a?(ModuleMethod) && other.name == name && other.types == types
+        end
+      end
+
+      class ModuleInstanceMethod
+        attr_reader :name
+        attr_reader :types
+
+        def initialize(name:, types:)
+          @name = name
+          @types = types
+        end
+
+        def ==(other)
+          other.is_a?(ModuleInstanceMethod) && other.name == name && other.types == types
+        end
+      end
+
+      class Include
+        attr_reader :name
+
+        def initialize(name:)
+          @name = name
+        end
+
+        def ==(other)
+          other.is_a?(Include) && other.name == name
+        end
+      end
+
+      class Extend
+        attr_reader :name
+
+        def initialize(name:)
+          @name = name
+        end
+
+        def ==(other)
+          other.is_a?(Extend) && other.name == name
+        end
+      end
+    end
+
+    module WithMethods
+      def instance_methods(assignability:, klass:, instance:, params:)
+        methods = super
+
+        hash = type_application_hash(params)
+
+        members.each do |member|
+          case member
+          when Members::Include
+            module_signature = assignability.lookup_included_signature(member.name)
+            merge_methods(methods, module_signature.instance_methods(assignability: assignability,
+                                                                     klass: klass,
+                                                                     instance: instance,
+                                                                     params: module_signature.type_application_hash(member.name.params)))
+          end
+        end
+
+        members.each do |member|
+          case member
+          when Members::InstanceMethod, Members::ModuleInstanceMethod
+            method_types = member.types.map {|type| type.substitute(klass: klass, instance: instance, params: hash) }
+            merge_methods(methods, member.name => Steep::Interface::Method.new(types: method_types, super_method: nil))
+          end
+        end
+
+        extensions = assignability.lookup_extensions(name)
+        extensions.each do |extension|
+          extension_methods = extension.instance_methods(assignability: assignability, klass: klass, instance: instance, params: [])
+          merge_methods(methods, extension_methods)
+        end
+
+        methods
+      end
+
+      def module_methods(assignability:, klass:, instance:, params:)
+        methods = super
+
+        members.each do |member|
+          case member
+          when Members::Include
+            module_signature = assignability.lookup_included_signature(member.name)
+            merge_methods(methods, module_signature.module_methods(assignability: assignability,
+                                                                   klass: klass,
+                                                                   instance: instance,
+                                                                   params: module_signature.type_application_hash(member.name.params)))
+          when Members::Extend
+            module_signature = assignability.lookup_included_signature(member.name)
+            merge_methods(methods, module_signature.instance_methods(assignability: assignability,
+                                                                     klass: klass,
+                                                                     instance: instance,
+                                                                     params: module_signature.type_application_hash(member.name.params)))
+          end
+        end
+
+        members.each do |member|
+          case member
+          when Members::ModuleInstanceMethod, Members::ModuleMethod
+            method_types = member.types.map {|type| type.substitute(klass: klass, instance: instance, params: {}) }
+            merge_methods(methods, member.name => Steep::Interface::Method.new(types: method_types, super_method: nil))
+          end
+        end
+
+        if self.is_a?(Class)
+          instance_methods = instance_methods(assignability: assignability, klass: klass, instance: instance, params: params)
+          new_method = if instance_methods[:initialize]
+                         types = instance_methods[:initialize].types.map do |method_type|
+                           method_type.updated(return_type: instance)
+                         end
+                         Steep::Interface::Method.new(types: types, super_method: nil)
+                       else
+                         Steep::Interface::Method.new(types: [Steep::Interface::MethodType.new(type_params: [],
+                                                                                               params: Steep::Interface::Params.empty,
+                                                                                               block: nil,
+                                                                                               return_type: instance)],
+                                                      super_method: nil)
+                       end
+          methods[:new] = new_method
+        end
+
+        methods
+      end
+
+      def merge_methods(methods, hash)
+        hash.each_key do |name|
+          method = hash[name]
+
+          methods[name] = Steep::Interface::Method.new(types: method.types,
+                                                       super_method: methods[name])
+        end
+      end
+    end
+
+    module WithMembers
+      def each_type
+        if block_given?
+          members.each do |member|
+            case member
+            when Members::InstanceMethod, Members::ModuleMethod, Members::ModuleInstanceMethod
+              member.types.each do |method_type|
+                method_type.params.each_type do |type|
+                  yield type
+                end
+                yield method_type.return_type
+                if method_type.block
+                  method_type.block.params.each_type do |type|
+                    yield type
+                  end
+                  yield method_type.block.return_type
+                end
+              end
+            when Members::Include, Members::Extend
+              yield member.name
+            else
+              raise "Unknown member: #{member.class.inspect}"
+            end
+          end
+        else
+          enum_for :each_type
+        end
+      end
+
+      def validate_mixins(assignability, interface)
+        members.each do |member|
+          if member.is_a?(Members::Include)
+            module_signature = assignability.lookup_included_signature(member.name)
+
+            if module_signature.self_type
+              self_type = module_signature.self_type.substitute(klass: Types::Name.module(name: name),
+                                                                instance: Types::Name.instance(name: name),
+                                                                params: {})
+              self_interface = assignability.resolve_interface(self_type.name, member.name.params)
+
+              unless assignability.test_interface(interface, self_interface, [])
+                assignability.errors << Errors::InvalidSelfType.new(signature: self, member: member)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    module WithParams
+      def type_application_hash(args)
+        Hash[params.zip(args)]
+      end
+    end
+
+    class Module
+      attr_reader :name
+      attr_reader :params
+      attr_reader :members
+      attr_reader :self_type
+
+      prepend WithMethods
+      include WithMembers
+      include WithParams
+
+      def initialize(name:, params:, members:, self_type:)
+        @name = name
+        @members = members
+        @params = params
+        @self_type = self_type
+      end
+
+      def ==(other)
+        other.is_a?(Module) && other.name == name && other.params == params && other.members == members && other.self_type == self_type
+      end
+
+      def instance_methods(assignability:, klass:, instance:, params:)
+        {}
+      end
+
+      def module_methods(assignability:, klass:, instance:, params:)
+        {}
+      end
+
+      def each_type
+        if block_given?
+          yield self_type if self_type
+          super do |type|
+            yield type
+          end
+        else
+          enum_for :each_type
+        end
+      end
+
+      def validate(assignability)
+        each_type do |type|
+          assignability.validate_type_presence self, type
+        end
+
+        interface = assignability.resolve_interface(TypeName::Instance.new(name: name),
+                                                    params.map {|x| Types::Var.new(name: x) })
+
+        validate_mixins(assignability, interface)
+      end
+    end
+
+    class Class
+      attr_reader :name
+      attr_reader :params
+      attr_reader :members
+      attr_reader :super_class
+
+      prepend WithMethods
+      include WithMembers
+      include WithParams
+
+      def initialize(name:, params:, members:, super_class:)
+        @name = name
+        @members = members
+        @params = params
+        @super_class = super_class
+      end
+
+      def ==(other)
+        other.is_a?(Class) && other.name == name && other.params == params && other.members == members && other.super_class == super_class
+      end
+
+      def instance_methods(assignability:, klass:, instance:, params:)
+        if self.name == :BasicObject
+          {}
+        else
+          super_class = self.super_class || Types::Name.instance(name: :Object)
+          signature = assignability.lookup_super_class_signature(super_class)
+
+          hash = type_application_hash(params)
+          super_class_params = super_class.params.map do |type|
+            type.substitute(klass: klass, instance: instance, params: hash)
+          end
+
+          signature.instance_methods(assignability: assignability, klass: klass, instance: instance, params: super_class_params)
+        end
+      end
+
+      def module_methods(assignability:, klass:, instance:, params:)
+        signature = assignability.lookup_class_signature(Types::Name.instance(name: :Class))
+        class_methods = signature.instance_methods(assignability: assignability,
+                                                   klass: klass,
+                                                   instance: instance,
+                                                   params: [instance])
+        if self.name == :BasicObject
+          class_methods
+        else
+          super_class = self.super_class || Types::Name.instance(name: :Object)
+          signature = assignability.lookup_super_class_signature(super_class)
+
+          hash = type_application_hash(params)
+          super_class_params = super_class.params.map do |type|
+            type.substitute(klass: klass, instance: instance, params: hash)
+          end
+
+          class_methods.merge!(signature.module_methods(assignability: assignability, klass: klass, instance: instance, params: super_class_params))
+        end
+      end
+
+      def each_type
+        if block_given?
+          yield super_class if super_class
+          super do |type|
+            yield type
+          end
+        else
+          enum_for :each_type
+        end
+      end
+
+      def validate(assignability)
+        each_type do |type|
+          assignability.validate_type_presence self, type
+        end
+
+        interface = assignability.resolve_interface(TypeName::Instance.new(name: name),
+                                                    params.map {|x| Types::Var.new(name: x) })
+
+        interface.methods.each_key do |method_name|
+          method = interface.methods[method_name]
+          if method.super_method
+            assignability.validate_method_compatibility(self, method_name, method)
+          end
+        end
+
+        validate_mixins(assignability, interface)
+      end
+    end
+  end
+end