houndstooth 0.1.0

data/lib/houndstooth/environment/types/defined/defined_type.rb

@@ -0,0 +1,137 @@
+class Houndstooth::Environment
+    class DefinedType < Type
+        def initialize(path: nil, node: nil, superclass: nil, instance_methods: nil, eigen: :generate, type_parameters: nil)
+            @path = path.to_s
+            @node = node
+            @superclass = superclass
+            @instance_methods = instance_methods || []
+            @type_parameters = type_parameters || []
+            @type_instance_variables = {}
+
+            if eigen == :generate
+                @eigen = DefinedType.new(
+                    path: "<Eigen:#{path}>",
+                    superclass:
+                        if superclass.is_a?(PendingDefinedType)
+                            PendingDefinedType.new("<Eigen:#{superclass.path}>")
+                        else 
+                            superclass&.eigen
+                        end,
+                    eigen: nil,
+                )
+            else
+                @eigen = eigen
+            end
+        end
+
+        # @return [String]
+        attr_reader :path
+
+        # @return [String]
+        def name
+            path.split("::").last
+        end
+
+        # @return [SemanticNode]
+        attr_reader :node
+
+        # @return [Type, nil]
+        attr_accessor :superclass
+
+        # @return [Type]
+        attr_accessor :eigen
+
+        # @return [<Method>]
+        attr_reader :instance_methods
+
+        # @return [<String>]
+        attr_reader :type_parameters
+
+        # @return [{String => Type}]
+        attr_reader :type_instance_variables
+
+        def resolve_instance_method(method_name, env, instance: nil, top_level: true)            
+            # Is it available on this type?
+            # If not, check the superclass
+            # If there's no superclass, then there is no method to be found, so return nil
+            instance_method = instance_methods.find { _1.name == method_name }
+
+            found = if instance_method
+                instance_method
+            else
+                superclass&.resolve_instance_method(method_name, env, instance: instance, top_level: false)
+            end
+
+            # If the upper chain returned a special constructor method, we need to convert this by
+            # grabbing our instance's `initialize` type
+            if top_level && found && found.is_a?(SpecialConstructorMethod)
+                initialize_sig = env.resolve_type(uneigen).resolve_instance_method(:initialize, env, instance: instance)
+                @new_sig ||= Method.new(
+                    :new,
+                    initialize_sig.signatures.map do |sig|
+                        # Same parameters, but returns `instance`
+                        new_sig = sig.clone
+                        new_sig.return_type = InstanceType.new
+                        new_sig
+                    end,
+                    const: initialize_sig.const,
+                )
+                @new_sig
+            else
+                found
+            end
+        end
+
+        def resolve_instance_variable(name)
+            var_here = type_instance_variables[name]
+            return var_here if var_here
+
+            superclass&.resolve_instance_variable(name)
+        end
+
+        # A path to this type, but with one layer of "eigen-ness" removed from the final element.
+        # A bit cursed, but used for constant resolution.
+        # @return [String]
+        def uneigen
+            path_parts = path.split("::")
+            *rest, name = path_parts
+
+            raise "internal error: can't uneigen a non-eigen type" unless /^<Eigen:(.+)>$/ === name
+            uneigened_name = $1
+
+            [*rest, uneigened_name].join("::")
+        end
+
+        def resolve_all_pending_types(environment, context: nil)
+            @superclass = resolve_type_if_pending(superclass, self, environment)
+            @eigen = resolve_type_if_pending(eigen, self, environment)
+
+            instance_methods.map do |method|
+                method.resolve_all_pending_types(environment, context: self)
+            end
+
+            type_instance_variables.keys.each do |k|
+                type_instance_variables[k] = resolve_type_if_pending(type_instance_variables[k], self, environment)
+            end
+        end
+
+        def accepts?(other)
+            return false unless other.is_a?(DefinedType)
+            
+            distance = 0
+            current = other
+            until current.nil?
+                return distance if current == self
+
+                current = current&.superclass
+                distance += 1
+            end
+
+            false
+        end
+
+        def rbs
+            path
+        end
+    end
+end

data/lib/houndstooth/environment/types/defined/pending_defined_type.rb

