carbon-core 0.1.1 → 0.2.0

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

@@ -9,7 +9,6 @@ module Carbon
       # 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
@@ -26,7 +25,7 @@ module Carbon
         # @api public
         # @example
         #   type = Carbon::Type("A.+(A, B)")
-        #   func = type.name.function
+        #   func = type.function
         #   func.name # => "+"
         # @return [::String] The name of the function.
         attr_reader :name
@@ -38,23 +37,35 @@ module Carbon
         # @api public
         # @example
         #   type = Carbon::Type("A.+(A, B)")
-        #   func = type.name.function
+        #   func = type.function
         #   func.parameters
-        #     # => [#<Carbon::Concrete::Type::Name A>,
-        #     #   #<Carbon::Concrete::Type::Name B>]
-        # @return [::Array<Type::Name>]
+        #     # => [#<Carbon::Concrete::Type A>,
+        #     #   #<Carbon::Concrete::Type B>]
+        # @return [::Array<Type>]
         attr_reader :parameters
 
+        # The generics used in the function definition.
+        #
+        # @api public
+        # @example
+        #   type = Carbon::Type("A.+<T>(A, T)")
+        #   func = type.function
+        #   func.generics
+        #     # => [#<Carbon::Concrete::Type::Generic T>]
+        # @return [::Array<Type>]
+        attr_reader :generics
+
         # 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.
+        # @param params [::Array<Type>] The parameters of the function.
         #   This is frozen before stored.
-        def initialize(name, params)
-          @name = name
+        def initialize(name, params, generics = [])
+          @name = name.to_s
           @parameters = params
+          @generics = generics
           deep_freeze!
         end
 
@@ -68,7 +79,12 @@ module Carbon
         #   func.to_s # => "+(Test<T>)"
         # @return [::String]
         def to_s
-          "#{@name}(#{@parameters.map(&:to_s).join(', ')})".freeze
+          if @generics.any?
+            "#{@name}<#{@generics.map(&:to_s).join(',')}>" \
+              "(#{@parameters.map(&:to_s).join(', ')})".freeze
+          else
+            "#{@name}(#{@parameters.map(&:to_s).join(', ')})".freeze
+          end
         end
 
         # Returns the interned version of this function.  In contrast to

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

@@ -41,6 +41,13 @@ module Carbon
         # @return [Set<Type>] The traits the generic has to implement.
         attr_reader :implements
 
+        # 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 generic part of the type.
         #
         # @see #name
@@ -48,7 +55,8 @@ module Carbon
         # @param name [Type] The name of the generic.
         # @param implements [Set<Type>] The traits the generic must
         #   implement, if any.
-        def initialize(name, implements)
+        def initialize(name, implements, location: nil)
+          @location = location
           @name = name
           @implements = Set.new(implements)
           deep_freeze!
@@ -67,12 +75,12 @@ module Carbon
         #   other.is_a?(Generic) # => true
         #   result = generic.sub("T" => other)
         #   result.to_s # => "Carbon::String: Carbon::Sized"
-        # @param mapping [{::String => Type::Generic}] The mapping.
+        # @param mapping [{::String => Type}] 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)
+          Generic.new(mapping.fetch(@name, @name), @implements)
         end
 
         # Compares this generic instance to another generic instance.  If the
@@ -112,6 +120,14 @@ module Carbon
             @name.to_s
           end
         end
+
+        # Accepts the current visitor unto itself.
+        #
+        # @param visitor [#visit]
+        # @return [Object]
+        def accept(visitor, *params)
+          visitor.visit(self, *params)
+        end
       end
     end
   end

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

@@ -135,6 +135,7 @@ module Carbon
             | \-
             | \* | \/
             | % | & | \|
+            | \[\]=
             | \[\]
             | \^
           )

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

@@ -36,15 +36,23 @@ module Carbon
         # @return [<Type::Generic>] The generics.
         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 part with the given value and generics.
         #
         # @see #value
         # @see #generics
         # @param value [::String] The value.
         # @param generics [<Type::Generic>] The generics.
-        def initialize(value, generics)
+        def initialize(value, generics, location: nil)
           @value = value
           @generics = generics
+          @location = location
           deep_freeze!
         end
 

data/lib/carbon/core.rb

@@ -40,16 +40,20 @@ module Carbon
     # @api private
     # @return [void]
     def self.finalize
+      @index = Concrete::Index.new
       Core::Integer.define_integer
       Core::Pointer.define_pointer
       index.finalize
     end
 
+    def self.define_main(build, pass)
+      Core::Main.define_main_function(build.module, build.index, pass)
+    end
+
     def self.find
       if PATH.exist?
         Concrete.load(PATH.read)
       else
-        @index = Concrete::Index.new
         finalize.tap { |i| PATH.write(Concrete.dump(i)) }
       end
     end
@@ -57,5 +61,6 @@ module Carbon
     require "carbon/core/int"
     require "carbon/core/integer"
     require "carbon/core/pointer"
+    require "carbon/core/main"
   end
 end

data/lib/carbon/core/integer/misc.rb

@@ -8,6 +8,7 @@ module Carbon
       # functions that don't fit in any of the other category.  These functions
       # include:
       #
+      # - `.null(): self`
       # - `.next(self): self`
       # - `.succ(self): self`
       # - `.abs(self): self`
@@ -18,7 +19,7 @@ module Carbon
       # - `.size(self): Carbon::UInt32`
       #
       # These functions are defined on all of the integer types except boolean.
-      # However, `.size` is also defined on boolean.
+      # However, `.size` and `.null` are also defined on boolean.
       #
       # @api private
       module Misc
@@ -40,6 +41,21 @@ module Carbon
           end
         end
 
