typeprof 0.2.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c01f41e130c6e3bbc112520904ed710a75dea1b167ea112e96a321cd1bceadf
-  data.tar.gz: 1b61e75c07cc8d24570bd998ea852f850b22264aaa1eed1bda425efe11660fba
+  metadata.gz: c1cf845328dbfd7b8dc14113c986be27a28457153d4e3b470ca45341035bdff7
+  data.tar.gz: 7e1aa96c7623832dc63e0d60573c28deeb0112c31921d63752553dcbf8127fde
 SHA512:
-  metadata.gz: ba66753bc6fe6b21939449ede398ee31c27aa06893884a3e93baebcf60439c9552fa0b1da1b8fd6158f83ef012966f275c83055ba94d2974c10f694e031c40ab
-  data.tar.gz: 6f6d9e688c024eefead28c9fe847686d172919a0c3ae0f5f6441bcb79d947710265e77dc52e4c5d44be699d7ea6bcd978943d0a898621956e6991a19c3874ac0
+  metadata.gz: 40e5f8da50d3b31dc96f2b010275083d9907c7510d16afc1f86b23114196a30c8170b9fc77cb8d8e1de0a7ba0b14a5deaf143450f3541e007a56a9170ce7ed93
+  data.tar.gz: 3fd01d2edc108f2ce262af023886fa04c8e2cbc6e98647dad238954428a188aa4637913c2e7f13c983deeb4ac6ff7b3dc3489acc740effcbddbd128519135662

data/.github/workflows/main.yml

@@ -17,9 +17,8 @@ jobs:
       uses: ruby/setup-ruby@v1
       with:
         ruby-version: ${{ matrix.ruby-version }}
-    - name: Set up RBS and bundle install
+    - name: Bundle install
       run: |
-        cd rbs && bundle install && bundle exec rake parser && cd ..
         bundle install
     - name: Run the test suite
       run: |

data/.gitignore

@@ -7,3 +7,4 @@ testbed/diff-lcs
 pkg/
 *.log
 .*.sw*
+*.dump

data/Gemfile

@@ -7,7 +7,7 @@ group :development do
   gem "rake"
   gem "stackprof"
   gem "test-unit"
-  gem "simplecov", github: "simplecov-ruby/simplecov"
-  gem "simplecov-html", github: "simplecov-ruby/simplecov-html", ref: "6567856c6940e285bbb70cce98edca60c7dfefdd"
+  gem "simplecov"
+  gem "simplecov-html"
   gem "coverage-helpers"
 end

data/Gemfile.lock

@@ -1,23 +1,8 @@
-GIT
-  remote: https://github.com/simplecov-ruby/simplecov-html.git
-  revision: 6567856c6940e285bbb70cce98edca60c7dfefdd
-  ref: 6567856c6940e285bbb70cce98edca60c7dfefdd
-  specs:
-    simplecov-html (0.12.2)
-
-GIT
-  remote: https://github.com/simplecov-ruby/simplecov.git
-  revision: 80700ec9f9b5ae426c22d06f62620f7e7b71ff42
-  specs:
-    simplecov (0.18.5)
-      docile (~> 1.1)
-      simplecov-html (~> 0.11)
-
 PATH
   remote: .
   specs:
-    typeprof (0.1.4)
-      rbs (>= 0.12.0)
+    typeprof (0.4.2)
+      rbs (>= 0.16.0)
 
 GEM
   remote: https://rubygems.org/
@@ -26,8 +11,12 @@ GEM
     docile (1.3.2)
     power_assert (1.2.0)
     rake (13.0.1)
-    rbs (0.14.0)
-    stackprof (0.2.15)
+    rbs (0.16.0)
+    simplecov (0.19.1)
+      docile (~> 1.1)
+      simplecov-html (~> 0.11)
+    simplecov-html (0.12.3)
+    stackprof (0.2.16)
     test-unit (3.3.6)
       power_assert
 
@@ -37,8 +26,8 @@ PLATFORMS
 DEPENDENCIES
   coverage-helpers
   rake
-  simplecov!
-  simplecov-html!
+  simplecov
+  simplecov-html
   stackprof
   test-unit
   typeprof!

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Yusuke Endoh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -33,3 +33,9 @@ end
 ## Documentation
 
 [English](doc/doc.md) / [日本語](doc/doc.ja.md)
+
+## Playground
+
+You can try typeprof gem on the Web via the URL below.
+
+https://mame.github.io/typeprof-playground/

data/doc/demo.md

