gloss 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a1461d26e97ea9693ee00d63016e0fa1e34ea719de672ae0d4c303e4efb5144
-  data.tar.gz: 2370827768056a2575c1987d661a140d7247b68629e049aa58b0bc9d1de0bc31
+  metadata.gz: 3a630a77074bd1fa44113b542bd04b312957e3d59834dc9dec0282466e60d50a
+  data.tar.gz: 653fc89b0793a114f9d6a04348a63d76368db464bf93a713268467140551680c
 SHA512:
-  metadata.gz: 17d5c598e8199b375599112a4365cb14691e651783a86880844dd35ff312dc2ca2ed0bb632e0a51897dcd3ba774231ae9c547710f19ed134318a39e098224a37
-  data.tar.gz: 6626ff60cab24dacfc6e6780368a719e04c45c80c1f4e8b89db76bfdc0848f725e33d907058b6c9991fc80c1b97b518503eb42a47435c733f43a4e0d0d49eb0e
+  metadata.gz: 0f8573f5596495a00d31c102edf033f010f07092a6441a26809dc7d0044e906651058191ff9b37a87d840cae4fb16916aad76e27d219688824cd06366ef46c3c
+  data.tar.gz: 22a085469dd74a3c88d3334ac8c75c44ea8e43fbca211acc5e25cd83230bc435b48b262787d6eccacf2efff2f4ed5324aa11a3e102e1aa9bc0ebe1dba04d2564

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    gloss (0.0.3)
+    gloss (0.0.4)
       fast_blank
       listen
       rbs
@@ -22,7 +22,7 @@ GEM
       thor (>= 0.19)
     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)
@@ -50,7 +50,7 @@ GEM
     rb-fsevent (0.10.4)
     rb-inotify (0.10.1)
       ffi (~> 1.0)
-    rbs (1.0.0)
+    rbs (1.0.3)
     regexp_parser (2.0.3)
     rexml (3.2.4)
     rspec (3.10.0)
@@ -86,7 +86,7 @@ GEM
       parser (~> 2.7.0)
       rainbow (>= 2.2.2, < 4.0)
       rbs (~> 1.0.0)
-    thor (1.0.1)
+    thor (1.1.0)
     tzinfo (2.0.4)
       concurrent-ruby (~> 1.0)
     unicode-display_width (1.7.0)

data/ext/gloss/lib/rbs_types.cr

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

data/ext/gloss/src/cr_ast.cr

@@ -104,8 +104,19 @@ module Crystal
 
   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
+      )
     end
   end
 
@@ -141,7 +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
       )
     end
   end
@@ -187,7 +199,7 @@ module Crystal
 
   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))
     end
   end
 
@@ -424,14 +436,35 @@ module Crystal
         [@const.to_rb],
         nil,
         nil,
-        nil
+        nil,
+        false
+      )
+    end
+  end
+
+  class VisibilityModifier < ASTNode
+    def to_rb
+      Rb::AST::VisibilityModifier.new(@modifier, @exp.to_rb)
+    end
+  end
+
+  class Yield < ASTNode
+    def to_rb
+      Rb::AST::Call.new(
+        nil,
+        "yield",
+        @exps.map(&.to_rb),
+        nil,
+        nil,
+        nil,
+        !@exps.empty?
       )
     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
@@ -441,7 +474,7 @@ module Crystal
     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)

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"

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/rb_ast.cr

@@ -94,18 +94,31 @@ 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?)
+      @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(name : String, rp_args : Array(Arg), body : Node, receiver : Node?, return_type : Node?, rest_kw_args)
+      def initialize(
+        receiver : Node?,
+        name : String,
+        positional_args : Array(Arg),
+        splat,
+        rest_kw_args,
+        body : Node,
+        return_type : Node?,
+        yields : Int32?,
+        block_arg : Node?
+      )
         @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
 
@@ -116,15 +129,14 @@ module Rb
       @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?, value :
-          Node?, keyword_arg)
+      def initialize(name : String, external_name : String, restriction : Node?, value : Node?, keyword_arg)
         @info = {
           type:          self.class.name.split("::").last,
           name:          name,
           restriction:   restriction,
-          value: value,
+          value:         value,
           external_name: external_name,
-          keyword_arg: keyword_arg
+          keyword_arg:   keyword_arg,
         }
       end
 
@@ -318,18 +330,19 @@ module Rb
     end
 
     class Call < Node
-      @info : NamedTuple(type: String, name: String, args: Array(Node), object: Node?, block:
-      Block?, block_arg: Node?, named_args: Array(Arg)?)
+      @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), named_args, block, block_arg)
+      def initialize(object : Node?, name : String, args : Array(Node), named_args, block,
+                     block_arg, has_parentheses)
         @info = {
-          type:      self.class.name.split("::").last,
-          name:      name,
-          args:      args,
-          object:    object,
-          block:     block,
-          block_arg: block_arg,
-          named_args: named_args,
+          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
 
@@ -400,6 +413,20 @@ 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)
+        @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)
 
@@ -511,7 +538,7 @@ module Rb
       def initialize(types)
         @info = {
           type:  self.class.name.split("::").last,
-          types: types
+          types: types,
         }
       end
 
