SymbolResolver Class Reference

#include <src/symbolresolver.h>

Classes
struct	Private

Public Member Functions
	SymbolResolver (const FileDef *fileScope=nullptr)
	~SymbolResolver ()
const ClassDef *	resolveClass (const Definition *scope, const QCString &name, bool maybeUnlinkable=false, bool mayBeHidden=false)
	Find the class definition matching name within the scope set.
ClassDefMutable *	resolveClassMutable (const Definition *scope, const QCString &name, bool mayBeUnlinkable=false, bool mayBeHidden=false)
	Wrapper around resolveClass that returns a mutable interface to the class object or a nullptr if the symbol is immutable.
const Definition *	resolveSymbol (const Definition *scope, const QCString &name, const QCString &args=QCString(), bool checkCV=false, bool insideCode=false, bool onlyLinkable=false)
	Find the symbool definition matching name within the scope set.
int	isAccessibleFrom (const Definition *scope, const Definition *item)
	Checks if symbol item is accessible from within scope.
int	isAccessibleFromWithExpScope (const Definition *scope, const Definition *item, const QCString &explicitScopePart)
	Check if symbol item is accessible from within scope, where it has to match the explicitScopePart.
void	setFileScope (const FileDef *fd)
	Sets or updates the file scope using when resolving symbols.
