New Typedef library

lib/solargraph.rb

@@ -49,6 +49,7 @@ class InvalidRubocopVersionError < RuntimeError;  end
   autoload :RbsMap,           'solargraph/rbs_map'
   autoload :GemPins,          'solargraph/gem_pins'
   autoload :PinCache,         'solargraph/pin_cache'
+  autoload :Typedef,          'solargraph/typedef'
 
   dir = File.dirname(__FILE__)
   VIEWS_PATH = File.join(dir, 'solargraph', 'views')

lib/solargraph/api_map.rb

@@ -403,7 +403,7 @@ def get_instance_variable_pins namespace, scope = :instance
     # @param candidates [Array<Pin::BaseVariable>]
     # @param name [String]
     # @param closure [Pin::Closure]
-    # @param location [Location]
+    # @param location [Location, nil]
     #
     # @return [Pin::BaseVariable, nil]
     def var_at_location candidates, name, closure, location
@@ -520,6 +520,27 @@ def get_methods rooted_tag, scope: :instance, visibility: [:public], deep: true
       result
     end
 
+    # @param path [Typedef::Path]
+    # @return [Array<Pin::Method>]
+    def typedef_path_methods path
+      # @todo Can we just try to resolve the path here? I guess we'd need gates.
+      if path.resolved?
+        get_methods(path.to_s)
+      else
+        []
+      end
+    end
+
+    # @param type [Typedef::Type]
+    # @return [Array<Pin::Method>]
+    def typedef_type_methods type
+      if type.class?
+        get_methods(type.params.first.to_s, scope: :class)
+      else
+        get_methods(type.base.to_s, scope: :instance)
+      end
+    end
+
     # Get an array of method pins for a complex type.
     #
     # The type's namespace and the context should be fully qualified. If the

lib/solargraph/complex_type.rb

@@ -399,6 +399,16 @@
       ComplexType.new(types)
     end
 
+    # @return [Array<Typedef::Type>]
+    def to_typedef_types
+      # @todo Quick and dirty hack
+      return [Typedef::Type::ROOT] if to_s == 'Class<>'
+
+      items.map do |item|
+        item.to_typedef_types
+      end
+    end
+
     protected
 
     def equality_fields

lib/solargraph/complex_type/unique_type.rb

@@ -614,6 +614,16 @@ def can_root_name? name_to_check = name
         self.class.can_root_name?(name_to_check)
       end
 
+      def to_typedef_types
+        # @todo Quick and dirty hack
+        return Typedef::Type.new(Typedef.tokenize(to_s)) if to_s.start_with?('generic<')
+
+        base = name
+        base = "::#{base}" if rooted? && base =~ /^[A-Z]/
+        params = all_params.map(&:to_typedef_types)
+        Typedef::Type.new(base, *params)
+      end
+
       # @param name [String]
       def self.can_root_name? name
         # name is not lowercase

lib/solargraph/pin/base.rb

@@ -33,6 +33,8 @@
       #   Between 2 pins, the one with the higher priority gets chosen. If the priorities are equal, they are combined.
       attr_reader :combine_priority
 
+      attr_reader :expansions
+
       def presence_certain?
         true
       end
@@ -47,7 +49,7 @@
       # @param directives [::Array<YARD::Tags::Directive>, nil]
       # @param combine_priority [::Numeric, nil] See attr_reader for combine_priority
       def initialize location: nil, type_location: nil, closure: nil, source: nil, name: '', comments: '',
-                     docstring: nil, directives: nil, combine_priority: nil
+                     docstring: nil, directives: nil, combine_priority: nil, expansions: {}
         @location = location
         @type_location = type_location
         @closure = closure
@@ -60,11 +62,26 @@
         @combine_priority = combine_priority
         # @type [ComplexType, ComplexType::UniqueType, nil]
         @binder = nil
+        @expansions = expansions
 
         assert_source_provided
         assert_location_provided
       end
 
+      def typedef_path
+        Typedef::Path.new(path.to_s, rooted: return_type.rooted?)
+      end
+
+      # @return [Array<Typedef::Type>]
+      def typedef_return_types
+        [Typedef::Type.from_complex_type(return_type)].flatten
+      end
+
+
+      def expansions
+        @expansions ||= {}
+      end
+
       # @return [void]
       def assert_location_provided
         return unless best_location.nil? && %i[yardoc source rbs].include?(source)
@@ -711,6 +728,10 @@
         end
       end
 