@@ -0,0 +1,14 @@
+class Houndstooth::Environment
+    class PendingDefinedType < Type
+        def initialize(path)
+            @path = path
+        end
+
+        # @return [String]
+        attr_reader :path
+
+        def rbs
+            "#{path} (unresolved)"
+        end 
+    end
+end

data/lib/houndstooth/environment/types/method/method.rb

@@ -0,0 +1,79 @@
+class Houndstooth::Environment
+    class Method
+        # @return [String]
+        attr_reader :name
+
+        # @return [<MethodType>]
+        attr_reader :signatures
+
+        # :public, :protected or :private
+        # @return [Symbol]
+        attr_reader :visibility
+
+        # If a symbol, the kind of constness this method has:
+        #   - :normal, defined as user-specified source, can be used anywhere
+        #   - :internal, defined in Houndstooth, can be used anywhere
+        #   - :required, defined as user-specified source, can only be used from a const context
+        #   - :required_internal, defined in Houndstooth, can only be used from a const context
+        # If nil, this method is not const.
+        # @return [Symbol, nil]
+        attr_reader :const
+
+        def const?; !const.nil?; end
+        def const_internal?; const == :internal || const == :required_internal; end
+        def const_required?; const == :required || const == :required_internal; end
+
+        # The instruction block which implements this method.
+        # @return [InstructionBlock]
+        attr_accessor :instruction_block
+
+        def initialize(name, signatures = nil, visibility: :public, const: false)
+            @name = name
+            @signatures = signatures || []
+            @visibility = visibility
+            @const = const
+        end
+
+        def resolve_all_pending_types(environment, context:)
+            signatures.map do |sig|
+                sig.resolve_all_pending_types(environment, context: context)
+            end
+        end
+
+        def substitute_type_parameters(instance, call_type_args)
+            raise 'internal error: tried to substitute parameters on a Method; too high in the hierarchy for this to be sensible'
+        end
+
+        # Given a set of arguments and their types, resolves and returns the best matching signature
+        # of this method.
+        #
+        # If multiple signatures match, the "best" is chosen according to the distance rules used
+        # by `Type#accepts?` - the type with the lowest distance over all arguments is returned.
+        # If no signatures match, returns nil.
+        #
+        # @param [TypeInstance] instance
+        # @param [<(Instructions::Argument, Type)>] arguments
+        # @param [<Type>] type_arguments
+        # @return [MethodType, nil]
+        def resolve_matching_signature(instance, arguments, type_arguments = nil)
+            type_arguments ||= []
+
+            sigs_with_scores = signatures
+                .map do |sig|
+                    # Create {name => type} type argument mapping, or if the numbers mismatch
+                    # return false, as this signature cannot match
+                    next [nil, false] if type_arguments.length != sig.type_parameters.length
+
+                    call_type_args = sig.type_parameters.zip(type_arguments).to_h
+                    [sig, sig.substitute_type_parameters(instance, call_type_args).accepts_arguments?(arguments)]
+                end
+                .reject { |_, r| r == false }
+
+            if sigs_with_scores.any?
+                sigs_with_scores.min_by { |sig, score| score }[0]
+            else
+                nil
+            end
+        end
+    end
+end

data/lib/houndstooth/environment/types/method/method_type.rb

