miniruby 0.1.0

data/lib/miniruby/parser/result.rb

@@ -0,0 +1,43 @@
+# typed: strong
+# frozen_string_literal: true
+
+module MiniRuby
+  # The result of parsing a MiniRuby string/file.
+  # Combines an AST (Abstract Syntax Tree) and a list of errors.
+  class Parser::Result
+    extend T::Sig
+
+    sig { returns(AST::ProgramNode) }
+    attr_reader :ast
+
+    sig { returns(T::Array[String]) }
+    attr_reader :errors
+
+    sig { params(ast: AST::ProgramNode, errors: T::Array[String]).void }
+    def initialize(ast, errors)
+      @ast = ast
+      @errors = errors
+    end
+
+    sig { returns(T::Boolean) }
+    def err?
+      @errors.any?
+    end
+
+    sig { returns(String) }
+    def inspect
+      buff = String.new
+      buff << "<#{self.class}>\n"
+      if @errors.any?
+        buff << "  !Errors!\n"
+        @errors.each do |err|
+          buff << "    - #{err}\n"
+        end
+        buff << "\n"
+      end
+
+      buff << "  AST:\n"
+      buff << @ast.inspect(2)
+    end
+  end
+end

data/lib/miniruby/parser.rb

@@ -0,0 +1,198 @@
+# typed: strict
+# frozen_string_literal: true
+
+module MiniRuby
+  # MiniRuby parser
+  class Parser
+    extend T::Sig
+
+    require_relative 'parser/result'
+
+    class << self
+      extend T::Sig
+
+      sig { params(source: String).returns(Result) }
+      def parse(source)
+        new(source).parse
+      end
+
+      private :new
+    end
+
+    sig { params(source: String).void }
+    def initialize(source)
+      # Lexer/Tokenizer that produces tokens
+      @lexer = T.let(Lexer.new(source), Lexer)
+      # Next token used for predicting productions
+      @lookahead = T.let(Token.new(Token::NONE, Span::ZERO), Token)
+      @errors = T.let([], T::Array[String])
+    end
+
+    sig { returns(Result) }
+    def parse
+      advance # populate @lookahead
+      ast = parse_program
+      Result.new(ast, @errors)
+    end
+
+    private
+
+    # program = statements
+    sig { returns(AST::ProgramNode) }
+    def parse_program
+      statements = parse_statements
+
+      span = Span::ZERO
+      if statements.length > 0
+        span = statements.fetch(0).span.join(statements.fetch(-1).span)
+      end
+
+      AST::ProgramNode.new(statements:, span:)
+    end
+
+     # statements = statement*
+     sig { params(stop_tokens: Symbol).returns(T::Array[AST::StatementNode]) }
+     def parse_statements(*stop_tokens)
+       statements = T.let([], T::Array[AST::StatementNode])
+       swallow_statement_separators
+
+       while true
+         return statements if accept!([Token::END_OF_FILE, *stop_tokens])
+
+         statements << parse_statement
+       end
+     end
+
+    # statement = expression_statement
+    sig { returns(AST::StatementNode) }
+    def parse_statement
+      parse_expression_statement
+    end
+
+    # expression_statement = expression ("\n" | ";")
+    sig { returns(AST::StatementNode) }
+    def parse_expression_statement
+      expression = parse_expression
+      span = expression.span
+      if (separator = match(Token::NEWLINE, Token::SEMICOLON, Token::END_OF_FILE))
+        span = span.join(separator.span)
+      else
+        error_expected('a statement separator')
+      end
+
+      swallow_statement_separators
+      AST::ExpressionStatementNode.new(expression:, span:)
+    end
+
+    sig { returns(AST::ExpressionNode) }
+    def parse_expression
+      case @lookahead.type
+      when Token::FALSE
+        tok = advance
+        AST::FalseLiteralNode.new(span: tok.span)
+      when Token::TRUE
+        tok = advance
+        AST::TrueLiteralNode.new(span: tok.span)
+      when Token::NIL
+        tok = advance
+        AST::NilLiteralNode.new(span: tok.span)
+      when Token::INTEGER
+        tok = advance
+        AST::IntegerLiteralNode.new(span: tok.span, value: T.must(tok.value))
+      when Token::FLOAT
+        tok = advance
+        AST::FloatLiteralNode.new(span: tok.span, value: T.must(tok.value))
+      when Token::STRING
+        tok = advance
+        AST::StringLiteralNode.new(span: tok.span, value: T.must(tok.value))
+      when Token::IDENTIFIER
+        tok = advance
+        AST::IdentifierNode.new(span: tok.span, value: T.must(tok.value))
+      else
+        token = advance
+        add_error("unexpected token `#{tok}`") if token.type != Token::ERROR
+        AST::InvalidNode.new(span: token.span, token:)
+      end
+    end
+
+    # Move over to the next token.
+    sig { returns(Token) }
+    def advance
+      previous = @lookahead
+      @lookahead = @lexer.next
+      handle_error_token(@lookahead) if @lookahead.type == Token::ERROR
+
+      previous
+    end
+
+    # Add the content of an error token to the syntax error list.
+    sig { params(err: Token).void }
+    def handle_error_token(err)
+      msg = err.value
+      return unless msg
+
+      add_error(msg)
+    end
+
+    # Register a syntax error
+    sig { params(err: String).void }
+    def add_error(err)
+      @errors << err
+    end
+
+    # Checks whether the next token matches any the specified types.
+    sig { params(token_types: Symbol).returns(T::Boolean) }
+    def accept(*token_types)
+      accept!(token_types)
+    end
+
+    # Checks whether the next token matches any the specified types.
+    sig { params(token_types: T::Array[Symbol]).returns(T::Boolean) }
+    def accept!(token_types)
+      token_types.each do |type|
+        return true if @lookahead.type == type
+      end
+
+      false
+    end
+
+    # Checks if the next token matches any of the given types,
+    # if so it gets consumed.
+    sig { params(token_types: Symbol).returns(T.nilable(Token)) }
+    def match(*token_types)
+      token_types.each do |type|
+        return advance if accept(type)
+      end
+
+      nil
+    end
+
+    # Accept and ignore any number of consecutive newline tokens.
+    sig { void }
+    def swallow_newlines
+      while true
+        break unless match(Token::NEWLINE)
+      end
+    end
+
+    # Accept and ignore any number of consecutive newline or semicolon tokens.
+    sig { void }
+    def swallow_statement_separators
+      while true
+        break unless match(Token::NEWLINE, Token::SEMICOLON)
+      end
+    end
+
+    # Adds an error which tells the user that another type of token
+    # was expected.
+    sig { params(expected: String).void }
+    def error_expected(expected)
+      return if @lookahead.type == Token::ERROR
+
+      add_error("unexpected #{@lookahead.type_name}, expected #{expected}")
+    end
+
+
+  end
+
+end

