autotype 0.1.0

data/lib/autotype/native.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module AutotypeNative
+  class << self
+    def available?
+      load_extension!
+      const_get(:Solver)
+      true
+    rescue LoadError, StandardError
+      false
+    end
+
+    def load_extension!
+      return if @extension_loaded
+
+      ext_dir = File.expand_path("../../ext/autotype", __dir__)
+      bundle = File.join(ext_dir, "autotype.#{RbConfig::CONFIG['DLEXT']}")
+      native_sources = Dir[File.expand_path("../../native/autotype/src/*.c", __dir__)]
+      extension_source = File.join(ext_dir, "autotype.c")
+      sources = native_sources + [extension_source]
+
+      stale =
+        !File.exist?(bundle) ||
+        sources.any? { |source| File.exist?(source) && File.mtime(source) > File.mtime(bundle) }
+
+      if stale
+        Dir.chdir(ext_dir) { system("ruby extconf.rb && make", exception: true) }
+      end
+
+      require bundle
+      @extension_loaded = true
+    end
+  end
+end

data/lib/autotype/native_bridge.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Autotype
+  module NativeBridge
+    module_function
+
+    def enabled?
+      ENV["AUTOTYPE_NATIVE"] == "1" && native_available?
+    end
+
+    def native_available?
+      require_relative "native"
+      AutotypeNative.available?
+    rescue LoadError, StandardError
+      false
+    end
+
+    def export_type(type)
+      case type
+      when Autotype::Named
+        { "k" => "named", "name" => type.name }
+      when Autotype::Generic
+        { "k" => "generic", "name" => type.name, "args" => type.arguments.map { export_type(_1) } }
+      when Autotype::Union
+        { "k" => "union", "members" => type.members.map { export_type(_1) } }
+      when Autotype::TypeVariable
+        { "k" => "var", "id" => type.object_id, "hint" => type.hint.to_s }
+      else
+        { "k" => "named", "name" => "Object" }
+      end
+    end
+
+    def import_type(hash)
+      entry = hash.transform_keys(&:to_s)
+      case entry["k"]
+      when "named" then Autotype::Named.new(entry["name"])
+      when "generic"
+        Autotype::Generic.new(entry["name"], entry["args"].map { import_type(_1) })
+      when "union"
+        Autotype::Union.new(entry["members"].map { import_type(_1) })
+      else
+        Autotype::Named.new("Object")
+      end
+    end
+
+    def export_graph(inferencer)
+      resolve = inferencer.method(:resolve)
+      var_objects = {}
+      capabilities = []
+
+      inferencer.instance_variable_get(:@methods).each do |method|
+        method.capabilities.each do |capability|
+          next if capability.arguments.any? { |argument| argument.is_a?(Autotype::Function) }
+
+          args = capability.arguments.reject { |argument| argument.is_a?(Autotype::Function) }
+          result = capability.result
+          next unless result.is_a?(Autotype::TypeVariable)
+
+          var_objects[result.object_id] = result
+          receiver = capability.receiver
+          var_objects[receiver.object_id] = receiver if receiver.is_a?(Autotype::TypeVariable)
+
+          args.each do |argument|
+            var_objects[argument.object_id] = argument if argument.is_a?(Autotype::TypeVariable)
+          end
+
+          capabilities << {
+            "message" => capability.message.to_s,
+            "receiver" => export_type(receiver),
+            "result" => result.object_id,
+            "args" => args.map { export_type(_1) },
+            "line" => capability.line
+          }
+        end
+      end
+
+      bindings = inferencer.instance_variable_get(:@substitutions).each_with_object({}) do |(variable, type), hash|
+        resolved = resolve.call(type)
+        next if resolved.is_a?(Autotype::TypeVariable)
+
+        hash[variable.object_id] = export_type(resolved)
+      end
+
+      {
+        "capabilities" => capabilities,
+        "bindings" => bindings,
+        "var_count" => var_objects.size
+      }
+    end
+
+    def apply_result!(inferencer, result)
+      result = result.transform_keys(&:to_s) if result.is_a?(Hash)
+      var_map = {}
+      inferencer.instance_variable_get(:@methods).each do |method|
+        method.capabilities.each do |capability|
+          [capability.receiver, capability.result, *capability.arguments].each do |node|
+            var_map[node.object_id] = node if node.is_a?(Autotype::TypeVariable)
+          end
+        end
+        method.parameters.each { |parameter| var_map[parameter.type.object_id] = parameter.type if parameter.type.is_a?(Autotype::TypeVariable) }
+        method.ivars.each_value { |type| var_map[type.object_id] = type if type.is_a?(Autotype::TypeVariable) }
+      end
+
+      subs = inferencer.instance_variable_get(:@substitutions)
+      result.fetch("bindings").each do |object_id, type_hash|
+        variable = var_map[object_id.to_i]
+        next unless variable
+
+        subs[variable] = import_type(type_hash)
+      end
+    end
+
+    def prime!(inferencer)
+      native_available?
+      graph = export_graph(inferencer)
+      result = AutotypeNative.solve_graph(graph)
+      apply_result!(inferencer, result)
+      result
+    end
+  end
+end

