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);
}
private static void CompileSomeConstructor(FunctionCompiler compiler, FunctionalNode someConstructorNode)
{
VariableReference input = someConstructorNode.InputTerminals.ElementAt(0).GetTrueVariable(),
output = someConstructorNode.OutputTerminals.ElementAt(0).GetTrueVariable();
compiler.CopyValueToSomeValue(input, output);
}
private static void CompileStringFromSlice(FunctionCompiler compiler, FunctionalNode stringFromSliceNode)
{
VariableReference input = stringFromSliceNode.InputTerminals[0].GetTrueVariable(),
output = stringFromSliceNode.OutputTerminals[1].GetTrueVariable();
Action <FunctionCompiler> loadStringOutputAllocationReference = c => c.LoadLocalAllocationReference(output);
// Get a pointer to a heap allocation big enough for the string
compiler.LoadConstantOffsetFromPointer(loadStringOutputAllocationReference, 0);
compiler.LoadStringSliceReferenceSizeReference(input);
compiler._builder.EmitDerefInteger();
compiler._builder.EmitAlloc_TEMP();
compiler._builder.EmitStorePointer();
// Copy the data from the string slice to the heap allocation
compiler.LoadStringSliceReferencePointer(input);
compiler._builder.EmitDerefPointer();
compiler.LoadConstantOffsetFromPointer(loadStringOutputAllocationReference, 0);
compiler._builder.EmitDerefPointer();
compiler.LoadStringSliceReferenceSizeReference(input);
compiler._builder.EmitDerefInteger();
compiler._builder.EmitCopyBytes_TEMP();
// Copy actual size into string handle
compiler.LoadConstantOffsetFromPointer(loadStringOutputAllocationReference, TargetConstants.PointerSize);
compiler.LoadStringSliceReferenceSizeReference(input);
compiler._builder.EmitDerefInteger();
compiler._builder.EmitStoreInteger();
}
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);
}
}
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 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);
}
private static FunctionalNode CreateFunctionalNodeWithFacade(Diagram parentDiagram, NIType signature)
{
var node = new FunctionalNode(parentDiagram, signature);
node.CreateFacadesForFunctionSignatureNode(signature);
return(node);
}
public bool VisitFunctionalNode(FunctionalNode functionalNode)
{
functionalNode.InputTerminals.ForEach(ValidateRequiredInputTerminal);
// TODO: for functions with more than one data type parameter, it would be better
// to report TypeNotDetermined on an output only if all inputs that use the same
// type parameter(s) are connected.
if (functionalNode.InputTerminals.All(terminal => terminal.IsConnected))
{
Signature signature = Signatures.GetSignatureForNIType(functionalNode.Signature);
foreach (var outputTerminalPair in functionalNode.OutputTerminals.Zip(signature.Outputs)
.Where(pair => !pair.Value.IsPassthrough))
{
VariableReference outputVariable = outputTerminalPair.Key.GetTrueVariable();
if (outputVariable.TypeVariableReference.IsOrContainsTypeVariable)
{
outputTerminalPair.Key.SetDfirMessage(Messages.TypeNotDetermined);
}
}
}
if (functionalNode.RequiredFeatureToggles.Any(feature => !FeatureToggleSupport.IsFeatureEnabled(feature)))
{
functionalNode.SetDfirMessage(Messages.FeatureNotEnabled);
}
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 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 void CompileAssign(FunctionCompiler compiler, FunctionalNode assignNode)
{
ValueSource assigneeSource = compiler.GetTerminalValueSource(assignNode.InputTerminals[0]),
newValueSource = compiler.GetTerminalValueSource(assignNode.InputTerminals[1]);
assigneeSource.UpdateDereferencedValue(compiler._builder, newValueSource.GetValue(compiler._builder));
}
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 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);
}
internal FunctionalNode ConnectInspectToOutputTerminal(Terminal outputTerminal)
{
FunctionalNode inspect = new FunctionalNode(outputTerminal.ParentDiagram, Signatures.InspectType);
Wire.Create(outputTerminal.ParentDiagram, outputTerminal, inspect.InputTerminals[0]);
return(inspect);
}
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);
}
internal FunctionalNode CreateFakeDropWithId(Diagram parentDiagram, int id)
{
FunctionalNode fakeDropCreate = new FunctionalNode(parentDiagram, Signatures.FakeDropCreateType);
ConnectConstantToInputTerminal(fakeDropCreate.InputTerminals[0], NITypes.Int32, id, false);
return(fakeDropCreate);
}
public void CanDeterminFunctionHasCycles()
{
TortoiseHare <int> algo = new TortoiseHare <int>();
FunctionalNode <int> fNode = new FunctionalNode <int>(x => (x + 1) % 10, 0);
Assert.True(algo.HasCycle(fNode));
}
protected void TestPrimitiveOperation(
NIType operationSignature,
object leftValue,
object rightValue,
NIType inputType,
bool mutating,
Action <byte[]> testExpectedValue)
{
DfirRoot function = DfirRoot.Create();
FunctionalNode functionNode = new FunctionalNode(function.BlockDiagram, operationSignature);
Constant leftValueConstant = ConnectConstantToInputTerminal(functionNode.InputTerminals[0], inputType, leftValue, mutating);
int lastIndex = 2;
if (rightValue != null)
{
Constant rightValueConstant = ConnectConstantToInputTerminal(functionNode.InputTerminals[1], inputType, rightValue, false);
}
else
{
lastIndex = 1;
}
FunctionalNode inspect = ConnectInspectToOutputTerminal(mutating
? functionNode.OutputTerminals[0]
: functionNode.OutputTerminals[lastIndex]);
TestExecutionInstance executionInstance = CompileAndExecuteFunction(function);
byte[] inspectValue = executionInstance.GetLastValueFromInspectNode(inspect);
testExpectedValue(inspectValue);
}
private static void CompileSelectReference(FunctionCompiler compiler, FunctionalNode selectReferenceNode)
{
LabelBuilder falseLabel = compiler._builder.CreateLabel(),
endLabel = compiler._builder.CreateLabel();
VariableReference input1 = selectReferenceNode.InputTerminals.ElementAt(1).GetTrueVariable(),
input2 = selectReferenceNode.InputTerminals.ElementAt(2).GetTrueVariable(),
selector = selectReferenceNode.InputTerminals.ElementAt(0).GetTrueVariable(),
selectedReference = selectReferenceNode.OutputTerminals.ElementAt(1).GetTrueVariable();
compiler.LoadLocalAllocationReference(selectedReference);
compiler.LoadValueAsReference(selector);
compiler._builder.EmitDerefInteger();
compiler._builder.EmitBranchIfFalse(falseLabel);
// true
compiler.LoadValueAsReference(input1);
compiler._builder.EmitBranch(endLabel);
// false
compiler._builder.SetLabel(falseLabel);
compiler.LoadValueAsReference(input2);
// end
compiler._builder.SetLabel(endLabel);
compiler._builder.EmitStorePointer();
}
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);
}
private static void CompileOutput(FunctionCompiler compiler, FunctionalNode outputNode)
{
VariableReference input = outputNode.InputTerminals.ElementAt(0).GetTrueVariable();
NIType referentType = input.Type.GetReferentType();
if (referentType.IsInt32())
{
compiler.LoadValueAsReference(input);
compiler._builder.EmitDerefInteger();
compiler._builder.EmitOutput_TEMP();
}
else if (referentType.IsString())
{
compiler.LoadValueAsReference(input);
compiler._builder.EmitDerefPointer();
compiler.LoadValueAsReference(input);
compiler._builder.EmitLoadIntegerImmediate(TargetConstants.PointerSize);
compiler._builder.EmitAdd();
compiler._builder.EmitDerefInteger();
compiler._builder.EmitOutputString_TEMP();
}
else if (referentType == DataTypes.StringSliceType)
{
compiler.LoadStringSliceReferencePointer(input);
compiler._builder.EmitDerefPointer();
compiler.LoadStringSliceReferenceSizeReference(input);
compiler._builder.EmitDerefInteger();
compiler._builder.EmitOutputString_TEMP();
}
else
{
throw new NotImplementedException($"Don't know how to display type {referentType} yet.");
}
}
private FunctionalNode CreateInt32SomeConstructor(Diagram diagram, int value)
{
FunctionalNode initialSome = new FunctionalNode(diagram, Signatures.SomeConstructorType);
Constant constant = ConnectConstantToInputTerminal(initialSome.InputTerminals[0], NITypes.Int32, value, false);
return(initialSome);
}
private static void CompileAssign(FunctionCompiler compiler, FunctionalNode assignNode)
{
VariableReference assignee = assignNode.InputTerminals.ElementAt(0).GetTrueVariable(),
value = assignNode.InputTerminals.ElementAt(1).GetTrueVariable();
compiler.CopyValueToReferencedAddress(assignee, value, assignee.Type.GetReferentType());
}
private void InsertStringToSliceAheadOfTerminal(Terminal sliceReceiver, out VariableReference stringReferenceVariable, out Terminal stringReferenceTerminal)
{
FunctionalNode stringToSlice = new FunctionalNode(sliceReceiver.ParentDiagram, Signatures.StringToSliceType);
Terminal stringToSliceInput = stringToSlice.InputTerminals[0],
stringToSliceOutput = stringToSlice.OutputTerminals[0];
VariableReference sliceReceiverTrueVariable = sliceReceiver.GetTrueVariable();
TypeVariableSet typeVariableSet = stringToSliceInput.GetTypeVariableSet();
TypeVariableReference stringSliceReferenceType = sliceReceiverTrueVariable.TypeVariableReference;
TypeVariableReference u, lifetime;
bool m;
typeVariableSet.TryDecomposeReferenceType(stringSliceReferenceType, out u, out lifetime, out m);
TypeVariableReference stringReferenceType = typeVariableSet.CreateReferenceToReferenceType(
false,
typeVariableSet.CreateReferenceToLiteralType(PFTypes.String),
lifetime);
AutoBorrowNodeFacade stringToSliceFacade = AutoBorrowNodeFacade.GetNodeFacade(stringToSlice);
stringToSliceFacade[stringToSliceInput] = new SimpleTerminalFacade(stringToSliceInput, stringReferenceType);
stringToSliceFacade[stringToSliceOutput] = new SimpleTerminalFacade(stringToSliceOutput, default(TypeVariableReference));
sliceReceiver.ConnectedTerminal.ConnectTo(stringToSliceInput);
stringToSliceOutput.WireTogether(sliceReceiver, SourceModelIdSource.NoSourceModelId);
stringToSliceOutput.GetFacadeVariable().MergeInto(sliceReceiverTrueVariable);
stringReferenceVariable = stringToSliceInput.GetFacadeVariable();
stringReferenceTerminal = stringToSliceInput;
}
bool IDfirNodeVisitor <bool> .VisitFunctionalNode(FunctionalNode functionalNode)
{
var signature = Signatures.GetSignatureForNIType(functionalNode.Signature);
foreach (var inputPair in signature.Inputs.Zip(functionalNode.InputTerminals))
{
SignatureTerminal signatureTerminal = inputPair.Key;
Terminal terminal = inputPair.Value;
if (signatureTerminal.IsPassthrough)
{
MarkFacadeVariableOfTerminalInterrupted(terminal);
}
else
{
// NOTE: this is only correct if we assume that all FunctionalNodes are in normal form;
// that is, they don't take in bounded-lifetime variables without outputting at least
// one variable in the same lifetime.
MarkFacadeVariableOfTerminalInterrupted(terminal);
MarkTrueVariableOfTerminalConsumed(terminal);
}
}
foreach (var outputTerminal in functionalNode.OutputTerminals)
{
MarkFacadeVariableOfTerminalLive(outputTerminal);
}
return(true);
}
private FunctionalNode CreateNonPanickingUnwrapOption(Diagram parentDiagram)
{
var unwrap = new FunctionalNode(parentDiagram, Signatures.UnwrapOptionType);
ConnectSomeOfIntegerToInputTerminal(unwrap.InputTerminals[0], 0);
return(unwrap);
}
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);
}
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);
}
