carbon-core 0.1.1 → 0.2.0

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

@@ -8,30 +8,19 @@ module Carbon
       # items need to share to be compatible with the index.  This module is
       # the bases of the build system in the {Concrete} module.
       module Base
-        # Returns the interned name of the item.  This contains no generic
-        # information.  Interned names are mostly used to match generic
-        # information laden types with the items that define them; for example,
-        # it is meant to be used to match the type
-        # `Carbon::Pointer<Carbon::String>` to the module `Carbon::Pointer<T>`.
-        # The common parts of both is the module name that the type uses - or,
-        # rather, everything but the generic information.  Interned names
-        # discard the information that is unneeded for matching the two.
-        #
-        # This methodology has the downside that a module with the same name
-        # as the base of a generic module cannot exist; however, allowing such
-        # would ultimately be confusing.
+        # Returns the type of the item.  This is the full {Concrete::Type}.
         #
         # @api public
         # @example For a module.
         #   item.name # => "Carbon::Pointer<T>"
-        #   item.intern # => "Carbon::Pointer"
+        #   item.type # => #<Carbon::Type Carbon::Pointer<T>>
         # @example For a function.
         #   item.name
         #     # => "Carbon::Pointer<T>.+(Carbon::Pointer<T>, Carbon::Int32)"
         #   item.intern
-        #     # => "Carbon::Pointer.+(Carbon::Pointer, Carbon::Int32)"
-        # @return [::String] The interned name.
-        attr_reader :intern
+        #     # => #<Carbon::Type Carbon::Pointer.+(Carbon::Pointer, Carbon::Int32)>
+        # @return [Concrete::Type] The type.
+        attr_reader :type
 
         # Returns the full name of the item.  This can include generic
         # information.
@@ -69,26 +58,24 @@ module Carbon
         # @param type [Concrete::Type] The type.
         # @return [{::Symbol => ::Object}]
         def self.from(type)
-          { module: type }
+          { type: type }
         end
 
         # Compares this item to another object.  If the other object _is_ this
-        # item, then it returns true; otherwise, if the other object is an
-        # item, and the other object's {#intern} is equal to this object's
-        # {#intern}, then it returns true; otherwise, it returns false.
+        # item, then it returns true; otherwise, it returns false.
         #
         # @api public
         # @example
-        #   first.intern # => "Carbon::Pointer"
-        #   second.intern # => "Carbon::Pointer"
+        #   first.type # => "Carbon::Pointer<T>"
+        #   second.type # => "Carbon::Pointer<T>"
         #   first == first # => true
         #   first == second # => true
         #   second == second # => true
         #   second == first # => true
-        # @param other [Base, ::String, ::Object] The object to compare.
+        # @param other [Base, ::Object] The object to compare.
         # @return [::Boolean] The result of comparison.
         def ==(other)
-          equal?(other) || (other.is_a?(Base) && intern == other.intern)
+          equal?(other)
         end
         alias_method :eql?, :==
 
@@ -98,7 +85,7 @@ module Carbon
         # @api private
         # @return [Numeric]
         def hash
-          intern.hash
+          type.hash
         end
 
         # rubocop:disable Lint/UnusedMethodArgument
@@ -150,10 +137,10 @@ module Carbon
 
         def forced_corrected_dependencies(request, &block)
           # Array<Type::Generic> -> Array<(Type::Generic, Numeric)> ->
-          # Array<(String, Type::Generic)> -> {String => Type::Generic}
+          # Array<(Type, Type)> -> {Type => Type}
           mapping = generics
                     .each_with_index
-                    .map { |gen, i| [gen.name.intern, request.generics[i]] }
+                    .map { |gen, i| [gen.name, request.generics[i].name] }
                     .to_h
 
           dependencies.map { |dep| dep.sub(mapping) }.each(&block)

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

