houndstooth 0.1.0

data/spec/interpreter_spec.rb

@@ -0,0 +1,170 @@
+RSpec.describe Houndstooth::Interpreter do
+    Iptr = Houndstooth::Interpreter
+
+    def interpret(code, local=nil)
+        env = Houndstooth::Environment.new
+        Houndstooth::Stdlib.add_types(env)
+
+        Houndstooth.process_file('(test)', code, env)
+
+        block = code_to_block(code)
+        runtime = Iptr::Runtime.new(env: env)
+        runtime.execute_block(
+            block,
+            self_type: nil,
+            self_object: nil,
+            lexical_context: Houndstooth::Environment::BaseDefinedType.new,
+            type_arguments: {},
+        )
+
+        if Houndstooth::Errors.errors.any?
+            raise "Errors occurred during interpretation:\n#{Houndstooth::Errors.errors.map(&:format).join("\n")}"
+        end
+
+        if local
+            [env, runtime.variables.find { |var, t| var.ruby_identifier == local }[1]]
+        else
+            [env, runtime]
+        end
+    end
+
+    it 'can unwrap primitive values' do
+        env = Houndstooth::Environment.new
+        Houndstooth::Stdlib.add_types(env)
+
+        # Unwrap where value given
+        known_int = Iptr::InterpreterObject.new(
+            type: env.resolve_type('Integer'),
+            env: env,
+            primitive_value: [true, 3],
+        )
+        expect(known_int.unwrap_primitive_value).to eq 3
+
+        # Unwrap where value not given (e.g. created with .new)
+        default_int = Iptr::InterpreterObject.new(
+            type: env.resolve_type('Integer'),
+            env: env,
+        )
+        expect(default_int.unwrap_primitive_value).to eq 0
+
+        # Can't unwrap non-primitive
+        expect do
+            Iptr::InterpreterObject.new(
+                type: env.resolve_type('Object'),
+                env: env,
+            ).unwrap_primitive_value
+        end.to raise_error(RuntimeError)
+    end
+
+    it 'assigns objects truthiness' do
+        env = Houndstooth::Environment.new
+        Houndstooth::Stdlib.add_types(env)
+
+        fals = Iptr::InterpreterObject.new(
+            type: env.resolve_type('FalseClass'),
+            env: env,
+        )
+        expect(fals.truthy?).to eq false
+
+        nl = Iptr::InterpreterObject.new(
+            type: env.resolve_type('NilClass'),
+            env: env,
+        )
+        expect(nl.truthy?).to eq false
+
+        tru = Iptr::InterpreterObject.new(
+            type: env.resolve_type('TrueClass'),
+            env: env,
+        )
+        expect(tru.truthy?).to eq true
+
+        int = Iptr::InterpreterObject.new(
+            type: env.resolve_type('Integer'),
+            env: env,
+        )
+        expect(int.truthy?).to eq true
+    end
+
+    it 'can execute basic literal evaluations' do
+        env, x = interpret('x = 3', 'x')
+        expect(x).to m(Iptr::InterpreterObject,
+            type: env.resolve_type('Integer'),
+            primitive_value: [true, 3]
+        )
+    end
+
+    it 'can send to const internal methods' do
+        env, x = interpret('x = 2 + 3', 'x')
+        expect(x).to m(Iptr::InterpreterObject,
+            type: env.resolve_type('Integer'),
+            primitive_value: [true, 5]
+        )
+    end
+    
+    it 'recurses into definitions' do
+        env, x = interpret('class X; class Y; x = 3; end; end', 'x')
+        expect(x).to m(Iptr::InterpreterObject,
+            type: env.resolve_type('Integer'),
+            primitive_value: [true, 3]
+        )
+    end
+
+    it 'can call const methods defined in Ruby' do
+        # No parameters
+        env, x = interpret('
+            module X
+                #: () -> Integer
+                #!const
+                def self.good_enough_pi
+                    3
+                end
+            end
+            
+            x = X.good_enough_pi
+        ', 'x')
+        expect(x).to m(Iptr::InterpreterObject,
+            type: env.resolve_type('Integer'),
+            primitive_value: [true, 3]
+        )
+
+        # Parameters
+        env, x = interpret('
+            module X
+                #: (Integer, Integer) -> Integer
+                #!const
+                def self.add_two(x, y)
+                    x + y
+                end
+            end
+            
+            x = X.add_two(2, 3)
+        ', 'x')
+        expect(x).to m(Iptr::InterpreterObject,
+            type: env.resolve_type('Integer'),
+            primitive_value: [true, 5]
+        )
+
+        # Working `self`
+        env, x = interpret('
+            module X
+                #: (Integer, Integer, Integer) -> Integer
+                #!const
+                def self.add_three(x, y, z)
+                    add_two(add_two(x, y), z)
+                end
+
+                #: (Integer, Integer) -> Integer
+                #!const
+                def self.add_two(x, y)
+                    x + y
+                end
+            end
+
+            x = X.add_three(1, 2, 3)
+        ', 'x')
+        expect(x).to m(Iptr::InterpreterObject,
+            type: env.resolve_type('Integer'),
+            primitive_value: [true, 6]
+        )
+    end
+end

data/spec/self_spec.rb

@@ -0,0 +1,7 @@
+# RSpec.describe 'self-test' do
+#     it 'does not fail when trying to parse this project' do
+#         Dir[File.join(__dir__, '..', '**', '*.rb')].each do |file|
+#             code_to_semantic_node(File.read(file))
+#         end
+#     end
+# end

data/spec/spec_helper.rb

@@ -0,0 +1,50 @@
+require 'simplecov'
+SimpleCov.start if defined?(RSpec)
+
+require_relative '../lib/houndstooth'
+
+RSpec.configure do |config|
+    config.expect_with :rspec do |expectations|
+        expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+    end
+
+    config.mock_with :rspec do |mocks|
+        mocks.verify_partial_doubles = true
+    end
+
+    config.shared_context_metadata_behavior = :apply_to_host_groups
+
+    config.before :each do
+        Houndstooth::Errors.reset
+    end
+
+    config.after :each do
+        if Houndstooth::Errors.errors.any?
+            errors = Houndstooth::Errors.errors.map { |e| e.format }.join("\n")
+            raise "Errors occurred during test:\n#{errors}"
+        end
+    end
+end if defined?(RSpec)
+
+def m(type, **attrs)
+    if attrs.length > 0
+        be_a(type) & have_attributes(**attrs)
+    else
+        be_a(type)
+    end
+end
+
+def code_to_semantic_node(code)
+    buffer = Parser::Source::Buffer.new("arg")
+    buffer.source = code
+
+    ast_node, comments = Parser::Ruby30.new.parse_with_comments(buffer)
+    $comments = comments
+    Houndstooth::SemanticNode.from_ast(ast_node)
+end
+
+def code_to_block(code)
+    block = I::InstructionBlock.new(has_scope: true, parent: nil)
+    code_to_semantic_node(code).to_instructions(block)
+    block
+end

data/test/ruby_interpreter_test.rb

@@ -0,0 +1,162 @@
+require_relative '../lib/houndstooth'
+require_relative '../spec/spec_helper' # contains code_to_X methods
+
+def run(command)
+    out = `#{command}`
+    abort "command failed: #{command}" unless $?.success?
+    out
+end
+
+# Perform a sparse checkout of the Ruby repository to grab bootstraptest
+ruby_dir = File.join(__dir__, "ruby")
+if Dir.exist?(ruby_dir)
+    puts "Ruby directory already exists, skipping checkout"
+else
+    puts "Sparse-checking out Ruby..."
+    Dir.mkdir(ruby_dir)
+    Dir.chdir(ruby_dir) do
+        run("git init")
+        run("git remote add -f origin https://github.com/ruby/ruby.git")
+        run("git config core.sparseCheckout true")
+        File.write(File.join(ruby_dir, ".git", "info", "sparse-checkout"), "bootstraptest/")
+        run("git pull origin master")
+    end
+end
+
+I = Houndstooth::Instructions
+
+# Required for Houndstooth.process_file, which expects to be run from the binary
+def abort_on_error!
+    if Houndstooth::Errors.errors.any?
+        raise "Errors occurred during interpretation:\n#{Houndstooth::Errors.errors.map(&:format).join("\n")}"
+    end
+end 
+
+def interpreter_execute(code)
+    # Create environment
+    env = Houndstooth::Environment.new
+    Houndstooth::Stdlib.add_types(env)
+
+    # Process input
+    Houndstooth.process_file('(test)', code, env)
+
+    # Process and evaluate input
+    block = code_to_block(code)
+    runtime = Houndstooth::Interpreter::Runtime.new(env: env)
+    runtime.execute_block(
+        block,
+        self_type: nil,
+        self_object: nil,
+        lexical_context: Houndstooth::Environment::BaseDefinedType.new,
+        type_arguments: {},
+    )
+
+    # If an error occurred, throw
+    abort_on_error!
+
+    # Get return value
+    runtime.variables[block.instructions.last.result]
+end
+
+$bootstrap_test_passes = Hash.new { |h, k| h[k] = [] }
+$bootstrap_test_failures = Hash.new { |h, k| h[k] = [] }
+$bootstrap_test_crashes = Hash.new { |h, k| h[k] = [] }
+$bootstrap_test_unimplemented = Hash.new { |h, k| h[k] = [] }
+
+module BootstrapTestHarness
+    def self.clear_errors
+        Houndstooth::Errors.errors.clear
+    end 
+
+    def self.target_platform
+        ""
+    end
+
+    def self.assert_equal(expected_result, code, *_)
+        clear_errors
+
+        actual_result = interpreter_execute(code)
+        if actual_result.ruby_inspect == expected_result
+            $bootstrap_test_passes[$bootstrap_test_current_file] << [expected_result, code]
+        else
+            $bootstrap_test_failures[$bootstrap_test_current_file] << [expected_result, actual_result.ruby_inspect, code]
+        end
+    rescue => e
+        $bootstrap_test_crashes[$bootstrap_test_current_file] << [expected_result, code]
+    end
+
+    def self.assert_match(matcher, code, *_)
+        clear_errors
+
+        actual_result = interpreter_execute(code)
+        if matcher === actual_result.ruby_inspect
+            $bootstrap_test_passes[$bootstrap_test_current_file] << [matcher, code]
+        else
+            $bootstrap_test_failures[$bootstrap_test_current_file] << [matcher, actual_result, code]
+        end
+    rescue
+        $bootstrap_test_crashes[$bootstrap_test_current_file] << [matcher, code]
+    end
+
+    def self.assert_not_match(matcher, code, *_)
+        clear_errors
+
+        actual_result = interpreter_execute(code)
+        if !(matcher === actual_result.ruby_inspect)
+            $bootstrap_test_passes[$bootstrap_test_current_file] << [matcher, code]
+        else
+            $bootstrap_test_failures[$bootstrap_test_current_file] << [matcher, actual_result, code]
+        end
+    rescue
+        $bootstrap_test_crashes[$bootstrap_test_current_file] << [matcher, code]
+    end
+
+    def self.assert_normal_exit(code, message="(normal exit)", *_)
+        clear_errors
+        interpreter_execute(code)
+    rescue
+        $bootstrap_test_crashes[$bootstrap_test_current_file] << [message, code]
+    end
+
+    def self.assert_valid_syntax(code, *_)
+        clear_errors
+        assert_normal_exit(code, "(valid syntax)")
+    end
+
+    def self.assert_finish(code, *_)
+        clear_errors
+        assert_normal_exit(code, "(finish)")
+    end
+
+    def self.method_missing(*a)
+        $bootstrap_test_unimplemented[$bootstrap_test_current_file] << a
+    end
+end
+
+files = Dir[File.join(ruby_dir, "bootstraptest", "test_*.rb")]
+files.each do |file|
+    puts file
+    test = File.read(file)
+    $bootstrap_test_current_file = file
+    BootstrapTestHarness.instance_eval(test, file)
+end
+
+puts
+puts "== RESULTS =="
+puts
+files.each do |file|
+    print File.split(file)[1]
+    print ":   "
+    print "#{$bootstrap_test_passes[file].length} passed, "
+    print "#{$bootstrap_test_failures[file].length} failed, "
+    print "#{$bootstrap_test_crashes[file].length} crashed, "
+    print "#{$bootstrap_test_unimplemented[file].length} unimplemented"
+    puts
+end
+
+puts
+puts "== TOTALS =="
+puts "Passes: #{$bootstrap_test_passes.values.map(&:length).sum}"
+puts "Failures: #{$bootstrap_test_failures.values.map(&:length).sum}"
+puts "Crashes: #{$bootstrap_test_crashes.values.map(&:length).sum}"
+puts "Unimplemented tests: #{$bootstrap_test_unimplemented.values.map(&:length).sum}"

data/types/stdlib.htt

@@ -0,0 +1,170 @@
+# Useful reference:
+# https://tiagodev.wordpress.com/2013/04/16/eigenclasses-for-lunch-the-ruby-object-model/
+
+#!magic basicobject
+class BasicObject
+    #: () -> void
+    def initialize; end
+
+    #: (Class) -> Boolean
+    def is_a?(_); end
+end
+
+class Class < Module
+    #: () -> Class
+    def superclass; end
+
+    #: () -> void
+    def initialize; end
+
+    #: () -> Object
+    # Special case of `new` being defined as a method rather than magically - this only affects the
+    # rather rare usage `Class.new.new`, not anything else e.g. `Object.new`
+    def new; end
+end
+
+class Object < BasicObject
+    #: () -> String
+    def inspect; end
+
+    #: (Object) -> Boolean
+    def ==(other); end
+end
+
+class Module
+    #: () -> Array[Module]
+    def nesting; end
+
+    # The RBS syntax doesn't support any nicer way of doing this :(
+    #: [                                         R] (Symbol) { ()                                        -> R } -> Symbol
+    #: [A1,                                      R] (Symbol) { (A1)                                      -> R } -> Symbol
+    #: [A1, A2,                                  R] (Symbol) { (A1, A2)                                  -> R } -> Symbol
+    #: [A1, A2, A3,                              R] (Symbol) { (A1, A2, A3)                              -> R } -> Symbol
+    #: [A1, A2, A3, A4,                          R] (Symbol) { (A1, A2, A3, A4)                          -> R } -> Symbol
+    #: [A1, A2, A3, A4, A5,                      R] (Symbol) { (A1, A2, A3, A4, A5)                      -> R } -> Symbol
+    #: [A1, A2, A3, A4, A5, A6,                  R] (Symbol) { (A1, A2, A3, A4, A5, A6)                  -> R } -> Symbol
+    #: [A1, A2, A3, A4, A5, A6, A7,              R] (Symbol) { (A1, A2, A3, A4, A5, A6, A7)              -> R } -> Symbol
+    #: [A1, A2, A3, A4, A5, A6, A7, A8,          R] (Symbol) { (A1, A2, A3, A4, A5, A6, A7, A8)          -> R } -> Symbol
+    #: [A1, A2, A3, A4, A5, A6, A7, A8, A9,      R] (Symbol) { (A1, A2, A3, A4, A5, A6, A7, A8, A9)      -> R } -> Symbol
+    #: [A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R] (Symbol) { (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) -> R } -> Symbol
+    #!const required_internal
+    def define_method(name, *); end
+
+    #: [T] (Symbol) -> void
+    #!const required_internal
+    def attr_reader(name); end
+
+    #: [T] (Symbol) -> void
+    #!const required_internal
+    def attr_writer(name); end
+
+    # TODO: Method visibility setters are only supported in their argument-taking form
+    
+    #: (Symbol) -> void
+    #!const required_internal
+    def private(name); end
+
+    #: (Symbol) -> void
+    #!const required_internal
+    def protected(name); end
+end
+
+class Numeric
+    #: (Numeric) -> Numeric
+    #!const internal
+    def +(other); end
+
+    #: (Numeric) -> Boolean
+    def >(other); end
+
+    #: (Numeric) -> Boolean
+    def >=(other); end
+
+    #: (Numeric) -> Boolean
+    def <(other); end
+
+    #: (Numeric) -> Boolean
+    def <=(other); end
+end
+
+class Integer < Numeric
+    #: (Integer) -> Integer
+    #: (Float) -> Float
+    #!const internal
+    def +(other); end
+
+    #: () { (Integer) -> void } -> Integer
+    #!const internal
+    def times; end
+
+    #: () -> Integer
+    def abs; end
+end
+
+class Float < Numeric
+    #: (Integer) -> Float
+    #: (Float) -> Float
+    #!const internal
+    def +(other); end
+
+    #: () -> Float
+    def abs; end
+end
+
+class String
+    #: (String) -> String
+    #!const internal
+    def +(other); end
+
+    #: () -> Integer
+    def length; end
+
+    #: () -> Symbol
+    #!const internal
+    def to_sym; end
+end
+
+class Symbol; end
+
+#!param T
+class Array    
+    #: () -> void
+    #!const internal
+    def initialize; end
+
+    #: (T) -> Array[T]
+    #!const internal
+    def <<(item); end
+
+    # TODO: should be nilable
+    #: (Integer) -> T
+    def [](index); end
+
+    #: () -> Integer
+    def length; end
+
+    #: () { (T) -> void } -> Array[T]
+    #!const internal
+    def each; end
+end
+
+# Doesn't actually exist, but we need some kind of boolean type
+class Boolean; end
+class TrueClass < Boolean; end
+class FalseClass < Boolean; end
+
+class NilClass; end
+
+class Kernel
+    #: (?Float) -> Float
+    #: (Integer) -> Integer
+    def self.rand(max=nil); end
+
+    #!const internal
+    #: (?untyped) -> void
+    def self.puts(message=nil); end
+
+    #!const internal
+    #: (?untyped) -> void
+    def self.print(message=nil); end
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: houndstooth
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Aaron Christiansen
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-04-28 00:00:00.000000000 Z
+dependencies: []
+description:
+email:
+- aaronc20000@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".ruby-version"
+- Gemfile
+- Gemfile.lock
+- README.md
+- bin/houndstooth.rb
+- fuzz/cases/x.rb
+- fuzz/cases/y.rb
+- fuzz/cases/z.rb
+- fuzz/ruby.dict
+- fuzz/run
+- lib/houndstooth.rb
+- lib/houndstooth/environment.rb
+- lib/houndstooth/environment/builder.rb
+- lib/houndstooth/environment/type_parser.rb
+- lib/houndstooth/environment/types.rb
+- lib/houndstooth/environment/types/basic/type.rb
+- lib/houndstooth/environment/types/basic/type_instance.rb
+- lib/houndstooth/environment/types/compound/union_type.rb
+- lib/houndstooth/environment/types/defined/base_defined_type.rb
+- lib/houndstooth/environment/types/defined/defined_type.rb
+- lib/houndstooth/environment/types/defined/pending_defined_type.rb
+- lib/houndstooth/environment/types/method/method.rb
+- lib/houndstooth/environment/types/method/method_type.rb
+- lib/houndstooth/environment/types/method/parameters.rb
+- lib/houndstooth/environment/types/method/special_constructor_method.rb
+- lib/houndstooth/environment/types/special/instance_type.rb
+- lib/houndstooth/environment/types/special/self_type.rb
+- lib/houndstooth/environment/types/special/type_parameter_placeholder.rb
+- lib/houndstooth/environment/types/special/untyped_type.rb
+- lib/houndstooth/environment/types/special/void_type.rb
+- lib/houndstooth/errors.rb
+- lib/houndstooth/instructions.rb
+- lib/houndstooth/interpreter.rb
+- lib/houndstooth/interpreter/const_internal.rb
+- lib/houndstooth/interpreter/objects.rb
+- lib/houndstooth/interpreter/runtime.rb
+- lib/houndstooth/semantic_node.rb
+- lib/houndstooth/semantic_node/control_flow.rb
+- lib/houndstooth/semantic_node/definitions.rb
+- lib/houndstooth/semantic_node/identifiers.rb
+- lib/houndstooth/semantic_node/keywords.rb
+- lib/houndstooth/semantic_node/literals.rb
+- lib/houndstooth/semantic_node/operators.rb
+- lib/houndstooth/semantic_node/parameters.rb
+- lib/houndstooth/semantic_node/send.rb
+- lib/houndstooth/semantic_node/super.rb
+- lib/houndstooth/stdlib.rb
+- lib/houndstooth/type_checker.rb
+- spec/ast_to_node_spec.rb
+- spec/environment_spec.rb
+- spec/instructions_spec.rb
+- spec/integration_spec.rb
+- spec/interpreter_spec.rb
+- spec/self_spec.rb
+- spec/spec_helper.rb
+- test/ruby_interpreter_test.rb
+- types/stdlib.htt
+homepage: https://github.com/AaronC81/houndstooth
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.22
+signing_key:
+specification_version: 4
+summary: Experimental type checker
+test_files:
+- spec/ast_to_node_spec.rb
+- spec/environment_spec.rb
+- spec/instructions_spec.rb
+- spec/integration_spec.rb
+- spec/interpreter_spec.rb
+- spec/self_spec.rb
+- spec/spec_helper.rb
+- test/ruby_interpreter_test.rb