@@ -0,0 +1,144 @@
+class Houndstooth::Environment
+    class MethodType < Type
+        # @return [<PositionalParameter>]
+        attr_accessor :positional_parameters
+
+        # @return [<KeywordParameter>]
+        attr_accessor :keyword_parameters
+
+        # @return [PositionalParameter, nil]
+        attr_accessor :rest_positional_parameter
+
+        # @return [KeywordParameter, nil]
+        attr_accessor :rest_keyword_parameter
+
+        # @return [BlockParameter, nil]
+        attr_accessor :block_parameter
+
+        # @return [Type]
+        attr_accessor :return_type
+
+        # @return [<String>]
+        attr_accessor :type_parameters
+
+        def initialize(positional: [], keyword: [], rest_positional: nil, rest_keyword: nil, block: nil, return_type: nil, type_parameters: nil)
+            super()
+
+            @positional_parameters = positional
+            @keyword_parameters = keyword
+            @rest_positional_parameter = rest_positional
+            @rest_keyword_parameter = rest_keyword
+            @block_parameter = block
+            @return_type = return_type || VoidType.new
+            @type_parameters = type_parameters || []
+        end
+
+        def resolve_all_pending_types(environment, context:)
+            @return_type = resolve_type_if_pending(return_type, context, environment)
+            
+            positional_parameters.map do |param|
+                param.resolve_all_pending_types(environment, context: context)
+            end
+            
+            keyword_parameters.map do |param|
+                param.resolve_all_pending_types(environment, context: context)
+            end
+            
+            rest_positional_parameter&.resolve_all_pending_types(environment, context: context)
+            rest_keyword_parameter&.resolve_all_pending_types(environment, context: context)
+            block_parameter&.resolve_all_pending_types(environment, context: context)
+        end
+
+        # Determines whether this method can be called with the given arguments and their types.
+        # Follows the same return-value rules as `accepts?`.
+        #
+        # @param [<(Instructions::Argument, Type)>] arguments
+        # @return [Integer, Boolean]
+        def accepts_arguments?(arguments)
+            distance_total = 0
+            args_index = 0
+
+            # Check the positional parameters first
+            positional_parameters.each do |param|
+                # Is there also a positional argument in this index slot?
+                this_arg, this_type = arguments[args_index]
+                if this_arg.is_a?(Houndstooth::Instructions::PositionalArgument)
+                    # Yes, so this argument was definitely passed to this parameter
+                    # Are the types compatible?
+                    dist = param.type.accepts?(this_type)
+                    if dist
+                        # Yep! All is well. Add to total distance
+                        distance_total += dist
+                        args_index += 1
+                    else
+                        # Nope, this isn't valid. Bail
+                        return false
+                    end
+                else
+                    # No positional argument - but that's OK if this parameter is optional
+                    if !param.optional?
+                        # Missing argument not allowed
+                        return false
+                    end
+                end
+            end
+
+            # Are there any positional arguments left over?
+            while arguments[args_index] && arguments[args_index][0].is_a?(Houndstooth::Instructions::PositionalArgument)
+                this_arg, this_type = arguments[args_index]
+
+                # Is there a rest-parameter to take these?
+                if !rest_positional_parameter.nil?
+                    # Yep, but does this argument match the type of the rest positional?
+                    dist = param.type.accepts?(this_type)
+                    if dist
+                        # Correct - this is passed into the splat!
+                        distance_total += dist
+                        args_index += 1
+                    else
+                        # Not the right type for the splat, invalid
+                        return false
+                    end
+                else
+                    # No, error - too many arguments
+                    return false
+                end
+            end
+
+            # TODO: keyword arguments
+            raise "keyword argument checking not implemeneted" \
+                if arguments.find { |x, _| x.is_a?(Houndstooth::Instructions::KeywordArgument) }
+
+            distance_total
+        end
+
+        def substitute_type_parameters(instance, call_type_args)
+            clone.tap do |t|
+                t.positional_parameters = t.positional_parameters.map { |p| p.substitute_type_parameters(instance, call_type_args) }
+                t.keyword_parameters = t.keyword_parameters.map { |p| p.substitute_type_parameters(instance, call_type_args) }
+
+                t.rest_positional_parameter = t.rest_positional_parameter&.substitute_type_parameters(instance, call_type_args)
+                t.rest_keyword_parameter = t.rest_keyword_parameter&.substitute_type_parameters(instance, call_type_args)
+                t.block_parameter = t.block_parameter&.substitute_type_parameters(instance, call_type_args)
+
+                t.return_type = t.return_type.substitute_type_parameters(instance, call_type_args)
+            end
+        end
+
+        # TODO: implement accepts?
+
+        def rbs
+            params = 
+                [positional_parameters.map(&:rbs), keyword_parameters.map(&:rbs)].flatten.join(", ")
+
+            if type_parameters.any?
+                type_params = "[#{type_parameters.join(', ')}] "
+            else
+                type_params = ''
+            end
+                
+            "#{type_params}(#{params}) #{block_parameter ? "#{block_parameter.rbs} " : ''}-> #{return_type.rbs}"
+        end
+    end
+end
+    

data/lib/houndstooth/environment/types/method/parameters.rb

