steep 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 05a765d5cdc7792406c32f581e041ee9e47b41c1b70dfb0d43e8db5400fbe172
-  data.tar.gz: 71e35e1516a261d82082e1278774ff0a8d36c5ffecdd8511ba8de312b93a16f8
+  metadata.gz: 63ee9143e226c595a96dd859109327d66f97ab2c428601c30f771a12a21a1603
+  data.tar.gz: ec8d8d3cdcde5c0e37c73fdb70faeb0887b5b36ae1590d57dbab1feea95f86ad
 SHA512:
-  metadata.gz: b721b3ac5bb01d3296071025ef72a7e2ab76f4900bdfb0909ee8a715642d371812185c4adc74585344a156c43af742e0e35782b8dc9f89966da6d558e7f87f83
-  data.tar.gz: 3849077a1ea0d7109eb3b148be3dc2e8260f9cc63df17cb1864235fa2137faa984947a64d95343524c1b34d75fcf4ff9ada215488e15977bcc657359da3cac4c
+  metadata.gz: 5297a41597af66524e848e02f2c6f6b33d53d9fc52aac03280ec438845414e306dc3ce6a86b643608d34e89e1cabacfc75262013f7f78970661af88d4679f624
+  data.tar.gz: 610747408983f5e98ee292b5a3795e7b61c8dd74b6d255e3768f5c3658676f63c7dd8157cf7cbba492c98d36806e9c08482dcf5d58474e7ffaaaf78ea93c1157

data/CHANGELOG.md

@@ -2,7 +2,14 @@
 
 ## master
 
