/***** * builtin_handlers.cc * * Custom call-site handlers for open-signature builtins. Each such builtin * is registered (via addOpenBuiltinFunc in builtin.cc) with a pair of member * function pointers on callExp -- one for trans, one for getType -- that * override the usual dispatch when overload resolution picks the open * signature. This file centralizes those handlers along with the * symbol-keyed side table that maps a builtin's symbol to its handlers. *****/ #include "exp.h" #include "errormsg.h" #include "runtime.h" #include "runarray.h" #include "runmath.h" #include "arrayop.h" #include "coenv.h" #include "application.h" #include "inst.h" #include "opsymbols.h" #include "access.h" #include "callable.h" #include "stack.h" #include "record.h" #include "entry.h" namespace absyntax { using namespace types; using namespace trans; using vm::inst; namespace { bltin aliasCompareBuiltin(ty *target) { switch (target->kind) { case ty_array: return run::arrayAlias; case ty_function: return run::boolFuncEq; default: return run::boolMemEq; } } bltin aliasNullBuiltin(ty *target) { switch (target->kind) { case ty_array: return run::arrayAliasNull; case ty_function: return run::boolFuncEqNull; default: return run::boolMemEqNull; } } // If `target` is the function signature `bool(T, T)` with a single common // operand type T and no rest or open formals, return T; otherwise return // nullptr. Defaults on the formals are intentionally not rejected: like any // function value assigned to a defaulted signature, the resulting comparison // works when called with both arguments (defaults don't carry through a // function-typed variable in Asymptote). Shared by the record `==`/`!=` and // `alias` specialize hooks. types::ty *binaryBoolOperandType(ty *target) { function *ft = dynamic_cast(target); if (!ft) return nullptr; if (!equivalent(ft->getResult(), primBoolean())) return nullptr; signature *sig = ft->getSignature(); if (!sig || sig->isOpen || sig->hasRest()) return nullptr; if (sig->getNumFormals() != 2) return nullptr; types::ty *t0 = sig->getFormal(0).t; types::ty *t1 = sig->getFormal(1).t; if (!t0 || !t1 || !equivalent(t0, t1)) return nullptr; return t0; } // Tests whether `target` has the function signature `bool(R, R)` with R a // concrete record type. Returns the record type on success, nullptr otherwise. record *recordEqTarget(ty *target) { types::ty *t = binaryBoolOperandType(target); if (!t || t->kind != ty_record) return nullptr; return dynamic_cast(t); } } // namespace trans::access *specializeRecordEq(ty *target) { if (!recordEqTarget(target)) return nullptr; return new trans::callableAccess(new vm::bfunc(run::boolMemEq)); } trans::access *specializeRecordNeq(ty *target) { if (!recordEqTarget(target)) return nullptr; return new trans::callableAccess(new vm::bfunc(run::boolMemNeq)); } trans::access *specializeAlias(ty *target) { // `alias` may be coerced to `bool(T, T)` for any nullable (reference) type T // --- records, arrays, and function types --- with the runtime comparison // selected the same way as at a direct call site. types::ty *t = binaryBoolOperandType(target); if (!t || !t->isReference() || t->kind == ty_null) return nullptr; return new trans::callableAccess(new vm::bfunc(aliasCompareBuiltin(t))); } namespace { // Symbol-keyed side table of custom call-site handlers. See the comment on // registerCustomHandlers() in exp.h. struct symbolHash { size_t operator()(symbol s) const { return s.hash(); } }; struct symbolEq { bool operator()(symbol s, symbol t) const { return s == t; } }; using HandlerMap = mem::unordered_map; HandlerMap &customHandlersTable() { static HandlerMap table; return table; } // Find a unique record type that occurs in both `lt` and `rt` (each of which // may be a concrete type or an overloaded set). Returns null on no match or // ambiguous match. record *commonRecordType(ty *lt, ty *rt) { overloaded ltFlat, rtFlat, common; ltFlat.add(lt); rtFlat.add(rt); for (ty *lty : ltFlat.sub) { if (lty->kind != ty_record) continue; for (ty *rty : rtFlat.sub) { if (rty->kind != ty_record) continue; if (equivalent(lty, rty)) common.addDistinct(lty); } } ty *resolved = common.simplify(); if (!resolved || resolved->kind != ty_record) return nullptr; return dynamic_cast(resolved); } // Find the unique record type referenced by `t` (which may be overloaded). // Returns null if none, or more than one, record type is present. record *uniqueRecordType(ty *t) { overloaded flat; flat.add(t); record *found = nullptr; for (ty *sub : flat.sub) { if (sub->kind != ty_record) continue; record *r = dynamic_cast(sub); if (!r) continue; if (found && !equivalent(found, r)) return nullptr; found = r; } return found; } // Validate that the operand expressions of a `==`/`!=` call resolve to a // common record type, with null allowed on at most one side. Returns the // target record type on success, or null on failure (without emitting a // diagnostic, so the caller can decide whether and how to report the error). record *resolveRecordEqTarget(exp *left, exp *right, coenv &e) { types::ty *lt = left->getType(e); types::ty *rt = right->getType(e); if (lt->kind == ty_error || rt->kind == ty_error) return nullptr; if (lt->kind == ty_null && rt->kind == ty_null) return nullptr; if (lt->kind == ty_null) return uniqueRecordType(rt); if (rt->kind == ty_null) return uniqueRecordType(lt); record *common = commonRecordType(lt, rt); if (common) return common; // If one side is a record and the other is not, check whether the // non-record side can be implicitly cast to the record type (e.g. a // string operand compared to a struct that has `T operator cast(string)`). record *lr = uniqueRecordType(lt); if (lr && rt->kind != ty_record) { if (e.e.castable(lr, rt, symbol::castsym)) return lr; } record *rr = uniqueRecordType(rt); if (rr && lt->kind != ty_record) { if (e.e.castable(rr, lt, symbol::castsym)) return rr; } return nullptr; } } // namespace void registerCustomHandlers(symbol name, callExp::CustomHandlers h) { // Idempotent: base_venv() may run more than once over the lifetime of the // process (e.g. once for the per-process genv and once for runtime // initialization). Subsequent calls must register the same handlers. HandlerMap &table = customHandlersTable(); auto it = table.find(name); if (it != table.end()) { assert(it->second.trans == h.trans && it->second.getType == h.getType && it->second.specialize == h.specialize); return; } table[name] = h; } const callExp::CustomHandlers *lookupCustomHandlers(symbol name) { if (!name) return nullptr; HandlerMap &table = customHandlersTable(); auto it = table.find(name); return it == table.end() ? nullptr : &it->second; } types::ty *callExp::getAliasType(coenv &) { // Invoked from callExp::getType only after open-signature resolution has // already been confirmed by the dispatch wrapper, so we simply return the // alias result type. return primBoolean(); } types::ty *callExp::transAlias(coenv &e) { // Called only when the alias builtin (OPEN signature) has been resolved. // Apply strict same-type, nullable semantics. cachedApp = 0; cachedVarEntry = 0; if (args->rest.val || args->size() != 2) { em.error(getPos()); em << "alias takes exactly two parameters"; return primError(); } exp *left = (*args)[0].val; exp *right = (*args)[1].val; types::ty *lt = left->getType(e); types::ty *rt = right->getType(e); if (lt->kind == ty_error || rt->kind == ty_error) { reportArgErrors(e); return primError(); } if (lt->kind == ty_null && rt->kind == ty_null) { em.error(getPos()); em << "alias is not defined when both arguments are null literals"; return primError(); } ty *target; if (lt->kind == ty_null) { target = rt; if (target->isOverloaded()) { em.error(getPos()); em << "alias: argument type is ambiguous"; return primError(); } } else if (rt->kind == ty_null) { target = lt; if (target->isOverloaded()) { em.error(getPos()); em << "alias: argument type is ambiguous"; return primError(); } } else { // Both non-null: find the intersection of concrete types from lt and rt. // This handles overloaded variable names (same name, multiple types in // scope) --- e.g., alias(c, f) where c is overloaded{B, real(real)} and // f is real(real) resolves unambiguously to real(real). overloaded ltFlat, rtFlat, common; ltFlat.add(lt); // flattens overloaded; no-op for concrete types rtFlat.add(rt); for (ty *lty : ltFlat.sub) for (ty *rty : rtFlat.sub) if (equivalent(lty, rty)) common.addDistinct(lty); ty *resolved = common.simplify(); if (!resolved) { em.error(getPos()); em << "alias requires both arguments to have the same type"; return primError(); } if (resolved->kind == ty_overloaded) { em.error(getPos()); em << "alias: argument type is ambiguous"; return primError(); } target = resolved; } if (!target->isReference() || target->kind == ty_null) { em.error(getPos()); em << "alias requires arguments of a nullable type"; return primError(); } // Emit the comparison. Use transToType to handle overloaded variable // types (where the same name is in scope multiple times); the type // equivalence check above already guarantees no actual cast occurs. if (lt->kind == ty_null) { right->transToType(e, target); e.c.encode(inst::builtin, aliasNullBuiltin(target)); } else if (rt->kind == ty_null) { left->transToType(e, target); e.c.encode(inst::builtin, aliasNullBuiltin(target)); } else { left->transToType(e, target); right->transToType(e, target); e.c.encode(inst::builtin, aliasCompareBuiltin(target)); } return primBoolean(); } types::ty *callExp::getRecordEqType(coenv &e) { // Return primBoolean() only when the operands can actually be reduced to a // record comparison; otherwise return ty_error so that equalityExp::trans // can fall through to its function-equality special case (and so that any // other "no matching == for these types" diagnostic propagates correctly). if (args->rest.val || args->size() != 2) return primError(); return resolveRecordEqTarget((*args)[0].val, (*args)[1].val, e) ? primBoolean() : primError(); } types::ty *callExp::transRecordEq(coenv &e) { // Invoked when `==` or `!=` resolves to the open-signature builtin (i.e. // when no concrete equality is in scope for the operand types). Apply // record reference-equality semantics, allowing null on at most one side. cachedApp = 0; cachedVarEntry = 0; symbol op = callee->getName(); bool isEq = (op == SYM_EQ); assert(isEq || op == SYM_NEQ); if (args->rest.val || args->size() != 2) { em.error(getPos()); em << "'" << op << "' takes exactly two operands"; return primError(); } exp *left = (*args)[0].val; exp *right = (*args)[1].val; // Surface argument errors first. types::ty *lt = left->getType(e); types::ty *rt = right->getType(e); if (lt->kind == ty_error || rt->kind == ty_error) { reportArgErrors(e); return primError(); } record *target = resolveRecordEqTarget(left, right, e); if (!target) { em.error(getPos()); em << "no matching '" << op << "' for these operand types"; return primError(); } // Emit the comparison. left->transToType(e, target); right->transToType(e, target); e.c.encode(inst::builtin, isEq ? run::boolMemEq : run::boolMemNeq); return primBoolean(); } // --------------------------------------------------------------------------- // Heterogeneous write() handler // --------------------------------------------------------------------------- namespace { // Returns true if `t` is a type that the write_var runtime can format: // one of the writeable scalar kinds, an array (any depth) thereof, or a // record that has a publicly accessible write(file, void(file)) method. bool isWriteableData(ty *t, coder &c) { switch (t->kind) { case ty_boolean: case ty_Int: case ty_real: case ty_pair: case ty_triple: case ty_string: case ty_pen: case ty_guide: case ty_path: case ty_transform: return true; case ty_array: { array *a = dynamic_cast(t); return a && isWriteableData(a->celltype, c); } case ty_record: { record *recType = dynamic_cast(t); if (!recType) return false; // Check that the record actually has a write(file, void(file)) method, // and that the method is accessible from the current context. static types::function *suffixType = new types::function( types::primVoid(), types::formal(types::primFile())); static types::function *writeType = new types::function( types::primVoid(), types::formal(types::primFile()), types::formal(suffixType)); varEntry *ve = recType->e.lookupVarByType(symbol::trans("write"), writeType); return ve && ve->checkPerm(READ, c); } default: return false; } } // The result of analysing the arguments of a heterogeneous write() call. struct WritePlan { // The static type each argument is written as, indexed as in the call. mem::vector argTypes; // Argument indices in the order write_var expects the values: the file (if // any), the identifying string (if any), the data, the suffix (if any). mem::vector order; bool hasFile = false; bool hasSuffix = false; // True if an empty identifying string must be supplied so that write_var // does not mistake the first string of a rest argument for one. bool padLabel = false; // The type of the rest argument, or null if there is none. types::array *restType = nullptr; // Set if planning failed because an argument is itself erroneous. bool argError = false; }; void writeError(bool report, position pos) { if (report) em.error(pos); } // Returns the type that `val` is written as, or null if there is no such // type. An overloaded name is written as its non-function value (there is at // most one, as a variable hides any earlier variable of the same name). ty *writtenType(coenv &e, exp *val, WritePlan &plan, bool report) { ty *t = val->cgetType(e); if (t->kind == ty_error) { plan.argError = true; return nullptr; } if (t->kind != ty_overloaded) return t; ty *value = t->signatureless(); if (!value || value->kind == ty_error) { writeError(report, val->getPos()); if (report) em << "cannot write a function value"; return nullptr; } return value; } // Classifies the arguments of a write() call that resolved to the // open-signature fallback and checks that they can be written. The names // file, s and suffix select the corresponding slot. Of the unnamed // arguments, a leading file, then a leading string, and a trailing // void(file) fill whichever of those slots are still vacant; the rest are // data. Returns false, reporting the error if `report` is true, when the // call is invalid. bool planHeteroWrite(coenv &e, arglist *args, WritePlan &plan, bool report) { static symbol fileName = symbol::trans("file"); static symbol labelName = symbol::trans("s"); static symbol suffixName = symbol::trans("suffix"); const size_t NONE = (size_t) -1; size_t n = args->size(); size_t fileArg = NONE, labelArg = NONE, suffixArg = NONE; mem::vector positional; plan.argTypes.assign(n, nullptr); for (size_t i = 0; i < n; ++i) { exp *val = (*args)[i].val; symbol name = (*args)[i].name; ty *t = writtenType(e, val, plan, report); if (!t) return false; plan.argTypes[i] = t; if (!name) { positional.push_back(i); continue; } size_t *slot = nullptr; bool fits = false; if (name == fileName) { slot = &fileArg; fits = t->kind == ty_file; } else if (name == labelName) { slot = &labelArg; fits = t->kind == ty_string; } else if (name == suffixName) { slot = &suffixArg; fits = run::isWriteSuffixType(t); } if (!slot || *slot != NONE || !fits) { writeError(report, val->getPos()); if (!report) return false; if (!slot) em << "write has no parameter named '" << name << "'"; else if (*slot != NONE) em << "multiple arguments named '" << name << "'"; else em << "type '" << *t << "' cannot be used for parameter '" << name << "' of write"; return false; } *slot = i; } size_t p = 0, q = positional.size(); if (fileArg == NONE && p < q && plan.argTypes[positional[p]]->kind == ty_file) fileArg = positional[p++]; if (labelArg == NONE && p < q && plan.argTypes[positional[p]]->kind == ty_string) labelArg = positional[p++]; if (suffixArg == NONE && p < q && run::isWriteSuffixType(plan.argTypes[positional[q - 1]])) suffixArg = positional[--q]; // Validate each data element at compile time. for (size_t k = p; k < q; ++k) { ty *t = plan.argTypes[positional[k]]; if (!isWriteableData(t, e.c)) { writeError(report, (*args)[positional[k]].val->getPos()); if (report) { em << "type '" << *t; if (t->kind == ty_record) em << "' has no accessible write(file, void(file)) method"; else em << "' is not writeable"; } return false; } } // The elements of a rest argument are further data. if (exp *rest = args->rest.val) { ty *t = writtenType(e, rest, plan, report); if (!t) return false; if (t->kind == ty_array) plan.restType = dynamic_cast(t); if (!plan.restType || !isWriteableData(plan.restType->celltype, e.c)) { writeError(report, rest->getPos()); if (report) em << "rest argument of type '" << *t << "' is not an array of writeable values"; return false; } plan.padLabel = labelArg == NONE && p == q && plan.restType->celltype->kind == ty_string; } plan.hasFile = fileArg != NONE; plan.hasSuffix = suffixArg != NONE; if (fileArg != NONE) plan.order.push_back(fileArg); if (labelArg != NONE) plan.order.push_back(labelArg); for (size_t k = p; k < q; ++k) plan.order.push_back(positional[k]); if (suffixArg != NONE) plan.order.push_back(suffixArg); return true; } } // namespace types::ty *callExp::getHeteroWriteType(coenv &e) { // A call that cannot be translated has no type. Interactive mode relies on // this to fall back to describing a value it cannot write. WritePlan plan; return planHeteroWrite(e, args, plan, false) ? primVoid() : primError(); } types::ty *callExp::transHeteroWrite(coenv &e) { // Invoked when a `write` call resolves to the open-signature fallback. // Classifies each argument by its name or static type (file / label / // suffix / data), validates writeability at compile time, builds a // vm::array of tagged_var* elements, and emits a call to the existing // write_var runtime. cachedApp = 0; cachedVarEntry = 0; WritePlan plan; if (!planHeteroWrite(e, args, plan, true)) { if (plan.argError) reportArgErrors(e); return primError(); } auto tag = [&](ty *t) { e.c.encode(inst::intpush, (Int)(intptr_t)t); e.c.encode(inst::builtin, run::makeTaggedVar); }; // Evaluate each argument and wrap it in a tagged_var*, so that write_var // can dispatch on its type at runtime. The arguments are evaluated in the // order write_var expects them, which differs from source order only when // named arguments are given out of place. size_t count = plan.order.size(); size_t labelPos = plan.hasFile ? 1 : 0; for (size_t k = 0; k <= plan.order.size(); ++k) { if (plan.padLabel && k == labelPos) { e.c.encode(inst::constpush, (vm::item)string("")); tag(primString()); ++count; } if (k == plan.order.size()) break; size_t j = plan.order[k]; (*args)[j].val->transToType(e, plan.argTypes[j]); tag(plan.argTypes[j]); } // Build the array: push element count, call newInitializedArray (which // pops elements in reverse to fill indices 0..n-1, preserving order). e.c.encode(inst::intpush, (Int)count); e.c.encode(inst::builtin, run::newInitializedArray); // Tag the elements of a rest argument with their cell type and insert them // after the other data. if (plan.restType) { args->rest.val->transToType(e, plan.restType); e.c.encode(inst::intpush, (Int)(intptr_t)plan.restType->celltype); e.c.encode(inst::intpush, (Int)plan.hasSuffix); e.c.encode(inst::builtin, run::insertTaggedRest); } // Call the existing heterogeneous write runtime. e.c.encode(inst::builtin, run::write_var); return primVoid(); } } // namespace absyntax