steep 0.3.0 → 0.4.0

data/lib/steep/type_inference/type_env.rb

@@ -78,7 +78,7 @@ module Steep
           if lvar_types.key?(name) || common_vars.member?(name)
             set(lvar: name, type: AST::Types::Union.build(types: types))
           else
-            set(lvar: name, type: AST::Types::Union.build(types: types + [AST::Types::Name.new_instance(name: "::NilClass")]))
+            set(lvar: name, type: AST::Types::Union.build(types: types + [AST::Types::Nil.new]))
           end
         end
       end

data/lib/steep/typing.rb

@@ -4,8 +4,11 @@ module Steep
     attr_reader :typing
     attr_reader :nodes
     attr_reader :var_typing
+    attr_reader :parent
+
+    def initialize(parent: nil)
+      @parent = parent
 
-    def initialize
       @errors = []
       @nodes = {}
       @var_typing = {}
@@ -27,28 +30,18 @@ module Steep
       typing.key?(node.__id__)
     end
 
-    def add_var_type(variable, type)
-      if var_typing.key?(variable)
-        unless var_typing[variable] == type
-          raise "Unexpected variable typing: existing=#{var_typing[variable]}, new=#{type}"
-        end
-      end
-
-      var_typing[variable] = type
-    end
-
     def type_of(node:)
-      typing[node.__id__] or raise "Unknown node for typing: #{node.inspect}"
-    end
+      type = typing[node.__id__]
 
-    def type_of_variable(name: nil, label: nil)
-      var_typing.each do |var, type|
-        if (!name || var.name == name) && (!label || var.label == label)
-          return type
+      if type
+        type
+      else
+        if parent
+          parent.type_of(node: node)
+        else
+          raise "Unknown node for typing: #{node.inspect}"
         end
       end
-
-      raise "Unknown variable for typing: #{name}@#{label}"
     end
 
     def dump(io)
@@ -70,5 +63,27 @@ module Steep
 
       "#{line}:#{col}:#{src}"
     end
+
+    def new_child
+      yield self.class.new(parent: self)
+    end
+
+    def each_typing
+      nodes.each do |id, node|
+        yield node, typing[id]
+      end
+    end
+
+    def save!
+      raise "Unexpected save!" unless parent
+
+      each_typing do |node, type|
+        parent.add_typing(node, type)
+      end
+
+      errors.each do |error|
+        parent.add_error error
+      end
+    end
   end
 end

data/lib/steep/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/smoke/and/a.rb

@@ -3,9 +3,9 @@
 
 a = "foo"
 
-# !expects IncompatibleAssignment: lhs_type=::String, rhs_type=(::NilClass | ::String)
+# !expects IncompatibleAssignment: lhs_type=::String, rhs_type=(::String | nil)
 b = a && a.to_str
 
-# !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=(::NilClass | ::String)
+# !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=(::String | nil)
 c = a && a.to_str
 

data/smoke/case/a.rb

@@ -1,6 +1,6 @@
 # @type var a: Integer
 
-# !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=(::Array<::String> | ::Integer | ::NilClass | ::String)
+# !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=(::Array<::String> | ::Integer | ::String | nil)
 a = case 1
     when 2
       1

data/smoke/literal/a.rb

@@ -10,7 +10,7 @@ x = :foo
 # !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=::String
 y = "foo"
 
-# !expects IncompatibleAssignment: lhs_type=::String, rhs_type=_Boolean
+# !expects IncompatibleAssignment: lhs_type=::String, rhs_type=bool
 x = true
-# !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=_Boolean
+# !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=bool
 y = false

data/stdlib/builtin.rbi

@@ -7,13 +7,13 @@ class Object <: BasicObject
   def tap: { (self) -> any } -> self
   def to_s: -> String
   def hash: -> Integer
-  def eql?: (any) -> _Boolean
-  def ==: (any) -> _Boolean
-  def ===: (any) -> _Boolean
-  def !=: (any) -> _Boolean
+  def eql?: (any) -> bool
+  def ==: (any) -> bool
+  def ===: (any) -> bool
+  def !=: (any) -> bool
   def class: -> class
   def to_i: -> Integer
-  def is_a?: (Module) -> _Boolean
+  def is_a?: (Module) -> bool
   def inspect: -> String
   def freeze: -> self
   def method: (Symbol) -> Method
@@ -31,8 +31,8 @@ class Module
   def extend: (Module) -> any
   def attr_accessor: (*Symbol) -> any
   def attr_writer: (*Symbol) -> any
