solargraph 0.53.4 → 0.54.1

data/lib/solargraph/rbs_map/conversions.rb

@@ -82,7 +82,7 @@ module Solargraph
       def convert_self_type_to_pins decl, closure
         include_pin = Solargraph::Pin::Reference::Include.new(
           name: decl.name.relative!.to_s,
-          location: rbs_location_to_location(decl.location),
+          type_location: location_decl_to_pin_location(decl.location),
           closure: closure
         )
         pins.push include_pin
@@ -144,6 +144,7 @@ module Solargraph
           name: decl.name.relative!.to_s,
           closure: Solargraph::Pin::ROOT_PIN,
           comments: decl.comment&.string,
+          type_location: location_decl_to_pin_location(decl.location),
           # @todo some type parameters in core/stdlib have default
           #   values; Solargraph doesn't support that yet as so these
           #   get treated as undefined if not specified
@@ -152,6 +153,7 @@ module Solargraph
         pins.push class_pin
         if decl.super_class
           pins.push Solargraph::Pin::Reference::Superclass.new(
+            type_location: location_decl_to_pin_location(decl.super_class.location),
             closure: class_pin,
             name: decl.super_class.name.relative!.to_s
           )
@@ -166,6 +168,7 @@ module Solargraph
       def interface_decl_to_pin decl, closure
         class_pin = Solargraph::Pin::Namespace.new(
           type: :module,
+          type_location: location_decl_to_pin_location(decl.location),
           name: decl.name.relative!.to_s,
           closure: Solargraph::Pin::ROOT_PIN,
           comments: decl.comment&.string,
@@ -185,6 +188,7 @@ module Solargraph
         module_pin = Solargraph::Pin::Namespace.new(
           type: :module,
           name: decl.name.relative!.to_s,
+          type_location: location_decl_to_pin_location(decl.location),
           closure: Solargraph::Pin::ROOT_PIN,
           comments: decl.comment&.string,
           generics: decl.type_params.map(&:name).map(&:to_s),
@@ -199,10 +203,11 @@ module Solargraph
       # @param name [String]
       # @param tag [String]
       # @param comments [String]
+      # @param decl [RBS::AST::Declarations::ClassAlias, RBS::AST::Declarations::Constant, RBS::AST::Declarations::ModuleAlias]
       # @param base [String, nil] Optional conversion of tag to base<tag>
       #
       # @return [Solargraph::Pin::Constant]
-      def create_constant(name, tag, comments, base = nil)
+      def create_constant(name, tag, comments, decl, base = nil)
         parts = name.split('::')
         if parts.length > 1
           name = parts.last
@@ -214,10 +219,12 @@ module Solargraph
         constant_pin = Solargraph::Pin::Constant.new(
           name: name,
           closure: closure,
+          type_location: location_decl_to_pin_location(decl.location),
           comments: comments
         )
         tag = "#{base}<#{tag}>" if base
-        constant_pin.docstring.add_tag(YARD::Tags::Tag.new(:return, '', tag))
+        rooted_tag = ComplexType.parse(tag).force_rooted.rooted_tags
+        constant_pin.docstring.add_tag(YARD::Tags::Tag.new(:return, '', rooted_tag))
         constant_pin
       end
 
@@ -228,7 +235,7 @@ module Solargraph
         new_name = decl.new_name.relative!.to_s
         old_name = decl.old_name.relative!.to_s
 
-        pins.push create_constant(new_name, old_name, decl.comment&.string, 'Class')
+        pins.push create_constant(new_name, old_name, decl.comment&.string, decl, 'Class')
       end
 
       # @param decl [RBS::AST::Declarations::ModuleAlias]
@@ -238,14 +245,14 @@ module Solargraph
         new_name = decl.new_name.relative!.to_s
         old_name = decl.old_name.relative!.to_s
 
-        pins.push create_constant(new_name, old_name, decl.comment&.string, 'Module')
+        pins.push create_constant(new_name, old_name, decl.comment&.string, decl,  'Module')
       end
 
       # @param decl [RBS::AST::Declarations::Constant]
       # @return [void]
       def constant_decl_to_pin decl
         tag = other_type_to_tag(decl.type)
-        pins.push create_constant(decl.name.relative!.to_s, tag, decl.comment&.string)
+        pins.push create_constant(decl.name.relative!.to_s, tag, decl.comment&.string, decl)
       end
 
       # @param decl [RBS::AST::Declarations::Global]
@@ -253,13 +260,13 @@ module Solargraph
       def global_decl_to_pin decl
         closure = Solargraph::Pin::ROOT_PIN
         name = decl.name.to_s
-        tag = other_type_to_tag(decl.type)
         pin = Solargraph::Pin::GlobalVariable.new(
           name: name,
           closure: closure,
           comments: decl.comment&.string,
         )
-        pin.docstring.add_tag(YARD::Tags::Tag.new(:type, '', tag))
+        rooted_tag = ComplexType.parse(other_type_to_tag(decl.type)).force_rooted.rooted_tags
+        pin.docstring.add_tag(YARD::Tags::Tag.new(:type, '', rooted_tag))
         pins.push pin
       end
 
@@ -276,6 +283,7 @@ module Solargraph
           pin = Solargraph::Pin::Method.new(
             name: decl.name.to_s,
             closure: closure,
+            type_location: location_decl_to_pin_location(decl.location),
             comments: decl.comment&.string,
             scope: :instance,
             signatures: [],
@@ -295,6 +303,7 @@ module Solargraph
             name: decl.name.to_s,
             closure: closure,
             comments: decl.comment&.string,
+            type_location: location_decl_to_pin_location(decl.location),
             scope: :class,
             signatures: [],
             generics: generics
@@ -310,42 +319,42 @@ module Solargraph
       def method_def_to_sigs decl, pin
         decl.overloads.map do |overload|
           generics = overload.method_type.type_params.map(&:to_s)
-          parameters, return_type = parts_of_function(overload.method_type, pin)
+          signature_parameters, signature_return_type = parts_of_function(overload.method_type, pin)
           block = if overload.method_type.block
-                    Pin::Signature.new(generics, *parts_of_function(overload.method_type.block, pin))
-          end
-          return_type = ComplexType.try_parse(method_type_to_tag(overload.method_type))
-          Pin::Signature.new(generics, parameters, return_type, block)
+                    block_parameters, block_return_type = parts_of_function(overload.method_type.block, pin)
+                    Pin::Signature.new(generics: generics, parameters: block_parameters, return_type: block_return_type)
+                  end
+          Pin::Signature.new(generics: generics, parameters: signature_parameters, return_type: signature_return_type, block: block)
         end
       end
 
       # @param location [RBS::Location, nil]
       # @return [Solargraph::Location, nil]
-      def rbs_location_to_location(location)
+      def location_decl_to_pin_location(location)
         return nil if location&.name.nil?
 
         start_pos = Position.new(location.start_line - 1, location.start_column)
         end_pos = Position.new(location.end_line - 1, location.end_column)
         range = Range.new(start_pos, end_pos)
-        Location.new(location.name, range)
+        Location.new(location.name.to_s, range)
       end
 
       # @param type [RBS::MethodType,RBS::Types::Block]
       # @param pin [Pin::Method]
-      # @return [Array<Array<Pin::Parameter>, ComplexType>]
+      # @return [Array(Array<Pin::Parameter>, ComplexType)]
       def parts_of_function type, pin
-        return [[Solargraph::Pin::Parameter.new(decl: :restarg, name: 'arg', closure: pin)], ComplexType.try_parse(method_type_to_tag(type))] if defined?(RBS::Types::UntypedFunction) && type.type.is_a?(RBS::Types::UntypedFunction)
+        return [[Solargraph::Pin::Parameter.new(decl: :restarg, name: 'arg', closure: pin)], ComplexType.try_parse(method_type_to_tag(type)).force_rooted] if defined?(RBS::Types::UntypedFunction) && type.type.is_a?(RBS::Types::UntypedFunction)
 
         parameters = []
         arg_num = -1
         type.type.required_positionals.each do |param|
           name = param.name ? param.name.to_s : "arg#{arg_num += 1}"
-          parameters.push Solargraph::Pin::Parameter.new(decl: :arg, name: name, closure: pin, return_type: ComplexType.try_parse(other_type_to_tag(param.type)))
+          parameters.push Solargraph::Pin::Parameter.new(decl: :arg, name: name, closure: pin, return_type: ComplexType.try_parse(other_type_to_tag(param.type)).force_rooted)
         end
         type.type.optional_positionals.each do |param|
           name = param.name ? param.name.to_s : "arg#{arg_num += 1}"
           parameters.push Solargraph::Pin::Parameter.new(decl: :optarg, name: name, closure: pin,
-                                                         return_type: ComplexType.try_parse(other_type_to_tag(param.type)))
+                                                         return_type: ComplexType.try_parse(other_type_to_tag(param.type)).force_rooted)
         end
         if type.type.rest_positionals
           name = type.type.rest_positionals.name ? type.type.rest_positionals.name.to_s : "arg#{arg_num += 1}"
@@ -358,18 +367,20 @@ module Solargraph
         type.type.required_keywords.each do |orig, param|
           name = orig ? orig.to_s : "arg#{arg_num += 1}"
           parameters.push Solargraph::Pin::Parameter.new(decl: :kwarg, name: name, closure: pin,
-                                                         return_type: ComplexType.try_parse(other_type_to_tag(param.type)))
+                                                         return_type: ComplexType.try_parse(other_type_to_tag(param.type)).force_rooted)
         end
         type.type.optional_keywords.each do |orig, param|
           name = orig ? orig.to_s : "arg#{arg_num += 1}"
           parameters.push Solargraph::Pin::Parameter.new(decl: :kwoptarg, name: name, closure: pin,
-                                                         return_type: ComplexType.try_parse(other_type_to_tag(param.type)))
+                                                         return_type: ComplexType.try_parse(other_type_to_tag(param.type)).force_rooted)
         end
         if type.type.rest_keywords
           name = type.type.rest_keywords.name ? type.type.rest_keywords.name.to_s : "arg#{arg_num += 1}"
           parameters.push Solargraph::Pin::Parameter.new(decl: :kwrestarg, name: type.type.rest_keywords.name.to_s, closure: pin)
         end
