public override void VisitPrefixUnaryExpression(PrefixUnaryExpressionSyntax node)
{
if (node.Kind() != SyntaxKind.LogicalNotExpression)
{
throw new InvalidPreprocessorExpressionException("Expected logical not expression");
}
node.Operand.Accept(this);
}
private static void GetExpression(PrefixUnaryExpressionSyntax prefix, out ExpressionSyntax expression, out uint count)
{
count = 0;
var currentUnary = prefix;
do
{
count++;
expression = currentUnary.Operand;
currentUnary = currentUnary.Operand as PrefixUnaryExpressionSyntax;
}
while (currentUnary != null);
}
public override SyntaxNode VisitPrefixUnaryExpression(PrefixUnaryExpressionSyntax node)
{
switch (node.Kind)
{
case SyntaxKind.PreIncrementExpression:
return Syntax.BinaryExpression(SyntaxKind.AddAssignExpression, node.Operand, Syntax.LiteralExpression(SyntaxKind.NumericLiteralExpression, Syntax.Literal(1)));
case SyntaxKind.PreDecrementExpression:
return Syntax.BinaryExpression(SyntaxKind.SubtractAssignExpression, node.Operand, Syntax.LiteralExpression(SyntaxKind.NumericLiteralExpression, Syntax.Literal(1)));
case SyntaxKind.NegateExpression:
if (node.Operand.Kind == SyntaxKind.NumericLiteralExpression)
{
dynamic newvalue = -((dynamic)((LiteralExpressionSyntax)node.Operand).Token.Value);
return Syntax.LiteralExpression(SyntaxKind.NumericLiteralExpression, Syntax.Literal(newvalue));
}
return node;
}
throw new NotImplementedException("Unary prefix " + node.Kind.ToString());
}
public override SyntaxNode VisitPrefixUnaryExpression(PrefixUnaryExpressionSyntax node)
{
switch (node.CSharpKind())
{
case SyntaxKind.PreIncrementExpression:
return SyntaxFactory.BinaryExpression(SyntaxKind.AddAssignmentExpression, node.Operand, SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(1)));
case SyntaxKind.PreDecrementExpression:
return SyntaxFactory.BinaryExpression(SyntaxKind.SubtractAssignmentExpression, node.Operand, SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(1)));
#if NEGATE_EXPRESSION
case SyntaxKind.NegateExpression:
if (node.Operand.CSharpKind() == SyntaxKind.NumericLiteralExpression)
{
dynamic newvalue = -((dynamic)((LiteralExpressionSyntax)node.Operand).Token.Value);
return SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(newvalue));
}
return node;
#endif
case SyntaxKind.LogicalNotExpression:
return SyntaxFactory.BinaryExpression(SyntaxKind.NotEqualsExpression, node.Operand, SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression));
}
throw new NotImplementedException("Unary prefix " + node.CSharpKind().ToString());
}
public SyntaxNode VisitPrePostExpression(PrefixUnaryExpressionSyntax pre, PostfixUnaryExpressionSyntax post)
{
SyntaxNode node = null;
if (pre == null)
{
node = post;
}
if (post == null)
{
node = pre;
}
if (node == null)
{
return(node);
}
bool postDecr = (node.Kind() == SyntaxKind.PostDecrementExpression);
bool postIncr = (node.Kind() == SyntaxKind.PostIncrementExpression);
bool preDecr = (node.Kind() == SyntaxKind.PreDecrementExpression);
bool preIncr = (node.Kind() == SyntaxKind.PreIncrementExpression);
bool condition = postDecr || postIncr || preDecr || preIncr;
if (!condition)
{
return(node);
}
int markedNodesCount = markedNodes.Count();
if (markedNodesCount > 0)
{
return(node);
}
ExpressionSyntax operand = null;
int operationType = 0; // 0 - pre, 1 - post
if (postDecr || postIncr)
{
operationType = 1;
operand = ((PostfixUnaryExpressionSyntax)node).Operand;
}
else
{
operand = ((PrefixUnaryExpressionSyntax)node).Operand;
}
string tempName = TemporaryVarIdentifier + "_" + operationType;
StatementSyntax indexUpdate = null;
if (postIncr || preIncr)
{
indexUpdate = IncrementIndex(operand);
}
else if (postDecr || preDecr)
{
indexUpdate = DecrementIndex(operand);
}
var tempVar = SyntaxFactoryExtensions.LocalVariableDeclaration(tempName, operand);
var tempIdentifier = SyntaxFactory.IdentifierName(tempName);
var tuple = new Tuple <SyntaxNode, IdentifierNameSyntax, int, SyntaxNode, SyntaxNode>(node, tempIdentifier, operationType, tempVar, indexUpdate);
var parent = GetParentExpression(node);
markedNodes.Add(parent);
replacementNodes.Add(tuple);
return(node);
}
/// <summary>
/// Initializes a new instance of the <see cref="UnaryExpression"/> class.
/// </summary>
/// <param name="syntaxNode"></param>
public UnaryExpression(PrefixUnaryExpressionSyntax syntaxNode)
: this(syntaxNode, null)
{
}
private BoundExpression BindUnaryOperator(PrefixUnaryExpressionSyntax node, DiagnosticBag diagnostics)
{
BoundExpression operand = BindValue(node.Operand, diagnostics, GetUnaryAssignmentKind(node.Kind()));
BoundLiteral constant = BindIntegralMinValConstants(node, operand, diagnostics);
return constant ?? BindUnaryOperatorCore(node, node.OperatorToken.Text, operand, diagnostics);
}
public static void WritePrefix(OutputWriter writer, PrefixUnaryExpressionSyntax expression)
{
// Console.WriteLine (expression.ToFullString());
if (expression.OperatorToken.RawKind == (decimal)SyntaxKind.MinusMinusToken)
{
writer.Write("--");
Core.Write(writer, expression.Operand);
}
else if (expression.OperatorToken.RawKind == (decimal)SyntaxKind.PlusPlusToken)
{
writer.Write("++");
Core.Write(writer, expression.Operand);
}
else
{
//TODO: cannot take addresses of structs in 32/64-bit mode and subtract them ... really weird d-bug ... leads to wrong math ... should we do a shift ?
// if (expression.OperatorToken.CSharpKind () == SyntaxKind.AmpersandToken) // Take address
// {
// var memberAccess = expression.Operand as MemberAccessExpressionSyntax;
// var simpleName = expression.Operand as NameSyntax;
//
// TypeInfo typeOperand;
//
// if (memberAccess != null)
// typeOperand = TypeProcessor.GetTypeInfo (memberAccess.Expression);
// if (simpleName != null)
// typeOperand = TypeProcessor.GetTypeInfo (simpleName);
//
// var failed = true;
// if (memberAccess != null)
// {
// failed = false;
// if (typeOperand.Type.TypeKind == TypeKind.Struct)
// {
// var sNAme = (memberAccess.Expression as SimpleNameSyntax).Identifier;
//
// writer.Write ("(cast(ulong)(&" + sNAme.ToFullString () + ") + (");
// Core.Write (writer, expression.Operand);
// writer.Write (".offsetof))");
// }
// else
// failed = true;
// }
// else if (simpleName != null)
// {
// failed = false;
//
// if (typeOperand.Type.TypeKind == TypeKind.Struct)
// {
// writer.Write ("(&" + simpleName.ToFullString () + " + (");
// Core.Write (writer, expression.Operand);
// writer.Write (".offsetof))");
// }
// else
// failed = true;
// }
//
// if(failed)
// {
// writer.Write (expression.OperatorToken.ToString ());
// Core.Write (writer, expression.Operand);
// }
//
// }
// else
{
writer.Write(expression.OperatorToken.ToString());
Core.Write(writer, expression.Operand);
}
}
}
private IEnumerable<ITypeSymbol> InferTypeInPrefixUnaryExpression(PrefixUnaryExpressionSyntax prefixUnaryExpression, SyntaxToken? previousToken = null)
{
// If we have a position, then we must be after the prefix token.
Contract.ThrowIfTrue(previousToken.HasValue && previousToken.Value != prefixUnaryExpression.OperatorToken);
switch (prefixUnaryExpression.CSharpKind())
{
case SyntaxKind.AwaitExpression:
// await <expression>
var types = InferTypes(prefixUnaryExpression);
var task = this.Compilation.TaskType();
var taskOfT = this.Compilation.TaskOfTType();
if (task == null || taskOfT == null)
{
break;
}
if (!types.Any())
{
return SpecializedCollections.SingletonEnumerable(task);
}
return types.Select(t => t.SpecialType == SpecialType.System_Void ? task : taskOfT.Construct(t));
case SyntaxKind.PreDecrementExpression:
case SyntaxKind.PreIncrementExpression:
case SyntaxKind.UnaryPlusExpression:
case SyntaxKind.UnaryMinusExpression:
case SyntaxKind.BitwiseNotExpression:
// ++, --, +Foo(), -Foo(), ~Foo();
return SpecializedCollections.SingletonEnumerable(this.Compilation.GetSpecialType(SpecialType.System_Int32));
case SyntaxKind.LogicalNotExpression:
// !Foo()
return SpecializedCollections.SingletonEnumerable(this.Compilation.GetSpecialType(SpecialType.System_Boolean));
}
return SpecializedCollections.EmptyEnumerable<ITypeSymbol>();
}
public override void VisitPrefixUnaryExpression(PrefixUnaryExpressionSyntax node)
{
base.VisitPrefixUnaryExpression(node);
DiscardFieldFromExpression(node.Operand);
}
public override SyntaxList <StatementSyntax> VisitForBlock(VBSyntax.ForBlockSyntax node)
{
var stmt = node.ForStatement;
ExpressionSyntax startValue = (ExpressionSyntax)stmt.FromValue.Accept(_nodesVisitor);
VariableDeclarationSyntax declaration = null;
ExpressionSyntax id;
if (stmt.ControlVariable is VBSyntax.VariableDeclaratorSyntax)
{
var v = (VBSyntax.VariableDeclaratorSyntax)stmt.ControlVariable;
declaration = CommonConversions.SplitVariableDeclarations(v).Values.Single();
declaration = declaration.WithVariables(SyntaxFactory.SingletonSeparatedList(declaration.Variables[0].WithInitializer(SyntaxFactory.EqualsValueClause(startValue))));
id = SyntaxFactory.IdentifierName(declaration.Variables[0].Identifier);
}
else
{
id = (ExpressionSyntax)stmt.ControlVariable.Accept(_nodesVisitor);
var symbol = _semanticModel.GetSymbolInfo(stmt.ControlVariable).Symbol;
if (!_semanticModel.LookupSymbols(node.FullSpan.Start, name: symbol.Name).Any())
{
declaration = CreateVariableDeclarationAndAssignment(symbol.Name, startValue);
}
else
{
startValue = SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, id, startValue);
}
}
var step = (ExpressionSyntax)stmt.StepClause?.StepValue.Accept(_nodesVisitor);
PrefixUnaryExpressionSyntax value = step.SkipParens() as PrefixUnaryExpressionSyntax;
ExpressionSyntax condition;
// In Visual Basic, the To expression is only evaluated once, but in C# will be evaluated every loop.
// If it could evaluate differently or has side effects, it must be extracted as a variable
var preLoopStatements = new List <SyntaxNode>();
var csToValue = (ExpressionSyntax)stmt.ToValue.Accept(_nodesVisitor);
if (!_semanticModel.GetConstantValue(stmt.ToValue).HasValue)
{
var loopToVariableName = GetUniqueVariableNameInScope(node, "loopTo");
var loopEndDeclaration = SyntaxFactory.LocalDeclarationStatement(CreateVariableDeclarationAndAssignment(loopToVariableName, csToValue));
// Does not do anything about porting newline trivia upwards to maintain spacing above the loop
preLoopStatements.Add(loopEndDeclaration);
csToValue = SyntaxFactory.IdentifierName(loopToVariableName);
}
;
if (value == null)
{
condition = SyntaxFactory.BinaryExpression(SyntaxKind.LessThanOrEqualExpression, id, csToValue);
}
else
{
condition = SyntaxFactory.BinaryExpression(SyntaxKind.GreaterThanOrEqualExpression, id, csToValue);
}
if (step == null)
{
step = SyntaxFactory.PostfixUnaryExpression(SyntaxKind.PostIncrementExpression, id);
}
else
{
step = SyntaxFactory.AssignmentExpression(SyntaxKind.AddAssignmentExpression, id, step);
}
var block = SyntaxFactory.Block(node.Statements.SelectMany(s => s.Accept(CommentConvertingVisitor)));
var forStatementSyntax = SyntaxFactory.ForStatement(
declaration,
declaration != null
? SyntaxFactory.SeparatedList <ExpressionSyntax>()
: SyntaxFactory.SingletonSeparatedList(startValue),
condition,
SyntaxFactory.SingletonSeparatedList(step),
block.UnpackNonNestedBlock());
return(SyntaxFactory.List(preLoopStatements.Concat(new[] { forStatementSyntax })));
}
public PrefixUnaryExpressionTranslation(PrefixUnaryExpressionSyntax syntax, SyntaxTranslation parent) : base(syntax, parent)
{
Operand = syntax.Operand.Get <ExpressionTranslation>(this);
}
private static ExpressionSyntax GetNewNode(PrefixUnaryExpressionSyntax logicalNot, Document document)
{
ExpressionSyntax operand = logicalNot.Operand;
ExpressionSyntax expression = operand.WalkDownParentheses();
switch (expression.Kind())
{
case SyntaxKind.TrueLiteralExpression:
case SyntaxKind.FalseLiteralExpression:
{
LiteralExpressionSyntax newNode = BooleanLiteralExpression(expression.Kind() == SyntaxKind.FalseLiteralExpression);
newNode = newNode.WithTriviaFrom(expression);
return(operand.ReplaceNode(expression, newNode));
}
case SyntaxKind.LogicalNotExpression:
{
return(((PrefixUnaryExpressionSyntax)expression).Operand);
}
case SyntaxKind.EqualsExpression:
case SyntaxKind.NotEqualsExpression:
case SyntaxKind.LessThanExpression:
case SyntaxKind.LessThanOrEqualExpression:
case SyntaxKind.GreaterThanExpression:
case SyntaxKind.GreaterThanOrEqualExpression:
{
BinaryExpressionSyntax newExpression = SyntaxLogicalInverter.GetInstance(document).InvertBinaryExpression((BinaryExpressionSyntax)expression);
return(operand.ReplaceNode(expression, newExpression));
}
case SyntaxKind.InvocationExpression:
{
var invocationExpression = (InvocationExpressionSyntax)expression;
var memberAccessExpression = (MemberAccessExpressionSyntax)invocationExpression.Expression;
ExpressionSyntax lambdaExpression = invocationExpression.ArgumentList.Arguments[0].Expression.WalkDownParentheses();
SingleParameterLambdaExpressionInfo lambdaInfo = SyntaxInfo.SingleParameterLambdaExpressionInfo(lambdaExpression);
var logicalNot2 = (PrefixUnaryExpressionSyntax)SimplifyLogicalNegationAnalyzer.GetReturnExpression(lambdaInfo.Body).WalkDownParentheses();
InvocationExpressionSyntax newNode = invocationExpression.ReplaceNode(logicalNot2, logicalNot2.Operand.WithTriviaFrom(logicalNot2));
return(SyntaxRefactorings.ChangeInvokedMethodName(newNode, (memberAccessExpression.Name.Identifier.ValueText == "All") ? "Any" : "All"));
}
case SyntaxKind.IsPatternExpression:
{
var isPatternExpression = (IsPatternExpressionSyntax)expression;
var pattern = (ConstantPatternSyntax)isPatternExpression.Pattern;
UnaryPatternSyntax newPattern = NotPattern(pattern.WithoutTrivia()).WithTriviaFrom(pattern);
return(isPatternExpression.WithPattern(newPattern)
.PrependToLeadingTrivia(logicalNot.GetLeadingTrivia())
.AppendToTrailingTrivia(logicalNot.GetTrailingTrivia()));
}
}
return(null);
}
public override void VisitPrefixUnaryExpression(PrefixUnaryExpressionSyntax node)
{
Emit <PrefixUnaryExpressionBlock, PrefixUnaryExpressionSyntax>(node);
}
public override void VisitPrefixUnaryExpression(PrefixUnaryExpressionSyntax node)
{
this.VisitExpression(node);
}
public PrefixUnaryExpressionSharpnode(PrefixUnaryExpressionSyntax syntax, string @operator) : base(syntax)
{
this.Operator = @operator;
this.Expression = RoslynToSharpnode.MapExpression(syntax.Operand);
}
private static bool SameOperators(PrefixUnaryExpressionSyntax expression1, PrefixUnaryExpressionSyntax expression2)
{
return(expression1.OperatorToken.IsKind(expression2.OperatorToken.Kind()));
}
public static Doc Print(PrefixUnaryExpressionSyntax node)
{
return(Doc.Concat(Token.Print(node.OperatorToken), Node.Print(node.Operand)));
}
private IEnumerable <StatementSyntax> GeneratePinningPath(TypePositionInfo info, StubCodeContext context)
{
(string managedIdentifer, string nativeIdentifier) = context.GetIdentifiers(info);
string byRefIdentifier = $"__byref_{managedIdentifer}";
TypeSyntax arrayElementType = _elementType;
if (context.CurrentStage == StubCodeContext.Stage.Marshal)
{
// [COMPAT] We use explicit byref calculations here instead of just using a fixed statement
// since a fixed statement converts a zero-length array to a null pointer.
// Many native APIs, such as GDI+, ICU, etc. validate that an array parameter is non-null
// even when the passed in array length is zero. To avoid breaking customers that want to move
// to source-generated interop in subtle ways, we explicitly pass a reference to the 0-th element
// of an array as long as it is non-null, matching the behavior of the built-in interop system
// for single-dimensional zero-based arrays.
// ref <elementType> <byRefIdentifier> = ref <managedIdentifer> == null ? ref *(<elementType>*)0 : ref MemoryMarshal.GetArrayDataReference(<managedIdentifer>);
PrefixUnaryExpressionSyntax nullRef =
PrefixUnaryExpression(SyntaxKind.PointerIndirectionExpression,
CastExpression(
PointerType(arrayElementType),
LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(0))));
InvocationExpressionSyntax getArrayDataReference =
InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
ParseTypeName(TypeNames.System_Runtime_InteropServices_MemoryMarshal),
IdentifierName("GetArrayDataReference")),
ArgumentList(SingletonSeparatedList(
Argument(IdentifierName(managedIdentifer)))));
yield return(LocalDeclarationStatement(
VariableDeclaration(
RefType(arrayElementType))
.WithVariables(SingletonSeparatedList(
VariableDeclarator(Identifier(byRefIdentifier))
.WithInitializer(EqualsValueClause(
RefExpression(ParenthesizedExpression(
ConditionalExpression(
BinaryExpression(
SyntaxKind.EqualsExpression,
IdentifierName(managedIdentifer),
LiteralExpression(
SyntaxKind.NullLiteralExpression)),
RefExpression(nullRef),
RefExpression(getArrayDataReference))))))))));
}
if (context.CurrentStage == StubCodeContext.Stage.Pin)
{
// fixed (<nativeType> <nativeIdentifier> = &Unsafe.As<elementType, byte>(ref <byrefIdentifier>))
yield return(FixedStatement(
VariableDeclaration(AsNativeType(info), SingletonSeparatedList(
VariableDeclarator(nativeIdentifier)
.WithInitializer(EqualsValueClause(
PrefixUnaryExpression(SyntaxKind.AddressOfExpression,
InvocationExpression(
MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
ParseTypeName(TypeNames.System_Runtime_CompilerServices_Unsafe),
GenericName("As").AddTypeArgumentListArguments(
arrayElementType,
PredefinedType(Token(SyntaxKind.ByteKeyword)))))
.AddArgumentListArguments(
Argument(IdentifierName(byRefIdentifier))
.WithRefKindKeyword(Token(SyntaxKind.RefKeyword)))))))),
EmptyStatement()));
}
}
public override void VisitPrefixUnaryExpression(PrefixUnaryExpressionSyntax node)
{
base.VisitPrefixUnaryExpression(node);
if (node.IsKind(SyntaxKind.PreDecrementExpression) || node.IsKind(SyntaxKind.PreIncrementExpression))
{
var postfixed = node.Operand;
if (postfixed.IsKind(SyntaxKind.IdentifierName))
{
var identifier = (IdentifierNameSyntax)postfixed;
if (identifier.Identifier.Text == _testee.Name)
{
_isAssigned = true;
}
}
}
}
public static string PrefixUnaryExpression(PrefixUnaryExpressionSyntax expression)
{
return expression.OperatorToken.Text + SyntaxNode(expression.Operand);
}
public PrefixUnaryExpressionTranslation(PrefixUnaryExpressionSyntax syntax, SyntaxTranslation parent) : base(syntax, parent)
{
Operand = syntax.Operand.Get<ExpressionTranslation>(this);
}
private static bool TopLevelUnaryInChain(PrefixUnaryExpressionSyntax unary)
{
var parent = unary.Parent as PrefixUnaryExpressionSyntax;
return parent == null || !SameOperators(parent, unary);
}
protected override SyntaxNode VisitPrefixUnaryExpression(PrefixUnaryExpressionSyntax node)
{
IdentifierNameSyntax name = node.Operand as IdentifierNameSyntax;
if (name != null)
{
switch (node.Kind)
{
case SyntaxKind.PreIncrementExpression:
case SyntaxKind.PreDecrementExpression:
return GetLogExpression (name.PlainName, node);
}
}
return base.VisitPrefixUnaryExpression (node);
}
public override void VisitPrefixUnaryExpression(PrefixUnaryExpressionSyntax node)
{
base.VisitPrefixUnaryExpression(node);
if (node.IsKind(SyntaxKind.AddressOfExpression) || node.IsKind(SyntaxKind.PointerIndirectionExpression)) // TODO: Check
MarkUnsafe();
}
private static void ReplacePreDecrementWithPreIncrement(RefactoringContext context, PrefixUnaryExpressionSyntax preDecrement)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ReplaceIncrementOperatorWithDecrementOperator))
{
PrefixUnaryExpressionSyntax preIncrement = preDecrement
.WithOperatorToken(Token(SyntaxKind.PlusPlusToken))
.WithTriviaFrom(preDecrement)
.WithFormatterAnnotation();
context.RegisterRefactoring(
$"Replace '{preDecrement}' with '{preIncrement}'",
cancellationToken => ChangePreDecrementToPreIncrementAsync(context.Document, preDecrement, preIncrement, cancellationToken));
}
}
// Based on ExpressionBinder::bindPtrIndirection.
private BoundExpression BindPointerIndirectionExpression(PrefixUnaryExpressionSyntax node, DiagnosticBag diagnostics)
{
BoundExpression operand = BindValue(node.Operand, diagnostics, GetUnaryAssignmentKind(node.Kind()));
TypeSymbol pointedAtType;
bool hasErrors;
BindPointerIndirectionExpressionInternal(node, operand, diagnostics, out pointedAtType, out hasErrors);
return new BoundPointerIndirectionOperator(node, operand, pointedAtType ?? CreateErrorType(), hasErrors);
}
private static string GetIdentifierFromPrefixOperand(PrefixUnaryExpressionSyntax expression) =>
GetIdentifierFromIdentifierNameSyntax((IdentifierNameSyntax)expression.Operand);
/// <summary>
/// Rewrites the expression with a nondetermnistic choice expression.
/// </summary>
/// <param name="node">PrefixUnaryExpressionSyntax</param>
/// <returns>SyntaxNode</returns>
private SyntaxNode RewriteExpression(PrefixUnaryExpressionSyntax node)
{
var text = "this.Nondet()";
var rewritten = SyntaxFactory.ParseExpression(text);
return rewritten;
}
public override void VisitPrefixUnaryExpression(PrefixUnaryExpressionSyntax node)
{
Enqueue(() => new AstUnary(node.OperatorToken.ToFullString().Trim(), Dequeue()));
base.VisitPrefixUnaryExpression(node);
}
private string GeneratePrefixUnaryExpression(PrefixUnaryExpressionSyntax prefixUnaryExpressionSyntax, SemanticModel semanticModel)
{
AssertOperandIsChangeble(prefixUnaryExpressionSyntax.Operand);
return(prefixUnaryExpressionSyntax.OperatorToken.Text + GenerateExpression(prefixUnaryExpressionSyntax.Operand, semanticModel));
}
public override AwaitExpressionInfo GetAwaitExpressionInfo(PrefixUnaryExpressionSyntax node)
{
using (Logger.LogBlock(FunctionId.CSharp_SemanticModel_GetAwaitExpressionInfo, message: this.SyntaxTree.FilePath))
{
MemberSemanticModel memberModel = GetMemberModel(node);
return memberModel == null ? default(AwaitExpressionInfo) : memberModel.GetAwaitExpressionInfo(node);
}
}
private static void ReplacePreDecrementWithPostDecrement(RefactoringContext context, PrefixUnaryExpressionSyntax preDecrement)
{
if (!context.IsRefactoringEnabled(RefactoringIdentifiers.ReplacePrefixOperatorWithPostfixOperator))
{
return;
}
ExpressionSyntax operand = preDecrement.Operand;
if (operand == null)
{
return;
}
PostfixUnaryExpressionSyntax postDecrement = PostDecrementExpression(operand.WithoutTrivia())
.WithTriviaFrom(preDecrement)
.WithFormatterAnnotation();
context.RegisterRefactoring(
$"Replace '{preDecrement}' with '{postDecrement}'",
cancellationToken => ChangePreDecrementToPostDecrementAsync(context.Document, preDecrement, postDecrement, cancellationToken),
RefactoringIdentifiers.ReplacePrefixOperatorWithPostfixOperator);
}
private static void AddPrefixUnaryExpressionTerms(PrefixUnaryExpressionSyntax prefixUnaryExpression, IList<string> terms, ref ExpressionType expressionType)
{
expressionType = ExpressionType.Invalid;
var flags = ExpressionType.Invalid;
// Ask our subexpression for terms
AddSubExpressionTerms(prefixUnaryExpression.Operand, terms, ref flags);
// Is our expression a valid term?
AddIfValidTerm(prefixUnaryExpression.Operand, flags, terms);
if (prefixUnaryExpression.IsKind(SyntaxKind.LogicalNotExpression, SyntaxKind.BitwiseNotExpression, SyntaxKind.UnaryMinusExpression, SyntaxKind.UnaryPlusExpression))
{
// We're a valid expression if our subexpression is...
expressionType = flags & ExpressionType.ValidExpression;
}
}
private static bool TopLevelUnaryInChain(PrefixUnaryExpressionSyntax unary)
{
var parent = unary.Parent as PrefixUnaryExpressionSyntax;
return(parent == null || !SameOperators(parent, unary));
}
public override SyntaxNode VisitPrefixUnaryExpression(PrefixUnaryExpressionSyntax node)
{
var based = base.VisitPrefixUnaryExpression (node);
switch (node.Kind)
{
case SyntaxKind.PreIncrementExpression:
case SyntaxKind.PreDecrementExpression:
return based.WithTrailingTrivia (based.GetTrailingTrivia().Prepend (GetIdComment()));
default:
return based;
}
}
public virtual void VisitPrefixUnaryExpression(PrefixUnaryExpressionSyntax node)
{
DefaultVisit(node);
}
public IncrementExpressionSharpnode(PrefixUnaryExpressionSyntax syntax, IncrementExpressionDirection direction) : base(syntax)
{
this.direction = direction;
this.order = IncrementExpressionOrder.Pre;
this.expression = RoslynToSharpnode.MapExpression(syntax.Operand);
}
public override SyntaxNode VisitPrefixUnaryExpression(PrefixUnaryExpressionSyntax node)
{
if (IsPropertyAccess(node.Operand))
this.AppendCompileIssue(node, IssueType.Error, IssueId.PropertyAccessIssue);
_output.Write(node, node.OperatorToken.ValueText);
this.Visit(node.Operand);
return node;
}
private BoundExpression BindAwait(PrefixUnaryExpressionSyntax node, DiagnosticBag diagnostics)
{
BoundExpression expression = BindValue(node.Operand, diagnostics, BindValueKind.RValue);
return BindAwait(expression, node, diagnostics);
}
/// <summary>
/// Initializes a new instance of the <see cref="UnaryExpression"/> class.
/// </summary>
/// <param name="syntaxNode"></param>
public UnaryExpression(PrefixUnaryExpressionSyntax syntaxNode)
: this(syntaxNode, null)
{
}
private void VisitLogicalNot(PrefixUnaryExpressionSyntax node, out TState trueState, out TState falseState)
{
this.VisitCondition(node.Operand, out falseState, out trueState);
}
private IEnumerable<ITypeSymbol> InferTypeInPrefixUnaryExpression(PrefixUnaryExpressionSyntax prefixUnaryExpression, SyntaxToken? previousToken = null)
{
// If we have a position, then we must be after the prefix token.
Contract.ThrowIfTrue(previousToken.HasValue && previousToken.Value != prefixUnaryExpression.OperatorToken);
switch (prefixUnaryExpression.Kind())
{
case SyntaxKind.PreDecrementExpression:
case SyntaxKind.PreIncrementExpression:
case SyntaxKind.UnaryPlusExpression:
case SyntaxKind.UnaryMinusExpression:
case SyntaxKind.BitwiseNotExpression:
// ++, --, +Foo(), -Foo(), ~Foo();
return SpecializedCollections.SingletonEnumerable(this.Compilation.GetSpecialType(SpecialType.System_Int32));
case SyntaxKind.LogicalNotExpression:
// !Foo()
return SpecializedCollections.SingletonEnumerable(this.Compilation.GetSpecialType(SpecialType.System_Boolean));
}
return SpecializedCollections.EmptyEnumerable<ITypeSymbol>();
}
/// <summary>
/// Initializes a new instance of the <see cref="UnaryExpression"/> class.
/// </summary>
/// <param name="syntaxNode"></param>
/// <param name="semanticModel"></param>
public UnaryExpression(PrefixUnaryExpressionSyntax syntaxNode, SemanticModel semanticModel)
: base(syntaxNode, semanticModel)
{
this.IsPrefix = true;
}
private static bool SameOperators(PrefixUnaryExpressionSyntax expression1, PrefixUnaryExpressionSyntax expression2)
{
return expression1.OperatorToken.IsKind(expression2.OperatorToken.Kind());
}
public override Ust VisitPrefixUnaryExpression(PrefixUnaryExpressionSyntax node)
{
var result = CreateUnaryOperatorExpression(true, node);
return(result);
}
public virtual void VisitPrefixUnaryExpression(PrefixUnaryExpressionSyntax node)
{
DefaultVisit(node);
}
private static ExpressionSyntax GetNewNode(PrefixUnaryExpressionSyntax logicalNot)
{
ExpressionSyntax operand = logicalNot.Operand;
ExpressionSyntax expression = operand.WalkDownParentheses();
switch (expression.Kind())
{
case SyntaxKind.TrueLiteralExpression:
case SyntaxKind.FalseLiteralExpression:
{
LiteralExpressionSyntax newNode = BooleanLiteralExpression(expression.Kind() == SyntaxKind.FalseLiteralExpression);
newNode = newNode.WithTriviaFrom(expression);
return(operand.ReplaceNode(expression, newNode));
}
case SyntaxKind.LogicalNotExpression:
{
return(((PrefixUnaryExpressionSyntax)expression).Operand);
}
case SyntaxKind.EqualsExpression:
{
var equalsExpression = (BinaryExpressionSyntax)expression;
BinaryExpressionSyntax notEqualsExpression = NotEqualsExpression(
equalsExpression.Left,
SyntaxFactory.Token(SyntaxKind.ExclamationEqualsToken).WithTriviaFrom(equalsExpression.OperatorToken),
equalsExpression.Right);
return(operand.ReplaceNode(equalsExpression, notEqualsExpression));
}
case SyntaxKind.NotEqualsExpression:
{
var notEqualsExpression = (BinaryExpressionSyntax)expression;
BinaryExpressionSyntax equalsExpression = NotEqualsExpression(
notEqualsExpression.Left,
SyntaxFactory.Token(SyntaxKind.EqualsEqualsToken).WithTriviaFrom(notEqualsExpression.OperatorToken),
notEqualsExpression.Right);
return(operand.ReplaceNode(notEqualsExpression, equalsExpression));
}
case SyntaxKind.InvocationExpression:
{
var invocationExpression = (InvocationExpressionSyntax)expression;
var memberAccessExpression = (MemberAccessExpressionSyntax)invocationExpression.Expression;
ExpressionSyntax lambdaExpression = invocationExpression.ArgumentList.Arguments.First().Expression.WalkDownParentheses();
SingleParameterLambdaExpressionInfo lambdaInfo = SyntaxInfo.SingleParameterLambdaExpressionInfo(lambdaExpression);
var logicalNot2 = (PrefixUnaryExpressionSyntax)SimplifyLogicalNegationAnalyzer.GetReturnExpression(lambdaInfo.Body).WalkDownParentheses();
InvocationExpressionSyntax newNode = invocationExpression.ReplaceNode(logicalNot2, logicalNot2.Operand.WithTriviaFrom(logicalNot2));
return(SyntaxRefactorings.ChangeInvokedMethodName(newNode, (memberAccessExpression.Name.Identifier.ValueText == "All") ? "Any" : "All"));
}
}
return(null);
}
public override AwaitExpressionInfo GetAwaitExpressionInfo(PrefixUnaryExpressionSyntax node)
{
if (node.Kind != SyntaxKind.AwaitExpression)
{
throw new ArgumentException("node.Kind==" + node.Kind);
}
BoundAwaitExpression boundAwait = GetUpperBoundNode(node) as BoundAwaitExpression;
if (boundAwait == null)
{
return default(AwaitExpressionInfo);
}
return new AwaitExpressionInfo(boundAwait.GetAwaiter, boundAwait.IsCompleted, boundAwait.GetResult, boundAwait.IsDynamic);
}
/// <inheritdoc />
public override Expression VisitPrefixUnaryExpression(PrefixUnaryExpressionSyntax node)
{
return(Expression.MakeUnary(GetUnaryExpressionType(node.OperatorToken.Kind(), true), node.Operand.Accept(this), null));
}
public override void VisitPrefixUnaryExpression(PrefixUnaryExpressionSyntax node)
{
base.VisitPrefixUnaryExpression(node);
var op = node.OperatorToken.ValueText;
expression = Expression.MakeUnary(unaryOps[op], expression, null);
}
public override JsExpression VisitPrefixUnaryExpression(PrefixUnaryExpressionSyntax node)
{
return(VisitUnaryExpression(node, node.Operand));
}
/// <summary>
/// Initializes a new instance of the <see cref="UnaryExpression"/> class.
/// </summary>
/// <param name="syntaxNode"></param>
/// <param name="semanticModel"></param>
public UnaryExpression(PrefixUnaryExpressionSyntax syntaxNode, SemanticModel semanticModel)
: base(syntaxNode, semanticModel)
{
this.IsPrefix = true;
}
public override SyntaxList <StatementSyntax> VisitForBlock(VBSyntax.ForBlockSyntax node)
{
var stmt = node.ForStatement;
ExpressionSyntax startValue = (ExpressionSyntax)stmt.FromValue.Accept(nodesVisitor);
VariableDeclarationSyntax declaration = null;
ExpressionSyntax id;
if (stmt.ControlVariable is VBSyntax.VariableDeclaratorSyntax)
{
var v = (VBSyntax.VariableDeclaratorSyntax)stmt.ControlVariable;
declaration = SplitVariableDeclarations(v, nodesVisitor, semanticModel).Values.Single();
declaration = declaration.WithVariables(SyntaxFactory.SingletonSeparatedList(declaration.Variables[0].WithInitializer(SyntaxFactory.EqualsValueClause(startValue))));
id = SyntaxFactory.IdentifierName(declaration.Variables[0].Identifier);
}
else
{
id = (ExpressionSyntax)stmt.ControlVariable.Accept(nodesVisitor);
var symbol = semanticModel.GetSymbolInfo(stmt.ControlVariable).Symbol;
if (!semanticModel.LookupSymbols(node.FullSpan.Start, name: symbol.Name).Any())
{
var variableDeclaratorSyntax = SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(symbol.Name), null,
SyntaxFactory.EqualsValueClause(startValue));
declaration = SyntaxFactory.VariableDeclaration(
SyntaxFactory.IdentifierName("var"),
SyntaxFactory.SingletonSeparatedList(variableDeclaratorSyntax));
}
else
{
startValue = SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, id, startValue);
}
}
var step = (ExpressionSyntax)stmt.StepClause?.StepValue.Accept(nodesVisitor);
PrefixUnaryExpressionSyntax value = step.SkipParens() as PrefixUnaryExpressionSyntax;
ExpressionSyntax condition;
if (value == null)
{
condition = SyntaxFactory.BinaryExpression(SyntaxKind.LessThanOrEqualExpression, id, (ExpressionSyntax)stmt.ToValue.Accept(nodesVisitor));
}
else
{
condition = SyntaxFactory.BinaryExpression(SyntaxKind.GreaterThanOrEqualExpression, id, (ExpressionSyntax)stmt.ToValue.Accept(nodesVisitor));
}
if (step == null)
{
step = SyntaxFactory.PostfixUnaryExpression(SyntaxKind.PostIncrementExpression, id);
}
else
{
step = SyntaxFactory.AssignmentExpression(SyntaxKind.AddAssignmentExpression, id, step);
}
var block = SyntaxFactory.Block(node.Statements.SelectMany(s => s.Accept(this)));
return(SingleStatement(SyntaxFactory.ForStatement(
declaration,
declaration != null ? SyntaxFactory.SeparatedList <ExpressionSyntax>() : SyntaxFactory.SingletonSeparatedList(startValue),
condition,
SyntaxFactory.SingletonSeparatedList(step),
block.UnpackBlock())));
}
// Based on ExpressionBinder::bindPtrAddr.
private BoundExpression BindAddressOfExpression(PrefixUnaryExpressionSyntax node, DiagnosticBag diagnostics)
{
BoundExpression operand = BindValue(node.Operand, diagnostics, BindValueKind.AddressOf);
bool hasErrors = operand.HasAnyErrors; // This would propagate automatically, but by reading it explicitly we can reduce cascading.
bool isFixedStatementAddressOfExpression = SyntaxFacts.IsFixedStatementExpression(node);
switch (operand.Kind)
{
case BoundKind.MethodGroup:
case BoundKind.Lambda:
case BoundKind.UnboundLambda:
{
Debug.Assert(hasErrors);
return new BoundAddressOfOperator(node, operand, isFixedStatementAddressOfExpression, CreateErrorType(), hasErrors: true);
}
}
TypeSymbol operandType = operand.Type;
Debug.Assert((object)operandType != null || hasErrors, "BindValue should have caught a null operand type");
bool isManagedType = operandType.IsManagedType;
bool allowManagedAddressOf = Flags.Includes(BinderFlags.AllowManagedAddressOf);
if (!allowManagedAddressOf)
{
if (!hasErrors && isManagedType)
{
hasErrors = true;
Error(diagnostics, ErrorCode.ERR_ManagedAddr, node, operandType);
}
if (!hasErrors)
{
Symbol accessedLocalOrParameterOpt;
if (IsNonMoveableVariable(operand, out accessedLocalOrParameterOpt) == isFixedStatementAddressOfExpression)
{
Error(diagnostics, isFixedStatementAddressOfExpression ? ErrorCode.ERR_FixedNotNeeded : ErrorCode.ERR_FixedNeeded, node);
hasErrors = true;
}
}
}
TypeSymbol pointerType = new PointerTypeSymbol(isManagedType && allowManagedAddressOf
? GetSpecialType(SpecialType.System_IntPtr, diagnostics, node)
: operandType ?? CreateErrorType());
return new BoundAddressOfOperator(node, operand, isFixedStatementAddressOfExpression, pointerType, hasErrors);
}
public override void VisitPrefixUnaryExpression(PrefixUnaryExpressionSyntax node)
{
throw new NotImplementedException();
}
private BoundLiteral BindIntegralMinValConstants(PrefixUnaryExpressionSyntax node, BoundExpression operand, DiagnosticBag diagnostics)
{
// SPEC: To permit the smallest possible int and long values to be written as decimal integer
// SPEC: literals, the following two rules exist:
// SPEC: When a decimal-integer-literal with the value 2147483648 and no integer-type-suffix
// SPEC: appears as the token immediately following a unary minus operator token, the result is a
// SPEC: constant of type int with the value −2147483648.
// SPEC: When a decimal-integer-literal with the value 9223372036854775808 and no integer-type-suffix
// SPEC: or the integer-type-suffix L or l appears as the token immediately following a unary minus
// SPEC: operator token, the result is a constant of type long with the value −9223372036854775808.
if (node.Kind() != SyntaxKind.UnaryMinusExpression)
{
return null;
}
if (node.Operand != operand.Syntax || operand.Syntax.Kind() != SyntaxKind.NumericLiteralExpression)
{
return null;
}
var literal = (LiteralExpressionSyntax)operand.Syntax;
var token = literal.Token;
if (token.Value is uint)
{
uint value = (uint)token.Value;
if (value != 2147483648U)
{
return null;
}
if (token.Text.Contains("u") || token.Text.Contains("U") || token.Text.Contains("l") || token.Text.Contains("L"))
{
return null;
}
return new BoundLiteral(node, ConstantValue.Create((int)-2147483648), GetSpecialType(SpecialType.System_Int32, diagnostics, node));
}
else if (token.Value is ulong)
{
var value = (ulong)token.Value;
if (value != 9223372036854775808UL)
{
return null;
}
if (token.Text.Contains("u") || token.Text.Contains("U"))
{
return null;
}
return new BoundLiteral(node, ConstantValue.Create(-9223372036854775808), GetSpecialType(SpecialType.System_Int64, diagnostics, node));
}
return null;
}
public override string VisitPrefixUnaryExpression(PrefixUnaryExpressionSyntax node)
{
return(node.OperatorToken.ToFullString() + Visit(node.Operand));
}
public override SyntaxNode VisitPrefixUnaryExpression(PrefixUnaryExpressionSyntax node)
{
if (node.Kind() != SyntaxKind.LogicalNotExpression)
{
throw new InvalidPreprocessorExpressionException("Expected logical not expression");
}
var newExpression = (ExpressionSyntax)node.Operand.Accept(this);
if (newExpression.Kind() == SyntaxKind.LogicalNotExpression)
{
return ((PrefixUnaryExpressionSyntax)newExpression).Operand
.WithLeadingTrivia(node.GetLeadingTrivia())
.WithTrailingTrivia(node.GetTrailingTrivia());
}
else
{
return node.Operand != newExpression ?
node.WithOperand(newExpression) : node;
}
}
public override SyntaxNode VisitPrefixUnaryExpression(PrefixUnaryExpressionSyntax node)
{
node = (PrefixUnaryExpressionSyntax)base.VisitPrefixUnaryExpression(node);
return(VisitPrePostExpression(node, null));
}
