Custom Compiler Warnings

Question

When using the ObsoleteAtribute in .Net it gives you compiler warnings telling you that the object/method/property is obsolete and somthing else should be used. I'm currently working on a project that requires a lot of refactoring an ex-employees code. I want to write a custom attribute that I can use to mark methods or properties that will generate compiler warnings that give messages that I write. Something like this

[MyAttribute("This code sux and should be looked at")]
public void DoEverything()
{
}

<MyAttribute("This code sux and should be looked at")>
Public Sub DoEverything()
End Sub

I want this to generate a compiler warning that says, "This code sux and should be looked at". I know how to create a custom attribute, the question is how do I cause it to generate compiler warnings in visual studio.

Trudy

Is this C#? I'm going to presumptively retag this as C# (not C) on the presumption that's what the original poster meant to pick. – Glochidiate

it's vb i think, definitely not c# – Buxton

That's not valid VB or C#... so what is it...?! – Kokura

I only retagged it as C# because he originally had tagged it as C. Maybe he's talking about managed C++? If the original poster reads this comment, please clarify the question. – Glochidiate

It should be tagged as either C# or VB.Net so I retagged them with both. I can do both so I don't really care. Perhaps it should be tagged with neither. – Trudy

I didn't mean to be unfair about it, removed the tags as I worried it could mislead people about the code sample in the q... but obviously if you definitely think they should be there that's cool. still a little confused about tagging it vs2008 though... :-S??! – Kokura

C# and vb.net could be removed I suppose, but it's marked vs2008 because I think it's something directly related to vs2008 and the compiler – Trudy

I've added some code samples and an image of what you wanted! good luck man! – Wakeful

Old question, but you can define custom compiler warnings using Roslyn now. – Chiastic

@RJCuthbertson How can you do this with Roslyn? – Drumlin

@Drumlin In Roslyn speak, code analyzers: johnkoerner.com/csharp/creating-your-first-code-analyzer – Chiastic

@RJCuthbertson I moved your comment into the accepted answer to give it the attention it deserves. – Redmond

Answer 1

Update

This is now possible with Roslyn (Visual Studio 2015). You can build a code analyzer to check for a custom attribute

---

Original outdated answer:

I don't believe it's possible. ObsoleteAttribute is treated specially by the compiler and is defined in the C# standard. Why on earth is ObsoleteAttribute not acceptable? It seems to me like this is precisely the situation it was designed for, and achieves precisely what you require!

Also note that Visual Studio picks up the warnings generated by ObsoleteAttribute on the fly too, which is very useful.

Don't mean to be unhelpful, just wondering why you're not keen on using it...

Unfortunately ObsoleteAttribute is sealed (probably partly due to the special treatment) hence you can't subclass your own attribute from it.

From the C# standard:-

The attribute Obsolete is used to mark types and members of types that should no longer be used.

If a program uses a type or member that is decorated with the Obsolete attribute, the compiler issues a warning or an error. Specifically, the compiler issues a warning if no error parameter is provided, or if the error parameter is provided and has the value false. The compiler issues an error if the error parameter is specified and has the value true.

Doesn't that sum up your needs?... you're not going to do better than that I don't think.

Kokura

I'm looking for the same thing. Obsolete 'works' but the code isn't really obsolete so much as incomplete due to refactoring. – Insipience

I agree with @g, and probably the original author. Obsolete means obsolete, don't use. I want to flag something as "hey this compiles but we really need to either a) complete the functionality or b) refactor". It would be more of a development time attribute. Also tasks work, e.g. // TODO:, but I don't use those, as I'm guessing many people don't, but do review the compiler warnings regularly. – Gyneco

Another reason not to use the [Obsolete] tag is that could cause problems if you need to do XmlSerialization with the property. Adding the [Obsolete] tag also adds [XmlIgnore] attribute behind the scenes. – Plautus

