Compilation 2013 Semantic Analysis

Transcription

1 Compilation 2013 Semantic Analysis Erik Ernst Aarhus University

2 Semantic Analysis The meaning of a program: Above the contextfree level Use general programming to compute well-formedness representation resource management Types may represent several of these aspects exceptions exist, e.g., correct placement of break 2

3 Symbol Tables Re: A symbol table maps names to meanings in some context (e.g., the type) Names are declarations or applications, exting sym.tabs resp. looking up the meaning Static, lexical scoping stack discipline Need undo to recover sym.tab. after scope s 3

4 An Imperative Symbol Table Note that binding needs to vary with the purpose Note that arrays are mutable (no ref needed!) val SIZE = 109 type binding =... type bucket = (string * binding) list type table = bucket Array.array val t: table = Array.array (SIZE, nil) fun hash (s: string): int = CharVector.foldl (fn (c,n) => (n*256+ord(c)) mod SIZE) 0 s fun insert (s: string, b: binding) = let val i = hash s in Array.update (t, i, (s,b)::array.sub(t,i))... Semantic Analysis 4

5 Note that hash is called all the time Note: insert/pop calls must correspond exactly!... exception NotFound An Imperative Symbol Table fun lookup (s: string) = let val i = hash s fun search ((s,b)::rest) = if s=s' then b else search rest search nil = raise NotFound in search (Array.sub (t,i)) fun pop (s: string) = let val i = hash s val (s,b)::rest = Array.sub (t,i) in assert (s=s ); Array.update (t,i,rest) Semantic Analysis 5

6 Example: Symbol Table Stack Discipline Starting from σ 0 the environment changes at name declarations, σ 0 σ 1 σ 2 σ 3 σ 1 σ 0 Transitions like σ 0 σ 1 require adding: override Transitions like σ 1 σ 0 require undo (pop + ) {g string, a int} = σ 0 function f(a:int, b:int, c:int) = σ 0 + {a int, b int, c int} = σ 1 ( print_int(a+c) σ 1 ; let var j := a+b σ 1 + {j int} = σ 2 var a := "hello" σ 2 + {a string} = σ 3 in print(a); print_int(j) σ 3 σ 1 ; print_int(b)) σ 0 σ 0 6

7 Symbol Table Stack Discipline Using a functional approach: Transition σ 0 σ 1, adding: build new, use sharing Transition σ 1 σ 0, undo : simply use older table again Safe, simple, used for Tiger but do use the right one! {g string, a int} = σ 0 function f(a:int, b:int, c:int) = σ 0 + {a int, b int, c int} = σ 1 ( print_int(a+c) σ 1 ; let var j := a+b σ 1 + {j int} = σ 2 var a := "hello" σ 2 + {a string} = σ 3 in print(a); print_int(j) σ 3 σ 1 ; print_int(b)) σ 0 σ 0 7

8 Tiger Compiler Symbol Table Signature SYMBOL NB: table polymorphic, symbol eqtype signature SYMBOL = sig eqtype symbol val symbol: string -> symbol val name: symbol -> string type 'a table val empty: 'a table val enter: 'a table * symbol * 'a -> 'a table val look: 'a table * symbol -> 'a option Semantic Analysis 8

9 Tiger Compiler Symbol Table structure Symbol :> SYMBOL = struct structure HT = HashTable structure HS = HashString type symbol = string * int exception Symbol val nextsym = ref 0 val hashtable: (string, int) HT.hash_table = HT.mkTable (HS.hashString, op= ) (128, Symbol) fun symbol name = case HT.find hashtable name of SOME i => (name, i) NONE => let val i =!nextsym in nextsym := i+1; HT.insert hashtable (name, i); (name, i) fun name (s, n) = s type 'a table = 'a IntBinaryMap.map val empty = IntBinaryMap.empty fun enter (t, (s,n), a) = IntBinaryMap.insert (t, n, a) fun look (t, (s,n)) = IntBinaryMap.look (t, n) structures types, exc state functions symbol tables! Semantic Analysis 9

