houndstooth 0.1.0

data/lib/houndstooth/interpreter/const_internal.rb

@@ -0,0 +1,148 @@
+module Houndstooth::Interpreter
+    # Provides definitions for `#!const internal` methods in the standard library.
+    class ConstInternal
+        def initialize(env:)
+            @method_definitions = {}
+
+            # Initialize adding methods
+            add = ->(this, other, **_) do
+                InterpreterObject.from_value(
+                    value: this.unwrap_primitive_value + other.unwrap_primitive_value,
+                    env: env,
+                )
+            end
+            ['::Numeric', '::Integer', '::Float', '::String'].each do |t|
+                @method_definitions[env.resolve_type(t).resolve_instance_method(:+, env)] = add     
+            end
+
+            # to_sym
+            @method_definitions[env.resolve_type('::String').resolve_instance_method(:to_sym, env)] =
+                ->(this, **_) do
+                    InterpreterObject.from_value(value: this.unwrap_primitive_value.to_sym, env: env)
+                end
+
+            # times
+            @method_definitions[env.resolve_type('::Integer').resolve_instance_method(:times, env)] =
+                ->(this, call_block:, **_) do
+                    this.unwrap_primitive_value.times do |i|
+                        call_block.([InterpreterObject.from_value(value: i, env: env)])
+                    end
+
+                    this
+                end
+
+            # Array.new
+            @method_definitions[env.resolve_type('::Array').eigen.resolve_instance_method(:new, env)] =
+                ->(this, **_) do
+                    InterpreterObject.from_value(value: [], env: env)
+                end
+
+            # Array#<<
+            @method_definitions[env.resolve_type('::Array').resolve_instance_method(:<<, env)] =
+                ->(this, item, **_) do
+                    this.unwrap_primitive_value << item
+                    this
+                end
+                
+            # Array#each
+            @method_definitions[env.resolve_type('::Array').resolve_instance_method(:each, env)] =
+                ->(this, call_block:, **_) do
+                    items = this.unwrap_primitive_value
+                    items.each do |item|
+                        call_block.([item])
+                    end
+
+                    this
+                end
+
+            # puts and print
+            kernel = env.resolve_type('::Kernel').eigen
+            @method_definitions[kernel.resolve_instance_method(:puts, env)] = ->(_, obj, **_) do
+                $const_printed = true
+                puts obj.ruby_inspect
+            end
+            @method_definitions[kernel.resolve_instance_method(:print, env)] = ->(_, obj, **_) do
+                $const_printed = true
+                print obj.ruby_inspect
+            end
+
+            # attr_reader
+            @method_definitions[env.resolve_type('::Class').eigen.resolve_instance_method(:attr_reader, env)] =
+                ->(this, name, type_arguments:, **_) do
+                    t = type_arguments['T']
+                    t = t.substitute_type_parameters(nil, type_arguments)
+
+                    env.resolve_type(this.type.uneigen).instance_methods << Houndstooth::Environment::Method.new(
+                        name.unwrap_primitive_value,
+                        [
+                            Houndstooth::Environment::MethodType.new(
+                                return_type: t,
+                            )
+                        ]
+                    )
+                    InterpreterObject.from_value(value: nil, env: env)
+                end
+
+            # attr_writer
+            @method_definitions[env.resolve_type('::Class').eigen.resolve_instance_method(:attr_writer, env)] =
+                ->(this, name, type_arguments:, **_) do
+                    t = type_arguments['T']
+                    t = t.substitute_type_parameters(nil, type_arguments)
+
+                    env.resolve_type(this.type.uneigen).instance_methods << Houndstooth::Environment::Method.new(
+                        "#{name.unwrap_primitive_value}=".to_sym,
+                        [
+                            Houndstooth::Environment::MethodType.new(
+                                positional: [
+                                    Houndstooth::Environment::PositionalParameter.new(:value, t)
+                                ],
+                            )
+                        ]
+                    )
+                    InterpreterObject.from_value(value: nil, env: env)
+                end
+
+            # define_method
+            @method_definitions[env.resolve_type('::Class').eigen.resolve_instance_method(:define_method, env)] =
+                ->(this, name, type_arguments:, **_) do
+                    # Get all argument types and return type
+                    arg_types = (type_arguments.length - 1).times.map do |i|
+                        type_arguments["A#{i + 1}"].substitute_type_parameters(nil, type_arguments)
+                    end
+                    return_type = type_arguments['R'].substitute_type_parameters(nil, type_arguments)
+
+                    # Create method
+                    env.resolve_type(this.type.uneigen).instance_methods << Houndstooth::Environment::Method.new(
+                        name.unwrap_primitive_value,
+                        [
+                            Houndstooth::Environment::MethodType.new(
+                                positional: arg_types.map.with_index do |t, i|
+                                    Houndstooth::Environment::PositionalParameter.new(
+                                        "__anon_param_#{i}",
+                                        t,
+                                    )
+                                end,
+                                return_type: return_type,
+                            )
+                        ]
+                    )
+                    InterpreterObject.from_value(value: nil, env: env)
+                end
+
+            # Various env-changing methods are a no-op for now
+            nil_method = ->(*_, **_) { InterpreterObject.from_value(value: nil, env: env) }
+            [:private, :protected].each do |m|
+                @method_definitions[env.resolve_type('::Class').eigen.resolve_instance_method(m, env)] = nil_method
+            end
+        end
+
+        # @return [Environment]
+        attr_accessor :env
+
+        # A hash of the method definitions. Access with the environment's method reference, call the
+        # given proc with the self value and argument values, and it will return a new object as the
+        # result.
+        # @return [{Method => Proc}]
+        attr_accessor :method_definitions
+    end
+end

