Support partial methods (#4)

davidfowl · web-flow · commit 4ab2acc2e376 · 2020-11-18T16:14:21.000-08:00
diff --git a/src/libraries/Microsoft.Extensions.Logging/gen/LoggingGenerator.Parser.cs b/src/libraries/Microsoft.Extensions.Logging/gen/LoggingGenerator.Parser.cs
@@ -110,7 +110,7 @@ public Parser(GeneratorExecutionContext context)
             /// <summary>
             /// Gets the set of logging classes that should be generated based on the discovered annotated interfaces.
             /// </summary>
-            public IEnumerable<LoggerClass> GetLogClasses(List<InterfaceDeclarationSyntax> interfaces)
+            public IEnumerable<LoggerClass> GetLogClasses(List<TypeDeclarationSyntax> types)
             {
                 var logExtensionsAttribute = _compilation.GetTypeByMetadataName("Microsoft.Extensions.Logging.LoggerExtensionsAttribute");
                 if (logExtensionsAttribute is null)
@@ -140,9 +140,9 @@ public IEnumerable<LoggerClass> GetLogClasses(List<InterfaceDeclarationSyntax> i
                     yield break;
                 }
 
-                foreach (var iface in interfaces)
+                foreach (var typeDef in types)
                 {
-                    foreach (var al in iface.AttributeLists)
+                    foreach (var al in typeDef.AttributeLists)
                     {
                         foreach (var a in al.Attributes)
                         {
@@ -153,13 +153,13 @@ public IEnumerable<LoggerClass> GetLogClasses(List<InterfaceDeclarationSyntax> i
                             {
                                 // determine the namespace the interface is declared in, if any
                                 NamespaceDeclarationSyntax? ns = null;
-                                if (iface.Parent != null)
+                                if (typeDef.Parent != null)
                                 {
-                                    ns = iface.Parent as NamespaceDeclarationSyntax;
-                                    if (ns == null && iface.Parent is not CompilationUnitSyntax)
+                                    ns = typeDef.Parent as NamespaceDeclarationSyntax;
+                                    if (ns == null && typeDef.Parent is not CompilationUnitSyntax)
                                     {
                                         // since this generator doesn't know how to generate a nested type...
-                                        Diag(ErrorNestedType, iface.Identifier.GetLocation());
+                                        Diag(ErrorNestedType, typeDef.Identifier.GetLocation());
                                     }
                                 }
 
@@ -173,42 +173,48 @@ public IEnumerable<LoggerClass> GetLogClasses(List<InterfaceDeclarationSyntax> i
                                 }
 
                                 // if no name was specified, try to derive it from the interface name
-                                var ifaceName = iface.Identifier.ToString();
+                                var ifaceName = typeDef.Identifier.ToString();
                                 if (name == null)
                                 {
-                                    if (ifaceName[0] == 'I')
+                                    if (typeDef is InterfaceDeclarationSyntax iface)
                                     {
-                                        // strip the leading I
-                                        name = ifaceName.Substring(1);
+                                        if (ifaceName[0] == 'I' && ifaceName.Length > 1)
+                                        {
+                                            name = ifaceName.Substring(1);
+                                        }
+                                        else
+                                        {
+                                            name = ifaceName + "Extensions";
+                                        }
                                     }
                                     else
                                     {
-                                        // fail
-                                        name = string.Empty;
+                                        name = typeDef.Identifier.ToString();
                                     }
                                 }
 
                                 var lc = new LoggerClass
                                 {
                                     Namespace = ns?.Name.ToString(),
                                     Name = name,
-                                    OriginalInterfaceName = iface.Identifier.ToString(),
-                                    AccessModifiers = iface.Modifiers.ToString(),
-                                    Documentation = GetDocs(iface),
+                                    OriginalInterfaceName = typeDef.Identifier.ToString(),
+                                    AccessModifiers = typeDef.Modifiers.ToString(),
+                                    Documentation = GetDocs(typeDef),
+                                    IsInterface = typeDef is InterfaceDeclarationSyntax
                                 };
 
                                 if (string.IsNullOrWhiteSpace(lc.Name))
                                 {
                                     Diag(ErrorInvalidTypeName, a.GetLocation(), ifaceName);
                                 }
 
-                                if (iface.Arity > 0)
+                                if (typeDef.Arity > 0)
                                 {
-                                    Diag(ErrorInterfaceGeneric, iface.GetLocation());
+                                    Diag(ErrorInterfaceGeneric, typeDef.GetLocation());
                                 }
 
                                 var ids = new HashSet<string>();
-                                foreach (var method in iface.Members.Where(m => m.IsKind(SyntaxKind.MethodDeclaration)).OfType<MethodDeclarationSyntax>())
+                                foreach (var method in typeDef.Members.Where(m => m.IsKind(SyntaxKind.MethodDeclaration)).OfType<MethodDeclarationSyntax>())
                                 {
                                     foreach (var mal in method.AttributeLists)
                                     {
@@ -289,6 +295,12 @@ public IEnumerable<LoggerClass> GetLogClasses(List<InterfaceDeclarationSyntax> i
                                                         Type = p.Type!.ToString(),
                                                         IsExceptionType = IsBaseOrIdentity(pSymbol, exSymbol),
                                                     };
+                                                    
+                                                    if (lp.Type.EndsWith("ILogger", StringComparison.Ordinal))
+                                                    {
+                                                        continue;
+                                                    }
+
                                                     lm.Parameters.Add(lp);
 
                                                     if (lp.Name.StartsWith("__", StringComparison.Ordinal))
@@ -394,6 +406,7 @@ private class LoggerClass
             public string AccessModifiers = string.Empty;
             public List<LoggerMethod> Methods = new();
             public string Documentation = string.Empty;
+            public bool IsInterface { get; set; }
         }
 
         // A log method in a logging class
diff --git a/src/libraries/Microsoft.Extensions.Logging/gen/LoggingGenerator.cs b/src/libraries/Microsoft.Extensions.Logging/gen/LoggingGenerator.cs
@@ -6,6 +6,7 @@ namespace Microsoft.Extensions.Logging.Generators
     using System.Collections.Generic;
     using System.Text;
     using Microsoft.CodeAnalysis;
+    using Microsoft.CodeAnalysis.CSharp;
     using Microsoft.CodeAnalysis.CSharp.Syntax;
     using Microsoft.CodeAnalysis.Text;
 
@@ -30,7 +31,7 @@ public void Execute(GeneratorExecutionContext context)
             var p = new Parser(context);
 
             var types = new StringBuilder();
-            foreach (var lc in p.GetLogClasses(receiver.InterfaceDeclarations))
+            foreach (var lc in p.GetLogClasses(receiver.TypeDeclarations))
             {
                 types.Append(GenType(lc));
             }
@@ -53,7 +54,7 @@ private static string GenType(LoggerClass lc)
             {
                 methods.Append(GenStruct(lm));
                 methods.Append(GenEventId(lm));
-                methods.Append(GenExtensionLogMethod(lm));
+                methods.Append(GenExtensionLogMethod(lc, lm));
             }
 
             var namespaceStart = string.Empty;
@@ -68,10 +69,9 @@ private static string GenType(LoggerClass lc)
             return $@"
 {namespaceStart}
     {lc.Documentation}
-    {lc.AccessModifiers} static class {lc.Name}
+    {lc.AccessModifiers} {(lc.IsInterface ? "static" : "")} class {lc.Name}
     {{
         {methods}
-        public static {lc.OriginalInterfaceName} Wrap(this ILogger logger) => new __Wrapper__(logger);
         {GenWrapper(lc)}
     }}
 {namespaceEnd}
@@ -80,13 +80,19 @@ private static string GenType(LoggerClass lc)
 
         private static string GenWrapper(LoggerClass lc)
         {
+            if (!lc.IsInterface)
+            {
+                return "";
+            }
             var methods = new StringBuilder();
             foreach (var lm in lc.Methods)
             {
                 methods.Append(GenInstanceLogMethod(lm));
             }
 
             return $@"
+        public static {lc.OriginalInterfaceName} Wrap(this ILogger logger) => new __Wrapper__(logger);
+
         private sealed class __Wrapper__ : {lc.OriginalInterfaceName}
         {{
             private readonly ILogger __logger;
@@ -162,7 +168,7 @@ private static string GenInstanceLogMethod(LoggerMethod lm)
 ";
         }
 
-        private static string GenExtensionLogMethod(LoggerMethod lm)
+        private static string GenExtensionLogMethod(LoggerClass lc, LoggerMethod lm)
         {
             string exceptionArg = "null";
             foreach (var p in lm.Parameters)
@@ -174,9 +180,11 @@ private static string GenExtensionLogMethod(LoggerMethod lm)
                 }
             }
 
+            var loggerArg = lc.IsInterface ? "this ILogger logger" : "ILogger logger";
+
             return $@"
         {lm.Documentation}
-        public static void {lm.Name}(this ILogger logger{(lm.Parameters.Count > 0 ? ", " : string.Empty)}{GenParameters(lm)})
+        public static {(lc.IsInterface ? "" : "partial")} void {lm.Name}({loggerArg}{(lm.Parameters.Count > 0 ? ", " : string.Empty)}{GenParameters(lm)})
         {{
             if (logger.IsEnabled((LogLevel){lm.Level}))
             {{
@@ -299,13 +307,19 @@ private static string GenCases(LoggerMethod lm)
 
         private sealed class SyntaxReceiver : ISyntaxReceiver
         {
-            public List<InterfaceDeclarationSyntax> InterfaceDeclarations { get; } = new();
+            public List<TypeDeclarationSyntax> TypeDeclarations { get; } = new();
 
             public void OnVisitSyntaxNode(SyntaxNode syntaxNode)
             {
                 if (syntaxNode is InterfaceDeclarationSyntax interfaceSyntax && interfaceSyntax.AttributeLists.Count > 0)
                 {
-                    InterfaceDeclarations.Add(interfaceSyntax);
+                    TypeDeclarations.Add(interfaceSyntax);
+                }
+
+                // Any partial class
+                if (syntaxNode is ClassDeclarationSyntax { Modifiers: { Count: > 0 } modifiers } classSyntax && modifiers.Any(SyntaxKind.StaticKeyword) && modifiers.Any(SyntaxKind.PartialKeyword))
+                {
+                    TypeDeclarations.Add(classSyntax);
                 }
             }
         }

Original file line number	Diff line number	Diff line change
`@@ -110,7 +110,7 @@ public Parser(GeneratorExecutionContext context)`
`110`	`110`	`/// <summary>`
`111`	`111`	`/// Gets the set of logging classes that should be generated based on the discovered annotated interfaces.`
`112`	`112`	`/// </summary>`
`113`		`- public IEnumerable<LoggerClass> GetLogClasses(List<InterfaceDeclarationSyntax> interfaces)`
	`113`	`+ public IEnumerable<LoggerClass> GetLogClasses(List<TypeDeclarationSyntax> types)`
`114`	`114`	`{`
`115`	`115`	`var logExtensionsAttribute = _compilation.GetTypeByMetadataName("Microsoft.Extensions.Logging.LoggerExtensionsAttribute");`
`116`	`116`	`if (logExtensionsAttribute is null)`
`@@ -140,9 +140,9 @@ public IEnumerable<LoggerClass> GetLogClasses(List<InterfaceDeclarationSyntax> i`
`140`	`140`	`yield break;`
`141`	`141`	`}`
`142`	`142`
`143`		`- foreach (var iface in interfaces)`
	`143`	`+ foreach (var typeDef in types)`
`144`	`144`	`{`
`145`		`- foreach (var al in iface.AttributeLists)`
	`145`	`+ foreach (var al in typeDef.AttributeLists)`
`146`	`146`	`{`
`147`	`147`	`foreach (var a in al.Attributes)`
`148`	`148`	`{`
`@@ -153,13 +153,13 @@ public IEnumerable<LoggerClass> GetLogClasses(List<InterfaceDeclarationSyntax> i`
`153`	`153`	`{`
`154`	`154`	`// determine the namespace the interface is declared in, if any`
`155`	`155`	`NamespaceDeclarationSyntax? ns = null;`
`156`		`- if (iface.Parent != null)`
	`156`	`+ if (typeDef.Parent != null)`
`157`	`157`	`{`
`158`		`- ns = iface.Parent as NamespaceDeclarationSyntax;`
`159`		`- if (ns == null && iface.Parent is not CompilationUnitSyntax)`
	`158`	`+ ns = typeDef.Parent as NamespaceDeclarationSyntax;`
	`159`	`+ if (ns == null && typeDef.Parent is not CompilationUnitSyntax)`
`160`	`160`	`{`
`161`	`161`	`// since this generator doesn't know how to generate a nested type...`
`162`		`- Diag(ErrorNestedType, iface.Identifier.GetLocation());`
	`162`	`+ Diag(ErrorNestedType, typeDef.Identifier.GetLocation());`
`163`	`163`	`}`
`164`	`164`	`}`
`165`	`165`
`@@ -173,42 +173,48 @@ public IEnumerable<LoggerClass> GetLogClasses(List<InterfaceDeclarationSyntax> i`
`173`	`173`	`}`
`174`	`174`
`175`	`175`	`// if no name was specified, try to derive it from the interface name`
`176`		`- var ifaceName = iface.Identifier.ToString();`
	`176`	`+ var ifaceName = typeDef.Identifier.ToString();`
`177`	`177`	`if (name == null)`
`178`	`178`	`{`
`179`		`- if (ifaceName[0] == 'I')`
	`179`	`+ if (typeDef is InterfaceDeclarationSyntax iface)`
`180`	`180`	`{`
`181`		`- // strip the leading I`
`182`		`- name = ifaceName.Substring(1);`
	`181`	`+ if (ifaceName[0] == 'I' && ifaceName.Length > 1)`
	`182`	`+ {`
	`183`	`+ name = ifaceName.Substring(1);`
	`184`	`+ }`
	`185`	`+ else`
	`186`	`+ {`
	`187`	`+ name = ifaceName + "Extensions";`
	`188`	`+ }`
`183`	`189`	`}`
`184`	`190`	`else`
`185`	`191`	`{`
`186`		`- // fail`
`187`		`- name = string.Empty;`
	`192`	`+ name = typeDef.Identifier.ToString();`
`188`	`193`	`}`
`189`	`194`	`}`
`190`	`195`
`191`	`196`	`var lc = new LoggerClass`
`192`	`197`	`{`
`193`	`198`	`Namespace = ns?.Name.ToString(),`
`194`	`199`	`Name = name,`
`195`		`- OriginalInterfaceName = iface.Identifier.ToString(),`
`196`		`- AccessModifiers = iface.Modifiers.ToString(),`
`197`		`- Documentation = GetDocs(iface),`
	`200`	`+ OriginalInterfaceName = typeDef.Identifier.ToString(),`
	`201`	`+ AccessModifiers = typeDef.Modifiers.ToString(),`
	`202`	`+ Documentation = GetDocs(typeDef),`
	`203`	`+ IsInterface = typeDef is InterfaceDeclarationSyntax`
`198`	`204`	`};`
`199`	`205`
`200`	`206`	`if (string.IsNullOrWhiteSpace(lc.Name))`
`201`	`207`	`{`
`202`	`208`	`Diag(ErrorInvalidTypeName, a.GetLocation(), ifaceName);`
`203`	`209`	`}`
`204`	`210`
`205`		`- if (iface.Arity > 0)`
	`211`	`+ if (typeDef.Arity > 0)`
`206`	`212`	`{`
`207`		`- Diag(ErrorInterfaceGeneric, iface.GetLocation());`
	`213`	`+ Diag(ErrorInterfaceGeneric, typeDef.GetLocation());`
`208`	`214`	`}`
`209`	`215`
`210`	`216`	`var ids = new HashSet<string>();`
`211`		`- foreach (var method in iface.Members.Where(m => m.IsKind(SyntaxKind.MethodDeclaration)).OfType<MethodDeclarationSyntax>())`
	`217`	`+ foreach (var method in typeDef.Members.Where(m => m.IsKind(SyntaxKind.MethodDeclaration)).OfType<MethodDeclarationSyntax>())`
`212`	`218`	`{`
`213`	`219`	`foreach (var mal in method.AttributeLists)`
`214`	`220`	`{`
`@@ -289,6 +295,12 @@ public IEnumerable<LoggerClass> GetLogClasses(List<InterfaceDeclarationSyntax> i`
`289`	`295`	`Type = p.Type!.ToString(),`
`290`	`296`	`IsExceptionType = IsBaseOrIdentity(pSymbol, exSymbol),`
`291`	`297`	`};`
	`298`	`+`
	`299`	`+ if (lp.Type.EndsWith("ILogger", StringComparison.Ordinal))`
	`300`	`+ {`
	`301`	`+ continue;`
	`302`	`+ }`
	`303`	`+`
`292`	`304`	`lm.Parameters.Add(lp);`
`293`	`305`
`294`	`306`	`if (lp.Name.StartsWith("__", StringComparison.Ordinal))`
`@@ -394,6 +406,7 @@ private class LoggerClass`
`394`	`406`	`public string AccessModifiers = string.Empty;`
`395`	`407`	`public List<LoggerMethod> Methods = new();`
`396`	`408`	`public string Documentation = string.Empty;`
	`409`	`+ public bool IsInterface { get; set; }`
`397`	`410`	`}`
`398`	`411`
`399`	`412`	`// A log method in a logging class`
Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,7 @@ namespace Microsoft.Extensions.Logging.Generators`
`6`	`6`	`using System.Collections.Generic;`
`7`	`7`	`using System.Text;`
`8`	`8`	`using Microsoft.CodeAnalysis;`
	`9`	`+ using Microsoft.CodeAnalysis.CSharp;`
`9`	`10`	`using Microsoft.CodeAnalysis.CSharp.Syntax;`
`10`	`11`	`using Microsoft.CodeAnalysis.Text;`
`11`	`12`
`@@ -30,7 +31,7 @@ public void Execute(GeneratorExecutionContext context)`
`30`	`31`	`var p = new Parser(context);`
`31`	`32`
`32`	`33`	`var types = new StringBuilder();`
`33`		`- foreach (var lc in p.GetLogClasses(receiver.InterfaceDeclarations))`
	`34`	`+ foreach (var lc in p.GetLogClasses(receiver.TypeDeclarations))`
`34`	`35`	`{`
`35`	`36`	`types.Append(GenType(lc));`
`36`	`37`	`}`
`@@ -53,7 +54,7 @@ private static string GenType(LoggerClass lc)`
`53`	`54`	`{`
`54`	`55`	`methods.Append(GenStruct(lm));`
`55`	`56`	`methods.Append(GenEventId(lm));`
`56`		`- methods.Append(GenExtensionLogMethod(lm));`
	`57`	`+ methods.Append(GenExtensionLogMethod(lc, lm));`
`57`	`58`	`}`
`58`	`59`
`59`	`60`	`var namespaceStart = string.Empty;`
`@@ -68,10 +69,9 @@ private static string GenType(LoggerClass lc)`
`68`	`69`	`return $@"`
`69`	`70`	`{namespaceStart}`
`70`	`71`	`{lc.Documentation}`
`71`		`- {lc.AccessModifiers} static class {lc.Name}`
	`72`	`+ {lc.AccessModifiers} {(lc.IsInterface ? "static" : "")} class {lc.Name}`
`72`	`73`	`{{`
`73`	`74`	`{methods}`
`74`		`- public static {lc.OriginalInterfaceName} Wrap(this ILogger logger) => new __Wrapper__(logger);`
`75`	`75`	`{GenWrapper(lc)}`
`76`	`76`	`}}`
`77`	`77`	`{namespaceEnd}`
`@@ -80,13 +80,19 @@ private static string GenType(LoggerClass lc)`
`80`	`80`
`81`	`81`	`private static string GenWrapper(LoggerClass lc)`
`82`	`82`	`{`
	`83`	`+ if (!lc.IsInterface)`
	`84`	`+ {`
	`85`	`+ return "";`
	`86`	`+ }`
`83`	`87`	`var methods = new StringBuilder();`
`84`	`88`	`foreach (var lm in lc.Methods)`
`85`	`89`	`{`
`86`	`90`	`methods.Append(GenInstanceLogMethod(lm));`
`87`	`91`	`}`
`88`	`92`
`89`	`93`	`return $@"`
	`94`	`+ public static {lc.OriginalInterfaceName} Wrap(this ILogger logger) => new __Wrapper__(logger);`
	`95`	`+`
`90`	`96`	`private sealed class __Wrapper__ : {lc.OriginalInterfaceName}`
`91`	`97`	`{{`
`92`	`98`	`private readonly ILogger __logger;`
`@@ -162,7 +168,7 @@ private static string GenInstanceLogMethod(LoggerMethod lm)`
`162`	`168`	`";`
`163`	`169`	`}`
`164`	`170`
`165`		`- private static string GenExtensionLogMethod(LoggerMethod lm)`
	`171`	`+ private static string GenExtensionLogMethod(LoggerClass lc, LoggerMethod lm)`
`166`	`172`	`{`
`167`	`173`	`string exceptionArg = "null";`
`168`	`174`	`foreach (var p in lm.Parameters)`
`@@ -174,9 +180,11 @@ private static string GenExtensionLogMethod(LoggerMethod lm)`
`174`	`180`	`}`
`175`	`181`	`}`
`176`	`182`
	`183`	`+ var loggerArg = lc.IsInterface ? "this ILogger logger" : "ILogger logger";`
	`184`	`+`
`177`	`185`	`return $@"`
`178`	`186`	`{lm.Documentation}`
`179`		`- public static void {lm.Name}(this ILogger logger{(lm.Parameters.Count > 0 ? ", " : string.Empty)}{GenParameters(lm)})`
	`187`	`+ public static {(lc.IsInterface ? "" : "partial")} void {lm.Name}({loggerArg}{(lm.Parameters.Count > 0 ? ", " : string.Empty)}{GenParameters(lm)})`
`180`	`188`	`{{`
`181`	`189`	`if (logger.IsEnabled((LogLevel){lm.Level}))`
`182`	`190`	`{{`
`@@ -299,13 +307,19 @@ private static string GenCases(LoggerMethod lm)`
`299`	`307`
`300`	`308`	`private sealed class SyntaxReceiver : ISyntaxReceiver`
`301`	`309`	`{`
`302`		`- public List<InterfaceDeclarationSyntax> InterfaceDeclarations { get; } = new();`
	`310`	`+ public List<TypeDeclarationSyntax> TypeDeclarations { get; } = new();`
`303`	`311`
`304`	`312`	`public void OnVisitSyntaxNode(SyntaxNode syntaxNode)`
`305`	`313`	`{`
`306`	`314`	`if (syntaxNode is InterfaceDeclarationSyntax interfaceSyntax && interfaceSyntax.AttributeLists.Count > 0)`
`307`	`315`	`{`
`308`		`- InterfaceDeclarations.Add(interfaceSyntax);`
	`316`	`+ TypeDeclarations.Add(interfaceSyntax);`
	`317`	`+ }`
	`318`	`+`
	`319`	`+ // Any partial class`
	`320`	`+ if (syntaxNode is ClassDeclarationSyntax { Modifiers: { Count: > 0 } modifiers } classSyntax && modifiers.Any(SyntaxKind.StaticKeyword) && modifiers.Any(SyntaxKind.PartialKeyword))`
	`321`	`+ {`
	`322`	`+ TypeDeclarations.Add(classSyntax);`
`309`	`323`	`}`
`310`	`324`	`}`
`311`	`325`	`}`