carbon-core 0.1.0 → 0.1.1

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

@@ -35,7 +35,7 @@ module Carbon
             function[:definition].add("entry").build do |b|
               this = function[:definition].params[0]
               this.name = "self"
-              b.ret(b.icmp(:ne, this, 0))
+              b.ret(b.icmp(:ne, this, 0).as(Carbon::Boolean))
             end
           end
         end
@@ -110,7 +110,7 @@ module Carbon
           this = definition.params[0]
           this.name = "self"
 
-          entry.ret(entry.add(this, 1))
+          entry.ret(entry.add(this, 1).as(this.type))
         end
 
         def define_prev_definition(definition)
@@ -118,7 +118,7 @@ module Carbon
           this = definition.params[0]
           this.name = "self"
 
-          entry.ret(entry.sub(this, 1))
+          entry.ret(entry.sub(this, 1).as(this.type))
         end
 
         def define_iabs_definition(int, definition)
@@ -129,8 +129,9 @@ module Carbon
           if int.sign == :unsigned
             entry.ret(this)
           else
-            y = entry.ashr(this, int.size - 1)
-            entry.ret(entry.sub(entry.xor(this, y), y))
+            y = entry.ashr(this, int.size - 1).as(this.type)
+            sub = entry.sub(entry.xor(this, y).as(this.type), y).as(this.type)
+            entry.ret(sub)
           end
         end
 

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

@@ -95,8 +95,8 @@ module Carbon
           this.name = "self"
 
           return entry.ret(1) if int.sign == :unsigned
-          sign = entry.lshr(this, int.size - 1)
-          trunc = entry.trunc(sign, Carbon::Boolean)
+          sign = entry.lshr(this, int.size - 1).as(this.type)
+          trunc = entry.trunc(sign, Carbon::Boolean).as(Carbon::Boolean)
           entry.ret(trunc)
         end
 
@@ -106,9 +106,9 @@ module Carbon
           this.name = "self"
 
           return entry.ret(0) if int.sign == :unsigned
-          sign = entry.lshr(this, int.size - 1)
-          trunc = entry.trunc(sign, Carbon::Boolean)
-          negate = entry.xor(trunc, 1)
+          sign = entry.lshr(this, int.size - 1).as(this.type)
+          trunc = entry.trunc(sign, Carbon::Boolean).as(Carbon::Boolean)
+          negate = entry.xor(trunc, 1).as(Carbon::Boolean)
           entry.ret(negate)
         end
 
@@ -117,7 +117,9 @@ module Carbon
           this = definition.params[0]
           this.name = "self"
 
-          entry.ret(entry.xor(entry.trunc(this, Carbon::Boolean), 1))
+          trunc = entry.trunc(this, Carbon::Boolean).as(Carbon::Boolean)
+          xor = entry.xor(trunc, 1).as(Carbon::Boolean)
+          entry.ret(xor)
         end
 
         def define_odd_definition(_int, definition)
@@ -125,7 +127,7 @@ module Carbon
           this = definition.params[0]
           this.name = "self"
 
-          entry.ret(entry.trunc(this, Carbon::Boolean))
+          entry.ret(entry.trunc(this, Carbon::Boolean).as(Carbon::Boolean))
         end
       end
     end

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

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

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

@@ -25,7 +25,7 @@ module Carbon
             function[:definition].add("entry").build do |b|
               this = function[:definition].params[0]
               this.name = "self"
-              b.ret(b.icmp(:eq, this, 0))
+              b.ret(b.icmp(:eq, this, 0).as(Carbon::Boolean))
             end
           end
         end
@@ -42,7 +42,7 @@ module Carbon
             function[:definition].add("entry").build do |b|
               this = function[:definition].params[0]
               this.name = "self"
-              b.ret(b.icmp(:ne, this, 0))
+              b.ret(b.icmp(:ne, this, 0).as(Carbon::Boolean))
             end
           end
         end

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

@@ -84,12 +84,13 @@ 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)
 
-          entry.store(entry.gep(this, index), value)
+          gep = entry.gep(this, index).as(Carbon::Type("Carbon::UInt64"))
+          entry.store(gep, value)
           entry.ret(value)
         end
 
@@ -98,7 +99,9 @@ module Carbon
           this, index = definition.params
           this.name, index.name = %w(self index)
 
-          entry.ret(entry.load(entry.gep(this, index)))
+          gep = entry.gep(this, index).as(Carbon::Type("Carbon::UInt64"))
+          load = entry.load(gep).as(PTYPEGEN)
+          entry.ret(load)
         end
 
         def define_value_set_definition(definition)
@@ -115,7 +118,7 @@ module Carbon
           this = definition.params[0]
           this.name = "self"
 
-          entry.ret(entry.load(this))
+          entry.ret(entry.load(this).as(PTYPEGEN))
         end
       end
     end

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

