tunable static inference for generic universe types
play

Tunable Static Inference for Generic Universe Types Werner Dietl - PowerPoint PPT Presentation

Mar 08, 2023 •429 likes •840 views

Tunable Static Inference for Generic Universe Types Werner Dietl Michael Ernst & Peter Mller Generic Universe Types (GUT) Lightweight ownership type system Heap topology Owner-as-Modifier encapsulation discipline Glimpse

  1. Tunable Static Inference for Generic Universe Types Werner Dietl Michael Ernst & Peter Müller

  2. Generic Universe Types (GUT)  Lightweight ownership type system  Heap topology  Owner-as-Modifier encapsulation discipline

  3. Glimpse of Generic Universe Types class List<Y> { List rep Node<Y> head; ... Node } Node class Node<X> { peer Node<X> next; Node ... } 3

  4. Generic Universe Types (GUT)  Lightweight ownership type system  Heap topology  Owner-as-Modifier encapsulation discipline  Large-scale use hampered by annotation effort  All fields, parameters, object creations, … need annotations

  5. Manual annotation effort huge rep AnnotatedTypeMirror lhsBase = lhs; AnnotatedTypeMirror lhsBase = lhs; while (lhsBase.getKind() != rhs.getKind() && (lhsBase.getKind() == TypeKind.WILDCARD || lhsBase.getKind() == while (lhsBase.getKind() != rhs.getKind() TypeKind.TYPEVAR)) { && (lhsBase.getKind() == TypeKind.WILDCARD || lhsBase.getKind() == if (lhsBase.getKind() == TypeKind.WILDCARD && rhs.getKind() != TypeKind.TYPEVAR)) { TypeKind.WILDCARD) { if (lhsBase.getKind() == TypeKind.WILDCARD && rhs.getKind() != AnnotatedWildcardType wildcard = (AnnotatedWildcardType)lhsBase; TypeKind.WILDCARD) { if (lhsBase == null || !lhsBase.isAnnotated()) rep AnnotatedWildcardType wildcard = ( rep return true; visited.add(lhsBase.getElement()); } else if (rhs.getKind() == TypeKind.WILDCARD) { AnnotatedWildcardType)lhsBase; if (lhsBase == null || !lhsBase.isAnnotated()) rhs = ((AnnotatedWildcardType)rhs).getExtendsBound(); return true; } else if (lhsBase.getKind() == TypeKind.TYPEVAR && rhs.getKind() != visited.add(lhsBase.getElement()); TypeKind.TYPEVAR) { } else if (rhs.getKind() == TypeKind.WILDCARD) { AnnotatedTypeVariable lhsb_atv = (AnnotatedTypeVariable)lhsBase; rhs = (( peer AnnotatedWildcardType)rhs).getExtendsBound(); Set<AnnotationMirror> lAnnos = lhsb_atv.getLowerBoundAnnotations(); if (!lAnnos.isEmpty()) return qualifierHierarchy.isSubtype(rhs.getAnnotations(), lAnnos); } else if (lhsBase.getKind() == TypeKind.TYPEVAR && rhs.getKind() != rhs.getAnnotations().contains(qualifierHierarchy.getBottomQualifier()); TypeKind.TYPEVAR) { rep AnnotatedTypeVariable lhsb_atv = ( rep } } AnnotatedTypeVariable)lhsBase; AnnotatedTypeMirror rhsBase = rhs.typeFactory.atypes.asSuper(rhs, rep Set< peer AnnotationMirror> lAnnos = lhsBase); if (!qualifierHierarchy.isSubtype(rhsBase.getAnnotations(), lhsb_atv.getLowerBoundAnnotations(); lhsBase.getAnnotations())) if (!lAnnos.isEmpty()) return false; return qualifierHierarchy.isSubtype(rhs.getAnnotations(), lAnnos); rhs.getAnnotations().contains(qualifierHierarchy.getBottomQualifier()); if (lhs.getKind() == TypeKind.ARRAY && rhsBase.getKind() == } TypeKind.ARRAY) { } rep AnnotatedTypeMirror rhsBase = AnnotatedTypeMirror rhsComponent = ((AnnotatedArrayType)rhsBase).getComponentType(); AnnotatedTypeMirror lhsComponent = rhs.typeFactory.atypes.asSuper(rhs, lhsBase); ((AnnotatedArrayType)lhsBase).getComponentType(); return isSubtypeAsArrayComponent(rhsComponent, lhsComponent); if (lhs.getKind() == TypeKind.ARRAY && rhsBase.getKind() == } else if (lhsBase.getKind() == TypeKind.DECLARED && rhsBase.getKind() TypeKind.ARRAY) { == TypeKind.DECLARED) { peer AnnotatedTypeMirror rhsComponent = (( peer return isSubtypeTypeArguments((AnnotatedDeclaredType)rhsBase, (AnnotatedDeclaredType)lhsBase); AnnotatedArrayType)rhsBase).getComponentType(); } else if (lhsBase.getKind() == TypeKind.TYPEVAR && rhsBase.getKind() == peer AnnotatedTypeMirror lhsComponent = (( peer TypeKind.TYPEVAR) { l AnnotatedTypeMirror rhsSuperClass = rhsBase; while (rhsSuperClass.getKind() == TypeKind.TYPEVAR) { AnnotatedArrayType)lhsBase).getComponentType(); rhsSuperClass = ((AnnotatedTypeVariable) return isSubtypeAsArrayComponent(rhsComponent, lhsComponent); rhsSuperClass).getUpperBound(); } else if (lhsBase.getKind() == TypeKind.DECLARED && rhsBase.getKind() } == TypeKind.DECLARED) { rep AnnotatedTypeMirror rhsBase = Set<AnnotationMirror> las = ((AnnotatedTypeVariable) lhsBase).getLowerBoundAnnotations(); Set<AnnotationMirror> ras = ((AnnotatedTypeVariable) rhs.typeFactory.atypes.asSuper(rhs, lhsBase); rhsBase).getUpperBoundAnnotations(); if (!las.isEmpty()) { return qualifierHierarchy.isSubtype(ras, las);

  6. Automated annotation support rep AnnotatedTypeMirror lhsBase = lhs; AnnotatedTypeMirror lhsBase = lhs; while (lhsBase.getKind() != rhs.getKind() && (lhsBase.getKind() == TypeKind.WILDCARD || lhsBase.getKind() == while (lhsBase.getKind() != rhs.getKind() TypeKind.TYPEVAR)) { && (lhsBase.getKind() == TypeKind.WILDCARD || lhsBase.getKind() == if (lhsBase.getKind() == TypeKind.WILDCARD && rhs.getKind() != TypeKind.TYPEVAR)) { TypeKind.WILDCARD) { if (lhsBase.getKind() == TypeKind.WILDCARD && rhs.getKind() != AnnotatedWildcardType wildcard = (AnnotatedWildcardType)lhsBase; TypeKind.WILDCARD) { if (lhsBase == null || !lhsBase.isAnnotated()) rep AnnotatedWildcardType wildcard = ( rep return true; visited.add(lhsBase.getElement()); } else if (rhs.getKind() == TypeKind.WILDCARD) { AnnotatedWildcardType)lhsBase; if (lhsBase == null || !lhsBase.isAnnotated()) rhs = ((AnnotatedWildcardType)rhs).getExtendsBound(); return true; } else if (lhsBase.getKind() == TypeKind.TYPEVAR && rhs.getKind() != visited.add(lhsBase.getElement()); TypeKind.TYPEVAR) { } else if (rhs.getKind() == TypeKind.WILDCARD) { AnnotatedTypeVariable lhsb_atv = (AnnotatedTypeVariable)lhsBase; rhs = (( peer AnnotatedWildcardType)rhs).getExtendsBound(); Set<AnnotationMirror> lAnnos = lhsb_atv.getLowerBoundAnnotations(); if (!lAnnos.isEmpty()) return qualifierHierarchy.isSubtype(rhs.getAnnotations(), lAnnos); } else if (lhsBase.getKind() == TypeKind.TYPEVAR && rhs.getKind() != rhs.getAnnotations().contains(qualifierHierarchy.getBottomQualifier()); TypeKind.TYPEVAR) { rep AnnotatedTypeVariable lhsb_atv = ( rep } } AnnotatedTypeVariable)lhsBase; AnnotatedTypeMirror rhsBase = rhs.typeFactory.atypes.asSuper(rhs, rep Set< peer AnnotationMirror> lAnnos = lhsBase); if (!qualifierHierarchy.isSubtype(rhsBase.getAnnotations(), lhsb_atv.getLowerBoundAnnotations(); lhsBase.getAnnotations())) if (!lAnnos.isEmpty()) return false; return qualifierHierarchy.isSubtype(rhs.getAnnotations(), lAnnos); rhs.getAnnotations().contains(qualifierHierarchy.getBottomQualifier()); if (lhs.getKind() == TypeKind.ARRAY && rhsBase.getKind() == } TypeKind.ARRAY) { } rep AnnotatedTypeMirror rhsBase = AnnotatedTypeMirror rhsComponent = ((AnnotatedArrayType)rhsBase).getComponentType(); AnnotatedTypeMirror lhsComponent = rhs.typeFactory.atypes.asSuper(rhs, lhsBase); ((AnnotatedArrayType)lhsBase).getComponentType(); return isSubtypeAsArrayComponent(rhsComponent, lhsComponent); if (lhs.getKind() == TypeKind.ARRAY && rhsBase.getKind() == } else if (lhsBase.getKind() == TypeKind.DECLARED && rhsBase.getKind() TypeKind.ARRAY) { == TypeKind.DECLARED) { peer AnnotatedTypeMirror rhsComponent = (( peer return isSubtypeTypeArguments((AnnotatedDeclaredType)rhsBase, (AnnotatedDeclaredType)lhsBase); AnnotatedArrayType)rhsBase).getComponentType(); } else if (lhsBase.getKind() == TypeKind.TYPEVAR && rhsBase.getKind() == peer AnnotatedTypeMirror lhsComponent = (( peer TypeKind.TYPEVAR) { l AnnotatedTypeMirror rhsSuperClass = rhsBase; while (rhsSuperClass.getKind() == TypeKind.TYPEVAR) { AnnotatedArrayType)lhsBase).getComponentType(); rhsSuperClass = ((AnnotatedTypeVariable) return isSubtypeAsArrayComponent(rhsComponent, lhsComponent); rhsSuperClass).getUpperBound(); } else if (lhsBase.getKind() == TypeKind.DECLARED && rhsBase.getKind() } == TypeKind.DECLARED) { rep AnnotatedTypeMirror rhsBase = Set<AnnotationMirror> las = ((AnnotatedTypeVariable) lhsBase).getLowerBoundAnnotations(); Set<AnnotationMirror> ras = ((AnnotatedTypeVariable) rhs.typeFactory.atypes.asSuper(rhs, lhsBase); rhsBase).getUpperBoundAnnotations(); if (!las.isEmpty()) { return qualifierHierarchy.isSubtype(ras, las);

  7. Architecture Max-SAT Solver Solution Generic Universe Types Inference WCNF Formula Constraint AST Constraint Constrs. Solver Variable Generation Interface Introduction Source Code Heuristics Annotations 7

  8. Many solutions exist  Problem is different from usual type inference  Not interested in only a typable solution  We want a good structure 8

  9. Outline  Overview  Tunable Static Inference for GUT  GUT motivation & example  Constraint variable introduction  Constraint generation  Max-SAT encoding  Implementation & Evaluation  Conclusion 9

  10. Intended Structure User List Appl Node Data Node Data Node Data 10

  11. Object Ownership User Iter List Appl Node Data Node Data Node Data 11

  12. Generic Universe Types (GUT) User rep peer Iter List Appl rep rep any Node Data X peer Node Data X peer Node Data X 12

  13. Generic Universe Types (GUT) User rep peer Iter List Appl rep rep any Node Data X peer Node Data X peer Node Data X 13

  14. Generic Universe Types (GUT) User rep peer Iter List Appl rep rep any Node Data X peer Node Data X peer Node Data X 14

  15. Generic Universe Types (GUT) User rep peer Iter List Appl rep rep any Node Data X peer Node Data X peer Node Data X 15

Recommend

1 Definition of a simple generic class Why generic programming (cont.) class Pair &lt;T&gt; {

1 Definition of a simple generic class Why generic programming (cont.) class Pair &lt;T&gt; {

Topics background and goals of generic programming basics of generic classes = parameterized types generic methods for general algorithms inheritance rules for generic types Generic programming in Java bounded type parameters

261 views • 5 slides
! TYPES &amp; STATIC ANALYSIS TYPES ARE GOOD, I PROMISE. SAM GREENWOOD @SAMTGREENWOOD

! TYPES &amp; STATIC ANALYSIS TYPES ARE GOOD, I PROMISE. SAM GREENWOOD @SAMTGREENWOOD

! TYPES &amp; STATIC ANALYSIS TYPES ARE GOOD, I PROMISE. SAM GREENWOOD @SAMTGREENWOOD TECHNOLOGY MANAGER @ UNITI GROUP I LIKE TYPES. WITHOUT TYPES WITH TYPES WHAT ARE TYPES? DYNAMIC TYPES DEFINED WHEN WE USE THEM STATIC TYPES DEFINED

756 views • 40 slides
What are Generics? e.g. Generics, Generic Programming, Generic Types, Generic Methods 6

What are Generics? e.g. Generics, Generic Programming, Generic Types, Generic Methods 6

What are Generics? e.g. Generics, Generic Programming, Generic Types, Generic Methods 6 Defining the idea Behind Java Generics Data Types are now used as Type Parameters 7 Defining the idea Behind Java Generics Generic Types: generic

601 views • 23 slides
Quiz: Types A. What is the static type of: int f(int x, float y) { return x y; } B. What are

Quiz: Types A. What is the static type of: int f(int x, float y) { return x y; } B. What are

Quiz: Types A. What is the static type of: int f(int x, float y) { return x y; } B. What are the values of the static type? C. What are the operations of this type? Oberon Types Rules (Phase I Checks) Numeric types The INTEGER and REAL types

468 views • 12 slides
GENERICS A generic type is a generic class or interface that is parameterized over types. 1 / 6

GENERICS A generic type is a generic class or interface that is parameterized over types. 1 / 6

GENERICS A generic type is a generic class or interface that is parameterized over types. 1 / 6 Weve already seen examples of generic classes ArrayList&lt;T&gt;; HashMap&lt;K, V&gt;; Where T is being used to represent the type of each

304 views • 6 slides
Types Dynamic types Types are broken down into many categories Static types Duck typing

Types Dynamic types Types are broken down into many categories Static types Duck typing

Types Dynamic types Types are broken down into many categories Static types Duck typing Dynamic types Subtypes Types are broken down into many categories Classes and subclasses Static types Strong types Dependent Duck typing

1.22k views • 98 slides
static vs automatic storage classes Three types of memory allocations static storage class

static vs automatic storage classes Three types of memory allocations static storage class

static vs automatic storage classes Three types of memory allocations static storage class means variable persists through static allocation: for globals and any static the life of the program variables in functions automatic storage

569 views • 9 slides
Generic Views on Data Types Problem Towards a solution Generic Views Detour into GH The

Generic Views on Data Types Problem Towards a solution Generic Views Detour into GH The

Introduction Generic Views on Data Types Problem Towards a solution Generic Views Detour into GH The influence of S. Holdermans 1 J. Jeuring 1 oh 2 A. Rodriguez 1 A. L views Formal definition Validity Implementation 1 Department of

677 views • 56 slides
GENERIC CUTS: AN EFFICIENT ALGORITHM FOR OPTIMAL INFERENCE IN HIGHER ORDER MRF-MAP Chetan Arora,

GENERIC CUTS: AN EFFICIENT ALGORITHM FOR OPTIMAL INFERENCE IN HIGHER ORDER MRF-MAP Chetan Arora,

GENERIC CUTS: AN EFFICIENT ALGORITHM FOR OPTIMAL INFERENCE IN HIGHER ORDER MRF-MAP Chetan Arora, Subhashis Banerjee, Prem Kalra, S.N. Maheshwari Indian Institute of Technology Delhi, INDIA MRF-MAP INFERENCE MRF-MAP INFERENCE HIGHER

374 views • 19 slides
A a:INTEGER b:INTEGER B C c:INTEGER D d:INTEGER Figure 1: Class Inheritance Hierarchy 1 2

A a:INTEGER b:INTEGER B C c:INTEGER D d:INTEGER Figure 1: Class Inheritance Hierarchy 1 2

EECS3311 Software Design Fall 2018 Static Types, Expectations, Dynamic Types, and Type Casts Chen-Wei Wang Contents 1 Inheritance Hierarchy 1 2 Static Types (at Compile Time) Define Expected Usages 2 3 Dynamic Types (at Runtime) 2 4

198 views • 5 slides
Tunable Dye Lasers Presented by Mokter Mahmud Chowdhury ID no.:0412062246 1 Tunable Dye

Tunable Dye Lasers Presented by Mokter Mahmud Chowdhury ID no.:0412062246 1 Tunable Dye

Chapter 14 Tunable Dye Lasers Presented by Mokter Mahmud Chowdhury ID no.:0412062246 1 Tunable Dye Lasers: - In a dye laser the active lasing medium is an organic dye dissolved in a solvent such as alcohol. - The major advantage of this

470 views • 13 slides
Generic functional programming Basic idea: define generic functions by induction on the

Generic functional programming Basic idea: define generic functions by induction on the

A Hitchhikers Guide to the Universes (Universes for Generic Programs and Proofs) Marcin Benke Peter Dybjer Patrik Jansson Chalmers Technical University Main goals: extend generic programming to functional languages with dependent types

250 views • 10 slides
Electronically Tunable Terahertz Electronically Tunable Terahertz Detector Using Plasmons

Electronically Tunable Terahertz Electronically Tunable Terahertz Detector Using Plasmons

Electronically Tunable Terahertz Electronically Tunable Terahertz Detector Using Plasmons Plasmons Detector Using Jess Crossno Physics Santa Barbara City College Mentor: Greg Dyer Research Advisor: Dr. Jim Allen Undergraduate Researchers:

1.09k views • 19 slides
CPSC 213 2.2.3, 2.3, 2.4.1-2.4.3, 2.6 static base types (e.g., int, char) Textbook

CPSC 213 2.2.3, 2.3, 2.4.1-2.4.3, 2.6 static base types (e.g., int, char) Textbook

Reading Examine Java and C Piece by Piece Companion Reading writing and arithmetic on variables CPSC 213 2.2.3, 2.3, 2.4.1-2.4.3, 2.6 static base types (e.g., int, char) Textbook static and dynamic arrays of base types

347 views • 3 slides
Generic Types in Java 4003-232-06 (Winter 2006-2007) Week 5: Generics, (Ch. 21 in Liang) Java

Generic Types in Java 4003-232-06 (Winter 2006-2007) Week 5: Generics, (Ch. 21 in Liang) Java

Computer Science II Generic Types in Java 4003-232-06 (Winter 2006-2007) Week 5: Generics, (Ch. 21 in Liang) Java Collection Framework Richard Zanibbi Rochester Institute of Technology What are Generic Types or Example: Comparable

334 views • 6 slides
Generic classes Declaration Use Annotations 54 Generic classes Declaration add

Generic classes Declaration Use Annotations 54 Generic classes Declaration add

Generic classes Declaration Use Annotations 54 Generic classes Declaration add generic types between angle brackets: public class MyStack &lt; E,F &gt;{ E item; } 55 Generic Classes Use MyStack&lt;Integer&gt; ms= new

273 views • 23 slides
Static verification framework for Go Overview 2 Model checking Behavioural mCRL2 model checker

Static verification framework for Go Overview 2 Model checking Behavioural mCRL2 model checker

Concurrency in Go Behavioural type inference Model checking behavioural types Termination checking Summary Static verification framework for Go Overview 2 Model checking Behavioural mCRL2 model checker Types Transform Check safety and

681 views • 67 slides
Static Assurance with Types Liam OConnor University of Edinburgh LFCS (and UNSW) Term 2 2020

Static Assurance with Types Liam OConnor University of Edinburgh LFCS (and UNSW) Term 2 2020

Static Assurance Phantom Types GADTs Type Families Software System Design and Implementation Static Assurance with Types Liam OConnor University of Edinburgh LFCS (and UNSW) Term 2 2020 1 Static Assurance Phantom Types GADTs Type

1.09k views • 81 slides
Type Checking General properties of type systems Types in programming languages

Type Checking General properties of type systems Types in programming languages

Outline Type Checking General properties of type systems Types in programming languages Notation for type rules Logical rules of inference Common type rules 2 Static Checking Static Checking (Cont.) Refers to

896 views • 10 slides
Boxy types: Inference for higher-rank types and impredicativity Dimitrios Vytiniotis 1 Simon

Boxy types: Inference for higher-rank types and impredicativity Dimitrios Vytiniotis 1 Simon

Boxy types: Inference for higher-rank types and impredicativity Dimitrios Vytiniotis 1 Simon Peyton Jones 2 Stephanie Weirich 1 1 Computer and Information Science Department University of Pennsylvania 2 Microsoft Research Kalvi, October 2005 D

603 views • 36 slides
Types la Milner Benjamin C. Pierce University of Pennsylvania April 2012 Type inference

Types la Milner Benjamin C. Pierce University of Pennsylvania April 2012 Type inference

Types are the leaven of computer programming: they make it digestible. - R. Milner Types la Milner Benjamin C. Pierce University of Pennsylvania April 2012 Type inference Abstract types Types la Milner Types for interaction

637 views • 42 slides
Static Analysis of Haskell Neil Mitchell http://ndmitchell.com Static Analysis is getting

Static Analysis of Haskell Neil Mitchell http://ndmitchell.com Static Analysis is getting

Static Analysis of Haskell Neil Mitchell http://ndmitchell.com Static Analysis is getting insights at compile time Full branch coverage Terminates Doesnt rely on a test suite Types are static analysis. Lets talk about

784 views • 39 slides
Deriving Generic Functions by Example Neil Mitchell www.cs.york.ac.uk/~ndm/derive Generic

Deriving Generic Functions by Example Neil Mitchell www.cs.york.ac.uk/~ndm/derive Generic

Deriving Generic Functions by Example Neil Mitchell www.cs.york.ac.uk/~ndm/derive Generic Functions Operates on many data types Think of equality Comparing two integers, booleans, lists, trees Usually, must give each version

450 views • 28 slides
OOPSLA 2004, Vancouver 1 Introduction: generic types in Java 1.5 The

OOPSLA 2004, Vancouver 1 Introduction: generic types in Java 1.5 The

Alan Donovan, Adam Kieun Matthew Tschantz, Michael Ernst MIT Computer Science &amp; AI Lab OOPSLA 2004, Vancouver 1 Introduction: generic types in Java 1.5

620 views • 37 slides

More recommend