gloss 0.0.1 → 0.0.6

data/ext/gloss/src/rb_ast.cr

@@ -43,13 +43,14 @@ module Rb
     end
 
     class Block < Node
-      @info : NamedTuple(type: String, args: Array(Var), body: Node)
+      @info : NamedTuple(type: String, positional_args: Array(Var), body: Node, rest_p_args: Node?)
 
-      def initialize(args, body)
+      def initialize(args, splat, body)
         @info = {
           type: self.class.name.split("::").last,
           body: body,
-          args: args,
+          positional_args: args,
+          rest_p_args: splat
         }
       end
 
@@ -94,18 +95,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?)
-
-      def initialize(name : String, rp_args : Array(Arg), body : Node, receiver : Node?, return_type : Node?, rest_kw_args)
+      @info : NamedTuple(type: String, name: String, body: Node, positional_args: Array(Arg), receiver: Node?,
+        return_type: Node?, rest_kw_args: Arg?, rest_p_args: Arg?, block_arg: Node?, yield_arg_count: Int32?)
+
+      def initialize(
+        receiver : Node?,
+        name : String,
+        positional_args : Array(Arg),
+        splat,
+        rest_kw_args,
+        body : Node,
+        return_type : Node?,
+        yields : Int32?,
+        block_arg : Node?
+      )
         @info = {
-          type:         self.class.name.split("::").last,
-          name:         name,
-          body:         body,
-          rp_args:      rp_args,
-          rest_kw_args: rest_kw_args,
-          receiver:     receiver,
-          return_type:  return_type,
+          type:            self.class.name.split("::").last,
+          name:            name,
+          body:            body,
+          positional_args: positional_args,
+          rest_kw_args:    rest_kw_args,
+          receiver:        receiver,
+          return_type:     return_type,
+          rest_p_args:     splat,
+          yield_arg_count: yields,
+          block_arg: block_arg
         }
       end
 
@@ -113,16 +127,17 @@ module Rb
     end
 
     class Arg < Node
-      @info : NamedTuple(type: String, name: String, external_name: String, default_value: Node?,
-        restriction: Node?)
+      @info : NamedTuple(type: String, name: String, external_name: String, value: Node?,
+        restriction: Node?, keyword_arg: Bool)
 
-      def initialize(name : String, external_name : String, restriction : Node?, default_value : Node?)
+      def initialize(name : String, external_name : String, restriction : Node?, value : Node?, keyword_arg)
         @info = {
           type:          self.class.name.split("::").last,
           name:          name,
           restriction:   restriction,
-          default_value: default_value,
+          value:         value,
           external_name: external_name,
+          keyword_arg:   keyword_arg,
         }
       end
 
@@ -198,7 +213,17 @@ module Rb
       delegate :to_json, to: @info
     end
 
-    class RegexLiteral < NodeWithValue
+    class RegexLiteral < Node
+      @info : NamedTuple(type: String, value: Node)
+
+      def initialize(value)
+        @info = {
+          type:  self.class.name.split("::").last,
+          value: value,
+        }
+      end
+
+      delegate :to_json, to: @info
     end
 
     class Nop < Node
@@ -236,6 +261,9 @@ module Rb
     class InstanceVar < Var
     end
 
+    class GlobalVar < Var
+    end
+
     abstract class Conditional < Node
       @info : NamedTuple(type: String, condition: Node, then: Node, else: Node)
 
@@ -303,16 +331,19 @@ module Rb
     end
 
     class Call < Node
-      @info : NamedTuple(type: String, name: String, args: Array(Node), object: Node?, block: Block?, block_arg: Node?)
+      @info : NamedTuple(type: String, name: String, args: Array(Node), object: Node?, block: Block?, block_arg: Node?, named_args: Array(Arg)?, has_parentheses: Bool)
 
-      def initialize(object : Node?, name : String, args : Array(Node), block, block_arg)
+      def initialize(object : Node?, name : String, args : Array(Node), named_args, block,
+                     block_arg, has_parentheses)
         @info = {
-          type:      self.class.name.split("::").last,
-          name:      name,
-          args:      args,
-          object:    object,
-          block:     block,
-          block_arg: block_arg,
+          type:            self.class.name.split("::").last,
+          name:            name,
+          args:            args,
+          object:          object,
+          block:           block,
+          block_arg:       block_arg,
+          named_args:      named_args,
+          has_parentheses: has_parentheses || false,
         }
       end
 
@@ -383,6 +414,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)
 
@@ -487,5 +532,86 @@ module Rb
 
       delegate :to_json, to: @info
     end