Obsolete is different. Obsolete will give you a warning on every line of code that calls that method. I don't think that's what the poster wants (at least that's not what I want when I did a search and found this question). I thought what the question was looking for was for a warning to show up on the definition of the function, not ever place that it's being used. – Dendrochronology

Not the greatest answer. -1 for thinking your inability to come up with a reason for not using it merits criticism. This attitude discourages authenticity. – Bologna

@Dendrochronology I think they want it to show up if the function is called. That's my use case too. Want to be able to mark a function as "only to be called from test code" or "not to be compiled in production" stuff like that. – Maffei

Here's an example from the .net core source code itself that is a misuse of ObsoleteAttribute indicating there should be other kinds or ways of creating your own. [System.ComponentModel.EditorBrowsableAttribute((System.ComponentModel.EditorBrowsableState)(1))] [System.ObsoleteAttribute("This API supports the .NET Framework infrastructure and is not intended to be used directly from your code.")] – Maffei

Code analyzer tutorial is now here, web archive version here – Jeanninejeans

Answer 2

This is worth a try.

You can't extend Obsolete, because it's final, but maybe you can create your own attribute, and mark that class as obsolete like this:

[Obsolete("Should be refactored")]
public class MustRefactor: System.Attribute{}

Then when you mark your methods with the "MustRefactor" attribute, the compile warnings will show. It generates a compile time warning, but the error message looks funny, you should see it for yourself and choose. This is very close to what you wanted to achieve.

UPDATE: With this code It generates a warning (not very nice, but I don't think there's something better).

public class User
{
    private String userName;

    [TooManyArgs] // Will show warning: Try removing some arguments
    public User(String userName)
    {
        this.userName = userName;   
    }

    public String UserName
    {
        get { return userName; }
    }
    [MustRefactor] // will show warning: Refactor is needed Here
    public override string ToString()
    {
        return "User: " + userName;
    }
}
[Obsolete("Refactor is needed Here")]
public class MustRefactor : System.Attribute
{

}
[Obsolete("Try removing some arguments")]
public class TooManyArgs : System.Attribute
{

}

Wakeful

Can you paste in what it generates? I'm curious. – Trudy

The compile warning is triggered even if the Property / Method is not called. – Brenda

Good suggestions here. I was looking to do the same thing, and ended up just throwing NotImplementedExceptions. Not the best solution since they don't show up at compile time, only at runtime if the code happens to be executed. I'll give this a try myself. – Semiskilled

Wouldn't it be great if the ObsolteAttribute could support expressions just like DebuggerDisplayAttribute, then we could really do some cool stuff. visualstudio.uservoice.com/forums/121579-visual-studio/… – Gluttony

If you implement IDisposable on those obsolete classes, it means you can wrap your dodgy test code in a using block. Like this: using(new MustRefactor()){DodgyCode();}. Then you can find all the usages when you're done. I'm using this right now to Sleep the thread inside a for loop I need to artificially slow down for debugging purposes. – Siphonophore

Incase anyone was wondering how to do this with a custom attribute I've provided an answer below – Munson

Answer 3

In some compilers you can use #warning to issue a warning:

#warning "Do not use ABC, which is deprecated. Use XYZ instead."

In Microsoft compilers, you can typically use the message pragma:

#pragma message ( "text" )

You mentioned .Net, but didn't specify whether you were programming with C/C++ or C#. If you're programming in C#, than you should know that C# supports the #warning format.

Kight

#warning or #pragma are pre-processor directives and thus will run regardless of the presence of any of micah's ex-colleagues' code, and it doesn't interact with the attribute at all. Pretty certain Obsolete is the only means of achieving this... – Kokura

This does not answer the question. – Alfonsoalfonzo

Answer 4

We're currently in the middle of a lot of refactoring where we couldn't fix everything right away. We just use the #warning preproc command where we need to go back and look at code. It shows up in the compiler output. I don't think you can put it on a method, but you could put it just inside the method, and it's still easy to find.

public void DoEverything() {
   #warning "This code sucks"
}

Bluefarb

This really is a good solution! – Vivianna

Answer 5

What you are trying to do is a misuse of attributes. Instead use the Visual Studio Task List. You can enter a comment in your code like this:

//TODO:  This code sux and should be looked at
public class SuckyClass(){
  //TODO:  Do something really sucky here!
}

Then open View / Task List from the menu. The task list has two categories, user tasks and Comments. Switch to Comments and you will see all of your //Todo:'s there. Double clicking on a TODO will jump to the comment in your code.

Al

Customs

i find this a more preferable solution – Elfreda

what if you want to mark a function as "Not to be called in production code" or similar. So you want it to fire if a function or class is called or instantiated, but not if it's just compiled. – Maffei

Answer 6

In VS 2008 (+sp1) #warnings don't show properly in Error List after Clean Soultion & Rebuild Solution, no all of them. Some Warnings are showed in the Error List only after I open particular class file. So I was forced to use custom attribute:

[Obsolete("Mapping ToDo")]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property)]
public class MappingToDo : System.Attribute
{
    public string Comment = "";

    public MappingToDo(string comment)
    {
        Comment = comment;
    }

    public MappingToDo()
    {}
}

So when I flag some code with it