-        return_type = ComplexType.try_parse(method_type_to_tag(type))
+
+        rooted_tag = method_type_to_tag(type)
+        return_type = ComplexType.try_parse(rooted_tag).force_rooted
         [parameters, return_type]
       end
 
@@ -379,12 +390,14 @@ module Solargraph
       def attr_reader_to_pin(decl, closure)
         pin = Solargraph::Pin::Method.new(
           name: decl.name.to_s,
+          type_location: location_decl_to_pin_location(decl.location),
           closure: closure,
           comments: decl.comment&.string,
           scope: :instance,
           attribute: true
         )
-        pin.docstring.add_tag(YARD::Tags::Tag.new(:return, '', other_type_to_tag(decl.type)))
+        rooted_tag = ComplexType.parse(other_type_to_tag(decl.type)).force_rooted.rooted_tags
+        pin.docstring.add_tag(YARD::Tags::Tag.new(:return, '', rooted_tag))
         pins.push pin
       end
 
@@ -394,12 +407,14 @@ module Solargraph
       def attr_writer_to_pin(decl, closure)
         pin = Solargraph::Pin::Method.new(
           name: "#{decl.name.to_s}=",
+          type_location: location_decl_to_pin_location(decl.location),
           closure: closure,
           comments: decl.comment&.string,
           scope: :instance,
           attribute: true
         )
