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 CreateMethodCallPromise(Node parentNode, NIType signature, CompilableDefinitionName targetName) : base(parentNode)
{
PromiseTerminal = CreateTerminal(Direction.Output, NITypes.Void, "promise");
foreach (NIType parameter in signature.GetParameters().Where(p => p.GetInputParameterPassingRule() == NIParameterPassingRule.Required))
{
CreateTerminal(Direction.Input, NITypes.Void, parameter.GetName());
}
Signature = signature;
TargetName = targetName;
}
public void PanickingMethodCallWithNoParametersThatDoesNotPanic_Execute_RuntimeDoesNotRegisterPanic()
{
using (FeatureToggleSupport.TemporarilyEnableFeature(RebarFeatureToggles.ParametersAndCalls))
{
string calleeName = "callee";
NIType calleeType = calleeName.DefineMethodType().CreateType();
CompilableDefinitionName calleeDefinitionName = CreateTestCompilableDefinitionName(calleeName);
DfirRoot calleeFunction = calleeType.CreateFunctionFromSignature(calleeDefinitionName);
CreateNonPanickingUnwrapOption(calleeFunction.BlockDiagram);
DfirRoot callerFunction = DfirRoot.Create();
var methodCall = new MethodCallNode(callerFunction.BlockDiagram, calleeDefinitionName, calleeType);
TestExecutionInstance executionInstance = CompileAndExecuteFunction(callerFunction, calleeFunction);
Assert.IsFalse(executionInstance.RuntimeServices.PanicOccurred);
}
}
public FunctionCompileSignature(
CompilableDefinitionName functionName,
IEnumerable <CompileSignatureParameter> compileSignatureParameters,
bool isYielding,
bool mayPanic)
: base(
functionName: functionName,
parameters: compileSignatureParameters,
declaringType: NIType.Unset,
reentrancy: Reentrancy.None,
isYielding: isYielding,
isFunctional: true,
threadAffinity: ThreadAffinity.Standard,
shouldAlwaysInline: false,
mayWantToInline: true,
priority: ExecutionPriority.Normal,
callingConvention: System.Runtime.InteropServices.CallingConvention.StdCall)
{
Version = FunctionBuiltPackage.CurrentVersion;
MayPanic = mayPanic;
}
public void PanickingMethodCallWithInputAndOutputThatPanicsIntoOutput_Execute_NoOutputValue()
{
using (FeatureToggleSupport.TemporarilyEnableFeature(RebarFeatureToggles.ParametersAndCalls))
{
string calleeName = "callee";
NIType calleeType = DefineFunctionTypeWithOptionIntInAndIntOut(calleeName);
CompilableDefinitionName calleeDefinitionName = CreateTestCompilableDefinitionName(calleeName);
DfirRoot calleeFunction = calleeType.CreateFunctionFromSignature(calleeDefinitionName);
DataAccessor inputDataAccessor = DataAccessor.Create(calleeFunction.BlockDiagram, calleeFunction.DataItems[0], Direction.Output);
DataAccessor outputDataAccessor = DataAccessor.Create(calleeFunction.BlockDiagram, calleeFunction.DataItems[1], Direction.Input);
FunctionalNode unwrap = new FunctionalNode(calleeFunction.BlockDiagram, Signatures.UnwrapOptionType);
Wire.Create(calleeFunction.BlockDiagram, inputDataAccessor.Terminal, unwrap.InputTerminals[0]);
Wire.Create(calleeFunction.BlockDiagram, unwrap.OutputTerminals[0], outputDataAccessor.Terminal);
DfirRoot callerFunction = DfirRoot.Create();
var methodCall = new MethodCallNode(callerFunction.BlockDiagram, calleeDefinitionName, calleeType);
FunctionalNode noneInteger = CreateNoneOfOptionIntegerType(callerFunction.BlockDiagram);
Wire.Create(callerFunction.BlockDiagram, noneInteger.OutputTerminals[0], methodCall.InputTerminals[0]);
ConnectOutputToOutputTerminal(methodCall.OutputTerminals[0]);
TestExecutionInstance executionInstance = CompileAndExecuteFunction(callerFunction, calleeFunction);
AssertNoOutput(executionInstance);
}
}
public MethodCallNode(
Node parentNode,
CompilableDefinitionName targetName,
NIType signature)
: base(
parentNode,
EnumerateRequiredDependencies(DfirDependencyName.CreateFromCompilableDefinitionName(targetName, parentNode.DfirRoot.BuildSpec), signature))
{
TargetName = targetName;
Signature = signature;
foreach (var parameter in signature.GetParameters())
{
NIType dataType = parameter.GetDataType();
string name = parameter.GetUserVisibleParameterName();
Terminal inputTerminal, outputTerminal;
if (parameter.IsInputOnlyParameter())
{
inputTerminal = CreateTerminal(Direction.Input, dataType, name);
_terminalParameters[inputTerminal] = parameter;
}
else if (parameter.IsOutputOnlyParameter())
{
outputTerminal = CreateTerminal(Direction.Output, dataType, name);
_terminalParameters[outputTerminal] = parameter;
}
else
{
inputTerminal = CreateTerminal(Direction.Input, dataType, name);
outputTerminal = CreateTerminal(Direction.Output, dataType, name);
_terminalParameters[inputTerminal] = parameter;
_terminalParameters[outputTerminal] = parameter;
_passthroughTerminalPairs = _passthroughTerminalPairs ?? new List <PassthroughTerminalPair>();
_passthroughTerminalPairs.Add(new PassthroughTerminalPair(inputTerminal, outputTerminal));
}
}
}
/// <inheritdoc />
protected override IExecutable TryGetExecutable(CompilableDefinitionName executableName, int cloneNumber)
{
throw new NotImplementedException();
}
/// <inheritdoc />
public override void UnloadFunction(CompilableDefinitionName executableName)
{
}
/// <inheritdoc/>
public override BuildSpec CreateDefaultBuildSpec(CompilableDefinitionName topLevelDefinitionName, IReadOnlySymbolTable symbolTable)
{
Log.Assert(0xC3B662C7U, topLevelDefinitionName.OwningComponentRuntimeName != null, "Component name must be set in ExtendedQualifiedNames passed to compiler");
return(new BuildSpec(TargetCompilerIdentity, symbolTable));
}
internal static string FunctionLLVMName(CompilableDefinitionName functionCompilableDefinitionName)
{
return(FunctionLLVMName(functionCompilableDefinitionName.SourceName));
}
public static DfirRoot CreateFunctionFromSignature(this NIType functionSignature, CompilableDefinitionName functionDefinitionName)
{
DfirRoot function = DfirRoot.Create(new CompileSpecification(functionDefinitionName, null));
int connectorPaneIndex = 0;
foreach (NIType parameter in functionSignature.GetParameters())
{
function.CreateDataItem(
parameter.GetName(),
parameter.GetDataType(),
null, // defaultValue
parameter.GetInputParameterPassingRule(),
parameter.GetOutputParameterPassingRule(),
connectorPaneIndex++);
}
return(function);
}
/// <inheritdoc />
protected override void UnloadCore(string runtimeName, CompilableDefinitionName editorName)
{
throw new NotImplementedException();
}
