qt-creator/src/libs/cplusplus/ResolveExpression.cpp

/**************************************************************************
**
** This file is part of Qt Creator
**
** Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
**
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** Commercial Usage
**
** Licensees holding valid Qt Commercial licenses may use this file in
** accordance with the Qt Commercial License Agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Nokia.
**
** GNU Lesser General Public License Usage
**
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file.  Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** If you are unsure which license is appropriate for your use, please
** contact the sales department at http://qt.nokia.com/contact.
**
**************************************************************************/

#include "ResolveExpression.h"
#include "LookupContext.h"
#include "Overview.h"
#include "GenTemplateInstance.h"

#include <Control.h>
#include <AST.h>
#include <Scope.h>
#include <Names.h>
#include <Symbols.h>
#include <Literals.h>
#include <CoreTypes.h>
#include <TypeVisitor.h>
#include <NameVisitor.h>

#include <QtCore/QList>
#include <QtCore/QtDebug>

using namespace CPlusPlus;

namespace {

template <typename _Tp>
static QList<_Tp> removeDuplicates(const QList<_Tp> &results)
{
    QList<_Tp> uniqueList;
    QSet<_Tp> processed;
    foreach (const _Tp &r, results) {
        if (processed.contains(r))
            continue;

        processed.insert(r);
        uniqueList.append(r);
    }

    return uniqueList;
}

} // end of anonymous namespace

/////////////////////////////////////////////////////////////////////
// ResolveExpression
/////////////////////////////////////////////////////////////////////
ResolveExpression::ResolveExpression(Symbol *lastVisibleSymbol, const LookupContext &context)
    : ASTVisitor(context.expressionDocument()->translationUnit()),
      _lastVisibleSymbol(lastVisibleSymbol),
      _context(context),
      sem(context.expressionDocument()->translationUnit())
{
    if (! lastVisibleSymbol)
        lastVisibleSymbol = context.thisDocument()->globalNamespace();
    _scope = lastVisibleSymbol->scope();
}

ResolveExpression::ResolveExpression(Scope *scope, const LookupContext &context)
    : ASTVisitor(context.expressionDocument()->translationUnit()),
      _lastVisibleSymbol(0),
      _scope(scope),
      _context(context),
      sem(context.expressionDocument()->translationUnit())
{ }

ResolveExpression::~ResolveExpression()
{ }

QList<LookupItem> ResolveExpression::operator()(ExpressionAST *ast)
{
    const QList<LookupItem> previousResults = switchResults(QList<LookupItem>());
    accept(ast);
    return removeDuplicates(switchResults(previousResults));
}

QList<LookupItem>
ResolveExpression::switchResults(const QList<LookupItem> &results)
{
    const QList<LookupItem> previousResults = _results;
    _results = results;
    return previousResults;
}

void ResolveExpression::addResults(const QList<LookupItem> &results)
{
    foreach (const LookupItem r, results)
        addResult(r);
}

void ResolveExpression::addResult(const FullySpecifiedType &ty, Symbol *symbol)
{
    if (! symbol) {
        if (_scope)
            symbol = _scope->owner();

        else
            symbol = _context.thisDocument()->globalNamespace();
    }

    return addResult(LookupItem(ty, symbol));
}

void ResolveExpression::addResult(const LookupItem &r)
{
    Q_ASSERT(r.lastVisibleSymbol() != 0);

    if (! _results.contains(r))
        _results.append(r);
}

bool ResolveExpression::visit(BinaryExpressionAST *ast)
{
    if (tokenKind(ast->binary_op_token) == T_COMMA && ast->right_expression && ast->right_expression->asQtMethod() != 0) {

        if (ast->left_expression && ast->left_expression->asQtMethod() != 0)
            thisObject();
        else
            accept(ast->left_expression);

        QtMethodAST *qtMethod = ast->right_expression->asQtMethod();
        if (DeclaratorAST *d = qtMethod->declarator) {
            if (d->core_declarator) {
                if (DeclaratorIdAST *declaratorId = d->core_declarator->asDeclaratorId())
                    if (NameAST *nameAST = declaratorId->name)
                        _results = resolveMemberExpression(_results, T_ARROW, nameAST->name);
            }
        }

        return false;
    }

    accept(ast->left_expression);
    return false;
}

