Handle Type Coercion Rules (e.g. int + float = float)

Topic Overview

Implicit Conversions at Boundaries

C promotes int to float in mixed arithmetic; Java widens primitives automatically. Clang applies standard conversion rules before checking assignment compatibility. Coercion rules are where subtle bugs hide: silent truncation, sign extension, and unexpected overflow.

Common Coercion Rules

Integer promotion: char and short widen to int. Usual arithmetic conversions: if one operand is float, the other promotes. Assignment may narrow with a warning or error depending on the language.

cCopy
Loading…

• Coercion happens before operator type checking
• Explicit casts bypass or supplement implicit rules
• String + number coercion is language-specific (JavaScript)
• Document which conversions are safe vs lossy

Connecting to real compilers

Production compilers embed this step inside a longer pipeline. GCC flows through cpp, cc1, assembly, and ld; Clang uses the driver, Sema, LLVM IR passes, and a target backend. LLVM bitcode, JVM bytecode, and WASM are other familiar IRs at the same layer. The exercise isolates one pass so you can test it alone before chaining it to the next stage.

Why for this exercise

You will implement type coercion rules for mixed-type arithmetic and assignments. This exercise asks you to promote operand types per language rules and report errors when implicit conversion is not permitted.

Your Task

C silently converts operands before arithmetic. Make those conversions visible: type-check each expression with C's usual arithmetic conversions and print it back with every implicit conversion written out as an explicit cast.

Input

One statement per line (blank lines ignored). Every variable is declared before use.

TYPE is one of char int long float double. Expressions use variables, literals, + - * /, < and parentheses, with the usual precedence (* / over + - over <, all left-associative).

Literals follow C: 42 is int, 2.5 is double, 2.5f is float, and a character literal like 'a' is int.

Conversion rules

Rank: char < int < long < float < double.

1. Integer promotion. A char operand of any operator is first converted to int.
2. Common type. If the two (promoted) operands still differ, the lower-ranked one is converted to the higher. The result has that type; < compares in the common type but its result is int.
3. Assignment / initialization. The value is converted to the target's type. If the target ranks lower than the value's type, also report warning: narrowing TYPE to TYPE.

A conversion is written as (TYPE)operand. Binary operations print fully parenthesized, so a converted operation looks like (double)(i + j).

Output

A narrowing warning goes on its own line right after, indented two spaces. Finish with warnings=N.

Example

Input:

cCopy
Loading…

Output:

cCopy
Loading…

Requirements

1. Build a typed expression tree, then insert explicit cast nodes where C inserts implicit conversions.
2. A common_type() function implementing the rank rule, and a coerce(node, type) that wraps a node in a cast only when its type differs.

Hidden tests cover long vs float, float literals, character literals, comparisons, and narrowing to char in declarations.