code cleanup and refactoring to simplify LiteralExpression / Attribut…

…es handling easier
adrianoc · Mar 8, 2024 · 26bdd89 · 26bdd89
1 parent 0da71d3
commit 26bdd89
Show file tree

Hide file tree

Showing 6 changed files with 26 additions and 19 deletions.
diff --git a/Cecilifier.Core/AST/EnumDeclarationVisitor.cs b/Cecilifier.Core/AST/EnumDeclarationVisitor.cs
@@ -111,18 +111,9 @@ public override int VisitEnumMemberDeclaration(EnumMemberDeclarationSyntax node)
 
             public override int VisitLiteralExpression(LiteralExpressionSyntax node)
             {
-                if (node.Kind() != SyntaxKind.NumericLiteralExpression)
-                {
-                    throw new InvalidOperationException($"Invalid literal type: {node}");
-                }
-
-                var value = node.ToString();
-                if (value.StartsWith("0x"))
-                {
-                    return Convert.ToInt32(value.Substring(2), 16);
-                }
-
-                return int.Parse(value);
+                return node.TryGetLiteralValueFor<int>(out var value) 
+                    ? value 
+                    : throw new InvalidOperationException($"Invalid literal type: {node}");
             }
 
             public override int VisitBinaryExpression(BinaryExpressionSyntax node)

diff --git a/Cecilifier.Core/AST/ExpressionVisitor.cs b/Cecilifier.Core/AST/ExpressionVisitor.cs
@@ -3,6 +3,7 @@
 using System.Collections.Immutable;
 using System.Diagnostics;
 using System.Linq;
+using System.Runtime.CompilerServices;
 using Cecilifier.Core.CodeGeneration;
 using Cecilifier.Core.Extensions;
 using Cecilifier.Core.Misc;
@@ -1388,8 +1389,7 @@ private void ProcessArgumentsTakingDefaultParametersIntoAccount(ISymbol? method,
 
         private string ArgumentValueToUseForDefaultParameter(IParameterSymbol arg, ImmutableArray<IParameterSymbol> parameters, SeparatedSyntaxList<ArgumentSyntax> arguments)
         {
-            var callerArgumentExpressionAttribute = arg.GetAttributes().SingleOrDefault(attr => attr.AttributeClass!.MetadataToken == Context.RoslynTypeSystem.CallerArgumentExpressionAttribute.MetadataToken);
-            if (callerArgumentExpressionAttribute != null)
+            if (arg.TryGetAttribute<CallerArgumentExpressionAttribute>(out var callerArgumentExpressionAttribute))
             {
                 var expressionParameter = parameters.SingleOrDefault(p => p.Name == (string) callerArgumentExpressionAttribute.ConstructorArguments[0].Value);
                 if (expressionParameter != null)

diff --git a/Cecilifier.Core/AST/SyntaxWalkerBase.cs b/Cecilifier.Core/AST/SyntaxWalkerBase.cs
@@ -305,8 +305,7 @@ private static void AppendStructLayoutTo(ITypeSymbol typeSymbol, StringBuilder t
             if (typeSymbol.TypeKind != TypeKind.Struct)
                 return;
 
-            var structLayoutAttribute = typeSymbol.GetAttributes().FirstOrDefault(attrData => attrData.AttributeClass.FullyQualifiedName().Equals("System.Runtime.InteropServices.StructLayoutAttribute"));
-            if (structLayoutAttribute == null)
+            if (!typeSymbol.TryGetAttribute<StructLayoutAttribute>(out var structLayoutAttribute))
             {
                 typeAttributes.AppendModifier("TypeAttributes.SequentialLayout");
             }
@@ -858,8 +857,8 @@ private static IEnumerable<string> ProcessStructLayoutAttribute(AttributeSyntax
             static int AssignedValue(AttributeSyntax attribute, string parameterName)
             {
                 // whenever Size/Pack are omitted the corresponding property should be set to 0. See Ecma-335 II 22.8.
-                var parameterAssignmentExpression = attribute.ArgumentList?.Arguments.FirstOrDefault(a => a.NameEquals?.Name.Identifier.Text == parameterName)?.Expression;
-                return parameterAssignmentExpression != null ? Int32.Parse(((LiteralExpressionSyntax) parameterAssignmentExpression).Token.Text) : 0;
+                var parameterAssignmentExpression = (LiteralExpressionSyntax) attribute.ArgumentList?.Arguments.FirstOrDefault(a => a.NameEquals?.Name.Identifier.Text == parameterName)?.Expression;
+                return parameterAssignmentExpression?.TryGetLiteralValueFor<int>(out var ret) == true ? ret : 0;
             }
         }
 

diff --git a/Cecilifier.Core/Extensions/ISymbolExtensions.cs b/Cecilifier.Core/Extensions/ISymbolExtensions.cs
@@ -240,5 +240,12 @@ public static IMethodSymbol Ctor(this ITypeSymbol self, params ITypeSymbol[] par
             SymbolKind.Parameter => VariableMemberKind.Parameter,
             _ => throw new ArgumentException($"Invalid symbol type for '{self}' ({self.Kind})")
         };
+
+        public static bool TryGetAttribute<T>(this ISymbol symbol, [NotNullWhen(true)] out AttributeData attributeData) where T : Attribute
+        {
+            var typeOfT = typeof(T);
+            attributeData = symbol.GetAttributes().SingleOrDefault(attr => attr.AttributeClass?.Name == typeOfT.Name);
+            return attributeData != null;
+        }
     }
 }
diff --git a/Cecilifier.Core/Extensions/StringExtensions.cs b/Cecilifier.Core/Extensions/StringExtensions.cs
@@ -54,7 +54,7 @@ internal static string[] CloneMethodReferenceOverriding(this string methodRef, I
             return exps.ToArray();
         }
 
-        public static int CountNewLines(this string value) => value.Count(ch => ch == '\n');
+        public static int CountNewLines(this string value) => value.AsSpan().Count('\n');
 
         private static List<string> methodReferencePropertiesToClone = new()
         {

diff --git a/Cecilifier.Core/Extensions/SyntaxNodeExtensions.cs b/Cecilifier.Core/Extensions/SyntaxNodeExtensions.cs
@@ -144,5 +144,15 @@ internal static bool IsArgumentPassedToReferenceTypeParameter(this SyntaxNode to
         }
 
         internal static bool IsMemberAccessOnElementAccess(this SyntaxNode self) => self.IsKind(SyntaxKind.ElementAccessExpression) && self.Parent is MemberAccessExpressionSyntax mae && mae.Expression == self;
+
+        internal static bool TryGetLiteralValueFor<T>(this ExpressionSyntax expressionSyntax, out T value)
+        {
+            value = default;
+            if (expressionSyntax is not LiteralExpressionSyntax literalExpression)
+                return false;
+
+            value = (T) literalExpression.Token.Value;
+            return true;
+        }
     }
 }