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)); }