data/lib/houndstooth/interpreter/objects.rb

@@ -0,0 +1,142 @@
+module Houndstooth::Interpreter
+    # An instance of a defined type.
+    class InterpreterObject
+        def initialize(type:, env:, primitive_value: nil)
+            @type = type
+            @env = env
+            @instance_variables = {}
+            @primitive_value = primitive_value || [false, nil]
+        end
+
+        # The type which this is an instance of.
+        # @return [DefinedType]
+        attr_accessor :type
+
+        # The type environment in which this object exists.
+        # @return [Environment]
+        attr_accessor :env
+        
+        # The instance variables on this instance.
+        # @return [{String => InterpreterObject}]
+        attr_accessor :instance_variables
+
+        # The primitive value on this instance, if it has one.
+        # A tuple of the form [present, value].
+        # @return [(Boolean, Object)]
+        attr_accessor :primitive_value
+
+        def unwrap_primitive_value
+            present, value = primitive_value
+
+            default = 
+                case type
+                when env.resolve_type('::Integer')
+                    0
+                when env.resolve_type('::String')
+                    ''
+                when env.resolve_type('::Boolean')
+                    false
+                when env.resolve_type('::Float')
+                    0.0
+                when env.resolve_type('::Symbol')
+                    :""
+                when env.resolve_type('::Array')
+                    []
+                
+                # These always have particular values, so just return immediately and ignore
+                # whatever the value might be set to
+                when env.resolve_type('::NilClass')
+                    return nil
+                when env.resolve_type('::FalseClass')
+                    return false
+                when env.resolve_type('::TrueClass')
+                    return true
+                
+                else
+                    raise 'internal error: tried to unwrapp primitive where type isn\'t primitive'
+                end
+
+            if present
+                value
+            else
+                default
+            end
+        end
+
+        def self.from_value(value:, env:)
+            case value
+            when Integer
+                t, prim = env.resolve_type('Integer'), [true, value]
+            when String
+                t, prim = env.resolve_type('String'), [true, value]
+            when Float
+                t, prim = env.resolve_type('Float'), [true, value]
+            when Symbol
+                t, prim = env.resolve_type('Symbol'), [true, value]
+            when Array
+                t, prim = env.resolve_type('Array'), [true, value]
+            when nil
+                t = env.resolve_type('NilClass')
+            when false
+                t = env.resolve_type('FalseClass')
+            when true
+                t = env.resolve_type('TrueClass')
+            else
+                raise 'internal error: could not convert primitive into instance'
+            end
+
+            new(
+                type: t,
+                env: env,
+                primitive_value: prim,
+            )
+        end
+
+        def falsey?
+            type == env.resolve_type('NilClass') || type == env.resolve_type('FalseClass')
+        end
+
+        def truthy?
+            !falsey?
+        end
+
+        def inspect
+            result = "#<interpreter object: #{type.rbs}"
+            if primitive_value[0]
+                result += " #{unwrap_primitive_value}"
+            else
+                if instance_variables.any?
+                    result += " #{instance_variables.map { |var, val| "#{var}=#{val}" }}"
+                end
+            end
+            result += ">"
+
+            result
+        end
+        alias to_s inspect
+
+        def ruby_inspect
+            # Special cases
+            if type == env.resolve_type('NilClass')
+                return ''
+            elsif type == env.resolve_type('TrueClass')
+                return 'true'
+            elsif type == env.resolve_type('FalseClass')
+                return 'false'
+            end
+
+            if primitive_value.first
+                primitive_value = unwrap_primitive_value
+                if primitive_value.is_a?(Array)
+                   "[" + primitive_value.map { |value| value.ruby_inspect }.join(", ") + "]"
+                else
+                    primitive_value.to_s
+                end
+            else
+                # Don't know how to handle this, call back to #<interpreter object: ...>
+                # representation
+                inspect
+            end
+        end
+    end
+end

