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