public static void UnwrapInterpolation <TInterpolationSyntax, TExpressionSyntax>(
IVirtualCharService virtualCharService, IInterpolationOperation interpolation,
out TExpressionSyntax?unwrapped, out TExpressionSyntax?alignment, out bool negate,
out string?formatString, out ImmutableArray <Location> unnecessaryLocations)
where TInterpolationSyntax : SyntaxNode
where TExpressionSyntax : SyntaxNode
{
alignment = null;
negate = false;
formatString = null;
var unnecessarySpans = new List <TextSpan>();
var expression = Unwrap(interpolation.Expression);
if (interpolation.Alignment == null)
{
UnwrapAlignmentPadding(expression, out expression, out alignment, out negate, unnecessarySpans);
}
if (interpolation.FormatString == null)
{
UnwrapFormatString(virtualCharService, expression, out expression, out formatString, unnecessarySpans);
}
unwrapped = expression.Syntax as TExpressionSyntax;
unnecessaryLocations =
unnecessarySpans.OrderBy(t => t.Start)
.SelectAsArray(interpolation.Syntax.SyntaxTree.GetLocation);
}
private static InterpolatedStringExpressionSyntax Convert(
IVirtualCharService charService, StringBuilder sb, InterpolatedStringExpressionSyntax stringExpression,
SyntaxKind newStartKind, Action <IVirtualCharService, StringBuilder, SyntaxToken> addStringText)
{
using var _ = ArrayBuilder <InterpolatedStringContentSyntax> .GetInstance(out var newContents);
foreach (var content in stringExpression.Contents)
{
if (content is InterpolatedStringTextSyntax textSyntax)
{
// Ensure our temp builder is in a empty starting state.
sb.Clear();
addStringText(charService, sb, textSyntax.TextToken);
newContents.Add(textSyntax.WithTextToken(CreateTextToken(textSyntax.TextToken, sb)));
}
else
{
// not text (i.e. it's an interpolation). just add as is.
newContents.Add(content);
}
}
var startToken = stringExpression.StringStartToken;
var newStartToken = SyntaxFactory.Token(
leading: startToken.LeadingTrivia,
kind: newStartKind,
trailing: startToken.TrailingTrivia);
return(stringExpression.Update(
newStartToken,
SyntaxFactory.List(newContents),
stringExpression.StringEndToken));
}
protected override LiteralExpressionSyntax CreateRegularStringExpression(IVirtualCharService charService, StringBuilder sb, LiteralExpressionSyntax stringExpression)
{
sb.Append(DoubleQuote);
AddRegularStringText(charService, sb, stringExpression.Token);
sb.Append(DoubleQuote);
return(stringExpression.WithToken(CreateStringToken(sb)));
}
public EmbeddedLanguageInfo(int stringLiteralTokenKind, int interpolatedTextTokenKind, ISyntaxFactsService syntaxFacts, ISemanticFactsService semanticFacts, IVirtualCharService virtualCharService)
{
StringLiteralTokenKind = stringLiteralTokenKind;
InterpolatedTextTokenKind = interpolatedTextTokenKind;
SyntaxFacts = syntaxFacts;
SemanticFacts = semanticFacts;
VirtualCharService = virtualCharService;
}
private static TextSpan GetSpanWithinLiteralQuotes(IVirtualCharService virtualCharService, SyntaxToken formatToken)
{
var sequence = virtualCharService.TryConvertToVirtualChars(formatToken);
return(sequence.IsDefaultOrEmpty
? default
: TextSpan.FromBounds(sequence.First().Span.Start, sequence.Last().Span.End));
}
protected AbstractEmbeddedLanguagesProvider(
int stringLiteralTokenKind,
int interpolatedTextTokenKind,
ISyntaxFactsService syntaxFacts,
ISemanticFactsService semanticFacts,
IVirtualCharService virtualCharService)
{
_embeddedLanguages = ImmutableArray.Create <IEmbeddedLanguage>(
new RegexEmbeddedLanguage(stringLiteralTokenKind, syntaxFacts, semanticFacts, virtualCharService),
new FallbackEmbeddedLanguage(stringLiteralTokenKind, interpolatedTextTokenKind, syntaxFacts, semanticFacts, virtualCharService));
}
protected override InterpolatedStringExpressionSyntax CreateRegularStringExpression(
IVirtualCharService charService,
StringBuilder sb,
InterpolatedStringExpressionSyntax stringExpression
) =>
Convert(
charService,
sb,
stringExpression,
SyntaxKind.InterpolatedStringStartToken,
AddRegularStringText
);
private static void UnwrapFormatString(
IVirtualCharService virtualCharService, ISyntaxFacts syntaxFacts, IOperation expression, out IOperation unwrapped,
out string?formatString, List <TextSpan> unnecessarySpans)
{
if (expression is IInvocationOperation {
TargetMethod : {
Name : nameof(ToString)
}
} invocation&&
HasNonImplicitInstance(invocation) &&
!syntaxFacts.IsBaseExpression(invocation.Instance.Syntax) &&
!invocation.Instance.Type.IsRefLikeType)
{
if (invocation.Arguments.Length == 1 &&
invocation.Arguments[0].Value is ILiteralOperation {
ConstantValue : { HasValue : true, Value : string value }
} literal&&
invocation.SemanticModel.Compilation.GetTypeByMetadataName(typeof(System.IFormattable).FullName !) is { } systemIFormattable&&
invocation.Instance.Type.Implements(systemIFormattable))
{
unwrapped = invocation.Instance;
formatString = value;
unnecessarySpans.AddRange(invocation.Syntax.Span
.Subtract(invocation.Instance.Syntax.FullSpan)
.Subtract(GetSpanWithinLiteralQuotes(virtualCharService, literal.Syntax.GetFirstToken())));
return;
}
var method = invocation.TargetMethod;
while (method.OverriddenMethod != null)
{
method = method.OverriddenMethod;
}
if (method.ContainingType.SpecialType == SpecialType.System_Object &&
method.Name == nameof(ToString))
{
// A call to `.ToString()` at the end of the interpolation. This is unnecessary.
// Just remove entirely.
unwrapped = invocation.Instance;
formatString = "";
unnecessarySpans.AddRange(invocation.Syntax.Span
.Subtract(invocation.Instance.Syntax.FullSpan));
return;
}
}
unwrapped = expression;
formatString = null;
}
private void UnwrapFormatString(
IVirtualCharService virtualCharService, ISyntaxFacts syntaxFacts, IOperation expression, out IOperation unwrapped,
out string?formatString, List <TextSpan> unnecessarySpans)
{
Contract.ThrowIfNull(expression.SemanticModel);
if (expression is IInvocationOperation {
TargetMethod.Name : nameof(ToString)
} invocation&&
HasNonImplicitInstance(invocation) &&
!syntaxFacts.IsBaseExpression(invocation.Instance !.Syntax) &&
!invocation.Instance.Type !.IsRefLikeType)
{
if (invocation.Arguments.Length == 1 ||
(invocation.Arguments.Length == 2 && UsesInvariantCultureReferenceInsideFormattableStringInvariant(invocation, formatProviderArgumentIndex : 1)))
{
if (invocation.Arguments[0].Value is ILiteralOperation {
ConstantValue : { HasValue : true, Value : string value }
} literal&&
FindType <System.IFormattable>(expression.SemanticModel) is { } systemIFormattable&&
invocation.Instance.Type.Implements(systemIFormattable))
{
unwrapped = invocation.Instance;
formatString = value;
unnecessarySpans.AddRange(invocation.Syntax.Span
.Subtract(GetPreservedInterpolationExpressionSyntax(invocation.Instance).FullSpan)
.Subtract(GetSpanWithinLiteralQuotes(virtualCharService, literal.Syntax.GetFirstToken())));
return;
}
}
if (IsObjectToStringOverride(invocation.TargetMethod) ||
(invocation.Arguments.Length == 1 && UsesInvariantCultureReferenceInsideFormattableStringInvariant(invocation, formatProviderArgumentIndex: 0)))
{
// A call to `.ToString()` at the end of the interpolation. This is unnecessary.
// Just remove entirely.
unwrapped = invocation.Instance;
formatString = "";
unnecessarySpans.AddRange(invocation.Syntax.Span
.Subtract(GetPreservedInterpolationExpressionSyntax(invocation.Instance).FullSpan));
return;
}
}
unwrapped = expression;
formatString = null;
}
public EmbeddedLanguageInfo(
ISyntaxFacts syntaxFacts,
ISemanticFactsService semanticFacts,
IVirtualCharService virtualCharService)
{
SyntaxFacts = syntaxFacts;
SemanticFacts = semanticFacts;
VirtualCharService = virtualCharService;
using var array = TemporaryArray <int> .Empty;
array.Add(syntaxFacts.SyntaxKinds.StringLiteralToken);
array.AsRef().AddIfNotNull(syntaxFacts.SyntaxKinds.SingleLineRawStringLiteralToken);
array.AsRef().AddIfNotNull(syntaxFacts.SyntaxKinds.MultiLineRawStringLiteralToken);
AllStringLiteralKinds = array.ToImmutableAndClear();
}
public FallbackEmbeddedLanguage(
int stringLiteralTokenKind,
int interpolatedTextTokenKind,
ISyntaxFactsService syntaxFacts,
ISemanticFactsService semanticFacts,
IVirtualCharService virtualCharService)
{
_stringLiteralTokenKind = stringLiteralTokenKind;
_interpolatedTextTokenKind = interpolatedTextTokenKind;
_syntaxFacts = syntaxFacts;
_semanticFacts = semanticFacts;
_virtualCharService = virtualCharService;
Classifier = new FallbackEmbeddedClassifier(this);
}
public RegexEmbeddedLanguage(
int stringLiteralKind,
ISyntaxFactsService syntaxFacts,
ISemanticFactsService semanticFacts,
IVirtualCharService virtualCharService)
{
StringLiteralKind = stringLiteralKind;
SyntaxFacts = syntaxFacts;
SemanticFacts = semanticFacts;
VirtualCharService = virtualCharService;
BraceMatcher = new RegexEmbeddedBraceMatcher(this);
Classifier = new RegexEmbeddedClassifier(this);
Highlighter = new RegexEmbeddedHighlighter(this);
DiagnosticAnalyzer = new RegexDiagnosticAnalyzer(this);
}
internal EmbeddedLanguageClassificationContext(
Project project,
SemanticModel semanticModel,
SyntaxToken syntaxToken,
ClassificationOptions options,
IVirtualCharService virtualCharService,
ArrayBuilder <ClassifiedSpan> result,
CancellationToken cancellationToken)
{
Project = project;
SemanticModel = semanticModel;
SyntaxToken = syntaxToken;
Options = options;
VirtualCharService = virtualCharService;
_result = result;
CancellationToken = cancellationToken;
}
protected void AddVerbatimStringText(
IVirtualCharService charService, StringBuilder sb, SyntaxToken stringToken)
{
var isInterpolation = IsInterpolation;
var chars = charService.TryConvertToVirtualChars(stringToken);
foreach (var ch in chars)
{
// just build the verbatim string by concatenating all the chars in the original
// string. The only exceptions are double-quotes which need to be doubled up in the
// final string, and curlies which need to be doubled in interpolations.
ch.AppendTo(sb);
if (ShouldDouble(ch, isInterpolation))
{
ch.AppendTo(sb);
}
}
private static void UnwrapFormatString(
IVirtualCharService virtualCharService, ISyntaxFacts syntaxFacts, IOperation expression, out IOperation unwrapped,
out string?formatString, List <TextSpan> unnecessarySpans)
{
if (expression is IInvocationOperation {
TargetMethod : {
Name : nameof(ToString)
}
} invocation&&
HasNonImplicitInstance(invocation) &&
!syntaxFacts.IsBaseExpression(invocation.Instance.Syntax))
{
if (invocation.Arguments.Length == 1 &&
invocation.Arguments[0].Value is ILiteralOperation {
ConstantValue : { HasValue : true, Value : string value }
} literal)
{
unwrapped = invocation.Instance;
formatString = value;
unnecessarySpans.AddRange(invocation.Syntax.Span
.Subtract(invocation.Instance.Syntax.FullSpan)
.Subtract(GetSpanWithinLiteralQuotes(virtualCharService, literal.Syntax.GetFirstToken())));
return;
}
if (invocation.Arguments.Length == 0)
{
// A call to `.ToString()` at the end of the interpolation. This is unnecessary.
// Just remove entirely.
unwrapped = invocation.Instance;
formatString = "";
unnecessarySpans.AddRange(invocation.Syntax.Span
.Subtract(invocation.Instance.Syntax.FullSpan));
return;
}
}
unwrapped = expression;
formatString = null;
}
private AspNetCoreCSharpVirtualCharService(IVirtualCharService virtualCharService)
{
_virtualCharService = virtualCharService;
}
protected abstract TStringExpressionSyntax CreateRegularStringExpression(IVirtualCharService charService, StringBuilder sb, TStringExpressionSyntax stringExpression);
