gloss 0.0.2 → 0.1.0

data/ext/gloss/src/gloss.cr

@@ -1,4 +1,5 @@
-require "./lib/cr_ruby"
+require "../lib/cr_ruby"
+require "../lib/rbs_types"
 require "./cr_ast"
 require "./rb_ast"
 require "./parser"
@@ -10,7 +11,6 @@ def parse_string(self : CrRuby::VALUE, str : CrRuby::VALUE)
   output = begin
              Gloss.parse_string(string)
            rescue e : Crystal::SyntaxException
-             pp e.backtrace
              e.to_s
            end
 

data/ext/gloss/src/lexer.cr

@@ -115,7 +115,7 @@ module Crystal
           case next_char
           when '='
             next_char :"<<="
-          when '-'
+          when '-', '~'
             has_single_quote = false
             found_closing_single_quote = false
 
@@ -1182,5 +1182,63 @@ module Crystal
 
       @token
     end
+
+    def check_heredoc_start
+      return nil unless current_char == '<' && next_char == '<' && {'-', '~'}.includes?(next_char)
+
+      has_single_quote = false
+      found_closing_single_quote = false
+
+      char = next_char
+      start_here = current_pos
+
+      if char == '\''
+        has_single_quote = true
+        char = next_char
+        start_here = current_pos
+      end
+
+      return nil unless ident_part?(char)
+
+      end_here = 0
+
+      while true
+        char = next_char
+        case
+        when char == '\r'
+          if peek_next_char == '\n'
+            end_here = current_pos
+            next_char
+            break
+          else
+            return nil
+          end
+        when char == '\n'
+          end_here = current_pos
+          break
+        when ident_part?(char)
+          # ok
+        when char == '\0'
+          return nil
+        else
+          if char == '\'' && has_single_quote
+            found_closing_single_quote = true
+            end_here = current_pos
+            next_char
+            break
+          elsif has_single_quote
+            # wait until another quote
+          else
+            end_here = current_pos
+            break
+          end
+        end
+      end
+
+      return nil if has_single_quote && !found_closing_single_quote
+
+      here = string_range(start_here, end_here)
+      Token::DelimiterState.new(:heredoc, here, here, allow_escapes: !has_single_quote)
+    end
   end
 end

data/ext/gloss/src/parser.cr

@@ -17,10 +17,10 @@ module Gloss
       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)
+      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)

data/ext/gloss/src/rb_ast.cr

@@ -19,7 +19,7 @@ module Rb
     abstract class NodeWithChildren < Node
       @info : NamedTuple(type: String, children: Array(Node))
 
-      def initialize(@children : Array(Node))
+      def initialize(@children : Array(Node), location : Crystal::Location?)
         @info = {
           type:     self.class.name.split("::").last,
           children: @children,
@@ -32,7 +32,7 @@ module Rb
     abstract class NodeWithValue < Node
       @info : NamedTuple(type: String, value: String)
 
-      def initialize(@value : String)
+      def initialize(@value : String, location : Crystal::Location?)
         @info = {
           type:  self.class.name.split("::").last,
           value: @value,
@@ -43,13 +43,14 @@ module Rb
     end
 
     class Block < Node
-      @info : NamedTuple(type: String, args: Array(Var), body: Node)
+      @info : NamedTuple(type: String, positional_args: Array(Var), body: Node, rest_p_args: Node?)
 
-      def initialize(args, body)
+      def initialize(args, splat, body, location : Crystal::Location?)
         @info = {
           type: self.class.name.split("::").last,
           body: body,
-          args: args,
+          positional_args: args,
+          rest_p_args: splat
         }
       end
 
@@ -62,7 +63,7 @@ module Rb
     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)
+      def initialize(name : Path, body : Node, superclass : Node?, type_vars : Array(String)?, abstr : Bool, location : Crystal::Location?)
         @info = {
           type:       self.class.name.split("::").last,
           name:       name,
@@ -80,7 +81,7 @@ module Rb
     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)?)
