commented up MemberDeclarationParser

1 files changed, 108 insertions, 71 deletions

diff --git a/SharpSwift/SharpSwift/Converters/MemberDeclarationParser.cs b/SharpSwift/SharpSwift/Converters/MemberDeclarationParser.cs
index 1ccf5a0..c11a122 100644
--- a/SharpSwift/SharpSwift/Converters/MemberDeclarationParser.cs
+++ b/SharpSwift/SharpSwift/Converters/MemberDeclarationParser.cs
@@ -1,7 +1,4 @@
 using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Diagnostics;
 using System.Linq;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
@@ -11,122 +8,143 @@ namespace SharpSwift.Converters
 {
     partial class ConvertToSwift
     {
+        /// <summary>
+        /// Parses an attribute
+        /// </summary>
+        /// <param name="attributeLists">The list of attributes to parse</param>
+        /// <param name="separator">The separator to use between attributes</param>
+        /// <returns>A tuple where the first value is the Swift attributes and the second contains the value of an ExportAttribute</returns>
         private static Tuple<string, string> ParseAttributes(SyntaxList<AttributeListSyntax> attributeLists, string separator = " ")
         {
+            if (!attributeLists.Any()) return new Tuple<string, string>("", null);
+
             var output = "";
             string exportAs = null;
 
-            if (attributeLists.Any())
+            foreach (var attribute in attributeLists.SelectMany(attrList => attrList.Attributes))
             {
-                foreach (var attrList in attributeLists)
+                if (IsSharpSwiftAttribute(attribute, "ExportAttribute"))
                 {
-                    foreach (var attribute in attrList.Attributes)
-                    {
-                        if (IsSharpSwiftAttribute(attribute, "ExportAttribute"))
-                        {
-                            exportAs = SyntaxNode(attribute.ArgumentList.Arguments[0].Expression).Trim().Trim('"');
-                            continue;
-                        }
-
-                        output += SyntaxNode(attribute) + separator;
-                    }
+                    exportAs = SyntaxNode(attribute.ArgumentList.Arguments[0].Expression).Trim().Trim('"');
+                    continue;
                 }
+
+                output += SyntaxNode(attribute) + separator;
             }
 
             return new Tuple<string, string>(output, exportAs);
         }
 
+        /// <summary>
+        /// Converts member declaration modifiers to Swift
+        /// NOTE that internal will be converted to public, as Swift doesn't have an internal modifier
+        /// </summary>
+        /// <example>public readonly</example>
+        /// <param name="modifiers">The modifiers to convert</param>
+        /// <returns>The converted Swift modifiers</returns>
         private static string ParseModifiers(SyntaxTokenList modifiers)
         {
-            return string.Join(" ", modifiers.Select(modifier =>
-            {
-                switch (modifier.Text)
-                {
-                    case "internal":
-                        return "public"; //Swift doesn't have internal
-                    default:
-                        return modifier.Text;
-                }
-            })) + " ";
+            return string.Join(" ", modifiers.Select(modifier => 
+                modifier.Text == "internal" ? "public" : modifier.Text)) + " ";
         }
 
-        //TODO: rewrite the MemberDeclarationParsers
-
+        /// <summary>
+        /// Converts a class declaration to Swift
+        /// </summary>
+        /// <example>public class SomeClass { }</example>
+        /// <param name="declaration">The class to convert</param>
+        /// <returns>The converted Swift class</returns>
         [ParsesType(typeof (ClassDeclarationSyntax))]
-        public static string ClassDeclaration(ClassDeclarationSyntax node)
+        public static string ClassDeclaration(ClassDeclarationSyntax declaration)
         {
-            var parsedAttributes = ParseAttributes(node.AttributeLists, NewLine);
+            var parsedAttributes = ParseAttributes(declaration.AttributeLists, NewLine);
 
             var output = parsedAttributes.Item1;
             var nameToUse = parsedAttributes.Item2;
 
-            output += "class " + (nameToUse ?? node.Identifier.Text);
+            output += "class " + (nameToUse ?? declaration.Identifier.Text);
 
             //parse the base type, if there is one
-            if (node.BaseList != null)
+            if (declaration.BaseList != null)
             {
-                var baseType = node.BaseList.Types.OfType<IdentifierNameSyntax>().FirstOrDefault();
+                var baseType = declaration.BaseList.Types.OfType<IdentifierNameSyntax>().FirstOrDefault();
                 output += ": " + SyntaxNode(baseType);
             }
             output += " {" + NewLine;
 
-            output += string.Join("", node.Members.Select(SyntaxNode));
+            output += string.Join("", declaration.Members.Select(SyntaxNode));
 
             return output + "}" + NewLine + NewLine;
         }
 
+        /// <summary>
+        /// Converts a method to Swift
+        /// </summary>
+        /// <example>public void Something() { }</example>
+        /// <param name="method">The method to convert</param>
+        /// <returns>The converted Swift method</returns>
         [ParsesType(typeof (MethodDeclarationSyntax))]
-        public static string MethodDeclaration(MethodDeclarationSyntax node)
+        public static string MethodDeclaration(MethodDeclarationSyntax method)
         {
-            var parsedAttributes = ParseAttributes(node.AttributeLists);
+            var parsedAttributes = ParseAttributes(method.AttributeLists);
 
             var output = parsedAttributes.Item1;
             var nameToUse = parsedAttributes.Item2;
 
-            output += ParseModifiers(node.Modifiers);
+            output += ParseModifiers(method.Modifiers);
 
-            output += "func " + (nameToUse ?? node.Identifier.Text);
+            output += "func " + (nameToUse ?? method.Identifier.Text);
 
-            if (node.TypeParameterList != null) //public string Something<T>
+            if (method.TypeParameterList != null) //public string Something<T>
             {
-                output += SyntaxNode(node.TypeParameterList);
+                output += SyntaxNode(method.TypeParameterList);
             }
 
-            output += SyntaxNode(node.ParameterList);
+            output += SyntaxNode(method.ParameterList);
 
-            if (node.ReturnType != null)
+            if (method.ReturnType != null)
             {
-                output += " -> " + SyntaxNode(node.ReturnType);
+                output += " -> " + SyntaxNode(method.ReturnType);
             }
 
-            return output + " " + SyntaxNode(node.Body);
+            return output + " " + SyntaxNode(method.Body);
         }
 
-
+        /// <summary>
+        /// Converts an enum member to Swift
+        /// </summary>
+        /// <example>name = 1</example>
+        /// <param name="declaration">The declaration to convert</param>
+        /// <returns>The converted Swift declaration</returns>
         [ParsesType(typeof(EnumMemberDeclarationSyntax))]
-        public static string EnumMemberDeclaration(EnumMemberDeclarationSyntax node)
+        public static string EnumMemberDeclaration(EnumMemberDeclarationSyntax declaration)
         {
-            var output = node.Identifier.Text;
-            if (node.EqualsValue != null)
+            var output = declaration.Identifier.Text;
+            if (declaration.EqualsValue != null)
             {
-                output += " " + SyntaxNode(node.EqualsValue);
+                output += " " + SyntaxNode(declaration.EqualsValue);
             }
             return output;
         }
 
+        /// <summary>
+        /// Converts an enum to Swift
+        /// </summary>
+        /// <example>public enum thing { }</example>
+        /// <param name="declaration">The enum declaration to convert</param>
+        /// <returns>The converted Swift enum</returns>
         [ParsesType(typeof (EnumDeclarationSyntax))]
-        public static string EnumDeclaration(EnumDeclarationSyntax node)
+        public static string EnumDeclaration(EnumDeclarationSyntax declaration)
         {
-            //TODO: parse EnumMemberDeclaration separately
-            var parsedAttributes = ParseAttributes(node.AttributeLists);
+            var parsedAttributes = ParseAttributes(declaration.AttributeLists);
 
             var output = parsedAttributes.Item1;
             var nameToUse = parsedAttributes.Item2;
 
-            output += "enum " + (nameToUse ?? node.Identifier.Text);
+            output += "enum " + (nameToUse ?? declaration.Identifier.Text);
 
             //Get the value of the enum
-            foreach (var decl in node.ChildNodes().OfType<EnumMemberDeclarationSyntax>().Where(decl => decl.EqualsValue != null).Select(decl => decl.EqualsValue.Value))
+            foreach (var decl in declaration.ChildNodes().OfType<EnumMemberDeclarationSyntax>().Where(decl => decl.EqualsValue != null).Select(decl => decl.EqualsValue.Value))
             {
                 if (decl.IsKind(SyntaxKind.StringLiteralExpression))
                 {
@@ -147,10 +165,9 @@ namespace SharpSwift.Converters
                 break;
             }
 
-            output += " {" + NewLine;
-
-            output += string.Join("," + NewLine, node.Members.Select(SyntaxNode)) + NewLine + "}" + NewLine + NewLine;
-            return output;
+            return output + " {" + NewLine +
+                             string.Join("," + NewLine, declaration.Members.Select(SyntaxNode)) + NewLine +
+                             "}" + NewLine + NewLine;
         }
 
         [ParsesType(typeof(AccessorDeclarationSyntax))]
@@ -160,50 +177,70 @@ namespace SharpSwift.Converters
             return SyntaxNode(node.Body);
         }
 
+        /// <summary>
+        /// Converts a field declaration to Swift
+        /// </summary>
+        /// <param name="declaration">The declarationt to convert</param>
+        /// <returns>The converted Swift code</returns>
         [ParsesType(typeof(FieldDeclarationSyntax))]
-        public static string FieldDeclaration(FieldDeclarationSyntax node)
+        public static string FieldDeclaration(FieldDeclarationSyntax declaration)
         {
-            var parsedAttributes = ParseAttributes(node.AttributeLists);
+            var parsedAttributes = ParseAttributes(declaration.AttributeLists);
 
             var output = parsedAttributes.Item1;
             var nameToUse = parsedAttributes.Item2;
 
             //TODO: handle ExportAttribute
-            return output + SyntaxNode(node.Declaration) + Semicolon(node.SemicolonToken);
+            return output + SyntaxNode(declaration.Declaration) + Semicolon(declaration.SemicolonToken);
         }
 
+        /// <summary>
+        /// Converts a property declaration to Swift
+        /// </summary>
+        /// <param name="declaration">The declaration to convert</param>
+        /// <returns>The converted Swift code</returns>
         [ParsesType(typeof (PropertyDeclarationSyntax))]
-        public static string PropertyDeclaration(PropertyDeclarationSyntax node)
+        public static string PropertyDeclaration(PropertyDeclarationSyntax declaration)
         {
-            var parsedAttributes = ParseAttributes(node.AttributeLists);
+            var parsedAttributes = ParseAttributes(declaration.AttributeLists);
 
             var output = parsedAttributes.Item1;
             var nameToUse = parsedAttributes.Item2;
 
-            output += "var " + (nameToUse ?? node.Identifier.Text);
-            output += ": " + SyntaxNode(node.Type);
+            output += "var " + (nameToUse ?? declaration.Identifier.Text);
+            output += ": " + SyntaxNode(declaration.Type);
             //accessors not supported yet, basically makes a field
-            return output + Semicolon(node.SemicolonToken);
+            return output + Semicolon(declaration.SemicolonToken);
         }
 
+        /// <summary>
+        /// Converts a constructor to Swift
+        /// </summary>
+        /// <param name="constructor">The constructor to convert</param>
+        /// <returns>The converted Swift constructor</returns>
         [ParsesType(typeof (ConstructorDeclarationSyntax))]
-        public static string ConstructorDeclaration(ConstructorDeclarationSyntax node)
+        public static string ConstructorDeclaration(ConstructorDeclarationSyntax constructor)
         {
-            var parsedAttributes = ParseAttributes(node.AttributeLists);
+            var parsedAttributes = ParseAttributes(constructor.AttributeLists);
 
             var output = parsedAttributes.Item1;
 
-            return output + "init" + SyntaxNode(node.ParameterList) + " " + Block(node.Body);
+            return output + "init" + SyntaxNode(constructor.ParameterList) + " " + Block(constructor.Body);
         }
 
+        /// <summary>
+        /// Converts a destructor to Swift
+        /// </summary>
+        /// <param name="destructor">The destructor to convert</param>
+        /// <returns>The converted Swift destructor</returns>
         [ParsesType(typeof(DestructorDeclarationSyntax))]
-        public static string DestructorDeclaration(DestructorDeclarationSyntax node)
+        public static string DestructorDeclaration(DestructorDeclarationSyntax destructor)
         {
-            var parsedAttributes = ParseAttributes(node.AttributeLists);
+            var parsedAttributes = ParseAttributes(destructor.AttributeLists);
 
             var output = parsedAttributes.Item1;
 
-            return output + "deinit " + Block(node.Body);
+            return output + "deinit " + Block(destructor.Body);
         }
     }
 }
\ No newline at end of file