solargraph 0.60.3 → 0.61.0

data/lib/solargraph/source/chain.rb

@@ -34,6 +34,7 @@ module Solargraph
       autoload :ZSuper,           'solargraph/source/chain/z_super'
       autoload :Hash,             'solargraph/source/chain/hash'
       autoload :Array,            'solargraph/source/chain/array'
+      autoload :Parameter,        'solargraph/source/chain/parameter'
 
       @@inference_stack = []
       @@inference_depth = 0
@@ -168,7 +169,7 @@ module Solargraph
           return ComplexType::UNDEFINED
         end
         type = infer_from_definitions(pins, links.last.last_context, api_map, locals)
-        out = maybe_nil(type)
+        out = maybe_nil(type, api_map)
         logger.debug do
           "Chain#infer_uncached(links=#{links.map(&:desc)}, locals=#{locals.map(&:desc)}, " \
             "name_pin=#{name_pin}, name_pin.closure=#{name_pin&.closure&.inspect}, " \
@@ -182,6 +183,13 @@ module Solargraph
         links.last.is_a?(Chain::Literal)
       end
 
+      # @return [Boolean]
+      # @sg-ignore false "return type could not be inferred"
+      def require_parameter?
+        # @sg-ignore false "Unresolved call to require_parameter? on Solargraph::Source::Chain::Link"
+        links.last.is_a?(Chain::Parameter) && links.last.require_parameter?
+      end
+
       def undefined?
         links.any?(&:undefined?)
       end
@@ -199,8 +207,38 @@ module Solargraph
         @splat
       end
 
-      def nullable?
-        links.any?(&:nullable?)
+      # Whether this chain's inferred type should have nil added to it
+      # because a `&.` earlier in the chain might have short-circuited
+      # evaluation to nil.
+      #
+      # A `&.` only makes the *immediate* call nil-or-normal-result; a
+      # later, non-safe-navigated call in the same chain is still
+      # invoked on whatever that produced. If receiver is nil at that
+      # point, Ruby calls the method on nil itself instead of skipping
+      # it - so nil only continues to flow through subsequent links
+      # that NilClass defines as returning `self` (e.g., #tap,
+      # #itself). Any other subsequent call resolves to a concrete,
+      # non-nil-including type (e.g. NilClass#== returns Boolean), and
+      # nil no longer needs to be tracked past that point (unless a
+      # later `&.` reintroduces it).
+      #
+      # @param api_map [ApiMap]
+      # @return [Boolean]
+      def nullable? api_map
+        currently_nullable = false
+        links.each do |link|
+          if link.nullable?
+            currently_nullable = true
+            next
+          end
+          next unless currently_nullable
+          next unless link.is_a?(Chain::Call)
+
+          pin = api_map.get_method_stack('NilClass', link.word, scope: :instance).first
+          # @sg-ignore Need to add nil check here
+          currently_nullable = pin.nil? || pin.return_type.tag == 'self'
+        end
+        currently_nullable
       end
 
       include Logging
@@ -286,10 +324,11 @@ module Solargraph
       end
 
       # @param type [ComplexType, ComplexType::UniqueType]
+      # @param api_map [ApiMap]
       # @return [ComplexType, ComplexType::UniqueType]
-      def maybe_nil type
+      def maybe_nil type, api_map
         return type if type.undefined? || type.void? || type.nullable?
-        return type unless nullable?
+        return type unless nullable?(api_map)
         ComplexType.new(type.items + [ComplexType::NIL])
       end
 

data/lib/solargraph/source/source_chainer.rb

@@ -31,55 +31,18 @@ module Solargraph
 
       # @return [Source::Chain]
       def chain
-        # Special handling for files that end with an integer and a period
-        # if phrase =~ /^[0-9]+\.$/
-        #   return Chain.new([Chain::Literal.new('Integer', Integer(phrase[0..-2])),
-        #                     Chain::UNDEFINED_CALL])
-        # end
-        if phrase.start_with?(':') && !phrase.start_with?('::')
-          return Chain.new([Chain::Literal.new('Symbol',
-                                               # @sg-ignore Need to add nil check here
-                                               phrase[1..].to_sym)])
-        end
-        if end_of_phrase.strip == '::' && source.code[Position.to_offset(
-          source.code, position
-        )].to_s.match?(/[a-z]/i)
-          return SourceChainer.chain(source,
-                                     Position.new(position.line,
-                                                  position.character + 1))
-        end
+        return SourceChainer.chain(source, Position.new(position.line, position.character + 1)) if end_of_phrase.strip == '::' && source.code[Position.to_offset(source.code, position)].to_s.match?(/[a-z]/i)
+
         begin
