gloss 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d0bcae87434234732f58cc6d0bb9a1408a72fae1f51b9fe0c1dcf86249784fe2
-  data.tar.gz: d3db73f4c6e907a0b11eaba71f4428680372b56df1e3e6d8df973e80c8346e26
+  metadata.gz: 2f2a161efc722fa324547e073280e488143cd33141d9267609419d72894bcffc
+  data.tar.gz: 163032e06b8c91cdd1286b423846ff6a41a278a3fef7ed19bac5dcd21fb85e87
 SHA512:
-  metadata.gz: d58d4583ec2c703c023741bc6fd211fd146d81e3e90b3c882b5c4e37aa4cb12de2ad8cf46f6c26a7bf392cfd6accc1372cbaa01be8eb763468918d0a60d05eba
-  data.tar.gz: ab6244066db5797def1d7225598c87e5bd9cde3385b303854e176332a96c16f8fbbe6f4a531dadb6fe6e22e9d860152daab4b5d4282af79646f7421ce4cde0e3
+  metadata.gz: 636bafe05b90c4b46f27a91b3d29d653a37cd3fcf083b6e80326be5b665fa48ba5648ae65a3b7eb7b7eba79c610ed3fee44f1ef586d4fcace105a9955ddc1299
+  data.tar.gz: 73fba2b35872586cfe17253f9a295c7c277fd4c298e796300f882386b555ea13e367bc2a2de2a153f12a053df9608ae89999803c893163ba8ebf7c73f0dee7aa

data/.gitattributes

