carbon-compiler 0.2.0

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

@@ -0,0 +1,39 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require "carbon/compiler/parser/expressions/precedence"
+require "carbon/compiler/parser/expressions/primary"
+
+module Carbon
+  module Compiler
+    class Parser
+      # Parses expressions.
+      module Expressions
+        include Precedence
+        include Primary
+
+      protected
+
+        PRECEDENCE = {
+          "=": 1,
+          "||": 2,
+          "&&": 3,
+          "|": 4,
+          "^": 5,
+          "&": 6,
+          "===": 7, "==": 7, "!=": 7,
+          "<": 8, ">": 8, "<=": 8, ">=": 8,
+          "<<": 9, ">>": 9,
+          "+": 10, "-": 10,
+          "*": 11, "/": 11, "%": 11,
+          ".": 12, "[": 12
+        }.freeze
+        RIGHT = [:"=", :"."].freeze
+
+        def parse_expression
+          parse_precedence(parse_expression_primary, 0)
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/parser/expressions/precedence.rb

@@ -0,0 +1,134 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    class Parser
+      module Expressions
+        # Parses precedence rules for expressions.
+        module Precedence
+        protected
+
+          def parse_precedence(expr, prec)
+            left = expr
+            while PRECEDENCE[peek.type] && PRECEDENCE[peek.type] >= prec
+              op = expect peek.type
+              left =
+                case op.type
+                when :<   then parse_precedence_less(left)
+                when :"." then parse_precedence_period(left)
+                when :"[" then parse_precedence_access(left)
+                else
+                  parse_precedence_op([left, op, parse_expression_primary])
+                end
+            end
+
+            left
+          end
+
+          def parse_precedence_less(left)
+            default = proc {
+              parse_precedence_op([left, :<, parse_expression_primary]) }
+            return default.call unless first(:type).include?(peek.type) &&
+              left.respond_to?(:generics)
+            position = @enum.dup
+            name = parse_type
+            case peek.type
+            when :>, :",", :":" then parse_precendence_generic(left, name)
+            else
+              @enum = position
+              parse_precedence_op([left, :<, parse_expression_primary])
+            end
+          end
+
+          def parse_precedence_generic(left, name)
+            children = [name]
+            until peek? :>
+              children << Concrete::Type::Generic.new(parse_module_name, [])
+              break unless peek? :","
+              expect :","
+            end
+            expect :>
+
+            if peek?(:"(") # if this is a call, our left should be an attribute
+              children = []
+              until peek? :")"
+                children << parse_expression
+                break unless peek? :","
+                expect :","
+              end
+              expect :")"
+
+              arguments = Node::Expression::Call::Parameters.new(children)
+              Node::Expression::Call::Unified.new([left.expression, left.name,
+                arguments, generics])
+            else
+              left.merge(generics: children)
+            end
+          end
+
+          def parse_precedence_period(left)
+            name = parse_name
+            generics = peek?(:<) ? parse_module_generics : []
+
+            if peek?(:"(")
+              parse_precedence_period_call(left, name, generics)
+            else
+              Node::Expression::Call::Attribute.new([left, name, generics])
+            end
+          end
+
+          def parse_precedence_access(left, generics = [])
+            children = []
+            until peek? :"]"
+              children << parse_expression
+              break unless peek? :","
+              expect :","
+            end
+            expect :"]"
+
+            arguments = Node::Expression::Call::Parameters.new(children)
+            Node::Expression::Call::Access.new([left, arguments, generics])
+          end
+
+          def parse_precedence_period_call(left, name, generics)
+            l = expect :"("
+            children = []
+            until peek? :")"
+              children << parse_expression
+              break unless peek? :","
+              expect :","
+            end
+            r = expect :")"
+
+            arguments = Node::Expression::Call::Parameters.new(children)
+            Node::Expression::Call::Unified.new([left, name, arguments,
+              generics], components: [left, name, l, r])
+          end
+
+          def parse_precedence_op(data)
+            left, op, right = *data
+            oprec = PRECEDENCE.fetch(op.type)
+            while PRECEDENCE[peek.type] && (PRECEDENCE[peek.type] > oprec ||
+              (RIGHT.include?(peek.type) && PRECEDENCE[peek.type] == oprec))
+              right = parse_precedence(right, PRECEDENCE[peek.type])
+            end
+
+            case op.type
+            when :"="
+              Node::Expression::Assignment.new([left, op, right])
+            when :"&&"
+              Node::Expression::Operation::And.new([left, op, right])
+            when :"||"
+              Node::Expression::Operation::Or.new([left, op, right])
+            when :"!="
+              Node::Expression::Operation::Neq.new([left, op, right])
+            else
+              Node::Expression::Operation::Normal.new([left, op, right])
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/parser/expressions/primary.rb