+
+    class Union < Node
+      @info : NamedTuple(type: String, types: Array(Node))
+
+      def initialize(types)
+        @info = {
+          type:  self.class.name.split("::").last,
+          types: types,
+        }
+      end
+
+      delegate :to_json, to: @info
+    end
+
+    class Generic < Node
+      @info : NamedTuple(type: String, name: Node, args: Array(Node))
+
+      def initialize(name, args)
+        @info = {
+          type: self.class.name.split("::").last,
+          name: name,
+          args: args,
+        }
+      end
+
+      delegate :to_json, to: @info
+    end
+
+    class Proc < Node
+      @info : NamedTuple(type: String, function: DefNode)
+
+      def initialize(function)
+        @info = {
+          type:     self.class.name.split("::").last,
+          function: function,
+        }
+      end
+
+      delegate :to_json, to: @info
+    end
+
+    class NodeWithNameNode < Node
+      @info : NamedTuple(type: String, name: Node)
+
+      def initialize(name)
+        @info = {
+          type: self.class.name.split("::").last,
+          name: name,
+        }
+      end
+
+      delegate :to_json, to: @info
+    end
+
+    class Extend < NodeWithNameNode
+    end
+
+    class Include < NodeWithNameNode
+    end
+
+    class VisibilityModifier < Node
+      @info : NamedTuple(type: String, visibility: String, exp: Node)
+
+      def initialize(visibility : Crystal::Visibility, exp : Node)
+        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/gloss.gemspec

@@ -17,6 +17,7 @@ Gem::Specification.new do |s|
 
   s.add_runtime_dependency "fast_blank"
   s.add_runtime_dependency "listen"
+  s.add_runtime_dependency "rbs"
   s.add_runtime_dependency "steep"
 
   s.add_development_dependency "rake-compiler"

data/lib/gloss.rb

@@ -8,6 +8,8 @@ require "fast_blank"
 require "gloss/version"
 require "gloss/cli"
 require "gloss/watcher"
+require "gloss/type_checker"
+require "gloss/parser"
 require "gloss/initializer"
 require "gloss/config"
 require "gloss/writer"
@@ -15,8 +17,9 @@ require "gloss/source"
 require "gloss/scope"
 require "gloss/builder"
 require "gloss/errors"
+require "gloss/logger"
 
-require "gloss.bundle"
+require "gls" unless ENV["CI"] # a bit of a hack for now
 
 EMPTY_ARRAY = [].freeze
 EMPTY_HASH = {}.freeze

data/lib/gloss/builder.rb

@@ -1,442 +1,640 @@
-# frozen_string_literal: true
+  # frozen_string_literal: true
+
+  ##### This file was generated by Gloss; any changes made here will be overwritten.
+  ##### See src/ to make changes
 
 module Gloss
+  module Utils
+    module_function
+    def with_file_header(str)
+      "#{Builder::FILE_HEADER}\n\n#{str}"
+    end
+  end
   class Builder
-    attr_reader :tree
-
-    def initialize(str)
+    FILE_HEADER = "  #{(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"
+    include Utils
+    attr_reader(:"tree")
+    def initialize(tree_hash, type_checker = nil)
       @indent_level = 0
       @inside_macro = false
       @eval_vars = false
-      tree_json = Gloss.parse_buffer str
-      begin
-        @tree = JSON.parse tree_json, symbolize_names: true
-      rescue JSON::ParserError
-        raise Errors::ParserError, tree_json
-      end
       @current_scope = nil
-      @steep_target = Steep::Project::Target.new(
-        name: "gloss",
-        options: Steep::Project::Options.new,
-        source_patterns: ["gloss"],
-        ignore_patterns: [],
-        signature_patterns: []
-      )
-      Dir.glob("sig/**/*.rbs").each do |fp|
-        next if !@steep_target.possible_signature_file?(fp) || @steep_target.signature_file?(fp)
-
-        Steep.logger.info { "Adding signature file: #{fp}" }
-        @steep_target.add_signature path, (Pathname(".") + fp).cleanpath.read
-      end
-      @top_level_decls = {}
+      @tree = tree_hash
+      @type_checker = type_checker
     end
-
-    def run
+    def run()
       rb_output = visit_node(@tree)
-      rb_output = "# frozen_string_literal: true\n#{rb_output}" if Config.frozen_string_literals
-
-      unless check_types(rb_output)
-        raise Errors::TypeError,
-              @steep_target.errors.map { |e|
-                case e
-                when Steep::Errors::NoMethod
-                  "Unknown method :#{e.method}, location: #{e.type.location.inspect}"
-                when Steep::Errors::MethodBodyTypeMismatch
-                  "Invalid method body type - expected: #{e.expected}, actual: #{e.actual}"
-                when Steep::Errors::IncompatibleArguments
-                  "Invalid argmuents - method type: #{e.method_type}, receiver type: #{e.receiver_type}"
-                when Steep::Errors::ReturnTypeMismatch
-                  "Invalid return type - expected: #{e.expected}, actual: #{e.actual}"
-                when Steep::Errors::IncompatibleAssignment
-                  "Invalid assignment - cannot assign #{e.rhs_type} to type #{e.lhs_type}"
-                else
-                  e.inspect
-                end
-              }.join("\n")
-      end
-
-      rb_output
+      with_file_header(rb_output)
     end
