gloss 0.0.6 → 0.1.4

data/lib/gloss/config.rb

@@ -8,14 +8,20 @@ require "yaml"
 module Gloss
   CONFIG_PATH = ".gloss.yml"
   Config = OpenStruct.new(default_config: {:frozen_string_literals => true,
-:src_dir => "src"}.freeze)
-  user_config = (if File.exist?(CONFIG_PATH)
-    YAML.safe_load(File.read(CONFIG_PATH))
-  else
+:src_dir => "src",
+:entrypoint => nil,
+:strict_require => false,
+:type_checking_strictness => "strict"}.freeze)
+  def self.load_config()
+    user_config = (if File.exist?(File.absolute_path(File.join(Dir.pwd, CONFIG_PATH)))
+      YAML.safe_load(File.read(CONFIG_PATH))
+    else
+      Config.default_config
+    end)
     Config.default_config
-  end)
-  Config.default_config
 .each() { |k, v|
-    Config.send(:"#{k}=", user_config.[](k.to_s) || v)
-  }
+      Config.send(:"#{k}=", user_config.[](k.to_s) || v)
+    }
+  end
+  load_config
 end

data/lib/gloss/errors.rb

@@ -3,7 +3,7 @@
   ##### This file was generated by Gloss; any changes made here will be overwritten.
   ##### See src/ to make changes
 
-  module Gloss
+module Gloss
   module Errors
     class BaseGlossError < StandardError
     end

data/lib/gloss/logger.rb

@@ -22,13 +22,13 @@ nil => nil,
       @logger = Logger.new((if real_log_level
         STDOUT
       else
-        nil
+        IO::NULL
       end))
-      formatter = Logger::Formatter.new
-      @logger.formatter=(proc() { |severity, datetime, progname, msg|
-        formatter.call(severity, datetime, progname, msg)
-      })
-@logger
+.tap() { |l|
+        (if real_log_level
+          l.level=(real_log_level)
+        end)
+      }
     end)
   end
 end

data/lib/gloss/prog_loader.rb

