Proposal: Add [NotNull] to the Validate() result and validationContext parameter.

(This issue duplicates RSRP-427424.)

Reasoning for a [NotNull] validationContext parameter

• IValidatableObject is an extension point for the BCL "Data Annotations" validation framework and therefore intended to be called from inside the BCL.
• Inside the BCL there are two calls:
  • Validator.GetObjectValidationErrors(): Here the validationContext argument is guarded by a null check.
  • ValidatableObjectAdapter.Validate(): Here the validationContext argument is a newly created instance.

Therefore it makes no sense to implement an argument null check in a Validate() interface implementation for objects which will be validated by the BCL and the new annotation would guide us to avoid this.

Reasoning for a [NotNull] result

• Validator.GetObjectValidationErrors() relies on a non-null result of Validate(). A null return value would result in an ArgumentNullException for the source argument in the following results.Where(...) call.

The array passed to the constructor may not be null, however the Array property can. For example:

default(ArraySegment<byte>).Array == null

<member name="M:...Validate(System.Object, System.String)">

should be

<member name="M:...Validate(System.Object,System.String)">

to be consistent with all others.

If you add <developmentDependency>true</developmentDependency>
in your Metadata Block in your Nuspec File, it will install itself as a Development Dependency.
You can see it for Example here Nuspec

Many generic member names contain duplicated back ticks, e.g.
<member name="M:System.Tuple.Create``1(``0)">
instead of
<member name="M:System.Tuple.Create`1(`0)">
(6899 member names with single ticks, 4533 member names with duplicate ticks)

This is not according to the specification, and makes parsing hard and error prone.

The "value" parameter can always be null.

s. "4.0.0.0.Nullness.Gen.xml":

At the moment the message parameters of Trace, Debug, and TraceListener methods are annotated with [NotNull]. Example: Trace.Write(string).

This is incorrect because there are no not-null preconditions (or guarding checks) in the concerned BCL classes. Also the BCL TraceListener implementations can cope with message null arguments (e.g. DefaultTraceListener here, here and here, or TextWriterTraceListener here and here).

=> Message null arguments are OK, and custom TraceListener implementations should be aware of that. But: At the moment R# warns about null arguments, and worse, suggests to remove null-handling in TraceListener implementations (see the following screenshot).

In the screenshot you can also see that (except for the "format string overloads") the null arguments do not raise any error.

Same with Debug class:

OfType linq extensions are missing the [ItemNotNull], thus generating false warnings.

This method always throws an exception: http://referencesource.microsoft.com/#mscorlib/system/runtime/exceptionservices/exceptionservicescommon.cs,fc3b312e2d0ab87a

But R# does not know about it:

// I will try to send PR for this

Observed under both net45 (mscorlib) and netstandard1.3 (System.Runtime).

I see somebody made this for Kendo.Mvc
https://github.com/Dim0N22/ResharperKendoAnnotations

Could we upstream this?
Should I contact @Dim0N22 for permission first or should I contact you for approval first?

I'm using the experimental implicit not-null setting in R# 2016.1 and every time I test Exception.InnerException for null, R# says it's always false which is definitely not the case.

I looked through the files here and couldn't find any reference to InnerException.

Also, I read the documents linked to from the README, but I couldn't find any information on how to contribute to this repo. The structure here is more involved than what's mentioned in the docs.

• NotNull for the parameters of DbSet.Add()/AddRange()/Attach()/Remove()/RemoveRange() (e.g. see null-check in Add(TEntity entity)).
• CanBeNull for the result of DbSet.Find() (See XML Doc comments).
• ItemCanBeNull for DbSet.FindAsync().