-        pin.docstring.add_tag(YARD::Tags::Tag.new(:return, '', other_type_to_tag(decl.type)))
+        rooted_tag = ComplexType.parse(other_type_to_tag(decl.type)).force_rooted.rooted_tags
+        pin.docstring.add_tag(YARD::Tags::Tag.new(:return, '', rooted_tag))
         pins.push pin
       end
 
@@ -418,9 +433,11 @@ module Solargraph
         pin = Solargraph::Pin::InstanceVariable.new(
           name: decl.name.to_s,
           closure: closure,
+          type_location: location_decl_to_pin_location(decl.location),
           comments: decl.comment&.string
         )
-        pin.docstring.add_tag(YARD::Tags::Tag.new(:type, '', other_type_to_tag(decl.type)))
+        rooted_tag = ComplexType.parse(other_type_to_tag(decl.type)).force_rooted.rooted_tags
+        pin.docstring.add_tag(YARD::Tags::Tag.new(:type, '', rooted_tag))
         pins.push pin
       end
 
@@ -434,7 +451,8 @@ module Solargraph
           closure: closure,
           comments: decl.comment&.string
         )
-        pin.docstring.add_tag(YARD::Tags::Tag.new(:type, '', other_type_to_tag(decl.type)))
+        rooted_tag = ComplexType.parse(other_type_to_tag(decl.type)).force_rooted.rooted_tags
+        pin.docstring.add_tag(YARD::Tags::Tag.new(:type, '', rooted_tag))
         pins.push pin
       end
 
