public PropertyDeclarationSyntax Enrich(PropertyDeclarationSyntax target,
OpenApiEnrichmentContext <OpenApiSchema> context)
{
if (target.Parent is ClassDeclarationSyntax classDeclaration &&
classDeclaration.GetGeneratorAnnotation() == typeof(RequestMediaTypeGenerator))
{
// Don't enrich body properties on the request classes
return(target);
}
var attribute = Attribute(NewtonsoftJsonTypes.JsonPropertyAttributeName,
AttributeArgumentList(SingletonSeparatedList(
AttributeArgument(SyntaxHelpers.StringLiteral(context.LocatedElement.Key)))));
bool isRequired =
context.LocatedElement.Parent is LocatedOpenApiElement <OpenApiSchema> parentSchema &&
parentSchema.Element.Required.Contains(context.LocatedElement.Key);
bool isNullable = context.LocatedElement.Element.Nullable;
if (!isRequired && !isNullable)
{
// We prefer not to send null values if the property is not required.
// However, for nullable properties, prefer to send the null explicitly.
// This is a compromise due to .NET not supporting a concept of null vs missing.
attribute = attribute.AddArgumentListArguments(AttributeArgument(
NameEquals(IdentifierName("NullValueHandling")),
null,
NewtonsoftJsonTypes.NullValueHandling.Ignore));
}
return(target.AddAttributeLists(AttributeList(SingletonSeparatedList(attribute))));
}
protected virtual IEnumerable <StatementSyntax> GenerateStatements(
ILocatedOpenApiElement <OpenApiOperation> operation)
{
var requestBody = operation.GetRequestBody();
ILocatedOpenApiElement <OpenApiMediaType>?mediaType;
if (requestBody == null || (mediaType = MediaTypeSelector.Select(requestBody)) == null)
{
yield return(ReturnStatement(LiteralExpression(SyntaxKind.NullLiteralExpression)));
yield break;
}
var createContentExpression =
InvocationExpression(MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
SerializationNamespace.TypeSerializerRegistryExtensions,
IdentifierName("Serialize")))
.AddArgumentListArguments(
Argument(IdentifierName(TypeSerializerRegistryParameterName)),
Argument(IdentifierName(RequestTypeGenerator.BodyPropertyName)),
Argument(SyntaxHelpers.StringLiteral(mediaType.Key)));
yield return(ReturnStatement(ConditionalExpression(
IsPatternExpression(
IdentifierName(RequestTypeGenerator.BodyPropertyName),
ConstantPattern(LiteralExpression(SyntaxKind.NullLiteralExpression))),
LiteralExpression(SyntaxKind.NullLiteralExpression),
createContentExpression)));
}
private async Task <Document> AddOperatorType(
Document document,
CompilationUnitSyntax root,
ImmutableDictionary <string, ImmutableArray <ITypeSymbol> > constraintDic)
{
bool hasMethod = false;
var usings = root.Usings.ToNamespaceHashSet();
MemberDeclarationSyntax[] newMembers = new MemberDeclarationSyntax[constraintDic.Count];
foreach (var(p, i) in constraintDic.Select((p, i) => (p, i)))
{
bool m;
(newMembers[i], m) = CreateOperatorTypeSyntax(p.Key, p.Value, usings);
hasMethod |= m;
}
root = root.AddMembers(newMembers);
if (hasMethod && !usings.Contains(System_Runtime_CompilerServices))
{
root = SyntaxHelpers.AddSystem_Runtime_CompilerServicesSyntax(root);
}
return(document.WithSyntaxRoot(root));
}
public override IEnumerable <SyntaxNode> GetSyntax()
{
var method = SyntaxFactory.MethodDeclaration
(
SyntaxFactory.PredefinedType
(
SyntaxFactory.Token(SyntaxKind.VoidKeyword)
),
SyntaxFactory.Identifier(Name)
)
.WithModifiers(SyntaxHelpers.GetModifiers(Modifiers));
if (!string.IsNullOrWhiteSpace(Comment))
{
method = method.WithLeadingTrivia(GetDocumentationTriviaSyntax());
}
var block = SyntaxFactory.Block();
foreach (var port in Ports.Where(x => x.PortType == Enums.PortType.Out))
{
foreach (var connectedPort in port.ConnectedPorts.Cast <CSPort>())
{
block = block.AddStatements(connectedPort.GetStatementSyntax().ToArray());
}
}
return(new[] { method.WithBody(block) });
}
protected override BlockSyntax GenerateApplyAsyncBody() => Block(
MethodHelpers.ThrowIfArgumentNull(MessageParameterName),
MethodHelpers.IfNull(IdentifierName(CacheFieldName), Block(
ExpressionStatement(AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
IdentifierName(CacheFieldName),
WellKnownTypes.System.Convert.ToBase64String(WellKnownTypes.System.Text.Encoding.GetBytes(
WellKnownTypes.System.Text.Encoding.UTF8,
BinaryExpression(SyntaxKind.AddExpression,
BinaryExpression(SyntaxKind.AddExpression,
IdentifierName(UsernamePropertyName),
SyntaxHelpers.StringLiteral(":")),
IdentifierName(PasswordPropertyName))
))))
)),
ExpressionStatement(AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
IdentifierName(MessageParameterName),
IdentifierName("Headers")),
IdentifierName("Authorization")),
ObjectCreationExpression(WellKnownTypes.System.Net.Http.Headers.AuthenticationHeaderValue.Name)
.AddArgumentListArguments(
Argument(SyntaxHelpers.StringLiteral("Basic")),
Argument(IdentifierName(CacheFieldName))))),
ReturnStatement(LiteralExpression(SyntaxKind.DefaultLiteralExpression)));
public MethodDeclarationSyntax Generate(ILocatedOpenApiElement <OpenApiOperation> operation)
{
var propertyNameFormatter = Context.NameFormatterSelector.GetFormatter(NameKind.Property);
var path = (LocatedOpenApiElement <OpenApiPathItem>)operation.Parent !;
ExpressionSyntax pathExpression = PathParser.Parse(path.Key).ToInterpolatedStringExpression(
pathSegment =>
{
OpenApiParameter?parameter = operation.Element.Parameters.FirstOrDefault(
p => p.Name == pathSegment.Value);
if (parameter == null)
{
throw new InvalidOperationException(
$"Missing path parameter '{pathSegment.Value}' in operation '{operation.Element.OperationId}'.");
}
return(InvocationExpression(MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
SerializationNamespace.PathSegmentSerializerInstance,
IdentifierName("Serialize")))
.AddArgumentListArguments(
Argument(SyntaxHelpers.StringLiteral(pathSegment.Value)),
Argument(IdentifierName(propertyNameFormatter.Format(pathSegment.Value))),
Argument(GetStyleExpression(parameter)),
Argument(GetExplodeExpression(parameter))));
});
OpenApiParameter[] queryParameters = operation.Element.Parameters
.Where(p => (p.In ?? ParameterLocation.Query) == ParameterLocation.Query)
.ToArray();
if (queryParameters.Length > 0)
{
NameSyntax keyValuePairType = WellKnownTypes.System.Collections.Generic.KeyValuePair.Name(
PredefinedType(Token(SyntaxKind.StringKeyword)),
PredefinedType(Token(SyntaxKind.ObjectKeyword)));
ExpressionSyntax buildArrayExpression = ArrayCreationExpression(
ArrayType(keyValuePairType)
.AddRankSpecifiers(ArrayRankSpecifier().AddSizes(OmittedArraySizeExpression())))
.WithInitializer(InitializerExpression(SyntaxKind.ArrayInitializerExpression,
SeparatedList <ExpressionSyntax>(queryParameters
.Select(parameter => ObjectCreationExpression(keyValuePairType)
.AddArgumentListArguments(
Argument(SyntaxHelpers.StringLiteral(parameter.Name)),
Argument(IdentifierName(propertyNameFormatter.Format(parameter.Name))))))));
pathExpression = WellKnownTypes.Yardarm.Client.OperationHelpers.AddQueryParameters(
pathExpression, buildArrayExpression);
}
return(MethodDeclaration(
PredefinedType(Token(SyntaxKind.StringKeyword)),
BuildUriMethodName)
.AddModifiers(Token(SyntaxKind.PublicKeyword))
.WithExpressionBody(ArrowExpressionClause(
pathExpression)));
}
public CompilationUnitSyntax Enrich(CompilationUnitSyntax syntax) => syntax
.AddAttributeLists(
SyntaxFactory.AttributeList().AddAttributes(
SyntaxFactory.Attribute(SyntaxFactory.ParseName("System.Runtime.Versioning.TargetFramework"))
.AddArgumentListArguments(
SyntaxFactory.AttributeArgument(SyntaxHelpers.StringLiteral(".NETStandard,Version=v2.0")),
SyntaxFactory.AttributeArgument(SyntaxHelpers.StringLiteral(""))
.WithNameEquals(SyntaxFactory.NameEquals("FrameworkDisplayName"))))
.WithTarget(SyntaxFactory.AttributeTargetSpecifier(SyntaxFactory.Token(SyntaxKind.AssemblyKeyword))));
public void TestGetTypeNameSyntax(string expectedCode, TypeMember type)
{
//-- act
var actualSyntax = SyntaxHelpers.GetTypeNameSyntax(type);
//-- assert
actualSyntax.Should().BeEquivalentToCode(expectedCode);
}
public void TestGetLegalCSharpIdentifier(string proposedName, string expectedName)
{
//-- act
var actualName = SyntaxHelpers.GetValidCSharpIdentifier(proposedName);
//-- assert
actualName.Should().Be(expectedName);
}
public void TestGetLiteralSyntax(object value, string expectedCode)
{
//-- act
var actualSyntax = SyntaxHelpers.GetLiteralSyntax(value);
//-- assert
actualSyntax.Should().BeEquivalentToCode(expectedCode);
}
private static async Task <Document> GenerateToString(
Document document,
ClassDeclarationSyntax classDeclarationSyntax,
IList <PropertyDeclarationSyntax> properties,
CancellationToken cancellationToken)
{
InvocationExpressionSyntax GenerateNameOfCall(SyntaxToken identifier) =>
ExpressionGenerationHelper.Invocation(
"nameof",
SyntaxHelpers.ArgumentFromIdentifier(identifier));
var tree = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
if (properties.Count == 0)
{
return(document);
}
var firstEl = Enumerable.Repeat(
(InterpolatedStringContentSyntax)SyntaxFactory.Interpolation(
GenerateNameOfCall(classDeclarationSyntax.Identifier)),
1);
var interpolatedStringExpression = InterpolatedStringGenerationHelper.InterpolatedString(
firstEl.Concat(
properties.SelectMany(p =>
new InterpolatedStringContentSyntax[]
{
InterpolatedStringGenerationHelper.Text($" "),
SyntaxFactory.Interpolation(GenerateNameOfCall(p.Identifier)),
InterpolatedStringGenerationHelper.Text($"="),
SyntaxFactory.Interpolation(SyntaxFactory.IdentifierName(p.Identifier.WithoutTrivia()))
})));
var methodExpression = MethodGenerationHelper.Builder(ToStringMethodName)
.Modifiers(Modifiers.Public, Modifiers.Override)
.ReturnType(Types.String)
.ArrowBody(ExpressionGenerationHelper.Arrow(interpolatedStringExpression))
.Build();
var previousToString = ClassDeclarationSyntaxAnalysis.GetMembers <MethodDeclarationSyntax>(
classDeclarationSyntax)
.FirstOrDefault(m => m.Identifier.ValueText.Equals(ToStringMethodName));
var newClassDeclaration =
previousToString != null?
classDeclarationSyntax.ReplaceNode(previousToString, methodExpression)
: classDeclarationSyntax.AddMembers(methodExpression);
var root = await tree.GetRootAsync(cancellationToken).ConfigureAwait(false);
var newRoot = root.ReplaceNode(classDeclarationSyntax, newClassDeclaration);
var newDocument = document.WithSyntaxRoot(newRoot);
return(newDocument);
}
private static TypeSyntax?TryParseType(JToken?value)
{
var typeString = value?.Value <string>();
if (typeString == null)
{
return(null);
}
return(new TypeSyntax(SyntaxHelpers.CreateToken(TokenType.Identifier, typeString.ToLowerInvariant())));
}
public AddAggressiveInliningRewriter(SemanticModel semanticModel, int position, AtCoderAnalyzerConfig config) : base(false)
{
this.semanticModel = semanticModel;
this.position = position;
methodImplAttribute = semanticModel.Compilation.GetTypeByMetadataName(
System_Runtime_CompilerServices_MethodImplAttribute);
methodImplOptions = semanticModel.Compilation.GetTypeByMetadataName(
System_Runtime_CompilerServices_MethodImplOptions);
aggressiveInliningAttribute = SyntaxHelpers.AggressiveInliningAttribute(
methodImplAttribute.ToMinimalDisplayString(semanticModel, position),
methodImplOptions.ToMinimalDisplayString(semanticModel, position), config.UseMethodImplNumeric);
}
public override async Task ProvideCompletionsAsync(CompletionContext context)
{
try
{
if (!context.Document.SupportsSemanticModel || !context.Document.SupportsSyntaxTree)
{
return;
}
var hasMoqReferenced = context.Document.Project.MetadataReferences.Any(r => r.Display.Contains(this._provider.AssemblyName));
if (!hasMoqReferenced)
{
return;
}
var syntaxRoot = await context.Document.GetSyntaxRootAsync();
var token = SyntaxHelpers.GetSelectedTokens(syntaxRoot, context.Position);
// Not in an opened method
if (token.Parent == null)
{
return;
}
var mockedMethodArgumentList = token.Parent as ArgumentListSyntax;
var setupMethodInvocation = mockedMethodArgumentList.Ancestors()
.OfType <InvocationExpressionSyntax>()
.Where(IsMoqSetupMethod)
.FirstOrDefault();
if (setupMethodInvocation == null)
{
return;
}
var semanticModel = await context.Document.GetSemanticModelAsync();
var matchingMockedMethods = SyntaxHelpers.GetCandidatesMockedMethodSignaturesForLambda(semanticModel, setupMethodInvocation);
var completionService = new CompletionService(context, token, semanticModel, this._provider);
foreach (IMethodSymbol matchingMockedMethodSymbol in matchingMockedMethods)
{
completionService.AddSuggestionsForMethod(matchingMockedMethodSymbol, mockedMethodArgumentList);
}
}
catch
{
}
}
public void TestGetTypeNameSyntax_OmitNamespaceIfImported(string expectedCode, Func <TypeMember> typeFactory)
{
//-- arrange
var type = typeFactory();
//-- act
var actualSyntax = SyntaxHelpers.GetTypeNameSyntax(type);
//-- assert
actualSyntax.Should().BeEqualToCode(expectedCode);
}
protected virtual IEnumerable <StatementSyntax> GenerateStatements(
ILocatedOpenApiElement <OpenApiOperation> operation)
{
ILocatedOpenApiElement <OpenApiResponses> responseSet = operation.GetResponseSet();
ILocatedOpenApiElement <OpenApiResponse> primaryResponse = responseSet
.GetResponses()
.OrderBy(p => p.Key)
.First();
ILocatedOpenApiElement <OpenApiMediaType>?mediaType = MediaTypeSelector.Select(primaryResponse);
if (mediaType != null)
{
yield return(ExpressionStatement(InvocationExpression(
SyntaxHelpers.MemberAccess(RequestMessageParameterName, "Headers", "Accept", "Add"))
.AddArgumentListArguments(
Argument(ObjectCreationExpression(WellKnownTypes.System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Name)
.AddArgumentListArguments(
Argument(SyntaxHelpers.StringLiteral(mediaType.Key)))))));
}
var propertyNameFormatter = NameFormatterSelector.GetFormatter(NameKind.Property);
foreach (var headerParameter in operation.Element.Parameters.Where(p => p.In == ParameterLocation.Header))
{
string propertyName = propertyNameFormatter.Format(headerParameter.Name);
StatementSyntax statement = ExpressionStatement(InvocationExpression(
SyntaxHelpers.MemberAccess(RequestMessageParameterName, "Headers", "Add"))
.AddArgumentListArguments(
Argument(SyntaxHelpers.StringLiteral(headerParameter.Name)),
Argument(InvocationExpression(MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
SerializationNamespace.HeaderSerializerInstance,
IdentifierName("Serialize")))
.AddArgumentListArguments(
Argument(IdentifierName(propertyName)),
Argument(headerParameter.Explode
? LiteralExpression(SyntaxKind.TrueLiteralExpression)
: LiteralExpression(SyntaxKind.FalseLiteralExpression))))));
if (!headerParameter.Required)
{
statement = MethodHelpers.IfNotNull(
IdentifierName(propertyName),
Block(statement));
}
yield return(statement);
}
}
protected virtual IEnumerable <StatementSyntax> GenerateStatements(
ILocatedOpenApiElement <OpenApiResponse> response, TypeSyntax returnType)
{
yield return(ReturnStatement(SyntaxHelpers.AwaitConfiguredFalse(
InvocationExpression(MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
SerializationNamespace.TypeSerializerRegistryExtensions,
GenericName("DeserializeAsync")
.AddTypeArgumentListArguments(returnType)))
.AddArgumentListArguments(
Argument(IdentifierName("TypeSerializerRegistry")),
Argument(MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
IdentifierName("Message"),
IdentifierName("Content")))))));
}
public PropertyDeclarationSyntax Enrich(PropertyDeclarationSyntax target,
OpenApiEnrichmentContext <OpenApiSchema> context)
{
if (target.Parent is ClassDeclarationSyntax classDeclaration &&
classDeclaration.GetGeneratorAnnotation() == typeof(RequestMediaTypeGenerator))
{
// Don't enrich body properties on the request classes
return(target);
}
return(target.AddAttributeLists(SyntaxFactory.AttributeList().AddAttributes(
SyntaxFactory.Attribute(SystemTextJsonTypes.Serialization.JsonPropertyNameAttributeName).AddArgumentListArguments(
SyntaxFactory.AttributeArgument(SyntaxHelpers.StringLiteral(context.LocatedElement.Key))))));
}
private async Task <Document> AddAggressiveInlining(
Document document, CompilationUnitSyntax root,
TypeDeclarationSyntax typeDeclarationSyntax, CancellationToken cancellationToken)
{
root = root.ReplaceNode(typeDeclarationSyntax,
new AddAggressiveInliningRewriter(await document.GetSemanticModelAsync(cancellationToken)).Visit(typeDeclarationSyntax));
if (!root.Usings.ToNamespaceHashSet().Contains(System_Runtime_CompilerServices))
{
root = SyntaxHelpers.AddSystem_Runtime_CompilerServicesSyntax(root);
}
return(document.WithSyntaxRoot(root));
}
protected virtual InterfaceDeclarationSyntax AddJsonConverter(InterfaceDeclarationSyntax target,
OpenApiEnrichmentContext <OpenApiSchema> context)
{
OpenApiSchema schema = context.Element;
var attribute = SyntaxFactory.Attribute(NewtonsoftJsonTypes.JsonConverterAttributeName).AddArgumentListArguments(
SyntaxFactory.AttributeArgument(
SyntaxFactory.TypeOfExpression(JsonSerializationNamespace.DiscriminatorConverter)),
SyntaxFactory.AttributeArgument(
SyntaxHelpers.StringLiteral(schema.Discriminator.PropertyName)),
SyntaxFactory.AttributeArgument(
SyntaxFactory.TypeOfExpression(Context.TypeGeneratorRegistry.Get(context.LocatedElement).TypeInfo.Name)));
if (schema.Discriminator.Mapping != null)
{
var paramArray = SyntaxFactory.ArrayCreationExpression(
SyntaxFactory
.ArrayType(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.ObjectKeyword)))
.WithRankSpecifiers(
SyntaxFactory.SingletonList(SyntaxFactory.ArrayRankSpecifier(
SyntaxFactory.SingletonSeparatedList <ExpressionSyntax>(
SyntaxFactory.OmittedArraySizeExpression())))))
.WithInitializer(SyntaxFactory.InitializerExpression(SyntaxKind.ArrayInitializerExpression,
SyntaxFactory.SeparatedList <ExpressionSyntax>(
schema.Discriminator.Mapping
.SelectMany(mapping =>
{
// Add two parameters to the object array for each mapping
// First is the string key of the mapping, second is the Type to deserialize
OpenApiSchema referencedSchema = schema.OneOf
.FirstOrDefault(p => p.Reference?.ReferenceV3 == mapping.Value);
return(referencedSchema != null
? new ExpressionSyntax[]
{
SyntaxHelpers.StringLiteral(mapping.Key), SyntaxFactory.TypeOfExpression(
Context.TypeGeneratorRegistry.Get(
referencedSchema.CreateRoot(referencedSchema.Reference.Id)).TypeInfo.Name)
}
: Enumerable.Empty <ExpressionSyntax>());
}))));
attribute = attribute.AddArgumentListArguments(SyntaxFactory.AttributeArgument(paramArray));
}
return(target.AddAttributeLists(SyntaxFactory.AttributeList().AddAttributes(attribute)));
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
private TypeMember BuildArtifactTypeFor(TypeMember productType)
{
var key = productType.Generator.TypeKey.Value;
var activationContract = productType.Generator.ActivationContract ?? typeof(object);
var artifactType = new TypeMember(
MemberVisibility.Public,
TypeMemberKind.Class,
SyntaxHelpers.GetValidCSharpIdentifier($"FactoryOf_{productType.FullName}"));
artifactType.BaseType = new TypeMember(typeof(RuntimeTypeFactoryArtifact <>).MakeGenericType(activationContract));
ImplementArtifactConstructor(productType, key, artifactType);
ImplementActivationInterfaces(productType, activationContract, artifactType);
return(artifactType);
}
public CompilationUnitSyntax Enrich(CompilationUnitSyntax target) =>
target.AddAttributeLists(
SyntaxFactory.AttributeList().AddAttributes(
SyntaxFactory.Attribute(SyntaxFactory.ParseName("System.Reflection.AssemblyVersion"))
.AddArgumentListArguments(SyntaxFactory.AttributeArgument(
SyntaxHelpers.StringLiteral(_settings.Version.ToString()))))
.WithTarget(SyntaxFactory.AttributeTargetSpecifier(SyntaxFactory.Token(SyntaxKind.AssemblyKeyword))),
SyntaxFactory.AttributeList().AddAttributes(
SyntaxFactory.Attribute(SyntaxFactory.ParseName("System.Reflection.AssemblyFileVersion"))
.AddArgumentListArguments(SyntaxFactory.AttributeArgument(
SyntaxHelpers.StringLiteral(_settings.Version.ToString()))))
.WithTarget(SyntaxFactory.AttributeTargetSpecifier(SyntaxFactory.Token(SyntaxKind.AssemblyKeyword))),
SyntaxFactory.AttributeList().AddAttributes(
SyntaxFactory.Attribute(SyntaxFactory.ParseName("System.Reflection.AssemblyInformationalVersion"))
.AddArgumentListArguments(SyntaxFactory.AttributeArgument(
SyntaxHelpers.StringLiteral(_settings.Version.ToString() + (_settings.VersionSuffix ?? "")))))
.WithTarget(SyntaxFactory.AttributeTargetSpecifier(SyntaxFactory.Token(SyntaxKind.AssemblyKeyword))));
protected virtual IEnumerable <StatementSyntax> GenerateStatements(
ILocatedOpenApiElement <OpenApiOperation> operation)
{
yield return(GenerateRequestMessageVariable(operation));
yield return(ExpressionStatement(AddHeadersMethodGenerator.InvokeAddHeaders(
ThisExpression(),
IdentifierName(RequestMessageVariableName))));
yield return(ExpressionStatement(AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
SyntaxHelpers.MemberAccess(RequestMessageVariableName, "Content"),
BuildContentMethodGenerator.InvokeBuildContent(
ThisExpression(),
IdentifierName(TypeSerializerRegistryParameterName)))));
yield return(ReturnStatement(IdentifierName(RequestMessageVariableName)));
}
protected override IEnumerable <MemberDeclarationSyntax> GenerateAdditionalMembers(string className)
{
yield return(ConstructorDeclaration(className)
.AddModifiers(Token(SyntaxKind.PublicKeyword))
.WithBody(Block()));
yield return(FieldDeclaration(VariableDeclaration(PredefinedType(Token(SyntaxKind.StringKeyword)))
.AddVariables(
VariableDeclarator(Identifier(UsernameFieldName), null,
EqualsValueClause(SyntaxHelpers.StringLiteral(""))),
VariableDeclarator(Identifier(PasswordFieldName), null,
EqualsValueClause(SyntaxHelpers.StringLiteral("")))))
.AddModifiers(Token(SyntaxKind.PublicKeyword)));
yield return(FieldDeclaration(VariableDeclaration(NullableType(PredefinedType(Token(SyntaxKind.StringKeyword))))
.AddVariables(
VariableDeclarator(Identifier(CacheFieldName))))
.AddModifiers(Token(SyntaxKind.PublicKeyword)));
yield return(PropertyDeclaration(PredefinedType(Token(SyntaxKind.StringKeyword)),
UsernamePropertyName)
.AddModifiers(Token(SyntaxKind.PublicKeyword))
.AddAccessorListAccessors(
AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
.WithExpressionBody(ArrowExpressionClause(IdentifierName(UsernameFieldName))),
AccessorDeclaration(SyntaxKind.SetAccessorDeclaration, Block(
ExpressionStatement(AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
IdentifierName(UsernameFieldName),
MethodHelpers.ArgumentOrThrowIfNull("value"))),
ExpressionStatement(AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
IdentifierName(CacheFieldName), LiteralExpression(SyntaxKind.NullLiteralExpression)))))));
yield return(PropertyDeclaration(PredefinedType(Token(SyntaxKind.StringKeyword)),
PasswordPropertyName)
.AddModifiers(Token(SyntaxKind.PublicKeyword))
.AddAccessorListAccessors(
AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
.WithExpressionBody(ArrowExpressionClause(IdentifierName(PasswordFieldName))),
AccessorDeclaration(SyntaxKind.SetAccessorDeclaration, Block(
ExpressionStatement(AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
IdentifierName(PasswordFieldName),
MethodHelpers.ArgumentOrThrowIfNull("value"))),
ExpressionStatement(AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
IdentifierName(CacheFieldName), LiteralExpression(SyntaxKind.NullLiteralExpression)))))));
}
protected virtual IEnumerable <StatementSyntax> GenerateStatements(
ILocatedOpenApiElement <OpenApiResponse> response, TypeSyntax returnType)
{
// Return from _body field if not null, otherwise deserialize and set the _body field
yield return(ReturnStatement(AssignmentExpression(SyntaxKind.CoalesceAssignmentExpression,
IdentifierName(ResponseTypeGenerator.BodyFieldName),
SyntaxHelpers.AwaitConfiguredFalse(
InvocationExpression(MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
SerializationNamespace.TypeSerializerRegistryExtensions,
GenericName("DeserializeAsync")
.AddTypeArgumentListArguments(returnType)))
.AddArgumentListArguments(
Argument(IdentifierName("TypeSerializerRegistry")),
Argument(MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
IdentifierName("Message"),
IdentifierName("Content"))))))));
}
protected virtual IEnumerable <StatementSyntax> GenerateStatements(
ILocatedOpenApiElement <OpenApiResponse> response)
{
var propertyNameFormatter = _context.NameFormatterSelector.GetFormatter(NameKind.Property);
// Declare values variable to hold TryGetValue out results
yield return(LocalDeclarationStatement(VariableDeclaration(
WellKnownTypes.System.Collections.Generic.IEnumerableT.Name(
PredefinedType(Token(SyntaxKind.StringKeyword))))
.AddVariables(VariableDeclarator("values"))));
NameSyntax valuesName = IdentifierName("values");
foreach (var header in response.GetHeaders())
{
ILocatedOpenApiElement <OpenApiSchema> schemaElement = header.GetSchemaOrDefault();
TypeSyntax typeName = _context.TypeNameProvider.GetName(schemaElement);
InvocationExpressionSyntax deserializeExpression =
InvocationExpression(MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
_serializationNamespace.HeaderSerializerInstance,
GenericName("Deserialize")
.AddTypeArgumentListArguments(typeName)))
.AddArgumentListArguments(
Argument(valuesName),
Argument(header.Element.Explode
? LiteralExpression(SyntaxKind.TrueLiteralExpression)
: LiteralExpression(SyntaxKind.FalseLiteralExpression)));
yield return(IfStatement(
WellKnownTypes.System.Net.Http.Headers.HttpHeaders.TryGetValues(
SyntaxHelpers.MemberAccess(IdentifierName("Message"),
"Headers"),
SyntaxHelpers.StringLiteral(header.Key),
valuesName),
Block(
ExpressionStatement(AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
IdentifierName(propertyNameFormatter.Format(header.Key)),
deserializeExpression)))));
}
}
protected virtual IEnumerable <StatementSyntax> GenerateStatements(ILocatedOpenApiElement <OpenApiOperation> operation)
{
yield return(MethodHelpers.ThrowIfArgumentNull(RequestParameterName));
yield return(GenerateAuthenticatorVariable());
yield return(GenerateRequestMessageVariable(operation));
yield return(MethodHelpers.IfNotNull(
IdentifierName(AuthenticatorVariableName),
Block(ExpressionStatement(SyntaxHelpers.AwaitConfiguredFalse(InvocationExpression(
MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
IdentifierName(AuthenticatorVariableName),
IdentifierName("ApplyAsync")))
.AddArgumentListArguments(
Argument(IdentifierName(RequestMessageVariableName)),
Argument(IdentifierName(MethodHelpers.CancellationTokenParameterName))))))));
yield return(LocalDeclarationStatement(VariableDeclaration(IdentifierName("var"))
.AddVariables(VariableDeclarator("responseMessage")
.WithInitializer(EqualsValueClause(
SyntaxHelpers.AwaitConfiguredFalse(InvocationExpression(
SyntaxHelpers.MemberAccess(TagTypeGenerator.HttpClientFieldName, "SendAsync"))
.AddArgumentListArguments(
Argument(IdentifierName(RequestMessageVariableName)),
Argument(IdentifierName(MethodHelpers.CancellationTokenParameterName)))))))));
yield return(MethodHelpers.IfNotNull(
IdentifierName(AuthenticatorVariableName),
Block(ExpressionStatement(SyntaxHelpers.AwaitConfiguredFalse(InvocationExpression(
MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
IdentifierName(AuthenticatorVariableName),
IdentifierName("ProcessResponseAsync")))
.AddArgumentListArguments(
Argument(IdentifierName("responseMessage")),
Argument(IdentifierName(MethodHelpers.CancellationTokenParameterName))))))));
yield return(ReturnStatement(GenerateResponse(operation, IdentifierName("responseMessage"))));
}
private IEnumerable <MemberDeclarationSyntax> GenerateNewNodes(PropertyDeclarationSyntax property)
{
TypeSyntax valueType = property.Type.DescendantNodes()
.OfType <GenericNameSyntax>()
.First()
.TypeArgumentList.Arguments[1];
bool isDynamic = SyntaxHelpers.IsDynamic(valueType, out bool isNullable);
TypeSyntax wrapperType = isDynamic
? isNullable
? _jsonSerializationNamespace.NullableDynamicAdditionalPropertiesDictionary
: _jsonSerializationNamespace.DynamicAdditionalPropertiesDictionary
: _jsonSerializationNamespace.AdditionalPropertiesDictionary(valueType);
yield return(_backingFieldDeclaration);
yield return(FieldDeclaration(VariableDeclaration(
NullableType(wrapperType),
SingletonSeparatedList(VariableDeclarator(Identifier(WrapperFieldName)))))
.AddModifiers(Token(SyntaxKind.PrivateKeyword)));
yield return(property
// Remove the getters and setters
.WithAccessorList(null)
// Remove the old initializer
.WithInitializer(null)
// Prevent serialization
.AddAttributeLists(AttributeList(SingletonSeparatedList(Attribute(NewtonsoftJsonTypes.JsonIgnoreAttributeName))))
// Provide an AdditionalPropertiesDictionary referencing the backing field
.WithExpressionBody(ArrowExpressionClause(
AssignmentExpression(SyntaxKind.CoalesceAssignmentExpression,
IdentifierName(WrapperFieldName),
ObjectCreationExpression(wrapperType)
.AddArgumentListArguments(
Argument(IdentifierName(BackingFieldName)))))));
}
public MoqIsAnyCompletion()
{
this._provider = new MoqProvider();
IsMoqSetupMethod = (InvocationExpressionSyntax invocation) => this._provider.MockingMethodNames.Any(methodName => SyntaxHelpers.IsMethodNamed(invocation, methodName));
}
public PropertyDeclarationSyntax Enrich(PropertyDeclarationSyntax target,
OpenApiEnrichmentContext <OpenApiSchema> context) =>
target
.AddAttributeLists(SyntaxFactory.AttributeList().AddAttributes(
SyntaxFactory.Attribute(NewtonsoftJsonTypes.JsonPropertyAttributeName).AddArgumentListArguments(
SyntaxFactory.AttributeArgument(SyntaxHelpers.StringLiteral(context.LocatedElement.Key)))));
