gloss 0.0.1

data/ext/gloss/src/lib/cr_ruby.cr

@@ -0,0 +1,35 @@
+lib CrRuby
+  # every ruby Object is a VALUE
+  type VALUE = Void*
+  # ruby method typing
+  type METHOD_FUNC = VALUE, VALUE -> VALUE
+
+  # a ruby Class is a VALUE
+  $rb_cObject : VALUE
+
+  # a ruby Module is also a VALUE
+  $rb_mObject : VALUE
+
+  # $rb_Qnil : VALUE
+
+  # convert Ruby str to C str
+  fun rb_str_new_cstr(str : UInt8*) : VALUE
+
+  # convert Ruby str to plain string
+  fun rb_str_to_str(value: VALUE) : VALUE
+
+  # convert plain string pointer to C string pointer
+  fun rb_string_value_cstr(value_ptr : VALUE*) : UInt8*
+
+  # define ruby class in C
+  fun rb_define_class(name: UInt8*, super: VALUE) : VALUE
+
+  # define ruby module in C
+  fun rb_define_module(name: UInt8*) : VALUE
+
+  # define ruby method in C
+  fun rb_define_method(klass: VALUE, name: UInt8*, func: METHOD_FUNC, argc: Int32)
+
+  # define singleton ruby method in C
+  fun rb_define_singleton_method(klass: VALUE, name: UInt8*, func: METHOD_FUNC, argc: Int32)
+end

data/ext/gloss/src/parser.cr