10 Tiger Compiler Symbol Table structure Symbol :> SYMBOL = struct structure HT = HashTable structure HS = HashString type symbol = string * int exception Symbol val nextsym = ref 0 val hashtable: (string, int) HT.hash_table = HT.mkTable (HS.hashString, op= ) (128, Symbol) fun symbol name = case HT.find hashtable name of SOME i => (name, i) NONE => let val i =!nextsym in nextsym := i+1; HT.insert hashtable (name, i); (name, i) fun name (s, n) = s type 'a table = 'a IntBinaryMap.map val empty = IntBinaryMap.empty fun enter (t, (s,n), a) = IntBinaryMap.insert (t, n, a) fun look (t, (s,n)) = IntBinaryMap.look (t, n) Semantic Analysis structures types, exc state functions symbol tables! NB: The symbol is the int 9

11 Representation of Types Almost enough to mimic the syntax but note uniqueness and error structure Types : TYPES = struct type unique = unit ref datatype ty = INT STRING RECORD of (Symbol.symbol * ty) list * unique ARRAY of ty * unique NIL UNIT NAME of Symbol.symbol * ty option ref ERROR (* ambiguity exists due to type error *) 10

12 Unique : Nominal Type Equivalence Nominal type equivalence known from Java etc.: class C1 {.. /* some declarations */..} class C2 {.. /* identical to C1, rename as needed */..} Even though declarations are identical, these classes are not the same type Tiger uses nominal type eq. for records and arrays: unit ref is always a unique value structure Types : TYPES = struct type unique = unit ref datatype ty =... RECORD of (Symbol.symbol * ty) list * unique ARRAY of ty * unique... 11

13 Representation of Environments Note incompleteness (formals: only types) Will return to access later signature ENV = sig type access type ty = Types.ty datatype enventry = VarEntry of {ty: ty} FunEntry of {formals: ty list, result: ty} val base_tenv: ty Symbol.table val base_venv: enventry Symbol.table 12

14 Top-down & bottom-up Type-checking Basics type of name application from environment, top-down type of composite (e.g., expression) built inductively Basic definitions for Tiger (Re: namespaces): type tenv = Types.ty Symbol.table type venv = Env.enventry Symbol.table type expty = {exp: Translate.exp, ty: Types.ty} transty: tenv * Absyn.ty -> Types.ty transvar: venv * tenv * Absyn.var -> expty transexp: venv * tenv * Absyn.exp -> expty transdec: venv * tenv * Absyn.dec -> {venv: venv, tenv: tenv} structure Translate = struct type exp = unit /* dummy, will be elaborated later */ 13

15 Type-checking Expressions: Bottom-up Bottom-up analysis ~ proof by induction Pattern matching ( left vs. oper=.., using _) fun transexp ( venv, tenv, Absyn.OpExp {left,oper=absyn.plusop,right,pos}) = let val {exp=_, ty=tyleft} = transexp (venv, tenv, left) val {exp=_, ty=tyright} = transexp (venv, tenv, right) in case tyleft of Types.INT => () _ => error pos "integer required"; case tyright of Types.INT => () _ => error pos "integer required" {exp=(), ty=types.int} Semantic Analysis 14

16 Reorganizing transexp structure A = Absyn fun checkint ({exp,ty},pos) = (...) fun transexp (venv, tenv) = let fun trexp (A.OpExp {left,oper=absyn.plusop,right,pos}) = ( checkint (trexp left, pos) ; checkint (trexp right, pos) ; {exp=(), ty=types.int}) fun trexp (A.RecordExp...) = and fun trvar (A.SimpleVar (id, pos)) = (case Symbol.look (venv, id) of SOME (E.VarEntry {ty}) => {exp=(), ty = actualty ty} NONE => (error pos "Undefined variable " ^ S.name id; {exp=(), ty=types.error}) trvar (A.FieldVar (v, id, pos)) =... in trexp Semantic Analysis NB: transexp now curried => missing 3rd argument 15

17 Type-checking Declarations General Tiger declarations are in let Below: Simple general treatment, complexity in cases Variable declarations: Easy Type declarations: Consider an easy case Function declarations: Consider an even easier case ;-) fun transexp (venv, tenv) =... trexp (A.LetExp {decs,body,pos}) = let val {venv=venv', tenv=tenv'} = transdecs (venv, tenv, decs) in transexp (venv', tenv') body... Semantic Analysis 16