+        # Defines the null function.  This defines a function that returns a
+        # null (zero) integer value.
+        #
+        # @param int [Core::Int] The integer type.
+        # @return [void]
+        def define_null_function(int)
+          function_name = int.name.call(:null, [])
+          Core.define(function: function_name) do |function|
+            function[:return] = int.name
+            function[:definition].add("entry").build do |b|
+              b.ret(b._null(int.name).as(int.name))
+            end
+          end
+        end
+
         # Define the next functions for the given integer type.  These
         # functions just return the given number incremented by one.  This is
         # implemented without any calls.  This function defines both the

data/lib/carbon/core/integer/ship.rb

@@ -61,11 +61,15 @@ module Carbon
 
         def define_ship_definition_compare(params, blocks)
           blocks[0]
-            .build { |b| b.br(b.icmp(:lt, *params).as(Carbon::Boolean),
-              blocks[1], blocks[2]) }
+            .build do |b|
+              b.br(b.icmp(:lt, *params).as(Carbon::Boolean),
+                blocks[1], blocks[2])
+            end
           blocks[2]
-            .build { |b| b.br(b.icmp(:eq, *params).as(Carbon::Boolean),
-              blocks[3], blocks[4]) }
+            .build do |b|
+              b.br(b.icmp(:eq, *params).as(Carbon::Boolean),
+                blocks[3], blocks[4])
+            end
         end
       end
     end

data/lib/carbon/core/main.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Core
+    module Main
+      class << self
+        def define_main_function(mod, index, pass)
+          main_params = [LLVM::Int32.type, LLVM::Int8.type.pointer.pointer]
+          main = mod.functions.add("main", main_params, LLVM::Int32.type)
+          define_main_definition(mod, main, index, pass)
+        end
+
+      private
+
+        def define_main_definition(mod, func, index, pass)
+          if pass.function.parameters.size == 2
+            define_main_definition_params(mod, func, index, pass)
+          else
+            define_main_definition_noparams(mod, func, index, pass)
+          end
+        end
+
+        def define_main_definition_params(mod, func, index, pass)
+          argc, argv = func.params
+          argc.name, argv.name = "argc", "argv"
+          func.basic_blocks.append("entry").build do |b|
+            if index.fetch(pass).first.return != Carbon::Void
+              b.ret(b.call(mod.functions[pass.to_s], argc, argv))
+            else
+              b.call(mod.function[pass.to_s], argc, argv)
+              b.ret(LLVM::Int(0))
+            end
+          end
+        end
+
+        def define_main_definition_noparams(mod, func, index, pass)
+          func.basic_blocks.append("entry").build do |b|
+            if index.fetch(pass).first.return != Carbon::Void
+              b.ret(b.call(mod.functions[pass.to_s]))
+            else
+              b.call(mod.function[pass.to_s])
+              b.ret(LLVM::Int(0))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/core/pointer/access.rb

@@ -84,7 +84,7 @@ module Carbon
 
       private
 
-        def define_array_set_definition(int, definition)
+        def define_array_set_definition(_int, definition)
           entry = definition.add("entry").build
           this, index, value = definition.params
           this.name, index.name, value.name = %w(self index value)

data/lib/carbon/core/pointer/math.rb

@@ -51,6 +51,15 @@ module Carbon
 
           COMP_OPERATIONS.each { |op| define_comp_pointer_function(op) }
           define_space_pointer_function
+          define_null_function
+        end
+
+        def define_null_function
+          function_name = PTYPE.call(:null, [])
+          Core.define(function: function_name) do |function|
+            function[:return] = PTYPE
+            define_null_definition(function[:definition])
+          end
         end
 
         # Defines the `<=>` function for two pointers.  This returns `-1`,
@@ -183,6 +192,11 @@ module Carbon
 
           entry.ret(entry.gep(this, other).as(PTYPE))
         end
+
+        def define_null_definition(definition)
+          entry = definition.add("entry").build
+          entry.ret(entry.null(PTYPE).as(PTYPE))
+        end
       end
     end
   end

data/lib/carbon/core/pointer/memory.rb

@@ -60,10 +60,8 @@ module Carbon
           size = definition.params[0]
           size.name = "size"
 
-          element = entry.sizeof(PTYPEGEN).as(Carbon::Type("Carbon::UInt64"))
           size = convert_int_size(int, size, entry)
-          total = entry.mul(element, size).as(size.type)
-          entry.ret(entry.malloc(total).as(PTYPE))
+          entry.ret(entry.array_malloc(PTYPEGEN, size).as(PTYPE))
         end
 
         def define_free_definition(definition)
@@ -75,7 +73,7 @@ module Carbon
         end
 
         def convert_int_size(int, value, entry)
-          size = Int.find(sign: :unsigned, size: 64)
+          size = Int.find(sign: :unsigned, size: 32)
           name = int.name.call(size.cast, [int.name])
           entry.call(name, value).as(size.name)
         end

data/lib/carbon/core/void.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Core
+    module Void
+      class << self
+        def define_void
+          define_void_type
+        end
+
+        def define_void_type
+          Core.define(internal: Carbon::Void) do |internal|
+            internal[:kind] = :void
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/counter.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  # A mutable counter for giving out incremental ids.
+  #
+  # @api private
+  class Counter
+    # The value.
+    # @return [::Numeric]
+    attr_reader :value
+
+    # Initialize the counter.
+    #
+    # @param value [::Numeric] The initial value of the counter.
+    def initialize(value = 0)
+      @value = value
+    end
+
+    # Increments the counter by one, and returns the new value.
+    #
+    # @return [::Numeric]
+    def increment
+      @value += 1
+    end
+  end
+end

data/lib/carbon/errors.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  class Error < StandardError
+  end
+
+  class TooManyItemsError < Error
+  end
+
+  class ItemNotFoundError < Error
+  end
+end