public object VisitCallExpression(Expression.Call expression) { object callee = Evaluate(expression.callee); List <object> arguments = new List <object>(); foreach (Expression argument in expression.arguments) { arguments.Add(Evaluate(argument)); } if (!(callee is Callable)) { throw new RuntimeError(expression.parenthesis, "Can only call functions and classes."); } Callable function = (Callable)callee; if (arguments.Count != function.Arity()) { throw new RuntimeError(expression.parenthesis, $"Expected {function.Arity()} arguments but got {arguments.Count}."); } return(function.Call(this, arguments)); }
protected override Node?Visit(Expression.Call call) { if (dependencyMap.CallDesugar.TryGetValue(call, out var alt)) { return(Transform(alt)); } return(base.Visit(call)); }
public object VisitCallExpression(Expression.Call expression) { Resolve(expression.callee); foreach (Expression argument in expression.arguments) { Resolve(argument); } return(null); }
public object VisitCallExpr(Expression.Call expr) { Resolve(expr.callee); foreach (Expression arg in expr.arguments) { Resolve(arg); } return(new Stmt.DefaultStatement()); }
protected override object?Visit(Expression.Call call) { base.Visit(call); var calledType = System.TypeOf(call.Procedure); if (calledType is Type.Proc procType) { var dependency = procType.GetDependency(); if (dependency != null) { /* * Desugar * f(dependee args..., independent args..., dependent args...) * Into * f(dependee args...).f(independent args..., dependent args...) */ Expression callProcedure; if (procType.IsIntrinsic) { var intrinsic = (Intrinsic)((Value.User)System.Evaluate(call.Procedure)).Payload; callProcedure = new Expression.Identifier(null, intrinsic.NonDependentDesugar()); } else { callProcedure = call.Procedure; } var result = new Expression.Call( null, new Expression.DotPath( null, new Expression.Call( null, callProcedure, dependency.DependeeIndices .Select(i => call.Arguments[i]) .ToArray()), "f"), dependency.DependentIndices .Concat(dependency.IndependentIndices) .Select(i => call.Arguments[i]) .ToArray()); DependencyMap.CallDesugar.Add(call, result); } } return(null); }
protected override object?Visit(Expression.Call call) { base.Visit(call); // Check if the called thing is even a procedure var calledType = System.TypeOf(call.Procedure); if (!(calledType is Type.Proc procType)) { // TODO throw new NotImplementedException("Can't call non-procedure!"); } // Check if arguments match parameters if (procType.Parameters.Count == call.Arguments.Count) { foreach (var(param, arg) in procType.Parameters.Zip(call.Arguments)) { var paramType = param.Type; var argType = System.TypeOf(arg); if (!paramType.Equals(argType)) { System.Report(new TypeMismatchError(paramType, argType) { Context = "procedure call", Defined = param.Symbol.Definition?.ParseTreeNode, Wrong = arg.ParseTreeNode, }); } } } else { // Argument count mismatch System.Report(new ArgCountMismatchError(procType.Parameters.Count, call.Arguments.Count) { // TODO: Add definition Wrong = call.ParseTreeNode, }); } return(null); }
public object VisitCallExpr(Expression.Call expr) { object callee = Evaluate(expr.callee); List <object> arguments = new(); foreach (Expression argument in expr.arguments) { arguments.Add(argument); } if (!(callee is IJukaCallable)) { throw new ArgumentException("not a class or function"); } IJukaCallable function = (IJukaCallable)callee; if (arguments.Count != function.Arity()) { throw new ArgumentException("Wrong number of arguments"); } return(function.Call(this, arguments)); }
public string VisitCallExpression(Expression.Call expression) { throw new NotImplementedException(); }
private Expression ParsePostfixExpression(ExprState state) { var result = ParseAtomicExpression(state); while (true) { var peek = Peek(); if (PostfixOperators.Contains(peek.Type)) { var op = Next(); result = new Expression.Postfix(result, op); } else if (peek.Type == TokenType.OpenParen) { var openParen = Expect(null, null, TokenType.OpenParen); // Call expression var args = new List <WithComma <Expression> >(); while (Peek().Type != TokenType.CloseParen) { var arg = ParseExpression(ExprState.None); var hasComma = Match(TokenType.Comma, out var comma); args.Add(new WithComma <Expression>(arg, comma)); if (!hasComma) { break; } } var closeParen = Expect("call expression", openParen, TokenType.CloseParen); result = new Expression.Call(result, openParen, args, closeParen); } else if (peek.Type == TokenType.OpenBracket) { var openBracket = Expect(null, null, TokenType.OpenBracket); // Subscript expression var index = ParseExpression(ExprState.None); var closeBracket = Expect("subscript expression", openBracket, TokenType.CloseBracket); result = new Expression.Subscript(result, openBracket, index, closeBracket); } else if (!state.HasFlag(ExprState.TypeOnly) && !state.HasFlag(ExprState.NoBraced) && peek.Type == TokenType.OpenBrace) { // Struct instantiation var openBrace = Expect(null, null, TokenType.OpenBrace); var fields = new List <Expression.StructValue.Field>(); while (Peek().Type != TokenType.CloseBrace) { fields.Add(ParseStructValueField()); } var closeBrace = Expect("struct instantiation", openBrace, TokenType.CloseBrace); result = new Expression.StructValue(result, openBrace, fields, closeBrace); } else if (peek.Type == TokenType.Dot) { // Dot path var dot = Expect(null, null, TokenType.Dot); var ident = Expect("dot path expression", null, TokenType.Identifier); result = new Expression.DotPath(result, dot, ident); } else { break; } } return(result); }