Merge pull request #318 from TNG/fix/multiple-instances-of-same-type

Deduplicate Types by Assembly Qualified Name

ArchUnitNET/Domain/Class.cs

@@ -69,6 +69,7 @@ public Class(Class @class)
         public bool IsCompilerGenerated => Type.IsCompilerGenerated;
         public string Name => Type.Name;
         public string FullName => Type.FullName;
+        public string AssemblyQualifiedName => Type.AssemblyQualifiedName;
 
         public Namespace Namespace => Type.Namespace;
         public Assembly Assembly => Type.Assembly;

ArchUnitNET/Domain/Enum.cs

@@ -22,6 +22,7 @@ public Enum(IType type)
         public IType Type { get; }
         public string Name => Type.Name;
         public string FullName => Type.FullName;
+        public string AssemblyQualifiedName => Type.AssemblyQualifiedName;
 
         [CanBeNull]
         public Class BaseClass =>

ArchUnitNET/Domain/Extensions/ArchitectureExtensions.cs

@@ -50,25 +50,16 @@ [NotNull] Type type
                 return architecture.GetInterfaceOfType(type);
             }
 
-            try
+            var foundType = AllTypes(architecture)
+                .WhereAssemblyQualifiedNameIs(type.AssemblyQualifiedName);
+            if (foundType != null)
             {
-                var foundType = AllTypes(architecture).WhereFullNameIs(type.FullName);
-                if (foundType != null)
-                {
-                    return foundType;
-                }
-
-                throw new TypeDoesNotExistInArchitecture(
-                    $"Type {type.FullName} does not exist in provided architecture."
-                );
-            }
-            catch (MultipleOccurrencesInSequenceException)
-            {
-                throw new NotSupportedException(
-                    $"Type {type.FullName} found multiple times in provided architecture. Please use extern "
-                        + "alias to reference assemblies that have the same fully-qualified type names."
-                );
+                return foundType;
             }
+
+            throw new TypeDoesNotExistInArchitecture(
+                $"Type {type.FullName} does not exist in provided architecture."
+            );
         }
 
         [NotNull]
@@ -77,25 +68,16 @@ public static Class GetClassOfType(
             [NotNull] Type type
         )
         {
-            try
+            var cls = AllClasses(architecture)
+                .WhereAssemblyQualifiedNameIs(type.AssemblyQualifiedName);
+            if (cls != null)
             {
-                var cls = AllClasses(architecture).WhereFullNameIs(type.FullName);
-                if (cls != null)
-                {
-                    return cls;
-                }
-
-                throw new TypeDoesNotExistInArchitecture(
-                    $"Type {type.FullName} does not exist in provided architecture or is no class."
-                );
-            }
-            catch (MultipleOccurrencesInSequenceException)
-            {
-                throw new NotSupportedException(
-                    $"Type {type.FullName} found multiple times in provided architecture. Please use extern "
-                        + "alias to reference assemblies that have the same fully-qualified type names."
-                );
+                return cls;
             }
+
+            throw new TypeDoesNotExistInArchitecture(
+                $"Type {type.FullName} does not exist in provided architecture or is no class."
+            );
         }
 
         [NotNull]
@@ -104,25 +86,16 @@ public static Interface GetInterfaceOfType(
             [NotNull] Type type
         )
         {
-            try
+            var intf = AllInterfaces(architecture)
+                .WhereAssemblyQualifiedNameIs(type.AssemblyQualifiedName);
+            if (intf != null)
             {
-                var intf = AllInterfaces(architecture).WhereFullNameIs(type.FullName);
-                if (intf != null)
-                {
-                    return intf;
-                }
-
-                throw new TypeDoesNotExistInArchitecture(
-                    $"Type {type.FullName} does not exist in provided architecture or is no interface."
-                );
-            }
-            catch (MultipleOccurrencesInSequenceException)
-            {
-                throw new NotSupportedException(
-                    $"Type {type.FullName} found multiple times in provided architecture. Please use extern "
-                        + "alias to reference assemblies that have the same fully-qualified type names."
-                );
+                return intf;
             }
+
+            throw new TypeDoesNotExistInArchitecture(
+                $"Type {type.FullName} does not exist in provided architecture or is no interface."
+            );
         }
 
         [NotNull]
