SemanticAnalyzer.cpp

// ============================================================
//SYMENTIC ANALYZER
// ============================================================
// Purpose: SEMANTIC ANALYSIS implementation.
//          Walks the AST and performs all meaning-checks.
//          Builds and maintains the Symbol Table.
// ============================================================

#include "SemanticAnalyzer.h"
#include <iostream>
#include <iomanip>  // std::setw for pretty table

SemanticAnalyzer::SemanticAnalyzer() {}

// ANALYZE() – entry point for semantic analysis, takes the AST and returns the symbol table
std::unordered_map<std::string, Symbol>
SemanticAnalyzer::analyze(const std::vector<ASTNodePtr>& stmts) {
    symbolTable_.clear();
    scopes_.clear();
    analysisLog_.clear();
    enterScope();

    log("=== SEMANTIC ANALYSIS STARTED ===");

    for (const auto& stmt : stmts) {
        analyzeNode(stmt.get());   // Visit each top-level statement
    }

    symbolTable_ = scopes_.front();
    log("=== SEMANTIC ANALYSIS COMPLETE - No errors found ===");
    return symbolTable_;   // Return the fully populated symbol table
}

// ANALYZE_NODE() – dispatches to the appropriate analysis function based on node type
void SemanticAnalyzer::analyzeNode(const ASTNode* node) {
    if (!node) return;   // Null check (safety)

    // Dynamic cast to each possible concrete node type
    if (auto* n = dynamic_cast<const VarDeclNode*>(node)) {
        analyzeVarDecl(n);
    } else if (auto* n = dynamic_cast<const AssignNode*>(node)) {
        analyzeAssign(n);
    } else if (auto* n = dynamic_cast<const IfNode*>(node)) {
        analyzeIf(n);
    } else if (auto* n = dynamic_cast<const WhileNode*>(node)) {
        analyzeWhile(n);
    } else if (auto* n = dynamic_cast<const PrintNode*>(node)) {
        analyzePrint(n);
    } else if (auto* n = dynamic_cast<const ReturnNode*>(node)) {
        analyzeReturn(n);
    } else if (auto* n = dynamic_cast<const BlockNode*>(node)) {
        analyzeBlock(n);
    }
    // Leaf expression nodes (Number, String, Identifier) need no
    // top-level analysis – they are checked via inferType() below
}

// ANALYZE_VAR_DECL() – check variable declaration rules and update symbol table
void SemanticAnalyzer::analyzeVarDecl(const VarDeclNode* node) {
    log("CHECK: Variable declaration '" + node->name + "' of type '" + node->type + "'");

    // ── Rule 1: No duplicate declarations in same scope ──
    if (scopes_.back().count(node->name)) {
        error("Variable '" + node->name + "' already declared in this scope");
    }

    // ── Rule 2: Type-check the initialiser ───────────────
    std::string initType = "none";
    if (node->init) {
        initType = inferType(node->init.get());
        log("  Initialiser inferred type: " + initType);

        // float can hold int values (widening) but not vice-versa
        if (node->type == "int" && initType == "float") {
            error("Cannot assign float to int variable '" + node->name + "'");
        }
    }

    // ── Add to symbol table ───────────────────────────────
    scopes_.back()[node->name] = Symbol{ node->type, node->init != nullptr, 0 };
    log("  Added '" + node->name + "' to symbol table");
}

// ANALYZE_ASSIGN() – check assignment rules and update symbol table
void SemanticAnalyzer::analyzeAssign(const AssignNode* node) {
    log("CHECK: Assignment to '" + node->name + "'");

    // ── Rule: Variable must be declared before assignment ─
    Symbol* symbol = findSymbol(node->name);
    if (!symbol) {
        error("Variable '" + node->name + "' used before declaration");
    }

    std::string exprType = inferType(node->expr.get());
    std::string varType  = symbol->type;
    log("  Assigning type '" + exprType + "' to '" + varType + "' variable");

    if (varType == "int" && exprType == "float") {
        error("Type mismatch: cannot assign float expression to int '" + node->name + "'");
    }

    symbol->initialised = true;  // Mark as assigned
}

// ANALYZE_IF() – check if-statement rules
void SemanticAnalyzer::analyzeIf(const IfNode* node) {
    log("CHECK: if-statement condition");
    inferType(node->condition.get());   // Verify condition is well-typed

    log("CHECK: if-statement then-branch");
    enterScope();
    for (const auto& s : node->thenBranch)
        analyzeNode(s.get());
    exitScope();

    if (!node->elseBranch.empty()) {
        log("CHECK: if-statement else-branch");
        enterScope();
        for (const auto& s : node->elseBranch)
            analyzeNode(s.get());
        exitScope();
    }
}

