public void TestFunctionRefs(IGraphModel graph, IFunctionModel functionModel, bool result)
{
var filter = new SearcherFilter(SearcherContext.Graph).WithFunctionReferences();
var data = new FunctionRefSearcherItemData(graph, functionModel);
Assert.AreEqual(result, filter.ApplyFilters(data));
}
public GraphElementSearcherDatabase AddFunctionMembers(IFunctionModel functionModel)
{
if (functionModel == null)
{
return(this);
}
SearcherItem parent = null;
IEnumerable <IVariableDeclarationModel> members = functionModel.FunctionParameterModels.Union(
functionModel.FunctionVariableModels);
foreach (IVariableDeclarationModel declarationModel in members)
{
if (parent == null)
{
parent = SearcherItemUtility.GetItemFromPath(Items, k_FunctionMembers);
}
parent.AddChild(new GraphNodeModelSearcherItem(
new TypeSearcherItemData(declarationModel.DataType, SearcherItemTarget.Variable),
data => data.CreateVariableNode(declarationModel),
declarationModel.Name.Nicify()
));
}
return(this);
}
public static List <ParameterSyntax> BuildArguments(Stencil stencil, IFunctionModel stack)
{
var argumentNodes = new List <ParameterSyntax>();
foreach (var paramDecl in stack.FunctionParameterModels)
{
switch (paramDecl.VariableType)
{
case VariableType.FunctionParameter:
argumentNodes.Add(SyntaxFactory.Parameter(
SyntaxFactory.Identifier(paramDecl.Name))
.WithType(
TypeSystem.BuildTypeSyntax(paramDecl.DataType.Resolve(stencil))));
break;
}
}
return(argumentNodes);
}
protected override void VisitStack(IStackModel stack, HashSet <IStackModel> visitedStacks, HashSet <INodeModel> visitedNodes)
{
base.VisitStack(stack, visitedStacks, visitedNodes);
IFunctionModel owner = null;
foreach (var stackInputPortModel in stack.InputPorts)
{
if (!stackInputPortModel.Connected)
{
continue;
}
foreach (var connectionPortModel in stackInputPortModel.ConnectionPortModels)
{
if (connectionPortModel.NodeModel is StackBaseModel stackModel)
{
owner = stackModel.OwningFunctionModel;
}
else
{
owner = connectionPortModel.NodeModel.ParentStackModel?.OwningFunctionModel;
}
if (owner != null)
{
break;
}
}
if (owner != null)
{
break;
}
}
((StackBaseModel)stack).OwningFunctionModel = owner;
foreach (var callback in Callbacks)
{
callback(stack);
}
}
static void FetchVariableDeclarationModelsFromFunctionModel(IFunctionModel functionModel, ref HashSet <Tuple <IVariableDeclarationModel, bool> > declarationModelTuples)
{
if (functionModel.FunctionVariableModels != null)
{
foreach (var declarationModel in functionModel.FunctionVariableModels)
{
declarationModelTuples.Add(new Tuple <IVariableDeclarationModel, bool>(declarationModel, true));
}
}
IEnumerable <IVariableDeclarationModel> allFunctionParameterModels = functionModel.FunctionParameterModels;
if (allFunctionParameterModels == null)
{
return;
}
foreach (var declarationModel in allFunctionParameterModels)
{
declarationModelTuples.Add(new Tuple <IVariableDeclarationModel, bool>(declarationModel,
functionModel.AllowChangesToModel));
}
}
public static List <StatementSyntax> BuildLocalDeclarations(RoslynTranslator roslynTranslator, IFunctionModel stack)
{
var localDeclarationNodes = new List <StatementSyntax>();
if (stack.VariableDeclarations == null)
{
return(localDeclarationNodes);
}
localDeclarationNodes.AddRange(stack.VariableDeclarations
.Where(localDecl => localDecl.VariableType == VariableType.FunctionVariable)
.Select(localDecl => localDecl.DeclareLocalVariable(roslynTranslator)));
return(localDeclarationNodes);
}
public static IEnumerable <SyntaxNode> BuildMethod(this RoslynTranslator roslynTranslator, IFunctionModel stack, IPortModel portModel)
{
roslynTranslator.ClearBuiltStacks();
var generatedName = roslynTranslator.MakeUniqueName(stack.CodeTitle);
var methodSyntaxNode = RoslynBuilder.DeclareMethod(
generatedName, AccessibilityFlags.Public, stack.ReturnType.Resolve(roslynTranslator.Stencil));
var localDeclarationNodes = BuildLocalDeclarations(roslynTranslator, stack);
var argumentNodes = BuildArguments(roslynTranslator.Stencil, stack);
methodSyntaxNode = methodSyntaxNode.WithParameterList(SyntaxFactory.ParameterList(
SyntaxFactory.SeparatedList(argumentNodes.ToArray())));
methodSyntaxNode = methodSyntaxNode.WithBody(SyntaxFactory.Block(localDeclarationNodes.ToArray()));
if (stack.EnableProfiling)
{
throw new NotImplementedException("BuildMethod Profiling not implemented");
// methodSyntaxNode = methodSyntaxNode.WithAdditionalAnnotations(InstrumentForProfiling.profilingAnnotation);
}
BlockSyntax stackBlock = SyntaxFactory.Block();
roslynTranslator.BuildStack(stack, ref stackBlock);
foreach (var statement in stackBlock.Statements)
{
methodSyntaxNode = methodSyntaxNode.AddBodyStatements(statement);
}
yield return(methodSyntaxNode);
}
public UpdateFunctionReturnTypeAction(IFunctionModel functionModel, TypeHandle newType)
{
FunctionModel = functionModel;
NewType = newType;
}
public virtual List <SearcherDatabase> GetGraphVariablesSearcherDatabases(IGraphModel graphModel, IFunctionModel functionModel = null)
{
return(new List <SearcherDatabase>
{
new GraphElementSearcherDatabase(m_Stencil)
.AddFunctionMembers(functionModel)
.AddGraphVariables(graphModel)
.Build()
});
}
protected IVariableDeclarationModel GetFunctionVariable(IFunctionModel method, string localName)
{
return(method.FunctionVariableModels.Single(f => f.Title == localName));
}
public FunctionRefSearcherItemData(IGraphModel graphModel, IFunctionModel functionModel)
{
FunctionModel = functionModel;
GraphModel = graphModel;
}
public CreateFunctionVariableDeclarationAction(IFunctionModel functionModel, string name, TypeHandle type)
{
FunctionModel = functionModel;
Name = name;
Type = type;
}
public DuplicateFunctionVariableDeclarationsAction(IFunctionModel functionModel, List <IVariableDeclarationModel> variableDeclarationModels)
{
FunctionModel = functionModel;
VariableDeclarationModels = variableDeclarationModels;
}
public List <SearcherDatabase> GetGraphVariablesSearcherDatabases(IGraphModel graphModel,
IFunctionModel functionModel = null)
{
return(new List <SearcherDatabase>());
}