@@ -0,0 +1,340 @@
+require "compiler/crystal/syntax/*"
+require "./lexer"
+
+module Gloss
+  class Parser < Crystal::Parser
+    parse_operator :or_keyword, :and_keyword, "Or.new left, right", ":or"
+    parse_operator :and_keyword, :prefix, "And.new left, right", ":and"
+    parse_operator :not_keyword, :or_keyword, "Not.new parse_prefix", ":not"
+
+    def parse_empty_array_literal
+      line = @line_number
+      column = @token.column_number
+
+      # next_token_skip_space
+      # next_token_skip_space_or_newline
+      # of = nil
+      Crystal::ArrayLiteral.new([] of Crystal::ASTNode) # .at_end(of)
+    end
+
+    def new_hash_literal(entries, line, column, end_location, allow_of = true)
+      of = nil
+
+      if allow_of
+        if @token.keyword?(:of)
+          next_token_skip_space_or_newline
+          of_key = parse_bare_proc_type
+          check :"=>"
+          next_token_skip_space_or_newline
+          of_value = parse_bare_proc_type
+          of = Crystal::HashLiteral::Entry.new(of_key, of_value)
+          end_location = of_value.end_location
+        end
+
+        # if entries.empty? && !of
+        #   raise "for empty hashes use '{} of KeyType => ValueType'", line, column
+        # end
+      end
+
+      Crystal::HashLiteral.new(entries, of).at_end(end_location)
+    end
+
+    def parse_rescue
+      next_token_skip_space
+
+      if @token.type == :CONST || @token.type == :"::"
+        types = parse_rescue_types
+        skip_space
+      end
+
+      if @token.type == :"=>"
+        next_token_skip_space
+      end
+
+      if @token.type == :IDENT
+        name = @token.value.to_s
+        push_var_name name
+        next_token_skip_space
+      end
+
+      check SemicolonOrNewLine
+
+      next_token_skip_space_or_newline
+
+      if @token.keyword?(:end)
+        body = nil
+      else
+        body = parse_expressions
+        skip_statement_end
+      end
+
+      Crystal::Rescue.new(body, types, name)
+    end
+
+    def parse_rescue_types
+      types = [] of Crystal::ASTNode
+      while true
+        types << parse_generic
+        skip_space
+        if @token.type == :","
+          next_token_skip_space
+        else
+          skip_space
+          break
+        end
+      end
+      types
+    end
+
+    # def parse_arg(args, extra_assigns, parentheses, found_default_value, found_splat, found_double_splat, allow_restrictions)
+    #   if @token.type == :"&"
+    #     next_token_skip_space_or_newline
+    #     block_arg = parse_block_arg(extra_assigns)
+    #     skip_space_or_newline
+    #     # When block_arg.name is empty, this is an anonymous argument.
+    #     # An anonymous argument should not conflict other arguments names.
+    #     # (In fact `args` may contain anonymous splat argument. See #9108).
+    #     # So check is skipped.
+    #     unless block_arg.name.empty?
+    #       conflict_arg = args.any?(&.name.==(block_arg.name))
+    #       conflict_double_splat = found_double_splat && found_double_splat.name == block_arg.name
+    #       if conflict_arg || conflict_double_splat
+    #         raise "duplicated argument name: #{block_arg.name}", block_arg.location.not_nil!
+    #       end
+    #     end
+    #     return ArgExtras.new(block_arg, false, false, false)
+    #   end
+
+    #   if found_double_splat
+    #     raise "only block argument is allowed after double splat"
+    #   end
+
+    #   splat = false
+    #   double_splat = false
+    #   arg_location = @token.location
+    #   allow_external_name = true
+
+    #   case @token.type
+    #   when :"*"
+    #     if found_splat
+    #       unexpected_token
+    #     end
+
+    #     splat = true
+    #     allow_external_name = false
+    #     next_token_skip_space
+    #   when :"**"
+    #     double_splat = true
+    #     allow_external_name = false
+    #     next_token_skip_space
+    #   else
+    #     # not a splat
+    #   end
+
+    #   found_space = false
+
+    #   if splat && (@token.type == :"," || @token.type == :")")
+    #     arg_name = ""
+    #     uses_arg = false
+    #     allow_restrictions = false
+    #   else
+    #     arg_location = @token.location
+    #     arg_name, external_name, found_space, uses_arg = parse_arg_name(arg_location, extra_assigns, allow_external_name: allow_external_name)
+
+    #     args.each do |arg|
+    #       if arg.name == arg_name
+    #         raise "duplicated argument name: #{arg_name}", arg_location
+    #       end
+
+    #       if arg.external_name == external_name
+    #         raise "duplicated argument external name: #{external_name}", arg_location
+    #       end
+    #     end
+
+    #     if @token.type == :SYMBOL
+    #       raise "space required after colon in type restriction", @token
+    #     end
+    #   end
+
+    #   default_value = nil
+    #   restriction = nil
+    #   keyword_argument = @token.type == :":" && !found_space
+
+    #   found_colon = false
+
+    #   next_token_skip_space
+
+    #   if allow_restrictions && @token.type == :":"
+
+    #     next_token_skip_space_or_newline
+
+    #     location = @token.location
+    #     splat_restriction = false
+    #     if (splat && @token.type == :"*") || (double_splat && @token.type == :"**")
+    #       splat_restriction = true
+    #       next_token
+    #     end
+
+    #     restriction = parse_bare_proc_type
+
+    #     if splat_restriction
+    #       restriction = splat ? Crystal::Splat.new(restriction) : Crystal::DoubleSplat.new(restriction)
+    #       restriction.at(location)
+    #     end
+    #     found_colon = true
+    #   end
+
+    #   if @token.type == :"="
+    #     raise "splat argument can't have default value", @token if splat
+    #     raise "double splat argument can't have default value", @token if double_splat
+
+    #     slash_is_regex!
+    #     next_token_skip_space_or_newline
+
+    #     case @token.type
+    #     when :__LINE__, :__END_LINE__, :__FILE__, :__DIR__
+    #       default_value = Crystal::MagicConstant.new(@token.type).at(@token.location)
+    #       next_token
+    #     else
+    #       @no_type_declaration += 1
+    #       default_value = parse_op_assign
+    #       @no_type_declaration -= 1
+    #     end
+
+    #     skip_space
+    #   else
+    #     if found_default_value && !found_splat && !splat && !double_splat
+    #       raise "argument must have a default value", arg_location
+    #     end
+    #   end
+
+    #   unless found_colon
+    #     if @token.type == :SYMBOL
+    #       raise "the syntax for an argument with a default value V and type T is `arg : T = V`", @token
+    #     end
+
+    #     if allow_restrictions && @token.type == :":"
+    #       raise "the syntax for an argument with a default value V and type T is `arg : T = V`", @token
+    #     end
+    #   end
+
+    #   raise "BUG: arg_name is nil" unless arg_name
+
+    #   arg = Crystal::Arg.new(arg_name, default_value, restriction, external_name: external_name).at(arg_location)
+    #   arg.keyword_arg = keyword_argument
+    #   args << arg
+    #   push_var arg
+
+    #   Crystal::Parser::ArgExtras.new(nil, !!default_value, splat, !!double_splat)
+    # end
+
+    #def parse_arg_name(location, extra_assigns, allow_external_name)
+    #  do_next_token = true
+    #  found_string_literal = false
+    #  invalid_internal_name = nil
+
+    #  if allow_external_name && (@token.type == :IDENT || string_literal_start?)
+    #    if @token.type == :IDENT
+    #      if @token.keyword? && invalid_internal_name?(@token.value)
+    #        invalid_internal_name = @token.dup
+    #      end
+    #      external_name = @token.type == :IDENT ? @token.value.to_s : ""
+    #      next_token
+    #    else
+    #      external_name = parse_string_without_interpolation("external name")
+    #      found_string_literal = true
+    #    end
+    #    found_space = @token.type == :SPACE || @token.type == :NEWLINE
+    #    skip_space
+    #    do_next_token = false
+    #  end
+
+    #  case @token.type
+    #  when :IDENT
+    #    if @token.keyword? && invalid_internal_name?(@token.value)
+    #      raise "cannot use '#{@token}' as an argument name", @token
+    #    end
+
+    #    arg_name = @token.value.to_s
+    #    if arg_name == external_name
+    #      raise "when specified, external name must be different than internal name", @token
+    #    end
+
+    #    uses_arg = false
+    #    do_next_token = true
+    #  when :INSTANCE_VAR
+    #    arg_name = @token.value.to_s[1..-1]
+    #    if arg_name == external_name
+    #      raise "when specified, external name must be different than internal name", @token
+    #    end
+
+    #    # If it's something like @select, we can't transform it to:
+    #    #
+    #    #     @select = select
+    #    #
+    #    # because if someone uses `to_s` later it will produce invalid code.
+    #    # So we do something like:
+    #    #
+    #    # def method(select __arg0)
+    #    #   @select = __arg0
+    #    # end
+    #    if !external_name && invalid_internal_name?(arg_name)
+    #      arg_name, external_name = temp_arg_name, arg_name
+    #    end
+
+    #    ivar = Crystal::InstanceVar.new(@token.value.to_s).at(location)
+    #    var = Crystal::Var.new(arg_name).at(location)
+    #    assign = Crystal::Assign.new(ivar, var).at(location)
+    #    if extra_assigns
+    #      extra_assigns.push assign
+    #    else
+    #      raise "can't use @instance_variable here"
+    #    end
+    #    uses_arg = true
+    #    do_next_token = true
+    #  when :CLASS_VAR
+    #    arg_name = @token.value.to_s[2..-1]
+    #    if arg_name == external_name
+    #      raise "when specified, external name must be different than internal name", @token
+    #    end
+
+    #    # Same case as :INSTANCE_VAR for things like @select
+    #    if !external_name && invalid_internal_name?(arg_name)
+    #      arg_name, external_name = temp_arg_name, arg_name
+    #    end
+
+    #    cvar = Crystal::ClassVar.new(@token.value.to_s).at(location)
+    #    var = Crystal::Var.new(arg_name).at(location)
+    #    assign = Crystal::Assign.new(cvar, var).at(location)
+    #    if extra_assigns
+    #      extra_assigns.push assign
+    #    else
+    #      raise "can't use @@class_var here"
+    #    end
+    #    uses_arg = true
+    #    do_next_token = true
+    #  else
+    #    if external_name
+    #      if found_string_literal
+    #        raise "unexpected token: #{@token}, expected argument internal name"
+    #      end
+    #      if invalid_internal_name
+    #        raise "cannot use '#{invalid_internal_name}' as an argument name", invalid_internal_name
+    #      end
+    #      arg_name = external_name
+    #    else
+    #      raise "unexpected token: #{@token}"
+    #    end
+    #  end
+
+    #  if do_next_token
+    #    next_token
+    #    found_space = @token.type == :SPACE || @token.type == :NEWLINE
+    #  end
+
+    #  skip_space
+
+    #  {arg_name, external_name, found_space, uses_arg}
+    #end
+  end
+end