@@ -448,7 +466,8 @@ module Solargraph
           closure: closure,
           comments: decl.comment&.string
         )
-        pin.docstring.add_tag(YARD::Tags::Tag.new(:type, '', other_type_to_tag(decl.type)))
+        rooted_tag = ComplexType.parse(other_type_to_tag(decl.type)).force_rooted.rooted_tags
+        pin.docstring.add_tag(YARD::Tags::Tag.new(:type, '', rooted_tag))
         pins.push pin
       end
 
@@ -456,10 +475,11 @@ module Solargraph
       # @param closure [Pin::Namespace]
       # @return [void]
       def include_to_pin decl, closure
-        type = generic_type(decl.name, decl.args)
+        type = build_type(decl.name, decl.args)
         generic_values = type.all_params.map(&:to_s)
         pins.push Solargraph::Pin::Reference::Include.new(
           name: decl.name.relative!.to_s,
+          type_location: location_decl_to_pin_location(decl.location),
           generic_values: generic_values,
           closure: closure
         )
@@ -471,6 +491,7 @@ module Solargraph
       def prepend_to_pin decl, closure
         pins.push Solargraph::Pin::Reference::Prepend.new(
           name: decl.name.relative!.to_s,
+          type_location: location_decl_to_pin_location(decl.location),
           closure: closure
         )
       end
@@ -481,6 +502,7 @@ module Solargraph
       def extend_to_pin decl, closure
         pins.push Solargraph::Pin::Reference::Extend.new(
           name: decl.name.relative!.to_s,
+          type_location: location_decl_to_pin_location(decl.location),
           closure: closure
         )
       end
@@ -491,6 +513,7 @@ module Solargraph
       def alias_to_pin decl, closure
         pins.push Solargraph::Pin::MethodAlias.new(
           name: decl.new_name.to_s,
+          type_location: location_decl_to_pin_location(decl.location),
           original: decl.old_name.to_s,
           closure: closure
         )
@@ -516,20 +539,24 @@ module Solargraph
 
       # @param type_name [RBS::TypeName]
       # @param type_args [Enumerable<RBS::Types::Bases::Base>]
-      # @return [ComplexType]
-      def generic_type(type_name, type_args)
+      # @return [ComplexType::UniqueType]
+      def build_type(type_name, type_args = [])
         base = RBS_TO_YARD_TYPE[type_name.relative!.to_s] || type_name.relative!.to_s
-        params = type_args.map { |a| other_type_to_tag(a) }.reject { |t| t == 'undefined' }
-        params_str = params.empty? ? '' : "<#{params.join(', ')}>"
-        type_string = "#{base}#{params_str}"
-        ComplexType.parse(type_string)
+        params = type_args.map { |a| other_type_to_tag(a) }.reject { |t| t == 'undefined' }.map do |t|
+          ComplexType.try_parse(t).force_rooted
+        end
+        if base == 'Hash' && params.length == 2
+          ComplexType::UniqueType.new(base, [params.first], [params.last], rooted: true, parameters_type: :hash)
+        else
+          ComplexType::UniqueType.new(base, [], params, rooted: true, parameters_type: :list)
+        end
       end
 
       # @param type_name [RBS::TypeName]
       # @param type_args [Enumerable<RBS::Types::Bases::Base>]
       # @return [String]
