15173156024

Committed 21 May 2025 09:41PM UTC coverage: 34.291% (+0.2%) from 34.062%

Build # 15173156024

Build Type

Pull #462

github

Committed by

web-flow

Commit Message

Merge 01e84d727 into 5807d2b6c

Pull Request Pull Request #462: Support overriding anything

Run Details

1801 of 6646 branches covered (27.1%)

Branch coverage included in aggregate %.

133 of 243 new or added lines in 35 files covered. (54.73%)

5 existing lines in 5 files now uncovered.

4201 of 10857 relevant lines covered (38.69%)

186186.05 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

65.96

/Cpp2IL.Core/Extensions/AccessibilityExtensions.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using Cpp2IL.Core.Model.Contexts;
using LibCpp2IL.Metadata;

namespace Cpp2IL.Core.Extensions;

internal static class AccessibilityExtensions
{
    public static bool IsAccessibleTo(this TypeAnalysisContext referenceType, TypeAnalysisContext referencingType)
    {
        if (referenceType == referencingType)
            return true;

        var declaringTypesHierarchy = referenceType.GetTypeAndDeclaringTypes().ToArray();
        var inheritsFromIndex = declaringTypesHierarchy.IndexOf(t => referencingType.IsAssignableTo(t));
        var declaringTypeIndex = Array.IndexOf(declaringTypesHierarchy, referencingType);

        if (referenceType.DeclaringAssembly == referencingType.DeclaringAssembly /*or internals visible*/)
        {
            for (var i = 0; i < declaringTypesHierarchy.Length; i++)
            {
                if (i == declaringTypeIndex - 1)
                {
                    //All nested classes are accesible to their immediate declaring type.
                }
                else if (i == inheritsFromIndex - 1)
                {
                    if (declaringTypesHierarchy[i].Visibility is TypeAttributes.NestedPrivate)
                    {
                        return false;
                    }
                }
                else
                {
                    if (declaringTypesHierarchy[i].Visibility is TypeAttributes.NestedPrivate or TypeAttributes.NestedFamily or TypeAttributes.NestedFamANDAssem)
                    {
                        return false;
                    }
                }
            }

            return true;
        }
        else if (referenceType.DeclaringAssembly.IsDependencyOf(referencingType.DeclaringAssembly))
        {
            for (var i = 0; i < declaringTypesHierarchy.Length; i++)
            {
                if (i == declaringTypeIndex - 1)
                {
                    //All nested classes are accesible to their immediate declaring type.
                }
                else if (i == inheritsFromIndex - 1)
                {
                    if (declaringTypesHierarchy[i].Visibility is TypeAttributes.NotPublic or TypeAttributes.NestedPrivate or TypeAttributes.NestedAssembly or TypeAttributes.NestedFamANDAssem)
                    {
                        return false;
                    }
                }
                else
                {
                    if (declaringTypesHierarchy[i].Visibility is TypeAttributes.NotPublic or TypeAttributes.NestedPrivate or TypeAttributes.NestedFamily or TypeAttributes.NestedAssembly or TypeAttributes.NestedFamANDAssem or TypeAttributes.NestedFamORAssem)
                    {
                        return false;
                    }
                }
            }

            return true;
        }

        return false;
    }

    public static bool IsAssignableTo(this TypeAnalysisContext derivedType, TypeAnalysisContext baseType)
    {
        if (baseType.IsInterface)
        {
            return derivedType.IsAssignableToInterface(baseType);
        }
        else
        {
            return derivedType.InheritsFrom(baseType);
        }
    }

    private static int IndexOf<T>(this IEnumerable<T> enumerable, Func<T, bool> selector)
    {
        var index = 0;
        foreach (var item in enumerable)
        {
            if (selector(item))
            {
                return index;
            }

            index++;
        }

        return -1;
    }

    private static IEnumerable<TypeAnalysisContext> GetTypeAndDeclaringTypes(this TypeAnalysisContext type)
    {
        var current = type;
        while (current != null)
        {
            yield return current;
            current = current.DeclaringType;
        }
    }

    private static bool InheritsFrom(this TypeAnalysisContext derivedType, TypeAnalysisContext baseType)
    {
        var current = derivedType;
        while (current != null)
        {
            if (current == baseType)
                return true;
            current = current.BaseType;
        }

        return false;
    }