@@ -523,9 +550,9 @@ module Rb
 
       def initialize(name, args)
         @info = {
-          type:  self.class.name.split("::").last,
+          type: self.class.name.split("::").last,
           name: name,
-          args: args
+          args: args,
         }
       end
 
@@ -537,8 +564,8 @@ module Rb
 
       def initialize(function)
         @info = {
-          type:  self.class.name.split("::").last,
-          function: function
+          type:     self.class.name.split("::").last,
+          function: function,
         }
       end
 
@@ -550,8 +577,8 @@ module Rb
 
       def initialize(name)
         @info = {
-          type:  self.class.name.split("::").last,
-          name: name
+          type: self.class.name.split("::").last,
+          name: name,
         }
       end
 
@@ -563,5 +590,27 @@ module Rb
 
     class Include < NodeWithNameNode
     end
+
+    class VisibilityModifier < Node
+      @info : NamedTuple(type: String, visibility: String, exp: Node)
+
+      def initialize(visibility : Crystal::Visibility, exp : Node)
+        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
+
+      delegate :to_json, to: @info
+    end
   end
 end

data/lib/gloss/builder.rb

@@ -1,9 +1,11 @@
-# frozen_string_literal: true
+  # frozen_string_literal: true
 
-module Gloss
-  class Builder
-    attr_reader :tree
+  ##### This file was generated by Gloss; any changes made here will be overwritten.
+  ##### See src/ to make changes
 
+  module Gloss
+  class Builder
+    attr_reader(:"tree")
     def initialize(tree_hash, type_checker = nil)
       @indent_level = 0
       @inside_macro = false
@@ -12,436 +14,603 @@ module Gloss
       @tree = tree_hash
       @type_checker = type_checker
     end
-
-    def run
+    def run()
       rb_output = visit_node(@tree)
-      <<~RUBY
-        #{"# frozen_string_literal: true\n" if Config.frozen_string_literals}
-        ##### This file was generated by Gloss; any changes made here will be overwritten.
-        ##### See #{Config.src_dir}/ to make changes
-
-        #{rb_output}
-      RUBY
+"  #{(if Config.frozen_string_literals
+        "# frozen_string_literal: true\n"
+      end)}\n  ##### This file was generated by Gloss; any changes made here will be overwritten.\n  ##### See #{Config.src_dir}/ to make changes\n\n  #{rb_output}"
     end
-
     def visit_node(node, scope = Scope.new)
       src = Source.new(@indent_level)
