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); }
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); }
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)); }
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)); }