@@ -0,0 +1,144 @@
+  # frozen_string_literal: true
+
+  ##### This file was generated by Gloss; any changes made here will be overwritten.
+  ##### See src/ to make changes
+
+require "rubygems/gem_runner"
+module Gloss
+  OUTPUT_BY_PATH = Hash.new
+  class ProgLoader
+    attr_reader(:"type_checker")
+    def initialize()
+      entrypoint = Config.entrypoint
+      (if entrypoint.==(nil) || entrypoint.==("")
+        throw(:"error", "Entrypoint is not yet set in .gloss.yml")
+      end)
+      @files_to_process = [Utils.absolute_path(Config.entrypoint), Utils.absolute_path(File.join(__dir__ || "", "..", "..", "sig", "core.rbs"))]
+      @processed_files = Set.new
+      @type_checker = TypeChecker.new
+    end
+    def run()
+      @files_to_process.each() { |path_string|
+        unless @processed_files.member?(path_string) || OUTPUT_BY_PATH.[](path_string)
+          Gloss.logger
+.debug("Loading #{path_string}")
+          path = Utils.absolute_path(path_string)
+          file_contents = File.open(path)
+.read
+          contents_tree = Parser.new(file_contents)
+.run
+          on_new_file_referenced = proc() { |ps, relative|
+            ps.each() { |pa|
+              (if relative
+                handle_require_relative(pa, path_string)
+              else
+                handle_require(pa)
+              end)
+            }
+          }
+          OUTPUT_BY_PATH.[]=(path_string, Visitor.new(contents_tree, @type_checker, on_new_file_referenced)
+.run)
+          @processed_files.add(path_string)
+        end
+      }
+@type_checker
+    end
+    STDLIB_TYPE_DEPENDENCIES = {"yaml" => ["pstore", "dbm"],
+"rbs" => ["logger", "set", "tsort"],
+"logger" => ["monitor"]}
+    private     def handle_require(path)
+      (if path.start_with?(".")
+        base = File.join(Dir.pwd, path)
+        fp = base.+(".gl")
+        (if File.exist?(fp)
+          @files_to_process.<<(fp)
+        end)
+return
+      end)
+      full = File.absolute_path("#{File.join(Config.src_dir, "lib", path)}.gl")
+      pathn = Pathname.new(full)
+      (if pathn.file?
+        @files_to_process.<<(pathn.to_s)
+      else
+        pathn = Pathname.new("#{File.join(Dir.pwd, "sig", path)}.rbs")
+        gem_path = Utils.gem_path_for(path)
+        (if gem_path
+          sig_files = Dir.glob(File.absolute_path(File.join(gem_path, "..", "sig", "**", "*.rbs")))
+          (if sig_files.length
+.positive?
+            sig_files.each() { |fp|
+              @type_checker.load_sig_path(fp)
+            }
+            @processed_files.add(path)
+            rbs_type_deps = STDLIB_TYPE_DEPENDENCIES.fetch(path) { ||
+nil            }
+            (if rbs_type_deps
+              rbs_type_deps.each() { |d|
+                handle_require(d)
+              }
+            end)
+return
+          end)
+        end)
+        (if pathn.file?
+          @type_checker.load_sig_path(pathn.to_s)
+          @processed_files.add(pathn.to_s)
+        else
+          rbs_stdlib_dir = File.absolute_path(File.join(@type_checker.rbs_gem_dir, "..", "stdlib", path))
+          (if Pathname.new(rbs_stdlib_dir)
+.exist?
+            load_rbs_from_require_path(path)
+            rbs_type_deps = STDLIB_TYPE_DEPENDENCIES.fetch(path) { ||
+nil            }
+            (if rbs_type_deps
+              rbs_type_deps.each() { |d|
+                load_rbs_from_require_path(d)
+              }
+            end)
+          else
+            (if Config.strict_require
+              throw(:"error", "Cannot resolve require path for #{path}")
+            else
+              Gloss.logger
+.debug("No path found for #{path}")
+            end)
+          end)
+        end)
+      end)
+    end
+    private     def handle_require_relative(path, source_file)
+      base = File.join(source_file, "..", path)
+      # @type var pn: String?
+      pn = nil
+      exts = [".gl"].concat(Gem.suffixes)
+      exts.each() { |ext|
+        full = File.absolute_path(base.+(ext))
+        (if File.exist?(full)
+          pn = full
+        end)
+      }
+      (if pn
+        unless         @files_to_process.include?(pn)
+          @files_to_process.<<(pn)
+        end
+      else
+        (if Config.strict_require
+          throw(:"error", "Cannot resolve relative path for #{path}")
+        else
+          Gloss.logger
+.debug("No path found for #{path}")
+        end)
+      end)
+    end
+    private     def rbs_stdlib_path_for(libr)
+      File.absolute_path(File.join(@type_checker.rbs_gem_dir, "..", "stdlib", libr))
+    end
+    private     def load_rbs_from_require_path(path)
+      Dir.glob(File.join(rbs_stdlib_path_for(path), "**", "*.rbs"))
+.each() { |fp|
+        @type_checker.load_sig_path(fp)
+        @processed_files.add(fp)
+      }
+    end
+  end
+end

data/lib/gloss/scope.rb

@@ -3,7 +3,7 @@
   ##### This file was generated by Gloss; any changes made here will be overwritten.
   ##### See src/ to make changes
 
