internal IEnumerable <IMethodDefinition> getReachableMethodsFromMethod(IMethodReference method, IEnumerable <IModule> modules)
        {
            IEnumerable <IAssembly> assemblies = getAssembliesFromModules(modules);

            Microsoft.Cci.MetadataReaderHost readerHost = host as Microsoft.Cci.MetadataReaderHost;

            if (readerHost == null)
            {
                return(new List <IMethodDefinition>()); //?
            }
            ILGarbageCollect.Mark.WholeProgram program = new ILGarbageCollect.Mark.WholeProgram(assemblies, readerHost);
            RapidTypeAnalysis analyzer = new RapidTypeAnalysis(program, TargetProfile.Phone);

            analyzer.Run(new IMethodReference[] { method });
            return(analyzer.ReachableMethods());
        }
Exemple #2
0
        static internal AssemblyReport CreateAssemblyReportFromRTA(IAssembly assembly, RapidTypeAnalysis rta)
        {
            AssemblyReport report = new AssemblyReport(assembly);

            int totalTypes   = 0;
            int totalFields  = 0;
            int totalMethods = 0;

            foreach (var t in assembly.GetAllTypes())
            {
                totalTypes++;
                if (rta.ReachableTypes().Contains(t) == false)
                {
                    report.UnreachableTypes.Add(t);
                    //Console.WriteLine("Unused type {0}", t);
                }
                else
                {
                    report.ReachableTypes.Add(t);
                }

                if (t.IsClass || t.IsStruct)
                {
                    foreach (var f in t.Fields)
                    {
                        totalFields++;
                        if (rta.ReachableFields().Contains(f) == false)
                        {
                            report.UnreachableFields.Add(f);
                            //Console.WriteLine("Unused field {0}", f);
                        }
                        else
                        {
                            report.ReachableFields.Add(f);
                        }
                    }

                    foreach (var m in t.Methods)
                    {
                        if (!m.IsAbstract)
                        {
                            totalMethods++;
                            if (rta.MethodIsReachable(m) == false)
                            {
                                report.UnreachableMethods.Add(m);
                                //Console.WriteLine("Unreachable method {0}", m);
                            }
                            else
                            {
                                report.ReachableMethods.Add(m);
                            }
                        }
                    }
                }
            }

            return(report);
        }