static ExpressionPtr makeIsNull(AnalysisResultConstPtr ar,
LocationPtr loc, ExpressionPtr exp,
bool invert) {
/* Replace "$x === null" with an is_null call; this requires slightly
* less work at runtime. */
ExpressionListPtr expList =
ExpressionListPtr(new ExpressionList(exp->getScope(), loc));
expList->insertElement(exp);
SimpleFunctionCallPtr call
(new SimpleFunctionCall(exp->getScope(), loc,
"is_null", false, expList, ExpressionPtr()));
call->setValid();
call->setActualType(Type::Boolean);
call->setupScopes(ar);
ExpressionPtr result(call);
if (invert) {
result = ExpressionPtr(new UnaryOpExpression(
exp->getScope(), loc,
result, '!', true));
}
return result;
}
static ExpressionPtr makeIsNull(LocationPtr loc, ExpressionPtr exp,
bool invert) {
/* Replace "$x === null" with an is_null call; this requires slightly
* less work at runtime. */
ExpressionListPtr expList =
ExpressionListPtr(new ExpressionList(loc,
Expression::KindOfExpressionList));
expList->insertElement(exp);
SimpleFunctionCallPtr call
(new SimpleFunctionCall(loc, Expression::KindOfSimpleFunctionCall,
"is_null", expList, ExpressionPtr()));
call->setValid();
call->setActualType(Type::Boolean);
ExpressionPtr result(call);
if (invert) {
result = ExpressionPtr(new UnaryOpExpression(
loc, Expression::KindOfUnaryOpExpression,
result, '!', true));
}
return result;
}
void AnalysisResult::resolveNSFallbackFuncs() {
for (auto &pair : m_nsFallbackFuncs) {
SimpleFunctionCallPtr sfc =
static_pointer_cast<SimpleFunctionCall>(pair.first);
sfc->resolveNSFallbackFunc(
shared_from_this(),
pair.second
);
}
}
void Parser::onCall(Token *out, bool dynamic, Token *name, Token *params,
Token *className) {
if (dynamic) {
out->exp = NEW_EXP(DynamicFunctionCall, name->exp,
dynamic_pointer_cast<ExpressionList>(params->exp),
className ? &className->text() : NULL);
} else {
SimpleFunctionCallPtr call =
NEW_EXP(SimpleFunctionCall, name->text(),
dynamic_pointer_cast<ExpressionList>(params->exp),
className ? &className->text() : NULL);
out->exp = call;
call->onParse(m_ar);
}
}
/**
* If one or more of the arguments of the function call depend on query only
* state (query local but not a query parameter reference), then rewrite
* all of the arguments to be query local and return the rewritten
* function call (the query processor has to either figure out a way to call
* the function or must cause a runtime error when faced with the call).
* Otherwise, rewrite the call as a query parameter reference.
*/
ExpressionPtr CaptureExtractor::rewriteCall(SimpleFunctionCallPtr sfc) {
assert(sfc != nullptr);
if (sfc->hadBackslash() || sfc->getClass() || sfc->hasStaticClass()) {
return newQueryParamRef(sfc);
}
auto args = sfc->getParams();
auto pc = args == nullptr ? 0 : args->getCount();
bool isQueryCall = false;
for (int i = 0; i < pc; i++) {
auto arg = (*args)[i];
assert(arg != nullptr);
isQueryCall |= this->dependsOnQueryOnlyState(arg);
}
if (!isQueryCall) return newQueryParamRef(sfc);
auto newArgs =
std::make_shared<ExpressionList>(args->getScope(), args->getRange());
bool noRewrites = true;
for (int i = 0; i < pc; i++) {
auto arg = (*args)[i];
auto newArg = rewrite(arg);
if (arg != newArg) noRewrites = false;
newArgs->addElement(newArg);
}
if (noRewrites) return sfc;
return std::make_shared<SimpleFunctionCall>(
sfc->getScope(), sfc->getRange(),
sfc->getOriginalName(), false, newArgs, ExpressionPtr());
}
ExpressionPtr AssignmentExpression::makeIdCall(AnalysisResultPtr ar) {
ExpressionListPtr arg =
ExpressionListPtr(new ExpressionList(getLocation(),
Expression::KindOfExpressionList));
arg->insertElement(m_value);
SimpleFunctionCallPtr result =
SimpleFunctionCallPtr(
new SimpleFunctionCall(getLocation(),
Expression::KindOfSimpleFunctionCall,
"id", arg, NULL));
result->setFunctionAndClassScope(ar->findHelperFunction("id"),
ClassScopePtr());
result->setValid();
result->setNoPrefix();
result->setActualType(m_value->getActualType());
result->setExpectedType(m_expectedType);
return result;
}