-  module Gloss
+module Gloss
   class Scope < Hash
     def [](k)
       fetch(k) { ||

data/lib/gloss/source.rb

@@ -3,7 +3,7 @@
   ##### This file was generated by Gloss; any changes made here will be overwritten.
   ##### See src/ to make changes
 
-  module Gloss
+module Gloss
   class Source < String
     def initialize(indent_level)
       @indent_level = indent_level

data/lib/gloss/type_checker.rb

@@ -3,21 +3,39 @@
   ##### This file was generated by Gloss; any changes made here will be overwritten.
   ##### See src/ to make changes
 
-require "pry-byebug"
+require "set"
 module Gloss
   class TypeChecker
-    Project = Struct.new(:"targets")
-    attr_reader(:"steep_target", :"top_level_decls")
+    attr_reader(:"steep_target", :"top_level_decls", :"env", :"rbs_gem_dir")
+    module Strictness
+      Strict = "strict"
+      Lenient = "lenient"
+      Default = "default"
+    end
     def initialize()
-      @steep_target = Steep::Project::Target.new(name: "gloss", options:       Steep::Project::Options.new
-.tap() { |o|
-        o.allow_unknown_constant_assignment=(true)
-      }, source_patterns: ["gloss.rb"], ignore_patterns:       Array.new, signature_patterns: ["sig"])
-      @top_level_decls = {}
+      options = Steep::Project::Options.new
+case Config.type_checking_strictness
+        when Strictness::Strict
+          options.apply_strict_typing_options!
+        when Strictness::Lenient
+          options.apply_lenient_typing_options!
+        else
+          options.apply_default_typing_options!
+      end
+      @steep_target = Steep::Project::Target.new(name: "gloss", options: options, source_patterns: ["**/*.rb"], ignore_patterns:       Array.new, signature_patterns: ["sig"])
+      @top_level_decls = Set.new
+      @rbs_gem_dir = Utils.gem_path_for("rbs")
+      env_loader = RBS::EnvironmentLoader.new
+      @env = RBS::Environment.from_loader(env_loader)
+      project = Steep::Project.new(steepfile_path:       Pathname.new(Config.src_dir)
+.realpath)
+      project.targets
+.<<(@steep_target)
+      loader = Steep::Project::FileLoader.new(project: project)
     end
-    def run(rb_str)
+    def run(filepath, rb_str)
       begin
-        valid_types = check_types(rb_str)
+        valid_types = check_types(filepath, rb_str)
       rescue ParseError => e
         throw(:"error", "")
       rescue  => e
@@ -34,10 +52,8 @@ case e
             when Steep::Diagnostic::Ruby::MethodBodyTypeMismatch
               "Invalid method body type - expected: #{e.expected}, actual: #{e.actual}"
             when Steep::Diagnostic::Ruby::IncompatibleArguments
-              "Invalid argmuents - method type: #{e.method_type}\nmethod name: #{e.method_type
-.method_decls
-.first
-.method_name}"
+              "Invalid argmuents - method type: #{e.method_types
+.first}\nmethod name: #{e.method_name}"
             when Steep::Diagnostic::Ruby::ReturnTypeMismatch
               "Invalid return type - expected: #{e.expected}, actual: #{e.actual}"
             when Steep::Diagnostic::Ruby::IncompatibleAssignment
@@ -45,7 +61,7 @@ case e
             when Steep::Diagnostic::Ruby::UnexpectedBlockGiven
               "Unexpected block given"
             else
-              e.inspect
+              "#{e.header_line}\n#{e}"
           end
         }
 .join("\n")
@@ -53,30 +69,36 @@ case e
       end
 true
     end
