carbon-core 0.1.0

data/lib/carbon/concrete/type/function.rb

@@ -0,0 +1,91 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Concrete
+    class Type
+      # The function part of a type.  This comes after the module that it is
+      # defined in, and contains three pieces of information: the name of the
+      # function, the generics associated with the function, and the parameters
+      # of the function.
+      #
+      # @todo TODO: add generic parameters.
+      # @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.
+      # @note
+      #   This class does not include comparison methods; however, if they
+      #   were to ever be needed, {#to_s} should be used for the basis of
+      #   comparison.
+      class Function
+        # The name of the function.  This is normally a bland string.
+        # Functions can have a variety of names to override default operations
+        # in the language; even more so than ruby.
+        #
+        # @api public
+        # @example
+        #   type = Carbon::Type("A.+(A, B)")
+        #   func = type.name.function
+        #   func.name # => "+"
+        # @return [::String] The name of the function.
+        attr_reader :name
+
+        # The parameters for the function.  These are the arguments that are
+        # passed to the function when it's called.  This is included in the
+        # definition for the name of the function to allow overloading.
+        #
+        # @api public
+        # @example
+        #   type = Carbon::Type("A.+(A, B)")
+        #   func = type.name.function
+        #   func.parameters
+        #     # => [#<Carbon::Concrete::Type::Name A>,
+        #     #   #<Carbon::Concrete::Type::Name B>]
+        # @return [::Array<Type::Name>]
+        attr_reader :parameters
+
+        # Initialize the function.
+        #
+        # @see #name
+        # @see #params
+        # @param name [::String] The name of the function.
+        # @param params [::Array<Type::Name>] The parameters of the function.
+        #   This is frozen before stored.
+        def initialize(name, params)
+          @name = name
+          @parameters = params
+          deep_freeze!
+        end
+
+        # Returns a string representation of this function.  In contrast to
+        # {#intern}, this includes generic information.
+        #
+        # @api public
+        # @example
+        #   func.name # => "+"
+        #   func.parameters # => [#<Carbon::Concrete::Type::Name Test<T>>]
+        #   func.to_s # => "+(Test<T>)"
+        # @return [::String]
+        def to_s
+          "#{@name}(#{@parameters.map(&:to_s).join(', ')})".freeze
+        end
+
+        # Returns the interned version of this function.  In contrast to
+        # {#to_s}, this does not include generic information.
+        #
+        # @api public
+        # @note See {Item::Base#intern} For more information about interned
+        #   names.
+        # @example
+        #   func.name # => "+"
+        #   func.parameters # => [#<Carbon::Concrete::Type::Name Test<T>>]
+        #   func.intern # => "+(Test)"
+        # @return [::String]
+        def intern
+          "#{@name}(#{@parameters.map(&:intern).join(', ')})".freeze
+        end
+      end
+    end
+  end
+end

data/lib/carbon/concrete/type/generic.rb