@@ -0,0 +1,53 @@
+class Houndstooth::Environment
+    class Parameter < Type
+        # Note: Parameters aren't *really* a type, but we need `resolve_type_if_pending`
+
+        # @return [Name]
+        attr_reader :name
+
+        # @return [Type]
+        attr_accessor :type
+
+        # @return [Boolean]
+        attr_reader :optional
+        alias optional? optional
+
+        def initialize(name, type, optional: false)
+            @name = name
+            @type = type
+            @optional = optional
+        end
+
+        def resolve_all_pending_types(environment, context:)
+            @type = resolve_type_if_pending(type, context, environment)
+        end
+
+        def substitute_type_parameters(instance, call_type_args)
+            clone.tap do |t|
+                t.type = t.type.substitute_type_parameters(instance, call_type_args)
+            end
+        end
+    end
+
+    class PositionalParameter < Parameter
+        def rbs
+            if name
+                "#{optional? ? '?' : ''}#{type.rbs} #{name}"
+            else
+                "#{optional? ? '?' : ''}#{type.rbs}"
+            end
+        end
+    end
+
+    class KeywordParameter < Parameter
+        def rbs
+            "#{optional? ? '?' : ''}#{name}: #{type.rbs}"
+        end
+    end
+
+    class BlockParameter < Parameter
+        def rbs
+            "#{optional? ? '?' : ''}{ #{type.rbs} }"
+        end
+    end
+end

data/lib/houndstooth/environment/types/method/special_constructor_method.rb

@@ -0,0 +1,15 @@
+class Houndstooth::Environment
+    # A special type which can be used in place of a method, typically only `new`. Specifies
+    # that the resolved instance method should actually be taken from an uneigened `initialize`.
+    class SpecialConstructorMethod < Type
+        def initialize(name)
+            @name = name
+        end
+
+        attr_accessor :name
+
+        def rbs
+            "<special constructor '#{name}'>"
+        end 
+    end
+end

data/lib/houndstooth/environment/types/special/instance_type.rb

@@ -0,0 +1,9 @@
+class Houndstooth::Environment
+    class InstanceType < Type
+        # TODO: implement accepts?
+
+        def rbs
+            "instance"
+        end
+    end
+end

data/lib/houndstooth/environment/types/special/self_type.rb

@@ -0,0 +1,9 @@
+class Houndstooth::Environment
+    class SelfType < Type
+        # TODO: implement accepts?
+
+        def rbs
+            "self"
+        end
+    end
+end

data/lib/houndstooth/environment/types/special/type_parameter_placeholder.rb

@@ -0,0 +1,38 @@
+class Houndstooth::Environment
+    # A type which will be replaced by a type argument later.
+    class TypeParameterPlaceholder < Type
+        def initialize(name)
+            @name = name
+        end
+
+        attr_accessor :name
+
+        def accepts?(other)
+            if other.is_a?(TypeParameterPlaceholder) && name == other.name
+                1
+            else
+                false
+            end
+        end
+
+        def rbs
+            name
+        end
+
+        def substitute_type_parameters(instance, call_type_args)
+            # Call type arguments take priority, check those first
+            return call_type_args[name] if call_type_args[name]
+
+            # Get index of type parameter
+            index = instance.type.type_parameters.index { |tp| tp == name } or return self
+
+            # Replace with type argument, which should be an instance
+            instance.type_arguments[index] or self
+        end
+
+        # Yikes!
+        # It doesn't ever make sense to instantiate a type parameter, and trying to do so was
+        # causing problems when passing type arguments around functions, so just don't allow it
+        def instantiate(...) = self
+    end
+end

data/lib/houndstooth/environment/types/special/untyped_type.rb

@@ -0,0 +1,11 @@
+class Houndstooth::Environment
+    class UntypedType < Type
+        def accepts?(other)
+            1
+        end
+
+        def rbs
+            "untyped"
+        end
+    end
+end

data/lib/houndstooth/environment/types/special/void_type.rb

@@ -0,0 +1,12 @@
+class Houndstooth::Environment
+    class VoidType < Type
+        def accepts?(other)
+            # Only valid as a return type, and you can return anything in a void method
+            1
+        end
+
+        def rbs
+            "void"
+        end
+    end
+end

