carbon-compiler 0.2.0

data/lib/carbon/compiler/parser/root/class.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    class Parser
+      module Root
+        # Parses a class.
+        module Class
+        protected
+
+          def parse_class
+            start = expect :class
+            expect :do
+            elements = []
+            elements << parse_class_element until peek?(:end)
+            stop = expect :end
+
+            Node::Definition::Class.new(elements, components: [start, stop])
+          end
+
+          def parse_class_element
+            name = parse_name
+            expect :":"
+            type = parse_type
+            expect :";"
+
+            Node::Definition::Class::Element.new([name, type])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/parser/root/directive.rb

@@ -0,0 +1,87 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    class Parser
+      module Root
+        # Parses a directive.
+        module Directive
+        protected
+
+          def parse_directive
+            expect :":"
+            name = parse_name
+            parameters = []
+            parameters << parse_directive_parameter until peek? :"."
+            expect :"."
+
+            Node::Definition::Directive.new([name, parameters])
+          end
+
+          def parse_directive_parameter
+            case peek.type
+            when :"(" then parse_directive_parameter_function
+            when :do  then parse_function_body
+            when :FLOAT, :STRING, :NUMBER then parse_expression_literal
+            when :MNAME then parse_directive_module_name
+            else parse_name
+            end
+          end
+
+          def parse_directive_parameter_function
+            expect :"("
+            parameters = []
+            until peek? :")"
+              parameters << parse_function_parameter
+              break unless peek? :","
+              expect :","
+            end
+            expect :")"
+
+            Node::Definition::Directive::Function.new(parameters)
+          end
+
+          def parse_directive_module_name
+            base = parse_directive_module_name_part
+            children = [base]
+            while peek? :"::"
+              expect :"::"
+              children << parse_directive_module_name_part
+            end
+
+            Node::EType.new(children)
+          end
+
+          def parse_directive_module_name_part
+            case peek.type
+            when :MNAME then parse_module_name_part
+            when :"{"   then parse_directive_module_name_option
+            when :*     then parse_directive_module_name_star
+            else error [:MNAME, :"{", :*]
+            end
+          end
+
+          def parse_directive_module_name_option
+            l = expect :"{"
+            children = []
+            until peek? :"}"
+              children << parse_directive_module_name
+              break unless peek? :","
+              expect :","
+            end
+            r = expect :"}"
+
+            Node::EType::Option.new(children, components: [l, r])
+          end
+
+          def parse_directive_module_name_star
+            star = expect :*
+
+            Node::EType::Star.new([], components: [star])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/parser/root/enum.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    class Parser
+      module Root
+        # Parses an enum.
+        module Enum
+        protected
+
+          def parse_enum
+            start = expect :enum
+            expect :do
+            elements = []
+            elements << parse_enum_element until peek?(:end)
+            stop = expect :end
+
+            Node::Definition::Enum.new(elements, components: [start, stop])
+          end
+
+          def parse_enum_element
+            name = expect :MNAME
+            value = parse_enum_element_value if peek?(:"(") || peek?(:"=")
+            expect :";"
+
+            Node::Definition::Enum::Element.new([name, value])
+          end
+
+          def parse_enum_element_value
+            case peek.type
+            when :"(" then parse_unit_type
+            when :"=" then parse_enum_element_value_expr
+            end
+          end
+
+          def parse_enum_element_value_expr
+            expect :"="
+            parse_expression
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/parser/root/function.rb

