lecture #15, march. 5, 2007

Cse321, Programming Languages and Compilers

104/19/23

Lecture #15, March. 5, 2007

•Judgments for mini-Java

•Multiple type environments

•Class Hierarchy

•Setting up an ML typechecker for mini-Java

•Subtyping

•Rules for Java

•Declarations as functions over environments


204/19/23

• HW 10, Assigned last week, due Wed,– excellent warmup for project 3

• Project 3 assigned today– See webpage for details


304/19/23

Types for mini-Java

• Mini-Java has two kinds of programs– Expressions

– Statements

• We need a judgment for each kind– Expressions

Th, C, TE |- exp : type

– Statements

R, Th, C, TE |= stmt

• Subtyping judgment– C |~ t1 ≤ t2

• Equality judgment– t1 = t2


404/19/23

Environments• TE - Type environments

– TE(x) = t– The variable x has type t in the environment TE

• R - Return mode– R = { void , explicit t , none}– void means the method has type return type void and no expression is

expected after a return statement– Explicit t means the method has return type t and the argument of a

return must present be a subtype of t

• C - Class Hierarchy– The set of classes is arranged into a hierarchy– Class colorpoint extends point { . . . }– C defines x

» There is a class definition for x

• Th – the type of the self object “this”


504/19/23

Class Hierarchy

object

numericpoint

int double

boolean

colorpoint

void

C |~ int ≤ object

C |~ colorpoint ≤ point

C |~ boolen ≤ object

C defines point


604/19/23

Type Checkers in ML

• To build type-checkers in ML we need– A datatype to represent types

– A datatype (or datatypes) to represent programs (whose type we are checking)

» Expressions

» Statements

» Declarations

– A means for computing equality and subtyping over types

– A means for expressing type errors


804/19/23

