private static void UpdateInvocationLocation(
SyntaxNodeAnalysisContext context,
ISymbol symbol,
SimpleNameSyntax currentAccessNode,
GetAccessInfoDelegate getAccessInfo)
{
var symbolInfo = _applicationBuilderSymbolInfos.GetOrCreateValue(symbol);
var scopeEnclosingNode =
currentAccessNode.FirstAncestorOrSelf <CSharpSyntaxNode>(IsScopeEnclosingNode);
lock (symbolInfo)
{
if (!symbolInfo.Scopes.TryGetValue(scopeEnclosingNode, out var scopeInfo))
{
symbolInfo.Scopes[scopeEnclosingNode] = scopeInfo = new ScopeInfo();
}
if (scopeInfo.DiagnosticReported)
{
return;
}
ref var existingAccessInfo = ref getAccessInfo(scopeInfo);
if (existingAccessInfo.location == null ||
currentAccessNode.GetLocation().SourceSpan.Start < existingAccessInfo.location.SourceSpan.Start)
{
existingAccessInfo = (currentAccessNode.GetLocation(), currentAccessNode.ToString());
VerifyInvocationOrder(context, scopeInfo);
}
}
public override IEnumerable <MemberDeclarationSyntax> Generate()
{
if (!HasDiscriminator)
{
// We have no discriminator, so we're just going to implement using dynamic expando objects
// So we shouldn't implement a specific class
yield break;
}
var interfaceNameAndNamespace = (QualifiedNameSyntax)GetTypeName();
// Register the referenced schema to implement this interface
var baseTypeRegistry = Context.GenerationServices.GetRequiredService <ISchemaBaseTypeRegistry>();
foreach (var referencedSchema in Schema.OneOf
.Where(p => p.Reference != null)
.Select(p => ((OpenApiSchema)Context.Document.ResolveReference(p.Reference)).CreateRoot(p.Reference.Id)))
{
baseTypeRegistry.AddBaseType(referencedSchema, SyntaxFactory.SimpleBaseType(interfaceNameAndNamespace));
}
SimpleNameSyntax interfaceName = interfaceNameAndNamespace.Right;
yield return(SyntaxFactory.InterfaceDeclaration(interfaceName.ToString())
.AddElementAnnotation(Element, Context.ElementRegistry)
.AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword)));
}
private void RegisterCodeFixVariant(CodeFixContext context, CodeFixHelper codeFixHelper, SimpleNameSyntax oldMethodName, SimpleNameSyntax newMethodName)
{
context.RegisterCodeFix(
CodeAction.Create(
title: CodeFixMessagesProvider.GetReplaceWithMessage(newMethodName),
createChangedDocument: c => codeFixHelper.ReplaceExpressionWith(oldMethodName, newMethodName, c),
equivalenceKey: newMethodName.ToString()),
codeFixHelper.GetFirstDiagnostic());
}
protected override IEnumerable <Diagnostic> Analyze(SyntaxNodeAnalysisContext context, InvocationExpressionSyntax invocationExpressionSyntax, MemberAccessExpressionSyntax memberAccessExpression)
{
string memberName = memberAccessExpression.Name switch
{
GenericNameSyntax generic => generic.Identifier.ToString(),
SimpleNameSyntax name => name.ToString()
};
if ((memberName != @"AreEqual") && (memberName != @"AreNotEqual"))
{
return(null);
}
IMethodSymbol memberSymbol = context.SemanticModel.GetSymbolInfo(memberAccessExpression).Symbol as IMethodSymbol;
if ((memberSymbol == null) || !memberSymbol.ToString().StartsWith("Microsoft.VisualStudio.TestTools.UnitTesting.Assert"))
{
return(null);
}
// Assert.AreEqual is incorrectly used if the literal is the second argument (including null) or if the first argument is null
ArgumentListSyntax argumentList = invocationExpressionSyntax.ArgumentList;
bool arg0Literal = IsLiteral(argumentList.Arguments[0].Expression, context.SemanticModel);
bool arg1Literal = IsLiteral(argumentList.Arguments[1].Expression, context.SemanticModel);
if (!arg0Literal && !arg1Literal)
{
return(null);
}
if (arg0Literal)
{
return(null);
}
if (arg1Literal)
{
Diagnostic diagnostic = Diagnostic.Create(Rule, invocationExpressionSyntax.GetLocation());
return(new[] { diagnostic });
}
return(null);
}
private InvocationExpressionSyntax ConvertToInvocation(SimpleNameSyntax calledMethod, ExpressionSyntax literalExpected, ExpressionSyntax actual, ExpressionSyntax message)
{
bool isLiteralTrue = GetMethod(literalExpected);
if (calledMethod.ToString() == @"AreNotEqual")
{
isLiteralTrue = !isLiteralTrue;
}
string method = isLiteralTrue ? "IsTrue" : "IsFalse";
ArgumentListSyntax argumentListSyntax = SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(new[] { SyntaxFactory.Argument(actual) }));
if (message != null)
{
argumentListSyntax = argumentListSyntax.AddArguments(SyntaxFactory.Argument(message));
}
return(SyntaxFactory.InvocationExpression(SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.ParseTypeName("Assert"), SyntaxFactory.Token(SyntaxKind.DotToken), (SimpleNameSyntax)SyntaxFactory.ParseName(method)), argumentListSyntax));
}
public override IEnumerable <MemberDeclarationSyntax> Generate()
{
var interfaceNameAndNamespace = (QualifiedNameSyntax)TypeInfo.Name;
// Register the referenced schema to implement this interface
var baseTypeRegistry = Context.GenerationServices.GetRequiredService <ISchemaBaseTypeRegistry>();
foreach (var referencedSchema in Schema.OneOf
.Where(p => p.Reference != null)
.Select(p => ((OpenApiSchema)Context.Document.ResolveReference(p.Reference)).CreateRoot(p.Reference.Id)))
{
baseTypeRegistry.AddBaseType(referencedSchema, SyntaxFactory.SimpleBaseType(interfaceNameAndNamespace));
}
SimpleNameSyntax interfaceName = interfaceNameAndNamespace.Right;
yield return(SyntaxFactory.InterfaceDeclaration(interfaceName.ToString())
.AddElementAnnotation(Element, Context.ElementRegistry)
.AddGeneratorAnnotation(this)
.AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword)));
}