-          return Chain.new([]) if phrase.end_with?('..')
-          # @type [::Parser::AST::Node, nil]
-          node = nil
-          # @type [::Parser::AST::Node, nil]
-          parent = nil
-          if !source.repaired? && source.parsed? && source.synchronized?
-            tree = source.tree_at(position.line, position.column)
-            node, parent = tree[0..2]
-          elsif source.parsed? && source.repaired? && end_of_phrase == '.'
-            node, parent = source.tree_at(fixed_position.line, fixed_position.column)[0..2]
-            # provide filename and line so that we can look up local variables there later
-            node = Parser.parse(fixed_phrase, source.filename, fixed_position.line) if node.nil?
-          elsif source.repaired?
-            node = Parser.parse(fixed_phrase, source.filename, fixed_position.line)
-          else
-            unless source.error_ranges.any? do |r|
-              r.nil? || r.include?(fixed_position)
-            end
-              node, parent = source.tree_at(fixed_position.line,
-                                            fixed_position.column)[0..2]
-            end
-            # Exception for positions that chain literal nodes in unsynchronized sources
-            node = nil unless source.synchronized? || !Parser.infer_literal_node_type(node).nil?
-            node = Parser.parse(fixed_phrase, source.filename, fixed_position.line) if node.nil?
-          end
+          node, parent, tree = node_from_position
         rescue Parser::SyntaxError
           return Chain.new([Chain::UNDEFINED_CALL])
         end
+
         return Chain.new([Chain::UNDEFINED_CALL]) if node.nil? || (node.type == :sym && !phrase.start_with?(':'))
-        # chain = NodeChainer.chain(node, source.filename, parent && parent.type == :block)
-        chain = Parser.chain(node, source.filename, parent)
+
+        chain = Parser.chain(node, source.filename, parent, tree)
+
         if source.repaired? || !source.parsed? || !source.synchronized?
           if end_of_phrase.strip == '.'
             chain.links.push Chain::UNDEFINED_CALL
@@ -94,6 +57,39 @@ module Solargraph
 
       private
 
+      # @return [Array(Parser::AST::Node, Parser::AST::Node, Array<Parser::AST::Node>)]
+      #   parent node, child node, and the tree at the position
+      def node_from_position
+        node = nil
+        parent = nil
+        tree = nil
+
+        if source.parsed? && !source.repaired? && source.synchronized?
+          tree = source.tree_at(position.line, position.column)
+          node, parent = tree[0..2]
+        elsif source.parsed? && source.repaired? && end_of_phrase == '.'
+          tree = source.tree_at(fixed_position.line, fixed_position.column)
+          node, parent = tree[0..2]
+          # provide filename and line so that we can look up local variables there later
+          node = Parser.parse(fixed_phrase, source.filename, fixed_position.line) if node.nil?
+          tree = source.tree_at(fixed_position.line, fixed_position.column) if node
+        elsif source.repaired?
+          node = Parser.parse(fixed_phrase, source.filename, fixed_position.line)
+          tree = source.tree_at(fixed_position.line, fixed_position.column) if node
+        else
+          unless source.error_ranges.any? { |r| r.nil? || r.include?(fixed_position) }
+            tree = source.tree_at(fixed_position.line, fixed_position.column)
+            node, parent = tree[0..2]
+          end
+          # Exception for positions that chain literal nodes in unsynchronized sources
+          node = nil unless source.synchronized? || !Parser.infer_literal_node_type(node).nil?
+          node = Parser.parse(fixed_phrase, source.filename, fixed_position.line) if node.nil?
+          tree = source.tree_at(fixed_position.line, fixed_position.column) if node
+        end
+
+        [node, parent, tree]
+      end
+
       # @return [Position]
       attr_reader :position
 

data/lib/solargraph/source_map/clip.rb

@@ -13,14 +13,14 @@ module Solargraph
         @cursor = cursor
         closure_pin = closure
         # @sg-ignore Need to add nil check here