bool ResolveExpression::visit(CastExpressionAST *ast)
{
    addResult(sem.check(ast->type_id, _context.expressionDocument()->globalSymbols()));
    return false;
}

bool ResolveExpression::visit(ConditionAST *)
{
    // nothing to do.
    return false;
}

bool ResolveExpression::visit(ConditionalExpressionAST *ast)
{
    if (ast->left_expression)
        accept(ast->left_expression);

    else if (ast->right_expression)
        accept(ast->right_expression);

    return false;
}

bool ResolveExpression::visit(CppCastExpressionAST *ast)
{
    addResult(sem.check(ast->type_id, _context.expressionDocument()->globalSymbols()));
    return false;
}

bool ResolveExpression::visit(DeleteExpressionAST *)
{
    FullySpecifiedType ty(control()->voidType());
    addResult(ty);
    return false;
}

bool ResolveExpression::visit(ArrayInitializerAST *)
{
    // nothing to do.
    return false;
}

bool ResolveExpression::visit(NewExpressionAST *ast)
{
    if (ast->new_type_id) {
        Scope *scope = _context.expressionDocument()->globalSymbols();
        FullySpecifiedType ty = sem.check(ast->new_type_id->type_specifier_list, scope);
        ty = sem.check(ast->new_type_id->ptr_operator_list, ty, scope);
        FullySpecifiedType ptrTy(control()->pointerType(ty));
        addResult(ptrTy);
    }
    // nothing to do.
    return false;
}

bool ResolveExpression::visit(TypeidExpressionAST *)
{
    const Name *std_type_info[2];
    std_type_info[0] = control()->nameId(control()->findOrInsertIdentifier("std"));
    std_type_info[1] = control()->nameId(control()->findOrInsertIdentifier("type_info"));

    const Name *q = control()->qualifiedNameId(std_type_info, 2, /*global=*/ true);
    FullySpecifiedType ty(control()->namedType(q));
    addResult(ty);

    return false;
}

bool ResolveExpression::visit(TypenameCallExpressionAST *)
{
    // nothing to do
    return false;
}

bool ResolveExpression::visit(TypeConstructorCallAST *)
{
    // nothing to do.
    return false;
}

bool ResolveExpression::visit(PostfixExpressionAST *ast)
{
    accept(ast->base_expression);

    for (PostfixListAST *it = ast->postfix_expression_list; it; it = it->next) {
        accept(it->value);
    }

    return false;
}

bool ResolveExpression::visit(SizeofExpressionAST *)
{
    FullySpecifiedType ty(control()->integerType(IntegerType::Int));
    ty.setUnsigned(true);
    addResult(ty);
    return false;
}

bool ResolveExpression::visit(NumericLiteralAST *ast)
{
    Type *type = 0;
    const NumericLiteral *literal = numericLiteral(ast->literal_token);

    if (literal->isChar())
        type = control()->integerType(IntegerType::Char);
    else if (literal->isWideChar())
        type = control()->integerType(IntegerType::WideChar);
    else if (literal->isInt())
        type = control()->integerType(IntegerType::Int);
    else if (literal->isLong())
        type = control()->integerType(IntegerType::Long);
    else if (literal->isLongLong())
        type = control()->integerType(IntegerType::LongLong);
    else if (literal->isFloat())
        type = control()->floatType(FloatType::Float);
    else if (literal->isDouble())
        type = control()->floatType(FloatType::Double);
    else if (literal->isLongDouble())
        type = control()->floatType(FloatType::LongDouble);
    else
        type = control()->integerType(IntegerType::Int);

    FullySpecifiedType ty(type);
    if (literal->isUnsigned())
        ty.setUnsigned(true);

    addResult(ty);
    return false;
}

bool ResolveExpression::visit(BoolLiteralAST *)
{
    FullySpecifiedType ty(control()->integerType(IntegerType::Bool));
    addResult(ty);
    return false;
}

bool ResolveExpression::visit(ThisExpressionAST *)
{
    thisObject();
    return false;
}

