void GlobalStatement::outputCPP(CodeGenerator &cg, AnalysisResultPtr ar) {
if (m_dynamicGlobal) {
cg.printf("throw_fatal(\"dynamic global\");\n");
} else if (!ar->getScope()->inPseudoMain() || !isTopLevel()) {
BlockScopePtr scope = ar->getScope();
if (m_exp->getCount() > 1) cg.indentBegin("{\n");
for (int i = 0; i < m_exp->getCount(); i++) {
ExpressionPtr exp = (*m_exp)[i];
if (exp->is(Expression::KindOfSimpleVariable)) {
SimpleVariablePtr var = dynamic_pointer_cast<SimpleVariable>(exp);
const string &name = var->getName();
VariableTablePtr variables = scope->getVariables();
if (variables->needLocalCopy(name)) {
cg.printf("%s%s = ref(g->%s);\n",
Option::VariablePrefix, name.c_str(),
variables->getGlobalVariableName(ar, name).c_str());
}
}
else {
// type inference should have set m_dynamicGlobal to true.
ASSERT(false);
}
}
if (m_exp->getCount() > 1) cg.indentEnd("}\n");
}
}
void GlobalStatement::outputCPPImpl(CodeGenerator &cg, AnalysisResultPtr ar) {
BlockScopePtr scope = getScope();
if (m_exp->getCount() > 1) cg_indentBegin("{\n");
for (int i = 0; i < m_exp->getCount(); i++) {
ExpressionPtr exp = (*m_exp)[i];
if (exp->is(Expression::KindOfSimpleVariable)) {
SimpleVariablePtr var = dynamic_pointer_cast<SimpleVariable>(exp);
const string &name = var->getName();
VariableTablePtr variables = scope->getVariables();
if (variables->needLocalCopy(name)) {
cg_printf("%s%s = ref(g->%s);\n",
Option::VariablePrefix, name.c_str(),
variables->getGlobalVariableName(cg, ar, name).c_str());
}
} else if (exp->is(Expression::KindOfDynamicVariable)) {
DynamicVariablePtr var = dynamic_pointer_cast<DynamicVariable>(exp);
ExpressionPtr exp = var->getSubExpression();
exp->outputCPPBegin(cg, ar);
int id = cg.createNewLocalId(shared_from_this());
cg_printf("CStrRef dgv_%d((", id);
exp->outputCPP(cg, ar);
cg_printf("));\n");
cg_printf("variables->get(dgv_%d) = ref(g->get(dgv_%d));\n", id, id);
exp->outputCPPEnd(cg, ar);
} else {
assert(false);
}
}
if (m_exp->getCount() > 1) cg_indentEnd("}\n");
}
static bool by_source(const BlockScopePtr &b1, const BlockScopePtr &b2) {
if (auto d = b1->getStmt()->getRange().compare(b2->getStmt()->getRange())) {
return d < 0;
}
return b1->getContainingFile()->getName() <
b2->getContainingFile()->getName();
}
void CatchStatement::inferTypes(AnalysisResultPtr ar) {
ClassScopePtr cls = ar->findClass(m_className);
TypePtr type;
m_valid = cls;
if (!m_valid) {
if (ar->isFirstPass()) {
ConstructPtr self = shared_from_this();
ar->getCodeError()->record(self, CodeError::UnknownClass, self);
}
type = NEW_TYPE(Object);
} else if (cls->isRedeclaring()) {
type = NEW_TYPE(Object);
} else {
type = Type::CreateObjectType(m_className);
}
BlockScopePtr scope = ar->getScope();
VariableTablePtr variables = scope->getVariables();
variables->add(m_variable, type, false, ar, shared_from_this(),
ModifierExpressionPtr(), false);
if (ar->isFirstPass()) {
FunctionScopePtr func = dynamic_pointer_cast<FunctionScope>(scope);
if (func && variables->isParameter(m_variable)) {
variables->addLvalParam(m_variable);
}
}
if (m_stmt) m_stmt->inferTypes(ar);
}
void GlobalStatement::inferTypes(AnalysisResultPtr ar) {
IMPLEMENT_INFER_AND_CHECK_ASSERT(getScope());
BlockScopePtr scope = getScope();
for (int i = 0; i < m_exp->getCount(); i++) {
ExpressionPtr exp = (*m_exp)[i];
VariableTablePtr variables = scope->getVariables();
variables->setAttribute(VariableTable::NeedGlobalPointer);
if (exp->is(Expression::KindOfSimpleVariable)) {
SimpleVariablePtr var = dynamic_pointer_cast<SimpleVariable>(exp);
const std::string &name = var->getName();
/* If we have already seen this variable in the current scope and
it is not a global variable, record this variable as "redeclared"
which will force Variant type.
*/
variables->setAttribute(VariableTable::InsideGlobalStatement);
variables->checkRedeclared(name, KindOfGlobalStatement);
variables->addLocalGlobal(name);
var->setContext(Expression::Declaration);
var->inferAndCheck(ar, Type::Any, true);
variables->forceVariant(ar, name, VariableTable::AnyVars);
variables->clearAttribute(VariableTable::InsideGlobalStatement);
} else {
variables->forceVariants(ar, VariableTable::AnyVars);
variables->setAttribute(VariableTable::ContainsLDynamicVariable);
assert(exp->is(Expression::KindOfDynamicVariable));
exp->inferAndCheck(ar, Type::Any, true);
}
}
}
void AssignmentExpression::onParse(AnalysisResultPtr ar, BlockScopePtr scope) {
// This is that much we can do during parse phase.
TypePtr type;
if (m_value->is(Expression::KindOfScalarExpression)) {
type = m_value->inferAndCheck(ar, Type::Some, false);
} else if (m_value->is(Expression::KindOfUnaryOpExpression)) {
UnaryOpExpressionPtr uexp =
dynamic_pointer_cast<UnaryOpExpression>(m_value);
if (uexp->getOp() == T_ARRAY) {
type = Type::Array;
}
}
if (!type) type = Type::Some;
if (m_variable->is(Expression::KindOfConstantExpression)) {
// ...as in ClassConstant statement
// We are handling this one here, not in ClassConstant, purely because
// we need "value" to store in constant table.
ConstantExpressionPtr exp =
dynamic_pointer_cast<ConstantExpression>(m_variable);
scope->getConstants()->add(exp->getName(), type, m_value, ar, m_variable);
} else if (m_variable->is(Expression::KindOfSimpleVariable)) {
SimpleVariablePtr var = dynamic_pointer_cast<SimpleVariable>(m_variable);
scope->getVariables()->add(var->getName(), type, true, ar,
shared_from_this(), scope->getModifiers());
var->clearContext(Declaration); // to avoid wrong CodeError
} else {
ASSERT(false); // parse phase shouldn't handle anything else
}
}
bool ClosureExpression::preOutputCPP(CodeGenerator &cg, AnalysisResultPtr ar,
int state) {
FunctionScopeRawPtr cfunc(m_func->getFunctionScope());
bool output = false;
for (BlockScopePtr sc = cfunc->getOuterScope(); sc;
sc = sc->getOuterScope()) {
if (sc->is(BlockScope::ClassScope)) {
ClassScopePtr cls = boost::static_pointer_cast<ClassScope>(sc);
if (cls->isTrait()) {
output = true;
break;
}
}
}
if (!cg.inExpression()) {
return output || Expression::preOutputCPP(cg, ar, state);
}
if (output) {
cg.wrapExpressionBegin();
cfunc->outputCPPPreface(cg, ar);
}
return Expression::preOutputCPP(cg, ar, state) || output;
}
int CodeGenerator::checkLiteralString(const std::string &str, int &index,
AnalysisResultPtr ar, BlockScopePtr bs,
bool scalarVariant /* = false */) {
always_assert(getContext() != CodeGenerator::CppConstantsDecl &&
getContext() != CodeGenerator::CppClassConstantsImpl);
int stringId = ar->getLiteralStringId(str, index);
if (m_literalScope) {
bs = m_literalScope;
}
if (bs && bs != ar) {
FileScopePtr fs = bs->getContainingFile();
if (fs) {
fs->addUsedLiteralString(str);
if (scalarVariant) fs->addUsedLitVarString(str);
if (isFileOrClassHeader()) {
ClassScopePtr cs = bs->getContainingClass();
if (cs) {
cs->addUsedLiteralStringHeader(str);
if (scalarVariant) cs->addUsedLitVarStringHeader(str);
} else {
fs->addUsedLiteralStringHeader(str);
if (scalarVariant) fs->addUsedLitVarStringHeader(str);
}
}
}
}
return stringId;
}
TypePtr AssignmentExpression::
inferTypesImpl(AnalysisResultPtr ar, TypePtr type, bool coerce,
ExpressionPtr variable,
ExpressionPtr value /* = ExpressionPtr() */) {
TypePtr ret = type;
if (value) {
if (coerce) {
ret = value->inferAndCheck(ar, type, coerce);
} else {
ret = value->inferAndCheck(ar, NEW_TYPE(Some), coerce);
}
}
BlockScopePtr scope = ar->getScope();
if (variable->is(Expression::KindOfConstantExpression)) {
// ...as in ClassConstant statement
ConstantExpressionPtr exp =
dynamic_pointer_cast<ConstantExpression>(variable);
bool p;
scope->getConstants()->check(exp->getName(), ret, true, ar, variable, p);
} else if (variable->is(Expression::KindOfDynamicVariable)) {
// simptodo: not too sure about this
ar->getFileScope()->setAttribute(FileScope::ContainsLDynamicVariable);
} else if (variable->is(Expression::KindOfSimpleVariable)) {
SimpleVariablePtr var = dynamic_pointer_cast<SimpleVariable>(variable);
if (var->getName() == "this" && ar->getClassScope()) {
if (ar->isFirstPass()) {
ar->getCodeError()->record(variable, CodeError::ReassignThis,
variable);
}
}
if (ar->getPhase() == AnalysisResult::LastInference && value) {
if (!value->getExpectedType()) {
value->setExpectedType(variable->getActualType());
}
}
}
// if the value may involve object, consider the variable as "referenced"
// so that objects are not destructed prematurely.
bool referenced = true;
if (value && value->isScalar()) referenced = false;
if (ret && ret->isNoObjectInvolved()) referenced = false;
if (referenced && variable->is(Expression::KindOfSimpleVariable)) {
SimpleVariablePtr var =
dynamic_pointer_cast<SimpleVariable>(variable);
const std::string &name = var->getName();
VariableTablePtr variables = ar->getScope()->getVariables();
variables->addReferenced(name);
}
TypePtr vt = variable->inferAndCheck(ar, ret, true);
if (!coerce && type->is(Type::KindOfAny)) {
ret = vt;
}
return ret;
}
void StaticStatement::outputCPPImpl(CodeGenerator &cg, AnalysisResultPtr ar) {
BlockScopePtr scope = getScope();
if (scope->inPseudoMain()) {
if (m_exp->getCount() > 1) cg_indentBegin("{\n");
for (int i = 0; i < m_exp->getCount(); i++) {
ExpressionPtr exp = (*m_exp)[i];
if (exp->is(Expression::KindOfAssignmentExpression)) {
exp->outputCPP(cg, ar);
cg_printf(";\n");
} else {
ASSERT(false);
}
}
if (m_exp->getCount() > 1) cg_indentEnd("}\n");
return;
}
VariableTablePtr variables = scope->getVariables();
if (m_exp->getCount() > 1) cg_indentBegin("{\n");
for (int i = 0; i < m_exp->getCount(); i++) {
ExpressionPtr exp = (*m_exp)[i];
if (exp->is(Expression::KindOfAssignmentExpression)) {
AssignmentExpressionPtr assignment_exp =
dynamic_pointer_cast<AssignmentExpression>(exp);
ExpressionPtr variable = assignment_exp->getVariable();
SimpleVariablePtr var = dynamic_pointer_cast<SimpleVariable>(variable);
assert(var->hasContext(Expression::Declaration));
const std::string &name = var->getName();
if (variables->needLocalCopy(name)) {
ASSERT(var->hasAssignableCPPVariable());
cg_printf("%s.assignRef(%s%s);\n",
var->getAssignableCPPVariable(ar).c_str(),
Option::StaticVariablePrefix, name.c_str());
}
cg_indentBegin("if (!%s%s%s) {\n", Option::InitPrefix,
Option::StaticVariablePrefix, name.c_str());
exp->outputCPP(cg, ar);
cg_printf(";\n");
cg_printf("%s%s%s = true;\n", Option::InitPrefix,
Option::StaticVariablePrefix, name.c_str());
cg_indentEnd("}\n");
} else {
ASSERT(false);
}
}
if (m_exp->getCount() > 1) cg_indentEnd("}\n");
}
void GlobalStatement::inferTypes(AnalysisResultPtr ar) {
BlockScopePtr scope = ar->getScope();
scope->getVariables()->setAttribute(VariableTable::InsideGlobalStatement);
for (int i = 0; i < m_exp->getCount(); i++) {
ExpressionPtr exp = (*m_exp)[i];
if (exp->is(Expression::KindOfSimpleVariable)) {
SimpleVariablePtr var = dynamic_pointer_cast<SimpleVariable>(exp);
VariableTablePtr variables = scope->getVariables();
const std::string &name = var->getName();
/* If we have already seen this variable in the current scope and
it is not a global variable, record this variable as "redeclared"
which will force Variant type.
*/
variables->checkRedeclared(name, KindOfGlobalStatement);
/* If this is not a top-level global statement, the variable also
needs to be Variant type. This should not be a common use case in
php code.
*/
if (!isTopLevel()) {
variables->addNestedGlobal(name);
}
var->setContext(Expression::Declaration);
var->inferAndCheck(ar, NEW_TYPE(Any), true);
if (variables->needLocalCopy(name)) {
variables->forceVariant(ar, name);
variables->setAttribute(VariableTable::NeedGlobalPointer);
}
ConstructPtr decl =
ar->getVariables()->getDeclaration(var->getName());
if (decl) {
ar->getDependencyGraph()->add(DependencyGraph::KindOfGlobalVariable,
ar->getName(),
var->getName(), var,
var->getName(), decl);
}
} else {
if (ar->isFirstPass()) {
ar->getCodeError()->record(shared_from_this(), CodeError::UseDynamicGlobal, exp);
}
m_dynamicGlobal = true;
}
}
FunctionScopePtr func = ar->getFunctionScope();
scope->getVariables()->clearAttribute(VariableTable::InsideGlobalStatement);
}
void StaticStatement::analyzeProgramImpl(AnalysisResultPtr ar) {
m_exp->analyzeProgram(ar);
BlockScopePtr scope = ar->getScope();
for (int i = 0; i < m_exp->getCount(); i++) {
ExpressionPtr exp = (*m_exp)[i];
ExpressionPtr variable;
ExpressionPtr value;
if (ar->getPhase() == AnalysisResult::AnalyzeInclude) {
// turn static $a; into static $a = null;
if (exp->is(Expression::KindOfSimpleVariable)) {
variable = dynamic_pointer_cast<SimpleVariable>(exp);
exp = AssignmentExpressionPtr
(new AssignmentExpression(exp->getLocation(),
Expression::KindOfAssignmentExpression,
variable,
CONSTANT("null"),
false));
(*m_exp)[i] = exp;
}
}
if (exp->is(Expression::KindOfAssignmentExpression)) {
AssignmentExpressionPtr assignment_exp =
dynamic_pointer_cast<AssignmentExpression>(exp);
variable = assignment_exp->getVariable();
value = assignment_exp->getValue();
} else {
ASSERT(false);
}
SimpleVariablePtr var = dynamic_pointer_cast<SimpleVariable>(variable);
if (ar->getPhase() == AnalysisResult::AnalyzeInclude) {
if (scope->getVariables()->setStaticInitVal(var->getName(), value)) {
ar->getCodeError()->record(CodeError::DeclaredStaticVariableTwice,
exp);
}
} else if (ar->getPhase() == AnalysisResult::AnalyzeAll) {
// update initial value
const string &name = var->getName();
ExpressionPtr initValue =
(dynamic_pointer_cast<Expression>
(scope->getVariables()->getStaticInitVal(name)))->clone();
exp = AssignmentExpressionPtr
(new AssignmentExpression(exp->getLocation(),
Expression::KindOfAssignmentExpression,
variable, initValue, false));
(*m_exp)[i] = exp;
}
}
}
TypePtr SimpleVariable::inferAndCheck(AnalysisResultPtr ar, TypePtr type,
bool coerce) {
TypePtr ret;
ConstructPtr construct = shared_from_this();
BlockScopePtr scope = getScope();
VariableTablePtr variables = scope->getVariables();
// check function parameter that can occur in lval context
if (m_sym && m_sym->isParameter() &&
m_context & (LValue | RefValue | DeepReference |
UnsetContext | InvokeArgument | OprLValue | DeepOprLValue)) {
m_sym->setLvalParam();
}
if (m_this) {
ClassScopePtr cls = getOriginalClass();
if (!hasContext(ObjectContext) && cls->derivedByDynamic()) {
ret = Type::Object;
} else {
ret = Type::CreateObjectType(cls->getName());
}
if (!hasContext(ObjectContext) &&
variables->getAttribute(VariableTable::ContainsDynamicVariable)) {
ret = variables->add(m_sym, ret, true, ar,
construct, scope->getModifiers());
}
} else if ((m_context & (LValue|Declaration)) &&
!(m_context & (ObjectContext|RefValue))) {
if (m_globals) {
ret = Type::Variant;
} else if (m_superGlobal) {
ret = m_superGlobalType;
} else if (m_superGlobalType) { // For system
ret = variables->add(m_sym, m_superGlobalType,
((m_context & Declaration) != Declaration), ar,
construct, scope->getModifiers());
} else {
ret = variables->add(m_sym, type,
((m_context & Declaration) != Declaration), ar,
construct, scope->getModifiers());
}
} else {
if (m_superGlobalType) {
ret = m_superGlobalType;
} else if (m_globals) {
ret = Type::Array;
} else if (scope->is(BlockScope::ClassScope)) {
// ClassVariable expression will come to this block of code
ret = getClassScope()->checkProperty(m_sym, type, true, ar);
} else {
TypePtr tmpType = type;
if (m_context & RefValue) {
tmpType = Type::Variant;
coerce = true;
}
int p;
ret = variables->checkVariable(m_sym, tmpType, coerce,
ar, construct, p);
}
}
TypePtr actual = propagateTypes(ar, ret);
setTypes(ar, actual, type);
if (Type::SameType(actual, ret)) {
m_implementedType.reset();
} else {
m_implementedType = ret;
}
return actual;
}
TypePtr SimpleVariable::inferAndCheck(AnalysisResultPtr ar, TypePtr type,
bool coerce) {
IMPLEMENT_INFER_AND_CHECK_ASSERT(getScope());
resetTypes();
TypePtr ret;
ConstructPtr construct = shared_from_this();
BlockScopePtr scope = getScope();
VariableTablePtr variables = scope->getVariables();
// check function parameter that can occur in lval context
if (m_sym && m_sym->isParameter() &&
m_context & (LValue | RefValue | DeepReference |
UnsetContext | InvokeArgument | OprLValue | DeepOprLValue)) {
m_sym->setLvalParam();
}
if (coerce && m_sym && type && type->is(Type::KindOfAutoSequence)) {
TypePtr t = m_sym->getType();
if (!t || t->is(Type::KindOfVoid) ||
t->is(Type::KindOfSome) || t->is(Type::KindOfArray)) {
type = Type::Array;
}
}
if (m_this) {
ret = Type::Object;
ClassScopePtr cls = getOriginalClass();
if (cls && (hasContext(ObjectContext) || !cls->derivedByDynamic())) {
ret = Type::CreateObjectType(cls->getName());
}
if (!hasContext(ObjectContext) &&
variables->getAttribute(VariableTable::ContainsDynamicVariable)) {
if (variables->getAttribute(VariableTable::ContainsLDynamicVariable)) {
ret = Type::Variant;
}
ret = variables->add(m_sym, ret, true, ar,
construct, scope->getModifiers());
}
} else if ((m_context & (LValue|Declaration)) &&
!(m_context & (ObjectContext|RefValue))) {
if (m_globals) {
ret = Type::Array;
} else if (m_superGlobal) {
ret = m_superGlobalType;
} else if (m_superGlobalType) { // For system
ret = variables->add(m_sym, m_superGlobalType,
((m_context & Declaration) != Declaration), ar,
construct, scope->getModifiers());
} else {
ret = variables->add(m_sym, type,
((m_context & Declaration) != Declaration), ar,
construct, scope->getModifiers());
}
} else {
if (m_superGlobalType) {
ret = m_superGlobalType;
} else if (m_globals) {
ret = Type::Array;
} else if (scope->is(BlockScope::ClassScope)) {
assert(getClassScope().get() == scope.get());
// ClassVariable expression will come to this block of code
ret = getClassScope()->checkProperty(getScope(), m_sym, type, true, ar);
} else {
TypePtr tmpType = type;
if (m_context & RefValue) {
tmpType = Type::Variant;
coerce = true;
}
ret = variables->checkVariable(m_sym, tmpType, coerce, ar, construct);
if (ret && (ret->is(Type::KindOfSome) || ret->is(Type::KindOfAny))) {
ret = Type::Variant;
}
}
}
// if m_assertedType is set, then this is a type assertion node
TypePtr inType = m_assertedType ?
GetAssertedInType(ar, m_assertedType, ret) : ret;
TypePtr actual = propagateTypes(ar, inType);
setTypes(ar, actual, type);
if (Type::SameType(actual, ret)) {
m_implementedType.reset();
} else {
m_implementedType = ret;
}
return actual;
}
void StaticStatement::inferTypes(AnalysisResultPtr ar) {
BlockScopePtr scope = ar->getScope();
if (scope->inPseudoMain()) { // static just means to unset at global level
for (int i = 0; i < m_exp->getCount(); i++) {
ExpressionPtr exp = (*m_exp)[i];
if (exp->is(Expression::KindOfAssignmentExpression)) {
AssignmentExpressionPtr assignment_exp =
dynamic_pointer_cast<AssignmentExpression>(exp);
ExpressionPtr variable = assignment_exp->getVariable();
if (variable->is(Expression::KindOfSimpleVariable)) {
SimpleVariablePtr var =
dynamic_pointer_cast<SimpleVariable>(variable);
var->setContext(Expression::Declaration);
scope->getVariables()->forceVariant(ar, var->getName(),
VariableTable::AnyStaticVars);
} else {
ASSERT(false);
}
} else {
// Expression was optimized away; remove it
m_exp->removeElement(i--);
}
}
m_exp->inferTypes(ar, Type::Any, true);
return;
}
scope->getVariables()->setAttribute(VariableTable::InsideStaticStatement);
for (int i = 0; i < m_exp->getCount(); i++) {
ExpressionPtr exp = (*m_exp)[i];
VariableTablePtr variables = scope->getVariables();
if (exp->is(Expression::KindOfAssignmentExpression)) {
AssignmentExpressionPtr assignment_exp =
dynamic_pointer_cast<AssignmentExpression>(exp);
ExpressionPtr variable = assignment_exp->getVariable();
if (variable->is(Expression::KindOfSimpleVariable)) {
SimpleVariablePtr var = dynamic_pointer_cast<SimpleVariable>(variable);
var->setContext(Expression::Declaration);
const std::string &name = var->getName();
/* If we have already seen this variable in the current scope and
it is not a static variable, record this variable as "redeclared"
to force Variant type.
*/
if (ar->isFirstPass()) {
variables->checkRedeclared(name, KindOfStaticStatement);
}
/* If this is not a top-level static statement, the variable also
needs to be Variant type. This should not be a common use case in
php code.
*/
if (!isTopLevel()) {
variables->addNestedStatic(name);
}
if (variables->needLocalCopy(name)) {
variables->forceVariant(ar, name, VariableTable::AnyStaticVars);
}
} else {
ASSERT(false);
}
} else {
// Expression was optimized away; remove it
m_exp->removeElement(i--);
continue;
}
exp->inferAndCheck(ar, Type::Any, false);
}
scope->getVariables()->clearAttribute(VariableTable::InsideStaticStatement);
}
static bool by_source(const BlockScopePtr &b1, const BlockScopePtr &b2) {
return b1->getStmt()->getLocation()->
compare(b2->getStmt()->getLocation().get()) < 0;
}
void SimpleFunctionCall::analyzeProgram(AnalysisResultPtr ar) {
if (m_className.empty()) {
addUserFunction(ar, m_name);
} else if (m_className != "parent") {
addUserClass(ar, m_className);
} else {
m_parentClass = true;
}
if (ar->getPhase() == AnalysisResult::AnalyzeInclude) {
CHECK_HOOK(onSimpleFunctionCallAnalyzeInclude);
ConstructPtr self = shared_from_this();
// We need to know the name of the constant so that we can associate it
// with this file before we do type inference.
if (m_className.empty() && m_type == DefineFunction) {
ScalarExpressionPtr name =
dynamic_pointer_cast<ScalarExpression>((*m_params)[0]);
string varName;
if (name) {
varName = name->getIdentifier();
if (!varName.empty()) {
ar->getFileScope()->declareConstant(ar, varName);
}
}
// handling define("CONSTANT", ...);
if (m_params && m_params->getCount() >= 2) {
ScalarExpressionPtr name =
dynamic_pointer_cast<ScalarExpression>((*m_params)[0]);
string varName;
if (name) {
varName = name->getIdentifier();
if (!varName.empty()) {
ExpressionPtr value = (*m_params)[1];
ConstantTablePtr constants =
ar->findConstantDeclarer(varName)->getConstants();
if (constants != ar->getConstants()) {
constants->add(varName, NEW_TYPE(Some), value, ar, self);
if (name->hasHphpNote("Dynamic")) {
constants->setDynamic(ar, varName);
}
}
}
}
}
}
if (m_type == UnserializeFunction) {
ar->forceClassVariants();
}
}
if (ar->getPhase() == AnalysisResult::AnalyzeAll) {
// Look up the corresponding FunctionScope and ClassScope
// for this function call
{
FunctionScopePtr func;
ClassScopePtr cls;
if (m_className.empty()) {
func = ar->findFunction(m_name);
} else {
cls = ar->resolveClass(m_className);
if (cls) {
if (m_name == "__construct") {
func = cls->findConstructor(ar, true);
} else {
func = cls->findFunction(ar, m_name, true, true);
}
}
}
if (func && !func->isRedeclaring()) {
if (m_funcScope != func) {
m_funcScope = func;
Construct::recomputeEffects();
}
}
if (cls && !cls->isRedeclaring())
m_classScope = cls;
}
// check for dynamic constant and volatile function/class
if (m_className.empty() &&
(m_type == DefinedFunction ||
m_type == FunctionExistsFunction ||
m_type == ClassExistsFunction ||
m_type == InterfaceExistsFunction) &&
m_params && m_params->getCount() >= 1) {
ExpressionPtr value = (*m_params)[0];
if (value->isScalar()) {
ScalarExpressionPtr name =
dynamic_pointer_cast<ScalarExpression>(value);
if (name && name->isLiteralString()) {
string symbol = name->getLiteralString();
switch (m_type) {
case DefinedFunction: {
ConstantTablePtr constants = ar->getConstants();
if (!constants->isPresent(symbol)) {
// user constant
BlockScopePtr block = ar->findConstantDeclarer(symbol);
if (block) { // found the constant
constants = block->getConstants();
// set to be dynamic
constants->setDynamic(ar, symbol);
}
}
break;
}
case FunctionExistsFunction: {
FunctionScopePtr func = ar->findFunction(Util::toLower(symbol));
if (func && func->isUserFunction()) {
func->setVolatile();
}
break;
}
case InterfaceExistsFunction:
case ClassExistsFunction: {
ClassScopePtr cls = ar->findClass(Util::toLower(symbol));
if (cls && cls->isUserClass()) {
cls->setVolatile();
}
break;
}
default:
ASSERT(false);
}
}
}
}
}
if (m_params) {
if (ar->getPhase() == AnalysisResult::AnalyzeAll) {
if (m_funcScope) {
ExpressionList ¶ms = *m_params;
int mpc = m_funcScope->getMaxParamCount();
for (int i = params.getCount(); i--; ) {
ExpressionPtr p = params[i];
if (i < mpc ? m_funcScope->isRefParam(i) :
m_funcScope->isReferenceVariableArgument()) {
p->setContext(Expression::RefValue);
} else if (!(p->getContext() & Expression::RefParameter)) {
p->clearContext(Expression::RefValue);
}
}
} else {
FunctionScopePtr func = ar->findFunction(m_name);
if (func && func->isRedeclaring()) {
FunctionScope::RefParamInfoPtr info =
FunctionScope::GetRefParamInfo(m_name);
if (info) {
for (int i = m_params->getCount(); i--; ) {
if (info->isRefParam(i)) {
m_params->markParam(i, canInvokeFewArgs());
}
}
}
} else {
m_params->markParams(false);
}
}
}
m_params->analyzeProgram(ar);
}
}
TypePtr SimpleVariable::inferAndCheck(AnalysisResultPtr ar, TypePtr type,
bool coerce) {
TypePtr ret;
ConstructPtr construct = shared_from_this();
BlockScopePtr scope = ar->getScope();
VariableTablePtr variables = scope->getVariables();
// check function parameter that can occur in lval context
if (m_context & (LValue | RefValue | UnsetContext | InvokeArgument)) {
FunctionScopePtr func = dynamic_pointer_cast<FunctionScope>(scope);
if (func) {
if (variables->isParameter(m_name)) {
variables->addLvalParam(m_name);
}
}
}
if (m_name == "this") {
ClassScopePtr cls = getOriginalScope(ar);
if (cls) {
bool isStaticFunc = false;
FunctionScopePtr func = dynamic_pointer_cast<FunctionScope>(scope);
if (func->isStatic()) isStaticFunc = true;
if (cls->isRedeclaring()) {
ret = Type::Variant;
} else {
ret = Type::CreateObjectType(cls->getName());
}
if (!isStaticFunc || (m_context & ObjectContext)) m_this = true;
}
}
if ((m_context & (LValue|Declaration)) && !(m_context & ObjectContext)) {
if (m_superGlobal) {
ret = m_superGlobalType;
} else if (m_superGlobalType) { // For system
if (!m_this) {
ret = variables->add(m_name, m_superGlobalType,
((m_context & Declaration) != Declaration), ar,
construct, scope->getModifiers());
}
} else {
if (m_globals) {
ret = Type::Variant; // this can happen with "unset($GLOBALS)"
} else if (!m_this) {
ret = variables->add(m_name, type,
((m_context & Declaration) != Declaration), ar,
construct, scope->getModifiers());
}
}
} else {
if (!m_this) {
if (m_superGlobalType) {
ret = m_superGlobalType;
} else if (m_globals) {
ret = Type::Array;
} else if (scope->is(BlockScope::ClassScope)) {
// ClassVariable expression will come to this block of code
int properties;
ret = variables->checkProperty(m_name, type, true, ar, construct,
properties);
} else {
TypePtr tmpType = type;
if (m_context & RefValue) {
tmpType = Type::Variant;
coerce = true;
}
int p;
ret = variables->checkVariable(m_name, tmpType, coerce, ar, construct,
p);
}
}
}
TypePtr actual = propagateTypes(ar, ret);
setTypes(actual, type);
if (Type::SameType(actual, ret)) {
m_implementedType.reset();
} else {
m_implementedType = ret;
}
return actual;
}
void FileScope::addConstant(const string &name, TypePtr type,
ExpressionPtr value,
AnalysisResultPtr ar, ConstructPtr con) {
BlockScopePtr f = ar->findConstantDeclarer(name);
f->getConstants()->add(name, type, value, ar, con);
}
ExpressionPtr SimpleFunctionCall::preOptimize(AnalysisResultPtr ar) {
ar->preOptimize(m_nameExp);
ar->preOptimize(m_params);
if (ar->getPhase() != AnalysisResult::SecondPreOptimize) {
return ExpressionPtr();
}
// optimize away various "exists" functions, this may trigger
// dead code elimination and improve type-inference.
if (m_className.empty() &&
(m_type == DefinedFunction ||
m_type == FunctionExistsFunction ||
m_type == ClassExistsFunction ||
m_type == InterfaceExistsFunction) &&
m_params && m_params->getCount() == 1) {
ExpressionPtr value = (*m_params)[0];
if (value->isScalar()) {
ScalarExpressionPtr name = dynamic_pointer_cast<ScalarExpression>(value);
if (name && name->isLiteralString()) {
string symbol = name->getLiteralString();
switch (m_type) {
case DefinedFunction: {
ConstantTablePtr constants = ar->getConstants();
// system constant
if (constants->isPresent(symbol)) {
return CONSTANT("true");
}
// user constant
BlockScopePtr block = ar->findConstantDeclarer(symbol);
// not found (i.e., undefined)
if (!block) {
if (symbol.find("::") == std::string::npos) {
return CONSTANT("false");
} else {
// e.g., defined("self::ZERO")
return ExpressionPtr();
}
}
constants = block->getConstants();
// already set to be dynamic
if (constants->isDynamic(symbol)) return ExpressionPtr();
ConstructPtr decl = constants->getValue(symbol);
ExpressionPtr constValue = dynamic_pointer_cast<Expression>(decl);
if (constValue->isScalar()) {
return CONSTANT("true");
} else {
return ExpressionPtr();
}
break;
}
case FunctionExistsFunction: {
const std::string &lname = Util::toLower(symbol);
if (Option::DynamicInvokeFunctions.find(lname) ==
Option::DynamicInvokeFunctions.end()) {
FunctionScopePtr func = ar->findFunction(lname);
if (!func) {
return CONSTANT("false");
} else if (!func->isVolatile()) {
return CONSTANT("true");
}
}
break;
}
case InterfaceExistsFunction: {
ClassScopePtr cls = ar->findClass(Util::toLower(symbol));
if (!cls || !cls->isInterface()) {
return CONSTANT("false");
} else if (!cls->isVolatile()) {
return CONSTANT("true");
}
break;
}
case ClassExistsFunction: {
ClassScopePtr cls = ar->findClass(Util::toLower(symbol));
if (!cls || cls->isInterface()) {
return CONSTANT("false");
} else if (!cls->isVolatile()) {
return CONSTANT("true");
}
break;
}
default:
ASSERT(false);
}
}
}
}
return ExpressionPtr();
}