-        if closure_pin.is_a?(Pin::Block) && !Solargraph::Range.from_node(closure_pin.receiver).contain?(cursor.range.start)
+        if closure_pin.is_a?(Pin::Block) && !Solargraph::Range.from_node(closure_pin.receiver)&.contain?(cursor.range.start)
           closure_pin.rebind(api_map)
         end
       end
 
       # @return [Array<Pin::Base>] Relevant pins for infering the type of the Cursor's position
       def define
-        return [] if cursor.comment? || cursor.chain.literal?
+        return [] if cursor.comment? || cursor.chain.literal? || cursor.chain.require_parameter?
         result = cursor.chain.define(api_map, closure, locals)
         result.concat file_global_methods
         if result.empty?
@@ -40,7 +40,8 @@ module Solargraph
       # @return [Completion]
       def complete
         return package_completions([]) if !source_map.source.parsed? || cursor.string?
-        if cursor.chain.literal? && cursor.chain.links.last.word == '<Symbol>'
+        # TODO: Improve magic word comparsion == '<::Symbol>', too fragile
+        if cursor.chain.literal? && cursor.chain.links.last.word == '<::Symbol>'
           return package_completions(api_map.get_symbols)
         end
         return Completion.new([], cursor.range) if cursor.chain.literal?
@@ -211,6 +212,7 @@ module Solargraph
               result.concat api_map.get_constants('', cursor.start_of_constant? ? '' : context_pin.full_context.namespace, *gates) # .select { |pin| pin.name.start_with?(full) }
             end
           else
+            type = type.qualify(api_map, *gates)
             result.concat api_map.get_constants(type.namespace,
                                                 cursor.start_of_constant? ? '' : context_pin.full_context.namespace, *gates)
           end

data/lib/solargraph/source_map/mapper.rb

@@ -12,7 +12,7 @@ module Solargraph
 
       private_class_method :new
 
-      DIRECTIVE_REGEXP = /(@!method|@!attribute|@!visibility|@!domain|@!macro|@!parse|@!override)/
+      DIRECTIVE_REGEXP = /(@!method|@!attribute|@!visibility|@!scope|@!domain|@!macro|@!parse|@!override)/
 
       # Generate the data.
       #
@@ -104,9 +104,13 @@ module Solargraph
         directive_processor = YardMap::Directives.for(directive)
         return unless directive_processor
 