data/lib/miniruby/position.rb

@@ -0,0 +1,31 @@
+# typed: strong
+# frozen_string_literal: true
+
+module MiniRuby
+  # A position of a single character in a piece of text
+  class Position
+    extend T::Sig
+
+    sig { returns(Integer) }
+    attr_reader :char_index
+
+    sig { params(char_index: Integer).void }
+    def initialize(char_index)
+      @char_index = char_index
+    end
+
+    ZERO = Position.new(0)
+
+    sig { params(other: Object).returns(T::Boolean) }
+    def ==(other)
+      return false unless other.is_a?(Position)
+
+      @char_index == other.char_index
+    end
+
+    sig { returns(String) }
+    def inspect
+      "P(#{char_index.inspect})"
+    end
+  end
+end

data/lib/miniruby/span.rb

@@ -0,0 +1,41 @@
+# typed: strong
+# frozen_string_literal: true
+
+module MiniRuby
+  # A collection of two positions: start and end
+  class Span
+    extend T::Sig
+
+    sig { returns(Position) }
+    attr_reader :start
+
+    sig { returns(Position) }
+    attr_reader :end
+
+    sig { params(start: Position, end_pos: Position).void }
+    def initialize(start, end_pos)
+      @start = start
+      @end = end_pos
+    end
+
+    ZERO = Span.new(Position::ZERO, Position::ZERO)
+
+    # Create a new span that includes the area of two spans.
+    sig { params(other: Span).returns(Span) }
+    def join(other)
+      Span.new(@start, other.end)
+    end
+
+    sig { params(other: Object).returns(T::Boolean) }
+    def ==(other)
+      return false unless other.is_a?(Span)
+
+      @start == other.start && @end == other.end
+    end
+
+    sig { returns(String) }
+    def inspect
+      "S(#{@start.inspect}, #{@end.inspect})"
+    end
+  end
+end

data/lib/miniruby/token.rb

