gloss 0.0.3 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a1461d26e97ea9693ee00d63016e0fa1e34ea719de672ae0d4c303e4efb5144
-  data.tar.gz: 2370827768056a2575c1987d661a140d7247b68629e049aa58b0bc9d1de0bc31
+  metadata.gz: 265e6f48bffa061f213e15f98be4d31b97c900701e95c381c1176048d9e8a75f
+  data.tar.gz: 9398669043cd6de339664f87529388f68d83f519d650b72ea06de6715d7477bb
 SHA512:
-  metadata.gz: 17d5c598e8199b375599112a4365cb14691e651783a86880844dd35ff312dc2ca2ed0bb632e0a51897dcd3ba774231ae9c547710f19ed134318a39e098224a37
-  data.tar.gz: 6626ff60cab24dacfc6e6780368a719e04c45c80c1f4e8b89db76bfdc0848f725e33d907058b6c9991fc80c1b97b518503eb42a47435c733f43a4e0d0d49eb0e
+  metadata.gz: d0ef0a2208f005eaa87c77fcc2e1cca5e2bdf4d08e712a70d0cf5dfa57e4a3d45a691dbc873f47d7c95a928ea48d36fa885b9ca2a62b52e55a42f7ae3540613d
+  data.tar.gz: a21377a395aa60bec26f0d420b8bb2124cb121994bf635b34653e290f0d2441f160888755695711ee6c1dd0e1e16da65fca9c6423a1b0f4600a7a15dc4b4a5a3

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:
@@ -16,7 +16,7 @@ on:
 jobs:
   test:
 
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-20.04
 
     steps:
     - uses: actions/checkout@v2

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.3)
+    gloss (0.1.1)
       fast_blank
       listen
       rbs
@@ -17,16 +17,15 @@ GEM
       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.7)
+    i18n (1.8.8)
       concurrent-ruby (~> 1.0)
     language_server-protocol (3.15.0.1)
     listen (3.4.1)
@@ -50,7 +49,7 @@ GEM
     rb-fsevent (0.10.4)
     rb-inotify (0.10.1)
       ffi (~> 1.0)
-    rbs (1.0.0)
+    rbs (1.0.4)
     regexp_parser (2.0.3)
     rexml (3.2.4)
     rspec (3.10.0)
@@ -78,15 +77,14 @@ GEM
     rubocop-ast (1.4.0)
       parser (>= 2.7.1.5)
     ruby-progressbar (1.11.0)
-    steep (0.39.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)

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/Rakefile

@@ -18,7 +18,7 @@ RSpec::Core::RakeTask.new :spec  do |spec|
 end
 
 task :build do
-  `cd ext/gloss && make && cd -`
+  sh "cd", "ext/gloss", "&&", "make", "all", "&&", "cd", "-"
 end
 
 task :default => [:spec]

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/Makefile

@@ -1,26 +1,20 @@
 CRYSTAL = crystal
-TARGET = ../../lib/gls
-
 PLATFORM = $(shell uname -s)
 
 ifeq "$(PLATFORM)" "Darwin"
-install: all
-
-all: clean shards build
+TARGET = ../../lib/gls.bundle
 
-shards:
-	shards
+clean:
+	rm -f $(TARGET) $(TARGET).dwarf
+endif
 
-build: ./src/gloss.cr
-	$(CRYSTAL) build  --link-flags "-dynamic -bundle -Wl,-undefined,dynamic_lookup" $< -o $(TARGET).bundle
+ifeq "$(PLATFORM)" "Linux"
+TARGET = ../../lib/gls.so
 
 clean:
-	rm -f $(TARGET).bundle
-	rm -f $(TARGET).bundle.dwarf
+	rm -f $(TARGET)
 endif
 
-ifeq "$(PLATFORM)" "Linux"
-LLVM_TARGET = "$(shell uname -m)-unknown-linux-gnu"
 install: all
 
 all: clean shards build
@@ -29,9 +23,4 @@ shards:
 	shards
 
 build: ./src/gloss.cr
-	$(CRYSTAL) build $< --cross-compile --target $(LLVM_TARGET) --link-flags "-dynamic -bundle -Wl,-undefined,dynamic_lookup" -o $(TARGET)
-
-clean:
-	rm -f $(TARGET).o
-	rm -f $(TARGET).so
-endif
+	$(CRYSTAL) build  --link-flags "-shared -dynamic -Wl,-undefined,dynamic_lookup" $< -o $(TARGET) --release

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,90 +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 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 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 not operator" do
-    Gloss.parse_string("puts 'hello world' if true and not false").should be_truthy
-  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 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 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 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 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 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 "parses the and operator" do
+    #   Gloss.parse_string("puts 'hello world' if 1 and 2").should be_truthy
+    # end
 
-  it "allows constant methods" do
-    Gloss.parse_string(<<-GLS).should be_truthy
-      def Hello(arg = nil)
-      end
+    # it "parses the or operator" do
+    #   Gloss.parse_string("puts 'hello world' if true or false").should be_truthy
+    # end
 
-      Hello()
+    # it "parses the not operator" do
+    #   Gloss.parse_string("puts 'hello world' if true and not false").should be_truthy
+    # end
 
-      Hello("a")
-    GLS
-  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 "requires constant methods to be called with ()" do
-    Gloss.parse_string(<<-GLS).should be_falsey
-      def Hello(arg = nil)
-      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
 
-      Hello
-    GLS
+    # 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
+
+    #     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,105 +31,116 @@ 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(@value.to_rb)
+      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
 
@@ -141,8 +152,8 @@ module Crystal
         @args.map(&.to_rb),
         @named_args.try(&.map(&.to_rb.as(Rb::AST::Arg))),
         @block.try(&.to_rb),
-        @block_arg.try(&.to_rb)
-      )
+        @block_arg.try(&.to_rb),
+        @has_parentheses, @location)
     end
   end
 
@@ -151,127 +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::Arg.new(@name, @name, nil, @value.to_rb, true)
+      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)
+      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
@@ -283,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
 
@@ -299,8 +304,7 @@ module Crystal
         @cond.try(&.to_rb),
         @whens.map(&.to_rb),
         @else.try(&.to_rb),
-        @exhaustive
-      )
+        @exhaustive, @location)
     end
   end
 
@@ -314,16 +318,14 @@ module Crystal
               Def.new(
                 "->",
                 [Arg.new(arg_name)],
-                c.tap { |call| call.obj = Var.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
 
@@ -343,8 +345,7 @@ module Crystal
         Rb::AST::UnaryExpr.new(
           @exp.to_rb,
           op,
-          requires_parentheses
-        )
+          requires_parentheses ,@location)
       end
     end
   {% end %}
@@ -359,8 +360,7 @@ module Crystal
             "||",
           {% end %}
           @left.to_rb,
-          @right.to_rb
-        )
+          @right.to_rb ,@location)
       end
     end
   {% end %}
@@ -368,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 %}
@@ -376,43 +376,43 @@ 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)
+      Rb::AST::Proc.new(@def.to_rb, @location)
     end
   end
 
   class Include < ASTNode
     def to_rb
-      Rb::AST::Include.new(@name.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)
+      Rb::AST::Extend.new(@name.to_rb, @location)
     end
   end
 
@@ -424,27 +424,46 @@ module Crystal
         [@const.to_rb],
         nil,
         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  RespondsTo
+  {% for class_name in %w[ProcNotation Macro OffsetOf RespondsTo
                          Select ImplicitObj AnnotationDef While Until UninitializedVar
-                         ProcPointer Self Yield LibDef FunDef TypeDef CStructOrUnionDef
+                         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 %}