steep 0.1.0.pre → 0.1.0.pre2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 91398a985c422d844373a28dadd59f8e55b73e8f
-  data.tar.gz: bdf3272c32938f7b5e762cfffce099b26630115b
+  metadata.gz: 74822cb390656501c900a6a8c1cb9fbe60c4dc4c
+  data.tar.gz: 1bd94c67e5339288af5052ecdbfaa553ae151aee
 SHA512:
-  metadata.gz: 1345b14455a625814b4beafcab5ad3327f47b2dd0be200a5ecbc73157c83ab8074b6069a80acffb8fe563987c042f133820c33c07d1a7baa4039d29e35438735
-  data.tar.gz: 455b3c6502ef94579bb859f12cbaca314285f426cf1a0b3cf5a9cad0c1533664738f8674b20ebde46ef8b8fcaa443ace1ece38f57922e5427465771afbf98f77
+  metadata.gz: 8102354b9e6ca837f22439b9b721e6e7ec67bc4b2e49de5db26a59d7167d5399ba04183b2e88d49afa3bf20cb88e5ed94ce6363a22caa0e7b5ec88ffd9963dfd
+  data.tar.gz: ea2304c8ee9850fc540c0b656daf4b100c97de914a4a124e332ef53117b0aa137c6f05a62402227a4601d51a74b1b5298c64980a6e3be9af300f480e41045e0a

data/README.md

@@ -2,86 +2,107 @@
 
 ## Installation
 
-Add this line to your application's Gemfile:
+Install via RubyGems.
 
-```ruby
-gem 'steep'
-```
-
-And then execute:
+    $ gem install steep --pre
 
-    $ bundle
+Note that Steep is not released yet (pre-released). Add `--pre` for `gem install`.
 
-Or install it yourself as:
+### Requirements
 
-    $ gem install steep
+Steep requires Ruby 2.4.
 
 ## Usage
 
-Run `steep check` command in project dir.
+Steep does not infer types from Ruby programs, but requires declaring types and writing annotations.
+You have to go on the following three steps.
 
-```
-$ steep check
-$ steep check lib
-```
+### 1. Declare Signatures
 
-It loads signatures from the global registry and `sig` dir in current dir.
-If you want to load signuatres from dir different from `sig`, pass `-I` parameter.
+Declare signatures in `.rbi` files.
 
 ```
-$ steep check -I signauture -I sig .
-```
+interface _Foo {
+  def do_something: (String) -> any
+}
 
-Note that when `-I` option is given, `steep` does not load signatures from `sig` dir.
+module Fooable : _Foo {
+  def foo: (Array<String>) { (String) -> String } -> any
+}
 
-## Type Annotations
+class SuperFoo {
+  include Fooable
 
-You have to write type annotations in your Ruby program.
+  def name: -> String
+  def do_something: (String) -> any
+  def bar: (?Symbol, size: Integer) -> Symbol
+}
+```
 
-```rb
-# @import ActiveRecord.Try
+### 2. Annotate Ruby Code
 
+Write annotations to your Ruby code.
+
+```rb
 class Foo
-  # @class Foo<A> extends Object
-  
-  # @attribute results: (readonly) Array<A>
-  attr_reader :results
-  
-  # @type initialize: () -> _
-  def initialize()
-    @results = []
+  # @implements SuperFoo
+  # @type const Helper: FooHelper
+
+  # @dynamic name
+  attr_reader :name
+
+  def do_something(string)
+    # ...
   end
-  
-  # @type plus: (Addable<X, A>, X) -> A
-  def plus(x, y)
-    (x + y).try do |a|
-      results << a
-      a
-    end
+
+  def bar(symbol = :default, size:)
+    Helper.run_bar(symbol, size: size)
   end
 end
 ```
 
-## Signature
-
-Steep does not allow types to be constructed from Ruby programs.
-You have to write down signatures by yourself.
+### 3. Type Check
 
-### Signature Scaffolding
-
-Steep allows generate a *scaffold* from Ruby programs.
+Run `steep check` command to type check.
 
 ```
-$ steep scaffold lib/**/*.rb
+$ steep check lib/foo.rb
+foo.rb:41:18: NoMethodError: type=FooHelper, method=run_bar
+foo.rb:42:24: NoMethodError: type=String, method==~
 ```
 