-      def generic_type_tag(type_name, type_args)
-        generic_type(type_name, type_args).tag
+      def type_tag(type_name, type_args = [])
+        build_type(type_name, type_args).tags
       end
 
       # @param type [RBS::Types::Bases::Base]
@@ -545,7 +572,7 @@ module Solargraph
         elsif type.is_a?(RBS::Types::Tuple)
           "Array(#{type.types.map { |t| other_type_to_tag(t) }.join(', ')})"
         elsif type.is_a?(RBS::Types::Literal)
-          "#{type.literal}"
+          type.literal.to_s
         elsif type.is_a?(RBS::Types::Union)
           type.types.map { |t| other_type_to_tag(t) }.join(', ')
         elsif type.is_a?(RBS::Types::Record)
@@ -560,7 +587,7 @@ module Solargraph
         elsif type.is_a?(RBS::Types::Variable)
           "#{Solargraph::ComplexType::GENERIC_TAG_NAME}<#{type.name}>"
         elsif type.is_a?(RBS::Types::ClassInstance) #&& !type.args.empty?
-          generic_type_tag(type.name, type.args)
+          type_tag(type.name, type.args)
         elsif type.is_a?(RBS::Types::Bases::Instance)
           'self'
         elsif type.is_a?(RBS::Types::Bases::Top)
@@ -577,8 +604,18 @@ module Solargraph
           type.types.map { |member| other_type_to_tag(member) }.join(', ')
         elsif type.is_a?(RBS::Types::Proc)
           'Proc'
-        elsif type.respond_to?(:name) && type.name.respond_to?(:relative!)
-          RBS_TO_YARD_TYPE[type.name.relative!.to_s] || type.name.relative!.to_s
+        elsif type.is_a?(RBS::Types::Alias)
+          # type-level alias use - e.g., 'bool' in "type bool = true | false"
+          # @todo ensure these get resolved after processing all aliases
+          # @todo handle recursive aliases
+          type_tag(type.name, type.args)
+        elsif type.is_a?(RBS::Types::Interface)
+          # represents a mix-in module which can be considered a
+          # subtype of a consumer of it
+          type_tag(type.name, type.args)
+        elsif type.is_a?(RBS::Types::ClassSingleton)
+          # e.g., singleton(String)
+          type_tag(type.name)
         else
           Solargraph.logger.warn "Unrecognized RBS type: #{type.class} at #{type.location}"
           'undefined'
@@ -586,14 +623,14 @@ module Solargraph
       end
 
       # @param decl [RBS::AST::Declarations::Class, RBS::AST::Declarations::Module]
-      # @param closure [Pin::Namespace]
+      # @param namespace [Pin::Namespace]
       # @return [void]
       def add_mixins decl, namespace
         decl.each_mixin do |mixin|
           klass = mixin.is_a?(RBS::AST::Members::Include) ? Pin::Reference::Include : Pin::Reference::Extend
           pins.push klass.new(
             name: mixin.name.relative!.to_s,
-            location: rbs_location_to_location(mixin.location),
+            location: location_decl_to_pin_location(mixin.location),
             closure: namespace
           )
         end

data/lib/solargraph/rbs_map/core_fills.rb