System.Reflection.Assembly.Location can be null, when the assembly is loaded from memory (for example, when dynamically compiling an assembly in memory and/or loading the assembly using Assembly.Load(byte[]).

I encountered numerous bugs in our systems (even in some official MS packages) where 'Location' is not checked for null/empty.

Resharper is definitely not helping here. It even suggests to remove the null check.

I think the annotation should be replaced by 'CanBeNull'.

Ninject is a commonly used dependency injection container. Having annotations for this library would be very beneficial.

The System.Net.Http assembly should be annotated. Specifically, the following methods should be marked as NotNull:

• CopyToAsync
• CreateContentReadStreamAsync
• LoadIntoBufferAsync
• ReadAsByteArrayAsync
• ReadAsStreamAsync
• ReadAsStringAsync
• SerializeToStreamAsync

Enumerabla.FirstOrDefault(source, predicate) throw ArgumentNullException due to documentation:
https://msdn.microsoft.com/en-us/library/bb549039(v=vs.110).aspx

Using methods such as FirstOrDefault in .NET Core causes R# to claim that the return value can never be null.

System.Globalization.CultureInfo.GetCultureInfo(string name)

Most of https://github.com/robv8r/resharper-annotations should be possible to Merga in

After getting a lot of false positives with R# I have compared the ExternalAnnotations with Code Contracts and found a lot of differences.

While 3933 methods/props have identical nullability contracts, 1091 methods/props are missing at all, and 679 methods/props are different (mostly parts missing on R# side).

I have attached the results of my analysis, where RS* are the normalized ExternalAnnotations and CC* are the corresponding contracts exported from the Code Contracts project. All files are in ExternalAnnotations xml format.

OK are the ones where both have the same outcome.
CC and RS contain the the differences (compare both folders with e.g. BeyondCompare)
CCOnly are the ones defined only in Code Contracts and missing in R#

For the differences most times CC is more exact, but not always, so these would need an extra review.

Contracts.zip

public static readonly fields or properties, like all DependencyPropery declarations, IPAddress members or System.Windows.Input.*Command declarations are missing a [NotNull] attribute, thus generating false warnings.

See related issue on YouTrack:

https://youtrack.jetbrains.com/issue/RSRP-296612

In this code block, ReSharper doesn't warn that attrib.Value is a possible NullReferenceException

void Foo()
{
var xe = XElement.Parse("");
var attrib = xe.Attribute("a");
var value = attrib.Value;
}

The inspection is there if I set the .NET Framework 3.5. for the project. If I choose anything higher than that, it doesn't work.

Enumerable.Empty<>() has attribute [NotNull]
Array.Empty<>() - yet not covered with [NotNull]

Otherwise when overriding Equals null tests are flagged as always false.

See screenshot, taken using R# 2016.2 EAP RC1, with "Implicit not-null" setting enabled.

All three overloads of System.Windows.IDataObject.GetData explain that they can return null in the API docs.

Convert and ConvertBack can both receive null for value, and I believe parameter can be null too.

I'm getting warnings under R#'s implicit not-null mode.

Given the attributes in the JetBrains.Annotations NuGet package are [Conditional("JETBRAINS_ANNOTATIONS")], they're not present in compiled library code (I could set the condition symbol, but I'm happy leaving them out of the DLL's metadata).

I'd like users of my library to benefit from these annotations, but I don't want to maintain the XML by hand.

Is it possible to have them generated automatically, perhaps as part of the build process?

If so, would including them in nupkg files be enough to have them picked up by users of my NuGet packages?

Methods that can infer result nullability from parameter nullability do not have a ContractAnnotation attribute.

When adding a Parameter to a SqlCommand, ReSharper reports that the return value can be null. Currently, ReSharper would report that the two Add methods could be null. Setting the Value property would result in a "red squiggle" to appear from the beginning of the line until the dot just before Value.

private void Example()
{
    const string SqlText = "UPDATE A SET B = @B WHERE C = @C";

    using (var conn = new SqlConnection(this.ConnectionString))
    {
        conn.Open();
        using (var command = new SqlCommand(SqlText, conn))
        {
            command.CommandType = CommandType.Text;
            command.Parameters.Add("@B", SqlDbType.VarChar, 255).Value = "B";
            command.Parameters.Add("@C", SqlDbType.Int).Value = 1;
            command.ExecuteNonQuery();
        }
    }
}

Full .NET framework.

Enum.GetNames should be with ItemNotNull

It's ok for the Func<TSource, TKey> to return null. R# warns if you try to (when using implicit not null).

Same for OrderByDescending, ThenBy and ThenByDescending.

Names for methods with no parameters should either all end with () or all without ()

e.g. M:Microsoft.CSharp.Error.NotImplemented
should be M:Microsoft.CSharp.Error.NotImplemented()

There are 1530 methods with () and 15105 without ()

Repro steps:

• Install VS 2017 RC with Web/Cloud workload
• Create a new ASP.NET Core application (MVC)
• From the package manager console: install-package jetbrains.externalannotations

Actual:

install-package : Package JetBrains.ExternalAnnotations 10.2.3 is not compatible with netcoreapp1.0 (.NETCoreApp,Version=v1.0). Package JetBrains.ExternalAnnotations 10.2.3 supports: net (.NETFramework,Version=v0.0)
At line:1 char:1
+ install-package jetbrains.externalannotations
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : NotSpecified: (:) [Install-Package], Exception
    + FullyQualifiedErrorId : NuGetCmdletUnhandledException,NuGet.PackageManagement.PowerShellCmdlets.InstallPackageCommand
 
install-package : One or more packages are incompatible with .NETCoreApp,Version=v1.0.
At line:1 char:1
+ install-package jetbrains.externalannotations
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : NotSpecified: (:) [Install-Package], Exception
    + FullyQualifiedErrorId : NuGetCmdletUnhandledException,NuGet.PackageManagement.PowerShellCmdlets.InstallPackageCommand
 
install-package : Package restore failed. Rolling back package changes for 'CoreWebApplication1'.
At line:1 char:1
+ install-package jetbrains.externalannotations
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : NotSpecified: (:) [Install-Package], Exception
    + FullyQualifiedErrorId : NuGetCmdletUnhandledException,NuGet.PackageManagement.PowerShellCmdlets.InstallPackageCommand
 

Expected: successful installation.

This annotation is missing. In fact I can't find any reference to the GridViewColumn class in System.Windows.Controls.

https://github.com/JetBrains/ExternalAnnotations/blob/master/Annotations/.NETFramework/System.Windows.Controls/2.0.5.0.Nullness.Gen.xml

Happy to add this if it'll be merged. Seems that this repo isn't actually being used. Is that the case?

I am using Visual Studio 2017 and ReSharper 2016.3.2
For some reason I can't find this package https://resharper-plugins.jetbrains.com/packages/ReSharper.ExternalAnnotations/ in my Extension Manager. When I search for External Annotations I get only this: Community ReSharper External Annotations
I've installed the nuget package: https://www.nuget.org/packages/JetBrains.ExternalAnnotations/ but I'm not sure if it's the same thing? Can someone clarify this for me?
Thanks.

https://msdn.microsoft.com/en-us/library/xsc9a449%28v=vs.110%29.aspx?f=255&MSPPError=-2147217396

but "value" parameter has "NotNull" attribute