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