Files
RobustToolbox/Robust.Shared/ContentPack/Sandbox.yml
Nyeogmi 6396ec472d XAML hot reloading (#5350)
* Move RobustXaml to a shared package

In a near-future change, I'll make it possible to optionally link to
this from Robust.Client, which will allow JIT compiling XAML.

Also upgrade it to a version of .NET that supports nullability
annotations.

* Re-namespace packages

* Add a JIT compiler, plus hooks that call into it

In Debug, after this change, all XAML will be hot reloaded once every
time an assembly is reloaded.

The new code is compiled with SRE and is _not_ sandboxed -- this is not
suitable to run against prod.

In Release, the hot reload path is totally skipped, using the same trick
as SmugLeaf used in an earlier attempt to implement this functionality.

* Hot reload: watcher

This is a bit of a horror, but there's not in-engine support for
identifying the source tree or the XAML files in it.

* Put everything dangerous behind conditional comp

* Code cleanup, docs

* Fix a bad comment

* Deal a little better with crashes in the watcher

* Make reload failures Info, since they're expected

They were previously causing the integration tests to flag, even though
"a few types fail hot reloading because they're internal" is expected
behavior.

* Fix an unnecessary null check

I removed the ability for CompileCore to return null.

* injectors: null! strings, default primitives

* Tidy documentation (thanks, PJB!)

* Reinstate netstandard2.0, abolish Pidgin

* Internal-ize all of Robust.Xaml

* Add a cautionary note to Sandbox.yml

* Shuffle around where conditional compilation occurs

* Privatize fields in XamlImplementationStorage

* Internalize XamlJitDelegate

* Inline some remarks. No cond. comp in Robust.Xaml

* Use file-scoped namespaces

They aren't allowed at Language Level 8.0. (which I arbitrarily picked
for Robust.Xaml because it's the oldest one that would work)

* Bump language level for R.Xaml, file namespaces

* Force hot reloading off for integration tests

* Fix bizarre comment/behavior in XamlImplementationStorage

* Consistently use interfaces, even in generated code

* Update Robust.Client/ClientIoC.cs

---------

Co-authored-by: Pieter-Jan Briers <pieterjan.briers@gmail.com>
2024-08-27 02:16:57 +02:00

1573 lines
68 KiB
YAML

# This file controls all whitelists and other rules enforced by AssemblyTypeChecker.
# Yes, I typed most of this out by hand.
# ILVerify errors that are allowed.
AllowedVerifierErrors:
# InitOnly happens a lot when calling e.g. ToString() on a readonly field.
# It's fine and doesn't break anything runtime related so...
- InitOnly
# ILVerify has problems with Default Interface Methods so...
- InterfaceMethodNotImplemented
# EVERYTHING in these namespaces is allowed.
# Note that, due to a historical bug in the sandbox, any namespace _prefixed_ with one of these
# is also allowed. (For instance, RobustBats.X, or ContentFarm.Y)
WhitelistedNamespaces:
- Robust
- Content
- OpenDreamShared
# The type whitelist does NOT care about which assembly types come from.
# This is because types switch assembly all the time.
# Just look up stuff like StreamReader on https://apisof.net.
# I figure this cannot be abused so long as we ensure content
# gets to load ONLY Content.Shared and Content.Client, no more.
# The whitelist is separated by namespace. Each namespace contains some types.
# A type definition has the following fields:
# All: bool -> If set, EVERYTHING on this type, including nested types, is whitelisted (except maybe inheritance).
# Inherit: Default/Allow/Block -> whether the type can be inherited.
# Default: Only if All is set to true
# Allow: Allowed
# Block: Disallowed even if All is set.
# Methods: List of methods that are allowed. See below for syntax.
# Fields: List of fields that are allowed. See below for syntax.
# NestedTypes: This again but for nested types.
# For type names in the whitelist, you DO NOT specify generic parameters.
# Generic types are compiled with a `n suffix, where n is the amount of generic parameters.
# So IEnumerable<T>'s ACTUAL name is IEnumerable`1.
# This is what you need to keep in mind.
# Type syntax in fields/methods is a mix of C#/ilasm. Quickly going over the rules:
# * C# primitive type names like 'int' or 'string are used, and MUST be used (can't use 'System.String').
# * You must manually specify the `n suffix on generic types, but still need to specify the generic arguments in <,>.
# * Nested types are parent/nested. For nested types of generics, you access it like this: List`1/Enumerator<int>
# * Use !n and !!n to specify generic type indexes on the type and method respectively.
# Field syntax: <type> <name>
# Method syntax: <type> <name>[generic param count](<type>, <type>, ...)
# For methods, you need to specify the amount of generic parameters (there's no `n suffix) with "empty angle brackets":
# int NoGeneric()
# int OneGeneric<>()
# int TwoGeneric<,>()
# There is no explicit syntax for properties. Properties compile to methods anyways.
# This is generally in the form of:
# <type> get_<propertyName>() - getter
# void set_<propertyName>(<type>) - setter
# <type> get_<indexerName>(<indexType>) - indexed property
# void set_<indexerName>(<indexType>, <type>) - indexed property
# Constructors are just methods with the name "void .ctor(<params>)".
# I think that's everything?
# Idk ask me if you can't figure it out yourself from looking at the 1k+ definitions in here already.
# Also you can use the "dmetamem" command on the client to dump the fields and methods of a type,
# in a format you can drop in here. So no need to manually type stuff over.
# You still have to split the fields and methods manually but I'm sure you're smart enough to do that yourself.
# Of course, I still expect you to do your due diligence to go over every member,
# even if they're more easy to dump in here.
# There are 4 reasons why an API might be missing here:
# * The API would simply allow you to break sandbox or such. e.g. File.Open().
# * It is a new API that has not been whitelisted yet.
# * The API is not *relevant* to content. e.g. System.Type.IsAnsiClass.
# * I am lazy these API lists are huge dude.
Types:
Avalonia.Metadata:
XmlnsDefinitionAttribute:
All: True
NetSerializer:
NetListAsArray`1:
Fields:
- "System.Collections.Generic.IReadOnlyCollection`1<!0> Value"
Methods:
- "bool get_HasContents()"
Lidgren.Network:
NetBuffer:
Methods:
- "byte[] get_Data()"
- "void set_Data(byte[])"
- "int get_LengthBytes()"
- "void set_LengthBytes(int)"
- "int get_LengthBits()"
- "void set_LengthBits(int)"
- "long get_Position()"
- "void set_Position(long)"
- "int get_PositionInBytes()"
- "byte[] PeekDataBuffer()"
- "bool PeekBoolean()"
- "byte PeekByte()"
- "sbyte PeekSByte()"
- "byte PeekByte(int)"
- "System.Span`1<byte> PeekBytes(System.Span`1<byte>)"
- "byte[] PeekBytes(int)"
- "void PeekBytes(byte[], int, int)"
- "short PeekInt16()"
- "ushort PeekUInt16()"
- "int PeekInt32()"
- "int PeekInt32(int)"
- "uint PeekUInt32()"
- "uint PeekUInt32(int)"
- "ulong PeekUInt64()"
- "long PeekInt64()"
- "ulong PeekUInt64(int)"
- "long PeekInt64(int)"
- "float PeekFloat()"
- "System.Half PeekHalf()"
- "float PeekSingle()"
- "double PeekDouble()"
- "string PeekString()"
- "int PeekStringSize()"
- "bool ReadBoolean()"
- "byte ReadByte()"
- "bool ReadByte(ref byte)"
- "sbyte ReadSByte()"
- "byte ReadByte(int)"
- "System.Span`1<byte> ReadBytes(System.Span`1<byte>)"
- "byte[] ReadBytes(int)"
- "bool ReadBytes(int, ref byte[])"
- "bool TryReadBytes(System.Span`1<byte>)"
- "void ReadBytes(byte[], int, int)"
- "void ReadBits(System.Span`1<byte>, int)"
- "void ReadBits(byte[], int, int)"
- "short ReadInt16()"
- "ushort ReadUInt16()"
- "int ReadInt32()"
- "bool ReadInt32(ref int)"
- "int ReadInt32(int)"
- "uint ReadUInt32()"
- "bool ReadUInt32(ref uint)"
- "uint ReadUInt32(int)"
- "ulong ReadUInt64()"
- "long ReadInt64()"
- "ulong ReadUInt64(int)"
- "long ReadInt64(int)"
- "float ReadFloat()"
- "System.Half ReadHalf()"
- "float ReadSingle()"
- "bool ReadSingle(ref float)"
- "double ReadDouble()"
- "uint ReadVariableUInt32()"
- "bool ReadVariableUInt32(ref uint)"
- "int ReadVariableInt32()"
- "long ReadVariableInt64()"
- "ulong ReadVariableUInt64()"
- "float ReadSignedSingle(int)"
- "float ReadUnitSingle(int)"
- "float ReadRangedSingle(float, float, int)"
- "int ReadRangedInteger(int, int)"
- "long ReadRangedInteger(long, long)"
- "string ReadString()"
- "bool ReadString(ref string)"
- "double ReadTime(Lidgren.Network.NetConnection, bool)"
- "System.Net.IPEndPoint ReadIPEndPoint()"
- "void SkipPadBits()"
- "void ReadPadBits()"
- "void SkipPadBits(int)"
- "void EnsureBufferSize(int)"
- "void Write(bool)"
- "void Write(byte)"
- "void WriteAt(int, byte)"
- "void Write(sbyte)"
- "void Write(byte, int)"
- "void Write(byte[])"
- "void Write(System.ReadOnlySpan`1<byte>)"
- "void Write(byte[], int, int)"
- "void Write(ushort)"
- "void WriteAt(int, ushort)"
- "void Write(ushort, int)"
- "void Write(short)"
- "void WriteAt(int, short)"
- "void Write(int)"
- "void WriteAt(int, int)"
- "void Write(uint)"
- "void WriteAt(int, uint)"
- "void Write(uint, int)"
- "void Write(int, int)"
- "void Write(ulong)"
- "void WriteAt(int, ulong)"
- "void Write(ulong, int)"
- "void Write(long)"
- "void Write(long, int)"
- "void Write(System.Half)"
- "void Write(float)"
- "void Write(double)"
- "int WriteVariableUInt32(uint)"
- "int WriteVariableInt32(int)"
- "int WriteVariableInt64(long)"
- "int WriteVariableUInt64(ulong)"
- "void WriteSignedSingle(float, int)"
- "void WriteUnitSingle(float, int)"
- "void WriteRangedSingle(float, float, float, int)"
- "int WriteRangedInteger(int, int, int)"
- "int WriteRangedInteger(long, long, long)"
- "void Write(string)"
- "void Write(System.Net.IPEndPoint)"
- "void WriteTime(bool)"
- "void WriteTime(double, bool)"
- "void WritePadBits()"
- "void WritePadBits(int)"
- "void Write(Lidgren.Network.NetBuffer)"
- "void Zero(int)"
- "void .ctor()"
NetDeliveryMethod: { }
NetIncomingMessage:
Methods:
- "Lidgren.Network.NetIncomingMessageType get_MessageType()"
- "Lidgren.Network.NetDeliveryMethod get_DeliveryMethod()"
- "int get_SequenceChannel()"
- "System.Net.IPEndPoint get_SenderEndPoint()"
- "Lidgren.Network.NetConnection get_SenderConnection()"
- "double get_ReceiveTime()"
- "double ReadTime(bool)"
- "string ToString()"
NetOutgoingMessage:
Methods:
- "string ToString()"
Nett:
CommentLocation: { } # Enum
Toml:
Methods:
- "Nett.TomlTable ReadString(string)"
TomlArray:
Methods:
- "int get_Length()"
- "Nett.Toml.TomlObject get_Item(int)"
- "Nett.Toml.TomlObject Last()"
- "Nett.Toml.TomlObject[] get_Items()"
TomlBool: { }
TomlComment:
Methods:
- "bool Equals(Nett.TomlComment)"
- "Nett.CommentLocation get_Location()"
- "string get_Text()"
- "void .ctor(string, Nett.CommentLocation)"
TomlDuration: { }
TomlFloat: { }
TomlInt:
Methods:
- "Nett.TomlInt/IntTypes get_IntType()"
NestedTypes:
TomlInt: { } # Enum
TomlLocalDate: { }
TomlLocalDateTime: { }
TomlLocalTime: { }
TomlObject:
Methods:
- "Nett.TomlObject AddComment(Nett.TomlComment)"
- "Nett.TomlObject AddComment(string, Nett.CommentLocation)"
- "Nett.TomlObject AddComments(System.Collections.Generic.IEnumerable`1<Nett.TomlComment>)"
- "Nett.TomlObjectType get_TomlType()"
- "string get_ReadableTypeName()"
- "System.Collections.Generic.IEnumerable`1<Nett.TomlComment> get_Comments()"
- "void ClearComments()"
TomlObjectType: { } # Enum
TomlOffsetDateTime: { }
TomlString: { }
TomlTable:
Methods:
- "bool Contains(System.Collections.Generic.KeyValuePair`2<string, Nett.TomlObject>)"
- "bool ContainsKey(string)"
- "bool Freeze()"
- "bool get_IsReadOnly()"
- "bool Remove(string)"
- "bool Remove(System.Collections.Generic.KeyValuePair`2<string, Nett.TomlObject>)"
- "bool TryGetValue(string, ref Nett.TomlObject)"
- "int get_Count()"
- "Nett.TomlObject Get(string)"
- "Nett.TomlObject get_Item(string)"
- "Nett.TomlObject TryGetValue(string)"
- "Nett.TomlTable/TableTypes get_TableType()"
- "System.Collections.Generic.Dictionary`2<string, object> ToDictionary()"
- "System.Collections.Generic.ICollection`1<Nett.TomlObject> get_Values()"
- "System.Collections.Generic.ICollection`1<string> get_Keys()"
- "System.Collections.Generic.IEnumerable`1<System.Collections.Generic.KeyValuePair`2<string, Nett.TomlObject>> get_Rows()"
- "System.Collections.Generic.IEnumerator`1<System.Collections.Generic.KeyValuePair`2<string, Nett.TomlObject>> GetEnumerator()"
- "void Clear()"
- "void set_Item(string, Nett.TomlObject)"
NestedTypes:
TableTypes: { }
TomlTableArray:
Methods:
- "int get_Count()"
- "Nett.TomlTable get_Item(int)"
- "Nett.TomlTable Last()"
- "System.Collections.Generic.List`1<Nett.TomlTable> get_Items()"
- "void Add(Nett.TomlTable)"
TomlValue:
Methods:
- "object get_UntypedValue()"
TomlValue`1:
Methods:
- "!0 get_Value()"
SixLabors.ImageSharp.Formats:
IImageEncoder: { All: True }
PixelTypeInfo: { All: True }
SixLabors.ImageSharp.PixelFormats:
A8: { All: True }
Argb32: { All: True }
Bgr24: { All: True }
Bgr565: { All: True }
Bgra32: { All: True }
Bgra4444: { All: True }
Bgra5551: { All: True }
Byte4: { All: True }
HalfSingle: { All: True }
HalfVector2: { All: True }
HalfVector4: { All: True }
IPixel: { All: True }
IPixel`1: { All: True }
L8: { All: True }
L16: { All: True }
La16: { All: True }
La32: { All: True }
NormalizedByte2: { All: True }
NormalizedByte4: { All: True }
NormalizedShort2: { All: True }
NormalizedShort4: { All: True }
Rg32: { All: True }
Rgb24: { All: True }
Rgb48: { All: True }
Rgba32: { All: True }
Rgba64: { All: True }
Rgba1010102: { All: True }
RgbaVector: { All: True }
Short2: { All: True }
Short4: { All: True }
SixLabors.ImageSharp:
Configuration:
Methods:
- "SixLabors.ImageSharp.Configuration get_Default()"
Image:
Methods:
- "int get_Height()"
- "int get_Width()"
- "SixLabors.ImageSharp.Formats.PixelTypeInfo get_PixelType()"
- "SixLabors.ImageSharp.Image`1<!!0> Load<>(System.IO.Stream)"
- "void Dispose()"
Image`1:
Methods:
- "SixLabors.ImageSharp.Image`1<!!0> CloneAs<>(SixLabors.ImageSharp.Configuration)"
- "SixLabors.ImageSharp.Image`1<!0> Clone()"
- "SixLabors.ImageSharp.Image`1<!0> Clone(SixLabors.ImageSharp.Configuration)"
- "void set_Item(int, int, !0)"
- "void .ctor(int, int)"
- "void .ctor(int, int, !0)"
- "void .ctor(SixLabors.ImageSharp.Configuration, int, int)"
- "void .ctor(SixLabors.ImageSharp.Configuration, int, int, !0)"
ImageExtensions:
Methods:
- "string ToBase64String(SixLabors.ImageSharp.Image, SixLabors.ImageSharp.Formats.IImageFormat)"
- "System.Threading.Tasks.Task SaveAsBmpAsync(SixLabors.ImageSharp.Image, System.IO.Stream, SixLabors.ImageSharp.Formats.Bmp.BmpEncoder, System.Threading.CancellationToken)"
- "System.Threading.Tasks.Task SaveAsBmpAsync(SixLabors.ImageSharp.Image, System.IO.Stream, System.Threading.CancellationToken)"
- "System.Threading.Tasks.Task SaveAsGifAsync(SixLabors.ImageSharp.Image, System.IO.Stream, SixLabors.ImageSharp.Formats.Gif.GifEncoder, System.Threading.CancellationToken)"
- "System.Threading.Tasks.Task SaveAsGifAsync(SixLabors.ImageSharp.Image, System.IO.Stream, System.Threading.CancellationToken)"
- "System.Threading.Tasks.Task SaveAsJpegAsync(SixLabors.ImageSharp.Image, System.IO.Stream, SixLabors.ImageSharp.Formats.Jpeg.JpegEncoder, System.Threading.CancellationToken)"
- "System.Threading.Tasks.Task SaveAsJpegAsync(SixLabors.ImageSharp.Image, System.IO.Stream, System.Threading.CancellationToken)"
- "System.Threading.Tasks.Task SaveAsPngAsync(SixLabors.ImageSharp.Image, System.IO.Stream, SixLabors.ImageSharp.Formats.Png.PngEncoder, System.Threading.CancellationToken)"
- "System.Threading.Tasks.Task SaveAsPngAsync(SixLabors.ImageSharp.Image, System.IO.Stream, System.Threading.CancellationToken)"
- "System.Threading.Tasks.Task SaveAsTgaAsync(SixLabors.ImageSharp.Image, System.IO.Stream, SixLabors.ImageSharp.Formats.Tga.TgaEncoder, System.Threading.CancellationToken)"
- "System.Threading.Tasks.Task SaveAsTgaAsync(SixLabors.ImageSharp.Image, System.IO.Stream, System.Threading.CancellationToken)"
- "System.Threading.Tasks.Task SaveAsync(SixLabors.ImageSharp.Image, System.IO.Stream, SixLabors.ImageSharp.Formats.IImageFormat, System.Threading.CancellationToken)"
- "void Save(SixLabors.ImageSharp.Image, System.IO.Stream, SixLabors.ImageSharp.Formats.IImageFormat)"
- "void SaveAsBmp(SixLabors.ImageSharp.Image, System.IO.Stream)"
- "void SaveAsBmp(SixLabors.ImageSharp.Image, System.IO.Stream, SixLabors.ImageSharp.Formats.Bmp.BmpEncoder)"
- "void SaveAsGif(SixLabors.ImageSharp.Image, System.IO.Stream)"
- "void SaveAsGif(SixLabors.ImageSharp.Image, System.IO.Stream, SixLabors.ImageSharp.Formats.Gif.GifEncoder)"
- "void SaveAsJpeg(SixLabors.ImageSharp.Image, System.IO.Stream)"
- "void SaveAsJpeg(SixLabors.ImageSharp.Image, System.IO.Stream, SixLabors.ImageSharp.Formats.Jpeg.JpegEncoder)"
- "void SaveAsPng(SixLabors.ImageSharp.Image, System.IO.Stream)"
- "void SaveAsPng(SixLabors.ImageSharp.Image, System.IO.Stream, SixLabors.ImageSharp.Formats.Png.PngEncoder)"
- "void SaveAsTga(SixLabors.ImageSharp.Image, System.IO.Stream)"
- "void SaveAsTga(SixLabors.ImageSharp.Image, System.IO.Stream, SixLabors.ImageSharp.Formats.Tga.TgaEncoder)"
Size: { All: True }
SizeF: { All: True }
System.Buffers:
SpanAction`2: { All: True }
System.Buffers.Binary:
BinaryPrimitives: { All: True }
System.Collections.Generic:
CollectionExtensions: { All: True }
Comparer`1: { All: True }
Dictionary`2: { All: True }
EqualityComparer`1: { All: True }
HashSet`1: { All: True }
IAsyncEnumerable`1: { All: True }
ICollection`1: { All: True }
IComparer`1: { All: True }
IDictionary`2: { All: True }
IEnumerable`1: { All: True }
IEnumerator`1: { All: True }
IEqualityComparer`1: { All: True }
IList`1: { All: True }
IReadOnlyCollection`1: { All: True }
IReadOnlyDictionary`2: { All: True }
IReadOnlyList`1: { All: True }
IReadOnlySet`1: { All: True }
ISet`1: { All: True }
KeyNotFoundException: { All: True }
KeyValuePair: { All: True } # Literally wtf is this class.
KeyValuePair`2: { All: True }
LinkedList`1: { All: True }
LinkedListNode`1: { All: True }
List`1: { All: True }
Queue`1: { All: True }
ReferenceEqualityComparer: { All: True }
SortedDictionary`2: { All: True }
SortedList`2: { All: True }
SortedSet`1: { All: True }
Stack`1: { All: True }
System.Collections.Frozen:
FrozenDictionary: { All: True }
FrozenSet: { All: True }
FrozenDictionary`2: { All: True }
FrozenSet`1: { All: True }
System.Collections.Immutable:
IImmutableDictionary`2: { All: True }
IImmutableList`1: { All: True }
IImmutableQueue`1: { All: True }
IImmutableSet`1: { All: True }
IImmutableStack`1: { All: True }
ImmutableArray: { All: True }
ImmutableArray`1: { All: True }
ImmutableDictionary: { All: True }
ImmutableDictionary`2: { All: True }
ImmutableHashSet: { All: True }
ImmutableHashSet`1: { All: True }
ImmutableInterlocked: { All: True }
ImmutableList: { All: True }
ImmutableList`1: { All: True }
ImmutableQueue: { All: True }
ImmutableQueue`1: { All: True }
ImmutableSortedDictionary: { All: True }
ImmutableSortedDictionary`2: { All: True }
ImmutableSortedSet: { All: True }
ImmutableSortedSet`1: { All: True }
ImmutableSortedStack: { All: True }
ImmutableSortedStack`1: { All: True }
System.Collections.Specialized:
NameValueCollection: { All: True }
System.Collections.Concurrent:
ConcurrentBag`1: { All: True }
ConcurrentDictionary`2: { All: True }
ConcurrentQueue`1: { All: True }
ConcurrentStack`1: { All: True }
System.Collections:
BitArray: { All: True }
ICollection: { All: True }
IEnumerable: { All: True }
IEnumerator: { All: True }
IList: { All: True }
System.ComponentModel:
CancelEventArgs: { All: True }
PropertyDescriptor: { }
ISite: { All: True }
IComponent: { All: True }
IContainer: { All: True }
ITypeDescriptorContext: { All: True }
System.Diagnostics.CodeAnalysis:
AllowNullAttribute: { All: True }
DisallowNullAttribute: { All: True }
DoesNotReturnAttribute: { All: True }
DoesNotReturnIfAttribute: { All: True }
ExcludeFromCodeCoverageAttribute: { All: True }
MaybeNullAttribute: { All: True }
MaybeNullWhenAttribute: { All: True }
MemberNotNullAttribute: { All: True }
MemberNotNullWhenAttribute: { All: True }
NotNullAttribute: { All: True }
NotNullIfNotNullAttribute: { All: True }
NotNullWhenAttribute: { All: True }
SuppressMessageAttribute: { All: True }
System.Diagnostics:
DebuggableAttribute: { All: True }
DebuggerBrowsableAttribute: { All: True }
DebuggerBrowsableState: { }
DebuggerDisplayAttribute: { All: True }
DebuggerHiddenAttribute: { All: True }
DebuggerNonUserCodeAttribute: { All: True }
DebuggerStepperBoundaryAttribute: { All: True }
DebuggerStepThroughAttribute: { All: True }
DebuggerTypeProxyAttribute: { All: True }
DebuggerVisualizerAttribute: { All: True }
Stopwatch: { All: True }
System.Globalization:
CompareOptions: { }
CultureInfo: { All: True }
DateTimeStyles: { All: True } # Enum
NumberFormatInfo: { All: True }
NumberStyles: { } # Enum
TextInfo:
Methods:
- "bool get_IsRightToLeft()"
- "char ToLower(char)"
- "char ToUpper(char)"
- "string get_ListSeparator()"
- "string ToLower(string)"
- "string ToTitleCase(string)"
- "string ToTitleCase(string)"
- "string ToUpper(string)"
System.IO.Compression:
CompressionMode: { } # Enum
CompressionLevel: { } # Enum
DeflateStream: { All: True }
ZipArchive: { All : True }
ZipArchiveEntry: { All : True }
ZipArchiveMode: { } # Enum
System.IO:
BinaryReader: { All: True }
FileAccess: { } # Enum
FileMode: { } # Enum
FileShare: { } # Enum
FileNotFoundException: { All: True }
InvalidDataException: { All: True }
IOException: { All: True }
MemoryStream: { All: True }
SeekOrigin: { } # Enum
Stream: { All: True }
StreamReader:
Fields:
- "System.IO.StreamReader Null"
Methods:
- "System.IO.Stream get_BaseStream()"
- "void .ctor(System.IO.Stream)"
- "void .ctor(System.IO.Stream, bool)"
- "void .ctor(System.IO.Stream, System.Text.Encoding)"
- "void .ctor(System.IO.Stream, System.Text.Encoding, bool)"
- "void .ctor(System.IO.Stream, System.Text.Encoding, bool, int)"
- "void .ctor(System.IO.Stream, System.Text.Encoding, bool, int, bool)"
StreamWriter:
Fields:
- "System.IO.StreamWriter Null"
Methods:
- "bool get_AutoFlush()"
- "System.IO.Stream get_BaseStream()"
- "void .ctor(System.IO.Stream)"
- "void .ctor(System.IO.Stream, System.Text.Encoding)"
- "void .ctor(System.IO.Stream, System.Text.Encoding, int)"
- "void .ctor(System.IO.Stream, System.Text.Encoding, int, bool)"
- "void DiscardBufferedData()"
TextReader: { All: True }
TextWriter: { All: True}
System.Linq.Expressions:
# TODO: Review
ConstantExpression: { }
Expression:
Methods:
- "System.Linq.Expressions.Expression`1<!!0> Lambda<>(System.Linq.Expressions.Expression, System.Linq.Expressions.ParameterExpression[])"
- "System.Linq.Expressions.MemberExpression Field(System.Linq.Expressions.Expression, System.Reflection.FieldInfo)"
- "System.Linq.Expressions.MemberExpression Property(System.Linq.Expressions.Expression, System.Reflection.MethodInfo)"
- "System.Linq.Expressions.ParameterExpression Parameter(System.Type)"
- "System.Linq.Expressions.ParameterExpression Parameter(System.Type, string)"
- "System.Linq.Expressions.ParameterExpression Variable(System.Type)"
- "System.Linq.Expressions.ParameterExpression Variable(System.Type, string)"
Expression`1: { }
MemberExpression: { }
ParameterExpression: { }
System.Linq:
Enumerable: { All: True }
IGrouping`2: { All: True }
IOrderedEnumerable`1: { All: True }
System.Net:
DnsEndPoint: { }
IPAddress: { All: True }
IPEndPoint: { All: True }
HttpStatusCode: { } # Enum
System.Net.Sockets:
AddressFamily: { }
System.Numerics:
BitOperations: { All: True }
Complex: { All: True }
Matrix3x2: { All: True }
Matrix4x4: { All: True }
Plane: { All: True }
Quaternion: { All: True }
Vector2: { All: True }
Vector3: { All: True }
Vector4: { All: True }
Matrix3x2: { All: True }
System.Reflection:
Assembly:
Methods:
- "string CreateQualifiedName(string, string)"
- "string get_FullName()"
- "System.Collections.Generic.IEnumerable`1<System.Reflection.TypeInfo> get_DefinedTypes()"
- "System.IO.Stream GetManifestResourceStream(string)"
- "System.IO.Stream GetManifestResourceStream(System.Type, string)"
- "System.Reflection.Assembly GetAssembly(System.Type)"
- "System.Reflection.Assembly GetExecutingAssembly()"
- "System.Type[] GetTypes()"
- "System.Reflection.AssemblyName GetName()"
AssemblyCompanyAttribute: { All: True }
AssemblyConfigurationAttribute: { All: True }
AssemblyFileVersionAttribute: { All: True }
AssemblyInformationalVersionAttribute: { All: True }
AssemblyName:
Methods:
- "string get_FullName()"
- "System.Version get_Version()"
- "string get_Name()"
AssemblyProductAttribute: { All: True }
AssemblyTitleAttribute: { All: True }
DefaultMemberAttribute: { All: True }
GenericParameterAttributes: { } # Enum
MemberFilter: { } # Delegate
MemberInfo:
Methods:
- "string get_Name()"
- "System.Reflection.MemberTypes get_MemberType()"
- "System.Type get_DeclaringType()"
MemberTypes: { } # Enum
MethodBase:
Methods:
- "System.Reflection.MethodBase GetMethodFromHandle(System.RuntimeMethodHandle)"
MethodInfo: { }
TypeAttributes: { } # Enum
TypeInfo: { }
System.Runtime.CompilerServices:
AsyncStateMachineAttribute: { All: True }
AsyncTaskMethodBuilder: { All: True }
AsyncTaskMethodBuilder`1: { All: True }
AsyncValueTaskMethodBuilder: { All: True }
AsyncValueTaskMethodBuilder`1: { All: True }
AsyncVoidMethodBuilder: { All: True }
CallerArgumentExpressionAttribute: { All: True }
CompilationRelaxationsAttribute: { All: True }
CompilerFeatureRequiredAttribute: { All: True }
CompilerGeneratedAttribute: { All: True }
DefaultInterpolatedStringHandler: { All: True }
ExtensionAttribute: { All: True }
IAsyncStateMachine: { All: True }
InternalsVisibleToAttribute: { All: True }
InterpolatedStringHandlerAttribute: { All: True }
InterpolatedStringHandlerArgumentAttribute: { All: True }
IsByRefLikeAttribute: { All: True }
IsExternalInit: { All: True }
IsReadOnlyAttribute: { All: True }
IsUnmanagedAttribute: { All: True }
IteratorStateMachineAttribute: { All: True }
NullableAttribute: { All: True }
NullableContextAttribute: { All: True }
PreserveBaseOverridesAttribute: { All: True }
RefSafetyRulesAttribute: { All: True }
RuntimeCompatibilityAttribute: { All: True }
RuntimeHelpers: { All: True }
TaskAwaiter: { All: True }
TaskAwaiter`1: { All: True }
TupleElementNamesAttribute: { All: True }
ValueTaskAwaiter: { All: True }
ValueTaskAwaiter`1: { All: True }
System.Runtime.ExceptionServices:
ExceptionDispatchInfo: { All: True }
System.Runtime.InteropServices:
CollectionsMarshal:
Methods:
- "System.Span`1<!!0> AsSpan<>(System.Collections.Generic.List`1<!!0>)"
InAttribute: { All: True }
UnmanagedType: { } # `unmanaged` constraint in C# modreqs with this.
System.Runtime.Versioning:
TargetFrameworkAttribute: { All: True }
System.Text.Json.Serialization:
JsonIgnoreAttribute: { All: True }
JsonPropertyNameAttribute: { All: True }
System.Text.RegularExpressions:
Capture: { All: True }
CaptureCollection: { All: True }
Group: { All: True }
GroupCollection: { All: True }
Match: { All: True }
MatchCollection: { All: True }
MatchEvaluator: { All: True } # Delegate
Regex:
Methods:
- "bool get_RightToLeft()"
- "bool IsMatch(string)"
- "bool IsMatch(string, int)"
- "bool IsMatch(string, string)"
- "bool IsMatch(string, string, System.Text.RegularExpressions.RegexOptions)"
- "bool IsMatch(string, string, System.Text.RegularExpressions.RegexOptions, System.TimeSpan)"
- "int GroupNumberFromName(string)"
- "int[] GetGroupNumbers()"
- "string Escape()"
- "string GroupNameFromNumber(int)"
- "string Replace(string, string)"
- "string Replace(string, string, int)"
- "string Replace(string, string, int, int)"
- "string Replace(string, string, string)"
- "string Replace(string, string, string, System.Text.RegularExpressions.RegexOptions)"
- "string Replace(string, string, string, System.Text.RegularExpressions.RegexOptions, System.TimeSpan)"
- "string Replace(string, string, System.Text.RegularExpressions.MatchEvaluator)"
- "string Replace(string, string, System.Text.RegularExpressions.MatchEvaluator, System.Text.RegularExpressions.RegexOptions)"
- "string Replace(string, string, System.Text.RegularExpressions.MatchEvaluator, System.Text.RegularExpressions.RegexOptions, System.TimeSpan)"
- "string Replace(string, System.Text.RegularExpressions.MatchEvaluator)"
- "string Replace(string, System.Text.RegularExpressions.MatchEvaluator, int)"
- "string Replace(string, System.Text.RegularExpressions.MatchEvaluator, int, int)"
- "string ToString()"
- "string Unescape(string)"
- "string[] GetGroupNames()"
- "string[] Split(string)"
- "string[] Split(string, int)"
- "string[] Split(string, int, int)"
- "string[] Split(string, string)"
- "string[] Split(string, string, System.Text.RegularExpressions.RegexOptions)"
- "string[] Split(string, string, System.Text.RegularExpressions.RegexOptions, System.TimeSpan)"
- "System.Text.RegularExpressions.Match Match(string)"
- "System.Text.RegularExpressions.Match Match(string, int)"
- "System.Text.RegularExpressions.Match Match(string, int, int)"
- "System.Text.RegularExpressions.Match Match(string, string)"
- "System.Text.RegularExpressions.Match Match(string, string, System.Text.RegularExpressions.RegexOptions)"
- "System.Text.RegularExpressions.Match Match(string, string, System.Text.RegularExpressions.RegexOptions, System.TimeSpan)"
- "System.Text.RegularExpressions.Match[] Matches(string)"
- "System.Text.RegularExpressions.Match[] Matches(string, int)"
- "System.Text.RegularExpressions.Match[] Matches(string, string)"
- "System.Text.RegularExpressions.Match[] Matches(string, string, System.Text.RegularExpressions.RegexOptions)"
- "System.Text.RegularExpressions.Match[] Matches(string, string, System.Text.RegularExpressions.RegexOptions, System.TimeSpan)"
- "System.Text.RegularExpressions.RegexOptions get_Options()"
- "System.TimeSpan get_MatchTimeout()"
- "void .ctor()"
- "void .ctor(string)"
- "void .ctor(string, System.Text.RegularExpressions.RegexOptions)"
- "void .ctor(string, System.Text.RegularExpressions.RegexOptions, System.TimeSpan)"
RegexMatchTimeoutException: { All: True }
RegexOptions: { } # Enum
RegexParseError: { }
RegexParseException: { All: True }
System.Text:
# TODO: Encoder/Decoder
Encoding:
Methods:
- "bool IsAlwaysNormalized()"
- "bool IsAlwaysNormalized(System.Text.NormalizationForm)"
- "byte[] Convert(System.Text.Encoding, System.Text.Encoding, byte[])"
- "byte[] Convert(System.Text.Encoding, System.Text.Encoding, byte[], int, int)"
- "byte[] GetBytes(char[])"
- "byte[] GetBytes(char[], int, int)"
- "byte[] GetBytes(string)"
- "byte[] GetBytes(string, int, int)"
- "byte[] GetPreamble()"
- "char[] GetChars(byte[])"
- "char[] GetChars(byte[], int, int)"
- "int GetByteCount(char[])"
- "int GetByteCount(char[], int, int)"
- "int GetByteCount(string)"
- "int GetByteCount(string, int, int)"
- "int GetByteCount(System.ReadOnlySpan`1<char>)"
- "int GetBytes(char[], int, int, byte[], int)"
- "int GetBytes(string, int, int, byte[], int)"
- "int GetBytes(System.ReadOnlySpan`1<char>, System.Span`1<byte>)"
- "int GetCharCount(byte[])"
- "int GetCharCount(byte[], int, int)"
- "int GetCharCount(System.ReadOnlySpan`1<byte>)"
- "int GetChars(byte[], int, int, char[], int)"
- "int GetChars(System.ReadOnlySpan`1<byte>, System.Span`1<char>)"
- "int GetMaxByteCount(int)"
- "int GetMaxCharCount(int)"
- "string GetString(byte[])"
- "string GetString(byte[], int, int)"
- "string GetString(System.ReadOnlySpan`1<byte>)"
- "System.Text.Decoder GetDecoder()"
- "System.Text.Encoder GetEncoder()"
- "System.Text.Encoding get_ASCII()"
- "System.Text.Encoding get_BigEndianUnicode()"
- "System.Text.Encoding get_Unicode()"
- "System.Text.Encoding get_UTF7()"
- "System.Text.Encoding get_UTF8()"
- "System.Text.Encoding get_UTF32()"
- "System.Text.Encoding GetEncoding(string)"
NormalizationForm: { } # Enum
Rune: { All: True }
StringBuilder:
Methods:
- "bool Equals(System.ReadOnlySpan`1<char>)"
- "bool Equals(System.Text.StringBuilder)"
- "char get_Chars(int)"
- "int EnsureCapacity(int)"
- "int get_Capacity()"
- "int get_Length()"
- "int get_MaxCapacity()"
- "string ToString()"
- "string ToString(int, int)"
- "System.Text.StringBuilder Append(bool)"
- "System.Text.StringBuilder Append(byte)"
- "System.Text.StringBuilder Append(char)"
- "System.Text.StringBuilder Append(char, int)"
- "System.Text.StringBuilder Append(char[])"
- "System.Text.StringBuilder Append(char[], int, int)"
- "System.Text.StringBuilder Append(double)"
- "System.Text.StringBuilder Append(int)"
- "System.Text.StringBuilder Append(long)"
- "System.Text.StringBuilder Append(object)"
- "System.Text.StringBuilder Append(sbyte)"
- "System.Text.StringBuilder Append(short)"
- "System.Text.StringBuilder Append(single)"
- "System.Text.StringBuilder Append(string)"
- "System.Text.StringBuilder Append(string, int, int)"
- "System.Text.StringBuilder Append(System.Decimal)"
- "System.Text.StringBuilder Append(System.ReadOnlyMemory`2<char>)"
- "System.Text.StringBuilder Append(System.ReadOnlySpan`2<char>)"
- "System.Text.StringBuilder Append(ref System.Text.StringBuilder/AppendInterpolatedStringHandler)"
- "System.Text.StringBuilder Append(System.Text.StringBuilder)"
- "System.Text.StringBuilder Append(System.Text.StringBuilder, int, int)"
- "System.Text.StringBuilder Append(uint)"
- "System.Text.StringBuilder Append(ulong)"
- "System.Text.StringBuilder Append(ushort)"
- "System.Text.StringBuilder AppendFormat(string, object)"
- "System.Text.StringBuilder AppendFormat(string, object, object)"
- "System.Text.StringBuilder AppendFormat(string, object, object, object)"
- "System.Text.StringBuilder AppendFormat(string, object[])"
- "System.Text.StringBuilder AppendFormat(System.IFormatProvider, string, object)"
- "System.Text.StringBuilder AppendFormat(System.IFormatProvider, string, object, object)"
- "System.Text.StringBuilder AppendFormat(System.IFormatProvider, string, object, object, object)"
- "System.Text.StringBuilder AppendFormat(System.IFormatProvider, string, object[])"
- "System.Text.StringBuilder AppendJoin(char, object[])"
- "System.Text.StringBuilder AppendJoin(char, string[])"
- "System.Text.StringBuilder AppendJoin(string, object[])"
- "System.Text.StringBuilder AppendJoin(string, string[])"
- "System.Text.StringBuilder AppendJoin<>(char, System.Collections.Generic.IEnumerable`1<!!0>)"
- "System.Text.StringBuilder AppendJoin<>(string, System.Collections.Generic.IEnumerable`1<!!0>)"
- "System.Text.StringBuilder AppendLine()"
- "System.Text.StringBuilder AppendLine(string)"
- "System.Text.StringBuilder Clear()"
- "System.Text.StringBuilder Insert(int, bool)"
- "System.Text.StringBuilder Insert(int, byte)"
- "System.Text.StringBuilder Insert(int, char)"
- "System.Text.StringBuilder Insert(int, char[])"
- "System.Text.StringBuilder Insert(int, char[], int, int)"
- "System.Text.StringBuilder Insert(int, double)"
- "System.Text.StringBuilder Insert(int, float)"
- "System.Text.StringBuilder Insert(int, int)"
- "System.Text.StringBuilder Insert(int, long)"
- "System.Text.StringBuilder Insert(int, object)"
- "System.Text.StringBuilder Insert(int, sbyte)"
- "System.Text.StringBuilder Insert(int, short)"
- "System.Text.StringBuilder Insert(int, string, int)"
- "System.Text.StringBuilder Insert(int, System.Decimal)"
- "System.Text.StringBuilder Insert(int, System.ReadOnlySpan`1<char>)"
- "System.Text.StringBuilder Insert(int, uint)"
- "System.Text.StringBuilder Insert(int, ulong)"
- "System.Text.StringBuilder Insert(int, ushort)"
- "System.Text.StringBuilder Remove(int, int)"
- "System.Text.StringBuilder Replace(char, char)"
- "System.Text.StringBuilder Replace(char, char, int, int)"
- "System.Text.StringBuilder Replace(string, string)"
- "System.Text.StringBuilder Replace(string, string, int, int)"
- "System.Text.StringBuilder/ChunkEnumerator GetChunks()"
- "void .ctor()"
- "void .ctor(int)"
- "void .ctor(int, int)"
- "void .ctor(string)"
- "void .ctor(string, int)"
- "void .ctor(string, int, int, int)"
- "void CopyTo(int, char[], int, int)"
- "void CopyTo(int, System.Span`1<char>, int)"
NestedTypes:
ChunkEnumerator: { All: True }
AppendInterpolatedStringHandler: { All: True }
StringRuneEnumerator: { All: True }
System.Text.Unicode:
UnicodeRange: { All: True }
UnicodeRanges: { All: True }
System.Threading.Tasks:
Task: { All: True }
Task`1: { All: True }
TaskCompletionSource: { All: True }
TaskCompletionSource`1: { All: True }
TaskCanceledException: { All: True }
ValueTask: { All: True }
ValueTask`1: { All: True }
System.Threading:
CancellationToken: { All: True }
CancellationTokenSource: { All: True }
Interlocked: { All: True }
Monitor: { All: True }
System.Web:
HttpUtility:
Methods:
- "System.Collections.Specialized.NameValueCollection ParseQueryString(string, System.Text.Encoding)"
- "System.Collections.Specialized.NameValueCollection ParseQueryString(string)"
- "string JavaScriptStringEncode(string)"
- "string UrlDecode(string, System.Text.Encoding)"
- "string UrlDecode(string)"
- "string UrlEncode(string, System.Text.Encoding)"
- "string UrlEncode(string)"
System:
IServiceProvider: { All: True }
Action: { All: True }
Action`1: { All: True }
Action`2: { All: True }
Action`3: { All: True }
Action`4: { All: True }
Action`5: { All: True }
Action`6: { All: True }
Action`7: { All: True }
Action`8: { All: True }
Action`9: { All: True }
Action`10: { All: True }
Action`11: { All: True }
Action`12: { All: True }
Action`13: { All: True }
Action`14: { All: True }
Action`15: { All: True }
Action`16: { All: True }
ArgumentException: { All: True }
ArgumentOutOfRangeException: { All: True }
Array:
Methods:
- "!!0 Find<>(!!0[], System.Predicate`1<!!0>)"
- "void Resize<>(ref !!0[], int)"
- "!!1 ConvertAll<,>(!!0[], System.Converter`2<!!0, !!1>)"
- "!!0[] Empty<>()"
- "!!0[] FindAll<>(!!0[], System.Predicate`1<!!0>)"
- "bool Exists<>(!!0[], System.Predicate`1<!!0>)"
- "bool get_IsFixedSize()"
- "bool get_IsReadOnly()"
- "bool get_IsSynchronized()"
- "bool TrueForAll<>(!!0[], System.Predicate`1<!!0>)"
- "int BinarySearch(System.Array, int, int, object)"
- "int BinarySearch(System.Array, int, int, object, System.Collections.IComparer)"
- "int BinarySearch(System.Array, object)"
- "int BinarySearch(System.Array, object, System.Collections.IComparer)"
- "int BinarySearch<>(!!0[], !!0[])"
- "int BinarySearch<>(!!0[], !!0[], System.Collections.IComparer)"
- "int BinarySearch<>(!!0[], int, int, !!0[])"
- "int BinarySearch<>(!!0[], int, int, !!0[], System.Collections.IComparer)"
- "int FindIndex<>(!!0[], int, int, System.Predicate`1<!!0>)"
- "int FindIndex<>(!!0[], int, System.Predicate`1<!!0>)"
- "int FindIndex<>(!!0[], System.Predicate`1<!!0>)"
- "int FindLastIndex<>(!!0[], int, int, System.Predicate`1<!!0>)"
- "int FindLastIndex<>(!!0[], int, System.Predicate`1<!!0>)"
- "int FindLastIndex<>(!!0[], System.Predicate`1<!!0>)"
- "int get_Length()"
- "int get_Rank()"
- "int GetLength(int)"
- "int GetLowerBound(int)"
- "int GetUpperBound(int)"
- "int IndexOf(System.Array, object)"
- "int IndexOf(System.Array, object, int)"
- "int IndexOf(System.Array, object, int, int)"
- "int IndexOf<>(!!0[], !!0)"
- "int IndexOf<>(!!0[], !!0, int)"
- "int IndexOf<>(!!0[], !!0, int, int)"
- "int LastIndexOf(System.Array, object)"
- "int LastIndexOf(System.Array, object, int)"
- "int LastIndexOf(System.Array, object, int, int)"
- "int LastIndexOf<>(!!0[], !!0)"
- "int LastIndexOf<>(!!0[], !!0, int)"
- "int LastIndexOf<>(!!0[], !!0, int, int)"
- "long get_LongLength()"
- "long GetLongLength(int)"
- "object Clone()"
- "object get_SyncRoot()"
- "object GetValue(int)"
- "object GetValue(int, int)"
- "object GetValue(int, int, int)"
- "object GetValue(int[])"
- "object GetValue(long)"
- "object GetValue(long, long)"
- "object GetValue(long, long, long)"
- "object GetValue(long[])"
- "System.Collections.IEnumerator GetEnumerator()"
- "System.Collections.ObjectModel.ReadOnlyCollection`1<!!0> AsReadOnly<>(!!0[])"
- "void Clear(System.Array)"
- "void Clear(System.Array, int, int)"
- "void ConstrainedCopy(System.Array, int, System.Array, int, int)"
- "void Copy(System.Array, int, System.Array, int, int)"
- "void Copy(System.Array, long, System.Array, long, long)"
- "void Copy(System.Array, System.Array, int)"
- "void Copy(System.Array, System.Array, long)"
- "void CopyTo(System.Array, int)"
- "void CopyTo(System.Array, long)"
- "void Fill<>(!!0[], !!0)"
- "void Fill<>(!!0[], !!0, int, int)"
- "void ForEach<>(!!0[], System.Action`1<!!0>)"
- "void Reverse(System.Array)"
- "void Reverse(System.Array, int, int)"
- "void Reverse<>(!!0[])"
- "void Reverse<>(!!0[], int, int)"
- "void SetValue(object, int)"
- "void SetValue(object, int, int)"
- "void SetValue(object, int, int, int)"
- "void SetValue(object, int[])"
- "void SetValue(object, long)"
- "void SetValue(object, long, long)"
- "void SetValue(object, long, long, long)"
- "void SetValue(object, long[])"
- "void Sort(System.Array)"
- "void Sort(System.Array, int, int)"
- "void Sort(System.Array, int, int, System.Collections.IComparer)"
- "void Sort(System.Array, System.Array)"
- "void Sort(System.Array, System.Array, int, int)"
- "void Sort(System.Array, System.Array, int, int, System.Collections.IComparer)"
- "void Sort(System.Array, System.Array, System.Collections.IComparer)"
- "void Sort(System.Array, System.Collections.IComparer)"
- "void Sort<,>(!!0[], !!1[])"
- "void Sort<,>(!!0[], !!1[], int, int)"
- "void Sort<,>(!!0[], !!1[], int, int, System.Collections.Generic.IComparer`1<!!0>)"
- "void Sort<,>(!!0[], !!1[], System.Collections.Generic.IComparer`1<!!0>)"
- "void Sort<>(!!0[])"
- "void Sort<>(!!0[], int, int)"
- "void Sort<>(!!0[], int, int, System.Collections.Generic.IComparer`1<!!0>)"
- "void Sort<>(!!0[], System.Collections.Generic.IComparer`1<!!0>)"
- "void Sort<>(!!0[], System.Collections.Generic.IComparer`1<!!0>)"
- "void Sort<>(!!0[], System.Comparison`1<!!0>)"
ArraySegment`1: { All: True }
AsyncCallback: { }
Attribute: { All: True }
AttributeTargets: { }
AttributeUsageAttribute: { All: True }
BitConverter: { All: True } # None of these APIs can do anything more complex than make funny looking NaNs and hex strings.
Base64FormattingOptions: { } # Enum
Boolean: { All: True }
Byte: { All: True }
Char: { All: True }
CharEnumerator: { All: True }
Comparison`1: { All: True }
Convert:
# All Type -> Type methods in this class are intentionally left out because they are insanely fucking stupid.
# Like yes, I want to do Convert.ToBoolean(DateTime) which LITERALLY ALWAYS THROWS.
# WHY ARE THESE A THING??
Fields:
- "object DBNull"
Methods:
- "System.TypeCode GetTypeCode(object)"
- "bool IsDBNull(object)"
- "string ToBase64String(byte[])"
- "string ToBase64String(byte[], System.Base64FormattingOptions)"
- "string ToBase64String(byte[], int, int)"
- "string ToBase64String(byte[], int, int, System.Base64FormattingOptions)"
- "string ToBase64String(System.ReadOnlySpan`1<byte>, System.Base64FormattingOptions)"
- "int ToBase64CharArray(byte[], int, int, char[], int)"
- "int ToBase64CharArray(byte[], int, int, char[], int, System.Base64FormattingOptions)"
- "bool TryToBase64Chars(System.ReadOnlySpan`1<byte>, System.Span`1<char>, ref int, System.Base64FormattingOptions)"
- "byte[] FromBase64String(string)"
- "bool TryFromBase64String(string, System.Span`1<byte>, ref int)"
- "bool TryFromBase64Chars(System.ReadOnlySpan`1<char>, System.Span`1<byte>, ref int)"
- "byte[] FromBase64CharArray(char[], int, int)"
- "byte[] FromHexString(string)"
- "byte[] FromHexString(System.ReadOnlySpan`1<char>)"
- "string ToHexString(byte[])"
- "string ToHexString(byte[], int, int)"
- "string ToHexString(System.ReadOnlySpan`1<byte>)"
Converter`2: { All: True } # Delegate
DateTime: { All: True }
DateTimeKind: { } # Enum
DateTimeOffset: { All: True }
Decimal: { All: True }
Delegate:
Methods:
- "System.Delegate Combine(System.Delegate, System.Delegate)"
- "System.Delegate Remove(System.Delegate, System.Delegate)"
DivideByZeroException: { All: True }
Double: { All: True }
Enum: { All: True}
Environment:
Methods:
- "int get_CurrentManagedThreadId()"
- "int get_ProcessorCount()"
- "string get_NewLine()"
- "string get_StackTrace()"
EventArgs: { All: True }
EventHandler: { All: True } # Delegate
EventHandler`1: { All: True } # Delagate
Exception: { All: True }
FlagsAttribute: { All: True }
Func`1: { All: True }
Func`2: { All: True }
Func`3: { All: True }
Func`4: { All: True }
Func`5: { All: True }
Func`6: { All: True }
Func`7: { All: True }
Func`8: { All: True }
Func`9: { All: True }
Func`10: { All: True }
Func`11: { All: True }
Func`12: { All: True }
Func`13: { All: True }
Func`14: { All: True }
Func`15: { All: True }
Func`16: { All: True }
Func`17: { All: True }
Guid: { All: True }
HashCode: { All: True }
IAsyncDisposable: { All: True }
IAsyncResult: { }
ICloneable: { All: True }
IComparable: { All: True }
IComparable`1: { All: True }
IDisposable: { All: True }
IEquatable`1:
Methods:
- "bool Equals(!0)"
IFormatProvider: { All: True }
IFormattable: { All: True }
Index: { All: True }
IndexOutOfRangeException: { All: True }
Int16: { All: True }
Int32: { All: True }
Int64: { All: True }
IntPtr: { All: True }
InvalidOperationException: { All: True }
Math: { All: True }
MathF: { All: True }
Memory`1:
Methods:
- "!0[] ToArray()"
- "bool Equals(object)"
- "bool Equals(System.Memory`1<!0>)"
- "bool get_IsEmpty()"
- "bool TryCopyTo(System.Memory`1<!0>)"
- "int get_Length()"
- "string ToString()"
- "System.Memory`1<!0> get_Empty()"
- "System.Memory`1<!0> op_Implicit(!0[])"
- "System.Memory`1<!0> op_Implicit(System.ArraySegment`1<!0>)"
- "System.Memory`1<!0> Slice(int)"
- "System.Memory`1<!0> Slice(int, int)"
- "System.ReadOnlyMemory`1<!0> op_Implicit(System.Memory`1<!0>)"
- "System.Span`1<!0> get_Span()"
- "void .ctor(!0[])"
- "void .ctor(!0[], int, int)"
- "void CopyTo(System.Memory`1<!0>)"
MemoryExtensions: { All: True}
MidpointRounding: { } # Enum
MulticastDelegate:
Inherit: Allow
NotImplementedException: { All: True }
NotSupportedException: { All: True }
Nullable: { All: True }
Nullable`1: { All: True }
NullReferenceException: { All: True }
Object: { All: True }
ObsoleteAttribute: { All: True }
OperationCanceledException: { All: True }
ParamArrayAttribute: { All: True }
Predicate`1: { All: True } # Delegate
Random: { All: True }
Range: { All: True }
ReadOnlyMemory`1:
Methods:
- "!0[] ToArray()"
- "bool Equals(object)"
- "bool Equals(System.ReadOnlyMemory`1<!0>)"
- "bool get_IsEmpty()"
- "bool TryCopyTo(System.Memory`1<!0>)"
- "int get_Length()"
- "string ToString()"
- "System.ReadOnlyMemory`1<!0> get_Empty()"
- "System.ReadOnlyMemory`1<!0> op_Implicit(!0[])"
- "System.ReadOnlyMemory`1<!0> op_Implicit(System.ArraySegment`1<!0>)"
- "System.ReadOnlyMemory`1<!0> Slice(int)"
- "System.ReadOnlyMemory`1<!0> Slice(int, int)"
- "System.ReadOnlySpan`1<!0> get_Span()"
- "void .ctor(!0[])"
- "void .ctor(!0[], int, int)"
- "void CopyTo(System.Memory`1<!0>)"
ReadOnlySpan`1:
Methods:
- "!0[] ToArray()"
- "bool get_IsEmpty()"
- "bool op_Equality(ReadOnlySystem.Span`1<!0>, ReadOnlySystem.Span`1<!0>)"
- "bool op_Inequality(System.ReadOnlySpan`1<!0>, System.ReadOnlySpan`1<!0>)"
- "bool TryCopyTo(System.Span`1<!0>)"
- "int get_Length()"
- "ref !0 get_Item(int)"
- "string ToString()"
- "System.ReadOnlySpan`1/Enumerator<!0> GetEnumerator()"
- "System.ReadOnlySpan`1<!0> get_Empty()"
- "System.ReadOnlySpan`1<!0> op_Implicit(!0[])"
- "System.ReadOnlySpan`1<!0> op_Implicit(System.ArraySegment`1<!0>)"
- "System.ReadOnlySpan`1<!0> Slice(int)"
- "System.ReadOnlySpan`1<!0> Slice(int, int)"
- "void .ctor(!0[])"
- "void .ctor(!0[], int, int)"
- "void Clear()"
- "void CopyTo(System.Span`1<!0>)"
- "void Fill(!0)"
NestedTypes:
Enumerator: { All: True }
Rune: { All: True }
RuntimeFieldHandle: { }
RuntimeMethodHandle: { }
RuntimeTypeHandle: { }
SByte: { All: True }
Single: { All: True }
Span`1:
Methods:
- "!0[] ToArray()"
- "bool get_IsEmpty()"
- "bool op_Equality(System.Span`1<!0>, System.Span`1<!0>)"
- "bool op_Inequality(System.Span`1<!0>, System.Span`1<!0>)"
- "bool TryCopyTo(System.Span`1<!0>)"
- "int get_Length()"
- "ref !0 get_Item(int)"
- "string ToString()"
- "System.ReadOnlySpan`1<!0> op_Implicit(System.Span`1<!0>)"
- "System.Span`1/Enumerator<!0> GetEnumerator()"
- "System.Span`1<!0> get_Empty()"
- "System.Span`1<!0> op_Implicit(!0[])"
- "System.Span`1<!0> op_Implicit(System.ArraySegment`1<!0>)"
- "System.Span`1<!0> Slice(int)"
- "System.Span`1<!0> Slice(int, int)"
- "void .ctor(!0[])"
- "void .ctor(!0[], int, int)"
- "void Clear()"
- "void CopyTo(System.Span`1<!0>)"
- "void Fill(!0)"
NestedTypes:
Enumerator: { All: True }
String:
Fields:
- "string Empty"
Methods:
- "bool Contains(char)"
- "bool Contains(char, System.StringComparison)"
- "bool Contains(string)"
- "bool Contains(string, System.StringComparison)"
- "bool EndsWith(char)"
- "bool EndsWith(string)"
- "bool EndsWith(string, bool, System.Globalization.CultureInfo)"
- "bool EndsWith(string, System.StringComparison)"
- "bool Equals(object)"
- "bool Equals(string)"
- "bool Equals(string, string)"
- "bool Equals(string, string, System.StringComparison)"
- "bool Equals(string, System.StringComparison)"
- "bool Equals(string, System.StringComparison)"
- "bool IsNormalized()"
- "bool IsNormalized(System.Text.NormalizationForm)"
- "bool IsNullOrEmpty(string)"
- "bool IsNullOrWhiteSpace(string)"
- "bool op_Equality(string, string)"
- "bool op_Inequality(string, string)"
- "bool StartsWith(char)"
- "bool StartsWith(string)"
- "bool StartsWith(string, bool, System.Globalization.CultureInfo)"
- "bool StartsWith(string, System.StringComparison)"
- "char get_Chars(int)"
- "char[] ToCharArray()"
- "char[] ToCharArray(int, int)"
- "int Compare(string, int, string, int, int)"
- "int Compare(string, int, string, int, int, bool)"
- "int Compare(string, int, string, int, int, bool, System.Globalization.CultureInfo)"
- "int Compare(string, int, string, int, int, bool, System.Globalization.CultureInfo, System.Globalization.CompareOptions)"
- "int Compare(string, int, string, int, int, System.StringComparison)"
- "int Compare(string, string)"
- "int Compare(string, string, bool)"
- "int Compare(string, string, bool, System.Globalization.CultureInfo)"
- "int Compare(string, string, bool, System.Globalization.CultureInfo, System.Globalization.CompareOptions)"
- "int Compare(string, string, System.StringComparison)"
- "int CompareOrdinal(string, int, string, int, int)"
- "int CompareOrdinal(string, string)"
- "int CompareTo(object)"
- "int CompareTo(string)"
- "int get_Length()"
- "int GetHashCode()"
- "int GetHashCode(System.ReadOnlySpan`1<char>)"
- "int GetHashCode(System.ReadOnlySpan`1<char>, System.StringComparison)"
- "int GetHashCode(System.StringComparison)"
- "int GetHashCode(System.StringComparison)"
- "int IndexOf(char)"
- "int IndexOf(char, int)"
- "int IndexOf(char, int, int)"
- "int IndexOf(char, System.StringComparison)"
- "int IndexOf(string)"
- "int IndexOf(string, int)"
- "int IndexOf(string, int, int)"
- "int IndexOf(string, int, int, System.StringComparison)"
- "int IndexOf(string, int, System.StringComparison)"
- "int IndexOf(string, System.StringComparison)"
- "int IndexOfAny(char[])"
- "int IndexOfAny(char[], int)"
- "int LastIndexOf(char)"
- "int LastIndexOf(char, int)"
- "int LastIndexOf(char, int, int)"
- "int LastIndexOf(string)"
- "int LastIndexOf(string, int)"
- "int LastIndexOf(string, int, int)"
- "int LastIndexOf(string, int, int, System.StringComparison)"
- "int LastIndexOf(string, int, System.StringComparison)"
- "int LastIndexOf(string, System.StringComparison)"
- "int LastIndexOfAny(char[])"
- "int LastIndexOfAny(char[], int)"
- "int LastIndexOfAny(char[], int, int)"
- "object Clone()"
- "string Concat(object)"
- "string Concat(object, object)"
- "string Concat(object, object, object)"
- "string Concat(object[])"
- "string Concat(string, string)"
- "string Concat(string, string, string)"
- "string Concat(string, string, string, string)"
- "string Concat(string[])"
- "string Concat<>(System.Collections.Generic.IEnumerable`1<!!0>)"
- "string Concat(System.Collections.Generic.IEnumerable`1<string>)"
- "string Concat(System.ReadOnlySpan`1<char>, System.ReadOnlySpan`1<char>)"
- "string Concat(System.ReadOnlySpan`1<char>, System.ReadOnlySpan`1<char>, System.ReadOnlySpan`1<char>)"
- "string Concat(System.ReadOnlySpan`1<char>, System.ReadOnlySpan`1<char>, System.ReadOnlySpan`1<char>, System.ReadOnlySpan`1<char>)"
- "string Create<>(int, !!0, System.Buffers.SpanAction`2<char, !!0>)"
- "string Format(string, object)"
- "string Format(string, object, object)"
- "string Format(string, object, object, object)"
- "string Format(string, object[])"
- "string Format(System.IFormatProvider, string, object)"
- "string Format(System.IFormatProvider, string, object, object)"
- "string Format(System.IFormatProvider, string, object, object, object)"
- "string Format(System.IFormatProvider, string, object[])"
- "string Insert(int, string)"
- "string Intern(string)"
- "string IsInterned(string)"
- "string Join(char, object[])"
- "string Join(char, string[])"
- "string Join(char, string[], int, int)"
- "string Join(string, object[])"
- "string Join(string, string[])"
- "string Join(string, string[], int, int)"
- "string Join(string, System.Collections.Generic.IEnumerable`1<string>)"
- "string Join<>(char, System.Collections.Generic.IEnumerable`1<!!0>)"
- "string Join<>(string, System.Collections.Generic.IEnumerable`1<!!0>)"
- "string Normalize()"
- "string Normalize(System.Text.NormalizationForm)"
- "string PadLeft(int)"
- "string PadLeft(int, char)"
- "string PadRight(int)"
- "string PadRight(int, char)"
- "string Remove(int)"
- "string Remove(int, int)"
- "string Replace(char, char)"
- "string Replace(string, string)"
- "string Replace(string, string, bool, System.Globalization.CultureInfo)"
- "string Replace(string, string, System.StringComparison)"
- "string Substring(int)"
- "string Substring(int, int)"
- "string ToLower()"
- "string ToLower(System.Globalization.CultureInfo)"
- "string ToLowerInvariant()"
- "string ToString()"
- "string ToString(System.IFormatProvider)"
- "string ToUpper()"
- "string ToUpper(System.Globalization.CultureInfo)"
- "string ToUpperInvariant()"
- "string Trim()"
- "string Trim(char)"
- "string Trim(char[])"
- "string TrimEnd()"
- "string TrimEnd(char)"
- "string TrimEnd(char[])"
- "string TrimStart()"
- "string TrimStart(char)"
- "string TrimStart(char[])"
- "string[] Split(char, int, System.StringSplitOptions)"
- "string[] Split(char, System.StringSplitOptions)"
- "string[] Split(char[])"
- "string[] Split(char[], int)"
- "string[] Split(char[], int, System.StringSplitOptions)"
- "string[] Split(char[], System.StringSplitOptions)"
- "string[] Split(string, int, System.StringSplitOptions)"
- "string[] Split(string, System.StringSplitOptions)"
- "string[] Split(string[], int, System.StringSplitOptions)"
- "string[] Split(string[], System.StringSplitOptions)"
- "System.Text.StringRuneEnumerator EnumerateRunes()"
- "System.CharEnumerator GetEnumerator()"
- "System.ReadOnlySpan`1<char> op_Implicit(string)"
- "System.TypeCode GetTypeCode()"
- "void .ctor(char, int)"
- "void .ctor(char[])"
- "void .ctor(char[], int, int)"
- "void .ctor(System.ReadOnlySpan`1<char>)"
- "void CopyTo(int, char[], int, int)"
StringComparison: { } # Enum
StringSplitOptions: { } # Enum
TimeSpan: { All: True }
Type:
# COM, marshalling, interop, etc... stuff omitted.
# Content should never touch that.
Methods:
- "bool Equals(object)"
- "bool Equals(System.Type)"
- "bool get_ContainsGenericParameters()"
- "bool get_HasElementType()"
- "bool get_IsAbstract()"
- "bool get_IsArray()"
- "bool get_IsByRef()"
- "bool get_IsByRefLike()"
- "bool get_IsClass()"
- "bool get_IsConstructedGenericType()"
- "bool get_IsEnum()"
- "bool get_IsGenericMethodParameter()"
- "bool get_IsGenericParameter()"
- "bool get_IsGenericType()"
- "bool get_IsGenericTypeDefinition()"
- "bool get_IsGenericTypeParameter()"
- "bool get_IsInterface()"
- "bool get_IsNested()"
- "bool get_IsNestedAssembly()"
- "bool get_IsNestedFamANDAssem()"
- "bool get_IsNestedFamily()"
- "bool get_IsNestedFamORAssem()"
- "bool get_IsNestedPrivate()"
- "bool get_IsNestedPublic()"
- "bool get_IsNotPublic()"
- "bool get_IsPointer()"
- "bool get_IsPrimitive()"
- "bool get_IsPublic()"
- "bool get_IsSealed()"
- "bool get_IsSerializable()"
- "bool get_IsSignatureType()"
- "bool get_IsSpecialName()"
- "bool get_IsSZArray()"
- "bool get_IsTypeDefinition()"
- "bool get_IsValueType()"
- "bool IsAssignableFrom(System.Type)"
- "bool IsAssignableTo(System.Type)"
- "bool IsInstanceOfType(object)"
- "bool IsSubclassOf(System.Type)"
- "bool op_Equality(System.Type, System.Type)"
- "bool op_Inequality(System.Type, System.Type)"
- "int get_GenericParameterPosition()"
- "int GetArrayRank()"
- "string get_AssemblyQualifiedName()"
- "string get_FullName()"
- "string get_Namespace()"
- "string GetEnumName(object)"
- "System.Array GetEnumValues()"
- "System.Guid get_GUID()"
- "System.Reflection.Assembly get_Assembly()"
- "System.Reflection.ConstructorInfo GetConstructor(System.Type[])"
- "System.Reflection.ConstructorInfo[] GetConstructors()"
- "System.Reflection.ConstructorInfo[] GetConstructors(System.Reflection.BindingFlags)"
- "System.Reflection.EventInfo GetEvent(string)"
- "System.Reflection.EventInfo GetEvent(string, System.Reflection.BindingFlags)"
- "System.Reflection.EventInfo[] GetEvents()"
- "System.Reflection.EventInfo[] GetEvents(System.Reflection.BindingFlags)"
- "System.Reflection.FieldInfo GetField(string)"
- "System.Reflection.FieldInfo GetField(string, System.Reflection.BindingFlags)"
- "System.Reflection.FieldInfo[] GetFields()"
- "System.Reflection.FieldInfo[] GetFields(System.Reflection.BindingFlags)"
- "System.Reflection.GenericParameterAttributes get_GenericParameterAttributes()"
- "System.Reflection.MemberInfo GetMember(string)"
- "System.Reflection.MemberInfo GetMember(string, System.Reflection.BindingFlags)"
- "System.Reflection.MemberInfo GetMember(string, System.Reflection.MemberTypes, System.Reflection.BindingFlags)"
- "System.Reflection.MemberInfo[] FindMembers(System.Reflection.MemberTypes, System.Reflection.BindingFlags, System.Reflection.MemberFilter, object)"
- "System.Reflection.MemberInfo[] GetMembers()"
- "System.Reflection.MemberInfo[] GetMembers(System.Reflection.BindingFlags)"
- "System.Reflection.MemberTypes get_MemberType()"
- "System.Reflection.MethodBase get_DeclaringMethod()"
- "System.Reflection.MethodInfo GetMethod(string)"
- "System.Reflection.MethodInfo GetMethod(string, int, System.Type[])"
- "System.Reflection.MethodInfo GetMethod(string, System.Reflection.BindingFlags)"
- "System.Reflection.MethodInfo GetMethod(string, System.Type[])"
- "System.Reflection.MethodInfo[] GetMethods()"
- "System.Reflection.MethodInfo[] GetMethods(System.Reflection.BindingFlags)"
- "System.Reflection.PropertyInfo GetProperty(string)"
- "System.Reflection.PropertyInfo GetProperty(string, System.Reflection.BindingFlags)"
- "System.Reflection.PropertyInfo GetProperty(string, System.Type)"
- "System.Reflection.PropertyInfo GetProperty(string, System.Type, System.Type[])"
- "System.Reflection.PropertyInfo GetProperty(string, System.Type[])"
- "System.Reflection.PropertyInfo[] GetProperties()"
- "System.Reflection.PropertyInfo[] GetProperties(System.Reflection.BindingFlags)"
- "System.Reflection.TypeAttributes get_Attributes()"
- "System.Type get_BaseType()"
- "System.Type get_DeclaringType()"
- "System.Type get_ReflectedType()"
- "System.Type GetElementType()"
- "System.Type GetEnumUnderlyingType()"
- "System.Type GetGenericTypeDefinition()"
- "System.Type GetInterface(string)"
- "System.Type GetInterface(string, bool)"
- "System.Type GetNestedType(string)"
- "System.Type GetNestedType(string, System.Reflection.BindingFlags)"
- "System.Type GetType(string)"
- "System.Type GetType(string, bool)"
- "System.Type GetType(string, bool, bool)"
- "System.Type GetTypeFromHandle(System.RuntimeTypeHandle)"
- "System.Type MakeArrayType()"
- "System.Type MakeArrayType(int)"
- "System.Type MakeByRefType()"
- "System.Type MakeGenericMethodParameter(int)"
- "System.Type MakeGenericType(System.Type[])"
- "System.Type[] FindInterfaces(System.Reflection.TypeFilter, object)"
- "System.Type[] get_GenericTypeArguments()"
- "System.Type[] GetGenericParameterConstraints()"
- "System.Type[] GetInterfaces()"
- "System.Type[] GetNestedTypes()"
- "System.Type[] GetNestedTypes(System.Reflection.BindingFlags)"
Fields:
- "System.Reflection.MemberFilter FilterAttribute"
- "System.Reflection.MemberFilter FilterName"
- "System.Reflection.MemberFilter FilterNameIgnoreCase"
- "object Missing"
- "char Delimiter"
- "System.Type[] EmptyTypes"
TypeCode: { } # Enum
UInt16: { All: True }
UInt32: { All: True }
UInt64: { All: True }
UIntPtr: { All: True }
Uri: { All: True }
ValueTuple: { All: True }
ValueTuple`1: { All: True }
ValueTuple`2: { All: True }
ValueTuple`3: { All: True }
ValueTuple`4: { All: True }
ValueTuple`5: { All: True }
ValueTuple`6: { All: True }
ValueTuple`7: { All: True }
ValueTuple`8: { All: True }
ValueType: { All: True }
Version: { All: True }
Void: { All: True }
YamlDotNet.Core.Events:
MappingStyle: { } # Enum
SequenceStyle: { } # Enum
YamlDotNet.Core:
Mark: { All: True }
ScalarStyle: { } # Enum
YamlDotNet.RepresentationModel:
IYamlVisitor: { All: True }
YamlDocument: { All: True }
YamlMappingNode:
Methods:
- "bool Equals(object)"
- "int GetHashCode()"
- "MappingStyle get_MappingStyle()"
- "System.Collections.Generic.IDictionary`2<YamlDotNet.RepresentationModel.YamlNode, YamlDotNet.RepresentationModel.YamlNode> get_Children()"
- "System.Collections.Generic.IEnumerator`1<System.Collections.Generic.KeyValuePair`2<YamlDotNet.RepresentationModel.YamlNode, YamlDotNet.RepresentationModel.YamlNode>> GetEnumerator()"
- "void .ctor()"
- "void .ctor(System.Collections.Generic.IEnumerable`1<System.Collections.Generic.KeyValuePair`2<YamlDotNet.RepresentationModel.YamlNode, YamlDotNet.RepresentationModel.YamlNode>>)"
- "void .ctor(System.Collections.Generic.IEnumerable`1<YamlDotNet.RepresentationModel.YamlNode>)"
- "void .ctor(System.Collections.Generic.KeyValuePair`2<YamlDotNet.RepresentationModel.YamlNode, YamlDotNet.RepresentationModel.YamlNode>[])"
- "void .ctor(YamlDotNet.RepresentationModel.YamlNode[])"
- "void Accept(YamlDotNet.RepresentationModel.IYamlVisitor)"
- "void Add(string, string)"
- "void Add(string, YamlDotNet.RepresentationModel.YamlNode)"
- "void Add(string, YamlDotNet.RepresentationModel.YamlNode)"
- "void Add(YamlDotNet.RepresentationModel.YamlNode, string)"
- "void Add(YamlDotNet.RepresentationModel.YamlNode, YamlDotNet.RepresentationModel.YamlNode)"
- "void set_MappingStyle(MappingStyle)"
- "YamlNodeType get_NodeType()"
YamlNode: { All: True }
YamlNodeIdentityEqualityComparer: { All: True } # Enum
YamlNodeType: { } # Enum
YamlScalarNode: { All: True }
YamlSequenceNode: { All: True }
YamlStream: { All: True }
YamlVisitorBase: { All: True }
Pidgin:
Unit: { All: True }
Parser: { All: True}
Parser`1: { All: True }
Parser`2: { All: True }
ParserExtensions:
# should be fine to do All: True, but this has some methods to read filestreams. So just in case this ever adds an extension method that directly opens a file:
Methods:
- "!!0 ParseOrThrow<>(Pidgin.Parser`2<char, !!0>, string, System.Func`3<char, Pidgin.SourcePos, Pidgin.SourcePos>)"
- "!!0 ParseOrThrow<>(Pidgin.Parser`2<char, !!0>, string, Pidgin.Configuration.IConfiguration`1<char>)"
SourcePos: { }
Pidgin.Configuration:
IConfiguration`1: { All: True }