@@ -0,0 +1,90 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    class Parser
+      module Root
+        # Parses a function.
+        module Function
+        protected
+
+          def parse_function
+            expect :def
+
+            name = parse_function_name
+            parameters = parse_function_parameters
+            type = parse_function_type
+            body = parse_function_body if peek?(:do)
+
+            Node::Definition::Function.new([name, parameters, type, body])
+          end
+
+          def parse_function_name
+            name = parse_name
+            generics = peek?(:"<") ? parse_module_generics : []
+
+            Node::Definition::Function::Name.new([name, generics])
+          end
+
+          def parse_function_parameters
+            l = expect :"("
+            parameters = []
+            until peek? :")"
+              parameters << parse_function_parameter
+              break unless peek? :","
+              expect :","
+            end
+            r = expect :")"
+
+            Node::Definition::Function::Parameters.new(parameters,
+              components: [l, r])
+          end
+
+          def parse_function_parameter
+            case peek.type
+            when :self then parse_function_argument_self
+            when :_    then parse_function_argument_ignore
+            else            parse_function_argument_normal
+            end
+          end
+
+          def parse_function_argument_self
+            Node::Definition::Function::Argument.new([expect(:self)])
+          end
+
+          def parse_function_argument_ignore
+            under = expect :_
+            expect :":"
+            type = parse_type
+
+            Node::Definition::Function::Argument.new([under, type])
+          end
+
+          def parse_function_argument_normal
+            name = parse_name
+            expect :":"
+            type = parse_type
+
+            Node::Definition::Function::Argument.new([name, type])
+          end
+
+          def parse_function_type
+            expect :":"
+            parse_type
+          end
+
+          def parse_function_body
+            start = expect :do
+            statements = []
+            statements << parse_statement until peek? :end
+            stop = expect :end
+
+            Node::Definition::Function::Body.new(statements,
+              components: [start, stop])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/parser/root/struct.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    class Parser
+      module Root
+        # Parses a struct.
+        module Struct
+        protected
+
+          def parse_struct
+            start = expect :struct
+            expect :do
+            elements = []
+            elements << parse_struct_element until peek?(:end)
+            stop = expect :end
+
+            Node::Definition::Struct.new(elements, components: [start, stop])
+          end
+
+          def parse_struct_element
+            name = parse_name
+            expect :":"
+            type = parse_type
+            expect :";"
+
+            Node::Definition::Struct::Element.new([name, type])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/parser/root/trait.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    class Parser
+      module Root
+        # Parses a trait.
+        module Trait
+        protected
+
+          # TODO: fix
+
+          def parse_trait
+            expect :trait
+            expect :do
+            elements = []
+            elements << parse_trait_element until peek?(:end)
+            expect :end
+
+            Node.new(:trait, [Node.new(:trait_elements, elements)])
+          end
+
+          def parse_trait_element
+            name = parse_name
+            arguments = []
+            expect :"("
+            until peek? :")"
+              arguments << parse_type
+              break unless peek? :","
+              expect :","
+            end
+            expect :")"
+            expect :":"
+            ret = parse_type
+            expect :";"
+
+            Node.new(:trait_element, [name, arguments, ret])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/parser/statements.rb

@@ -0,0 +1,86 @@
+# encoding: utf-8
+# frozen_string_literal: true
+# rubocop:disable Metrics/CyclomaticComplexity
+
+require "carbon/compiler/parser/statements/if"
+require "carbon/compiler/parser/statements/match"
+require "carbon/compiler/parser/statements/try"
+
+module Carbon
+  module Compiler
+    class Parser
+      # Parses statements.
+      module Statements
+        include If
+        include Match
+        include Try
+
+      protected
+
+        def parse_statement
+          case peek.type
+          when :if     then parse_statement_if
+          when :match  then parse_statement_match
+          when :try    then parse_statement_try
+          when :for    then parse_statement_for
+          when :return then parse_statement_return
+          when :while  then parse_statement_while
+          when :let    then parse_statement_let
+          when :do     then parse_function_body
+          else
+            expr = parse_expression
+            expect :";"
+            expr
+          end
+        end
+
+        def parse_statement_return
+          expect :return
+          expr = parse_expression unless peek? :";"
+          expect :";"
+
+          Node::Statement::Return.new([expr].compact)
+        end
+
+        def parse_statement_let
+          expect :let
+          name = parse_name
+          expect :":"
+          type = parse_type
+          value =
+            if peek? :"="
+              expect :"="
+              parse_expression
+            end
+          expect :";"
+
+          Node::Statement::Let.new([name, type, value])
+        end
+
+        def parse_statement_while
+          expect :while
+          expect :"("
+          condition = parse_expression
+          expect :")"
+          body = parse_statement
+
+          Node::Statement::While.new([condition, body])
+        end
+
+        def parse_statement_for
+          expect :for
+          expect :"("
+          initial = parse_expression
+          expect :";"
+          condition = parse_expression
+          expect :";"
+          increment = parse_expression
+          expect :")"
+          body = parse_statement
+
+          Node::Statement::For.new([initial, condition, increment, body])
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/parser/statements/if.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    class Parser
+      module Statements
+        # Parses an if statement.
+        module If
+        protected
+
+          def parse_statement_if
+            expect :if
+            expect :"("
+            condition = parse_expression
+            expect :")"
+            body = parse_statement
+            follow = parse_statement_if_continued
+
+            Node::Statement::If.new([condition, body, follow])
+          end
+
+          def parse_statement_if_continued
+            case peek.type
+            when :elsif then parse_statement_if_elsif
+            when :else  then parse_statement_if_else
+            end
+          end
+
+          def parse_statement_if_elsif
+            expect :elsif
+            expect :"("
+            condition = parse_expression
+            expect :")"
+            body = parse_statement
+            follow = parse_statement_if_continued
+
+            Node::Statement::Elsif.new([condition, body, follow])
+          end
+
+          def parse_statement_if_else
+            expect :else
+
+            Node::Statement::Else.new([parse_statement])
+          end
+        end
+      end
+    end
+  end
+end