Type checking rules in Compiler Design - Mini Project: Build & Apply

Understanding Type Checking Rules

📖 Scenario: Imagine you are designing a simple programming language. You want to make sure that the language checks if the types of values used in expressions are correct before running the program. This helps catch mistakes early.

🎯 Goal: You will build a basic set of rules that check if operations between values are allowed based on their types. This will help you understand how type checking works in compilers.

📋 What You'll Learn

Create a dictionary called variables with variable names and their types

Create a list called expressions with tuples representing operations and operand variable names

Write a function called is_operation_valid that checks if an operation between two types is allowed

Use a loop to check each expression and store the result in a dictionary called results

💡 Why This Matters

🌍 Real World

Type checking is used in compilers and interpreters to catch errors before running programs, making software more reliable.

💼 Career

Understanding type checking rules is important for compiler developers, language designers, and software engineers working on tools that analyze or transform code.

1

Create the variables dictionary

Create a dictionary called variables with these exact entries: 'x': 'int', 'y': 'float', 'z': 'string'

Compiler Design

# Create the variables dictionary with exact entries
# Your code here

Hint

Use curly braces to create a dictionary with keys and values as shown.

2

Create the expressions list

Create a list called expressions with these exact tuples: ('add', 'x', 'y'), ('concat', 'z', 'z'), ('add', 'x', 'z')

Compiler Design

variables = {'x': 'int', 'y': 'float', 'z': 'string'}
# Create the expressions list with exact tuples
# Your code here

Hint

Use square brackets to create a list and parentheses for tuples.

3

Write the type checking function

Write a function called is_operation_valid that takes three parameters: op, type1, and type2. It returns True if the operation is valid based on these rules: 'add' is valid if both types are 'int' or 'float' (or one 'int' and one 'float'), 'concat' is valid only if both types are 'string'. Otherwise, return False.

Compiler Design

variables = {'x': 'int', 'y': 'float', 'z': 'string'}
expressions = [('add', 'x', 'y'), ('concat', 'z', 'z'), ('add', 'x', 'z')]
# Write the is_operation_valid function below
# Your code here

Hint

Use if and elif to check the operation and types, then return True or False.

4

Check expressions and store results

Create an empty dictionary called results. Use a for loop with variables op, var1, and var2 to iterate over expressions. For each expression, get the types of var1 and var2 from variables. Use is_operation_valid(op, type1, type2) to check if the operation is valid. Store the result (True or False) in results with the key as the expression tuple.

Compiler Design

variables = {'x': 'int', 'y': 'float', 'z': 'string'}
expressions = [('add', 'x', 'y'), ('concat', 'z', 'z'), ('add', 'x', 'z')]

def is_operation_valid(op, type1, type2):
    if op == 'add':
        if (type1 in ('int', 'float') and type2 in ('int', 'float')):
            return True
        else:
            return False
    elif op == 'concat':
        if type1 == 'string' and type2 == 'string':
            return True
        else:
            return False
    else:
        return False

# Create results dictionary and check each expression
# Your code here

Hint

Use a for loop to go through each expression and store the validity in the results dictionary.

Practice

1. What is the main purpose of type checking rules in a compiler?

easy

A. To ensure that data types are used correctly in operations and assignments

B. To optimize the program's execution speed

C. To translate code into machine language

D. To manage memory allocation during runtime

Solution

1. Step 1: Understand the role of type checking

   Type checking rules verify that variables and expressions use compatible data types to avoid errors.

2. Step 2: Differentiate from other compiler tasks

   Optimization, translation, and memory management are separate compiler tasks, not type checking.

3. Final Answer:

   To ensure that data types are used correctly in operations and assignments -> Option A

4. Quick Check:

   Type checking = Correct data types [OK]

Hint: Type checking = matching data types in code [OK]

Common Mistakes:

• Confusing type checking with code optimization
• Thinking type checking manages memory
• Assuming type checking translates code

2. Which of the following is a correct type checking rule for assignment statements?

easy

A. Type checking only applies to function calls, not assignments

B. A variable can be assigned a value of any type without restrictions

C. Variables do not need to be declared before assignment

D. The type of the value assigned must match the variable's declared type

Solution

1. Step 1: Review assignment type rules

   In type checking, the value assigned must have the same type as the variable's declared type.

2. Step 2: Eliminate incorrect options

   Allowing any type or ignoring declarations violates type safety; type checking applies to assignments.

3. Final Answer:

   The type of the value assigned must match the variable's declared type -> Option D

4. Quick Check:

   Assignment types must match [OK]

Hint: Assignment value type = variable type [OK]

Common Mistakes:

• Ignoring variable declarations
• Assigning incompatible types
• Thinking type checking excludes assignments

3. Consider this code snippet:

int x = 5;
float y = 3.2;
x = y;

What will a strict type checker report?

medium

A. No error, assignment allowed

B. Warning but allowed at runtime

C. Type mismatch error: cannot assign float to int

D. Syntax error due to missing semicolon

Solution

1. Step 1: Identify variable types and assignment

   Variable x is int, y is float. Assignment tries to put a float into an int.

2. Step 2: Apply strict type checking rules

   Strict type checking disallows assigning a float value to an int variable without explicit conversion.

3. Final Answer:

   Type mismatch error: cannot assign float to int -> Option C

4. Quick Check:

   Float to int assignment = error [OK]

Hint: Assigning float to int causes type mismatch error [OK]

Common Mistakes:

• Assuming implicit conversion is automatic
• Confusing syntax errors with type errors
• Ignoring strict type checking rules

4. Identify the error in this code snippet under type checking rules:

string name = "Alice";
int age = "30";

medium

A. No error, both assignments are valid

B. Type error: assigning string literal to int variable

C. Syntax error: missing quotes around 30

D. Runtime error due to invalid conversion

Solution

1. Step 1: Analyze variable declarations and assignments

   name is a string assigned a string literal, which is correct. age is an int assigned a string literal "30".

2. Step 2: Apply type checking rules

   Assigning a string literal to an int variable violates type checking rules, causing a type error.

3. Final Answer:

   Type error: assigning string literal to int variable -> Option B

4. Quick Check:

   String to int assignment = type error [OK]

Hint: Assigning string to int causes type error [OK]

Common Mistakes:

• Thinking quotes around 30 are optional
• Confusing syntax errors with type errors
• Assuming implicit conversion from string to int

5. Given a function with parameters typed as int and float, which call violates type checking rules?

void process(int a, float b) { /*...*/ }

// Calls:
process(10, 5.5);
process(3.2, 4.1);
process(7, 2);

hard

A. process(3.2, 4.1);

B. process(10, 5.5);

C. process(7, 2);

D. All calls are valid

Solution

1. Step 1: Check parameter types for each call

   Function expects int then float. Call 1 passes int and float correctly. Call 2 passes float then float, which mismatches first parameter. Call 3 passes int and int, which may be allowed if int converts to float.

2. Step 2: Apply strict type checking

   Call 2 violates type checking because first argument is float but expected int. Call 3 is valid if implicit int to float conversion allowed for second parameter.

3. Final Answer:

   process(3.2, 4.1); -> Option A

4. Quick Check:

   First param must be int, call 2 fails [OK]

Hint: First argument must be int, float causes error [OK]

Common Mistakes:

• Assuming all numeric types are interchangeable
• Ignoring parameter order in function calls
• Thinking int cannot convert to float