public static TypeDeclarationSyntax ReparentDeclaration( this TypeDeclarationSyntax classToNest, SourceProductionContext context, TypeDeclarationSyntax source ) { var parent = source.Parent; while (parent is TypeDeclarationSyntax parentSyntax) { classToNest = parentSyntax .WithMembers(SyntaxFactory.List <MemberDeclarationSyntax>()) .WithAttributeLists(SyntaxFactory.List <AttributeListSyntax>()) .WithConstraintClauses(SyntaxFactory.List <TypeParameterConstraintClauseSyntax>()) .WithBaseList(null) .AddMembers(classToNest); if (!parentSyntax.Modifiers.Any(z => z.IsKind(SyntaxKind.PartialKeyword))) { context.ReportDiagnostic( Diagnostic.Create(GeneratorDiagnostics.MustBePartial, parentSyntax.Identifier.GetLocation(), parentSyntax.GetFullMetadataName()) ); } parent = parentSyntax.Parent; } return(classToNest); }
private static void GenerateSource(SourceProductionContext context, ImmutableArray <AdditionalText> xmlFiles) { var records = ReadIso4217RecordsFromAdditionalFiles(xmlFiles, context.CancellationToken).ToImmutableArray(); context.AddSource("CurrencyCode.Generated", SourceText.From(GenerateCurrencyClass(records), Encoding.UTF8)); context.AddSource("Money.Generated", SourceText.From(GenerateMoneyClass(records), Encoding.UTF8)); }
protected override void Execute( SourceProductionContext context, INamedTypeSymbol scriptContentClass, INamedTypeSymbol scriptContentTypeEnum, INamedTypeSymbol sageGameEnum) { var sb = new StringBuilder(); sb.AppendLine("namespace OpenSage.Scripting"); sb.AppendLine("{"); sb.AppendLine(" partial class ScriptActions"); sb.AppendLine(" {"); sb.AppendLine(" private static void ExecuteImpl(ScriptExecutionContext context, ScriptAction action, ScriptActionType actionType)"); sb.AppendLine(" {"); sb.AppendLine(" var game = context.Game.SageGame;"); sb.AppendLine(); sb.AppendLine(" switch (actionType)"); sb.AppendLine(" {"); WriteCases(scriptContentClass, scriptContentTypeEnum, sageGameEnum, sb); sb.AppendLine(" default:"); sb.AppendLine(" Logger.Warn($\"Script action type '{actionType}' not implemented\");"); sb.AppendLine(" break;"); sb.AppendLine(" }"); sb.AppendLine(" }"); sb.AppendLine(" }"); sb.AppendLine("}"); context.AddSource("ScriptActions.Execution.g.cs", sb.ToString()); }
private static MethodDeclarationSyntax?GenerateMethod( SourceProductionContext context, IRestfulApiMethodMatcher?matcher, IReadOnlyDictionary <RestfulApiMethod, int> statusCodeMap, MethodDeclarationSyntax syntax, IMethodSymbol symbol, IParameterSymbol parameter, ImmutableArray <(MethodDeclarationSyntax method, IMethodSymbol symbol, IRestfulApiMethodMatcher?matcher, IParameterSymbol?request)> members
public static void EmitFile(this SourceProductionContext context, string?typeNamespace, string typeName, string?generatedCode, string?fileNameSuffix) { if (String.IsNullOrWhiteSpace(generatedCode)) { return; } var hintName = $"{(typeNamespace is null ? null : $"{typeNamespace}.")}{typeName}{fileNameSuffix}.g.cs";
public IEnumerable <MemberDeclarationSyntax> Apply(SourceProductionContext context, GeneratorData item) { if (item is not RequestItem requestItem) { yield break; } if (requestItem is not { LspAttributes : { Resolver : { } } })
public IEnumerable <MemberDeclarationSyntax> Apply(SourceProductionContext context, ExtensionMethodContext extensionMethodContext, GeneratorData item) { if (item is not RequestItem request) { yield break; } if (extensionMethodContext is not { IsProxy : true })
public static OutputModel?Create(SourceProductionContext context, Compilation compilation, ImmutableArray <SyntaxNode> syntaxNodes) { context.CancellationToken.ThrowIfCancellationRequested(); if (syntaxNodes.IsDefaultOrEmpty) { return(null); } var model = new OutputModel { Context = context, CancellationToken = context.CancellationToken, Compilation = compilation, DbAttributeSymbol = compilation.GetTypeByMetadataName("Cosmogenesis.Core.Attributes.DbAttribute") !, DocTypeAttributeSymbol = compilation.GetTypeByMetadataName("Cosmogenesis.Core.Attributes.DocTypeAttribute") !, MutableAttributeSymbol = compilation.GetTypeByMetadataName("Cosmogenesis.Core.Attributes.MutableAttribute") !, PartitionAttributeSymbol = compilation.GetTypeByMetadataName("Cosmogenesis.Core.Attributes.PartitionAttribute") !, PartitionDefinitionAttributeSymbol = compilation.GetTypeByMetadataName("Cosmogenesis.Core.Attributes.PartitionDefinitionAttribute") !, TransientAttributeSymbol = compilation.GetTypeByMetadataName("Cosmogenesis.Core.Attributes.TransientAttribute") !, UseDefaultAttributeSymbol = compilation.GetTypeByMetadataName("Cosmogenesis.Core.Attributes.UseDefaultAttribute") !, DbDocSymbol = compilation.GetTypeByMetadataName("Cosmogenesis.Core.DbDoc") !, JsonIgnoreAttributeSymbol = compilation.GetTypeByMetadataName("System.Text.Json.Serialization.JsonIgnoreAttribute") }; if (model.DbAttributeSymbol is null || model.DocTypeAttributeSymbol is null || model.MutableAttributeSymbol is null || model.PartitionAttributeSymbol is null || model.PartitionDefinitionAttributeSymbol is null || model.TransientAttributeSymbol is null || model.UseDefaultAttributeSymbol is null || model.DbDocSymbol is null) { return(null); } if (compilation.Options.NullableContextOptions != NullableContextOptions.Enable) { model.Report(Diagnostics.Errors.NullableContext, compilation.Assembly); return(null); } foreach (var attributeData in compilation.Assembly.GetAttributes()) { if (SymbolEqualityComparer.Default.Equals(attributeData.AttributeClass, model.DbAttributeSymbol)) { DbAttributeModelBuilder.Build(model, null, attributeData); } } foreach (var syntax in syntaxNodes.Select(x => x as ClassDeclarationSyntax).Where(x => x is not null)) { ClassModelBuilder.Build(model, syntax !); } return(model); } }
private static void EmitSourceFile(SourceProductionContext context, EventSourceClass ec) { StringBuilder sb = new StringBuilder(1024); sb.AppendLine(@"// <auto-generated/>"); sb.AppendLine(); sb.AppendLine("using System;"); GenType(ec, sb); context.AddSource($"{ec.ClassName}.g.cs", SourceText.From(sb.ToString(), Encoding.UTF8)); }
public static void ReportDiagnostics( this SourceProductionContext context, DiagnosticDescriptor descriptor, IEnumerable <Location> locations, params object?[]?messageArgs) { foreach (var location in locations) { context.ReportDiagnostic(Diagnostic.Create(descriptor, location, messageArgs)); } }
public void ReportDiagnosticTo(SourceProductionContext context) { if (_diagnosticList == null) { return; } foreach (var d in _diagnosticList) { context.ReportDiagnostic(d); } }
public GeneratorContext( SourceProductionContext sourceProductionContext, ImmutableArray <TypeDeclarationSyntax> candidateTypes, ImmutableArray <InvocationExpressionSyntax> candidateGetServiceCalls, Compilation compilation) { _sourceProductionContext = sourceProductionContext; CandidateTypes = candidateTypes; CandidateGetServiceCalls = candidateGetServiceCalls; Compilation = compilation; _compilationAnalysisContext = null; }
public IEnumerable <MemberDeclarationSyntax> Apply(SourceProductionContext context, GeneratorData item) { foreach (var diagnostic in item.JsonRpcAttributes.RequestProxyDiagnostics) { context.ReportDiagnostic(diagnostic); } return(item.JsonRpcAttributes.RequestProxies .Select( registry => new ExtensionMethodContext( item.JsonRpcAttributes.GenerateRequestMethods !.Data, item.TypeDeclaration, item.TypeSymbol, registry, item.JsonRpcAttributes.RequestProxies ) { IsProxy = true }
private static void GenerateAutoImplementedInterfaces(SourceProductionContext context, GeneratorSyntaxContext syntaxContext) { var candidate = (TypeDeclarationSyntax)syntaxContext.Node; var members = new List <MemberDeclarationSyntax>(); var model = syntaxContext.SemanticModel; var symbol = model.GetDeclaredSymbol(candidate); if (symbol is null) { return; } var autoImplementProperties = AutoImplementInterfaces(candidate, symbol).ToArray(); if (autoImplementProperties is { Length : > 0 })
private void GenerateSource(SourceProductionContext context, ImmutableArray <ITypeSymbol> typeSymbols) { var sb = new StringBuilder(); foreach (var symbol in typeSymbols) { if (symbol is null) { continue; } sb.AppendLine("// " + symbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)); } context.AddSource($"all_types.cs", SourceText.From(sb.ToString(), Encoding.UTF8)); }
private static void GeneratePropertyTracking( SourceProductionContext context, TypeDeclarationSyntax declaration, INamedTypeSymbol symbol, INamedTypeSymbol targetSymbol ) { if (!declaration.Modifiers.Any(z => z.IsKind(SyntaxKind.PartialKeyword))) { context.ReportDiagnostic( Diagnostic.Create(GeneratorDiagnostics.MustBePartial, declaration.Identifier.GetLocation(), declaration.GetFullMetadataName()) ); return; } var isRecord = declaration is RecordDeclarationSyntax; if (targetSymbol.IsRecord != isRecord) { context.ReportDiagnostic( Diagnostic.Create( GeneratorDiagnostics.ParameterMustBeSameTypeOfObject, declaration.Keyword.GetLocation(), declaration.GetFullMetadataName(), declaration.Keyword.IsKind(SyntaxKind.ClassKeyword) ? "record" : "class" ) ); return; } var classToInherit = declaration .WithMembers(List <MemberDeclarationSyntax>()) .WithAttributeLists(List <AttributeListSyntax>()) .WithConstraintClauses(List <TypeParameterConstraintClauseSyntax>()) .WithBaseList(null) .WithAttributeLists( SingletonList( AttributeList( SingletonSeparatedList(Attribute(ParseName("System.Runtime.CompilerServices.CompilerGenerated"))) ) ) ); var writeableProperties = targetSymbol.GetMembers() .OfType <IPropertySymbol>() // only works for `set`able properties not init only .Where(z => !symbol.GetMembers(z.Name).Any()) .Where(z => z is { IsStatic: false, IsIndexer: false, IsReadOnly: false });
private void GenerateEnum(SourceProductionContext context, GeneratorSyntaxContext syntaxContext) { var candidate = (StructDeclarationSyntax)syntaxContext.Node; var model = syntaxContext.SemanticModel; var symbol = model.GetDeclaredSymbol(syntaxContext.Node); if (symbol is null) { return; } if (!candidate.Modifiers.Any(z => z.IsKind(SyntaxKind.PartialKeyword))) { context.ReportDiagnostic(Diagnostic.Create(GeneratorDiagnostics.MustBePartial, candidate.Identifier.GetLocation(), candidate.Identifier.Text)); return; } if (!candidate.Modifiers.Any(z => z.IsKind(SyntaxKind.ReadOnlyKeyword))) { context.ReportDiagnostic(Diagnostic.Create(GeneratorDiagnostics.MustBeReadOnly, candidate.Identifier.GetLocation(), candidate.Identifier.Text)); return; } var cu = CompilationUnit( List <ExternAliasDirectiveSyntax>(), List <UsingDirectiveSyntax>(), List <AttributeListSyntax>(), SingletonList <MemberDeclarationSyntax>( NamespaceDeclaration(ParseName(symbol.ContainingNamespace.ToDisplayString())) .WithMembers(SingletonList <MemberDeclarationSyntax>(GetImplementation(candidate))) ) ) .AddUsings( UsingDirective(ParseName("System")), UsingDirective(ParseName("System.Collections.Generic")), UsingDirective(ParseName("System.Diagnostics")), UsingDirective(ParseName("System.Linq")), UsingDirective(ParseName("System.Reflection")), UsingDirective(ParseName("Newtonsoft.Json")), UsingDirective(ParseName("OmniSharp.Extensions.JsonRpc")), UsingDirective(ParseName("OmniSharp.Extensions.JsonRpc.Serialization.Converters")) ) .WithLeadingTrivia() .WithTrailingTrivia() .WithLeadingTrivia(Trivia(NullableDirectiveTrivia(Token(SyntaxKind.EnableKeyword), true))) .WithTrailingTrivia(Trivia(NullableDirectiveTrivia(Token(SyntaxKind.RestoreKeyword), true))); context.AddSource( $"{Path.GetFileNameWithoutExtension(candidate.SyntaxTree.FilePath)}_{candidate.Identifier.Text}{( candidate.Arity > 0 ? candidate.Arity.ToString() : "" )}.cs", cu.NormalizeWhitespace().GetText(Encoding.UTF8) ); }
private static void Execute( SourceProductionContext context, ImmutableArray <SyntaxNode> syntaxNodes, OutputKind outputKind, ApplicationConfig?applicationConfig, Diagnostic?applicationConfigDiagnostics) { if (syntaxNodes.IsEmpty) { return; } if (applicationConfig is null) { if (applicationConfigDiagnostics is not null) { context.ReportDiagnostic(applicationConfigDiagnostics); } return; } if (outputKind != OutputKind.WindowsApplication && // Starting in the 5.0.100 version of the .NET SDK, when OutputType is set to Exe, it is automatically changed to WinExe // for WPF and Windows Forms apps that target any framework version, including .NET Framework. // https://docs.microsoft.com/en-us/dotnet/core/compatibility/sdk/5.0/automatically-infer-winexe-output-type outputKind != OutputKind.ConsoleApplication) { context.ReportDiagnostic(Diagnostic.Create(DiagnosticDescriptors.s_errorUnsupportedProjectType, Location.None, nameof(OutputKind.WindowsApplication))); return; } string?code = ApplicationConfigurationInitializeBuilder.GenerateInitialize(projectNamespace: GetUserProjectNamespace(syntaxNodes[0]), applicationConfig); if (code is not null) { context.AddSource("ApplicationConfiguration.g.cs", code); } }
private static void GenerateInheritance( SourceProductionContext context, Compilation compilation, TypeDeclarationSyntax declaration, INamedTypeSymbol symbol, AttributeData[] attributes ) { if (!declaration.Modifiers.Any(z => z.IsKind(SyntaxKind.PartialKeyword))) { context.ReportDiagnostic( Diagnostic.Create(GeneratorDiagnostics.MustBePartial, declaration.Identifier.GetLocation(), declaration.GetFullMetadataName()) ); return; } var classToInherit = declaration .WithMembers(List <MemberDeclarationSyntax>()) .WithAttributeLists(List <AttributeListSyntax>()) .WithConstraintClauses(List <TypeParameterConstraintClauseSyntax>()) .WithBaseList(null) .WithAttributeLists( SingletonList( AttributeList( SingletonSeparatedList(Attribute(ParseName("System.Runtime.CompilerServices.CompilerGenerated"))) ) ) ); foreach (var attribute in attributes) { if (attribute.ApplicationSyntaxReference?.GetSyntax() is not { } attributeSyntax) { continue; } if (attribute is { ConstructorArguments: { Length: 0 } } || attribute.ConstructorArguments[0] is { Kind: not TypedConstantKind.Type })
public IEnumerable <MemberDeclarationSyntax> Apply(SourceProductionContext context, GeneratorData item) { if (item.Capability != null) { item.AdditionalUsings.Add(item.Capability.Symbol.ContainingNamespace.ToDisplayString()); } if (item.RegistrationOptions != null) { item.AdditionalUsings.Add(item.RegistrationOptions.Symbol.ContainingNamespace.ToDisplayString()); } if (item is RequestItem requestItem) { if (requestItem.PartialItem != null) { item.AdditionalUsings.Add(requestItem.PartialItem.Symbol.ContainingNamespace.ToDisplayString()); } if (requestItem.PartialItems != null) { item.AdditionalUsings.Add(requestItem.PartialItems.Symbol.ContainingNamespace.ToDisplayString()); } } yield break; }
public IEnumerable <MemberDeclarationSyntax> Apply(SourceProductionContext context, ExtensionMethodContext extensionMethodContext, GeneratorData item) { if (item is { RegistrationOptions : { } })
public static Location?GetLocationOrNullSafe(this ISourceGeneratorState enumState, SourceProductionContext context) { try { // pick one location as the representative return(enumState.GetFirstLocation()); } catch (Exception ex) { context.ReportException(ex); return(null); } }
public Emitter(SourceProductionContext context, SourceGenerationSpec spec) { _context = context; _spec = spec; }
private static void Execute( SourceProductionContext context, (ImmutableArray <ClassDeclarationSyntax> Candidates, AssemblyResolver AssemblyResolver, Compilation Compilation) source)
public IEnumerable <MemberDeclarationSyntax> Apply(SourceProductionContext context, GeneratorData item) { var methods = _extensionMethodGeneratorStrategies.Aggregate( new List <MemberDeclarationSyntax>(), (m, strategy) => { try { m.AddRange(strategy.Apply(context, item)); } catch (Exception e) { Debug.WriteLine($"Strategy {strategy.GetType().FullName} failed!"); Debug.WriteLine(e); Debug.WriteLine(e.StackTrace); } return(m); } ); var className = item.JsonRpcAttributes.HandlerName + "Extensions" + (item.TypeDeclaration.Arity == 0 ? "" : item.TypeDeclaration.Arity.ToString()); var obsoleteAttribute = item.TypeDeclaration.AttributeLists .SelectMany(z => z.Attributes) .Where(z => z.IsAttribute("Obsolete")) .ToArray(); var attributes = List( new[] { AttributeList( SeparatedList( new[] { Attribute(ParseName("System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute")), Attribute(ParseName("System.Runtime.CompilerServices.CompilerGeneratedAttribute")), }.Union(obsoleteAttribute) ) ) } ); if (methods.Count == 0) { yield break; } yield return(NamespaceDeclaration(ParseName(item.JsonRpcAttributes.HandlerNamespace)) .WithMembers( SingletonList <MemberDeclarationSyntax>( ClassDeclaration(className) .WithAttributeLists(attributes) .WithModifiers( TokenList( new [] { Token(item.TypeSymbol.DeclaredAccessibility == Accessibility.Public ? SyntaxKind.PublicKeyword : SyntaxKind.InternalKeyword), Token(SyntaxKind.StaticKeyword), Token(SyntaxKind.PartialKeyword) } ) ) .WithMembers(List(methods)) .WithLeadingTrivia(TriviaList(Trivia(NullableDirectiveTrivia(Token(SyntaxKind.EnableKeyword), true)))) .WithTrailingTrivia(TriviaList(Trivia(NullableDirectiveTrivia(Token(SyntaxKind.RestoreKeyword), true)))) ) )); }
public ExecutionContext(SourceProductionContext context) { _context = context; }
public static void Write(SourceProductionContext context, (Compilation Left, ImmutableArray <SyntaxNode> Right) action)
public JsonSourceGenerationContext(SourceProductionContext context) { _context = context; }
private void Execute(Compilation compilation, ImmutableArray <ClassDeclarationSyntax> contextClasses, SourceProductionContext sourceProductionContext) { #if LAUNCH_DEBUGGER if (!Diagnostics.Debugger.IsAttached) { Diagnostics.Debugger.Launch(); } #endif if (contextClasses.IsDefaultOrEmpty) { return; } JsonSourceGenerationContext context = new JsonSourceGenerationContext(sourceProductionContext); Parser parser = new(compilation, context); SourceGenerationSpec?spec = parser.GetGenerationSpec(contextClasses, sourceProductionContext.CancellationToken); if (spec != null) { _rootTypes = spec.ContextGenerationSpecList[0].RootSerializableTypes; Emitter emitter = new(context, spec); emitter.Emit(); } }
public IEnumerable <MemberDeclarationSyntax> Apply(SourceProductionContext context, ExtensionMethodContext extensionMethodContext, GeneratorData item) { if (extensionMethodContext is not { IsProxy : true })