-The generated scaffold includes:
+## Commandline
+
+`steep check` is the command to run type checking.
+
+### Signature Directory
+
+Use `-I` option to specify signature file or signature directory.
+
+    $ steep check -I my-types.rbi test.rb
+
+If you don't specify `-I` option, it assumes `sig` directory.
+
+### Detecting Fallback
+
+When Steep finds a node which cannot be typed, it assumes the type of the node is *any*.
+*any* type does not raise any type error so that fallback to *any* may hide some type errors.
+
+Using `--fallback-any-is-error` option prints the fallbacks.
+
+    $ steep check --fallback-any-is-error test.rb
+
+### Dump All Types
+
+When you are debugging, printing all types of all node in the source code may help.
+
+Use `--dump-all-types` for that.
 
-* Signature definition for each class/module defined in the given program
-* Method definition stub for each method
+    $ steep check --dump-all-types test.rb
 
-The scaffold may be a good starting point for writing signatures.
+## Examples
 
+You can find examples in `smoke` directory.
 
 ## Development
 
@@ -91,5 +112,5 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/steep.
+Bug reports and pull requests are welcome on GitHub at https://github.com/soutaro/steep.
 

data/bin/smoke_runner.rb

@@ -93,9 +93,13 @@ ARGV.each do |arg|
 
   unless lines.empty?
     lines.each do |line|
-      puts Rainbow("  🤦‍♀️ Unexpected error found: #{line}").red
+      if line =~ /:\d+:\d+:/
+        puts Rainbow("  🤦‍♀️ Unexpected error found: #{line}").red
+        failed = true
+      else
+        puts Rainbow("  🤦 Unexpected error found, but ignored: #{line}").yellow
+      end
     end
-    failed = true
   end
 end
 

data/lib/steep/cli.rb

@@ -56,14 +56,14 @@ module Steep
         opts.on("--fallback-any-is-error") { fallback_any_is_error = true }
       end.parse!(argv)
 
-      unless no_builtin
-        signature_dirs.unshift Pathname(__dir__).join("../../stdlib").realpath
-      end
-
       if signature_dirs.empty?
         signature_dirs << Pathname("sig")
       end
 
+      unless no_builtin
+        signature_dirs.unshift Pathname(__dir__).join("../../stdlib").realpath
+      end
+
       source_paths = argv.map {|path| Pathname(path) }
       if source_paths.empty?
         source_paths << Pathname(".")

data/lib/steep/drivers/check.rb

@@ -34,6 +34,10 @@ module Steep
           end
         end
 
+        assignability.errors.each do |error|
+          error.puts(stdout)
+        end
+
         sources = []
         each_ruby_source do |source|
           sources << source

data/lib/steep/interface.rb

@@ -232,14 +232,19 @@ module Steep
     class Method
       attr_reader :super_method
       attr_reader :types
+      attr_reader :attributes
 
-      def initialize(types:, super_method:)
+      def initialize(types:, super_method:, attributes:)
         @types = types
         @super_method = super_method
+        @attributes = attributes
       end
 
       def ==(other)
-        other.is_a?(Method) && other.types == types && other.super_method == super_method
+        other.is_a?(Method) &&
+          other.types == types &&
+          other.super_method == super_method &&
+          other.attributes == attributes
       end
 
       def closed?
@@ -262,10 +267,12 @@ module Steep
     end
 
     attr_reader :name
+    attr_reader :params
     attr_reader :methods
 
-    def initialize(name:, methods:)
+    def initialize(name:, params:, methods:)
       @name = name
+      @params = params
       @methods = methods
     end
 
@@ -274,7 +281,7 @@ module Steep
     end
 
     def ==(other)
-      other.is_a?(self.class) && other.name == name && other.methods == methods
+      other.is_a?(self.class) && other.name == name && other.params == params && other.methods == methods
     end
   end
 end

data/lib/steep/parser.y

