public static SyntaxTokenList InsertModifier(SyntaxTokenList modifiers, SyntaxToken modifier)
{
if (modifiers.Any())
{
int index = GetModifierInsertIndex(modifiers, modifier);
if (index == modifiers.Count)
{
return(modifiers.Add(modifier.PrependToLeadingTrivia(Space)));
}
else
{
SyntaxToken nextModifier = modifiers[index];
return(modifiers
.Replace(nextModifier, nextModifier.WithoutLeadingTrivia())
.Insert(
index,
modifier
.WithLeadingTrivia(nextModifier.LeadingTrivia)
.WithTrailingTrivia(Space)));
}
}
else
{
return(modifiers.Add(modifier));
}
}
internal static SyntaxTokenList TranslateTokenList(IEnumerable <SyntaxToken> ChildTokens)
{
var NewTokenList = new SyntaxTokenList();
foreach (SyntaxToken token in ChildTokens)
{
var NewLeadingTriviaList = new SyntaxTriviaList();
var NewTrailingTriviaList = new SyntaxTriviaList();
string TokenText = token.Text;
string ValueText = token.ValueText;
if (token.HasLeadingTrivia)
{
foreach (SyntaxTrivia t in token.LeadingTrivia)
{
if (t.IsKind(CS.SyntaxKind.DocumentationCommentExteriorTrivia))
{
NewLeadingTriviaList = NewLeadingTriviaList.Add(VBFactory.DocumentationCommentExteriorTrivia(token.LeadingTrivia[0].ToString().Replace("///", "'''")));
if (!TokenText.StartsWith(" "))
{
TokenText = " " + TokenText;
ValueText = " " + ValueText;
}
}
else
{
}
}
}
var switchExpr = token.RawKind;
switch (switchExpr)
{
case (int)CS.SyntaxKind.XmlTextLiteralToken:
{
NewTokenList = NewTokenList.Add(VBFactory.XmlTextLiteralToken(NewLeadingTriviaList, TokenText, ValueText, NewTrailingTriviaList));
break;
}
case (int)CS.SyntaxKind.XmlTextLiteralNewLineToken:
{
NewTokenList = NewTokenList.Add(VBFactory.XmlTextNewLine(text: Constants.vbCrLf, value: Constants.vbCrLf, NewLeadingTriviaList, NewTrailingTriviaList));
break;
}
case (int)CS.SyntaxKind.XmlEntityLiteralToken:
{
NewTokenList = NewTokenList.Add(VBFactory.XmlEntityLiteralToken(NewLeadingTriviaList, TokenText, ValueText, NewTrailingTriviaList));
break;
}
default:
{
break;
}
}
}
return(NewTokenList);
}
private static LocalFunctionStatementSyntax CreateLocalFunctionStatement(
LocalDeclarationStatementSyntax localDeclaration,
AnonymousFunctionExpressionSyntax anonymousFunction,
IMethodSymbol delegateMethod,
ParameterListSyntax parameterList,
bool makeStatic
)
{
var modifiers = new SyntaxTokenList();
if (makeStatic)
{
modifiers = modifiers.Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword));
}
if (anonymousFunction.AsyncKeyword.IsKind(SyntaxKind.AsyncKeyword))
{
modifiers = modifiers.Add(anonymousFunction.AsyncKeyword);
}
var returnType = delegateMethod.GenerateReturnTypeSyntax();
var identifier = localDeclaration.Declaration.Variables[0].Identifier;
var typeParameterList = (TypeParameterListSyntax)null;
var constraintClauses = default(SyntaxList <TypeParameterConstraintClauseSyntax>);
var body = anonymousFunction.Body.IsKind(SyntaxKind.Block, out BlockSyntax block)
? block
: null;
var expressionBody = anonymousFunction.Body is ExpressionSyntax expression
? SyntaxFactory.ArrowExpressionClause(
((LambdaExpressionSyntax)anonymousFunction).ArrowToken,
expression
)
: null;
var semicolonToken =
anonymousFunction.Body is ExpressionSyntax
? localDeclaration.SemicolonToken
: default;
return(SyntaxFactory.LocalFunctionStatement(
modifiers,
returnType,
identifier,
typeParameterList,
parameterList,
constraintClauses,
body,
expressionBody,
semicolonToken
));
}
public ClassComposer SetAccessModifier(AccessModifierTypes newType)
{
dynamic twm = CurrentNode;
SyntaxTokenList modifiers = twm.Modifiers;
for (int i = modifiers.Count - 1; i >= 0; i--)
{
var m = modifiers.ElementAt(i);
switch (m.Kind())
{
case SyntaxKind.PrivateKeyword:
case SyntaxKind.ProtectedKeyword:
case SyntaxKind.InternalKeyword:
case SyntaxKind.PublicKeyword:
modifiers = modifiers.RemoveAt(i);
break;
}
}
switch (newType)
{
case AccessModifierTypes.PRIVATE:
modifiers = modifiers.Add(SyntaxFactory.Token(SyntaxKind.PrivateKeyword));
break;
case AccessModifierTypes.PROTECTED:
modifiers = modifiers.Add(SyntaxFactory.Token(SyntaxKind.ProtectedKeyword));
break;
case AccessModifierTypes.PRIVATE_PROTECTED:
modifiers = SyntaxFactory.TokenList(modifiers.Concat(new[] { SyntaxFactory.Token(SyntaxKind.PrivateKeyword), SyntaxFactory.Token(SyntaxKind.ProtectedKeyword) }));
break;
case AccessModifierTypes.INTERNAL:
modifiers = modifiers.Add(SyntaxFactory.Token(SyntaxKind.InternalKeyword));
break;
case AccessModifierTypes.PROTECTED_INTERNAL:
modifiers = SyntaxFactory.TokenList(modifiers.Concat(new[] { SyntaxFactory.Token(SyntaxKind.ProtectedKeyword), SyntaxFactory.Token(SyntaxKind.InternalKeyword) }));
break;
case AccessModifierTypes.PUBLIC:
modifiers = modifiers.Add(SyntaxFactory.Token(SyntaxKind.PublicKeyword));
break;
}
SyntaxNode newNode = twm.WithModifiers(modifiers);
Replace(twm, newNode, null);
return(this);
}
public SyntaxTokenList ModifiersToTokenList()
{
SyntaxTokenList retVal = new SyntaxTokenList();
switch (AccessModifier)
{
case AccessModifierTypes.PRIVATE:
retVal = retVal.Add(SyntaxFactory.Token(SyntaxKind.PrivateKeyword));
break;
case AccessModifierTypes.PROTECTED:
retVal = retVal.Add(SyntaxFactory.Token(SyntaxKind.ProtectedKeyword));
break;
case AccessModifierTypes.PRIVATE_PROTECTED:
retVal = retVal.Add(SyntaxFactory.Token(SyntaxKind.PrivateKeyword));
retVal = retVal.Add(SyntaxFactory.Token(SyntaxKind.ProtectedKeyword));
break;
case AccessModifierTypes.INTERNAL:
retVal = retVal.Add(SyntaxFactory.Token(SyntaxKind.InternalKeyword));
break;
case AccessModifierTypes.PROTECTED_INTERNAL:
retVal = retVal.Add(SyntaxFactory.Token(SyntaxKind.ProtectedKeyword));
retVal = retVal.Add(SyntaxFactory.Token(SyntaxKind.InternalKeyword));
break;
case AccessModifierTypes.PUBLIC:
retVal = retVal.Add(SyntaxFactory.Token(SyntaxKind.PublicKeyword));
break;
}
return(retVal);
}
private void DoTestAddInsertRemoveReplaceOnEmptyList(SyntaxTokenList list)
{
Assert.Equal(0, list.Count);
var tokenD = SyntaxFactory.ParseToken("D ");
var tokenE = SyntaxFactory.ParseToken("E ");
var newList = list.Add(tokenD);
Assert.Equal(1, newList.Count);
Assert.Equal("D ", newList.ToFullString());
newList = list.AddRange(new[] { tokenD, tokenE });
Assert.Equal(2, newList.Count);
Assert.Equal("D E ", newList.ToFullString());
newList = list.Insert(0, tokenD);
Assert.Equal(1, newList.Count);
Assert.Equal("D ", newList.ToFullString());
newList = list.InsertRange(0, new[] { tokenD, tokenE });
Assert.Equal(2, newList.Count);
Assert.Equal("D E ", newList.ToFullString());
newList = list.Remove(tokenD);
Assert.Equal(0, newList.Count);
Assert.Equal(-1, list.IndexOf(tokenD));
Assert.Throws <ArgumentOutOfRangeException>(() => list.RemoveAt(0));
Assert.Throws <ArgumentOutOfRangeException>(() => list.Insert(1, tokenD));
Assert.Throws <ArgumentOutOfRangeException>(() => list.Insert(-1, tokenD));
Assert.Throws <ArgumentOutOfRangeException>(
() => list.InsertRange(-1, new[] { tokenD })
);
Assert.Throws <ArgumentOutOfRangeException>(
() => list.InsertRange(list.Count + 1, new[] { tokenD })
);
Assert.Throws <ArgumentOutOfRangeException>(() => list.Replace(tokenD, tokenE));
Assert.Throws <ArgumentOutOfRangeException>(
() => list.ReplaceRange(tokenD, new[] { tokenE })
);
Assert.Throws <ArgumentOutOfRangeException>(() => list.Add(default(SyntaxToken)));
Assert.Throws <ArgumentOutOfRangeException>(() => list.Insert(0, default(SyntaxToken)));
Assert.Throws <ArgumentNullException>(
() => list.AddRange((IEnumerable <SyntaxToken>)null)
);
Assert.Throws <ArgumentNullException>(
() => list.InsertRange(0, (IEnumerable <SyntaxToken>)null)
);
}
public static ClassDeclarationSyntax WithModifiers(ClassDeclarationSyntax decl, bool @static = false, bool @public = false, bool @protected = false, bool @private = false)
{
SyntaxTokenList modifiers = new SyntaxTokenList();
foreach (var modifier in decl.Modifiers)
{
bool add = true;
switch (modifier.CSharpKind())
{
case SyntaxKind.PrivateKeyword:
case SyntaxKind.ProtectedKeyword:
case SyntaxKind.PublicKeyword:
add = !(@public || @private || @protected);
break;
case SyntaxKind.StaticKeyword:
add = !@static;
break;
}
if (add)
{
modifiers.Add(modifier);
}
}
if (@static)
{
modifiers.Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword));
}
if (@public)
{
modifiers.Add(SyntaxFactory.Token(SyntaxKind.PublicKeyword));
}
if (@protected)
{
modifiers.Add(SyntaxFactory.Token(SyntaxKind.ProtectedKeyword));
}
if (@private)
{
modifiers.Add(SyntaxFactory.Token(SyntaxKind.PrivateKeyword));
}
return(decl.WithModifiers(modifiers));
}
public static SyntaxTokenList ToList(this SyntaxToken token)
{
var stl = new SyntaxTokenList();
stl = stl.Add(token);
return(stl);
}
static SyntaxTokenList ConvertModifiers(SyntaxTokenList csmodifiers)
{
SyntaxTokenList retvals = VB.SyntaxFactory.TokenList();
foreach (SyntaxToken csmodifier in csmodifiers)
{
foreach (KeywordPair pair in Keyword.ModifirePairs)
{
if (csmodifier.IsKind(pair.CS))
{
if (pair.Targets != AttributeTargets.All)
{
SyntaxNode parent = csmodifier.Parent;
if (((pair.Targets & AttributeTargets.Class) == AttributeTargets.Class)
^ parent.IsKind(CS.SyntaxKind.ClassDeclaration))
{
continue;
}
}
retvals = retvals.Add(VB.SyntaxFactory.Token(pair.VB));
break;
}
}
}
return retvals;
}
private XmlTextSyntax CreateTextSyntax(string text)
{
var tokenList = new SyntaxTokenList();
tokenList = tokenList.Add(XmlTextLiteral(text));
return(SyntaxFactory.XmlText(tokenList));
}
public static SyntaxTokenList WithParameterModifier(this SyntaxTokenList tokens, ParameterModifier modifier)
{
tokens = tokens.Remove(parameterModifierTokens);
switch (modifier)
{
case ParameterModifier.Out:
return(tokens.Add(SyntaxKind.OutKeyword));
case ParameterModifier.Params:
return(tokens.Add(SyntaxKind.ParamsKeyword));
case ParameterModifier.Ref:
return(tokens.Add(SyntaxKind.RefKeyword));
}
return(tokens);
}
private async Task <Document> ToConstantDeclarationAsync(Document document, SyntaxNode fieldDeclaration, CancellationToken cancellationToken)
{
var editor = await DocumentEditor.CreateAsync(document, cancellationToken).ConfigureAwait(false);
SyntaxTriviaList leadingTrivia = new SyntaxTriviaList();
SyntaxTriviaList trailingTrivia = new SyntaxTriviaList();
SyntaxTokenList newModifiers = new SyntaxTokenList();
foreach (SyntaxToken modifier in GetModifiers(fieldDeclaration))
{
if (IsStaticKeyword(modifier) || IsReadonlyKeyword(modifier))
{
// The associated analyzer ensures we'll only get in the fixer if both 'static' and 'readonly'
// keywords are in the declaration. Because their order is not relevant, we detect if both
// have been passed by inspecting whether leading and trailing trivia are non-empty.
if (leadingTrivia.Count == 0 && trailingTrivia.Count == 0)
{
leadingTrivia = leadingTrivia.AddRange(modifier.LeadingTrivia);
trailingTrivia = trailingTrivia.AddRange(modifier.TrailingTrivia);
}
else
{
// Copy the trivia in-between both keywords ('static' and 'readonly') into
// the combined set of trailing trivia.
trailingTrivia = trailingTrivia.AddRange(modifier.LeadingTrivia);
trailingTrivia = trailingTrivia.AddRange(modifier.TrailingTrivia);
// We have processed both the keywords 'static' and 'readonly', so we insert the 'const' keyword here.
// In case any additional modifiers will follow, their relative position should not change.
SyntaxToken constModifier =
GetConstKeywordToken().WithLeadingTrivia(leadingTrivia).WithTrailingTrivia(trailingTrivia);
newModifiers = newModifiers.Add(constModifier);
}
}
else
{
newModifiers = newModifiers.Add(modifier);
}
}
var constFieldDeclaration = WithModifiers(fieldDeclaration, newModifiers).WithAdditionalAnnotations(Formatter.Annotation);
editor.ReplaceNode(fieldDeclaration, constFieldDeclaration);
return(editor.GetChangedDocument());
}
private static XmlTextSyntax XmlNewLine()
{
var tokenList = new SyntaxTokenList();
tokenList = tokenList.Add(SyntaxFactory.XmlTextNewLine(default(SyntaxTriviaList), "\r\n", "\r\n", default(SyntaxTriviaList)));
return(SyntaxFactory.XmlText(tokenList));
}
private static SyntaxTokenList AddAbstractKeywordIfNotPresent(SyntaxTokenList modifiers)
{
if (!modifiers.Contains(SyntaxKind.AbstractKeyword))
{
modifiers = modifiers.Add(AbstractKeyword());
}
return(modifiers);
}
/// <summary>
/// Creates a new list of modifiers with a specified modifier inserted.
/// </summary>
/// <param name="modifiers"></param>
/// <param name="modifier"></param>
/// <param name="comparer"></param>
public static SyntaxTokenList Insert(SyntaxTokenList modifiers, SyntaxToken modifier, IComparer <SyntaxToken> comparer = null)
{
if (!modifiers.Any())
{
return(modifiers.Add(modifier));
}
return(InsertImpl(modifiers, modifier, GetInsertIndex(modifiers, modifier, comparer)));
}
/// <summary>
/// Creates a new list of modifiers with the modifier of the specified kind inserted.
/// </summary>
/// <param name="modifiers"></param>
/// <param name="kind"></param>
/// <param name="comparer"></param>
public static SyntaxTokenList Insert(SyntaxTokenList modifiers, SyntaxKind kind, IComparer <SyntaxKind> comparer = null)
{
if (!modifiers.Any())
{
return(modifiers.Add(Token(kind)));
}
return(InsertImpl(modifiers, Token(kind), GetInsertIndex(modifiers, kind, comparer)));
}
static SyntaxTokenList ConvertModifiersWithDefault(SyntaxTokenList csmodifiers, SyntaxToken? defaultModifire = null)
{
SyntaxTokenList retvals = ConvertModifiers(csmodifiers);
if (retvals.Count == 0 && defaultModifire != null)
{
retvals = retvals.Add(defaultModifire.Value);
}
return retvals;
}
private static SyntaxTokenList GenerateModifiers(
IParameterSymbol parameter, bool isFirstParam)
{
SyntaxTokenList list = CSharpSyntaxGenerator.GetParameterModifiers(parameter.RefKind);
if (isFirstParam &&
parameter.ContainingSymbol is IMethodSymbol methodSymbol &&
methodSymbol.IsExtensionMethod)
{
list = list.Add(SyntaxFactory.Token(SyntaxKind.ThisKeyword));
}
if (parameter.IsParams)
{
list = list.Add(SyntaxFactory.Token(SyntaxKind.ParamsKeyword));
}
return(list);
}
public static InterfaceDeclarationSyntax WithModifiers(this InterfaceDeclarationSyntax interfaceDeclarationSyntax, params SyntaxKind[] modifiers)
{
var tokenList = new SyntaxTokenList();
foreach (var modifier in modifiers)
{
tokenList = tokenList.Add(SyntaxFactory.Token(modifier));
}
return(interfaceDeclarationSyntax.WithModifiers(tokenList));
}
private static SyntaxTokenList ConvertVirtualModifier(SyntaxTokenList tokenList, VirtualModifier virtualModifier)
{
switch (virtualModifier)
{
case VirtualModifier.None:
return(tokenList);
case VirtualModifier.Abstract:
return(tokenList.Add(Token(SyntaxKind.AbstractKeyword)));
case VirtualModifier.Virtual:
return(tokenList.Add(Token(SyntaxKind.VirtualKeyword)));
case VirtualModifier.Override:
return(tokenList.Add(Token(SyntaxKind.OverrideKeyword)));
default:
throw new ArgumentOutOfRangeException(nameof(virtualModifier), virtualModifier, null);
}
}
private static FieldDeclarationSyntax CreateBackingField(PropertyDeclarationSyntax propertyDeclaration, string name)
{
SyntaxTokenList modifiers = TokenList(PrivateKeyword());
if (propertyDeclaration.IsStatic())
{
modifiers = modifiers.Add(StaticKeyword());
}
return(FieldDeclaration(modifiers, propertyDeclaration.Type, name, propertyDeclaration.Initializer));
}
public static SyntaxTokenList WithClassFieldModifier(this SyntaxTokenList tokens, ClassFieldModifier modifier)
{
tokens = tokens.Remove(classFieldModifierTokens);
switch (modifier)
{
case ClassFieldModifier.New:
return(tokens.Add(SyntaxKind.NewKeyword));
case ClassFieldModifier.NewReadOnly:
return(tokens.AddRange(SyntaxKind.NewKeyword, SyntaxKind.ReadOnlyKeyword));
case ClassFieldModifier.NewStatic:
return(tokens.AddRange(SyntaxKind.NewKeyword, SyntaxKind.StaticKeyword));
case ClassFieldModifier.NewStaticReadOnly:
return(tokens.AddRange(SyntaxKind.NewKeyword, SyntaxKind.StaticKeyword, SyntaxKind.ReadOnlyKeyword));
case ClassFieldModifier.NewStaticVolatile:
return(tokens.AddRange(SyntaxKind.NewKeyword, SyntaxKind.StaticKeyword, SyntaxKind.VolatileKeyword));
case ClassFieldModifier.NewVolatile:
return(tokens.AddRange(SyntaxKind.NewKeyword, SyntaxKind.VolatileKeyword));
case ClassFieldModifier.ReadOnly:
return(tokens.Add(SyntaxKind.ReadOnlyKeyword));
case ClassFieldModifier.Static:
return(tokens.Add(SyntaxKind.StaticKeyword));
case ClassFieldModifier.StaticReadOnly:
return(tokens.AddRange(SyntaxKind.StaticKeyword, SyntaxKind.ReadOnlyKeyword));
case ClassFieldModifier.StaticVolatile:
return(tokens.AddRange(SyntaxKind.StaticKeyword, SyntaxKind.VolatileKeyword));
case ClassFieldModifier.Volatile:
return(tokens.Add(SyntaxKind.VolatileKeyword));
}
return(tokens);
}
public static SyntaxTokenList AddToModifiers(this SyntaxTokenList modifiers, SyntaxKind modifierToAdd)
{
if (modifiers.IndexOf(modifierToAdd) >= 0)
{
return(modifiers);
}
int idx = modifiers.IndexOf(SyntaxKind.PartialKeyword);
return(idx >= 0
? modifiers.Insert(idx, SyntaxFactory.Token(modifierToAdd))
: modifiers.Add(SyntaxFactory.Token(modifierToAdd)));
}
private static SyntaxTokenList AddAsyncModifierWithCorrectedTrivia(SyntaxTokenList modifiers, ref TypeSyntax newReturnType)
{
if (modifiers.Any())
{
return(modifiers.Add(s_asyncToken));
}
// Move the leading trivia from the return type to the new modifiers list.
SyntaxTokenList result = SyntaxFactory.TokenList(s_asyncToken.WithLeadingTrivia(newReturnType.GetLeadingTrivia()));
newReturnType = newReturnType.WithoutLeadingTrivia();
return(result);
}
private static SyntaxTokenList ConvertAccessibility(SyntaxTokenList tokenList, Accessibility accessibity)
{
switch (accessibity)
{
case Accessibility.Public:
return(tokenList.Add(Token(SyntaxKind.PublicKeyword)));
case Accessibility.Private:
return(tokenList.Add(Token(SyntaxKind.PrivateKeyword)));
case Accessibility.Protected:
return(tokenList.Add(Token(SyntaxKind.ProtectedKeyword)));
case Accessibility.Internal:
return(tokenList.Add(Token(SyntaxKind.InternalKeyword)));
case Accessibility.ProtectedOrInternal:
return(tokenList.Add(Token(SyntaxKind.ProtectedKeyword)).Add(Token(SyntaxKind.InternalKeyword)));
default:
throw new ArgumentOutOfRangeException(nameof(accessibity), accessibity, null);
}
}
private MethodDeclarationSyntax BuildImplementationMethod(SemanticModel semanticModel, INamedTypeSymbol declaringType, IPropertySymbol property, AccessorDeclarationSyntax propertyGetter)
{
// by this point we know the getter contains a simple return statement for a field
ExpressionSyntax fieldExpression = ((ReturnStatementSyntax)propertyGetter.Body.Statements[0]).Expression;
IFieldSymbol fieldSymbol = (IFieldSymbol)semanticModel.GetSymbolInfo(fieldExpression).Symbol;
SyntaxList <AttributeListSyntax> attributeLists = SyntaxFactory.List <AttributeListSyntax>();
SyntaxTokenList modifiers = SyntaxFactory.TokenList(
SyntaxFactory.Token(SyntaxKind.ProtectedKeyword),
SyntaxFactory.Token(SyntaxKind.InternalKeyword));
if (!declaringType.IsSealed)
{
modifiers = modifiers.Add(SyntaxFactory.Token(SyntaxKind.VirtualKeyword));
}
TypeSyntax returnType = SyntaxFactory.ParseTypeName(declaringType.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat));
TypeSyntax propertyType = SyntaxFactory.ParseTypeName(property.Type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat));
ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier = null;
SyntaxToken identifier = SyntaxFactory.Identifier($"With{property.Name}Impl");
TypeParameterListSyntax typeParameterList = null;
ParameterListSyntax parameterList = SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList(new[] { SyntaxFactory.Parameter(SyntaxFactory.Identifier("value")).WithType(propertyType) }));
SyntaxList <TypeParameterConstraintClauseSyntax> constraintClauses = SyntaxFactory.List <TypeParameterConstraintClauseSyntax>();
ExpressionSyntax resultInitializerExpression =
SyntaxFactory.CastExpression(returnType, SyntaxFactory.ParseExpression("MemberwiseClone()"));
ExpressionStatementSyntax propertyUpdate =
SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("result"), SyntaxFactory.IdentifierName(fieldSymbol.Name)),
SyntaxFactory.IdentifierName("value")));
ReturnStatementSyntax returnSyntax =
SyntaxFactory.ReturnStatement(SyntaxFactory.IdentifierName("result"));
BlockSyntax body = SyntaxFactory.Block(
SyntaxFactory.LocalDeclarationStatement(SyntaxFactory.VariableDeclaration(returnType).AddVariables(SyntaxFactory.VariableDeclarator("result").WithInitializer(SyntaxFactory.EqualsValueClause(resultInitializerExpression)))),
propertyUpdate,
returnSyntax);
SyntaxToken semicolonToken = default(SyntaxToken);
return(SyntaxFactory.MethodDeclaration(attributeLists, modifiers, returnType, explicitInterfaceSpecifier, identifier, typeParameterList, parameterList, constraintClauses, body, semicolonToken)
.WithAdditionalAnnotations(Simplifier.Annotation));
}
private static MemberDeclarationSyntax MakeAbstract(PropertyDeclarationSyntax propertyDeclaration)
{
if (propertyDeclaration == null)
{
throw new ArgumentNullException(nameof(propertyDeclaration));
}
AccessorListSyntax accessorList = AccessorList();
if (propertyDeclaration.ExpressionBody != null)
{
accessorList = accessorList
.AddAccessors(
AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
.WithSemicolonToken(Token(SyntaxKind.SemicolonToken)));
}
else
{
AccessorDeclarationSyntax getter = propertyDeclaration.Getter();
if (getter != null)
{
accessorList = accessorList.AddAccessors(getter
.WithBody(null)
.WithSemicolonToken(Token(SyntaxKind.SemicolonToken)));
}
AccessorDeclarationSyntax setter = propertyDeclaration.Setter();
if (setter != null)
{
accessorList = accessorList.AddAccessors(setter
.WithBody(null)
.WithSemicolonToken(Token(SyntaxKind.SemicolonToken)));
}
}
SyntaxTokenList modifiers = propertyDeclaration.Modifiers;
if (!modifiers.Contains(SyntaxKind.AbstractKeyword))
{
modifiers = modifiers.Add(Token(SyntaxKind.AbstractKeyword));
}
return(propertyDeclaration
.WithExpressionBody(null)
.WithSemicolonToken(Token(SyntaxKind.None))
.WithAccessorList(accessorList)
.WithModifiers(modifiers));
}
public override VB.VisualBasicSyntaxNode VisitXmlElement(CSS.XmlElementSyntax node)
{
var Content = new SyntaxList <VBS.XmlNodeSyntax>();
VBS.XmlElementStartTagSyntax StartTag = (VBS.XmlElementStartTagSyntax)node.StartTag.Accept(this);
bool NoEndTag = string.IsNullOrWhiteSpace(node.EndTag.Name.LocalName.ValueText);
var EndTag = NoEndTag ? VBFactory.XmlElementEndTag(((VBS.XmlNameSyntax)StartTag.Name)) : VBFactory.XmlElementEndTag((VBS.XmlNameSyntax)node.EndTag.Name.Accept(this));
try
{
for (int i = 0, loopTo = node.Content.Count - 1; i <= loopTo; i++)
{
var C = node.Content[i];
VBS.XmlNodeSyntax Node1 = (VBS.XmlNodeSyntax)C.Accept(this);
if (NoEndTag)
{
var LastToken = Node1.GetLastToken();
if (LastToken.ValueText.IsNewLine())
{
Node1 = Node1.ReplaceToken(LastToken, default(SyntaxToken));
}
}
Content = Content.Add(Node1);
}
if (node.EndTag?.HasLeadingTrivia == true && node.EndTag.GetLeadingTrivia()[0].IsKind(CS.SyntaxKind.DocumentationCommentExteriorTrivia) == true)
{
var NewLeadingTriviaList = new SyntaxTriviaList();
NewLeadingTriviaList = NewLeadingTriviaList.Add(VBFactory.DocumentationCommentExteriorTrivia(node.EndTag.GetLeadingTrivia()[0].ToString().Replace("///", "'''")));
var NewTokenList = new SyntaxTokenList();
NewTokenList = NewTokenList.Add(VBFactory.XmlTextLiteralToken(NewLeadingTriviaList, " ", " ", new SyntaxTriviaList()));
Content = Content.Add(VBFactory.XmlText(NewTokenList));
EndTag = EndTag.WithoutLeadingTrivia();
}
}
catch (OperationCanceledException ex)
{
throw;
}
catch (Exception ex)
{
}
var XmlElement = VBFactory.XmlElement(StartTag, Content, EndTag);
return(XmlElement);
}
private async Task<Document> AddPublicAccessModifierAsync(Document document, InterfaceDeclarationSyntax interfaceDeclaration, CancellationToken cancellationToken)
{
SyntaxTokenList newModifiers = new SyntaxTokenList();
newModifiers = newModifiers.Add(SyntaxFactory.Token(SyntaxKind.PublicKeyword));
newModifiers = newModifiers.AddRange(interfaceDeclaration.Modifiers.Where(x =>
!x.IsKind(SyntaxKind.ProtectedKeyword) &&
!x.IsKind(SyntaxKind.InternalKeyword) &&
!x.IsKind(SyntaxKind.PrivateKeyword))
);
InterfaceDeclarationSyntax newInterfaceDeclaration = interfaceDeclaration.WithModifiers(newModifiers);
SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken);
SyntaxNode newRoot = root.ReplaceNode(interfaceDeclaration, newInterfaceDeclaration);
return document.WithSyntaxRoot(newRoot);
}
private static FieldDeclarationSyntax CreateBackingField(PropertyDeclarationSyntax propertyDeclaration, string name)
{
SyntaxTokenList modifiers = TokenList(PrivateKeyword());
if (propertyDeclaration.IsStatic())
{
modifiers = modifiers.Add(StaticKeyword());
}
return(FieldDeclaration(
default(SyntaxList <AttributeListSyntax>),
modifiers,
VariableDeclaration(
propertyDeclaration.Type,
name,
propertyDeclaration.Initializer)));
}
private static EventFieldDeclarationSyntax MakeAbstract(EventFieldDeclarationSyntax eventDeclaration)
{
if (eventDeclaration == null)
{
throw new ArgumentNullException(nameof(eventDeclaration));
}
SyntaxTokenList modifiers = eventDeclaration.Modifiers;
if (!modifiers.Contains(SyntaxKind.AbstractKeyword))
{
modifiers = modifiers.Add(SyntaxFactory.Token(SyntaxKind.AbstractKeyword));
}
return(eventDeclaration
.WithModifiers(modifiers));
}
private void DoTestAddInsertRemoveReplaceOnEmptyList(SyntaxTokenList list)
{
Assert.Equal(0, list.Count);
var tokenD = SyntaxFactory.ParseToken("D ");
var tokenE = SyntaxFactory.ParseToken("E ");
var newList = list.Add(tokenD);
Assert.Equal(1, newList.Count);
Assert.Equal("D ", newList.ToFullString());
newList = list.AddRange(new[] { tokenD, tokenE });
Assert.Equal(2, newList.Count);
Assert.Equal("D E ", newList.ToFullString());
newList = list.Insert(0, tokenD);
Assert.Equal(1, newList.Count);
Assert.Equal("D ", newList.ToFullString());
newList = list.InsertRange(0, new[] { tokenD, tokenE });
Assert.Equal(2, newList.Count);
Assert.Equal("D E ", newList.ToFullString());
newList = list.Remove(tokenD);
Assert.Equal(0, newList.Count);
Assert.Equal(-1, list.IndexOf(tokenD));
Assert.Throws<ArgumentOutOfRangeException>(() => list.RemoveAt(0));
Assert.Throws<ArgumentOutOfRangeException>(() => list.Insert(1, tokenD));
Assert.Throws<ArgumentOutOfRangeException>(() => list.Insert(-1, tokenD));
Assert.Throws<ArgumentOutOfRangeException>(() => list.InsertRange(-1, new[] { tokenD }));
Assert.Throws<ArgumentOutOfRangeException>(() => list.InsertRange(list.Count + 1, new[] { tokenD }));
Assert.Throws<ArgumentOutOfRangeException>(() => list.Replace(tokenD, tokenE));
Assert.Throws<ArgumentOutOfRangeException>(() => list.ReplaceRange(tokenD, new[] { tokenE }));
Assert.Throws<ArgumentOutOfRangeException>(() => list.Add(default(SyntaxToken)));
Assert.Throws<ArgumentOutOfRangeException>(() => list.Insert(0, default(SyntaxToken)));
Assert.Throws<ArgumentNullException>(() => list.AddRange((IEnumerable<SyntaxToken>)null));
Assert.Throws<ArgumentNullException>(() => list.InsertRange(0, (IEnumerable<SyntaxToken>)null));
}