steep 1.5.0.pre.5 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ed79428764aa83fbd2e7f3c5a8e52ff863b4e65bef05aae43ba9ca4b7c9d2f4e
-  data.tar.gz: be79772ce19f152e3048ae565802640cae96f1bfca98adf60eab47a28ab3ccad
+  metadata.gz: 77aea7baf36285cf4a5b0941e63cc8f5f95d52132d3a5d4933a396a79b949721
+  data.tar.gz: 2506370595dde6633abbab74b1e370d435579415a154b4a82b4da3bb1b065627
 SHA512:
-  metadata.gz: aa071be8eaf425a2a36ffed4c8d0a97446997f9cbf85c9dc4190b5bf26c9bf5f66c7106ab27b96378d05e246a6327689ef491dedbd16ad7cb9eb8d8079b3818d
-  data.tar.gz: d7f842d51c84a2f48bdfd79a07de3e6265dd746497aa9661871f12b062832c2a24f46b37ce1ddb614ac5ba1c65f4c408e9e1eafec27fd69d7158514fe77e0fec
+  metadata.gz: 6f3190f0ca65a931f9c88d99cbd67836478d754439b5630b1b68f89e9fa6d84a84cc8bde32335d4bdb38b3f13aefaeaf93a75b53722a0b6841eab27e9b689ed8
+  data.tar.gz: 94576f1eedcb8c46ca8228e84e4100e860c0e3ed2a28dc209afa80abdeeed188118f1589dcb15d0a8edb0cd8c751f611035a15b613d284113c8cbebcce42dc6e

data/CHANGELOG.md

@@ -2,6 +2,42 @@
 
 ## master
 
