public override SyntaxNode VisitConditionalAccessExpression(ConditionalAccessExpressionSyntax node)
{
// update the expression but not the Elvis itself
var newExpression = (ExpressionSyntax)Visit(node.Expression);
return(node.Update(newExpression, node.OperatorToken, node.WhenNotNull));
}
public static async Task ComputeRefactoringAsync(RefactoringContext context, ConditionalAccessExpressionSyntax conditionalAccessExpression)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.WrapCallChain))
{
await WrapCallChainRefactoring.ComputeRefactoringsAsync(context, conditionalAccessExpression).ConfigureAwait(false);
}
}
public override Evaluation VisitConditionalAccessExpression(ConditionalAccessExpressionSyntax node)
{
node.WhenNotNull?.Accept <Evaluation>(this);
node.Expression?.Accept <Evaluation>(this);
return(base.VisitConditionalAccessExpression(node));
}
private bool ReplacementBreaksConditionalAccessExpression(ConditionalAccessExpressionSyntax conditionalAccessExpression, ConditionalAccessExpressionSyntax newConditionalAccessExpression)
{
return(!SymbolsAreCompatible(conditionalAccessExpression, newConditionalAccessExpression) ||
!TypesAreCompatible(conditionalAccessExpression, newConditionalAccessExpression) ||
!SymbolsAreCompatible(conditionalAccessExpression.WhenNotNull, newConditionalAccessExpression.WhenNotNull) ||
!TypesAreCompatible(conditionalAccessExpression.WhenNotNull, newConditionalAccessExpression.WhenNotNull));
}
private Block BuildConditionalAccessExpression(ConditionalAccessExpressionSyntax conditionalAccess, Block currentBlock)
{
var whenNotNull = BuildExpression(conditionalAccess.WhenNotNull, CreateBlock(currentBlock));
return(BuildExpression(conditionalAccess.Expression,
CreateBinaryBranchBlock(conditionalAccess, currentBlock, whenNotNull)));
}
public override void VisitConditionalAccessExpression(ConditionalAccessExpressionSyntax node)
{
node.WhenNotNull?.Accept(this);
node.Expression?.Accept(this);
base.VisitConditionalAccessExpression(node);
}
public static void Write(this ConditionalAccessExpressionSyntax syntax,
IIndentedTextWriterWrapper textWriter,
IContext context)
{
textWriter.Write("_M.CA(");
syntax.Expression.Write(textWriter, context);
textWriter.Write(",function(obj) return ");
var stringWriter = new StringWriter();
var newTextWriter = new IndentedTextWriterWrapper(stringWriter);
syntax.WhenNotNull.Write(newTextWriter, context);
if (stringWriter.ToString().StartsWith("("))
{
textWriter.Write("((obj % _M.DOT)");
textWriter.Write(newTextWriter.ToString().Substring(1));
}
else
{
textWriter.Write("(obj % _M.DOT)");
textWriter.AppendTextWriter(newTextWriter);
}
textWriter.Write("; end)");
}
private static ExpressionSyntax TryCreateExpressionWithoutConditionalAccess(ConditionalAccessExpressionSyntax conditionalAccess)
{
switch (conditionalAccess.WhenNotNull)
{
case MemberBindingExpressionSyntax memberBinding:
{
return(SimpleMemberAccessExpression(conditionalAccess.Expression, memberBinding.Name));
}
case ElementBindingExpressionSyntax elementBinding:
{
return(ElementAccessExpression(conditionalAccess.Expression, elementBinding.ArgumentList));
}
case InvocationExpressionSyntax invocation:
{
if (!(invocation.Expression is MemberBindingExpressionSyntax memberBinding))
{
return(null);
}
return(InvocationExpression(SimpleMemberAccessExpression(conditionalAccess.Expression, memberBinding.Name), invocation.ArgumentList));
}
}
return(null);
}
public override SyntaxNode VisitConditionalAccessExpression(ConditionalAccessExpressionSyntax node)
{
ExpressionSyntax whenNotNull = node.WhenNotNull;
if (whenNotNull?.IsKind(SyntaxKind.MemberBindingExpression) == true)
{
var memberBinding = (MemberBindingExpressionSyntax)whenNotNull;
SimpleNameSyntax name = memberBinding.Name;
if (name != null &&
_textSpans.Contains(name.Span))
{
_textSpans.Remove(node.Span);
var expression = (ExpressionSyntax)base.Visit(node.Expression);
InvocationExpressionSyntax invocation = InvocationExpression(
memberBinding.WithName(IdentifierName(_methodName).WithLeadingTrivia(name.GetLeadingTrivia())),
ArgumentList().WithTrailingTrivia(memberBinding.GetTrailingTrivia()));
return(node
.WithExpression(expression)
.WithWhenNotNull(invocation));
}
}
return(base.VisitConditionalAccessExpression(node));
}
public override void VisitConditionalAccessExpression(ConditionalAccessExpressionSyntax node)
{
if (Predicate(node.Expression))
{
Success = true;
}
}
public override Ust VisitConditionalAccessExpression(ConditionalAccessExpressionSyntax node)
{
Ust ustNode = base.Visit(node.Expression);
Expression expression = ustNode as Expression;
if (expression == null)
{
expression = new MultichildExpression(((ArgsUst)ustNode).Collection, ustNode.TextSpan);
}
Expression whenNotNullExpression;
if (node.WhenNotNull is ElementBindingExpressionSyntax)
{
var args = (ArgsUst)VisitElementBindingExpression((ElementBindingExpressionSyntax)node.WhenNotNull);
whenNotNullExpression = new IndexerExpression(expression, args, args.TextSpan);
}
else
{
whenNotNullExpression = (Expression)base.Visit(node.WhenNotNull);
}
var nullExpr = new NullLiteral(default(TextSpan));
var binayOpLiteral = new BinaryOperatorLiteral(BinaryOperator.Equal, default(TextSpan));
var condition = new BinaryOperatorExpression(expression, binayOpLiteral, nullExpr, default(TextSpan));
var result = new ConditionalExpression(condition, nullExpr, whenNotNullExpression, node.GetTextSpan());
return(result);
}
private static ExpressionSyntax Reformat(ConditionalAccessExpressionSyntax expression)
{
if (!expression.WhenNotNull.IsKind(SyntaxKind.InvocationExpression))
{
return(expression);
}
var invocation = (InvocationExpressionSyntax)expression.WhenNotNull;
if (!expression.Expression.IsKind(SyntaxKind.ConditionalAccessExpression) &&
!expression.Expression.IsKind(SyntaxKind.InvocationExpression) &&
invocation.Expression.IsKind(SyntaxKind.SimpleMemberAccessExpression))
{
var memberAccess = (MemberAccessExpressionSyntax)invocation.Expression;
var conditionalAccess = SyntaxFactory.ConditionalAccessExpression(
expression.Expression,
memberAccess.Expression);
var newMemberAccess = SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
conditionalAccess,
memberAccess.Name);
return(SyntaxFactory.InvocationExpression(newMemberAccess, invocation.ArgumentList));
}
else
{
return(expression);
}
}
public override bool VisitConditionalAccessExpression(ConditionalAccessExpressionSyntax node)
{
if (!Visit(node.Expression))
{
return(false);
}
return(Visit(node.WhenNotNull));
}
public static Doc Print(ConditionalAccessExpressionSyntax node)
{
return(Doc.Concat(
Node.Print(node.Expression),
Token.Print(node.OperatorToken),
Node.Print(node.WhenNotNull)
));
}
public override ExpressionSyntax VisitConditionalAccessExpression(ConditionalAccessExpressionSyntax node)
{
return(node
.WithExpression(
Visit(node.Expression))
.WithWhenNotNull(
Visit(node.WhenNotNull)));
}
public override void VisitConditionalAccessExpression(ConditionalAccessExpressionSyntax node)
{
if (!_foundConditionalAccess)
{
_foundConditionalAccess = true;
}
base.VisitConditionalAccessExpression(node);
}
private Doc PrintConditionalAccessExpressionSyntax(
ConditionalAccessExpressionSyntax node)
{
return(Concat(
this.Print(node.Expression),
this.PrintSyntaxToken(node.OperatorToken),
this.Print(node.WhenNotNull)
));
}
public override LuaSyntaxNode VisitConditionalAccessExpression(ConditionalAccessExpressionSyntax node)
{
bool isEmpty = functions_.Count == 0;
if (isEmpty)
{
LuaFunctionExpressionSyntax function = new LuaFunctionExpressionSyntax();
PushFunction(function);
blocks_.Push(function.Body);
}
var temp = GetTempIdentifier(node.Expression);
conditionalTemps_.Push(temp);
var expression = (LuaExpressionSyntax)node.Expression.Accept(this);
CurBlock.Statements.Add(new LuaLocalVariableDeclaratorSyntax(temp, expression));
LuaBinaryExpressionSyntax condition = new LuaBinaryExpressionSyntax(temp, LuaSyntaxNode.Tokens.NotEquals, LuaIdentifierNameSyntax.Nil);
LuaIfStatementSyntax ifStatement = new LuaIfStatementSyntax(condition);
CurBlock.Statements.Add(ifStatement);
blocks_.Push(ifStatement.Body);
var whenNotNull = (LuaExpressionSyntax)node.WhenNotNull.Accept(this);
blocks_.Pop();
conditionalTemps_.Pop();
if (node.Parent.IsKind(SyntaxKind.ExpressionStatement))
{
if (isEmpty)
{
throw new InvalidOperationException();
}
ifStatement.Body.Statements.Add(new LuaExpressionStatementSyntax(whenNotNull));
return(LuaExpressionSyntax.EmptyExpression);
}
else
{
LuaAssignmentExpressionSyntax assignment = new LuaAssignmentExpressionSyntax(temp, whenNotNull);
ifStatement.Body.Statements.Add(new LuaExpressionStatementSyntax(assignment));
if (isEmpty)
{
var function = CurFunction;
function.AddStatement(new LuaReturnStatementSyntax(temp));
blocks_.Pop();
PopFunction();
return(new LuaInvocationExpressionSyntax(new LuaParenthesizedExpressionSyntax(function)));
}
else
{
return(temp);
}
}
}
public override void VisitConditionalAccessExpression(ConditionalAccessExpressionSyntax node)
{
base.VisitConditionalAccessExpression(node);
if (node.OperatorToken.Kind() != SyntaxKind.QuestionToken)
{
return;
}
Count++;
}
private void BuildConditionalAccessExpression(ConditionalAccessExpressionSyntax conditionalAccess)
{
var successorBlock = currentBlock;
currentBlock = CreateBlock(currentBlock);
BuildExpression(conditionalAccess.WhenNotNull);
currentBlock = CreateBinaryBranchBlock(conditionalAccess, successorBlock, currentBlock);
BuildExpression(conditionalAccess.Expression);
}
/// <summary>
/// Returns first <see cref="MemberBindingExpressionSyntax"/> of <paramref name="conditionalAccessExpression" />
/// </summary>
/// <param name="conditionalAccessExpression">Conditional access to be inspected</param>
/// <returns>First member binding expression</returns>
public static MemberBindingExpressionSyntax GetFirstMemberBindingExpression(this ConditionalAccessExpressionSyntax conditionalAccessExpression)
{
var firstMemberBindingExpressionOnTheRightOfTheDot = conditionalAccessExpression
?.WhenNotNull
?.DescendantNodesAndSelf()
.OfType <MemberBindingExpressionSyntax>()
.FirstOrDefault();
return(firstMemberBindingExpressionOnTheRightOfTheDot);
}
public override void VisitConditionalAccessExpression(ConditionalAccessExpressionSyntax node)
{
if (entryPoint.IsMethodLevel() && node.IsParent <AnonymousFunctionExpressionSyntax>())
{
return;
}
nobcounter++;
base.VisitConditionalAccessExpression(node);
}
private static void CollectDisposedSymbol <T>(ConditionalAccessExpressionSyntax conditionalAccess, SemanticModel semanticModel,
IMethodSymbol disposeMethod, Predicate <T> isSymbolRelevant, ref ImmutableHashSet <T> fieldsDisposed)
where T : class, ISymbol
{
T fieldSymbol;
if (TryGetDisposedSymbol(conditionalAccess, semanticModel, disposeMethod,
isSymbolRelevant, out fieldSymbol))
{
fieldsDisposed = fieldsDisposed.Add(fieldSymbol);
}
}
/// <summary>
/// Runs conditional access expression. (CS6)
/// [Syntax] EXPR?.WHEN_NOT_NULL
/// </summary>
private HybInstance RunConditionalAccess(ConditionalAccessExpressionSyntax node)
{
var left = RunExpression(node.Expression);
Ctx._bound = left;
if (left.IsNull() == false)
{
return(RunExpression(node.WhenNotNull));
}
return(HybInstance.Null());
}
public override void VisitConditionalAccessExpression(ConditionalAccessExpressionSyntax node)
{
if (entryPoint.IsMethodLevel() && node.IsParent <AnonymousFunctionExpressionSyntax>())
{
return;
}
IncreaseHeight();
EmbeddednessConsideredToIncrease();
base.VisitConditionalAccessExpression(node);
currentNL--;
EmbeddednessConsideredToDecrease();
}
private void BuildConditionalAccessExpression(ConditionalAccessExpressionSyntax conditionalAccess)
{
// is this required here?
currentBlock.ReversedInstructions.Add(conditionalAccess);
var successorBlock = currentBlock;
currentBlock = CreateBlock(currentBlock);
BuildExpression(conditionalAccess.WhenNotNull);
currentBlock = CreateBinaryBranchBlock(conditionalAccess, successorBlock, currentBlock);
BuildExpression(conditionalAccess.Expression);
}
public override void VisitConditionalAccessExpression(ConditionalAccessExpressionSyntax node)
{
if (!PreVisit(node))
{
return;
}
node.WhenNotNull?.Accept(this);
node.Expression?.Accept(this);
base.VisitConditionalAccessExpression(node);
PostVisit(node);
}
public override SyntaxNode VisitConditionalAccessExpression(ConditionalAccessExpressionSyntax node)
{
var old = insideConditionalExpression;
insideConditionalExpression = true;
try
{
return(base.VisitConditionalAccessExpression(node));
}
finally
{
insideConditionalExpression = old;
}
}
private bool IsForbiddenUsage(SyntaxNodeAnalysisContext context, ConditionalAccessExpressionSyntax conditionalAccess)
{
var memberName = conditionalAccess.GetFirstMemberBindingExpression()?.Name?.Identifier.ValueText;
if (!string.IsNullOrEmpty(memberName) &&
_config.ForbiddenMembers.All(forbiddenMember => !memberName.Equals(forbiddenMember, StringComparison.Ordinal)))
{
return(false);
}
var actualTargetType = context.SemanticModel.GetTypeInfo(conditionalAccess.Expression).Type as INamedTypeSymbol;
return(actualTargetType != null && _config.ForbiddenTypes.Any(forbidenType => actualTargetType.IsDerivedFrom(forbidenType, context.Compilation)));
}
public ConditionalAccessInfo(SemanticModel semanticModel, ConditionalAccessExpressionSyntax node)
{
Node = node;
var expressionType = semanticModel.GetTypeInfo(node.Expression).Type;
ExpressionType = SyntaxFactory.ParseTypeName(expressionType.ToMinimalDisplayString(semanticModel, node.Expression.GetLocation().SourceSpan.Start));
var resultType = semanticModel.GetTypeInfo(node).Type;
ResultType = SyntaxFactory.ParseTypeName(resultType.ToMinimalDisplayString(semanticModel, node.GetLocation().SourceSpan.Start));
IsResultVoid = resultType.SpecialType == SpecialType.System_Void;
IsComplex = IsExpressionComplexEnoughToGetATemporaryVariable.IsComplex(semanticModel, node.Expression);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitConditionalAccessExpression(ConditionalAccessExpressionSyntax node)
{
this.OnNodeVisited(node);
if (!this.traverseRootOnly) base.VisitConditionalAccessExpression(node);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitConditionalAccessExpression(ConditionalAccessExpressionSyntax node)
{
this.OnNodeVisited(node, this.type.IsInstanceOfType(node));
base.VisitConditionalAccessExpression(node);
}
public override void VisitConditionalAccessExpression(ConditionalAccessExpressionSyntax node)
{
base.VisitConditionalAccessExpression(node);
}
public ConditionalAccessExpressionTranslation(ConditionalAccessExpressionSyntax syntax, SyntaxTranslation parent) : base(syntax, parent)
{
Expression = syntax.Expression.Get<ExpressionTranslation>(this);
WhenNotNull = syntax.WhenNotNull.Get<ExpressionTranslation>(this);
}
public override SyntaxNode VisitConditionalAccessExpression(ConditionalAccessExpressionSyntax node)
{
var result = base.VisitConditionalAccessExpression(node);
var conditionalAccessResult = result as ConditionalAccessExpressionSyntax;
if (conditionalAccessResult == node || conditionalAccessResult == null)
{
return node;
}
if (((conditionalAccessResult.WhenNotNull as ParenthesizedExpressionSyntax)?.Expression ?? conditionalAccessResult.WhenNotNull as AwaitExpressionSyntax)?.Kind() == SyntaxKind.AwaitExpression)
{
var awaitExpression = (AwaitExpressionSyntax)(conditionalAccessResult.WhenNotNull as ParenthesizedExpressionSyntax)?.Expression ?? conditionalAccessResult.WhenNotNull as AwaitExpressionSyntax;
var awaitExpressionExpression = awaitExpression?.Expression;
if (awaitExpressionExpression == null)
{
return result;
}
var stack = new Stack<ExpressionSyntax>();
var syntax = awaitExpressionExpression;
while (true)
{
if (syntax is MemberAccessExpressionSyntax)
{
stack.Push(syntax);
syntax = ((MemberAccessExpressionSyntax)syntax).Expression;
}
else if (syntax is InvocationExpressionSyntax)
{
stack.Push(syntax);
syntax = ((InvocationExpressionSyntax)syntax).Expression;
}
else if (syntax is MemberBindingExpressionSyntax)
{
var name = ((MemberBindingExpressionSyntax)syntax).Name;
dynamic current = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, conditionalAccessResult.Expression, name);
while (stack.Count > 0)
{
dynamic next = stack.Pop();
current = next.WithExpression(current);
}
syntax = current;
break;
}
else
{
throw new InvalidOperationException("Unsupported expression " + syntax);
}
}
if (node.Parent == null || node.Parent is StatementSyntax)
{
return SyntaxFactory.IfStatement(SyntaxFactory.BinaryExpression(SyntaxKind.NotEqualsExpression, conditionalAccessResult.Expression, SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)), SyntaxFactory.Block(SyntaxFactory.ExpressionStatement(SyntaxFactory.AwaitExpression(syntax))));
}
else
{
var typeResult = this.semanticModel.GetSpeculativeTypeInfo(node.SpanStart + this.displacement, node, SpeculativeBindingOption.BindAsExpression);
if (typeResult.Type.IsValueType)
{
return SyntaxFactory.ParenthesizedExpression(SyntaxFactory.ConditionalExpression(SyntaxFactory.BinaryExpression(SyntaxKind.NotEqualsExpression, conditionalAccessResult.Expression, SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)), SyntaxFactory.AwaitExpression(syntax), SyntaxFactory.ParenthesizedExpression(SyntaxFactory.CastExpression(SyntaxFactory.ParseTypeName(typeResult.Type.ToString()), SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)))));
}
else
{
return SyntaxFactory.ParenthesizedExpression(SyntaxFactory.ConditionalExpression(SyntaxFactory.BinaryExpression(SyntaxKind.NotEqualsExpression, conditionalAccessResult.Expression, SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)), SyntaxFactory.AwaitExpression(syntax), SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)));
}
}
}
return result;
}
private IEnumerable<TypeInferenceInfo> InferTypeInConditionalAccessExpression(ConditionalAccessExpressionSyntax expression)
{
return InferTypes(expression);
}
public override SyntaxNode VisitConditionalAccessExpression(ConditionalAccessExpressionSyntax node)
{
this.AppendCompileIssue(node, IssueType.Warning, IssueId.ConditionalAccess);
this.Visit(node.Expression);
switch (node.WhenNotNull.Kind())
{
case SyntaxKind.ElementBindingExpression:
var eb = node.WhenNotNull as ElementBindingExpressionSyntax;
_output.TrivialWrite('[');
this.Visit(eb.ArgumentList);
_output.TrivialWrite(']');
break;
case SyntaxKind.MemberBindingExpression:
var mb = node.WhenNotNull as MemberBindingExpressionSyntax;
_output.TrivialWrite('.');
this.Visit(mb.Name);
break;
}
return node;
}
private IEnumerable<ITypeSymbol> InferTypeInConditionalAccessExpression(ConditionalAccessExpressionSyntax expression)
{
return InferTypes(expression);
}
