carbon-core 0.1.1 → 0.2.0

data/lib/carbon/concrete/item/trait.rb

@@ -19,7 +19,7 @@ module Carbon
 
         # (see Item::Base.from)
         def self.from(type)
-          { module: type, expectations: [] }
+          { type: type, expectations: [] }
         end
 
         # The expectations for the trait.
@@ -34,14 +34,13 @@ module Carbon
         # Initialize the trait with data.
         #
         # @param data [::Hash] The data to initialize the trait with.
-        # @option data [Type] :module The name of the trait type.
+        # @option data [Type] :type The name of the trait type.
         # @option data [<(::String, <Type>, Type)>] :expectations
         #   The expectations that the trait requires.
         def initialize(data)
-          @module = data.fetch(:module)
-          @generics = @module.generics
-          @intern = @module.intern
-          @name = @module.to_s
+          @type = data.fetch(:type)
+          @generics = @type.generics
+          @name = @type.to_s
 
           derive_expectations(data.fetch(:expectations))
           derive_dependencies
@@ -49,8 +48,8 @@ module Carbon
         end
 
         # (see Base#call)
-        def call(build, generics)
-          super # TODO: fixme.
+        def call(_build, _generics)
+          # do nothing.
         end
 
       private
@@ -62,8 +61,8 @@ module Carbon
 
         def derive_dependencies
           @expectations.each do |expect|
-            @dependencies.merge(expect.parameters.map(&:to_request))
-            @dependencies << expect.return.to_request
+            @dependencies.merge(expect.parameters)
+            @dependencies << expect.return
           end
         end
       end

data/lib/carbon/concrete/request.rb

@@ -1,137 +1,138 @@
-# encoding: utf-8
+# # encoding: utf-8
 # frozen_string_literal: true