    private static bool IsAssignableToInterface(this TypeAnalysisContext derivedType, TypeAnalysisContext baseInterface)
    {
        if (derivedType == baseInterface)
            return true;

        foreach (var @interface in derivedType.InterfaceContexts)
        {
            if (@interface.IsAssignableToInterface(baseInterface))
                return true;
        }

        return false;
    }

    private static bool IsDependencyOf(this AssemblyAnalysisContext referencedAssembly, AssemblyAnalysisContext referencingAssembly)
    {
        if (referencingAssembly.Definition is null)
        {
            // Injected assemblies can access everything
            return true;
        }
        if (referencedAssembly.Definition is null)
        {
            // Injected assemblies cannot be accessed by metadata assemblies
            return false;
        }
        return referencedAssembly.Definition.IsDependencyOf(referencingAssembly.Definition);
    }

    private static bool IsDependencyOf(this Il2CppAssemblyDefinition referencedAssembly, Il2CppAssemblyDefinition referencingAssembly)
    {
        if (Array.IndexOf(referencingAssembly.ReferencedAssemblies, referencedAssembly) >= 0)
            return true;

        if (Array.IndexOf(referencedAssembly.ReferencedAssemblies, referencingAssembly) >= 0)
            return false;

        return referencingAssembly.CollectAllDependencies().Contains(referencedAssembly);
    }

    private static HashSet<Il2CppAssemblyDefinition> CollectAllDependencies(this Il2CppAssemblyDefinition referencingAssembly)
    {
        var dependencies = new HashSet<Il2CppAssemblyDefinition> { referencingAssembly };
        referencingAssembly.CollectAllDependencies(dependencies);
        return dependencies;
    }

    private static void CollectAllDependencies(this Il2CppAssemblyDefinition referencingAssembly, HashSet<Il2CppAssemblyDefinition> dependencies)
    {
        foreach (var dependency in referencingAssembly.ReferencedAssemblies)
        {
            //Assemblies can have circular references
            if (dependencies.Add(dependency))
            {
                dependency.CollectAllDependencies(dependencies);
            }
        }
    }
}

