|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using System.Collections.Immutable;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis.Indentation;
using Microsoft.CodeAnalysis.LanguageService;
using Microsoft.CodeAnalysis.Shared.Extensions;
using Microsoft.CodeAnalysis.Text;
using Roslyn.Utilities;
namespace Microsoft.CodeAnalysis.BraceCompletion
{
internal abstract class AbstractBraceCompletionService : IBraceCompletionService
{
protected abstract ISyntaxFacts SyntaxFacts { get; }
protected abstract char OpeningBrace { get; }
protected abstract char ClosingBrace { get; }
/// <summary>
/// Whether or not this brace completion session actually needs semantics to work (and thus should get a semantic model).
/// </summary>
protected virtual bool NeedsSemantics => false;
/// <summary>
/// Returns if the token is a valid opening token kind for this brace completion service.
/// </summary>
protected abstract bool IsValidOpeningBraceToken(SyntaxToken token);
/// <summary>
/// Returns if the token is a valid closing token kind for this brace completion service.
/// </summary>
protected abstract bool IsValidClosingBraceToken(SyntaxToken token);
public abstract bool AllowOverType(BraceCompletionContext braceCompletionContext, CancellationToken cancellationToken);
public Task<bool> HasBraceCompletionAsync(BraceCompletionContext context, Document document, CancellationToken cancellationToken)
{
if (!context.HasCompletionForOpeningBrace(OpeningBrace))
{
return Task.FromResult(false);
}
var openingToken = context.GetOpeningToken();
if (!NeedsSemantics)
{
return Task.FromResult(IsValidOpenBraceTokenAtPosition(context.Document.Text, openingToken, context.OpeningPoint));
}
// Pass along a document with frozen partial semantics. Brace completion is a highly latency sensitive
// operation. We don't want to wait on things like source generators to figure things out.
return IsValidOpenBraceTokenAtPositionAsync(document.WithFrozenPartialSemantics(cancellationToken), openingToken, context.OpeningPoint, cancellationToken);
}
public BraceCompletionResult GetBraceCompletion(BraceCompletionContext context)
{
Debug.Assert(context.HasCompletionForOpeningBrace(OpeningBrace));
var closingPoint = context.ClosingPoint;
var braceTextEdit = new TextChange(TextSpan.FromBounds(closingPoint, closingPoint), ClosingBrace.ToString());
// The caret location should be in between the braces.
var originalOpeningLinePosition = context.Document.Text.Lines.GetLinePosition(context.OpeningPoint);
var caretLocation = new LinePosition(originalOpeningLinePosition.Line, originalOpeningLinePosition.Character + 1);
return new BraceCompletionResult(ImmutableArray.Create(braceTextEdit), caretLocation);
}
public virtual BraceCompletionResult? GetTextChangesAfterCompletion(BraceCompletionContext braceCompletionContext, IndentationOptions options, CancellationToken cancellationToken)
=> null;
public virtual BraceCompletionResult? GetTextChangeAfterReturn(BraceCompletionContext braceCompletionContext, IndentationOptions options, CancellationToken cancellationToken)
=> null;
public virtual bool CanProvideBraceCompletion(char brace, int openingPosition, ParsedDocument document, CancellationToken cancellationToken)
{
if (OpeningBrace != brace)
{
return false;
}
// check that the user is not typing in a string literal or comment
var syntaxFactsService = document.LanguageServices.GetRequiredService<ISyntaxFactsService>();
return !syntaxFactsService.IsInNonUserCode(document.SyntaxTree, openingPosition, cancellationToken);
}
public BraceCompletionContext? GetCompletedBraceContext(ParsedDocument document, int caretLocation)
{
var leftToken = document.Root.FindTokenOnLeftOfPosition(caretLocation);
var rightToken = document.Root.FindTokenOnRightOfPosition(caretLocation);
if (IsValidOpeningBraceToken(leftToken) && IsValidClosingBraceToken(rightToken))
{
return new BraceCompletionContext(document, leftToken.GetLocation().SourceSpan.Start, rightToken.GetLocation().SourceSpan.End, caretLocation);
}
return null;
}
/// <summary>
/// Only called if <see cref="NeedsSemantics"/> returns true;
/// </summary>
protected virtual Task<bool> IsValidOpenBraceTokenAtPositionAsync(Document document, SyntaxToken token, int position, CancellationToken cancellationToken)
{
// Subclass should have overridden this.
throw ExceptionUtilities.Unreachable();
}
/// <summary>
/// Checks if the already inserted token is a valid opening token at the position in the document.
/// By default checks that the opening token is a valid token at the position and not in skipped token trivia.
/// </summary>
protected virtual bool IsValidOpenBraceTokenAtPosition(SourceText text, SyntaxToken token, int position)
=> token.SpanStart == position && IsValidOpeningBraceToken(token) && !ParentIsSkippedTokensTriviaOrNull(this.SyntaxFacts, token);
/// <summary>
/// Returns true when the current position is inside user code (e.g. not strings) and the closing token
/// matches the expected closing token for this brace completion service.
/// Helper method used by <see cref="AllowOverType(BraceCompletionContext, CancellationToken)"/> implementations.
/// </summary>
protected bool AllowOverTypeInUserCodeWithValidClosingToken(BraceCompletionContext context, CancellationToken cancellationToken)
{
var tree = context.Document.SyntaxTree;
var syntaxFactsService = context.Document.LanguageServices.GetRequiredService<ISyntaxFactsService>();
return !syntaxFactsService.IsInNonUserCode(tree, context.CaretLocation, cancellationToken)
&& CheckClosingTokenKind(context.Document, context.ClosingPoint);
}
/// <summary>
/// Returns true when the closing token matches the expected closing token for this brace completion service.
/// Used by <see cref="AllowOverType(BraceCompletionContext, CancellationToken)"/> implementations
/// when the over type could be triggered from outside of user code (e.g. overtyping end quotes in a string).
/// </summary>
protected bool AllowOverTypeWithValidClosingToken(BraceCompletionContext context)
{
return CheckClosingTokenKind(context.Document, context.ClosingPoint);
}
protected static bool ParentIsSkippedTokensTriviaOrNull(ISyntaxFacts syntaxFacts, SyntaxToken token)
=> token.Parent == null || syntaxFacts.IsSkippedTokensTrivia(token.Parent);
/// <summary>
/// Checks that the token at the closing position is a valid closing token.
/// </summary>
private bool CheckClosingTokenKind(ParsedDocument document, int closingPosition)
{
var closingToken = document.Root.FindTokenFromEnd(closingPosition, includeZeroWidth: false, findInsideTrivia: true);
return IsValidClosingBraceToken(closingToken);
}
public static class CurlyBrace
{
public const char OpenCharacter = '{';
public const char CloseCharacter = '}';
}
public static class Parenthesis
{
public const char OpenCharacter = '(';
public const char CloseCharacter = ')';
}
public static class Bracket
{
public const char OpenCharacter = '[';
public const char CloseCharacter = ']';
}
public static class LessAndGreaterThan
{
public const char OpenCharacter = '<';
public const char CloseCharacter = '>';
}
public static class DoubleQuote
{
public const char OpenCharacter = '"';
public const char CloseCharacter = '"';
}
public static class SingleQuote
{
public const char OpenCharacter = '\'';
public const char CloseCharacter = '\'';
}
/// <summary>
/// Determines if inserting the opening brace at the location could be an attempt to
/// escape a previously inserted opening brace.
/// E.g. they are trying to type $"{{"
/// </summary>
protected static bool CouldEscapePreviousOpenBrace(char openingBrace, int position, SourceText text)
{
var index = position - 1;
var openBraceCount = 0;
while (index >= 0)
{
if (text[index] == openingBrace)
{
openBraceCount++;
}
else
{
break;
}
index--;
}
if (openBraceCount > 0 && openBraceCount % 2 == 1)
{
return true;
}
return false;
}
}
}
|