void ResolveExpression::thisObject()
{
    Scope *scope = _scope;
    for (; scope; scope = scope->enclosingScope()) {
        if (scope->isFunctionScope()) {
            Function *fun = scope->owner()->asFunction();
            if (Scope *cscope = scope->enclosingClassScope()) {
                Class *klass = cscope->owner()->asClass();
                FullySpecifiedType classTy(control()->namedType(klass->name()));
                FullySpecifiedType ptrTy(control()->pointerType(classTy));
                addResult(ptrTy, fun);
                break;
            } else if (const QualifiedNameId *q = fun->name()->asQualifiedNameId()) {
                const Name *nestedNameSpecifier = 0;
                if (q->nameCount() == 1 && q->isGlobal())
                    nestedNameSpecifier = q->nameAt(0);
                else
                    nestedNameSpecifier = control()->qualifiedNameId(q->names(), q->nameCount() - 1);
                FullySpecifiedType classTy(control()->namedType(nestedNameSpecifier));
                FullySpecifiedType ptrTy(control()->pointerType(classTy));
                addResult(ptrTy, fun);
                break;
            }
        }
    }
}

bool ResolveExpression::visit(CompoundExpressionAST *ast)
{
    CompoundStatementAST *cStmt = ast->statement;
    if (cStmt && cStmt->statement_list) {
        accept(cStmt->statement_list->lastValue());
    }
    return false;
}

bool ResolveExpression::visit(NestedExpressionAST *ast)
{
    accept(ast->expression);
    return false;
}

bool ResolveExpression::visit(StringLiteralAST *)
{
    FullySpecifiedType charTy = control()->integerType(IntegerType::Char);
    charTy.setConst(true);
    FullySpecifiedType ty(control()->pointerType(charTy));
    addResult(ty);
    return false;
}

bool ResolveExpression::visit(ThrowExpressionAST *)
{
    return false;
}

bool ResolveExpression::visit(TypeIdAST *)
{
    return false;
}

bool ResolveExpression::visit(UnaryExpressionAST *ast)
{
    accept(ast->expression);
    unsigned unaryOp = tokenKind(ast->unary_op_token);
    if (unaryOp == T_AMPER) {
        QMutableListIterator<LookupItem > it(_results);
        while (it.hasNext()) {
            LookupItem p = it.next();
            FullySpecifiedType ty = p.type();
            ty.setType(control()->pointerType(ty));
            p.setType(ty);
            it.setValue(p);
        }
    } else if (unaryOp == T_STAR) {
        QMutableListIterator<LookupItem > it(_results);
        while (it.hasNext()) {
            LookupItem p = it.next();
            if (PointerType *ptrTy = p.type()->asPointerType()) {
                p.setType(ptrTy->elementType());
                it.setValue(p);
            } else {
                it.remove();
            }
        }
    }
    return false;
}

bool ResolveExpression::visit(CompoundLiteralAST *ast)
{
    accept(ast->type_id);
    return false;
}

bool ResolveExpression::visit(QualifiedNameAST *ast)
{
    if (const Name *name = ast->name) {
        const QList<Symbol *> candidates = _context.lookup(name, _scope);

        foreach (Symbol *candidate, candidates)
            addResult(candidate->type(), candidate);
    }

    return false;
}

bool ResolveExpression::visit(SimpleNameAST *ast)
{
    QList<Symbol *> symbols = _context.lookup(ast->name, _scope);
    foreach (Symbol *symbol, symbols)
        addResult(symbol->type(), symbol);

    return false;
}

bool ResolveExpression::visit(TemplateIdAST *ast)
{
    const QList<Symbol *> symbols = _context.lookup(ast->name, _scope);
    foreach (Symbol *symbol, symbols)
        addResult(symbol->type(), symbol);

    return false;
}

bool ResolveExpression::visit(DestructorNameAST *)
{
    FullySpecifiedType ty(control()->voidType());
    addResult(ty);
    return false;
}

bool ResolveExpression::visit(OperatorFunctionIdAST *)
{
    return false;
}

bool ResolveExpression::visit(ConversionFunctionIdAST *)
{
    return false;
}

