carbon-compiler 0.2.0

data/lib/carbon/compiler/visitor/generation.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require "carbon/compiler/visitor/generation/context"
+
+module Carbon
+  module Compiler
+    module Visitor
+      class Generation
+        include Base
+
+        require "carbon/compiler/visitor/generation/asserts"
+        require "carbon/compiler/visitor/generation/expressions"
+        require "carbon/compiler/visitor/generation/function"
+        require "carbon/compiler/visitor/generation/statements"
+        require "carbon/compiler/visitor/generation/struct"
+
+        include Generation::Asserts
+        include Generation::Expressions
+        include Generation::Function
+        include Generation::Statements
+        include Generation::Struct
+
+        def initialize(file, index)
+          @index = index
+          @file = file
+          @name = @file.module
+        end
+
+        def call(node)
+          accept(node)
+        end
+
+        on Node::Root => :visit_root
+        def visit_root(node)
+          node.each { |c| accept(c) }
+        end
+
+        on Node::Definition::Directive => :visit_directive
+        def visit_directive(node)
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/visitor/generation/asserts.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    module Visitor
+      class Generation
+        module Asserts
+          def assert_type_equal(found, expected, location: Location.default)
+            return unless found != expected
+            @file.emit("Expression/Type/Mismatch", location, [found, expected])
+          end
+
+          def assert_type_void(found, location: Location.default)
+            assert_type_equal(found, Carbon::Void, location: location)
+          end
+
+          def assert_type_boolean(found, location: Location.default)
+            assert_type_equal(found, Carbon::Boolean, location: location)
+          end
+
+          def assert_nolocal(name, context, location: Location.default)
+            return unless context.key?(name)
+            @file.emit("Statement/Let/Redefine", location, [name])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/visitor/generation/class.rb

@@ -0,0 +1,93 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    module Visitor
+      class Generation
+        module Class
+          Generation.on Node::Definition::Class => :visit_class
+          def visit_class(node)
+            @index.define(class: @name) do |cl|
+              cl[:elements] = node.each
+            end
+
+            class_accessors(node)
+            class_allocate(node)
+          end
+
+        private
+
+          def class_allocate(node)
+            fname = @name.call("allocate", [])
+            @index.define(function: fname) do |function|
+              function[:return] = @name
+              class_allocate_definition(function[:definition])
+            end
+          end
+
+          def class_accessors(node)
+            node.each_with_index do |element, index|
+              class_read_accessor(element, index, node)
+              class_write_accessor(element, index, node)
+            end
+          end
+
+          def class_read_accessor(element, index, node)
+            fname = @name.call(element.name.value, [@name])
+            @index.define(function: fname) do |function|
+              function[:return] = element.type
+              class_read_accessor_definition(function[:definition], element,
+                index)
+            end
+
+            fname = @name.call("@#{element.name.value}", [@name])
+            @index.define(function: fname) do |function|
+              function[:return] = element.type
+              class_read_accessor_definition(function[:definition], element,
+                index)
+            end
+          end
+
+          def class_write_accessor(element, index, node)
+            fname = @name.call("#{element.name.value}=", [@name, element.type])
+            @index.define(function: fname) do |function|
+              function[:return] = element.type
+              class_write_accessor_definition(function[:definition], element,
+                index)
+            end
+
+            fname = @name.call("@#{element.name.value}=", [@name, element.type])
+            @index.define(function: fname) do |function|
+              function[:return] = element.type
+              class_write_accessor_definition(function[:definition], element,
+                index)
+            end
+          end
+
+          def class_read_accessor_definition(definition, element, index)
+            entry = definition.add("entry").build
+            this = definition.params[0]
+            this.name = "self"
+            gep = entry.class_gep(this, index).as(this.type)
+            entry.ret(entry.load(gep).as(element.type))
+          end
+
+          def class_write_accessor_definition(definition, element, index)
+            entry = definition.add("entry").build
+            this, value = definition.params
+            this.name, value.name = %w(self value)
+            gep = entry.class_gep(this, index).as(this.type)
+            entry.store(value, gep)
+            entry.ret(value)
+          end
+
+          def class_allocate_definition(definition)
+            entry = definition.add("entry").build
+            entry.ret(entry.malloc(entry.deref(@name).as(@name)).as(@name))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/visitor/generation/context.rb