-      case node[:type]
-      when "ClassNode"
-        class_name = visit_node(node[:name])
-        current_namespace = @current_scope ? @current_scope.name.to_namespace : RBS::Namespace.root
-        superclass_type = nil
-        superclass_output = nil
-        if node[:superclass]
-          @eval_vars = true
-          superclass_output = visit_node(node[:superclass])
-          @eval_vars = false
-          ns = if superclass_output.start_with? '::'
-                 RBS::Namespace.root
-               elsif superclass_output.include? '::'
-                 current_namespace
-               else
-                 RBS::Namespace.empty
-               end
-          superclass_type = RBS::AST::Declarations::Class::Super.new(
-            name: RBS::TypeName.new(
-              name: superclass_output.to_sym,
-              namespace: ns
-            ),
-            args: [],
-            location: nil
-          )
-        end
-
-        src.write_ln "class #{class_name}#{" < #{superclass_output}" if superclass_output}"
-
-        class_type = RBS::AST::Declarations::Class.new(
-          name: RBS::TypeName.new(
-            namespace: current_namespace,
-            name: class_name.to_sym
-          ),
-          type_params: RBS::AST::Declarations::ModuleTypeParams.new, # responds to #add to add params
-          super_class: superclass_type,
-          members: [],
-          annotations: [],
-          location: node[:location],
-          comment: node[:comment]
-        )
-        old_parent_scope = @current_scope
-        @current_scope = class_type
-
-        indented(src) { src.write_ln visit_node(node[:body]) if node[:body] }
-
-        src.write_ln "end"
-
-        @current_scope = old_parent_scope
-
-        @current_scope.members << class_type if @current_scope
-
-        if @type_checker
-          @type_checker.top_level_decls[class_type.name.name] = class_type unless @current_scope
-        end
-      when "ModuleNode"
-        module_name = visit_node node[:name]
-        src.write_ln "module #{module_name}"
-
-        current_namespace = @current_scope ? @current_scope.name.to_namespace : RBS::Namespace.root
-
-        module_type = RBS::AST::Declarations::Module.new(
-          name: RBS::TypeName.new(
-            namespace: current_namespace,
-            name: module_name.to_sym
-          ),
-          type_params: RBS::AST::Declarations::ModuleTypeParams.new, # responds to #add to add params
-          self_types: [],
-          members: [],
-          annotations: [],
-          location: node[:location],
-          comment: node[:comment]
-        )
-        old_parent_scope = @current_scope
-        @current_scope = module_type
-
-        indented(src) { src.write_ln visit_node(node[:body]) if node[:body] }
-
-        @current_scope = old_parent_scope
-
-        @current_scope.members << module_type if @current_scope
-
-        if @type_checker
-          @type_checker.top_level_decls[module_type.name.name] = module_type unless @current_scope
-        end
-        src.write_ln "end"
-      when "DefNode"
-        args = render_args(node)
-        src.write_ln "def #{node[:name]}#{args}"
-
-        return_type = if node[:return_type]
-                        RBS::Types::ClassInstance.new(
-                          name: RBS::TypeName.new(
-                            name: eval(visit_node(node[:return_type])).to_s.to_sym,
-                            namespace: RBS::Namespace.root
-                          ),
-                          args: [],
-                          location: nil
-                        )
-                      else
-                        RBS::Types::Bases::Any.new(location: nil)
-                      end
-
-        method_types = [
-          RBS::MethodType.new(
-            type_params: [],
-            type: RBS::Types::Function.new(
-              required_positionals: node[:rp_args]&.map do |a|
-                RBS::Types::Function::Param.new(
-                  name: visit_node(a).to_sym,
-                  type: RBS::Types::Bases::Any.new(location: nil)
-                )
-              end || EMPTY_ARRAY,
-              optional_positionals: node[:op_args] || EMPTY_ARRAY,
-              rest_positionals: node[:rest_p_args],
-              trailing_positionals: [],
-              required_keywords: node[:req_kw_args] || EMPTY_HASH,
-              optional_keywords: node[:opt_kw_args] || EMPTY_HASH,
-              rest_keywords: node[:rest_kw_args] ?
-                RBS::Types::Function::Param.new(
-                  name: visit_node(node[:rest_kw_args]).to_sym,
-                  type: RBS::Types::Bases::Any.new(location: nil)
-                ) : nil,
-              return_type: return_type
-            ),
-            block: nil,
-            location: nil
-          )
-        ]
-        method_definition = RBS::AST::Members::MethodDefinition.new(
-          name: node[:name].to_sym,
-          kind: :instance,
-          types: method_types,
-          annotations: [],
-          location: node[:location],
-          comment: node[:comment],
-          overload: false
-        )
-
-        if @current_scope
-          @current_scope.members << method_definition
-        else
-          @type_checker.type_env << method_definition if @type_checker # should be new class declaration for Object with method_definition as private method
-        end
-
-        indented(src) { src.write_ln visit_node(node[:body]) if node[:body] }
-
-        src.write_ln "end"
-      when "CollectionNode"
-        src.write(*node[:children].map { |a| visit_node(a, scope) })
-      when "Call"
-        obj = node[:object] ? "#{visit_node(node[:object], scope)}." : ""
-        args = node[:args] || EMPTY_ARRAY
-        args += node[:named_args] if node[:named_args]
-        args = if !args.empty? || node[:block_arg]
-                 "(#{args.map { |a| visit_node(a, scope).strip }.reject(&:blank?).join(", ")}#{"&#{visit_node(node[:block_arg]).strip}" if node[:block_arg]})"
-               else
-                 nil
-               end
-        block = node[:block] ? " #{visit_node(node[:block])}" : nil
-        src.write_ln "#{obj}#{node[:name]}#{args}#{block}"
-
-      when "Block"
-
-        src.write "{ |#{node[:args].map { |a| visit_node a }.join(", ")}|\n"
-
-        indented(src) { src.write visit_node(node[:body]) }
-
-        src.write_ln "}"
-
-      when "RangeLiteral"
-        dots = node[:exclusive] ? "..." : ".."
-
-        # parentheses help the compatibility with precendence of operators in some situations
-        # eg. (1..3).cover? 2 vs. 1..3.cover? 2
-        src.write "(", visit_node(node[:from]), dots, visit_node(node[:to]), ")"
-
-      when "LiteralNode"
-
-        src.write node[:value]
-
-      when "ArrayLiteral"
-
-        src.write("[", *node[:elements].map { |e| visit_node e }.join(", "), "]")
-        src.write ".freeze" if node[:frozen]
-
-      when "StringInterpolation"
-
-        contents = node[:contents].inject(String.new) do |str, c|
-          str << case c[:type]
-                 when "LiteralNode"
-                   c[:value][1...-1]
-                 else
-                   "\#{#{visit_node(c).strip}}"
-                 end
-        end
-        src.write '"', contents, '"'
-
-      when "Path"
-
-        src.write node[:value]
-
-      when "Require"
-
-        src.write_ln %(require "#{node[:value]}")
-
-      when "Assign", "OpAssign"
-
-        src.write_ln "#{visit_node(node[:target])} #{node[:op]}= #{visit_node(node[:value]).strip}"
-
-      when "Var"
-
-        if @eval_vars
-          src.write scope[node[:name]]
-        else
-          src.write node[:name]
-        end
-
-      when "InstanceVar"
-
-        src.write node[:name]
-
-      when "GlobalVar"
-
-        src.write node[:name]
-
-      when "Arg"
-        val = node[:external_name]
-        if node[:keyword_arg]
-          val += ":"
-          val += " #{visit_node(node[:value])}" if node[:value]
-        elsif node[:value]
-          val += " = #{visit_node(node[:value])}"
-        end
-
-        src.write val
-
-      when "UnaryExpr"
-
-        src.write "#{node[:op]}#{visit_node(node[:value]).strip}"
-
-      when "BinaryOp"
-
-        src.write visit_node(node[:left]).strip, " #{node[:op]} ", visit_node(node[:right]).strip
-
-      when "HashLiteral"
-
-        contents = node[:elements].map do |k, v|
-          key = case k
-                when String
-                  k.to_sym
-                else
-                  visit_node k
-                end
-          value = visit_node v
-          "#{key.inspect} => #{value}"
-        end
-
-        src.write "{#{contents.join(",\n")}}"
-        src.write ".freeze" if node[:frozen]
-
-      when "Enum"
-        src.write_ln "module #{node[:name]}"
-        node[:members].each_with_index do |m, i|
-          indented(src) { src.write_ln(visit_node(m) + (!m[:value] ? " = #{i}" : "")) }
-        end
-        src.write_ln "end"
-      when "If"
-        src.write_ln "(if #{visit_node(node[:condition]).strip}"
-
-        indented(src) { src.write_ln visit_node(node[:then]) }
-
-        if node[:else]
-          src.write_ln "else"
-          indented(src) { src.write_ln visit_node(node[:else]) }
-        end
-
-        src.write_ln "end)"
-      when "Unless"
-        src.write_ln "unless #{visit_node node[:condition]}"
-        indented(src) { src.write_ln visit_node(node[:then]) }
-
-        if node[:else]
-          src.write_ln "else"
-          indented(src) { src.write_ln visit_node(node[:else]) }
-        end
-
-        src.write_ln "end"
-      when "Case"
-        src.write "case"
-        src.write " #{visit_node(node[:condition]).strip}\n" if node[:condition]
-        indented(src) do
-          node[:whens].each do |w|
-            src.write_ln visit_node(w)
-          end
-        end
-        src.write_ln "end"
-      when "When"
-        src.write_ln "when #{node[:conditions].map { |n| visit_node(n) }.join(", ")}"
-
-        indented(src) { src.write_ln visit_node(node[:body]) }
-      when "MacroFor"
-        vars, expr, body = node[:vars], node[:expr], node[:body]
-        var_names = vars.map { |v| visit_node v }
-        @inside_macro = true
-        indent_level = @indent_level
-        @indent_level -= 1 unless indent_level.zero?
-        expanded = eval(visit_node(expr)).map do |*a|
-          locals = Hash[[var_names.join(%(", "))].zip(a)]
-          locals.merge!(scope) if @inside_macro
-          visit_node(body, locals)
-        end.flatten
-        @indent_level += 1 unless indent_level.zero?
-        src.write(*expanded)
-        @inside_macro = false
-      when "MacroLiteral"
-        src.write node[:value]
-      when "MacroExpression"
-        if node[:output]
-          expr = visit_node node[:expr], scope
-          val = scope[expr]
-          src.write val
-        end
-      when "MacroIf"
-        if evaluate_macro_condition(node[:condition], scope)
-          src.write_ln visit_node(node[:then], scope) if node[:then]
-        else
-          src.write_ln visit_node(node[:else], scope) if node[:else]
-        end
-      when "Return"
-        val = node[:value] ? " #{visit_node(node[:value]).strip}" : nil
-        src.write "return#{val}"
-      when "TypeDeclaration"
-        src.write_ln "# @type var #{visit_node(node[:var])}: #{visit_node(node[:declared_type])}"
-        src.write_ln "#{visit_node(node[:var])} = #{visit_node(node[:value])}"
-      when "ExceptionHandler"
-        src.write_ln "begin"
-        indented src do
-          src.write_ln visit_node(node[:body])
-        end
-          node[:rescues]&.each do |r|
-            src.write_ln "rescue #{r[:types].map { |n| visit_node n }.join(", ") if r[:types]}#{" => #{r[:name]}" if r[:name]}"
-            indented(src) { src.write_ln visit_node(r[:body]) } if r[:body]
-          end
-          if node[:else]
-            src.write_ln "else"
-            indented(src) { src.write_ln visit_node(node[:else]) }
+case node.[](:"type")
+        when "ClassNode"
+          class_name = visit_node(node.[](:"name"))
+          current_namespace = (if @current_scope
+            @current_scope.name
+.to_namespace
+          else
+            RBS::Namespace.root
+          end)
+          superclass_type = nil
+          superclass_output = nil
+          (if node.[](:"superclass")
+            @eval_vars = true
+            superclass_output = visit_node(node.[](:"superclass"))
+            @eval_vars = false
+            superclass_type = RBS::Parser.parse_type(superclass_output)
+            (if node.dig(:"superclass", :"type")
+.==("Generic")
+              superclass_output = superclass_output.[](/^[^\[]+/)
+            end)
+          end)
+          src.write_ln("class #{class_name}#{(if superclass_output
+            " < #{superclass_output}"
+          end)}")
+          class_type = RBS::AST::Declarations::Class.new(name:           RBS::TypeName.new(namespace: current_namespace, name:           class_name.to_sym), type_params:           RBS::AST::Declarations::ModuleTypeParams.new, super_class: superclass_type, members:           Array.new, annotations:           Array.new, location:           node.[](:"location"), comment:           node.[](:"comment"))
+          old_parent_scope = @current_scope
+          @current_scope = class_type
+          indented(src) { ||
+            (if node.[](:"body")
+              src.write_ln(visit_node(node.[](:"body")))
+            end)
+          }
+          src.write_ln("end")
+          @current_scope = old_parent_scope
+          (if @current_scope
+            @current_scope.members
+.<<(class_type)
+          end)
+          (if @type_checker
+            unless @current_scope
+              @type_checker.top_level_decls
+.[]=(class_type.name
+.name, class_type)
+            end
+          end)
+        when "ModuleNode"
+          module_name = visit_node(node.[](:"name"))
+          src.write_ln("module #{module_name}")
+          current_namespace = (if @current_scope
+            @current_scope.name
+.to_namespace
+          else
+            RBS::Namespace.root
+          end)
+          module_type = RBS::AST::Declarations::Module.new(name:           RBS::TypeName.new(namespace: current_namespace, name:           module_name.to_sym), type_params:           RBS::AST::Declarations::ModuleTypeParams.new, self_types:           Array.new, members:           Array.new, annotations:           Array.new, location:           node.[](:"location"), comment:           node.[](:"comment"))
+          old_parent_scope = @current_scope
+          @current_scope = module_type
+          indented(src) { ||
+            (if node.[](:"body")
+              src.write_ln(visit_node(node.[](:"body")))
+            end)
+          }
+          @current_scope = old_parent_scope
+          (if @current_scope
+            @current_scope.members
+.<<(module_type)
+          end)
+          (if @type_checker
+            unless @current_scope
+              @type_checker.top_level_decls
+.[]=(module_type.name
+.name, module_type)
+            end
+          end)
+          src.write_ln("end")
+        when "DefNode"
+          args = render_args(node)
+          src.write_ln("def #{node.[](:"name")}#{args}")
+          return_type = (if node.[](:"return_type")
+            RBS::Types::ClassInstance.new(name:             RBS::TypeName.new(name:             eval(visit_node(node.[](:"return_type")))
+.to_s
+.to_sym, namespace:             RBS::Namespace.root), args: EMPTY_ARRAY, location:             node.[](:"location"))
+          else
+            RBS::Types::Bases::Any.new(location:             node.[](:"location"))
+          end)
+          # @type var rp: Array[Hash[Symbol, Any]]
+          rp =           node.fetch(:"positional_args") { ||
+EMPTY_ARRAY          }
+.filter() { |a|
+!a.[](:"value")          }
+          # @type var op: Array[Hash[Symbol, Any]]
+          op =           node.fetch(:"positional_args") { ||
+EMPTY_ARRAY          }
+.filter() { |a|
+            a.[](:"value")
+          }
+          method_types = [RBS::MethodType.new(type_params: EMPTY_ARRAY, type:           RBS::Types::Function.new(required_positionals:           rp.map() { |a|
+            RBS::Types::Function::Param.new(name:             visit_node(a)
+.to_sym, type:             RBS::Types::Bases::Any.new(location:             a.[](:"location")))
+          }, optional_positionals:           op.map() { |a|
+            RBS::Types::Function::Param.new(name:             visit_node(a)
+.to_sym, type:             RBS::Types::Bases::Any.new(location:             a.[](:"location")))
+          }, rest_positionals:           (if rpa = node.[](:"rest_p_args")
+            RBS::Types::Function::Param.new(name:             visit_node(rpa)
+.to_sym, type:             RBS::Types::Bases::Any.new(location:             node.[](:"location")))
+          else
+            nil
+          end), trailing_positionals: EMPTY_ARRAY, required_keywords: node.[](:"req_kw_args") || EMPTY_HASH, optional_keywords: node.[](:"opt_kw_args") || EMPTY_HASH, rest_keywords:           (if node.[](:"rest_kw_args")
+            RBS::Types::Function::Param.new(name:             visit_node(node.[](:"rest_kw_args"))
+.to_sym, type:             RBS::Types::Bases::Any.new(location:             node.[](:"location")))
+          else
+            nil
+          end), return_type: return_type), block:           (if node.[](:"yield_arg_count")
+            RBS::Types::Block.new(type:             RBS::Types::Function.new(required_positionals:             Array.new, optional_positionals:             Array.new, rest_positionals: nil, trailing_positionals:             Array.new, required_keywords:             Hash.new, optional_keywords:             Hash.new, rest_keywords: nil, return_type:             RBS::Types::Bases::Any.new(location:             node.[](:"location"))), required: !!node.[](:"block_arg") || node.[](:"yield_arg_count"))
+          else
+            nil
+          end), location:           node.[](:"location"))]
+          method_definition = RBS::AST::Members::MethodDefinition.new(name:           node.[](:"name")
+.to_sym, kind: :"instance", types: method_types, annotations: EMPTY_ARRAY, location:           node.[](:"location"), comment:           node.[](:"comment"), overload: false)
+          (if @current_scope
+            @current_scope.members
+.<<(method_definition)
+          else
+            (if @type_checker
+              @type_checker.type_env
+.<<(method_definition)
+            end)
+          end)
+          indented(src) { ||
+            (if node.[](:"body")
+              src.write_ln(visit_node(node.[](:"body")))
+            end)
+          }
+          src.write_ln("end")
+        when "VisibilityModifier"
+          src.write_ln("#{node.[](:"visibility")} #{visit_node(node.[](:"exp"))}")
+        when "CollectionNode"
+          node.[](:"children")
+.each() { |a|
+            src.write(visit_node(a, scope))
+          }
+        when "Call"
+          obj = (if node.[](:"object")
+            "#{visit_node(node.[](:"object"), scope)}."
+          else
+            ""
+          end)
+          arg_arr = node.fetch(:"args") { ||
+EMPTY_ARRAY          }
+          (if node.[](:"named_args")
+            arg_arr += node.[](:"named_args")
+          end)
+          args = (if !arg_arr.empty? || node.[](:"block_arg")
+            "#{arg_arr.map() { |a|
+              visit_node(a, scope)
+.strip
+            }
+.reject(&:"blank?")
+.join(", ")}#{(if node.[](:"block_arg")
+              "&#{visit_node(node.[](:"block_arg"))
+.strip}"
+            end)}"
+          else
+            nil
+          end)
+          block = (if node.[](:"block")
+            " #{visit_node(node.[](:"block"))}"
+          else
+            nil
+          end)
+          has_parens = !!node.[](:"has_parentheses") || args || block
+          opening_delimiter = (if has_parens
+            "("
+          else
+            nil
+          end)
+          call = "#{obj}#{node.[](:"name")}#{opening_delimiter}#{args}#{(if has_parens
+            ")"
+          end)}#{block}"
+          src.write_ln(call)
+        when "Block"
+          src.write("{ |#{node.[](:"args")
+.map() { |a|
+            visit_node(a)
+          }
+.join(", ")}|\n")
+          indented(src) { ||
+            src.write(visit_node(node.[](:"body")))
+          }
+          src.write_ln("}")
+        when "RangeLiteral"
+          dots = (if node.[](:"exclusive")
+            "..."
+          else
+            ".."
+          end)
+          src.write("(", visit_node(node.[](:"from")), dots, visit_node(node.[](:"to")), ")")
+        when "LiteralNode"
+          src.write(node.[](:"value"))
+        when "ArrayLiteral"
+          src.write("[", node.[](:"elements")
+.map() { |e|
+            visit_node(e)
+.strip
+          }
+.join(", "), "]")
+          (if node.[](:"frozen")
+            src.write(".freeze")
+          end)
+        when "StringInterpolation"
+          contents = node.[](:"contents")
+.inject(String.new) { |str, c|
+            str.<<(case c.[](:"type")
+              when "LiteralNode"
+                c.[](:"value")
+.[]((1...-1))
+              else
+                ["\#{", visit_node(c)
+.strip, "}"].join
+            end)
+          }
+          src.write("\"", contents, "\"")
+        when "Path"
+          src.write(node.[](:"value"))
+        when "Require"
+          src.write_ln("require \"#{node.[](:"value")}\"")
+        when "Assign", "OpAssign"
+          src.write_ln("#{visit_node(node.[](:"target"))} #{node.[](:"op")}= #{visit_node(node.[](:"value"))
+.strip}")
+        when "MultiAssign"
+          src.write_ln("#{node.[](:"targets")
+.map() { |t|
+            visit_node(t)
+.strip
+          }
+.join(", ")} = #{node.[](:"values")
+.map() { |v|
+            visit_node(v)
+.strip
+          }
+.join(", ")}")
+        when "Var"
+          (if @eval_vars
+            src.write(scope.[](node.[](:"name")))
+          else
+            src.write(node.[](:"name"))
+          end)
+        when "InstanceVar"
+          src.write(node.[](:"name"))
+        when "GlobalVar"
+          src.write(node.[](:"name"))
+        when "Arg"
+          val = node.[](:"external_name")
+          (if node.[](:"keyword_arg")
+            val += ":"
+            (if node.[](:"value")
+              val += " #{visit_node(node.[](:"value"))}"
+            end)
+          else
+            (if node.[](:"value")
+              val += " = #{visit_node(node.[](:"value"))}"
+            end)
+          end)
+          src.write(val)
+        when "UnaryExpr"
+          src.write("#{node.[](:"op")}#{visit_node(node.[](:"value"))
+.strip}")
+        when "BinaryOp"
+          src.write(visit_node(node.[](:"left"))
+.strip, " #{node.[](:"op")} ", visit_node(node.[](:"right"))
+.strip)
+        when "HashLiteral"
+          contents = node.[](:"elements")
+.map() { |k, v|
+            key = case k
+              when String
+                k.to_sym
+              else
+                visit_node(k)
+            end
+            value = visit_node(v)
+"#{key.inspect} => #{value}"          }
+          src.write("{#{contents.join(",\n")}}")
+          (if node.[](:"frozen")
+            src.write(".freeze")
+          end)
+        when "Enum"
+          src.write_ln("module #{node.[](:"name")}")
+          node.[](:"members")
+.each_with_index() { |m, i|
+            indented(src) { ||
+              src.write_ln(visit_node(m)
+.+((if !m.[](:"value")
+                " = #{i}"
+              else
+                ""
+              end)))
+            }
+          }
+          src.write_ln("end")
+        when "If"
+          src.write_ln("(if #{visit_node(node.[](:"condition"))
+.strip}")
+          indented(src) { ||
+            src.write_ln(visit_node(node.[](:"then")))
+          }
+          (if node.[](:"else")
+            src.write_ln("else")
+            indented(src) { ||
+              src.write_ln(visit_node(node.[](:"else")))
+            }
+          end)
+          src.write_ln("end)")
+        when "Unless"
+          src.write_ln("unless #{visit_node(node.[](:"condition"))}")
+          indented(src) { ||
+            src.write_ln(visit_node(node.[](:"then")))
+          }
+          (if node.[](:"else")
+            src.write_ln("else")
+            indented(src) { ||
+              src.write_ln(visit_node(node.[](:"else")))
+            }
+          end)
+          src.write_ln("end")
+        when "Case"
+          src.write("case")
+          (if node.[](:"condition")
+            src.write(" #{visit_node(node.[](:"condition"))
+.strip}\n")
+          end)
+          indented(src) { ||
+            node.[](:"whens")
+.each() { |w|
+              src.write_ln(visit_node(w))
+            }
+            (if node.[](:"else")
+              src.write_ln("else")
+              indented(src) { ||
+                src.write_ln(visit_node(node.[](:"else")))
+              }
+            end)
+          }
+          src.write_ln("end")
+        when "When"
+          src.write_ln("when #{node.[](:"conditions")
+.map() { |n|
+            visit_node(n)
+          }
+.join(", ")}")
+          indented(src) { ||
+            src.write_ln((if node.[](:"body")
+              visit_node(node.[](:"body"))
+            else
+              "# no op"
+            end))
+          }
+        when "MacroFor"
+          vars, expr, body = node.[](:"vars"), node.[](:"expr"), node.[](:"body")
+          var_names = vars.map() { |v|
+            visit_node(v)
+          }
+          @inside_macro = true
+          indent_level = @indent_level
+          unless           indent_level.zero?
+            @indent_level -= 1
           end
