public XmlElement Visit(IdentifierParseNode i) { var el = makeNode(i, "identifier"); addProperty(el, "name", i.Name); return(el); }
/// <inheritdoc /> public Node Visit(IdentifierParseNode i) { var ret = new ImplicitReceiverRequestNode(i.Token, i); var rpn = new RequestPartNode(i.Name, new List <Node>(), new List <Node>()); ret.AddPart(rpn); return(ret); }
/// <inheritdoc/> public override ParseNode Visit(IdentifierParseNode ipn) { // A bare identifier that matches an element of the // set of disallowed names will always raise an error, // but the other cases below avoid visiting such a // node if it is in a valid place. if (_names.Contains(ipn.Name)) { ErrorReporting.ReportStaticError(ipn.Token.Module, ipn.Line, "P1043", new Dictionary <string, string> { { "name", ipn.Name } }, "Invalid use of parent name"); } return(ipn); }
private GraceBlock(EvaluationContext ctx, List <Node> parameters, List <Node> body, BlockNode node) { this.parameters = parameters; this.body = body; this.node = node; lexicalScope = ctx.Memorise(); applyName = MethodHelper.ArityNamePart("apply", parameters.Count); AddMethod(applyName, null); AddMethod("spawn", null); AddMethod("asString", null); if (parameters.Count == 1) { AddMethod("match(_)", null); AddMethod("|(_)", Matching.OrMethod); AddMethod("&(_)", Matching.AndMethod); var par = parameters[0]; var first = par as ParameterNode; if (first != null && first.Type != null) { Pattern = first.Type.Evaluate(ctx); } else if (par is NumberLiteralNode || par is StringLiteralNode || par is ExplicitReceiverRequestNode) { Pattern = par.Evaluate(ctx); explicitPattern = true; var t = par.Location; var id = new IdentifierParseNode( new IdentifierToken(t.module, t.line, t.column, "_")); this.parameters = new List <Node> { new ParameterNode(t, id) }; } } }
/// <inheritdoc /> public Node Visit(BlockParseNode d) { var parameters = new List <Node>(); Node forcedPattern = null; foreach (ParseNode p in d.Parameters) { var id = p as IdentifierParseNode; var tppn = p as TypedParameterParseNode; var vappn = p as VarArgsParameterParseNode; if (id != null) { parameters.Add(new ParameterNode(id.Token, id)); } else if (tppn != null) { parameters.Add( new ParameterNode(tppn.Token, tppn.Name as IdentifierParseNode, tppn.Type.Visit(this))); } else if (vappn != null) { // Inside could be either an identifier or a // TypedParameterParseNode - check for both. var inIPN = vappn.Name as IdentifierParseNode; var inTPPN = vappn.Name as TypedParameterParseNode; if (inIPN != null) { parameters.Add(new ParameterNode(inIPN.Token, inIPN, true // Variadic )); } else if (inTPPN != null) { parameters.Add(new ParameterNode(inTPPN.Token, inTPPN.Name as IdentifierParseNode, true, // Variadic inTPPN.Type.Visit(this) )); } } else if (p is NumberParseNode || p is StringLiteralParseNode || p is OperatorParseNode) { parameters.Add(p.Visit(this)); } else if (p is ParenthesisedParseNode) { var tok = p.Token; var it = new IdentifierToken(tok.module, tok.line, tok.column, "_"); id = new IdentifierParseNode(it); parameters.Add(new ParameterNode(tok, id, p.Visit(this))); } else { throw new Exception("unimplemented - unusual parameters"); } } var ret = new BlockNode(d.Token, d, parameters, map(d.Body), forcedPattern); return(ret); }
public void VisitIdentifier(IdentifierParseNode node) { Print($"Identifier (Parse Tree Node) (Name={node.Name})"); }
/// <inheritdoc/> public virtual ParseNode Visit(IdentifierParseNode i) { return(i); }
public void VisitIdentifier(IdentifierParseNode node) { }
public void VisitIdentifier(IdentifierParseNode node) { VisitPreOrder(node); VisitPostOrder(node); }
public void VisitIdentifier(IdentifierParseNode node) { IdentifierVisitor?.Visit(node); }