solargraph 0.38.6 → 0.39.0

data/lib/solargraph/type_checker/checks.rb

@@ -0,0 +1,95 @@
+module Solargraph
+  class TypeChecker
+    module Checks
+      module_function
+
+      # Compare an expected type with an inferred type. Common usage is to
+      # check if the type declared in a method's @return tag matches the type
+      # inferred from static analysis of the code.
+      #
+      # @param api_map [ApiMap]
+      # @param expected [ComplexType]
+      # @param inferred [ComplexType]
+      # @return [Boolean]
+      def types_match? api_map, expected, inferred
+        return true if expected.to_s == inferred.to_s
+        matches = []
+        expected.each do |exp|
+          found = false
+          inferred.each do |inf|
+            # if api_map.super_and_sub?(fuzz(inf), fuzz(exp))
+            if either_way?(api_map, inf, exp)
+              found = true
+              matches.push inf
+              break
+            end
+          end
+          return false unless found
+        end
+        inferred.each do |inf|
+          next if matches.include?(inf)
+          found = false
+          expected.each do |exp|
+            # if api_map.super_and_sub?(fuzz(inf), fuzz(exp))
+            if either_way?(api_map, inf, exp)
+              found = true
+              break
+            end
+          end
+          return false unless found
+        end
+        true
+      end
+
+      # @param api_map [ApiMap]
+      # @param expected [ComplexType]
+      # @param inferred [ComplexType]
+      # @return [Boolean]
+      def any_types_match? api_map, expected, inferred
+        return duck_types_match?(api_map, expected, inferred) if expected.duck_type?
+        expected.each do |exp|
+          next if exp.duck_type?
+          inferred.each do |inf|
+            # return true if exp == inf || api_map.super_and_sub?(fuzz(inf), fuzz(exp))
+            return true if exp == inf || either_way?(api_map, inf, exp)
+          end
+        end
+        false
+      end
+
+      # @param api_map [ApiMap]
+      # @param expected [ComplexType]
+      # @param inferred [ComplexType]
+      # @return [Boolean]
+      def duck_types_match? api_map, expected, inferred
+        raise ArgumentError, "Expected type must be duck type" unless expected.duck_type?
+        expected.each do |exp|
+          next unless exp.duck_type?
+          quack = exp.to_s[1..-1]
+          return false if api_map.get_method_stack(inferred.namespace, quack, scope: inferred.scope).empty?
+        end
+        true
+      end
+
+      # @param type [ComplexType]
+      # @return [String]
+      def fuzz type
+        if type.parameters?
+          type.name
+        else
+          type.tag
+        end
+      end
+
+      # @param api_map [ApiMap]
+      # @param cls1 [ComplexType]
+      # @param cls2 [ComplexType]
+      # @return [Boolean]
+      def either_way?(api_map, cls1, cls2)
+        f1 = fuzz(cls1)
+        f2 = fuzz(cls2)
+        api_map.super_and_sub?(f1, f2) || api_map.super_and_sub?(f2, f1)
+      end
+    end
+  end
+end

data/lib/solargraph/type_checker/param_def.rb

@@ -24,27 +24,12 @@ module Solargraph
         # @return [Array<ParamDef>]
         def from pin
           result = []
-          pin.parameters.each_with_index do |full, index|
-            result.push ParamDef.new(pin.parameter_names[index], arg_type(full))
+          pin.parameters.each do |par|
+            result.push ParamDef.new(par.name, par.decl)
           end
           result
         end
-
-        private
-
-        # @param string [String]
-        # @return [Symbol]
-        def arg_type string
-          return :kwrestarg if string.start_with?('**')
-          return :restarg if string.start_with?('*')
-          return :optarg if string.include?('=')
-          return :kwoptarg if string.end_with?(':')
-          return :kwarg if string =~ /^[a-z0-9_]*?:/
-          return :blockarg if string.start_with?('&')
-          :arg
-        end
       end
-
     end
   end
 end

data/lib/solargraph/type_checker/rules.rb