-
-require "forwardable"
-
-module Carbon
-  module Concrete
-    # A "request."  This is used to note the generics that a given module
-    # should be compiled with.  This is used for items to note the dependencies
-    # that an item has; otherwise, it is used in the index for build
-    # information.
-    #
-    # @note
-    #   **This class is frozen upon initialization.**  This means that any
-    #   attempt to modify it will result in an error.  In most cases, the
-    #   attributes on this class will also be frozen, as well.
-    class Request
-      extend Forwardable
-
-      # The interned name of a module.  This is used for module lookup.  This
-      # contains no generic information.  For generic functions, all generics
-      # are pushed onto the defining module.
-      #
-      # @api public
-      # @example
-      #   request.intern # => "Carbon::Pointer"
-      # @note See {Item::Base#intern} For more information about interned
-      #   names.
-      # @return [::String]
-      attr_reader :intern
-
-      # The generics of the request.  Even if the request has no definable
-      # generics, these are still kept in place for both name information and
-      # for placement information (e.g. identity and size).
-      #
-      # @api public
-      # @example
-      #   request.generics # => [#<Carbon::Concrete::Type::Generic T>]
-      # @return [<Type::Generic>]
-      attr_reader :generics
-
-      # Initialize the request with the given interned name and generics,
-      # and then freezes the request.
-      #
-      # @api public
-      # @see #intern
-      # @see #generics
-      # @param intern [::String] The interned name.
-      # @param generics [<Type::Generic>] The generics.
-      def initialize(intern, generics)
-        @intern = intern
-        @generics = generics
-        deep_freeze!
-      end
-
-      # Replaces this request or this request's generics with the corresponding
-      # correct module.  This is designed to resolve generic names; for
-      # example, it resolves `Carbon::Pointer<T>` to
-      # `Carbon::Pointer<Carbon::String>` with the right argument.  It checks
-      # for three seperate cases.
-      #
-      # 1. The request has no generics, and the request's {#intern} has a
-      #   mapping in the argument.  In this case, it creates a new request
-      #   object with the new module's name and no generics (because the
-      #   mapping could not have added any worthwhile generics).
-      # 2. The request has no generics, and the request's {#intern} has no
-      #   mapping in the argument.  In this case, it returns itself.
-      # 3. The request has generics.  In this case, the generics are mapped
-      #   using {Type::Generic#sub}, and a new request is created with the
-      #   mapped generics.
-      #
-      # @api public
-      # @example
-      #   string # => #<Carbon::Concrete::Type::Generic Carbon::String>
-      #   request.intern # => "Carbon::Pointer"
-      #   request.generics # => [#<Carbon::Concrete::Type::Generic T>]
-      #   mapped = request.sub("T" => string)
-      #   mapped.intern # => "Carbon::Pointer"
-      #   request.generics.first.equal?(string) # => true
-      # @param mapping [{::String => Type::Generic}] The mapping.
-      # @return [Request] The new request, if the request has no generics,
-      #   and the request's {#intern} is not a key in the mapping, or if
-      #   the request has generics.
-      # @return [self] If the request has no generics and it is not a key
-      #   in the mapping.
-      def sub(mapping)
-        case [@generics.none?, mapping.key?(@intern)]
-        when [true, true]
-          Request.new(mapping[@intern].name.intern, [])
-        when [true, false]
-          self
-        else
-          generics = @generics.map { |generic| generic.sub(mapping) }
-          Request.new(intern, generics)
-        end
-      end
-
-      # Compares this request to another.  If this request _is_ the other
-      # request, it returns true; otherwise, if the other is a request, and
-      # the other request's {#intern} is equal to this request's, it
-      # returns true; otherwise, it returns false.
-      #
-      # @api public
-      # @param other [Request, ::String, ::Object] The object to compare.
-      # @return [::Boolean]
-      def ==(other)
-        equal?(other) ||
-          (other.is_a?(Request) && other.intern == intern &&
-            other.generics == generics)
-      end
-
-      alias_method :eql?, :==
-
-      # Creates a hash of the request.  This is used mostly in the Hash
-      # class.
-      #
-      # @api private
-      # @return [Numeric]
-      def hash
-        @intern.hash
-      end
-
-      # Returns a string representation of this request.  This includes all
-      # generics that are associated with the request, if applicable.
-      #
-      # @api public
-      # @return [::String]
-      def to_s
-        if @generics.any?
-          "#{@intern}<#{@generics.map(&:to_s).join(', ')}>".freeze
-        else
-          @intern
-        end
-      end
-    end
-  end
-end
+# # frozen_string_literal: true
+#
+# require "forwardable"
+#
+# module Carbon
+#   module Concrete
+#     # A "request."  This is used to note the generics that a given module
+#     # should be compiled with.  This is used for items to note the dependencies
+#     # that an item has; otherwise, it is used in the index for build
+#     # information.
+#     #
+#     # @note
+#     #   **This class is frozen upon initialization.**  This means that any
+#     #   attempt to modify it will result in an error.  In most cases, the
+#     #   attributes on this class will also be frozen, as well.
+#     class Request
+#       extend Forwardable
+#
+#       # The interned name of a module.  This is used for module lookup.  This
+#       # contains no generic information.  For generic functions, all generics
+#       # are pushed onto the defining module.
+#       #
+#       # @api public
+#       # @example
+#       #   request.intern # => "Carbon::Pointer"
+#       # @note See {Item::Base#intern} For more information about interned
+#       #   names.
+#       # @return [::String]
+#       attr_reader :intern
+#
+#       # The generics of the request.  Even if the request has no definable
+#       # generics, these are still kept in place for both name information and
+#       # for placement information (e.g. identity and size).
+#       #
+#       # @api public
+#       # @example
+#       #   request.generics # => [#<Carbon::Concrete::Type::Generic T>]
+#       # @return [<Type::Generic>]
+#       attr_reader :generics
+#
+#       # Initialize the request with the given interned name and generics,
+#       # and then freezes the request.
+#       #
+#       # @api public
+#       # @see #intern
+#       # @see #generics
+#       # @param intern [::String] The interned name.
+#       # @param generics [<Type::Generic>] The generics.
+#       def initialize(intern, generics)
+#         @intern = intern
+#         @generics = generics
+#         deep_freeze!
+#       end
+#
+#       # Replaces this request or this request's generics with the corresponding
+#       # correct module.  This is designed to resolve generic names; for
+#       # example, it resolves `Carbon::Pointer<T>` to
+#       # `Carbon::Pointer<Carbon::String>` with the right argument.  It checks
+#       # for three seperate cases.
+#       #
+#       # 1. The request has no generics, and the request's {#intern} has a
+#       #   mapping in the argument.  In this case, it creates a new request
+#       #   object with the new module's name and no generics (because the
+#       #   mapping could not have added any worthwhile generics).
+#       # 2. The request has no generics, and the request's {#intern} has no
+#       #   mapping in the argument.  In this case, it returns itself.
+#       # 3. The request has generics.  In this case, the generics are mapped
+#       #   using {Type::Generic#sub}, and a new request is created with the
+#       #   mapped generics.
+#       #
+#       # @api public
+#       # @example
+#       #   string # => #<Carbon::Concrete::Type::Generic Carbon::String>
+#       #   request.intern # => "Carbon::Pointer"
+#       #   request.generics # => [#<Carbon::Concrete::Type::Generic T>]
+#       #   mapped = request.sub("T" => string)
+#       #   mapped.intern # => "Carbon::Pointer"
+#       #   request.generics.first.equal?(string) # => true
+#       # @param mapping [{::String => Type::Generic}] The mapping.
+#       # @return [Request] The new request, if the request has no generics,
+#       #   and the request's {#intern} is not a key in the mapping, or if
+#       #   the request has generics.
+#       # @return [self] If the request has no generics and it is not a key
+#       #   in the mapping.
+#       def sub(mapping)
+#         case [@generics.none?, mapping.key?(@intern)]
+#         when [true, true]
+#           Request.new(mapping[@intern].name.intern, [])
+#         when [true, false]
+#           self
+#         else
+#           generics = @generics.map { |generic| generic.sub(mapping) }
+#           Request.new(intern, generics)
+#         end
+#       end
+#
+#       # Compares this request to another.  If this request _is_ the other
+#       # request, it returns true; otherwise, if the other is a request, and
+#       # the other request's {#intern} is equal to this request's, it
+#       # returns true; otherwise, it returns false.
+#       #
+#       # @api public
+#       # @param other [Request, ::String, ::Object] The object to compare.
+#       # @return [::Boolean]
+#       def ==(other)
+#         equal?(other) ||
+#           (other.is_a?(Request) && other.intern == intern &&
+#             other.generics == generics)
+#       end
+#
+#       alias_method :eql?, :==
+#
+#       # Creates a hash of the request.  This is used mostly in the Hash
+#       # class.
+#       #
+#       # @api private
+#       # @return [Numeric]
+#       def hash
+#         @intern.hash
+#       end
+#
+#       # Returns a string representation of this request.  This includes all
+#       # generics that are associated with the request, if applicable.
+#       #
+#       # @api public
+#       # @return [::String]
+#       def to_s
+#         if @generics.any?
+#           "#{@intern}<#{@generics.map(&:to_s).join(', ')}>".freeze
+#         else
+#           @intern
+#         end
+#       end
+#     end
+#   end
+# end