Representing Programs 1 - Auxillaries(* A slot of type (`x TC) is an option type. The *)(* parser places NONE there and the type-checker *)(* fills it in with (SOME x) when "x" is known *)

type 'x TC = 'x option;

(******** Representing Programs *******)

datatype Op (* infix operators *) = ADD | SUB | MUL | DIV (* Arithmetic *) | AND | OR (* logical *) | EQ | NE | LT | LE | GT | GE (* relational *)

datatype Constant (* Literal constants *) = Cint of int | Creal of string | Cbool of bool


904/19/23

Representing Programs 2 - expressions

datatype Exp = Literal of Constant (* 5, 6.3, true *) | Binop of Op * Exp * Exp (* x + 3 *) | Relop of Op * Exp * Exp (* x < 7.7 *) | Not of Exp (* ! x *) | ArrayElm of Exp * Exp * (Basic TC) (* x[3] *) | ArrayLen of Exp (* x.length() *) | Call of Exp * Id *(Id TC)* Exp list (* x.f(1,z) *) | NewArray of Basic * Exp (* new int[3] *) | NewObject of Id (* new point() *) (* Coerce is used only in type checking *) | Coerce of Exp


1004/19/23

Representing Programs 3 - statements

datatype Stmt = Block of Stmt list (* {x:5; print(2)} *) | Assign of Exp option * Id * Exp option * Exp (* p.x[2]=5 p.x=5 x=5 *) | CallStmt of Exp * Id * (Id TC)* Exp list (* x.f(1,z) *)

| If of Exp * Stmt * Stmt (* if (p<2) x=5 else x=6 *) | While of Exp * Stmt (* while (p) s *) | PrintE of Exp (* System.out.println(x) *) | PrintT of string (* System.out.println("zbc") *) | Return of Exp option; (* return (x+3) *)


1104/19/23

Representing programs 4 - declarationsdatatype VarDecl = VarDecl of Type * Id * Exp option;

datatype Formal = Formal of Type * Id;

datatype MetDecl = MetDecl of Type * Id *

Formal list * VarDecl list *

Stmt list;

datatype ClassDec

= ClassDec of Id * Id * VarDecl list * MetDecl list;

datatype Program = Program of ClassDec list;


1204/19/23

Type Equality• In mini-Java we need both type equality and sub-

typing

• Type equality for testing that the primitive operators are applied to appropriate expressions of the correct type. Type equality is over basic types.

• Sub-typing for method calls and assignments, testing that actual arguments are subtypes of the formal arguments. Subtyping is over all types.


1304/19/23

Type Equality over basic types

fun typeeq (x,y) =

case (x,y) of

(Real,Real) => true

| (Int,Int) => true

| (Bool,Bool) => true

| (_,_) => false

•Pair wise pattern match over the basic types


1404/19/23

Type equality

fun typeeq (x,y) =

case (x,y) of

(BasicType x,BasicType y) => basiceq(x,y)

| (ArrayType x,ArrayType y) => basiceq(x,y)

| (ObjType x,ObjType y) => x=y

| (VoidType,VoidType) => true

| (_,_) => false


1504/19/23

Subtypingfun subtype classH (x,y) =

case (x,y) of

(x,ObjType “object”) => true

| (BasicType Int,ObjType “numeric”) => true

| (BasicType Real,ObjType “numeric”) => true

| (ObjType x,ObjType y) => useTree classH (x,y)

| (_,_) => typeeq(x,y);

Fun useTree class (x,y) = . . .


1604/19/23

Expressing Errors

• In ML we are lucky to have a rich exception mechanism.

• Design a set of exceptions to report errors.

• You might want to define helper functions

– fun showt t = . . .– fun report exp computed expected = . . .


1704/19/23

Type rules for mini-java• One rule for each piece of syntax• Use the different judgments accordingly

Th, C, TE |- exp : type

Th, R, C, TE |= stmt

C |~ t1 ≤ t2

t1 = t2

C defines x

Th, C, TE |- Y.f : (s1, … ,sn) → t

Th, C, TE |- Y.x : t [ ]

Op <+> : (t1,t2) -> t3

t is basic

x TE and TE (x) = t

Expression has type

Statement is well formed

t1 is a subtype of t2

Class Y has method f with domain and range

Class Y has variable x with type


2304/19/23

New arrays and objects

Th, C, TE |- e : tt is basic----------------------------Th, C, TE |- new t [e] : t [ ]

C defines x----------------------------Th, C, TE |- new x ( ) : x


2404/19/23

Judgments over Statements

• We use a different notation for typing statements

• The judgment for statements does not have a return type.

• It also uses a different “turnstile” symbol.

• R, Th, C, TE |= e1 . x [ e2] = e3


2504/19/23

Static Implicit Assignment

TE (x) = t [ ]

TE |- e2 : int

Th, C, TE |- e3 : t

----------------------------

R, Th, C, TE |= x [ e2] = e3

TE (x) = tTh, C, TE |- e2 : t----------------------------R, Th, C, TE |= x = e2

Static, because the variable is in the type environment.

This means the variable is a either a parameter or local

variable to the current method.


2704/19/23

Hierarchical Implicit Assignment

x TEC defines ThTh, C, TE |- Th.x : t [ ]

Th, C, TE |- e2 : int

Th, C, TE |- e3 : t

----------------------------

R, Th, C, TE |= x [ e2] = e3

x TEC defines ThTh, C, TE |- Th.x : t Th, C, TE |- e2 : t----------------------------R, Th, C, TE |= x = e2

Implicit because the object containg the variable is not

in the code.

These rules hold only if the variable is

not in the type environment


3004/19/23

While and Print statement

R, Th, C, TE |= s1

Th, C, TE |- e1 : boolean-----------------------------------------R, Th, C, TE |= while ( e1 ) s1

t is basic Th, C, TE |- x : t--------------------------------------------------------R, Th, C, TE |= System.out.println ( x )

R, Th, C, TE |= System.out.println ( “literal string” )


3104/19/23

Return statement

Void, Th, C, TE |= return

C |~ t ≤ s

Th, C, TE |- e : s--------------------------------------------------

Explicit t, Th, C, TE |= return e


3304/19/23

Sequences of statements

R, Th, C, TE |= si ----------------------------

R, Th, C, TE |= { s1, … ,sn }


3404/19/23

Declarations

• Declarations are type-environment to type-environment functions.

R, Th, C, TE |= decl → R, Th, C, TE

There are four kinds of declarations– Var-declarations

– Method-declarations

» Are mutually recursive

– Class-declarations

– Main method declaration

» There is only one of these in any program


3504/19/23

One Var declaration

R, Th, C, TE |= t x ; → R, Th, C, TE+(x:t)

Th, C, TE |- e : t

--------------------------------------------------------------------

R, Th, C, TE |= t x = e ; → R, Th, C, TE+(x:t)


3604/19/23

Many Var declarations

R, Th, C, TE |= d1 → R1, Th1, C1, TE1

R1, Th1, C1, TE1 |= d2 → R2, Th2, C2, TE2

R2, Th2, C2, TE2 |= d3 → R3, Th3, C3, TE3

--------------------------------------------------------------------------------------

R, Th, C, TE |= {d1; d2; d3; …} → R3, Th3, C3, TE3


3704/19/23

Mutually recursive Method Declaration

TEA = TE + (f1,method Th (t11, … ,tn

1) →t1) + … +

(fk,method Th (t1k, … ,tn

k) →tk)

TEA |= (t1k x1

k, … tnk xn

k) → TEBk

TEBk |= (v1; … ; vi ) → TEC

k

tk, Th, C, TECk |= {s1; … ;sj }

----------------------------------------------------------------------

R, Th, C, TE |=

{ public t1 f1 (t1 x1, … tn xn) { v1; … ; vi ; s1; … ;sj }

; … ;

public tk fk (t1 x1, … tn xn) { v1; … ; vi ; s1; … ;sj } } →

R, Th, C, TEA


3804/19/23

Class Declarations

• Class declarations extend the Class heirarchy

R, Th, C+(y/x), TE |=

{ v1; … ; vi ; m1; … ;mj } →

R2, Th2, C2 TE2

--------------------------------------------------------------

R, Th, C, TE |=

Class x extends y { v1; … ; vi ; m1; … ;mj } →

R2, Th2, C2 TE2


3904/19/23

New Boiler plate for Parser

structure ProgramTypes = struct

(* Put type declarations here that you *)(* want to appear in both the parser *)(* and lexer. You can open this structure *)(* else where inside your application as well(* I’ve put the datatypes for the syntax here to start *)

end;

group is ProgramTypes.sml Mini.lex Mini.grm Driver.sml TypeCheck.sml $/basis.cm $/smlnj-lib.cm $/ml-yacc-lib.cm

Mini.cm

ProgramTypes.sml

lecture #15, march. 5, 2007

Documents