/*

 * Copyright (C) 2012 David Anderson

 *

 * This file is part of JITCraft.

 *

 * JITCraft is free software: you can redistribute it and/or modify it under

 * the terms of the GNU General Public License as published by the Free

 * Software Foundation, either version 3 of the License, or (at your option)

 * any later version.

 * 

 * Foobar is distributed in the hope that it will be useful, but WITHOUT ANY

 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License along with

 * JITCraft. If not, see http://www.gnu.org/licenses/.

 */

#include "SemanticAnalysis.h"

#include "Types.h"

#include "Zone.h"

#include "TypeManager.h"

#include "Scopes.h"

using namespace jc;

static inline bool

IsPrimitiveType(Type *type, PrimitiveType primitive)

{

    if (!type)

        return false;

    if (!type->isPrimitive())

        return false;

    return primitive == type->primitive();

}

static inline bool

EvaluateBinaryOperation(TokenKind kind, const BoxedPrimitive &left, const BoxedPrimitive &right,

                        BoxedPrimitive *out)

{

    switch (kind) {

      case TOK_PLUS:

        *out = BoxedPrimitive::Int(left.toInt() + right.toInt());

        return true;

      case TOK_SHL:

        *out = BoxedPrimitive::Int(left.toInt() << right.toInt());

        return true;

    }

    return true;

}

static bool

EvaluateForConstant(Expression *expression, BoxedPrimitive *out)

{

    switch (expression->kind()) {

      case AstNode::kBinaryExpression:

      {

        BoxedPrimitive left;

        BoxedPrimitive right;

        BinaryExpression *b = expression->toBinaryExpression();

        if (!EvaluateForConstant(b->left(), &left) ||

            !EvaluateForConstant(b->right(), &right))

        {

            return false;

        }

        return EvaluateBinaryOperation(b->token(), left, right, out);

      }

      case AstNode::kNameProxy:

      {

        NameProxy *proxy = expression->toNameProxy();

        if (proxy->binding()->kind() != BoundName::CONSTANT)

            return false;

        NamedConstant *c = proxy->binding()->toNamedConstant();

        if (!IsPrimitiveType(c->type(), PrimitiveType_Int32))

            return false;

        *out = c->value();

        return true;

      }

      case AstNode::kIntegerLiteral:

        *out = BoxedPrimitive::Int(expression->toIntegerLiteral()->value());

        return true;

      default:

        return false;

    }

}

SemanticAnalysis::SemanticAnalysis(ParseTree *tree)

  : tree_(tree),

    loopDepth_(0),

    scope_(NULL)

{

}

bool

SemanticAnalysis::analyze()

{

    for (size_t i = 0; i < tree_->statements()->length(); i++) {

        Statement *statement = tree_->statements()->at(i);

        statement->accept(this);

    }

    return true;

}

void

SemanticAnalysis::visit(NameProxy *name)

{

    name->setType(name->binding()->type());

}

Type *

SemanticAnalysis::visitForLoad(Expression *expression)

{

    expression->accept(this);

    if (!expression->type())

        return NULL;

    // :TODO: use Local

    Type *type = expression->type();

    if (type->isReference()) {

        expression->setType(type->contained());

    } else if (expression->isIndexExpression()) {

        if (type->isArray())

            expression->setType(type->contained());

    }

    return expression->type();

}

Type *

SemanticAnalysis::visitForRef(Expression *expression)

{

    expression->accept(this);

    return expression->type();

}

static inline bool

TypeCheck(Type *left, Type *right)

{

    if (!left || !right)

        return false;

    if (left->isPrimitive()) {

        if (!right->isPrimitive())

            return false;

        return left->primitive() == right->primitive();

    }

    return false;

}

static inline bool

TypeCheckAssignment(Type *left, Type *right)

{

    if (!left || !right)

        return false;

    if (left->isPrimitive()) {

        if (!right->isPrimitive())

            return false;

        return left->primitive() == right->primitive();

    }

    if (left->isArray() != right->isArray())

        return false;

    if (left->levels() != 1 || right->levels() != 1)

        return false;

    if (left->elements() == -1 || right->elements() == -1)

        return false;

    if (!TypeCheckAssignment(left->contained(), right->contained()))

        return false;

    if (left->elements() != right->elements()) {

        if (left->isCharArray() && (left->elements() >= right->elements()))

            return true;

        return false;

    }

    return false;

}

static inline Type *

TypeCheckBinary(TokenKind token, Type *left, Type *right)