@@ -66,13 +66,17 @@ 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]) }
+    | CLASS_IDENT constructor { result = Types::Name.module(name: val[0], constructor: val[1]) }
     | 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 }
 
+constructor: { result = nil }
+           | CONSTRUCTOR
+           | NOCONSTRUCTOR
+
 type: simple_type
     | union_seq { result = Types::Union.new(types: val[0]) }
 
@@ -89,6 +93,8 @@ keyword: IDENT
        | CLASS { result = :class }
        | MODULE { result = :module }
        | INSTANCE { result = :instance }
+       | BLOCK { result = :block }
+       | INCLUDE { result = :include }
 
 signatures: { result = [] }
           | interface signatures { result = [val[0]] + val[1] }
@@ -117,12 +123,15 @@ class_member: 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]) }
+instance_method_member: DEF constructor_method method_name COLON method_type_union { result = Signature::Members::InstanceMethod.new(name: val[2], types: val[4], constructor: val[1]) }
+class_method_member: DEF constructor_method SELF DOT method_name COLON method_type_union { result = Signature::Members::ModuleMethod.new(name: val[4], types: val[6], constructor: val[1]) }
+class_instance_method_member: DEF constructor_method SELFQ DOT method_name COLON method_type_union { result = Signature::Members::ModuleInstanceMethod.new(name: val[4], types: val[6], constructor: val[1]) }
 include_member: INCLUDE type { result = Signature::Members::Include.new(name: val[1]) }
 extend_member: EXTEND type { result = Signature::Members::Extend.new(name: val[1]) }
 
+constructor_method: { result = false }
+                  | LPAREN CONSTRUCTOR RPAREN { result = true }
+
 super_opt: { result = nil }
          | LTCOLON type { result = val[1] }
 
@@ -152,6 +161,11 @@ method_name: IDENT
            | INSTANCE { result = :instance }
            | OPERATOR
            | METHOD_NAME
+           | BLOCK { result = :block }
+           | INCLUDE { result = :include }
+           | CONSTRUCTOR { result = :constructor }
+           | NOCONSTRUCTOR { result = :noconstructor }
+           | GT GT { result = :>> }
 
 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]) }
@@ -241,7 +255,7 @@ def next_token
     [:DOT, nil]
   when input.scan(/<:/)
     [:LTCOLON, nil]
-  when input.scan(/(\[\]=)|(\[\])|===|==|\^|!=|<<|>>/)
+  when input.scan(/(\[\]=)|(\[\])|===|==|\^|!=|<</)
     [:OPERATOR, input.matched.to_sym]
   when input.scan(/</)
     [:LT, nil]
@@ -295,6 +309,10 @@ def next_token
     [:IVAR, nil]
   when input.scan(/extension\b/)
     [:EXTENSION, nil]
+  when input.scan(/constructor\b/)
+    [:CONSTRUCTOR, true]
+  when input.scan(/noconstructor\b/)
+    [:NOCONSTRUCTOR, false]
   when input.scan(/[A-Z]\w*\.(class|module)\b/)
     [:CLASS_IDENT, input.matched.gsub(/\.(class|module)$/, '').to_sym]
   when input.scan(/\w+(\!|\?)/)

data/lib/steep/signature/class.rb

@@ -2,48 +2,70 @@ module Steep
   module Signature
     module Members
       class InstanceMethod
+        # @implements Steep__SignatureMember__Method
+
+        # @dynamic name
         attr_reader :name
+        # @dynamic types
         attr_reader :types
 
-        def initialize(name:, types:)
+        attr_reader :constructor
+
+        def initialize(name:, types:, constructor:)
           @name = name
           @types = types
+          @constructor = constructor
         end
 
         def ==(other)
-          other.is_a?(InstanceMethod) && other.name == name && other.types == types
+          other.is_a?(self.class) && other.name == name && other.types == types && other.constructor == constructor
         end
       end
 
       class ModuleMethod
+        # @implements Steep__SignatureMember__Method
+
+        # @dynamic name
         attr_reader :name
+        # @dynamic types
         attr_reader :types
+        attr_reader :constructor
 
-        def initialize(name:, types:)
+        def initialize(name:, types:, constructor:)
           @name = name
           @types = types