@@ -0,0 +1,75 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    module Visitor
+      class Generation
+        # Context for building function bodies.
+        class Context
+          attr_reader :index
+          attr_reader :function
+
+          def initialize(definition, index, function)
+            @locals = []
+            @definition = definition
+            @index = index
+            @function = function
+          end
+
+          def block
+            @block ||= @definition.add("entry")
+          end
+
+          def new(name = "")
+            @definition.add(name)
+          end
+
+          def build(*p)
+            return block.build(*p) unless block_given?
+            result = nil
+            block.build(*p) { |*a| result = yield(*a) }
+            result
+          end
+
+          def swap(other)
+            old, @block = @block, other
+            old
+          end
+
+          def find(name)
+            index.fetch(name)
+          end
+
+          def key?(name)
+            current.key?(name)
+          end
+
+          def [](name)
+            current[name]
+          end
+
+          def []=(name, value)
+            top[name] = value
+          end
+
+          def current
+            @locals.inject({}, :merge)
+          end
+
+          def push
+            @locals << {}
+          end
+
+          def pop
+            @locals.pop
+          end
+
+          def top
+            @locals.last
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/visitor/generation/expressions.rb

@@ -0,0 +1,82 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require "carbon/compiler/visitor/generation/expressions/assignment"
+require "carbon/compiler/visitor/generation/expressions/calls"
+
+module Carbon
+  module Compiler
+    module Visitor
+      class Generation
+        module Expressions
+          include Generation::Expressions::Assignment
+          include Generation::Expressions::Calls
+
+          Generation.on Node::Expression::Literal => :visit_expression_literal
+          def visit_expression_literal(node, context)
+            Tacky::Typed.new(node.value, node.type)
+          end
+
+          # TODO: implement short circuitry
+          Generation.on Node::Expression::Operation::And =>
+            :visit_expression_operation_and
+          def visit_expression_operation_and(node, context)
+            context.build do |b|
+              left = accept(node.left, context)
+              assert_type_boolean(left.type, location: node.left.location)
+              lchk = b.icmp(:ne, left, 0).as(Carbon::Boolean)
+              right = accept(node.right, context)
+              assert_type_boolean(right.type, location: node.right.location)
+              rchk = b.icmp(:ne, right, 0).as(Carbon::Boolean)
+              b.and(lchk, rchk).as(Carbon::Boolean)
+            end
+          end
+
+          Generation.on Node::Expression::Operation::Or =>
+            :visit_expression_operation_or
+          def visit_expression_operation_or(node, context)
+            context.build do |b|
+              left = accept(node.left, context)
+              assert_type_boolean(left.type, location: node.left.location)
+              lchk = b.icmp(:ne, left, 0).as(Carbon::Boolean)
+              right = accept(node.right, context)
+              assert_type_boolean(left.right, location: node.right.location)
+              rchk = b.icmp(:ne, right, 0).as(Carbon::Boolean)
+              b.or(lchk, rchk).as(Carbon::Boolean)
+            end
+          end
+
+          Generation.on Node::Expression::Operation::Neq =>
+            :visit_expression_operation_neq
+          def visit_expression_operation_neq(node, context)
+            context.build do |b|
+              left = accept(node.left, context)
+              right = accept(node.right, context)
+              name = left.type.call(:==, [left.type, right.type])
+              result = b.call(name, left, right).as(Carbon::Boolean)
+              context.type(b.xor(result, 1), Carbon::Boolean)
+            end
+          end
+
+          Generation.on Node::Expression::Operation::Normal =>
+            :visit_expression_operation_normal
+          def visit_expression_operation_normal(node, context)
+            context.build do |b|
+              left = accept(node.left, context)
+              right = accept(node.right, context)
+              name = left.type.call(node.op.value, [left.type, right.type])
+              type = context.find(name).return
+              b.call(name, left, right).as(type)
+            end
+          end
+
+          Generation.on Node::Name => :visit_name
+          def visit_name(node, context)
+            value = context.current.fetch(node.value)
+            context.build.load(value).as(value.type)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/visitor/generation/expressions/assignment.rb

