Declarative Semantics Definition - Static Analysis and Error Checking

IN4303 2014/15 Compiler Construction

Declarative Semantics Definition static analysis and error checking

Guido Wachsmuth

Static Analysis and Error Checking 2

source code


source code

parse


source code

errors

parse

check


source code

errors

parse generate

check

machine code


source code


source code

parse


source code

parse

check


source code

parse generate

machine code

check


static checking

name analysis name binding and scope


static checking

editor services



static checking

editor services

transformation



static checking

editor services

transformation

refactoring



static checking

editor services

transformation

refactoring

code generation


Static Analysis and Error Checking

Stratego

NaBL TS

SDF3

ESV editor

SPT tests

5

syntax definition

concrete syntax

abstract syntax

static semantics

name binding

type system

dynamic semantics

translation

interpretation

Static Analysis and Error Checking

Stratego

NaBL TS

SDF3

ESV editor

SPT tests

6

syntax definition

concrete syntax

abstract syntax

static semantics

name binding

type system

dynamic semantics

translation

interpretation


formal semantics

type system

name binding

testing

name binding

type system

constraints

specification

name binding

type system

constraints


formal semantics static semantics


word problem χL: Σ*→ {0,1}

w → 1, if w∈L

w → 0, else

theoretical computer science decidability & complexity



w → 1, if w∈L

w → 0, else

decidability

type-0: semi-decidable

type-1, type-2, type-3: decidable




w → 1, if w∈L

w → 0, else

decidability



complexity

type-1: PSPACE-complete

type-2, type-3: P




w → 1, if w∈L

w → 0, else

decidability



complexity

type-1: PSPACE-complete

type-2, type-3: P


PSPACE⊇NP⊇P


formal grammars

context-sensitive

context-free

regular



/* factorial function */!let ! var x := 0! function fact(n : int) : int = if n < 1 then 1 else (n * fact(n - 1))!in ! for i := 1 to 3 do ( x := x + fact(i); printint(x); print(" ") )!end


#include <stio.h>!/* factorial function */!int fac(int num) { if (num < 1) return 1; else return num * fac(num - 1);}!int main() { printf(“%d! = %d\n”, 10, fac(10)); return 0;}


class Main {! public static void main(String[] args) { System.out.println(new Fac().fac(10)); }}!class Fac {! public int fac(int num) { int num_aux; if (num < 1) num_aux = 1; else num_aux = num * this.fac(num - 1); return num_aux; }}


static semantics restricting context-free languages

context-sensitive language

context-free grammar

L(G) = {w∈Σ* | S ⇒G* w}


context-free superset




L(G) = {w∈Σ* | S ⇒G* w}






L(G) = {w∈Σ* | S ⇒G* w}

static semantics

L = {w∈ L(G) | ⊢ w}






L(G) = {w∈Σ* | S ⇒G* w}

static semantics

L = {w∈ L(G) | ⊢ w}

judgements

well-formed ⊢ w

well-typed E ⊢ e : t


formal semantics type systems


Tiger type system

E ⊢ i : int

E ⊢ s : string

E ⊢ nil : ⊥


Tiger type system

E ⊢ () : ∅

E ⊢ e1 : t1 E ⊢ e2 : t2

E ⊢ e1 ; e2 : t2


Tiger type system

E ⊢ e1 : int E ⊢ e2 : int

E ⊢ e1 + e2 : int


E ⊢ e1 < e2 : int

E ⊢ e1 : string E ⊢ e2 : string

E ⊢ e1 < e2 : int

E ⊢ e1 : array of t E ⊢ e2 : int

E ⊢ e1[e2] : t


Tiger type system

E ⊢ e1 : t1 E ⊢ e2 : t2 t1 ≅ t2

E ⊢ e1 = e2 : int

t1 <: t2

t1 ≅ t2

t2 <: t1

t1 ≅ t2

t ≠ ∅

t ≅ t

