gloss 0.0.6 → 0.1.4

data/src/lib/gloss/scope.gl

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Gloss
   class Scope < Hash[String, String]
     def [](k)

data/src/lib/gloss/type_checker.gl

@@ -1,28 +1,45 @@
-# frozen_string_literal: true
-      require "pry-byebug"
+require "set"
 
 module Gloss
   class TypeChecker
-    Project = Struct.new :targets
+    attr_reader :steep_target, :top_level_decls, :env, :rbs_gem_dir
 
-    attr_reader :steep_target, :top_level_decls
+    enum Strictness
+      Strict = "strict"
+      Lenient = "lenient"
+      Default = "default"
+    end
 
     def initialize
+      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: Steep::Project::Options.new.tap do |o|
-          o.allow_unknown_constant_assignment = true
-        end,
-        source_patterns: ["gloss.rb"],
+        options: options,
+        source_patterns: ["**/*.rb"],
         ignore_patterns: Array.new,
         signature_patterns: ["sig"]
       )
-      @top_level_decls = {}
+      @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)
+      #loader.load_signatures
     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
@@ -38,8 +55,8 @@ module Gloss
               "Invalid method body type - expected: #{e.expected}, actual: #{e.actual}"
             when Steep::Diagnostic::Ruby::IncompatibleArguments
               <<-ERR
-              Invalid argmuents - method type: #{e.method_type}
-              method name: #{e.method_type.method_decls.first.method_name}
+              Invalid argmuents - method type: #{e.method_types.first}
+              method name: #{e.method_name}
               ERR
             when Steep::Diagnostic::Ruby::ReturnTypeMismatch
               "Invalid return type - expected: #{e.expected}, actual: #{e.actual}"
@@ -48,7 +65,7 @@ module Gloss
             when Steep::Diagnostic::Ruby::UnexpectedBlockGiven
               "Unexpected block given"
             else
-              e.inspect
+              "#{e.header_line}\n#{e}"
             end
         }.join("\n")
         throw :error, errors
@@ -57,31 +74,38 @@ module Gloss
       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
+    def ready_for_checking!
+      @top_level_decls.each do |decl|
+        @env << decl
+      end
+      @env = @env.resolve_type_names
 
-      @steep_target.add_source("gloss.rb", rb_str)
+      @steep_target.instance_variable_set("@environment", @env)
+    end
 
-      @top_level_decls.each do |_, decl|
-        env << decl
-      end
-      env = env.resolve_type_names
+    def check_types(filepath, rb_str)
+      @steep_target.add_source(filepath, rb_str)
 
-      @steep_target.instance_variable_set("@environment", env)
+      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|
+          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
           <<~MSG
             SignatureSyntaxError:
               Location: #{e.location}
-              Message: "#{e.exception.error_value.value}"
+              Message: "#{msg}"
           MSG
         }.join("\n")
       end
@@ -97,5 +121,10 @@ module Gloss
         @steep_target.no_error? &&
         @steep_target.errors.empty?
     end
+
+    def load_sig_path(path : String)
+      Gloss.logger.debug "Loading signature file for #{path}"
+      @steep_target.add_signature path, File.open(path).read
+    end
   end
 end

data/src/lib/gloss/utils.gl

@@ -0,0 +1,35 @@
+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)
+      spec.full_require_paths.first if spec
+    end
+
+    def with_file_header(str)
+      "#{Visitor::FILE_HEADER}\n\n#{str}"
+    end
+
+    def src_path_to_output_path(src_path : String) : String
+      src_path.sub("#{Config.src_dir}/", "")
+              .sub(/\.gl$/, ".rb")
+    end
+  end
+end

data/src/lib/gloss/version.gl

@@ -1,3 +1,3 @@
 module Gloss
-  VERSION = "0.0.6"
+  VERSION = "0.1.4"
 end

data/src/lib/gloss/{builder.gl → visitor.gl}

@@ -1,35 +1,26 @@
 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 = <<~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
     RUBY
 
-    include Utils
-
     attr_reader :tree
 
-    def initialize(tree_hash, type_checker = nil)
+    def initialize(tree_hash, type_checker = nil, @on_new_file_referenced = nil)
       @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
 
     # type node = Hash[Symbol, String | Array[String | node] | Hash[Symbol, node]] | true | false
@@ -41,18 +32,31 @@ module Gloss
         class_name = visit_node(node[:name])
         current_namespace = @current_scope ? @current_scope.name.to_namespace : RBS::Namespace.root
         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}#{" < #{superclass_output}" if superclass_output}"
+        src.write_ln "class #{class_name}#{" < #{superclass_output}" unless superclass_output.blank?}"
 
         class_type = RBS::AST::Declarations::Class.new(
           name: RBS::TypeName.new(
@@ -63,7 +67,7 @@ module Gloss
           super_class: superclass_type,
           members: Array.new, # TODO
           annotations: Array.new, # TODO
-          location: node[:location],
+          location: build_location(node),
           comment: node[:comment]
         )
         old_parent_scope = @current_scope
@@ -77,10 +81,12 @@ module Gloss
 
         @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
+        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}"
 
@@ -95,8 +101,8 @@ module Gloss
           self_types: Array.new, # TODO
           members: Array.new, # TODO
           annotations: Array.new, # TODO
-          location: node[:location],
-          comment: node[:comment]
+          location: build_location(node),
+          comment: node[:comment],
         )
         old_parent_scope = @current_scope
         @current_scope = module_type
@@ -107,10 +113,11 @@ module Gloss
 
         @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