@@ -0,0 +1,300 @@
+# typed: strong
+# frozen_string_literal: true
+
+require 'set'
+
+module MiniRuby
+  # Represents a single token (word) produced by the lexer.
+  class Token
+    extend T::Sig
+
+    class << self
+      extend T::Sig
+
+      # Converts a token type into a human-readable string.
+      sig { params(type: Symbol).returns(String) }
+      def type_to_string(type)
+        case type
+        when NONE
+          'NONE'
+        when END_OF_FILE
+          'END_OF_FILE'
+        when ERROR
+          'ERROR'
+        when LPAREN
+          '('
+        when RPAREN
+          ')'
+        when COMMA
+          ','
+        when SEMICOLON
+          ';'
+        when NEWLINE
+          'NEWLINE'
+        when EQUAL
+          '='
+        when BANG
+          '!'
+        when EQUAL_EQUAL
+          '=='
+        when NOT_EQUAL
+          '!='
+        when GREATER
+          '>'
+        when GREATER_EQUAL
+          '>='
+        when LESS
+          '<'
+        when LESS_EQUAL
+          '<='
+        when PLUS
+          '+'
+        when MINUS
+          '-'
+        when STAR
+          '*'
+        when SLASH
+          '/'
+        when FLOAT
+          'FLOAT'
+        when INTEGER
+          'INTEGER'
+        when STRING
+          'STRING'
+        when IDENTIFIER
+          'IDENTIFIER'
+        else
+          t = type.to_s
+          return t if KEYWORDS.include?(t)
+
+          '<invalid>'
+        end
+      end
+    end
+
+    sig { returns(Symbol) }
+    attr_reader :type
+
+    sig { returns(T.nilable(String)) }
+    attr_reader :value
+
+    sig { returns(Span) }
+    attr_reader :span
+
+    sig { params(type: Symbol, span: Span, value: T.nilable(String)).void }
+    def initialize(type, span, value = nil)
+      @type = type
+      @span = span
+      @value = value
+    end
+
+    sig { params(other: Object).returns(T::Boolean) }
+    def ==(other)
+      return false unless other.is_a?(Token)
+
+      type == other.type && value == other.value
+    end
+
+    sig { returns(String) }
+    def inspect
+      return "Token(#{type.inspect}, #{span.inspect})" if value.nil?
+
+      "Token(#{type.inspect}, #{span.inspect}, #{value.inspect})"
+    end
+
+    sig { returns(T::Boolean) }
+    def equality_operator?
+      case @type
+      when EQUAL_EQUAL, NOT_EQUAL
+        true
+      else
+        false
+      end
+    end
+
+    sig { returns(T::Boolean) }
+    def additive_operator?
+      case @type
+      when PLUS, MINUS
+        true
+      else
+        false
+      end
+    end
+
+    sig { returns(T::Boolean) }
+    def multiplicative_operator?
+      case @type
+      when STAR, SLASH
+        true
+      else
+        false
+      end
+    end
+
+    sig { returns(T::Boolean) }
+    def comparison_operator?
+      case @type
+      when GREATER, GREATER_EQUAL, LESS, LESS_EQUAL
+        true
+      else
+        false
+      end
+    end
+
+    sig { returns(String) }
+    def type_name
+      self.class.type_to_string(@type)
+    end
+
+    # Converts a token into a human-readable string.
+    sig { returns(String) }
+    def to_s
+      case type
+      when NONE
+        'NONE'
+      when END_OF_FILE
+        'END_OF_FILE'
+      when ERROR
+        "<error: #{value}>"
+      when LPAREN
+        '('
+      when RPAREN
+        ')'
+      when COMMA
+        ','
+      when SEMICOLON
+        ';'
+      when NEWLINE
+        'NEWLINE'
+      when EQUAL
+        '='
+      when BANG
+        '!'
+      when EQUAL_EQUAL
+        '=='
+      when NOT_EQUAL
+        '!='
+      when GREATER
+        '>'
+      when GREATER_EQUAL
+        '>='
+      when LESS
+        '<'
+      when LESS_EQUAL
+        '<='
+      when PLUS
+        '+'
+      when MINUS
+        '-'
+      when STAR
+        '*'
+      when SLASH
+        '/'
+      when FLOAT, INTEGER, IDENTIFIER
+        value.to_s
+      when STRING
+        T.cast(value.inspect, String)
+      else
+        t = type.to_s
+        return t if KEYWORDS.include?(t)
+
+        '<invalid>'
+      end
+    end
+
+    # String containing all valid decimal digits
+    DIGITS = '0123456789'
+    # String containing all valid hexadecimal digits
+    HEX_DIGITS = '0123456789abcdefABCDEF'
+
+    # Set of all keywords
+    KEYWORDS = T.let(
+      Set[
+        'false',
+        'true',
+        'nil',
+        'if',
+        'while',
+        'return',
+        'end',
+        'else',
+        'self',
+      ],
+      T::Set[String],
+    )
+
+    # List of all token types
+    # ------------------------
+
+    # Represents no token, a placeholder
+    NONE = :none
+    # Signifies that the entire string/file has been processed,
+    # there will be no more tokens
+    END_OF_FILE = :end_of_file
+    # Holds an error message, means that the string/file could not be
+    # successfully processed
+    ERROR = :error
+    # Left parentheses `(`
+    LPAREN = :lparen
+    # Right parentheses `)`
+    RPAREN = :rparen
+    # Comma `,`
+    COMMA = :comma
+    # Semicolon `;`
+    SEMICOLON = :semicolon
+    # Newline
+    NEWLINE = :newline
+    # Equal `=`
+    EQUAL = :equal
+    # Bang `!`
+    BANG = :bang
+    # Equal `==`
+    EQUAL_EQUAL = :equal_equal
+    # Equal `!=`
+    NOT_EQUAL = :not_equal
+    # Greater than `>`
+    GREATER = :greater
+    # Greater equal `>=`
+    GREATER_EQUAL = :greater_equal
+    # Less than `<`
+    LESS = :less
+    # Less equal `<=`
+    LESS_EQUAL = :less_equal
+    # Plus `+`
+    PLUS = :plus
+    # Minus `-`
+    MINUS = :minus
+    # Star `*`
+    STAR = :star
+    # Slash `/`
+    SLASH = :slash
+    # Integer literal eg. `123`
+    INTEGER = :integer
+    # Float literal eg. `12.3`
+    FLOAT = :float
+    # String literal eg. `"foo"`
+    STRING = :string
+    # Identifier eg. `foo`
+    IDENTIFIER = :identifier
+
+    # Keyword `false`
+    FALSE = :false
+    # Keyword `true`
+    TRUE = :true
+    # Keyword `nil`
+    NIL = :nil
+    # Keyword `if`
+    IF = :if
+    # Keyword `while`
+    WHILE = :while
+    # Keyword `return`
+    RETURN = :return
+    # Keyword `end`
+    END_K = :end
+    # Keyword `else`
+    ELSE = :else
+    # Keyword `self`
+    SELF = :self
+  end
+end

