public static FlowGraph HeapSimpleConstructorGraph(FlowGraphId id)
{
var builder = new FlowGraphBuilder(id);
var enterNode = builder.AddEnterNode();
var n = builder.AddLocalVariable(References.Sort, "n");
var newNode = builder.AddCallNode(
new TestRoutineLocation(typeof(SampleFlowGraphGenerator).GetMethod(nameof(NodeConstructorGraph)), true),
new Expression[] { References.Null, ExpressionFactory.IntInterpretation(0), References.Null },
n.ToSingular(),
CallKind.ObjectCreation);
var n_value = builder.AddLocalVariable(Sort.Int, "n_value");
var assert1 = builder.AddLocalVariable(Sort.Bool, "assert1");
var assert2 = builder.AddLocalVariable(Sort.Bool, "assert2");
var assertNode = builder.AddInnerNode(new Operation[]
{
new Assignment(assert1, builder.AddReferenceComparison(false, n, References.Null)),
new FieldRead(n_value, n, SampleLinkedListDefinitions.Value),
new Assignment(assert2, (IntHandle)n_value == 0)
});
var returnNode = builder.AddReturnNode();
builder.AddEdge(enterNode, newNode);
builder.AddEdge(newNode, assertNode);
builder.AddEdge(assertNode, returnNode);
return(builder.FreezeAndReleaseGraph());
}
public void EmptyReturnNodeCreatedProperly()
{
var graphId = new FlowGraphId(1);
var builder = new FlowGraphBuilder(graphId);
var node = builder.AddReturnNode();
FlowGraphTestHelper.CheckReturnNode(node, builder.Graph, 0, 0, 0);
}
public static FlowGraph TrivialGraph(FlowGraphId id)
{
var builder = new FlowGraphBuilder(id);
var enterNode = builder.AddEnterNode();
var retNode = builder.AddReturnNode();
builder.AddEdge(enterNode, retNode);
return(builder.FreezeAndReleaseGraph());
}
public void LocalVariableCreatedProperly()
{
var graphId = new FlowGraphId(1);
var builder = new FlowGraphBuilder(graphId);
string name = "testBoolVar";
var variable = builder.AddLocalVariable(Sort.Bool, name);
ExpressionTestHelper.CheckExpression(variable, ExpressionKind.Variable, Sort.Bool, name, 0);
Assert.AreEqual(builder.Graph, variable.Graph);
}
public void EmptyThrowExceptionNodeCreatedProperly()
{
var graphId = new FlowGraphId(1);
var builder = new FlowGraphBuilder(graphId);
var location = new TestRoutineLocation("ExceptionConstructor");
var node = builder.AddThrowExceptionNode(location);
FlowGraphTestHelper.CheckThrowExceptionNode(node, builder.Graph, 0, 0, location, 0);
}
public void EmptyCallNodeCreatedProperly()
{
var graphId = new FlowGraphId(1);
var builder = new FlowGraphBuilder(graphId);
var location = new TestRoutineLocation("CalledRoutine");
var node = builder.AddCallNode(location);
FlowGraphTestHelper.CheckCallNode(node, builder.Graph, 0, 0, location, 0, 0);
}
public void GlobalVariableCreatedProperly()
{
var graphId = new FlowGraphId(1);
var builder = new FlowGraphBuilder(graphId);
string name = "testBoolVar";
var variableId = new GlobalFlowVariableId(1);
var variable = new GlobalFlowVariable(variableId, Sort.Bool, name);
ExpressionTestHelper.CheckExpression(variable, ExpressionKind.Variable, Sort.Bool, name, 0);
}
public void EdgeCreatedProperly()
{
var graphId = new FlowGraphId(1);
var builder = new FlowGraphBuilder(graphId);
var nodeA = builder.AddInnerNode();
var nodeB = builder.AddInnerNode();
var edge = builder.AddEdge(nodeA, nodeB, true);
Assert.AreEqual(builder.Graph, edge.Graph);
Assert.AreEqual(nodeA, edge.From);
Assert.AreEqual(nodeB, edge.To);
Assert.AreEqual(ExpressionFactory.True, edge.Condition.Expression);
}
public static FlowGraph IntAddGraph(FlowGraphId id)
{
var builder = new FlowGraphBuilder(id);
var aParam = builder.AddLocalVariable(Sort.Int, "a");
var bParam = builder.AddLocalVariable(Sort.Int, "b");
var enterNode = builder.AddEnterNode(new[] { aParam, bParam });
var retValueHandle = (IntHandle)aParam + (IntHandle)bParam;
var retNode = builder.AddReturnNode(new[] { retValueHandle.Expression });
builder.AddEdge(enterNode, retNode);
return(builder.FreezeAndReleaseGraph());
}
public static FlowGraph HeapSimpleComparisonGraph(FlowGraphId id)
{
var builder = new FlowGraphBuilder(id);
var a = builder.AddLocalVariable(References.Sort, "a");
var b = builder.AddLocalVariable(References.Sort, "b");
var enterNode = builder.AddEnterNode(new[] { a, b });
var a_eq_b = builder.AddReferenceComparison(true, a, b);
var a_neq_b = builder.AddReferenceComparison(false, a, b);
var a_next = builder.AddLocalVariable(References.Sort, "a_next");
var b_next = builder.AddLocalVariable(References.Sort, "b_next");
var a_next_eq_b_next = builder.AddReferenceComparison(true, a_next, b_next);
var eqAssert = builder.AddLocalVariable(Sort.Bool, "assert1");
var eqNode = builder.AddInnerNode(new Operation[]
{
new FieldRead(a_next, a, SampleLinkedListDefinitions.Next),
new FieldRead(b_next, b, SampleLinkedListDefinitions.Next),
new Assignment(eqAssert, a_next_eq_b_next)
});
var a_value = builder.AddLocalVariable(Sort.Int, "a_value");
var b_value = builder.AddLocalVariable(Sort.Int, "b_value");
var neqAssert = builder.AddLocalVariable(Sort.Bool, "assert2");
var neqNode = builder.AddInnerNode(new Operation[]
{
new FieldWrite(a, SampleLinkedListDefinitions.Value, new IntHandle(5)),
new FieldWrite(b, SampleLinkedListDefinitions.Value, new IntHandle(10)),
new FieldRead(a_value, a, SampleLinkedListDefinitions.Value),
new FieldRead(b_value, b, SampleLinkedListDefinitions.Value),
new Assignment(neqAssert, (IntHandle)a_value != (IntHandle)b_value)
});
var returnNode = builder.AddReturnNode();
builder.AddEdge(enterNode, eqNode, a_eq_b);
builder.AddEdge(eqNode, returnNode);
builder.AddEdge(enterNode, neqNode, a_neq_b);
builder.AddEdge(neqNode, returnNode);
return(builder.FreezeAndReleaseGraph());
}
public static FlowGraph HeapSimpleBranchingGraph(FlowGraphId id)
{
var builder = new FlowGraphBuilder(id);
var n = builder.AddLocalVariable(References.Sort, "n");
var enterNode = builder.AddEnterNode(n.ToSingular());
var n_eq_null = builder.AddReferenceComparison(true, n, References.Null);
var n_neq_null = builder.AddReferenceComparison(false, n, References.Null);
var eqNewNode = builder.AddCallNode(
new TestRoutineLocation(typeof(SampleFlowGraphGenerator).GetMethod(nameof(NodeConstructorGraph)), true),
new Expression[] { References.Null, ExpressionFactory.IntInterpretation(0), n },
n.ToSingular(),
CallKind.ObjectCreation);
var n_next = builder.AddLocalVariable(References.Sort, "n_next");
var eqAssertResult = builder.AddLocalVariable(Sort.Bool, "assert1");
var eqAssertNode = builder.AddInnerNode(new Operation[]
{
new FieldRead(n_next, n, SampleLinkedListDefinitions.Next),
new Assignment(eqAssertResult, builder.AddReferenceComparison(true, n_next, References.Null))
});
var val = builder.AddLocalVariable(Sort.Int, "val");
var neqAssertResult = builder.AddLocalVariable(Sort.Bool, "assert2");
var neqNode = builder.AddInnerNode(new Operation[]
{
new FieldRead(val, n, SampleLinkedListDefinitions.Value),
new Assignment(neqAssertResult, builder.AddReferenceComparison(false, n, References.Null))
});
var returnNode = builder.AddReturnNode();
builder.AddEdge(enterNode, eqNewNode, n_eq_null);
builder.AddEdge(eqNewNode, eqAssertNode);
builder.AddEdge(eqAssertNode, returnNode);
builder.AddEdge(enterNode, neqNode, n_neq_null);
builder.AddEdge(neqNode, returnNode);
return(builder.FreezeAndReleaseGraph());
}
public void EmptyGraphCreatedProperly()
{
var graphId = new FlowGraphId(1);
var builder = new FlowGraphBuilder(graphId);
Assert.AreNotEqual(null, builder.Graph);
Assert.AreEqual(true, builder.Graph.CanFreeze);
var graphHandler = builder.FreezeAndReleaseGraph();
Assert.AreEqual(null, builder.Graph);
Assert.AreNotEqual(null, graphHandler.Value);
FlowGraph graph = graphHandler;
Assert.AreEqual(graphHandler.Value, graph);
Assert.AreEqual(true, graph.IsFrozen);
Assert.AreEqual(graphId, graph.Id);
Assert.AreEqual(0, graph.Nodes.Count);
Assert.AreEqual(0, graph.Edges.Count);
Assert.AreEqual(0, graph.LocalVariables.Count);
}
public static FlowGraph NodeConstructorGraph(FlowGraphId id)
{
var builder = new FlowGraphBuilder(id);
var @this = builder.AddLocalVariable(References.Sort, "this");
var value = builder.AddLocalVariable(Sort.Int, "value");
var next = builder.AddLocalVariable(References.Sort, "next");
var enterNode = builder.AddEnterNode(new[] { @this, value, next });
var initNode = builder.AddInnerNode(new[]
{
new FieldWrite(@this, SampleLinkedListDefinitions.Value, value),
new FieldWrite(@this, SampleLinkedListDefinitions.Next, next)
});
var returnNode = builder.AddReturnNode(@this.ToSingular());
builder.AddEdge(enterNode, initNode);
builder.AddEdge(initNode, returnNode);
return(builder.FreezeAndReleaseGraph());
}
public static FlowGraph IntMaxGraph(FlowGraphId id)
{
var builder = new FlowGraphBuilder(id);
var aParam = builder.AddLocalVariable(Sort.Int, "a");
var a = (IntHandle)aParam;
var bParam = builder.AddLocalVariable(Sort.Int, "b");
var b = (IntHandle)bParam;
var enterNode = builder.AddEnterNode(new[] { aParam, bParam });
var ifResult = builder.AddLocalVariable(Sort.Bool, "ifResult");
var ifResultHandle = (BoolHandle)ifResult;
var checkNode = builder.AddInnerNode(new Assignment(ifResult, a > b));
var retANode = builder.AddReturnNode(new[] { aParam });
var retBNode = builder.AddReturnNode(new[] { bParam });
builder.AddEdge(enterNode, checkNode);
builder.AddEdge(checkNode, retANode, ifResultHandle);
builder.AddEdge(checkNode, retBNode, !ifResultHandle);
return(builder.FreezeAndReleaseGraph());
}
// TODO: Implement proper exception handling
private async Task <GeneratedGraphs> GenerateGraphsImpl(MethodLocation location, FlowGraphId graphId)
{
var declarationLocation = location.Method.Locations.FirstOrDefault();
Contract.Assert(declarationLocation != null);
Contract.Assert(declarationLocation.IsInSource);
var root = declarationLocation.SourceTree.GetRoot();
var methodSyntax = root.FindNode(declarationLocation.SourceSpan) as BaseMethodDeclarationSyntax;
Contract.Assert(methodSyntax != null);
// TODO: Handle the continuation in a logic way
var document = this.Solution.GetDocument(root.SyntaxTree);
var semanticModel = document.GetSemanticModelAsync().Result;
var builder = new CSharpGraphBuilder(
this.ModelManager,
document.Id,
semanticModel,
methodSyntax);
var buildGraph = await builder.BuildAsync();
var flowGraphTranslator = new FlowGraphTranslator(buildGraph, builder.DisplayGraph, graphId);
var result = flowGraphTranslator.Translate();
result.Location = location;
return(result);
}
public FlowGraph this[FlowGraphId graphId] => this.graphs[graphId.Value];
IRoutineLocation IFlowGraphProvider.GetLocation(FlowGraphId graphId) => this.GetLocation(graphId);
public MethodLocation GetLocation(FlowGraphId graphId)
{
return(this.generatedGraphs[graphId].Location);
}
public DisplayGraph GetDisplayGraph(FlowGraphId graphId)
{
return(this.generatedGraphs[graphId].DisplayGraph);
}
public IRoutineLocation GetLocation(FlowGraphId graphId) => this.locations[graphId.Value];
public LocalFlowVariableOverlay <T> this[FlowGraphId graphId]
{
get { return(this.localVariableOverlay[graphId]); }
set { this.localVariableOverlay[graphId] = value; }
}
public FlowGraphTranslator(BuildGraph buildGraph, DisplayGraph displayGraph, FlowGraphId flowGraphId)
{
this.BuildGraph = buildGraph;
this.DisplayGraph = displayGraph;
this.flowGraphId = flowGraphId;
}
public static FlowGraph ComplexExampleGraph(FlowGraphId id)
{
var builder = new FlowGraphBuilder(id);
var aVar = builder.AddLocalVariable(Sort.Int, "a");
var a = (IntHandle)aVar;
var bVar = builder.AddLocalVariable(Sort.Int, "b");
var b = (IntHandle)bVar;
var cVar = builder.AddLocalVariable(Sort.Bool, "c");
var c = (BoolHandle)cVar;
var enterNode = builder.AddEnterNode(new[] { aVar, bVar, cVar });
var if1Var = builder.AddLocalVariable(Sort.Bool, "if!1");
var if1 = (BoolHandle)if1Var;
var if1Node = builder.AddInnerNode(new Assignment(if1Var, a == 0));
var ret1Node = builder.AddReturnNode(new[] { ExpressionFactory.IntInterpretation(-1) });
var isNiceNumberLocation = new TestRoutineLocation("IsNiceNumber");
var if21Var = builder.AddLocalVariable(Sort.Bool, "if!2!1");
var if21 = (BoolHandle)if21Var;
var if21Node = builder.AddCallNode(isNiceNumberLocation, new[] { aVar }, new[] { if21Var });
var if22CheckVar = builder.AddLocalVariable(Sort.Bool, "if!2!2!check");
var if22Check = (BoolHandle)if22CheckVar;
var if22CheckNode = builder.AddInnerNode(new Assignment(if22CheckVar, b != 0));
var exceptionLocation = new TestRoutineLocation("DivisionByZeroException");
var if22ThrowNode = builder.AddThrowExceptionNode(exceptionLocation);
var if22Var = builder.AddLocalVariable(Sort.Bool, "if!2!2");
var if22 = (BoolHandle)if22Var;
var if22Node = builder.AddInnerNode(new Assignment(if22Var, a / b > 2 && b != -1));
var dVar = builder.AddLocalVariable(Sort.Int, "d");
var d = (IntHandle)dVar;
var dEqualsBNode = builder.AddInnerNode(new Assignment(dVar, bVar));
var while1Var = builder.AddLocalVariable(Sort.Bool, "while!1");
var while1 = (BoolHandle)while1Var;
var while1Node = builder.AddInnerNode(new[] { new Assignment(while1Var, a < b) }, FlowNodeFlags.LoopCondition);
var assert1Var = builder.AddLocalVariable(Sort.Bool, "assert!1");
var assert1 = (BoolHandle)assert1Var;
var whileBodyNode = builder.AddInnerNode(
new[]
{
new Assignment(aVar, a + a),
new Assignment(assert1Var, a != 0)
},
FlowNodeFlags.LoopBody);
var elseBodyNode = builder.AddInnerNode(new Assignment(aVar, a + b));
var ret2Node = builder.AddReturnNode(new[] { aVar });
builder.AddEdge(enterNode, if1Node);
builder.AddEdge(if1Node, ret1Node, if1);
builder.AddEdge(if1Node, if21Node, !if1);
builder.AddEdge(if21Node, if22CheckNode, if21);
builder.AddEdge(if22CheckNode, if22ThrowNode, !if22Check);
builder.AddEdge(if22CheckNode, if22Node, if22Check);
builder.AddEdge(if22Node, dEqualsBNode, if22);
builder.AddEdge(dEqualsBNode, while1Node);
builder.AddEdge(while1Node, whileBodyNode, while1);
builder.AddEdge(whileBodyNode, while1Node);
builder.AddEdge(while1Node, ret2Node, !while1);
builder.AddEdge(if21Node, elseBodyNode, !if21);
builder.AddEdge(if22Node, elseBodyNode, !if22);
builder.AddEdge(elseBodyNode, ret2Node);
return(builder.FreezeAndReleaseGraph());
}
public FlowGraph this[FlowGraphId graphId]
{
get { return(this.generatedGraphs[graphId].FlowGraph); }
}
