C++ FullySpecifiedType::isFunctionType方法代码示例

Icons::IconType Icons::iconTypeForSymbol(const Symbol *symbol)
{
    if (const Template *templ = symbol->asTemplate()) {
        if (Symbol *decl = templ->declaration())
            return iconTypeForSymbol(decl);
    }

    FullySpecifiedType symbolType = symbol->type();
    if (symbol->isFunction() || (symbol->isDeclaration() && symbolType &&
                                 symbolType->isFunctionType()))
    {
        const Function *function = symbol->asFunction();
        if (!function)
            function = symbol->type()->asFunctionType();

        if (function->isSlot()) {
            if (function->isPublic())
                return SlotPublicIconType;
            else if (function->isProtected())
                return SlotProtectedIconType;
            else if (function->isPrivate())
                return SlotPrivateIconType;
        } else if (function->isSignal()) {
            return SignalIconType;
        } else if (symbol->isPublic()) {
            return FuncPublicIconType;
        } else if (symbol->isProtected()) {
            return FuncProtectedIconType;
        } else if (symbol->isPrivate()) {
            return FuncPrivateIconType;
        }
    } else if (symbol->enclosingScope() && symbol->enclosingScope()->isEnum()) {
        return EnumeratorIconType;
    } else if (symbol->isDeclaration() || symbol->isArgument()) {
        if (symbol->isPublic())
            return VarPublicIconType;
        else if (symbol->isProtected())
            return VarProtectedIconType;
        else if (symbol->isPrivate())
            return VarPrivateIconType;
    } else if (symbol->isEnum()) {
        return EnumIconType;
    } else if (symbol->isClass() || symbol->isForwardClassDeclaration()) {
        return ClassIconType;
    } else if (symbol->isObjCClass() || symbol->isObjCForwardClassDeclaration()) {
        return ClassIconType;
    } else if (symbol->isObjCProtocol() || symbol->isObjCForwardProtocolDeclaration()) {
        return ClassIconType;
    } else if (symbol->isObjCMethod()) {
        return FuncPublicIconType;
    } else if (symbol->isNamespace()) {
        return NamespaceIconType;
    } else if (symbol->isTypenameArgument()) {
        return ClassIconType;
    } else if (symbol->isUsingNamespaceDirective() ||
               symbol->isUsingDeclaration()) {
        // TODO: Might be nice to have a different icons for these things
        return NamespaceIconType;
    }

    return UnknownIconType;
}

bool CheckDeclaration::visit(FunctionDefinitionAST *ast)
{
    FullySpecifiedType ty = semantic()->check(ast->decl_specifier_seq, _scope);
    FullySpecifiedType qualTy = ty.qualifiedType();
    Name *name = 0;
    FullySpecifiedType funTy = semantic()->check(ast->declarator, qualTy,
                                                 _scope, &name);
    if (! (funTy && funTy->isFunctionType())) {
        translationUnit()->error(ast->firstToken(),
                                 "expected a function prototype");
        return false;
    }

    Function *fun = funTy->asFunctionType();
    fun->setVirtual(ty.isVirtual());
    fun->setStartOffset(tokenAt(ast->firstToken()).offset);
    fun->setEndOffset(tokenAt(ast->lastToken()).offset);
    if (ast->declarator)
        fun->setSourceLocation(ast->declarator->firstToken());
    fun->setName(name);
    fun->setTemplateParameters(_templateParameters);
    fun->setVisibility(semantic()->currentVisibility());
    fun->setMethodKey(semantic()->currentMethodKey());

    const bool isQ_SLOT   = ast->qt_invokable_token && tokenKind(ast->qt_invokable_token) == T_Q_SLOT;
    const bool isQ_SIGNAL = ast->qt_invokable_token && tokenKind(ast->qt_invokable_token) == T_Q_SIGNAL;

    if (isQ_SIGNAL)
        fun->setMethodKey(Function::SignalMethod);
    else if (isQ_SLOT)
        fun->setMethodKey(Function::SlotMethod);

    checkFunctionArguments(fun);

    ast->symbol = fun;
    _scope->enterSymbol(fun);

    if (! semantic()->skipFunctionBodies()) {
        if (ast->ctor_initializer) {
            bool looksLikeCtor = false;
            if (ty.isValid() || ! fun->identity())
                looksLikeCtor = false;
            else if (fun->identity()->isNameId() || fun->identity()->isTemplateNameId())
                looksLikeCtor = true;

            if (! looksLikeCtor) {
                translationUnit()->error(ast->ctor_initializer->firstToken(),
                                         "only constructors take base initializers");
            }
            accept(ast->ctor_initializer);
        }

        const int previousVisibility = semantic()->switchVisibility(Symbol::Public);
        const int previousMethodKey = semantic()->switchMethodKey(Function::NormalMethod);

        semantic()->check(ast->function_body, fun->members());

        semantic()->switchMethodKey(previousMethodKey);
        semantic()->switchVisibility(previousVisibility);
    }

    return false;
}

SymbolInfo::ElementType SymbolInfo::elementTypeFromSymbol( const CPlusPlus::Symbol *symbol )
{
	if (const Template *templ = symbol->asTemplate()) {
		if (Symbol *decl = templ->declaration())
			return elementTypeFromSymbol(decl);
	}

	FullySpecifiedType symbolType = symbol->type();
	if (symbol->isFunction() || (symbol->isDeclaration() && symbolType &&
		symbolType->isFunctionType()))
	{
		const CPlusPlus::Function *func = symbol->asFunction();
		if (!func)
			func = symbol->type()->asFunctionType();

		if (func->isSlot() ) {
			if (func->isPublic())
				return SymbolInfo::SlotPublic;
			else if (func->isProtected())
				return SymbolInfo::SlotProtected;
			else if (func->isPrivate())
				return SymbolInfo::SlotPrivate;
		} else if (func->isSignal()) {
			return SymbolInfo::Signal;
		} else if (symbol->isPublic()) {
			return SymbolInfo::FuncPublic;
		} else if (symbol->isProtected()) {
			return SymbolInfo::FuncProtected;
		} else if (symbol->isPrivate()) {
			return SymbolInfo::FuncPrivate;
		}
	} else if (symbol->enclosingScope() && symbol->enclosingScope()->isEnum()) {
		return SymbolInfo::Enumerator;
	} else if (symbol->isDeclaration() || symbol->isArgument()) {
		if (symbol->isPublic())
			return SymbolInfo::VarPublic;
		else if (symbol->isProtected())
			return SymbolInfo::VarProtected;
		else if (symbol->isPrivate())
			return SymbolInfo::VarPrivate;
	} else if (symbol->isEnum()) {
		return SymbolInfo::Enum;
	} else if (symbol->isClass() || symbol->isForwardClassDeclaration()) {
		return SymbolInfo::Class;
	} else if (symbol->isObjCClass() || symbol->isObjCForwardClassDeclaration()) {
		return SymbolInfo::Class;
	} else if (symbol->isObjCProtocol() || symbol->isObjCForwardProtocolDeclaration()) {
		return SymbolInfo::Class;
	} else if (symbol->isObjCMethod()) {
		return SymbolInfo::FuncPublic;
	} else if (symbol->isNamespace()) {
		return SymbolInfo::Namespace;
	} else if (symbol->isTypenameArgument()) {
		return SymbolInfo::Class;
	} else if (symbol->isUsingNamespaceDirective() ||
		symbol->isUsingDeclaration()) {
			// TODO: Might be nice to have a different icons for these things
			return SymbolInfo::Namespace;
	} else if (symbol->isBlock()){
		return SymbolInfo::Block;
	}

	return SymbolInfo::Unknown;
}