Type Checker - Problem

Implement a type checker for a simple expression language that can infer types, detect type mismatches, and support type coercion.

You are given an abstract syntax tree (AST) representing an expression, and a symbol table mapping variable names to their declared types. Your task is to:

Infer the type of the entire expression
Detect type errors and return appropriate error messages
Apply type coercion rules when compatible types are used together

The expression language supports:

Literals: integers, floats, strings, booleans
Variables: identifiers that reference symbol table entries
Binary operations: arithmetic (+, -, *, /), comparison (==, !=, <, >), logical (&&, ||)
Type coercion: int can be promoted to float, but not vice versa

Return the inferred type as a string, or an error message starting with "ERROR:" if type checking fails.

Input & Output

Example 1 — Basic Arithmetic with Coercion

$ Input: ast = {"type":"binary","operator":"+","left":{"type":"variable","name":"x"},"right":{"type":"literal","dataType":"float","value":3.14}}, symbolTable = {"x":"int"}

› Output: float

💡 Note: Variable x is int, literal 3.14 is float. Addition of int + float requires coercion to float, so result type is float.

Example 2 — Type Error Detection

$ Input: ast = {"type":"binary","operator":"+","left":{"type":"variable","name":"name"},"right":{"type":"literal","dataType":"int","value":5}}, symbolTable = {"name":"string"}

› Output: ERROR: Cannot apply + to string and int

💡 Note: Cannot add string variable 'name' to integer 5. No valid coercion rule exists between string and int for arithmetic.

Example 3 — Logical Operation

$ Input: ast = {"type":"binary","operator":"&&","left":{"type":"variable","name":"flag1"},"right":{"type":"variable","name":"flag2"}}, symbolTable = {"flag1":"boolean","flag2":"boolean"}

› Output: boolean

💡 Note: Both operands are boolean variables. Logical AND of boolean && boolean results in boolean type.

Constraints

AST depth ≤ 100 levels
Symbol table size ≤ 1000 entries
Variable names are alphanumeric strings
Supported types: int, float, string, boolean

Visualization

Tap to expand

Asked in

G Google 35 M Microsoft 28 a Amazon 22 f Facebook 18

The key insight is to recursively traverse the AST while applying type rules and coercion logic at each node. The optimal approach uses a systematic type checker class with enhanced coercion rules and context propagation. Time: O(n), Space: O(h + s).

Common Approaches

✓ Brute Force Recursive Checking

⏱️ Time: O(n) Space: O(h)

Visit each AST node and determine its type by recursively checking all child nodes. Apply type rules and coercion at each step without memoization or optimization.

Optimized with Type Context

⏱️ Time: O(n) Space: O(h + s)

Traverse AST with additional context information and optimized type checking rules. Provides better error messages and handles edge cases more efficiently.

Brute Force Recursive Checking — Algorithm Steps

Step 1: Check if node is a literal and return its type
Step 2: If variable, lookup type in symbol table
Step 3: For binary operations, recursively get left and right types
Step 4: Apply operation-specific type rules and coercion

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at Root

Begin type checking at root binary operation node

Check Children

Recursively determine types of left and right operands

Apply Rules

Apply operation-specific type rules and coercion

Return Type

Return inferred type or error message

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct ASTNode {
    char type[20];
    char dataType[20];
    char name[50];
    char operator[10];
    struct ASTNode* left;
    struct ASTNode* right;
} ASTNode;

typedef struct {
    char key[50];
    char value[20];
} SymbolEntry;

char* checkType(ASTNode* node, SymbolEntry* symbolTable, int tableSize, char* result) {
    if (strcmp(node->type, "literal") == 0) {
        strcpy(result, node->dataType);
        return result;
    } else if (strcmp(node->type, "variable") == 0) {
        for (int i = 0; i < tableSize; i++) {
            if (strcmp(symbolTable[i].key, node->name) == 0) {
                strcpy(result, symbolTable[i].value);
                return result;
            }
        }
        sprintf(result, "ERROR: Undefined variable '%s'", node->name);
        return result;
    } else if (strcmp(node->type, "binary") == 0) {
        char leftType[100], rightType[100];
        checkType(node->left, symbolTable, tableSize, leftType);
        checkType(node->right, symbolTable, tableSize, rightType);
        
        if (strncmp(leftType, "ERROR", 5) == 0 || strncmp(rightType, "ERROR", 5) == 0) {
            strcpy(result, strncmp(leftType, "ERROR", 5) == 0 ? leftType : rightType);
            return result;
        }
        
        // Arithmetic operations
        if (strchr("+-*/", node->operator[0]) != NULL) {
            if (strcmp(leftType, "string") == 0 && strcmp(rightType, "string") == 0 && 
                strcmp(node->operator, "+") == 0) {
                strcpy(result, "string");
                return result;
            }
            if ((strcmp(leftType, "int") == 0 || strcmp(leftType, "float") == 0) &&
                (strcmp(rightType, "int") == 0 || strcmp(rightType, "float") == 0)) {
                if (strcmp(leftType, "float") == 0 || strcmp(rightType, "float") == 0) {
                    strcpy(result, "float");
                } else {
                    strcpy(result, "int");
                }
                return result;
            }
            sprintf(result, "ERROR: Cannot apply %s to %s and %s", node->operator, leftType, rightType);
            return result;
        }
        
        // Comparison operations
        if (strstr("== != < > <= >=", node->operator) != NULL) {
            if (strcmp(leftType, rightType) == 0) {
                strcpy(result, "boolean");
                return result;
            }
            if ((strcmp(leftType, "int") == 0 || strcmp(leftType, "float") == 0) &&
                (strcmp(rightType, "int") == 0 || strcmp(rightType, "float") == 0)) {
                strcpy(result, "boolean");
                return result;
            }
            sprintf(result, "ERROR: Cannot compare %s and %s", leftType, rightType);
            return result;
        }
        
        // Logical operations
        if (strcmp(node->operator, "&&") == 0 || strcmp(node->operator, "||") == 0) {
            if (strcmp(leftType, "boolean") == 0 && strcmp(rightType, "boolean") == 0) {
                strcpy(result, "boolean");
                return result;
            }
            sprintf(result, "ERROR: Logical %s requires boolean operands", node->operator);
            return result;
        }
    }
    
    strcpy(result, "ERROR: Unknown node type");
    return result;
}

char* solution(ASTNode* ast, SymbolEntry* symbolTable, int tableSize) {
    static char result[200];
    return checkType(ast, symbolTable, tableSize, result);
}

int main() {
    // Simplified example - in real implementation, parse JSON input
    SymbolEntry symbolTable[] = {{"x", "int"}, {"y", "float"}};
    int tableSize = 2;
    
    ASTNode leftNode = {"variable", "", "x", "", NULL, NULL};
    ASTNode rightNode = {"variable", "", "y", "", NULL, NULL};
    ASTNode ast = {"binary", "", "", "+", &leftNode, &rightNode};
    
    char* result = solution(&ast, symbolTable, tableSize);
    printf("%s\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each AST node exactly once, where n is number of nodes

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h

✓ Linear Space

30.3K Views

Medium Frequency

~35 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Type Checker - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Recursive Checking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler