typeprof 0.20.2 → 0.21.1

data/vscode/package.json

@@ -1,14 +1,14 @@
 {
     "name": "ruby-typeprof",
     "displayName": "Ruby TypeProf",
-    "version": "0.20.0",
+    "version": "0.20.1",
     "publisher": "mame",
     "author": {
         "name": "Yusuke Endoh"
     },
     "repository": {
         "type": "git",
-        "url": "https://github.com/mame/vscode-typeprof"
+        "url": "https://github.com/ruby/typeprof/tree/master/vscode"
     },
     "license": "MIT",
     "categories": [
@@ -62,7 +62,7 @@
     "devDependencies": {
         "@types/node": "^14.14.37",
         "typescript": "^4.2.3",
-        "vsce": "^1.96.1",
+        "vsce": "^1.103.1",
         "vscode": "^1.1.37"
     },
     "dependencies": {

data/vscode/src/extension.ts

@@ -88,6 +88,9 @@ function executeTypeProf(folder: vscode.WorkspaceFolder, arg: String): child_pro
   if (shell && (shell.endsWith("bash") || shell.endsWith("zsh") || shell.endsWith("fish"))) {
     typeprof = child_process.spawn(shell, ["-c", "-l", cmd], { cwd });
   }
+  else if (process.platform === "win32") {
+    typeprof = child_process.spawn("C:\\Windows\\System32\\cmd.exe", ["/c", cmd], { cwd });
+  }
   else {
     typeprof = child_process.spawn(cmd, { cwd });
   }
@@ -95,20 +98,30 @@ function executeTypeProf(folder: vscode.WorkspaceFolder, arg: String): child_pro
   return typeprof;
 }
 
-function getTypeProfVersion(folder: vscode.WorkspaceFolder, callback: (version: string) => void): child_process.ChildProcessWithoutNullStreams {
+function getTypeProfVersion(folder: vscode.WorkspaceFolder, outputChannel: vscode.OutputChannel, callback: (version: string) => void): child_process.ChildProcessWithoutNullStreams {
   const typeprof = executeTypeProf(folder, "--version");
   let output = "";
 
+  const log = (msg: string) => {
+    outputChannel.appendLine("[vscode] " + msg);
+    console.info(msg);
+  };
+
   typeprof.stdout?.on("data", out => { output += out; });
-  typeprof.stderr?.on("data", out => { console.log(out); });
+  typeprof.stderr?.on("data", (out: Buffer) => {
+    const str = ("" + out).trim();
+    for (const line of str.split("\n")) {
+      log("stderr: " + line);
+    }
+  });
   typeprof.on("error", e => {
-    console.info(`typeprof is not supported for this folder: ${folder}`);
-    console.info(`because: ${e}`);
+    log(`typeprof is not supported for this folder: ${folder}`);
+    log(`because: ${e}`);
   });
   typeprof.on("exit", (code) => {
     if (code == 0) {
-      console.info(`typeprof version: ${output}`)
       const str = output.trim();
+      log(`typeprof version: ${str}`)
       const version = /^typeprof (\d+).(\d+).(\d+)$/.exec(str);
       if (version) {
         const major = Number(version[1]);
@@ -118,15 +131,15 @@ function getTypeProfVersion(folder: vscode.WorkspaceFolder, callback: (version:
           callback(str);
         }
         else {
-          console.info(`typeprof version ${str} is too old; please use 0.20.0 or later for IDE feature`);
+          log(`typeprof version ${str} is too old; please use 0.20.0 or later for IDE feature`);
         }
       }
       else {
-        console.info(`typeprof --version showed unknown message`);
+        log(`typeprof --version showed unknown message`);
       }
     }
     else {
-      console.info(`failed to invoke typeprof: error code ${code}`);
+      log(`failed to invoke typeprof: error code ${code}`);
     }
     typeprof.kill()
   });
@@ -164,7 +177,7 @@ function getTypeProfStream(folder: vscode.WorkspaceFolder, error: (msg: string)
   });
 }
 
-function invokeTypeProf(folder: vscode.WorkspaceFolder): LanguageClient {
+function invokeTypeProf(folder: vscode.WorkspaceFolder, outputChannel: vscode.OutputChannel): LanguageClient {
   let client: LanguageClient;
 
   const reportError = (msg: string) => client.info(msg);
@@ -185,6 +198,7 @@ function invokeTypeProf(folder: vscode.WorkspaceFolder): LanguageClient {
       { scheme: "file", language: "ruby" },
       { scheme: "file", language: "rbs" },
     ],
+    outputChannel,
     synchronize: {
       fileEvents:
         vscode.workspace.createFileSystemWatcher("{**/*.rb,**/*.rbs}"),
@@ -199,17 +213,21 @@ function invokeTypeProf(folder: vscode.WorkspaceFolder): LanguageClient {
 const clientSessions: Map<vscode.WorkspaceFolder, State> = new Map();
 
 function startTypeProf(folder: vscode.WorkspaceFolder) {
-  const showStatus = (msg: string) => vscode.window.setStatusBarMessage(msg, 3000);
-  console.log(`start: ${folder}`);
+  const outputChannel = vscode.window.createOutputChannel("Ruby TypeProf");
+  const showStatus = (msg: string) => {
+    outputChannel.appendLine("[vscode] " + msg);
+    vscode.window.setStatusBarMessage(msg, 3000);
+  }
+  outputChannel.appendLine("[vscode] Try to start TypeProf for IDE");
 
-  const typeprof = getTypeProfVersion(folder, (version) => {
+  const typeprof = getTypeProfVersion(folder, outputChannel, (version) => {
     if (!version) {
       showStatus(`Ruby TypeProf is not configured; Try to add "gem 'typeprof'" to Gemfile`);
       clientSessions.delete(folder);
       return;
     }
     showStatus(`Starting Ruby TypeProf (${version})...`);
-    const client = invokeTypeProf(folder);
+    const client = invokeTypeProf(folder, outputChannel);
     client.onReady()
     .then(() => {
       showStatus("Ruby TypeProf is running");
@@ -225,7 +243,6 @@ function startTypeProf(folder: vscode.WorkspaceFolder) {
 }
 
 function stopTypeProf(state: State) {
-  console.log(`stop: ${state.workspaceFolder}`);
   switch (state.kind) {
     case "invoking":
       state.process.kill();

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: typeprof
 version: !ruby/object:Gem::Version
-  version: 0.20.2
+  version: 0.21.1
 platform: ruby
 authors:
 - Yusuke Endoh
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-10-28 00:00:00.000000000 Z
+date: 2021-12-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rbs
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.6.2
+        version: 1.8.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.6.2
+        version: 1.8.1
 description: |
   TypeProf performs a type analysis of non-annotated Ruby code.
 
@@ -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.