+      def initialize(name : Path, body : Node, type_vars : Array(String)?, location : Crystal::Location?)
         @info = {
           type:      self.class.name.split("::").last,
           name:      name,
@@ -94,18 +95,32 @@ module Rb
     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 : NamedTuple(type: String, name: String, body: Node, positional_args: Array(Arg), receiver: Node?,
+        return_type: Node?, rest_kw_args: Arg?, rest_p_args: Arg?, block_arg: Node?, yield_arg_count: Int32?)
+
+      def initialize(
+        receiver : Node?,
+        name : String,
+        positional_args : Array(Arg),
+        splat,
+        rest_kw_args,
+        body : Node,
+        return_type : Node?,
+        yields : Int32?,
+        block_arg : Node?,
+        location : Crystal::Location?
+      )
         @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,
+          type:            self.class.name.split("::").last,
+          name:            name,
+          body:            body,
+          positional_args: positional_args,
+          rest_kw_args:    rest_kw_args,
+          receiver:        receiver,
+          return_type:     return_type,
+          rest_p_args:     splat,
+          yield_arg_count: yields,
+          block_arg: block_arg
         }
       end
 
@@ -113,18 +128,18 @@ module Rb
     end
 
     class Arg < Node
-      @info : NamedTuple(type: String, name: String, external_name: String, default_value: Node?,
+      @info : NamedTuple(type: String, name: String, external_name: String, value: Node?,
         restriction: Node?, keyword_arg: Bool)
 
-      def initialize(name : String, external_name : String, restriction : Node?, default_value :
-          Node?, keyword_arg)
+      def initialize(name : String, external_name : String, restriction : Node?, value : Node?,
+          keyword_arg, location : Crystal::Location?)
         @info = {
           type:          self.class.name.split("::").last,
           name:          name,
           restriction:   restriction,
-          default_value: default_value,
+          value:         value,
           external_name: external_name,
-          keyword_arg: keyword_arg
+          keyword_arg:   keyword_arg,
         }
       end
 
@@ -134,7 +149,7 @@ module Rb
     class LiteralNode < Node
       @info : NamedTuple(type: String, value: String | Int32 | Bool | Nil, rb_type: String)
 
-      def initialize(value, rb_type : RbLiteral)
+      def initialize(value, rb_type : RbLiteral, location : Crystal::Location?)
         val = case rb_type
               when Rb::AST::RbLiteral::TrueClass
                 true
@@ -160,7 +175,7 @@ module Rb
     class ArrayLiteral < Node
       @info : NamedTuple(type: String, elements: Array(Node), frozen: Bool)
 
-      def initialize(elems, frozen = false)
+      def initialize(elems, location : Crystal::Location?, frozen = false)
         @info = {
           type:     self.class.name.split("::").last,
           elements: elems,
@@ -174,7 +189,7 @@ module Rb
     class HashLiteral < Node
       @info : NamedTuple(type: String, elements: Array(Tuple(Node, Node)) | Array(Tuple(String, Node)), frozen: Bool)
 
-      def initialize(elems, frozen = false)
+      def initialize(elems, location : Crystal::Location?, frozen = false)
         @info = {
           type:     self.class.name.split("::").last,
           elements: elems,
@@ -188,7 +203,7 @@ module Rb
     class RangeLiteral < Node
       @info : NamedTuple(type: String, from: Node, to: Node, exclusive: Bool)
 
-      def initialize(from, to, exclusive)
+      def initialize(from, to, exclusive, location : Crystal::Location?)
         @info = {
           type:      self.class.name.split("::").last,
           from:      from,
@@ -200,7 +215,17 @@ module Rb
       delegate :to_json, to: @info
     end
 
-    class RegexLiteral < NodeWithValue
+    class RegexLiteral < Node
+      @info : NamedTuple(type: String, value: Node)
+
+      def initialize(value, location : Crystal::Location?)
+        @info = {
+          type:  self.class.name.split("::").last,
+          value: value,
+        }
+      end
+
+      delegate :to_json, to: @info
     end
 
     class Nop < Node
@@ -214,7 +239,7 @@ module Rb
     end
 
     class EmptyNode < Nop
-      def initialize(class_name : String)
+      def initialize(class_name : String, location : Crystal::Location?)
         STDERR.puts "Encountered a ruby EmptyNode class name: #{class_name}"
         @info = {
           type: self.class.name.split("::").last,
@@ -225,7 +250,7 @@ module Rb
     class Var < Node
       @info : NamedTuple(type: String, name: String)
 
-      def initialize(@name : String)
+      def initialize(@name : String, location : Crystal::Location?)
         @info = {
           type: self.class.name.split("::").last,
           name: @name,
@@ -244,7 +269,7 @@ module Rb
     abstract class Conditional < Node
       @info : NamedTuple(type: String, condition: Node, then: Node, else: Node)
 
-      def initialize(@condition : Node, @thn : Node, @els : Node)
+      def initialize(@condition : Node, @thn : Node, @els : Node, location : Crystal::Location?)
         @info = {
           type:      self.class.name.split("::").last,
           condition: @condition,
@@ -265,7 +290,7 @@ module Rb
     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)
+      def initialize(cond : Node?, whens : Array(When), els : Node?, exhaustive : Bool, location : Crystal::Location?)
         @info = {
           type:       self.class.name.split("::").last,
           condition:  cond,
@@ -281,7 +306,7 @@ module Rb
     class When < Node
       @info : NamedTuple(type: String, conditions: Array(Node), body: Node, exhaustive: Bool)
 
-      def initialize(conds : Array(Node), body : Node, exhaustive : Bool)
+      def initialize(conds : Array(Node), body : Node, exhaustive : Bool, location : Crystal::Location?)
         @info = {
           type:       self.class.name.split("::").last,
           conditions: conds,
@@ -296,7 +321,7 @@ module Rb
     class Enum < Node
       @info : NamedTuple(type: String, name: Crystal::Path, members: Array(Node))
 
-      def initialize(@name : Crystal::Path, @members : Array(Node))
+      def initialize(@name : Crystal::Path, @members : Array(Node), location : Crystal::Location?)
         @info = {
           type:    self.class.name.split("::").last,
           name:    @name,
@@ -308,16 +333,18 @@ module Rb
     end
 
     class Call < Node
-      @info : NamedTuple(type: String, name: String, args: Array(Node), object: Node?, block: Block?, block_arg: Node?)
+      @info : NamedTuple(type: String, name: String, args: Array(Node), object: Node?, block: Block?, block_arg: Node?, named_args: Array(Arg)?, has_parentheses: Bool)
 
-      def initialize(object : Node?, name : String, args : Array(Node), block, block_arg)
+      def initialize(object : Node?, name : String, args : Array(Node), named_args, block, block_arg, has_parentheses, location : Crystal::Location?)
         @info = {
-          type:      self.class.name.split("::").last,
-          name:      name,
-          args:      args,
-          object:    object,
-          block:     block,
-          block_arg: block_arg,
+          type:            self.class.name.split("::").last,
+          name:            name,
+          args:            args,
+          object:          object,
+          block:           block,
+          block_arg:       block_arg,
+          named_args:      named_args,
+          has_parentheses: has_parentheses || false,
         }
       end
 
@@ -333,7 +360,7 @@ module Rb
     class StringInterpolation < Node
       @info : NamedTuple(type: String, contents: Array(Node))
 
-      def initialize(contents)
+      def initialize(contents, location : Crystal::Location?)
         @info = {
           type:     self.class.name.split("::").last,
           contents: contents,
@@ -346,7 +373,7 @@ module Rb
     class UnaryExpr < Node
       @info : NamedTuple(type: String, op: String, value: Node, with_parens: Bool)
 
-      def initialize(val, op, parens)
+      def initialize(val, op, parens, location : Crystal::Location?)
         @info = {
           type:        self.class.name.split("::").last,
           value:       val,
@@ -361,7 +388,7 @@ module Rb
     class BinaryOp < Node
       @info : NamedTuple(type: String, op: String, left: Node, right: Node)
 
-      def initialize(op, left, right)
+      def initialize(op, left, right, location : Crystal::Location?)
         @info = {
           type:  self.class.name.split("::").last,
           left:  left,
@@ -376,7 +403,7 @@ module Rb
     class Assign < Node
       @info : NamedTuple(type: String, op: String?, target: Node, value: Node)
 
-      def initialize(target, value, op = nil)
+      def initialize(target, value, op, location : Crystal::Location?)
         @info = {
           type:   self.class.name.split("::").last,
           target: target,
@@ -388,10 +415,24 @@ module Rb
       delegate :to_json, to: @info
     end
 
+    class MultiAssign < Node
+      @info : NamedTuple(type: String, targets: Array(Node), values: Array(Node))
+
+      def initialize(targets, values, location : Crystal::Location?)
+        @info = {
+          type:    self.class.name.split("::").last,
+          targets: targets,
+          values:  values,
+        }
+      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?)
+      def initialize(@var : Node, @declared_type : Node, @value : Node?, location : Crystal::Location?)
         @info = {
           type:          self.class.name.split("::").last,
           var:           @var,
@@ -407,7 +448,7 @@ module Rb
     class MacroFor < Node
       @info : NamedTuple(type: String, vars: Array(Var), expr: Node, body: Node)
 
-      def initialize(vars, expr, body)
+      def initialize(vars, expr, body, location : Crystal::Location?)
         @info = {
           type: self.class.name.split("::").last,
           vars: vars,
@@ -428,7 +469,7 @@ module Rb
     class MacroExpression < Node
       @info : NamedTuple(type: String, expr: Node, output: Bool)
 
-      def initialize(expr, output)
+      def initialize(expr, output, location : Crystal::Location?)
         @info = {
           type:   self.class.name.split("::").last,
           expr:   expr,
@@ -442,7 +483,7 @@ module Rb
     class ControlExpression < Node
       @info : NamedTuple(type: String, value: Node?)
 
-      def initialize(value)
+      def initialize(value, location : Crystal::Location?)
         @info = {
           type:  self.class.name.split("::").last,
           value: value,
@@ -465,7 +506,7 @@ module Rb
       @info : NamedTuple(type: String, body: Node, rescues: Array(Rescue)?, else: Node?,
         ensure: Node?)
 
-      def initialize(body, rescues, else_node, ensure_node)
+      def initialize(body, rescues, else_node, ensure_node, location : Crystal::Location?)
         @info = {
           type:    self.class.name.split("::").last,
           body:    body,
@@ -481,7 +522,7 @@ module Rb
     class Rescue < Node
       @info : NamedTuple(type: String, body: Node, types: Array(Node)?, name: String?)
 
-      def initialize(body, types, name)
+      def initialize(body, types, name, location : Crystal::Location?)
         @info = {
           type:  self.class.name.split("::").last,
           body:  body,
@@ -496,10 +537,10 @@ module Rb
     class Union < Node
       @info : NamedTuple(type: String, types: Array(Node))
 
-      def initialize(types)
+      def initialize(types, location : Crystal::Location?)
         @info = {
           type:  self.class.name.split("::").last,
-          types: types
+          types: types,
         }
       end
 
@@ -509,11 +550,65 @@ module Rb
     class Generic < Node
       @info : NamedTuple(type: String, name: Node, args: Array(Node))
 
-      def initialize(name, args)
+      def initialize(name, args, location : Crystal::Location?)
         @info = {
-          type:  self.class.name.split("::").last,
+          type: self.class.name.split("::").last,
+          name: name,
+          args: args,
+        }
+      end
+
+      delegate :to_json, to: @info
+    end
+
+    class Proc < Node
+      @info : NamedTuple(type: String, function: DefNode)
+
+      def initialize(function, location : Crystal::Location?)
+        @info = {
+          type:     self.class.name.split("::").last,
+          function: function,
+        }
+      end
+
+      delegate :to_json, to: @info
+    end
+
+    class NodeWithNameNode < Node
+      @info : NamedTuple(type: String, name: Node)
+
+      def initialize(name, location : Crystal::Location?)
+        @info = {
+          type: self.class.name.split("::").last,
           name: name,
-          args: args
+        }
+      end
+
+      delegate :to_json, to: @info
+    end
+
+    class Extend < NodeWithNameNode
+    end
+
+    class Include < NodeWithNameNode
+    end
+
+    class VisibilityModifier < Node
+      @info : NamedTuple(type: String, visibility: String, exp: Node)
+
+      def initialize(visibility : Crystal::Visibility, exp : Node, location : Crystal::Location?)
+        vis = case visibility
+              when Crystal::Visibility::Public
+                "public"
+              when Crystal::Visibility::Protected
+                "protected"
+              when Crystal::Visibility::Private
+                "private"
+              end
+        @info = {
+          type:       self.class.name.split("::").last,
+          visibility: vis.as(String),
+          exp:        exp,
         }
       end