steep 0.9.0 → 0.10.0

data/lib/steep/type_construction.rb

@@ -50,8 +50,9 @@ module Steep
       attr_reader :const_env
       attr_reader :implement_name
       attr_reader :current_namespace
+      attr_reader :class_name
 
-      def initialize(instance_type:, module_type:, implement_name:, current_namespace:, const_env:)
+      def initialize(instance_type:, module_type:, implement_name:, current_namespace:, const_env:, class_name:)
         @instance_type = instance_type
         @module_type = module_type
         @defined_instance_methods = Set.new
@@ -59,6 +60,7 @@ module Steep
         @implement_name = implement_name
         @current_namespace = current_namespace
         @const_env = const_env
+        @class_name = class_name
       end
 
       def const_context
@@ -344,7 +346,8 @@ module Steep
         module_type: annots.self_type || module_type,
         implement_name: implement_module_name,
         current_namespace: new_namespace,
-        const_env: module_const_env
+        const_env: module_const_env,
+        class_name: absolute_name(new_module_name)
       )
 
       module_type_env = TypeInference::TypeEnv.build(annotations: annots,
@@ -368,6 +371,7 @@ module Steep
 
     def for_class(node)
       new_class_name = Names::Module.from_node(node.children.first) or raise "Unexpected class name: #{node.children.first}"
+      super_class_name = node.children[1] && Names::Module.from_node(node.children[1])
       new_namespace = nested_namespace_for_module(new_class_name)
 
       annots = source.annotations(block: node, builder: checker.builder, current_module: new_namespace)
@@ -384,16 +388,26 @@ module Steep
             end
           end
         else
-          absolute_name(new_class_name).yield_self do |absolute_name|
-            if checker.builder.signatures.class_name?(absolute_name)
-              signature = checker.builder.signatures.find_class(absolute_name)
-              AST::Annotation::Implements::Module.new(name: absolute_name,
-                                                      args: signature.params&.variables || [])
-            end
+          name = nil
+          name ||= absolute_name(new_class_name).yield_self do |absolute_name|
+            absolute_name if checker.builder.signatures.class_name?(absolute_name)
+          end
+          name ||= super_class_name && absolute_name(super_class_name).yield_self do |absolute_name|
+            absolute_name if checker.builder.signatures.class_name?(absolute_name)
+          end
+
+          if name
+            signature = checker.builder.signatures.find_class(name)
+            AST::Annotation::Implements::Module.new(name: name,
+                                                    args: signature.params&.variables || [])
           end
         end
       end
 
+      if annots.implement_module_annotation
+        new_class_name = implement_module_name.name
+      end
+
       if implement_module_name
         class_name = implement_module_name.name
         class_args = implement_module_name.args.map {|x| AST::Types::Var.new(name: x) }
@@ -416,7 +430,8 @@ module Steep
         module_type: annots.self_type || annots.module_type || module_type,
         implement_name: implement_module_name,
         current_namespace: new_namespace,
-        const_env: class_const_env
+        const_env: class_const_env,
+        class_name: absolute_name(new_class_name)
       )
 
       class_type_env = TypeInference::TypeEnv.build(
@@ -702,7 +717,7 @@ module Steep
             if send_node.type == :lambda
               type_lambda(node, block_params: params, block_body: body, type_hint: hint)
             else
-              type_send(node, send_node: send_node, block_params: params, block_body: body)
+              type_send(node, send_node: send_node, block_params: params, block_body: body, unwrap: send_node.type == :csend)
             end
           end
 
@@ -1151,11 +1166,12 @@ module Steep
               expand_alias(hint) do |hint|
                 is_tuple = hint.is_a?(AST::Types::Tuple)
                 is_tuple &&= node.children.all? {|child| child.type != :splat }
-                is_tuple &&= node.children.map.with_index do |child, index|
-                  synthesize(child, hint: hint.types[index])
-                end.yield_self do |types|
-                  tuple = AST::Types::Tuple.new(types: types)
-                  relation = Subtyping::Relation.new(sub_type: tuple, super_type: hint)
+                is_tuple &&= node.children.size >= hint.types.size
+                is_tuple &&= hint.types.map.with_index do |child_type, index|
+                  child_node = node.children[index]
+                  [synthesize(child_node, hint: child_type), child_type]
+                end.all? do |node_type, hint_type|
+                  relation = Subtyping::Relation.new(sub_type: node_type, super_type: hint_type)
                   result = checker.check(relation, constraints: Subtyping::Constraints.empty)
                   result.success?
                 end
@@ -1224,7 +1240,9 @@ module Steep
 
         when :or
           yield_self do
-            t1, t2 = each_child_node(node).map {|child| synthesize(child) }
+            c1, c2 = node.children
+            t1 = synthesize(c1, hint: hint)
+            t2 = synthesize(c2, hint: unwrap(t1))
             type = union_type(unwrap(t1), t2)
             typing.add_typing(node, type)
           end
@@ -1272,7 +1290,7 @@ module Steep
                 if (body = clause.children.last)
                   if var_names && var_types && test_types.all? {|type| type.is_a?(AST::Types::Name::Class) }
                     var_types_in_body = test_types.flat_map {|test_type|
-                      filtered_types = var_types.select {|var_type| var_type.name == test_type.name }
+                      filtered_types = var_types.select {|var_type| var_type.is_a?(AST::Types::Name::Base) && var_type.name == test_type.name }
                       if filtered_types.empty?
                         to_instance_type(test_type)
                       else
@@ -1281,7 +1299,7 @@ module Steep
                     }
                     var_types.reject! {|type|
                       var_types_in_body.any? {|test_type|
-                        test_type.name == type.name
+                        type.is_a?(AST::Types::Name::Base) && test_type.name == type.name
                       }
                     }
 
@@ -1761,7 +1779,7 @@ module Steep
         receiver_type = unwrap(receiver_type)
       end
 
-      return_type = case receiver_type
+      return_type = case expand_alias(receiver_type)
                     when AST::Types::Any
                       typing.add_typing node, AST::Builtin.any_type
 
@@ -2041,7 +2059,7 @@ module Steep
           )
         else
           hash_elements = params.required_keywords.merge(
-            method_type.optional_keywords.transform_values do |type|
+            method_type.params.optional_keywords.transform_values do |type|
               AST::Types::Union.build(types: [type, AST::Builtin.nil_type],
                                       location: method_type.location)
             end
@@ -2465,10 +2483,12 @@ module Steep
         when annotations.instance_dynamics.include?(method_name)
           # ok
         else
-          typing.add_error Errors::MethodDefinitionMissing.new(node: node,
-                                                               module_name: module_name.name,
-                                                               kind: :instance,
-                                                               missing_method: method_name)
+          if module_name.name == module_context&.class_name
+            typing.add_error Errors::MethodDefinitionMissing.new(node: node,
+                                                                 module_name: module_name.name,
+                                                                 kind: :instance,
+                                                                 missing_method: method_name)
+          end
         end
       end
       expected_module_method_names.each do |method_name|
@@ -2478,10 +2498,12 @@ module Steep
         when annotations.module_dynamics.include?(method_name)
           # ok
         else
-          typing.add_error Errors::MethodDefinitionMissing.new(node: node,
-                                                               module_name: module_name.name,
-                                                               kind: :module,
-                                                               missing_method: method_name)
+          if module_name.name == module_context&.class_name
+            typing.add_error Errors::MethodDefinitionMissing.new(node: node,
+                                                                 module_name: module_name.name,
+                                                                 kind: :module,
+                                                                 missing_method: method_name)
+          end
         end
       end
 
@@ -2659,7 +2681,8 @@ module Steep
     end
 
     def try_hash_type(node, hint)
-      if hint.is_a?(AST::Types::Record)
+      case hint
+      when AST::Types::Record
         typing.new_child do |child_typing|
           new_construction = with_new_typing(child_typing)
           elements = {}
@@ -2699,6 +2722,10 @@ module Steep
           hash = AST::Types::Record.new(elements: elements)
           typing.add_typing(node, hash)
         end
+      when AST::Types::Union
+        hint.types.find do |type|
+          try_hash_type(node, type)
+        end
       end
     end
   end

data/lib/steep/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "0.9.0"
+  VERSION = "0.10.0"
 end

data/lib/steep.rb

@@ -7,6 +7,8 @@ require "active_support/core_ext/object/try"
 require "logger"
 require "active_support/tagged_logging"
 require "rainbow"
+require "listen"
+require 'pry'
 
 require "steep/ast/namespace"
 require "steep/names"
@@ -72,13 +74,17 @@ require "steep/type_inference/block_params"
 require "steep/type_inference/constant_env"
 require "steep/type_inference/type_env"
 
-require "steep/drivers/utils/validator"
+require "steep/project"
+require "steep/project/file"
+require "steep/project/listener"
+require "steep/project/options"
 require "steep/drivers/utils/each_signature"
 require "steep/drivers/check"
 require "steep/drivers/validate"
 require "steep/drivers/annotations"
 require "steep/drivers/scaffold"
 require "steep/drivers/print_interface"
+require "steep/drivers/watch"
 
 if ENV["NO_COLOR"]
   Rainbow.enabled = false

data/sig/project.rbi

@@ -0,0 +1,106 @@
+class Pathname
+end
+
+class Time
+  def self.now: -> instance
+  def < : (Time) -> bool
+  def >=: (Time) -> bool
+end
+
+type annotation = any
+
+class Steep::Source
+  def self.parse: (String, path: String, labeling: any) -> instance
+  def annotations: (block: any, builder: any, current_module: any) -> Array<annotation>
+  def node: -> any
+end
+
+class Steep::Typing
+  attr_reader errors: Array<type_error>
+  attr_reader nodes: any
+end
+
+type type_error = any
+
+class Steep::Project::Options
+  attr_accessor fallback_any_is_error: bool
+  attr_accessor allow_missing_definitions: bool
+end
+
+class Parser::SyntaxError
+end
+
+class Steep::Project::SourceFile
+  attr_reader options: Options
+  attr_reader path: Pathname
+  attr_accessor content: String
+  attr_reader content_updated_at: Time
+
+  attr_reader source: (Source | Parser::SyntaxError | nil)
+  attr_reader typing: Typing?
+  attr_reader last_type_checked_at: Time?
+
+  def initialize: (path: Pathname, options: Options) -> any
+  def requires_type_check?: -> bool
+  def invalidate: -> void
+  def parse: -> (Source | Parser::SyntaxError)
+  def errors: -> Array<type_error>?
+  def type_check: (any) -> void
+end
+
+class Steep::Project::SignatureFile
+  attr_reader path: Pathname
+  attr_accessor content: String
+  attr_reader content_updated_at: Time
+
+  def parse: -> Array<any>
+end
+
+interface Steep::Project::_Listener
+  def parse_signature: <'x> (project: Project, file: SignatureFile) { -> 'x } -> 'x
+  def parse_source: <'x> (project: Project, file: SourceFile) { -> 'x } -> 'x
+  def check: <'x> (project: Project) { -> 'x } -> 'x
+  def load_signature: <'x> (project: Project) { -> 'x } -> 'x
+  def validate_signature: <'x> (project: Project) { -> 'x } -> 'x
+  def type_check_source: <'x> (project: Project, file: SourceFile) { -> 'x } -> 'x
+  def clear_project: <'x> (project: Project) { -> 'x } -> 'x
+end
+
+class Steep::Project::SignatureLoaded
+  attr_reader check: any
+  attr_reader loaded_at: Time
+  attr_reader file_paths: Array<Pathname>
+
+  def initialize: (check: any, loaded_at: Time, file_paths: Array<Pathname>) -> any
+end
+
+class Steep::Project::SignatureHasSyntaxError
+  attr_reader errors: Hash<Pathname, any>
+  def initialize: (errors: Hash<Pathname, any>) -> any
+end
+
+class Steep::Project::SignatureHasError
+  attr_reader errors: Array<any>
+  def initialize: (errors: Array<any>) -> any
+end
+
+class Steep::Project
+  attr_reader listener: _Listener
+  attr_reader source_files: Hash<Pathname, SourceFile>
+  attr_reader signature_files: Hash<Pathname, SignatureFile>
+
+  attr_reader signature: (SignatureLoaded | SignatureHasError | SignatureHasSyntaxError | nil)
+
+  def initialize: (?_Listener?) -> any
+  def clear: -> void
+  def type_check: (?force_signatures: bool, ?force_sources: bool) -> void
+
+  def success?: -> bool
+  def has_type_error?: -> bool
+  def errors: -> Array<type_error>
+  def each_updated_source: (?force: bool) { (SourceFile) -> void } -> void
+                         | (?force: bool) -> Enumerator<SourceFile, void>
+  def signature_updated?: -> bool
+  def reload_signature: -> void
+  def validate_signature: (any) -> Array<any>
+end

