OperatorKind

Binder\Binder.ValueChecks.cs (1)

5388if (binary.OperatorKind == BinaryOperatorKind.Utf8Addition)

Binder\Binder_TupleOperators.cs (2)

111Debug.Assert(!binary.OperatorKind.IsDynamic()); 112return new TupleBinaryOperatorInfo.Single(binary.Left.Type, binary.Right.Type, binary.OperatorKind, binary.BinaryOperatorMethod, binary.ConstrainedToType,

Binder\Semantics\Operators\BinaryOperatorOverloadResolution.cs (1)

787return value is BoundUtf8String or BoundBinaryOperator { OperatorKind: BinaryOperatorKind.Utf8Addition };

BoundTree\BoundBinaryOperator.UncommonData.cs (2)

17if (OperatorKind.IsDynamic()) 19Debug.Assert(OperatorKind.IsLogical());

BoundTree\BoundExpression.cs (3)

408public MethodSymbol? BinaryOperatorMethod => OperatorKind.IsDynamic() ? null : Data?.Method; 409public MethodSymbol? LeftTruthOperatorMethod => OperatorKind.IsDynamic() && OperatorKind.IsLogical() ? Data?.Method : null;

BoundTree\BoundNode_Source.cs (1)

344append(binary.OperatorKind.ToString());

BoundTree\BoundTreeRewriter.cs (2)

252return node.Update(node.OperatorKind, VisitBinaryOperatorData(node), node.ResultKind, (BoundExpression)this.Visit(node.Left), (BoundExpression)this.Visit(node.Right), this.VisitType(node.Type)); 282left = binary.Update(binary.OperatorKind, VisitBinaryOperatorData(binary), binary.ResultKind, left, right, type);

BoundTree\Constructors.cs (1)

460return Update(OperatorKind, uncommonData, ResultKind, Left, Right, Type);

BoundTree\NullabilityRewriter.cs (1)

101binary.OperatorKind,

CodeGen\EmitConversion.cs (1)

160(fromPredefTypeKind == Cci.PrimitiveTypeCode.IntPtr && conversion.Operand is BoundBinaryOperator { OperatorKind: BinaryOperatorKind.Division })); // pointer subtraction: see LocalRewriter.RewritePointerSubtraction()

CodeGen\EmitExpression.cs (2)

2181Debug.Assert(!b.OperatorKind.IsUserDefined()); 2183if (b.OperatorKind.IsUserDefined() || !isSafeToDereferenceReceiverRefAfterEvaluatingArgument(b.Right))

CodeGen\EmitOperators.cs (17)

60var operatorKind = expression.OperatorKind; 101var operatorKind = binary.OperatorKind; 124operatorKind = binary.OperatorKind; 139bool isChecked = binary.OperatorKind.EmitsAsCheckedInstruction(); 162bool isChecked = expression.OperatorKind.EmitsAsCheckedInstruction(); 177switch (expression.OperatorKind.Operator()) 245throw ExceptionUtilities.UnexpectedValue(expression.OperatorKind.Operator()); 302switch (binOp.OperatorKind.OperatorWithLogical()) 438throw ExceptionUtilities.UnexpectedValue(binOp.OperatorKind.OperatorWithLogical()); 445else if (IsFloat(binOp.OperatorKind)) 510if (IsConditional(binOp.OperatorKind)) 543if (binOp.OperatorKind.IsComparison()) 649switch (expression.OperatorKind.Operator() | expression.OperatorKind.OperandTypes()) 700switch (expression.OperatorKind.Operator()) 736throw ExceptionUtilities.UnexpectedValue(expression.OperatorKind.Operator()); 778BinaryOperatorKind opKind = op.OperatorKind;

CodeGen\EmitStatement.cs (8)

230var opKind = condition.OperatorKind.Operator(); 303switch (op.OperatorKind.Operator()) 330throw ExceptionUtilities.UnexpectedValue(op.OperatorKind.Operator()); 337else if (IsFloat(op.OperatorKind)) 424if (binOp.OperatorKind.OperatorWithLogical() is BinaryOperatorKind.LogicalOr or BinaryOperatorKind.LogicalAnd) 445binary.OperatorKind.OperatorWithLogical() is BinaryOperatorKind.LogicalOr or BinaryOperatorKind.LogicalAnd) 447if (binary.OperatorKind.OperatorWithLogical() is BinaryOperatorKind.LogicalOr ? !top.sense : top.sense) 492switch (binOp.OperatorKind.OperatorWithLogical())

CodeGen\Optimizer.cs (8)