@@ -0,0 +1,53 @@
+module Solargraph
+  class TypeChecker
+    class Rules
+      LEVELS = {
+        normal: 0,
+        typed: 1,
+        strict: 2,
+        strong: 3
+      }
+
+      # @return [Symbol]
+      attr_reader :level
+
+      # @return [Integer]
+      attr_reader :rank
+
+      # @param level [Symbol]
+      def initialize level
+        @rank = if LEVELS.key?(level)
+          LEVELS[level]
+        else
+          Solargraph.logger.warn "Unrecognized TypeChecker level #{level}, assuming normal"
+          0
+        end
+        @level = LEVELS[LEVELS.values.index(@rank)]
+      end
+
+      def ignore_all_undefined?
+        rank < LEVELS[:strict]
+      end
+
+      def validate_consts?
+        rank >= LEVELS[:strict]
+      end
+
+      def validate_calls?
+        rank >= LEVELS[:strict]
+      end
+
+      def require_type_tags?
+        rank >= LEVELS[:strong]
+      end
+
+      def must_tag_or_infer?
+        rank > LEVELS[:typed]
+      end
+
+      def validate_tags?
+        rank > LEVELS[:normal]
+      end
+    end
+  end
+end

data/lib/solargraph/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Solargraph
-  VERSION = '0.38.6'
+  VERSION = '0.39.0'
 end

data/lib/solargraph/views/environment.erb

@@ -35,9 +35,11 @@
     <li>
       Core Cache Directory: <%= Solargraph::YardMap::CoreDocs.cache_dir %>
     </li>
-    <li>
-      Parser Target Version: <%= Solargraph::Source.parser.version %>
-    </li>
+    <% unless Solargraph::Parser.rubyvm? %>
+      <li>
+        Parser Target Version: <%= Solargraph::Parser.version %>
+      </li>
+    <% end %>
     <li>
       Using Bundler: <%= ENV.key?('BUNDLE_BIN_PATH') %>
     </li>

data/lib/solargraph/workspace.rb

@@ -27,6 +27,7 @@ module Solargraph
       load_sources
       @gemnames = []
       @require_paths = generate_require_paths
+      require_plugins
     end
 
     # @return [Solargraph::Workspace::Config]
@@ -145,7 +146,11 @@ module Solargraph
         size = config.calculated.length
         raise WorkspaceTooLargeError, "The workspace is too large to index (#{size} files, #{config.max_files} max)" if config.max_files > 0 and size > config.max_files
         config.calculated.each do |filename|
-          source_hash[filename] = Solargraph::Source.load(filename)
+          begin
+            source_hash[filename] = Solargraph::Source.load(filename)
+          rescue Errno::ENOENT => e
+            Solargraph.logger.warn("Error loading #{filename}: [#{e.class}] #{e.message}")
+          end
         end
       end
     end
@@ -169,7 +174,7 @@ module Solargraph
             next unless Gem::Specification === spec
             @gemnames.push spec.name
             result.concat(spec.require_paths.map { |path| File.join(base, path) })
-          rescue Exception => e
+          rescue RuntimeError, ScriptError, Errno::ENOENT => e
             # Don't die if we have an error during eval-ing a gem spec.
             # Concat the default lib directory instead.
             Solargraph.logger.warn "Error reading #{file}: [#{e.class}] #{e.message}"
@@ -190,5 +195,15 @@ module Solargraph
       return [File.join(directory, 'lib')] if config.require_paths.empty?
       config.require_paths.map{|p| File.join(directory, p)}
     end
+
+    def require_plugins
+      config.plugins.each do |plugin|
+        begin
+          require plugin
+        rescue LoadError
+          Solargraph.logger.warn "Failed to load plugin '#{plugin}'"
+        end
+      end
+    end
   end
 end

data/lib/solargraph/workspace/config.rb

@@ -10,7 +10,7 @@ module Solargraph
       # The maximum number of files that can be added to a workspace.
       # The workspace's .solargraph.yml can override this value.
       MAX_FILES = 5000
-        
+
       # @return [String]
       attr_reader :directory
 
@@ -85,6 +85,13 @@ module Solargraph
         raw_data['reporters']
       end
 
+      # An array of plugins to require.
+      #
+      # @return [Array<String>]
+      def plugins
+        raw_data['plugins']
+      end
+
       # The maximum number of files to parse from the workspace.
       #
       # @return [Integer]
@@ -93,7 +100,7 @@ module Solargraph
       end
 
       private
-      
+
       # @return [String]
       def global_config_path
         ENV['SOLARGRAPH_GLOBAL_CONFIG'] || 