18 Type-checking Variable Declarations Variable declaration: Easy! Basic idea: Declaration = environment transformer Consider treatment of var x := e fun transdec ( venv, tenv, A.VarDec {name, typ=none, init,...}) = let val {exp,ty} = transexp (venv, tenv) init in { tenv = tenv, venv = S.enter ( venv, name, E.VarEntry {ty=ty})} NB: We need another pattern typ=.. to handle var x: T := e Semantic Analysis 17

19 Type-checking Type Declarations Focus on easy case! just one type Idea: Transform syntax to meaning transdec (venv, tenv, A.TypeDec [{name,ty}]) = { venv = venv, tenv = S.enter ( tenv, name, transty (tenv, ty))} Note lack of generality Recursion: Later structure Types : TYPES = struct type unique = unit ref datatype ty = INT STRING RECORD of (Symbol.symbol * ty) list * unique ARRAY of ty * unique NIL UNIT NAME of Symbol.symbol * ty option ref ERROR Semantic Analysis 18

20 Translating Type Expressions Mainly a cleanup job just construct the obvious Types.ty from the given Absyn.TypeDec NB: Just a skeleton several times more code with error checking fun transty (tenv, t) = let fun getfieldty {name, typ,...} = (name, S.look tenv (#1 typ)) fun getfieldtys fields = map getfieldty fields in case t of A.NameTy (sym, pos) => S.look tenv sym A.RecordTy fields => Ty.RECORD (getfieldtys fields, ref ()) A.ArrayTy (sym, pos) => Ty.ARRAY (S.look tenv sym, ref ()) Semantic Analysis 19

21 Type-checking a Function Declaration Lots of stuff to consider! Simple case here. Basic idea: Deal with all syntactic elements transdec (venv, tenv, A.FunctionDec [{ name, params, body, pos,, result = SOME (rt,pos)}]) = let val SOME resultty = S.look (tenv, rt) fun transparam {name, typ, pos} = case S.look (tenv, typ) of SOME t => {name = name, ty = t} val params' = map transparam params val venv' = S.enter ( venv, name, E.FunEntry { formals = maps #ty params', result = resultty}) fun enterparam ({name,ty}, venv) = S.enter (venv, name, E.VarEntry {access = (), ty = ty}) val venv'' = foldl enterparam params' venv' in transexp (venv'', tenv) body; {venv = venv', tenv = tenv} Semantic Analysis 20

22 Type-checking a Function Declaration Incompleteness of this solution: Only one function (singleton list) No recursion (self or mutual) No error handling (check SOME t ) No type check on returned value Complete solution systematically built from this Semantic Analysis 21

23 Supporting Recursion Crucial feature with recursive data types ( anything having unbounded size ) Two-phase approach: Visit all mutually recursive declarations, add header Revisit declarations, check body Requires circular data ( enable unlimited walk ) Cannot be built bottom-up, only trees can: Need mutable state! 22

24 Recursion Enabler: Types.NAME NAME types forward to other types Note option: May be unresolved type list = {first: int, rest: list} Initial tenv entry: type list =?, i.e.: tenv' = S.enter( tenv, name, NAME (name, ref NONE)) Call transty on {first: int, rest: list} with tenv' as type environment After both phases: cyclic structure in place structure Types : TYPES = struct type unique = unit ref datatype ty = INT STRING RECORD of (Symbol.symbol * ty) list * unique ARRAY of ty * unique NIL UNIT NAME of Symbol.symbol * ty option ref ERROR 23

25 Type Checking as Inference Rules Idea: Premises (top) imply conclusion (bottom) If e 1 has type INT and e 2 has type INT, then e 1 + e 2 has type INT The system is not complete, e.g., we do not handle declarations Δ;Γ e 1 :INT Δ;Γ e 2 :INT Δ;Γ e 1 + e 2 :INT 24

26 Inference Rules vs Implementation Each premise and conclusion is a judgment Environments given to the left of each judgment Syntax corresponds to Absyn values Types correspond to Types values Δ;Γ e 1 :INT Δ;Γ e 2 :INT Δ;Γ e 1 + e 2 :INT tenv venv Absyn.OpExp {..PlusOp..} Types.ty 25

27 Inference Rules vs Implementation Environment lookup corresponds to simple rules Note use of actualty to eliminate NAME types val (SOME Env.VarEntry {ty}) = Symbol.look (venv, sym) val ty = actualty ty sym venv Γ(x) = T Δ;Γ x:t ty 26

28 Inference Rule: If-then Illustrating valueless expression, multiple types Δ;Γ e 1 :INT Δ;Γ e 2 :UNIT Δ;Γ if e 1 then e 2 : UNIT 27

29 Inference Rule: If-then-else Illustrating the use of a type variable: T can be any well-formed type Δ;Γ e 1 :INT Δ;Γ e 2 :T Δ;Γ e 3 :T Δ;Γ if e 1 then e 2 else e 3 : T 28

30 Inference Rule: If-then-else Illustrating the use of a type variable: T can be any well-formed type Δ;Γ e 1 :INT Δ;Γ e 2 :T Δ;Γ e 3 :T Δ;Γ if e 1 then e 2 else e 3 : T (NB: Subsumed by later rules!) 28

31 Inference Rule: Wrong addition Illustrating simple error handling: Report error because addition is incorrect, but use type INT in conclusion because no other type is possible in corrected program Δ;Γ e 1 :S Δ;Γ e 2 :T S INT T INT Δ;Γ e 1 + e 2 :INT 29

32 Checking Type-correct Equality Δ;Γ e 1 :S Δ;Γ e 2 :T eqok(s,t ) Δ;Γ e 1 = e 2 : INT fun eqok (INT,INT) = true... (* + other simple cases, except (NIL,NIL) *) eqok (RECORD (_,u1), RECORD (_,u2)) = (u1=u2) eqok (RECORD _, NIL) = true eqok (NIL, RECORD _) = true... eqok (ERROR,_) = true (* no error message: has *) eqok (_,ERROR) = true (* been reported already *) eqok _ = false eqok as premise: Rule only applicable when eqok true 30

33 Checking Type-incorrect Equality Δ;Γ e 1 :S Δ;Γ e 2 :T eqok(s,t ) Δ;Γ e 1 = e 2 : INT fun eqok (INT,INT) = true... (* + other simple cases, except (NIL,NIL) *) eqok (RECORD (_,u1), RECORD (_,u2)) = (u1=u2) eqok (RECORD _, NIL) = true eqok (NIL, RECORD _) = true... eqok (ERROR,_) = true (* no error message: has *) eqok (_,ERROR) = true (* been reported already *) eqok _ = false Report error: Error always introduced when eqok 31

34 Checking if-then-else with OK Guard Improving on earlier rule Δ;Γ e 1 :INT Δ;Γ e 2 :S Δ;Γ e 3 :T U = ifcomb(s,t ) Δ;Γ if e 1 then e 2 else e 3 : U fun ifcomb (ERROR,_) = ERROR ifcomb (_,ERROR) = ERROR ifcomb (S as RECORD _, NIL) = S ifcomb (NIL, T as RECORD _) = T... ifcomb (S,T) = if S=T then S else ERROR Report error if introduced 32

35 Checking If-then-else with Wrong Guard Δ;Γ e 1 :T Δ;Γ e 2 :S Δ;Γ e 3 :T T INT U = ifcombw(s,t ) Δ;Γ if e 1 then e 2 else e 3 : U fun ifcombw (S,T) = if S=T then S else ERROR Report error that guard is not INT unless ERROR already Possibly report error for differently typed if-branches 33

36 Inference Rule: Function Call Illustrating a variable number of premises Note that we check both the number of arguments and the type of each of them Note that we can add f to the environment Γ when checking the body of f itself: Two phases.. Γ(f)= S 1 S k T Δ;Γ e i :S i for i=1 k Δ;Γ f(e 1 e k ): T 34

37 Summary Semantic analysis: Above CFG, general Major element: Type-checking: well-formedness, representation, choice of variant,... Tool: Symbol table (imp./func.), stack discipline Representation of types, environments Bottom-up type-checking: Expressions Top-down: Environments, name applications Type-checking declarations Recursion: Header phase + Body phase + NAME Inference rules: Concise and useful notation 35