public override void VisitLiteral(ILiteralOperation operation)
{
if (operation.ConstantValue.HasValue && operation.ConstantValue.Value is null)
{
Matched = true;
}
}
/// <summary>
/// コンストラクタ
/// </summary>
/// <param name="operation">IOperationインスタンス</param>
/// <param name="container">イベントコンテナ</param>
public Literal(ILiteralOperation operation, EventContainer container) : base(container)
{
var literalValue = operation.ConstantValue.Value;
// nullの場合はその情報を格納して終了
if (literalValue is null)
{
var type = "null";
Expressions.Add(new Expression(type, type));
return;
}
// 各Typeごとの加工処理
if (literalValue is string)
{
literalValue = $"\"{literalValue}\"";
}
if (literalValue is bool)
{
literalValue = $"{literalValue}".ToLower(CultureInfo.CurrentCulture);
}
// 情報格納
Expressions.Add(new Expression(literalValue.ToString(), Expression.GetSymbolTypeName(operation.Type)));
}
public FixInfo(string fixValue, ILiteralOperation sourceLiteralAtLocationToFix)
{
FixValue = fixValue;
SourceLiteralAtLocationToFix = sourceLiteralAtLocationToFix;
AdditionalDocumentToFix = null;
AdditionalDocumentSpanToFix = null;
}
private Task VisitLiteralAsync(ILiteralOperation literalOperation, CancellationToken cancellationToken)
{
if (literalOperation.Type is null)
{
return(Task.CompletedTask);
}
return(AddOperationAsync(literalOperation, literalOperation.Type, cancellationToken));
}
public static bool IsExpressionEqualsIntZero(IOperation operation)
{
ILiteralOperation literal = operation as ILiteralOperation;
if (literal == null || !literal.ConstantValue.HasValue)
{
return(false);
}
return(literal.HasConstantValue(0));
}
static async Task <Document?> HandleStringLiteral(ILiteralOperation argumentLiteral, Document doc, SyntaxNode root, CancellationToken cancellationToken)
{
var unitString = (string)argumentLiteral.ConstantValue.Value;
DocumentEditor editor = await DocumentEditor.CreateAsync(doc, cancellationToken).ConfigureAwait(false);
SyntaxGenerator generator = editor.Generator;
char charValue = unitString[0];
SyntaxNode charLiteralExpressionNode = generator.LiteralExpression(charValue);
var newRoot = generator.ReplaceNode(root, argumentLiteral.Syntax, charLiteralExpressionNode);
return(doc.WithSyntaxRoot(newRoot));
}
private static AbstractExpression ReadLiteral(ILiteralOperation op)
{
var context = CodeReaderContext.GetContextOrThrow();
var type = (op.Type != null
? context.FindMemberOrThrow <TypeMember>(binding: op.Type)
: null);
return(new ConstantExpression {
Type = type,
Value = op.ConstantValue.HasValue ? op.ConstantValue.Value : null
});
}
private static bool CanSimplifyToLengthEqualsZeroExpression(
IOperation variableExpression,
ILiteralOperation numericLiteralExpression
)
{
var numericValue = numericLiteralExpression.ConstantValue;
if (numericValue.HasValue && numericValue.Value is 0)
{
if (variableExpression is IPropertyReferenceOperation propertyOperation)
{
var property = propertyOperation.Property;
if ((property.Name == nameof(Array.Length) || property.Name == LongLength))
{
var containingType = property.ContainingType;
if (
containingType?.SpecialType == SpecialType.System_Array ||
containingType.SpecialType == SpecialType.System_String
)
{
return(true);
}
}
}
var type = variableExpression.Type;
if (type != null)
{
switch (type.SpecialType)
{
case SpecialType.System_Byte:
case SpecialType.System_UInt16:
case SpecialType.System_UInt32:
case SpecialType.System_UInt64:
return(true);
}
}
}
return(false);
}
public static bool IsExpressionEqualsNull(IOperation operation)
{
ILiteralOperation literal = operation as ILiteralOperation;
return(literal != null && literal.HasNullConstantValue());
}
public override IOperation VisitLiteral(ILiteralOperation operation, object argument)
{
return(new LiteralExpression(((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit));
}
public override void VisitLiteral(ILiteralOperation operation)
{
Assert.Equal(OperationKind.Literal, operation.Kind);
Assert.Empty(operation.Children);
}
public virtual void VisitLiteral(ILiteralOperation operation)
{
DefaultVisit(operation);
}
public override void VisitLiteral([NotNull] ILiteralOperation operation)
{
base.VisitLiteral(operation);
}
public override void VisitLiteral([NotNull] ILiteralOperation operation)
{
Result.SetImmediate();
}
public override Scope VisitLiteral(ILiteralOperation operation, Scope currentScope) => currentScope;
public override bool VisitLiteral([NotNull] ILiteralOperation operation1, [CanBeNull] IOperation argument)
{
return(argument is ILiteralOperation operation2 && AreBaseOperationsEqual(operation1, operation2));
}
