void TypeConstraint::verifyFail(const Func* func, int paramNum,
const TypedValue* tv) const {
Transl::VMRegAnchor _;
std::ostringstream fname;
fname << func->fullName()->data() << "()";
const StringData* tn = typeName();
if (isSelf()) {
selfToTypeName(func, &tn);
} else if (isParent()) {
parentToTypeName(func, &tn);
}
auto const givenType = describe_actual_type(tv);
if (isExtended()) {
// Extended type hints raise warnings instead of recoverable
// errors for now, to ease migration (we used to not check these
// at all at runtime).
assert(
(isSoft() || isNullable()) &&
"Only nullable and soft extended type hints are currently implemented");
raise_debugging(
"Argument %d to %s must be of type %s, %s given",
paramNum + 1, fname.str().c_str(), fullName().c_str(), givenType);
} else {
raise_recoverable_error(
"Argument %d passed to %s must be an instance of %s, %s given",
paramNum + 1, fname.str().c_str(), tn->data(), givenType);
}
}
void raise_debugging(const char *fmt, ...) {
std::string msg;
va_list ap;
va_start(ap, fmt);
string_vsnprintf(msg, fmt, ap);
va_end(ap);
raise_debugging(msg);
}
void TypeConstraint::verifyFail(const Func* func, int paramNum,
TypedValue* tv) const {
JIT::VMRegAnchor _;
const StringData* tn = typeName();
if (isSelf()) {
selfToTypeName(func, &tn);
} else if (isParent()) {
parentToTypeName(func, &tn);
}
auto const givenType = describe_actual_type(tv);
auto c = tvToCell(tv);
if (isArray() && !isSoft() && !func->mustBeRef(paramNum) &&
c->m_type == KindOfObject && c->m_data.pobj->isCollection()) {
// To ease migration, the 'array' type constraint will implicitly cast
// collections to arrays, provided the type constraint is not soft and
// the parameter is not by reference. We raise a notice to let the user
// know that there was a type mismatch and that an implicit conversion
// was performed.
raise_notice(
folly::format(
"Argument {} to {}() must be of type {}, {} given; argument {} was "
"implicitly cast to array",
paramNum + 1, func->fullName()->data(), fullName(), givenType,
paramNum + 1
).str()
);
tvCastToArrayInPlace(tv);
return;
}
if (isExtended() && isSoft()) {
// Soft extended type hints raise warnings instead of recoverable
// errors, to ease migration.
raise_debugging(
"Argument %d to %s() must be of type %s, %s given",
paramNum + 1, func->fullName()->data(), fullName().c_str(), givenType);
} else if (isExtended() && isNullable()) {
raise_typehint_error(
folly::format(
"Argument {} to {}() must be of type {}, {} given",
paramNum + 1, func->fullName()->data(), fullName(), givenType
).str()
);
} else {
raise_typehint_error(
folly::format(
"Argument {} passed to {}() must be an instance of {}, {} given",
paramNum + 1, func->fullName()->data(), tn->data(), givenType
).str()
);
}
}
void TypeConstraint::verifyFail(const Func* func, TypedValue* tv,
int id) const {
VMRegAnchor _;
std::string name = displayName(func);
auto const givenType = describe_actual_type(tv, isHHType());
// Handle return type constraint failures
if (id == ReturnId) {
std::string msg;
if (func->isClosureBody()) {
msg =
folly::format(
"Value returned from {}closure must be of type {}, {} given",
func->isAsync() ? "async " : "",
name,
givenType
).str();
} else {
msg =
folly::format(
"Value returned from {}{} {}() must be of type {}, {} given",
func->isAsync() ? "async " : "",
func->preClass() ? "method" : "function",
func->fullName()->data(),
name,
givenType
).str();
}
if (RuntimeOption::EvalCheckReturnTypeHints >= 2 && !isSoft() &&
(!func->isClosureBody() ||
!RuntimeOption::EvalSoftClosureReturnTypeHints)) {
raise_return_typehint_error(msg);
} else {
raise_debugging(msg);
}
return;
}
// Handle implicit collection->array conversion for array parameter type
// constraints
auto c = tvToCell(tv);
if (isArray() && !isSoft() && !func->mustBeRef(id) &&
c->m_type == KindOfObject && c->m_data.pobj->isCollection()) {
// To ease migration, the 'array' type constraint will implicitly cast
// collections to arrays, provided the type constraint is not soft and
// the parameter is not by reference. We raise a notice to let the user
// know that there was a type mismatch and that an implicit conversion
// was performed.
raise_notice(
folly::format(
"Argument {} to {}() must be of type {}, {} given; argument {} was "
"implicitly cast to array",
id + 1, func->fullName()->data(), name, givenType, id + 1
).str()
);
tvCastToArrayInPlace(tv);
return;
}
// Handle parameter type constraint failures
if (isExtended() && isSoft()) {
// Soft extended type hints raise warnings instead of recoverable
// errors, to ease migration.
raise_debugging(
folly::format(
"Argument {} to {}() must be of type {}, {} given",
id + 1, func->fullName()->data(), name, givenType
).str()
);
} else if (isExtended() && isNullable()) {
raise_typehint_error(
folly::format(
"Argument {} to {}() must be of type {}, {} given",
id + 1, func->fullName()->data(), name, givenType
).str()
);
} else {
auto cls = Unit::lookupClass(m_typeName);
if (cls && isInterface(cls)) {
raise_typehint_error(
folly::format(
"Argument {} passed to {}() must implement interface {}, {} given",
id + 1, func->fullName()->data(), name, givenType
).str()
);
} else {
raise_typehint_error(
folly::format(
"Argument {} passed to {}() must be an instance of {}, {} given",
id + 1, func->fullName()->data(), name, givenType
).str()
);
}
}
}
