wehub-resource-sync
427 lines
32 KiB
C
427 lines
32 KiB
C
/* rust_crates_seed.c — Common-crate API seeds for the Rust LSP.
|
|
*
|
|
* Per RUST_LSP_FOLLOWUP.md A3: we don't run Cargo or download deps.
|
|
* What we CAN do is hand-curate a small registered-method seed for the
|
|
* most-used external crates (serde, tokio, anyhow, clap, regex, log,
|
|
* futures, thiserror, reqwest, hyper, async-trait, parking_lot,
|
|
* chrono, uuid, lazy_static, once_cell, rayon, …) so a project that
|
|
* just `use`s these crates resolves the obvious calls instead of
|
|
* leaving them all `unresolved`.
|
|
*
|
|
* Each entry is "best-effort" — we register the type with its trait
|
|
* QNs in embedded_types and synthesize the high-frequency methods
|
|
* with vaguely-correct return shapes. Anything we get wrong stays
|
|
* `unresolved` rather than a wrong edge (per the doc's no-false-edge
|
|
* policy: we only register what we're confident about).
|
|
*
|
|
* Designed to be appended to the existing stdlib register: takes the
|
|
* same (reg, arena) pair. */
|
|
|
|
#include "../type_rep.h"
|
|
#include "../type_registry.h"
|
|
#include "../rust_lsp.h"
|
|
#include <string.h>
|
|
|
|
/* Shorthand. Mirrors the macros in rust_stdlib_data.c. */
|
|
#ifndef RUST_CRATES_SEED_INCLUDED
|
|
#define RUST_CRATES_SEED_INCLUDED 1
|
|
|
|
#define CADD_TYPE(qn, sn, iface) do { \
|
|
CBMRegisteredType _rt; \
|
|
memset(&_rt, 0, sizeof(_rt)); \
|
|
_rt.qualified_name = (qn); \
|
|
_rt.short_name = (sn); \
|
|
_rt.is_interface = (iface); \
|
|
cbm_registry_add_type(reg, _rt); \
|
|
} while (0)
|
|
|
|
#define CADD_FUNC(rcv, sn, qn, ret_type) do { \
|
|
CBMRegisteredFunc _rf; \
|
|
memset(&_rf, 0, sizeof(_rf)); \
|
|
_rf.qualified_name = (qn); \
|
|
_rf.short_name = (sn); \
|
|
_rf.receiver_type = (rcv); \
|
|
_rf.min_params = -1; \
|
|
const CBMType** _rta = (const CBMType**)cbm_arena_alloc(arena, \
|
|
2 * sizeof(const CBMType*)); \
|
|
_rta[0] = (ret_type); \
|
|
_rta[1] = NULL; \
|
|
_rf.signature = cbm_type_func(arena, NULL, NULL, _rta); \
|
|
cbm_registry_add_func(reg, _rf); \
|
|
} while (0)
|
|
|
|
void cbm_rust_crates_register(CBMTypeRegistry* reg, CBMArena* arena) {
|
|
const CBMType* t_unit = cbm_type_builtin(arena, "()");
|
|
const CBMType* t_bool = cbm_type_builtin(arena, "bool");
|
|
const CBMType* t_usize = cbm_type_builtin(arena, "usize");
|
|
const CBMType* t_str_ref = cbm_type_reference(arena,
|
|
cbm_type_builtin(arena, "str"));
|
|
const CBMType* t_string = cbm_type_named(arena, "alloc.string.String");
|
|
|
|
/* ── serde — Serialize / Deserialize / json ─────────────── */
|
|
CADD_TYPE("serde.Serialize", "Serialize", true);
|
|
CADD_TYPE("serde.Deserialize", "Deserialize", true);
|
|
CADD_TYPE("serde.Serializer", "Serializer", true);
|
|
CADD_TYPE("serde.Deserializer", "Deserializer", true);
|
|
CADD_TYPE("serde.de.Error", "Error", true);
|
|
CADD_TYPE("serde.ser.Error", "Error", true);
|
|
CADD_TYPE("serde_json.Value", "Value", false);
|
|
CADD_TYPE("serde_json.Map", "Map", false);
|
|
CADD_TYPE("serde_json.Number", "Number", false);
|
|
CADD_TYPE("serde_json.Error", "Error", false);
|
|
|
|
CADD_FUNC("serde.Serialize", "serialize", "serde.Serialize.serialize", cbm_type_unknown());
|
|
CADD_FUNC("serde.Deserialize", "deserialize", "serde.Deserialize.deserialize", cbm_type_unknown());
|
|
CADD_FUNC("serde_json.Value", "is_null", "serde_json.Value.is_null", t_bool);
|
|
CADD_FUNC("serde_json.Value", "is_bool", "serde_json.Value.is_bool", t_bool);
|
|
CADD_FUNC("serde_json.Value", "is_number", "serde_json.Value.is_number", t_bool);
|
|
CADD_FUNC("serde_json.Value", "is_string", "serde_json.Value.is_string", t_bool);
|
|
CADD_FUNC("serde_json.Value", "is_array", "serde_json.Value.is_array", t_bool);
|
|
CADD_FUNC("serde_json.Value", "is_object", "serde_json.Value.is_object", t_bool);
|
|
CADD_FUNC("serde_json.Value", "as_bool", "serde_json.Value.as_bool", cbm_type_unknown());
|
|
CADD_FUNC("serde_json.Value", "as_i64", "serde_json.Value.as_i64", cbm_type_unknown());
|
|
CADD_FUNC("serde_json.Value", "as_f64", "serde_json.Value.as_f64", cbm_type_unknown());
|
|
CADD_FUNC("serde_json.Value", "as_str", "serde_json.Value.as_str", cbm_type_unknown());
|
|
CADD_FUNC("serde_json.Value", "as_array", "serde_json.Value.as_array", cbm_type_unknown());
|
|
CADD_FUNC("serde_json.Value", "as_object", "serde_json.Value.as_object", cbm_type_unknown());
|
|
CADD_FUNC("serde_json.Value", "get", "serde_json.Value.get", cbm_type_unknown());
|
|
CADD_FUNC("serde_json.Value", "pointer", "serde_json.Value.pointer", cbm_type_unknown());
|
|
CADD_FUNC("serde_json.Value", "to_string", "serde_json.Value.to_string", t_string);
|
|
/* Free functions in serde_json. */
|
|
CADD_FUNC(NULL, "from_str", "serde_json.from_str", cbm_type_unknown());
|
|
CADD_FUNC(NULL, "to_string", "serde_json.to_string", cbm_type_unknown());
|
|
CADD_FUNC(NULL, "from_value","serde_json.from_value",cbm_type_unknown());
|
|
CADD_FUNC(NULL, "to_value", "serde_json.to_value", cbm_type_unknown());
|
|
CADD_FUNC(NULL, "json", "serde_json.json", cbm_type_named(arena, "serde_json.Value"));
|
|
|
|
/* ── anyhow — Error / Result / ensure!/bail!/anyhow! ───── */
|
|
CADD_TYPE("anyhow.Error", "Error", false);
|
|
CADD_TYPE("anyhow.Result", "Result", false);
|
|
CADD_TYPE("anyhow.Chain", "Chain", false);
|
|
CADD_FUNC("anyhow.Error", "new", "anyhow.Error.new", cbm_type_named(arena, "anyhow.Error"));
|
|
CADD_FUNC("anyhow.Error", "from", "anyhow.Error.from", cbm_type_named(arena, "anyhow.Error"));
|
|
CADD_FUNC("anyhow.Error", "msg", "anyhow.Error.msg", cbm_type_named(arena, "anyhow.Error"));
|
|
CADD_FUNC("anyhow.Error", "context", "anyhow.Error.context", cbm_type_named(arena, "anyhow.Error"));
|
|
CADD_FUNC("anyhow.Error", "downcast", "anyhow.Error.downcast", cbm_type_unknown());
|
|
CADD_FUNC("anyhow.Error", "downcast_ref","anyhow.Error.downcast_ref", cbm_type_unknown());
|
|
CADD_FUNC("anyhow.Error", "is", "anyhow.Error.is", t_bool);
|
|
CADD_FUNC("anyhow.Error", "chain", "anyhow.Error.chain", cbm_type_unknown());
|
|
CADD_FUNC("anyhow.Error", "root_cause","anyhow.Error.root_cause", cbm_type_unknown());
|
|
CADD_FUNC("anyhow.Error", "source", "anyhow.Error.source", cbm_type_unknown());
|
|
/* Free functions. */
|
|
CADD_FUNC(NULL, "anyhow", "anyhow.anyhow", cbm_type_named(arena, "anyhow.Error"));
|
|
CADD_FUNC(NULL, "bail", "anyhow.bail", cbm_type_unknown());
|
|
CADD_FUNC(NULL, "ensure", "anyhow.ensure", cbm_type_unknown());
|
|
|
|
/* ── thiserror — derive-only crate, but the Error trait. ─── */
|
|
/* (Error trait is already covered under core.error.Error.) */
|
|
|
|
/* ── tokio — runtime + I/O + sync primitives. ───────────── */
|
|
CADD_TYPE("tokio.runtime.Runtime", "Runtime", false);
|
|
CADD_TYPE("tokio.runtime.Handle", "Handle", false);
|
|
CADD_TYPE("tokio.runtime.Builder", "Builder", false);
|
|
CADD_TYPE("tokio.task.JoinHandle", "JoinHandle",false);
|
|
CADD_TYPE("tokio.sync.Mutex", "Mutex", false);
|
|
CADD_TYPE("tokio.sync.RwLock", "RwLock", false);
|
|
CADD_TYPE("tokio.sync.Semaphore", "Semaphore", false);
|
|
CADD_TYPE("tokio.sync.Notify", "Notify", false);
|
|
CADD_TYPE("tokio.sync.oneshot.Sender","Sender", false);
|
|
CADD_TYPE("tokio.sync.oneshot.Receiver","Receiver", false);
|
|
CADD_TYPE("tokio.sync.mpsc.Sender", "Sender", false);
|
|
CADD_TYPE("tokio.sync.mpsc.Receiver", "Receiver", false);
|
|
CADD_TYPE("tokio.sync.mpsc.UnboundedSender","UnboundedSender", false);
|
|
CADD_TYPE("tokio.sync.mpsc.UnboundedReceiver","UnboundedReceiver", false);
|
|
CADD_TYPE("tokio.net.TcpListener", "TcpListener", false);
|
|
CADD_TYPE("tokio.net.TcpStream", "TcpStream", false);
|
|
CADD_TYPE("tokio.io.BufReader", "BufReader", false);
|
|
CADD_TYPE("tokio.io.BufWriter", "BufWriter", false);
|
|
CADD_TYPE("tokio.time.Sleep", "Sleep", false);
|
|
CADD_TYPE("tokio.time.Interval", "Interval", false);
|
|
CADD_TYPE("tokio.fs.File", "File", false);
|
|
CADD_TYPE("tokio.process.Command", "Command", false);
|
|
CADD_TYPE("tokio.process.Child", "Child", false);
|
|
|
|
CADD_FUNC("tokio.runtime.Runtime", "new", "tokio.runtime.Runtime.new", cbm_type_unknown());
|
|
CADD_FUNC("tokio.runtime.Runtime", "block_on", "tokio.runtime.Runtime.block_on", cbm_type_unknown());
|
|
CADD_FUNC("tokio.runtime.Runtime", "spawn", "tokio.runtime.Runtime.spawn", cbm_type_unknown());
|
|
CADD_FUNC("tokio.runtime.Runtime", "handle", "tokio.runtime.Runtime.handle", cbm_type_unknown());
|
|
CADD_FUNC("tokio.runtime.Runtime", "shutdown_timeout","tokio.runtime.Runtime.shutdown_timeout", t_unit);
|
|
CADD_FUNC("tokio.runtime.Builder", "new_multi_thread","tokio.runtime.Builder.new_multi_thread", cbm_type_unknown());
|
|
CADD_FUNC("tokio.runtime.Builder", "new_current_thread","tokio.runtime.Builder.new_current_thread", cbm_type_unknown());
|
|
CADD_FUNC("tokio.runtime.Builder", "worker_threads","tokio.runtime.Builder.worker_threads", cbm_type_unknown());
|
|
CADD_FUNC("tokio.runtime.Builder", "enable_all","tokio.runtime.Builder.enable_all", cbm_type_unknown());
|
|
CADD_FUNC("tokio.runtime.Builder", "build", "tokio.runtime.Builder.build", cbm_type_unknown());
|
|
CADD_FUNC("tokio.runtime.Handle", "current", "tokio.runtime.Handle.current", cbm_type_unknown());
|
|
CADD_FUNC("tokio.runtime.Handle", "spawn", "tokio.runtime.Handle.spawn", cbm_type_unknown());
|
|
CADD_FUNC("tokio.runtime.Handle", "block_on", "tokio.runtime.Handle.block_on", cbm_type_unknown());
|
|
CADD_FUNC("tokio.task.JoinHandle", "await", "tokio.task.JoinHandle.await", cbm_type_unknown());
|
|
CADD_FUNC("tokio.task.JoinHandle", "abort", "tokio.task.JoinHandle.abort", t_unit);
|
|
CADD_FUNC("tokio.task.JoinHandle", "is_finished","tokio.task.JoinHandle.is_finished", t_bool);
|
|
CADD_FUNC("tokio.sync.Mutex", "new", "tokio.sync.Mutex.new", cbm_type_unknown());
|
|
CADD_FUNC("tokio.sync.Mutex", "lock", "tokio.sync.Mutex.lock", cbm_type_unknown());
|
|
CADD_FUNC("tokio.sync.Mutex", "try_lock", "tokio.sync.Mutex.try_lock", cbm_type_unknown());
|
|
CADD_FUNC("tokio.sync.RwLock", "new", "tokio.sync.RwLock.new", cbm_type_unknown());
|
|
CADD_FUNC("tokio.sync.RwLock", "read", "tokio.sync.RwLock.read", cbm_type_unknown());
|
|
CADD_FUNC("tokio.sync.RwLock", "write", "tokio.sync.RwLock.write", cbm_type_unknown());
|
|
CADD_FUNC("tokio.sync.Semaphore", "new", "tokio.sync.Semaphore.new", cbm_type_unknown());
|
|
CADD_FUNC("tokio.sync.Semaphore", "acquire", "tokio.sync.Semaphore.acquire", cbm_type_unknown());
|
|
CADD_FUNC("tokio.sync.Semaphore", "add_permits","tokio.sync.Semaphore.add_permits", t_unit);
|
|
CADD_FUNC("tokio.sync.Notify", "new", "tokio.sync.Notify.new", cbm_type_unknown());
|
|
CADD_FUNC("tokio.sync.Notify", "notified", "tokio.sync.Notify.notified", cbm_type_unknown());
|
|
CADD_FUNC("tokio.sync.Notify", "notify_one","tokio.sync.Notify.notify_one", t_unit);
|
|
CADD_FUNC("tokio.sync.Notify", "notify_waiters","tokio.sync.Notify.notify_waiters", t_unit);
|
|
CADD_FUNC("tokio.sync.mpsc.Sender", "send", "tokio.sync.mpsc.Sender.send", cbm_type_unknown());
|
|
CADD_FUNC("tokio.sync.mpsc.Sender", "try_send","tokio.sync.mpsc.Sender.try_send",cbm_type_unknown());
|
|
CADD_FUNC("tokio.sync.mpsc.Receiver","recv", "tokio.sync.mpsc.Receiver.recv", cbm_type_unknown());
|
|
CADD_FUNC("tokio.sync.mpsc.Receiver","try_recv","tokio.sync.mpsc.Receiver.try_recv",cbm_type_unknown());
|
|
CADD_FUNC("tokio.sync.oneshot.Sender","send", "tokio.sync.oneshot.Sender.send", cbm_type_unknown());
|
|
CADD_FUNC("tokio.sync.oneshot.Receiver","await","tokio.sync.oneshot.Receiver.await", cbm_type_unknown());
|
|
CADD_FUNC("tokio.net.TcpListener", "bind", "tokio.net.TcpListener.bind", cbm_type_unknown());
|
|
CADD_FUNC("tokio.net.TcpListener", "accept", "tokio.net.TcpListener.accept", cbm_type_unknown());
|
|
CADD_FUNC("tokio.net.TcpListener", "local_addr","tokio.net.TcpListener.local_addr",cbm_type_unknown());
|
|
CADD_FUNC("tokio.net.TcpStream", "connect", "tokio.net.TcpStream.connect", cbm_type_unknown());
|
|
CADD_FUNC("tokio.net.TcpStream", "peer_addr","tokio.net.TcpStream.peer_addr", cbm_type_unknown());
|
|
CADD_FUNC("tokio.time.Sleep", "await", "tokio.time.Sleep.await", t_unit);
|
|
CADD_FUNC("tokio.time.Interval", "tick", "tokio.time.Interval.tick", cbm_type_unknown());
|
|
CADD_FUNC("tokio.fs.File", "open", "tokio.fs.File.open", cbm_type_unknown());
|
|
CADD_FUNC("tokio.fs.File", "create", "tokio.fs.File.create", cbm_type_unknown());
|
|
/* Free functions. */
|
|
CADD_FUNC(NULL, "spawn", "tokio.spawn", cbm_type_named(arena, "tokio.task.JoinHandle"));
|
|
CADD_FUNC(NULL, "spawn_blocking","tokio.task.spawn_blocking", cbm_type_named(arena, "tokio.task.JoinHandle"));
|
|
CADD_FUNC(NULL, "yield_now","tokio.task.yield_now", t_unit);
|
|
CADD_FUNC(NULL, "sleep", "tokio.time.sleep", cbm_type_named(arena, "tokio.time.Sleep"));
|
|
CADD_FUNC(NULL, "sleep_until","tokio.time.sleep_until", cbm_type_named(arena, "tokio.time.Sleep"));
|
|
CADD_FUNC(NULL, "interval", "tokio.time.interval", cbm_type_named(arena, "tokio.time.Interval"));
|
|
CADD_FUNC(NULL, "timeout", "tokio.time.timeout", cbm_type_unknown());
|
|
CADD_FUNC(NULL, "read_to_string","tokio.fs.read_to_string", cbm_type_unknown());
|
|
CADD_FUNC(NULL, "write", "tokio.fs.write", cbm_type_unknown());
|
|
CADD_FUNC(NULL, "read", "tokio.fs.read", cbm_type_unknown());
|
|
CADD_FUNC(NULL, "channel", "tokio.sync.mpsc.channel", cbm_type_unknown());
|
|
CADD_FUNC(NULL, "unbounded_channel","tokio.sync.mpsc.unbounded_channel", cbm_type_unknown());
|
|
CADD_FUNC(NULL, "join", "tokio.join", cbm_type_unknown());
|
|
CADD_FUNC(NULL, "try_join", "tokio.try_join", cbm_type_unknown());
|
|
CADD_FUNC(NULL, "select", "tokio.select", cbm_type_unknown());
|
|
|
|
/* ── clap — argument parsing. ─────────────────────────── */
|
|
CADD_TYPE("clap.Parser", "Parser", true);
|
|
CADD_TYPE("clap.Args", "Args", true);
|
|
CADD_TYPE("clap.Subcommand", "Subcommand", true);
|
|
CADD_TYPE("clap.ValueEnum", "ValueEnum", true);
|
|
CADD_TYPE("clap.Command", "Command", false);
|
|
CADD_TYPE("clap.Arg", "Arg", false);
|
|
CADD_TYPE("clap.ArgMatches", "ArgMatches", false);
|
|
|
|
CADD_FUNC("clap.Parser", "parse", "clap.Parser.parse", cbm_type_unknown());
|
|
CADD_FUNC("clap.Parser", "try_parse", "clap.Parser.try_parse", cbm_type_unknown());
|
|
CADD_FUNC("clap.Parser", "parse_from", "clap.Parser.parse_from", cbm_type_unknown());
|
|
CADD_FUNC("clap.Parser", "try_parse_from","clap.Parser.try_parse_from",cbm_type_unknown());
|
|
CADD_FUNC("clap.Parser", "command", "clap.Parser.command", cbm_type_named(arena, "clap.Command"));
|
|
CADD_FUNC("clap.Command","new", "clap.Command.new", cbm_type_named(arena, "clap.Command"));
|
|
CADD_FUNC("clap.Command","arg", "clap.Command.arg", cbm_type_named(arena, "clap.Command"));
|
|
CADD_FUNC("clap.Command","subcommand", "clap.Command.subcommand", cbm_type_named(arena, "clap.Command"));
|
|
CADD_FUNC("clap.Command","about", "clap.Command.about", cbm_type_named(arena, "clap.Command"));
|
|
CADD_FUNC("clap.Command","version", "clap.Command.version", cbm_type_named(arena, "clap.Command"));
|
|
CADD_FUNC("clap.Command","author", "clap.Command.author", cbm_type_named(arena, "clap.Command"));
|
|
CADD_FUNC("clap.Command","get_matches", "clap.Command.get_matches", cbm_type_named(arena, "clap.ArgMatches"));
|
|
CADD_FUNC("clap.Command","get_matches_from","clap.Command.get_matches_from", cbm_type_named(arena, "clap.ArgMatches"));
|
|
CADD_FUNC("clap.Arg", "new", "clap.Arg.new", cbm_type_named(arena, "clap.Arg"));
|
|
CADD_FUNC("clap.Arg", "short", "clap.Arg.short", cbm_type_named(arena, "clap.Arg"));
|
|
CADD_FUNC("clap.Arg", "long", "clap.Arg.long", cbm_type_named(arena, "clap.Arg"));
|
|
CADD_FUNC("clap.Arg", "value_name", "clap.Arg.value_name", cbm_type_named(arena, "clap.Arg"));
|
|
CADD_FUNC("clap.Arg", "required", "clap.Arg.required", cbm_type_named(arena, "clap.Arg"));
|
|
CADD_FUNC("clap.Arg", "default_value", "clap.Arg.default_value", cbm_type_named(arena, "clap.Arg"));
|
|
CADD_FUNC("clap.Arg", "help", "clap.Arg.help", cbm_type_named(arena, "clap.Arg"));
|
|
CADD_FUNC("clap.ArgMatches","get_one", "clap.ArgMatches.get_one", cbm_type_unknown());
|
|
CADD_FUNC("clap.ArgMatches","get_many", "clap.ArgMatches.get_many", cbm_type_unknown());
|
|
CADD_FUNC("clap.ArgMatches","get_flag", "clap.ArgMatches.get_flag", t_bool);
|
|
CADD_FUNC("clap.ArgMatches","contains_id","clap.ArgMatches.contains_id",t_bool);
|
|
CADD_FUNC("clap.ArgMatches","subcommand", "clap.ArgMatches.subcommand",cbm_type_unknown());
|
|
|
|
/* ── regex — pattern matching. ────────────────────────── */
|
|
CADD_TYPE("regex.Regex", "Regex", false);
|
|
CADD_TYPE("regex.Captures", "Captures", false);
|
|
CADD_TYPE("regex.Match", "Match", false);
|
|
CADD_TYPE("regex.RegexBuilder","RegexBuilder", false);
|
|
|
|
CADD_FUNC("regex.Regex", "new", "regex.Regex.new", cbm_type_unknown());
|
|
CADD_FUNC("regex.Regex", "is_match", "regex.Regex.is_match", t_bool);
|
|
CADD_FUNC("regex.Regex", "find", "regex.Regex.find", cbm_type_unknown());
|
|
CADD_FUNC("regex.Regex", "find_iter", "regex.Regex.find_iter", cbm_type_unknown());
|
|
CADD_FUNC("regex.Regex", "captures", "regex.Regex.captures", cbm_type_unknown());
|
|
CADD_FUNC("regex.Regex", "captures_iter","regex.Regex.captures_iter", cbm_type_unknown());
|
|
CADD_FUNC("regex.Regex", "replace", "regex.Regex.replace", t_string);
|
|
CADD_FUNC("regex.Regex", "replace_all", "regex.Regex.replace_all", t_string);
|
|
CADD_FUNC("regex.Regex", "split", "regex.Regex.split", cbm_type_unknown());
|
|
CADD_FUNC("regex.Regex", "as_str", "regex.Regex.as_str", t_str_ref);
|
|
CADD_FUNC("regex.Captures","get", "regex.Captures.get", cbm_type_unknown());
|
|
CADD_FUNC("regex.Captures","name", "regex.Captures.name", cbm_type_unknown());
|
|
CADD_FUNC("regex.Captures","len", "regex.Captures.len", t_usize);
|
|
CADD_FUNC("regex.Match", "as_str", "regex.Match.as_str", t_str_ref);
|
|
CADD_FUNC("regex.Match", "start", "regex.Match.start", t_usize);
|
|
CADD_FUNC("regex.Match", "end", "regex.Match.end", t_usize);
|
|
CADD_FUNC("regex.Match", "range", "regex.Match.range", cbm_type_unknown());
|
|
|
|
/* ── log — logging macros + Logger trait. ─────────────── */
|
|
CADD_TYPE("log.Logger", "Logger", true);
|
|
CADD_TYPE("log.Level", "Level", false);
|
|
CADD_TYPE("log.LevelFilter", "LevelFilter", false);
|
|
CADD_TYPE("log.Metadata", "Metadata", false);
|
|
CADD_TYPE("log.Record", "Record", false);
|
|
/* The macros log!/info!/warn!/error!/debug!/trace! are matched by
|
|
* name in rust_lsp.c's macro handler — register them as void
|
|
* synthetic functions so the resolver can attribute them. */
|
|
CADD_FUNC(NULL, "info", "log.info", t_unit);
|
|
CADD_FUNC(NULL, "warn", "log.warn", t_unit);
|
|
CADD_FUNC(NULL, "error", "log.error", t_unit);
|
|
CADD_FUNC(NULL, "debug", "log.debug", t_unit);
|
|
CADD_FUNC(NULL, "trace", "log.trace", t_unit);
|
|
CADD_FUNC(NULL, "log", "log.log", t_unit);
|
|
CADD_FUNC(NULL, "set_logger","log.set_logger", cbm_type_unknown());
|
|
CADD_FUNC(NULL, "set_max_level","log.set_max_level", t_unit);
|
|
|
|
/* ── futures — Future combinators + stream / sink. ────── */
|
|
CADD_TYPE("futures.Future", "Future", true);
|
|
CADD_TYPE("futures.Stream", "Stream", true);
|
|
CADD_TYPE("futures.Sink", "Sink", true);
|
|
CADD_TYPE("futures.StreamExt","StreamExt",true);
|
|
CADD_TYPE("futures.FutureExt","FutureExt",true);
|
|
CADD_TYPE("futures.SinkExt", "SinkExt", true);
|
|
CADD_TYPE("futures.executor.LocalPool","LocalPool", false);
|
|
|
|
CADD_FUNC("futures.StreamExt", "next", "futures.StreamExt.next", cbm_type_unknown());
|
|
CADD_FUNC("futures.StreamExt", "map", "futures.StreamExt.map", cbm_type_unknown());
|
|
CADD_FUNC("futures.StreamExt", "filter", "futures.StreamExt.filter", cbm_type_unknown());
|
|
CADD_FUNC("futures.StreamExt", "filter_map", "futures.StreamExt.filter_map", cbm_type_unknown());
|
|
CADD_FUNC("futures.StreamExt", "for_each", "futures.StreamExt.for_each", cbm_type_unknown());
|
|
CADD_FUNC("futures.StreamExt", "collect", "futures.StreamExt.collect", cbm_type_unknown());
|
|
CADD_FUNC("futures.StreamExt", "fold", "futures.StreamExt.fold", cbm_type_unknown());
|
|
CADD_FUNC("futures.StreamExt", "take", "futures.StreamExt.take", cbm_type_unknown());
|
|
CADD_FUNC("futures.StreamExt", "skip", "futures.StreamExt.skip", cbm_type_unknown());
|
|
CADD_FUNC("futures.StreamExt", "chunks", "futures.StreamExt.chunks", cbm_type_unknown());
|
|
CADD_FUNC("futures.StreamExt", "buffered", "futures.StreamExt.buffered", cbm_type_unknown());
|
|
CADD_FUNC("futures.SinkExt", "send", "futures.SinkExt.send", cbm_type_unknown());
|
|
CADD_FUNC("futures.SinkExt", "send_all", "futures.SinkExt.send_all", cbm_type_unknown());
|
|
CADD_FUNC("futures.SinkExt", "flush", "futures.SinkExt.flush", cbm_type_unknown());
|
|
CADD_FUNC("futures.SinkExt", "close", "futures.SinkExt.close", cbm_type_unknown());
|
|
CADD_FUNC("futures.FutureExt", "boxed", "futures.FutureExt.boxed", cbm_type_unknown());
|
|
CADD_FUNC("futures.FutureExt", "fuse", "futures.FutureExt.fuse", cbm_type_unknown());
|
|
CADD_FUNC("futures.FutureExt", "shared", "futures.FutureExt.shared", cbm_type_unknown());
|
|
|
|
CADD_FUNC(NULL, "join_all", "futures.future.join_all", cbm_type_unknown());
|
|
CADD_FUNC(NULL, "try_join_all", "futures.future.try_join_all", cbm_type_unknown());
|
|
CADD_FUNC(NULL, "select", "futures.future.select", cbm_type_unknown());
|
|
CADD_FUNC(NULL, "ready", "futures.future.ready", cbm_type_unknown());
|
|
|
|
/* ── parking_lot — drop-in std::sync alternatives. ────── */
|
|
CADD_TYPE("parking_lot.Mutex", "Mutex", false);
|
|
CADD_TYPE("parking_lot.RwLock", "RwLock", false);
|
|
CADD_TYPE("parking_lot.MutexGuard", "MutexGuard", false);
|
|
CADD_TYPE("parking_lot.RwLockReadGuard","RwLockReadGuard", false);
|
|
CADD_TYPE("parking_lot.RwLockWriteGuard","RwLockWriteGuard", false);
|
|
CADD_TYPE("parking_lot.Condvar", "Condvar", false);
|
|
CADD_TYPE("parking_lot.Once", "Once", false);
|
|
|
|
CADD_FUNC("parking_lot.Mutex", "new", "parking_lot.Mutex.new", cbm_type_unknown());
|
|
CADD_FUNC("parking_lot.Mutex", "lock", "parking_lot.Mutex.lock", cbm_type_unknown());
|
|
CADD_FUNC("parking_lot.Mutex", "try_lock", "parking_lot.Mutex.try_lock", cbm_type_unknown());
|
|
CADD_FUNC("parking_lot.RwLock", "new", "parking_lot.RwLock.new", cbm_type_unknown());
|
|
CADD_FUNC("parking_lot.RwLock", "read", "parking_lot.RwLock.read", cbm_type_unknown());
|
|
CADD_FUNC("parking_lot.RwLock", "write", "parking_lot.RwLock.write", cbm_type_unknown());
|
|
|
|
/* ── lazy_static / once_cell — singleton init. ────────── */
|
|
CADD_TYPE("once_cell.sync.Lazy", "Lazy", false);
|
|
CADD_TYPE("once_cell.sync.OnceCell","OnceCell", false);
|
|
CADD_TYPE("once_cell.unsync.Lazy","Lazy", false);
|
|
CADD_FUNC("once_cell.sync.Lazy","new","once_cell.sync.Lazy.new",cbm_type_unknown());
|
|
CADD_FUNC("once_cell.sync.OnceCell","new","once_cell.sync.OnceCell.new",cbm_type_unknown());
|
|
CADD_FUNC("once_cell.sync.OnceCell","get","once_cell.sync.OnceCell.get",cbm_type_unknown());
|
|
CADD_FUNC("once_cell.sync.OnceCell","set","once_cell.sync.OnceCell.set",cbm_type_unknown());
|
|
CADD_FUNC("once_cell.sync.OnceCell","get_or_init","once_cell.sync.OnceCell.get_or_init", cbm_type_unknown());
|
|
|
|
/* ── chrono — date/time. ────────────────────────────── */
|
|
CADD_TYPE("chrono.DateTime", "DateTime", false);
|
|
CADD_TYPE("chrono.NaiveDate", "NaiveDate", false);
|
|
CADD_TYPE("chrono.NaiveTime", "NaiveTime", false);
|
|
CADD_TYPE("chrono.NaiveDateTime","NaiveDateTime",false);
|
|
CADD_TYPE("chrono.Duration", "Duration", false);
|
|
CADD_TYPE("chrono.Utc", "Utc", false);
|
|
CADD_TYPE("chrono.Local", "Local", false);
|
|
|
|
CADD_FUNC("chrono.DateTime", "now", "chrono.DateTime.now", cbm_type_unknown());
|
|
CADD_FUNC("chrono.DateTime", "format", "chrono.DateTime.format", cbm_type_unknown());
|
|
CADD_FUNC("chrono.DateTime", "timestamp", "chrono.DateTime.timestamp", cbm_type_unknown());
|
|
CADD_FUNC("chrono.DateTime", "to_rfc3339","chrono.DateTime.to_rfc3339",t_string);
|
|
CADD_FUNC("chrono.Utc", "now", "chrono.Utc.now", cbm_type_unknown());
|
|
CADD_FUNC("chrono.Local", "now", "chrono.Local.now", cbm_type_unknown());
|
|
CADD_FUNC("chrono.Duration", "seconds", "chrono.Duration.seconds", cbm_type_unknown());
|
|
CADD_FUNC("chrono.Duration", "minutes", "chrono.Duration.minutes", cbm_type_unknown());
|
|
CADD_FUNC("chrono.Duration", "hours", "chrono.Duration.hours", cbm_type_unknown());
|
|
CADD_FUNC("chrono.Duration", "days", "chrono.Duration.days", cbm_type_unknown());
|
|
|
|
/* ── uuid — IDs. ────────────────────────────────────── */
|
|
CADD_TYPE("uuid.Uuid", "Uuid", false);
|
|
CADD_FUNC("uuid.Uuid", "new_v4", "uuid.Uuid.new_v4", cbm_type_unknown());
|
|
CADD_FUNC("uuid.Uuid", "nil", "uuid.Uuid.nil", cbm_type_unknown());
|
|
CADD_FUNC("uuid.Uuid", "parse_str", "uuid.Uuid.parse_str", cbm_type_unknown());
|
|
CADD_FUNC("uuid.Uuid", "to_string", "uuid.Uuid.to_string", t_string);
|
|
CADD_FUNC("uuid.Uuid", "to_hyphenated","uuid.Uuid.to_hyphenated", cbm_type_unknown());
|
|
CADD_FUNC("uuid.Uuid", "as_bytes", "uuid.Uuid.as_bytes", cbm_type_unknown());
|
|
|
|
/* ── reqwest — HTTP client. ──────────────────────────── */
|
|
CADD_TYPE("reqwest.Client", "Client", false);
|
|
CADD_TYPE("reqwest.RequestBuilder","RequestBuilder", false);
|
|
CADD_TYPE("reqwest.Response", "Response", false);
|
|
CADD_TYPE("reqwest.Error", "Error", false);
|
|
CADD_TYPE("reqwest.Url", "Url", false);
|
|
CADD_TYPE("reqwest.header.HeaderMap","HeaderMap", false);
|
|
|
|
CADD_FUNC("reqwest.Client", "new", "reqwest.Client.new", cbm_type_named(arena, "reqwest.Client"));
|
|
CADD_FUNC("reqwest.Client", "builder", "reqwest.Client.builder", cbm_type_unknown());
|
|
CADD_FUNC("reqwest.Client", "get", "reqwest.Client.get", cbm_type_named(arena, "reqwest.RequestBuilder"));
|
|
CADD_FUNC("reqwest.Client", "post", "reqwest.Client.post", cbm_type_named(arena, "reqwest.RequestBuilder"));
|
|
CADD_FUNC("reqwest.Client", "put", "reqwest.Client.put", cbm_type_named(arena, "reqwest.RequestBuilder"));
|
|
CADD_FUNC("reqwest.Client", "delete", "reqwest.Client.delete", cbm_type_named(arena, "reqwest.RequestBuilder"));
|
|
CADD_FUNC("reqwest.Client", "request", "reqwest.Client.request", cbm_type_named(arena, "reqwest.RequestBuilder"));
|
|
CADD_FUNC("reqwest.RequestBuilder","header","reqwest.RequestBuilder.header", cbm_type_named(arena, "reqwest.RequestBuilder"));
|
|
CADD_FUNC("reqwest.RequestBuilder","headers","reqwest.RequestBuilder.headers", cbm_type_named(arena, "reqwest.RequestBuilder"));
|
|
CADD_FUNC("reqwest.RequestBuilder","body", "reqwest.RequestBuilder.body", cbm_type_named(arena, "reqwest.RequestBuilder"));
|
|
CADD_FUNC("reqwest.RequestBuilder","json", "reqwest.RequestBuilder.json", cbm_type_named(arena, "reqwest.RequestBuilder"));
|
|
CADD_FUNC("reqwest.RequestBuilder","form", "reqwest.RequestBuilder.form", cbm_type_named(arena, "reqwest.RequestBuilder"));
|
|
CADD_FUNC("reqwest.RequestBuilder","query","reqwest.RequestBuilder.query", cbm_type_named(arena, "reqwest.RequestBuilder"));
|
|
CADD_FUNC("reqwest.RequestBuilder","send", "reqwest.RequestBuilder.send", cbm_type_named(arena, "reqwest.Response"));
|
|
CADD_FUNC("reqwest.Response","status", "reqwest.Response.status", cbm_type_unknown());
|
|
CADD_FUNC("reqwest.Response","headers", "reqwest.Response.headers", cbm_type_unknown());
|
|
CADD_FUNC("reqwest.Response","text", "reqwest.Response.text", cbm_type_unknown());
|
|
CADD_FUNC("reqwest.Response","json", "reqwest.Response.json", cbm_type_unknown());
|
|
CADD_FUNC("reqwest.Response","bytes", "reqwest.Response.bytes", cbm_type_unknown());
|
|
CADD_FUNC("reqwest.Url", "parse", "reqwest.Url.parse", cbm_type_unknown());
|
|
|
|
/* ── rayon — parallel iteration. ────────────────────── */
|
|
CADD_TYPE("rayon.iter.ParallelIterator","ParallelIterator", true);
|
|
CADD_TYPE("rayon.iter.IntoParallelIterator","IntoParallelIterator", true);
|
|
|
|
CADD_FUNC("rayon.iter.ParallelIterator","map", "rayon.iter.ParallelIterator.map", cbm_type_unknown());
|
|
CADD_FUNC("rayon.iter.ParallelIterator","filter", "rayon.iter.ParallelIterator.filter", cbm_type_unknown());
|
|
CADD_FUNC("rayon.iter.ParallelIterator","for_each", "rayon.iter.ParallelIterator.for_each", t_unit);
|
|
CADD_FUNC("rayon.iter.ParallelIterator","collect", "rayon.iter.ParallelIterator.collect", cbm_type_unknown());
|
|
CADD_FUNC("rayon.iter.ParallelIterator","reduce", "rayon.iter.ParallelIterator.reduce", cbm_type_unknown());
|
|
CADD_FUNC("rayon.iter.ParallelIterator","sum", "rayon.iter.ParallelIterator.sum", cbm_type_unknown());
|
|
CADD_FUNC("rayon.iter.ParallelIterator","count", "rayon.iter.ParallelIterator.count", t_usize);
|
|
CADD_FUNC("rayon.iter.ParallelIterator","any", "rayon.iter.ParallelIterator.any", t_bool);
|
|
CADD_FUNC("rayon.iter.ParallelIterator","all", "rayon.iter.ParallelIterator.all", t_bool);
|
|
CADD_FUNC("rayon.iter.IntoParallelIterator","into_par_iter","rayon.iter.IntoParallelIterator.into_par_iter", cbm_type_unknown());
|
|
|
|
CADD_FUNC(NULL, "scope", "rayon.scope", cbm_type_unknown());
|
|
CADD_FUNC(NULL, "par_iter", "rayon.par_iter", cbm_type_unknown());
|
|
CADD_FUNC(NULL, "spawn", "rayon.spawn", t_unit);
|
|
CADD_FUNC(NULL, "join", "rayon.join", cbm_type_unknown());
|
|
|
|
/* ── async-trait / async_trait — typically derive-only. ──
|
|
* Calls to trait methods are resolved through the normal trait
|
|
* dispatch since async_trait emits real Rust impl blocks. No
|
|
* extra registration needed. */
|
|
(void)t_str_ref;
|
|
}
|
|
|
|
#endif /* RUST_CRATES_SEED_INCLUDED */
|