bool ResolveExpression::maybeValidPrototype(Function *funTy, unsigned actualArgumentCount) const
{
    unsigned minNumberArguments = 0;

    for (; minNumberArguments < funTy->argumentCount(); ++minNumberArguments) {
        Argument *arg = funTy->argumentAt(minNumberArguments)->asArgument();

        if (arg->hasInitializer())
            break;
    }

    if (actualArgumentCount < minNumberArguments) {
        // not enough arguments.
        return false;

    } else if (! funTy->isVariadic() && actualArgumentCount > funTy->argumentCount()) {
        // too many arguments.
        return false;
    }

    return true;
}

bool ResolveExpression::visit(CallAST *ast)
{
    const QList<LookupItem> baseResults = _results;
    _results.clear();

    // Compute the types of the actual arguments.
    int actualArgumentCount = 0;

    //QList< QList<Result> > arguments;
    for (ExpressionListAST *exprIt = ast->expression_list; exprIt; exprIt = exprIt->next) {
        //arguments.append(operator()(exprIt->expression));
        ++actualArgumentCount;
    }

    const Name *functionCallOp = control()->operatorNameId(OperatorNameId::FunctionCallOp);

    foreach (const LookupItem &result, baseResults) {
        FullySpecifiedType ty = result.type().simplified();
        Symbol *lastVisibleSymbol = result.lastVisibleSymbol();

        if (NamedType *namedTy = ty->asNamedType()) {
            if (ClassOrNamespace *b = _context.classOrNamespace(namedTy->name(), lastVisibleSymbol->scope())) {
                foreach (Symbol *overload, b->lookup(functionCallOp)) {
                    if (Function *funTy = overload->type()->asFunctionType()) {
                        if (maybeValidPrototype(funTy, actualArgumentCount)) {
                            Function *proto = instantiate(namedTy->name(), funTy)->asFunctionType();
                            addResult(proto->returnType().simplified(), lastVisibleSymbol);
                        }
                    }
                }
            }

        } else if (Function *funTy = ty->asFunctionType()) {
            if (maybeValidPrototype(funTy, actualArgumentCount))
                addResult(funTy->returnType().simplified(), lastVisibleSymbol);

        } else if (Class *classTy = ty->asClassType()) {
            // Constructor call
            FullySpecifiedType ctorTy = control()->namedType(classTy->name());
            addResult(ctorTy, lastVisibleSymbol);
        }
    }

    return false;
}

bool ResolveExpression::visit(ArrayAccessAST *ast)
{
    const QList<LookupItem> baseResults = _results;
    _results.clear();

    const QList<LookupItem> indexResults = operator()(ast->expression);

    const Name *arrayAccessOp = control()->operatorNameId(OperatorNameId::ArrayAccessOp);

    foreach (const LookupItem &result, baseResults) {
        FullySpecifiedType ty = result.type().simplified();
        Symbol *lastVisibleSymbol = result.lastVisibleSymbol();

        if (PointerType *ptrTy = ty->asPointerType()) {
            addResult(ptrTy->elementType().simplified(), lastVisibleSymbol);

        } else if (ArrayType *arrTy = ty->asArrayType()) {
            addResult(arrTy->elementType().simplified(), lastVisibleSymbol);

        } else if (NamedType *namedTy = ty->asNamedType()) {
            if (ClassOrNamespace *b = _context.classOrNamespace(namedTy->name(), lastVisibleSymbol->scope())) {
                foreach (Symbol *overload, b->lookup(arrayAccessOp)) {
                    if (Function *funTy = overload->type()->asFunctionType()) {
                        Function *proto = instantiate(namedTy->name(), funTy)->asFunctionType();
                        // ### TODO: check the actual arguments
                        addResult(proto->returnType().simplified(), lastVisibleSymbol);
                    }
                }

            }
        }
    }
    return false;
}

bool ResolveExpression::visit(MemberAccessAST *ast)
{
    // The candidate types for the base expression are stored in
    // _results.
    const QList<LookupItem> baseResults = _results;

    // Evaluate the expression-id that follows the access operator.
    const Name *memberName = 0;
    if (ast->member_name)
        memberName = ast->member_name->name;

    // Remember the access operator.
    const int accessOp = tokenKind(ast->access_token);

    _results = resolveMemberExpression(baseResults, accessOp, memberName);

    return false;
}

