steep 0.31.1 → 0.36.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5fa95738ddb4d770cdba53deb56b05f2ad86523729852ac16823bfb433470a19
-  data.tar.gz: 9c295a1c5f1d28c1b9ae76b0693c582911770185828e18ce114f062a05fd4d24
+  metadata.gz: 5203340eb3b3534da5f1071cc497bbe7a481553e909088277c83dbfe5e5c0bbc
+  data.tar.gz: 11863c0ea9b692de6fba552ec01645525240c025c598235f9b3bf88e35571ed5
 SHA512:
-  metadata.gz: 709a0883a3c698f8ca2246763a9c18e8af04072aa6edf7ca5e339a5c6d6e079693e1405c543fe8690276d4eebdcc35e5b65077dcba4c3dca2e1f102e84906e9b
-  data.tar.gz: 3eeef0c3d9cfd34a7678ab8b4f5f125e949d56706510aa1619f018c1346242e10452045b00a09b117bdbec9b5aa27f577ba6ec01c4f732335e9f69dfcf88e228
+  metadata.gz: 9897fecb7ca5b60da9eeb236e5f06af1a9b2fa2a2df2bd87d07f7a496f0f05b988b30db2e294797304c6d7f0e8fe478cdc1d41049cbaf2e56c45108444b2c721
+  data.tar.gz: fa2dca2cd37d74e39878ab3da7a5453a714f50e921fcd1c0e75054bf083a11003cb5799f4f92531a10bce6074dce3cce88c90daeb214b9fb45d7f5612e294fb3

data/CHANGELOG.md

@@ -2,6 +2,33 @@
 
 ## master
 
