Пример #1
0
        static void SeenAt(EncounteredCollection info, Type type, MemberInfo m)
        {
            if (type == null)
            {
                return;
            }

            if (!info.Contains(type))
            {
                Console.WriteLine("# can't find referenced member: {0}; from: {1}", type, m);
                return;
            }

            info [type].At.Add(m);
        }
Пример #2
0
        public static void Main(string[] args)
        {
            var info = new EncounteredCollection();
            var seen = new HashSet <Type>(new TypeNameComparer());

            foreach (var t in Ecma335.Types)
            {
                seen.Add(t);
                info.Add(new Encountered {
                    Type = t
                });
            }

            foreach (var t in ToStandarize)
            {
                AddReferencedTypes(t, seen, info);
            }

            var missingTypes = info.Select(e => e.Type).Except(ToStandarize).Except(Ecma335.Types);

            Console.WriteLine("# Missing: {0} Types", missingTypes.Count());
            foreach (var missing in missingTypes)
            {
                Console.WriteLine("Missing: {0}", missing.FullName);
                var e = info [missing];
                foreach (var m in e.At)
                {
                    Console.WriteLine("\tAt: {0}{1} plus {2} others...",
                                      m.DeclaringType == null ? "" : m.DeclaringType.FullName,
                                      m, e.At.Count - 1);
                }
                foreach (var b in e.At.Where(mi => Array.IndexOf(ToStandarize,
                                                                 GetTypeDefinition(mi.DeclaringType)) >= 0))
                {
                    Console.WriteLine("\tBecause: {0}", b.DeclaringType.FullName + "/" + b);
                }
            }
        }
Пример #3
0
        static Type AddReferencedTypes(Type type, ICollection <Type> seen, EncounteredCollection info)
        {
            if (seen.Contains(type))
            {
                return(type);
            }

            if (type.IsGenericParameter)
            {
                return(null);
            }

            if (type.IsArray || type.IsByRef || type.IsPointer)
            {
                return(AddReferencedTypes(type.GetElementType(), seen, info));
            }

            if (type.IsGenericType && !type.IsGenericTypeDefinition)
            {
                return(AddReferencedTypes(type.GetGenericTypeDefinition(), seen, info));
            }

            seen.Add(type);
            info.Add(new Encountered {
                Type = type,
            });

            if (type.BaseType != null)
            {
                var b = AddReferencedTypes(type.BaseType, seen, info);
                SeenAt(info, b, type);
            }

            foreach (var c in type.GetConstructors(DeclaredMembers))
            {
                var ps = c.GetParameters();
                if (SkipConstructors.Any(s => s.SequenceEqual(ps.Select(p => p.ParameterType))))
                {
                    continue;
                }

                if (!(c.IsPublic || c.IsFamily))
                {
                    continue;
                }

                foreach (var p in ps)
                {
                    var t = AddReferencedTypes(p.ParameterType, seen, info);
                    SeenAt(info, t, c);
                }
            }

            foreach (var m in type.GetMethods(DeclaredMembers))
            {
                var ps = m.GetParameters();
                if (SkipMethods.Any(s => s.Item1 == m.Name &&
                                    s.Item2.SequenceEqual(ps.Select(p => p.ParameterType))))
                {
                    continue;
                }

                if (!(m.IsPublic || m.IsFamily))
                {
                    continue;
                }

                foreach (var p in ps)
                {
                    var pt = AddReferencedTypes(p.ParameterType, seen, info);
                    SeenAt(info, pt, m);
                }
                var rt = AddReferencedTypes(m.ReturnType, seen, info);
                SeenAt(info, rt, m);
            }

            foreach (var f in type.GetFields(DeclaredMembers))
            {
                if (!(f.IsPublic || f.IsFamily))
                {
                    continue;
                }

                var ft = AddReferencedTypes(f.FieldType, seen, info);
                SeenAt(info, ft, f);
            }

            foreach (var p in type.GetProperties(DeclaredMembers))
            {
                if (p.GetAccessors(nonPublic:false).All(m => !(m.IsPublic || m.IsFamily)))
                {
                    continue;
                }

                var pt = AddReferencedTypes(p.PropertyType, seen, info);
                SeenAt(info, pt, p);
            }

            foreach (var e in type.GetEvents(DeclaredMembers))
            {
                var m = e.GetAddMethod(nonPublic: false);
                if (!(m.IsPublic || m.IsFamily))
                {
                    continue;
                }

                var et = AddReferencedTypes(e.EventHandlerType, seen, info);
                SeenAt(info, et, e);
            }

            foreach (var t in type.GetNestedTypes())
            {
                AddReferencedTypes(t, seen, info);
            }

            return(type);
        }