-## 0.8.3 (2018-11-11)
+## 0.10.0 (2019-03-05)
+
+* Add `watch` subcommand (#77)
+* Automatically `@implements` super class if the class definition inherits
+* Fix tuple typing
+* Fix `or` typing
+
+## 0.9.0 (2018-11-11)
 
 * Private methods (#72)
 * `__skip__` to skip type checking (#73)

data/lib/steep/ast/types/proc.rb

@@ -50,7 +50,7 @@ module Steep
         end
 
         def with_location(new_location)
-          self.class.new(location: new_location)
+          self.class.new(location: new_location, params: params, return_type: return_type)
         end
 
         def map_type(&block)

data/lib/steep/cli.rb

@@ -89,7 +89,7 @@ module Steep
       end
 
       def paths
-        options = if @options.none? {|option| option.is_a?(Pathname) }
+        options = if @options.none? {|option| option.is_a?(Pathname) } && Pathname("sig").directory?
                     @options + [Pathname("sig")]
                   else
                     @options
@@ -132,7 +132,7 @@ module Steep
     end
 
     def self.available_commands
-      [:check, :validate, :annotations, :scaffold, :interface, :version, :paths]
+      [:check, :validate, :annotations, :scaffold, :interface, :version, :paths, :watch]
     end
 
     def process_global_options
@@ -228,13 +228,11 @@ module Steep
     def process_annotations
       source_paths = argv.map {|file| Pathname(file) }
       Drivers::Annotations.new(source_paths: source_paths, stdout: stdout, stderr: stderr).run
-      0
     end
 
     def process_scaffold
       source_paths = argv.map {|file| Pathname(file) }
       Drivers::Scaffold.new(source_paths: source_paths, stdout: stdout, stderr: stderr).run
-      0
     end
 
     def process_interface
@@ -244,6 +242,29 @@ module Steep
         end.parse!(argv)
 
         Drivers::PrintInterface.new(type_name: argv.first, signature_dirs: signature_options.paths, stdout: stdout, stderr: stderr).run
+      end
+    end
+
+    def process_watch
+      with_signature_options do |signature_options|
+        strict = false
+        fallback_any_is_error = false
+
+        OptionParser.new do |opts|
+          handle_dir_options opts, signature_options
+          opts.on("--strict") { strict = true }
+          opts.on("--fallback-any-is-error") { fallback_any_is_error = true }
+        end.parse!(argv)
+
+        source_dirs = argv.map {|path| Pathname(path) }
+        if source_dirs.empty?
+          source_dirs << Pathname(".")
+        end
+
+        Drivers::Watch.new(source_dirs: source_dirs, signature_dirs: signature_options.paths, stdout: stdout, stderr: stderr).tap do |driver|
+          driver.options.fallback_any_is_error = fallback_any_is_error || strict
+          driver.options.allow_missing_definitions = false if strict
+        end.run
 
         0
       end

data/lib/steep/drivers/annotations.rb

@@ -17,10 +17,21 @@ module Steep
       end
 
       def run
-        each_ruby_source(source_paths, false) do |source|
-          source.each_annotation.sort_by {|node, _| [node.loc.expression.begin_pos, node.loc.expression.end_pos] }.each do |node, annotations|
+        project = Project.new()
+
+        source_paths.each do |path|
+          each_file_in_path(".rb", path) do |file_path|
+            file = Project::SourceFile.new(path: file_path, options: Project::Options.new)
+            file.content = file_path.read
+            project.source_files[file_path] = file
+          end
+        end
+
+        project.source_files.each_value do |file|
+          file.parse
+          file.source.each_annotation.sort_by {|node, _| [node.loc.expression.begin_pos, node.loc.expression.end_pos] }.each do |node, annotations|
             loc = node.loc
-            stdout.puts "#{source.path}:#{loc.line}:#{loc.column}:#{node.type}:\t#{node.loc.expression.source.lines.first}"
+            stdout.puts "#{file.path}:#{loc.line}:#{loc.column}:#{node.type}:\t#{node.loc.expression.source.lines.first}"
             annotations.each do |annotation|
               stdout.puts "  #{annotation.location.source}"
             end

data/lib/steep/drivers/check.rb

@@ -27,106 +27,102 @@ module Steep
         self.dump_all_types = false
         self.fallback_any_is_error = false
         self.allow_missing_definitions = true
+      end
 
-        @labeling = ASTUtils::Labeling.new
+      def options
+        Project::Options.new.tap do |opt|
+          opt.allow_missing_definitions = allow_missing_definitions
+          opt.fallback_any_is_error = fallback_any_is_error
+        end
       end
 
       def run
         Steep.logger.level = Logger::DEBUG if verbose
 
-        env = AST::Signature::Env.new
+        project = Project.new(Project::SyntaxErrorRaisingListener.new)
 
-        each_signature(signature_dirs, verbose) do |signature|
-          env.add signature
+        source_paths.each do |path|
+          each_file_in_path(".rb", path) do |file_path|
+            file = Project::SourceFile.new(path: file_path, options: options)
+            file.content = file_path.read
+            project.source_files[file_path] = file
+          end
         end
 
-        builder = Interface::Builder.new(signatures: env)
-        check = Subtyping::Check.new(builder: builder)
-
-        validator = Utils::Validator.new(stdout: stdout, stderr: stderr, verbose: verbose)
-
-        validated = validator.run(env: env, builder: builder, check: check) do |sig|
-          stderr.puts "Validating #{sig.name} (#{sig.location.name}:#{sig.location.start_line})..." if verbose
+        signature_dirs.each do |path|
+          each_file_in_path(".rbi", path) do |file_path|
+            file = Project::SignatureFile.new(path: file_path)
+            file.content = file_path.read
+            project.signature_files[file_path] = file
+          end
         end
 
-        unless validated
-          return 1
-        end
+        project.type_check
 
-        sources = []
-        each_ruby_source(source_paths, verbose) do |source|
-          sources << source
+        case signature = project.signature
+        when Project::SignatureLoaded
+          output_type_check_result(project)
+          project.has_type_error? ? 1 : 0
+        when Project::SignatureHasError
+          output_signature_errors(project)
+          1
         end
+      end
 
-        typing = Typing.new
-
-        sources.each do |source|
-          Steep.logger.tagged source.path do
-            Steep.logger.debug "Typechecking..."
-            annotations = source.annotations(block: source.node, builder: check.builder, current_module: AST::Namespace.root)
-
-            const_env = TypeInference::ConstantEnv.new(builder: check.builder, context: nil)
-            type_env = TypeInference::TypeEnv.build(annotations: annotations,
-                                                    subtyping: check,
-                                                    const_env: const_env,
-                                                    signatures: check.builder.signatures)
-
-            construction = TypeConstruction.new(
-              checker: check,
-              annotations: annotations,
-              source: source,
-              self_type: AST::Builtin::Object.instance_type,
-              block_context: nil,
-              module_context: TypeConstruction::ModuleContext.new(
-                instance_type: nil,
-                module_type: nil,
-                implement_name: nil,
-                current_namespace: AST::Namespace.root,
-                const_env: const_env
-              ),
-              method_context: nil,
-              typing: typing,
-              break_context: nil,
-              type_env: type_env
-              )
-            construction.synthesize(source.node)
-          end
-        end
+      def output_type_check_result(project)
+        # @type var project: Project
 
         if dump_all_types
-          lines = []
-
-          typing.nodes.each_value do |node|
-            begin
-              type = typing.type_of(node: node)
-              lines << [node.loc.expression.source_buffer.name, [node.loc.last_line,node.loc.last_column], [node.loc.first_line, node.loc.column], node, type]
-            rescue
-              lines << [node.loc.expression.source_buffer.name, [node.loc.last_line,node.loc.last_column], [node.loc.first_line, node.loc.column], node, nil]
+          project.source_files.each_value do |file|
+            lines = []
+
+            if typing = file.typing
+              typing.nodes.each_value do |node|
+                begin
+                  type = typing.type_of(node: node)
+                  lines << [node.loc.expression.source_buffer.name, [node.loc.last_line,node.loc.last_column], [node.loc.first_line, node.loc.column], node, type]
+                rescue
+                  lines << [node.loc.expression.source_buffer.name, [node.loc.last_line,node.loc.last_column], [node.loc.first_line, node.loc.column], node, nil]
+                end
+              end
+
+              lines.sort {|x,y| y <=> x }.reverse_each do |line|
+                source = line[3].loc.expression.source
+                stdout.puts "#{line[0]}:(#{line[2].join(",")}):(#{line[1].join(",")}):\t#{line[3].type}:\t#{line[4]}\t(#{source.split(/\n/).first})"
+              end
             end
           end
+        end
 
-          lines.sort {|x,y| y <=> x }.reverse_each do |line|
-            source = line[3].loc.expression.source
-            stdout.puts "#{line[0]}:(#{line[2].join(",")}):(#{line[1].join(",")}):\t#{line[3].type}:\t#{line[4]}\t(#{source.split(/\n/).first})"
+        project.source_files.each_value do |file|
+          file.errors&.each do |error|
+            error.print_to stdout
           end
         end
+      end
 
-        errors = typing.errors.select do |error|
-          case
-          when error.is_a?(Errors::FallbackAny) && !fallback_any_is_error
-            false
-          when error.is_a?(Errors::MethodDefinitionMissing) && allow_missing_definitions
-            false
+      def output_signature_errors(project)
+        project.signature.errors.each do |error|
+          case error
+          when Interface::Instantiated::InvalidMethodOverrideError
+            stdout.puts "😱 #{error.message}"
+            error.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 "  🚨 #{error.result.error.message}"
+          when Interface::Instantiated::InvalidIvarOverrideError
+            stdout.puts "😱 #{error.message}"
           else
-            true
+            stdout.puts "😱 #{error.inspect}"
           end
         end
-
-        errors.each do |error|
-          error.print_to stdout
-        end
-
-        errors.empty? ? 0 : 1
       end
     end
   end

data/lib/steep/drivers/print_interface.rb

@@ -18,39 +18,70 @@ module Steep
       def run
         if type_name
           type = Parser.parse_type(type_name)
+          project = Project.new()
 
-          env = AST::Signature::Env.new
-
-          each_signature(signature_dirs, false) do |signature|
-            env.add signature
+          signature_dirs.each do |path|
+            each_file_in_path(".rbi", path) do |file_path|
+              file = Project::SignatureFile.new(path: file_path)
+              file.content = file_path.read
+              project.signature_files[file_path] = file
+            end
           end
 
-          begin
-            builder = Interface::Builder.new(signatures: env)
-            check = Subtyping::Check.new(builder: builder)
+          project.reload_signature
 
-            interface = check.resolve(type)
+          case sig = project.signature
+          when Project::SignatureLoaded
+            begin
+              check = sig.check
+              interface = check.resolve(type)
 
-            stdout.puts "#{type}"
-            stdout.puts "- Instance variables:"
-            interface.ivars.each do |name, type|
-              puts "  - #{name}: #{type}"
+              stdout.puts "#{type}"
+              stdout.puts "- Instance variables:"
+              interface.ivars.each do |name, type|
+                puts "  - #{name}: #{type}"
+              end
+              stdout.puts "- Methods:"
+              interface.methods.each do |name, method|
+                puts "  - #{Rainbow(name).blue}:"
+                method.types.each do |method_type|
+                  loc = if method_type.location
+                          "#{method_type.location.buffer.name}:#{method_type.location.to_s}"
+                        else
+                          "no location"
+                        end
+                  puts "    - #{Rainbow(method_type.to_s).red} (#{loc})"
+                end
+              end
+              0
+            rescue Steep::Subtyping::Check::CannotResolveError
+              stderr.puts "🤔 #{Rainbow(type.to_s).red} cannot be resolved to interface"
+              1
             end
-            stdout.puts "- Methods:"
-            interface.methods.each do |name, method|
-              puts "  - #{Rainbow(name).blue}:"
-              method.types.each do |method_type|
-                loc = if method_type.location
-                        "#{method_type.location.buffer.name}:#{method_type.location.to_s}"
-                      else
-                        "no location"
-                      end
-                puts "    - #{Rainbow(method_type.to_s).red} (#{loc})"
+
+          when Project::SignatureHasError
+            sig.errors.each do |error|
+              case error
+              when Interface::Instantiated::InvalidMethodOverrideError
+                stdout.puts "😱 #{error.message}"
+                error.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 "  🚨 #{error.result.error.message}"
+              when Interface::Instantiated::InvalidIvarOverrideError
+                stdout.puts "😱 #{error.message}"
+              else
+                stdout.puts "😱 #{error.inspect}"
               end
             end
-            0
-          rescue Steep::Subtyping::Check::CannotResolveError
-            stderr.puts "🤔 #{Rainbow(type.to_s).red} cannot be resolved to interface"
+
             1
           end
         else

data/lib/steep/drivers/scaffold.rb

@@ -12,13 +12,16 @@ module Steep
         @source_paths = source_paths
         @stdout = stdout
         @stderr = stderr
-
-        @labeling = ASTUtils::Labeling.new
       end
 
       def run
-        each_ruby_source(source_paths, false) do |source|
-          Generator.new(source: source, stderr: stderr).write(io: stdout)
+        source_paths.each do |path|
+          each_file_in_path(".rb", path) do |file_path|
+            file = Project::SourceFile.new(path: file_path, options: Project::Options.new)
+            file.content = file_path.read
+            file.parse
+            Generator.new(source: file.source, stderr: stderr).write(io: stdout)
+          end
         end
         0
       end

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

@@ -2,49 +2,14 @@ module Steep
   module Drivers
     module Utils
       module EachSignature
-        def each_signature(signature_dirs, verbose)
-          signature_dirs.each do |path|
-            if path.file?
-              stderr.puts "Loading signature #{path}..." if verbose
-              Parser.parse_signature(path.read, name: path).each do |signature|
-                yield signature
-              end
-            end
-
-            if path.directory?
-              each_file_in_dir(".rbi", path) do |file|
-                stderr.puts "Loading signature #{file}..." if verbose
-                Parser.parse_signature(file.read, name: file).each do |signature|
-                  yield signature
-                end
-              end
-            end
-          end
-        end
-
-        def each_ruby_source(source_paths, verbose)
-          each_ruby_file source_paths do |file|
-            begin
-              stdout.puts "Loading Ruby program #{file}..." if verbose
-              if (source = Source.parse(file.read, path: file.to_s, labeling: labeling))
-                yield source
-              end
-            rescue => exn
-              Steep.logger.error "Error occured on parsing #{file}: #{exn.inspect}"
-            end
+        def each_file_in_path(suffix, path)
+          if path.file?
+            yield path
           end
-        end
-
-        def each_ruby_file(source_paths)
-          source_paths.each do |path|
-            if path.file?
-              yield path
-            end
 
-            if path.directory?
-              each_file_in_dir(".rb", path) do |file|
-                yield file
-              end
+          if path.directory?
+            each_file_in_dir(suffix, path) do |file|
+              yield file
             end
           end
         end

data/lib/steep/drivers/validate.rb

@@ -19,20 +19,45 @@ module Steep
       def run
         Steep.logger.level = Logger::DEBUG if verbose
 
-        env = AST::Signature::Env.new
+        project = Project.new
 
-        each_signature(signature_dirs, verbose) do |signature|
-          env.add signature
+        signature_dirs.each do |path|
+          each_file_in_path(".rbi", path) do |file_path|
+            file = Project::SignatureFile.new(path: file_path)
+            file.content = file_path.read
+            project.signature_files[file_path] = file
+          end
         end
 
-        builder = Interface::Builder.new(signatures: env)
-        check = Subtyping::Check.new(builder: builder)
+        project.type_check
 
-        validator = Utils::Validator.new(stdout: stdout, stderr: stderr, verbose: verbose)
-
-        validator.run(env: env, builder: builder, check: check) do |sig|
-          stderr.puts "Validating #{sig.name} (#{sig.location.name}:#{sig.location.start_line})..." if verbose
-        end ? 0 : 1
+        case project.signature
+        when Project::SignatureHasError
+          project.signature.errors.each do |error|
+            case error
+            when Interface::Instantiated::InvalidMethodOverrideError
+              stdout.puts "😱 #{error.message}"
+              error.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 "  🚨 #{error.result.error.message}"
+            when Interface::Instantiated::InvalidIvarOverrideError
+              stdout.puts "😱 #{error.message}"
+            else
+              stdout.puts "😱 #{error.inspect}"
+            end
+          end
+          1
+        else
+          0
+        end
       end
     end
   end