-        @pins += directive_processor.process_directive(
+        new_pins = directive_processor.process_directive(
           @source, @pins, source_position, comment_position, directive
         )
+        # A @!scope directive in the indented text of another directive applies
+        # only to the object that directive defines.
+        YardMap::Directives::ScopeDirective.apply_nested directive, new_pins
+        @pins += new_pins
       end
 
       # @param comment [String]

data/lib/solargraph/source_map.rb

@@ -190,10 +190,12 @@ module Solargraph
       end
     end
 
-    private
-
     # @return [Array<Pin::Base>]
-    attr_writer :convention_pins
+    def convention_pins
+      @convention_pins || []
+    end
+
+    private
 
     # @return [Hash{Class<Pin::Base> => Array<Pin::Base>}]
     def pin_class_hash
@@ -206,9 +208,12 @@ module Solargraph
       @data ||= Data.new(source)
     end
 
+    # @param pins [Array<Pin::Base>]
     # @return [Array<Pin::Base>]
-    def convention_pins
-      @convention_pins || []
+    def convention_pins= pins
+      # unmemoizing the document_symbols in case it was called from any of conventions
+      @document_symbols = nil
+      @convention_pins = pins
     end
 
     # @generic T

data/lib/solargraph/type_checker/rules.rb

@@ -75,7 +75,7 @@ module Solargraph
       # @todo 22: Translate to something flow sensitive typing understands
       # @todo 3: Need a downcast here
       #
-      # flow sensitive typing could handle (96):
+      # flow sensitive typing could handle (97):
       #
       # @todo 36: flow sensitive typing needs to handle attrs
       # @todo 29: flow sensitive typing should be able to handle redefinition
@@ -113,6 +113,7 @@ module Solargraph
       # @todo 1: flow sensitive typing needs to create separate ranges for postfix if
       # @todo 1: flow sensitive typing needs to handle constants
       # @todo 1: flow sensitive typing needs to eliminate literal from union with return if foo == :bar
+      # @todo 1: Array#flatten returns a bare Array
       def require_all_unique_types_match_expected?
         report?(:require_all_unique_types_match_expected, :strong)
       end

data/lib/solargraph/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Solargraph
-  VERSION = ENV.fetch('SOLARGRAPH_FORCE_VERSION', '0.60.3')
+  VERSION = ENV.fetch('SOLARGRAPH_FORCE_VERSION', '0.61.0')
 end

data/lib/solargraph/workspace.rb

@@ -10,7 +10,6 @@ module Solargraph
   #
   class Workspace
     autoload :Config, 'solargraph/workspace/config'
-    autoload :Gemspecs, 'solargraph/workspace/gemspecs'
     autoload :RequirePaths, 'solargraph/workspace/require_paths'
 
     # @return [String]

data/lib/solargraph/yard_map/cache.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Solargraph
-  class YardMap
+  module YardMap
     class Cache
       def initialize
         # @type [Hash{String => Array<Solargraph::Pin::Base>}]

data/lib/solargraph/yard_map/directives/attribute_directive.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Solargraph
-  class YardMap
+  module YardMap
     module Directives
       module AttributeDirective
         module_function

data/lib/solargraph/yard_map/directives/domain_directive.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Solargraph
-  class YardMap
+  module YardMap
     module Directives
       module DomainDirective
         module_function

data/lib/solargraph/yard_map/directives/method_directive.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Solargraph
-  class YardMap
+  module YardMap
     module Directives
       module MethodDirective
         module_function

data/lib/solargraph/yard_map/directives/override_directive.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Solargraph
-  class YardMap
+  module YardMap
     module Directives
       module OverrideDirective
         module_function

data/lib/solargraph/yard_map/directives/parse_directive.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Solargraph
-  class YardMap
+  module YardMap
     module Directives
       module ParseDirective
         module_function

data/lib/solargraph/yard_map/directives/scope_directive.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module YardMap
+    module Directives
+      # Implements YARD's @!scope directive.
+      #
+      # As described in YARD::Tags::ScopeDirective, a @!scope directive that
+      # appears in a docstring attached to a method definition applies only to
+      # that method. Anywhere else it applies to all of the methods that follow
+      # it within the namespace it was defined in.
+      #
+      #   class Example
+      #     # @!scope class
+      #     def foo; end  # => Example.foo
+      #
+      #     def bar; end  # => Example#bar
+      #   end
+      #
+      #   class Other
+      #     # @!scope class
+      #
+      #     def foo; end  # => Other.foo
+      #
+      #     def bar; end  # => Other.bar
+      #   end
+      #
+      module ScopeDirective
+        module_function
+
+        VALID_SCOPES = %i[class instance].freeze
+
+        # Directives that define an object whose scope is inherited from a
+        # @!scope directive. @!parse is not one of them because the code it
+        # contains already declares the scope of everything it defines.
+        SCOPED_DIRECTIVES = %w[method attribute].freeze
+
+        # @param source [Solargraph::Source]
+        # @param pins [Array<Solargraph::Pin::Base>]
+        # @param source_position [Position]
+        # @param comment_position [Position]
+        # @param directive [YARD::Tags::Directive]
+        # @return [Array<Solargraph::Pin::Base>]
+        def process_directive source, pins, source_position, comment_position, directive
+          kind = parse_scope directive
+          return [] if kind.nil?
+
+          attached = attached_method pins, source_position
+          if attached && no_empty_lines?(source.code, comment_position.line, source_position.line)
+            attached.scope = kind
+          else
+            apply_to_namespace pins, kind, source_position
+          end
+
+          []
+        end
+
+        # @param directive [YARD::Tags::Directive]
+        # @return [::Symbol, nil] :class, :instance, or nil if the directive is malformed
+        def parse_scope directive
+          kind = directive.tag.text.to_s.strip.downcase.to_sym
+          VALID_SCOPES.include?(kind) ? kind : nil
+        end
+
+        # True if the scope of the object defined by this directive can be set
+        # by a @!scope directive.
+        #
+        # @param directive [YARD::Tags::Directive]
+        # @return [Boolean]
+        def scopes_directive? directive
+          SCOPED_DIRECTIVES.include? directive.tag.tag_name
+        end
+
+        # The scope set by a @!scope directive that appears in the indented
+        # text of another directive:
+        #
+        #   @!method foo
+        #     @!scope class
+        #
+        # YARD parses the indented text of a directive with a state of its own,
+        # so a directive nested this way applies only to the object the
+        # enclosing directive defines. It never affects the objects that
+        # follow.
+        #
+        # @param directive [YARD::Tags::Directive]
+        # @return [::Symbol, nil] :class, :instance, or nil if there is none
+        def nested_scope directive
+          text = directive.tag.text.to_s
+          return nil unless text.include? '@!scope'
+
+          kind = nil
+          Solargraph::Source.parse_docstring(text).directives.each do |nested|
+            next unless nested.tag.tag_name == 'scope'
+
+            # A later directive overrides an earlier one, but an invalid value
+            # leaves the current one in place, as it does in YARD.
+            kind = parse_scope(nested) || kind
+          end
+          kind
+        end
+
+        # Set the scope of pins generated by a directive.
+        #
+        # @param pins [Array<Solargraph::Pin::Base>]
+        # @param kind [::Symbol, nil] :class or :instance; nothing happens if nil
+        # @return [void]
+        def apply_scope pins, kind
+          return if kind.nil?
+
+          # Only methods have a scope. Applying one to any other kind of pin,
+          # such as a namespace generated by @!parse, would corrupt its path.
+          pins.each { |pin| pin.scope = kind if pin.is_a?(Pin::Method) }
+        end
+
+        # Apply a @!scope directive from the indented text of another directive
+        # to the pins that directive generated.
+        #
+        # @param directive [YARD::Tags::Directive]
+        # @param pins [Array<Solargraph::Pin::Base>] the pins generated by the directive
+        # @return [void]
+        def apply_nested directive, pins
+          return unless scopes_directive? directive
+
+          apply_scope pins, nested_scope(directive)
+        end
+
+        # Applies the scope to each method that follows the directive within
+        # the namespace the directive appears in. Methods in nested namespaces
+        # are excluded, since the directive only affects its own namespace.
+        #
+        # @param pins [Array<Solargraph::Pin::Base>]
+        # @param kind [::Symbol] :class or :instance
+        # @param source_position [Position]
+        # @return [void]
+        def apply_to_namespace pins, kind, source_position
+          namespace = namespace_at pins, source_position
+          return if namespace.nil?
+
+          pins.each do |pin|
+            next unless pin.is_a?(Pin::Method)
+            next unless pin.namespace == namespace.path
+            # @sg-ignore flow sensitive typing should narrow location after the nil check
+            next if pin.location.nil? || pin.location.range.start.line < source_position.line
+
+            pin.scope = kind
+          end
+        end
+
+        # The method defined on the line the comment is attached to, if any.
+        #
+        # @param pins [Array<Solargraph::Pin::Base>]
+        # @param source_position [Position]
+        # @return [Pin::Method, nil]
+        def attached_method pins, source_position
+          pins.select { |pin| pin.is_a?(Pin::Method) && pin.location&.range&.contain?(source_position) }.last
+        end
+
+        # @param pins [Array<Solargraph::Pin::Base>]
+        # @param position [Position]
+        # @return [Pin::Namespace, nil]
+        def namespace_at pins, position
+          pins.select { |pin| pin.is_a?(Pin::Namespace) && pin.location&.range&.contain?(position) }.last
+        end
+
+        # @param code [String]
+        # @param line1 [Integer]
+        # @param line2 [Integer]
+        # @return [Boolean]
+        def no_empty_lines? code, line1, line2
+          lines = code.lines[line1..line2]
+          return false if lines.nil?
+
+          lines.none? { |line| line.strip.empty? }
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/yard_map/directives/visibility_directive.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Solargraph
-  class YardMap
+  module YardMap
     module Directives
       module VisibilityDirective
         module_function

data/lib/solargraph/yard_map/directives.rb

@@ -1,17 +1,18 @@
 # frozen_string_literal: true
 
 module Solargraph
-  class YardMap
+  module YardMap
     module Directives
       autoload :AttributeDirective, 'solargraph/yard_map/directives/attribute_directive'
       autoload :MethodDirective, 'solargraph/yard_map/directives/method_directive'
       autoload :DomainDirective, 'solargraph/yard_map/directives/domain_directive'
       autoload :OverrideDirective, 'solargraph/yard_map/directives/override_directive'
       autoload :ParseDirective, 'solargraph/yard_map/directives/parse_directive'
+      autoload :ScopeDirective, 'solargraph/yard_map/directives/scope_directive'
       autoload :VisibilityDirective, 'solargraph/yard_map/directives/visibility_directive'
 
       # @param directive [YARD::Tags::Directive]
-      # @return [Class<AttributeDirective>, Class<MethodDirective>, Class<DomainDirective>, Class<OverrideDirective>, Class<ParseDirective>, Class<VisibilityDirective>, nil]
+      # @return [Class<AttributeDirective>, Class<MethodDirective>, Class<DomainDirective>, Class<OverrideDirective>, Class<ParseDirective>, Class<ScopeDirective>, Class<VisibilityDirective>, nil]
       def self.for directive
         case directive.tag.tag_name
         when 'attribute'
@@ -24,6 +25,8 @@ module Solargraph
           OverrideDirective
         when 'parse'
           ParseDirective
+        when 'scope'
+          ScopeDirective
         when 'visibility'
           VisibilityDirective
         else # rubocop:disable Style/EmptyElse

data/lib/solargraph/yard_map/helpers.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Solargraph
-  class YardMap
+  module YardMap
     module Helpers
       module_function
 

data/lib/solargraph/yard_map/macro.rb

@@ -1,9 +1,15 @@
 # frozen_string_literal: true
 
 module Solargraph
-  class YardMap
+  module YardMap
     class Macro
-      PROCESSABLE_DIRECTIVES = %w[method attribute parse].freeze
+      PROCESSABLE_DIRECTIVES = %w[method attribute parse scope].freeze
+
+      # Directives whose text is a value rather than a definition. The comments
+      # attached to the macro's call site belong to the objects the macro
+      # generates, but adding them to one of these directives would invalidate
+      # its content.
+      VALUE_DIRECTIVES = %w[parse scope].freeze
 
       class << self
         # @param directive [YARD::Tags::Directive]
@@ -73,13 +79,34 @@ module Solargraph
       # @return [Array<Pin::Base>]
       def generate_pins_from chain, pin, source_map
         call_location = Solargraph::Location.from_node(chain.node)
+        return [] unless call_location
+
+        # A @!scope directive in a macro applies to the objects the macro
+        # generates after it, the same way it applies to the objects that
+        # follow it in a namespace. Its effect ends with the macro.
+        #
+        # @type [::Symbol, nil]
+        inherited_scope = nil
+
         # @param generated_pins [Array<Pin::Base>]
         generate_yardoc_from(chain, source_map).reduce([]) do |generated_pins, directive|
+          # @sg-ignore flow sensitive typing confuses this block variable with the #directive attr reader
+          if directive.tag.tag_name == 'scope'
+            inherited_scope = Directives::ScopeDirective.parse_scope(directive) || inherited_scope
+            next generated_pins
+          end
           directive_processor = YardMap::Directives.for(directive)
-          next generated_pins unless directive_processor && call_location
-          generated_pins + directive_processor.process_directive(
+          next generated_pins unless directive_processor
+          new_pins = directive_processor.process_directive(
             source_map.source, source_map.pins, call_location.range.start, call_location.range.start, directive
           )
+          if Directives::ScopeDirective.scopes_directive?(directive)
+            # A @!scope directive nested in another directive's text applies
+            # only to the object that directive defines.
+            scope = Directives::ScopeDirective.nested_scope(directive) || inherited_scope
+            Directives::ScopeDirective.apply_scope new_pins, scope
+          end
+          generated_pins + new_pins
         end
       end
 
@@ -100,9 +127,11 @@ module Solargraph
           PROCESSABLE_DIRECTIVES.include?(directive.tag.tag_name)
         end
         directives.each do |directive|
+          next if VALUE_DIRECTIVES.include? directive.tag.tag_name
+
           # @sg-ignore chain.node is assumed to exist
           comments = source_map.source.comments_for(chain.node)
-          if comments&.length&.positive? && directive.tag.tag_name != 'parse'
+          if comments&.length&.positive?
             directive.tag.text += "\n#{comments}"
           end
         end