Debian Codegraph @

external/api-doc-tools/mdoc/Mono.Documentation/Updater/Frameworks/AssemblySet.cs

raw
1 using System;
2 using System.Collections;
3 using System.Collections.Generic;
4 using System.IO;
5 using System.Linq;
6 using Mono.Cecil;
7
8 namespace Mono.Documentation.Updater.Frameworks
9 {
10 /// <summary>
11 /// Represents a set of assemblies that we want to document
12 /// </summary>
13 public class AssemblySet : IDisposable
14 {
15 BaseAssemblyResolver resolver = new Frameworks.MDocResolver ();
16 CachedResolver cachedResolver;
17 IMetadataResolver metadataResolver;
18
19 HashSet<string> assemblyPaths = new HashSet<string> ();
20 Dictionary<string, bool> assemblyPathsMap = new Dictionary<string, bool> ();
21 HashSet<string> assemblySearchPaths = new HashSet<string> ();
22 HashSet<string> forwardedTypes = new HashSet<string> ();
23 IEnumerable<string> importPaths;
24 public IEnumerable<DocumentationImporter> Importers { get; private set; }
25
26 FrameworkEntry fx;
27 public FrameworkEntry Framework
28 {
29 get => fx;
30 set
31 {
32 fx = value;
33 fx.AddAssemblySet (this);
34 }
35 }
36
37 /// <summary>This is meant only for unit test access</summary>
38 public IDictionary<string, bool> AssemblyMapsPath
39 {
40 get => assemblyPathsMap;
41 }
42
43 private IDictionary<string, HashSet<MDocResolver.TypeForwardEventArgs>> forwardedTypesTo = new Dictionary<string, HashSet<MDocResolver.TypeForwardEventArgs>> ();
44
45
46 public AssemblySet (IEnumerable<string> paths) : this ("Default", paths, new string[0]) { }
47
48 public AssemblySet (string name, IEnumerable<string> paths, IEnumerable<string> resolverSearchPaths, IEnumerable<string> imports = null, string version = null, string id = null)
49 {
50 cachedResolver = cachedResolver ?? new CachedResolver (resolver);
51 metadataResolver = metadataResolver ?? new Frameworks.MDocMetadataResolver (cachedResolver);
52 ((MDocResolver)resolver).TypeExported += (sender, e) =>
53 {
54 TrackTypeExported (e);
55 };
56
57 Name = name;
58 Version = version;
59 Id = id;
60
61 foreach (var path in paths)
62 {
63 assemblyPaths.Add (path);
64 string pathName = Path.GetFileName (path);
65 if (!assemblyPathsMap.ContainsKey (pathName))
66 assemblyPathsMap.Add (pathName, true);
67 }
68
69 // add default search paths
70 var assemblyDirectories = paths
71 .Where (p => p.Contains (Path.DirectorySeparatorChar))
72 .Select (p => Path.GetDirectoryName (p));
73
74 foreach (var searchPath in assemblyDirectories.Union(resolverSearchPaths))
75 assemblySearchPaths.Add (searchPath);
76
77 char oppositeSeparator = Path.DirectorySeparatorChar == '/' ? '\\' : '/';
78 Func<string, string> sanitize = p =>
79 p.Replace (oppositeSeparator, Path.DirectorySeparatorChar);
80
81 foreach (var searchPath in assemblySearchPaths.Select (sanitize))
82 resolver.AddSearchDirectory (searchPath);
83
84 this.importPaths = imports;
85 if (this.importPaths != null)
86 {
87 this.Importers = this.importPaths.Select (p => MDocUpdater.Instance.GetImporter (p, supportsEcmaDoc: false)).ToArray ();
88 }
89 else
90 this.Importers = new DocumentationImporter[0];
91 }
92
93 private void TrackTypeExported (MDocResolver.TypeForwardEventArgs e)
94 {
95 if (e.ForType == null) return;
96
97 // keep track of types that have been exported for this assemblyset
98 if (!forwardedTypesTo.ContainsKey (e.ForType))
99 {
100 forwardedTypesTo.Add (e.ForType, new HashSet<MDocResolver.TypeForwardEventArgs> ());
101 }
102
103 forwardedTypesTo[e.ForType].Add (e);
104 }
105
106 public string Name { get; private set; }
107 public string Version { get; private set; }
108 public string Id { get; private set; }
109
110 IEnumerable<AssemblyDefinition> assemblies;
111 public IEnumerable<AssemblyDefinition> Assemblies
112 {
113 get
114 {
115 if (this.assemblies == null)
116 this.assemblies = this.LoadAllAssemblies ().Where (a => a != null).ToArray ();
117
118 return this.assemblies;
119 }
120 }
121 public IEnumerable<string> AssemblyPaths { get { return this.assemblyPaths; } }
122
123 /// <summary>Adds all subdirectories to the search directories for the resolver to look in.</summary>
124 public void RecurseSearchDirectories ()
125 {
126 var directories = resolver
127 .GetSearchDirectories ()
128 .Select (d => new DirectoryInfo (d))
129 .Where (d => d.Exists)
130 .Select (d => d.FullName)
131 .Distinct ()
132 .ToDictionary (d => d, d => d);
133
134 var subdirs = directories.Keys
135 .SelectMany (d => Directory.GetDirectories (d, ".", SearchOption.AllDirectories))
136 .Where (d => !directories.ContainsKey (d));
137
138 foreach (var dir in subdirs)
139 resolver.AddSearchDirectory (dir);
140 }
141
142 /// <returns><c>true</c>, if in set was contained in the set of assemblies, <c>false</c> otherwise.</returns>
143 /// <param name="name">An assembly file name</param>
144 public bool Contains (string name)
145 {
146 return assemblyPathsMap.ContainsKey (name);//assemblyPaths.Any (p => Path.GetFileName (p) == name);
147 }
148
149 /// <summary>Tells whether an already enumerated AssemblyDefinition, contains the type.</summary>
150 /// <param name="name">Type name</param>
151 public bool ContainsForwardedType (string name)
152 {
153 return forwardedTypes.Contains (name);
154 }
155
156 /// <summary>
157 /// Forwardeds the assemblies.
158 /// </summary>
159 /// <returns>The assemblies.</returns>
160 /// <param name="type">Type.</param>
161 public IEnumerable<AssemblyNameReference> FullAssemblyChain(TypeDefinition type)
162 {
163 if (forwardedTypesTo.ContainsKey (type.FullName))
164 {
165 var list = forwardedTypesTo[type.FullName];
166 var assemblies = (new[] { type.Module.Assembly.Name })
167 .Union (list.Select (f => f.To))
168 .Union (list.Select (f => f.From))
169 .Distinct (anc);
170 return assemblies;
171 }
172 else
173 return new[] { type.Module.Assembly.Name };
174 }
175
176 AssemblyNameComparer anc = new AssemblyNameComparer ();
177 class AssemblyNameComparer : IEqualityComparer<AssemblyNameReference>
178 {
179 public bool Equals (AssemblyNameReference x, AssemblyNameReference y)
180 {
181 return x.FullName.Equals (y.FullName, StringComparison.Ordinal);
182 }
183
184 public int GetHashCode (AssemblyNameReference obj)
185 {
186 return obj.FullName.GetHashCode ();
187 }
188 }
189
190 public void Dispose ()
191 {
192 this.assemblies = null;
193 cachedResolver?.Dispose();
194 cachedResolver = null;
195 }
196
197 public override string ToString ()
198 {
199 return string.Format ("[AssemblySet: Name={0}, Assemblies={1}]", Name, assemblyPaths.Count);
200 }
201
202 IEnumerable<AssemblyDefinition> LoadAllAssemblies ()
203 {
204 foreach (var path in this.assemblyPaths) {
205 var assembly = MDocUpdater.Instance.LoadAssembly (path, metadataResolver, cachedResolver);
206 if (assembly != null) {
207 foreach (var type in assembly.MainModule.ExportedTypes.Where (t => t.IsForwarder).Cast<ExportedType>())
208 {
209 forwardedTypes.Add (type.FullName);
210 TrackTypeExported (new MDocResolver.TypeForwardEventArgs (assembly.Name, (AssemblyNameReference)type.Scope, type?.FullName));
211 }
212 }
213 yield return assembly;
214 }
215 }
216 }
217 }