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 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; } }