-    def check_types(rb_str)
-      env_loader = RBS::EnvironmentLoader.new
-      env = RBS::Environment.from_loader(env_loader)
-      project = Steep::Project.new(steepfile_path:       Pathname.new(Config.src_dir)
-.realpath)
-      project.targets
-.<<(@steep_target)
-      loader = Steep::Project::FileLoader.new(project: project)
-      loader.load_signatures
-      @steep_target.add_source("gloss.rb", rb_str)
-      @top_level_decls.each() { |_, decl|
-        env.<<(decl)
+    def ready_for_checking!()
+      @top_level_decls.each() { |decl|
+        @env.<<(decl)
       }
-      env = env.resolve_type_names
-      @steep_target.instance_variable_set("@environment", env)
+      @env = @env.resolve_type_names
+      @steep_target.instance_variable_set("@environment", @env)
+    end
+    def check_types(filepath, rb_str)
+      @steep_target.add_source(filepath, rb_str)
+      ready_for_checking!
       @steep_target.type_check
       (if @steep_target.status
 .is_a?(Steep::Project::Target::SignatureErrorStatus)
         throw(:"error", @steep_target.status
 .errors
 .map() { |e|
-"  SignatureSyntaxError:\n    Location: #{e.location}\n    Message: \"#{e.exception
-.error_value
-.value}\""        }
+          msg = case e
+            when Steep::Diagnostic::Signature::UnknownTypeName
+              "Unknown type name: #{e.name
+.name} (#{e.location
+.source
+.[](/^.*$/)})"
+            when Steep::Diagnostic::Signature::InvalidTypeApplication
+              "Invalid type application: #{e.header_line}"
+            when Steep::Diagnostic::Signature::DuplicatedMethodDefinition
+              "Duplicated method: #{e.header_line}"
+            else
+              e.header_line
+          end
+"  SignatureSyntaxError:\n    Location: #{e.location}\n    Message: \"#{msg}\""        }
 .join("\n"))
       end)
       @steep_target.source_files
@@ -92,5 +114,11 @@ true
 .is_a?(Steep::Project::Target::TypeCheckStatus) && @steep_target.no_error? && @steep_target.errors
 .empty?
     end
+    def load_sig_path(path)
+      Gloss.logger
+.debug("Loading signature file for #{path}")
+      @steep_target.add_signature(path, File.open(path)
+.read)
+    end
   end
 end

data/lib/gloss/utils.rb

@@ -0,0 +1,38 @@
+  # frozen_string_literal: true
+
+  ##### This file was generated by Gloss; any changes made here will be overwritten.
+  ##### See src/ to make changes
+
+require "rubygems"
+module Gloss
+  module Utils
+    module_function
+    def absolute_path(path)
+      pn = Pathname.new(path)
+      (if pn.absolute?
+        pn.to_s
+      else
+        ap = File.absolute_path(path)
+        (if File.exist?(ap)
+          ap
+        else
+          throw(:"error", "File path #{path} does not exist (also looked for #{ap})")
+        end)
+      end)
+    end
+    def gem_path_for(gem_name)
+      spec = Gem::Specification.find_by_path(gem_name)
+      (if spec
+        spec.full_require_paths
+.first
+      end)
+    end
+    def with_file_header(str)
+      "#{Visitor::FILE_HEADER}\n\n#{str}"
+    end
+    def src_path_to_output_path(src_path)
+      src_path.sub("#{Config.src_dir}/", "")
+.sub(/\.gl$/, ".rb")
+    end
+  end
+end

data/lib/gloss/version.rb

@@ -4,5 +4,5 @@
   ##### See src/ to make changes
 
 module Gloss
-  VERSION = "0.0.6"
+  VERSION = "0.1.4"
 end

data/lib/gloss/{builder.rb → visitor.rb}

@@ -4,29 +4,24 @@
   ##### 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
+  class Visitor
     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)
+    def initialize(tree_hash, type_checker = nil, on_new_file_referenced = nil)
+      @on_new_file_referenced = on_new_file_referenced
       @indent_level = 0
       @inside_macro = false
       @eval_vars = false
       @current_scope = nil
       @tree = tree_hash
       @type_checker = type_checker
+      @after_module_function = false
     end
     def run()
       rb_output = visit_node(@tree)
-      with_file_header(rb_output)
+      Utils.with_file_header(rb_output)
     end
     def visit_node(node, scope = Scope.new)
       src = Source.new(@indent_level)
@@ -40,21 +35,30 @@ case node.[](:"type")
             RBS::Namespace.root
           end)
           superclass_type = nil
