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); }