public void Accept(TupleNode node)
{
foreach (var element in node.Elements)
{
element.Visit(this);
}
emit(node.SourceLocation, InstructionType.BuildTuple, node.Elements.Count);
}
internal bool TryParseTuple(ILookaroundEnumerator <Token> enumerator, [NotNullWhen(true)] out ASTNode?parsedNode, AssignmentOperatorBehavior assignmentOperatorBehavior)
{
if (TryParseCommaSeperatedSet(enumerator, TokenType.Operator, _OPERATOR_PAREN_OPEN, ParenClose, out var parsedListItems, minimumItems: 2, assignmentOperatorBehavior))
{
parsedNode = new TupleNode(parsedListItems);
return(true);
}
parsedNode = default;
return(false);
}
private void GetContent(CompilerContext context, ParseTreeNode parseNode)
{
var tupleNode = new TupleNode();
tupleNode.Init(context, parseNode);
if (tupleNode.TupleDefinition.Count() != 1)
{
throw new GraphDBException(new Error_InvalidTuple( "Only 1 element allowed but found " + tupleNode.TupleDefinition.Count().ToString()));
}
_TupleElement = tupleNode.TupleDefinition.First();
}
public override void VisitTupleNode(TupleNode node)
{
var tuple = TupleExpression();
foreach (var expr in node.Expressions)
{
expr.Visit(this);
tuple = tuple.AddArguments(Argument(expressions.Pop()));
}
tuple = GetNodeWithAnnotation(tuple, node.Location) as TupleExpressionSyntax;
expressions.Push(tuple);
}
public Expression Transform(TupleNode item)
{
var tupleItems = item.TupleItems.Select(item => item.Transform(this)).ToArray();
if (tupleItems.Length > 7)
{
throw new NotImplementedException();
}
var types = tupleItems.Select(item => item.Type).ToArray();
var genericType = GetTupleType(tupleItems.Length).MakeGenericType(types);
var constructor = genericType.GetConstructor(types);
return(Expression.New(constructor, tupleItems));
public static FunctionBody TupleBodyDefinition(RootNamespace root, TupleNode tuple)
{
var name = GetName(tuple);
var exists = root.Structs.FindFirstOrNull(x => x.Name == name);
if (exists is null)
{
_ = TupleDefinition(root, tuple.Values.Count);
}
var fbody = MakeFunction(root, $"{name}#{root.TupleUniqueCount++}");
var fret = new TypeSpecialization(new VariableValue(name));
var fcall = new TypeSpecialization(new VariableValue(name));
var self = new VariableValue("$self");
fbody.LexicalScope.Add(self.Name, self);
fbody.Body.Add(new Call(new FunctionCallValue(fcall))
{
Return = self
});
tuple.Values.Each((x, i) =>
{
var gp = new TypeGenericsParameter($"t{i + 1}");
var farg_var = new VariableValue($"x{i + 1}");
fbody.Generics.Add(gp);
fbody.Arguments.Add((farg_var, gp));
fbody.LexicalScope.Add(farg_var.Name, farg_var);
fbody.Body.Add(new Code {
Operator = Operator.Bind, Return = new PropertyValue(self, $"{i + 1}"), Left = NormalizationExpression(fbody, x, true)
});
fret.Generics.Add(gp);
fcall.Generics.Add(gp);
});
fbody.Body.Add(new Call(new FunctionCallValue(new VariableValue("return")).Return(x => x.Arguments.Add(self))));
fbody.Return = fret;
return(fbody);
}
private Expression Build(TupleNode node)
{
return(InnerBuild(node.Expression));
}
public object?Transform(TupleNode item)
{
var tupleItems = item.TupleItems.Select(listItem => listItem.Transform(this));
return(Common.ReflectionHelpers.MakeGenericTuple(tupleItems));
}
public IEnumerable <StatementNode> Visit(TupleNode node) => node.Values.SelectMany(Flatten) .Append((StatementExpressionNode)node);
public string Visit(TupleNode node)
=> ASTHelper.PrintToken(node.OpeningToken)
+ Utilities.Join(",", Print, node.Values)
+ ASTHelper.PrintToken(node.ClosingToken);
public IEnumerable <bool> Transform(TupleNode item)
{
throw new NotImplementedException();
}
public virtual void VisitTupleNode(TupleNode node)
{
}
public void VisitEnter(TupleNode node)
{
WriteLine(node, "Tuple");
tabs++;
}
private Expression Build(TupleNode node) => InnerBuild(node.Expression);
public void Init(ParsingContext context, ParseTreeNode parseNode)
{
#region get myAttributeName
_AttributeIDNode = ((IDNode)parseNode.ChildNodes[0].AstNode).IDChainDefinition;
#endregion
var _Node = parseNode.ChildNodes[2];
if (_Node.Token != null)
{
AttributeValue = new AttributeAssignOrUpdateValue(_AttributeIDNode, _Node.Token.Value);
}
else if (_Node.AstNode is BinaryExpressionNode)
{
#region binary expression
AttributeValue = new AttributeAssignOrUpdateExpression(_AttributeIDNode, (_Node.AstNode as BinaryExpressionNode).BinaryExpressionDefinition);
#endregion
}
else if (_Node.AstNode is TupleNode)
{
#region Tuple
TupleNode tempTupleNode = (TupleNode)_Node.AstNode;
if (tempTupleNode.TupleDefinition.Count() == 1)
{
if (tempTupleNode.TupleDefinition.First().Value is BinaryExpressionDefinition)
{
AttributeValue = new AttributeAssignOrUpdateExpression(_AttributeIDNode, tempTupleNode.TupleDefinition.First().Value as BinaryExpressionDefinition);
}
else
{
throw new InvalidTupleException("Could not extract BinaryExpressionNode from TupleNode.");
}
}
else
{
throw new InvalidTupleException("It is not possible to have more than one binary expression in one tuple. Please check brackets.");
}
#endregion
}
else if (_Node.AstNode is IDNode)
{
throw new InvalidVertexAttributeValueException(_AttributeIDNode.ToString(), (_Node.AstNode as IDNode).ToString());
}
else if (_Node.AstNode is SetRefNode)
{
#region setref
AttributeValue = new AttributeAssignOrUpdateSetRef(_AttributeIDNode, (_Node.AstNode as SetRefNode).SetRefDefinition);
#endregion
}
else if ((_Node.AstNode is CollectionOfDBObjectsNode))
{
#region collection like list
AttributeValue = new AttributeAssignOrUpdateList((_Node.AstNode as CollectionOfDBObjectsNode).CollectionDefinition, _AttributeIDNode, true);
#endregion
}
else
{
throw new NotImplementedQLException("");
}
}
public bool Visit(TupleNode node) => node.Values.All(IsContant);
public void VisitLeave(TupleNode node)
{
tabs--;
}
