steep 0.1.0.pre2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 74822cb390656501c900a6a8c1cb9fbe60c4dc4c
-  data.tar.gz: 1bd94c67e5339288af5052ecdbfaa553ae151aee
+SHA256:
+  metadata.gz: e44524f5daae1f0506108ead6a30bc8abff67ab100d2639e21dd75e3384dab7e
+  data.tar.gz: 1a5595ef390995476f5d6dd88fb3c1684bdca27a87ec26d048b071e4a5ccf9d0
 SHA512:
-  metadata.gz: 8102354b9e6ca837f22439b9b721e6e7ec67bc4b2e49de5db26a59d7167d5399ba04183b2e88d49afa3bf20cb88e5ed94ce6363a22caa0e7b5ec88ffd9963dfd
-  data.tar.gz: ea2304c8ee9850fc540c0b656daf4b100c97de914a4a124e332ef53117b0aa137c6f05a62402227a4601d51a74b1b5298c64980a6e3be9af300f480e41045e0a
+  metadata.gz: 97c834ae154ac5bc617f4f65be66820531524888237ace9bc316c9cbecb1e2433f8a40b947c9c4d1ae97da7701b55622fe2a7407464fb9db90666e6fd790897b
+  data.tar.gz: fe8b9e5ab3367df5b28281a0179b58af6b96fd497ee84293b69533808d2b52ffa7ebc801021456fd0fc528c21d2cd07eb63f9b6ca49899052b9cf746eb184cdd

data/.travis.yml

@@ -1,6 +1,6 @@
 sudo: false
 language: ruby
 rvm:
-  - 2.4.0
+  - 2.5.0
 before_install: gem install bundler -v 1.13.7
 script: bundle exec rake test smoke

data/README.md

@@ -4,73 +4,181 @@
 
 Install via RubyGems.
 
-    $ gem install steep --pre
-
-Note that Steep is not released yet (pre-released). Add `--pre` for `gem install`.
+    $ gem install steep
 
 ### Requirements
 
-Steep requires Ruby 2.4.
+Steep requires Ruby 2.5.
 
 ## Usage
 
 Steep does not infer types from Ruby programs, but requires declaring types and writing annotations.
 You have to go on the following three steps.
 
-### 1. Declare Signatures
+### 1. Declare Types
 
-Declare signatures in `.rbi` files.
+Declare types in `.rbi` files in `sig` directory.
 
 ```
-interface _Foo {
-  def do_something: (String) -> any
-}
+class Person
+  @name: String
+  @contacts: Array<Email | Phone>
+
+  def initialize: (name: String) -> any
+  def name: -> String
+  def contacts: -> Array<Email | Phone>
+  def guess_country: -> (String | nil)
+end
 
-module Fooable : _Foo {
-  def foo: (Array<String>) { (String) -> String } -> any
-}
+class Email
+  @address: String
 
-class SuperFoo {
-  include Fooable
+  def initialize: (address: String) -> any
+  def address: -> String
+end
 
-  def name: -> String
-  def do_something: (String) -> any
-  def bar: (?Symbol, size: Integer) -> Symbol
-}
+class Phone
+  @country: String
+  @number: String
+
+  def initialize: (country: String, number: String) -> any
+  def country: -> String
+  def number: -> String
+
+  def self.countries: -> Hash<String, String>
+end
 ```
 
-### 2. Annotate Ruby Code
+* You can use simple *generics*, like `Hash<String, String>`.
+* You can use *union types*, like `Email | Phone`.
+* You have to declare not only public methods but also private methods and instance variables.
+* You can declare *singleton methods*, like `self.countries`.
+* There is `nil` type to represent *nullable* types.
 