@@ -0,0 +1,71 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require "carbon/concrete/item/class/element"
+
+module Carbon
+  module Concrete
+    module Item
+      # A struct data type.  This is normally a sequence of elements that are
+      # stored sequentially in memory.  Each element has a name, to reference
+      # which position, and a type.  All references to this data type in memory
+      # are through pointers.
+      #
+      # @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 Class
+        include Data
+
+        # (see Item::Base.from)
+        def self.from(type)
+          { type: type, implements: [], elements: [] }
+        end
+
+        # Initialize the struct with the given data.
+        #
+        # @param data [::Hash] The data to initialize with.
+        # @option data [Type] :module The name of the struct.
+        # @option data [<::String, Type>] :elements The elements of
+        #   the struct.
+        # @option data [<Type>] :implements The traits that this
+        #   data type implements.
+        def initialize(data)
+          @type     = data.fetch(:type)
+          @generics = @type.generics
+          @name     = @type.to_s
+          @extern   = data[:extern]
+
+          @implements   = Set.new(data.fetch(:implements))
+          @dependencies = Set.new
+
+          derive_elements(data.fetch(:elements))
+          derive_dependencies
+          deep_freeze!
+        end
+
+        # (see Base#call)
+        def call(build, generics)
+          full = @type.sub(generics)
+          elements = @elements.map(&:type).map { |t| t.sub(generics) }
+            .map { |t| build.fetch(t).last }
+          name = @extern || full.to_s
+          build.items[full] =
+            [self, ::LLVM::Type.struct(elements, false, name).pointer]
+        end
+
+      private
+
+        def derive_elements(elements)
+          @elements = elements.map { |e| Element.new(*e) }
+        end
+
+        def derive_dependencies
+          @dependencies.merge(@elements.map(&:type))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Concrete
+    module Item
+      class Class
+        # An element of a class.  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/function.rb

@@ -24,35 +24,35 @@ module Carbon
         attr_reader :return
         attr_reader :definition
 
-
         # (see Item::Base.from)
         def self.from(type)
           {
-            module: type.to_module,
-            internal: type.name.function.name,
-            arguments: type.name.function.parameters,
+            type: type,
             generics: type.generics,
-            definition: Tacky::Function.new(type.name.function.parameters)
+            internal: type.function.name,
+            parameters: type.function.parameters,
+            definition: Tacky::Function.new(type.function.parameters)
           }
         end
 
         def initialize(data)
-          @module = data.fetch(:module)
-          @internal = data.fetch(:internal)
-          @parameters = data.fetch(:arguments) { data.fetch(:parameters) }
+          @type = data.fetch(:type)
+          @internal = data.fetch(:internal) { @type.function.name }
+          @parameters = data.fetch(:parameters) { @type.function.parameters }
           @definition = data.fetch(:definition)
-          @generics = data.fetch(:generics) { @module.generics }
+          @generics = data.fetch(:generics) { @type.generics }
           @return = data.fetch(:return)
+          @extern = data[:extern]
+          @name = @type.to_s
 
-          derive_name
           derive_dependencies
           deep_freeze!
         end
 
         def define(index)
           if @definition.is_a?(::Proc)
-            Function.from(func)
-              .merge(definition: @definition.call(index), return: @return)
+            Function.new(Function.from(@type)
+              .merge(definition: @definition.call(index), return: @return))
           else
             self
           end
@@ -60,47 +60,43 @@ module Carbon
 
         # (see Base#call)
         def call(build, generics)
-          value = case @definition
-                  when Tacky::Function
-                    build_function_intern(build, generics)
-                  when ::String, ::Symbol
-                    build_function_extern(build, generics)
-                  else fail ArgumentError,
-                    "Unknown definition #{@definition.class}"
-                  end
-
-          build.functions[@module.sub(generics)] = value
+          case @definition
+          when Tacky::Function
+            build_function_intern(build, generics)
+          when ::String, ::Symbol
+            build_function_extern(build, generics)
+          else fail ArgumentError,
+            "Unknown definition #{@definition.class}"
+          end
         end
 
       private
 
-        # rubocop:disable Metrics/AbcSize
         def build_function_intern(build, generics)
-          full = @full.sub(generics)
+          full = @type.sub(generics)
           params = @parameters
-            .map { |p| build.types.fetch(p.sub(generics)).last }
-          ret = build.types.fetch(@return.sub(generics)).last
-          func = build.module.functions.add(full, params, ret)
+            .map { |p| build.fetch(p.sub(generics)).last }
+          ret = build.fetch(@return.sub(generics)).last
+          func = build.module.functions.add(@extern || full, params, ret)
           @definition.call(func, build, generics)
-          build.functions[full] = [self, func]
+          build.items[full] = [self, func]
         end
-        # rubocop:enable Metrics/AbcSize
 
-        # @todo TODO: finish.
         def build_function_extern(build, generics)
+          full = @type.sub(generics)
+          params = @parameters
+            .map { |p| build.fetch(p.sub(generics)).last }
+          ret = build.fetch(@return.sub(generics)).last
+          func = build.module.functions.add(@definition, params, ret)
+          build.items[full] = [self, func]
         end