@@ -0,0 +1,118 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Concrete
+    class Type
+      # A generic part of a type.  This is normally the `T` in
+      # `Carbon::Pointer<T>`.  Generic portions can also have traits that
+      # the generic type must implement; this keeps track of that too.
+      # A complete example, containing traits, would look like this:
+      # `Carbon::Pointer<T: Carbon::Sized + Carbon::Numeric>`.  The actual
+      # pointer type may not use those traits.
+      #
+      # @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 Generic
+        # The name of the generic.  This is the generic type variable that is
+        # substituted in later for an actual value.  This is normally a single
+        # character module name, but can be as complicated as needed.
+        #
+        # @api public
+        # @example
+        #   type = Carbon::Type("Carbon::Pointer<T>")
+        #   type.generics.first.name # => #<Carbon::Concrete::Type T>
+        # @return [Type] The name.
+        attr_reader :name
+
+        # The implements of the generic.  These are the traits that the generic
+        # parameter has to implement; this allows the generic code to make
+        # assumptions about the generic type (such as behavior or size) that
+        # would otherwise be impossible to make.
+        #
+        # @api public
+        # @example
+        #   name = "Carbon::Pointer<T: Carbon::Sized>"
+        #   type = Carbon::Type(name)
+        #   type.generics.first.implements
+        #     # => Set[#<Carbon::Concrete::Type Carbon::Sized>]
+        # @return [Set<Type>] The traits the generic has to implement.
+        attr_reader :implements
+
+        # Initialize the generic part of the type.
+        #
+        # @see #name
+        # @see #implements
+        # @param name [Type] The name of the generic.
+        # @param implements [Set<Type>] The traits the generic must
+        #   implement, if any.
+        def initialize(name, implements)
+          @name = name
+          @implements = Set.new(implements)
+          deep_freeze!
+        end
+
+        # Returns the correct generic.  This is a weird function, but
+        # essentially, if the {#name}'s {Type#intern} is oen of the keys of
+        # the mapping, it returns the new generic; otherwise, it returns
+        # this object.
+        #
+        # @api public
+        # @example
+        #   generic.to_s # => "T: Carbon::Sized"
+        #   generic.is_a?(Generic) # => true
+        #   other.to_s # => "Carbon::String"
+        #   other.is_a?(Generic) # => true
+        #   result = generic.sub("T" => other)
+        #   result.to_s # => "Carbon::String: Carbon::Sized"
+        # @param mapping [{::String => Type::Generic}] The mapping.
+        # @return [Type::Generic] A different instance of the generic, if it's
+        #   in the mapping.
+        # @return [self] otherwise.
+        def sub(mapping)
+          mapping.fetch(@name.intern, self)
+        end
+
+        # Compares this generic instance to another generic instance.  If the
+        # other generic instance _is_ this generic instance it returns true;
+        # otherwise, if the other value is a generic, and that generic's
+        # {#to_s} is equal to this one's, it returns true; otherwise, it
+        # returns false.
+        #
+        # @api public
+        # @example
+        #   type1 = Carbon::Type("Carbon::Pointer<T>")
+        #   type2 = Carbon::Type("Carbon::List<T>")
+        #   type1.generics == type2.generics # => true
+        # @param other [Type::Generic, ::Object] The object to compare.
+        # @return [::Boolean] True if the two are equivalent.
+        def ==(other)
+          equal?(other) ||
+            (other.is_a?(Type::Generic) && other.to_s == to_s)
+        end
+
+        alias_method :eql?, :==
+
+        # A string representation of the generic.  If there are no implements,
+        # this is a direct call to {#name}'s {Type#to_s}; otherwise, this
+        # includes the name with a joined string of implements.
+        #
+        # @api public
+        # @example
+        #   name = "Carbon::Pointer<T: Carbon::Sized>"
+        #   type = Carbon::Type(name)
+        #   type.generics.first.to_s # => "T: Carbon::Sized"
+        # @return [::String] The string representation.
+        def to_s
+          if @implements.any?
+            "#{@name}: #{@implements.map(&:to_s).join(' + ')}".freeze
+          else
+            @name.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/concrete/type/name.rb

