private void GenerateCode(SourceGeneratorContext context) { foreach (CodeGenerationConfigBuilder builder in _config.Builders) { if (builder.Input == null || builder.Output == null) { _logger.LogError("Skipping generation", "Input or ouput object is not provided.", null); continue; } foreach (INamedItem @object in _renderEngine.GetMatchedObjects(context, _visitor, builder)) { RenderResultModel renderResult = _renderEngine.RenderMatch(@object, builder); if (renderResult != null) { _generationEngine.AddToCurrentGeneration(renderResult); } else { _logger.LogError("Skipping generation", "File failed to render.", null); continue; } } _generationEngine.PublishGeneration(context); } }
public override void Execute(SourceGeneratorContext context) { var project = context.GetProjectInstance(); _bindingsPaths = project.GetPropertyValue("TSBindingsPath")?.ToString(); _sourceAssemblies = project.GetItems("TSBindingAssemblySource").Select(s => s.EvaluatedInclude).ToArray(); if (!string.IsNullOrEmpty(_bindingsPaths)) { _stringSymbol = context.Compilation.GetTypeByMetadataName("System.String"); _intSymbol = context.Compilation.GetTypeByMetadataName("System.Int32"); _floatSymbol = context.Compilation.GetTypeByMetadataName("System.Single"); _doubleSymbol = context.Compilation.GetTypeByMetadataName("System.Double"); _byteSymbol = context.Compilation.GetTypeByMetadataName("System.Byte"); _shortSymbol = context.Compilation.GetTypeByMetadataName("System.Int16"); _intPtrSymbol = context.Compilation.GetTypeByMetadataName("System.IntPtr"); _boolSymbol = context.Compilation.GetTypeByMetadataName("System.Boolean"); _longSymbol = context.Compilation.GetTypeByMetadataName("System.Int64"); _structLayoutSymbol = context.Compilation.GetTypeByMetadataName(typeof(System.Runtime.InteropServices.StructLayoutAttribute).FullName); _interopMessageSymbol = context.Compilation.GetTypeByMetadataName("Uno.Foundation.Interop.TSInteropMessageAttribute"); var modules = from ext in context.Compilation.ExternalReferences let sym = context.Compilation.GetAssemblyOrModuleSymbol(ext) as IAssemblySymbol where _sourceAssemblies.Contains(sym.Name) from module in sym.Modules select module; modules = modules.Concat(context.Compilation.SourceModule); GenerateTSMarshallingLayouts(modules); } }
public void Execute(SourceGeneratorContext context) { _config = ConfigParser.GetConfig(_visitor, context); if (!string.IsNullOrEmpty(_config.Debugging?.LogOutput)) { _logger.RegisterFactory( new FileLogOutputFactory("Log Output", _config.Debugging.LogOutput, LogScope.Error | LogScope.Warning | LogScope.Information, LogScope.Objects, DateTime.Now.ToString("yyyy-MM-dd-HH-mm-ss")) ); } if (string.IsNullOrEmpty(_config.Debugging?.ObjectOutput)) { _logger.RegisterFactory( new FileLogOutputFactory("Object Output", _config.Debugging?.ObjectOutput, LogScope.Error | LogScope.Warning | LogScope.Information, LogScope.Objects, DateTime.Now.ToString("yyyy-MM-dd-HH-mm-ss")) ); } if (_config?.Builders == null) { _logger.LogError("Skipping generation", "No template config found.", null); } _generationEngine.NewGeneration(); GenerateCode(context); }
private static void BuildSearchPaths(SourceGeneratorContext context, IndentedStringBuilder sb) { var projectInstance = context.GetProjectInstance(); sb.AppendLineInvariant($"[assembly: global::Uno.UI.RemoteControl.ProjectConfigurationAttribute("); sb.AppendLineInvariant($"@\"{projectInstance.FullPath}\",\n"); var sources = new[] { "Page", "ApplicationDefinition", "ProjectReference", }; IEnumerable <string> BuildSearchPath(string s) => projectInstance .GetItems(s) .Select(v => v.EvaluatedInclude) .Select(v => Path.IsPathRooted(v) ? v : Path.Combine(projectInstance.Directory, v)); var xamlPaths = from item in sources.SelectMany(BuildSearchPath) select Path.GetDirectoryName(item); var distictPaths = string.Join(",\n", xamlPaths.Distinct().Select(p => $"@\"{p}\"")); sb.AppendLineInvariant("{0}", $"new[]{{{distictPaths}}}"); sb.AppendLineInvariant($")]"); }
private static void BuildEndPointAttribute(SourceGeneratorContext context, IndentedStringBuilder sb) { var unoRemoteControlPort = context.GetProjectInstance().GetPropertyValue("UnoRemoteControlPort"); if (string.IsNullOrEmpty(unoRemoteControlPort)) { unoRemoteControlPort = "0"; } var unoRemoteControlHost = context.GetProjectInstance().GetPropertyValue("UnoRemoteControlHost"); if (string.IsNullOrEmpty(unoRemoteControlHost)) { var addresses = NetworkInterface.GetAllNetworkInterfaces() .SelectMany(x => x.GetIPProperties().UnicastAddresses) .Where(x => !IPAddress.IsLoopback(x.Address)); foreach (var addressInfo in addresses) { sb.AppendLineInvariant($"[assembly: global::Uno.UI.RemoteControl.ServerEndpointAttribute(\"{addressInfo.Address}\", {unoRemoteControlPort})]"); } } else { sb.AppendLineInvariant($"[assembly: global::Uno.UI.RemoteControl.ServerEndpointAttribute(\"{unoRemoteControlHost}\", {unoRemoteControlPort})]"); } }
void CollectExtensionMethods(SourceGeneratorContext context) { logger.Info("Collecting extension methods with interface constraints!"); foreach (var method in hyperlinqNamespace .GetTypeMembers() .Where(type => type.IsPublic() && type.IsStatic) .SelectMany(type => type.GetMembers() .OfType <IMethodSymbol>() .Where(method => method.IsPublic() && method.IsExtensionMethod && !method.ShouldIgnore(context.Compilation)))) { var extensionType = method.Parameters[0].Type; var generic = method.TypeParameters .FirstOrDefault(parameter => parameter.Name == extensionType.Name && parameter.ConstraintTypes.Length != 0); if (generic is object) { var extendedType = generic.ConstraintTypes[0]; var key = extendedType.OriginalDefinition.MetadataName; if (!collectedExtensionMethods.TryGetValue(key, out var list)) { list = new List <IMethodSymbol>(); collectedExtensionMethods.Add(key, list); } list.Add(method); } } }
public void Execute(SourceGeneratorContext context) { context.AddCompiledOnMetadataAttribute(); var compilation = context.Compilation; var types = CompilationHelper.GetAllTypes(context.Compilation.Assembly); using (var stringWriter = new StringWriter()) using (var indentedTextWriter = new IndentedTextWriter(stringWriter, " ")) { var defaultToStringGenerator = new DefaultToStringGenerator(context); foreach (var type in types) { if (DefaultToStringGenerator.ShouldUseGenerator(type)) { defaultToStringGenerator.WriteType(type, indentedTextWriter); } } indentedTextWriter.Flush(); stringWriter.Flush(); var sourceText = SourceText.From(stringWriter.ToString(), Encoding.UTF8); var hintName = $"AutoToString_{compilation.Assembly.Name}.g.cs"; context.AddSource(hintName, sourceText); } }
/// <inheritdoc /> public override void Execute(SourceGeneratorContext context) { var output = new StringBuilder(); output.AppendLine("// This is the list of all external references used to compile this project:"); var lines = context .Compilation .References .OrderBy(r => r.Display, StringComparer.InvariantCultureIgnoreCase) .Select((r, i) => $"// #{i}: {r.Display}"); output.AppendLine(string.Join(Environment.NewLine, lines)); context.AddCompilationUnit(nameof(CompilationReferencesListingGenerator), output.ToString()); var projectReferences = context .GetProjectInstance() .Items .Where(i => i.ItemType.Equals("PackageReference", StringComparison.OrdinalIgnoreCase)) .ToArray(); var projectDependencies = context .GetProjectInstance() .Items .Where(i => i.ItemType.Equals("PackageDependencies", StringComparison.OrdinalIgnoreCase)) .ToArray(); projectReferences.ToString(); }
public override void Execute(SourceGeneratorContext context) { #if DEBUG Debugger.Launch(); #endif _logger = context.GetLogger(); DirectoryInfo projDir = new DirectoryInfo(Path.GetDirectoryName(context.Project.FilePath)); string solutionFullName = null; while (projDir.Parent != null) { string filePath = Path.Combine(projDir.FullName, "BitConfigV1.json"); if (File.Exists(filePath)) { solutionFullName = Directory.EnumerateFiles(projDir.FullName, "*.sln").FirstOrDefault(); break; } projDir = projDir.Parent; } CallGenerateCodes(context.Project.Solution.Workspace, solutionFullName); }
public void Execute(SourceGeneratorContext context) { foreach (var file in context.AdditionalFiles) { context.AddSource(GetGeneratedFileName(file.Path), SourceText.From("", Encoding.UTF8)); } }
public void Execute(SourceGeneratorContext context) { // retreive the populated receiver if (!(context.SyntaxReceiver is SyntaxReceiver receiver)) { return; } try { // 简单测试aop 生成 Action <StringBuilder, IMethodSymbol> beforeCall = (sb, method) => { }; Action <StringBuilder, IMethodSymbol> afterCall = (sb, method) => { sb.Append("r++;"); }; // 获取生成结果 var code = receiver.SyntaxNodes .Select(i => context.Compilation.GetSemanticModel(i.SyntaxTree).GetDeclaredSymbol(i) as INamedTypeSymbol) .Where(i => i != null && !i.IsStatic) .Select(i => ProxyCodeGenerator.GenerateProxyCode(i, beforeCall, afterCall)) .First(); context.AddSource("code.cs", SourceText.From(code, Encoding.UTF8)); } catch (Exception ex) { // 失败汇报 context.ReportDiagnostic(Diagnostic.Create(new DiagnosticDescriptor("n001", ex.ToString(), ex.ToString(), "AOP.Generate", DiagnosticSeverity.Warning, true), Location.Create("code.cs", TextSpan.FromBounds(0, 0), new LinePositionSpan()))); } }
public override void Execute(SourceGeneratorContext context) { #if DEBUG Debugger.Launch(); #endif _logger = context.GetLogger(); DirectoryInfo projDir = new DirectoryInfo(Path.GetDirectoryName(context.Project.FilePath) ?? throw new InvalidOperationException("Context's project's file path is null")); string solutionFullName = null; while (projDir.Parent != null) { string filePath = Path.Combine(projDir.FullName, "BitConfigV1.json"); if (File.Exists(filePath)) { solutionFullName = Directory.EnumerateFiles(projDir.FullName, "*.sln").FirstOrDefault(); break; } projDir = projDir.Parent; } CallGenerateCodes((MSBuildWorkspace)context.Project.Solution.Workspace, context.Project, solutionFullName).GetAwaiter().GetResult(); }
public override void Execute(SourceGeneratorContext context) { var compilation = context.Compilation; var diags = compilation.GetDiagnostics(); Debugger.Launch(); }
public void Execute(SourceGeneratorContext context) { StringBuilder sourceBuilder = new StringBuilder(@" using System; namespace SyntaxTreesGenerated { public static class SyntaxTrees { public static void PrintSyntaxTrees() { Console.WriteLine(""The following syntax trees existed in the compilation that created this program:""); "); foreach (SyntaxTree tree in context.Compilation.SyntaxTrees) { sourceBuilder.AppendLine($@"Console.WriteLine(@""{tree.FilePath}"");"); } sourceBuilder.Append(@" } } }"); context.AddSource("syntaxTreesGenerator", SourceText.From(sourceBuilder.ToString(), Encoding.UTF8)); }
public void Execute(SourceGeneratorContext context) { Compilation?compilation = context.Compilation; compilation = GenerateHelperClasses(context); INamedTypeSymbol?serviceLocatorClass = compilation.GetTypeByMetadataName("DI.ServiceLocator") !; INamedTypeSymbol?transientAttribute = compilation.GetTypeByMetadataName("DI.TransientAttribute") !; INamedTypeSymbol?iEnumerableOfT = compilation.GetTypeByMetadataName("System.Collections.Generic.IEnumerable`1") !.ConstructUnboundGenericType(); INamedTypeSymbol?listOfT = compilation.GetTypeByMetadataName("System.Collections.Generic.List`1") !; var knownTypes = new KnownTypes(iEnumerableOfT, listOfT, transientAttribute); var services = new List <Service>(); foreach (SyntaxTree?tree in compilation.SyntaxTrees) { SemanticModel?semanticModel = compilation.GetSemanticModel(tree); IEnumerable <INamedTypeSymbol>?typesToCreate = from i in tree.GetRoot().DescendantNodesAndSelf().OfType <InvocationExpressionSyntax>() let symbol = semanticModel.GetSymbolInfo(i).Symbol as IMethodSymbol where symbol != null where SymbolEqualityComparer.Default.Equals(symbol.ContainingType, serviceLocatorClass) select symbol.ReturnType as INamedTypeSymbol; foreach (INamedTypeSymbol?typeToCreate in typesToCreate) { CollectServices(context, typeToCreate, compilation, services, knownTypes); } } GenerateServiceLocator(context, services); }
public override void Execute(SourceGeneratorContext context) { if ( context.GetProjectInstance().GetPropertyValue("Configuration") == "Debug" && IsRemoteControlClientInstalled(context) && IsApplication(context.GetProjectInstance())) { var sb = new IndentedStringBuilder(); sb.AppendLineInvariant("// <auto-generated>"); sb.AppendLineInvariant("// ***************************************************************************************"); sb.AppendLineInvariant("// This file has been generated by the package Uno.UI.RemoteControl - for Xaml Hot Reload."); sb.AppendLineInvariant("// Documentation: https://platform.uno/docs/articles/features/working-with-xaml-hot-reload.html"); sb.AppendLineInvariant("// ***************************************************************************************"); sb.AppendLineInvariant("// </auto-generated>"); sb.AppendLineInvariant("// <autogenerated />"); sb.AppendLineInvariant("#pragma warning disable // Ignore code analysis warnings"); sb.AppendLineInvariant(""); BuildEndPointAttribute(context, sb); BuildSearchPaths(context, sb); context.AddCompilationUnit("RemoteControl", sb.ToString()); } }
public void Execute(SourceGeneratorContext context) { foreach (var file in context.AdditionalFiles) { AddSourceForAdditionalFile(context.AdditionalSources, file); } }
/// <inheritdoc /> public override void Execute(SourceGeneratorContext context) { _context = context; _objectSymbol = context.Compilation.GetTypeByMetadataName("System.Object"); _valueTypeSymbol = context.Compilation.GetTypeByMetadataName("System.ValueType"); _boolSymbol = context.Compilation.GetTypeByMetadataName("System.Bool"); _intSymbol = context.Compilation.GetTypeByMetadataName("System.Int32"); _stringSymbol = context.Compilation.GetTypeByMetadataName("System.String"); _arraySymbol = context.Compilation.GetTypeByMetadataName("System.Array"); _collectionSymbol = context.Compilation.GetTypeByMetadataName("System.Collections.ICollection"); _readonlyCollectionGenericSymbol = context.Compilation.GetTypeByMetadataName("System.Collections.Generic.IReadOnlyCollection`1"); _collectionGenericSymbol = context.Compilation.GetTypeByMetadataName("System.Collections.Generic.ICollection`1"); _iEquatableSymbol = context.Compilation.GetTypeByMetadataName("System.IEquatable`1"); _iKeyEquatableSymbol = context.Compilation.GetTypeByMetadataName("Uno.Equality.IKeyEquatable"); _iKeyEquatableGenericSymbol = context.Compilation.GetTypeByMetadataName("Uno.Equality.IKeyEquatable`1"); _generatedEqualityAttributeSymbol = context.Compilation.GetTypeByMetadataName("Uno.GeneratedEqualityAttribute"); _ignoreForEqualityAttributeSymbol = context.Compilation.GetTypeByMetadataName("Uno.EqualityIgnoreAttribute"); _equalityHashAttributeSymbol = context.Compilation.GetTypeByMetadataName("Uno.EqualityHashAttribute"); _equalityKeyAttributeSymbol = context.Compilation.GetTypeByMetadataName("Uno.EqualityKeyAttribute"); _equalityComparerOptionsAttributeSymbol = context.Compilation.GetTypeByMetadataName("Uno.Equality.EqualityComparerOptionsAttribute"); _dataAnnonationsKeyAttributeSymbol = context.Compilation.GetTypeByMetadataName("System.ComponentModel.DataAnnotations.KeyAttribute"); _generateKeyEqualityCode = _iKeyEquatableSymbol != null; foreach (var type in EnumerateEqualityTypesToGenerate()) { GenerateEquality(type); } }
public void Execute(SourceGeneratorContext context) { try { var registrationSymbols = RegistrationSymbols.FromCompilation(context.Compilation); var containerClasses = context.LocateContainerSymbols(registrationSymbols.ContainerSymbol); var generator = new ContainerClassContentGenerator(context, registrationSymbols); foreach (var containerClass in containerClasses) { var hintName = $"Generated.{containerClass.FullyQualifiedName}"; var content = generator.GenerateClassString(containerClass); WriteOutDebugFile(hintName, content, context); context.AddSource(hintName, SourceText.From(content, Encoding.UTF8)); } } catch (DiagnosticException ex) { context.ReportDiagnostic(ex.Diagnostic); } catch (Exception ex) { var descriptor = new DiagnosticDescriptor(DiagnosticConstants.UnknownExceptionId, "Unexpected error", $"Unknown error during generation: {ex.GetType()} {ex.Message}", DiagnosticConstants.Category, DiagnosticSeverity.Error, true); context.ReportDiagnostic(Diagnostic.Create(descriptor, Location.None)); } }
public void Execute(SourceGeneratorContext context) { //_ = Debugger.Launch(); // uncomment to debug this source generator // create a folder to serialize the generated source for debugging var generatedPath = default(string?); if (serializeSource) { // place it inside obj so that source is not added to the project generatedPath = Path.Combine("Generated", nameof(OverloadsGenerator)); // delete source generated by previous build if (Directory.Exists(generatedPath)) { Directory.Delete(generatedPath, true); } _ = Directory.CreateDirectory(generatedPath); } try { var collectedExtensionMethods = CollectExtensionMethods(context); GenerateSource(context, collectedExtensionMethods, generatedPath); } catch (Exception ex) { context.ReportDiagnostic(Diagnostic.Create(UnhandledExceptionError, Location.None, ex.Message)); } }
public void Execute(SourceGeneratorContext context) { var resources = context.GetMSBuildItems("PRIResource"); if (resources.Any()) { var sb = new IndentedStringBuilder(); using (sb.BlockInvariant($"namespace {context.GetMSBuildProperty("RootNamespace")}")) { using (sb.BlockInvariant($"internal enum PriResources")) { foreach (var item in resources) { //load document XmlDocument doc = new XmlDocument(); doc.Load(item); //extract all localization keys from Win10 resource file var nodes = doc.SelectNodes("//data") .Cast <XmlElement>() .Select(node => node.GetAttribute("name")) .ToArray(); foreach (var node in nodes) { sb.AppendLineInvariant($"{node},"); } } } } context.AddSource("PriResources", SourceText.From(sb.ToString(), Encoding.UTF8)); } }
public void Execute(SourceGeneratorContext context) { string attributeSource = @" [System.AttributeUsage(System.AttributeTargets.Assembly, AllowMultiple=true)] public class MustacheAttribute: System.Attribute { public string Name { get; } public string Template { get; } public string Hash { get; } public MustacheAttribute(string name, string template, string hash) => (Name, Template, Hash) = (name, template, hash); } "; context.AddSource("Mustache_MainAttributes__", SourceText.From(attributeSource, Encoding.UTF8)); Compilation compilation = context.Compilation; IEnumerable <(string, string, string)> options = GetMustacheOptions(compilation); IEnumerable <(string, string)> namesSources = SourceFilesFromMustachePaths(options); foreach ((string name, string source) in namesSources) { context.AddSource($"Mustache{name}", SourceText.From(source, Encoding.UTF8)); } }
protected override void Generate(SourceGeneratorContext context, INamedTypeSymbol symbol) { var equalsCandidates = symbol.GetMembers(nameof(Equals)) .Where(member => member is IMethodSymbol method && SymbolEqualityComparer.Default.Equals(method.ReturnType, context.Compilation.GetSpecialType(SpecialType.System_Boolean)) && method.Parameters.Length == 1 && SymbolEqualityComparer.Default.Equals(method.Parameters[0], symbol)); var ghcCandidates = symbol.GetMembers(nameof(GetHashCode)) .Where(member => member is IMethodSymbol method && SymbolEqualityComparer.Default.Equals(method.ReturnType, context.Compilation.GetSpecialType(SpecialType.System_Int32)) && method.Parameters.Length == 0); var builder = new StringBuilder(); if (equalsCandidates.Count() == 0) { var compString = GenerateComparisonOfAllFields(context, symbol); builder.AppendLine(string.Format(symbol.IsValueType ? ValueTypeStandardEqualsTemplate : RefTypeStandardEqualsTemplate, symbol.Name, compString)); } if (ghcCandidates.Count() == 0) { var ghcString = GenerateHashCodeOfAllFields(context, symbol); builder.AppendLine(string.Format(GetHashCodeTemplate, ghcString)); } builder.AppendLine(string.Format(symbol.IsValueType ? ValueTypeEqualsTemplate : RefTypeEqualsTemplate, symbol.Name)); builder.AppendLine(string.Format(EquatableTemplate, symbol.Name)); var source = string.Format(TypeTemplate, symbol.ContainingNamespace, symbol.IsValueType ? "struct" : "class", symbol.Name, builder.ToString()); context.AddSource($"{symbol.Name}.EqualityMembers.cs", SourceText.From(source, Encoding.UTF8)); }
private void GenerateCategories( SourceGeneratorContext context, IEnumerable <INamedTypeSymbol> symbols, int bucketCount) { var sha1 = SHA1.Create(); foreach (var type in symbols) { var builder = new IndentedStringBuilder(); builder.AppendLineInvariant("using System;"); using (builder.BlockInvariant($"namespace {type.ContainingNamespace}")) { // Compute a stable hash of the full metadata name var buffer = Encoding.UTF8.GetBytes(type.GetFullMetadataName()); var hash = sha1.ComputeHash(buffer); var hashPart64 = BitConverter.ToUInt64(hash, 0); var testCategoryBucket = (hashPart64 % (uint)bucketCount) + 1; builder.AppendLineInvariant($"[global::NUnit.Framework.Category(\"testBucket:{testCategoryBucket}\")]"); using (builder.BlockInvariant($"partial class {type.Name}")) { } } context.AddCompilationUnit(Sanitize(type.GetFullMetadataName()), builder.ToString()); } }
public void Execute(SourceGeneratorContext context) { // begin creating the source we'll inject into the users compilation StringBuilder sourceBuilder = new StringBuilder(@" using System; namespace HelloWorldGenerated { public static class HelloWorld { public static void SayHello() { Console.WriteLine(""Hello from generated code!""); Console.WriteLine(""The following syntax trees existed in the compilation that created this program:""); "); // using the context, get a list of syntax trees in the users compilation IEnumerable <SyntaxTree> syntaxTrees = context.Compilation.SyntaxTrees; // add the filepath of each tree to the class we're building foreach (SyntaxTree tree in syntaxTrees) { sourceBuilder.AppendLine($@"Console.WriteLine(@"" - {tree.FilePath}"");"); } // finish creating the source to inject sourceBuilder.Append(@" } } }"); // inject the created source into the users compilation context.AddSource("helloWorldGenerated", SourceText.From(sourceBuilder.ToString(), Encoding.UTF8)); }
public void Execute(GeneratorExecutionContext context) { // check that the users compilation references the expected library if (!context.Compilation.ReferencedAssemblyNames.Any(ai => ai.Name.Equals("SaltLakeCity.Framework.Alpakabroker", StringComparison.OrdinalIgnoreCase))) { //context.ReportDiagnostic(); } using var sourceGenContext = SourceGeneratorContext <Generator> .Create(context); if (context.SyntaxReceiver is not AlpakaEventSyntaxReceiver actorSyntaxReciver) { return; } foreach (var @event in actorSyntaxReciver.Events) { var alpakaEventModel = AlpakaEventModelFactory.From(@event, sourceGenContext.GeneratorExecutionContext.Compilation); var alpakaEventEmitter = TemplateGenerator.GenerateAlpakaEventEmitter(alpakaEventModel); var alpakaEventReceiverBase = TemplateGenerator.GenerateAlpakaEventEventReceiverBase(alpakaEventModel); context.AddSource(alpakaEventEmitter.FileName, alpakaEventEmitter.SourceCode); context.AddSource(alpakaEventReceiverBase.FileName, alpakaEventReceiverBase.SourceCode); } }
public void WritePrimitivesSerializerClass(SourceGeneratorContext context) { // Write out some functions that are missing from the BinaryPrimitives class. var sourceBuilder = new StringBuilder(); sourceBuilder.Append(@" namespace BitSerialization.Generated { internal static class BitPrimitivesSerializer { public static bool TryWriteByte(global::System.Span<byte> destination, byte value) { if (destination.Length < 1) { return false; } destination[0] = value; return true; } public static bool TryWriteSByte(global::System.Span<byte> destination, sbyte value) { if (destination.Length < 1) { return false; } destination[0] = (byte)value; return true; } public static bool TryReadByte(global::System.ReadOnlySpan<byte> source, out byte value) { if (source.Length < 1) { value = default; return false; } value = source[0]; return true; } public static bool TryReadSByte(global::System.ReadOnlySpan<byte> source, out sbyte value) { if (source.Length < 1) { value = default; return false; } value = (sbyte)source[0]; return true; } } } "); string sourceCode = sourceBuilder.ToString(); context.AddSource("BitPrimitivesSerializer.cs", SourceText.From(sourceCode, Encoding.UTF8)); }
public void Execute(SourceGeneratorContext context) { Compilation?compilation = context.Compilation; string sourceBuilder = Generate(compilation); context.AddSource("ServiceLocator.cs", SourceText.From(sourceBuilder, Encoding.UTF8)); }
public void Execute(SourceGeneratorContext context) { _onExecute(context); if (!string.IsNullOrWhiteSpace(_sourceOpt)) { context.AdditionalSources.Add("source.cs", SourceText.From(_sourceOpt, Encoding.UTF8)); } }
public override void Execute(SourceGeneratorContext context) { if (PlatformHelper.IsValidPlatform(context)) { var visitor = new SerializationMethodsGenerator(context); visitor.Visit(context.Compilation.SourceModule); } }
public abstract void Execute(SourceGeneratorContext context);
public override void Execute(SourceGeneratorContext context) { _execute(context); }