+      def typedef_generics
+        @generics ||= docstring.tags(:generic).map(&:name)
+      end
+
       protected
 
       # @sg-ignore def should infer as symbol - "Not enough arguments to Module#protected"

lib/solargraph/pin/callable.rb

@@ -160,6 +160,24 @@
         callable
       end
 
+      # @param api_map [ApiMap]
+      # @return [Array<Typedef::Type>]
+      def typedef_resolve_rooted api_map
+        typedef_return_types.map { |rt| rt.resolve_rooted(api_map, gates) }
+      end
+
+      # @param arguments [Array<Typedef::Type>]
+      # @return [Array<Typedef::Type>]
+      def typedef_resolve_call(arguments)
+        # named_values = closure.generics
+        #                       .map { |name| "generic[#{name}]" }
+        #                       .zip(arguments)
+        #                       .to_h
+        # puts "Named values from typedef_resolve_call #{named_values.inspect}"
+        # puts "With arguments #{arguments.inspect}"
+        typedef_return_types
+      end
+
       def typify api_map
         type = return_type
         return type.qualify(api_map, *gates) if type.defined?

lib/solargraph/pin/parameter.rb

@@ -22,6 +22,11 @@
         @decl = decl
       end
 
+      # @param arguments [Array<Typedef::Type>]
+      def typedef_resolve_generics(arguments)
+
+      end
+
       def type_location
         super || closure&.type_location
       end

lib/solargraph/pin/proxy_type.rb

@@ -3,16 +3,19 @@
 module Solargraph
   module Pin
     class ProxyType < Base
+      attr_reader :generics
+
       # @param return_type [ComplexType, ComplexType::UniqueType]
       # @param gates [Array<String>, nil] Namespaces to try while resolving non-rooted types
       # @param binder [ComplexType, ComplexType::UniqueType, nil]
       # @param gates [Array<String>, nil]
       # @param [Hash{Symbol => Object}] splat
-      def initialize return_type: ComplexType::UNDEFINED, binder: nil, gates: nil, **splat
+      def initialize return_type: ComplexType::UNDEFINED, binder: nil, gates: nil, generics: [], **splat
         super(**splat)
         @gates = gates
         @return_type = return_type
         @binder = binder if binder
+        @generics = generics
       end
 
       def context

lib/solargraph/rbs_map/core_fills.rb

@@ -38,7 +38,8 @@ module CoreFills
                               source: :core_fill),
         # 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', source: :core_fill)
+        Override.method_return('Class#allocate', 'self', source: :core_fill),
+        Override.method_return('Class#new', 'self', source: :core_fill)
       ].freeze
 
       # @todo I don't see any direct link in RBS to build this from -

lib/solargraph/typedef.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Typedef
+    autoload :Path,       'solargraph/typedef/path'
+    autoload :Token,      'solargraph/typedef/token'
+    autoload :Type,       'solargraph/typedef/type'
+    autoload :Linker,     'solargraph/typedef/linker'
+    autoload :Memos,      'solargraph/typedef/memos'
+    autoload :Dictionary, 'solargraph/typedef/dictionary'
+    autoload :Generics,   'solargraph/typedef/generics'
+    autoload :Typeset,    'solargraph/typedef/typeset'
+
+    # Convert a value to a Path or Token
+    # @param value [String, Path, Token, Type, Array<String, Path, Token, Type>]
+    # @return [Path, Token, Type]
+    def self.tokenize value
+      case value
+      when String
+        convert value
+      when Path, Token, Type
+        value
+      when Array
+        Typedef::Type.new(*value)
+      else
+        raise "Invalid value #{value.inspect}"
+      end
+    end
+
+    def self.memos
+      @memos ||= Memos.new
+    end
+
+    class << self
+      private
+
+      # @param string [String]
+      # @return [Path, Token]
+      def convert string
+        case string
+        when ""
+          Path::ROOT
+        # @todo Should interfaces (e.g, `_Each`) be paths?
+        #   (Probably)
+        when /^(::)?[A-Z_][A-Za-z_(::)]*?/
+          Path.new(string)
+        when /^generic<[A-Za-z\d_]*>$/
+          Token.new(string)
+        when /^?[a-z\d_]*?$/
+          Token.new(string)
+        when /^"?[a-z\d_]*?"$/
+          Token.new(string)
+        when /^\:?[a-z\d_]*?$/
+          Token.new(string)
+        # @todo How to handle integers?
+        when /^\d+$/
+          Token.new(string)
+        else
+          raise "Invalid Typedef token string: #{string.inspect}"
+        end
+      end
+    end
+  end
+end