@@ -19,17 +19,17 @@ module Solargraph
         Solargraph::Pin::Method.new(name: 'tap', scope: :instance,
                                     closure: Solargraph::Pin::Namespace.new(name: 'Object')),
         Solargraph::Pin::Method.new(name: 'class', scope: :instance,
-                                    closure: Solargraph::Pin::Namespace.new(name: 'Object'), comments: '@return [Class<self>]')
+                                    closure: Solargraph::Pin::Namespace.new(name: 'Object'), comments: '@return [::Class<self>]')
       ]
 
       OVERRIDES = [
         Override.from_comment('BasicObject#instance_eval', '@yieldreceiver [self]'),
         Override.from_comment('BasicObject#instance_exec', '@yieldreceiver [self]'),
-        Override.from_comment('Module#define_method', '@yieldreceiver [Object<self>]'),
-        Override.from_comment('Module#class_eval', '@yieldreceiver [Class<self>]'),
-        Override.from_comment('Module#class_exec', '@yieldreceiver [Class<self>]'),
-        Override.from_comment('Module#module_eval', '@yieldreceiver [Module<self>]'),
-        Override.from_comment('Module#module_exec', '@yieldreceiver [Module<self>]'),
+        Override.from_comment('Module#define_method', '@yieldreceiver [::Object<self>]'),
+        Override.from_comment('Module#class_eval', '@yieldreceiver [::Class<self>]'),
+        Override.from_comment('Module#class_exec', '@yieldreceiver [::Class<self>]'),
+        Override.from_comment('Module#module_eval', '@yieldreceiver [::Module<self>]'),
+        Override.from_comment('Module#module_exec', '@yieldreceiver [::Module<self>]'),
         # RBS does not define Class with a generic, so all calls to
         # generic() return an 'untyped'.  We can do better:
         Override.method_return('Class#allocate', 'self')

data/lib/solargraph/rbs_map.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'pathname'
 require 'rbs'
 
 module Solargraph
@@ -17,10 +18,13 @@ module Solargraph
     attr_reader :library
 
     # @param library [String]
-    def initialize library, version = nil
+    # @param version [String, nil]
+    # @param directories [Array<Pathname, String>]
+    def initialize library, version = nil, directories: []
       @library = library
       @version = version
       @collection = nil
+      @directories = directories
       loader = RBS::EnvironmentLoader.new(core_root: nil, repository: repository)
       add_library loader, library, version
       return unless resolved?
@@ -47,7 +51,11 @@ module Solargraph
     end
 
     def repository
-      @repository ||= RBS::Repository.new(no_stdlib: false)
+      @repository ||= RBS::Repository.new(no_stdlib: false).tap do |repo|
+        # @todo Temporarily ignoring external directories due to issues with
+        #   incomplete/broken gem_rbs_collection installations
+        # @directories.each { |dir| repo.add(Pathname.new(dir)) }
+      end
     end
 
     # @param library [String]
@@ -71,7 +79,7 @@ module Solargraph
         Solargraph.logger.info "#{short_name} successfully loaded library #{library}"
         true
       else
-        Solargraph.logger.debug "#{short_name} failed to load library #{library}"
+        Solargraph.logger.info "#{short_name} failed to load library #{library}"
         false
       end
     end

data/lib/solargraph/shell.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'benchmark'
 require 'thor'
 require 'yard'
 
@@ -88,7 +89,7 @@ module Solargraph
     )
     # @return [void]
     def clear
-      puts "Deleting the cached documentation"
+      puts "Deleting all cached documentation (gems, core and stdlib)"
       Solargraph::Cache.clear
     end
     map 'clear-cache' => :clear
@@ -104,11 +105,26 @@ module Solargraph
       Cache.save('gems', "#{spec.name}-#{spec.version}.ser", pins)
     end
 
-    desc 'uncache GEM [...GEM]', "Delete cached gem documentation"
+    desc 'uncache GEM [...GEM]', "Delete specific cached gem documentation"
+    long_desc %(
+      Specify one or more gem names to clear. 'core' or 'stdlib' may
+      also be specified to clear cached system documentation.
+      Documentation will be regenerated as needed.
+    )
     # @return [void]
     def uncache *gems
       raise ArgumentError, 'No gems specified.' if gems.empty?
       gems.each do |gem|
+        if gem == 'core'
+          Cache.uncache("core.ser")
+          next
+        end
+
+        if gem == 'stdlib'
+          Cache.uncache("stdlib")
+          next
+        end
+
         spec = Gem::Specification.find_by_name(gem)
         Cache.uncache('gems', "#{spec.name}-#{spec.version}.ser")
         Cache.uncache('gems', "#{spec.name}-#{spec.version}.yardoc")