+          @constructor = constructor
         end
 
         def ==(other)
-          other.is_a?(ModuleMethod) && other.name == name && other.types == types
+          other.is_a?(self.class) && other.name == name && other.types == types && other.constructor == constructor
         end
       end
 
       class ModuleInstanceMethod
+        # @implements Steep__SignatureMember__Method
+
+        # @dynamic name
         attr_reader :name
+        # @dynamic types
         attr_reader :types
+        attr_reader :constructor
 
-        def initialize(name:, types:)
+        def initialize(name:, types:, constructor:)
           @name = name
           @types = types
+          @constructor = constructor
         end
 
         def ==(other)
-          other.is_a?(ModuleInstanceMethod) && other.name == name && other.types == types
+          other.is_a?(self.class) && other.name == name && other.types == types && other.constructor == constructor
         end
       end
 
       class Include
+        # @implements Steep__SignatureMember__Include
+
+        # @dynamic name
         attr_reader :name
 
         def initialize(name:)
@@ -56,6 +78,9 @@ module Steep
       end
 
       class Extend
+        # @implements Steep__SignatureMember__Extend
+
+        # @dynamic name
         attr_reader :name
 
         def initialize(name:)
@@ -69,6 +94,8 @@ module Steep
     end
 
     module WithMethods
+      # @implements Steep__Signature__WithMethods
+
       def instance_methods(assignability:, klass:, instance:, params:)
         methods = super
 
@@ -77,19 +104,32 @@ module Steep
         members.each do |member|
           case member
           when Members::Include
-            module_signature = assignability.lookup_included_signature(member.name)
+            # @type var include_member: Steep__SignatureMember__Include
+            include_member = member
+            module_signature = assignability.lookup_included_signature(include_member.name)
             merge_methods(methods, module_signature.instance_methods(assignability: assignability,
                                                                      klass: klass,
                                                                      instance: instance,
-                                                                     params: module_signature.type_application_hash(member.name.params)))
+                                                                     params: module_signature.type_application_hash(include_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))
+            # @type var method_member: Steep__SignatureMember__Method
+            method_member = member
+            method_types = method_member.types.map {|type| type.substitute(klass: klass, instance: instance, params: hash) }
+
+            attributes = [].tap do |attrs|
+              attrs.push(:constructor) if method_member.constructor
+            end
+
+            merge_methods(methods,
+                          method_member.name => Steep::Interface::Method.new(types: method_types,
+                                                                             super_method: nil,
+                                                                             attributes: attributes))
           end
         end
 
@@ -102,7 +142,7 @@ module Steep
         methods
       end
 
-      def module_methods(assignability:, klass:, instance:, params:)
+      def module_methods(assignability:, klass:, instance:, params:, constructor:)
         methods = super
 
         members.each do |member|
@@ -112,7 +152,8 @@ module Steep
             merge_methods(methods, module_signature.module_methods(assignability: assignability,
                                                                    klass: klass,
                                                                    instance: instance,
-                                                                   params: module_signature.type_application_hash(member.name.params)))
+                                                                   params: module_signature.type_application_hash(member.name.params),
+                                                                   constructor: constructor))
           when Members::Extend
             module_signature = assignability.lookup_included_signature(member.name)
             merge_methods(methods, module_signature.instance_methods(assignability: assignability,
@@ -125,24 +166,30 @@ module Steep
         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))
+            # @type var method_member: Steep__SignatureMember__Method
+            method_member = member
+            method_types = method_member.types.map {|type| type.substitute(klass: klass, instance: instance, params: {}) }
+            merge_methods(methods,
+                          method_member.name => Steep::Interface::Method.new(types: method_types,
+                                                                             super_method: nil,
+                                                                             attributes: []))
           end
         end
 
-        if self.is_a?(Class)
+        if is_class? && constructor
           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)
+                         Steep::Interface::Method.new(types: types, super_method: nil, attributes: [])
                        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)
+                                                      super_method: nil,
+                                                      attributes: [])
                        end
           methods[:new] = new_method
         end
