IBoundExpr IUnboundExprVisitor<IBoundExpr>.Visit(FuncRefExpr expr)
{
IBoundDecl paramType = null;
if (expr.ParamType != null)
{
paramType = TypeBinder.Bind(mContext, expr.ParamType);
}
var callable = mContext.Compiler.Functions.Find(mContext,
expr.Name.Name, expr.Name.TypeArgs, paramType);
var function = callable as Function;
//### bob: to support intrinsics, we'll need to basically create wrapper functions
// that have the same type signature as the intrinsic and that do nothing but
// call the intrinsic and return. then, we can get a reference to that wrapper.
//
// to support foreign functions, we can either do the same thing, or change the
// way function references work. if a function reference can be distinguished
// between being a regular function, a foreign one (or later a closure), then
// we can get rid of ForeignFuncCallExpr and just use CallExpr for foreign calls
// too.
if (function == null) throw new NotImplementedException("Can only get references to user-defined functions. Intrinsics, auto-generated, and foreign function references aren't supported yet.");
return new BoundFuncRefExpr(function);
}
IBoundExpr IUnboundExprVisitor<IBoundExpr>.Visit(LocalFuncExpr expr)
{
// create a unique name for the local function
string name = mContext.NameGenerator.Generate();
// create a reference to it
var reference = new FuncRefExpr(expr.Position,
new NameExpr(expr.Position, name),
expr.Type.Parameter.Unbound);
// lift the local function into a new top-level function
var function = new Function(expr.Position, name,
expr.Type, expr.ParamNames, expr.Body);
function.BindSearchSpace(mContext.SearchSpace);
// bind it
mContext.Compiler.Functions.AddAndBind(mContext.Compiler, function);
// return the reference to it
return reference.Accept(this);
//### bob: eventually, will need to handle closures
}
public virtual IUnboundExpr Transform(FuncRefExpr expr)
{
return(expr);
}
IUnboundExpr IUnboundExprVisitor <IUnboundExpr> .Visit(FuncRefExpr expr)
{
throw new NotImplementedException();
}