data/lib/carbon/concrete/type.rb

@@ -19,8 +19,6 @@ module Carbon
     #   **This class is frozen upon initialization.**  This means that any
     #   attempt to modify it will result in an error.  In most cases, the
     #   attributes on this class will also be frozen, as well.
-    # @todo
-    #   TODO: Add function generics.
     class Type
       # A cache of types.  This maps unparsed strings to their parsed
       # derivatives.  The cache is guarenteed to be thread-safe.
@@ -70,14 +68,23 @@ module Carbon
       # @return [<Type::Generic>]
       attr_reader :generics
 
+      # The location of the type.  This is used for interfacing with other
+      # programs that require a location of some sort.
+      #
+      # @api semiprivate
+      # @return [Object]
+      attr_reader :location
+
       # Initialize the type with the given name.  After initialization, this
       # freezes the type, preventing modification.
       #
       # @api public
       # @param name [Type::Name] The name.
-      def initialize(name)
+      def initialize(name, location: nil)
         @name = name
         @generics = name.last.generics
+        @generics += function.generics if function?
+        @location = location
         deep_freeze!
       end
 
@@ -95,7 +102,27 @@ module Carbon
       #   type.function? # => true
       # @return [::Boolean] True if the type is a function, false otherwise.
       def function?
-        !@name.function.nil?
+        !function.nil?
+      end
+
+      # Returns the function information of the type.  If this isn't a function
+      # type (see {#function?}), then this returns `nil`.
+      #
+      # @api public
+      # @example Not a function.
+      #   type.to_s # => "Carbon::Pointer<T>"
+      #   type.function? # => false
+      #   type.function # => nil
+      # @example A function.
+      #   type.to_s
+      #     # => "Carbon::Pointer<T>.add(Carbon::Pointer<T>, Carbon::Int32)"
+      #   type.function? # => true
+      #   type.function # => #<Carbon::Concrete::Type::Function ...>
+      # @return [Concrete::Type::Function] The function information, if this is
+      #   a function type; otherwise,
+      # @return [nil] returns nil.
+      def function
+        @name.function
       end
 
       # Compares this type to another type.  If the other type _is_ this type,
@@ -123,6 +150,25 @@ module Carbon
 
       alias_method :eql?, :==
 
+      # Checks if the given type "matches" the current type.  This
+      # matches if any of the following conditions apply:
+      #
+      # 1. If the types match exactly, with no generics; otherwise,
+      # 2. If the types match exactly, with generics; otherwise,
+      # 3. If the given type can be made to look like the item type by
+      #   introducing generics; otherwise,
+      # 4. They don't match.
+      #
+      # The base item provides a good default for most items.
+      #
+      # @param type [Concrete::Type] The type to check for matching.
+      # @return [Boolean] If the type matches the item.
+      def match?(other, generics = {})
+        (@generics.none? && to_s == other.to_s && generics) ||
+          (!function? && match_generic_module?(other, generics)) ||
+          (function? && match_generic_function?(other, generics))
+      end
+
       # Creates a hash of the request. This is used mostly in the Hash class.
       #
       # @api private
