public Rewriter(CSharpCompilation compilation, AnalyzerResult result) { tree = (CSharpSyntaxTree) compilation.SyntaxTrees.Single(); model = compilation.GetSemanticModel(tree); this.compilation = compilation; this.result = result; }
public static void ConvertRoslynToCCI( IMetadataHost host, CSharpSyntaxTree tree, SemanticModel semanticModel, out IModule module, out ISourceLocationProvider sourceLocationProvider) { sourceLocationProvider = new SourceLocationProvider(); var transformer = new NodeVisitor(host, semanticModel, sourceLocationProvider); var assembly = (Module)transformer.Visit(tree.GetRoot()); assembly.Location = Path.GetFullPath(tree.FilePath); module = assembly; }
/// <summary> /// /// </summary> /// <param name="name"></param> /// <param name="path"></param> /// <param name="sourceTree"></param> /// <param name="loadMsCoreLib"></param> /// <returns></returns> public static CSharpCompilation RetrieveCompilation(string name, string path, CSharpSyntaxTree sourceTree, bool loadMsCoreLib = false) { var references = new List<MetadataReference>(); var assembly = MetadataReference.CreateFromFile(path); // The target assembly we want to translate references.Add(assembly); if (loadMsCoreLib) { var mscorelib = GetMsCoreLibMetadataReference(); // .NET native references.Add(mscorelib); } return CSharpCompilation.Create(name, new[] { sourceTree }, references); }
/// <summary> /// Transforms the tree. /// </summary> /// <param name="node">The node which will be impacted by the transformation.</param> /// <param name="compilation">The compilation containing the semantic model associated to the node.</param> public void Transform(ref CSharpSyntaxTree tree, ref CSharpCompilation compilation) { if (tree == null) { throw new ArgumentNullException(nameof(tree), "A tree is needed!"); } if (compilation == null) { throw new ArgumentNullException(nameof(compilation), "A compilation is needed!"); } // 1. Initialize this.Initialize(tree, compilation); var res = GetTeeSymbols(this.tree, this.compilation.GetSemanticModel(this.tree)).ToArray(); // TBR // 2.1. Analyze this.RetrieveOverridenNamespaceNames(); // 2.2. Rearrange this.ProcessOverridenNamespaceNames(); // 2.3. Using directives handling for fixing references inside namespaces this.RetrieveAllUsingDirectivesAndCopyAtRootLevel(); // 2.4. Tidy up this.CleanUpCompilationUnit(); // 3. Update compilation and semantics this.UpdateCompilation(); // 4. Updating references compilation = this.newCompilation; tree = this.newNode.SyntaxTree as CSharpSyntaxTree; //var diagnostics = this.compilation.GetSemanticModel(this.tree).GetDiagnostics(); // TBR, used to check errors //var newDiagnostics = this.newCompilation.GetSemanticModel(this.newTree).GetDiagnostics(); // TBR, used to check errors // 5. Clean resources this.CleanUp(); }
public async Task <SimAnticsModule> CompileModule() { var translator = new CSTranslator(); var objIff = File.MainIff; var refs = GetReferences().ToList(); if (!IsGlobal) { var global = await Context.GetGlobal(); translator.Context.GlobalRes = global.File; translator.Context.GlobalModule = global.Module; refs.Add(MetadataReference.CreateFromFile(global.FilePath + ".dll")); } else { translator.Context.GlobalRes = File; } var sg = File.SemiGlobal; if (sg != null) { var sgModule = await Context.GetSemiglobal(sg); translator.Context.SemiGlobalRes = sg; translator.Context.SemiGlobalModule = sgModule.Module; refs.Add(MetadataReference.CreateFromFile(sgModule.FilePath + ".dll")); } translator.Context.ObjectRes = File; // create the cs source Console.WriteLine($"Translating {objIff.Filename}"); var objText = translator.TranslateIff(objIff); // compile it into an assembly with roslyn var options = new CSharpCompilationOptions(Microsoft.CodeAnalysis.OutputKind.DynamicallyLinkedLibrary, optimizationLevel: Context.Debug ? OptimizationLevel.Debug : OptimizationLevel.Release, moduleName: translator.Context.NamespaceName, platform: Platform.AnyCpu, warningLevel: 0); if (Context.Debug) { using (var files = System.IO.File.Open(FilePath + ".cs", System.IO.FileMode.Create)) { using (var writer = new System.IO.StreamWriter(files)) { writer.Write(objText); } } } var file = CSharpSyntaxTree.ParseText(objText, new CSharpParseOptions(), Path.GetFullPath(FilePath + ".cs"), Encoding.UTF8); var compiler = CSharpCompilation.Create(translator.Context.NamespaceName, options: options, references: refs, syntaxTrees: new List <SyntaxTree>() { file }); // save the assembly to disk for later use var emitResult = compiler.Emit(FilePath + ".dll", Context.Debug ? (FilePath + ".pdb") : null, Context.Debug ? (FilePath + ".xml") : null); // load the assembly if (!emitResult.Success) { return(null); } try { var assembly = Assembly.LoadFile(Path.GetFullPath(FilePath + ".dll")); return(FindModuleInAssembly(assembly)); } catch (Exception e) { return(null); } }
private void Initialize(CSharpSyntaxTree tree, CSharpCompilation compilation) { this.tree = tree; if (this.tree.GetRoot() as CompilationUnitSyntax == null) { throw new ArgumentException(nameof(node), $"This class expects root nodes of type: {typeof(CompilationUnitSyntax).Name}!"); } this.node = this.tree.GetRoot() as CompilationUnitSyntax; this.compilation = compilation; this.transformationInfos = new List<TransformationInfo>(); this.removableNamespaces = new List<SyntaxNode>(); }
/// <summary> /// 编译dll /// </summary> /// <param name="rootpaths"></param> /// <param name="output"></param> static public bool BuildByRoslyn(string[] dlls, string[] codefiles, string output, bool isdebug = false) { //添加语法树 //宏解析 var Symbols = define.Split(';'); List <Microsoft.CodeAnalysis.SyntaxTree> codes = new List <Microsoft.CodeAnalysis.SyntaxTree>(); var opa = new CSharpParseOptions(LanguageVersion.Latest, preprocessorSymbols: Symbols); foreach (var cs in codefiles) { var content = File.ReadAllText(cs); var syntaxTree = CSharpSyntaxTree.ParseText(content, opa, cs, Encoding.UTF8); codes.Add(syntaxTree); } //添加dll List <MetadataReference> assemblies = new List <MetadataReference>(); foreach (var dll in dlls) { var metaref = MetadataReference.CreateFromFile(dll); if (metaref != null) { assemblies.Add(metaref); } } //创建目录 var dir = Path.GetDirectoryName(output); Directory.CreateDirectory(dir); //编译参数 CSharpCompilationOptions option = null; if (isdebug) { option = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary, optimizationLevel: OptimizationLevel.Debug, checkOverflow: true, allowUnsafe: true ); } else { option = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary, optimizationLevel: OptimizationLevel.Release, checkOverflow: true, allowUnsafe: true ); } //创建编译器代理 var compilation = CSharpCompilation.Create(Path.GetFileName(output), codes, assemblies, option); EmitResult result = null; if (!isdebug) { result = compilation.Emit(output); } else { var pdbPath = output + ".pdb"; var emitOptions = new EmitOptions( debugInformationFormat: DebugInformationFormat.PortablePdb, pdbFilePath: pdbPath); using (var dllStream = new MemoryStream()) using (var pdbStream = new MemoryStream()) { result = compilation.Emit(dllStream, pdbStream, options: emitOptions); File.WriteAllBytes(output, dllStream.GetBuffer()); File.WriteAllBytes(pdbPath, pdbStream.GetBuffer()); } } // 编译失败,提示 if (!result.Success) { IEnumerable <Diagnostic> failures = result.Diagnostics.Where(diagnostic => diagnostic.IsWarningAsError || diagnostic.Severity == DiagnosticSeverity.Error); foreach (var diagnostic in failures) { Debug.LogError(diagnostic.ToString()); } } return(result.Success); }
private void ConvertDialog() { var dialogFiles = Tig.FS.ListDirectory("dlg") .Where(f => f.EndsWith(".dlg")) .Distinct() .ToList(); Console.WriteLine($"Found {dialogFiles.Count} dialog files."); var dlgFilePattern = new Regex(@"(\d{5}).*"); foreach (var dialogFile in dialogFiles) { var m = dlgFilePattern.Match(dialogFile); if (!m.Success) { Console.WriteLine($"Skipping dialog file that doesn't match expected pattern: {dialogFile}'."); continue; } var scriptId = int.Parse(m.Groups[1].Value); var associatedScript = _convertedScripts.FirstOrDefault(s => s.Type == ScriptType.Object && s.ScriptId == scriptId); if (associatedScript == null) { Console.WriteLine($"Dialog file {dialogFile} with id {scriptId} has no associated script!"); continue; } var outputDir = Path.Join( Path.GetDirectoryName(associatedScript.OutputPath), "Dialog" ); Directory.CreateDirectory(Path.Combine(_outputDirectory, outputDir)); var outputPath = Path.Join(outputDir, Path.GetFileNameWithoutExtension(associatedScript.OutputPath) + "Dialog.cs"); if (_writeDialog) { File.Delete(Path.Combine(_outputDirectory, outputPath)); } var dialogContent = Tig.FS.ReadTextFile("dlg/" + dialogFile); var parser = new DialogScriptParser(dialogFile, dialogContent); // We're going to build a class file for the dialog script that contains two methods, // and extends from the object script of the same script id var conditions = new List <(int, string, string)>(); var effects = new List <(int, string, string)>(); var skillChecks = new List <(int, SkillCheck)>(); while (parser.GetSingleLine(out var dialogLine, out var fileLine)) { var effectPython = dialogLine.effectField; if (effectPython == "pc.barter(npc)" && dialogLine.txt.StartsWith("b:", StringComparison.OrdinalIgnoreCase)) { continue; // Skip bogus barter effect (this is implied by B:) } try { if (!string.IsNullOrEmpty(effectPython)) { var converted = converter.ConvertSnippet(effectPython, associatedScript, DialogContext); effects.Add((dialogLine.key, effectPython, converted)); } } catch (Exception e) { Console.WriteLine( $"[e] Failed to convert effect for line {dialogLine.key} ({effectPython}): {e}"); effects.Add((dialogLine.key, effectPython, null)); } if (dialogLine.IsPcLine) { var conditionPython = dialogLine.testField; try { if (!string.IsNullOrEmpty(conditionPython)) { foreach (var skillCheck in converter.FindSkillChecks(conditionPython)) { skillChecks.Add((dialogLine.key, skillCheck)); } var converted = converter.ConvertSnippet(conditionPython, associatedScript, DialogContext); conditions.Add((dialogLine.key, conditionPython, converted)); } } catch (Exception e) { Console.WriteLine( $"[e] Failed to convert condition for line {dialogLine.key} ({conditionPython}): {e}"); conditions.Add((dialogLine.key, conditionPython, null)); } } } if (_writeDialog) { var dialogScript = new StringBuilder(); dialogScript.AppendLine(@" using System; using System.Collections.Generic; using System.Diagnostics; using OpenTemple.Core.GameObject; using OpenTemple.Core.Systems; using OpenTemple.Core.Systems.Dialog; using OpenTemple.Core.Systems.Feats; using OpenTemple.Core.Systems.D20; using OpenTemple.Core.Systems.Script; using OpenTemple.Core.Systems.Spells; using OpenTemple.Core.Systems.GameObjects; using OpenTemple.Core.Systems.D20.Conditions; using OpenTemple.Core.Location; using OpenTemple.Core.Systems.ObjScript; using OpenTemple.Core.Ui; using System.Linq; using OpenTemple.Core.Systems.Script.Extensions; using OpenTemple.Core.Utils; using static OpenTemple.Core.Systems.Script.ScriptUtilities; "); dialogScript.AppendLine("namespace " + associatedScript.Namespace + ".Dialog"); dialogScript.AppendLine("{"); dialogScript.Append("[DialogScript(").Append(associatedScript.ScriptId).AppendLine(")]"); dialogScript.AppendLine("public class " + associatedScript.ClassName + "Dialog : " + associatedScript.ClassName + ", IDialogScript"); dialogScript.AppendLine("{"); WriteDialogMethod(dialogScript, conditions, false); WriteDialogMethod(dialogScript, effects, true); WriteSkillChecksMethod(dialogScript, skillChecks); dialogScript.AppendLine("}"); dialogScript.AppendLine("}"); var parseOptions = new CSharpParseOptions(LanguageVersion.Latest); var syntaxTree = CSharpSyntaxTree.ParseText(dialogScript.ToString(), parseOptions); var formattedNode = Formatter.Format(syntaxTree.GetRoot(), workspace); File.WriteAllText(Path.Join(_outputDirectory, outputPath), formattedNode.ToFullString()); } } }
public static bool TryGetJsonForAnonymousType(this string anonymousTypeString, out string json) { json = null; foreach (var substitution in Substitutions) { anonymousTypeString = anonymousTypeString.Replace(substitution.Key, substitution.Value); } var text = $@" using System; using System.Collections.Generic; using System.ComponentModel; using Newtonsoft.Json; using Newtonsoft.Json.Linq; namespace Temporary {{ public class Json {{ public string Write() {{ var o = {anonymousTypeString}; var json = JsonConvert.SerializeObject(o, Formatting.Indented); return json; }} }} }}" ; var syntaxTree = CSharpSyntaxTree.ParseText(text); var assemblyName = Path.GetRandomFileName(); var references = new List <MetadataReference> { MetadataReference.CreateFromFile(typeof(object).GetTypeInfo().Assembly.Location), MetadataReference.CreateFromFile(typeof(Enumerable).GetTypeInfo().Assembly.Location), MetadataReference.CreateFromFile(typeof(JsonConvert).GetTypeInfo().Assembly.Location), MetadataReference.CreateFromFile(typeof(ITypedList).GetTypeInfo().Assembly.Location), }; var systemReferences = new string[] { "System.Runtime, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", "System.ObjectModel, Version=4.0.10.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", "System.Dynamic.Runtime, Version=4.0.10.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", "System.Linq.Expressions, Version=4.2.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" }; foreach (var r in systemReferences) { var location = Assembly.Load(r).Location; references.Add(MetadataReference.CreateFromFile(location)); } var compilation = CSharpCompilation.Create( assemblyName, new[] { syntaxTree }, references, new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); using (var ms = new MemoryStream()) { var result = compilation.Emit(ms); if (!result.Success) { var failures = result.Diagnostics.Where(diagnostic => diagnostic.IsWarningAsError || diagnostic.Severity == DiagnosticSeverity.Error); var builder = new StringBuilder($"Unable to serialize the following C# anonymous type string to json: {anonymousTypeString}"); foreach (var diagnostic in failures) { builder.AppendLine($"{diagnostic.Id}: {diagnostic.GetMessage()}"); } builder.AppendLine(new string('-', 30)); Console.Error.WriteLine(builder.ToString()); return(false); } ms.Seek(0, SeekOrigin.Begin); var assembly = Assembly.Load(ms.ToArray()); var type = assembly.GetType("Temporary.Json"); var obj = Activator.CreateInstance(type); var output = type.InvokeMember("Write", BindingFlags.Default | BindingFlags.InvokeMethod, null, obj, new object[] { }); json = output.ToString(); return(true); } }
/// <summary> /// Creates a CSharpSyntaxTree instance. /// </summary> /// <param name="sourceCode"></param> /// <param name="sourceCodePath"></param> /// <returns></returns> public override Microsoft.CodeAnalysis.SyntaxTree GetSyntaxTree(string sourceCode, string sourceCodePath) { return(CSharpSyntaxTree.ParseText(sourceCode, path: sourceCodePath, encoding: System.Text.Encoding.UTF8)); }
private static SyntaxTree Parse(string snippet) => CSharpSyntaxTree.ParseText(snippet);
static Dictionary <string, IPropertyAccessor> GetAccessorTypes(Type type, string code) { var sourceCode = $"using System;\r\nusing Olive.Entities;\r\nusing System.Data;{code}"; var syntaxTree = CSharpSyntaxTree.ParseText(sourceCode); var assemblyPath = Path.GetDirectoryName(typeof(object).Assembly.Location); var assemblyName = Path.GetRandomFileName(); var references2 = Cache.GetOrAdd(type.Assembly, assembly => { var references = new List <PortableExecutableReference> { MetadataReference.CreateFromFile(typeof(IEntity).Assembly.Location), MetadataReference.CreateFromFile(type.Assembly.Location), MetadataReference.CreateFromFile(typeof(Guid).Assembly.Location), MetadataReference.CreateFromFile(Path.Combine(assemblyPath, "System.Private.CoreLib.dll")), MetadataReference.CreateFromFile(Path.Combine(assemblyPath, "System.Data.Common.dll")), MetadataReference.CreateFromFile(Path.Combine(assemblyPath, "System.Console.dll")), MetadataReference.CreateFromFile(Path.Combine(assemblyPath, "System.Runtime.dll")), MetadataReference.CreateFromFile(Path.Combine(assemblyPath, "netstandard.dll")), }; foreach (var item in type.Assembly.GetReferencedAssemblies()) { references.Add(MetadataReference.CreateFromFile(Assembly.Load(item).Location)); } return(references); }); var compilation = CSharpCompilation.Create( assemblyName, syntaxTrees: new[] { syntaxTree }, references: references2, options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); using (var stream = new MemoryStream()) { var emitResult = compilation.Emit(stream); if (!emitResult.Success) { var error = new Exception("DataProviderMetaDataGenerator failed." + emitResult.Diagnostics.Where(x => x.Severity == DiagnosticSeverity.Error) .Select(v => v.GetMessage()).Distinct().ToLinesString().WithPrefix(Environment.NewLine)); Console.WriteLine(error.Message); throw error; } stream.Seek(0, SeekOrigin.Begin); var assembly = Assembly.Load(stream.ToArray()); var result = new Dictionary <string, IPropertyAccessor>(); foreach (var accessorType in assembly.GetTypes()) { result.Add(accessorType.Name, (IPropertyAccessor)Activator.CreateInstance(accessorType)); } return(result); } }
public static void Document(Action shouldMethod, ITestOutputHelper testOutputHelper, Action <ShouldMatchConfigurationBuilder>?additionConfig = null) { var stackTrace = new StackTrace(true); var caller = stackTrace.GetFrame(1) !; var callerFileName = caller.GetFileName() !; var callerMethod = caller.GetMethod() !; var testMethod = FileMethodsLookup.GetOrAdd(callerFileName, fn => { var callerFile = File.ReadAllText(fn); var syntaxTree = CSharpSyntaxTree.ParseText(callerFile); return(syntaxTree.GetRoot() .DescendantNodes() .OfType <MethodDeclarationSyntax>().ToList()); }).Single(m => m.Identifier.ValueText == callerMethod.Name); var documentCall = testMethod.DescendantNodes() .OfType <InvocationExpressionSyntax>() .First(); var shouldMethodCallSyntax = documentCall.ArgumentList.Arguments[0]; var blockSyntax = shouldMethodCallSyntax.DescendantNodes() .OfType <BlockSyntax>() .First(); var enumerable = blockSyntax .Statements .Select(s => s.WithoutLeadingTrivia().ToFullString()); var body = string.Join(string.Empty, enumerable).Trim(); var exceptionText = Should.Throw <Exception>(shouldMethod).Message; testOutputHelper.WriteLine("Docs body:"); testOutputHelper.WriteLine(""); testOutputHelper.WriteLine(body); testOutputHelper.WriteLine(""); testOutputHelper.WriteLine(""); testOutputHelper.WriteLine("Exception text:"); testOutputHelper.WriteLine(""); testOutputHelper.WriteLine(exceptionText); Func <string, string> scrubber = v => Regex.Replace(v, @"\w:.+?shouldly\\src", "C:\\PathToCode\\shouldly\\src"); try { body.ShouldMatchApproved(configurationBuilder => { configurationBuilder .WithDiscriminator("codeSample") .UseCallerLocation() .SubFolder("CodeExamples") .WithScrubber(scrubber).WithFileExtension(".cs"); additionConfig?.Invoke(configurationBuilder); }); } finally { exceptionText = $@"``` {exceptionText} ``` "; exceptionText.ShouldMatchApproved(configurationBuilder => { configurationBuilder .WithDiscriminator("exceptionText") .UseCallerLocation() .SubFolder("CodeExamples") .WithScrubber(scrubber); additionConfig?.Invoke(configurationBuilder); }); } }
private static Type[] LoadCSScript(string file) { var text = File.ReadAllText(file); // define source code, then parse it (to the type used for compilation) SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(text); // define other necessary objects for compilation string assemblyName = Path.GetRandomFileName(); List <MetadataReference> references = new() { MetadataReference.CreateFromFile(typeof(object).Assembly.Location), MetadataReference.CreateFromFile(typeof(Enumerable).Assembly.Location), MetadataReference.CreateFromFile(typeof(IPerformanceTest).Assembly.Location), MetadataReference.CreateFromFile(typeof(HttpRequestMessage).Assembly.Location), MetadataReference.CreateFromFile(typeof(Uri).Assembly.Location), MetadataReference.CreateFromFile(typeof(object).Assembly.Location), MetadataReference.CreateFromFile(typeof(GCLatencyMode).Assembly.Location), MetadataReference.CreateFromFile(Assembly.GetEntryAssembly() !.Location) }; Assembly.GetEntryAssembly() !.GetReferencedAssemblies().ToList() .ForEach(a => references.Add(MetadataReference.CreateFromFile(Assembly.Load(a).Location))); // analyse and generate IL code from syntax tree CSharpCompilation compilation = CSharpCompilation.Create( assemblyName, new[] { syntaxTree }, references, new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary, optimizationLevel: OptimizationLevel.Release)); using var ms = new MemoryStream(); // write IL code into memory EmitResult result = compilation.Emit(ms); if (!result.Success) { // handle exceptions IEnumerable <Diagnostic> failures = result.Diagnostics.Where(diagnostic => diagnostic.IsWarningAsError || diagnostic.Severity == DiagnosticSeverity.Error); foreach (Diagnostic diagnostic in failures) { Console.Error.WriteLine("{0}: {1}", diagnostic.Id, diagnostic.GetMessage()); } } else { // load this 'virtual' DLL so that we can use ms.Seek(0, SeekOrigin.Begin); Assembly assembly = Assembly.Load(ms.ToArray()); return((from type in assembly.GetTypes() where type.BaseType == typeof(IPerformanceTest) select type).ToArray()); } return(Array.Empty <Type>()); }
public void TestSetup() { var syntaxTree = CSharpSyntaxTree.ParseText(Source); methods = syntaxTree.GetRoot().DescendantNodes().OfType <MethodDeclarationSyntax>().ToList(); }
public SyntaxTree ParseText(string text) { var syntaxTree = CSharpSyntaxTree.ParseText(text); return(syntaxTree); }
public static AssemblyDefinition GenerateSerializationAssembly(PlatformType platformType, BaseAssemblyResolver assemblyResolver, AssemblyDefinition assembly, string serializationAssemblyLocation, string signKeyFile, List <string> references, List <AssemblyDefinition> memoryReferences, ILogger log) { // Create the serializer code generator var serializerGenerator = new ComplexSerializerCodeGenerator(assemblyResolver, assembly, log); // Register default serialization profile (to help AOT generic instantiation of serializers) RegisterDefaultSerializationProfile(assemblyResolver, assembly, serializerGenerator); // Generate serializer code var serializerGeneratedCode = serializerGenerator.TransformText(); var syntaxTree = CSharpSyntaxTree.ParseText(serializerGeneratedCode); // Add reference from source assembly // Use a hash set because it seems including twice mscorlib (2.0 and 4.0) seems to be a problem. var skipWindows = "Windows, Version=255.255.255.255, Culture=neutral, PublicKeyToken=null"; var compilerOptions = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary, allowUnsafe: true, assemblyIdentityComparer: DesktopAssemblyIdentityComparer.Default); // Sign the serialization assembly the same way the source was signed // TODO: Transmit over command line if (assembly.Name.HasPublicKey) { // TODO: If delay signed, we could actually extract the public key and apply it ourself maybe? if (signKeyFile == null) { throw new InvalidOperationException("Generating serialization code for signed assembly, but no key was specified."); } compilerOptions = compilerOptions.WithCryptoKeyFile(signKeyFile).WithStrongNameProvider(new DesktopStrongNameProvider()); if ((assembly.MainModule.Attributes & ModuleAttributes.StrongNameSigned) != ModuleAttributes.StrongNameSigned) { // Delay signed compilerOptions = compilerOptions.WithDelaySign(true); } } // Add references (files and in-memory PE data) var metadataReferences = new List <MetadataReference>(); foreach (var reference in references) { metadataReferences.Add(MetadataReference.CreateFromFile(reference)); } foreach (var reference in memoryReferences) { metadataReferences.Add(CreateMetadataReference(assemblyResolver, reference)); } // typeof(Dictionary<,>) // Special case for 4.5: Because Dictionary<,> is forwarded, we need to add a reference to the actual assembly var mscorlibAssembly = CecilExtensions.FindCorlibAssembly(assembly); metadataReferences.Add(CreateMetadataReference(assemblyResolver, mscorlibAssembly)); var collectionType = mscorlibAssembly.MainModule.GetTypeResolved(typeof(Dictionary <,>).FullName); metadataReferences.Add(CreateMetadataReference(assemblyResolver, collectionType.Module.Assembly)); metadataReferences.Add(CreateMetadataReference(assemblyResolver, assembly)); // In case SiliconStudio.Core was not referenced, let's add it. if (assembly.Name.Name != "SiliconStudio.Core" && !references.Any(x => string.Compare(Path.GetFileNameWithoutExtension(x), "SiliconStudio.Core", StringComparison.OrdinalIgnoreCase) == 0)) { metadataReferences.Add(CreateMetadataReference(assemblyResolver, assemblyResolver.Resolve("SiliconStudio.Core"))); } // Create roslyn compilation object var assemblyName = assembly.Name.Name + ".Serializers"; var compilation = CSharpCompilation.Create(assemblyName, new[] { syntaxTree }, metadataReferences, compilerOptions); // Do the actual compilation, and check errors using (var peStream = new FileStream(serializationAssemblyLocation, FileMode.Create, FileAccess.Write)) { var compilationResult = compilation.Emit(peStream); if (!compilationResult.Success) { var errors = new StringBuilder(); errors.AppendLine(string.Format("Serialization assembly compilation: {0} error(s)", compilationResult.Diagnostics.Count(x => x.Severity >= DiagnosticSeverity.Error))); foreach (var error in compilationResult.Diagnostics) { if (error.Severity >= DiagnosticSeverity.Warning) { errors.AppendLine(error.ToString()); } } throw new InvalidOperationException(errors.ToString()); } } var repackOptions = new ILRepacking.RepackOptions(new string[0]) { OutputFile = assembly.MainModule.FullyQualifiedName, DebugInfo = true, CopyAttributes = true, AllowMultipleAssemblyLevelAttributes = true, XmlDocumentation = false, NoRepackRes = true, InputAssemblies = new[] { serializationAssemblyLocation }, SearchDirectories = assemblyResolver.GetSearchDirectories(), SearchAssemblies = references, }; // Run ILMerge var merge = new ILRepacking.ILRepack(repackOptions) { PrimaryAssemblyDefinition = assembly, MemoryOnly = true, //KeepFirstOfMultipleAssemblyLevelAttributes = true, //Log = true, //LogFile = "ilmerge.log", }; try { merge.Repack(); } catch (Exception) { log.Log(new LogMessage("ILRepack", LogMessageType.Error, string.Format("Error while ILRepacking {0}", assembly.Name.Name))); throw; } // Copy name merge.TargetAssemblyDefinition.Name.Name = assembly.Name.Name; merge.TargetAssemblyDefinition.Name.Version = assembly.Name.Version; // Add assembly signing info if (assembly.Name.HasPublicKey) { merge.TargetAssemblyDefinition.Name.PublicKey = assembly.Name.PublicKey; merge.TargetAssemblyDefinition.Name.PublicKeyToken = assembly.Name.PublicKeyToken; merge.TargetAssemblyDefinition.Name.Attributes |= AssemblyAttributes.PublicKey; if ((assembly.MainModule.Attributes & ModuleAttributes.StrongNameSigned) == ModuleAttributes.StrongNameSigned) { merge.TargetAssemblyMainModule.Attributes |= ModuleAttributes.StrongNameSigned; } } try { // Delete serializer dll File.Delete(serializationAssemblyLocation); var serializationAssemblyPdbFilePath = Path.ChangeExtension(serializationAssemblyLocation, "pdb"); if (File.Exists(serializationAssemblyPdbFilePath)) { File.Delete(serializationAssemblyPdbFilePath); } } catch (IOException) { // Mute IOException } return(merge.TargetAssemblyDefinition); }
private static bool DoHandleDrop([NotNull] Store store, [NotNull] string filename) { if (store == null) { throw new ArgumentNullException(nameof(store)); } if (filename == null) { throw new ArgumentNullException(nameof(filename)); } try { if (string.IsNullOrEmpty(filename)) { return(false); } // read the file string fileContents = File.ReadAllText(filename); // parse the contents SyntaxTree tree = CSharpSyntaxTree.ParseText(fileContents); if (tree.GetRoot() is CompilationUnitSyntax root) { List <ClassDeclarationSyntax> classDecls = root.DescendantNodes().OfType <ClassDeclarationSyntax>().Where(classDecl => classDecl.BaseList == null || classDecl.BaseList.Types.FirstOrDefault()?.ToString() != "DbContext").ToList(); List <EnumDeclarationSyntax> enumDecls = root.DescendantNodes().OfType <EnumDeclarationSyntax>().ToList(); if (!classDecls.Any() && !enumDecls.Any()) { WarningDisplay.Show($"Couldn't find any classes or enums to add to the model in {filename}"); return(false); } // keep this order: enums, classes, class properties foreach (EnumDeclarationSyntax enumDecl in enumDecls) { ProcessEnum(store, enumDecl); } List <ModelClass> processedClasses = new List <ModelClass>(); foreach (ClassDeclarationSyntax classDecl in classDecls) { processedClasses.Add(ProcessClass(store, classDecl)); } // process last so all classes and enums are already in the model foreach (ClassDeclarationSyntax classDecl in classDecls) { ProcessProperties(store, classDecl); } // now that all the properties are in, go through the classes again and ensure identities are present based on convention // ReSharper disable once LoopCanBePartlyConvertedToQuery foreach (ModelClass modelClass in processedClasses.Where(c => !c.AllIdentityAttributes.Any())) { // no identity attribute. Only look in current class for attributes that could be identity by convention List <ModelAttribute> identitiesByConvention = modelClass.Attributes.Where(a => a.Name == "Id" || a.Name == $"{modelClass.Name}Id").ToList(); // if both 'Id' and '[ClassName]Id' are present, don't do anything since we don't know which to make the identity if (identitiesByConvention.Count == 1) { using (Transaction transaction = store.TransactionManager.BeginTransaction("Add identity")) { identitiesByConvention[0].IsIdentity = true; transaction.Commit(); } } } } } catch { ErrorDisplay.Show("Error interpreting " + filename); return(false); } return(true); }
private byte[] CompileByte(string originalClassName, string originalText) { Console.WriteLine(assemblieslist); if (assemblieslist == null) { string replstr = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "file:///" : "file://"; var assemblies = CompilerServicesUtility .GetLoadedAssemblies() .Where(a => !a.IsDynamic && File.Exists(a.CodeBase.Replace(replstr, ""))) .Select(a => (a.CodeBase.Replace(replstr, ""))); int c = assemblies.Count(); assemblieslist = new MetadataReference[c]; int i = 0; foreach (string item in assemblies) { assemblieslist[i] = (MetadataReference.CreateFromFile(item)); i++; } } CSharpCompilation compilation = null; var syntaxTree = CSharpSyntaxTree.ParseText(originalText); // 指定编译选项。 var assemblyName = $"{originalClassName}.g"; compilation = CSharpCompilation.Create(assemblyName, new[] { syntaxTree }, options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)) .AddReferences( // 这算是偷懒了吗?我把 .NET Core 运行时用到的那些引用都加入到引用了。 // 加入引用是必要的,不然连 object 类型都是没有的,肯定编译不通过。 //AppDomain.CurrentDomain.GetAssemblies().Select(x => MetadataReference.CreateFromFile(x.Location)) assemblieslist ); // 编译到内存流中。 byte [] buff = null; using (var ms = new MemoryStream()) { var result = compilation.Emit(ms); if (result.Success) { ms.Seek(0, SeekOrigin.Begin); buff = ms.ToArray(); } else { string errmsg = ""; for (int i1 = 0; i1 < result.Diagnostics.Length; i1++) { errmsg += result.Diagnostics[i1] + "\r\n"; } throw new Exception(errmsg); } ms.Close(); } /* * for (int i1=0;i1< list.Length;i1++) * { * list[i1] = null; * } */ return(buff); // } //catch (Exception e) //{ //} return(null); }
public static CSharpSyntaxTree ParseText(string code) { return((CSharpSyntaxTree)CSharpSyntaxTree.ParseText(code)); }
protected static CSharpSyntaxTree Parse(string text, string path = null) { return((CSharpSyntaxTree)CSharpSyntaxTree.ParseText(text, CSharpParseOptions, path: path)); }
public async Task ReturnsDefinitionInMetadata_FromMetadata_WhenSymbolIsType(string filename) { var testFile = new TestFile(filename, @" using System; class Bar { public void Baz() { var number = in$$t.MaxValue; } }"); using (var host = CreateOmniSharpHost(testFile)) { var point = testFile.Content.GetPointFromPosition(); // 1. start by asking for definition of "int" var gotoDefinitionRequest = new GotoDefinitionRequest { FileName = testFile.FileName, Line = point.Line, Column = point.Offset, WantMetadata = true }; var gotoDefinitionRequestHandler = GetRequestHandler(host); var gotoDefinitionResponse = await gotoDefinitionRequestHandler.Handle(gotoDefinitionRequest); // 2. now, based on the response information // go to the metadata endpoint, and ask for "int" specific metadata var metadataRequest = new MetadataRequest { AssemblyName = gotoDefinitionResponse.MetadataSource.AssemblyName, TypeName = gotoDefinitionResponse.MetadataSource.TypeName, ProjectName = gotoDefinitionResponse.MetadataSource.ProjectName, Language = gotoDefinitionResponse.MetadataSource.Language }; var metadataRequestHandler = host.GetRequestHandler <MetadataService>(OmniSharpEndpoints.Metadata); var metadataResponse = await metadataRequestHandler.Handle(metadataRequest); // 3. the metadata response contains SourceName (metadata "file") and SourceText (syntax tree) // use the source to locate "IComparable" which is an interface implemented by Int32 struct var metadataTree = CSharpSyntaxTree.ParseText(metadataResponse.Source); var iComparable = metadataTree.GetCompilationUnitRoot(). DescendantNodesAndSelf(). OfType <BaseTypeDeclarationSyntax>().First(). BaseList.Types.FirstOrDefault(x => x.Type.ToString() == "IComparable"); var relevantLineSpan = iComparable.GetLocation().GetLineSpan(); // 4. now ask for the definition of "IComparable" // pass in the SourceName (metadata "file") as FileName - since it's not a regular file in our workspace var metadataNavigationRequest = new GotoDefinitionRequest { FileName = metadataResponse.SourceName, Line = relevantLineSpan.StartLinePosition.Line, Column = relevantLineSpan.StartLinePosition.Character, WantMetadata = true }; var metadataNavigationResponse = await gotoDefinitionRequestHandler.Handle(metadataNavigationRequest); // 5. validate the response to be matching the expected IComparable meta info Assert.NotNull(metadataNavigationResponse.MetadataSource); Assert.Equal(AssemblyHelpers.CorLibName, metadataNavigationResponse.MetadataSource.AssemblyName); Assert.Equal("System.IComparable", metadataNavigationResponse.MetadataSource.TypeName); Assert.NotEqual(0, metadataNavigationResponse.Line); Assert.NotEqual(0, metadataNavigationResponse.Column); } }
private static void Main(string[] args) { string attribute = ""; string csvOutputFile = ""; string directoryToScan = ""; string negativeSearch = ""; Dictionary <String, List <Result> > results = new Dictionary <string, List <Result> >(); try { var options = new Options(); bool isFlagValid = options.OptionParser(args, out csvOutputFile, out attribute, out directoryToScan, out negativeSearch); // If Command-line options not set correctly, show default message and exit if (!isFlagValid) { System.Environment.Exit(0); } if (String.IsNullOrEmpty(csvOutputFile)) { DateTime dt = DateTime.Now; String timestamp = dt.ToString("yyyyMMddHHmmss"); csvOutputFile = "enumerated_controllers_" + timestamp + ".csv"; } string curDir = Directory.GetCurrentDirectory(); if (String.IsNullOrEmpty(directoryToScan)) { directoryToScan = curDir; } string[] paths = Directory.GetFiles(directoryToScan, "*.cs", SearchOption.AllDirectories); if (paths.Length > 0) { foreach (var path in paths) { using (var stream = File.OpenRead(path)) { var tree = CSharpSyntaxTree.ParseText(SourceText.From(stream), path: path); SyntaxNode root = tree.GetRoot(); // Check if the Class inherits Apicontroller or Controller and print out all the public entry points ControllerChecker controllerchk = new ControllerChecker(); if (controllerchk.inheritsFromController(root, attribute)) { controllerchk.enumerateEntrypoints(root, attribute, negativeSearch, path, results); } } } string[] controllerPaths = results.Keys.ToArray(); String pathToTrim = getPathToTrim(controllerPaths); if (!String.IsNullOrEmpty(attribute) || !String.IsNullOrEmpty(negativeSearch)) { printCommandLineResults(results, pathToTrim); } printCSVResults(results, csvOutputFile, pathToTrim); } } catch (DirectoryNotFoundException) { Console.WriteLine("Invalid Path"); } catch (IndexOutOfRangeException) { //Shoudn't Reach this, but in case Console.WriteLine("No Arguments passed"); } catch (UnauthorizedAccessException e) { e.GetBaseException(); Console.WriteLine("You do not seem to have appropiate Permissions on this direcctory"); } catch (NotSupportedException) { Console.WriteLine("The operating system is Windows CE, which does not have current directory functionality."); } catch (ArgumentException) { Console.WriteLine("Illegal characters passed as arguments! "); } catch (Exception) { Console.WriteLine("Unexpected error"); } }
public void ReportErrors() { string text = @"class C { }"; using (var directory = new DisposableDirectory(Temp)) { var file = directory.CreateFile("c.cs"); file.WriteAllText(text); // Error only. var diagnostics = DiagnosticBag.GetInstance(); RunCompiler( directory.Path, file.Path, diagnostics, ImmutableArray.Create <SourceGenerator>( new SimpleSourceGenerator( c => { c.ReportDiagnostic(new CSDiagnostic(new CSDiagnosticInfo(ErrorCode.ERR_IntDivByZero), Location.None)); }))); diagnostics.Verify( Diagnostic(ErrorCode.ERR_IntDivByZero).WithLocation(1, 1)); diagnostics.Free(); // Error and valid tree. diagnostics = DiagnosticBag.GetInstance(); RunCompiler( directory.Path, file.Path, diagnostics, ImmutableArray.Create <SourceGenerator>( new SimpleSourceGenerator( c => { c.AddCompilationUnit("S", CSharpSyntaxTree.ParseText(@"struct S { }")); c.ReportDiagnostic(new CSDiagnostic(new CSDiagnosticInfo(ErrorCode.ERR_IntDivByZero), Location.None)); }))); diagnostics.Verify( Diagnostic(ErrorCode.ERR_IntDivByZero).WithLocation(1, 1)); diagnostics.Free(); // Error and tree with parse error. diagnostics = DiagnosticBag.GetInstance(); RunCompiler( directory.Path, file.Path, diagnostics, ImmutableArray.Create <SourceGenerator>( new SimpleSourceGenerator( c => { c.AddCompilationUnit("__c", CSharpSyntaxTree.ParseText(@"class { }")); c.ReportDiagnostic(new CSDiagnostic(new CSDiagnosticInfo(ErrorCode.ERR_IntDivByZero), Location.None)); }))); diagnostics.Verify( Diagnostic(ErrorCode.ERR_IntDivByZero).WithLocation(1, 1), Diagnostic(ErrorCode.ERR_IdentifierExpected, "{").WithLocation(1, 7)); diagnostics.Free(); } }
public static void ValidateProperty(CSharpSyntaxTree tree, SemanticModel model, Property propertyToValidate) { var treeProperties = GetTreeProperties(tree, model); GetPropertyValidationError(treeProperties, propertyToValidate); }
private static Assembly CompileScript(string[] path) { var scriptPath = path.Length > 1 ? Path.GetDirectoryName(path[0]) : path[0]; var scriptName = Path.GetFileName(scriptPath); var symbolsName = Path.ChangeExtension(scriptName, "pdb"); try { var syntaxTrees = path.Select(file => CSharpSyntaxTree.ParseText(File.ReadAllText(file), null, file, Encoding.UTF8)); var compilation = CSharpCompilation.Create( scriptName, syntaxTrees, References, CompilationOptions); var emitOptions = new EmitOptions( debugInformationFormat: DebugInformationFormat.PortablePdb, pdbFilePath: symbolsName); var assemblyStream = new MemoryStream(); var symbolsStream = new MemoryStream(); var result = compilation.Emit( assemblyStream, symbolsStream, options: emitOptions); if (result.Success) { assemblyStream.Seek(0, SeekOrigin.Begin); symbolsStream.Seek(0, SeekOrigin.Begin); var script = Assembly.Load(assemblyStream.ToArray(), symbolsStream.ToArray()); // in netcore: //var script = AssemblyLoadContext.Default.LoadFromStream(ms); if (script == null) { Trace.TraceWarning($"Script {scriptPath} could not be loaded into the process."); } return(script); } else { var errors = result.Diagnostics.Where(diagnostic => diagnostic.IsWarningAsError || diagnostic.Severity == DiagnosticSeverity.Error); var errorString = new StringBuilder(); errorString.AppendFormat("Skipped script {0} with error:", scriptPath); errorString.Append(Environment.NewLine); foreach (var error in errors) { var textSpan = error.Location.SourceSpan; var fileName = Path.GetFileName(error.Location.SourceTree.FilePath); var lineSpan = error.Location.SourceTree.GetLineSpan(textSpan); var line = lineSpan.StartLinePosition.Line + 1; var column = lineSpan.StartLinePosition.Character + 1; errorString.AppendFormat("\t{0}: {1}, ", error.Id, error.GetMessage()); if (path.Length > 1) { errorString.AppendFormat("file: {0}, ", fileName); } errorString.AppendFormat("line: {0}, column: {1}", line, column); errorString.Append(Environment.NewLine); } Trace.TraceWarning(errorString.ToString()); return(null); } } catch (InvalidDataException error) { Trace.TraceWarning("Skipped script {0} with error: {1}", scriptPath, error.Message); return(null); } catch (Exception error) { if (File.Exists(scriptPath) || Directory.Exists(scriptPath)) { Trace.WriteLine(new FileLoadException(scriptPath, error)); } else { Trace.TraceWarning("Ignored missing script {0}", scriptPath); } return(null); } }
public static void ValidateClass(CSharpSyntaxTree tree, SemanticModel model, string className) { var classDeclarations = GetClassDeclarations(tree, model); GetClassValidationError(classDeclarations, className); }
protected override SyntaxTree ParseText(string code) { return(CSharpSyntaxTree.ParseText(code)); }
public static void ValidateMethod(CSharpSyntaxTree tree, SemanticModel model, string methodName) { var treeMethods = GetTreeMethods(tree, model); GetVoidMethodValidationError(treeMethods, methodName); }
/// <summary> /// Transforms the tree. /// </summary> /// <param name="node">The node which will be impacted by the transformation.</param> public void Transform(ref CSharpSyntaxTree tree) { if (tree == null) { throw new ArgumentNullException(nameof(tree), "A tree is needed!"); } // 1. Initialize this.Initialize(tree, compilation); // 2.1. Analyze this.RetrieveOverridenNamespaceNames(); // 2.2. Rearrange this.ProcessOverridenNamespaceNames(); // We don't perform using directives rearrangement like in other method as that is meaningful only when having a semantic model // 2.3. Tidy up this.CleanUpCompilationUnit(); // 3. Updating references tree = this.newNode.SyntaxTree as CSharpSyntaxTree; // 4. Clean resources this.CleanUp(); }
public static List <IMethodSymbol> GetTreeMethods(CSharpSyntaxTree tree, SemanticModel model) { return(tree.GetCompilationUnitRoot().DescendantNodes().OfType <MethodDeclarationSyntax>() .Select(p => model.GetDeclaredSymbol(p)) .ToList()); }
/// <summary> /// Updates the semantic model after all the changes. /// </summary> private void UpdateCompilation() { this.newTree = this.newNode.SyntaxTree as CSharpSyntaxTree; this.newCompilation = this.compilation.ReplaceSyntaxTree(this.tree, this.newTree); this.newCompilation.GetSemanticModel(this.newTree); // NOT NEEDED }
/// <summary> /// /// </summary> /// <param name="name"></param> /// <param name="path"></param> /// <param name="sourceTree"></param> /// <param name="loadMsCoreLib"></param> /// <returns></returns> public static SemanticModel RetrieveSemanticModel(string name, string path, CSharpSyntaxTree sourceTree, bool loadMsCoreLib = false) { return RetrieveCompilation(name, path, sourceTree, loadMsCoreLib).GetSemanticModel(sourceTree); }
void ExecuteCore(GeneratorExecutionContext context) { context.AddSource("EnumWithValues.cs", SourceText.From(AttributeClassesSource, Encoding.UTF8)); if (context.SyntaxReceiver is not SyntaxReceiver receiver) { return; } if (context.Compilation is not Compilation compilation) { return; } var options = (compilation as CSharpCompilation) !.SyntaxTrees[0].Options as CSharpParseOptions; compilation = compilation.AddSyntaxTrees(CSharpSyntaxTree.ParseText(SourceText.From(AttributeClassesSource, Encoding.UTF8), options)); var enumWithValuesAttributeSymbol = compilation.GetTypeByMetadataName("EnumWithValues.EnumWithValuesAttribute"); var enumValueAttributeSymbol = compilation.GetTypeByMetadataName("EnumWithValues.EnumValueAttribute"); var enums = new List <EnumDeclaration>(); foreach (var syntax in receiver.EnumDeclarationSyntaxes) { var model = compilation.GetSemanticModel(syntax.SyntaxTree); var symbol = (ModelExtensions.GetDeclaredSymbol(model, syntax) as INamedTypeSymbol) !; var attrs = symbol.GetAttributes(); var(name, convertEnumValue, throwIfCastFails) = attrs .Where(attr => attr.AttributeClass !.Equals(enumWithValuesAttributeSymbol, SymbolEqualityComparer.Default)) .Select(attr => ( (string)attr.ConstructorArguments[0].Value !, (bool)attr.ConstructorArguments[1].Value !, (bool)attr.ConstructorArguments[2].Value ! )) .FirstOrDefault(); if (name is null) { continue; } var enumDeclaration = new EnumDeclaration() { Accessibility = symbol.DeclaredAccessibility, EnumType = GetEnumValueTypeString(syntax), EnumName = symbol.Name, EnumFullname = symbol.ToString(), StructName = name, ConvertEnumValue = convertEnumValue, ThrowIfCastFails = throwIfCastFails, }; foreach (var memberSyntax in syntax.Members) { var memberModel = compilation.GetSemanticModel(memberSyntax.SyntaxTree); var memberSymbol = (ModelExtensions.GetDeclaredSymbol(memberModel, memberSyntax) as IFieldSymbol) !; var memberAttrs = memberSymbol.GetAttributes(); ImmutableArray <TypedConstant>?valueConstants = memberAttrs.Length == 0 ? null : memberAttrs .Where(attr => attr.AttributeClass !.Equals(enumValueAttributeSymbol, SymbolEqualityComparer.Default)) .Select(attr => attr.ConstructorArguments[0].Values !) .FirstOrDefault(); if (valueConstants is not null) { enumDeclaration.Members.Add(new() { EnumName = symbol.Name, Name = memberSymbol.Name, EnumValue = GetNumericObjectValue(memberSymbol.ConstantValue), Values = valueConstants }); } } enums.Add(enumDeclaration); } foreach (var e in enums) { e.DetectTypes(); var code = StructCode(e); if (e.Namespace is string ns) { code = Namespaced(ns, code); } context.AddSource($"{e.StructFullname}.cs", SourceText.From(code, Encoding.UTF8)); } }
private void LoadSemanticModel(string path, CSharpSyntaxTree sourceTree) { this.semanticModel = SemanticUtils.RetrieveSemanticModel("LoadedAssembly", path, sourceTree, true); }
/// <summary> /// Use Roslyn to create an assembly. /// </summary> /// <param name="fn">File to compile. Also used for assembly name.</param> /// <returns></returns> public bool Compile(string fn) { CompiledAssembly = null; Errors.Clear(); string sc = File.ReadAllText(fn); string newAssyName = Path.GetFileNameWithoutExtension(fn); // Assemble references. var mr = new List <MetadataReference>(); // Remarks: // Performance considerations: // It is recommended to use Microsoft.CodeAnalysis.AssemblyMetadata.CreateFromFile(System.String) // API when creating multiple references to the same assembly. Reusing Microsoft.CodeAnalysis.AssemblyMetadata // object allows for sharing data across these references. //var myAssy = Assembly.GetExecutingAssembly(); //var refAssys = myAssy.GetReferencedAssemblies(); // Add reference to almost everything we have loaded now. var loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies(); List <string> ignore = new List <string> { "Dex9.exe", "Microsoft.CodeAnalysis.dll", "Microsoft.CodeAnalysis.CSharp.dll" }; foreach (var lassy in loadedAssemblies) { string loc = lassy.Location; if (ignore.TrueForAll(i => !loc.Contains(i))) { Debug.WriteLine(loc); AssemblyMetadata amd = AssemblyMetadata.CreateFromFile(loc); mr.Add(amd.GetReference()); } } // Parse the source. SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(sc); CSharpCompilationOptions opts = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary); CSharpCompilation compilation = CSharpCompilation.Create(newAssyName, new[] { syntaxTree }, mr, opts); // Compile the source. using (var memoryStream = new MemoryStream()) { var result = compilation.Emit(memoryStream); if (result.Success) { memoryStream.Seek(0, SeekOrigin.Begin); CompiledAssembly = Assembly.Load(memoryStream.ToArray()); } else { foreach (var diag in result.Diagnostics) { Errors.Add(FormatDiagnostic(diag, fn)); } } } return(Errors.Count == 0 && CompiledAssembly != null); }
private CSharpCompilation GetCompilation(string path, CSharpSyntaxTree sourceTree) { return SemanticUtils.RetrieveCompilation("LoadedAssembly", path, sourceTree, true); }
private static SyntaxTree BuildSyntaxTree(string code) { return(CSharpSyntaxTree.ParseText(code)); }
private void Initialize() { // Getting the AST node this.tree = ASTExtractor.Extract(this.source); // Loading the semantic model CSharpCompilation compilation = null; if (this.assemblyPath != null) { compilation = this.GetCompilation(this.assemblyPath, this.tree); } IASTTransformer transformer = new ScriptNamespaceBasedASTTransformer(); if (compilation != null) { transformer.Transform(ref this.tree, ref compilation); this.semanticModel = SemanticUtils.RetrieveSemanticModel(compilation, this.tree); } else { transformer.Transform(ref this.tree); } // Creating the walker // If no semantic model was loaded, null will just be passed var node = this.tree.GetRoot(); this.walker = ProgramDefinitionASTWalker.Create(node, null, this.semanticModel); // Translating this.output = this.walker.Walk().Translate(); this.initialized = true; }
/// <summary> /// /// </summary> /// <param name="compilation"></param> /// <param name="sourceTree"></param> /// <returns></returns> public static SemanticModel RetrieveSemanticModel(Compilation compilation, CSharpSyntaxTree sourceTree) { return compilation.GetSemanticModel(sourceTree); }
public void TestSourceGenerators() { string source0 = @"partial class C { D F() { return (D)G; } } class P { static void Main() { } }"; string source1 = @"partial class C { const object G = null; } class D { }"; var generator = new MyGenerator(c => c.AddCompilationUnit("__c", CSharpSyntaxTree.ParseText(source1))); var generatorReference = new MyGeneratorReference(ImmutableArray.Create <SourceGenerator>(generator)); using (var directory = new DisposableDirectory(Temp)) { var outputPath = Path.Combine(directory.Path, "obj", "debug"); Directory.CreateDirectory(outputPath); var projectId = ProjectId.CreateNewId(); var docId = DocumentId.CreateNewId(projectId); var workspace = new AdhocWorkspace(); var projectInfo = ProjectInfo.Create( projectId, VersionStamp.Default, name: "C", assemblyName: "C.dll", language: LanguageNames.CSharp, outputFilePath: outputPath + Path.DirectorySeparatorChar); var solution = workspace.CurrentSolution .AddProject(projectInfo) .AddMetadataReference(projectId, MscorlibRef) .AddDocument(docId, "C.cs", source0) .AddAnalyzerReference(projectId, generatorReference); bool ok = workspace.TryApplyChanges(solution); Assert.True(ok); var actualAnalyzerReferences = solution.GetProject(projectId).AnalyzerReferences; Assert.Equal(1, actualAnalyzerReferences.Count); Assert.Equal(generatorReference, actualAnalyzerReferences[0]); var actualGenerators = actualAnalyzerReferences[0].GetSourceGenerators(LanguageNames.CSharp); Assert.Equal(1, actualGenerators.Length); Assert.Equal(generator, actualGenerators[0]); // Before generating source. solution = workspace.CurrentSolution; var project = solution.GetProject(projectId); Assert.Equal(1, project.DocumentIds.Count); var doc = solution.GetDocument(docId); var model = doc.GetSemanticModelAsync().Result; Assert.NotNull(model); var compilation = model.Compilation; var trees = compilation.SyntaxTrees.ToArray(); Assert.Equal(1, trees.Length); // After generating source. workspace.UpdateGeneratedDocumentsIfNecessary(projectId); solution = workspace.CurrentSolution; project = solution.GetProject(projectId); Assert.Equal(2, project.DocumentIds.Count); doc = solution.GetDocument(docId); model = doc.GetSemanticModelAsync().Result; Assert.NotNull(model); compilation = model.Compilation; trees = compilation.SyntaxTrees.ToArray(); Assert.Equal(2, trees.Length); var tree = trees[1]; doc = solution.GetDocument(tree); Assert.NotNull(doc); Assert.True(doc.State.IsGenerated); var actualSource = tree.GetText().ToString(); Assert.Equal(source1, actualSource); var filePath = doc.FilePath; Assert.NotNull(filePath); Assert.Equal(outputPath, Path.GetDirectoryName(filePath)); // Workspace should not write files to disk. Assert.False(File.Exists(filePath)); } }
private void Initialize() { // Getting the AST node this.tree = ASTExtractor.Extract(this.source); var node = this.tree.GetRoot(); // Loading the semantic model if (this.assemblyPath != null) { this.LoadSemanticModel(this.assemblyPath, this.tree); } // Creating the walker // If no semantic model was loaded, null will just be passed this.walker = ProgramASTWalker.Create(node, null, this.semanticModel); // Translating this.output = this.walker.Walk().Translate(); this.initialized = true; }
public static string CompileAndRun(string code) { //baaa //code = code.Replace("[!DOUBLE-QUOTES-REPLACED-HERE!]", @""""); // define source code, then parse it (to the type used for compilation) //SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(@" // using System; // namespace RoslynCompileSample // { // public class Writer // { // public string Write() // { // return ""message""; // } // } // }"); SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(code); // define other necessary objects for compilation string assemblyName = Path.GetRandomFileName(); //paths to all the framework.dll files var allPathsToFrameworkDllFiles = ((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")).Split(Path.PathSeparator); List <MetadataReference> references = new List <MetadataReference>(); foreach (var dllPath in allPathsToFrameworkDllFiles) { references.Add(MetadataReference.CreateFromFile(dllPath)); } //MetadataReference[] references = new MetadataReference[] //{ // MetadataReference.CreateFromFile(typeof(object).Assembly.Location), // MetadataReference.CreateFromFile(typeof(Enumerable).Assembly.Location) //}; // analyse and generate IL code from syntax tree CSharpCompilation compilation = CSharpCompilation.Create( assemblyName, syntaxTrees: new[] { syntaxTree }, references: references, options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); using (var ms = new MemoryStream()) { // write IL code into memory EmitResult result = compilation.Emit(ms); if (!result.Success) { // handle exceptions IEnumerable <Diagnostic> failures = result.Diagnostics.Where(diagnostic => diagnostic.IsWarningAsError || diagnostic.Severity == DiagnosticSeverity.Error); var errors = new List <Error>(); foreach (Diagnostic diagnostic in failures) { Console.Error.WriteLine("{0}: {1}", diagnostic.Id, diagnostic.GetMessage()); var error = new Error(); error.Location = code.Substring(diagnostic.Location.SourceSpan.Start, diagnostic.Location.SourceSpan.Length); error.Message = "{" + diagnostic.Id + "}: {" + diagnostic.GetMessage() + "}"; //errors.Add("{" + diagnostic.Id + "}: {" + diagnostic.GetMessage() + "}"); //errors.Add(diagnostic.ToString()); errors.Add(error); } var ceResult = new CodeExecutionResult(); ceResult.EcounteredCompilerErrors = true; ceResult.CompilerErrors = errors; return(JsonSerializer.Serialize(ceResult)); } else { // load this 'virtual' DLL so that we can use ms.Seek(0, SeekOrigin.Begin); Assembly assembly = Assembly.Load(ms.ToArray()); // create instance of the desired class and call the desired function Type type = assembly.GetType("TeacherTestingNameSpace.TeacherTestingClass"); object obj = Activator.CreateInstance(type); //string asdf = (string) type.InvokeMember("Write", // BindingFlags.Default | BindingFlags.InvokeMethod, // null, // obj, // new object[] { "Hello World" }); try { string executionResult = (string)type.InvokeMember("TeacherTestingFunction", BindingFlags.Default | BindingFlags.InvokeMethod, null, obj, null); return("{\"Tests\":" + executionResult + "}"); } catch (Exception ex) { var errors = new List <Error>(); var error = new Error(); error.Location = ""; error.Message = ex.InnerException?.Message; errors.Add(error); var ceResult = new CodeExecutionResult(); ceResult.EcounteredCompilerErrors = true; ceResult.CompilerErrors = errors; return(JsonSerializer.Serialize(ceResult)); } } } }