protected override BaseStatement Visit(CompoundAssignment compAss)
{
if (_toRemove.Contains(compAss.Left))
return new EmptyStatement();
else
return base.Visit(compAss);
}
protected override BaseStatement Visit(CompoundAssignment compAss)
{
if (compAss.Op != Grammar.YololBinaryOp.Add && compAss.Op != Grammar.YololBinaryOp.Subtract)
{
return(base.Visit(compAss));
}
if (!compAss.Expression.IsConstant)
{
return(base.Visit(compAss));
}
// if right side cannot be evaluated then we can't compress it
var right = compAss.Expression.TryStaticEvaluate();
if (!right.HasValue)
{
return(base.Visit(compAss));
}
var type = _types.TypeOf(compAss.Left);
switch (type)
{
default:
case null:
case Type.Error:
case Type.Unassigned:
return(base.Visit(compAss));
case Type.Number: {
if (right != 1)
{
return(base.Visit(compAss));
}
if (compAss.Op == Grammar.YololBinaryOp.Add)
{
return(new Assignment(compAss.Left, new Increment(compAss.Left)));
}
else
{
return(new Assignment(compAss.Left, new Decrement(compAss.Left)));
}
}
case Type.String: {
if (right != " " || compAss.Op != Grammar.YololBinaryOp.Add)
{
return(base.Visit(compAss));
}
return(new Assignment(compAss.Left, new Increment(compAss.Left)));
}
}
}
protected override IEnumerable <BaseStatement> Visit(CompoundAssignment compAss)
{
var tmp = new VariableName(_names.Name());
var a = new ExpressionDecomposition(_names).Visit(compAss.Expression).ToArray();
var b = new Assignment(tmp, BaseBinaryExpression.Create(compAss.Op, new Variable(new VariableName(compAss.Left.Name)), new Variable(((Assignment)a.Last()).Left)));
var c = new Assignment(new VariableName(compAss.Left.Name), new Variable(tmp));
return(a.Append(b).Append(c));
}
protected override BaseStatement Visit(CompoundAssignment compAss)
{
var r = base.Visit(compAss.Right);
if (r is ErrorExpression)
{
return(new ErrorStatement());
}
return(compAss);
}
protected override BaseStatement Visit(CompoundAssignment ass)
{
if (ass.Left.Equals(_var))
{
return(new EmptyStatement());
}
else
{
return(base.Visit(ass));
}
}
protected override BaseStatement Visit(CompoundAssignment compAss)
{
if (_toRemove.Contains(compAss.Left))
{
return(new EmptyStatement());
}
else
{
return(base.Visit(compAss));
}
}
public TResult Visit(BaseStatement statement)
{
return(statement switch {
Conditional a => Visit(a),
TypedAssignment a => Visit(a),
ErrorStatement a => Visit(a),
CompoundAssignment a => Visit(a),
Assignment a => Visit(a),
ExpressionWrapper a => Visit(a),
Goto a => Visit(a),
If a => Visit(a),
StatementList a => Visit(a),
EmptyStatement a => Visit(a),
_ => VisitUnknown(statement)
});
[NotNull] protected abstract TResult Visit([NotNull] CompoundAssignment compAss);
protected override BaseStatement Visit(CompoundAssignment compAss)
{
_names.Add(compAss.Left);
return(base.Visit(compAss));
}
protected override BaseStatement Visit(CompoundAssignment compAss)
{
using (AppendLine($"Assign({compAss.Left.Name}) {compAss.Op.String()}= "))
return(base.Visit(compAss));
}
[NotNull] protected virtual BaseStatement Visit([NotNull] CompoundAssignment compAss)
{
var expr = Visit(compAss.Expression);
return(new CompoundAssignment(Visit(compAss.Left), compAss.Op, expr));
}
/// <summary>
/// IExpressionリスト取得
/// </summary>
/// <param name="operation">IOperationインスタンス</param>
/// <param name="container">イベントコンテナ</param>
/// <returns>IExpressionリスト</returns>
public static List <IExpression> GetExpressionList(IOperation operation, EventContainer container)
{
List <IExpression> result = new List <IExpression>();
AbstractOperation instance = null;
switch (operation)
{
// 式系
case ISimpleAssignmentOperation param:
instance = new SimpleAssignment(param, container);
break;
case IInvocationOperation param:
instance = new Invocation(param, container);
break;
case IBinaryOperation param:
instance = new Binary(param, container);
break;
case IIncrementOrDecrementOperation param:
instance = new Increment(param, container);
break;
case ICompoundAssignmentOperation param:
instance = new CompoundAssignment(param, container);
break;
case IConversionOperation param:
result.AddRange(GetExpressionList(param.Operand, container));
break;
// 参照系
case IInstanceReferenceOperation param:
instance = new InstanceReference(param, container);
break;
case IFieldReferenceOperation param:
instance = new FieldReference(param, container);
break;
case IPropertyReferenceOperation param:
instance = new PropertyReference(param, container);
break;
case ILocalReferenceOperation param:
instance = new LocalReference(param, container);
break;
case IParameterReferenceOperation param:
instance = new ParameterReference(param, container);
break;
case IArrayElementReferenceOperation param:
instance = new ArrayElementReference(param, container);
break;
case IArgumentOperation param:
instance = new Argument(param, container);
break;
// 生成系
case IObjectCreationOperation param:
instance = new ObjectCreation(param, container);
break;
case IArrayCreationOperation param:
instance = new ArrayCreation(param, container);
break;
case IArrayInitializerOperation param:
instance = new ArrayInitializer(param, container);
break;
case IVariableDeclaratorOperation param:
instance = new VariableDeclarator(param, container);
break;
// 直値
case ILiteralOperation param:
instance = new Literal(param, container);
break;
// Switch Case系
case IDefaultCaseClauseOperation param:
instance = new DefalutCase(param, container);
break;
case IDeclarationPatternOperation param:
instance = new DeclarationPattern(param, container);
break;
//If系
case IIsPatternOperation param:
instance = new IsPattern(param, container);
break;
case IIsTypeOperation param:
instance = new IsType(param, container);
break;
default:
Console.Write($" [{operation.Kind} is none] ");
break;
}
// リスト追加
if (instance != null)
{
result.AddRange(instance.Expressions);
}
return(result);
}
protected override bool Visit(CompoundAssignment compAss)
{
return(_check.Visit(compAss.Right));
}