data/lib/houndstooth/environment/types.rb

@@ -0,0 +1,3 @@
+Dir[File.join(__dir__, '**', '*.rb')].each do |f|
+    require_relative f
+end

data/lib/houndstooth/environment.rb

@@ -0,0 +1,74 @@
+class Houndstooth::Environment
+    def initialize
+        @types = {}
+    end
+
+    def add_type(type)
+        # Add the type and its entire eigen chain
+        @types[type.path] = type
+        add_type(type.eigen) if type.respond_to?(:eigen) && type.eigen
+    end
+
+    # @return [{String, DefinedType}] 
+    attr_reader :types
+
+    def resolve_all_pending_types
+        types.each do |_, type|
+            type.resolve_all_pending_types(self)
+        end
+    end
+
+    # Resolve a type by path; either an absolute path from the root namespace, or optionally as a
+    # relative path from the context of it being used within the given type.
+    # If the type does not exist, returns nil.
+    #
+    # @param [String] path The path to resolve. If `type_context` is nil, this is interpreted as an
+    #   absolute path regardless of whether it is prefixed with `::`. If `type_context` is given,
+    #   this is interpreted as a relative path without a `::` prefix, or an absolute path with one.
+    # @param [DefinedType] type_context Optional: The context to search from.
+    #
+    # @return [DefinedType, nil]
+    def resolve_type(path, type_context: nil)
+        if path.start_with?('::') || type_context.nil?
+            # Our `#types` field is indexed by absolute path, let's just look at that!
+            # Prune the :: if present
+            path = path[2..] if path.start_with?('::')
+            return types[path]
+        end
+        
+        # This is a relative path - split into parts
+        path_parts = path.split('::')
+        return nil if path_parts.empty?
+        next_part, *rest_parts = *path_parts
+    
+        # Does the current type context contain the next part of the path?
+        maybe_inner_type = types[type_context.path + '::' + next_part]
+        if maybe_inner_type
+            # Yes - either return if there's no more parts, or advance into that type and continue
+            # the search
+            if rest_parts.empty?
+                maybe_inner_type
+            else
+                resolve_type(rest_parts.join('::'), type_context: maybe_inner_type)
+            end
+        else
+            # No - check the current type context's parent
+            # (Or, if there's no parent, we'll try searching for it as absolute as a last-ditch
+            # attempt)
+            if type_context.path.include?('::')
+                resolve_type(path, type_context: types[type_context.path.split('::')[...-1].join('::')])
+            else
+                resolve_type(path, type_context: nil)
+            end
+        end
+    end
+
+    def inspect
+        "#<Houndstooth::Environment (#{types.length} types)>"
+    end
+    alias to_s inspect
+end
+
+require_relative 'environment/types'
+require_relative 'environment/type_parser'
+require_relative 'environment/builder'

data/lib/houndstooth/errors.rb

@@ -0,0 +1,53 @@
+module Houndstooth
+    module Errors
+        class Error
+            def initialize(message, tagged_ranges)
+                @message = message
+                @tagged_ranges = tagged_ranges
+            end
+
+            # @return [String]
+            attr_reader :message
+
+            # @return [(Parser::Source::Range, String)]
+            attr_reader :tagged_ranges
+
+            def format
+                # TODO: merge nearby errors
+
+                (["Error: #{message}"] \
+                + tagged_ranges.flat_map do |range, hint|
+                    # TODO: won't work if the error spans multiple lines
+                    line_range = range.source_buffer.line_range(range.line)
+                    begin_pos_on_line = range.begin_pos - line_range.begin_pos
+                    length = range.end_pos - range.begin_pos
+
+                    [
+                        "",
+                        "  #{range.source_buffer.name}",
+                        "  #{range.line}  |  #{range.source_line}",
+                        "  #{' ' * range.line.to_s.length}     #{' ' * begin_pos_on_line}#{'^' * length} #{hint}",
+                    ]
+                end).join("\n")
+            end
+
+            def push
+                Errors.push(self)
+            end
+        end
+
+        @errors = []
+
+        def self.reset
+            @errors = []
+        end
+
+        def self.push(error)
+            @errors << error
+        end
+
+        def self.errors
+            @errors
+        end
+    end
+end