steep 1.9.0.dev.2 → 1.9.0

data/lib/steep/type_construction.rb

@@ -357,35 +357,40 @@ module Steep
       end
 
       if implement_module_name
-        module_entry = checker.factory.definition_builder.env.normalized_module_entry(implement_module_name.name) or raise
-
-        module_context = module_context.update(
-          instance_type: AST::Types::Intersection.build(
-            types: [
-              AST::Builtin::Object.instance_type,
-              *module_entry.self_types.map {|module_self|
-                type = case
-                       when module_self.name.interface?
-                         RBS::Types::Interface.new(
-                           name: module_self.name,
-                           args: module_self.args,
-                           location: module_self.location
-                         )
-                       when module_self.name.class?
-                         RBS::Types::ClassInstance.new(
-                           name: module_self.name,
-                           args: module_self.args,
-                           location: module_self.location
-                         )
-                       else
-                         raise
-                       end
-                checker.factory.type(type)
-              },
-              module_context.instance_type
-            ].compact
+        module_entry = checker.factory.definition_builder.env.normalized_module_entry(implement_module_name.name)
+        if module_entry
+          module_context = module_context.update(
+            instance_type: AST::Types::Intersection.build(
+              types: [
+                AST::Builtin::Object.instance_type,
+                *module_entry.self_types.map {|module_self|
+                  type = case
+                        when module_self.name.interface?
+                          RBS::Types::Interface.new(
+                            name: module_self.name,
+                            args: module_self.args,
+                            location: module_self.location
+                          )
+                        when module_self.name.class?
+                          RBS::Types::ClassInstance.new(
+                            name: module_self.name,
+                            args: module_self.args,
+                            location: module_self.location
+                          )
+                        else
+                          raise
+                        end
+                  checker.factory.type(type)
+                },
+                module_context.instance_type
+              ].compact
+            )
           )
-        )
+        elsif checker.factory.definition_builder.env.normalized_class_entry(implement_module_name.name)
+          typing.add_error(
+            Diagnostic::Ruby::ClassModuleMismatch.new(node: node, name: new_module_name)
+          )
+        end
       end
 
       if annots.instance_type
@@ -472,6 +477,13 @@ module Steep
         if super_class_name && implement_module_name.name == absolute_name(super_class_name)
           module_context = module_context.update(instance_definition: nil, module_definition: nil)
         end
+
+        if !checker.factory.definition_builder.env.normalized_class_entry(implement_module_name.name) &&
+          checker.factory.definition_builder.env.normalized_module_entry(implement_module_name.name)
+          typing.add_error(
+            Diagnostic::Ruby::ClassModuleMismatch.new(node: node, name: new_class_name)
+          )
+        end
       else
         module_context = module_context.update(
           instance_type: AST::Builtin::Object.instance_type,
@@ -2401,11 +2413,26 @@ module Steep
             if value_node
               type, constr = synthesize(value_node, hint: hint)
 
-              if hint.is_a?(AST::Types::Proc) && value_node.type == :sym
+              if hint.is_a?(AST::Types::Proc) && value_node.type == :send && value_node.children[1] == :method && AST::Builtin::Method.instance_type?(type)
+                receiver_node = value_node.children[0] #: Parser::AST::Node?
+                receiver_type = receiver_node ? typing.type_of(node: receiver_node) : self_type
+                method_name = value_node.children[2].children[0] #: Symbol
+                if method = calculate_interface(receiver_type, private: true)&.methods&.[](method_name)
+                  if method_type = method.method_types.find {|method_type| method_type.accept_one_arg? }
+                    if method_type.type_params.empty?
+                      type = AST::Types::Proc.new(
+                        type: method_type.type,
+                        block: method_type.block,
+                        self_type: nil
+                      )
+                    end
+                  end
+                end
+              elsif hint.is_a?(AST::Types::Proc) && value_node.type == :sym
                 if hint.one_arg?
                   if hint.type.params
                     # Assumes Symbol#to_proc implementation
-                    param_type = hint.type.params.required[0]
+                    param_type = hint.type.params.required.fetch(0)
                     case param_type
                     when AST::Types::Any
                       type = AST::Types::Any.instance
@@ -2423,7 +2450,7 @@ module Steep
                               params: Interface::Function::Params.empty.with_first_param(
                                 Interface::Function::Params::PositionalParams::Required.new(param_type)
                               ),
-                              return_type: return_types[0],
+                              return_type: return_types.fetch(0),
                               location: nil
                             ),
                             block: nil,
@@ -3479,13 +3506,13 @@ module Steep
       decls = method_overload.method_decls(method_name).to_set
 
       case
-      when decl = decls.find {|decl| SPECIAL_METHOD_NAMES[:array_compact].include?(decl.method_name) }
+      when decl = decls.find {|decl| SPECIAL_METHOD_NAMES.fetch(:array_compact).include?(decl.method_name) }
         if arguments.empty? && !block_params
           # compact
           return_type = method_type.type.return_type
           if AST::Builtin::Array.instance_type?(return_type)
             # @type var return_type: AST::Types::Name::Instance
-            elem = return_type.args[0]
+            elem = return_type.args.fetch(0)
             type = AST::Builtin::Array.instance_type(unwrap(elem))
 
             _, constr = add_typing(node, type: type)
@@ -3502,14 +3529,14 @@ module Steep
             return [call, constr]
           end
         end
-      when decl = decls.find {|decl| SPECIAL_METHOD_NAMES[:hash_compact].include?(decl.method_name) }
+      when decl = decls.find {|decl| SPECIAL_METHOD_NAMES.fetch(:hash_compact).include?(decl.method_name) }
         if arguments.empty? && !block_params
           # compact
           return_type = method_type.type.return_type
           if AST::Builtin::Hash.instance_type?(return_type)
             # @type var return_type: AST::Types::Name::Instance
-            key = return_type.args[0]
-            value = return_type.args[1]
+            key = return_type.args.fetch(0)
+            value = return_type.args.fetch(1)
             type = AST::Builtin::Hash.instance_type(key, unwrap(value))
 
             _, constr = add_typing(node, type: type)
@@ -3526,7 +3553,7 @@ module Steep
             return [call, constr]
           end
         end
-      when decl = decls.find {|decl| SPECIAL_METHOD_NAMES[:lambda].include?(decl.method_name) }
+      when decl = decls.find {|decl| SPECIAL_METHOD_NAMES.fetch(:lambda).include?(decl.method_name) }
         if block_params
           # @type var node: Parser::AST::Node & Parser::AST::_BlockNode
           type, constr = type_lambda(node, params_node: block_params, body_node: block_body, type_hint: hint)
@@ -3609,7 +3636,7 @@ module Steep
       end
 
       if fails.one?
-        call, constr = fails[0]
+        call, constr = fails.fetch(0)
 
         constr.typing.save!
 
@@ -3824,7 +3851,7 @@ module Steep
           args_ = []
 
           type_args.each_with_index do |type, index|
-            param = method_type.type_params[index]
+            param = method_type.type_params.fetch(index)
 
             if upper_bound = param.upper_bound
               if result = no_subtyping?(sub_type: type.value, super_type: upper_bound)
@@ -4912,7 +4939,7 @@ module Steep
           case
           when AST::Builtin::Array.instance_type?(type)
             type.is_a?(AST::Types::Name::Instance) or raise
-            element_types << type.args[0]
+            element_types << type.args.fetch(0)
           when type.is_a?(AST::Types::Tuple)
             element_types.push(*type.types)
           else
@@ -4948,20 +4975,32 @@ module Steep
             key_node = child.children[0] #: Parser::AST::Node
             value_node = child.children[1] #: Parser::AST::Node
 
-            key = key_node.children[0] #: AST::Types::Record::key
+            key =
+              case key_node.type
+              when :sym, :int, :str
+                key_node.children[0]
+              when :true
+                true
+              when :false
+                false
+              end #: AST::Types::Record::key
 
             _, constr = constr.synthesize(key_node, hint: AST::Types::Literal.new(value: key))
 
             value_type, constr = constr.synthesize(value_node, hint: hints[key])
 
             if hints.key?(key)
-              hint_type = hints[key]
+              hint_type = hints.fetch(key)
               case
               when value_type.is_a?(AST::Types::Any)
-                value_type = hints[key]
+                value_type = hints.fetch(key)
               when hint_type.is_a?(AST::Types::Var)
                 value_type = value_type
               end
+            else
+              typing.add_error(
+                Diagnostic::Ruby::UnknownRecordKey.new(key: key, node: key_node)
+              )
             end
 
             elems[key] = value_type
@@ -5033,8 +5072,8 @@ module Steep
               constr.synthesize(elem_, hint: hint_hash).tap do |(type, _)|
                 if AST::Builtin::Hash.instance_type?(type)
                   # @type var type: AST::Types::Name::Instance
-                  key_types << type.args[0]
-                  value_types << type.args[1]
+                  key_types << type.args.fetch(0)
+                  value_types << type.args.fetch(1)
                 end
               end
             end

data/lib/steep/type_inference/block_params.rb

@@ -266,7 +266,7 @@ module Steep
           when AST::Builtin::Array.instance_type?(type)
             type.is_a?(AST::Types::Name::Instance) or raise
 
-            type_arg = type.args[0]
+            type_arg = type.args.fetch(0)
             params.each do |param|
               unless param == rest_param
                 zip << [param, AST::Types::Union.build(types: [type_arg, AST::Builtin.nil_type])]
@@ -359,7 +359,7 @@ module Steep
           true
         when (leading_params.any? || trailing_params.any?) && rest_param
           true
-        when params.size == 1 && params[0].node.type == :arg
+        when params.size == 1 && params.fetch(0).node.type == :arg
           true
         else
           false
@@ -409,7 +409,7 @@ module Steep
 
       def untyped_args?(params)
         flat = params.flat_unnamed_params
-        flat.size == 1 && flat[0][1].is_a?(AST::Types::Any)
+        flat.size == 1 && flat.dig(0, 1)&.is_a?(AST::Types::Any)
       end
     end
   end

data/lib/steep/type_inference/context.rb

@@ -121,7 +121,7 @@ module Steep
         end
 
         def [](name)
-          table[name].upper_bound
+          table.fetch(name).upper_bound
         end
 
         def upper_bounds

data/lib/steep/type_inference/method_params.rb

@@ -469,7 +469,7 @@ module Steep
           has_error = false
 
           keywords.each do |keyword|
-            rest_types << (keyword_params.requireds[keyword] || keyword_params.optionals[keyword])
+            rest_types << (keyword_params.requireds[keyword] || keyword_params.optionals.fetch(keyword))
             has_error = true
           end
           keywords.clear

data/lib/steep/type_inference/type_env.rb

@@ -231,7 +231,7 @@ module Steep
 
         envs.each do |env|
           all_lvar_types.each_key do |name|
-            all_lvar_types[name] << (env[name] || AST::Builtin.nil_type)
+            all_lvar_types.fetch(name) << (env[name] || AST::Builtin.nil_type)
           end
         end
 
@@ -245,11 +245,11 @@ module Steep
           .inject {|s1, s2| s1.intersection(s2) } || Set[]
 
         pure_call_updates = common_pure_nodes.each_with_object({}) do |node, hash| #$ Hash[Parser::AST::Node, [MethodCall::Typed, AST::Types::t]]
-          pairs = envs.map {|env| env.pure_method_calls[node] }
+          pairs = envs.map {|env| env.pure_method_calls.fetch(node) }
           refined_type = AST::Types::Union.build(types: pairs.map {|call, type| type || call.return_type })
 
           # Any *pure_method_call* can be used because it's *pure*
-          (call, _ = envs[0].pure_method_calls[node]) or raise
+          (call, _ = envs.fetch(0).pure_method_calls[node]) or raise
 
           hash[node] = [call, refined_type]
         end

data/lib/steep/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "1.9.0.dev.2"
+  VERSION = "1.9.0"
 end

data/manual/annotations.md

@@ -142,3 +142,40 @@ This annotation tells instance variable of instance.
 
 * `@type` `instance` `ivar` *ivar* `:` *type*
 * `@type` `module` `ivar` *ivar* `:` *type*
+
+## Type assertion
+
+Type assertion allows declaring type of an expression inline, without introducing new local variable with variable type annotation.
+
+### Example
+
+```
+array = [] #: Array[String]
+
+path = nil #: Pathname?
+```
+
+##### Syntax
+
+* `#:` *type*
+
+## Type application
+
+Type application is for generic method calls.
+
+### Example
+
+```
+table = accounts.each_with_object({}) do |account, table| #$ Hash[String, Account]
+  table[account.email] = account
+end
+```
+
+The `each_with_object` method has `[T] (T) { (Account, T) -> void } -> T`,
+and the type application syntax directly specifies the type of `T`.
+
+So the resulting type is `(Hash[String, Account]) { (Account, Hash[String, Account]) -> void } -> Hash[String, Account]`.
+
+#### Syntax
+
+* `#$` *type*

data/manual/ignore.md

@@ -0,0 +1,20 @@
+# Ignore diagnostics
+
+Steep allows you to ignore diagnostics by adding comments to your code.
+
+```ruby
+# Ignoring a range of lines
+
+# steep:ignore:start
+
+foo()      # NoMethod is detected, but ignored
+
+# steep:ignore:end
+```
+
+```ruby
+# Ignoring a specific line
+
+foo() # steep:ignore
+foo() # steep:ignore NoMethod
+```