@@ -0,0 +1,398 @@
+# TypeProf demo cases
+
+## A simple demo with a "User" class
+
+```ruby
+def hello_message(user)
+  "The name is " + user.name
+end
+
+def type_error_demo(user)
+  "The age is " + user.age
+end
+
+user = User.new(name: "John", age: 20)
+
+hello_message(user)
+type_error_demo(user)
+```
+
+```ruby
+class User
+  attr_reader name: String
+  attr_reader age: Integer
+
+  def initialize: (name: String, age: Integer) -> void
+end
+```
+
+Result:
+```
+$ typeprof test.rb test.rbs
+# Errors
+test.rb:6: [error] failed to resolve overload: String#+
+
+# Classes
+class Object
+  def hello_message : (User) -> String
+  def type_error_demo : (User) -> untyped
+end
+```
+
+Yoy can [try this analysis online](https://mame.github.io/typeprof-playground/#rb=def+hello_message%28user%29%0A++%22The+name+is+%22+%2B+user.name%0Aend%0A%0Adef+type_error_demo%28user%29%0A++%22The+age+is+%22+%2B+user.age%0Aend%0A%0Auser+%3D+User.new%28name%3A+%22John%22%2C+age%3A+20%29%0A%0Ahello_message%28user%29%0Atype_error_demo%28user%29&rbs=class+User%0A++attr_reader+name%3A+String%0A++attr_reader+age%3A+Integer%0A%0A++def+initialize%3A+%28name%3A+String%2C+age%3A+Integer%29+-%3E+void%0Aend).
+
+## A simple demo to generate the signature prototype of "User" class
+
+```ruby
+class User
+  def initialize(name:, age:)
+    @name, @age = name, age
+  end
+  attr_reader :name, :age
+end
+
+# A test case to tell TypeProf what types are expected by the class and methods
+User.new(name: "John", age: 20)
+```
+
+Result:
+```
+$ typeprof -v test.rb
+# Classes
+class User
+  attr_reader name : String
+  attr_reader age : Integer
+  def initialize : (name: String, age: Integer) -> [String, Integer]
+end
+```
+
+## Type inspection by `p` (`Kernel#p`)
+
+```ruby
+p 42          #=> Integer
+p "str"       #=> String
+p "str".chars #=> Array[String]
+```
+
+Result:
+```
+$ typeprof test.rb
+# Revealed types
+#  test.rb:1 #=> Integer
+#  test.rb:2 #=> String
+#  test.rb:3 #=> Array[String]
+```
+
+## Block with builtin methods
+
+```ruby
+# TypeProf runs this block only once
+10000000000000.times do |n|
+  p n #=> Integer
+end
+
+# "each" with Heterogeneous array yields a union type
+[1, 1.0, "str"].each do |e|
+  p e #=> Float | Integer | String
+end
+
+# You can use the idiom `&:method_name` too
+p [1, 1.0, "str"].map(&:to_s) #=> Array[String]
+```
+
+## User-defined blocks
+
+```ruby
+def foo(n)
+  yield n.to_s
+end
+
+foo(42) do |n|
+  p n #=> String
+  nil
+end
+```
+
+Result:
+```
+$ typeprof test.rb
+# Revealed types
+#  test.rb:6 #=> String
+
+# Classes
+class Object
+  def foo : (Integer) { (String) -> nil } -> nil
+end
+```
+
+## Arrays
+
+```ruby
+# A fixed-length array literal generates a "tuple" array
+ary = [1, 1.0]
+
+# A tuple array keeps its length, and the association between indexes and elements
+p ary    #=> [Integer, Float]
+p ary[0] #=> Integer
+p ary[1] #=> Float
+
+# Destructive operation is well handled (in method-local analysis)
+ary[0] = "str"
+p ary #=> [String, Float]
+
+# An calculated array generates a "sequence" array
+ary = [1] + [1.0]
+
+# A sequence array does not keep length nor association
+p ary    #=> Array[Float | Integer]
+p ary[0] #=> Float | Integer
+
+# Destructive operation is still handled (but "weak update" is applied)
+ary[0] = "str"
+p ary #=> Array[Float | Integer | String]
+```
+
+## Multiple return values by using a tuple array
+
+```ruby
+def foo
+  return 42, "str"
+end
+
+int, str = foo
+p int #=> Integer
+p str #=> String
+```
+
+## Delegation by using a tuple array
+
+```ruby
+def foo(x, y, z)
+end
+
+def proxy(dummy, *args)
+  foo(*args)
+end
+
+proxy(:dummy, 1, 1.0, "str")
+```
+
+## Symbols
+
+```ruby
+# Symbols are handled as concrete values instead of abstract ones
+p [:a, :b, :c] #=> [:a, :b, :c]
+```
+
+## Hashes
+
+```ruby
+# A Hash is a "type-to-type" map
+h = { "int" => 1, "float" => 1.0 }
+p h        #=> {String=>Float | Integer}
+p h["int"] #=> Float | Intger
+
+# Symbol-key hashes (a.k.a. records) can have distinct types for each key as Symbols are concrete
+h = { int: 1, float: 1.0 }
+
+p h         #=> {:int=>Integer, :float=>Float}
+p h[:int]   #=> Integer
+p h[:float] #=> Float
+
+# Symbol-key hash can be appropriately passed to a keyword method
+def foo(int:, float:)
+  p [int, float] #=> [Integer, Float]
+end
+
+foo(**h)
+```
+
+## Structs
+
+```ruby
+FooBar = Struct.new(:foo, :bar)
+
+obj = FooBar.new(42)
+obj.foo = :dummy
+obj.bar = "str"
+```
+
+Result:
+```
+$ typeprof test.rb
+# Classes
+class FooBar < Struct
+  attr_accessor foo() : :dummy | Integer
+  attr_accessor bar() : String?
+end
+```
+
+## Exceptions
+
+```ruby
+# TypeProf assumes that any exception may be raised anywhere
+def foo
+  x = 1
+  x = "str"
+  x = :sym
+ensure
+  p(x) #=> :sym | Integer | String
+end
+```
+
+Result:
+```
+$ typeprof test.rb
+# Revealed types
+#  test.rb:6 #=> :sym | Integer | String
+
+# Classes
+class Object
+  def foo : -> :sym
+end
+```
+
+## RBS overloaded methods
+
+```ruby
+# TypeProf selects all overloaded method declarations that matches actual arguments
+p foo(42)    #=> Integer
+p foo("str") #=> String
+p foo(1.0)   #=> failed to resolve overload: Object#foo
+```
+
+```
+class Object
+  def foo: (Integer) -> Integer
+         | (String) -> String
+end
+```
+
+## Flow-sensitive analysis demo: case/when with class constants
+
+```ruby
+def foo(n)
+  case n
+  when Integer
+    p n #=> Integer
+  when String
+    p n #=> String
+  else
+    p n #=> Float
+  end
+end
+
+foo(42)
+foo(1.0)
+foo("str")
+```
+
+Result:
+```
+$ typeprof test.rb
+# Revealed types
+#  test.rb:4 #=> Integer
+#  test.rb:8 #=> Float
+#  test.rb:6 #=> String
+
+# Classes
+class Object
+  def foo : (Float | Integer | String) -> (Float | Integer | String)
+end
+```
+
+## Flow-sensitive analysis demo: `is_a?` and `respond_to?`
+
+```ruby
+def foo(n)
+  if n.is_a?(Integer)
+    p n #=> Integer
+  else
+    p n #=> Float | String
+  end
+
+  if n.respond_to?(:times)
+    p n #=> Integer
+  else
+    p n #=> Float | String
+  end
+end
+
+foo(42)
+foo(1.0)
+foo("str")
+```
+
+## Flow-sensitive analysis demo: `x || y`
+
+```ruby
+# ENV["FOO"] returns String? (which means String | nil)
+p ENV["FOO"]              #=> String?
+
+# Using "|| (default value)" can force it to be non-nil
+p ENV["FOO"] || "default" #=> String
+```
+
+## Recursion
+
+```ruby
+def fib(x)
+  if x <= 1
+    x
+  else
+    fib(x - 1) + fib(x - 2)
+  end
+end
+
+fib(40000)
+```
+
+Result:
+```
+$ typeprof test.rb
+# Classes
+class Object
+  def fib : (Integer) -> Integer
+end
+```
+
+## "Stub-execution" that invokes methods without tests
+
+```ruby
+def foo(n)
+  # bar is invoked with Integer arguments
+  bar(42)
+  n
+end
+
+def bar(n)
+  n
+end
+
+# As there is no test code to call methods foo and bar,
+# TypeProf tries to invoke them with "untyped" arguments
+```
+
+Result:
+```
+$ typeprof test.rb
+# Classes
+class Object
+  def foo : (untyped) -> untyped
+  def bar : (Integer) -> Integer
+end
+```
+
+## Library demo
+
+```ruby
+require "pathname"
+
+p Pathname("foo")         #=> Pathname
+p Pathname("foo").dirname #=> Pathname
+p Pathname("foo").ctime   #=> Time
+```
+
+## More
+
+See ruby/typeprof's [smoke](https://github.com/ruby/typeprof/tree/master/smoke) directory.