carbon-core 0.1.0

data/lib/carbon/concrete/item/struct/element.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Concrete
+    module Item
+      class Struct
+        # An element of a struct.  Contains name and type information, and
+        # that's it.
+        #
+        # @api private
+        # @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 Element
+          # The name of the element.
+          #
+          # @return [::String]
+          attr_reader :name
+
+          # The type of the element.
+          #
+          # @return [Type]
+          attr_reader :type
+
+          # Initialize the element with the given name and type.
+          #
+          # @see #name
+          # @see #type
+          # @param name [::String] The name of the element.
+          # @param type [Type] The type of the element.
+          def initialize(name, type)
+            @name = name
+            @type = type
+            deep_freeze!
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require "carbon/concrete/item/trait/expectation"
+
+module Carbon
+  module Concrete
+    module Item
+      # A trait.  This says that a specific type behaves with a certain set
+      # of functions.
+      #
+      # @api private
+      # @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 Trait
+        include Base
+
+        # (see Item::Base.from)
+        def self.from(type)
+          { module: type, expectations: [] }
+        end
+
+        # The expectations for the trait.
+        #
+        # @api semipublic
+        # @example
+        #   trait.expectations
+        #     # => [#<Carbon::Concrete::Item::Trait::Expectation +)]
+        # @return [Set<Expectation>]
+        attr_reader :expectations
+
+        # 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 [<(::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
+
+          derive_expectations(data.fetch(:expectations))
+          derive_dependencies
+          deep_freeze!
+        end
+
+        # (see Base#call)
+        def call(build, generics)
+          super # TODO: fixme.
+        end
+
+      private
+
+        def derive_expectations(expectations)
+          expects = expectations.map { |e| Expectation.new(*e) }
+          @expectations = Set.new(expects)
+        end
+
+        def derive_dependencies
+          @expectations.each do |expect|
+            @dependencies.merge(expect.parameters.map(&:to_request))
+            @dependencies << expect.return.to_request
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Concrete
+    module Item
+      class Trait
+        # An expectation of a trait.  This is a function that an implementing
+        # data type must implement to be considered a part of the trait.
+        #
+        # @api private
+        # @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 Expectation
+          # The name of the function for this expectation.  This is a string,
+          # and can be any valid function name for a carbon function.
+          #
+          # @return [::String] The function name.
+          attr_reader :name
+
+          # The parameters of the function for this expectation.  This is an
+          # array of types, which can contain generic parameters.
+          #
+          # @return [<Type>] The parameter types.
+          attr_reader :parameters
+
+          # The return type of the function for this expectation.  This is
+          # a single type, which can contain generic parameters.
+          #
+          # @return [Type] The return type.
+          attr_reader :return
+
+          # Initialize the expectation with the given arguments.
+          #
+          # @see #name
+          # @see #parameters
+          # @see #return
+          # @param name [::String] The name of the function for the expectation.
+          # @param parameters [<Type>] The parameters of the function for
+          #   the expectation.
+          # @param ret [Type] The return type of the function for the
+          #   expectation.
+          def initialize(name, parameters, ret)
+            @name = name
+            @parameters = parameters
+            @return = ret
+            deep_freeze!
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/concrete/request.rb

@@ -0,0 +1,137 @@
+# 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

data/lib/carbon/concrete/type.rb

