public bool VisitDropNode(DropNode dropNode)
{
VariableUsageValidator validator = dropNode.Terminals[0].GetValidator();
validator.TestVariableIsOwnedType();
return(true);
}
bool IDfirNodeVisitor <bool> .VisitDropNode(DropNode dropNode)
{
Terminal valueInput = dropNode.InputTerminals.ElementAt(0);
TypeVariableReference dataTypeVariable = _typeVariableSet.CreateReferenceToNewTypeVariable();
_nodeFacade[valueInput] = new SimpleTerminalFacade(valueInput, dataTypeVariable);
return(true);
}
internal static void InsertDropForVariable(Diagram parentDiagram, LiveVariable liveUnboundedLifetimeVariable, ITypeUnificationResultFactory unificationResultFactory)
{
var drop = new DropNode(parentDiagram);
Terminal inputTerminal = drop.InputTerminals[0];
AutoBorrowNodeFacade nodeFacade = AutoBorrowNodeFacade.GetNodeFacade(drop);
nodeFacade[inputTerminal] = new SimpleTerminalFacade(
inputTerminal,
parentDiagram.GetTypeVariableSet().CreateReferenceToNewTypeVariable());
liveUnboundedLifetimeVariable.ConnectToTerminalAsInputAndUnifyVariables(inputTerminal, unificationResultFactory);
}
public void Execute(DfirRoot dfirRoot, CompileCancellationToken cancellationToken)
{
LiveVariable liveUnboundedLifetimeVariable;
while (_lifetimeVariableAssociation.TryGetLiveVariableWithUnboundedLifetime(out liveUnboundedLifetimeVariable))
{
Diagram parentDiagram = liveUnboundedLifetimeVariable.Terminal.ParentDiagram;
var drop = new DropNode(parentDiagram);
Terminal inputTerminal = drop.InputTerminals[0];
AutoBorrowNodeFacade nodeFacade = AutoBorrowNodeFacade.GetNodeFacade(drop);
nodeFacade[inputTerminal] = new SimpleTerminalFacade(inputTerminal, default(TypeVariableReference));
Wire.Create(parentDiagram, liveUnboundedLifetimeVariable.Terminal, inputTerminal);
inputTerminal.GetFacadeVariable().MergeInto(liveUnboundedLifetimeVariable.Variable);
_lifetimeVariableAssociation.MarkVariableConsumed(liveUnboundedLifetimeVariable.Variable);
}
}
public void UnconsumedStructVariable_AutomaticNodeInsertion_StructIsDecomposedAndElementsAreDropped()
{
DfirRoot function = DfirRoot.Create();
var constructorNode = new StructConstructorNode(function.BlockDiagram, StructType);
Constant constant = Constant.Create(function.BlockDiagram, string.Empty, DataTypes.StringSliceType.CreateImmutableReference());
var stringFromSlice = new FunctionalNode(function.BlockDiagram, Signatures.StringFromSliceType);
Wire.Create(function.BlockDiagram, constant.OutputTerminal, stringFromSlice.InputTerminals[0]);
Wire.Create(function.BlockDiagram, stringFromSlice.OutputTerminals[1], constructorNode.InputTerminals[0]);
RunCompilationUpToAutomaticNodeInsertion(function);
DecomposeStructNode decomposeStruct = AssertDiagramContainsNodeWithSources <DecomposeStructNode>(function.BlockDiagram, constructorNode.OutputTerminals[0]);
Assert.AreEqual(StructType, decomposeStruct.Type);
DropNode dropNode = AssertDiagramContainsNodeWithSources <DropNode>(function.BlockDiagram, decomposeStruct.OutputTerminals[0]);
AssertDropInputVariableHasType(dropNode, NITypes.String);
}
public void UnconsumedTupleVariable_AutomaticNodeInsertion_TupleIsMoveDecomposedAndElementsAreDropped()
{
DfirRoot function = DfirRoot.Create();
BuildTupleNode buildTuple = new BuildTupleNode(function.BlockDiagram, 2);
ConnectConstantToInputTerminal(buildTuple.InputTerminals[0], NITypes.Int32, false);
ConnectConstantToInputTerminal(buildTuple.InputTerminals[1], NITypes.Boolean, false);
RunCompilationUpToAutomaticNodeInsertion(function);
DecomposeTupleNode decomposeTuple = AssertDiagramContainsNodeWithSources <DecomposeTupleNode>(function.BlockDiagram, buildTuple.OutputTerminals[0]);
Assert.AreEqual(DecomposeMode.Move, decomposeTuple.DecomposeMode);
AssertVariablesReferenceSame(buildTuple.OutputTerminals[0].GetTrueVariable(), decomposeTuple.InputTerminals[0].GetTrueVariable());
Assert.AreEqual(2, decomposeTuple.OutputTerminals.Count);
DropNode drop0 = AssertDiagramContainsNodeWithSources <DropNode>(function.BlockDiagram, decomposeTuple.OutputTerminals[0]);
AssertDropInputVariableHasType(drop0, NITypes.Int32);
DropNode drop1 = AssertDiagramContainsNodeWithSources <DropNode>(function.BlockDiagram, decomposeTuple.OutputTerminals[1]);
AssertDropInputVariableHasType(drop1, NITypes.Boolean);
}
public bool VisitDropNode(DropNode dropNode)
{
VariableReference input = dropNode.InputTerminals[0].GetTrueVariable();
var inputAllocation = (LocalAllocationValueSource)_variableValues[input];
NIType inputType = input.Type;
if (inputType.TypeHasDropTrait())
{
CreateDropCall(inputType, inputAllocation.AllocationPointer);
return(true);
}
NIType innerType;
if (inputType.TryDestructureVectorType(out innerType))
{
// TODO
return(true);
}
if (inputType.TryDestructureOptionType(out innerType) && innerType.TypeHasDropTrait())
{
// TODO: turn this into a monomorphized generic function call
LLVMValueRef isSomePtr = _builder.CreateStructGEP(inputAllocation.AllocationPointer, 0u, "isSomePtr"),
isSome = _builder.CreateLoad(isSomePtr, "isSome");
LLVMBasicBlockRef optionDropIsSomeBlock = _topLevelFunction.AppendBasicBlock("optionDropIsSome"),
optionDropEndBlock = _topLevelFunction.AppendBasicBlock("optionDropEnd");
_builder.CreateCondBr(isSome, optionDropIsSomeBlock, optionDropEndBlock);
_builder.PositionBuilderAtEnd(optionDropIsSomeBlock);
LLVMValueRef innerValuePtr = _builder.CreateStructGEP(inputAllocation.AllocationPointer, 1u, "innerValuePtr");
CreateDropCall(innerType, innerValuePtr);
_builder.CreateBr(optionDropEndBlock);
_builder.PositionBuilderAtEnd(optionDropEndBlock);
return(true);
}
return(true);
}
bool IDfirNodeVisitor <bool> .VisitDropNode(DropNode dropNode)
{
MarkTrueVariableOfTerminalConsumed(dropNode.InputTerminals[0]);
return(true);
}
bool IDfirNodeVisitor <bool> .VisitDropNode(DropNode dropNode)
{
return(true);
}
private void AssertDropInputVariableHasType(DropNode dropNode, NIType type)
{
VariableReference dropInputVariable = dropNode.InputTerminals[0].GetTrueVariable();
Assert.AreEqual(type, dropInputVariable.Type);
}
public bool VisitDropNode(DropNode dropNode)
{
// TODO: call Drop function for input types that require it
return(true);
}
public bool VisitDropNode(DropNode dropNode)
{
return(true);
}