@@ -47,7 +47,7 @@ module Carbon
           this = definition.params[0]
           this.name = "self"
 
-          entry.ret(entry.ptr2int(this, int.name))
+          entry.ret(entry.ptr2int(this, int.name).as(int.name))
         end
       end
     end

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

@@ -126,8 +126,8 @@ module Carbon
           this, other = params
           this.name, other.name = %w(self other)
           fname = PTYPE.call(int.cast, [PTYPE])
-          thisint = entry.call(fname, this)
-          otherint = entry.call(fname, other)
+          thisint = entry.call(fname, this).as(int.name)
+          otherint = entry.call(fname, other).as(int.name)
           [thisint, otherint]
         end
 
@@ -138,7 +138,8 @@ module Carbon
           this, other = perform_pointer_cast(entry, params, int)
 
           fname = PTYPE.call(:<=>, [int.name, int.name])
-          entry.ret(entry.call(fname, this, other))
+          call = entry.call(fname, this, other)
+          entry.ret(call.as(Carbon::Type("Carbon::Int8")))
         end
 
         def define_comp_pointer_definition(op, definition)
@@ -148,7 +149,7 @@ module Carbon
           this, other = perform_pointer_cast(entry, params, int)
           icmp = Integer::Math::COMP_OPERATIONS_MAP.fetch([:signed, op])
 
-          entry.ret(entry.icmp(icmp, this, other))
+          entry.ret(entry.icmp(icmp, this, other).as(Carbon::Boolean))
         end
 
         def define_space_definition(int, definition)
@@ -157,9 +158,10 @@ module Carbon
           this.name, other.name = %w(self other)
 
           fname = PTYPE.call(int.cast, [PTYPE])
-          intptr = entry.call(fname, this)
+          intptr = entry.call(fname, this).as(int.name)
           fname = PTYPE.call(:<=>, [int.name, int.name])
-          entry.ret(entry.call(fname, intptr, other))
+          compare = entry.call(fname, intptr, other)
+          entry.ret(compare.as(Carbon::Type("Carbon::Int8")))
         end
 
         def define_comp_definition(int, op, definition)
@@ -168,18 +170,18 @@ module Carbon
           this.name, other.name = %w(self other)
 
           fname = PTYPE.call(int.cast, [PTYPE])
-          intptr = entry.call(fname, this)
+          intptr = entry.call(fname, this).as(int.name)
           icmp = Integer::Math::COMP_OPERATIONS_MAP.fetch([int.sign, op])
-          entry.ret(entry.icmp(icmp, intptr, other))
+          entry.ret(entry.icmp(icmp, intptr, other).as(Carbon::Boolean))
         end
 
         def define_math_definition(_int, op, definition)
           entry = definition.add("entry").build
           this, other = definition.params
           this.name, other.name = %w(self other)
-          other = entry.mul(other, -1) if op == :-
+          other = entry.mul(other, -1).as(other.type) if op == :-
 
-          entry.ret(entry.gep(this, other))
+          entry.ret(entry.gep(this, other).as(PTYPE))
         end
       end
     end

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

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

data/lib/carbon/tacky.rb

@@ -9,6 +9,7 @@ require "carbon/tacky/value"
 require "carbon/tacky/instruction"
 require "carbon/tacky/parameter"
 require "carbon/tacky/reference"
+require "carbon/tacky/typed"
 
 module Carbon
   # Tacky is a IR implementation.  It is a medium-level IR, just above LLVM IR

data/lib/carbon/tacky/builder.rb

@@ -288,6 +288,14 @@ module Carbon
         _call(:_null, type)
       end
 
+      def typeof(value)
+        _call(:_typeof, value)
+      end
+
+      def mcall(mod, name, *params)
+        _call(:_mcall, mod, name, *params)
+      end
+
       # Creates an instruction, and returns a reference to that instruction.
       # The reference points to the instruction using the "instruction id,"
       # which is essentially the instruction's place in the block.
@@ -299,11 +307,15 @@ module Carbon
       # @param name [::String] The return value name of the instruction.
       # @return [Tacky::Reference] The reference to the new instruction.
       def _call(inst, *parameters, name: "")
+        # cut it off at the pass and force all parameters to instructions to
+        # have a type.
         id = @block.next
-        instruction = Tacky::Instruction.new(id, inst, parameters)
+        typed = parameters.map { |p| Tacky::Typed.from(p) }
+        reference = Tacky::Reference.new(id)
+        instruction = Tacky::Instruction.new(id, inst, parameters, reference)
         instruction.name = name
         @block.instructions << instruction
-        Tacky::Reference.new(id)
+        reference
       end
     end
   end

data/lib/carbon/tacky/context.rb

@@ -49,11 +49,18 @@ module Carbon
       attr_reader :functions
       def_delegator :@build, :functions
 
+      # Returns the function that this is being built for.
+      #
+      # @return [Tacky::Function]
+      attr_reader :function
+
       # Initialize the context.
       #