⊥<: {f1, …, fn}

⊥<: array of t


Tiger type system

E ⊢ e1 : t1 E ⊢ e2 : t2 t1 ≅ t2

E ⊢ e1 := e2 : ∅

E ⊢ e1 : int E ⊢ e2 : t1 E ⊢ e3 : t2

E ⊢ if e1 then e2 else e3: sup<: {t1, t2}


formal semantics name binding


Tiger scoping

let type t = u type u = int var x: u := 0in x := 42 ; let type u = t var y: u := 0 in y := 42 endend


Tiger variable names

E ⊢ e1 : t1 t ≅ t1 E ⊕ v ↦ t ⊢ e2 : t2

E ⊢ let var v : t = e1 in e2: t2

E(v) = t

E ⊢ v : t


Tiger function names

E ⊕ v1 ↦ t1 ,…, vn ↦ tn ⊢ e1 : tf E ⊕ f ↦ t1 × … × tn → tf ⊢ e2 : t

E ⊢ let function f (v1 : t1, …, vn : tn) = e1 in e2: t

E(f) = t1 × … × tn → tf e1 : t1 … en : tn

E ⊢ f (e1, …, en) : t


testing


test outer name [[ let type t = u type [[u]] = int var x: [[u]] := 0 in x := 42 ; let type u = t var y: u := 0 in y := 42 endend]] resolve #2 to #1

test inner name [[ let type t = u type u = int var x: u := 0 in x := 42 ; let type [[u]] = t var y: [[u]] := 0 in y := 42 endend]] resolve #2 to #1

Testing name binding


test integer constant [[ let type t = u type u = int var x: u := 0 in x := 42 ; let type u = t var y: u := 0 in y := [[42]] endend]] run get-type to IntTy()

test variable reference [[ let type t = u type u = int var x: u := 0 in x := 42 ; let type u = t var y: u := 0 in y := [[x]] endend]] run get-type to IntTy()

Testing type system


test undefined variable [[ let type t = u type u = int var x: u := 0 in x := 42 ; let type u = t var y: u := 0 in y := [[z]] endend]] 1 error

test type error [[ let type t = u type u = string var x: u := 0 in x := 42 ; let type u = t var y: u := 0 in y := [[x]] endend]] 1 error

Testing constraints



testing static semantics

language


specification name binding


defines !

refers!

namespaces!

scopes!

imports

Name Binding Language concepts


Name Binding Language definitions and references

TypeDec(t, _): defines Type t Tid(t) : refers to Type t



Name Binding Language unique definitions

TypeDec(t, _): defines unique Type t Tid(t) : refers to Type t



Name Binding Language namespaces

let type mt = int type rt = {f1: string, f2: int} type at = array of int! var x := 42 var y: int := 42! function p() = print("foo") function sqr(x: int): int = x*xin … end

namespaces Type Variable Function!TypeDec(t, _): defines unique Type t!FunDec(f, _, _): defines unique Function fFunDec(f, _, _, _): defines unique Function fCall(f, _) : refers to Function f!VarDec(v, _): defines unique Variable vFArg(a, _): defines unique Variable aVar(v): refers to Variable v


Name Binding Language scopes

FunDec(f, _, _): defines unique Function f scopes Variable!FunDec(f, _, _, _): defines unique Function f scopes Variable Let(_, _): scopes Type, Function, Variable



Name Binding Language definition scopes

for x := 0 to 42 do x;For(v, start, end, body): defines Variable v in body


Spoofax bound renaming


let type t0 = u0 type u0 = int var x: u0 := 0in x := 42 ; let type u1 = t0 var y: u1 := 0 in y := 42 endend


Spoofax annotated terms

t{t1, ..., tn}!!!

add additional information to a term but preserve its signature


specification type system


TS axioms

type rules! Int(_) : IntTy() String(_): StringTy()!signatures! NilTy: Type type rules! Nil(): NilTy()

