public bool VisitUnwrapOptionTunnel(UnwrapOptionTunnel unwrapOptionTunnel)
{
FrameData frameData = _frameData[(Frame)unwrapOptionTunnel.ParentStructure];
VariableReference tunnelInput = unwrapOptionTunnel.InputTerminals.ElementAt(0).GetTrueVariable(),
tunnelOutput = unwrapOptionTunnel.OutputTerminals.ElementAt(0).GetTrueVariable();
LoadLocalAllocationReference(tunnelInput);
_builder.EmitDerefInteger();
_builder.EmitBranchIfFalse(frameData.UnwrapFailed);
// TODO: we could cheat here and do nothing if we say that the address of the
// output is the address of the value within the input
// (assuming Option<T> always ::= { bool, T })
LoadLocalAllocationReference(tunnelOutput);
LoadLocalAllocationReference(tunnelInput);
_builder.EmitLoadIntegerImmediate(4);
_builder.EmitAdd();
if (tunnelOutput.Type.IsRebarReferenceType())
{
_builder.EmitDerefPointer();
_builder.EmitStorePointer();
}
else
{
// TODO
_builder.EmitDerefInteger();
_builder.EmitStoreInteger();
}
return(true);
}
public void UnwrapOptionTunnelWithSomeInputAndYieldingFrameInterior_Execute_FrameExecutes()
{
DfirRoot function = DfirRoot.Create();
FunctionalNode some = new FunctionalNode(function.BlockDiagram, Signatures.SomeConstructorType);
ConnectConstantToInputTerminal(some.InputTerminals[0], NITypes.Int32, 5, false);
Frame frame = Frame.Create(function.BlockDiagram);
UnwrapOptionTunnel unwrapOptionTunnel = new UnwrapOptionTunnel(frame);
Wire.Create(function.BlockDiagram, some.OutputTerminals[0], unwrapOptionTunnel.InputTerminals[0]);
BorrowTunnel borrowTunnel = CreateBorrowTunnel(frame, BorrowMode.Mutable);
ConnectConstantToInputTerminal(borrowTunnel.InputTerminals[0], NITypes.Int32, 0, true);
FunctionalNode assign = new FunctionalNode(frame.Diagram, Signatures.AssignType);
var yieldNode = new FunctionalNode(frame.Diagram, Signatures.YieldType);
Wire.Create(frame.Diagram, borrowTunnel.OutputTerminals[0], yieldNode.InputTerminals[0]);
Wire.Create(frame.Diagram, yieldNode.OutputTerminals[0], assign.InputTerminals[0]);
Wire.Create(frame.Diagram, unwrapOptionTunnel.OutputTerminals[0], assign.InputTerminals[1]);
FunctionalNode inspect = ConnectInspectToOutputTerminal(borrowTunnel.TerminateLifetimeTunnel.OutputTerminals[0]);
TestExecutionInstance executionInstance = CompileAndExecuteFunction(function);
byte[] finalValue = executionInstance.GetLastValueFromInspectNode(inspect);
AssertByteArrayIsInt32(finalValue, 5);
}
public void OpenFileHandleAndReadLine_Execute_LineReadFromFile()
{
string filePath = Path.Combine(TestContext.DeploymentDirectory, Path.GetRandomFileName());
const string data = "data";
CreateFileAndWriteData(filePath, data + "\r\n");
DfirRoot function = DfirRoot.Create();
FunctionalNode openFileHandle = new FunctionalNode(function.BlockDiagram, Signatures.OpenFileHandleType);
Constant pathConstant = ConnectStringConstantToInputTerminal(openFileHandle.InputTerminals[0], filePath);
Frame frame = Frame.Create(function.BlockDiagram);
UnwrapOptionTunnel unwrapOption = new UnwrapOptionTunnel(frame);
Wire.Create(function.BlockDiagram, openFileHandle.OutputTerminals[1], unwrapOption.InputTerminals[0]);
FunctionalNode readLineFromFileHandle = new FunctionalNode(frame.Diagram, Signatures.ReadLineFromFileHandleType);
Wire.Create(frame.Diagram, unwrapOption.OutputTerminals[0], readLineFromFileHandle.InputTerminals[0]);
Frame innerFrame = Frame.Create(frame.Diagram);
UnwrapOptionTunnel innerUnwrapOption = new UnwrapOptionTunnel(innerFrame);
Wire.Create(frame.Diagram, readLineFromFileHandle.OutputTerminals[1], innerUnwrapOption.InputTerminals[0]);
FunctionalNode output = new FunctionalNode(innerFrame.Diagram, Signatures.OutputType);
Wire.Create(innerFrame.Diagram, innerUnwrapOption.OutputTerminals[0], output.InputTerminals[0]);
TestExecutionInstance executionInstance = CompileAndExecuteFunction(function);
Assert.AreEqual(data, executionInstance.RuntimeServices.LastOutputValue);
}
public void UnwrapOptionTunnelWithNoneInputAndDroppableUnwrapOptionTunnel_Execute_DroppableValueIsDropped()
{
DfirRoot function = DfirRoot.Create();
FunctionalNode some = CreateInt32SomeConstructor(function.BlockDiagram, 0);
var none = new FunctionalNode(function.BlockDiagram, Signatures.NoneConstructorType);
var assign = new FunctionalNode(function.BlockDiagram, Signatures.AssignType);
Wire.Create(function.BlockDiagram, some.OutputTerminals[0], assign.InputTerminals[0])
.SetWireBeginsMutableVariable(true);
Wire.Create(function.BlockDiagram, none.OutputTerminals[0], assign.InputTerminals[1]);
Frame frame = Frame.Create(function.BlockDiagram);
var unwrapOptionTunnel = new UnwrapOptionTunnel(frame);
Wire.Create(function.BlockDiagram, assign.OutputTerminals[0], unwrapOptionTunnel.InputTerminals[0]);
FunctionalNode createFakeDrop = CreateFakeDropWithId(function.BlockDiagram, 1);
var someFakeDrop = new FunctionalNode(function.BlockDiagram, Signatures.SomeConstructorType);
Wire.Create(function.BlockDiagram, createFakeDrop.OutputTerminals[0], someFakeDrop.InputTerminals[0]);
var someUnwrapOptionTunnel = new UnwrapOptionTunnel(frame);
Wire.Create(function.BlockDiagram, someFakeDrop.OutputTerminals[0], someUnwrapOptionTunnel.InputTerminals[0]);
TestExecutionInstance executionInstance = CompileAndExecuteFunction(function);
Assert.IsTrue(executionInstance.RuntimeServices.DroppedFakeDropIds.Contains(1), "Expected FakeDrop value to be dropped.");
}
public bool VisitUnwrapOptionTunnel(UnwrapOptionTunnel unwrapOptionTunnel)
{
// TODO: it would be nice to allow the output value source to reference an offset from the input value source,
// rather than needing a separate allocation.
CreateLocalAllocationForVariable(unwrapOptionTunnel.OutputTerminals[0].GetTrueVariable());
return(true);
}
bool IDfirNodeVisitor <bool> .VisitUnwrapOptionTunnel(UnwrapOptionTunnel unwrapOptionTunnel)
{
Terminal optionInput = unwrapOptionTunnel.InputTerminals[0],
unwrappedOutput = unwrapOptionTunnel.OutputTerminals[0];
TypeVariableReference innerTypeVariable = _typeVariableSet.CreateReferenceToNewTypeVariable();
_nodeFacade[optionInput] = new SimpleTerminalFacade(
optionInput,
_typeVariableSet.CreateReferenceToOptionType(innerTypeVariable));
_nodeFacade[unwrappedOutput] = new SimpleTerminalFacade(unwrappedOutput, innerTypeVariable);
return(true);
}
public void UnwrapOptionTunnelWithNonOptionTypeWired_ValidateVariableUsages_TypeConflictErrorCreated()
{
DfirRoot function = DfirRoot.Create();
Frame frame = Frame.Create(function.BlockDiagram);
UnwrapOptionTunnel unwrapOption = CreateUnwrapOptionTunnel(frame);
ConnectConstantToInputTerminal(unwrapOption.InputTerminals[0], PFTypes.Int32, false);
RunSemanticAnalysisUpToValidation(function);
AssertTerminalHasTypeConflictMessage(unwrapOption.InputTerminals[0]);
}
public void OutputTunnelWithInnerDiagramReferenceTypeInputOnFrameWithUnwrapOptionTunnel_ValidateVariableUsages_ErrorReported()
{
DfirRoot function = DfirRoot.Create();
Frame frame = Frame.Create(function.BlockDiagram);
UnwrapOptionTunnel unwrapOption = CreateUnwrapOptionTunnel(frame);
Tunnel outputTunnel = CreateOutputTunnel(frame);
FunctionalNode someConstructor = ConnectSomeConstructorToInputTerminal(outputTunnel.InputTerminals[0]);
ExplicitBorrowNode borrow = ConnectExplicitBorrowToInputTerminals(someConstructor.InputTerminals[0]);
ConnectConstantToInputTerminal(borrow.InputTerminals[0], PFTypes.Int32, false);
RunSemanticAnalysisUpToValidation(function);
Assert.IsTrue(outputTunnel.InputTerminals[0].GetDfirMessages().Any(message => message.Descriptor == Messages.WiredReferenceDoesNotLiveLongEnough.Descriptor));
}
public void UnwrapOptionTunnelWithOptionTypeWired_SetVariableTypes_OutputTerminalIsInnerType()
{
DfirRoot function = DfirRoot.Create();
Frame frame = Frame.Create(function.BlockDiagram);
UnwrapOptionTunnel unwrapOption = CreateUnwrapOptionTunnel(frame);
FunctionalNode someConstructor = ConnectSomeConstructorToInputTerminal(unwrapOption.InputTerminals[0]);
ConnectConstantToInputTerminal(someConstructor.InputTerminals[0], PFTypes.Int32, false);
RunSemanticAnalysisUpToSetVariableTypes(function);
VariableReference unwrapVariable = unwrapOption.OutputTerminals[0].GetTrueVariable();
Assert.IsTrue(unwrapVariable.Type.IsInt32());
}
public void UnwrapOptionTunnelWithSomeReferenceInputAndUnusedOutput_Execute_CompilesCorrectly()
{
DfirRoot function = DfirRoot.Create();
ExplicitBorrowNode borrow = new ExplicitBorrowNode(function.BlockDiagram, BorrowMode.Immutable, 1, true, true);
ConnectConstantToInputTerminal(borrow.InputTerminals[0], NITypes.Int32, false);
var some = new FunctionalNode(function.BlockDiagram, Signatures.SomeConstructorType);
Wire.Create(function.BlockDiagram, borrow.OutputTerminals[0], some.InputTerminals[0]);
Frame frame = Frame.Create(function.BlockDiagram);
var unwrapOptionTunnel = new UnwrapOptionTunnel(frame);
Wire.Create(function.BlockDiagram, some.OutputTerminals[0], unwrapOptionTunnel.InputTerminals[0]);
CompileAndExecuteFunction(function);
}
public void FillVectorEnoughToGrowItThenRemoveAllElements_Execute_AllElementsPreservedAndRemoved()
{
DfirRoot function = DfirRoot.Create();
var createVector = new FunctionalNode(function.BlockDiagram, Signatures.VectorCreateType);
Loop firstLoop = new Loop(function.BlockDiagram);
CreateLoopConditionTunnel(firstLoop);
BorrowTunnel firstLoopBorrowTunnel = CreateBorrowTunnel(firstLoop, BorrowMode.Mutable);
Wire.Create(function.BlockDiagram, createVector.OutputTerminals[0], firstLoopBorrowTunnel.InputTerminals[0])
.SetWireBeginsMutableVariable(true);
IterateTunnel iterateTunnel = CreateRangeAndIterateTunnel(firstLoop, 1, 7);
var appendToVector = new FunctionalNode(firstLoop.Diagram, Signatures.VectorAppendType);
Wire.Create(firstLoop.Diagram, firstLoopBorrowTunnel.OutputTerminals[0], appendToVector.InputTerminals[0]);
Wire.Create(firstLoop.Diagram, iterateTunnel.OutputTerminals[0], appendToVector.InputTerminals[1]);
Loop secondLoop = new Loop(function.BlockDiagram);
CreateLoopConditionTunnel(secondLoop);
BorrowTunnel secondLoopBorrowTunnel = CreateBorrowTunnel(secondLoop, BorrowMode.Mutable);
Wire.Create(function.BlockDiagram, firstLoopBorrowTunnel.TerminateLifetimeTunnel.OutputTerminals[0], secondLoopBorrowTunnel.InputTerminals[0]);
CreateRangeAndIterateTunnel(secondLoop, 1, 7);
var removeLastFromVector = new FunctionalNode(secondLoop.Diagram, Signatures.VectorRemoveLastType);
Wire.Create(secondLoop.Diagram, secondLoopBorrowTunnel.OutputTerminals[0], removeLastFromVector.InputTerminals[0]);
BorrowTunnel resultBorrowTunnel = CreateBorrowTunnel(secondLoop, BorrowMode.Mutable);
ConnectConstantToInputTerminal(resultBorrowTunnel.InputTerminals[0], NITypes.Int32, 0, true);
Frame unwrapFrame = Frame.Create(secondLoop.Diagram);
UnwrapOptionTunnel unwrapTunnel = CreateUnwrapOptionTunnel(unwrapFrame);
Wire.Create(secondLoop.Diagram, removeLastFromVector.OutputTerminals[1], unwrapTunnel.InputTerminals[0]);
Tunnel inputTunnel = CreateInputTunnel(unwrapFrame);
Wire.Create(secondLoop.Diagram, resultBorrowTunnel.OutputTerminals[0], inputTunnel.InputTerminals[0]);
var accumulateAdd = new FunctionalNode(unwrapFrame.Diagram, Signatures.DefineMutatingBinaryFunction("AccumulateAdd", NITypes.Int32));
Wire.Create(unwrapFrame.Diagram, inputTunnel.OutputTerminals[0], accumulateAdd.InputTerminals[0]);
Wire.Create(unwrapFrame.Diagram, unwrapTunnel.OutputTerminals[0], accumulateAdd.InputTerminals[1]);
FunctionalNode inspect = ConnectInspectToOutputTerminal(resultBorrowTunnel.TerminateLifetimeTunnel.OutputTerminals[0]);
TestExecutionInstance executionInstance = CompileAndExecuteFunction(function);
byte[] inspectValue = executionInstance.GetLastValueFromInspectNode(inspect);
AssertByteArrayIsInt32(inspectValue, 21);
}
public void OutputTunnelOnFrameWithUnwrapOptionTunnelWithNonOptionInput_SetVariableTypes_OutputTerminalIsOptionType()
{
DfirRoot function = DfirRoot.Create();
Frame frame = Frame.Create(function.BlockDiagram);
UnwrapOptionTunnel unwrapOption = CreateUnwrapOptionTunnel(frame);
Tunnel outputTunnel = CreateOutputTunnel(frame);
ConnectConstantToInputTerminal(outputTunnel.InputTerminals[0], PFTypes.Int32, false);
RunSemanticAnalysisUpToSetVariableTypes(function);
VariableReference outputVariable = outputTunnel.OutputTerminals[0].GetTrueVariable();
NIType innerType;
Assert.IsTrue(outputVariable.Type.TryDestructureOptionType(out innerType));
Assert.IsTrue(innerType.IsInt32());
}
public void PanickingUnwrapOptionIntoConditionalFrame_Execute_FrameDoesNotExecute()
{
DfirRoot function = DfirRoot.Create();
FunctionalNode unwrap = CreatePanickingUnwrapOption(function.BlockDiagram);
Frame frame = Frame.Create(function.BlockDiagram);
Tunnel inputTunnel = CreateInputTunnel(frame);
Wire.Create(function.BlockDiagram, unwrap.OutputTerminals[0], inputTunnel.InputTerminals[0]);
ConnectOutputToOutputTerminal(inputTunnel.OutputTerminals[0]);
UnwrapOptionTunnel unwrapOptionTunnel = CreateUnwrapOptionTunnel(frame);
ConnectSomeOfIntegerToInputTerminal(unwrapOptionTunnel.InputTerminals[0], 0);
TestExecutionInstance executionInstance = CompileAndExecuteFunction(function);
AssertNoOutput(executionInstance);
}
public void UnwrapOptionTunnelWithSomeInputAndOutputTunnel_Execute_OutputTunnelOutputsSomeValue()
{
DfirRoot function = DfirRoot.Create();
FunctionalNode some = CreateInt32SomeConstructor(function.BlockDiagram, 5);
Frame frame = Frame.Create(function.BlockDiagram);
UnwrapOptionTunnel unwrapOptionTunnel = new UnwrapOptionTunnel(frame);
Wire.Create(function.BlockDiagram, some.OutputTerminals[0], unwrapOptionTunnel.InputTerminals[0]);
Tunnel outputTunnel = CreateOutputTunnel(frame);
Constant intConstant = ConnectConstantToInputTerminal(outputTunnel.InputTerminals[0], NITypes.Int32, 5, false);
FunctionalNode inspect = ConnectInspectToOutputTerminal(outputTunnel.OutputTerminals[0]);
TestExecutionInstance executionInstance = CompileAndExecuteFunction(function);
byte[] finalValue = executionInstance.GetLastValueFromInspectNode(inspect);
AssertByteArrayIsSomeInteger(finalValue, 5);
}
public bool VisitUnwrapOptionTunnel(UnwrapOptionTunnel unwrapOptionTunnel)
{
FrameData frameData = _frameData[(Frame)unwrapOptionTunnel.ParentStructure];
var tunnelInputAllocationSource = (LocalAllocationValueSource)GetTerminalValueSource(unwrapOptionTunnel.InputTerminals[0]);
LLVMValueRef isSomePtr = _builder.CreateStructGEP(tunnelInputAllocationSource.AllocationPointer, 0, "isSomePtr");
LLVMValueRef isSome = _builder.CreateLoad(isSomePtr, "isSome");
LLVMBasicBlockRef someBlock = _topLevelFunction.AppendBasicBlock($"unwrapOption{unwrapOptionTunnel.UniqueId}_some");
_builder.CreateCondBr(isSome, someBlock, frameData.UnwrapFailedBlock);
_builder.PositionBuilderAtEnd(someBlock);
LLVMValueRef valuePtr = _builder.CreateStructGEP(tunnelInputAllocationSource.AllocationPointer, 1, "valuePtr");
LLVMValueRef value = _builder.CreateLoad(valuePtr, "value");
ValueSource tunnelOutputSource = GetTerminalValueSource(unwrapOptionTunnel.OutputTerminals[0]);
tunnelOutputSource.UpdateValue(_builder, value);
return(true);
}
public void OpenFileHandleAndWriteString_Execute_FileCreatedWithCorrectContents()
{
DfirRoot function = DfirRoot.Create();
FunctionalNode openFileHandle = new FunctionalNode(function.BlockDiagram, Signatures.OpenFileHandleType);
string filePath = Path.Combine(TestContext.DeploymentDirectory, Path.GetRandomFileName());
Constant pathConstant = ConnectStringConstantToInputTerminal(openFileHandle.InputTerminals[0], filePath);
Frame frame = Frame.Create(function.BlockDiagram);
UnwrapOptionTunnel unwrapOption = new UnwrapOptionTunnel(frame);
Wire.Create(function.BlockDiagram, openFileHandle.OutputTerminals[1], unwrapOption.InputTerminals[0]);
FunctionalNode writeStringToFileHandle = new FunctionalNode(frame.Diagram, Signatures.WriteStringToFileHandleType);
Wire.Create(frame.Diagram, unwrapOption.OutputTerminals[0], writeStringToFileHandle.InputTerminals[0]);
const string data = "data";
Constant dataConstant = ConnectStringConstantToInputTerminal(writeStringToFileHandle.InputTerminals[1], data);
TestExecutionInstance executionInstance = CompileAndExecuteFunction(function);
AssertFileExistsAndContainsExpectedData(filePath, data);
}
private Tuple <DfirRoot, FunctionalNode> CreateInitializeVectorAndSliceIndexFunction(int elementValue, int index)
{
DfirRoot function = DfirRoot.Create();
FunctionalNode initializeVector = CreateInitializeVectorWithIntegerConstants(function.BlockDiagram, elementValue, 4);
FunctionalNode vectorToSlice = new FunctionalNode(function.BlockDiagram, Signatures.VectorToSliceType);
Wire.Create(function.BlockDiagram, initializeVector.OutputTerminals[0], vectorToSlice.InputTerminals[0]);
FunctionalNode sliceIndex = new FunctionalNode(function.BlockDiagram, Signatures.SliceIndexType);
ConnectConstantToInputTerminal(sliceIndex.InputTerminals[0], NITypes.Int32, index, false);
Wire.Create(function.BlockDiagram, vectorToSlice.OutputTerminals[0], sliceIndex.InputTerminals[1]);
Frame frame = Frame.Create(function.BlockDiagram);
UnwrapOptionTunnel unwrapOption = new UnwrapOptionTunnel(frame);
Wire.Create(function.BlockDiagram, sliceIndex.OutputTerminals[1], unwrapOption.InputTerminals[0]);
FunctionalNode inspect = new FunctionalNode(frame.Diagram, Signatures.InspectType);
Wire.Create(frame.Diagram, unwrapOption.OutputTerminals[0], inspect.InputTerminals[0]);
return(new Tuple <DfirRoot, FunctionalNode>(function, inspect));
}
private static void HandleAddUnwrapOptionTunnel(object parameter, IEnumerable <IViewModel> selection, ICompositionHost host, DocumentEditSite site)
{
var flatSequenceStructureViewModels = selection.OfType <StructureViewModel>().WhereNotNull();
if (flatSequenceStructureViewModels.Any())
{
using (var transaction = flatSequenceStructureViewModels.First().TransactionManager.BeginTransaction("Add Unwrap Option Tunnels", TransactionPurpose.User))
{
foreach (var structureViewModel in flatSequenceStructureViewModels)
{
Structure model = (Structure)structureViewModel.Model;
SMRect leftRect, rightRect;
BorderNodeViewModelHelpers.FindBorderNodePositions(structureViewModel, out leftRect, out rightRect);
UnwrapOptionTunnel unwrapOptionTunnel = model.MakeTunnel <UnwrapOptionTunnel>(model.AncestorDiagram, model.NestedDiagrams.First());
unwrapOptionTunnel.Top = leftRect.Y;
unwrapOptionTunnel.Left = leftRect.X;
}
transaction.Commit();
}
}
}
public void FrameWithUnwrapOptionTunnelAndNoInteriorAwaits_GroupAsyncStates_AllFrameAsyncStateGroupsInSameFunction()
{
DfirRoot function = DfirRoot.Create();
Frame frame = Frame.Create(function.BlockDiagram);
UnwrapOptionTunnel unwrapTunnel = CreateUnwrapOptionTunnel(frame);
FunctionalNode someConstructor = ConnectSomeConstructorToInputTerminal(unwrapTunnel.InputTerminals[0]);
ConnectConstantToInputTerminal(someConstructor.InputTerminals[0], NITypes.Int32, false);
var output = new FunctionalNode(frame.Diagram, Signatures.OutputType);
Wire.Create(frame.Diagram, unwrapTunnel.OutputTerminals[0], output.InputTerminals[0]);
IEnumerable <AsyncStateGroup> asyncStateGroups = GroupAsyncStates(function);
AsyncStateGroup frameInitialGroup = asyncStateGroups.First(g => g.GroupContainsStructureTraversalPoint(frame, frame.Diagram, StructureTraversalPoint.BeforeLeftBorderNodes)),
frameDiagramInitialGroup = asyncStateGroups.First(g => g.GroupContainsNode(output)),
frameTerminalGroup = asyncStateGroups.First(g => g.GroupContainsStructureTraversalPoint(frame, frame.Diagram, StructureTraversalPoint.AfterRightBorderNodes));
Assert.AreEqual(frameInitialGroup.FunctionId, frameDiagramInitialGroup.FunctionId);
Assert.AreEqual(frameInitialGroup.FunctionId, frameTerminalGroup.FunctionId);
}
public void UnwrapOptionTunnelWithNoneInput_Execute_FrameDoesNotExecute()
{
DfirRoot function = DfirRoot.Create();
FunctionalNode none = new FunctionalNode(function.BlockDiagram, Signatures.NoneConstructorType);
Frame frame = Frame.Create(function.BlockDiagram);
UnwrapOptionTunnel unwrapOptionTunnel = new UnwrapOptionTunnel(frame);
Wire.Create(function.BlockDiagram, none.OutputTerminals[0], unwrapOptionTunnel.InputTerminals[0]);
BorrowTunnel borrowTunnel = CreateBorrowTunnel(frame, BorrowMode.Mutable);
ConnectConstantToInputTerminal(borrowTunnel.InputTerminals[0], NITypes.Int32, true);
FunctionalNode assign = new FunctionalNode(frame.Diagram, Signatures.AssignType);
Wire.Create(frame.Diagram, borrowTunnel.OutputTerminals[0], assign.InputTerminals[0]);
Wire.Create(frame.Diagram, unwrapOptionTunnel.OutputTerminals[0], assign.InputTerminals[1]);
FunctionalNode inspect = ConnectInspectToOutputTerminal(borrowTunnel.TerminateLifetimeTunnel.OutputTerminals[0]);
TestExecutionInstance executionInstance = CompileAndExecuteFunction(function);
byte[] finalValue = executionInstance.GetLastValueFromInspectNode(inspect);
AssertByteArrayIsInt32(finalValue, 0);
}
public void UnwrapOptionTunnelWithNoneInputAndOutputTunnel_Execute_OutputTunnelOutputsNoneValue()
{
DfirRoot function = DfirRoot.Create();
var none = new FunctionalNode(function.BlockDiagram, Signatures.NoneConstructorType);
Frame frame = Frame.Create(function.BlockDiagram);
var unwrapOptionTunnel = new UnwrapOptionTunnel(frame);
Wire.Create(function.BlockDiagram, none.OutputTerminals[0], unwrapOptionTunnel.InputTerminals[0]);
var assign = new FunctionalNode(frame.Diagram, Signatures.AssignType);
Wire.Create(frame.Diagram, unwrapOptionTunnel.OutputTerminals[0], assign.InputTerminals[0])
.SetWireBeginsMutableVariable(true);
ConnectConstantToInputTerminal(assign.InputTerminals[1], NITypes.Int32, false);
Tunnel outputTunnel = CreateOutputTunnel(frame);
ConnectConstantToInputTerminal(outputTunnel.InputTerminals[0], NITypes.Int32, false);
FunctionalNode inspect = ConnectInspectToOutputTerminal(outputTunnel.OutputTerminals[0]);
TestExecutionInstance executionInstance = CompileAndExecuteFunction(function);
byte[] finalValue = executionInstance.GetLastValueFromInspectNode(inspect);
AssertByteArrayIsNoneInteger(finalValue);
}
public void CreateNotifierPairDropNotifierWriterAndGetNotifierValue_Execute_ExecutionFinishesAndNoValueOutput()
{
DfirRoot function = DfirRoot.Create();
var createNotifierPair = new FunctionalNode(function.BlockDiagram, Signatures.CreateNotifierPairType);
var getNotifierValue = new FunctionalNode(function.BlockDiagram, Signatures.GetNotifierValueType);
Wire.Create(function.BlockDiagram, createNotifierPair.OutputTerminals[0], getNotifierValue.InputTerminals[0]);
FunctionalNode inspect = ConnectInspectToOutputTerminal(getNotifierValue.OutputTerminals[0]);
// Create a frame that adds to the unwrapped value to coerce it to Int32, even though the value should be None
Frame frame = Frame.Create(function.BlockDiagram);
UnwrapOptionTunnel unwrapOption = new UnwrapOptionTunnel(frame);
Wire.Create(function.BlockDiagram, inspect.OutputTerminals[0], unwrapOption.InputTerminals[0]);
var add = new FunctionalNode(frame.Diagram, Signatures.DefinePureBinaryFunction("Add", NITypes.Int32, NITypes.Int32));
Wire.Create(frame.Diagram, unwrapOption.OutputTerminals[0], add.InputTerminals[0]);
ConnectConstantToInputTerminal(add.InputTerminals[1], NITypes.Int32, 0, false);
TestExecutionInstance executionInstance = CompileAndExecuteFunction(function);
byte[] inspectValue = executionInstance.GetLastValueFromInspectNode(inspect);
AssertByteArrayIsNoneInteger(inspectValue);
}
public void TerminateLifetimeOnLifetimeContainingVariablesConsumedByUnwrapOptionTunnel_SetVariableTypes_TerminateLifetimeHasNoError()
{
DfirRoot function = DfirRoot.Create();
Frame frame = Frame.Create(function.BlockDiagram);
UnwrapOptionTunnel unwrapOptionTunnel = new UnwrapOptionTunnel(frame);
Tunnel outputTunnel = CreateOutputTunnel(frame);
Wire.Create(frame.Diagram, unwrapOptionTunnel.OutputTerminals[0], outputTunnel.InputTerminals[0]);
TerminateLifetimeNode terminateLifetime = new TerminateLifetimeNode(function.BlockDiagram, 1, 1);
Wire.Create(function.BlockDiagram, outputTunnel.OutputTerminals[0], terminateLifetime.InputTerminals[0]);
FunctionalNode someConstructor = new FunctionalNode(function.BlockDiagram, Signatures.SomeConstructorType);
Wire.Create(function.BlockDiagram, someConstructor.OutputTerminals[0], unwrapOptionTunnel.InputTerminals[0]);
ExplicitBorrowNode borrow = ConnectExplicitBorrowToInputTerminals(someConstructor.InputTerminals[0]);
ConnectConstantToInputTerminal(borrow.InputTerminals[0], PFTypes.Int32, false);
RunSemanticAnalysisUpToSetVariableTypes(function);
Assert.AreEqual(TerminateLifetimeErrorState.NoError, terminateLifetime.ErrorState);
Assert.AreEqual(1, terminateLifetime.OutputTerminals.Count);
}
public bool VisitUnwrapOptionTunnel(UnwrapOptionTunnel unwrapOptionTunnel)
{
ValidateRequiredInputTerminal(unwrapOptionTunnel.InputTerminals[0]);
return(true);
}
bool IDfirNodeVisitor <bool> .VisitUnwrapOptionTunnel(UnwrapOptionTunnel unwrapOptionTunnel)
{
unwrapOptionTunnel.UnifyNodeInputTerminalTypes(_typeUnificationResults);
return(true);
}
bool IDfirNodeVisitor <bool> .VisitUnwrapOptionTunnel(UnwrapOptionTunnel unwrapOptionTunnel)
{
MarkTrueVariableOfTerminalConsumed(unwrapOptionTunnel.InputTerminals[0]);
MarkFacadeVariableOfTerminalLive(unwrapOptionTunnel.OutputTerminals[0]);
return(true);
}
bool IDfirNodeVisitor <bool> .VisitUnwrapOptionTunnel(UnwrapOptionTunnel unwrapOptionTunnel)
{
UnifyNodeInputTerminalTypes(unwrapOptionTunnel);
return(true);
}