1519var isLogical = (binary.OperatorKind & BinaryOperatorKind.Logical) != 0; 1536Debug.Assert(!binary.OperatorKind.IsDynamic()); 1537left = binary.Update(binary.OperatorKind, binary.ConstantValueOpt, binary.BinaryOperatorMethod, binary.ConstrainedToType, binary.ResultKind, left, right, type); 1558var isLogical = (node.OperatorKind & BinaryOperatorKind.Logical) != 0; 1571Debug.Assert(!node.OperatorKind.IsDynamic()); 1572return node.Update(node.OperatorKind, node.ConstantValueOpt, node.BinaryOperatorMethod, node.ConstrainedToType, node.ResultKind, left, right, node.Type); 2113Debug.Assert(!binary.OperatorKind.IsDynamic()); 2114left = binary.Update(binary.OperatorKind, binary.ConstantValueOpt, binary.BinaryOperatorMethod, binary.ConstrainedToType, binary.ResultKind, left, right, type);

Compilation\CSharpSemanticModel.cs (6)

3850BinaryOperatorKind operandType = binaryOperator.OperatorKind.OperandTypes(); 3851BinaryOperatorKind op = binaryOperator.OperatorKind.Operator(); 3852isDynamic = binaryOperator.OperatorKind.IsDynamic(); 3854if (operandType == 0 || operandType == BinaryOperatorKind.UserDefined || binaryOperator.ResultKind != LookupResultKind.Viable || binaryOperator.OperatorKind.IsLogical()) 3875OperatorFacts.BinaryOperatorNameFromOperatorKind(op, isChecked: binaryOperator.OperatorKind.IsChecked()), 3885binaryOperator.OperatorKind.IsChecked()));

FlowAnalysis\AbstractFlowPass.cs (8)

2392if (node.OperatorKind.IsLogical()) 2394Debug.Assert(!node.OperatorKind.IsUserDefined()); 2431if (!binOp.OperatorKind.IsLogical()) 2436Debug.Assert(!binOp.OperatorKind.IsUserDefined()); 2489kind = binOp.OperatorKind; 2574while (binary != null && !binary.OperatorKind.IsLogical() && binary.InterpolatedStringHandlerData is null); 2654var kind = binary.OperatorKind; 2667=> binary.OperatorKind.Operator() == BinaryOperatorKind.Equal;

FlowAnalysis\NullableWalker.cs (8)

5167&& binary.OperatorKind.Operator() is BinaryOperatorKind.Equal or BinaryOperatorKind.NotEqual) 5238=> binary.OperatorKind.Operator() == BinaryOperatorKind.Equal; 5270if (binary.OperatorKind.Operator() is not (BinaryOperatorKind.Equal or BinaryOperatorKind.NotEqual)) 5294if (binary.OperatorKind.IsUserDefined()) 5342var inferredResult = ReinferAndVisitBinaryOperator(binary, binary.OperatorKind, binary.BinaryOperatorMethod, binary.Type, binary.Left, leftOperand, leftConversion, leftType, binary.Right, rightOperand, rightConversion, rightType); 5552BinaryOperatorKind op = binary.OperatorKind.Operator(); 12288getBinaryConditionalOperatorInfo(node.OperatorKind, out bool isAnd, out bool isBool); 12296SetResultType(node, InferResultNullability(node.OperatorKind, node.BinaryOperatorMethod, node.Type, leftType, rightType));

Generated\BoundNodes.xml.Generated.cs (3)

1681if (operatorKind != this.OperatorKind || data != this.Data || resultKind != this.ResultKind || left != this.Left || right != this.Right || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything)) 11109return node.Update(node.OperatorKind, node.Data, node.ResultKind, left, right, type); 15492new TreeDumperNode("operatorKind", node.OperatorKind, null),

Lowering\BoundTreeToDifferentEnclosingContextRewriter.cs (1)

164Debug.Assert(!node.OperatorKind.IsDynamic());

Lowering\ClosureConversion\ExpressionLambdaRewriter.cs (2)

195Debug.Assert(!binOp.OperatorKind.IsDynamic()); 196return VisitBinaryOperator(binOp.OperatorKind, binOp.BinaryOperatorMethod, binOp.Type, binOp.Left, binOp.Right);

Lowering\DiagnosticsPass_ExpressionTrees.cs (1)

789if (_inExpressionLambda && node.OperatorKind.IsDynamic())

Lowering\DiagnosticsPass_Warnings.cs (16)