{

    if (!left || !right)

        return NULL;

    if ((token >= TOK_PLUS && token <= TOK_SLASH) ||

        (token >= TOK_ASSIGN_ADD && token <= TOK_ASSIGN_DIV))

    {

        // If either side is a float, the other side must be a float or int.

        if (left->isFloat() || right->isFloat()) {

            assert(left->isFloat() || left->isInt32());

            assert(right->isFloat() || right->isInt32());

            return left->isFloat() ? left : right;

        }

    }

    assert(left->isInt32() && right->isInt32());

    assert(!left->tag() && !right->tag());

    return left;

}

Type *

SemanticAnalysis::visitForLValue(Expression *expression)

{

    if (expression->isIndexExpression()) {

        expression->accept(this);

        if (!expression->type())

            return NULL;

        return expression->type()->contained();

    }

    if (!expression->isNameProxy()) {

        assert(false);

        return NULL;

    }

    NameProxy *proxy = expression->toNameProxy();

    if (!proxy->binding()->kind() == BoundName::VARIABLE) {

        fprintf(stderr, "error\n");

        return NULL;

    }

    Variable *var = proxy->binding()->toVariable();

    if (!var->type())

        return NULL;

    if  (var->type()->isReference())

        return var->type()->contained();

    return var->type();

}

void

SemanticAnalysis::visit(Assignment *node)

{

    visitForLoad(node->expression());

    // :TODO: use Local

    Type *type = visitForLValue(node->lvalue());

    if (!type)

        return;

    node->setType(type);

    if (node->token() != TOK_ASSIGN)

        assert(TypeCheckBinary(node->token(), node->type(), node->expression()->type()));

    assert(TypeCheckAssignment(node->type(), node->expression()->type()));

}

void

SemanticAnalysis::visit(IncDecExpression *node)

{

    // :TODO: use Local

    Type *type = visitForLValue(node->expression());

    if (!type)

        return;

    assert(!type->isReference());

    if (type->isArray()) {

        // can't a[]++

        assert(false);

        return;

    }

    assert((type->isInt32() && !type->tag()) || type->isFloat());

    node->setType(type);

}

void

SemanticAnalysis::visit(BinaryExpression *node)

{

    // :TODO: use Local

    Type *left = visitForLoad(node->left());

    Type *right = visitForLoad(node->right());

    Type *result = TypeCheckBinary(node->token(), left, right);

    node->setType(result);

}

void

SemanticAnalysis::visit(ReturnStatement *node)

{

    visitForLoad(node->expression());

    // :TODO: type check

}

void

SemanticAnalysis::visit(ForStatement *node)

{

    loopDepth_++;

    if (node->scope())

        scope_ = node->scope();

    if (node->initialization())

        node->initialization()->accept(this);

    if (node->condition())

        visitForLoad(node->condition());

    if (node->update())

        node->update()->accept(this);

    node->body()->accept(this);

    if (node->scope())

        scope_ = scope_->enclosing();

    loopDepth_--;

}

void 

SemanticAnalysis::visit(WhileStatement *node)

{

    loopDepth_++;

    node->condition()->accept(this);

    node->body()->accept(this);

    loopDepth_--;

}

void

SemanticAnalysis::visit(BlockStatement *node)

{

    if (node->scope())

        scope_ = node->scope();

    for (size_t i = 0; i < node->statements()->length(); i++) {

        Statement *statement = node->statements()->at(i);

        statement->accept(this);

    }

    if (node->scope())

        scope_ = scope_->enclosing();

}

void

SemanticAnalysis::visit(VariableDeclaration *node)

{

    // :TODO: use locals

    Type *type = ZONE()->types()->getPrimitiveForTag(node->tag());

    if (!type)

        return;

    if (node->postDimensions()) {

        Type *init = NULL;

        if (node->initialization()) {

            node->initialization()->accept(this);

            if ((init = node->initialization()->type()) == NULL)

                return;

        }

        if (node->postDimensions()->size() > Type::MAX_UNSAFE_ARRAY_DEPTH) {

            error();

            return;

        }

        // If we have an initializer, make sure it's the same type.

        if (init) {

            assert(init->levels() == node->postDimensions()->size());

        }

        Type *check = init;

        for (size_t i = node->postDimensions()->size() - 1; i < node->postDimensions()->size(); i--) {

            Expression *expr = node->postDimensions()->at(i);

            visitForLoad(expr);

            if (!IsPrimitiveType(expr->type(), PrimitiveType_Int32)) {

                typeError(expr, "integer");

                return;

            }

            int size = -1;

            if (expr->isIntegerLiteral()) {

                size = expr->toIntegerLiteral()->value();

                if (size <= 0) {

                    error();

                    return;

                }

                if (size >= INT_MAX / sizeof(int)) {

                    error();

                    return;

                }

            } else {

                assert(false);

            }

            type = ZONE()->types()->unsafeArray(type, size);

            if (check) {

                assert(check->elements() != -1);

                assert(size != -1);

                // If we're assigning a string, we're allowed to pad with

                // zeroes.

                if (check->isCharArray()) {

                    assert(type->isCharArray());

                    assert(type->elements() >= check->elements());

                } else {

                    assert(false);

                }

            }

            if (check)

                check = check->contained();

        }

        // Right now, any array is allowed on the LIFO heap. In case the

        // runtime actually decides to use the LIFO heap, we must reserve

        // a slot so we can unwind the heap when the current scope leaves.

        scope_->setUsesLifoHeap();

    } else {

        if (node->initialization()) {

            Type *right = visitForLoad(node->initialization());

            assert(TypeCheck(type, right));

        }

        if (type->primitive() == PrimitiveType_Char) {

            assert(false);

            return;

        }

    }

    node->variable()->setType(type);

}

