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));
}
private PrimitiveTypeNode ConnectPrimitiveTypeToInputTerminal(Terminal inputTerminal, NIType type)
{
var primitive = new PrimitiveTypeNode(inputTerminal.ParentDiagram, type);
Wire.Create(inputTerminal.ParentDiagram, primitive.OutputTerminal, inputTerminal);
return(primitive);
}
public void InitializeVectorAndSumWithSliceIterator_Execute_CorrectSumValue()
{
DfirRoot function = DfirRoot.Create();
FunctionalNode initializeVector = CreateInitializeVectorWithIntegerConstants(function.BlockDiagram, 4, 4);
FunctionalNode vectorToSlice = new FunctionalNode(function.BlockDiagram, Signatures.VectorToSliceType);
Wire.Create(function.BlockDiagram, initializeVector.OutputTerminals[0], vectorToSlice.InputTerminals[0]);
FunctionalNode sliceToIterator = new FunctionalNode(function.BlockDiagram, Signatures.SliceToIteratorType);
Wire.Create(function.BlockDiagram, vectorToSlice.OutputTerminals[0], sliceToIterator.InputTerminals[0]);
Loop loop = new Loop(function.BlockDiagram);
CreateLoopConditionTunnel(loop);
IterateTunnel iterateTunnel = CreateIterateTunnel(loop);
BorrowTunnel borrowTunnel = CreateBorrowTunnel(loop, BorrowMode.Mutable);
ConnectConstantToInputTerminal(borrowTunnel.InputTerminals[0], NITypes.Int32, 0, true);
Wire.Create(function.BlockDiagram, sliceToIterator.OutputTerminals[0], iterateTunnel.InputTerminals[0])
.SetWireBeginsMutableVariable(true);
FunctionalNode accumulateAdd = new FunctionalNode(loop.Diagrams[0], Signatures.DefineMutatingBinaryFunction("AccumulateAdd", NITypes.Int32));
Wire.Create(loop.Diagrams[0], borrowTunnel.OutputTerminals[0], accumulateAdd.InputTerminals[0]);
Wire.Create(loop.Diagrams[0], iterateTunnel.OutputTerminals[0], accumulateAdd.InputTerminals[1]);
FunctionalNode inspectNode = ConnectInspectToOutputTerminal(borrowTunnel.TerminateLifetimeTunnel.OutputTerminals[0]);
TestExecutionInstance executionInstance = CompileAndExecuteFunction(function);
byte[] inspectValue = executionInstance.GetLastValueFromInspectNode(inspectNode);
AssertByteArrayIsInt32(inspectValue, 16);
}
internal static FunctionalNode ConnectSomeConstructorToInputTerminal(Terminal inputTerminal)
{
FunctionalNode someConstructor = new FunctionalNode(inputTerminal.ParentDiagram, Signatures.SomeConstructorType);
Wire wire = Wire.Create(inputTerminal.ParentDiagram, someConstructor.OutputTerminals[0], inputTerminal);
return(someConstructor);
}
public void SumItemsFromRangeIterator_Execute_CorrectFinalResult()
{
DfirRoot function = DfirRoot.Create();
Loop loop = new Loop(function.BlockDiagram);
LoopConditionTunnel conditionTunnel = CreateLoopConditionTunnel(loop);
IterateTunnel iterateTunnel = CreateIterateTunnel(loop);
FunctionalNode range = new FunctionalNode(function.BlockDiagram, Signatures.RangeType);
Wire rangeWire = Wire.Create(function.BlockDiagram, range.OutputTerminals[0], iterateTunnel.InputTerminals[0]);
rangeWire.SetWireBeginsMutableVariable(true);
Constant lowConstant = ConnectConstantToInputTerminal(range.InputTerminals[0], NITypes.Int32, 0, false);
Constant highConstant = ConnectConstantToInputTerminal(range.InputTerminals[1], NITypes.Int32, 10, false);
BorrowTunnel borrow = CreateBorrowTunnel(loop, BorrowMode.Mutable);
Constant accumulateConstant = ConnectConstantToInputTerminal(borrow.InputTerminals[0], NITypes.Int32, 0, true);
FunctionalNode accumulateAdd = new FunctionalNode(loop.Diagram, Signatures.DefineMutatingBinaryFunction("AccumulateAdd", NITypes.Int32));
Wire.Create(loop.Diagram, borrow.OutputTerminals[0], accumulateAdd.InputTerminals[0]);
Wire.Create(loop.Diagram, iterateTunnel.OutputTerminals[0], accumulateAdd.InputTerminals[1]);
FunctionalNode inspect = ConnectInspectToOutputTerminal(borrow.TerminateLifetimeTunnel.OutputTerminals[0]);
TestExecutionInstance executionInstance = CompileAndExecuteFunction(function);
byte[] inspectValue = executionInstance.GetLastValueFromInspectNode(inspect);
AssertByteArrayIsInt32(inspectValue, 45);
}
private static FunctionalNode ConnectCreateLockingCellToInputTerminal(Terminal inputTerminal)
{
FunctionalNode createLockingCell = new FunctionalNode(inputTerminal.ParentDiagram, Signatures.CreateLockingCellType);
Wire wire = Wire.Create(inputTerminal.ParentDiagram, createLockingCell.OutputTerminals[0], inputTerminal);
return(createLockingCell);
}
public static FunctionalNode ConnectOutputToOutputTerminal(this CompilerTestBase test, Terminal outputTerminal)
{
var output = new FunctionalNode(outputTerminal.ParentDiagram, Signatures.OutputType);
Wire.Create(outputTerminal.ParentDiagram, outputTerminal, output.InputTerminals[0]);
return(output);
}
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 void PanickingMethodCallWithTwoOutputsThatDoesNotPanicIntoAdd_Execute_CorrectValue()
{
using (FeatureToggleSupport.TemporarilyEnableFeature(RebarFeatureToggles.ParametersAndCalls))
{
string calleeName = "callee";
NIType calleeType = DefineFunctionTypeWithTwoIntOuts(calleeName);
CompilableDefinitionName calleeDefinitionName = CreateTestCompilableDefinitionName(calleeName);
DfirRoot calleeFunction = calleeType.CreateFunctionFromSignature(calleeDefinitionName);
DataAccessor outputDataAccessor0 = DataAccessor.Create(calleeFunction.BlockDiagram, calleeFunction.DataItems[0], Direction.Input);
DataAccessor outputDataAccessor1 = DataAccessor.Create(calleeFunction.BlockDiagram, calleeFunction.DataItems[1], Direction.Input);
FunctionalNode unwrap = new FunctionalNode(calleeFunction.BlockDiagram, Signatures.UnwrapOptionType);
ConnectSomeOfIntegerToInputTerminal(unwrap.InputTerminals[0], 1);
Wire.Create(calleeFunction.BlockDiagram, unwrap.OutputTerminals[0], outputDataAccessor0.Terminal, outputDataAccessor1.Terminal);
DfirRoot callerFunction = DfirRoot.Create();
var methodCall = new MethodCallNode(callerFunction.BlockDiagram, calleeDefinitionName, calleeType);
FunctionalNode add = new FunctionalNode(callerFunction.BlockDiagram, Signatures.DefinePureBinaryFunction("Add", NITypes.Int32, NITypes.Int32));
Wire.Create(callerFunction.BlockDiagram, methodCall.OutputTerminals[0], add.InputTerminals[0]);
Wire.Create(callerFunction.BlockDiagram, methodCall.OutputTerminals[1], add.InputTerminals[1]);
FunctionalNode inspect = ConnectInspectToOutputTerminal(add.OutputTerminals[2]);
TestExecutionInstance executionInstance = CompileAndExecuteFunction(callerFunction, calleeFunction);
byte[] inspectValue = executionInstance.GetLastValueFromInspectNode(inspect);
AssertByteArrayIsInt32(inspectValue, 2);
}
}
internal FunctionalNode ConnectInspectToOutputTerminal(Terminal outputTerminal)
{
FunctionalNode inspect = new FunctionalNode(outputTerminal.ParentDiagram, Signatures.InspectType);
Wire.Create(outputTerminal.ParentDiagram, outputTerminal, inspect.InputTerminals[0]);
return(inspect);
}
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);
}
protected Constant ConnectConstantToInputTerminal(Terminal inputTerminal, NIType variableType, bool mutable)
{
Constant constant = Constant.Create(inputTerminal.ParentDiagram, variableType.CreateDefaultValue(), variableType);
Wire wire = Wire.Create(inputTerminal.ParentDiagram, constant.OutputTerminal, inputTerminal);
wire.SetWireBeginsMutableVariable(mutable);
return(constant);
}
private void AssignFalseToLoopConditionOutputTerminal(LoopConditionTunnel condition)
{
Diagram loopDiagram = condition.OutputTerminals[0].ParentDiagram;
var assign = new FunctionalNode(loopDiagram, Signatures.AssignType);
Wire.Create(loopDiagram, condition.OutputTerminals[0], assign.InputTerminals[0]);
ConnectConstantToInputTerminal(assign.InputTerminals[1], NITypes.Boolean, false, false);
}
private FunctionalNode ConnectOutputToOutputTerminal(Terminal outputTerminal)
{
Diagram diagram = outputTerminal.ParentDiagram;
var output = new FunctionalNode(diagram, Signatures.OutputType);
Wire.Create(diagram, outputTerminal, output.InputTerminals[0]);
return(output);
}
internal FunctionalNode ConnectSomeConstructorToInputTerminal(Terminal inputTerminal, bool mutableOutput = false)
{
var someConstructor = new FunctionalNode(inputTerminal.ParentDiagram, Signatures.SomeConstructorType);
Wire.Create(inputTerminal.ParentDiagram, someConstructor.OutputTerminals[0], inputTerminal)
.SetWireBeginsMutableVariable(mutableOutput);
return(someConstructor);
}
private FunctionalNode CreatePanickingUnwrapOption(Diagram parentDiagram)
{
FunctionalNode createNoneInteger = CreateNoneOfOptionIntegerType(parentDiagram);
var unwrap = new FunctionalNode(parentDiagram, Signatures.UnwrapOptionType);
Wire.Create(parentDiagram, createNoneInteger.OutputTerminals[0], unwrap.InputTerminals[0]);
return(unwrap);
}
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;
}
}
}
private FunctionalNode CreateNoneOfOptionIntegerType(Diagram parentDiagram)
{
var assign = new FunctionalNode(parentDiagram, Signatures.AssignType);
ConnectSomeOfIntegerToInputTerminal(assign.InputTerminals[0], 0, true);
var noneConstructor = new FunctionalNode(parentDiagram, Signatures.NoneConstructorType);
Wire.Create(parentDiagram, noneConstructor.OutputTerminals[0], assign.InputTerminals[1]);
return(assign);
}
private void CreateAssignToSomeInt32ValueAndInspect(Diagram diagram, out FunctionalNode assign, out FunctionalNode inspect)
{
FunctionalNode initialSome = CreateInt32SomeConstructor(diagram, 0);
assign = new FunctionalNode(diagram, Signatures.AssignType);
Wire initialAssignWire = Wire.Create(diagram, initialSome.OutputTerminals[0], assign.InputTerminals[0]);
initialAssignWire.SetWireBeginsMutableVariable(true);
inspect = ConnectInspectToOutputTerminal(assign.OutputTerminals[0]);
}
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);
}
private FunctionalNode ConnectRangeWithIntegerInputsToInputTerminal(Terminal inputTerminal, bool mutable = true)
{
FunctionalNode range = new FunctionalNode(inputTerminal.ParentDiagram, Signatures.RangeType);
ConnectConstantToInputTerminal(range.InputTerminals[0], PFTypes.Int32, false);
ConnectConstantToInputTerminal(range.InputTerminals[1], PFTypes.Int32, false);
Wire wire = Wire.Create(inputTerminal.ParentDiagram, range.OutputTerminals[0], inputTerminal);
wire.SetWireBeginsMutableVariable(mutable);
return(range);
}
public void StructConstructorContainingDroppableType_Execute_DroppableValueDropped()
{
DfirRoot function = DfirRoot.Create();
var structConstructorNode = new StructConstructorNode(function.BlockDiagram, FakeDropStructType);
FunctionalNode fakeDrop = CreateFakeDropWithId(function.BlockDiagram, 1);
Wire.Create(function.BlockDiagram, fakeDrop.OutputTerminals[0], structConstructorNode.InputTerminals[0]);
TestExecutionInstance executionInstance = CompileAndExecuteFunction(function);
Assert.IsTrue(executionInstance.RuntimeServices.DroppedFakeDropIds.Contains(1));
}
public void DropSomeValueWithDroppableInnerValue_Execute_InnerValueIsDropped()
{
DfirRoot function = DfirRoot.Create();
FunctionalNode someConstructor = new FunctionalNode(function.BlockDiagram, Signatures.SomeConstructorType);
FunctionalNode fakeDropCreate = CreateFakeDropWithId(function.BlockDiagram, 1);
Wire.Create(function.BlockDiagram, fakeDropCreate.OutputTerminals[0], someConstructor.InputTerminals[0]);
TestExecutionInstance executionInstance = CompileAndExecuteFunction(function);
Assert.IsTrue(executionInstance.RuntimeServices.DroppedFakeDropIds.Contains(1));
}
public void VariantConstructorContainingDroppableValue_Execute_ValueIsDropped()
{
DfirRoot function = DfirRoot.Create();
var variantConstructorNode = new VariantConstructorNode(function.BlockDiagram, VariantWithDropField, 1);
FunctionalNode createFakeDrop = CreateFakeDropWithId(function.BlockDiagram, 1);
Wire.Create(function.BlockDiagram, createFakeDrop.OutputTerminals[0], variantConstructorNode.InputTerminals[0]);
TestExecutionInstance executionInstance = CompileAndExecuteFunction(function);
Assert.IsTrue(executionInstance.RuntimeServices.DroppedFakeDropIds.Contains(1));
}
public void NoneConstructorWithUsageThatDoesNotDetermineType_ValidateVariableUsage_ErrorReported()
{
DfirRoot function = DfirRoot.Create();
FunctionalNode none = new FunctionalNode(function.BlockDiagram, Signatures.NoneConstructorType);
FunctionalNode immutablePassthrough = new FunctionalNode(function.BlockDiagram, Signatures.ImmutablePassthroughType);
Wire.Create(function.BlockDiagram, none.OutputTerminals[0], immutablePassthrough.InputTerminals[0]);
RunSemanticAnalysisUpToValidation(function);
Assert.IsTrue(none.OutputTerminals[0].GetDfirMessages().Any(message => message.Descriptor == Messages.TypeNotDetermined.Descriptor));
}
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]);
}
private IterateTunnel CreateRangeAndIterateTunnel(Loop loop, int rangeLow, int rangeHigh)
{
var range = new FunctionalNode(loop.ParentDiagram, Signatures.RangeType);
ConnectConstantToInputTerminal(range.InputTerminals[0], NITypes.Int32, 1, false);
ConnectConstantToInputTerminal(range.InputTerminals[1], NITypes.Int32, 7, false);
IterateTunnel iterateTunnel = CreateIterateTunnel(loop);
Wire.Create(loop.ParentDiagram, range.OutputTerminals[0], iterateTunnel.InputTerminals[0])
.SetWireBeginsMutableVariable(true);
return(iterateTunnel);
}
private DfirRoot CreateStringIntoStringConcatFunction()
{
DfirRoot function = DfirRoot.Create();
Constant constant = Constant.Create(function.BlockDiagram, string.Empty, DataTypes.StringSliceType.CreateImmutableReference());
FunctionalNode stringFromSlice = new FunctionalNode(function.BlockDiagram, Signatures.StringFromSliceType);
Wire.Create(function.BlockDiagram, constant.OutputTerminal, stringFromSlice.InputTerminals[0]);
FunctionalNode stringConcat = new FunctionalNode(function.BlockDiagram, Signatures.StringConcatType);
Wire.Create(function.BlockDiagram, stringFromSlice.OutputTerminals[1], stringConcat.InputTerminals[0]);
return(function);
}
