void ClassStatement::onParse(AnalysisResultPtr ar) {
ClassScope::KindOf kindOf = ClassScope::KindOfObjectClass;
switch (m_type) {
case T_CLASS: kindOf = ClassScope::KindOfObjectClass; break;
case T_ABSTRACT: kindOf = ClassScope::KindOfAbstractClass; break;
case T_FINAL: kindOf = ClassScope::KindOfFinalClass; break;
default:
ASSERT(false);
}
vector<string> bases;
if (!m_parent.empty()) {
bases.push_back(m_parent);
ar->addNonFinal(m_parent);
}
if (m_base) m_base->getStrings(bases);
StatementPtr stmt = dynamic_pointer_cast<Statement>(shared_from_this());
ClassScopePtr classScope(new ClassScope(kindOf, m_originalName, m_parent,
bases, m_docComment,
stmt, ar->getFileScope()));
m_classScope = classScope;
if (!ar->getFileScope()->addClass(ar, classScope)) {
m_ignored = true;
return;
}
ar->recordClassSource(m_name, ar->getFileScope()->getName());
if (m_stmt) {
ar->pushScope(classScope);
bool seenConstruct = false;
for (int i = 0; i < m_stmt->getCount(); i++) {
MethodStatementPtr meth =
dynamic_pointer_cast<MethodStatement>((*m_stmt)[i]);
if (meth && meth->getName() == "__construct") {
seenConstruct = true;
break;
}
}
for (int i = 0; i < m_stmt->getCount(); i++) {
if (!seenConstruct) {
MethodStatementPtr meth =
dynamic_pointer_cast<MethodStatement>((*m_stmt)[i]);
if (meth && classScope && meth->getName() == classScope->getName()
&& !meth->getModifiers()->isStatic()) {
// class-name constructor
classScope->setAttribute(ClassScope::classNameConstructor);
}
}
IParseHandlerPtr ph = dynamic_pointer_cast<IParseHandler>((*m_stmt)[i]);
ph->onParse(ar);
}
ar->popScope();
}
}
MethodStatementPtr
ClassScope::importTraitMethod(const TraitMethod& traitMethod,
AnalysisResultPtr ar,
string methName,
const std::map<string, MethodStatementPtr>&
importedTraitMethods) {
MethodStatementPtr meth = traitMethod.m_method;
string origMethName = traitMethod.m_originalName;
ModifierExpressionPtr modifiers = traitMethod.m_modifiers;
MethodStatementPtr cloneMeth = dynamic_pointer_cast<MethodStatement>(
dynamic_pointer_cast<ClassStatement>(m_stmt)->addClone(meth));
cloneMeth->setName(methName);
cloneMeth->setOriginalName(origMethName);
// Note: keep previous modifiers if none specified when importing the trait
if (modifiers && modifiers->getCount()) {
cloneMeth->setModifiers(modifiers);
}
FunctionScopePtr funcScope = meth->getFunctionScope();
// Trait method typehints, self and parent, need to be converted
ClassScopePtr cScope = dynamic_pointer_cast<ClassScope>(shared_from_this());
cloneMeth->fixupSelfAndParentTypehints( cScope );
FunctionScopePtr cloneFuncScope
(new HPHP::FunctionScope(funcScope, ar, methName, origMethName, cloneMeth,
cloneMeth->getModifiers(), cScope->isUserClass()));
cloneMeth->resetScope(cloneFuncScope, true);
cloneFuncScope->setOuterScope(shared_from_this());
informClosuresAboutScopeClone(cloneMeth, cloneFuncScope, ar);
cloneMeth->addTraitMethodToScope(ar,
dynamic_pointer_cast<ClassScope>(shared_from_this()));
// Preserve original filename (as this varies per-function and not per-unit
// in the case of methods imported from flattened traits)
cloneMeth->setOriginalFilename(meth->getFileScope()->getName());
return cloneMeth;
}
void ClassStatement::onParse(AnalysisResultConstPtr ar, FileScopePtr fs) {
ClassScope::KindOf kindOf = ClassScope::KindOfObjectClass;
switch (m_type) {
case T_CLASS: kindOf = ClassScope::KindOfObjectClass; break;
case T_ABSTRACT: kindOf = ClassScope::KindOfAbstractClass; break;
case T_FINAL: kindOf = ClassScope::KindOfFinalClass; break;
default:
ASSERT(false);
}
vector<string> bases;
if (!m_parent.empty()) {
bases.push_back(m_parent);
}
if (m_base) m_base->getStrings(bases);
StatementPtr stmt = dynamic_pointer_cast<Statement>(shared_from_this());
ClassScopePtr classScope(new ClassScope(kindOf, m_originalName, m_parent,
bases, m_docComment,
stmt));
setBlockScope(classScope);
if (!fs->addClass(ar, classScope)) {
m_ignored = true;
return;
}
if (m_stmt) {
bool seenConstruct = false;
// flatten continuation StatementList into MethodStatements
for (int i = 0; i < m_stmt->getCount(); i++) {
StatementListPtr stmts =
dynamic_pointer_cast<StatementList>((*m_stmt)[i]);
if (stmts) {
m_stmt->removeElement(i);
for (int j = 0; j < stmts->getCount(); j++) {
m_stmt->insertElement((*stmts)[j], i + j);
}
}
}
for (int i = 0; i < m_stmt->getCount(); i++) {
MethodStatementPtr meth =
dynamic_pointer_cast<MethodStatement>((*m_stmt)[i]);
if (meth && meth->getName() == "__construct") {
seenConstruct = true;
break;
}
}
for (int i = 0; i < m_stmt->getCount(); i++) {
if (!seenConstruct) {
MethodStatementPtr meth =
dynamic_pointer_cast<MethodStatement>((*m_stmt)[i]);
if (meth && classScope && meth->getName() == classScope->getName()
&& !meth->getModifiers()->isStatic()) {
// class-name constructor
classScope->setAttribute(ClassScope::ClassNameConstructor);
}
}
IParseHandlerPtr ph = dynamic_pointer_cast<IParseHandler>((*m_stmt)[i]);
ph->onParseRecur(ar, classScope);
}
}
}
void ClassStatement::onParse(AnalysisResultConstPtr ar, FileScopePtr fs) {
ClassScope::KindOf kindOf = ClassScope::KindOfObjectClass;
switch (m_type) {
case T_CLASS: kindOf = ClassScope::KindOfObjectClass; break;
case T_ABSTRACT: kindOf = ClassScope::KindOfAbstractClass; break;
case T_FINAL: kindOf = ClassScope::KindOfFinalClass; break;
case T_TRAIT: kindOf = ClassScope::KindOfTrait; break;
default:
assert(false);
}
vector<string> bases;
if (!m_originalParent.empty()) {
bases.push_back(m_originalParent);
}
if (m_base) m_base->getOriginalStrings(bases);
for (auto &b : bases) {
ar->parseOnDemandByClass(Util::toLower(b));
}
vector<UserAttributePtr> attrs;
if (m_attrList) {
for (int i = 0; i < m_attrList->getCount(); ++i) {
UserAttributePtr a =
dynamic_pointer_cast<UserAttribute>((*m_attrList)[i]);
attrs.push_back(a);
}
}
StatementPtr stmt = dynamic_pointer_cast<Statement>(shared_from_this());
ClassScopePtr classScope(new ClassScope(kindOf, m_originalName,
m_originalParent,
bases, m_docComment,
stmt, attrs));
setBlockScope(classScope);
if (!fs->addClass(ar, classScope)) {
m_ignored = true;
return;
}
if (Option::PersistenceHook) {
classScope->setPersistent(Option::PersistenceHook(classScope, fs));
}
if (m_stmt) {
MethodStatementPtr constructor;
// flatten continuation StatementList into MethodStatements
for (int i = 0; i < m_stmt->getCount(); i++) {
StatementListPtr stmts =
dynamic_pointer_cast<StatementList>((*m_stmt)[i]);
if (stmts) {
m_stmt->removeElement(i);
for (int j = 0; j < stmts->getCount(); j++) {
m_stmt->insertElement((*stmts)[j], i + j);
}
}
}
for (int i = 0; i < m_stmt->getCount(); i++) {
MethodStatementPtr meth =
dynamic_pointer_cast<MethodStatement>((*m_stmt)[i]);
if (meth && meth->getName() == "__construct") {
constructor = meth;
break;
}
}
for (int i = 0; i < m_stmt->getCount(); i++) {
if (!constructor) {
MethodStatementPtr meth =
dynamic_pointer_cast<MethodStatement>((*m_stmt)[i]);
if (meth && meth->getName() == classScope->getName()
&& !classScope->isTrait()) {
// class-name constructor
constructor = meth;
classScope->setAttribute(ClassScope::ClassNameConstructor);
}
}
IParseHandlerPtr ph = dynamic_pointer_cast<IParseHandler>((*m_stmt)[i]);
ph->onParseRecur(ar, classScope);
}
if (constructor && constructor->getModifiers()->isStatic()) {
constructor->parseTimeFatal(Compiler::InvalidAttribute,
"Constructor %s::%s() cannot be static",
classScope->getOriginalName().c_str(),
constructor->getOriginalName().c_str());
}
}
}
void ClassStatement::onParse(AnalysisResultConstPtr ar, FileScopePtr fs) {
ClassScope::KindOf kindOf = ClassScope::KindOf::ObjectClass;
switch (m_type) {
case T_CLASS: kindOf = ClassScope::KindOf::ObjectClass; break;
case T_ABSTRACT: kindOf = ClassScope::KindOf::AbstractClass; break;
case T_STATIC: // Slight hack: see comments in hphp.y
kindOf = ClassScope::KindOf::UtilClass; break;
case T_FINAL: kindOf = ClassScope::KindOf::FinalClass; break;
case T_TRAIT: kindOf = ClassScope::KindOf::Trait; break;
case T_ENUM: kindOf = ClassScope::KindOf::Enum; break;
default:
assert(false);
}
std::vector<std::string> bases;
if (!m_originalParent.empty()) {
bases.push_back(m_originalParent);
}
if (m_base) m_base->getStrings(bases);
for (auto &b : bases) {
ar->parseOnDemandByClass(b);
}
std::vector<UserAttributePtr> attrs;
if (m_attrList) {
for (int i = 0; i < m_attrList->getCount(); ++i) {
UserAttributePtr a =
dynamic_pointer_cast<UserAttribute>((*m_attrList)[i]);
attrs.push_back(a);
}
}
StatementPtr stmt = dynamic_pointer_cast<Statement>(shared_from_this());
auto classScope = std::make_shared<ClassScope>(
fs, kindOf, m_originalName,
m_originalParent,
bases, m_docComment,
stmt, attrs);
setBlockScope(classScope);
if (!fs->addClass(ar, classScope)) {
m_ignored = true;
return;
}
classScope->setPersistent(false);
if (m_stmt) {
MethodStatementPtr constructor = nullptr;
MethodStatementPtr destructor = nullptr;
MethodStatementPtr clone = nullptr;
// flatten continuation StatementList into MethodStatements
for (int i = 0; i < m_stmt->getCount(); i++) {
StatementListPtr stmts =
dynamic_pointer_cast<StatementList>((*m_stmt)[i]);
if (stmts) {
m_stmt->removeElement(i);
for (int j = 0; j < stmts->getCount(); j++) {
m_stmt->insertElement((*stmts)[j], i + j);
}
}
}
for (int i = 0; i < m_stmt->getCount(); i++) {
MethodStatementPtr meth =
dynamic_pointer_cast<MethodStatement>((*m_stmt)[i]);
if (meth) {
if (meth->isNamed("__construct")) {
constructor = meth;
continue;
}
if (meth->isNamed("__destruct")) {
destructor = meth;
continue;
}
if (meth->isNamed("__clone")) {
clone = meth;
continue;
}
}
if (constructor && destructor && clone) {
break;
}
}
for (int i = 0; i < m_stmt->getCount(); i++) {
if (!constructor) {
MethodStatementPtr meth =
dynamic_pointer_cast<MethodStatement>((*m_stmt)[i]);
if (meth &&
meth->isNamed(classScope->getOriginalName()) &&
!classScope->isTrait()) {
// class-name constructor
constructor = meth;
classScope->setAttribute(ClassScope::ClassNameConstructor);
}
}
IParseHandlerPtr ph = dynamic_pointer_cast<IParseHandler>((*m_stmt)[i]);
ph->onParseRecur(ar, fs, classScope);
}
if (constructor && constructor->getModifiers()->isStatic()) {
constructor->parseTimeFatal(fs,
Compiler::InvalidAttribute,
"Constructor %s::%s() cannot be static",
classScope->getOriginalName().c_str(),
constructor->getOriginalName().c_str());
}
if (destructor && destructor->getModifiers()->isStatic()) {
destructor->parseTimeFatal(fs,
Compiler::InvalidAttribute,
"Destructor %s::%s() cannot be static",
classScope->getOriginalName().c_str(),
destructor->getOriginalName().c_str());
}
if (clone && clone->getModifiers()->isStatic()) {
clone->parseTimeFatal(fs,
Compiler::InvalidAttribute,
"Clone method %s::%s() cannot be static",
classScope->getOriginalName().c_str(),
clone->getOriginalName().c_str());
}
}
}