data/ext/gloss/src/rb_ast.cr

@@ -0,0 +1,491 @@
+require "compiler/crystal/syntax/*"
+require "json"
+
+module Rb
+  class AST
+    enum RbLiteral
+      String
+      Integer
+      TrueClass
+      FalseClass
+      NilClass
+      Float
+      Symbol
+    end
+
+    abstract class Node
+    end
+
+    abstract class NodeWithChildren < Node
+      @info : NamedTuple(type: String, children: Array(Node))
+
+      def initialize(@children : Array(Node))
+        @info = {
+          type:     self.class.name.split("::").last,
+          children: @children,
+        }
+      end
+
+      delegate :to_json, to: @info
+    end
+
+    abstract class NodeWithValue < Node
+      @info : NamedTuple(type: String, value: String)
+
+      def initialize(@value : String)
+        @info = {
+          type:  self.class.name.split("::").last,
+          value: @value,
+        }
+      end
+
+      delegate :to_json, to: @info
+    end
+
+    class Block < Node
+      @info : NamedTuple(type: String, args: Array(Var), body: Node)
+
+      def initialize(args, body)
+        @info = {
+          type: self.class.name.split("::").last,
+          body: body,
+          args: args,
+        }
+      end
+
+      delegate :to_json, to: @info
+    end
+
+    class CollectionNode < NodeWithChildren
+    end
+
+    class ClassNode < Node
+      @info : NamedTuple(type: String, name: Path, body: Node, superclass: Node?, type_vars: Array(String)?, abstract: Bool)
+
+      def initialize(name : Path, body : Node, superclass : Node?, type_vars : Array(String)?, abstr : Bool)
+        @info = {
+          type:       self.class.name.split("::").last,
+          name:       name,
+          body:       body,
+          superclass: superclass,
+          type_vars:  type_vars,
+          abstract:   abstr,
+          # visibility: vis,
+        }
+      end
+
+      delegate :to_json, to: @info
+    end
+
+    class ModuleNode < Node
+      @info : NamedTuple(type: String, name: Path, body: Node, type_vars: Array(String)?)
+
+      def initialize(name : Path, body : Node, type_vars : Array(String)?)
+        @info = {
+          type:      self.class.name.split("::").last,
+          name:      name,
+          body:      body,
+          type_vars: type_vars,
+          # visiblity:   vis,
+        }
+      end
+
+      delegate :to_json, to: @info
+    end
+
+    class DefNode < Node
+      @info : NamedTuple(type: String, name: String, body: Node, rp_args: Array(Arg), receiver: Node?,
+        return_type: Node?, rest_kw_args: Arg?)
+
+      def initialize(name : String, rp_args : Array(Arg), body : Node, receiver : Node?, return_type : Node?, rest_kw_args)
+        @info = {
+          type:         self.class.name.split("::").last,
+          name:         name,
+          body:         body,
+          rp_args:      rp_args,
+          rest_kw_args: rest_kw_args,
+          receiver:     receiver,
+          return_type:  return_type,
+        }
+      end
+
+      delegate :to_json, to: @info
+    end
+
+    class Arg < Node
+      @info : NamedTuple(type: String, name: String, external_name: String, default_value: Node?,
+        restriction: Node?)
+
+      def initialize(name : String, external_name : String, restriction : Node?, default_value : Node?)
+        @info = {
+          type:          self.class.name.split("::").last,
+          name:          name,
+          restriction:   restriction,
+          default_value: default_value,
+          external_name: external_name,
+        }
+      end
+
+      delegate :to_json, to: @info
+    end
+
+    class LiteralNode < Node
+      @info : NamedTuple(type: String, value: String | Int32 | Bool | Nil, rb_type: String)
+
+      def initialize(value, rb_type : RbLiteral)
+        val = case rb_type
+              when Rb::AST::RbLiteral::TrueClass
+                true
+              when Rb::AST::RbLiteral::FalseClass
+                false
+              when Rb::AST::RbLiteral::NilClass
+                nil
+              when Rb::AST::RbLiteral::Symbol
+                ":#{value}"
+              else
+                value
+              end
+        @info = {
+          type:    self.class.name.split("::").last,
+          value:   value,
+          rb_type: rb_type.inspect,
+        }
+      end
+
+      delegate :to_json, to: @info
+    end
+
+    class ArrayLiteral < Node
+      @info : NamedTuple(type: String, elements: Array(Node), frozen: Bool)
+
+      def initialize(elems, frozen = false)
+        @info = {
+          type:     self.class.name.split("::").last,
+          elements: elems,
+          frozen:   frozen,
+        }
+      end
+
+      delegate :to_json, to: @info
+    end
+
+    class HashLiteral < Node
+      @info : NamedTuple(type: String, elements: Array(Tuple(Node, Node)) | Array(Tuple(String, Node)), frozen: Bool)
+
+      def initialize(elems, frozen = false)
+        @info = {
+          type:     self.class.name.split("::").last,
+          elements: elems,
+          frozen:   frozen,
+        }
+      end
+
+      delegate :to_json, to: @info
+    end
+
+    class RangeLiteral < Node
+      @info : NamedTuple(type: String, from: Node, to: Node, exclusive: Bool)
+
+      def initialize(from, to, exclusive)
+        @info = {
+          type:      self.class.name.split("::").last,
+          from:      from,
+          to:        to,
+          exclusive: exclusive,
+        }
+      end
+
+      delegate :to_json, to: @info
+    end
+
+    class RegexLiteral < NodeWithValue
+    end
+
+    class Nop < Node
+      @info : NamedTuple(type: String)?
+
+      def initialize
+        @info = nil
+      end
+
+      delegate :to_json, to: @info
+    end
+
+    class EmptyNode < Nop
+      def initialize(class_name : String)
+        STDERR.puts "Encountered a ruby EmptyNode class name: #{class_name}"
+        @info = {
+          type: self.class.name.split("::").last,
+        }
+      end
+    end
+
+    class Var < Node
+      @info : NamedTuple(type: String, name: String)
+
+      def initialize(@name : String)
+        @info = {
+          type: self.class.name.split("::").last,
+          name: @name,
+        }
+      end
+
+      delegate :to_json, to: @info
+    end
+
+    class InstanceVar < Var
+    end
+
+    abstract class Conditional < Node
+      @info : NamedTuple(type: String, condition: Node, then: Node, else: Node)
+
+      def initialize(@condition : Node, @thn : Node, @els : Node)
+        @info = {
+          type:      self.class.name.split("::").last,
+          condition: @condition,
+          then:      @thn,
+          else:      @els,
+        }
+      end
+
+      delegate :to_json, to: @info
+    end
+
+    class If < Conditional
+    end
+
+    class Unless < Conditional
+    end
+
+    class Case < Node
+      @info : NamedTuple(type: String, condition: Node?, whens: Array(When), else: Node?, exhaustive: Bool)
+
+      def initialize(cond : Node?, whens : Array(When), els : Node?, exhaustive : Bool)
+        @info = {
+          type:       self.class.name.split("::").last,
+          condition:  cond,
+          whens:      whens,
+          else:       els,
+          exhaustive: exhaustive,
+        }
+      end
+
+      delegate :to_json, to: @info
+    end
+
+    class When < Node
+      @info : NamedTuple(type: String, conditions: Array(Node), body: Node, exhaustive: Bool)
+
+      def initialize(conds : Array(Node), body : Node, exhaustive : Bool)
+        @info = {
+          type:       self.class.name.split("::").last,
+          conditions: conds,
+          body:       body,
+          exhaustive: exhaustive,
+        }
+      end
+
+      delegate :to_json, to: @info
+    end
+
+    class Enum < Node
+      @info : NamedTuple(type: String, name: Crystal::Path, members: Array(Node))
+
+      def initialize(@name : Crystal::Path, @members : Array(Node))
+        @info = {
+          type:    self.class.name.split("::").last,
+          name:    @name,
+          members: @members,
+        }
+      end
+
+      delegate :to_json, to: @info
+    end
+
+    class Call < Node
+      @info : NamedTuple(type: String, name: String, args: Array(Node), object: Node?, block: Block?, block_arg: Node?)
+
+      def initialize(object : Node?, name : String, args : Array(Node), block, block_arg)
+        @info = {
+          type:      self.class.name.split("::").last,
+          name:      name,
+          args:      args,
+          object:    object,
+          block:     block,
+          block_arg: block_arg,
+        }
+      end
+
+      delegate :to_json, to: @info
+    end
+
+    class Path < NodeWithValue
+    end
+
+    class Require < NodeWithValue
+    end
+
+    class StringInterpolation < Node
+      @info : NamedTuple(type: String, contents: Array(Node))
+
+      def initialize(contents)
+        @info = {
+          type:     self.class.name.split("::").last,
+          contents: contents,
+        }
+      end
+
+      delegate :to_json, to: @info
+    end
+
+    class UnaryExpr < Node
+      @info : NamedTuple(type: String, op: String, value: Node, with_parens: Bool)
+
+      def initialize(val, op, parens)
+        @info = {
+          type:        self.class.name.split("::").last,
+          value:       val,
+          op:          op,
+          with_parens: parens,
+        }
+      end
+
+      delegate :to_json, to: @info
+    end
+
+    class BinaryOp < Node
+      @info : NamedTuple(type: String, op: String, left: Node, right: Node)
+
+      def initialize(op, left, right)
+        @info = {
+          type:  self.class.name.split("::").last,
+          left:  left,
+          op:    op,
+          right: right,
+        }
+      end
+
+      delegate :to_json, to: @info
+    end
+
+    class Assign < Node
+      @info : NamedTuple(type: String, op: String?, target: Node, value: Node)
+
+      def initialize(target, value, op = nil)
+        @info = {
+          type:   self.class.name.split("::").last,
+          target: target,
+          op:     op,
+          value:  value,
+        }
+      end
+
+      delegate :to_json, to: @info
+    end
+
+    class TypeDeclaration < Node
+      @info : NamedTuple(type: String, var: Node, declared_type: Node, value: Node?, var_type: String)
+
+      def initialize(@var : Node, @declared_type : Node, @value : Node?)
+        @info = {
+          type:          self.class.name.split("::").last,
+          var:           @var,
+          var_type:      @var.class.name.split("::").last,
+          declared_type: @declared_type,
+          value:         @value,
+        }
+      end
+
+      delegate :to_json, to: @info
+    end
+
+    class MacroFor < Node
+      @info : NamedTuple(type: String, vars: Array(Var), expr: Node, body: Node)
+
+      def initialize(vars, expr, body)
+        @info = {
+          type: self.class.name.split("::").last,
+          vars: vars,
+          expr: expr,
+          body: body,
+        }
+      end
+
+      delegate :to_json, to: @info
+    end
+
+    class MacroIf < Conditional
+    end
+
+    class MacroLiteral < NodeWithValue
+    end
+
+    class MacroExpression < Node
+      @info : NamedTuple(type: String, expr: Node, output: Bool)
+
+      def initialize(expr, output)
+        @info = {
+          type:   self.class.name.split("::").last,
+          expr:   expr,
+          output: output,
+        }
+      end
+
+      delegate :to_json, to: @info
+    end
+
+    class ControlExpression < Node
+      @info : NamedTuple(type: String, value: Node?)
+
+      def initialize(value)
+        @info = {
+          type:  self.class.name.split("::").last,
+          value: value,
+        }
+      end
+
+      delegate :to_json, to: @info
+    end
+
+    class Return < ControlExpression
+    end
+
+    class Break < ControlExpression
+    end
+
+    class Next < ControlExpression
+    end
+
+    class ExceptionHandler < Node
+      @info : NamedTuple(type: String, body: Node, rescues: Array(Rescue)?, else: Node?,
+        ensure: Node?)
+
+      def initialize(body, rescues, else_node, ensure_node)
+        @info = {
+          type:    self.class.name.split("::").last,
+          body:    body,
+          rescues: rescues,
+          else:    else_node,
+          ensure:  ensure_node,
+        }
+      end
+
+      delegate :to_json, to: @info
+    end
+
+    class Rescue < Node
+      @info : NamedTuple(type: String, body: Node, types: Array(Node)?, name: String?)
+
+      def initialize(body, types, name)
+        @info = {
+          type:  self.class.name.split("::").last,
+          body:  body,
+          types: types,
+          name:  name,
+        }
+      end
+
+      delegate :to_json, to: @info
+    end
+  end
+end