public void Build()
{
if (_result == null)
{
BlockParser parser = new BlockParser(_blacklistManager, _problemPipe, _returnFragment, _referenceAndOutConditions);
Dictionary <int, BasicBlock> graph = new Dictionary <int, BasicBlock>();
int initialBlockId;
List <Block> blockList = GetBlocks(_methodBody.Statements);
using (var blocksEnumerator = blockList.GetEnumerator())
{
if (!blocksEnumerator.MoveNext())
{
return;
}
var currentBlock = blocksEnumerator.Current;
// ReSharper disable PossibleNullReferenceException
initialBlockId = currentBlock.UniqueKey;
// ReSharper restore PossibleNullReferenceException
BasicBlock currentBasicBlock;
while (blocksEnumerator.MoveNext())
{
var nextBlock = blocksEnumerator.Current;
if (ContainsUnconditionalBranch(currentBlock))
{
currentBasicBlock = parser.Parse(currentBlock);
}
else
{
// ReSharper disable PossibleNullReferenceException
currentBasicBlock = parser.Parse(currentBlock, nextBlock.UniqueKey);
// ReSharper restore PossibleNullReferenceException
}
graph.Add(currentBasicBlock.Id, currentBasicBlock);
currentBlock = nextBlock;
}
currentBasicBlock = parser.Parse(currentBlock);
graph.Add(currentBasicBlock.Id, currentBasicBlock);
}
_result = new MethodGraph(initialBlockId, graph);
}
}
public void Parse_ValidReturnWithIf_ReturnsCorrectReturnFragmentType()
{
_blockParser = new BlockParser(_blacklist, _problemPipeStub, Fragment.CreateNamed("DummyFragment"), new List <ReturnCondition>());
TypeNode stringTypeNode = IntrospectionUtility.TypeNodeFactory <string>();
Method sampleMethod = TestHelper.GetSample <BlockParserSample> ("ValidReturnWithLiteralAssignmentInsideIf", stringTypeNode);
Block sample = sampleMethod.Body.Statements[3] as Block;
BasicBlock returnedBlock = _blockParser.Parse(sample);
var preConditionFragmentType = returnedBlock.PreConditions[0].Fragment;
Assert.That(preConditionFragmentType, Is.EqualTo(Fragment.CreateNamed("DummyFragment")));
}
public void Parse_ReturnFragmentRequiredUnsafeReturn_ReturnsCorrectReturnFragmentType2()
{
var returnFragmentType = Fragment.CreateNamed("ReturnFragmentType2");
_blockParser = new BlockParser(_blacklist, _problemPipeStub, returnFragmentType, new List <ReturnCondition>());
Method sampleMethod = TestHelper.GetSample <BlockParserSample> ("UnsafeReturnWhenFragmentRequired");
Block sample = sampleMethod.Body.Statements[1] as Block;
BasicBlock returnedBlock = _blockParser.Parse(sample);
var preConditionFragment = returnedBlock.PreConditions[0].Fragment;
Assert.That(preConditionFragment, Is.EqualTo(returnFragmentType));
}
public void Parse_NotBlock_ReturnsNull()
{
// Arrange
var parser = new Parser("foo");
var blockParser = new BlockParser(parser);
parser.PushScopeStack();
// Act
var result = blockParser.Parse();
// Assert
Assert.That(result, Is.Null);
Assert.That(parser.StackCount, Is.EqualTo(0));
}
public void Parse_Method_ReturnsBlockWithMethod()
{
// Arrange
var parser = new Parser("{ main() { } }");
var blockParser = new BlockParser(parser);
parser.PushScopeStack();
// Act
var result = blockParser.Parse() as Block;
// Assert
Assert.That(result.Statements, Has.One.InstanceOf <Method>());
Assert.That(parser.StackCount, Is.EqualTo(0));
}
public void Parse_Empty_ReturnsEmptyBlock()
{
// Arrange
var parser = new Parser("{ }");
var blockParser = new BlockParser(parser);
parser.PushScopeStack();
// Act
var result = blockParser.Parse();
// Assert
Assert.That(result, Is.InstanceOf <Block>().With.Property(nameof(Block.Statements)).Empty);
Assert.That(parser.StackCount, Is.EqualTo(0));
}
protected virtual void Init()
{
RootScope = BlockParser.Parse(Method, Method.Body);
IRContext = new IRContext(Method, Method.Body);
}
public void Parse_PostConditionOnlySafeSymbols()
{
Method sampleMethod = TestHelper.GetSample <BlockParserSample> ("PostConditionOnlySafeSymbols");
Block sample = sampleMethod.Body.Statements[0] as Block;
BasicBlock basicBlock = _blockParser.Parse(sample);
bool correctPostCondition = basicBlock.PostConditionSymbolTable.IsAssignableTo("local$0", Fragment.CreateNamed("SqlFragment")) &&
basicBlock.PostConditionSymbolTable.IsAssignableTo("local$1", Fragment.CreateNamed("SqlFragment"));
Assert.That(correctPostCondition, Is.True);
}
static public void Merge(TextAsset inTextAsset, TextPackage ioTarget)
{
BlockParser.Parse(ref ioTarget, inTextAsset.name, inTextAsset.text, BlockParsingRules.Default, new Generator());
}
static public TextPackage Parse(TextAsset inTextAsset)
{
return(BlockParser.Parse(inTextAsset.name, inTextAsset.text, BlockParsingRules.Default, new Generator()));
}