[MappingToDo("Some comment")]
public class MembershipHour : Entity
{
    // .....
}

It produces warnings like this:

Namespace.MappingToDo is obsolete: 'Mapping ToDo'.

I can't change the text of the warning, 'Some comment' is not showed it Error List. But it will jump to proper place in file. So if you need to vary such warning messages, create various attributes.

Neocene

Answer 7

Here is the Roslyn Implementation, so you can create your own attributes that give warnings or errors on the fly.

I've create an attribute Type Called IdeMessage which will be the attribute which generates warnings:

[AttributeUsage(AttributeTargets.Method, AllowMultiple = true, Inherited = true)]
public class IDEMessageAttribute : Attribute
{
    public string Message;

    public IDEMessageAttribute(string message);
}

In order to do this you need to install the Roslyn SDK first and start a new VSIX project with analyzer. I've omitted some of the less relevant piece like the messages, you can figure out how to do that. In your analyzer you do this

public override void Initialize(AnalysisContext context)
{
    context.RegisterSyntaxNodeAction(AnalyzerInvocation, SyntaxKind.InvocationExpression);
}

private static void AnalyzerInvocation(SyntaxNodeAnalysisContext context)
{
    var invocation = (InvocationExpressionSyntax)context.Node;

    var methodDeclaration = (context.SemanticModel.GetSymbolInfo(invocation, context.CancellationToken).Symbol as IMethodSymbol);

    //There are several reason why this may be null e.g invoking a delegate
    if (null == methodDeclaration)
    {
        return;
    }

    var methodAttributes = methodDeclaration.GetAttributes();
    var attributeData = methodAttributes.FirstOrDefault(attr => IsIDEMessageAttribute(context.SemanticModel, attr, typeof(IDEMessageAttribute)));
    if(null == attributeData)
    {
        return;
    }

    var message = GetMessage(attributeData); 
    var diagnostic = Diagnostic.Create(Rule, invocation.GetLocation(), methodDeclaration.Name, message);
    context.ReportDiagnostic(diagnostic);
}

static bool IsIDEMessageAttribute(SemanticModel semanticModel, AttributeData attribute, Type desiredAttributeType)
{
    var desiredTypeNamedSymbol = semanticModel.Compilation.GetTypeByMetadataName(desiredAttributeType.FullName);

    var result = attribute.AttributeClass.Equals(desiredTypeNamedSymbol);
    return result;
}

static string GetMessage(AttributeData attribute)
{
    if (attribute.ConstructorArguments.Length < 1)
    {
        return "This method is obsolete";
    }

    return (attribute.ConstructorArguments[0].Value as string);
}

There are no CodeFixProvider for this you can remove it from the solution.

Munson

Answer 8

I don't think you can. As far as I know support for ObsoleteAttribute is essentially hardcoded into the C# compiler; you can't do anything similar directly.

What you might be able to do is use an MSBuild task (or a post-build event) that executes a custom tool against the just-compiled assembly. The custom tool would reflect over all types/methods in the assembly and consume your custom attribute, at which point it could print to System.Console's default or error TextWriters.

Wilburn

Answer 9

Looking at the source for ObsoleteAttribute, it doesn't look like it's doing anything special to generate a compiler warning, so I would tend to go with @technophile and say that it is hard-coded into the compiler. Is there a reason you don't want to just use ObsoleteAttribute to generate your warning messages?

Kendall

No particular reason other than code isn't necessarily obsolete. – Trudy

It's specified in the C# specification as being treated specially by the compiler, check out my answer :-). Micah - 'The attribute Obsolete is used to mark types and members of types that should no longer be used.' from the specification. Isn't that applicable?... – Kokura

Just if somebody wondered, there is no C# code in source code to do this either. referencesource.microsoft.com/#mscorlib/system/… – Jibheaded

Answer 10

There are several comments that suggest to insert warnings or pragma. Obsolete works in a very different way! Marking obsolete a function of a library L, the obsolete message raises when a program calls the function even if the caller program is not in the library L. Warning raises the message ONLY when L is compiled.

Prognostication

Answer 11

If like me you are here through how can I create [experimental] tag in c# which throws a compiler warning question,

With C# 12 they have added a feature which you can use to mark a class as Experimental, the only way to use this class would be using a NoWarn or a Pragma suppression.

[Experimental("Risky for usage")]
public class ExperimentalClass
{

}

Usage:

#pragma warning disable Risky
     var data = new ExperimentalClass();
#pragma warning restore Risky

Feel free to reach out for queries

Farlee