@@ -0,0 +1,105 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    module Visitor
+      class Generation
+        module Expressions
+          module Assignment
+            Generation.on Node::Expression::Assignment =>
+              :visit_expression_assignment
+            def visit_expression_assignment(node, context)
+              case node.left
+              when Node::Expression::Call::Access
+                assign_access(node, context)
+              when Node::Expression::Call::Attribute
+                assign_attribute(node, context)
+              when Node::Name
+                assign_name(node, context)
+              else fail # not possible
+              end
+            end
+
+          private
+
+            def assign_access(node, context)
+              access = node.left
+              base = accept(access.expression, context)
+              params = [*access.parameters, node.right]
+                .map { |p| accept(p, context) }
+              ptypes = params.map(&:type)
+              name = base.type.call("[]=", [base.type, *ptypes],
+                access.generics)
+              func, gens = context.find(name)
+              context.build.call(name, base, *params).as(func.return.sub(gens))
+            end
+
+            def assign_attribute(node, context)
+              attribute = node.left
+              base = accept(attribute.expression, context)
+              bitem = context.index.fetch(base.type).first
+
+              if bitem.is_a?(Carbon::Concrete::Item::Struct) &&
+                attribute.expression.is_a?(Node::Name)
+                assign_attribute_struct(attribute, base, node, context)
+              else
+                assign_attribute_other(attribute, base, node, context)
+              end
+            end
+
+            def assign_attribute_struct(attribute, base, node, context)
+              params = [accept(node.right, context)]
+              ptypes = params.map(&:type)
+              name = base.type.call("#{attribute.name.value}=",
+                [base.type.to_pointer, *ptypes], attribute.generics)
+              func, gens = context.find(name) do
+                return assign_attribute_other(attribute, base, node, context)
+              end
+
+              address = context.current.fetch(attribute.expression.value)
+              context.build do |b|
+                b.call(name, address, *params).as(func.return.sub(gens))
+              end
+            end
+
+            def assign_attribute_other(attribute, base, node, context)
+              params = [accept(node.right, context)]
+              ptypes = params.map(&:type)
+              name = base.type.call("#{attribute.name.value}=",
+                [base.type, *ptypes], attribute.generics)
+              func, gens = context.find(name)
+              context.build.call(name, base, *params).as(func.return.sub(gens))
+            end
+
+            def assign_name(node, context)
+              if context.current.key?(node.left.value)
+                assign_local(node, context)
+              else
+                assign_function(node, context)
+              end
+            end
+
+            def assign_function(node, context)
+              value = accept(node.right, context)
+              name = @name.call(node.left.value, [@name, value.type])
+              thisp = context.current.fetch("self")
+              this = context.build.load(thisp).as(@name)
+              func, gens = context.find(name)
+              context.build.call(name, this, value).as(func.return.sub(gens))
+            end
+
+            def assign_local(node, context)
+              local = context.current.fetch(node.left.value)
+              value = accept(node.right, context)
+              assert_type_equal(value.type, local.type,
+                location: node.right.location)
+              context.build.store(value, local)
+              context.build.load(local).as(local.type)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/visitor/generation/expressions/calls.rb

@@ -0,0 +1,89 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    module Visitor
+      class Generation
+        module Expressions
+          module Calls
+            Generation.on Node::Expression::Call::Access =>
+              :visit_expression_call_access
+            def visit_expression_call_access(node, context)
+              base = accept(node.expression, context)
+              params = node.parameters.map { |p| accept(p, context) }
+              ptypes = params.map(&:type)
+              name = base.type.call(:[], [base.type, *ptypes],
+                node.generics || [])
+              func, gens = context.find(name)
+              context.build.call(name, base, *params)
+                .as(func.return.sub(gens))
+            end
+
+            Generation.on Node::Expression::Call::Attribute =>
+              :visit_expression_call_attribute
+            def visit_expression_call_attribute(node, context)
+              base = accept(node.expression, context)
+              name = base.type.call(node.name.value, [base.type],
+                node.generics || [])
+              func, gens = context.find(name)
+              context.build.call(name, base).as(func.return.sub(gens))
+            end
+
+            Generation.on Node::Expression::Call::Enum =>
+              :visit_expression_call_enum
+            def visit_expression_call_enum(node, context)
+              base = node.module
+              params = node.parameters.map { |p| accept(p, context) }
+              generics = node.generics.map { |p| accept(p, context) }
+              ptypes = params.map(&:type)
+              name = base.call(node.name.value, ptypes, node.generics || [])
+              func, gens = context.find(name)
+              context.build.call(name, *params).as(func.return.sub(gens))
+            end
+
+            Generation.on Node::Expression::Call::Module =>
+              :visit_expression_call_module
+            def visit_expression_call_module(node, context)
+              base = node.module
+              params = node.parameters.map { |p| accept(p, context) }
+              ptypes = params.map(&:type)
+              name = base.call(node.name.value, ptypes, node.generics || [])
+              func, gens = context.find(name)
+              context.build.call(name, *params).as(func.return.sub(gens))
+            end
+
+            Generation.on Node::Expression::Call::Self =>
+              :visit_expression_call_self
+            def visit_expression_call_self(node, context)
+              base = @name
+              params = node.parameters.map { |p| accept(p, context) }
+              ptypes = params.map(&:type)
+              name = base.call(node.name.value, [base, *ptypes],
+                node.generics || [])
+              func, gens = context.find(name)
+              thisp = context.current.fetch("self")
+              this = context.build.load(thisp).as(base)
+              context.build.call(name, this, *params)
+                .as(func.return.sub(gens))
+            end
+
+            Generation.on Node::Expression::Call::Unified =>
+              :visit_expression_call_unified
+            def visit_expression_call_unified(node, context)
+              base = accept(node.expression, context)
+              params = node.parameters.map { |p| accept(p, context) }
+              generics = node.generics.map { |p| accept(p, context) }
+              ptypes = params.map(&:type)
+              name = base.type.call(node.name.value, [base.type, *ptypes],
+                node.generics || [])
+              func, gens = context.find(name)
+              context.build.call(name, base, *params)
+                .as(func.return.sub(gens))
+            end
+          end
+        end
+      end
+    end
+  end
+end