-          superclass_output = nil
+          superclass_output = ""
           (if node.[](:"superclass")
             @eval_vars = true
             superclass_output = visit_node(node.[](:"superclass"))
             @eval_vars = false
-            superclass_type = RBS::Parser.parse_type(superclass_output)
+            args = Array.new
             (if node.dig(:"superclass", :"type")
 .==("Generic")
-              superclass_output = superclass_output.[](/^[^\[]+/)
+              superclass_output = superclass_output.[](/^[^\[]+/) || superclass_output
+              args = node.dig(:"superclass", :"args")
+.map() { |n|
+                RBS::Parser.parse_type(visit_node(n))
+              }
             end)
+            class_name_index = superclass_output.index(/[^(?:::)]+\z/) || 0
+            namespace = superclass_output.[](0, class_name_index)
+            superclass_name = superclass_output.[](/[^(?:::)]+\z/) || superclass_output
+            superclass_type = RBS::AST::Declarations::Class::Super.new(name:             RBS::TypeName.new(namespace:             method(:"Namespace")
+.call(namespace), name:             superclass_name.to_sym), args: args, location:             build_location(node))
           end)
-          src.write_ln("class #{class_name}#{(if superclass_output
+          src.write_ln("class #{class_name}#{unless           superclass_output.blank?
             " < #{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"))
+          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:           build_location(node), comment:           node.[](:"comment"))
           old_parent_scope = @current_scope
           @current_scope = class_type
           indented(src) { ||
@@ -68,14 +72,13 @@ case node.[](:"type")
             @current_scope.members
 .<<(class_type)
           end)
-          (if @type_checker
-            unless @current_scope
-              @type_checker.top_level_decls
-.[]=(class_type.name
-.name, class_type)
-            end
+          (if @type_checker && !@current_scope
+            @type_checker.top_level_decls
+.add(class_type)
           end)
         when "ModuleNode"
+          existing_module_function_state = @after_module_function.dup
+          @after_module_function = false
           module_name = visit_node(node.[](:"name"))
           src.write_ln("module #{module_name}")
           current_namespace = (if @current_scope
@@ -84,7 +87,7 @@ case node.[](:"type")
           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"))
+          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:           build_location(node), comment:           node.[](:"comment"))
           old_parent_scope = @current_scope
           @current_scope = module_type
           indented(src) { ||
@@ -97,14 +100,12 @@ case node.[](:"type")
             @current_scope.members
 .<<(module_type)
           end)
-          (if @type_checker
-            unless @current_scope
-              @type_checker.top_level_decls
-.[]=(module_type.name
-.name, module_type)
-            end
+          (if @type_checker && !@current_scope
+            @type_checker.top_level_decls
+.add(module_type)
           end)
           src.write_ln("end")
+          @after_module_function = existing_module_function_state
         when "DefNode"
           args = render_args(node)
           receiver = (if node.[](:"receiver")
@@ -118,21 +119,25 @@ case node.[](:"type")
           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"))
+.to_sym, namespace:             RBS::Namespace.root), args: EMPTY_ARRAY, location:             build_location(node))
           else
-            RBS::Types::Bases::Any.new(location:             node.[](:"location"))
+            RBS::Types::Bases::Any.new(location:             build_location(node))
           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"))
+            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:             build_location(node))), required: !!node.[](:"block_arg") || node.[](:"yield_arg_count"))
           else
             nil
-          end), location:           node.[](:"location"))]
+          end), location:           build_location(node))]
           method_definition = RBS::AST::Members::MethodDefinition.new(name:           node.[](:"name")
-.to_sym, kind:           (if receiver
-            :"class"
+.to_sym, kind:           (if @after_module_function
+            :"singleton_instance"
           else
-            :"instance"
-          end), types: method_types, annotations: EMPTY_ARRAY, location:           node.[](:"location"), comment:           node.[](:"comment"), overload: false)
+            (if receiver
+              :"singleton"
+            else
+              :"instance"
+            end)
+          end), types: method_types, annotations: EMPTY_ARRAY, location:           build_location(node), comment:           node.[](:"comment"), overload: false)
           (if @current_scope
             @current_scope.members
 .<<(method_definition)
@@ -179,6 +184,7 @@ EMPTY_ARRAY          }
           else
             nil
           end)
+          name = node.[](:"name")
           block = (if node.[](:"block")
             " #{visit_node(node.[](:"block"))}"
           else
@@ -190,9 +196,25 @@ EMPTY_ARRAY          }
           else
             nil
           end)