-          if node[:ensure]
-            src.write_ln "ensure"
-            intended(src) { src.write_ln visit_node(node[:ensure]) }
+          # @type var expanded: Array[String]
+          expanded =           eval(visit_node(expr))
+.map() { |a|
+            locals = [var_names.join("\", \"")].zip(a)
+.to_h
+            (if @inside_macro
+              locals.merge!(scope)
+            end)
+            visit_node(body, locals)
+          }
+.flatten
+          unless           indent_level.zero?
+            @indent_level += 1
           end
-        src.write_ln "end"
-      when "Generic"
-        src.write "#{node[:name]}[#{node[:args].map { |a| visit_node a }.join(", ")}]"
-      when "Proc"
-        fn = node[:function]
-        src.write "->#{render_args(fn)} { #{visit_node fn[:body]} }"
-      when "Include"
-        src.write_ln "include #{visit_node node[:name]}"
-      when "Extend"
-        src.write_ln "extend #{visit_node node[:name]}"
-      when "RegexLiteral"
-        contents = visit_node node[:value]
-        src.write Regexp.new(contents.undump).inspect
-      when "EmptyNode"
-        # pass
-      else
-        raise "Not implemented: #{node[:type]}"
+          expanded.each() { |e|
+            src.write(e)
+          }
+          @inside_macro = false
+        when "MacroLiteral"
+          src.write(node.[](:"value"))
+        when "MacroExpression"
+          (if node.[](:"output")
+            expr = visit_node(node.[](:"expr"), scope)
+            val = scope.[](expr)
+            src.write(val)
+          end)
+        when "MacroIf"
+          (if evaluate_macro_condition(node.[](:"condition"), scope)
+            (if node.[](:"then")
+              src.write_ln(visit_node(node.[](:"then"), scope))
+            end)
+          else
+            (if node.[](:"else")
+              src.write_ln(visit_node(node.[](:"else"), scope))
+            end)
+          end)
+        when "Return"
+          val = (if node.[](:"value")
+            " #{visit_node(node.[](:"value"))
+.strip}"
+          else
+            nil
+          end)
+          src.write("return#{val}")
+        when "TypeDeclaration"
+          src.write_ln("# @type var #{visit_node(node.[](:"var"))}: #{visit_node(node.[](:"declared_type"))}")
+          src.write_ln("#{visit_node(node.[](:"var"))} = #{visit_node(node.[](:"value"))}")
+        when "ExceptionHandler"
+          src.write_ln("begin")
+          indented(src) { ||
+            src.write_ln(visit_node(node.[](:"body")))
+          }
+          (if node.[](:"rescues")
+            node.[](:"rescues")
+.each() { |r|
+              src.write_ln("rescue #{(if r.[](:"types")
+                r.[](:"types")
+.map() { |n|
+                  visit_node(n)
+                }
+.join(", ")
+              end)}#{(if r.[](:"name")
+                " => #{r.[](:"name")}"
+              end)}")
+              (if r.[](:"body")
+                indented(src) { ||
+                  src.write_ln(visit_node(r.[](:"body")))
+                }
+              end)
+            }
+          end)
+          (if node.[](:"else")
+            src.write_ln("else")
+            indented(src) { ||
+              src.write_ln(visit_node(node.[](:"else")))
+            }
+          end)
+          (if node.[](:"ensure")
+            src.write_ln("ensure")
+            indented(src) { ||
+              src.write_ln(visit_node(node.[](:"ensure")))
+            }
+          end)
+          src.write_ln("end")
+        when "Generic"
+          src.write("#{visit_node(node.[](:"name"))}[#{node.[](:"args")
+.map() { |a|
+            visit_node(a)
+          }
+.join(", ")}]")
+        when "Proc"
+          fn = node.[](:"function")
+          src.write("->#{render_args(fn)} { #{visit_node(fn.[](:"body"))} }")
+        when "Include"
+          current_namespace = (if @current_scope
+            @current_scope.name
+.to_namespace
+          else
+            RBS::Namespace.root
+          end)
+          name = visit_node(node.[](:"name"))
+          src.write_ln("include #{name}")
+          type = RBS::AST::Members::Include.new(name:           method(:"TypeName")
+.call(name), args:           Array.new, annotations:           Array.new, location:           node.[](:"location"), comment:           node.[](:"comment"))
+          (if @current_scope
+            @current_scope.members
+.<<(type)
+          else
+            @type_checker.type_env
+.<<(type)
+          end)
+        when "Extend"
+          current_namespace = (if @current_scope
+            @current_scope.name
+.to_namespace
+          else
+            RBS::Namespace.root
+          end)
+          name = visit_node(node.[](:"name"))
+          src.write_ln("extend #{name}")
+          type = RBS::AST::Members::Extend.new(name:           method(:"TypeName")
+.call(name), args:           Array.new, annotations:           Array.new, location:           node.[](:"location"), comment:           node.[](:"comment"))
+          (if @current_scope
+            @current_scope.members
+.<<(type)
+          else
+            @type_checker.type_env
+.<<(type)
+          end)
+        when "RegexLiteral"
+          contents = visit_node(node.[](:"value"))
+          src.write(Regexp.new(contents.undump)
+.inspect)
+        when "Union"
+          types = node.[](:"types")
+          output = (if types.length
+.==(2) && types.[](1)
+.[](:"type")
+.==("Path") && types.[](1)
+.[]("value")
+.==(nil)
+            "#{visit_node(types.[](0))}?"
+          else
+            types.map() { |t|
+              visit_node(t)
+            }
+.join(" | ")
+          end)
+          src.write(output)
+        when "EmptyNode"
+          # no op
+        else
+          raise("Not implemented: #{node.[](:"type")}")
       end
