public void BranchedStringSliceWire_Execute_BothSinksHaveCorrectValues()
{
DfirRoot function = DfirRoot.Create();
Constant stringSliceConstant = Constant.Create(function.BlockDiagram, "test", DataTypes.StringSliceType.CreateImmutableReference());
var inspect1Node = new FunctionalNode(function.BlockDiagram, Signatures.InspectType);
ExplicitBorrowNode borrow1 = ConnectExplicitBorrowToInputTerminals(inspect1Node.InputTerminals[0]);
var inspect2Node = new FunctionalNode(function.BlockDiagram, Signatures.InspectType);
ExplicitBorrowNode borrow2 = ConnectExplicitBorrowToInputTerminals(inspect2Node.InputTerminals[0]);
Wire.Create(function.BlockDiagram, stringSliceConstant.OutputTerminal, borrow1.InputTerminals[0], borrow2.InputTerminals[0]);
TestExecutionInstance executionInstance = CompileAndExecuteFunction(function);
#if LLVM_TEST
const int stringSliceReferenceSize = 16;
#else
const int stringSliceReferenceSize = 8;
#endif
byte[] inspect1Value = executionInstance.GetLastValueFromInspectNode(inspect1Node);
Assert.AreEqual(stringSliceReferenceSize, inspect1Value.Length);
byte[] inspect2Value = executionInstance.GetLastValueFromInspectNode(inspect2Node);
Assert.AreEqual(stringSliceReferenceSize, inspect2Value.Length);
Assert.IsTrue(inspect1Value.Zip(inspect2Value, (a, b) => a == b).All(b => b));
}
public void VisitImmutableBorrowNode(ImmutableBorrowNode immutableBorrowNode)
{
var explicitBorrowDfir = new ExplicitBorrowNode(_currentDiagram, BorrowMode.Immutable, 1, true, true);
_map.AddMapping(immutableBorrowNode, explicitBorrowDfir);
MapTerminalsInOrder(immutableBorrowNode, explicitBorrowDfir);
}
bool IDfirNodeVisitor <bool> .VisitExplicitBorrowNode(ExplicitBorrowNode explicitBorrowNode)
{
if (explicitBorrowNode.AlwaysCreateReference && explicitBorrowNode.AlwaysBeginLifetime)
{
bool mutable = explicitBorrowNode.BorrowMode == BorrowMode.Mutable;
Lifetime borrowLifetime = explicitBorrowNode.OutputTerminals.First().DefineLifetimeThatIsBoundedByDiagram();
TypeVariableReference borrowLifetimeType = _typeVariableSet.CreateReferenceToLifetimeType(borrowLifetime);
foreach (var terminalPair in explicitBorrowNode.InputTerminals.Zip(explicitBorrowNode.OutputTerminals))
{
Terminal inputTerminal = terminalPair.Key, outputTerminal = terminalPair.Value;
TypeVariableReference inputTypeVariable = _typeVariableSet.CreateReferenceToNewTypeVariable();
_nodeFacade[inputTerminal] = new SimpleTerminalFacade(inputTerminal, inputTypeVariable);
TypeVariableReference outputReferenceType = _typeVariableSet.CreateReferenceToReferenceType(mutable, inputTypeVariable, borrowLifetimeType);
_nodeFacade[outputTerminal] = new SimpleTerminalFacade(outputTerminal, outputReferenceType);
}
}
else
{
// TODO
throw new NotImplementedException();
}
return(true);
}
public void LifetimeWithLiveVariablesOnMainAndNestedDiagrams_ValidateVariableUsages_TerminateLifetimeNodeHasCorrectInputTerminalCount()
{
var signatureBuilder = NITypes.Factory.DefineFunction("outputString");
NIType outputOwnerStringSignature = signatureBuilder.AddOutput(NITypes.String, "owner").CreateType();
DfirRoot function = DfirRoot.Create();
var outputString = new FunctionalNode(function.BlockDiagram, outputOwnerStringSignature);
ExplicitBorrowNode borrow = new ExplicitBorrowNode(function.BlockDiagram, BorrowMode.Immutable, 1, true, true);
Wire.Create(function.BlockDiagram, outputString.OutputTerminals[0], borrow.InputTerminals[0]);
Frame outerFrame = Frame.Create(function.BlockDiagram);
Tunnel outerFrameInputTunnel = CreateInputTunnel(outerFrame);
Wire.Create(function.BlockDiagram, borrow.OutputTerminals[0], outerFrameInputTunnel.InputTerminals[0]);
Frame innerFrame = Frame.Create(outerFrame.Diagram);
Tunnel innerFrameInputTunnel = CreateInputTunnel(innerFrame), innerFrameOutputTunnel = CreateOutputTunnel(innerFrame);
FunctionalNode outerStringToSlice = new FunctionalNode(outerFrame.Diagram, Signatures.StringToSliceType);
Wire.Create(outerFrame.Diagram, outerFrameInputTunnel.OutputTerminals[0], innerFrameInputTunnel.InputTerminals[0], outerStringToSlice.InputTerminals[0]);
FunctionalNode innerStringToSlice = new FunctionalNode(innerFrame.Diagram, Signatures.StringToSliceType);
Wire.Create(innerFrame.Diagram, innerFrameInputTunnel.OutputTerminals[0], innerStringToSlice.InputTerminals[0]);
Wire.Create(innerFrame.Diagram, innerStringToSlice.OutputTerminals[0], innerFrameOutputTunnel.InputTerminals[0]);
Tunnel outerFrameOutputTunnel = CreateOutputTunnel(outerFrame);
Wire.Create(outerFrame.Diagram, outerStringToSlice.OutputTerminals[0], outerFrameOutputTunnel.InputTerminals[0]);
TerminateLifetimeNode terminateLifetime = new TerminateLifetimeNode(function.BlockDiagram, 1, 1);
Wire.Create(function.BlockDiagram, outerFrameOutputTunnel.OutputTerminals[0], terminateLifetime.InputTerminals[0]);
RunSemanticAnalysisUpToValidation(function);
Assert.AreEqual(2, terminateLifetime.InputTerminals.Count);
}
public bool VisitExplicitBorrowNode(ExplicitBorrowNode explicitBorrowNode)
{
VariableReference input = explicitBorrowNode.InputTerminals.ElementAt(0).GetTrueVariable(),
output = explicitBorrowNode.OutputTerminals.ElementAt(0).GetTrueVariable();
BorrowFromVariableIntoVariable(input, output);
return(true);
}
bool IDfirNodeVisitor <bool> .VisitExplicitBorrowNode(ExplicitBorrowNode explicitBorrowNode)
{
Lifetime outputLifetime = explicitBorrowNode.OutputTerminals[0].GetTrueVariable().Lifetime;
IEnumerable <VariableReference> inputVariables = explicitBorrowNode.InputTerminals.Select(VariableExtensions.GetTrueVariable);
inputVariables.ForEach(v => _lifetimeVariableAssociation.AddVariableInterruptedByLifetime(v, outputLifetime));
return(true);
}
public bool VisitExplicitBorrowNode(ExplicitBorrowNode explicitBorrowNode)
{
foreach (var inputTerminal in explicitBorrowNode.InputTerminals)
{
VariableUsageValidator validator = inputTerminal.GetValidator();
}
return(true);
}
internal static ExplicitBorrowNode ConnectExplicitBorrowToInputTerminals(BorrowMode borrowMode, params Terminal[] inputTerminals)
{
Diagram parentDiagram = inputTerminals[0].ParentDiagram;
ExplicitBorrowNode borrow = new ExplicitBorrowNode(parentDiagram, borrowMode, inputTerminals.Length, true, true);
for (int i = 0; i < inputTerminals.Length; ++i)
{
Wire.Create(parentDiagram, borrow.OutputTerminals[i], inputTerminals[i]);
}
return(borrow);
}
public void CreateBorrowAndTerminateLifetimeNodes(LifetimeVariableAssociation lifetimeVariableAssociation)
{
if (_borrowRequired)
{
Node parentNode = _facades.First().Terminal.ParentNode;
BorrowMode borrowMode = _mutableBorrow ? BorrowMode.Mutable : BorrowMode.Immutable;
int borrowInputCount = _facades.Count;
Diagram inputParentDiagram = _facades.First().Terminal.ParentDiagram;
var explicitBorrow = new ExplicitBorrowNode(inputParentDiagram, borrowMode, borrowInputCount, true, false);
AutoBorrowNodeFacade borrowNodeFacade = AutoBorrowNodeFacade.GetNodeFacade(explicitBorrow);
foreach (var terminal in explicitBorrow.Terminals)
{
borrowNodeFacade[terminal] = new SimpleTerminalFacade(terminal, default(TypeVariableReference));
}
int index = 0;
foreach (var facade in _facades)
{
Terminal input = facade.Terminal;
VariableReference ownerVariable = input.GetFacadeVariable(), borrowVariable;
((AutoborrowingInputTerminalFacade)facade).AddPostBorrowCoercion(ref input, out borrowVariable);
InsertBorrowAheadOfTerminal(input, explicitBorrow, index, ownerVariable, borrowVariable);
++index;
}
List <TerminateLifetimeOutputTerminalFacade> terminates = new List <TerminateLifetimeOutputTerminalFacade>();
foreach (var terminal in parentNode.OutputTerminals)
{
var terminateFacade = _nodeFacade[terminal] as TerminateLifetimeOutputTerminalFacade;
if (terminateFacade != null && _facades.Contains(terminateFacade.InputFacade))
{
terminates.Add(terminateFacade);
}
}
if (terminates.Count == borrowInputCount)
{
Diagram outputParentDiagram = terminates.First().Terminal.ParentDiagram;
var terminateLifetime = TerminateLifetimeNodeHelpers.CreateTerminateLifetimeWithFacades(outputParentDiagram, borrowInputCount, borrowInputCount);
index = 0;
foreach (var terminate in terminates)
{
InsertTerminateLifetimeBehindTerminal(terminate.Terminal, terminateLifetime, index, lifetimeVariableAssociation);
++index;
}
}
else if (terminates.Count > 0)
{
throw new InvalidOperationException("Mismatched terminates and borrows; not sure what to do");
}
}
}
bool IDfirNodeVisitor <bool> .VisitExplicitBorrowNode(ExplicitBorrowNode explicitBorrowNode)
{
foreach (Terminal inputTerminal in explicitBorrowNode.InputTerminals)
{
MarkFacadeVariableOfTerminalInterrupted(inputTerminal);
}
foreach (Terminal outputTerminal in explicitBorrowNode.OutputTerminals)
{
MarkFacadeVariableOfTerminalLive(outputTerminal);
}
return(true);
}
public void BorrowNodeWithUnwiredOutput_AutomaticNodeInsertion_TerminateLifetimeNodeInserted()
{
DfirRoot function = DfirRoot.Create();
FunctionalNode outputOwner = new FunctionalNode(function.BlockDiagram, _outputOwnerSignature);
ExplicitBorrowNode borrow = new ExplicitBorrowNode(function.BlockDiagram, BorrowMode.Immutable, 1, true, true);
Wire.Create(function.BlockDiagram, outputOwner.OutputTerminals[0], borrow.InputTerminals[0]);
RunCompilationUpToAutomaticNodeInsertion(function);
AssertDiagramContainsNodeWithSources <TerminateLifetimeNode>(function.BlockDiagram, borrow.OutputTerminals[0]);
}
public void FrameOutputTunnelWithInnerDiagramReferenceTypeWiredIn_ValidateVariableUsages_ErrorReported()
{
DfirRoot dfirRoot = DfirRoot.Create();
Frame frame = Frame.Create(dfirRoot.BlockDiagram);
Tunnel tunnel = CreateOutputTunnel(frame);
ExplicitBorrowNode borrow = ConnectExplicitBorrowToInputTerminals(tunnel.InputTerminals[0]);
ConnectConstantToInputTerminal(borrow.InputTerminals[0], PFTypes.Int32, false);
RunSemanticAnalysisUpToValidation(dfirRoot);
Assert.IsTrue(tunnel.InputTerminals[0].GetDfirMessages().Any(message => message.Descriptor == Messages.WiredReferenceDoesNotLiveLongEnough.Descriptor));
}
public void LoopConditionTunnelWithBooleanReferenceInput_ValidateVariableUsage_TypeConflictErrorReported()
{
DfirRoot function = DfirRoot.Create();
Loop loop = new Loop(function.BlockDiagram);
LoopConditionTunnel loopConditionTunnel = CreateLoopConditionTunnel(loop);
ExplicitBorrowNode borrow = ConnectExplicitBorrowToInputTerminals(loopConditionTunnel.InputTerminals[0]);
ConnectConstantToInputTerminal(borrow.InputTerminals[0], PFTypes.Boolean, false);
RunSemanticAnalysisUpToValidation(function);
AssertTerminalHasTypeConflictMessage(loopConditionTunnel.InputTerminals[0]);
}
public void FunctionNodeWithReferenceWiredToInReferenceParameter_SetVariableTypes_InputTerminalTrueAndFacadeVariablesMerged()
{
NIType signatureType = Signatures.ImmutablePassthroughType;
DfirRoot dfirRoot = DfirRoot.Create();
FunctionalNode functionalNode = new FunctionalNode(dfirRoot.BlockDiagram, signatureType);
ExplicitBorrowNode borrow = ConnectExplicitBorrowToInputTerminals(functionalNode.InputTerminals[0]);
ConnectConstantToInputTerminal(borrow.InputTerminals[0], NITypes.Int32, false);
RunSemanticAnalysisUpToSetVariableTypes(dfirRoot);
AssertTerminalTrueAndFacadeVariablesReferenceSame(functionalNode.InputTerminals[0]);
}
public void FunctionNodeWithMutableInOutSignatureParameterAndImmutableReferenceWired_ValidateVariableUsages_ErrorCreated()
{
NIType signatureType = Signatures.MutablePassthroughType;
DfirRoot dfirRoot = DfirRoot.Create();
FunctionalNode functionalNode = new FunctionalNode(dfirRoot.BlockDiagram, signatureType);
ExplicitBorrowNode borrow = ConnectExplicitBorrowToInputTerminals(functionalNode.InputTerminals[0]);
ConnectConstantToInputTerminal(borrow.InputTerminals[0], PFTypes.Int32, false);
RunSemanticAnalysisUpToValidation(dfirRoot);
Assert.IsTrue(functionalNode.InputTerminals[0].GetDfirMessages().Any(message => message.Descriptor == Messages.TerminalDoesNotAcceptImmutableType.Descriptor));
}
public void FunctionNodeWithNonReferenceInSignatureParameterAndReferenceVariableWired_ValidateVariableUsages_ErrorCreated()
{
NIType signatureType = Signatures.RangeType;
DfirRoot dfirRoot = DfirRoot.Create();
FunctionalNode functionalNode = new FunctionalNode(dfirRoot.BlockDiagram, signatureType);
ExplicitBorrowNode borrow = ConnectExplicitBorrowToInputTerminals(functionalNode.InputTerminals[0]);
ConnectConstantToInputTerminal(borrow.InputTerminals[0], NITypes.Int32, false);
RunSemanticAnalysisUpToValidation(dfirRoot);
AssertTerminalHasTypeConflictMessage(functionalNode.InputTerminals[0]);
}
public void FunctionNodeWithGenericImmutableInOutSignatureParameterAndImmutableReferenceVariableWired_ValidateVariableUsages_NoErrorCreated()
{
NIType signatureType = Signatures.ImmutablePassthroughType;
DfirRoot dfirRoot = DfirRoot.Create();
FunctionalNode functionalNode = new FunctionalNode(dfirRoot.BlockDiagram, signatureType);
ExplicitBorrowNode borrow = ConnectExplicitBorrowToInputTerminals(functionalNode.InputTerminals[0]);
ConnectConstantToInputTerminal(borrow.InputTerminals[0], NITypes.Int32, false);
RunSemanticAnalysisUpToValidation(dfirRoot);
Assert.IsFalse(functionalNode.InputTerminals[0].GetDfirMessages().Any());
}
public void TerminateLifetimeWithAllVariablesInLifetimeWired_ValidateVariableUsages_NoError()
{
DfirRoot function = DfirRoot.Create();
TerminateLifetimeNode terminateLifetime = new TerminateLifetimeNode(function.BlockDiagram, 2, 1);
ExplicitBorrowNode borrow = ConnectExplicitBorrowToInputTerminals(terminateLifetime.InputTerminals[0], terminateLifetime.InputTerminals[1]);
ConnectConstantToInputTerminal(borrow.InputTerminals[0], PFTypes.Int32, false);
ConnectConstantToInputTerminal(borrow.InputTerminals[1], PFTypes.Int32, false);
RunSemanticAnalysisUpToValidation(function);
Assert.AreEqual(TerminateLifetimeErrorState.NoError, terminateLifetime.ErrorState);
Assert.IsFalse(terminateLifetime.GetDfirMessages().Any());
}
public void TerminateLifetimeWithMultipleInputLifetimesWired_ValidateVariableUsages_NonUniqueLifetimeErrorMessageReported()
{
DfirRoot function = DfirRoot.Create();
TerminateLifetimeNode terminateLifetime = new TerminateLifetimeNode(function.BlockDiagram, 2, 1);
ExplicitBorrowNode borrow1 = ConnectExplicitBorrowToInputTerminals(terminateLifetime.InputTerminals[0]);
ConnectConstantToInputTerminal(borrow1.InputTerminals[0], PFTypes.Int32, false);
ExplicitBorrowNode borrow2 = ConnectExplicitBorrowToInputTerminals(terminateLifetime.InputTerminals[1]);
ConnectConstantToInputTerminal(borrow2.InputTerminals[0], PFTypes.Int32, false);
RunSemanticAnalysisUpToValidation(function);
Assert.IsTrue(terminateLifetime.GetDfirMessages().Any(message => message.Descriptor == Messages.TerminateLifetimeInputLifetimesNotUnique.Descriptor));
}
public void TerminateLifetimeWithInputLifetimeThatOutlastsDiagramWired_ValidateVariableUsages_LifetimeCannotBeTerminatedErrorMessageReported()
{
DfirRoot function = DfirRoot.Create();
Frame frame = Frame.Create(function.BlockDiagram);
Tunnel tunnel = CreateInputTunnel(frame);
ExplicitBorrowNode borrow = ConnectExplicitBorrowToInputTerminals(tunnel.InputTerminals[0]);
ConnectConstantToInputTerminal(borrow.InputTerminals[0], PFTypes.Int32, false);
TerminateLifetimeNode terminateLifetime = new TerminateLifetimeNode(frame.Diagram, 1, 1);
Wire wire = Wire.Create(frame.Diagram, tunnel.OutputTerminals[0], terminateLifetime.InputTerminals[0]);
RunSemanticAnalysisUpToValidation(function);
Assert.IsTrue(terminateLifetime.GetDfirMessages().Any(message => message.Descriptor == Messages.TerminateLifetimeInputLifetimeCannotBeTerminated.Descriptor));
}
public void FunctionNodeWithSelectReferenceSignatureAndSameLifetimeMutableReferencesWired_SetVariableTypes_InputTerminalsTrueAndFacadeVariablesMerged()
{
NIType signatureType = Signatures.SelectReferenceType;
DfirRoot dfirRoot = DfirRoot.Create();
FunctionalNode functionalNode = new FunctionalNode(dfirRoot.BlockDiagram, signatureType);
ExplicitBorrowNode borrow = ConnectExplicitBorrowToInputTerminals(BorrowMode.Mutable, functionalNode.InputTerminals[1], functionalNode.InputTerminals[2]);
ConnectConstantToInputTerminal(borrow.InputTerminals[0], NITypes.Int32, true);
ConnectConstantToInputTerminal(borrow.InputTerminals[1], NITypes.Int32, true);
RunSemanticAnalysisUpToSetVariableTypes(dfirRoot);
AssertTerminalTrueAndFacadeVariablesReferenceSame(functionalNode.InputTerminals[1]);
AssertTerminalTrueAndFacadeVariablesReferenceSame(functionalNode.InputTerminals[2]);
}
public void TerminateLifetimeWithAllVariablesInLifetimeWired_SetVariableTypes_LifetimeDecomposedVariablesSetOnOutputs()
{
DfirRoot function = DfirRoot.Create();
TerminateLifetimeNode terminateLifetime = new TerminateLifetimeNode(function.BlockDiagram, 2, 1);
ExplicitBorrowNode borrow = ConnectExplicitBorrowToInputTerminals(terminateLifetime.InputTerminals[0], terminateLifetime.InputTerminals[1]);
ConnectConstantToInputTerminal(borrow.InputTerminals[0], PFTypes.Int32, false);
ConnectConstantToInputTerminal(borrow.InputTerminals[1], PFTypes.Int32, false);
RunSemanticAnalysisUpToSetVariableTypes(function);
Assert.AreEqual(2, terminateLifetime.OutputTerminals.Count);
Assert.IsTrue(borrow.InputTerminals[0].GetTrueVariable().ReferencesSame(terminateLifetime.OutputTerminals[0].GetTrueVariable()));
Assert.IsTrue(borrow.InputTerminals[1].GetTrueVariable().ReferencesSame(terminateLifetime.OutputTerminals[1].GetTrueVariable()));
}
public void BranchedMutableWireWithNonCopyableType_ValidateVariableUsages_WireCannotForkErrorReported()
{
NIType signatureType = Signatures.MutablePassthroughType;
DfirRoot dfirRoot = DfirRoot.Create();
FunctionalNode firstSink = new FunctionalNode(dfirRoot.BlockDiagram, signatureType),
secondSink = new FunctionalNode(dfirRoot.BlockDiagram, signatureType);
ExplicitBorrowNode mutableBorrow = new ExplicitBorrowNode(dfirRoot.BlockDiagram, BorrowMode.Mutable, 1, true, true);
ConnectConstantToInputTerminal(mutableBorrow.InputTerminals[0], NITypes.Int32, true);
Wire branchedWire = Wire.Create(dfirRoot.BlockDiagram, mutableBorrow.OutputTerminals[0], firstSink.InputTerminals[0], secondSink.InputTerminals[0]);
RunSemanticAnalysisUpToValidation(dfirRoot);
Assert.IsTrue(branchedWire.GetDfirMessages().Any(message => message.Descriptor == Messages.WireCannotFork.Descriptor));
}
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 TerminateLifetimeWithNotAllVariablesInLifetimeWired_ValidateVariableUsages_NotAllVariablesInLifetimeConnectedErrorMessageReported()
{
DfirRoot function = DfirRoot.Create();
TerminateLifetimeNode terminateLifetime = new TerminateLifetimeNode(function.BlockDiagram, 1, 1);
ExplicitBorrowNode borrow = ConnectExplicitBorrowToInputTerminals(terminateLifetime.InputTerminals[0]);
ConnectConstantToInputTerminal(borrow.InputTerminals[0], PFTypes.Int32, false);
FunctionalNode passthrough = new FunctionalNode(function.BlockDiagram, Signatures.ImmutablePassthroughType);
borrow.OutputTerminals[0].WireTogether(passthrough.InputTerminals[0], SourceModelIdSource.NoSourceModelId);
RunSemanticAnalysisUpToValidation(function);
Assert.IsTrue(terminateLifetime.GetDfirMessages().Any(message => message.Descriptor == Messages.TerminateLifetimeNotAllVariablesInLifetimeConnected.Descriptor));
}
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 FrameOutputTunnelWithReferenceTypeWiredIn_SetVariableTypes_TypeAndLifetimeSetOnOutputVariable()
{
DfirRoot dfirRoot = DfirRoot.Create();
Frame frame = Frame.Create(dfirRoot.BlockDiagram);
Tunnel tunnel = CreateOutputTunnel(frame);
ExplicitBorrowNode borrow = ConnectExplicitBorrowToInputTerminals(tunnel.InputTerminals[0]);
ConnectConstantToInputTerminal(borrow.InputTerminals[0], PFTypes.Int32, false);
RunSemanticAnalysisUpToSetVariableTypes(dfirRoot);
VariableReference outputVariable = tunnel.OutputTerminals[0].GetTrueVariable();
Assert.IsTrue(outputVariable.Type.IsImmutableReferenceType());
Assert.IsFalse(outputVariable.Lifetime.DoesOutlastDiagram(frame.Diagram));
}
public void ReborrowMutableReferenceAsImmutableAndOutput_Execute_CorrectValue()
{
DfirRoot function = DfirRoot.Create();
var mutableBorrow = new ExplicitBorrowNode(function.BlockDiagram, BorrowMode.Mutable, 1, true, true);
ConnectConstantToInputTerminal(mutableBorrow.InputTerminals[0], NITypes.Int32, 5, true);
FunctionalNode inspect = ConnectInspectToOutputTerminal(mutableBorrow.OutputTerminals[0]);
// set mutable reference wire to mutable so that it gets a local allocation
mutableBorrow.OutputTerminals[0].GetWireIfConnected().SetWireBeginsMutableVariable(true);
TestExecutionInstance executionInstance = CompileAndExecuteFunction(function);
byte[] inspectValue = executionInstance.GetLastValueFromInspectNode(inspect);
AssertByteArrayIsInt32(inspectValue, 5);
}
public void OwnerWireConnectedToReferenceInputTerminal_AutomaticNodeInsertion_BorrowNodeAndTerminateLifetimeNodeInserted()
{
DfirRoot function = DfirRoot.Create();
FunctionalNode outputOwner = new FunctionalNode(function.BlockDiagram, _outputOwnerSignature);
FunctionalNode immutablePassthrough = new FunctionalNode(function.BlockDiagram, Signatures.ImmutablePassthroughType);
Wire.Create(function.BlockDiagram, outputOwner.OutputTerminals[0], immutablePassthrough.InputTerminals[0]);
RunCompilationUpToAutomaticNodeInsertion(function);
ExplicitBorrowNode borrowNode = AssertDiagramContainsNodeWithSources <ExplicitBorrowNode>(function.BlockDiagram, outputOwner.OutputTerminals[0]);
Assert.AreEqual(borrowNode.OutputTerminals[0], immutablePassthrough.InputTerminals[0].GetImmediateSourceTerminal());
TerminateLifetimeNode terminateLifetime = AssertDiagramContainsNodeWithSources <TerminateLifetimeNode>(function.BlockDiagram, immutablePassthrough.OutputTerminals[0]);
AssertDiagramContainsNodeWithSources <DropNode>(function.BlockDiagram, terminateLifetime.OutputTerminals[0]);
}
public void Yield_AutomaticNodeInsertion_YieldReplacedWithCreateYieldPromiseAndAwaitNode()
{
DfirRoot function = DfirRoot.Create();
var yieldNode = new FunctionalNode(function.BlockDiagram, Signatures.YieldType);
Constant constant = ConnectConstantToInputTerminal(yieldNode.InputTerminals[0], NITypes.Int32, false);
RunCompilationUpToAsyncNodeDecomposition(function);
ExplicitBorrowNode borrowNode = AssertDiagramContainsNodeWithSources <ExplicitBorrowNode>(function.BlockDiagram, constant.OutputTerminal);
FunctionalNode createYieldPromise = AssertDiagramContainsNodeWithSources <FunctionalNode>(
function.BlockDiagram,
f => f.Signature == Signatures.CreateYieldPromiseType,
borrowNode.OutputTerminals[0]);
var awaitNode = AssertDiagramContainsNodeWithSources <AwaitNode>(function.BlockDiagram, createYieldPromise.OutputTerminals[0]);
Assert.IsNull(yieldNode.ParentDiagram);
}
