Announcements. Written Assignment 2 Due Monday at 5:00PM. Midterm next Wednesday in class, 11:00 1:00. Midterm review session next Monday in class.
|
|
|
- Donald King
- 5 years ago
- Views:
Transcription
1 Type-Checking II
2 Announcements Written Assignment 2 Due Monday at 5:00PM. Office hours today, Sunday, and Monday. Ask questions on Piazzza! the staff list with questions! Midterm next Wednesday in class, 11:00 1:00. Midterm review session next Monday in class. We'll post practice midterms online. Midterm covers all of scanning and parsing, but not semantic analysis. Open-book, open-notes, open-computer, closed-network. OH switch next week: Monday office hours in Gates B24A, Friday office hours in Gates 160 at the scheduled times.
3 Where We Are Source Code Lexical Analysis Syntax Analysis Semantic Analysis IR Generation IR Optimization Code Generation Optimization Machine Code
4 Review from Last Time Static type checking in Decaf consists of two separate processes: Inferring the type of each expression from the types of its components. Confirming that the types of expressions in certain contexts matches what is expected. Logically two steps, but you will probably combine into one pass.
5 Review from Last Time while (numbitsset(x + 5) <= 10) { if ( ) { /* */ while (5 == null) { /* */
6 Review from Last Time while (numbitsset(x + 5) <= 10) { if ( ) { /* */ while (5 == null) { /* */
7 Review from Last Time while (numbitsset(x + 5) <= 10) { if ( ) { /* */ while (5 == null) { /* */
8 Review from Last Time while (numbitsset(x + 5) <= 10) { if ( ) { /* */ while (5 == null) { /* */ Well-typed expression with wrong type.
9 Review from Last Time while (numbitsset(x + 5) <= 10) { if ( ) { /* */ while (5 == null) { /* */
10 Review from Last Time while (numbitsset(x + 5) <= 10) { if ( ) { /* */ while (5 == null) { /* */ Expression with type error
11 Review from Last Time We write S e : T if in scope S, the expression e has type T.
12 Review from Last Time f is an identifier. f is a non-member function in scope S. f has type (T 1,, T n ) U S e i : T i for 1 i n S f(e 1,..., e n ) : U Read rules like this
13 Review from Last Time f is an identifier. f is a non-member function in scope S. f has type (T 1,, T n ) U S e i : T i for 1 i n S f(e 1,..., e n ) : U
14 Review from Last Time We say that A B if A is convertible to B. The least upper bound of A and B is the class C where A C B C C C' for all other upper bounds. The least upper bound is denoted A B when it exists. A minimal upper bound of A and B is an upper bound of A and B that is not larger than any other upper bound.
15 Review from Last Time f is an identifier. f is a non-member function in scope S. f has type (T 1,, T n ) U S e i : R i for 1 i n R i T i for 1 i n S f(e 1,..., e n ) : U
16 Review from Last Time S null : null type
17 Overview for Today Type-checking statements. Practical type-checking considerations. Type-checking practical language constructs: Function overloading. Specializing overrides.
18 Using our Type Proofs We can now prove the types of various expressions. How do we check... that if statements have well-formed conditional expressions? that return statements actually return the right type of value? Use another proof system!
19 Proofs of Structural Soundness Idea: extend our proof system to statements to confirm that they are well-formed. We say that S WF( stmt) if the statement stmt is well-formed in scope S. The type system is satisfied if for every function f with body B in scope S, we can show S WF(B).
20 A Simple Well-Formedness Rule S expr : T S WF( expr;)
21 A Simple Well-Formedness Rule S expr : T S WF( expr;) If we can assign a valid type to an expression in scope S
22 A Simple Well-Formedness Rule S expr : T S WF( expr;) If we can assign a valid type to an expression in scope S then it is a valid statement in scope S.
23 A More Complex Rule
24 A More Complex Rule S S WF( stmt 1 ) WF( stmt 2 ) S WF( stmt 1 stmt 2 )
25 Rules for break
26 Rules for break S is in a for or while loop. S WF( break;)
27 A Rule for Loops
28 A Rule for Loops S expr : bool S' is the scope inside the loop. S' WF( stmt) S WF( while (expr) stmt)
29 Rules for Block Statements
30 Rules for Block Statements S' is the scope formed by adding decls to S S' WF( stmt) S WF( { decls stmt )
31 Rules for return
32 Rules for return S is in a function returning T S expr : T' T' T S is in a function returning void S WF( return expr;) S WF( return;)
33 Checking Well-Formedness Recursively walk the AST. For each statement: Typecheck any subexpressions it contains. Report errors if no type can be assigned. Report errors if the wrong type is assigned. Typecheck child statements. Check the overall correctness.
34 Practical Concerns
35 Something is Very Wrong Here int x, y, z; if (((x == y) > 5 && x + y < z) x == z) { /* */
36 Something is Very Wrong Here int x, y, z; if (((x == y) > 5 && x + y < z) x == z) { /* */
37 Something is Very Wrong Here int x, y, z; if (((x == y) > 5 && x + y < z) x == z) { /* */
38 Something is Very Wrong Here int x, y, z; if (((x == y) > 5 && x + y < z) x == z) { /* */ Facts
39 Something is Very Wrong Here int x, y, z; if (((x == y) > 5 && x + y < z) x == z) { /* */ Facts
40 Something is Very Wrong Here int x, y, z; if (((x == y) > 5 && x + y < z) x == z) { /* */ Facts x is an identifier. x is a variable in scope S with type T. S x : T
41 Something is Very Wrong Here int x, y, z; if (((x == y) > 5 && x + y < z) x == z) { /* */ x is an identifier. x is a variable in scope S with type T. S x : T Facts S x : int
42 Something is Very Wrong Here int x, y, z; if (((x == y) > 5 && x + y < z) x == z) { /* */ x is an identifier. x is a variable in scope S with type T. S x : T Facts S x : int
43 Something is Very Wrong Here int x, y, z; if (((x == y) > 5 && x + y < z) x == z) { /* */ x is an identifier. x is a variable in scope S with type T. Facts S x : int S y : int S z : int S x : T
44 Something is Very Wrong Here int x, y, z; if (((x == y) > 5 && x + y < z) x == z) { /* */ x is an identifier. x is a variable in scope S with type T. Facts S x : int S y : int S z : int S x : T
45 Something is Very Wrong Here int x, y, z; if (((x == y) > 5 && x + y < z) x == z) { /* */ S e 1 : T 1 S e 2 : T 2 T 1 T 2 or T 2 T 1 Facts S x : int S y : int S z : int S e 1 == e 2 : bool
46 Something is Very Wrong Here int x, y, z; if (((x == y) > 5 && x + y < z) x == z) { /* */ S e 1 : T 1 S e 2 : T 2 T 1 T 2 or T 2 T 1 S e 1 == e 2 : bool Facts S x : int S y : int S z : int S x == y : bool
47 Something is Very Wrong Here int x, y, z; if (((x == y) > 5 && x + y < z) x == z) { /* */ S e 1 : T 1 S e 2 : T 2 T 1 T 2 or T 2 T 1 S e 1 == e 2 : bool Facts S x : int S y : int S z : int S x == y : bool
48 Something is Very Wrong Here int x, y, z; if (((x == y) > 5 && x + y < z) x == z) { /* */ i is an integer constant S i : int Facts S x : int S y : int S z : int S x == y : bool
49 Something is Very Wrong Here int x, y, z; if (((x == y) > 5 && x + y < z) x == z) { /* */ i is an integer constant S i : int Facts S x : int S y : int S z : int S x == y : bool S 5 : int
50 Something is Very Wrong Here int x, y, z; if (((x == y) > 5 && x + y < z) x == z) { /* */ i is an integer constant S i : int Facts S x : int S y : int S z : int S x == y : bool S 5 : int
51 Something is Very Wrong Here int x, y, z; if (((x == y) > 5 && x + y < z) x == z) { /* */ S e 1 : int S e 2 : int S e 1 + e 2 : int Facts S x : int S y : int S z : int S x == y : bool S 5 : int
52 Something is Very Wrong Here int x, y, z; if (((x == y) > 5 && x + y < z) x == z) { /* */ S e 1 : int S e 2 : int S e 1 + e 2 : int Facts S x : int S y : int S z : int S x == y : bool S 5 : int S x + y : int
53 Something is Very Wrong Here int x, y, z; if (((x == y) > 5 && x + y < z) x == z) { /* */ S e 1 : int S e 2 : int S e 1 + e 2 : int Facts S x : int S y : int S z : int S x == y : bool S 5 : int S x + y : int
54 Something is Very Wrong Here int x, y, z; if (((x == y) > 5 && x + y < z) x == z) { /* */ S e 1 : int S e 2 : int S e 1 < e 2 : bool Facts S x : int S y : int S z : int S x == y : bool S 5 : int S x + y : int
55 Something is Very Wrong Here int x, y, z; if (((x == y) > 5 && x + y < z) x == z) { /* */ S e 1 : int S e 2 : int S e 1 < e 2 : bool Facts S x : int S y : int S z : int S x == y : bool S 5 : int S x + y : int S x + y < z : bool
56 Something is Very Wrong Here int x, y, z; if (((x == y) > 5 && x + y < z) x == z) { /* */ S e 1 : int S e 2 : int S e 1 < e 2 : bool Facts S x : int S y : int S z : int S x == y : bool S 5 : int S x + y : int S x + y < z : bool
57 Something is Very Wrong Here int x, y, z; if (((x == y) > 5 && x + y < z) x == z) { /* */ S e 1 : T 1 S e 2 : T 2 T 1 T 2 or T 2 T 1 S e 1 == e 2 : bool Facts S x : int S y : int S z : int S x == y : bool S 5 : int S x + y : int S x + y < z : bool
58 Something is Very Wrong Here int x, y, z; if (((x == y) > 5 && x + y < z) x == z) { /* */ S e 1 : T 1 S e 2 : T 2 T 1 T 2 or T 2 T 1 S e 1 == e 2 : bool Facts S x : int S y : int S z : int S x == y : bool S 5 : int S x + y : int S x + y < z : bool S x == z : bool
59 Something is Very Wrong Here int x, y, z; if (((x == y) > 5 && x + y < z) x == z) { /* */ S e 1 : T 1 S e 2 : T 2 T 1 T 2 or T 2 T 1 S e 1 == e 2 : bool Facts S x : int S y : int S z : int S x == y : bool S 5 : int S x + y : int S x + y < z : bool S x == z : bool
60 Something is Very Wrong Here int x, y, z; if (((x == y) > 5 && x + y < z) x == z) { /* */ S e 1 : int S e 2 : int S e 1 > e 2 : bool Facts S x : int S y : int S z : int S x == y : bool S 5 : int S x + y : int S x + y < z : bool S x == z : bool
61 Something is Very Wrong Here int x, y, z; if (((x == y) > 5 && x + y < z) x == z) { /* */ > S e 1 : int S e 2 : int S e 1 > e 2 : bool Facts S x : int S y : int S z : int S x == y : bool S 5 : int S x + y : int S x + y < z : bool S x == z : bool
62 Something is Very Wrong Here int x, y, z; if (((x == y) > 5 && x + y < z) x == z) { /* */ S e 1 : int S e 2 : int S e 1 > e 2 : bool > Error: Cannot compare int and bool Facts S x : int S y : int S z : int S x == y : bool S 5 : int S x + y : int S x + y < z : bool S x == z : bool
63 Something is Very Wrong Here int x, y, z; if (((x == y) > 5 && x + y < z) x == z) { /* */ S e 1 : int S e 2 : int S e 1 > e 2 : bool > Error: Cannot compare int and bool Facts S x : int S y : int S z : int S x == y : bool S 5 : int S x + y : int S x + y < z : bool S x == z : bool
64 Something is Very Wrong Here int x, y, z; if (((x == y) > 5 && x + y < z) x == z) { /* */ S e 1 : bool S e 2 : bool S e 1 && e 2 : bool > Error: Cannot compare int and bool Facts S x : int S y : int S z : int S x == y : bool S 5 : int S x + y : int S x + y < z : bool S x == z : bool
65 Something is Very Wrong Here int x, y, z; if (((x == y) > 5 && x + y < z) x == z) { /* */ S e 1 : bool S e 2 : bool S e 1 && e 2 : bool > Error: Cannot compare int and bool Error: Cannot compare??? and bool Facts S x : int S y : int S z : int S x == y : bool S 5 : int S x + y : int S x + y < z : bool S x == z : bool
66 Something is Very Wrong Here int x, y, z; if (((x == y) > 5 && x + y < z) x == z) { /* */ S e 1 : bool S e 2 : bool S e 1 && e 2 : bool > Error: Cannot compare int and bool Error: Cannot compare??? and bool Facts S x : int S y : int S z : int S x == y : bool S 5 : int S x + y : int S x + y < z : bool S x == z : bool
67 Something is Very Wrong Here int x, y, z; if (((x == y) > 5 && x + y < z) x == z) { /* */ S e 1 : bool S e 2 : bool S e 1 e 2 : bool > Error: Cannot compare int and bool Error: Cannot compare??? and bool Facts S x : int S y : int S z : int S x == y : bool S 5 : int S x + y : int S x + y < z : bool S x == z : bool
68 Something is Very Wrong Here int x, y, z; if (((x == y) > 5 && x + y < z) x == z) { /* */ S e 1 : bool S e 2 : bool S e 1 e 2 : bool > Error: Cannot compare int and bool Error: Cannot compare??? and bool Error: Cannot compare??? and bool Facts S x : int S y : int S z : int S x == y : bool S 5 : int S x + y : int S x + y < z : bool S x == z : bool
69 Cascading Errors A type error occurs when we cannot prove that an expression has a given type. Type errors can easily cascade: Can't prove a type for e 1, so can't prove a type for e 1 +e 2, so can't prove a type for (e 1 +e 2 )+e 3, etc. How do we resolve this?
70 The Shape of Types Vegetable Carrot Artichoke
71 The Shape of Types Vegetable Carrot Artichoke bool string int double Array Types
72 The Shape of Types Vegetable Carrot Artichoke bool string int double Array Types null Type
73 The Shape of Types Vegetable Carrot Artichoke bool string int double Array Types null Type Error Type
74 The Shape of Types Vegetable Carrot Artichoke bool string int double Array Types null Type Error Type
75 The Error Type Introduce a new type representing an error into the type system. The error type is less than all other types and is denoted. It is sometimes called the bottom type. By definition, A for any type A. On discovery of a type error, pretend that we can prove the expression has type. Update our inference rules to support.
76 Updated Rules for Addition S e 1 : double 1 S e 2 : double 2 T 1 double T 2 double S e 1 + e 2 : double
77 Updated Rules for Addition S e 1 : T 1 S e 2 : T 2 T 1 double T 2 double S e 1 + e 2 : double
78 Updated Rules for Addition S e 1 : T 1 S e 2 : T 2 T 1 double T 2 double S e 1 + e 2 : double
79 Updated Rules for Addition S e 1 : T 1 S e 2 : T 2 T 1 double T 2 double S e 1 + e 2 : double What does this mean?
80 Updated Rules for Addition S e 1 : T 1 S e 2 : T 2 T 1 double T 2 double S e 1 + e 2 : double S e 1 : T 1 S e 2 : T 2 T 1 int T 2 int S e 1 + e 2 : int
81 Updated Rules for Addition S e 1 : T 1 S e 2 : T 2 T 1 double T 2 double S e 1 + e 2 : double S e 1 : T 1 S e 2 : T 2 T 1 int T 2 int S e 1 + e 2 : int Prevents errors from propagating.
82 Updated Rules for Addition S e 1 : T 1 S e 2 : T 2 T 1 double T 2 double S e 1 + e 2 : double S e 1 : T 1 S e 2 : T 2 T 1 int T 2 int S e 1 + e 2 : int
83 Updated Rules for Addition S e 1 : T 1 S e 2 : T 2 T 1 double T 2 double S e 1 + e 2 : double S e 1 : T 1 S e 2 : T 2 T 1 int T 2 int S e 1 + e 2 : int What happens if both operands have error type?
84 Error-Recovery in Practice In your semantic analyzer, you will need to do some sort of error recovery. We provide an error type Type::errorType. But what about other cases? Calling a nonexistent function. Declaring a variable of a bad type. Treating a non-array as an array. There are no right answers to these questions; just better and worse choices.
85 Implementing Convertibility How do we implement the operator we've described so far? Lots of cases: From Class Type Primitive Type To Array Type Class Type If same or inherits from No No Primitive Type Array Type Null Type Error Type No No No No If same type No No No No If underlying types match No No Null Type Error Type Yes No No Yes No Yes Yes Yes Yes Yes
86 A Hierarchy for Types Type Class Type Primitive Type Array Type Null Type Error Type
87 Methods You Might Want... virtual bool Type::IsIdenticalTo(Type* other); Returns whether two types represent the same actual type. virtual bool Type::IsConvertibleTo(Type* other); Returns whether one type is convertible to some other type.
88 Type-Checking in the Real World
89 Function Overloading
90 Function Overloading Two functions are said to be overloads of one another if they have the same name but a different set of arguments. At compile-time, determine which function is meant by inspecting the types of the arguments. Report an error if no one function is the best function.
91 Overloading Example void Function(); void Function(int x); void Function(double x); void Function(Base b); void Function(Derived d); Function(); Function(137); Function(42.0); Function(new Base); Function(new Derived);
92 Overloading Example void Function(); void Function(int x); void Function(double x); void Function(Base b); void Function(Derived d); Function(); Function(137); Function(42.0); Function(new Base); Function(new Derived);
93 Implementing Overloading void Function(); void Function(int x); void Function(double x); void Function(Base b); void Function(Derived d);
94 Implementing Overloading void Function(); void Function(int x); void Function(double x); void Function(Base b); void Function(Derived d); Function(137);
95 Implementing Overloading void Function(); void Function(int x); void Function(double x); void Function(Base b); void Function(Derived d); () (int x) (double x) (Base b) (Derived d) Function(137);
96 Implementing Overloading void Function(); void Function(int x); void Function(double x); void Function(Base b); void Function(Derived d); () (int x) (double x) (Base b) (Derived d) Function(137);
97 Implementing Overloading void Function(); void Function(int x); void Function(double x); void Function(Base b); void Function(Derived d); () (int x) (double x) (Base b) (Derived d) Function(137);
98 Implementing Overloading void Function(); void Function(int x); void Function(double x); void Function(Base b); void Function(Derived d); () (int x) (double x) (Base b) (Derived d) Function(137);
99 Implementing Overloading void Function(); void Function(int x); void Function(double x); void Function(Base b); void Function(Derived d); () (int x) (double x) (Base b) (Derived d) Function(137);
100 Implementing Overloading void Function(); void Function(int x); void Function(double x); void Function(Base b); void Function(Derived d); () (int x) (double x) (Base b) (Derived d) Function(137);
101 Implementing Overloading void Function(); void Function(int x); void Function(double x); void Function(Base b); void Function(Derived d); () (int x) (double x) (Base b) (Derived d) Function(137);
102 Simple Overloading We begin with a set of overloaded functions. After filtering out functions that cannot match, we have a candidate set (C++ terminology) or set of potentially applicable methods (Javaspeak). If no functions are left, report an error. If exactly one function left, choose it. (We'll deal with two or more in a second)
103 Overloading with Inheritance void Function(); void Function(int x); void Function(double x); void Function(Base b); void Function(Derived d);
104 Overloading with Inheritance void Function(); void Function(int x); void Function(double x); void Function(Base b); void Function(Derived d); Function(new Derived);
105 Overloading with Inheritance void Function(); void Function(int x); void Function(double x); void Function(Base b); void Function(Derived d); () (int x) (double x) (Base b) (Derived d) Function(new Derived);
106 Overloading with Inheritance void Function(); void Function(int x); void Function(double x); void Function(Base b); void Function(Derived d); () (int x) (double x) (Base b) (Derived d) Function(new Derived);
107 Overloading with Inheritance void Function(); void Function(int x); void Function(double x); void Function(Base b); void Function(Derived d); How do we compare these? () (int x) (double x) (Base b) (Derived d) Function(new Derived);
108 Finding the Best Match Choose one function over another if it's strictly more specific. Given two candidate functions A and B with argument types A 1, A 2,, A n and B 1, B 2,, B n, we say that A <: B if A i B i for all i, 1 i n. This relation is also a partial order. A candidate function A is the best match if for any candidate function B, A <: B. It's at least as good a match. If there is a best match, we choose that function. Otherwise, the call is ambiguous.
109 Overloading with Inheritance void Function(); void Function(int x); void Function(double x); void Function(Base b); void Function(Derived d); () (int x) (double x) (Base b) (Derived d) Function(new Derived);
110 Overloading with Inheritance void Function(); void Function(int x); void Function(double x); void Function(Base b); void Function(Derived d); () (int x) (double x) (Base b) (Derived d) Function(new Derived);
111 Overloading with Inheritance void Function(); void Function(int x); void Function(double x); void Function(Base b); void Function(Derived d); () (int x) (double x) (Base b) (Derived d) Function(new Derived);
112 Ambiguous Calls void Function(Base b1, Base b2); void Function(Derived d1, Base b2); void Function(Base b1, Derived d2);
113 Ambiguous Calls void Function(Base b1, Base b2); void Function(Derived d1, Base b2); void Function(Base b1, Derived d2); Function(new Derived, new Derived);
114 Ambiguous Calls void Function(Base b1, Base b2); void Function(Derived d1, Base b2); void Function(Base b1, Derived d2); Base, Base Base, Derived Derived, Base Function(new Derived, new Derived);
115 Ambiguous Calls void Function(Base b1, Base b2); void Function(Derived d1, Base b2); void Function(Base b1, Derived d2); Base, Base Base, Derived Derived, Base Function(new Derived, new Derived);
116
117 In the Real World Often much more complex than this. Example: variadic functions Functions that can take multiple arguments. Supported by C, C++, and Java.
118 Overloading with Variadic Functions void Function(Base b1, Base b2); void Function(Derived d1, Base b2); void Function(Derived d1,...);
119 Overloading with Variadic Functions void Function(Base b1, Base b2); void Function(Derived d1, Base b2); void Function(Derived d1,...); Function(new Derived, new Derived);
120 Overloading with Variadic Functions void Function(Base b1, Base b2); void Function(Derived d1, Base b2); void Function(Derived d1,...); Base, Base Derived, Base Derived, Function(new Derived, new Derived);
121 Overloading with Variadic Functions void Function(Base b1, Base b2); void Function(Derived d1, Base b2); void Function(Derived d1,...); Base, Base Derived, Base Derived, Function(new Derived, new Derived);
122 Overloading with Variadic Functions Option one: Consider the call ambiguous. There are indeed multiple valid function calls, and that's that! Option two: Prefer the non-variadic function. A function specifically designed to handle a set of arguments is probably a better match than one designed to handle arbitrarily many parameters. Used in both C++ and (with minor modifications) Java.
123 Hierarchical Function Overloads Idea: Have a hierarchy of candidate functions. Conceptually similar to a scope chain: Start with the lowest hierarchy level and look for an overload. If a match is found, choose it. If multiple functions match, report an ambiguous call. If no match is found, go to the next level in the chain. Can you think of another example where we would use a hierarchy like this?
124 Overloading with Variadic Functions void Function(Base b1, Base b2); void Function(Derived d1, Base b2); void Function(Derived d1,...); Base, Base Derived, Base Derived, Function(new Derived, new Derived);
125 Overloading with Variadic Functions void Function(Base b1, Base b2); void Function(Derived d1, Base b2); void Function(Derived d1,...); Derived, Base, Base Derived, Base Function(new Derived, new Derived);
126 Overloading with Variadic Functions void Function(Base b1, Base b2); void Function(Derived d1, Base b2); void Function(Derived d1,...); Derived, Base, Base Derived, Base Function(new Derived, new Derived);
127 Overloading with Variadic Functions void Function(Base b1, Base b2); void Function(Derived d1, Base b2); void Function(Derived d1,...); Derived, Base, Base Derived, Base Function(new Derived, new Derived);
128 Overloading with Variadic Functions void Function(Base b1, Base b2); void Function(Derived d1, Base b2); void Function(Derived d1,...); Derived, Base, Base Derived, Base Function(new Derived, new Derived);
129 Overloading with Variadic Functions void Function(Base b1, Base b2); void Function(Derived d1, Base b2); void Function(Derived d1,...); Derived, Base, Base Derived, Base Function(new Derived, new Derived);
130 Covariance and Contravariance
131 A Rule for Member Functions f is an identifier. S e 0 : M f is a member function in class M. f has type (T 1,, T n ) U S e i : R i for 1 i n R i T i for 1 i n S e 0.f(e 1,..., e n ) :?
132 A Rule for Member Functions f is an identifier. S e 0 : M f is a member function in class M. f has type (T 1,, T n ) U S e i : R i for 1 i n R i T i for 1 i n S e 0.f(e 1,..., e n ) :?
133 A Rule for Member Functions f is an identifier. S e 0 : M f is a member function in class M. f has type (T 1,, T n ) U S e i : R i for 1 i n R i T i for 1 i n S e 0.f(e 1,..., e n ) :?
134 A Rule for Member Functions f is an identifier. S e 0 : M f is a member function in class M. f has type (T 1,, T n ) U S e i : R i for 1 i n R i T i for 1 i n S e 0.f(e 1,..., e n ) :?
135 A Rule for Member Functions f is an identifier. S e 0 : M f is a member function in class M. f has type (T 1,, T n ) U S e i : R i for 1 i n R i T i for 1 i n S e 0.f(e 1,..., e n ) :?
136 A Rule for Member Functions f is an identifier. S e 0 : M f is a member function in class M. f has type (T 1,, T n ) U S e i : R i for 1 i n R i T i for 1 i n S e 0.f(e 1,..., e n ) :?
137 A Rule for Member Functions f is an identifier. S e 0 : M f is a member function in class M. f has type (T 1,, T n ) U S e i : R i for 1 i n R i T i for 1 i n S e 0.f(e 1,..., e n ) : U
138 class Id { Id me() { return this; void beselfish() { /* */ class Ego extends Id { void bepractical() { /* */ Legal Code? int main() { (new Ego).me().bePractical();
139 class Id { Id me() { return this; void beselfish() { /* */ class Ego extends Id { void bepractical() { /* */ Legal Code? int main() { (new Ego).me().bePractical();
140 class Id { Id me() { return this; void beselfish() { /* */ class Ego extends Id { void bepractical() { /* */ Legal Code? int main() { (new Ego).me().bePractical(); Ego
141 class Id { Id me() { return this; void beselfish() { /* */ class Ego extends Id { void bepractical() { /* */ Legal Code? int main() { (new Ego).me().bePractical(); Ego
142 Legal Code? class Id { Id me() { return this; void beselfish() { /* */ class Ego extends Id { void bepractical() { /* */ f is an identifier. S e 0 : M f is a member function in class M. f has type (T 1,, T n ) U S e i : R i for 1 i n R i T i for 1 i n S e 0.f(e 1,..., e n ) : U int main() { (new Ego).me().bePractical(); Ego
143 Legal Code? class Id { Id me() { return this; void beselfish() { /* */ class Ego extends Id { void bepractical() { /* */ f is an identifier. S e 0 : M f is a member function in class M. f has type (T 1,, T n ) U S e i : R i for 1 i n R i T i for 1 i n S e 0.f(e 1,..., e n ) : U int main() { (new Ego).me().bePractical(); Ego
144 Legal Code? class Id { Id me() { return this; void beselfish() { /* */ class Ego extends Id { void bepractical() { /* */ f is an identifier. S e 0 : M f is a member function in class M. f has type (T 1,, T n ) U S e i : R i for 1 i n R i T i for 1 i n S e 0.f(e 1,..., e n ) : U int main() { (new Ego).me().bePractical(); Id Ego
145 Legal Code? class Id { Id me() { return this; void beselfish() { /* */ class Ego extends Id { void bepractical() { /* */ f is an identifier. S e 0 : M f is a member function in class M. f has type (T 1,, T n ) U S e i : R i for 1 i n R i T i for 1 i n S e 0.f(e 1,..., e n ) : U int main() { (new Ego).me().bePractical(); Id Ego
146 class Id { Id me() { return this; void beselfish() { /* */ class Ego extends Id { void bepractical() { /* */ Legal Code? int main() { (new Ego).me().bePractical(); Id Ego f is an identifier. S e 0 : M f is a member function in class M. f has type (T 1,, T n ) U S e i : R i for 1 i n R i T i for 1 i n S e 0.f(e 1,..., e n ) : U bepractical is not in Id!
147 Limitations of Static Type Systems Static type systems are often incomplete. There are valid programs that are rejected. Tension between the static and dynamic types of objects. Static type is the type declared in the program source. Dynamic type is the actual type of the object at runtime.
148 Soundness and Completeness Static type systems sometimes reject valid programs because they cannot prove the absence of a type error. A type system like this is called incomplete. Instead, try to prove for every expression that DynamicType(E) StaticType(E) A type system like this is called sound.
149 Building a Good Static Checker It is difficult to build a good static type checker. Easy to have unsound rules. Impossible to accept all valid programs. Goal: make the language as expressive as possible while still making the type-checker sound.
150 Relaxing our Restrictions class Base { Base clone() { return new Base; class Derived extends Base { Base clone() { return new Derived;
151 Relaxing our Restrictions class Base { Base clone() { return new Base; class Derived extends Base { Base clone() { return new Derived;
152 Relaxing our Restrictions class Base { Base clone() { return new Base; class Derived extends Base { Derived clone() { return new Derived;
153 Relaxing our Restrictions class Base { Base clone() { return new Base; class Derived extends Base { Derived clone() { return new Derived; Is this safe?
154 The Intuition Base b = new Base; Derived d = new Derived; Base b2 = b.clone(); Base b3 = d.clone(); Derived d2 = b.clone(); Derived d3 = d.clone(); Base reallyd = new Derived; Base b4 = reallyd.clone(); Derived d4 = reallyd.clone();
155 The Intuition Base b = new Base; Derived d = new Derived; Base b2 = b.clone(); Base b3 = d.clone(); Derived d2 = b.clone(); Derived d3 = d.clone(); Base reallyd = new Derived; Base b4 = reallyd.clone(); Derived d4 = reallyd.clone();
156 The Intuition Base b = new Base; Derived d = new Derived; Base b2 = b.clone(); Base b3 = d.clone(); Derived d2 = b.clone(); Derived d3 = d.clone(); Base reallyd = new Derived; Base b4 = reallyd.clone(); Derived d4 = reallyd.clone();
157 The Intuition Base b = new Base; Derived d = new Derived; Base b2 = b.clone(); Base b3 = d.clone(); Derived d2 = b.clone(); Derived d3 = d.clone(); Base reallyd = new Derived; Base b4 = reallyd.clone(); Derived d4 = reallyd.clone();
158 The Intuition Base b = new Base; Derived d = new Derived; Base b2 = b.clone(); Base b3 = d.clone(); Derived d2 = b.clone(); Derived d3 = d.clone(); Base reallyd = new Derived; Base b4 = reallyd.clone(); Derived d4 = reallyd.clone();
159 The Intuition Base b = new Base; Derived d = new Derived; Base b2 = b.clone(); Base b3 = d.clone(); Derived d2 = b.clone(); Derived d3 = d.clone(); Base reallyd = new Derived; Base b4 = reallyd.clone(); Derived d4 = reallyd.clone();
160 The Intuition Base b = new Base; Derived d = new Derived; Base b2 = b.clone(); Base b3 = d.clone(); Derived d2 = b.clone(); Derived d3 = d.clone(); Base reallyd = new Derived; Base b4 = reallyd.clone(); Derived d4 = reallyd.clone();
161 The Intuition Base b = new Base; Derived d = new Derived; Base b2 = b.clone(); Base b3 = d.clone(); Derived d2 = b.clone(); Derived d3 = d.clone(); Base reallyd = new Derived; Base b4 = reallyd.clone(); Derived d4 = reallyd.clone();
162 The Intuition Base b = new Base; Derived d = new Derived; Base b2 = b.clone(); Base b3 = d.clone(); Derived d2 = b.clone(); Derived d3 = d.clone(); Base reallyd = new Derived; Base b4 = reallyd.clone(); Derived d4 = reallyd.clone();
163 The Intuition Base b = new Base; Derived d = new Derived; Base b2 = b.clone(); Base b3 = d.clone(); Derived d2 = b.clone(); Derived d3 = d.clone(); Base reallyd = new Derived; Base b4 = reallyd.clone(); Derived d4 = reallyd.clone();
164 Is this Safe? f is an identifier. S e 0 : M f is a member function in class M. f has type (T 1,, T n ) U S e i : R i for 1 i n R i T i for 1 i n S e 0.f(e 1,..., e n ) : U
165 Is this Safe? f is an identifier. S e 0 : M f is a member function in class M. f has type (T 1,, T n ) U S e i : R i for 1 i n R i T i for 1 i n This refers to the static type of the function. S e 0.f(e 1,..., e n ) : U
166 Is this Safe? f is an identifier. S e 0 : M f is a member function in class M. f has type (T 1,, T n ) U S e i : R i for 1 i n R i T i for 1 i n S e 0.f(e 1,..., e n ) : U This refers to the static type of the function. f has dynamic type (T 1, T 2,, T n ) V and we know that V U
167 Is this Safe? f is an identifier. S e 0 : M f is a member function in class M. f has type (T 1,, T n ) U S e i : R i for 1 i n R i T i for 1 i n S e 0.f(e 1,..., e n ) : U This refers to the static type of the function. f has dynamic type (T 1, T 2,, T n ) V and we know that V U So the rule is sound!
168 Covariant Return Types Two functions A and B are covariant in their return types if the return type of A is convertible to the return type of B. Many programming language support covariant return types. C++ and Java, for example. Not supported in Decaf. But easy extra credit!
169 Relaxing our Restrictions (Again) class Base { bool equalto(base B) { /* */ class Derived extends Base { bool equalto(base B) { /* */
170 Relaxing our Restrictions (Again) class Base { bool equalto(base B) { /* */ class Derived extends Base { bool equalto(base B) { /* */
171 Relaxing our Restrictions (Again) class Base { bool equalto(base B) { /* */ class Derived extends Base { bool equalto(derived B) { /* */
172 Relaxing our Restrictions (Again) class Base { bool equalto(base B) { /* */ class Derived extends Base { bool equalto(derived D) { /* */
173 Relaxing our Restrictions (Again) class Base { bool equalto(base B) { /* */ class Derived extends Base { bool equalto(derived D) { /* */ Is this safe?
174 Is this Safe? f is an identifier. S e 0 : M f is a member function in class M. f has type (T 1,, T n ) U S e i : R i for 1 i n R i T i for 1 i n S e 0.f(e 1,..., e n ) : U
175 Is this Safe? f is an identifier. S e 0 : M f is a member function in class M. f has type (T 1,, T n ) U S e i : R i for 1 i n R i T i for 1 i n This refers to the static type of the function. S e 0.f(e 1,..., e n ) : U
176 Is this Safe? f is an identifier. S e 0 : M f is a member function in class M. f has type (T 1,, T n ) U S e i : R i for 1 i n R i T i for 1 i n S e 0.f(e 1,..., e n ) : U This refers to the static type of the function. f has dynamic type (V 1, V 2,, V n ) U and we know that V i T i for 1 i n
177 Is this Safe? f is an identifier. S e 0 : M f is a member function in class M. f has type (T 1,, T n ) U S e i : R i for 1 i n R i T i for 1 i n S e 0.f(e 1,..., e n ) : U R i T i for 1 i n V i T i for 1 i n This refers to the static type of the function. f has dynamic type (V 1, V 2,, V n ) U and we know that V i T i for 1 i n
178 Is this Safe? f is an identifier. S e 0 : M f is a member function in class M. f has type (T 1,, T n ) U S e i : R i for 1 i n R i T i for 1 i n S e 0.f(e 1,..., e n ) : U R i T i for 1 i n V i T i for 1 i n This refers to the static type of the function. f has dynamic type (V 1, V 2,, V n ) U and we know that V i T i for 1 i n This doesn't mean that R i V i for 1 i n
179 A Concrete Example
180 A Concrete Example class Fine { void nothingfancy(fine f) { /* do nothing */ class Borken extends Fine { int missingfn() { return 137; void nothingfancy(borken b) { Print(b.missingFn()); int main() { Fine f = new Borken; f.nothingfancy(f);
181 A Concrete Example class Fine { void nothingfancy(fine f) { /* do nothing */ class Borken extends Fine { int missingfn() { return 137; void nothingfancy(borken b) { Print(b.missingFn()); int main() { Fine f = new Borken; f.nothingfancy(f);
182 A Concrete Example class Fine { void nothingfancy(fine f) { /* do nothing */ class Borken extends Fine { int missingfn() { return 137; void nothingfancy(borken b) { Print(b.missingFn()); int main() { Fine f = new Borken; f.nothingfancy(new Fine);
183 A Concrete Example class Fine { void nothingfancy(fine f) { /* do nothing */ class Borken extends Fine { int missingfn() { return 137; void nothingfancy(borken b) { Print(b.missingFn()); int main() { Fine f = new Borken; f.nothingfancy(new Fine);
184 A Concrete Example class Fine { void nothingfancy(fine f) { /* do nothing */ class Borken extends Fine { int missingfn() { return 137; void nothingfancy(borken b) { Print(b.missingFn()); int main() { Fine f = new Borken; f.nothingfancy(new Fine); (That calls this one)
185 A Concrete Example class Fine { void nothingfancy(fine f) { /* do nothing */ class Borken extends Fine { int missingfn() { return 137; void nothingfancy(borken b) { Print(b.missingFn()); int main() { Fine f = new Borken; f.nothingfancy(new Fine); (That calls this one)
186 A Concrete Example class Fine { void nothingfancy(fine f) { /* do nothing */ Problem? class Borken extends Fine { int missingfn() { return 137; void nothingfancy(borken b) { Print(b.missingFn()); int main() { Fine f = new Borken; f.nothingfancy(new Fine); (That calls this one)
187 Covariant Arguments are Unsafe Allowing subclasses to restrict their parameter types is fundamentally unsafe. Calls through base class can send objects of the wrong type down to base classes. This is why Java's Object.equals takes another Object. Some languages got this wrong. Eiffel allows functions to be covariant in their arguments; can cause runtime errors.
188 Contravariant Arguments class Super { class Base extends Super { bool equalto(base B) { /* */ class Derived extends Base { bool equalto(base B) { /* */
189 Contravariant Arguments class Super { class Base extends Super { bool equalto(base B) { /* */ class Derived extends Base { bool equalto(base B) { /* */
190 Contravariant Arguments class Super { class Base extends Super { bool equalto(base B) { /* */ class Derived extends Base { bool equalto(super B) { /* */
191 Contravariant Arguments class Super { class Base extends Super { bool equalto(base B) { /* */ class Derived extends Base { bool equalto(super B) { /* */
192 Contravariant Arguments class Super { class Base extends Super { bool equalto(base B) { /* */ class Derived extends Base { bool equalto(super B) { /* */ Is this safe?
193 Is this Safe? f is an identifier. S e 0 : M f is a member function in class M. f has type (T 1,, T n ) U S e i : R i for 1 i n R i T i for 1 i n S e 0.f(e 1,..., e n ) : U
194 Is this Safe? f is an identifier. S e 0 : M f is a member function in class M. f has type (T 1,, T n ) U S e i : R i for 1 i n R i T i for 1 i n This refers to the static type of the function. S e 0.f(e 1,..., e n ) : U
195 Is this Safe? f is an identifier. S e 0 : M f is a member function in class M. f has type (T 1,, T n ) U S e i : R i for 1 i n R i T i for 1 i n S e 0.f(e 1,..., e n ) : U This refers to the static type of the function. f has dynamic type (V 1, V 2,, V n ) U and we know that T i V i for 1 i n
196 Is this Safe? f is an identifier. S e 0 : M f is a member function in class M. f has type (T 1,, T n ) U S e i : R i for 1 i n R i T i for 1 i n S e 0.f(e 1,..., e n ) : U R i T i for 1 i n T i V i for 1 i n This refers to the static type of the function. f has dynamic type (V 1, V 2,, V n ) U and we know that T i V i for 1 i n
197 Is this Safe? f is an identifier. S e 0 : M f is a member function in class M. f has type (T 1,, T n ) U S e i : R i for 1 i n R i T i for 1 i n S e 0.f(e 1,..., e n ) : U R i T i for 1 i n T i V i for 1 i n so R i V i for 1 i n This refers to the static type of the function. f has dynamic type (V 1, V 2,, V n ) U and we know that T i V i for 1 i n
198 Contravariant Arguments are Safe Intuition: When called through base class, will accept anything the base class already would. Most languages do not support contravariant arguments. Why? Increases the complexity of the compiler and the language specification. Increases the complexity of checking method overrides.
199 Contravariant Overrides class Super { class Duper extends Super { class Base extends Super { bool equalto(base B) { /* */ class Derived extends Base { bool equalto(super B) { /* */ bool equalto(duper B) { /* */
200 Contravariant Overrides class Super { class Duper extends Super { class Base extends Super { bool equalto(base B) { /* */ class Derived extends Base { bool equalto(super B) { /* */ bool equalto(duper B) { /* */ Two overrides? Or an overload and an override?
201 So What? Need to be very careful when introducing language features into a statically-typed language. Easy to design language features; hard to design language features that are type-safe. Type proof system can sometimes help detect these errors in the abstract.
202 Array Polymorphism In some languages like C++ and Java, it is possible to treat arrays of objects polymorphically. class A { ; class B: public A { ; B* barray = new B[137]; A* aarray = barray; class A { ; class B extends A { ; B[] barray = new B[137]; A[] aarray = barray; Is this safe?
203 A Different Approach to Arrays Think of arrays as classes: class ArrayOfA { public A getelement(int index); class ArrayOfB extends ArrayOfA { public B getelement(int index);
204 A Different Approach to Arrays Think of arrays as classes: class ArrayOfA { public A getelement(int index); class ArrayOfB extends ArrayOfA { public B getelement(int index);
205 A Different Approach to Arrays Think of arrays as classes: class ArrayOfA { public A getelement(int index); class ArrayOfB extends ArrayOfA { public B getelement(int index); Is this safe?
206 A Different Approach to Arrays Think of arrays as classes: class ArrayOfA { public A getelement(int index); class ArrayOfB extends ArrayOfA { public B getelement(int index); Is this safe? Yes!
207 A Different Approach to Arrays Think of arrays as classes: class ArrayOfA { public A getelement(int index); public void setelement(int index, A value); class ArrayOfB extends ArrayOfA { public B getelement(int index); public void setelement(int index, B value);
208 A Different Approach to Arrays Think of arrays as classes: class ArrayOfA { public A getelement(int index); public void setelement(int index, A value); class ArrayOfB extends ArrayOfA { public B getelement(int index); public void setelement(int index, B value);
209 A Different Approach to Arrays Think of arrays as classes: class ArrayOfA { public A getelement(int index); public void setelement(int index, A value); class ArrayOfB extends ArrayOfA { public B getelement(int index); public void setelement(int index, B value); Is this safe?
210 A Different Approach to Arrays Think of arrays as classes: class ArrayOfA { public A getelement(int index); public void setelement(int index, A value); class ArrayOfB extends ArrayOfA { public B getelement(int index); public void setelement(int index, B value); Is this safe? No!
211 Problematic Java Code class A { class B extends A { public static void main(string[] args) { A[] arr = new B[137]; arr[0] = new A();
212 Problematic Java Code class A { class B extends A { public static void main(string[] args) { A[] arr = new B[137]; arr[0] = new A();
213 Java's Solution All array writes checked at runtime. Throws ArrayStoreException if the element stored in an array has the wrong type. Pay at runtime for something that could be detected at compile-time. Almost no benefits in practice; array polymorphism is rarely used.
214 Java's Solution All array writes checked at runtime. Throws ArrayStoreException if the element stored in an array has the wrong type. Pay at runtime for something that could be detected at compile-time. Almost no benefits in practice; array polymorphism is rarely used. Please don't add this as an extension to Decaf.
215 Summary We can extend our type proofs to handle wellformedness proofs. The error type is convertible to all other types and helps prevent cascading errors. Overloading is resolved at compile-time and determines which of many functions to call. Overloading ranks functions against one another to determine the best match. Functions can safely be covariant in their return types and contravariant in their argument types. Don't treat arrays polymorphically!
Semantic Analysis Type Checking
Semantic Analysis Type Checking Maryam Siahbani CMPT 379 * Slides are modified version of Schwarz s compiler course at Stanford 4/8/2016 1 Type Checking Type errors arise when operations are performed
Announcements. Written Assignment 2 due today at 5:00PM. Programming Project 2 due Friday at 11:59PM. Please contact us with questions!
Type-Checking Announcements Written Assignment 2 due today at 5:00PM. Programming Project 2 due Friday at 11:59PM. Please contact us with questions! Stop by office hours! Email the staff list! Ask on Piazza!
Lecture Outline. Type systems and their expressiveness. Type Checking in COOL (II) Type checking with SELF_TYPE in COOL
Lecture Outline Type systems and their expressiveness Type Checking in COOL (II) Type checking with SELF_TYPE in COOL Error recovery in semantic analysis Adapted from Lectures by Profs. Alex Aiken and
Object typing and subtypes
CS 242 2012 Object typing and subtypes Reading Chapter 10, section 10.2.3 Chapter 11, sections 11.3.2 and 11.7 Chapter 12, section 12.4 Chapter 13, section 13.3 Subtyping and Inheritance Interface The
1 Lexical Considerations
Massachusetts Institute of Technology Department of Electrical Engineering and Computer Science 6.035, Spring 2013 Handout Decaf Language Thursday, Feb 7 The project for the course is to write a compiler
Type Checking in COOL (II) Lecture 10
Type Checking in COOL (II) Lecture 10 1 Lecture Outline Type systems and their expressiveness Type checking with SELF_TYPE in COOL Error recovery in semantic analysis 2 Expressiveness of Static Type Systems
Review: Object Diagrams for Inheritance. Type Conformance. Inheritance Structures. Car. Vehicle. Truck. Vehicle. conforms to Object
Review: Diagrams for Inheritance - String makemodel - int mileage + (String, int) Class #3: Inheritance & Polymorphism Software Design II (CS 220): M. Allen, 25 Jan. 18 + (String, int) + void
Lexical Considerations
Massachusetts Institute of Technology Department of Electrical Engineering and Computer Science 6.035, Fall 2005 Handout 6 Decaf Language Wednesday, September 7 The project for the course is to write a
Rules and syntax for inheritance. The boring stuff
Rules and syntax for inheritance The boring stuff The compiler adds a call to super() Unless you explicitly call the constructor of the superclass, using super(), the compiler will add such a call for
Operational Semantics. One-Slide Summary. Lecture Outline
Operational Semantics #1 One-Slide Summary Operational semantics are a precise way of specifying how to evaluate a program. A formal semantics tells you what each expression means. Meaning depends on context:
COMP 181. Agenda. Midterm topics. Today: type checking. Purpose of types. Type errors. Type checking
Agenda COMP 181 Type checking October 21, 2009 Next week OOPSLA: Object-oriented Programming Systems Languages and Applications One of the top PL conferences Monday (Oct 26 th ) In-class midterm Review
Passing Out Review Forms
Type Checking #1 Passing Out Review Forms #2 One-Slide Summary A type environment gives types for free variables. You typecheck a let-body with an environment that has been updated to contain the new let-variable.
Scoping rules match identifier uses with identifier definitions. A type is a set of values coupled with a set of operations on those values.
#1 Type Checking Previously, in PL Scoping rules match identifier uses with identifier definitions. A type is a set of values coupled with a set of operations on those values. A type system specifies which
Lecture Outline. Type systems and their expressiveness. Type Checking in COOL (II) Type checking with SELF_TYPE in COOL
Lecture Outline Type systems and their expressiveness Type Checking in COOL (II) Lecture 10 Type checking with SELF_TYPE in COOL Error recovery in semantic analysis Prof. Aiken CS 143 Lecture 10 1 Prof.
Outline. Java Models for variables Types and type checking, type safety Interpretation vs. compilation. Reasoning about code. CSCI 2600 Spring
Java Outline Java Models for variables Types and type checking, type safety Interpretation vs. compilation Reasoning about code CSCI 2600 Spring 2017 2 Java Java is a successor to a number of languages,
SEMANTIC ANALYSIS TYPES AND DECLARATIONS
SEMANTIC ANALYSIS CS 403: Type Checking Stefan D. Bruda Winter 2015 Parsing only verifies that the program consists of tokens arranged in a syntactically valid combination now we move to check whether
2. Reachability in garbage collection is just an approximation of garbage.
symbol tables were on the first exam of this particular year's exam. We did not discuss register allocation in this This exam has questions from previous CISC 471/672. particular year. Not all questions
CS1622. Semantic Analysis. The Compiler So Far. Lecture 15 Semantic Analysis. How to build symbol tables How to use them to find
CS1622 Lecture 15 Semantic Analysis CS 1622 Lecture 15 1 Semantic Analysis How to build symbol tables How to use them to find multiply-declared and undeclared variables. How to perform type checking CS
Lexical Considerations
Massachusetts Institute of Technology Department of Electrical Engineering and Computer Science 6.035, Spring 2010 Handout Decaf Language Tuesday, Feb 2 The project for the course is to write a compiler
1 Shyam sir JAVA Notes
1 Shyam sir JAVA Notes 1. What is the most important feature of Java? Java is a platform independent language. 2. What do you mean by platform independence? Platform independence means that we can write
CSCE 314 Programming Languages. Type System
CSCE 314 Programming Languages Type System Dr. Hyunyoung Lee 1 Names Names refer to different kinds of entities in programs, such as variables, functions, classes, templates, modules,.... Names can be
Implementing objects as in Javascript, Lua, 164 is expensive because object attributes are implemented as hashtable accesses:
Lectures Page 1 L18 Monday, November 23, 2009 10:22 PM Implementing objects as in Javascript, Lua, 164 is expensive because object attributes are implemented as hashtable accesses: x = { f=1 } x.f -->
Static Semantics. Lecture 15. (Notes by P. N. Hilfinger and R. Bodik) 2/29/08 Prof. Hilfinger, CS164 Lecture 15 1
Static Semantics Lecture 15 (Notes by P. N. Hilfinger and R. Bodik) 2/29/08 Prof. Hilfinger, CS164 Lecture 15 1 Current Status Lexical analysis Produces tokens Detects & eliminates illegal tokens Parsing
Pierce Ch. 3, 8, 11, 15. Type Systems
Pierce Ch. 3, 8, 11, 15 Type Systems Goals Define the simple language of expressions A small subset of Lisp, with minor modifications Define the type system of this language Mathematical definition using
Operational Semantics of Cool
Operational Semantics of Cool Key Concepts semantics: the meaning of a program, what does program do? how the code is executed? operational semantics: high level code generation steps of calculating values
What are the characteristics of Object Oriented programming language?
What are the various elements of OOP? Following are the various elements of OOP:- Class:- A class is a collection of data and the various operations that can be performed on that data. Object- This is
Topics Covered Thus Far CMSC 330: Organization of Programming Languages
Topics Covered Thus Far CMSC 330: Organization of Programming Languages Names & Binding, Type Systems Programming languages Ruby Ocaml Lambda calculus Syntax specification Regular expressions Context free
Type Checking. COMP 520: Compiler Design (4 credits) Alexander Krolik MWF 9:30-10:30, TR Bob, from Accounting.
COMP 520 Winter 2018 Type Checking (1) Type Checking COMP 520: Compiler Design (4 credits) Alexander Krolik alexander.krolik@mail.mcgill.ca MWF 9:30-10:30, TR 1080 http://www.cs.mcgill.ca/~cs520/2018/
Compilers. Type checking. Yannis Smaragdakis, U. Athens (original slides by Sam
Compilers Type checking Yannis Smaragdakis, U. Athens (original slides by Sam Guyer@Tufts) Summary of parsing Parsing A solid foundation: context-free grammars A simple parser: LL(1) A more powerful parser:
OOPs Concepts. 1. Data Hiding 2. Encapsulation 3. Abstraction 4. Is-A Relationship 5. Method Signature 6. Polymorphism 7. Constructors 8.
OOPs Concepts 1. Data Hiding 2. Encapsulation 3. Abstraction 4. Is-A Relationship 5. Method Signature 6. Polymorphism 7. Constructors 8. Type Casting Let us discuss them in detail: 1. Data Hiding: Every
Every language has its own scoping rules. For example, what is the scope of variable j in this Java program?
Lexical Binding There are two ways a variable can be used in a program: As a declaration As a "reference" or use of the variable Scheme has two kinds of variable "declarations" -- the bindings of a let-expression
+ Abstract Data Types
Linked Lists Abstract Data Types An Abstract Data Type (ADT) is: a set of values a set of operations Sounds familiar, right? I gave a similar definition for a data structure. Abstract Data Types Abstract
Lecture 7: Type Systems and Symbol Tables. CS 540 George Mason University
Lecture 7: Type Systems and Symbol Tables CS 540 George Mason University Static Analysis Compilers examine code to find semantic problems. Easy: undeclared variables, tag matching Difficult: preventing
Supporting Class / C++ Lecture Notes
Goal Supporting Class / C++ Lecture Notes You started with an understanding of how to write Java programs. This course is about explaining the path from Java to executing programs. We proceeded in a mostly
Week 7. Statically-typed OO languages: C++ Closer look at subtyping
C++ & Subtyping Week 7 Statically-typed OO languages: C++ Closer look at subtyping Why talk about C++? C++ is an OO extension of C Efficiency and flexibility from C OO program organization from Simula
Class, Variable, Constructor, Object, Method Questions
Class, Variable, Constructor, Object, Method Questions http://www.wideskills.com/java-interview-questions/java-classes-andobjects-interview-questions https://www.careerride.com/java-objects-classes-methods.aspx
Super-Classes and sub-classes
Super-Classes and sub-classes Subclasses. Overriding Methods Subclass Constructors Inheritance Hierarchies Polymorphism Casting 1 Subclasses: Often you want to write a class that is a special case of an
Syntax Errors; Static Semantics
Dealing with Syntax Errors Syntax Errors; Static Semantics Lecture 14 (from notes by R. Bodik) One purpose of the parser is to filter out errors that show up in parsing Later stages should not have to
Introduction to Programming Using Java (98-388)
Introduction to Programming Using Java (98-388) Understand Java fundamentals Describe the use of main in a Java application Signature of main, why it is static; how to consume an instance of your own class;
The Decaf language 1
The Decaf language 1 In this course, we will write a compiler for a simple object-oriented programming language called Decaf. Decaf is a strongly-typed, object-oriented language with support for inheritance
Contents. I. Classes, Superclasses, and Subclasses. Topic 04 - Inheritance
Contents Topic 04 - Inheritance I. Classes, Superclasses, and Subclasses - Inheritance Hierarchies Controlling Access to Members (public, no modifier, private, protected) Calling constructors of superclass
An Introduction to Subtyping
An Introduction to Subtyping Type systems are to me the most interesting aspect of modern programming languages. Subtyping is an important notion that is helpful for describing and reasoning about type
Type Systems. Pierce Ch. 3, 8, 11, 15 CSE
Type Systems Pierce Ch. 3, 8, 11, 15 CSE 6341 1 A Simple Language ::= true false if then else 0 succ pred iszero Simple untyped expressions Natural numbers encoded as succ succ
The Decaf Language. 1 Lexical considerations
The Decaf Language In this course, we will write a compiler for a simple object-oriented programming language called Decaf. Decaf is a strongly-typed, object-oriented language with support for inheritance
COP 3330 Final Exam Review
COP 3330 Final Exam Review I. The Basics (Chapters 2, 5, 6) a. comments b. identifiers, reserved words c. white space d. compilers vs. interpreters e. syntax, semantics f. errors i. syntax ii. run-time
Winter Compiler Construction Who. Mailing list and forum
Winter 2006-2007 Compiler Construction 0368-3133 Mooly Sagiv and Roman Manevich School of Computer Science Tel-Aviv University Who Roman Manevich Schreiber Open-space (basement) Tel: 640-5358 rumster@post.tau.ac.il
Outline. More optimizations for our interpreter. Types for objects
Outline More optimizations for our interpreter Types for objects Optimization Eliminate tree walks: object creation, method calls fish initialize get_ grow eat colorfish color set_color get_color pickyfish
CS558 Programming Languages
CS558 Programming Languages Winter 2017 Lecture 7b Andrew Tolmach Portland State University 1994-2017 Values and Types We divide the universe of values according to types A type is a set of values and
IR Optimization. May 15th, Tuesday, May 14, 13
IR Optimization May 15th, 2013 Tuesday, May 14, 13 But before we talk about IR optimization... Wrapping up IR generation Tuesday, May 14, 13 Three-Address Code Or TAC The IR that you will be using for
The pre-processor (cpp for C-Pre-Processor). Treats all # s. 2 The compiler itself (cc1) this one reads text without any #include s
Session 2 - Classes in C++ Dr Christos Kloukinas City, UoL http://staff.city.ac.uk/c.kloukinas/cpp (slides originally produced by Dr Ross Paterson) A C++ source file may contain: include directives #include
COS 320. Compiling Techniques
Topic 5: Types COS 320 Compiling Techniques Princeton University Spring 2016 Lennart Beringer 1 Types: potential benefits (I) 2 For programmers: help to eliminate common programming mistakes, particularly
Project Compiler. CS031 TA Help Session November 28, 2011
Project Compiler CS031 TA Help Session November 28, 2011 Motivation Generally, it s easier to program in higher-level languages than in assembly. Our goal is to automate the conversion from a higher-level
Memory Safety (cont d) Software Security
Memory Safety (cont d) Software Security CS 161: Computer Security Prof. Raluca Ada Popa January 17, 2016 Some slides credit to David Wagner and Nick Weaver Announcements Discussion sections and office
(Not Quite) Minijava
(Not Quite) Minijava CMCS22620, Spring 2004 April 5, 2004 1 Syntax program mainclass classdecl mainclass class identifier { public static void main ( String [] identifier ) block } classdecl class identifier
Semantic Analysis. Lecture 9. February 7, 2018
Semantic Analysis Lecture 9 February 7, 2018 Midterm 1 Compiler Stages 12 / 14 COOL Programming 10 / 12 Regular Languages 26 / 30 Context-free Languages 17 / 21 Parsing 20 / 23 Extra Credit 4 / 6 Average
CSE 413 Languages & Implementation. Hal Perkins Winter 2019 Structs, Implementing Languages (credits: Dan Grossman, CSE 341)
CSE 413 Languages & Implementation Hal Perkins Winter 2019 Structs, Implementing Languages (credits: Dan Grossman, CSE 341) 1 Goals Representing programs as data Racket structs as a better way to represent
What s Conformance? Conformance. Conformance and Class Invariants Question: Conformance and Overriding
Conformance Conformance and Class Invariants Same or Better Principle Access Conformance Contract Conformance Signature Conformance Co-, Contra- and No-Variance Overloading and Overriding Inheritance as
CSE 341, Spring 2011, Final Examination 9 June Please do not turn the page until everyone is ready.
CSE 341, Spring 2011, Final Examination 9 June 2011 Please do not turn the page until everyone is ready. Rules: The exam is closed-book, closed-note, except for one side of one 8.5x11in piece of paper.
CS 360 Programming Languages Interpreters
CS 360 Programming Languages Interpreters Implementing PLs Most of the course is learning fundamental concepts for using and understanding PLs. Syntax vs. semantics vs. idioms. Powerful constructs like
CSE115 / CSE503 Introduction to Computer Science I Dr. Carl Alphonce 343 Davis Hall Office hours:
CSE115 / CSE503 Introduction to Computer Science I Dr. Carl Alphonce 343 Davis Hall alphonce@buffalo.edu Office hours: Tuesday 10:00 AM 12:00 PM * Wednesday 4:00 PM 5:00 PM Friday 11:00 AM 12:00 PM OR
Comp215: Thinking Generically
Comp215: Thinking Generically Dan S. Wallach (Rice University) Copyright 2015, Dan S. Wallach. All rights reserved. Functional APIs On Wednesday, we built a list of Objects. This works. But it sucks. class
Motivation for typed languages
Motivation for typed languages Untyped Languages: perform any operation on any data. Example: Assembly movi 5 r0 // Move integer 5 (some representation) to r0 addf 3.6 r0 // Treat bit representation in
1 of 5 5/11/2006 12:10 AM CS 61A Spring 2006 Midterm 2 solutions 1. Box and pointer. Note: Please draw actual boxes, as in the book and the lectures, not XX and X/ as in these ASCII-art solutions. Also,
Lecture 3. COMP1006/1406 (the Java course) Summer M. Jason Hinek Carleton University
Lecture 3 COMP1006/1406 (the Java course) Summer 2014 M. Jason Hinek Carleton University today s agenda assignments 1 (graded) & 2 3 (available now) & 4 (tomorrow) a quick look back primitive data types
EECS483 D6: Project 3 Overview
EECS483 D6: Project 3 Overview Chun-Hung Hsiao Feb 15, 2013 Special thanks to Ashutosh 1 Announcement We do have a discussion session on 2/22 (schedule updated) Homework 3 due on the next discussion session
Compilers. Compiler Construction Tutorial The Front-end
Compilers Compiler Construction Tutorial The Front-end Salahaddin University College of Engineering Software Engineering Department 2011-2012 Amanj Sherwany http://www.amanj.me/wiki/doku.php?id=teaching:su:compilers
Inheritance. Inheritance allows the following two changes in derived class: 1. add new members; 2. override existing (in base class) methods.
Inheritance Inheritance is the act of deriving a new class from an existing one. Inheritance allows us to extend the functionality of the object. The new class automatically contains some or all methods
Compilers Project 3: Semantic Analyzer
Compilers Project 3: Semantic Analyzer CSE 40243 Due April 11, 2006 Updated March 14, 2006 Overview Your compiler is halfway done. It now can both recognize individual elements of the language (scan) and
Binghamton University. CS-140 Fall Dynamic Types
Dynamic Types 1 Assignment to a subtype If public Duck extends Bird { Then, you may code:. } Bird bref; Duck quack = new Duck(); bref = quack; A subtype may be assigned where the supertype is expected
Programming Languages. Streams Wrapup, Memoization, Type Systems, and Some Monty Python
Programming Languages Streams Wrapup, Memoization, Type Systems, and Some Monty Python Quick Review of Constructing Streams Usually two ways to construct a stream. Method 1: Use a function that takes a(n)
Types and Static Type Checking (Introducing Micro-Haskell)
Types and Static (Introducing Micro-Haskell) Informatics 2A: Lecture 13 Alex Simpson School of Informatics University of Edinburgh als@inf.ed.ac.uk 16 October, 2012 1 / 21 1 Types 2 3 4 2 / 21 Thus far
(Refer Slide Time: 4:00)
Principles of Programming Languages Dr. S. Arun Kumar Department of Computer Science & Engineering Indian Institute of Technology, Delhi Lecture - 38 Meanings Let us look at abstracts namely functional
CS558 Programming Languages
CS558 Programming Languages Fall 2017 Lecture 7b Andrew Tolmach Portland State University 1994-2017 Type Inference Some statically typed languages, like ML (and to a lesser extent Scala), offer alternative
Harvard School of Engineering and Applied Sciences CS 152: Programming Languages
Harvard School of Engineering and Applied Sciences CS 152: Programming Languages Lecture 14 Tuesday, March 24, 2015 1 Parametric polymorphism Polymorph means many forms. Polymorphism is the ability of
Overriding המחלקה למדעי המחשב עזאם מרעי אוניברסיטת בן-גוריון
Overriding עזאם מרעי המחלקה למדעי המחשב אוניברסיטת בן-גוריון 2 Roadmap A method in a child class overrides a method in the parent class if it has the same name and type signature: Parent void method(int,float)
CSE P 501 Compilers. Implementing ASTs (in Java) Hal Perkins Autumn /20/ Hal Perkins & UW CSE H-1
CSE P 501 Compilers Implementing ASTs (in Java) Hal Perkins Autumn 2009 10/20/2009 2002-09 Hal Perkins & UW CSE H-1 Agenda Representing ASTs as Java objects Parser actions Operations on ASTs Modularity
Lecture 16: Static Semantics Overview 1
Lecture 16: Static Semantics Overview 1 Lexical analysis Produces tokens Detects & eliminates illegal tokens Parsing Produces trees Detects & eliminates ill-formed parse trees Static semantic analysis
Programming in C++ Prof. Partha Pratim Das Department of Computer Science and Engineering Programming in C++ Indian Institute of Technology, Kharagpur
Programming in C++ Prof. Partha Pratim Das Department of Computer Science and Engineering Programming in C++ Indian Institute of Technology, Kharagpur Lecture 14 Default Parameters and Function Overloading
Semantic Analysis and Type Checking
Semantic Analysis and Type Checking The compilation process is driven by the syntactic structure of the program as discovered by the parser Semantic routines: interpret meaning of the program based on
Announcements. My office hours are today in Gates 160 from 1PM-3PM. Programming Project 3 checkpoint due tomorrow night at 11:59PM.
IR Generation Announcements My office hours are today in Gates 160 from 1PM-3PM. Programming Project 3 checkpoint due tomorrow night at 11:59PM. This is a hard deadline and no late submissions will be
Three-Address Code IR
Three-Address Code IR Announcements Programming Project 3 due tonight at 11:59PM. OH today after lecture. Ask questions on Piazzza! Ask questions via email! Programming Project 4 out, due Wednesday, August
Intermediate Code, Object Representation, Type-Based Optimization
CS 301 Spring 2016 Meetings March 14 Intermediate Code, Object Representation, Type-Based Optimization Plan Source Program Lexical Syntax Semantic Intermediate Code Generation Machine- Independent Optimization
Outline. Introduction Concepts and terminology The case for static typing. Implementing a static type system Basic typing relations Adding context
Types 1 / 15 Outline Introduction Concepts and terminology The case for static typing Implementing a static type system Basic typing relations Adding context 2 / 15 Types and type errors Type: a set of
CS412/CS413. Introduction to Compilers Tim Teitelbaum. Lecture 17: Types and Type-Checking 25 Feb 08
CS412/CS413 Introduction to Compilers Tim Teitelbaum Lecture 17: Types and Type-Checking 25 Feb 08 CS 412/413 Spring 2008 Introduction to Compilers 1 What Are Types? Types describe the values possibly
Inheritance and Interfaces
Inheritance and Interfaces Object Orientated Programming in Java Benjamin Kenwright Outline Review What is Inheritance? Why we need Inheritance? Syntax, Formatting,.. What is an Interface? Today s Practical
Late Binding; OOP as a Racket Pattern
Late Binding; OOP as a Racket Pattern Today Dynamic dispatch aka late binding aka virtual method calls Call to self.m2() in method m1 defined in class C can resolve to a method m2 defined in a subclass
CS558 Programming Languages
CS558 Programming Languages Winter 2018 Lecture 7b Andrew Tolmach Portland State University 1994-2018 Dynamic Type Checking Static type checking offers the great advantage of catching errors early And
Operational Semantics of Cool
Operational Semantics of Cool Lecture 22 Dr. Sean Peisert ECS 142 Spring 2009 1 Status Project 3 due on Friday Project 4 assigned on Friday. Due June 5, 11:55pm Office Hours this week are Wed at 4pm and
More Static Semantics. Static. One-Slide Summary. Lecture Outline. Typing Rules. Dispatch Rules SELF_TYPE
More Static Semantics #1 One-Slide Summary Typing rules formalize the semantics checks necessary to validate a program. Well-typed programs do not go wrong. Subtyping relations ( ) and least-upper-bounds
C++ Important Questions with Answers
1. Name the operators that cannot be overloaded. sizeof,.,.*,.->, ::,? 2. What is inheritance? Inheritance is property such that a parent (or super) class passes the characteristics of itself to children
6.001 Notes: Section 15.1
6.001 Notes: Section 15.1 Slide 15.1.1 Our goal over the next few lectures is to build an interpreter, which in a very basic sense is the ultimate in programming, since doing so will allow us to define
CS 321 Homework 4 due 1:30pm, Thursday, March 15, 2012 This homework specification is copyright by Andrew Tolmach. All rights reserved.
CS 321 Homework 4 due 1:30pm, Thursday, March 15, 2012 This homework specification is copyright 2002-2012 by Andrew Tolmach. All rights reserved. Typechecking In this assignment, you will build a type-checker
CS 565: Programming Languages. Spring 2008 Tu, Th: 16:30-17:45 Room LWSN 1106
CS 565: Programming Languages Spring 2008 Tu, Th: 16:30-17:45 Room LWSN 1106 Administrivia Who am I? Course web page http://www.cs.purdue.edu/homes/peugster/cs565spring08/ Office hours By appointment Main
Introduction to Inheritance
Introduction to Inheritance James Brucker These slides cover only the basics of inheritance. What is Inheritance? One class incorporates all the attributes and behavior from another class -- it inherits
Array. Prepared By - Rifat Shahriyar
Java More Details Array 2 Arrays A group of variables containing values that all have the same type Arrays are fixed length entities In Java, arrays are objects, so they are considered reference types
CONTENTS: Arrays Strings. COMP-202 Unit 5: Loops in Practice
CONTENTS: Arrays Strings COMP-202 Unit 5: Loops in Practice Computing the mean of several numbers Suppose we want to write a program which asks the user to enter several numbers and then computes the average
CSC 148 Lecture 3. Dynamic Typing, Scoping, and Namespaces. Recursion
CSC 148 Lecture 3 Dynamic Typing, Scoping, and Namespaces Recursion Announcements Python Ramp Up Session Monday June 1st, 1 5pm. BA3195 This will be a more detailed introduction to the Python language
CSE 401/M501 Compilers
CSE 401/M501 Compilers ASTs, Modularity, and the Visitor Pattern Hal Perkins Autumn 2018 UW CSE 401/M501 Autumn 2018 H-1 Agenda Today: AST operations: modularity and encapsulation Visitor pattern: basic
Fundamentals of Object Oriented Programming
INDIAN INSTITUTE OF TECHNOLOGY ROORKEE Fundamentals of Object Oriented Programming CSN- 103 Dr. R. Balasubramanian Associate Professor Department of Computer Science and Engineering Indian Institute of
Outline for Today. Why could we construct them in time O(n)? Analyzing data structures over the long term.
Amortized Analysis Outline for Today Euler Tour Trees A quick bug fix from last time. Cartesian Trees Revisited Why could we construct them in time O(n)? Amortized Analysis Analyzing data structures over