E ⊢ i : int

E ⊢ s : string

E ⊢ nil : ⊥


TS inference rules

type rules! Add(e1,e2): IntTy() where e1: ty1 and ty1 == IntTy() and e2: ty2 and ty2 == IntTy()


E ⊢ e1 + e2 : int


TS inference rules

type rules! Lt(e1,e2): IntTy() where e1: ty1 and e2: ty2 and ( ( ty1 == IntTy() and ty2 == IntTy() ) or ( ty1 == StringTy() and ty2 == StringTy() ) )


E ⊢ e1 < e2 : int

E ⊢ e1 : string E ⊢ e2 : string

E ⊢ e1 < e2 : int


NaBL and TS interaction

type rules! Var(x): ty where definition of x: ty

binding rules! VarDec(x, ty): defines unique Variable x of type ty


NaBL and TS interaction

FArg(a, t): defines unique Variable a of type t!FunDec(f, a*, e): defines unique Function f of type (t*, t) where a* has type t* and e has type t!Call(f, a*) : refers to Function f of type (t*, _) where a* has type t*


specification constraints


TS type errors

type rules! Add(e1,e2): IntTy() where e1: ty1 and ty1 == IntTy() else error "…" on e1 and e2: ty2 and ty2 == IntTy() else error "…" on e2


E ⊢ e1 + e2 : int


TS missing definitions

type rules! Var(x): ty where definition of x: ty else error "…" on x

Static Analysis and Error Checking48 48

Spoofax origin tracking

let var x := 21 in y * 2 end




Let([VarDec("x", Int("21"))], [Times(Var("y"), Int("2"))])





desugar: Times(e1, e2) -> Bop(MUL(), e1, e2)






Let([VarDec("x", Int("21"))], [Bop(MUL(), Var("y"), Int("2"))])







Let([VarDec("x"{"…"}, Int("21"))], [Bop(MUL(), Var("y"), Int("2"))])







Let([VarDec("x"{"…"}, Int("21"))], [Bop(MUL(), Var("y"), Int("2"))])

Var(x): ty where definition of x: ty else error "…" on x


derivation of editor services

error checking

reference resolution

code completion

Spoofax static analysis



error checking


code completion

multi-file analysis




error checking


code completion

multi-file analysis

parallel analysis




error checking


code completion

multi-file analysis

parallel analysis

incremental analysis



Except where otherwise noted, this work is licensed under

http://creativecommons.org/licenses/by/4.0/




































attribution

slide title author license

1 Inspection Kent Wien CC BY-NC 2.0

2, 3 PICOL icons Melih Bilgil CC BY 3.0

10 Noam Chomsky Maria Castelló Solbes CC BY-NC-SA 2.0

11, 16-20, 22-24 Tiger Bernard Landgraf CC BY-SA 3.0

12 The C Programming Language Bill Bradford CC BY 2.0

13 Italian Java book cover

http://www.flickr.com/photos/flyforfun/2638180406/

http://www.flickr.com/photos/flyforfun/

https://creativecommons.org/licenses/by-nc/2.0/

http://www.picol.org

https://creativecommons.org/licenses/by/3.0/

http://www.flickr.com/photos/fellowsisters/2710276258/

http://www.flickr.com/photos/fellowsisters/

https://creativecommons.org/licenses/by-nc-sa/2.0/

http://commons.wikimedia.org/wiki/File:Panthera_tigris_2.jpg

http://commons.wikimedia.org/wiki/User:Baerni

http://creativecommons.org/licenses/by-sa/3.0/deed.en

http://www.flickr.com/photos/mrbill/2482009942/

http://www.flickr.com/people/mrbill/

https://creativecommons.org/licenses/by/2.0/

http://duke.kenai.com/italian/

Declarative Semantics Definition - Static Analysis and Error Checking

Education

Transcript of Declarative Semantics Definition - Static Analysis and Error Checking