public RazorProjectEngine Create(RazorConfiguration configuration, RazorProjectFileSystem fileSystem, Action <RazorProjectEngineBuilder> configure) { // Rewrite the assembly name into a full name just like this one, but with the name of the MVC design time assembly. var assemblyName = new AssemblyName(typeof(LegacyProjectEngineFactory_3_0).Assembly.FullName); assemblyName.Name = AssemblyName; var extension = new AssemblyExtension(configuration.ConfigurationName, Assembly.Load(assemblyName)); var initializer = extension.CreateInitializer(); return(RazorProjectEngine.Create(configuration, fileSystem, b => { CompilerFeatures.Register(b); initializer.Initialize(b); configure?.Invoke(b); // See comments on MangleClassNames var componentDocumentClassifier = b.Features.OfType <ComponentDocumentClassifierPass>().FirstOrDefault(); if (componentDocumentClassifier != null) { componentDocumentClassifier.MangleClassNames = true; } })); }
// intentionally private - we don't want individual tests messing with the project engine private RazorProjectEngine CreateProjectEngine(RazorConfiguration configuration, MetadataReference[] references) { return(RazorProjectEngine.Create(configuration, FileSystem, b => { b.SetRootNamespace(DefaultRootNamespace); // Turn off checksums, we're testing code generation. b.Features.Add(new SuppressChecksum()); b.Features.Add(new TestImportProjectFeature(ImportItems)); if (LineEnding != null) { b.Phases.Insert(0, new ForceLineEndingPhase(LineEnding)); } b.Features.Add(new DefaultTypeNameFeature()); b.Features.Add(new CompilationTagHelperFeature()); b.Features.Add(new DefaultMetadataReferenceFeature() { References = references, }); b.SetCSharpLanguageVersion(CSharpParseOptions.LanguageVersion); CompilerFeatures.Register(b); })); }
public void Execute(GeneratorExecutionContext context) { var razorContext = RazorSourceGenerationContext.Create(context); if (razorContext is null || (razorContext.RazorFiles.Count == 0 && razorContext.CshtmlFiles.Count == 0)) { return; } HandleDebugSwitch(razorContext.WaitForDebugger); var tagHelpers = ResolveTagHelperDescriptors(context, razorContext); var projectEngine = RazorProjectEngine.Create(razorContext.Configuration, razorContext.FileSystem, b => { b.Features.Add(new DefaultTypeNameFeature()); b.SetRootNamespace(razorContext.RootNamespace); b.Features.Add(new StaticTagHelperFeature { TagHelpers = tagHelpers, }); b.Features.Add(new DefaultTagHelperDescriptorProvider()); CompilerFeatures.Register(b); RazorExtensions.Register(b); b.SetCSharpLanguageVersion(((CSharpParseOptions)context.ParseOptions).LanguageVersion); }); CodeGenerateRazorComponents(context, razorContext, projectEngine); GenerateViews(context, razorContext, projectEngine); }
public Generator() { Declarations = new Dictionary <string, string>(); References = new List <MetadataReference>(); GC.KeepAlive(typeof(EditForm)); foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies()) { if (!assembly.IsDynamic && assembly.Location != null) { References.Add(MetadataReference.CreateFromFile(assembly.Location)); } } BaseCompilation = CSharpCompilation.Create( assemblyName: "__Test", Array.Empty <SyntaxTree>(), References.ToArray(), new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); References.Add(BaseCompilation.ToMetadataReference()); FileSystem = new TestRazorProjectFileSystem(); Engine = RazorProjectEngine.Create(RazorConfiguration.Default, FileSystem, builder => { builder.Features.Add(new CompilationTagHelperFeature()); builder.Features.Add(new DefaultMetadataReferenceFeature() { References = References, }); CompilerFeatures.Register(builder); }); }
private static RazorProjectEngine GetDeclarationProjectEngine( SourceGeneratorProjectItem item, IEnumerable <SourceGeneratorProjectItem> imports, RazorSourceGenerationOptions razorSourceGeneratorOptions) { var fileSystem = new VirtualRazorProjectFileSystem(); fileSystem.Add(item); foreach (var import in imports) { fileSystem.Add(import); } var discoveryProjectEngine = RazorProjectEngine.Create(razorSourceGeneratorOptions.Configuration, fileSystem, b => { b.Features.Add(new DefaultTypeNameFeature()); b.Features.Add(new ConfigureRazorCodeGenerationOptions(options => { options.SuppressPrimaryMethodBody = true; options.SuppressChecksum = true; })); b.SetRootNamespace(razorSourceGeneratorOptions.RootNamespace); CompilerFeatures.Register(b); RazorExtensions.Register(b); b.SetCSharpLanguageVersion(razorSourceGeneratorOptions.CSharpLanguageVersion); }); return(discoveryProjectEngine); }
public RazorProjectEngine Create(RazorConfiguration configuration, RazorProjectFileSystem fileSystem, Action <RazorProjectEngineBuilder> configure) { return(RazorProjectEngine.Create(configuration, fileSystem, b => { CompilerFeatures.Register(b); configure?.Invoke(b); })); }
public void Execute(GeneratorExecutionContext context) { var _razorContext = new RazorSourceGenerationContext(context); if (_razorContext is null) { context.ReportDiagnostic(Diagnostic.Create(RazorDiagnostics.InvalidRazorContextComputedDescriptor, Location.None)); return; } if (_razorContext.RazorFiles.Count == 0 && _razorContext.CshtmlFiles.Count == 0) { return; } if (_razorContext.SuppressRazorSourceGenerator) { return; } HandleDebugSwitch(_razorContext.WaitForDebugger); var tagHelpers = ResolveTagHelperDescriptors(context, _razorContext); AssertOrFailFast(tagHelpers.Count == 0, "No tag helpers resolved."); var projectEngine = RazorProjectEngine.Create(_razorContext.Configuration, _razorContext.FileSystem, b => { b.Features.Add(new DefaultTypeNameFeature()); b.SetRootNamespace(_razorContext.RootNamespace); b.Features.Add(new ConfigureRazorCodeGenerationOptions(options => { options.SuppressMetadataSourceChecksumAttributes = !_razorContext.GenerateMetadataSourceChecksumAttributes; })); b.Features.Add(new StaticTagHelperFeature { TagHelpers = tagHelpers, }); b.Features.Add(new DefaultTagHelperDescriptorProvider()); CompilerFeatures.Register(b); RazorExtensions.Register(b); b.SetCSharpLanguageVersion(((CSharpParseOptions)context.ParseOptions).LanguageVersion); }); if (_razorContext.CshtmlFiles.Count != 0) { context.AddSource($"{context.Compilation.AssemblyName}.UnifiedAssembly.Info.g.cs", ProvideApplicationPartFactoryAttributeSourceText); } RazorGenerateForSourceTexts(_razorContext.CshtmlFiles, context, projectEngine); RazorGenerateForSourceTexts(_razorContext.RazorFiles, context, projectEngine); }
private RazorProjectEngine CreateProjectEngine(IReadOnlyList <MetadataReference> references) => RazorProjectEngine.Create(this.Configuration, this.FileSystem, b => { b.SetRootNamespace(DefaultRootNamespace); // Features that use Roslyn are mandatory for components CompilerFeatures.Register(b); b.Features.Add(new CompilationTagHelperFeature()); b.Features.Add(new DefaultMetadataReferenceFeature { References = references, }); });
public RazorProjectEngine Create(RazorConfiguration configuration, RazorProjectFileSystem fileSystem, Action <RazorProjectEngineBuilder> configure) { return(RazorProjectEngine.Create(configuration, fileSystem, b => { CompilerFeatures.Register(b); configure?.Invoke(b); // See comments on MangleClassNames var componentDocumentClassifier = b.Features.OfType <ComponentDocumentClassifierPass>().FirstOrDefault(); if (componentDocumentClassifier != null) { componentDocumentClassifier.MangleClassNames = true; } })); }
private int ExecuteCore(RazorConfiguration configuration, string projectDirectory, string outputFilePath, string[] assemblies) { outputFilePath = Path.Combine(projectDirectory, outputFilePath); var metadataReferences = new MetadataReference[assemblies.Length]; for (var i = 0; i < assemblies.Length; i++) { metadataReferences[i] = Parent.AssemblyReferenceProvider(assemblies[i], default(MetadataReferenceProperties)); } var engine = RazorProjectEngine.Create(configuration, RazorProjectFileSystem.Empty, b => { b.Features.Add(new DefaultMetadataReferenceFeature() { References = metadataReferences }); b.Features.Add(new CompilationTagHelperFeature()); b.Features.Add(new DefaultTagHelperDescriptorProvider()); CompilerFeatures.Register(b); }); var feature = engine.Engine.Features.OfType <ITagHelperFeature>().Single(); var tagHelpers = feature.GetDescriptors(); using (var stream = new MemoryStream()) { Serialize(stream, tagHelpers); stream.Position = 0; var newHash = Hash(stream); var existingHash = Hash(outputFilePath); if (!HashesEqual(newHash, existingHash)) { stream.Position = 0; using (var output = File.Open(outputFilePath, FileMode.Create)) { stream.CopyTo(output); } } } return(ExitCodeSuccess); }
public RazorProjectEngine CreateRazorProjectEngine(IReadOnlyList <MetadataReference> references) { Console.WriteLine("CreateRazorProjectEngine"); return(RazorProjectEngine.Create(_config, _fileSystem, builder => { builder.SetRootNamespace(DefaultRootNamespace); builder.AddDefaultImports(RazorConstants.DefaultUsings); // Features that use Roslyn are mandatory for components CompilerFeatures.Register(builder); builder.Features.Add(new CompilationTagHelperFeature()); builder.Features.Add(new DefaultMetadataReferenceFeature { References = references }); })); }
public RazorProjectEngine Create(RazorConfiguration configuration, RazorProjectFileSystem fileSystem, Action <RazorProjectEngineBuilder> configure) { // Rewrite the assembly name into a full name just like this one, but with the name of the MVC design time assembly. var assemblyName = new AssemblyName(typeof(RazorProjectEngine).Assembly.FullName); assemblyName.Name = AssemblyName; var extension = new AssemblyExtension(configuration.ConfigurationName, Assembly.Load(assemblyName)); var initializer = extension.CreateInitializer(); return(RazorProjectEngine.Create(configuration, fileSystem, b => { CompilerFeatures.Register(b); initializer.Initialize(b); configure?.Invoke(b); })); }
private static RazorProjectEngine GetDiscoveryProjectEngine( IReadOnlyList <MetadataReference> references, StaticCompilationTagHelperFeature tagHelperFeature) { var discoveryProjectEngine = RazorProjectEngine.Create(RazorConfiguration.Default, new VirtualRazorProjectFileSystem(), b => { b.Features.Add(new DefaultMetadataReferenceFeature { References = references }); b.Features.Add(tagHelperFeature); b.Features.Add(new DefaultTagHelperDescriptorProvider()); CompilerFeatures.Register(b); RazorExtensions.Register(b); }); return(discoveryProjectEngine); }
// intentionally private - we don't want individual tests messing with the project engine private RazorProjectEngine CreateProjectEngine(RazorConfiguration configuration, MetadataReference[] references) { return(RazorProjectEngine.Create(configuration, FileSystem, b => { // Turn off checksums, we're testing code generation. b.Features.Add(new SuppressChecksum()); if (LineEnding != null) { b.Phases.Insert(0, new ForceLineEndingPhase(LineEnding)); } b.Features.Add(new CompilationTagHelperFeature()); b.Features.Add(new DefaultMetadataReferenceFeature() { References = references, }); CompilerFeatures.Register(b); })); }
private static RazorProjectEngine GetGenerationProjectEngine( IReadOnlyList <TagHelperDescriptor> tagHelpers, SourceGeneratorProjectItem item, IEnumerable <SourceGeneratorProjectItem> imports, RazorSourceGenerationOptions razorSourceGeneratorOptions) { var fileSystem = new VirtualRazorProjectFileSystem(); fileSystem.Add(item); foreach (var import in imports) { fileSystem.Add(import); } var projectEngine = RazorProjectEngine.Create(razorSourceGeneratorOptions.Configuration, fileSystem, b => { b.Features.Add(new DefaultTypeNameFeature()); b.SetRootNamespace(razorSourceGeneratorOptions.RootNamespace); b.Features.Add(new ConfigureRazorCodeGenerationOptions(options => { options.SuppressMetadataSourceChecksumAttributes = !razorSourceGeneratorOptions.GenerateMetadataSourceChecksumAttributes; options.SupportLocalizedComponentNames = razorSourceGeneratorOptions.SupportLocalizedComponentNames; })); b.Features.Add(new StaticTagHelperFeature { TagHelpers = tagHelpers }); b.Features.Add(new DefaultTagHelperDescriptorProvider()); CompilerFeatures.Register(b); RazorExtensions.Register(b); b.SetCSharpLanguageVersion(razorSourceGeneratorOptions.CSharpLanguageVersion); }); return(projectEngine); }
byte[] CompileCode(string code) { typeof(EventHandlers).ToString(); typeof(EditContext).ToString(); //ensure more assemblies.. if (refs == null) { refs = AppDomain.CurrentDomain.GetAssemblies().Select(v => { try { return(Microsoft.CodeAnalysis.MetadataReference.CreateFromFile(v.Location)); } catch { return(null); } }).Where(v => v != null).ToArray(); } if (exts == null) { exts = new List <RazorExtension>(); exts.Add(new AssemblyExtension("ComponentBase", typeof(ComponentBase).Assembly)); exts.Add(new AssemblyExtension("ComponentWeb", typeof(BindAttributes).Assembly)); foreach (AssemblyName asm in this.GetType().Assembly.GetReferencedAssemblies()) { exts.Add(new AssemblyExtension(asm.FullName, AppDomain.CurrentDomain.Load(asm.FullName))); } } var config = RazorConfiguration.Create(RazorLanguageVersion.Version_3_0, "Default", exts); var proj = new MyProject(); if (tagHelpers == null) { var rpe1 = RazorProjectEngine.Create(config, proj, b => { //Check Microsoft.AspNetCore.Razor.Tools.DiscoverCommand b.Features.Add(new DefaultMetadataReferenceFeature { References = refs }); b.Features.Add(new CompilationTagHelperFeature()); b.Features.Add(new DefaultTagHelperDescriptorProvider()); CompilerFeatures.Register(b); }); tagHelpers = rpe1.Engine.Features.OfType <ITagHelperFeature>().Single().GetDescriptors().ToArray(); } if (code == null) { return(null); } var engine = RazorProjectEngine.Create(config, proj, b => { var mf = new MyFeatureV2() { TagHelpers = tagHelpers }; b.Features.Add(mf); }); var projitem = new MyProjectItem() { Name = "MyComponent.razor", Code = code }; var razorDoc = engine.Process(projitem); var csdoc = razorDoc.GetCSharpDocument(); foreach (var diag in csdoc.Diagnostics) { switch (diag.Id) { case "RZ9980": case "RZ9981": throw new Exception("Error : " + diag.Id); } } string targetCode = csdoc.GeneratedCode; if (string.IsNullOrEmpty(targetCode) && csdoc.Diagnostics.Count != 0) { return(null); } var invalidAttrChars = new char[] { '@', '/', '\\' }; foreach (string eachline in targetCode.Split('\n')) { var line = eachline.Trim(); if (line.StartsWith("__builder.AddAttribute")) { int p1 = line.IndexOf('"') + 1; int p2 = line.IndexOf('"', p1); var attrname = line.Substring(p1, p2 - p1); if (attrname.IndexOfAny(invalidAttrChars) != -1) { throw new Exception("Invalid attribute name [" + attrname + "]"); } } } System.Diagnostics.Stopwatch watch = new System.Diagnostics.Stopwatch(); watch.Start(); var st = Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(csdoc.GeneratedCode); var csc = Microsoft.CodeAnalysis.CSharp.CSharpCompilation.Create("new" + DateTime.Now.Ticks) .WithOptions(new Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions(Microsoft.CodeAnalysis.OutputKind.DynamicallyLinkedLibrary)) .AddSyntaxTrees(st) .AddReferences(refs); System.IO.MemoryStream ms = new System.IO.MemoryStream(); var result = csc.Emit(ms); if (!result.Success) { throw new Exception(result.Diagnostics.First(v => v.Severity == Microsoft.CodeAnalysis.DiagnosticSeverity.Error).ToString()); } return(ms.ToArray()); }
public void Execute(GeneratorExecutionContext context) { var configuration = RazorConfiguration.Default; var compilation = context.Compilation; // TODO: Figure these out. var projectDirectory = @"C:\Users\prkrishn\source\repos\ClassLibrary2\ConsoleApp2\"; var rootNamespace = "ConsoleApp2"; var tagHelperFeature = new CompilationTagHelperFeature(() => compilation); var discoveryProjectEngine = RazorProjectEngine.Create(configuration, RazorProjectFileSystem.Create(projectDirectory), b => { b.Features.Add((IRazorFeature)Activator.CreateInstance(typeof(CompilerFeatures).Assembly.GetType("Microsoft.CodeAnalysis.Razor.DefaultTypeNameFeature"))); b.Features.Add(new SetSuppressPrimaryMethodBodyOptionFeature()); b.Features.Add(new SuppressChecksumOptionsFeature()); b.SetRootNamespace(rootNamespace); var metadataReferences = new List <MetadataReference>(context.Compilation.References); b.Features.Add(new DefaultMetadataReferenceFeature { References = metadataReferences }); b.Features.Add(tagHelperFeature); b.Features.Add(new DefaultTagHelperDescriptorProvider()); CompilerFeatures.Register(b); b.SetCSharpLanguageVersion(((CSharpParseOptions)context.ParseOptions).LanguageVersion); }); foreach (var file in context.AdditionalFiles.Where(f => f.Path.EndsWith(".razor", StringComparison.OrdinalIgnoreCase))) { var codeGen = discoveryProjectEngine.Process(discoveryProjectEngine.FileSystem.GetItem(file.Path, FileKinds.Component)); compilation = compilation.AddSyntaxTrees(CSharpSyntaxTree.ParseText(codeGen.GetCSharpDocument().GeneratedCode)); } var tagHelpers = tagHelperFeature.GetDescriptors(); var projectEngine = RazorProjectEngine.Create(configuration, RazorProjectFileSystem.Create(projectDirectory), b => { b.Features.Add((IRazorFeature)Activator.CreateInstance(typeof(CompilerFeatures).Assembly.GetType("Microsoft.CodeAnalysis.Razor.DefaultTypeNameFeature"))); b.SetRootNamespace(rootNamespace); b.Features.Add(new StaticTagHelperFeature { TagHelpers = tagHelpers, }); b.Features.Add(new DefaultTagHelperDescriptorProvider()); CompilerFeatures.Register(b); b.SetCSharpLanguageVersion(((CSharpParseOptions)context.ParseOptions).LanguageVersion); }); foreach (var file in context.AdditionalFiles.Where(f => f.Path.EndsWith(".razor", StringComparison.OrdinalIgnoreCase))) { var codeGen = projectEngine.Process(projectEngine.FileSystem.GetItem(file.Path, FileKinds.Component)); var path = file.Path.Replace(':', '_').Replace('\\', '_').Replace('/', '_'); context.AddSource(path, SourceText.From(codeGen.GetCSharpDocument().GeneratedCode, Encoding.UTF8)); } }
private async Task <Project> OpenProjectWithRazorFileAsync(string projectDirectory) { Project project = null; var projectFilePath = Directory.GetFiles(projectDirectory, "*.csproj", SearchOption.TopDirectoryOnly).FirstOrDefault(); if (projectFilePath == null) { return(project); } var razorFiles = Directory.GetFiles(Path.Combine(projectDirectory), "*.cshtml", SearchOption.AllDirectories); var razorCSCodes = new string[razorFiles.Length]; IEnumerable <MetadataReference> references = Array.Empty <MetadataReference>(); using (var msbws = MSBuildWorkspace.Create()) { msbws.SkipUnrecognizedProjects = true; msbws.LoadMetadataForReferencedProjects = true; msbws.WorkspaceFailed += (object sender, WorkspaceDiagnosticEventArgs e) => Console.WriteLine("ERR" + ":" + e.Diagnostic.Message); // load project file project = await msbws.OpenProjectAsync(projectDirectory); var compilation = await project.GetCompilationAsync(); Console.WriteLine("-------------------------------------------"); var diagnostics = msbws.Diagnostics; foreach (var diagnostic in diagnostics) { Console.WriteLine(diagnostic.Message); } references = compilation.References; } // discover tagHelpers var fileSystem = RazorProjectFileSystem.Create(projectDirectory); var engine = RazorProjectEngine.Create(RazorConfiguration.Default, fileSystem, b => { b.Features.Add(new DefaultMetadataReferenceFeature() { References = references.ToList() }); b.Features.Add(new CompilationTagHelperFeature()); b.Features.Add(new DefaultTagHelperDescriptorProvider()); CompilerFeatures.Register(b); }); var feature = engine.Engine.Features.OfType <ITagHelperFeature>().Single(); var tagHelpers = feature.GetDescriptors(); // generate C# code var razorConfiguration = RazorConfiguration.Create( RazorLanguageVersion.Latest, "MVC-3.0", new[] { new AssemblyExtension("MVC-3.0", typeof(RazorExtensions).Assembly) }); engine = RazorProjectEngine.Create(razorConfiguration, fileSystem, b => { b.Features.Add(new StaticTagHelperFeature() { TagHelpers = tagHelpers, }); //CompilerFeatures.Register(b); }); foreach (var file in razorFiles) { var item = engine.FileSystem.GetItem(file, "cshtml"); var razorCode = engine.Process(item).GetCSharpDocument().GeneratedCode; project = project.AddDocument(Path.ChangeExtension(Path.GetRandomFileName(), ".cshtml.g.cs"), razorCode).Project; } return(project); }