@@ -149,23 +165,28 @@ module Solargraph
     # @return [void]
     def typecheck *files
       directory = File.realpath(options[:directory])
-      api_map = Solargraph::ApiMap.load_with_cache(directory)
+      api_map = Solargraph::ApiMap.load_with_cache(directory, $stdout)
+      probcount = 0
       if files.empty?
         files = api_map.source_maps.map(&:filename)
       else
         files.map! { |file| File.realpath(file) }
       end
-      probcount = 0
       filecount = 0
-      files.each do |file|
-        checker = TypeChecker.new(file, api_map: api_map, level: options[:level].to_sym)
-        problems = checker.problems
-        next if problems.empty?
-        problems.sort! { |a, b| a.location.range.start.line <=> b.location.range.start.line }
-        puts problems.map { |prob| "#{prob.location.filename}:#{prob.location.range.start.line + 1} - #{prob.message}" }.join("\n")
-        filecount += 1
-        probcount += problems.length
-      end
+
+      time = Benchmark.measure {
+        files.each do |file|
+          checker = TypeChecker.new(file, api_map: api_map, level: options[:level].to_sym)
+          problems = checker.problems
+          next if problems.empty?
+          problems.sort! { |a, b| a.location.range.start.line <=> b.location.range.start.line }
+          puts problems.map { |prob| "#{prob.location.filename}:#{prob.location.range.start.line + 1} - #{prob.message}" }.join("\n")
+          filecount += 1
+          probcount += problems.length
+        end
+        # "
+      }
+      puts "Typecheck finished in #{time.real} seconds."
       puts "#{probcount} problem#{probcount != 1 ? 's' : ''} found#{files.length != 1 ? " in #{filecount} of #{files.length} files" : ''}."
       # "
       exit 1 if probcount > 0
@@ -182,11 +203,10 @@ module Solargraph
     option :verbose, type: :boolean, aliases: :v, desc: 'Verbose output', default: false
     # @return [void]
     def scan
-      require 'benchmark'
       directory = File.realpath(options[:directory])
       api_map = nil
       time = Benchmark.measure {
-        api_map = Solargraph::ApiMap.load_with_cache(directory)
+        api_map = Solargraph::ApiMap.load_with_cache(directory, $stdout)
         api_map.pins.each do |pin|
           begin
             puts pin_description(pin) if options[:verbose]

data/lib/solargraph/source/chain/array.rb

@@ -17,14 +17,15 @@ module Solargraph
         # @param locals [Enumerable<Pin::LocalVariable>]
         def resolve api_map, name_pin, locals
           child_types = @children.map do |child|
-            child.infer(api_map, name_pin, locals).tag
+            child.infer(api_map, name_pin, locals)
           end
-          type = if child_types.uniq.length == 1 && child_types.first != 'undefined'
-                   "::Array<#{child_types.first}>"
+
+          type = if child_types.uniq.length == 1 && child_types.first.defined?
+                   ComplexType::UniqueType.new('Array', [], child_types.uniq, rooted: true, parameters_type: :list)
                  else
-                   '::Array'
+                   ComplexType::UniqueType.new('Array', rooted: true)
                  end
-          [Pin::ProxyType.anonymous(ComplexType.try_parse(type))]
+          [Pin::ProxyType.anonymous(type)]
         end
       end
     end

data/lib/solargraph/source/chain/block_symbol.rb

@@ -5,7 +5,7 @@ module Solargraph
     class Chain
       class BlockSymbol < Link
         def resolve api_map, name_pin, locals
-          [Pin::ProxyType.anonymous(ComplexType.try_parse('Proc'))]
+          [Pin::ProxyType.anonymous(ComplexType.try_parse('::Proc'))]
         end
       end
     end

data/lib/solargraph/source/chain/block_variable.rb

@@ -5,7 +5,7 @@ module Solargraph
     class Chain
       class BlockVariable < Link
         def resolve api_map, name_pin, locals
-          [Pin::ProxyType.anonymous(ComplexType.try_parse('Proc'))]
+          [Pin::ProxyType.anonymous(ComplexType.try_parse('::Proc'))]
         end
       end
     end