solargraph 0.56.2 → 0.57.0

data/lib/solargraph/parser/flow_sensitive_typing.rb

@@ -4,14 +4,20 @@ module Solargraph
       include Solargraph::Parser::NodeMethods
 
       # @param locals [Array<Solargraph::Pin::LocalVariable, Solargraph::Pin::Parameter>]
+      # @param enclosing_breakable_pin [Solargraph::Pin::Breakable, nil]
       def initialize(locals, enclosing_breakable_pin = nil)
         @locals = locals
         @enclosing_breakable_pin = enclosing_breakable_pin
       end
 
       # @param and_node [Parser::AST::Node]
+      # @param true_ranges [Array<Range>]
+      #
+      # @return [void]
       def process_and(and_node, true_ranges = [])
+        # @type [Parser::AST::Node]
         lhs = and_node.children[0]
+        # @type [Parser::AST::Node]
         rhs = and_node.children[1]
 
         before_rhs_loc = rhs.location.expression.adjust(begin_pos: -1)
@@ -23,6 +29,8 @@ module Solargraph
       end
 
       # @param if_node [Parser::AST::Node]
+      #
+      # @return [void]
       def process_if(if_node)
         #
         # See if we can refine a type based on the result of 'if foo.nil?'
@@ -36,7 +44,9 @@ module Solargraph
         #   s(:send, nil, :bar))
         # [4] pry(main)>
         conditional_node = if_node.children[0]
+        # @type [Parser::AST::Node]
         then_clause = if_node.children[1]
+        # @type [Parser::AST::Node]
         else_clause = if_node.children[2]
 
         true_ranges = []
@@ -72,8 +82,11 @@ module Solargraph
       # them based on the Closure and Location.
       #
       # @param pins [Array<Pin::LocalVariable>]
+      # @param name [String]
       # @param closure [Pin::Closure]
       # @param location [Location]
+      #
+      # @return [Array<Pin::LocalVariable>]
       def self.visible_pins(pins, name, closure, location)
         logger.debug { "FlowSensitiveTyping#visible_pins(name=#{name}, closure=#{closure}, location=#{location})" }
         pins_with_name = pins.select { |p| p.name == name }
@@ -107,7 +120,10 @@ module Solargraph
       private
 
       # @param pin [Pin::LocalVariable]