-
-      src
+src
     end
-
-    private
-
-    def evaluate_macro_condition(condition_node, scope)
+    private     def evaluate_macro_condition(condition_node, scope)
       @eval_vars = true
       eval(visit_node(condition_node, scope))
       @eval_vars = false
     end
-
-    def indented(src)
+    private     def indented(src)
       increment_indent(src)
       yield
       decrement_indent(src)
     end
-
-    def increment_indent(src)
+    private     def increment_indent(src)
       @indent_level += 1
       src.increment_indent
     end
-
-    def decrement_indent(src)
+    private     def decrement_indent(src)
       @indent_level -= 1
       src.decrement_indent
     end
-
-    def render_args(node)
-      rp = node[:rp_args] || EMPTY_ARRAY
-      op = node[:op_args] || EMPTY_ARRAY
-      rkw = node[:req_kw_args] || EMPTY_HASH
-      okw = node[:opt_kw_args] || EMPTY_HASH
-      rest_p = node[:rest_p_args]
-      rest_kw = node[:rest_kw_args]
-      return nil unless [rp, op, rkw, okw, rest_p, rest_kw].any? { |a| !a.nil? || !a.empty? }
-
-      contents = [
-        rp.map { |a| visit_node(a) },
-        op.map { |pos| "#{pos.name} = #{value}" },
-        rkw.map { |name, _| "#{name}:" },
-        okw.map { |name, _| "#{name}: #{value}" },
-        rest_p ? "*#{rest_p}" : "",
-        rest_kw ? "**#{visit_node(rest_kw)}" : ""
-      ].reject(&:empty?).flatten.join(", ")
-      "(#{contents})"
+    private     def render_args(node)
+      # @type var rp: Array[Hash[Symbol, Any]]
+      rp =       node.fetch(:"positional_args") { ||
+EMPTY_ARRAY      }
+.filter() { |a|
+!a.[](:"value")      }
+      # @type var op: Array[Hash[Symbol, Any]]
+      op =       node.fetch(:"positional_args") { ||
+EMPTY_ARRAY      }
+.filter() { |a|
+        a.[](:"value")
+      }
+      # @type var rkw: Hash[Symbol, Any]
+      rkw =       node.fetch(:"req_kw_args") { ||
+EMPTY_HASH      }
+      # @type var okw: Hash[Symbol, Any]
+      okw =       node.fetch(:"opt_kw_args") { ||
+EMPTY_HASH      }
+      # @type var rest_p: String?
+      rest_p =       (if node.[](:"rest_p_args")
+        visit_node(node.[](:"rest_p_args"))
+      else
+        nil
+      end)
+      # @type var rest_kw: Hash[Symbol, Any]?
+      rest_kw =       node.[](:"rest_kw_args")
+      (if [rp, op, rkw, okw, rest_p, rest_kw].all?() { |a|
+a && a.empty?      }
+        return nil
+      end)
+      contents = [rp.map() { |a|
+        visit_node(a)
+      }, op.map() { |a|
+"#{a.[](:"name")} = #{visit_node(a.[](:"value"))
+.strip}"      }, rkw.map() { |name, _|
+"#{name}:"      }, okw.map() { |name, value|
+"#{name}: #{value}"      }, (if rest_p
+        "*#{rest_p}"
+      else
+        ""
+      end), (if rest_kw
+        "**#{visit_node(rest_kw)}"
+      else
+        ""
+      end)].reject(&:"empty?")
+.flatten
+.join(", ")
+"(#{contents})"
     end
   end
 end