@@ -0,0 +1,260 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require "set"
+require "carbon/concrete/type/function"
+require "carbon/concrete/type/generic"
+require "carbon/concrete/type/name"
+require "carbon/concrete/type/part"
+require "carbon/concrete/type/parse"
+
+module Carbon
+  module Concrete
+    # A type.  This is, basically, any possible name that could resolve
+    # into an actual type.  Modules or functions are included in the
+    # typing.  The Type class includes a parsing module, allowing types
+    # to be stored as a string and then re-serialized as a Type.
+    #
+    # @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.
+    # @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.
+      #
+      # @api private
+      # @return [{::String => Type}]
+      def self.cache
+        @cache ||= Concurrent::Map.new
+      end
+
+      # Returns the corresponding type for the given string value.  If
+      # a type is not cached in {.cache}, then it computes it using
+      # {Parse}.  The cache is locked during the computation, such that
+      # it won't be modified while the value is being parsed.
+      #
+      # @api public
+      # @example
+      #   type = Carbon::Type("Carbon::Pointer")
+      #   type.to_s # => "Carbon::Pointer"
+      #   type.function? # => false
+      #   second = Carbon::Type("Carbon::Pointer")
+      #   type.equal?(second) # => true
+      # @param string [::String] The type to parse.
+      # @return [Type]
+      def self.from(string)
+        return string if string.is_a?(Type)
+        cache.compute_if_absent(string) { new(Parse.new(string).value) }
+      end
+
+      # The name of the type.  This is from the parsed result.  This
+      # contains the part and function information.
+      #
+      # @api private
+      # @return [Type::Name]
+      attr_reader :name
+
+      # The generic information for the type.  This is derived directly
+      # from the last part in the name and the function name (if it
+      # exists).
+      #
+      # @api public
+      # @example
+      #   type = Carbon::Type("Result<T, E>")
+      #   type.generics
+      #     # => [#<Carbon::Concrete::Type::Generic T>,
+      #     #  #<Carbon::Concrete::Type::Generic E>]
+      # @return [<Type::Generic>]
+      attr_reader :generics
+
+      # 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)
+        @name = name
+        @generics = name.last.generics
+        deep_freeze!
+      end
+
+      # Returns whether or not this type is a function type.  It does this by
+      # checking to see if the {Type::Name#function} attribute on the {#name}
+      # is not nil.
+      #
+      # @api public
+      # @example Not a function.
+      #   type.to_s # => "Carbon::Pointer<T>"
+      #   type.function? # => false
+      # @example A function.
+      #   type.to_s
+      #     # => "Carbon::Pointer<T>.add(Carbon::Pointer<T>, Carbon::Int32)"
+      #   type.function? # => true
+      # @return [::Boolean] True if the type is a function, false otherwise.
+      def function?
+        !@name.function.nil?
+      end
+
+      # Compares this type to another type.  If the other type _is_ this type,
+      # it returns true; otherwise, if the other value is a {Type} and the
+      # other type's {#to_s} is equal to this one's, it returns true;
+      # otherwise, it returns false.
+      #
+      # @api public
+      # @example Compare with self.
+      #   second = type
+      #   type.equal?(second) # => true
+      #   type == second # => true
+      # @example Compare with a type.
+      #   type.equal?(second) # => false
+      #   type.to_s # => "Carbon::Pointer<T>"
+      #   second.to_s # => "Carbon::Pointer<T>"
+      #   type.to_s == second.to_s # => true
+      #   type == second # => true
+      # @param other [Type, ::String, ::Object] The other object to compare.
+      # @return [::Boolean] True if the other object is similar to this type;
+      #   false otherwise.
+      def ==(other)
+        equal?(other) || (other.is_a?(Type) && other.to_s == to_s)
+      end
+
+      alias_method :eql?, :==
+
+      # Creates a hash of the request. This is used mostly in the Hash class.
+      #
+      # @api private
+      # @return [::Numeric] The hash.
+      def hash
+        to_s.hash
+      end
+
+      # 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
+      #   type.intern # => "Carbon::Pointer"
+      # @note See {Item::Base#intern} For more information about interned
+      #   names.
+      # @see Type::Name#intern
+      # @return [::String] The interned name of the type.
+      def intern
+        @name.intern
+      end
+
+      # Creates a new type using this type as a base.  The new type is a
+      # function type; this provides information for the function type.
+      #
+      # @api semipublic
+      # @example
+      #   bool = Carbon::Boolean
+      #   func = bool.call("<=>", [bool, bool])
+      #   func.to_s # => "Carbon::Boolean.<=>(Carbon::Boolean, Carbon::Boolean)"
+      # @param name [::String] The name of the function that is being defined.
+      # @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)
+        name = Name.new(@name.parts, func)
+        Type.new(name)
+      end
+
+      # Replaces all of the generics in the {Type} with the mapped ones.  This
+      # is used when generics are fully resolved.
+      #
+      # @note
+      #   This also replaces the type itself if the type matches any of the
+      #   keys in the generic mapping.
+      # @api semipublic
+      # @example Normal replacement.
+      #   type # => #<Carbon::Concrete::Type Carbon::Pointer<T>>
+      #   mapping # => {"T" => #<Carbon::Concrete::Type Carbon::Int32>}
+      #   subbed = type.sub(mapping)
+      #   subbed # => #<Carbon::Concrete::Type Carbon::Pointer<Carbon::Int32>>
+      # @example Special replacement.
+      #   type # => #<Carbon::Concrete::Type T>
+      #   mapping # => {"T" => #<Carbon::Concrete::Type Carbon::Int32>}
+      #   subbed = type.sub(mapping)
+      #   subbed # => #<Carbon::Concrete::Type Carbon::Int32>
+      # @param generics [{::String => Carbon::Concrete::Type}] The generics to
+      #   replace.
+      # @return [Concrete::Type] The new type.
+      def sub(generics)
+        return generics[key] if generics.key?(intern)
+        return self if generics.none?
+        replace_generics(generics)
+      end
+
+      # Creates a string representation of the type for comparison or storage.
+      # The string representation has a constraint that it must be re-parsable
+      # by the {Type::Parse} class.
+      #
+      # @api public
+      # @example String representation.
+      #   type = Carbon::Type("Carbon::Pointer<T>")
+      #   type.to_s # => "Carbon::Pointer<T>"
+      # @example Re-parsing string.
+      #   form = "Carbon::Pointer<T: Carbon::Sized + Carbon::Numeric>" \
+      #     ".add(Carbon::Pointer<T: Carbon::Sized + Carbon::Numeric>, " \
+      #     "Carbon::Int32)"
+      #   type = Carbon::Type(form)
+      #   type.to_s == form # => true
+      #   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.
+      #
+      # @api semipublic
+      # @example
+      #   func = Carbon::Boolean.call("test")
+      #   func.to_s # => "Carbon::Boolean.test()"
+      #   func.to_module.to_s # => "Carbon::Boolean"
+      # @return [Type]
+      def to_module
+        name = Name.new(@name.parts, nil)
+        Type.new(name)
+      end
+
+      # Pretty inspect.
+      #
+      # @api private
+      # @return [::String] An inspection string.
+      def inspect
+        "#<Carbon::Concrete::Type #{self}>".freeze
+      end
+
+    private
+
+      def replace_generics(generics)
+        part = Part.new(@name.parts.last.value,
+          @generics.map { |g| g.sub(generics) })
+        name = Name.new([*@name.parts[0..-2], part], @name.function)
+        Type.new(name)
+      end
+    end
+  end
+end