-      # @param if_node [Parser::AST::Node]
+      # @param downcast_type_name [String]
+      # @param presence [Range]
+      #
+      # @return [void]
       def add_downcast_local(pin, downcast_type_name, presence)
         # @todo Create pin#update method
         new_pin = Solargraph::Pin::LocalVariable.new(
@@ -126,6 +142,7 @@ module Solargraph
 
       # @param facts_by_pin [Hash{Pin::LocalVariable => Array<Hash{Symbol => String}>}]
       # @param presences [Array<Range>]
+      #
       # @return [void]
       def process_facts(facts_by_pin, presences)
         #
@@ -142,6 +159,9 @@ module Solargraph
       end
 
       # @param conditional_node [Parser::AST::Node]
+      # @param true_ranges [Array<Range>]
+      #
+      # @return [void]
       def process_conditional(conditional_node, true_ranges)
         if conditional_node.type == :send
           process_isa(conditional_node, true_ranges)
@@ -176,12 +196,20 @@ module Solargraph
         [isa_type_name, variable_name]
       end
 
+      # @param variable_name [String]
+      # @param position [Position]
+      #
+      # @return [Solargraph::Pin::LocalVariable, nil]
       def find_local(variable_name, position)
         pins = locals.select { |pin| pin.name == variable_name && pin.presence.include?(position) }
         return unless pins.length == 1
         pins.first
       end
 
+      # @param isa_node [Parser::AST::Node]
+      # @param true_presences [Array<Range>]
+      #
+      # @return [void]
       def process_isa(isa_node, true_presences)
         isa_type_name, variable_name = parse_isa(isa_node)
         return if variable_name.nil? || variable_name.empty?
@@ -197,10 +225,12 @@ module Solargraph
       end
 
       # @param node [Parser::AST::Node]
+      #
+      # @return [String, nil]
       def type_name(node)
         # e.g.,
         #  s(:const, nil, :Baz)
-        return unless node.type == :const
+        return unless node&.type == :const
         module_node = node.children[0]
         class_node = node.children[1]
 
@@ -212,8 +242,6 @@ module Solargraph
         "#{module_type_name}::#{class_node}"
       end
 
-      # @todo "return type could not be inferred" should not trigger here
-      # @sg-ignore
       # @param clause_node [Parser::AST::Node]
       def always_breaks?(clause_node)
         clause_node&.type == :break

data/lib/solargraph/parser/node_methods.rb

@@ -1,6 +1,6 @@
 module Solargraph
   module Parser
-    class NodeMethods
+    module NodeMethods
       module_function
 
       # @abstract
@@ -74,7 +74,7 @@ module Solargraph
 
       # @abstract
       # @param node [Parser::AST::Node]
-      # @return [Hash{Parser::AST::Node => Source::Chain}]
+      # @return [Hash{Symbol => Source::Chain}]
       def convert_hash node
         raise NotImplementedError
       end

data/lib/solargraph/parser/node_processor/base.rb

@@ -13,7 +13,7 @@ module Solargraph
         # @return [Array<Pin::Base>]
         attr_reader :pins
 
-        # @return [Array<Pin::BaseVariable>]
+        # @return [Array<Pin::LocalVariable>]
         attr_reader :locals
 
         # @param node [Parser::AST::Node]

data/lib/solargraph/parser/node_processor.rb

@@ -9,7 +9,7 @@ module Solargraph
       autoload :Base, 'solargraph/parser/node_processor/base'
 
       class << self
-        # @type [Hash<Symbol, Array<Class<NodeProcessor::Base>>>]
+        # @type [Hash{Symbol => Array<Class<NodeProcessor::Base>>}]
         @@processors ||= {}
 
         # Register a processor for a node type. You can register multiple processors for the same type.
@@ -17,12 +17,16 @@ module Solargraph
         #
         # @param type [Symbol]
         # @param cls [Class<NodeProcessor::Base>]
-        # @return [Class<NodeProcessor::Base>]
+        # @return [Array<Class<NodeProcessor::Base>>]
         def register type, cls
           @@processors[type] ||= []
           @@processors[type] << cls
         end
 
+        # @param type [Symbol]
+        # @param cls [Class<NodeProcessor::Base>]
+        #
+        # @return [void]
         def deregister type, cls
           @@processors[type].delete(cls)
         end

data/lib/solargraph/parser/parser_gem/class_methods.rb

@@ -17,7 +17,7 @@ module Solargraph
       module ClassMethods
         # @param code [String]
         # @param filename [String, nil]
-        # @return [Array(Parser::AST::Node, Hash{Integer => String})]
+        # @return [Array(Parser::AST::Node, Hash{Integer => Solargraph::Parser::Snippet})]
         def parse_with_comments code, filename = nil
           node = parse(code, filename)
           comments = CommentRipper.new(code, filename, 0).parse

data/lib/solargraph/parser/parser_gem/flawed_builder.rb

@@ -9,6 +9,7 @@ module Solargraph
       class FlawedBuilder < ::Parser::Builders::Default
         # @param token [::Parser::AST::Node]
         # @return [String]
+        # @sg-ignore
         def string_value(token)
           value(token)
         end

data/lib/solargraph/parser/parser_gem/node_chainer.rb

@@ -7,6 +7,7 @@ module Solargraph
       #
       class NodeChainer
         include NodeMethods
+
         Chain = Source::Chain
 
         # @param node [Parser::AST::Node]
@@ -98,7 +99,8 @@ module Solargraph
           elsif [:gvar, :gvasgn].include?(n.type)
             result.push Chain::GlobalVariable.new(n.children[0].to_s)
           elsif n.type == :or_asgn
-            result.concat generate_links n.children[1]
+            new_node = n.updated(n.children[0].type, n.children[0].children + [n.children[1]])
+            result.concat generate_links new_node
           elsif [:class, :module, :def, :defs].include?(n.type)
             # @todo Undefined or what?
             result.push Chain::UNDEFINED_CALL

data/lib/solargraph/parser/parser_gem/node_methods.rb

@@ -120,7 +120,7 @@ module Solargraph
         end
 
         # @param node [Parser::AST::Node]
-        # @return [Hash{Parser::AST::Node => Chain}]
+        # @return [Hash{Symbol => Chain}]
         def convert_hash node
           return {} unless Parser.is_ast_node?(node)
           return convert_hash(node.children[0]) if node.type == :kwsplat
@@ -179,6 +179,7 @@ module Solargraph
             node.children[1..-1].each { |child| result.concat call_nodes_from(child) }
           elsif node.type == :send
             result.push node
+            result.concat call_nodes_from(node.children.first)
             node.children[2..-1].each { |child| result.concat call_nodes_from(child) }
           elsif [:super, :zsuper].include?(node.type)
             result.push node
@@ -232,6 +233,7 @@ module Solargraph
           else
             source.tree_at(position.line, position.column - 1)
           end
+          # @type [AST::Node, nil]
           prev = nil
           tree.each do |node|
             if node.type == :send
@@ -242,7 +244,7 @@ module Solargraph
                 if source.synchronized?
                   return node if source.code[0..offset-1] =~ /\(\s*\z/ && source.code[offset..-1] =~ /^\s*\)/
                 else
-                  return node if source.code[0..offset-1] =~ /\([^\(]*\z/
+                  return node if source.code[0..offset-1] =~ /\([^(]*\z/
                 end
               end
             end

data/lib/solargraph/parser/parser_gem/node_processors/block_node.rb

@@ -19,7 +19,7 @@ module Solargraph
             else
               region.closure
             end
-            pins.push Solargraph::Pin::Block.new(
+            block_pin = Solargraph::Pin::Block.new(
               location: location,
               closure: parent,
               node: node,
@@ -28,7 +28,8 @@ module Solargraph
               scope: region.scope || region.closure.context.scope,
               source: :parser
             )
-            process_children region.update(closure: pins.last)
+            pins.push block_pin
+            process_children region.update(closure: block_pin)
           end
 
           private

data/lib/solargraph/parser/parser_gem/node_processors/if_node.rb

@@ -11,6 +11,8 @@ module Solargraph
             process_children
 
             position = get_node_start_position(node)
+            # @sg-ignore
+            # @type [Solargraph::Pin::Breakable, nil]
             enclosing_breakable_pin = pins.select{|pin| pin.is_a?(Pin::Breakable) && pin.location.range.contain?(position)}.last
             FlowSensitiveTyping.new(locals, enclosing_breakable_pin).process_if(node)
           end

data/lib/solargraph/parser/parser_gem/node_processors/masgn_node.rb

@@ -22,8 +22,11 @@ module Solargraph
             #     s(:int, 2),
             #     s(:int, 3)))
             masgn = node
+            # @type [Parser::AST::Node]
             mlhs = masgn.children.fetch(0)
+            # @type [Array<Parser::AST::Node>]
             lhs_arr = mlhs.children
+            # @type [Parser::AST::Node]
             mass_rhs = node.children.fetch(1)
 
             # Get pins created for the mlhs node

data/lib/solargraph/parser/parser_gem/node_processors/send_node.rb

@@ -8,32 +8,44 @@ module Solargraph
           include ParserGem::NodeMethods
 
           def process
+            # @sg-ignore Variable type could not be inferred for method_name
+            # @type [Symbol]
+            method_name = node.children[1]
+            # :nocov:
+            unless method_name.instance_of?(Symbol)
+              Solargraph.assert_or_log(:parser_method_name, "Expected method name to be a Symbol, got #{method_name.class} for node #{node.inspect}")
+              return process_children
+            end
+            # :nocov:
             if node.children[0].nil?
-              if [:private, :public, :protected].include?(node.children[1])
+              if [:private, :public, :protected].include?(method_name)
                 process_visibility
-              elsif node.children[1] == :module_function
+              elsif method_name == :module_function
                 process_module_function
-              elsif [:attr_reader, :attr_writer, :attr_accessor].include?(node.children[1])
+              elsif [:attr_reader, :attr_writer, :attr_accessor].include?(method_name)
                 process_attribute
-              elsif node.children[1] == :include
+              elsif method_name == :include
                 process_include
-              elsif node.children[1] == :extend
+              elsif method_name == :extend
                 process_extend
-              elsif node.children[1] == :prepend
+              elsif method_name == :prepend
                 process_prepend
-              elsif node.children[1] == :require
+              elsif method_name == :require
                 process_require
-              elsif node.children[1] == :autoload
+              elsif method_name == :autoload
                 process_autoload
-              elsif node.children[1] == :private_constant
+              elsif method_name == :private_constant
                 process_private_constant
-              elsif node.children[1] == :alias_method && node.children[2] && node.children[2] && node.children[2].type == :sym && node.children[3] && node.children[3].type == :sym
+              # @sg-ignore
+              elsif method_name == :alias_method && node.children[2] && node.children[2] && node.children[2].type == :sym && node.children[3] && node.children[3].type == :sym
                 process_alias_method
-              elsif node.children[1] == :private_class_method && node.children[2].is_a?(AST::Node)
+              # @sg-ignore
+              elsif method_name == :private_class_method && node.children[2].is_a?(AST::Node)
                 # Processing a private class can potentially handle children on its own
                 return if process_private_class_method
               end
-            elsif node.children[1] == :require && node.children[0].to_s == '(const nil :Bundler)'
+            # @sg-ignore
+            elsif method_name == :require && node.children[0].to_s == '(const nil :Bundler)'
               pins.push Pin::Reference::Require.new(Solargraph::Location.new(region.filename, Solargraph::Range.from_to(0, 0, 0, 0)), 'bundler/require', source: :parser)
             end
             process_children
@@ -45,15 +57,24 @@ module Solargraph
           def process_visibility
             if (node.children.length > 2)
               node.children[2..-1].each do |child|
+                # @sg-ignore Variable type could not be inferred for method_name
+                # @type [Symbol]
+                visibility = node.children[1]
+                # :nocov:
+                unless visibility.instance_of?(Symbol)
+                  Solargraph.assert_or_log(:parser_visibility, "Expected visibility name to be a Symbol, got #{visibility.class} for node #{node.inspect}")
+                  return process_children
+                end
+                # :nocov:
                 if child.is_a?(AST::Node) && (child.type == :sym || child.type == :str)
                   name = child.children[0].to_s
                   matches = pins.select{ |pin| pin.is_a?(Pin::Method) && pin.name == name && pin.namespace == region.closure.full_context.namespace && pin.context.scope == (region.scope || :instance)}
                   matches.each do |pin|
                     # @todo Smelly instance variable access
-                    pin.instance_variable_set(:@visibility, node.children[1])
+                    pin.instance_variable_set(:@visibility, visibility)
                   end
                 else
-                  process_children region.update(visibility: node.children[1])
+                  process_children region.update(visibility: visibility)
                 end
               end
             else

data/lib/solargraph/parser/region.rb

@@ -23,8 +23,10 @@ module Solargraph
 
       # @param source [Source]
       # @param namespace [String]
+      # @param closure [Pin::Closure, nil]
       # @param scope [Symbol, nil]
       # @param visibility [Symbol]
+      # @param lvars [Array<Symbol>]
       def initialize source: Solargraph::Source.load_string(''), closure: nil,
                      scope: nil, visibility: :public, lvars: []
         @source = source
@@ -45,6 +47,7 @@ module Solargraph
       # @param closure [Pin::Closure, nil]
       # @param scope [Symbol, nil]
       # @param visibility [Symbol, nil]
+      # @param lvars [Array<Symbol>, nil]
       # @return [Region]
       def update closure: nil, scope: nil, visibility: nil, lvars: nil
         Region.new(

data/lib/solargraph/parser/snippet.rb

@@ -6,6 +6,8 @@ module Solargraph
       # @return [String]
       attr_reader :text
 
+      # @param range [Solargraph::Range]
+      # @param text [String]
       def initialize range, text
         @range = range
         @text = text

data/lib/solargraph/pin/base.rb

@@ -13,10 +13,10 @@ module Solargraph
       # @return [YARD::CodeObjects::Base]
       attr_reader :code_object
 
-      # @return [Solargraph::Location]
+      # @return [Solargraph::Location, nil]
       attr_reader :location
 
-      # @return [Solargraph::Location]
+      # @return [Solargraph::Location, nil]
       attr_reader :type_location
 
       # @return [String]
@@ -28,6 +28,11 @@ module Solargraph
       # @return [::Symbol]
       attr_accessor :source
 
+      # @type [::Numeric, nil] A priority for determining if pins should be combined or not
+      #   A nil priority is considered the be the lowest. All code, yard & rbs pins have nil priority
+      #   Between 2 pins, the one with the higher priority gets chosen. If the priorities are equal, they are combined.
+      attr_reader :combine_priority
+
       def presence_certain?
         true
       end
@@ -40,7 +45,8 @@ module Solargraph
       # @param source [Symbol, nil]
       # @param docstring [YARD::Docstring, nil]
       # @param directives [::Array<YARD::Tags::Directive>, nil]
-      def initialize location: nil, type_location: nil, closure: nil, source: nil, name: '', comments: '', docstring: nil, directives: nil
+      # @param combine_priority [::Numeric, nil] See attr_reader for combine_priority
+      def initialize location: nil, type_location: nil, closure: nil, source: nil, name: '', comments: '', docstring: nil, directives: nil, combine_priority: nil
         @location = location
         @type_location = type_location
         @closure = closure
@@ -50,6 +56,8 @@ module Solargraph
         @identity = nil
         @docstring = docstring
         @directives = directives
+        @combine_priority = combine_priority
+
         assert_source_provided
         assert_location_provided
       end
@@ -61,12 +69,22 @@ module Solargraph
         Solargraph.assert_or_log(:best_location, "Neither location nor type_location provided - #{path} #{source} #{self.class}")
       end
 
+      # @return [Pin::Closure, nil]
+      def closure
+        Solargraph.assert_or_log(:closure, "Closure not set on #{self.class} #{name.inspect} from #{source.inspect}") unless @closure
+        # @type [Pin::Closure, nil]
+        @closure
+      end
+
       # @param other [self]
-      # @param attrs [Hash{Symbol => Object}]
+      # @param attrs [Hash{::Symbol => Object}]
       #
       # @return [self]
       def combine_with(other, attrs={})
         raise "tried to combine #{other.class} with #{self.class}" unless other.class == self.class
+        priority_choice = choose_priority(other)
+        return priority_choice unless priority_choice.nil?
+
         type_location = choose(other, :type_location)
         location = choose(other, :location)
         combined_name = combine_name(other)
@@ -79,6 +97,7 @@ module Solargraph
           source: :combined,
           docstring: choose(other, :docstring),
           directives: combine_directives(other),
+          combine_priority: combine_priority
         }.merge(attrs)
         assert_same_macros(other)
         logger.debug { "Base#combine_with(path=#{path}) - other.comments=#{other.comments.inspect}, self.comments = #{self.comments}" }
@@ -87,6 +106,25 @@ module Solargraph
         out
       end
 
+      # @param other [self]
+      # @return [self, nil] Returns either the pin chosen based on priority or nil
+      #   A nil return means that the combination process must proceed
+      def choose_priority(other)
+        if combine_priority.nil? && !other.combine_priority.nil?
+          return other
+        elsif other.combine_priority.nil? && !combine_priority.nil?
+          return self
+        elsif !combine_priority.nil? && !other.combine_priority.nil?
+          if combine_priority > other.combine_priority
+            return self
+          elsif combine_priority < other.combine_priority
+            return other
+          end
+        end
+
+        nil
+      end
+
       # @param other [self]
       # @param attr [::Symbol]
       # @sg-ignore
@@ -98,7 +136,6 @@ module Solargraph
         val2 = other.send(attr)
         return val1 if val1 == val2
         return val2 if val1.nil?
-        # @sg-ignore
         val1.length > val2.length ? val1 : val2
       end
 
@@ -188,7 +225,7 @@ module Solargraph
       end
 
       # @param other [self]
-      # @param attr [Symbol]
+      # @param attr [::Symbol]
       # @sg-ignore
       # @return [undefined]
       def choose_node(other, attr)
@@ -237,7 +274,6 @@ module Solargraph
         raise "Expected #{attr} on #{other} to be an Enumerable, got #{arr2.class}" unless arr2.is_a?(::Enumerable)
         # @type arr2 [::Enumerable]
 
-        # @sg-ignore
         # @type [undefined]
         values1 = arr1.map(&block)
         # @type [undefined]
@@ -269,7 +305,8 @@ module Solargraph
       # @param other [self]
       # @param attr [::Symbol]
       #
-      # @return [Object, nil]
+      # @sg-ignore
+      # @return [undefined]
       def assert_same(other, attr)
         return false if other.nil?
         val1 = send(attr)
@@ -300,6 +337,8 @@ module Solargraph
 
       # @param other [self]
       # @param attr [::Symbol]
+      #
+      # @sg-ignore
       # @return [undefined]
       def choose_pin_attr(other, attr)
         # @type [Pin::Base, nil]
@@ -307,11 +346,14 @@ module Solargraph
         # @type [Pin::Base, nil]
         val2 = other.send(attr)
         if val1.class != val2.class
+          # :nocov:
           Solargraph.assert_or_log("combine_with_#{attr}_class".to_sym,
                                    "Inconsistent #{attr.inspect} class values between \nself =#{inspect} and \nother=#{other.inspect}:\n\n self.#{attr} = #{val1.inspect}\nother.#{attr} = #{val2.inspect}")
           return val1
+          # :nocov:
         end
         # arbitrary way of choosing a pin
+        # @sg-ignore Need _1 support
         [val1, val2].compact.min_by { _1.best_location.to_s }
       end
 

data/lib/solargraph/pin/base_variable.rb

@@ -3,8 +3,8 @@
 module Solargraph
   module Pin
     class BaseVariable < Base
-      include Solargraph::Parser::NodeMethods
       # include Solargraph::Source::NodeMethods
+      include Solargraph::Parser::NodeMethods
 
       # @return [Parser::AST::Node, nil]
       attr_reader :assignment
@@ -43,7 +43,6 @@ module Solargraph
         @return_type ||= generate_complex_type
       end
 
-      # @sg-ignore
       def nil_assignment?
         # this will always be false - should it be return_type ==
         #   ComplexType::NIL or somesuch?

data/lib/solargraph/pin/callable.rb

@@ -21,10 +21,13 @@ module Solargraph
         @parameters = parameters
       end
 
+      # @return [String]
       def method_namespace
         closure.namespace
       end
 
+      # @param other [self]
+      # @return [Pin::Block, nil]
       def combine_blocks(other)
         if block.nil?
           other.block
@@ -57,6 +60,8 @@ module Solargraph
         []
       end
 
+      # @param other [self]
+      # @return [Array<Pin::Parameter>]
       def choose_parameters(other)
         raise "Trying to combine two pins with different arities - \nself =#{inspect}, \nother=#{other.inspect}, \n\n self.arity=#{self.arity}, \nother.arity=#{other.arity}" if other.arity != arity
         parameters.zip(other.parameters).map do |param, other_param|
@@ -70,6 +75,7 @@ module Solargraph
         end
       end
 
+      # @return [Array<Pin::Parameter>]
       def blockless_parameters
         if parameters.last&.block?
           parameters[0..-2]
@@ -78,6 +84,7 @@ module Solargraph
         end
       end
 
+      # @return [Array]
       def arity
         [generics, blockless_parameters.map(&:arity_decl), block&.arity]
       end
@@ -125,6 +132,7 @@ module Solargraph
         end
       end
 
+      # @return [String]
       def method_name
         raise "closure was nil in #{self.inspect}" if closure.nil?
         @method_name ||= closure.name
@@ -197,6 +205,7 @@ module Solargraph
         true
       end
 
+      # @return [Integer]
       def mandatory_positional_param_count
         parameters.count(&:arg?)
       end

data/lib/solargraph/pin/closure.rb

@@ -8,6 +8,7 @@ module Solargraph
 
       # @param scope [::Symbol] :class or :instance
       # @param generics [::Array<Pin::Parameter>, nil]
+      # @param generic_defaults [Hash{String => ComplexType}]
       def initialize scope: :class, generics: nil, generic_defaults: {},  **splat
         super(**splat)
         @scope = scope
@@ -15,6 +16,7 @@ module Solargraph
         @generic_defaults = generic_defaults
       end
 
+      # @return [Hash{String => ComplexType}]
       def generic_defaults
         @generic_defaults ||= {}
       end

data/lib/solargraph/pin/common.rb

@@ -3,12 +3,16 @@
 module Solargraph
   module Pin
     module Common
+      # @!method source
+      #   @abstract
+      #   @return [Source, nil]
+      # @type @closure [Pin::Closure, nil]
+
       # @return [Location]
       attr_reader :location
 
+      # @sg-ignore Solargraph::Pin::Common#closure return type could not be inferred
       # @return [Pin::Closure, nil]
-      attr_reader :closure
-
       def closure
         Solargraph.assert_or_log(:closure, "Closure not set on #{self.class} #{name.inspect} from #{source.inspect}") unless @closure
         @closure