public void LoopConditionTunnelWithNonBooleanInput_ValidateVariableUsage_TypeConflictErrorReported()
{
DfirRoot function = DfirRoot.Create();
Loop loop = new Loop(function.BlockDiagram);
LoopConditionTunnel loopConditionTunnel = CreateLoopConditionTunnel(loop);
ConnectConstantToInputTerminal(loopConditionTunnel.InputTerminals[0], NITypes.Int32, false);
RunSemanticAnalysisUpToValidation(function);
AssertTerminalHasTypeConflictMessage(loopConditionTunnel.InputTerminals[0]);
}
public void LoopConditionTunnelWithUnwiredInput_SetVariableTypes_InputVariableIsBooleanType()
{
DfirRoot function = DfirRoot.Create();
Loop loop = new Loop(function.BlockDiagram);
LoopConditionTunnel loopConditionTunnel = CreateLoopConditionTunnel(loop);
RunSemanticAnalysisUpToSetVariableTypes(function);
VariableReference loopConditionInputVariable = loopConditionTunnel.InputTerminals[0].GetTrueVariable();
Assert.IsTrue(loopConditionInputVariable.Type.IsBoolean());
}
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 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 = CreateNodeFacadesHelpers.CreateTerminateLifetimeWithFacades(originDiagram, inputVariableCount, outputVariableCount);
foreach (var pair in liveVariables.Zip(terminateLifetime.InputTerminals))
{
// TODO: maybe assert that liveVariable.Terminal is unwired here?
LiveVariable liveVariable = pair.Key;
Terminal terminateLifetimeInputTerminal = pair.Value;
liveVariable.ConnectToTerminalAsInputAndUnifyVariables(terminateLifetimeInputTerminal, _unificationResultFactory);
_lifetimeVariableAssociation.MarkVariableConsumed(liveVariable.Variable);
}
foreach (var pair in interruptedVariables.Zip(terminateLifetime.OutputTerminals))
{
VariableReference interruptedVariable = pair.Key;
Terminal terminateLifetimeOutputTerminal = pair.Value;
terminateLifetimeOutputTerminal.GetFacadeVariable().MergeInto(interruptedVariable);
_lifetimeVariableAssociation.MarkVariableLive(interruptedVariable, terminateLifetimeOutputTerminal);
}
}
}
public void FunctionNodeWithGenericOutParameterWithDownstreamTypeDeterminant_SetVariableTypes_TypeSetOnOutput()
{
DfirRoot function = DfirRoot.Create();
var genericOutput = new FunctionalNode(function.BlockDiagram, DefineGenericOutputFunctionSignature());
var assignNode = new FunctionalNode(function.BlockDiagram, Signatures.AssignType);
genericOutput.OutputTerminals[0].WireTogether(assignNode.InputTerminals[0], SourceModelIdSource.NoSourceModelId);
ConnectConstantToInputTerminal(assignNode.InputTerminals[1], NITypes.Int32, false);
RunSemanticAnalysisUpToSetVariableTypes(function);
Assert.IsTrue(genericOutput.OutputTerminals[0].GetTrueVariable().Type.IsInt32());
}
public void FunctionNodeWithReferenceWiredToInReferenceParameter_SetVariableTypes_InputTerminalTrueAndFacadeVariablesMerged()
{
NIType signatureType = Signatures.ImmutablePassthroughType;
DfirRoot dfirRoot = DfirRoot.Create();
FunctionalNode functionalNode = new FunctionalNode(dfirRoot.BlockDiagram, signatureType);
ExplicitBorrowNode borrow = ConnectExplicitBorrowToInputTerminals(functionalNode.InputTerminals[0]);
ConnectConstantToInputTerminal(borrow.InputTerminals[0], NITypes.Int32, false);
RunSemanticAnalysisUpToSetVariableTypes(dfirRoot);
AssertTerminalTrueAndFacadeVariablesReferenceSame(functionalNode.InputTerminals[0]);
}
public void FunctionNodeWithSelectReferenceSignature_CreateNodeFacades_CreatesFacades()
{
NIType signatureType = Signatures.SelectReferenceType;
DfirRoot dfirRoot = DfirRoot.Create();
FunctionalNode functionalNode = new FunctionalNode(dfirRoot.BlockDiagram, signatureType);
RunSemanticAnalysisUpToCreateNodeFacades(dfirRoot);
AutoBorrowNodeFacade nodeFacade = AutoBorrowNodeFacade.GetNodeFacade(functionalNode);
Terminal inputTerminal = functionalNode.InputTerminals[1];
Assert.IsNotInstanceOfType(nodeFacade[inputTerminal], typeof(SimpleTerminalFacade));
}
public void StringSliceConstantToOutput_Execute_CorrectStringOutput()
{
DfirRoot function = DfirRoot.Create();
FunctionalNode output = new FunctionalNode(function.BlockDiagram, Signatures.OutputType);
FunctionalNode stringFromSlice = new FunctionalNode(function.BlockDiagram, Signatures.StringFromSliceType);
Wire.Create(function.BlockDiagram, stringFromSlice.OutputTerminals[1], output.InputTerminals[0]);
Constant stringConstant = ConnectStringConstantToInputTerminal(stringFromSlice.InputTerminals[0], "test");
TestExecutionInstance executionInstance = CompileAndExecuteFunction(function);
Assert.AreEqual("test", executionInstance.RuntimeServices.LastOutputValue);
}
public void BorrowTunnelWithUnwiredOutput_AutomaticNodeInsertion_NoTerminateLifetimeInserted()
{
DfirRoot function = DfirRoot.Create();
Frame frame = Frame.Create(function.BlockDiagram);
BorrowTunnel borrowTunnel = CreateBorrowTunnel(frame, BorrowMode.Immutable);
FunctionalNode outputStringOwner = new FunctionalNode(function.BlockDiagram, _outputOwnerStringSignature);
Wire.Create(function.BlockDiagram, outputStringOwner.OutputTerminals[0], borrowTunnel.InputTerminals[0]);
RunCompilationUpToAutomaticNodeInsertion(function);
Assert.IsFalse(frame.Diagram.Nodes.OfType <TerminateLifetimeNode>().Any());
}
public void VariantConstructorWithValidFields_SetVariableTypes_CorrectFieldVariableTypes()
{
DfirRoot function = DfirRoot.Create();
var variantConstructorNode = new VariantConstructorNode(function.BlockDiagram, VariantType, 0);
ConnectConstantToInputTerminal(variantConstructorNode.InputTerminals[0], NITypes.Int32, false);
RunSemanticAnalysisUpToSetVariableTypes(function);
VariableReference variantVariable = variantConstructorNode.VariantOutputTerminal.GetTrueVariable();
Assert.AreEqual(VariantType, variantVariable.Type);
}
public void LoopConditionTunnelWithBooleanReferenceInput_ValidateVariableUsage_TypeConflictErrorReported()
{
DfirRoot function = DfirRoot.Create();
Loop loop = new Loop(function.BlockDiagram);
LoopConditionTunnel loopConditionTunnel = CreateLoopConditionTunnel(loop);
ExplicitBorrowNode borrow = ConnectExplicitBorrowToInputTerminals(loopConditionTunnel.InputTerminals[0]);
ConnectConstantToInputTerminal(borrow.InputTerminals[0], PFTypes.Boolean, false);
RunSemanticAnalysisUpToValidation(function);
AssertTerminalHasTypeConflictMessage(loopConditionTunnel.InputTerminals[0]);
}
public void FrameOutputTunnelWithInnerDiagramReferenceTypeWiredIn_ValidateVariableUsages_ErrorReported()
{
DfirRoot dfirRoot = DfirRoot.Create();
Frame frame = Frame.Create(dfirRoot.BlockDiagram);
Tunnel tunnel = CreateOutputTunnel(frame);
ExplicitBorrowNode borrow = ConnectExplicitBorrowToInputTerminals(tunnel.InputTerminals[0]);
ConnectConstantToInputTerminal(borrow.InputTerminals[0], PFTypes.Int32, false);
RunSemanticAnalysisUpToValidation(dfirRoot);
Assert.IsTrue(tunnel.InputTerminals[0].GetDfirMessages().Any(message => message.Descriptor == Messages.WiredReferenceDoesNotLiveLongEnough.Descriptor));
}
public void CreateYieldPromiseAndAwait_Execute_ExecutionFinishesAndYieldedValueReadFromInspect()
{
DfirRoot function = DfirRoot.Create();
var yieldNode = new FunctionalNode(function.BlockDiagram, Signatures.YieldType);
ConnectConstantToInputTerminal(yieldNode.InputTerminals[0], NITypes.Int32, 5, false);
FunctionalNode inspect = ConnectInspectToOutputTerminal(yieldNode.OutputTerminals[0]);
TestExecutionInstance executionInstance = CompileAndExecuteFunction(function);
byte[] inspectValue = executionInstance.GetLastValueFromInspectNode(inspect);
AssertByteArrayIsInt32(inspectValue, 5);
}
public void FunctionNodeWithMutableInOutSignatureParameterAndImmutableReferenceWired_ValidateVariableUsages_ErrorCreated()
{
NIType signatureType = Signatures.MutablePassthroughType;
DfirRoot dfirRoot = DfirRoot.Create();
FunctionalNode functionalNode = new FunctionalNode(dfirRoot.BlockDiagram, signatureType);
ExplicitBorrowNode borrow = ConnectExplicitBorrowToInputTerminals(functionalNode.InputTerminals[0]);
ConnectConstantToInputTerminal(borrow.InputTerminals[0], PFTypes.Int32, false);
RunSemanticAnalysisUpToValidation(dfirRoot);
Assert.IsTrue(functionalNode.InputTerminals[0].GetDfirMessages().Any(message => message.Descriptor == Messages.TerminalDoesNotAcceptImmutableType.Descriptor));
}
public void TypeDiagram_InferTypes_DefinedTypeNameMatchesDfirRootName()
{
DfirRoot typeDiagram = DfirRoot.Create(CreateTestCompilableDefinitionName("type"));
var selfTypeNode = new SelfTypeNode(typeDiagram.BlockDiagram, SelfTypeMode.Struct, 1);
ConnectPrimitiveTypeToInputTerminal(selfTypeNode.InputTerminals[0], NITypes.Int32);
RunSemanticAnalysisUpToTypeInference(typeDiagram);
NIType selfType = typeDiagram.GetSelfType();
Assert.AreEqual("type", selfType.GetName());
}
public void NonPanickingUnwrapOptionIntoInspect_Execute_CorrectValue()
{
DfirRoot function = DfirRoot.Create();
var unwrapOption = new FunctionalNode(function.BlockDiagram, Signatures.UnwrapOptionType);
ConnectSomeOfIntegerToInputTerminal(unwrapOption.InputTerminals[0], 5, false);
FunctionalNode inspect = ConnectInspectToOutputTerminal(unwrapOption.OutputTerminals[0]);
TestExecutionInstance executionInstance = CompileAndExecuteFunction(function);
byte[] inspectValue = executionInstance.GetLastValueFromInspectNode(inspect);
AssertByteArrayIsInt32(inspectValue, 5);
}
public void FunctionNodeWithGenericImmutableInOutSignatureParameterAndImmutableReferenceVariableWired_ValidateVariableUsages_NoErrorCreated()
{
NIType signatureType = Signatures.ImmutablePassthroughType;
DfirRoot dfirRoot = DfirRoot.Create();
FunctionalNode functionalNode = new FunctionalNode(dfirRoot.BlockDiagram, signatureType);
ExplicitBorrowNode borrow = ConnectExplicitBorrowToInputTerminals(functionalNode.InputTerminals[0]);
ConnectConstantToInputTerminal(borrow.InputTerminals[0], NITypes.Int32, false);
RunSemanticAnalysisUpToValidation(dfirRoot);
Assert.IsFalse(functionalNode.InputTerminals[0].GetDfirMessages().Any());
}
public void OptionPatternStructureSelectorWiredToInspectOnSomeValueDiagram_Execute_CorrectValue()
{
DfirRoot function = DfirRoot.Create();
OptionPatternStructure patternStructure = CreateOptionPatternStructureWithOptionValueWiredToSelector(function.BlockDiagram, 1);
FunctionalNode someInspectNode = new FunctionalNode(patternStructure.Diagrams[0], Signatures.InspectType);
Wire.Create(patternStructure.Diagrams[0], patternStructure.Selector.OutputTerminals[0], someInspectNode.InputTerminals[0]);
TestExecutionInstance executionInstance = CompileAndExecuteFunction(function);
byte[] inspectValue = executionInstance.GetLastValueFromInspectNode(someInspectNode);
AssertByteArrayIsInt32(inspectValue, 1);
}
public void PanickingUnwrapOptionInsideLoopDiagram_Execute_LoopTerminatesAndDownstreamOfLoopDoesNotExecute()
{
DfirRoot function = DfirRoot.Create();
Loop loop = new Loop(function.BlockDiagram);
LoopConditionTunnel condition = CreateLoopConditionTunnel(loop);
FunctionalNode unwrap = CreatePanickingUnwrapOption(loop.Diagram);
ConnectOutputToOutputTerminal(condition.TerminateLifetimeTunnel.OutputTerminals[0]);
TestExecutionInstance executionInstance = CompileAndExecuteFunction(function);
AssertNoOutput(executionInstance);
}
private DfirRoot CreateOptionPatternStructureWithOutputTunnelAndInspect(bool selectorValueIsSome, int someDiagramTunnelValue, int noneDiagramTunnelValue)
{
DfirRoot function = DfirRoot.Create();
OptionPatternStructure patternStructure = CreateOptionPatternStructureWithOptionValueWiredToSelector(
function.BlockDiagram,
selectorValueIsSome ? (int?)0 : null);
Tunnel outputTunnel = CreateOutputTunnel(patternStructure);
ConnectConstantToInputTerminal(outputTunnel.InputTerminals[0], NITypes.Int32, someDiagramTunnelValue, false);
ConnectConstantToInputTerminal(outputTunnel.InputTerminals[1], NITypes.Int32, noneDiagramTunnelValue, false);
ConnectInspectToOutputTerminal(outputTunnel.OutputTerminals[0]);
return(function);
}
public void FunctionNodeWithNonReferenceInSignatureParameter_CreateNodeFacades_CreatesSimpleFacadeForTerminal()
{
NIType signatureType = Signatures.VectorInsertType;
DfirRoot dfirRoot = DfirRoot.Create();
FunctionalNode functionalNode = new FunctionalNode(dfirRoot.BlockDiagram, signatureType);
RunSemanticAnalysisUpToCreateNodeFacades(dfirRoot);
AutoBorrowNodeFacade nodeFacade = AutoBorrowNodeFacade.GetNodeFacade(functionalNode);
Terminal inputTerminal = functionalNode.InputTerminals[2];
Assert.IsInstanceOfType(nodeFacade[inputTerminal], typeof(SimpleTerminalFacade));
}
public void FunctionNodeWithSelectReferenceSignatureAndDifferentValueTypesWired_ValidateVariableUsages_TypeMismatchErrorCreated()
{
NIType signatureType = Signatures.SelectReferenceType;
DfirRoot dfirRoot = DfirRoot.Create();
FunctionalNode functionalNode = new FunctionalNode(dfirRoot.BlockDiagram, signatureType);
ConnectConstantToInputTerminal(functionalNode.InputTerminals[1], NITypes.Boolean, false);
ConnectConstantToInputTerminal(functionalNode.InputTerminals[2], NITypes.Int32, false);
RunSemanticAnalysisUpToValidation(dfirRoot);
AssertTerminalHasTypeConflictMessage(functionalNode.InputTerminals[2]);
}
public void FunctionNodeWithNonGenericSignatureParameterAndIncorrectTypeWired_ValidateVariableUsages_ErrorCreated()
{
DfirRoot dfirRoot = DfirRoot.Create();
NIFunctionBuilder signatureTypeBuilder = NITypes.Factory.DefineFunction("NonGenericInput");
NIType signatureType = signatureTypeBuilder.AddInput(NITypes.Int32, "input").CreateType();
FunctionalNode functionalNode = new FunctionalNode(dfirRoot.BlockDiagram, signatureType);
ConnectConstantToInputTerminal(functionalNode.InputTerminals[0], NITypes.Boolean, false);
RunSemanticAnalysisUpToValidation(dfirRoot);
AssertTerminalHasTypeConflictMessage(functionalNode.InputTerminals[0]);
}
public void FunctionNodeWithNonReferenceInSignatureParameterAndReferenceVariableWired_ValidateVariableUsages_ErrorCreated()
{
NIType signatureType = Signatures.RangeType;
DfirRoot dfirRoot = DfirRoot.Create();
FunctionalNode functionalNode = new FunctionalNode(dfirRoot.BlockDiagram, signatureType);
ExplicitBorrowNode borrow = ConnectExplicitBorrowToInputTerminals(functionalNode.InputTerminals[0]);
ConnectConstantToInputTerminal(borrow.InputTerminals[0], NITypes.Int32, false);
RunSemanticAnalysisUpToValidation(dfirRoot);
AssertTerminalHasTypeConflictMessage(functionalNode.InputTerminals[0]);
}
public void IterateTunnelWithRangeIteratorTypeWired_SetVariableTypes_OutputIsInt32()
{
DfirRoot function = DfirRoot.Create();
Loop loop = new Loop(function.BlockDiagram);
var iterateTunnel = CreateIterateTunnel(loop);
ConnectRangeWithIntegerInputsToInputTerminal(iterateTunnel.InputTerminals[0]);
RunSemanticAnalysisUpToSetVariableTypes(function);
VariableReference iterateOutputVariable = iterateTunnel.OutputTerminals[0].GetTrueVariable();
Assert.IsTrue(iterateOutputVariable.Type.IsInt32());
}
public void PanickingUnwrapOptionIntoFrame_Execute_FrameDoesNotExecute()
{
DfirRoot function = DfirRoot.Create();
FunctionalNode unwrap = CreatePanickingUnwrapOption(function.BlockDiagram);
Frame frame = Frame.Create(function.BlockDiagram);
Tunnel inputTunnel = CreateInputTunnel(frame);
Wire.Create(function.BlockDiagram, unwrap.OutputTerminals[0], inputTunnel.InputTerminals[0]);
ConnectOutputToOutputTerminal(inputTunnel.OutputTerminals[0]);
TestExecutionInstance executionInstance = CompileAndExecuteFunction(function);
AssertNoOutput(executionInstance);
}
public void CompileAndExecuteFunction(CompilerTestBase test, DfirRoot function)
{
#if LLVM_TEST
const string compiledFunctionName = "test";
LLVMSharp.Module compiledFunction = test.RunSemanticAnalysisUpToLLVMCodeGeneration(function, compiledFunctionName);
_context.LoadFunction(compiledFunction);
_context.ExecuteFunctionTopLevel(compiledFunctionName);
#else
Function compiledFunction = test.RunSemanticAnalysisUpToCodeGeneration(function);
_context.LoadFunction(compiledFunction);
_context.FinalizeLoad();
_context.ExecuteFunctionTopLevel(compiledFunction.Name);
#endif
}
public void SelectReferenceWithFalseSelector_Execute_CorrectSelectedResult()
{
DfirRoot function = DfirRoot.Create();
FunctionalNode selectReference = new FunctionalNode(function.BlockDiagram, Signatures.SelectReferenceType);
Constant selectorConstant = ConnectConstantToInputTerminal(selectReference.InputTerminals[0], NITypes.Boolean, false, false);
Constant trueValueConstant = ConnectConstantToInputTerminal(selectReference.InputTerminals[1], NITypes.Int32, 1, false);
Constant falseValueConstant = ConnectConstantToInputTerminal(selectReference.InputTerminals[2], NITypes.Int32, 0, false);
FunctionalNode inspect = ConnectInspectToOutputTerminal(selectReference.OutputTerminals[1]);
TestExecutionInstance executionInstance = CompileAndExecuteFunction(function);
byte[] inspectValue = executionInstance.GetLastValueFromInspectNode(inspect);
AssertByteArrayIsInt32(inspectValue, 0);
}
public OptionPatternStructureWithInspectOnEachDiagramTest(OptionPatternStructureExecutionTests test, bool selectorValueIsSome)
{
_test = test;
_function = DfirRoot.Create();
OptionPatternStructure patternStructure = _test.CreateOptionPatternStructureWithOptionValueWiredToSelector(
_function.BlockDiagram,
selectorValueIsSome ? (int?)0 : null);
_someInspectNode = new FunctionalNode(patternStructure.Diagrams[0], Signatures.InspectType);
_test.ConnectConstantToInputTerminal(_someInspectNode.InputTerminals[0], NITypes.Int32, 1, false);
_noneInspectNode = new FunctionalNode(patternStructure.Diagrams[1], Signatures.InspectType);
_test.ConnectConstantToInputTerminal(_noneInspectNode.InputTerminals[0], NITypes.Int32, 1, false);
}
public void FunctionNodeWithSelectReferenceSignatureAndNoInputsWired_SetVariableTypes_VoidReferenceSetOnOutput()
{
NIType signatureType = Signatures.SelectReferenceType;
DfirRoot dfirRoot = DfirRoot.Create();
FunctionalNode functionalNode = new FunctionalNode(dfirRoot.BlockDiagram, signatureType);
RunSemanticAnalysisUpToSetVariableTypes(dfirRoot);
Terminal outputTerminal = functionalNode.OutputTerminals[1];
NIType outputTerminalType = outputTerminal.GetTrueVariable().Type;
Assert.IsTrue(outputTerminalType.IsImmutableReferenceType());
Assert.IsTrue(outputTerminalType.GetReferentType().IsVoid());
}