+## 0.36.0 (2020-11-16)
+
+* Flow-sensitive typing improvements with `||` and `&&` ([#260](https://github.com/soutaro/steep/pull/260))
+* Type-case improvement ([#259](https://github.com/soutaro/steep/pull/259))
+* Subtyping between `bool` and logic types ([#258](https://github.com/soutaro/steep/pull/258))
+
+## 0.35.0 (2020-11-14)
+
+* Support third party RBS repository ([#231](https://github.com/soutaro/steep/pull/231), [#254](https://github.com/soutaro/steep/pull/254), [#255](https://github.com/soutaro/steep/pull/255))
+* Boolean type semantics update ([#252](https://github.com/soutaro/steep/pull/252))
+* More flexible record typing ([#256](https://github.com/soutaro/steep/pull/256))
+
+## 0.34.0 (2020-10-27)
+
+* Add `steep stats` command to show method call typing stats ([#246](https://github.com/soutaro/steep/pull/246))
+* Fix attribute assignment typing ([#243](https://github.com/soutaro/steep/pull/243))
+* Let `Range[T]` be covariant ([#242](https://github.com/soutaro/steep/pull/242))
+* Fix constant typing ([#247](https://github.com/soutaro/steep/pull/247), [#248](https://github.com/soutaro/steep/pull/248))
+
+## 0.33.0 (2020-10-13)
+
+* Make `!` typing flow sensitive ([#240](https://github.com/soutaro/steep/pull/240))
+
+## 0.32.0 (2020-10-09)
+
+* Let type-case support interface types ([#237](https://github.com/soutaro/steep/pull/237))
+
 ## 0.31.1 (2020-10-07)
 
 * Fix `if-then-else` parsing ([#236](https://github.com/soutaro/steep/pull/236))

data/lib/steep.rb

@@ -16,7 +16,7 @@ require 'uri'
 
 require "rbs"
 
-require "steep/ast/location"
+require "steep/method_name"
 require "steep/ast/types/helper"
 require "steep/ast/types/any"
 require "steep/ast/types/instance"
@@ -39,7 +39,6 @@ require "steep/ast/types/logic"
 require "steep/ast/type_params"
 require "steep/ast/annotation"
 require "steep/ast/annotation/collection"
-require "steep/ast/buffer"
 require "steep/ast/builtin"
 require "steep/ast/types/factory"
 
@@ -72,6 +71,7 @@ require "steep/type_inference/type_env"
 require "steep/type_inference/local_variable_type_env"
 require "steep/type_inference/logic"
 require "steep/type_inference/logic_type_interpreter"
+require "steep/type_inference/method_call"
 require "steep/ast/types"
 
 require "steep/server/utils"
@@ -93,6 +93,7 @@ require "steep/project/hover_content"
 require "steep/project/completion_provider"
 require "steep/drivers/utils/driver_helper"
 require "steep/drivers/check"
+require "steep/drivers/stats"
 require "steep/drivers/validate"
 require "steep/drivers/annotations"
 require "steep/drivers/watch"

data/lib/steep/annotation_parser.rb

@@ -68,7 +68,7 @@ module Steep
           name = match[:name]
           type = match[:type]
 
-          method_type = factory.method_type(RBS::Parser.parse_method_type(type), self_type: AST::Types::Self.new)
+          method_type = factory.method_type(RBS::Parser.parse_method_type(type), self_type: AST::Types::Self.new, method_decls: Set[])
 
           AST::Annotation::MethodType.new(name: name.to_sym,
                                           type: method_type,

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

@@ -149,6 +149,8 @@ module Steep
               type: function_1(type.params, type.return_type),
               location: nil
             )
+          when Logic::Base
+            RBS::Types::Bases::Bool.new(location: nil)
           else
             raise "Unexpected type given: #{type} (#{type.class})"
           end
@@ -178,7 +180,7 @@ module Steep
           )
         end
 
-        def method_type(method_type, self_type:, subst2: nil, method_def: nil)
+        def method_type(method_type, self_type:, subst2: nil, method_decls:)
           fvs = self_type.free_variables()
 
           type_params = []
@@ -209,8 +211,7 @@ module Steep
                                return_type: type(block.type.return_type).subst(subst), location: nil)
               )
             end,
-            method_def: method_def,
-            location: method_def&.member&.location
+            method_decls: method_decls
           )
 
           if block_given?
@@ -342,48 +343,46 @@ module Steep
           end
         end
 
-        def setup_primitives(method_name, method_type)
-          if method_def = method_type.method_def
-            defined_in = method_def.defined_in
-            member = method_def.member
-
-            if member.is_a?(RBS::AST::Members::MethodDefinition)
-              case
-              when defined_in == RBS::BuiltinNames::Object.name && member.instance?
-                case method_name
-                when :is_a?, :kind_of?, :instance_of?
-                  return method_type.with(
-                    return_type: AST::Types::Logic::ReceiverIsArg.new(location: method_type.return_type.location)
-                  )
-                when :nil?
-                  return method_type.with(
-                    return_type: AST::Types::Logic::ReceiverIsNil.new(location: method_type.return_type.location)
-                  )
-                end
+        NilClassName = TypeName("::NilClass")
 
-              when defined_in == AST::Builtin::NilClass.module_name && member.instance?
-                case method_name
-                when :nil?
-                  return method_type.with(
-                    return_type: AST::Types::Logic::ReceiverIsNil.new(location: method_type.return_type.location)
-                  )
-                end
+        def setup_primitives(method_name, method_def, method_type)
+          defined_in = method_def.defined_in
+          member = method_def.member
 
-              when defined_in == RBS::BuiltinNames::BasicObject.name && member.instance?
-                case method_name
-                when :!
-                  return method_type.with(
-                    return_type: AST::Types::Logic::Not.new(location: method_type.return_type.location)
-                  )
-                end
+          if member.is_a?(RBS::AST::Members::MethodDefinition)
+            case method_name
+            when :is_a?, :kind_of?, :instance_of?
+              if defined_in == RBS::BuiltinNames::Object.name && member.instance?
+                return method_type.with(
+                  return_type: AST::Types::Logic::ReceiverIsArg.new(location: method_type.return_type.location)
+                )
+              end
 
-              when defined_in == RBS::BuiltinNames::Module.name && member.instance?
-                case method_name
-                when :===
-                  return method_type.with(
-                    return_type: AST::Types::Logic::ArgIsReceiver.new(location: method_type.return_type.location)
-                  )
-                end
+            when :nil?
+              case defined_in
+              when RBS::BuiltinNames::Object.name,
+                NilClassName
+                return method_type.with(
+                  return_type: AST::Types::Logic::ReceiverIsNil.new(location: method_type.return_type.location)
+                )
+              end
+
+            when :!
+              case defined_in
+              when RBS::BuiltinNames::BasicObject.name,
+                RBS::BuiltinNames::TrueClass.name,
+                RBS::BuiltinNames::FalseClass.name
+                return method_type.with(
+                  return_type: AST::Types::Logic::Not.new(location: method_type.return_type.location)
+                )
+              end
+
+            when :===
+              case defined_in
+              when RBS::BuiltinNames::Module.name
+                return method_type.with(
+                  return_type: AST::Types::Logic::ArgIsReceiver.new(location: method_type.return_type.location)
+                )
               end
             end
           end
@@ -409,7 +408,7 @@ module Steep
             else
               raise "Unexpected `self` type interface"
             end
-            
+
           when Name::Instance
             Interface::Interface.new(type: self_type, private: private).tap do |interface|
               definition = definition_builder.build_instance(type.name)
@@ -433,10 +432,13 @@ module Steep
 
                   interface.methods[name] = Interface::Interface::Entry.new(
                     method_types: method.defs.map do |type_def|
+                      method_name = InstanceMethodName.new(type_name: type_def.implemented_in || type_def.defined_in, method_name: name)
+                      decl = TypeInference::MethodCall::MethodDecl.new(method_name: method_name, method_def: type_def)
                       setup_primitives(
                         name,
+                        type_def,
                         method_type(type_def.type,
-                                    method_def: type_def,
+                                    method_decls: Set[decl],
                                     self_type: self_type,
                                     subst2: subst)
                       )
@@ -460,7 +462,11 @@ module Steep
               definition.methods.each do |name, method|
                 interface.methods[name] = Interface::Interface::Entry.new(
                   method_types: method.defs.map do |type_def|
-                    method_type(type_def.type, method_def: type_def, self_type: self_type, subst2: subst)
+                    decls = Set[TypeInference::MethodCall::MethodDecl.new(
+                      method_name: InstanceMethodName.new(type_name: type_def.implemented_in || type_def.defined_in, method_name: name),
+                      method_def: type_def
+                    )]
+                    method_type(type_def.type, method_decls: decls, self_type: self_type, subst2: subst)
                   end
                 )
               end
@@ -485,10 +491,16 @@ module Steep
 
                 interface.methods[name] = Interface::Interface::Entry.new(
                   method_types: method.defs.map do |type_def|
+                    decl = TypeInference::MethodCall::MethodDecl.new(
+                      method_name: SingletonMethodName.new(type_name: type_def.implemented_in || type_def.defined_in,
+                                                           method_name: name),
+                      method_def: type_def
+                    )
                     setup_primitives(
                       name,
+                      type_def,
                       method_type(type_def.type,
-                                  method_def: type_def,
+                                  method_decls: Set[decl],
                                   self_type: self_type,
                                   subst2: subst)
                     )
@@ -568,8 +580,7 @@ module Steep
                                                       rest_keywords: nil),
                         block: nil,
                         return_type: elem_type,
-                        method_def: nil,
-                        location: nil
+                        method_decls: Set[]
                       )
                     } + aref.method_types
                   )
@@ -588,8 +599,7 @@ module Steep
                                                       rest_keywords: nil),
                         block: nil,
                         return_type: elem_type,
-                        method_def: nil,
-                        location: nil
+                        method_decls: Set[]
                       )
                     } + update.method_types
                   )
@@ -603,8 +613,7 @@ module Steep
                         params: Interface::Params.empty,
                         block: nil,
                         return_type: type.types[0] || AST::Builtin.nil_type,
-                        method_def: nil,
-                        location: nil
+                        method_decls: Set[]
                       )
                     ]
                   )
@@ -618,8 +627,7 @@ module Steep
                         params: Interface::Params.empty,
                         block: nil,
                         return_type: type.types.last || AST::Builtin.nil_type,
-                        method_def: nil,
-                        location: nil
+                        method_decls: Set[]
                       )
                     ]
                   )
@@ -640,6 +648,7 @@ module Steep
                   Interface::Interface::Entry.new(
                     method_types: type.elements.map {|key_value, value_type|
                       key_type = Literal.new(value: key_value, location: nil)
+
                       Interface::MethodType.new(
                         type_params: [],
                         params: Interface::Params.new(required: [key_type],
@@ -650,8 +659,7 @@ module Steep
                                                       rest_keywords: nil),
                         block: nil,
                         return_type: value_type,
-                        method_def: nil,
-                        location: nil
+                        method_decls: Set[]
                       )
                     } + ref.method_types
                   )
@@ -671,8 +679,7 @@ module Steep
                                                       rest_keywords: nil),
                         block: nil,
                         return_type: value_type,
-                        method_def: nil,
-                        location: nil
+                        method_decls: Set[]
                       )
                     } + update.method_types
                   )
@@ -687,8 +694,7 @@ module Steep
                 params: type.params,
                 return_type: type.return_type,
                 block: nil,
-                method_def: nil,
-                location: nil
+                method_decls: Set[]
               )
 
               interface.methods[:[]] = Interface::Interface::Entry.new(method_types: [method_type])

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

@@ -18,7 +18,7 @@ module Steep
           end
 
           def ==(other)
-            other.class ==self.class
+            other.class == self.class
           end
 
           alias eql? ==
@@ -57,6 +57,25 @@ module Steep
             @location = location
           end
         end
+
+        class Env < Base
+          attr_reader :truthy, :falsy
+
+          def initialize(truthy:, falsy:, location: nil)
+            @truthy = truthy
+            @falsy = falsy
+          end
+
+          def ==(other)
+            other.is_a?(Env) && other.truthy == truthy && other.falsy == falsy
+          end
+
+          alias eql? ==
+
+          def hash
+            self.class.hash ^ truthy.hash ^ falsy.hash
+          end
+        end
       end
     end
   end

data/lib/steep/cli.rb

@@ -16,7 +16,7 @@ module Steep
     end
 
     def self.available_commands
-      [:init, :check, :validate, :annotations, :version, :project, :watch, :langserver, :vendor]
+      [:init, :check, :validate, :annotations, :version, :project, :watch, :langserver, :stats]
     end
 
     def process_global_options
@@ -34,7 +34,7 @@ module Steep
 
     def setup_command
       @command = argv.shift&.to_sym
-      if CLI.available_commands.include?(@command) || @command == :worker
+      if CLI.available_commands.include?(@command) || @command == :worker || @command == :vendor
         true
       else
         stderr.puts "Unknown command: #{command}"
@@ -91,6 +91,19 @@ module Steep
       end.run
     end
 
+    def process_stats
+      Drivers::Stats.new(stdout: stdout, stderr: stderr).tap do |check|
+        OptionParser.new do |opts|
+          opts.banner = "Usage: steep stats [options] [sources]"
+
+          opts.on("--steepfile=PATH") {|path| check.steepfile = Pathname(path) }
+          handle_logging_options opts
+        end.parse!(argv)
+
+        check.command_line_patterns.push *argv
+      end.run
+    end
+
     def process_validate
       Drivers::Validate.new(stdout: stdout, stderr: stderr).tap do |command|
         OptionParser.new do |opts|

data/lib/steep/drivers/print_project.rb

@@ -47,6 +47,17 @@ module Steep
           target.options.libraries.each do |lib|
             stdout.puts "      - #{lib}"
           end
+          stdout.puts "    library dirs:"
+          Project::Target.construct_env_loader(options: target.options).tap do |loader|
+            loader.each_dir do |lib, path|
+              case lib
+              when :core
+                stdout.puts "      - core: #{path}"
+              else
+                stdout.puts "      - #{lib.name}: #{path}"
+              end
+            end
+          end
         end
 
         0

data/lib/steep/drivers/stats.rb

@@ -0,0 +1,85 @@
+require "csv"
+
+module Steep
+  module Drivers
+    class Stats
+      attr_reader :stdout
+      attr_reader :stderr
+      attr_reader :command_line_patterns
+
+      include Utils::DriverHelper
+
+      def initialize(stdout:, stderr:)
+        @stdout = stdout
+        @stderr = stderr
+        @command_line_patterns = []
+      end
+
+      def run
+        project = load_config()
+
+        loader = Project::FileLoader.new(project: project)
+        loader.load_sources(command_line_patterns)
+        loader.load_signatures()
+
+        type_check(project)
+
+        stdout.puts(
+          CSV.generate do |csv|
+            csv << ["Target", "File", "Status", "Typed calls", "Untyped calls", "All calls", "Typed %"]
+
+            project.targets.each do |target|
+              case (status = target.status)
+              when Project::Target::TypeCheckStatus
+                status.type_check_sources.each do |source_file|
+                  case source_file.status
+                  when Project::SourceFile::TypeCheckStatus
+                    typing = source_file.status.typing
+
+                    typed = 0
+                    untyped = 0
+                    total = 0
+                    typing.method_calls.each_value do |call|
+                      case call
+                      when TypeInference::MethodCall::Typed
+                        typed += 1
+                      when TypeInference::MethodCall::Untyped
+                        untyped += 1
+                      end
+
+                      total += 1
+                    end
+
+                    csv << format_stats(target, source_file.path, "success", typed, untyped, total)
+                  when Project::SourceFile::TypeCheckErrorStatus
+                    csv << format_stats(target, source_file.path, "error", 0, 0, 0)
+                  else
+                    csv << format_stats(target, source_file.path, "unknown (#{source_file.status.class.to_s.split(/::/).last})", 0, 0, 0)
+                  end
+                end
+              end
+            end
+          end
+        )
+
+        0
+      end
+
+      def format_stats(target, path, status, typed, untyped, total)
+        [
+          target.name,
+          path.to_s,
+          status,
+          typed,
+          untyped,
+          total,
+          if total.nonzero?
+            format("%.2f", (typed.to_f/total)*100)
+          else
+            0
+          end
+        ]
+      end
+    end
+  end
+end