wehub-resource-sync
1140 lines
72 KiB
C
1140 lines
72 KiB
C
/*
|
|
* cs_stdlib_data.c — corpus-seeded .NET BCL stdlib type/method data.
|
|
*
|
|
* Strategy:
|
|
* 1. Genuinely-stdlib base — System.Object root, primitives, collections,
|
|
* Task<T>, Linq Enumerable extensions.
|
|
* 2. Top corpus types: ASP.NET Core's Console + DI containers, JSON,
|
|
* logging, runtime intrinsics. We keep the surface deliberately
|
|
* narrow (≈300 types) to bias for false-negative miss rather than
|
|
* false-positive misroutes — the LSP can fall back to UNKNOWN safely
|
|
* but a wrong stdlib entry routes calls to the wrong target.
|
|
* 3. Linq extension methods registered with `param_names[0] = "this"`
|
|
* so cs_lookup_extension picks them up for any IEnumerable<T>.
|
|
*
|
|
* Type QNs use the dotted form Roslyn produces (System.Console,
|
|
* System.Collections.Generic.List, etc.). Receiver types match exactly so
|
|
* cs_lookup_method's primary index hits.
|
|
*/
|
|
|
|
#include "../type_rep.h"
|
|
#include "../type_registry.h"
|
|
#include "../../arena.h"
|
|
#include "../cs_lsp.h"
|
|
#include <string.h>
|
|
|
|
#define REG_TYPE(qn_, short_, is_iface_, parents_) \
|
|
do { \
|
|
memset(&rt, 0, sizeof(rt)); \
|
|
rt.qualified_name = (qn_); \
|
|
rt.short_name = (short_); \
|
|
rt.is_interface = (is_iface_); \
|
|
rt.embedded_types = (parents_); \
|
|
cbm_registry_add_type(reg, rt); \
|
|
} while (0)
|
|
|
|
/* Helper for single-parent inline registration. The macro avoids the
|
|
* preprocessor "comma in compound literal splits args" pitfall by taking
|
|
* the parent QN as a single string. */
|
|
#define REG_TYPE_P1(qn_, short_, is_iface_, p1_) \
|
|
do { \
|
|
static const char *_p_arr[] = {(p1_), NULL}; \
|
|
memset(&rt, 0, sizeof(rt)); \
|
|
rt.qualified_name = (qn_); \
|
|
rt.short_name = (short_); \
|
|
rt.is_interface = (is_iface_); \
|
|
rt.embedded_types = _p_arr; \
|
|
cbm_registry_add_type(reg, rt); \
|
|
} while (0)
|
|
|
|
#define REG_GENERIC_TYPE_P1(qn_, short_, is_iface_, p1_, tparams_) \
|
|
do { \
|
|
static const char *_pg_arr[] = {(p1_), NULL}; \
|
|
memset(&rt, 0, sizeof(rt)); \
|
|
rt.qualified_name = (qn_); \
|
|
rt.short_name = (short_); \
|
|
rt.is_interface = (is_iface_); \
|
|
rt.embedded_types = _pg_arr; \
|
|
rt.type_param_names = (tparams_); \
|
|
cbm_registry_add_type(reg, rt); \
|
|
} while (0)
|
|
|
|
#define REG_GENERIC_TYPE(qn_, short_, is_iface_, parents_, tparams_) \
|
|
do { \
|
|
memset(&rt, 0, sizeof(rt)); \
|
|
rt.qualified_name = (qn_); \
|
|
rt.short_name = (short_); \
|
|
rt.is_interface = (is_iface_); \
|
|
rt.embedded_types = (parents_); \
|
|
rt.type_param_names = (tparams_); \
|
|
cbm_registry_add_type(reg, rt); \
|
|
} while (0)
|
|
|
|
#define REG_METHOD(class_qn_, method_name_, ret_type_) \
|
|
do { \
|
|
memset(&rf, 0, sizeof(rf)); \
|
|
rf.min_params = -1; \
|
|
rf.qualified_name = \
|
|
cbm_arena_sprintf(arena, "%s.%s", (class_qn_), (method_name_)); \
|
|
rf.short_name = (method_name_); \
|
|
rf.receiver_type = (class_qn_); \
|
|
{ \
|
|
const CBMType **rets = \
|
|
(const CBMType **)cbm_arena_alloc(arena, 2 * sizeof(*rets)); \
|
|
rets[0] = (ret_type_); \
|
|
rets[1] = NULL; \
|
|
rf.signature = cbm_type_func(arena, NULL, NULL, rets); \
|
|
} \
|
|
cbm_registry_add_func(reg, rf); \
|
|
} while (0)
|
|
|
|
#define REG_STATIC(class_qn_, method_name_, ret_type_) \
|
|
do { \
|
|
memset(&rf, 0, sizeof(rf)); \
|
|
rf.min_params = -1; \
|
|
rf.qualified_name = \
|
|
cbm_arena_sprintf(arena, "%s.%s", (class_qn_), (method_name_)); \
|
|
rf.short_name = (method_name_); \
|
|
rf.receiver_type = (class_qn_); \
|
|
{ \
|
|
const CBMType **rets = \
|
|
(const CBMType **)cbm_arena_alloc(arena, 2 * sizeof(*rets)); \
|
|
rets[0] = (ret_type_); \
|
|
rets[1] = NULL; \
|
|
rf.signature = cbm_type_func(arena, NULL, NULL, rets); \
|
|
} \
|
|
cbm_registry_add_func(reg, rf); \
|
|
} while (0)
|
|
|
|
/* Extension method: register as a free static function whose first param's
|
|
* NAME is "this" — cs_lookup_extension dispatches on this convention. */
|
|
#define REG_EXTENSION(qn_, short_name_, recv_, ret_type_) \
|
|
do { \
|
|
memset(&rf, 0, sizeof(rf)); \
|
|
rf.min_params = -1; \
|
|
rf.qualified_name = (qn_); \
|
|
rf.short_name = (short_name_); \
|
|
{ \
|
|
const CBMType **rets = \
|
|
(const CBMType **)cbm_arena_alloc(arena, 2 * sizeof(*rets)); \
|
|
rets[0] = (ret_type_); \
|
|
rets[1] = NULL; \
|
|
const char **pnames = \
|
|
(const char **)cbm_arena_alloc(arena, 2 * sizeof(*pnames)); \
|
|
pnames[0] = "this"; \
|
|
pnames[1] = NULL; \
|
|
const CBMType **ptypes = \
|
|
(const CBMType **)cbm_arena_alloc(arena, 2 * sizeof(*ptypes)); \
|
|
ptypes[0] = (recv_); \
|
|
ptypes[1] = NULL; \
|
|
rf.signature = cbm_type_func(arena, pnames, ptypes, rets); \
|
|
} \
|
|
cbm_registry_add_func(reg, rf); \
|
|
} while (0)
|
|
|
|
#define OBJ() cbm_type_named(arena, "System.Object")
|
|
#define STR() cbm_type_named(arena, "System.String")
|
|
#define INT() cbm_type_named(arena, "System.Int32")
|
|
#define LONG_T() cbm_type_named(arena, "System.Int64")
|
|
#define BOOL_T() cbm_type_named(arena, "System.Boolean")
|
|
#define DBL() cbm_type_named(arena, "System.Double")
|
|
#define VOID_T() cbm_type_named(arena, "System.Void")
|
|
#define UNK() cbm_type_unknown()
|
|
|
|
void cbm_csharp_stdlib_register(CBMTypeRegistry *reg, CBMArena *arena) {
|
|
CBMRegisteredType rt;
|
|
CBMRegisteredFunc rf;
|
|
|
|
/* ── System root types ─────────────────────────────────────── */
|
|
static const char *no_parents[] = {NULL};
|
|
static const char *obj_parent[] = {"System.Object", NULL};
|
|
static const char *valuetype_parent[] = {"System.ValueType", NULL};
|
|
static const char *exception_parent[] = {"System.Exception", NULL};
|
|
static const char *runtime_exception_parent[] = {"System.SystemException", NULL};
|
|
|
|
REG_TYPE("System.Object", "Object", false, no_parents);
|
|
REG_TYPE("System.ValueType", "ValueType", false, obj_parent);
|
|
REG_TYPE("System.Enum", "Enum", false, valuetype_parent);
|
|
REG_TYPE("System.Type", "Type", false, obj_parent);
|
|
REG_TYPE("System.Void", "Void", false, valuetype_parent);
|
|
REG_TYPE("System.Delegate", "Delegate", false, obj_parent);
|
|
REG_TYPE("System.MulticastDelegate", "MulticastDelegate", false, no_parents);
|
|
REG_TYPE("System.IDisposable", "IDisposable", true, no_parents);
|
|
REG_TYPE("System.IComparable", "IComparable", true, no_parents);
|
|
REG_TYPE("System.IEquatable", "IEquatable", true, no_parents);
|
|
REG_TYPE("System.IFormattable", "IFormattable", true, no_parents);
|
|
|
|
/* Object methods. */
|
|
REG_METHOD("System.Object", "ToString", STR());
|
|
REG_METHOD("System.Object", "GetHashCode", INT());
|
|
REG_METHOD("System.Object", "Equals", BOOL_T());
|
|
REG_METHOD("System.Object", "GetType", cbm_type_named(arena, "System.Type"));
|
|
|
|
/* ── Primitive value types ─────────────────────────────────── */
|
|
REG_TYPE("System.Boolean", "Boolean", false, valuetype_parent);
|
|
REG_TYPE("System.Byte", "Byte", false, valuetype_parent);
|
|
REG_TYPE("System.SByte", "SByte", false, valuetype_parent);
|
|
REG_TYPE("System.Int16", "Int16", false, valuetype_parent);
|
|
REG_TYPE("System.UInt16", "UInt16", false, valuetype_parent);
|
|
REG_TYPE("System.Int32", "Int32", false, valuetype_parent);
|
|
REG_TYPE("System.UInt32", "UInt32", false, valuetype_parent);
|
|
REG_TYPE("System.Int64", "Int64", false, valuetype_parent);
|
|
REG_TYPE("System.UInt64", "UInt64", false, valuetype_parent);
|
|
REG_TYPE("System.Single", "Single", false, valuetype_parent);
|
|
REG_TYPE("System.Double", "Double", false, valuetype_parent);
|
|
REG_TYPE("System.Decimal", "Decimal", false, valuetype_parent);
|
|
REG_TYPE("System.Char", "Char", false, valuetype_parent);
|
|
REG_TYPE("System.IntPtr", "IntPtr", false, valuetype_parent);
|
|
REG_TYPE("System.UIntPtr", "UIntPtr", false, valuetype_parent);
|
|
|
|
/* Int32 / Int64 — common static methods. */
|
|
REG_STATIC("System.Int32", "Parse", INT());
|
|
REG_STATIC("System.Int32", "TryParse", BOOL_T());
|
|
REG_METHOD("System.Int32", "ToString", STR());
|
|
REG_METHOD("System.Int32", "CompareTo", INT());
|
|
REG_STATIC("System.Int64", "Parse", LONG_T());
|
|
REG_STATIC("System.Int64", "TryParse", BOOL_T());
|
|
REG_METHOD("System.Int64", "ToString", STR());
|
|
REG_STATIC("System.Double", "Parse", DBL());
|
|
REG_STATIC("System.Double", "TryParse", BOOL_T());
|
|
REG_METHOD("System.Double", "ToString", STR());
|
|
REG_STATIC("System.Boolean", "Parse", BOOL_T());
|
|
REG_STATIC("System.Boolean", "TryParse", BOOL_T());
|
|
|
|
/* ── System.String ─────────────────────────────────────────── */
|
|
REG_TYPE("System.String", "String", false, obj_parent);
|
|
REG_METHOD("System.String", "ToUpper", STR());
|
|
REG_METHOD("System.String", "ToLower", STR());
|
|
REG_METHOD("System.String", "ToUpperInvariant", STR());
|
|
REG_METHOD("System.String", "ToLowerInvariant", STR());
|
|
REG_METHOD("System.String", "Trim", STR());
|
|
REG_METHOD("System.String", "TrimStart", STR());
|
|
REG_METHOD("System.String", "TrimEnd", STR());
|
|
REG_METHOD("System.String", "Substring", STR());
|
|
REG_METHOD("System.String", "Replace", STR());
|
|
REG_METHOD("System.String", "Insert", STR());
|
|
REG_METHOD("System.String", "Remove", STR());
|
|
REG_METHOD("System.String", "PadLeft", STR());
|
|
REG_METHOD("System.String", "PadRight", STR());
|
|
REG_METHOD("System.String", "Split",
|
|
cbm_type_template(arena, "System.Array",
|
|
(const CBMType *[]){STR(), NULL}, 1));
|
|
REG_METHOD("System.String", "IndexOf", INT());
|
|
REG_METHOD("System.String", "LastIndexOf", INT());
|
|
REG_METHOD("System.String", "StartsWith", BOOL_T());
|
|
REG_METHOD("System.String", "EndsWith", BOOL_T());
|
|
REG_METHOD("System.String", "Contains", BOOL_T());
|
|
REG_METHOD("System.String", "Equals", BOOL_T());
|
|
REG_METHOD("System.String", "CompareTo", INT());
|
|
REG_METHOD("System.String", "GetEnumerator", UNK());
|
|
REG_METHOD("System.String", "Length", INT());
|
|
REG_METHOD("System.String", "ToCharArray",
|
|
cbm_type_template(arena, "System.Array",
|
|
(const CBMType *[]){cbm_type_named(arena, "System.Char"), NULL},
|
|
1));
|
|
REG_STATIC("System.String", "Format", STR());
|
|
REG_STATIC("System.String", "Concat", STR());
|
|
REG_STATIC("System.String", "Join", STR());
|
|
REG_STATIC("System.String", "IsNullOrEmpty", BOOL_T());
|
|
REG_STATIC("System.String", "IsNullOrWhiteSpace", BOOL_T());
|
|
REG_STATIC("System.String", "Compare", INT());
|
|
REG_STATIC("System.String", "Empty", STR());
|
|
REG_STATIC("System.String", "Equals", BOOL_T());
|
|
|
|
/* ── System.Console ─────────────────────────────────────────── */
|
|
REG_TYPE("System.Console", "Console", false, obj_parent);
|
|
REG_STATIC("System.Console", "WriteLine", VOID_T());
|
|
REG_STATIC("System.Console", "Write", VOID_T());
|
|
REG_STATIC("System.Console", "ReadLine", STR());
|
|
REG_STATIC("System.Console", "Read", INT());
|
|
REG_STATIC("System.Console", "ReadKey", UNK());
|
|
REG_STATIC("System.Console", "Beep", VOID_T());
|
|
REG_STATIC("System.Console", "Clear", VOID_T());
|
|
|
|
/* ── System.Math ───────────────────────────────────────────── */
|
|
REG_TYPE("System.Math", "Math", false, obj_parent);
|
|
REG_STATIC("System.Math", "Abs", DBL());
|
|
REG_STATIC("System.Math", "Min", DBL());
|
|
REG_STATIC("System.Math", "Max", DBL());
|
|
REG_STATIC("System.Math", "Pow", DBL());
|
|
REG_STATIC("System.Math", "Sqrt", DBL());
|
|
REG_STATIC("System.Math", "Round", DBL());
|
|
REG_STATIC("System.Math", "Floor", DBL());
|
|
REG_STATIC("System.Math", "Ceiling", DBL());
|
|
REG_STATIC("System.Math", "Sin", DBL());
|
|
REG_STATIC("System.Math", "Cos", DBL());
|
|
REG_STATIC("System.Math", "Tan", DBL());
|
|
REG_STATIC("System.Math", "Log", DBL());
|
|
REG_STATIC("System.Math", "Log10", DBL());
|
|
REG_STATIC("System.Math", "Exp", DBL());
|
|
REG_STATIC("System.Math", "PI", DBL());
|
|
REG_STATIC("System.Math", "E", DBL());
|
|
REG_STATIC("System.Math", "Sign", INT());
|
|
|
|
/* ── System.Convert ────────────────────────────────────────── */
|
|
REG_TYPE("System.Convert", "Convert", false, obj_parent);
|
|
REG_STATIC("System.Convert", "ToInt32", INT());
|
|
REG_STATIC("System.Convert", "ToInt64", LONG_T());
|
|
REG_STATIC("System.Convert", "ToString", STR());
|
|
REG_STATIC("System.Convert", "ToBoolean", BOOL_T());
|
|
REG_STATIC("System.Convert", "ToDouble", DBL());
|
|
REG_STATIC("System.Convert", "ToSingle", cbm_type_named(arena, "System.Single"));
|
|
REG_STATIC("System.Convert", "ChangeType", OBJ());
|
|
|
|
/* ── System.Guid ───────────────────────────────────────────── */
|
|
REG_TYPE("System.Guid", "Guid", false, valuetype_parent);
|
|
REG_STATIC("System.Guid", "NewGuid", cbm_type_named(arena, "System.Guid"));
|
|
REG_STATIC("System.Guid", "Parse", cbm_type_named(arena, "System.Guid"));
|
|
REG_STATIC("System.Guid", "TryParse", BOOL_T());
|
|
REG_METHOD("System.Guid", "ToString", STR());
|
|
|
|
/* ── System.DateTime ───────────────────────────────────────── */
|
|
REG_TYPE("System.DateTime", "DateTime", false, valuetype_parent);
|
|
REG_STATIC("System.DateTime", "Now", cbm_type_named(arena, "System.DateTime"));
|
|
REG_STATIC("System.DateTime", "UtcNow", cbm_type_named(arena, "System.DateTime"));
|
|
REG_STATIC("System.DateTime", "Today", cbm_type_named(arena, "System.DateTime"));
|
|
REG_STATIC("System.DateTime", "Parse", cbm_type_named(arena, "System.DateTime"));
|
|
REG_STATIC("System.DateTime", "TryParse", BOOL_T());
|
|
REG_METHOD("System.DateTime", "AddDays", cbm_type_named(arena, "System.DateTime"));
|
|
REG_METHOD("System.DateTime", "AddHours", cbm_type_named(arena, "System.DateTime"));
|
|
REG_METHOD("System.DateTime", "AddMinutes", cbm_type_named(arena, "System.DateTime"));
|
|
REG_METHOD("System.DateTime", "AddSeconds", cbm_type_named(arena, "System.DateTime"));
|
|
REG_METHOD("System.DateTime", "AddMilliseconds", cbm_type_named(arena, "System.DateTime"));
|
|
REG_METHOD("System.DateTime", "Subtract", cbm_type_named(arena, "System.TimeSpan"));
|
|
REG_METHOD("System.DateTime", "ToString", STR());
|
|
REG_METHOD("System.DateTime", "ToUniversalTime", cbm_type_named(arena, "System.DateTime"));
|
|
REG_METHOD("System.DateTime", "ToLocalTime", cbm_type_named(arena, "System.DateTime"));
|
|
REG_METHOD("System.DateTime", "Year", INT());
|
|
REG_METHOD("System.DateTime", "Month", INT());
|
|
REG_METHOD("System.DateTime", "Day", INT());
|
|
REG_METHOD("System.DateTime", "Hour", INT());
|
|
REG_METHOD("System.DateTime", "Minute", INT());
|
|
REG_METHOD("System.DateTime", "Second", INT());
|
|
REG_TYPE("System.TimeSpan", "TimeSpan", false, valuetype_parent);
|
|
REG_TYPE("System.DateTimeOffset", "DateTimeOffset", false, valuetype_parent);
|
|
REG_STATIC("System.DateTimeOffset", "Now", cbm_type_named(arena, "System.DateTimeOffset"));
|
|
REG_STATIC("System.DateTimeOffset", "UtcNow", cbm_type_named(arena, "System.DateTimeOffset"));
|
|
|
|
/* ── System.IO ─────────────────────────────────────────────── */
|
|
REG_TYPE("System.IO.File", "File", false, obj_parent);
|
|
REG_STATIC("System.IO.File", "ReadAllText", STR());
|
|
REG_STATIC("System.IO.File", "ReadAllLines",
|
|
cbm_type_template(arena, "System.Array",
|
|
(const CBMType *[]){STR(), NULL}, 1));
|
|
REG_STATIC("System.IO.File", "ReadAllBytes",
|
|
cbm_type_template(arena, "System.Array",
|
|
(const CBMType *[]){cbm_type_named(arena, "System.Byte"), NULL},
|
|
1));
|
|
REG_STATIC("System.IO.File", "WriteAllText", VOID_T());
|
|
REG_STATIC("System.IO.File", "WriteAllLines", VOID_T());
|
|
REG_STATIC("System.IO.File", "WriteAllBytes", VOID_T());
|
|
REG_STATIC("System.IO.File", "Exists", BOOL_T());
|
|
REG_STATIC("System.IO.File", "Delete", VOID_T());
|
|
REG_STATIC("System.IO.File", "Copy", VOID_T());
|
|
REG_STATIC("System.IO.File", "Move", VOID_T());
|
|
REG_STATIC("System.IO.File", "Open", cbm_type_named(arena, "System.IO.FileStream"));
|
|
REG_STATIC("System.IO.File", "OpenRead", cbm_type_named(arena, "System.IO.FileStream"));
|
|
REG_STATIC("System.IO.File", "OpenWrite", cbm_type_named(arena, "System.IO.FileStream"));
|
|
REG_STATIC("System.IO.File", "Create", cbm_type_named(arena, "System.IO.FileStream"));
|
|
REG_STATIC("System.IO.File", "ReadAllTextAsync",
|
|
cbm_type_template(arena, "System.Threading.Tasks.Task",
|
|
(const CBMType *[]){STR(), NULL}, 1));
|
|
REG_STATIC("System.IO.File", "WriteAllTextAsync",
|
|
cbm_type_named(arena, "System.Threading.Tasks.Task"));
|
|
REG_TYPE("System.IO.FileStream", "FileStream", false, obj_parent);
|
|
REG_METHOD("System.IO.FileStream", "Close", VOID_T());
|
|
REG_METHOD("System.IO.FileStream", "Read", INT());
|
|
REG_METHOD("System.IO.FileStream", "Write", VOID_T());
|
|
REG_METHOD("System.IO.FileStream", "Dispose", VOID_T());
|
|
REG_METHOD("System.IO.FileStream", "Flush", VOID_T());
|
|
|
|
REG_TYPE("System.IO.Path", "Path", false, obj_parent);
|
|
REG_STATIC("System.IO.Path", "Combine", STR());
|
|
REG_STATIC("System.IO.Path", "GetExtension", STR());
|
|
REG_STATIC("System.IO.Path", "GetFileName", STR());
|
|
REG_STATIC("System.IO.Path", "GetFileNameWithoutExtension", STR());
|
|
REG_STATIC("System.IO.Path", "GetDirectoryName", STR());
|
|
REG_STATIC("System.IO.Path", "GetFullPath", STR());
|
|
REG_STATIC("System.IO.Path", "GetTempPath", STR());
|
|
REG_STATIC("System.IO.Path", "GetTempFileName", STR());
|
|
REG_STATIC("System.IO.Path", "ChangeExtension", STR());
|
|
REG_STATIC("System.IO.Path", "Exists", BOOL_T());
|
|
|
|
REG_TYPE("System.IO.Directory", "Directory", false, obj_parent);
|
|
REG_STATIC("System.IO.Directory", "CreateDirectory",
|
|
cbm_type_named(arena, "System.IO.DirectoryInfo"));
|
|
REG_STATIC("System.IO.Directory", "Exists", BOOL_T());
|
|
REG_STATIC("System.IO.Directory", "Delete", VOID_T());
|
|
REG_STATIC("System.IO.Directory", "GetFiles",
|
|
cbm_type_template(arena, "System.Array",
|
|
(const CBMType *[]){STR(), NULL}, 1));
|
|
REG_STATIC("System.IO.Directory", "GetDirectories",
|
|
cbm_type_template(arena, "System.Array",
|
|
(const CBMType *[]){STR(), NULL}, 1));
|
|
REG_STATIC("System.IO.Directory", "EnumerateFiles",
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){STR(), NULL}, 1));
|
|
REG_TYPE("System.IO.DirectoryInfo", "DirectoryInfo", false, obj_parent);
|
|
|
|
/* ── System.Text ───────────────────────────────────────────── */
|
|
REG_TYPE("System.Text.StringBuilder", "StringBuilder", false, obj_parent);
|
|
REG_METHOD("System.Text.StringBuilder", "Append",
|
|
cbm_type_named(arena, "System.Text.StringBuilder"));
|
|
REG_METHOD("System.Text.StringBuilder", "AppendLine",
|
|
cbm_type_named(arena, "System.Text.StringBuilder"));
|
|
REG_METHOD("System.Text.StringBuilder", "AppendFormat",
|
|
cbm_type_named(arena, "System.Text.StringBuilder"));
|
|
REG_METHOD("System.Text.StringBuilder", "Clear",
|
|
cbm_type_named(arena, "System.Text.StringBuilder"));
|
|
REG_METHOD("System.Text.StringBuilder", "Insert",
|
|
cbm_type_named(arena, "System.Text.StringBuilder"));
|
|
REG_METHOD("System.Text.StringBuilder", "Replace",
|
|
cbm_type_named(arena, "System.Text.StringBuilder"));
|
|
REG_METHOD("System.Text.StringBuilder", "ToString", STR());
|
|
REG_METHOD("System.Text.StringBuilder", "Length", INT());
|
|
|
|
REG_TYPE("System.Text.Encoding", "Encoding", false, obj_parent);
|
|
REG_STATIC("System.Text.Encoding", "UTF8", cbm_type_named(arena, "System.Text.Encoding"));
|
|
REG_STATIC("System.Text.Encoding", "ASCII", cbm_type_named(arena, "System.Text.Encoding"));
|
|
REG_STATIC("System.Text.Encoding", "Unicode", cbm_type_named(arena, "System.Text.Encoding"));
|
|
REG_METHOD("System.Text.Encoding", "GetBytes",
|
|
cbm_type_template(arena, "System.Array",
|
|
(const CBMType *[]){cbm_type_named(arena, "System.Byte"), NULL},
|
|
1));
|
|
REG_METHOD("System.Text.Encoding", "GetString", STR());
|
|
|
|
REG_TYPE("System.Text.RegularExpressions.Regex", "Regex", false, obj_parent);
|
|
REG_STATIC("System.Text.RegularExpressions.Regex", "Match",
|
|
cbm_type_named(arena, "System.Text.RegularExpressions.Match"));
|
|
REG_STATIC("System.Text.RegularExpressions.Regex", "Matches",
|
|
cbm_type_named(arena, "System.Text.RegularExpressions.MatchCollection"));
|
|
REG_STATIC("System.Text.RegularExpressions.Regex", "IsMatch", BOOL_T());
|
|
REG_STATIC("System.Text.RegularExpressions.Regex", "Replace", STR());
|
|
REG_METHOD("System.Text.RegularExpressions.Regex", "Match",
|
|
cbm_type_named(arena, "System.Text.RegularExpressions.Match"));
|
|
REG_METHOD("System.Text.RegularExpressions.Regex", "Matches",
|
|
cbm_type_named(arena, "System.Text.RegularExpressions.MatchCollection"));
|
|
REG_METHOD("System.Text.RegularExpressions.Regex", "IsMatch", BOOL_T());
|
|
REG_METHOD("System.Text.RegularExpressions.Regex", "Replace", STR());
|
|
REG_TYPE("System.Text.RegularExpressions.Match", "Match", false, obj_parent);
|
|
REG_METHOD("System.Text.RegularExpressions.Match", "Success", BOOL_T());
|
|
REG_METHOD("System.Text.RegularExpressions.Match", "Value", STR());
|
|
REG_TYPE("System.Text.RegularExpressions.MatchCollection", "MatchCollection", false,
|
|
obj_parent);
|
|
|
|
/* ── System.Collections.Generic ────────────────────────────── */
|
|
static const char *list_t_params[] = {"T", NULL};
|
|
static const char *kv_t_params[] = {"TKey", "TValue", NULL};
|
|
static const char *single_t_params[] = {"T", NULL};
|
|
|
|
static const char *ienumerable_parents[] = {"System.Collections.IEnumerable", NULL};
|
|
REG_GENERIC_TYPE("System.Collections.Generic.IEnumerable", "IEnumerable", true,
|
|
ienumerable_parents, single_t_params);
|
|
REG_METHOD("System.Collections.Generic.IEnumerable", "GetEnumerator",
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerator",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL}, 1));
|
|
|
|
static const char *ienumerator_parents[] = {NULL};
|
|
REG_GENERIC_TYPE("System.Collections.Generic.IEnumerator", "IEnumerator", true,
|
|
ienumerator_parents, single_t_params);
|
|
REG_METHOD("System.Collections.Generic.IEnumerator", "MoveNext", BOOL_T());
|
|
REG_METHOD("System.Collections.Generic.IEnumerator", "Current",
|
|
cbm_type_type_param(arena, "T"));
|
|
REG_METHOD("System.Collections.Generic.IEnumerator", "Reset", VOID_T());
|
|
|
|
static const char *icollection_parents[] = {
|
|
"System.Collections.Generic.IEnumerable", NULL};
|
|
REG_GENERIC_TYPE("System.Collections.Generic.ICollection", "ICollection", true,
|
|
icollection_parents, single_t_params);
|
|
REG_METHOD("System.Collections.Generic.ICollection", "Add", VOID_T());
|
|
REG_METHOD("System.Collections.Generic.ICollection", "Remove", BOOL_T());
|
|
REG_METHOD("System.Collections.Generic.ICollection", "Clear", VOID_T());
|
|
REG_METHOD("System.Collections.Generic.ICollection", "Contains", BOOL_T());
|
|
REG_METHOD("System.Collections.Generic.ICollection", "Count", INT());
|
|
REG_METHOD("System.Collections.Generic.ICollection", "CopyTo", VOID_T());
|
|
|
|
static const char *ilist_parents[] = {"System.Collections.Generic.ICollection", NULL};
|
|
REG_GENERIC_TYPE("System.Collections.Generic.IList", "IList", true, ilist_parents,
|
|
single_t_params);
|
|
REG_METHOD("System.Collections.Generic.IList", "IndexOf", INT());
|
|
REG_METHOD("System.Collections.Generic.IList", "Insert", VOID_T());
|
|
REG_METHOD("System.Collections.Generic.IList", "RemoveAt", VOID_T());
|
|
|
|
static const char *list_parents[] = {"System.Collections.Generic.IList",
|
|
"System.Collections.Generic.ICollection",
|
|
"System.Collections.Generic.IEnumerable", NULL};
|
|
REG_GENERIC_TYPE("System.Collections.Generic.List", "List", false, list_parents,
|
|
list_t_params);
|
|
REG_METHOD("System.Collections.Generic.List", "Add", VOID_T());
|
|
REG_METHOD("System.Collections.Generic.List", "AddRange", VOID_T());
|
|
REG_METHOD("System.Collections.Generic.List", "Remove", BOOL_T());
|
|
REG_METHOD("System.Collections.Generic.List", "RemoveAt", VOID_T());
|
|
REG_METHOD("System.Collections.Generic.List", "RemoveAll", INT());
|
|
REG_METHOD("System.Collections.Generic.List", "Clear", VOID_T());
|
|
REG_METHOD("System.Collections.Generic.List", "Contains", BOOL_T());
|
|
REG_METHOD("System.Collections.Generic.List", "IndexOf", INT());
|
|
REG_METHOD("System.Collections.Generic.List", "Insert", VOID_T());
|
|
REG_METHOD("System.Collections.Generic.List", "Sort", VOID_T());
|
|
REG_METHOD("System.Collections.Generic.List", "Reverse", VOID_T());
|
|
REG_METHOD("System.Collections.Generic.List", "Find", cbm_type_type_param(arena, "T"));
|
|
REG_METHOD("System.Collections.Generic.List", "FindAll",
|
|
cbm_type_template(arena, "System.Collections.Generic.List",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL}, 1));
|
|
REG_METHOD("System.Collections.Generic.List", "FindIndex", INT());
|
|
REG_METHOD("System.Collections.Generic.List", "Count", INT());
|
|
REG_METHOD("System.Collections.Generic.List", "ToArray",
|
|
cbm_type_template(arena, "System.Array",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL}, 1));
|
|
REG_METHOD("System.Collections.Generic.List", "ForEach", VOID_T());
|
|
REG_METHOD("System.Collections.Generic.List", "ConvertAll",
|
|
cbm_type_template(arena, "System.Collections.Generic.List",
|
|
(const CBMType *[]){UNK(), NULL}, 1));
|
|
REG_METHOD("System.Collections.Generic.List", "GetEnumerator",
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerator",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL}, 1));
|
|
REG_METHOD("System.Collections.Generic.List", "GetRange",
|
|
cbm_type_template(arena, "System.Collections.Generic.List",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL}, 1));
|
|
|
|
static const char *idict_parents[] = {"System.Collections.Generic.ICollection", NULL};
|
|
REG_GENERIC_TYPE("System.Collections.Generic.IDictionary", "IDictionary", true,
|
|
idict_parents, kv_t_params);
|
|
REG_METHOD("System.Collections.Generic.IDictionary", "Add", VOID_T());
|
|
REG_METHOD("System.Collections.Generic.IDictionary", "Remove", BOOL_T());
|
|
REG_METHOD("System.Collections.Generic.IDictionary", "ContainsKey", BOOL_T());
|
|
REG_METHOD("System.Collections.Generic.IDictionary", "TryGetValue", BOOL_T());
|
|
REG_METHOD("System.Collections.Generic.IDictionary", "Keys",
|
|
cbm_type_template(arena, "System.Collections.Generic.ICollection",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "TKey"), NULL},
|
|
1));
|
|
REG_METHOD("System.Collections.Generic.IDictionary", "Values",
|
|
cbm_type_template(arena, "System.Collections.Generic.ICollection",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "TValue"), NULL},
|
|
1));
|
|
|
|
static const char *dict_parents[] = {"System.Collections.Generic.IDictionary",
|
|
"System.Collections.Generic.ICollection",
|
|
"System.Collections.Generic.IEnumerable", NULL};
|
|
REG_GENERIC_TYPE("System.Collections.Generic.Dictionary", "Dictionary", false,
|
|
dict_parents, kv_t_params);
|
|
REG_METHOD("System.Collections.Generic.Dictionary", "Add", VOID_T());
|
|
REG_METHOD("System.Collections.Generic.Dictionary", "Remove", BOOL_T());
|
|
REG_METHOD("System.Collections.Generic.Dictionary", "Clear", VOID_T());
|
|
REG_METHOD("System.Collections.Generic.Dictionary", "ContainsKey", BOOL_T());
|
|
REG_METHOD("System.Collections.Generic.Dictionary", "ContainsValue", BOOL_T());
|
|
REG_METHOD("System.Collections.Generic.Dictionary", "TryGetValue", BOOL_T());
|
|
REG_METHOD("System.Collections.Generic.Dictionary", "TryAdd", BOOL_T());
|
|
REG_METHOD("System.Collections.Generic.Dictionary", "GetEnumerator", UNK());
|
|
REG_METHOD("System.Collections.Generic.Dictionary", "Count", INT());
|
|
REG_METHOD("System.Collections.Generic.Dictionary", "Keys",
|
|
cbm_type_template(arena, "System.Collections.Generic.ICollection",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "TKey"), NULL},
|
|
1));
|
|
REG_METHOD("System.Collections.Generic.Dictionary", "Values",
|
|
cbm_type_template(arena, "System.Collections.Generic.ICollection",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "TValue"), NULL},
|
|
1));
|
|
|
|
static const char *hashset_parents[] = {"System.Collections.Generic.ICollection", NULL};
|
|
REG_GENERIC_TYPE("System.Collections.Generic.HashSet", "HashSet", false, hashset_parents,
|
|
single_t_params);
|
|
REG_METHOD("System.Collections.Generic.HashSet", "Add", BOOL_T());
|
|
REG_METHOD("System.Collections.Generic.HashSet", "Remove", BOOL_T());
|
|
REG_METHOD("System.Collections.Generic.HashSet", "Contains", BOOL_T());
|
|
REG_METHOD("System.Collections.Generic.HashSet", "Clear", VOID_T());
|
|
REG_METHOD("System.Collections.Generic.HashSet", "Count", INT());
|
|
REG_METHOD("System.Collections.Generic.HashSet", "UnionWith", VOID_T());
|
|
REG_METHOD("System.Collections.Generic.HashSet", "IntersectWith", VOID_T());
|
|
REG_METHOD("System.Collections.Generic.HashSet", "ExceptWith", VOID_T());
|
|
REG_METHOD("System.Collections.Generic.HashSet", "SymmetricExceptWith", VOID_T());
|
|
|
|
static const char *queue_parents[] = {"System.Collections.Generic.ICollection", NULL};
|
|
REG_GENERIC_TYPE("System.Collections.Generic.Queue", "Queue", false, queue_parents,
|
|
single_t_params);
|
|
REG_METHOD("System.Collections.Generic.Queue", "Enqueue", VOID_T());
|
|
REG_METHOD("System.Collections.Generic.Queue", "Dequeue", cbm_type_type_param(arena, "T"));
|
|
REG_METHOD("System.Collections.Generic.Queue", "Peek", cbm_type_type_param(arena, "T"));
|
|
REG_METHOD("System.Collections.Generic.Queue", "Count", INT());
|
|
|
|
static const char *stack_parents[] = {"System.Collections.Generic.ICollection", NULL};
|
|
REG_GENERIC_TYPE("System.Collections.Generic.Stack", "Stack", false, stack_parents,
|
|
single_t_params);
|
|
REG_METHOD("System.Collections.Generic.Stack", "Push", VOID_T());
|
|
REG_METHOD("System.Collections.Generic.Stack", "Pop", cbm_type_type_param(arena, "T"));
|
|
REG_METHOD("System.Collections.Generic.Stack", "Peek", cbm_type_type_param(arena, "T"));
|
|
REG_METHOD("System.Collections.Generic.Stack", "Count", INT());
|
|
|
|
static const char *kvp_parents[] = {NULL};
|
|
REG_GENERIC_TYPE("System.Collections.Generic.KeyValuePair", "KeyValuePair", false,
|
|
kvp_parents, kv_t_params);
|
|
REG_METHOD("System.Collections.Generic.KeyValuePair", "Key",
|
|
cbm_type_type_param(arena, "TKey"));
|
|
REG_METHOD("System.Collections.Generic.KeyValuePair", "Value",
|
|
cbm_type_type_param(arena, "TValue"));
|
|
|
|
/* Non-generic collections */
|
|
REG_TYPE("System.Collections.IEnumerable", "IEnumerable", true, no_parents);
|
|
REG_TYPE("System.Collections.IEnumerator", "IEnumerator", true, no_parents);
|
|
REG_TYPE_P1("System.Collections.ICollection", "ICollection", true,
|
|
"System.Collections.IEnumerable");
|
|
REG_TYPE_P1("System.Collections.IList", "IList", true,
|
|
"System.Collections.ICollection");
|
|
|
|
/* Array */
|
|
REG_TYPE("System.Array", "Array", false, obj_parent);
|
|
REG_METHOD("System.Array", "Length", INT());
|
|
REG_METHOD("System.Array", "GetLength", INT());
|
|
REG_METHOD("System.Array", "GetEnumerator", UNK());
|
|
REG_METHOD("System.Array", "GetValue", OBJ());
|
|
REG_METHOD("System.Array", "SetValue", VOID_T());
|
|
REG_METHOD("System.Array", "Clone", OBJ());
|
|
REG_STATIC("System.Array", "Sort", VOID_T());
|
|
REG_STATIC("System.Array", "Reverse", VOID_T());
|
|
REG_STATIC("System.Array", "IndexOf", INT());
|
|
REG_STATIC("System.Array", "Resize", VOID_T());
|
|
REG_STATIC("System.Array", "Empty", UNK());
|
|
|
|
/* Span / ReadOnlySpan */
|
|
static const char *span_parents[] = {NULL};
|
|
REG_GENERIC_TYPE("System.Span", "Span", false, span_parents, single_t_params);
|
|
REG_METHOD("System.Span", "Length", INT());
|
|
REG_METHOD("System.Span", "Slice",
|
|
cbm_type_template(arena, "System.Span",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL}, 1));
|
|
REG_METHOD("System.Span", "ToArray",
|
|
cbm_type_template(arena, "System.Array",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL}, 1));
|
|
REG_GENERIC_TYPE("System.ReadOnlySpan", "ReadOnlySpan", false, span_parents,
|
|
single_t_params);
|
|
REG_METHOD("System.ReadOnlySpan", "Length", INT());
|
|
REG_METHOD("System.ReadOnlySpan", "Slice",
|
|
cbm_type_template(arena, "System.ReadOnlySpan",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL}, 1));
|
|
|
|
REG_GENERIC_TYPE("System.Memory", "Memory", false, span_parents, single_t_params);
|
|
REG_GENERIC_TYPE("System.ReadOnlyMemory", "ReadOnlyMemory", false, span_parents,
|
|
single_t_params);
|
|
|
|
REG_GENERIC_TYPE("System.Nullable", "Nullable", false, valuetype_parent, single_t_params);
|
|
REG_METHOD("System.Nullable", "HasValue", BOOL_T());
|
|
REG_METHOD("System.Nullable", "Value", cbm_type_type_param(arena, "T"));
|
|
REG_METHOD("System.Nullable", "GetValueOrDefault", cbm_type_type_param(arena, "T"));
|
|
|
|
/* ── System.Threading.Tasks ────────────────────────────────── */
|
|
REG_TYPE("System.Threading.Tasks.Task", "Task", false, obj_parent);
|
|
REG_METHOD("System.Threading.Tasks.Task", "Wait", VOID_T());
|
|
REG_METHOD("System.Threading.Tasks.Task", "Result", UNK());
|
|
REG_METHOD("System.Threading.Tasks.Task", "ContinueWith",
|
|
cbm_type_named(arena, "System.Threading.Tasks.Task"));
|
|
REG_METHOD("System.Threading.Tasks.Task", "GetAwaiter", UNK());
|
|
REG_METHOD("System.Threading.Tasks.Task", "IsCompleted", BOOL_T());
|
|
REG_METHOD("System.Threading.Tasks.Task", "IsFaulted", BOOL_T());
|
|
REG_METHOD("System.Threading.Tasks.Task", "IsCanceled", BOOL_T());
|
|
REG_METHOD("System.Threading.Tasks.Task", "Status", UNK());
|
|
REG_METHOD("System.Threading.Tasks.Task", "Exception",
|
|
cbm_type_named(arena, "System.AggregateException"));
|
|
REG_METHOD("System.Threading.Tasks.Task", "Dispose", VOID_T());
|
|
REG_STATIC("System.Threading.Tasks.Task", "Run",
|
|
cbm_type_named(arena, "System.Threading.Tasks.Task"));
|
|
REG_STATIC("System.Threading.Tasks.Task", "Delay",
|
|
cbm_type_named(arena, "System.Threading.Tasks.Task"));
|
|
REG_STATIC("System.Threading.Tasks.Task", "WhenAll",
|
|
cbm_type_named(arena, "System.Threading.Tasks.Task"));
|
|
REG_STATIC("System.Threading.Tasks.Task", "WhenAny",
|
|
cbm_type_named(arena, "System.Threading.Tasks.Task"));
|
|
REG_STATIC("System.Threading.Tasks.Task", "FromResult",
|
|
cbm_type_named(arena, "System.Threading.Tasks.Task"));
|
|
REG_STATIC("System.Threading.Tasks.Task", "CompletedTask",
|
|
cbm_type_named(arena, "System.Threading.Tasks.Task"));
|
|
|
|
REG_GENERIC_TYPE_P1("System.Threading.Tasks.Task", "Task", false,
|
|
"System.Threading.Tasks.Task", single_t_params);
|
|
/* Same QN for generic — registry stores both. The Task<T>.Result uses
|
|
* type param T. */
|
|
|
|
REG_TYPE("System.Threading.Tasks.ValueTask", "ValueTask", false, obj_parent);
|
|
REG_GENERIC_TYPE_P1("System.Threading.Tasks.ValueTask", "ValueTask", false,
|
|
"System.Threading.Tasks.ValueTask", single_t_params);
|
|
|
|
REG_TYPE("System.Threading.CancellationToken", "CancellationToken", false, valuetype_parent);
|
|
REG_METHOD("System.Threading.CancellationToken", "IsCancellationRequested", BOOL_T());
|
|
REG_METHOD("System.Threading.CancellationToken", "ThrowIfCancellationRequested", VOID_T());
|
|
REG_METHOD("System.Threading.CancellationToken", "Register", UNK());
|
|
REG_TYPE("System.Threading.CancellationTokenSource", "CancellationTokenSource", false,
|
|
obj_parent);
|
|
REG_METHOD("System.Threading.CancellationTokenSource", "Token",
|
|
cbm_type_named(arena, "System.Threading.CancellationToken"));
|
|
REG_METHOD("System.Threading.CancellationTokenSource", "Cancel", VOID_T());
|
|
|
|
/* ── Exceptions ────────────────────────────────────────────── */
|
|
REG_TYPE("System.Exception", "Exception", false, obj_parent);
|
|
REG_METHOD("System.Exception", "Message", STR());
|
|
REG_METHOD("System.Exception", "StackTrace", STR());
|
|
REG_METHOD("System.Exception", "InnerException",
|
|
cbm_type_named(arena, "System.Exception"));
|
|
REG_METHOD("System.Exception", "ToString", STR());
|
|
REG_METHOD("System.Exception", "GetBaseException",
|
|
cbm_type_named(arena, "System.Exception"));
|
|
REG_METHOD("System.Exception", "Source", STR());
|
|
|
|
REG_TYPE("System.SystemException", "SystemException", false, exception_parent);
|
|
REG_TYPE("System.ApplicationException", "ApplicationException", false, exception_parent);
|
|
REG_TYPE("System.AggregateException", "AggregateException", false, exception_parent);
|
|
REG_TYPE("System.ArgumentException", "ArgumentException", false, runtime_exception_parent);
|
|
REG_TYPE_P1("System.ArgumentNullException", "ArgumentNullException", false,
|
|
"System.ArgumentException");
|
|
REG_TYPE_P1("System.ArgumentOutOfRangeException", "ArgumentOutOfRangeException", false,
|
|
"System.ArgumentException");
|
|
REG_TYPE("System.InvalidOperationException", "InvalidOperationException", false,
|
|
runtime_exception_parent);
|
|
REG_TYPE("System.NotImplementedException", "NotImplementedException", false,
|
|
runtime_exception_parent);
|
|
REG_TYPE("System.NotSupportedException", "NotSupportedException", false,
|
|
runtime_exception_parent);
|
|
REG_TYPE("System.NullReferenceException", "NullReferenceException", false,
|
|
runtime_exception_parent);
|
|
REG_TYPE("System.IndexOutOfRangeException", "IndexOutOfRangeException", false,
|
|
runtime_exception_parent);
|
|
REG_TYPE("System.OverflowException", "OverflowException", false, runtime_exception_parent);
|
|
REG_TYPE_P1("System.DivideByZeroException", "DivideByZeroException", false,
|
|
"System.ArithmeticException");
|
|
REG_TYPE("System.ArithmeticException", "ArithmeticException", false,
|
|
runtime_exception_parent);
|
|
REG_TYPE("System.FormatException", "FormatException", false, runtime_exception_parent);
|
|
REG_TYPE("System.IO.IOException", "IOException", false, runtime_exception_parent);
|
|
REG_TYPE_P1("System.IO.FileNotFoundException", "FileNotFoundException", false,
|
|
"System.IO.IOException");
|
|
REG_TYPE_P1("System.IO.DirectoryNotFoundException", "DirectoryNotFoundException", false,
|
|
"System.IO.IOException");
|
|
REG_TYPE("System.UnauthorizedAccessException", "UnauthorizedAccessException", false,
|
|
runtime_exception_parent);
|
|
REG_TYPE("System.OperationCanceledException", "OperationCanceledException", false,
|
|
runtime_exception_parent);
|
|
REG_TYPE_P1("System.TaskCanceledException", "TaskCanceledException", false,
|
|
"System.OperationCanceledException");
|
|
|
|
/* ── System.Linq.Enumerable extension methods ──────────────── */
|
|
/* These dispatch on IEnumerable<T> via the cs_lookup_extension path.
|
|
* We register them as free functions whose first param is named "this". */
|
|
REG_TYPE("System.Linq.Enumerable", "Enumerable", false, obj_parent);
|
|
REG_EXTENSION("System.Linq.Enumerable.Where", "Where",
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1),
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1));
|
|
REG_EXTENSION("System.Linq.Enumerable.Select", "Select",
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1),
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1));
|
|
REG_EXTENSION("System.Linq.Enumerable.SelectMany", "SelectMany",
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1),
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1));
|
|
REG_EXTENSION("System.Linq.Enumerable.First", "First",
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1),
|
|
cbm_type_type_param(arena, "T"));
|
|
REG_EXTENSION("System.Linq.Enumerable.FirstOrDefault", "FirstOrDefault",
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1),
|
|
cbm_type_type_param(arena, "T"));
|
|
REG_EXTENSION("System.Linq.Enumerable.Last", "Last",
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1),
|
|
cbm_type_type_param(arena, "T"));
|
|
REG_EXTENSION("System.Linq.Enumerable.LastOrDefault", "LastOrDefault",
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1),
|
|
cbm_type_type_param(arena, "T"));
|
|
REG_EXTENSION("System.Linq.Enumerable.Single", "Single",
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1),
|
|
cbm_type_type_param(arena, "T"));
|
|
REG_EXTENSION("System.Linq.Enumerable.SingleOrDefault", "SingleOrDefault",
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1),
|
|
cbm_type_type_param(arena, "T"));
|
|
REG_EXTENSION("System.Linq.Enumerable.Count", "Count",
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1),
|
|
INT());
|
|
REG_EXTENSION("System.Linq.Enumerable.Any", "Any",
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1),
|
|
BOOL_T());
|
|
REG_EXTENSION("System.Linq.Enumerable.All", "All",
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1),
|
|
BOOL_T());
|
|
REG_EXTENSION("System.Linq.Enumerable.Sum", "Sum",
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1),
|
|
DBL());
|
|
REG_EXTENSION("System.Linq.Enumerable.Average", "Average",
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1),
|
|
DBL());
|
|
REG_EXTENSION("System.Linq.Enumerable.Min", "Min",
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1),
|
|
cbm_type_type_param(arena, "T"));
|
|
REG_EXTENSION("System.Linq.Enumerable.Max", "Max",
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1),
|
|
cbm_type_type_param(arena, "T"));
|
|
REG_EXTENSION("System.Linq.Enumerable.OrderBy", "OrderBy",
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1),
|
|
cbm_type_template(arena, "System.Linq.IOrderedEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1));
|
|
REG_EXTENSION("System.Linq.Enumerable.OrderByDescending", "OrderByDescending",
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1),
|
|
cbm_type_template(arena, "System.Linq.IOrderedEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1));
|
|
REG_EXTENSION("System.Linq.Enumerable.GroupBy", "GroupBy",
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1),
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1));
|
|
REG_EXTENSION("System.Linq.Enumerable.Take", "Take",
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1),
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1));
|
|
REG_EXTENSION("System.Linq.Enumerable.Skip", "Skip",
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1),
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1));
|
|
REG_EXTENSION("System.Linq.Enumerable.ToList", "ToList",
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1),
|
|
cbm_type_template(arena, "System.Collections.Generic.List",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1));
|
|
REG_EXTENSION("System.Linq.Enumerable.ToArray", "ToArray",
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1),
|
|
cbm_type_template(arena, "System.Array",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1));
|
|
REG_EXTENSION("System.Linq.Enumerable.ToDictionary", "ToDictionary",
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1),
|
|
cbm_type_template(arena, "System.Collections.Generic.Dictionary",
|
|
(const CBMType *[]){UNK(), UNK(), NULL}, 2));
|
|
REG_EXTENSION("System.Linq.Enumerable.ToHashSet", "ToHashSet",
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1),
|
|
cbm_type_template(arena, "System.Collections.Generic.HashSet",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1));
|
|
REG_EXTENSION("System.Linq.Enumerable.Distinct", "Distinct",
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1),
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1));
|
|
REG_EXTENSION("System.Linq.Enumerable.Reverse", "Reverse",
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1),
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1));
|
|
REG_EXTENSION("System.Linq.Enumerable.Concat", "Concat",
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1),
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1));
|
|
REG_EXTENSION("System.Linq.Enumerable.Zip", "Zip",
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1),
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1));
|
|
REG_EXTENSION("System.Linq.Enumerable.Aggregate", "Aggregate",
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1),
|
|
cbm_type_type_param(arena, "T"));
|
|
REG_EXTENSION("System.Linq.Enumerable.Contains", "Contains",
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1),
|
|
BOOL_T());
|
|
REG_EXTENSION("System.Linq.Enumerable.ElementAt", "ElementAt",
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1),
|
|
cbm_type_type_param(arena, "T"));
|
|
REG_EXTENSION("System.Linq.Enumerable.ElementAtOrDefault", "ElementAtOrDefault",
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1),
|
|
cbm_type_type_param(arena, "T"));
|
|
REG_EXTENSION("System.Linq.Enumerable.Cast", "Cast",
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1),
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1));
|
|
REG_EXTENSION("System.Linq.Enumerable.OfType", "OfType",
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1),
|
|
cbm_type_template(arena, "System.Collections.Generic.IEnumerable",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL},
|
|
1));
|
|
|
|
/* ── System.Json (System.Text.Json) ────────────────────────── */
|
|
REG_TYPE("System.Text.Json.JsonSerializer", "JsonSerializer", false, obj_parent);
|
|
REG_STATIC("System.Text.Json.JsonSerializer", "Serialize", STR());
|
|
REG_STATIC("System.Text.Json.JsonSerializer", "SerializeAsync",
|
|
cbm_type_named(arena, "System.Threading.Tasks.Task"));
|
|
REG_STATIC("System.Text.Json.JsonSerializer", "Deserialize", OBJ());
|
|
REG_STATIC("System.Text.Json.JsonSerializer", "DeserializeAsync",
|
|
cbm_type_named(arena, "System.Threading.Tasks.Task"));
|
|
REG_TYPE("System.Text.Json.JsonDocument", "JsonDocument", false, obj_parent);
|
|
REG_STATIC("System.Text.Json.JsonDocument", "Parse",
|
|
cbm_type_named(arena, "System.Text.Json.JsonDocument"));
|
|
REG_TYPE("System.Text.Json.JsonElement", "JsonElement", false, valuetype_parent);
|
|
|
|
/* ── HTTP / networking ─────────────────────────────────────── */
|
|
REG_TYPE("System.Net.Http.HttpClient", "HttpClient", false, obj_parent);
|
|
REG_METHOD("System.Net.Http.HttpClient", "GetAsync",
|
|
cbm_type_named(arena, "System.Threading.Tasks.Task"));
|
|
REG_METHOD("System.Net.Http.HttpClient", "PostAsync",
|
|
cbm_type_named(arena, "System.Threading.Tasks.Task"));
|
|
REG_METHOD("System.Net.Http.HttpClient", "PutAsync",
|
|
cbm_type_named(arena, "System.Threading.Tasks.Task"));
|
|
REG_METHOD("System.Net.Http.HttpClient", "DeleteAsync",
|
|
cbm_type_named(arena, "System.Threading.Tasks.Task"));
|
|
REG_METHOD("System.Net.Http.HttpClient", "GetStringAsync",
|
|
cbm_type_template(arena, "System.Threading.Tasks.Task",
|
|
(const CBMType *[]){STR(), NULL}, 1));
|
|
REG_METHOD("System.Net.Http.HttpClient", "SendAsync",
|
|
cbm_type_named(arena, "System.Threading.Tasks.Task"));
|
|
REG_METHOD("System.Net.Http.HttpClient", "Dispose", VOID_T());
|
|
REG_TYPE("System.Net.Http.HttpResponseMessage", "HttpResponseMessage", false, obj_parent);
|
|
REG_METHOD("System.Net.Http.HttpResponseMessage", "EnsureSuccessStatusCode",
|
|
cbm_type_named(arena, "System.Net.Http.HttpResponseMessage"));
|
|
REG_METHOD("System.Net.Http.HttpResponseMessage", "IsSuccessStatusCode", BOOL_T());
|
|
REG_METHOD("System.Net.Http.HttpResponseMessage", "StatusCode", INT());
|
|
REG_METHOD("System.Net.Http.HttpResponseMessage", "Content",
|
|
cbm_type_named(arena, "System.Net.Http.HttpContent"));
|
|
REG_TYPE("System.Net.Http.HttpContent", "HttpContent", false, obj_parent);
|
|
REG_METHOD("System.Net.Http.HttpContent", "ReadAsStringAsync",
|
|
cbm_type_template(arena, "System.Threading.Tasks.Task",
|
|
(const CBMType *[]){STR(), NULL}, 1));
|
|
REG_METHOD("System.Net.Http.HttpContent", "ReadAsByteArrayAsync",
|
|
cbm_type_template(arena, "System.Threading.Tasks.Task",
|
|
(const CBMType *[]){UNK(), NULL}, 1));
|
|
REG_METHOD("System.Net.Http.HttpContent", "ReadAsStreamAsync",
|
|
cbm_type_template(arena, "System.Threading.Tasks.Task",
|
|
(const CBMType *[]){UNK(), NULL}, 1));
|
|
REG_TYPE("System.Net.Http.HttpRequestMessage", "HttpRequestMessage", false, obj_parent);
|
|
REG_TYPE_P1("System.Net.Http.StringContent", "StringContent", false,
|
|
"System.Net.Http.HttpContent");
|
|
|
|
/* ── Logging / DI (corpus-popular) ─────────────────────────── */
|
|
REG_TYPE("Microsoft.Extensions.Logging.ILogger", "ILogger", true, no_parents);
|
|
REG_METHOD("Microsoft.Extensions.Logging.ILogger", "Log", VOID_T());
|
|
REG_METHOD("Microsoft.Extensions.Logging.ILogger", "LogTrace", VOID_T());
|
|
REG_METHOD("Microsoft.Extensions.Logging.ILogger", "LogDebug", VOID_T());
|
|
REG_METHOD("Microsoft.Extensions.Logging.ILogger", "LogInformation", VOID_T());
|
|
REG_METHOD("Microsoft.Extensions.Logging.ILogger", "LogWarning", VOID_T());
|
|
REG_METHOD("Microsoft.Extensions.Logging.ILogger", "LogError", VOID_T());
|
|
REG_METHOD("Microsoft.Extensions.Logging.ILogger", "LogCritical", VOID_T());
|
|
REG_METHOD("Microsoft.Extensions.Logging.ILogger", "BeginScope",
|
|
cbm_type_named(arena, "System.IDisposable"));
|
|
REG_METHOD("Microsoft.Extensions.Logging.ILogger", "IsEnabled", BOOL_T());
|
|
|
|
REG_TYPE("Microsoft.Extensions.DependencyInjection.IServiceProvider", "IServiceProvider",
|
|
true, no_parents);
|
|
REG_METHOD("Microsoft.Extensions.DependencyInjection.IServiceProvider", "GetService", OBJ());
|
|
REG_TYPE("Microsoft.Extensions.DependencyInjection.IServiceCollection", "IServiceCollection",
|
|
true, no_parents);
|
|
|
|
/* ── ASP.NET Core (compact set) ─────────────────────────────── */
|
|
REG_TYPE("Microsoft.AspNetCore.Mvc.ControllerBase", "ControllerBase", false, obj_parent);
|
|
REG_METHOD("Microsoft.AspNetCore.Mvc.ControllerBase", "Ok",
|
|
cbm_type_named(arena, "Microsoft.AspNetCore.Mvc.OkObjectResult"));
|
|
REG_METHOD("Microsoft.AspNetCore.Mvc.ControllerBase", "NotFound",
|
|
cbm_type_named(arena, "Microsoft.AspNetCore.Mvc.NotFoundObjectResult"));
|
|
REG_METHOD("Microsoft.AspNetCore.Mvc.ControllerBase", "BadRequest",
|
|
cbm_type_named(arena, "Microsoft.AspNetCore.Mvc.BadRequestObjectResult"));
|
|
REG_METHOD("Microsoft.AspNetCore.Mvc.ControllerBase", "StatusCode",
|
|
cbm_type_named(arena, "Microsoft.AspNetCore.Mvc.IActionResult"));
|
|
REG_METHOD("Microsoft.AspNetCore.Mvc.ControllerBase", "Json",
|
|
cbm_type_named(arena, "Microsoft.AspNetCore.Mvc.JsonResult"));
|
|
REG_TYPE_P1("Microsoft.AspNetCore.Mvc.Controller", "Controller", false,
|
|
"Microsoft.AspNetCore.Mvc.ControllerBase");
|
|
REG_TYPE("Microsoft.AspNetCore.Mvc.OkObjectResult", "OkObjectResult", false, obj_parent);
|
|
REG_TYPE("Microsoft.AspNetCore.Mvc.NotFoundObjectResult", "NotFoundObjectResult", false,
|
|
obj_parent);
|
|
REG_TYPE("Microsoft.AspNetCore.Mvc.BadRequestObjectResult", "BadRequestObjectResult", false,
|
|
obj_parent);
|
|
REG_TYPE("Microsoft.AspNetCore.Mvc.IActionResult", "IActionResult", true, no_parents);
|
|
REG_TYPE("Microsoft.AspNetCore.Mvc.JsonResult", "JsonResult", false, obj_parent);
|
|
|
|
/* ── EF Core (compact set) ─────────────────────────────────── */
|
|
REG_TYPE("Microsoft.EntityFrameworkCore.DbContext", "DbContext", false, obj_parent);
|
|
REG_METHOD("Microsoft.EntityFrameworkCore.DbContext", "SaveChanges", INT());
|
|
REG_METHOD("Microsoft.EntityFrameworkCore.DbContext", "SaveChangesAsync",
|
|
cbm_type_template(arena, "System.Threading.Tasks.Task",
|
|
(const CBMType *[]){INT(), NULL}, 1));
|
|
REG_METHOD("Microsoft.EntityFrameworkCore.DbContext", "Set", UNK());
|
|
REG_METHOD("Microsoft.EntityFrameworkCore.DbContext", "Database", UNK());
|
|
REG_GENERIC_TYPE("Microsoft.EntityFrameworkCore.DbSet", "DbSet", false, obj_parent,
|
|
single_t_params);
|
|
REG_METHOD("Microsoft.EntityFrameworkCore.DbSet", "Add", UNK());
|
|
REG_METHOD("Microsoft.EntityFrameworkCore.DbSet", "Remove", UNK());
|
|
REG_METHOD("Microsoft.EntityFrameworkCore.DbSet", "Update", UNK());
|
|
REG_METHOD("Microsoft.EntityFrameworkCore.DbSet", "Find", cbm_type_type_param(arena, "T"));
|
|
REG_METHOD("Microsoft.EntityFrameworkCore.DbSet", "FindAsync",
|
|
cbm_type_template(arena, "System.Threading.Tasks.ValueTask",
|
|
(const CBMType *[]){cbm_type_type_param(arena, "T"), NULL}, 1));
|
|
|
|
/* ── Newtonsoft.Json (popular alternative) ─────────────────── */
|
|
REG_TYPE("Newtonsoft.Json.JsonConvert", "JsonConvert", false, obj_parent);
|
|
REG_STATIC("Newtonsoft.Json.JsonConvert", "SerializeObject", STR());
|
|
REG_STATIC("Newtonsoft.Json.JsonConvert", "DeserializeObject", OBJ());
|
|
|
|
/* ── Random / Guid / Lazy ──────────────────────────────────── */
|
|
REG_TYPE("System.Random", "Random", false, obj_parent);
|
|
REG_METHOD("System.Random", "Next", INT());
|
|
REG_METHOD("System.Random", "NextDouble", DBL());
|
|
REG_METHOD("System.Random", "NextBytes", VOID_T());
|
|
REG_GENERIC_TYPE("System.Lazy", "Lazy", false, obj_parent, single_t_params);
|
|
REG_METHOD("System.Lazy", "Value", cbm_type_type_param(arena, "T"));
|
|
REG_METHOD("System.Lazy", "IsValueCreated", BOOL_T());
|
|
|
|
/* ── System.Action / Func / Predicate ──────────────────────── */
|
|
REG_TYPE_P1("System.Action", "Action", false, "System.Delegate");
|
|
REG_GENERIC_TYPE_P1("System.Action", "Action", false,
|
|
"System.Delegate", single_t_params);
|
|
REG_METHOD("System.Action", "Invoke", VOID_T());
|
|
REG_GENERIC_TYPE_P1("System.Func", "Func", false,
|
|
"System.Delegate", single_t_params);
|
|
REG_METHOD("System.Func", "Invoke", cbm_type_type_param(arena, "T"));
|
|
REG_GENERIC_TYPE_P1("System.Predicate", "Predicate", false,
|
|
"System.Delegate", single_t_params);
|
|
REG_METHOD("System.Predicate", "Invoke", BOOL_T());
|
|
REG_GENERIC_TYPE_P1("System.Comparison", "Comparison", false,
|
|
"System.Delegate", single_t_params);
|
|
REG_METHOD("System.Comparison", "Invoke", INT());
|
|
REG_GENERIC_TYPE_P1("System.EventHandler", "EventHandler", false,
|
|
"System.Delegate", single_t_params);
|
|
|
|
/* ── System.Tuple / ValueTuple ─────────────────────────────── */
|
|
REG_GENERIC_TYPE("System.Tuple", "Tuple", false, obj_parent, single_t_params);
|
|
REG_METHOD("System.Tuple", "Item1", cbm_type_type_param(arena, "T"));
|
|
REG_GENERIC_TYPE("System.ValueTuple", "ValueTuple", false, valuetype_parent, single_t_params);
|
|
|
|
/* ── Misc commonly-used ────────────────────────────────────── */
|
|
REG_TYPE("System.Environment", "Environment", false, obj_parent);
|
|
REG_STATIC("System.Environment", "GetEnvironmentVariable", STR());
|
|
REG_STATIC("System.Environment", "SetEnvironmentVariable", VOID_T());
|
|
REG_STATIC("System.Environment", "Exit", VOID_T());
|
|
REG_STATIC("System.Environment", "GetFolderPath", STR());
|
|
REG_STATIC("System.Environment", "MachineName", STR());
|
|
REG_STATIC("System.Environment", "UserName", STR());
|
|
|
|
REG_TYPE("System.Diagnostics.Debug", "Debug", false, obj_parent);
|
|
REG_STATIC("System.Diagnostics.Debug", "WriteLine", VOID_T());
|
|
REG_STATIC("System.Diagnostics.Debug", "Assert", VOID_T());
|
|
REG_TYPE("System.Diagnostics.Trace", "Trace", false, obj_parent);
|
|
REG_STATIC("System.Diagnostics.Trace", "WriteLine", VOID_T());
|
|
|
|
REG_TYPE("System.Diagnostics.Stopwatch", "Stopwatch", false, obj_parent);
|
|
REG_STATIC("System.Diagnostics.Stopwatch", "StartNew",
|
|
cbm_type_named(arena, "System.Diagnostics.Stopwatch"));
|
|
REG_METHOD("System.Diagnostics.Stopwatch", "Start", VOID_T());
|
|
REG_METHOD("System.Diagnostics.Stopwatch", "Stop", VOID_T());
|
|
REG_METHOD("System.Diagnostics.Stopwatch", "Elapsed",
|
|
cbm_type_named(arena, "System.TimeSpan"));
|
|
REG_METHOD("System.Diagnostics.Stopwatch", "ElapsedMilliseconds", LONG_T());
|
|
|
|
/* xUnit (popular test framework, helpful for resolving test files) */
|
|
REG_TYPE("Xunit.Assert", "Assert", false, obj_parent);
|
|
REG_STATIC("Xunit.Assert", "Equal", VOID_T());
|
|
REG_STATIC("Xunit.Assert", "NotEqual", VOID_T());
|
|
REG_STATIC("Xunit.Assert", "True", VOID_T());
|
|
REG_STATIC("Xunit.Assert", "False", VOID_T());
|
|
REG_STATIC("Xunit.Assert", "Null", VOID_T());
|
|
REG_STATIC("Xunit.Assert", "NotNull", VOID_T());
|
|
REG_STATIC("Xunit.Assert", "Throws", UNK());
|
|
REG_STATIC("Xunit.Assert", "ThrowsAsync",
|
|
cbm_type_named(arena, "System.Threading.Tasks.Task"));
|
|
REG_STATIC("Xunit.Assert", "Contains", VOID_T());
|
|
REG_STATIC("Xunit.Assert", "DoesNotContain", VOID_T());
|
|
REG_STATIC("Xunit.Assert", "Empty", VOID_T());
|
|
REG_STATIC("Xunit.Assert", "NotEmpty", VOID_T());
|
|
REG_STATIC("Xunit.Assert", "Single", UNK());
|
|
REG_STATIC("Xunit.Assert", "Same", VOID_T());
|
|
REG_STATIC("Xunit.Assert", "NotSame", VOID_T());
|
|
REG_STATIC("Xunit.Assert", "IsType", UNK());
|
|
REG_STATIC("Xunit.Assert", "IsAssignableFrom", UNK());
|
|
|
|
/* NUnit */
|
|
REG_TYPE("NUnit.Framework.Assert", "Assert", false, obj_parent);
|
|
REG_STATIC("NUnit.Framework.Assert", "AreEqual", VOID_T());
|
|
REG_STATIC("NUnit.Framework.Assert", "IsTrue", VOID_T());
|
|
REG_STATIC("NUnit.Framework.Assert", "IsFalse", VOID_T());
|
|
REG_STATIC("NUnit.Framework.Assert", "IsNull", VOID_T());
|
|
REG_STATIC("NUnit.Framework.Assert", "IsNotNull", VOID_T());
|
|
REG_STATIC("NUnit.Framework.Assert", "Throws", UNK());
|
|
|
|
/* MSTest */
|
|
REG_TYPE("Microsoft.VisualStudio.TestTools.UnitTesting.Assert", "Assert", false, obj_parent);
|
|
REG_STATIC("Microsoft.VisualStudio.TestTools.UnitTesting.Assert", "AreEqual", VOID_T());
|
|
REG_STATIC("Microsoft.VisualStudio.TestTools.UnitTesting.Assert", "IsTrue", VOID_T());
|
|
REG_STATIC("Microsoft.VisualStudio.TestTools.UnitTesting.Assert", "IsFalse", VOID_T());
|
|
REG_STATIC("Microsoft.VisualStudio.TestTools.UnitTesting.Assert", "IsNull", VOID_T());
|
|
REG_STATIC("Microsoft.VisualStudio.TestTools.UnitTesting.Assert", "IsNotNull", VOID_T());
|
|
|
|
/* End */
|
|
}
|