void ClassCheck::checkInterfaceVars(
const ClassDefPtr& pClassDef,
const InterfaceDefPtr& pInterfaceDef,
const StaticContextPtr& pRootCtx,
const LogPtr& pLog) const
{
const list<VariableDeclDefPtr>& classVars = pClassDef->getVariableDecls();
const list<VariableDeclDefPtr>& ifaceVars = pInterfaceDef->getVariableDecls();
map<const wstring, VariableDeclDefPtr> classVarsMap;
map<const wstring, VariableDeclDefPtr>::const_iterator mit;
list<VariableDeclDefPtr>::const_iterator cit;
for (cit = classVars.begin(); cit != classVars.end(); cit++)
{
const VariableDeclDefPtr& pVariableDecl = *cit;
classVarsMap[pVariableDecl->getName()] = pVariableDecl;
}
list<VariableDeclDefPtr>::const_iterator iit;
for (iit = ifaceVars.begin(); iit != ifaceVars.end(); iit++)
{
const VariableDeclDefPtr& pIfaceVariableDecl = *iit;
const wstring& variableName = pIfaceVariableDecl->getName();
if ((mit = classVarsMap.find(variableName)) == classVarsMap.end())
{
boost::wformat f(L"Variable %1% defined on interface %2% not found in class.");
f % variableName % pInterfaceDef->getClassName();
pLog->log(*pClassDef, msg::ErrAnaClassDef_MissingIfaceVar, f.str());
continue;
}
const VariableDeclDefPtr& pClassVariableDecl = (*mit).second;
if (pIfaceVariableDecl->isStatic() != pClassVariableDecl->isStatic())
{
boost::wformat f(L"Variable %1% has invalid scope. See interface %2%");
f % variableName % pInterfaceDef->getClassName();
pLog->log(*pClassVariableDecl, msg::ErrAnaClassDef_IfaceVarWrongScope, f.str());
continue;
}
if (!SemanticAnalysis::isTypeAssignableFrom(
pClassVariableDecl->getDeclaredType(),
pIfaceVariableDecl->getDeclaredType(),
pRootCtx))
{
boost::wformat f(L"Can't convert from %1% to %2% at class variable %3% defined on interface %4%");
f % pIfaceVariableDecl->getDeclaredType()->toString()%
pClassVariableDecl->getDeclaredType()->toString() %
variableName %
pInterfaceDef->getClassName();
pLog->log(*pClassVariableDecl, msg::ErrAnaClassDef_IfaceVarIncompTypes, f.str());
continue;
}
}
}
void ClassCheck::doCheck(
const StaticContextPtr& pRootCtx,
const ASTNodePtr& pNode,
const LogPtr& pLog) const
{
if (pNode->getASTNodeType() != ASTN_CLASS)
{
return;
}
ClassDefPtr pClassDef = boost::static_pointer_cast<ClassDef>(pNode);
const list<const wstring>& ifaces = pClassDef->getImplementedInterfaces();
list<const wstring>::const_iterator it;
for (it = ifaces.begin(); it != ifaces.end(); it++)
{
const wstring& ifaceName = *it;
CStaticContextEntryPtr pEntry;
InterfaceDefPtr pInterfaceDef;
if (!pRootCtx->lookup(ifaceName, pEntry))
{
boost::wformat f(L"Interface %1% not found.");
f % ifaceName;
pLog->log(*pClassDef, msg::ErrAnaClassDef_IfaceNotFound, f.str());
continue;
}
else if (!pEntry->getInterface(pInterfaceDef))
{
boost::wformat f(L"%1% is not an interface.");
f % ifaceName;
pLog->log(*pClassDef, msg::ErrAnaClassDef_NotAnIface, f.str());
continue;
}
checkInterfaceParams(pClassDef, pInterfaceDef, pRootCtx, pLog);
checkInterfaceVars(pClassDef, pInterfaceDef, pRootCtx, pLog);
}
const list<VariableDeclDefPtr>& vars = pClassDef->getVariableDecls();
list<VariableDeclDefPtr>::const_iterator vit;
for (vit = vars.begin(); vit != vars.end(); vit++)
{
const VariableDeclDefPtr& pVar = *vit;
if (pVar->getValue().get() == NULL)
{
boost::wformat f(L"Unassigned class variable %1%.");
f % pVar->getName();
pLog->log(*pClassDef, msg::ErrAnaClassDef_UnassignedClassVar, f.str());
continue;
}
}
}
void ClassCheck::checkInterfaceParams(
const ClassDefPtr& pClassDef,
const InterfaceDefPtr& pInterfaceDef,
const StaticContextPtr& pRootCtx,
const LogPtr& pLog) const
{
const map<const wstring, FormalParamDefPtr>& ifaceFormalParams =
pInterfaceDef->getFormalParametersMap();
const map<const wstring, FormalParamDefPtr>& classFormalParams =
pClassDef->getFormalParametersMap();
if (ifaceFormalParams.empty())
{
return;
}
map<const wstring, FormalParamDefPtr>::const_iterator iit;
map<const wstring, FormalParamDefPtr>::const_iterator cit;
for (iit = ifaceFormalParams.begin(); iit != ifaceFormalParams.end(); iit++)
{
const FormalParamDefPtr& pIfaceParam = (*iit).second;
cit = classFormalParams.find(pIfaceParam->getParamName());
if (cit == classFormalParams.end())
{
boost::wformat f(L"Interface parameter %1% not found.");
f % pIfaceParam->getParamName();
pLog->log(*pClassDef, msg::ErrAnaClassDef_MissingIfaceParam, f.str());
continue;
}
const FormalParamDefPtr& pClassParam = (*cit).second;
if (!SemanticAnalysis::isTypeAssignableFrom(
pClassParam->getType(),
pIfaceParam->getType(),
pRootCtx))
{
boost::wformat f(
L"Can't convert from %1% to %2% at class parameter %3% defined on interface %4%.");
f % pIfaceParam->getType()->toString() %
pClassParam->getType()->toString() %
pIfaceParam->getParamName() %
pInterfaceDef->getClassName();
pLog->log(*pClassDef, msg::ErrAnaClassDef_IfaceParamIncompTypes, f.str());
continue;
}
}
for (cit = classFormalParams.begin(); cit != classFormalParams.end(); cit++)
{
const wstring& classParamName = (*cit).first;
iit = ifaceFormalParams.find(classParamName);
if (iit == ifaceFormalParams.end())
{
boost::wformat f(L"Class parameter %1% not defined on interface %2%.");
f % classParamName % pInterfaceDef->getClassName();
pLog->log(*pClassDef, msg::ErrAnaClassDef_ClassParamNotFoundIface, f.str());
continue;
}
}
}
void TypeInference::inferTypes(
ValueDef& valueDef,
StaticContextPtr& pMemberCtx,
const LogPtr& pLog)
{
switch (valueDef.getValueType())
{
case OBJECT_INIT:
{
const ObjectInitValueDef& objectInitDef = static_cast<const ObjectInitValueDef&>(valueDef);
TypePtr pType = TypePtr(
new ReferenceType(OBJECT_REF_TYPE, objectInitDef.getClassName()));
valueDef.setInferredType(pType);
const map<const wstring, ActualParamDefPtr>& actualParamsMap = objectInitDef.getActualParamsMap();
map<const wstring, ActualParamDefPtr>::const_iterator it;
for (it = actualParamsMap.begin(); it != actualParamsMap.end(); it++)
{
const ActualParamDefPtr& pActualParamDef = (*it).second;
const ValueDefPtr& pParamValueDef = pActualParamDef->getValue();
inferTypes(*pParamValueDef, pMemberCtx, pLog);
}
}
break;
case ARRAY_INIT:
{
const ArrayInitValueDef& arrayInitDef = static_cast<const ArrayInitValueDef&>(valueDef);
valueDef.setInferredType(arrayInitDef.getDeclaredType());
const list<ValueDefPtr>& arrayValues = arrayInitDef.getValues();
list<ValueDefPtr>::const_iterator it;
for (it = arrayValues.begin(); it != arrayValues.end(); it++)
{
const ValueDefPtr& pArrayValue = *it;
inferTypes(*pArrayValue, pMemberCtx, pLog);
}
}
break;
case LITERAL:
{
const LiteralValueDef& literalDef = static_cast<const LiteralValueDef&>(valueDef);
switch (literalDef.getLiteralType())
{
case INTEGER_LITERAL:
valueDef.setInferredType(P_INTEGER_TYPE);
break;
case FLOAT_LITERAL:
valueDef.setInferredType(P_FLOAT_TYPE);
break;
case STRING_LITERAL:
valueDef.setInferredType(P_STRING_TYPE);
break;
default:
assert(false);
break;
}
}
break;
case REFERENCE_PATH:
{
const ReferencePathValueDef& referencePathDef = static_cast<const ReferencePathValueDef&>(valueDef);
const list<const wstring>& path = referencePathDef.getReferencePath();
StaticContextEntryPtr pEntry;
TypePtr pCurrentType;
list<const wstring>::const_iterator it;
wstring parentPath(L"");
for (it = path.begin(); it != path.end(); it++)
{
const wstring& pathElement = *it;
if (it == path.begin())
{
CStaticContextEntryPtr pEntry;
if (!pMemberCtx->lookup(pathElement, pEntry))
{
boost::wformat f(L"Unable to resolve name %1%");
f % pathElement;
pLog->log(referencePathDef, msg::ErrAnaTypeInfer_NameNotInContext, f.str());
return;
}
else
{
switch (pEntry->getStaticEntryType())
{
case CLASS_DEF_CTX_ENTRY:
{
TypePtr pType(new ReferenceType(CLASS_REF_TYPE, pEntry->getName()));
pCurrentType = pType;
}
break;
case INTERFACE_DEF_CTX_ENTRY:
{
TypePtr pType(new ReferenceType(CLASS_REF_TYPE, pEntry->getName()));
pCurrentType = pType;
}
break;
case VARIABLE_DEF_CTX_ENTRY:
{
VariableDeclDefPtr pVariableDef;
pEntry->getVariable(pVariableDef);
if (pMemberCtx->isStatic() && !pVariableDef->isStatic())
{
boost::wformat f(L"Cannot refer to a non static variable from an static context: %1%");
f % pathElement;
pLog->log(referencePathDef, msg::ErrAnaTypeInfer_NonStaticVarRef, f.str());
return;
}
else
{
pCurrentType = pVariableDef->getDeclaredType();
}
}
break;
case FORMAL_PARAM_DEF_CTX_ENTRY:
{
if (pMemberCtx->isStatic())
{
boost::wformat f(L"Cannot refer to a class parameter from an static context: %1%");
f % pathElement;
pLog->log(referencePathDef, msg::ErrAnaTypeInfer_NonStaticParamRef, f.str());
return;
}
FormalParamDefPtr pFormalParamDef;
pEntry->getFormalParam(pFormalParamDef);
pCurrentType = pFormalParamDef->getType();
}
break;
default:
assert(false);
return;
}
}
}
else
{
assert(pCurrentType.get() != NULL);
StaticContextPtr pRootCtx;
pMemberCtx->getRootContext(pRootCtx);
if (!followPathElement(
*pCurrentType,
*pRootCtx,
pathElement,
pCurrentType))
{
boost::wformat f(L"%1% is not a member of %2%");
f % pathElement % parentPath;
pLog->log(referencePathDef, msg::ErrAnaTypeInfer_NotAMember, f.str());
return;
}
}
if (parentPath.size())
{
parentPath.append(L".");
}
parentPath.append(pathElement);
}
assert(pCurrentType.get() != NULL);
valueDef.setInferredType(pCurrentType);
}
break;
default:
assert(false);
break;
}
}