const MemberDef *	getTypedef () const
	In case a call to resolveClass() resolves to a type member (e.g.
QCString	getTemplateSpec () const
	In case a call to resolveClass() points to a template specialization, the template part is return via this method.
QCString	getResolvedType () const
	In case a call to resolveClass() points to a typedef or using declaration.

Private Attributes
std::unique_ptr< Private >	p

Detailed Description

Helper class to find a class definition or check if A symbol is accessible in a given scope.

Definition at line 31 of file symbolresolver.h.

Constructor & Destructor Documentation

SymbolResolver()

SymbolResolver::SymbolResolver ( const FileDef * fileScope = nullptr )

explicit

Definition at line 1615 of file symbolresolver.cpp.

  : p(std::make_unique<Private>(fileScope))
{
}

References p.

~SymbolResolver()

SymbolResolver::~SymbolResolver

(

)

Definition at line 1620 of file symbolresolver.cpp.

{
}

Member Function Documentation

getResolvedType()

QCString SymbolResolver::getResolvedType

(

)

const

In case a call to resolveClass() points to a typedef or using declaration.

The type name it resolved to is returned via this method.

Definition at line 1737 of file symbolresolver.cpp.

{
  return p->resolvedType;
}

References p.

Referenced by getCanonicalTypeForIdentifier(), and SymbolResolver::Private::getResolvedTypeRec().

getTemplateSpec()

QCString SymbolResolver::getTemplateSpec

(

)

const

In case a call to resolveClass() points to a template specialization, the template part is return via this method.

Definition at line 1732 of file symbolresolver.cpp.

{
  return p->templateSpec;
}

References p.

Referenced by findClassRelation(), and getCanonicalTypeForIdentifier().

getTypedef()

const MemberDef * SymbolResolver::getTypedef

(

)

const

In case a call to resolveClass() resolves to a type member (e.g.

an enum) this method will return it.

Definition at line 1727 of file symbolresolver.cpp.

{
  return p->typeDef;
}

References p.

Referenced by findClassRelation(), getCanonicalTypeForIdentifier(), and linkifyText().

isAccessibleFrom()

int SymbolResolver::isAccessibleFrom	(	const Definition *	scope,
		const Definition *	item )

Checks if symbol item is accessible from within scope.

Returns

-1 if item is not accessible or a number indicating how many scope levels up the nearest match was found.

Definition at line 1696 of file symbolresolver.cpp.

{
  AUTO_TRACE("scope={} item={}",
      scope?scope->name():QCString(), item?item->name():QCString());
  p->reset();
  VisitedKeys visitedKeys;
  AccessStack accessStack;
  int result = p->isAccessibleFrom(visitedKeys,accessStack,scope,item);
  AUTO_TRACE_EXIT("result={}",result);
  return result;
}

References AUTO_TRACE, AUTO_TRACE_EXIT, Definition::name(), and p.

Referenced by SymbolResolver::Private::isAccessibleFrom(), SymbolResolver::Private::isAccessibleFromWithExpScope(), and resolveTypeDef().

isAccessibleFromWithExpScope()

int SymbolResolver::isAccessibleFromWithExpScope	(	const Definition *	scope,
		const Definition *	item,
		const QCString &	explicitScopePart )

Check if symbol item is accessible from within scope, where it has to match the explicitScopePart.

Returns

-1 if item is not accessible or a number indicating how many scope levels up the nearest match was found.

Definition at line 1708 of file symbolresolver.cpp.

{
  AUTO_TRACE("scope={} item={} explicitScopePart={}",
      scope?scope->name():QCString(), item?item->name():QCString(), explicitScopePart);
  p->reset();
  VisitedKeys visitedKeys;
  VisitedNamespaces visitedNamespaces;
  AccessStack accessStack;
  int result = p->isAccessibleFromWithExpScope(visitedKeys,visitedNamespaces,accessStack,scope,item,explicitScopePart);
  AUTO_TRACE_EXIT("result={}",result);
  return result;
}

References AUTO_TRACE, AUTO_TRACE_EXIT, Definition::name(), and p.

Referenced by getMemberFromSymbol(), SymbolResolver::Private::getResolvedSymbol(), SymbolResolver::Private::getResolvedType(), SymbolResolver::Private::isAccessibleFromWithExpScope(), and SymbolResolver::Private::substTypedef().

resolveClass()

const ClassDef * SymbolResolver::resolveClass	(	const Definition *	scope,
		const QCString &	name,
		bool	maybeUnlinkable = false,
		bool	mayBeHidden = false )

Find the class definition matching name within the scope set.

Parameters

scope	The scope to search from.
name	The name of the symbol.
maybeUnlinkable	include unlinkable symbols in the search.
mayBeHidden	include hidden symbols in the search.

Note

As a result of this call the getters getTypedef(), getTemplateSpec(), and getResolvedType() are set as well.

Definition at line 1625 of file symbolresolver.cpp.

{
  AUTO_TRACE("scope={} name={} mayBeUnlinkable={} mayBeHidden={}",
      scope?scope->name():QCString(), name, mayBeUnlinkable, mayBeHidden);
  p->reset();
 
  auto lang = scope ? scope->getLanguage() :
          p->fileScope() ? p->fileScope()->getLanguage() :
          SrcLangExt::Cpp;  // fallback to C++
 
  if (scope==nullptr ||
      (scope->definitionType()!=Definition::TypeClass &&
       scope->definitionType()!=Definition::TypeNamespace
      ) ||
      (name.stripWhiteSpace().startsWith("::")) ||
      ((lang==SrcLangExt::Java || lang==SrcLangExt::CSharp) && QCString(name).find("::")!=-1)
     )
  {
    scope=Doxygen::globalScope;
  }
  const ClassDef *result=nullptr;
  if (Config_getBool(OPTIMIZE_OUTPUT_VHDL))
  {
    result = getClass(name);
  }
  else
  {
    VisitedKeys visitedKeys;
    QCString lookupName = lang==SrcLangExt::CSharp ? mangleCSharpGenericName(name) : name;
    AUTO_TRACE_ADD("lookup={}",lookupName);
    result = p->getResolvedTypeRec(visitedKeys,scope,lookupName,&p->typeDef,&p->templateSpec,&p->resolvedType);
    if (result==nullptr) // for nested classes imported via tag files, the scope may not
                   // present, so we check the class name directly as well.
                   // See also bug701314
    {
      result = getClass(lookupName);
    }
  }
  if (!mayBeUnlinkable && result && !result->isLinkable())
  {
    if (!mayBeHidden || !result->isHidden())
    {
      AUTO_TRACE_ADD("hiding symbol {}",result->name());
      result=nullptr; // don't link to artificial/hidden classes unless explicitly allowed
    }
  }
  AUTO_TRACE_EXIT("result={}",result?result->name():QCString());
  return result;
}

References AUTO_TRACE, AUTO_TRACE_ADD, AUTO_TRACE_EXIT, Config_getBool, Definition::definitionType(), getClass(), Definition::getLanguage(), Doxygen::globalScope, Definition::isHidden(), Definition::isLinkable(), mangleCSharpGenericName(), Definition::name(), p, QCString::startsWith(), QCString::stripWhiteSpace(), Definition::TypeClass, and Definition::TypeNamespace.

Referenced by findClassDefinition(), findClassWithinClassContext(), findUsingDeclImports(), getCanonicalTypeForIdentifier(), isVarWithConstructor(), linkifyText(), normalizeNonTemplateArgumentsInString(), and resolveClassMutable().

resolveClassMutable()

ClassDefMutable * SymbolResolver::resolveClassMutable ( const Definition * scope, const QCString & name, bool mayBeUnlinkable = false, bool mayBeHidden = false )

inline

Wrapper around resolveClass that returns a mutable interface to the class object or a nullptr if the symbol is immutable.

Definition at line 57 of file symbolresolver.h.

    {
      return toClassDefMutable(const_cast<ClassDef*>(resolveClass(scope,name,mayBeUnlinkable,mayBeHidden)));
    }

References resolveClass(), and toClassDefMutable().

Referenced by ClassDefImpl::addTypeConstraint(), findClassRelation(), findUsedClassesForClass(), and resolveTemplateInstanceInType().

resolveSymbol()

const Definition * SymbolResolver::resolveSymbol	(	const Definition *	scope,
		const QCString &	name,
		const QCString &	args = QCString(),
		bool	checkCV = false,
		bool	insideCode = false,
		bool	onlyLinkable = false )

Find the symbool definition matching name within the scope set.

Parameters

scope	The scope to search from.
name	The name of the symbol.
args	Argument list associated with the symbol (for functions)
checkCV	Check const/volatile qualifiers (for methods)
insideCode	Is the symbol found in a code fragment
onlyLinkable	Only search linkable definitions

Definition at line 1678 of file symbolresolver.cpp.

{
  AUTO_TRACE("scope={} name={} args={} checkCV={} insideCode={}",
             scope?scope->name():QCString(), name, args, checkCV, insideCode);
  p->reset();
  if (scope==nullptr) scope=Doxygen::globalScope;
  VisitedKeys visitedKeys;
  const Definition *result = p->getResolvedSymbolRec(visitedKeys,scope,name,args,checkCV,insideCode,onlyLinkable,&p->typeDef,&p->templateSpec,&p->resolvedType);
  AUTO_TRACE_EXIT("result={}{}", qPrint(result?result->qualifiedName():QCString()),
                                 qPrint(result && result->definitionType()==Definition::TypeMember ? toMemberDef(result)->argsString() : QCString()));
  return result;
}

References AUTO_TRACE, AUTO_TRACE_EXIT, Definition::definitionType(), Doxygen::globalScope, Definition::name(), p, qPrint(), Definition::qualifiedName(), toMemberDef(), and Definition::TypeMember.

Referenced by findUsingDeclarations(), findUsingDeclImports(), and getDefs().

setFileScope()

void SymbolResolver::setFileScope

(

const FileDef *

fd

)

Sets or updates the file scope using when resolving symbols.

Definition at line 1722 of file symbolresolver.cpp.

{
  p->setFileScope(fileScope);
}

References p.

Referenced by getDefs().

Member Data Documentation

p

std::unique_ptr<Private> SymbolResolver::p

private

Definition at line 120 of file symbolresolver.h.

Referenced by getResolvedType(), getTemplateSpec(), getTypedef(), isAccessibleFrom(), isAccessibleFromWithExpScope(), resolveClass(), resolveSymbol(), setFileScope(), and SymbolResolver().

---

The documentation for this class was generated from the following files:

• src/symbolresolver.h
• src/symbolresolver.cpp