@@ -158,8 +204,8 @@ module Carbon
       # @param parameters [<Type>] The parameters that the function is
       #   called with.
       # @return [Type] The new type.
-      def call(name, parameters)
-        func = Type::Function.new(name, parameters)
+      def call(name, parameters, generics = [])
+        func = Type::Function.new(name.to_s, parameters, generics)
         name = Name.new(@name.parts, func)
         Type.new(name)
       end
@@ -185,7 +231,8 @@ module Carbon
       #   replace.
       # @return [Concrete::Type] The new type.
       def sub(generics)
-        return generics[key] if generics.key?(intern)
+        return sub_function(generics) if function?
+        return generics[self] if generics.key?(self)
         return self if generics.none?
         replace_generics(generics)
       end
@@ -204,26 +251,13 @@ module Carbon
       #     "Carbon::Int32)"
       #   type = Carbon::Type(form)
       #   type.to_s == form # => true
-      #   second = Carbon::Type`(type.to_s)
+      #   second = Carbon::Type(type.to_s)
       #   type == second # => true
       # @return [::String] The string representation of the type.
       def to_s
         @name.to_s
       end
 
-      # Creates a request based on this type.
-      #
-      # @api semipublic
-      # @example
-      #   type = Carbon::Type("Carbon::Pointer<T>")
-      #   req = type.to_request
-      #   req.intern # => "Carbon::Pointer"
-      #   req.generics # => [#<Carbon::Concrete::Type::Generic T>]
-      # @return [Request]
-      def to_request
-        Request.new(intern, generics)
-      end
-
       # Removes all function information from the type.  This is the complete
       # opposite of {#call}.  This just leaves the module that the function
       # was defined on.
@@ -239,6 +273,21 @@ module Carbon
         Type.new(name)
       end
 
+      # Converts the type into a pointer type.  Essentially, it just
+      # encapsulates the current type in a pointer.
+      #
+      # @example
+      #   inner = Carbon::Boolean
+      #   inner.to_s # => "Carbon::Boolean"
+      #   inner.to_pointer.to_s # => "Carbon::Pointer<Carbon::Boolean>"
+      # @return [Type] The encapsulated type.
+      def to_pointer
+        ptype = Carbon::Type("Carbon::Pointer<T>")
+        tgen = Carbon::Type("T")
+
+        ptype.sub(tgen => self)
+      end
+
       # Pretty inspect.
       #
       # @api private
@@ -247,8 +296,64 @@ module Carbon
         "#<Carbon::Concrete::Type #{self}>".freeze
       end
 
+      # Accepts the current visitor unto itself.
+      #
+      # @param visitor [#visit]
+      # @return [Object]
+      def accept(visitor, *params)
+        visitor.visit(self, *params)
+      end
+
     private
 
+      def sub_function(generics)
+        return self if !@generics.any? &&
+                       function.parameters.all? { |p| !p.generics.any? }
+        basic = to_module.sub(generics)
+        gens = function.generics.map { |p| p.sub(generics) }
+        params = function.parameters.map { |p| p.sub(generics) }
+        basic.call(function.name, params, gens)
+      end
+
+      def match_generic_module?(other, generics)
+        return intern == other.intern && {} unless generics.any?
+        intern == other.intern &&
+          other.generics.all? { |g| generics.values.include?(g.name) } &&
+          generics
+      end
+
+      def match_generic_function_preflight?(other, _)
+        # If neither have generics, then this can't match them.
+        @generics.any? && other.generics.any? &&
+          # If the types are modules, then they should have matched earlier.
+          function? && other.function? &&
+          # The function names should be the same.
+          (function.name == other.function.name) &&
+          # They should have the same number of generics.
+          (@generics.size == other.generics.size) &&
+          # They should have the same number of parameters.
+          (function.parameters.size == other.function.parameters.size)
+      end
+
+      def match_generic_function?(other, generics)
+        return false unless match_generic_function_preflight?(other, generics)
+        mapping = generics.merge(@generics.map(&:name)
+          .zip(other.generics.map(&:name)).to_h)
+        params = function.parameters.zip(other.function.parameters)
+        # If any of the parameters don't match, then the whole doesn't match.
+        # However, if one of the parameters is a generic, then we check to make
+        # sure that the same generic placement is used in the other type.
+        # For example, `A<T>.+(A<T>, T)` would match `A<B>.+(A<B>, B)`, but not
+        # `A<B>.+(A<B>, C)`.
+        params.all? do |(ours, theirs)|
+          if mapping.key?(ours)
+            mapping[ours].match?(theirs, mapping)
+          else
+            ours.match?(theirs, mapping)
+          end
+        end && mapping
+      end
+
       def replace_generics(generics)
         part = Part.new(@name.parts.last.value,
           @generics.map { |g| g.sub(generics) })