typeprof 0.20.3 → 0.20.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3ee0445d195b9ab48538b37afc382d3b48d74c4fd9c5628010a3ac5084349259
-  data.tar.gz: 183309d5b70590396a7b0eec078b1b980b5e38877d5d756e66e03acefb971055
+  metadata.gz: 20dc7384f6e6cdbfd5d698a0fc91f3d4ed4a45eba3433bfa5fd9a372f24361e6
+  data.tar.gz: 5f5bf30af6e23ee8a3eb4afe77e6bb7cadeb87335a2ba40a309433c88341b114
 SHA512:
-  metadata.gz: 2b43a67c81128f11a34bd3d9aeecad1763e3baf7a8498e68c411fa652579213519956a6ff4d301873b8d9291d1ce89f1c1e33f0379846df620118d47b42add0f
-  data.tar.gz: e1768b62ac2fe976fb94abe2fbf41656002f80e8016cd8c5e634a44770a4a8eeafb1e50bc5003a774d84621a5c14fbad9fef4eb40c9c383b9b48bee74ca05907
+  metadata.gz: 6d1f9adf368ceaebf9ece57f50be445d9fad60c2a7f447b3a3dc6b3ff710c05cd9a59ea27dd76d620843159a28bd912c0bd78b10d02c96bfe68af1fe691b7b46
+  data.tar.gz: 277fca4264f3df16e3de7742e6e8c44fe42badc7d2dba7ff3fb07a8bce2eebe954e0f2e10ee570a3bf172b86fd77ecd1d39118f70eed0a1079a0e34976c94a2c

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    typeprof (0.20.3)
+    typeprof (0.20.4)
       rbs (>= 1.6.2)
 
 GEM

data/lib/typeprof/analyzer.rb

@@ -1393,7 +1393,7 @@ module TypeProf
         num, = operands
         env, = env.pop(num)
         env = env.push(Type::Instance.new(Type::Builtin[:str]))
-      when :tostring, :anytostring
+      when :tostring, :objtostring, :anytostring
         env, (_ty1, _ty2,) = env.pop(2)
         env = env.push(Type::Instance.new(Type::Builtin[:str]))
       when :freezestring

data/lib/typeprof/insns-def.rb

@@ -21,6 +21,7 @@ TypeProf::INSN_TABLE = {:nop=>[],
  :putstring=>["VALUE"],
  :concatstrings=>["rb_num_t"],
  :tostring=>[],
+ :objtostring=>[],
  :anytostring=>[],
  :freezestring=>["VALUE"],
  :toregexp=>["rb_num_t", "rb_num_t"],

data/lib/typeprof/iseq.rb

@@ -704,7 +704,7 @@ module TypeProf
         sp += 1
       when :newhashfromarray
         raise NotImplementedError, "newhashfromarray"
-      when :newrange, :tostring, :anytostring
+      when :newrange, :tostring, :objtostring, :anytostring
         sp -= 2
         return nil if sp <= 0
         sp += 1

data/lib/typeprof/version.rb

@@ -1,3 +1,3 @@
 module TypeProf
-  VERSION = "0.20.3"
+  VERSION = "0.20.4"
 end

data/typeprof.gemspec

@@ -24,7 +24,7 @@ Gem::Specification.new do |spec|
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|smoke|testbed)/}) }
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(doc|test|spec|features|smoke|testbed)/}) }
   end
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: typeprof
 version: !ruby/object:Gem::Version
-  version: 0.20.3
+  version: 0.20.4
 platform: ruby
 authors:
 - Yusuke Endoh
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-11-11 00:00:00.000000000 Z
+date: 2021-11-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rbs
@@ -44,14 +44,6 @@ files:
 - LICENSE
 - README.md
 - Rakefile
-- doc/demo.md
-- doc/doc.ja.md
-- doc/doc.md
-- doc/ide.md
-- doc/ppl2019.pdf
-- doc/todo.md
-- doc/typeprof-for-ide-log.png
-- doc/typeprof-for-ide.png
 - exe/typeprof
 - lib/typeprof.rb
 - lib/typeprof/analyzer.rb

data/doc/demo.md

@@ -1,398 +0,0 @@
-# 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
-```
-
-You 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 | Integer
-
-# 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.