+        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 = node[:receiver] ? visit_node(node[:receiver]) : nil
@@ -123,11 +130,11 @@ module Gloss
                             namespace: RBS::Namespace.root
                           ),
                           args: EMPTY_ARRAY, # TODO
-                          location: node[:location]
+                          location: build_location(node)
                         )
                       else
                         RBS::Types::Bases::Any.new(
-                          location: node[:location]
+                          location: build_location(node)
                         )
                       end
 
@@ -154,19 +161,19 @@ module Gloss
                   required_keywords: Hash.new,
                   optional_keywords: Hash.new,
                   rest_keywords: nil,
-                  return_type: RBS::Types::Bases::Any.new(location: node[:location])
+                  return_type: RBS::Types::Bases::Any.new(location: build_location(node))
                 ),
                 required: !!(node[:block_arg] || node[:yield_arg_count])
               ) : nil,
-            location: node[:location]
+            location: build_location(node)
           )
         ]
         method_definition = RBS::AST::Members::MethodDefinition.new(
           name: node[:name].to_sym,
-          kind: receiver ? :class : :instance,
+          kind: @after_module_function ? :singleton_instance : receiver ? :singleton : :instance,
           types: method_types,
           annotations: EMPTY_ARRAY, # TODO
-          location: node[:location],
+          location: build_location(node),
           comment: node[:comment],
           overload: false
         )
@@ -195,6 +202,7 @@ module Gloss
                else
                  nil
                end
+        name = node[:name]
         block = node[:block] ? " #{visit_node(node[:block])}" : nil
         has_parens = !!(node[:has_parentheses] || args || block)
         opening_delimiter = if has_parens
@@ -202,7 +210,21 @@ module Gloss
                             else
                               nil
                             end
-        call = "#{obj}#{node[:name]}#{opening_delimiter}#{args}#{")" if has_parens}#{block}"
+        call = "#{obj}#{name}#{opening_delimiter}#{args}#{")" if has_parens}#{block}"
+        case name
+        when "require_relative"
+          if @on_new_file_referenced
+            paths = arg_arr.map do |a|
+              unless a[:type] == "LiteralNode"
+                throw :error, "Dynamic file paths are not allowed in require_relative"
+              end
+              eval(visit_node(a, scope).strip)
+            end
+            @on_new_file_referenced.call(paths, true)
+          end
+        when "module_function"
+          @after_module_function = true
+        end
         src.write_ln(call)
 
       when "Block"
@@ -247,9 +269,10 @@ module Gloss
         src.write node[:value]
 
       when "Require"
+        path = node[:value]
+        src.write_ln %(require "#{path}")
 
-        src.write_ln %(require "#{node[:value]}")
-
+        @on_new_file_referenced.call([path], false) if @on_new_file_referenced
       when "Assign", "OpAssign"
 
         src.write_ln "#{visit_node(node[:target])} #{node[:op]}= #{visit_node(node[:value]).strip}"
@@ -388,7 +411,8 @@ module Gloss
         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 = node[:value] ? " = #{visit_node node[:value]}" : nil
+        src.write_ln "#{visit_node(node[:var])}#{value}"
       when "ExceptionHandler"
         src.write_ln "begin"
         indented src do
@@ -422,7 +446,7 @@ module Gloss
             name: method(:TypeName).call(name),
             args: Array.new,
             annotations: Array.new,
-            location: node[:location],
+            location: build_location(node),
             comment: node[:comment]
           )
         if @current_scope
@@ -438,7 +462,7 @@ module Gloss
             name: method(:TypeName).call(name),
             args: Array.new,
             annotations: Array.new,
-            location: node[:location],
+            location: build_location(node),
             comment: node[:comment]
           )
         if @current_scope
@@ -510,37 +534,50 @@ module Gloss
         rest_kw ? "**#{visit_node(rest_kw)}" : ""
       ].reject(&:empty?).flatten.join(", ")
       representation = "(#{contents})"
-      rp.map! do |a|
+      rp_args = rp.map do |a|
         RBS::Types::Function::Param.new(
           name: visit_node(a).to_sym,
           type: RBS::Types::Bases::Any.new(
-            location: a[:location]
+            location: build_location(a)
           )
         )
       end
-      op.map! do |a|
+      op_args = op.map do |a|
         RBS::Types::Function::Param.new(
           name: visit_node(a).to_sym,
-          type: RBS::Types::Bases::Any.new(location: a[:location])
+          type: RBS::Types::Bases::Any.new(location: build_location(a))
         )
       end
-      rest_p = (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])) : nil
+      rpa = rest_p ? RBS::Types::Function::Param.new(
+              name: rest_p.to_sym,
+              type: RBS::Types::Bases::Any.new(location: build_location(node))
+            ) : nil
       {
         representation: representation,
         types: {
-          required_positionals: rp,
-          optional_positionals: op,
-          rest_positionals: rest_p,
+          required_positionals: rp_args,
+          optional_positionals: op_args,
+          rest_positionals: rpa,
           trailing_positionals: EMPTY_ARRAY, # TODO
           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: node[:location])
+              type: RBS::Types::Bases::Any.new(location: build_location(node))
             ) : nil
         }
       }
     end
+
+    def build_location(node)
+      return nil unless node[:location]
+
+#      RBS::Location.new(
+#        buffer: RBS::Buffer.new(@file_path, @file_content),
+#        start_pos: node[:location][:start],
+#        end_pos: node[:location][:end]
+#      )
+    end
   end
 end