@@ -110,7 +117,7 @@ module Solargraph
       def config_data
         workspace_config = read_config(workspace_config_path)
         global_config = read_config(global_config_path)
-        
+
         defaults = default_config
         defaults.merge({'exclude' => []}) unless workspace_config.nil?
 
@@ -118,17 +125,17 @@ module Solargraph
           .merge(global_config || {})
           .merge(workspace_config || {})
       end
-      
+
       # Read a .solargraph yaml config
       #
       # @param directory [String]
-      # @return [Hash]
+      # @return [Hash, nil]
       def read_config config_path = ''
         return nil if config_path.empty?
         return nil unless File.file?(config_path)
         YAML.safe_load(File.read(config_path))
       end
-      
+
       # @return [Hash]
       def default_config
         {
@@ -138,7 +145,8 @@ module Solargraph
           'domains' => [],
           'reporters' => %w[rubocop require_not_found],
           'require_paths' => [],
-          'max_files' => MAX_FILES,
+          'plugins' => [],
+          'max_files' => MAX_FILES
         }
       end
 

data/lib/solargraph/yard_map.rb

@@ -16,17 +16,20 @@ module Solargraph
     autoload :RdocToYard, 'solargraph/yard_map/rdoc_to_yard'
 
     CoreDocs.require_minimum