1	using System;
2	using System.Collections.Generic;
3	using System.Linq;
4	using System.Reflection;
5	using Cpp2IL.Core.Model.Contexts;
6	using LibCpp2IL.Metadata;
7
8	namespace Cpp2IL.Core.Extensions;
9
10	internal static class AccessibilityExtensions
11	{
12	public static bool IsAccessibleTo(this TypeAnalysisContext referenceType, TypeAnalysisContext referencingType)
13	{
14	if (referenceType == referencingType)	9✔
15	return true;	1✔
16
17	var declaringTypesHierarchy = referenceType.GetTypeAndDeclaringTypes().ToArray();	8✔
18	var inheritsFromIndex = declaringTypesHierarchy.IndexOf(t => referencingType.IsAssignableTo(t));	19✔
19	var declaringTypeIndex = Array.IndexOf(declaringTypesHierarchy, referencingType);	8✔
20
21	if (referenceType.DeclaringAssembly == referencingType.DeclaringAssembly /or internals visible/)	8✔
22	{
23	for (var i = 0; i < declaringTypesHierarchy.Length; i++)	16✔
24	{
25	if (i == declaringTypeIndex - 1)	5✔
26	{
27	//All nested classes are accesible to their immediate declaring type.
28	}
29	else if (i == inheritsFromIndex - 1)	4!
30	{
NEW 31	if (declaringTypesHierarchy[i].Visibility is TypeAttributes.NestedPrivate)	×
32	{
33	return false;	×
34	}
35	}
36	else
37	{
38	if (declaringTypesHierarchy[i].Visibility is TypeAttributes.NestedPrivate or TypeAttributes.NestedFamily or TypeAttributes.NestedFamANDAssem)	4✔
39	{
40	return false;	1✔
41	}
42	}
43	}
44
45	return true;	3✔
46	}
47	else if (referenceType.DeclaringAssembly.IsDependencyOf(referencingType.DeclaringAssembly))	4✔
48	{
49	for (var i = 0; i < declaringTypesHierarchy.Length; i++)	8✔
50	{
51	if (i == declaringTypeIndex - 1)	3✔
52	{
53	//All nested classes are accesible to their immediate declaring type.
54	}
55	else if (i == inheritsFromIndex - 1)	3!
56	{
NEW 57	if (declaringTypesHierarchy[i].Visibility is TypeAttributes.NotPublic or TypeAttributes.NestedPrivate or TypeAttributes.NestedAssembly or TypeAttributes.NestedFamANDAssem)	×
58	{
59	return false;	×
60	}
61	}
62	else
63	{
64	if (declaringTypesHierarchy[i].Visibility is TypeAttributes.NotPublic or TypeAttributes.NestedPrivate or TypeAttributes.NestedFamily or TypeAttributes.NestedAssembly or TypeAttributes.NestedFamANDAssem or TypeAttributes.NestedFamORAssem)	3✔
65	{
66	return false;	2✔
67	}
68	}
69	}
70
71	return true;	1✔
72	}
73
74	return false;	1✔
75	}
76
77	public static bool IsAssignableTo(this TypeAnalysisContext derivedType, TypeAnalysisContext baseType)
78	{
79	if (baseType.IsInterface)	11!
80	{
81	return derivedType.IsAssignableToInterface(baseType);	×
82	}
83	else
84	{
85	return derivedType.InheritsFrom(baseType);	11✔
86	}
87	}
88
89	private static int IndexOf<T>(this IEnumerable<T> enumerable, Func<T, bool> selector)
90	{
91	var index = 0;	8✔
92	foreach (var item in enumerable)	37✔
93	{
94	if (selector(item))	11✔
95	{
96	return index;	1✔
97	}
98
99	index++;	10✔
100	}
101
102	return -1;	7✔
103	}	1✔
104
105	private static IEnumerable<TypeAnalysisContext> GetTypeAndDeclaringTypes(this TypeAnalysisContext type)
106	{
107	var current = type;	8✔
108	while (current != null)	19✔
109	{
110	yield return current;	11✔
111	current = current.DeclaringType;	11✔
112	}
113	}	8✔
114
115	private static bool InheritsFrom(this TypeAnalysisContext derivedType, TypeAnalysisContext baseType)
116	{
117	var current = derivedType;	11✔
118	while (current != null)	35✔
119	{
120	if (current == baseType)	25✔
121	return true;	1✔
122	current = current.BaseType;	24✔
123	}
124
125	return false;	10✔
126	}
127
128	private static bool IsAssignableToInterface(this TypeAnalysisContext derivedType, TypeAnalysisContext baseInterface)
129	{
130	if (derivedType == baseInterface)	×
131	return true;	×
132
133	foreach (var @interface in derivedType.InterfaceContexts)	×
134	{
135	if (@interface.IsAssignableToInterface(baseInterface))	×
136	return true;	×
137	}
138
139	return false;	×
140	}	×
141
142	private static bool IsDependencyOf(this AssemblyAnalysisContext referencedAssembly, AssemblyAnalysisContext referencingAssembly)
143	{
144	if (referencingAssembly.Definition is null)	4!
145	{
146	// Injected assemblies can access everything
147	return true;	×
148	}
149	if (referencedAssembly.Definition is null)	4!
150	{
151	// Injected assemblies cannot be accessed by metadata assemblies
152	return false;	×
153	}
154	return referencedAssembly.Definition.IsDependencyOf(referencingAssembly.Definition);	4✔
155	}
156
157	private static bool IsDependencyOf(this Il2CppAssemblyDefinition referencedAssembly, Il2CppAssemblyDefinition referencingAssembly)
158	{
159	if (Array.IndexOf(referencingAssembly.ReferencedAssemblies, referencedAssembly) >= 0)	4✔
160	return true;	3✔
161
162	if (Array.IndexOf(referencedAssembly.ReferencedAssemblies, referencingAssembly) >= 0)	1!
163	return false;	1✔
164
165	return referencingAssembly.CollectAllDependencies().Contains(referencedAssembly);	×
166	}
167
168	private static HashSet<Il2CppAssemblyDefinition> CollectAllDependencies(this Il2CppAssemblyDefinition referencingAssembly)
169	{
170	var dependencies = new HashSet<Il2CppAssemblyDefinition> { referencingAssembly };	×
171	referencingAssembly.CollectAllDependencies(dependencies);	×
172	return dependencies;	×
173	}
174
175	private static void CollectAllDependencies(this Il2CppAssemblyDefinition referencingAssembly, HashSet<Il2CppAssemblyDefinition> dependencies)
176	{
177	foreach (var dependency in referencingAssembly.ReferencedAssemblies)	×
178	{
179	//Assemblies can have circular references
180	if (dependencies.Add(dependency))	×
181	{
182	dependency.CollectAllDependencies(dependencies);	×
183	}
184	}
185	}	×
186	}

SamboyCoding / Cpp2IL / 15173156024

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous