carbon-compiler 0.2.0

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

@@ -0,0 +1,39 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    class Parser
+      module Statements
+        # Parses a match statement.
+        module Match
+        protected
+
+          # TODO: Fix
+
+          def parse_statement_match
+            expect :match
+            expect :"("
+            source = parse_expression
+            expect :")"
+            expect :do
+            children = []
+            children << parse_match_element until peek? :end
+            expect :end
+
+            elements = Node.new(:statement_match_elements, children)
+            Node.new(:statement_match, [source, elements])
+          end
+
+          def parse_match_element
+            pattern = parse_expression
+            expect :"=>"
+            body = parse_statement
+
+            Node.new(:statement_match_element, [pattern, body])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    class Parser
+      module Statements
+        # Parses a try statement.
+        module Try
+        protected
+
+          def parse_statement_try
+            expect :try
+            body = parse_statement
+            continued = parse_statement_try_continued
+
+            Node::Statement::Try.new([body, continued])
+          end
+
+          def parse_statement_try_continued
+            case peek.type
+            when :catch   then parse_statement_try_catch
+            when :finally then parse_statement_try_finally
+            end
+          end
+
+          def parse_statement_try_catch
+            expect :catch
+            expect :"("
+            name = parse_name
+            expect :":"
+            type = parse_type
+            expect :")"
+            body = parse_statement
+            follow = parse_statement_try_continued
+
+            Node::Statement::Catch.new([name, type, body, follow])
+          end
+
+          def parse_statement_try_finally
+            expect :finally
+
+            Node::Statement::Finally.new([parse_statement])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/project.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require "carbon/compiler/project/file"
+require "llvm/target"
+require "llvm/execution_engine"
+
+module Carbon
+  module Compiler
+    class Project
+      attr_reader :diagnostics
+      attr_reader :items
+      attr_reader :main
+
+      def initialize(files, root, libraries: [])
+        @root = Pathname.new(root).expand_path(Dir.pwd)
+        @files = files.map { |f| Project::File.new(f, @root, self) }
+        @diagnostics = Metanostic::List.new
+        @libraries = []
+        @files.each { |f| @diagnostics.files[f.short] = f }
+      end
+
+      def call
+        @index ||= begin
+          @index = Concrete::Index.new
+          @files.each { |f| f.call(@index, @diagnostics.clone) }
+          # load libraries...
+          @libraries.each do |library|
+            @index.link(Carbon::Concrete.load(::File.read(library, "rb")))
+          end
+          @index.link(Carbon::Core.index)
+          @index.finalize
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/project/file.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    class Project
+      class File
+        attr_reader :name
+        attr_reader :root
+        attr_reader :path
+        attr_reader :short
+        attr_reader :aliases
+
+        def initialize(path, root, project)
+          @root = Pathname.new(root)
+          @path = Pathname.new(path).expand_path(@root)
+          @short = @path.relative_path_from(@root)
+          @name = @short.sub_ext("").to_s
+          @project = project
+          @aliases = {}
+        end
+
+        def module
+          @module ||= begin
+            mname = @name
+              .gsub(/\A([a-z])/, &:upcase)
+              .gsub(/(\/|\\)([a-z])/) { |m| "::#{m[1].upcase}" }
+              .gsub(/_([a-z])/) { |m| m[1].upcase }
+              .gsub(/\/|\\/, "::")
+            Carbon::Type(mname)
+          end
+        end
+
+        attr_writer :module
+
+        def emit(*p)
+          @diagnostics.emit(*p)
+        end
+
+        def call(index, diagnostics)
+          @diagnostics = diagnostics
+          root = Visitor::Preparation.new(self, index).call(parser.root)
+          Visitor::Generation.new(self, index).call(root)
+        end
+
+        def parser
+          @parser ||= Compiler::Parser.new(scanner)
+        end
+
+        def scanner
+          @scanner ||= Compiler::Scanner.new(self)
+        end
+
+        def read
+          @_read ||= @path.read
+        end
+
+        def lines
+          @_lines ||= @path.each_line
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/scanner.rb

@@ -0,0 +1,82 @@
+# encoding: utf-8
+# frozen_string_literal: true
+require "strscan"
+require "carbon/compiler/scanner/main"
+require "carbon/compiler/scanner/token"
+
+module Carbon
+  module Compiler
+    # Scans over the file, taking a squence of characters and turning them into
+    # tokens.
+    class Scanner
+      include Main
+      include Enumerable
+
+      # The file that the scanner will run over.
+      #
+      # @return [Project::File]
+      attr_reader :file
+
+      # Initialize the scanner.  Takes a file, which contains information about
+      # the file, and can read from the file.
+      #
+      # @param file [Project::File]
+      def initialize(file)
+        @file = file
+        @scanner = StringScanner.new(@file.read)
+        @line = 1
+        @last = 0
+      end
+
+      # Pretty inspect.
+      #
+      # @return [void]
+      def inspect
+        "#<#{self.class} #{@file.name}>"
+      end
+
+      # Yields each token to the block, if one is given.  Returns an
+      # enumerator that enumerates over all generated tokens.
+      #
+      # @yield [token]
+      # @yieldparam token [Token]
+      # @return [Enumerator<Token>]
+      def each
+        return to_enum unless block_given?
+        until @scanner.eos?
+          token = scan
+          yield token if token.is_a?(Token)
+        end
+
+        yield Token.new(:EOF, "", location)
+        @scanner.reset
+      end
+
+    private
+
+      def match(string, name = :"#{string}")
+        if string.is_a?(::String)
+          string = /#{::Regexp.escape(string.to_s)}/
+        elsif string.is_a?(::Symbol)
+          string = /#{::Regexp.escape(string.to_s)}(?![\w])/
+        end
+
+        if @scanner.scan(string)
+          Token.new(name, @scanner[0], location(@scanner[0].length))
+        end
+      end
+
+      def location(length = 0)
+        lines = @line..@line
+        start = @scanner.charpos - @last
+        columns = (start - length)..start
+        Location.new(lines, columns, @file.short)
+      end
+
+      def error!
+        @file.emit("Syntax/Token/Unknown", location,
+          [@scanner.string[@scanner.charpos]])
+      end
+    end
+  end
+end

data/lib/carbon/compiler/scanner/main.rb

@@ -0,0 +1,76 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    class Scanner
+      # Performs the scanning.
+      module Main
+      protected
+
+        def scan
+          false ||
+            scan_keywords ||
+            scan_identifiers ||
+            scan_operators ||
+            scan_comment ||
+            scan_whitespace ||
+            error!
+        end
+
+        # rubocop:disable Metrics/CyclomaticComplexity
+        def scan_identifiers
+          false ||
+            match(/[a-z][A-Za-z0-9_-]*[!?=]?/, :IDENTIFIER) ||
+            match(/(0[xX][0-9a-fA-F]+)(_?[ui][0-9]+)?/, :NUMBER) ||
+            match(/(0|[1-9][0-9]*)(_?[ui][0-9]+)?/, :NUMBER) ||
+            match(/[A-Z][A-Za-z0-9_-]*/, :MNAME) ||
+            match(/"(([^"\\]|\\.)*)"/, :STRING) ||
+            false
+        end
+
+        KEYWORDS = %i(
+          finally return struct module catch elsif match trait while
+          self else enum for def end let try do if _
+        ).sort_by(&:size).reverse.freeze
+
+        def scan_keywords
+          KEYWORDS.find do |keyword|
+            m = match(/#{Regexp.escape(keyword)}(?![a-zA-Z0-9!?=_-])/, keyword)
+            return m if m
+          end || false
+        end
+
+        OPERATORS = %w(
+          === :: => == && || != << >> <= >= + - ~ ! * / % : ; & | [ ] ( ) { } <
+          > . , = ^ [] []=
+        ).sort_by(&:size).reverse.freeze
+
+        def scan_operators
+          OPERATORS.find do |operator|
+            m = match(operator)
+            return m if m
+          end || false
+        end
+
+        def scan_comment
+          if @scanner.scan(/\#.+?(\r\n|\r|\n)/)
+            @line += 1
+            @last = @scanner.charpos - 1
+            true
+          end
+        end
+
+        def scan_whitespace
+          if @scanner.scan(/\r\n|\r|\n/)
+            @line += 1
+            @last = @scanner.charpos - 1
+            true
+          elsif @scanner.scan(/[ \v\t\f]/)
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/scanner/token.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    class Scanner
+      # A token from the scanner.
+      class Token
+        # The type of the token.  For any explicit matches (e.g. `"module"`),
+        # this is the exact match (e.g. `:module`).  For any regular matches
+        # (e.g. an identifier), this is in all caps (e.g. `:IDENTIFIER`).
+        #
+        # @return [Symbol]
+        attr_reader :type
+        # The lexeme that this token is associated.  This is what the token
+        # matched directly from the source.
+        #
+        # @return [String]
+        attr_reader :value
+        # The exact location the token was taken from.  This only spans one
+        # line.
+        #
+        # @return [Location]
+        attr_reader :location
+
+        # Initialize the token.  Freezes it after initializing.
+        #
+        # @param type [Symbol] The type.  See {#type}.
+        # @param value [String] The value.  See {#value}.
+        # @param location [Location] The location.  See {#location}.
+        def initialize(type, value, location)
+          @type = type
+          @value = value
+          @location = location
+          @children = []
+          to_a
+          freeze
+        end
+
+        # Creates an array representation of this class.  This is cached and
+        # frozen, since nothing about this class changes.
+        #
+        # @return [(Class, Symbol, String, Location)]
+        def to_a
+          @array ||= [self.class, @type, @value, @location].freeze
+        end
+
+        # Creates a numeric representation of this class for hashing.
+        #
+        # @see #to_a
+        # @return [Numeric]
+        def hash
+          to_a.hash
+        end
+      end
+    end
+  end
+end

data/lib/carbon/compiler/version.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    VERSION = "0.2.0".freeze
+  end
+end

data/lib/carbon/compiler/visitor.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require "carbon/compiler/visitor/base"
+require "carbon/compiler/visitor/generation"
+require "carbon/compiler/visitor/preparation"
+
+module Carbon
+  module Compiler
+    module Visitor
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Compiler
+    module Visitor
+      # A visitor base.
+      module Base
+        # The class methods.
+        module ClassMethods
+          def matches
+            @_matches ||= Concurrent::Hash.new
+          end
+
+          def on(nodes)
+            matches.merge!(nodes)
+          end
+        end
+
+        # The instance methods.
+        module InstanceMethods
+          def accept(node, *params)
+            visit(node, *params)
+          end
+
+          def visit(node, *params)
+            return unless node
+            begin
+              action = self.class.matches.fetch(node.class)
+            rescue KeyError
+              visit_missing(node, *params)
+            end
+            public_send(action, node, *params)
+          end
+
+          def visit_missing(node, *)
+            fail ArgumentError, "Cannot visit #{node.class}"
+          end
+
+          def visit_ignore(node)
+            node
+          end
+        end
+
+        def self.included(base)
+          base.include InstanceMethods
+          base.extend ClassMethods
+        end
+      end
+    end
+  end
+end