@@ -152,21 +199,27 @@ module Steep
 
       def merge_methods(methods, hash)
         hash.each_key do |name|
-          method = hash[name]
+          new_method = hash[name]
+          old_method = methods[name]
+          attributes = (new_method.attributes + (old_method&.attributes || [])).sort.uniq
 
-          methods[name] = Steep::Interface::Method.new(types: method.types,
-                                                       super_method: methods[name])
+          methods[name] = Steep::Interface::Method.new(types: new_method.types,
+                                                       super_method: old_method,
+                                                       attributes: attributes)
         end
       end
     end
 
     module WithMembers
+      # @implements Steep__Signature__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|
+              # @type var method_member: Steep__SignatureMember__Method
+              method_member = member
+              method_member.types.each do |method_type|
                 method_type.params.each_type do |type|
                   yield type
                 end
@@ -179,7 +232,9 @@ module Steep
                 end
               end
             when Members::Include, Members::Extend
-              yield member.name
+              # @type var mixin_member: _Steep__SignatureMember__Mixin
+              mixin_member = member
+              yield mixin_member.name
             else
               raise "Unknown member: #{member.class.inspect}"
             end
@@ -210,15 +265,23 @@ module Steep
     end
 
     module WithParams
+      # @implements Steep__Signature__WithParams
+
       def type_application_hash(args)
         Hash[params.zip(args)]
       end
     end
 
     class Module
+      # @implements Steep__Signature__Module
+
+      # @dynamic name
       attr_reader :name
+      # @dynamic params
       attr_reader :params
+      # @dynamic members
       attr_reader :members
+      # @dynamic self_type
       attr_reader :self_type
 
       prepend WithMethods
@@ -240,7 +303,7 @@ module Steep
         {}
       end
 
-      def module_methods(assignability:, klass:, instance:, params:)
+      def module_methods(assignability:, klass:, instance:, params:, constructor:)
         {}
       end
 
@@ -264,13 +327,28 @@ module Steep
                                                     params.map {|x| Types::Var.new(name: x) })
 
         validate_mixins(assignability, interface)
+
+        # FIXME: There is no check for initializer compatibility
+        if interface.methods.values.any? {|method| method.attributes.include?(:constructor) }
+          assignability.errors << Signature::Errors::ConstructorNoCheck.new(signature: self)
+        end
+      end
+
+      def is_class?
+        false
       end
     end
 
     class Class
+      # @implements Steep__Signature__Class
+
+      # @dynamic name
       attr_reader :name
+      # @dynamic params
       attr_reader :params
+      # @dynamic members
       attr_reader :members
+      # @dynamic super_class
       attr_reader :super_class
 
       prepend WithMethods
@@ -304,7 +382,7 @@ module Steep
         end
       end
 
-      def module_methods(assignability:, klass:, instance:, params:)
+      def module_methods(assignability:, klass:, instance:, params:, constructor:)
         signature = assignability.lookup_class_signature(Types::Name.instance(name: :Class))
         class_methods = signature.instance_methods(assignability: assignability,
                                                    klass: klass,
@@ -321,7 +399,11 @@ module Steep
             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))
+          class_methods.merge!(signature.module_methods(assignability: assignability,
+                                                        klass: klass,
+                                                        instance: instance,
+                                                        params: super_class_params,
+                                                        constructor: constructor))
         end
       end
 
@@ -342,7 +424,8 @@ module Steep
         end
 
         interface = assignability.resolve_interface(TypeName::Instance.new(name: name),
-                                                    params.map {|x| Types::Var.new(name: x) })
+                                                    params.map {|x| Types::Var.new(name: x) },
+                                                    constructor: true)
 
         interface.methods.each_key do |method_name|
           method = interface.methods[method_name]
@@ -352,6 +435,15 @@ module Steep
         end
 
         validate_mixins(assignability, interface)
+
+        # FIXME: There is no check for initializer compatibility
+        if interface.methods.values.any? {|method| method.attributes.include?(:constructor) }
+          assignability.errors << Signature::Errors::ConstructorNoCheck.new(signature: self)
+        end
+      end
+
+      def is_class?
+        true
       end
     end
   end