-Write annotations to your Ruby code.
+### 2. Write Ruby Code
+
+Write Ruby code with annotations.
 
 ```rb
-class Foo
-  # @implements SuperFoo
-  # @type const Helper: FooHelper
+class Person
+  # `@dynamic` annotation is to tell steep that
+  # the `name` and `contacts` methods are defined without def syntax.
+  # (Steep can skip checking if the methods are implemented.)
 
-  # @dynamic name
+  # @dynamic name, contacts
   attr_reader :name
+  attr_reader :contacts
 
-  def do_something(string)
-    # ...
+  def initialize(name:)
+    @name = name
+    @contacts = []
   end
 
-  def bar(symbol = :default, size:)
-    Helper.run_bar(symbol, size: size)
+  def guess_country()
+    contacts.map do |contact|
+      # With case expression, simple type-case is implemented.
+      # `contact` has type of `Phone | Email` but in the `when` clause, contact has type of `Phone`.
+      case contact
+      when Phone
+        contact.country
+      end
+    end.compact.first
+  end
+end
+
+class Email
+  # @dynamic address
+  attr_reader :address
+
+  def initialize(address:)
+    @address = address
+  end
+
+  def ==(other)
+    # `other` has type of `any`, which means type checking is skipped.
+    # No type errors can be detected in this method.
+    other.is_a?(self.class) && other.address == address
+  end
+
+  def hash
+    self.class.hash ^ address.hash
+  end
+end
+
+class Phone
+  # @dynamic country, number
+
+  def initialize(country:, number:)
+    @country = country
+    @number = number
+  end
+
+  def ==(other)
+    # You cannot use `case` for type case because `other` has type of `any`, not a union type.
+    # You have to explicitly declare the type of `other` in `if` expression.
+
+    if other.is_a?(Phone)
+      # @type var other: Phone
+      other.country == country && other.number == number
+    end
+  end
+
+  def hash
+    self.class.hash ^ country.hash ^ number.hash
   end
 end
 ```
 
 ### 3. Type Check
 
-Run `steep check` command to type check.
+Run `steep check` command to type check. 💡
 
 ```
-$ steep check lib/foo.rb
-foo.rb:41:18: NoMethodError: type=FooHelper, method=run_bar
-foo.rb:42:24: NoMethodError: type=String, method==~
+$ steep check lib
+lib/phone.rb:46:0: MethodDefinitionMissing: module=::Phone, method=self.countries (class Phone)
+```
+
+You now find `Phone.countries` method is not implemented yet. 🙃
+
+## Scaffolding
+
+You can use `steep scaffold` command to generate a signature declaration.
+
+```
+$ steep scaffold lib/*.rb
+class Person
+  @name: any
+  @contacts: Array<any>
+  def initialize: (name: any) -> Array<any>
+  def guess_country: () -> any
+end
+
+class Email
+  @address: any
+  def initialize: (address: any) -> any
+  def ==: (any) -> any
+  def hash: () -> any
+end
+
+class Phone
+  @country: any
+  @number: any
+  def initialize: (country: any, number: any) -> any
+  def ==: (any) -> void
+  def hash: () -> any
+end
 ```
 
+It prints all methods, classes, instance variables, and constants.
+It can be a good starting point to writing signatures.
+
+Because it just prints all `def`s, you may find some odd points:
+
+* The type of `initialize` in `Person` looks strange.
+* There are no `attr_reader` methods extracted.
+
+Generally, these are by our design.
+
 ## Commandline
 
 `steep check` is the command to run type checking.
@@ -85,7 +193,7 @@ 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*.
+When Steep finds an expression 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.
@@ -100,6 +208,11 @@ Use `--dump-all-types` for that.
 
     $ steep check --dump-all-types test.rb
 
+### Verbose option
+
+Try `-v` option to report more information about type checking.
+
+
 ## Examples
 
 You can find examples in `smoke` directory.

data/bin/smoke_runner.rb

@@ -14,7 +14,11 @@ OptionParser.new do |opts|
   opts.on("-v", "--verbose") do verbose = true end
 end.parse!(ARGV)
 
-Expectation = Struct.new(:line, :message)
+Expectation = Struct.new(:line, :message, :path, :starts) do
+  attr_accessor :prefix_test
+end
+
+allowed_paths = []
 
 failed = false
 
@@ -35,12 +39,24 @@ ARGV.each do |arg|
       comments.each do |comment|
         src = comment.text.gsub(/\A#\s*/, '')
 
+        if src =~ /!expects\*(@(\+\d+))?/
+          offset = $2&.to_i || 1
+          message = src.gsub!(/\A!expects\*(@\+\d+)? +/, '')
+          line = comment.location.line
+
+          expectations << Expectation.new(line+offset, message, file).tap {|e| e.prefix_test = true }
+        end
+
         if src =~ /!expects(@(\+\d+))?/
           offset = $2&.to_i || 1
           message = src.gsub!(/\A!expects(@\+\d+)? +/, '')
           line = comment.location.line
 
-          expectations << Expectation.new(line+offset, message)
+          expectations << Expectation.new(line+offset, message, file)
+        end
+
+        if src =~ /ALLOW FAILURE/
+          allowed_paths << file
         end
       end
 
@@ -58,6 +74,7 @@ ARGV.each do |arg|
                                        stdout: stdout,
                                        stderr: stderr)
 