@@ -0,0 +1,147 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Concrete
+    class Type
+      # The "name" of a type.  This contains all of the physical information
+      # of a type.  This mostly means the "parts" for the name, and the
+      # function information if it is included.
+      #
+      # @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 Name
+        include Enumerable
+        extend Forwardable
+
+        # The parts of the name.  This is mainly the sections of the type
+        # name; for example, for `Carbon::Pointer`, the parts are `Carbon` and
+        # `Pointer`.  Each part can contain generic information; however,
+        # by convention, only the last part is actually included for generic
+        # information.
+        #
+        # @api semipublic
+        # @example
+        #   type = Carbon::Type("Carbon::Pointer<T>")
+        #   name = type.name
+        #   name.parts
+        #     # => [#<Carbon::Concrete::Type::Part Carbon>,
+        #     #   #<Carbon::Concrete::Type::Part Pointer>]
+        # @return [<Type::Part>] The parts.
+        attr_reader :parts
+
+        # The function information of a type.  If no function information was
+        # included (i.e. the type is a module), then this is `nil`.
+        # Function information always includes a name and the parameters, if
+        # it is included.
+        #
+        # @api public
+        # @example
+        #   full = "Carbon::Pointer<T>.+(Carbon::Pointer<T>, Carbon::Int32)"
+        #   type = Carbon::Type(full)
+        #   name = type.name
+        #   name.function.to_s # => "+(Carbon::Pointer<T>, Carbon::Int32)"
+        # @return [Type::Function] The function information.
+        attr_reader :function
+
+        # @!method each
+        #   Iterates over each part.
+        #
+        #   @see #parts
+        #   @api semipublic
+        #   @example
+        #     type.name.each { |part| puts part }
+        #   @return [::Enumerable] An enumerable over the parts.
+        # @!method to_a
+        #   Returns an array of the parts of the name.
+        #
+        #   @see #parts
+        #   @api semipublic
+        #   @example
+        #     type.name.to_a == type.name.parts # => true
+        #   @return [<Type::Part>] The parts.
+        # @!method [](index)
+        #   Returns a part at a specific index, or the parts over the given
+        #   range.
+        #
+        #   @see #parts
+        #   @api semipublic
+        #   @example
+        #     type.name[0].to_s # => "Carbon"
+        #   @param index [Numeric, Range<Numeric>]
+        #   @return [Type::Part] The part.
+        #   @return [<Type::Part>] The parts over the range.
+        # @!method first
+        #   Returns the first part in the name.
+        #
+        #   @see #parts
+        #   @api semipublic
+        #   @example
+        #     type.name.first.to_s # => "Carbon"
+        #   @return [Type::Part] The first part.
+        # @!method last
+        #   Returns the last part in the name.
+        #
+        #   @see #part
+        #   @api semipublic
+        #   @example
+        #     type.name.last.to_s # => "Pointer<T>"
+        #   @return [Type::Part] The last part.
+        delegate [:each, :to_a, :[], :first, :last] => :@parts
+
+        # Initialize the name with the given parts and function information.
+        # Freezes the class after completion.
+        #
+        # @param parts [<Type::Part>] The parts of the name.
+        # @param function [Type::Function?] The function part of the name, if
+        #   it exists.
+        def initialize(parts, function)
+          @parts = parts.freeze
+          @function = function
+
+          to_s
+          intern
+          deep_freeze!
+        end
+
+        # A string representation of the name.  Unlike {#intern}, this
+        # includes all generic information as well.
+        #
+        # @api public
+        # @example
+        #   type = Carbon::Type("Carbon::Pointer<T>")
+        #   type.to_s # => "Carbon::Pointer<T>"
+        # @return [::String] The string representation.
+        def to_s
+          @_to_s ||=
+            if @function
+              "#{@parts.map(&:to_s).join('::')}.#{@function}"
+            else
+              @parts.map(&:to_s).join("::")
+            end.freeze
+        end
+
+        # An interned name of the type.  Unlike {#to_s}, this doesn't include
+        # any generic information.
+        #
+        # @api public
+        # @example
+        #   type = Carbon::Type("Carbon::Pointer<T>")
+        #   type.intern # => "Carbon::Pointer"
+        # @note See {Item::Base#intern} For more information about interned
+        #   names.
+        # @return [::String] The interned name of the type.
+        def intern
+          @_intern ||=
+            if @function
+              "#{@parts.map(&:intern).join('::')}.#{@function.intern}"
+            else
+              @parts.map(&:intern).join("::")
+            end.freeze
+        end
+      end
+    end
+  end
+end

data/lib/carbon/concrete/type/parse.rb

