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