@@ -0,0 +1,120 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    class Parser
+      module Expressions
+        # Parses primary expressions, e.g. literals, module calls, etc.
+        module Primary
+        protected
+
+          FUNCTION_NAMES = Set[:|, :&, :"^", :===, :==, :<, :>, :<=, :>=,
+            :<=>, :<<, :>>, :+, :-, :*, :/, :%, :[], :[]=]
+          Parser.first(:module, [:MNAME])
+          Parser.first(:literal, [:NUMBER, :FLOAT, :STRING])
+          Parser.first(:unit, [:"("])
+          Parser.first(:expression, Parser.first(:module) |
+            Parser.first(:literal) | Parser.first(:unit) |
+            Parser.first(:name))
+          Parser.first(:call, Parser.first(:name))
+          def parse_expression_primary
+            if first(:module).include?(peek.type)
+              parse_expression_module
+            elsif first(:literal).include?(peek.type)
+              parse_expression_literal
+            elsif first(:unit).include?(peek.type)
+              parse_expression_unit
+            elsif first(:name).include?(peek.type)
+              parse_expression_name
+            else
+              error(first(:expression))
+            end
+          end
+
+          def parse_expression_module
+            mname = parse_module_name
+            case peek.type
+            when :"."
+              parse_expression_call(mname)
+            else
+              error([:"."])
+            end
+          end
+
+          def parse_expression_name
+            name = parse_name
+            return name unless peek? :"("
+            l = expect :"("
+            children = []
+            until peek? :")"
+              children << parse_expression
+              break unless peek? :","
+              expect :","
+            end
+            r = expect :")"
+
+            arguments = Node::Expression::Call::Parameters.new(children,
+              components: [l, r])
+            Node::Expression::Call::Self.new([name, arguments])
+          end
+
+          def parse_expression_call_name
+            if first(:name).include?(peek.type)
+              parse_name
+            elsif peek?(:MNAME)
+              expect :MNAME
+            else
+              error(first(:name) | [:MNAME])
+            end
+          end
+
+          def parse_expression_call(mname)
+            expect :"."
+            name = parse_expression_call_name
+            generics = peek?(:<) ? parse_module_generics : []
+
+            l = expect :"("
+            children = []
+            until peek? :")"
+              children << parse_expression
+              break unless peek? :","
+              expect :","
+            end
+            r = expect :")"
+
+            arguments = Node::Expression::Call::Parameters.new(children,
+              components: [l, r])
+            Node::Expression::Call::Module.new([mname, name, arguments,
+              generics])
+          end
+
+          def parse_expression_unit
+            expect :"("
+            children = []
+            until peek? :")"
+              children << parse_expression
+              break unless peek? :","
+              expect :","
+            end
+            expect :")"
+            Node::Expression::Unit.new(children)
+          end
+
+          def parse_expression_literal
+            case peek.type
+            when :NUMBER
+              Node::Expression::Literal.new([expect(:NUMBER)])
+            when :FLOAT
+              Node::Expression::Literal.new([expect(:FLOAT)])
+            when :STRING
+              Node::Expression::Literal.new([expect(:STRING)])
+            else
+              error first(:literal)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# encoding: utf-8
+# frozen_string_literal: true
+require "set"
+
+module Carbon
+  module Compiler
+    class Parser
+      # Manages first sets for the parser.  This is only for internal
+      # reference to make parsing easier.
+      module Firsts
+        # The class methods that should be placed on the parser.
+        module ClassMethods
+          # The first sets.  The key is the name of a node, and the value
+          # is a set of all tokens that can be at the start of that node.
+          #
+          # @return [{Symbol => Set<Symbol>}]
+          def firsts
+            @firsts ||= Hash.new { |h, k| h[k] = Set.new }
+          end
+
+          # @overload first(name)
+          #   Retrieves the first set for the given node name.  If none exists,
+          #   a `KeyError` is raised.
+          #
+          #   @api private
+          #   @param name [::Symbol] The name of the node to look up the first
+          #     set for.
+          #   @return [Set<::Symbol>] The first set
+          #   @raise [KeyError] If the node has no defined first set.
+          # @overload first(name, tokens)
+          #   Merges the given tokens into the first set of the name of the
+          #   node given.
+          #
+          #   @api private
+          #   @param name [::Symbol] The name of the node that the first set is
+          #     for.
+          #   @param tokens [<::Symbol>] The tokens that act as the first set
+          #     for the node.
+          #   @return [void]
+          def first(name, tokens = nil)
+            if tokens
+              firsts[name].merge(tokens)
+            else
+              firsts.fetch(name)
+            end
+          end
+        end
+
+        # The instance methods that should be placed in the parser.
+        module InstanceMethods
+          # Retrieves the first set for the given node name.
+          #
+          # @param name [Symbol]
+          # @return [Set<Symbol>]
+          def first(name)
+            self.class.firsts.fetch(name)
+          end
+        end
+
+        # Includes the {ClassMethods} and {InstanceMethods} into the
+        # parser or whatever base includes it.
+        #
+        # @param base [Parser]
+        # @api private
+        def self.included(base)
+          base.extend ClassMethods
+          base.send :include, InstanceMethods
+        end
+      end
+
+      include Firsts
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    class Parser
+      # helpers that manage the state of the parser.  This can be things like
+      # peeking, shifting, and erroring.
+      module Helpers
+        # Peeks to the next token.  If peeking would cause a `StopIteration`
+        # error, it instead returns the last value that was peeked.
+        #
+        # @return [Scanner::Token]
+        def peek
+          value = @enum.peek
+          @_last = value
+        rescue StopIteration
+          @_last
+        end
+
+        # Checks to see if any of the given types includes the next token.
+        #
+        # @param types [Symbol] The possible types.
+        # @return [Boolean]
+        def peek?(*types)
+          types.include?(peek.type)
+        end
+
+        # Shifts to the next token, and returns the old token.
+        #
+        # @return [Scanner::Token]
+        def shift
+          @enum.next
+        end
+
+        # Sets up an expectation for a given token.  If the next token is
+        # an expected token, it shifts, returning the token; otherwise,
+        # it {#error}s with the token information.
+        #
+        # @param tokens [Symbol] The expected tokens.
+        # @return [Scanner::Token]
+        def expect(*tokens)
+          return shift if peek?(*tokens)
+          error(tokens)
+        end
+
+        # Errors, noting the expected tokens, the given token, the location
+        # of given tokens.  It does this by emitting a diagnostic.  The
+        # diagnostic is only allowed to be a {Metanostic::Mode::PANIC}
+        # diagnostic, so this is garenteed to error.
+        #
+        # @param tokens [<Symbol>] The expected tokens.
+        # @return [void]
+        def error(tokens)
+          @file.emit("Syntax/Token/Unexpected", peek.location,
+            [peek.type.inspect, tokens.map(&:inspect).join(", ")])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# encoding: utf-8
+# frozen_string_literal: true
+# rubocop:disable Metrics/CyclomaticComplexity
+
+require "carbon/compiler/parser/root/class"
+require "carbon/compiler/parser/root/directive"
+require "carbon/compiler/parser/root/enum"
+require "carbon/compiler/parser/root/function"
+require "carbon/compiler/parser/root/struct"
+require "carbon/compiler/parser/root/trait"
+
+module Carbon
+  module Compiler
+    class Parser
+      # Parses root definitions, like functions and enums.
+      module Root
+        include Class
+        include Directive
+        include Enum
+        include Function
+        include Struct
+        include Trait
+
+      protected
+
+        Parser.first(:root, [:":", :module, :struct, :class, :trait, :enum,
+          :def])
+        def parse_root
+          children = []
+          until peek? :EOF
+            children <<
+              case peek.type
+              when :":"    then parse_directive
+              when :module then parse_module
+              when :struct then parse_struct
+              when :class  then parse_class
+              when :trait  then parse_trait
+              when :enum   then parse_enum
+              when :def    then parse_function
+              else error first(:root)
+              end
+          end
+
+          Node::Root.new(children)
+        end
+
+        def parse_module
+          expect :module
+          name = parse_module_name
+          expect :"."
+
+          Node::Definition::Module.new([name])
+        end
+      end
+    end
+  end
+end