solargraph 0.53.4 → 0.54.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 82af0b18d57296a8eef96680e60f131bad23268e4043d49407d197fc378dd3d2
-  data.tar.gz: 10c5622ac74f0feef06033ed0b851268c876a68581d846b2874fe61a29612acb
+  metadata.gz: 39ad27afe3afb59299f8701f9a7ea3f25a9f95379ef68e53ac0e22eb60f50e21
+  data.tar.gz: 1f01a9d5cdf4aec5b50c245a25b1f7d83e5d6762e5b8f65bc9ce3555654e21ed
 SHA512:
-  metadata.gz: 1671b54ae2c314d5c566629706b6de94ca5de0902d1d56e7b96853a889d54b0caef084a5c416222f6fe9f4d40387ea3b56d34b6af917a36855ae902f0b8acf0d
-  data.tar.gz: e7b24e7c08164da0a0b60fc8f04281bfceef59e95470d3f3e78193b024d615da2ae62f94712222ffac722623f7de8207f7af29013bdad6787c63716556ecaf43
+  metadata.gz: 788f17e92a54e782ea1dcf03cb44245df823ba33b4fe866d1afa5d06c7171b40a4e1f93c97c8b26c13b58be7478b9b07cd75d6735da65ecef21ab6a4a61dbb0e
+  data.tar.gz: 742f43fcdce4a592a80ebe8e3acbd020f39f569cf323621a527e626ae8c6154f7dedb32739b8b62f38e98997ed414ec30471160332ecfb4a2fe5d5052e871333

data/CHANGELOG.md