@@ -131,25 +104,16 @@ public static Attribute GetAttributeOfType(
             [NotNull] Type type
         )
         {
-            try
+            var attribute = AllAttributes(architecture)
+                .WhereAssemblyQualifiedNameIs(type.AssemblyQualifiedName);
+            if (attribute != null)
             {
-                var attribute = AllAttributes(architecture).WhereFullNameIs(type.FullName);
-                if (attribute != null)
-                {
-                    return attribute;
-                }
-
-                throw new TypeDoesNotExistInArchitecture(
-                    $"Type {type.FullName} does not exist in provided architecture or is no attribute."
-                );
-            }
-            catch (MultipleOccurrencesInSequenceException)
-            {
-                throw new NotSupportedException(
-                    $"Type {type.FullName} found multiple times in provided architecture. Please use extern "
-                        + "alias to reference assemblies that have the same fully-qualified type names."
-                );
+                return attribute;
             }
+
+            throw new TypeDoesNotExistInArchitecture(
+                $"Type {type.FullName} does not exist in provided architecture or is no attribute."
+            );
         }
 
         [NotNull]

ArchUnitNET/Domain/Extensions/NamingExtensions.cs

@@ -102,5 +102,17 @@ public static TType WhereFullNameIs<TType>(this IEnumerable<TType> source, strin
 
             return withFullName.FirstOrDefault();
         }
+
+        [CanBeNull]
+        public static TType WhereAssemblyQualifiedNameIs<TType>(
+            this IEnumerable<TType> source,
+            string assemblyQualifiedName
+        )
+            where TType : IHasAssemblyQualifiedName
+        {
+            return source.FirstOrDefault(type =>
+                type.AssemblyQualifiedName == assemblyQualifiedName
+            );
+        }
     }
 }

ArchUnitNET/Domain/FieldMember.cs

@@ -28,18 +28,24 @@ Writability writability
             DeclaringType = declaringType;
             Name = name;
             FullName = fullName;
+            AssemblyQualifiedName = System.Reflection.Assembly.CreateQualifiedName(
+                declaringType.Assembly.FullName,
+                fullName
+            );
             Visibility = visibility;
             IsCompilerGenerated = isCompilerGenerated;
             _typeInstance = typeInstance;
             IsStatic = isStatic;
             Writability = writability;
         }
 
+        public Assembly Assembly => DeclaringType.Assembly;
+        public Namespace Namespace => DeclaringType.Namespace;
         public Visibility Visibility { get; }
-
         public IType DeclaringType { get; }
         public string Name { get; }
         public string FullName { get; }
+        public string AssemblyQualifiedName { get; }
 
         public bool IsCompilerGenerated { get; }
         public bool? IsStatic { get; }

ArchUnitNET/Domain/FunctionPointer.cs

@@ -34,6 +34,7 @@ List<ITypeInstance<IType>> parameterTypeInstances
         public bool IsGenericParameter => _type.IsGenericParameter;
         public string Name => _type.Name;
         public string FullName => _type.FullName;
+        public string AssemblyQualifiedName => _type.AssemblyQualifiedName;
         public Visibility Visibility => _type.Visibility;
         public bool IsGeneric => _type.IsGeneric;
         public List<GenericParameter> GenericParameters => _type.GenericParameters;

ArchUnitNET/Domain/GenericParameter.cs