-
-        def derive_name
-          @full = @module.call(@internal, @parameters)
-          @intern = @full.intern
-          @name = @full.to_s
-        end
+        # rubocop:enable Metrics/AbcSize
 
         def derive_dependencies
           @dependencies = Set.new
-          @dependencies << @return.to_request
-          @dependencies.merge(@parameters.map(&:to_request))
-          @dependencies.merge(@definition.dependencies.map(&:to_request)) if \
+          @dependencies << @return
+          @dependencies.merge(@parameters)
+          @dependencies.merge(@definition.dependencies) if \
             @definition.is_a?(Tacky::Function)
         end
       end

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

@@ -26,7 +26,7 @@ module Carbon
 
         # (see Item::Base.from)
         def self.from(type)
-          { module: type, implements: [] }
+          { type: type, implements: [] }
         end
 
         # Initialize the internal data type.  Internal data types may not have
@@ -34,11 +34,11 @@ module Carbon
         # implement traits.
         #
         # @param data [::Hash] The options for the internal data type.
-        # @option data [Type] :module The module of the internal data type.
+        # @option data [Type] :type The module of the internal data type.
         # @option data [::String, ::Symbol] :kind The kind of the internal data
-        #   type.  Valid values are `:integer`, `:pointer`, `:int_pointer`,
-        #   `:ary_pointer`, or the string version of any of those.  This
-        #   controls the underlying LLVM type of the internal data type.
+        #   type.  Valid values are `:integer`, `:pointer`, `:void`, or the
+        #   string version of any of those.  This controls the underlying LLVM
+        #   type of the internal data type.
         # @option data [::String, ::Numeric, #to_i] :size The size of the
         #   internal data type.  For integers, it is the number of bits in the
         #   integer; for pointers, it is the number of bits of the element it
@@ -46,36 +46,34 @@ module Carbon
         # @option data [<Type>] :implements ([]) The types that the
         #   internal data type implements.
         def initialize(data)
-          @module = data.fetch(:module)
-          @kind = data.fetch(:kind) { data.fetch(:type) }.to_s
+          @type = data.fetch(:type)
+          @kind = data.fetch(:kind).to_s
           @size = data.fetch(:size, 8)
+          @extern = data[:extern]
 
-          @generics = @module.generics
+          @generics = @type.generics
           @implements = Set.new(data.fetch(:implements, []))
-          @dependencies = Set.new
+          @dependencies = Set.new(@generics.map(&:name))
+          @name = @module.to_s
 
-          derive_name
           deep_freeze!
         end
 
         # (see Base#call)
         def call(build, generics)
+          full = @type.sub(generics)
           value = case @kind.to_s
                   when "integer" then TYPE.call(@size)
+                  when "void"    then ::LLVM::Type.void
+                  when "opaque"
+                    ::LLVM::Type.struct([], false, @extern || full.to_s)
                   when "pointer"
-                    type = build.types.fetch(generics.fetch("T"))
+                    type = build.fetch(generics.fetch(Carbon::Type("T")))
                     type.last.pointer
                   else fail ArgumentError, "Unknown kind #{@kind}"
                   end
 
-          build.types[@module.sub(generics)] = [self, value]
-        end
-
-      private
-
-        def derive_name
-          @intern = @module.intern
-          @name = @module.to_s
+          build.items[@type.sub(generics)] = [self, value]
         end
       end
     end

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

@@ -20,7 +20,7 @@ module Carbon
 
         # (see Item::Base.from)
         def self.from(type)
-          { module: type, implements: [], elements: [] }
+          { type: type, implements: [], elements: [] }
         end
 
         # Initialize the struct with the given data.
@@ -32,10 +32,10 @@ module Carbon
         # @option data [<Type>] :implements The traits that this
         #   data type implements.
         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
+          @extern   = data[:extern]
 
           @implements   = Set.new(data.fetch(:implements))
           @dependencies = Set.new
@@ -47,7 +47,12 @@ module Carbon
 
         # (see Base#call)
         def call(build, generics)
-          super # TODO: fixme.
+          full = @type.sub(generics)
+          elements = @elements.map(&:type).map { |t| t.sub(generics) }
+            .map { |t| build.fetch(t).last }
+          name = @extern || full.to_s
+          build.items[full] =
+            [self, ::LLVM::Type.struct(elements, false, name)]
         end
 
       private
@@ -57,7 +62,7 @@ module Carbon
         end
 
         def derive_dependencies
-          @dependencies.merge(@elements.map { |e| e.type.to_request })
+          @dependencies.merge(@elements.map(&:type))
         end
       end
     end