private static void InsertTerminateLifetimeBehindTerminal(
Terminal lifetimeSource,
TerminateLifetimeNode terminateLifetime,
int index,
LifetimeVariableAssociation lifetimeVariableAssociation)
{
Terminal terminateLifetimeInput = terminateLifetime.InputTerminals.ElementAt(index),
terminateLifetimeOutput = terminateLifetime.OutputTerminals.ElementAt(index);
// wiring: output
if (lifetimeSource.IsConnected)
{
lifetimeSource.ConnectedTerminal.ConnectTo(terminateLifetimeOutput);
}
lifetimeSource.WireTogether(terminateLifetimeInput, SourceModelIdSource.NoSourceModelId);
// variables: output
terminateLifetimeInput.GetFacadeVariable().MergeInto(lifetimeSource.GetTrueVariable());
VariableReference facadeVariable = lifetimeSource.GetFacadeVariable();
terminateLifetimeOutput.GetFacadeVariable().MergeInto(facadeVariable);
if (lifetimeVariableAssociation.IsLive(facadeVariable))
{
lifetimeVariableAssociation.MarkVariableLive(facadeVariable, terminateLifetimeOutput);
}
}
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 void VisitTerminateLifetimeNode(TerminateLifetime node)
{
var terminateLifetimeDfir = new TerminateLifetimeNode(_currentDiagram, node.InputTerminals.Count(), node.OutputTerminals.Count());
_map.AddMapping(node, terminateLifetimeDfir);
MapTerminalsInOrder(node, terminateLifetimeDfir);
}
public void FinalizeTerminateLifetimeInputs(TerminateLifetimeNode terminateLifetimeNode, LifetimeVariableAssociation lifetimeVariableAssociation)
{
if (CommonLifetime != null && _state == State.VariablesInLifetimeRemaining)
{
// assume that none of the lifetimes of our inputs are going to change after this point
foreach (var inputVariable in _inputVariables)
{
lifetimeVariableAssociation.MarkVariableConsumed(inputVariable);
}
List <VariableReference> unconsumedVariables = _parentDiagram
.GetVariableSet()
.GetUniqueVariableReferences()
.Where(variable => variable.Lifetime == CommonLifetime && !lifetimeVariableAssociation.IsVariableConsumed(variable))
.ToList();
if (unconsumedVariables.Count == 0)
{
_state = State.AllVariablesInLifetimeTerminated;
}
int requiredInputCount = _inputVariables.Count + unconsumedVariables.Count;
terminateLifetimeNode.RequiredInputCount = requiredInputCount;
terminateLifetimeNode.UpdateInputTerminals(requiredInputCount);
}
UpdateTerminateLifetimeErrorState(terminateLifetimeNode);
}
public void UpdateTerminateLifetimeOutputs(TerminateLifetimeNode terminateLifetimeNode, LifetimeVariableAssociation lifetimeVariableAssociation)
{
if (CommonLifetime != null)
{
IEnumerable <VariableReference> interruptedVariables = lifetimeVariableAssociation.GetVariablesInterruptedByLifetime(CommonLifetime);
int outputCount = interruptedVariables.Count();
terminateLifetimeNode.RequiredOutputCount = outputCount;
terminateLifetimeNode.UpdateOutputTerminals(outputCount);
foreach (var outputTerminalPair in terminateLifetimeNode.OutputTerminals.Zip(interruptedVariables))
{
Terminal outputTerminal = outputTerminalPair.Key;
VariableReference decomposedVariable = outputTerminalPair.Value;
if (decomposedVariable.IsValid)
{
outputTerminal.GetFacadeVariable().MergeInto(decomposedVariable);
}
}
}
else
{
foreach (Terminal outputTerminal in terminateLifetimeNode.OutputTerminals)
{
outputTerminal.GetFacadeVariable().MergeInto(outputTerminal.CreateNewVariableForUnwiredTerminal());
}
}
}
bool IDfirNodeVisitor <bool> .VisitTerminateLifetimeNode(TerminateLifetimeNode terminateLifetimeNode)
{
foreach (var terminal in terminateLifetimeNode.Terminals)
{
// TODO: when updating terminals during SA, also update the TerminalFacades
_nodeFacade[terminal] = new TerminateLifetimeInputTerminalFacade(terminal, terminateLifetimeNode.UnificationState);
}
return(true);
}
public void Execute(DfirRoot dfirRoot, CompileCancellationToken cancellationToken)
{
var lifetimeGraphTree = dfirRoot.GetLifetimeGraphTree();
BoundedLifetimeLiveVariableSet boundedLifetimeLiveVariableSet;
while (_lifetimeVariableAssociation.TryGetBoundedLifetimeWithLiveVariables(out boundedLifetimeLiveVariableSet))
{
if (lifetimeGraphTree.IsDiagramLifetimeOfAnyLifetimeGraph(boundedLifetimeLiveVariableSet.Lifetime))
{
// Since we assume there are no semantic errors at this point, just mark any remaining live variables
// in a diagram lifetime as consumed.
boundedLifetimeLiveVariableSet.LiveVariables.Select(l => l.Variable).ForEach(_lifetimeVariableAssociation.MarkVariableConsumed);
continue;
}
int inputVariableCount = boundedLifetimeLiveVariableSet.LiveVariables.Count();
IEnumerable <VariableReference> interruptedVariables = _lifetimeVariableAssociation.GetVariablesInterruptedByLifetime(boundedLifetimeLiveVariableSet.Lifetime);
int outputVariableCount = interruptedVariables.Count();
Diagram startSearch = boundedLifetimeLiveVariableSet.LiveVariables.First().Terminal.ParentDiagram;
LifetimeGraphIdentifier originGraphIdentifier = lifetimeGraphTree.GetBoundedLifetimeGraphIdentifier(boundedLifetimeLiveVariableSet.Lifetime);
Diagram originDiagram = originGraphIdentifier.FindDiagramForGraphIdentifier(startSearch);
LiveVariable[] liveVariables = boundedLifetimeLiveVariableSet.LiveVariables.ToArray();
for (int i = 0; i < liveVariables.Length; ++i)
{
LiveVariable liveVariable = liveVariables[i];
while (liveVariable.Terminal.ParentDiagram != originDiagram)
{
liveVariable = PullLiveVariableUpToNextHigherDiagram(liveVariable);
}
liveVariables[i] = liveVariable;
}
TerminateLifetimeNode terminateLifetime = TerminateLifetimeNodeHelpers.CreateTerminateLifetimeWithFacades(originDiagram, inputVariableCount, outputVariableCount);
int inputIndex = 0;
foreach (LiveVariable liveVariable in liveVariables)
{
// TODO: maybe assert that liveVariable.Terminal is unwired here?
Terminal terminateLifetimeInputTerminal = terminateLifetime.InputTerminals[inputIndex];
Wire.Create(originDiagram, liveVariable.Terminal, terminateLifetimeInputTerminal);
terminateLifetimeInputTerminal.GetFacadeVariable().MergeInto(liveVariable.Variable);
_lifetimeVariableAssociation.MarkVariableConsumed(liveVariable.Variable);
++inputIndex;
}
int outputIndex = 0;
foreach (VariableReference interruptedVariable in interruptedVariables)
{
Terminal terminateLifetimeOutputTerminal = terminateLifetime.OutputTerminals[outputIndex];
terminateLifetimeOutputTerminal.GetFacadeVariable().MergeInto(interruptedVariable);
_lifetimeVariableAssociation.MarkVariableLive(interruptedVariable, terminateLifetimeOutputTerminal);
++outputIndex;
}
}
}
bool IDfirNodeVisitor <bool> .VisitTerminateLifetimeNode(TerminateLifetimeNode terminateLifetimeNode)
{
terminateLifetimeNode.UnificationState.FinalizeTerminateLifetimeInputs(terminateLifetimeNode, _lifetimeVariableAssociation);
foreach (Terminal outputTerminal in terminateLifetimeNode.OutputTerminals)
{
MarkFacadeVariableOfTerminalLive(outputTerminal);
}
return(true);
}
public void TerminateLifetimeWithNoInputLifetimesWired_ValidateVariableUsages_NonUniqueLifetimeErrorMessageReported()
{
DfirRoot function = DfirRoot.Create();
TerminateLifetimeNode terminateLifetime = new TerminateLifetimeNode(function.BlockDiagram, 2, 1);
RunSemanticAnalysisUpToValidation(function);
AssertTerminalHasRequiredTerminalUnconnectedMessage(terminateLifetime.InputTerminals[0]);
AssertTerminalHasRequiredTerminalUnconnectedMessage(terminateLifetime.InputTerminals[1]);
}
public void TerminateLifetimeWithNoInputLifetimesWired_ValidateVariableUsages_NonUniqueLifetimeErrorMessageReported()
{
DfirRoot function = DfirRoot.Create();
TerminateLifetimeNode terminateLifetime = new TerminateLifetimeNode(function.BlockDiagram, 2, 1);
RunSemanticAnalysisUpToValidation(function);
Assert.IsTrue(terminateLifetime.InputTerminals[0].GetDfirMessages().Any(message => message.Descriptor == AllModelsOfComputationErrorMessages.RequiredTerminalUnconnected));
Assert.IsTrue(terminateLifetime.InputTerminals[1].GetDfirMessages().Any(message => message.Descriptor == AllModelsOfComputationErrorMessages.RequiredTerminalUnconnected));
}
public void TerminateLifetimeWithUnboundedInputLifetimeWired_ValidateVariableUsages_LifetimeCannotBeTerminatedErrorMessageReported()
{
DfirRoot function = DfirRoot.Create();
TerminateLifetimeNode terminateLifetime = new TerminateLifetimeNode(function.BlockDiagram, 1, 1);
ConnectConstantToInputTerminal(terminateLifetime.InputTerminals[0], PFTypes.Int32, false);
RunSemanticAnalysisUpToValidation(function);
Assert.IsTrue(terminateLifetime.GetDfirMessages().Any(message => message.Descriptor == Messages.TerminateLifetimeInputLifetimeCannotBeTerminated.Descriptor));
}
public static TerminateLifetimeNode CreateTerminateLifetimeWithFacades(Diagram parentDiagram, int inputs, int outputs)
{
var terminateLifetime = new TerminateLifetimeNode(parentDiagram, inputs, outputs);
AutoBorrowNodeFacade terminateLifetimeFacade = AutoBorrowNodeFacade.GetNodeFacade(terminateLifetime);
foreach (var terminal in terminateLifetime.Terminals)
{
terminateLifetimeFacade[terminal] = new SimpleTerminalFacade(terminal, default(TypeVariableReference));
}
return(terminateLifetime);
}
public void TerminateLifetimeWithNoInputLifetimesWired_SetVariableTypes_OutputVariableHasType()
{
DfirRoot function = DfirRoot.Create();
TerminateLifetimeNode terminateLifetime = new TerminateLifetimeNode(function.BlockDiagram, 1, 1);
RunSemanticAnalysisUpToSetVariableTypes(function);
VariableReference outputVariable = terminateLifetime.OutputTerminals[0].GetFacadeVariable();
Assert.IsNotNull(outputVariable.TypeVariableReference.TypeVariableSet);
Assert.IsTrue(outputVariable.Type.IsVoid());
}
public void TerminateLifetimeWithStructureBorderInputLifetimeWired_ValidateVariableUsages_LifetimeCannotBeTerminatedErrorMessageReported()
{
DfirRoot function = DfirRoot.Create();
Frame frame = Frame.Create(function.BlockDiagram);
BorrowTunnel borrowTunnel = CreateBorrowTunnel(frame, BorrowMode.Immutable);
ConnectConstantToInputTerminal(borrowTunnel.InputTerminals[0], PFTypes.Int32, false);
TerminateLifetimeNode terminateLifetime = new TerminateLifetimeNode(frame.Diagram, 1, 1);
Wire wire = Wire.Create(frame.Diagram, borrowTunnel.OutputTerminals[0], terminateLifetime.InputTerminals[0]);
RunSemanticAnalysisUpToValidation(function);
Assert.IsTrue(terminateLifetime.GetDfirMessages().Any(message => message.Descriptor == Messages.TerminateLifetimeInputLifetimeCannotBeTerminated.Descriptor));
}
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 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 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 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 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));
}
private void VisitTerminateLifetime(TerminateLifetime terminateLifetime)
{
TerminateLifetimeNode terminateLifetimeDfir = (TerminateLifetimeNode)_map.GetDfirForModel(terminateLifetime);
if (terminateLifetimeDfir.RequiredInputCount != null && terminateLifetimeDfir.RequiredOutputCount != null)
{
terminateLifetime.UpdateTerminals(terminateLifetimeDfir.RequiredInputCount.Value, terminateLifetimeDfir.RequiredOutputCount.Value);
}
foreach (var pair in terminateLifetime.Terminals.Zip(terminateLifetimeDfir.Terminals))
{
if (!_map.ContainsTerminal(pair.Key))
{
_map.AddMapping(pair.Key, pair.Value);
}
}
}
public void TerminateLifetimeOnLifetimeContainingVariablesConsumedByFunctionalNode_SetVariableTypes_TerminateLifetimeHasNoError()
{
DfirRoot function = DfirRoot.Create();
TerminateLifetimeNode terminateLifetime = new TerminateLifetimeNode(function.BlockDiagram, 1, 1);
FunctionalNode selectReference = new FunctionalNode(function.BlockDiagram, Signatures.SelectReferenceType);
Wire.Create(function.BlockDiagram, selectReference.OutputTerminals[1], terminateLifetime.InputTerminals[0]);
ExplicitBorrowNode borrow = ConnectExplicitBorrowToInputTerminals(selectReference.InputTerminals[1], selectReference.InputTerminals[2]);
ConnectConstantToInputTerminal(borrow.InputTerminals[0], PFTypes.Int32, false);
ConnectConstantToInputTerminal(borrow.InputTerminals[1], PFTypes.Int32, false);
RunSemanticAnalysisUpToSetVariableTypes(function);
Assert.AreEqual(TerminateLifetimeErrorState.NoError, terminateLifetime.ErrorState);
Assert.AreEqual(2, terminateLifetime.OutputTerminals.Count);
}
public void TypeDeterminantDownstreamOfTerminateLifetime_SetVariableTypes_UpstreamTypeSetCorrectly()
{
DfirRoot function = DfirRoot.Create();
var genericOutput = new FunctionalNode(function.BlockDiagram, DefineGenericOutputFunctionSignature());
var terminateLifetime = new TerminateLifetimeNode(function.BlockDiagram, 1, 1);
var borrow = ConnectExplicitBorrowToInputTerminals(terminateLifetime.InputTerminals[0]);
genericOutput.OutputTerminals[0].WireTogether(borrow.InputTerminals[0], SourceModelIdSource.NoSourceModelId);
var assignNode = new FunctionalNode(function.BlockDiagram, Signatures.AssignType);
terminateLifetime.OutputTerminals[0].WireTogether(assignNode.InputTerminals[0], SourceModelIdSource.NoSourceModelId);
ConnectConstantToInputTerminal(assignNode.InputTerminals[1], PFTypes.Int32, false);
RunSemanticAnalysisUpToSetVariableTypes(function);
Assert.IsTrue(genericOutput.OutputTerminals[0].GetTrueVariable().Type.IsInt32());
}
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 OwnerStringConnectedToStringSliceReferenceInputTerminal_AutomaticNodeInsertion_BorrowNodeAndStringToSliceInserted()
{
DfirRoot function = DfirRoot.Create();
FunctionalNode outputStringOwner = new FunctionalNode(function.BlockDiagram, _outputOwnerStringSignature);
FunctionalNode concatString = new FunctionalNode(function.BlockDiagram, _stringSlicePassthroughSignature);
Wire.Create(function.BlockDiagram, outputStringOwner.OutputTerminals[0], concatString.InputTerminals[0]);
RunCompilationUpToAutomaticNodeInsertion(function);
ExplicitBorrowNode borrowNode = AssertDiagramContainsNodeWithSources <ExplicitBorrowNode>(function.BlockDiagram, outputStringOwner.OutputTerminals[0]);
FunctionalNode stringToSlice = AssertDiagramContainsNodeWithSources <FunctionalNode>(function.BlockDiagram, f => f.Signature == Signatures.StringToSliceType, borrowNode.OutputTerminals[0]);
Assert.AreEqual(stringToSlice.OutputTerminals[0], concatString.InputTerminals[0].GetImmediateSourceTerminal());
TerminateLifetimeNode terminateLifetime = AssertDiagramContainsNodeWithSources <TerminateLifetimeNode>(function.BlockDiagram, concatString.OutputTerminals[0]);
AssertDiagramContainsNodeWithSources <DropNode>(function.BlockDiagram, terminateLifetime.OutputTerminals[0]);
}
public void VectorIntoSliceIntoSliceIterator_AutomaticNodeInsertion_SliceIteratorTerminatedAndVectorDropped()
{
DfirRoot function = DfirRoot.Create();
var initializeVector = new FunctionalNode(function.BlockDiagram, Signatures.VectorInitializeType);
ConnectConstantToInputTerminal(initializeVector.InputTerminals[0], NITypes.Int32, false);
ConnectConstantToInputTerminal(initializeVector.InputTerminals[1], NITypes.Int32, false);
var vectorToSlice = new FunctionalNode(function.BlockDiagram, Signatures.VectorToSliceType);
Wire.Create(function.BlockDiagram, initializeVector.OutputTerminals[0], vectorToSlice.InputTerminals[0]);
var createSliceIterator = new FunctionalNode(function.BlockDiagram, Signatures.SliceToIteratorType);
Wire.Create(function.BlockDiagram, vectorToSlice.OutputTerminals[0], createSliceIterator.InputTerminals[0]);
RunCompilationUpToAutomaticNodeInsertion(function);
TerminateLifetimeNode terminateLifetime = AssertDiagramContainsNodeWithSources <TerminateLifetimeNode>(function.BlockDiagram, createSliceIterator.OutputTerminals[0]);
AssertDiagramContainsNodeWithSources <DropNode>(function.BlockDiagram, terminateLifetime.OutputTerminals[0]);
}
public void PassthroughIntoBorrowAndTerminateLifetime_AutomaticNodeInsertion_DropIsInsertedCorrectly()
{
// Note: this test for a bug case where auto-inserting a TerminateLifetime in a graph where a variable
// was already marked live at a later TL would later wreck the graph by disconnecting everything
// downstream of the auto-inserted TL when creating a Drop.
DfirRoot function = DfirRoot.Create();
FunctionalNode mutablePassthrough = new FunctionalNode(function.BlockDiagram, Signatures.MutablePassthroughType);
ConnectConstantToInputTerminal(mutablePassthrough.InputTerminals[0], NITypes.Int32, true);
var borrowNode = new ExplicitBorrowNode(function.BlockDiagram, BorrowMode.Immutable, 1, true, true);
Wire.Create(function.BlockDiagram, mutablePassthrough.OutputTerminals[0], borrowNode.InputTerminals[0]);
TerminateLifetimeNode terminateLifetime = new TerminateLifetimeNode(function.BlockDiagram, 1, 1);
Wire.Create(function.BlockDiagram, borrowNode.OutputTerminals[0], terminateLifetime.InputTerminals[0]);
RunCompilationUpToAutomaticNodeInsertion(function);
AssertDiagramContainsNodeWithSources <DropNode>(function.BlockDiagram, terminateLifetime.OutputTerminals[0]);
}
private void UpdateTerminateLifetimeErrorState(TerminateLifetimeNode terminateLifetimeNode)
{
switch (_state)
{
case State.NoVariableSeen:
case State.AllVariablesInLifetimeTerminated:
terminateLifetimeNode.ErrorState = TerminateLifetimeErrorState.NoError;
break;
case State.VariablesInLifetimeRemaining:
terminateLifetimeNode.ErrorState = TerminateLifetimeErrorState.NotAllVariablesInLifetimeConnected;
break;
case State.InputLifetimeIsNotUnique:
terminateLifetimeNode.ErrorState = TerminateLifetimeErrorState.InputLifetimesNotUnique;
break;
case State.LifetimeCannotBeTerminated:
terminateLifetimeNode.ErrorState = TerminateLifetimeErrorState.InputLifetimeCannotBeTerminated;
break;
}
}
public bool VisitTerminateLifetimeNode(TerminateLifetimeNode terminateLifetimeNode)
{
foreach (var inputTerminal in terminateLifetimeNode.InputTerminals)
{
VariableUsageValidator validator = new VariableUsageValidator(inputTerminal, false);
}
switch (terminateLifetimeNode.ErrorState)
{
case TerminateLifetimeErrorState.InputLifetimesNotUnique:
terminateLifetimeNode.SetDfirMessage(Messages.TerminateLifetimeInputLifetimesNotUnique);
break;
case TerminateLifetimeErrorState.InputLifetimeCannotBeTerminated:
terminateLifetimeNode.SetDfirMessage(Messages.TerminateLifetimeInputLifetimeCannotBeTerminated);
break;
case TerminateLifetimeErrorState.NotAllVariablesInLifetimeConnected:
terminateLifetimeNode.SetDfirMessage(Messages.TerminateLifetimeNotAllVariablesInLifetimeConnected);
break;
}
return(true);
}
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);
}
bool IDfirNodeVisitor <bool> .VisitTerminateLifetimeNode(TerminateLifetimeNode terminateLifetimeNode)
{
terminateLifetimeNode.UnificationState.UpdateTerminateLifetimeOutputs(terminateLifetimeNode, _lifetimeVariableAssociation);
return(true);
}
