Merge pull request #71 from dansiegel/dev/ds/remove-internal-extensions

Hide internal extensions

src/CodeGenHelpers/AvantiPoint.CodeGenHelpers.csproj

@@ -2,6 +2,7 @@
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
     <IsPackable>true</IsPackable>
+    <RootNamespace>CodegenHelpers</RootNamespace>
     <Description>The AvantiPoint CodeGenHelpers are exactly what you need for your Source Generation tasks. Whether you're writing Code Generators with Roslyn's built in Source Gen or Uno Platform's Source Generator's, this helps you more powerfully generate the code you need. This combines an understanding of some system types, Roslyn Symbol's and strings. The result is beautifully formated code that's easy to read and doesn't require you to track indentations or what's already been added to the class.</Description>
     <PackageProjectUrl>https://github.com/dansiegel/CodeGenHelpers</PackageProjectUrl>
     <RepositoryUrl>https://github.com/dansiegel/CodeGenHelpers.git</RepositoryUrl>

src/CodeGenHelpers/ClassBuilder.cs

@@ -114,7 +114,7 @@ public ClassBuilder SetBaseClass(INamedTypeSymbol symbol)
         {
             if(symbol.Name == Name)
             {
-                BaseClass = $"global::{symbol.GetFullMetadataName()}";
+                BaseClass = $"global::{SymbolHelpers.GetFullMetadataName(symbol)}";
                 return this;
             }
 
@@ -338,7 +338,7 @@ internal override void Write(in CodeWriter writer)
                 IsAbstract = true;
 
             var classDeclaration = new[] {
-                AccessModifier.Code(),
+                AccessibilityHelpers.Code(AccessModifier),
                 IsStatic ? "static" : null,
                 IsSealed ? "sealed" : null,
                 IsAbstract ? "abstract" : null,

src/CodeGenHelpers/ConstructorBuilder.cs

@@ -219,7 +219,7 @@ internal override void Write(in CodeWriter writer)
             var modifier = AccessModifier switch
             {
                 null => Class.AccessModifier.ToString().ToLowerInvariant(),
-                _ => AccessModifier.Code()
+                _ => AccessibilityHelpers.Code(AccessModifier)
             };
             var parameters = _parameters.Any() ? string.Join(", ", _parameters.Select(x => x.ToString())) : string.Empty;
             using(writer.Block($"{modifier} {Class.Name}({parameters})", _baseCall.Invoke()))

src/CodeGenHelpers/DelegateBuilder.cs

@@ -140,7 +140,7 @@ internal override void Write(in CodeWriter writer)
         var parameters = _parameters.Any() ? string.Join(", ", _parameters.Select(x => x.ToString())) : string.Empty;
         var parts = new string?[]
         {
-            AccessModifier.Code(),
+            AccessibilityHelpers.Code(AccessModifier),
             "delegate",
             ReturnType is null || string.IsNullOrEmpty(ReturnType) ? "void" : ReturnType.Trim(),
             $"{Name}{_generics}({parameters})",

src/CodeGenHelpers/EnumBuilder.cs

@@ -110,7 +110,7 @@ void IBuilder.Write(in CodeWriter writer)
 
             var parts = new[]
             {
-                AccessModifier.Code(),
+                AccessibilityHelpers.Code(AccessModifier),
                 "enum",
                 Name
             };

src/CodeGenHelpers/EventBuilder.cs

@@ -175,7 +175,7 @@ internal override void Write(in CodeWriter writer)
             }
 
             var @static = _static ? "static " : string.Empty;
-            var eventDeclaration = $"{_declaredAccessibility.Code()} {@static}event {_eventDelegateType} {Name}";
+            var eventDeclaration = $"{AccessibilityHelpers.Code(_declaredAccessibility)} {@static}event {_eventDelegateType} {Name}";
             if(!string.IsNullOrEmpty(_explicitImplementation))
             {
                 eventDeclaration = $"event {@static}{_eventDelegateType} {_explicitImplementation}.{Name}";

src/CodeGenHelpers/Extensions/RoslynExtensions.cs

@@ -3,7 +3,7 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 
-namespace AvantiPoint.CodeGenHelpers.Extensions;
+namespace CodeGenHelpers.Extensions;
 
 #nullable enable
 public static class RoslynExtensions

src/CodeGenHelpers/Internals/AccessibilityHelpers.cs

@@ -0,0 +1,23 @@
+using Microsoft.CodeAnalysis;
+
+#nullable enable
+namespace CodeGenHelpers.Internals
+{
+    internal static class AccessibilityHelpers
+    {
+        public static string? Code(Accessibility accessModifier) =>
+            accessModifier switch
+            {
+                Accessibility.ProtectedAndInternal => "private protected",
+                Accessibility.ProtectedOrInternal => "protected internal",
+                Accessibility.NotApplicable => null,
+                _ => accessModifier.ToString().ToLowerInvariant()
+            };
+
+        public static string? Code(Accessibility? accessModifier) =>
+            accessModifier.HasValue ? Code(accessModifier.Value) : null;
+
+        public static string? Code(Accessibility? accessModifier, Accessibility defaultValue) =>
+            accessModifier.HasValue ? Code(accessModifier.Value) : Code(defaultValue);
+    }
+}

src/CodeGenHelpers/Internals/CodeBuilderExtensions.cs

@@ -34,7 +34,7 @@ public static string GetTypeName(this ITypeSymbol symbol)
             if (symbol.ContainingNamespace.Name == "System" && _mappings.ContainsKey(symbol.Name))
                 return _mappings[symbol.Name];
 
-            return symbol.GetFullMetadataName();
+            return SymbolHelpers.GetFullMetadataName(symbol);
         }
 
         public static string GetTypeName(this Type type)

src/CodeGenHelpers/Internals/ISymbolExtensions.cs → src/CodeGenHelpers/Internals/SymbolHelpers.cs

@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
-using CodeGenHelpers.Extensions;
 using Microsoft.CodeAnalysis;
 
 #pragma warning disable IDE0008
@@ -11,7 +10,7 @@
 #nullable enable
 namespace CodeGenHelpers.Internals
 {
-    internal static class ISymbolExtensions
+    internal static class SymbolHelpers
     {
         private static readonly Dictionary<string, string> _fullNamesMaping = new Dictionary<string, string>
             (StringComparer.OrdinalIgnoreCase)
@@ -30,7 +29,7 @@ internal static class ISymbolExtensions
                 { "bool",       typeof(bool).ToString()    },
             };
 
-        public static string GetGloballyQualifiedTypeName(this INamespaceOrTypeSymbol symbol)
+        public static string GetGloballyQualifiedTypeName(INamespaceOrTypeSymbol symbol)
         {
             var value = GetFullMetadataName(symbol);
             if(_fullNamesMaping.Any(x => x.Value == value))
@@ -45,7 +44,7 @@ public static string GetGloballyQualifiedTypeName(this INamespaceOrTypeSymbol sy
             return value;
         }
 
-        public static string GetFullMetadataName(this INamespaceOrTypeSymbol symbol)
+        public static string GetFullMetadataName(INamespaceOrTypeSymbol symbol)
         {
             ISymbol s = symbol;
             var sb = new StringBuilder(s.MetadataName);
@@ -55,7 +54,7 @@ public static string GetFullMetadataName(this INamespaceOrTypeSymbol symbol)
 
             if (s == null)
             {
-                return symbol.GetFullName();
+                return GetFullName(symbol);
             }
 
             while (!IsRootNamespace(s))
@@ -89,16 +88,16 @@ private static bool IsRootNamespace(ISymbol s)
             return s is INamespaceSymbol symbol && symbol.IsGlobalNamespace;
         }
 
-        public static string GetFullName(this INamespaceOrTypeSymbol type)
+        public static string GetFullName(INamespaceOrTypeSymbol type)
         {
             if (type is IArrayTypeSymbol arrayType)
             {
-                return $"{arrayType.ElementType.GetFullName()}[]";
+                return $"{GetFullName(arrayType.ElementType)}[]";
             }
 
-            if (((ITypeSymbol)type).IsNullable(out var t) && t != null)
+            if (IsNullable((ITypeSymbol)type, out var t) && t != null)
             {
-                return $"System.Nullable`1[{t.GetFullName()}]";
+                return $"System.Nullable`1[{GetFullName(t)}]";
             }
 
             var name = type.ToDisplayString() ?? string.Empty;
@@ -110,5 +109,68 @@ public static string GetFullName(this INamespaceOrTypeSymbol type)
 
             return output;
         }
+
+        public static string GetQualifiedTypeName(ITypeSymbol typeSymbol)
+        {
+            var type = typeSymbol.GetTypeName();
+            if (!type.Contains(".") || typeSymbol is not INamedTypeSymbol namedTypeSymbol)
+            {
+                return type;
+            }
+
+            var @namespace = namedTypeSymbol.ContainingNamespace.ToString();
+            var typeName = namedTypeSymbol.Name;
+
+            if (typeSymbol.ContainingType is not null)
+            {
+                return $"{GetQualifiedTypeName(typeSymbol.ContainingType)}.{typeSymbol.Name}";
+            }
+
+            var fullyQualifiedName = $"{@namespace}.{typeName}";
+
+            if (namedTypeSymbol.IsGenericType)
+            {
+                var generics = namedTypeSymbol.TypeArguments.Select(x => GetQualifiedTypeName(x));
+                var baseName = fullyQualifiedName;
+                var nullable = string.Empty;
+                if (baseName.EndsWith("?", StringComparison.InvariantCulture))
+                {
+                    baseName = baseName.Substring(0, baseName.Length - 1);
+                    nullable = "?";
+                }
+
+                fullyQualifiedName = $"{baseName}<{string.Join(", ", generics)}>{nullable}";
+            }
+
+            if (fullyQualifiedName.Contains(".") && !fullyQualifiedName.StartsWith("global::", StringComparison.InvariantCulture))
+            {
+                fullyQualifiedName = $"global::{fullyQualifiedName}";
+            }
+
+            return fullyQualifiedName;
+        }
+
+        public static bool IsNullable(ITypeSymbol type)
+        {
+            if (type.NullableAnnotation == NullableAnnotation.Annotated)
+                return true;
+
+            return ((type as INamedTypeSymbol)?.IsGenericType ?? false)
+                && type.OriginalDefinition.ToDisplayString().Equals("System.Nullable<T>", StringComparison.OrdinalIgnoreCase);
+        }
+
+        public static bool IsNullable(ITypeSymbol type, out ITypeSymbol? nullableType)
+        {
+            if (IsNullable(type))
+            {
+                nullableType = type.NullableAnnotation == NullableAnnotation.Annotated ? type : ((INamedTypeSymbol)type).TypeArguments.First();
+                return true;
+            }
+            else
+            {
+                nullableType = null;
+                return false;
+            }
+        }
     }
 }

src/CodeGenHelpers/MethodBuilder.cs

@@ -226,7 +226,7 @@ internal override void Write(in CodeWriter writer)
                 output = $"static {output}";
 
             var parameters = string.Join(", ", _parameters.Select(x => x.ToString()));
-            output = $"{AccessModifier.Code()} {output} {Name}{_generics}({parameters})";
+            output = $"{AccessibilityHelpers.Code(AccessModifier)} {output} {Name}{_generics}({parameters})";
 
             if(_xmlDoc is ParameterDocumentationComment parameterDocumentation)
                 parameterDocumentation.RemoveUnusedParameters(_parameters);

src/CodeGenHelpers/ParameterizedExtensions.cs

@@ -34,7 +34,7 @@ public static T AddParameter<T>(this IParameterized<T> parameterized, ITypeSymbo
             where T : BuilderBase<T>, IParameterized<T>
         {
             parameterized.Parent.AddNamespaceImport(typeSymbol);
-            return parameterized.AddParameter(typeSymbol.GetGloballyQualifiedTypeName(), parameterName);
+            return parameterized.AddParameter(SymbolHelpers.GetGloballyQualifiedTypeName(typeSymbol), parameterName);
         }
 
         public static T AddParameter<T>(this IParameterized<T> parameterized, string typeName, string parameterName, int index)

src/CodeGenHelpers/PropertyBuilder.cs

@@ -275,11 +275,11 @@ void IBuilder.Write(in CodeWriter writer)
 
             var output = (FieldTypeValue switch
             {
-                FieldType.Const => $"{AccessModifier.Code()}{isNew} const {type} {name}",
-                FieldType.ReadOnly => $"{AccessModifier.Code()}{isNew}{_static} readonly {type} {name}",
+                FieldType.Const => $"{AccessibilityHelpers.Code(AccessModifier)}{isNew} const {type} {name}",
+                FieldType.ReadOnly => $"{AccessibilityHelpers.Code(AccessModifier)}{isNew}{_static} readonly {type} {name}",
                 _ => additionalModifier is null
-                    ? $"{AccessModifier.Code()}{isNew}{_static} {type} {name}"
-                    : $"{AccessModifier.Code()} {additionalModifier} {type} {name}"
+                    ? $"{AccessibilityHelpers.Code(AccessModifier)}{isNew}{_static} {type} {name}"
+                    : $"{AccessibilityHelpers.Code(AccessModifier)} {additionalModifier} {type} {name}"
             }).Trim();
 
             var maxCharacters = (value?.StartsWith("\"") ?? false) ? 9 : 5;
@@ -312,7 +312,7 @@ void IBuilder.Write(in CodeWriter writer)
                     return;
                 }
 
-                var set = $"{_setterAccessibility.Code()} set".Trim();
+                var set = $"{AccessibilityHelpers.Code(_setterAccessibility)} set".Trim();
                 writer.AppendLine($"{output} {{ get; {set}; }}");
                 return;
             }

src/CodeGenHelpers/RecordBuilder.cs

@@ -97,7 +97,7 @@ internal override void Write(in CodeWriter writer)
 
             if (PropertyType == RecordPropertyType.Init)
             {
-                using (writer.Block($"{AccessModifier.Code()} record {Name}"))
+                using (writer.Block($"{AccessibilityHelpers.Code(AccessModifier)} record {Name}"))
                 {
                     foreach (RecordPropertyBuilder property in _properties)
                     {
@@ -109,7 +109,7 @@ internal override void Write(in CodeWriter writer)
             }
 
             var properties = _properties.Any() ? string.Join(", ", _properties.Select(x => x.ToPositionalProperty())) : string.Empty;
-            writer.AppendLine($"{AccessModifier.Code()} record {Name}({properties});");
+            writer.AppendLine($"{AccessibilityHelpers.Code(AccessModifier)} record {Name}({properties});");
         }
 
         public override RecordBuilder AddNamespaceImport(string importedNamespace)