public virtual bool VisitCompoundStmt(CompoundStmt stmt)
{
if (!VisitStmt(stmt))
{
return(false);
}
return(true);
}
public bool VisitCompoundStmt(CompoundStmt stmt)
{
throw new NotImplementedException();
}
private (IExprTerm, List <IPStmt>) SimplifyExpression(IPExpr expr)
{
Antlr4.Runtime.ParserRuleContext location = expr.SourceLocation;
List <IPStmt> deps = new List <IPStmt>();
#pragma warning disable CCN0002 // Non exhaustive patterns in switch block
switch (expr)
{
case IExprTerm term:
return(term, deps);
case BinOpExpr binOpExpr:
(IExprTerm lhsTemp, List <IPStmt> lhsDeps) = SimplifyExpression(binOpExpr.Lhs);
(IExprTerm rhsTemp, List <IPStmt> rhsDeps) = SimplifyExpression(binOpExpr.Rhs);
if (binOpExpr.Operation == BinOpType.And)
{
// And is short-circuiting, so we need to treat it differently from other binary operators
deps.AddRange(lhsDeps);
(VariableAccessExpr andTemp, IPStmt andInitialStore) = SaveInTemporary(new CloneExpr(lhsTemp));
deps.Add(andInitialStore);
CompoundStmt reassignFromRhs = new CompoundStmt(location, rhsDeps.Append(new AssignStmt(location, andTemp, new CloneExpr(rhsTemp))));
deps.Add(new IfStmt(location, andTemp, reassignFromRhs, null));
return(andTemp, deps);
}
else if (binOpExpr.Operation == BinOpType.Or)
{
// Or is short-circuiting, so we need to treat it differently from other binary operators
deps.AddRange(lhsDeps);
(VariableAccessExpr orTemp, IPStmt orInitialStore) = SaveInTemporary(new CloneExpr(lhsTemp));
deps.Add(orInitialStore);
CompoundStmt reassignFromRhs = new CompoundStmt(location, rhsDeps.Append(new AssignStmt(location, orTemp, new CloneExpr(rhsTemp))));
deps.Add(new IfStmt(location, orTemp, new NoStmt(location), reassignFromRhs));
return(orTemp, deps);
}
else
{
(VariableAccessExpr binOpTemp, IPStmt binOpStore) =
SaveInTemporary(new BinOpExpr(location, binOpExpr.Operation, lhsTemp, rhsTemp));
deps.AddRange(lhsDeps.Concat(rhsDeps));
deps.Add(binOpStore);
return(binOpTemp, deps);
}
case CastExpr castExpr:
(IExprTerm castSubExpr, List <IPStmt> castDeps) = SimplifyExpression(castExpr.SubExpr);
(VariableAccessExpr castTemp, IPStmt castStore) = SaveInTemporary(new CastExpr(location, new CloneExpr(castSubExpr), castExpr.Type));
deps.AddRange(castDeps);
deps.Add(castStore);
return(castTemp, deps);
case ChooseExpr chooseExpr:
if (chooseExpr.SubExpr != null)
{
(IExprTerm chooseSubExpr, List <IPStmt> chooseDeps) = SimplifyExpression(chooseExpr.SubExpr);
(VariableAccessExpr chooseTemp, IPStmt chooseStore) = SaveInTemporary(new ChooseExpr(location, chooseSubExpr, chooseExpr.Type));
deps.AddRange(chooseDeps);
deps.Add(chooseStore);
return(chooseTemp, deps);
}
else
{
(VariableAccessExpr chooseTemp, IPStmt chooseStore) = SaveInTemporary(chooseExpr);
deps.Add(chooseStore);
return(chooseTemp, deps);
}
case CoerceExpr coerceExpr:
(IExprTerm coerceSubExpr, List <IPStmt> coerceDeps) = SimplifyExpression(coerceExpr.SubExpr);
(VariableAccessExpr coerceTemp, IPStmt coerceStore) =
SaveInTemporary(new CoerceExpr(location, coerceSubExpr, coerceExpr.NewType));
deps.AddRange(coerceDeps);
deps.Add(coerceStore);
return(coerceTemp, deps);
case ContainsExpr containsKeyExpr:
(IExprTerm contKeyExpr, List <IPStmt> contKeyDeps) = SimplifyExpression(containsKeyExpr.Item);
(IExprTerm contMapExpr, List <IPStmt> contMapDeps) = SimplifyExpression(containsKeyExpr.Collection);
(VariableAccessExpr contTemp, IPStmt contStore) =
SaveInTemporary(new ContainsExpr(location, contKeyExpr, contMapExpr));
deps.AddRange(contKeyDeps.Concat(contMapDeps));
deps.Add(contStore);
return(contTemp, deps);
case CtorExpr ctorExpr:
(IReadOnlyList <IVariableRef> ctorArgs, List <IPStmt> ctorArgDeps) = SimplifyArgPack(ctorExpr.Arguments);
deps.AddRange(ctorArgDeps);
(VariableAccessExpr ctorTemp, IPStmt ctorStore) = SaveInTemporary(new CtorExpr(location, ctorExpr.Interface, ctorArgs));
deps.Add(ctorStore);
return(ctorTemp, deps);
case DefaultExpr defaultExpr:
(VariableAccessExpr defTemp, IPStmt defStore) = SaveInTemporary(defaultExpr);
deps.Add(defStore);
return(defTemp, deps);
case FairNondetExpr fairNondetExpr:
(VariableAccessExpr fndTemp, IPStmt fndStore) = SaveInTemporary(fairNondetExpr);
deps.Add(fndStore);
return(fndTemp, deps);
case FunCallExpr funCallExpr:
(ILinearRef[] funArgs, List <IPStmt> funArgsDeps) = SimplifyFunArgs(funCallExpr.Arguments);
deps.AddRange(funArgsDeps);
(VariableAccessExpr funTemp, IPStmt funStore) = SaveInTemporary(new FunCallExpr(location, funCallExpr.Function, funArgs));
deps.Add(funStore);
return(funTemp, deps);
case KeysExpr keysExpr:
(IExprTerm keysColl, List <IPStmt> keysDeps) = SimplifyExpression(keysExpr.Expr);
(VariableAccessExpr keysTemp, IPStmt keysStore) = SaveInTemporary(new KeysExpr(location, keysColl, keysExpr.Type));
deps.AddRange(keysDeps);
deps.Add(keysStore);
return(keysTemp, deps);
case MapAccessExpr mapAccessExpr:
(IExprTerm mapExpr, List <IPStmt> mapDeps) = SimplifyExpression(mapAccessExpr.MapExpr);
(IExprTerm mapIdxExpr, List <IPStmt> mapIdxDeps) = SimplifyExpression(mapAccessExpr.IndexExpr);
(VariableAccessExpr mapItemTemp, IPStmt mapItemStore) =
SaveInTemporary(new MapAccessExpr(location, mapExpr, mapIdxExpr, mapAccessExpr.Type));
deps.AddRange(mapDeps.Concat(mapIdxDeps));
deps.Add(mapItemStore);
return(mapItemTemp, deps);
case NamedTupleAccessExpr namedTupleAccessExpr:
(IExprTerm ntSubExpr, List <IPStmt> ntSubDeps) = SimplifyExpression(namedTupleAccessExpr.SubExpr);
(VariableAccessExpr ntTemp, IPStmt ntStore) =
SaveInTemporary(new NamedTupleAccessExpr(location, ntSubExpr, namedTupleAccessExpr.Entry));
deps.AddRange(ntSubDeps);
deps.Add(ntStore);
return(ntTemp, deps);
case NamedTupleExpr namedTupleExpr:
(IReadOnlyList <IVariableRef> args, List <IPStmt> argDeps) = SimplifyArgPack(namedTupleExpr.TupleFields);
deps.AddRange(argDeps);
(VariableAccessExpr ntVal, IPStmt ntValStore) =
SaveInTemporary(new NamedTupleExpr(location, args, namedTupleExpr.Type));
deps.Add(ntValStore);
return(ntVal, deps);
case NondetExpr nondetExpr:
(VariableAccessExpr ndTemp, IPStmt ndStore) = SaveInTemporary(nondetExpr);
deps.Add(ndStore);
return(ndTemp, deps);
case SeqAccessExpr seqAccessExpr:
(IExprTerm seqExpr, List <IPStmt> seqDeps) = SimplifyExpression(seqAccessExpr.SeqExpr);
(IExprTerm seqIdx, List <IPStmt> seqIdxDeps) = SimplifyExpression(seqAccessExpr.IndexExpr);
(VariableAccessExpr seqElem, IPStmt seqElemStore) =
SaveInTemporary(new SeqAccessExpr(location, seqExpr, seqIdx, seqAccessExpr.Type));
deps.AddRange(seqDeps.Concat(seqIdxDeps));
deps.Add(seqElemStore);
return(seqElem, deps);
case SizeofExpr sizeofExpr:
(IExprTerm sizeExpr, List <IPStmt> sizeDeps) = SimplifyExpression(sizeofExpr.Expr);
(VariableAccessExpr sizeTemp, IPStmt sizeStore) = SaveInTemporary(new SizeofExpr(location, sizeExpr));
deps.AddRange(sizeDeps);
deps.Add(sizeStore);
return(sizeTemp, deps);
case TupleAccessExpr tupleAccessExpr:
(IExprTerm tupItemExpr, List <IPStmt> tupAccessDeps) = SimplifyExpression(tupleAccessExpr.SubExpr);
(VariableAccessExpr tupItemTemp, IPStmt tupItemStore) =
SaveInTemporary(new TupleAccessExpr(location,
tupItemExpr,
tupleAccessExpr.FieldNo,
tupleAccessExpr.Type));
deps.AddRange(tupAccessDeps);
deps.Add(tupItemStore);
return(tupItemTemp, deps);
case UnaryOpExpr unaryOpExpr:
(IExprTerm unExpr, List <IPStmt> unDeps) = SimplifyExpression(unaryOpExpr.SubExpr);
(VariableAccessExpr unTemp, IPStmt unStore) = SaveInTemporary(new UnaryOpExpr(location, unaryOpExpr.Operation, unExpr));
deps.AddRange(unDeps);
deps.Add(unStore);
return(unTemp, deps);
case UnnamedTupleExpr unnamedTupleExpr:
(IReadOnlyList <IVariableRef> tupFields, List <IPStmt> tupFieldDeps) = SimplifyArgPack(unnamedTupleExpr.TupleFields);
deps.AddRange(tupFieldDeps);
(VariableAccessExpr tupVal, IPStmt tupStore) = SaveInTemporary(new UnnamedTupleExpr(location, tupFields));
deps.Add(tupStore);
return(tupVal, deps);
case ValuesExpr valuesExpr:
(IExprTerm valuesColl, List <IPStmt> valuesDeps) = SimplifyExpression(valuesExpr.Expr);
(VariableAccessExpr valuesTemp, IPStmt valuesStore) =
SaveInTemporary(new ValuesExpr(location, valuesColl, valuesExpr.Type));
deps.AddRange(valuesDeps);
deps.Add(valuesStore);
return(valuesTemp, deps);
case StringExpr stringExpr:
(IPExpr[] stringArgs, List <IPStmt> stringArgsDeps) = SimplifyFunArgs(stringExpr.Args);
(VariableAccessExpr stringTemp, IPStmt stringStore) = SaveInTemporary(new StringExpr(location, stringExpr.BaseString, stringArgs.ToList()));
deps.AddRange(stringArgsDeps);
deps.Add(stringStore);
return(stringTemp, deps);
default:
throw new ArgumentOutOfRangeException(nameof(expr));
}
#pragma warning restore CCN0002 // Non exhaustive patterns in switch block
}
public FuncDef(DeclnSpecs specs, Declr declr, CompoundStmt stmt) {
this.Specs = specs;
this.Declr = declr;
this.Stmt = stmt;
}
private (IExprTerm, List <IPStmt>) SimplifyExpression(IPExpr expr)
{
var location = expr.SourceLocation;
var deps = new List <IPStmt>();
switch (expr)
{
case IExprTerm term:
return(term, deps);
case BinOpExpr binOpExpr:
var(lhsTemp, lhsDeps) = SimplifyExpression(binOpExpr.Lhs);
var(rhsTemp, rhsDeps) = SimplifyExpression(binOpExpr.Rhs);
if (binOpExpr.Operation == BinOpType.And)
{
// And is short-circuiting, so we need to treat it differently from other binary operators
deps.AddRange(lhsDeps);
var(andTemp, andInitialStore) = SaveInTemporary(new CloneExpr(lhsTemp));
deps.Add(andInitialStore);
var reassignFromRhs = new CompoundStmt(location, rhsDeps.Append(new AssignStmt(location, andTemp, new CloneExpr(rhsTemp))));
deps.Add(new IfStmt(location, andTemp, reassignFromRhs, null));
return(andTemp, deps);
}
else if (binOpExpr.Operation == BinOpType.Or)
{
// Or is short-circuiting, so we need to treat it differently from other binary operators
deps.AddRange(lhsDeps);
var(orTemp, orInitialStore) = SaveInTemporary(new CloneExpr(lhsTemp));
deps.Add(orInitialStore);
var reassignFromRhs = new CompoundStmt(location, rhsDeps.Append(new AssignStmt(location, orTemp, new CloneExpr(rhsTemp))));
deps.Add(new IfStmt(location, orTemp, new NoStmt(location), reassignFromRhs));
return(orTemp, deps);
}
else
{
var(binOpTemp, binOpStore) =
SaveInTemporary(new BinOpExpr(location, binOpExpr.Operation, lhsTemp, rhsTemp));
deps.AddRange(lhsDeps.Concat(rhsDeps));
deps.Add(binOpStore);
return(binOpTemp, deps);
}
case CastExpr castExpr:
var(castSubExpr, castDeps) = SimplifyExpression(castExpr.SubExpr);
var(castTemp, castStore) = SaveInTemporary(new CastExpr(location, castSubExpr, castExpr.Type));
deps.AddRange(castDeps);
deps.Add(castStore);
return(castTemp, deps);
case CoerceExpr coerceExpr:
var(coerceSubExpr, coerceDeps) = SimplifyExpression(coerceExpr.SubExpr);
var(coerceTemp, coerceStore) =
SaveInTemporary(new CoerceExpr(location, coerceSubExpr, coerceExpr.NewType));
deps.AddRange(coerceDeps);
deps.Add(coerceStore);
return(coerceTemp, deps);
case ContainsExpr containsKeyExpr:
var(contKeyExpr, contKeyDeps) = SimplifyExpression(containsKeyExpr.Item);
var(contMapExpr, contMapDeps) = SimplifyExpression(containsKeyExpr.Collection);
var(contTemp, contStore) =
SaveInTemporary(new ContainsExpr(location, contKeyExpr, contMapExpr));
deps.AddRange(contKeyDeps.Concat(contMapDeps));
deps.Add(contStore);
return(contTemp, deps);
case CtorExpr ctorExpr:
var(ctorArgs, ctorArgDeps) = SimplifyArgPack(ctorExpr.Arguments);
deps.AddRange(ctorArgDeps);
var(ctorTemp, ctorStore) = SaveInTemporary(new CtorExpr(location, ctorExpr.Interface, ctorArgs));
deps.Add(ctorStore);
return(ctorTemp, deps);
case DefaultExpr defaultExpr:
var(defTemp, defStore) = SaveInTemporary(defaultExpr);
deps.Add(defStore);
return(defTemp, deps);
case FairNondetExpr fairNondetExpr:
var(fndTemp, fndStore) = SaveInTemporary(fairNondetExpr);
deps.Add(fndStore);
return(fndTemp, deps);
case FunCallExpr funCallExpr:
var(funArgs, funArgsDeps) = SimplifyFunArgs(funCallExpr.Arguments);
deps.AddRange(funArgsDeps);
var(funTemp, funStore) = SaveInTemporary(new FunCallExpr(location, funCallExpr.Function, funArgs));
deps.Add(funStore);
return(funTemp, deps);
case KeysExpr keysExpr:
var(keysColl, keysDeps) = SimplifyExpression(keysExpr.Expr);
var(keysTemp, keysStore) = SaveInTemporary(new KeysExpr(location, keysColl, keysExpr.Type));
deps.AddRange(keysDeps);
deps.Add(keysStore);
return(keysTemp, deps);
case MapAccessExpr mapAccessExpr:
var(mapExpr, mapDeps) = SimplifyExpression(mapAccessExpr.MapExpr);
var(mapIdxExpr, mapIdxDeps) = SimplifyExpression(mapAccessExpr.IndexExpr);
var(mapItemTemp, mapItemStore) =
SaveInTemporary(new MapAccessExpr(location, mapExpr, mapIdxExpr, mapAccessExpr.Type));
deps.AddRange(mapDeps.Concat(mapIdxDeps));
deps.Add(mapItemStore);
return(mapItemTemp, deps);
case NamedTupleAccessExpr namedTupleAccessExpr:
var(ntSubExpr, ntSubDeps) = SimplifyExpression(namedTupleAccessExpr.SubExpr);
var(ntTemp, ntStore) =
SaveInTemporary(new NamedTupleAccessExpr(location, ntSubExpr, namedTupleAccessExpr.Entry));
deps.AddRange(ntSubDeps);
deps.Add(ntStore);
return(ntTemp, deps);
case NamedTupleExpr namedTupleExpr:
var(args, argDeps) = SimplifyArgPack(namedTupleExpr.TupleFields);
deps.AddRange(argDeps);
var(ntVal, ntValStore) =
SaveInTemporary(new NamedTupleExpr(location, args, namedTupleExpr.Type));
deps.Add(ntValStore);
return(ntVal, deps);
case NondetExpr nondetExpr:
var(ndTemp, ndStore) = SaveInTemporary(nondetExpr);
deps.Add(ndStore);
return(ndTemp, deps);
case SeqAccessExpr seqAccessExpr:
var(seqExpr, seqDeps) = SimplifyExpression(seqAccessExpr.SeqExpr);
var(seqIdx, seqIdxDeps) = SimplifyExpression(seqAccessExpr.IndexExpr);
var(seqElem, seqElemStore) =
SaveInTemporary(new SeqAccessExpr(location, seqExpr, seqIdx, seqAccessExpr.Type));
deps.AddRange(seqDeps.Concat(seqIdxDeps));
deps.Add(seqElemStore);
return(seqElem, deps);
case SizeofExpr sizeofExpr:
var(sizeExpr, sizeDeps) = SimplifyExpression(sizeofExpr.Expr);
var(sizeTemp, sizeStore) = SaveInTemporary(new SizeofExpr(location, sizeExpr));
deps.AddRange(sizeDeps);
deps.Add(sizeStore);
return(sizeTemp, deps);
case TupleAccessExpr tupleAccessExpr:
var(tupItemExpr, tupAccessDeps) = SimplifyExpression(tupleAccessExpr.SubExpr);
var(tupItemTemp, tupItemStore) =
SaveInTemporary(new TupleAccessExpr(location,
tupItemExpr,
tupleAccessExpr.FieldNo,
tupleAccessExpr.Type));
deps.AddRange(tupAccessDeps);
deps.Add(tupItemStore);
return(tupItemTemp, deps);
case UnaryOpExpr unaryOpExpr:
var(unExpr, unDeps) = SimplifyExpression(unaryOpExpr.SubExpr);
var(unTemp, unStore) = SaveInTemporary(new UnaryOpExpr(location, unaryOpExpr.Operation, unExpr));
deps.AddRange(unDeps);
deps.Add(unStore);
return(unTemp, deps);
case UnnamedTupleExpr unnamedTupleExpr:
var(tupFields, tupFieldDeps) = SimplifyArgPack(unnamedTupleExpr.TupleFields);
deps.AddRange(tupFieldDeps);
var(tupVal, tupStore) = SaveInTemporary(new UnnamedTupleExpr(location, tupFields));
deps.Add(tupStore);
return(tupVal, deps);
case ValuesExpr valuesExpr:
var(valuesColl, valuesDeps) = SimplifyExpression(valuesExpr.Expr);
var(valuesTemp, valuesStore) =
SaveInTemporary(new ValuesExpr(location, valuesColl, valuesExpr.Type));
deps.AddRange(valuesDeps);
deps.Add(valuesStore);
return(valuesTemp, deps);
default:
throw new ArgumentOutOfRangeException(nameof(expr));
}
}
