static 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();
unresolvedAssemblies[i] = loader.LoadAssemblyFile(assemblies[i].Location);
});
Debug.WriteLine("Init project content, loading base assemblies: " + total.Elapsed);
projectContent = projectContent.AddAssemblyReferences((IEnumerable <IUnresolvedAssembly>)unresolvedAssemblies);
}
public SimpleCompilation(ISolutionSnapshot solutionSnapshot, IUnresolvedAssembly mainAssembly, IEnumerable <IAssemblyReference> assemblyReferences)
{
if (solutionSnapshot == null)
{
throw new ArgumentNullException("solutionSnapshot");
}
if (mainAssembly == null)
{
throw new ArgumentNullException("mainAssembly");
}
if (assemblyReferences == null)
{
throw new ArgumentNullException("assemblyReferences");
}
this.solutionSnapshot = solutionSnapshot;
this.context = new SimpleTypeResolveContext(this);
this.mainAssembly = mainAssembly.Resolve(context);
List <IAssembly> referencedAssemblies = new List <IAssembly>();
foreach (var asmRef in assemblyReferences)
{
IAssembly asm = asmRef.Resolve(context);
if (asm != null && !referencedAssemblies.Contains(asm))
{
referencedAssemblies.Add(asm);
}
}
this.referencedAssemblies = referencedAssemblies.AsReadOnly();
this.knownTypeCache = new KnownTypeCache(this);
}
public LoadedAssembly(IUnresolvedAssembly projectContent, DateTime assemblyFileLastWriteTime, bool hasInternalMembers, IEnumerable <DomAssemblyName> references)
{
this.ProjectContent = projectContent;
this.AssemblyFileLastWriteTime = assemblyFileLastWriteTime;
this.HasInternalMembers = hasInternalMembers;
this.References = references.ToArray();
}
public SimpleCompilation(ISolutionSnapshot solutionSnapshot, IUnresolvedAssembly mainAssembly, IEnumerable<IAssemblyReference> assemblyReferences)
{
if (solutionSnapshot == null)
throw new ArgumentNullException("solutionSnapshot");
if (mainAssembly == null)
throw new ArgumentNullException("mainAssembly");
if (assemblyReferences == null)
throw new ArgumentNullException("assemblyReferences");
this.solutionSnapshot = solutionSnapshot;
this.context = new SimpleTypeResolveContext(this);
this.mainAssembly = mainAssembly.Resolve(context);
List<IAssembly> assemblies = new List<IAssembly>();
assemblies.Add(this.mainAssembly);
List<IAssembly> referencedAssemblies = new List<IAssembly>();
foreach (var asmRef in assemblyReferences) {
IAssembly asm;
try {
asm = asmRef.Resolve(context);
} catch (InvalidOperationException) {
throw new InvalidOperationException("Tried to initialize compilation with an invalid assembly reference. (Forgot to load the assembly reference ? - see CecilLoader)");
}
if (asm != null && !assemblies.Contains(asm))
assemblies.Add(asm);
if (asm != null && !referencedAssemblies.Contains(asm))
referencedAssemblies.Add(asm);
}
this.assemblies = assemblies.AsReadOnly();
this.referencedAssemblies = referencedAssemblies.AsReadOnly();
this.knownTypeCache = new KnownTypeCache(this);
}
public static IDocumentationProvider Get(IProject project, string assemblyName)
{
if (PlatformService.IsUnix)
{
return(new MonoDocDocumentationProvider());
}
if (_providers.ContainsKey(assemblyName))
{
return(_providers[assemblyName]);
}
string fileName = null;
IUnresolvedAssembly reference = project.References.OfType <IUnresolvedAssembly>().FirstOrDefault(i => i.AssemblyName.Equals(assemblyName));
if (reference != null)
{
fileName = XmlDocumentationProvider.LookupLocalizedXmlDoc(reference.Location);
}
if (fileName != null)
{
var docProvider = new XmlDocumentationProvider(fileName);
_providers.TryAdd(assemblyName, docProvider);
return(docProvider);
}
return(null);
}
public BVE5Compilation(ISolutionSnapshot solutionSnapshot, IUnresolvedAssembly mainAssembly,
IEnumerable<IAssemblyReference> assemblyReferences)
{
if(solutionSnapshot == null)
throw new ArgumentNullException("solutionSnapshot");
if(mainAssembly == null)
throw new ArgumentNullException("mainAssembly");
if(assemblyReferences == null)
throw new ArgumentNullException("assemblyReferences");
solution_snapshot = solutionSnapshot;
context = new SimpleTypeResolveContext(this);
main_assembly = mainAssembly.Resolve(context);
var assemblies = new List<IAssembly>{main_assembly};
var referenced_assemblies = new List<IAssembly>();
foreach(var asm_ref in assemblyReferences){
IAssembly asm = asm_ref.Resolve(context);
if(asm != null && !assemblies.Contains(asm))
assemblies.Add(asm);
if(asm != null && !referenced_assemblies.Contains(asm))
referenced_assemblies.Add(asm);
}
this.assemblies = assemblies.AsReadOnly();
this.referenced_assemblies = referenced_assemblies.AsReadOnly();
this.type_cache = new PrimitiveTypeCache(this);
}
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 LoadedAssembly(IUnresolvedAssembly projectContent, DateTime assemblyFileLastWriteTime, bool hasInternalMembers, IEnumerable<DomAssemblyName> references)
{
this.ProjectContent = projectContent;
this.AssemblyFileLastWriteTime = assemblyFileLastWriteTime;
this.HasInternalMembers = hasInternalMembers;
this.References = references.ToArray();
}
/// <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
typeof(MathNet.Numerics.Combinatorics).Assembly, // MathNet.Numerics,
typeof(System.Data.DataTable).Assembly // System.Data.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);
}
}
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(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);
}
public SimpleCompilation(ISolutionSnapshot solutionSnapshot, IUnresolvedAssembly mainAssembly, IEnumerable<IAssemblyReference> assemblyReferences)
{
if (solutionSnapshot == null)
throw new ArgumentNullException("solutionSnapshot");
if (mainAssembly == null)
throw new ArgumentNullException("mainAssembly");
if (assemblyReferences == null)
throw new ArgumentNullException("assemblyReferences");
this.solutionSnapshot = solutionSnapshot;
this.context = new SimpleTypeResolveContext(this);
this.mainAssembly = mainAssembly.Resolve(context);
List<IAssembly> assemblies = new List<IAssembly>();
assemblies.Add(this.mainAssembly);
List<IAssembly> referencedAssemblies = new List<IAssembly>();
foreach (var asmRef in assemblyReferences) {
IAssembly asm = asmRef.Resolve(context);
if (asm != null && !assemblies.Contains(asm))
assemblies.Add(asm);
if (asm != null && !referencedAssemblies.Contains(asm))
referencedAssemblies.Add(asm);
}
this.assemblies = assemblies.AsReadOnly();
this.referencedAssemblies = referencedAssemblies.AsReadOnly();
this.knownTypeCache = new KnownTypeCache(this);
}
public RefreshAssemblyEventArgs(FileName fileName, IUnresolvedAssembly oldAssembly, IUnresolvedAssembly newAssembly)
{
if (fileName == null)
throw new ArgumentNullException("fileName");
this.fileName = fileName;
this.oldAssembly = oldAssembly;
this.newAssembly = newAssembly;
}
private void ResolveAssemblies()
{
foreach (string assemblyFile in ReferencedAssemblies)
{
IUnresolvedAssembly assembly = ((Solution)Solution).LoadAssembly(assemblyFile);
ProjectContent = ProjectContent.AddAssemblyReferences(new[] { assembly });
ResolvedReferencedAssemblies.Add(assembly);
}
}
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 RefreshAssemblyEventArgs(FileName fileName, IUnresolvedAssembly oldAssembly, IUnresolvedAssembly newAssembly)
{
if (fileName == null)
{
throw new ArgumentNullException("fileName");
}
this.fileName = fileName;
this.oldAssembly = oldAssembly;
this.newAssembly = newAssembly;
}
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 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 AssemblyEntityModelContext(IUnresolvedAssembly mainAssembly, IAssemblyReference[] references)
{
if (mainAssembly == null)
{
throw new ArgumentNullException("mainAssembly");
}
this.mainAssembly = mainAssembly;
this.references = references;
this.compilation = new Lazy <ICompilation>(() => new SimpleCompilation(mainAssembly, references));
}
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 CSharpProject(Solution solution, string title, string fileName)
{
// Normalize the file name
fileName = Path.GetFullPath(fileName);
this.Solution = solution;
this.Title = title;
this.FileName = fileName;
// Use MSBuild to open the .csproj
var msbuildProject = new Microsoft.Build.Evaluation.Project(fileName);
// Figure out some compiler settings
this.AssemblyName = msbuildProject.GetPropertyValue("AssemblyName");
this.CompilerSettings.AllowUnsafeBlocks = GetBoolProperty(msbuildProject, "AllowUnsafeBlocks") ?? false;
this.CompilerSettings.CheckForOverflow = GetBoolProperty(msbuildProject, "CheckForOverflowUnderflow") ?? false;
string defineConstants = msbuildProject.GetPropertyValue("DefineConstants");
foreach (string symbol in defineConstants.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries))
{
this.CompilerSettings.ConditionalSymbols.Add(symbol.Trim());
}
// Initialize the unresolved type system
IProjectContent pc = new CSharpProjectContent();
pc = pc.SetAssemblyName(this.AssemblyName);
pc = pc.SetProjectFileName(fileName);
pc = pc.SetCompilerSettings(this.CompilerSettings);
// Parse the C# code files
foreach (var item in msbuildProject.GetItems("Compile"))
{
var file = new CSharpFile(this, Path.Combine(msbuildProject.DirectoryPath, item.EvaluatedInclude));
Files.Add(file);
}
// Add parsed files to the type system
pc = pc.AddOrUpdateFiles(Files.Select(f => f.UnresolvedTypeSystemForFile));
// Add referenced assemblies:
foreach (string assemblyFile in ResolveAssemblyReferences(msbuildProject))
{
IUnresolvedAssembly assembly = solution.LoadAssembly(assemblyFile);
pc = pc.AddAssemblyReferences(new [] { assembly });
}
// Add project references:
foreach (var item in msbuildProject.GetItems("ProjectReference"))
{
string referencedFileName = Path.Combine(msbuildProject.DirectoryPath, item.EvaluatedInclude);
// Normalize the path; this is required to match the name with the referenced project's file name
referencedFileName = Path.GetFullPath(referencedFileName);
pc = pc.AddAssemblyReferences(new[] { new ProjectReference(referencedFileName) });
}
this.ProjectContent = pc;
}
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);
}
// 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 void AddAssemblies(IEnumerable<Assembly> assemblies) {
var a = assemblies.ToArray();
OnAssembliesLoading(a);
var ua = new IUnresolvedAssembly[a.Length];
Parallel.For(0, a.Length, i => ua[i] = Load(a[i]));
lock (locker)
foreach (var asm in ua)
assemblySet.Add(asm);
OnInternalAssembliesLoaded(ua);
OnAssembliesLoaded(a);
}
bool IsSharpDevelopAssembly(IUnresolvedAssembly pc, out Assembly assembly)
{
assembly = null;
foreach (var asm in AppDomain.CurrentDomain.GetAssemblies())
{
if (!asm.IsDynamic && asm.Location.StartsWith(sharpDevelopRoot, StringComparison.OrdinalIgnoreCase) && pc.AssemblyName == asm.GetName().Name)
{
assembly = asm;
return(true);
}
}
return(false);
}
AssemblyDefinition GetCecilObject(IUnresolvedAssembly assembly)
{
object cecilObj;
if (unresolvedTypeSystemToCecilDict.TryGetValue(assembly, out cecilObj))
{
return(cecilObj as AssemblyDefinition);
}
else
{
return(null);
}
}
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);
}
// Token: 0x06000028 RID: 40 RVA: 0x00002C08 File Offset: 0x00000E08
private IAssemblyReference[] GetReferences(VSProject vsproject)
{
string[] assemblies = this.GetReferencesPaths(vsproject);
IUnresolvedAssembly[] projectContents = new IUnresolvedAssembly[assemblies.Length];
ParallelOptions parallelOptions = new ParallelOptions
{
TaskScheduler = TaskScheduler.Default
};
Parallel.For(0, assemblies.Length, parallelOptions, delegate(int i)
{
projectContents[i] = this.LoadAssembly(assemblies[i]);
});
return(projectContents);
}
public void FixtureSetUp()
{
try {
// use "IncludeInternalMembers" so that Cecil results match C# parser results
IkvmLoader loader = new IkvmLoader()
{
IncludeInternalMembers = true
};
IUnresolvedAssembly asm = loader.LoadAssemblyFile(typeof(TestCase.SimplePublicClass).Assembly.Location);
compilation = new SimpleCompilation(asm, IkvmLoaderTests.Mscorlib);
} catch (Exception e) {
Console.WriteLine(e);
throw;
}
}
public void FixtureSetUp()
{
CecilLoader loader = new CecilLoader()
{
IncludeInternalMembers = true
};
IUnresolvedAssembly pc = loader.LoadAssemblyFile(typeof(TestCase.SimplePublicClass).Assembly.Location);
FastSerializer serializer = new FastSerializer();
using (MemoryStream ms = new MemoryStream()) {
serializer.Serialize(ms, pc);
ms.Position = 0;
var asm = (IUnresolvedAssembly)serializer.Deserialize(ms);
base.compilation = new SimpleCompilation(asm, CecilLoaderTests.Mscorlib);
}
}
public Minifier(MinifierOptions options = null, string[] ignoredIdentifiers = null, string[] ignoredComments = null)
{
Options = options ?? new MinifierOptions();
_projectContent = new CSharpProjectContent();
var assemblies = new List <Assembly>
{
typeof(object).Assembly, // mscorlib
typeof(Uri).Assembly, // System.dll
typeof(Enumerable).Assembly, // System.Core.dll
};
var unresolvedAssemblies = new IUnresolvedAssembly[assemblies.Count];
Parallel.For(
0, assemblies.Count,
delegate(int i)
{
var loader = new CecilLoader();
var path = assemblies[i].Location;
unresolvedAssemblies[i] = loader.LoadAssemblyFile(assemblies[i].Location);
});
_projectContent = _projectContent.AddAssemblyReferences((IEnumerable <IUnresolvedAssembly>)unresolvedAssemblies);
IgnoredIdentifiers = ignoredIdentifiers == null ? new List <string>() : ignoredIdentifiers.ToList();
IgnoredComments = new List <string>();
if (ignoredComments != null)
{
foreach (string comment in ignoredComments)
{
var str = comment;
if (str.StartsWith("//"))
{
str = str.Substring("//".Length);
}
else if (str.StartsWith("/*") && str.EndsWith("*/"))
{
str = str.Substring("/*".Length, str.Length - "/*".Length - "*/".Length);
}
if (!IgnoredComments.Contains(str))
{
IgnoredComments.Add(str);
}
}
}
}
public SimpleCompilation(ISolutionSnapshot solutionSnapshot, IUnresolvedAssembly mainAssembly, IEnumerable <IAssemblyReference> assemblyReferences)
{
if (solutionSnapshot == null)
{
throw new ArgumentNullException("solutionSnapshot");
}
if (mainAssembly == null)
{
throw new ArgumentNullException("mainAssembly");
}
if (assemblyReferences == null)
{
throw new ArgumentNullException("assemblyReferences");
}
this.solutionSnapshot = solutionSnapshot;
this.context = new SimpleTypeResolveContext(this);
this.mainAssembly = mainAssembly.Resolve(context);
List <IAssembly> assemblies = new List <IAssembly>();
assemblies.Add(this.mainAssembly);
List <IAssembly> referencedAssemblies = new List <IAssembly>();
foreach (var asmRef in assemblyReferences)
{
IAssembly asm;
try
{
asm = asmRef.Resolve(context);
}
catch (InvalidOperationException)
{
throw new InvalidOperationException("Tried to initialize compilation with an invalid assembly reference. (Forgot to load the assembly reference ? - see CecilLoader)");
}
if (asm != null && !assemblies.Contains(asm))
{
assemblies.Add(asm);
}
if (asm != null && !referencedAssemblies.Contains(asm))
{
referencedAssemblies.Add(asm);
}
}
this.assemblies = assemblies.AsReadOnly();
this.referencedAssemblies = referencedAssemblies.AsReadOnly();
this.knownTypeCache = new KnownTypeCache(this);
}
public void AddAssemblies(IEnumerable <Assembly> assemblies)
{
var a = assemblies.ToArray();
OnAssembliesLoading(a);
var ua = new IUnresolvedAssembly[a.Length];
Parallel.For(0, a.Length, i => ua[i] = Load(a[i]));
lock (locker)
foreach (var asm in ua)
{
assemblySet.Add(asm);
}
OnInternalAssembliesLoaded(ua);
OnAssembliesLoaded(a);
}
/// <summary>
/// Gets the location of the assembly on disk.
/// If the specified assembly is a reference assembly, this method the location of the actual runtime assembly instead.
/// </summary>
/// <remarks>
/// May return null if the assembly has no location.
/// </remarks>
public static FileName GetRuntimeAssemblyLocation(this IAssembly assembly)
{
if (assembly == null)
{
throw new ArgumentNullException("assembly");
}
IUnresolvedAssembly asm = assembly.UnresolvedAssembly;
if (!(asm is IProjectContent))
{
// assembly might be in the GAC
var location = SD.GlobalAssemblyCache.FindAssemblyInNetGac(new DomAssemblyName(assembly.FullAssemblyName));
if (location != null)
{
return(location);
}
}
return(FileName.Create(assembly.UnresolvedAssembly.Location));
}
/// <summary>
/// Gets an assembly that contains BVE5's primitive and builtin types.
/// </summary>
/// <returns></returns>
public static IUnresolvedAssembly GetBuiltinAssembly()
{
if(builtin_assembly == null){
var builtin_asm = new DefaultUnresolvedAssembly("BVE5Builtin");
foreach(var primitive_type in GetPrimitiveTypeDefs())
builtin_asm.AddTypeDefinition(primitive_type);
var semantic_info = BVE5ResourceManager.RouteFileSemanticInfos;
foreach(var type_name in semantic_info.Keys){
var cur_type_def = new DefaultUnresolvedTypeDefinition("global", type_name);
InitTypeDefinition(semantic_info[type_name], cur_type_def);
builtin_asm.AddTypeDefinition(cur_type_def);
}
builtin_assembly = builtin_asm;
}
return builtin_assembly;
}
private void TestCommonBody(String source)
{
CSharpParser parser = new CSharpParser();
SyntaxTree syntaxTree = parser.Parse(source);
syntaxTree.FileName = "example.cs";
BaseReferenceExpression baseRef = syntaxTree.Descendants.OfType <BaseReferenceExpression>().First();
ExpressionStatement expr = MoveToParent <ExpressionStatement>(baseRef);
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);
ShowSubtree(expr, 0, resolver);
}
public void MethodParamsReturnAttributes()
{
const String source = "namespace ns\r\n" +
"{\r\n" +
" [System.AttributeUsage(System.AttributeTargets.Parameter)]\r\n" +
" public class AttrA : System.Attribute\r\n" +
" {\r\n" +
" }\r\n" +
" [System.AttributeUsage(System.AttributeTargets.ReturnValue)]\r\n" +
" public class AttrB : System.Attribute\r\n" +
" {\r\n" +
" }\r\n" +
" public class SomeClass\r\n" +
" {\r\n" +
" [return: AttrB]\r\n" +
" public string SomeMethod(int p1, [AttrA]string p2) { return \"iddqd\"; }\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 == "SomeMethod");
ResolveResult result = resolver.Resolve(method);
MemberResolveResult memberResult = (MemberResolveResult)result;
IMember member = memberResult.Member;
}
public CSharpCompletion(IReadOnlyList <Assembly> assemblies = null)
{
projectContent = new CSharpProjectContent();
if (assemblies == null)
{
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,
typeof(IDbConnection).Assembly, // System.Data.dll
typeof(XmlDocument).Assembly, // System.Xml.dll
typeof(XDocument).Assembly, // System.Xml.Linq.dll
};
}
assemblies = assemblies.Where(v => !v.IsDynamic).ToList();
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 Minifier(MinifierOptions options = null, string[] ignoredIdentifiers = null, string[] ignoredComments = null)
{
Options = options ?? new MinifierOptions();
_projectContent = new CSharpProjectContent();
var assemblies = new List<Assembly>
{
typeof(object).Assembly, // mscorlib
typeof(Uri).Assembly, // System.dll
typeof(Enumerable).Assembly, // System.Core.dll
};
var unresolvedAssemblies = new IUnresolvedAssembly[assemblies.Count];
Parallel.For(
0, assemblies.Count,
delegate (int i)
{
var loader = new CecilLoader();
var path = assemblies[i].Location;
unresolvedAssemblies[i] = loader.LoadAssemblyFile(assemblies[i].Location);
});
_projectContent = _projectContent.AddAssemblyReferences((IEnumerable<IUnresolvedAssembly>)unresolvedAssemblies);
IgnoredIdentifiers = ignoredIdentifiers == null ? new List<string>() : ignoredIdentifiers.ToList();
IgnoredComments = new List<string>();
if (ignoredComments != null)
foreach (var comment in ignoredComments)
{
var str = comment;
if (str.StartsWith("//"))
str = str.Substring("//".Length);
else if (str.StartsWith("/*") && str.EndsWith("*/"))
str = str.Substring("/*".Length, str.Length - "/*".Length - "*/".Length);
if (!IgnoredComments.Contains(str))
IgnoredComments.Add(str);
}
}
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.MyCommand).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 DebugCompilation(AppDomain appDomain, IUnresolvedAssembly mainAssembly, IEnumerable<IAssemblyReference> assemblyReferences)
: base(mainAssembly, assemblyReferences)
{
this.AppDomain = appDomain;
}
public AssemblyEntityModelContext(IUnresolvedAssembly mainAssembly, IAssemblyReference[] references)
{
if (mainAssembly == null)
throw new ArgumentNullException("mainAssembly");
this.mainAssembly = mainAssembly;
this.references = references;
this.compilation = new Lazy<ICompilation>(() => new SimpleCompilation(mainAssembly, references));
}
bool IsSharpDevelopAssembly(IUnresolvedAssembly pc, out Assembly assembly)
{
assembly = null;
foreach (var asm in AppDomain.CurrentDomain.GetAssemblies()) {
if (!asm.IsDynamic && asm.Location.StartsWith(sharpDevelopRoot, StringComparison.OrdinalIgnoreCase) && pc.AssemblyName == asm.GetName().Name) {
assembly = asm;
return true;
}
}
return false;
}
public SimpleCompilation(IUnresolvedAssembly mainAssembly, IEnumerable<IAssemblyReference> assemblyReferences)
: this(new DefaultSolutionSnapshot(), mainAssembly, assemblyReferences)
{
}
public SimpleCompilation(ISolutionSnapshot solutionSnapshot, IUnresolvedAssembly mainAssembly, params IAssemblyReference[] assemblyReferences)
: this(solutionSnapshot, mainAssembly, (IEnumerable<IAssemblyReference>)assemblyReferences)
{
}
AssemblyDefinition GetCecilObject(IUnresolvedAssembly assembly)
{
object cecilObj;
if (unresolvedTypeSystemToCecilDict.TryGetValue(assembly, out cecilObj)) {
return cecilObj as AssemblyDefinition;
} else {
return null;
}
}