data/lib/autotype/profile.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Autotype
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration) if block_given?
+      configuration
+    end
+
+    def profile
+      configure.load_profile
+    end
+
+    def reset_configuration!
+      @configuration = nil
+    end
+  end
+
+  class Configuration
+    attr_accessor :config_path
+
+    def initialize
+      @config_path = ENV["AUTOTYPE_CONFIG"]
+    end
+
+    def skipped_files
+      load_profile.skipped_files
+    end
+
+    def load_profile
+      return @profile if defined?(@profile) && @profile
+
+      path = config_path || DiscoveryProfile.find
+      @profile = path ? DiscoveryProfile.load_overrides(path) : DiscoveryProfile.new
+    end
+
+    def reload_profile!
+      remove_instance_variable(:@profile) if defined?(@profile)
+      load_profile
+    end
+  end
+end

data/lib/autotype/type_string.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Autotype
+  module TypeString
+    module_function
+
+    def parse(string)
+      string = string.to_s.strip
+      raise ArgumentError, "type string cannot be empty" if string.empty?
+
+      if string.include?("|")
+        members = string.split("|").map { parse(_1.strip) }
+        return members.first if members.length == 1
+
+        return Union.new(members.uniq)
+      end
+
+      if (match = string.match(/\A([A-Za-z_][\w:]*)\[(.*)\]\z/m))
+        name = match[1]
+        args = split_args(match[2]).map { parse(_1) }
+        return Generic.new(name, args)
+      end
+
+      Named.new(string)
+    end
+
+    def split_args(source)
+      args = []
+      depth = 0
+      start = 0
+      source.each_char.with_index do |char, index|
+        case char
+        when "["
+          depth += 1
+        when "]"
+          depth -= 1
+        when ","
+          if depth.zero?
+            args << source[start...index]
+            start = index + 1
+          end
+        end
+      end
+      args << source[start..]
+      args.map(&:strip).reject(&:empty?)
+    end
+  end
+end

data/lib/autotype/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Autotype
+  VERSION = "0.1.0"
+end

data/lib/autotype.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "autotype/version"
+require_relative "autotype/type_string"
+require_relative "autotype/profile"
+require_relative "autotype/discovery_profile"
+require_relative "autotype/engine"
+
+module Autotype
+  class << self
+    def run(argv = ARGV)
+      CLI.run(argv)
+    end
+  end
+end

data/native/autotype/Makefile

@@ -0,0 +1,23 @@
+CC ?= cc
+CFLAGS ?= -std=c11 -O3 -Wall -Wextra -Iinclude
+LDFLAGS ?=
+
+SRCS = src/type.c src/solver.c src/main.c
+OBJS = $(SRCS:.c=.o)
+BIN = stc_solve
+
+.PHONY: all clean test
+
+all: $(BIN)
+
+$(BIN): $(OBJS)
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS)
+
+src/%.o: src/%.c include/stc.h
+	$(CC) $(CFLAGS) -c -o $@ $<
+
+clean:
+	rm -f $(OBJS) $(BIN)
+
+test: $(BIN)
+	./$(BIN)

data/native/autotype/include/stc.h