// ANALYZE_WHILE() – check while-loop rules
void SemanticAnalyzer::analyzeWhile(const WhileNode* node) {
    log("CHECK: while-loop condition");
    inferType(node->condition.get());

    log("CHECK: while-loop body");
    enterScope();
    for (const auto& s : node->body)
        analyzeNode(s.get());
    exitScope();
}

// ANALYZE_PRINT() – check print statement rules
void SemanticAnalyzer::analyzePrint(const PrintNode* node) {
    log("CHECK: print statement");
    inferType(node->expr.get());   // Ensure the expression is valid
}

// ANALYZE_RETURN() – check return statement rules
void SemanticAnalyzer::analyzeReturn(const ReturnNode* node) {
    log("CHECK: return statement");
    if (node->expr) inferType(node->expr.get());
}

// ANALYZE_BLOCK() – check block statement rules
void SemanticAnalyzer::analyzeBlock(const BlockNode* node) {
    enterScope();
    for (const auto& s : node->statements)
        analyzeNode(s.get());
    exitScope();
}

// INFER_TYPE() – recursively determine the type of an expression node
std::string SemanticAnalyzer::inferType(const ASTNode* node) {
    if (!node) return "void";

    if (dynamic_cast<const NumberNode*>(node)) {
        // Numeric literal: check if it has a decimal point
        auto* n = dynamic_cast<const NumberNode*>(node);
        // If value has a fractional part it is float, otherwise int
        return (n->value != (int)n->value) ? "float" : "int";
    }

    if (dynamic_cast<const StringNode*>(node)) {
        return "string";
    }

    if (auto* n = dynamic_cast<const IdentifierNode*>(node)) {
        // Look up in symbol table
        const Symbol* symbol = findSymbol(n->name);
        if (!symbol)
            error("Undeclared variable '" + n->name + "'");
        return symbol->type;
    }

    if (auto* n = dynamic_cast<const BinaryOpNode*>(node)) {
        std::string lt = inferType(n->left.get());
        std::string rt = inferType(n->right.get());
        // Relational operators always produce int (0 or 1)
        if (n->op == "==" || n->op == "!=" ||
            n->op == "<"  || n->op == ">"  ||
            n->op == "<=" || n->op == ">=") {
            return "int";
        }
        // Arithmetic: if either operand is float, result is float
        if (lt == "float" || rt == "float") return "float";
        return "int";
    }

    return "unknown";
}

// INFER_TYPE() – recursively determine the type of an expression node
void SemanticAnalyzer::log(const std::string& msg) {
    analysisLog_.push_back(msg);
    std::cout << "  [SEMANTIC] " << msg << "\n";
}

// ERROR() – throw a semantic error
void SemanticAnalyzer::error(const std::string& msg) {
    throw std::runtime_error("Semantic error: " + msg);
}

void SemanticAnalyzer::enterScope() {
    scopes_.push_back({});
}

void SemanticAnalyzer::exitScope() {
    if (!scopes_.empty()) {
        scopes_.pop_back();
    }
}

Symbol* SemanticAnalyzer::findSymbol(const std::string& name) {
    for (auto it = scopes_.rbegin(); it != scopes_.rend(); ++it) {
        auto found = it->find(name);
        if (found != it->end()) {
            return &found->second;
        }
    }
    return nullptr;
}

const Symbol* SemanticAnalyzer::findSymbol(const std::string& name) const {
    for (auto it = scopes_.rbegin(); it != scopes_.rend(); ++it) {
        auto found = it->find(name);
        if (found != it->end()) {
            return &found->second;
        }
    }
    return nullptr;
}

// PRINT_SYMBOL_TABLE() – utility to display the current symbol table (for debugging)
void SemanticAnalyzer::printSymbolTable() const {
    std::cout << "\n  +---------------+-------+-------------+\n";
    std::cout <<   "  | Name          | Type  | Initialised |\n";
    std::cout <<   "  +---------------+-------+-------------+\n";

    for (const auto& entry : symbolTable_) {
        const std::string& name = entry.first;
        const Symbol& sym = entry.second;
        std::cout << "  | " << std::setw(13) << std::left << name
                  << " | " << std::setw(5)  << std::left << sym.type
                  << " | " << std::setw(11) << std::left << (sym.initialised ? "YES" : "NO")
                  << " |\n";
    }
    std::cout << "  +---------------+-------+-------------+\n\n";
}

//example of semantic analysis for the statement:
// int x = 3+5
// AST (parser) =     
                //       =
                // x           +
                //         3       5
                        

// semmentic analyze (ASY) + symbol table
            //             <assignment,=>

            // <identifier,x>      <arithmaticoperator,+>

            //             <number,3>              <number,5>