/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the Qt Mobility Components.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** 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.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#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/QVarLengthArray>

#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(const LookupContext &context)

    : ASTVisitor(context.expressionDocument()->translationUnit()),

      _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)

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

void ResolveExpression::addResult(const LookupItem &r)

{

    LookupItem p = r;

    if (! p.lastVisibleSymbol())

        p.setLastVisibleSymbol(_context.symbol());

    if (! _results.contains(p))

        _results.append(p);

}

QList<Scope *> ResolveExpression::visibleScopes(const LookupItem &result) const

{ return _context.visibleScopes(result); }

bool ResolveExpression::visit(BinaryExpressionAST *ast)

{

    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 *)

{

    if (! _context.symbol())

        return false;

    Scope *scope = _context.symbol()->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;

            }

        }

    }

    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)

{

    ResolveClass resolveClass;

    const Name *name = ast->name;

    QList<Symbol *> symbols = _context.resolve(name);

    foreach (Symbol *symbol, symbols) {

        if (symbol->isTypedef()) {

            if (NamedType *namedTy = symbol->type()->asNamedType()) {

                const LookupItem r(namedTy, symbol);

                const QList<Symbol *> resolvedClasses =

                        resolveClass(namedTy->name(), r, _context);

                if (resolvedClasses.count()) {

                    foreach (Symbol *s, resolvedClasses) {

                        addResult(s->type(), s);

                    }

                    continue;

                }

            }

        }

        addResult(symbol->type(), symbol);

    }

    return false;

}

bool ResolveExpression::visit(OperatorFunctionIdAST *)

{

    return false;

}

bool ResolveExpression::visit(ConversionFunctionIdAST *)

{

    return false;

}

bool ResolveExpression::visit(SimpleNameAST *ast)

{

    QList<Symbol *> symbols = _context.resolve(ast->name);

    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(TemplateIdAST *ast)

{

    QList<Symbol *> symbols = _context.resolve(ast->name);

    foreach (Symbol *symbol, symbols)

        addResult(symbol->type(), symbol);

    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)

{

    ResolveClass resolveClass;

    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()) {

            const QList<Symbol *> classObjectCandidates = resolveClass(namedTy->name(), result, _context);

            foreach (Symbol *classObject, classObjectCandidates) {

                const QList<LookupItem> overloads = resolveMember(functionCallOp, classObject->asClass(), namedTy->name());

                foreach (const LookupItem &o, overloads) {

                    FullySpecifiedType overloadTy = o.type().simplified();

                    if (Function *funTy = overloadTy->asFunctionType()) {

                        if (maybeValidPrototype(funTy, actualArgumentCount))

                            addResult(funTy->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);

    ResolveClass resolveClass;

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

    foreach (const LookupItem &result, baseResults) {

        FullySpecifiedType ty = result.type().simplified();

        Symbol *contextSymbol = result.lastVisibleSymbol();

        if (PointerType *ptrTy = ty->asPointerType()) {

            addResult(ptrTy->elementType().simplified(), contextSymbol);

        } else if (ArrayType *arrTy = ty->asArrayType()) {

            addResult(arrTy->elementType().simplified(), contextSymbol);

        } else if (NamedType *namedTy = ty->asNamedType()) {

            const QList<Symbol *> classObjectCandidates =

                    resolveClass(namedTy->name(), result, _context);

            foreach (Symbol *classObject, classObjectCandidates) {

                Q_ASSERT(classObject->isClass());