public static FieldDeclarationSyntax DeclareField(Type fieldType, string name,
AccessibilityFlags accessibility = AccessibilityFlags.Default, EqualsValueClauseSyntax defaultValue = null)
{
var typeSyntax = fieldType.ToTypeSyntax();
return(DeclareField(typeSyntax, name, accessibility, defaultValue));
}
public static FieldDeclarationSyntax DeclareField(Type fieldType, string name,
AccessibilityFlags accessibility = AccessibilityFlags.Default)
{
var typeSyntax = fieldType.ToTypeSyntax();
return(DeclareField(typeSyntax, name, accessibility));
}
public static IEnumerable <SyntaxToken> AccessibilityToSyntaxToken(AccessibilityFlags accessibility)
{
var modifiers = new List <SyntaxToken>();
if (accessibility.HasFlag(AccessibilityFlags.Public))
{
modifiers.Add(SyntaxFactory.Token(SyntaxKind.PublicKeyword));
}
else if (accessibility.HasFlag(AccessibilityFlags.Protected))
{
modifiers.Add(SyntaxFactory.Token(SyntaxKind.ProtectedKeyword));
}
else if (accessibility.HasFlag(AccessibilityFlags.Private))
{
modifiers.Add(SyntaxFactory.Token(SyntaxKind.PrivateKeyword));
}
if (accessibility.HasFlag(AccessibilityFlags.Override))
{
modifiers.Add(SyntaxFactory.Token(SyntaxKind.OverrideKeyword));
}
else if (accessibility.HasFlag(AccessibilityFlags.Static))
{
modifiers.Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword));
}
return(modifiers);
}
public static MethodDeclarationSyntax DeclareMethod(string name, AccessibilityFlags accessibility,
Type returnValueType)
{
return(SyntaxFactory.MethodDeclaration(
TypeSystem.BuildTypeSyntax(returnValueType),
SyntaxFactory.Identifier(name))
.WithModifiers(SyntaxFactory.TokenList(AccessibilityToSyntaxToken(accessibility).ToArray())));
}
public static FieldDeclarationSyntax DeclareField(Type fieldType, string name,
AccessibilityFlags accessibility = AccessibilityFlags.Default)
{
VariableDeclarationSyntax varDeclaration = SyntaxFactory.VariableDeclaration(fieldType.ToTypeSyntax());
VariableDeclaratorSyntax varDeclarator = SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(name));
if (fieldType.IsVsArrayType())
{
ObjectCreationExpressionSyntax exp = SyntaxFactory.ObjectCreationExpression(fieldType.ToTypeSyntax())
.WithArgumentList(SyntaxFactory.ArgumentList());
varDeclarator = varDeclarator.WithInitializer(SyntaxFactory.EqualsValueClause(exp));
}
FieldDeclarationSyntax fieldDeclaration = SyntaxFactory.FieldDeclaration(
varDeclaration.WithVariables(SyntaxFactory.SingletonSeparatedList(varDeclarator)))
.WithModifiers(SyntaxFactory.TokenList(AccessibilityToSyntaxToken(accessibility).ToArray()));
return(fieldDeclaration);
}
void DeclareAndInitField(Type t, string name, AccessibilityFlags accessibility = AccessibilityFlags.Private,
ExpressionSyntax initValue = null)
{
var entityGroup = RoslynBuilder
.DeclareField(t, name)
.WithModifiers(TokenList(RoslynBuilder.AccessibilityToSyntaxToken(accessibility)));
AddMember(entityGroup);
if (initValue == null)
{
return;
}
StatementSyntax init = ExpressionStatement(
AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
IdentifierName(name),
initValue))
.NormalizeWhitespace();
InitializationStatements.Add(init);
}
public static FieldDeclarationSyntax DeclareField(TypeSyntax typeSyntax, string name, AccessibilityFlags accessibility, EqualsValueClauseSyntax defaultValue = null)
{
VariableDeclarationSyntax varDeclaration = SyntaxFactory.VariableDeclaration(typeSyntax);
var varDeclarator = SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(name));
if (defaultValue != null)
{
varDeclarator = varDeclarator.WithInitializer(defaultValue);
}
FieldDeclarationSyntax fieldDeclaration = SyntaxFactory.FieldDeclaration(
varDeclaration.WithVariables(SyntaxFactory.SingletonSeparatedList(varDeclarator)))
.WithModifiers(SyntaxFactory.TokenList(AccessibilityToSyntaxToken(accessibility).ToArray()));
return(fieldDeclaration);
}
public static void ComputeRefactoring(RefactoringContext context, MemberDeclarationSelection selectedMembers)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ChangeAccessibility))
{
AccessibilityFlags accessibilityFlags = ChangeAccessibilityRefactoring.GetAllowedAccessibilityFlags(selectedMembers, allowOverride: true);
if (accessibilityFlags != AccessibilityFlags.None)
{
bool canHaveMultipleDeclarations = CanHaveMultipleDeclarations();
TryRegisterRefactoring(accessibilityFlags, Accessibility.Public, canHaveMultipleDeclarations);
TryRegisterRefactoring(accessibilityFlags, Accessibility.Internal, canHaveMultipleDeclarations);
TryRegisterRefactoring(accessibilityFlags, Accessibility.Protected, canHaveMultipleDeclarations);
TryRegisterRefactoring(accessibilityFlags, Accessibility.Private, canHaveMultipleDeclarations);
}
}
void TryRegisterRefactoring(AccessibilityFlags accessibilityFlags, Accessibility accessibility, bool canHaveMultipleDeclarations)
{
if ((accessibilityFlags & accessibility.GetAccessibilityFlag()) != 0)
{
if (canHaveMultipleDeclarations)
{
context.RegisterRefactoring(
ChangeAccessibilityRefactoring.GetTitle(accessibility),
async cancellationToken =>
{
SemanticModel semanticModel = await context.Document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
return(await ChangeAccessibilityRefactoring.RefactorAsync(context.Document.Solution(), selectedMembers, accessibility, semanticModel, cancellationToken).ConfigureAwait(false));
});
}
else
{
context.RegisterRefactoring(
ChangeAccessibilityRefactoring.GetTitle(accessibility),
cancellationToken => ChangeAccessibilityRefactoring.RefactorAsync(context.Document, selectedMembers, accessibility, cancellationToken));
}
}
}
bool CanHaveMultipleDeclarations()
{
foreach (MemberDeclarationSyntax member in selectedMembers)
{
switch (member.Kind())
{
case SyntaxKind.ClassDeclaration:
{
if (((ClassDeclarationSyntax)member).Modifiers.Contains(SyntaxKind.PartialKeyword))
{
return(true);
}
break;
}
case SyntaxKind.InterfaceDeclaration:
{
if (((InterfaceDeclarationSyntax)member).Modifiers.Contains(SyntaxKind.PartialKeyword))
{
return(true);
}
break;
}
case SyntaxKind.StructDeclaration:
{
if (((StructDeclarationSyntax)member).Modifiers.Contains(SyntaxKind.PartialKeyword))
{
return(true);
}
break;
}
case SyntaxKind.MethodDeclaration:
{
if (((MethodDeclarationSyntax)member).Modifiers.ContainsAny(SyntaxKind.PartialKeyword, SyntaxKind.AbstractKeyword, SyntaxKind.VirtualKeyword, SyntaxKind.OverrideKeyword))
{
return(true);
}
break;
}
case SyntaxKind.PropertyDeclaration:
{
if (((PropertyDeclarationSyntax)member).Modifiers.ContainsAny(SyntaxKind.AbstractKeyword, SyntaxKind.VirtualKeyword, SyntaxKind.OverrideKeyword))
{
return(true);
}
break;
}
case SyntaxKind.IndexerDeclaration:
{
if (((IndexerDeclarationSyntax)member).Modifiers.ContainsAny(SyntaxKind.AbstractKeyword, SyntaxKind.VirtualKeyword, SyntaxKind.OverrideKeyword))
{
return(true);
}
break;
}
case SyntaxKind.EventDeclaration:
{
if (((EventDeclarationSyntax)member).Modifiers.ContainsAny(SyntaxKind.AbstractKeyword, SyntaxKind.VirtualKeyword, SyntaxKind.OverrideKeyword))
{
return(true);
}
break;
}
case SyntaxKind.EventFieldDeclaration:
{
if (((EventFieldDeclarationSyntax)member).Modifiers.ContainsAny(SyntaxKind.AbstractKeyword, SyntaxKind.VirtualKeyword, SyntaxKind.OverrideKeyword))
{
return(true);
}
break;
}
}
}
return(false);
}
}
public static AccessibilityFlags GetAllowedAccessibilityFlags(MemberDeclarationSelection selectedMembers, bool allowOverride = false)
{
if (selectedMembers.Count < 2)
{
return(AccessibilityFlags.None);
}
var allFlags = AccessibilityFlags.None;
AccessibilityFlags allowedFlags = AccessibilityFlags.Public
| AccessibilityFlags.Internal
| AccessibilityFlags.Protected
| AccessibilityFlags.Private;
foreach (MemberDeclarationSyntax member in selectedMembers)
{
Accessibility accessibility = SyntaxInfo.AccessibilityInfo(member).Accessibility;
if (accessibility == Accessibility.NotApplicable)
{
accessibility = member.GetDefaultExplicitAccessibility();
if (accessibility == Accessibility.NotApplicable)
{
return(AccessibilityFlags.None);
}
}
AccessibilityFlags flag = accessibility.GetAccessibilityFlag();
switch (accessibility)
{
case Accessibility.Private:
case Accessibility.Protected:
case Accessibility.ProtectedAndInternal:
case Accessibility.ProtectedOrInternal:
case Accessibility.Internal:
case Accessibility.Public:
{
allFlags |= flag;
break;
}
default:
{
Debug.Fail(accessibility.ToString());
return(AccessibilityFlags.None);
}
}
foreach (Accessibility accessibility2 in Accessibilities)
{
if (accessibility != accessibility2 &&
!CSharpUtility.IsAllowedAccessibility(member, accessibility2, allowOverride: allowOverride))
{
allowedFlags &= ~accessibility2.GetAccessibilityFlag();
}
}
}
switch (allFlags)
{
case AccessibilityFlags.Private:
case AccessibilityFlags.Protected:
case AccessibilityFlags.Internal:
case AccessibilityFlags.Public:
{
allowedFlags &= ~allFlags;
break;
}
}
return(allowedFlags);
}
public static FieldDeclarationSyntax DeclareField(TypeSyntax typeSyntax, string name, AccessibilityFlags accessibility)
{
VariableDeclarationSyntax varDeclaration = SyntaxFactory.VariableDeclaration(typeSyntax);
var varDeclarator = SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(name));
FieldDeclarationSyntax fieldDeclaration = SyntaxFactory.FieldDeclaration(
varDeclaration.WithVariables(SyntaxFactory.SingletonSeparatedList(varDeclarator)))
.WithModifiers(SyntaxFactory.TokenList(AccessibilityToSyntaxToken(accessibility).ToArray()));
return(fieldDeclaration);
}