@@ -1,3 +1,25 @@
+## 0.54.0 - April 14, 2025
+- Add support for simple block argument destructuring (#821)
+- Benchmark the typecheck command (#852)
+- Send Gem Caching Progress Notifications to LSP Clients (#855)
+- [breaking] Fix more complex_type_spec.rb cases (#813)
+- Mass assignment support - e.g., a, b = ['1', '2'] (#843)
+- Memoize result of Chain#infer (#857)
+- Ignore malformed mixins and overloads (#862)
+- Drop Parser::ParserGem::ClassMethods#returns_from_node (#866)
+- Refactor TypeChecker#argument_problems_for for type safety (#867)
+- Specify more type behavior for variable reassignment (#863)
+- One-step source synchronization (#871)
+- Show cache progress in shell commands (#874)
+- Fix miscellaneous scan errors (#875)
+- Synchronous libraries (#876)
+- Fix parsing of Set#classify method signature from RBS (#878)
+- Sync Library#diagnose (#882)
+- Doesn't false-alarm over splatted non-final args in typechecking (#883)
+- Remove accidental inclusion of Module's methods in objects (#884)
+- Remove another splat-related false alarm in strict typechecking (#889)
+- Change require path `warn` to `debug` (#897)
+
 ## 0.53.4 - March 30, 2025
 - [regression] Restore 'Unresolved call' typecheck for stdlib objects (#849)
 - Lazy dynamic rebinding (#851)

data/lib/solargraph/api_map/cache.rb

@@ -78,20 +78,10 @@ module Solargraph
         @receiver_definitions[path] = pin
       end
 
-      # @param cursor [Source::Cursor]
-      # @return [SourceMap::Clip, nil]
-      def get_clip(cursor)
-        @clips["#{cursor.filename}|#{cursor.range.inspect}|#{cursor.node&.to_sexp}"]
-      end
-
-      # @param cursor [Source::Cursor]
-      # @param clip [SourceMap::Clip]
-      def set_clip(cursor, clip)
-        @clips["#{cursor.filename}|#{cursor.range.inspect}|#{cursor.node&.to_sexp}"] = clip
-      end
-
       # @return [void]
       def clear
+        return if empty?
+
         all_caches.each(&:clear)
       end
 

data/lib/solargraph/api_map/store.rb

@@ -65,6 +65,10 @@ module Solargraph
         path_pin_hash[path] || []
       end
 
+      def cacheable_pins
+        @cacheable_pins ||= pins_by_class(Pin::Namespace) + pins_by_class(Pin::Constant) + pins_by_class(Pin::Method) + pins_by_class(Pin::Reference)
+      end
+
       # @param fqns [String]
       # @param scope [Symbol] :class or :instance
       # @return [Enumerable<Solargraph::Pin::Base>]
@@ -96,7 +100,7 @@ module Solargraph
         @namespaces ||= Set.new
       end
 
-      # @return [Enumerable<Solargraph::Pin::Base>]
+      # @return [Array<Solargraph::Pin::Base>]
       def namespace_pins
         pins_by_class(Solargraph::Pin::Namespace)
       end
@@ -140,8 +144,9 @@ module Solargraph
         to_s
       end
 
-      # @param klass [Class]
-      # @return [Enumerable<Solargraph::Pin::Base>]
+      # @generic T
+      # @param klass [Class<T>]
+      # @return [Array<T>]
       def pins_by_class klass
         # @type [Set<Solargraph::Pin::Base>]
         s = Set.new
@@ -165,7 +170,7 @@ module Solargraph
 
       private
 
-      # @return [Hash{Array(String, String) => Array<Pin::Namespace>}]
+      # @return [Hash{::Array(String, String) => ::Array<Pin::Namespace>}]
       def fqns_pins_map
         @fqns_pins_map ||= Hash.new do |h, (base, name)|
           value = namespace_children(base).select { |pin| pin.name == name && pin.is_a?(Pin::Namespace) }
@@ -178,7 +183,7 @@ module Solargraph
         pins_by_class(Pin::Symbol)
       end
 
-      # @return [Hash{String => Enumerable<String>}]
+      # @return [Hash{String => Array<String>}]
       def superclass_references
         @superclass_references ||= {}
       end
@@ -243,7 +248,7 @@ module Solargraph
       def index
         set = pins.to_set
         @pin_class_hash = set.classify(&:class).transform_values(&:to_a)
-        # @type [Hash{Class => Enumerable<Solargraph::Pin::Base>}]
+        # @type [Hash{Class => ::Array<Solargraph::Pin::Base>}]
         @pin_select_cache = {}
         @namespace_map = set.classify(&:namespace)
         @path_pin_hash = set.classify(&:path)

data/lib/solargraph/api_map.rb

@@ -29,6 +29,25 @@ module Solargraph
       index pins
     end
 
+    #
+    # This is a mutable object, which is cached in the Chain class -
+    # if you add any fields which change the results of calls (not
+    # just caches), please also change `equality_fields` below.
+    #
+
+    def eql?(other)
+      self.class == other.class &&
+        equality_fields == other.equality_fields
+    end
+
+    def ==(other)
+      self.eql?(other)
+    end
+
+    def hash
+      equality_fields.hash
+    end
+
     # @param pins [Array<Pin::Base>]
     # @return [self]
     def index pins
@@ -56,21 +75,31 @@ module Solargraph
     # @param bench [Bench]
     # @return [self]
     def catalog bench
-      implicit.clear
-      @cache.clear
+      old_api_hash = @source_map_hash&.values&.map(&:api_hash)
+      need_to_uncache = (old_api_hash != bench.source_maps.map(&:api_hash))
       @source_map_hash = bench.source_maps.map { |s| [s.filename, s] }.to_h
-      pins = bench.source_maps.map(&:pins).flatten
+      pins = bench.source_maps.flat_map(&:pins).flatten
+      implicit.clear
       source_map_hash.each_value do |map|
         implicit.merge map.environ
       end
-      unresolved_requires = (bench.external_requires + implicit.requires + bench.workspace.config.required).uniq
-      @doc_map = DocMap.new(unresolved_requires, []) # @todo Implement gem preferences
+      unresolved_requires = (bench.external_requires + implicit.requires + bench.workspace.config.required).to_a.compact.uniq
+      if @unresolved_requires != unresolved_requires || @doc_map&.uncached_gemspecs&.any?
+        @doc_map = DocMap.new(unresolved_requires, [], bench.workspace.rbs_collection_path) # @todo Implement gem preferences
+        @unresolved_requires = unresolved_requires
+        need_to_uncache = true
+      end
       @store = Store.new(@@core_map.pins + @doc_map.pins + implicit.pins + pins)
-      @unresolved_requires = @doc_map.unresolved_requires
+      @cache.clear if need_to_uncache
+
       @missing_docs = [] # @todo Implement missing docs
       self
     end
 
+    protected def equality_fields
+      [self.class, @source_map_hash, implicit, @doc_map, @unresolved_requires, @missing_docs]
+    end
+
     # @return [::Array<Gem::Specification>]
     def uncached_gemspecs
       @doc_map&.uncached_gemspecs || []
@@ -133,14 +162,19 @@ module Solargraph
     # Create an ApiMap with a workspace in the specified directory and cache
     # any missing gems.
     #
+    #
+    # @todo IO::NULL is incorrectly inferred to be a String.
+    # @sg-ignore
+    #
     # @param directory [String]
+    # @param out [IO] The output stream for messages
     # @return [ApiMap]
-    def self.load_with_cache directory
+    def self.load_with_cache directory, out = IO::NULL
       api_map = load(directory)
       return api_map if api_map.uncached_gemspecs.empty?
 
       api_map.uncached_gemspecs.each do |gemspec|
-        Solargraph.logger.info "Caching #{gemspec.name} #{gemspec.version}..."
+        out.puts "Caching gem #{gemspec.name} #{gemspec.version}"
         pins = GemPins.build(gemspec)
         Solargraph::Cache.save('gems', "#{gemspec.name}-#{gemspec.version}.ser", pins)
       end
@@ -221,10 +255,15 @@ module Solargraph
     # @return [String, nil] fully qualified tag
     def qualify tag, context_tag = ''
       return tag if ['self', nil].include?(tag)
-      context_type = ComplexType.parse(context_tag)
-      type = ComplexType.parse(tag)
+      context_type = ComplexType.try_parse(context_tag)
+      return unless context_type
+
+      type = ComplexType.try_parse(tag)
+      return unless type
+
       fqns = qualify_namespace(type.rooted_namespace, context_type.rooted_namespace)
-      return nil if fqns.nil?
+      return unless fqns
+
       fqns + type.substring
     end
 
@@ -332,7 +371,7 @@ module Solargraph
           end
         end
         result.concat inner_get_methods('Kernel', :instance, [:public], deep, skip) if visibility.include?(:private)
-        result.concat inner_get_methods('Module', scope, visibility, deep, skip)
+        result.concat inner_get_methods('Module', scope, visibility, deep, skip) if scope == :module
       end
       resolved = resolve_method_aliases(result, visibility)
       cache.set_methods(rooted_tag, scope, visibility, deep, resolved)
@@ -466,9 +505,6 @@ module Solargraph
     def clip cursor
       raise FileNotFoundError, "ApiMap did not catalog #{cursor.filename}" unless source_map_hash.key?(cursor.filename)
 
-      # @todo Clip caches are disabled pending resolution of a stale cache bug
-      # cache.get_clip(cursor) ||
-      #   SourceMap::Clip.new(self, cursor).tap { |clip| cache.set_clip(cursor, clip) }
       SourceMap::Clip.new(self, cursor)
     end
 
@@ -573,8 +609,8 @@ module Solargraph
       # namespaces; resolving the generics in the method pins is this
       # class' responsibility
       raw_methods = store.get_methods(fqns, scope: scope, visibility: visibility).sort{ |a, b| a.name <=> b.name }
-      namespace_pin = store.get_path_pins(fqns).select{|p| p.is_a?(Pin::Namespace)}.first
-      methods = if rooted_tag != fqns
+      namespace_pin = store.get_path_pins(fqns).select { |p| p.is_a?(Pin::Namespace) }.first
+      methods = if namespace_pin && rooted_tag != fqns
                   methods = raw_methods.map do |method_pin|
                     method_pin.resolve_generics(namespace_pin, rooted_type)
                   end

data/lib/solargraph/complex_type/type_methods.rb

@@ -22,14 +22,18 @@ module Solargraph
       # @return [String]
       attr_reader :name
 
-      # @return [String]
-      attr_reader :substring
+      # @return [Array<ComplexType>]
+      attr_reader :subtypes
 
       # @return [String]
-      attr_reader :tag
+      def tag
+        @tag ||= "#{name}#{substring}"
+      end
 
-      # @return [Array<ComplexType>]
-      attr_reader :subtypes
+      # @return [String]
+      def rooted_tag
+        @rooted_tag ||= rooted_name + rooted_substring
+      end
 
       # @return [Boolean]
       def duck_type?
@@ -46,6 +50,10 @@ module Solargraph
         !substring.empty?
       end
 
+      def tuple?
+        @tuple_type ||= (name == 'Tuple') || (name == 'Array' && subtypes.length >= 1 && fixed_parameters?)
+      end
+
       def void?
         name == 'void'
       end
@@ -74,19 +82,28 @@ module Solargraph
         end
       end
 
+      # @return [Symbol, nil]
+      attr_reader :parameters_type
+
+      PARAMETERS_TYPE_BY_STARTING_TAG = {
+        '{' => :hash,
+        '(' => :fixed,
+        '<' => :list
+      }.freeze
+
       # @return [Boolean]
       def list_parameters?
-        substring.start_with?('<')
+        parameters_type == :list
       end
 
       # @return [Boolean]
       def fixed_parameters?
-        substring.start_with?('(')
+        parameters_type == :fixed
       end
 
       # @return [Boolean]
       def hash_parameters?
-        substring.start_with?('{')
+        parameters_type == :hash
       end
 
       # @return [Array<ComplexType>]
@@ -121,6 +138,33 @@ module Solargraph
         "::#{name}"
       end
 
+      # @return [String]
+      def substring
+        @substring ||= generate_substring_from(&:tags)
+      end
+
+      # @return [String]
+      def rooted_substring
+        @rooted_substring = generate_substring_from(&:rooted_tags)
+      end
+
+      # @return [String]
+      def generate_substring_from(&to_str)
+        key_types_str = key_types.map(&to_str).join(', ')
+        subtypes_str = subtypes.map(&to_str).join(', ')
+        if key_types.none?(&:defined?) && subtypes.none?(&:defined?)
+          ''
+        elsif key_types.empty? && subtypes.empty?
+          ''
+        elsif hash_parameters?
+          "{#{key_types_str} => #{subtypes_str}}"
+        elsif fixed_parameters?
+          "(#{subtypes_str})"
+        else
+          "<#{subtypes_str}>"
+        end
+      end
+
       # @return [::Symbol] :class or :instance
       def scope
         @scope ||= :instance if duck_type? || nil_type?
@@ -143,28 +187,16 @@ module Solargraph
       # @param context [String] The namespace from which to resolve names
       # @return [self, ComplexType, UniqueType] The generated ComplexType
       def qualify api_map, context = ''
-        return self if name == GENERIC_TAG_NAME
-        return ComplexType.new([self]) if duck_type? || void? || undefined?
-        recon = (rooted? ? '' : context)
-        fqns = api_map.qualify(name, recon)
-        if fqns.nil?
-          return UniqueType::BOOLEAN if tag == 'Boolean'
-          return UniqueType::UNDEFINED
-        end
-        fqns = "::#{fqns}" # Ensure the resulting complex type is rooted
-        all_ltypes = key_types.map { |t| t.qualify api_map, context }.uniq
-        all_rtypes = value_types.map { |t| t.qualify api_map, context }
-        if list_parameters?
-          rtypes = all_rtypes.uniq
-          Solargraph::ComplexType.parse("#{fqns}<#{rtypes.map(&:tag).join(', ')}>")
-        elsif fixed_parameters?
-          Solargraph::ComplexType.parse("#{fqns}(#{all_rtypes.map(&:tag).join(', ')})")
-        elsif hash_parameters?
-          ltypes = all_ltypes.uniq
-          rtypes = all_rtypes.uniq
-          Solargraph::ComplexType.parse("#{fqns}{#{ltypes.map(&:tag).join(', ')} => #{rtypes.map(&:tag).join(', ')}}")
-        else
-          Solargraph::ComplexType.parse(fqns)
+        transform do |t|
+          next t if t.name == GENERIC_TAG_NAME
+          next t if t.duck_type? || t.void? || t.undefined?
+          recon = (t.rooted? ? '' : context)
+          fqns = api_map.qualify(t.name, recon)
+          if fqns.nil?
+            next UniqueType::BOOLEAN if t.tag == 'Boolean'
+            next UniqueType::UNDEFINED
+          end
+          t.recreate(new_name: fqns, make_rooted: true)
         end
       end
 

data/lib/solargraph/complex_type/unique_type.rb

@@ -17,43 +17,61 @@ module Solargraph
       #
       # @param name [String] The name of the type
       # @param substring [String] The substring of the type
-      def initialize name, substring = ''
+      # @param make_rooted [Boolean, nil]
+      # @return [UniqueType]
+      def self.parse name, substring = '', make_rooted: nil
+        if name.start_with?(':::')
+          raise "Illegal prefix: #{name}"
+        end
         if name.start_with?('::')
-          @name = name[2..-1]
-          @rooted = true
+          name = name[2..-1]
+          rooted = true
         else
-          @name = name
-          @rooted = false
+          rooted = false
         end
-        @substring = substring
-        @tag = @name + substring
-        # @type [Array<ComplexType>]
-        @key_types = []
+        rooted = make_rooted unless make_rooted.nil?
+
         # @type [Array<ComplexType>]
-        @subtypes = []
+        key_types = []
         # @type [Array<ComplexType>]
-        @all_params = []
-        return unless parameters?
-        # @todo we should be able to probe the type of 'subs' without
-        #   hoisting the definition outside of the if statement
-        subs = if @substring.start_with?('<(') && @substring.end_with?(')>')
-                 ComplexType.parse(substring[2..-3], partial: true)
-               else
-                 ComplexType.parse(substring[1..-2], partial: true)
-               end
-        if hash_parameters?
-          raise ComplexTypeError, "Bad hash type" unless !subs.is_a?(ComplexType) and subs.length == 2 and !subs[0].is_a?(UniqueType) and !subs[1].is_a?(UniqueType)
-          # @todo should be able to resolve map; both types have it
-          #   with same return type
-          # @sg-ignore
-          @key_types.concat subs[0].map { |u| ComplexType.new([u]) }
-          # @sg-ignore
-          @subtypes.concat subs[1].map { |u| ComplexType.new([u]) }
-        else
-          @subtypes.concat subs
+        subtypes = []
+        parameters_type = nil
+        unless substring.empty?
+          subs = ComplexType.parse(substring[1..-2], partial: true)
+          parameters_type = PARAMETERS_TYPE_BY_STARTING_TAG.fetch(substring[0])
+          if parameters_type == :hash
+            raise ComplexTypeError, "Bad hash type" unless !subs.is_a?(ComplexType) and subs.length == 2 and !subs[0].is_a?(UniqueType) and !subs[1].is_a?(UniqueType)
+            # @todo should be able to resolve map; both types have it
+            #   with same return type
+            # @sg-ignore
+            key_types.concat(subs[0].map { |u| ComplexType.new([u]) })
+            # @sg-ignore
+            subtypes.concat(subs[1].map { |u| ComplexType.new([u]) })
+          else
+            subtypes.concat subs
+          end
         end
-        @all_params.concat @key_types
-        @all_params.concat @subtypes
+        new(name, key_types, subtypes, rooted: rooted, parameters_type: parameters_type)
+      end
+
+      # @param name [String]
+      # @param key_types [Array<ComplexType>]
+      # @param subtypes [Array<ComplexType>]
+      # @param rooted [Boolean]
+      # @param parameters_type [Symbol, nil]
+      def initialize(name, key_types = [], subtypes = [], rooted:, parameters_type: nil)
+        if parameters_type.nil?
+          raise "You must supply parameters_type if you provide parameters" unless key_types.empty? && subtypes.empty?
+        end
+        raise "Please remove leading :: and set rooted instead - #{name}" if name.start_with?('::')
+        @name = name
+        @key_types = key_types
+        @subtypes = subtypes
+        @rooted = rooted
+        @all_params = []
+        @all_params.concat key_types
+        @all_params.concat subtypes
+        @parameters_type = parameters_type
       end
 
       def to_s
@@ -76,7 +94,17 @@ module Solargraph
 
       # @return [String]
       def to_rbs
-        if ['Tuple', 'Array'].include?(name) && fixed_parameters?
+        if duck_type?
+          'untyped'
+        elsif name == 'Boolean'
+          'bool'
+        elsif name.downcase == 'nil'
+          'nil'
+        elsif name == GENERIC_TAG_NAME
+          all_params.first.name
+        elsif ['Class', 'Module'].include?(name)
+          rbs_name
+        elsif ['Tuple', 'Array'].include?(name) && fixed_parameters?
           # tuples don't have a name; they're just [foo, bar, baz].
           if substring == '()'
             # but there are no zero element tuples, so we go with an array
@@ -90,16 +118,37 @@ module Solargraph
         end
       end
 
+      # @return [Boolean]
+      def parameters?
+        !all_params.empty?
+      end
+
+      # @param types [Array<UniqueType, ComplexType>]
+      # @return [String]
+      def rbs_union(types)
+        if types.length == 1
+          types.first.to_rbs
+        else
+          "(#{types.map(&:to_rbs).join(' | ')})"
+        end
+      end
+
       # @return [String]
       def parameters_as_rbs
-        parameters? ? "[#{all_params.map { |s| s.to_rbs }.join(', ')}]" : ''
+        return '' unless parameters?
+
+        return "[#{all_params.map(&:to_rbs).join(', ')}]" if key_types.empty?
+
+        # handle, e.g., Hash[K, V] case
+        key_types_str = rbs_union(key_types)
+        subtypes_str = rbs_union(subtypes)
+        "[#{key_types_str}, #{subtypes_str}]"
       end
 
       def generic?
         name == GENERIC_TAG_NAME || all_params.any?(&:generic?)
       end
 
-
       # @param generics_to_resolve [Enumerable<String>]
       # @param context_type [UniqueType, nil]
       # @param resolved_generic_values [Hash{String => ComplexType}] Added to as types are encountered or resolved
@@ -182,39 +231,34 @@ module Solargraph
       end
 
       # @param new_name [String, nil]
+      # @param make_rooted [Boolean, nil]
       # @param new_key_types [Array<UniqueType>, nil]
+      # @param rooted [Boolean, nil]
       # @param new_subtypes [Array<UniqueType>, nil]
       # @return [self]
-      def recreate(new_name: nil, new_key_types: nil, new_subtypes: nil)
+      def recreate(new_name: nil, make_rooted: nil, new_key_types: nil, new_subtypes: nil)
+        raise "Please remove leading :: and set rooted instead - #{new_name}" if new_name&.start_with?('::')
         new_name ||= name
         new_key_types ||= @key_types
         new_subtypes ||= @subtypes
-        if new_key_types.none?(&:defined?) && new_subtypes.none?(&:defined?)
-          # if all subtypes are undefined, erase down to the non-parametric type
-          UniqueType.new(new_name)
-        elsif new_key_types.empty? && new_subtypes.empty?
-          UniqueType.new(new_name)
-        elsif hash_parameters?
-          UniqueType.new(new_name, "{#{new_key_types.join(', ')} => #{new_subtypes.join(', ')}}")
-        elsif @substring.start_with?('<(')
-          # @todo This clause is probably wrong, and if so, fixing it
-          #    will be some level of breaking change.  Probably best
-          #    handled before real tuple support is rolled out and
-          #    folks start relying on it more.
-          #
-          #   (String) is a one element tuple in https://yardoc.org/types
-          #   <String> is an array of zero or more Strings in https://yardoc.org/types
-          #   Array<(String)> could be an Array of one-element tuples or a
-          #     one element tuple.  https://yardoc.org/types treats it
-          #     as the former.
-          #   Array<(String), Integer> is not ambiguous if we accept
-          #     (String) as a tuple type, but not currently understood
-          #     by Solargraph.
-          UniqueType.new(new_name, "<(#{new_subtypes.join(', ')})>")
-        elsif fixed_parameters?
-          UniqueType.new(new_name, "(#{new_subtypes.join(', ')})")
-        else
-          UniqueType.new(new_name, "<#{new_subtypes.join(', ')}>")
+        make_rooted = @rooted if make_rooted.nil?
+        UniqueType.new(new_name, new_key_types, new_subtypes, rooted: make_rooted, parameters_type: parameters_type)
+      end
+
+      # @return [String]
+      def rooted_tags
+        rooted_tag
+      end
+
+      # @return [String]
+      def tags
+        tag
+      end
+
+      # @return [self]
+      def force_rooted
+        transform do |t|
+          t.recreate(make_rooted: true)
         end
       end
 
@@ -225,9 +269,16 @@ module Solargraph
       # @yieldreturn [self]
       # @return [self]
       def transform(new_name = nil, &transform_type)
-        new_key_types = @key_types.flat_map { |ct| ct.map { |ut| ut.transform(&transform_type) } }.compact
-        new_subtypes = @subtypes.flat_map { |ct| ct.map { |ut| ut.transform(&transform_type) } }.compact
-        new_type = recreate(new_name: new_name || rooted_name, new_key_types: new_key_types, new_subtypes: new_subtypes)
+        raise "Please remove leading :: and set rooted with recreate() instead - #{new_name}" if new_name&.start_with?('::')
+        if name == ComplexType::GENERIC_TAG_NAME
+          # doesn't make sense to manipulate the name of the generic
+          new_key_types = @key_types
+          new_subtypes = @subtypes
+        else
+          new_key_types = @key_types.flat_map { |ct| ct.items.map { |ut| ut.transform(&transform_type) } }
+          new_subtypes = @subtypes.flat_map { |ct| ct.items.map { |ut| ut.transform(&transform_type) } }
+        end
+        new_type = recreate(new_name: new_name || name, new_key_types: new_key_types, new_subtypes: new_subtypes)
         yield new_type
       end
 
@@ -245,8 +296,8 @@ module Solargraph
         @name == 'self' || @key_types.any?(&:selfy?) || @subtypes.any?(&:selfy?)
       end
 
-      UNDEFINED = UniqueType.new('undefined')
-      BOOLEAN = UniqueType.new('Boolean')
+      UNDEFINED = UniqueType.new('undefined', rooted: false)
+      BOOLEAN = UniqueType.new('Boolean', rooted: true)
     end
   end
 end