@@ -0,0 +1,172 @@
+# encoding: utf-8
+# frozen_string_literal: true
+# rubocop:disable all
+
+require "strscan"
+
+module Carbon
+  module Concrete
+    class Type
+      # Parses a type.  This starts by scanning the string, then parsing it.
+      # Each instance should result in a different parsed value; a single
+      # instance cannot be re-used for parsing something else.  **Not for
+      # public consumption.**
+      #
+      # @api private
+      # @private
+      class Parse
+        # Initialize the parser.
+        #
+        # @param scan [::String] The string to parse.
+        def initialize(scan)
+          @string = scan
+          @scanner = StringScanner.new(@string)
+        end
+
+        # The resulting value.  This should be a name.
+        #
+        # @see #parse
+        # @return [Type::Name]
+        def value
+          @_value ||= parse
+        end
+
+      private
+
+        def parse
+          @tokens = scan
+          name = parse_name
+        end
+
+        def scan
+          return to_enum(:scan) unless block_given?
+
+          until @scanner.eos?
+            single = scan_single
+            yield single if single
+          end
+
+          yield [:EOS]
+        end
+
+        def expect(*values)
+          token = @tokens.next
+          error(values, token[0]) unless values.include?(token[0])
+          token
+        end
+
+        def parse_name
+          parts = [parse_name_part]
+          func = nil
+
+          while @tokens.peek[0] == :"::"
+            expect :"::"
+            parts << parse_name_part
+          end
+
+          parts = [*parts[0..-2].map(&:strip), parts[-1]]
+          func = parse_function_name if @tokens.peek[0] == :"."
+
+          Name.new(parts, func)
+        end
+
+        def parse_function_name
+          name = nil
+          params = []
+          expect :"."
+          name =  case @tokens.peek[0]
+                  when :<   then expect(:<); "<"
+                  when :>   then expect(:>); ">"
+                  when :+   then expect(:+); "+"
+                  else expect(:FNAME)[1]
+                  end
+
+          expect :"("
+          until @tokens.peek[0] == :")"
+            params << Type.new(parse_name)
+            break unless @tokens.peek[0] == :","
+            expect :","
+          end
+          expect :")"
+
+          Function.new(name, params)
+        end
+
+        def parse_name_part
+          part = expect(:MNAME)
+          generics = []
+          if @tokens.peek[0] == :<
+            expect :<
+
+            until @tokens.peek[0] == :>
+              generics << parse_generic
+              break unless @tokens.peek[0] == :","
+              expect :","
+            end
+
+            expect :>
+          end
+
+          Part.new(part[1], generics)
+        end
+
+        def parse_generic
+          name = Type.new(parse_name)
+          implements = []
+          if @tokens.peek[0] == :":"
+            expect :":"
+            implements << Type.new(parse_name)
+            while @tokens.peek[0] == :+
+              expect :+
+              implements << Type.new(parse_name)
+            end
+          end
+
+          Generic.new(name, implements)
+        end
+
+        FUNC_NAME = %r{
+          (
+              [a-z][A-Za-z0-9_-]*[!?=]?
+            | === | ==
+            | \<=\>
+            | << | >>
+            | <= | >=
+            | \-
+            | \* | \/
+            | % | & | \|
+            | \[\]
+            | \^
+          )
+        }x.freeze
+
+        def scan_single
+          case
+          when @scanner.scan(/[A-Z][A-Za-z0-9_-]*/)
+            [:MNAME, @scanner[0]]
+          when @scanner.scan(FUNC_NAME)
+            [:FNAME, @scanner[0]]
+          when @scanner.scan(/::/) then [:"::"]
+          when @scanner.scan(/</) then [:<]
+          when @scanner.scan(/>/) then [:>]
+          when @scanner.scan(/,/) then [:","]
+          when @scanner.scan(/:/) then [:":"]
+          when @scanner.scan(/\+/) then [:+]
+          when @scanner.scan(/\./) then [:"."]
+          when @scanner.scan(/\(/) then [:"("]
+          when @scanner.scan(/\)/) then [:")"]
+          when @scanner.scan(/\s+/)
+          else error([], @string[@scanner.pos])
+          end
+        end
+
+        def error(expected, given)
+          fail ArgumentError,
+            "Unexpected #{given.inspect}, " \
+            "expected #{expected.map(&:inspect).join(', ')} " \
+            "(source #{@string})"
+        end
+      end
+    end
+  end
+end