-    @@stdlib_yardoc = CoreDocs.yardoc_stdlib_file
-    @@stdlib_paths = {}
-    YARD::Registry.load! @@stdlib_yardoc
-    YARD::Registry.all(:class, :module).each do |ns|
-      next if ns.nil? || ns.file.nil?
-      path = ns.file.sub(/^(ext|lib)\//, '').sub(/\.(rb|c)$/, '')
-      next if path.start_with?('-')
-      base = path.split('/').first
-      @@stdlib_paths[base] ||= {}
-      @@stdlib_paths[base][path] ||= []
-      @@stdlib_paths[base][path].push ns
+
+    def stdlib_paths
+      @@stdlib_paths ||= begin
+        result = {}
+        YARD::Registry.load! CoreDocs.yardoc_stdlib_file
+        YARD::Registry.all.each do |co|
+          next if co.file.nil?
+          path = co.file.sub(/^(ext|lib)\//, '').sub(/\.(rb|c)$/, '')
+          base = path.split('/').first
+          result[base] ||= []
+          result[base].push co
+        end
+        result
+      end
     end
 
     # @return [Array<String>]
@@ -108,8 +111,39 @@ module Solargraph
     # @return [Array<Solargraph::Pin::Base>]
     def core_pins
       @@core_pins ||= begin
-        load_yardoc CoreDocs.yardoc_file
-        result = Mapper.new(YARD::Registry.all).map
+        yd = CoreDocs.yardoc_file
+        ser = File.join(File.dirname(yd), 'core.ser')
+        result = []
+        if File.file?(ser)
+          file = File.open(ser, 'rb')
+          dump = file.read
+          file.close
+          result.concat Marshal.load(dump)
+        else
+          load_yardoc CoreDocs.yardoc_file
+          result.concat Mapper.new(YARD::Registry.all).map
+          # HACK: Assume core methods with a single `args` parameter accept restarg
+          result.select { |pin| pin.is_a?(Solargraph::Pin::BaseMethod )}.each do |pin|
+            if pin.parameters.length == 1 && pin.parameters.first.name == 'args' && pin.parameters.first.decl == :arg
+              # @todo Smelly instance variable access
+              pin.parameters.first.instance_variable_set(:@decl, :restarg)
+            end
+          end
+          # HACK: Set missing parameters on `==` methods, e.g., `Symbol#==`
+          result.select { |pin| pin.name == '==' && pin.parameters.empty? }.each do |pin|
+            pin.parameters.push Pin::Parameter.new(decl: :arg, name: 'obj2')
+          end
+          dump = Marshal.dump(result)
+          file = File.open(ser, 'wb')
+          file.write dump
+          file.close
+        end
+        # HACK: Add Errno exception classes
+        errno = result.select{ |pin| pin.path == 'Errno' }.first
+        Errno.constants.each do |const|
+          result.push Solargraph::Pin::Namespace.new(type: :class, name: const.to_s, closure: errno)
+          result.push Solargraph::Pin::Reference::Superclass.new(closure: result.last, name: 'SystemCallError')
+        end
         CoreFills::OVERRIDES.each do |ovr|
           pin = result.select { |p| p.path == ovr.name }.first
           next if pin.nil?
@@ -169,7 +203,7 @@ module Solargraph
     def process_requires
       pins.clear
       unresolved_requires.clear
-      stdnames = {}
+      # stdnames = {}
       done = []
       from_std = []
       required.each do |r|
@@ -201,20 +235,33 @@ module Solargraph
           end
         rescue Gem::LoadError => e
           base = r.split('/').first
+          next if from_std.include?(base)
+          from_std.push base
           stdtmp = []
-          if @@stdlib_paths[base]
-            @@stdlib_paths[base].each_pair do |path, objects|
-              next if from_std.include?(path)
-              if path == r || path.start_with?("#{r}/")
-                from_std.push path
-                stdtmp.concat objects
-              end
+          ser = File.join(File.dirname(CoreDocs.yardoc_stdlib_file), "#{base}.ser")
+          if File.file?(ser)
+            Solargraph.logger.info "Loading #{base} stdlib from cache"
+            file = File.open(ser, 'rb')
+            dump = file.read
+            file.close
+            stdtmp.concat Marshal.load(dump)
+          else
+            if stdlib_paths[base]
+              Solargraph.logger.info "Loading #{base} stdlib from yardoc"
+              stdtmp.concat Mapper.new(stdlib_paths[base]).map
+              next if stdtmp.empty?
+              dump = Marshal.dump(stdtmp)
+              file = File.open(ser, 'wb')
+              file.write dump
+              file.close
             end
           end
           if stdtmp.empty?
             unresolved_requires.push r
           else
-            stdnames[r] = stdtmp
+            stdlib_fill base, stdtmp
+            result.concat stdtmp
+            # stdnames[r] = stdtmp
           end
         end
         result.delete_if(&:nil?)
@@ -223,35 +270,10 @@ module Solargraph
           pins.concat result
         end
       end
-      pins.concat process_stdlib(stdnames)
+      # pins.concat process_stdlib(stdnames)
       pins.concat core_pins
     end
 
-    # @param required_namespaces [Array<YARD::CodeObjects::Namespace>]
-    # @return [Array<Solargraph::Pin::Base>]
-    def process_stdlib required_namespaces
-      pins = []
-      unless required_namespaces.empty?
-        yard = load_yardoc @@stdlib_yardoc
-        done = []
-        required_namespaces.each_pair do |r, objects|
-          result = []
-          objects.each do |ns|
-            next if done.include?(ns.path)
-            done.push ns.path
-            all = [ns]
-            all.concat recurse_namespace_object(ns)
-            result.concat Mapper.new(all).map
-          end
-          result.delete_if(&:nil?)
-          stdlib_fill r, result
-          cache.set_path_pins(r, result) unless result.empty?
-          pins.concat result
-        end
-      end
-      pins
-    end
-
     # @param spec [Gem::Specification]
     # @return [void]
     def add_gem_dependencies spec
@@ -287,12 +309,30 @@ module Solargraph
       size = Dir.glob(File.join(y, '**', '*'))
         .map{ |f| File.size(f) }
         .inject(:+)
+      if spec
+        ser = File.join(CoreDocs.cache_dir, 'gems', "#{spec.name}-#{spec.version}.ser")
+        if File.file?(ser)
+          Solargraph.logger.info "Loading #{spec.name} #{spec.version} from cache"
+          file = File.open(ser, 'rb')
+          dump = file.read
+          file.close
+          return Marshal.load(dump)
+        end
+      end
       if !size.nil? && size > 20_000_000
         Solargraph::Logging.logger.warn "Yardoc at #{y} is too large to process (#{size} bytes)"
         return []
       end
       load_yardoc y
-      Mapper.new(YARD::Registry.all, spec).map
+      Solargraph.logger.info "Loading #{spec.name} #{spec.version} from yardoc"
+      result = Mapper.new(YARD::Registry.all, spec).map
+      if spec
+        ser = File.join(CoreDocs.cache_dir, 'gems', "#{spec.name}-#{spec.version}.ser")
+        file = File.open(ser, 'wb')
+        file.write Marshal.dump(result)
+        file.close
+      end
+      result
     end
 
     # @param spec [Gem::Specification]