data/lib/miniruby/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module MiniRuby
+  VERSION = '0.1.0'
+end

data/lib/miniruby.rb

@@ -0,0 +1,72 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+
+# Contains the MiniRuby interpreter.
+module MiniRuby
+  class Error < StandardError; end
+
+  class << self
+    extend T::Sig
+
+    # Tokenize the MiniRuby source string.
+    # Carries out lexical analysis and returns
+    # an array of tokens (words).
+    sig do
+      params(
+        source: String,
+      ).returns(T::Array[Token])
+    end
+    def lex(source)
+      Lexer.lex(source)
+    end
+
+    # Parse the MiniRuby source.
+    # Returns an AST (Abstract Syntax Tree) and a list of errors.
+    sig do
+      params(
+        source: String,
+      ).returns(Parser::Result)
+    end
+    def parse(source)
+      Parser.parse(source)
+    end
+
+    # # Compile the MiniRuby source.
+    # # Returns a chunk of compiled bytecode.
+    # sig do
+    #   params(
+    #     source: String,
+    #   ).returns(BytecodeFunction)
+    # end
+    # def compile(source)
+    #   Compiler.compile_source(source)
+    # end
+
+    # # Interpret the MiniRuby source with the Virtual Machine.
+    # # Returns the last computed value.
+    # sig do
+    #   params(
+    #     source: String,
+    #     stdout: IO,
+    #     stdin:  IO,
+    #   ).returns(Object)
+    # end
+    # def interpret(source, stdout: $stdout, stdin: $stdin)
+    #   VM.interpret(source, stdout:, stdin:)
+    # end
+  end
+end
+
+require_relative 'miniruby/version'
+require_relative 'miniruby/position'
+require_relative 'miniruby/span'
+require_relative 'miniruby/token'
+require_relative 'miniruby/lexer'
+require_relative 'miniruby/ast'
+require_relative 'miniruby/parser'
+# require_relative 'miniruby/opcode'
+# require_relative 'miniruby/bytecode_function'
+# require_relative 'miniruby/compiler'
+# require_relative 'miniruby/vm'