internal static List <IAssemblyReference> ToAssemblyReferences(IEnumerable <AssemblyDefinition> references, ILogger logger)
{
logger.Info("Assembly definition to references...");
var list = new List <IAssemblyReference>();
if (references == null)
{
return(list);
}
foreach (var reference in references)
{
logger.Trace("\tLoading AssemblyDefinition " + (reference != null && reference.Name != null && reference.Name.Name != null ? reference.Name.Name : "") + " ...");
var loader = new CecilLoader();
loader.IncludeInternalMembers = true;
list.Add(loader.LoadAssembly(reference));
logger.Trace("\tLoading AssemblyDefinition done");
}
logger.Info("Assembly definition to references done");
return(list);
}
public CSharpCompletion()
{
projectContent = new CSharpProjectContent();
var assemblies = new List <Assembly>
{
typeof(object).Assembly, // mscorlib
typeof(Uri).Assembly, // System.dll
typeof(Enumerable).Assembly, // System.Core.dll
// typeof(System.Xml.XmlDocument).Assembly, // System.Xml.dll
// typeof(System.Drawing.Bitmap).Assembly, // System.Drawing.dll
// typeof(Form).Assembly, // System.Windows.Forms.dll
// typeof(ICSharpCode.NRefactory.TypeSystem.IProjectContent).Assembly,
};
var unresolvedAssemblies = new IUnresolvedAssembly[assemblies.Count];
Stopwatch total = Stopwatch.StartNew();
Parallel.For(
0, assemblies.Count,
delegate(int i)
{
var loader = new CecilLoader();
var path = assemblies[i].Location;
loader.DocumentationProvider = GetXmlDocumentation(assemblies[i].Location);
unresolvedAssemblies[i] = loader.LoadAssemblyFile(assemblies[i].Location);
});
Debug.WriteLine("Init project content, loading base assemblies: " + total.Elapsed);
projectContent = projectContent.AddAssemblyReferences((IEnumerable <IUnresolvedAssembly>)unresolvedAssemblies);
}
private static IList <Tuple <IUnresolvedAssembly, IList <string>, Assembly> > LoadReferences(IEnumerable <string> references, IErrorReporter er)
{
var loader = new CecilLoader {
IncludeInternalMembers = true
};
var assemblies = references.Select(r => AssemblyDefinition.ReadAssembly(r)).ToList(); // Shouldn't result in errors because mcs would have caught it.
var indirectReferences = (from a in assemblies
from m in a.Modules
from r in m.AssemblyReferences
select r.Name)
.Distinct();
var directReferences = from a in assemblies select a.Name.Name;
var missingReferences = indirectReferences.Except(directReferences).ToList();
if (missingReferences.Count > 0)
{
er.Region = DomRegion.Empty;
foreach (var r in missingReferences)
{
er.Message(Messages._7996, r);
}
return(null);
}
return(assemblies.Select(asm => Tuple.Create(loader.LoadAssembly(asm), GetReferencedAssemblyNames(asm), LoadPlugin(asm))).ToList());
}
static IEnumerable <ITypeDefinition> LoadTypes()
{
var tt = typeof(File).Assembly.Location;
Reflector.OutputDir = Environment.CurrentDirectory;
var asmFile = Assembly.GetExecutingAssembly().Location;
//asmFile = "".GetType().Assembly.Location;
string xmlFile = Path.GetFullPath(Path.GetFileNameWithoutExtension(asmFile) + ".xml");
XmlDocumentationProvider doc = MonoCompletionEngine.GetXmlDocumentation(asmFile);
if (doc == null && File.Exists(xmlFile))
{
doc = new XmlDocumentationProvider(xmlFile);
}
var loader = new CecilLoader {
DocumentationProvider = doc
};
var unresolvedAsm = loader.LoadAssemblyFile(asmFile);
var compilation = new SimpleCompilation(unresolvedAsm);
var context = new SimpleTypeResolveContext(compilation);
var asm = unresolvedAsm.Resolve(context);
return(asm.GetAllTypeDefinitions().ToArray());
}
public ModuleMetadataInfo(Module module, Mono.Cecil.ModuleDefinition cecilModule)
{
this.Module = module;
this.CecilModule = cecilModule;
typeRefLoader = new CecilLoader();
typeRefLoader.SetCurrentModule(cecilModule);
}
public List <ReferenceSegment> Decompile(TextEditorData data, ITreeNavigator navigator, bool publicOnly)
{
if (DomMethodNodeBuilder.HandleSourceCodeEntity(navigator, data))
{
return(null);
}
var type = CecilLoader.GetCecilObject((IUnresolvedTypeDefinition)navigator.DataItem);
if (type == null)
{
return(null);
}
var settings = new DecompilerSettings()
{
AnonymousMethods = true,
AutomaticEvents = true,
AutomaticProperties = true,
ForEachStatement = true,
LockStatement = true,
HideNonPublicMembers = publicOnly
};
return(DomMethodNodeBuilder.Decompile(data, DomMethodNodeBuilder.GetModule(navigator), type, builder => {
builder.AddType(type);
}, settings));
}
public IEnumerable <ILLocalVariable> GetLocalVariables(IMethod method)
{
string id = IdStringProvider.GetIdString(method.MemberDefinition);
var file = GetSymbols(method);
if (file == null || !file.DebugSymbols.ContainsKey(id))
{
return(Enumerable.Empty <ILLocalVariable>());
}
var symbols = file.DebugSymbols[id];
var context = new SimpleTypeResolveContext(method);
var loader = new CecilLoader();
return(symbols.LocalVariables.Where(v => v.OriginalVariable != null).Select(
v => new Debugger.ILLocalVariable()
{
Index = v.OriginalVariable.Index,
Type = loader.ReadTypeReference(v.Type).Resolve(context),
Name = v.Name,
IsCompilerGenerated = false,
ILRanges = new [] { new ILRange(0, int.MaxValue) }
}));
}
public AssemblyLoader(AssemblyBrowserWidget widget, string fileName)
{
if (widget == null)
{
throw new ArgumentNullException(nameof(widget));
}
if (fileName == null)
{
throw new ArgumentNullException(nameof(fileName));
}
this.widget = widget;
FileName = fileName;
if (!File.Exists(fileName))
{
throw new ArgumentException("File doesn't exist.", nameof(fileName));
}
loader = new CecilLoader(true);
loader.InterningProvider = new FastNonInterningProvider();
loader.IncludeInternalMembers = true;
loader.LazyLoad = true;
assemblyLoaderTask = Task.Run(() => {
try {
var asm = AssemblyDefinition.ReadAssembly(FileName, new ReaderParameters {
AssemblyResolver = this
});
var loadedAssembley = loader.LoadAssembly(asm);
return(Tuple.Create(asm, loadedAssembley));
} catch (Exception e) {
LoggingService.LogError("Error while reading assembly " + FileName, e);
return(null);
}
}, src.Token);
}
public static IList <ITypeDefinition> GetNestedTypes(AssemblyDefinition assemblyDefinition, string fullTypeName)
{
var loader = new CecilLoader();
loader.IncludeInternalMembers = true;
var bridgeAssemblyDefinition = MonoCecilAssemblyHelper.GetBridgeAssemlyDefinition();
var bridgeAssembly = loader.LoadAssembly(bridgeAssemblyDefinition);
IProjectContent project = new CSharpProjectContent();
project = project.AddAssemblyReferences(bridgeAssembly);
var compilation = project.CreateCompilation();
var ctx = new SimpleTypeResolveContext(compilation);
var unresolvedAssembly = loader.LoadAssembly(assemblyDefinition);
var assembly = unresolvedAssembly.Resolve(ctx);
var parentType = assembly.GetAllTypeDefinitions().FirstOrDefault(x => x.FullName == fullTypeName);
if (parentType == null)
{
return(new List <ITypeDefinition>());
}
var nested = parentType.NestedTypes;
return(nested);
}
public void ResetProject(Tuple <string, string>[] sourceFiles = null, params string[] assemblies)
{
Project = null;
if (sourceFiles == null)
{
sourceFiles = new Tuple <string, string> [0]; //will happen only during the testing
}
var projectContents = new IUnresolvedAssembly[assemblies.Length];
Parallel.For(0, assemblies.Length, i =>
{
projectContents[i] = new CecilLoader {
DocumentationProvider = GetXmlDocumentation(assemblies[i])
}.LoadAssemblyFile(assemblies[i]);
});
var unresolvedAsms = builtInLibs.Value.Concat(projectContents);
var unresolvedFiles = new IUnresolvedFile[sourceFiles.Length];
Parallel.For(0, unresolvedFiles.Length, i =>
{
var pair = sourceFiles[i];
var syntaxTree = new CSharpParser().Parse(pair.Item1, pair.Item2);
syntaxTree.Freeze();
unresolvedFiles[i] = syntaxTree.ToTypeSystem();
});
IProjectContent project = new CSharpProjectContent();
project = project.AddAssemblyReferences(unresolvedAsms);
project = project.AddOrUpdateFiles(unresolvedFiles);
Project = project;
}
public CSharpCompletion()
{
projectContent = new CSharpProjectContent();
var assemblies = new List <Assembly>
{
typeof(object).Assembly, // mscorlib
typeof(Uri).Assembly, // System.dll
typeof(Enumerable).Assembly, // System.Core.dll
typeof(System.Xml.XmlDocument).Assembly, // System.Xml.dll
typeof(Sandbox.Common.ObjectBuilders.MyObjectBuilder_AdvancedDoor).Assembly, // SpaceEngineers.ObjectBuilders.dll
typeof(SpaceEngineers.Game.ModAPI.IMyButtonPanel).Assembly, // SpaceEngineers.Game.dll
typeof(Sandbox.MySandboxGame).Assembly, // Sandbox.Game.dll
typeof(Sandbox.ModAPI.MyAPIGateway).Assembly, // Sandbox.Common.dll
typeof(Sandbox.Graphics.GUI.MyGuiSandbox).Assembly, // Sandbox.Graphics.dll
typeof(VRage.MyModelData).Assembly, // VRage.dll
typeof(VRage.Exceptions).Assembly, // VRage.Library.dll
typeof(VRageMath.MathHelper).Assembly, // VRage.Math
typeof(VRage.Game.ObjectBuilders.MyObjectBuilder_EntityStat).Assembly, //VRage.Game
};
var unresolvedAssemblies = new IUnresolvedAssembly[assemblies.Count];
Stopwatch total = Stopwatch.StartNew();
Parallel.For(
0, assemblies.Count,
delegate(int i)
{
var loader = new CecilLoader();
var path = assemblies[i].Location;
loader.DocumentationProvider = GetXmlDocumentation(assemblies[i].Location);
unresolvedAssemblies[i] = loader.LoadAssemblyFile(assemblies[i].Location);
});
Debug.WriteLine("Init project content, loading base assemblies: " + total.Elapsed);
projectContent = projectContent.AddAssemblyReferences((IEnumerable <IUnresolvedAssembly>)unresolvedAssemblies);
}
public List <ReferenceSegment> Decompile(TextEditorData data, ITreeNavigator navigator, bool publicOnly)
{
if (DomMethodNodeBuilder.HandleSourceCodeEntity(navigator, data))
{
return(null);
}
var type = CecilLoader.GetCecilObject((IUnresolvedTypeDefinition)navigator.DataItem);
if (type == null)
{
return(null);
}
var types = DesktopService.GetMimeTypeInheritanceChain(data.Document.MimeType);
var codePolicy = MonoDevelop.Projects.Policies.PolicyService.GetDefaultPolicy <MonoDevelop.CSharp.Formatting.CSharpFormattingPolicy> (types);
var settings = new DecompilerSettings()
{
AnonymousMethods = true,
AutomaticEvents = true,
AutomaticProperties = true,
ForEachStatement = true,
LockStatement = true,
CSharpFormattingOptions = codePolicy.CreateOptions()
//,
// HideNonPublicMembers = publicOnly
};
return(DomMethodNodeBuilder.Decompile(data, DomMethodNodeBuilder.GetModule(navigator), type, builder =>
{
builder.AddType(type);
}, settings));
}
/// <summary>
/// Loads the assemblies needed to generate completion options.
/// </summary>
/// <param name="assemblies">List of assemblies. If nothing is passed in, a default list will be used.</param>
/// <returns>List of assemblies.</returns>
/// <remarks>This is an expensive operation.</remarks>
private static IUnresolvedAssembly[] GetAssemblies(List <Assembly> assemblies = null)
{
// List of assemblies frequently used in manager scripts.
// These assemblies get used by the CSharpCompletion object to look for intellisense options.
// Would be better to dynamically generate this list based on the user's script. The disadvantage of doing it that way
// is that loading these assemblies into the CSharpCompletion object is quite slow.
if (assemblies == null)
{
assemblies = new List <Assembly>
{
typeof(object).Assembly, // mscorlib
typeof(Uri).Assembly, // System.dll
typeof(System.Linq.Enumerable).Assembly, // System.Core.dll
typeof(System.Xml.XmlDocument).Assembly, // System.Xml.dll
typeof(System.Drawing.Bitmap).Assembly, // System.Drawing.dll
typeof(IProjectContent).Assembly,
typeof(Models.Core.IModel).Assembly, // Models.exe
typeof(APSIM.Shared.Utilities.StringUtilities).Assembly, // APSIM.Shared.dll
}
}
;
assemblies = assemblies.Where(v => !v.IsDynamic).ToList();
IUnresolvedAssembly[] assemblyList = new IUnresolvedAssembly[assemblies.Count];
for (int i = 0; i < assemblies.Count; i++)
{
var loader = new CecilLoader();
loader.DocumentationProvider = GetXmlDocumentation(assemblies[i].Location);
assemblyList[i] = loader.LoadAssemblyFile(assemblies[i].Location);
}
return(assemblyList);
}
}
private IUnresolvedAssembly Load(Assembly assembly)
{
var loader = new CecilLoader {
DocumentationProvider = GetXmlDocumentation(assembly.Location)
};
return(loader.LoadAssemblyFile(assembly.Location));
}
List <ReferenceSegment> IAssemblyBrowserNodeBuilder.Decompile(TextEditorData data, ITreeNavigator navigator, bool publicOnly)
{
if (DomMethodNodeBuilder.HandleSourceCodeEntity(navigator, data))
{
return(null);
}
var field = CecilLoader.GetCecilObject((IUnresolvedField)navigator.DataItem);
return(DomMethodNodeBuilder.Decompile(data, DomMethodNodeBuilder.GetModule(navigator), field.DeclaringType, b => b.AddField(field)));
}
List <ReferenceSegment> IAssemblyBrowserNodeBuilder.GetSummary(TextEditorData data, ITreeNavigator navigator, bool publicOnly)
{
if (DomMethodNodeBuilder.HandleSourceCodeEntity(navigator, data))
{
return(null);
}
var property = CecilLoader.GetCecilObject((IUnresolvedProperty)navigator.DataItem);
return(DomMethodNodeBuilder.GetSummary(data, DomMethodNodeBuilder.GetModule(navigator), property.DeclaringType, b => b.AddProperty(property)));
}
List <ReferenceSegment> IAssemblyBrowserNodeBuilder.Disassemble(TextEditorData data, ITreeNavigator navigator)
{
if (DomMethodNodeBuilder.HandleSourceCodeEntity(navigator, data))
{
return(null);
}
var field = CecilLoader.GetCecilObject((IUnresolvedField)navigator.DataItem);
return(DomMethodNodeBuilder.Disassemble(data, rd => rd.DisassembleField(field)));
}
public CSharpAmbienceTests()
{
ambience = new CSharpAmbience();
mscorlib = CecilLoaderTests.Mscorlib;
var loader = new CecilLoader();
loader.IncludeInternalMembers = true;
myLib = loader.LoadAssemblyFile(typeof(CSharpAmbienceTests).Assembly.Location);
compilation = new SimpleCompilation(myLib, mscorlib);
}
public void SetUp()
{
snippetGenerator = new SnippetGenerator(true);
var loader = new CecilLoader();
loader.IncludeInternalMembers = true;
myLib = loader.LoadAssemblyFile(typeof(SnippetGenerationTests).Assembly.Location);
mscorlib = loader.LoadAssemblyFile(typeof(object).Assembly.Location);
compilation = new SimpleCompilation(myLib, mscorlib);
}
public void FixtureSetUp()
{
CecilLoader loader = new CecilLoader()
{
IncludeInternalMembers = true, LazyLoad = true
};
IUnresolvedAssembly pc = loader.LoadAssemblyFile(typeof(TestCase.SimplePublicClass).Assembly.Location);
base.compilation = new SimpleCompilation(pc, CecilLoaderTests.Mscorlib);
}
public void FixtureSetUp()
{
// use "IncludeInternalMembers" so that Cecil results match C# parser results
CecilLoader loader = new CecilLoader()
{
IncludeInternalMembers = true
};
testCasePC = loader.LoadAssemblyFile(typeof(TestCase.SimplePublicClass).Assembly.Location);
}
LoadedAssembly LoadAssembly(FileName fileName, CancellationToken cancellationToken, bool includeInternalMembers)
{
DateTime lastWriteTime = File.GetLastWriteTimeUtc(fileName);
string cacheFileName = GetCacheFileName(fileName);
LoadedAssembly pc = TryReadFromCache(cacheFileName, lastWriteTime);
if (pc != null)
{
if (!includeInternalMembers || includeInternalMembers == pc.HasInternalMembers)
{
return(pc);
}
}
//LoggingService.Debug("Loading " + fileName);
cancellationToken.ThrowIfCancellationRequested();
var param = new ReaderParameters();
param.AssemblyResolver = new DummyAssemblyResolver();
ModuleDefinition module = ModuleDefinition.ReadModule(fileName, param);
CecilLoader l = new CecilLoader();
l.IncludeInternalMembers = includeInternalMembers;
string xmlDocFile = FindXmlDocumentation(fileName, module.Runtime);
if (xmlDocFile != null)
{
try
{
l.DocumentationProvider = new XmlDocumentationProvider(xmlDocFile);
}
catch (XmlException ex)
{
LoggingService.Warn("Ignoring error while reading xml doc from " + xmlDocFile, ex);
}
catch (IOException ex)
{
LoggingService.Warn("Ignoring error while reading xml doc from " + xmlDocFile, ex);
}
catch (UnauthorizedAccessException ex)
{
LoggingService.Warn("Ignoring error while reading xml doc from " + xmlDocFile, ex);
}
}
l.CancellationToken = cancellationToken;
var references = module.AssemblyReferences
.Select(anr => new DomAssemblyName(anr.FullName));
pc = new LoadedAssembly(l.LoadModule(module), lastWriteTime, includeInternalMembers, references);
SaveToCacheAsync(cacheFileName, lastWriteTime, pc).FireAndForget();
//SaveToCache(cacheFileName, lastWriteTime, pc);
return(pc);
}
public void SetUp()
{
var cecilLoader = new CecilLoader()
{
IncludeInternalMembers = true
};
var mscorlib = cecilLoader.LoadAssemblyFile(typeof(object).Assembly.Location);
var systemCore = cecilLoader.LoadAssemblyFile(typeof(System.Linq.Enumerable).Assembly.Location);
compilation = new SimpleCompilation(cecilLoader.LoadAssemblyFile(typeof(OverloadResolutionTests).Assembly.Location), mscorlib, systemCore);
}
public void FixtureSetUp()
{
// use "IncludeInternalMembers" so that Cecil results match C# parser results
CecilLoader loader = new CecilLoader()
{
IncludeInternalMembers = true
};
IUnresolvedAssembly asm = loader.LoadAssemblyFile(typeof(TestCase.SimplePublicClass).Assembly.Location);
compilation = new SimpleCompilation(asm, CecilLoaderTests.Mscorlib);
}
private static IEnumerable <IUnresolvedAssembly> GetProjectReferences(List <string> explicitReferences)
{
var loader = new CecilLoader();
yield return(loader.LoadAssemblyFile(typeof(object).Assembly.Location));
foreach (var reference in explicitReferences)
{
yield return(loader.LoadAssemblyFile(reference));
}
}
public static void AddAssembly(string file)
{
if (String.IsNullOrEmpty(file))
{
return;
}
var loader = new CecilLoader();
var unresolvedAssembly = loader.LoadAssemblyFile(file);
projectContent = projectContent.AddAssemblyReferences(unresolvedAssembly);
}
public MetricsReader(string fileName)
{
loader = new CecilLoader(true)
{
IncludeInternalMembers = true
};
namespaceMappings = new Dictionary <string, NamespaceNode>();
typeMappings = new Dictionary <ITypeDefinition, TypeNode>();
methodMappings = new Dictionary <IMethod, MethodNode>();
fieldMappings = new Dictionary <IField, FieldNode>();
cecilMappings = new Dictionary <MemberReference, IEntity>();
compilation = new SimpleCompilation(loader.LoadAssemblyFile(fileName));
// TODO load referenced assemblies into compilation.
Assembly = new AssemblyNode(compilation.MainAssembly.AssemblyName);
assemblyDefinition = loader.GetCecilObject(compilation.MainAssembly.UnresolvedAssembly);
foreach (var type in compilation.MainAssembly.GetAllTypeDefinitions())
{
ReadType(type);
foreach (IMethod method in type.Methods)
{
ReadMethod(method);
}
foreach (IProperty property in type.Properties)
{
if (property.CanGet)
{
ReadMethod(property.Getter);
}
if (property.CanSet)
{
ReadMethod(property.Setter);
}
}
foreach (IField field in type.Fields)
{
ReadField(field);
}
}
foreach (var method in methodMappings.Values)
{
ReadInstructions(method, method.Method, loader.GetCecilObject((IUnresolvedMethod)method.Method.UnresolvedMember));
}
Assembly.namespaces = namespaceMappings.Values;
}
// Token: 0x06000025 RID: 37 RVA: 0x00002B34 File Offset: 0x00000D34
private IUnresolvedAssembly LoadAssembly(string path)
{
if (this.assemblies.ContainsKey(path))
{
return(this.assemblies[path]);
}
CecilLoader cecilLoader = new CecilLoader();
IUnresolvedAssembly unresolvedAssembly = cecilLoader.LoadAssemblyFile(path);
this.assemblies.Add(path, unresolvedAssembly);
return(unresolvedAssembly);
}
public void ResolveTypeWithUnknownAttributes()
{
const String source = "namespace ns\r\n" +
"{\r\n" +
" public enum EE {v1 = 13, v2 = 666}\r\n" +
" [System.AttributeUsage(System.AttributeTargets.Method | System.AttributeTargets.Property, AllowMultiple = true)]\r\n" +
" public class AttrA : System.Attribute\r\n" +
" {\r\n" +
" }\r\n" +
" [System.AttributeUsage(System.AttributeTargets.Method)]\r\n" +
" public class AttrB : System.Attribute\r\n" +
" {\r\n" +
" public AttrB(int i, string s, EE e) {}\r\n" +
" }\r\n" +
" public class SomeClass\r\n" +
" {\r\n" +
" [AttrA]\r\n" +
" [AttrB(666, \"iddqd\", EE.v1)]\r\n" +
" [AttrC]\r\n" +
" public void M()\r\n" +
" { }\r\n" +
" }\r\n" +
"}";
CSharpParser parser = new CSharpParser();
SyntaxTree syntaxTree = parser.Parse(source);
syntaxTree.FileName = "example.cs";
CSharpUnresolvedFile unresolvedTypeSystem = syntaxTree.ToTypeSystem();
IProjectContent content = new CSharpProjectContent();
content = content.AddOrUpdateFiles(unresolvedTypeSystem);
CecilLoader loader = new CecilLoader();
AssemblyDefinition mscorlibAssemblyDefinition = AssemblyDefinition.ReadAssembly(typeof(Object).Assembly.Location);
IUnresolvedAssembly mscorlibAssembly = loader.LoadAssembly(mscorlibAssemblyDefinition);
content = content.AddAssemblyReferences(mscorlibAssembly);
ICompilation compilation = content.CreateCompilation();
CSharpAstResolver resolver = new CSharpAstResolver(compilation, syntaxTree);
MethodDeclaration method = syntaxTree.Descendants.OfType <MethodDeclaration>().First(m => m.Name == "M");
ResolveResult result = resolver.Resolve(method);
MemberResolveResult memberResult = (MemberResolveResult)result;
IMember member = memberResult.Member;
foreach (IAttribute attribute in member.Attributes)
{
Console.WriteLine("attribute.AttributeType = {0}, attribute.AttributeType.Kind = {1}", attribute.AttributeType.FullName, attribute.AttributeType.Kind);
Console.WriteLine("attribute.PositionalArguments.Count = {0}", attribute.PositionalArguments.Count);
ProcessPositionalArgs(attribute.PositionalArguments);
Console.WriteLine("attribute.NamedArguments.Count = {0}", attribute.NamedArguments.Count);
Console.WriteLine();
}
}
public DecompilerTypeSystem(ModuleDefinition moduleDefinition)
{
if (moduleDefinition == null)
{
throw new ArgumentNullException(nameof(moduleDefinition));
}
this.moduleDefinition = moduleDefinition;
CecilLoader cecilLoader = new CecilLoader {
IncludeInternalMembers = true, LazyLoad = true, OnEntityLoaded = StoreMemberReference, ShortenInterfaceImplNames = false
};
typeReferenceCecilLoader.SetCurrentModule(moduleDefinition);
IUnresolvedAssembly mainAssembly = cecilLoader.LoadModule(moduleDefinition);
// Load referenced assemblies and type-forwarder references.
// This is necessary to make .NET Core/PCL binaries work better.
var referencedAssemblies = new List <IUnresolvedAssembly>();
var assemblyReferenceQueue = new Queue <AssemblyNameReference>(moduleDefinition.AssemblyReferences);
var processedAssemblyReferences = new HashSet <AssemblyNameReference>(KeyComparer.Create((AssemblyNameReference reference) => reference.FullName));
while (assemblyReferenceQueue.Count > 0)
{
var asmRef = assemblyReferenceQueue.Dequeue();
if (!processedAssemblyReferences.Add(asmRef))
{
continue;
}
var asm = moduleDefinition.AssemblyResolver.Resolve(asmRef);
if (asm != null)
{
referencedAssemblies.Add(cecilLoader.LoadAssembly(asm));
foreach (var forwarder in asm.MainModule.ExportedTypes)
{
if (!forwarder.IsForwarder || !(forwarder.Scope is AssemblyNameReference forwarderRef))
{
continue;
}
assemblyReferenceQueue.Enqueue(forwarderRef);
}
}
}
compilation = new SimpleCompilation(mainAssembly, referencedAssemblies);
// Primitive types are necessary to avoid assertions in ILReader.
// Fallback to MinimalCorlib to provide the primitive types.
if (compilation.FindType(KnownTypeCode.Void).Kind == TypeKind.Unknown || compilation.FindType(KnownTypeCode.Int32).Kind == TypeKind.Unknown)
{
referencedAssemblies.Add(MinimalCorlib.Instance);
compilation = new SimpleCompilation(mainAssembly, referencedAssemblies);
}
context = new SimpleTypeResolveContext(compilation.MainAssembly);
}
