Go-to-definition decompiler puts `throw null` in bodies of all members/properties for refs libraries.

[Krzysztof-Cieslak]

This happens on .Net Core / .Net Standard for any symbol which definition is added through reference library (for example netstandard.dll or System.Runtime).

Sample for float:

using System.Globalization;

namespace System
{
    public struct Double : IComparable, IComparable<double>, IConvertible, IEquatable<double>, IFormattable
    {
        public const double Epsilon = 4.94065645841247E-324;

        public const double MaxValue = 1.7976931348623157E+308;

        public const double MinValue = -1.7976931348623157E+308;

        public const double NaN = 0.0 / 0.0;

        public const double NegativeInfinity = -1.0 / 0.0;

        public const double PositiveInfinity = 1.0 / 0.0;

        public int CompareTo(double value)
        {
            throw null;
        }

        public int CompareTo(object value)
        {
            throw null;
        }

        public bool Equals(double obj)
        {
            throw null;
        }

        public override bool Equals(object obj)
        {
            throw null;
        }

        public override int GetHashCode()
        {
            throw null;
        }

        public TypeCode GetTypeCode()
        {
            throw null;
        }

        public static bool IsInfinity(double d)
        {
            throw null;
        }

        public static bool IsNaN(double d)
        {
            throw null;
        }

        public static bool IsNegativeInfinity(double d)
        {
            throw null;
        }

        public static bool IsPositiveInfinity(double d)
        {
            throw null;
        }

        public static bool operator ==(double left, double right)
        {
            throw null;
        }

        public static bool operator >(double left, double right)
        {
            throw null;
        }

        public static bool operator >=(double left, double right)
        {
            throw null;
        }

        public static bool operator !=(double left, double right)
        {
            throw null;
        }

        public static bool operator <(double left, double right)
        {
            throw null;
        }

        public static bool operator <=(double left, double right)
        {
            throw null;
        }

        public static double Parse(string s)
        {
            throw null;
        }

        public static double Parse(string s, NumberStyles style)
        {
            throw null;
        }

        public static double Parse(string s, NumberStyles style, IFormatProvider provider)
        {
            throw null;
        }

        public static double Parse(string s, IFormatProvider provider)
        {
            throw null;
        }

        bool IConvertible.ToBoolean(IFormatProvider provider)
        {
            throw null;
        }

        byte IConvertible.ToByte(IFormatProvider provider)
        {
            throw null;
        }

        char IConvertible.ToChar(IFormatProvider provider)
        {
            throw null;
        }

        DateTime IConvertible.ToDateTime(IFormatProvider provider)
        {
            throw null;
        }

        decimal IConvertible.ToDecimal(IFormatProvider provider)
        {
            throw null;
        }

        double IConvertible.ToDouble(IFormatProvider provider)
        {
            throw null;
        }

        short IConvertible.ToInt16(IFormatProvider provider)
        {
            throw null;
        }

        int IConvertible.ToInt32(IFormatProvider provider)
        {
            throw null;
        }

        long IConvertible.ToInt64(IFormatProvider provider)
        {
            throw null;
        }

        sbyte IConvertible.ToSByte(IFormatProvider provider)
        {
            throw null;
        }

        float IConvertible.ToSingle(IFormatProvider provider)
        {
            throw null;
        }

        object IConvertible.ToType(Type type, IFormatProvider provider)
        {
            throw null;
        }

        ushort IConvertible.ToUInt16(IFormatProvider provider)
        {
            throw null;
        }

        uint IConvertible.ToUInt32(IFormatProvider provider)
        {
            throw null;
        }

        ulong IConvertible.ToUInt64(IFormatProvider provider)
        {
            throw null;
        }

        public override string ToString()
        {
            throw null;
        }

        public string ToString(IFormatProvider provider)
        {
            throw null;
        }

        public string ToString(string format)
        {
            throw null;
        }

        public string ToString(string format, IFormatProvider provider)
        {
            throw null;
        }

        public static bool TryParse(string s, out double result)
        {
            result = 0.0;
            throw null;
        }

        public static bool TryParse(string s, NumberStyles style, IFormatProvider provider, out double result)
        {
            result = 0.0;
            throw null;
        }
    }
}

[baronfel]

Confirmed, if you decompile System.Private.Corelib you can see the actual definitions for those members^

[baronfel]

This is because we find the ref assembly instead of the actual implementation assembly. I don't know of any mechanism to find an implementation assembly given a ref assembly, at least not without doing more path probing....

[baronfel]

A potential solution to this might be using the new signature-file metadata view coming in FCS 40 for these lookups instead of the ICSharpCode decompiler. We may want to make that an option anyway.

[baronfel]

Roslyn has logic for handling this here.

[github-actions]

🤖 This is an automated response from Repo Assist.

The throw null pattern is characteristic of .NET reference assemblies (found in the packs/Microsoft.NETCore.App.Ref/ directory). These assemblies are signature-only by design — they contain metadata but no method bodies. ILSpy faithfully decompiles them with throw null as the stub body.

Fix location: src/FsAutoComplete.Core/Decompiler.fs → decompilerForFile. The CSharpDecompiler is created without first checking whether the target assembly is a reference assembly.

Detection: A reference assembly has the [System.Runtime.CompilerServices.ReferenceAssemblyAttribute] assembly-level attribute. ICSharpCode.Decompiler exposes this via PEFile:

let isReferenceAssembly (assemblyPath: string) =
    use pef = new ICSharpCode.Decompiler.Metadata.PEFile(assemblyPath)
    pef.Metadata.GetAssemblyDefinition()
    |> pef.Metadata.GetCustomAttributes
    |> Seq.exists (fun handle ->
        let attr = pef.Metadata.GetCustomAttribute(handle)
        let typeName = attr.Constructor.GetTypeName(pef.Metadata)
        typeName = "System.Runtime.CompilerServices.ReferenceAssemblyAttribute")

Possible recovery strategies (once detected):

1. Roslyn-style impl-assembly lookup (most complete): Follow the approach baronfel linked in Roslyn's ImplementationAssemblyLookupService. For example, packs/Microsoft.NETCore.App.Ref/8.0.0/ref/net8.0/System.Runtime.dll maps to shared/Microsoft.NETCore.App/8.0.0/System.Runtime.dll. The path pattern is deterministic.

2. FCS metadata view (lighter weight): When the target is a reference assembly, show FCS-generated F# metadata instead of decompiled C#. FCS exposes FSharpEntity.TryGetFullDisplayName and related APIs that produce a clean signature without throw null.

3. UI note: Simplest option — show a banner like "This is a reference assembly — method bodies are not available" in the decompiled output.

This is a well-scoped help wanted fix — the detection code is straightforward, and option 3 would be a minimal but user-friendly improvement.

Generated by Repo Assist · ◷

To install this agentic workflow, run

gh aw add githubnext/agentics/workflows/repo-assist.md@10f087607af87e4e89439161f1e5d4724235f396

[baronfel]

/repo-assist use the second option of locating the actual dll for decompilation and send a PR implementing that