-          call = "#{obj}#{node.[](:"name")}#{opening_delimiter}#{args}#{(if has_parens
+          call = "#{obj}#{name}#{opening_delimiter}#{args}#{(if has_parens
             ")"
           end)}#{block}"
+case name
+            when "require_relative"
+              (if @on_new_file_referenced
+                paths = arg_arr.map() { |a|
+                  unless                   a.[](:"type")
+.==("LiteralNode")
+                    throw(:"error", "Dynamic file paths are not allowed in require_relative")
+                  end
+                  eval(visit_node(a, scope)
+.strip)
+                }
+                @on_new_file_referenced.call(paths, true)
+              end)
+            when "module_function"
+              @after_module_function = true
+          end
           src.write_ln(call)
         when "Block"
           args = render_args(node)
@@ -237,7 +259,11 @@ EMPTY_ARRAY          }
         when "Path"
           src.write(node.[](:"value"))
         when "Require"
-          src.write_ln("require \"#{node.[](:"value")}\"")
+          path = node.[](:"value")
+          src.write_ln("require \"#{path}\"")
+          (if @on_new_file_referenced
+            @on_new_file_referenced.call([path], false)
+          end)
         when "Assign", "OpAssign"
           src.write_ln("#{visit_node(node.[](:"target"))} #{node.[](:"op")}= #{visit_node(node.[](:"value"))
 .strip}")
@@ -426,7 +452,12 @@ EMPTY_ARRAY          }
           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"))}")
+          value = (if node.[](:"value")
+            " = #{visit_node(node.[](:"value"))}"
+          else
+            nil
+          end)
+          src.write_ln("#{visit_node(node.[](:"var"))}#{value}")
         when "ExceptionHandler"
           src.write_ln("begin")
           indented(src) { ||
@@ -483,7 +514,7 @@ EMPTY_ARRAY          }
           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"))
+.call(name), args:           Array.new, annotations:           Array.new, location:           build_location(node), comment:           node.[](:"comment"))
           (if @current_scope
             @current_scope.members
 .<<(type)
@@ -501,7 +532,7 @@ EMPTY_ARRAY          }
           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"))
+.call(name), args:           Array.new, annotations:           Array.new, location:           build_location(node), comment:           node.[](:"comment"))
           (if @current_scope
             @current_scope.members
 .<<(type)
@@ -607,34 +638,38 @@ a && a.empty?      }
 .flatten
 .join(", ")
       representation = "(#{contents})"
-      rp.map!() { |a|
+      rp_args = rp.map() { |a|
         RBS::Types::Function::Param.new(name:         visit_node(a)
-.to_sym, type:         RBS::Types::Bases::Any.new(location:         a.[](:"location")))
+.to_sym, type:         RBS::Types::Bases::Any.new(location:         build_location(a)))
       }
-      op.map!() { |a|
+      op_args = op.map() { |a|
         RBS::Types::Function::Param.new(name:         visit_node(a)
-.to_sym, type:         RBS::Types::Bases::Any.new(location:         a.[](:"location")))
+.to_sym, type:         RBS::Types::Bases::Any.new(location:         build_location(a)))
       }
-      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")))
+      rpa = (if rest_p
+        RBS::Types::Function::Param.new(name:         rest_p.to_sym, type:         RBS::Types::Bases::Any.new(location:         build_location(node)))
       else
         nil
       end)
 {:representation => representation,
-:types => {:required_positionals => rp,
-:optional_positionals => op,
-:rest_positionals => rest_p,
+:types => {:required_positionals => rp_args,
+:optional_positionals => op_args,
+:rest_positionals => rpa,
 :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")))
+.to_sym, type:         RBS::Types::Bases::Any.new(location:         build_location(node)))
       else
         nil
       end)
 }.freeze}.freeze
     end
+    def build_location(node)
+      unless       node.[](:"location")
+        return nil
+      end
+    end
   end
 end