272CheckForBitwiseOrSignExtend(node, node.OperatorKind, node.Left, node.Right); 278if (_inExpressionLambda && node.OperatorKind.Operator() == BinaryOperatorKind.UnsignedRightShift) 308if (!node.OperatorKind.IsComparison()) 327if (node.OperatorKind == BinaryOperatorKind.ObjectEqual || node.OperatorKind == BinaryOperatorKind.ObjectNotEqual) 330if (node.Left.Type.SpecialType == SpecialType.System_Object && !IsExplicitCast(node.Left) && !(node.Left.ConstantValueOpt != null && node.Left.ConstantValueOpt.IsNull) && ConvertedHasEqual(node.OperatorKind, node.Right, out t)) 335else if (node.Right.Type.SpecialType == SpecialType.System_Object && !IsExplicitCast(node.Right) && !(node.Right.ConstantValueOpt != null && node.Right.ConstantValueOpt.IsNull) && ConvertedHasEqual(node.OperatorKind, node.Left, out t)) 384Debug.Assert(node.OperatorKind.IsComparison()); 751if (node.OperatorKind.OperandTypes() != BinaryOperatorKind.NullableNull) 756switch (node.OperatorKind.Operator()) 765string always = node.OperatorKind.Operator() == BinaryOperatorKind.NotEqual ? "true" : "false"; 784if (!node.OperatorKind.IsLifted()) 789switch (node.OperatorKind.Operator()) 814string always = node.OperatorKind.Operator() == BinaryOperatorKind.NotEqual ? "true" : "false"; 818Error(node.OperatorKind.IsUserDefined() ? ErrorCode.WRN_NubExprIsConstBool2 : ErrorCode.WRN_NubExprIsConstBool, node, always, node.Left.Type.GetNullableUnderlyingType(), GetTypeForLiftedComparisonWarning(node.Right)); 822Error(node.OperatorKind.IsUserDefined() ? ErrorCode.WRN_NubExprIsConstBool2 : ErrorCode.WRN_NubExprIsConstBool, node, always, node.Right.Type.GetNullableUnderlyingType(), GetTypeForLiftedComparisonWarning(node.Left));

Lowering\ExtensionMethodReferenceRewriter.cs (1)

250Debug.Assert(!node.OperatorKind.IsDynamic());

Lowering\LocalRewriter\LocalRewriter_BinaryOperator.cs (4)

123if (node.OperatorKind is BinaryOperatorKind.Utf8Addition) 145if (current.InterpolatedStringHandlerData is not null || current.OperatorKind is BinaryOperatorKind.Utf8Addition || IsBinaryStringConcatenation(current)) 159loweredLeft = MakeBinaryOperator(original, original.Syntax, original.OperatorKind, loweredLeft, loweredRight, original.Type, original.LeftTruthOperatorMethod ?? original.BinaryOperatorMethod, original.ConstrainedToType, 169Debug.Assert(node.OperatorKind == BinaryOperatorKind.StringConcatenation);

Lowering\LocalRewriter\LocalRewriter_Conversion.cs (2)

166Debug.Assert(node.OperatorKind is BinaryOperatorKind.Utf8Addition); 194Debug.Assert(utf8Addition.OperatorKind is BinaryOperatorKind.Utf8Addition);

Lowering\LocalRewriter\LocalRewriter_StringConcat.cs (3)

18=> binaryOperator is { OperatorKind: var kind } && IsBinaryStringConcatenation(kind); 603SpecialMember member = (current.OperatorKind == BinaryOperatorKind.StringConcatenation) ? 610currentResult = new BoundBinaryOperator(current.Syntax, current.OperatorKind, constantValueOpt: null, method, constrainedToTypeOpt: null, default(LookupResultKind), currentResult, right, current.Type);

Lowering\LocalRewriter\LocalRewriter_UnaryOperator.cs (2)

52if (node.OperatorKind == UnaryOperatorKind.DynamicTrue && binaryOperator.OperatorKind == BinaryOperatorKind.DynamicLogicalOr || 53node.OperatorKind == UnaryOperatorKind.DynamicFalse && binaryOperator.OperatorKind == BinaryOperatorKind.DynamicLogicalAnd)

Lowering\SpillSequenceSpiller.cs (5)

993Debug.Assert(!node.OperatorKind.IsDynamic()); 1007if (node.OperatorKind == BinaryOperatorKind.LogicalBoolOr || node.OperatorKind == BinaryOperatorKind.LogicalBoolAnd) 1013node.OperatorKind == BinaryOperatorKind.LogicalBoolAnd ? _F.Local(tmp) : _F.Not(_F.Local(tmp)), 1026return UpdateExpression(builder, node.Update(node.OperatorKind, node.ConstantValueOpt, node.BinaryOperatorMethod, node.ConstrainedToType, node.ResultKind, left, right, node.Type));

Operations\CSharpOperationFactory.cs (3)

1509BinaryOperatorKind operatorKind = Helper.DeriveBinaryOperatorKind(boundBinaryOperator.OperatorKind); 1516bool isLifted = boundBinaryOperator.OperatorKind.IsLifted(); 1517bool isChecked = boundBinaryOperator.OperatorKind.IsChecked() || (binaryOperatorMethod is not null && SyntaxFacts.IsCheckedOperator(binaryOperatorMethod.Name));