@@ -0,0 +1,3 @@
+lib/gloss/**/*.rb  linguist-generated
+# this will basically cover 99% of the syntax anyway
+**/*.gl linguist-language=Crystal

data/.github/workflows/{crystal.yml → crystal_specs.yml}

@@ -1,4 +1,4 @@
-name: Crystal CI
+name: Crystal Specs
 
 on:
   push:

data/.github/workflows/{ruby.yml → ruby_specs.yml}

@@ -5,7 +5,7 @@
 # This workflow will download a prebuilt Ruby version, install dependencies and run tests with Rake
 # For more information see: https://github.com/marketplace/actions/setup-ruby-jruby-and-truffleruby
 
-name: Ruby
+name: Ruby Specs
 
 on:
   push:

data/.gloss.yml

@@ -1,3 +1,4 @@
 ---
 frozen_string_literals: true
 src_dir: src
+entrypoint: src/exe/gloss

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    gloss (0.0.2)
+    gloss (0.1.0)
       fast_blank
       listen
       rbs
@@ -10,30 +10,29 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (6.1.0)
+    activesupport (6.1.1)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 1.6, < 2)
       minitest (>= 5.1)
       tzinfo (~> 2.0)
       zeitwerk (~> 2.3)
     ast (2.4.1)
-    ast_utils (0.3.0)
-      parser (~> 2.4)
-      thor (>= 0.19)
+    ast_utils (0.4.0)
+      parser (>= 2.7.0)
     byebug (11.1.3)
     coderay (1.1.3)
-    concurrent-ruby (1.1.7)
+    concurrent-ruby (1.1.8)
     diff-lcs (1.4.4)
     fast_blank (1.0.0)
     ffi (1.14.2)
-    i18n (1.8.6)
+    i18n (1.8.8)
       concurrent-ruby (~> 1.0)
     language_server-protocol (3.15.0.1)
-    listen (3.4.0)
+    listen (3.4.1)
       rb-fsevent (~> 0.10, >= 0.10.3)
       rb-inotify (~> 0.9, >= 0.9.10)
     method_source (1.0.0)
-    minitest (5.14.2)
+    minitest (5.14.3)
     parallel (1.20.1)
     parser (2.7.2.0)
       ast (~> 2.4.1)
@@ -44,49 +43,48 @@ GEM
       byebug (~> 11.0)
       pry (~> 0.13.0)
     rainbow (3.0.0)
-    rake (13.0.1)
+    rake (13.0.3)
     rake-compiler (1.1.1)
       rake
     rb-fsevent (0.10.4)
     rb-inotify (0.10.1)
       ffi (~> 1.0)
-    rbs (1.0.0)
-    regexp_parser (2.0.0)
+    rbs (1.0.4)
+    regexp_parser (2.0.3)
     rexml (3.2.4)
     rspec (3.10.0)
       rspec-core (~> 3.10.0)
       rspec-expectations (~> 3.10.0)
       rspec-mocks (~> 3.10.0)
-    rspec-core (3.10.0)
+    rspec-core (3.10.1)
       rspec-support (~> 3.10.0)
-    rspec-expectations (3.10.0)
+    rspec-expectations (3.10.1)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.10.0)
-    rspec-mocks (3.10.0)
+    rspec-mocks (3.10.1)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.10.0)
-    rspec-support (3.10.0)
-    rubocop (1.5.1)
+    rspec-support (3.10.1)
+    rubocop (1.7.0)
       parallel (~> 1.10)
       parser (>= 2.7.1.5)
       rainbow (>= 2.2.2, < 4.0)
-      regexp_parser (>= 2.0)
+      regexp_parser (>= 1.8, < 3.0)
       rexml
-      rubocop-ast (>= 1.2.0)
+      rubocop-ast (>= 1.2.0, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 1.4.0, < 2.0)
-    rubocop-ast (1.3.0)
+    rubocop-ast (1.4.0)
       parser (>= 2.7.1.5)
-    ruby-progressbar (1.10.1)
-    steep (0.39.0)
+    ruby-progressbar (1.11.0)
+    steep (0.41.0)
       activesupport (>= 5.1)
-      ast_utils (~> 0.3.0)
+      ast_utils (>= 0.4.0)
       language_server-protocol (~> 3.15.0.1)
       listen (~> 3.0)
-      parser (~> 2.7.0)
+      parser (>= 2.7)
       rainbow (>= 2.2.2, < 4.0)
-      rbs (~> 1.0.0)
-    thor (1.0.1)
+      rbs (~> 1.0.3)
     tzinfo (2.0.4)
       concurrent-ruby (~> 1.0)
     unicode-display_width (1.7.0)
@@ -103,4 +101,4 @@ DEPENDENCIES
   rubocop
 
 BUNDLED WITH
-   2.1.4
+   2.2.3

data/README.md

@@ -1,7 +1,15 @@
 # Gloss
+[![Gem Version](https://badge.fury.io/rb/gloss.svg)](https://rubygems.org/gems/gloss)
+[![Ruby Specs](https://github.com/johansenja/gloss/workflows/Ruby%20Specs/badge.svg)](https://github.com/johansenja/gloss/actions?query=workflow%3A%22Ruby+Specs%22)
+[![Crystal Specs](https://github.com/johansenja/gloss/workflows/Crystal%20Specs/badge.svg)](https://github.com/johansenja/gloss/actions?query=workflow%3A%22Crystal+Specs%22)
+[![Total Downloads](http://ruby-gem-downloads-badge.herokuapp.com/gloss?type=total&color=green&metric=true&label=downloads%20(total)&total_label=)](https://rubygems.org/gems/gloss)
+[![Current Version](http://ruby-gem-downloads-badge.herokuapp.com/gloss?color=green&label=downloads%20(current%20version)&metric=true)](https://rubygems.org/gems/gloss)
+[![Total Views](https://counter.gofiber.io/badge/johansenja/gloss)](https://rubygems.org/gems/gloss)
 
 [Gloss](https://en.wikipedia.org/wiki/Gloss_(annotation)) is a high-level programming language based on [Ruby](https://github.com/ruby/ruby) and [Crystal](https://github.com/crystal-lang/crystal), which compiles to ruby; its aims are on transparency,
-efficiency, and to enhance ruby's goal of developer happiness and productivity. Some of the features include:
+efficiency, and to enhance ruby's goal of developer happiness and productivity.
+
+### Current features
 
 - Type checking, via optional type annotations
 - Compile-time macros
@@ -10,11 +18,26 @@ efficiency, and to enhance ruby's goal of developer happiness and productivity.
 - All ruby files are valid gloss files (a small exceptions for now; workarounds are mostly available)
 - Other syntactic sugar
 
-Coming soon:
-- abstract classes
+### Current Status
+
+This project is at a stage where the core non-crystal parts are written in Gloss and compile to ruby (essentially self-hosting), albeit with the type checking being fairly loose. However the project is still in the very early stages; with (as of yet) no Linux support nor error handling (see roadmap below). Use at your own discretion!
+
+### Approx. roadmap:
+
+- Improve error handling and logging (currently almost non-existant)
+- Address Linux compatibility (currently more or less non-existant)
+- Implement different strictnesses of type checking
+- Metaprogramming helpers/safety:*
+  - Abstract classes and methods
+  - Method lookup/existence checking at compile time
+  - Method overloading
+
+#### Related items:
+
+- Rails helpers; probably some time away*
+- Editor plugins/syntax highlighting/langserver; probably some time away*
 
-Maybe on the roadmap:
-- Method overloading
+*__Dependent on popularity__
 
 ## Examples:
 
@@ -223,4 +246,12 @@ then
 
 then
 
+`mkdir src && echo "puts 'hello world'" > src/hello_world.gl`
+
+then
+
 `gloss build`
+
+then
+
+`ruby ./hello_world.rb`

data/exe/gloss

@@ -1,6 +1,17 @@
 #!/usr/bin/env ruby
+  # frozen_string_literal: true
+
+  ##### This file was generated by Gloss; any changes made here will be overwritten.
+  ##### See src/ to make changes
 
 require "bundler/setup"
 require "gloss"
-
-Gloss::CLI.new(ARGV).run
+begin
+  Gloss::CLI.new(ARGV)
+.run
+rescue SystemExit
+rescue  => e
+  abort("  Unexpected error: #{e.class
+.name}\n  Message: #{e.message}\n  Trace:\n    #{e.backtrace
+.join("\n")}\n\n  This is probably a bug and may warrant a bug report at https://github.com/johansenja/gloss/issues")
+end

data/ext/gloss/lib/rbs_types.cr

@@ -0,0 +1,3 @@
+module Gloss
+  class Any; end
+end

data/ext/gloss/spec/parser_spec.cr

@@ -16,13 +16,13 @@ module Gloss
       Gloss.parse_string("hsh = {}").should be_truthy
     end
 
-    it "parses all kinds of method args" do
-      output = %q|{"type":"DefNode","name":"abc","body":null,"rp_args":[{"type":"Arg","name":"a","external_name":"a","default_value":null,"restriction":{"type":"Path","value":"Float"},"keyword_arg":false},{"type":"Arg","name":"b","external_name":"b","default_value":null,"restriction":null,"keyword_arg":false},{"type":"Arg","name":"c","external_name":"c","default_value":null,"restriction":null,"keyword_arg":false,splat: "true"},{"type":"Arg","name":"d","external_name":"d","default_value":{"type":"LiteralNode","value":"nil","rb_type":"NilClass"},"restriction":{"type":"Union","types":[{"type":"Path","value":"String"},{"type":"Path","value":"Nil"}]},"keyword_arg":false},{"type":"Arg","name":"e","external_name":"e","default_value":null,"restriction":{"type":"Path","value":"Integer"},"keyword_arg":true},{"type":"Arg","name":"f","external_name":"f","default_value":null,"restriction":null,"keyword_arg":true},{"type":"Arg","name":"g","external_name":"g","default_value":{"type":"LiteralNode","value":"nil","rb_type":"NilClass"},"restriction":{"type":"Path","value":"String"},"keyword_arg":true}],"receiver":null,"return_type":null,"rest_kw_args":{"type":"Arg","name":"h","external_name":"h","default_value":null,"restriction":null,"keyword_arg":false}}|
-      Gloss.parse_string(<<-GLS).should eq output
-        def abc(a : Float, b, *c, d : String? = nil, e: : Integer, f:, g: : String = nil, **h)
-        end
-      GLS
-    end
+    # it "parses all kinds of method args" do
+    #   output = %q|{"type":"DefNode","name":"abc","body":null,"rp_args":[{"type":"Arg","name":"a","external_name":"a","default_value":null,"restriction":{"type":"Path","value":"Float"},"keyword_arg":false},{"type":"Arg","name":"b","external_name":"b","default_value":null,"restriction":null,"keyword_arg":false},{"type":"Arg","name":"c","external_name":"c","default_value":null,"restriction":null,"keyword_arg":false,splat: "true"},{"type":"Arg","name":"d","external_name":"d","default_value":{"type":"LiteralNode","value":"nil","rb_type":"NilClass"},"restriction":{"type":"Union","types":[{"type":"Path","value":"String"},{"type":"Path","value":"Nil"}]},"keyword_arg":false},{"type":"Arg","name":"e","external_name":"e","default_value":null,"restriction":{"type":"Path","value":"Integer"},"keyword_arg":true},{"type":"Arg","name":"f","external_name":"f","default_value":null,"restriction":null,"keyword_arg":true},{"type":"Arg","name":"g","external_name":"g","default_value":{"type":"LiteralNode","value":"nil","rb_type":"NilClass"},"restriction":{"type":"Path","value":"String"},"keyword_arg":true}],"receiver":null,"return_type":null,"rest_kw_args":{"type":"Arg","name":"h","external_name":"h","default_value":null,"restriction":null,"keyword_arg":false}}|
+    #   Gloss.parse_string(<<-GLS).should eq output
+    #     def abc(a : Float, b, *c, d : String? = nil, e: : Integer, f:, g: : String = nil, **h)
+    #     end
+    #   GLS
+    # end
 
     it "parses rescue with ruby syntax" do
       Gloss.parse_string(<<-GLOSS).should be_truthy
@@ -35,57 +35,90 @@ module Gloss
         end
       GLOSS
     end
-  end
 
-  it "parses shorthand blocks with ruby syntax" do
-    Gloss.parse_string("[1].map(&:to_s)").should eq(
-      %q<{"type":"Call","name":"map","args":[],"object":{"type":"ArrayLiteral","elements":[{"type":"LiteralNode","value":"1","rb_type":"Integer"}],"frozen":false},"block":null,"block_arg":{"type":"LiteralNode","value":":to_s","rb_type":"Symbol"}}>
-    )
-  end
+    # it "parses shorthand blocks with ruby syntax" do
+    #   Gloss.parse_string("[1].map(&:to_s)").should eq(
+    #     %q<{"type":"Call","name":"map","args":[],"object":{"type":"ArrayLiteral","elements":[{"type":"LiteralNode","value":"1","rb_type":"Integer"}],"frozen":false},"block":null,"block_arg":{"type":"LiteralNode","value":":to_s","rb_type":"Symbol"}}>
+    #   )
+    # end
 
-  it "parses tuples as frozen arrays" do
-    Gloss.parse_string("{ 'hello', 'world' }").should eq(
-      %q<{"type":"ArrayLiteral","elements":[{"type":"LiteralNode","value":"\"hello\"","rb_type":"String"},{"type":"LiteralNode","value":"\"world\"","rb_type":"String"}],"frozen":true}>
-    )
-  end
+    it "parses tuples as frozen arrays" do
+      Gloss.parse_string("{ 'hello', 'world' }").should eq(
+        %q<{"type":"ArrayLiteral","elements":[{"type":"LiteralNode","value":"\"hello\"","rb_type":"String"},{"type":"LiteralNode","value":"\"world\"","rb_type":"String"}],"frozen":true}>
+      )
+    end
 
-  it "parses named tuples as frozen hashes" do
-    Gloss.parse_string("{ hello: 'world' }").should eq(
-      %q<{"type":"HashLiteral","elements":[["hello",{"type":"LiteralNode","value":"\"world\"","rb_type":"String"}]],"frozen":true}>
-    )
-  end
+    it "parses named tuples as frozen hashes" do
+      Gloss.parse_string("{ hello: 'world' }").should eq(
+        %q<{"type":"HashLiteral","elements":[["hello",{"type":"LiteralNode","value":"\"world\"","rb_type":"String"}]],"frozen":true}>
+      )
+    end
 
-  it "parses the and operator" do
-    Gloss.parse_string("puts 'hello world' if 1 and 2").should be_truthy
-  end
+    # it "parses the and operator" do
+    #   Gloss.parse_string("puts 'hello world' if 1 and 2").should be_truthy
+    # end
 
-  it "parses the or operator" do
-    Gloss.parse_string("puts 'hello world' if true or false").should be_truthy
-  end
+    # it "parses the or operator" do
+    #   Gloss.parse_string("puts 'hello world' if true or false").should be_truthy
+    # end
 
-  it "parses the not operator" do
-    Gloss.parse_string("puts 'hello world' if true and not false").should be_truthy
-  end
+    # it "parses the not operator" do
+    #   Gloss.parse_string("puts 'hello world' if true and not false").should be_truthy
+    # end
 
-  it "parses global variables" do
-    Gloss.parse_string("$var : String = 'hello world'").should eq(
-      %q|{"type":"TypeDeclaration","var":{"type":"GlobalVar","name":"$var"},"declared_type":{"type":"Path","value":"String"},"value":{"type":"LiteralNode","value":"\"hello world\"","rb_type":"String"},"var_type":"GlobalVar"}|
-    )
-  end
+    it "parses global variables" do
+      Gloss.parse_string("$var : String = 'hello world'").should eq(
+        %q|{"type":"TypeDeclaration","var":{"type":"GlobalVar","name":"$var"},"declared_type":{"type":"Path","value":"String"},"value":{"type":"LiteralNode","value":"\"hello world\"","rb_type":"String"},"var_type":"GlobalVar"}|
+      )
+    end
 
-  it "parses for loops" do
-    Gloss.parse_string(<<-GLS).should be_truthy
-      for k, v in { hello: world }
-        puts key: k, value: v
-      end
-    GLS
-  end
+    # it "parses for loops" do
+    #   Gloss.parse_string(<<-GLS).should be_truthy
+    #     for k, v in { hello: world }
+    #       puts key: k, value: v
+    #     end
+    #   GLS
+    # end
+
+    it "parses generics as RBS generics" do
+      expected =
+        %q|{"type":"TypeDeclaration","var":{"type":"Var","name":"hsh"},"declared_type":{"type":"Generic","name":{"type":"Path","value":"Hash"},"args":[{"type":"Path","value":"String"},{"type":"Path","value":"String"}]},"value":{"type":"HashLiteral","elements":[[{"type":"LiteralNode","value":"\"hello\"","rb_type":"String"},{"type":"LiteralNode","value":"\"world\"","rb_type":"String"}]],"frozen":false},"var_type":"Var"}|
+      Gloss.parse_string(<<-GLS).should eq expected
+        hsh : Hash[String, String] = { "hello" => "world" }
+      GLS
+    end
+
+    # it "parses method calls in case statements" do
+    #   expected =
+    #     %q|{"type":"Case","condition":{"type":"LiteralNode","value":"\"abc\"","rb_type":"String"},"whens":[{"type":"When","conditions":[{"type":"Proc","function":{"type":"DefNode","name":"->","body":{"type":"Call","name":"start_with?","args":[{"type":"LiteralNode","value":"\"a\"","rb_type":"String"}],"object":{"type":"Var","name":"x"},"block":null,"block_arg":null},"rp_args":[{"type":"Arg","name":"x","external_name":"x","default_value":null,"restriction":null,"keyword_arg":false}],"receiver":null,"return_type":null,"rest_kw_args":null}}],"body":{"type":"LiteralNode","value":"1","rb_type":"Integer"},"exhaustive":false}],"else":{"type":"LiteralNode","value":"0","rb_type":"Integer"},"exhaustive":false}|
+    #   Gloss.parse_string(<<-GLS).should eq expected
+    #     case "abc"
+    #     when .start_with? 'a'
+    #       1
+    #     else
+    #       0
+    #     end
+    #   GLS
+    # end
+
+    # it "allows constant methods" do
+    #   Gloss.parse_string(<<-GLS).should be_truthy
+    #     def Hello(arg = nil)
+    #     end
+
+    #     Hello()
+
+    #     Hello("a")
+    #   GLS
+    # end
+
+    # it "requires constant methods to be called with ()" do
+    #   Gloss.parse_string(<<-GLS).should be_falsey
+    #     def Hello(arg = nil)
+    #     end
 
-  it "parses generics as RBS generics" do
-    expected =
-      %q|{"type":"TypeDeclaration","var":{"type":"Var","name":"hsh"},"declared_type":{"type":"Generic","name":{"type":"Path","value":"Hash"},"args":[{"type":"Path","value":"String"},{"type":"Path","value":"String"}]},"value":{"type":"HashLiteral","elements":[[{"type":"LiteralNode","value":"\"hello\"","rb_type":"String"},{"type":"LiteralNode","value":"\"world\"","rb_type":"String"}]],"frozen":false},"var_type":"Var"}|
-    Gloss.parse_string(<<-GLS).should eq expected
-      hsh : Hash[String, String] = { "hello" => "world" }
-    GLS
+    #     Hello
+    #   GLS
+    # end
   end
 end

data/ext/gloss/src/cr_ast.cr

@@ -5,7 +5,7 @@ require "./rb_ast"
 module Crystal
   abstract class ASTNode
     def to_rb
-      Rb::AST::EmptyNode.new(self.class.name)
+      Rb::AST::EmptyNode.new(self.class.name, @location)
     end
   end
 
@@ -17,13 +17,13 @@ module Crystal
 
   class Expressions < ASTNode
     def to_rb
-      Rb::AST::CollectionNode.new(@expressions.map(&.to_rb))
+      Rb::AST::CollectionNode.new(@expressions.map(&.to_rb), @location)
     end
   end
 
   class NilLiteral < ASTNode
     def to_rb
-      Rb::AST::LiteralNode.new("nil", Rb::AST::RbLiteral::NilClass)
+      Rb::AST::LiteralNode.new("nil", Rb::AST::RbLiteral::NilClass, @location)
     end
   end
 
@@ -31,112 +31,129 @@ module Crystal
     def to_rb
       Rb::AST::LiteralNode.new(
         @value.inspect,
-        @value ? Rb::AST::RbLiteral::TrueClass : Rb::AST::RbLiteral::FalseClass
-      )
+        @value ? Rb::AST::RbLiteral::TrueClass : Rb::AST::RbLiteral::FalseClass, @location)
     end
   end
 
   class NumberLiteral < ASTNode
     def to_rb
-      Rb::AST::LiteralNode.new(@value, Rb::AST::RbLiteral::Integer)
+      Rb::AST::LiteralNode.new(@value, Rb::AST::RbLiteral::Integer, @location)
     end
   end
 
   class CharLiteral < ASTNode
     def to_rb
-      Rb::AST::LiteralNode.new(@value.inspect, Rb::AST::RbLiteral::String)
+      Rb::AST::LiteralNode.new(@value.inspect, Rb::AST::RbLiteral::String, @location)
     end
   end
 
   class StringLiteral < ASTNode
     def to_rb
-      Rb::AST::LiteralNode.new(@value.inspect, Rb::AST::RbLiteral::String)
+      Rb::AST::LiteralNode.new(@value.inspect, Rb::AST::RbLiteral::String, @location)
     end
   end
 
   class StringInterpolation < ASTNode
     def to_rb
-      Rb::AST::StringInterpolation.new(@expressions.map &.to_rb)
+      Rb::AST::StringInterpolation.new(@expressions.map &.to_rb, @location)
     end
   end
 
   class SymbolLiteral < ASTNode
     def to_rb
-      Rb::AST::LiteralNode.new(":#{@value.to_s}", Rb::AST::RbLiteral::Symbol)
+      Rb::AST::LiteralNode.new(%{:"#{@value.to_s}"}, Rb::AST::RbLiteral::Symbol, @location)
     end
   end
 
   class ArrayLiteral < ASTNode
     def to_rb
-      Rb::AST::ArrayLiteral.new(@elements.map(&.to_rb))
+      Rb::AST::ArrayLiteral.new(@elements.map(&.to_rb), @location)
     end
   end
 
   class HashLiteral < ASTNode
     def to_rb
-      Rb::AST::HashLiteral.new(@entries.map { |e| { e.key.to_rb, e.value.to_rb }})
+      Rb::AST::HashLiteral.new(@entries.map { |e| {e.key.to_rb, e.value.to_rb} }, @location)
     end
   end
 
   class NamedTupleLiteral < ASTNode
     def to_rb
-      Rb::AST::HashLiteral.new(@entries.map { |e| { e.key, e.value.to_rb }}, frozen: true)
+      Rb::AST::HashLiteral.new(@entries.map { |e| {e.key, e.value.to_rb} }, @location, frozen: true)
     end
   end
 
   class RangeLiteral < ASTNode
     def to_rb
-      Rb::AST::RangeLiteral.new(@from.to_rb, @to.to_rb, @exclusive)
+      Rb::AST::RangeLiteral.new(@from.to_rb, @to.to_rb, @exclusive, @location)
     end
   end
 
   class RegexLiteral < ASTNode
     def to_rb
-      Rb::AST::RegexLiteral.new("//")
+      Rb::AST::RegexLiteral.new(@value.to_rb, @location)
     end
   end
 
   class TupleLiteral < ASTNode
     def to_rb
-      Rb::AST::ArrayLiteral.new(@elements.map(&.to_rb), frozen: true)
+      Rb::AST::ArrayLiteral.new(@elements.map(&.to_rb), @location, frozen: true)
     end
   end
 
   class Def < ASTNode
     def to_rb
-      Rb::AST::DefNode.new(@name, @args.map(&.to_rb), @body.to_rb, receiver.try(&.to_rb),
-                           return_type.try(&.to_rb), @double_splat.try(&.to_rb))
+      positional_args = args.dup
+      splat = @splat_index ? positional_args.delete_at(@splat_index.as(Int32)) : nil
+      Rb::AST::DefNode.new(
+        receiver.try(&.to_rb),
+        @name,
+        positional_args.map(&.to_rb),
+        splat.try(&.to_rb),
+        @double_splat.try(&.to_rb),
+        @body.to_rb,
+        return_type.try(&.to_rb),
+        @yields,
+        @block_arg.try &.to_rb, @location)
     end
   end
 
   class ClassDef < ASTNode
     def to_rb
-      Rb::AST::ClassNode.new(@name.to_rb, @body.to_rb, @superclass.try(&.to_rb), @type_vars, @abstract)
+      Rb::AST::ClassNode.new(@name.to_rb, @body.to_rb, @superclass.try(&.to_rb), @type_vars, @abstract, @location)
     end
   end
 
   class ModuleDef < ASTNode
     def to_rb
-      Rb::AST::ModuleNode.new(@name.to_rb, @body.to_rb, @type_vars)
+      Rb::AST::ModuleNode.new(@name.to_rb, @body.to_rb, @type_vars, @location)
     end
   end
 
   class Var < ASTNode
     def to_rb
-      Rb::AST::Var.new(@name)
+      Rb::AST::Var.new(@name, @location)
     end
   end
 
   class Block < ASTNode
     def to_rb
-      Rb::AST::Block.new(@args.map(&.to_rb), @body.to_rb)
+      positional_args = args.dup
+      splat = @splat_index ? positional_args.delete_at(@splat_index.as(Int32)) : nil
+      Rb::AST::Block.new(positional_args.map(&.to_rb), splat.try &.to_rb, @body.to_rb, @location)
     end
   end
 
   class Call < ASTNode
     def to_rb
-      Rb::AST::Call.new(@obj.try(&.to_rb), @name, @args.map(&.to_rb), @block.try(&.to_rb),
-                        @block_arg.try(&.to_rb))
+      Rb::AST::Call.new(
+        @obj.try(&.to_rb),
+        @name,
+        @args.map(&.to_rb),
+        @named_args.try(&.map(&.to_rb.as(Rb::AST::Arg))),
+        @block.try(&.to_rb),
+        @block_arg.try(&.to_rb),
+        @has_parentheses, @location)
     end
   end
 
@@ -145,121 +162,121 @@ module Crystal
 
     def to_rb
       Rb::AST::Arg.new(@name, @external_name, @restriction.try(&.to_rb),
-                       @default_value.try(&.to_rb), @keyword_arg)
+        @default_value.try(&.to_rb), @keyword_arg, @location)
     end
   end
 
   class NamedArgument < ASTNode
     def to_rb
-      Rb::AST::EmptyNode.new(self.class.name)
+      Rb::AST::Arg.new(@name, @name, nil, @value.to_rb, true, @location)
     end
   end
 
   class If < ASTNode
     def to_rb
-      Rb::AST::If.new(@cond.to_rb, @then.to_rb, @else.to_rb)
+      Rb::AST::If.new(@cond.to_rb, @then.to_rb, @else.to_rb, @location)
+    end
+  end
+
+  class Unless < ASTNode
+    def to_rb
+      Rb::AST::Unless.new(@cond.to_rb, @then.to_rb, @else.to_rb, @location)
     end
   end
 
   class Assign < ASTNode
     def to_rb
-      Rb::AST::Assign.new(@target.to_rb, @value.to_rb)
+      Rb::AST::Assign.new(@target.to_rb, @value.to_rb, nil, @location)
     end
   end
 
   class OpAssign < ASTNode
     def to_rb
-      Rb::AST::Assign.new(@target.to_rb, @value.to_rb, @op)
+      Rb::AST::Assign.new(@target.to_rb, @value.to_rb, @op, @location)
     end
   end
 
   class MultiAssign < ASTNode
     def to_rb
-      Rb::AST::EmptyNode.new(self.class.name)
+      Rb::AST::MultiAssign.new(@targets.map(&.to_rb), @values.map(&.to_rb), @location)
     end
   end
 
   class InstanceVar < ASTNode
     def to_rb
-      Rb::AST::InstanceVar.new(@name)
+      Rb::AST::InstanceVar.new(@name, @location)
     end
   end
 
   class ReadInstanceVar < ASTNode
     def to_rb
-      Rb::AST::EmptyNode.new(self.class.name)
+      Rb::AST::EmptyNode.new(self.class.name, @location)
     end
   end
 
   class ClassVar < ASTNode
     def to_rb
-      Rb::AST::EmptyNode.new(self.class.name)
+      Rb::AST::EmptyNode.new(self.class.name, @location)
     end
   end
 
   class Global < ASTNode
     def to_rb
-      Rb::AST::GlobalVar.new(@name)
+      Rb::AST::GlobalVar.new(@name, @location)
     end
   end
 
   class Annotation < ASTNode
     def to_rb
-      Rb::AST::EmptyNode.new(self.class.name)
-    end
-  end
-
-  class MacroExpression < ASTNode
-    def to_rb
-      Rb::AST::EmptyNode.new(self.class.name)
+      Rb::AST::EmptyNode.new(self.class.name, @location)
     end
   end
 
   class MacroIf < ASTNode
     def to_rb
-      Rb::AST::MacroIf.new(@cond.to_rb, @then.to_rb, @else.to_rb)
+      Rb::AST::MacroIf.new(@cond.to_rb, @then.to_rb, @else.to_rb, @location)
     end
   end
 
   class MacroFor < ASTNode
     def to_rb
-      Rb::AST::MacroFor.new(@vars.map(&.to_rb), @exp.to_rb, @body.to_rb)
+      Rb::AST::MacroFor.new(@vars.map(&.to_rb), @exp.to_rb, @body.to_rb, @location)
     end
   end
 
   class MacroVar < ASTNode
     def to_rb
-      Rb::AST::EmptyNode.new(self.class.name)
+      Rb::AST::EmptyNode.new(self.class.name, @location)
     end
   end
 
   class MacroExpression < ASTNode
     def to_rb
-      Rb::AST::MacroExpression.new(@exp.to_rb, @output)
+      Rb::AST::MacroExpression.new(@exp.to_rb, @output, @location)
     end
   end
 
   class MacroLiteral < ASTNode
     def to_rb
-      Rb::AST::MacroLiteral.new(@value)
+      Rb::AST::MacroLiteral.new(@value, @location)
     end
   end
 
   class Annotation < ASTNode
     def to_rb
-      Rb::AST::EmptyNode.new(self.class.name)
+      Rb::AST::EmptyNode.new(self.class.name, @location)
     end
   end
 
   class EnumDef < ASTNode
     def to_rb
-      Rb::AST::Enum.new(@name, @members.map(&.to_rb))
+      Rb::AST::Enum.new(@name, @members.map(&.to_rb), @location)
     end
   end
 
   class Path < ASTNode
     def to_rb
-      Rb::AST::Path.new(full_name)
+      Rb::AST::Path.new(full_name, @location)
     end
 
     def full_name
@@ -271,13 +288,13 @@ module Crystal
 
   class Require < ASTNode
     def to_rb
-      Rb::AST::Require.new(@string)
+      Rb::AST::Require.new(@string, @location)
     end
   end
 
   class TypeDeclaration < ASTNode
     def to_rb
-      Rb::AST::TypeDeclaration.new(@var.to_rb, @declared_type.to_rb, @value.try(&.to_rb))
+      Rb::AST::TypeDeclaration.new(@var.to_rb, @declared_type.to_rb, @value.try(&.to_rb), @location)
     end
   end
 
@@ -287,18 +304,28 @@ module Crystal
         @cond.try(&.to_rb),
         @whens.map(&.to_rb),
         @else.try(&.to_rb),
-        @exhaustive
-      )
+        @exhaustive, @location)
     end
   end
 
   class When < ASTNode
     def to_rb
       Rb::AST::When.new(
-        @conds.map(&.to_rb),
+        @conds.map do |c|
+          if c.is_a? Call
+            arg_name = "x"
+            ProcLiteral.new(
+              Def.new(
+                "->",
+                [Arg.new(arg_name)],
+                c.tap { |call| call.obj = Var.new(arg_name) })
+            ).to_rb
+          else
+            c.to_rb
+          end
+        end,
         @body.to_rb,
-        @exhaustive
-      )
+        @exhaustive, @location)
     end
   end
 
@@ -318,8 +345,7 @@ module Crystal
         Rb::AST::UnaryExpr.new(
           @exp.to_rb,
           op,
-          requires_parentheses
-        )
+          requires_parentheses ,@location)
       end
     end
   {% end %}
@@ -334,8 +360,7 @@ module Crystal
             "||",
           {% end %}
           @left.to_rb,
-          @right.to_rb
-        )
+          @right.to_rb ,@location)
       end
     end
   {% end %}
@@ -343,7 +368,7 @@ module Crystal
   {% for class_name in %w[Return Break Next] %}
     class {{class_name.id}} < ControlExpression
       def to_rb
-        Rb::AST::{{class_name.id}}.new(@exp.try(&.to_rb))
+        Rb::AST::{{class_name.id}}.new(@exp.try(&.to_rb),@location)
       end
     end
   {% end %}
@@ -351,45 +376,94 @@ module Crystal
   class ExceptionHandler < ASTNode
     def to_rb
       Rb::AST::ExceptionHandler.new(@body.to_rb, @rescues.try(&.map(&.to_rb)), @else.try(&.to_rb),
-                                    @ensure.try(&.to_rb))
+        @ensure.try(&.to_rb), @location)
     end
   end
 
   class Rescue < ASTNode
     def to_rb
-      Rb::AST::Rescue.new(@body.to_rb, @types.try(&.map(&.to_rb)), @name)
+      Rb::AST::Rescue.new(@body.to_rb, @types.try(&.map(&.to_rb)), @name, @location)
     end
   end
 
   class Union < ASTNode
     def to_rb
-      Rb::AST::Union.new(@types.map(&.to_rb))
+      Rb::AST::Union.new(@types.map(&.to_rb), @location)
     end
   end
 
   class Generic < ASTNode
     def to_rb
-      Rb::AST::Generic.new(@name.to_rb, @type_vars.map(&.to_rb))
+      Rb::AST::Generic.new(@name.to_rb, @type_vars.map(&.to_rb), @location)
+    end
+  end
+
+  class ProcLiteral < ASTNode
+    def to_rb
+      Rb::AST::Proc.new(@def.to_rb, @location)
+    end
+  end
+
+  class Include < ASTNode
+    def to_rb
+      Rb::AST::Include.new(@name.to_rb, @location)
+    end
+  end
+
+  class Extend < ASTNode
+    def to_rb
+      Rb::AST::Extend.new(@name.to_rb, @location)
+    end
+  end
+
+  class IsA < ASTNode
+    def to_rb
+      Rb::AST::Call.new(
+        @obj.to_rb,
+        "is_a?",
+        [@const.to_rb],
+        nil,
+        nil,
+        nil,
+        false, @location)
+    end
+  end
+
+  class VisibilityModifier < ASTNode
+    def to_rb
+      Rb::AST::VisibilityModifier.new(@modifier, @exp.to_rb, @location)
+    end
+  end
+
+  class Yield < ASTNode
+    def to_rb
+      Rb::AST::Call.new(
+        nil,
+        "yield",
+        @exps.map(&.to_rb),
+        nil,
+        nil,
+        nil,
+        !@exps.empty?, @location)
     end
   end
 
-  {% for class_name in %w[ProcNotation Macro OffsetOf VisibilityModifier IsA RespondsTo
+  {% for class_name in %w[ProcNotation Macro OffsetOf RespondsTo
                          Select ImplicitObj AnnotationDef While Until UninitializedVar
-                         ProcLiteral ProcPointer Self Yield Include
-                         Extend LibDef FunDef TypeDef CStructOrUnionDef ExternalVar Alias
-                         Metaclass Cast NilableCast TypeOf Annotation
+                         ProcPointer Self LibDef FunDef TypeDef CStructOrUnionDef
+                         ExternalVar Alias Metaclass Cast NilableCast TypeOf Annotation
                          Underscore MagicConstant Asm AsmOperand] %}
     class {{class_name.id}} < ASTNode
       def to_rb
-        Rb::AST::EmptyNode.new(self.class.name)
+        Rb::AST::EmptyNode.new(self.class.name,@location)
       end
     end
   {% end %}
 
-  {% for class_name in %w[PointerOf SizeOf InstanceSizeOf Out MacroVerbatim DoubleSplat] %}
+  {% for class_name in %w[PointerOf SizeOf InstanceSizeOf Out MacroVerbatim] %}
     class {{class_name.id}} < UnaryExpression
       def to_rb
-        Rb::AST::EmptyNode.new(self.class.name)
+        Rb::AST::EmptyNode.new(self.class.name,@location)
       end
     end
   {% end %}