void ClassScope::applyTraitRules(AnalysisResultPtr ar) {
assert(Option::WholeProgram);
ClassStatementPtr classStmt = dynamic_pointer_cast<ClassStatement>(getStmt());
assert(classStmt);
StatementListPtr stmts = classStmt->getStmts();
if (!stmts) return;
for (int s = 0; s < stmts->getCount(); s++) {
StatementPtr stmt = (*stmts)[s];
UseTraitStatementPtr useStmt =
dynamic_pointer_cast<UseTraitStatement>(stmt);
if (!useStmt) continue;
StatementListPtr rules = useStmt->getStmts();
for (int r = 0; r < rules->getCount(); r++) {
StatementPtr rule = (*rules)[r];
TraitPrecStatementPtr precStmt =
dynamic_pointer_cast<TraitPrecStatement>(rule);
if (precStmt) {
applyTraitPrecRule(precStmt);
} else {
TraitAliasStatementPtr aliasStmt =
dynamic_pointer_cast<TraitAliasStatement>(rule);
assert(aliasStmt);
applyTraitAliasRule(ar, aliasStmt);
}
}
}
}
void Parser::saveParseTree(Token &tree) {
StatementListStatementPtr s = tree->getStmtList();
// Reorder so that classes and funcs are first.
if (s) {
std::vector<StatementPtr> scopes;
std::vector<StatementPtr> rest;
const std::vector<StatementPtr> &svec = s->stmts();
for (std::vector<StatementPtr>::const_iterator it = svec.begin();
it != svec.end(); ++it) {
ClassStatementPtr cs = (*it)->cast<ClassStatement>();
if (cs || (*it)->cast<FunctionStatement>()) {
scopes.push_back(*it);
if (cs) {
rest.push_back(cs->getMarker());
}
} else {
rest.push_back(*it);
}
}
rest.insert(rest.begin(), scopes.begin(), scopes.end());
m_tree = StatementPtr(new StatementListStatement(this, rest));
} else {
m_tree = tree->stmt();
}
if (!m_tree) {
m_tree = NEW_STMT0(StatementList);
}
}
void Parser::onMethod(Token &out, Token &modifiers, Token &ret, Token &ref,
Token &name, Token ¶ms, Token &stmt,
bool reloc /* = true */) {
ClassStatementPtr cs = peekClass();
MethodStatementPtr ms = peekFunc()->unsafe_cast<MethodStatement>();
ASSERT(ms);
popFunc();
if (reloc) {
ms->setLoc(popFuncLocation().get());
}
ms->resetLoc(this);
bool hasCallToGetArgs = m_hasCallToGetArgs.back();
m_hasCallToGetArgs.pop_back();
if (ms->hasYield()) {
string closureName = getClosureName();
ms->setName(closureName);
ms->setPublic();
Token new_params;
prepare_generator(this, stmt, new_params, ms->getYieldCount());
StatementListStatementPtr stmts = stmt->getStmtList();
if (stmts) stmts->resetLoc(this);
ms->init(this, ref.num(), new_params->params(), stmts, hasCallToGetArgs);
String clsname = cs->name();
create_generator(this, out, params, name, closureName, clsname.data(),
&modifiers);
} else {
StatementListStatementPtr stmts = stmt->getStmtList();
if (stmts) stmts->resetLoc(this);
ms->init(this, ref.num(), params->params(), stmts, hasCallToGetArgs);
}
cs->addMethod(ms);
}
void ClassScope::applyTraitRules(TMIData& tmid) {
ClassStatementPtr classStmt =
dynamic_pointer_cast<ClassStatement>(getStmt());
assert(classStmt);
StatementListPtr stmts = classStmt->getStmts();
if (!stmts) return;
for (int s = 0; s < stmts->getCount(); s++) {
StatementPtr stmt = (*stmts)[s];
UseTraitStatementPtr useStmt =
dynamic_pointer_cast<UseTraitStatement>(stmt);
if (!useStmt) continue;
StatementListPtr rules = useStmt->getStmts();
for (int r = 0; r < rules->getCount(); r++) {
StatementPtr rule = (*rules)[r];
TraitPrecStatementPtr precStmt =
dynamic_pointer_cast<TraitPrecStatement>(rule);
if (precStmt) {
tmid.applyPrecRule(precStmt);
} else {
TraitAliasStatementPtr aliasStmt =
dynamic_pointer_cast<TraitAliasStatement>(rule);
assert(aliasStmt);
tmid.applyAliasRule(aliasStmt, this);
}
}
}
}
void Parser::onInterface(Token &out, Token &name, Token &base, Token &stmt) {
out.reset();
ClassStatementPtr cs = peekClass();
popClass();
std::vector<String> &interfaceNames = base->strings();
cs->addBases(interfaceNames);
out->stmt() = cs;
}
void Parser::onMethodStart(Token &name, Token &modifiers) {
ClassStatementPtr cs = peekClass();
FunctionStatementPtr func = NEW_STMT(Method, name.text(), cs.get(),
modifiers.num(),
m_scanner.detachDocComment());
m_hasCallToGetArgs.push_back(false);
pushFunc(func);
}
void Parser::onClassStart(int type, Token &name, Token *parent) {
ClassStatementPtr cs = NEW_STMT(Class, name.text(),
parent ? parent->text() : "", m_scanner.detachDocComment());
pushClass(cs);
int mod = 0;
if (type == T_ABSTRACT) mod = ClassStatement::Abstract;
else if (type == T_FINAL) mod = ClassStatement::Final;
else if (type == T_INTERFACE) mod = ClassStatement::Interface;
cs->setModifiers(mod);
}
void Parser::onMethod(Token &modifiers, Token &ref, Token &name,
Token ¶ms, Token &stmt) {
ClassStatementPtr cs = peekClass();
MethodStatementPtr ms = peekFunc()->cast<MethodStatement>();
ASSERT(ms);
popFunc();
StatementListStatementPtr stmts = stmt->getStmtList();
ms->init(ref.num, params->params(), stmts, m_hasCallToGetArgs);
cs->addMethod(ms);
}
void Parser::onClassVariable(Token &name, Token *val) {
ClassStatementPtr cs = peekClass();
ExpressionPtr v;
if (val) {
v = (*val)->exp();
}
cs->addVariable(ClassVariablePtr(
new ClassVariable(this, name.getText(), m_classVarMods, v,
m_scanner.getDocComment(), cs.get())));
}
void Parser::onClass(Token &out, Token &type, Token &bases) {
out.reset();
ClassStatementPtr cs = peekClass();
popClass();
int mod = 0;
if (type.num == T_ABSTRACT) mod = ClassStatement::Abstract;
else if (type.num == T_FINAL) mod = ClassStatement::Final;
cs->setModifiers(mod);
std::vector<String> &interfaceNames = bases->strings();
cs->addBases(interfaceNames);
cs->finish();
out->stmt() = cs;
}
void Parser::onClass(Token *out, Token *type, Token *name, Token *base,
Token *baseInterface, Token *stmt) {
StatementListPtr stmtList;
if (stmt->stmt) {
stmtList = dynamic_pointer_cast<StatementList>(stmt->stmt);
}
ClassStatementPtr cls = NEW_STMT_POP_LOC
(ClassStatement, type->num, name->text(), base->text(),
dynamic_pointer_cast<ExpressionList>(baseInterface->exp),
popComment(), stmtList);
out->stmt = cls;
cls->onParse(m_ar);
}
void Parser::onClassStart(int type, Token &name, Token *parent) {
if (name.text() == "self" || name.text() == "parent" ||
Construct::GetTypeHintTypes().find(name.text()) !=
Construct::GetTypeHintTypes().end()) {
raise_error("Cannot use '%s' as class name as it is reserved: %s",
name.text().c_str(), getMessage().c_str());
}
ClassStatementPtr cs = NEW_STMT(Class, name.text(),
parent ? parent->text() : "", m_scanner.detachDocComment());
pushClass(cs);
int mod = 0;
if (type == T_ABSTRACT) mod = ClassStatement::Abstract;
else if (type == T_FINAL) mod = ClassStatement::Final;
else if (type == T_INTERFACE) mod = ClassStatement::Interface;
cs->setModifiers(mod);
}
void ClassScope::findTraitMethodsToImport(AnalysisResultPtr ar,
ClassScopePtr trait) {
assert(Option::WholeProgram);
ClassStatementPtr tStmt =
dynamic_pointer_cast<ClassStatement>(trait->getStmt());
StatementListPtr tStmts = tStmt->getStmts();
if (!tStmts) return;
for (int s = 0; s < tStmts->getCount(); s++) {
MethodStatementPtr meth =
dynamic_pointer_cast<MethodStatement>((*tStmts)[s]);
if (meth) {
TraitMethod traitMethod(trait, meth, ModifierExpressionPtr(),
MethodStatementPtr());
addImportTraitMethod(traitMethod, meth->getName());
}
}
}
MethodStatementPtr
ClassScope::findTraitMethod(AnalysisResultPtr ar,
ClassScopePtr trait,
const string &methodName,
std::set<ClassScopePtr> &visitedTraits) {
if (visitedTraits.find(trait) != visitedTraits.end()) {
return MethodStatementPtr();
}
visitedTraits.insert(trait);
ClassStatementPtr tStmt =
dynamic_pointer_cast<ClassStatement>(trait->getStmt());
StatementListPtr tStmts = tStmt->getStmts();
// Look in the current trait
for (int s = 0; s < tStmts->getCount(); s++) {
MethodStatementPtr meth =
dynamic_pointer_cast<MethodStatement>((*tStmts)[s]);
if (meth) { // Handle methods
if (meth->getName() == methodName) {
return meth;
}
}
}
// Look into children traits
for (int s = 0; s < tStmts->getCount(); s++) {
UseTraitStatementPtr useTraitStmt =
dynamic_pointer_cast<UseTraitStatement>((*tStmts)[s]);
if (useTraitStmt) {
vector<string> usedTraits;
useTraitStmt->getUsedTraitNames(usedTraits);
for (unsigned i = 0; i < usedTraits.size(); i++) {
MethodStatementPtr foundMethod =
findTraitMethod(ar, ar->findClass(usedTraits[i]), methodName,
visitedTraits);
if (foundMethod) return foundMethod;
}
}
}
return MethodStatementPtr(); // not found
}
void ClassScope::importTraitProperties(AnalysisResultPtr ar) {
for (unsigned i = 0; i < m_usedTraitNames.size(); i++) {
ClassScopePtr tCls = ar->findClass(m_usedTraitNames[i]);
if (!tCls) continue;
ClassStatementPtr tStmt =
dynamic_pointer_cast<ClassStatement>(tCls->getStmt());
StatementListPtr tStmts = tStmt->getStmts();
if (!tStmts) continue;
for (int s = 0; s < tStmts->getCount(); s++) {
ClassVariablePtr prop =
dynamic_pointer_cast<ClassVariable>((*tStmts)[s]);
if (prop) {
ClassVariablePtr cloneProp = dynamic_pointer_cast<ClassVariable>(
dynamic_pointer_cast<ClassStatement>(m_stmt)->addClone(prop));
cloneProp->resetScope(shared_from_this());
cloneProp->addTraitPropsToScope(ar,
dynamic_pointer_cast<ClassScope>(shared_from_this()));
}
}
}
}
void Parser::saveParseTree(Token &tree) {
StatementListStatementPtr s = tree->getStmtList();
// Reorder so that classes and funcs are first.
if (s) {
std::vector<StatementPtr> scopes;
std::vector<StatementPtr> rest;
const std::vector<StatementPtr> &svec = s->stmts();
for (std::vector<StatementPtr>::const_iterator it = svec.begin();
it != svec.end(); ++it) {
ClassStatementPtr cs = (*it)->unsafe_cast<ClassStatement>();
if (cs || (*it)->unsafe_cast<FunctionStatement>()) {
scopes.push_back(*it);
} else {
rest.push_back(*it);
}
if (cs) {
rest.push_back(cs->getMarker());
}
}
rest.insert(rest.begin(), scopes.begin(), scopes.end());
m_tree = StatementPtr(new StatementListStatement(this, rest));
// Classes that have a parent declared after them must be evaluated at
// the marker position. I don't know why.
hphp_const_char_map<bool> seen;
for (int i = svec.size() - 1; i >= 0; --i) {
ClassStatementPtr cs = svec[i]->unsafe_cast<ClassStatement>();
if (cs) {
seen[cs->name().c_str()] = true;
if (!cs->parent().empty()) {
if (seen.find(cs->parent().c_str()) != seen.end()) {
cs->delayDeclaration();
}
}
}
}
} else {
m_tree = tree->stmt();
}
if (!m_tree) {
m_tree = NEW_STMT0(StatementList);
}
}
void Parser::onClassConstant(Token &out, Token *exprs, Token &name,
Token &val) {
ClassStatementPtr cs = peekClass();
cs->addConstant(name.text(), val->exp());
}
void Parser::onClassVariableStart(Token &mods) {
ClassStatementPtr cs = peekClass();
cs->setModifiers(mods.num);
}
