static void AdjustAccessibility (SyntaxTokenList modifiers, ref Accessibility acc, ref bool isStatic, ref bool result)
{
isStatic = modifiers.Any (mod => mod.Kind () == Microsoft.CodeAnalysis.CSharp.SyntaxKind.StaticKeyword);
if (modifiers.Any (mod => mod.Kind () == Microsoft.CodeAnalysis.CSharp.SyntaxKind.ProtectedKeyword) &&
modifiers.Any (mod => mod.Kind () == Microsoft.CodeAnalysis.CSharp.SyntaxKind.InternalKeyword)) {
acc = Accessibility.ProtectedOrInternal;
result = true;
return;
}
foreach (var mod in modifiers) {
if (mod.Kind () == Microsoft.CodeAnalysis.CSharp.SyntaxKind.PublicKeyword) {
acc = Accessibility.Public;
result = true;
return;
}
if (mod.Kind () == Microsoft.CodeAnalysis.CSharp.SyntaxKind.PrivateKeyword) {
acc = Accessibility.Private;
result = true;
return;
}
if (mod.Kind () == Microsoft.CodeAnalysis.CSharp.SyntaxKind.ProtectedKeyword) {
acc = Accessibility.Protected;
result = true;
return;
}
if (mod.Kind () == Microsoft.CodeAnalysis.CSharp.SyntaxKind.InternalKeyword) {
acc = Accessibility.Internal;
result = true;
return;
}
}
}
public static bool Any(this SyntaxTokenList list, SyntaxKind kind1, SyntaxKind kind2, params SyntaxKind[] kinds)
{
if (list.Any(kind1, kind2))
{
return(true);
}
for (int i = 0; i < kinds.Length; i++)
{
if (list.IndexOf(kinds[i]) >= 0)
{
return(true);
}
}
return(false);
}
bool CheckModifiers(SyntaxTokenList modifiers)
{
var isUnsafe = modifiers.Any(m => m.IsKind(SyntaxKind.UnsafeKeyword));
if (unsafeStateStack.Count > 0)
{
var curState = unsafeStateStack.Peek();
unsafeStateStack.Push(new UnsafeState(curState.InUnsafeContext));
}
else
{
unsafeStateStack.Push(new UnsafeState(isUnsafe));
}
return(isUnsafe);
}
private static bool TryUpdate(SyntaxTokenList modifiers, out SyntaxTokenList result)
{
result = modifiers;
if (modifiers.TrySingle(x => x.IsKind(SyntaxKind.VirtualKeyword), out var modifier))
{
result = modifiers.Remove(modifier);
}
if (result.TrySingle(x => x.IsKind(SyntaxKind.ProtectedKeyword), out modifier) &&
!result.Any(SyntaxKind.OverrideKeyword))
{
result = result.Replace(modifier, SyntaxFactory.Token(SyntaxKind.PrivateKeyword));
}
return(result != modifiers);
}
private void FindMissingVisibilityModifiers(SyntaxNodeAnalysisContext context)
{
if (IsInterfaceMember(context.Node) || IsExplicitInterfaceMember(context.Node) || IsStaticConstructor(context.Node))
{
return;
}
SyntaxNode root = context.Node.Ancestors().Last();
IDeclarationHandler handler = DeclarationHandlers.HandlerLookup[context.Node.Kind()];
SyntaxTokenList modifiers = handler.GetModifiers(context.Node);
if (!modifiers.Any(m => IsVisibilityModifier(m)))
{
context.ReportDiagnostic(Diagnostic.Create(_rule, context.Node.ChildTokens().First().GetLocation()));
}
}
private void AnalyzeIndexerDeclaration(SyntaxNodeAnalysisContext context)
{
var indexerDeclaration = (IndexerDeclarationSyntax)context.Node;
SyntaxTokenList modifiers = indexerDeclaration.Modifiers;
SyntaxNodeOrToken nodeOrToken = (modifiers.Any())
? modifiers[0]
: indexerDeclaration.Type;
Analyze(context, indexerDeclaration.AttributeLists, nodeOrToken);
if (!indexerDeclaration.IsSingleLine())
{
AnalyzeAccessorList(context, indexerDeclaration.AccessorList);
}
}
private void AnalyzePropertyDeclaration(SyntaxNodeAnalysisContext context)
{
var propertyDeclaration = (PropertyDeclarationSyntax)context.Node;
SyntaxTokenList modifiers = propertyDeclaration.Modifiers;
SyntaxNodeOrToken token = (modifiers.Any())
? modifiers[0]
: propertyDeclaration.Type;
Analyze(context, propertyDeclaration.AttributeLists, token);
if (!propertyDeclaration.IsSingleLine())
{
AnalyzeAccessorList(context, propertyDeclaration.AccessorList);
}
}
private static TextSpan?TryCreateSpanForVariableDeclaration(
VariableDeclarationSyntax variableDeclaration,
SyntaxTokenList modifiersOpt,
SyntaxToken semicolonOpt,
int position)
{
if (variableDeclaration.Variables.Count == 0)
{
return(null);
}
if (modifiersOpt.Any(SyntaxKind.ConstKeyword))
{
// no sequence points are emitted for const fields/locals
return(default(TextSpan));
}
if (variableDeclaration.Variables.Count == 1)
{
if (variableDeclaration.Variables[0].Initializer == null)
{
return(default(TextSpan));
}
return(CreateSpan(modifiersOpt, variableDeclaration, semicolonOpt));
}
if (semicolonOpt != default(SyntaxToken) && position > semicolonOpt.SpanStart)
{
position = variableDeclaration.SpanStart;
}
var declarator = FindClosestDeclaratorWithInitializer(variableDeclaration.Variables, position);
if (declarator == null)
{
return(default(TextSpan));
}
if (declarator == variableDeclaration.Variables[0])
{
return(CreateSpan(modifiersOpt, variableDeclaration.Type, variableDeclaration.Variables[0]));
}
return(CreateSpan(declarator));
}
/// <summary>
/// Return a node declaration that has a visibility modifier. If one isn't present it will be added as the
/// first modifier. Any trivia before the node will be added as leading trivia to the added <see cref="SyntaxToken"/>.
/// </summary>
private static SyntaxNode EnsureVisibility <T>(T node, SyntaxTokenList originalModifiers, Func <T, SyntaxTokenList, T> withModifiers, Func <SyntaxKind> getDefaultVisibility) where T : SyntaxNode
{
if (originalModifiers.Any(x => SyntaxFacts.IsAccessibilityModifier(x.Kind())))
{
return(node);
}
SyntaxKind visibilityKind = getDefaultVisibility();
Debug.Assert(SyntaxFacts.IsAccessibilityModifier(visibilityKind));
SyntaxTokenList modifierList;
if (originalModifiers.Count == 0)
{
var leadingTrivia = node.GetLeadingTrivia();
node = node.WithLeadingTrivia();
var visibilityToken = SyntaxFactory.Token(
leadingTrivia,
visibilityKind,
SyntaxFactory.TriviaList(SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " ")));
modifierList = SyntaxFactory.TokenList(visibilityToken);
}
else
{
var leadingTrivia = originalModifiers[0].LeadingTrivia;
var visibilityToken = SyntaxFactory.Token(
leadingTrivia,
visibilityKind,
SyntaxFactory.TriviaList(SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " ")));
var list = new List <SyntaxToken>();
list.Add(visibilityToken);
list.Add(originalModifiers[0].WithLeadingTrivia());
for (int i = 1; i < originalModifiers.Count; i++)
{
list.Add(originalModifiers[i]);
}
modifierList = SyntaxFactory.TokenList(list);
}
return(withModifiers(node, modifierList));
}
private void AnalyzeEventDeclaration(SyntaxNodeAnalysisContext context)
{
var eventDeclaration = (EventDeclarationSyntax)context.Node;
SyntaxTokenList modifiers = eventDeclaration.Modifiers;
SyntaxToken token = (modifiers.Any())
? modifiers[0]
: eventDeclaration.EventKeyword;
Analyze(context, eventDeclaration.AttributeLists, token);
if (!eventDeclaration.IsSingleLine())
{
AnalyzeAccessorList(context, eventDeclaration.AccessorList);
}
}
/// <summary>
/// Determines if Modifier Contains.
/// </summary>
/// <param name="tokenList">An instance of <see cref="SyntaxTokenList"/> containing the Syntax token list to check.</param>
/// <param name="syntaxKinds">An list of instances of <see cref="SyntaxKind"/> to attempt to locate.</param>
/// <returns><c>true</c> if the modifier is in the list of Syntax tokens, otherwise <c>false</c>.</returns>
protected static bool ModifierContains(SyntaxTokenList tokenList, List <SyntaxKind> syntaxKinds)
{
var containsSyntaxKind = false;
if (null != syntaxKinds)
{
foreach (var syntaxKind in syntaxKinds)
{
containsSyntaxKind = tokenList.Any(syntaxKind);
if (containsSyntaxKind)
{
break;
}
}
}
return(containsSyntaxKind);
}
private void AnalyzeAccessorList(SyntaxNodeAnalysisContext context, AccessorListSyntax accessorList)
{
if (accessorList == null)
{
return;
}
foreach (AccessorDeclarationSyntax accessor in accessorList.Accessors)
{
SyntaxTokenList modifiers = accessor.Modifiers;
SyntaxToken token = (modifiers.Any())
? modifiers[0]
: accessor.Keyword;
Analyze(context, accessor.AttributeLists, token);
}
}
private static void AnalyzeBasePropertyDeclaration(SyntaxNodeAnalysisContext context)
{
var basePropertyDeclaration = (BasePropertyDeclarationSyntax)context.Node;
AttributeListSyntax attributeList = basePropertyDeclaration.AttributeLists.LastOrDefault();
if (attributeList == null)
{
return;
}
SyntaxTokenList modifiers = basePropertyDeclaration.Modifiers;
SyntaxToken token = (modifiers.Any())
? modifiers[0]
: attributeList.CloseBracketToken.GetNextToken();
Analyze(context, attributeList, token);
}
private static void AnalyzeDelegateDeclaration(SyntaxNodeAnalysisContext context)
{
var delegateDeclaration = (DelegateDeclarationSyntax)context.Node;
AttributeListSyntax attributeList = delegateDeclaration.AttributeLists.LastOrDefault();
if (attributeList == null)
{
return;
}
SyntaxTokenList modifiers = delegateDeclaration.Modifiers;
SyntaxToken token = (modifiers.Any())
? modifiers[0]
: delegateDeclaration.DelegateKeyword;
Analyze(context, attributeList, token);
}
private static void AnalyzeBaseTypeDeclaration(SyntaxNodeAnalysisContext context)
{
var baseTypeDeclaration = (BaseTypeDeclarationSyntax)context.Node;
AttributeListSyntax attributeList = baseTypeDeclaration.AttributeLists.LastOrDefault();
if (attributeList == null)
{
return;
}
SyntaxTokenList modifiers = baseTypeDeclaration.Modifiers;
SyntaxToken token;
if (modifiers.Any())
{
token = modifiers[0];
}
else if (baseTypeDeclaration is ClassDeclarationSyntax classDeclaration)
{
token = classDeclaration.Keyword;
}
else if (baseTypeDeclaration is InterfaceDeclarationSyntax interfaceDeclaration)
{
token = interfaceDeclaration.Keyword;
}
else if (baseTypeDeclaration is StructDeclarationSyntax structDeclaration)
{
token = structDeclaration.Keyword;
}
else if (baseTypeDeclaration is EnumDeclarationSyntax enumDeclaration)
{
token = enumDeclaration.EnumKeyword;
}
else
{
throw new InvalidOperationException("");
}
Analyze(context, attributeList, token);
}
public static OperatorDeclarationSyntax InsertModifier(OperatorDeclarationSyntax operatorDeclaration, SyntaxToken modifier, IModifierComparer comparer)
{
if (operatorDeclaration == null)
{
throw new ArgumentNullException(nameof(operatorDeclaration));
}
SyntaxTokenList modifiers = operatorDeclaration.Modifiers;
if (!modifiers.Any())
{
TypeSyntax returnType = operatorDeclaration.ReturnType;
return(operatorDeclaration
.WithReturnType(returnType.WithoutLeadingTrivia())
.WithModifiers(TokenList(modifier.WithLeadingTrivia(returnType.GetLeadingTrivia()))));
}
return(operatorDeclaration.WithModifiers(modifiers.InsertModifier(modifier, comparer)));
}
public static StructDeclarationSyntax InsertModifier(StructDeclarationSyntax structDeclaration, SyntaxToken modifier, IModifierComparer comparer)
{
if (structDeclaration == null)
{
throw new ArgumentNullException(nameof(structDeclaration));
}
SyntaxTokenList modifiers = structDeclaration.Modifiers;
if (!modifiers.Any())
{
SyntaxToken structKeyword = structDeclaration.Keyword;
return(structDeclaration
.WithKeyword(structKeyword.WithoutLeadingTrivia())
.WithModifiers(TokenList(modifier.WithLeadingTrivia(structKeyword.LeadingTrivia))));
}
return(structDeclaration.WithModifiers(modifiers.InsertModifier(modifier, comparer)));
}
public static ConstructorDeclarationSyntax InsertModifier(ConstructorDeclarationSyntax constructorDeclaration, SyntaxToken modifier, IModifierComparer comparer)
{
if (constructorDeclaration == null)
{
throw new ArgumentNullException(nameof(constructorDeclaration));
}
SyntaxTokenList modifiers = constructorDeclaration.Modifiers;
if (!modifiers.Any())
{
SyntaxToken identifier = constructorDeclaration.Identifier;
return(constructorDeclaration
.WithIdentifier(identifier.WithoutLeadingTrivia())
.WithModifiers(TokenList(modifier.WithLeadingTrivia(identifier.LeadingTrivia))));
}
return(constructorDeclaration.WithModifiers(modifiers.InsertModifier(modifier, comparer)));
}
public static ConversionOperatorDeclarationSyntax InsertModifier(ConversionOperatorDeclarationSyntax conversionOperatorDeclaration, SyntaxToken modifier, IModifierComparer comparer)
{
if (conversionOperatorDeclaration == null)
{
throw new ArgumentNullException(nameof(conversionOperatorDeclaration));
}
SyntaxTokenList modifiers = conversionOperatorDeclaration.Modifiers;
if (!modifiers.Any())
{
SyntaxToken implicitOrExplicitKeyword = conversionOperatorDeclaration.ImplicitOrExplicitKeyword;
return(conversionOperatorDeclaration
.WithImplicitOrExplicitKeyword(implicitOrExplicitKeyword.WithoutLeadingTrivia())
.WithModifiers(TokenList(modifier.WithLeadingTrivia(implicitOrExplicitKeyword.LeadingTrivia))));
}
return(conversionOperatorDeclaration.WithModifiers(modifiers.InsertModifier(modifier, comparer)));
}
private void AnalyzeEnumDeclaration(SyntaxNodeAnalysisContext context)
{
var enumDeclaration = (EnumDeclarationSyntax)context.Node;
SyntaxTokenList modifiers = enumDeclaration.Modifiers;
SyntaxToken token = (modifiers.Any())
? modifiers[0]
: enumDeclaration.EnumKeyword;
Analyze(context, enumDeclaration.AttributeLists, token);
if (!enumDeclaration.IsSingleLine())
{
foreach (EnumMemberDeclarationSyntax enumMember in enumDeclaration.Members)
{
Analyze(context, enumMember.AttributeLists, enumMember.Identifier);
}
}
}
public static PropertyDeclarationSyntax InsertModifier(PropertyDeclarationSyntax propertyDeclaration, SyntaxToken modifier, IModifierComparer comparer)
{
if (propertyDeclaration == null)
{
throw new ArgumentNullException(nameof(propertyDeclaration));
}
SyntaxTokenList modifiers = propertyDeclaration.Modifiers;
if (!modifiers.Any())
{
TypeSyntax type = propertyDeclaration.Type;
return(propertyDeclaration
.WithType(type.WithoutLeadingTrivia())
.WithModifiers(TokenList(modifier.WithLeadingTrivia(type.GetLeadingTrivia()))));
}
return(propertyDeclaration.WithModifiers(modifiers.InsertModifier(modifier, comparer)));
}
public static DelegateDeclarationSyntax InsertModifier(DelegateDeclarationSyntax delegateDeclaration, SyntaxToken modifier, IModifierComparer comparer)
{
if (delegateDeclaration == null)
{
throw new ArgumentNullException(nameof(delegateDeclaration));
}
SyntaxTokenList modifiers = delegateDeclaration.Modifiers;
if (!modifiers.Any())
{
SyntaxToken delegateKeyword = delegateDeclaration.DelegateKeyword;
return(delegateDeclaration
.WithDelegateKeyword(delegateKeyword.WithoutLeadingTrivia())
.WithModifiers(TokenList(modifier.WithLeadingTrivia(delegateKeyword.LeadingTrivia))));
}
return(delegateDeclaration.WithModifiers(modifiers.InsertModifier(modifier, comparer)));
}
public static EventFieldDeclarationSyntax InsertModifier(EventFieldDeclarationSyntax eventFieldDeclaration, SyntaxToken modifier, IModifierComparer comparer)
{
if (eventFieldDeclaration == null)
{
throw new ArgumentNullException(nameof(eventFieldDeclaration));
}
SyntaxTokenList modifiers = eventFieldDeclaration.Modifiers;
if (!modifiers.Any())
{
SyntaxToken eventKeyword = eventFieldDeclaration.EventKeyword;
return(eventFieldDeclaration
.WithEventKeyword(eventKeyword.WithoutLeadingTrivia())
.WithModifiers(TokenList(modifier.WithLeadingTrivia(eventKeyword.LeadingTrivia))));
}
return(eventFieldDeclaration.WithModifiers(modifiers.InsertModifier(modifier, comparer)));
}
private static int GetModifierInsertIndex(SyntaxTokenList modifiers, int orderIndex)
{
if (modifiers.Any())
{
for (int i = orderIndex; i >= 0; i--)
{
SyntaxKind kind = ModifierComparer.GetKind(i);
for (int j = modifiers.Count - 1; j >= 0; j--)
{
if (modifiers[j].IsKind(kind))
{
return(j + 1);
}
}
}
}
return(0);
}
private static SyntaxTokenList Static(SyntaxTokenList modifiers)
{
if (!modifiers.Any(SyntaxKind.StaticKeyword))
{
var first = modifiers.First();
switch (first.Kind())
{
case SyntaxKind.PrivateKeyword:
case SyntaxKind.ProtectedKeyword:
case SyntaxKind.InternalKeyword:
case SyntaxKind.PublicKeyword:
return(modifiers.Insert(1, SyntaxFactory.Token(SyntaxKind.StaticKeyword)));
default:
return(modifiers.Insert(0, SyntaxFactory.Token(SyntaxKind.StaticKeyword)));
}
}
return(modifiers);
}
protected void ProcessAttribute(SyntaxNodeAnalysisContext context, SyntaxTokenList textTokens)
{
if (!textTokens.Any())
{
return;
}
var token = textTokens.First();
if (token.Span.Length >= 2)
{
var text = token.Text;
if (text[1] == ':')
{
var location = Location.Create(token.SyntaxTree, textTokens.Span);
context.ReportDiagnostic(Diagnostic.Create(Rule, location, text.Substring(0, 2)));
}
}
}
protected static void ProcessAttribute(SyntaxNodeAnalysisContext context, SyntaxTokenList textTokens)
{
if (!textTokens.Any())
{
return;
}
var token = textTokens.First();
if (token.Span.Length >= 2)
{
var text = token.Text;
if (text[1] == ':')
{
var location = Location.Create(token.SyntaxTree, textTokens.Span);
context.ReportDiagnostic(Diagnostic.Create(Rule, location, text.Substring(0, 2)));
}
}
}
public static FieldDeclarationSyntax InsertModifier(FieldDeclarationSyntax fieldDeclaration, SyntaxToken modifier, IModifierComparer comparer)
{
if (fieldDeclaration == null)
{
throw new ArgumentNullException(nameof(fieldDeclaration));
}
SyntaxTokenList modifiers = fieldDeclaration.Modifiers;
if (!modifiers.Any())
{
TypeSyntax type = fieldDeclaration.Declaration?.Type;
return(fieldDeclaration
.ReplaceNode(type, type.WithoutLeadingTrivia())
.WithModifiers(TokenList(modifier.WithLeadingTrivia(type.GetLeadingTrivia()))));
}
return(fieldDeclaration.WithModifiers(modifiers.InsertModifier(modifier, comparer)));
}
private const string _set = ""; //"set";
static void WriteRegion(bool get, string body, ITypeSymbol iface, OutputWriter writer, string typeString, string name, SyntaxTokenList modifiers, string parameters, bool isindexer, bool hasGetter)
{
//no inline in D
// if (get)
writer.Write((get ? (typeString) : (hasGetter ? typeString : "void")) + " ");
// else
// writer.Write("void ");
if (!isindexer)
{
writer.Write((get?(_get + name):(_set + (name))) +
(get
? "(" + (iface != null ? (TypeProcessor.ConvertType(iface) + " __ig=null") : "") + ")"
: "(" + typeString + " value " +
(iface != null ? ("," + TypeProcessor.ConvertType(iface) + " __ig=null") : "") + ")") +
" ");
}
else
{
writer.Write((name) +
(get
? "(" + parameters + ")"
: "(" + typeString + " value, " +
parameters + ")") +
"");
}
if (modifiers.Any(SyntaxKind.AbstractKeyword) || body == null)
{
writer.Write(";\r\n");
}
else
{
writer.WriteLine();
writer.OpenBrace();
writer.WriteLine(body);
writer.CloseBrace();
writer.WriteLine();
}
}
private const string _set = "";//"set";
static void WriteRegion(bool get, string body, ITypeSymbol iface, OutputWriter writer, string typeString, string name, SyntaxTokenList modifiers, string parameters, bool isindexer, bool hasGetter)
{
//no inline in D
// if (get)
writer.Write((get ? (typeString) : (hasGetter ? typeString : "void")) + " ");
// else
// writer.Write("void ");
if (!isindexer)
{
writer.Write( (get?(_get+name):(_set+(name))) +
(get
? "(" + (iface != null ? (TypeProcessor.ConvertType(iface) + " __ig=null") : "") + ")"
: "(" + typeString + " value " +
(iface != null ? ("," + TypeProcessor.ConvertType(iface) + " __ig=null") : "") + ")") +
" ");
}
else
{
writer.Write((name) +
(get
? "(" + parameters + ")"
: "(" + typeString + " value, " +
parameters + ")") +
"");
}
if (modifiers.Any(SyntaxKind.AbstractKeyword) || body == null)
writer.Write(";\r\n");
else
{
writer.WriteLine();
writer.OpenBrace();
writer.WriteLine(body);
writer.CloseBrace();
writer.WriteLine();
}
}
public static ConstructorDeclarationSyntax AddStaticModifier(ConstructorDeclarationSyntax constructorDeclaration)
{
if (constructorDeclaration == null)
{
throw new ArgumentNullException(nameof(constructorDeclaration));
}
SyntaxTokenList modifiers = constructorDeclaration.Modifiers;
if (!modifiers.Contains(SyntaxKind.StaticKeyword))
{
SyntaxTokenList newModifiers = modifiers;
if (modifiers.ContainsAccessModifier())
{
newModifiers = modifiers.RemoveAccessModifiers();
if (newModifiers.Any())
{
newModifiers = newModifiers.ReplaceAt(0, newModifiers[0].WithLeadingTrivia(modifiers[0].LeadingTrivia));
newModifiers = Inserter.InsertModifier(newModifiers, SyntaxKind.StaticKeyword);
}
else
{
newModifiers = Inserter.InsertModifier(newModifiers, CSharpFactory.StaticKeyword().WithLeadingTrivia(modifiers[0].LeadingTrivia));
}
}
else
{
newModifiers = Inserter.InsertModifier(newModifiers, SyntaxKind.StaticKeyword);
}
return(constructorDeclaration.WithModifiers(newModifiers));
}
else
{
return(constructorDeclaration);
}
}
private static ClassDeclarationSyntax AddModifier(ClassDeclarationSyntax classDeclaration, SyntaxKind modifierKind)
{
SyntaxTokenList modifiers = classDeclaration.Modifiers;
if (modifiers.Contains(modifierKind))
{
return(classDeclaration);
}
if (modifiers.Any())
{
int partialIndex = modifiers.IndexOf(SyntaxKind.PartialKeyword);
if (partialIndex != -1)
{
SyntaxToken partialToken = modifiers[partialIndex];
modifiers = modifiers
.ReplaceAt(partialIndex, partialToken.WithoutLeadingTrivia())
.Insert(
partialIndex,
Token(modifierKind)
.WithLeadingTrivia(partialToken.LeadingTrivia)
.WithTrailingTrivia(SpaceTrivia()));
return(classDeclaration.WithModifiers(modifiers));
}
else
{
return(classDeclaration
.AddModifiers(Token(modifierKind).WithLeadingTrivia(SpaceTrivia())));
}
}
else
{
return(classDeclaration.AddModifiers(Token(modifierKind)));
}
}
private static void AnalyzeBaseMethodDeclaration(SyntaxNodeAnalysisContext context)
{
var baseMethodDeclaration = (BaseMethodDeclarationSyntax)context.Node;
AttributeListSyntax attributeList = baseMethodDeclaration.AttributeLists.LastOrDefault();
if (attributeList == null)
{
return;
}
SyntaxTokenList modifiers = baseMethodDeclaration.Modifiers;
SyntaxToken token;
if (modifiers.Any())
{
token = modifiers[0];
}
else if (baseMethodDeclaration is ConstructorDeclarationSyntax constructorDeclaration)
{
token = constructorDeclaration.Identifier;
}
else if (baseMethodDeclaration is ConversionOperatorDeclarationSyntax conversionOperatorDeclaration)
{
token = conversionOperatorDeclaration.ImplicitOrExplicitKeyword;
}
else if (baseMethodDeclaration is DestructorDeclarationSyntax destructorDeclaration)
{
token = destructorDeclaration.TildeToken;
}
else
{
token = attributeList.CloseBracketToken.GetNextToken();
}
Analyze(context, attributeList, token);
}
internal static void GetFirstLocalOrFieldBreakpointSpan(SyntaxTokenList modifiers, VariableDeclaratorSyntax declaratorSyntax, out SyntaxNode node, out TextSpan? part)
{
var declarationSyntax = (VariableDeclarationSyntax)declaratorSyntax.Parent;
int start = modifiers.Any() ? modifiers[0].SpanStart : declarationSyntax.SpanStart;
int end;
if (declarationSyntax.Variables.Count == 1)
{
// [|int x = 1;|]
// [|public static int x = 1;|]
end = declarationSyntax.Parent.Span.End;
}
else
{
// [|int x = 1|], y = 2;
// [|public static int x = 1|], y = 2;
end = declaratorSyntax.Span.End;
}
part = TextSpan.FromBounds(start, end);
node = declarationSyntax.Parent;
}
private static string WriteAutoFieldName(OutputWriter writer, string name, SyntaxTokenList modifiers, bool isInterface,
bool hasGetter, bool getterHasBody, bool hasSetter, bool setterHasBody, string typeString, out string isOverride, bool isIndexer=false)
{
//Auto Property
var fieldName = "__prop_" + name;
isOverride = (modifiers.Any(SyntaxKind.NewKeyword) ||
modifiers.Any(SyntaxKind.OverrideKeyword)) && !isInterface
? " override "
: "";
var isStatic = modifiers.Any(SyntaxKind.StaticKeyword);
if (!isInterface &&!isIndexer) // Auto property
{
if ((hasGetter && !getterHasBody) &&
(hasSetter && !setterHasBody) && (!modifiers.Any(SyntaxKind.AbstractKeyword)))
{
writer.WriteLine("private " + (isStatic?"static " :"") + typeString + " " + fieldName + ";");
}
}
return fieldName;
}
private bool NeedsComment(SyntaxTokenList modifiers, SyntaxKind defaultModifier)
{
if (!(modifiers.Any(SyntaxKind.PublicKeyword)
|| modifiers.Any(SyntaxKind.ProtectedKeyword)
|| modifiers.Any(SyntaxKind.InternalKeyword)
|| defaultModifier == SyntaxKind.PublicKeyword
|| defaultModifier == SyntaxKind.ProtectedKeyword
|| defaultModifier == SyntaxKind.InternalKeyword))
{
return false;
}
// Also ignore partial classes because they get reported as SA1601
return !modifiers.Any(SyntaxKind.PartialKeyword);
}
private AccessModifierKind GetAccessModifier(SyntaxTokenList tokenList)
{
if (tokenList.Any(SyntaxKind.PublicKeyword))
{
return AccessModifierKind.Public;
}
if (tokenList.Any(SyntaxKind.ProtectedKeyword))
{
var isInternal = tokenList.Any(SyntaxKind.InternalKeyword);
return isInternal ? AccessModifierKind.Internal | AccessModifierKind.Protected : AccessModifierKind.Protected;
}
return AccessModifierKind.Private;
}
private static string GetVisibilityModifier(SyntaxTokenList tokens)
{
return tokens.Any(m => m.Kind() == SyntaxKind.PublicKeyword) ? "public" : "private";
}
public static bool IsConst(SyntaxTokenList modifiers, EqualsValueClauseSyntax initializerOpt, TypeSyntax type)
{
var t = TypeProcessor.ConvertType(type);
return modifiers.Any(SyntaxKind.ConstKeyword);
}
private static bool ContainsModifier(SyntaxTokenList modifiers, SyntaxKind expectedKeyword)
{
return modifiers.Any(modifier => modifier.Kind() == expectedKeyword);
}
private static void WriteGetter(OutputWriter writer, bool isProxy, bool hasGetter, string acccessmodifiers, string typeString, string name, ITypeSymbol iface, bool getterHasBody, SyntaxTokenList modifiers, bool isInterface, string fieldName, string getterbody, string parameters, bool isindexer)
{
if (isindexer)
name = "opIndex";
var args =_get;
if (hasGetter && isProxy)
{
if (!isindexer)
{
writer.WriteLine (string.Format ("{0}{1} {4}{2}({3}) {{ return __Value.{2};}}", acccessmodifiers, typeString, name, (iface != null ? (TypeProcessor.ConvertType (iface) + " __ig=null") : ""), args));
}
else
{
writer.WriteLine (string.Format ("{0}{1} {2}({3}) {{ return __Value.{2};}}", acccessmodifiers, typeString, name, parameters));
}
}
else if (hasGetter && !getterHasBody) //Getter
{
if (modifiers.Any(SyntaxKind.AbstractKeyword) || isInterface)
{
if (!isindexer)
{
writer.WriteLine (string.Format ("{0}{1} {4}{2}({3});", acccessmodifiers, typeString, name, (iface != null ? (TypeProcessor.ConvertType (iface) + " __ig=null") : ""), args));
}
else
{
writer.WriteLine (string.Format ("{0}{1} {2}({3});", acccessmodifiers, typeString, name, parameters));
}
}
else
{
if (!isindexer)
{
writer.WriteLine (string.Format ("{0}{1} {5}{2}({3}) {{ return {4};}}", acccessmodifiers, typeString, name, (iface != null ? (TypeProcessor.ConvertType (iface) + " __ig=null") : ""), fieldName, args));
}
else
{
writer.WriteLine (string.Format ("{0}{1} {2}({3}) {{ return {4};}}", acccessmodifiers, typeString, name, parameters, fieldName));
}
}
}
else if (hasGetter)
{
writer.WriteIndent();
writer.Write(acccessmodifiers);
WriteRegion(true, getterbody, iface, writer, typeString, name, modifiers,parameters,isindexer,hasGetter);
}
}
public static void Go(OutputWriter writer, MemberDeclarationSyntax field, SyntaxTokenList modifiers, string name,
TypeSyntax type, EqualsValueClauseSyntax initializerOpt = null, bool isThreadStatic =false)
{
writer.WriteIndent();
var typeinfo = TypeProcessor.GetTypeInfo(type);
// var isPtr = typeinfo.Type != null && (typeinfo.Type.IsValueType || typeinfo.Type.TypeKind==TypeKind.TypeParameter) ? "" : "";
var typeStringNoPtr = TypeProcessor.ConvertType(type);
var typeString = typeStringNoPtr + " ";
var isConst = IsConst(modifiers, initializerOpt, type);
var isStatic = isConst;
//Handle Auto Properties
// if (modifiers.Any(SyntaxKind.PrivateKeyword)) // Reflection cannot work with this, cant get address or set value
// writer.Write("private ");
if (modifiers.Any(SyntaxKind.PublicKeyword) || modifiers.Any(SyntaxKind.InternalKeyword) ||
modifiers.Any(SyntaxKind.ProtectedKeyword) || modifiers.Any(SyntaxKind.AbstractKeyword))
writer.Write("public ");
if (isThreadStatic)
{
writer.Write("static ");
}
if (modifiers.Any(SyntaxKind.StaticKeyword) || modifiers.Any(SyntaxKind.ConstKeyword))
{
isStatic = true;
writer.Write("__gshared ");
}
if (isConst && typeinfo.Type.IsPrimitive())
{
writer.Write("const "); //const has interesting semantics in Dlang
}
var @event = field is EventFieldDeclarationSyntax;
ITypeSymbol iface;
ISymbol[] proxies;
bool isInterface =false;
// var ename = MemberUtilities.GetMethodName(field, ref isInterface, out iface, out proxies);
if (@event)
{
typeString = ("__Event!(" + typeString + ")");
if (field.Parent is InterfaceDeclarationSyntax)
{
//writer.Write(typeString);
writer.WriteLine(typeString + " " + name + "(" + TypeProcessor.ConvertType(field.Parent) +" __ij)" + "@property;");
return;
}
}
writer.Write(typeString);
// if (isStatic)
// writer.Write(typeString);
writer.Write(name);
if (isStatic)
{
// var fieldInfo = TypeProcessor.GetDeclaredSymbol(field.Parent);
// if (fieldInfo != null)
// writer.Write((!string.IsNullOrEmpty(fieldInfo.ContainingNamespace.FullName())?(fieldInfo.ContainingNamespace.FullName()+".") :"") + fieldInfo.Name+"."+name);
// writer.Write(name);
}
if (!isStatic || isConst)
{
if (initializerOpt != null)
{
writer.Write(String.Format(" = cast({0})", typeString));
if (CSharpExtensions.CSharpKind(initializerOpt.Value) == SyntaxKind.CollectionInitializerExpression ||
CSharpExtensions.CSharpKind(initializerOpt.Value) == SyntaxKind.ArrayInitializerExpression)
{
// writer.Write("gc::gc_ptr< " + typeStringNoPtr + " >(");
writer.Write(" new " + typeString + " (");
var intializer = initializerOpt.Value as InitializerExpressionSyntax;
intializer.WriteArrayInitializer(writer, type);
writer.Write(")");
}
else
Core.Write(writer, initializerOpt.Value);
}
else
{
// if (typeinfo.Type.TypeKind != TypeKind.Struct)
{
writer.Write(" = ");
if (typeinfo.Type.TypeKind == TypeKind.Delegate)
writer.Write("new " + typeString + "()");
else
writer.Write(TypeProcessor.DefaultValue(type));
}
}
}
else
{
var staticWriter = new TempWriter();
if (initializerOpt != null)
{
staticWriter.Write(name);
staticWriter.Write(" = ");
if (CSharpExtensions.CSharpKind(initializerOpt.Value) == SyntaxKind.CollectionInitializerExpression ||
CSharpExtensions.CSharpKind(initializerOpt.Value) == SyntaxKind.ArrayInitializerExpression)
{
staticWriter.Write("new " + typeStringNoPtr + " (");
var intializer = initializerOpt.Value as InitializerExpressionSyntax;
intializer.WriteArrayInitializer(staticWriter, type);
staticWriter.Write(")");
}
else
Core.Write(staticWriter, initializerOpt.Value);
staticWriter.Write(";");
staticWriter.WriteLine();
Context.Instance.StaticInits.Add(staticWriter.ToString());
}
else if (typeinfo.Type.TypeKind != TypeKind.Struct)
{
staticWriter.Write(name);
staticWriter.Write(" = ");
if (typeinfo.Type.TypeKind == TypeKind.Delegate)
staticWriter.Write("new " + typeString + "()");
else
staticWriter.Write(TypeProcessor.DefaultValue(type));
staticWriter.Write(";");
staticWriter.WriteLine();
Context.Instance.StaticInits.Add(staticWriter.ToString());
}
}
writer.Write(";");
writer.WriteLine();
}
bool CheckModifiers(SyntaxTokenList modifiers)
{
var isUnsafe = modifiers.Any(m => m.IsKind(SyntaxKind.UnsafeKeyword));
if (unsafeStateStack.Count > 0)
{
var curState = unsafeStateStack.Peek();
unsafeStateStack.Push(new UnsafeState(curState.InUnsafeContext));
}
else {
unsafeStateStack.Push(new UnsafeState(isUnsafe));
}
return isUnsafe;
}
static bool IsConst (SyntaxTokenList modifiers)
{
return modifiers.Any (mod => mod.Kind () == Microsoft.CodeAnalysis.CSharp.SyntaxKind.ConstKeyword);
}
private bool ClassifyModifiedMemberInsert(SyntaxTokenList modifiers)
{
if (modifiers.Any(SyntaxKind.ExternKeyword))
{
ReportError(RudeEditKind.InsertExtern);
return false;
}
if (modifiers.Any(SyntaxKind.VirtualKeyword) || modifiers.Any(SyntaxKind.AbstractKeyword) || modifiers.Any(SyntaxKind.OverrideKeyword))
{
ReportError(RudeEditKind.InsertVirtual);
return false;
}
return true;
}
private static ModifierFlags GetModifierFlags(SyntaxTokenList syntax)
{
ModifierFlags flags = 0;
if (syntax.Any(SyntaxKind.ConstKeyword))
{
flags |= ModifierFlags.Const;
}
else
{
if (syntax.Any(SyntaxKind.StaticKeyword))
{
flags |= ModifierFlags.Static;
}
if (syntax.Any(SyntaxKind.ReadOnlyKeyword))
{
flags |= ModifierFlags.Readonly;
}
}
return flags == 0 ? ModifierFlags.None : flags;
}
private static void WriteSetter(OutputWriter writer, bool isProxy, bool hasSetter, string acccessmodifiers, string name, string typeString, ITypeSymbol iface, string isOverride, bool setterHasBody, SyntaxTokenList modifiers, bool isInterface, string fieldName, string setterbody, string parameters, bool isindexer,bool hasGetter)
{
if (isindexer)
name = "opIndexAssign";
var args = _set;
if (hasSetter && isProxy)
{
if (!isindexer)
{
writer.WriteLine (string.Format ("{0} {2} {5}{1}({2} value{3}{4}){4} {{ __Value.{1} = value; return value;}}", acccessmodifiers, name, hasGetter ? typeString : "void", (iface != null ? ("," + TypeProcessor.ConvertType (iface) + " __ig=null") : ""), isOverride, args));
}
else
{
writer.WriteLine (string.Format ("{0} {2} {1}({2} value,{3}{4}) {4} {{ __Value.{1} = value;return value;}}", acccessmodifiers, name, typeString, parameters, isOverride));
}
}
else if (hasSetter && !setterHasBody) //Setter
{
if (modifiers.Any(SyntaxKind.AbstractKeyword) || isInterface)
{
if (!isindexer)
{
writer.WriteLine (string.Format ("{0} {2} {5}{1}({2} value{3}{4});", acccessmodifiers, name, hasGetter ? typeString : "void", (iface != null ? ("," + TypeProcessor.ConvertType (iface) + " __ig=null") : ""), isOverride, args));
}
else
{
writer.WriteLine (string.Format ("{0} {2} {1}({2} value,{3}{4});", acccessmodifiers, name, typeString, parameters, isOverride));
}
}
else
{
if (!isindexer)
{
var returnValue = hasGetter ? writer.WriteIndentToString() + "return value;" :"";
writer.WriteLine (string.Format("{0} {2} {6}{1}({2} value{3}){4} {{{5} = value;{7}}}", acccessmodifiers, name, hasGetter?typeString :"void", (iface != null ? ("," + TypeProcessor.ConvertType (iface) + " __ig=null") : ""), isOverride, fieldName, args,returnValue));
}
else
{
var returnValue = hasGetter ? writer.WriteIndentToString() + "return value;" : "";
writer.WriteLine (string.Format("{0} {2} {1}({2} value,{3}){4} {{{5} = value;{6}}}" , acccessmodifiers, name, typeString, parameters, isOverride, fieldName, returnValue));
}
}
}
else if (hasSetter)
{
writer.WriteIndent();
writer.Write(acccessmodifiers);
WriteRegion(false, setterbody, iface, writer, typeString, name, modifiers,parameters,isindexer,hasGetter);
}
}
internal static AccessLevel GetAccessLevelForOrdering(SyntaxNode member, SyntaxTokenList modifiers)
{
SyntaxKind type = member.Kind();
AccessLevel accessibility;
if ((type == SyntaxKind.ConstructorDeclaration && modifiers.Any(SyntaxKind.StaticKeyword))
|| (type == SyntaxKind.MethodDeclaration && ((MethodDeclarationSyntax)member).ExplicitInterfaceSpecifier != null)
|| (type == SyntaxKind.PropertyDeclaration && ((PropertyDeclarationSyntax)member).ExplicitInterfaceSpecifier != null)
|| (type == SyntaxKind.IndexerDeclaration && ((IndexerDeclarationSyntax)member).ExplicitInterfaceSpecifier != null))
{
accessibility = AccessLevel.Public;
}
else
{
accessibility = AccessLevelHelper.GetAccessLevel(modifiers);
if (accessibility == AccessLevel.NotSpecified)
{
if (member.Parent.IsKind(SyntaxKind.CompilationUnit) || member.Parent.IsKind(SyntaxKind.NamespaceDeclaration))
{
accessibility = AccessLevel.Internal;
}
else
{
accessibility = AccessLevel.Private;
}
}
}
return accessibility;
}
private AccessModifierKind GetAccessModifier(SyntaxTokenList tokenList)
{
if (tokenList.Any(SyntaxKind.PublicKeyword))
{
return AccessModifierKind.Public;
}
if (tokenList.Any(SyntaxKind.PrivateKeyword))
{
return AccessModifierKind.Private;
}
return AccessModifierKind.Internal;
}
internal Binder WithUnsafeRegionIfNecessary(SyntaxTokenList modifiers)
{
return (this.Flags.Includes(BinderFlags.UnsafeRegion) || !modifiers.Any(SyntaxKind.UnsafeKeyword))
? this
: new Binder(this, this.Flags | BinderFlags.UnsafeRegion);
}
private static ModifierFlags GetModifierFlags(SyntaxTokenList syntax, ElementOrderingChecks checks)
{
var flags = ModifierFlags.None;
if (checks.Const && syntax.Any(SyntaxKind.ConstKeyword))
{
flags |= ModifierFlags.Const;
}
else
{
if (checks.Static && syntax.Any(SyntaxKind.StaticKeyword))
{
flags |= ModifierFlags.Static;
}
if (checks.Readonly && syntax.Any(SyntaxKind.ReadOnlyKeyword))
{
flags |= ModifierFlags.Readonly;
}
}
return flags;
}