QList<LookupItem>
ResolveExpression::resolveBaseExpression(const QList<LookupItem> &baseResults, int accessOp,
                                         bool *replacedDotOperator) const
{
    QList<LookupItem> results;

    if (baseResults.isEmpty())
        return results;

    LookupItem result = baseResults.first();
    FullySpecifiedType ty = result.type().simplified();
    Symbol *lastVisibleSymbol = result.lastVisibleSymbol();

    if (Function *funTy = ty->asFunctionType()) {
        if (funTy->isAmbiguous())
            ty = funTy->returnType().simplified();
    }

    if (accessOp == T_ARROW)  {
        if (NamedType *namedTy = ty->asNamedType()) {
            const Name *arrowAccessOp = control()->operatorNameId(OperatorNameId::ArrowOp);

            if (ClassOrNamespace *b = _context.classOrNamespace(namedTy->name(), result.lastVisibleSymbol())) {
                foreach (Symbol *overload, b->lookup(arrowAccessOp)) {
                    if (Function *funTy = overload->type()->asFunctionType()) {
                        FullySpecifiedType f = instantiate(namedTy->name(), funTy);
                        FullySpecifiedType retTy = f->asFunctionType()->returnType().simplified();

                        if (PointerType *ptrTy = retTy->asPointerType()) {
                            FullySpecifiedType elementTy = ptrTy->elementType().simplified();
                            results.append(LookupItem(elementTy, overload));
                        }
                    }
                }
            }

        } else if (PointerType *ptrTy = ty->asPointerType()) {
            FullySpecifiedType elementTy = ptrTy->elementType().simplified();

            if (elementTy->isNamedType() || elementTy->isClassType())
                results.append(LookupItem(elementTy, lastVisibleSymbol));
        }
    } else if (accessOp == T_DOT) {
        if (replacedDotOperator) {
            if (PointerType *ptrTy = ty->asPointerType()) {
                *replacedDotOperator = true;
                ty = ptrTy->elementType().simplified();
            } else if (ArrayType *arrTy = ty->asArrayType()) {
                *replacedDotOperator = true;
                ty = arrTy->elementType().simplified();
            }
        }

        if (NamedType *namedTy = ty->asNamedType()) {
            const QList<Symbol *> candidates = _context.lookup(namedTy->name(), result.lastVisibleSymbol());
            foreach (Symbol *candidate, candidates) {
                if (candidate->isTypedef() && candidate->type()->isNamedType()) {
                    ty = candidate->type();
                    lastVisibleSymbol = candidate;
                    break;
                } else if (TypenameArgument *arg = candidate->asTypenameArgument()) {
                    ty = arg->type();
                    lastVisibleSymbol = candidate;
                    break;
                }
            }

            results.append(LookupItem(ty, lastVisibleSymbol));

        } else if (Function *fun = ty->asFunctionType()) {
            Scope *funScope = fun->scope();

            if (funScope && (funScope->isBlockScope() || funScope->isNamespaceScope())) {
                FullySpecifiedType retTy = fun->returnType().simplified();
                results.append(LookupItem(retTy, lastVisibleSymbol));
            }
        }
    }

    return removeDuplicates(results);
}

QList<LookupItem>
ResolveExpression::resolveMemberExpression(const QList<LookupItem> &baseResults,
                                           unsigned accessOp,
                                           const Name *memberName,
                                           bool *replacedDotOperator) const
{
    QList<LookupItem> results;

    const QList<LookupItem> classObjectResults = resolveBaseExpression(baseResults, accessOp, replacedDotOperator);

    foreach (const LookupItem &r, classObjectResults) {
        FullySpecifiedType ty = r.type();

        if (Class *klass = ty->asClassType())
            results += resolveMember(memberName, klass);

        else if (NamedType *namedTy = ty->asNamedType()) {
            if (ClassOrNamespace *b = _context.classOrNamespace(namedTy->name(), r.lastVisibleSymbol())) {
                foreach (Symbol *c, b->lookup(memberName))
                    results.append(LookupItem(instantiate(namedTy->name(), c), c));
            }
        }
    }

    return removeDuplicates(results);
}