@@ -0,0 +1,107 @@
+#ifndef STC_H
+#define STC_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#define STC_MAX_NAME 256
+#define STC_MAX_ITERATIONS 64
+
+typedef uint64_t stc_var_id;
+
+typedef enum {
+  STC_TY_NIL = 0,
+  STC_TY_NAMED,
+  STC_TY_VAR,
+  STC_TY_GENERIC,
+  STC_TY_UNION
+} stc_type_kind;
+
+typedef struct stc_type stc_type;
+
+struct stc_type {
+  stc_type_kind kind;
+  union {
+    struct { char name[STC_MAX_NAME]; } named;
+    struct { stc_var_id id; char hint[64]; } var;
+    struct {
+      char name[32];
+      stc_type **args;
+      size_t arg_count;
+    } generic;
+    struct {
+      stc_type **members;
+      size_t member_count;
+    } union_;
+  } as;
+};
+
+typedef struct {
+  stc_var_id id;
+  char hint[64];
+} stc_var;
+
+typedef struct {
+  stc_type *receiver;
+  stc_type *result;
+  char message[64];
+  stc_type **args;
+  size_t arg_count;
+  int32_t line;
+} stc_capability;
+
+typedef struct {
+  char name[STC_MAX_NAME];
+  char owner[STC_MAX_NAME];
+  stc_type *result;
+  stc_capability *capabilities;
+  size_t capability_count;
+} stc_method;
+
+typedef struct {
+  stc_var_id var_id;
+  stc_type *type;
+} stc_substitution;
+
+typedef struct {
+  stc_var *vars;
+  size_t var_count;
+
+  stc_method *methods;
+  size_t method_count;
+
+  stc_substitution *subs;
+  size_t sub_count;
+  size_t sub_cap;
+
+  stc_type **type_pool;
+  size_t type_pool_count;
+  size_t type_pool_cap;
+
+  int32_t changed;
+  int32_t iterations;
+  int32_t converged;
+} stc_solver;
+
+stc_solver *stc_solver_new(void);
+void stc_solver_free(stc_solver *solver);
+
+stc_type *stc_type_named(stc_solver *solver, const char *name);
+stc_type *stc_type_var(stc_solver *solver, stc_var_id id, const char *hint);
+stc_type *stc_type_generic(stc_solver *solver, const char *name, stc_type **args, size_t arg_count);
+stc_type *stc_type_union(stc_solver *solver, stc_type **members, size_t member_count);
+
+stc_type *stc_dereference(stc_solver *solver, stc_type *type);
+stc_type *stc_resolve(stc_solver *solver, stc_type *type);
+
+void stc_unify(stc_solver *solver, stc_type *left, stc_type *right);
+void stc_bind(stc_solver *solver, stc_var_id var_id, stc_type *type);
+
+void stc_apply_builtin(stc_solver *solver, stc_capability *capability);
+void stc_solve_to_fixed_point(stc_solver *solver);
+int stc_solver_run(stc_solver *solver);
+
+void stc_solver_load_flat(stc_solver *solver, stc_capability *capabilities, size_t capability_count);
+
+#endif

data/native/autotype/src/main.c

@@ -0,0 +1,50 @@
+#include "../include/stc.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* Minimal smoke-test driver for the native solver core. */
+int main(void) {
+  stc_solver *solver = stc_solver_new();
+  if (!solver) return 1;
+
+  stc_capability *caps = calloc(2, sizeof(stc_capability));
+  if (!caps) return 1;
+
+  caps[0].receiver = stc_type_var(solver, 1, "hash");
+  caps[0].result = stc_type_var(solver, 2, "array");
+  strncpy(caps[0].message, "[]", sizeof(caps[0].message) - 1);
+  caps[0].args = malloc(sizeof(stc_type *));
+  caps[0].args[0] = stc_type_var(solver, 3, "key");
+  caps[0].arg_count = 1;
+
+  caps[1].receiver = stc_type_var(solver, 2, "array");
+  caps[1].result = stc_type_var(solver, 10, "result");
+  strncpy(caps[1].message, "<<", sizeof(caps[1].message) - 1);
+  caps[1].args = malloc(sizeof(stc_type *));
+  caps[1].args[0] = stc_type_var(solver, 4, "item");
+  caps[1].arg_count = 1;
+
+  stc_solver_load_flat(solver, caps, 2);
+
+  stc_type *key = stc_type_named(solver, "Integer");
+  stc_type *element = stc_type_var(solver, 99, "element");
+  stc_type *hash_args[] = { key, stc_type_generic(solver, "Array", &element, 1) };
+  stc_type *hash_type = stc_type_generic(solver, "Hash", hash_args, 2);
+  stc_bind(solver, 1, hash_type);
+
+  stc_type *item = stc_type_named(solver, "Widget");
+  stc_bind(solver, 4, item);
+
+  stc_solver_run(solver);
+
+  stc_type *resolved = stc_resolve(solver, stc_type_var(solver, 10, "result"));
+  printf("converged=%d iterations=%d\n", solver->converged, solver->iterations);
+  if (resolved && resolved->kind == STC_TY_GENERIC) {
+    printf("result=%s\n", resolved->as.generic.name);
+  }
+
+  stc_solver_free(solver);
+  return 0;
+}