1. Semantic Analysis II

2. Messages Please check lecturer notices in the Moodle Appeals  Legitimate: “I don’t have the bug you mentioned…”  Illegitimate: “You took too many points for that…” No resubmission Theoretical part to my box (floor 1 near the elevator) 2

3. 3 Compiler IC Program ic x86 executable exe Lexical Analysis Syntax Analysis Parsing ASTSymbol Table etc. Inter. Rep. (IR) Code Generation IC compiler We saw: Scope Symbol tables Today: Type checking

4. 4 Examples of type errors int a; a = true; void foo(int x) { int y; foo(5,7); } 1 < true class A {…} class B extends A { void foo() { A a; B b; b = a; } } argument list doesn’t match formal parameters a is not a subtype of b assigned type doesn’t match declared type relational operator applied to non-int type

5. 5 Types Type  Set of possible values (and operations)  boolean = { true,false }  int = {-2 31..2 31 -1}  void = {} Type safety  Type usage adheres to formally defined typing rules

6. 6 Type judgments e : T  e is a well-typed expression of type T Examples  2 : int  2 * (3 + 4) : int  true : bool  “Hello” : string

7. 7 Type judgments E  e : T In the context E, e is a well-typed expression of T Examples:  b:bool, x:int  b:bool  x:int  1 + x < 4:bool  foo:int->string, x:int  foo(x) : string

8. 8 Typing rules Premise Conclusion [Name] Conclusion [Name]

9. 9 Typing rules for expressions E  e 1 : intE  e 2 : int E  e 1 +e 2 : int [+]

10. 10 Expression rules E  true : bool E  e1 : intE  e2 : int E  e1 op e2 : int E  false : bool E  int-literal : int E  string-literal : string op  { +, -, /, *, %} E  e1 : intE  e2 : int E  e1 rop e2 : bool rop  {, >=}

11. 11 More expression rules E  e1 : boolE  e2 : bool E  e1 lop e2 : bool lop  { &&,|| } E  e1 : int E  - e1 : int E  e1 : bool E  ! e1 : bool E  e1 : T[] E  e1. length : int E  e1 : T[]E  e2 : int E  e1[e2] : T E  e1 : int E  new T[e1] : T[] E  new T() : T E  e:C ( id : T)  C E  e.id : T

12. 12 Subtyping Inheritance induces subtyping relation ≤  S ≤ T  values(S)  values(T)  “A value of type S may be used wherever a value of type T is expected”

13. 13 Subtyping For all types: For reference types: A ≤ A A extends B {…} A ≤ B A ≤ B B ≤ C A ≤ C null ≤ A

14. Examples 1. int ≤ int ? 2. null ≤ A ? 3. null ≤ string ? 4. string ≤ null ? 5. null ≤ boolean ? 6. null ≤ boolean[] ? 7. A[] ≤ B[] ? 14

15. Examples 1. int ≤ int ? 2. null ≤ A ? 3. null ≤ string ? 4. string ≤ null ? 5. null ≤ boolean ? 6. null ≤ boolean[] ? 7. A[] ≤ B[] ? “Subtyping is not covariant for array types: if A is a subtype of B then A[ ] is not a subtype of B[ ]. Instead, array subtyping is type invariant, which means that each array type is only a subtype of itself.” 15

16. 16 Expression rules with subtyping E  e1 : T1 E  e2 : T2 T1 ≤ T2 or T2 ≤ T1 op  {==,!=} E  e1 op e2 : bool

17. 17 Rules for method invocations E  e 0 : T 1  …  T n  T r E  e i : T ’ i T ’ i ≤ T i for all i=1..n E  e 0 (e 1, …,e n ): T r (m : static T 1  …  T n  T r )  C E  e i : T ’ i T ’ i ≤ T i for all i=1..n E  C.m(e 1, …,e n ): T r

18. 18 Statement rules Statements have type void Judgments of the form E  S  In environment E, S is well typed E  e:bool E  S E  while (e) S E  e:bool E  S E  if (e) S E  e:bool E  S 1 E  S 2 E  if (e) S 1 else S 2 E  break E  continue

19. 19 Return statements ret :T r represents return type of current method ret :void  E E  return; ret :T’  E T≤T’ E  return e; E  e:T

20. More IC Rules Declarations Method Class Program … 20

21. 21 Type-checking algorithm 1. Construct types 1. Add basic types to a “type table” 2. Traverse AST looking for user-defined types (classes,methods,arrays) and store in table 3. Bind all symbols to types

22. 22 Type-checking algorithm 2. Traverse AST bottom-up (using visitor) 1. For each AST node find corresponding rule (there is only one for each kind of node) 2. Check if rule holds 1. Yes: assign type to node according to consequent 2. No: report error

23. 23 45 > 32 && !false BinopExpr UnopExpr BinopExpr … op=AND op=NEG op=GT intLiteral val=45 intLiteral val=32 boolLiteral val=false : int : bool E  false : bool E  int-literal : int E  e1 : intE  e2 : int E  e1 > e2 : bool E  e1 : bool E  e2 : bool E  e1 && e2 : bool E  e1 : bool E  !e1 : bool Algorithm example

24. 24 Semantic analysis flow Parsing and AST construction  Combine library AST with IC program AST Construct and initialize global type table  Construct class hierarchy and verify the hierarchy is tree Phase 1: Symbol table construction  Assign enclosing-scope for each AST node Phase 2: Scope checking  Resolve names  Check scope rules using symbol table Phase 3: Type checking  Assign type for each AST node Phase 4: Remaining semantic checks