+    Rainbow.enabled = false
     driver.run
   rescue => exn
     puts "ERROR: #{exn.inspect}"
@@ -66,6 +83,8 @@ ARGV.each do |arg|
     end
 
     failed = true
+  ensure
+    Rainbow.enabled = true
   end
 
   if verbose
@@ -82,22 +101,36 @@ ARGV.each do |arg|
 
   expectations.each do |expectation|
     deleted = lines.reject! do |string|
-      string =~ /:#{expectation.line}:\d+: #{Regexp.quote expectation.message}\Z/
+      if expectation.prefix_test
+        string =~ /\A#{Regexp.escape(expectation.path.to_s)}:#{expectation.line}:\d+: #{Regexp.quote expectation.message}/
+      else
+        string =~ /\A#{Regexp.escape(expectation.path.to_s)}:#{expectation.line}:\d+: #{Regexp.quote expectation.message} \(/
+      end
     end
 
     unless deleted
-      puts Rainbow("  💀 Expected error not found: #{expectation.line}:#{expectation.message}").red
-      failed = true
+      allowed = allowed_paths.any? {|path| path == expectation.path }
+      message = Rainbow("  💀 Expected error not found: #{expectation.path}:#{expectation.line}:#{expectation.message}")
+      if allowed
+        puts message.yellow
+      else
+        puts message.red
+        failed = true
+      end
     end
   end
 
   unless lines.empty?
     lines.each do |line|
-      if line =~ /:\d+:\d+:/
-        puts Rainbow("  🤦‍♀️ Unexpected error found: #{line}").red
-        failed = true
-      else
-        puts Rainbow("  🤦 Unexpected error found, but ignored: #{line}").yellow
+      if line =~ /\A([^:]+):\d+:\d+:/
+        message = Rainbow("  🤦‍♀️ Unexpected error found: #{line}")
+
+        if allowed_paths.include?(Pathname($1))
+          puts message.yellow
+        else
+          puts message.red
+          failed = true
+        end
       end
     end
   end

data/lib/steep/ast/annotation/collection.rb

@@ -0,0 +1,93 @@
+module Steep
+  module AST
+    module Annotation
+      class Collection
+        attr_reader :var_types
+        attr_reader :method_types
+        attr_reader :annotations
+        attr_reader :block_type
+        attr_reader :return_type
+        attr_reader :self_type
+        attr_reader :const_types
+        attr_reader :instance_type
+        attr_reader :module_type
+        attr_reader :implement_module
+        attr_reader :ivar_types
+        attr_reader :dynamics
+        attr_reader :break_type
+
+        def initialize(annotations:)
+          @var_types = {}
+          @method_types = {}
+          @const_types = {}
+          @ivar_types = {}
+          @dynamics = {}
+          @break_type = nil
+
+          annotations.each do |annotation|
+            case annotation
+            when VarType
+              var_types[annotation.name] = annotation
+            when MethodType
+              method_types[annotation.name] = annotation
+            when BlockType
+              @block_type = annotation.type
+            when ReturnType
+              @return_type = annotation.type
+            when SelfType
+              @self_type = annotation.type
+            when ConstType
+              @const_types[annotation.name] = annotation.type
+            when InstanceType
+              @instance_type = annotation.type
+            when ModuleType
+              @module_type = annotation.type
+            when Implements
+              @implement_module = annotation
+            when IvarType
+              ivar_types[annotation.name] = annotation.type
+            when Dynamic
+              annotation.names.each do |name|
+                dynamics[name.name] = name
+              end
+            when BreakType
+              @break_type = annotation.type
+            else
+              raise "Unexpected annotation: #{annotation.inspect}"
+            end
+          end
+
+          @annotations = annotations
+        end
+
+        def lookup_var_type(name)
+          var_types[name]&.type
+        end
+
+        def lookup_method_type(name)
+          method_types[name]&.type
+        end
+
+        def lookup_const_type(node)
+          const_types[node]
+        end
+
+        def +(other)
+          self.class.new(annotations: annotations.reject {|a| a.is_a?(BlockType) } + other.annotations)
+        end
+
+        def any?(&block)
+          annotations.any?(&block)
+        end
+
+        def size
+          annotations.size
+        end
+
+        def include?(obj)
+          annotations.include?(obj)
+        end
+      end
+    end
+  end
+end