@@ -14,37 +14,42 @@ namespace ArchUnitNET.Domain
 {
     public class GenericParameter : IType
     {
-        private readonly string _declarerFullName;
         internal readonly IEnumerable<ITypeInstance<IType>> TypeInstanceConstraints;
 
         public GenericParameter(
-            string declarerFullName,
+            ITypeInstance<IType> declaringTypeInstance,
+            [CanBeNull] MethodMemberInstance declaringMethodInstance,
+            string fullName,
             string name,
             GenericParameterVariance variance,
             IEnumerable<ITypeInstance<IType>> typeConstraints,
             bool hasReferenceTypeConstraint,
             bool hasNotNullableValueTypeConstraint,
             bool hasDefaultConstructorConstraint,
-            bool isCompilerGenerated,
-            bool declarerIsMethod
+            bool isCompilerGenerated
         )
         {
-            _declarerFullName = declarerFullName;
+            DeclaringTypeInstance = declaringTypeInstance;
+            DeclaringMethodInstance = declaringMethodInstance;
+            FullName = fullName;
             Name = name;
             Variance = variance;
             TypeInstanceConstraints = typeConstraints;
             HasReferenceTypeConstraint = hasReferenceTypeConstraint;
             HasNotNullableValueTypeConstraint = hasNotNullableValueTypeConstraint;
             HasDefaultConstructorConstraint = hasDefaultConstructorConstraint;
             IsCompilerGenerated = isCompilerGenerated;
-            DeclarerIsMethod = declarerIsMethod;
         }
 
-        public IType DeclaringType { get; private set; }
+        public ITypeInstance<IType> DeclaringTypeInstance { get; }
+        public IType DeclaringType => DeclaringTypeInstance.Type;
 
         [CanBeNull]
-        public IMember DeclaringMethod { get; private set; }
-        public bool DeclarerIsMethod { get; }
+        public MethodMemberInstance DeclaringMethodInstance { get; }
+
+        [CanBeNull]
+        public IMember DeclaringMethod => DeclaringMethodInstance?.Member;
+        public bool DeclarerIsMethod => DeclaringMethodInstance != null;
         public GenericParameterVariance Variance { get; }
         public IEnumerable<IType> TypeConstraints =>
             TypeInstanceConstraints.Select(instance => instance.Type);
@@ -59,7 +64,12 @@ bool declarerIsMethod
             || TypeConstraints.Any();
 
         public string Name { get; }
-        public string FullName => _declarerFullName + "+<" + Name + ">";
+        public string FullName { get; }
+        public string AssemblyQualifiedName =>
+            System.Reflection.Assembly.CreateQualifiedName(
+                DeclaringType.Assembly.FullName,
+                FullName
+            );
         public bool IsCompilerGenerated { get; }
         public IEnumerable<Attribute> Attributes =>
             AttributeInstances.Select(instance => instance.Type);
@@ -79,27 +89,6 @@ bool declarerIsMethod
         public bool IsNested => true;
         public bool IsStub => true;
 
-        internal void AssignDeclarer(IMember declaringMethod)
-        {
-            if (!declaringMethod.FullName.Equals(_declarerFullName))
-            {
-                throw new InvalidOperationException("Full name of declaring member doesn't match.");
-            }
-
-            DeclaringType = declaringMethod.DeclaringType;
-            DeclaringMethod = declaringMethod;
-        }
-
-        internal void AssignDeclarer(IType declaringType)
-        {
-            if (!declaringType.FullName.Equals(_declarerFullName))
-            {
-                throw new InvalidOperationException("Full name of declaring type doesn't match.");
-            }
-
-            DeclaringType = declaringType;
-        }
-
         public bool Equals(GenericParameter other)
         {
             if (ReferenceEquals(null, other))

ArchUnitNET/Domain/ICanBeAnalyzed.cs

@@ -7,7 +7,8 @@
 namespace ArchUnitNET.Domain
 {
     public interface ICanBeAnalyzed
-        : IHasName,
+        : IHasAssemblyQualifiedName,
+            IResidesInNamespace,
             IHasDependencies,
             IHasAttributes,
             IHasVisibility,

ArchUnitNET/Domain/IHasAssemblyQualifiedName.cs

@@ -0,0 +1,13 @@
+// Copyright 2019 Florian Gather <[email protected]>
+// 	Copyright 2019 Fritz Brandhuber <[email protected]>
+// 	Copyright 2020 Pavel Fischer <[email protected]>
+//
+// 	SPDX-License-Identifier: Apache-2.0
+
+namespace ArchUnitNET.Domain
+{
+    public interface IHasAssemblyQualifiedName : IHasName, IResidesInAssembly
+    {
+        string AssemblyQualifiedName { get; }
+    }
+}

ArchUnitNET/Domain/IResidesInAssembly.cs

@@ -0,0 +1,13 @@
+// Copyright 2019 Florian Gather <[email protected]>
+// 	Copyright 2019 Fritz Brandhuber <[email protected]>
+// 	Copyright 2020 Pavel Fischer <[email protected]>
+//
+// 	SPDX-License-Identifier: Apache-2.0
+
+namespace ArchUnitNET.Domain
+{
+    public interface IResidesInAssembly
+    {
+        Assembly Assembly { get; }
+    }
+}

ArchUnitNET/Domain/IResidesInNamespace.cs

@@ -0,0 +1,13 @@
+// Copyright 2019 Florian Gather <[email protected]>
+// 	Copyright 2019 Fritz Brandhuber <[email protected]>
+// 	Copyright 2020 Pavel Fischer <[email protected]>
+//
+// 	SPDX-License-Identifier: Apache-2.0
+
+namespace ArchUnitNET.Domain
+{
+    public interface IResidesInNamespace
+    {
+        Namespace Namespace { get; }
+    }
+}

ArchUnitNET/Domain/IType.cs

@@ -10,8 +10,6 @@ namespace ArchUnitNET.Domain
 {
     public interface IType : ICanBeAnalyzed
     {
-        Namespace Namespace { get; }
-        Assembly Assembly { get; }
         MemberList Members { get; }
         IEnumerable<IType> ImplementedInterfaces { get; }
         bool IsNested { get; }

ArchUnitNET/Domain/Interface.cs

@@ -21,6 +21,7 @@ public Interface(IType type)
         public IType Type { get; }
         public string Name => Type.Name;
         public string FullName => Type.FullName;
+        public string AssemblyQualifiedName => Type.AssemblyQualifiedName;
 
         public Visibility Visibility => Type.Visibility;
         public bool IsNested => Type.IsNested;