-
-    def check_types(rb_str)
-      env_loader = RBS::EnvironmentLoader.new
-      env = RBS::Environment.from_loader(env_loader)
-
-      @top_level_decls.each do |_, decl|
-        env << decl
-      end
-      env = env.resolve_type_names
-
-      @steep_target.instance_variable_set("@environment", env)
-      @steep_target.add_source("gloss", rb_str)
-
-      definition_builder = RBS::DefinitionBuilder.new(env: env)
-      factory = Steep::AST::Types::Factory.new(builder: definition_builder)
-      check = Steep::Subtyping::Check.new(factory: factory)
-      validator = Steep::Signature::Validator.new(checker: check)
-      validator.validate
-
-      raise Errors::TypeValidationError, validator.each_error.to_a.join("\n") unless validator.no_error?
-
-      @steep_target.run_type_check(env, check, Time.now)
-
-      @steep_target.status.is_a?(Steep::Project::Target::TypeCheckStatus) &&
-        @steep_target.no_error? &&
-        @steep_target.errors.empty?
-    end
-
     def visit_node(node, scope = Scope.new)
       src = Source.new(@indent_level)
-      case node[:type]
-      when "ClassNode"
-        class_name = visit_node(node[:name])
-        superclass = if node[:superclass]
-                       @eval_vars = true
-                       visit_node(node[:superclass])
-                       @eval_vars = false
-                     else
-                       nil
-                     end
-
-        src.write_ln "class #{class_name}#{" < #{superclass}" if superclass}"
-
-        current_namespace = @current_scope ? @current_scope.name.to_namespace : RBS::Namespace.root
-        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 ? RBS::AST::Declarations::Class::Super.new(name: RBS::Typename.new(name: super_class.to_sym, namespace: RBS::Namespace.root), args: [], location: nil) : nil,
-          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
-        @top_level_decls[class_type.name.name] = class_type unless @current_scope
-      when "ModuleNode"
-        module_name = visit_node node[:name]
-        src.write_ln "module #{module_name}"
-
-        current_namespace = RBS::Namespace.root # RBS::Namespace.new(path: [module_name.to_sym], absolute: false)
-
-        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
-        @top_level_decls[module_type.name.name] = module_type unless @current_scope
-        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: [],
-              optional_positionals: [],
-              rest_positionals: nil,
-              trailing_positionals: [],
-              required_keywords: {},
-              optional_keywords: {},
-              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_env << method_definition # 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 = 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 "Arg"
-
-        src.write node[:external_name]
-
-      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 "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)
+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)
+          receiver = (if node.[](:"receiver")
+            visit_node(node.[](:"receiver"))
+          else
+            nil
+          end)
+          src.write_ln("def #{(if receiver
+            "#{receiver}."
+          end)}#{node.[](:"name")}#{args.[](:"representation")}")
+          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)
+          method_types = [RBS::MethodType.new(type_params: EMPTY_ARRAY, type:           RBS::Types::Function.new(required_positionals:           args.dig(:"types", :"required_positionals"), optional_positionals:           args.dig(:"types", :"optional_positionals"), rest_positionals:           args.dig(:"types", :"rest_positionals"), trailing_positionals:           args.dig(:"types", :"trailing_positionals"), required_keywords:           args.dig(:"types", :"required_keywords"), optional_keywords:           args.dig(:"types", :"optional_keywords"), rest_keywords:           args.dig(:"types", :"rest_keywords"), 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:           (if receiver
+            :"class"
+          else
+            :"instance"
+          end), 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"
+          args = render_args(node)
+          src.write("{ #{args.[](:"representation")
+.gsub(/(\A\(|\)\z)/, "|")}\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
+.inspect
+              else
+                visit_node(k)
+            end
+            value = visit_node(v)
+"#{key} => #{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
-        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]
+          # @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
+          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 "Next"
+          (if node.[](:"value")
+            val = " #{node.[](:"value")}"
+          end)
+          src.write("next#{val}")
+        when "EmptyNode"
+          # no op
         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"
-        src.write_ln visit_node(node[:body])
-        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]}"
-          src.write_ln visit_node(r[:body]) if r[:body]
-        end
-        if node[:else]
-          src.write_ln "else"
-          src.write_ln visit_node(node[:else])
-        end
-        if node[:ensure]
-          src.write_ln "ensure"
-          src.write_ln visit_node(node[:ensure])
-        end
-        src.write_ln "end"
-      when "EmptyNode"
-        # pass
-      else
-        raise "Not implemented: #{node[:type]}"
+          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(", ")
+      representation = "(#{contents})"
+      rp.map!() { |a|
+        RBS::Types::Function::Param.new(name:         visit_node(a)
+.to_sym, type:         RBS::Types::Bases::Any.new(location:         a.[](:"location")))
+      }
+      op.map!() { |a|
+        RBS::Types::Function::Param.new(name:         visit_node(a)
+.to_sym, type:         RBS::Types::Bases::Any.new(location:         a.[](:"location")))
+      }
+      rest_p = (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)
+{:representation => representation,
+:types => {:required_positionals => rp,
+:optional_positionals => op,
+:rest_positionals => rest_p,
+: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)
+}.freeze}.freeze
     end
   end
 end