Code cleanup

Author: duckdoom5

src/AST/Type.cs

@@ -4,14 +4,12 @@ public static class TypeExtensions
     {
         public static bool IsPrimitiveType(this Type t)
         {
-            PrimitiveType type;
-            return t.IsPrimitiveType(out type);
+            return t.IsPrimitiveType(out PrimitiveType _);
         }
 
         public static bool IsPrimitiveType(this Type t, out PrimitiveType primitive)
         {
-            var builtin = t.Desugar() as BuiltinType;
-            if (builtin != null)
+            if (t.Desugar() is BuiltinType builtin)
             {
                 primitive = builtin.Type;
                 return true;
@@ -32,9 +30,7 @@ public static bool IsPrimitiveType(this Type t, PrimitiveType primitive)
 
         public static bool IsEnumType(this Type t)
         {
-            var tag = t.Desugar() as TagType;
-
-            if (tag == null)
+            if (t.Desugar() is not TagType tag)
                 return false;
 
             return tag.Declaration is Enumeration;
@@ -47,36 +43,28 @@ public static bool IsAddress(this Type t)
 
         public static bool IsPointer(this Type t)
         {
-            var functionPointer = t as MemberPointerType;
-            if (functionPointer != null)
+            if (t is MemberPointerType)
                 return true;
-            var pointer = t as PointerType;
-            if (pointer == null)
+
+            if (t is not PointerType pointer)
                 return false;
+
             return pointer.Modifier == PointerType.TypeModifier.Pointer;
         }
 
         public static bool IsReference(this Type t)
         {
-            var pointer = t as PointerType;
-            if (pointer == null)
-                return false;
-            return pointer.IsReference;
+            return t is PointerType { IsReference: true };
         }
 
         public static bool IsPointerToPrimitiveType(this Type t)
         {
-            var ptr = t as PointerType;
-            if (ptr == null)
-                return false;
-            PrimitiveType primitiveType;
-            return ptr.Pointee.IsPrimitiveType(out primitiveType);
+            return t is PointerType ptr && ptr.Pointee.IsPrimitiveType(out _);
         }
 
         public static bool IsPointerToPrimitiveType(this Type t, out PrimitiveType primitive)
         {
-            var ptr = t as PointerType;
-            if (ptr == null)
+            if (t is not PointerType ptr)
             {
                 primitive = PrimitiveType.Null;
                 return false;
@@ -86,24 +74,21 @@ public static bool IsPointerToPrimitiveType(this Type t, out PrimitiveType primi
 
         public static bool IsPointerToPrimitiveType(this Type t, PrimitiveType primitive)
         {
-            var ptr = t as PointerType;
-            if (ptr == null)
+            if (t is not PointerType ptr)
                 return false;
             return ptr.Pointee.IsPrimitiveType(primitive);
         }
 
         public static bool IsPointerToEnum(this Type t)
         {
-            var ptr = t as PointerType;
-            if (ptr == null)
+            if (t is not PointerType ptr)
                 return false;
             return ptr.Pointee.IsEnumType();
         }
 
         public static bool IsPointerToEnum(this Type t, out Enumeration @enum)
         {
-            var ptr = t as PointerType;
-            if (ptr == null)
+            if (t is not PointerType ptr)
             {
                 @enum = null;
                 return false;
@@ -113,33 +98,31 @@ public static bool IsPointerToEnum(this Type t, out Enumeration @enum)
 
         public static bool IsPointerTo<T>(this Type t, out T type) where T : Type
         {
-            var pointee = t.GetPointee();
-            type = pointee as T;
-            if (type == null)
-            {
-                var attributedType = pointee as AttributedType;
-                if (attributedType != null)
-                    type = attributedType.Modified.Type as T;
-            }
+            type = t.GetPointee() as T;
+            if (type != null) 
+                return true;
+
+            if (type is AttributedType attributedType)
+                type = attributedType.Modified.Type as T;
             return type != null;
         }
 
         public static bool IsClass(this Type t)
         {
-            Class @class;
-            return t.TryGetClass(out @class);
+            return t.TryGetClass(out _);
         }
 
         public static bool TryGetClass(this Type t, out Class @class, Class value = null)
         {
             return TryGetDeclaration(t, out @class, value);
         }
 
-        public static bool TryGetDeclaration<T>(this Type t, out T decl, T value = null) where T : Declaration
+        public static bool TryGetDeclaration<T>(this Type t, out T decl, T value = null)
+            where T : Declaration
         {
             t = t.Desugar();
 
-            TagType tagType = null;
+            TagType tagType;
             if (t is TemplateSpecializationType type)
             {
                 if (type.IsDependent)
@@ -193,15 +176,12 @@ public static bool TryGetDeclaration<T>(this Type t, out T decl, T value = null)
 
         public static bool IsEnum(this Type t)
         {
-            Enumeration @enum;
-            return t.TryGetEnum(out @enum);
+            return t.TryGetEnum(out _);
         }
 
         public static bool TryGetEnum(this Type t, out Enumeration @enum)
         {
-            var tag = t.Desugar() as TagType;
-
-            if (tag == null)
+            if (t.Desugar() is not TagType tag)
             {
                 @enum = null;
                 return false;
@@ -269,13 +249,12 @@ public static Type SkipPointerRefs(this Type t)
         /// </summary>
         public static Type GetPointee(this Type t)
         {
-            var ptr = t as PointerType;
-            if (ptr != null)
-                return ptr.Pointee;
-            var memberPtr = t as MemberPointerType;
-            if (memberPtr != null)
-                return memberPtr.QualifiedPointee.Type;
-            return null;
+            return t switch
+            {
+                PointerType ptr => ptr.Pointee,
+                MemberPointerType memberPtr => memberPtr.QualifiedPointee.Type,
+                _ => null
+            };
         }
 
         /// <summary>
@@ -296,17 +275,28 @@ public static Type GetFinalPointee(this Type t)
             return finalPointee;
         }
 
+        public static PointerType GetFinalPointer(this Type t)
+        {
+            if (t is not PointerType type)
+                return null;
+
+            var pointee = type.Desugar().GetPointee();
+
+            if (pointee.IsPointer())
+                return pointee.GetFinalPointer();
+
+            return type;
+        }
+
         /// <summary>
         /// If t is a pointer type the type pointed to by t will be returned.
         /// Otherwise the default qualified type.
         /// </summary>
         public static QualifiedType GetQualifiedPointee(this Type t)
         {
-            var ptr = t as PointerType;
-            if (ptr != null)
+            if (t is PointerType ptr)
                 return ptr.QualifiedPointee;
-            var memberPtr = t as MemberPointerType;
-            if (memberPtr != null)
+            if (t is MemberPointerType memberPtr)
                 return memberPtr.QualifiedPointee;
             return new QualifiedType();
         }
@@ -329,31 +319,14 @@ public static QualifiedType GetFinalQualifiedPointee(this Type t)
             return finalPointee;
         }
 
-        public static PointerType GetFinalPointer(this Type t)
-        {
-            var type = t as PointerType;
-
-            if (type == null)
-                return null;
-
-            var pointee = type.Desugar().GetPointee();
-
-            if (pointee.IsPointer())
-                return pointee.GetFinalPointer();
-
-            return type;
-        }
-
         public static bool ResolvesTo(this QualifiedType type, QualifiedType other)
         {
             if (!type.Qualifiers.Equals(other.Qualifiers))
                 return false;
 
             var left = type.Type.Desugar();
             var right = other.Type.Desugar();
-            var leftPointer = left as PointerType;
-            var rightPointer = right as PointerType;
-            if (leftPointer != null && rightPointer != null)
+            if (left is PointerType leftPointer && right is PointerType rightPointer)
             {
                 return leftPointer.Modifier == rightPointer.Modifier &&
                     leftPointer.QualifiedPointee.ResolvesTo(rightPointer.QualifiedPointee);
@@ -388,8 +361,7 @@ public static QualifiedType StripConst(this QualifiedType type)
             qualifiers.IsConst = false;
             type.Qualifiers = qualifiers;
 
-            var ptr = type.Type as PointerType;
-            if (ptr != null)
+            if (type.Type is PointerType ptr)
             {
                 var pointee = ptr.QualifiedPointee;
                 var pointeeQualifiers = pointee.Qualifiers;

src/AST/TypeExtensions.cs

@@ -5,7 +5,7 @@ namespace CppSharp.AST
     /// </summary>
     public abstract class TypedefNameDecl : Declaration, ITypedDecl
     {
-        public Type Type { get { return QualifiedType.Type; } }
+        public Type Type => QualifiedType.Type;
         public QualifiedType QualifiedType { get; set; }
         public bool IsSynthetized { get; set; }
     }

src/AST/Typedef.cs

@@ -9,19 +9,19 @@
 
 #include "Helpers.h"
 
-namespace CppSharp { namespace CppParser {
+namespace CppSharp::CppParser {
 
-    struct CS_API CS_VALUE_TYPE SourceLocation
-    {
-        SourceLocation();
-        SourceLocation(unsigned ID);
-        unsigned ID;
-    };
+struct CS_API CS_VALUE_TYPE SourceLocation
+{
+    SourceLocation();
+    SourceLocation(unsigned ID);
+    unsigned ID;
+};
 
-    struct CS_API SourceRange
-    {
-        SourceLocation beginLoc;
-        SourceLocation endLoc;
-    };
+struct CS_API SourceRange
+{
+    SourceLocation beginLoc;
+    SourceLocation endLoc;
+};
 
-}} // namespace CppSharp::CppParser
+} // namespace CppSharp::CppParser