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

errors

source code

errors

parse generate

machine code

source code

parse generate

machine code

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

ESV editor

SPT tests

syntax definition

concrete syntax

abstract syntax

static semantics

name binding

type system

dynamic semantics

translation

interpretation

Static Analysis and Error Checking

Stratego

NaBL TS

ESV editor

SPT tests

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

formal grammars

context-sensitive

context-free

regular

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}

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

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 scoping

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"))])

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

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

Declarative Semantics Definition - Static Analysis and Error Checking

Education

Transcript of Declarative Semantics Definition - Static Analysis and Error Checking

A declarative framework for object-oriented programming ... · Keywords: Object-oriented declarative programming; Genetic inheritance; Algebraic semantics; Paradigm integration 1.Introduction

Declarative Services

A core Erlang semantics for declarative debugginggpd.sip.ucm.es/rafa/papers/jlamp19.pdf · A core Erlang semantics for declarative debugging. ... establish the correctness of tools.

Requirements-Level Semantics and Model Checking …is.tm.tue.nl/staff/heshuis/req.pdf · Requirements-Level Semantics and Model Checking of Object-Oriented Statecharts ... McMenamin

SystemC Semantics by Actors and Reduction Techniques in Model Checking

XML based information systems and formal semantics of …€¦ · XML based information systems and formal semantics of programming languages 3 computer sciences: model checking and

Robust Distributed System Nucleus (rDSN) · Program Test Debug Perf Tuning Deploy Operate Analysi s Fault injection Model checking Global assertion Declarative Scenario test … Replay

Model checking security properties of control flow graphs2.1 Trace semantics for control flow graphs The operational semantics of a flow graph is defined as a transition system

Declarative Programming

IKI30820 -- Logic Programming Semantic Aspects of Prolog ...ocw.ui.ac.id/materials/12.01_FASILKOM/IKI30820-Pemrograman_Logika/... · Outline 1 General overview 2 Declarative semantics

A Lightweight Approach for Deﬁning the Formal Semantics of ...bochmann/talks/MODELS 2008... · guages, type checking, meta-modeling and operational semantics. Al-though both Alloy

Pnueli & Shalev’s declarative semantics

Declarative Indexes

Declarative sentences

Declarative Design

GENERAL SEMANTICS - Andrew M. BaileyGENERAL SEMANTICS 23 to non-declarative sentences, but postpone consideration of them.) Similarly, a meaning for a name is something that determines

Aligning Event Logs and Declarative Process Models for ... · Aligning Event Logs and Declarative Process Models for Conformance Checking Massimiliano de Leoni?, Fabrizio M. Maggi,

Declarative Memory

Jinq: LINQ-style Queries in Java 8 - oracle.com · LINQ Syntax •Use lambdas as operations over collections •Automatic Java type checking and syntax checking •Uses familiar semantics

Programming in Logic: Prolog - University of Auckland · MB: 2 March 2001 CS360 Lecture 3 1 Programming in Logic: Prolog Prolog’s Declarative & Procedural Semantics Readings: Sections