+## 1.5.0 (2023-07-13)
+
+### Type checker core
+
+* Fix for the case `untyped` is the proc type hint ([#868](https://github.com/soutaro/steep/pull/868))
+* Type case with type variable ([#869](https://github.com/soutaro/steep/pull/869))
+* Filx `nil?` unreachability detection ([#867](https://github.com/soutaro/steep/pull/867))
+
+### Commandline tool
+
+* Update `#configure_code_diagnostics` type ([#873](https://github.com/soutaro/steep/pull/873))
+* Update diagnostics templates ([#871](https://github.com/soutaro/steep/pull/871))
+* Removed "set" from "libray" in init.rb and README ([#870](https://github.com/soutaro/steep/pull/870))
+
+### Language server
+
+* Use RBS::Buffer method to calculate position ([#872](https://github.com/soutaro/steep/pull/872))
+
+## 1.5.0.pre.6 (2023-07-11)
+
+### Type checker core
+
+* Report RBS validation errors in Ruby code ([#859](https://github.com/soutaro/steep/pull/859))
+* Fix proc type assignment ([#858](https://github.com/soutaro/steep/pull/858))
+* Report `UnexpectedKeywordArgument` even if no keyword param is accepted ([#856](https://github.com/soutaro/steep/pull/856))
+* Unfold type alias on unwrap optional ([#855](https://github.com/soutaro/steep/pull/855))
+
+### Language server
+
+* Keyword completion in block call ([#865](https://github.com/soutaro/steep/pull/865))
+* Indicate the current or next argument on signature help ([#850](https://github.com/soutaro/steep/pull/850))
+* Support completion for keyword arguments ([#851](https://github.com/soutaro/steep/pull/851))
+* Let hover show the type of method call node ([#864](https://github.com/soutaro/steep/pull/864))
+* Fix UnknownNodeError in SignatureHelp ([#863](https://github.com/soutaro/steep/pull/863))
+* hover: Fix NoMethodError on generating hover for not supported files ([#853](https://github.com/soutaro/steep/pull/853))
+
 ## 1.5.0.pre.5 (2023-07-07)
 
 ### Type checker core

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    steep (1.5.0.pre.5)
+    steep (1.5.0)
       activesupport (>= 5.1)
       concurrent-ruby (>= 1.1.10)
       csv (>= 3.0.9)

data/README.md

@@ -30,7 +30,7 @@ target :app do
   check "lib"
   signature "sig"
 
-  library "set", "pathname"
+  library "pathname"
 end
 ```
 

data/lib/steep/ast/node/type_application.rb

@@ -37,10 +37,12 @@ module Steep
             ty = ty.map_type_name {|name| resolver.resolve(name, context: context) || name.absolute! }
 
             validator = Signature::Validator.new(checker: subtyping)
-            validator.validate_type(ty)
+            validator.rescue_validation_errors do
+              validator.validate_type(ty)
+            end
 
             if validator.has_error?
-              return
+              return validator.each_error
             end
 
             ty = subtyping.factory.type(ty)
@@ -58,7 +60,7 @@ module Steep
 
         def types?(context, subtyping, type_vars)
           case types = types(context, subtyping, type_vars)
-          when RBS::ParsingError
+          when RBS::ParsingError, Enumerator
             nil
           else
             types

data/lib/steep/ast/node/type_assertion.rb

@@ -22,10 +22,14 @@ module Steep
             ty = ty.map_type_name {|name| resolver.resolve(name, context: context) || name.absolute! }
 
             validator = Signature::Validator.new(checker: subtyping)
-            validator.validate_type(ty)
+            validator.rescue_validation_errors do
+              validator.validate_type(ty)
+            end
 
             unless validator.has_error?
               subtyping.factory.type(ty)
+            else
+              validator.each_error.to_a
             end
           else
             nil
@@ -37,7 +41,7 @@ module Steep
         def type_syntax?
           RBS::Parser.parse_type(type_location.buffer, range: type_location.range, variables: [], require_eof: true)
           true
-        rescue::RBS::ParsingError
+        rescue ::RBS::ParsingError
           false
         end
 
@@ -45,7 +49,7 @@ module Steep
           type = type(context, subtyping, type_vars)
 
           case type
-          when RBS::ParsingError, nil
+          when RBS::ParsingError, nil, Array
             nil
           else
             type

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

@@ -401,6 +401,13 @@ module Steep
             end
           when AST::Types::Nil
             nil
+          when AST::Types::Name::Alias
+            type_ = expand_alias(type)
+            if type_ == type
+              type_
+            else
+              unwrap_optional(type_)
+            end
           else
             type
           end

data/lib/steep/diagnostic/ruby.rb

@@ -964,6 +964,19 @@ module Steep
         end
       end
 
+      class RBSError < Base
+        attr_reader :error
+
+        def initialize(error:, node:, location:)
+          @error = error
+          super(node: node, location: location)
+        end
+
+        def header_line
+          error.header_line
+        end
+      end
+
       ALL = ObjectSpace.each_object(Class).with_object([]) do |klass, array|
         if klass < Base
           array << klass
@@ -979,20 +992,57 @@ module Steep
       def self.default
         @default ||= _ = all_error.merge(
           {
-            ImplicitBreakValueMismatch => :warning,
-            FallbackAny => :information,
-            UnreachableValueBranch => :warning,
-            UnreachableBranch => :information,
+            ArgumentTypeMismatch => :error,
+            BlockBodyTypeMismatch => :hint,
+            BlockTypeMismatch => :hint,
+            BreakTypeMismatch => :hint,
+            DifferentMethodParameterKind => :hint,
+            FallbackAny => :hint,
+            FalseAssertion => :hint,
+            ImplicitBreakValueMismatch => :hint,
+            IncompatibleAnnotation => :hint,
+            IncompatibleArgumentForwarding => :warning,
+            IncompatibleAssignment => :hint,
+            IncompatibleMethodTypeAnnotation => :hint,
+            IncompatibleTypeCase => :hint,
+            InsufficientKeywordArguments => :error,
+            InsufficientPositionalArguments => :error,
+            InsufficientTypeArgument => :hint,
+            MethodArityMismatch => :error,
+            MethodBodyTypeMismatch => :error,
+            MethodDefinitionMissing => nil,
+            MethodParameterMismatch => :error,
+            MethodReturnTypeAnnotationMismatch => :hint,
+            MultipleAssignmentConversionError => :hint,
+            NoMethod => :error,
+            ProcHintIgnored => :hint,
+            ProcTypeExpected => :hint,
+            RBSError => :information,
+            RequiredBlockMissing => :error,
+            ReturnTypeMismatch => :error,
+            SetterBodyTypeMismatch => :information,
+            SetterReturnTypeMismatch => :information,
+            SyntaxError => :hint,
+            TypeArgumentMismatchError => :hint,
+            UnexpectedBlockGiven => :warning,
+            UnexpectedDynamicMethod => :hint,
+            UnexpectedError => :hint,
+            UnexpectedJump => :hint,
+            UnexpectedJumpValue => :hint,
+            UnexpectedKeywordArgument => :error,
+            UnexpectedPositionalArgument => :error,
+            UnexpectedSplat => :hint,
+            UnexpectedSuper => :information,
+            UnexpectedTypeArgument => :hint,
+            UnexpectedYield => :warning,
             UnknownConstant => :warning,
-            MethodDefinitionMissing => :information,
-            FalseAssertion => :information,
-            UnexpectedTypeArgument => :information,
-            InsufficientTypeArgument => :information,
-            UnexpectedTypeArgument => :information,
-            UnsupportedSyntax => nil,
-            ProcHintIgnored => :information,
-            SetterBodyTypeMismatch => nil,
-            SetterReturnTypeMismatch => nil
+            UnknownGlobalVariable => :warning,
+            UnknownInstanceVariable => :information,
+            UnreachableBranch => :hint,
+            UnreachableValueBranch => :hint,
+            UnresolvedOverloading => :error,
+            UnsatisfiableConstraint => :hint,
+            UnsupportedSyntax => :hint,
           }
         ).freeze
       end
@@ -1000,17 +1050,57 @@ module Steep
       def self.strict
         @strict ||= _ = all_error.merge(
           {
-            NoMethod => nil,
-            ImplicitBreakValueMismatch => nil,
-            FallbackAny => nil,
-            UnreachableValueBranch => nil,
-            UnreachableBranch => nil,
-            UnknownConstant => nil,
-            MethodDefinitionMissing => nil,
-            UnsupportedSyntax => nil,
-            ProcHintIgnored => :warning,
+            ArgumentTypeMismatch => :error,
+            BlockBodyTypeMismatch => :error,
+            BlockTypeMismatch => :error,
+            BreakTypeMismatch => :error,
+            DifferentMethodParameterKind => :error,
+            FallbackAny => :warning,
+            FalseAssertion => :error,
+            ImplicitBreakValueMismatch => :information,
+            IncompatibleAnnotation => :error,
+            IncompatibleArgumentForwarding => :error,
+            IncompatibleAssignment => :error,
+            IncompatibleMethodTypeAnnotation => :error,
+            IncompatibleTypeCase => :error,
+            InsufficientKeywordArguments => :error,
+            InsufficientPositionalArguments => :error,
+            InsufficientTypeArgument => :error,
+            MethodArityMismatch => :error,
+            MethodBodyTypeMismatch => :error,
+            MethodDefinitionMissing => :hint,
+            MethodParameterMismatch => :error,
+            MethodReturnTypeAnnotationMismatch => :error,
+            MultipleAssignmentConversionError => :error,
+            NoMethod => :error,
+            ProcHintIgnored => :information,
+            ProcTypeExpected => :error,
+            RBSError => :error,
+            RequiredBlockMissing => :error,
+            ReturnTypeMismatch => :error,
             SetterBodyTypeMismatch => :error,
-            SetterReturnTypeMismatch => :error
+            SetterReturnTypeMismatch => :error,
+            SyntaxError => :hint,
+            TypeArgumentMismatchError => :error,
+            UnexpectedBlockGiven => :error,
+            UnexpectedDynamicMethod => :information,
+            UnexpectedError => :information,
+            UnexpectedJump => :error,
+            UnexpectedJumpValue => :error,
+            UnexpectedKeywordArgument => :error,
+            UnexpectedPositionalArgument => :error,
+            UnexpectedSplat => :warning,
+            UnexpectedSuper => :error,
+            UnexpectedTypeArgument => :error,
+            UnexpectedYield => :error,
+            UnknownConstant => :error,
+            UnknownGlobalVariable => :error,
+            UnknownInstanceVariable => :error,
+            UnreachableBranch => :information,
+            UnreachableValueBranch => :warning,
+            UnresolvedOverloading => :error,
+            UnsatisfiableConstraint => :error,
+            UnsupportedSyntax => :information,
           }
         ).freeze
       end
@@ -1018,19 +1108,57 @@ module Steep
       def self.lenient
         @lenient ||= _ = all_error.merge(
           {
-            NoMethod => nil,
-            ImplicitBreakValueMismatch => nil,
+            ArgumentTypeMismatch => :information,
+            BlockBodyTypeMismatch => :hint,
+            BlockTypeMismatch => :hint,
+            BreakTypeMismatch => :hint,
+            DifferentMethodParameterKind => nil,
             FallbackAny => nil,
-            UnreachableValueBranch => nil,
-            UnreachableBranch => nil,
-            UnknownConstant => nil,
+            FalseAssertion => nil,
+            ImplicitBreakValueMismatch => nil,
+            IncompatibleAnnotation => nil,
+            IncompatibleArgumentForwarding => :information,
+            IncompatibleAssignment => :hint,
+            IncompatibleMethodTypeAnnotation => nil,
+            IncompatibleTypeCase => nil,
+            InsufficientKeywordArguments => :information,
+            InsufficientPositionalArguments => :information,
+            InsufficientTypeArgument => nil,
+            MethodArityMismatch => :information,
+            MethodBodyTypeMismatch => :warning,
             MethodDefinitionMissing => nil,
-            UnexpectedJump => nil,
-            FalseAssertion => :hint,
-            UnsupportedSyntax => nil,
-            ProcHintIgnored => :hint,
+            MethodParameterMismatch => :warning,
+            MethodReturnTypeAnnotationMismatch => nil,
+            MultipleAssignmentConversionError => nil,
+            NoMethod => :information,
+            ProcHintIgnored => nil,
+            ProcTypeExpected => nil,
+            RBSError => :information,
+            RequiredBlockMissing => :hint,
+            ReturnTypeMismatch => :warning,
             SetterBodyTypeMismatch => nil,
-            SetterReturnTypeMismatch => nil
+            SetterReturnTypeMismatch => nil,
+            SyntaxError => :hint,
+            TypeArgumentMismatchError => nil,
+            UnexpectedBlockGiven => :hint,
+            UnexpectedDynamicMethod => nil,
+            UnexpectedError => :hint,
+            UnexpectedJump => nil,
+            UnexpectedJumpValue => nil,
+            UnexpectedKeywordArgument => :information,
+            UnexpectedPositionalArgument => :information,
+            UnexpectedSplat => nil,
+            UnexpectedSuper => nil,
+            UnexpectedTypeArgument => nil,
+            UnexpectedYield => :information,
+            UnknownConstant => :hint,
+            UnknownGlobalVariable => :hint,
+            UnknownInstanceVariable => :hint,
+            UnreachableBranch => :hint,
+            UnreachableValueBranch => :hint,
+            UnresolvedOverloading => :information,
+            UnsatisfiableConstraint => :hint,
+            UnsupportedSyntax => :hint,
           }
         ).freeze
       end

data/lib/steep/drivers/init.rb

@@ -18,9 +18,10 @@ module Steep
       #   check "app/models/**/*.rb"        # Glob
       #   # ignore "lib/templates/*.rb"
       #
-      #   # library "pathname", "set"       # Standard libraries
+      #   # library "pathname"              # Standard libraries
       #   # library "strong_json"           # Gems
       #
+      #   # configure_code_diagnostics(D::Ruby.default)      # `default` diagnostics setting (applies by default)
       #   # configure_code_diagnostics(D::Ruby.strict)       # `strict` diagnostics setting
       #   # configure_code_diagnostics(D::Ruby.lenient)      # `lenient` diagnostics setting
       #   # configure_code_diagnostics(D::Ruby.silent)       # `silent` diagnostics setting
@@ -34,7 +35,7 @@ module Steep
       #
       #   check "test"
       #
-      #   # library "pathname", "set"       # Standard libraries
+      #   # library "pathname"              # Standard libraries
       # end
       EOF
 

data/lib/steep/node_helper.rb

@@ -217,5 +217,28 @@ module Steep
         false
       end
     end
+
+    def deconstruct_sendish_and_block_nodes(*nodes)
+      send_node, block_node = nodes.take(2)
+
+      if send_node
+        case send_node.type
+        when :send, :csend, :super
+          if block_node
+            case block_node.type
+            when :block, :numblock
+              if send_node.equal?(block_node.children[0])
+                return [send_node, block_node]
+              end
+            end
+          end
+
+          [send_node, nil]
+        when :zsuper
+          # zsuper doesn't receive block
+          [send_node, nil]
+        end
+      end
+    end
   end
 end

data/lib/steep/project/dsl.rb

@@ -143,27 +143,6 @@ module Steep
           @repo_paths.push(*paths.map {|s| Pathname(s) })
         end
 
-        # Configure the code diagnostics printing setup.
-        #
-        # Yields a hash, and the update the hash in the block.
-        #
-        # ```rb
-        # D = Steep::Diagnostic
-        #
-        # configure_code_diagnostics do |hash|
-        #   # Assign one of :error, :warning, :information, :hint or :nil to error classes.
-        #   hash[D::Ruby::UnexpectedPositionalArgument] = :error
-        # end
-        # ```
-        #
-        # Passing a hash is also allowed.
-        #
-        # ```rb
-        # D = Steep::Diagnostic
-        #
-        # configure_code_diagnostics(D::Ruby.lenient)
-        # ```
-        #
         def configure_code_diagnostics(hash = nil)
           if hash
             code_diagnostics_config.merge!(hash)

data/lib/steep/server/interaction_worker.rb

@@ -361,6 +361,17 @@ module Steep
               new_text: item.identifier.to_s
             )
           )
+        when Services::CompletionProvider::KeywordArgumentItem
+          LSP::Interface::CompletionItem.new(
+            label: item.identifier.to_s,
+            kind: LSP::Constant::CompletionItemKind::FIELD,
+            label_details: LSP::Interface::CompletionItemLabelDetails.new(description: 'Keyword argument'),
+            documentation: LSPFormatter.markup_content { LSPFormatter.format_completion_docs(item) },
+            text_edit: LSP::Interface::TextEdit.new(
+              range: range,
+              new_text: item.identifier.to_s
+            )
+          )
         when Services::CompletionProvider::TypeNameItem
           kind =
             case
@@ -397,6 +408,8 @@ module Steep
               signatures = items.map do |item|
                 LSP::Interface::SignatureInformation.new(
                   label: "(#{item.method_type.type.param_to_s})",
+                  parameters: item.parameters.map { |param| LSP::Interface::ParameterInformation.new(label: param)},
+                  active_parameter: item.active_parameter,
                   documentation: item.comment&.yield_self do |comment|
                     LSP::Interface::MarkupContent.new(
                       kind: LSP::Constant::MarkupKind::MARKDOWN,

data/lib/steep/server/lsp_formatter.rb

@@ -28,7 +28,16 @@ module Steep
 
           case call
           when TypeInference::MethodCall::Typed
+            io.puts <<~MD
+              ```rbs
+              #{call.actual_method_type.type.return_type}
+              ```
+
+              ----
+            MD
+
             method_types = call.method_decls.map(&:method_type)
+
             if call.is_a?(TypeInference::MethodCall::Special)
               method_types = [
                 call.actual_method_type.with(
@@ -250,6 +259,10 @@ module Steep
           end
 
           io.string
+        when Services::CompletionProvider::KeywordArgumentItem
+          <<~MD
+            **Keyword argument**: `#{item.identifier}`
+          MD
         end
       end
 

data/lib/steep/services/completion_provider.rb

@@ -1,6 +1,8 @@
 module Steep
   module Services
     class CompletionProvider
+      include NodeHelper
+
       Position = _ = Struct.new(:line, :column, keyword_init: true) do
         # @implements Position
         def -(size)
@@ -11,6 +13,7 @@ module Steep
       Range = _ = Struct.new(:start, :end, keyword_init: true)
 
       InstanceVariableItem = _ = Struct.new(:identifier, :range, :type, keyword_init: true)
+      KeywordArgumentItem = _ = Struct.new(:identifier, :range, keyword_init: true)
       LocalVariableItem = _ = Struct.new(:identifier, :range, :type, keyword_init: true)
       ConstantItem = _ = Struct.new(:env, :identifier, :range, :type, :full_name, keyword_init: true) do
         # @implements ConstantItem
@@ -267,7 +270,9 @@ module Steep
               []
             end
           else
-            []
+            items = [] #: Array[item]
+            items_for_following_keyword_arguments(source_text, index: index, line: line, column: column, items: items)
+            items
           end
         end
       end
@@ -302,10 +307,10 @@ module Steep
       end
 
       def items_for_trigger(position:)
-        node, *_parents = source.find_nodes(line: position.line, column: position.column)
+        node, *parents = source.find_nodes(line: position.line, column: position.column)
         node ||= source.node
 
-        return [] unless node
+        return [] unless node && parents
 
         items = [] #: Array[item]
 
@@ -319,6 +324,16 @@ module Steep
           method_items_for_receiver_type(context.self_type, include_private: true, prefix: prefix, position: position, items: items)
           local_variable_items_for_context(context, position: position, prefix: prefix, items: items)
 
+          if (send_node, block_node = deconstruct_sendish_and_block_nodes(*parents))
+            keyword_argument_items_for_method(
+              call_node: block_node || send_node,
+              send_node: send_node,
+              position: position,
+              prefix: prefix,
+              items: items
+            )
+          end
+
         when node.type == :lvar && at_end?(position, of: node.loc)
           # foo ← (lvar)
           local_variable_items_for_context(context, position: position, prefix: node.children[0].to_s, items: items)
@@ -527,6 +542,37 @@ module Steep
         items
       end
 
+      def items_for_following_keyword_arguments(text, index:, line:, column:, items:)
+        return if text[index - 1] !~ /[a-zA-Z0-9]/
+
+        text = text.dup
+        argname = [] #: Array[String]
+        while text[index - 1] =~ /[a-zA-Z0-9]/
+          argname.unshift(text[index - 1] || '')
+          source_text[index - 1] = " "
+          index -= 1
+        end
+
+        begin
+          type_check!(source_text, line: line, column: column)
+        rescue Parser::SyntaxError
+          return
+        end
+
+        if nodes = source.find_nodes(line: line, column: column)
+          if (send_node, block_node = deconstruct_sendish_and_block_nodes(*nodes))
+            position = Position.new(line: line, column: column)
+            keyword_argument_items_for_method(
+              call_node: block_node || send_node,
+              send_node: send_node,
+              position: position,
+              prefix: argname.join,
+              items: items
+            )
+          end
+        end
+      end
+
       def method_items_for_receiver_type(type, include_private:, prefix:, position:, items:)
         range = range_for(position, prefix: prefix)
         context = typing.context_at(line: position.line, column: position.column)
@@ -641,6 +687,42 @@ module Steep
         end
       end
 
+      def keyword_argument_items_for_method(call_node:, send_node:, position:, prefix:, items:)
+        receiver_node, method_name, argument_nodes = deconstruct_send_node!(send_node)
+
+        call = typing.call_of(node: call_node)
+
+        case call
+        when TypeInference::MethodCall::Typed, TypeInference::MethodCall::Error
+          type = call.receiver_type
+          shape = subtyping.builder.shape(
+            type,
+            public_only: !!receiver_node,
+            config: Interface::Builder::Config.new(self_type: type, class_type: nil, instance_type: nil, variable_bounds: {})
+          )
+          if shape
+            if method = shape.methods[call.method_name]
+              method.method_types.each.with_index do |method_type, i|
+                defn = method_type.method_decls.to_a[0]&.method_def
+                if defn
+                  range = range_for(position, prefix: prefix)
+                  kwargs = argument_nodes.find { |arg| arg.type == :kwargs }&.children || []
+                  used_kwargs = kwargs.filter_map { |arg| arg.type == :pair && arg.children.first.children.first }
+
+                  kwargs = defn.type.type.required_keywords.keys + defn.type.type.optional_keywords.keys
+                  kwargs.each do |name|
+                    if name.to_s.start_with?(prefix) && !used_kwargs.include?(name)
+                      items << KeywordArgumentItem.new(identifier: "#{name}:", range: range)
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+
+
       def index_for(string, line:, column:)
         index = 0
 

data/lib/steep/services/hover_provider/ruby.rb

@@ -110,7 +110,7 @@ module Steep
         end
 
         def content_for(target:, path:, line:, column:)
-          file = service.source_files[path]
+          file = service.source_files[path] or return
           typing = typecheck(target, path: path, content: file.content, line: line, column: column) or return
           node, *parents = typing.source.find_nodes(line: line, column: column)