static bool TryGetDiagnostic(MemberAccessExpressionSyntax memberAccessSyntax, ITypeSymbol containingType, SyntaxNode extensionParameter, out Diagnostic diagnostic)
{
diagnostic = default(Diagnostic);
if (memberAccessSyntax.IsKind(SyntaxKind.ThisKeyword) || memberAccessSyntax.IsKind(SyntaxKind.BaseExpression))
{
return(false);
}
var rightMostName = memberAccessSyntax.Expression.GetRightmostName();
if (rightMostName == null || rightMostName == extensionParameter)
{
return(false);
}
var rightMostType = rightMostName.Identifier.Text;
if (rightMostType == containingType.Name)
{
return(false);
}
if (CheckCuriouslyRecurringTemplatePattern(containingType, rightMostType))
{
return(false);
}
diagnostic = Diagnostic.Create(
descriptor,
memberAccessSyntax.GetLocation()
);
return(true);
}
/// <inheritdoc/>
public override SyntaxNode VisitMemberAccessExpression(MemberAccessExpressionSyntax node)
{
var updatedNode = (MemberAccessExpressionSyntax)base.VisitMemberAccessExpression(node) !;
if (node.IsKind(SyntaxKind.SimpleMemberAccessExpression) &&
SemanticModel.For(node).GetOperation(node) is IMemberReferenceOperation operation)
{
// Track and replace constants
if (operation is IFieldReferenceOperation fieldOperation &&
fieldOperation.Field.IsConst &&
fieldOperation.Type !.TypeKind != TypeKind.Enum)
{
if (HlslKnownFields.TryGetMappedName(fieldOperation.Member.ToDisplayString(), out string?constantLiteral))
{
return(ParseExpression(constantLiteral !));
}
ConstantDefinitions[fieldOperation.Field] = ((IFormattable)fieldOperation.Field.ConstantValue !).ToString(null, CultureInfo.InvariantCulture);
var ownerTypeName = ((INamedTypeSymbol)fieldOperation.Field.ContainingSymbol).ToDisplayString().ToHlslIdentifierName();
var constantName = $"__{ownerTypeName}__{fieldOperation.Field.Name}";
return(IdentifierName(constantName));
}
if (HlslKnownProperties.TryGetMappedName(operation.Member.ToDisplayString(), out string?mapping))
{
// Rewrite static and instance mapped members
return(operation.Member.IsStatic switch
{
true => ParseExpression(mapping !),
false => updatedNode.WithName(IdentifierName(mapping !))
});
private static bool IsRelayReturn(MemberAccessExpressionSyntax memberAccess, SemanticModel semanticModel, CancellationToken cancellationToken)
{
if (memberAccess == null ||
!memberAccess.IsKind(SyntaxKind.SimpleMemberAccessExpression) ||
memberAccess.Expression is InstanceExpressionSyntax ||
memberAccess.Expression == null)
{
return(false);
}
if (semanticModel.TryGetSymbol(memberAccess.Expression, cancellationToken, out ISymbol member) &&
FieldOrProperty.TryCreate(member, out FieldOrProperty fieldOrProperty) &&
memberAccess.TryFirstAncestor <TypeDeclarationSyntax>(out var typeDeclaration) &&
!IsInjected(fieldOrProperty, typeDeclaration, semanticModel, cancellationToken))
{
return(false);
}
if (memberAccess.Expression is IdentifierNameSyntax &&
memberAccess.Name is IdentifierNameSyntax)
{
return(true);
}
if (memberAccess.Expression is MemberAccessExpressionSyntax &&
memberAccess.Name is IdentifierNameSyntax)
{
return(true);
}
return(false);
}
private static bool IsCalleePotentiallyCreatedInScope(MemberAccessExpressionSyntax memberAccess, SemanticModel semanticModel, CancellationToken cancellationToken)
{
if (memberAccess == null ||
!memberAccess.IsKind(SyntaxKind.SimpleMemberAccessExpression) ||
memberAccess.Expression.IsKind(SyntaxKind.ThisExpression))
{
return(false);
}
if (memberAccess.Expression is IdentifierNameSyntax callee)
{
var symbol = semanticModel.GetSymbolSafe(callee, cancellationToken);
if (symbol.Kind != SymbolKind.Local)
{
return(false);
}
if (!symbol.DeclaringSyntaxReferences.TrySingle(out var reference))
{
return(false);
}
return(reference.GetSyntax(cancellationToken) is VariableDeclaratorSyntax variableDeclarator &&
variableDeclarator.Initializer is EqualsValueClauseSyntax initializer &&
initializer.Value is ObjectCreationExpressionSyntax);
}
return(false);
}
public static async Task ComputeRefactoringsAsync(RefactoringContext context, MemberAccessExpressionSyntax memberAccess)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ReplaceCountWithLengthOrLengthWithCount) &&
memberAccess.IsKind(SyntaxKind.SimpleMemberAccessExpression))
{
memberAccess = GetTopmostMemberAccessExpression(memberAccess);
if (memberAccess.Name?.Span.Contains(context.Span) == true)
{
string name = memberAccess.Name.Identifier.ValueText;
if (string.Equals(name, "Count", StringComparison.Ordinal))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
if (CanRefactor(memberAccess, "Length", semanticModel, context.CancellationToken))
{
RegisterRefactoring(context, memberAccess, "Count", "Length");
}
}
else if (string.Equals(name, "Length", StringComparison.Ordinal))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
if (CanRefactor(memberAccess, "Count", semanticModel, context.CancellationToken))
{
RegisterRefactoring(context, memberAccess, "Length", "Count");
}
}
}
}
}
public static void FormatExpressionChain(CodeRefactoringContext context, MemberAccessExpressionSyntax memberAccessExpression)
{
if (!memberAccessExpression.IsKind(SyntaxKind.SimpleMemberAccessExpression))
{
return;
}
MemberAccessExpressionSyntax[] expressions = GetChain(memberAccessExpression).ToArray();
if (expressions.Length <= 1)
{
return;
}
if (expressions[0].IsSingleline(includeExteriorTrivia: false))
{
context.RegisterRefactoring(
"Format expression chain on multiple lines",
cancellationToken => FormatExpressionChainOnMultipleLinesAsync(context.Document, expressions[0], cancellationToken));
}
else
{
context.RegisterRefactoring(
"Format expression chain on a single line",
cancellationToken => FormatExpressionChainOnSingleLineAsync(context.Document, expressions[0], cancellationToken));
}
}
private static bool IsRelayReturn(MemberAccessExpressionSyntax memberAccess, SemanticModel semanticModel, CancellationToken cancellationToken)
{
if (memberAccess == null ||
!memberAccess.IsKind(SyntaxKind.SimpleMemberAccessExpression) ||
memberAccess.Expression is InstanceExpressionSyntax ||
memberAccess.Expression == null)
{
return(false);
}
var member = semanticModel.GetSymbolSafe(memberAccess.Expression, cancellationToken);
if (member == null ||
!IsInjected(member, semanticModel, cancellationToken))
{
return(false);
}
if (memberAccess.Expression is IdentifierNameSyntax &&
memberAccess.Name is IdentifierNameSyntax)
{
return(true);
}
if (memberAccess.Expression is MemberAccessExpressionSyntax &&
memberAccess.Name is IdentifierNameSyntax)
{
return(true);
}
return(false);
}
private static bool IsCalleePotentiallyCreatedInScope(MemberAccessExpressionSyntax memberAccess, SemanticModel semanticModel, CancellationToken cancellationToken)
{
if (memberAccess == null ||
!memberAccess.IsKind(SyntaxKind.SimpleMemberAccessExpression) ||
memberAccess.Expression.IsKind(SyntaxKind.ThisExpression))
{
return(false);
}
if (memberAccess.Expression is IdentifierNameSyntax callee &&
semanticModel.TryGetSymbol(callee, cancellationToken, out var symbol))
{
if (symbol.Kind != SymbolKind.Local)
{
return(false);
}
if (symbol.TrySingleDeclaration(cancellationToken, out VariableDeclaratorSyntax? declaration))
{
return(declaration.Initializer is { } initializer&&
initializer.Value is ObjectCreationExpressionSyntax);
}
}
return(false);
}
public override void VisitMemberAccessExpression(MemberAccessExpressionSyntax node)
{
if (node.IsKind(SyntaxKind.SimpleMemberAccessExpression))
{
this.simpleMemberAccesses.Add(node);
}
base.VisitMemberAccessExpression(node);
}
public override void VisitMemberAccessExpression(MemberAccessExpressionSyntax node)
{
if (node.IsKind(SyntaxKind.SimpleMemberAccessExpression) && TrySimplify(node))
{
// found a match. report it and stop processing.
return;
}
// descend further.
DefaultVisit(node);
}
/// <inheritdoc/>
public override SyntaxNode VisitMemberAccessExpression(MemberAccessExpressionSyntax node)
{
var updatedNode = (MemberAccessExpressionSyntax)base.VisitMemberAccessExpression(node) !;
if (node.IsKind(SyntaxKind.SimpleMemberAccessExpression) &&
SemanticModel.For(node).GetOperation(node) is IMemberReferenceOperation operation)
{
// Track and replace constants
if (operation is IFieldReferenceOperation fieldOperation &&
fieldOperation.Field.IsConst &&
fieldOperation.Type !.TypeKind != TypeKind.Enum)
{
if (HlslKnownFields.TryGetMappedName(fieldOperation.Member.ToDisplayString(), out string?constantLiteral))
{
return(ParseExpression(constantLiteral !));
}
ConstantDefinitions[fieldOperation.Field] = ((IFormattable)fieldOperation.Field.ConstantValue !).ToString(null, CultureInfo.InvariantCulture);
var ownerTypeName = ((INamedTypeSymbol)fieldOperation.Field.ContainingSymbol).ToDisplayString().ToHlslIdentifierName();
var constantName = $"__{ownerTypeName}__{fieldOperation.Field.Name}";
return(IdentifierName(constantName));
}
if (HlslKnownProperties.TryGetMappedName(operation.Member.ToDisplayString(), out string?mapping))
{
if (operation.Member.IsStatic)
{
string typeName = operation.Member.ContainingType.GetFullMetadataName();
// Special dispatch types are not supported from static constants
DiagnosticDescriptor?descriptor = typeName switch
{
_ when typeName == typeof(ThreadIds).FullName || typeName == typeof(ThreadIds.Normalized).FullName => InvalidThreadIdsUsage,
_ when typeName == typeof(GroupIds).FullName => InvalidGroupIdsUsage,
_ when typeName == typeof(GroupSize).FullName => InvalidGroupSizeUsage,
_ when typeName == typeof(GridIds).FullName => InvalidGridIdsUsage,
_ when typeName == typeof(DispatchSize).FullName => InvalidDispatchSizeUsage,
_ => null
};
if (descriptor is not null)
{
Diagnostics.Add(descriptor, node);
}
}
// Rewrite static and instance mapped members
return(operation.Member.IsStatic switch
{
true => ParseExpression(mapping !),
false => updatedNode.WithName(IdentifierName(mapping !))
});
public override SyntaxNode VisitMemberAccessExpression(MemberAccessExpressionSyntax node)
{
node = (MemberAccessExpressionSyntax)base.VisitMemberAccessExpression(node);
if (node.IsKind(SyntaxKind.SimpleMemberAccessExpression) &&
string.Equals((node.Expression as IdentifierNameSyntax)?.Identifier.ValueText, _name, StringComparison.Ordinal) &&
string.Equals((node.Name as IdentifierNameSyntax)?.Identifier.ValueText, "Current", StringComparison.Ordinal) &&
SymbolEqualityComparer.Default.Equals(_symbol, _semanticModel.GetSymbol(node.Expression, _cancellationToken)))
{
return(_newName.WithTriviaFrom(node));
}
return(node);
}
public override SyntaxNode VisitMemberAccessExpression(MemberAccessExpressionSyntax node)
{
if (!Options.FullyQualifiedNames &&
node.IsKind(SyntaxKind.SimpleMemberAccessExpression))
{
ISymbol symbol = SemanticModel.GetSymbol(node, CancellationToken);
if (symbol?.Kind == SymbolKind.Field &&
symbol.ContainingType?.TypeKind == TypeKind.Enum)
{
return(node.WithAdditionalAnnotations(_simplifierAnnotationAsArray));
}
}
return(base.VisitMemberAccessExpression(node));
}
public override void VisitMemberAccessExpression(MemberAccessExpressionSyntax node)
{
if (node.IsKind(SyntaxKind.SimpleMemberAccessExpression))
{
var baseInfo = model.GetSymbolInfo(node.Expression);
if (baseInfo.Symbol == info.Symbol)
{
var name = node.Name.ToString();
if (!conflictNames.ContainsKey(name) || conflictNames[name] <= 0)
{
ReplaceNodes.Add(node);
}
}
}
base.VisitMemberAccessExpression(node);
}
public static async Task ComputeRefactoringsAsync(RefactoringContext context, MemberAccessExpressionSyntax memberAccessExpression)
{
if (!context.Span.IsEmpty)
{
return;
}
if (!memberAccessExpression.Span.Contains(context.Span))
{
return;
}
if (!memberAccessExpression.IsKind(SyntaxKind.SimpleMemberAccessExpression))
{
return;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
List <MemberAccessExpressionSyntax> expressions = GetChain(memberAccessExpression, semanticModel, context.CancellationToken);
if (expressions == null)
{
return;
}
if (expressions.Count <= 1)
{
return;
}
if (expressions[0].IsSingleLine(includeExteriorTrivia: false))
{
context.RegisterRefactoring(
"Format expression chain on multiple lines",
ct => SyntaxFormatter.ToMultiLineAsync(context.Document, expressions.ToArray(), ct),
RefactoringIdentifiers.FormatExpressionChain);
}
else if (expressions[0].DescendantTrivia(expressions[0].Span).All(f => f.IsWhitespaceOrEndOfLineTrivia()))
{
context.RegisterRefactoring(
"Format expression chain on a single line",
ct => SyntaxFormatter.ToSingleLineAsync(context.Document, expressions[0], ct),
RefactoringIdentifiers.FormatExpressionChain);
}
}
public override SyntaxNode VisitMemberAccessExpression(MemberAccessExpressionSyntax node)
{
if (node.IsKind(SyntaxKind.SimpleMemberAccessExpression) &&
node.Expression is IdentifierNameSyntax identifierName &&
identifierName.Identifier.ValueText == IdentifierSymbol.Name &&
SymbolEqualityComparer.Default.Equals(SemanticModel.GetSymbol(identifierName, CancellationToken), IdentifierSymbol))
{
string name = node.Name.Identifier.ValueText;
if (!Names.TryGetValue(name, out string newName))
{
newName = StringUtility.FirstCharToLower(name);
}
return(IdentifierName(newName).WithTriviaFrom(identifierName));
}
return(base.VisitMemberAccessExpression(node));
}
public override SyntaxNode VisitMemberAccessExpression(MemberAccessExpressionSyntax node)
{
SyntaxNode r_node = node;
if (node.IsKind(SyntaxKind.SimpleMemberAccessExpression) && node.ToString() == "ById.OnLeft")
{
var p = node.HasParent<ArgumentSyntax, ArgumentListSyntax, InvocationExpressionSyntax, EqualsValueClauseSyntax, VariableDeclaratorSyntax>();
if (p == null)
{
}
else
{
var byId = SyntaxFactory.ParseExpression("\"#" + p.Identifier.Text + "\"");
//var argById = SyntaxFactory.Argument(byId);
r_node = byId;
}
}
return r_node;
}
private static bool IsCalleePotentiallyCreatedInScope(MemberAccessExpressionSyntax memberAccess, SemanticModel semanticModel, CancellationToken cancellationToken)
{
if (memberAccess == null ||
!memberAccess.IsKind(SyntaxKind.SimpleMemberAccessExpression) ||
memberAccess.Expression.IsKind(SyntaxKind.ThisExpression))
{
return(false);
}
var callee = memberAccess.Expression as IdentifierNameSyntax;
if (callee == null)
{
return(false);
}
var symbol = semanticModel.GetSymbolInfo(callee, cancellationToken).Symbol;
if (symbol.Kind != SymbolKind.Local)
{
return(false);
}
SyntaxReference reference;
if (!symbol.DeclaringSyntaxReferences.TryGetSingle(out reference))
{
return(false);
}
var declarator = reference.GetSyntax(cancellationToken) as VariableDeclaratorSyntax;
var objectCreation = declarator?.Initializer?.Value as ObjectCreationExpressionSyntax;
if (objectCreation == null)
{
return(false);
}
return(true);
}
public static async Task ComputeRefactoringsAsync(RefactoringContext context, MemberAccessExpressionSyntax memberAccessExpression)
{
if (context.Span.IsEmpty &&
memberAccessExpression.Span.Contains(context.Span) &&
memberAccessExpression.IsKind(SyntaxKind.SimpleMemberAccessExpression))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
List <MemberAccessExpressionSyntax> expressions = GetChain(memberAccessExpression, semanticModel, context.CancellationToken);
if (expressions.Count > 1)
{
if (expressions[0].IsSingleLine(includeExteriorTrivia: false))
{
context.RegisterRefactoring(
"Format expression chain on multiple lines",
cancellationToken =>
{
return(CSharpFormatter.ToMultiLineAsync(
context.Document,
expressions.ToArray(),
cancellationToken));
});
}
else
{
context.RegisterRefactoring(
"Format expression chain on a single line",
cancellationToken =>
{
return(CSharpFormatter.ToSingleLineAsync(
context.Document,
expressions[0],
cancellationToken));
});
}
}
}
}
public override void VisitMemberAccessExpression(MemberAccessExpressionSyntax node)
{
if (node.IsKind(SyntaxKind.SimpleMemberAccessExpression))
{
var baseInfo = model.GetSymbolInfo(node.Expression);
if (baseInfo.Symbol == info.Symbol)
{
var name = node.Name.ToString();
if (!conflictNames.ContainsKey(name) || conflictNames[name] <= 0)
ReplaceNodes.Add(node);
}
}
base.VisitMemberAccessExpression(node);
}
/// <summary> /// https://github.com/icsharpcode/CodeConverter/issues/765 Roslyn turns dataReader["foo"] into dataReader.Item /// </summary> private static bool IsRoslynElementAccessBug(MemberAccessExpressionSyntax maes) => maes.IsKind(SyntaxKind.DictionaryAccessExpression);