data/smoke/hash/f.rb

@@ -0,0 +1,11 @@
+# @type method commit: (Hash<Symbol, String?>) -> { repo: String, branch: String?, tag: String?, commit: String? }?
+def commit(hash)
+  if repo = hash[:foo]
+    {
+      repo: repo,
+      branch: hash[:bar],
+      tag: hash[:baz],
+      commit: hash[:commit]
+    }
+  end
+end

data/stdlib/builtin.rbi

@@ -240,6 +240,9 @@ class Hash<'key, 'value>
   def key?: ('key) -> bool
   def merge: (Hash<'key, 'value>) -> Hash<'key, 'value>
   def delete: ('key) -> 'value?
+  def each_value: { ('value) -> void } -> self
+                | -> Enumerator<'valud, self>
+  def empty?: -> bool
 
   include Enumerable<['key, 'value], self>
 end

data/steep.gemspec

@@ -24,7 +24,7 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = '>= 2.5.0'
 
-  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "bundler", ">= 1.13"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "minitest", "~> 5.0"
   spec.add_development_dependency "racc", "~> 1.4"
@@ -33,4 +33,6 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "ast_utils", "~> 0.3.0"
   spec.add_runtime_dependency "activesupport", "~> 5.1"
   spec.add_runtime_dependency "rainbow", "~> 2.2.2", "< 4.0"
+  spec.add_runtime_dependency "listen", "~> 3.1"
+  spec.add_runtime_dependency "pry", "~> 0.12.2"
 end

metadata

@@ -1,27 +1,27 @@
 --- !ruby/object:Gem::Specification
 name: steep
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-11-12 00:00:00.000000000 Z
+date: 2019-03-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.13'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.13'
 - !ruby/object:Gem::Dependency
@@ -128,6 +128,34 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: listen
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.2
 description: Gradual Typing for Ruby
 email:
 - matsumoto@soutaro.com
@@ -189,8 +217,8 @@ files:
 - lib/steep/drivers/print_interface.rb
 - lib/steep/drivers/scaffold.rb
 - lib/steep/drivers/utils/each_signature.rb
-- lib/steep/drivers/utils/validator.rb
 - lib/steep/drivers/validate.rb
+- lib/steep/drivers/watch.rb
 - lib/steep/errors.rb
 - lib/steep/interface/abstract.rb
 - lib/steep/interface/builder.rb
@@ -202,6 +230,10 @@ files:
 - lib/steep/names.rb
 - lib/steep/parser.rb
 - lib/steep/parser.y
+- lib/steep/project.rb
+- lib/steep/project/file.rb
+- lib/steep/project/listener.rb
+- lib/steep/project/options.rb
 - lib/steep/signature/errors.rb
 - lib/steep/source.rb
 - lib/steep/subtyping/check.rb
@@ -220,8 +252,7 @@ files:
 - lib/steep/typing.rb
 - lib/steep/version.rb
 - manual/annotations.md
-- sig/signature.rbi
-- sig/types.rbi
+- sig/project.rbi
 - smoke/alias/a.rb
 - smoke/alias/a.rbi
 - smoke/alias/b.rb
@@ -268,6 +299,7 @@ files:
 - smoke/hash/d.rb
 - smoke/hash/e.rb
 - smoke/hash/e.rbi
+- smoke/hash/f.rb
 - smoke/hello/hello.rb
 - smoke/hello/hello.rbi
 - smoke/if/a.rb

data/lib/steep/drivers/utils/validator.rb

@@ -1,110 +0,0 @@
-module Steep
-  module Drivers
-    module Utils
-      class Validator
-        attr_reader :stdout
-        attr_reader :stderr
-        attr_reader :verbose
-
-        def initialize(stdout:, stderr:, verbose:)
-          @stdout = stdout
-          @stderr = stderr
-          @verbose = verbose
-        end
-
-        def run(env:, builder:, check:)
-          result = true
-
-          env.each do |sig|
-            yield sig if block_given?
-
-            case sig
-            when AST::Signature::Interface
-              yield_self do
-                instance_interface = builder.build_interface(sig.name)
-
-                args = instance_interface.params.map {|var| AST::Types::Var.fresh(var) }
-                instance_type = AST::Types::Name::Interface.new(name: sig.name, args: args)
-
-                instance_interface.instantiate(type: instance_type,
-                                               args: args,
-                                               instance_type: instance_type,
-                                               module_type: nil).validate(check)
-              end
-
-            when AST::Signature::Module
-              yield_self do
-                instance_interface = builder.build_instance(sig.name)
-                instance_args = instance_interface.params.map {|var| AST::Types::Var.fresh(var) }
-
-                module_interface = builder.build_module(sig.name)
-                module_args = module_interface.params.map {|var| AST::Types::Var.fresh(var) }
-
-                instance_type = AST::Types::Name::Instance.new(name: sig.name, args: instance_args)
-                module_type = AST::Types::Name::Module.new(name: sig.name)
-
-                stdout.puts "👀 Validating instance methods..." if verbose
-                instance_interface.instantiate(type: instance_type,
-                                               args: instance_args,
-                                               instance_type: instance_type,
-                                               module_type: module_type).validate(check)
-
-                stdout.puts "👀 Validating class methods..." if verbose
-                module_interface.instantiate(type: module_type,
-                                             args: module_args,
-                                             instance_type: instance_type,
-                                             module_type: module_type).validate(check)
-              end
-
-            when AST::Signature::Class
-              yield_self do
-                instance_interface = builder.build_instance(sig.name)
-                instance_args = instance_interface.params.map {|var| AST::Types::Var.fresh(var) }
-
-                module_interface = builder.build_class(sig.name, constructor: true)
-                module_args = module_interface.params.map {|var| AST::Types::Var.fresh(var) }
-
-                instance_type = AST::Types::Name::Instance.new(name: sig.name, args: instance_args)
-                module_type = AST::Types::Name::Class.new(name: sig.name, constructor: true)
-
-                stdout.puts "👀 Validating instance methods..." if verbose
-                instance_interface.instantiate(type: instance_type,
-                                               args: instance_args,
-                                               instance_type: instance_type,
-                                               module_type: module_type).validate(check)
-
-                stdout.puts "👀 Validating class methods..." if verbose
-                module_interface.instantiate(type: module_type,
-                                             args: module_args,
-                                             instance_type: instance_type,
-                                             module_type: module_type).validate(check)
-              end
-            end
-
-          rescue Interface::Instantiated::InvalidMethodOverrideError => exn
-            result = false
-            stdout.puts "😱 #{exn.message}"
-            exn.result.trace.each do |s, t|
-              case s
-              when Interface::Method
-                stdout.puts "  #{s.name}(#{s.type_name}) <: #{t.name}(#{t.type_name})"
-              when Interface::MethodType
-                stdout.puts "  #{s} <: #{t} (#{s.location&.name||"?"}:#{s.location&.start_line||"?"})"
-              else
-                stdout.puts "  #{s} <: #{t}"
-              end
-            end
-            stdout.puts "  🚨 #{exn.result.error.message}"
-
-          rescue Interface::Instantiated::InvalidIvarOverrideError => exn
-            result = false
-            stdout.puts "😱 #{exn.message}"
-
-          end
-
-          result
-        end
-      end
-    end
-  end
-end