void

SemanticAnalysis::visit(IntegerLiteral *node)

{

    node->setType(ZONE()->types()->getPrimitive(PrimitiveType_Int32));

}

void

SemanticAnalysis::visit(ExpressionStatement *node)

{

    node->expression()->accept(this);

}

bool

SemanticAnalysis::preanalyze(FunctionStatement *node)

{

    // :TODO: use Local

    FixedArray *args = FixedArray::New(ZONE(), node->parameters()->size(), Heap::Tenure_Old);

    if (!args)

        return false;

    // Apply types to arguments.

    for (size_t i = 0; i < node->parameters()->size(); i++) {

        Parameter *parameter = node->parameters()->at(i);

        Type *type = ZONE()->types()->getPrimitiveForTag(parameter->tag());

        if (!type)

            return false;

        if (parameter->reference()) {

            type = ZONE()->types()->getReference(type);

            if (!type)

                return false;

        }

        args->set(ZONE(), i, type);

        parameter->variable()->setType(type);

    }

    Type *returnType = ZONE()->types()->getPrimitive(PrimitiveType_Int32);

    if (!returnType)

        return false;

    Type *funtype = ZONE()->types()->newFunction(returnType, args);

    if (!funtype)

        return false;

    node->fun()->setType(funtype);

    return true;

}

void

SemanticAnalysis::visit(FunctionStatement *node)

{

    scope_ = node->scope();

    // :TODO: call this ahead of time.

    if (!preanalyze(node))

        return;

    node->body()->accept(this);

    scope_ = NULL;

}

// :TODO: use handles

static inline bool

TypeCheckParameter(Type *given, Type *actual)

{

    if (actual->isReference()) {

        if (given->isReference())

            given = given->contained();

        return TypeCheck(given, actual->contained());

    }

    return TypeCheck(given, actual);

}

void

SemanticAnalysis::visit(CallExpression *node)

{

    visitForLoad(node->callee());

    // :TODO: use locals

    Type *type = node->callee()->type();

    if (!type)

        return;

    assert(type->isFunction());

    assert(node->arguments()->size() == type->parameters()->length());

    for (unsigned i = 0; i < node->arguments()->size(); i++) {

        // Note: we don't compute references unless the callee needs a

        // reference type.

        Expression *expression = node->arguments()->at(i);

        expression->accept(this);

        Type *given = expression->type();

        if (!given)

            return;

        // If it's an IndexExpression, we special case the ability to compute

        // a reference. Maybe we should compute actual Ref types for

        // IndexExpression?

        if (expression->isIndexExpression())

            given = given->contained();

        Type *actual = Type::cast(type->parameters()->at(i));

        assert(TypeCheckParameter(given, actual));

        // If the actual is a reference, and the given is not, we'll need to

        // compute a reference, which may be allocated on the stack.

        if (actual->isReference() && !given->isReference())

            scope_->setUsesLifoHeap();

    }

}

void

SemanticAnalysis::visit(IfStatement *node)

{

    visitForLoad(node->condition());

    node->ifTrue()->accept(this);

    if (node->ifFalse())

        node->ifFalse()->accept(this);

}

void

SemanticAnalysis::visit(IndexExpression *node)

{

    // :TODO: use locals

    Type *left = visitForRef(node->left());

    Type *right = visitForLoad(node->right());

    if (!right || !right->isInt32()) {

        typeError(node->right(), "integer");

        return;

    }

    if (!left || !left->isArray() || !left->contained()->isPrimitive()) {

        typeError(node->left(), "array");

        return;

    }

    node->setType(left);

}

void

SemanticAnalysis::visit(EnumStatement *node)