data/lib/houndstooth/interpreter/runtime.rb

@@ -0,0 +1,309 @@
+require_relative 'const_internal'
+
+module Houndstooth::Interpreter
+    class Runtime
+        def initialize(env:)
+            @variables = {}
+            @env = env
+            @const_internal = ConstInternal.new(env: env)
+        end
+
+        # @return [{Variable => InterpreterObject}]
+        attr_accessor :variables
+
+        # @return [Environment]
+        attr_accessor :env
+
+        # @return [ConstInternal]
+        attr_accessor :const_internal
+
+        def execute_block(block, lexical_context:, self_type:, self_object:, type_arguments:)
+            block.instructions.each do |inst|
+                execute_instruction(inst, lexical_context: lexical_context, self_type: self_type, self_object: self_object, type_arguments: type_arguments)
+            end
+        end
+
+        def execute_instruction(ins, lexical_context:, self_type:, self_object:, type_arguments:)
+            case ins
+            when Houndstooth::Instructions::ConstantBaseAccessInstruction
+                # There's no object we can use to represent the constant base, so let's go with a 
+                # special symbol - it'll make it very obvious if it's being used somewhere it
+                # shouldn't
+                result_value = :constant_base
+
+            when Houndstooth::Instructions::ConstantAccessInstruction
+                if ins.target
+                    # TODO: will only work with types, not actual constants
+                    target_value = variables[ins.target]
+                    if target_value == :constant_base
+                        target = Houndstooth::Environment::BaseDefinedType.new
+                    else
+                        target = target_value.type
+                    end
+                else
+                    target = lexical_context
+                end
+                resolved = env.resolve_type(ins.name.to_s, type_context: env.resolve_type(target.uneigen))
+
+                if resolved.nil?
+                    Houndstooth::Errors::Error.new(
+                        "No constant named `#{ins.name}` on `#{target.rbs}`",
+                        [[ins.node.ast_node.loc.expression, "no such constant"]]
+                    ).push
+
+                    # Abandon
+                    variables[ins.result] = InterpreterObject.from_value(value: nil, env: env)
+                    return
+                end
+
+                result_value = InterpreterObject.new(type: resolved.eigen, env: env)
+
+            when Houndstooth::Instructions::TypeDefinitionInstruction
+                if ins.target
+                    Houndstooth::Errors::Error.new(
+                        "namespace targets visited by interpreter are not supported",
+                        [[node.ast_node.loc.expression, 'break up "class A::B" into separate definitions']],
+                    ).push
+                end
+
+                # Because it can't be overridden (not yet supported above), we know that the type
+                # is going to be defined on the lexical context
+                type_being_defined = env.resolve_type("#{lexical_context.uneigen}::#{ins.name}").eigen
+                type_being_defined_inst = type_being_defined.instantiate
+
+                execute_block(
+                    ins.body,
+                    lexical_context: type_being_defined,
+                    self_type: type_being_defined_inst,
+                    self_object: InterpreterObject.new(
+                        type: type_being_defined,
+                        env: env,
+                    ),
+                    type_arguments: type_arguments,
+                )
+
+                result_value = variables[ins.body.instructions.last.result]
+
+            when Houndstooth::Instructions::MethodDefinitionInstruction
+                method, _ = ins.resolve_method_and_type(self_type, env)
+
+                # Associate instruction block with environment
+                method.instruction_block = ins.body
+                
+                # Return name of defined method
+                result_value = InterpreterObject.from_value(value: ins.name, env: env)
+
+            when Houndstooth::Instructions::LiteralInstruction
+                result_value = InterpreterObject.from_value(value: ins.value, env: env)
+
+            when Houndstooth::Instructions::SelfInstruction
+                result_value = self_object
+
+            when Houndstooth::Instructions::AssignExistingInstruction
+                result_value = variables[ins.variable]
+
+            when Houndstooth::Instructions::SendInstruction
+                target = variables[ins.target]
+                meth = target.type.resolve_instance_method(ins.method_name, env)
+                args = ins.arguments.map do |arg|
+                    if arg.is_a?(Houndstooth::Instructions::PositionalArgument)
+                        variables[arg.variable]
+                    else
+                        raise 'internal error: unimplemented arg should\'ve been caught earlier than interpreter'
+                    end
+                end
+
+                if meth.nil?
+                    Houndstooth::Errors::Error.new(
+                        "`#{target}` has no method named `#{ins.method_name}`",
+                        [[ins.node.ast_node.loc.expression, 'no such method']],
+                    ).push
+
+                    # Abandon
+                    variables[ins.result] = InterpreterObject.from_value(value: nil, env: env)
+                    return
+                end
+                
+                if meth.const.nil?
+                    Houndstooth::Errors::Error.new(
+                        "Cannot call non-const method `#{meth.name}` on `#{target}` from const context",
+                        [[ins.node.ast_node.loc.expression, 'call is not const']],
+                    ).push
+
+                    # Abandon
+                    variables[ins.result] = InterpreterObject.from_value(value: nil, env: env)
+                    return
+                end
+
+                # Parse type arguments
+                type_args = Houndstooth::Environment::TypeParser.parse_type_arguments(env, ins.type_arguments, type_arguments)
+                    .map { |t| t.substitute_type_parameters(nil, type_arguments) }
+
+                # Crudely find the best signature based on the number of type parameters - this is
+                # extremely wonky!
+                type_params = meth.signatures.find { |sig| sig.type_parameters.length == type_args.length }&.type_parameters
+                raise 'internal error: no const signature matching number of type parameters' if type_params.nil?
+                type_arguments = type_arguments.merge(type_params.zip(type_args).to_h)
+
+                if meth.const_internal?
+                    # Look up, call, and set result
+                    begin
+                        definition = const_internal.method_definitions[meth]
+                        raise "internal error: `#{meth.name}` on `#{target}` is missing const-internal definition" if definition.nil?
+
+                        # It's OK for const-internal definitions to just execute the block directly
+                        # on this runtime, since the instruction generator will have sorted out any
+                        # local scoping with overlapping names for us
+                        result_value = definition.(
+                            target, *args,
+                            type_arguments: type_arguments,
+                            call_block: ->(args) do
+                                # `call_method`'s arguments expect Variables... but we don't have
+                                # any here! The value came from a magical internal source.
+                                # Instead, we can just make up some new ones; it'll be fine!
+                                args = args.map do |arg|
+                                    var = Houndstooth::Instructions::Variable.new
+                                    variables[var] = arg
+                                    Houndstooth::Instructions::PositionalArgument.new(var)
+                                end
+
+                                call_method(
+                                    block: ins.method_block,
+                                    arguments: args,
+                                    loc: ins.node.ast_node.loc,
+                                    type_arguments: type_arguments,
+                                    target: self_object,
+                                    lexical_context: lexical_context,
+                                )
+                            end,
+                        )
+                    rescue => e
+                        raise e if $cli_options[:fatal_interpreter]
+                        
+                        Houndstooth::Errors::Error.new(
+                            "Interpreter runtime error: #{e}\n       " \
+                            "(run with --fatal-interpreter to exit with backtrace on first error)",
+                            [[ins.node.ast_node.loc.expression, 'occurred within this call']],
+                        ).push
+
+                        # Abandon
+                        variables[ins.result] = InterpreterObject.from_value(value: nil, env: env)
+                        return
+                    end
+                else
+                    # Check there's actually a definition
+                    if meth.instruction_block.nil?
+                        Houndstooth::Errors::Error.new(
+                            "`#{meth.name}` on `#{target}` has not been defined yet",
+                            [[ins.node.ast_node.loc.expression, 'no definition of method called here']],
+                        ).push
+
+                        # Abandon
+                        variables[ins.result] = InterpreterObject.from_value(value: nil, env: env)
+                        return
+                    end
+
+                    call_result = call_method(
+                        block: meth.instruction_block,
+                        arguments: ins.arguments,
+                        loc: ins.node.ast_node.loc,
+                        type_arguments: type_arguments,
+                        target: target,
+                        lexical_context: lexical_context,
+                    )
+                    if call_result == false
+                        # Abandon
+                        variables[ins.result] = InterpreterObject.from_value(value: nil, env: env)
+                    else
+                        result_value = call_result
+                    end
+                end
+                
+            when Houndstooth::Instructions::ConditionalInstruction
+                condition = variables[ins.condition]
+                if condition.truthy?
+                    execute_block(ins.true_branch, lexical_context: lexical_context, self_type: self_type, self_object: self_object, type_arguments: type_arguments)
+                    result_value = variables[ins.true_branch.instructions.last.result]
+                else
+                    execute_block(ins.false_branch, lexical_context: lexical_context, self_type: self_type, self_object: self_object, type_arguments: type_arguments)
+                    result_value = variables[ins.false_branch.instructions.last.result]
+                end
+
+            when Houndstooth::Instructions::ToStringInstruction
+                obj = variables[ins.target]
+                result_value = obj.ruby_inspect
+                result_value = InterpreterObject.from_value(value: result_value, env: env)
+            else
+                raise "internal error: don't know how to interpret #{ins.class.name}"
+            end
+
+            variables[ins.result] = result_value
+        end
+
+        # Finds instructions at the very top level of a program to execute, and executes them. Not
+        # all instructions in the given block will be executed.
+        def execute_from_top_level(block)
+            # Run the interpreter on top-level definitions
+            # TODO: ...and also particular marked top-level sends (see notes in Obsidian)
+            # Because we don't allow definitions to have targets yet, this is fine - any nodes used to
+            # build up to the definition do not matter
+            instructions_to_interpret = []
+            block.instructions.each do |ins|
+                if ins.is_a?(Houndstooth::Instructions::TypeDefinitionInstruction)
+                    instructions_to_interpret << ins
+                end
+            end
+            instructions_to_interpret.each do |ins|
+                ins.mark_const_considered
+                execute_instruction(
+                    ins,
+                    self_object: nil, # TODO
+                    self_type: nil, # TODO
+                    lexical_context: Houndstooth::Environment::BaseDefinedType.new,
+                    type_arguments: {},
+                )
+            end
+        end
+
+        def call_method(block:, arguments:, loc:, type_arguments:, target:, lexical_context:)
+            # Create a new runtime frame to call this method
+            child_runtime = Runtime.new(env: env)
+
+            # Populate arguments
+            if arguments.length != block.parameters.length
+                Houndstooth::Errors::Error.new(
+                    "Wrong number of arguments to interpreter method call",
+                    [[loc.expression, "got #{arguments.length}, expected #{block.parameters.length}"]],
+                ).push
+
+                # Abandon
+                return false
+            end
+
+            arguments.zip(block.parameters).each do |arg, param_var|
+                unless arg.is_a?(Houndstooth::Instructions::PositionalArgument)
+                    Houndstooth::Errors::Error.new(
+                        "Unsupported argument type used - only positional arguments are supported",
+                        [[loc.expression, 'unsupported']],
+                    ).push
+
+                    # Abandon
+                    return false
+                end
+
+                # Inject variables into the runtime to set
+                child_runtime.variables[param_var] = variables[arg.variable]
+            end
+
+            # Execute body and set return value
+            child_runtime.execute_block(
+                block,
+                lexical_context: lexical_context,
+                self_object: target,
+                self_type: target.type,
+                type_arguments: type_arguments,
+            )
+            child_runtime.variables[block.instructions.last.result]
+        end
+    end
+end

data/lib/houndstooth/interpreter.rb

@@ -0,0 +1,7 @@
+module Houndstooth
+    module Interpreter; end
+end
+
+require_relative 'interpreter/objects'
+require_relative 'interpreter/runtime'
+require_relative 'interpreter/const_internal'