feat: framework resolvers, synthesis, VB.NET and codegraph context

crates/codegraph-bench/Cargo.toml

@@ -26,6 +26,9 @@ rusqlite = { workspace = true }
 sha2 = { workspace = true }
 codegraph-core = { path = "../codegraph-core" }
 codegraph-extract = { path = "../codegraph-extract" }
+codegraph-resolve = { path = "../codegraph-resolve" }
+regex = "1.10"
+tree-sitter = { workspace = true }
 
 [target.'cfg(unix)'.dependencies]
 libc = "0.2"

crates/codegraph-bench/fixtures/go/config.go

@@ -0,0 +1,41 @@
+package payroll
+
+import "errors"
+
+// Errors a payroll run returns.
+var (
+	// ErrNoRun is returned when no run is scheduled.
+	ErrNoRun   = errors.New("no run")
+	ErrTooLate = newRunError("too late")
+)
+
+// Phases of a payroll run.
+const (
+	PhaseDraft = iota
+	PhaseFinal
+)
+
+// Schedule runs a hook at the end of a run.
+type Schedule struct {
+	Hook func() error
+}
+
+func newRunError(msg string) error { return errors.New(msg) }
+
+func closeBooks() error { return nil }
+
+var nightly = Schedule{Hook: closeBooks}
+
+var defaultEmitter = &Emitter{Table: "payroll"}
+
+var runAll = func() error {
+	_ = RunNightly("all")
+	return closeBooks()
+}
+
+func phaseOf(final bool) int {
+	if final {
+		return PhaseFinal
+	}
+	return PhaseDraft
+}

crates/codegraph-bench/fixtures/synthesis/c/src/cmds.c

@@ -0,0 +1,13 @@
+#include "cmds.h"
+
+static void getCommand(int argc) {}
+static void setCommand(int argc) {}
+
+static struct COMMAND_T commandTable[] = {
+    MAKE_CMD("get", getCommand),
+    MAKE_CMD("set", setCommand),
+};
+
+void call(struct client *c, int argc) {
+    c->cmd->proc(argc);
+}

crates/codegraph-bench/fixtures/synthesis/c/src/cmds.h

@@ -0,0 +1,14 @@
+typedef void cmdProc(int argc);
+
+struct command {
+    const char *name;
+    cmdProc *proc;
+};
+
+struct client {
+    int id;
+    struct command *cmd, *lastcmd;
+};
+
+#define MAKE_CMD(name, fn) { name, fn }
+#define COMMAND_T command

crates/codegraph-bench/fixtures/synthesis/c/src/opcodes.c

@@ -0,0 +1,10 @@
+typedef void opcode_t(unsigned char op);
+
+static void op_nop(unsigned char op) {}
+static void op_inc(unsigned char op) {}
+
+static opcode_t *opcodes[2] = { op_nop, op_inc };
+
+void step(unsigned char op) {
+    opcodes[op](op);
+}

crates/codegraph-bench/fixtures/synthesis/c/src/optab.c

@@ -0,0 +1,18 @@
+typedef int opRun(void);
+
+struct op {
+    const char *name;
+    opRun *run;
+};
+
+#define MK(nm, fn) nm, fn
+#define CMD_T op
+
+static int optab_a(void) { return 0; }
+static int optab_b(void) { return 0; }
+
+#include "optab.def"
+
+int dispatch_op(struct op *o) {
+    return o->run();
+}

crates/codegraph-bench/fixtures/synthesis/c/src/optab.def

@@ -0,0 +1,4 @@
+static struct CMD_T optable[] = {
+    { MK("a", optab_a) },
+    { MK("b", optab_b) },
+};

crates/codegraph-bench/fixtures/synthesis/cpp/src/launch.cpp

@@ -0,0 +1,12 @@
+void kernel_a(int n) {}
+
+template <typename T>
+void kernel_b(T n) {}
+
+void launch(int n) {
+    auto kernel = &kernel_a;
+    if (n > 1) {
+        kernel = &kernel_b<int>;
+    }
+    kernel(n);
+}

crates/codegraph-bench/fixtures/synthesis/dispatch/app/Http/Registration.php

@@ -0,0 +1,12 @@
+<?php
+namespace App\Http;
+
+use App\Events\Registered;
+
+class Registration
+{
+    public function register(): void
+    {
+        event(new Registered());
+    }
+}

crates/codegraph-bench/fixtures/synthesis/dispatch/app/Listeners/SendWelcome.php

@@ -0,0 +1,11 @@
+<?php
+namespace App\Listeners;
+
+use App\Events\Registered;
+
+class SendWelcome
+{
+    public function handle(Registered $event): void
+    {
+    }
+}

crates/codegraph-bench/fixtures/synthesis/dispatch/app/services/signup.rb

@@ -0,0 +1,5 @@
+class Signup
+  def call(user)
+    WelcomeWorker.perform_async(user.id)
+  end
+end

crates/codegraph-bench/fixtures/synthesis/dispatch/app/workers/welcome_worker.rb

@@ -0,0 +1,7 @@
+class WelcomeWorker
+  include Sidekiq::Worker
+
+  def perform(user_id)
+    user_id
+  end
+end

crates/codegraph-bench/fixtures/synthesis/dispatch/src/Orders.cs

@@ -0,0 +1,18 @@
+namespace App;
+
+public class PlaceOrder : IRequest<int> { }
+
+public class PlaceOrderHandler : IRequestHandler<PlaceOrder, int>
+{
+    public Task<int> Handle(PlaceOrder request, CancellationToken ct) => Task.FromResult(1);
+}
+
+public class OrdersController
+{
+    private readonly ISender _mediator;
+
+    public async Task Place()
+    {
+        await _mediator.Send(new PlaceOrder());
+    }
+}

crates/codegraph-bench/fixtures/synthesis/go.mod

@@ -0,0 +1,3 @@
+module example.com/synthesis
+
+require github.com/gogf/gf/v2 v2.7.0

crates/codegraph-bench/fixtures/synthesis/go/ec2/ec2.go

@@ -0,0 +1,30 @@
+package ec2
+
+import (
+	"context"
+
+	"example.com/synth/refresh"
+)
+
+type Discovery struct {
+	*refresh.Discovery
+	region string
+}
+
+func New(region string) *Discovery {
+	d := &Discovery{region: region}
+	d.Discovery = refresh.NewDiscovery(refresh.Options{
+		Mech:     "ec2",
+		RefreshF: d.refresh,
+	})
+	return d
+}
+
+func (d *Discovery) refresh(ctx context.Context) ([]*refresh.Group, error) {
+	return nil, nil
+}
+
+func listStatic(ctx context.Context) ([]*refresh.Group, error) { return nil, nil }
+
+// The static provider's options, wired at package level.
+var staticOptions = refresh.Options{Mech: "static", RefreshF: listStatic}

crates/codegraph-bench/fixtures/synthesis/go/gin/app.go

@@ -0,0 +1,11 @@
+package gin
+
+func Logger(c *Context) {}
+
+func getUser(c *Context) {}
+
+func setup(e *Engine) {
+	e.Use(Logger)
+	e.GET("/users", getUser)
+	e.GET("/inline", func(c *Context) {})
+}