-  def include: (Module) -> _Boolean
-  def prepend: (Module) -> _Boolean
+  def include: (Module) -> bool
+  def prepend: (Module) -> bool
 end
 
 class Method
@@ -49,13 +49,13 @@ module Kernel
            | (String) -> any
            | (*any) -> any
 
-  def block_given?: -> _Boolean
+  def block_given?: -> bool
   def enum_for: (Symbol, *any) -> any
   def require_relative: (*String) -> void
   def require: (*String) -> void
   def loop: { () -> void } -> void
   def puts: (*any) -> void
-  def eval: (String, ? Integer | nil, ?String) -> any
+  def eval: (String, ? Integer?, ?String) -> any
 end
 
 class Array<'a>
@@ -72,11 +72,11 @@ class Array<'a>
   def <<: ('a) -> self
 
   def []: (Integer) -> 'a
-        | (Range<Integer>) -> (self | nil)
-        | (Integer, Integer) -> (self | nil)
+        | (Range<Integer>) -> self?
+        | (Integer, Integer) -> self?
   def at: (Integer) -> 'a
-        | (Range<Integer>) -> (self | nil)
-        | (Integer, Integer) -> (self | nil)
+        | (Range<Integer>) -> self?
+        | (Integer, Integer) -> self?
   def []=: (Integer, 'a) -> 'a
          | (Integer, Integer, 'a) -> 'a
          | (Integer, Integer, self) -> self
@@ -96,18 +96,18 @@ class Array<'a>
   def combination: (?Integer) { (self) -> any } -> Array<self>
                  | (?Integer) -> Enumerator<self, Array<self>>
 
-  def empty?: -> _Boolean
+  def empty?: -> bool
   def compact: -> self
-  def compact!: -> (self | nil)
+  def compact!: -> self?
   def concat: (*Array<'a>) -> self
             | (*'a) -> self
-  def delete: ('a) -> ('a | nil)
+  def delete: ('a) -> 'a?
             | <'x> ('a) { ('a) -> any } -> ('a | 'x)
-  def delete_at: (Integer) -> ('a | nil)
+  def delete_at: (Integer) -> 'a?
   def delete_if: { ('a) -> any } -> self
                | -> Enumerator<'a, self>
-  def reject!: { ('a) -> any } -> (self | nil)
-             | -> Enumerator<'a, self | nil>
+  def reject!: { ('a) -> any } -> self?
+             | -> Enumerator<'a, self?>
   def dig: (Integer, any) -> any
   def each: { ('a) -> any } -> self
           | -> Enumerator<'a, self>
@@ -118,21 +118,21 @@ class Array<'a>
            | (Integer) { (Integer) -> 'a } -> 'a
   def fill: ('a) -> self
           | { (Integer) -> 'a } -> self
-          | ('a, Integer, ?Integer|nil) -> self
+          | ('a, Integer, ?Integer?) -> self
           | ('a, Range<Integer>) -> self
-          | (Integer, ?Integer|nil) { (Integer) -> 'a} -> self
+          | (Integer, ?Integer?) { (Integer) -> 'a} -> self
           | (Range<Integer>) { (Integer) -> 'a } -> self
 
-  def find_index: ('a) -> (Integer | nil)
-                | { ('a) -> any } -> (Integer | nil)
-                | -> Enumerator<'a, Integer | nil>
+  def find_index: ('a) -> Integer?
+                | { ('a) -> any } -> Integer?
+                | -> Enumerator<'a, Integer?>
 
-  def index: ('a) -> (Integer | nil)
-           | { ('a) -> any } -> (Integer | nil)
-           | -> Enumerator<'a, Integer | nil>
+  def index: ('a) -> Integer?
+           | { ('a) -> any } -> Integer?
+           | -> Enumerator<'a, Integer?>
 
-  def flatten: (?Integer | nil) -> Array<any>
-  def flatten!: (?Integer | nil) -> (self | nil)
+  def flatten: (?Integer?) -> Array<any>
+  def flatten!: (?Integer?) -> self?
 
   def insert: (Integer, *'a) -> self
 
@@ -141,7 +141,7 @@ class Array<'a>
   def keep_if: { ('a) -> any } -> self
              | -> Enumerator<'a, self>
 
-  def last: -> ('a | nil)
+  def last: -> 'a?
           | (Integer) -> self
 
   def length: -> Integer
@@ -152,7 +152,7 @@ class Array<'a>
   def permutation: (?Integer) { (self) -> any } -> Array<self>
                  | (?Integer) -> Enumerator<self, Array<self>>
 
-  def pop: -> ('a | nil)
+  def pop: -> 'a?
          | (Integer) -> self
 
   def unshift: (*'a) -> self
@@ -174,41 +174,41 @@ class Array<'a>
   def reverse: -> self
   def reverse!: -> self
 
-  def rindex: ('a) -> (Integer | nil)
-            | { ('a) -> any } -> (Integer | nil)
-            | -> Enumerator<'a, Integer | nil>
+  def rindex: ('a) -> Integer?
+            | { ('a) -> any } -> Integer?
+            | -> Enumerator<'a, Integer?>
 
   def rotate: (?Integer) -> self
 
   def rotate!: (?Integer) -> self
 
-  def sample: (?random: any) -> ('a | nil)
+  def sample: (?random: any) -> 'a?
             | (Integer, ?random: any) -> self
 
   def select!: -> Enumerator<'a, self>
              | { ('a) -> any } -> self
 
-  def shift: -> ('a | nil)
+  def shift: -> 'a?
            | (Integer) -> self
 
   def shuffle: (?random: any) -> self
 
   def shuffle!: (?random: any) -> self
 
-  def slice: (Integer) -> ('a | nil)
-           | (Integer, Integer) -> (self | nil)
-           | (Range<Integer>) -> (self | nil)
+  def slice: (Integer) -> 'a?
+           | (Integer, Integer) -> self?
+           | (Range<Integer>) -> self?
 
-  def slice!: (Integer) -> ('a | nil)
-            | (Integer, Integer) -> (self | nil)
-            | (Range<Integer>) -> (self | nil)
+  def slice!: (Integer) -> 'a?
+            | (Integer, Integer) -> self?
+            | (Range<Integer>) -> self?
 
   def to_h: -> Hash<any, any>
 
   def transpose: -> self
 
-  def uniq!: -> (self | nil)
-           | { ('a) -> any } -> (self | nil)
+  def uniq!: -> self?
+           | { ('a) -> any } -> self?
 
   def values_at: (*Integer | Range<Integer>) -> self
 
@@ -217,7 +217,7 @@ class Array<'a>
 end
 
 class Hash<'key, 'value>
-  def []: ('key) -> ('value | nil)
+  def []: ('key) -> 'value?
   def []=: ('key, 'value) -> 'value
   def size: -> Integer
   def transform_values: <'a> { ('value) -> 'a } -> Hash<'key, 'a>
@@ -235,10 +235,12 @@ interface _ToS
   def to_s: -> String
 end
 
-interface _Boolean
-  def !: -> _Boolean
-  def to_s: -> String
-  def ==: (any) -> _Boolean
+class TrueClass
+  def !: -> bool
+end
+
+class FalseClass
+  def !: -> bool
 end
 
 class NilClass
@@ -247,10 +249,10 @@ end
 class Numeric
   def +: (Numeric) -> Numeric
   def /: (Numeric) -> Numeric
-  def <=: (any) -> _Boolean
-  def >=: (any) -> _Boolean
-  def < : (any) -> _Boolean
-  def >: (any) -> _Boolean
+  def <=: (any) -> bool
+  def >=: (any) -> bool
+  def < : (any) -> bool
+  def >: (any) -> bool
 end
 
 class Integer <: Numeric
@@ -357,13 +359,13 @@ interface _Iteratable<'a, 'b>
 end
 
 module Enumerable<'a, 'b> : _Iteratable<'a, 'b>
-  def all?: -> _Boolean
-          | { ('a) -> any } -> _Boolean
-          | (any) -> _Boolean
+  def all?: -> bool
+          | { ('a) -> any } -> bool
+          | (any) -> bool
 
-  def any?: -> _Boolean
-          | { ('a) -> any } -> _Boolean
-          | (any) -> _Boolean
+  def any?: -> bool
+          | { ('a) -> any } -> bool
+          | (any) -> bool
 
   def chunk: { ('a) -> any } -> Enumerator<'a, self>
 
@@ -389,13 +391,13 @@ module Enumerable<'a, 'b> : _Iteratable<'a, 'b>
            | (?Integer) { ('a) -> any } -> nil
 
   def detect: ('a) { ('a) -> any } -> 'a
-            | { ('a) -> any } -> ('a | nil)
-            | -> Enumerator<'a, 'a | nil>
+            | { ('a) -> any } -> 'a?
+            | -> Enumerator<'a, 'a?>
             | ('a) -> Enumerator<'a, 'a>
 
   def find: ('a) { ('a) -> any } -> 'a
-          | { ('a) -> any } -> ('a | nil)
-          | -> Enumerator<'a, 'a | nil>
+          | { ('a) -> any } -> 'a?
+          | -> Enumerator<'a, 'a?>
           | ('a) -> Enumerator<'a, 'a>
 
   def drop: (Integer) -> Array<'a>
@@ -424,11 +426,11 @@ module Enumerable<'a, 'b> : _Iteratable<'a, 'b>
   def select: -> Enumerator<'a, Array<'a>>
             | { ('a) -> any } -> Array<'a>
 
-  def find_index: (any) -> (Integer | nil)
-                | { ('a) -> any } -> (Integer | nil)
-                | -> Enumerator<'a, Integer | nil>
+  def find_index: (any) -> Integer?
+                | { ('a) -> any } -> Integer?
+                | -> Enumerator<'a, Integer?>
 
-  def first: () -> ('a | nil)
+  def first: () -> 'a?
            | (Integer) -> Array<'a>
 
   def grep: (any) -> Array<'a>
@@ -439,8 +441,8 @@ module Enumerable<'a, 'b> : _Iteratable<'a, 'b>
 
   def group_by: <'x> { ('a) -> 'x } -> Hash<'x, Array<'a>>
 
-  def member?: (any) -> _Boolean
-  def include?: (any) -> _Boolean
+  def member?: (any) -> bool
+  def include?: (any) -> bool
 
   def inject: <'x> ('x) { ('x, 'a) -> 'x } -> 'x
             | (Symbol) -> any
@@ -453,20 +455,20 @@ module Enumerable<'a, 'b> : _Iteratable<'a, 'b>
             | (any, Symbol) -> any
             | { ('a, 'a) -> 'a } -> 'a
 
-  def max: -> ('a | nil)
+  def max: -> 'a?
          | (Integer) -> Array<'a>
-         | { ('a, 'a) -> Integer } -> ('a | nil)
+         | { ('a, 'a) -> Integer } -> 'a?
          | (Integer) { ('a, 'a) -> Integer } -> Array<'a>
 
-  def max_by: { ('a, 'a) -> Integer } -> ('a | nil)
+  def max_by: { ('a, 'a) -> Integer } -> 'a?
             | (Integer) { ('a, 'a) -> Integer } -> Array<'a>
 
-  def min: -> ('a | nil)
+  def min: -> 'a?
          | (Integer) -> Array<'a>
-         | { ('a, 'a) -> Integer } -> ('a | nil)
+         | { ('a, 'a) -> Integer } -> 'a?
          | (Integer) { ('a, 'a) -> Integer } -> Array<'a>
 
-  def min_by: { ('a, 'a) -> Integer } -> ('a | nil)
+  def min_by: { ('a, 'a) -> Integer } -> 'a?
             | (Integer) { ('a, 'a) -> Integer } -> Array<'a>
 
   def min_max: -> Array<'a>
@@ -474,13 +476,13 @@ module Enumerable<'a, 'b> : _Iteratable<'a, 'b>
 
   def min_max_by: { ('a, 'a) -> Integer } -> Array<'a>
 
-  def none?: -> _Boolean
-           | { ('a) -> any } -> _Boolean
-           | (any) -> _Boolean
+  def none?: -> bool
+           | { ('a) -> any } -> bool
+           | (any) -> bool
 
-  def one?: -> _Boolean
-          | { ('a) -> any } -> _Boolean
-          | (any) -> _Boolean
+  def one?: -> bool
+          | { ('a) -> any } -> bool
+          | (any) -> bool
 
   def partition: { ('a) -> any } -> Array<Array<'a>>
                | -> Enumerator<'a, Array<Array<'a>>>
@@ -533,7 +535,7 @@ class Regexp
 end
 
 class IO
-  def gets: -> (String | nil)
+  def gets: -> String?
   def puts: (*any) -> void
 end
 
@@ -541,10 +543,10 @@ class File <: IO
   def self.binread: (String) -> String
   def self.extname: (String) -> String
   def self.basename: (String) -> String
-  def self.readable?: (String) -> _Boolean
+  def self.readable?: (String) -> bool
   def self.binwrite: (String, String) -> void
   def self.read: (String) -> String
-               | (String, Integer | nil) -> (String | nil)
+               | (String, Integer?) -> String?
 end
 
 STDOUT: IO