FullySpecifiedType ResolveExpression::instantiate(const Name *className, Symbol *candidate) const
{
    if (const TemplateNameId *templId = className->asTemplateNameId()) {
        if (Class *klass = candidate->enclosingSymbol()->asClass()) {
            GenTemplateInstance::Substitution subst;

            for (unsigned i = 0; i < templId->templateArgumentCount(); ++i) {
                FullySpecifiedType templArgTy = templId->templateArgumentAt(i);

                if (i < klass->templateParameterCount()) {
                    const Name *templArgName = klass->templateParameterAt(i)->name();

                    if (templArgName && templArgName->identifier()) {
                        const Identifier *templArgId = templArgName->identifier();
                        subst.append(qMakePair(templArgId, templArgTy));
                    }
                }
            }

            GenTemplateInstance inst(_context.control(), subst);
            return inst(candidate);
        }
    }

    return candidate->type();
}

QList<LookupItem>
ResolveExpression::resolveMember(const Name *memberName, Class *klass,
                                 const Name *className) const
{
    QList<LookupItem> results;

    if (! klass)
        return results;

    if (! className)
        className = klass->name();

    if (! className)
        return results;

    const QList<Symbol *> candidates = _context.lookup(memberName, klass->members());

    foreach (Symbol *candidate, candidates) {
        FullySpecifiedType ty = candidate->type();
        const Name *unqualifiedNameId = className;

        if (const QualifiedNameId *q = className->asQualifiedNameId())
            unqualifiedNameId = q->unqualifiedNameId();

        if (const TemplateNameId *templId = unqualifiedNameId->asTemplateNameId()) {
            GenTemplateInstance::Substitution subst;

            for (unsigned i = 0; i < templId->templateArgumentCount(); ++i) {
                FullySpecifiedType templArgTy = templId->templateArgumentAt(i);

                if (i < klass->templateParameterCount()) {
                    const Name *templArgName = klass->templateParameterAt(i)->name();
                    if (templArgName && templArgName->identifier()) {
                        const Identifier *templArgId = templArgName->identifier();
                        subst.append(qMakePair(templArgId, templArgTy));
                    }
                }
            }

            GenTemplateInstance inst(_context.control(), subst);
            ty = inst(candidate);
        }

        results.append(LookupItem(ty, candidate));
    }

    return removeDuplicates(results);
}


QList<LookupItem>
ResolveExpression::resolveMember(const Name *memberName, ObjCClass *klass) const
{
    QList<LookupItem> results;
    if (!memberName || !klass)
        return results;

    const QList<Symbol *> candidates = _context.lookup(memberName, klass->members());

    foreach (Symbol *candidate, candidates) {
        FullySpecifiedType ty = candidate->type();

        results.append(LookupItem(ty, candidate));
    }

    return removeDuplicates(results);
}

bool ResolveExpression::visit(PostIncrDecrAST *)
{
    return false;
}

bool ResolveExpression::visit(ObjCMessageExpressionAST *ast)
{
    QList<LookupItem> receiverResults = operator()(ast->receiver_expression);

    if (!receiverResults.isEmpty()) {
        LookupItem result = receiverResults.first();
        FullySpecifiedType ty = result.type().simplified();
        const Name *klassName = 0;

        if (const ObjCClass *classTy = ty->asObjCClassType()) {
            // static access, e.g.:
            // [NSObject description];
            klassName = classTy->name();
        } else if (const PointerType *ptrTy = ty->asPointerType()) {
            const FullySpecifiedType pointeeTy = ptrTy->elementType();
            if (pointeeTy && pointeeTy->isNamedType()) {
                // dynamic access, e.g.:
                // NSObject *obj = ...; [obj release];
                klassName = pointeeTy->asNamedType()->name();
            }
        }

        if (klassName&&ast->selector && ast->selector->name) {
            const QList<Symbol *> resolvedSymbols = _context.lookup(klassName, result.lastVisibleSymbol());
            foreach (Symbol *resolvedSymbol, resolvedSymbols)
                if (ObjCClass *klass = resolvedSymbol->asObjCClass())
                    _results.append(resolveMember(ast->selector->name, klass));
        }
    }

    return false;
}