data/lib/steep/ast/annotation.rb

@@ -0,0 +1,131 @@
+module Steep
+  module AST
+    module Annotation
+      class Named
+        attr_reader :name
+        attr_reader :type
+        attr_reader :location
+
+        def initialize(name:, type:, location: nil)
+          @name = name
+          @type = type
+          @location = location
+        end
+
+        def ==(other)
+          other.is_a?(self.class) &&
+            other.name == name &&
+            other.type == type &&
+            (!other.location || !location || other.location == location)
+        end
+      end
+
+      class Typed
+        attr_reader :type
+        attr_reader :annotation
+        attr_reader :location
+
+        def initialize(type:, location: nil)
+          @type = type
+          @location = location
+        end
+
+        def ==(other)
+          other.is_a?(self.class) &&
+            other.type == type &&
+            (!other.location || !location || other.location == location)
+        end
+      end
+
+      class ReturnType < Typed; end
+      class BlockType < Typed; end
+      class SelfType < Typed; end
+      class InstanceType < Typed; end
+      class ModuleType < Typed; end
+      class BreakType < Typed; end
+
+      class MethodType < Named; end
+      class VarType < Named; end
+      class ConstType < Named; end
+      class IvarType < Named; end
+
+      class Implements
+        class Module
+          attr_reader :name
+          attr_reader :args
+
+          def initialize(name:, args:)
+            @name = name
+            @args = args
+          end
+
+          def ==(other)
+            other.is_a?(Module) && other.name == name && other.args == args
+          end
+
+          alias eql? ==
+
+          def hash
+            self.class.hash ^ name.hash ^ args.hash
+          end
+        end
+
+        attr_reader :location
+        attr_reader :name
+
+        def initialize(name:, location:)
+          @location = location
+          @name = name
+        end
+
+        def ==(other)
+          other.is_a?(Implements) &&
+            other.name == name &&
+            other.location == location
+        end
+      end
+
+      class Dynamic
+        class Name
+          attr_reader :kind
+          attr_reader :name
+          attr_reader :location
+
+          def initialize(name:, kind:, location: nil)
+            @name = name
+            @kind = kind
+            @location = location
+          end
+
+          def instance_method?
+            kind == :instance || kind == :module_instance
+          end
+
+          def module_method?
+            kind == :module || kind == :module_instance
+          end
+
+          def ==(other)
+            other.is_a?(Name) &&
+              other.name == name &&
+              other.kind == kind
+          end
+        end
+
+        attr_reader :location
+        attr_reader :names
+
+        def initialize(names:, location: nil)
+          @location = location
+          @names = names
+        end
+
+        def ==(other)
+          other.is_a?(Dynamic) &&
+            other.names == names &&
+            (!other.location || location || other.location == location)
+        end
+      end
+    end
+  end
+end

data/lib/steep/ast/buffer.rb

@@ -0,0 +1,47 @@
+module Steep
+  module AST
+    class Buffer
+      attr_reader :name
+      attr_reader :content
+      attr_reader :lines
+      attr_reader :ranges
+
+      def initialize(name:, content:)
+        @name = name
+        @content = content
+
+        @lines = content.lines
+
+        @ranges = []
+        offset = 0
+        lines.each do |line|
+          size = line.bytesize
+          range = offset .. (offset+size)
+          ranges << range
+          offset += size
+        end
+      end
+
+      def pos_to_loc(pos)
+        index = ranges.bsearch_index do |range|
+          pos < range.end
+        end
+
+        if index
+          [index + 1, pos - ranges[index].begin]
+        else
+          [1, pos]
+        end
+      end
+
+      def loc_to_pos(loc)
+        line, column = loc
+        ranges[line - 1].begin + column
+      end
+
+      def source(range)
+        content[range]
+      end
+    end
+  end
+end