public static void ProcessRightOfAssignmentToField( ISymbol variable, BlockSyntax block, SemanticModel semanticModel, CancellationToken cancellationToken, RefCounterStatus status) { List <AssignmentExpressionSyntax> rc = new List <AssignmentExpressionSyntax>(); block?.TryGetAssignment(variable, semanticModel, cancellationToken, rc); int count = 0; ISymbol field = null; Location loc = Location.None; foreach (AssignmentExpressionSyntax assignment in rc) { var classDef = block.FirstAncestor <ClassDeclarationSyntax>(); var classSymbol = CSharpExtensions.GetDeclaredSymbol(semanticModel, classDef, cancellationToken); if (IsRightOfAssignmentToField(semanticModel, cancellationToken, assignment.Left, out field)) { count++; loc = assignment.GetLocation(); if (!field.ContainingType.Equals(classSymbol)) { status.Skip("assigned to field/property of other class", loc); } if (LoopUtils.HasLoopBetween(assignment, block)) { status.Skip("loop between assignment to field/property and var block", loc); } } } if (count == 1) { status.ReleaseReference("assign to class field/property", loc); var methodBlock = block?.FirstAncestorOrSelf <BlockSyntax>(); if (methodBlock == null) { return; } if (RightSideOfAssignmentCount(field, methodBlock, semanticModel, cancellationToken) > 0) { status.Skip("var assigned to field/property, which is assigned to others", loc); } ChangeReferenceMethodUtils.ProcessIncDelRefInvocation(field, methodBlock, semanticModel, cancellationToken, status); ReturnUtils.ProcessReturnStatement(field, methodBlock, semanticModel, cancellationToken, status); } else if (count > 1) { status.Skip("multiple assign to field/property", loc); } }
public AccessorBlockSyntax ConvertAccessor(AccessorDeclarationSyntax node, out bool isIterator) { SyntaxKind blockKind; AccessorStatementSyntax stmt; EndBlockStatementSyntax endStmt; SyntaxList <StatementSyntax> body; isIterator = false; var isIteratorState = new MethodBodyVisitor(_semanticModel, _nodesVisitor, _triviaConverter, this); body = ConvertBody(node.Body, node.ExpressionBody, isIteratorState); isIterator = isIteratorState.IsIterator; var attributes = SyntaxFactory.List(node.AttributeLists.Select(a => (AttributeListSyntax)a.Accept(_nodesVisitor))); var modifiers = ConvertModifiers(node.Modifiers, SyntaxKindExtensions.TokenContext.Local); var parent = (BasePropertyDeclarationSyntax)node.Parent.Parent; Microsoft.CodeAnalysis.VisualBasic.Syntax.ParameterSyntax valueParam; switch (CSharpExtensions.Kind(node)) { case Microsoft.CodeAnalysis.CSharp.SyntaxKind.GetAccessorDeclaration: blockKind = SyntaxKind.GetAccessorBlock; stmt = SyntaxFactory.GetAccessorStatement(attributes, modifiers, null); endStmt = SyntaxFactory.EndGetStatement(); break; case Microsoft.CodeAnalysis.CSharp.SyntaxKind.SetAccessorDeclaration: blockKind = SyntaxKind.SetAccessorBlock; valueParam = SyntaxFactory.Parameter(SyntaxFactory.ModifiedIdentifier("value")) .WithAsClause(SyntaxFactory.SimpleAsClause((TypeSyntax)parent.Type.Accept(_nodesVisitor))) .WithModifiers(SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.ByValKeyword))); stmt = SyntaxFactory.SetAccessorStatement(attributes, modifiers, SyntaxFactory.ParameterList(SyntaxFactory.SingletonSeparatedList(valueParam))); endStmt = SyntaxFactory.EndSetStatement(); break; case Microsoft.CodeAnalysis.CSharp.SyntaxKind.AddAccessorDeclaration: blockKind = SyntaxKind.AddHandlerAccessorBlock; valueParam = SyntaxFactory.Parameter(SyntaxFactory.ModifiedIdentifier("value")) .WithAsClause(SyntaxFactory.SimpleAsClause((TypeSyntax)parent.Type.Accept(_nodesVisitor))) .WithModifiers(SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.ByValKeyword))); stmt = SyntaxFactory.AddHandlerAccessorStatement(attributes, modifiers, SyntaxFactory.ParameterList(SyntaxFactory.SingletonSeparatedList(valueParam))); endStmt = SyntaxFactory.EndAddHandlerStatement(); break; case Microsoft.CodeAnalysis.CSharp.SyntaxKind.RemoveAccessorDeclaration: blockKind = SyntaxKind.RemoveHandlerAccessorBlock; valueParam = SyntaxFactory.Parameter(SyntaxFactory.ModifiedIdentifier("value")) .WithAsClause(SyntaxFactory.SimpleAsClause((TypeSyntax)parent.Type.Accept(_nodesVisitor))) .WithModifiers(SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.ByValKeyword))); stmt = SyntaxFactory.RemoveHandlerAccessorStatement(attributes, modifiers, SyntaxFactory.ParameterList(SyntaxFactory.SingletonSeparatedList(valueParam))); endStmt = SyntaxFactory.EndRemoveHandlerStatement(); break; default: throw new NotSupportedException(); } return(SyntaxFactory.AccessorBlock(blockKind, stmt, body, endStmt)); }
public static SyntaxTokenList GetModifiers(this CSharpSyntaxNode member) { if (member != null) { switch (CSharpExtensions.Kind(member)) { case CSSyntaxKind.EnumDeclaration: return(((EnumDeclarationSyntax)member).Modifiers); case CSSyntaxKind.ClassDeclaration: case CSSyntaxKind.InterfaceDeclaration: case CSSyntaxKind.StructDeclaration: return(((TypeDeclarationSyntax)member).Modifiers); case CSSyntaxKind.DelegateDeclaration: return(((DelegateDeclarationSyntax)member).Modifiers); case CSSyntaxKind.FieldDeclaration: return(((FieldDeclarationSyntax)member).Modifiers); case CSSyntaxKind.EventFieldDeclaration: return(((EventFieldDeclarationSyntax)member).Modifiers); case CSSyntaxKind.ConstructorDeclaration: return(((ConstructorDeclarationSyntax)member).Modifiers); case CSSyntaxKind.DestructorDeclaration: return(((DestructorDeclarationSyntax)member).Modifiers); case CSSyntaxKind.PropertyDeclaration: return(((PropertyDeclarationSyntax)member).Modifiers); case CSSyntaxKind.EventDeclaration: return(((EventDeclarationSyntax)member).Modifiers); case CSSyntaxKind.IndexerDeclaration: return(((IndexerDeclarationSyntax)member).Modifiers); case CSSyntaxKind.OperatorDeclaration: return(((OperatorDeclarationSyntax)member).Modifiers); case CSSyntaxKind.ConversionOperatorDeclaration: return(((ConversionOperatorDeclarationSyntax)member).Modifiers); case CSSyntaxKind.MethodDeclaration: return(((MethodDeclarationSyntax)member).Modifiers); case CSSyntaxKind.GetAccessorDeclaration: case CSSyntaxKind.SetAccessorDeclaration: case CSSyntaxKind.AddAccessorDeclaration: case CSSyntaxKind.RemoveAccessorDeclaration: return(((AccessorDeclarationSyntax)member).Modifiers); } } return(default(SyntaxTokenList)); }
/// <summary> /// Returns all of the trivia to the left of this token up to the previous token (concatenates /// the previous token's trailing trivia and this token's leading trivia). /// </summary> public static IEnumerable <SyntaxTrivia> GetAllPrecedingTriviaToPreviousToken(this SyntaxToken token) { var prevToken = token.GetPreviousToken(includeSkipped: true); if (CSharpExtensions.Kind(prevToken) == CSSyntaxKind.None) { return(token.LeadingTrivia); } return(prevToken.TrailingTrivia.Concat(token.LeadingTrivia)); }
public static bool IsKind(this SyntaxNode node, CSSyntaxKind kind1, CSSyntaxKind kind2, CSSyntaxKind kind3, CSSyntaxKind kind4, CSSyntaxKind kind5) { if (node == null) { return(false); } var csharpKind = CSharpExtensions.Kind(node); return(csharpKind == kind1 || csharpKind == kind2 || csharpKind == kind3 || csharpKind == kind4 || csharpKind == kind5); }
public static bool IsContinuableConstruct(this SyntaxNode node) { switch (CSharpExtensions.Kind(node)) { case CSSyntaxKind.DoStatement: case CSSyntaxKind.WhileStatement: case CSSyntaxKind.ForStatement: case CSSyntaxKind.ForEachStatement: return(true); } return(false); }
private static string ConvertStopOrEndToCSharpStatementText(VBSyntax.StopOrEndStatementSyntax node) { switch (VBasic.VisualBasicExtensions.Kind(node.StopOrEndKeyword)) { case VBasic.SyntaxKind.StopKeyword: return("System.Diagnostics.Debugger.Break();"); case VBasic.SyntaxKind.EndKeyword: return("System.Environment.Exit(0);"); default: throw new NotImplementedException(CSharpExtensions.Kind(node.StopOrEndKeyword) + " not implemented!"); } }
public SyntaxToken ConvertIdentifier(SyntaxToken id) { CSharpSyntaxNode parent = (CSharpSyntaxNode)id.Parent; var idText = IsEventHandlerIdentifier(parent) && !IsEventHandlerAssignLhs(parent) ? id.ValueText + "Event" : id.ValueText; // Underscore is a special character in VB lexer which continues lines - not sure where to find the whole set of other similar tokens if any // Rather than a complicated contextual rename, just add an extra dash to all identifiers and hope this method is consistently used bool keywordRequiresEscaping = id.IsKind(CSSyntaxKind.IdentifierToken) && KeywordRequiresEscaping(id); switch (CSharpExtensions.Kind(id)) { case CSSyntaxKind.GlobalKeyword: idText = "Global"; break; } return(Identifier(idText, keywordRequiresEscaping)); }
public static bool IsReturnableConstruct(this SyntaxNode node) { switch (CSharpExtensions.Kind(node)) { case CSSyntaxKind.AnonymousMethodExpression: case CSSyntaxKind.SimpleLambdaExpression: case CSSyntaxKind.ParenthesizedLambdaExpression: case CSSyntaxKind.MethodDeclaration: case CSSyntaxKind.ConstructorDeclaration: case CSSyntaxKind.DestructorDeclaration: case CSSyntaxKind.GetAccessorDeclaration: case CSSyntaxKind.SetAccessorDeclaration: case CSSyntaxKind.OperatorDeclaration: case CSSyntaxKind.AddAccessorDeclaration: case CSSyntaxKind.RemoveAccessorDeclaration: return(true); } return(false); }
public SyntaxToken ConvertIdentifier(SyntaxToken id) { var parent = (CS.CSharpSyntaxNode)id.Parent; var idText = AdjustIfEventIdentifier(id, parent); // Underscore is a special character in VB lexer which continues lines - not sure where to find the whole set of other similar tokens if any // Rather than a complicated contextual rename, just add an extra dash to all identifiers and hope this method is consistently used bool keywordRequiresEscaping = id.IsKind(CSSyntaxKind.IdentifierToken) && KeywordRequiresEscaping(id); switch (CSharpExtensions.Kind(id)) { case CSSyntaxKind.GlobalKeyword: idText = "Global"; break; case CSSyntaxKind.ThisKeyword: idText = "Item"; break; } return(Identifier(idText, keywordRequiresEscaping).WithSourceMappingFrom(id)); }
public static bool IsKind(this SyntaxToken token, params SyntaxKind[] kinds) { return(kinds.Contains(CSharpExtensions.Kind(token))); }
private static SyntaxToken?ConvertModifier(SyntaxToken m, SyntaxKindExtensions.TokenContext context = SyntaxKindExtensions.TokenContext.Global) { var token = CSharpExtensions.Kind(m).ConvertToken(context); return(token == SyntaxKind.None ? null : new SyntaxToken?(SyntaxFactory.Token(token))); }
public static bool IsKind(this SyntaxToken token, SyntaxKind kind1, SyntaxKind kind2, SyntaxKind kind3) { return(CSharpExtensions.Kind(token) == kind1 || CSharpExtensions.Kind(token) == kind2 || CSharpExtensions.Kind(token) == kind3); }
static SyntaxTokenList ConvertModifiers(SyntaxTokenList modifiers, TokenContext context = SyntaxKindExtensions.TokenContext.Global) { return(SyntaxFactory.TokenList(ConvertModifiersCore(modifiers, context).Where(t => CSharpExtensions.Kind(t) != SyntaxKind.None))); }
private IEnumerable <SyntaxInfo> GetSyntaxInfos(int lineInfoOffset = 0) { #if DEBUG _debugFn?.Invoke($"{nameof(GetSyntaxInfos)} [{lineInfoOffset}]", 5); #endif SyntaxToken token1; if (lineInfoOffset != 0) { if (lineInfoOffset < Length) { var child = Node.ChildThatContainsPosition(lineInfoOffset); if (child.SpanStart > lineInfoOffset) { if (child.HasLeadingTrivia) { foreach (var syntaxTrivia in child.GetLeadingTrivia()) { yield return(new SyntaxInfo(syntaxTrivia, Node)); } } } // ReSharper disable once PossibleNullReferenceException token1 = child.IsToken ? child.AsToken() : child.AsNode().GetFirstToken(); } else { yield break; } } else { if (Node == null) { yield break; } if (Node.HasLeadingTrivia) { foreach (var syntaxTrivia in Node.GetLeadingTrivia()) { yield return(new SyntaxInfo(syntaxTrivia, Node)); } } token1 = Node.GetFirstToken(); } // ReSharper disable once InvokeAsExtensionMethod while (CSharpExtensions.Kind(token1) != SyntaxKind.None) { // ReSharper disable once InvokeAsExtensionMethod if (CSharpExtensions.Kind(token1) == SyntaxKind.EndOfFileToken) { yield break; } yield return(new SyntaxInfo(token1)); if (token1.HasTrailingTrivia) { foreach (var syntaxTrivia in token1.TrailingTrivia) { // ReSharper disable once ConditionIsAlwaysTrueOrFalse if (false && syntaxTrivia.IsPartOfStructuredTrivia()) // ReSharper disable once HeuristicUnreachableCode { var syntaxNode = syntaxTrivia.GetStructure(); var n = syntaxTrivia.Token.Parent; if (n is StructuredTriviaSyntax sn) { var trail = sn.GetTrailingTrivia(); } // while (syntaxNode == null) // { // syntaxNode = n.ParentTrivia; // } // syntaxNode = syntaxTrivia.GetStructure(); var token2 = syntaxNode.GetFirstToken(true, true, true, true); while (CSharpExtensions.Kind(token2) != SyntaxKind.None) { if (token2.HasLeadingTrivia) { foreach (var syntaxTrivia2 in token2.LeadingTrivia) { yield return new SyntaxInfo(syntaxTrivia2, token2, TriviaPosition.Leading) { StructuredTrivia = syntaxNode } } } ; yield return(new SyntaxInfo(token2) { StructuredTrivia = syntaxNode }); if (token2.HasTrailingTrivia) { foreach (var syntaxTrivia2 in token2.TrailingTrivia) { yield return new SyntaxInfo(syntaxTrivia2, token2, TriviaPosition.Trailing) { StructuredTrivia = syntaxNode } } } ; token2 = token2.GetNextToken(true, true, true, true); } } else { yield return(new SyntaxInfo(syntaxTrivia, token1, TriviaPosition.Trailing)); } } } token1 = token1.GetNextToken(true, true, true, true); if (token1.HasLeadingTrivia) { foreach (var syntaxTrivia in token1.LeadingTrivia) { // if (syntaxTrivia.IsPartOfStructuredTrivia()) // { // var token2 = syntaxTrivia.GetStructure().GetFirstToken(true, true, true, true); // while (CSharpExtensions.Kind(token2) != SyntaxKind.None) // { // if (token2.HasLeadingTrivia) // { // foreach (var syntaxTrivia2 in token2.LeadingTrivia) // { // yield return new SyntaxInfo(syntaxTrivia2); // } // } // yield return new SyntaxInfo(token2); // if (token2.HasTrailingTrivia) // { // foreach (var syntaxTrivia2 in token2.TrailingTrivia) // { // yield return new SyntaxInfo(syntaxTrivia2); // } // } // token2 = token2.GetNextToken(true, true, true, true); // } // } // else // { yield return(new SyntaxInfo(syntaxTrivia, token1, TriviaPosition.Leading)); } } // } } }
private TextRun _GetTextRun(int textSourceCharacterIndex) { _charIndex = textSourceCharacterIndex; _debugFn?.Invoke($"GetTextRun(textSourceCharacterIndex = {textSourceCharacterIndex})", 5); if (textSourceCharacterIndex == 0) { #if DEBUG _debugFn?.Invoke($"Clearing runs because at beginning of text source", 4); #endif Runs.Clear(); SyntaxInfos = GetSyntaxInfos().GetEnumerator(); if (!SyntaxInfos.MoveNext()) { var endOfParagraph = new CustomTextEndOfParagraph(2) { Index = textSourceCharacterIndex }; Runs.Add(endOfParagraph); return(endOfParagraph); } } else { #if DEBUGRUNS foreach (var textRun in Runs) { _debugFn?.Invoke(" " + textRun.ToString(), 4); } #endif Runs = RunsBefore(textSourceCharacterIndex, Runs).ToList(); } var si = SyntaxInfos.Current; if (si == null) { var endOfParagraph = new CustomTextEndOfParagraph(2) { Index = textSourceCharacterIndex }; Runs.Add(endOfParagraph); return(endOfParagraph); } // ReSharper disable once PossibleNullReferenceException while (textSourceCharacterIndex > si.Span1.Start || /*|| si.Span1.End < textSourceCharacterIndex*/ si.Text.Length == 0) { if (!SyntaxInfos.MoveNext()) { if (textSourceCharacterIndex < Length) { var len = Length - textSourceCharacterIndex; var buf = new char[len]; Text.CopyTo(textSourceCharacterIndex, buf, 0, len); if (len == 2 && buf[0] == '\r' && buf[1] == '\n') { var eol = new CustomTextEndOfLine(2) { Index = textSourceCharacterIndex }; Runs.Add(eol); return(eol); } var t = string.Join("", buf); var customTextCharacters = new CustomTextCharacters(t, MakeProperties(SyntaxKind.None, t)) { Index = textSourceCharacterIndex }; Runs.Add(customTextCharacters); return(customTextCharacters); } var endOfParagraph = new CustomTextEndOfParagraph(2) { Index = textSourceCharacterIndex }; Runs.Add(endOfParagraph); return(endOfParagraph); } si = SyntaxInfos.Current; } if (textSourceCharacterIndex < si.Span1.Start) { var len = si.Span1.Start - textSourceCharacterIndex; var buf = new char[len]; Text.CopyTo(textSourceCharacterIndex, buf, 0, len); if (len == 2 && buf[0] == '\r' && buf[1] == '\n') { var eol = new CustomTextEndOfLine(2) { Index = textSourceCharacterIndex }; Runs.Add(eol); return(eol); } var t = string.Join("", buf); var nl = t.IndexOf("\r\n", StringComparison.Ordinal); if (nl != -1) { t = t.Substring(0, nl); if (t == "") { var eol = new CustomTextEndOfLine(2) { Index = textSourceCharacterIndex }; Runs.Add(eol); return(eol); } var ctc = new CustomTextCharacters(t, MakeProperties(SyntaxKind.None, t)) { Index = textSourceCharacterIndex }; Runs.Add(ctc); return(ctc); } var customTextCharacters = new CustomTextCharacters(t, MakeProperties(SyntaxKind.None, t)) { Index = textSourceCharacterIndex }; Runs.Add(customTextCharacters); return(customTextCharacters); } // while (textSourceCharacterIndex > si.Span1.Start) // { // if (!SyntaxInfos.MoveNext()) // { // } // } if (textSourceCharacterIndex != si.Span1.Start) { throw new InvalidOperationException("Character index does not match span start"); } if (si.SyntaxTrivia.HasValue) { var syntaxKind = CSharpExtensions.Kind(si.SyntaxTrivia.Value); if (syntaxKind == SyntaxKind.EndOfLineTrivia || syntaxKind == SyntaxKind.XmlTextLiteralNewLineToken) { var customTextEndOfLine = new CustomTextEndOfLine(2) { Index = textSourceCharacterIndex }; Runs.Add(customTextEndOfLine); return(customTextEndOfLine); } var p = PropsFor(si.SyntaxTrivia.Value, si.Text); var syntaxTriviaTextCharacters = new SyntaxTriviaTextCharacters(si.Text, p, si.Span1, si.SyntaxTrivia.Value, si.Node, si.Token, si.TriviaPosition, si.StructuredTrivia) { Index = si.Span1.Start }; Runs.Add(syntaxTriviaTextCharacters); return(syntaxTriviaTextCharacters); } if (si.SyntaxToken.HasValue) { if (CSharpExtensions.Kind(si.SyntaxToken.Value) == SyntaxKind.XmlTextLiteralNewLineToken) { var customTextEndOfLine = new CustomTextEndOfLine(2) { Index = textSourceCharacterIndex }; Runs.Add(customTextEndOfLine); return(customTextEndOfLine); } var syntaxTokenTextCharacters = new SyntaxTokenTextCharacters(si.Text, si.Text.Length, PropsFor(si.SyntaxToken.Value, si.Text), si.SyntaxToken.Value, si.SyntaxToken.Value.Parent) { Index = si.Span1.Start }; Runs.Add(syntaxTokenTextCharacters); return(syntaxTokenTextCharacters); } var textEndOfParagraph = new CustomTextEndOfParagraph(2) { Index = textSourceCharacterIndex }; Runs.Add(textEndOfParagraph); return(textEndOfParagraph); #if false Debug.WriteLine($"index: {textSourceCharacterIndex}"); TextSpan?TakeToken() { var includeDocumentationComments = true; var includeDirectives = true; var includeSkipped = true; var includeZeroWidth = true; token = token.HasValue ? token.Value.GetNextToken(includeZeroWidth, includeSkipped, includeDirectives, includeDocumentationComments) : Node?.GetFirstToken(includeZeroWidth, includeSkipped, includeDirectives, includeDocumentationComments); if (token.HasValue) { if (!_starts.Any() && token.Value.SpanStart != 0) { } var tuple = new StartInfo(token.Value.Span, token.Value); _starts.Add(tuple); DumpStarts(); return(token.Value.Span); } return(null); } TextSpan?span = null; if (textSourceCharacterIndex == 0) { if (Length == 0) { return(new TextEndOfParagraph(2)); } _curStart = 0; if (_starts.Any()) { var startInfo = _starts.First(); token = startInfo.Token; trivia = startInfo.SyntaxTrivia; span = startInfo.TextSpan; if (token.HasValue) { CheckToken(token); } } // _starts.Clear(); DumpStarts(); } else { var startInfo = _starts[_curStart]; token = startInfo.Token; trivia = startInfo.SyntaxTrivia; span = startInfo.TextSpan; if (token.HasValue) { CheckToken(token); } } try { var childInPos = Node.ChildThatContainsPosition(textSourceCharacterIndex); if (childInPos.IsNode) { var n = childInPos.AsNode(); if (textSourceCharacterIndex < n.SpanStart) { foreach (var syntaxTrivia in n.GetLeadingTrivia()) { if (textSourceCharacterIndex >= syntaxTrivia.SpanStart && textSourceCharacterIndex < syntaxTrivia.Span.End) { Debug.WriteLine("In trivia " + syntaxTrivia); if (textSourceCharacterIndex > syntaxTrivia.SpanStart) { Debug.WriteLine("In middle of trivia"); } var characterString = syntaxTrivia.ToFullString(); return(new SyntaxTriviaTextCharacters(characterString, PropsFor(syntaxTrivia, characterString), syntaxTrivia.FullSpan, syntaxTrivia, null, null, TriviaPosition.Leading)); } } } } } catch (Exception ex) { } var token1 = token; // Debug.WriteLine("Index = " + textSourceCharacterIndex); // if (!token1.HasValue) // { // span = TakeToken(); // if (!this.token.HasValue) return new TextEndOfParagraph(2); // token1 = this.token; // } // var token = token1.Value; if (!span.HasValue) { throw new InvalidOperationException(); } var k = span.Value; if (textSourceCharacterIndex < k.Start) { var len = k.Start - textSourceCharacterIndex; var buf = new char[len]; Text.CopyTo(textSourceCharacterIndex, buf, 0, len); if (len == 2 && buf[0] == '\r' && buf[1] == '\n') { return(new CustomTextEndOfLine(2)); } var t = string.Join("", buf); return(new CustomTextCharacters(t, MakeProperties(SyntaxKind.None, t))); } else if (textSourceCharacterIndex >= k.End && k.Length != 0) { TakeToken(); return(GetTextRun(textSourceCharacterIndex)); } else { if (trivia.HasValue) { var syntaxTrivia1 = trivia.Value; var q = syntaxTrivia1.Token.LeadingTrivia .SkipWhile(syntaxTrivia => syntaxTrivia != syntaxTrivia1) .Skip(1); if (q.Any()) { _curStart++; var startInfo = new StartInfo(q.First()); if (_starts.Count <= _curStart) { _starts.Add(startInfo); } else { _starts[_curStart] = startInfo; } } else { var t2 = syntaxTrivia1.Token.GetNextToken(true, true, true, true); if (t2.HasLeadingTrivia) { var st = new StartInfo(t2.LeadingTrivia.First()); _curStart++; if (_starts.Count <= _curStart) { _starts.Add(st); } else { _starts[_curStart] = st; } } else if (CSharpExtensions.Kind(t2) != SyntaxKind.None) { var st = new StartInfo(t2.Span, t2); _curStart++; if (_starts.Count <= _curStart) { _starts.Add(st); } else { _starts[_curStart] = st; } } } var t = syntaxTrivia1.ToFullString(); return(new SyntaxTriviaTextCharacters(t, PropsFor(trivia.Value, t), span.Value, syntaxTrivia1, null, null, TriviaPosition.Leading)); } if (token.HasValue && (CSharpExtensions.Kind(token.Value) == SyntaxKind.None || CSharpExtensions.Kind(token.Value) == SyntaxKind.EndOfFileToken)) { return(new TextEndOfParagraph(2)); } var token0 = token.Value; if (CSharpExtensions.Kind(token0) == SyntaxKind.EndOfLineTrivia) { return(new CustomTextEndOfLine(2)); } var len = k.Length; if (len == 0) { TakeToken(); return(GetTextRun(textSourceCharacterIndex)); } TakeToken(); if (token0.Text.Length != len) { } return(new CustomTextCharacters(token0.Text, MakeProperties(token, token0.Text))); } #endif }
public SyntaxTokenList ConvertModifiers(IEnumerable <SyntaxToken> modifiers, TokenContext context = TokenContext.Global, bool isVariableOrConst = false) { return(SyntaxFactory.TokenList(ConvertModifiersCore(modifiers, context, isVariableOrConst).Where(t => CSharpExtensions.Kind(t) != Microsoft.CodeAnalysis.CSharp.SyntaxKind.None))); }
public AccessorBlockSyntax ConvertAccessor(CSS.AccessorDeclarationSyntax node, out bool isIterator, bool isAutoImplementedProperty = false) { SyntaxKind blockKind; AccessorStatementSyntax stmt; EndBlockStatementSyntax endStmt; SyntaxList <StatementSyntax> body; isIterator = false; var accesorKind = CSharpExtensions.Kind(node); var isIteratorState = new MethodBodyExecutableStatementVisitor(_semanticModel, _nodesVisitor, this); body = ConvertBody(node.Body, node.ExpressionBody, accesorKind == CSSyntaxKind.GetAccessorDeclaration, isIteratorState); isIterator = isIteratorState.IsIterator; var attributes = SyntaxFactory.List(node.AttributeLists.Select(a => (AttributeListSyntax)a.Accept(_nodesVisitor))); var modifiers = ConvertModifiers(node.Modifiers, TokenContext.Local); var parent = (CSS.BasePropertyDeclarationSyntax)node.Parent.Parent; Microsoft.CodeAnalysis.VisualBasic.Syntax.ParameterSyntax valueParam; switch (accesorKind) { case CSSyntaxKind.GetAccessorDeclaration: blockKind = SyntaxKind.GetAccessorBlock; stmt = SyntaxFactory.GetAccessorStatement(attributes, modifiers, null); endStmt = SyntaxFactory.EndGetStatement(); if (isAutoImplementedProperty) { body = body.Count > 0 ? body : SyntaxFactory.SingletonList((StatementSyntax)SyntaxFactory.ReturnStatement(SyntaxFactory.IdentifierName(GetVbPropertyBackingFieldName(parent)))); } break; case CSSyntaxKind.SetAccessorDeclaration: blockKind = SyntaxKind.SetAccessorBlock; valueParam = SyntaxFactory.Parameter(SyntaxFactory.ModifiedIdentifier("value")) .WithAsClause(SyntaxFactory.SimpleAsClause((TypeSyntax)parent.Type.Accept(_nodesVisitor, false))) .WithModifiers(SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.ByValKeyword))); stmt = SyntaxFactory.SetAccessorStatement(attributes, modifiers, SyntaxFactory.ParameterList(SyntaxFactory.SingletonSeparatedList(valueParam))); endStmt = SyntaxFactory.EndSetStatement(); if (isAutoImplementedProperty) { body = body.Count > 0 ? body : SyntaxFactory.SingletonList((StatementSyntax)SyntaxFactory.AssignmentStatement(SyntaxKind.SimpleAssignmentStatement, SyntaxFactory.IdentifierName(GetVbPropertyBackingFieldName(parent)), SyntaxFactory.Token(VBUtil.GetExpressionOperatorTokenKind(SyntaxKind.SimpleAssignmentStatement)), SyntaxFactory.IdentifierName("value") )); } break; case CSSyntaxKind.AddAccessorDeclaration: blockKind = SyntaxKind.AddHandlerAccessorBlock; valueParam = SyntaxFactory.Parameter(SyntaxFactory.ModifiedIdentifier("value")) .WithAsClause(SyntaxFactory.SimpleAsClause((TypeSyntax)parent.Type.Accept(_nodesVisitor, false))) .WithModifiers(SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.ByValKeyword))); stmt = SyntaxFactory.AddHandlerAccessorStatement(attributes, modifiers, SyntaxFactory.ParameterList(SyntaxFactory.SingletonSeparatedList(valueParam))); endStmt = SyntaxFactory.EndAddHandlerStatement(); break; case CSSyntaxKind.RemoveAccessorDeclaration: blockKind = SyntaxKind.RemoveHandlerAccessorBlock; valueParam = SyntaxFactory.Parameter(SyntaxFactory.ModifiedIdentifier("value")) .WithAsClause(SyntaxFactory.SimpleAsClause((TypeSyntax)parent.Type.Accept(_nodesVisitor, false))) .WithModifiers(SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.ByValKeyword))); stmt = SyntaxFactory.RemoveHandlerAccessorStatement(attributes, modifiers, SyntaxFactory.ParameterList(SyntaxFactory.SingletonSeparatedList(valueParam))); endStmt = SyntaxFactory.EndRemoveHandlerStatement(); break; default: throw new NotSupportedException(); } return(SyntaxFactory.AccessorBlock(blockKind, stmt, body, endStmt).WithCsSourceMappingFrom(node)); }