Add simple diagnostic output to InterfaceStubGenerator.

InterfaceStubGenerator/Diagnostics.cs

@@ -0,0 +1,98 @@
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Refit.Generator
+{
+    public class DiagnosticsLogger
+    {
+        List<Diagnostic> diagnostics = new List<Diagnostic>();
+
+        public IEnumerable<Diagnostic> Diagnostics { get { return diagnostics.AsReadOnly(); } }
+
+        public void Add(Diagnostic diagnostic)
+        {
+            this.diagnostics.Add(diagnostic);
+        }
+
+        public void AddRange(IEnumerable<Diagnostic> collection)
+        {
+            this.diagnostics.AddRange(collection);
+        }
+
+        public void Dump()
+        {
+            var builder = new StringBuilder();
+
+            foreach (var diagnostic in diagnostics)
+            {
+                builder.Clear();
+
+                if (!string.IsNullOrWhiteSpace(diagnostic.File))
+                {
+                    builder.Append(diagnostic.File);
+                    if (diagnostic.Line.HasValue)
+                    {
+                        builder.AppendFormat("({0}", diagnostic.Line);
+                        if (diagnostic.Character.HasValue)
+                            builder.AppendFormat(",{0}", diagnostic.Character);
+                        builder.Append(")");
+                    }
+                    builder.Append(": ");
+                }
+                builder.AppendFormat("{0} {1}", diagnostic.Type, diagnostic.Code);
+                if (!string.IsNullOrWhiteSpace(diagnostic.Message))
+                    builder.AppendFormat(": {0}", diagnostic.Message);
+
+                Console.Error.WriteLine(builder.ToString());
+            }
+        }
+    }
+
+    public class Diagnostic
+    {
+        public string Type { get; private set; }
+        public string Code { get; private set; }
+        public string File { get; protected set; }
+        public int? Line { get; protected set; }
+        public int? Character { get; protected set; }
+        public string Message { get; protected set; }
+
+        public Diagnostic(string type, string code)
+        {
+            this.Type = type;
+            this.Code = code;
+        }
+    }
+
+    public class Warning : Diagnostic
+    {
+        public Warning(string code) : base("warning", code) { }
+    }
+
+    public class MissingRefitAttributeWarning : Warning
+    {
+        public string InterfaceName { get; private set; }
+        public string MethodName { get; private set; }
+
+        public MissingRefitAttributeWarning(InterfaceDeclarationSyntax @interface, MethodDeclarationSyntax method)
+            : base("RF001")
+        {
+            var location = method.GetLocation();
+            var line = location.GetMappedLineSpan().StartLinePosition;
+
+            this.File = location.FilePath;
+            this.Line = line.Line + 1;
+            this.Character = line.Character + 1;
+            this.InterfaceName = @interface.Identifier.Text;
+            this.MethodName = method.Identifier.Text;
+
+            this.Message = string.Format(
+                "Method {0}.{1} either has no Refit HTTP method attribute or you've used something other than a string literal for the 'path' argument.",
+                this.InterfaceName, this.MethodName);
+        }
+    }
+}

InterfaceStubGenerator/InterfaceStubGenerator.cs

@@ -34,6 +34,10 @@ public string GenerateInterfaceStubs(string[] paths)
 
             var templateInfo = GenerateTemplateInfoForInterfaceList(interfacesToGenerate);
 
+            var logger = new DiagnosticsLogger();
+            GenerateWarnings(interfacesToGenerate, logger);
+            logger.Dump();
+
             Encoders.HtmlEncode = (s) => s;
             var text = Render.StringToString(ExtractTemplateSource(), templateInfo);
             return text;
@@ -126,6 +130,14 @@ public ClassTemplateInfo GenerateClassInfoForInterface(InterfaceDeclarationSynta
             return ret;
         }
 
+        public void GenerateWarnings(List<InterfaceDeclarationSyntax> interfacesToGenerate, DiagnosticsLogger logger)
+        {
+            logger.AddRange(interfacesToGenerate
+                .SelectMany(i => i.Members.OfType<MethodDeclarationSyntax>().Select(m => new { Interface = i, Method = m }))
+                .Where(x => !HasRefitHttpMethodAttribute(x.Method))
+                .Select(x => new MissingRefitAttributeWarning(x.Interface, x.Method)));
+        }
+
         public static string ExtractTemplateSource()
         {
             var ourPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);

InterfaceStubGenerator/InterfaceStubGenerator.csproj

@@ -75,6 +75,7 @@
     </Reference>
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Diagnostics.cs" />
     <Compile Include="InterfaceStubGenerator.cs" />
     <Compile Include="Mono.Options\Options.cs" />
     <Compile Include="Program.cs" />
@@ -95,4 +96,4 @@
   <Target Name="AfterBuild">
   </Target>
   -->
-</Project>
+</Project>

Refit-Tests/InterfaceStubGenerator.cs

@@ -116,6 +116,24 @@ public void RetainsAliasesInUsings()
             CollectionAssert.Contains(usingList, "SomeType = CollisionA.SomeType");
             CollectionAssert.Contains(usingList, "CollisionB");
         }
+
+        [Test]
+        public void CheckGeneratedWarning()
+        {
+            var fixture = new InterfaceStubGenerator();
+            var file = CSharpSyntaxTree.ParseFile(IntegrationTestHelper.GetPath("InterfaceStubGenerator.cs"));
+
+            var input = file.GetRoot().DescendantNodes()
+                .OfType<InterfaceDeclarationSyntax>()
+                .First(x => x.Identifier.ValueText == "IAmARefitInterfaceButNobodyUsesMe");
+            var logger = new DiagnosticsLogger();
+
+            fixture.GenerateWarnings(new List<InterfaceDeclarationSyntax> { input }, logger);
+            var result = logger.Diagnostics.OfType<MissingRefitAttributeWarning>().Single();
+
+            Assert.AreEqual("IAmARefitInterfaceButNobodyUsesMe", result.InterfaceName);
+            Assert.AreEqual("NoConstantsAllowed", result.MethodName);
+        }
     }
 
     public static class ThisIsDumbButMightHappen