carbon-compiler 0.2.0

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

@@ -0,0 +1,68 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    module Visitor
+      class Generation
+        # Building functions and function bodies.
+        module Function
+          Generation.on Node::Definition::Function => :visit_function
+          def visit_function(node)
+            params = node.parameters.map { |p| function_parameter_type(p) }
+            full = @name.call(node.name, params, node.generics)
+
+            @index.define(function: full) do |function|
+              function[:return] = node.type
+              function_definition(function, node)
+            end
+          end
+
+          Generation.on Node::Definition::Function::Body =>
+            :visit_function_body
+          def visit_function_body(node, context)
+            context.push
+            node.children.each { |c| accept(c, context) }
+            context.pop
+          end
+
+        private
+
+          def function_definition(function, node)
+            return unless node.body
+            function_definition_intern(function, node)
+          end
+
+          def function_definition_intern(function, node)
+            function[:definition] = proc do |index|
+              definition = Tacky::Function.new(function[:parameters])
+              context = Context.new(definition, index, node).tap(&:push)
+              function_definition_intern_parameters(definition, node,
+                context)
+              accept(node.body, context)
+              definition
+            end
+          end
+
+          def function_definition_intern_parameters(defn, node, context)
+            defn.params.each_with_index do |param, i|
+              fparam = node.parameters[i]
+              next if fparam.name.value == "_"
+              param.name = "#{fparam.name.value}.p"
+              context.build do |b|
+                value = b.alloca(fparam.type).as(fparam.type)
+                context[fparam] = value
+                b.set(param, context[fparam])
+              end
+            end
+          end
+
+          def function_parameter_type(param)
+            return @name if param.name.value.to_s == "self"
+            param.type
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,131 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    module Visitor
+      class Generation
+        # Statement generation.
+        module Statements
+          Generation.on Node::Statement::Return => :visit_statement_return
+          def visit_statement_return(node, context)
+            if node.value
+              value = accept(node.value, context)
+              assert_type_equal(value.type, context.function.type,
+                location: node.location)
+              context.build { |b| b.ret(value) }
+            else
+              assert_type_equal(Carbon::Void, context.function.type,
+                location: node.location)
+              context.build(&:ret_void)
+            end
+          end
+
+          Generation.on Node::Statement::Let => :visit_statement_let
+          def visit_statement_let(node, context)
+            name = node.name.value
+            value = accept(node.value, context) if node.value
+            assert_type_equal(value.type, node.type,
+              location: node.value.location) if node.value
+            assert_nolocal(name, context)
+
+            context.build do |b|
+              context[name] = b.alloca(node.type).as(node.type)
+              value = value || b.null(node.type).as(node.type)
+              b.store(value, context[name])
+            end
+          end
+
+          Generation.on Node::Statement::While => :visit_statement_while
+          def visit_statement_while(node, context)
+            loop, merge = context.new("while-loop"), context.new("while-merge")
+
+            cond = accept(node.condition, context)
+            assert_type_boolean(cond.type, location: node.condition.location)
+            check = context.build.icmp(:ne, cond, 0)
+
+            context.build.cond(check, loop, merge)
+            context.swap(loop)
+            accept(node.body, context)
+            cond = accept(node.condition, context)
+            check = context.build.icmp(:ne, cond, 0)
+            context.build.cond(check, loop, merge)
+            context.swap(merge)
+          end
+
+          Generation.on Node::Statement::For => :visit_statement_for
+          def visit_statement_for(node, context)
+            loop, merge = context.new("for-loop"), context.new("for-merge")
+
+            accept(node.initial, context)
+            cond = accept(node.condition, context)
+            assert_type_boolean(cond.type, location: node.condition.location)
+            check = context.build.icmp(:ne, cond, 0)
+
+            context.build.cond(check, loop, merge)
+            context.swap(loop)
+            accept(node.body, context)
+            accept(node.increment, context)
+            cond = accept(node.condition, context)
+            check = context.build.icmp(:ne, cond, 0)
+            context.build.cond(check, loop, merge)
+            context.swap(merge)
+          end
+
+          Generation.on Node::Statement::If => :visit_statement_if
+          def visit_statement_if(node, context)
+            cond = accept(node.condition, context)
+            assert_type_boolean(cond.type, location: node.condition.location)
+            check = context.build.icmp(:ne, cond, 0)
+
+            iftrue, iffalse, ifmerge = context.new("if-true"),
+              context.new("if-false"), context.new("if-merge")
+
+            context.build.cond(check, iftrue, iffalse)
+            context.swap(iftrue)
+            accept(node.body, context)
+            context.build.br(ifmerge)
+            context.swap(iffalse)
+            statement_if_false_merge(node, context, merge)
+            context.swap(ifmerge)
+          end
+
+          Generation.on Node::Statement::ElsIf => :visit_statement_elsif
+          def visit_statement_elsif(node, context, merge)
+            cond = accept(node.condition)
+            assert_type_boolean(cond.type, location: node.condition.location)
+            check = context.build.icmp(:ne, cond, 0)
+
+            ifetrue = context.new("if-else-true")
+            ifefalse = context.new("if-else-false")
+
+            context.build.cond(check, ifetrue, ifefalse)
+            context.swap(ifetrue)
+            accept(node.body, context)
+            context.build.br(merge)
+            context.swap(ifefalse)
+            statement_if_false_merge(node, context, merge)
+            context.swap(merge)
+          end
+
+          Generation.on Node::Statement::Else => :visit_statement_else
+          def visit_statement_else(node, context, merge)
+            accept(node.body, context)
+            context.build.br(merge)
+            context.swap(merge)
+          end
+
+        private
+
+          def statement_if_false_merge(node, context, merge)
+            if node.follow
+              accept(node.follow, context, merge)
+            else
+              context.build.br(merge)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    module Visitor
+      class Generation
+        module Struct
+          Generation.on Node::Definition::Struct => :visit_struct
+          def visit_struct(node)
+            @index.define(struct: @name) do |struct|
+              struct[:elements] = node.each
+            end
+
+            struct_accessors(node)
+            struct_allocate(node)
+          end
+
+        private
+
+          def struct_allocate(node)
+            fname = @name.call(:allocate, node.map(&:type))
+            @index.define(function: fname) do |function|
+              function[:return] = @name
+              struct_allocate_params_definition(node, function[:definition])
+            end
+
+            fname = @name.call(:allocate, [])
+            @index.define(function: fname) do |function|
+              function[:return] = @name
+              struct_allocate_null_definition(node, function[:definition])
+            end
+          end
+
+          def struct_accessors(node)
+            node.each_with_index do |element, index|
+              struct_read_accessor(element, index, node)
+              struct_write_accessor(element, index, node)
+            end
+          end
+
+          def struct_read_accessor(element, index, node)
+            fname = @name.call(element.name.value, [@name])
+            @index.define(function: fname) do |function|
+              function[:return] = element.type
+              struct_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
+              struct_read_accessor_definition(function[:definition], element,
+                index)
+            end
+          end
+
+          def struct_write_accessor(element, index, node)
+            pname = @name.to_pointer
+            fname = @name.call("#{element.name.value}=", [pname, element.type])
+            @index.define(function: fname) do |function|
+              function[:return] = element.type
+              struct_write_accessor_definition(function[:definition], element,
+                index)
+            end
+
+            fname = @name.call("@#{element.name.value}=", [pname, element.type])
+            @index.define(function: fname) do |function|
+              function[:return] = element.type
+              struct_write_accessor_definition(function[:definition], element,
+                index)
+            end
+          end
+
+          def struct_read_accessor_definition(definition, element, index)
+            entry = definition.add("entry").build
+            this = definition.params[0]
+            this.name = "self"
+
+            entry.ret(entry.extract_value(this, index).as(element.type))
+          end
+
+          def struct_write_accessor_definition(definition, element, index)
+            entry = definition.add("entry").build
+            this, value = definition.params
+            this.name, value.name = %w(self value)
+
+            gep = entry.struct_gep(this, index).as(this.type)
+            entry.store(value, gep)
+            entry.ret(value)
+          end
+
+          def struct_allocate_params_definition(node, definition)
+            entry = definition.add("entry").build
+            node.each_with_index do |e, i|
+              definition.params[i].name = e.name.value
+            end
+
+            blank = entry.null(@name).as(@name)
+            definition.params.each_with_index do |param, i|
+              entry.insert_value(blank, param, i)
+            end
+
+            entry.ret(blank)
+          end
+
+          def struct_allocate_null_definition(node, definition)
+            entry = definition.add("entry").build
+            entry.ret(entry.null(@name).as(@name))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    module Visitor
+      class Preparation
+        include Base
+
+        require "carbon/compiler/visitor/preparation/expressions"
+        require "carbon/compiler/visitor/preparation/function"
+        require "carbon/compiler/visitor/preparation/statements"
+        require "carbon/compiler/visitor/preparation/struct"
+
+        include Preparation::Expressions
+        include Preparation::Function
+        include Preparation::Statements
+        include Preparation::Struct
+
+        def initialize(file, index)
+          @index = index
+          @file = file
+          @name = @file.module
+          @directives = []
+          @_funcs = {}
+          @context = :normal
+        end
+
+        def call(node)
+          accept(node)
+        end
+
+        Preparation.on Concrete::Type => :visit_type
+        def visit_type(node)
+          node.sub(@file.aliases)
+        end
+
+        Preparation.on Node::Root => :visit_root
+        def visit_root(node)
+          node.map! { |c| accept(c) }
+        end
+
+        Preparation.on Node::Definition::Module => :visit_module
+        def visit_module(node)
+          error_mismatched_name(node) if node.name != @name
+          error_multiple_modules(node) if @_name
+          @_name = node
+          @file.module = @name = node.name
+          node
+        end
+
+        Preparation.on Node::Definition::Directive => :visit_directive
+        def visit_directive(node)
+          directive = Compiler::Directive.new(node, @file, @index)
+          @directives << node if directive.attach?
+          directive.call
+          node
+        end
+
+      private
+
+        def directives_pop
+          directives = @directives.clone
+          @directives.clear
+          directives
+        end
+
+        def error_mismatched_name(node)
+          @file.emit("Module/Definition/MismatchedName", node.location,
+            [@name, node.name])
+        end
+
+        def error_multiple_modules(node)
+          @file.emit("Module/Definition/MultipleNames", node.location)
+          @file.emit("Trace/Location", @_name.location, "previous name here")
+        end
+
+        def error_multiple_data(node)
+          @file.emit("Module/Definition/MultipleData", node.location)
+          @file.emit("Trace/Location", @_data.location,
+            "previous data definition here")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    module Visitor
+      class Preparation
+        module Expressions
+          Preparation.on Node::Expression::Assignment => :visit_ignore
+          Preparation.on Node::Expression::Call::Access => :visit_ignore
+          Preparation.on Node::Expression::Call::Attribute => :visit_ignore
+          Preparation.on Node::Expression::Call::Enum => :visit_ignore
+          Preparation.on Node::Expression::Call::Module => :visit_ignore
+          Preparation.on Node::Expression::Call::Self => :visit_ignore
+          Preparation.on Node::Expression::Call::Unified => :visit_ignore
+          Preparation.on Node::Expression::Literal => :visit_ignore
+          Preparation.on Node::Expression::Operation::And => :visit_ignore
+          Preparation.on Node::Expression::Operation::Neq => :visit_ignore
+          Preparation.on Node::Expression::Operation::Normal => :visit_ignore
+          Preparation.on Node::Expression::Operation::Or => :visit_ignore
+          Preparation.on Node::Expression::Unit => :visit_ignore
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/visitor/preparation/function.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    module Visitor
+      class Preparation
+        module Function
+          Preparation.on Node::Definition::Function => :visit_function
+          def visit_function(node)
+            params = node.parameters.map { |c| accept(c) }
+            generics = node.generics.map { |c| accept(c) }
+            ptypes = params.map { |c| c.name.value == "self" ? @name : c.type }
+            name = @name.call(node.name, ptypes, generics)
+            error_function_duplicate(node, name) if @_funcs.key?(name)
+            @_funcs[name] = node
+            fname = node._name.merge(generics: generics)
+            body = accept(node.body)
+            node.merge(parameters: params, _name: fname, body: body)
+          end
+
+          Preparation.on Node::Definition::Function::Parameter =>
+            :visit_function_parameter
+          def visit_function_parameter(node)
+            return node if node.name.value == "self"
+            type = accept(node.type)
+            node.merge(type: type)
+          end
+
+          Preparation.on Concrete::Type::Generic => :visit_function_generic
+          def visit_function_generic(node)
+            name = accept(node.name)
+            implements = node.implements.map { |i| accept(i) }
+
+            Concrete::Type::Generic.new(name, implements)
+          end
+
+          Preparation.on Node::Definition::Function::Body =>
+            :visit_function_body
+          def visit_function_body(node)
+            node.map! { |c| accept(c) }
+          end
+
+        private
+
+          def error_function_duplicate(node, name)
+            @file.emit("Function/Duplicate", node.location)
+            @file.emit("Trace/Location", @_funcs[name].location,
+              "previous function location")
+          end
+        end
+      end
+    end
+  end
+end