+      # @param function [Tacky::Function]
       # @param build [Concrete::Build]
       # @param generics [{::String => Concrete::Type}]
-      def initialize(build, generics)
+      def initialize(function, build, generics)
+        @function = function
         @build = build
         @generics = generics
         @instructions = []
@@ -61,6 +68,10 @@ module Carbon
         @params = []
         freeze
       end
+
+      def find(name)
+        name.function? ? functions.fetch(name).last : types.fetch(name).last
+      end
     end
   end
 end

data/lib/carbon/tacky/function.rb

@@ -105,7 +105,7 @@ module Carbon
       #   being applied to the function.
       # @return [void]
       def call(function, build, generics)
-        context = Context.new(build, generics)
+        context = Context.new(self, build, generics)
         mark_function_params(context, function)
 
         @blocks.each do |block|

data/lib/carbon/tacky/instruction.rb

@@ -1,11 +1,16 @@
 # encoding: utf-8
 # frozen_string_literal: true
+#
+require "carbon/tacky/instruction/generation"
+require "carbon/tacky/instruction/typeof"
 
 module Carbon
   module Tacky
     # An instruction.  This is the building block of the rest of the Tacky
     # structures.  Each instruction performs some sort of action.
     class Instruction < Value
+      include Instruction::Generation
+      include Instruction::Typeof
       # Instructions that can be represented by this class that can have a
       # name parameter.
       #
@@ -40,10 +45,11 @@ module Carbon
       # @param name [::Symbol, ::String] The name of the instruction.
       # @param parameters [<Reference, Parameter, Value, ::Object>] The
       #   parameters to be used with the instruction.
-      def initialize(id, name, parameters)
+      def initialize(id, name, parameters, reference)
         @value = id
         @instruction = name.to_s
         @parameters = parameters
+        @reference = reference
       end
 
       # Builds the instruction.  If the instruction is special, i.e. it starts
@@ -60,7 +66,9 @@ module Carbon
       def call(context, block)
         case @instruction
         when "_null"   then generate_null(context, block)
+        when "_mcall"  then generate_mcall(context, block)
         when "_sizeof" then generate_sizeof(context, block)
+        when "_typeof" then generate_typeof(context, block)
         else generate_normal(context, block)
         end
       end
@@ -112,59 +120,6 @@ module Carbon
 
         name
       end
-
-    private
-
-      # Generates a "normal" instruction.  It maps the parameters, then sends
-      # the instruction over to a builder for LLVM, before returning the
-      # result of the instruction.
-      #
-      # @param context [Tacky::Context] The context.
-      # @param block [::LLVM::BasicBlock] The block.
-      # @return [::LLVM::Value] The result of the llvm instruction.
-      def generate_normal(context, block)
-        params = mapped_parameters(context, block)
-        value = nil
-
-        block.build { |b| value = b.public_send(@instruction, *params) }
-        value
-      end
-
-      def generate_null(context, block)
-        params = mapped_parameters(context, block)
-        context.types.fetch(params.first).last.null
-      end
-
-      def generate_sizeof(context, block)
-        params = mapped_parameters(context, block)
-        context.types.fetch(params.first).last.size
-      end
-
-      def mapped_parameters(context, block)
-        @parameters.map { |p| mapped_parameter(p, context, block) }
-      end
-
-      # rubocop:disable Metrics/CyclomaticComplexity
-      def mapped_parameter(param, context, _block)
-        case param
-        when Concrete::Type   then map_parameter_type(param, context)
-        when Tacky::Reference then context.instructions.fetch(param.id)
-        when Tacky::Parameter then context.params.fetch(param.value)
-        when ::Integer then LLVM.Int(param)
-        when ::Float then LLVM.Float(param)
-        when ::String then param
-        else fail ArgumentError, "Unexpected parameter #{param.class}"
-        end
-      end
-      # rubocop:enable Metrics/CyclomaticComplexity
-
-      def map_parameter_type(param, context)
-        if param.function?
-          context.functions.fetch(param)
-        else
-          context.types.fetch(param).last
-        end
-      end
     end
   end
 end

data/lib/carbon/tacky/instruction/dependencies.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Tacky
+    class Instruction < Value
+      module Dependencies
+        def dependencies
+          case @instruction
+          when "_mcall"  then dependencies_mcall
+          when "_ucall"  then dependencies_ucall
+          when "_typeof" then dependencies_typeof
+          else dependencies_normal
+          end
+        end
+
+      private
+
+        def dependencies_mcall
+          deps = Set.new
+          mod = @parameters[0]
+          types = @parameters[2..-1].map { }
+          @function = mod.call(@parameters[1])
+          deps << @parameters[0]
+        end
+
+        def dependencies_normal
+          @parameters.select { |p| p.is_a?(Concrete::Type) }.inject(Set.new, :<<)
+        end
+      end
+    end
+  end
+end